First cut at TargetMachineRegistry and RegisterTarget classes

[oota-llvm.git] / include / llvm / Target / MRegisterInfo.h

diff --git a/include/llvm/Target/MRegisterInfo.h b/include/llvm/Target/MRegisterInfo.h
index 3217b47b7299212ecca1e48cd62e4f713baf7586..af62c13bddd06a99d96a63c80427d1af76155273 100644 (file)
--- a/include/llvm/Target/MRegisterInfo.h
+++ b/include/llvm/Target/MRegisterInfo.h
@@ -18,11 +18,13 @@
 
 #include "llvm/CodeGen/MachineBasicBlock.h"
 #include <cassert>
+#include <functional>
 
 namespace llvm {
 
 class Type;
 class MachineFunction;
+class MachineInstr;
 
 /// MRegisterDesc - This record contains all of the information known about a
 /// particular register.  The AliasSet field (if not null) contains a pointer to
@@ -136,6 +138,20 @@ public:
     FirstVirtualRegister = 1024,
   };
 
+  /// isPhysicalRegister - Return true if the specified register number is in
+  /// the physical register namespace.
+  static bool isPhysicalRegister(unsigned Reg) {
+    assert(Reg && "this is not a register!");
+    return Reg < FirstVirtualRegister;
+  }
+
+  /// isVirtualRegister - Return true if the specified register number is in
+  /// the virtual register namespace.
+  static bool isVirtualRegister(unsigned Reg) {
+    assert(Reg && "this is not a register!");
+    return Reg >= FirstVirtualRegister;
+  }
+
   const MRegisterDesc &operator[](unsigned RegNo) const {
     assert(RegNo < NumRegs &&
            "Attempting to access record for invalid register number!");
@@ -170,6 +186,20 @@ public:
     return get(RegNo).Name;
   }
 
+  /// getNumRegs - Return the number of registers this target has
+  /// (useful for sizing arrays holding per register information)
+  unsigned getNumRegs() const {
+    return NumRegs;
+  }
+
+  /// areAliases - Returns true if the two registers alias each other,
+  /// false otherwise
+  bool areAliases(unsigned regA, unsigned regB) const {
+    for (const unsigned *Alias = getAliasSet(regA); *Alias; ++Alias)
+      if (*Alias == regB) return true;
+    return false;
+  }
+
   virtual const unsigned* getCalleeSaveRegs() const = 0;
 
 
@@ -208,21 +238,33 @@ public:
   //
 
   virtual int storeRegToStackSlot(MachineBasicBlock &MBB,
-                                  MachineBasicBlock::iterator &MBBI,
+                                  MachineBasicBlock::iterator MI,
                                   unsigned SrcReg, int FrameIndex,
                                   const TargetRegisterClass *RC) const = 0;
 
   virtual int loadRegFromStackSlot(MachineBasicBlock &MBB,
-                                   MachineBasicBlock::iterator &MBBI,
+                                   MachineBasicBlock::iterator MI,
                                    unsigned DestReg, int FrameIndex,
                                    const TargetRegisterClass *RC) const = 0;
 
   virtual int copyRegToReg(MachineBasicBlock &MBB,
-                           MachineBasicBlock::iterator &MBBI,
+                           MachineBasicBlock::iterator MI,
                            unsigned DestReg, unsigned SrcReg,
                            const TargetRegisterClass *RC) const = 0;
 
 
+  /// foldMemoryOperand - Attempt to fold a load or store of the
+  /// specified stack slot into the specified machine instruction for
+  /// the specified operand.  If this is possible, a new instruction
+  /// is returned with the specified operand folded, otherwise NULL is
+  /// returned. The client is responsible for removing the old
+  /// instruction and adding the new one in the instruction stream
+  virtual MachineInstr* foldMemoryOperand(MachineInstr* MI,
+                                          unsigned OpNum,
+                                          int FrameIndex) const {
+    return NULL;
+  }
+
   /// getCallFrameSetup/DestroyOpcode - These methods return the opcode of the
   /// frame setup/destroy instructions if they exist (-1 otherwise).  Some
   /// targets use pseudo instructions in order to abstract away the difference
@@ -241,14 +283,14 @@ public:
   /// setup/destroy pseudo instructions. The return value is the number of
   /// instructions added to (negative if removed from) the basic block.
   ///
-  virtual int eliminateCallFramePseudoInstr(MachineFunction &MF,
-                                            MachineBasicBlock &MBB,
-                                         MachineBasicBlock::iterator &I) const {
+  virtual void 
+  eliminateCallFramePseudoInstr(MachineFunction &MF,
+                                MachineBasicBlock &MBB,
+                                MachineBasicBlock::iterator MI) const {
     assert(getCallFrameSetupOpcode()== -1 && getCallFrameDestroyOpcode()== -1 &&
           "eliminateCallFramePseudoInstr must be implemented if using"
           " call frame setup/destroy pseudo instructions!");
     assert(0 && "Call Frame Pseudo Instructions do not exist on this target!");
-    return -1;
   }
 
   /// processFunctionBeforeFrameFinalized - This method is called immediately
@@ -258,8 +300,7 @@ public:
   /// is the number of instructions added to (negative if removed from) the
   /// basic block
   ///
-  virtual int processFunctionBeforeFrameFinalized(MachineFunction &MF) const {
-    return 0;
+  virtual void processFunctionBeforeFrameFinalized(MachineFunction &MF) const {
   }
 
   /// eliminateFrameIndex - This method must be overriden to eliminate abstract
@@ -270,16 +311,23 @@ public:
   /// finished product. The return value is the number of instructions
   /// added to (negative if removed from) the basic block.
   ///
-  virtual int eliminateFrameIndex(MachineFunction &MF,
-                                  MachineBasicBlock::iterator &II) const = 0;
+  virtual void eliminateFrameIndex(MachineFunction &MF,
+                                   MachineBasicBlock::iterator MI) const = 0;
 
   /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
   /// the function. The return value is the number of instructions
   /// added to (negative if removed from) the basic block (entry for prologue).
   ///
-  virtual int emitPrologue(MachineFunction &MF) const = 0;
-  virtual int emitEpilogue(MachineFunction &MF,
-                           MachineBasicBlock &MBB) const = 0;
+  virtual void emitPrologue(MachineFunction &MF) const = 0;
+  virtual void emitEpilogue(MachineFunction &MF,
+                            MachineBasicBlock &MBB) const = 0;
+};
+
+// This is useful when building DenseMaps keyed on virtual registers
+struct VirtReg2IndexFunctor : std::unary_function<unsigned, unsigned> {
+  unsigned operator()(unsigned Reg) const {
+    return Reg - MRegisterInfo::FirstVirtualRegister;
+  }
 };
 
 } // End llvm namespace