Rationalise GhcMode, HscTarget and GhcLink
[ghc.git] / compiler / main / DynFlags.hs
index a5269c0..f10d2f9 100644 (file)
@@ -1,3 +1,5 @@
+
+{-# OPTIONS -fno-warn-missing-fields #-}
 -----------------------------------------------------------------------------
 --
 -- Dynamic flags
@@ -15,7 +17,7 @@ module DynFlags (
        -- Dynamic flags
        DynFlag(..),
        DynFlags(..),
-       HscTarget(..),
+       HscTarget(..), isObjectTarget,
        GhcMode(..), isOneShot,
        GhcLink(..), isNoLink,
        PackageFlag(..),
@@ -38,13 +40,14 @@ module DynFlags (
        getVerbFlag,
        updOptLevel,
        setTmpDir,
+       setPackageName,
        
        -- parsing DynFlags
        parseDynamicFlags,
         allFlags,
 
        -- misc stuff
-       machdepCCOpts, picCCOpts,
+       machdepCCOpts, picCCOpts
   ) where
 
 #include "HsVersions.h"
@@ -63,24 +66,29 @@ import Config
 import CmdLineParser
 import Constants       ( mAX_CONTEXT_REDUCTION_DEPTH )
 import Panic           ( panic, GhcException(..) )
+import UniqFM           ( UniqFM )
 import Util            ( notNull, splitLongestPrefix, normalisePath )
 import Maybes          ( fromJust, orElse )
 import SrcLoc           ( SrcSpan )
+import Outputable
+import {-# SOURCE #-} ErrUtils ( Severity(..), Message, mkLocMessage )
 
-import DATA_IOREF      ( readIORef )
-import EXCEPTION       ( throwDyn )
-import Monad           ( when )
+import Data.IORef      ( readIORef )
+import Control.Exception ( throwDyn )
+import Control.Monad   ( when )
 #ifdef mingw32_TARGET_OS
 import Data.List       ( isPrefixOf )
 #else
 import Util            ( split )
 #endif
 
-import Char            ( isDigit, isUpper )
-import Outputable
+import Data.Char       ( isUpper )
 import System.IO        ( hPutStrLn, stderr )
-import {-# SOURCE #-} ErrUtils ( Severity(..), Message, mkLocMessage )
 
+#ifdef GHCI
+import Breakpoints      ( BkptHandler )
+import Module           ( ModuleName )
+#endif
 -- -----------------------------------------------------------------------------
 -- DynFlags
 
@@ -95,6 +103,7 @@ data DynFlag
    | Opt_D_dump_flatC
    | Opt_D_dump_foreign
    | Opt_D_dump_inlinings
+   | Opt_D_dump_rule_firings
    | Opt_D_dump_occur_anal
    | Opt_D_dump_parsed
    | Opt_D_dump_rn
@@ -118,12 +127,14 @@ data DynFlag
    | Opt_D_dump_splices
    | Opt_D_dump_BCOs
    | Opt_D_dump_vect
+   | Opt_D_dump_hpc
    | Opt_D_source_stats
    | Opt_D_verbose_core2core
    | Opt_D_verbose_stg2stg
    | Opt_D_dump_hi
    | Opt_D_dump_hi_diffs
    | Opt_D_dump_minimal_imports
+   | Opt_D_dump_mod_cycles
    | Opt_D_faststring_stats
    | Opt_DoCoreLinting
    | Opt_DoStgLinting
@@ -147,6 +158,7 @@ data DynFlag
    | Opt_WarnDeprecations
    | Opt_WarnDodgyImports
    | Opt_WarnOrphans
+   | Opt_WarnTabs
 
    -- language opts
    | Opt_AllowOverlappingInstances
@@ -154,21 +166,26 @@ data DynFlag
    | Opt_AllowIncoherentInstances
    | Opt_MonomorphismRestriction
    | Opt_MonoPatBinds
+   | Opt_ExtendedDefaultRules          -- Use GHC's extended rules for defaulting
    | Opt_GlasgowExts
    | Opt_FFI
-   | Opt_PArr                         -- syntactic support for parallel arrays
-   | Opt_Arrows                               -- Arrow-notation syntax
+   | Opt_PArr                          -- Syntactic support for parallel arrays
+   | Opt_Arrows                                -- Arrow-notation syntax
    | Opt_TH
    | Opt_ImplicitParams
    | Opt_Generics
    | Opt_ImplicitPrelude 
    | Opt_ScopedTypeVariables
    | Opt_BangPatterns
+   | Opt_IndexedTypes
+   | Opt_OverloadedStrings
 
    -- optimisation opts
    | Opt_Strictness
    | Opt_FullLaziness
    | Opt_CSE
+   | Opt_LiberateCase
+   | Opt_SpecConstr
    | Opt_IgnoreInterfacePragmas
    | Opt_OmitInterfacePragmas
    | Opt_DoLambdaEtaExpansion
@@ -182,7 +199,7 @@ data DynFlag
    -- misc opts
    | Opt_Cpp
    | Opt_Pp
-   | Opt_RecompChecking
+   | Opt_ForceRecomp
    | Opt_DryRun
    | Opt_DoAsmMangling
    | Opt_ExcessPrecision
@@ -191,6 +208,12 @@ data DynFlag
    | Opt_SplitObjs
    | Opt_StgStats
    | Opt_HideAllPackages
+#if defined(GHCI) && defined(DEBUGGER)
+   | Opt_Debugging
+#endif
+   | Opt_PrintBindResult
+   | Opt_Haddock
+   | Opt_Hpc_No_Auto
 
    -- keeping stuff
    | Opt_KeepHiDiffs
@@ -213,6 +236,9 @@ data DynFlags = DynFlags {
   optLevel             :: Int,         -- optimisation level
   maxSimplIterations    :: Int,                -- max simplifier iterations
   ruleCheck            :: Maybe String,
+
+  specThreshold                :: Int,         -- Threshold for function specialisation
+
   stolen_x86_regs      :: Int,         
   cmdlineHcIncludes    :: [String],    -- -#includes
   importPaths          :: [FilePath],
@@ -245,6 +271,11 @@ data DynFlags = DynFlags {
   cmdlineFrameworks    :: [String],    -- ditto
   tmpDir               :: String,      -- no trailing '/'
   
+  ghcUsagePath          :: FilePath,    -- Filled in by SysTools
+  ghciUsagePath         :: FilePath,    -- ditto
+
+  hpcDir               :: String,      -- ^ path to store the .mix files
+
   -- options for particular phases
   opt_L                        :: [String],
   opt_P                        :: [String],
@@ -266,16 +297,23 @@ data DynFlags = DynFlags {
   pgm_a                        :: (String,[Option]),
   pgm_l                        :: (String,[Option]),
   pgm_dll              :: (String,[Option]),
+  pgm_T                 :: String,
+  pgm_sysman            :: String,
 
-  --  ** Package flags
+  --  Package flags
   extraPkgConfs                :: [FilePath],
+  topDir                :: FilePath,    -- filled in by SysTools
+  systemPackageConfig   :: FilePath,    -- ditto
        -- The -package-conf flags given on the command line, in the order
        -- they appeared.
 
   packageFlags         :: [PackageFlag],
        -- The -package and -hide-package flags from the command-line
 
-  --  ** Package state
+  -- Package state
+  -- NB. do not modify this field, it is calculated by 
+  -- Packages.initPackages and Packages.updatePackages.
+  pkgDatabase           :: Maybe (UniqFM InstalledPackageInfo),
   pkgState             :: PackageState,
 
   -- hsc dynamic flags
@@ -283,35 +321,50 @@ data DynFlags = DynFlags {
   
   -- message output
   log_action            :: Severity -> SrcSpan -> PprStyle -> Message -> IO ()
+
+#ifdef GHCI
+  -- breakpoint handling
+ ,bkptHandler           :: Maybe (BkptHandler Module)
+#endif
  }
 
 data HscTarget
   = HscC
   | HscAsm
   | HscJava
-  | HscILX
   | HscInterpreted
   | HscNothing
   deriving (Eq, Show)
 
+-- | will this target result in an object file on the disk?
+isObjectTarget :: HscTarget -> Bool
+isObjectTarget HscC     = True
+isObjectTarget HscAsm   = True
+isObjectTarget _        = False
+
+-- | The 'GhcMode' tells us whether we're doing multi-module
+-- compilation (controlled via the "GHC" API) or one-shot
+-- (single-module) compilation.  This makes a difference primarily to
+-- the "Finder": in one-shot mode we look for interface files for
+-- imported modules, but in multi-module mode we look for source files
+-- in order to check whether they need to be recompiled.
 data GhcMode
-  = BatchCompile       -- | @ghc --make Main@
-  | Interactive                -- | @ghc --interactive@
-  | OneShot            -- | @ghc -c Foo.hs@
-  | JustTypecheck      -- | Development environemnts, refactorer, etc.
-  | MkDepend
+  = CompManager         -- ^ --make, GHCi, etc.
+  | OneShot            -- ^ ghc -c Foo.hs
+  | MkDepend            -- ^ ghc -M, see Finder for why we need this
   deriving Eq
 
 isOneShot :: GhcMode -> Bool
 isOneShot OneShot = True
 isOneShot _other  = False
 
+-- | What kind of linking to do.
 data GhcLink   -- What to do in the link step, if there is one
-  =            -- Only relevant for modes
-               --      DoMake and StopBefore StopLn
-    NoLink             -- Don't link at all
-  | StaticLink         -- Ordinary linker [the default]
+  = NoLink             -- Don't link at all
+  | LinkBinary         -- Link object code into a binary
+  | LinkInMemory        -- Use the in-memory dynamic linker
   | MkDLL              -- Make a DLL
+  deriving Eq
 
 isNoLink :: GhcLink -> Bool
 isNoLink NoLink = True
@@ -321,6 +374,7 @@ data PackageFlag
   = ExposePackage  String
   | HidePackage    String
   | IgnorePackage  String
+  deriving Eq
 
 defaultHscTarget
   | cGhcWithNativeCodeGen == "YES"     =  HscAsm
@@ -339,8 +393,8 @@ initDynFlags dflags = do
 
 defaultDynFlags =
      DynFlags {
-       ghcMode                 = OneShot,
-       ghcLink                 = StaticLink,
+       ghcMode                 = CompManager,
+       ghcLink                 = LinkBinary,
        coreToDo                = Nothing,
        stgToDo                 = Nothing, 
        hscTarget               = defaultHscTarget, 
@@ -350,6 +404,7 @@ defaultDynFlags =
        optLevel                = 0,
        maxSimplIterations      = 4,
        ruleCheck               = Nothing,
+       specThreshold           = 200,
        stolen_x86_regs         = 4,
        cmdlineHcIncludes       = [],
        importPaths             = ["."],
@@ -358,10 +413,6 @@ defaultDynFlags =
        ctxtStkDepth            = mAX_CONTEXT_REDUCTION_DEPTH,
 
        thisPackage             = mainPackageId,
-       
-       wayNames                = panic "ways",
-       buildTag                = panic "buildTag",
-       rtsBuildTag             = panic "rtsBuildTag",
 
        objectDir               = Nothing,
        hiDir                   = Nothing,
@@ -379,6 +430,8 @@ defaultDynFlags =
        cmdlineFrameworks       = [],
        tmpDir                  = cDEFAULT_TMPDIR,
        
+        hpcDir                 = ".hpc",
+
        opt_L                   = [],
        opt_P                   = [],
        opt_F                   = [],
@@ -389,22 +442,14 @@ defaultDynFlags =
        opt_dll                 = [],
        opt_dep                 = [],
        
-       pgm_L                   = panic "pgm_L",
-       pgm_P                   = panic "pgm_P",
-       pgm_F                   = panic "pgm_F",
-       pgm_c                   = panic "pgm_c",
-       pgm_m                   = panic "pgm_m",
-       pgm_s                   = panic "pgm_s",
-       pgm_a                   = panic "pgm_a",
-       pgm_l                   = panic "pgm_l",
-       pgm_dll                 = panic "pgm_mkdll",
-       
        extraPkgConfs           = [],
        packageFlags            = [],
-       pkgState                = panic "pkgState",
-       
+        pkgDatabase             = Nothing,
+        pkgState                = panic "no package state yet: call GHC.setSessionDynFlags",
+#ifdef GHCI
+        bkptHandler             = Nothing,
+#endif
        flags = [ 
-           Opt_RecompChecking,
            Opt_ReadUserPackageConf,
     
            Opt_MonoPatBinds,   -- Experimentally, I'm making this non-standard
@@ -413,25 +458,14 @@ defaultDynFlags =
 
            Opt_ImplicitPrelude,
            Opt_MonomorphismRestriction,
-           Opt_Strictness,
-                       -- strictness is on by default, but this only
-                       -- applies to -O.
-           Opt_CSE,            -- similarly for CSE.
-           Opt_FullLaziness,   -- ...and for full laziness
-    
-           Opt_DoLambdaEtaExpansion,
-                       -- This one is important for a tiresome reason:
-                       -- we want to make sure that the bindings for data 
-                       -- constructors are eta-expanded.  This is probably
-                       -- a good thing anyway, but it seems fragile.
-    
+
            Opt_DoAsmMangling,
     
-           -- and the default no-optimisation options:
-           Opt_IgnoreInterfacePragmas,
-           Opt_OmitInterfacePragmas
-    
-               ] ++ standardWarnings,
+           -- on by default:
+           Opt_PrintBindResult ]
+           ++ [f | (ns,f) <- optLevelFlags, 0 `elem` ns]
+                   -- The default -O0 options
+           ++ standardWarnings,
                
         log_action = \severity srcSpan style msg -> 
                         case severity of
@@ -528,32 +562,34 @@ data Option
 updOptLevel :: Int -> DynFlags -> DynFlags
 -- Set dynflags appropriate to the optimisation level
 updOptLevel n dfs
-  = if (n >= 1)
-     then dfs2{ hscTarget = HscC, optLevel = n } -- turn on -fvia-C with -O
-     else dfs2{ optLevel = n }
+  = dfs2{ optLevel = n }
   where
    dfs1 = foldr (flip dopt_unset) dfs  remove_dopts
    dfs2 = foldr (flip dopt_set)   dfs1 extra_dopts
 
-   extra_dopts
-       | n == 0    = opt_0_dopts
-       | otherwise = opt_1_dopts
-
-   remove_dopts
-       | n == 0    = opt_1_dopts
-       | otherwise = opt_0_dopts
+   extra_dopts  = [ f | (ns,f) <- optLevelFlags, n `elem` ns ]
+   remove_dopts = [ f | (ns,f) <- optLevelFlags, n `notElem` ns ]
        
-opt_0_dopts =  [ 
-       Opt_IgnoreInterfacePragmas,
-       Opt_OmitInterfacePragmas
+optLevelFlags :: [([Int], DynFlag)]
+optLevelFlags
+  = [ ([0],    Opt_IgnoreInterfacePragmas)
+    , ([0],     Opt_OmitInterfacePragmas)
+    , ([1,2],  Opt_IgnoreAsserts)
+    , ([1,2],  Opt_DoEtaReduction)
+    , ([1,2],  Opt_CaseMerge)
+    , ([1,2],  Opt_Strictness)
+    , ([1,2],  Opt_CSE)
+    , ([1,2],  Opt_FullLaziness)
+    , ([2],    Opt_LiberateCase)
+    , ([2],    Opt_SpecConstr)
+
+    , ([0,1,2], Opt_DoLambdaEtaExpansion)
+               -- This one is important for a tiresome reason:
+               -- we want to make sure that the bindings for data 
+               -- constructors are eta-expanded.  This is probably
+               -- a good thing anyway, but it seems fragile.
     ]
 
-opt_1_dopts = [
-       Opt_IgnoreAsserts,
-       Opt_DoEtaReduction,
-       Opt_CaseMerge
-     ]
-
 -- -----------------------------------------------------------------------------
 -- Standard sets of warning options
 
@@ -609,8 +645,8 @@ data CoreToDo               -- These are diff core-to-core passes,
   | CoreCSE
   | CoreDoRuleCheck Int{-CompilerPhase-} String        -- Check for non-application of rules 
                                                -- matching this string
-
-  | CoreDoNothing       -- useful when building up lists of these things
+  | CoreDoNothing               -- Useful when building up 
+  | CoreDoPasses [CoreToDo]     -- lists of these things
 
 data SimplifierMode            -- See comments in SimplMonad
   = SimplGently
@@ -627,6 +663,9 @@ data FloatOutSwitches
 
 
 -- The core-to-core pass ordering is derived from the DynFlags:
+runWhen :: Bool -> CoreToDo -> CoreToDo
+runWhen True  do_this = do_this
+runWhen False do_this = CoreDoNothing
 
 getCoreToDo :: DynFlags -> [CoreToDo]
 getCoreToDo dflags
@@ -638,6 +677,8 @@ getCoreToDo dflags
     strictness    = dopt Opt_Strictness dflags
     full_laziness = dopt Opt_FullLaziness dflags
     cse           = dopt Opt_CSE dflags
+    spec_constr   = dopt Opt_SpecConstr dflags
+    liberate_case = dopt Opt_LiberateCase dflags
     rule_check    = ruleCheck dflags
 
     core_todo = 
@@ -670,8 +711,7 @@ getCoreToDo dflags
        -- so that overloaded functions have all their dictionary lambdas manifest
        CoreDoSpecialising,
 
-       if full_laziness then CoreDoFloatOutwards (FloatOutSw False False)
-                        else CoreDoNothing,
+       runWhen full_laziness (CoreDoFloatOutwards (FloatOutSw False False)),
 
        CoreDoFloatInwards,
 
@@ -710,20 +750,19 @@ getCoreToDo dflags
        case rule_check of { Just pat -> CoreDoRuleCheck 0 pat; Nothing -> CoreDoNothing },
 
 #ifdef OLD_STRICTNESS
-       CoreDoOldStrictness
+       CoreDoOldStrictness,
 #endif
-       if strictness then CoreDoStrictness else CoreDoNothing,
-       CoreDoWorkerWrapper,
-       CoreDoGlomBinds,
-
-       CoreDoSimplify (SimplPhase 0) [
-          MaxSimplifierIterations max_iter
-       ],
-
-       if full_laziness then
-         CoreDoFloatOutwards (FloatOutSw False   -- Not lambdas
-                                         True)   -- Float constants
-       else CoreDoNothing,
+       runWhen strictness (CoreDoPasses [
+               CoreDoStrictness,
+               CoreDoWorkerWrapper,
+               CoreDoGlomBinds,
+               CoreDoSimplify (SimplPhase 0) [
+                  MaxSimplifierIterations max_iter
+               ]]),
+
+       runWhen full_laziness 
+         (CoreDoFloatOutwards (FloatOutSw False    -- Not lambdas
+                                          True)),  -- Float constants
                -- nofib/spectral/hartel/wang doubles in speed if you
                -- do full laziness late in the day.  It only happens
                -- after fusion and other stuff, so the early pass doesn't
@@ -731,38 +770,29 @@ getCoreToDo dflags
                --        f_el22 (f_el21 r_midblock)
 
 
-       -- We want CSE to follow the final full-laziness pass, because it may
-       -- succeed in commoning up things floated out by full laziness.
-       -- CSE used to rely on the no-shadowing invariant, but it doesn't any more
-
-       if cse then CoreCSE else CoreDoNothing,
+       runWhen cse CoreCSE,
+               -- We want CSE to follow the final full-laziness pass, because it may
+               -- succeed in commoning up things floated out by full laziness.
+               -- CSE used to rely on the no-shadowing invariant, but it doesn't any more
 
        CoreDoFloatInwards,
 
--- Case-liberation for -O2.  This should be after
--- strictness analysis and the simplification which follows it.
-
-       case rule_check of { Just pat -> CoreDoRuleCheck 0 pat; Nothing -> CoreDoNothing }
-     ]
-
-       ++ 
+       case rule_check of { Just pat -> CoreDoRuleCheck 0 pat; Nothing -> CoreDoNothing },
 
-     (if opt_level >= 2 then
-          [  CoreLiberateCase,
-             CoreDoSimplify (SimplPhase 0) [
+               -- Case-liberation for -O2.  This should be after
+               -- strictness analysis and the simplification which follows it.
+       runWhen liberate_case (CoreDoPasses [
+           CoreLiberateCase,
+           CoreDoSimplify (SimplPhase 0) [
                  MaxSimplifierIterations max_iter
-             ],        -- Run the simplifier after LiberateCase to vastly 
+           ] ]),       -- Run the simplifier after LiberateCase to vastly 
                        -- reduce the possiblility of shadowing
                        -- Reason: see Note [Shadowing] in SpecConstr.lhs
-            CoreDoSpecConstr
-          ]
-      else
-          [])
 
-       ++
+       runWhen spec_constr CoreDoSpecConstr,
 
        -- Final clean-up simplification:
-     [ CoreDoSimplify (SimplPhase 0) [
+       CoreDoSimplify (SimplPhase 0) [
          MaxSimplifierIterations max_iter
        ]
      ]
@@ -870,15 +900,17 @@ dynamic_flags = [
        ------- Miscellaneous ----------------------------------------------
   ,  ( "no-hs-main"     , NoArg (setDynFlag Opt_NoHsMain))
   ,  ( "main-is"       , SepArg setMainIs )
+  ,  ( "haddock"       , NoArg (setDynFlag Opt_Haddock) )
+  ,  ( "hpcdir"                , SepArg setOptHpcDir )
 
-       ------- recompilation checker --------------------------------------
-  ,  ( "recomp"                , NoArg (setDynFlag   Opt_RecompChecking) )
-  ,  ( "no-recomp"     , NoArg (unSetDynFlag Opt_RecompChecking) )
+       ------- recompilation checker (DEPRECATED, use -fforce-recomp) -----
+  ,  ( "recomp"                , NoArg (unSetDynFlag Opt_ForceRecomp) )
+  ,  ( "no-recomp"     , NoArg (setDynFlag   Opt_ForceRecomp) )
 
         ------- Packages ----------------------------------------------------
   ,  ( "package-conf"   , HasArg extraPkgConf_ )
   ,  ( "no-user-package-conf", NoArg (unSetDynFlag Opt_ReadUserPackageConf) )
-  ,  ( "package-name"   , HasArg setPackageName )
+  ,  ( "package-name"   , HasArg (upd . setPackageName) )
   ,  ( "package"        , HasArg exposePackage )
   ,  ( "hide-package"   , HasArg hidePackage )
   ,  ( "hide-all-packages", NoArg (setDynFlag Opt_HideAllPackages) )
@@ -904,6 +936,7 @@ dynamic_flags = [
   ,  ( "ddump-flatC",           setDumpFlag Opt_D_dump_flatC)
   ,  ( "ddump-foreign",         setDumpFlag Opt_D_dump_foreign)
   ,  ( "ddump-inlinings",       setDumpFlag Opt_D_dump_inlinings)
+  ,  ( "ddump-rule-firings",            setDumpFlag Opt_D_dump_rule_firings)
   ,  ( "ddump-occur-anal",      setDumpFlag Opt_D_dump_occur_anal)
   ,  ( "ddump-parsed",          setDumpFlag Opt_D_dump_parsed)
   ,  ( "ddump-rn",              setDumpFlag Opt_D_dump_rn)
@@ -918,25 +951,28 @@ dynamic_flags = [
   ,  ( "ddump-rules",           setDumpFlag Opt_D_dump_rules)
   ,  ( "ddump-cse",             setDumpFlag Opt_D_dump_cse)
   ,  ( "ddump-worker-wrapper",   setDumpFlag Opt_D_dump_worker_wrapper)
-  ,  ( "ddump-rn-trace",         NoArg (setDynFlag Opt_D_dump_rn_trace))
-  ,  ( "ddump-if-trace",         NoArg (setDynFlag Opt_D_dump_if_trace))
+  ,  ( "ddump-rn-trace",         setDumpFlag Opt_D_dump_rn_trace)
+  ,  ( "ddump-if-trace",         setDumpFlag Opt_D_dump_if_trace)
   ,  ( "ddump-tc-trace",         setDumpFlag Opt_D_dump_tc_trace)
   ,  ( "ddump-splices",          setDumpFlag Opt_D_dump_splices)
-  ,  ( "ddump-rn-stats",         NoArg (setDynFlag Opt_D_dump_rn_stats))
+  ,  ( "ddump-rn-stats",         setDumpFlag Opt_D_dump_rn_stats)
   ,  ( "ddump-opt-cmm",          setDumpFlag Opt_D_dump_opt_cmm)
   ,  ( "ddump-simpl-stats",      setDumpFlag Opt_D_dump_simpl_stats)
   ,  ( "ddump-bcos",             setDumpFlag Opt_D_dump_BCOs)
   ,  ( "dsource-stats",          setDumpFlag Opt_D_source_stats)
   ,  ( "dverbose-core2core",     setDumpFlag Opt_D_verbose_core2core)
   ,  ( "dverbose-stg2stg",       setDumpFlag Opt_D_verbose_stg2stg)
-  ,  ( "ddump-hi-diffs",         NoArg (setDynFlag Opt_D_dump_hi_diffs))
+  ,  ( "ddump-hi-diffs",         setDumpFlag Opt_D_dump_hi_diffs)
   ,  ( "ddump-hi",               setDumpFlag Opt_D_dump_hi)
-  ,  ( "ddump-minimal-imports",  NoArg (setDynFlag Opt_D_dump_minimal_imports))
+  ,  ( "ddump-minimal-imports",  setDumpFlag Opt_D_dump_minimal_imports)
   ,  ( "ddump-vect",            setDumpFlag Opt_D_dump_vect)
+  ,  ( "ddump-hpc",             setDumpFlag Opt_D_dump_hpc)
+  ,  ( "ddump-mod-cycles",              setDumpFlag Opt_D_dump_mod_cycles)
+  
   ,  ( "dcore-lint",            NoArg (setDynFlag Opt_DoCoreLinting))
   ,  ( "dstg-lint",             NoArg (setDynFlag Opt_DoStgLinting))
   ,  ( "dcmm-lint",             NoArg (setDynFlag Opt_DoCmmLinting))
-  ,  ( "dshow-passes",           NoArg (do unSetDynFlag Opt_RecompChecking
+  ,  ( "dshow-passes",           NoArg (do setDynFlag Opt_ForceRecomp
                                           setVerbosity (Just 2)) )
   ,  ( "dfaststring-stats",     NoArg (setDynFlag Opt_D_faststring_stats))
 
@@ -954,32 +990,34 @@ dynamic_flags = [
   ,  ( "w"             , NoArg (mapM_ unSetDynFlag minusWallOpts) )
 
        ------ Optimisation flags ------------------------------------------
-  ,  ( "O"                , NoArg (upd (setOptLevel 1)))
-  ,  ( "Onot"             , NoArg (upd (setOptLevel 0)))
-  ,  ( "O"                , PrefixPred (all isDigit) 
-                               (\f -> upd (setOptLevel (read f))))
+  ,  ( "O"     , NoArg (upd (setOptLevel 1)))
+  ,  ( "Onot"  , NoArg (upd (setOptLevel 0)))
+  ,  ( "O"     , OptIntSuffix (\mb_n -> upd (setOptLevel (mb_n `orElse` 1))))
+               -- If the number is missing, use 1
 
-  ,  ( "fmax-simplifier-iterations", 
-               PrefixPred (all isDigit) 
-                 (\n -> upd (\dfs -> 
-                       dfs{ maxSimplIterations = read n })) )
+  ,  ( "fmax-simplifier-iterations", IntSuffix (\n -> 
+               upd (\dfs -> dfs{ maxSimplIterations = n })) )
 
-  ,  ( "frule-check", 
-               SepArg (\s -> upd (\dfs -> dfs{ ruleCheck = Just s })))
+       -- liberate-case-threshold is an old flag for '-fspec-threshold'
+  ,  ( "fspec-threshold",          IntSuffix (\n -> upd (\dfs -> dfs{ specThreshold = n })))
+  ,  ( "fliberate-case-threshold", IntSuffix (\n -> upd (\dfs -> dfs{ specThreshold = n })))
+
+  ,  ( "frule-check", SepArg (\s -> upd (\dfs -> dfs{ ruleCheck = Just s })))
+  ,  ( "fcontext-stack"        , IntSuffix $ \n -> upd $ \dfs -> dfs{ ctxtStkDepth = n })
 
         ------ Compiler flags -----------------------------------------------
 
+  ,  ( "fasm",         AnySuffix (\_ -> setObjTarget HscAsm) )
+  ,  ( "fvia-c",       NoArg (setObjTarget HscC) )
+  ,  ( "fvia-C",       NoArg (setObjTarget HscC) )
+
   ,  ( "fno-code",     NoArg (setTarget HscNothing))
-  ,  ( "fasm",         AnySuffix (\_ -> setTarget HscAsm) )
-  ,  ( "fvia-c",       NoArg (setTarget HscC) )
-  ,  ( "fvia-C",       NoArg (setTarget HscC) )
-  ,  ( "filx",         NoArg (setTarget HscILX) )
+  ,  ( "fbyte-code",    NoArg (setTarget HscInterpreted) )
+  ,  ( "fobject-code",  NoArg (setTarget defaultHscTarget) )
 
   ,  ( "fglasgow-exts",    NoArg (mapM_ setDynFlag   glasgowExtsFlags) )
   ,  ( "fno-glasgow-exts", NoArg (mapM_ unSetDynFlag glasgowExtsFlags) )
 
-  ,  ( "fcontext-stack"        , OptIntSuffix $ \mb_n -> upd $ \dfs -> 
-                         dfs{ ctxtStkDepth = mb_n `orElse` 3 })
 
        -- the rest of the -f* and -fno-* flags
   ,  ( "fno-",                 PrefixPred (\f -> isFFlag f) (\f -> unSetDynFlag (getFFlag f)) )
@@ -1005,6 +1043,7 @@ fFlags = [
   ( "warn-unused-matches",             Opt_WarnUnusedMatches ),
   ( "warn-deprecations",               Opt_WarnDeprecations ),
   ( "warn-orphans",                    Opt_WarnOrphans ),
+  ( "warn-tabs",                       Opt_WarnTabs ),
   ( "fi",                              Opt_FFI ),  -- support `-ffi'...
   ( "ffi",                             Opt_FFI ),  -- ...and also `-fffi'
   ( "arrows",                          Opt_Arrows ), -- arrow syntax
@@ -1013,8 +1052,11 @@ fFlags = [
   ( "implicit-prelude",                Opt_ImplicitPrelude ),
   ( "scoped-type-variables",           Opt_ScopedTypeVariables ),
   ( "bang-patterns",                   Opt_BangPatterns ),
+  ( "overloaded-strings",              Opt_OverloadedStrings ),
+  ( "indexed-types",                   Opt_IndexedTypes ),
   ( "monomorphism-restriction",                Opt_MonomorphismRestriction ),
   ( "mono-pat-binds",                  Opt_MonoPatBinds ),
+  ( "extended-default-rules",          Opt_ExtendedDefaultRules ),
   ( "implicit-params",                 Opt_ImplicitParams ),
   ( "allow-overlapping-instances",     Opt_AllowOverlappingInstances ),
   ( "allow-undecidable-instances",     Opt_AllowUndecidableInstances ),
@@ -1022,6 +1064,8 @@ fFlags = [
   ( "generics",                        Opt_Generics ),
   ( "strictness",                      Opt_Strictness ),
   ( "full-laziness",                   Opt_FullLaziness ),
+  ( "liberate-case",                   Opt_LiberateCase ),
+  ( "spec-constr",                     Opt_SpecConstr ),
   ( "cse",                             Opt_CSE ),
   ( "ignore-interface-pragmas",                Opt_IgnoreInterfacePragmas ),
   ( "omit-interface-pragmas",          Opt_OmitInterfacePragmas ),
@@ -1033,15 +1077,22 @@ fFlags = [
   ( "unbox-strict-fields",             Opt_UnboxStrictFields ),
   ( "dicts-cheap",                     Opt_DictsCheap ),
   ( "excess-precision",                        Opt_ExcessPrecision ),
-  ( "asm-mangling",                    Opt_DoAsmMangling )
+  ( "asm-mangling",                    Opt_DoAsmMangling ),
+  ( "print-bind-result",               Opt_PrintBindResult ),
+#if defined(GHCI) && defined(DEBUGGER)
+  ( "debugging",                        Opt_Debugging),
+#endif
+  ( "force-recomp",                    Opt_ForceRecomp ),
+  ( "hpc-no-auto",                     Opt_Hpc_No_Auto )
   ]
 
+
 glasgowExtsFlags = [ 
   Opt_GlasgowExts, 
   Opt_FFI, 
   Opt_ImplicitParams, 
   Opt_ScopedTypeVariables,
-  Opt_BangPatterns ]
+  Opt_IndexedTypes ]
 
 isFFlag f = f `elem` (map fst fFlags)
 getFFlag f = fromJust (lookup f fFlags)
@@ -1071,7 +1122,7 @@ unSetDynFlag f = upd (\dfs -> dopt_unset dfs f)
 
 setDumpFlag :: DynFlag -> OptKind DynP
 setDumpFlag dump_flag 
-  = NoArg (unSetDynFlag Opt_RecompChecking >> setDynFlag dump_flag)
+  = NoArg (setDynFlag Opt_ForceRecomp >> setDynFlag dump_flag)
        -- Whenver we -ddump, switch off the recompilation checker,
        -- else you don't see the dump!
 
@@ -1088,21 +1139,32 @@ hidePackage p =
   upd (\s -> s{ packageFlags = HidePackage p : packageFlags s })
 ignorePackage p = 
   upd (\s -> s{ packageFlags = IgnorePackage p : packageFlags s })
+
 setPackageName p
   | Nothing <- unpackPackageId pid
   = throwDyn (CmdLineError ("cannot parse \'" ++ p ++ "\' as a package identifier"))
   | otherwise
-  = upd (\s -> s{ thisPackage = pid })
+  = \s -> s{ thisPackage = pid }
   where
         pid = stringToPackageId p
 
--- we can only switch between HscC, HscAsmm, and HscILX with dynamic flags 
--- (-fvia-C, -fasm, -filx respectively).
-setTarget l = upd (\dfs -> case hscTarget dfs of
-                                       HscC   -> dfs{ hscTarget = l }
-                                       HscAsm -> dfs{ hscTarget = l }
-                                       HscILX -> dfs{ hscTarget = l }
-                                       _      -> dfs)
+-- If we're linking a binary, then only targets that produce object
+-- code are allowed (requests for other target types are ignored).
+setTarget l = upd set
+  where 
+   set dfs 
+     | ghcLink dfs /= LinkBinary || isObjectTarget l  = dfs{ hscTarget = l }
+     | otherwise = dfs
+
+-- Changes the target only if we're compiling object code.  This is
+-- used by -fasm and -fvia-C, which switch from one to the other, but
+-- not from bytecode to object-code.  The idea is that -fasm/-fvia-C
+-- can be safely used in an OPTIONS_GHC pragma.
+setObjTarget l = upd set
+  where 
+   set dfs 
+     | isObjectTarget (hscTarget dfs) = dfs { hscTarget = l }
+     | otherwise = dfs
 
 setOptLevel :: Int -> DynFlags -> DynFlags
 setOptLevel n dflags
@@ -1235,6 +1297,12 @@ setTmpDir dir dflags = dflags{ tmpDir = canonicalise dir }
 #endif
 
 -----------------------------------------------------------------------------
+-- Hpc stuff
+
+setOptHpcDir :: String -> DynP ()
+setOptHpcDir arg  = upd $ \ d -> d{hpcDir = arg}
+
+-----------------------------------------------------------------------------
 -- Via-C compilation stuff
 
 machdepCCOpts :: DynFlags -> ([String], -- flags for all C compilations
@@ -1324,9 +1392,6 @@ machdepCCOpts dflags
                        -- version.
                ] )
 
-#elif mips_TARGET_ARCH
-       = ( ["-static"], [] )
-
 #elif sparc_TARGET_ARCH
        = ( [], ["-w"] )
        -- For now, to suppress the gcc warning "call-clobbered