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(..), StgToDo(..),
  10         SimplifierSwitch(..),
  11         SimplifierMode(..),
  12
  13         HscLang(..),
  14         DynFlag(..),    -- needed non-abstractly by DriverFlags
  15         DynFlags(..),
  16
  17         v_Static_hsc_opts,
  18
  19         isStaticHscFlag,
  20
  21         -- Manipulating DynFlags
  22         defaultDynFlags,                -- DynFlags
  23         dopt,                           -- DynFlag -> DynFlags -> Bool
  24         dopt_set, dopt_unset,           -- DynFlags -> DynFlag -> DynFlags
  25         dopt_CoreToDo,                  -- DynFlags -> [CoreToDo]
  26         dopt_StgToDo,                   -- DynFlags -> [StgToDo]
  27         dopt_HscLang,                   -- DynFlags -> HscLang
  28         dopt_OutName,                   -- DynFlags -> String
  29
  30         -- Manipulating the DynFlags state
  31         getDynFlags,                    -- IO DynFlags
  32         setDynFlags,                    -- DynFlags -> IO ()
  33         updDynFlags,                    -- (DynFlags -> DynFlags) -> IO ()
  34         dynFlag,                        -- (DynFlags -> a) -> IO a
  35         setDynFlag, unSetDynFlag,       -- DynFlag -> IO ()
  36         saveDynFlags,                   -- IO ()
  37         restoreDynFlags,                -- IO DynFlags
  38
  39         -- sets of warning opts
  40         standardWarnings,
  41         minusWOpts,
  42         minusWallOpts,
  43
  44         -- Output style options
  45         opt_PprStyle_NoPrags,
  46         opt_PprStyle_RawTypes,
  47         opt_PprUserLength,
  48         opt_PprStyle_Debug,
  49
  50         -- profiling opts
  51         opt_AutoSccsOnAllToplevs,
  52         opt_AutoSccsOnExportedToplevs,
  53         opt_AutoSccsOnIndividualCafs,
  54         opt_AutoSccsOnDicts,
  55         opt_SccProfilingOn,
  56         opt_DoTickyProfiling,
  57
  58         -- language opts
  59         opt_AllStrict,
  60         opt_DictsStrict,
  61         opt_MaxContextReductionDepth,
  62         opt_IrrefutableTuples,
  63         opt_NumbersStrict,
  64         opt_Parallel,
  65         opt_SMP,
  66         opt_NoMonomorphismRestriction,
  67         opt_RuntimeTypes,
  68
  69         -- optimisation opts
  70         opt_NoMethodSharing,
  71         opt_DoSemiTagging,
  72         opt_FoldrBuildOn,
  73         opt_LiberateCaseThreshold,
  74         opt_StgDoLetNoEscapes,
  75         opt_UnfoldCasms,
  76         opt_UsageSPOn,
  77         opt_UnboxStrictFields,
  78         opt_SimplNoPreInlining,
  79         opt_SimplDoEtaReduction,
  80         opt_SimplDoLambdaEtaExpansion,
  81         opt_SimplCaseMerge,
  82         opt_SimplExcessPrecision,
  83         opt_MaxWorkerArgs,
  84
  85         -- Unfolding control
  86         opt_UF_CreationThreshold,
  87         opt_UF_UseThreshold,
  88         opt_UF_FunAppDiscount,
  89         opt_UF_KeenessFactor,
  90         opt_UF_UpdateInPlace,
  91         opt_UF_CheapOp,
  92         opt_UF_DearOp,
  93
  94         -- misc opts
  95         opt_InPackage,
  96         opt_EmitCExternDecls,
  97         opt_EnsureSplittableC,
  98         opt_GranMacros,
  99         opt_HiVersion,
 100         opt_HistorySize,
 101         opt_IgnoreAsserts,
 102         opt_IgnoreIfacePragmas,
 103         opt_NoHiCheck,
 104         opt_OmitBlackHoling,
 105         opt_OmitInterfacePragmas,
 106         opt_NoPruneTyDecls,
 107         opt_NoPruneDecls,
 108         opt_Static,
 109         opt_Unregisterised,
 110         opt_EmitExternalCore
 111     ) where
 112
 113 #include "HsVersions.h"
 114
 115 import GlaExts
 116 import IOExts   ( IORef, readIORef, writeIORef )
 117 import Constants        -- Default values for some flags
 118 import Util
 119 import FastTypes
 120 import Config
 121
 122 import Maybes           ( firstJust )
 123 \end{code}
 124
 125 %************************************************************************
 126 %*                                                                      *
 127 \subsection{Command-line options}
 128 %*                                                                      *
 129 %************************************************************************
 130
 131 The hsc command-line options are split into two categories:
 132
 133   - static flags
 134   - dynamic flags
 135
 136 Static flags are represented by top-level values of type Bool or Int,
 137 for example.  They therefore have the same value throughout the
 138 invocation of hsc.
 139
 140 Dynamic flags are represented by an abstract type, DynFlags, which is
 141 passed into hsc by the compilation manager for every compilation.
 142 Dynamic flags are those that change on a per-compilation basis,
 143 perhaps because they may be present in the OPTIONS pragma at the top
 144 of a module.
 145
 146 Other flag-related blurb:
 147
 148 A list of {\em ToDo}s is things to be done in a particular part of
 149 processing.  A (fictitious) example for the Core-to-Core simplifier
 150 might be: run the simplifier, then run the strictness analyser, then
 151 run the simplifier again (three ``todos'').
 152
 153 There are three ``to-do processing centers'' at the moment.  In the
 154 main loop (\tr{main/Main.lhs}), in the Core-to-Core processing loop
 155 (\tr{simplCore/SimplCore.lhs), and in the STG-to-STG processing loop
 156 (\tr{simplStg/SimplStg.lhs}).
 157
 158 %************************************************************************
 159 %*                                                                      *
 160 \subsection{Datatypes associated with command-line options}
 161 %*                                                                      *
 162 %************************************************************************
 163
 164 \begin{code}
 165 data CoreToDo           -- These are diff core-to-core passes,
 166                         -- which may be invoked in any order,
 167                         -- as many times as you like.
 168
 169   = CoreDoSimplify      -- The core-to-core simplifier.
 170         SimplifierMode
 171         [SimplifierSwitch]
 172                         -- Each run of the simplifier can take a different
 173                         -- set of simplifier-specific flags.
 174   | CoreDoFloatInwards
 175   | CoreDoFloatOutwards Bool    -- True <=> float lambdas to top level
 176   | CoreLiberateCase
 177   | CoreDoPrintCore
 178   | CoreDoStaticArgs
 179   | CoreDoStrictness
 180   | CoreDoWorkerWrapper
 181   | CoreDoSpecialising
 182   | CoreDoSpecConstr
 183   | CoreDoUSPInf
 184   | CoreDoCPResult
 185   | CoreDoGlomBinds
 186   | CoreCSE
 187   | CoreDoRuleCheck Int{-CompilerPhase-} String -- Check for non-application of rules
 188                                                 -- matching this string
 189
 190   | CoreDoNothing        -- useful when building up lists of these things
 191 \end{code}
 192
 193 \begin{code}
 194 data StgToDo
 195   = StgDoMassageForProfiling  -- should be (next to) last
 196   -- There's also setStgVarInfo, but its absolute "lastness"
 197   -- is so critical that it is hardwired in (no flag).
 198   | D_stg_stats
 199 \end{code}
 200
 201 \begin{code}
 202 data SimplifierMode             -- See comments in SimplMonad
 203   = SimplGently
 204   | SimplPhase Int
 205
 206 data SimplifierSwitch
 207   = MaxSimplifierIterations Int
 208   | NoCaseOfCase
 209 \end{code}
 210
 211 %************************************************************************
 212 %*                                                                      *
 213 \subsection{Dynamic command-line options}
 214 %*                                                                      *
 215 %************************************************************************
 216
 217 \begin{code}
 218 data DynFlag
 219
 220    -- debugging flags
 221    = Opt_D_dump_absC
 222    | Opt_D_dump_asm
 223    | Opt_D_dump_cpranal
 224    | Opt_D_dump_deriv
 225    | Opt_D_dump_ds
 226    | Opt_D_dump_flatC
 227    | Opt_D_dump_foreign
 228    | Opt_D_dump_inlinings
 229    | Opt_D_dump_occur_anal
 230    | Opt_D_dump_parsed
 231    | Opt_D_dump_realC
 232    | Opt_D_dump_rn
 233    | Opt_D_dump_simpl
 234    | Opt_D_dump_simpl_iterations
 235    | Opt_D_dump_spec
 236    | Opt_D_dump_sat
 237    | Opt_D_dump_stg
 238    | Opt_D_dump_stranal
 239    | Opt_D_dump_tc
 240    | Opt_D_dump_types
 241    | Opt_D_dump_rules
 242    | Opt_D_dump_usagesp
 243    | Opt_D_dump_cse
 244    | Opt_D_dump_worker_wrapper
 245    | Opt_D_dump_rn_trace
 246    | Opt_D_dump_rn_stats
 247    | Opt_D_dump_stix
 248    | Opt_D_dump_simpl_stats
 249    | Opt_D_dump_tc_trace
 250    | Opt_D_dump_BCOs
 251    | Opt_D_source_stats
 252    | Opt_D_verbose_core2core
 253    | Opt_D_verbose_stg2stg
 254    | Opt_D_dump_hi
 255    | Opt_D_dump_hi_diffs
 256    | Opt_D_dump_minimal_imports
 257    | Opt_DoCoreLinting
 258    | Opt_DoStgLinting
 259    | Opt_DoUSPLinting
 260
 261    | Opt_WarnDuplicateExports
 262    | Opt_WarnHiShadows
 263    | Opt_WarnIncompletePatterns
 264    | Opt_WarnMissingFields
 265    | Opt_WarnMissingMethods
 266    | Opt_WarnMissingSigs
 267    | Opt_WarnNameShadowing
 268    | Opt_WarnOverlappingPatterns
 269    | Opt_WarnSimplePatterns
 270    | Opt_WarnTypeDefaults
 271    | Opt_WarnUnusedBinds
 272    | Opt_WarnUnusedImports
 273    | Opt_WarnUnusedMatches
 274    | Opt_WarnDeprecations
 275    | Opt_WarnMisc
 276
 277    -- language opts
 278    | Opt_AllowOverlappingInstances
 279    | Opt_AllowUndecidableInstances
 280    | Opt_GlasgowExts
 281    | Opt_Generics
 282    | Opt_NoImplicitPrelude
 283
 284    deriving (Eq)
 285
 286 data DynFlags = DynFlags {
 287   coreToDo              :: [CoreToDo],
 288   stgToDo               :: [StgToDo],
 289   hscLang               :: HscLang,
 290   hscOutName            :: String,      -- name of the output file
 291   hscStubHOutName       :: String,      -- name of the .stub_h output file
 292   hscStubCOutName       :: String,      -- name of the .stub_c output file
 293   extCoreName           :: String,      -- name of the .core output file
 294   verbosity             :: Int,         -- verbosity level
 295   cppFlag               :: Bool,        -- preprocess with cpp?
 296   stolen_x86_regs       :: Int,
 297   cmdlineHcIncludes     :: [String],    -- -#includes
 298
 299   -- options for particular phases
 300   opt_L                 :: [String],
 301   opt_P                 :: [String],
 302   opt_c                 :: [String],
 303   opt_a                 :: [String],
 304   opt_m                 :: [String],
 305 #ifdef ILX
 306   opt_I                 :: [String],
 307   opt_i                 :: [String],
 308 #endif
 309
 310   -- hsc dynamic flags
 311   flags                 :: [DynFlag]
 312  }
 313
 314 data HscLang
 315   = HscC
 316   | HscAsm
 317   | HscJava
 318   | HscILX
 319   | HscInterpreted
 320   | HscNothing
 321     deriving (Eq, Show)
 322
 323 defaultDynFlags = DynFlags {
 324   coreToDo = [], stgToDo = [],
 325   hscLang = HscC,
 326   hscOutName = "",
 327   hscStubHOutName = "", hscStubCOutName = "",
 328   extCoreName = "",
 329   verbosity = 0,
 330   cppFlag               = False,
 331   stolen_x86_regs       = 4,
 332   cmdlineHcIncludes     = [],
 333   opt_L                 = [],
 334   opt_P                 = [],
 335   opt_c                 = [],
 336   opt_a                 = [],
 337   opt_m                 = [],
 338 #ifdef ILX
 339   opt_I                 = [],
 340   opt_i                 = [],
 341 #endif
 342   flags = standardWarnings,
 343   }
 344
 345 {-
 346     Verbosity levels:
 347
 348     0   |   print errors & warnings only
 349     1   |   minimal verbosity: print "compiling M ... done." for each module.
 350     2   |   equivalent to -dshow-passes
 351     3   |   equivalent to existing "ghc -v"
 352     4   |   "ghc -v -ddump-most"
 353     5   |   "ghc -v -ddump-all"
 354 -}
 355
 356 dopt :: DynFlag -> DynFlags -> Bool
 357 dopt f dflags  = f `elem` (flags dflags)
 358
 359 dopt_CoreToDo :: DynFlags -> [CoreToDo]
 360 dopt_CoreToDo = coreToDo
 361
 362 dopt_StgToDo :: DynFlags -> [StgToDo]
 363 dopt_StgToDo = stgToDo
 364
 365 dopt_OutName :: DynFlags -> String
 366 dopt_OutName = hscOutName
 367
 368 dopt_HscLang :: DynFlags -> HscLang
 369 dopt_HscLang = hscLang
 370
 371 dopt_set :: DynFlags -> DynFlag -> DynFlags
 372 dopt_set dfs f = dfs{ flags = f : flags dfs }
 373
 374 dopt_unset :: DynFlags -> DynFlag -> DynFlags
 375 dopt_unset dfs f = dfs{ flags = filter (/= f) (flags dfs) }
 376 \end{code}
 377
 378 -----------------------------------------------------------------------------
 379 -- Mess about with the mutable variables holding the dynamic arguments
 380
 381 -- v_InitDynFlags
 382 --      is the "baseline" dynamic flags, initialised from
 383 --      the defaults and command line options, and updated by the
 384 --      ':s' command in GHCi.
 385 --
 386 -- v_DynFlags
 387 --      is the dynamic flags for the current compilation.  It is reset
 388 --      to the value of v_InitDynFlags before each compilation, then
 389 --      updated by reading any OPTIONS pragma in the current module.
 390
 391 \begin{code}
 392 GLOBAL_VAR(v_InitDynFlags, defaultDynFlags, DynFlags)
 393 GLOBAL_VAR(v_DynFlags,     defaultDynFlags, DynFlags)
 394
 395 setDynFlags :: DynFlags -> IO ()
 396 setDynFlags dfs = writeIORef v_DynFlags dfs
 397
 398 saveDynFlags :: IO ()
 399 saveDynFlags = do dfs <- readIORef v_DynFlags
 400                   writeIORef v_InitDynFlags dfs
 401
 402 restoreDynFlags :: IO DynFlags
 403 restoreDynFlags = do dfs <- readIORef v_InitDynFlags
 404                      writeIORef v_DynFlags dfs
 405                      return dfs
 406
 407 getDynFlags :: IO DynFlags
 408 getDynFlags = readIORef v_DynFlags
 409
 410 updDynFlags :: (DynFlags -> DynFlags) -> IO ()
 411 updDynFlags f = do dfs <- readIORef v_DynFlags
 412                    writeIORef v_DynFlags (f dfs)
 413
 414 dynFlag :: (DynFlags -> a) -> IO a
 415 dynFlag f = do dflags <- readIORef v_DynFlags; return (f dflags)
 416
 417 setDynFlag, unSetDynFlag :: DynFlag -> IO ()
 418 setDynFlag f   = updDynFlags (\dfs -> dopt_set dfs f)
 419 unSetDynFlag f = updDynFlags (\dfs -> dopt_unset dfs f)
 420 \end{code}
 421
 422
 423 %************************************************************************
 424 %*                                                                      *
 425 \subsection{Warnings}
 426 %*                                                                      *
 427 %************************************************************************
 428
 429 \begin{code}
 430 standardWarnings
 431     = [ Opt_WarnDeprecations,
 432         Opt_WarnOverlappingPatterns,
 433         Opt_WarnMissingFields,
 434         Opt_WarnMissingMethods,
 435         Opt_WarnDuplicateExports
 436       ]
 437
 438 minusWOpts
 439     = standardWarnings ++
 440       [ Opt_WarnUnusedBinds,
 441         Opt_WarnUnusedMatches,
 442         Opt_WarnUnusedImports,
 443         Opt_WarnIncompletePatterns,
 444         Opt_WarnMisc
 445       ]
 446
 447 minusWallOpts
 448     = minusWOpts ++
 449       [ Opt_WarnTypeDefaults,
 450         Opt_WarnNameShadowing,
 451         Opt_WarnMissingSigs,
 452         Opt_WarnHiShadows
 453       ]
 454 \end{code}
 455
 456 %************************************************************************
 457 %*                                                                      *
 458 \subsection{Classifying command-line options}
 459 %*                                                                      *
 460 %************************************************************************
 461
 462 \begin{code}
 463 -- v_Statis_hsc_opts is here to avoid a circular dependency with
 464 -- main/DriverState.
 465 GLOBAL_VAR(v_Static_hsc_opts, [], [String])
 466
 467 lookUp           :: FAST_STRING -> Bool
 468 lookup_int       :: String -> Maybe Int
 469 lookup_def_int   :: String -> Int -> Int
 470 lookup_def_float :: String -> Float -> Float
 471 lookup_str       :: String -> Maybe String
 472
 473 unpacked_static_opts = unsafePerformIO (readIORef v_Static_hsc_opts)
 474 packed_static_opts   = map _PK_ unpacked_static_opts
 475
 476 lookUp     sw = sw `elem` packed_static_opts
 477
 478 lookup_str sw = firstJust (map (startsWith sw) unpacked_static_opts)
 479
 480 lookup_int sw = case (lookup_str sw) of
 481                   Nothing -> Nothing
 482                   Just xx -> Just (read xx)
 483
 484 lookup_def_int sw def = case (lookup_str sw) of
 485                             Nothing -> def              -- Use default
 486                             Just xx -> read xx
 487
 488 lookup_def_float sw def = case (lookup_str sw) of
 489                             Nothing -> def              -- Use default
 490                             Just xx -> read xx
 491
 492
 493 {-
 494  Putting the compiler options into temporary at-files
 495  may turn out to be necessary later on if we turn hsc into
 496  a pure Win32 application where I think there's a command-line
 497  length limit of 255. unpacked_opts understands the @ option.
 498
 499 unpacked_opts :: [String]
 500 unpacked_opts =
 501   concat $
 502   map (expandAts) $
 503   map _UNPK_ argv  -- NOT ARGV any more: v_Static_hsc_opts
 504   where
 505    expandAts ('@':fname) = words (unsafePerformIO (readFile fname))
 506    expandAts l = [l]
 507 -}
 508 \end{code}
 509
 510 %************************************************************************
 511 %*                                                                      *
 512 \subsection{Static options}
 513 %*                                                                      *
 514 %************************************************************************
 515
 516 \begin{code}
 517 -- debugging opts
 518 opt_PprStyle_NoPrags            = lookUp  SLIT("-dppr-noprags")
 519 opt_PprStyle_Debug              = lookUp  SLIT("-dppr-debug")
 520 opt_PprStyle_RawTypes           = lookUp  SLIT("-dppr-rawtypes")
 521 opt_PprUserLength               = lookup_def_int "-dppr-user-length" 5 --ToDo: give this a name
 522
 523 -- profiling opts
 524 opt_AutoSccsOnAllToplevs        = lookUp  SLIT("-fauto-sccs-on-all-toplevs")
 525 opt_AutoSccsOnExportedToplevs   = lookUp  SLIT("-fauto-sccs-on-exported-toplevs")
 526 opt_AutoSccsOnIndividualCafs    = lookUp  SLIT("-fauto-sccs-on-individual-cafs")
 527 opt_AutoSccsOnDicts             = lookUp  SLIT("-fauto-sccs-on-dicts")
 528 opt_SccProfilingOn              = lookUp  SLIT("-fscc-profiling")
 529 opt_DoTickyProfiling            = lookUp  SLIT("-fticky-ticky")
 530
 531 -- language opts
 532 opt_AllStrict                   = lookUp  SLIT("-fall-strict")
 533 opt_NoMonomorphismRestriction   = lookUp  SLIT("-fno-monomorphism-restriction")
 534 opt_DictsStrict                 = lookUp  SLIT("-fdicts-strict")
 535 opt_IrrefutableTuples           = lookUp  SLIT("-firrefutable-tuples")
 536 opt_MaxContextReductionDepth    = lookup_def_int "-fcontext-stack" mAX_CONTEXT_REDUCTION_DEPTH
 537 opt_NumbersStrict               = lookUp  SLIT("-fnumbers-strict")
 538 opt_Parallel                    = lookUp  SLIT("-fparallel")
 539 opt_SMP                         = lookUp  SLIT("-fsmp")
 540
 541 -- optimisation opts
 542 opt_NoMethodSharing             = lookUp  SLIT("-fno-method-sharing")
 543 opt_DoSemiTagging               = lookUp  SLIT("-fsemi-tagging")
 544 opt_FoldrBuildOn                = lookUp  SLIT("-ffoldr-build-on")
 545 opt_LiberateCaseThreshold       = lookup_def_int "-fliberate-case-threshold" (10::Int)
 546 opt_StgDoLetNoEscapes           = lookUp  SLIT("-flet-no-escape")
 547 opt_UnfoldCasms                 = lookUp  SLIT("-funfold-casms-in-hi-file")
 548 opt_UsageSPOn                   = lookUp  SLIT("-fusagesp-on")
 549 opt_UnboxStrictFields           = lookUp  SLIT("-funbox-strict-fields")
 550 opt_MaxWorkerArgs               = lookup_def_int "-fmax-worker-args" (10::Int)
 551
 552 {-
 553    The optional '-inpackage=P' flag tells what package
 554    we are compiling this module for.
 555    The Prelude, for example is compiled with '-inpackage std'
 556 -}
 557 opt_InPackage                   = case lookup_str "-inpackage=" of
 558                                     Just p  -> _PK_ p
 559                                     Nothing -> SLIT("Main")     -- The package name if none is specified
 560
 561 opt_EmitCExternDecls            = lookUp  SLIT("-femit-extern-decls")
 562 opt_EnsureSplittableC           = lookUp  SLIT("-fglobalise-toplev-names")
 563 opt_GranMacros                  = lookUp  SLIT("-fgransim")
 564 opt_HiVersion                   = read cProjectVersionInt :: Int
 565 opt_HistorySize                 = lookup_def_int "-fhistory-size" 20
 566 opt_IgnoreAsserts               = lookUp  SLIT("-fignore-asserts")
 567 opt_IgnoreIfacePragmas          = lookUp  SLIT("-fignore-interface-pragmas")
 568 opt_NoHiCheck                   = lookUp  SLIT("-fno-hi-version-check")
 569 opt_OmitBlackHoling             = lookUp  SLIT("-dno-black-holing")
 570 opt_OmitInterfacePragmas        = lookUp  SLIT("-fomit-interface-pragmas")
 571 opt_RuntimeTypes                = lookUp  SLIT("-fruntime-types")
 572
 573 -- Simplifier switches
 574 opt_SimplNoPreInlining          = lookUp  SLIT("-fno-pre-inlining")
 575         -- NoPreInlining is there just to see how bad things
 576         -- get if you don't do it!
 577 opt_SimplDoEtaReduction         = lookUp  SLIT("-fdo-eta-reduction")
 578 opt_SimplDoLambdaEtaExpansion   = lookUp  SLIT("-fdo-lambda-eta-expansion")
 579 opt_SimplCaseMerge              = lookUp  SLIT("-fcase-merge")
 580 opt_SimplExcessPrecision        = lookUp  SLIT("-fexcess-precision")
 581
 582 -- Unfolding control
 583 opt_UF_CreationThreshold        = lookup_def_int "-funfolding-creation-threshold"  (45::Int)
 584 opt_UF_UseThreshold             = lookup_def_int "-funfolding-use-threshold"       (8::Int)     -- Discounts can be big
 585 opt_UF_FunAppDiscount           = lookup_def_int "-funfolding-fun-discount"        (6::Int)     -- It's great to inline a fn
 586 opt_UF_KeenessFactor            = lookup_def_float "-funfolding-keeness-factor"    (1.5::Float)
 587 opt_UF_UpdateInPlace            = lookUp  SLIT("-funfolding-update-in-place")
 588
 589 opt_UF_CheapOp  = ( 1 :: Int)   -- Only one instruction; and the args are charged for
 590 opt_UF_DearOp   = ( 4 :: Int)
 591
 592 opt_NoPruneDecls                = lookUp  SLIT("-fno-prune-decls")
 593 opt_NoPruneTyDecls              = lookUp  SLIT("-fno-prune-tydecls")
 594 opt_Static                      = lookUp  SLIT("-static")
 595 opt_Unregisterised              = lookUp  SLIT("-funregisterised")
 596 opt_EmitExternalCore            = lookUp  SLIT("-fext-core")
 597 \end{code}
 598
 599 %************************************************************************
 600 %*                                                                      *
 601 \subsection{List of static hsc flags}
 602 %*                                                                      *
 603 %************************************************************************
 604
 605 \begin{code}
 606 isStaticHscFlag f =
 607   f `elem` [
 608         "fauto-sccs-on-all-toplevs",
 609         "fauto-sccs-on-exported-toplevs",
 610         "fauto-sccs-on-individual-cafs",
 611         "fauto-sccs-on-dicts",
 612         "fscc-profiling",
 613         "fticky-ticky",
 614         "fall-strict",
 615         "fdicts-strict",
 616         "firrefutable-tuples",
 617         "fnumbers-strict",
 618         "fparallel",
 619         "fsmp",
 620         "fsemi-tagging",
 621         "ffoldr-build-on",
 622         "flet-no-escape",
 623         "funfold-casms-in-hi-file",
 624         "fusagesp-on",
 625         "funbox-strict-fields",
 626         "femit-extern-decls",
 627         "fglobalise-toplev-names",
 628         "fgransim",
 629         "fignore-asserts",
 630         "fignore-interface-pragmas",
 631         "fno-hi-version-check",
 632         "dno-black-holing",
 633         "fno-method-sharing",
 634         "fno-monomorphism-restriction",
 635         "fomit-interface-pragmas",
 636         "fruntime-types",
 637         "fno-pre-inlining",
 638         "fdo-eta-reduction",
 639         "fdo-lambda-eta-expansion",
 640         "fcase-merge",
 641         "fexcess-precision",
 642         "funfolding-update-in-place",
 643         "fno-prune-decls",
 644         "fno-prune-tydecls",
 645         "static",
 646         "funregisterised",
 647         "fext-core",
 648         "frule-check"
 649         ]
 650   || any (flip prefixMatch f) [
 651         "fcontext-stack",
 652         "fliberate-case-threshold",
 653         "fmax-worker-args",
 654         "fhistory-size",
 655         "funfolding-creation-threshold",
 656         "funfolding-use-threshold",
 657         "funfolding-fun-discount",
 658         "funfolding-keeness-factor"
 659      ]
 660 \end{code}
 661
 662 %************************************************************************
 663 %*                                                                      *
 664 \subsection{Misc functions for command-line options}
 665 %*                                                                      *
 666 %************************************************************************
 667
 668
 669
 670 \begin{code}
 671 startsWith :: String -> String -> Maybe String
 672 -- startsWith pfx (pfx++rest) = Just rest
 673
 674 startsWith []     str = Just str
 675 startsWith (c:cs) (s:ss)
 676   = if c /= s then Nothing else startsWith cs ss
 677 startsWith  _     []  = Nothing
 678
 679 endsWith  :: String -> String -> Maybe String
 680 endsWith cs ss
 681   = case (startsWith (reverse cs) (reverse ss)) of
 682       Nothing -> Nothing
 683       Just rs -> Just (reverse rs)
 684 \end{code}