← Back to branch summary

~pali/+junk/llvm-toolchain-3.7

« back to all changes in this revision

Viewing changes to lib/Target/PowerPC/PPCMachineFunctionInfo.h

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2015-07-15 17:51:08 UTC
  • Revision ID: package-import@ubuntu.com-20150715175108-l8mynwovkx4zx697
Tags: upstream-3.7~+rc2
Import upstream version 3.7~+rc2

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/Target/PowerPC/PPCMachineFunctionInfo.h
 
1
//===-- PPCMachineFunctionInfo.h - Private data used for PowerPC --*- C++ -*-=//
 
2
//
 
3
//                     The LLVM Compiler Infrastructure
 
4
//
 
5
// This file is distributed under the University of Illinois Open Source
 
6
// License. See LICENSE.TXT for details.
 
7
//
 
8
//===----------------------------------------------------------------------===//
 
9
//
 
10
// This file declares the PowerPC specific subclass of MachineFunctionInfo.
 
11
//
 
12
//===----------------------------------------------------------------------===//
 
13
 
 
14
#ifndef LLVM_LIB_TARGET_POWERPC_PPCMACHINEFUNCTIONINFO_H
 
15
#define LLVM_LIB_TARGET_POWERPC_PPCMACHINEFUNCTIONINFO_H
 
16
 
 
17
#include "llvm/CodeGen/MachineFunction.h"
 
18
 
 
19
namespace llvm {
 
20
 
 
21
/// PPCFunctionInfo - This class is derived from MachineFunction private
 
22
/// PowerPC target-specific information for each MachineFunction.
 
23
class PPCFunctionInfo : public MachineFunctionInfo {
 
24
  virtual void anchor();
 
25
 
 
26
  /// FramePointerSaveIndex - Frame index of where the old frame pointer is
 
27
  /// stored.  Also used as an anchor for instructions that need to be altered
 
28
  /// when using frame pointers (dyna_add, dyna_sub.)
 
29
  int FramePointerSaveIndex;
 
30
  
 
31
  /// ReturnAddrSaveIndex - Frame index of where the return address is stored.
 
32
  ///
 
33
  int ReturnAddrSaveIndex;
 
34
 
 
35
  /// Frame index where the old base pointer is stored.
 
36
  int BasePointerSaveIndex;
 
37
 
 
38
  /// Frame index where the old PIC base pointer is stored.
 
39
  int PICBasePointerSaveIndex;
 
40
 
 
41
  /// MustSaveLR - Indicates whether LR is defined (or clobbered) in the current
 
42
  /// function.  This is only valid after the initial scan of the function by
 
43
  /// PEI.
 
44
  bool MustSaveLR;
 
45
 
 
46
  /// Does this function have any stack spills.
 
47
  bool HasSpills;
 
48
 
 
49
  /// Does this function spill using instructions with only r+r (not r+i)
 
50
  /// forms.
 
51
  bool HasNonRISpills;
 
52
 
 
53
  /// SpillsCR - Indicates whether CR is spilled in the current function.
 
54
  bool SpillsCR;
 
55
 
 
56
  /// Indicates whether VRSAVE is spilled in the current function.
 
57
  bool SpillsVRSAVE;
 
58
 
 
59
  /// LRStoreRequired - The bool indicates whether there is some explicit use of
 
60
  /// the LR/LR8 stack slot that is not obvious from scanning the code.  This
 
61
  /// requires that the code generator produce a store of LR to the stack on
 
62
  /// entry, even though LR may otherwise apparently not be used.
 
63
  bool LRStoreRequired;
 
64
 
 
65
  /// This function makes use of the PPC64 ELF TOC base pointer (register r2).
 
66
  bool UsesTOCBasePtr;
 
67
 
 
68
  /// MinReservedArea - This is the frame size that is at least reserved in a
 
69
  /// potential caller (parameter+linkage area).
 
70
  unsigned MinReservedArea;
 
71
 
 
72
  /// TailCallSPDelta - Stack pointer delta used when tail calling. Maximum
 
73
  /// amount the stack pointer is adjusted to make the frame bigger for tail
 
74
  /// calls. Used for creating an area before the register spill area.
 
75
  int TailCallSPDelta;
 
76
 
 
77
  /// HasFastCall - Does this function contain a fast call. Used to determine
 
78
  /// how the caller's stack pointer should be calculated (epilog/dynamicalloc).
 
79
  bool HasFastCall;
 
80
 
 
81
  /// VarArgsFrameIndex - FrameIndex for start of varargs area.
 
82
  int VarArgsFrameIndex;
 
83
  /// VarArgsStackOffset - StackOffset for start of stack
 
84
  /// arguments.
 
85
  int VarArgsStackOffset;
 
86
  /// VarArgsNumGPR - Index of the first unused integer
 
87
  /// register for parameter passing.
 
88
  unsigned VarArgsNumGPR;
 
89
  /// VarArgsNumFPR - Index of the first unused double
 
90
  /// register for parameter passing.
 
91
  unsigned VarArgsNumFPR;
 
92
 
 
93
  /// CRSpillFrameIndex - FrameIndex for CR spill slot for 32-bit SVR4.
 
94
  int CRSpillFrameIndex;
 
95
 
 
96
  /// If any of CR[2-4] need to be saved in the prologue and restored in the
 
97
  /// epilogue then they are added to this array. This is used for the
 
98
  /// 64-bit SVR4 ABI.
 
99
  SmallVector<unsigned, 3> MustSaveCRs;
 
100
 
 
101
  /// Hold onto our MachineFunction context.
 
102
  MachineFunction &MF;
 
103
 
 
104
  /// Whether this uses the PIC Base register or not.
 
105
  bool UsesPICBase;
 
106
 
 
107
public:
 
108
  explicit PPCFunctionInfo(MachineFunction &MF) 
 
109
    : FramePointerSaveIndex(0),
 
110
      ReturnAddrSaveIndex(0),
 
111
      BasePointerSaveIndex(0),
 
112
      PICBasePointerSaveIndex(0),
 
113
      HasSpills(false),
 
114
      HasNonRISpills(false),
 
115
      SpillsCR(false),
 
116
      SpillsVRSAVE(false),
 
117
      LRStoreRequired(false),
 
118
      UsesTOCBasePtr(false),
 
119
      MinReservedArea(0),
 
120
      TailCallSPDelta(0),
 
121
      HasFastCall(false),
 
122
      VarArgsFrameIndex(0),
 
123
      VarArgsStackOffset(0),
 
124
      VarArgsNumGPR(0),
 
125
      VarArgsNumFPR(0),
 
126
      CRSpillFrameIndex(0),
 
127
      MF(MF),
 
128
      UsesPICBase(0) {}
 
129
 
 
130
  int getFramePointerSaveIndex() const { return FramePointerSaveIndex; }
 
131
  void setFramePointerSaveIndex(int Idx) { FramePointerSaveIndex = Idx; }
 
132
  
 
133
  int getReturnAddrSaveIndex() const { return ReturnAddrSaveIndex; }
 
134
  void setReturnAddrSaveIndex(int idx) { ReturnAddrSaveIndex = idx; }
 
135
 
 
136
  int getBasePointerSaveIndex() const { return BasePointerSaveIndex; }
 
137
  void setBasePointerSaveIndex(int Idx) { BasePointerSaveIndex = Idx; }
 
138
 
 
139
  int getPICBasePointerSaveIndex() const { return PICBasePointerSaveIndex; }
 
140
  void setPICBasePointerSaveIndex(int Idx) { PICBasePointerSaveIndex = Idx; }
 
141
 
 
142
  unsigned getMinReservedArea() const { return MinReservedArea; }
 
143
  void setMinReservedArea(unsigned size) { MinReservedArea = size; }
 
144
 
 
145
  int getTailCallSPDelta() const { return TailCallSPDelta; }
 
146
  void setTailCallSPDelta(int size) { TailCallSPDelta = size; }
 
147
 
 
148
  /// MustSaveLR - This is set when the prolog/epilog inserter does its initial
 
149
  /// scan of the function. It is true if the LR/LR8 register is ever explicitly
 
150
  /// defined/clobbered in the machine function (e.g. by calls and movpctolr,
 
151
  /// which is used in PIC generation), or if the LR stack slot is explicitly
 
152
  /// referenced by builtin_return_address.
 
153
  void setMustSaveLR(bool U) { MustSaveLR = U; }
 
154
  bool mustSaveLR() const    { return MustSaveLR; }
 
155
 
 
156
  void setHasSpills()      { HasSpills = true; }
 
157
  bool hasSpills() const   { return HasSpills; }
 
158
 
 
159
  void setHasNonRISpills()    { HasNonRISpills = true; }
 
160
  bool hasNonRISpills() const { return HasNonRISpills; }
 
161
 
 
162
  void setSpillsCR()       { SpillsCR = true; }
 
163
  bool isCRSpilled() const { return SpillsCR; }
 
164
 
 
165
  void setSpillsVRSAVE()       { SpillsVRSAVE = true; }
 
166
  bool isVRSAVESpilled() const { return SpillsVRSAVE; }
 
167
 
 
168
  void setLRStoreRequired() { LRStoreRequired = true; }
 
169
  bool isLRStoreRequired() const { return LRStoreRequired; }
 
170
 
 
171
  void setUsesTOCBasePtr()    { UsesTOCBasePtr = true; }
 
172
  bool usesTOCBasePtr() const { return UsesTOCBasePtr; }
 
173
 
 
174
  void setHasFastCall() { HasFastCall = true; }
 
175
  bool hasFastCall() const { return HasFastCall;}
 
176
 
 
177
  int getVarArgsFrameIndex() const { return VarArgsFrameIndex; }
 
178
  void setVarArgsFrameIndex(int Index) { VarArgsFrameIndex = Index; }
 
179
 
 
180
  int getVarArgsStackOffset() const { return VarArgsStackOffset; }
 
181
  void setVarArgsStackOffset(int Offset) { VarArgsStackOffset = Offset; }
 
182
 
 
183
  unsigned getVarArgsNumGPR() const { return VarArgsNumGPR; }
 
184
  void setVarArgsNumGPR(unsigned Num) { VarArgsNumGPR = Num; }
 
185
 
 
186
  unsigned getVarArgsNumFPR() const { return VarArgsNumFPR; }
 
187
  void setVarArgsNumFPR(unsigned Num) { VarArgsNumFPR = Num; }
 
188
 
 
189
  int getCRSpillFrameIndex() const { return CRSpillFrameIndex; }
 
190
  void setCRSpillFrameIndex(int idx) { CRSpillFrameIndex = idx; }
 
191
 
 
192
  const SmallVectorImpl<unsigned> &
 
193
    getMustSaveCRs() const { return MustSaveCRs; }
 
194
  void addMustSaveCR(unsigned Reg) { MustSaveCRs.push_back(Reg); }
 
195
 
 
196
  void setUsesPICBase(bool uses) { UsesPICBase = uses; }
 
197
  bool usesPICBase() const { return UsesPICBase; }
 
198
 
 
199
  MCSymbol *getPICOffsetSymbol() const;
 
200
};
 
201
 
 
202
} // end of namespace llvm
 
203
 
 
204
 
 
205
#endif