Clean up code a bit.

[oota-llvm.git] / lib / Target / X86 / X86RegisterInfo.h

diff --git a/lib/Target/X86/X86RegisterInfo.h b/lib/Target/X86/X86RegisterInfo.h
index c804691e6c7a551ba70496a476c676c632633ae8..b67091cd404e853af554f4ea4a7afe279073c1e1 100644 (file)
--- a/lib/Target/X86/X86RegisterInfo.h
+++ b/lib/Target/X86/X86RegisterInfo.h
@@ -1,4 +1,11 @@
 //===- X86RegisterInfo.h - X86 Register Information Impl --------*- C++ -*-===//
+// 
+//                     The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// 
+//===----------------------------------------------------------------------===//
 //
 // This file contains the X86 implementation of the MRegisterInfo class.
 //
@@ -9,36 +16,49 @@
 
 #include "llvm/Target/MRegisterInfo.h"
 
-class Type;
+class llvm::Type;
 
-struct X86RegisterInfo : public MRegisterInfo {
-  X86RegisterInfo();
+#include "X86GenRegisterInfo.h.inc"
 
-  const unsigned* getCalleeSaveRegs() const;
+namespace llvm {
 
+struct X86RegisterInfo : public X86GenRegisterInfo {
+  X86RegisterInfo();
   const TargetRegisterClass* getRegClassForType(const Type* Ty) const;
 
   /// Code Generation virtual methods...
-  void storeRegToStackSlot(MachineBasicBlock &MBB,
-                          MachineBasicBlock::iterator &MBBI,
-                          unsigned SrcReg, int FrameIndex,
-                          const TargetRegisterClass *RC) const;
-
-  void loadRegFromStackSlot(MachineBasicBlock &MBB,
-                           MachineBasicBlock::iterator &MBBI,
-                           unsigned DestReg, int FrameIndex,
-                           const TargetRegisterClass *RC) const;
+  int storeRegToStackSlot(MachineBasicBlock &MBB,
+                          MachineBasicBlock::iterator MI,
+                          unsigned SrcReg, int FrameIndex,
+                          const TargetRegisterClass *RC) const;
+
+  int loadRegFromStackSlot(MachineBasicBlock &MBB,
+                           MachineBasicBlock::iterator MI,
+                           unsigned DestReg, int FrameIndex,
+                           const TargetRegisterClass *RC) const;
   
-  void copyRegToReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI,
+  int copyRegToReg(MachineBasicBlock &MBB,
+                   MachineBasicBlock::iterator MI,
                   unsigned DestReg, unsigned SrcReg,
                   const TargetRegisterClass *RC) const;
 
+  /// foldMemoryOperand - If this target supports it, fold a load or store of
+  /// the specified stack slot into the specified machine instruction for the
+  /// specified operand.  If this is possible, the target should perform the
+  /// folding and return true, otherwise it should return false.  If it folds
+  /// the instruction, it is likely that the MachineInstruction the iterator
+  /// references has been changed.
+  virtual MachineInstr* foldMemoryOperand(MachineInstr* MI,
+                                          unsigned OpNum,
+                                          int FrameIndex) const;
+
+
   void eliminateCallFramePseudoInstr(MachineFunction &MF,
-                                    MachineBasicBlock &MBB,
-                                    MachineBasicBlock::iterator &I) const;
+                                     MachineBasicBlock &MBB,
+                                     MachineBasicBlock::iterator MI) const;
 
   void eliminateFrameIndex(MachineFunction &MF,
-                          MachineBasicBlock::iterator &II) const;
+                           MachineBasicBlock::iterator MI) const;
 
   void processFunctionBeforeFrameFinalized(MachineFunction &MF) const;
 
@@ -46,4 +66,6 @@ struct X86RegisterInfo : public MRegisterInfo {
   void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const;
 };
 
+} // End llvm namespace
+
 #endif