Include PHINode operands in liveness analysis.

Until now we've ignored PHINode operands inside our liveness analysis,
since the algorithm we are using did not consider SSA. With the recent
change in yk which uses stackmap calls to collect live values for
deoptimisation, we no longer get away with this.

The difficulty with PHINodes, is that marking their operands live means the
backwards running liveness algorithm will consider values live in blocks
where they can never appear. For example, let's consider a branch in a
block A splitting to block B and C, which then both diverge into block D.
The PHINode at the beginning of block D might look like this:

`%10 = phi [B, %5], [C, %7]`

The backwards running pass would now consider `%5` and `%7` live in both
block B and C, even though only one of the values was defined in each. This
is incorrect and leads to non-existing values inside some stackmap calls.

The fix is relatively simple. At the end of each block we mark each value
that wasn't defined inside this block as if it was. For example, at the end
of block B we mark `%7` as defined, and do the same for block C and value
`%5`. This means the backwards pass immediately kills those values when
entering the block, which means the non-existing values are no longer live
at that point and won't be inserted into any earlier stackmap calls.

Author: ptersilie

llvm/lib/Transforms/Yk/LivenessAnalysis.cpp

@@ -77,14 +77,36 @@ LivenessAnalysis::LivenessAnalysis(Function *Func) {
 
       // Record what this instruction uses.
       //
-      // Note that Phi nodes are special and must be skipped. If we consider
-      // their operands as uses, then Phi nodes in loops may use variables
-      // before they are defined, and this messes with the algorithm.
+      // In order to track the operands of PHI nodes we need to be a bit crafty
+      // as otherwise we end up with live values in blocks where they actually
+      // don't exist. To avoid this, we need to mark as live any PHI operand
+      // from one block at the end of all other blocks. This leads to those
+      // values being killed immediately after entering the block in the
+      // backwards pass and thus the value never being live there.
       //
       // The book doesn't cover this quirk, as it explains liveness for
       // non-SSA form, and thus doesn't need to worry about Phi nodes.
-      if (isa<PHINode>(I))
+      if (isa<PHINode>(I)) {
+        PHINode *P = cast<PHINode>(&I);
+        for (unsigned IVC = 0; IVC < P->getNumIncomingValues(); IVC++) {
+          BasicBlock *IBB = P->getIncomingBlock(IVC);
+          Value *IV = P->getIncomingValue(IVC);
+          if (isa<Constant>(IV)) {
+            continue;
+          }
+          // For each block that isn't the incoming block create a Def for this
+          // value. This means when we do the backwards liveness pass this
+          // value is immediately killed in the block.
+          for (auto *BBB = P->block_begin(); BBB != P->block_end(); BBB++) {
+            if (*BBB != IBB) {
+              Instruction *Last = &((*BBB)->back());
+              Defs[Last].insert(IV);
+            }
+          }
+          Uses[&I].insert(IV);
+        }
         continue;
+      }
 
       for (auto *U = I.op_begin(); U < I.op_end(); U++)
         if ((!isa<Constant>(U)) && (!isa<BasicBlock>(U)) &&