Update Trac ticket URLs to point to GitLab
[ghc.git] / docs / users_guide / using-optimisation.rst
index 123d74b..9571c7e 100644 (file)
@@ -45,13 +45,14 @@ optimisation to be performed, which can have an impact on how much of
 your program needs to be recompiled when you change something. This is
 one reason to stick to no-optimisation when developing code.
 
-.. ghc-flag:: -O*
-
-    This is taken to mean: “Please compile quickly; I'm not
-    over-bothered about compiled-code quality.” So, for example:
-    ``ghc -c Foo.hs``
+**No ``-O*``-type option specified:** This is taken to mean “Please
+compile quickly; I'm not over-bothered about compiled-code quality.”
+So, for example, ``ghc -c Foo.hs``
 
 .. ghc-flag:: -O0
+    :shortdesc: Disable optimisations (default)
+    :type: dynamic
+    :category: optimization-levels
 
     Means "turn off all optimisation", reverting to the same settings as
     if no ``-O`` options had been specified. Saying ``-O0`` can be
@@ -60,6 +61,10 @@ one reason to stick to no-optimisation when developing code.
 
 .. ghc-flag:: -O
               -O1
+    :shortdesc: Enable level 1 optimisations
+    :type: dynamic
+    :reverse: -O0
+    :category: optimization-levels
 
     .. index::
        single: optimise; normally
@@ -68,6 +73,10 @@ one reason to stick to no-optimisation when developing code.
     it." Thus, for example: ``ghc -c -O Main.lhs``
 
 .. ghc-flag:: -O2
+    :shortdesc: Enable level 2 optimisations
+    :type: dynamic
+    :reverse: -O0
+    :category: optimization-levels
 
     .. index::
        single: optimise; aggressively
@@ -79,15 +88,6 @@ one reason to stick to no-optimisation when developing code.
     runtime or space *worse* if you're unlucky. They are normally turned
     on or off individually.
 
-.. ghc-flag:: -Odph
-
-    .. index::
-       single: optimise; DPH
-
-    Enables all ``-O2`` optimisation, sets
-    ``-fmax-simplifier-iterations=20`` and ``-fsimplifier-phases=3``.
-    Designed for use with :ref:`Data Parallel Haskell (DPH) <dph>`.
-
 We don't use a ``-O*`` flag for day-to-day work. We use ``-O`` to get
 respectable speed; e.g., when we want to measure something. When we want
 to go for broke, we tend to use ``-O2`` (and we go for lots of coffee
@@ -108,10 +108,13 @@ The easiest way to see what ``-O`` (etc.) “really mean” is to run with
 These flags turn on and off individual optimisations. Flags marked as
 on by default are enabled by ``-O``, and as such you shouldn't
 need to set any of them explicitly. A flag ``-fwombat`` can be negated
-by saying ``-fno-wombat``. See :ref:`options-f-compact` for a compact
-list.
+by saying ``-fno-wombat``.
 
 .. ghc-flag:: -fcase-merge
+    :shortdesc: Enable case-merging. Implied by :ghc-flag:`-O`.
+    :type: dynamic
+    :reverse: -fno-case-merge
+    :category:
 
     :default: on
 
@@ -132,6 +135,10 @@ list.
              Green -> e2
 
 .. ghc-flag:: -fcase-folding
+    :shortdesc: Enable constant folding in case expressions. Implied by :ghc-flag:`-O`.
+    :type: dynamic
+    :reverse: -fno-case-folding
+    :category:
 
     :default: on
 
@@ -151,12 +158,30 @@ list.
              _    -> let v = x `minusWord#` 10## in e3
 
 .. ghc-flag:: -fcall-arity
+    :shortdesc: Enable call-arity optimisation. Implied by :ghc-flag:`-O`.
+    :type: dynamic
+    :reverse: -fno-call-arity
+    :category:
 
     :default: on
 
     Enable call-arity analysis.
 
+.. ghc-flag:: -fexitification
+    :shortdesc: Enables exitification optimisation. Implied by :ghc-flag:`-O`.
+    :type: dynamic
+    :reverse: -fno-exitification
+    :category:
+
+    :default: on
+
+    Enables the floating of exit paths out of recursive functions.
+
 .. ghc-flag:: -fcmm-elim-common-blocks
+    :shortdesc: Enable Cmm common block elimination. Implied by :ghc-flag:`-O`.
+    :type: dynamic
+    :reverse: -fno-cmm-elim-common-blocks
+    :category:
 
     :default: on
 
@@ -165,6 +190,10 @@ list.
     Cmm blocks and eliminate the duplicates.
 
 .. ghc-flag:: -fcmm-sink
+    :shortdesc: Enable Cmm sinking. Implied by :ghc-flag:`-O`.
+    :type: dynamic
+    :reverse: -fno-cmm-sink
+    :category:
 
     :default: on
 
@@ -174,11 +203,90 @@ list.
     to their usage sites. It also inlines simple expressions like
     literals or registers.
 
-.. ghc-flag:: -fcpr-off
+.. ghc-flag:: -fasm-shortcutting
+    :shortdesc: Enable shortcutting on assembly. Implied by :ghc-flag:`-O2`.
+    :type: dynamic
+    :reverse: -fno-asm-shortcutting
+    :category:
+
+    :default: off
+
+    This enables shortcutting at the assembly stage of the code generator.
+    In simpler terms shortcutting means if a block of instructions A only consists
+    of a unconditionally jump, we replace all jumps to A by jumps to the successor
+    of A.
+
+    This is mostly done during Cmm passes. However this can miss corner cases. So at -O2
+    we run the pass again at the asm stage to catch these.
+
+.. ghc-flag:: -fblock-layout-cfg
+    :shortdesc: Use the new cfg based block layout algorithm.
+    :type: dynamic
+    :reverse: -fno-block-layout-cfg
+    :category:
+
+    :default: off but enabled with :ghc-flag:`-O`.
+
+    The new algorithm considers all outgoing edges of a basic blocks for
+    code layout instead of only the last jump instruction.
+    It also builds a control flow graph for functions, tries to find
+    hot code paths and place them sequentially leading to better cache utilization
+    and performance.
+
+    This is expected to improve performance on average, but actual performance
+    difference can vary.
+
+    If you find cases of significant performance regressions, which can
+    be traced back to obviously bad code layout please open a ticket.
+
+.. ghc-flag:: -fblock-layout-weights
+    :shortdesc: Sets edge weights used by the new code layout algorithm.
+    :type: dynamic
+    :category:
+
+    This flag is hacker territory. The main purpose of this flag is to make
+    it easy to debug and tune the new code layout algorithm. There is no
+    guarantee that values giving better results now won't be worse with
+    the next release.
+
+    If you feel your code warrants modifying these settings please consult
+    the source code for default values and documentation. But I strongly
+    advise against this.
+
+.. ghc-flag:: -fblock-layout-weightless
+    :shortdesc: Ignore cfg weights for code layout.
+    :type: dynamic
+    :reverse: -fno-block-layout-weightless
+    :category:
+
+    :default: off
+
+    When not using the cfg based blocklayout layout is determined either
+    by the last jump in a basic block or the heaviest outgoing edge of the
+    block in the cfg.
 
-    Switch off CPR analysis in the demand analyser.
+    With this flag enabled we use the last jump instruction in blocks.
+    Without this flags the old algorithm also uses the heaviest outgoing
+    edge.
+
+    When this flag is enabled and :ghc-flag:`-fblock-layout-cfg` is disabled
+    block layout behaves the same as in 8.6 and earlier.
+
+.. ghc-flag:: -fcpr-anal
+    :shortdesc: Turn on CPR analysis in the demand analyser. Implied by :ghc-flag:`-O`.
+    :type: dynamic
+    :reverse: -fno-cpr-anal
+    :category:
+
+    :default: on
+
+    Turn on CPR analysis in the demand analyser.
 
 .. ghc-flag:: -fcse
+    :shortdesc: Enable common sub-expression elimination. Implied by :ghc-flag:`-O`.
+    :type: dynamic
+    :reverse: -fno-cse
+    :category:
 
     :default: on
 
@@ -187,6 +295,11 @@ list.
     ``unsafePerformIO`` expressions that you don't want commoned-up.
 
 .. ghc-flag:: -fstg-cse
+    :shortdesc: Enable common sub-expression elimination on the STG
+        intermediate language
+    :type: dynamic
+    :reverse: -fno-stg-cse
+    :category:
 
     :default: on
 
@@ -195,21 +308,42 @@ list.
     that differ in their types, but not their represetation.
 
 .. ghc-flag:: -fdicts-cheap
+    :shortdesc: Make dictionary-valued expressions seem cheap to the optimiser.
+    :type: dynamic
+    :reverse: -fno-dicts-cheap
+    :category:
+
+    :default: off
 
     A very experimental flag that makes dictionary-valued expressions
     seem cheap to the optimiser.
 
 .. ghc-flag:: -fdicts-strict
+    :shortdesc: Make dictionaries strict
+    :type: dynamic
+    :reverse: -fno-dicts-strict
+    :category:
+
+    :default: off
 
     Make dictionaries strict.
 
 .. ghc-flag:: -fdmd-tx-dict-sel
+    :shortdesc: Use a special demand transformer for dictionary selectors.
+        Always enabled by default.
+    :type: dynamic
+    :reverse: -fno-dmd-tx-dict-sel
+    :category:
 
-    *On by default for ``-O0``, ``-O``, ``-O2``.*
+    :default: on
 
     Use a special demand transformer for dictionary selectors.
 
 .. ghc-flag:: -fdo-eta-reduction
+    :shortdesc: Enable eta-reduction. Implied by :ghc-flag:`-O`.
+    :type: dynamic
+    :reverse: -fno-do-eta-reduction
+    :category:
 
     :default: on
 
@@ -217,19 +351,36 @@ list.
     lambdas.
 
 .. ghc-flag:: -fdo-lambda-eta-expansion
+    :shortdesc: Enable lambda eta-expansion. Always enabled by default.
+    :type: dynamic
+    :reverse: -fno-do-lambda-eta-expansion
+    :category:
 
     :default: on
 
     Eta-expand let-bindings to increase their arity.
 
 .. ghc-flag:: -feager-blackholing
+    :shortdesc: Turn on :ref:`eager blackholing <parallel-compile-options>`
+    :type: dynamic
+    :category:
+
+    :default: off
 
     Usually GHC black-holes a thunk only when it switches threads. This
     flag makes it do so as soon as the thunk is entered. See `Haskell on
     a shared-memory
-    multiprocessor <http://research.microsoft.com/en-us/um/people/simonpj/papers/parallel/>`__.
+    multiprocessor <http://community.haskell.org/~simonmar/papers/multiproc.pdf>`__.
+
+    See :ref:`parallel-compile-options` for a dicussion on its use.
 
 .. ghc-flag:: -fexcess-precision
+    :shortdesc: Enable excess intermediate precision
+    :type: dynamic
+    :reverse: -fno-excess-precision
+    :category:
+
+    :default: off
 
     When this option is given, intermediate floating point values can
     have a *greater* precision/range than the final type. Generally this
@@ -243,12 +394,22 @@ list.
     :ref:`bugs-ghc`.
 
 .. ghc-flag:: -fexpose-all-unfoldings
+    :shortdesc: Expose all unfoldings, even for very large or recursive functions.
+    :type: dynamic
+    :reverse: -fno-expose-all-unfoldings
+    :category:
+
+    :default: off
 
     An experimental flag to expose all unfoldings, even for very large
     or recursive functions. This allows for all functions to be inlined
     while usually GHC would avoid inlining larger functions.
 
 .. ghc-flag:: -ffloat-in
+    :shortdesc: Turn on the float-in transformation. Implied by :ghc-flag:`-O`.
+    :type: dynamic
+    :reverse: -fno-float-in
+    :category:
 
     :default: on
 
@@ -270,6 +431,11 @@ list.
     allocation and helping the garbage collector and allocator.
 
 .. ghc-flag:: -ffull-laziness
+    :shortdesc: Turn on full laziness (floating bindings outwards).
+        Implied by :ghc-flag:`-O`.
+    :type: dynamic
+    :reverse: -fno-full-laziness
+    :category:
 
     :default: on
 
@@ -291,6 +457,11 @@ list.
        don't rely on it.
 
 .. ghc-flag:: -ffun-to-thunk
+    :shortdesc: Allow worker-wrapper to convert a function closure into a thunk
+        if the function does not use any of its arguments. Off by default.
+    :type: dynamic
+    :reverse: -fno-fun-to-thunk
+    :category:
 
     :default: off
 
@@ -300,6 +471,10 @@ list.
     This flag allows worker/wrapper to remove *all* value lambdas.
 
 .. ghc-flag:: -fignore-asserts
+    :shortdesc: Ignore assertions in the source. Implied by :ghc-flag:`-O`.
+    :type: dynamic
+    :reverse: -fno-ignore-asserts
+    :category:
 
     :default: on
 
@@ -308,6 +483,12 @@ list.
     :ref:`assertions`).
 
 .. ghc-flag:: -fignore-interface-pragmas
+    :shortdesc: Ignore pragmas in interface files. Implied by :ghc-flag:`-O0` only.
+    :type: dynamic
+    :reverse: -fno-ignore-interface-pragmas
+    :category:
+
+    :default: off
 
     Tells GHC to ignore all inessential information when reading
     interface files. That is, even if :file:`M.hi` contains unfolding or
@@ -315,29 +496,51 @@ list.
     information.
 
 .. ghc-flag:: -flate-dmd-anal
+    :shortdesc: Run demand analysis again, at the end of the
+        simplification pipeline
+    :type: dynamic
+    :reverse: -fno-late-dmd-anal
+    :category:
+
+    :default: off
 
     Run demand analysis again, at the end of the simplification
     pipeline. We found some opportunities for discovering strictness
     that were not visible earlier; and optimisations like
     :ghc-flag:`-fspec-constr` can create functions with unused arguments which
     are eliminated by late demand analysis. Improvements are modest, but
-    so is the cost. See notes on the :ghc-wiki:`Trac wiki page <LateDmd>`.
+    so is the cost. See notes on the :ghc-wiki:`wiki page <LateDmd>`.
 
 .. ghc-flag:: -fliberate-case
+    :shortdesc: Turn on the liberate-case transformation. Implied by :ghc-flag:`-O2`.
+    :type: dynamic
+    :reverse: -fno-liberate-case
+    :category:
 
-    *Off by default, but enabled by -O2.* Turn on the liberate-case
-    transformation. This unrolls recursive function once in its own RHS,
-    to avoid repeated case analysis of free variables. It's a bit like
-    the call-pattern specialiser (:ghc-flag:`-fspec-constr`) but for free
-    variables rather than arguments.
+    :default: off but enabled with :ghc-flag:`-O2`.
 
-.. ghc-flag:: -fliberate-case-threshold=<n>
+    Turn on the liberate-case transformation. This unrolls recursive function
+    once in its own RHS, to avoid repeated case analysis of free variables. It's
+    a bit like the call-pattern specialiser (:ghc-flag:`-fspec-constr`) but for
+    free variables rather than arguments.
+
+.. ghc-flag:: -fliberate-case-threshold=⟨n⟩
+    :shortdesc: *default: 2000.* Set the size threshold for the liberate-case
+        transformation to ⟨n⟩
+    :type: dynamic
+    :reverse: -fno-liberate-case-threshold
+    :category:
 
     :default: 2000
 
     Set the size threshold for the liberate-case transformation.
 
 .. ghc-flag:: -floopification
+    :shortdesc: Turn saturated self-recursive tail-calls into local jumps in the
+        generated assembly. Implied by :ghc-flag:`-O`.
+    :type: dynamic
+    :reverse: -fno-loopification
+    :category:
 
     :default: on
 
@@ -345,7 +548,23 @@ list.
     self-recursive saturated tail calls into local jumps rather than
     function calls.
 
-.. ghc-flag:: -fmax-inline-alloc-size=<n>
+.. ghc-flag:: -fllvm-pass-vectors-in-regs
+    :shortdesc: Pass vector value in vector registers for function calls
+    :type: dynamic
+    :reverse: -fno-llvm-pass-vectors-in-regs
+    :category:
+
+    :default: on
+
+    Instructs GHC to use the platform's native vector registers to pass vector
+    arguments during function calls. As with all vector support, this requires
+    :ghc-flag:`-fllvm`.
+
+.. ghc-flag:: -fmax-inline-alloc-size=⟨n⟩
+    :shortdesc: *default: 128.* Set the maximum size of inline array allocations
+        to ⟨n⟩ bytes (default: 128).
+    :type: dynamic
+    :category:
 
     :default: 128
 
@@ -354,21 +573,33 @@ list.
     nursery block if they're no bigger than n bytes, ignoring GC overheap. This
     value should be quite a bit smaller than the block size (typically: 4096).
 
-.. ghc-flag:: -fmax-inline-memcpy-insn=<n>
+.. ghc-flag:: -fmax-inline-memcpy-insns=⟨n⟩
+    :shortdesc: *default: 32.* Inline ``memcpy`` calls if they would generate no
+        more than ⟨n⟩ pseudo instructions.
+    :type: dynamic
+    :category:
 
     :default: 32
 
     Inline ``memcpy`` calls if they would generate no more than ⟨n⟩ pseudo-instructions.
 
-.. ghc-flag:: -fmax-inline-memset-insns=<n>
+.. ghc-flag:: -fmax-inline-memset-insns=⟨n⟩
+    :shortdesc: *default: 32.* Inline ``memset`` calls if they would generate no
+        more than ⟨n⟩ pseudo instructions
+    :type: dynamic
+    :category:
 
     :default: 32
 
     Inline ``memset`` calls if they would generate no more than n pseudo
     instructions.
 
-.. ghc-flag:: -fmax-relevant-binds=<n>
-              -fno-max-relevant-bindings
+.. ghc-flag:: -fmax-relevant-binds=⟨n⟩
+    :shortdesc: *default: 6.* Set the maximum number of bindings to display in
+        type error messages.
+    :type: dynamic
+    :reverse: -fno-max-relevant-bindings
+    :category: verbosity
 
     :default: 6
 
@@ -380,34 +611,62 @@ list.
     they may be numerous), but ``-fno-max-relevant-bindings`` includes
     them too.
 
-.. ghc-flag:: -fmax-uncovered-patterns=<n>
+.. ghc-flag:: -fmax-uncovered-patterns=⟨n⟩
+    :shortdesc: *default: 4.* Set the maximum number of patterns to display in
+        warnings about non-exhaustive ones.
+    :type: dynamic
+    :category:
 
     :default: 4
 
     Maximum number of unmatched patterns to be shown in warnings generated by
     :ghc-flag:`-Wincomplete-patterns` and :ghc-flag:`-Wincomplete-uni-patterns`.
 
-.. ghc-flag:: -fmax-simplifier-iterations=<n>
+.. ghc-flag:: -fmax-simplifier-iterations=⟨n⟩
+    :shortdesc: *default: 4.* Set the max iterations for the simplifier.
+    :type: dynamic
+    :category:
 
     :default: 4
 
     Sets the maximal number of iterations for the simplifier.
 
-.. ghc-flag:: -fmax-worker-args=<n>
+.. ghc-flag:: -fmax-worker-args=⟨n⟩
+    :shortdesc: *default: 10.* If a worker has that many arguments, none will
+        be unpacked anymore.
+    :type: dynamic
+    :category:
 
     :default: 10
 
     If a worker has that many arguments, none will be unpacked anymore.
 
 .. ghc-flag:: -fno-opt-coercion
+    :shortdesc: Turn off the coercion optimiser
+    :type: dynamic
+    :category:
+
+    :default: coercion optimisation enabled.
 
     Turn off the coercion optimiser.
 
 .. ghc-flag:: -fno-pre-inlining
+    :shortdesc: Turn off pre-inlining
+    :type: dynamic
+    :category:
+
+    :default: pre-inlining enabled
 
     Turn off pre-inlining.
 
 .. ghc-flag:: -fno-state-hack
+    :shortdesc: Turn off the \state hack\ whereby any lambda with a real-world
+        state token as argument is considered to be single-entry. Hence
+        OK to inline things inside it.
+    :type: dynamic
+    :category:
+
+    :default: state hack is enabled
 
     Turn off the "state hack" whereby any lambda with a ``State#`` token
     as argument is considered to be single-entry, hence it is considered
@@ -415,6 +674,12 @@ list.
     and ST monad code, but it runs the risk of reducing sharing.
 
 .. ghc-flag:: -fomit-interface-pragmas
+    :shortdesc: Don't generate interface pragmas. Implied by :ghc-flag:`-O0` only.
+    :type: dynamic
+    :reverse: -fno-omit-interface-pragmas
+    :category:
+
+    :default: Implied by :ghc-flag:`-O0`, otherwise off.
 
     Tells GHC to omit all inessential information from the interface
     file generated for the module being compiled (say M). This means
@@ -426,8 +691,12 @@ list.
     type, not when they change their implementation).
 
 .. ghc-flag:: -fomit-yields
+    :shortdesc: Omit heap checks when no allocation is being performed.
+    :type: dynamic
+    :reverse: -fno-omit-yields
+    :category:
 
-    :default: on
+    :default: yield points enabled
 
     Tells GHC to omit heap checks when no allocation is
     being performed. While this improves binary sizes by about 5%, it
@@ -438,6 +707,14 @@ list.
     turned off, if you need to guarantee interruptibility.
 
 .. ghc-flag:: -fpedantic-bottoms
+    :shortdesc: Make GHC be more precise about its treatment of bottom (but see
+        also :ghc-flag:`-fno-state-hack`). In particular, GHC will not
+        eta-expand through a case expression.
+    :type: dynamic
+    :reverse: -fno-pedantic-bottoms
+    :category:
+
+    :default: off
 
     Make GHC be more precise about its treatment of bottom (but see also
     :ghc-flag:`-fno-state-hack`). In particular, stop GHC eta-expanding through
@@ -445,6 +722,11 @@ list.
     using ``seq`` on partial applications.
 
 .. ghc-flag:: -fregs-graph
+    :shortdesc: Use the graph colouring register allocator for register
+        allocation in the native code generator. Implied by :ghc-flag:`-O2`.
+    :type: dynamic
+    :reverse: -fno-regs-graph
+    :category:
 
     :default: off due to a performance regression bug (:ghc-ticket:`7679`)
 
@@ -458,6 +740,11 @@ list.
     when faced with code with high register pressure :ghc-ticket:`8657`.
 
 .. ghc-flag:: -fregs-iterative
+    :shortdesc: Use the iterative coalescing graph colouring register allocator
+        in the native code generator.
+    :type: dynamic
+    :reverse: -fno-regs-iterative
+    :category:
 
     :default: off
 
@@ -467,13 +754,20 @@ list.
     as the :ghc-flag:`-fregs-graph` one but also enables iterative coalescing
     during register allocation.
 
-.. ghc-flag:: -fsimplifier-phases=<n>
+.. ghc-flag:: -fsimplifier-phases=⟨n⟩
+    :shortdesc: *default: 2.* Set the number of phases for the simplifier.
+        Ignored with :ghc-flag:`-O0`.
+    :type: dynamic
+    :category:
 
     :default: 2
 
     Set the number of phases for the simplifier. Ignored with ``-O0``.
 
-.. ghc-flag:: -fsimpl-tick-factor=<n>
+.. ghc-flag:: -fsimpl-tick-factor=⟨n⟩
+    :shortdesc: *default: 100.* Set the percentage factor for simplifier ticks.
+    :type: dynamic
+    :category:
 
     :default: 100
 
@@ -494,10 +788,16 @@ list.
     accurately, because some numbers are very large.
 
 .. ghc-flag:: -fspec-constr
+    :shortdesc: Turn on the SpecConstr transformation. Implied by :ghc-flag:`-O2`.
+    :type: dynamic
+    :reverse: -fno-spec-constr
+    :category:
 
-    *Off by default, but enabled by -O2.* Turn on call-pattern
-    specialisation; see `Call-pattern specialisation for Haskell
-    programs <http://research.microsoft.com/en-us/um/people/simonpj/papers/spec-constr/index.htm>`__.
+    :default: off but enabled by :ghc-flag:`-O2`.
+
+    Turn on call-pattern specialisation; see `Call-pattern specialisation for
+    Haskell programs
+    <https://www.microsoft.com/en-us/research/publication/system-f-with-type-equality-coercions-2/>`__.
 
     This optimisation specializes recursive functions according to their
     argument "shapes". This is best explained by example so consider: ::
@@ -555,20 +855,50 @@ list.
     body directly, allowing heavy specialisation over the recursive
     cases.
 
-.. ghc-flag:: -fspec-constr-count=<n>
+.. ghc-flag:: -fspec-constr-keen
+    :shortdesc: Specialize a call with an explicit constructor argument,
+        even if the argument is not scrutinised in the body of the function
+    :type: dynamic
+    :reverse: -fno-spec-constr-keen
+    :category:
+
+    :default: off
+
+    If this flag is on, call-pattern specialisation will specialise a call
+    ``(f (Just x))`` with an explicit constructor argument, even if the argument
+    is not scrutinised in the body of the function. This is sometimes
+    beneficial; e.g. the argument might be given to some other function
+    that can itself be specialised.
+
+.. ghc-flag:: -fspec-constr-count=⟨n⟩
+    :shortdesc: default: 3.* Set to ⟨n⟩ the maximum number of specialisations that
+        will be created for any one function by the SpecConstr
+        transformation.
+    :type: dynamic
+    :reverse: -fno-spec-constr-count
+    :category:
 
     :default: 3
 
     Set the maximum number of specialisations that will be created for
     any one function by the SpecConstr transformation.
 
-.. ghc-flag:: -fspec-constr-threshold=<n>
+.. ghc-flag:: -fspec-constr-threshold=⟨n⟩
+    :shortdesc: *default: 2000.* Set the size threshold for the SpecConstr
+        transformation to ⟨n⟩.
+    :type: dynamic
+    :reverse: -fno-spec-constr-threshold
+    :category:
 
     :default: 2000
 
     Set the size threshold for the SpecConstr transformation.
 
 .. ghc-flag:: -fspecialise
+    :shortdesc: Turn on specialisation of overloaded functions. Implied by :ghc-flag:`-O`.
+    :type: dynamic
+    :reverse: -fno-specialise
+    :category:
 
     :default: on
 
@@ -579,6 +909,11 @@ list.
     specialised as well.
 
 .. ghc-flag:: -fspecialise-aggressively
+    :shortdesc: Turn on specialisation of overloaded functions regardless of
+        size, if unfolding is available
+    :type: dynamic
+    :reverse: -fno-specialise-aggressively
+    :category:
 
     :default: off
 
@@ -591,6 +926,11 @@ list.
 
 
 .. ghc-flag:: -fcross-module-specialise
+    :shortdesc: Turn on specialisation of overloaded functions imported from
+        other modules.
+    :type: dynamic
+    :reverse: -fno-cross-module-specialise
+    :category:
 
     :default: on
 
@@ -599,12 +939,33 @@ list.
     which they are called in this module. Note that specialisation must be
     enabled (by ``-fspecialise``) for this to have any effect.
 
+.. ghc-flag:: -flate-specialise
+    :shortdesc: Run a late specialisation pass
+    :type: dynamic
+    :reverse: -fno-late-specialise
+    :category:
+
+    :default: off
+
+    Runs another specialisation pass towards the end of the optimisation
+    pipeline. This can catch specialisation opportunities which arose from
+    the previous specialisation pass or other inlining.
+
+    You might want to use this if you are you have a type class method
+    which returns a constrained type. For example, a type class where one
+    of the methods implements a traversal.
+
 .. ghc-flag:: -fsolve-constant-dicts
+    :shortdesc: When solving constraints, try to eagerly solve
+        super classes using available dictionaries.
+    :type: dynamic
+    :reverse: -fno-solve-constant-dicts
+    :category:
 
-    :default on
+    :default: on
 
     When solving constraints, try to eagerly solve
-    super classes using availible dictionaries.
+    super classes using available dictionaries.
 
     For example::
 
@@ -619,7 +980,7 @@ list.
     constraint from the context  because we have `C Int b` and that provides us
     a
     solution for `Num Int`. However, we can often produce much better code
-    by directly solving for an availible `Num Int` dictionary we might have at
+    by directly solving for an available `Num Int` dictionary we might have at
     hand. This removes potentially many layers of indirection and crucially
     allows other optimisations to fire as the dictionary will be statically
     known and selector functions can be inlined.
@@ -631,21 +992,82 @@ list.
 
 
 .. ghc-flag:: -fstatic-argument-transformation
+    :shortdesc: Turn on the static argument transformation.
+    :type: dynamic
+    :reverse: -fno-static-argument-transformation
+    :category:
+
+    :default: off
+
+    Turn on the static argument transformation, which turns a recursive function
+    into a non-recursive one with a local recursive loop. See Chapter 7 of
+    `Andre Santos's PhD thesis
+    <https://www.microsoft.com/en-us/research/publication/compilation-transformation-non-strict-functional-languages/>`__.
+
+.. ghc-flag:: -fstg-lift-lams
+    :shortdesc: Enable late lambda lifting on the STG intermediate
+        language. Implied by :ghc-flag:`-O2`.
+    :type: dynamic
+    :reverse: -fno-stg-lift-lams
+    :category:
 
-    Turn on the static argument transformation, which turns a recursive
-    function into a non-recursive one with a local recursive loop. See
-    Chapter 7 of `Andre Santos's PhD
-    thesis <http://research.microsoft.com/en-us/um/people/simonpj/papers/santos-thesis.ps.gz>`__
+    :default: on
+
+    Enables the late lambda lifting optimisation on the STG
+    intermediate language. This selectively lifts local functions to
+    top-level by converting free variables into function parameters.
+
+.. ghc-flag:: -fstg-lift-lams-known
+    :shortdesc: Allow turning known into unknown calls while performing
+        late lambda lifting.
+    :type: dynamic
+    :reverse: -fno-stg-lift-lams-known
+    :category:
+
+    :default: off
+
+    Allow turning known into unknown calls while performing
+    late lambda lifting. This is deemed non-beneficial, so it's
+    off by default.
+
+.. ghc-flag:: -fstg-lift-lams-non-rec-args
+    :shortdesc: Create top-level non-recursive functions with at most <n>
+        parameters while performing late lambda lifting.
+    :type: dynamic
+    :reverse: -fno-stg-lift-lams-non-rec-args-any
+    :category:
+
+    :default: 5
+
+    Create top-level non-recursive functions with at most <n> parameters
+    while performing late lambda lifting. The default is 5, the number of
+    available parameter registers on x86_64.
+
+.. ghc-flag:: -fstg-lift-lams-rec-args
+    :shortdesc: Create top-level recursive functions with at most <n>
+        parameters while performing late lambda lifting.
+    :type: dynamic
+    :reverse: -fno-stg-lift-lams-rec-args-any
+    :category:
+
+    :default: 5
+
+    Create top-level recursive functions with at most <n> parameters
+    while performing late lambda lifting. The default is 5, the number of
+    available parameter registers on x86_64.
 
 .. ghc-flag:: -fstrictness
+    :shortdesc: Turn on strictness analysis.
+        Implied by :ghc-flag:`-O`. Implies :ghc-flag:`-fworker-wrapper`
+    :type: dynamic
+    :reverse: -fno-strictness
+    :category:
 
     :default: on
 
-    Switch on the strictness analyser. There is a very
-    old paper about GHC's strictness analyser, `Measuring the
-    effectiveness of a simple strictness
-    analyser <http://research.microsoft.com/en-us/um/people/simonpj/papers/simple-strictnes-analyser.ps.gz>`__,
-    but the current one is quite a bit different.
+    Switch on the strictness analyser. The implementation is described in the
+    paper `Theory and Practice of Demand Analysis in Haskell
+    <https://www.microsoft.com/en-us/research/wp-content/uploads/2017/03/demand-jfp-draft.pdf>`__.
 
     The strictness analyser figures out when arguments and variables in
     a function can be treated 'strictly' (that is they are always
@@ -655,10 +1077,18 @@ list.
     arguments.
 
 .. ghc-flag:: -fstrictness-before=⟨n⟩
+    :shortdesc: Run an additional strictness analysis before simplifier phase ⟨n⟩
+    :type: dynamic
+    :category:
 
     Run an additional strictness analysis before simplifier phase ⟨n⟩.
 
 .. ghc-flag:: -funbox-small-strict-fields
+    :shortdesc: Flatten strict constructor fields with a pointer-sized
+        representation. Implied by :ghc-flag:`-O`.
+    :type: dynamic
+    :reverse: -fno-unbox-small-strict-fields
+    :category:
 
     :default: on
 
@@ -694,6 +1124,12 @@ list.
     they are technically larger than a pointer on those platforms.
 
 .. ghc-flag:: -funbox-strict-fields
+    :shortdesc: Flatten strict constructor fields
+    :type: dynamic
+    :reverse: -fno-unbox-strict-fields
+    :category:
+
+    :default: off
 
     .. index::
        single: strict constructor fields
@@ -711,7 +1147,13 @@ list.
     it for certain constructor fields using the ``NOUNPACK`` pragma (see
     :ref:`nounpack-pragma`).
 
-.. ghc-flag:: -funfolding-creation-threshold=<n>
+    Alternatively you can use :ghc-flag:`-funbox-small-strict-fields` to only
+    unbox strict fields which are "small".
+
+.. ghc-flag:: -funfolding-creation-threshold=⟨n⟩
+    :shortdesc: *default: 750.* Tweak unfolding settings.
+    :type: dynamic
+    :category:
 
     :default: 750
 
@@ -730,11 +1172,14 @@ list.
     a. nothing larger than this will be inlined (unless it has an ``INLINE`` pragma)
     b. nothing larger than this will be spewed into an interface file.
 
-    Increasing this figure is more likely to result in longer compile
-    times than faster code. The :ghc-flag:`-funfolding-use-threshold` is more
+    Increasing this figure is more likely to result in longer compile times
+    than faster code. The :ghc-flag:`-funfolding-use-threshold=⟨n⟩` is more
     useful.
 
-.. ghc-flag:: -funfolding-dict-discount=<n>
+.. ghc-flag:: -funfolding-dict-discount=⟨n⟩
+    :shortdesc: *default: 30.* Tweak unfolding settings.
+    :type: dynamic
+    :category:
 
     :default: 30
 
@@ -744,7 +1189,10 @@ list.
 
     How eager should the compiler be to inline dictionaries?
 
-.. ghc-flag:: -funfolding-fun-discount=<n>
+.. ghc-flag:: -funfolding-fun-discount=⟨n⟩
+    :shortdesc: *default: 60.* Tweak unfolding settings.
+    :type: dynamic
+    :category:
 
     :default: 60
 
@@ -754,7 +1202,10 @@ list.
 
     How eager should the compiler be to inline functions?
 
-.. ghc-flag:: -funfolding-keeness-factor=<n>
+.. ghc-flag:: -funfolding-keeness-factor=⟨n⟩
+    :shortdesc: *default: 1.5.* Tweak unfolding settings.
+    :type: dynamic
+    :category:
 
     :default: 1.5
 
@@ -764,7 +1215,10 @@ list.
 
     How eager should the compiler be to inline functions?
 
-.. ghc-flag:: -funfolding-use-threshold=<n>
+.. ghc-flag:: -funfolding-use-threshold=⟨n⟩
+    :shortdesc: *default: 60.* Tweak unfolding settings.
+    :type: dynamic
+    :category:
 
     :default: 60
 
@@ -779,37 +1233,24 @@ list.
     minus any discounts that apply depending on the context into which
     the expression is to be inlined.
 
-    The difference between this and :ghc-flag:`-funfolding-creation-threshold`
-    is that this one determines if a function definition will be inlined
-    *at a call site*. The other option determines if a function
-    definition will be kept around at all for potential inlining.
-
-.. ghc-flag:: -fvectorisation-avoidance
-
-    :default: on
-
-    .. index::
-       single: -fvectorisation-avoidance
-
-    Part of :ref:`Data Parallel Haskell (DPH) <dph>`.
+    The difference between this and
+    :ghc-flag:`-funfolding-creation-threshold=⟨n⟩` is that this one determines
+    if a function definition will be inlined *at a call site*. The other option
+    determines if a function definition will be kept around at all for
+    potential inlining.
 
-    Enable the *vectorisation* avoidance optimisation.
-    This optimisation only works when used in combination with the
-    ``-fvectorise`` transformation.
+.. ghc-flag:: -fbinary-blob-threshold=⟨n⟩
+    :shortdesc: *default: 500K.* Tweak assembly generator for binary blobs.
+    :type: dynamic
+    :category: optimization
 
-    While vectorisation of code using DPH is often a big win, it can
-    also produce worse results for some kinds of code. This optimisation
-    modifies the vectorisation transformation to try to determine if a
-    function would be better of unvectorised and if so, do just that.
-
-.. ghc-flag:: -fvectorise
-
-    :default: off
+    :default: 500000
 
-    Part of :ref:`Data Parallel Haskell (DPH) <dph>`.
+    The native code-generator can either dump binary blobs (e.g. string
+    literals) into the assembly file (by using ".asciz" or ".string" assembler
+    directives) or it can dump them as binary data into a temporary file which
+    is then included by the assembler (using the ".incbin" assembler directive).
 
-    Enable the *vectorisation* optimisation
-    transformation. This optimisation transforms the nested data
-    parallelism code of programs using DPH into flat data parallelism.
-    Flat data parallel programs should have better load balancing,
-    enable SIMD parallelism and friendlier cache behaviour.
+    This flag sets the size (in bytes) threshold above which the second approach
+    is used. You can disable the second approach entirely by setting the
+    threshold to 0.