1193326Sed//===-- CGBuilder.h - Choose IRBuilder implementation ----------*- C++ -*-===// 2193326Sed// 3353358Sdim// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4353358Sdim// See https://llvm.org/LICENSE.txt for license information. 5353358Sdim// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6193326Sed// 7193326Sed//===----------------------------------------------------------------------===// 8193326Sed 9280031Sdim#ifndef LLVM_CLANG_LIB_CODEGEN_CGBUILDER_H 10280031Sdim#define LLVM_CLANG_LIB_CODEGEN_CGBUILDER_H 11193326Sed 12309124Sdim#include "llvm/IR/DataLayout.h" 13249423Sdim#include "llvm/IR/IRBuilder.h" 14296417Sdim#include "Address.h" 15296417Sdim#include "CodeGenTypeCache.h" 16193326Sed 17193326Sednamespace clang { 18193326Sednamespace CodeGen { 19210299Sed 20276479Sdimclass CodeGenFunction; 21276479Sdim 22341825Sdim/// This is an IRBuilder insertion helper that forwards to 23280031Sdim/// CodeGenFunction::InsertHelper, which adds necessary metadata to 24276479Sdim/// instructions. 25309124Sdimclass CGBuilderInserter : protected llvm::IRBuilderDefaultInserter { 26276479Sdimpublic: 27296417Sdim CGBuilderInserter() = default; 28276479Sdim explicit CGBuilderInserter(CodeGenFunction *CGF) : CGF(CGF) {} 29276479Sdim 30276479Sdimprotected: 31341825Sdim /// This forwards to CodeGenFunction::InsertHelper. 32276479Sdim void InsertHelper(llvm::Instruction *I, const llvm::Twine &Name, 33276479Sdim llvm::BasicBlock *BB, 34276479Sdim llvm::BasicBlock::iterator InsertPt) const; 35276479Sdimprivate: 36296417Sdim CodeGenFunction *CGF = nullptr; 37276479Sdim}; 38276479Sdim 39309124Sdimtypedef CGBuilderInserter CGBuilderInserterTy; 40296417Sdim 41309124Sdimtypedef llvm::IRBuilder<llvm::ConstantFolder, CGBuilderInserterTy> 42309124Sdim CGBuilderBaseTy; 43296417Sdim 44296417Sdimclass CGBuilderTy : public CGBuilderBaseTy { 45296417Sdim /// Storing a reference to the type cache here makes it a lot easier 46296417Sdim /// to build natural-feeling, target-specific IR. 47296417Sdim const CodeGenTypeCache &TypeCache; 48296417Sdimpublic: 49296417Sdim CGBuilderTy(const CodeGenTypeCache &TypeCache, llvm::LLVMContext &C) 50296417Sdim : CGBuilderBaseTy(C), TypeCache(TypeCache) {} 51296417Sdim CGBuilderTy(const CodeGenTypeCache &TypeCache, 52296417Sdim llvm::LLVMContext &C, const llvm::ConstantFolder &F, 53296417Sdim const CGBuilderInserterTy &Inserter) 54296417Sdim : CGBuilderBaseTy(C, F, Inserter), TypeCache(TypeCache) {} 55296417Sdim CGBuilderTy(const CodeGenTypeCache &TypeCache, llvm::Instruction *I) 56296417Sdim : CGBuilderBaseTy(I), TypeCache(TypeCache) {} 57296417Sdim CGBuilderTy(const CodeGenTypeCache &TypeCache, llvm::BasicBlock *BB) 58296417Sdim : CGBuilderBaseTy(BB), TypeCache(TypeCache) {} 59296417Sdim 60296417Sdim llvm::ConstantInt *getSize(CharUnits N) { 61296417Sdim return llvm::ConstantInt::get(TypeCache.SizeTy, N.getQuantity()); 62296417Sdim } 63296417Sdim llvm::ConstantInt *getSize(uint64_t N) { 64296417Sdim return llvm::ConstantInt::get(TypeCache.SizeTy, N); 65296417Sdim } 66296417Sdim 67296417Sdim // Note that we intentionally hide the CreateLoad APIs that don't 68296417Sdim // take an alignment. 69296417Sdim llvm::LoadInst *CreateLoad(Address Addr, const llvm::Twine &Name = "") { 70296417Sdim return CreateAlignedLoad(Addr.getPointer(), 71296417Sdim Addr.getAlignment().getQuantity(), 72296417Sdim Name); 73296417Sdim } 74296417Sdim llvm::LoadInst *CreateLoad(Address Addr, const char *Name) { 75296417Sdim // This overload is required to prevent string literals from 76296417Sdim // ending up in the IsVolatile overload. 77296417Sdim return CreateAlignedLoad(Addr.getPointer(), 78296417Sdim Addr.getAlignment().getQuantity(), 79296417Sdim Name); 80296417Sdim } 81296417Sdim llvm::LoadInst *CreateLoad(Address Addr, bool IsVolatile, 82296417Sdim const llvm::Twine &Name = "") { 83296417Sdim return CreateAlignedLoad(Addr.getPointer(), 84296417Sdim Addr.getAlignment().getQuantity(), 85296417Sdim IsVolatile, 86296417Sdim Name); 87296417Sdim } 88296417Sdim 89296417Sdim using CGBuilderBaseTy::CreateAlignedLoad; 90296417Sdim llvm::LoadInst *CreateAlignedLoad(llvm::Value *Addr, CharUnits Align, 91296417Sdim const llvm::Twine &Name = "") { 92296417Sdim return CreateAlignedLoad(Addr, Align.getQuantity(), Name); 93296417Sdim } 94296417Sdim llvm::LoadInst *CreateAlignedLoad(llvm::Value *Addr, CharUnits Align, 95296417Sdim const char *Name) { 96296417Sdim return CreateAlignedLoad(Addr, Align.getQuantity(), Name); 97296417Sdim } 98296417Sdim llvm::LoadInst *CreateAlignedLoad(llvm::Type *Ty, llvm::Value *Addr, 99296417Sdim CharUnits Align, 100296417Sdim const llvm::Twine &Name = "") { 101296417Sdim assert(Addr->getType()->getPointerElementType() == Ty); 102296417Sdim return CreateAlignedLoad(Addr, Align.getQuantity(), Name); 103296417Sdim } 104296417Sdim 105296417Sdim // Note that we intentionally hide the CreateStore APIs that don't 106296417Sdim // take an alignment. 107296417Sdim llvm::StoreInst *CreateStore(llvm::Value *Val, Address Addr, 108296417Sdim bool IsVolatile = false) { 109296417Sdim return CreateAlignedStore(Val, Addr.getPointer(), 110360784Sdim Addr.getAlignment().getAsAlign(), IsVolatile); 111296417Sdim } 112296417Sdim 113296417Sdim using CGBuilderBaseTy::CreateAlignedStore; 114296417Sdim llvm::StoreInst *CreateAlignedStore(llvm::Value *Val, llvm::Value *Addr, 115296417Sdim CharUnits Align, bool IsVolatile = false) { 116296417Sdim return CreateAlignedStore(Val, Addr, Align.getQuantity(), IsVolatile); 117296417Sdim } 118341825Sdim 119296417Sdim // FIXME: these "default-aligned" APIs should be removed, 120296417Sdim // but I don't feel like fixing all the builtin code right now. 121296417Sdim llvm::StoreInst *CreateDefaultAlignedStore(llvm::Value *Val, 122296417Sdim llvm::Value *Addr, 123296417Sdim bool IsVolatile = false) { 124296417Sdim return CGBuilderBaseTy::CreateStore(Val, Addr, IsVolatile); 125296417Sdim } 126296417Sdim 127296417Sdim /// Emit a load from an i1 flag variable. 128296417Sdim llvm::LoadInst *CreateFlagLoad(llvm::Value *Addr, 129296417Sdim const llvm::Twine &Name = "") { 130296417Sdim assert(Addr->getType()->getPointerElementType() == getInt1Ty()); 131296417Sdim return CreateAlignedLoad(getInt1Ty(), Addr, CharUnits::One(), Name); 132296417Sdim } 133296417Sdim 134296417Sdim /// Emit a store to an i1 flag variable. 135296417Sdim llvm::StoreInst *CreateFlagStore(bool Value, llvm::Value *Addr) { 136296417Sdim assert(Addr->getType()->getPointerElementType() == getInt1Ty()); 137296417Sdim return CreateAlignedStore(getInt1(Value), Addr, CharUnits::One()); 138296417Sdim } 139296417Sdim 140296417Sdim using CGBuilderBaseTy::CreateBitCast; 141296417Sdim Address CreateBitCast(Address Addr, llvm::Type *Ty, 142296417Sdim const llvm::Twine &Name = "") { 143296417Sdim return Address(CreateBitCast(Addr.getPointer(), Ty, Name), 144296417Sdim Addr.getAlignment()); 145296417Sdim } 146296417Sdim 147327952Sdim using CGBuilderBaseTy::CreateAddrSpaceCast; 148327952Sdim Address CreateAddrSpaceCast(Address Addr, llvm::Type *Ty, 149327952Sdim const llvm::Twine &Name = "") { 150327952Sdim return Address(CreateAddrSpaceCast(Addr.getPointer(), Ty, Name), 151327952Sdim Addr.getAlignment()); 152327952Sdim } 153327952Sdim 154296417Sdim /// Cast the element type of the given address to a different type, 155296417Sdim /// preserving information like the alignment and address space. 156296417Sdim Address CreateElementBitCast(Address Addr, llvm::Type *Ty, 157296417Sdim const llvm::Twine &Name = "") { 158296417Sdim auto PtrTy = Ty->getPointerTo(Addr.getAddressSpace()); 159296417Sdim return CreateBitCast(Addr, PtrTy, Name); 160296417Sdim } 161296417Sdim 162296417Sdim using CGBuilderBaseTy::CreatePointerBitCastOrAddrSpaceCast; 163296417Sdim Address CreatePointerBitCastOrAddrSpaceCast(Address Addr, llvm::Type *Ty, 164296417Sdim const llvm::Twine &Name = "") { 165296417Sdim llvm::Value *Ptr = 166296417Sdim CreatePointerBitCastOrAddrSpaceCast(Addr.getPointer(), Ty, Name); 167296417Sdim return Address(Ptr, Addr.getAlignment()); 168296417Sdim } 169296417Sdim 170353358Sdim /// Given 171353358Sdim /// %addr = {T1, T2...}* ... 172353358Sdim /// produce 173353358Sdim /// %name = getelementptr inbounds %addr, i32 0, i32 index 174353358Sdim /// 175353358Sdim /// This API assumes that drilling into a struct like this is always an 176353358Sdim /// inbounds operation. 177296417Sdim using CGBuilderBaseTy::CreateStructGEP; 178353358Sdim Address CreateStructGEP(Address Addr, unsigned Index, 179296417Sdim const llvm::Twine &Name = "") { 180353358Sdim llvm::StructType *ElTy = cast<llvm::StructType>(Addr.getElementType()); 181353358Sdim const llvm::DataLayout &DL = BB->getParent()->getParent()->getDataLayout(); 182353358Sdim const llvm::StructLayout *Layout = DL.getStructLayout(ElTy); 183353358Sdim auto Offset = CharUnits::fromQuantity(Layout->getElementOffset(Index)); 184353358Sdim 185296417Sdim return Address(CreateStructGEP(Addr.getElementType(), 186296417Sdim Addr.getPointer(), Index, Name), 187296417Sdim Addr.getAlignment().alignmentAtOffset(Offset)); 188296417Sdim } 189296417Sdim 190296417Sdim /// Given 191296417Sdim /// %addr = [n x T]* ... 192296417Sdim /// produce 193296417Sdim /// %name = getelementptr inbounds %addr, i64 0, i64 index 194296417Sdim /// where i64 is actually the target word size. 195296417Sdim /// 196296417Sdim /// This API assumes that drilling into an array like this is always 197296417Sdim /// an inbounds operation. 198353358Sdim Address CreateConstArrayGEP(Address Addr, uint64_t Index, 199296417Sdim const llvm::Twine &Name = "") { 200353358Sdim llvm::ArrayType *ElTy = cast<llvm::ArrayType>(Addr.getElementType()); 201353358Sdim const llvm::DataLayout &DL = BB->getParent()->getParent()->getDataLayout(); 202353358Sdim CharUnits EltSize = 203353358Sdim CharUnits::fromQuantity(DL.getTypeAllocSize(ElTy->getElementType())); 204353358Sdim 205353358Sdim return Address( 206353358Sdim CreateInBoundsGEP(Addr.getPointer(), 207353358Sdim {getSize(CharUnits::Zero()), getSize(Index)}, Name), 208353358Sdim Addr.getAlignment().alignmentAtOffset(Index * EltSize)); 209296417Sdim } 210296417Sdim 211296417Sdim /// Given 212296417Sdim /// %addr = T* ... 213296417Sdim /// produce 214296417Sdim /// %name = getelementptr inbounds %addr, i64 index 215296417Sdim /// where i64 is actually the target word size. 216296417Sdim Address CreateConstInBoundsGEP(Address Addr, uint64_t Index, 217296417Sdim const llvm::Twine &Name = "") { 218353358Sdim llvm::Type *ElTy = Addr.getElementType(); 219353358Sdim const llvm::DataLayout &DL = BB->getParent()->getParent()->getDataLayout(); 220353358Sdim CharUnits EltSize = CharUnits::fromQuantity(DL.getTypeAllocSize(ElTy)); 221353358Sdim 222296417Sdim return Address(CreateInBoundsGEP(Addr.getElementType(), Addr.getPointer(), 223296417Sdim getSize(Index), Name), 224296417Sdim Addr.getAlignment().alignmentAtOffset(Index * EltSize)); 225296417Sdim } 226296417Sdim 227296417Sdim /// Given 228296417Sdim /// %addr = T* ... 229296417Sdim /// produce 230296417Sdim /// %name = getelementptr inbounds %addr, i64 index 231296417Sdim /// where i64 is actually the target word size. 232353358Sdim Address CreateConstGEP(Address Addr, uint64_t Index, 233296417Sdim const llvm::Twine &Name = "") { 234353358Sdim const llvm::DataLayout &DL = BB->getParent()->getParent()->getDataLayout(); 235353358Sdim CharUnits EltSize = 236353358Sdim CharUnits::fromQuantity(DL.getTypeAllocSize(Addr.getElementType())); 237353358Sdim 238296417Sdim return Address(CreateGEP(Addr.getElementType(), Addr.getPointer(), 239296417Sdim getSize(Index), Name), 240296417Sdim Addr.getAlignment().alignmentAtOffset(Index * EltSize)); 241296417Sdim } 242296417Sdim 243296417Sdim /// Given a pointer to i8, adjust it by a given constant offset. 244296417Sdim Address CreateConstInBoundsByteGEP(Address Addr, CharUnits Offset, 245296417Sdim const llvm::Twine &Name = "") { 246296417Sdim assert(Addr.getElementType() == TypeCache.Int8Ty); 247296417Sdim return Address(CreateInBoundsGEP(Addr.getPointer(), getSize(Offset), Name), 248296417Sdim Addr.getAlignment().alignmentAtOffset(Offset)); 249296417Sdim } 250296417Sdim Address CreateConstByteGEP(Address Addr, CharUnits Offset, 251296417Sdim const llvm::Twine &Name = "") { 252296417Sdim assert(Addr.getElementType() == TypeCache.Int8Ty); 253296417Sdim return Address(CreateGEP(Addr.getPointer(), getSize(Offset), Name), 254296417Sdim Addr.getAlignment().alignmentAtOffset(Offset)); 255296417Sdim } 256296417Sdim 257341825Sdim using CGBuilderBaseTy::CreateConstInBoundsGEP2_32; 258353358Sdim Address CreateConstInBoundsGEP2_32(Address Addr, unsigned Idx0, unsigned Idx1, 259353358Sdim const llvm::Twine &Name = "") { 260353358Sdim const llvm::DataLayout &DL = BB->getParent()->getParent()->getDataLayout(); 261353358Sdim 262341825Sdim auto *GEP = cast<llvm::GetElementPtrInst>(CreateConstInBoundsGEP2_32( 263341825Sdim Addr.getElementType(), Addr.getPointer(), Idx0, Idx1, Name)); 264341825Sdim llvm::APInt Offset( 265341825Sdim DL.getIndexSizeInBits(Addr.getType()->getPointerAddressSpace()), 0, 266353358Sdim /*isSigned=*/true); 267341825Sdim if (!GEP->accumulateConstantOffset(DL, Offset)) 268341825Sdim llvm_unreachable("offset of GEP with constants is always computable"); 269341825Sdim return Address(GEP, Addr.getAlignment().alignmentAtOffset( 270341825Sdim CharUnits::fromQuantity(Offset.getSExtValue()))); 271341825Sdim } 272341825Sdim 273296417Sdim using CGBuilderBaseTy::CreateMemCpy; 274296417Sdim llvm::CallInst *CreateMemCpy(Address Dest, Address Src, llvm::Value *Size, 275296417Sdim bool IsVolatile = false) { 276360784Sdim return CreateMemCpy(Dest.getPointer(), Dest.getAlignment().getAsAlign(), 277360784Sdim Src.getPointer(), Src.getAlignment().getAsAlign(), Size, 278360784Sdim IsVolatile); 279296417Sdim } 280296417Sdim llvm::CallInst *CreateMemCpy(Address Dest, Address Src, uint64_t Size, 281296417Sdim bool IsVolatile = false) { 282360784Sdim return CreateMemCpy(Dest.getPointer(), Dest.getAlignment().getAsAlign(), 283360784Sdim Src.getPointer(), Src.getAlignment().getAsAlign(), Size, 284360784Sdim IsVolatile); 285296417Sdim } 286296417Sdim 287296417Sdim using CGBuilderBaseTy::CreateMemMove; 288296417Sdim llvm::CallInst *CreateMemMove(Address Dest, Address Src, llvm::Value *Size, 289296417Sdim bool IsVolatile = false) { 290360784Sdim return CreateMemMove(Dest.getPointer(), Dest.getAlignment().getAsAlign(), 291360784Sdim Src.getPointer(), Src.getAlignment().getAsAlign(), 292341825Sdim Size, IsVolatile); 293296417Sdim } 294296417Sdim 295296417Sdim using CGBuilderBaseTy::CreateMemSet; 296296417Sdim llvm::CallInst *CreateMemSet(Address Dest, llvm::Value *Value, 297296417Sdim llvm::Value *Size, bool IsVolatile = false) { 298296417Sdim return CreateMemSet(Dest.getPointer(), Value, Size, 299360784Sdim Dest.getAlignment().getAsAlign(), IsVolatile); 300296417Sdim } 301353358Sdim 302353358Sdim using CGBuilderBaseTy::CreatePreserveStructAccessIndex; 303353358Sdim Address CreatePreserveStructAccessIndex(Address Addr, 304353358Sdim unsigned Index, 305353358Sdim unsigned FieldIndex, 306353358Sdim llvm::MDNode *DbgInfo) { 307353358Sdim llvm::StructType *ElTy = cast<llvm::StructType>(Addr.getElementType()); 308353358Sdim const llvm::DataLayout &DL = BB->getParent()->getParent()->getDataLayout(); 309353358Sdim const llvm::StructLayout *Layout = DL.getStructLayout(ElTy); 310353358Sdim auto Offset = CharUnits::fromQuantity(Layout->getElementOffset(Index)); 311353358Sdim 312360784Sdim return Address(CreatePreserveStructAccessIndex(ElTy, Addr.getPointer(), 313353358Sdim Index, FieldIndex, DbgInfo), 314353358Sdim Addr.getAlignment().alignmentAtOffset(Offset)); 315353358Sdim } 316296417Sdim}; 317296417Sdim 318193326Sed} // end namespace CodeGen 319193326Sed} // end namespace clang 320193326Sed 321193326Sed#endif 322