X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FTarget%2FTargetFrameInfo.h;h=3e26b9dd01bea6112c778d529388b30fdd4a1263;hb=ac57e6e498abccb117e0d61c2fa0f733845e50cb;hp=659955cdfba42a30c6497fad8dc51231d30a921c;hpb=035dfbe7f2d109008d2d62d9f2a67efb477a7ab6;p=oota-llvm.git

diff --git a/include/llvm/Target/TargetFrameInfo.h b/include/llvm/Target/TargetFrameInfo.h
index 659955cdfba..3e26b9dd01b 100644
--- a/include/llvm/Target/TargetFrameInfo.h
+++ b/include/llvm/Target/TargetFrameInfo.h
@@ -1,70 +1,80 @@
-//===-- llvm/CodeGen/MachineFrameInfo.h -------------------------*- C++ -*-===//
+//===-- llvm/Target/TargetFrameInfo.h ---------------------------*- C++ -*-===//
 //
-// Interface to layout of stack frame on target machine.
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Interface to describe the layout of a stack frame on the target machine.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_CODEGEN_FRAMEINFO_H
-#define LLVM_CODEGEN_FRAMEINFO_H
+#ifndef LLVM_TARGET_TARGETFRAMEINFO_H
+#define LLVM_TARGET_TARGETFRAMEINFO_H
 
-#include "Support/NonCopyable.h"
-#include <vector>
+#include <utility>
 
-class MachineCodeForMethod;
-class TargetMachine;
+namespace llvm {
 
-struct MachineFrameInfo : public NonCopyableV {
-  const TargetMachine &target;
-  
+/// Information about stack frame layout on the target.  It holds the direction
+/// of stack growth, the known stack alignment on entry to each function, and
+/// the offset to the locals area.
+///
+/// The offset to the local area is the offset from the stack pointer on
+/// function entry to the first location where function data (local variables,
+/// spill locations) can be stored.
+class TargetFrameInfo {
+public:
+  enum StackDirection {
+    StackGrowsUp,        // Adding to the stack increases the stack address
+    StackGrowsDown       // Adding to the stack decreases the stack address
+  };
+private:
+  StackDirection StackDir;
+  unsigned StackAlignment;
+  int LocalAreaOffset;
 public:
-  MachineFrameInfo(const TargetMachine& tgt) : target(tgt) {}
-  
-  //
-  // These methods provide constant parameters of the frame layout.
-  // 
-  virtual int  getStackFrameSizeAlignment       () const = 0;
-  virtual int  getMinStackFrameSize             () const = 0;
-  virtual int  getNumFixedOutgoingArgs          () const = 0;
-  virtual int  getSizeOfEachArgOnStack          () const = 0;
-  virtual bool argsOnStackHaveFixedSize         () const = 0;
-  
-  //
-  // These methods compute offsets using the frame contents for a
-  // particular method.  The frame contents are obtained from the
-  // MachineCodeInfoForMethod object for the given method.
-  // The first few methods have default machine-independent implementations.
-  // The rest must be implemented by the machine-specific subclass.
-  // 
-  virtual int getIncomingArgOffset              (MachineCodeForMethod& mcInfo,
-                                                 unsigned argNum) const;
-  virtual int getOutgoingArgOffset              (MachineCodeForMethod& mcInfo,
-                                                 unsigned argNum) const;
-  
-  virtual int getFirstIncomingArgOffset         (MachineCodeForMethod& mcInfo,
-                                                 bool& growUp) const=0;
-  virtual int getFirstOutgoingArgOffset         (MachineCodeForMethod& mcInfo,
-                                                 bool& growUp) const=0;
-  virtual int getFirstOptionalOutgoingArgOffset (MachineCodeForMethod&,
-                                                 bool& growUp) const=0;
-  virtual int getFirstAutomaticVarOffset        (MachineCodeForMethod& mcInfo,
-                                                 bool& growUp) const=0;
-  virtual int getRegSpillAreaOffset             (MachineCodeForMethod& mcInfo,
-                                                 bool& growUp) const=0;
-  virtual int getTmpAreaOffset                  (MachineCodeForMethod& mcInfo,
-                                                 bool& growUp) const=0;
-  virtual int getDynamicAreaOffset              (MachineCodeForMethod& mcInfo,
-                                                 bool& growUp) const=0;
+  TargetFrameInfo(StackDirection D, unsigned StackAl, int LAO)
+    : StackDir(D), StackAlignment(StackAl), LocalAreaOffset(LAO) {}
+
+  virtual ~TargetFrameInfo();
 
-  //
-  // These methods specify the base register used for each stack area
-  // (generally FP or SP)
-  // 
-  virtual int getIncomingArgBaseRegNum()               const=0;
-  virtual int getOutgoingArgBaseRegNum()               const=0;
-  virtual int getOptionalOutgoingArgBaseRegNum()       const=0;
-  virtual int getAutomaticVarBaseRegNum()              const=0;
-  virtual int getRegSpillAreaBaseRegNum()              const=0;
-  virtual int getDynamicAreaBaseRegNum()               const=0;
+  // These methods return information that describes the abstract stack layout
+  // of the target machine.
+
+  /// getStackGrowthDirection - Return the direction the stack grows
+  ///
+  StackDirection getStackGrowthDirection() const { return StackDir; }
+
+  /// getStackAlignment - This method returns the number of bytes that the stack
+  /// pointer must be aligned to.  Typically, this is the largest alignment for
+  /// any data object in the target.
+  ///
+  unsigned getStackAlignment() const { return StackAlignment; }
+
+  /// getOffsetOfLocalArea - This method returns the offset of the local area
+  /// from the stack pointer on entrance to a function.
+  ///
+  int getOffsetOfLocalArea() const { return LocalAreaOffset; }
+
+  /// getCalleeSavedSpillSlots - This method returns a pointer to an array of
+  /// pairs, that contains an entry for each callee saved register that must be
+  /// spilled to a particular stack location if it is spilled.
+  ///
+  /// Each entry in this array contains a <register,offset> pair, indicating the
+  /// fixed offset from the incoming stack pointer that each register should be
+  /// spilled at.  If a register is not listed here, the code generator is
+  /// allowed to spill it anywhere it chooses.
+  ///
+  virtual const std::pair<unsigned, int> *
+  getCalleeSavedSpillSlots(unsigned &NumEntries) const {
+    NumEntries = 0;
+    return 0;
+  }
 };
 
+} // End llvm namespace
+
 #endif