This means that we now generate the same code whatever platform we are
on, which should help avoid changes on one platform breaking the build
on another.

It's also another step towards full cross-compilation.

This is a bit odd by itself, but it's a stepping stone on the way to
putting "target unregisterised" into the settings file.

See Note [shortcut call returns]

Instead of relying on common-block-elimination to share return
continuations in the common case (case-alternative heap checks) we do
it explicitly.  This isn't hard to do, is more robust, and saves some
compilation time.  Full commentary in Note [sharing continuations].

Proc-point splitting is only required by backends that do not support
having proc-points within a code block (that is, everything except the
native backend, i.e. LLVM and C).

Not doing proc-point splitting saves some compilation time, and might
produce slightly better code in some cases.

All the flags that 'ways' imply are now dynamic

We can now get the Platform from the DynFlags inside an SDoc, so we
no longer need to pass the Platform in.

Also, do removeDeadAssignments instead of cmmLiveness before stack
allocation, because the former also does liveness analysis, and we can
do just one liveness analysis instead of two.  The stack layout
algorithm doesn't introduce any dead assignments, so this doesn't
affect the generated code.

Also:
 - improvements to code generation: push slow-call continuations
   on the stack instead of generating explicit continuations

 - remove unused CmmInfo wrapper type (replace with CmmInfoTable)

 - squash Area and AreaId together, remove now-unused RegSlot

 - comment out old unused stack-allocation code that no longer
   compiles after removal of RegSlot

It was causing wrong info tables where it was; I'm not entirely sure
why.

This is so that we can process the Stg code in constant space.  Before
we were generating all the C-- up front, leading to a large space
leak.

I haven't converted the LLVM or C back ends to the incremental scheme,
but it's not hard to do.

And some knock-on changes

Simon Peyton Jones authored Aug 23, 2011 and Simon Marlow committed Aug 25, 2011

   CmmTop -> CmmDecl
   CmmPgm -> CmmGroup

There's now a variant of the Outputable class that knows what
platform we're targetting:

class PlatformOutputable a where
    pprPlatform :: Platform -> a -> SDoc
    pprPlatformPrec :: Platform -> Rational -> a -> SDoc

and various instances have had to be converted to use that class,
and we pass Platform around accordingly.

    * Move dead assignment elimination to CmmLive
    * Kill off dead code in CmmSpillReload related
      to non-splitting procpoints case
    * Refactor dual liveness transfer function to
      more closely mimic CmmLive's liveness transfer.

Signed-off-by: Edward Z. Yang <ezyang@mit.edu>

Signed-off-by: Edward Z. Yang <ezyang@mit.edu>

Signed-off-by: Edward Z. Yang <ezyang@mit.edu>

Signed-off-by: Edward Z. Yang <ezyang@mit.edu>

Unfortunately, I couldn't remove all incidences of runCmmContFlowOpt
from HscMain; in particular, there is a Cmm conversion testing
facility which may run with only control flow optimizations, which
I preserved the semantics of.  Given the state of the current
codegen, this code might be moribund anyway.

Signed-off-by: Edward Z. Yang <ezyang@mit.edu>