/build/source/llvm/include/llvm/IR/IRBuilder.h

Bug Summary

File:	build/source/llvm/include/llvm/IR/IRBuilder.h
Warning:	line 2558, column 23 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name X86LowerAMXType.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/source/build-llvm -resource-dir /usr/lib/llvm-16/lib/clang/16.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I lib/Target/X86 -I /build/source/llvm/lib/Target/X86 -I include -I /build/source/llvm/include -D _FORTIFY_SOURCE=2 -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-16/lib/clang/16.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/build/source/build-llvm=build-llvm -fmacro-prefix-map=/build/source/= -fcoverage-prefix-map=/build/source/build-llvm=build-llvm -fcoverage-prefix-map=/build/source/= -source-date-epoch 1668078801 -O3 -Wno-unused-command-line-argument -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -Wno-misleading-indentation -std=c++17 -fdeprecated-macro -fdebug-compilation-dir=/build/source/build-llvm -fdebug-prefix-map=/build/source/build-llvm=build-llvm -fdebug-prefix-map=/build/source/= -ferror-limit 19 -fvisibility=hidden -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-11-10-135928-647445-1 -x c++ /build/source/llvm/lib/Target/X86/X86LowerAMXType.cpp

/build/source/llvm/lib/Target/X86/X86LowerAMXType.cpp

→

1//===- Target/X86/X86LowerAMXType.cpp - -------------------------*- 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/// \file Pass to transform <256 x i32> load/store
10/// <256 x i32> is bitcasted to x86_amx on X86, and AMX instruction set only
11/// provides simple operation on x86_amx. The basic elementwise operation
12/// is not supported by AMX. Since x86_amx is bitcasted from vector <256 x i32>
13/// and only AMX intrinsics can operate on the type, we need transform
14/// load/store <256 x i32> instruction to AMX load/store. If the bitcast can
15/// not be combined with load/store, we transform the bitcast to amx load/store
16/// and <256 x i32> store/load.
17///
18/// If Front End not use O0 but the Mid/Back end use O0, (e.g. "Clang -O2 -S
19/// -emit-llvm t.c" + "llc t.ll") we should make sure the amx data is volatile,
20/// because that is necessary for AMX fast register allocation. (In Fast
21/// registera allocation, register will be allocated before spill/reload, so
22/// there is no additional register for amx to identify the step in spill.)
23/// The volatileTileData() will handle this case.
24/// e.g.
25/// ----------------------------------------------------------
26/// | def %td = ...                                          |
27/// | ...                                                    |
28/// | "use %td"                                              |
29/// ----------------------------------------------------------
30/// will transfer to -->
31/// ----------------------------------------------------------
32/// | def %td = ...                                          |
33/// | call void @llvm.x86.tilestored64.internal(mem, %td)    |
34/// | ...                                                    |
35/// | %td2 = call x86_amx @llvm.x86.tileloadd64.internal(mem)|
36/// | "use %td2"                                             |
37/// ----------------------------------------------------------
38//
39//===----------------------------------------------------------------------===//
40//
41#include "X86.h"
42#include "llvm/ADT/PostOrderIterator.h"
43#include "llvm/ADT/SetVector.h"
44#include "llvm/ADT/SmallSet.h"
45#include "llvm/Analysis/OptimizationRemarkEmitter.h"
46#include "llvm/Analysis/TargetLibraryInfo.h"
47#include "llvm/Analysis/TargetTransformInfo.h"
48#include "llvm/CodeGen/Passes.h"
49#include "llvm/CodeGen/TargetPassConfig.h"
50#include "llvm/CodeGen/ValueTypes.h"
51#include "llvm/IR/DataLayout.h"
52#include "llvm/IR/Function.h"
53#include "llvm/IR/IRBuilder.h"
54#include "llvm/IR/Instructions.h"
55#include "llvm/IR/IntrinsicInst.h"
56#include "llvm/IR/IntrinsicsX86.h"
57#include "llvm/IR/PatternMatch.h"
58#include "llvm/InitializePasses.h"
59#include "llvm/Pass.h"
60#include "llvm/Target/TargetMachine.h"
61#include "llvm/Transforms/Utils/AssumeBundleBuilder.h"
62#include "llvm/Transforms/Utils/Local.h"

64#include <map>

66using namespace llvm;
67using namespace PatternMatch;

69#define DEBUG_TYPE"lower-amx-type" "lower-amx-type"

71static bool isAMXCast(Instruction *II) {
return match(II,
             m_Intrinsic<Intrinsic::x86_cast_vector_to_tile>(m_Value())) ||
       match(II, m_Intrinsic<Intrinsic::x86_cast_tile_to_vector>(m_Value()));
75}

77static bool isAMXIntrinsic(Value *I) {
auto *II = dyn_cast<IntrinsicInst>(I);
if (!II)
  return false;
if (isAMXCast(II))
  return false;
// Check if return type or parameter is x86_amx. If it is x86_amx
// the intrinsic must be x86 amx intrinsics.
if (II->getType()->isX86_AMXTy())
  return true;
for (Value *V : II->args()) {
  if (V->getType()->isX86_AMXTy())
    return true;
}

return false;
93}

95static AllocaInst *createAllocaInstAtEntry(IRBuilder<> &Builder, BasicBlock *BB,
                                         Type *Ty) {
Function &F = *BB->getParent();
Module *M = BB->getModule();
const DataLayout &DL = M->getDataLayout();

LLVMContext &Ctx = Builder.getContext();
auto AllocaAlignment = DL.getPrefTypeAlign(Type::getX86_AMXTy(Ctx));
unsigned AllocaAS = DL.getAllocaAddrSpace();
AllocaInst *AllocaRes =
    new AllocaInst(Ty, AllocaAS, "", &F.getEntryBlock().front());
AllocaRes->setAlignment(AllocaAlignment);
return AllocaRes;
108}

110static Instruction *getFirstNonAllocaInTheEntryBlock(Function &F) {
for (Instruction &I : F.getEntryBlock())
  if (!isa<AllocaInst>(&I))
    return &I;
llvm_unreachable("No terminator in the entry block!")::llvm::llvm_unreachable_internal("No terminator in the entry block!"
, "llvm/lib/Target/X86/X86LowerAMXType.cpp", 114);
115}

117static std::pair<Value *, Value *> getShape(IntrinsicInst *II, unsigned OpNo) {
IRBuilder<> Builder(II);
Value *Row = nullptr, *Col = nullptr;
switch (II->getIntrinsicID()) {
default:
  llvm_unreachable("Expect amx intrinsics")::llvm::llvm_unreachable_internal("Expect amx intrinsics", "llvm/lib/Target/X86/X86LowerAMXType.cpp"
, 122);
case Intrinsic::x86_tileloadd64_internal:
case Intrinsic::x86_tileloaddt164_internal:
case Intrinsic::x86_tilestored64_internal: {
  Row = II->getArgOperand(0);
  Col = II->getArgOperand(1);
  break;
}
// a * b + c
// The shape depends on which operand.
case Intrinsic::x86_tdpbssd_internal:
case Intrinsic::x86_tdpbsud_internal:
case Intrinsic::x86_tdpbusd_internal:
case Intrinsic::x86_tdpbuud_internal:
case Intrinsic::x86_tdpbf16ps_internal: {
  switch (OpNo) {
  case 3:
    Row = II->getArgOperand(0);
    Col = II->getArgOperand(1);
    break;
  case 4:
    Row = II->getArgOperand(0);
    Col = II->getArgOperand(2);
    break;
  case 5:
    if (isa<ConstantInt>(II->getArgOperand(2)))
      Row = Builder.getInt16(
          (cast<ConstantInt>(II->getOperand(2))->getSExtValue()) / 4);
    else if (isa<Instruction>(II->getArgOperand(2))) {
      // When it is not a const value and it is not a function argument, we
      // create Row after the definition of II->getOperand(2) instead of
      // before II. For example, II is %118, we try to getshape for %117:
      //   %117 = call x86_amx @llvm.x86.cast.vector.to.tile.v256i32(<256 x
      //   i32> %115).
      //   %118 = call x86_amx @llvm.x86.tdpbf16ps.internal(i16
      //   %104, i16 %105, i16 %106, x86_amx %110, x86_amx %114, x86_amx
      //   %117).
      // If we create %row = udiv i16 %106, 4 before %118(aka. II), then its
      // definition is after its user(new tileload for %117).
      // So, the best choice is to create %row right after the definition of
      // %106.
      Builder.SetInsertPoint(cast<Instruction>(II->getOperand(2)));
      Row = Builder.CreateUDiv(II->getOperand(2), Builder.getInt16(4));
      cast<Instruction>(Row)->moveAfter(cast<Instruction>(II->getOperand(2)));
    } else {
      // When it is not a const value and it is a function argument, we create
      // Row at the entry bb.
      IRBuilder<> NewBuilder(
          getFirstNonAllocaInTheEntryBlock(*II->getFunction()));
      Row = NewBuilder.CreateUDiv(II->getOperand(2), NewBuilder.getInt16(4));
    }
    Col = II->getArgOperand(1);
    break;
  }
  break;
}
}

return std::make_pair(Row, Col);
181}

183static std::pair<Value *, Value *> getShape(PHINode *Phi) {
Use &U = *(Phi->use_begin());
unsigned OpNo = U.getOperandNo();
User *V = U.getUser();
// TODO We don't traverse all users. To make the algorithm simple, here we
// just traverse the first user. If we can find shape, then return the shape,
// otherwise just return nullptr and the optimization for undef/zero will be
// abandoned.
while (V) {
  if (isAMXCast(dyn_cast<Instruction>(V))) {
    if (V->use_empty())
      break;
    Use &U = *(V->use_begin());
    OpNo = U.getOperandNo();
    V = U.getUser();
  } else if (isAMXIntrinsic(V)) {
    return getShape(cast<IntrinsicInst>(V), OpNo);
  } else if (isa<PHINode>(V)) {
    if (V->use_empty())
      break;
    Use &U = *(V->use_begin());
    V = U.getUser();
  } else {
    break;
  }
}

return std::make_pair(nullptr, nullptr);
211}

213namespace {
214class X86LowerAMXType {
Function &Func;

// In AMX intrinsics we let Shape = {Row, Col}, but the
// RealCol = Col / ElementSize. We may use the RealCol
// as a new Row for other new created AMX intrinsics.
std::map<Value *, Value *> Col2Row;

222public:
X86LowerAMXType(Function &F) : Func(F) {}
bool visit();
void combineLoadBitcast(LoadInst *LD, BitCastInst *Bitcast);
void combineBitcastStore(BitCastInst *Bitcast, StoreInst *ST);
bool transformBitcast(BitCastInst *Bitcast);
228};

230// %src = load <256 x i32>, <256 x i32>* %addr, align 64
231// %2 = bitcast <256 x i32> %src to x86_amx
232// -->
233// %2 = call x86_amx @llvm.x86.tileloadd64.internal(i16 %row, i16 %col,
234// i8* %addr, i64 %stride64)
235void X86LowerAMXType::combineLoadBitcast(LoadInst *LD, BitCastInst *Bitcast) {
Value *Row = nullptr, *Col = nullptr;
Use &U = *(Bitcast->use_begin());
unsigned OpNo = U.getOperandNo();
auto *II = cast<IntrinsicInst>(U.getUser());
std::tie(Row, Col) = getShape(II, OpNo);
IRBuilder<> Builder(Bitcast);
// Use the maximun column as stride.
Value *Stride = Builder.getInt64(64);
Value *I8Ptr =
    Builder.CreateBitCast(LD->getOperand(0), Builder.getInt8PtrTy());
std::array<Value *, 4> Args = {Row, Col, I8Ptr, Stride};

Value *NewInst =
    Builder.CreateIntrinsic(Intrinsic::x86_tileloadd64_internal, None, Args);
Bitcast->replaceAllUsesWith(NewInst);
251}

253// %src = call x86_amx @llvm.x86.tileloadd64.internal(%row, %col, %addr,
254//                                                    %stride);
255// %13 = bitcast x86_amx %src to <256 x i32>
256// store <256 x i32> %13, <256 x i32>* %addr, align 64
257// -->
258// call void @llvm.x86.tilestored64.internal(%row, %col, %addr,
259//                                           %stride64, %13)
260void X86LowerAMXType::combineBitcastStore(BitCastInst *Bitcast, StoreInst *ST) {

Value *Tile = Bitcast->getOperand(0);
auto *II = cast<IntrinsicInst>(Tile);
// Tile is output from AMX intrinsic. The first operand of the
// intrinsic is row, the second operand of the intrinsic is column.
Value *Row = II->getOperand(0);
Value *Col = II->getOperand(1);
IRBuilder<> Builder(ST);
// Use the maximum column as stride. It must be the same with load
// stride.
Value *Stride = Builder.getInt64(64);
Value *I8Ptr =
    Builder.CreateBitCast(ST->getOperand(1), Builder.getInt8PtrTy());
std::array<Value *, 5> Args = {Row, Col, I8Ptr, Stride, Tile};
Builder.CreateIntrinsic(Intrinsic::x86_tilestored64_internal, None, Args);
if (Bitcast->hasOneUse())
  return;
// %13 = bitcast x86_amx %src to <256 x i32>
// store <256 x i32> %13, <256 x i32>* %addr, align 64
// %add = <256 x i32> %13, <256 x i32> %src2
// -->
// %13 = bitcast x86_amx %src to <256 x i32>
// call void @llvm.x86.tilestored64.internal(%row, %col, %addr,
//                                           %stride64, %13)
// %14 = load <256 x i32>, %addr
// %add = <256 x i32> %14, <256 x i32> %src2
Value *Vec = Builder.CreateLoad(Bitcast->getType(), ST->getOperand(1));
Bitcast->replaceAllUsesWith(Vec);
289}

291// transform bitcast to <store, load> instructions.
292bool X86LowerAMXType::transformBitcast(BitCastInst *Bitcast) {
IRBuilder<> Builder(Bitcast);
AllocaInst *AllocaAddr;
Value *I8Ptr, *Stride;
auto *Src = Bitcast->getOperand(0);

auto Prepare = [&](Type *MemTy) {
  AllocaAddr = createAllocaInstAtEntry(Builder, Bitcast->getParent(), MemTy);
  I8Ptr = Builder.CreateBitCast(AllocaAddr, Builder.getInt8PtrTy());
  Stride = Builder.getInt64(64);
};

if (Bitcast->getType()->isX86_AMXTy()) {
  // %2 = bitcast <256 x i32> %src to x86_amx
  // -->
  // %addr = alloca <256 x i32>, align 64
  // store <256 x i32> %src, <256 x i32>* %addr, align 64
  // %addr2 = bitcast <256 x i32>* to i8*
  // %2 = call x86_amx @llvm.x86.tileloadd64.internal(i16 %row, i16 %col,
  //                                                  i8* %addr2,
  //                                                  i64 64)
  Use &U = *(Bitcast->use_begin());
  unsigned OpNo = U.getOperandNo();
  auto *II = dyn_cast<IntrinsicInst>(U.getUser());
  if (!II)
    return false; // May be bitcast from x86amx to <256 x i32>.
  Prepare(Bitcast->getOperand(0)->getType());
  Builder.CreateStore(Src, AllocaAddr);
  // TODO we can pick an constant operand for the shape.
  Value *Row = nullptr, *Col = nullptr;
  std::tie(Row, Col) = getShape(II, OpNo);
  std::array<Value *, 4> Args = {Row, Col, I8Ptr, Stride};
  Value *NewInst = Builder.CreateIntrinsic(
      Intrinsic::x86_tileloadd64_internal, None, Args);
  Bitcast->replaceAllUsesWith(NewInst);
} else {
  // %2 = bitcast x86_amx %src to <256 x i32>
  // -->
  // %addr = alloca <256 x i32>, align 64
  // %addr2 = bitcast <256 x i32>* to i8*
  // call void @llvm.x86.tilestored64.internal(i16 %row, i16 %col,
  //                                           i8* %addr2, i64 %stride)
  // %2 = load <256 x i32>, <256 x i32>* %addr, align 64
  auto *II = dyn_cast<IntrinsicInst>(Src);
  if (!II)
    return false; // May be bitcast from <256 x i32> to x86amx.
  Prepare(Bitcast->getType());
  Value *Row = II->getOperand(0);
  Value *Col = II->getOperand(1);
  std::array<Value *, 5> Args = {Row, Col, I8Ptr, Stride, Src};
  Builder.CreateIntrinsic(Intrinsic::x86_tilestored64_internal, None, Args);
  Value *NewInst = Builder.CreateLoad(Bitcast->getType(), AllocaAddr);
  Bitcast->replaceAllUsesWith(NewInst);
}

return true;
348}

350bool X86LowerAMXType::visit() {
SmallVector<Instruction *, 8> DeadInsts;
Col2Row.clear();

for (BasicBlock *BB : post_order(&Func)) {
  for (Instruction &Inst : llvm::make_early_inc_range(llvm::reverse(*BB))) {
    auto *Bitcast = dyn_cast<BitCastInst>(&Inst);
    if (!Bitcast)
      continue;

    Value *Src = Bitcast->getOperand(0);
    if (Bitcast->getType()->isX86_AMXTy()) {
      if (Bitcast->user_empty()) {
        DeadInsts.push_back(Bitcast);
        continue;
      }
      LoadInst *LD = dyn_cast<LoadInst>(Src);
      if (!LD) {
        if (transformBitcast(Bitcast))
          DeadInsts.push_back(Bitcast);
        continue;
      }
      // If load has mutli-user, duplicate a vector load.
      // %src = load <256 x i32>, <256 x i32>* %addr, align 64
      // %2 = bitcast <256 x i32> %src to x86_amx
      // %add = add <256 x i32> %src, <256 x i32> %src2
      // -->
      // %src = load <256 x i32>, <256 x i32>* %addr, align 64
      // %2 = call x86_amx @llvm.x86.tileloadd64.internal(i16 %row, i16 %col,
      //                                            i8* %addr, i64 %stride64)
      // %add = add <256 x i32> %src, <256 x i32> %src2

      // If load has one user, the load will be eliminated in DAG ISel.
      // %src = load <256 x i32>, <256 x i32>* %addr, align 64
      // %2 = bitcast <256 x i32> %src to x86_amx
      // -->
      // %2 = call x86_amx @llvm.x86.tileloadd64.internal(i16 %row, i16 %col,
      //                                            i8* %addr, i64 %stride64)
      combineLoadBitcast(LD, Bitcast);
      DeadInsts.push_back(Bitcast);
      if (LD->hasOneUse())
        DeadInsts.push_back(LD);
    } else if (Src->getType()->isX86_AMXTy()) {
      if (Bitcast->user_empty()) {
        DeadInsts.push_back(Bitcast);
        continue;
      }
      StoreInst *ST = nullptr;
      for (Use &U : Bitcast->uses()) {
        ST = dyn_cast<StoreInst>(U.getUser());
        if (ST)
          break;
      }
      if (!ST) {
        if (transformBitcast(Bitcast))
          DeadInsts.push_back(Bitcast);
        continue;
      }
      // If bitcast (%13) has one use, combine bitcast and store to amx store.
      // %src = call x86_amx @llvm.x86.tileloadd64.internal(%row, %col, %addr,
      //                                                    %stride);
      // %13 = bitcast x86_amx %src to <256 x i32>
      // store <256 x i32> %13, <256 x i32>* %addr, align 64
      // -->
      // call void @llvm.x86.tilestored64.internal(%row, %col, %addr,
      //                                           %stride64, %13)
      //
      // If bitcast (%13) has multi-use, transform as below.
      // %13 = bitcast x86_amx %src to <256 x i32>
      // store <256 x i32> %13, <256 x i32>* %addr, align 64
      // %add = <256 x i32> %13, <256 x i32> %src2
      // -->
      // %13 = bitcast x86_amx %src to <256 x i32>
      // call void @llvm.x86.tilestored64.internal(%row, %col, %addr,
      //                                           %stride64, %13)
      // %14 = load <256 x i32>, %addr
      // %add = <256 x i32> %14, <256 x i32> %src2
      //
      combineBitcastStore(Bitcast, ST);
      // Delete user first.
      DeadInsts.push_back(ST);
      DeadInsts.push_back(Bitcast);
    }
  }
}

bool C = !DeadInsts.empty();

for (auto *Inst : DeadInsts)
  Inst->eraseFromParent();

return C;
442}
443} // anonymous namespace

445static Value *getAllocaPos(BasicBlock *BB) {
Module *M = BB->getModule();
Function *F = BB->getParent();
IRBuilder<> Builder(&F->getEntryBlock().front());
const DataLayout &DL = M->getDataLayout();
unsigned AllocaAS = DL.getAllocaAddrSpace();
Type *V256I32Ty = VectorType::get(Builder.getInt32Ty(), 256, false);
AllocaInst *AllocaRes =
    new AllocaInst(V256I32Ty, AllocaAS, "", &F->getEntryBlock().front());
BasicBlock::iterator Iter = AllocaRes->getIterator();
++Iter;
Builder.SetInsertPoint(&*Iter);
Value *I8Ptr = Builder.CreateBitCast(AllocaRes, Builder.getInt8PtrTy());
return I8Ptr;
459}

461static Instruction *createTileStore(Instruction *TileDef, Value *Ptr) {
assert(TileDef->getType()->isX86_AMXTy() && "Not define tile!")(static_cast <bool> (TileDef->getType()->isX86_AMXTy
() && "Not define tile!") ? void (0) : __assert_fail (
"TileDef->getType()->isX86_AMXTy() && \"Not define tile!\""
, "llvm/lib/Target/X86/X86LowerAMXType.cpp", 462, __extension__
 __PRETTY_FUNCTION__));
auto *II = cast<IntrinsicInst>(TileDef);
assert(II && "Not tile intrinsic!")(static_cast <bool> (II && "Not tile intrinsic!"
) ? void (0) : __assert_fail ("II && \"Not tile intrinsic!\""
, "llvm/lib/Target/X86/X86LowerAMXType.cpp", 464, __extension__
 __PRETTY_FUNCTION__));
Value *Row = II->getOperand(0);
Value *Col = II->getOperand(1);

BasicBlock *BB = TileDef->getParent();
BasicBlock::iterator Iter = TileDef->getIterator();
IRBuilder<> Builder(BB, ++Iter);
Value *Stride = Builder.getInt64(64);
std::array<Value *, 5> Args = {Row, Col, Ptr, Stride, TileDef};

Instruction *TileStore =
    Builder.CreateIntrinsic(Intrinsic::x86_tilestored64_internal, None, Args);
return TileStore;
477}

479static void replaceWithTileLoad(Use &U, Value *Ptr, bool IsPHI = false) {
Value *V = U.get();
assert(V->getType()->isX86_AMXTy() && "Not define tile!")(static_cast <bool> (V->getType()->isX86_AMXTy() &&
 "Not define tile!") ? void (0) : __assert_fail ("V->getType()->isX86_AMXTy() && \"Not define tile!\""
, "llvm/lib/Target/X86/X86LowerAMXType.cpp", 481, __extension__
 __PRETTY_FUNCTION__));
14
←
'?' condition is true→

// Get tile shape.
IntrinsicInst *II = nullptr;
if (IsPHI14.1
'IsPHI' is true
1
'IsPHI' is true
) {
15
←
Taking true branch→
  Value *PhiOp = dyn_cast<PHINode>(V)->getIncomingValue(0);
16
←
Assuming 'V' is a 'CastReturnType'→
  II = cast<IntrinsicInst>(PhiOp);
17
←
'PhiOp' is a 'CastReturnType'→
} else {
  II = cast<IntrinsicInst>(V);
}
Value *Row = II->getOperand(0);
Value *Col = II->getOperand(1);

Instruction *UserI = dyn_cast<Instruction>(U.getUser());
18
←
Assuming the object is not a 'CastReturnType'→
19
←
'UserI' initialized to a null pointer value→
IRBuilder<> Builder(UserI);
20
←
Passing null pointer value via 1st parameter 'IP'→
21
←
Calling constructor for 'IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>'→
Value *Stride = Builder.getInt64(64);
std::array<Value *, 4> Args = {Row, Col, Ptr, Stride};

Value *TileLoad =
    Builder.CreateIntrinsic(Intrinsic::x86_tileloadd64_internal, None, Args);
UserI->replaceUsesOfWith(V, TileLoad);
502}

504static bool isIncomingOfPHI(Instruction *I) {
for (Use &U : I->uses()) {
  User *V = U.getUser();
  if (isa<PHINode>(V))
    return true;
}
return false;
511}

513// Let all AMX tile data become volatile data, shorten the life range
514// of each tile register before fast register allocation.
515namespace {
516class X86VolatileTileData {
Function &F;

519public:
X86VolatileTileData(Function &Func) : F(Func) {}
Value *updatePhiIncomings(BasicBlock *BB,
                          SmallVector<Instruction *, 2> &Incomings);
void replacePhiDefWithLoad(Instruction *PHI, Value *StorePtr);
bool volatileTileData();
void volatileTilePHI(PHINode *Inst);
void volatileTileNonPHI(Instruction *I);
527};

529Value *X86VolatileTileData::updatePhiIncomings(
  BasicBlock *BB, SmallVector<Instruction *, 2> &Incomings) {
Value *I8Ptr = getAllocaPos(BB);

for (auto *I : Incomings) {
  User *Store = createTileStore(I, I8Ptr);

  // All its uses (except phi) should load from stored mem.
  for (Use &U : I->uses()) {
    User *V = U.getUser();
    if (isa<PHINode>(V) || V == Store)
      continue;
    replaceWithTileLoad(U, I8Ptr);
  }
}
return I8Ptr;
545}

547void X86VolatileTileData::replacePhiDefWithLoad(Instruction *PHI,
                                              Value *StorePtr) {
for (Use &U : PHI->uses())
  replaceWithTileLoad(U, StorePtr, true);
13
←
Calling 'replaceWithTileLoad'→
PHI->eraseFromParent();
552}

554// Smilar with volatileTileNonPHI, this function only handle PHI Nodes
555// and their related AMX intrinsics.
556// 1) PHI Def should change to tileload.
557// 2) PHI Incoming Values should tilestored in just after their def.
558// 3) The mem of these tileload and tilestores should be same.
559// e.g.
560// ------------------------------------------------------
561// bb_dom:
562//   ...
563//   br i1 %bool.cond, label %if.else, label %if.then
564//
565// if.then:
566//   def %t0 = ...
567//   ...
568//   use %t0
569//   ...
570//   br label %if.end
571//
572// if.else:
573//   def %t1 = ...
574//   br label %if.end
575//
576// if.end:
577//   %td = phi x86_amx [ %t1, %if.else ], [ %t0, %if.then ]
578//   ...
579//   use %td
580// ------------------------------------------------------
581// -->
582// ------------------------------------------------------
583// bb_entry:
584//   %mem = alloca <256 x i32>, align 1024                  *
585//   ...
586// bb_dom:
587//   ...
588//   br i1 %bool.cond, label %if.else, label %if.then
589//
590// if.then:
591//   def %t0 = ...
592//   call void @llvm.x86.tilestored64.internal(mem, %t0)    *
593//   ...
594//   %t0` = call x86_amx @llvm.x86.tileloadd64.internal(mem)*
595//   use %t0`                                               *
596//   ...
597//   br label %if.end
598//
599// if.else:
600//   def %t1 = ...
601//   call void @llvm.x86.tilestored64.internal(mem, %t1)    *
602//   br label %if.end
603//
604// if.end:
605//   ...
606//   %td = call x86_amx @llvm.x86.tileloadd64.internal(mem) *
607//   use %td
608// ------------------------------------------------------
609void X86VolatileTileData::volatileTilePHI(PHINode *PHI) {
BasicBlock *BB = PHI->getParent();
SmallVector<Instruction *, 2> Incomings;

for (unsigned I = 0, E = PHI->getNumIncomingValues(); I != E; ++I) {
10
←
Assuming 'I' is equal to 'E'→
11
←
Loop condition is false. Execution continues on line 620→
  Value *Op = PHI->getIncomingValue(I);
  Instruction *Inst = dyn_cast<Instruction>(Op);
  assert(Inst && "We shouldn't fold AMX instrution!")(static_cast <bool> (Inst && "We shouldn't fold AMX instrution!"
) ? void (0) : __assert_fail ("Inst && \"We shouldn't fold AMX instrution!\""
, "llvm/lib/Target/X86/X86LowerAMXType.cpp", 616, __extension__
 __PRETTY_FUNCTION__));
  Incomings.push_back(Inst);
}

Value *StorePtr = updatePhiIncomings(BB, Incomings);
replacePhiDefWithLoad(PHI, StorePtr);
12
←
Calling 'X86VolatileTileData::replacePhiDefWithLoad'→
622}

624// Store the defined tile and load it before use.
625// All its users are not PHI.
626// e.g.
627// ------------------------------------------------------
628// def %td = ...
629// ...
630// "use %td"
631// ------------------------------------------------------
632// -->
633// ------------------------------------------------------
634// def %td = ...
635// call void @llvm.x86.tilestored64.internal(mem, %td)
636// ...
637// %td2 = call x86_amx @llvm.x86.tileloadd64.internal(mem)
638// "use %td2"
639// ------------------------------------------------------
640void X86VolatileTileData::volatileTileNonPHI(Instruction *I) {
BasicBlock *BB = I->getParent();
Value *I8Ptr = getAllocaPos(BB);
User *Store = createTileStore(I, I8Ptr);

// All its uses should load from stored mem.
for (Use &U : I->uses()) {
  User *V = U.getUser();
  assert(!isa<PHINode>(V) && "PHI Nodes should be excluded!")(static_cast <bool> (!isa<PHINode>(V) && "PHI Nodes should be excluded!"
) ? void (0) : __assert_fail ("!isa<PHINode>(V) && \"PHI Nodes should be excluded!\""
, "llvm/lib/Target/X86/X86LowerAMXType.cpp", 648, __extension__
 __PRETTY_FUNCTION__));
  if (V != Store)
    replaceWithTileLoad(U, I8Ptr);
}
652}

654// Volatile Tile Model:
655// 1) All the uses of tile data comes from tileload in time.
656// 2) All the defs of tile data tilestore into mem immediately.
657// For example:
658// --------------------------------------------------------------------------
659// %t1 = call x86_amx @llvm.x86.tileloadd64.internal(m, k, ...)          key
660// %t2 = call x86_amx @llvm.x86.tileloadd64.internal(k, n, ...)
661// %t3 = call x86_amx @llvm.x86.tileloadd64.internal(m, n, ...)          amx
662// %td = tail call x86_amx @llvm.x86.tdpbssd.internal(m, n, k, t1, t2, t3)
663// call void @llvm.x86.tilestored64.internal(... td)                     area
664// --------------------------------------------------------------------------
665// 3) No terminator, call or other amx instructions in the key amx area.
666bool X86VolatileTileData::volatileTileData() {
bool Changed = false;
for (BasicBlock &BB : F) {
  SmallVector<Instruction *, 2> PHIInsts;
  SmallVector<Instruction *, 8> AMXDefInsts;

  for (Instruction &I : BB) {
    if (!I.getType()->isX86_AMXTy())
      continue;
    if (isa<PHINode>(&I))
      PHIInsts.push_back(&I);
    else
      AMXDefInsts.push_back(&I);
  }

  // First we "volatile" the non-phi related amx intrinsics.
  for (Instruction *I : AMXDefInsts) {
6
←
Assuming '__begin2' is equal to '__end2'→
    if (isIncomingOfPHI(I))
      continue;
    volatileTileNonPHI(I);
    Changed = true;
  }

  for (Instruction *I : PHIInsts) {
7
←
Assuming '__begin2' is not equal to '__end2'→
    volatileTilePHI(dyn_cast<PHINode>(I));
8
←
Assuming 'I' is a 'CastReturnType'→
9
←
Calling 'X86VolatileTileData::volatileTilePHI'→
    Changed = true;
  }
}
return Changed;
695}

697} // anonymous namespace

699namespace {

701class X86LowerAMXCast {
Function &Func;

704public:
X86LowerAMXCast(Function &F) : Func(F) {}
void combineCastStore(IntrinsicInst *Cast, StoreInst *ST);
void combineLoadCast(IntrinsicInst *Cast, LoadInst *LD);
bool combineLdSt(SmallVectorImpl<Instruction *> &Casts);
bool combineAMXcast(TargetLibraryInfo *TLI);
bool transformAMXCast(IntrinsicInst *AMXCast);
bool transformAllAMXCast();
bool optimizeAMXCastFromPhi(IntrinsicInst *CI, PHINode *PN,
                            SmallSetVector<Instruction *, 16> &DeadInst);
714};

716static bool DCEInstruction(Instruction *I,
                         SmallSetVector<Instruction *, 16> &WorkList,
                         const TargetLibraryInfo *TLI) {
if (isInstructionTriviallyDead(I, TLI)) {
  salvageDebugInfo(*I);
  salvageKnowledge(I);

  // Null out all of the instruction's operands to see if any operand becomes
  // dead as we go.
  for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i) {
    Value *OpV = I->getOperand(i);
    I->setOperand(i, nullptr);

    if (!OpV->use_empty() || I == OpV)
      continue;

    // If the operand is an instruction that became dead as we nulled out the
    // operand, and if it is 'trivially' dead, delete it in a future loop
    // iteration.
    if (Instruction *OpI = dyn_cast<Instruction>(OpV)) {
      if (isInstructionTriviallyDead(OpI, TLI)) {
        WorkList.insert(OpI);
      }
    }
  }
  I->eraseFromParent();
  return true;
}
return false;
745}

747/// This function handles following case
748///
749///     A  ->  B    amxcast
750///     PHI
751///     B  ->  A    amxcast
752///
753/// All the related PHI nodes can be replaced by new PHI nodes with type A.
754/// The uses of \p CI can be changed to the new PHI node corresponding to \p PN.
755bool X86LowerAMXCast::optimizeAMXCastFromPhi(
  IntrinsicInst *CI, PHINode *PN,
  SmallSetVector<Instruction *, 16> &DeadInst) {
IRBuilder<> Builder(CI);
Value *Src = CI->getOperand(0);
Type *SrcTy = Src->getType(); // Type B
Type *DestTy = CI->getType(); // Type A

SmallVector<PHINode *, 4> PhiWorklist;
SmallSetVector<PHINode *, 4> OldPhiNodes;

// Find all of the A->B casts and PHI nodes.
// We need to inspect all related PHI nodes, but PHIs can be cyclic, so
// OldPhiNodes is used to track all known PHI nodes, before adding a new
// PHI to PhiWorklist, it is checked against and added to OldPhiNodes first.
PhiWorklist.push_back(PN);
OldPhiNodes.insert(PN);
while (!PhiWorklist.empty()) {
  auto *OldPN = PhiWorklist.pop_back_val();
  for (unsigned I = 0; I < OldPN->getNumOperands(); ++I) {
    Value *IncValue = OldPN->getIncomingValue(I);
    // TODO: currently, We ignore cases where it is a const. In the future, we
    // might support const.
    if (isa<Constant>(IncValue)) {
      auto *IncConst = dyn_cast<Constant>(IncValue);
      if (!isa<UndefValue>(IncValue) && !IncConst->isZeroValue())
        return false;
      Value *Row = nullptr, *Col = nullptr;
      std::tie(Row, Col) = getShape(OldPN);
      // TODO: If it is not constant the Row and Col must domoniate tilezero
      // that we are going to create.
      if (!Row || !Col || !isa<Constant>(Row) || !isa<Constant>(Col))
        return false;
      // Create tilezero at the end of incoming block.
      auto *Block = OldPN->getIncomingBlock(I);
      BasicBlock::iterator Iter = Block->getTerminator()->getIterator();
      Instruction *NewInst = Builder.CreateIntrinsic(
          Intrinsic::x86_tilezero_internal, None, {Row, Col});
      NewInst->moveBefore(&*Iter);
      NewInst = Builder.CreateIntrinsic(Intrinsic::x86_cast_tile_to_vector,
                                        {IncValue->getType()}, {NewInst});
      NewInst->moveBefore(&*Iter);
      // Replace InValue with new Value.
      OldPN->setIncomingValue(I, NewInst);
      IncValue = NewInst;
    }

    if (auto *PNode = dyn_cast<PHINode>(IncValue)) {
      if (OldPhiNodes.insert(PNode))
        PhiWorklist.push_back(PNode);
      continue;
    }
    Instruction *ACI = dyn_cast<Instruction>(IncValue);
    if (ACI && isAMXCast(ACI)) {
      // Verify it's a A->B cast.
      Type *TyA = ACI->getOperand(0)->getType();
      Type *TyB = ACI->getType();
      if (TyA != DestTy || TyB != SrcTy)
        return false;
      continue;
    }
    return false;
  }
}

// Check that each user of each old PHI node is something that we can
// rewrite, so that all of the old PHI nodes can be cleaned up afterwards.
for (auto *OldPN : OldPhiNodes) {
  for (User *V : OldPN->users()) {
    Instruction *ACI = dyn_cast<Instruction>(V);
    if (ACI && isAMXCast(ACI)) {
      // Verify it's a B->A cast.
      Type *TyB = ACI->getOperand(0)->getType();
      Type *TyA = ACI->getType();
      if (TyA != DestTy || TyB != SrcTy)
        return false;
    } else if (auto *PHI = dyn_cast<PHINode>(V)) {
      // As long as the user is another old PHI node, then even if we don't
      // rewrite it, the PHI web we're considering won't have any users
      // outside itself, so it'll be dead.
      // example:
      //   bb.0:
      //      %0 = amxcast ...
      //   bb.1:
      //      %1 = amxcast ...
      //   bb.2:
      //      %goodphi = phi %0, %1
      //      %3 = amxcast %goodphi
      //   bb.3:
      //      %goodphi2 = phi %0, %goodphi
      //      %4 = amxcast %goodphi2
      // When optimizeAMXCastFromPhi process %3 and %goodphi, %goodphi2 is
      // outside the phi-web, so the combination stop When
      // optimizeAMXCastFromPhi process %4 and %goodphi2, the optimization
      // will be done.
      if (OldPhiNodes.count(PHI) == 0)
        return false;
    } else
      return false;
  }
}

// For each old PHI node, create a corresponding new PHI node with a type A.
SmallDenseMap<PHINode *, PHINode *> NewPNodes;
for (auto *OldPN : OldPhiNodes) {
  Builder.SetInsertPoint(OldPN);
  PHINode *NewPN = Builder.CreatePHI(DestTy, OldPN->getNumOperands());
  NewPNodes[OldPN] = NewPN;
}

// Fill in the operands of new PHI nodes.
for (auto *OldPN : OldPhiNodes) {
  PHINode *NewPN = NewPNodes[OldPN];
  for (unsigned j = 0, e = OldPN->getNumOperands(); j != e; ++j) {
    Value *V = OldPN->getOperand(j);
    Value *NewV = nullptr;
    Instruction *ACI = dyn_cast<Instruction>(V);
    // There should not be a AMXcast from a const.
    if (ACI && isAMXCast(ACI))
      NewV = ACI->getOperand(0);
    else if (auto *PrevPN = dyn_cast<PHINode>(V))
      NewV = NewPNodes[PrevPN];
    assert(NewV)(static_cast <bool> (NewV) ? void (0) : __assert_fail (
"NewV", "llvm/lib/Target/X86/X86LowerAMXType.cpp", 877, __extension__
 __PRETTY_FUNCTION__));
    NewPN->addIncoming(NewV, OldPN->getIncomingBlock(j));
  }
}

// Traverse all accumulated PHI nodes and process its users,
// which are Stores and BitcCasts. Without this processing
// NewPHI nodes could be replicated and could lead to extra
// moves generated after DeSSA.
// If there is a store with type B, change it to type A.

// Replace users of BitCast B->A with NewPHI. These will help
// later to get rid of a closure formed by OldPHI nodes.
for (auto *OldPN : OldPhiNodes) {
  PHINode *NewPN = NewPNodes[OldPN];
  for (User *V : make_early_inc_range(OldPN->users())) {
    Instruction *ACI = dyn_cast<Instruction>(V);
    if (ACI && isAMXCast(ACI)) {
      Type *TyB = ACI->getOperand(0)->getType();
      Type *TyA = ACI->getType();
      assert(TyA == DestTy && TyB == SrcTy)(static_cast <bool> (TyA == DestTy && TyB == SrcTy
) ? void (0) : __assert_fail ("TyA == DestTy && TyB == SrcTy"
, "llvm/lib/Target/X86/X86LowerAMXType.cpp", 897, __extension__
 __PRETTY_FUNCTION__));
      (void)TyA;
      (void)TyB;
      ACI->replaceAllUsesWith(NewPN);
      DeadInst.insert(ACI);
    } else if (auto *PHI = dyn_cast<PHINode>(V)) {
      // We don't need to push PHINode into DeadInst since they are operands
      // of rootPN DCE can safely delete rootPN's operands if rootPN is dead.
      assert(OldPhiNodes.contains(PHI))(static_cast <bool> (OldPhiNodes.contains(PHI)) ? void (
0) : __assert_fail ("OldPhiNodes.contains(PHI)", "llvm/lib/Target/X86/X86LowerAMXType.cpp"
, 905, __extension__ __PRETTY_FUNCTION__));
      (void)PHI;
    } else
      llvm_unreachable("all uses should be handled")::llvm::llvm_unreachable_internal("all uses should be handled"
, "llvm/lib/Target/X86/X86LowerAMXType.cpp", 908);
  }
}
return true;
912}

914// %43 = call <256 x i32> @llvm.x86.cast.tile.to.vector.v256i32(x86_amx %42)
915// store <256 x i32> %43, <256 x i32>* %p, align 64
916// -->
917// call void @llvm.x86.tilestored64.internal(i16 %row, i16 %col, i8* %p,
918//                                           i64 64, x86_amx %42)
919void X86LowerAMXCast::combineCastStore(IntrinsicInst *Cast, StoreInst *ST) {
Value *Tile = Cast->getOperand(0);
// TODO: If it is cast intrinsic or phi node, we can propagate the
// shape information through def-use chain.
if (!isAMXIntrinsic(Tile))
  return;
auto *II = cast<IntrinsicInst>(Tile);
// Tile is output from AMX intrinsic. The first operand of the
// intrinsic is row, the second operand of the intrinsic is column.
Value *Row = II->getOperand(0);
Value *Col = II->getOperand(1);
IRBuilder<> Builder(ST);
// Use the maximum column as stride. It must be the same with load
// stride.
Value *Stride = Builder.getInt64(64);
Value *I8Ptr =
    Builder.CreateBitCast(ST->getOperand(1), Builder.getInt8PtrTy());
std::array<Value *, 5> Args = {Row, Col, I8Ptr, Stride, Tile};
Builder.CreateIntrinsic(Intrinsic::x86_tilestored64_internal, None, Args);
938}

940// %65 = load <256 x i32>, <256 x i32>* %p, align 64
941// %66 = call x86_amx @llvm.x86.cast.vector.to.tile(<256 x i32> %65)
942// -->
943// %66 = call x86_amx @llvm.x86.tileloadd64.internal(i16 %row, i16 %col,
944//                                                   i8* %p, i64 64)
945void X86LowerAMXCast::combineLoadCast(IntrinsicInst *Cast, LoadInst *LD) {
Value *Row = nullptr, *Col = nullptr;
Use &U = *(Cast->use_begin());
unsigned OpNo = U.getOperandNo();
auto *II = cast<IntrinsicInst>(U.getUser());
// TODO: If it is cast intrinsic or phi node, we can propagate the
// shape information through def-use chain.
if (!isAMXIntrinsic(II))
  return;
std::tie(Row, Col) = getShape(II, OpNo);
IRBuilder<> Builder(LD);
// Use the maximun column as stride.
Value *Stride = Builder.getInt64(64);
Value *I8Ptr =
    Builder.CreateBitCast(LD->getOperand(0), Builder.getInt8PtrTy());
std::array<Value *, 4> Args = {Row, Col, I8Ptr, Stride};

Value *NewInst =
    Builder.CreateIntrinsic(Intrinsic::x86_tileloadd64_internal, None, Args);
Cast->replaceAllUsesWith(NewInst);
965}

967bool X86LowerAMXCast::combineLdSt(SmallVectorImpl<Instruction *> &Casts) {
bool Change = false;
for (auto *Cast : Casts) {
  auto *II = cast<IntrinsicInst>(Cast);
  // %43 = call <256 x i32> @llvm.x86.cast.tile.to.vector(x86_amx %42)
  // store <256 x i32> %43, <256 x i32>* %p, align 64
  // -->
  // call void @llvm.x86.tilestored64.internal(i16 %row, i16 %col, i8* %p,
  //                                           i64 64, x86_amx %42)
  if (II->getIntrinsicID() == Intrinsic::x86_cast_tile_to_vector) {
    SmallVector<Instruction *, 2> DeadStores;
    for (User *U : Cast->users()) {
      StoreInst *Store = dyn_cast<StoreInst>(U);
      if (!Store)
        continue;
      combineCastStore(cast<IntrinsicInst>(Cast), Store);
      DeadStores.push_back(Store);
      Change = true;
    }
    for (auto *Store : DeadStores)
      Store->eraseFromParent();
  } else { // x86_cast_vector_to_tile
    SmallVector<Instruction *, 2> DeadLoads;
    auto *Load = dyn_cast<LoadInst>(Cast->getOperand(0));
    if (!Load || !Load->hasOneUse())
      continue;
    // %65 = load <256 x i32>, <256 x i32>* %p, align 64
    // %66 = call x86_amx @llvm.x86.cast.vector.to.tile(<256 x i32> %65)
    // -->
    // %66 = call x86_amx @llvm.x86.tileloadd64.internal(i16 %row, i16 %col,
    //                                                   i8* %p, i64 64)
    combineLoadCast(cast<IntrinsicInst>(Cast), Load);
    // Set the operand is null so that load instruction can be erased.
    Cast->setOperand(0, nullptr);
    Load->eraseFromParent();
  }
}
return Change;
1005}

1007bool X86LowerAMXCast::combineAMXcast(TargetLibraryInfo *TLI) {
bool Change = false;
// Collect tile cast instruction.
SmallVector<Instruction *, 8> Vec2TileInsts;
SmallVector<Instruction *, 8> Tile2VecInsts;
SmallVector<Instruction *, 8> PhiCastWorkList;
SmallSetVector<Instruction *, 16> DeadInst;
for (BasicBlock &BB : Func) {
  for (Instruction &I : BB) {
    Value *Vec;
    if (match(&I,
              m_Intrinsic<Intrinsic::x86_cast_vector_to_tile>(m_Value(Vec))))
      Vec2TileInsts.push_back(&I);
    else if (match(&I, m_Intrinsic<Intrinsic::x86_cast_tile_to_vector>(
                           m_Value(Vec))))
      Tile2VecInsts.push_back(&I);
  }
}

auto Convert = [&](SmallVectorImpl<Instruction *> &Insts, Intrinsic::ID IID) {
  for (auto *Inst : Insts) {
    for (User *U : Inst->users()) {
      IntrinsicInst *II = dyn_cast<IntrinsicInst>(U);
      if (!II || II->getIntrinsicID() != IID)
        continue;
      // T1 = vec2tile V0
      // V2 = tile2vec T1
      // V3 = OP V2
      // -->
      // T1 = vec2tile V0
      // V2 = tile2vec T1
      // V3 = OP V0
      II->replaceAllUsesWith(Inst->getOperand(0));
      Change = true;
    }
  }
};

Convert(Vec2TileInsts, Intrinsic::x86_cast_tile_to_vector);
Convert(Tile2VecInsts, Intrinsic::x86_cast_vector_to_tile);

SmallVector<Instruction *, 8> LiveCasts;
auto EraseInst = [&](SmallVectorImpl<Instruction *> &Insts) {
  for (auto *Inst : Insts) {
    if (Inst->use_empty()) {
      Inst->eraseFromParent();
      Change = true;
    } else {
      LiveCasts.push_back(Inst);
    }
  }
};

EraseInst(Vec2TileInsts);
EraseInst(Tile2VecInsts);
Change |= combineLdSt(LiveCasts);
EraseInst(LiveCasts);

// Handle the A->B->A cast, and there is an intervening PHI node.
for (BasicBlock &BB : Func) {
  for (Instruction &I : BB) {
    if (isAMXCast(&I)) {
      if (isa<PHINode>(I.getOperand(0)))
        PhiCastWorkList.push_back(&I);
    }
  }
}
for (auto *I : PhiCastWorkList) {
  // We skip the dead Amxcast.
  if (DeadInst.contains(I))
    continue;
  PHINode *PN = cast<PHINode>(I->getOperand(0));
  if (optimizeAMXCastFromPhi(cast<IntrinsicInst>(I), PN, DeadInst)) {
    DeadInst.insert(PN);
    Change = true;
  }
}

// Since we create new phi and merge AMXCast, some old phis and AMXCast might
// have no uses. We do some DeadCodeElimination for them.
while (!DeadInst.empty()) {
  Instruction *I = DeadInst.pop_back_val();
  Change |= DCEInstruction(I, DeadInst, TLI);
}
return Change;
1092}

1094// There might be remaining AMXcast after combineAMXcast and they should be
1095// handled elegantly.
1096bool X86LowerAMXCast::transformAMXCast(IntrinsicInst *AMXCast) {
IRBuilder<> Builder(AMXCast);
AllocaInst *AllocaAddr;
Value *I8Ptr, *Stride;
auto *Src = AMXCast->getOperand(0);

auto Prepare = [&](Type *MemTy) {
  AllocaAddr = createAllocaInstAtEntry(Builder, AMXCast->getParent(), MemTy);
  I8Ptr = Builder.CreateBitCast(AllocaAddr, Builder.getInt8PtrTy());
  Stride = Builder.getInt64(64);
};

if (AMXCast->getType()->isX86_AMXTy()) {
  // %2 = amxcast <225 x i32> %src to x86_amx
  // call void @llvm.x86.tilestored64.internal(i16 15, i16 60,
  //                                           i8* %addr3, i64 60, x86_amx %2)
  // -->
  // %addr = alloca <225 x i32>, align 64
  // store <225 x i32> %src, <225 x i32>* %addr, align 64
  // %addr2 = bitcast <225 x i32>* %addr to i8*
  // %2 = call x86_amx @llvm.x86.tileloadd64.internal(i16 15, i16 60,
  //                                                  i8* %addr2,
  //                                                  i64 60)
  // call void @llvm.x86.tilestored64.internal(i16 15, i16 60,
  //                                           i8* %addr3, i64 60, x86_amx %2)
  if (AMXCast->use_empty()) {
    AMXCast->eraseFromParent();
    return true;
  }
  Use &U = *(AMXCast->use_begin());
  unsigned OpNo = U.getOperandNo();
  auto *II = dyn_cast<IntrinsicInst>(U.getUser());
  if (!II)
    return false; // May be bitcast from x86amx to <256 x i32>.
  Prepare(AMXCast->getOperand(0)->getType());
  Builder.CreateStore(Src, AllocaAddr);
  // TODO we can pick an constant operand for the shape.
  Value *Row = nullptr, *Col = nullptr;
  std::tie(Row, Col) = getShape(II, OpNo);
  std::array<Value *, 4> Args = {
      Row, Col, I8Ptr, Builder.CreateSExt(Col, Builder.getInt64Ty())};
  Value *NewInst = Builder.CreateIntrinsic(
      Intrinsic::x86_tileloadd64_internal, None, Args);
  AMXCast->replaceAllUsesWith(NewInst);
  AMXCast->eraseFromParent();
} else {
  // %2 = amxcast x86_amx %src to <225 x i32>
  // -->
  // %addr = alloca <225 x i32>, align 64
  // %addr2 = bitcast <225 x i32>* to i8*
  // call void @llvm.x86.tilestored64.internal(i16 %row, i16 %col,
  //                                           i8* %addr2, i64 %stride)
  // %2 = load <225 x i32>, <225 x i32>* %addr, align 64
  auto *II = dyn_cast<IntrinsicInst>(Src);
  if (!II)
    return false; // May be bitcast from <256 x i32> to x86amx.
  Prepare(AMXCast->getType());
  Value *Row = II->getOperand(0);
  Value *Col = II->getOperand(1);
  std::array<Value *, 5> Args = {
      Row, Col, I8Ptr, Builder.CreateSExt(Col, Builder.getInt64Ty()), Src};
  Builder.CreateIntrinsic(Intrinsic::x86_tilestored64_internal, None, Args);
  Value *NewInst = Builder.CreateLoad(AMXCast->getType(), AllocaAddr);
  AMXCast->replaceAllUsesWith(NewInst);
  AMXCast->eraseFromParent();
}

return true;
1164}

1166bool X86LowerAMXCast::transformAllAMXCast() {
bool Change = false;
// Collect tile cast instruction.
SmallVector<Instruction *, 8> WorkLists;
for (BasicBlock &BB : Func) {
  for (Instruction &I : BB) {
    if (isAMXCast(&I))
      WorkLists.push_back(&I);
  }
}

for (auto *Inst : WorkLists) {
  Change |= transformAMXCast(cast<IntrinsicInst>(Inst));
}

return Change;
1182}

1184} // anonymous namespace

1186namespace {

1188class X86LowerAMXTypeLegacyPass : public FunctionPass {
1189public:
static char ID;

X86LowerAMXTypeLegacyPass() : FunctionPass(ID) {
  initializeX86LowerAMXTypeLegacyPassPass(*PassRegistry::getPassRegistry());
}

bool runOnFunction(Function &F) override {
  bool C = false;
  TargetMachine *TM = &getAnalysis<TargetPassConfig>().getTM<TargetMachine>();
  TargetLibraryInfo *TLI =
      &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(F);
  X86LowerAMXCast LAC(F);
  C |= LAC.combineAMXcast(TLI);
  // There might be remaining AMXcast after combineAMXcast and they should be
  // handled elegantly.
  C |= LAC.transformAllAMXCast();

  X86LowerAMXType LAT(F);
  C |= LAT.visit();

  // Prepare for fast register allocation at O0.
  // Todo: May better check the volatile model of AMX code, not just
  // by checking Attribute::OptimizeNone and CodeGenOpt::None.
  if (TM->getOptLevel() == CodeGenOpt::None) {
1
Assuming the condition is true→
2
←
Taking true branch→
    // If Front End not use O0 but the Mid/Back end use O0, (e.g.
    // "Clang -O2 -S -emit-llvm t.c" + "llc t.ll") we should make
    // sure the amx data is volatile, that is nessary for AMX fast
    // register allocation.
    if (!F.hasFnAttribute(Attribute::OptimizeNone)) {
3
←
Assuming the condition is true→
4
←
Taking true branch→
      X86VolatileTileData VTD(F);
      C = VTD.volatileTileData() || C;
5
←
Calling 'X86VolatileTileData::volatileTileData'→
    }
  }

  return C;
}

void getAnalysisUsage(AnalysisUsage &AU) const override {
  AU.setPreservesCFG();
  AU.addRequired<TargetPassConfig>();
  AU.addRequired<TargetLibraryInfoWrapperPass>();
}
1232};

1234} // anonymous namespace

1236static const char PassName[] = "Lower AMX type for load/store";
1237char X86LowerAMXTypeLegacyPass::ID = 0;
1238INITIALIZE_PASS_BEGIN(X86LowerAMXTypeLegacyPass, DEBUG_TYPE, PassName, false,static void *initializeX86LowerAMXTypeLegacyPassPassOnce(PassRegistry
 &Registry) {
                    false)static void *initializeX86LowerAMXTypeLegacyPassPassOnce(PassRegistry
 &Registry) {
1240INITIALIZE_PASS_DEPENDENCY(TargetPassConfig)initializeTargetPassConfigPass(Registry);
1241INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)initializeTargetLibraryInfoWrapperPassPass(Registry);
1242INITIALIZE_PASS_END(X86LowerAMXTypeLegacyPass, DEBUG_TYPE, PassName, false,PassInfo *PI = new PassInfo( PassName, "lower-amx-type", &
X86LowerAMXTypeLegacyPass::ID, PassInfo::NormalCtor_t(callDefaultCtor
<X86LowerAMXTypeLegacyPass>), false, false); Registry.registerPass
(*PI, true); return PI; } static llvm::once_flag InitializeX86LowerAMXTypeLegacyPassPassFlag
; void llvm::initializeX86LowerAMXTypeLegacyPassPass(PassRegistry
 &Registry) { llvm::call_once(InitializeX86LowerAMXTypeLegacyPassPassFlag
, initializeX86LowerAMXTypeLegacyPassPassOnce, std::ref(Registry
)); }
                  false)PassInfo *PI = new PassInfo( PassName, "lower-amx-type", &
X86LowerAMXTypeLegacyPass::ID, PassInfo::NormalCtor_t(callDefaultCtor
<X86LowerAMXTypeLegacyPass>), false, false); Registry.registerPass
(*PI, true); return PI; } static llvm::once_flag InitializeX86LowerAMXTypeLegacyPassPassFlag
; void llvm::initializeX86LowerAMXTypeLegacyPassPass(PassRegistry
 &Registry) { llvm::call_once(InitializeX86LowerAMXTypeLegacyPassPassFlag
, initializeX86LowerAMXTypeLegacyPassPassOnce, std::ref(Registry
)); }

1245FunctionPass *llvm::createX86LowerAMXTypePass() {
return new X86LowerAMXTypeLegacyPass();
1247}

←

/build/source/llvm/include/llvm/IR/IRBuilder.h

1//===- llvm/IRBuilder.h - Builder for LLVM Instructions ---------*- 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// This file defines the IRBuilder class, which is used as a convenient way
10// to create LLVM instructions with a consistent and simplified interface.
11//
12//===----------------------------------------------------------------------===//

14#ifndef LLVM_IR_IRBUILDER_H
15#define LLVM_IR_IRBUILDER_H

17#include "llvm-c/Types.h"
18#include "llvm/ADT/ArrayRef.h"
19#include "llvm/ADT/None.h"
20#include "llvm/ADT/STLExtras.h"
21#include "llvm/ADT/StringRef.h"
22#include "llvm/ADT/Twine.h"
23#include "llvm/IR/BasicBlock.h"
24#include "llvm/IR/Constant.h"
25#include "llvm/IR/ConstantFolder.h"
26#include "llvm/IR/Constants.h"
27#include "llvm/IR/DataLayout.h"
28#include "llvm/IR/DebugLoc.h"
29#include "llvm/IR/DerivedTypes.h"
30#include "llvm/IR/FPEnv.h"
31#include "llvm/IR/Function.h"
32#include "llvm/IR/GlobalVariable.h"
33#include "llvm/IR/InstrTypes.h"
34#include "llvm/IR/Instruction.h"
35#include "llvm/IR/Instructions.h"
36#include "llvm/IR/Intrinsics.h"
37#include "llvm/IR/LLVMContext.h"
38#include "llvm/IR/Module.h"
39#include "llvm/IR/Operator.h"
40#include "llvm/IR/Type.h"
41#include "llvm/IR/Value.h"
42#include "llvm/IR/ValueHandle.h"
43#include "llvm/Support/AtomicOrdering.h"
44#include "llvm/Support/CBindingWrapping.h"
45#include "llvm/Support/Casting.h"
46#include <cassert>
47#include <cstdint>
48#include <functional>
49#include <utility>

51namespace llvm {

53class APInt;
54class Use;

56/// This provides the default implementation of the IRBuilder
57/// 'InsertHelper' method that is called whenever an instruction is created by
58/// IRBuilder and needs to be inserted.
59///
60/// By default, this inserts the instruction at the insertion point.
61class IRBuilderDefaultInserter {
62public:
virtual ~IRBuilderDefaultInserter();

virtual void InsertHelper(Instruction *I, const Twine &Name,
                          BasicBlock *BB,
                          BasicBlock::iterator InsertPt) const {
  if (BB) BB->getInstList().insert(InsertPt, I);
  I->setName(Name);
}
71};

73/// Provides an 'InsertHelper' that calls a user-provided callback after
74/// performing the default insertion.
75class IRBuilderCallbackInserter : public IRBuilderDefaultInserter {
std::function<void(Instruction *)> Callback;

78public:
~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);
}
90};

92/// Common base class shared among various IRBuilders.
93class 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);
}

117protected:
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;

133public:
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))(static_cast <bool> (isa<Constant>(V)) ? void (0)
 : __assert_fail ("isa<Constant>(V)", "llvm/include/llvm/IR/IRBuilder.h"
, 158, __extension__ __PRETTY_FUNCTION__));
  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()")(static_cast <bool> (InsertPt != BB->end() &&
 "Can't read debug loc from end()") ? void (0) : __assert_fail
 ("InsertPt != BB->end() && \"Can't read debug loc from end()\""
, "llvm/include/llvm/IR/IRBuilder.h", 189, __extension__ __PRETTY_FUNCTION__
));
  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) {
309#ifndef NDEBUG
  Optional<StringRef> ExceptStr = convertExceptionBehaviorToStr(NewExcept);
  assert(ExceptStr && "Garbage strict exception behavior!")(static_cast <bool> (ExceptStr && "Garbage strict exception behavior!"
) ? void (0) : __assert_fail ("ExceptStr && \"Garbage strict exception behavior!\""
, "llvm/include/llvm/IR/IRBuilder.h", 311, __extension__ __PRETTY_FUNCTION__
));
312#endif
  DefaultConstrainedExcept = NewExcept;
}

/// Set the rounding mode handling to be used with constrained floating point
void setDefaultConstrainedRounding(RoundingMode NewRounding) {
318#ifndef NDEBUG
  Optional<StringRef> RoundingStr = convertRoundingModeToStr(NewRounding);
  assert(RoundingStr && "Garbage strict rounding mode!")(static_cast <bool> (RoundingStr && "Garbage strict rounding mode!"
) ? void (0) : __assert_fail ("RoundingStr && \"Garbage strict rounding mode!\""
, "llvm/include/llvm/IR/IRBuilder.h", 320, __extension__ __PRETTY_FUNCTION__
));
321#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!")(static_cast <bool> (BB && "Must have a basic block to set any function attributes!"
) ? void (0) : __assert_fail ("BB && \"Must have a basic block to set any function attributes!\""
, "llvm/include/llvm/IR/IRBuilder.h", 336, __extension__ __PRETTY_FUNCTION__
));

  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);

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

706public:
/// 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 = llvm::None);

/// 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,
                                 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,
                                 Optional<ArrayRef<Use>> TransitionArgs,
                                 Optional<ArrayRef<Use>> DeoptArgs,
                                 ArrayRef<Value *> GCArgs,
                                 const Twine &Name = "");

/// Conveninence function for the common case when CallArgs are filled
/// in using makeArrayRef(CS.arg_begin(), CS.arg_end()); Use needs to be
/// .get()'ed to get the Value pointer.
CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes,
                                 FunctionCallee ActualCallee,
                                 ArrayRef<Use> CallArgs,
                                 Optional<ArrayRef<Value *>> DeoptArgs,
                                 ArrayRef<Value *> GCArgs,
                                 const Twine &Name = "");

/// Create an invoke to the experimental.gc.statepoint intrinsic to
/// start a new statepoint sequence.
InvokeInst *
CreateGCStatepointInvoke(uint64_t ID, uint32_t NumPatchBytes,
                         FunctionCallee ActualInvokee, BasicBlock *NormalDest,
                         BasicBlock *UnwindDest, ArrayRef<Value *> InvokeArgs,
                         Optional<ArrayRef<Value *>> DeoptArgs,
                         ArrayRef<Value *> GCArgs, const Twine &Name = "");

/// Create an invoke to the experimental.gc.statepoint intrinsic to
/// start a new statepoint sequence.
InvokeInst *CreateGCStatepointInvoke(
    uint64_t ID, uint32_t NumPatchBytes, FunctionCallee ActualInvokee,
    BasicBlock *NormalDest, BasicBlock *UnwindDest, uint32_t Flags,
    ArrayRef<Value *> InvokeArgs, Optional<ArrayRef<Use>> TransitionArgs,
    Optional<ArrayRef<Use>> DeoptArgs, ArrayRef<Value *> GCArgs,
    const Twine &Name = "");

// Convenience function for the common case when CallArgs are filled in using
// makeArrayRef(CS.arg_begin(), CS.arg_end()); Use needs to be .get()'ed to
// get the Value *.
InvokeInst *
CreateGCStatepointInvoke(uint64_t ID, uint32_t NumPatchBytes,
                         FunctionCallee ActualInvokee, BasicBlock *NormalDest,
                         BasicBlock *UnwindDest, ArrayRef<Use> InvokeArgs,
                         Optional<ArrayRef<Value *>> DeoptArgs,
                         ArrayRef<Value *> GCArgs, const Twine &Name = "");

/// Create a call to the experimental.gc.result intrinsic to extract
/// the result from a call wrapped in a statepoint.
CallInst *CreateGCResult(Instruction *Statepoint,
                         Type *ResultType,
                         const Twine &Name = "");

/// Create a call to the experimental.gc.relocate intrinsics to
/// project the relocated value of one pointer from the statepoint.
CallInst *CreateGCRelocate(Instruction *Statepoint,
                           int BaseOffset,
                           int DerivedOffset,
                           Type *ResultType,
                           const Twine &Name = "");

/// Create a call to the experimental.gc.pointer.base intrinsic to get the
/// base pointer for the specified derived pointer.
CallInst *CreateGCGetPointerBase(Value *DerivedPtr, const Twine &Name = "");

/// Create a call to the experimental.gc.get.pointer.offset intrinsic to get
/// the offset of the specified derived pointer from its base.
CallInst *CreateGCGetPointerOffset(Value *DerivedPtr, const Twine &Name = "");

/// Create a call to llvm.vscale, multiplied by \p Scaling. The type of VScale
/// will be the same type as that of \p Scaling.
Value *CreateVScale(Constant *Scaling, const Twine &Name = "");

/// Creates a vector of type \p DstType with the linear sequence <0, 1, ...>
Value *CreateStepVector(Type *DstType, const Twine &Name = "");

/// Create a call to intrinsic \p ID with 1 operand which is mangled on its
/// type.
CallInst *CreateUnaryIntrinsic(Intrinsic::ID ID, Value *V,
                               Instruction *FMFSource = nullptr,
                               const Twine &Name = "");

/// Create a call to intrinsic \p ID with 2 operands which is mangled on the
/// first type.
CallInst *CreateBinaryIntrinsic(Intrinsic::ID ID, Value *LHS, Value *RHS,
                                Instruction *FMFSource = nullptr,
                                const Twine &Name = "");

/// Create a call to intrinsic \p ID with \p Args, mangled using \p Types. If
/// \p FMFSource is provided, copy fast-math-flags from that instruction to
/// the intrinsic.
CallInst *CreateIntrinsic(Intrinsic::ID ID, ArrayRef<Type *> Types,
                          ArrayRef<Value *> Args,
                          Instruction *FMFSource = nullptr,
                          const Twine &Name = "");

/// Create a call to intrinsic \p ID with \p RetTy and \p Args. If
/// \p FMFSource is provided, copy fast-math-flags from that instruction to
/// the intrinsic.
CallInst *CreateIntrinsic(Type *RetTy, Intrinsic::ID ID,
                          ArrayRef<Value *> Args,
                          Instruction *FMFSource = nullptr,
                          const Twine &Name = "");

/// Create call to the minnum intrinsic.
CallInst *CreateMinNum(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateBinaryIntrinsic(Intrinsic::minnum, LHS, RHS, nullptr, Name);
}

/// Create call to the maxnum intrinsic.
CallInst *CreateMaxNum(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateBinaryIntrinsic(Intrinsic::maxnum, LHS, RHS, nullptr, Name);
}

/// Create call to the minimum intrinsic.
CallInst *CreateMinimum(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateBinaryIntrinsic(Intrinsic::minimum, LHS, RHS, nullptr, Name);
}

/// Create call to the maximum intrinsic.
CallInst *CreateMaximum(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateBinaryIntrinsic(Intrinsic::maximum, LHS, RHS, nullptr, Name);
}

/// Create a call to the arithmetic_fence intrinsic.
CallInst *CreateArithmeticFence(Value *Val, Type *DstType,
                                const Twine &Name = "") {
  return CreateIntrinsic(Intrinsic::arithmetic_fence, DstType, Val, nullptr,
                         Name);
}

/// Create a call to the vector.extract intrinsic.
CallInst *CreateExtractVector(Type *DstType, Value *SrcVec, Value *Idx,
                              const Twine &Name = "") {
  return CreateIntrinsic(Intrinsic::vector_extract,
                         {DstType, SrcVec->getType()}, {SrcVec, Idx}, nullptr,
                         Name);
}

/// Create a call to the vector.insert intrinsic.
CallInst *CreateInsertVector(Type *DstType, Value *SrcVec, Value *SubVec,
                             Value *Idx, const Twine &Name = "") {
  return CreateIntrinsic(Intrinsic::vector_insert,
                         {DstType, SubVec->getType()}, {SrcVec, SubVec, Idx},
                         nullptr, Name);
}

966private:
/// Create a call to a masked intrinsic with given Id.
CallInst *CreateMaskedIntrinsic(Intrinsic::ID Id, ArrayRef<Value *> Ops,
                                ArrayRef<Type *> OverloadedTypes,
                                const Twine &Name = "");

Value *getCastedInt8PtrValue(Value *Ptr);

//===--------------------------------------------------------------------===//
// Instruction creation methods: Terminators
//===--------------------------------------------------------------------===//

978private:
/// Helper to add branch weight and unpredictable metadata onto an
/// instruction.
/// \returns The annotated instruction.
template <typename InstTy>
InstTy *addBranchMetadata(InstTy *I, MDNode *Weights, MDNode *Unpredictable) {
  if (Weights)
    I->setMetadata(LLVMContext::MD_prof, Weights);
  if (Unpredictable)
    I->setMetadata(LLVMContext::MD_unpredictable, Unpredictable);
  return I;
}

991public:
/// Create a 'ret void' instruction.
ReturnInst *CreateRetVoid() {
  return Insert(ReturnInst::Create(Context));
}

/// Create a 'ret <val>' instruction.
ReturnInst *CreateRet(Value *V) {
  return Insert(ReturnInst::Create(Context, V));
}

/// Create a sequence of N insertvalue instructions,
/// with one Value from the retVals array each, that build a aggregate
/// return value one value at a time, and a ret instruction to return
/// the resulting aggregate value.
///
/// This is a convenience function for code that uses aggregate return values
/// as a vehicle for having multiple return values.
ReturnInst *CreateAggregateRet(Value *const *retVals, unsigned N) {
  Value *V = PoisonValue::get(getCurrentFunctionReturnType());
  for (unsigned i = 0; i != N; ++i)
    V = CreateInsertValue(V, retVals[i], i, "mrv");
  return Insert(ReturnInst::Create(Context, V));
}

/// Create an unconditional 'br label X' instruction.
BranchInst *CreateBr(BasicBlock *Dest) {
  return Insert(BranchInst::Create(Dest));
}

/// Create a conditional 'br Cond, TrueDest, FalseDest'
/// instruction.
BranchInst *CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False,
                         MDNode *BranchWeights = nullptr,
                         MDNode *Unpredictable = nullptr) {
  return Insert(addBranchMetadata(BranchInst::Create(True, False, Cond),
                                  BranchWeights, Unpredictable));
}

/// Create a conditional 'br Cond, TrueDest, FalseDest'
/// instruction. Copy branch meta data if available.
BranchInst *CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False,
                         Instruction *MDSrc) {
  BranchInst *Br = BranchInst::Create(True, False, Cond);
  if (MDSrc) {
    unsigned WL[4] = {LLVMContext::MD_prof, LLVMContext::MD_unpredictable,
                      LLVMContext::MD_make_implicit, LLVMContext::MD_dbg};
    Br->copyMetadata(*MDSrc, makeArrayRef(&WL[0], 4));
  }
  return Insert(Br);
}

/// Create a switch instruction with the specified value, default dest,
/// and with a hint for the number of cases that will be added (for efficient
/// allocation).
SwitchInst *CreateSwitch(Value *V, BasicBlock *Dest, unsigned NumCases = 10,
                         MDNode *BranchWeights = nullptr,
                         MDNode *Unpredictable = nullptr) {
  return Insert(addBranchMetadata(SwitchInst::Create(V, Dest, NumCases),
                                  BranchWeights, Unpredictable));
}

/// Create an indirect branch instruction with the specified address
/// operand, with an optional hint for the number of destinations that will be
/// added (for efficient allocation).
IndirectBrInst *CreateIndirectBr(Value *Addr, unsigned NumDests = 10) {
  return Insert(IndirectBrInst::Create(Addr, NumDests));
}

/// Create an invoke instruction.
InvokeInst *CreateInvoke(FunctionType *Ty, Value *Callee,
                         BasicBlock *NormalDest, BasicBlock *UnwindDest,
                         ArrayRef<Value *> Args,
                         ArrayRef<OperandBundleDef> OpBundles,
                         const Twine &Name = "") {
  InvokeInst *II =
      InvokeInst::Create(Ty, Callee, NormalDest, UnwindDest, Args, OpBundles);
  if (IsFPConstrained)
    setConstrainedFPCallAttr(II);
  return Insert(II, Name);
}
InvokeInst *CreateInvoke(FunctionType *Ty, Value *Callee,
                         BasicBlock *NormalDest, BasicBlock *UnwindDest,
                         ArrayRef<Value *> Args = None,
                         const Twine &Name = "") {
  InvokeInst *II =
      InvokeInst::Create(Ty, Callee, NormalDest, UnwindDest, Args);
  if (IsFPConstrained)
    setConstrainedFPCallAttr(II);
  return Insert(II, Name);
}

InvokeInst *CreateInvoke(FunctionCallee Callee, BasicBlock *NormalDest,
                         BasicBlock *UnwindDest, ArrayRef<Value *> Args,
                         ArrayRef<OperandBundleDef> OpBundles,
                         const Twine &Name = "") {
  return CreateInvoke(Callee.getFunctionType(), Callee.getCallee(),
                      NormalDest, UnwindDest, Args, OpBundles, Name);
}

InvokeInst *CreateInvoke(FunctionCallee Callee, BasicBlock *NormalDest,
                         BasicBlock *UnwindDest,
                         ArrayRef<Value *> Args = None,
                         const Twine &Name = "") {
  return CreateInvoke(Callee.getFunctionType(), Callee.getCallee(),
                      NormalDest, UnwindDest, Args, Name);
}

/// \brief Create a callbr instruction.
CallBrInst *CreateCallBr(FunctionType *Ty, Value *Callee,
                         BasicBlock *DefaultDest,
                         ArrayRef<BasicBlock *> IndirectDests,
                         ArrayRef<Value *> Args = None,
                         const Twine &Name = "") {
  return Insert(CallBrInst::Create(Ty, Callee, DefaultDest, IndirectDests,
                                   Args), Name);
}
CallBrInst *CreateCallBr(FunctionType *Ty, Value *Callee,
                         BasicBlock *DefaultDest,
                         ArrayRef<BasicBlock *> IndirectDests,
                         ArrayRef<Value *> Args,
                         ArrayRef<OperandBundleDef> OpBundles,
                         const Twine &Name = "") {
  return Insert(
      CallBrInst::Create(Ty, Callee, DefaultDest, IndirectDests, Args,
                         OpBundles), Name);
}

CallBrInst *CreateCallBr(FunctionCallee Callee, BasicBlock *DefaultDest,
                         ArrayRef<BasicBlock *> IndirectDests,
                         ArrayRef<Value *> Args = None,
                         const Twine &Name = "") {
  return CreateCallBr(Callee.getFunctionType(), Callee.getCallee(),
                      DefaultDest, IndirectDests, Args, Name);
}
CallBrInst *CreateCallBr(FunctionCallee Callee, BasicBlock *DefaultDest,
                         ArrayRef<BasicBlock *> IndirectDests,
                         ArrayRef<Value *> Args,
                         ArrayRef<OperandBundleDef> OpBundles,
                         const Twine &Name = "") {
  return CreateCallBr(Callee.getFunctionType(), Callee.getCallee(),
                      DefaultDest, IndirectDests, Args, Name);
}

ResumeInst *CreateResume(Value *Exn) {
  return Insert(ResumeInst::Create(Exn));
}

CleanupReturnInst *CreateCleanupRet(CleanupPadInst *CleanupPad,
                                    BasicBlock *UnwindBB = nullptr) {
  return Insert(CleanupReturnInst::Create(CleanupPad, UnwindBB));
}

CatchSwitchInst *CreateCatchSwitch(Value *ParentPad, BasicBlock *UnwindBB,
                                   unsigned NumHandlers,
                                   const Twine &Name = "") {
  return Insert(CatchSwitchInst::Create(ParentPad, UnwindBB, NumHandlers),
                Name);
}

CatchPadInst *CreateCatchPad(Value *ParentPad, ArrayRef<Value *> Args,
                             const Twine &Name = "") {
  return Insert(CatchPadInst::Create(ParentPad, Args), Name);
}

CleanupPadInst *CreateCleanupPad(Value *ParentPad,
                                 ArrayRef<Value *> Args = None,
                                 const Twine &Name = "") {
  return Insert(CleanupPadInst::Create(ParentPad, Args), Name);
}

CatchReturnInst *CreateCatchRet(CatchPadInst *CatchPad, BasicBlock *BB) {
  return Insert(CatchReturnInst::Create(CatchPad, BB));
}

UnreachableInst *CreateUnreachable() {
  return Insert(new UnreachableInst(Context));
}

//===--------------------------------------------------------------------===//
// Instruction creation methods: Binary Operators
//===--------------------------------------------------------------------===//
1173private:
BinaryOperator *CreateInsertNUWNSWBinOp(BinaryOperator::BinaryOps Opc,
                                        Value *LHS, Value *RHS,
                                        const Twine &Name,
                                        bool HasNUW, bool HasNSW) {
  BinaryOperator *BO = Insert(BinaryOperator::Create(Opc, LHS, RHS), Name);
  if (HasNUW) BO->setHasNoUnsignedWrap();
  if (HasNSW) BO->setHasNoSignedWrap();
  return BO;
}

Instruction *setFPAttrs(Instruction *I, MDNode *FPMD,
                        FastMathFlags FMF) const {
  if (!FPMD)
    FPMD = DefaultFPMathTag;
  if (FPMD)
    I->setMetadata(LLVMContext::MD_fpmath, FPMD);
  I->setFastMathFlags(FMF);
  return I;
}

Value *getConstrainedFPRounding(Optional<RoundingMode> Rounding) {
  RoundingMode UseRounding = DefaultConstrainedRounding;

  if (Rounding)
    UseRounding = Rounding.value();

  Optional<StringRef> RoundingStr = convertRoundingModeToStr(UseRounding);
  assert(RoundingStr && "Garbage strict rounding mode!")(static_cast <bool> (RoundingStr && "Garbage strict rounding mode!"
) ? void (0) : __assert_fail ("RoundingStr && \"Garbage strict rounding mode!\""
, "llvm/include/llvm/IR/IRBuilder.h", 1201, __extension__ __PRETTY_FUNCTION__
));
  auto *RoundingMDS = MDString::get(Context, RoundingStr.value());

  return MetadataAsValue::get(Context, RoundingMDS);
}

Value *getConstrainedFPExcept(Optional<fp::ExceptionBehavior> Except) {
  fp::ExceptionBehavior UseExcept = DefaultConstrainedExcept;

  if (Except)
    UseExcept = Except.value();

  Optional<StringRef> ExceptStr = convertExceptionBehaviorToStr(UseExcept);
  assert(ExceptStr && "Garbage strict exception behavior!")(static_cast <bool> (ExceptStr && "Garbage strict exception behavior!"
) ? void (0) : __assert_fail ("ExceptStr && \"Garbage strict exception behavior!\""
, "llvm/include/llvm/IR/IRBuilder.h", 1214, __extension__ __PRETTY_FUNCTION__
));
  auto *ExceptMDS = MDString::get(Context, ExceptStr.value());

  return MetadataAsValue::get(Context, ExceptMDS);
}

Value *getConstrainedFPPredicate(CmpInst::Predicate Predicate) {
  assert(CmpInst::isFPPredicate(Predicate) &&(static_cast <bool> (CmpInst::isFPPredicate(Predicate) &&
 Predicate != CmpInst::FCMP_FALSE && Predicate != CmpInst
::FCMP_TRUE && "Invalid constrained FP comparison predicate!"
) ? void (0) : __assert_fail ("CmpInst::isFPPredicate(Predicate) && Predicate != CmpInst::FCMP_FALSE && Predicate != CmpInst::FCMP_TRUE && \"Invalid constrained FP comparison predicate!\""
, "llvm/include/llvm/IR/IRBuilder.h", 1224, __extension__ __PRETTY_FUNCTION__
))
         Predicate != CmpInst::FCMP_FALSE &&(static_cast <bool> (CmpInst::isFPPredicate(Predicate) &&
 Predicate != CmpInst::FCMP_FALSE && Predicate != CmpInst
::FCMP_TRUE && "Invalid constrained FP comparison predicate!"
) ? void (0) : __assert_fail ("CmpInst::isFPPredicate(Predicate) && Predicate != CmpInst::FCMP_FALSE && Predicate != CmpInst::FCMP_TRUE && \"Invalid constrained FP comparison predicate!\""
, "llvm/include/llvm/IR/IRBuilder.h", 1224, __extension__ __PRETTY_FUNCTION__
))
         Predicate != CmpInst::FCMP_TRUE &&(static_cast <bool> (CmpInst::isFPPredicate(Predicate) &&
 Predicate != CmpInst::FCMP_FALSE && Predicate != CmpInst
::FCMP_TRUE && "Invalid constrained FP comparison predicate!"
) ? void (0) : __assert_fail ("CmpInst::isFPPredicate(Predicate) && Predicate != CmpInst::FCMP_FALSE && Predicate != CmpInst::FCMP_TRUE && \"Invalid constrained FP comparison predicate!\""
, "llvm/include/llvm/IR/IRBuilder.h", 1224, __extension__ __PRETTY_FUNCTION__
))
         "Invalid constrained FP comparison predicate!")(static_cast <bool> (CmpInst::isFPPredicate(Predicate) &&
 Predicate != CmpInst::FCMP_FALSE && Predicate != CmpInst
::FCMP_TRUE && "Invalid constrained FP comparison predicate!"
) ? void (0) : __assert_fail ("CmpInst::isFPPredicate(Predicate) && Predicate != CmpInst::FCMP_FALSE && Predicate != CmpInst::FCMP_TRUE && \"Invalid constrained FP comparison predicate!\""
, "llvm/include/llvm/IR/IRBuilder.h", 1224, __extension__ __PRETTY_FUNCTION__
));

  StringRef PredicateStr = CmpInst::getPredicateName(Predicate);
  auto *PredicateMDS = MDString::get(Context, PredicateStr);

  return MetadataAsValue::get(Context, PredicateMDS);
}

1232public:
Value *CreateAdd(Value *LHS, Value *RHS, const Twine &Name = "",
                 bool HasNUW = false, bool HasNSW = false) {
  if (Value *V =
          Folder.FoldNoWrapBinOp(Instruction::Add, LHS, RHS, HasNUW, HasNSW))
    return V;
  return CreateInsertNUWNSWBinOp(Instruction::Add, LHS, RHS, Name, HasNUW,
                                 HasNSW);
}

Value *CreateNSWAdd(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateAdd(LHS, RHS, Name, false, true);
}

Value *CreateNUWAdd(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateAdd(LHS, RHS, Name, true, false);
}

Value *CreateSub(Value *LHS, Value *RHS, const Twine &Name = "",
                 bool HasNUW = false, bool HasNSW = false) {
  if (Value *V =
          Folder.FoldNoWrapBinOp(Instruction::Sub, LHS, RHS, HasNUW, HasNSW))
    return V;
  return CreateInsertNUWNSWBinOp(Instruction::Sub, LHS, RHS, Name, HasNUW,
                                 HasNSW);
}

Value *CreateNSWSub(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateSub(LHS, RHS, Name, false, true);
}

Value *CreateNUWSub(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateSub(LHS, RHS, Name, true, false);
}

Value *CreateMul(Value *LHS, Value *RHS, const Twine &Name = "",
                 bool HasNUW = false, bool HasNSW = false) {
  if (Value *V =
          Folder.FoldNoWrapBinOp(Instruction::Mul, LHS, RHS, HasNUW, HasNSW))
    return V;
  return CreateInsertNUWNSWBinOp(Instruction::Mul, LHS, RHS, Name, HasNUW,
                                 HasNSW);
}

Value *CreateNSWMul(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateMul(LHS, RHS, Name, false, true);
}

Value *CreateNUWMul(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateMul(LHS, RHS, Name, true, false);
}

Value *CreateUDiv(Value *LHS, Value *RHS, const Twine &Name = "",
                  bool isExact = false) {
  if (Value *V = Folder.FoldExactBinOp(Instruction::UDiv, LHS, RHS, isExact))
    return V;
  if (!isExact)
    return Insert(BinaryOperator::CreateUDiv(LHS, RHS), Name);
  return Insert(BinaryOperator::CreateExactUDiv(LHS, RHS), Name);
}

Value *CreateExactUDiv(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateUDiv(LHS, RHS, Name, true);
}

Value *CreateSDiv(Value *LHS, Value *RHS, const Twine &Name = "",
                  bool isExact = false) {
  if (Value *V = Folder.FoldExactBinOp(Instruction::SDiv, LHS, RHS, isExact))
    return V;
  if (!isExact)
    return Insert(BinaryOperator::CreateSDiv(LHS, RHS), Name);
  return Insert(BinaryOperator::CreateExactSDiv(LHS, RHS), Name);
}

Value *CreateExactSDiv(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateSDiv(LHS, RHS, Name, true);
}

Value *CreateURem(Value *LHS, Value *RHS, const Twine &Name = "") {
  if (Value *V = Folder.FoldBinOp(Instruction::URem, LHS, RHS))
    return V;
  return Insert(BinaryOperator::CreateURem(LHS, RHS), Name);
}

Value *CreateSRem(Value *LHS, Value *RHS, const Twine &Name = "") {
  if (Value *V = Folder.FoldBinOp(Instruction::SRem, LHS, RHS))
    return V;
  return Insert(BinaryOperator::CreateSRem(LHS, RHS), Name);
}

Value *CreateShl(Value *LHS, Value *RHS, const Twine &Name = "",
                 bool HasNUW = false, bool HasNSW = false) {
  if (Value *V =
          Folder.FoldNoWrapBinOp(Instruction::Shl, LHS, RHS, HasNUW, HasNSW))
    return V;
  return CreateInsertNUWNSWBinOp(Instruction::Shl, LHS, RHS, Name,
                                 HasNUW, HasNSW);
}

Value *CreateShl(Value *LHS, const APInt &RHS, const Twine &Name = "",
                 bool HasNUW = false, bool HasNSW = false) {
  return CreateShl(LHS, ConstantInt::get(LHS->getType(), RHS), Name,
                   HasNUW, HasNSW);
}

Value *CreateShl(Value *LHS, uint64_t RHS, const Twine &Name = "",
                 bool HasNUW = false, bool HasNSW = false) {
  return CreateShl(LHS, ConstantInt::get(LHS->getType(), RHS), Name,
                   HasNUW, HasNSW);
}

Value *CreateLShr(Value *LHS, Value *RHS, const Twine &Name = "",
                  bool isExact = false) {
  if (Value *V = Folder.FoldExactBinOp(Instruction::LShr, LHS, RHS, isExact))
    return V;
  if (!isExact)
    return Insert(BinaryOperator::CreateLShr(LHS, RHS), Name);
  return Insert(BinaryOperator::CreateExactLShr(LHS, RHS), Name);
}

Value *CreateLShr(Value *LHS, const APInt &RHS, const Twine &Name = "",
                  bool isExact = false) {
  return CreateLShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
}

Value *CreateLShr(Value *LHS, uint64_t RHS, const Twine &Name = "",
                  bool isExact = false) {
  return CreateLShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
}

Value *CreateAShr(Value *LHS, Value *RHS, const Twine &Name = "",
                  bool isExact = false) {
  if (Value *V = Folder.FoldExactBinOp(Instruction::AShr, LHS, RHS, isExact))
    return V;
  if (!isExact)
    return Insert(BinaryOperator::CreateAShr(LHS, RHS), Name);
  return Insert(BinaryOperator::CreateExactAShr(LHS, RHS), Name);
}

Value *CreateAShr(Value *LHS, const APInt &RHS, const Twine &Name = "",
                  bool isExact = false) {
  return CreateAShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
}

Value *CreateAShr(Value *LHS, uint64_t RHS, const Twine &Name = "",
                  bool isExact = false) {
  return CreateAShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
}

Value *CreateAnd(Value *LHS, Value *RHS, const Twine &Name = "") {
  if (auto *V = Folder.FoldBinOp(Instruction::And, LHS, RHS))
    return V;
  return Insert(BinaryOperator::CreateAnd(LHS, RHS), Name);
}

Value *CreateAnd(Value *LHS, const APInt &RHS, const Twine &Name = "") {
  return CreateAnd(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
}

Value *CreateAnd(Value *LHS, uint64_t RHS, const Twine &Name = "") {
  return CreateAnd(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
}

Value *CreateAnd(ArrayRef<Value*> Ops) {
  assert(!Ops.empty())(static_cast <bool> (!Ops.empty()) ? void (0) : __assert_fail
 ("!Ops.empty()", "llvm/include/llvm/IR/IRBuilder.h", 1396, __extension__
 __PRETTY_FUNCTION__));
  Value *Accum = Ops[0];
  for (unsigned i = 1; i < Ops.size(); i++)
    Accum = CreateAnd(Accum, Ops[i]);
  return Accum;
}

Value *CreateOr(Value *LHS, Value *RHS, const Twine &Name = "") {
  if (auto *V = Folder.FoldBinOp(Instruction::Or, LHS, RHS))
    return V;
  return Insert(BinaryOperator::CreateOr(LHS, RHS), Name);
}

Value *CreateOr(Value *LHS, const APInt &RHS, const Twine &Name = "") {
  return CreateOr(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
}

Value *CreateOr(Value *LHS, uint64_t RHS, const Twine &Name = "") {
  return CreateOr(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
}

Value *CreateOr(ArrayRef<Value*> Ops) {
  assert(!Ops.empty())(static_cast <bool> (!Ops.empty()) ? void (0) : __assert_fail
 ("!Ops.empty()", "llvm/include/llvm/IR/IRBuilder.h", 1418, __extension__
 __PRETTY_FUNCTION__));
  Value *Accum = Ops[0];
  for (unsigned i = 1; i < Ops.size(); i++)
    Accum = CreateOr(Accum, Ops[i]);
  return Accum;
}

Value *CreateXor(Value *LHS, Value *RHS, const Twine &Name = "") {
  if (Value *V = Folder.FoldBinOp(Instruction::Xor, LHS, RHS))
    return V;
  return Insert(BinaryOperator::CreateXor(LHS, RHS), Name);
}

Value *CreateXor(Value *LHS, const APInt &RHS, const Twine &Name = "") {
  return CreateXor(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
}

Value *CreateXor(Value *LHS, uint64_t RHS, const Twine &Name = "") {
  return CreateXor(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
}

Value *CreateFAdd(Value *L, Value *R, const Twine &Name = "",
                  MDNode *FPMD = nullptr) {
  if (IsFPConstrained)
    return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fadd,
                                    L, R, nullptr, Name, FPMD);

  if (Value *V = Folder.FoldBinOpFMF(Instruction::FAdd, L, R, FMF))
    return V;
  Instruction *I = setFPAttrs(BinaryOperator::CreateFAdd(L, R), FPMD, FMF);
  return Insert(I, Name);
}

/// Copy fast-math-flags from an instruction rather than using the builder's
/// default FMF.
Value *CreateFAddFMF(Value *L, Value *R, Instruction *FMFSource,
                     const Twine &Name = "") {
  if (IsFPConstrained)
    return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fadd,
                                    L, R, FMFSource, Name);

  FastMathFlags FMF = FMFSource->getFastMathFlags();
  if (Value *V = Folder.FoldBinOpFMF(Instruction::FAdd, L, R, FMF))
    return V;
  Instruction *I = setFPAttrs(BinaryOperator::CreateFAdd(L, R), nullptr, FMF);
  return Insert(I, Name);
}

Value *CreateFSub(Value *L, Value *R, const Twine &Name = "",
                  MDNode *FPMD = nullptr) {
  if (IsFPConstrained)
    return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fsub,
                                    L, R, nullptr, Name, FPMD);

  if (Value *V = Folder.FoldBinOpFMF(Instruction::FSub, L, R, FMF))
    return V;
  Instruction *I = setFPAttrs(BinaryOperator::CreateFSub(L, R), FPMD, FMF);
  return Insert(I, Name);
}

/// Copy fast-math-flags from an instruction rather than using the builder's
/// default FMF.
Value *CreateFSubFMF(Value *L, Value *R, Instruction *FMFSource,
                     const Twine &Name = "") {
  if (IsFPConstrained)
    return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fsub,
                                    L, R, FMFSource, Name);

  FastMathFlags FMF = FMFSource->getFastMathFlags();
  if (Value *V = Folder.FoldBinOpFMF(Instruction::FSub, L, R, FMF))
    return V;
  Instruction *I = setFPAttrs(BinaryOperator::CreateFSub(L, R), nullptr, FMF);
  return Insert(I, Name);
}

Value *CreateFMul(Value *L, Value *R, const Twine &Name = "",
                  MDNode *FPMD = nullptr) {
  if (IsFPConstrained)
    return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fmul,
                                    L, R, nullptr, Name, FPMD);

  if (Value *V = Folder.FoldBinOpFMF(Instruction::FMul, L, R, FMF))
    return V;
  Instruction *I = setFPAttrs(BinaryOperator::CreateFMul(L, R), FPMD, FMF);
  return Insert(I, Name);
}

/// Copy fast-math-flags from an instruction rather than using the builder's
/// default FMF.
Value *CreateFMulFMF(Value *L, Value *R, Instruction *FMFSource,
                     const Twine &Name = "") {
  if (IsFPConstrained)
    return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fmul,
                                    L, R, FMFSource, Name);

  FastMathFlags FMF = FMFSource->getFastMathFlags();
  if (Value *V = Folder.FoldBinOpFMF(Instruction::FMul, L, R, FMF))
    return V;
  Instruction *I = setFPAttrs(BinaryOperator::CreateFMul(L, R), nullptr, FMF);
  return Insert(I, Name);
}

Value *CreateFDiv(Value *L, Value *R, const Twine &Name = "",
                  MDNode *FPMD = nullptr) {
  if (IsFPConstrained)
    return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fdiv,
                                    L, R, nullptr, Name, FPMD);

  if (Value *V = Folder.FoldBinOpFMF(Instruction::FDiv, L, R, FMF))
    return V;
  Instruction *I = setFPAttrs(BinaryOperator::CreateFDiv(L, R), FPMD, FMF);
  return Insert(I, Name);
}

/// Copy fast-math-flags from an instruction rather than using the builder's
/// default FMF.
Value *CreateFDivFMF(Value *L, Value *R, Instruction *FMFSource,
                     const Twine &Name = "") {
  if (IsFPConstrained)
    return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fdiv,
                                    L, R, FMFSource, Name);

  if (Value *V = Folder.FoldBinOpFMF(Instruction::FDiv, L, R, FMF))
    return V;
  Instruction *I = setFPAttrs(BinaryOperator::CreateFDiv(L, R), nullptr, FMF);
  return Insert(I, Name);
}

Value *CreateFRem(Value *L, Value *R, const Twine &Name = "",
                  MDNode *FPMD = nullptr) {
  if (IsFPConstrained)
    return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_frem,
                                    L, R, nullptr, Name, FPMD);

  if (Value *V = Folder.FoldBinOpFMF(Instruction::FRem, L, R, FMF)) return V;
  Instruction *I = setFPAttrs(BinaryOperator::CreateFRem(L, R), FPMD, FMF);
  return Insert(I, Name);
}

/// Copy fast-math-flags from an instruction rather than using the builder's
/// default FMF.
Value *CreateFRemFMF(Value *L, Value *R, Instruction *FMFSource,
                     const Twine &Name = "") {
  if (IsFPConstrained)
    return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_frem,
                                    L, R, FMFSource, Name);

  FastMathFlags FMF = FMFSource->getFastMathFlags();
  if (Value *V = Folder.FoldBinOpFMF(Instruction::FRem, L, R, FMF)) return V;
  Instruction *I = setFPAttrs(BinaryOperator::CreateFRem(L, R), nullptr, FMF);
  return Insert(I, Name);
}

Value *CreateBinOp(Instruction::BinaryOps Opc,
                   Value *LHS, Value *RHS, const Twine &Name = "",
                   MDNode *FPMathTag = nullptr) {
  if (Value *V = Folder.FoldBinOp(Opc, LHS, RHS)) return V;
  Instruction *BinOp = BinaryOperator::Create(Opc, LHS, RHS);
  if (isa<FPMathOperator>(BinOp))
    setFPAttrs(BinOp, FPMathTag, FMF);
  return Insert(BinOp, Name);
}

Value *CreateLogicalAnd(Value *Cond1, Value *Cond2, const Twine &Name = "") {
  assert(Cond2->getType()->isIntOrIntVectorTy(1))(static_cast <bool> (Cond2->getType()->isIntOrIntVectorTy
(1)) ? void (0) : __assert_fail ("Cond2->getType()->isIntOrIntVectorTy(1)"
, "llvm/include/llvm/IR/IRBuilder.h", 1582, __extension__ __PRETTY_FUNCTION__
));
  return CreateSelect(Cond1, Cond2,
                      ConstantInt::getNullValue(Cond2->getType()), Name);
}

Value *CreateLogicalOr(Value *Cond1, Value *Cond2, const Twine &Name = "") {
  assert(Cond2->getType()->isIntOrIntVectorTy(1))(static_cast <bool> (Cond2->getType()->isIntOrIntVectorTy
(1)) ? void (0) : __assert_fail ("Cond2->getType()->isIntOrIntVectorTy(1)"
, "llvm/include/llvm/IR/IRBuilder.h", 1588, __extension__ __PRETTY_FUNCTION__
));
  return CreateSelect(Cond1, ConstantInt::getAllOnesValue(Cond2->getType()),
                      Cond2, Name);
}

// NOTE: this is sequential, non-commutative, ordered reduction!
Value *CreateLogicalOr(ArrayRef<Value *> Ops) {
  assert(!Ops.empty())(static_cast <bool> (!Ops.empty()) ? void (0) : __assert_fail
 ("!Ops.empty()", "llvm/include/llvm/IR/IRBuilder.h", 1595, __extension__
 __PRETTY_FUNCTION__));
  Value *Accum = Ops[0];
  for (unsigned i = 1; i < Ops.size(); i++)
    Accum = CreateLogicalOr(Accum, Ops[i]);
  return Accum;
}

CallInst *CreateConstrainedFPBinOp(
    Intrinsic::ID ID, Value *L, Value *R, Instruction *FMFSource = nullptr,
    const Twine &Name = "", MDNode *FPMathTag = nullptr,
    Optional<RoundingMode> Rounding = None,
    Optional<fp::ExceptionBehavior> Except = None);

Value *CreateNeg(Value *V, const Twine &Name = "", bool HasNUW = false,
                 bool HasNSW = false) {
  return CreateSub(Constant::getNullValue(V->getType()), V, Name, HasNUW,
                   HasNSW);
}

Value *CreateNSWNeg(Value *V, const Twine &Name = "") {
  return CreateNeg(V, Name, false, true);
}

Value *CreateNUWNeg(Value *V, const Twine &Name = "") {
  return CreateNeg(V, Name, true, false);
}

Value *CreateFNeg(Value *V, const Twine &Name = "",
                  MDNode *FPMathTag = nullptr) {
  if (Value *Res = Folder.FoldUnOpFMF(Instruction::FNeg, V, FMF))
    return Res;
  return Insert(setFPAttrs(UnaryOperator::CreateFNeg(V), FPMathTag, FMF),
                Name);
}

/// Copy fast-math-flags from an instruction rather than using the builder's
/// default FMF.
Value *CreateFNegFMF(Value *V, Instruction *FMFSource,
                     const Twine &Name = "") {
 FastMathFlags FMF = FMFSource->getFastMathFlags();
  if (Value *Res = Folder.FoldUnOpFMF(Instruction::FNeg, V, FMF))
    return Res;
 return Insert(setFPAttrs(UnaryOperator::CreateFNeg(V), nullptr, FMF),
               Name);
}

Value *CreateNot(Value *V, const Twine &Name = "") {
  return CreateXor(V, Constant::getAllOnesValue(V->getType()), Name);
}

Value *CreateUnOp(Instruction::UnaryOps Opc,
                  Value *V, const Twine &Name = "",
                  MDNode *FPMathTag = nullptr) {
  if (Value *Res = Folder.FoldUnOpFMF(Opc, V, FMF))
    return Res;
  Instruction *UnOp = UnaryOperator::Create(Opc, V);
  if (isa<FPMathOperator>(UnOp))
    setFPAttrs(UnOp, FPMathTag, FMF);
  return Insert(UnOp, Name);
}

/// Create either a UnaryOperator or BinaryOperator depending on \p Opc.
/// Correct number of operands must be passed accordingly.
Value *CreateNAryOp(unsigned Opc, ArrayRef<Value *> Ops,
                    const Twine &Name = "", MDNode *FPMathTag = nullptr);

//===--------------------------------------------------------------------===//
// Instruction creation methods: Memory Instructions
//===--------------------------------------------------------------------===//

AllocaInst *CreateAlloca(Type *Ty, unsigned AddrSpace,
                         Value *ArraySize = nullptr, const Twine &Name = "") {
  const DataLayout &DL = BB->getModule()->getDataLayout();
  Align AllocaAlign = DL.getPrefTypeAlign(Ty);
  return Insert(new AllocaInst(Ty, AddrSpace, ArraySize, AllocaAlign), Name);
}

AllocaInst *CreateAlloca(Type *Ty, Value *ArraySize = nullptr,
                         const Twine &Name = "") {
  const DataLayout &DL = BB->getModule()->getDataLayout();
  Align AllocaAlign = DL.getPrefTypeAlign(Ty);
  unsigned AddrSpace = DL.getAllocaAddrSpace();
  return Insert(new AllocaInst(Ty, AddrSpace, ArraySize, AllocaAlign), Name);
}

/// Provided to resolve 'CreateLoad(Ty, Ptr, "...")' correctly, instead of
/// converting the string to 'bool' for the isVolatile parameter.
LoadInst *CreateLoad(Type *Ty, Value *Ptr, const char *Name) {
  return CreateAlignedLoad(Ty, Ptr, MaybeAlign(), Name);
}

LoadInst *CreateLoad(Type *Ty, Value *Ptr, const Twine &Name = "") {
  return CreateAlignedLoad(Ty, Ptr, MaybeAlign(), Name);
}

LoadInst *CreateLoad(Type *Ty, Value *Ptr, bool isVolatile,
                     const Twine &Name = "") {
  return CreateAlignedLoad(Ty, Ptr, MaybeAlign(), isVolatile, Name);
}

StoreInst *CreateStore(Value *Val, Value *Ptr, bool isVolatile = false) {
  return CreateAlignedStore(Val, Ptr, MaybeAlign(), isVolatile);
}

LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr, MaybeAlign Align,
                            const char *Name) {
  return CreateAlignedLoad(Ty, Ptr, Align, /*isVolatile*/false, Name);
}

LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr, MaybeAlign Align,
                            const Twine &Name = "") {
  return CreateAlignedLoad(Ty, Ptr, Align, /*isVolatile*/false, Name);
}

LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr, MaybeAlign Align,
                            bool isVolatile, const Twine &Name = "") {
  if (!Align) {
    const DataLayout &DL = BB->getModule()->getDataLayout();
    Align = DL.getABITypeAlign(Ty);
  }
  return Insert(new LoadInst(Ty, Ptr, Twine(), isVolatile, *Align), Name);
}

StoreInst *CreateAlignedStore(Value *Val, Value *Ptr, MaybeAlign Align,
                              bool isVolatile = false) {
  if (!Align) {
    const DataLayout &DL = BB->getModule()->getDataLayout();
    Align = DL.getABITypeAlign(Val->getType());
  }
  return Insert(new StoreInst(Val, Ptr, isVolatile, *Align));
}
FenceInst *CreateFence(AtomicOrdering Ordering,
                       SyncScope::ID SSID = SyncScope::System,
                       const Twine &Name = "") {
  return Insert(new FenceInst(Context, Ordering, SSID), Name);
}

AtomicCmpXchgInst *
CreateAtomicCmpXchg(Value *Ptr, Value *Cmp, Value *New, MaybeAlign Align,
                    AtomicOrdering SuccessOrdering,
                    AtomicOrdering FailureOrdering,
                    SyncScope::ID SSID = SyncScope::System) {
  if (!Align) {
    const DataLayout &DL = BB->getModule()->getDataLayout();
    Align = llvm::Align(DL.getTypeStoreSize(New->getType()));
  }

  return Insert(new AtomicCmpXchgInst(Ptr, Cmp, New, *Align, SuccessOrdering,
                                      FailureOrdering, SSID));
}

AtomicRMWInst *CreateAtomicRMW(AtomicRMWInst::BinOp Op, Value *Ptr,
                               Value *Val, MaybeAlign Align,
                               AtomicOrdering Ordering,
                               SyncScope::ID SSID = SyncScope::System) {
  if (!Align) {
    const DataLayout &DL = BB->getModule()->getDataLayout();
    Align = llvm::Align(DL.getTypeStoreSize(Val->getType()));
  }

  return Insert(new AtomicRMWInst(Op, Ptr, Val, *Align, Ordering, SSID));
}

Value *CreateGEP(Type *Ty, Value *Ptr, ArrayRef<Value *> IdxList,
                 const Twine &Name = "", bool IsInBounds = false) {
  if (auto *V = Folder.FoldGEP(Ty, Ptr, IdxList, IsInBounds))
    return V;
  return Insert(IsInBounds
                    ? GetElementPtrInst::CreateInBounds(Ty, Ptr, IdxList)
                    : GetElementPtrInst::Create(Ty, Ptr, IdxList),
                Name);
}

Value *CreateInBoundsGEP(Type *Ty, Value *Ptr, ArrayRef<Value *> IdxList,
                         const Twine &Name = "") {
  return CreateGEP(Ty, Ptr, IdxList, Name, /* IsInBounds */ true);
}

Value *CreateConstGEP1_32(Type *Ty, Value *Ptr, unsigned Idx0,
                          const Twine &Name = "") {
  Value *Idx = ConstantInt::get(Type::getInt32Ty(Context), Idx0);

  if (auto *V = Folder.FoldGEP(Ty, Ptr, Idx, /*IsInBounds=*/false))
    return V;

  return Insert(GetElementPtrInst::Create(Ty, Ptr, Idx), Name);
}

Value *CreateConstInBoundsGEP1_32(Type *Ty, Value *Ptr, unsigned Idx0,
                                  const Twine &Name = "") {
  Value *Idx = ConstantInt::get(Type::getInt32Ty(Context), Idx0);

  if (auto *V = Folder.FoldGEP(Ty, Ptr, Idx, /*IsInBounds=*/true))
    return V;

  return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idx), Name);
}

Value *CreateConstGEP2_32(Type *Ty, Value *Ptr, unsigned Idx0, unsigned Idx1,
                          const Twine &Name = "") {
  Value *Idxs[] = {
    ConstantInt::get(Type::getInt32Ty(Context), Idx0),
    ConstantInt::get(Type::getInt32Ty(Context), Idx1)
  };

  if (auto *V = Folder.FoldGEP(Ty, Ptr, Idxs, /*IsInBounds=*/false))
    return V;

  return Insert(GetElementPtrInst::Create(Ty, Ptr, Idxs), Name);
}

Value *CreateConstInBoundsGEP2_32(Type *Ty, Value *Ptr, unsigned Idx0,
                                  unsigned Idx1, const Twine &Name = "") {
  Value *Idxs[] = {
    ConstantInt::get(Type::getInt32Ty(Context), Idx0),
    ConstantInt::get(Type::getInt32Ty(Context), Idx1)
  };

  if (auto *V = Folder.FoldGEP(Ty, Ptr, Idxs, /*IsInBounds=*/true))
    return V;

  return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idxs), Name);
}

Value *CreateConstGEP1_64(Type *Ty, Value *Ptr, uint64_t Idx0,
                          const Twine &Name = "") {
  Value *Idx = ConstantInt::get(Type::getInt64Ty(Context), Idx0);

  if (auto *V = Folder.FoldGEP(Ty, Ptr, Idx, /*IsInBounds=*/false))
    return V;

  return Insert(GetElementPtrInst::Create(Ty, Ptr, Idx), Name);
}

Value *CreateConstInBoundsGEP1_64(Type *Ty, Value *Ptr, uint64_t Idx0,
                                  const Twine &Name = "") {
  Value *Idx = ConstantInt::get(Type::getInt64Ty(Context), Idx0);

  if (auto *V = Folder.FoldGEP(Ty, Ptr, Idx, /*IsInBounds=*/true))
    return V;

  return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idx), Name);
}

Value *CreateConstGEP2_64(Type *Ty, Value *Ptr, uint64_t Idx0, uint64_t Idx1,
                          const Twine &Name = "") {
  Value *Idxs[] = {
    ConstantInt::get(Type::getInt64Ty(Context), Idx0),
    ConstantInt::get(Type::getInt64Ty(Context), Idx1)
  };

  if (auto *V = Folder.FoldGEP(Ty, Ptr, Idxs, /*IsInBounds=*/false))
    return V;

  return Insert(GetElementPtrInst::Create(Ty, Ptr, Idxs), Name);
}

Value *CreateConstInBoundsGEP2_64(Type *Ty, Value *Ptr, uint64_t Idx0,
                                  uint64_t Idx1, const Twine &Name = "") {
  Value *Idxs[] = {
    ConstantInt::get(Type::getInt64Ty(Context), Idx0),
    ConstantInt::get(Type::getInt64Ty(Context), Idx1)
  };

  if (auto *V = Folder.FoldGEP(Ty, Ptr, Idxs, /*IsInBounds=*/true))
    return V;

  return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idxs), Name);
}

Value *CreateStructGEP(Type *Ty, Value *Ptr, unsigned Idx,
                       const Twine &Name = "") {
  return CreateConstInBoundsGEP2_32(Ty, Ptr, 0, Idx, Name);
}

/// Same as CreateGlobalString, but return a pointer with "i8*" type
/// instead of a pointer to array of i8.
///
/// If no module is given via \p M, it is take from the insertion point basic
/// block.
Constant *CreateGlobalStringPtr(StringRef Str, const Twine &Name = "",
                                unsigned AddressSpace = 0,
                                Module *M = nullptr) {
  GlobalVariable *GV = CreateGlobalString(Str, Name, AddressSpace, M);
  Constant *Zero = ConstantInt::get(Type::getInt32Ty(Context), 0);
  Constant *Indices[] = {Zero, Zero};
  return ConstantExpr::getInBoundsGetElementPtr(GV->getValueType(), GV,
                                                Indices);
}

//===--------------------------------------------------------------------===//
// Instruction creation methods: Cast/Conversion Operators
//===--------------------------------------------------------------------===//

Value *CreateTrunc(Value *V, Type *DestTy, const Twine &Name = "") {
  return CreateCast(Instruction::Trunc, V, DestTy, Name);
}

Value *CreateZExt(Value *V, Type *DestTy, const Twine &Name = "") {
  return CreateCast(Instruction::ZExt, V, DestTy, Name);
}

Value *CreateSExt(Value *V, Type *DestTy, const Twine &Name = "") {
  return CreateCast(Instruction::SExt, V, DestTy, Name);
}

/// Create a ZExt or Trunc from the integer value V to DestTy. Return
/// the value untouched if the type of V is already DestTy.
Value *CreateZExtOrTrunc(Value *V, Type *DestTy,
                         const Twine &Name = "") {
  assert(V->getType()->isIntOrIntVectorTy() &&(static_cast <bool> (V->getType()->isIntOrIntVectorTy
() && DestTy->isIntOrIntVectorTy() && "Can only zero extend/truncate integers!"
) ? void (0) : __assert_fail ("V->getType()->isIntOrIntVectorTy() && DestTy->isIntOrIntVectorTy() && \"Can only zero extend/truncate integers!\""
, "llvm/include/llvm/IR/IRBuilder.h", 1907, __extension__ __PRETTY_FUNCTION__
))
         DestTy->isIntOrIntVectorTy() &&(static_cast <bool> (V->getType()->isIntOrIntVectorTy
() && DestTy->isIntOrIntVectorTy() && "Can only zero extend/truncate integers!"
) ? void (0) : __assert_fail ("V->getType()->isIntOrIntVectorTy() && DestTy->isIntOrIntVectorTy() && \"Can only zero extend/truncate integers!\""
, "llvm/include/llvm/IR/IRBuilder.h", 1907, __extension__ __PRETTY_FUNCTION__
))
         "Can only zero extend/truncate integers!")(static_cast <bool> (V->getType()->isIntOrIntVectorTy
() && DestTy->isIntOrIntVectorTy() && "Can only zero extend/truncate integers!"
) ? void (0) : __assert_fail ("V->getType()->isIntOrIntVectorTy() && DestTy->isIntOrIntVectorTy() && \"Can only zero extend/truncate integers!\""
, "llvm/include/llvm/IR/IRBuilder.h", 1907, __extension__ __PRETTY_FUNCTION__
));
  Type *VTy = V->getType();
  if (VTy->getScalarSizeInBits() < DestTy->getScalarSizeInBits())
    return CreateZExt(V, DestTy, Name);
  if (VTy->getScalarSizeInBits() > DestTy->getScalarSizeInBits())
    return CreateTrunc(V, DestTy, Name);
  return V;
}

/// Create a SExt or Trunc from the integer value V to DestTy. Return
/// the value untouched if the type of V is already DestTy.
Value *CreateSExtOrTrunc(Value *V, Type *DestTy,
                         const Twine &Name = "") {
  assert(V->getType()->isIntOrIntVectorTy() &&(static_cast <bool> (V->getType()->isIntOrIntVectorTy
() && DestTy->isIntOrIntVectorTy() && "Can only sign extend/truncate integers!"
) ? void (0) : __assert_fail ("V->getType()->isIntOrIntVectorTy() && DestTy->isIntOrIntVectorTy() && \"Can only sign extend/truncate integers!\""
, "llvm/include/llvm/IR/IRBuilder.h", 1922, __extension__ __PRETTY_FUNCTION__
))
         DestTy->isIntOrIntVectorTy() &&(static_cast <bool> (V->getType()->isIntOrIntVectorTy
() && DestTy->isIntOrIntVectorTy() && "Can only sign extend/truncate integers!"
) ? void (0) : __assert_fail ("V->getType()->isIntOrIntVectorTy() && DestTy->isIntOrIntVectorTy() && \"Can only sign extend/truncate integers!\""
, "llvm/include/llvm/IR/IRBuilder.h", 1922, __extension__ __PRETTY_FUNCTION__
))
         "Can only sign extend/truncate integers!")(static_cast <bool> (V->getType()->isIntOrIntVectorTy
() && DestTy->isIntOrIntVectorTy() && "Can only sign extend/truncate integers!"
) ? void (0) : __assert_fail ("V->getType()->isIntOrIntVectorTy() && DestTy->isIntOrIntVectorTy() && \"Can only sign extend/truncate integers!\""
, "llvm/include/llvm/IR/IRBuilder.h", 1922, __extension__ __PRETTY_FUNCTION__
));
  Type *VTy = V->getType();
  if (VTy->getScalarSizeInBits() < DestTy->getScalarSizeInBits())
    return CreateSExt(V, DestTy, Name);
  if (VTy->getScalarSizeInBits() > DestTy->getScalarSizeInBits())
    return CreateTrunc(V, DestTy, Name);
  return V;
}

Value *CreateFPToUI(Value *V, Type *DestTy, const Twine &Name = "") {
  if (IsFPConstrained)
    return CreateConstrainedFPCast(Intrinsic::experimental_constrained_fptoui,
                                   V, DestTy, nullptr, Name);
  return CreateCast(Instruction::FPToUI, V, DestTy, Name);
}

Value *CreateFPToSI(Value *V, Type *DestTy, const Twine &Name = "") {
  if (IsFPConstrained)
    return CreateConstrainedFPCast(Intrinsic::experimental_constrained_fptosi,
                                   V, DestTy, nullptr, Name);
  return CreateCast(Instruction::FPToSI, V, DestTy, Name);
}

Value *CreateUIToFP(Value *V, Type *DestTy, const Twine &Name = ""){
  if (IsFPConstrained)
    return CreateConstrainedFPCast(Intrinsic::experimental_constrained_uitofp,
                                   V, DestTy, nullptr, Name);
  return CreateCast(Instruction::UIToFP, V, DestTy, Name);
}

Value *CreateSIToFP(Value *V, Type *DestTy, const Twine &Name = ""){
  if (IsFPConstrained)
    return CreateConstrainedFPCast(Intrinsic::experimental_constrained_sitofp,
                                   V, DestTy, nullptr, Name);
  return CreateCast(Instruction::SIToFP, V, DestTy, Name);
}

Value *CreateFPTrunc(Value *V, Type *DestTy,
                     const Twine &Name = "") {
  if (IsFPConstrained)
    return CreateConstrainedFPCast(
        Intrinsic::experimental_constrained_fptrunc, V, DestTy, nullptr,
        Name);
  return CreateCast(Instruction::FPTrunc, V, DestTy, Name);
}

Value *CreateFPExt(Value *V, Type *DestTy, const Twine &Name = "") {
  if (IsFPConstrained)
    return CreateConstrainedFPCast(Intrinsic::experimental_constrained_fpext,
                                   V, DestTy, nullptr, Name);
  return CreateCast(Instruction::FPExt, V, DestTy, Name);
}

Value *CreatePtrToInt(Value *V, Type *DestTy,
                      const Twine &Name = "") {
  return CreateCast(Instruction::PtrToInt, V, DestTy, Name);
}

Value *CreateIntToPtr(Value *V, Type *DestTy,
                      const Twine &Name = "") {
  return CreateCast(Instruction::IntToPtr, V, DestTy, Name);
}

Value *CreateBitCast(Value *V, Type *DestTy,
                     const Twine &Name = "") {
  return CreateCast(Instruction::BitCast, V, DestTy, Name);
}

Value *CreateAddrSpaceCast(Value *V, Type *DestTy,
                           const Twine &Name = "") {
  return CreateCast(Instruction::AddrSpaceCast, V, DestTy, Name);
}

Value *CreateZExtOrBitCast(Value *V, Type *DestTy,
                           const Twine &Name = "") {
  if (V->getType() == DestTy)
    return V;
  if (auto *VC = dyn_cast<Constant>(V))
    return Insert(Folder.CreateZExtOrBitCast(VC, DestTy), Name);
  return Insert(CastInst::CreateZExtOrBitCast(V, DestTy), Name);
}

Value *CreateSExtOrBitCast(Value *V, Type *DestTy,
                           const Twine &Name = "") {
  if (V->getType() == DestTy)
    return V;
  if (auto *VC = dyn_cast<Constant>(V))
    return Insert(Folder.CreateSExtOrBitCast(VC, DestTy), Name);
  return Insert(CastInst::CreateSExtOrBitCast(V, DestTy), Name);
}

Value *CreateTruncOrBitCast(Value *V, Type *DestTy,
                            const Twine &Name = "") {
  if (V->getType() == DestTy)
    return V;
  if (auto *VC = dyn_cast<Constant>(V))
    return Insert(Folder.CreateTruncOrBitCast(VC, DestTy), Name);
  return Insert(CastInst::CreateTruncOrBitCast(V, DestTy), Name);
}

Value *CreateCast(Instruction::CastOps Op, Value *V, Type *DestTy,
                  const Twine &Name = "") {
  if (V->getType() == DestTy)
    return V;
  if (auto *VC = dyn_cast<Constant>(V))
    return Insert(Folder.CreateCast(Op, VC, DestTy), Name);
  return Insert(CastInst::Create(Op, V, DestTy), Name);
}

Value *CreatePointerCast(Value *V, Type *DestTy,
                         const Twine &Name = "") {
  if (V->getType() == DestTy)
    return V;
  if (auto *VC = dyn_cast<Constant>(V))
    return Insert(Folder.CreatePointerCast(VC, DestTy), Name);
  return Insert(CastInst::CreatePointerCast(V, DestTy), Name);
}

Value *CreatePointerBitCastOrAddrSpaceCast(Value *V, Type *DestTy,
                                           const Twine &Name = "") {
  if (V->getType() == DestTy)
    return V;

  if (auto *VC = dyn_cast<Constant>(V)) {
    return Insert(Folder.CreatePointerBitCastOrAddrSpaceCast(VC, DestTy),
                  Name);
  }

  return Insert(CastInst::CreatePointerBitCastOrAddrSpaceCast(V, DestTy),
                Name);
}

Value *CreateIntCast(Value *V, Type *DestTy, bool isSigned,
                     const Twine &Name = "") {
  if (V->getType() == DestTy)
    return V;
  if (auto *VC = dyn_cast<Constant>(V))
    return Insert(Folder.CreateIntCast(VC, DestTy, isSigned), Name);
  return Insert(CastInst::CreateIntegerCast(V, DestTy, isSigned), Name);
}

Value *CreateBitOrPointerCast(Value *V, Type *DestTy,
                              const Twine &Name = "") {
  if (V->getType() == DestTy)
    return V;
  if (V->getType()->isPtrOrPtrVectorTy() && DestTy->isIntOrIntVectorTy())
    return CreatePtrToInt(V, DestTy, Name);
  if (V->getType()->isIntOrIntVectorTy() && DestTy->isPtrOrPtrVectorTy())
    return CreateIntToPtr(V, DestTy, Name);

  return CreateBitCast(V, DestTy, Name);
}

Value *CreateFPCast(Value *V, Type *DestTy, const Twine &Name = "") {
  if (V->getType() == DestTy)
    return V;
  if (auto *VC = dyn_cast<Constant>(V))
    return Insert(Folder.CreateFPCast(VC, DestTy), Name);
  return Insert(CastInst::CreateFPCast(V, DestTy), Name);
}

CallInst *CreateConstrainedFPCast(
    Intrinsic::ID ID, Value *V, Type *DestTy,
    Instruction *FMFSource = nullptr, const Twine &Name = "",
    MDNode *FPMathTag = nullptr,
    Optional<RoundingMode> Rounding = None,
    Optional<fp::ExceptionBehavior> Except = None);

// Provided to resolve 'CreateIntCast(Ptr, Ptr, "...")', giving a
// compile time error, instead of converting the string to bool for the
// isSigned parameter.
Value *CreateIntCast(Value *, Type *, const char *) = delete;

//===--------------------------------------------------------------------===//
// Instruction creation methods: Compare Instructions
//===--------------------------------------------------------------------===//

Value *CreateICmpEQ(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateICmp(ICmpInst::ICMP_EQ, LHS, RHS, Name);
}

Value *CreateICmpNE(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateICmp(ICmpInst::ICMP_NE, LHS, RHS, Name);
}

Value *CreateICmpUGT(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateICmp(ICmpInst::ICMP_UGT, LHS, RHS, Name);
}

Value *CreateICmpUGE(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateICmp(ICmpInst::ICMP_UGE, LHS, RHS, Name);
}

Value *CreateICmpULT(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateICmp(ICmpInst::ICMP_ULT, LHS, RHS, Name);
}

Value *CreateICmpULE(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateICmp(ICmpInst::ICMP_ULE, LHS, RHS, Name);
}

Value *CreateICmpSGT(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateICmp(ICmpInst::ICMP_SGT, LHS, RHS, Name);
}

Value *CreateICmpSGE(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateICmp(ICmpInst::ICMP_SGE, LHS, RHS, Name);
}

Value *CreateICmpSLT(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateICmp(ICmpInst::ICMP_SLT, LHS, RHS, Name);
}

Value *CreateICmpSLE(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateICmp(ICmpInst::ICMP_SLE, LHS, RHS, Name);
}

Value *CreateFCmpOEQ(Value *LHS, Value *RHS, const Twine &Name = "",
                     MDNode *FPMathTag = nullptr) {
  return CreateFCmp(FCmpInst::FCMP_OEQ, LHS, RHS, Name, FPMathTag);
}

Value *CreateFCmpOGT(Value *LHS, Value *RHS, const Twine &Name = "",
                     MDNode *FPMathTag = nullptr) {
  return CreateFCmp(FCmpInst::FCMP_OGT, LHS, RHS, Name, FPMathTag);
}

Value *CreateFCmpOGE(Value *LHS, Value *RHS, const Twine &Name = "",
                     MDNode *FPMathTag = nullptr) {
  return CreateFCmp(FCmpInst::FCMP_OGE, LHS, RHS, Name, FPMathTag);
}

Value *CreateFCmpOLT(Value *LHS, Value *RHS, const Twine &Name = "",
                     MDNode *FPMathTag = nullptr) {
  return CreateFCmp(FCmpInst::FCMP_OLT, LHS, RHS, Name, FPMathTag);
}

Value *CreateFCmpOLE(Value *LHS, Value *RHS, const Twine &Name = "",
                     MDNode *FPMathTag = nullptr) {
  return CreateFCmp(FCmpInst::FCMP_OLE, LHS, RHS, Name, FPMathTag);
}

Value *CreateFCmpONE(Value *LHS, Value *RHS, const Twine &Name = "",
                     MDNode *FPMathTag = nullptr) {
  return CreateFCmp(FCmpInst::FCMP_ONE, LHS, RHS, Name, FPMathTag);
}

Value *CreateFCmpORD(Value *LHS, Value *RHS, const Twine &Name = "",
                     MDNode *FPMathTag = nullptr) {
  return CreateFCmp(FCmpInst::FCMP_ORD, LHS, RHS, Name, FPMathTag);
}

Value *CreateFCmpUNO(Value *LHS, Value *RHS, const Twine &Name = "",
                     MDNode *FPMathTag = nullptr) {
  return CreateFCmp(FCmpInst::FCMP_UNO, LHS, RHS, Name, FPMathTag);
}

Value *CreateFCmpUEQ(Value *LHS, Value *RHS, const Twine &Name = "",
                     MDNode *FPMathTag = nullptr) {
  return CreateFCmp(FCmpInst::FCMP_UEQ, LHS, RHS, Name, FPMathTag);
}

Value *CreateFCmpUGT(Value *LHS, Value *RHS, const Twine &Name = "",
                     MDNode *FPMathTag = nullptr) {
  return CreateFCmp(FCmpInst::FCMP_UGT, LHS, RHS, Name, FPMathTag);
}

Value *CreateFCmpUGE(Value *LHS, Value *RHS, const Twine &Name = "",
                     MDNode *FPMathTag = nullptr) {
  return CreateFCmp(FCmpInst::FCMP_UGE, LHS, RHS, Name, FPMathTag);
}

Value *CreateFCmpULT(Value *LHS, Value *RHS, const Twine &Name = "",
                     MDNode *FPMathTag = nullptr) {
  return CreateFCmp(FCmpInst::FCMP_ULT, LHS, RHS, Name, FPMathTag);
}

Value *CreateFCmpULE(Value *LHS, Value *RHS, const Twine &Name = "",
                     MDNode *FPMathTag = nullptr) {
  return CreateFCmp(FCmpInst::FCMP_ULE, LHS, RHS, Name, FPMathTag);
}

Value *CreateFCmpUNE(Value *LHS, Value *RHS, const Twine &Name = "",
                     MDNode *FPMathTag = nullptr) {
  return CreateFCmp(FCmpInst::FCMP_UNE, LHS, RHS, Name, FPMathTag);
}

Value *CreateICmp(CmpInst::Predicate P, Value *LHS, Value *RHS,
                  const Twine &Name = "") {
  if (auto *V = Folder.FoldICmp(P, LHS, RHS))
    return V;
  return Insert(new ICmpInst(P, LHS, RHS), Name);
}

// Create a quiet floating-point comparison (i.e. one that raises an FP
// exception only in the case where an input is a signaling NaN).
// Note that this differs from CreateFCmpS only if IsFPConstrained is true.
Value *CreateFCmp(CmpInst::Predicate P, Value *LHS, Value *RHS,
                  const Twine &Name = "", MDNode *FPMathTag = nullptr) {
  return CreateFCmpHelper(P, LHS, RHS, Name, FPMathTag, false);
}

Value *CreateCmp(CmpInst::Predicate Pred, Value *LHS, Value *RHS,
                 const Twine &Name = "", MDNode *FPMathTag = nullptr) {
  return CmpInst::isFPPredicate(Pred)
             ? CreateFCmp(Pred, LHS, RHS, Name, FPMathTag)
             : CreateICmp(Pred, LHS, RHS, Name);
}

// Create a signaling floating-point comparison (i.e. one that raises an FP
// exception whenever an input is any NaN, signaling or quiet).
// Note that this differs from CreateFCmp only if IsFPConstrained is true.
Value *CreateFCmpS(CmpInst::Predicate P, Value *LHS, Value *RHS,
                   const Twine &Name = "", MDNode *FPMathTag = nullptr) {
  return CreateFCmpHelper(P, LHS, RHS, Name, FPMathTag, true);
}

2239private:
// Helper routine to create either a signaling or a quiet FP comparison.
Value *CreateFCmpHelper(CmpInst::Predicate P, Value *LHS, Value *RHS,
                        const Twine &Name, MDNode *FPMathTag,
                        bool IsSignaling);

2245public:
CallInst *CreateConstrainedFPCmp(
    Intrinsic::ID ID, CmpInst::Predicate P, Value *L, Value *R,
    const Twine &Name = "", Optional<fp::ExceptionBehavior> Except = None);

//===--------------------------------------------------------------------===//
// Instruction creation methods: Other Instructions
//===--------------------------------------------------------------------===//

PHINode *CreatePHI(Type *Ty, unsigned NumReservedValues,
                   const Twine &Name = "") {
  PHINode *Phi = PHINode::Create(Ty, NumReservedValues);
  if (isa<FPMathOperator>(Phi))
    setFPAttrs(Phi, nullptr /* MDNode* */, FMF);
  return Insert(Phi, Name);
}

2262private:
CallInst *createCallHelper(Function *Callee, ArrayRef<Value *> Ops,
                           const Twine &Name = "",
                           Instruction *FMFSource = nullptr,
                           ArrayRef<OperandBundleDef> OpBundles = {});

2268public:
CallInst *CreateCall(FunctionType *FTy, Value *Callee,
                     ArrayRef<Value *> Args = None, const Twine &Name = "",
                     MDNode *FPMathTag = nullptr) {
  CallInst *CI = CallInst::Create(FTy, Callee, Args, DefaultOperandBundles);
  if (IsFPConstrained)
    setConstrainedFPCallAttr(CI);
  if (isa<FPMathOperator>(CI))
    setFPAttrs(CI, FPMathTag, FMF);
  return Insert(CI, Name);
}

CallInst *CreateCall(FunctionType *FTy, Value *Callee, ArrayRef<Value *> Args,
                     ArrayRef<OperandBundleDef> OpBundles,
                     const Twine &Name = "", MDNode *FPMathTag = nullptr) {
  CallInst *CI = CallInst::Create(FTy, Callee, Args, OpBundles);
  if (IsFPConstrained)
    setConstrainedFPCallAttr(CI);
  if (isa<FPMathOperator>(CI))
    setFPAttrs(CI, FPMathTag, FMF);
  return Insert(CI, Name);
}

CallInst *CreateCall(FunctionCallee Callee, ArrayRef<Value *> Args = None,
                     const Twine &Name = "", MDNode *FPMathTag = nullptr) {
  return CreateCall(Callee.getFunctionType(), Callee.getCallee(), Args, Name,
                    FPMathTag);
}

CallInst *CreateCall(FunctionCallee Callee, ArrayRef<Value *> Args,
                     ArrayRef<OperandBundleDef> OpBundles,
                     const Twine &Name = "", MDNode *FPMathTag = nullptr) {
  return CreateCall(Callee.getFunctionType(), Callee.getCallee(), Args,
                    OpBundles, Name, FPMathTag);
}

CallInst *CreateConstrainedFPCall(
    Function *Callee, ArrayRef<Value *> Args, const Twine &Name = "",
    Optional<RoundingMode> Rounding = None,
    Optional<fp::ExceptionBehavior> Except = None);

Value *CreateSelect(Value *C, Value *True, Value *False,
                    const Twine &Name = "", Instruction *MDFrom = nullptr);

VAArgInst *CreateVAArg(Value *List, Type *Ty, const Twine &Name = "") {
  return Insert(new VAArgInst(List, Ty), Name);
}

Value *CreateExtractElement(Value *Vec, Value *Idx,
                            const Twine &Name = "") {
  if (Value *V = Folder.FoldExtractElement(Vec, Idx))
    return V;
  return Insert(ExtractElementInst::Create(Vec, Idx), Name);
}

Value *CreateExtractElement(Value *Vec, uint64_t Idx,
                            const Twine &Name = "") {
  return CreateExtractElement(Vec, getInt64(Idx), Name);
}

Value *CreateInsertElement(Type *VecTy, Value *NewElt, Value *Idx,
                           const Twine &Name = "") {
  return CreateInsertElement(PoisonValue::get(VecTy), NewElt, Idx, Name);
}

Value *CreateInsertElement(Type *VecTy, Value *NewElt, uint64_t Idx,
                           const Twine &Name = "") {
  return CreateInsertElement(PoisonValue::get(VecTy), NewElt, Idx, Name);
}

Value *CreateInsertElement(Value *Vec, Value *NewElt, Value *Idx,
                           const Twine &Name = "") {
  if (Value *V = Folder.FoldInsertElement(Vec, NewElt, Idx))
    return V;
  return Insert(InsertElementInst::Create(Vec, NewElt, Idx), Name);
}

Value *CreateInsertElement(Value *Vec, Value *NewElt, uint64_t Idx,
                           const Twine &Name = "") {
  return CreateInsertElement(Vec, NewElt, getInt64(Idx), Name);
}

Value *CreateShuffleVector(Value *V1, Value *V2, Value *Mask,
                           const Twine &Name = "") {
  SmallVector<int, 16> IntMask;
  ShuffleVectorInst::getShuffleMask(cast<Constant>(Mask), IntMask);
  return CreateShuffleVector(V1, V2, IntMask, Name);
}

/// See class ShuffleVectorInst for a description of the mask representation.
Value *CreateShuffleVector(Value *V1, Value *V2, ArrayRef<int> Mask,
                           const Twine &Name = "") {
  if (Value *V = Folder.FoldShuffleVector(V1, V2, Mask))
    return V;
  return Insert(new ShuffleVectorInst(V1, V2, Mask), Name);
}

/// Create a unary shuffle. The second vector operand of the IR instruction
/// is poison.
Value *CreateShuffleVector(Value *V, ArrayRef<int> Mask,
                           const Twine &Name = "") {
  return CreateShuffleVector(V, PoisonValue::get(V->getType()), Mask, Name);
}

Value *CreateExtractValue(Value *Agg, ArrayRef<unsigned> Idxs,
                          const Twine &Name = "") {
  if (auto *V = Folder.FoldExtractValue(Agg, Idxs))
    return V;
  return Insert(ExtractValueInst::Create(Agg, Idxs), Name);
}

Value *CreateInsertValue(Value *Agg, Value *Val, ArrayRef<unsigned> Idxs,
                         const Twine &Name = "") {
  if (auto *V = Folder.FoldInsertValue(Agg, Val, Idxs))
    return V;
  return Insert(InsertValueInst::Create(Agg, Val, Idxs), Name);
}

LandingPadInst *CreateLandingPad(Type *Ty, unsigned NumClauses,
                                 const Twine &Name = "") {
  return Insert(LandingPadInst::Create(Ty, NumClauses), Name);
}

Value *CreateFreeze(Value *V, const Twine &Name = "") {
  return Insert(new FreezeInst(V), Name);
}

//===--------------------------------------------------------------------===//
// Utility creation methods
//===--------------------------------------------------------------------===//

/// Return a boolean value testing if \p Arg == 0.
Value *CreateIsNull(Value *Arg, const Twine &Name = "") {
  return CreateICmpEQ(Arg, ConstantInt::getNullValue(Arg->getType()), Name);
}

/// Return a boolean value testing if \p Arg != 0.
Value *CreateIsNotNull(Value *Arg, const Twine &Name = "") {
  return CreateICmpNE(Arg, ConstantInt::getNullValue(Arg->getType()), Name);
}

/// Return a boolean value testing if \p Arg < 0.
Value *CreateIsNeg(Value *Arg, const Twine &Name = "") {
  return CreateICmpSLT(Arg, ConstantInt::getNullValue(Arg->getType()), Name);
}

/// Return a boolean value testing if \p Arg > -1.
Value *CreateIsNotNeg(Value *Arg, const Twine &Name = "") {
  return CreateICmpSGT(Arg, ConstantInt::getAllOnesValue(Arg->getType()),
                       Name);
}

/// Return the i64 difference between two pointer values, dividing out
/// the size of the pointed-to objects.
///
/// This is intended to implement C-style pointer subtraction. As such, the
/// pointers must be appropriately aligned for their element types and
/// pointing into the same object.
Value *CreatePtrDiff(Type *ElemTy, Value *LHS, Value *RHS,
                     const Twine &Name = "");

/// Create a launder.invariant.group intrinsic call. If Ptr type is
/// different from pointer to i8, it's casted to pointer to i8 in the same
/// address space before call and casted back to Ptr type after call.
Value *CreateLaunderInvariantGroup(Value *Ptr);

/// \brief Create a strip.invariant.group intrinsic call. If Ptr type is
/// different from pointer to i8, it's casted to pointer to i8 in the same
/// address space before call and casted back to Ptr type after call.
Value *CreateStripInvariantGroup(Value *Ptr);

/// Return a vector value that contains the vector V reversed
Value *CreateVectorReverse(Value *V, const Twine &Name = "");

/// Return a vector splice intrinsic if using scalable vectors, otherwise
/// return a shufflevector. If the immediate is positive, a vector is
/// extracted from concat(V1, V2), starting at Imm. If the immediate
/// is negative, we extract -Imm elements from V1 and the remaining
/// elements from V2. Imm is a signed integer in the range
/// -VL <= Imm < VL (where VL is the runtime vector length of the
/// source/result vector)
Value *CreateVectorSplice(Value *V1, Value *V2, int64_t Imm,
                          const Twine &Name = "");

/// Return a vector value that contains \arg V broadcasted to \p
/// NumElts elements.
Value *CreateVectorSplat(unsigned NumElts, Value *V, const Twine &Name = "");

/// Return a vector value that contains \arg V broadcasted to \p
/// EC elements.
Value *CreateVectorSplat(ElementCount EC, Value *V, const Twine &Name = "");

/// Return a value that has been extracted from a larger integer type.
Value *CreateExtractInteger(const DataLayout &DL, Value *From,
                            IntegerType *ExtractedTy, uint64_t Offset,
                            const Twine &Name);

Value *CreatePreserveArrayAccessIndex(Type *ElTy, Value *Base,
                                      unsigned Dimension, unsigned LastIndex,
                                      MDNode *DbgInfo);

Value *CreatePreserveUnionAccessIndex(Value *Base, unsigned FieldIndex,
                                      MDNode *DbgInfo);

Value *CreatePreserveStructAccessIndex(Type *ElTy, Value *Base,
                                       unsigned Index, unsigned FieldIndex,
                                       MDNode *DbgInfo);

2476private:
/// Helper function that creates an assume intrinsic call that
/// represents an alignment assumption on the provided pointer \p PtrValue
/// with offset \p OffsetValue and alignment value \p AlignValue.
CallInst *CreateAlignmentAssumptionHelper(const DataLayout &DL,
                                          Value *PtrValue, Value *AlignValue,
                                          Value *OffsetValue);

2484public:
/// Create an assume intrinsic call that represents an alignment
/// assumption on the provided pointer.
///
/// An optional offset can be provided, and if it is provided, the offset
/// must be subtracted from the provided pointer to get the pointer with the
/// specified alignment.
CallInst *CreateAlignmentAssumption(const DataLayout &DL, Value *PtrValue,
                                    unsigned Alignment,
                                    Value *OffsetValue = nullptr);

/// Create an assume intrinsic call that represents an alignment
/// assumption on the provided pointer.
///
/// An optional offset can be provided, and if it is provided, the offset
/// must be subtracted from the provided pointer to get the pointer with the
/// specified alignment.
///
/// This overload handles the condition where the Alignment is dependent
/// on an existing value rather than a static value.
CallInst *CreateAlignmentAssumption(const DataLayout &DL, Value *PtrValue,
                                    Value *Alignment,
                                    Value *OffsetValue = nullptr);
2507};

2509/// This provides a uniform API for creating instructions and inserting
2510/// them into a basic block: either at the end of a BasicBlock, or at a specific
2511/// iterator location in a block.
2512///
2513/// Note that the builder does not expose the full generality of LLVM
2514/// instructions.  For access to extra instruction properties, use the mutators
2515/// (e.g. setVolatile) on the instructions after they have been
2516/// created. Convenience state exists to specify fast-math flags and fp-math
2517/// tags.
2518///
2519/// The first template argument specifies a class to use for creating constants.
2520/// This defaults to creating minimally folded constants.  The second template
2521/// argument allows clients to specify custom insertion hooks that are called on
2522/// every newly created insertion.
2523template <typename FolderTy = ConstantFolder,
        typename InserterTy = IRBuilderDefaultInserter>
2525class IRBuilder : public IRBuilderBase {
2526private:
FolderTy Folder;
InserterTy Inserter;

2530public:
IRBuilder(LLVMContext &C, FolderTy Folder, InserterTy Inserter = InserterTy(),
          MDNode *FPMathTag = nullptr,
          ArrayRef<OperandBundleDef> OpBundles = None)
    : IRBuilderBase(C, this->Folder, this->Inserter, FPMathTag, OpBundles),
      Folder(Folder), Inserter(Inserter) {}

explicit IRBuilder(LLVMContext &C, MDNode *FPMathTag = nullptr,
                   ArrayRef<OperandBundleDef> OpBundles = None)
    : IRBuilderBase(C, this->Folder, this->Inserter, FPMathTag, OpBundles) {}

explicit IRBuilder(BasicBlock *TheBB, FolderTy Folder,
                   MDNode *FPMathTag = nullptr,
                   ArrayRef<OperandBundleDef> OpBundles = None)
    : IRBuilderBase(TheBB->getContext(), this->Folder, this->Inserter,
                    FPMathTag, OpBundles), Folder(Folder) {
  SetInsertPoint(TheBB);
}

explicit IRBuilder(BasicBlock *TheBB, MDNode *FPMathTag = nullptr,
                   ArrayRef<OperandBundleDef> OpBundles = None)
    : IRBuilderBase(TheBB->getContext(), this->Folder, this->Inserter,
                    FPMathTag, OpBundles) {
  SetInsertPoint(TheBB);
}

explicit IRBuilder(Instruction *IP, MDNode *FPMathTag = nullptr,
                   ArrayRef<OperandBundleDef> OpBundles = None)
    : IRBuilderBase(IP->getContext(), this->Folder, this->Inserter,
22
←
Called C++ object pointer is null
                    FPMathTag, OpBundles) {
  SetInsertPoint(IP);
}

IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP, FolderTy Folder,
          MDNode *FPMathTag = nullptr,
          ArrayRef<OperandBundleDef> OpBundles = None)
    : IRBuilderBase(TheBB->getContext(), this->Folder, this->Inserter,
                    FPMathTag, OpBundles), Folder(Folder) {
  SetInsertPoint(TheBB, IP);
}

IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP,
          MDNode *FPMathTag = nullptr,
          ArrayRef<OperandBundleDef> OpBundles = None)
    : IRBuilderBase(TheBB->getContext(), this->Folder, this->Inserter,
                    FPMathTag, OpBundles) {
  SetInsertPoint(TheBB, IP);
}

/// Avoid copying the full IRBuilder. Prefer using InsertPointGuard
/// or FastMathFlagGuard instead.
IRBuilder(const IRBuilder &) = delete;

InserterTy &getInserter() { return Inserter; }
2584};

2586// Create wrappers for C Binding types (see CBindingWrapping.h).
2587DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IRBuilder<>, LLVMBuilderRef)inline IRBuilder<> *unwrap(LLVMBuilderRef P) { return reinterpret_cast
<IRBuilder<>*>(P); } inline LLVMBuilderRef wrap(const
 IRBuilder<> *P) { return reinterpret_cast<LLVMBuilderRef
>(const_cast<IRBuilder<>*>(P)); }

2589} // end namespace llvm

2591#endif // LLVM_IR_IRBUILDER_H