initStaticOpts,
-- Ways
- WayName(..), v_Ways, v_Build_tag, v_RTS_Build_tag, isRTSWay,
+ WayName(..), Way(..), v_Ways, isRTSWay, mkBuildTag,
-- Output style options
opt_PprUserLength,
+ opt_PprCols,
+ opt_PprCaseAsLet,
+ opt_PprStyle_Debug, opt_TraceLevel,
+ opt_NoDebugOutput,
+
+ -- Suppressing boring aspects of core dumps
+ opt_SuppressAll,
opt_SuppressUniques,
- opt_PprStyle_Debug,
- opt_NoDebugOutput,
+ opt_SuppressCoercions,
+ opt_SuppressModulePrefixes,
+ opt_SuppressTypeApplications,
+ opt_SuppressIdInfo,
+ opt_SuppressTypeSignatures,
-- profiling opts
- opt_AutoSccsOnAllToplevs,
- opt_AutoSccsOnExportedToplevs,
- opt_AutoSccsOnIndividualCafs,
opt_SccProfilingOn,
- opt_DoTickyProfiling,
-- Hpc opts
opt_Hpc,
opt_Parallel,
-- optimisation opts
- opt_DsMultiTyVar,
opt_NoStateHack,
- opt_SpecInlineJoinPoints,
+ opt_SimpleListLiterals,
opt_CprOff,
opt_SimplNoPreInlining,
opt_SimplExcessPrecision,
+ opt_NoOptCoercion,
opt_MaxWorkerArgs,
-- Unfolding control
opt_UF_CreationThreshold,
opt_UF_UseThreshold,
opt_UF_FunAppDiscount,
+ opt_UF_DictDiscount,
opt_UF_KeenessFactor,
opt_UF_DearOp,
opt_HistorySize,
opt_OmitBlackHoling,
opt_Unregisterised,
- opt_EmitExternalCore,
v_Ld_inputs,
tablesNextToCode,
opt_StubDeadValues,
+ opt_Ticky,
-- For the parser
- addOpt, removeOpt, addWay, findBuildTag, v_opt_C_ready
+ addOpt, removeOpt, addWay, getWayFlags, v_opt_C_ready
) where
#include "HsVersions.h"
import Config
import FastString
import Util
-import Maybes ( firstJust )
+import Maybes ( firstJusts )
import Panic
+import Data.Maybe ( listToMaybe )
import Data.IORef
import System.IO.Unsafe ( unsafePerformIO )
import Data.List
addOpt = consIORef v_opt_C
addWay :: WayName -> IO ()
-addWay = consIORef v_Ways
+addWay = consIORef v_Ways . lkupWay
removeOpt :: String -> IO ()
removeOpt f = do
-- (lookup_str "foo") looks for the flag -foo=X or -fooX,
-- and returns the string X
lookup_str sw
- = case firstJust (map (maybePrefixMatch sw) staticFlags) of
+ = case firstJusts (map (stripPrefix sw) staticFlags) of
Just ('=' : str) -> Just str
Just str -> Just str
Nothing -> Nothing
= case reads str of
((x,_):_) -> x -- Be forgiving: ignore trailing goop, and alternative parses
[] -> ghcError (UsageError ("Malformed argument " ++ str ++ " for flag " ++ sw))
- -- ToDo: hack alert. We should really parse the arugments
+ -- ToDo: hack alert. We should really parse the arguments
-- and announce errors in a more civilised way.
opt_IgnoreDotGhci :: Bool
opt_IgnoreDotGhci = lookUp (fsLit "-ignore-dot-ghci")
--- debugging opts
+-- debugging options
+-- | Suppress all that is suppressable in core dumps.
+-- Except for uniques, as some simplifier phases introduce new varibles that
+-- have otherwise identical names.
+opt_SuppressAll :: Bool
+opt_SuppressAll
+ = lookUp (fsLit "-dsuppress-all")
+
+-- | Suppress all coercions, them replacing with '...'
+opt_SuppressCoercions :: Bool
+opt_SuppressCoercions
+ = lookUp (fsLit "-dsuppress-all")
+ || lookUp (fsLit "-dsuppress-coercions")
+
+-- | Suppress module id prefixes on variables.
+opt_SuppressModulePrefixes :: Bool
+opt_SuppressModulePrefixes
+ = lookUp (fsLit "-dsuppress-all")
+ || lookUp (fsLit "-dsuppress-module-prefixes")
+
+-- | Suppress type applications.
+opt_SuppressTypeApplications :: Bool
+opt_SuppressTypeApplications
+ = lookUp (fsLit "-dsuppress-all")
+ || lookUp (fsLit "-dsuppress-type-applications")
+
+-- | Suppress info such as arity and unfoldings on identifiers.
+opt_SuppressIdInfo :: Bool
+opt_SuppressIdInfo
+ = lookUp (fsLit "-dsuppress-all")
+ || lookUp (fsLit "-dsuppress-idinfo")
+
+-- | Suppress seprate type signatures in core, but leave types on lambda bound vars
+opt_SuppressTypeSignatures :: Bool
+opt_SuppressTypeSignatures
+ = lookUp (fsLit "-dsuppress-all")
+ || lookUp (fsLit "-dsuppress-type-signatures")
+
+-- | Suppress unique ids on variables.
+-- Except for uniques, as some simplifier phases introduce new variables that
+-- have otherwise identical names.
opt_SuppressUniques :: Bool
-opt_SuppressUniques = lookUp (fsLit "-dsuppress-uniques")
+opt_SuppressUniques
+ = lookUp (fsLit "-dsuppress-uniques")
+
+-- | Display case expressions with a single alternative as strict let bindings
+opt_PprCaseAsLet :: Bool
+opt_PprCaseAsLet = lookUp (fsLit "-dppr-case-as-let")
+
+-- | Set the maximum width of the dumps
+-- If GHC's command line options are bad then the options parser uses the
+-- pretty printer display the error message. In this case the staticFlags
+-- won't be initialized yet, so we must check for this case explicitly
+-- and return the default value.
+opt_PprCols :: Int
+opt_PprCols
+ = unsafePerformIO
+ $ do ready <- readIORef v_opt_C_ready
+ if (not ready)
+ then return 100
+ else return $ lookup_def_int "-dppr-cols" 100
+
+
opt_PprStyle_Debug :: Bool
-opt_PprStyle_Debug = lookUp (fsLit "-dppr-debug")
+opt_PprStyle_Debug = lookUp (fsLit "-dppr-debug")
+
+opt_TraceLevel :: Int
+opt_TraceLevel = lookup_def_int "-dtrace-level" 1 -- Standard level is 1
+ -- Less verbose is 0
+
opt_PprUserLength :: Int
opt_PprUserLength = lookup_def_int "-dppr-user-length" 5 --ToDo: give this a name
+
opt_Fuel :: Int
opt_Fuel = lookup_def_int "-dopt-fuel" maxBound
+
opt_NoDebugOutput :: Bool
opt_NoDebugOutput = lookUp (fsLit "-dno-debug-output")
-
-- profiling opts
-opt_AutoSccsOnAllToplevs :: Bool
-opt_AutoSccsOnAllToplevs = lookUp (fsLit "-fauto-sccs-on-all-toplevs")
-opt_AutoSccsOnExportedToplevs :: Bool
-opt_AutoSccsOnExportedToplevs = lookUp (fsLit "-fauto-sccs-on-exported-toplevs")
-opt_AutoSccsOnIndividualCafs :: Bool
-opt_AutoSccsOnIndividualCafs = lookUp (fsLit "-fauto-sccs-on-individual-cafs")
opt_SccProfilingOn :: Bool
opt_SccProfilingOn = lookUp (fsLit "-fscc-profiling")
-opt_DoTickyProfiling :: Bool
-opt_DoTickyProfiling = WayTicky `elem` (unsafePerformIO $ readIORef v_Ways)
-- Hpc opts
opt_Hpc :: Bool
-- language opts
opt_DictsStrict :: Bool
opt_DictsStrict = lookUp (fsLit "-fdicts-strict")
+
opt_IrrefutableTuples :: Bool
opt_IrrefutableTuples = lookUp (fsLit "-firrefutable-tuples")
+
opt_Parallel :: Bool
opt_Parallel = lookUp (fsLit "-fparallel")
--- optimisation opts
-opt_DsMultiTyVar :: Bool
-opt_DsMultiTyVar = not (lookUp (fsLit "-fno-ds-multi-tyvar"))
- -- On by default
-
-opt_SpecInlineJoinPoints :: Bool
-opt_SpecInlineJoinPoints = lookUp (fsLit "-fspec-inline-join-points")
+opt_SimpleListLiterals :: Bool
+opt_SimpleListLiterals = lookUp (fsLit "-fsimple-list-literals")
opt_NoStateHack :: Bool
opt_NoStateHack = lookUp (fsLit "-fno-state-hack")
+
opt_CprOff :: Bool
opt_CprOff = lookUp (fsLit "-fcpr-off")
-- Switch off CPR analysis in the new demand analyser
opt_GranMacros :: Bool
opt_GranMacros = lookUp (fsLit "-fgransim")
+
opt_HiVersion :: Integer
opt_HiVersion = read (cProjectVersionInt ++ cProjectPatchLevel) :: Integer
+
opt_HistorySize :: Int
opt_HistorySize = lookup_def_int "-fhistory-size" 20
+
opt_OmitBlackHoling :: Bool
opt_OmitBlackHoling = lookUp (fsLit "-dno-black-holing")
+
opt_StubDeadValues :: Bool
opt_StubDeadValues = lookUp (fsLit "-dstub-dead-values")
opt_SimplExcessPrecision :: Bool
opt_SimplExcessPrecision = lookUp (fsLit "-fexcess-precision")
+opt_NoOptCoercion :: Bool
+opt_NoOptCoercion = lookUp (fsLit "-fno-opt-coercion")
+
-- Unfolding control
-opt_UF_CreationThreshold :: Int
-opt_UF_CreationThreshold = lookup_def_int "-funfolding-creation-threshold" (45::Int)
-opt_UF_UseThreshold :: Int
-opt_UF_UseThreshold = lookup_def_int "-funfolding-use-threshold" (8::Int) -- Discounts can be big
-opt_UF_FunAppDiscount :: Int
-opt_UF_FunAppDiscount = lookup_def_int "-funfolding-fun-discount" (6::Int) -- It's great to inline a fn
+-- See Note [Discounts and thresholds] in CoreUnfold
+
+opt_UF_CreationThreshold, opt_UF_UseThreshold :: Int
+opt_UF_DearOp, opt_UF_FunAppDiscount, opt_UF_DictDiscount :: Int
opt_UF_KeenessFactor :: Float
-opt_UF_KeenessFactor = lookup_def_float "-funfolding-keeness-factor" (1.5::Float)
-opt_UF_DearOp :: Int
-opt_UF_DearOp = ( 4 :: Int)
+opt_UF_CreationThreshold = lookup_def_int "-funfolding-creation-threshold" (450::Int)
+opt_UF_UseThreshold = lookup_def_int "-funfolding-use-threshold" (60::Int)
+opt_UF_FunAppDiscount = lookup_def_int "-funfolding-fun-discount" (60::Int)
+
+opt_UF_DictDiscount = lookup_def_int "-funfolding-dict-discount" (30::Int)
+ -- Be fairly keen to inline a fuction if that means
+ -- we'll be able to pick the right method from a dictionary
+
+opt_UF_KeenessFactor = lookup_def_float "-funfolding-keeness-factor" (1.5::Float)
+opt_UF_DearOp = ( 40 :: Int)
-- Related to linking
opt_PIC :: Bool
#if darwin_TARGET_OS && x86_64_TARGET_ARCH
opt_PIC = True
+#elif darwin_TARGET_OS
+opt_PIC = lookUp (fsLit "-fPIC") || not opt_Static
#else
opt_PIC = lookUp (fsLit "-fPIC")
#endif
-- Derived, not a real option. Determines whether we will be compiling
-- info tables that reside just before the entry code, or with an
-- indirection to the entry code. See TABLES_NEXT_TO_CODE in
--- includes/InfoTables.h.
+-- includes/rts/storage/InfoTables.h.
tablesNextToCode :: Bool
tablesNextToCode = not opt_Unregisterised
&& cGhcEnableTablesNextToCode == "YES"
-opt_EmitExternalCore :: Bool
-opt_EmitExternalCore = lookUp (fsLit "-fext-core")
-
-- Include full span info in error messages, instead of just the start position.
opt_ErrorSpans :: Bool
opt_ErrorSpans = lookUp (fsLit "-ferror-spans")
+opt_Ticky :: Bool
+opt_Ticky = lookUp (fsLit "-ticky")
-- object files and libraries to be linked in are collected here.
-- ToDo: perhaps this could be done without a global, it wasn't obvious
-- non-profiling objects.
-- After parsing the command-line options, we determine which "way" we
--- are building - this might be a combination way, eg. profiling+ticky-ticky.
+-- are building - this might be a combination way, eg. profiling+threaded.
-- We then find the "build-tag" associated with this way, and this
-- becomes the suffix used to find .hi files and libraries used in
-- this compilation.
-GLOBAL_VAR(v_Build_tag, "", String)
-
--- The RTS has its own build tag, because there are some ways that
--- affect the RTS only.
-GLOBAL_VAR(v_RTS_Build_tag, "", String)
-
data WayName
= WayThreaded
| WayDebug
| WayProf
- | WayTicky
+ | WayEventLog
| WayPar
| WayGran
| WayNDP
- | WayUser_a
- | WayUser_b
- | WayUser_c
- | WayUser_d
- | WayUser_e
- | WayUser_f
- | WayUser_g
- | WayUser_h
- | WayUser_i
- | WayUser_j
- | WayUser_k
- | WayUser_l
- | WayUser_m
- | WayUser_n
- | WayUser_o
- | WayUser_A
- | WayUser_B
+ | WayDyn
deriving (Eq,Ord)
-GLOBAL_VAR(v_Ways, [] ,[WayName])
+GLOBAL_VAR(v_Ways, [] ,[Way])
allowed_combination :: [WayName] -> Bool
allowed_combination way = and [ x `allowedWith` y
-- <= the right argument, according to the Ord instance
-- on Way above.
+ -- dyn is allowed with everything
+ _ `allowedWith` WayDyn = True
+ WayDyn `allowedWith` _ = True
+
-- debug is allowed with everything
_ `allowedWith` WayDebug = True
WayDebug `allowedWith` _ = True
WayProf `allowedWith` WayNDP = True
WayThreaded `allowedWith` WayProf = True
+ WayThreaded `allowedWith` WayEventLog = True
_ `allowedWith` _ = False
-findBuildTag :: IO [String] -- new options
-findBuildTag = do
- way_names <- readIORef v_Ways
- let ws = sort (nub way_names)
+getWayFlags :: IO [String] -- new options
+getWayFlags = do
+ unsorted <- readIORef v_Ways
+ let ways = sortBy (compare `on` wayName) $
+ nubBy ((==) `on` wayName) $ unsorted
+ writeIORef v_Ways ways
- if not (allowed_combination ws)
+ if not (allowed_combination (map wayName ways))
then ghcError (CmdLineError $
"combination not supported: " ++
foldr1 (\a b -> a ++ '/':b)
- (map (wayName . lkupWay) ws))
- else let ways = map lkupWay ws
- tag = mkBuildTag (filter (not.wayRTSOnly) ways)
- rts_tag = mkBuildTag ways
- flags = map wayOpts ways
- in do
- writeIORef v_Build_tag tag
- writeIORef v_RTS_Build_tag rts_tag
- return (concat flags)
-
-
+ (map wayDesc ways))
+ else
+ return (concatMap wayOpts ways)
mkBuildTag :: [Way] -> String
mkBuildTag ways = concat (intersperse "_" (map wayTag ways))
lkupWay :: WayName -> Way
lkupWay w =
- case lookup w way_details of
+ case listToMaybe (filter ((==) w . wayName) way_details) of
Nothing -> error "findBuildTag"
Just details -> details
isRTSWay = wayRTSOnly . lkupWay
data Way = Way {
+ wayName :: WayName,
wayTag :: String,
wayRTSOnly :: Bool,
- wayName :: String,
+ wayDesc :: String,
wayOpts :: [String]
}
-way_details :: [ (WayName, Way) ]
+way_details :: [ Way ]
way_details =
- [ (WayThreaded, Way "thr" True "Threaded" [
+ [ Way WayThreaded "thr" True "Threaded" [
#if defined(freebsd_TARGET_OS)
-- "-optc-pthread"
-- , "-optl-pthread"
-- the problems are our fault or theirs, but it seems that using the
-- alternative 1:1 threading library libthr works around it:
"-optl-lthr"
+#elif defined(openbsd_TARGET_OS)
+ "-optc-pthread"
+ , "-optl-pthread"
#elif defined(solaris2_TARGET_OS)
"-optl-lrt"
#endif
- ] ),
-
- (WayDebug, Way "debug" True "Debug" [] ),
+ ],
+
+ Way WayDebug "debug" True "Debug" [],
+
+ Way WayDyn "dyn" False "Dynamic"
+ [ "-DDYNAMIC"
+ , "-optc-DDYNAMIC"
+#if defined(mingw32_TARGET_OS)
+ -- On Windows, code that is to be linked into a dynamic library must be compiled
+ -- with -fPIC. Labels not in the current package are assumed to be in a DLL
+ -- different from the current one.
+ , "-fPIC"
+#elif defined(openbsd_TARGET_OS)
+ -- Without this, linking the shared libHSffi fails because
+ -- it uses pthread mutexes.
+ , "-optl-pthread"
+#endif
+ ],
- (WayProf, Way "p" False "Profiling"
+ Way WayProf "p" False "Profiling"
[ "-fscc-profiling"
, "-DPROFILING"
- , "-optc-DPROFILING" ]),
+ , "-optc-DPROFILING" ],
- (WayTicky, Way "t" True "Ticky-ticky Profiling"
- [ "-DTICKY_TICKY"
- , "-optc-DTICKY_TICKY" ]),
+ Way WayEventLog "l" True "RTS Event Logging"
+ [ "-DTRACING"
+ , "-optc-DTRACING" ],
- -- optl's below to tell linker where to find the PVM library -- HWL
- (WayPar, Way "mp" False "Parallel"
+ Way WayPar "mp" False "Parallel"
[ "-fparallel"
, "-D__PARALLEL_HASKELL__"
, "-optc-DPAR"
, "-optc-w"
, "-optl-L${PVM_ROOT}/lib/${PVM_ARCH}"
, "-optl-lpvm3"
- , "-optl-lgpvm3" ]),
+ , "-optl-lgpvm3" ],
-- at the moment we only change the RTS and could share compiler and libs!
- (WayPar, Way "mt" False "Parallel ticky profiling"
+ Way WayPar "mt" False "Parallel ticky profiling"
[ "-fparallel"
, "-D__PARALLEL_HASKELL__"
, "-optc-DPAR"
, "-optc-w"
, "-optl-L${PVM_ROOT}/lib/${PVM_ARCH}"
, "-optl-lpvm3"
- , "-optl-lgpvm3" ]),
+ , "-optl-lgpvm3" ],
- (WayPar, Way "md" False "Distributed"
+ Way WayPar "md" False "Distributed"
[ "-fparallel"
, "-D__PARALLEL_HASKELL__"
, "-D__DISTRIBUTED_HASKELL__"
, "-optc-w"
, "-optl-L${PVM_ROOT}/lib/${PVM_ARCH}"
, "-optl-lpvm3"
- , "-optl-lgpvm3" ]),
+ , "-optl-lgpvm3" ],
- (WayGran, Way "mg" False "GranSim"
+ Way WayGran "mg" False "GranSim"
[ "-fgransim"
, "-D__GRANSIM__"
, "-optc-DGRAN"
- , "-package concurrent" ]),
+ , "-package concurrent" ],
- (WayNDP, Way "ndp" False "Nested data parallelism"
+ Way WayNDP "ndp" False "Nested data parallelism"
[ "-XParr"
- , "-fvectorise"]),
-
- (WayUser_a, Way "a" False "User way 'a'" ["$WAY_a_REAL_OPTS"]),
- (WayUser_b, Way "b" False "User way 'b'" ["$WAY_b_REAL_OPTS"]),
- (WayUser_c, Way "c" False "User way 'c'" ["$WAY_c_REAL_OPTS"]),
- (WayUser_d, Way "d" False "User way 'd'" ["$WAY_d_REAL_OPTS"]),
- (WayUser_e, Way "e" False "User way 'e'" ["$WAY_e_REAL_OPTS"]),
- (WayUser_f, Way "f" False "User way 'f'" ["$WAY_f_REAL_OPTS"]),
- (WayUser_g, Way "g" False "User way 'g'" ["$WAY_g_REAL_OPTS"]),
- (WayUser_h, Way "h" False "User way 'h'" ["$WAY_h_REAL_OPTS"]),
- (WayUser_i, Way "i" False "User way 'i'" ["$WAY_i_REAL_OPTS"]),
- (WayUser_j, Way "j" False "User way 'j'" ["$WAY_j_REAL_OPTS"]),
- (WayUser_k, Way "k" False "User way 'k'" ["$WAY_k_REAL_OPTS"]),
- (WayUser_l, Way "l" False "User way 'l'" ["$WAY_l_REAL_OPTS"]),
- (WayUser_m, Way "m" False "User way 'm'" ["$WAY_m_REAL_OPTS"]),
- (WayUser_n, Way "n" False "User way 'n'" ["$WAY_n_REAL_OPTS"]),
- (WayUser_o, Way "o" False "User way 'o'" ["$WAY_o_REAL_OPTS"]),
- (WayUser_A, Way "A" False "User way 'A'" ["$WAY_A_REAL_OPTS"]),
- (WayUser_B, Way "B" False "User way 'B'" ["$WAY_B_REAL_OPTS"])
+ , "-fvectorise"]
]
-
projects / ghc-hetmet.git / blobdiff