1 //===-- FastISel.h - Definition of the FastISel class ---------------------===// 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 defines the FastISel class. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef LLVM_CODEGEN_FASTISEL_H 15 #define LLVM_CODEGEN_FASTISEL_H 16 17 #include "llvm/ADT/DenseMap.h" 18 #ifndef NDEBUG 19 #include "llvm/ADT/SmallSet.h" 20 #endif 21 #include "llvm/CodeGen/ValueTypes.h" 22 #include "llvm/CodeGen/MachineBasicBlock.h" 23 24 namespace llvm { 25 26 class AllocaInst; 27 class ConstantFP; 28 class FunctionLoweringInfo; 29 class Instruction; 30 class MachineBasicBlock; 31 class MachineConstantPool; 32 class MachineFunction; 33 class MachineInstr; 34 class MachineFrameInfo; 35 class MachineRegisterInfo; 36 class TargetData; 37 class TargetInstrInfo; 38 class TargetLowering; 39 class TargetMachine; 40 class TargetRegisterClass; 41 class TargetRegisterInfo; 42 43 /// FastISel - This is a fast-path instruction selection class that 44 /// generates poor code and doesn't support illegal types or non-trivial 45 /// lowering, but runs quickly. 46 class FastISel { 47 protected: 48 DenseMap<const Value *, unsigned> LocalValueMap; 49 FunctionLoweringInfo &FuncInfo; 50 MachineRegisterInfo &MRI; 51 MachineFrameInfo &MFI; 52 MachineConstantPool &MCP; 53 DebugLoc DL; 54 const TargetMachine &TM; 55 const TargetData &TD; 56 const TargetInstrInfo &TII; 57 const TargetLowering &TLI; 58 const TargetRegisterInfo &TRI; 59 MachineInstr *LastLocalValue; 60 61 public: 62 /// getLastLocalValue - Return the position of the last instruction 63 /// emitted for materializing constants for use in the current block. getLastLocalValue()64 MachineInstr *getLastLocalValue() { return LastLocalValue; } 65 66 /// setLastLocalValue - Update the position of the last instruction 67 /// emitted for materializing constants for use in the current block. setLastLocalValue(MachineInstr * I)68 void setLastLocalValue(MachineInstr *I) { LastLocalValue = I; } 69 70 /// startNewBlock - Set the current block to which generated machine 71 /// instructions will be appended, and clear the local CSE map. 72 /// 73 void startNewBlock(); 74 75 /// getCurDebugLoc() - Return current debug location information. getCurDebugLoc()76 DebugLoc getCurDebugLoc() const { return DL; } 77 78 /// SelectInstruction - Do "fast" instruction selection for the given 79 /// LLVM IR instruction, and append generated machine instructions to 80 /// the current block. Return true if selection was successful. 81 /// 82 bool SelectInstruction(const Instruction *I); 83 84 /// SelectOperator - Do "fast" instruction selection for the given 85 /// LLVM IR operator (Instruction or ConstantExpr), and append 86 /// generated machine instructions to the current block. Return true 87 /// if selection was successful. 88 /// 89 bool SelectOperator(const User *I, unsigned Opcode); 90 91 /// getRegForValue - Create a virtual register and arrange for it to 92 /// be assigned the value for the given LLVM value. 93 unsigned getRegForValue(const Value *V); 94 95 /// lookUpRegForValue - Look up the value to see if its value is already 96 /// cached in a register. It may be defined by instructions across blocks or 97 /// defined locally. 98 unsigned lookUpRegForValue(const Value *V); 99 100 /// getRegForGEPIndex - This is a wrapper around getRegForValue that also 101 /// takes care of truncating or sign-extending the given getelementptr 102 /// index value. 103 std::pair<unsigned, bool> getRegForGEPIndex(const Value *V); 104 105 /// recomputeInsertPt - Reset InsertPt to prepare for insterting instructions 106 /// into the current block. 107 void recomputeInsertPt(); 108 109 struct SavePoint { 110 MachineBasicBlock::iterator InsertPt; 111 DebugLoc DL; 112 }; 113 114 /// enterLocalValueArea - Prepare InsertPt to begin inserting instructions 115 /// into the local value area and return the old insert position. 116 SavePoint enterLocalValueArea(); 117 118 /// leaveLocalValueArea - Reset InsertPt to the given old insert position. 119 void leaveLocalValueArea(SavePoint Old); 120 121 virtual ~FastISel(); 122 123 protected: 124 explicit FastISel(FunctionLoweringInfo &funcInfo); 125 126 /// TargetSelectInstruction - This method is called by target-independent 127 /// code when the normal FastISel process fails to select an instruction. 128 /// This gives targets a chance to emit code for anything that doesn't 129 /// fit into FastISel's framework. It returns true if it was successful. 130 /// 131 virtual bool 132 TargetSelectInstruction(const Instruction *I) = 0; 133 134 /// FastEmit_r - This method is called by target-independent code 135 /// to request that an instruction with the given type and opcode 136 /// be emitted. 137 virtual unsigned FastEmit_(MVT VT, 138 MVT RetVT, 139 unsigned Opcode); 140 141 /// FastEmit_r - This method is called by target-independent code 142 /// to request that an instruction with the given type, opcode, and 143 /// register operand be emitted. 144 /// 145 virtual unsigned FastEmit_r(MVT VT, 146 MVT RetVT, 147 unsigned Opcode, 148 unsigned Op0, bool Op0IsKill); 149 150 /// FastEmit_rr - This method is called by target-independent code 151 /// to request that an instruction with the given type, opcode, and 152 /// register operands be emitted. 153 /// 154 virtual unsigned FastEmit_rr(MVT VT, 155 MVT RetVT, 156 unsigned Opcode, 157 unsigned Op0, bool Op0IsKill, 158 unsigned Op1, bool Op1IsKill); 159 160 /// FastEmit_ri - This method is called by target-independent code 161 /// to request that an instruction with the given type, opcode, and 162 /// register and immediate operands be emitted. 163 /// 164 virtual unsigned FastEmit_ri(MVT VT, 165 MVT RetVT, 166 unsigned Opcode, 167 unsigned Op0, bool Op0IsKill, 168 uint64_t Imm); 169 170 /// FastEmit_rf - This method is called by target-independent code 171 /// to request that an instruction with the given type, opcode, and 172 /// register and floating-point immediate operands be emitted. 173 /// 174 virtual unsigned FastEmit_rf(MVT VT, 175 MVT RetVT, 176 unsigned Opcode, 177 unsigned Op0, bool Op0IsKill, 178 const ConstantFP *FPImm); 179 180 /// FastEmit_rri - This method is called by target-independent code 181 /// to request that an instruction with the given type, opcode, and 182 /// register and immediate operands be emitted. 183 /// 184 virtual unsigned FastEmit_rri(MVT VT, 185 MVT RetVT, 186 unsigned Opcode, 187 unsigned Op0, bool Op0IsKill, 188 unsigned Op1, bool Op1IsKill, 189 uint64_t Imm); 190 191 /// FastEmit_ri_ - This method is a wrapper of FastEmit_ri. It first tries 192 /// to emit an instruction with an immediate operand using FastEmit_ri. 193 /// If that fails, it materializes the immediate into a register and try 194 /// FastEmit_rr instead. 195 unsigned FastEmit_ri_(MVT VT, 196 unsigned Opcode, 197 unsigned Op0, bool Op0IsKill, 198 uint64_t Imm, MVT ImmType); 199 200 /// FastEmit_rf_ - This method is a wrapper of FastEmit_rf. It first tries 201 /// to emit an instruction with an immediate operand using FastEmit_rf. 202 /// If that fails, it materializes the immediate into a register and try 203 /// FastEmit_rr instead. 204 unsigned FastEmit_rf_(MVT VT, 205 unsigned Opcode, 206 unsigned Op0, bool Op0IsKill, 207 const ConstantFP *FPImm, MVT ImmType); 208 209 /// FastEmit_i - This method is called by target-independent code 210 /// to request that an instruction with the given type, opcode, and 211 /// immediate operand be emitted. 212 virtual unsigned FastEmit_i(MVT VT, 213 MVT RetVT, 214 unsigned Opcode, 215 uint64_t Imm); 216 217 /// FastEmit_f - This method is called by target-independent code 218 /// to request that an instruction with the given type, opcode, and 219 /// floating-point immediate operand be emitted. 220 virtual unsigned FastEmit_f(MVT VT, 221 MVT RetVT, 222 unsigned Opcode, 223 const ConstantFP *FPImm); 224 225 /// FastEmitInst_ - Emit a MachineInstr with no operands and a 226 /// result register in the given register class. 227 /// 228 unsigned FastEmitInst_(unsigned MachineInstOpcode, 229 const TargetRegisterClass *RC); 230 231 /// FastEmitInst_r - Emit a MachineInstr with one register operand 232 /// and a result register in the given register class. 233 /// 234 unsigned FastEmitInst_r(unsigned MachineInstOpcode, 235 const TargetRegisterClass *RC, 236 unsigned Op0, bool Op0IsKill); 237 238 /// FastEmitInst_rr - Emit a MachineInstr with two register operands 239 /// and a result register in the given register class. 240 /// 241 unsigned FastEmitInst_rr(unsigned MachineInstOpcode, 242 const TargetRegisterClass *RC, 243 unsigned Op0, bool Op0IsKill, 244 unsigned Op1, bool Op1IsKill); 245 246 /// FastEmitInst_ri - Emit a MachineInstr with two register operands 247 /// and a result register in the given register class. 248 /// 249 unsigned FastEmitInst_ri(unsigned MachineInstOpcode, 250 const TargetRegisterClass *RC, 251 unsigned Op0, bool Op0IsKill, 252 uint64_t Imm); 253 254 /// FastEmitInst_rf - Emit a MachineInstr with two register operands 255 /// and a result register in the given register class. 256 /// 257 unsigned FastEmitInst_rf(unsigned MachineInstOpcode, 258 const TargetRegisterClass *RC, 259 unsigned Op0, bool Op0IsKill, 260 const ConstantFP *FPImm); 261 262 /// FastEmitInst_rri - Emit a MachineInstr with two register operands, 263 /// an immediate, and a result register in the given register class. 264 /// 265 unsigned FastEmitInst_rri(unsigned MachineInstOpcode, 266 const TargetRegisterClass *RC, 267 unsigned Op0, bool Op0IsKill, 268 unsigned Op1, bool Op1IsKill, 269 uint64_t Imm); 270 271 /// FastEmitInst_i - Emit a MachineInstr with a single immediate 272 /// operand, and a result register in the given register class. 273 unsigned FastEmitInst_i(unsigned MachineInstrOpcode, 274 const TargetRegisterClass *RC, 275 uint64_t Imm); 276 277 /// FastEmitInst_extractsubreg - Emit a MachineInstr for an extract_subreg 278 /// from a specified index of a superregister to a specified type. 279 unsigned FastEmitInst_extractsubreg(MVT RetVT, 280 unsigned Op0, bool Op0IsKill, 281 uint32_t Idx); 282 283 /// FastEmitZExtFromI1 - Emit MachineInstrs to compute the value of Op 284 /// with all but the least significant bit set to zero. 285 unsigned FastEmitZExtFromI1(MVT VT, 286 unsigned Op0, bool Op0IsKill); 287 288 /// FastEmitBranch - Emit an unconditional branch to the given block, 289 /// unless it is the immediate (fall-through) successor, and update 290 /// the CFG. 291 void FastEmitBranch(MachineBasicBlock *MBB, DebugLoc DL); 292 293 unsigned UpdateValueMap(const Value* I, unsigned Reg); 294 295 unsigned createResultReg(const TargetRegisterClass *RC); 296 297 /// TargetMaterializeConstant - Emit a constant in a register using 298 /// target-specific logic, such as constant pool loads. TargetMaterializeConstant(const Constant * C)299 virtual unsigned TargetMaterializeConstant(const Constant* C) { 300 return 0; 301 } 302 303 /// TargetMaterializeAlloca - Emit an alloca address in a register using 304 /// target-specific logic. TargetMaterializeAlloca(const AllocaInst * C)305 virtual unsigned TargetMaterializeAlloca(const AllocaInst* C) { 306 return 0; 307 } 308 309 private: 310 bool SelectBinaryOp(const User *I, unsigned ISDOpcode); 311 312 bool SelectFNeg(const User *I); 313 314 bool SelectGetElementPtr(const User *I); 315 316 bool SelectCall(const User *I); 317 318 bool SelectBitCast(const User *I); 319 320 bool SelectCast(const User *I, unsigned Opcode); 321 322 /// HandlePHINodesInSuccessorBlocks - Handle PHI nodes in successor blocks. 323 /// Emit code to ensure constants are copied into registers when needed. 324 /// Remember the virtual registers that need to be added to the Machine PHI 325 /// nodes as input. We cannot just directly add them, because expansion 326 /// might result in multiple MBB's for one BB. As such, the start of the 327 /// BB might correspond to a different MBB than the end. 328 bool HandlePHINodesInSuccessorBlocks(const BasicBlock *LLVMBB); 329 330 /// materializeRegForValue - Helper for getRegForVale. This function is 331 /// called when the value isn't already available in a register and must 332 /// be materialized with new instructions. 333 unsigned materializeRegForValue(const Value *V, MVT VT); 334 335 /// hasTrivialKill - Test whether the given value has exactly one use. 336 bool hasTrivialKill(const Value *V) const; 337 }; 338 339 } 340 341 #endif 342