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