clang/lib/CodeGen/CGBuilder.h

   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 "Address.h"
  13 #include "CodeGenTypeCache.h"
  14 #include "llvm/IR/DataLayout.h"
  15 #include "llvm/IR/IRBuilder.h"
  16 #include "llvm/IR/Type.h"
  17
  18 namespace clang {
  19 namespace CodeGen {
  20
  21 class CodeGenFunction;
  22
  23 /// This is an IRBuilder insertion helper that forwards to
  24 /// CodeGenFunction::InsertHelper, which adds necessary metadata to
  25 /// instructions.
  26 class CGBuilderInserter final : public llvm::IRBuilderDefaultInserter {
  27 public:
  28   CGBuilderInserter() = default;
  29   explicit CGBuilderInserter(CodeGenFunction *CGF) : CGF(CGF) {}
  30
  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 override;
  35
  36 private:
  37   CodeGenFunction *CGF = nullptr;
  38 };
  39
  40 typedef CGBuilderInserter CGBuilderInserterTy;
  41
  42 typedef llvm::IRBuilder<llvm::ConstantFolder, CGBuilderInserterTy>
  43     CGBuilderBaseTy;
  44
  45 class CGBuilderTy : public CGBuilderBaseTy {
  46   /// Storing a reference to the type cache here makes it a lot easier
  47   /// to build natural-feeling, target-specific IR.
  48   const CodeGenTypeCache &TypeCache;
  49
  50 public:
  51   CGBuilderTy(const CodeGenTypeCache &TypeCache, llvm::LLVMContext &C)
  52       : CGBuilderBaseTy(C), TypeCache(TypeCache) {}
  53   CGBuilderTy(const CodeGenTypeCache &TypeCache, llvm::LLVMContext &C,
  54               const llvm::ConstantFolder &F,
  55               const CGBuilderInserterTy &Inserter)
  56       : CGBuilderBaseTy(C, F, Inserter), TypeCache(TypeCache) {}
  57   CGBuilderTy(const CodeGenTypeCache &TypeCache, llvm::Instruction *I)
  58       : CGBuilderBaseTy(I), TypeCache(TypeCache) {}
  59   CGBuilderTy(const CodeGenTypeCache &TypeCache, llvm::BasicBlock *BB)
  60       : CGBuilderBaseTy(BB), TypeCache(TypeCache) {}
  61
  62   llvm::ConstantInt *getSize(CharUnits N) {
  63     return llvm::ConstantInt::get(TypeCache.SizeTy, N.getQuantity());
  64   }
  65   llvm::ConstantInt *getSize(uint64_t N) {
  66     return llvm::ConstantInt::get(TypeCache.SizeTy, N);
  67   }
  68
  69   // Note that we intentionally hide the CreateLoad APIs that don't
  70   // take an alignment.
  71   llvm::LoadInst *CreateLoad(Address Addr, const llvm::Twine &Name = "") {
  72     return CreateAlignedLoad(Addr.getElementType(), Addr.getPointer(),
  73                              Addr.getAlignment().getAsAlign(), Name);
  74   }
  75   llvm::LoadInst *CreateLoad(Address Addr, const char *Name) {
  76     // This overload is required to prevent string literals from
  77     // ending up in the IsVolatile overload.
  78     return CreateAlignedLoad(Addr.getElementType(), Addr.getPointer(),
  79                              Addr.getAlignment().getAsAlign(), Name);
  80   }
  81   llvm::LoadInst *CreateLoad(Address Addr, bool IsVolatile,
  82                              const llvm::Twine &Name = "") {
  83     return CreateAlignedLoad(Addr.getElementType(), Addr.getPointer(),
  84                              Addr.getAlignment().getAsAlign(), IsVolatile,
  85                              Name);
  86   }
  87
  88   using CGBuilderBaseTy::CreateAlignedLoad;
  89   llvm::LoadInst *CreateAlignedLoad(llvm::Type *Ty, llvm::Value *Addr,
  90                                     CharUnits Align,
  91                                     const llvm::Twine &Name = "") {
  92     assert(llvm::cast<llvm::PointerType>(Addr->getType())
  93                ->isOpaqueOrPointeeTypeMatches(Ty));
  94     return CreateAlignedLoad(Ty, Addr, Align.getAsAlign(), Name);
  95   }
  96
  97   // Note that we intentionally hide the CreateStore APIs that don't
  98   // take an alignment.
  99   llvm::StoreInst *CreateStore(llvm::Value *Val, Address Addr,
 100                                bool IsVolatile = false) {
 101     return CreateAlignedStore(Val, Addr.getPointer(),
 102                               Addr.getAlignment().getAsAlign(), IsVolatile);
 103   }
 104
 105   using CGBuilderBaseTy::CreateAlignedStore;
 106   llvm::StoreInst *CreateAlignedStore(llvm::Value *Val, llvm::Value *Addr,
 107                                       CharUnits Align,
 108                                       bool IsVolatile = false) {
 109     return CreateAlignedStore(Val, Addr, Align.getAsAlign(), IsVolatile);
 110   }
 111
 112   // FIXME: these "default-aligned" APIs should be removed,
 113   // but I don't feel like fixing all the builtin code right now.
 114   llvm::StoreInst *CreateDefaultAlignedStore(llvm::Value *Val,
 115                                              llvm::Value *Addr,
 116                                              bool IsVolatile = false) {
 117     return CGBuilderBaseTy::CreateStore(Val, Addr, IsVolatile);
 118   }
 119
 120   /// Emit a load from an i1 flag variable.
 121   llvm::LoadInst *CreateFlagLoad(llvm::Value *Addr,
 122                                  const llvm::Twine &Name = "") {
 123     assert(llvm::cast<llvm::PointerType>(Addr->getType())
 124                ->isOpaqueOrPointeeTypeMatches(getInt1Ty()));
 125     return CreateAlignedLoad(getInt1Ty(), Addr, CharUnits::One(), Name);
 126   }
 127
 128   /// Emit a store to an i1 flag variable.
 129   llvm::StoreInst *CreateFlagStore(bool Value, llvm::Value *Addr) {
 130     assert(llvm::cast<llvm::PointerType>(Addr->getType())
 131                ->isOpaqueOrPointeeTypeMatches(getInt1Ty()));
 132     return CreateAlignedStore(getInt1(Value), Addr, CharUnits::One());
 133   }
 134
 135   // Temporarily use old signature; clang will be updated to an Address overload
 136   // in a subsequent patch.
 137   llvm::AtomicCmpXchgInst *
 138   CreateAtomicCmpXchg(llvm::Value *Ptr, llvm::Value *Cmp, llvm::Value *New,
 139                       llvm::AtomicOrdering SuccessOrdering,
 140                       llvm::AtomicOrdering FailureOrdering,
 141                       llvm::SyncScope::ID SSID = llvm::SyncScope::System) {
 142     return CGBuilderBaseTy::CreateAtomicCmpXchg(
 143         Ptr, Cmp, New, llvm::MaybeAlign(), SuccessOrdering, FailureOrdering,
 144         SSID);
 145   }
 146
 147   // Temporarily use old signature; clang will be updated to an Address overload
 148   // in a subsequent patch.
 149   llvm::AtomicRMWInst *
 150   CreateAtomicRMW(llvm::AtomicRMWInst::BinOp Op, llvm::Value *Ptr,
 151                   llvm::Value *Val, llvm::AtomicOrdering Ordering,
 152                   llvm::SyncScope::ID SSID = llvm::SyncScope::System) {
 153     return CGBuilderBaseTy::CreateAtomicRMW(Op, Ptr, Val, llvm::MaybeAlign(),
 154                                             Ordering, SSID);
 155   }
 156
 157   using CGBuilderBaseTy::CreateAddrSpaceCast;
 158   Address CreateAddrSpaceCast(Address Addr, llvm::Type *Ty,
 159                               const llvm::Twine &Name = "") {
 160     assert(cast<llvm::PointerType>(Ty)->isOpaqueOrPointeeTypeMatches(
 161                Addr.getElementType()) &&
 162            "Should not change the element type");
 163     return Addr.withPointer(CreateAddrSpaceCast(Addr.getPointer(), Ty, Name));
 164   }
 165
 166   /// Cast the element type of the given address to a different type,
 167   /// preserving information like the alignment and address space.
 168   Address CreateElementBitCast(Address Addr, llvm::Type *Ty,
 169                                const llvm::Twine &Name = "") {
 170     auto *PtrTy = Ty->getPointerTo(Addr.getAddressSpace());
 171     return Address(CreateBitCast(Addr.getPointer(), PtrTy, Name), Ty,
 172                    Addr.getAlignment());
 173   }
 174
 175   using CGBuilderBaseTy::CreatePointerBitCastOrAddrSpaceCast;
 176   Address CreatePointerBitCastOrAddrSpaceCast(Address Addr, llvm::Type *Ty,
 177                                               llvm::Type *ElementTy,
 178                                               const llvm::Twine &Name = "") {
 179     llvm::Value *Ptr =
 180         CreatePointerBitCastOrAddrSpaceCast(Addr.getPointer(), Ty, Name);
 181     return Address(Ptr, ElementTy, Addr.getAlignment());
 182   }
 183
 184   /// Given
 185   ///   %addr = {T1, T2...}* ...
 186   /// produce
 187   ///   %name = getelementptr inbounds %addr, i32 0, i32 index
 188   ///
 189   /// This API assumes that drilling into a struct like this is always an
 190   /// inbounds operation.
 191   using CGBuilderBaseTy::CreateStructGEP;
 192   Address CreateStructGEP(Address Addr, unsigned Index,
 193                           const llvm::Twine &Name = "") {
 194     llvm::StructType *ElTy = cast<llvm::StructType>(Addr.getElementType());
 195     const llvm::DataLayout &DL = BB->getParent()->getParent()->getDataLayout();
 196     const llvm::StructLayout *Layout = DL.getStructLayout(ElTy);
 197     auto Offset = CharUnits::fromQuantity(Layout->getElementOffset(Index));
 198
 199     return Address(
 200         CreateStructGEP(Addr.getElementType(), Addr.getPointer(), Index, Name),
 201         ElTy->getElementType(Index),
 202         Addr.getAlignment().alignmentAtOffset(Offset));
 203   }
 204
 205   /// Given
 206   ///   %addr = [n x T]* ...
 207   /// produce
 208   ///   %name = getelementptr inbounds %addr, i64 0, i64 index
 209   /// where i64 is actually the target word size.
 210   ///
 211   /// This API assumes that drilling into an array like this is always
 212   /// an inbounds operation.
 213   Address CreateConstArrayGEP(Address Addr, uint64_t Index,
 214                               const llvm::Twine &Name = "") {
 215     llvm::ArrayType *ElTy = cast<llvm::ArrayType>(Addr.getElementType());
 216     const llvm::DataLayout &DL = BB->getParent()->getParent()->getDataLayout();
 217     CharUnits EltSize =
 218         CharUnits::fromQuantity(DL.getTypeAllocSize(ElTy->getElementType()));
 219
 220     return Address(
 221         CreateInBoundsGEP(Addr.getElementType(), Addr.getPointer(),
 222                           {getSize(CharUnits::Zero()), getSize(Index)}, Name),
 223         ElTy->getElementType(),
 224         Addr.getAlignment().alignmentAtOffset(Index * EltSize));
 225   }
 226
 227   /// Given
 228   ///   %addr = T* ...
 229   /// produce
 230   ///   %name = getelementptr inbounds %addr, i64 index
 231   /// where i64 is actually the target word size.
 232   Address CreateConstInBoundsGEP(Address Addr, uint64_t Index,
 233                                  const llvm::Twine &Name = "") {
 234     llvm::Type *ElTy = Addr.getElementType();
 235     const llvm::DataLayout &DL = BB->getParent()->getParent()->getDataLayout();
 236     CharUnits EltSize = CharUnits::fromQuantity(DL.getTypeAllocSize(ElTy));
 237
 238     return Address(CreateInBoundsGEP(Addr.getElementType(), Addr.getPointer(),
 239                                      getSize(Index), Name),
 240                    ElTy,
 241                    Addr.getAlignment().alignmentAtOffset(Index * EltSize));
 242   }
 243
 244   /// Given
 245   ///   %addr = T* ...
 246   /// produce
 247   ///   %name = getelementptr inbounds %addr, i64 index
 248   /// where i64 is actually the target word size.
 249   Address CreateConstGEP(Address Addr, uint64_t Index,
 250                          const llvm::Twine &Name = "") {
 251     const llvm::DataLayout &DL = BB->getParent()->getParent()->getDataLayout();
 252     CharUnits EltSize =
 253         CharUnits::fromQuantity(DL.getTypeAllocSize(Addr.getElementType()));
 254
 255     return Address(CreateGEP(Addr.getElementType(), Addr.getPointer(),
 256                              getSize(Index), Name),
 257                    Addr.getElementType(),
 258                    Addr.getAlignment().alignmentAtOffset(Index * EltSize));
 259   }
 260
 261   /// Create GEP with single dynamic index. The address alignment is reduced
 262   /// according to the element size.
 263   using CGBuilderBaseTy::CreateGEP;
 264   Address CreateGEP(Address Addr, llvm::Value *Index,
 265                     const llvm::Twine &Name = "") {
 266     const llvm::DataLayout &DL = BB->getParent()->getParent()->getDataLayout();
 267     CharUnits EltSize =
 268         CharUnits::fromQuantity(DL.getTypeAllocSize(Addr.getElementType()));
 269
 270     return Address(
 271         CreateGEP(Addr.getElementType(), Addr.getPointer(), Index, Name),
 272         Addr.getElementType(),
 273         Addr.getAlignment().alignmentOfArrayElement(EltSize));
 274   }
 275
 276   /// Given a pointer to i8, adjust it by a given constant offset.
 277   Address CreateConstInBoundsByteGEP(Address Addr, CharUnits Offset,
 278                                      const llvm::Twine &Name = "") {
 279     assert(Addr.getElementType() == TypeCache.Int8Ty);
 280     return Address(CreateInBoundsGEP(Addr.getElementType(), Addr.getPointer(),
 281                                      getSize(Offset), Name),
 282                    Addr.getElementType(),
 283                    Addr.getAlignment().alignmentAtOffset(Offset));
 284   }
 285   Address CreateConstByteGEP(Address Addr, CharUnits Offset,
 286                              const llvm::Twine &Name = "") {
 287     assert(Addr.getElementType() == TypeCache.Int8Ty);
 288     return Address(CreateGEP(Addr.getElementType(), Addr.getPointer(),
 289                              getSize(Offset), Name),
 290                    Addr.getElementType(),
 291                    Addr.getAlignment().alignmentAtOffset(Offset));
 292   }
 293
 294   using CGBuilderBaseTy::CreateConstInBoundsGEP2_32;
 295   Address CreateConstInBoundsGEP2_32(Address Addr, unsigned Idx0, unsigned Idx1,
 296                                      const llvm::Twine &Name = "") {
 297     const llvm::DataLayout &DL = BB->getParent()->getParent()->getDataLayout();
 298
 299     auto *GEP = cast<llvm::GetElementPtrInst>(CreateConstInBoundsGEP2_32(
 300         Addr.getElementType(), Addr.getPointer(), Idx0, Idx1, Name));
 301     llvm::APInt Offset(
 302         DL.getIndexSizeInBits(Addr.getType()->getPointerAddressSpace()), 0,
 303         /*isSigned=*/true);
 304     if (!GEP->accumulateConstantOffset(DL, Offset))
 305       llvm_unreachable("offset of GEP with constants is always computable");
 306     return Address(GEP, GEP->getResultElementType(),
 307                    Addr.getAlignment().alignmentAtOffset(
 308                        CharUnits::fromQuantity(Offset.getSExtValue())));
 309   }
 310
 311   using CGBuilderBaseTy::CreateMemCpy;
 312   llvm::CallInst *CreateMemCpy(Address Dest, Address Src, llvm::Value *Size,
 313                                bool IsVolatile = false) {
 314     return CreateMemCpy(Dest.getPointer(), Dest.getAlignment().getAsAlign(),
 315                         Src.getPointer(), Src.getAlignment().getAsAlign(), Size,
 316                         IsVolatile);
 317   }
 318   llvm::CallInst *CreateMemCpy(Address Dest, Address Src, uint64_t Size,
 319                                bool IsVolatile = false) {
 320     return CreateMemCpy(Dest.getPointer(), Dest.getAlignment().getAsAlign(),
 321                         Src.getPointer(), Src.getAlignment().getAsAlign(), Size,
 322                         IsVolatile);
 323   }
 324
 325   using CGBuilderBaseTy::CreateMemCpyInline;
 326   llvm::CallInst *CreateMemCpyInline(Address Dest, Address Src, uint64_t Size) {
 327     return CreateMemCpyInline(
 328         Dest.getPointer(), Dest.getAlignment().getAsAlign(), Src.getPointer(),
 329         Src.getAlignment().getAsAlign(), getInt64(Size));
 330   }
 331
 332   using CGBuilderBaseTy::CreateMemMove;
 333   llvm::CallInst *CreateMemMove(Address Dest, Address Src, llvm::Value *Size,
 334                                 bool IsVolatile = false) {
 335     return CreateMemMove(Dest.getPointer(), Dest.getAlignment().getAsAlign(),
 336                          Src.getPointer(), Src.getAlignment().getAsAlign(),
 337                          Size, IsVolatile);
 338   }
 339
 340   using CGBuilderBaseTy::CreateMemSet;
 341   llvm::CallInst *CreateMemSet(Address Dest, llvm::Value *Value,
 342                                llvm::Value *Size, bool IsVolatile = false) {
 343     return CreateMemSet(Dest.getPointer(), Value, Size,
 344                         Dest.getAlignment().getAsAlign(), IsVolatile);
 345   }
 346
 347   using CGBuilderBaseTy::CreateMemSetInline;
 348   llvm::CallInst *CreateMemSetInline(Address Dest, llvm::Value *Value,
 349                                      uint64_t Size) {
 350     return CreateMemSetInline(Dest.getPointer(),
 351                               Dest.getAlignment().getAsAlign(), Value,
 352                               getInt64(Size));
 353   }
 354
 355   using CGBuilderBaseTy::CreatePreserveStructAccessIndex;
 356   Address CreatePreserveStructAccessIndex(Address Addr, unsigned Index,
 357                                           unsigned FieldIndex,
 358                                           llvm::MDNode *DbgInfo) {
 359     llvm::StructType *ElTy = cast<llvm::StructType>(Addr.getElementType());
 360     const llvm::DataLayout &DL = BB->getParent()->getParent()->getDataLayout();
 361     const llvm::StructLayout *Layout = DL.getStructLayout(ElTy);
 362     auto Offset = CharUnits::fromQuantity(Layout->getElementOffset(Index));
 363
 364     return Address(CreatePreserveStructAccessIndex(ElTy, Addr.getPointer(),
 365                                                    Index, FieldIndex, DbgInfo),
 366                    ElTy->getElementType(Index),
 367                    Addr.getAlignment().alignmentAtOffset(Offset));
 368   }
 369
 370   using CGBuilderBaseTy::CreateLaunderInvariantGroup;
 371   Address CreateLaunderInvariantGroup(Address Addr) {
 372     return Addr.withPointer(CreateLaunderInvariantGroup(Addr.getPointer()));
 373   }
 374 };
 375
 376 } // end namespace CodeGen
 377 } // end namespace clang
 378
 379 #endif