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