The -O* options specify convenient
    “packages” of optimisation flags; the
    -f* options described later on specify
    individual optimisations to be turned on/off;
    the -m* options specify
    machine-specific optimisations to be turned
    on/off.
There are many options that affect the quality of code produced by GHC. Most people only have a general goal, something like “Compile quickly” or “Make my program run like greased lightning.” The following “packages” of optimisations (or lack thereof) should suffice.
Note that higher optimisation levels cause more cross-module 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.
-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
-O0:
            
          Means “turn off all optimisation”,
            reverting to the same settings as if no
            -O options had been specified.  Saying
            -O0 can be useful if
            eg. make has inserted a
            -O on the command line already.
-O or -O1:
            
            
            
          Means: “Generate good-quality code without taking too long about it.” Thus, for example: ghc -c -O Main.lhs
-O2:
            
            
          Means: “Apply every non-dangerous optimisation, even if it means significantly longer compile times.”
The avoided “dangerous” optimisations are those that can make runtime or space worse if you're unlucky. They are normally turned on or off individually.
At the moment, -O2 is
            unlikely to produce better code than
            -O.
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 breaks).
The easiest way to see what -O (etc.)
      “really mean” is to run with -v,
      then stand back in amazement.
These flags turn on and off individual optimisations.
      They are normally set via the -O options
      described above, and as such, you shouldn't need to set any of
      them explicitly (indeed, doing so could lead to unexpected
      results).  A flag -fwombat can be negated by 
      saying -fno-wombat.  The flags below are off
      by default, except where noted below.
     
-fcse
            
          On by default..  Enables the common-sub-expression 
            elimination optimisation.
            Switching this off can be useful if you have some unsafePerformIO
            expressions that you don't want commoned-up.
-fstrictness
            
          On by default.. Switch on the strictness analyser. There is a very old paper about GHC's strictness analyser, Measuring the effectiveness of a simple strictness analyser, but the current one is quite a bit different.
The strictness analyser figures out when arguments and variables in a function can be treated 'strictly' (that is they are always evaluated in the function at some point). This allow GHC to apply certain optimisations such as unboxing that otherwise don't apply as they change the semantics of the program when applied to lazy arguments.
-funbox-strict-fields:
            
            
            
          This option causes all constructor fields which are marked
            strict (i.e. “!”) to be unpacked if possible. It is
            equivalent to adding an UNPACK pragma to every
            strict constructor field (see Section 7.18.10, “UNPACK pragma”).
            
This option is a bit of a sledgehammer: it might sometimes
            make things worse. Selectively unboxing fields by using
            UNPACK pragmas might be better. An alternative
            is to use -funbox-strict-fields to turn on
            unboxing by default but disable it for certain constructor
            fields using the NOUNPACK pragma (see
            Section 7.18.11, “NOUNPACK pragma”).
-fspec-constr
            
          Off by default, but enabled by -O2. Turn on call-pattern specialisation; see Call-pattern specialisation for Haskell programs.
This optimisation specializes recursive functions according to their argument "shapes". This is best explained by example so consider:
last :: [a] -> a last [] = error "last" last (x : []) = x last (x : xs) = last xs
            In this code, once we pass the initial check for an empty list we
            know that in the recursive case this pattern match is redundant. As
            such -fspec-constr will transform the above code
            to:
last :: [a] -> a
last []       = error "last"
last (x : xs) = last' x xs
    where
      last' x []       = x
      last' x (y : ys) = last' y ys
As well avoid unnecessary pattern matching it also helps avoid unnecessary allocation. This applies when a argument is strict in the recursive call to itself but not on the initial entry. As strict recursive branch of the function is created similar to the above example.
-fspecialise
            
          On by default. Specialise each type-class-overloaded function defined in this module for the types at which it is called in this module. Also specialise imported functions that have an INLINABLE pragma (Section 7.18.5.2, “INLINABLE pragma”) for the types at which they are called in this module.
-fstatic-argument-transformation
            
          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
-ffloat-in
            
          On by default. Float let-bindings inwards, nearer their binding site. See Let-floating: moving bindings to give faster programs (ICFP'96).
This optimisation moves let bindings closer to their use site. The benefit here is that this may avoid unnecessary allocation if the branch the let is now on is never executed. It also enables other optimisation passes to work more effectively as they have more information locally.
This optimisation isn't always beneficial though (so GHC applies some heuristics to decide when to apply it). The details get complicated but a simple example is that it is often beneficial to move let bindings outwards so that multiple let bindings can be grouped into a larger single let binding, effectively batching their allocation and helping the garbage collector and allocator.
-ffull-laziness
            
          On by default. Run the full laziness optimisation (also known as let-floating), which floats let-bindings outside enclosing lambdas, in the hope they will be thereby be computed less often. See Let-floating: moving bindings to give faster programs (ICFP'96). Full laziness increases sharing, which can lead to increased memory residency.
NOTE: GHC doesn't implement complete full-laziness.
            When optimisation in on, and -fno-full-laziness
            is not given, some transformations that increase sharing are
            performed, such as extracting repeated computations from a loop.
            These are the same transformations that a fully lazy
            implementation would do, the difference is that GHC doesn't
            consistently apply full-laziness, so don't rely on it.
            
-fdo-lambda-eta-expansion
            
          On by default. Eta-expand let-bindings to increase their arity.
-fdo-eta-reduction
            
          On by default. Eta-reduce lambda expressions, if doing so gets rid of a whole group of lambdas.
-fcase-merge
            
          On by default. Merge immediately-nested case expressions that scrutinse the same variable. Example
  case x of
     Red -> e1
     _   -> case x of 
              Blue -> e2
              Green -> e3
==>
  case x of
     Red -> e1
     Blue -> e2
     Green -> e2
-fliberate-case
            
          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
            (-fspec-constr) but for free variables rather than
            arguments.
            
-fdicts-cheap
            
          A very experimental flag that makes dictionary-valued expressions seem cheap to the optimiser.
-feager-blackholing
            
          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.
-fno-state-hack
            
          Turn off the "state hack" whereby any lambda with a
            State# token as argument is considered to be
            single-entry, hence it is considered OK to inline things inside
            it. This can improve performance of IO and ST monad code, but it
            runs the risk of reducing sharing.
            
-fpedantic-bottoms
            
          Make GHC be more precise about its treatment of bottom (but see also
            -fno-state-hack). In particular, stop GHC
            eta-expanding through a case expression, which is good for
            performance, but bad if you are using seq on
            partial applications.
            
-fsimpl-tick-factor=n
            
          GHC's optimiser can diverge if you write rewrite rules (
              Section 7.19, “Rewrite rules
”) that don't terminate, or (less
            satisfactorily) if you code up recursion through data types
            (Section 14.2.1, “Bugs in GHC”).  To avoid making the compiler fall
            into an infinite loop, the optimiser carries a "tick count" and
            stops inlining and applying rewrite rules when this count is
            exceeded.  The limit is set as a multiple of the program size, so
            bigger programs get more ticks. The
            -fsimpl-tick-factor flag lets you change the
            multiplier. The default is 100; numbers larger than 100 give more
            ticks, and numbers smaller than 100 give fewer.
            
If the tick-count expires, GHC summarises what simplifier
            steps it has done; you can use
            -fddump-simpl-stats to generate a much more
            detailed list.  Usually that identifies the loop quite
            accurately, because some numbers are very large.
            
-funfolding-creation-threshold=n:
            
            
            
          (Default: 45) Governs the maximum size that GHC will allow a function unfolding to be. (An unfolding has a “size” that reflects the cost in terms of “code bloat” of expanding (aka inlining) that unfolding at a call site. A bigger function would be assigned a bigger cost.)
Consequences: (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
            -funfolding-use-threshold is more useful.
            
-funfolding-use-threshold=n
            
            
            
          (Default: 8) This is the magic cut-off figure for unfolding
            (aka inlining): below this size, a function definition will be
            unfolded at the call-site, any bigger and it won't. The size
            computed for a function depends on two things: the actual size of
            the expression minus any discounts that
            apply (see -funfolding-con-discount).
            
The difference between this and
            -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.
            
-fexpose-all-unfoldings
            
          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.
-fvectorise
            
          Data Parallel Haskell.
TODO: Document optimisation-favoid-vect
            
          Data Parallel Haskell.
TODO: Document optimisation-fregs-graph
            
          Off by default, but enabled by -O2. Only applies in combination with the native code generator. Use the graph colouring register allocator for register allocation in the native code generator. By default, GHC uses a simpler, faster linear register allocator. The downside being that the linear register allocator usually generates worse code.
-fregs-iterative
            
          Off by default, only applies in combination with
              the native code generator.
            Use the iterative coalescing graph colouring register allocator for
            register allocation in the native code generator. This is the same
            register allocator as the -freg-graph one but also
            enables iterative coalescing during register allocation.
            
-fexcess-precision
            
          When this option is given, intermediate floating
            point values can have a greater
            precision/range than the final type.  Generally this is a
            good thing, but some programs may rely on the exact
            precision/range of
            Float/Double values
            and should not use this option for their compilation.
              Note that the 32-bit x86 native code generator only
              supports excess-precision mode, so neither
              -fexcess-precision nor
              -fno-excess-precision has any effect.
              This is a known bug, see Section 14.2.1, “Bugs in GHC”.
            
-fignore-asserts
            
          Causes GHC to ignore uses of the function
            Exception.assert in source code (in
            other words, rewriting Exception.assert p
            e to e (see Section 7.17, “Assertions
”).  This flag is turned on by
            -O.
            
-fignore-interface-pragmas
            
          Tells GHC to ignore all inessential information when reading interface files.
            That is, even if M.hi contains unfolding or strictness information
            for a function, GHC will ignore that information.
-fomit-interface-pragmas
            
          Tells GHC to omit all inessential information from the interface file generated for the module being compiled (say M). This means that a module importing M will see only the types of the functions that M exports, but not their unfoldings, strictness info, etc. Hence, for example, no function exported by M will be inlined into an importing module. The benefit is that modules that import M will need to be recompiled less often (only when M's exports change their type, not when they change their implementation).