1 //===-- CGBuilder.h - Choose IRBuilder implementation ----------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #ifndef LLVM_CLANG_LIB_CODEGEN_CGBUILDER_H 10 #define LLVM_CLANG_LIB_CODEGEN_CGBUILDER_H 11 12 #include "llvm/IR/DataLayout.h" 13 #include "llvm/IR/IRBuilder.h" 14 #include "Address.h" 15 #include "CodeGenTypeCache.h" 16 17 namespace clang { 18 namespace CodeGen { 19 20 class CodeGenFunction; 21 22 /// This is an IRBuilder insertion helper that forwards to 23 /// CodeGenFunction::InsertHelper, which adds necessary metadata to 24 /// instructions. 25 class CGBuilderInserter : protected llvm::IRBuilderDefaultInserter { 26 public: 27 CGBuilderInserter() = default; 28 explicit CGBuilderInserter(CodeGenFunction *CGF) : CGF(CGF) {} 29 30 protected: 31 /// This forwards to CodeGenFunction::InsertHelper. 32 void InsertHelper(llvm::Instruction *I, const llvm::Twine &Name, 33 llvm::BasicBlock *BB, 34 llvm::BasicBlock::iterator InsertPt) const; 35 private: 36 CodeGenFunction *CGF = nullptr; 37 }; 38 39 typedef CGBuilderInserter CGBuilderInserterTy; 40 41 typedef llvm::IRBuilder<llvm::ConstantFolder, CGBuilderInserterTy> 42 CGBuilderBaseTy; 43 44 class CGBuilderTy : public CGBuilderBaseTy { 45 /// Storing a reference to the type cache here makes it a lot easier 46 /// to build natural-feeling, target-specific IR. 47 const CodeGenTypeCache &TypeCache; 48 public: 49 CGBuilderTy(const CodeGenTypeCache &TypeCache, llvm::LLVMContext &C) 50 : CGBuilderBaseTy(C), TypeCache(TypeCache) {} 51 CGBuilderTy(const CodeGenTypeCache &TypeCache, 52 llvm::LLVMContext &C, const llvm::ConstantFolder &F, 53 const CGBuilderInserterTy &Inserter) 54 : CGBuilderBaseTy(C, F, Inserter), TypeCache(TypeCache) {} 55 CGBuilderTy(const CodeGenTypeCache &TypeCache, llvm::Instruction *I) 56 : CGBuilderBaseTy(I), TypeCache(TypeCache) {} 57 CGBuilderTy(const CodeGenTypeCache &TypeCache, llvm::BasicBlock *BB) 58 : CGBuilderBaseTy(BB), TypeCache(TypeCache) {} 59 60 llvm::ConstantInt *getSize(CharUnits N) { 61 return llvm::ConstantInt::get(TypeCache.SizeTy, N.getQuantity()); 62 } 63 llvm::ConstantInt *getSize(uint64_t N) { 64 return llvm::ConstantInt::get(TypeCache.SizeTy, N); 65 } 66 67 // Note that we intentionally hide the CreateLoad APIs that don't 68 // take an alignment. 69 llvm::LoadInst *CreateLoad(Address Addr, const llvm::Twine &Name = "") { 70 return CreateAlignedLoad(Addr.getPointer(), 71 Addr.getAlignment().getAsAlign(), Name); 72 } 73 llvm::LoadInst *CreateLoad(Address Addr, const char *Name) { 74 // This overload is required to prevent string literals from 75 // ending up in the IsVolatile overload. 76 return CreateAlignedLoad(Addr.getPointer(), 77 Addr.getAlignment().getAsAlign(), Name); 78 } 79 llvm::LoadInst *CreateLoad(Address Addr, bool IsVolatile, 80 const llvm::Twine &Name = "") { 81 return CreateAlignedLoad( 82 Addr.getPointer(), Addr.getAlignment().getAsAlign(), IsVolatile, Name); 83 } 84 85 using CGBuilderBaseTy::CreateAlignedLoad; 86 llvm::LoadInst *CreateAlignedLoad(llvm::Value *Addr, CharUnits Align, 87 const llvm::Twine &Name = "") { 88 return CreateAlignedLoad(Addr, Align.getAsAlign(), Name); 89 } 90 llvm::LoadInst *CreateAlignedLoad(llvm::Value *Addr, CharUnits Align, 91 const char *Name) { 92 return CreateAlignedLoad(Addr, Align.getAsAlign(), Name); 93 } 94 llvm::LoadInst *CreateAlignedLoad(llvm::Type *Ty, llvm::Value *Addr, 95 CharUnits Align, 96 const llvm::Twine &Name = "") { 97 assert(Addr->getType()->getPointerElementType() == Ty); 98 return CreateAlignedLoad(Addr, Align.getAsAlign(), Name); 99 } 100 101 // Note that we intentionally hide the CreateStore APIs that don't 102 // take an alignment. 103 llvm::StoreInst *CreateStore(llvm::Value *Val, Address Addr, 104 bool IsVolatile = false) { 105 return CreateAlignedStore(Val, Addr.getPointer(), 106 Addr.getAlignment().getAsAlign(), IsVolatile); 107 } 108 109 using CGBuilderBaseTy::CreateAlignedStore; 110 llvm::StoreInst *CreateAlignedStore(llvm::Value *Val, llvm::Value *Addr, 111 CharUnits Align, bool IsVolatile = false) { 112 return CreateAlignedStore(Val, Addr, Align.getAsAlign(), IsVolatile); 113 } 114 115 // FIXME: these "default-aligned" APIs should be removed, 116 // but I don't feel like fixing all the builtin code right now. 117 llvm::StoreInst *CreateDefaultAlignedStore(llvm::Value *Val, 118 llvm::Value *Addr, 119 bool IsVolatile = false) { 120 return CGBuilderBaseTy::CreateStore(Val, Addr, IsVolatile); 121 } 122 123 /// Emit a load from an i1 flag variable. 124 llvm::LoadInst *CreateFlagLoad(llvm::Value *Addr, 125 const llvm::Twine &Name = "") { 126 assert(Addr->getType()->getPointerElementType() == getInt1Ty()); 127 return CreateAlignedLoad(getInt1Ty(), Addr, CharUnits::One(), Name); 128 } 129 130 /// Emit a store to an i1 flag variable. 131 llvm::StoreInst *CreateFlagStore(bool Value, llvm::Value *Addr) { 132 assert(Addr->getType()->getPointerElementType() == getInt1Ty()); 133 return CreateAlignedStore(getInt1(Value), Addr, CharUnits::One()); 134 } 135 136 using CGBuilderBaseTy::CreateBitCast; 137 Address CreateBitCast(Address Addr, llvm::Type *Ty, 138 const llvm::Twine &Name = "") { 139 return Address(CreateBitCast(Addr.getPointer(), Ty, Name), 140 Addr.getAlignment()); 141 } 142 143 using CGBuilderBaseTy::CreateAddrSpaceCast; 144 Address CreateAddrSpaceCast(Address Addr, llvm::Type *Ty, 145 const llvm::Twine &Name = "") { 146 return Address(CreateAddrSpaceCast(Addr.getPointer(), Ty, Name), 147 Addr.getAlignment()); 148 } 149 150 /// Cast the element type of the given address to a different type, 151 /// preserving information like the alignment and address space. 152 Address CreateElementBitCast(Address Addr, llvm::Type *Ty, 153 const llvm::Twine &Name = "") { 154 auto PtrTy = Ty->getPointerTo(Addr.getAddressSpace()); 155 return CreateBitCast(Addr, PtrTy, Name); 156 } 157 158 using CGBuilderBaseTy::CreatePointerBitCastOrAddrSpaceCast; 159 Address CreatePointerBitCastOrAddrSpaceCast(Address Addr, llvm::Type *Ty, 160 const llvm::Twine &Name = "") { 161 llvm::Value *Ptr = 162 CreatePointerBitCastOrAddrSpaceCast(Addr.getPointer(), Ty, Name); 163 return Address(Ptr, Addr.getAlignment()); 164 } 165 166 /// Given 167 /// %addr = {T1, T2...}* ... 168 /// produce 169 /// %name = getelementptr inbounds %addr, i32 0, i32 index 170 /// 171 /// This API assumes that drilling into a struct like this is always an 172 /// inbounds operation. 173 using CGBuilderBaseTy::CreateStructGEP; 174 Address CreateStructGEP(Address Addr, unsigned Index, 175 const llvm::Twine &Name = "") { 176 llvm::StructType *ElTy = cast<llvm::StructType>(Addr.getElementType()); 177 const llvm::DataLayout &DL = BB->getParent()->getParent()->getDataLayout(); 178 const llvm::StructLayout *Layout = DL.getStructLayout(ElTy); 179 auto Offset = CharUnits::fromQuantity(Layout->getElementOffset(Index)); 180 181 return Address(CreateStructGEP(Addr.getElementType(), 182 Addr.getPointer(), Index, Name), 183 Addr.getAlignment().alignmentAtOffset(Offset)); 184 } 185 186 /// Given 187 /// %addr = [n x T]* ... 188 /// produce 189 /// %name = getelementptr inbounds %addr, i64 0, i64 index 190 /// where i64 is actually the target word size. 191 /// 192 /// This API assumes that drilling into an array like this is always 193 /// an inbounds operation. 194 Address CreateConstArrayGEP(Address Addr, uint64_t Index, 195 const llvm::Twine &Name = "") { 196 llvm::ArrayType *ElTy = cast<llvm::ArrayType>(Addr.getElementType()); 197 const llvm::DataLayout &DL = BB->getParent()->getParent()->getDataLayout(); 198 CharUnits EltSize = 199 CharUnits::fromQuantity(DL.getTypeAllocSize(ElTy->getElementType())); 200 201 return Address( 202 CreateInBoundsGEP(Addr.getPointer(), 203 {getSize(CharUnits::Zero()), getSize(Index)}, Name), 204 Addr.getAlignment().alignmentAtOffset(Index * EltSize)); 205 } 206 207 /// Given 208 /// %addr = T* ... 209 /// produce 210 /// %name = getelementptr inbounds %addr, i64 index 211 /// where i64 is actually the target word size. 212 Address CreateConstInBoundsGEP(Address Addr, uint64_t Index, 213 const llvm::Twine &Name = "") { 214 llvm::Type *ElTy = Addr.getElementType(); 215 const llvm::DataLayout &DL = BB->getParent()->getParent()->getDataLayout(); 216 CharUnits EltSize = CharUnits::fromQuantity(DL.getTypeAllocSize(ElTy)); 217 218 return Address(CreateInBoundsGEP(Addr.getElementType(), Addr.getPointer(), 219 getSize(Index), Name), 220 Addr.getAlignment().alignmentAtOffset(Index * EltSize)); 221 } 222 223 /// Given 224 /// %addr = T* ... 225 /// produce 226 /// %name = getelementptr inbounds %addr, i64 index 227 /// where i64 is actually the target word size. 228 Address CreateConstGEP(Address Addr, uint64_t Index, 229 const llvm::Twine &Name = "") { 230 const llvm::DataLayout &DL = BB->getParent()->getParent()->getDataLayout(); 231 CharUnits EltSize = 232 CharUnits::fromQuantity(DL.getTypeAllocSize(Addr.getElementType())); 233 234 return Address(CreateGEP(Addr.getElementType(), Addr.getPointer(), 235 getSize(Index), Name), 236 Addr.getAlignment().alignmentAtOffset(Index * EltSize)); 237 } 238 239 /// Given a pointer to i8, adjust it by a given constant offset. 240 Address CreateConstInBoundsByteGEP(Address Addr, CharUnits Offset, 241 const llvm::Twine &Name = "") { 242 assert(Addr.getElementType() == TypeCache.Int8Ty); 243 return Address(CreateInBoundsGEP(Addr.getPointer(), getSize(Offset), Name), 244 Addr.getAlignment().alignmentAtOffset(Offset)); 245 } 246 Address CreateConstByteGEP(Address Addr, CharUnits Offset, 247 const llvm::Twine &Name = "") { 248 assert(Addr.getElementType() == TypeCache.Int8Ty); 249 return Address(CreateGEP(Addr.getPointer(), getSize(Offset), Name), 250 Addr.getAlignment().alignmentAtOffset(Offset)); 251 } 252 253 using CGBuilderBaseTy::CreateConstInBoundsGEP2_32; 254 Address CreateConstInBoundsGEP2_32(Address Addr, unsigned Idx0, unsigned Idx1, 255 const llvm::Twine &Name = "") { 256 const llvm::DataLayout &DL = BB->getParent()->getParent()->getDataLayout(); 257 258 auto *GEP = cast<llvm::GetElementPtrInst>(CreateConstInBoundsGEP2_32( 259 Addr.getElementType(), Addr.getPointer(), Idx0, Idx1, Name)); 260 llvm::APInt Offset( 261 DL.getIndexSizeInBits(Addr.getType()->getPointerAddressSpace()), 0, 262 /*isSigned=*/true); 263 if (!GEP->accumulateConstantOffset(DL, Offset)) 264 llvm_unreachable("offset of GEP with constants is always computable"); 265 return Address(GEP, Addr.getAlignment().alignmentAtOffset( 266 CharUnits::fromQuantity(Offset.getSExtValue()))); 267 } 268 269 using CGBuilderBaseTy::CreateMemCpy; 270 llvm::CallInst *CreateMemCpy(Address Dest, Address Src, llvm::Value *Size, 271 bool IsVolatile = false) { 272 return CreateMemCpy(Dest.getPointer(), Dest.getAlignment().getAsAlign(), 273 Src.getPointer(), Src.getAlignment().getAsAlign(), Size, 274 IsVolatile); 275 } 276 llvm::CallInst *CreateMemCpy(Address Dest, Address Src, uint64_t Size, 277 bool IsVolatile = false) { 278 return CreateMemCpy(Dest.getPointer(), Dest.getAlignment().getAsAlign(), 279 Src.getPointer(), Src.getAlignment().getAsAlign(), Size, 280 IsVolatile); 281 } 282 283 using CGBuilderBaseTy::CreateMemCpyInline; 284 llvm::CallInst *CreateMemCpyInline(Address Dest, Address Src, uint64_t Size) { 285 return CreateMemCpyInline( 286 Dest.getPointer(), Dest.getAlignment().getAsAlign(), Src.getPointer(), 287 Src.getAlignment().getAsAlign(), getInt64(Size)); 288 } 289 290 using CGBuilderBaseTy::CreateMemMove; 291 llvm::CallInst *CreateMemMove(Address Dest, Address Src, llvm::Value *Size, 292 bool IsVolatile = false) { 293 return CreateMemMove(Dest.getPointer(), Dest.getAlignment().getAsAlign(), 294 Src.getPointer(), Src.getAlignment().getAsAlign(), 295 Size, IsVolatile); 296 } 297 298 using CGBuilderBaseTy::CreateMemSet; 299 llvm::CallInst *CreateMemSet(Address Dest, llvm::Value *Value, 300 llvm::Value *Size, bool IsVolatile = false) { 301 return CreateMemSet(Dest.getPointer(), Value, Size, 302 Dest.getAlignment().getAsAlign(), IsVolatile); 303 } 304 305 using CGBuilderBaseTy::CreatePreserveStructAccessIndex; 306 Address CreatePreserveStructAccessIndex(Address Addr, 307 unsigned Index, 308 unsigned FieldIndex, 309 llvm::MDNode *DbgInfo) { 310 llvm::StructType *ElTy = cast<llvm::StructType>(Addr.getElementType()); 311 const llvm::DataLayout &DL = BB->getParent()->getParent()->getDataLayout(); 312 const llvm::StructLayout *Layout = DL.getStructLayout(ElTy); 313 auto Offset = CharUnits::fromQuantity(Layout->getElementOffset(Index)); 314 315 return Address(CreatePreserveStructAccessIndex(ElTy, Addr.getPointer(), 316 Index, FieldIndex, DbgInfo), 317 Addr.getAlignment().alignmentAtOffset(Offset)); 318 } 319 }; 320 321 } // end namespace CodeGen 322 } // end namespace clang 323 324 #endif 325