[llvm-commits] CVS: llvm/include/llvm/CodeGen/LiveVariables.h

[Chris Lattner]

Changes in directory llvm/include/llvm/CodeGen:

LiveVariables.h updated: 1.27 -> 1.28
---
Log message:

add a comment that I should have written a long time ago


---
Diffs of the changes:  (+28 -0)

 LiveVariables.h |   28 ++++++++++++++++++++++++++++
 1 files changed, 28 insertions(+)


Index: llvm/include/llvm/CodeGen/LiveVariables.h
diff -u llvm/include/llvm/CodeGen/LiveVariables.h:1.27 llvm/include/llvm/CodeGen/LiveVariables.h:1.28
--- llvm/include/llvm/CodeGen/LiveVariables.h:1.27	Tue Jan  3 23:39:51 2006
+++ llvm/include/llvm/CodeGen/LiveVariables.h	Wed Jan  4 01:29:33 2006
@@ -38,6 +38,34 @@
 
 class LiveVariables : public MachineFunctionPass {
 public:
+  /// VarInfo - This represents the regions where a virtual register is live in
+  /// the program.  We represent this with three difference pieces of
+  /// information: the instruction that uniquely defines the value, the set of
+  /// blocks the instruction is live into and live out of, and the set of 
+  /// non-phi instructions that are the last users of the value.
+  ///
+  /// In the common case where a value is defined and killed in the same block,
+  /// DefInst is the defining inst, there is one killing instruction, and 
+  /// AliveBlocks is empty.
+  ///
+  /// Otherwise, the value is live out of the block.  If the value is live
+  /// across any blocks, these blocks are listed in AliveBlocks.  Blocks where
+  /// the liveness range ends are not included in AliveBlocks, instead being
+  /// captured by the Kills set.  In these blocks, the value is live into the
+  /// block (unless the value is defined and killed in the same block) and lives
+  /// until the specified instruction.  Note that there cannot ever be a value
+  /// whose Kills set contains two instructions from the same basic block.
+  ///
+  /// PHI nodes complicate things a bit.  If a PHI node is the last user of a
+  /// value in one of its predecessor blocks, it is not listed in the kills set,
+  /// but does include the predecessor block in the AliveBlocks set (unless that
+  /// block also defines the value).  This leads to the (perfectly sensical)
+  /// situation where a value is defined in a block, and the last use is a phi
+  /// node in the successor.  In this case, DefInst will be the defining
+  /// instruction, AliveBlocks is empty (the value is not live across any 
+  /// blocks) and Kills is empty (phi nodes are not included).  This is sensical
+  /// because the value must be live to the end of the block, but is not live in
+  /// any successor blocks.
   struct VarInfo {
     /// DefInst - The machine instruction that defines this register.
     ///