OLD | NEW |
(Empty) | |
| 1 //===- subzero/src/IceTargetLowering.h - Lowering interface -----*- C++ -*-===// |
| 2 // |
| 3 // The Subzero Code Generator |
| 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 TargetLowering and LoweringContext |
| 11 // classes. TargetLowering is an abstract class used to drive the |
| 12 // translation/lowering process. LoweringContext maintains a |
| 13 // context for lowering each instruction, offering conveniences such |
| 14 // as iterating over non-deleted instructions. |
| 15 // |
| 16 //===----------------------------------------------------------------------===// |
| 17 |
| 18 #ifndef SUBZERO_SRC_ICETARGETLOWERING_H |
| 19 #define SUBZERO_SRC_ICETARGETLOWERING_H |
| 20 |
| 21 #include "IceDefs.h" |
| 22 #include "IceTypes.h" |
| 23 |
| 24 #include "IceInst.h" // for the names of the Inst subtypes |
| 25 |
| 26 namespace Ice { |
| 27 |
| 28 // LoweringContext makes it easy to iterate through non-deleted |
| 29 // instructions in a node, and insert new (lowered) instructions at |
| 30 // the current point. Along with the instruction list container and |
| 31 // associated iterators, it holds the current node, which is needed |
| 32 // when inserting new instructions in order to track whether variables |
| 33 // are used as single-block or multi-block. |
| 34 class LoweringContext { |
| 35 public: |
| 36 LoweringContext() : Node(NULL) {} |
| 37 ~LoweringContext() {} |
| 38 void init(CfgNode *Node); |
| 39 Inst *getNextInst() const { |
| 40 if (Next == End) |
| 41 return NULL; |
| 42 return *Next; |
| 43 } |
| 44 CfgNode *getNode() const { return Node; } |
| 45 bool atEnd() const { return Cur == End; } |
| 46 InstList::iterator getCur() const { return Cur; } |
| 47 InstList::iterator getEnd() const { return End; } |
| 48 void insert(Inst *Inst); |
| 49 void advanceCur() { Cur = Next; } |
| 50 void advanceNext() { advance(Next); } |
| 51 void setInsertPoint(const InstList::iterator &Position) { Next = Position; } |
| 52 |
| 53 private: |
| 54 // Node is the argument to Inst::updateVars(). |
| 55 CfgNode *Node; |
| 56 // Cur points to the current instruction being considered. It is |
| 57 // guaranteed to point to a non-deleted instruction, or to be End. |
| 58 InstList::iterator Cur; |
| 59 // Next doubles as a pointer to the next valid instruction (if any), |
| 60 // and the new-instruction insertion point. It is also updated for |
| 61 // the caller in case the lowering consumes more than one high-level |
| 62 // instruction. It is guaranteed to point to a non-deleted |
| 63 // instruction after Cur, or to be End. TODO: Consider separating |
| 64 // the notion of "next valid instruction" and "new instruction |
| 65 // insertion point", to avoid confusion when previously-deleted |
| 66 // instructions come between the two points. |
| 67 InstList::iterator Next; |
| 68 // End is a copy of Insts.end(), used if Next needs to be advanced. |
| 69 InstList::iterator End; |
| 70 |
| 71 void skipDeleted(InstList::iterator &I); |
| 72 void advance(InstList::iterator &I); |
| 73 LoweringContext(const LoweringContext &) LLVM_DELETED_FUNCTION; |
| 74 LoweringContext &operator=(const LoweringContext &) LLVM_DELETED_FUNCTION; |
| 75 }; |
| 76 |
| 77 class TargetLowering { |
| 78 public: |
| 79 static TargetLowering *createLowering(TargetArch Target, Cfg *Func); |
| 80 void translate() { |
| 81 switch (Ctx->getOptLevel()) { |
| 82 case Opt_m1: |
| 83 translateOm1(); |
| 84 break; |
| 85 case Opt_0: |
| 86 translateO0(); |
| 87 break; |
| 88 case Opt_1: |
| 89 translateO1(); |
| 90 break; |
| 91 case Opt_2: |
| 92 translateO2(); |
| 93 break; |
| 94 default: |
| 95 Func->setError("Target doesn't specify lowering steps."); |
| 96 break; |
| 97 } |
| 98 } |
| 99 virtual void translateOm1() { |
| 100 Func->setError("Target doesn't specify Om1 lowering steps."); |
| 101 } |
| 102 virtual void translateO0() { |
| 103 Func->setError("Target doesn't specify O0 lowering steps."); |
| 104 } |
| 105 virtual void translateO1() { |
| 106 Func->setError("Target doesn't specify O1 lowering steps."); |
| 107 } |
| 108 virtual void translateO2() { |
| 109 Func->setError("Target doesn't specify O2 lowering steps."); |
| 110 } |
| 111 |
| 112 // Lowers a single instruction. |
| 113 void lower(); |
| 114 |
| 115 // Returns a variable pre-colored to the specified physical |
| 116 // register. This is generally used to get very direct access to |
| 117 // the register such as in the prolog or epilog or for marking |
| 118 // scratch registers as killed by a call. |
| 119 virtual Variable *getPhysicalRegister(SizeT RegNum) = 0; |
| 120 // Returns a printable name for the register. |
| 121 virtual IceString getRegName(SizeT RegNum, Type Ty) const = 0; |
| 122 |
| 123 virtual bool hasFramePointer() const { return false; } |
| 124 virtual SizeT getFrameOrStackReg() const = 0; |
| 125 virtual size_t typeWidthInBytesOnStack(Type Ty) = 0; |
| 126 bool hasComputedFrame() const { return HasComputedFrame; } |
| 127 int32_t getStackAdjustment() const { return StackAdjustment; } |
| 128 void updateStackAdjustment(int32_t Offset) { StackAdjustment += Offset; } |
| 129 void resetStackAdjustment() { StackAdjustment = 0; } |
| 130 LoweringContext &getContext() { return Context; } |
| 131 |
| 132 enum RegSet { |
| 133 RegSet_None = 0, |
| 134 RegSet_CallerSave = 1 << 0, |
| 135 RegSet_CalleeSave = 1 << 1, |
| 136 RegSet_StackPointer = 1 << 2, |
| 137 RegSet_FramePointer = 1 << 3, |
| 138 RegSet_All = ~RegSet_None |
| 139 }; |
| 140 typedef uint32_t RegSetMask; |
| 141 |
| 142 virtual llvm::SmallBitVector getRegisterSet(RegSetMask Include, |
| 143 RegSetMask Exclude) const = 0; |
| 144 virtual const llvm::SmallBitVector &getRegisterSetForType(Type Ty) const = 0; |
| 145 void regAlloc(); |
| 146 |
| 147 virtual void emitVariable(const Variable *Var, const Cfg *Func) const = 0; |
| 148 |
| 149 virtual void addProlog(CfgNode *Node) = 0; |
| 150 virtual void addEpilog(CfgNode *Node) = 0; |
| 151 |
| 152 virtual ~TargetLowering() {} |
| 153 |
| 154 protected: |
| 155 TargetLowering(Cfg *Func) |
| 156 : Func(Func), Ctx(Func->getContext()), HasComputedFrame(false), |
| 157 StackAdjustment(0) {} |
| 158 virtual void lowerAlloca(const InstAlloca *Inst) = 0; |
| 159 virtual void lowerArithmetic(const InstArithmetic *Inst) = 0; |
| 160 virtual void lowerAssign(const InstAssign *Inst) = 0; |
| 161 virtual void lowerBr(const InstBr *Inst) = 0; |
| 162 virtual void lowerCall(const InstCall *Inst) = 0; |
| 163 virtual void lowerCast(const InstCast *Inst) = 0; |
| 164 virtual void lowerFcmp(const InstFcmp *Inst) = 0; |
| 165 virtual void lowerIcmp(const InstIcmp *Inst) = 0; |
| 166 virtual void lowerLoad(const InstLoad *Inst) = 0; |
| 167 virtual void lowerPhi(const InstPhi *Inst) = 0; |
| 168 virtual void lowerRet(const InstRet *Inst) = 0; |
| 169 virtual void lowerSelect(const InstSelect *Inst) = 0; |
| 170 virtual void lowerStore(const InstStore *Inst) = 0; |
| 171 virtual void lowerSwitch(const InstSwitch *Inst) = 0; |
| 172 virtual void lowerUnreachable(const InstUnreachable *Inst) = 0; |
| 173 |
| 174 // This gives the target an opportunity to post-process the lowered |
| 175 // expansion before returning. The primary intention is to do some |
| 176 // Register Manager activity as necessary, specifically to eagerly |
| 177 // allocate registers based on affinity and other factors. The |
| 178 // simplest lowering does nothing here and leaves it all to a |
| 179 // subsequent global register allocation pass. |
| 180 virtual void postLower() {} |
| 181 |
| 182 Cfg *Func; |
| 183 GlobalContext *Ctx; |
| 184 bool HasComputedFrame; |
| 185 // StackAdjustment keeps track of the current stack offset from its |
| 186 // natural location, as arguments are pushed for a function call. |
| 187 int32_t StackAdjustment; |
| 188 LoweringContext Context; |
| 189 |
| 190 private: |
| 191 TargetLowering(const TargetLowering &) LLVM_DELETED_FUNCTION; |
| 192 TargetLowering &operator=(const TargetLowering &) LLVM_DELETED_FUNCTION; |
| 193 }; |
| 194 |
| 195 } // end of namespace Ice |
| 196 |
| 197 #endif // SUBZERO_SRC_ICETARGETLOWERING_H |
OLD | NEW |