GitLab

o Moved BlockId stuff to a new file to avoid module recursion
o Defined stack areas for parameter-passing locations and spill slots
o Part way through replacing copy in and copy out nodes
  - added movement instructions for stack pointer
  - added movement instructions for call and return parameters
    (but not with the proper calling conventions)
o Inserting spills and reloads for proc points is now procpoint-aware
  (it was relying on the presence of a CopyIn node as a proxy for
   procpoint knowledge)
o Changed ZipDataflow to expect AGraphs (instead of being polymorphic in
   the type of graph)

It was (panic "RegisterAlloc.joinToTargets"), but had since moved to
RegAllocLinear.makeRegMovementGraph.

Modules that need it import it themselves instead.

If these modules use UniqFM then we get a stack overflow when compiling
modules that use fundeps. I haven't tracked down the actual cause.

If these modules use UniqFM then we get a stack overflow when compiling
modules that use fundeps. I haven't tracked down the actual cause.

Fixes building with -Werror (i.e. validate) and GHC < 6.6

I've renamed a number of type and data constructors within Cmm so that
the names used in the compiler may more closely reflect the C--
specification 2.1.  I've done a bit of other renaming as well.
Highlights:

  CmmFormal and CmmActual now bear a CmmKind (which for now is a
                                              MachHint as before)
  CmmFormals = [CmmFormal] and CmmActuals = [CmmActual]
  
  suitable changes have been made to both code and nonterminals in the
  Cmm parser (which is as yet untested)

  For reasons I don't understand, parts of the code generator use a
  sequence of 'formal parameters' with no C-- kinds.  For these we now
  have the types
    type CmmFormalWithoutKind   = LocalReg
    type CmmFormalsWithoutKinds = [CmmFormalWithoutKind]

  A great many appearances of (Tau, MachHint) have been simplified to
  the appropriate CmmFormal or CmmActual, though I'm sure there are
  more opportunities.

  Kind and its data constructors are now renamed to
     data GCKind = GCKindPtr | GCKindNonPtr 
  to avoid confusion with the Kind used in the type checker and with CmmKind.

Finally, in a somewhat unrelated bit (and in honor of Simon PJ, who
thought of the name), the Whalley/Davidson 'transaction limit' is now
called 'OptimizationFuel' with the net effect that there are no longer
two unrelated uses of the abbreviation 'tx'.

trivColorable was soaking up total 31% time, 41% alloc when
compiling SHA1.lhs with -O2 -fregs-graph on x86.

Refactoring to use unboxed accumulators and walk directly
over the UniqFM holding the set of conflicts reduces this 
to 17% time, 6% alloc.

The type parameter to a C-- procedure now represents a control-flow
graph, not a single instruction.  The newtype ListGraph preserves the 
current representation while enabling other representations and a
sensible way of prettyprinting.  Except for a few changes in the
prettyprinter the new compiler binary should be bit-for-bit identical
to the old.

Older GHCs can't parse OPTIONS_GHC.
This also changes the URL referenced for the -w options from
WorkingConventions#Warnings to CodingStyle#Warnings for the compiler
modules.

Linear register allocator now keeps track of why it spilled certain 
registers. It had to be refactored somewhat to thread the information
through, but the algorithm is unchanged.

Refactored linear allocator into separate liveness annotation and allocation stages.
Added graph coloring allocator, use -fregs-graph to enable.
  New dump flags are
    -ddump-asm-native          -- output of cmm -> native transform.
    -ddump-asm-liveness        -- code annotated with register liveness info
    -ddump-asm-coalesce        -- output of register move coalescing
                                    (this is a separate pass when using the coloring allocator)
                                    (this could change in the future)
    -ddump-asm-regalloc        -- code after register allocation
    -ddump-asm-regalloc-stages -- blocks after each build/spill stage of coloring allocator
    -ddump-asm-conflicts       -- a global register liveness graph in graphviz format 
        
The new register allocator will allocate some registers, but it's not
quite ready for prime-time yet. The spill code generator needs some work...

First, cycles can only start of with registers and their destination
must involve a register location. This is because memory locations are
allocated exclusively for a virtual register and hence can never cause
a conflict in the assignment, hence need no fixup code. Therefore, we
only have to deal with InReg -> InReg, or InReg -> InReg/InMem
movements.  

The strategy is to take the first cycle element, which is guaranteed
to start with a register, spill it to a fresh memory location, compute
the fixup for the rest, and restore from the spill slot to its
destinations. The "rest" will degenerate into an acyclic scc, so we do
not need take care of the empty list case in CyclicScc. 
 ***END OF DESCRIPTION***

Place the long patch description above the ***END OF DESCRIPTION*** marker.
The first line of this file will be the patch name.


This patch contains the following changes:

M ./compiler/nativeGen/RegisterAlloc.hs -6 +27

We were being overly conservative, registers that were live only at a
branch target were not recorded as being dead in the branch-not-taken
code.

This is a follow-up to "NCG: Handle loops in register allocator".
The newly-introduced invariant that every virtual register is always assigned to
the same spill slot wasn't kept under all circumstances.
*Now* memory-to-memory moves should never be required when compiling hand-written
cmm code.

Push this further along, and fix build problems in the first patch.

We weren't handling InBoth properly.  InBoth needs to be expanded to
appropriate InReg/InMem locations *before* building the interference
graph, otherwise an InBoth will not be seen to conflict with other
InReg/InMem locations.

Most of the other users of the fptools build system have migrated to
Cabal, and with the move to darcs we can now flatten the source tree
without losing history, so here goes.

The main change is that the ghc/ subdir is gone, and most of what it
contained is now at the top level.  The build system now makes no
pretense at being multi-project, it is just the GHC build system.

No doubt this will break many things, and there will be a period of
instability while we fix the dependencies.  A straightforward build
should work, but I haven't yet fixed binary/source distributions.
Changes to the Building Guide will follow, too.

Fix previous patch "NCG: Handle loops in register allocator"
Of course, I broke it when correcting a style problem just before committing.

Fill in the missing parts in the register allocator so that it can
handle loops.

*) The register allocator now runs in the UniqSuppy monad, as it needs
   to be able to generate unique labels for fixup code blocks.

*) A few functions have been added to RegAllocInfo:
	mkRegRegMoveInstr -- generates a good old move instruction
	mkBranchInstr     -- used to be MachCodeGen.genBranch
	patchJump         -- Change the destination of a jump

*) The register allocator now makes sure that only one spill slot is used
   for each temporary, even if it is spilled and reloaded several times.
   This obviates the need for memory-to-memory moves in fixup code.

LIMITATIONS:

*) The case where the fixup code needs to cyclically permute a group of
   registers is currently unhandled. This will need more work once we come
   accross code where this actually happens.

*) Register allocation for code with loop is probably very inefficient
   (both at compile-time and at run-time).

*) We still cannot compile the RTS via NCG, for various other reasons.

Missing Show instance for FreeRegs on PowerPC

PowerPC: track changes in the rest of the register allocator

some small optimisations

Undo accidental commit