Fix PR3667

[oota-llvm.git] / lib / CodeGen / SimpleRegisterCoalescing.h

diff --git a/lib/CodeGen/SimpleRegisterCoalescing.h b/lib/CodeGen/SimpleRegisterCoalescing.h
index a4f0fa3f2feb4a03cd36bf1b890c3dd7114ce575..9e55c220034bca93ffcfb9fb53f849f238c29535 100644 (file)
--- a/lib/CodeGen/SimpleRegisterCoalescing.h
+++ b/lib/CodeGen/SimpleRegisterCoalescing.h
@@ -173,12 +173,8 @@ namespace llvm {
     bool SimpleJoin(LiveInterval &LHS, LiveInterval &RHS);
     
     /// Return true if the two specified registers belong to different register
-    /// classes.  The registers may be either phys or virt regs. In the
-    /// case where both registers are virtual registers, it would also returns
-    /// true by reference the RegB register class in SubRC if it is a subset of
-    /// RegA's register class.
-    bool differingRegisterClasses(unsigned RegA, unsigned RegB,
-                                  const TargetRegisterClass *&SubRC) const;
+    /// classes.  The registers may be either phys or virt regs.
+    bool differingRegisterClasses(unsigned RegA, unsigned RegB) const;
 
 
     /// AdjustCopiesBackFrom - We found a non-trivially-coalescable copy. If
@@ -200,6 +196,15 @@ namespace llvm {
     bool RemoveCopyByCommutingDef(LiveInterval &IntA, LiveInterval &IntB,
                                   MachineInstr *CopyMI);
 
+    /// TrimLiveIntervalToLastUse - If there is a last use in the same basic
+    /// block as the copy instruction, trim the ive interval to the last use
+    /// and return true.
+    bool TrimLiveIntervalToLastUse(unsigned CopyIdx,
+                                   MachineBasicBlock *CopyMBB,
+                                   LiveInterval &li, const LiveRange *LR);
+
+    /// ReMaterializeTrivialDef - If the source of a copy is defined by a trivial
+    /// computation, replace the copy by rematerialize the definition.
     bool ReMaterializeTrivialDef(LiveInterval &SrcInt, unsigned DstReg,
                                  MachineInstr *CopyMI);
 
@@ -219,11 +224,10 @@ namespace llvm {
     /// identity copies so they will be removed.
     void RemoveCopiesFromValNo(LiveInterval &li, VNInfo *VNI);
 
-    /// isProfitableToCoalesceToSubRC - Given that register class of DstReg is
-    /// a subset of the register class of SrcReg, return true if it's profitable
-    /// to coalesce the two registers.
-    bool isProfitableToCoalesceToSubRC(unsigned SrcReg, unsigned DstReg,
-                                       MachineBasicBlock *MBB);
+    /// isWinToJoinCrossClass - Return true if it's profitable to coalesce
+    /// two virtual registers from different register classes.
+    bool isWinToJoinCrossClass(unsigned LargeReg, unsigned SmallReg,
+                               unsigned Threshold);
 
     /// HasIncompatibleSubRegDefUse - If we are trying to coalesce a virtual
     /// register with a physical register, check if any of the virtual register
@@ -235,15 +239,13 @@ namespace llvm {
     /// CanJoinExtractSubRegToPhysReg - Return true if it's possible to coalesce
     /// an extract_subreg where dst is a physical register, e.g.
     /// cl = EXTRACT_SUBREG reg1024, 1
-    bool CanJoinExtractSubRegToPhysReg(MachineInstr *CopyMI,
-                                       unsigned DstReg, unsigned SrcReg,
+    bool CanJoinExtractSubRegToPhysReg(unsigned DstReg, unsigned SrcReg,
                                        unsigned SubIdx, unsigned &RealDstReg);
 
     /// CanJoinInsertSubRegToPhysReg - Return true if it's possible to coalesce
     /// an insert_subreg where src is a physical register, e.g.
     /// reg1024 = INSERT_SUBREG reg1024, c1, 0
-    bool CanJoinInsertSubRegToPhysReg(MachineInstr *CopyMI,
-                                      unsigned DstReg, unsigned SrcReg,
+    bool CanJoinInsertSubRegToPhysReg(unsigned DstReg, unsigned SrcReg,
                                       unsigned SubIdx, unsigned &RealDstReg);
 
     /// RangeIsDefinedByCopyFromReg - Return true if the specified live range of