Initial live range computation based on dataflow analysis.

This uses a dataflow algorithm to compute the live set at the
beginning of each basic block.  For a given basic block, initialize
the live set to be the union of the successors' live sets, then
iterate backwards through the instruction list and incrementally
update the live set.  Set this block's live set to the union of the
result and its old live set, and if the live set changed, mark that
the predecessor blocks need to be recomputed.  Continue until no more
blocks need to be recomputed.

IceCfg::translate() computes liveness at some arbitrarily chosen point
just for testing, and beginning-of-block liveness is printed in the
dump() routines.

A few more things are needed:

- This also allows dead instruction elimination.  In most cases, if
  the instruction's destination operands are not live, the instruction
  can be marked as dead and its operands not marked as live.
  Exceptions include call instructions, volatile loads, and perhaps
  exception-producing instructions like load, idiv, and irem.

- Take into account the fully-deleted and maybe-dead flags for each
  instruction.

- After convergence, we need one final pass over all instructions to
  officially delete instructions that were marked as dead, and to
  actually record the live instruction ranges for each variable.

- It's less efficient than I'd like to find the phi operands for a
  node's out-edges.
Add *.o, subzerotest, and llvm2ice to .gitignore.