Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===- llvm/IRBuilder.h - Builder for LLVM Instructions ---------*- C++ -*-===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

// This file defines the IRBuilder class, which is used as a convenient way

// to create LLVM instructions with a consistent and simplified interface.

//

//===----------------------------------------------------------------------===//

#ifndef LLVM_IR_IRBUILDER_H

#define LLVM_IR_IRBUILDER_H

#include "llvm-c/Types.h"

#include "llvm/ADT/ArrayRef.h"

#include "llvm/ADT/STLExtras.h"

#include "llvm/ADT/StringRef.h"

#include "llvm/ADT/Twine.h"

#include "llvm/IR/BasicBlock.h"

#include "llvm/IR/Constant.h"

#include "llvm/IR/ConstantFolder.h"

#include "llvm/IR/Constants.h"

#include "llvm/IR/DataLayout.h"

#include "llvm/IR/DebugLoc.h"

#include "llvm/IR/DerivedTypes.h"

#include "llvm/IR/FPEnv.h"

#include "llvm/IR/Function.h"

#include "llvm/IR/GlobalVariable.h"

#include "llvm/IR/InstrTypes.h"

#include "llvm/IR/Instruction.h"

#include "llvm/IR/Instructions.h"

#include "llvm/IR/Intrinsics.h"

#include "llvm/IR/LLVMContext.h"

#include "llvm/IR/Module.h"

#include "llvm/IR/Operator.h"

#include "llvm/IR/Type.h"

#include "llvm/IR/Value.h"

#include "llvm/IR/ValueHandle.h"

#include "llvm/Support/AtomicOrdering.h"

#include "llvm/Support/CBindingWrapping.h"

#include "llvm/Support/Casting.h"

#include <cassert>

#include <cstdint>

#include <functional>

#include <optional>

#include <utility>

namespace llvm {

class APInt;

class Use;

/// This provides the default implementation of the IRBuilder

/// 'InsertHelper' method that is called whenever an instruction is created by

/// IRBuilder and needs to be inserted.

///

/// By default, this inserts the instruction at the insertion point.

class IRBuilderDefaultInserter {

public:

  virtual ~IRBuilderDefaultInserter();

  virtual void InsertHelper(Instruction *I, const Twine &Name,

                            BasicBlock *BB,

                            BasicBlock::iterator InsertPt) const {

    if (BB)

      I->insertInto(BB, InsertPt);

    I->setName(Name);

  }

};

/// Provides an 'InsertHelper' that calls a user-provided callback after

/// performing the default insertion.

class IRBuilderCallbackInserter : public IRBuilderDefaultInserter {

  std::function<void(Instruction *)> Callback;

public:

  ~IRBuilderCallbackInserter() override;

  IRBuilderCallbackInserter(std::function<void(Instruction *)> Callback)

      : Callback(std::move(Callback)) {}

  void InsertHelper(Instruction *I, const Twine &Name,

                    BasicBlock *BB,

                    BasicBlock::iterator InsertPt) const override {

    IRBuilderDefaultInserter::InsertHelper(I, Name, BB, InsertPt);

    Callback(I);

  }

};

/// Common base class shared among various IRBuilders.

class IRBuilderBase {

  /// Pairs of (metadata kind, MDNode *) that should be added to all newly

  /// created instructions, like !dbg metadata.

  SmallVector<std::pair<unsigned, MDNode *>, 2> MetadataToCopy;

  /// Add or update the an entry (Kind, MD) to MetadataToCopy, if \p MD is not

  /// null. If \p MD is null, remove the entry with \p Kind.

  void AddOrRemoveMetadataToCopy(unsigned Kind, MDNode *MD) {

    if (!MD) {

      erase_if(MetadataToCopy, [Kind](const std::pair<unsigned, MDNode *> &KV) {

        return KV.first == Kind;

      });

      return;

    }

    for (auto &KV : MetadataToCopy)

      if (KV.first == Kind) {

        KV.second = MD;

        return;

      }

    MetadataToCopy.emplace_back(Kind, MD);

  }

protected:

  BasicBlock *BB;

  BasicBlock::iterator InsertPt;

  LLVMContext &Context;

  const IRBuilderFolder &Folder;

  const IRBuilderDefaultInserter &Inserter;

  MDNode *DefaultFPMathTag;

  FastMathFlags FMF;

  bool IsFPConstrained = false;

  fp::ExceptionBehavior DefaultConstrainedExcept = fp::ebStrict;

  RoundingMode DefaultConstrainedRounding = RoundingMode::Dynamic;

  ArrayRef<OperandBundleDef> DefaultOperandBundles;

public:

  IRBuilderBase(LLVMContext &context, const IRBuilderFolder &Folder,

                const IRBuilderDefaultInserter &Inserter, MDNode *FPMathTag,

                ArrayRef<OperandBundleDef> OpBundles)

      : Context(context), Folder(Folder), Inserter(Inserter),

        DefaultFPMathTag(FPMathTag), DefaultOperandBundles(OpBundles) {

    ClearInsertionPoint();

  }

  /// Insert and return the specified instruction.

  template<typename InstTy>

  InstTy *Insert(InstTy *I, const Twine &Name = "") const {

    Inserter.InsertHelper(I, Name, BB, InsertPt);

    AddMetadataToInst(I);

    return I;

  }

  /// No-op overload to handle constants.

  Constant *Insert(Constant *C, const Twine& = "") const {

    return C;

  }

  Value *Insert(Value *V, const Twine &Name = "") const {

    if (Instruction *I = dyn_cast<Instruction>(V))

      return Insert(I, Name);

    assert(isa<Constant>(V));

    return V;

  }

  //===--------------------------------------------------------------------===//

  // Builder configuration methods

  //===--------------------------------------------------------------------===//

  /// Clear the insertion point: created instructions will not be

  /// inserted into a block.

  void ClearInsertionPoint() {

    BB = nullptr;

    InsertPt = BasicBlock::iterator();

  }

  BasicBlock *GetInsertBlock() const { return BB; }

  BasicBlock::iterator GetInsertPoint() const { return InsertPt; }

  LLVMContext &getContext() const { return Context; }

  /// This specifies that created instructions should be appended to the

  /// end of the specified block.

  void SetInsertPoint(BasicBlock *TheBB) {

    BB = TheBB;

    InsertPt = BB->end();

  }

  /// This specifies that created instructions should be inserted before

  /// the specified instruction.

  void SetInsertPoint(Instruction *I) {

    BB = I->getParent();

    InsertPt = I->getIterator();

    assert(InsertPt != BB->end() && "Can't read debug loc from end()");

    SetCurrentDebugLocation(I->getDebugLoc());

  }

  /// This specifies that created instructions should be inserted at the

  /// specified point.

  void SetInsertPoint(BasicBlock *TheBB, BasicBlock::iterator IP) {

    BB = TheBB;

    InsertPt = IP;

    if (IP != TheBB->end())

      SetCurrentDebugLocation(IP->getDebugLoc());

  }

  /// This specifies that created instructions should inserted at the beginning

  /// end of the specified function, but after already existing static alloca

  /// instructions that are at the start.

  void SetInsertPointPastAllocas(Function *F) {

    BB = &F->getEntryBlock();

    InsertPt = BB->getFirstNonPHIOrDbgOrAlloca();

  }

  /// Set location information used by debugging information.

  void SetCurrentDebugLocation(DebugLoc L) {

    AddOrRemoveMetadataToCopy(LLVMContext::MD_dbg, L.getAsMDNode());

  }

  /// Collect metadata with IDs \p MetadataKinds from \p Src which should be

  /// added to all created instructions. Entries present in MedataDataToCopy but

  /// not on \p Src will be dropped from MetadataToCopy.

  void CollectMetadataToCopy(Instruction *Src,

                             ArrayRef<unsigned> MetadataKinds) {

    for (unsigned K : MetadataKinds)

      AddOrRemoveMetadataToCopy(K, Src->getMetadata(K));

  }

  /// Get location information used by debugging information.

  DebugLoc getCurrentDebugLocation() const;

  /// If this builder has a current debug location, set it on the

  /// specified instruction.

  void SetInstDebugLocation(Instruction *I) const;

  /// Add all entries in MetadataToCopy to \p I.

  void AddMetadataToInst(Instruction *I) const {

    for (const auto &KV : MetadataToCopy)

      I->setMetadata(KV.first, KV.second);

  }

  /// Get the return type of the current function that we're emitting

  /// into.

  Type *getCurrentFunctionReturnType() const;

  /// InsertPoint - A saved insertion point.

  class InsertPoint {

    BasicBlock *Block = nullptr;

    BasicBlock::iterator Point;

  public:

    /// Creates a new insertion point which doesn't point to anything.

    InsertPoint() = default;

    /// Creates a new insertion point at the given location.

    InsertPoint(BasicBlock *InsertBlock, BasicBlock::iterator InsertPoint)

        : Block(InsertBlock), Point(InsertPoint) {}

    /// Returns true if this insert point is set.

    bool isSet() const { return (Block != nullptr); }

    BasicBlock *getBlock() const { return Block; }

    BasicBlock::iterator getPoint() const { return Point; }

  };

  /// Returns the current insert point.

  InsertPoint saveIP() const {

    return InsertPoint(GetInsertBlock(), GetInsertPoint());

  }

  /// Returns the current insert point, clearing it in the process.

  InsertPoint saveAndClearIP() {

    InsertPoint IP(GetInsertBlock(), GetInsertPoint());

    ClearInsertionPoint();

    return IP;

  }

  /// Sets the current insert point to a previously-saved location.

  void restoreIP(InsertPoint IP) {

    if (IP.isSet())

      SetInsertPoint(IP.getBlock(), IP.getPoint());

    else

      ClearInsertionPoint();

  }

  /// Get the floating point math metadata being used.

  MDNode *getDefaultFPMathTag() const { return DefaultFPMathTag; }

  /// Get the flags to be applied to created floating point ops

  FastMathFlags getFastMathFlags() const { return FMF; }

  FastMathFlags &getFastMathFlags() { return FMF; }

  /// Clear the fast-math flags.

  void clearFastMathFlags() { FMF.clear(); }

  /// Set the floating point math metadata to be used.

  void setDefaultFPMathTag(MDNode *FPMathTag) { DefaultFPMathTag = FPMathTag; }

  /// Set the fast-math flags to be used with generated fp-math operators

  void setFastMathFlags(FastMathFlags NewFMF) { FMF = NewFMF; }

  /// Enable/Disable use of constrained floating point math. When

  /// enabled the CreateF<op>() calls instead create constrained

  /// floating point intrinsic calls. Fast math flags are unaffected

  /// by this setting.

  void setIsFPConstrained(bool IsCon) { IsFPConstrained = IsCon; }

  /// Query for the use of constrained floating point math

  bool getIsFPConstrained() { return IsFPConstrained; }

  /// Set the exception handling to be used with constrained floating point

  void setDefaultConstrainedExcept(fp::ExceptionBehavior NewExcept) {

#ifndef NDEBUG

    std::optional<StringRef> ExceptStr =

        convertExceptionBehaviorToStr(NewExcept);

    assert(ExceptStr && "Garbage strict exception behavior!");

#endif

    DefaultConstrainedExcept = NewExcept;

  }

  /// Set the rounding mode handling to be used with constrained floating point

  void setDefaultConstrainedRounding(RoundingMode NewRounding) {

#ifndef NDEBUG

    std::optional<StringRef> RoundingStr =

        convertRoundingModeToStr(NewRounding);

    assert(RoundingStr && "Garbage strict rounding mode!");

#endif

    DefaultConstrainedRounding = NewRounding;

  }

  /// Get the exception handling used with constrained floating point

  fp::ExceptionBehavior getDefaultConstrainedExcept() {

    return DefaultConstrainedExcept;

  }

  /// Get the rounding mode handling used with constrained floating point

  RoundingMode getDefaultConstrainedRounding() {

    return DefaultConstrainedRounding;

  }

  void setConstrainedFPFunctionAttr() {

    assert(BB && "Must have a basic block to set any function attributes!");

    Function *F = BB->getParent();

    if (!F->hasFnAttribute(Attribute::StrictFP)) {

      F->addFnAttr(Attribute::StrictFP);

    }

  }

  void setConstrainedFPCallAttr(CallBase *I) {

    I->addFnAttr(Attribute::StrictFP);

  }

  void setDefaultOperandBundles(ArrayRef<OperandBundleDef> OpBundles) {

    DefaultOperandBundles = OpBundles;

  }

  //===--------------------------------------------------------------------===//

  // RAII helpers.

  //===--------------------------------------------------------------------===//

  // RAII object that stores the current insertion point and restores it

  // when the object is destroyed. This includes the debug location.

  class InsertPointGuard {

    IRBuilderBase &Builder;

    AssertingVH<BasicBlock> Block;

    BasicBlock::iterator Point;

    DebugLoc DbgLoc;

  public:

    InsertPointGuard(IRBuilderBase &B)

        : Builder(B), Block(B.GetInsertBlock()), Point(B.GetInsertPoint()),

          DbgLoc(B.getCurrentDebugLocation()) {}

    InsertPointGuard(const InsertPointGuard &) = delete;

    InsertPointGuard &operator=(const InsertPointGuard &) = delete;

    ~InsertPointGuard() {

      Builder.restoreIP(InsertPoint(Block, Point));

      Builder.SetCurrentDebugLocation(DbgLoc);

    }

  };

  // RAII object that stores the current fast math settings and restores

  // them when the object is destroyed.

  class FastMathFlagGuard {

    IRBuilderBase &Builder;

    FastMathFlags FMF;

    MDNode *FPMathTag;

    bool IsFPConstrained;

    fp::ExceptionBehavior DefaultConstrainedExcept;

    RoundingMode DefaultConstrainedRounding;

  public:

    FastMathFlagGuard(IRBuilderBase &B)

        : Builder(B), FMF(B.FMF), FPMathTag(B.DefaultFPMathTag),

          IsFPConstrained(B.IsFPConstrained),

          DefaultConstrainedExcept(B.DefaultConstrainedExcept),

          DefaultConstrainedRounding(B.DefaultConstrainedRounding) {}

    FastMathFlagGuard(const FastMathFlagGuard &) = delete;

    FastMathFlagGuard &operator=(const FastMathFlagGuard &) = delete;

    ~FastMathFlagGuard() {

      Builder.FMF = FMF;

      Builder.DefaultFPMathTag = FPMathTag;

      Builder.IsFPConstrained = IsFPConstrained;

      Builder.DefaultConstrainedExcept = DefaultConstrainedExcept;

      Builder.DefaultConstrainedRounding = DefaultConstrainedRounding;

    }

  };

  // RAII object that stores the current default operand bundles and restores

  // them when the object is destroyed.

  class OperandBundlesGuard {

    IRBuilderBase &Builder;

    ArrayRef<OperandBundleDef> DefaultOperandBundles;

  public:

    OperandBundlesGuard(IRBuilderBase &B)

        : Builder(B), DefaultOperandBundles(B.DefaultOperandBundles) {}

    OperandBundlesGuard(const OperandBundlesGuard &) = delete;

    OperandBundlesGuard &operator=(const OperandBundlesGuard &) = delete;

    ~OperandBundlesGuard() {

      Builder.DefaultOperandBundles = DefaultOperandBundles;

    }

  };

  //===--------------------------------------------------------------------===//

  // Miscellaneous creation methods.

  //===--------------------------------------------------------------------===//

  /// Make a new global variable with initializer type i8*

  ///

  /// Make a new global variable with an initializer that has array of i8 type

  /// filled in with the null terminated string value specified.  The new global

  /// variable will be marked mergable with any others of the same contents.  If

  /// Name is specified, it is the name of the global variable created.

  ///

  /// If no module is given via \p M, it is take from the insertion point basic

  /// block.

  GlobalVariable *CreateGlobalString(StringRef Str, const Twine &Name = "",

                                     unsigned AddressSpace = 0,

                                     Module *M = nullptr);

  /// Get a constant value representing either true or false.

  ConstantInt *getInt1(bool V) {

    return ConstantInt::get(getInt1Ty(), V);

  }

  /// Get the constant value for i1 true.

  ConstantInt *getTrue() {

    return ConstantInt::getTrue(Context);

  }

  /// Get the constant value for i1 false.

  ConstantInt *getFalse() {

    return ConstantInt::getFalse(Context);

  }

  /// Get a constant 8-bit value.

  ConstantInt *getInt8(uint8_t C) {

    return ConstantInt::get(getInt8Ty(), C);

  }

  /// Get a constant 16-bit value.

  ConstantInt *getInt16(uint16_t C) {

    return ConstantInt::get(getInt16Ty(), C);

  }

  /// Get a constant 32-bit value.

  ConstantInt *getInt32(uint32_t C) {

    return ConstantInt::get(getInt32Ty(), C);

  }

  /// Get a constant 64-bit value.

  ConstantInt *getInt64(uint64_t C) {

    return ConstantInt::get(getInt64Ty(), C);

  }

  /// Get a constant N-bit value, zero extended or truncated from

  /// a 64-bit value.

  ConstantInt *getIntN(unsigned N, uint64_t C) {

    return ConstantInt::get(getIntNTy(N), C);

  }

  /// Get a constant integer value.

  ConstantInt *getInt(const APInt &AI) {

    return ConstantInt::get(Context, AI);

  }

  //===--------------------------------------------------------------------===//

  // Type creation methods

  //===--------------------------------------------------------------------===//

  /// Fetch the type representing a single bit

  IntegerType *getInt1Ty() {

    return Type::getInt1Ty(Context);

  }

  /// Fetch the type representing an 8-bit integer.

  IntegerType *getInt8Ty() {

    return Type::getInt8Ty(Context);

  }

  /// Fetch the type representing a 16-bit integer.

  IntegerType *getInt16Ty() {

    return Type::getInt16Ty(Context);

  }

  /// Fetch the type representing a 32-bit integer.

  IntegerType *getInt32Ty() {

    return Type::getInt32Ty(Context);

  }

  /// Fetch the type representing a 64-bit integer.

  IntegerType *getInt64Ty() {

    return Type::getInt64Ty(Context);

  }

  /// Fetch the type representing a 128-bit integer.

  IntegerType *getInt128Ty() { return Type::getInt128Ty(Context); }

  /// Fetch the type representing an N-bit integer.

  IntegerType *getIntNTy(unsigned N) {

    return Type::getIntNTy(Context, N);

  }

  /// Fetch the type representing a 16-bit floating point value.

  Type *getHalfTy() {

    return Type::getHalfTy(Context);

  }

  /// Fetch the type representing a 16-bit brain floating point value.

  Type *getBFloatTy() {

    return Type::getBFloatTy(Context);

  }

  /// Fetch the type representing a 32-bit floating point value.

  Type *getFloatTy() {

    return Type::getFloatTy(Context);

  }

  /// Fetch the type representing a 64-bit floating point value.

  Type *getDoubleTy() {

    return Type::getDoubleTy(Context);

  }

  /// Fetch the type representing void.

  Type *getVoidTy() {

    return Type::getVoidTy(Context);

  }

  /// Fetch the type representing a pointer.

  PointerType *getPtrTy(unsigned AddrSpace = 0) {

    return PointerType::get(Context, AddrSpace);

  }

  /// Fetch the type representing a pointer to an 8-bit integer value.

  PointerType *getInt8PtrTy(unsigned AddrSpace = 0) {

    return Type::getInt8PtrTy(Context, AddrSpace);

  }

  /// Fetch the type of an integer with size at least as big as that of a

  /// pointer in the given address space.

  IntegerType *getIntPtrTy(const DataLayout &DL, unsigned AddrSpace = 0) {

    return DL.getIntPtrType(Context, AddrSpace);

  }

  //===--------------------------------------------------------------------===//

  // Intrinsic creation methods

  //===--------------------------------------------------------------------===//

  /// Create and insert a memset to the specified pointer and the

  /// specified value.

  ///

  /// If the pointer isn't an i8*, it will be converted. If a TBAA tag is

  /// specified, it will be added to the instruction. Likewise with alias.scope

  /// and noalias tags.

  CallInst *CreateMemSet(Value *Ptr, Value *Val, uint64_t Size,

                         MaybeAlign Align, bool isVolatile = false,

                         MDNode *TBAATag = nullptr, MDNode *ScopeTag = nullptr,

                         MDNode *NoAliasTag = nullptr) {

    return CreateMemSet(Ptr, Val, getInt64(Size), Align, isVolatile,

                        TBAATag, ScopeTag, NoAliasTag);

  }

  CallInst *CreateMemSet(Value *Ptr, Value *Val, Value *Size, MaybeAlign Align,

                         bool isVolatile = false, MDNode *TBAATag = nullptr,

                         MDNode *ScopeTag = nullptr,

                         MDNode *NoAliasTag = nullptr);

  CallInst *CreateMemSetInline(Value *Dst, MaybeAlign DstAlign, Value *Val,

                               Value *Size, bool IsVolatile = false,

                               MDNode *TBAATag = nullptr,

                               MDNode *ScopeTag = nullptr,

                               MDNode *NoAliasTag = nullptr);

  /// Create and insert an element unordered-atomic memset of the region of

  /// memory starting at the given pointer to the given value.

  ///

  /// If the pointer isn't an i8*, it will be converted. If a TBAA tag is

  /// specified, it will be added to the instruction. Likewise with alias.scope

  /// and noalias tags.

  CallInst *CreateElementUnorderedAtomicMemSet(Value *Ptr, Value *Val,

                                               uint64_t Size, Align Alignment,

                                               uint32_t ElementSize,

                                               MDNode *TBAATag = nullptr,

                                               MDNode *ScopeTag = nullptr,

                                               MDNode *NoAliasTag = nullptr) {

    return CreateElementUnorderedAtomicMemSet(Ptr, Val, getInt64(Size),

                                              Align(Alignment), ElementSize,

                                              TBAATag, ScopeTag, NoAliasTag);

  }

  CallInst *CreateElementUnorderedAtomicMemSet(Value *Ptr, Value *Val,

                                               Value *Size, Align Alignment,

                                               uint32_t ElementSize,

                                               MDNode *TBAATag = nullptr,

                                               MDNode *ScopeTag = nullptr,

                                               MDNode *NoAliasTag = nullptr);

  /// Create and insert a memcpy between the specified pointers.

  ///

  /// If the pointers aren't i8*, they will be converted.  If a TBAA tag is

  /// specified, it will be added to the instruction. Likewise with alias.scope

  /// and noalias tags.

  CallInst *CreateMemCpy(Value *Dst, MaybeAlign DstAlign, Value *Src,

                         MaybeAlign SrcAlign, uint64_t Size,

                         bool isVolatile = false, MDNode *TBAATag = nullptr,

                         MDNode *TBAAStructTag = nullptr,

                         MDNode *ScopeTag = nullptr,

                         MDNode *NoAliasTag = nullptr) {

    return CreateMemCpy(Dst, DstAlign, Src, SrcAlign, getInt64(Size),

                        isVolatile, TBAATag, TBAAStructTag, ScopeTag,

                        NoAliasTag);

  }

  CallInst *CreateMemTransferInst(

      Intrinsic::ID IntrID, Value *Dst, MaybeAlign DstAlign, Value *Src,

      MaybeAlign SrcAlign, Value *Size, bool isVolatile = false,

      MDNode *TBAATag = nullptr, MDNode *TBAAStructTag = nullptr,

      MDNode *ScopeTag = nullptr, MDNode *NoAliasTag = nullptr);

  CallInst *CreateMemCpy(Value *Dst, MaybeAlign DstAlign, Value *Src,

                         MaybeAlign SrcAlign, Value *Size,

                         bool isVolatile = false, MDNode *TBAATag = nullptr,

                         MDNode *TBAAStructTag = nullptr,

                         MDNode *ScopeTag = nullptr,

                         MDNode *NoAliasTag = nullptr) {

    return CreateMemTransferInst(Intrinsic::memcpy, Dst, DstAlign, Src,

                                 SrcAlign, Size, isVolatile, TBAATag,

                                 TBAAStructTag, ScopeTag, NoAliasTag);

  }

  CallInst *

  CreateMemCpyInline(Value *Dst, MaybeAlign DstAlign, Value *Src,

                     MaybeAlign SrcAlign, Value *Size, bool IsVolatile = false,

                     MDNode *TBAATag = nullptr, MDNode *TBAAStructTag = nullptr,

                     MDNode *ScopeTag = nullptr, MDNode *NoAliasTag = nullptr);

  /// Create and insert an element unordered-atomic memcpy between the

  /// specified pointers.

  ///

  /// DstAlign/SrcAlign are the alignments of the Dst/Src pointers, respectively.

  ///

  /// If the pointers aren't i8*, they will be converted.  If a TBAA tag is

  /// specified, it will be added to the instruction. Likewise with alias.scope

  /// and noalias tags.

  CallInst *CreateElementUnorderedAtomicMemCpy(

      Value *Dst, Align DstAlign, Value *Src, Align SrcAlign, Value *Size,

      uint32_t ElementSize, MDNode *TBAATag = nullptr,

      MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr,

      MDNode *NoAliasTag = nullptr);

  CallInst *CreateMemMove(Value *Dst, MaybeAlign DstAlign, Value *Src,

                          MaybeAlign SrcAlign, uint64_t Size,

                          bool isVolatile = false, MDNode *TBAATag = nullptr,

                          MDNode *ScopeTag = nullptr,

                          MDNode *NoAliasTag = nullptr) {

    return CreateMemMove(Dst, DstAlign, Src, SrcAlign, getInt64(Size),

                         isVolatile, TBAATag, ScopeTag, NoAliasTag);

  }

  CallInst *CreateMemMove(Value *Dst, MaybeAlign DstAlign, Value *Src,

                          MaybeAlign SrcAlign, Value *Size,

                          bool isVolatile = false, MDNode *TBAATag = nullptr,

                          MDNode *ScopeTag = nullptr,

                          MDNode *NoAliasTag = nullptr);

  /// \brief Create and insert an element unordered-atomic memmove between the

  /// specified pointers.

  ///

  /// DstAlign/SrcAlign are the alignments of the Dst/Src pointers,

  /// respectively.

  ///

  /// If the pointers aren't i8*, they will be converted.  If a TBAA tag is

  /// specified, it will be added to the instruction. Likewise with alias.scope

  /// and noalias tags.

  CallInst *CreateElementUnorderedAtomicMemMove(

      Value *Dst, Align DstAlign, Value *Src, Align SrcAlign, Value *Size,

      uint32_t ElementSize, MDNode *TBAATag = nullptr,

      MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr,

      MDNode *NoAliasTag = nullptr);

private:

  CallInst *getReductionIntrinsic(Intrinsic::ID ID, Value *Src);

public:

  /// Create a sequential vector fadd reduction intrinsic of the source vector.

  /// The first parameter is a scalar accumulator value. An unordered reduction

  /// can be created by adding the reassoc fast-math flag to the resulting

  /// sequential reduction.

  CallInst *CreateFAddReduce(Value *Acc, Value *Src);

  /// Create a sequential vector fmul reduction intrinsic of the source vector.

  /// The first parameter is a scalar accumulator value. An unordered reduction

  /// can be created by adding the reassoc fast-math flag to the resulting

  /// sequential reduction.

  CallInst *CreateFMulReduce(Value *Acc, Value *Src);

  /// Create a vector int add reduction intrinsic of the source vector.

  CallInst *CreateAddReduce(Value *Src);

  /// Create a vector int mul reduction intrinsic of the source vector.

  CallInst *CreateMulReduce(Value *Src);

  /// Create a vector int AND reduction intrinsic of the source vector.

  CallInst *CreateAndReduce(Value *Src);

  /// Create a vector int OR reduction intrinsic of the source vector.

  CallInst *CreateOrReduce(Value *Src);

  /// Create a vector int XOR reduction intrinsic of the source vector.

  CallInst *CreateXorReduce(Value *Src);

  /// Create a vector integer max reduction intrinsic of the source

  /// vector.

  CallInst *CreateIntMaxReduce(Value *Src, bool IsSigned = false);

  /// Create a vector integer min reduction intrinsic of the source

  /// vector.

  CallInst *CreateIntMinReduce(Value *Src, bool IsSigned = false);

  /// Create a vector float max reduction intrinsic of the source

  /// vector.

  CallInst *CreateFPMaxReduce(Value *Src);

  /// Create a vector float min reduction intrinsic of the source

  /// vector.

  CallInst *CreateFPMinReduce(Value *Src);

  /// Create a lifetime.start intrinsic.

  ///

  /// If the pointer isn't i8* it will be converted.

  CallInst *CreateLifetimeStart(Value *Ptr, ConstantInt *Size = nullptr);

  /// Create a lifetime.end intrinsic.

  ///

  /// If the pointer isn't i8* it will be converted.

  CallInst *CreateLifetimeEnd(Value *Ptr, ConstantInt *Size = nullptr);

  /// Create a call to invariant.start intrinsic.

  ///

  /// If the pointer isn't i8* it will be converted.

  CallInst *CreateInvariantStart(Value *Ptr, ConstantInt *Size = nullptr);

  /// Create a call to llvm.threadlocal.address intrinsic.

  CallInst *CreateThreadLocalAddress(Value *Ptr);

  /// Create a call to Masked Load intrinsic

  CallInst *CreateMaskedLoad(Type *Ty, Value *Ptr, Align Alignment, Value *Mask,

                             Value *PassThru = nullptr, const Twine &Name = "");

  /// Create a call to Masked Store intrinsic

  CallInst *CreateMaskedStore(Value *Val, Value *Ptr, Align Alignment,

                              Value *Mask);

  /// Create a call to Masked Gather intrinsic

  CallInst *CreateMaskedGather(Type *Ty, Value *Ptrs, Align Alignment,

                               Value *Mask = nullptr, Value *PassThru = nullptr,

                               const Twine &Name = "");

  /// Create a call to Masked Scatter intrinsic

  CallInst *CreateMaskedScatter(Value *Val, Value *Ptrs, Align Alignment,

                                Value *Mask = nullptr);

  /// Create a call to Masked Expand Load intrinsic

  CallInst *CreateMaskedExpandLoad(Type *Ty, Value *Ptr, Value *Mask = nullptr,

                                   Value *PassThru = nullptr,

                                   const Twine &Name = "");

  /// Create a call to Masked Compress Store intrinsic

  CallInst *CreateMaskedCompressStore(Value *Val, Value *Ptr,

                                      Value *Mask = nullptr);

  /// Create an assume intrinsic call that allows the optimizer to

  /// assume that the provided condition will be true.

  ///

  /// The optional argument \p OpBundles specifies operand bundles that are

  /// added to the call instruction.

  CallInst *

  CreateAssumption(Value *Cond,

                   ArrayRef<OperandBundleDef> OpBundles = std::nullopt);

  /// Create a llvm.experimental.noalias.scope.decl intrinsic call.

  Instruction *CreateNoAliasScopeDeclaration(Value *Scope);

  Instruction *CreateNoAliasScopeDeclaration(MDNode *ScopeTag) {

    return CreateNoAliasScopeDeclaration(

        MetadataAsValue::get(Context, ScopeTag));

  }

  /// Create a call to the experimental.gc.statepoint intrinsic to

  /// start a new statepoint sequence.

  CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes,

                                   FunctionCallee ActualCallee,

                                   ArrayRef<Value *> CallArgs,

                                   std::optional<ArrayRef<Value *>> DeoptArgs,

                                   ArrayRef<Value *> GCArgs,

                                   const Twine &Name = "");

  /// Create a call to the experimental.gc.statepoint intrinsic to

  /// start a new statepoint sequence.

  CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes,

                                   FunctionCallee ActualCallee, uint32_t Flags,

                                   ArrayRef<Value *> CallArgs,

                                   std::optional<ArrayRef<Use>> TransitionArgs,

                                   std::optional<ArrayRef<Use>> DeoptArgs,

                                   ArrayRef<Value *> GCArgs,

                                   const Twine &Name = "");