- -- The SimplifierSwitches should be delimited by "(" and ")".
-
- simpl_sep (opt1:opts) simpl_sw core_td stg_td
- = case (_UNPK_ opt1) of
- "(" -> ASSERT (null simpl_sw)
- simpl_sep opts [] core_td stg_td
- ")" -> let
- this_simpl = CoreDoSimplify (isAmongSimpl simpl_sw)
- in
- sep opts (this_simpl : core_td) stg_td
-
-# define SIMPL_SW(sw) simpl_sep opts (sw:simpl_sw) core_td stg_td
-
- -- the non-"just match a string" options are at the end...
- "-fshow-simplifier-progress" -> SIMPL_SW(ShowSimplifierProgress)
- "-fcode-duplication-ok" -> SIMPL_SW(SimplOkToDupCode)
- "-ffloat-lets-exposing-whnf" -> SIMPL_SW(SimplFloatLetsExposingWHNF)
- "-ffloat-primops-ok" -> SIMPL_SW(SimplOkToFloatPrimOps)
- "-falways-float-lets-from-lets" -> SIMPL_SW(SimplAlwaysFloatLetsFromLets)
- "-fdo-case-elim" -> SIMPL_SW(SimplDoCaseElim)
- "-fdo-eta-reduction" -> SIMPL_SW(SimplDoEtaReduction)
- "-fdo-lambda-eta-expansion" -> SIMPL_SW(SimplDoLambdaEtaExpansion)
- "-fdo-foldr-build" -> SIMPL_SW(SimplDoFoldrBuild)
- "-fdo-not-fold-back-append" -> SIMPL_SW(SimplDontFoldBackAppend)
- "-fdo-arity-expand" -> SIMPL_SW(SimplDoArityExpand)
- "-fdo-inline-foldr-build" -> SIMPL_SW(SimplDoInlineFoldrBuild)
- "-freuse-con" -> SIMPL_SW(SimplReuseCon)
- "-fcase-of-case" -> SIMPL_SW(SimplCaseOfCase)
- "-flet-to-case" -> SIMPL_SW(SimplLetToCase)
- "-fpedantic-bottoms" -> SIMPL_SW(SimplPedanticBottoms)
- "-fkeep-spec-pragma-ids" -> SIMPL_SW(KeepSpecPragmaIds)
- "-fkeep-unused-bindings" -> SIMPL_SW(KeepUnusedBindings)
- "-fmay-delete-conjurable-ids" -> SIMPL_SW(SimplMayDeleteConjurableIds)
- "-fessential-unfoldings-only" -> SIMPL_SW(EssentialUnfoldingsOnly)
- "-fignore-inline-pragma" -> SIMPL_SW(IgnoreINLINEPragma)
- "-fno-let-from-case" -> SIMPL_SW(SimplNoLetFromCase)
- "-fno-let-from-app" -> SIMPL_SW(SimplNoLetFromApp)
- "-fno-let-from-strict-let" -> SIMPL_SW(SimplNoLetFromStrictLet)
-
- o | starts_with_msi -> SIMPL_SW(MaxSimplifierIterations (read after_msi))
- | starts_with_suut -> SIMPL_SW(SimplUnfoldingUseThreshold (read after_suut))
- | starts_with_suct -> SIMPL_SW(SimplUnfoldingCreationThreshold (read after_suct))
- where
- maybe_suut = starts_with "-fsimpl-uf-use-threshold" o
- maybe_suct = starts_with "-fsimpl-uf-creation-threshold" o
- maybe_msi = starts_with "-fmax-simplifier-iterations" o
- starts_with_suut = maybeToBool maybe_suut
- starts_with_suct = maybeToBool maybe_suct
- starts_with_msi = maybeToBool maybe_msi
- (Just after_suut) = maybe_suut
- (Just after_suct) = maybe_suct
- (Just after_msi) = maybe_msi
-
- _ -> -- NB: the driver is really supposed to handle bad options
- simpl_sep opts simpl_sw core_td stg_td
+-- Core-to-core phases:
+
+buildCoreToDo :: DynFlags -> [CoreToDo]
+buildCoreToDo dflags = core_todo
+ where
+ opt_level = optLevel dflags
+ max_iter = maxSimplIterations dflags
+ strictness = dopt Opt_Strictness dflags
+ full_laziness = dopt Opt_FullLaziness dflags
+ cse = dopt Opt_CSE dflags
+ rule_check = ruleCheck dflags
+
+ core_todo =
+ if opt_level == 0 then
+ [
+ CoreDoSimplify (SimplPhase 0) [
+ MaxSimplifierIterations max_iter
+ ]
+ ]
+
+ else {- opt_level >= 1 -} [
+
+ -- initial simplify: mk specialiser happy: minimum effort please
+ CoreDoSimplify SimplGently [
+ -- Simplify "gently"
+ -- Don't inline anything till full laziness has bitten
+ -- In particular, inlining wrappers inhibits floating
+ -- e.g. ...(case f x of ...)...
+ -- ==> ...(case (case x of I# x# -> fw x#) of ...)...
+ -- ==> ...(case x of I# x# -> case fw x# of ...)...
+ -- and now the redex (f x) isn't floatable any more
+ -- Similarly, don't apply any rules until after full
+ -- laziness. Notably, list fusion can prevent floating.
+
+ NoCaseOfCase,
+ -- Don't do case-of-case transformations.
+ -- This makes full laziness work better
+ MaxSimplifierIterations max_iter
+ ],
+
+ -- Specialisation is best done before full laziness
+ -- so that overloaded functions have all their dictionary lambdas manifest
+ CoreDoSpecialising,
+
+ if full_laziness then CoreDoFloatOutwards (FloatOutSw False False)
+ else CoreDoNothing,
+
+ CoreDoFloatInwards,
+
+ CoreDoSimplify (SimplPhase 2) [
+ -- Want to run with inline phase 2 after the specialiser to give
+ -- maximum chance for fusion to work before we inline build/augment
+ -- in phase 1. This made a difference in 'ansi' where an
+ -- overloaded function wasn't inlined till too late.
+ MaxSimplifierIterations max_iter
+ ],
+ case rule_check of { Just pat -> CoreDoRuleCheck 2 pat; Nothing -> CoreDoNothing },
+
+ CoreDoSimplify (SimplPhase 1) [
+ -- Need inline-phase2 here so that build/augment get
+ -- inlined. I found that spectral/hartel/genfft lost some useful
+ -- strictness in the function sumcode' if augment is not inlined
+ -- before strictness analysis runs
+ MaxSimplifierIterations max_iter
+ ],
+ case rule_check of { Just pat -> CoreDoRuleCheck 1 pat; Nothing -> CoreDoNothing },
+
+ CoreDoSimplify (SimplPhase 0) [
+ -- Phase 0: allow all Ids to be inlined now
+ -- This gets foldr inlined before strictness analysis
+
+ MaxSimplifierIterations 3
+ -- At least 3 iterations because otherwise we land up with
+ -- huge dead expressions because of an infelicity in the
+ -- simpifier.
+ -- let k = BIG in foldr k z xs
+ -- ==> let k = BIG in letrec go = \xs -> ...(k x).... in go xs
+ -- ==> let k = BIG in letrec go = \xs -> ...(BIG x).... in go xs
+ -- Don't stop now!
+
+ ],
+ case rule_check of { Just pat -> CoreDoRuleCheck 0 pat; Nothing -> CoreDoNothing },
+
+#ifdef OLD_STRICTNESS
+ 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,
+ -- 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
+ -- catch it. For the record, the redex is
+ -- 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,
+
+ 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 },
+
+ if opt_level >= 2 then
+ CoreLiberateCase
+ else
+ CoreDoNothing,
+ if opt_level >= 2 then
+ CoreDoSpecConstr
+ else
+ CoreDoNothing,
+
+ -- Final clean-up simplification:
+ CoreDoSimplify (SimplPhase 0) [
+ MaxSimplifierIterations max_iter
+ ]
+ ]