/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Analysis/LazyValueInfo.cpp

Bug Summary

File:	llvm/lib/Analysis/LazyValueInfo.cpp
Warning:	line 1295, column 34 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 -disable-llvm-verifier -discard-value-names -main-file-name LazyValueInfo.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -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 -fhalf-no-semantic-interposition -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/build-llvm/lib/Analysis -resource-dir /usr/lib/llvm-13/lib/clang/13.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/build-llvm/lib/Analysis -I /build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Analysis -I /build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/build-llvm/include -I /build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../x86_64-linux-gnu/include -internal-isystem /usr/lib/llvm-13/lib/clang/13.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/build-llvm/lib/Analysis -fdebug-prefix-map=/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4=. -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -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-2021-04-05-202135-9119-1 -x c++ /build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Analysis/LazyValueInfo.cpp

/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Analysis/LazyValueInfo.cpp

→

1//===- LazyValueInfo.cpp - Value constraint analysis ------------*- 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 interface for lazy computation of value constraint
10// information.
11//
12//===----------------------------------------------------------------------===//

14#include "llvm/Analysis/LazyValueInfo.h"
15#include "llvm/ADT/DenseSet.h"
16#include "llvm/ADT/Optional.h"
17#include "llvm/ADT/STLExtras.h"
18#include "llvm/Analysis/AssumptionCache.h"
19#include "llvm/Analysis/ConstantFolding.h"
20#include "llvm/Analysis/InstructionSimplify.h"
21#include "llvm/Analysis/TargetLibraryInfo.h"
22#include "llvm/Analysis/ValueLattice.h"
23#include "llvm/Analysis/ValueTracking.h"
24#include "llvm/IR/AssemblyAnnotationWriter.h"
25#include "llvm/IR/CFG.h"
26#include "llvm/IR/ConstantRange.h"
27#include "llvm/IR/Constants.h"
28#include "llvm/IR/DataLayout.h"
29#include "llvm/IR/Dominators.h"
30#include "llvm/IR/Instructions.h"
31#include "llvm/IR/IntrinsicInst.h"
32#include "llvm/IR/Intrinsics.h"
33#include "llvm/IR/LLVMContext.h"
34#include "llvm/IR/PatternMatch.h"
35#include "llvm/IR/ValueHandle.h"
36#include "llvm/InitializePasses.h"
37#include "llvm/Support/Debug.h"
38#include "llvm/Support/FormattedStream.h"
39#include "llvm/Support/KnownBits.h"
40#include "llvm/Support/raw_ostream.h"
41#include <map>
42using namespace llvm;
43using namespace PatternMatch;

45#define DEBUG_TYPE"lazy-value-info" "lazy-value-info"

47// This is the number of worklist items we will process to try to discover an
48// answer for a given value.
49static const unsigned MaxProcessedPerValue = 500;

51char LazyValueInfoWrapperPass::ID = 0;
52LazyValueInfoWrapperPass::LazyValueInfoWrapperPass() : FunctionPass(ID) {
initializeLazyValueInfoWrapperPassPass(*PassRegistry::getPassRegistry());
54}
55INITIALIZE_PASS_BEGIN(LazyValueInfoWrapperPass, "lazy-value-info",static void *initializeLazyValueInfoWrapperPassPassOnce(PassRegistry
 &Registry) {
              "Lazy Value Information Analysis", false, true)static void *initializeLazyValueInfoWrapperPassPassOnce(PassRegistry
 &Registry) {
57INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)initializeAssumptionCacheTrackerPass(Registry);
58INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)initializeTargetLibraryInfoWrapperPassPass(Registry);
59INITIALIZE_PASS_END(LazyValueInfoWrapperPass, "lazy-value-info",PassInfo *PI = new PassInfo( "Lazy Value Information Analysis"
, "lazy-value-info", &LazyValueInfoWrapperPass::ID, PassInfo
::NormalCtor_t(callDefaultCtor<LazyValueInfoWrapperPass>
), false, true); Registry.registerPass(*PI, true); return PI;
 } static llvm::once_flag InitializeLazyValueInfoWrapperPassPassFlag
; void llvm::initializeLazyValueInfoWrapperPassPass(PassRegistry
 &Registry) { llvm::call_once(InitializeLazyValueInfoWrapperPassPassFlag
, initializeLazyValueInfoWrapperPassPassOnce, std::ref(Registry
)); }
              "Lazy Value Information Analysis", false, true)PassInfo *PI = new PassInfo( "Lazy Value Information Analysis"
, "lazy-value-info", &LazyValueInfoWrapperPass::ID, PassInfo
::NormalCtor_t(callDefaultCtor<LazyValueInfoWrapperPass>
), false, true); Registry.registerPass(*PI, true); return PI;
 } static llvm::once_flag InitializeLazyValueInfoWrapperPassPassFlag
; void llvm::initializeLazyValueInfoWrapperPassPass(PassRegistry
 &Registry) { llvm::call_once(InitializeLazyValueInfoWrapperPassPassFlag
, initializeLazyValueInfoWrapperPassPassOnce, std::ref(Registry
)); }

62namespace llvm {
FunctionPass *createLazyValueInfoPass() { return new LazyValueInfoWrapperPass(); }
64}

66AnalysisKey LazyValueAnalysis::Key;

68/// Returns true if this lattice value represents at most one possible value.
69/// This is as precise as any lattice value can get while still representing
70/// reachable code.
71static bool hasSingleValue(const ValueLatticeElement &Val) {
if (Val.isConstantRange() &&
    Val.getConstantRange().isSingleElement())
  // Integer constants are single element ranges
  return true;
if (Val.isConstant())
  // Non integer constants
  return true;
return false;
80}

82/// Combine two sets of facts about the same value into a single set of
83/// facts.  Note that this method is not suitable for merging facts along
84/// different paths in a CFG; that's what the mergeIn function is for.  This
85/// is for merging facts gathered about the same value at the same location
86/// through two independent means.
87/// Notes:
88/// * This method does not promise to return the most precise possible lattice
89///   value implied by A and B.  It is allowed to return any lattice element
90///   which is at least as strong as *either* A or B (unless our facts
91///   conflict, see below).
92/// * Due to unreachable code, the intersection of two lattice values could be
93///   contradictory.  If this happens, we return some valid lattice value so as
94///   not confuse the rest of LVI.  Ideally, we'd always return Undefined, but
95///   we do not make this guarantee.  TODO: This would be a useful enhancement.
96static ValueLatticeElement intersect(const ValueLatticeElement &A,
                                   const ValueLatticeElement &B) {
// Undefined is the strongest state.  It means the value is known to be along
// an unreachable path.
if (A.isUnknown())
  return A;
if (B.isUnknown())
  return B;

// If we gave up for one, but got a useable fact from the other, use it.
if (A.isOverdefined())
  return B;
if (B.isOverdefined())
  return A;

// Can't get any more precise than constants.
if (hasSingleValue(A))
  return A;
if (hasSingleValue(B))
  return B;

// Could be either constant range or not constant here.
if (!A.isConstantRange() || !B.isConstantRange()) {
  // TODO: Arbitrary choice, could be improved
  return A;
}

// Intersect two constant ranges
ConstantRange Range =
    A.getConstantRange().intersectWith(B.getConstantRange());
// Note: An empty range is implicitly converted to unknown or undef depending
// on MayIncludeUndef internally.
return ValueLatticeElement::getRange(
    std::move(Range), /*MayIncludeUndef=*/A.isConstantRangeIncludingUndef() |
                          B.isConstantRangeIncludingUndef());
131}

133//===----------------------------------------------------------------------===//
134//                          LazyValueInfoCache Decl
135//===----------------------------------------------------------------------===//

137namespace {
/// A callback value handle updates the cache when values are erased.
class LazyValueInfoCache;
struct LVIValueHandle final : public CallbackVH {
  LazyValueInfoCache *Parent;

  LVIValueHandle(Value *V, LazyValueInfoCache *P = nullptr)
    : CallbackVH(V), Parent(P) { }

  void deleted() override;
  void allUsesReplacedWith(Value *V) override {
    deleted();
  }
};
151} // end anonymous namespace

153namespace {
using NonNullPointerSet = SmallDenseSet<AssertingVH<Value>, 2>;

/// This is the cache kept by LazyValueInfo which
/// maintains information about queries across the clients' queries.
class LazyValueInfoCache {
  /// This is all of the cached information for one basic block. It contains
  /// the per-value lattice elements, as well as a separate set for
  /// overdefined values to reduce memory usage. Additionally pointers
  /// dereferenced in the block are cached for nullability queries.
  struct BlockCacheEntry {
    SmallDenseMap<AssertingVH<Value>, ValueLatticeElement, 4> LatticeElements;
    SmallDenseSet<AssertingVH<Value>, 4> OverDefined;
    // None indicates that the nonnull pointers for this basic block
    // block have not been computed yet.
    Optional<NonNullPointerSet> NonNullPointers;
  };

  /// Cached information per basic block.
  DenseMap<PoisoningVH<BasicBlock>, std::unique_ptr<BlockCacheEntry>>
      BlockCache;
  /// Set of value handles used to erase values from the cache on deletion.
  DenseSet<LVIValueHandle, DenseMapInfo<Value *>> ValueHandles;

  const BlockCacheEntry *getBlockEntry(BasicBlock *BB) const {
    auto It = BlockCache.find_as(BB);
    if (It == BlockCache.end())
      return nullptr;
    return It->second.get();
  }

  BlockCacheEntry *getOrCreateBlockEntry(BasicBlock *BB) {
    auto It = BlockCache.find_as(BB);
    if (It == BlockCache.end())
      It = BlockCache.insert({ BB, std::make_unique<BlockCacheEntry>() })
                     .first;

    return It->second.get();
  }

  void addValueHandle(Value *Val) {
    auto HandleIt = ValueHandles.find_as(Val);
    if (HandleIt == ValueHandles.end())
      ValueHandles.insert({ Val, this });
  }

public:
  void insertResult(Value *Val, BasicBlock *BB,
                    const ValueLatticeElement &Result) {
    BlockCacheEntry *Entry = getOrCreateBlockEntry(BB);

    // Insert over-defined values into their own cache to reduce memory
    // overhead.
    if (Result.isOverdefined())
      Entry->OverDefined.insert(Val);
    else
      Entry->LatticeElements.insert({ Val, Result });

    addValueHandle(Val);
  }

  Optional<ValueLatticeElement> getCachedValueInfo(Value *V,
                                                   BasicBlock *BB) const {
    const BlockCacheEntry *Entry = getBlockEntry(BB);
    if (!Entry)
      return None;

    if (Entry->OverDefined.count(V))
      return ValueLatticeElement::getOverdefined();

    auto LatticeIt = Entry->LatticeElements.find_as(V);
    if (LatticeIt == Entry->LatticeElements.end())
      return None;

    return LatticeIt->second;
  }

  bool isNonNullAtEndOfBlock(
      Value *V, BasicBlock *BB,
      function_ref<NonNullPointerSet(BasicBlock *)> InitFn) {
    BlockCacheEntry *Entry = getOrCreateBlockEntry(BB);
    if (!Entry->NonNullPointers) {
      Entry->NonNullPointers = InitFn(BB);
      for (Value *V : *Entry->NonNullPointers)
        addValueHandle(V);
    }

    return Entry->NonNullPointers->count(V);
  }

  /// clear - Empty the cache.
  void clear() {
    BlockCache.clear();
    ValueHandles.clear();
  }

  /// Inform the cache that a given value has been deleted.
  void eraseValue(Value *V);

  /// This is part of the update interface to inform the cache
  /// that a block has been deleted.
  void eraseBlock(BasicBlock *BB);

  /// Updates the cache to remove any influence an overdefined value in
  /// OldSucc might have (unless also overdefined in NewSucc).  This just
  /// flushes elements from the cache and does not add any.
  void threadEdgeImpl(BasicBlock *OldSucc,BasicBlock *NewSucc);
};
261}

263void LazyValueInfoCache::eraseValue(Value *V) {
for (auto &Pair : BlockCache) {
  Pair.second->LatticeElements.erase(V);
  Pair.second->OverDefined.erase(V);
  if (Pair.second->NonNullPointers)
    Pair.second->NonNullPointers->erase(V);
}

auto HandleIt = ValueHandles.find_as(V);
if (HandleIt != ValueHandles.end())
  ValueHandles.erase(HandleIt);
274}

276void LVIValueHandle::deleted() {
// This erasure deallocates *this, so it MUST happen after we're done
// using any and all members of *this.
Parent->eraseValue(*this);
280}

282void LazyValueInfoCache::eraseBlock(BasicBlock *BB) {
BlockCache.erase(BB);
284}

286void LazyValueInfoCache::threadEdgeImpl(BasicBlock *OldSucc,
                                      BasicBlock *NewSucc) {
// When an edge in the graph has been threaded, values that we could not
// determine a value for before (i.e. were marked overdefined) may be
// possible to solve now. We do NOT try to proactively update these values.
// Instead, we clear their entries from the cache, and allow lazy updating to
// recompute them when needed.

// The updating process is fairly simple: we need to drop cached info
// for all values that were marked overdefined in OldSucc, and for those same
// values in any successor of OldSucc (except NewSucc) in which they were
// also marked overdefined.
std::vector<BasicBlock*> worklist;
worklist.push_back(OldSucc);

const BlockCacheEntry *Entry = getBlockEntry(OldSucc);
if (!Entry || Entry->OverDefined.empty())
  return; // Nothing to process here.
SmallVector<Value *, 4> ValsToClear(Entry->OverDefined.begin(),
                                    Entry->OverDefined.end());

// Use a worklist to perform a depth-first search of OldSucc's successors.
// NOTE: We do not need a visited list since any blocks we have already
// visited will have had their overdefined markers cleared already, and we
// thus won't loop to their successors.
while (!worklist.empty()) {
  BasicBlock *ToUpdate = worklist.back();
  worklist.pop_back();

  // Skip blocks only accessible through NewSucc.
  if (ToUpdate == NewSucc) continue;

  // If a value was marked overdefined in OldSucc, and is here too...
  auto OI = BlockCache.find_as(ToUpdate);
  if (OI == BlockCache.end() || OI->second->OverDefined.empty())
    continue;
  auto &ValueSet = OI->second->OverDefined;

  bool changed = false;
  for (Value *V : ValsToClear) {
    if (!ValueSet.erase(V))
      continue;

    // If we removed anything, then we potentially need to update
    // blocks successors too.
    changed = true;
  }

  if (!changed) continue;

  llvm::append_range(worklist, successors(ToUpdate));
}
338}


341namespace {
342/// An assembly annotator class to print LazyValueCache information in
343/// comments.
344class LazyValueInfoImpl;
345class LazyValueInfoAnnotatedWriter : public AssemblyAnnotationWriter {
LazyValueInfoImpl *LVIImpl;
// While analyzing which blocks we can solve values for, we need the dominator
// information.
DominatorTree &DT;

351public:
LazyValueInfoAnnotatedWriter(LazyValueInfoImpl *L, DominatorTree &DTree)
    : LVIImpl(L), DT(DTree) {}

void emitBasicBlockStartAnnot(const BasicBlock *BB,
                              formatted_raw_ostream &OS) override;

void emitInstructionAnnot(const Instruction *I,
                          formatted_raw_ostream &OS) override;
360};
361}
362namespace {
363// The actual implementation of the lazy analysis and update.  Note that the
364// inheritance from LazyValueInfoCache is intended to be temporary while
365// splitting the code and then transitioning to a has-a relationship.
366class LazyValueInfoImpl {

/// Cached results from previous queries
LazyValueInfoCache TheCache;

/// This stack holds the state of the value solver during a query.
/// It basically emulates the callstack of the naive
/// recursive value lookup process.
SmallVector<std::pair<BasicBlock*, Value*>, 8> BlockValueStack;

/// Keeps track of which block-value pairs are in BlockValueStack.
DenseSet<std::pair<BasicBlock*, Value*> > BlockValueSet;

/// Push BV onto BlockValueStack unless it's already in there.
/// Returns true on success.
bool pushBlockValue(const std::pair<BasicBlock *, Value *> &BV) {
  if (!BlockValueSet.insert(BV).second)
    return false;  // It's already in the stack.

  LLVM_DEBUG(dbgs() << "PUSH: " << *BV.second << " in "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("lazy-value-info")) { dbgs() << "PUSH: " << *BV.
second << " in " << BV.first->getName() <<
 "\n"; } } while (false)
                    << BV.first->getName() << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("lazy-value-info")) { dbgs() << "PUSH: " << *BV.
second << " in " << BV.first->getName() <<
 "\n"; } } while (false);
  BlockValueStack.push_back(BV);
  return true;
}

AssumptionCache *AC;  ///< A pointer to the cache of @llvm.assume calls.
const DataLayout &DL; ///< A mandatory DataLayout

/// Declaration of the llvm.experimental.guard() intrinsic,
/// if it exists in the module.
Function *GuardDecl;

Optional<ValueLatticeElement> getBlockValue(Value *Val, BasicBlock *BB);
Optional<ValueLatticeElement> getEdgeValue(Value *V, BasicBlock *F,
                              BasicBlock *T, Instruction *CxtI = nullptr);

// These methods process one work item and may add more. A false value
// returned means that the work item was not completely processed and must
// be revisited after going through the new items.
bool solveBlockValue(Value *Val, BasicBlock *BB);
Optional<ValueLatticeElement> solveBlockValueImpl(Value *Val, BasicBlock *BB);
Optional<ValueLatticeElement> solveBlockValueNonLocal(Value *Val,
                                                      BasicBlock *BB);
Optional<ValueLatticeElement> solveBlockValuePHINode(PHINode *PN,
                                                     BasicBlock *BB);
Optional<ValueLatticeElement> solveBlockValueSelect(SelectInst *S,
                                                    BasicBlock *BB);
Optional<ConstantRange> getRangeFor(Value *V, Instruction *CxtI,
                                    BasicBlock *BB);
Optional<ValueLatticeElement> solveBlockValueBinaryOpImpl(
    Instruction *I, BasicBlock *BB,
    std::function<ConstantRange(const ConstantRange &,
                                const ConstantRange &)> OpFn);
Optional<ValueLatticeElement> solveBlockValueBinaryOp(BinaryOperator *BBI,
                                                      BasicBlock *BB);
Optional<ValueLatticeElement> solveBlockValueCast(CastInst *CI,
                                                  BasicBlock *BB);
Optional<ValueLatticeElement> solveBlockValueOverflowIntrinsic(
    WithOverflowInst *WO, BasicBlock *BB);
Optional<ValueLatticeElement> solveBlockValueIntrinsic(IntrinsicInst *II,
                                                       BasicBlock *BB);
Optional<ValueLatticeElement> solveBlockValueExtractValue(
    ExtractValueInst *EVI, BasicBlock *BB);
bool isNonNullAtEndOfBlock(Value *Val, BasicBlock *BB);
void intersectAssumeOrGuardBlockValueConstantRange(Value *Val,
                                                   ValueLatticeElement &BBLV,
                                                   Instruction *BBI);

void solve();

436public:
/// This is the query interface to determine the lattice value for the
/// specified Value* at the context instruction (if specified) or at the
/// start of the block.
ValueLatticeElement getValueInBlock(Value *V, BasicBlock *BB,
                                    Instruction *CxtI = nullptr);

/// This is the query interface to determine the lattice value for the
/// specified Value* at the specified instruction using only information
/// from assumes/guards and range metadata. Unlike getValueInBlock(), no
/// recursive query is performed.
ValueLatticeElement getValueAt(Value *V, Instruction *CxtI);

/// This is the query interface to determine the lattice
/// value for the specified Value* that is true on the specified edge.
ValueLatticeElement getValueOnEdge(Value *V, BasicBlock *FromBB,
                                   BasicBlock *ToBB,
                                   Instruction *CxtI = nullptr);

/// Complete flush all previously computed values
void clear() {
  TheCache.clear();
}

/// Printing the LazyValueInfo Analysis.
void printLVI(Function &F, DominatorTree &DTree, raw_ostream &OS) {
  LazyValueInfoAnnotatedWriter Writer(this, DTree);
  F.print(OS, &Writer);
}

/// This is part of the update interface to inform the cache
/// that a block has been deleted.
void eraseBlock(BasicBlock *BB) {
  TheCache.eraseBlock(BB);
}

/// This is the update interface to inform the cache that an edge from
/// PredBB to OldSucc has been threaded to be from PredBB to NewSucc.
void threadEdge(BasicBlock *PredBB,BasicBlock *OldSucc,BasicBlock *NewSucc);

LazyValueInfoImpl(AssumptionCache *AC, const DataLayout &DL,
                  Function *GuardDecl)
    : AC(AC), DL(DL), GuardDecl(GuardDecl) {}
479};
480} // end anonymous namespace


483void LazyValueInfoImpl::solve() {
SmallVector<std::pair<BasicBlock *, Value *>, 8> StartingStack(
    BlockValueStack.begin(), BlockValueStack.end());

unsigned processedCount = 0;
while (!BlockValueStack.empty()) {
  processedCount++;
  // Abort if we have to process too many values to get a result for this one.
  // Because of the design of the overdefined cache currently being per-block
  // to avoid naming-related issues (IE it wants to try to give different
  // results for the same name in different blocks), overdefined results don't
  // get cached globally, which in turn means we will often try to rediscover
  // the same overdefined result again and again.  Once something like
  // PredicateInfo is used in LVI or CVP, we should be able to make the
  // overdefined cache global, and remove this throttle.
  if (processedCount > MaxProcessedPerValue) {
    LLVM_DEBUG(do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("lazy-value-info")) { dbgs() << "Giving up on stack because we are getting too deep\n"
; } } while (false)
        dbgs() << "Giving up on stack because we are getting too deep\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("lazy-value-info")) { dbgs() << "Giving up on stack because we are getting too deep\n"
; } } while (false);
    // Fill in the original values
    while (!StartingStack.empty()) {
      std::pair<BasicBlock *, Value *> &e = StartingStack.back();
      TheCache.insertResult(e.second, e.first,
                            ValueLatticeElement::getOverdefined());
      StartingStack.pop_back();
    }
    BlockValueSet.clear();
    BlockValueStack.clear();
    return;
  }
  std::pair<BasicBlock *, Value *> e = BlockValueStack.back();
  assert(BlockValueSet.count(e) && "Stack value should be in BlockValueSet!")((BlockValueSet.count(e) && "Stack value should be in BlockValueSet!"
) ? static_cast<void> (0) : __assert_fail ("BlockValueSet.count(e) && \"Stack value should be in BlockValueSet!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Analysis/LazyValueInfo.cpp"
, 513, __PRETTY_FUNCTION__));

  if (solveBlockValue(e.second, e.first)) {
    // The work item was completely processed.
    assert(BlockValueStack.back() == e && "Nothing should have been pushed!")((BlockValueStack.back() == e && "Nothing should have been pushed!"
) ? static_cast<void> (0) : __assert_fail ("BlockValueStack.back() == e && \"Nothing should have been pushed!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Analysis/LazyValueInfo.cpp"
, 517, __PRETTY_FUNCTION__));
518#ifndef NDEBUG
    Optional<ValueLatticeElement> BBLV =
        TheCache.getCachedValueInfo(e.second, e.first);
    assert(BBLV && "Result should be in cache!")((BBLV && "Result should be in cache!") ? static_cast
<void> (0) : __assert_fail ("BBLV && \"Result should be in cache!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Analysis/LazyValueInfo.cpp"
, 521, __PRETTY_FUNCTION__));
    LLVM_DEBUG(do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("lazy-value-info")) { dbgs() << "POP " << *e.second
 << " in " << e.first->getName() << " = "
 << *BBLV << "\n"; } } while (false)
        dbgs() << "POP " << *e.second << " in " << e.first->getName() << " = "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("lazy-value-info")) { dbgs() << "POP " << *e.second
 << " in " << e.first->getName() << " = "
 << *BBLV << "\n"; } } while (false)
               << *BBLV << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("lazy-value-info")) { dbgs() << "POP " << *e.second
 << " in " << e.first->getName() << " = "
 << *BBLV << "\n"; } } while (false);
525#endif

    BlockValueStack.pop_back();
    BlockValueSet.erase(e);
  } else {
    // More work needs to be done before revisiting.
    assert(BlockValueStack.back() != e && "Stack should have been pushed!")((BlockValueStack.back() != e && "Stack should have been pushed!"
) ? static_cast<void> (0) : __assert_fail ("BlockValueStack.back() != e && \"Stack should have been pushed!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Analysis/LazyValueInfo.cpp"
, 531, __PRETTY_FUNCTION__));
  }
}
534}

536Optional<ValueLatticeElement> LazyValueInfoImpl::getBlockValue(Value *Val,
                                                             BasicBlock *BB) {
// If already a constant, there is nothing to compute.
if (Constant *VC = dyn_cast<Constant>(Val))
  return ValueLatticeElement::get(VC);

if (Optional<ValueLatticeElement> OptLatticeVal =
        TheCache.getCachedValueInfo(Val, BB))
  return OptLatticeVal;

// We have hit a cycle, assume overdefined.
if (!pushBlockValue({ BB, Val }))
  return ValueLatticeElement::getOverdefined();

// Yet to be resolved.
return None;
552}

554static ValueLatticeElement getFromRangeMetadata(Instruction *BBI) {
switch (BBI->getOpcode()) {
default: break;
case Instruction::Load:
case Instruction::Call:
case Instruction::Invoke:
  if (MDNode *Ranges = BBI->getMetadata(LLVMContext::MD_range))
    if (isa<IntegerType>(BBI->getType())) {
      return ValueLatticeElement::getRange(
          getConstantRangeFromMetadata(*Ranges));
    }
  break;
};
// Nothing known - will be intersected with other facts
return ValueLatticeElement::getOverdefined();
569}

571bool LazyValueInfoImpl::solveBlockValue(Value *Val, BasicBlock *BB) {
assert(!isa<Constant>(Val) && "Value should not be constant")((!isa<Constant>(Val) && "Value should not be constant"
) ? static_cast<void> (0) : __assert_fail ("!isa<Constant>(Val) && \"Value should not be constant\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Analysis/LazyValueInfo.cpp"
, 572, __PRETTY_FUNCTION__));
assert(!TheCache.getCachedValueInfo(Val, BB) &&((!TheCache.getCachedValueInfo(Val, BB) && "Value should not be in cache"
) ? static_cast<void> (0) : __assert_fail ("!TheCache.getCachedValueInfo(Val, BB) && \"Value should not be in cache\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Analysis/LazyValueInfo.cpp"
, 574, __PRETTY_FUNCTION__))
       "Value should not be in cache")((!TheCache.getCachedValueInfo(Val, BB) && "Value should not be in cache"
) ? static_cast<void> (0) : __assert_fail ("!TheCache.getCachedValueInfo(Val, BB) && \"Value should not be in cache\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Analysis/LazyValueInfo.cpp"
, 574, __PRETTY_FUNCTION__));

// Hold off inserting this value into the Cache in case we have to return
// false and come back later.
Optional<ValueLatticeElement> Res = solveBlockValueImpl(Val, BB);
if (!Res)
  // Work pushed, will revisit
  return false;

TheCache.insertResult(Val, BB, *Res);
return true;
585}

587Optional<ValueLatticeElement> LazyValueInfoImpl::solveBlockValueImpl(
  Value *Val, BasicBlock *BB) {
Instruction *BBI = dyn_cast<Instruction>(Val);
if (!BBI || BBI->getParent() != BB)
  return solveBlockValueNonLocal(Val, BB);

if (PHINode *PN = dyn_cast<PHINode>(BBI))
  return solveBlockValuePHINode(PN, BB);

if (auto *SI = dyn_cast<SelectInst>(BBI))
  return solveBlockValueSelect(SI, BB);

// If this value is a nonnull pointer, record it's range and bailout.  Note
// that for all other pointer typed values, we terminate the search at the
// definition.  We could easily extend this to look through geps, bitcasts,
// and the like to prove non-nullness, but it's not clear that's worth it
// compile time wise.  The context-insensitive value walk done inside
// isKnownNonZero gets most of the profitable cases at much less expense.
// This does mean that we have a sensitivity to where the defining
// instruction is placed, even if it could legally be hoisted much higher.
// That is unfortunate.
PointerType *PT = dyn_cast<PointerType>(BBI->getType());
if (PT && isKnownNonZero(BBI, DL))
  return ValueLatticeElement::getNot(ConstantPointerNull::get(PT));

if (BBI->getType()->isIntegerTy()) {
  if (auto *CI = dyn_cast<CastInst>(BBI))
    return solveBlockValueCast(CI, BB);

  if (BinaryOperator *BO = dyn_cast<BinaryOperator>(BBI))
    return solveBlockValueBinaryOp(BO, BB);

  if (auto *EVI = dyn_cast<ExtractValueInst>(BBI))
    return solveBlockValueExtractValue(EVI, BB);

  if (auto *II = dyn_cast<IntrinsicInst>(BBI))
    return solveBlockValueIntrinsic(II, BB);
}

LLVM_DEBUG(dbgs() << " compute BB '" << BB->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("lazy-value-info")) { dbgs() << " compute BB '" <<
 BB->getName() << "' - unknown inst def found.\n"; }
 } while (false)
                  << "' - unknown inst def found.\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("lazy-value-info")) { dbgs() << " compute BB '" <<
 BB->getName() << "' - unknown inst def found.\n"; }
 } while (false);
return getFromRangeMetadata(BBI);
629}

631static void AddNonNullPointer(Value *Ptr, NonNullPointerSet &PtrSet) {
// TODO: Use NullPointerIsDefined instead.
if (Ptr->getType()->getPointerAddressSpace() == 0)
  PtrSet.insert(getUnderlyingObject(Ptr));
635}

637static void AddNonNullPointersByInstruction(
  Instruction *I, NonNullPointerSet &PtrSet) {
if (LoadInst *L = dyn_cast<LoadInst>(I)) {
  AddNonNullPointer(L->getPointerOperand(), PtrSet);
} else if (StoreInst *S = dyn_cast<StoreInst>(I)) {
  AddNonNullPointer(S->getPointerOperand(), PtrSet);
} else if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(I)) {
  if (MI->isVolatile()) return;

  // FIXME: check whether it has a valuerange that excludes zero?
  ConstantInt *Len = dyn_cast<ConstantInt>(MI->getLength());
  if (!Len || Len->isZero()) return;

  AddNonNullPointer(MI->getRawDest(), PtrSet);
  if (MemTransferInst *MTI = dyn_cast<MemTransferInst>(MI))
    AddNonNullPointer(MTI->getRawSource(), PtrSet);
}
654}

656bool LazyValueInfoImpl::isNonNullAtEndOfBlock(Value *Val, BasicBlock *BB) {
if (NullPointerIsDefined(BB->getParent(),
                         Val->getType()->getPointerAddressSpace()))
  return false;

Val = getUnderlyingObject(Val);
return TheCache.isNonNullAtEndOfBlock(Val, BB, [](BasicBlock *BB) {
  NonNullPointerSet NonNullPointers;
  for (Instruction &I : *BB)
    AddNonNullPointersByInstruction(&I, NonNullPointers);
  return NonNullPointers;
});
668}

670Optional<ValueLatticeElement> LazyValueInfoImpl::solveBlockValueNonLocal(
  Value *Val, BasicBlock *BB) {
ValueLatticeElement Result;  // Start Undefined.

// If this is the entry block, we must be asking about an argument.  The
// value is overdefined.
if (BB == &BB->getParent()->getEntryBlock()) {
  assert(isa<Argument>(Val) && "Unknown live-in to the entry block")((isa<Argument>(Val) && "Unknown live-in to the entry block"
) ? static_cast<void> (0) : __assert_fail ("isa<Argument>(Val) && \"Unknown live-in to the entry block\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Analysis/LazyValueInfo.cpp"
, 677, __PRETTY_FUNCTION__));
  return ValueLatticeElement::getOverdefined();
}

// Loop over all of our predecessors, merging what we know from them into
// result.  If we encounter an unexplored predecessor, we eagerly explore it
// in a depth first manner.  In practice, this has the effect of discovering
// paths we can't analyze eagerly without spending compile times analyzing
// other paths.  This heuristic benefits from the fact that predecessors are
// frequently arranged such that dominating ones come first and we quickly
// find a path to function entry.  TODO: We should consider explicitly
// canonicalizing to make this true rather than relying on this happy
// accident.
for (BasicBlock *Pred : predecessors(BB)) {
  Optional<ValueLatticeElement> EdgeResult = getEdgeValue(Val, Pred, BB);
  if (!EdgeResult)
    // Explore that input, then return here
    return None;

  Result.mergeIn(*EdgeResult);

  // If we hit overdefined, exit early.  The BlockVals entry is already set
  // to overdefined.
  if (Result.isOverdefined()) {
    LLVM_DEBUG(dbgs() << " compute BB '" << BB->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("lazy-value-info")) { dbgs() << " compute BB '" <<
 BB->getName() << "' - overdefined because of pred (non local).\n"
; } } while (false)
                      << "' - overdefined because of pred (non local).\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("lazy-value-info")) { dbgs() << " compute BB '" <<
 BB->getName() << "' - overdefined because of pred (non local).\n"
; } } while (false);
    return Result;
  }
}

// Return the merged value, which is more precise than 'overdefined'.
assert(!Result.isOverdefined())((!Result.isOverdefined()) ? static_cast<void> (0) : __assert_fail
 ("!Result.isOverdefined()", "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Analysis/LazyValueInfo.cpp"
, 708, __PRETTY_FUNCTION__));
return Result;
710}

712Optional<ValueLatticeElement> LazyValueInfoImpl::solveBlockValuePHINode(
  PHINode *PN, BasicBlock *BB) {
ValueLatticeElement Result;  // Start Undefined.

// Loop over all of our predecessors, merging what we know from them into
// result.  See the comment about the chosen traversal order in
// solveBlockValueNonLocal; the same reasoning applies here.
for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
  BasicBlock *PhiBB = PN->getIncomingBlock(i);
  Value *PhiVal = PN->getIncomingValue(i);
  // Note that we can provide PN as the context value to getEdgeValue, even
  // though the results will be cached, because PN is the value being used as
  // the cache key in the caller.
  Optional<ValueLatticeElement> EdgeResult =
      getEdgeValue(PhiVal, PhiBB, BB, PN);
  if (!EdgeResult)
    // Explore that input, then return here
    return None;

  Result.mergeIn(*EdgeResult);

  // If we hit overdefined, exit early.  The BlockVals entry is already set
  // to overdefined.
  if (Result.isOverdefined()) {
    LLVM_DEBUG(dbgs() << " compute BB '" << BB->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("lazy-value-info")) { dbgs() << " compute BB '" <<
 BB->getName() << "' - overdefined because of pred (local).\n"
; } } while (false)
                      << "' - overdefined because of pred (local).\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("lazy-value-info")) { dbgs() << " compute BB '" <<
 BB->getName() << "' - overdefined because of pred (local).\n"
; } } while (false);

    return Result;
  }
}

// Return the merged value, which is more precise than 'overdefined'.
assert(!Result.isOverdefined() && "Possible PHI in entry block?")((!Result.isOverdefined() && "Possible PHI in entry block?"
) ? static_cast<void> (0) : __assert_fail ("!Result.isOverdefined() && \"Possible PHI in entry block?\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Analysis/LazyValueInfo.cpp"
, 744, __PRETTY_FUNCTION__));
return Result;
746}

748static ValueLatticeElement getValueFromCondition(Value *Val, Value *Cond,
                                               bool isTrueDest = true);

751// If we can determine a constraint on the value given conditions assumed by
752// the program, intersect those constraints with BBLV
753void LazyValueInfoImpl::intersectAssumeOrGuardBlockValueConstantRange(
      Value *Val, ValueLatticeElement &BBLV, Instruction *BBI) {
BBI = BBI ? BBI : dyn_cast<Instruction>(Val);
if (!BBI)
  return;

BasicBlock *BB = BBI->getParent();
for (auto &AssumeVH : AC->assumptionsFor(Val)) {
  if (!AssumeVH)
    continue;

  // Only check assumes in the block of the context instruction. Other
  // assumes will have already been taken into account when the value was
  // propagated from predecessor blocks.
  auto *I = cast<CallInst>(AssumeVH);
  if (I->getParent() != BB || !isValidAssumeForContext(I, BBI))
    continue;

  BBLV = intersect(BBLV, getValueFromCondition(Val, I->getArgOperand(0)));
}

// If guards are not used in the module, don't spend time looking for them
if (GuardDecl && !GuardDecl->use_empty() &&
    BBI->getIterator() != BB->begin()) {
  for (Instruction &I : make_range(std::next(BBI->getIterator().getReverse()),
                                   BB->rend())) {
    Value *Cond = nullptr;
    if (match(&I, m_Intrinsic<Intrinsic::experimental_guard>(m_Value(Cond))))
      BBLV = intersect(BBLV, getValueFromCondition(Val, Cond));
  }
}

if (BBLV.isOverdefined()) {
  // Check whether we're checking at the terminator, and the pointer has
  // been dereferenced in this block.
  PointerType *PTy = dyn_cast<PointerType>(Val->getType());
  if (PTy && BB->getTerminator() == BBI &&
      isNonNullAtEndOfBlock(Val, BB))
    BBLV = ValueLatticeElement::getNot(ConstantPointerNull::get(PTy));
}
793}

795Optional<ValueLatticeElement> LazyValueInfoImpl::solveBlockValueSelect(
  SelectInst *SI, BasicBlock *BB) {
// Recurse on our inputs if needed
Optional<ValueLatticeElement> OptTrueVal =
    getBlockValue(SI->getTrueValue(), BB);
if (!OptTrueVal)
  return None;
ValueLatticeElement &TrueVal = *OptTrueVal;

Optional<ValueLatticeElement> OptFalseVal =
    getBlockValue(SI->getFalseValue(), BB);
if (!OptFalseVal)
  return None;
ValueLatticeElement &FalseVal = *OptFalseVal;

if (TrueVal.isConstantRange() && FalseVal.isConstantRange()) {
  const ConstantRange &TrueCR = TrueVal.getConstantRange();
  const ConstantRange &FalseCR = FalseVal.getConstantRange();
  Value *LHS = nullptr;
  Value *RHS = nullptr;
  SelectPatternResult SPR = matchSelectPattern(SI, LHS, RHS);
  // Is this a min specifically of our two inputs?  (Avoid the risk of
  // ValueTracking getting smarter looking back past our immediate inputs.)
  if (SelectPatternResult::isMinOrMax(SPR.Flavor) &&
      LHS == SI->getTrueValue() && RHS == SI->getFalseValue()) {
    ConstantRange ResultCR = [&]() {
      switch (SPR.Flavor) {
      default:
        llvm_unreachable("unexpected minmax type!")::llvm::llvm_unreachable_internal("unexpected minmax type!", "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Analysis/LazyValueInfo.cpp"
, 823);
      case SPF_SMIN:                   /// Signed minimum
        return TrueCR.smin(FalseCR);
      case SPF_UMIN:                   /// Unsigned minimum
        return TrueCR.umin(FalseCR);
      case SPF_SMAX:                   /// Signed maximum
        return TrueCR.smax(FalseCR);
      case SPF_UMAX:                   /// Unsigned maximum
        return TrueCR.umax(FalseCR);
      };
    }();
    return ValueLatticeElement::getRange(
        ResultCR, TrueVal.isConstantRangeIncludingUndef() |
                      FalseVal.isConstantRangeIncludingUndef());
  }

  if (SPR.Flavor == SPF_ABS) {
    if (LHS == SI->getTrueValue())
      return ValueLatticeElement::getRange(
          TrueCR.abs(), TrueVal.isConstantRangeIncludingUndef());
    if (LHS == SI->getFalseValue())
      return ValueLatticeElement::getRange(
          FalseCR.abs(), FalseVal.isConstantRangeIncludingUndef());
  }

  if (SPR.Flavor == SPF_NABS) {
    ConstantRange Zero(APInt::getNullValue(TrueCR.getBitWidth()));
    if (LHS == SI->getTrueValue())
      return ValueLatticeElement::getRange(
          Zero.sub(TrueCR.abs()), FalseVal.isConstantRangeIncludingUndef());
    if (LHS == SI->getFalseValue())
      return ValueLatticeElement::getRange(
          Zero.sub(FalseCR.abs()), FalseVal.isConstantRangeIncludingUndef());
  }
}

// Can we constrain the facts about the true and false values by using the
// condition itself?  This shows up with idioms like e.g. select(a > 5, a, 5).
// TODO: We could potentially refine an overdefined true value above.
Value *Cond = SI->getCondition();
TrueVal = intersect(TrueVal,
                    getValueFromCondition(SI->getTrueValue(), Cond, true));
FalseVal = intersect(FalseVal,
                     getValueFromCondition(SI->getFalseValue(), Cond, false));

ValueLatticeElement Result = TrueVal;
Result.mergeIn(FalseVal);
return Result;
871}

873Optional<ConstantRange> LazyValueInfoImpl::getRangeFor(Value *V,
                                                     Instruction *CxtI,
                                                     BasicBlock *BB) {
Optional<ValueLatticeElement> OptVal = getBlockValue(V, BB);
if (!OptVal)
  return None;

ValueLatticeElement &Val = *OptVal;
intersectAssumeOrGuardBlockValueConstantRange(V, Val, CxtI);
if (Val.isConstantRange())
  return Val.getConstantRange();

const unsigned OperandBitWidth = DL.getTypeSizeInBits(V->getType());
return ConstantRange::getFull(OperandBitWidth);
887}

889Optional<ValueLatticeElement> LazyValueInfoImpl::solveBlockValueCast(
  CastInst *CI, BasicBlock *BB) {
// Without knowing how wide the input is, we can't analyze it in any useful
// way.
if (!CI->getOperand(0)->getType()->isSized())
  return ValueLatticeElement::getOverdefined();

// Filter out casts we don't know how to reason about before attempting to
// recurse on our operand.  This can cut a long search short if we know we're
// not going to be able to get any useful information anways.
switch (CI->getOpcode()) {
case Instruction::Trunc:
case Instruction::SExt:
case Instruction::ZExt:
case Instruction::BitCast:
  break;
default:
  // Unhandled instructions are overdefined.
  LLVM_DEBUG(dbgs() << " compute BB '" << BB->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("lazy-value-info")) { dbgs() << " compute BB '" <<
 BB->getName() << "' - overdefined (unknown cast).\n"
; } } while (false)
                    << "' - overdefined (unknown cast).\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("lazy-value-info")) { dbgs() << " compute BB '" <<
 BB->getName() << "' - overdefined (unknown cast).\n"
; } } while (false);
  return ValueLatticeElement::getOverdefined();
}

// Figure out the range of the LHS.  If that fails, we still apply the
// transfer rule on the full set since we may be able to locally infer
// interesting facts.
Optional<ConstantRange> LHSRes = getRangeFor(CI->getOperand(0), CI, BB);
if (!LHSRes.hasValue())
  // More work to do before applying this transfer rule.
  return None;
const ConstantRange &LHSRange = LHSRes.getValue();

const unsigned ResultBitWidth = CI->getType()->getIntegerBitWidth();

// NOTE: We're currently limited by the set of operations that ConstantRange
// can evaluate symbolically.  Enhancing that set will allows us to analyze
// more definitions.
return ValueLatticeElement::getRange(LHSRange.castOp(CI->getOpcode(),
                                                     ResultBitWidth));
928}

930Optional<ValueLatticeElement> LazyValueInfoImpl::solveBlockValueBinaryOpImpl(
  Instruction *I, BasicBlock *BB,
  std::function<ConstantRange(const ConstantRange &,
                              const ConstantRange &)> OpFn) {
// Figure out the ranges of the operands.  If that fails, use a
// conservative range, but apply the transfer rule anyways.  This
// lets us pick up facts from expressions like "and i32 (call i32
// @foo()), 32"
Optional<ConstantRange> LHSRes = getRangeFor(I->getOperand(0), I, BB);
Optional<ConstantRange> RHSRes = getRangeFor(I->getOperand(1), I, BB);
if (!LHSRes.hasValue() || !RHSRes.hasValue())
  // More work to do before applying this transfer rule.
  return None;

const ConstantRange &LHSRange = LHSRes.getValue();
const ConstantRange &RHSRange = RHSRes.getValue();
return ValueLatticeElement::getRange(OpFn(LHSRange, RHSRange));
947}

949Optional<ValueLatticeElement> LazyValueInfoImpl::solveBlockValueBinaryOp(
  BinaryOperator *BO, BasicBlock *BB) {
assert(BO->getOperand(0)->getType()->isSized() &&((BO->getOperand(0)->getType()->isSized() &&
 "all operands to binary operators are sized") ? static_cast<
void> (0) : __assert_fail ("BO->getOperand(0)->getType()->isSized() && \"all operands to binary operators are sized\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Analysis/LazyValueInfo.cpp"
, 952, __PRETTY_FUNCTION__))
       "all operands to binary operators are sized")((BO->getOperand(0)->getType()->isSized() &&
 "all operands to binary operators are sized") ? static_cast<
void> (0) : __assert_fail ("BO->getOperand(0)->getType()->isSized() && \"all operands to binary operators are sized\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Analysis/LazyValueInfo.cpp"
, 952, __PRETTY_FUNCTION__));
if (BO->getOpcode() == Instruction::Xor) {
  // Xor is the only operation not supported by ConstantRange::binaryOp().
  LLVM_DEBUG(dbgs() << " compute BB '" << BB->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("lazy-value-info")) { dbgs() << " compute BB '" <<
 BB->getName() << "' - overdefined (unknown binary operator).\n"
; } } while (false)
                    << "' - overdefined (unknown binary operator).\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("lazy-value-info")) { dbgs() << " compute BB '" <<
 BB->getName() << "' - overdefined (unknown binary operator).\n"
; } } while (false);
  return ValueLatticeElement::getOverdefined();
}

if (auto *OBO = dyn_cast<OverflowingBinaryOperator>(BO)) {
  unsigned NoWrapKind = 0;
  if (OBO->hasNoUnsignedWrap())
    NoWrapKind |= OverflowingBinaryOperator::NoUnsignedWrap;
  if (OBO->hasNoSignedWrap())
    NoWrapKind |= OverflowingBinaryOperator::NoSignedWrap;

  return solveBlockValueBinaryOpImpl(
      BO, BB,
      [BO, NoWrapKind](const ConstantRange &CR1, const ConstantRange &CR2) {
        return CR1.overflowingBinaryOp(BO->getOpcode(), CR2, NoWrapKind);
      });
}

return solveBlockValueBinaryOpImpl(
    BO, BB, [BO](const ConstantRange &CR1, const ConstantRange &CR2) {
      return CR1.binaryOp(BO->getOpcode(), CR2);
    });
978}

980Optional<ValueLatticeElement>
981LazyValueInfoImpl::solveBlockValueOverflowIntrinsic(WithOverflowInst *WO,
                                                  BasicBlock *BB) {
return solveBlockValueBinaryOpImpl(
    WO, BB, [WO](const ConstantRange &CR1, const ConstantRange &CR2) {
      return CR1.binaryOp(WO->getBinaryOp(), CR2);
    });
987}

989Optional<ValueLatticeElement> LazyValueInfoImpl::solveBlockValueIntrinsic(
  IntrinsicInst *II, BasicBlock *BB) {
if (!ConstantRange::isIntrinsicSupported(II->getIntrinsicID())) {
  LLVM_DEBUG(dbgs() << " compute BB '" << BB->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("lazy-value-info")) { dbgs() << " compute BB '" <<
 BB->getName() << "' - unknown intrinsic.\n"; } } while
 (false)
                    << "' - unknown intrinsic.\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("lazy-value-info")) { dbgs() << " compute BB '" <<
 BB->getName() << "' - unknown intrinsic.\n"; } } while
 (false);
  return getFromRangeMetadata(II);
}

SmallVector<ConstantRange, 2> OpRanges;
for (Value *Op : II->args()) {
  Optional<ConstantRange> Range = getRangeFor(Op, II, BB);
  if (!Range)
    return None;
  OpRanges.push_back(*Range);
}

return ValueLatticeElement::getRange(
    ConstantRange::intrinsic(II->getIntrinsicID(), OpRanges));
1007}

1009Optional<ValueLatticeElement> LazyValueInfoImpl::solveBlockValueExtractValue(
  ExtractValueInst *EVI, BasicBlock *BB) {
if (auto *WO = dyn_cast<WithOverflowInst>(EVI->getAggregateOperand()))
  if (EVI->getNumIndices() == 1 && *EVI->idx_begin() == 0)
    return solveBlockValueOverflowIntrinsic(WO, BB);

// Handle extractvalue of insertvalue to allow further simplification
// based on replaced with.overflow intrinsics.
if (Value *V = SimplifyExtractValueInst(
        EVI->getAggregateOperand(), EVI->getIndices(),
        EVI->getModule()->getDataLayout()))
  return getBlockValue(V, BB);

LLVM_DEBUG(dbgs() << " compute BB '" << BB->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("lazy-value-info")) { dbgs() << " compute BB '" <<
 BB->getName() << "' - overdefined (unknown extractvalue).\n"
; } } while (false)
                  << "' - overdefined (unknown extractvalue).\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("lazy-value-info")) { dbgs() << " compute BB '" <<
 BB->getName() << "' - overdefined (unknown extractvalue).\n"
; } } while (false);
return ValueLatticeElement::getOverdefined();
1025}

1027static bool matchICmpOperand(APInt &Offset, Value *LHS, Value *Val,
                           ICmpInst::Predicate Pred) {
if (LHS == Val)
  return true;

// Handle range checking idiom produced by InstCombine. We will subtract the
// offset from the allowed range for RHS in this case.
const APInt *C;
if (match(LHS, m_Add(m_Specific(Val), m_APInt(C)))) {
  Offset = *C;
  return true;
}

// Handle the symmetric case. This appears in saturation patterns like
// (x == 16) ? 16 : (x + 1).
if (match(Val, m_Add(m_Specific(LHS), m_APInt(C)))) {
  Offset = -*C;
  return true;
}

// If (x | y) < C, then (x < C) && (y < C).
if (match(LHS, m_c_Or(m_Specific(Val), m_Value())) &&
    (Pred == ICmpInst::ICMP_ULT || Pred == ICmpInst::ICMP_ULE))
  return true;

// If (x & y) > C, then (x > C) && (y > C).
if (match(LHS, m_c_And(m_Specific(Val), m_Value())) &&
    (Pred == ICmpInst::ICMP_UGT || Pred == ICmpInst::ICMP_UGE))
  return true;

return false;
1058}

1060/// Get value range for a "(Val + Offset) Pred RHS" condition.
1061static ValueLatticeElement getValueFromSimpleICmpCondition(
  CmpInst::Predicate Pred, Value *RHS, const APInt &Offset) {
ConstantRange RHSRange(RHS->getType()->getIntegerBitWidth(),
                       /*isFullSet=*/true);
if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS))
  RHSRange = ConstantRange(CI->getValue());
else if (Instruction *I = dyn_cast<Instruction>(RHS))
  if (auto *Ranges = I->getMetadata(LLVMContext::MD_range))
    RHSRange = getConstantRangeFromMetadata(*Ranges);

ConstantRange TrueValues =
    ConstantRange::makeAllowedICmpRegion(Pred, RHSRange);
return ValueLatticeElement::getRange(TrueValues.subtract(Offset));
1074}

1076static ValueLatticeElement getValueFromICmpCondition(Value *Val, ICmpInst *ICI,
                                                   bool isTrueDest) {
Value *LHS = ICI->getOperand(0);
Value *RHS = ICI->getOperand(1);

// Get the predicate that must hold along the considered edge.
CmpInst::Predicate EdgePred =
    isTrueDest ? ICI->getPredicate() : ICI->getInversePredicate();

if (isa<Constant>(RHS)) {
  if (ICI->isEquality() && LHS == Val) {
    if (EdgePred == ICmpInst::ICMP_EQ)
      return ValueLatticeElement::get(cast<Constant>(RHS));
    else if (!isa<UndefValue>(RHS))
      return ValueLatticeElement::getNot(cast<Constant>(RHS));
  }
}

Type *Ty = Val->getType();
if (!Ty->isIntegerTy())
  return ValueLatticeElement::getOverdefined();

APInt Offset(Ty->getScalarSizeInBits(), 0);
if (matchICmpOperand(Offset, LHS, Val, EdgePred))
  return getValueFromSimpleICmpCondition(EdgePred, RHS, Offset);

CmpInst::Predicate SwappedPred = CmpInst::getSwappedPredicate(EdgePred);
if (matchICmpOperand(Offset, RHS, Val, SwappedPred))
  return getValueFromSimpleICmpCondition(SwappedPred, LHS, Offset);

// If (Val & Mask) == C then all the masked bits are known and we can compute
// a value range based on that.
const APInt *Mask, *C;
if (EdgePred == ICmpInst::ICMP_EQ &&
    match(LHS, m_And(m_Specific(Val), m_APInt(Mask))) &&
    match(RHS, m_APInt(C))) {
  KnownBits Known;
  Known.Zero = ~*C & *Mask;
  Known.One = *C & *Mask;
  return ValueLatticeElement::getRange(
      ConstantRange::fromKnownBits(Known, /*IsSigned*/ false));
}

return ValueLatticeElement::getOverdefined();
1120}

1122// Handle conditions of the form
1123// extractvalue(op.with.overflow(%x, C), 1).
1124static ValueLatticeElement getValueFromOverflowCondition(
  Value *Val, WithOverflowInst *WO, bool IsTrueDest) {
// TODO: This only works with a constant RHS for now. We could also compute
// the range of the RHS, but this doesn't fit into the current structure of
// the edge value calculation.
const APInt *C;
if (WO->getLHS() != Val || !match(WO->getRHS(), m_APInt(C)))
  return ValueLatticeElement::getOverdefined();

// Calculate the possible values of %x for which no overflow occurs.
ConstantRange NWR = ConstantRange::makeExactNoWrapRegion(
    WO->getBinaryOp(), *C, WO->getNoWrapKind());

// If overflow is false, %x is constrained to NWR. If overflow is true, %x is
// constrained to it's inverse (all values that might cause overflow).
if (IsTrueDest)
  NWR = NWR.inverse();
return ValueLatticeElement::getRange(NWR);
1142}

1144static ValueLatticeElement
1145getValueFromCondition(Value *Val, Value *Cond, bool isTrueDest,
                    SmallDenseMap<Value*, ValueLatticeElement> &Visited);

1148static ValueLatticeElement
1149getValueFromConditionImpl(Value *Val, Value *Cond, bool isTrueDest,
                        SmallDenseMap<Value*, ValueLatticeElement> &Visited) {
if (ICmpInst *ICI = dyn_cast<ICmpInst>(Cond))
  return getValueFromICmpCondition(Val, ICI, isTrueDest);

if (auto *EVI = dyn_cast<ExtractValueInst>(Cond))
  if (auto *WO = dyn_cast<WithOverflowInst>(EVI->getAggregateOperand()))
    if (EVI->getNumIndices() == 1 && *EVI->idx_begin() == 1)
      return getValueFromOverflowCondition(Val, WO, isTrueDest);

Value *L, *R;
bool IsAnd;
if (match(Cond, m_LogicalAnd(m_Value(L), m_Value(R))))
  IsAnd = true;
else if (match(Cond, m_LogicalOr(m_Value(L), m_Value(R))))
  IsAnd = false;
else
  return ValueLatticeElement::getOverdefined();

// Prevent infinite recursion if Cond references itself as in this example:
//  Cond: "%tmp4 = and i1 %tmp4, undef"
//    BL: "%tmp4 = and i1 %tmp4, undef"
//    BR: "i1 undef"
if (L == Cond || R == Cond)
  return ValueLatticeElement::getOverdefined();

// if (L && R) -> intersect L and R
// if (!(L || R)) -> intersect L and R
// if (L || R) -> union L and R
// if (!(L && R)) -> union L and R
if (isTrueDest ^ IsAnd) {
  ValueLatticeElement V = getValueFromCondition(Val, L, isTrueDest, Visited);
  if (V.isOverdefined())
    return V;
  V.mergeIn(getValueFromCondition(Val, R, isTrueDest, Visited));
  return V;
}

return intersect(getValueFromCondition(Val, L, isTrueDest, Visited),
                 getValueFromCondition(Val, R, isTrueDest, Visited));
1189}

1191static ValueLatticeElement
1192getValueFromCondition(Value *Val, Value *Cond, bool isTrueDest,
                    SmallDenseMap<Value*, ValueLatticeElement> &Visited) {
auto I = Visited.find(Cond);
if (I != Visited.end())
  return I->second;

auto Result = getValueFromConditionImpl(Val, Cond, isTrueDest, Visited);
Visited[Cond] = Result;
return Result;
1201}

1203ValueLatticeElement getValueFromCondition(Value *Val, Value *Cond,
                                        bool isTrueDest) {
assert(Cond && "precondition")((Cond && "precondition") ? static_cast<void> (
0) : __assert_fail ("Cond && \"precondition\"", "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Analysis/LazyValueInfo.cpp"
, 1205, __PRETTY_FUNCTION__));
SmallDenseMap<Value*, ValueLatticeElement> Visited;
return getValueFromCondition(Val, Cond, isTrueDest, Visited);
1208}

1210// Return true if Usr has Op as an operand, otherwise false.
1211static bool usesOperand(User *Usr, Value *Op) {
return is_contained(Usr->operands(), Op);
1213}

1215// Return true if the instruction type of Val is supported by
1216// constantFoldUser(). Currently CastInst, BinaryOperator and FreezeInst only.
1217// Call this before calling constantFoldUser() to find out if it's even worth
1218// attempting to call it.
1219static bool isOperationFoldable(User *Usr) {
return isa<CastInst>(Usr) || isa<BinaryOperator>(Usr) || isa<FreezeInst>(Usr);
1221}

1223// Check if Usr can be simplified to an integer constant when the value of one
1224// of its operands Op is an integer constant OpConstVal. If so, return it as an
1225// lattice value range with a single element or otherwise return an overdefined
1226// lattice value.
1227static ValueLatticeElement constantFoldUser(User *Usr, Value *Op,
                                          const APInt &OpConstVal,
                                          const DataLayout &DL) {
assert(isOperationFoldable(Usr) && "Precondition")((isOperationFoldable(Usr) && "Precondition") ? static_cast
<void> (0) : __assert_fail ("isOperationFoldable(Usr) && \"Precondition\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Analysis/LazyValueInfo.cpp"
, 1230, __PRETTY_FUNCTION__));
Constant* OpConst = Constant::getIntegerValue(Op->getType(), OpConstVal);
// Check if Usr can be simplified to a constant.
if (auto *CI = dyn_cast<CastInst>(Usr)) {
  assert(CI->getOperand(0) == Op && "Operand 0 isn't Op")((CI->getOperand(0) == Op && "Operand 0 isn't Op")
 ? static_cast<void> (0) : __assert_fail ("CI->getOperand(0) == Op && \"Operand 0 isn't Op\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Analysis/LazyValueInfo.cpp"
, 1234, __PRETTY_FUNCTION__));
  if (auto *C = dyn_cast_or_null<ConstantInt>(
          SimplifyCastInst(CI->getOpcode(), OpConst,
                           CI->getDestTy(), DL))) {
    return ValueLatticeElement::getRange(ConstantRange(C->getValue()));
  }
} else if (auto *BO = dyn_cast<BinaryOperator>(Usr)) {
  bool Op0Match = BO->getOperand(0) == Op;
  bool Op1Match = BO->getOperand(1) == Op;
  assert((Op0Match || Op1Match) &&(((Op0Match || Op1Match) && "Operand 0 nor Operand 1 isn't a match"
) ? static_cast<void> (0) : __assert_fail ("(Op0Match || Op1Match) && \"Operand 0 nor Operand 1 isn't a match\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Analysis/LazyValueInfo.cpp"
, 1244, __PRETTY_FUNCTION__))
         "Operand 0 nor Operand 1 isn't a match")(((Op0Match || Op1Match) && "Operand 0 nor Operand 1 isn't a match"
) ? static_cast<void> (0) : __assert_fail ("(Op0Match || Op1Match) && \"Operand 0 nor Operand 1 isn't a match\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Analysis/LazyValueInfo.cpp"
, 1244, __PRETTY_FUNCTION__));
  Value *LHS = Op0Match ? OpConst : BO->getOperand(0);
  Value *RHS = Op1Match ? OpConst : BO->getOperand(1);
  if (auto *C = dyn_cast_or_null<ConstantInt>(
          SimplifyBinOp(BO->getOpcode(), LHS, RHS, DL))) {
    return ValueLatticeElement::getRange(ConstantRange(C->getValue()));
  }
} else if (isa<FreezeInst>(Usr)) {
  assert(cast<FreezeInst>(Usr)->getOperand(0) == Op && "Operand 0 isn't Op")((cast<FreezeInst>(Usr)->getOperand(0) == Op &&
 "Operand 0 isn't Op") ? static_cast<void> (0) : __assert_fail
 ("cast<FreezeInst>(Usr)->getOperand(0) == Op && \"Operand 0 isn't Op\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Analysis/LazyValueInfo.cpp"
, 1252, __PRETTY_FUNCTION__));
  return ValueLatticeElement::getRange(ConstantRange(OpConstVal));
}
return ValueLatticeElement::getOverdefined();
1256}

1258/// Compute the value of Val on the edge BBFrom -> BBTo. Returns false if
1259/// Val is not constrained on the edge.  Result is unspecified if return value
1260/// is false.
1261static Optional<ValueLatticeElement> getEdgeValueLocal(Value *Val,
                                                     BasicBlock *BBFrom,
                                                     BasicBlock *BBTo) {
// TODO: Handle more complex conditionals. If (v == 0 || v2 < 1) is false, we
// know that v != 0.
if (BranchInst *BI11.1
'BI' is non-null
1
'BI' is non-null
1
'BI' is non-null
 = dyn_cast<BranchInst>(BBFrom->getTerminator())) {
11
←
Assuming the object is a 'BranchInst'→
12
←
Taking true branch→
  // If this is a conditional branch and only one successor goes to BBTo, then
  // we may be able to infer something from the condition.
  if (BI->isConditional() &&
13
←
Calling 'BranchInst::isConditional'→
16
←
Returning from 'BranchInst::isConditional'→
17
←
Taking true branch→
      BI->getSuccessor(0) != BI->getSuccessor(1)) {
    bool isTrueDest = BI->getSuccessor(0) == BBTo;
18
←
Assuming pointer value is null→
    assert(BI->getSuccessor(!isTrueDest) == BBTo &&((BI->getSuccessor(!isTrueDest) == BBTo && "BBTo isn't a successor of BBFrom"
) ? static_cast<void> (0) : __assert_fail ("BI->getSuccessor(!isTrueDest) == BBTo && \"BBTo isn't a successor of BBFrom\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Analysis/LazyValueInfo.cpp"
, 1273, __PRETTY_FUNCTION__))
19
←
'?' condition is true→
           "BBTo isn't a successor of BBFrom")((BI->getSuccessor(!isTrueDest) == BBTo && "BBTo isn't a successor of BBFrom"
) ? static_cast<void> (0) : __assert_fail ("BI->getSuccessor(!isTrueDest) == BBTo && \"BBTo isn't a successor of BBFrom\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Analysis/LazyValueInfo.cpp"
, 1273, __PRETTY_FUNCTION__));
    Value *Condition = BI->getCondition();

    // If V is the condition of the branch itself, then we know exactly what
    // it is.
    if (Condition == Val)
20
←
Assuming 'Condition' is not equal to 'Val'→
21
←
Taking false branch→
      return ValueLatticeElement::get(ConstantInt::get(
                            Type::getInt1Ty(Val->getContext()), isTrueDest));

    // If the condition of the branch is an equality comparison, we may be
    // able to infer the value.
    ValueLatticeElement Result = getValueFromCondition(Val, Condition,
                                                       isTrueDest);
    if (!Result.isOverdefined())
22
←
Calling 'ValueLatticeElement::isOverdefined'→
25
←
Returning from 'ValueLatticeElement::isOverdefined'→
26
←
Taking false branch→
      return Result;

    if (User *Usr27.1
'Usr' is non-null
1
'Usr' is non-null
1
'Usr' is non-null
 = dyn_cast<User>(Val)) {
27
←
Assuming 'Val' is a 'User'→
28
←
Taking true branch→
      assert(Result.isOverdefined() && "Result isn't overdefined")((Result.isOverdefined() && "Result isn't overdefined"
) ? static_cast<void> (0) : __assert_fail ("Result.isOverdefined() && \"Result isn't overdefined\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Analysis/LazyValueInfo.cpp"
, 1290, __PRETTY_FUNCTION__));
29
←
'?' condition is true→
      // Check with isOperationFoldable() first to avoid linearly iterating
      // over the operands unnecessarily which can be expensive for
      // instructions with many operands.
      if (isa<IntegerType>(Usr->getType()) && isOperationFoldable(Usr)) {
30
←
Assuming the object is a 'IntegerType'→
31
←
Taking true branch→
        const DataLayout &DL = BBTo->getModule()->getDataLayout();
32
←
Called C++ object pointer is null
        if (usesOperand(Usr, Condition)) {
          // If Val has Condition as an operand and Val can be folded into a
          // constant with either Condition == true or Condition == false,
          // propagate the constant.
          // eg.
          //   ; %Val is true on the edge to %then.
          //   %Val = and i1 %Condition, true.
          //   br %Condition, label %then, label %else
          APInt ConditionVal(1, isTrueDest ? 1 : 0);
          Result = constantFoldUser(Usr, Condition, ConditionVal, DL);
        } else {
          // If one of Val's operand has an inferred value, we may be able to
          // infer the value of Val.
          // eg.
          //    ; %Val is 94 on the edge to %then.
          //    %Val = add i8 %Op, 1
          //    %Condition = icmp eq i8 %Op, 93
          //    br i1 %Condition, label %then, label %else
          for (unsigned i = 0; i < Usr->getNumOperands(); ++i) {
            Value *Op = Usr->getOperand(i);
            ValueLatticeElement OpLatticeVal =
                getValueFromCondition(Op, Condition, isTrueDest);
            if (Optional<APInt> OpConst = OpLatticeVal.asConstantInteger()) {
              Result = constantFoldUser(Usr, Op, OpConst.getValue(), DL);
              break;
            }
          }
        }
      }
    }
    if (!Result.isOverdefined())
      return Result;
  }
}

// If the edge was formed by a switch on the value, then we may know exactly
// what it is.
if (SwitchInst *SI = dyn_cast<SwitchInst>(BBFrom->getTerminator())) {
  Value *Condition = SI->getCondition();
  if (!isa<IntegerType>(Val->getType()))
    return None;
  bool ValUsesConditionAndMayBeFoldable = false;
  if (Condition != Val) {
    // Check if Val has Condition as an operand.
    if (User *Usr = dyn_cast<User>(Val))
      ValUsesConditionAndMayBeFoldable = isOperationFoldable(Usr) &&
          usesOperand(Usr, Condition);
    if (!ValUsesConditionAndMayBeFoldable)
      return None;
  }
  assert((Condition == Val || ValUsesConditionAndMayBeFoldable) &&(((Condition == Val || ValUsesConditionAndMayBeFoldable) &&
 "Condition != Val nor Val doesn't use Condition") ? static_cast
<void> (0) : __assert_fail ("(Condition == Val || ValUsesConditionAndMayBeFoldable) && \"Condition != Val nor Val doesn't use Condition\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Analysis/LazyValueInfo.cpp"
, 1347, __PRETTY_FUNCTION__))
         "Condition != Val nor Val doesn't use Condition")(((Condition == Val || ValUsesConditionAndMayBeFoldable) &&
 "Condition != Val nor Val doesn't use Condition") ? static_cast
<void> (0) : __assert_fail ("(Condition == Val || ValUsesConditionAndMayBeFoldable) && \"Condition != Val nor Val doesn't use Condition\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Analysis/LazyValueInfo.cpp"
, 1347, __PRETTY_FUNCTION__));

  bool DefaultCase = SI->getDefaultDest() == BBTo;
  unsigned BitWidth = Val->getType()->getIntegerBitWidth();
  ConstantRange EdgesVals(BitWidth, DefaultCase/*isFullSet*/);

  for (auto Case : SI->cases()) {
    APInt CaseValue = Case.getCaseValue()->getValue();
    ConstantRange EdgeVal(CaseValue);
    if (ValUsesConditionAndMayBeFoldable) {
      User *Usr = cast<User>(Val);
      const DataLayout &DL = BBTo->getModule()->getDataLayout();
      ValueLatticeElement EdgeLatticeVal =
          constantFoldUser(Usr, Condition, CaseValue, DL);
      if (EdgeLatticeVal.isOverdefined())
        return None;
      EdgeVal = EdgeLatticeVal.getConstantRange();
    }
    if (DefaultCase) {
      // It is possible that the default destination is the destination of
      // some cases. We cannot perform difference for those cases.
      // We know Condition != CaseValue in BBTo.  In some cases we can use
      // this to infer Val == f(Condition) is != f(CaseValue).  For now, we
      // only do this when f is identity (i.e. Val == Condition), but we
      // should be able to do this for any injective f.
      if (Case.getCaseSuccessor() != BBTo && Condition == Val)
        EdgesVals = EdgesVals.difference(EdgeVal);
    } else if (Case.getCaseSuccessor() == BBTo)
      EdgesVals = EdgesVals.unionWith(EdgeVal);
  }
  return ValueLatticeElement::getRange(std::move(EdgesVals));
}
return None;
1380}

1382/// Compute the value of Val on the edge BBFrom -> BBTo or the value at
1383/// the basic block if the edge does not constrain Val.
1384Optional<ValueLatticeElement> LazyValueInfoImpl::getEdgeValue(
  Value *Val, BasicBlock *BBFrom, BasicBlock *BBTo, Instruction *CxtI) {
// If already a constant, there is nothing to compute.
if (Constant *VC7.1
'VC' is null
1
'VC' is null
1
'VC' is null
 = dyn_cast<Constant>(Val))
7
←
Assuming 'Val' is not a 'Constant'→
8
←
Taking false branch→
  return ValueLatticeElement::get(VC);

ValueLatticeElement LocalResult = getEdgeValueLocal(Val, BBFrom, BBTo)
9
←
Passing value via 3rd parameter 'BBTo'→
10
←
Calling 'getEdgeValueLocal'→
    .getValueOr(ValueLatticeElement::getOverdefined());
if (hasSingleValue(LocalResult))
  // Can't get any more precise here
  return LocalResult;

Optional<ValueLatticeElement> OptInBlock = getBlockValue(Val, BBFrom);
if (!OptInBlock)
  return None;
ValueLatticeElement &InBlock = *OptInBlock;

// Try to intersect ranges of the BB and the constraint on the edge.
intersectAssumeOrGuardBlockValueConstantRange(Val, InBlock,
                                              BBFrom->getTerminator());
// We can use the context instruction (generically the ultimate instruction
// the calling pass is trying to simplify) here, even though the result of
// this function is generally cached when called from the solve* functions
// (and that cached result might be used with queries using a different
// context instruction), because when this function is called from the solve*
// functions, the context instruction is not provided. When called from
// LazyValueInfoImpl::getValueOnEdge, the context instruction is provided,
// but then the result is not cached.
intersectAssumeOrGuardBlockValueConstantRange(Val, InBlock, CxtI);

return intersect(LocalResult, InBlock);
1415}

1417ValueLatticeElement LazyValueInfoImpl::getValueInBlock(Value *V, BasicBlock *BB,
                                                     Instruction *CxtI) {
LLVM_DEBUG(dbgs() << "LVI Getting block end value " << *V << " at '"do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("lazy-value-info")) { dbgs() << "LVI Getting block end value "
 << *V << " at '" << BB->getName() <<
 "'\n"; } } while (false)
                  << BB->getName() << "'\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("lazy-value-info")) { dbgs() << "LVI Getting block end value "
 << *V << " at '" << BB->getName() <<
 "'\n"; } } while (false);

assert(BlockValueStack.empty() && BlockValueSet.empty())((BlockValueStack.empty() && BlockValueSet.empty()) ?
 static_cast<void> (0) : __assert_fail ("BlockValueStack.empty() && BlockValueSet.empty()"
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Analysis/LazyValueInfo.cpp"
, 1422, __PRETTY_FUNCTION__));
Optional<ValueLatticeElement> OptResult = getBlockValue(V, BB);
if (!OptResult) {
  solve();
  OptResult = getBlockValue(V, BB);
  assert(OptResult && "Value not available after solving")((OptResult && "Value not available after solving") ?
 static_cast<void> (0) : __assert_fail ("OptResult && \"Value not available after solving\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Analysis/LazyValueInfo.cpp"
, 1427, __PRETTY_FUNCTION__));
}
ValueLatticeElement Result = *OptResult;
intersectAssumeOrGuardBlockValueConstantRange(V, Result, CxtI);

LLVM_DEBUG(dbgs() << "  Result = " << Result << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("lazy-value-info")) { dbgs() << "  Result = " <<
 Result << "\n"; } } while (false);
return Result;
1434}

1436ValueLatticeElement LazyValueInfoImpl::getValueAt(Value *V, Instruction *CxtI) {
LLVM_DEBUG(dbgs() << "LVI Getting value " << *V << " at '" << CxtI->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("lazy-value-info")) { dbgs() << "LVI Getting value " <<
 *V << " at '" << CxtI->getName() << "'\n"
; } } while (false)
                  << "'\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("lazy-value-info")) { dbgs() << "LVI Getting value " <<
 *V << " at '" << CxtI->getName() << "'\n"
; } } while (false);

if (auto *C = dyn_cast<Constant>(V))
  return ValueLatticeElement::get(C);

ValueLatticeElement Result = ValueLatticeElement::getOverdefined();
if (auto *I = dyn_cast<Instruction>(V))
  Result = getFromRangeMetadata(I);
intersectAssumeOrGuardBlockValueConstantRange(V, Result, CxtI);

LLVM_DEBUG(dbgs() << "  Result = " << Result << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("lazy-value-info")) { dbgs() << "  Result = " <<
 Result << "\n"; } } while (false);
return Result;
1450}

1452ValueLatticeElement LazyValueInfoImpl::
1453getValueOnEdge(Value *V, BasicBlock *FromBB, BasicBlock *ToBB,
             Instruction *CxtI) {
LLVM_DEBUG(dbgs() << "LVI Getting edge value " << *V << " from '"do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("lazy-value-info")) { dbgs() << "LVI Getting edge value "
 << *V << " from '" << FromBB->getName()
 << "' to '" << ToBB->getName() << "'\n"
; } } while (false)
3
←
Assuming 'DebugFlag' is false→
4
←
Loop condition is false.  Exiting loop→
                  << FromBB->getName() << "' to '" << ToBB->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("lazy-value-info")) { dbgs() << "LVI Getting edge value "
 << *V << " from '" << FromBB->getName()
 << "' to '" << ToBB->getName() << "'\n"
; } } while (false)
                  << "'\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("lazy-value-info")) { dbgs() << "LVI Getting edge value "
 << *V << " from '" << FromBB->getName()
 << "' to '" << ToBB->getName() << "'\n"
; } } while (false);

Optional<ValueLatticeElement> Result = getEdgeValue(V, FromBB, ToBB, CxtI);
5
←
Passing value via 3rd parameter 'BBTo'→
6
←
Calling 'LazyValueInfoImpl::getEdgeValue'→
if (!Result) {
  solve();
  Result = getEdgeValue(V, FromBB, ToBB, CxtI);
  assert(Result && "More work to do after problem solved?")((Result && "More work to do after problem solved?") ?
 static_cast<void> (0) : __assert_fail ("Result && \"More work to do after problem solved?\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Analysis/LazyValueInfo.cpp"
, 1463, __PRETTY_FUNCTION__));
}

LLVM_DEBUG(dbgs() << "  Result = " << *Result << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("lazy-value-info")) { dbgs() << "  Result = " <<
 *Result << "\n"; } } while (false);
return *Result;
1468}

1470void LazyValueInfoImpl::threadEdge(BasicBlock *PredBB, BasicBlock *OldSucc,
                                 BasicBlock *NewSucc) {
TheCache.threadEdgeImpl(OldSucc, NewSucc);
1473}

1475//===----------------------------------------------------------------------===//
1476//                            LazyValueInfo Impl
1477//===----------------------------------------------------------------------===//

1479/// This lazily constructs the LazyValueInfoImpl.
1480static LazyValueInfoImpl &getImpl(void *&PImpl, AssumptionCache *AC,
                                const Module *M) {
if (!PImpl) {
  assert(M && "getCache() called with a null Module")((M && "getCache() called with a null Module") ? static_cast
<void> (0) : __assert_fail ("M && \"getCache() called with a null Module\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Analysis/LazyValueInfo.cpp"
, 1483, __PRETTY_FUNCTION__));
  const DataLayout &DL = M->getDataLayout();
  Function *GuardDecl = M->getFunction(
      Intrinsic::getName(Intrinsic::experimental_guard));
  PImpl = new LazyValueInfoImpl(AC, DL, GuardDecl);
}
return *static_cast<LazyValueInfoImpl*>(PImpl);
1490}

1492bool LazyValueInfoWrapperPass::runOnFunction(Function &F) {
Info.AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
Info.TLI = &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(F);

if (Info.PImpl)
  getImpl(Info.PImpl, Info.AC, F.getParent()).clear();

// Fully lazy.
return false;
1501}

1503void LazyValueInfoWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
AU.setPreservesAll();
AU.addRequired<AssumptionCacheTracker>();
AU.addRequired<TargetLibraryInfoWrapperPass>();
1507}

1509LazyValueInfo &LazyValueInfoWrapperPass::getLVI() { return Info; }

1511LazyValueInfo::~LazyValueInfo() { releaseMemory(); }

1513void LazyValueInfo::releaseMemory() {
// If the cache was allocated, free it.
if (PImpl) {
  delete &getImpl(PImpl, AC, nullptr);
  PImpl = nullptr;
}
1519}

1521bool LazyValueInfo::invalidate(Function &F, const PreservedAnalyses &PA,
                             FunctionAnalysisManager::Invalidator &Inv) {
// We need to invalidate if we have either failed to preserve this analyses
// result directly or if any of its dependencies have been invalidated.
auto PAC = PA.getChecker<LazyValueAnalysis>();
if (!(PAC.preserved() || PAC.preservedSet<AllAnalysesOn<Function>>()))
  return true;

return false;
1530}

1532void LazyValueInfoWrapperPass::releaseMemory() { Info.releaseMemory(); }

1534LazyValueInfo LazyValueAnalysis::run(Function &F,
                                   FunctionAnalysisManager &FAM) {
auto &AC = FAM.getResult<AssumptionAnalysis>(F);
auto &TLI = FAM.getResult<TargetLibraryAnalysis>(F);

return LazyValueInfo(&AC, &F.getParent()->getDataLayout(), &TLI);
1540}

1542/// Returns true if we can statically tell that this value will never be a
1543/// "useful" constant.  In practice, this means we've got something like an
1544/// alloca or a malloc call for which a comparison against a constant can
1545/// only be guarding dead code.  Note that we are potentially giving up some
1546/// precision in dead code (a constant result) in favour of avoiding a
1547/// expensive search for a easily answered common query.
1548static bool isKnownNonConstant(Value *V) {
V = V->stripPointerCasts();
// The return val of alloc cannot be a Constant.
if (isa<AllocaInst>(V))
  return true;
return false;
1554}

1556Constant *LazyValueInfo::getConstant(Value *V, Instruction *CxtI) {
// Bail out early if V is known not to be a Constant.
if (isKnownNonConstant(V))
  return nullptr;

BasicBlock *BB = CxtI->getParent();
ValueLatticeElement Result =
    getImpl(PImpl, AC, BB->getModule()).getValueInBlock(V, BB, CxtI);

if (Result.isConstant())
  return Result.getConstant();
if (Result.isConstantRange()) {
  const ConstantRange &CR = Result.getConstantRange();
  if (const APInt *SingleVal = CR.getSingleElement())
    return ConstantInt::get(V->getContext(), *SingleVal);
}
return nullptr;
1573}

1575ConstantRange LazyValueInfo::getConstantRange(Value *V, Instruction *CxtI,
                                            bool UndefAllowed) {
assert(V->getType()->isIntegerTy())((V->getType()->isIntegerTy()) ? static_cast<void>
 (0) : __assert_fail ("V->getType()->isIntegerTy()", "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Analysis/LazyValueInfo.cpp"
, 1577, __PRETTY_FUNCTION__));
unsigned Width = V->getType()->getIntegerBitWidth();
BasicBlock *BB = CxtI->getParent();
ValueLatticeElement Result =
    getImpl(PImpl, AC, BB->getModule()).getValueInBlock(V, BB, CxtI);
if (Result.isUnknown())
  return ConstantRange::getEmpty(Width);
if (Result.isConstantRange(UndefAllowed))
  return Result.getConstantRange(UndefAllowed);
// We represent ConstantInt constants as constant ranges but other kinds
// of integer constants, i.e. ConstantExpr will be tagged as constants
assert(!(Result.isConstant() && isa<ConstantInt>(Result.getConstant())) &&((!(Result.isConstant() && isa<ConstantInt>(Result
.getConstant())) && "ConstantInt value must be represented as constantrange"
) ? static_cast<void> (0) : __assert_fail ("!(Result.isConstant() && isa<ConstantInt>(Result.getConstant())) && \"ConstantInt value must be represented as constantrange\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Analysis/LazyValueInfo.cpp"
, 1589, __PRETTY_FUNCTION__))
       "ConstantInt value must be represented as constantrange")((!(Result.isConstant() && isa<ConstantInt>(Result
.getConstant())) && "ConstantInt value must be represented as constantrange"
) ? static_cast<void> (0) : __assert_fail ("!(Result.isConstant() && isa<ConstantInt>(Result.getConstant())) && \"ConstantInt value must be represented as constantrange\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Analysis/LazyValueInfo.cpp"
, 1589, __PRETTY_FUNCTION__));
return ConstantRange::getFull(Width);
1591}

1593/// Determine whether the specified value is known to be a
1594/// constant on the specified edge. Return null if not.
1595Constant *LazyValueInfo::getConstantOnEdge(Value *V, BasicBlock *FromBB,
                                         BasicBlock *ToBB,
                                         Instruction *CxtI) {
Module *M = FromBB->getModule();
ValueLatticeElement Result =
    getImpl(PImpl, AC, M).getValueOnEdge(V, FromBB, ToBB, CxtI);

if (Result.isConstant())
  return Result.getConstant();
if (Result.isConstantRange()) {
  const ConstantRange &CR = Result.getConstantRange();
  if (const APInt *SingleVal = CR.getSingleElement())
    return ConstantInt::get(V->getContext(), *SingleVal);
}
return nullptr;
1610}

1612ConstantRange LazyValueInfo::getConstantRangeOnEdge(Value *V,
                                                  BasicBlock *FromBB,
                                                  BasicBlock *ToBB,
                                                  Instruction *CxtI) {
unsigned Width = V->getType()->getIntegerBitWidth();
Module *M = FromBB->getModule();
ValueLatticeElement Result =
    getImpl(PImpl, AC, M).getValueOnEdge(V, FromBB, ToBB, CxtI);
1
Passing value via 3rd parameter 'ToBB'→
2
←
Calling 'LazyValueInfoImpl::getValueOnEdge'→

if (Result.isUnknown())
  return ConstantRange::getEmpty(Width);
if (Result.isConstantRange())
  return Result.getConstantRange();
// We represent ConstantInt constants as constant ranges but other kinds
// of integer constants, i.e. ConstantExpr will be tagged as constants
assert(!(Result.isConstant() && isa<ConstantInt>(Result.getConstant())) &&((!(Result.isConstant() && isa<ConstantInt>(Result
.getConstant())) && "ConstantInt value must be represented as constantrange"
) ? static_cast<void> (0) : __assert_fail ("!(Result.isConstant() && isa<ConstantInt>(Result.getConstant())) && \"ConstantInt value must be represented as constantrange\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Analysis/LazyValueInfo.cpp"
, 1628, __PRETTY_FUNCTION__))
       "ConstantInt value must be represented as constantrange")((!(Result.isConstant() && isa<ConstantInt>(Result
.getConstant())) && "ConstantInt value must be represented as constantrange"
) ? static_cast<void> (0) : __assert_fail ("!(Result.isConstant() && isa<ConstantInt>(Result.getConstant())) && \"ConstantInt value must be represented as constantrange\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Analysis/LazyValueInfo.cpp"
, 1628, __PRETTY_FUNCTION__));
return ConstantRange::getFull(Width);
1630}

1632static LazyValueInfo::Tristate
1633getPredicateResult(unsigned Pred, Constant *C, const ValueLatticeElement &Val,
                 const DataLayout &DL, TargetLibraryInfo *TLI) {
// If we know the value is a constant, evaluate the conditional.
Constant *Res = nullptr;
if (Val.isConstant()) {
  Res = ConstantFoldCompareInstOperands(Pred, Val.getConstant(), C, DL, TLI);
  if (ConstantInt *ResCI = dyn_cast<ConstantInt>(Res))
    return ResCI->isZero() ? LazyValueInfo::False : LazyValueInfo::True;
  return LazyValueInfo::Unknown;
}

if (Val.isConstantRange()) {
  ConstantInt *CI = dyn_cast<ConstantInt>(C);
  if (!CI) return LazyValueInfo::Unknown;

  const ConstantRange &CR = Val.getConstantRange();
  if (Pred == ICmpInst::ICMP_EQ) {
    if (!CR.contains(CI->getValue()))
      return LazyValueInfo::False;

    if (CR.isSingleElement())
      return LazyValueInfo::True;
  } else if (Pred == ICmpInst::ICMP_NE) {
    if (!CR.contains(CI->getValue()))
      return LazyValueInfo::True;

    if (CR.isSingleElement())
      return LazyValueInfo::False;
  } else {
    // Handle more complex predicates.
    ConstantRange TrueValues = ConstantRange::makeExactICmpRegion(
        (ICmpInst::Predicate)Pred, CI->getValue());
    if (TrueValues.contains(CR))
      return LazyValueInfo::True;
    if (TrueValues.inverse().contains(CR))
      return LazyValueInfo::False;
  }
  return LazyValueInfo::Unknown;
}

if (Val.isNotConstant()) {
  // If this is an equality comparison, we can try to fold it knowing that
  // "V != C1".
  if (Pred == ICmpInst::ICMP_EQ) {
    // !C1 == C -> false iff C1 == C.
    Res = ConstantFoldCompareInstOperands(ICmpInst::ICMP_NE,
                                          Val.getNotConstant(), C, DL,
                                          TLI);
    if (Res->isNullValue())
      return LazyValueInfo::False;
  } else if (Pred == ICmpInst::ICMP_NE) {
    // !C1 != C -> true iff C1 == C.
    Res = ConstantFoldCompareInstOperands(ICmpInst::ICMP_NE,
                                          Val.getNotConstant(), C, DL,
                                          TLI);
    if (Res->isNullValue())
      return LazyValueInfo::True;
  }
  return LazyValueInfo::Unknown;
}

return LazyValueInfo::Unknown;
1695}

1697/// Determine whether the specified value comparison with a constant is known to
1698/// be true or false on the specified CFG edge. Pred is a CmpInst predicate.
1699LazyValueInfo::Tristate
1700LazyValueInfo::getPredicateOnEdge(unsigned Pred, Value *V, Constant *C,
                                BasicBlock *FromBB, BasicBlock *ToBB,
                                Instruction *CxtI) {
Module *M = FromBB->getModule();
ValueLatticeElement Result =
    getImpl(PImpl, AC, M).getValueOnEdge(V, FromBB, ToBB, CxtI);

return getPredicateResult(Pred, C, Result, M->getDataLayout(), TLI);
1708}

1710LazyValueInfo::Tristate
1711LazyValueInfo::getPredicateAt(unsigned Pred, Value *V, Constant *C,
                            Instruction *CxtI, bool UseBlockValue) {
// Is or is not NonNull are common predicates being queried. If
// isKnownNonZero can tell us the result of the predicate, we can
// return it quickly. But this is only a fastpath, and falling
// through would still be correct.
Module *M = CxtI->getModule();
const DataLayout &DL = M->getDataLayout();
if (V->getType()->isPointerTy() && C->isNullValue() &&
    isKnownNonZero(V->stripPointerCastsSameRepresentation(), DL)) {
  if (Pred == ICmpInst::ICMP_EQ)
    return LazyValueInfo::False;
  else if (Pred == ICmpInst::ICMP_NE)
    return LazyValueInfo::True;
}

ValueLatticeElement Result = UseBlockValue
    ? getImpl(PImpl, AC, M).getValueInBlock(V, CxtI->getParent(), CxtI)
    : getImpl(PImpl, AC, M).getValueAt(V, CxtI);
Tristate Ret = getPredicateResult(Pred, C, Result, DL, TLI);
if (Ret != Unknown)
  return Ret;

// Note: The following bit of code is somewhat distinct from the rest of LVI;
// LVI as a whole tries to compute a lattice value which is conservatively
// correct at a given location.  In this case, we have a predicate which we
// weren't able to prove about the merged result, and we're pushing that
// predicate back along each incoming edge to see if we can prove it
// separately for each input.  As a motivating example, consider:
// bb1:
//   %v1 = ... ; constantrange<1, 5>
//   br label %merge
// bb2:
//   %v2 = ... ; constantrange<10, 20>
//   br label %merge
// merge:
//   %phi = phi [%v1, %v2] ; constantrange<1,20>
//   %pred = icmp eq i32 %phi, 8
// We can't tell from the lattice value for '%phi' that '%pred' is false
// along each path, but by checking the predicate over each input separately,
// we can.
// We limit the search to one step backwards from the current BB and value.
// We could consider extending this to search further backwards through the
// CFG and/or value graph, but there are non-obvious compile time vs quality
// tradeoffs.
if (CxtI) {
  BasicBlock *BB = CxtI->getParent();

  // Function entry or an unreachable block.  Bail to avoid confusing
  // analysis below.
  pred_iterator PI = pred_begin(BB), PE = pred_end(BB);
  if (PI == PE)
    return Unknown;

  // If V is a PHI node in the same block as the context, we need to ask
  // questions about the predicate as applied to the incoming value along
  // each edge. This is useful for eliminating cases where the predicate is
  // known along all incoming edges.
  if (auto *PHI = dyn_cast<PHINode>(V))
    if (PHI->getParent() == BB) {
      Tristate Baseline = Unknown;
      for (unsigned i = 0, e = PHI->getNumIncomingValues(); i < e; i++) {
        Value *Incoming = PHI->getIncomingValue(i);
        BasicBlock *PredBB = PHI->getIncomingBlock(i);
        // Note that PredBB may be BB itself.
        Tristate Result = getPredicateOnEdge(Pred, Incoming, C, PredBB, BB,
                                             CxtI);

        // Keep going as long as we've seen a consistent known result for
        // all inputs.
        Baseline = (i == 0) ? Result /* First iteration */
          : (Baseline == Result ? Baseline : Unknown); /* All others */
        if (Baseline == Unknown)
          break;
      }
      if (Baseline != Unknown)
        return Baseline;
    }

  // For a comparison where the V is outside this block, it's possible
  // that we've branched on it before. Look to see if the value is known
  // on all incoming edges.
  if (!isa<Instruction>(V) ||
      cast<Instruction>(V)->getParent() != BB) {
    // For predecessor edge, determine if the comparison is true or false
    // on that edge. If they're all true or all false, we can conclude
    // the value of the comparison in this block.
    Tristate Baseline = getPredicateOnEdge(Pred, V, C, *PI, BB, CxtI);
    if (Baseline != Unknown) {
      // Check that all remaining incoming values match the first one.
      while (++PI != PE) {
        Tristate Ret = getPredicateOnEdge(Pred, V, C, *PI, BB, CxtI);
        if (Ret != Baseline) break;
      }
      // If we terminated early, then one of the values didn't match.
      if (PI == PE) {
        return Baseline;
      }
    }
  }
}
return Unknown;
1813}

1815void LazyValueInfo::threadEdge(BasicBlock *PredBB, BasicBlock *OldSucc,
                             BasicBlock *NewSucc) {
if (PImpl) {
  getImpl(PImpl, AC, PredBB->getModule())
      .threadEdge(PredBB, OldSucc, NewSucc);
}
1821}

1823void LazyValueInfo::eraseBlock(BasicBlock *BB) {
if (PImpl) {
  getImpl(PImpl, AC, BB->getModule()).eraseBlock(BB);
}
1827}


1830void LazyValueInfo::printLVI(Function &F, DominatorTree &DTree, raw_ostream &OS) {
if (PImpl) {
  getImpl(PImpl, AC, F.getParent()).printLVI(F, DTree, OS);
}
1834}

1836// Print the LVI for the function arguments at the start of each basic block.
1837void LazyValueInfoAnnotatedWriter::emitBasicBlockStartAnnot(
  const BasicBlock *BB, formatted_raw_ostream &OS) {
// Find if there are latticevalues defined for arguments of the function.
auto *F = BB->getParent();
for (auto &Arg : F->args()) {
  ValueLatticeElement Result = LVIImpl->getValueInBlock(
      const_cast<Argument *>(&Arg), const_cast<BasicBlock *>(BB));
  if (Result.isUnknown())
    continue;
  OS << "; LatticeVal for: '" << Arg << "' is: " << Result << "\n";
}
1848}

1850// This function prints the LVI analysis for the instruction I at the beginning
1851// of various basic blocks. It relies on calculated values that are stored in
1852// the LazyValueInfoCache, and in the absence of cached values, recalculate the
1853// LazyValueInfo for `I`, and print that info.
1854void LazyValueInfoAnnotatedWriter::emitInstructionAnnot(
  const Instruction *I, formatted_raw_ostream &OS) {

auto *ParentBB = I->getParent();
SmallPtrSet<const BasicBlock*, 16> BlocksContainingLVI;
// We can generate (solve) LVI values only for blocks that are dominated by
// the I's parent. However, to avoid generating LVI for all dominating blocks,
// that contain redundant/uninteresting information, we print LVI for
// blocks that may use this LVI information (such as immediate successor
// blocks, and blocks that contain uses of `I`).
auto printResult = [&](const BasicBlock *BB) {
  if (!BlocksContainingLVI.insert(BB).second)
    return;
  ValueLatticeElement Result = LVIImpl->getValueInBlock(
      const_cast<Instruction *>(I), const_cast<BasicBlock *>(BB));
    OS << "; LatticeVal for: '" << *I << "' in BB: '";
    BB->printAsOperand(OS, false);
    OS << "' is: " << Result << "\n";
};

printResult(ParentBB);
// Print the LVI analysis results for the immediate successor blocks, that
// are dominated by `ParentBB`.
for (auto *BBSucc : successors(ParentBB))
  if (DT.dominates(ParentBB, BBSucc))
    printResult(BBSucc);

// Print LVI in blocks where `I` is used.
for (auto *U : I->users())
  if (auto *UseI = dyn_cast<Instruction>(U))
    if (!isa<PHINode>(UseI) || DT.dominates(ParentBB, UseI->getParent()))
      printResult(UseI->getParent());

1887}

1889namespace {
1890// Printer class for LazyValueInfo results.
1891class LazyValueInfoPrinter : public FunctionPass {
1892public:
static char ID; // Pass identification, replacement for typeid
LazyValueInfoPrinter() : FunctionPass(ID) {
  initializeLazyValueInfoPrinterPass(*PassRegistry::getPassRegistry());
}

void getAnalysisUsage(AnalysisUsage &AU) const override {
  AU.setPreservesAll();
  AU.addRequired<LazyValueInfoWrapperPass>();
  AU.addRequired<DominatorTreeWrapperPass>();
}

// Get the mandatory dominator tree analysis and pass this in to the
// LVIPrinter. We cannot rely on the LVI's DT, since it's optional.
bool runOnFunction(Function &F) override {
  dbgs() << "LVI for function '" << F.getName() << "':\n";
  auto &LVI = getAnalysis<LazyValueInfoWrapperPass>().getLVI();
  auto &DTree = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
  LVI.printLVI(F, DTree, dbgs());
  return false;
}
1913};
1914}

1916char LazyValueInfoPrinter::ID = 0;
1917INITIALIZE_PASS_BEGIN(LazyValueInfoPrinter, "print-lazy-value-info",static void *initializeLazyValueInfoPrinterPassOnce(PassRegistry
 &Registry) {
              "Lazy Value Info Printer Pass", false, false)static void *initializeLazyValueInfoPrinterPassOnce(PassRegistry
 &Registry) {
1919INITIALIZE_PASS_DEPENDENCY(LazyValueInfoWrapperPass)initializeLazyValueInfoWrapperPassPass(Registry);
1920INITIALIZE_PASS_END(LazyValueInfoPrinter, "print-lazy-value-info",PassInfo *PI = new PassInfo( "Lazy Value Info Printer Pass", "print-lazy-value-info"
, &LazyValueInfoPrinter::ID, PassInfo::NormalCtor_t(callDefaultCtor
<LazyValueInfoPrinter>), false, false); Registry.registerPass
(*PI, true); return PI; } static llvm::once_flag InitializeLazyValueInfoPrinterPassFlag
; void llvm::initializeLazyValueInfoPrinterPass(PassRegistry &
Registry) { llvm::call_once(InitializeLazyValueInfoPrinterPassFlag
, initializeLazyValueInfoPrinterPassOnce, std::ref(Registry))
; }
              "Lazy Value Info Printer Pass", false, false)PassInfo *PI = new PassInfo( "Lazy Value Info Printer Pass", "print-lazy-value-info"
, &LazyValueInfoPrinter::ID, PassInfo::NormalCtor_t(callDefaultCtor
<LazyValueInfoPrinter>), false, false); Registry.registerPass
(*PI, true); return PI; } static llvm::once_flag InitializeLazyValueInfoPrinterPassFlag
; void llvm::initializeLazyValueInfoPrinterPass(PassRegistry &
Registry) { llvm::call_once(InitializeLazyValueInfoPrinterPassFlag
, initializeLazyValueInfoPrinterPassOnce, std::ref(Registry))
; }

←

/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h

→

1//===- llvm/Instructions.h - Instruction subclass definitions ---*- 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 exposes the class definitions of all of the subclasses of the
10// Instruction class.  This is meant to be an easy way to get access to all
11// instruction subclasses.
12//
13//===----------------------------------------------------------------------===//

15#ifndef LLVM_IR_INSTRUCTIONS_H
16#define LLVM_IR_INSTRUCTIONS_H

18#include "llvm/ADT/ArrayRef.h"
19#include "llvm/ADT/Bitfields.h"
20#include "llvm/ADT/None.h"
21#include "llvm/ADT/STLExtras.h"
22#include "llvm/ADT/SmallVector.h"
23#include "llvm/ADT/StringRef.h"
24#include "llvm/ADT/Twine.h"
25#include "llvm/ADT/iterator.h"
26#include "llvm/ADT/iterator_range.h"
27#include "llvm/IR/Attributes.h"
28#include "llvm/IR/BasicBlock.h"
29#include "llvm/IR/CallingConv.h"
30#include "llvm/IR/CFG.h"
31#include "llvm/IR/Constant.h"
32#include "llvm/IR/DerivedTypes.h"
33#include "llvm/IR/Function.h"
34#include "llvm/IR/InstrTypes.h"
35#include "llvm/IR/Instruction.h"
36#include "llvm/IR/OperandTraits.h"
37#include "llvm/IR/Type.h"
38#include "llvm/IR/Use.h"
39#include "llvm/IR/User.h"
40#include "llvm/IR/Value.h"
41#include "llvm/Support/AtomicOrdering.h"
42#include "llvm/Support/Casting.h"
43#include "llvm/Support/ErrorHandling.h"
44#include <cassert>
45#include <cstddef>
46#include <cstdint>
47#include <iterator>

49namespace llvm {

51class APInt;
52class ConstantInt;
53class DataLayout;
54class LLVMContext;

56//===----------------------------------------------------------------------===//
57//                                AllocaInst Class
58//===----------------------------------------------------------------------===//

60/// an instruction to allocate memory on the stack
61class AllocaInst : public UnaryInstruction {
Type *AllocatedType;

using AlignmentField = AlignmentBitfieldElementT<0>;
using UsedWithInAllocaField = BoolBitfieldElementT<AlignmentField::NextBit>;
using SwiftErrorField = BoolBitfieldElementT<UsedWithInAllocaField::NextBit>;
static_assert(Bitfield::areContiguous<AlignmentField, UsedWithInAllocaField,
                                      SwiftErrorField>(),
              "Bitfields must be contiguous");

71protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

AllocaInst *cloneImpl() const;

77public:
explicit AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize,
                    const Twine &Name, Instruction *InsertBefore);
AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize,
           const Twine &Name, BasicBlock *InsertAtEnd);

AllocaInst(Type *Ty, unsigned AddrSpace, const Twine &Name,
           Instruction *InsertBefore);
AllocaInst(Type *Ty, unsigned AddrSpace,
           const Twine &Name, BasicBlock *InsertAtEnd);

AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize, Align Align,
           const Twine &Name = "", Instruction *InsertBefore = nullptr);
AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize, Align Align,
           const Twine &Name, BasicBlock *InsertAtEnd);

/// Return true if there is an allocation size parameter to the allocation
/// instruction that is not 1.
bool isArrayAllocation() const;

/// Get the number of elements allocated. For a simple allocation of a single
/// element, this will return a constant 1 value.
const Value *getArraySize() const { return getOperand(0); }
Value *getArraySize() { return getOperand(0); }

/// Overload to return most specific pointer type.
PointerType *getType() const {
  return cast<PointerType>(Instruction::getType());
}

/// Get allocation size in bits. Returns None if size can't be determined,
/// e.g. in case of a VLA.
Optional<TypeSize> getAllocationSizeInBits(const DataLayout &DL) const;

/// Return the type that is being allocated by the instruction.
Type *getAllocatedType() const { return AllocatedType; }
/// for use only in special circumstances that need to generically
/// transform a whole instruction (eg: IR linking and vectorization).
void setAllocatedType(Type *Ty) { AllocatedType = Ty; }

/// Return the alignment of the memory that is being allocated by the
/// instruction.
Align getAlign() const {
  return Align(1ULL << getSubclassData<AlignmentField>());
}

void setAlignment(Align Align) {
  setSubclassData<AlignmentField>(Log2(Align));
}

// FIXME: Remove this one transition to Align is over.
unsigned getAlignment() const { return getAlign().value(); }

/// Return true if this alloca is in the entry block of the function and is a
/// constant size. If so, the code generator will fold it into the
/// prolog/epilog code, so it is basically free.
bool isStaticAlloca() const;

/// Return true if this alloca is used as an inalloca argument to a call. Such
/// allocas are never considered static even if they are in the entry block.
bool isUsedWithInAlloca() const {
  return getSubclassData<UsedWithInAllocaField>();
}

/// Specify whether this alloca is used to represent the arguments to a call.
void setUsedWithInAlloca(bool V) {
  setSubclassData<UsedWithInAllocaField>(V);
}

/// Return true if this alloca is used as a swifterror argument to a call.
bool isSwiftError() const { return getSubclassData<SwiftErrorField>(); }
/// Specify whether this alloca is used to represent a swifterror.
void setSwiftError(bool V) { setSubclassData<SwiftErrorField>(V); }

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return (I->getOpcode() == Instruction::Alloca);
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}

159private:
// Shadow Instruction::setInstructionSubclassData with a private forwarding
// method so that subclasses cannot accidentally use it.
template <typename Bitfield>
void setSubclassData(typename Bitfield::Type Value) {
  Instruction::setSubclassData<Bitfield>(Value);
}
166};

168//===----------------------------------------------------------------------===//
169//                                LoadInst Class
170//===----------------------------------------------------------------------===//

172/// An instruction for reading from memory. This uses the SubclassData field in
173/// Value to store whether or not the load is volatile.
174class LoadInst : public UnaryInstruction {
using VolatileField = BoolBitfieldElementT<0>;
using AlignmentField = AlignmentBitfieldElementT<VolatileField::NextBit>;
using OrderingField = AtomicOrderingBitfieldElementT<AlignmentField::NextBit>;
static_assert(
    Bitfield::areContiguous<VolatileField, AlignmentField, OrderingField>(),
    "Bitfields must be contiguous");

void AssertOK();

184protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

LoadInst *cloneImpl() const;

190public:
LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr,
         Instruction *InsertBefore);
LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, BasicBlock *InsertAtEnd);
LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
         Instruction *InsertBefore);
LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
         BasicBlock *InsertAtEnd);
LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
         Align Align, Instruction *InsertBefore = nullptr);
LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
         Align Align, BasicBlock *InsertAtEnd);
LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
         Align Align, AtomicOrdering Order,
         SyncScope::ID SSID = SyncScope::System,
         Instruction *InsertBefore = nullptr);
LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
         Align Align, AtomicOrdering Order, SyncScope::ID SSID,
         BasicBlock *InsertAtEnd);

/// Return true if this is a load from a volatile memory location.
bool isVolatile() const { return getSubclassData<VolatileField>(); }

/// Specify whether this is a volatile load or not.
void setVolatile(bool V) { setSubclassData<VolatileField>(V); }

/// Return the alignment of the access that is being performed.
/// FIXME: Remove this function once transition to Align is over.
/// Use getAlign() instead.
unsigned getAlignment() const { return getAlign().value(); }

/// Return the alignment of the access that is being performed.
Align getAlign() const {
  return Align(1ULL << (getSubclassData<AlignmentField>()));
}

void setAlignment(Align Align) {
  setSubclassData<AlignmentField>(Log2(Align));
}

/// Returns the ordering constraint of this load instruction.
AtomicOrdering getOrdering() const {
  return getSubclassData<OrderingField>();
}
/// Sets the ordering constraint of this load instruction.  May not be Release
/// or AcquireRelease.
void setOrdering(AtomicOrdering Ordering) {
  setSubclassData<OrderingField>(Ordering);
}

/// Returns the synchronization scope ID of this load instruction.
SyncScope::ID getSyncScopeID() const {
  return SSID;
}

/// Sets the synchronization scope ID of this load instruction.
void setSyncScopeID(SyncScope::ID SSID) {
  this->SSID = SSID;
}

/// Sets the ordering constraint and the synchronization scope ID of this load
/// instruction.
void setAtomic(AtomicOrdering Ordering,
               SyncScope::ID SSID = SyncScope::System) {
  setOrdering(Ordering);
  setSyncScopeID(SSID);
}

bool isSimple() const { return !isAtomic() && !isVolatile(); }

bool isUnordered() const {
  return (getOrdering() == AtomicOrdering::NotAtomic ||
          getOrdering() == AtomicOrdering::Unordered) &&
         !isVolatile();
}

Value *getPointerOperand() { return getOperand(0); }
const Value *getPointerOperand() const { return getOperand(0); }
static unsigned getPointerOperandIndex() { return 0U; }
Type *getPointerOperandType() const { return getPointerOperand()->getType(); }

/// Returns the address space of the pointer operand.
unsigned getPointerAddressSpace() const {
  return getPointerOperandType()->getPointerAddressSpace();
}

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::Load;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}

284private:
// Shadow Instruction::setInstructionSubclassData with a private forwarding
// method so that subclasses cannot accidentally use it.
template <typename Bitfield>
void setSubclassData(typename Bitfield::Type Value) {
  Instruction::setSubclassData<Bitfield>(Value);
}

/// The synchronization scope ID of this load instruction.  Not quite enough
/// room in SubClassData for everything, so synchronization scope ID gets its
/// own field.
SyncScope::ID SSID;
296};

298//===----------------------------------------------------------------------===//
299//                                StoreInst Class
300//===----------------------------------------------------------------------===//

302/// An instruction for storing to memory.
303class StoreInst : public Instruction {
using VolatileField = BoolBitfieldElementT<0>;
using AlignmentField = AlignmentBitfieldElementT<VolatileField::NextBit>;
using OrderingField = AtomicOrderingBitfieldElementT<AlignmentField::NextBit>;
static_assert(
    Bitfield::areContiguous<VolatileField, AlignmentField, OrderingField>(),
    "Bitfields must be contiguous");

void AssertOK();

313protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

StoreInst *cloneImpl() const;

319public:
StoreInst(Value *Val, Value *Ptr, Instruction *InsertBefore);
StoreInst(Value *Val, Value *Ptr, BasicBlock *InsertAtEnd);
StoreInst(Value *Val, Value *Ptr, bool isVolatile, Instruction *InsertBefore);
StoreInst(Value *Val, Value *Ptr, bool isVolatile, BasicBlock *InsertAtEnd);
StoreInst(Value *Val, Value *Ptr, bool isVolatile, Align Align,
          Instruction *InsertBefore = nullptr);
StoreInst(Value *Val, Value *Ptr, bool isVolatile, Align Align,
          BasicBlock *InsertAtEnd);
StoreInst(Value *Val, Value *Ptr, bool isVolatile, Align Align,
          AtomicOrdering Order, SyncScope::ID SSID = SyncScope::System,
          Instruction *InsertBefore = nullptr);
StoreInst(Value *Val, Value *Ptr, bool isVolatile, Align Align,
          AtomicOrdering Order, SyncScope::ID SSID, BasicBlock *InsertAtEnd);

// allocate space for exactly two operands
void *operator new(size_t s) {
  return User::operator new(s, 2);
}

/// Return true if this is a store to a volatile memory location.
bool isVolatile() const { return getSubclassData<VolatileField>(); }

/// Specify whether this is a volatile store or not.
void setVolatile(bool V) { setSubclassData<VolatileField>(V); }

/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
 setOperand(unsigned, Value*); inline op_iterator op_begin();
 inline const_op_iterator op_begin() const; inline op_iterator
 op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
 getNumOperands() const;

/// Return the alignment of the access that is being performed
/// FIXME: Remove this function once transition to Align is over.
/// Use getAlign() instead.
unsigned getAlignment() const { return getAlign().value(); }

Align getAlign() const {
  return Align(1ULL << (getSubclassData<AlignmentField>()));
}

void setAlignment(Align Align) {
  setSubclassData<AlignmentField>(Log2(Align));
}

/// Returns the ordering constraint of this store instruction.
AtomicOrdering getOrdering() const {
  return getSubclassData<OrderingField>();
}

/// Sets the ordering constraint of this store instruction.  May not be
/// Acquire or AcquireRelease.
void setOrdering(AtomicOrdering Ordering) {
  setSubclassData<OrderingField>(Ordering);
}

/// Returns the synchronization scope ID of this store instruction.
SyncScope::ID getSyncScopeID() const {
  return SSID;
}

/// Sets the synchronization scope ID of this store instruction.
void setSyncScopeID(SyncScope::ID SSID) {
  this->SSID = SSID;
}

/// Sets the ordering constraint and the synchronization scope ID of this
/// store instruction.
void setAtomic(AtomicOrdering Ordering,
               SyncScope::ID SSID = SyncScope::System) {
  setOrdering(Ordering);
  setSyncScopeID(SSID);
}

bool isSimple() const { return !isAtomic() && !isVolatile(); }

bool isUnordered() const {
  return (getOrdering() == AtomicOrdering::NotAtomic ||
          getOrdering() == AtomicOrdering::Unordered) &&
         !isVolatile();
}

Value *getValueOperand() { return getOperand(0); }
const Value *getValueOperand() const { return getOperand(0); }

Value *getPointerOperand() { return getOperand(1); }
const Value *getPointerOperand() const { return getOperand(1); }
static unsigned getPointerOperandIndex() { return 1U; }
Type *getPointerOperandType() const { return getPointerOperand()->getType(); }

/// Returns the address space of the pointer operand.
unsigned getPointerAddressSpace() const {
  return getPointerOperandType()->getPointerAddressSpace();
}

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::Store;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}

419private:
// Shadow Instruction::setInstructionSubclassData with a private forwarding
// method so that subclasses cannot accidentally use it.
template <typename Bitfield>
void setSubclassData(typename Bitfield::Type Value) {
  Instruction::setSubclassData<Bitfield>(Value);
}

/// The synchronization scope ID of this store instruction.  Not quite enough
/// room in SubClassData for everything, so synchronization scope ID gets its
/// own field.
SyncScope::ID SSID;
431};

433template <>
434struct OperandTraits<StoreInst> : public FixedNumOperandTraits<StoreInst, 2> {
435};

437DEFINE_TRANSPARENT_OPERAND_ACCESSORS(StoreInst, Value)StoreInst::op_iterator StoreInst::op_begin() { return OperandTraits
<StoreInst>::op_begin(this); } StoreInst::const_op_iterator
 StoreInst::op_begin() const { return OperandTraits<StoreInst
>::op_begin(const_cast<StoreInst*>(this)); } StoreInst
::op_iterator StoreInst::op_end() { return OperandTraits<StoreInst
>::op_end(this); } StoreInst::const_op_iterator StoreInst::
op_end() const { return OperandTraits<StoreInst>::op_end
(const_cast<StoreInst*>(this)); } Value *StoreInst::getOperand
(unsigned i_nocapture) const { ((i_nocapture < OperandTraits
<StoreInst>::operands(this) && "getOperand() out of range!"
) ? static_cast<void> (0) : __assert_fail ("i_nocapture < OperandTraits<StoreInst>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 437, __PRETTY_FUNCTION__)); return cast_or_null<Value>
( OperandTraits<StoreInst>::op_begin(const_cast<StoreInst
*>(this))[i_nocapture].get()); } void StoreInst::setOperand
(unsigned i_nocapture, Value *Val_nocapture) { ((i_nocapture <
 OperandTraits<StoreInst>::operands(this) && "setOperand() out of range!"
) ? static_cast<void> (0) : __assert_fail ("i_nocapture < OperandTraits<StoreInst>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 437, __PRETTY_FUNCTION__)); OperandTraits<StoreInst>::
op_begin(this)[i_nocapture] = Val_nocapture; } unsigned StoreInst
::getNumOperands() const { return OperandTraits<StoreInst>
::operands(this); } template <int Idx_nocapture> Use &
StoreInst::Op() { return this->OpFrom<Idx_nocapture>
(this); } template <int Idx_nocapture> const Use &StoreInst
::Op() const { return this->OpFrom<Idx_nocapture>(this
); }

439//===----------------------------------------------------------------------===//
440//                                FenceInst Class
441//===----------------------------------------------------------------------===//

443/// An instruction for ordering other memory operations.
444class FenceInst : public Instruction {
using OrderingField = AtomicOrderingBitfieldElementT<0>;

void Init(AtomicOrdering Ordering, SyncScope::ID SSID);

449protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

FenceInst *cloneImpl() const;

455public:
// Ordering may only be Acquire, Release, AcquireRelease, or
// SequentiallyConsistent.
FenceInst(LLVMContext &C, AtomicOrdering Ordering,
          SyncScope::ID SSID = SyncScope::System,
          Instruction *InsertBefore = nullptr);
FenceInst(LLVMContext &C, AtomicOrdering Ordering, SyncScope::ID SSID,
          BasicBlock *InsertAtEnd);

// allocate space for exactly zero operands
void *operator new(size_t s) {
  return User::operator new(s, 0);
}

/// Returns the ordering constraint of this fence instruction.
AtomicOrdering getOrdering() const {
  return getSubclassData<OrderingField>();
}

/// Sets the ordering constraint of this fence instruction.  May only be
/// Acquire, Release, AcquireRelease, or SequentiallyConsistent.
void setOrdering(AtomicOrdering Ordering) {
  setSubclassData<OrderingField>(Ordering);
}

/// Returns the synchronization scope ID of this fence instruction.
SyncScope::ID getSyncScopeID() const {
  return SSID;
}

/// Sets the synchronization scope ID of this fence instruction.
void setSyncScopeID(SyncScope::ID SSID) {
  this->SSID = SSID;
}

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::Fence;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}

498private:
// Shadow Instruction::setInstructionSubclassData with a private forwarding
// method so that subclasses cannot accidentally use it.
template <typename Bitfield>
void setSubclassData(typename Bitfield::Type Value) {
  Instruction::setSubclassData<Bitfield>(Value);
}

/// The synchronization scope ID of this fence instruction.  Not quite enough
/// room in SubClassData for everything, so synchronization scope ID gets its
/// own field.
SyncScope::ID SSID;
510};

512//===----------------------------------------------------------------------===//
513//                                AtomicCmpXchgInst Class
514//===----------------------------------------------------------------------===//

516/// An instruction that atomically checks whether a
517/// specified value is in a memory location, and, if it is, stores a new value
518/// there. The value returned by this instruction is a pair containing the
519/// original value as first element, and an i1 indicating success (true) or
520/// failure (false) as second element.
521///
522class AtomicCmpXchgInst : public Instruction {
void Init(Value *Ptr, Value *Cmp, Value *NewVal, Align Align,
          AtomicOrdering SuccessOrdering, AtomicOrdering FailureOrdering,
          SyncScope::ID SSID);

template <unsigned Offset>
using AtomicOrderingBitfieldElement =
    typename Bitfield::Element<AtomicOrdering, Offset, 3,
                               AtomicOrdering::LAST>;

532protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

AtomicCmpXchgInst *cloneImpl() const;

538public:
AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal, Align Alignment,
                  AtomicOrdering SuccessOrdering,
                  AtomicOrdering FailureOrdering, SyncScope::ID SSID,
                  Instruction *InsertBefore = nullptr);
AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal, Align Alignment,
                  AtomicOrdering SuccessOrdering,
                  AtomicOrdering FailureOrdering, SyncScope::ID SSID,
                  BasicBlock *InsertAtEnd);

// allocate space for exactly three operands
void *operator new(size_t s) {
  return User::operator new(s, 3);
}

using VolatileField = BoolBitfieldElementT<0>;
using WeakField = BoolBitfieldElementT<VolatileField::NextBit>;
using SuccessOrderingField =
    AtomicOrderingBitfieldElementT<WeakField::NextBit>;
using FailureOrderingField =
    AtomicOrderingBitfieldElementT<SuccessOrderingField::NextBit>;
using AlignmentField =
    AlignmentBitfieldElementT<FailureOrderingField::NextBit>;
static_assert(
    Bitfield::areContiguous<VolatileField, WeakField, SuccessOrderingField,
                            FailureOrderingField, AlignmentField>(),
    "Bitfields must be contiguous");

/// Return the alignment of the memory that is being allocated by the
/// instruction.
Align getAlign() const {
  return Align(1ULL << getSubclassData<AlignmentField>());
}

void setAlignment(Align Align) {
  setSubclassData<AlignmentField>(Log2(Align));
}

/// Return true if this is a cmpxchg from a volatile memory
/// location.
///
bool isVolatile() const { return getSubclassData<VolatileField>(); }

/// Specify whether this is a volatile cmpxchg.
///
void setVolatile(bool V) { setSubclassData<VolatileField>(V); }

/// Return true if this cmpxchg may spuriously fail.
bool isWeak() const { return getSubclassData<WeakField>(); }

void setWeak(bool IsWeak) { setSubclassData<WeakField>(IsWeak); }

/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
 setOperand(unsigned, Value*); inline op_iterator op_begin();
 inline const_op_iterator op_begin() const; inline op_iterator
 op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
 getNumOperands() const;

/// Returns the success ordering constraint of this cmpxchg instruction.
AtomicOrdering getSuccessOrdering() const {
  return getSubclassData<SuccessOrderingField>();
}

/// Sets the success ordering constraint of this cmpxchg instruction.
void setSuccessOrdering(AtomicOrdering Ordering) {
  assert(Ordering != AtomicOrdering::NotAtomic &&((Ordering != AtomicOrdering::NotAtomic && "CmpXchg instructions can only be atomic."
) ? static_cast<void> (0) : __assert_fail ("Ordering != AtomicOrdering::NotAtomic && \"CmpXchg instructions can only be atomic.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 601, __PRETTY_FUNCTION__))
         "CmpXchg instructions can only be atomic.")((Ordering != AtomicOrdering::NotAtomic && "CmpXchg instructions can only be atomic."
) ? static_cast<void> (0) : __assert_fail ("Ordering != AtomicOrdering::NotAtomic && \"CmpXchg instructions can only be atomic.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 601, __PRETTY_FUNCTION__));
  setSubclassData<SuccessOrderingField>(Ordering);
}

/// Returns the failure ordering constraint of this cmpxchg instruction.
AtomicOrdering getFailureOrdering() const {
  return getSubclassData<FailureOrderingField>();
}

/// Sets the failure ordering constraint of this cmpxchg instruction.
void setFailureOrdering(AtomicOrdering Ordering) {
  assert(Ordering != AtomicOrdering::NotAtomic &&((Ordering != AtomicOrdering::NotAtomic && "CmpXchg instructions can only be atomic."
) ? static_cast<void> (0) : __assert_fail ("Ordering != AtomicOrdering::NotAtomic && \"CmpXchg instructions can only be atomic.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 613, __PRETTY_FUNCTION__))
         "CmpXchg instructions can only be atomic.")((Ordering != AtomicOrdering::NotAtomic && "CmpXchg instructions can only be atomic."
) ? static_cast<void> (0) : __assert_fail ("Ordering != AtomicOrdering::NotAtomic && \"CmpXchg instructions can only be atomic.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 613, __PRETTY_FUNCTION__));
  setSubclassData<FailureOrderingField>(Ordering);
}

/// Returns the synchronization scope ID of this cmpxchg instruction.
SyncScope::ID getSyncScopeID() const {
  return SSID;
}

/// Sets the synchronization scope ID of this cmpxchg instruction.
void setSyncScopeID(SyncScope::ID SSID) {
  this->SSID = SSID;
}

Value *getPointerOperand() { return getOperand(0); }
const Value *getPointerOperand() const { return getOperand(0); }
static unsigned getPointerOperandIndex() { return 0U; }

Value *getCompareOperand() { return getOperand(1); }
const Value *getCompareOperand() const { return getOperand(1); }

Value *getNewValOperand() { return getOperand(2); }
const Value *getNewValOperand() const { return getOperand(2); }

/// Returns the address space of the pointer operand.
unsigned getPointerAddressSpace() const {
  return getPointerOperand()->getType()->getPointerAddressSpace();
}

/// Returns the strongest permitted ordering on failure, given the
/// desired ordering on success.
///
/// If the comparison in a cmpxchg operation fails, there is no atomic store
/// so release semantics cannot be provided. So this function drops explicit
/// Release requests from the AtomicOrdering. A SequentiallyConsistent
/// operation would remain SequentiallyConsistent.
static AtomicOrdering
getStrongestFailureOrdering(AtomicOrdering SuccessOrdering) {
  switch (SuccessOrdering) {
  default:
    llvm_unreachable("invalid cmpxchg success ordering")::llvm::llvm_unreachable_internal("invalid cmpxchg success ordering"
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 653);
  case AtomicOrdering::Release:
  case AtomicOrdering::Monotonic:
    return AtomicOrdering::Monotonic;
  case AtomicOrdering::AcquireRelease:
  case AtomicOrdering::Acquire:
    return AtomicOrdering::Acquire;
  case AtomicOrdering::SequentiallyConsistent:
    return AtomicOrdering::SequentiallyConsistent;
  }
}

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::AtomicCmpXchg;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}

673private:
// Shadow Instruction::setInstructionSubclassData with a private forwarding
// method so that subclasses cannot accidentally use it.
template <typename Bitfield>
void setSubclassData(typename Bitfield::Type Value) {
  Instruction::setSubclassData<Bitfield>(Value);
}

/// The synchronization scope ID of this cmpxchg instruction.  Not quite
/// enough room in SubClassData for everything, so synchronization scope ID
/// gets its own field.
SyncScope::ID SSID;
685};

687template <>
688struct OperandTraits<AtomicCmpXchgInst> :
  public FixedNumOperandTraits<AtomicCmpXchgInst, 3> {
690};

692DEFINE_TRANSPARENT_OPERAND_ACCESSORS(AtomicCmpXchgInst, Value)AtomicCmpXchgInst::op_iterator AtomicCmpXchgInst::op_begin() {
 return OperandTraits<AtomicCmpXchgInst>::op_begin(this
); } AtomicCmpXchgInst::const_op_iterator AtomicCmpXchgInst::
op_begin() const { return OperandTraits<AtomicCmpXchgInst>
::op_begin(const_cast<AtomicCmpXchgInst*>(this)); } AtomicCmpXchgInst
::op_iterator AtomicCmpXchgInst::op_end() { return OperandTraits
<AtomicCmpXchgInst>::op_end(this); } AtomicCmpXchgInst::
const_op_iterator AtomicCmpXchgInst::op_end() const { return OperandTraits
<AtomicCmpXchgInst>::op_end(const_cast<AtomicCmpXchgInst
*>(this)); } Value *AtomicCmpXchgInst::getOperand(unsigned
 i_nocapture) const { ((i_nocapture < OperandTraits<AtomicCmpXchgInst
>::operands(this) && "getOperand() out of range!")
 ? static_cast<void> (0) : __assert_fail ("i_nocapture < OperandTraits<AtomicCmpXchgInst>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 692, __PRETTY_FUNCTION__)); return cast_or_null<Value>
( OperandTraits<AtomicCmpXchgInst>::op_begin(const_cast
<AtomicCmpXchgInst*>(this))[i_nocapture].get()); } void
 AtomicCmpXchgInst::setOperand(unsigned i_nocapture, Value *Val_nocapture
) { ((i_nocapture < OperandTraits<AtomicCmpXchgInst>
::operands(this) && "setOperand() out of range!") ? static_cast
<void> (0) : __assert_fail ("i_nocapture < OperandTraits<AtomicCmpXchgInst>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 692, __PRETTY_FUNCTION__)); OperandTraits<AtomicCmpXchgInst
>::op_begin(this)[i_nocapture] = Val_nocapture; } unsigned
 AtomicCmpXchgInst::getNumOperands() const { return OperandTraits
<AtomicCmpXchgInst>::operands(this); } template <int
 Idx_nocapture> Use &AtomicCmpXchgInst::Op() { return this
->OpFrom<Idx_nocapture>(this); } template <int Idx_nocapture
> const Use &AtomicCmpXchgInst::Op() const { return this
->OpFrom<Idx_nocapture>(this); }

694//===----------------------------------------------------------------------===//
695//                                AtomicRMWInst Class
696//===----------------------------------------------------------------------===//

698/// an instruction that atomically reads a memory location,
699/// combines it with another value, and then stores the result back.  Returns
700/// the old value.
701///
702class AtomicRMWInst : public Instruction {
703protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

AtomicRMWInst *cloneImpl() const;

709public:
/// This enumeration lists the possible modifications atomicrmw can make.  In
/// the descriptions, 'p' is the pointer to the instruction's memory location,
/// 'old' is the initial value of *p, and 'v' is the other value passed to the
/// instruction.  These instructions always return 'old'.
enum BinOp : unsigned {
  /// *p = v
  Xchg,
  /// *p = old + v
  Add,
  /// *p = old - v
  Sub,
  /// *p = old & v
  And,
  /// *p = ~(old & v)
  Nand,
  /// *p = old | v
  Or,
  /// *p = old ^ v
  Xor,
  /// *p = old >signed v ? old : v
  Max,
  /// *p = old <signed v ? old : v
  Min,
  /// *p = old >unsigned v ? old : v
  UMax,
  /// *p = old <unsigned v ? old : v
  UMin,

  /// *p = old + v
  FAdd,

  /// *p = old - v
  FSub,

  FIRST_BINOP = Xchg,
  LAST_BINOP = FSub,
  BAD_BINOP
};

749private:
template <unsigned Offset>
using AtomicOrderingBitfieldElement =
    typename Bitfield::Element<AtomicOrdering, Offset, 3,
                               AtomicOrdering::LAST>;

template <unsigned Offset>
using BinOpBitfieldElement =
    typename Bitfield::Element<BinOp, Offset, 4, BinOp::LAST_BINOP>;

759public:
AtomicRMWInst(BinOp Operation, Value *Ptr, Value *Val, Align Alignment,
              AtomicOrdering Ordering, SyncScope::ID SSID,
              Instruction *InsertBefore = nullptr);
AtomicRMWInst(BinOp Operation, Value *Ptr, Value *Val, Align Alignment,
              AtomicOrdering Ordering, SyncScope::ID SSID,
              BasicBlock *InsertAtEnd);

// allocate space for exactly two operands
void *operator new(size_t s) {
  return User::operator new(s, 2);
}

using VolatileField = BoolBitfieldElementT<0>;
using AtomicOrderingField =
    AtomicOrderingBitfieldElementT<VolatileField::NextBit>;
using OperationField = BinOpBitfieldElement<AtomicOrderingField::NextBit>;
using AlignmentField = AlignmentBitfieldElementT<OperationField::NextBit>;
static_assert(Bitfield::areContiguous<VolatileField, AtomicOrderingField,
                                      OperationField, AlignmentField>(),
              "Bitfields must be contiguous");

BinOp getOperation() const { return getSubclassData<OperationField>(); }

static StringRef getOperationName(BinOp Op);

static bool isFPOperation(BinOp Op) {
  switch (Op) {
  case AtomicRMWInst::FAdd:
  case AtomicRMWInst::FSub:
    return true;
  default:
    return false;
  }
}

void setOperation(BinOp Operation) {
  setSubclassData<OperationField>(Operation);
}

/// Return the alignment of the memory that is being allocated by the
/// instruction.
Align getAlign() const {
  return Align(1ULL << getSubclassData<AlignmentField>());
}

void setAlignment(Align Align) {
  setSubclassData<AlignmentField>(Log2(Align));
}

/// Return true if this is a RMW on a volatile memory location.
///
bool isVolatile() const { return getSubclassData<VolatileField>(); }

/// Specify whether this is a volatile RMW or not.
///
void setVolatile(bool V) { setSubclassData<VolatileField>(V); }

/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
 setOperand(unsigned, Value*); inline op_iterator op_begin();
 inline const_op_iterator op_begin() const; inline op_iterator
 op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
 getNumOperands() const;

/// Returns the ordering constraint of this rmw instruction.
AtomicOrdering getOrdering() const {
  return getSubclassData<AtomicOrderingField>();
}

/// Sets the ordering constraint of this rmw instruction.
void setOrdering(AtomicOrdering Ordering) {
  assert(Ordering != AtomicOrdering::NotAtomic &&((Ordering != AtomicOrdering::NotAtomic && "atomicrmw instructions can only be atomic."
) ? static_cast<void> (0) : __assert_fail ("Ordering != AtomicOrdering::NotAtomic && \"atomicrmw instructions can only be atomic.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 828, __PRETTY_FUNCTION__))
         "atomicrmw instructions can only be atomic.")((Ordering != AtomicOrdering::NotAtomic && "atomicrmw instructions can only be atomic."
) ? static_cast<void> (0) : __assert_fail ("Ordering != AtomicOrdering::NotAtomic && \"atomicrmw instructions can only be atomic.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 828, __PRETTY_FUNCTION__));
  setSubclassData<AtomicOrderingField>(Ordering);
}

/// Returns the synchronization scope ID of this rmw instruction.
SyncScope::ID getSyncScopeID() const {
  return SSID;
}

/// Sets the synchronization scope ID of this rmw instruction.
void setSyncScopeID(SyncScope::ID SSID) {
  this->SSID = SSID;
}

Value *getPointerOperand() { return getOperand(0); }
const Value *getPointerOperand() const { return getOperand(0); }
static unsigned getPointerOperandIndex() { return 0U; }

Value *getValOperand() { return getOperand(1); }
const Value *getValOperand() const { return getOperand(1); }

/// Returns the address space of the pointer operand.
unsigned getPointerAddressSpace() const {
  return getPointerOperand()->getType()->getPointerAddressSpace();
}

bool isFloatingPointOperation() const {
  return isFPOperation(getOperation());
}

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::AtomicRMW;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}

866private:
void Init(BinOp Operation, Value *Ptr, Value *Val, Align Align,
          AtomicOrdering Ordering, SyncScope::ID SSID);

// Shadow Instruction::setInstructionSubclassData with a private forwarding
// method so that subclasses cannot accidentally use it.
template <typename Bitfield>
void setSubclassData(typename Bitfield::Type Value) {
  Instruction::setSubclassData<Bitfield>(Value);
}

/// The synchronization scope ID of this rmw instruction.  Not quite enough
/// room in SubClassData for everything, so synchronization scope ID gets its
/// own field.
SyncScope::ID SSID;
881};

883template <>
884struct OperandTraits<AtomicRMWInst>
  : public FixedNumOperandTraits<AtomicRMWInst,2> {
886};

888DEFINE_TRANSPARENT_OPERAND_ACCESSORS(AtomicRMWInst, Value)AtomicRMWInst::op_iterator AtomicRMWInst::op_begin() { return
 OperandTraits<AtomicRMWInst>::op_begin(this); } AtomicRMWInst
::const_op_iterator AtomicRMWInst::op_begin() const { return OperandTraits
<AtomicRMWInst>::op_begin(const_cast<AtomicRMWInst*>
(this)); } AtomicRMWInst::op_iterator AtomicRMWInst::op_end()
 { return OperandTraits<AtomicRMWInst>::op_end(this); }
 AtomicRMWInst::const_op_iterator AtomicRMWInst::op_end() const
 { return OperandTraits<AtomicRMWInst>::op_end(const_cast
<AtomicRMWInst*>(this)); } Value *AtomicRMWInst::getOperand
(unsigned i_nocapture) const { ((i_nocapture < OperandTraits
<AtomicRMWInst>::operands(this) && "getOperand() out of range!"
) ? static_cast<void> (0) : __assert_fail ("i_nocapture < OperandTraits<AtomicRMWInst>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 888, __PRETTY_FUNCTION__)); return cast_or_null<Value>
( OperandTraits<AtomicRMWInst>::op_begin(const_cast<
AtomicRMWInst*>(this))[i_nocapture].get()); } void AtomicRMWInst
::setOperand(unsigned i_nocapture, Value *Val_nocapture) { ((
i_nocapture < OperandTraits<AtomicRMWInst>::operands
(this) && "setOperand() out of range!") ? static_cast
<void> (0) : __assert_fail ("i_nocapture < OperandTraits<AtomicRMWInst>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 888, __PRETTY_FUNCTION__)); OperandTraits<AtomicRMWInst>
::op_begin(this)[i_nocapture] = Val_nocapture; } unsigned AtomicRMWInst
::getNumOperands() const { return OperandTraits<AtomicRMWInst
>::operands(this); } template <int Idx_nocapture> Use
 &AtomicRMWInst::Op() { return this->OpFrom<Idx_nocapture
>(this); } template <int Idx_nocapture> const Use &
AtomicRMWInst::Op() const { return this->OpFrom<Idx_nocapture
>(this); }

890//===----------------------------------------------------------------------===//
891//                             GetElementPtrInst Class
892//===----------------------------------------------------------------------===//

894// checkGEPType - Simple wrapper function to give a better assertion failure
895// message on bad indexes for a gep instruction.
896//
897inline Type *checkGEPType(Type *Ty) {
assert(Ty && "Invalid GetElementPtrInst indices for type!")((Ty && "Invalid GetElementPtrInst indices for type!"
) ? static_cast<void> (0) : __assert_fail ("Ty && \"Invalid GetElementPtrInst indices for type!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 898, __PRETTY_FUNCTION__));
return Ty;
900}

902/// an instruction for type-safe pointer arithmetic to
903/// access elements of arrays and structs
904///
905class GetElementPtrInst : public Instruction {
Type *SourceElementType;
Type *ResultElementType;

GetElementPtrInst(const GetElementPtrInst &GEPI);

/// Constructors - Create a getelementptr instruction with a base pointer an
/// list of indices. The first ctor can optionally insert before an existing
/// instruction, the second appends the new instruction to the specified
/// BasicBlock.
inline GetElementPtrInst(Type *PointeeType, Value *Ptr,
                         ArrayRef<Value *> IdxList, unsigned Values,
                         const Twine &NameStr, Instruction *InsertBefore);
inline GetElementPtrInst(Type *PointeeType, Value *Ptr,
                         ArrayRef<Value *> IdxList, unsigned Values,
                         const Twine &NameStr, BasicBlock *InsertAtEnd);

void init(Value *Ptr, ArrayRef<Value *> IdxList, const Twine &NameStr);

924protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

GetElementPtrInst *cloneImpl() const;

930public:
static GetElementPtrInst *Create(Type *PointeeType, Value *Ptr,
                                 ArrayRef<Value *> IdxList,
                                 const Twine &NameStr = "",
                                 Instruction *InsertBefore = nullptr) {
  unsigned Values = 1 + unsigned(IdxList.size());
  if (!PointeeType)
    PointeeType =
        cast<PointerType>(Ptr->getType()->getScalarType())->getElementType();
  else
    assert(((PointeeType == cast<PointerType>(Ptr->getType()->
getScalarType())->getElementType()) ? static_cast<void>
 (0) : __assert_fail ("PointeeType == cast<PointerType>(Ptr->getType()->getScalarType())->getElementType()"
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 942, __PRETTY_FUNCTION__))
        PointeeType ==((PointeeType == cast<PointerType>(Ptr->getType()->
getScalarType())->getElementType()) ? static_cast<void>
 (0) : __assert_fail ("PointeeType == cast<PointerType>(Ptr->getType()->getScalarType())->getElementType()"
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 942, __PRETTY_FUNCTION__))
        cast<PointerType>(Ptr->getType()->getScalarType())->getElementType())((PointeeType == cast<PointerType>(Ptr->getType()->
getScalarType())->getElementType()) ? static_cast<void>
 (0) : __assert_fail ("PointeeType == cast<PointerType>(Ptr->getType()->getScalarType())->getElementType()"
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 942, __PRETTY_FUNCTION__));
  return new (Values) GetElementPtrInst(PointeeType, Ptr, IdxList, Values,
                                        NameStr, InsertBefore);
}

static GetElementPtrInst *Create(Type *PointeeType, Value *Ptr,
                                 ArrayRef<Value *> IdxList,
                                 const Twine &NameStr,
                                 BasicBlock *InsertAtEnd) {
  unsigned Values = 1 + unsigned(IdxList.size());
  if (!PointeeType)
    PointeeType =
        cast<PointerType>(Ptr->getType()->getScalarType())->getElementType();
  else
    assert(((PointeeType == cast<PointerType>(Ptr->getType()->
getScalarType())->getElementType()) ? static_cast<void>
 (0) : __assert_fail ("PointeeType == cast<PointerType>(Ptr->getType()->getScalarType())->getElementType()"
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 958, __PRETTY_FUNCTION__))
        PointeeType ==((PointeeType == cast<PointerType>(Ptr->getType()->
getScalarType())->getElementType()) ? static_cast<void>
 (0) : __assert_fail ("PointeeType == cast<PointerType>(Ptr->getType()->getScalarType())->getElementType()"
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 958, __PRETTY_FUNCTION__))
        cast<PointerType>(Ptr->getType()->getScalarType())->getElementType())((PointeeType == cast<PointerType>(Ptr->getType()->
getScalarType())->getElementType()) ? static_cast<void>
 (0) : __assert_fail ("PointeeType == cast<PointerType>(Ptr->getType()->getScalarType())->getElementType()"
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 958, __PRETTY_FUNCTION__));
  return new (Values) GetElementPtrInst(PointeeType, Ptr, IdxList, Values,
                                        NameStr, InsertAtEnd);
}

/// Create an "inbounds" getelementptr. See the documentation for the
/// "inbounds" flag in LangRef.html for details.
static GetElementPtrInst *CreateInBounds(Value *Ptr,
                                         ArrayRef<Value *> IdxList,
                                         const Twine &NameStr = "",
                                         Instruction *InsertBefore = nullptr){
  return CreateInBounds(nullptr, Ptr, IdxList, NameStr, InsertBefore);
}

static GetElementPtrInst *
CreateInBounds(Type *PointeeType, Value *Ptr, ArrayRef<Value *> IdxList,
               const Twine &NameStr = "",
               Instruction *InsertBefore = nullptr) {
  GetElementPtrInst *GEP =
      Create(PointeeType, Ptr, IdxList, NameStr, InsertBefore);
  GEP->setIsInBounds(true);
  return GEP;
}

static GetElementPtrInst *CreateInBounds(Value *Ptr,
                                         ArrayRef<Value *> IdxList,
                                         const Twine &NameStr,
                                         BasicBlock *InsertAtEnd) {
  return CreateInBounds(nullptr, Ptr, IdxList, NameStr, InsertAtEnd);
}

static GetElementPtrInst *CreateInBounds(Type *PointeeType, Value *Ptr,
                                         ArrayRef<Value *> IdxList,
                                         const Twine &NameStr,
                                         BasicBlock *InsertAtEnd) {
  GetElementPtrInst *GEP =
      Create(PointeeType, Ptr, IdxList, NameStr, InsertAtEnd);
  GEP->setIsInBounds(true);
  return GEP;
}

/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
 setOperand(unsigned, Value*); inline op_iterator op_begin();
 inline const_op_iterator op_begin() const; inline op_iterator
 op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
 getNumOperands() const;

Type *getSourceElementType() const { return SourceElementType; }

void setSourceElementType(Type *Ty) { SourceElementType = Ty; }
void setResultElementType(Type *Ty) { ResultElementType = Ty; }

Type *getResultElementType() const {
  assert(ResultElementType ==((ResultElementType == cast<PointerType>(getType()->
getScalarType())->getElementType()) ? static_cast<void>
 (0) : __assert_fail ("ResultElementType == cast<PointerType>(getType()->getScalarType())->getElementType()"
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 1009, __PRETTY_FUNCTION__))
         cast<PointerType>(getType()->getScalarType())->getElementType())((ResultElementType == cast<PointerType>(getType()->
getScalarType())->getElementType()) ? static_cast<void>
 (0) : __assert_fail ("ResultElementType == cast<PointerType>(getType()->getScalarType())->getElementType()"
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 1009, __PRETTY_FUNCTION__));
  return ResultElementType;
}

/// Returns the address space of this instruction's pointer type.
unsigned getAddressSpace() const {
  // Note that this is always the same as the pointer operand's address space
  // and that is cheaper to compute, so cheat here.
  return getPointerAddressSpace();
}

/// Returns the result type of a getelementptr with the given source
/// element type and indexes.
///
/// Null is returned if the indices are invalid for the specified
/// source element type.
static Type *getIndexedType(Type *Ty, ArrayRef<Value *> IdxList);
static Type *getIndexedType(Type *Ty, ArrayRef<Constant *> IdxList);
static Type *getIndexedType(Type *Ty, ArrayRef<uint64_t> IdxList);

/// Return the type of the element at the given index of an indexable
/// type.  This is equivalent to "getIndexedType(Agg, {Zero, Idx})".
///
/// Returns null if the type can't be indexed, or the given index is not
/// legal for the given type.
static Type *getTypeAtIndex(Type *Ty, Value *Idx);
static Type *getTypeAtIndex(Type *Ty, uint64_t Idx);

inline op_iterator       idx_begin()       { return op_begin()+1; }
inline const_op_iterator idx_begin() const { return op_begin()+1; }
inline op_iterator       idx_end()         { return op_end(); }
inline const_op_iterator idx_end()   const { return op_end(); }

inline iterator_range<op_iterator> indices() {
  return make_range(idx_begin(), idx_end());
}

inline iterator_range<const_op_iterator> indices() const {
  return make_range(idx_begin(), idx_end());
}

Value *getPointerOperand() {
  return getOperand(0);
}
const Value *getPointerOperand() const {
  return getOperand(0);
}
static unsigned getPointerOperandIndex() {
  return 0U;    // get index for modifying correct operand.
}

/// Method to return the pointer operand as a
/// PointerType.
Type *getPointerOperandType() const {
  return getPointerOperand()->getType();
}

/// Returns the address space of the pointer operand.
unsigned getPointerAddressSpace() const {
  return getPointerOperandType()->getPointerAddressSpace();
}

/// Returns the pointer type returned by the GEP
/// instruction, which may be a vector of pointers.
static Type *getGEPReturnType(Type *ElTy, Value *Ptr,
                              ArrayRef<Value *> IdxList) {
  Type *PtrTy = PointerType::get(checkGEPType(getIndexedType(ElTy, IdxList)),
                                 Ptr->getType()->getPointerAddressSpace());
  // Vector GEP
  if (auto *PtrVTy = dyn_cast<VectorType>(Ptr->getType())) {
    ElementCount EltCount = PtrVTy->getElementCount();
    return VectorType::get(PtrTy, EltCount);
  }
  for (Value *Index : IdxList)
    if (auto *IndexVTy = dyn_cast<VectorType>(Index->getType())) {
      ElementCount EltCount = IndexVTy->getElementCount();
      return VectorType::get(PtrTy, EltCount);
    }
  // Scalar GEP
  return PtrTy;
}

unsigned getNumIndices() const {  // Note: always non-negative
  return getNumOperands() - 1;
}

bool hasIndices() const {
  return getNumOperands() > 1;
}

/// Return true if all of the indices of this GEP are
/// zeros.  If so, the result pointer and the first operand have the same
/// value, just potentially different types.
bool hasAllZeroIndices() const;

/// Return true if all of the indices of this GEP are
/// constant integers.  If so, the result pointer and the first operand have
/// a constant offset between them.
bool hasAllConstantIndices() const;

/// Set or clear the inbounds flag on this GEP instruction.
/// See LangRef.html for the meaning of inbounds on a getelementptr.
void setIsInBounds(bool b = true);

/// Determine whether the GEP has the inbounds flag.
bool isInBounds() const;

/// Accumulate the constant address offset of this GEP if possible.
///
/// This routine accepts an APInt into which it will accumulate the constant
/// offset of this GEP if the GEP is in fact constant. If the GEP is not
/// all-constant, it returns false and the value of the offset APInt is
/// undefined (it is *not* preserved!). The APInt passed into this routine
/// must be at least as wide as the IntPtr type for the address space of
/// the base GEP pointer.
bool accumulateConstantOffset(const DataLayout &DL, APInt &Offset) const;

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return (I->getOpcode() == Instruction::GetElementPtr);
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
1133};

1135template <>
1136struct OperandTraits<GetElementPtrInst> :
public VariadicOperandTraits<GetElementPtrInst, 1> {
1138};

1140GetElementPtrInst::GetElementPtrInst(Type *PointeeType, Value *Ptr,
                                   ArrayRef<Value *> IdxList, unsigned Values,
                                   const Twine &NameStr,
                                   Instruction *InsertBefore)
  : Instruction(getGEPReturnType(PointeeType, Ptr, IdxList), GetElementPtr,
                OperandTraits<GetElementPtrInst>::op_end(this) - Values,
                Values, InsertBefore),
    SourceElementType(PointeeType),
    ResultElementType(getIndexedType(PointeeType, IdxList)) {
assert(ResultElementType ==((ResultElementType == cast<PointerType>(getType()->
getScalarType())->getElementType()) ? static_cast<void>
 (0) : __assert_fail ("ResultElementType == cast<PointerType>(getType()->getScalarType())->getElementType()"
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 1150, __PRETTY_FUNCTION__))
       cast<PointerType>(getType()->getScalarType())->getElementType())((ResultElementType == cast<PointerType>(getType()->
getScalarType())->getElementType()) ? static_cast<void>
 (0) : __assert_fail ("ResultElementType == cast<PointerType>(getType()->getScalarType())->getElementType()"
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 1150, __PRETTY_FUNCTION__));
init(Ptr, IdxList, NameStr);
1152}

1154GetElementPtrInst::GetElementPtrInst(Type *PointeeType, Value *Ptr,
                                   ArrayRef<Value *> IdxList, unsigned Values,
                                   const Twine &NameStr,
                                   BasicBlock *InsertAtEnd)
  : Instruction(getGEPReturnType(PointeeType, Ptr, IdxList), GetElementPtr,
                OperandTraits<GetElementPtrInst>::op_end(this) - Values,
                Values, InsertAtEnd),
    SourceElementType(PointeeType),
    ResultElementType(getIndexedType(PointeeType, IdxList)) {
assert(ResultElementType ==((ResultElementType == cast<PointerType>(getType()->
getScalarType())->getElementType()) ? static_cast<void>
 (0) : __assert_fail ("ResultElementType == cast<PointerType>(getType()->getScalarType())->getElementType()"
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 1164, __PRETTY_FUNCTION__))
       cast<PointerType>(getType()->getScalarType())->getElementType())((ResultElementType == cast<PointerType>(getType()->
getScalarType())->getElementType()) ? static_cast<void>
 (0) : __assert_fail ("ResultElementType == cast<PointerType>(getType()->getScalarType())->getElementType()"
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 1164, __PRETTY_FUNCTION__));
init(Ptr, IdxList, NameStr);
1166}

1168DEFINE_TRANSPARENT_OPERAND_ACCESSORS(GetElementPtrInst, Value)GetElementPtrInst::op_iterator GetElementPtrInst::op_begin() {
 return OperandTraits<GetElementPtrInst>::op_begin(this
); } GetElementPtrInst::const_op_iterator GetElementPtrInst::
op_begin() const { return OperandTraits<GetElementPtrInst>
::op_begin(const_cast<GetElementPtrInst*>(this)); } GetElementPtrInst
::op_iterator GetElementPtrInst::op_end() { return OperandTraits
<GetElementPtrInst>::op_end(this); } GetElementPtrInst::
const_op_iterator GetElementPtrInst::op_end() const { return OperandTraits
<GetElementPtrInst>::op_end(const_cast<GetElementPtrInst
*>(this)); } Value *GetElementPtrInst::getOperand(unsigned
 i_nocapture) const { ((i_nocapture < OperandTraits<GetElementPtrInst
>::operands(this) && "getOperand() out of range!")
 ? static_cast<void> (0) : __assert_fail ("i_nocapture < OperandTraits<GetElementPtrInst>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 1168, __PRETTY_FUNCTION__)); return cast_or_null<Value>
( OperandTraits<GetElementPtrInst>::op_begin(const_cast
<GetElementPtrInst*>(this))[i_nocapture].get()); } void
 GetElementPtrInst::setOperand(unsigned i_nocapture, Value *Val_nocapture
) { ((i_nocapture < OperandTraits<GetElementPtrInst>
::operands(this) && "setOperand() out of range!") ? static_cast
<void> (0) : __assert_fail ("i_nocapture < OperandTraits<GetElementPtrInst>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 1168, __PRETTY_FUNCTION__)); OperandTraits<GetElementPtrInst
>::op_begin(this)[i_nocapture] = Val_nocapture; } unsigned
 GetElementPtrInst::getNumOperands() const { return OperandTraits
<GetElementPtrInst>::operands(this); } template <int
 Idx_nocapture> Use &GetElementPtrInst::Op() { return this
->OpFrom<Idx_nocapture>(this); } template <int Idx_nocapture
> const Use &GetElementPtrInst::Op() const { return this
->OpFrom<Idx_nocapture>(this); }

1170//===----------------------------------------------------------------------===//
1171//                               ICmpInst Class
1172//===----------------------------------------------------------------------===//

1174/// This instruction compares its operands according to the predicate given
1175/// to the constructor. It only operates on integers or pointers. The operands
1176/// must be identical types.
1177/// Represent an integer comparison operator.
1178class ICmpInst: public CmpInst {
void AssertOK() {
  assert(isIntPredicate() &&((isIntPredicate() && "Invalid ICmp predicate value")
 ? static_cast<void> (0) : __assert_fail ("isIntPredicate() && \"Invalid ICmp predicate value\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 1181, __PRETTY_FUNCTION__))
         "Invalid ICmp predicate value")((isIntPredicate() && "Invalid ICmp predicate value")
 ? static_cast<void> (0) : __assert_fail ("isIntPredicate() && \"Invalid ICmp predicate value\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 1181, __PRETTY_FUNCTION__));
  assert(getOperand(0)->getType() == getOperand(1)->getType() &&((getOperand(0)->getType() == getOperand(1)->getType() &&
 "Both operands to ICmp instruction are not of the same type!"
) ? static_cast<void> (0) : __assert_fail ("getOperand(0)->getType() == getOperand(1)->getType() && \"Both operands to ICmp instruction are not of the same type!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 1183, __PRETTY_FUNCTION__))
        "Both operands to ICmp instruction are not of the same type!")((getOperand(0)->getType() == getOperand(1)->getType() &&
 "Both operands to ICmp instruction are not of the same type!"
) ? static_cast<void> (0) : __assert_fail ("getOperand(0)->getType() == getOperand(1)->getType() && \"Both operands to ICmp instruction are not of the same type!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 1183, __PRETTY_FUNCTION__));
  // Check that the operands are the right type
  assert((getOperand(0)->getType()->isIntOrIntVectorTy() ||(((getOperand(0)->getType()->isIntOrIntVectorTy() || getOperand
(0)->getType()->isPtrOrPtrVectorTy()) && "Invalid operand types for ICmp instruction"
) ? static_cast<void> (0) : __assert_fail ("(getOperand(0)->getType()->isIntOrIntVectorTy() || getOperand(0)->getType()->isPtrOrPtrVectorTy()) && \"Invalid operand types for ICmp instruction\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 1187, __PRETTY_FUNCTION__))
          getOperand(0)->getType()->isPtrOrPtrVectorTy()) &&(((getOperand(0)->getType()->isIntOrIntVectorTy() || getOperand
(0)->getType()->isPtrOrPtrVectorTy()) && "Invalid operand types for ICmp instruction"
) ? static_cast<void> (0) : __assert_fail ("(getOperand(0)->getType()->isIntOrIntVectorTy() || getOperand(0)->getType()->isPtrOrPtrVectorTy()) && \"Invalid operand types for ICmp instruction\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 1187, __PRETTY_FUNCTION__))
         "Invalid operand types for ICmp instruction")(((getOperand(0)->getType()->isIntOrIntVectorTy() || getOperand
(0)->getType()->isPtrOrPtrVectorTy()) && "Invalid operand types for ICmp instruction"
) ? static_cast<void> (0) : __assert_fail ("(getOperand(0)->getType()->isIntOrIntVectorTy() || getOperand(0)->getType()->isPtrOrPtrVectorTy()) && \"Invalid operand types for ICmp instruction\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 1187, __PRETTY_FUNCTION__));
}

1190protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

/// Clone an identical ICmpInst
ICmpInst *cloneImpl() const;

1197public:
/// Constructor with insert-before-instruction semantics.
ICmpInst(
  Instruction *InsertBefore,  ///< Where to insert
  Predicate pred,  ///< The predicate to use for the comparison
  Value *LHS,      ///< The left-hand-side of the expression
  Value *RHS,      ///< The right-hand-side of the expression
  const Twine &NameStr = ""  ///< Name of the instruction
) : CmpInst(makeCmpResultType(LHS->getType()),
            Instruction::ICmp, pred, LHS, RHS, NameStr,
            InsertBefore) {
1208#ifndef NDEBUG
AssertOK();
1210#endif
}

/// Constructor with insert-at-end semantics.
ICmpInst(
  BasicBlock &InsertAtEnd, ///< Block to insert into.
  Predicate pred,  ///< The predicate to use for the comparison
  Value *LHS,      ///< The left-hand-side of the expression
  Value *RHS,      ///< The right-hand-side of the expression
  const Twine &NameStr = ""  ///< Name of the instruction
) : CmpInst(makeCmpResultType(LHS->getType()),
            Instruction::ICmp, pred, LHS, RHS, NameStr,
            &InsertAtEnd) {
1223#ifndef NDEBUG
AssertOK();
1225#endif
}

/// Constructor with no-insertion semantics
ICmpInst(
  Predicate pred, ///< The predicate to use for the comparison
  Value *LHS,     ///< The left-hand-side of the expression
  Value *RHS,     ///< The right-hand-side of the expression
  const Twine &NameStr = "" ///< Name of the instruction
) : CmpInst(makeCmpResultType(LHS->getType()),
            Instruction::ICmp, pred, LHS, RHS, NameStr) {
1236#ifndef NDEBUG
AssertOK();
1238#endif
}

/// For example, EQ->EQ, SLE->SLE, UGT->SGT, etc.
/// @returns the predicate that would be the result if the operand were
/// regarded as signed.
/// Return the signed version of the predicate
Predicate getSignedPredicate() const {
  return getSignedPredicate(getPredicate());
}

/// This is a static version that you can use without an instruction.
/// Return the signed version of the predicate.
static Predicate getSignedPredicate(Predicate pred);

/// For example, EQ->EQ, SLE->ULE, UGT->UGT, etc.
/// @returns the predicate that would be the result if the operand were
/// regarded as unsigned.
/// Return the unsigned version of the predicate
Predicate getUnsignedPredicate() const {
  return getUnsignedPredicate(getPredicate());
}

/// This is a static version that you can use without an instruction.
/// Return the unsigned version of the predicate.
static Predicate getUnsignedPredicate(Predicate pred);

/// Return true if this predicate is either EQ or NE.  This also
/// tests for commutativity.
static bool isEquality(Predicate P) {
  return P == ICMP_EQ || P == ICMP_NE;
}

/// Return true if this predicate is either EQ or NE.  This also
/// tests for commutativity.
bool isEquality() const {
  return isEquality(getPredicate());
}

/// @returns true if the predicate of this ICmpInst is commutative
/// Determine if this relation is commutative.
bool isCommutative() const { return isEquality(); }

/// Return true if the predicate is relational (not EQ or NE).
///
bool isRelational() const {
  return !isEquality();
}

/// Return true if the predicate is relational (not EQ or NE).
///
static bool isRelational(Predicate P) {
  return !isEquality(P);
}

/// Return true if the predicate is SGT or UGT.
///
static bool isGT(Predicate P) {
  return P == ICMP_SGT || P == ICMP_UGT;
}

/// Return true if the predicate is SLT or ULT.
///
static bool isLT(Predicate P) {
  return P == ICMP_SLT || P == ICMP_ULT;
}

/// Return true if the predicate is SGE or UGE.
///
static bool isGE(Predicate P) {
  return P == ICMP_SGE || P == ICMP_UGE;
}

/// Return true if the predicate is SLE or ULE.
///
static bool isLE(Predicate P) {
  return P == ICMP_SLE || P == ICMP_ULE;
}

/// Exchange the two operands to this instruction in such a way that it does
/// not modify the semantics of the instruction. The predicate value may be
/// changed to retain the same result if the predicate is order dependent
/// (e.g. ult).
/// Swap operands and adjust predicate.
void swapOperands() {
  setPredicate(getSwappedPredicate());
  Op<0>().swap(Op<1>());
}

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::ICmp;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
1334};

1336//===----------------------------------------------------------------------===//
1337//                               FCmpInst Class
1338//===----------------------------------------------------------------------===//

1340/// This instruction compares its operands according to the predicate given
1341/// to the constructor. It only operates on floating point values or packed
1342/// vectors of floating point values. The operands must be identical types.
1343/// Represents a floating point comparison operator.
1344class FCmpInst: public CmpInst {
void AssertOK() {
  assert(isFPPredicate() && "Invalid FCmp predicate value")((isFPPredicate() && "Invalid FCmp predicate value") ?
 static_cast<void> (0) : __assert_fail ("isFPPredicate() && \"Invalid FCmp predicate value\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 1346, __PRETTY_FUNCTION__));
  assert(getOperand(0)->getType() == getOperand(1)->getType() &&((getOperand(0)->getType() == getOperand(1)->getType() &&
 "Both operands to FCmp instruction are not of the same type!"
) ? static_cast<void> (0) : __assert_fail ("getOperand(0)->getType() == getOperand(1)->getType() && \"Both operands to FCmp instruction are not of the same type!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 1348, __PRETTY_FUNCTION__))
         "Both operands to FCmp instruction are not of the same type!")((getOperand(0)->getType() == getOperand(1)->getType() &&
 "Both operands to FCmp instruction are not of the same type!"
) ? static_cast<void> (0) : __assert_fail ("getOperand(0)->getType() == getOperand(1)->getType() && \"Both operands to FCmp instruction are not of the same type!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 1348, __PRETTY_FUNCTION__));
  // Check that the operands are the right type
  assert(getOperand(0)->getType()->isFPOrFPVectorTy() &&((getOperand(0)->getType()->isFPOrFPVectorTy() &&
 "Invalid operand types for FCmp instruction") ? static_cast<
void> (0) : __assert_fail ("getOperand(0)->getType()->isFPOrFPVectorTy() && \"Invalid operand types for FCmp instruction\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 1351, __PRETTY_FUNCTION__))
         "Invalid operand types for FCmp instruction")((getOperand(0)->getType()->isFPOrFPVectorTy() &&
 "Invalid operand types for FCmp instruction") ? static_cast<
void> (0) : __assert_fail ("getOperand(0)->getType()->isFPOrFPVectorTy() && \"Invalid operand types for FCmp instruction\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 1351, __PRETTY_FUNCTION__));
}

1354protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

/// Clone an identical FCmpInst
FCmpInst *cloneImpl() const;

1361public:
/// Constructor with insert-before-instruction semantics.
FCmpInst(
  Instruction *InsertBefore, ///< Where to insert
  Predicate pred,  ///< The predicate to use for the comparison
  Value *LHS,      ///< The left-hand-side of the expression
  Value *RHS,      ///< The right-hand-side of the expression
  const Twine &NameStr = ""  ///< Name of the instruction
) : CmpInst(makeCmpResultType(LHS->getType()),
            Instruction::FCmp, pred, LHS, RHS, NameStr,
            InsertBefore) {
  AssertOK();
}

/// Constructor with insert-at-end semantics.
FCmpInst(
  BasicBlock &InsertAtEnd, ///< Block to insert into.
  Predicate pred,  ///< The predicate to use for the comparison
  Value *LHS,      ///< The left-hand-side of the expression
  Value *RHS,      ///< The right-hand-side of the expression
  const Twine &NameStr = ""  ///< Name of the instruction
) : CmpInst(makeCmpResultType(LHS->getType()),
            Instruction::FCmp, pred, LHS, RHS, NameStr,
            &InsertAtEnd) {
  AssertOK();
}

/// Constructor with no-insertion semantics
FCmpInst(
  Predicate Pred, ///< The predicate to use for the comparison
  Value *LHS,     ///< The left-hand-side of the expression
  Value *RHS,     ///< The right-hand-side of the expression
  const Twine &NameStr = "", ///< Name of the instruction
  Instruction *FlagsSource = nullptr
) : CmpInst(makeCmpResultType(LHS->getType()), Instruction::FCmp, Pred, LHS,
            RHS, NameStr, nullptr, FlagsSource) {
  AssertOK();
}

/// @returns true if the predicate of this instruction is EQ or NE.
/// Determine if this is an equality predicate.
static bool isEquality(Predicate Pred) {
  return Pred == FCMP_OEQ || Pred == FCMP_ONE || Pred == FCMP_UEQ ||
         Pred == FCMP_UNE;
}

/// @returns true if the predicate of this instruction is EQ or NE.
/// Determine if this is an equality predicate.
bool isEquality() const { return isEquality(getPredicate()); }

/// @returns true if the predicate of this instruction is commutative.
/// Determine if this is a commutative predicate.
bool isCommutative() const {
  return isEquality() ||
         getPredicate() == FCMP_FALSE ||
         getPredicate() == FCMP_TRUE ||
         getPredicate() == FCMP_ORD ||
         getPredicate() == FCMP_UNO;
}

/// @returns true if the predicate is relational (not EQ or NE).
/// Determine if this a relational predicate.
bool isRelational() const { return !isEquality(); }

/// Exchange the two operands to this instruction in such a way that it does
/// not modify the semantics of the instruction. The predicate value may be
/// changed to retain the same result if the predicate is order dependent
/// (e.g. ult).
/// Swap operands and adjust predicate.
void swapOperands() {
  setPredicate(getSwappedPredicate());
  Op<0>().swap(Op<1>());
}

/// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::FCmp;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
1442};

1444//===----------------------------------------------------------------------===//
1445/// This class represents a function call, abstracting a target
1446/// machine's calling convention.  This class uses low bit of the SubClassData
1447/// field to indicate whether or not this is a tail call.  The rest of the bits
1448/// hold the calling convention of the call.
1449///
1450class CallInst : public CallBase {
CallInst(const CallInst &CI);

/// Construct a CallInst given a range of arguments.
/// Construct a CallInst from a range of arguments
inline CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
                ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr,
                Instruction *InsertBefore);

inline CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
                const Twine &NameStr, Instruction *InsertBefore)
    : CallInst(Ty, Func, Args, None, NameStr, InsertBefore) {}

/// Construct a CallInst given a range of arguments.
/// Construct a CallInst from a range of arguments
inline CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
                ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr,
                BasicBlock *InsertAtEnd);

explicit CallInst(FunctionType *Ty, Value *F, const Twine &NameStr,
                  Instruction *InsertBefore);

CallInst(FunctionType *ty, Value *F, const Twine &NameStr,
         BasicBlock *InsertAtEnd);

void init(FunctionType *FTy, Value *Func, ArrayRef<Value *> Args,
          ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr);
void init(FunctionType *FTy, Value *Func, const Twine &NameStr);

/// Compute the number of operands to allocate.
static int ComputeNumOperands(int NumArgs, int NumBundleInputs = 0) {
  // We need one operand for the called function, plus the input operand
  // counts provided.
  return 1 + NumArgs + NumBundleInputs;
}

1486protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

CallInst *cloneImpl() const;

1492public:
static CallInst *Create(FunctionType *Ty, Value *F, const Twine &NameStr = "",
                        Instruction *InsertBefore = nullptr) {
  return new (ComputeNumOperands(0)) CallInst(Ty, F, NameStr, InsertBefore);
}

static CallInst *Create(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
                        const Twine &NameStr,
                        Instruction *InsertBefore = nullptr) {
  return new (ComputeNumOperands(Args.size()))
      CallInst(Ty, Func, Args, None, NameStr, InsertBefore);
}

static CallInst *Create(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
                        ArrayRef<OperandBundleDef> Bundles = None,
                        const Twine &NameStr = "",
                        Instruction *InsertBefore = nullptr) {
  const int NumOperands =
      ComputeNumOperands(Args.size(), CountBundleInputs(Bundles));
  const unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);

  return new (NumOperands, DescriptorBytes)
      CallInst(Ty, Func, Args, Bundles, NameStr, InsertBefore);
}

static CallInst *Create(FunctionType *Ty, Value *F, const Twine &NameStr,
                        BasicBlock *InsertAtEnd) {
  return new (ComputeNumOperands(0)) CallInst(Ty, F, NameStr, InsertAtEnd);
}

static CallInst *Create(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
                        const Twine &NameStr, BasicBlock *InsertAtEnd) {
  return new (ComputeNumOperands(Args.size()))
      CallInst(Ty, Func, Args, None, NameStr, InsertAtEnd);
}

static CallInst *Create(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
                        ArrayRef<OperandBundleDef> Bundles,
                        const Twine &NameStr, BasicBlock *InsertAtEnd) {
  const int NumOperands =
      ComputeNumOperands(Args.size(), CountBundleInputs(Bundles));
  const unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);

  return new (NumOperands, DescriptorBytes)
      CallInst(Ty, Func, Args, Bundles, NameStr, InsertAtEnd);
}

static CallInst *Create(FunctionCallee Func, const Twine &NameStr = "",
                        Instruction *InsertBefore = nullptr) {
  return Create(Func.getFunctionType(), Func.getCallee(), NameStr,
                InsertBefore);
}

static CallInst *Create(FunctionCallee Func, ArrayRef<Value *> Args,
                        ArrayRef<OperandBundleDef> Bundles = None,
                        const Twine &NameStr = "",
                        Instruction *InsertBefore = nullptr) {
  return Create(Func.getFunctionType(), Func.getCallee(), Args, Bundles,
                NameStr, InsertBefore);
}

static CallInst *Create(FunctionCallee Func, ArrayRef<Value *> Args,
                        const Twine &NameStr,
                        Instruction *InsertBefore = nullptr) {
  return Create(Func.getFunctionType(), Func.getCallee(), Args, NameStr,
                InsertBefore);
}

static CallInst *Create(FunctionCallee Func, const Twine &NameStr,
                        BasicBlock *InsertAtEnd) {
  return Create(Func.getFunctionType(), Func.getCallee(), NameStr,
                InsertAtEnd);
}

static CallInst *Create(FunctionCallee Func, ArrayRef<Value *> Args,
                        const Twine &NameStr, BasicBlock *InsertAtEnd) {
  return Create(Func.getFunctionType(), Func.getCallee(), Args, NameStr,
                InsertAtEnd);
}

static CallInst *Create(FunctionCallee Func, ArrayRef<Value *> Args,
                        ArrayRef<OperandBundleDef> Bundles,
                        const Twine &NameStr, BasicBlock *InsertAtEnd) {
  return Create(Func.getFunctionType(), Func.getCallee(), Args, Bundles,
                NameStr, InsertAtEnd);
}

/// Create a clone of \p CI with a different set of operand bundles and
/// insert it before \p InsertPt.
///
/// The returned call instruction is identical \p CI in every way except that
/// the operand bundles for the new instruction are set to the operand bundles
/// in \p Bundles.
static CallInst *Create(CallInst *CI, ArrayRef<OperandBundleDef> Bundles,
                        Instruction *InsertPt = nullptr);

/// Generate the IR for a call to malloc:
/// 1. Compute the malloc call's argument as the specified type's size,
///    possibly multiplied by the array size if the array size is not
///    constant 1.
/// 2. Call malloc with that argument.
/// 3. Bitcast the result of the malloc call to the specified type.
static Instruction *CreateMalloc(Instruction *InsertBefore, Type *IntPtrTy,
                                 Type *AllocTy, Value *AllocSize,
                                 Value *ArraySize = nullptr,
                                 Function *MallocF = nullptr,
                                 const Twine &Name = "");
static Instruction *CreateMalloc(BasicBlock *InsertAtEnd, Type *IntPtrTy,
                                 Type *AllocTy, Value *AllocSize,
                                 Value *ArraySize = nullptr,
                                 Function *MallocF = nullptr,
                                 const Twine &Name = "");
static Instruction *CreateMalloc(Instruction *InsertBefore, Type *IntPtrTy,
                                 Type *AllocTy, Value *AllocSize,
                                 Value *ArraySize = nullptr,
                                 ArrayRef<OperandBundleDef> Bundles = None,
                                 Function *MallocF = nullptr,
                                 const Twine &Name = "");
static Instruction *CreateMalloc(BasicBlock *InsertAtEnd, Type *IntPtrTy,
                                 Type *AllocTy, Value *AllocSize,
                                 Value *ArraySize = nullptr,
                                 ArrayRef<OperandBundleDef> Bundles = None,
                                 Function *MallocF = nullptr,
                                 const Twine &Name = "");
/// Generate the IR for a call to the builtin free function.
static Instruction *CreateFree(Value *Source, Instruction *InsertBefore);
static Instruction *CreateFree(Value *Source, BasicBlock *InsertAtEnd);
static Instruction *CreateFree(Value *Source,
                               ArrayRef<OperandBundleDef> Bundles,
                               Instruction *InsertBefore);
static Instruction *CreateFree(Value *Source,
                               ArrayRef<OperandBundleDef> Bundles,
                               BasicBlock *InsertAtEnd);

// Note that 'musttail' implies 'tail'.
enum TailCallKind : unsigned {
  TCK_None = 0,
  TCK_Tail = 1,
  TCK_MustTail = 2,
  TCK_NoTail = 3,
  TCK_LAST = TCK_NoTail
};

using TailCallKindField = Bitfield::Element<TailCallKind, 0, 2, TCK_LAST>;
static_assert(
    Bitfield::areContiguous<TailCallKindField, CallBase::CallingConvField>(),
    "Bitfields must be contiguous");

TailCallKind getTailCallKind() const {
  return getSubclassData<TailCallKindField>();
}

bool isTailCall() const {
  TailCallKind Kind = getTailCallKind();
  return Kind == TCK_Tail || Kind == TCK_MustTail;
}

bool isMustTailCall() const { return getTailCallKind() == TCK_MustTail; }

bool isNoTailCall() const { return getTailCallKind() == TCK_NoTail; }

void setTailCallKind(TailCallKind TCK) {
  setSubclassData<TailCallKindField>(TCK);
}

void setTailCall(bool IsTc = true) {
  setTailCallKind(IsTc ? TCK_Tail : TCK_None);
}

/// Return true if the call can return twice
bool canReturnTwice() const { return hasFnAttr(Attribute::ReturnsTwice); }
void setCanReturnTwice() {
  addAttribute(AttributeList::FunctionIndex, Attribute::ReturnsTwice);
}

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::Call;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}

/// Updates profile metadata by scaling it by \p S / \p T.
void updateProfWeight(uint64_t S, uint64_t T);

1678private:
// Shadow Instruction::setInstructionSubclassData with a private forwarding
// method so that subclasses cannot accidentally use it.
template <typename Bitfield>
void setSubclassData(typename Bitfield::Type Value) {
  Instruction::setSubclassData<Bitfield>(Value);
}
1685};

1687CallInst::CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
                 ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr,
                 BasicBlock *InsertAtEnd)
  : CallBase(Ty->getReturnType(), Instruction::Call,
             OperandTraits<CallBase>::op_end(this) -
                 (Args.size() + CountBundleInputs(Bundles) + 1),
             unsigned(Args.size() + CountBundleInputs(Bundles) + 1),
             InsertAtEnd) {
init(Ty, Func, Args, Bundles, NameStr);
1696}

1698CallInst::CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
                 ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr,
                 Instruction *InsertBefore)
  : CallBase(Ty->getReturnType(), Instruction::Call,
             OperandTraits<CallBase>::op_end(this) -
                 (Args.size() + CountBundleInputs(Bundles) + 1),
             unsigned(Args.size() + CountBundleInputs(Bundles) + 1),
             InsertBefore) {
init(Ty, Func, Args, Bundles, NameStr);
1707}

1709//===----------------------------------------------------------------------===//
1710//                               SelectInst Class
1711//===----------------------------------------------------------------------===//

1713/// This class represents the LLVM 'select' instruction.
1714///
1715class SelectInst : public Instruction {
SelectInst(Value *C, Value *S1, Value *S2, const Twine &NameStr,
           Instruction *InsertBefore)
  : Instruction(S1->getType(), Instruction::Select,
                &Op<0>(), 3, InsertBefore) {
  init(C, S1, S2);
  setName(NameStr);
}

SelectInst(Value *C, Value *S1, Value *S2, const Twine &NameStr,
           BasicBlock *InsertAtEnd)
  : Instruction(S1->getType(), Instruction::Select,
                &Op<0>(), 3, InsertAtEnd) {
  init(C, S1, S2);
  setName(NameStr);
}

void init(Value *C, Value *S1, Value *S2) {
  assert(!areInvalidOperands(C, S1, S2) && "Invalid operands for select")((!areInvalidOperands(C, S1, S2) && "Invalid operands for select"
) ? static_cast<void> (0) : __assert_fail ("!areInvalidOperands(C, S1, S2) && \"Invalid operands for select\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 1733, __PRETTY_FUNCTION__));
  Op<0>() = C;
  Op<1>() = S1;
  Op<2>() = S2;
}

1739protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

SelectInst *cloneImpl() const;

1745public:
static SelectInst *Create(Value *C, Value *S1, Value *S2,
                          const Twine &NameStr = "",
                          Instruction *InsertBefore = nullptr,
                          Instruction *MDFrom = nullptr) {
  SelectInst *Sel = new(3) SelectInst(C, S1, S2, NameStr, InsertBefore);
  if (MDFrom)
    Sel->copyMetadata(*MDFrom);
  return Sel;
}

static SelectInst *Create(Value *C, Value *S1, Value *S2,
                          const Twine &NameStr,
                          BasicBlock *InsertAtEnd) {
  return new(3) SelectInst(C, S1, S2, NameStr, InsertAtEnd);
}

const Value *getCondition() const { return Op<0>(); }
const Value *getTrueValue() const { return Op<1>(); }
const Value *getFalseValue() const { return Op<2>(); }
Value *getCondition() { return Op<0>(); }
Value *getTrueValue() { return Op<1>(); }
Value *getFalseValue() { return Op<2>(); }

void setCondition(Value *V) { Op<0>() = V; }
void setTrueValue(Value *V) { Op<1>() = V; }
void setFalseValue(Value *V) { Op<2>() = V; }

/// Swap the true and false values of the select instruction.
/// This doesn't swap prof metadata.
void swapValues() { Op<1>().swap(Op<2>()); }

/// Return a string if the specified operands are invalid
/// for a select operation, otherwise return null.
static const char *areInvalidOperands(Value *Cond, Value *True, Value *False);

/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
 setOperand(unsigned, Value*); inline op_iterator op_begin();
 inline const_op_iterator op_begin() const; inline op_iterator
 op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
 getNumOperands() const;

OtherOps getOpcode() const {
  return static_cast<OtherOps>(Instruction::getOpcode());
}

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::Select;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
1795};

1797template <>
1798struct OperandTraits<SelectInst> : public FixedNumOperandTraits<SelectInst, 3> {
1799};

1801DEFINE_TRANSPARENT_OPERAND_ACCESSORS(SelectInst, Value)SelectInst::op_iterator SelectInst::op_begin() { return OperandTraits
<SelectInst>::op_begin(this); } SelectInst::const_op_iterator
 SelectInst::op_begin() const { return OperandTraits<SelectInst
>::op_begin(const_cast<SelectInst*>(this)); } SelectInst
::op_iterator SelectInst::op_end() { return OperandTraits<
SelectInst>::op_end(this); } SelectInst::const_op_iterator
 SelectInst::op_end() const { return OperandTraits<SelectInst
>::op_end(const_cast<SelectInst*>(this)); } Value *SelectInst
::getOperand(unsigned i_nocapture) const { ((i_nocapture <
 OperandTraits<SelectInst>::operands(this) && "getOperand() out of range!"
) ? static_cast<void> (0) : __assert_fail ("i_nocapture < OperandTraits<SelectInst>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 1801, __PRETTY_FUNCTION__)); return cast_or_null<Value>
( OperandTraits<SelectInst>::op_begin(const_cast<SelectInst
*>(this))[i_nocapture].get()); } void SelectInst::setOperand
(unsigned i_nocapture, Value *Val_nocapture) { ((i_nocapture <
 OperandTraits<SelectInst>::operands(this) && "setOperand() out of range!"
) ? static_cast<void> (0) : __assert_fail ("i_nocapture < OperandTraits<SelectInst>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 1801, __PRETTY_FUNCTION__)); OperandTraits<SelectInst>
::op_begin(this)[i_nocapture] = Val_nocapture; } unsigned SelectInst
::getNumOperands() const { return OperandTraits<SelectInst
>::operands(this); } template <int Idx_nocapture> Use
 &SelectInst::Op() { return this->OpFrom<Idx_nocapture
>(this); } template <int Idx_nocapture> const Use &
SelectInst::Op() const { return this->OpFrom<Idx_nocapture
>(this); }

1803//===----------------------------------------------------------------------===//
1804//                                VAArgInst Class
1805//===----------------------------------------------------------------------===//

1807/// This class represents the va_arg llvm instruction, which returns
1808/// an argument of the specified type given a va_list and increments that list
1809///
1810class VAArgInst : public UnaryInstruction {
1811protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

VAArgInst *cloneImpl() const;

1817public:
VAArgInst(Value *List, Type *Ty, const Twine &NameStr = "",
           Instruction *InsertBefore = nullptr)
  : UnaryInstruction(Ty, VAArg, List, InsertBefore) {
  setName(NameStr);
}

VAArgInst(Value *List, Type *Ty, const Twine &NameStr,
          BasicBlock *InsertAtEnd)
  : UnaryInstruction(Ty, VAArg, List, InsertAtEnd) {
  setName(NameStr);
}

Value *getPointerOperand() { return getOperand(0); }
const Value *getPointerOperand() const { return getOperand(0); }
static unsigned getPointerOperandIndex() { return 0U; }

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == VAArg;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
1841};

1843//===----------------------------------------------------------------------===//
1844//                                ExtractElementInst Class
1845//===----------------------------------------------------------------------===//

1847/// This instruction extracts a single (scalar)
1848/// element from a VectorType value
1849///
1850class ExtractElementInst : public Instruction {
ExtractElementInst(Value *Vec, Value *Idx, const Twine &NameStr = "",
                   Instruction *InsertBefore = nullptr);
ExtractElementInst(Value *Vec, Value *Idx, const Twine &NameStr,
                   BasicBlock *InsertAtEnd);

1856protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

ExtractElementInst *cloneImpl() const;

1862public:
static ExtractElementInst *Create(Value *Vec, Value *Idx,
                                 const Twine &NameStr = "",
                                 Instruction *InsertBefore = nullptr) {
  return new(2) ExtractElementInst(Vec, Idx, NameStr, InsertBefore);
}

static ExtractElementInst *Create(Value *Vec, Value *Idx,
                                 const Twine &NameStr,
                                 BasicBlock *InsertAtEnd) {
  return new(2) ExtractElementInst(Vec, Idx, NameStr, InsertAtEnd);
}

/// Return true if an extractelement instruction can be
/// formed with the specified operands.
static bool isValidOperands(const Value *Vec, const Value *Idx);

Value *getVectorOperand() { return Op<0>(); }
Value *getIndexOperand() { return Op<1>(); }
const Value *getVectorOperand() const { return Op<0>(); }
const Value *getIndexOperand() const { return Op<1>(); }

VectorType *getVectorOperandType() const {
  return cast<VectorType>(getVectorOperand()->getType());
}

/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
 setOperand(unsigned, Value*); inline op_iterator op_begin();
 inline const_op_iterator op_begin() const; inline op_iterator
 op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
 getNumOperands() const;

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::ExtractElement;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
1898};

1900template <>
1901struct OperandTraits<ExtractElementInst> :
public FixedNumOperandTraits<ExtractElementInst, 2> {
1903};

1905DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ExtractElementInst, Value)ExtractElementInst::op_iterator ExtractElementInst::op_begin(
) { return OperandTraits<ExtractElementInst>::op_begin(
this); } ExtractElementInst::const_op_iterator ExtractElementInst
::op_begin() const { return OperandTraits<ExtractElementInst
>::op_begin(const_cast<ExtractElementInst*>(this)); }
 ExtractElementInst::op_iterator ExtractElementInst::op_end()
 { return OperandTraits<ExtractElementInst>::op_end(this
); } ExtractElementInst::const_op_iterator ExtractElementInst
::op_end() const { return OperandTraits<ExtractElementInst
>::op_end(const_cast<ExtractElementInst*>(this)); } Value
 *ExtractElementInst::getOperand(unsigned i_nocapture) const {
 ((i_nocapture < OperandTraits<ExtractElementInst>::
operands(this) && "getOperand() out of range!") ? static_cast
<void> (0) : __assert_fail ("i_nocapture < OperandTraits<ExtractElementInst>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 1905, __PRETTY_FUNCTION__)); return cast_or_null<Value>
( OperandTraits<ExtractElementInst>::op_begin(const_cast
<ExtractElementInst*>(this))[i_nocapture].get()); } void
 ExtractElementInst::setOperand(unsigned i_nocapture, Value *
Val_nocapture) { ((i_nocapture < OperandTraits<ExtractElementInst
>::operands(this) && "setOperand() out of range!")
 ? static_cast<void> (0) : __assert_fail ("i_nocapture < OperandTraits<ExtractElementInst>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 1905, __PRETTY_FUNCTION__)); OperandTraits<ExtractElementInst
>::op_begin(this)[i_nocapture] = Val_nocapture; } unsigned
 ExtractElementInst::getNumOperands() const { return OperandTraits
<ExtractElementInst>::operands(this); } template <int
 Idx_nocapture> Use &ExtractElementInst::Op() { return
 this->OpFrom<Idx_nocapture>(this); } template <int
 Idx_nocapture> const Use &ExtractElementInst::Op() const
 { return this->OpFrom<Idx_nocapture>(this); }

1907//===----------------------------------------------------------------------===//
1908//                                InsertElementInst Class
1909//===----------------------------------------------------------------------===//

1911/// This instruction inserts a single (scalar)
1912/// element into a VectorType value
1913///
1914class InsertElementInst : public Instruction {
InsertElementInst(Value *Vec, Value *NewElt, Value *Idx,
                  const Twine &NameStr = "",
                  Instruction *InsertBefore = nullptr);
InsertElementInst(Value *Vec, Value *NewElt, Value *Idx, const Twine &NameStr,
                  BasicBlock *InsertAtEnd);

1921protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

InsertElementInst *cloneImpl() const;

1927public:
static InsertElementInst *Create(Value *Vec, Value *NewElt, Value *Idx,
                                 const Twine &NameStr = "",
                                 Instruction *InsertBefore = nullptr) {
  return new(3) InsertElementInst(Vec, NewElt, Idx, NameStr, InsertBefore);
}

static InsertElementInst *Create(Value *Vec, Value *NewElt, Value *Idx,
                                 const Twine &NameStr,
                                 BasicBlock *InsertAtEnd) {
  return new(3) InsertElementInst(Vec, NewElt, Idx, NameStr, InsertAtEnd);
}

/// Return true if an insertelement instruction can be
/// formed with the specified operands.
static bool isValidOperands(const Value *Vec, const Value *NewElt,
                            const Value *Idx);

/// Overload to return most specific vector type.
///
VectorType *getType() const {
  return cast<VectorType>(Instruction::getType());
}

/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
 setOperand(unsigned, Value*); inline op_iterator op_begin();
 inline const_op_iterator op_begin() const; inline op_iterator
 op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
 getNumOperands() const;

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::InsertElement;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
1961};

1963template <>
1964struct OperandTraits<InsertElementInst> :
public FixedNumOperandTraits<InsertElementInst, 3> {
1966};

1968DEFINE_TRANSPARENT_OPERAND_ACCESSORS(InsertElementInst, Value)InsertElementInst::op_iterator InsertElementInst::op_begin() {
 return OperandTraits<InsertElementInst>::op_begin(this
); } InsertElementInst::const_op_iterator InsertElementInst::
op_begin() const { return OperandTraits<InsertElementInst>
::op_begin(const_cast<InsertElementInst*>(this)); } InsertElementInst
::op_iterator InsertElementInst::op_end() { return OperandTraits
<InsertElementInst>::op_end(this); } InsertElementInst::
const_op_iterator InsertElementInst::op_end() const { return OperandTraits
<InsertElementInst>::op_end(const_cast<InsertElementInst
*>(this)); } Value *InsertElementInst::getOperand(unsigned
 i_nocapture) const { ((i_nocapture < OperandTraits<InsertElementInst
>::operands(this) && "getOperand() out of range!")
 ? static_cast<void> (0) : __assert_fail ("i_nocapture < OperandTraits<InsertElementInst>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 1968, __PRETTY_FUNCTION__)); return cast_or_null<Value>
( OperandTraits<InsertElementInst>::op_begin(const_cast
<InsertElementInst*>(this))[i_nocapture].get()); } void
 InsertElementInst::setOperand(unsigned i_nocapture, Value *Val_nocapture
) { ((i_nocapture < OperandTraits<InsertElementInst>
::operands(this) && "setOperand() out of range!") ? static_cast
<void> (0) : __assert_fail ("i_nocapture < OperandTraits<InsertElementInst>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 1968, __PRETTY_FUNCTION__)); OperandTraits<InsertElementInst
>::op_begin(this)[i_nocapture] = Val_nocapture; } unsigned
 InsertElementInst::getNumOperands() const { return OperandTraits
<InsertElementInst>::operands(this); } template <int
 Idx_nocapture> Use &InsertElementInst::Op() { return this
->OpFrom<Idx_nocapture>(this); } template <int Idx_nocapture
> const Use &InsertElementInst::Op() const { return this
->OpFrom<Idx_nocapture>(this); }

1970//===----------------------------------------------------------------------===//
1971//                           ShuffleVectorInst Class
1972//===----------------------------------------------------------------------===//

1974constexpr int UndefMaskElem = -1;

1976/// This instruction constructs a fixed permutation of two
1977/// input vectors.
1978///
1979/// For each element of the result vector, the shuffle mask selects an element
1980/// from one of the input vectors to copy to the result. Non-negative elements
1981/// in the mask represent an index into the concatenated pair of input vectors.
1982/// UndefMaskElem (-1) specifies that the result element is undefined.
1983///
1984/// For scalable vectors, all the elements of the mask must be 0 or -1. This
1985/// requirement may be relaxed in the future.
1986class ShuffleVectorInst : public Instruction {
SmallVector<int, 4> ShuffleMask;
Constant *ShuffleMaskForBitcode;

1990protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

ShuffleVectorInst *cloneImpl() const;

1996public:
ShuffleVectorInst(Value *V1, Value *V2, Value *Mask,
                  const Twine &NameStr = "",
                  Instruction *InsertBefor = nullptr);
ShuffleVectorInst(Value *V1, Value *V2, Value *Mask,
                  const Twine &NameStr, BasicBlock *InsertAtEnd);
ShuffleVectorInst(Value *V1, Value *V2, ArrayRef<int> Mask,
                  const Twine &NameStr = "",
                  Instruction *InsertBefor = nullptr);
ShuffleVectorInst(Value *V1, Value *V2, ArrayRef<int> Mask,
                  const Twine &NameStr, BasicBlock *InsertAtEnd);

void *operator new(size_t s) { return User::operator new(s, 2); }

/// Swap the operands and adjust the mask to preserve the semantics
/// of the instruction.
void commute();

/// Return true if a shufflevector instruction can be
/// formed with the specified operands.
static bool isValidOperands(const Value *V1, const Value *V2,
                            const Value *Mask);
static bool isValidOperands(const Value *V1, const Value *V2,
                            ArrayRef<int> Mask);

/// Overload to return most specific vector type.
///
VectorType *getType() const {
  return cast<VectorType>(Instruction::getType());
}

/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
 setOperand(unsigned, Value*); inline op_iterator op_begin();
 inline const_op_iterator op_begin() const; inline op_iterator
 op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
 getNumOperands() const;

/// Return the shuffle mask value of this instruction for the given element
/// index. Return UndefMaskElem if the element is undef.
int getMaskValue(unsigned Elt) const { return ShuffleMask[Elt]; }

/// Convert the input shuffle mask operand to a vector of integers. Undefined
/// elements of the mask are returned as UndefMaskElem.
static void getShuffleMask(const Constant *Mask,
                           SmallVectorImpl<int> &Result);

/// Return the mask for this instruction as a vector of integers. Undefined
/// elements of the mask are returned as UndefMaskElem.
void getShuffleMask(SmallVectorImpl<int> &Result) const {
  Result.assign(ShuffleMask.begin(), ShuffleMask.end());
}

/// Return the mask for this instruction, for use in bitcode.
///
/// TODO: This is temporary until we decide a new bitcode encoding for
/// shufflevector.
Constant *getShuffleMaskForBitcode() const { return ShuffleMaskForBitcode; }

static Constant *convertShuffleMaskForBitcode(ArrayRef<int> Mask,
                                              Type *ResultTy);

void setShuffleMask(ArrayRef<int> Mask);

ArrayRef<int> getShuffleMask() const { return ShuffleMask; }

/// Return true if this shuffle returns a vector with a different number of
/// elements than its source vectors.
/// Examples: shufflevector <4 x n> A, <4 x n> B, <1,2,3>
///           shufflevector <4 x n> A, <4 x n> B, <1,2,3,4,5>
bool changesLength() const {
  unsigned NumSourceElts = cast<VectorType>(Op<0>()->getType())
                               ->getElementCount()
                               .getKnownMinValue();
  unsigned NumMaskElts = ShuffleMask.size();
  return NumSourceElts != NumMaskElts;
}

/// Return true if this shuffle returns a vector with a greater number of
/// elements than its source vectors.
/// Example: shufflevector <2 x n> A, <2 x n> B, <1,2,3>
bool increasesLength() const {
  unsigned NumSourceElts = cast<VectorType>(Op<0>()->getType())
                               ->getElementCount()
                               .getKnownMinValue();
  unsigned NumMaskElts = ShuffleMask.size();
  return NumSourceElts < NumMaskElts;
}

/// Return true if this shuffle mask chooses elements from exactly one source
/// vector.
/// Example: <7,5,undef,7>
/// This assumes that vector operands are the same length as the mask.
static bool isSingleSourceMask(ArrayRef<int> Mask);
static bool isSingleSourceMask(const Constant *Mask) {
  assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.")((Mask->getType()->isVectorTy() && "Shuffle needs vector constant."
) ? static_cast<void> (0) : __assert_fail ("Mask->getType()->isVectorTy() && \"Shuffle needs vector constant.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 2087, __PRETTY_FUNCTION__));
  SmallVector<int, 16> MaskAsInts;
  getShuffleMask(Mask, MaskAsInts);
  return isSingleSourceMask(MaskAsInts);
}

/// Return true if this shuffle chooses elements from exactly one source
/// vector without changing the length of that vector.
/// Example: shufflevector <4 x n> A, <4 x n> B, <3,0,undef,3>
/// TODO: Optionally allow length-changing shuffles.
bool isSingleSource() const {
  return !changesLength() && isSingleSourceMask(ShuffleMask);
}

/// Return true if this shuffle mask chooses elements from exactly one source
/// vector without lane crossings. A shuffle using this mask is not
/// necessarily a no-op because it may change the number of elements from its
/// input vectors or it may provide demanded bits knowledge via undef lanes.
/// Example: <undef,undef,2,3>
static bool isIdentityMask(ArrayRef<int> Mask);
static bool isIdentityMask(const Constant *Mask) {
  assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.")((Mask->getType()->isVectorTy() && "Shuffle needs vector constant."
) ? static_cast<void> (0) : __assert_fail ("Mask->getType()->isVectorTy() && \"Shuffle needs vector constant.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 2108, __PRETTY_FUNCTION__));
  SmallVector<int, 16> MaskAsInts;
  getShuffleMask(Mask, MaskAsInts);
  return isIdentityMask(MaskAsInts);
}

/// Return true if this shuffle chooses elements from exactly one source
/// vector without lane crossings and does not change the number of elements
/// from its input vectors.
/// Example: shufflevector <4 x n> A, <4 x n> B, <4,undef,6,undef>
bool isIdentity() const {
  return !changesLength() && isIdentityMask(ShuffleMask);
}

/// Return true if this shuffle lengthens exactly one source vector with
/// undefs in the high elements.
bool isIdentityWithPadding() const;

/// Return true if this shuffle extracts the first N elements of exactly one
/// source vector.
bool isIdentityWithExtract() const;

/// Return true if this shuffle concatenates its 2 source vectors. This
/// returns false if either input is undefined. In that case, the shuffle is
/// is better classified as an identity with padding operation.
bool isConcat() const;

/// Return true if this shuffle mask chooses elements from its source vectors
/// without lane crossings. A shuffle using this mask would be
/// equivalent to a vector select with a constant condition operand.
/// Example: <4,1,6,undef>
/// This returns false if the mask does not choose from both input vectors.
/// In that case, the shuffle is better classified as an identity shuffle.
/// This assumes that vector operands are the same length as the mask
/// (a length-changing shuffle can never be equivalent to a vector select).
static bool isSelectMask(ArrayRef<int> Mask);
static bool isSelectMask(const Constant *Mask) {
  assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.")((Mask->getType()->isVectorTy() && "Shuffle needs vector constant."
) ? static_cast<void> (0) : __assert_fail ("Mask->getType()->isVectorTy() && \"Shuffle needs vector constant.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 2145, __PRETTY_FUNCTION__));
  SmallVector<int, 16> MaskAsInts;
  getShuffleMask(Mask, MaskAsInts);
  return isSelectMask(MaskAsInts);
}

/// Return true if this shuffle chooses elements from its source vectors
/// without lane crossings and all operands have the same number of elements.
/// In other words, this shuffle is equivalent to a vector select with a
/// constant condition operand.
/// Example: shufflevector <4 x n> A, <4 x n> B, <undef,1,6,3>
/// This returns false if the mask does not choose from both input vectors.
/// In that case, the shuffle is better classified as an identity shuffle.
/// TODO: Optionally allow length-changing shuffles.
bool isSelect() const {
  return !changesLength() && isSelectMask(ShuffleMask);
}

/// Return true if this shuffle mask swaps the order of elements from exactly
/// one source vector.
/// Example: <7,6,undef,4>
/// This assumes that vector operands are the same length as the mask.
static bool isReverseMask(ArrayRef<int> Mask);
static bool isReverseMask(const Constant *Mask) {
  assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.")((Mask->getType()->isVectorTy() && "Shuffle needs vector constant."
) ? static_cast<void> (0) : __assert_fail ("Mask->getType()->isVectorTy() && \"Shuffle needs vector constant.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 2169, __PRETTY_FUNCTION__));
  SmallVector<int, 16> MaskAsInts;
  getShuffleMask(Mask, MaskAsInts);
  return isReverseMask(MaskAsInts);
}

/// Return true if this shuffle swaps the order of elements from exactly
/// one source vector.
/// Example: shufflevector <4 x n> A, <4 x n> B, <3,undef,1,undef>
/// TODO: Optionally allow length-changing shuffles.
bool isReverse() const {
  return !changesLength() && isReverseMask(ShuffleMask);
}

/// Return true if this shuffle mask chooses all elements with the same value
/// as the first element of exactly one source vector.
/// Example: <4,undef,undef,4>
/// This assumes that vector operands are the same length as the mask.
static bool isZeroEltSplatMask(ArrayRef<int> Mask);
static bool isZeroEltSplatMask(const Constant *Mask) {
  assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.")((Mask->getType()->isVectorTy() && "Shuffle needs vector constant."
) ? static_cast<void> (0) : __assert_fail ("Mask->getType()->isVectorTy() && \"Shuffle needs vector constant.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 2189, __PRETTY_FUNCTION__));
  SmallVector<int, 16> MaskAsInts;
  getShuffleMask(Mask, MaskAsInts);
  return isZeroEltSplatMask(MaskAsInts);
}

/// Return true if all elements of this shuffle are the same value as the
/// first element of exactly one source vector without changing the length
/// of that vector.
/// Example: shufflevector <4 x n> A, <4 x n> B, <undef,0,undef,0>
/// TODO: Optionally allow length-changing shuffles.
/// TODO: Optionally allow splats from other elements.
bool isZeroEltSplat() const {
  return !changesLength() && isZeroEltSplatMask(ShuffleMask);
}

/// Return true if this shuffle mask is a transpose mask.
/// Transpose vector masks transpose a 2xn matrix. They read corresponding
/// even- or odd-numbered vector elements from two n-dimensional source
/// vectors and write each result into consecutive elements of an
/// n-dimensional destination vector. Two shuffles are necessary to complete
/// the transpose, one for the even elements and another for the odd elements.
/// This description closely follows how the TRN1 and TRN2 AArch64
/// instructions operate.
///
/// For example, a simple 2x2 matrix can be transposed with:
///
///   ; Original matrix
///   m0 = < a, b >
///   m1 = < c, d >
///
///   ; Transposed matrix
///   t0 = < a, c > = shufflevector m0, m1, < 0, 2 >
///   t1 = < b, d > = shufflevector m0, m1, < 1, 3 >
///
/// For matrices having greater than n columns, the resulting nx2 transposed
/// matrix is stored in two result vectors such that one vector contains
/// interleaved elements from all the even-numbered rows and the other vector
/// contains interleaved elements from all the odd-numbered rows. For example,
/// a 2x4 matrix can be transposed with:
///
///   ; Original matrix
///   m0 = < a, b, c, d >
///   m1 = < e, f, g, h >
///
///   ; Transposed matrix
///   t0 = < a, e, c, g > = shufflevector m0, m1 < 0, 4, 2, 6 >
///   t1 = < b, f, d, h > = shufflevector m0, m1 < 1, 5, 3, 7 >
static bool isTransposeMask(ArrayRef<int> Mask);
static bool isTransposeMask(const Constant *Mask) {
  assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.")((Mask->getType()->isVectorTy() && "Shuffle needs vector constant."
) ? static_cast<void> (0) : __assert_fail ("Mask->getType()->isVectorTy() && \"Shuffle needs vector constant.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 2239, __PRETTY_FUNCTION__));
  SmallVector<int, 16> MaskAsInts;
  getShuffleMask(Mask, MaskAsInts);
  return isTransposeMask(MaskAsInts);
}

/// Return true if this shuffle transposes the elements of its inputs without
/// changing the length of the vectors. This operation may also be known as a
/// merge or interleave. See the description for isTransposeMask() for the
/// exact specification.
/// Example: shufflevector <4 x n> A, <4 x n> B, <0,4,2,6>
bool isTranspose() const {
  return !changesLength() && isTransposeMask(ShuffleMask);
}

/// Return true if this shuffle mask is an extract subvector mask.
/// A valid extract subvector mask returns a smaller vector from a single
/// source operand. The base extraction index is returned as well.
static bool isExtractSubvectorMask(ArrayRef<int> Mask, int NumSrcElts,
                                   int &Index);
static bool isExtractSubvectorMask(const Constant *Mask, int NumSrcElts,
                                   int &Index) {
  assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.")((Mask->getType()->isVectorTy() && "Shuffle needs vector constant."
) ? static_cast<void> (0) : __assert_fail ("Mask->getType()->isVectorTy() && \"Shuffle needs vector constant.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 2261, __PRETTY_FUNCTION__));
  // Not possible to express a shuffle mask for a scalable vector for this
  // case.
  if (isa<ScalableVectorType>(Mask->getType()))
    return false;
  SmallVector<int, 16> MaskAsInts;
  getShuffleMask(Mask, MaskAsInts);
  return isExtractSubvectorMask(MaskAsInts, NumSrcElts, Index);
}

/// Return true if this shuffle mask is an extract subvector mask.
bool isExtractSubvectorMask(int &Index) const {
  // Not possible to express a shuffle mask for a scalable vector for this
  // case.
  if (isa<ScalableVectorType>(getType()))
    return false;

  int NumSrcElts =
      cast<FixedVectorType>(Op<0>()->getType())->getNumElements();
  return isExtractSubvectorMask(ShuffleMask, NumSrcElts, Index);
}

/// Change values in a shuffle permute mask assuming the two vector operands
/// of length InVecNumElts have swapped position.
static void commuteShuffleMask(MutableArrayRef<int> Mask,
                               unsigned InVecNumElts) {
  for (int &Idx : Mask) {
    if (Idx == -1)
      continue;
    Idx = Idx < (int)InVecNumElts ? Idx + InVecNumElts : Idx - InVecNumElts;
    assert(Idx >= 0 && Idx < (int)InVecNumElts * 2 &&((Idx >= 0 && Idx < (int)InVecNumElts * 2 &&
 "shufflevector mask index out of range") ? static_cast<void
> (0) : __assert_fail ("Idx >= 0 && Idx < (int)InVecNumElts * 2 && \"shufflevector mask index out of range\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 2292, __PRETTY_FUNCTION__))
           "shufflevector mask index out of range")((Idx >= 0 && Idx < (int)InVecNumElts * 2 &&
 "shufflevector mask index out of range") ? static_cast<void
> (0) : __assert_fail ("Idx >= 0 && Idx < (int)InVecNumElts * 2 && \"shufflevector mask index out of range\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 2292, __PRETTY_FUNCTION__));
  }
}

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::ShuffleVector;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
2303};

2305template <>
2306struct OperandTraits<ShuffleVectorInst>
  : public FixedNumOperandTraits<ShuffleVectorInst, 2> {};

2309DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ShuffleVectorInst, Value)ShuffleVectorInst::op_iterator ShuffleVectorInst::op_begin() {
 return OperandTraits<ShuffleVectorInst>::op_begin(this
); } ShuffleVectorInst::const_op_iterator ShuffleVectorInst::
op_begin() const { return OperandTraits<ShuffleVectorInst>
::op_begin(const_cast<ShuffleVectorInst*>(this)); } ShuffleVectorInst
::op_iterator ShuffleVectorInst::op_end() { return OperandTraits
<ShuffleVectorInst>::op_end(this); } ShuffleVectorInst::
const_op_iterator ShuffleVectorInst::op_end() const { return OperandTraits
<ShuffleVectorInst>::op_end(const_cast<ShuffleVectorInst
*>(this)); } Value *ShuffleVectorInst::getOperand(unsigned
 i_nocapture) const { ((i_nocapture < OperandTraits<ShuffleVectorInst
>::operands(this) && "getOperand() out of range!")
 ? static_cast<void> (0) : __assert_fail ("i_nocapture < OperandTraits<ShuffleVectorInst>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 2309, __PRETTY_FUNCTION__)); return cast_or_null<Value>
( OperandTraits<ShuffleVectorInst>::op_begin(const_cast
<ShuffleVectorInst*>(this))[i_nocapture].get()); } void
 ShuffleVectorInst::setOperand(unsigned i_nocapture, Value *Val_nocapture
) { ((i_nocapture < OperandTraits<ShuffleVectorInst>
::operands(this) && "setOperand() out of range!") ? static_cast
<void> (0) : __assert_fail ("i_nocapture < OperandTraits<ShuffleVectorInst>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 2309, __PRETTY_FUNCTION__)); OperandTraits<ShuffleVectorInst
>::op_begin(this)[i_nocapture] = Val_nocapture; } unsigned
 ShuffleVectorInst::getNumOperands() const { return OperandTraits
<ShuffleVectorInst>::operands(this); } template <int
 Idx_nocapture> Use &ShuffleVectorInst::Op() { return this
->OpFrom<Idx_nocapture>(this); } template <int Idx_nocapture
> const Use &ShuffleVectorInst::Op() const { return this
->OpFrom<Idx_nocapture>(this); }

2311//===----------------------------------------------------------------------===//
2312//                                ExtractValueInst Class
2313//===----------------------------------------------------------------------===//

2315/// This instruction extracts a struct member or array
2316/// element value from an aggregate value.
2317///
2318class ExtractValueInst : public UnaryInstruction {
SmallVector<unsigned, 4> Indices;

ExtractValueInst(const ExtractValueInst &EVI);

/// Constructors - Create a extractvalue instruction with a base aggregate
/// value and a list of indices.  The first ctor can optionally insert before
/// an existing instruction, the second appends the new instruction to the
/// specified BasicBlock.
inline ExtractValueInst(Value *Agg,
                        ArrayRef<unsigned> Idxs,
                        const Twine &NameStr,
                        Instruction *InsertBefore);
inline ExtractValueInst(Value *Agg,
                        ArrayRef<unsigned> Idxs,
                        const Twine &NameStr, BasicBlock *InsertAtEnd);

void init(ArrayRef<unsigned> Idxs, const Twine &NameStr);

2337protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

ExtractValueInst *cloneImpl() const;

2343public:
static ExtractValueInst *Create(Value *Agg,
                                ArrayRef<unsigned> Idxs,
                                const Twine &NameStr = "",
                                Instruction *InsertBefore = nullptr) {
  return new
    ExtractValueInst(Agg, Idxs, NameStr, InsertBefore);
}

static ExtractValueInst *Create(Value *Agg,
                                ArrayRef<unsigned> Idxs,
                                const Twine &NameStr,
                                BasicBlock *InsertAtEnd) {
  return new ExtractValueInst(Agg, Idxs, NameStr, InsertAtEnd);
}

/// Returns the type of the element that would be extracted
/// with an extractvalue instruction with the specified parameters.
///
/// Null is returned if the indices are invalid for the specified type.
static Type *getIndexedType(Type *Agg, ArrayRef<unsigned> Idxs);

using idx_iterator = const unsigned*;

inline idx_iterator idx_begin() const { return Indices.begin(); }
inline idx_iterator idx_end()   const { return Indices.end(); }
inline iterator_range<idx_iterator> indices() const {
  return make_range(idx_begin(), idx_end());
}

Value *getAggregateOperand() {
  return getOperand(0);
}
const Value *getAggregateOperand() const {
  return getOperand(0);
}
static unsigned getAggregateOperandIndex() {
  return 0U;                      // get index for modifying correct operand
}

ArrayRef<unsigned> getIndices() const {
  return Indices;
}

unsigned getNumIndices() const {
  return (unsigned)Indices.size();
}

bool hasIndices() const {
  return true;
}

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::ExtractValue;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
2402};

2404ExtractValueInst::ExtractValueInst(Value *Agg,
                                 ArrayRef<unsigned> Idxs,
                                 const Twine &NameStr,
                                 Instruction *InsertBefore)
: UnaryInstruction(checkGEPType(getIndexedType(Agg->getType(), Idxs)),
                   ExtractValue, Agg, InsertBefore) {
init(Idxs, NameStr);
2411}

2413ExtractValueInst::ExtractValueInst(Value *Agg,
                                 ArrayRef<unsigned> Idxs,
                                 const Twine &NameStr,
                                 BasicBlock *InsertAtEnd)
: UnaryInstruction(checkGEPType(getIndexedType(Agg->getType(), Idxs)),
                   ExtractValue, Agg, InsertAtEnd) {
init(Idxs, NameStr);
2420}

2422//===----------------------------------------------------------------------===//
2423//                                InsertValueInst Class
2424//===----------------------------------------------------------------------===//

2426/// This instruction inserts a struct field of array element
2427/// value into an aggregate value.
2428///
2429class InsertValueInst : public Instruction {
SmallVector<unsigned, 4> Indices;

InsertValueInst(const InsertValueInst &IVI);

/// Constructors - Create a insertvalue instruction with a base aggregate
/// value, a value to insert, and a list of indices.  The first ctor can
/// optionally insert before an existing instruction, the second appends
/// the new instruction to the specified BasicBlock.
inline InsertValueInst(Value *Agg, Value *Val,
                       ArrayRef<unsigned> Idxs,
                       const Twine &NameStr,
                       Instruction *InsertBefore);
inline InsertValueInst(Value *Agg, Value *Val,
                       ArrayRef<unsigned> Idxs,
                       const Twine &NameStr, BasicBlock *InsertAtEnd);

/// Constructors - These two constructors are convenience methods because one
/// and two index insertvalue instructions are so common.
InsertValueInst(Value *Agg, Value *Val, unsigned Idx,
                const Twine &NameStr = "",
                Instruction *InsertBefore = nullptr);
InsertValueInst(Value *Agg, Value *Val, unsigned Idx, const Twine &NameStr,
                BasicBlock *InsertAtEnd);

void init(Value *Agg, Value *Val, ArrayRef<unsigned> Idxs,
          const Twine &NameStr);

2457protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

InsertValueInst *cloneImpl() const;

2463public:
// allocate space for exactly two operands
void *operator new(size_t s) {
  return User::operator new(s, 2);
}

static InsertValueInst *Create(Value *Agg, Value *Val,
                               ArrayRef<unsigned> Idxs,
                               const Twine &NameStr = "",
                               Instruction *InsertBefore = nullptr) {
  return new InsertValueInst(Agg, Val, Idxs, NameStr, InsertBefore);
}

static InsertValueInst *Create(Value *Agg, Value *Val,
                               ArrayRef<unsigned> Idxs,
                               const Twine &NameStr,
                               BasicBlock *InsertAtEnd) {
  return new InsertValueInst(Agg, Val, Idxs, NameStr, InsertAtEnd);
}

/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
 setOperand(unsigned, Value*); inline op_iterator op_begin();
 inline const_op_iterator op_begin() const; inline op_iterator
 op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
 getNumOperands() const;

using idx_iterator = const unsigned*;

inline idx_iterator idx_begin() const { return Indices.begin(); }
inline idx_iterator idx_end()   const { return Indices.end(); }
inline iterator_range<idx_iterator> indices() const {
  return make_range(idx_begin(), idx_end());
}

Value *getAggregateOperand() {
  return getOperand(0);
}
const Value *getAggregateOperand() const {
  return getOperand(0);
}
static unsigned getAggregateOperandIndex() {
  return 0U;                      // get index for modifying correct operand
}

Value *getInsertedValueOperand() {
  return getOperand(1);
}
const Value *getInsertedValueOperand() const {
  return getOperand(1);
}
static unsigned getInsertedValueOperandIndex() {
  return 1U;                      // get index for modifying correct operand
}

ArrayRef<unsigned> getIndices() const {
  return Indices;
}

unsigned getNumIndices() const {
  return (unsigned)Indices.size();
}

bool hasIndices() const {
  return true;
}

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::InsertValue;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
2533};

2535template <>
2536struct OperandTraits<InsertValueInst> :
public FixedNumOperandTraits<InsertValueInst, 2> {
2538};

2540InsertValueInst::InsertValueInst(Value *Agg,
                               Value *Val,
                               ArrayRef<unsigned> Idxs,
                               const Twine &NameStr,
                               Instruction *InsertBefore)
: Instruction(Agg->getType(), InsertValue,
              OperandTraits<InsertValueInst>::op_begin(this),
              2, InsertBefore) {
init(Agg, Val, Idxs, NameStr);
2549}

2551InsertValueInst::InsertValueInst(Value *Agg,
                               Value *Val,
                               ArrayRef<unsigned> Idxs,
                               const Twine &NameStr,
                               BasicBlock *InsertAtEnd)
: Instruction(Agg->getType(), InsertValue,
              OperandTraits<InsertValueInst>::op_begin(this),
              2, InsertAtEnd) {
init(Agg, Val, Idxs, NameStr);
2560}

2562DEFINE_TRANSPARENT_OPERAND_ACCESSORS(InsertValueInst, Value)InsertValueInst::op_iterator InsertValueInst::op_begin() { return
 OperandTraits<InsertValueInst>::op_begin(this); } InsertValueInst
::const_op_iterator InsertValueInst::op_begin() const { return
 OperandTraits<InsertValueInst>::op_begin(const_cast<
InsertValueInst*>(this)); } InsertValueInst::op_iterator InsertValueInst
::op_end() { return OperandTraits<InsertValueInst>::op_end
(this); } InsertValueInst::const_op_iterator InsertValueInst::
op_end() const { return OperandTraits<InsertValueInst>::
op_end(const_cast<InsertValueInst*>(this)); } Value *InsertValueInst
::getOperand(unsigned i_nocapture) const { ((i_nocapture <
 OperandTraits<InsertValueInst>::operands(this) &&
 "getOperand() out of range!") ? static_cast<void> (0) :
 __assert_fail ("i_nocapture < OperandTraits<InsertValueInst>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 2562, __PRETTY_FUNCTION__)); return cast_or_null<Value>
( OperandTraits<InsertValueInst>::op_begin(const_cast<
InsertValueInst*>(this))[i_nocapture].get()); } void InsertValueInst
::setOperand(unsigned i_nocapture, Value *Val_nocapture) { ((
i_nocapture < OperandTraits<InsertValueInst>::operands
(this) && "setOperand() out of range!") ? static_cast
<void> (0) : __assert_fail ("i_nocapture < OperandTraits<InsertValueInst>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 2562, __PRETTY_FUNCTION__)); OperandTraits<InsertValueInst
>::op_begin(this)[i_nocapture] = Val_nocapture; } unsigned
 InsertValueInst::getNumOperands() const { return OperandTraits
<InsertValueInst>::operands(this); } template <int Idx_nocapture
> Use &InsertValueInst::Op() { return this->OpFrom<
Idx_nocapture>(this); } template <int Idx_nocapture>
 const Use &InsertValueInst::Op() const { return this->
OpFrom<Idx_nocapture>(this); }

2564//===----------------------------------------------------------------------===//
2565//                               PHINode Class
2566//===----------------------------------------------------------------------===//

2568// PHINode - The PHINode class is used to represent the magical mystical PHI
2569// node, that can not exist in nature, but can be synthesized in a computer
2570// scientist's overactive imagination.
2571//
2572class PHINode : public Instruction {
/// The number of operands actually allocated.  NumOperands is
/// the number actually in use.
unsigned ReservedSpace;

PHINode(const PHINode &PN);

explicit PHINode(Type *Ty, unsigned NumReservedValues,
                 const Twine &NameStr = "",
                 Instruction *InsertBefore = nullptr)
  : Instruction(Ty, Instruction::PHI, nullptr, 0, InsertBefore),
    ReservedSpace(NumReservedValues) {
  setName(NameStr);
  allocHungoffUses(ReservedSpace);
}

PHINode(Type *Ty, unsigned NumReservedValues, const Twine &NameStr,
        BasicBlock *InsertAtEnd)
  : Instruction(Ty, Instruction::PHI, nullptr, 0, InsertAtEnd),
    ReservedSpace(NumReservedValues) {
  setName(NameStr);
  allocHungoffUses(ReservedSpace);
}

2596protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

PHINode *cloneImpl() const;

// allocHungoffUses - this is more complicated than the generic
// User::allocHungoffUses, because we have to allocate Uses for the incoming
// values and pointers to the incoming blocks, all in one allocation.
void allocHungoffUses(unsigned N) {
  User::allocHungoffUses(N, /* IsPhi */ true);
}

2609public:
/// Constructors - NumReservedValues is a hint for the number of incoming
/// edges that this phi node will have (use 0 if you really have no idea).
static PHINode *Create(Type *Ty, unsigned NumReservedValues,
                       const Twine &NameStr = "",
                       Instruction *InsertBefore = nullptr) {
  return new PHINode(Ty, NumReservedValues, NameStr, InsertBefore);
}

static PHINode *Create(Type *Ty, unsigned NumReservedValues,
                       const Twine &NameStr, BasicBlock *InsertAtEnd) {
  return new PHINode(Ty, NumReservedValues, NameStr, InsertAtEnd);
}

/// Provide fast operand accessors
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
 setOperand(unsigned, Value*); inline op_iterator op_begin();
 inline const_op_iterator op_begin() const; inline op_iterator
 op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
 getNumOperands() const;

// Block iterator interface. This provides access to the list of incoming
// basic blocks, which parallels the list of incoming values.

using block_iterator = BasicBlock **;
using const_block_iterator = BasicBlock * const *;

block_iterator block_begin() {
  return reinterpret_cast<block_iterator>(op_begin() + ReservedSpace);
}

const_block_iterator block_begin() const {
  return reinterpret_cast<const_block_iterator>(op_begin() + ReservedSpace);
}

block_iterator block_end() {
  return block_begin() + getNumOperands();
}

const_block_iterator block_end() const {
  return block_begin() + getNumOperands();
}

iterator_range<block_iterator> blocks() {
  return make_range(block_begin(), block_end());
}

iterator_range<const_block_iterator> blocks() const {
  return make_range(block_begin(), block_end());
}

op_range incoming_values() { return operands(); }

const_op_range incoming_values() const { return operands(); }

/// Return the number of incoming edges
///
unsigned getNumIncomingValues() const { return getNumOperands(); }

/// Return incoming value number x
///
Value *getIncomingValue(unsigned i) const {
  return getOperand(i);
}
void setIncomingValue(unsigned i, Value *V) {
  assert(V && "PHI node got a null value!")((V && "PHI node got a null value!") ? static_cast<
void> (0) : __assert_fail ("V && \"PHI node got a null value!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 2670, __PRETTY_FUNCTION__));
  assert(getType() == V->getType() &&((getType() == V->getType() && "All operands to PHI node must be the same type as the PHI node!"
) ? static_cast<void> (0) : __assert_fail ("getType() == V->getType() && \"All operands to PHI node must be the same type as the PHI node!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 2672, __PRETTY_FUNCTION__))
         "All operands to PHI node must be the same type as the PHI node!")((getType() == V->getType() && "All operands to PHI node must be the same type as the PHI node!"
) ? static_cast<void> (0) : __assert_fail ("getType() == V->getType() && \"All operands to PHI node must be the same type as the PHI node!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 2672, __PRETTY_FUNCTION__));
  setOperand(i, V);
}

static unsigned getOperandNumForIncomingValue(unsigned i) {
  return i;
}

static unsigned getIncomingValueNumForOperand(unsigned i) {
  return i;
}

/// Return incoming basic block number @p i.
///
BasicBlock *getIncomingBlock(unsigned i) const {
  return block_begin()[i];
}

/// Return incoming basic block corresponding
/// to an operand of the PHI.
///
BasicBlock *getIncomingBlock(const Use &U) const {
  assert(this == U.getUser() && "Iterator doesn't point to PHI's Uses?")((this == U.getUser() && "Iterator doesn't point to PHI's Uses?"
) ? static_cast<void> (0) : __assert_fail ("this == U.getUser() && \"Iterator doesn't point to PHI's Uses?\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 2694, __PRETTY_FUNCTION__));
  return getIncomingBlock(unsigned(&U - op_begin()));
}

/// Return incoming basic block corresponding
/// to value use iterator.
///
BasicBlock *getIncomingBlock(Value::const_user_iterator I) const {
  return getIncomingBlock(I.getUse());
}

void setIncomingBlock(unsigned i, BasicBlock *BB) {
  assert(BB && "PHI node got a null basic block!")((BB && "PHI node got a null basic block!") ? static_cast
<void> (0) : __assert_fail ("BB && \"PHI node got a null basic block!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 2706, __PRETTY_FUNCTION__));
  block_begin()[i] = BB;
}

/// Replace every incoming basic block \p Old to basic block \p New.
void replaceIncomingBlockWith(const BasicBlock *Old, BasicBlock *New) {
  assert(New && Old && "PHI node got a null basic block!")((New && Old && "PHI node got a null basic block!"
) ? static_cast<void> (0) : __assert_fail ("New && Old && \"PHI node got a null basic block!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 2712, __PRETTY_FUNCTION__));
  for (unsigned Op = 0, NumOps = getNumOperands(); Op != NumOps; ++Op)
    if (getIncomingBlock(Op) == Old)
      setIncomingBlock(Op, New);
}

/// Add an incoming value to the end of the PHI list
///
void addIncoming(Value *V, BasicBlock *BB) {
  if (getNumOperands() == ReservedSpace)
    growOperands();  // Get more space!
  // Initialize some new operands.
  setNumHungOffUseOperands(getNumOperands() + 1);
  setIncomingValue(getNumOperands() - 1, V);
  setIncomingBlock(getNumOperands() - 1, BB);
}

/// Remove an incoming value.  This is useful if a
/// predecessor basic block is deleted.  The value removed is returned.
///
/// If the last incoming value for a PHI node is removed (and DeletePHIIfEmpty
/// is true), the PHI node is destroyed and any uses of it are replaced with
/// dummy values.  The only time there should be zero incoming values to a PHI
/// node is when the block is dead, so this strategy is sound.
///
Value *removeIncomingValue(unsigned Idx, bool DeletePHIIfEmpty = true);

Value *removeIncomingValue(const BasicBlock *BB, bool DeletePHIIfEmpty=true) {
  int Idx = getBasicBlockIndex(BB);
  assert(Idx >= 0 && "Invalid basic block argument to remove!")((Idx >= 0 && "Invalid basic block argument to remove!"
) ? static_cast<void> (0) : __assert_fail ("Idx >= 0 && \"Invalid basic block argument to remove!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 2741, __PRETTY_FUNCTION__));
  return removeIncomingValue(Idx, DeletePHIIfEmpty);
}

/// Return the first index of the specified basic
/// block in the value list for this PHI.  Returns -1 if no instance.
///
int getBasicBlockIndex(const BasicBlock *BB) const {
  for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
    if (block_begin()[i] == BB)
      return i;
  return -1;
}

Value *getIncomingValueForBlock(const BasicBlock *BB) const {
  int Idx = getBasicBlockIndex(BB);
  assert(Idx >= 0 && "Invalid basic block argument!")((Idx >= 0 && "Invalid basic block argument!") ? static_cast
<void> (0) : __assert_fail ("Idx >= 0 && \"Invalid basic block argument!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 2757, __PRETTY_FUNCTION__));
  return getIncomingValue(Idx);
}

/// Set every incoming value(s) for block \p BB to \p V.
void setIncomingValueForBlock(const BasicBlock *BB, Value *V) {
  assert(BB && "PHI node got a null basic block!")((BB && "PHI node got a null basic block!") ? static_cast
<void> (0) : __assert_fail ("BB && \"PHI node got a null basic block!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 2763, __PRETTY_FUNCTION__));
  bool Found = false;
  for (unsigned Op = 0, NumOps = getNumOperands(); Op != NumOps; ++Op)
    if (getIncomingBlock(Op) == BB) {
      Found = true;
      setIncomingValue(Op, V);
    }
  (void)Found;
  assert(Found && "Invalid basic block argument to set!")((Found && "Invalid basic block argument to set!") ? static_cast
<void> (0) : __assert_fail ("Found && \"Invalid basic block argument to set!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 2771, __PRETTY_FUNCTION__));
}

/// If the specified PHI node always merges together the
/// same value, return the value, otherwise return null.
Value *hasConstantValue() const;

/// Whether the specified PHI node always merges
/// together the same value, assuming undefs are equal to a unique
/// non-undef value.
bool hasConstantOrUndefValue() const;

/// If the PHI node is complete which means all of its parent's predecessors
/// have incoming value in this PHI, return true, otherwise return false.
bool isComplete() const {
  return llvm::all_of(predecessors(getParent()),
                      [this](const BasicBlock *Pred) {
                        return getBasicBlockIndex(Pred) >= 0;
                      });
}

/// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::PHI;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}

2800private:
void growOperands();
2802};

2804template <>
2805struct OperandTraits<PHINode> : public HungoffOperandTraits<2> {
2806};

2808DEFINE_TRANSPARENT_OPERAND_ACCESSORS(PHINode, Value)PHINode::op_iterator PHINode::op_begin() { return OperandTraits
<PHINode>::op_begin(this); } PHINode::const_op_iterator
 PHINode::op_begin() const { return OperandTraits<PHINode>
::op_begin(const_cast<PHINode*>(this)); } PHINode::op_iterator
 PHINode::op_end() { return OperandTraits<PHINode>::op_end
(this); } PHINode::const_op_iterator PHINode::op_end() const {
 return OperandTraits<PHINode>::op_end(const_cast<PHINode
*>(this)); } Value *PHINode::getOperand(unsigned i_nocapture
) const { ((i_nocapture < OperandTraits<PHINode>::operands
(this) && "getOperand() out of range!") ? static_cast
<void> (0) : __assert_fail ("i_nocapture < OperandTraits<PHINode>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 2808, __PRETTY_FUNCTION__)); return cast_or_null<Value>
( OperandTraits<PHINode>::op_begin(const_cast<PHINode
*>(this))[i_nocapture].get()); } void PHINode::setOperand(
unsigned i_nocapture, Value *Val_nocapture) { ((i_nocapture <
 OperandTraits<PHINode>::operands(this) && "setOperand() out of range!"
) ? static_cast<void> (0) : __assert_fail ("i_nocapture < OperandTraits<PHINode>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 2808, __PRETTY_FUNCTION__)); OperandTraits<PHINode>::
op_begin(this)[i_nocapture] = Val_nocapture; } unsigned PHINode
::getNumOperands() const { return OperandTraits<PHINode>
::operands(this); } template <int Idx_nocapture> Use &
PHINode::Op() { return this->OpFrom<Idx_nocapture>(this
); } template <int Idx_nocapture> const Use &PHINode
::Op() const { return this->OpFrom<Idx_nocapture>(this
); }

2810//===----------------------------------------------------------------------===//
2811//                           LandingPadInst Class
2812//===----------------------------------------------------------------------===//

2814//===---------------------------------------------------------------------------
2815/// The landingpad instruction holds all of the information
2816/// necessary to generate correct exception handling. The landingpad instruction
2817/// cannot be moved from the top of a landing pad block, which itself is
2818/// accessible only from the 'unwind' edge of an invoke. This uses the
2819/// SubclassData field in Value to store whether or not the landingpad is a
2820/// cleanup.
2821///
2822class LandingPadInst : public Instruction {
using CleanupField = BoolBitfieldElementT<0>;

/// The number of operands actually allocated.  NumOperands is
/// the number actually in use.
unsigned ReservedSpace;

LandingPadInst(const LandingPadInst &LP);

2831public:
enum ClauseType { Catch, Filter };

2834private:
explicit LandingPadInst(Type *RetTy, unsigned NumReservedValues,
                        const Twine &NameStr, Instruction *InsertBefore);
explicit LandingPadInst(Type *RetTy, unsigned NumReservedValues,
                        const Twine &NameStr, BasicBlock *InsertAtEnd);

// Allocate space for exactly zero operands.
void *operator new(size_t s) {
  return User::operator new(s);
}

void growOperands(unsigned Size);
void init(unsigned NumReservedValues, const Twine &NameStr);

2848protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

LandingPadInst *cloneImpl() const;

2854public:
/// Constructors - NumReservedClauses is a hint for the number of incoming
/// clauses that this landingpad will have (use 0 if you really have no idea).
static LandingPadInst *Create(Type *RetTy, unsigned NumReservedClauses,
                              const Twine &NameStr = "",
                              Instruction *InsertBefore = nullptr);
static LandingPadInst *Create(Type *RetTy, unsigned NumReservedClauses,
                              const Twine &NameStr, BasicBlock *InsertAtEnd);

/// Provide fast operand accessors
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
 setOperand(unsigned, Value*); inline op_iterator op_begin();
 inline const_op_iterator op_begin() const; inline op_iterator
 op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
 getNumOperands() const;

/// Return 'true' if this landingpad instruction is a
/// cleanup. I.e., it should be run when unwinding even if its landing pad
/// doesn't catch the exception.
bool isCleanup() const { return getSubclassData<CleanupField>(); }

/// Indicate that this landingpad instruction is a cleanup.
void setCleanup(bool V) { setSubclassData<CleanupField>(V); }

/// Add a catch or filter clause to the landing pad.
void addClause(Constant *ClauseVal);

/// Get the value of the clause at index Idx. Use isCatch/isFilter to
/// determine what type of clause this is.
Constant *getClause(unsigned Idx) const {
  return cast<Constant>(getOperandList()[Idx]);
}

/// Return 'true' if the clause and index Idx is a catch clause.
bool isCatch(unsigned Idx) const {
  return !isa<ArrayType>(getOperandList()[Idx]->getType());
}

/// Return 'true' if the clause and index Idx is a filter clause.
bool isFilter(unsigned Idx) const {
  return isa<ArrayType>(getOperandList()[Idx]->getType());
}

/// Get the number of clauses for this landing pad.
unsigned getNumClauses() const { return getNumOperands(); }

/// Grow the size of the operand list to accommodate the new
/// number of clauses.
void reserveClauses(unsigned Size) { growOperands(Size); }

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::LandingPad;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
2907};

2909template <>
2910struct OperandTraits<LandingPadInst> : public HungoffOperandTraits<1> {
2911};

2913DEFINE_TRANSPARENT_OPERAND_ACCESSORS(LandingPadInst, Value)LandingPadInst::op_iterator LandingPadInst::op_begin() { return
 OperandTraits<LandingPadInst>::op_begin(this); } LandingPadInst
::const_op_iterator LandingPadInst::op_begin() const { return
 OperandTraits<LandingPadInst>::op_begin(const_cast<
LandingPadInst*>(this)); } LandingPadInst::op_iterator LandingPadInst
::op_end() { return OperandTraits<LandingPadInst>::op_end
(this); } LandingPadInst::const_op_iterator LandingPadInst::op_end
() const { return OperandTraits<LandingPadInst>::op_end
(const_cast<LandingPadInst*>(this)); } Value *LandingPadInst
::getOperand(unsigned i_nocapture) const { ((i_nocapture <
 OperandTraits<LandingPadInst>::operands(this) &&
 "getOperand() out of range!") ? static_cast<void> (0) :
 __assert_fail ("i_nocapture < OperandTraits<LandingPadInst>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 2913, __PRETTY_FUNCTION__)); return cast_or_null<Value>
( OperandTraits<LandingPadInst>::op_begin(const_cast<
LandingPadInst*>(this))[i_nocapture].get()); } void LandingPadInst
::setOperand(unsigned i_nocapture, Value *Val_nocapture) { ((
i_nocapture < OperandTraits<LandingPadInst>::operands
(this) && "setOperand() out of range!") ? static_cast
<void> (0) : __assert_fail ("i_nocapture < OperandTraits<LandingPadInst>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 2913, __PRETTY_FUNCTION__)); OperandTraits<LandingPadInst
>::op_begin(this)[i_nocapture] = Val_nocapture; } unsigned
 LandingPadInst::getNumOperands() const { return OperandTraits
<LandingPadInst>::operands(this); } template <int Idx_nocapture
> Use &LandingPadInst::Op() { return this->OpFrom<
Idx_nocapture>(this); } template <int Idx_nocapture>
 const Use &LandingPadInst::Op() const { return this->
OpFrom<Idx_nocapture>(this); }

2915//===----------------------------------------------------------------------===//
2916//                               ReturnInst Class
2917//===----------------------------------------------------------------------===//

2919//===---------------------------------------------------------------------------
2920/// Return a value (possibly void), from a function.  Execution
2921/// does not continue in this function any longer.
2922///
2923class ReturnInst : public Instruction {
ReturnInst(const ReturnInst &RI);

2926private:
// ReturnInst constructors:
// ReturnInst()                  - 'ret void' instruction
// ReturnInst(    null)          - 'ret void' instruction
// ReturnInst(Value* X)          - 'ret X'    instruction
// ReturnInst(    null, Inst *I) - 'ret void' instruction, insert before I
// ReturnInst(Value* X, Inst *I) - 'ret X'    instruction, insert before I
// ReturnInst(    null, BB *B)   - 'ret void' instruction, insert @ end of B
// ReturnInst(Value* X, BB *B)   - 'ret X'    instruction, insert @ end of B
//
// NOTE: If the Value* passed is of type void then the constructor behaves as
// if it was passed NULL.
explicit ReturnInst(LLVMContext &C, Value *retVal = nullptr,
                    Instruction *InsertBefore = nullptr);
ReturnInst(LLVMContext &C, Value *retVal, BasicBlock *InsertAtEnd);
explicit ReturnInst(LLVMContext &C, BasicBlock *InsertAtEnd);

2943protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

ReturnInst *cloneImpl() const;

2949public:
static ReturnInst* Create(LLVMContext &C, Value *retVal = nullptr,
                          Instruction *InsertBefore = nullptr) {
  return new(!!retVal) ReturnInst(C, retVal, InsertBefore);
}

static ReturnInst* Create(LLVMContext &C, Value *retVal,
                          BasicBlock *InsertAtEnd) {
  return new(!!retVal) ReturnInst(C, retVal, InsertAtEnd);
}

static ReturnInst* Create(LLVMContext &C, BasicBlock *InsertAtEnd) {
  return new(0) ReturnInst(C, InsertAtEnd);
}

/// Provide fast operand accessors
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
 setOperand(unsigned, Value*); inline op_iterator op_begin();
 inline const_op_iterator op_begin() const; inline op_iterator
 op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
 getNumOperands() const;

/// Convenience accessor. Returns null if there is no return value.
Value *getReturnValue() const {
  return getNumOperands() != 0 ? getOperand(0) : nullptr;
}

unsigned getNumSuccessors() const { return 0; }

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return (I->getOpcode() == Instruction::Ret);
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}

2982private:
BasicBlock *getSuccessor(unsigned idx) const {
  llvm_unreachable("ReturnInst has no successors!")::llvm::llvm_unreachable_internal("ReturnInst has no successors!"
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 2984);
}

void setSuccessor(unsigned idx, BasicBlock *B) {
  llvm_unreachable("ReturnInst has no successors!")::llvm::llvm_unreachable_internal("ReturnInst has no successors!"
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 2988);
}
2990};

2992template <>
2993struct OperandTraits<ReturnInst> : public VariadicOperandTraits<ReturnInst> {
2994};

2996DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ReturnInst, Value)ReturnInst::op_iterator ReturnInst::op_begin() { return OperandTraits
<ReturnInst>::op_begin(this); } ReturnInst::const_op_iterator
 ReturnInst::op_begin() const { return OperandTraits<ReturnInst
>::op_begin(const_cast<ReturnInst*>(this)); } ReturnInst
::op_iterator ReturnInst::op_end() { return OperandTraits<
ReturnInst>::op_end(this); } ReturnInst::const_op_iterator
 ReturnInst::op_end() const { return OperandTraits<ReturnInst
>::op_end(const_cast<ReturnInst*>(this)); } Value *ReturnInst
::getOperand(unsigned i_nocapture) const { ((i_nocapture <
 OperandTraits<ReturnInst>::operands(this) && "getOperand() out of range!"
) ? static_cast<void> (0) : __assert_fail ("i_nocapture < OperandTraits<ReturnInst>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 2996, __PRETTY_FUNCTION__)); return cast_or_null<Value>
( OperandTraits<ReturnInst>::op_begin(const_cast<ReturnInst
*>(this))[i_nocapture].get()); } void ReturnInst::setOperand
(unsigned i_nocapture, Value *Val_nocapture) { ((i_nocapture <
 OperandTraits<ReturnInst>::operands(this) && "setOperand() out of range!"
) ? static_cast<void> (0) : __assert_fail ("i_nocapture < OperandTraits<ReturnInst>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 2996, __PRETTY_FUNCTION__)); OperandTraits<ReturnInst>
::op_begin(this)[i_nocapture] = Val_nocapture; } unsigned ReturnInst
::getNumOperands() const { return OperandTraits<ReturnInst
>::operands(this); } template <int Idx_nocapture> Use
 &ReturnInst::Op() { return this->OpFrom<Idx_nocapture
>(this); } template <int Idx_nocapture> const Use &
ReturnInst::Op() const { return this->OpFrom<Idx_nocapture
>(this); }

2998//===----------------------------------------------------------------------===//
2999//                               BranchInst Class
3000//===----------------------------------------------------------------------===//

3002//===---------------------------------------------------------------------------
3003/// Conditional or Unconditional Branch instruction.
3004///
3005class BranchInst : public Instruction {
/// Ops list - Branches are strange.  The operands are ordered:
///  [Cond, FalseDest,] TrueDest.  This makes some accessors faster because
/// they don't have to check for cond/uncond branchness. These are mostly
/// accessed relative from op_end().
BranchInst(const BranchInst &BI);
// BranchInst constructors (where {B, T, F} are blocks, and C is a condition):
// BranchInst(BB *B)                           - 'br B'
// BranchInst(BB* T, BB *F, Value *C)          - 'br C, T, F'
// BranchInst(BB* B, Inst *I)                  - 'br B'        insert before I
// BranchInst(BB* T, BB *F, Value *C, Inst *I) - 'br C, T, F', insert before I
// BranchInst(BB* B, BB *I)                    - 'br B'        insert at end
// BranchInst(BB* T, BB *F, Value *C, BB *I)   - 'br C, T, F', insert at end
explicit BranchInst(BasicBlock *IfTrue, Instruction *InsertBefore = nullptr);
BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond,
           Instruction *InsertBefore = nullptr);
BranchInst(BasicBlock *IfTrue, BasicBlock *InsertAtEnd);
BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond,
           BasicBlock *InsertAtEnd);

void AssertOK();

3027protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

BranchInst *cloneImpl() const;

3033public:
/// Iterator type that casts an operand to a basic block.
///
/// This only makes sense because the successors are stored as adjacent
/// operands for branch instructions.
struct succ_op_iterator
    : iterator_adaptor_base<succ_op_iterator, value_op_iterator,
                            std::random_access_iterator_tag, BasicBlock *,
                            ptrdiff_t, BasicBlock *, BasicBlock *> {
  explicit succ_op_iterator(value_op_iterator I) : iterator_adaptor_base(I) {}

  BasicBlock *operator*() const { return cast<BasicBlock>(*I); }
  BasicBlock *operator->() const { return operator*(); }
};

/// The const version of `succ_op_iterator`.
struct const_succ_op_iterator
    : iterator_adaptor_base<const_succ_op_iterator, const_value_op_iterator,
                            std::random_access_iterator_tag,
                            const BasicBlock *, ptrdiff_t, const BasicBlock *,
                            const BasicBlock *> {
  explicit const_succ_op_iterator(const_value_op_iterator I)
      : iterator_adaptor_base(I) {}

  const BasicBlock *operator*() const { return cast<BasicBlock>(*I); }
  const BasicBlock *operator->() const { return operator*(); }
};

static BranchInst *Create(BasicBlock *IfTrue,
                          Instruction *InsertBefore = nullptr) {
  return new(1) BranchInst(IfTrue, InsertBefore);
}

static BranchInst *Create(BasicBlock *IfTrue, BasicBlock *IfFalse,
                          Value *Cond, Instruction *InsertBefore = nullptr) {
  return new(3) BranchInst(IfTrue, IfFalse, Cond, InsertBefore);
}

static BranchInst *Create(BasicBlock *IfTrue, BasicBlock *InsertAtEnd) {
  return new(1) BranchInst(IfTrue, InsertAtEnd);
}

static BranchInst *Create(BasicBlock *IfTrue, BasicBlock *IfFalse,
                          Value *Cond, BasicBlock *InsertAtEnd) {
  return new(3) BranchInst(IfTrue, IfFalse, Cond, InsertAtEnd);
}

/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
 setOperand(unsigned, Value*); inline op_iterator op_begin();
 inline const_op_iterator op_begin() const; inline op_iterator
 op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
 getNumOperands() const;

bool isUnconditional() const { return getNumOperands() == 1; }
bool isConditional()   const { return getNumOperands() == 3; }
14
←
Assuming the condition is true→
15
←
Returning the value 1, which participates in a condition later→

Value *getCondition() const {
  assert(isConditional() && "Cannot get condition of an uncond branch!")((isConditional() && "Cannot get condition of an uncond branch!"
) ? static_cast<void> (0) : __assert_fail ("isConditional() && \"Cannot get condition of an uncond branch!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 3087, __PRETTY_FUNCTION__));
  return Op<-3>();
}

void setCondition(Value *V) {
  assert(isConditional() && "Cannot set condition of unconditional branch!")((isConditional() && "Cannot set condition of unconditional branch!"
) ? static_cast<void> (0) : __assert_fail ("isConditional() && \"Cannot set condition of unconditional branch!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 3092, __PRETTY_FUNCTION__));
  Op<-3>() = V;
}

unsigned getNumSuccessors() const { return 1+isConditional(); }

BasicBlock *getSuccessor(unsigned i) const {
  assert(i < getNumSuccessors() && "Successor # out of range for Branch!")((i < getNumSuccessors() && "Successor # out of range for Branch!"
) ? static_cast<void> (0) : __assert_fail ("i < getNumSuccessors() && \"Successor # out of range for Branch!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 3099, __PRETTY_FUNCTION__));
  return cast_or_null<BasicBlock>((&Op<-1>() - i)->get());
}

void setSuccessor(unsigned idx, BasicBlock *NewSucc) {
  assert(idx < getNumSuccessors() && "Successor # out of range for Branch!")((idx < getNumSuccessors() && "Successor # out of range for Branch!"
) ? static_cast<void> (0) : __assert_fail ("idx < getNumSuccessors() && \"Successor # out of range for Branch!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 3104, __PRETTY_FUNCTION__));
  *(&Op<-1>() - idx) = NewSucc;
}

/// Swap the successors of this branch instruction.
///
/// Swaps the successors of the branch instruction. This also swaps any
/// branch weight metadata associated with the instruction so that it
/// continues to map correctly to each operand.
void swapSuccessors();

iterator_range<succ_op_iterator> successors() {
  return make_range(
      succ_op_iterator(std::next(value_op_begin(), isConditional() ? 1 : 0)),
      succ_op_iterator(value_op_end()));
}

iterator_range<const_succ_op_iterator> successors() const {
  return make_range(const_succ_op_iterator(
                        std::next(value_op_begin(), isConditional() ? 1 : 0)),
                    const_succ_op_iterator(value_op_end()));
}

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return (I->getOpcode() == Instruction::Br);
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
3134};

3136template <>
3137struct OperandTraits<BranchInst> : public VariadicOperandTraits<BranchInst, 1> {
3138};

3140DEFINE_TRANSPARENT_OPERAND_ACCESSORS(BranchInst, Value)BranchInst::op_iterator BranchInst::op_begin() { return OperandTraits
<BranchInst>::op_begin(this); } BranchInst::const_op_iterator
 BranchInst::op_begin() const { return OperandTraits<BranchInst
>::op_begin(const_cast<BranchInst*>(this)); } BranchInst
::op_iterator BranchInst::op_end() { return OperandTraits<
BranchInst>::op_end(this); } BranchInst::const_op_iterator
 BranchInst::op_end() const { return OperandTraits<BranchInst
>::op_end(const_cast<BranchInst*>(this)); } Value *BranchInst
::getOperand(unsigned i_nocapture) const { ((i_nocapture <
 OperandTraits<BranchInst>::operands(this) && "getOperand() out of range!"
) ? static_cast<void> (0) : __assert_fail ("i_nocapture < OperandTraits<BranchInst>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 3140, __PRETTY_FUNCTION__)); return cast_or_null<Value>
( OperandTraits<BranchInst>::op_begin(const_cast<BranchInst
*>(this))[i_nocapture].get()); } void BranchInst::setOperand
(unsigned i_nocapture, Value *Val_nocapture) { ((i_nocapture <
 OperandTraits<BranchInst>::operands(this) && "setOperand() out of range!"
) ? static_cast<void> (0) : __assert_fail ("i_nocapture < OperandTraits<BranchInst>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 3140, __PRETTY_FUNCTION__)); OperandTraits<BranchInst>
::op_begin(this)[i_nocapture] = Val_nocapture; } unsigned BranchInst
::getNumOperands() const { return OperandTraits<BranchInst
>::operands(this); } template <int Idx_nocapture> Use
 &BranchInst::Op() { return this->OpFrom<Idx_nocapture
>(this); } template <int Idx_nocapture> const Use &
BranchInst::Op() const { return this->OpFrom<Idx_nocapture
>(this); }

3142//===----------------------------------------------------------------------===//
3143//                               SwitchInst Class
3144//===----------------------------------------------------------------------===//

3146//===---------------------------------------------------------------------------
3147/// Multiway switch
3148///
3149class SwitchInst : public Instruction {
unsigned ReservedSpace;

// Operand[0]    = Value to switch on
// Operand[1]    = Default basic block destination
// Operand[2n  ] = Value to match
// Operand[2n+1] = BasicBlock to go to on match
SwitchInst(const SwitchInst &SI);

/// Create a new switch instruction, specifying a value to switch on and a
/// default destination. The number of additional cases can be specified here
/// to make memory allocation more efficient. This constructor can also
/// auto-insert before another instruction.
SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases,
           Instruction *InsertBefore);

/// Create a new switch instruction, specifying a value to switch on and a
/// default destination. The number of additional cases can be specified here
/// to make memory allocation more efficient. This constructor also
/// auto-inserts at the end of the specified BasicBlock.
SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases,
           BasicBlock *InsertAtEnd);

// allocate space for exactly zero operands
void *operator new(size_t s) {
  return User::operator new(s);
}

void init(Value *Value, BasicBlock *Default, unsigned NumReserved);
void growOperands();

3180protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

SwitchInst *cloneImpl() const;

3186public:
// -2
static const unsigned DefaultPseudoIndex = static_cast<unsigned>(~0L-1);

template <typename CaseHandleT> class CaseIteratorImpl;

/// A handle to a particular switch case. It exposes a convenient interface
/// to both the case value and the successor block.
///
/// We define this as a template and instantiate it to form both a const and
/// non-const handle.
template <typename SwitchInstT, typename ConstantIntT, typename BasicBlockT>
class CaseHandleImpl {
  // Directly befriend both const and non-const iterators.
  friend class SwitchInst::CaseIteratorImpl<
      CaseHandleImpl<SwitchInstT, ConstantIntT, BasicBlockT>>;

protected:
  // Expose the switch type we're parameterized with to the iterator.
  using SwitchInstType = SwitchInstT;

  SwitchInstT *SI;
  ptrdiff_t Index;

  CaseHandleImpl() = default;
  CaseHandleImpl(SwitchInstT *SI, ptrdiff_t Index) : SI(SI), Index(Index) {}

public:
  /// Resolves case value for current case.
  ConstantIntT *getCaseValue() const {
    assert((unsigned)Index < SI->getNumCases() &&(((unsigned)Index < SI->getNumCases() && "Index out the number of cases."
) ? static_cast<void> (0) : __assert_fail ("(unsigned)Index < SI->getNumCases() && \"Index out the number of cases.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 3217, __PRETTY_FUNCTION__))
           "Index out the number of cases.")(((unsigned)Index < SI->getNumCases() && "Index out the number of cases."
) ? static_cast<void> (0) : __assert_fail ("(unsigned)Index < SI->getNumCases() && \"Index out the number of cases.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 3217, __PRETTY_FUNCTION__));
    return reinterpret_cast<ConstantIntT *>(SI->getOperand(2 + Index * 2));
  }

  /// Resolves successor for current case.
  BasicBlockT *getCaseSuccessor() const {
    assert(((unsigned)Index < SI->getNumCases() ||((((unsigned)Index < SI->getNumCases() || (unsigned)Index
 == DefaultPseudoIndex) && "Index out the number of cases."
) ? static_cast<void> (0) : __assert_fail ("((unsigned)Index < SI->getNumCases() || (unsigned)Index == DefaultPseudoIndex) && \"Index out the number of cases.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 3225, __PRETTY_FUNCTION__))
            (unsigned)Index == DefaultPseudoIndex) &&((((unsigned)Index < SI->getNumCases() || (unsigned)Index
 == DefaultPseudoIndex) && "Index out the number of cases."
) ? static_cast<void> (0) : __assert_fail ("((unsigned)Index < SI->getNumCases() || (unsigned)Index == DefaultPseudoIndex) && \"Index out the number of cases.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 3225, __PRETTY_FUNCTION__))
           "Index out the number of cases.")((((unsigned)Index < SI->getNumCases() || (unsigned)Index
 == DefaultPseudoIndex) && "Index out the number of cases."
) ? static_cast<void> (0) : __assert_fail ("((unsigned)Index < SI->getNumCases() || (unsigned)Index == DefaultPseudoIndex) && \"Index out the number of cases.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 3225, __PRETTY_FUNCTION__));
    return SI->getSuccessor(getSuccessorIndex());
  }

  /// Returns number of current case.
  unsigned getCaseIndex() const { return Index; }

  /// Returns successor index for current case successor.
  unsigned getSuccessorIndex() const {
    assert(((unsigned)Index == DefaultPseudoIndex ||((((unsigned)Index == DefaultPseudoIndex || (unsigned)Index <
 SI->getNumCases()) && "Index out the number of cases."
) ? static_cast<void> (0) : __assert_fail ("((unsigned)Index == DefaultPseudoIndex || (unsigned)Index < SI->getNumCases()) && \"Index out the number of cases.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 3236, __PRETTY_FUNCTION__))
            (unsigned)Index < SI->getNumCases()) &&((((unsigned)Index == DefaultPseudoIndex || (unsigned)Index <
 SI->getNumCases()) && "Index out the number of cases."
) ? static_cast<void> (0) : __assert_fail ("((unsigned)Index == DefaultPseudoIndex || (unsigned)Index < SI->getNumCases()) && \"Index out the number of cases.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 3236, __PRETTY_FUNCTION__))
           "Index out the number of cases.")((((unsigned)Index == DefaultPseudoIndex || (unsigned)Index <
 SI->getNumCases()) && "Index out the number of cases."
) ? static_cast<void> (0) : __assert_fail ("((unsigned)Index == DefaultPseudoIndex || (unsigned)Index < SI->getNumCases()) && \"Index out the number of cases.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 3236, __PRETTY_FUNCTION__));
    return (unsigned)Index != DefaultPseudoIndex ? Index + 1 : 0;
  }

  bool operator==(const CaseHandleImpl &RHS) const {
    assert(SI == RHS.SI && "Incompatible operators.")((SI == RHS.SI && "Incompatible operators.") ? static_cast
<void> (0) : __assert_fail ("SI == RHS.SI && \"Incompatible operators.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 3241, __PRETTY_FUNCTION__));
    return Index == RHS.Index;
  }
};

using ConstCaseHandle =
    CaseHandleImpl<const SwitchInst, const ConstantInt, const BasicBlock>;

class CaseHandle
    : public CaseHandleImpl<SwitchInst, ConstantInt, BasicBlock> {
  friend class SwitchInst::CaseIteratorImpl<CaseHandle>;

public:
  CaseHandle(SwitchInst *SI, ptrdiff_t Index) : CaseHandleImpl(SI, Index) {}

  /// Sets the new value for current case.
  void setValue(ConstantInt *V) {
    assert((unsigned)Index < SI->getNumCases() &&(((unsigned)Index < SI->getNumCases() && "Index out the number of cases."
) ? static_cast<void> (0) : __assert_fail ("(unsigned)Index < SI->getNumCases() && \"Index out the number of cases.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 3259, __PRETTY_FUNCTION__))
           "Index out the number of cases.")(((unsigned)Index < SI->getNumCases() && "Index out the number of cases."
) ? static_cast<void> (0) : __assert_fail ("(unsigned)Index < SI->getNumCases() && \"Index out the number of cases.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 3259, __PRETTY_FUNCTION__));
    SI->setOperand(2 + Index*2, reinterpret_cast<Value*>(V));
  }

  /// Sets the new successor for current case.
  void setSuccessor(BasicBlock *S) {
    SI->setSuccessor(getSuccessorIndex(), S);
  }
};

template <typename CaseHandleT>
class CaseIteratorImpl
    : public iterator_facade_base<CaseIteratorImpl<CaseHandleT>,
                                  std::random_access_iterator_tag,
                                  CaseHandleT> {
  using SwitchInstT = typename CaseHandleT::SwitchInstType;

  CaseHandleT Case;

public:
  /// Default constructed iterator is in an invalid state until assigned to
  /// a case for a particular switch.
  CaseIteratorImpl() = default;

  /// Initializes case iterator for given SwitchInst and for given
  /// case number.
  CaseIteratorImpl(SwitchInstT *SI, unsigned CaseNum) : Case(SI, CaseNum) {}

  /// Initializes case iterator for given SwitchInst and for given
  /// successor index.
  static CaseIteratorImpl fromSuccessorIndex(SwitchInstT *SI,
                                             unsigned SuccessorIndex) {
    assert(SuccessorIndex < SI->getNumSuccessors() &&((SuccessorIndex < SI->getNumSuccessors() && "Successor index # out of range!"
) ? static_cast<void> (0) : __assert_fail ("SuccessorIndex < SI->getNumSuccessors() && \"Successor index # out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 3292, __PRETTY_FUNCTION__))
           "Successor index # out of range!")((SuccessorIndex < SI->getNumSuccessors() && "Successor index # out of range!"
) ? static_cast<void> (0) : __assert_fail ("SuccessorIndex < SI->getNumSuccessors() && \"Successor index # out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 3292, __PRETTY_FUNCTION__));
    return SuccessorIndex != 0 ? CaseIteratorImpl(SI, SuccessorIndex - 1)
                               : CaseIteratorImpl(SI, DefaultPseudoIndex);
  }

  /// Support converting to the const variant. This will be a no-op for const
  /// variant.
  operator CaseIteratorImpl<ConstCaseHandle>() const {
    return CaseIteratorImpl<ConstCaseHandle>(Case.SI, Case.Index);
  }

  CaseIteratorImpl &operator+=(ptrdiff_t N) {
    // Check index correctness after addition.
    // Note: Index == getNumCases() means end().
    assert(Case.Index + N >= 0 &&((Case.Index + N >= 0 && (unsigned)(Case.Index + N
) <= Case.SI->getNumCases() && "Case.Index out the number of cases."
) ? static_cast<void> (0) : __assert_fail ("Case.Index + N >= 0 && (unsigned)(Case.Index + N) <= Case.SI->getNumCases() && \"Case.Index out the number of cases.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 3308, __PRETTY_FUNCTION__))
           (unsigned)(Case.Index + N) <= Case.SI->getNumCases() &&((Case.Index + N >= 0 && (unsigned)(Case.Index + N
) <= Case.SI->getNumCases() && "Case.Index out the number of cases."
) ? static_cast<void> (0) : __assert_fail ("Case.Index + N >= 0 && (unsigned)(Case.Index + N) <= Case.SI->getNumCases() && \"Case.Index out the number of cases.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 3308, __PRETTY_FUNCTION__))
           "Case.Index out the number of cases.")((Case.Index + N >= 0 && (unsigned)(Case.Index + N
) <= Case.SI->getNumCases() && "Case.Index out the number of cases."
) ? static_cast<void> (0) : __assert_fail ("Case.Index + N >= 0 && (unsigned)(Case.Index + N) <= Case.SI->getNumCases() && \"Case.Index out the number of cases.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 3308, __PRETTY_FUNCTION__));
    Case.Index += N;
    return *this;
  }
  CaseIteratorImpl &operator-=(ptrdiff_t N) {
    // Check index correctness after subtraction.
    // Note: Case.Index == getNumCases() means end().
    assert(Case.Index - N >= 0 &&((Case.Index - N >= 0 && (unsigned)(Case.Index - N
) <= Case.SI->getNumCases() && "Case.Index out the number of cases."
) ? static_cast<void> (0) : __assert_fail ("Case.Index - N >= 0 && (unsigned)(Case.Index - N) <= Case.SI->getNumCases() && \"Case.Index out the number of cases.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 3317, __PRETTY_FUNCTION__))
           (unsigned)(Case.Index - N) <= Case.SI->getNumCases() &&((Case.Index - N >= 0 && (unsigned)(Case.Index - N
) <= Case.SI->getNumCases() && "Case.Index out the number of cases."
) ? static_cast<void> (0) : __assert_fail ("Case.Index - N >= 0 && (unsigned)(Case.Index - N) <= Case.SI->getNumCases() && \"Case.Index out the number of cases.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 3317, __PRETTY_FUNCTION__))
           "Case.Index out the number of cases.")((Case.Index - N >= 0 && (unsigned)(Case.Index - N
) <= Case.SI->getNumCases() && "Case.Index out the number of cases."
) ? static_cast<void> (0) : __assert_fail ("Case.Index - N >= 0 && (unsigned)(Case.Index - N) <= Case.SI->getNumCases() && \"Case.Index out the number of cases.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 3317, __PRETTY_FUNCTION__));
    Case.Index -= N;
    return *this;
  }
  ptrdiff_t operator-(const CaseIteratorImpl &RHS) const {
    assert(Case.SI == RHS.Case.SI && "Incompatible operators.")((Case.SI == RHS.Case.SI && "Incompatible operators."
) ? static_cast<void> (0) : __assert_fail ("Case.SI == RHS.Case.SI && \"Incompatible operators.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 3322, __PRETTY_FUNCTION__));
    return Case.Index - RHS.Case.Index;
  }
  bool operator==(const CaseIteratorImpl &RHS) const {
    return Case == RHS.Case;
  }
  bool operator<(const CaseIteratorImpl &RHS) const {
    assert(Case.SI == RHS.Case.SI && "Incompatible operators.")((Case.SI == RHS.Case.SI && "Incompatible operators."
) ? static_cast<void> (0) : __assert_fail ("Case.SI == RHS.Case.SI && \"Incompatible operators.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 3329, __PRETTY_FUNCTION__));
    return Case.Index < RHS.Case.Index;
  }
  CaseHandleT &operator*() { return Case; }
  const CaseHandleT &operator*() const { return Case; }
};

using CaseIt = CaseIteratorImpl<CaseHandle>;
using ConstCaseIt = CaseIteratorImpl<ConstCaseHandle>;

static SwitchInst *Create(Value *Value, BasicBlock *Default,
                          unsigned NumCases,
                          Instruction *InsertBefore = nullptr) {
  return new SwitchInst(Value, Default, NumCases, InsertBefore);
}

static SwitchInst *Create(Value *Value, BasicBlock *Default,
                          unsigned NumCases, BasicBlock *InsertAtEnd) {
  return new SwitchInst(Value, Default, NumCases, InsertAtEnd);
}

/// Provide fast operand accessors
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
 setOperand(unsigned, Value*); inline op_iterator op_begin();
 inline const_op_iterator op_begin() const; inline op_iterator
 op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
 getNumOperands() const;

// Accessor Methods for Switch stmt
Value *getCondition() const { return getOperand(0); }
void setCondition(Value *V) { setOperand(0, V); }

BasicBlock *getDefaultDest() const {
  return cast<BasicBlock>(getOperand(1));
}

void setDefaultDest(BasicBlock *DefaultCase) {
  setOperand(1, reinterpret_cast<Value*>(DefaultCase));
}

/// Return the number of 'cases' in this switch instruction, excluding the
/// default case.
unsigned getNumCases() const {
  return getNumOperands()/2 - 1;
}

/// Returns a read/write iterator that points to the first case in the
/// SwitchInst.
CaseIt case_begin() {
  return CaseIt(this, 0);
}

/// Returns a read-only iterator that points to the first case in the
/// SwitchInst.
ConstCaseIt case_begin() const {
  return ConstCaseIt(this, 0);
}

/// Returns a read/write iterator that points one past the last in the
/// SwitchInst.
CaseIt case_end() {
  return CaseIt(this, getNumCases());
}

/// Returns a read-only iterator that points one past the last in the
/// SwitchInst.
ConstCaseIt case_end() const {
  return ConstCaseIt(this, getNumCases());
}

/// Iteration adapter for range-for loops.
iterator_range<CaseIt> cases() {
  return make_range(case_begin(), case_end());
}

/// Constant iteration adapter for range-for loops.
iterator_range<ConstCaseIt> cases() const {
  return make_range(case_begin(), case_end());
}

/// Returns an iterator that points to the default case.
/// Note: this iterator allows to resolve successor only. Attempt
/// to resolve case value causes an assertion.
/// Also note, that increment and decrement also causes an assertion and
/// makes iterator invalid.
CaseIt case_default() {
  return CaseIt(this, DefaultPseudoIndex);
}
ConstCaseIt case_default() const {
  return ConstCaseIt(this, DefaultPseudoIndex);
}

/// Search all of the case values for the specified constant. If it is
/// explicitly handled, return the case iterator of it, otherwise return
/// default case iterator to indicate that it is handled by the default
/// handler.
CaseIt findCaseValue(const ConstantInt *C) {
  CaseIt I = llvm::find_if(
      cases(), [C](CaseHandle &Case) { return Case.getCaseValue() == C; });
  if (I != case_end())
    return I;

  return case_default();
}
ConstCaseIt findCaseValue(const ConstantInt *C) const {
  ConstCaseIt I = llvm::find_if(cases(), [C](ConstCaseHandle &Case) {
    return Case.getCaseValue() == C;
  });
  if (I != case_end())
    return I;

  return case_default();
}

/// Finds the unique case value for a given successor. Returns null if the
/// successor is not found, not unique, or is the default case.
ConstantInt *findCaseDest(BasicBlock *BB) {
  if (BB == getDefaultDest())
    return nullptr;

  ConstantInt *CI = nullptr;
  for (auto Case : cases()) {
    if (Case.getCaseSuccessor() != BB)
      continue;

    if (CI)
      return nullptr; // Multiple cases lead to BB.

    CI = Case.getCaseValue();
  }

  return CI;
}

/// Add an entry to the switch instruction.
/// Note:
/// This action invalidates case_end(). Old case_end() iterator will
/// point to the added case.
void addCase(ConstantInt *OnVal, BasicBlock *Dest);

/// This method removes the specified case and its successor from the switch
/// instruction. Note that this operation may reorder the remaining cases at
/// index idx and above.
/// Note:
/// This action invalidates iterators for all cases following the one removed,
/// including the case_end() iterator. It returns an iterator for the next
/// case.
CaseIt removeCase(CaseIt I);

unsigned getNumSuccessors() const { return getNumOperands()/2; }
BasicBlock *getSuccessor(unsigned idx) const {
  assert(idx < getNumSuccessors() &&"Successor idx out of range for switch!")((idx < getNumSuccessors() &&"Successor idx out of range for switch!"
) ? static_cast<void> (0) : __assert_fail ("idx < getNumSuccessors() &&\"Successor idx out of range for switch!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 3476, __PRETTY_FUNCTION__));
  return cast<BasicBlock>(getOperand(idx*2+1));
}
void setSuccessor(unsigned idx, BasicBlock *NewSucc) {
  assert(idx < getNumSuccessors() && "Successor # out of range for switch!")((idx < getNumSuccessors() && "Successor # out of range for switch!"
) ? static_cast<void> (0) : __assert_fail ("idx < getNumSuccessors() && \"Successor # out of range for switch!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/Instructions.h"
, 3480, __PRETTY_FUNCTION__));
  setOperand(idx * 2 + 1, NewSucc);
}

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::Switch;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
3491};

3493/// A wrapper class to simplify modification of SwitchInst cases along with
3494/// their prof branch_weights metadata.
3495class SwitchInstProfUpdateWrapper {
SwitchInst &SI;
Optional<SmallVector<uint32_t, 8> > Weights = None;
bool Changed = false;

3500protected:
static MDNode *getProfBranchWeightsMD(const SwitchInst &SI);

MDNode *buildProfBranchWeightsMD();

void init();

3507public:
using CaseWeightOpt = Optional<uint32_t>;
SwitchInst *operator->() { return &SI; }
SwitchInst &operator*() { return SI; }
operator SwitchInst *() { return &SI; }

SwitchInstProfUpdateWrapper(SwitchInst &SI) : SI(SI) { init(); }

~SwitchInstProfUpdateWrapper() {
  if (Changed)
    SI.setMetadata(LLVMContext::MD_prof, buildProfBranchWeightsMD());
}

/// Delegate the call to the underlying SwitchInst::removeCase() and remove
/// correspondent branch weight.
SwitchInst::CaseIt removeCase(SwitchInst::CaseIt I);

/// Delegate the call to the underlying SwitchInst::addCase() and set the
/// specified branch weight for the added case.
void addCase(ConstantInt *OnVal, BasicBlock *Dest, CaseWeightOpt W);

/// Delegate the call to the underlying SwitchInst::eraseFromParent() and mark
/// this object to not touch the underlying SwitchInst in destructor.
SymbolTableList<Instruction>::iterator eraseFromParent();

void setSuccessorWeight(unsigned idx, CaseWeightOpt W);
CaseWeightOpt getSuccessorWeight(unsigned idx);

static CaseWeightOpt getSuccessorWeight(const SwitchInst &SI, unsigned idx);
3536};

3538template <>
3539struct OperandTraits<SwitchInst> : public HungoffOperandTraits<2> {
3540};
