1 //===-- PPCFastISel.cpp - PowerPC FastISel implementation -----------------===// 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 PowerPC-specific support for the FastISel class. Some 11 // of the target-specific code is generated by tablegen in the file 12 // PPCGenFastISel.inc, which is #included here. 13 // 14 //===----------------------------------------------------------------------===// 15 16 #define DEBUG_TYPE "ppcfastisel" 17 #include "PPC.h" 18 #include "PPCISelLowering.h" 19 #include "PPCSubtarget.h" 20 #include "PPCTargetMachine.h" 21 #include "MCTargetDesc/PPCPredicates.h" 22 #include "llvm/ADT/Optional.h" 23 #include "llvm/CodeGen/CallingConvLower.h" 24 #include "llvm/CodeGen/FastISel.h" 25 #include "llvm/CodeGen/FunctionLoweringInfo.h" 26 #include "llvm/CodeGen/MachineConstantPool.h" 27 #include "llvm/CodeGen/MachineFrameInfo.h" 28 #include "llvm/CodeGen/MachineInstrBuilder.h" 29 #include "llvm/CodeGen/MachineRegisterInfo.h" 30 #include "llvm/IR/CallingConv.h" 31 #include "llvm/IR/GlobalAlias.h" 32 #include "llvm/IR/GlobalVariable.h" 33 #include "llvm/IR/IntrinsicInst.h" 34 #include "llvm/IR/Operator.h" 35 #include "llvm/Support/Debug.h" 36 #include "llvm/Support/GetElementPtrTypeIterator.h" 37 #include "llvm/Target/TargetLowering.h" 38 #include "llvm/Target/TargetMachine.h" 39 40 using namespace llvm; 41 42 namespace { 43 44 typedef struct Address { 45 enum { 46 RegBase, 47 FrameIndexBase 48 } BaseType; 49 50 union { 51 unsigned Reg; 52 int FI; 53 } Base; 54 55 int Offset; 56 57 // Innocuous defaults for our address. 58 Address() 59 : BaseType(RegBase), Offset(0) { 60 Base.Reg = 0; 61 } 62 } Address; 63 64 class PPCFastISel : public FastISel { 65 66 const TargetMachine &TM; 67 const TargetInstrInfo &TII; 68 const TargetLowering &TLI; 69 const PPCSubtarget &PPCSubTarget; 70 LLVMContext *Context; 71 72 public: 73 explicit PPCFastISel(FunctionLoweringInfo &FuncInfo, 74 const TargetLibraryInfo *LibInfo) 75 : FastISel(FuncInfo, LibInfo), 76 TM(FuncInfo.MF->getTarget()), 77 TII(*TM.getInstrInfo()), 78 TLI(*TM.getTargetLowering()), 79 PPCSubTarget( 80 *((static_cast<const PPCTargetMachine *>(&TM))->getSubtargetImpl()) 81 ), 82 Context(&FuncInfo.Fn->getContext()) { } 83 84 // Backend specific FastISel code. 85 private: 86 virtual bool TargetSelectInstruction(const Instruction *I); 87 virtual unsigned TargetMaterializeConstant(const Constant *C); 88 virtual unsigned TargetMaterializeAlloca(const AllocaInst *AI); 89 virtual bool tryToFoldLoadIntoMI(MachineInstr *MI, unsigned OpNo, 90 const LoadInst *LI); 91 virtual bool FastLowerArguments(); 92 93 // Utility routines. 94 private: 95 unsigned PPCMaterializeFP(const ConstantFP *CFP, MVT VT); 96 unsigned PPCMaterializeInt(const Constant *C, MVT VT); 97 unsigned PPCMaterialize32BitInt(int64_t Imm, 98 const TargetRegisterClass *RC); 99 unsigned PPCMaterialize64BitInt(int64_t Imm, 100 const TargetRegisterClass *RC); 101 102 private: 103 #include "PPCGenFastISel.inc" 104 105 }; 106 107 } // end anonymous namespace 108 109 // Attempt to fast-select an instruction that wasn't handled by 110 // the table-generated machinery. TBD. 111 bool PPCFastISel::TargetSelectInstruction(const Instruction *I) { 112 return I && false; 113 } 114 115 // Materialize a floating-point constant into a register, and return 116 // the register number (or zero if we failed to handle it). 117 unsigned PPCFastISel::PPCMaterializeFP(const ConstantFP *CFP, MVT VT) { 118 // No plans to handle long double here. 119 if (VT != MVT::f32 && VT != MVT::f64) 120 return 0; 121 122 // All FP constants are loaded from the constant pool. 123 unsigned Align = TD.getPrefTypeAlignment(CFP->getType()); 124 assert(Align > 0 && "Unexpectedly missing alignment information!"); 125 unsigned Idx = MCP.getConstantPoolIndex(cast<Constant>(CFP), Align); 126 unsigned DestReg = createResultReg(TLI.getRegClassFor(VT)); 127 CodeModel::Model CModel = TM.getCodeModel(); 128 129 MachineMemOperand *MMO = 130 FuncInfo.MF->getMachineMemOperand( 131 MachinePointerInfo::getConstantPool(), MachineMemOperand::MOLoad, 132 (VT == MVT::f32) ? 4 : 8, Align); 133 134 // For small code model, generate a LDtocCPT. 135 if (CModel == CodeModel::Small || CModel == CodeModel::JITDefault) 136 BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(PPC::LDtocCPT), 137 DestReg) 138 .addConstantPoolIndex(Idx).addReg(PPC::X2).addMemOperand(MMO); 139 else { 140 // Otherwise we generate LF[SD](Idx[lo], ADDIStocHA(X2, Idx)). 141 unsigned Opc = (VT == MVT::f32) ? PPC::LFS : PPC::LFD; 142 unsigned TmpReg = createResultReg(&PPC::G8RC_and_G8RC_NOX0RegClass); 143 BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(PPC::ADDIStocHA), 144 TmpReg).addReg(PPC::X2).addConstantPoolIndex(Idx); 145 BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(Opc), DestReg) 146 .addConstantPoolIndex(Idx, 0, PPCII::MO_TOC_LO) 147 .addReg(TmpReg) 148 .addMemOperand(MMO); 149 } 150 151 return DestReg; 152 } 153 154 // Materialize a 32-bit integer constant into a register, and return 155 // the register number (or zero if we failed to handle it). 156 unsigned PPCFastISel::PPCMaterialize32BitInt(int64_t Imm, 157 const TargetRegisterClass *RC) { 158 unsigned Lo = Imm & 0xFFFF; 159 unsigned Hi = (Imm >> 16) & 0xFFFF; 160 161 unsigned ResultReg = createResultReg(RC); 162 bool IsGPRC = RC->hasSuperClassEq(&PPC::GPRCRegClass); 163 164 if (isInt<16>(Imm)) 165 BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, 166 TII.get(IsGPRC ? PPC::LI : PPC::LI8), ResultReg) 167 .addImm(Imm); 168 else if (Lo) { 169 // Both Lo and Hi have nonzero bits. 170 unsigned TmpReg = createResultReg(RC); 171 BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, 172 TII.get(IsGPRC ? PPC::LIS : PPC::LIS8), TmpReg) 173 .addImm(Hi); 174 BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, 175 TII.get(IsGPRC ? PPC::ORI : PPC::ORI8), ResultReg) 176 .addReg(TmpReg).addImm(Lo); 177 } else 178 // Just Hi bits. 179 BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, 180 TII.get(IsGPRC ? PPC::LIS : PPC::LIS8), ResultReg) 181 .addImm(Hi); 182 183 return ResultReg; 184 } 185 186 // Materialize a 64-bit integer constant into a register, and return 187 // the register number (or zero if we failed to handle it). 188 unsigned PPCFastISel::PPCMaterialize64BitInt(int64_t Imm, 189 const TargetRegisterClass *RC) { 190 unsigned Remainder = 0; 191 unsigned Shift = 0; 192 193 // If the value doesn't fit in 32 bits, see if we can shift it 194 // so that it fits in 32 bits. 195 if (!isInt<32>(Imm)) { 196 Shift = countTrailingZeros<uint64_t>(Imm); 197 int64_t ImmSh = static_cast<uint64_t>(Imm) >> Shift; 198 199 if (isInt<32>(ImmSh)) 200 Imm = ImmSh; 201 else { 202 Remainder = Imm; 203 Shift = 32; 204 Imm >>= 32; 205 } 206 } 207 208 // Handle the high-order 32 bits (if shifted) or the whole 32 bits 209 // (if not shifted). 210 unsigned TmpReg1 = PPCMaterialize32BitInt(Imm, RC); 211 if (!Shift) 212 return TmpReg1; 213 214 // If upper 32 bits were not zero, we've built them and need to shift 215 // them into place. 216 unsigned TmpReg2; 217 if (Imm) { 218 TmpReg2 = createResultReg(RC); 219 BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(PPC::RLDICR), 220 TmpReg2).addReg(TmpReg1).addImm(Shift).addImm(63 - Shift); 221 } else 222 TmpReg2 = TmpReg1; 223 224 unsigned TmpReg3, Hi, Lo; 225 if ((Hi = (Remainder >> 16) & 0xFFFF)) { 226 TmpReg3 = createResultReg(RC); 227 BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(PPC::ORIS8), 228 TmpReg3).addReg(TmpReg2).addImm(Hi); 229 } else 230 TmpReg3 = TmpReg2; 231 232 if ((Lo = Remainder & 0xFFFF)) { 233 unsigned ResultReg = createResultReg(RC); 234 BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(PPC::ORI8), 235 ResultReg).addReg(TmpReg3).addImm(Lo); 236 return ResultReg; 237 } 238 239 return TmpReg3; 240 } 241 242 243 // Materialize an integer constant into a register, and return 244 // the register number (or zero if we failed to handle it). 245 unsigned PPCFastISel::PPCMaterializeInt(const Constant *C, MVT VT) { 246 247 if (VT != MVT::i64 && VT != MVT::i32 && VT != MVT::i16 && 248 VT != MVT::i8 && VT != MVT::i1) 249 return 0; 250 251 const TargetRegisterClass *RC = ((VT == MVT::i64) ? &PPC::G8RCRegClass : 252 &PPC::GPRCRegClass); 253 254 // If the constant is in range, use a load-immediate. 255 const ConstantInt *CI = cast<ConstantInt>(C); 256 if (isInt<16>(CI->getSExtValue())) { 257 unsigned Opc = (VT == MVT::i64) ? PPC::LI8 : PPC::LI; 258 unsigned ImmReg = createResultReg(RC); 259 BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(Opc), ImmReg) 260 .addImm(CI->getSExtValue()); 261 return ImmReg; 262 } 263 264 // Construct the constant piecewise. 265 int64_t Imm = CI->getZExtValue(); 266 267 if (VT == MVT::i64) 268 return PPCMaterialize64BitInt(Imm, RC); 269 else if (VT == MVT::i32) 270 return PPCMaterialize32BitInt(Imm, RC); 271 272 return 0; 273 } 274 275 // Materialize a constant into a register, and return the register 276 // number (or zero if we failed to handle it). 277 unsigned PPCFastISel::TargetMaterializeConstant(const Constant *C) { 278 EVT CEVT = TLI.getValueType(C->getType(), true); 279 280 // Only handle simple types. 281 if (!CEVT.isSimple()) return 0; 282 MVT VT = CEVT.getSimpleVT(); 283 284 if (const ConstantFP *CFP = dyn_cast<ConstantFP>(C)) 285 return PPCMaterializeFP(CFP, VT); 286 else if (isa<ConstantInt>(C)) 287 return PPCMaterializeInt(C, VT); 288 // TBD: Global values. 289 290 return 0; 291 } 292 293 // Materialize the address created by an alloca into a register, and 294 // return the register number (or zero if we failed to handle it). TBD. 295 unsigned PPCFastISel::TargetMaterializeAlloca(const AllocaInst *AI) { 296 return AI && 0; 297 } 298 299 // Fold loads into extends when possible. TBD. 300 bool PPCFastISel::tryToFoldLoadIntoMI(MachineInstr *MI, unsigned OpNo, 301 const LoadInst *LI) { 302 return MI && OpNo && LI && false; 303 } 304 305 // Attempt to lower call arguments in a faster way than done by 306 // the selection DAG code. 307 bool PPCFastISel::FastLowerArguments() { 308 // Defer to normal argument lowering for now. It's reasonably 309 // efficient. Consider doing something like ARM to handle the 310 // case where all args fit in registers, no varargs, no float 311 // or vector args. 312 return false; 313 } 314 315 namespace llvm { 316 // Create the fast instruction selector for PowerPC64 ELF. 317 FastISel *PPC::createFastISel(FunctionLoweringInfo &FuncInfo, 318 const TargetLibraryInfo *LibInfo) { 319 const TargetMachine &TM = FuncInfo.MF->getTarget(); 320 321 // Only available on 64-bit ELF for now. 322 const PPCSubtarget *Subtarget = &TM.getSubtarget<PPCSubtarget>(); 323 if (Subtarget->isPPC64() && Subtarget->isSVR4ABI()) 324 return new PPCFastISel(FuncInfo, LibInfo); 325 326 return 0; 327 } 328 } 329