/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp

Bug Summary

File:	llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp
Warning:	line 4043, column 9 Array access (from variable 'MLiveIns') results in a null pointer dereference

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 InstrRefBasedImpl.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 -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~++20210726100616+dead50d4427c/build-llvm/lib/CodeGen -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~++20210726100616+dead50d4427c/build-llvm/lib/CodeGen -I /build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen -I /build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/build-llvm/include -I /build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-13/lib/clang/13.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/build-llvm/lib/CodeGen -fdebug-prefix-map=/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c=. -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-07-26-235520-9401-1 -x c++ /build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp

/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp

→

1//===- InstrRefBasedImpl.cpp - Tracking Debug Value MIs -------------------===//
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/// \file InstrRefBasedImpl.cpp
9///
10/// This is a separate implementation of LiveDebugValues, see
11/// LiveDebugValues.cpp and VarLocBasedImpl.cpp for more information.
12///
13/// This pass propagates variable locations between basic blocks, resolving
14/// control flow conflicts between them. The problem is much like SSA
15/// construction, where each DBG_VALUE instruction assigns the *value* that
16/// a variable has, and every instruction where the variable is in scope uses
17/// that variable. The resulting map of instruction-to-value is then translated
18/// into a register (or spill) location for each variable over each instruction.
19///
20/// This pass determines which DBG_VALUE dominates which instructions, or if
21/// none do, where values must be merged (like PHI nodes). The added
22/// complication is that because codegen has already finished, a PHI node may
23/// be needed for a variable location to be correct, but no register or spill
24/// slot merges the necessary values. In these circumstances, the variable
25/// location is dropped.
26///
27/// What makes this analysis non-trivial is loops: we cannot tell in advance
28/// whether a variable location is live throughout a loop, or whether its
29/// location is clobbered (or redefined by another DBG_VALUE), without
30/// exploring all the way through.
31///
32/// To make this simpler we perform two kinds of analysis. First, we identify
33/// every value defined by every instruction (ignoring those that only move
34/// another value), then compute a map of which values are available for each
35/// instruction. This is stronger than a reaching-def analysis, as we create
36/// PHI values where other values merge.
37///
38/// Secondly, for each variable, we effectively re-construct SSA using each
39/// DBG_VALUE as a def. The DBG_VALUEs read a value-number computed by the
40/// first analysis from the location they refer to. We can then compute the
41/// dominance frontiers of where a variable has a value, and create PHI nodes
42/// where they merge.
43/// This isn't precisely SSA-construction though, because the function shape
44/// is pre-defined. If a variable location requires a PHI node, but no
45/// PHI for the relevant values is present in the function (as computed by the
46/// first analysis), the location must be dropped.
47///
48/// Once both are complete, we can pass back over all instructions knowing:
49///  * What _value_ each variable should contain, either defined by an
50///    instruction or where control flow merges
51///  * What the location of that value is (if any).
52/// Allowing us to create appropriate live-in DBG_VALUEs, and DBG_VALUEs when
53/// a value moves location. After this pass runs, all variable locations within
54/// a block should be specified by DBG_VALUEs within that block, allowing
55/// DbgEntityHistoryCalculator to focus on individual blocks.
56///
57/// This pass is able to go fast because the size of the first
58/// reaching-definition analysis is proportional to the working-set size of
59/// the function, which the compiler tries to keep small. (It's also
60/// proportional to the number of blocks). Additionally, we repeatedly perform
61/// the second reaching-definition analysis with only the variables and blocks
62/// in a single lexical scope, exploiting their locality.
63///
64/// Determining where PHIs happen is trickier with this approach, and it comes
65/// to a head in the major problem for LiveDebugValues: is a value live-through
66/// a loop, or not? Your garden-variety dataflow analysis aims to build a set of
67/// facts about a function, however this analysis needs to generate new value
68/// numbers at joins.
69///
70/// To do this, consider a lattice of all definition values, from instructions
71/// and from PHIs. Each PHI is characterised by the RPO number of the block it
72/// occurs in. Each value pair A, B can be ordered by RPO(A) < RPO(B):
73/// with non-PHI values at the top, and any PHI value in the last block (by RPO
74/// order) at the bottom.
75///
76/// (Awkwardly: lower-down-the _lattice_ means a greater RPO _number_. Below,
77/// "rank" always refers to the former).
78///
79/// At any join, for each register, we consider:
80///  * All incoming values, and
81///  * The PREVIOUS live-in value at this join.
82/// If all incoming values agree: that's the live-in value. If they do not, the
83/// incoming values are ranked according to the partial order, and the NEXT
84/// LOWEST rank after the PREVIOUS live-in value is picked (multiple values of
85/// the same rank are ignored as conflicting). If there are no candidate values,
86/// or if the rank of the live-in would be lower than the rank of the current
87/// blocks PHIs, create a new PHI value.
88///
89/// Intuitively: if it's not immediately obvious what value a join should result
90/// in, we iteratively descend from instruction-definitions down through PHI
91/// values, getting closer to the current block each time. If the current block
92/// is a loop head, this ordering is effectively searching outer levels of
93/// loops, to find a value that's live-through the current loop.
94///
95/// If there is no value that's live-through this loop, a PHI is created for
96/// this location instead. We can't use a lower-ranked PHI because by definition
97/// it doesn't dominate the current block. We can't create a PHI value any
98/// earlier, because we risk creating a PHI value at a location where values do
99/// not in fact merge, thus misrepresenting the truth, and not making the true
100/// live-through value for variable locations.
101///
102/// This algorithm applies to both calculating the availability of values in
103/// the first analysis, and the location of variables in the second. However
104/// for the second we add an extra dimension of pain: creating a variable
105/// location PHI is only valid if, for each incoming edge,
106///  * There is a value for the variable on the incoming edge, and
107///  * All the edges have that value in the same register.
108/// Or put another way: we can only create a variable-location PHI if there is
109/// a matching machine-location PHI, each input to which is the variables value
110/// in the predecessor block.
111///
112/// To accommodate this difference, each point on the lattice is split in
113/// two: a "proposed" PHI and "definite" PHI. Any PHI that can immediately
114/// have a location determined are "definite" PHIs, and no further work is
115/// needed. Otherwise, a location that all non-backedge predecessors agree
116/// on is picked and propagated as a "proposed" PHI value. If that PHI value
117/// is truly live-through, it'll appear on the loop backedges on the next
118/// dataflow iteration, after which the block live-in moves to be a "definite"
119/// PHI. If it's not truly live-through, the variable value will be downgraded
120/// further as we explore the lattice, or remains "proposed" and is considered
121/// invalid once dataflow completes.
122///
123/// ### Terminology
124///
125/// A machine location is a register or spill slot, a value is something that's
126/// defined by an instruction or PHI node, while a variable value is the value
127/// assigned to a variable. A variable location is a machine location, that must
128/// contain the appropriate variable value. A value that is a PHI node is
129/// occasionally called an mphi.
130///
131/// The first dataflow problem is the "machine value location" problem,
132/// because we're determining which machine locations contain which values.
133/// The "locations" are constant: what's unknown is what value they contain.
134///
135/// The second dataflow problem (the one for variables) is the "variable value
136/// problem", because it's determining what values a variable has, rather than
137/// what location those values are placed in. Unfortunately, it's not that
138/// simple, because producing a PHI value always involves picking a location.
139/// This is an imperfection that we just have to accept, at least for now.
140///
141/// TODO:
142///   Overlapping fragments
143///   Entry values
144///   Add back DEBUG statements for debugging this
145///   Collect statistics
146///
147//===----------------------------------------------------------------------===//

149#include "llvm/ADT/DenseMap.h"
150#include "llvm/ADT/PostOrderIterator.h"
151#include "llvm/ADT/STLExtras.h"
152#include "llvm/ADT/SmallPtrSet.h"
153#include "llvm/ADT/SmallSet.h"
154#include "llvm/ADT/SmallVector.h"
155#include "llvm/ADT/Statistic.h"
156#include "llvm/ADT/UniqueVector.h"
157#include "llvm/CodeGen/LexicalScopes.h"
158#include "llvm/CodeGen/MachineBasicBlock.h"
159#include "llvm/CodeGen/MachineFrameInfo.h"
160#include "llvm/CodeGen/MachineFunction.h"
161#include "llvm/CodeGen/MachineFunctionPass.h"
162#include "llvm/CodeGen/MachineInstr.h"
163#include "llvm/CodeGen/MachineInstrBuilder.h"
164#include "llvm/CodeGen/MachineInstrBundle.h"
165#include "llvm/CodeGen/MachineMemOperand.h"
166#include "llvm/CodeGen/MachineOperand.h"
167#include "llvm/CodeGen/PseudoSourceValue.h"
168#include "llvm/CodeGen/RegisterScavenging.h"
169#include "llvm/CodeGen/TargetFrameLowering.h"
170#include "llvm/CodeGen/TargetInstrInfo.h"
171#include "llvm/CodeGen/TargetLowering.h"
172#include "llvm/CodeGen/TargetPassConfig.h"
173#include "llvm/CodeGen/TargetRegisterInfo.h"
174#include "llvm/CodeGen/TargetSubtargetInfo.h"
175#include "llvm/Config/llvm-config.h"
176#include "llvm/IR/DIBuilder.h"
177#include "llvm/IR/DebugInfoMetadata.h"
178#include "llvm/IR/DebugLoc.h"
179#include "llvm/IR/Function.h"
180#include "llvm/IR/Module.h"
181#include "llvm/InitializePasses.h"
182#include "llvm/MC/MCRegisterInfo.h"
183#include "llvm/Pass.h"
184#include "llvm/Support/Casting.h"
185#include "llvm/Support/Compiler.h"
186#include "llvm/Support/Debug.h"
187#include "llvm/Support/TypeSize.h"
188#include "llvm/Support/raw_ostream.h"
189#include "llvm/Target/TargetMachine.h"
190#include "llvm/Transforms/Utils/SSAUpdaterImpl.h"
191#include <algorithm>
192#include <cassert>
193#include <cstdint>
194#include <functional>
195#include <queue>
196#include <tuple>
197#include <utility>
198#include <vector>
199#include <limits.h>
200#include <limits>

202#include "LiveDebugValues.h"

204using namespace llvm;

206// SSAUpdaterImple sets DEBUG_TYPE, change it.
207#undef DEBUG_TYPE"livedebugvalues"
208#define DEBUG_TYPE"livedebugvalues" "livedebugvalues"

210// Act more like the VarLoc implementation, by propagating some locations too
211// far and ignoring some transfers.
212static cl::opt<bool> EmulateOldLDV("emulate-old-livedebugvalues", cl::Hidden,
                                 cl::desc("Act like old LiveDebugValues did"),
                                 cl::init(false));

216namespace {

218// The location at which a spilled value resides. It consists of a register and
219// an offset.
220struct SpillLoc {
unsigned SpillBase;
StackOffset SpillOffset;
bool operator==(const SpillLoc &Other) const {
  return std::make_pair(SpillBase, SpillOffset) ==
         std::make_pair(Other.SpillBase, Other.SpillOffset);
}
bool operator<(const SpillLoc &Other) const {
  return std::make_tuple(SpillBase, SpillOffset.getFixed(),
                  SpillOffset.getScalable()) <
         std::make_tuple(Other.SpillBase, Other.SpillOffset.getFixed(),
                  Other.SpillOffset.getScalable());
}
233};

235class LocIdx {
unsigned Location;

// Default constructor is private, initializing to an illegal location number.
// Use only for "not an entry" elements in IndexedMaps.
LocIdx() : Location(UINT_MAX(2147483647 *2U +1U)) { }

242public:
#define NUM_LOC_BITS24 24
LocIdx(unsigned L) : Location(L) {
  assert(L < (1 << NUM_LOC_BITS) && "Machine locations must fit in 24 bits")(static_cast <bool> (L < (1 << 24) && "Machine locations must fit in 24 bits"
) ? void (0) : __assert_fail ("L < (1 << NUM_LOC_BITS) && \"Machine locations must fit in 24 bits\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 245, __extension__ __PRETTY_FUNCTION__));
}

static LocIdx MakeIllegalLoc() {
  return LocIdx();
}

bool isIllegal() const {
  return Location == UINT_MAX(2147483647 *2U +1U);
}

uint64_t asU64() const {
  return Location;
}

bool operator==(unsigned L) const {
  return Location == L;
}

bool operator==(const LocIdx &L) const {
  return Location == L.Location;
}

bool operator!=(unsigned L) const {
  return !(*this == L);
}

bool operator!=(const LocIdx &L) const {
  return !(*this == L);
}

bool operator<(const LocIdx &Other) const {
  return Location < Other.Location;
}
279};

281class LocIdxToIndexFunctor {
282public:
using argument_type = LocIdx;
unsigned operator()(const LocIdx &L) const {
  return L.asU64();
}
287};

289/// Unique identifier for a value defined by an instruction, as a value type.
290/// Casts back and forth to a uint64_t. Probably replacable with something less
291/// bit-constrained. Each value identifies the instruction and machine location
292/// where the value is defined, although there may be no corresponding machine
293/// operand for it (ex: regmasks clobbering values). The instructions are
294/// one-based, and definitions that are PHIs have instruction number zero.
295///
296/// The obvious limits of a 1M block function or 1M instruction blocks are
297/// problematic; but by that point we should probably have bailed out of
298/// trying to analyse the function.
299class ValueIDNum {
uint64_t BlockNo : 20;         /// The block where the def happens.
uint64_t InstNo : 20;          /// The Instruction where the def happens.
                               /// One based, is distance from start of block.
uint64_t LocNo : NUM_LOC_BITS24; /// The machine location where the def happens.

305public:
// XXX -- temporarily enabled while the live-in / live-out tables are moved
// to something more type-y
ValueIDNum() : BlockNo(0xFFFFF),
               InstNo(0xFFFFF),
               LocNo(0xFFFFFF) { }

ValueIDNum(uint64_t Block, uint64_t Inst, uint64_t Loc)
  : BlockNo(Block), InstNo(Inst), LocNo(Loc) { }

ValueIDNum(uint64_t Block, uint64_t Inst, LocIdx Loc)
  : BlockNo(Block), InstNo(Inst), LocNo(Loc.asU64()) { }

uint64_t getBlock() const { return BlockNo; }
uint64_t getInst() const { return InstNo; }
uint64_t getLoc() const { return LocNo; }
bool isPHI() const { return InstNo == 0; }

uint64_t asU64() const {
  uint64_t TmpBlock = BlockNo;
  uint64_t TmpInst = InstNo;
  return TmpBlock << 44ull | TmpInst << NUM_LOC_BITS24 | LocNo;
}

static ValueIDNum fromU64(uint64_t v) {
  uint64_t L = (v & 0x3FFF);
  return {v >> 44ull, ((v >> NUM_LOC_BITS24) & 0xFFFFF), L};
}

bool operator<(const ValueIDNum &Other) const {
  return asU64() < Other.asU64();
}

bool operator==(const ValueIDNum &Other) const {
  return std::tie(BlockNo, InstNo, LocNo) ==
         std::tie(Other.BlockNo, Other.InstNo, Other.LocNo);
}

bool operator!=(const ValueIDNum &Other) const { return !(*this == Other); }

std::string asString(const std::string &mlocname) const {
  return Twine("Value{bb: ")
      .concat(Twine(BlockNo).concat(
          Twine(", inst: ")
              .concat((InstNo ? Twine(InstNo) : Twine("live-in"))
                          .concat(Twine(", loc: ").concat(Twine(mlocname)))
                          .concat(Twine("}")))))
      .str();
}

static ValueIDNum EmptyValue;
356};

358} // end anonymous namespace

360namespace {

362/// Meta qualifiers for a value. Pair of whatever expression is used to qualify
363/// the the value, and Boolean of whether or not it's indirect.
364class DbgValueProperties {
365public:
DbgValueProperties(const DIExpression *DIExpr, bool Indirect)
    : DIExpr(DIExpr), Indirect(Indirect) {}

/// Extract properties from an existing DBG_VALUE instruction.
DbgValueProperties(const MachineInstr &MI) {
  assert(MI.isDebugValue())(static_cast <bool> (MI.isDebugValue()) ? void (0) : __assert_fail
 ("MI.isDebugValue()", "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 371, __extension__ __PRETTY_FUNCTION__));
  DIExpr = MI.getDebugExpression();
  Indirect = MI.getOperand(1).isImm();
}

bool operator==(const DbgValueProperties &Other) const {
  return std::tie(DIExpr, Indirect) == std::tie(Other.DIExpr, Other.Indirect);
}

bool operator!=(const DbgValueProperties &Other) const {
  return !(*this == Other);
}

const DIExpression *DIExpr;
bool Indirect;
386};

388/// Tracker for what values are in machine locations. Listens to the Things
389/// being Done by various instructions, and maintains a table of what machine
390/// locations have what values (as defined by a ValueIDNum).
391///
392/// There are potentially a much larger number of machine locations on the
393/// target machine than the actual working-set size of the function. On x86 for
394/// example, we're extremely unlikely to want to track values through control
395/// or debug registers. To avoid doing so, MLocTracker has several layers of
396/// indirection going on, with two kinds of ``location'':
397///  * A LocID uniquely identifies a register or spill location, with a
398///    predictable value.
399///  * A LocIdx is a key (in the database sense) for a LocID and a ValueIDNum.
400/// Whenever a location is def'd or used by a MachineInstr, we automagically
401/// create a new LocIdx for a location, but not otherwise. This ensures we only
402/// account for locations that are actually used or defined. The cost is another
403/// vector lookup (of LocID -> LocIdx) over any other implementation. This is
404/// fairly cheap, and the compiler tries to reduce the working-set at any one
405/// time in the function anyway.
406///
407/// Register mask operands completely blow this out of the water; I've just
408/// piled hacks on top of hacks to get around that.
409class MLocTracker {
410public:
MachineFunction &MF;
const TargetInstrInfo &TII;
const TargetRegisterInfo &TRI;
const TargetLowering &TLI;

/// IndexedMap type, mapping from LocIdx to ValueIDNum.
using LocToValueType = IndexedMap<ValueIDNum, LocIdxToIndexFunctor>;

/// Map of LocIdxes to the ValueIDNums that they store. This is tightly
/// packed, entries only exist for locations that are being tracked.
LocToValueType LocIdxToIDNum;

/// "Map" of machine location IDs (i.e., raw register or spill number) to the
/// LocIdx key / number for that location. There are always at least as many
/// as the number of registers on the target -- if the value in the register
/// is not being tracked, then the LocIdx value will be zero. New entries are
/// appended if a new spill slot begins being tracked.
/// This, and the corresponding reverse map persist for the analysis of the
/// whole function, and is necessarying for decoding various vectors of
/// values.
std::vector<LocIdx> LocIDToLocIdx;

/// Inverse map of LocIDToLocIdx.
IndexedMap<unsigned, LocIdxToIndexFunctor> LocIdxToLocID;

/// Unique-ification of spill slots. Used to number them -- their LocID
/// number is the index in SpillLocs minus one plus NumRegs.
UniqueVector<SpillLoc> SpillLocs;

// If we discover a new machine location, assign it an mphi with this
// block number.
unsigned CurBB;

/// Cached local copy of the number of registers the target has.
unsigned NumRegs;

/// Collection of register mask operands that have been observed. Second part
/// of pair indicates the instruction that they happened in. Used to
/// reconstruct where defs happened if we start tracking a location later
/// on.
SmallVector<std::pair<const MachineOperand *, unsigned>, 32> Masks;

/// Iterator for locations and the values they contain. Dereferencing
/// produces a struct/pair containing the LocIdx key for this location,
/// and a reference to the value currently stored. Simplifies the process
/// of seeking a particular location.
class MLocIterator {
  LocToValueType &ValueMap;
  LocIdx Idx;

public:
  class value_type {
    public:
    value_type(LocIdx Idx, ValueIDNum &Value) : Idx(Idx), Value(Value) { }
    const LocIdx Idx;  /// Read-only index of this location.
    ValueIDNum &Value; /// Reference to the stored value at this location.
  };

  MLocIterator(LocToValueType &ValueMap, LocIdx Idx)
    : ValueMap(ValueMap), Idx(Idx) { }

  bool operator==(const MLocIterator &Other) const {
    assert(&ValueMap == &Other.ValueMap)(static_cast <bool> (&ValueMap == &Other.ValueMap
) ? void (0) : __assert_fail ("&ValueMap == &Other.ValueMap"
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 473, __extension__ __PRETTY_FUNCTION__));
    return Idx == Other.Idx;
  }

  bool operator!=(const MLocIterator &Other) const {
    return !(*this == Other);
  }

  void operator++() {
    Idx = LocIdx(Idx.asU64() + 1);
  }

  value_type operator*() {
    return value_type(Idx, ValueMap[LocIdx(Idx)]);
  }
};

MLocTracker(MachineFunction &MF, const TargetInstrInfo &TII,
            const TargetRegisterInfo &TRI, const TargetLowering &TLI)
    : MF(MF), TII(TII), TRI(TRI), TLI(TLI),
      LocIdxToIDNum(ValueIDNum::EmptyValue),
      LocIdxToLocID(0) {
  NumRegs = TRI.getNumRegs();
  reset();
  LocIDToLocIdx.resize(NumRegs, LocIdx::MakeIllegalLoc());
  assert(NumRegs < (1u << NUM_LOC_BITS))(static_cast <bool> (NumRegs < (1u << 24)) ? void
 (0) : __assert_fail ("NumRegs < (1u << NUM_LOC_BITS)"
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 498, __extension__ __PRETTY_FUNCTION__)); // Detect bit packing failure

  // Always track SP. This avoids the implicit clobbering caused by regmasks
  // from affectings its values. (LiveDebugValues disbelieves calls and
  // regmasks that claim to clobber SP).
  Register SP = TLI.getStackPointerRegisterToSaveRestore();
  if (SP) {
    unsigned ID = getLocID(SP, false);
    (void)lookupOrTrackRegister(ID);
  }
}

/// Produce location ID number for indexing LocIDToLocIdx. Takes the register
/// or spill number, and flag for whether it's a spill or not.
unsigned getLocID(Register RegOrSpill, bool isSpill) {
  return (isSpill) ? RegOrSpill.id() + NumRegs - 1 : RegOrSpill.id();
}

/// Accessor for reading the value at Idx.
ValueIDNum getNumAtPos(LocIdx Idx) const {
  assert(Idx.asU64() < LocIdxToIDNum.size())(static_cast <bool> (Idx.asU64() < LocIdxToIDNum.size
()) ? void (0) : __assert_fail ("Idx.asU64() < LocIdxToIDNum.size()"
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 518, __extension__ __PRETTY_FUNCTION__));
  return LocIdxToIDNum[Idx];
}

unsigned getNumLocs(void) const { return LocIdxToIDNum.size(); }

/// Reset all locations to contain a PHI value at the designated block. Used
/// sometimes for actual PHI values, othertimes to indicate the block entry
/// value (before any more information is known).
void setMPhis(unsigned NewCurBB) {
  CurBB = NewCurBB;
  for (auto Location : locations())
    Location.Value = {CurBB, 0, Location.Idx};
}

/// Load values for each location from array of ValueIDNums. Take current
/// bbnum just in case we read a value from a hitherto untouched register.
void loadFromArray(ValueIDNum *Locs, unsigned NewCurBB) {
  CurBB = NewCurBB;
  // Iterate over all tracked locations, and load each locations live-in
  // value into our local index.
  for (auto Location : locations())
    Location.Value = Locs[Location.Idx.asU64()];
}

/// Wipe any un-necessary location records after traversing a block.
void reset(void) {
  // We could reset all the location values too; however either loadFromArray
  // or setMPhis should be called before this object is re-used. Just
  // clear Masks, they're definitely not needed.
  Masks.clear();
}

/// Clear all data. Destroys the LocID <=> LocIdx map, which makes most of
/// the information in this pass uninterpretable.
void clear(void) {
  reset();
  LocIDToLocIdx.clear();
  LocIdxToLocID.clear();
  LocIdxToIDNum.clear();
  //SpillLocs.reset(); XXX UniqueVector::reset assumes a SpillLoc casts from 0
  SpillLocs = decltype(SpillLocs)();

  LocIDToLocIdx.resize(NumRegs, LocIdx::MakeIllegalLoc());
}

/// Set a locaiton to a certain value.
void setMLoc(LocIdx L, ValueIDNum Num) {
  assert(L.asU64() < LocIdxToIDNum.size())(static_cast <bool> (L.asU64() < LocIdxToIDNum.size(
)) ? void (0) : __assert_fail ("L.asU64() < LocIdxToIDNum.size()"
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 566, __extension__ __PRETTY_FUNCTION__));
  LocIdxToIDNum[L] = Num;
}

/// Create a LocIdx for an untracked register ID. Initialize it to either an
/// mphi value representing a live-in, or a recent register mask clobber.
LocIdx trackRegister(unsigned ID) {
  assert(ID != 0)(static_cast <bool> (ID != 0) ? void (0) : __assert_fail
 ("ID != 0", "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 573, __extension__ __PRETTY_FUNCTION__));
  LocIdx NewIdx = LocIdx(LocIdxToIDNum.size());
  LocIdxToIDNum.grow(NewIdx);
  LocIdxToLocID.grow(NewIdx);

  // Default: it's an mphi.
  ValueIDNum ValNum = {CurBB, 0, NewIdx};
  // Was this reg ever touched by a regmask?
  for (const auto &MaskPair : reverse(Masks)) {
    if (MaskPair.first->clobbersPhysReg(ID)) {
      // There was an earlier def we skipped.
      ValNum = {CurBB, MaskPair.second, NewIdx};
      break;
    }
  }

  LocIdxToIDNum[NewIdx] = ValNum;
  LocIdxToLocID[NewIdx] = ID;
  return NewIdx;
}

LocIdx lookupOrTrackRegister(unsigned ID) {
  LocIdx &Index = LocIDToLocIdx[ID];
  if (Index.isIllegal())
    Index = trackRegister(ID);
  return Index;
}

/// Record a definition of the specified register at the given block / inst.
/// This doesn't take a ValueIDNum, because the definition and its location
/// are synonymous.
void defReg(Register R, unsigned BB, unsigned Inst) {
  unsigned ID = getLocID(R, false);
  LocIdx Idx = lookupOrTrackRegister(ID);
  ValueIDNum ValueID = {BB, Inst, Idx};
  LocIdxToIDNum[Idx] = ValueID;
}

/// Set a register to a value number. To be used if the value number is
/// known in advance.
void setReg(Register R, ValueIDNum ValueID) {
  unsigned ID = getLocID(R, false);
  LocIdx Idx = lookupOrTrackRegister(ID);
  LocIdxToIDNum[Idx] = ValueID;
}

ValueIDNum readReg(Register R) {
  unsigned ID = getLocID(R, false);
  LocIdx Idx = lookupOrTrackRegister(ID);
  return LocIdxToIDNum[Idx];
}

/// Reset a register value to zero / empty. Needed to replicate the
/// VarLoc implementation where a copy to/from a register effectively
/// clears the contents of the source register. (Values can only have one
///  machine location in VarLocBasedImpl).
void wipeRegister(Register R) {
  unsigned ID = getLocID(R, false);
  LocIdx Idx = LocIDToLocIdx[ID];
  LocIdxToIDNum[Idx] = ValueIDNum::EmptyValue;
}

/// Determine the LocIdx of an existing register.
LocIdx getRegMLoc(Register R) {
  unsigned ID = getLocID(R, false);
  return LocIDToLocIdx[ID];
}

/// Record a RegMask operand being executed. Defs any register we currently
/// track, stores a pointer to the mask in case we have to account for it
/// later.
void writeRegMask(const MachineOperand *MO, unsigned CurBB, unsigned InstID) {
  // Ensure SP exists, so that we don't override it later.
  Register SP = TLI.getStackPointerRegisterToSaveRestore();

  // Def any register we track have that isn't preserved. The regmask
  // terminates the liveness of a register, meaning its value can't be
  // relied upon -- we represent this by giving it a new value.
  for (auto Location : locations()) {
    unsigned ID = LocIdxToLocID[Location.Idx];
    // Don't clobber SP, even if the mask says it's clobbered.
    if (ID < NumRegs && ID != SP && MO->clobbersPhysReg(ID))
      defReg(ID, CurBB, InstID);
  }
  Masks.push_back(std::make_pair(MO, InstID));
}

/// Find LocIdx for SpillLoc \p L, creating a new one if it's not tracked.
LocIdx getOrTrackSpillLoc(SpillLoc L) {
  unsigned SpillID = SpillLocs.idFor(L);
  if (SpillID == 0) {
    SpillID = SpillLocs.insert(L);
    unsigned L = getLocID(SpillID, true);
    LocIdx Idx = LocIdx(LocIdxToIDNum.size()); // New idx
    LocIdxToIDNum.grow(Idx);
    LocIdxToLocID.grow(Idx);
    LocIDToLocIdx.push_back(Idx);
    LocIdxToLocID[Idx] = L;
    return Idx;
  } else {
    unsigned L = getLocID(SpillID, true);
    LocIdx Idx = LocIDToLocIdx[L];
    return Idx;
  }
}

/// Set the value stored in a spill slot.
void setSpill(SpillLoc L, ValueIDNum ValueID) {
  LocIdx Idx = getOrTrackSpillLoc(L);
  LocIdxToIDNum[Idx] = ValueID;
}

/// Read whatever value is in a spill slot, or None if it isn't tracked.
Optional<ValueIDNum> readSpill(SpillLoc L) {
  unsigned SpillID = SpillLocs.idFor(L);
  if (SpillID == 0)
    return None;

  unsigned LocID = getLocID(SpillID, true);
  LocIdx Idx = LocIDToLocIdx[LocID];
  return LocIdxToIDNum[Idx];
}

/// Determine the LocIdx of a spill slot. Return None if it previously
/// hasn't had a value assigned.
Optional<LocIdx> getSpillMLoc(SpillLoc L) {
  unsigned SpillID = SpillLocs.idFor(L);
  if (SpillID == 0)
    return None;
  unsigned LocNo = getLocID(SpillID, true);
  return LocIDToLocIdx[LocNo];
}

/// Return true if Idx is a spill machine location.
bool isSpill(LocIdx Idx) const {
  return LocIdxToLocID[Idx] >= NumRegs;
}

MLocIterator begin() {
  return MLocIterator(LocIdxToIDNum, 0);
}

MLocIterator end() {
  return MLocIterator(LocIdxToIDNum, LocIdxToIDNum.size());
}

/// Return a range over all locations currently tracked.
iterator_range<MLocIterator> locations() {
  return llvm::make_range(begin(), end());
}

std::string LocIdxToName(LocIdx Idx) const {
  unsigned ID = LocIdxToLocID[Idx];
  if (ID >= NumRegs)
    return Twine("slot ").concat(Twine(ID - NumRegs)).str();
  else
    return TRI.getRegAsmName(ID).str();
}

std::string IDAsString(const ValueIDNum &Num) const {
  std::string DefName = LocIdxToName(Num.getLoc());
  return Num.asString(DefName);
}

LLVM_DUMP_METHOD__attribute__((noinline)) __attribute__((__used__))
void dump() {
  for (auto Location : locations()) {
    std::string MLocName = LocIdxToName(Location.Value.getLoc());
    std::string DefName = Location.Value.asString(MLocName);
    dbgs() << LocIdxToName(Location.Idx) << " --> " << DefName << "\n";
  }
}

LLVM_DUMP_METHOD__attribute__((noinline)) __attribute__((__used__))
void dump_mloc_map() {
  for (auto Location : locations()) {
    std::string foo = LocIdxToName(Location.Idx);
    dbgs() << "Idx " << Location.Idx.asU64() << " " << foo << "\n";
  }
}

/// Create a DBG_VALUE based on  machine location \p MLoc. Qualify it with the
/// information in \pProperties, for variable Var. Don't insert it anywhere,
/// just return the builder for it.
MachineInstrBuilder emitLoc(Optional<LocIdx> MLoc, const DebugVariable &Var,
                            const DbgValueProperties &Properties) {
  DebugLoc DL = DILocation::get(Var.getVariable()->getContext(), 0, 0,
                                Var.getVariable()->getScope(),
                                const_cast<DILocation *>(Var.getInlinedAt()));
  auto MIB = BuildMI(MF, DL, TII.get(TargetOpcode::DBG_VALUE));

  const DIExpression *Expr = Properties.DIExpr;
  if (!MLoc) {
    // No location -> DBG_VALUE $noreg
    MIB.addReg(0, RegState::Debug);
    MIB.addReg(0, RegState::Debug);
  } else if (LocIdxToLocID[*MLoc] >= NumRegs) {
    unsigned LocID = LocIdxToLocID[*MLoc];
    const SpillLoc &Spill = SpillLocs[LocID - NumRegs + 1];

    auto *TRI = MF.getSubtarget().getRegisterInfo();
    Expr = TRI->prependOffsetExpression(Expr, DIExpression::ApplyOffset,
                                        Spill.SpillOffset);
    unsigned Base = Spill.SpillBase;
    MIB.addReg(Base, RegState::Debug);
    MIB.addImm(0);
  } else {
    unsigned LocID = LocIdxToLocID[*MLoc];
    MIB.addReg(LocID, RegState::Debug);
    if (Properties.Indirect)
      MIB.addImm(0);
    else
      MIB.addReg(0, RegState::Debug);
  }

  MIB.addMetadata(Var.getVariable());
  MIB.addMetadata(Expr);
  return MIB;
}
792};

794/// Class recording the (high level) _value_ of a variable. Identifies either
795/// the value of the variable as a ValueIDNum, or a constant MachineOperand.
796/// This class also stores meta-information about how the value is qualified.
797/// Used to reason about variable values when performing the second
798/// (DebugVariable specific) dataflow analysis.
799class DbgValue {
800public:
union {
  /// If Kind is Def, the value number that this value is based on.
  ValueIDNum ID;
  /// If Kind is Const, the MachineOperand defining this value.
  MachineOperand MO;
  /// For a NoVal DbgValue, which block it was generated in.
  unsigned BlockNo;
};
/// Qualifiers for the ValueIDNum above.
DbgValueProperties Properties;

typedef enum {
  Undef,     // Represents a DBG_VALUE $noreg in the transfer function only.
  Def,       // This value is defined by an inst, or is a PHI value.
  Const,     // A constant value contained in the MachineOperand field.
  Proposed,  // This is a tentative PHI value, which may be confirmed or
             // invalidated later.
  NoVal      // Empty DbgValue, generated during dataflow. BlockNo stores
             // which block this was generated in.
 } KindT;
/// Discriminator for whether this is a constant or an in-program value.
KindT Kind;

DbgValue(const ValueIDNum &Val, const DbgValueProperties &Prop, KindT Kind)
  : ID(Val), Properties(Prop), Kind(Kind) {
  assert(Kind == Def || Kind == Proposed)(static_cast <bool> (Kind == Def || Kind == Proposed) ?
 void (0) : __assert_fail ("Kind == Def || Kind == Proposed",
 "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 826, __extension__ __PRETTY_FUNCTION__));
}

DbgValue(unsigned BlockNo, const DbgValueProperties &Prop, KindT Kind)
  : BlockNo(BlockNo), Properties(Prop), Kind(Kind) {
  assert(Kind == NoVal)(static_cast <bool> (Kind == NoVal) ? void (0) : __assert_fail
 ("Kind == NoVal", "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 831, __extension__ __PRETTY_FUNCTION__));
}

DbgValue(const MachineOperand &MO, const DbgValueProperties &Prop, KindT Kind)
  : MO(MO), Properties(Prop), Kind(Kind) {
  assert(Kind == Const)(static_cast <bool> (Kind == Const) ? void (0) : __assert_fail
 ("Kind == Const", "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 836, __extension__ __PRETTY_FUNCTION__));
}

DbgValue(const DbgValueProperties &Prop, KindT Kind)
  : Properties(Prop), Kind(Kind) {
  assert(Kind == Undef &&(static_cast <bool> (Kind == Undef && "Empty DbgValue constructor must pass in Undef kind"
) ? void (0) : __assert_fail ("Kind == Undef && \"Empty DbgValue constructor must pass in Undef kind\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 842, __extension__ __PRETTY_FUNCTION__))
         "Empty DbgValue constructor must pass in Undef kind")(static_cast <bool> (Kind == Undef && "Empty DbgValue constructor must pass in Undef kind"
) ? void (0) : __assert_fail ("Kind == Undef && \"Empty DbgValue constructor must pass in Undef kind\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 842, __extension__ __PRETTY_FUNCTION__));
}

void dump(const MLocTracker *MTrack) const {
  if (Kind == Const) {
    MO.dump();
  } else if (Kind == NoVal) {
    dbgs() << "NoVal(" << BlockNo << ")";
  } else if (Kind == Proposed) {
    dbgs() << "VPHI(" << MTrack->IDAsString(ID) << ")";
  } else {
    assert(Kind == Def)(static_cast <bool> (Kind == Def) ? void (0) : __assert_fail
 ("Kind == Def", "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 853, __extension__ __PRETTY_FUNCTION__));
    dbgs() << MTrack->IDAsString(ID);
  }
  if (Properties.Indirect)
    dbgs() << " indir";
  if (Properties.DIExpr)
    dbgs() << " " << *Properties.DIExpr;
}

bool operator==(const DbgValue &Other) const {
  if (std::tie(Kind, Properties) != std::tie(Other.Kind, Other.Properties))
    return false;
  else if (Kind == Proposed && ID != Other.ID)
    return false;
  else if (Kind == Def && ID != Other.ID)
    return false;
  else if (Kind == NoVal && BlockNo != Other.BlockNo)
    return false;
  else if (Kind == Const)
    return MO.isIdenticalTo(Other.MO);

  return true;
}

bool operator!=(const DbgValue &Other) const { return !(*this == Other); }
878};

880/// Types for recording sets of variable fragments that overlap. For a given
881/// local variable, we record all other fragments of that variable that could
882/// overlap it, to reduce search time.
883using FragmentOfVar =
  std::pair<const DILocalVariable *, DIExpression::FragmentInfo>;
885using OverlapMap =
  DenseMap<FragmentOfVar, SmallVector<DIExpression::FragmentInfo, 1>>;

888/// Collection of DBG_VALUEs observed when traversing a block. Records each
889/// variable and the value the DBG_VALUE refers to. Requires the machine value
890/// location dataflow algorithm to have run already, so that values can be
891/// identified.
892class VLocTracker {
893public:
/// Map DebugVariable to the latest Value it's defined to have.
/// Needs to be a MapVector because we determine order-in-the-input-MIR from
/// the order in this container.
/// We only retain the last DbgValue in each block for each variable, to
/// determine the blocks live-out variable value. The Vars container forms the
/// transfer function for this block, as part of the dataflow analysis. The
/// movement of values between locations inside of a block is handled at a
/// much later stage, in the TransferTracker class.
MapVector<DebugVariable, DbgValue> Vars;
DenseMap<DebugVariable, const DILocation *> Scopes;
MachineBasicBlock *MBB;

906public:
VLocTracker() {}

void defVar(const MachineInstr &MI, const DbgValueProperties &Properties,
            Optional<ValueIDNum> ID) {
  assert(MI.isDebugValue() || MI.isDebugRef())(static_cast <bool> (MI.isDebugValue() || MI.isDebugRef
()) ? void (0) : __assert_fail ("MI.isDebugValue() || MI.isDebugRef()"
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 911, __extension__ __PRETTY_FUNCTION__));
  DebugVariable Var(MI.getDebugVariable(), MI.getDebugExpression(),
                    MI.getDebugLoc()->getInlinedAt());
  DbgValue Rec = (ID) ? DbgValue(*ID, Properties, DbgValue::Def)
                      : DbgValue(Properties, DbgValue::Undef);

  // Attempt insertion; overwrite if it's already mapped.
  auto Result = Vars.insert(std::make_pair(Var, Rec));
  if (!Result.second)
    Result.first->second = Rec;
  Scopes[Var] = MI.getDebugLoc().get();
}

void defVar(const MachineInstr &MI, const MachineOperand &MO) {
  // Only DBG_VALUEs can define constant-valued variables.
  assert(MI.isDebugValue())(static_cast <bool> (MI.isDebugValue()) ? void (0) : __assert_fail
 ("MI.isDebugValue()", "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 926, __extension__ __PRETTY_FUNCTION__));
  DebugVariable Var(MI.getDebugVariable(), MI.getDebugExpression(),
                    MI.getDebugLoc()->getInlinedAt());
  DbgValueProperties Properties(MI);
  DbgValue Rec = DbgValue(MO, Properties, DbgValue::Const);

  // Attempt insertion; overwrite if it's already mapped.
  auto Result = Vars.insert(std::make_pair(Var, Rec));
  if (!Result.second)
    Result.first->second = Rec;
  Scopes[Var] = MI.getDebugLoc().get();
}
938};

940/// Tracker for converting machine value locations and variable values into
941/// variable locations (the output of LiveDebugValues), recorded as DBG_VALUEs
942/// specifying block live-in locations and transfers within blocks.
943///
944/// Operating on a per-block basis, this class takes a (pre-loaded) MLocTracker
945/// and must be initialized with the set of variable values that are live-in to
946/// the block. The caller then repeatedly calls process(). TransferTracker picks
947/// out variable locations for the live-in variable values (if there _is_ a
948/// location) and creates the corresponding DBG_VALUEs. Then, as the block is
949/// stepped through, transfers of values between machine locations are
950/// identified and if profitable, a DBG_VALUE created.
951///
952/// This is where debug use-before-defs would be resolved: a variable with an
953/// unavailable value could materialize in the middle of a block, when the
954/// value becomes available. Or, we could detect clobbers and re-specify the
955/// variable in a backup location. (XXX these are unimplemented).
956class TransferTracker {
957public:
const TargetInstrInfo *TII;
const TargetLowering *TLI;
/// This machine location tracker is assumed to always contain the up-to-date
/// value mapping for all machine locations. TransferTracker only reads
/// information from it. (XXX make it const?)
MLocTracker *MTracker;
MachineFunction &MF;
bool ShouldEmitDebugEntryValues;

/// Record of all changes in variable locations at a block position. Awkwardly
/// we allow inserting either before or after the point: MBB != nullptr
/// indicates it's before, otherwise after.
struct Transfer {
  MachineBasicBlock::instr_iterator Pos; /// Position to insert DBG_VALUes
  MachineBasicBlock *MBB; /// non-null if we should insert after.
  SmallVector<MachineInstr *, 4> Insts; /// Vector of DBG_VALUEs to insert.
};

struct LocAndProperties {
  LocIdx Loc;
  DbgValueProperties Properties;
};

/// Collection of transfers (DBG_VALUEs) to be inserted.
SmallVector<Transfer, 32> Transfers;

/// Local cache of what-value-is-in-what-LocIdx. Used to identify differences
/// between TransferTrackers view of variable locations and MLocTrackers. For
/// example, MLocTracker observes all clobbers, but TransferTracker lazily
/// does not.
std::vector<ValueIDNum> VarLocs;

/// Map from LocIdxes to which DebugVariables are based that location.
/// Mantained while stepping through the block. Not accurate if
/// VarLocs[Idx] != MTracker->LocIdxToIDNum[Idx].
std::map<LocIdx, SmallSet<DebugVariable, 4>> ActiveMLocs;

/// Map from DebugVariable to it's current location and qualifying meta
/// information. To be used in conjunction with ActiveMLocs to construct
/// enough information for the DBG_VALUEs for a particular LocIdx.
DenseMap<DebugVariable, LocAndProperties> ActiveVLocs;

/// Temporary cache of DBG_VALUEs to be entered into the Transfers collection.
SmallVector<MachineInstr *, 4> PendingDbgValues;

/// Record of a use-before-def: created when a value that's live-in to the
/// current block isn't available in any machine location, but it will be
/// defined in this block.
struct UseBeforeDef {
  /// Value of this variable, def'd in block.
  ValueIDNum ID;
  /// Identity of this variable.
  DebugVariable Var;
  /// Additional variable properties.
  DbgValueProperties Properties;
};

/// Map from instruction index (within the block) to the set of UseBeforeDefs
/// that become defined at that instruction.
DenseMap<unsigned, SmallVector<UseBeforeDef, 1>> UseBeforeDefs;

/// The set of variables that are in UseBeforeDefs and can become a location
/// once the relevant value is defined. An element being erased from this
/// collection prevents the use-before-def materializing.
DenseSet<DebugVariable> UseBeforeDefVariables;

const TargetRegisterInfo &TRI;
const BitVector &CalleeSavedRegs;

TransferTracker(const TargetInstrInfo *TII, MLocTracker *MTracker,
                MachineFunction &MF, const TargetRegisterInfo &TRI,
                const BitVector &CalleeSavedRegs, const TargetPassConfig &TPC)
    : TII(TII), MTracker(MTracker), MF(MF), TRI(TRI),
      CalleeSavedRegs(CalleeSavedRegs) {
  TLI = MF.getSubtarget().getTargetLowering();
  auto &TM = TPC.getTM<TargetMachine>();
  ShouldEmitDebugEntryValues = TM.Options.ShouldEmitDebugEntryValues();
}

/// Load object with live-in variable values. \p mlocs contains the live-in
/// values in each machine location, while \p vlocs the live-in variable
/// values. This method picks variable locations for the live-in variables,
/// creates DBG_VALUEs and puts them in #Transfers, then prepares the other
/// object fields to track variable locations as we step through the block.
/// FIXME: could just examine mloctracker instead of passing in \p mlocs?
void loadInlocs(MachineBasicBlock &MBB, ValueIDNum *MLocs,
                SmallVectorImpl<std::pair<DebugVariable, DbgValue>> &VLocs,
                unsigned NumLocs) {
  ActiveMLocs.clear();
  ActiveVLocs.clear();
  VarLocs.clear();
  VarLocs.reserve(NumLocs);
  UseBeforeDefs.clear();
  UseBeforeDefVariables.clear();

  auto isCalleeSaved = [&](LocIdx L) {
    unsigned Reg = MTracker->LocIdxToLocID[L];
    if (Reg >= MTracker->NumRegs)
      return false;
    for (MCRegAliasIterator RAI(Reg, &TRI, true); RAI.isValid(); ++RAI)
      if (CalleeSavedRegs.test(*RAI))
        return true;
    return false;
  };

  // Map of the preferred location for each value.
  std::map<ValueIDNum, LocIdx> ValueToLoc;

  // Produce a map of value numbers to the current machine locs they live
  // in. When emulating VarLocBasedImpl, there should only be one
  // location; when not, we get to pick.
  for (auto Location : MTracker->locations()) {
    LocIdx Idx = Location.Idx;
    ValueIDNum &VNum = MLocs[Idx.asU64()];
    VarLocs.push_back(VNum);
    auto it = ValueToLoc.find(VNum);
    // In order of preference, pick:
    //  * Callee saved registers,
    //  * Other registers,
    //  * Spill slots.
    if (it == ValueToLoc.end() || MTracker->isSpill(it->second) ||
        (!isCalleeSaved(it->second) && isCalleeSaved(Idx.asU64()))) {
      // Insert, or overwrite if insertion failed.
      auto PrefLocRes = ValueToLoc.insert(std::make_pair(VNum, Idx));
      if (!PrefLocRes.second)
        PrefLocRes.first->second = Idx;
    }
  }

  // Now map variables to their picked LocIdxes.
  for (auto Var : VLocs) {
    if (Var.second.Kind == DbgValue::Const) {
      PendingDbgValues.push_back(
          emitMOLoc(Var.second.MO, Var.first, Var.second.Properties));
      continue;
    }

    // If the value has no location, we can't make a variable location.
    const ValueIDNum &Num = Var.second.ID;
    auto ValuesPreferredLoc = ValueToLoc.find(Num);
    if (ValuesPreferredLoc == ValueToLoc.end()) {
      // If it's a def that occurs in this block, register it as a
      // use-before-def to be resolved as we step through the block.
      if (Num.getBlock() == (unsigned)MBB.getNumber() && !Num.isPHI())
        addUseBeforeDef(Var.first, Var.second.Properties, Num);
      else
        recoverAsEntryValue(Var.first, Var.second.Properties, Num);
      continue;
    }

    LocIdx M = ValuesPreferredLoc->second;
    auto NewValue = LocAndProperties{M, Var.second.Properties};
    auto Result = ActiveVLocs.insert(std::make_pair(Var.first, NewValue));
    if (!Result.second)
      Result.first->second = NewValue;
    ActiveMLocs[M].insert(Var.first);
    PendingDbgValues.push_back(
        MTracker->emitLoc(M, Var.first, Var.second.Properties));
  }
  flushDbgValues(MBB.begin(), &MBB);
}

/// Record that \p Var has value \p ID, a value that becomes available
/// later in the function.
void addUseBeforeDef(const DebugVariable &Var,
                     const DbgValueProperties &Properties, ValueIDNum ID) {
  UseBeforeDef UBD = {ID, Var, Properties};
  UseBeforeDefs[ID.getInst()].push_back(UBD);
  UseBeforeDefVariables.insert(Var);
}

/// After the instruction at index \p Inst and position \p pos has been
/// processed, check whether it defines a variable value in a use-before-def.
/// If so, and the variable value hasn't changed since the start of the
/// block, create a DBG_VALUE.
void checkInstForNewValues(unsigned Inst, MachineBasicBlock::iterator pos) {
  auto MIt = UseBeforeDefs.find(Inst);
  if (MIt == UseBeforeDefs.end())
    return;

  for (auto &Use : MIt->second) {
    LocIdx L = Use.ID.getLoc();

    // If something goes very wrong, we might end up labelling a COPY
    // instruction or similar with an instruction number, where it doesn't
    // actually define a new value, instead it moves a value. In case this
    // happens, discard.
    if (MTracker->LocIdxToIDNum[L] != Use.ID)
      continue;

    // If a different debug instruction defined the variable value / location
    // since the start of the block, don't materialize this use-before-def.
    if (!UseBeforeDefVariables.count(Use.Var))
      continue;

    PendingDbgValues.push_back(MTracker->emitLoc(L, Use.Var, Use.Properties));
  }
  flushDbgValues(pos, nullptr);
}

/// Helper to move created DBG_VALUEs into Transfers collection.
void flushDbgValues(MachineBasicBlock::iterator Pos, MachineBasicBlock *MBB) {
  if (PendingDbgValues.size() == 0)
    return;

  // Pick out the instruction start position.
  MachineBasicBlock::instr_iterator BundleStart;
  if (MBB && Pos == MBB->begin())
    BundleStart = MBB->instr_begin();
  else
    BundleStart = getBundleStart(Pos->getIterator());

  Transfers.push_back({BundleStart, MBB, PendingDbgValues});
  PendingDbgValues.clear();
}

bool isEntryValueVariable(const DebugVariable &Var,
                          const DIExpression *Expr) const {
  if (!Var.getVariable()->isParameter())
    return false;

  if (Var.getInlinedAt())
    return false;

  if (Expr->getNumElements() > 0)
    return false;

  return true;
}

bool isEntryValueValue(const ValueIDNum &Val) const {
  // Must be in entry block (block number zero), and be a PHI / live-in value.
  if (Val.getBlock() || !Val.isPHI())
    return false;

  // Entry values must enter in a register.
  if (MTracker->isSpill(Val.getLoc()))
    return false;

  Register SP = TLI->getStackPointerRegisterToSaveRestore();
  Register FP = TRI.getFrameRegister(MF);
  Register Reg = MTracker->LocIdxToLocID[Val.getLoc()];
  return Reg != SP && Reg != FP;
}

bool recoverAsEntryValue(const DebugVariable &Var, DbgValueProperties &Prop,
                         const ValueIDNum &Num) {
  // Is this variable location a candidate to be an entry value. First,
  // should we be trying this at all?
  if (!ShouldEmitDebugEntryValues)
    return false;

  // Is the variable appropriate for entry values (i.e., is a parameter).
  if (!isEntryValueVariable(Var, Prop.DIExpr))
    return false;

  // Is the value assigned to this variable still the entry value?
  if (!isEntryValueValue(Num))
    return false;

  // Emit a variable location using an entry value expression.
  DIExpression *NewExpr =
      DIExpression::prepend(Prop.DIExpr, DIExpression::EntryValue);
  Register Reg = MTracker->LocIdxToLocID[Num.getLoc()];
  MachineOperand MO = MachineOperand::CreateReg(Reg, false);
  MO.setIsDebug(true);

  PendingDbgValues.push_back(emitMOLoc(MO, Var, {NewExpr, Prop.Indirect}));
  return true;
}

/// Change a variable value after encountering a DBG_VALUE inside a block.
void redefVar(const MachineInstr &MI) {
  DebugVariable Var(MI.getDebugVariable(), MI.getDebugExpression(),
                    MI.getDebugLoc()->getInlinedAt());
  DbgValueProperties Properties(MI);

  const MachineOperand &MO = MI.getOperand(0);

  // Ignore non-register locations, we don't transfer those.
  if (!MO.isReg() || MO.getReg() == 0) {
    auto It = ActiveVLocs.find(Var);
    if (It != ActiveVLocs.end()) {
      ActiveMLocs[It->second.Loc].erase(Var);
      ActiveVLocs.erase(It);
   }
    // Any use-before-defs no longer apply.
    UseBeforeDefVariables.erase(Var);
    return;
  }

  Register Reg = MO.getReg();
  LocIdx NewLoc = MTracker->getRegMLoc(Reg);
  redefVar(MI, Properties, NewLoc);
}

/// Handle a change in variable location within a block. Terminate the
/// variables current location, and record the value it now refers to, so
/// that we can detect location transfers later on.
void redefVar(const MachineInstr &MI, const DbgValueProperties &Properties,
              Optional<LocIdx> OptNewLoc) {
  DebugVariable Var(MI.getDebugVariable(), MI.getDebugExpression(),
                    MI.getDebugLoc()->getInlinedAt());
  // Any use-before-defs no longer apply.
  UseBeforeDefVariables.erase(Var);

  // Erase any previous location,
  auto It = ActiveVLocs.find(Var);
  if (It != ActiveVLocs.end())
    ActiveMLocs[It->second.Loc].erase(Var);

  // If there _is_ no new location, all we had to do was erase.
  if (!OptNewLoc)
    return;
  LocIdx NewLoc = *OptNewLoc;

  // Check whether our local copy of values-by-location in #VarLocs is out of
  // date. Wipe old tracking data for the location if it's been clobbered in
  // the meantime.
  if (MTracker->getNumAtPos(NewLoc) != VarLocs[NewLoc.asU64()]) {
    for (auto &P : ActiveMLocs[NewLoc]) {
      ActiveVLocs.erase(P);
    }
    ActiveMLocs[NewLoc.asU64()].clear();
    VarLocs[NewLoc.asU64()] = MTracker->getNumAtPos(NewLoc);
  }

  ActiveMLocs[NewLoc].insert(Var);
  if (It == ActiveVLocs.end()) {
    ActiveVLocs.insert(
        std::make_pair(Var, LocAndProperties{NewLoc, Properties}));
  } else {
    It->second.Loc = NewLoc;
    It->second.Properties = Properties;
  }
}

/// Account for a location \p mloc being clobbered. Examine the variable
/// locations that will be terminated: and try to recover them by using
/// another location. Optionally, given \p MakeUndef, emit a DBG_VALUE to
/// explicitly terminate a location if it can't be recovered.
void clobberMloc(LocIdx MLoc, MachineBasicBlock::iterator Pos,
                 bool MakeUndef = true) {
  auto ActiveMLocIt = ActiveMLocs.find(MLoc);
  if (ActiveMLocIt == ActiveMLocs.end())
    return;

  // What was the old variable value?
  ValueIDNum OldValue = VarLocs[MLoc.asU64()];
  VarLocs[MLoc.asU64()] = ValueIDNum::EmptyValue;

  // Examine the remaining variable locations: if we can find the same value
  // again, we can recover the location.
  Optional<LocIdx> NewLoc = None;
  for (auto Loc : MTracker->locations())
    if (Loc.Value == OldValue)
      NewLoc = Loc.Idx;

  // If there is no location, and we weren't asked to make the variable
  // explicitly undef, then stop here.
  if (!NewLoc && !MakeUndef) {
    // Try and recover a few more locations with entry values.
    for (auto &Var : ActiveMLocIt->second) {
      auto &Prop = ActiveVLocs.find(Var)->second.Properties;
      recoverAsEntryValue(Var, Prop, OldValue);
    }
    flushDbgValues(Pos, nullptr);
    return;
  }

  // Examine all the variables based on this location.
  DenseSet<DebugVariable> NewMLocs;
  for (auto &Var : ActiveMLocIt->second) {
    auto ActiveVLocIt = ActiveVLocs.find(Var);
    // Re-state the variable location: if there's no replacement then NewLoc
    // is None and a $noreg DBG_VALUE will be created. Otherwise, a DBG_VALUE
    // identifying the alternative location will be emitted.
    const DIExpression *Expr = ActiveVLocIt->second.Properties.DIExpr;
    DbgValueProperties Properties(Expr, false);
    PendingDbgValues.push_back(MTracker->emitLoc(NewLoc, Var, Properties));

    // Update machine locations <=> variable locations maps. Defer updating
    // ActiveMLocs to avoid invalidaing the ActiveMLocIt iterator.
    if (!NewLoc) {
      ActiveVLocs.erase(ActiveVLocIt);
    } else {
      ActiveVLocIt->second.Loc = *NewLoc;
      NewMLocs.insert(Var);
    }
  }

  // Commit any deferred ActiveMLoc changes.
  if (!NewMLocs.empty())
    for (auto &Var : NewMLocs)
      ActiveMLocs[*NewLoc].insert(Var);

  // We lazily track what locations have which values; if we've found a new
  // location for the clobbered value, remember it.
  if (NewLoc)
    VarLocs[NewLoc->asU64()] = OldValue;

  flushDbgValues(Pos, nullptr);

  ActiveMLocIt->second.clear();
}

/// Transfer variables based on \p Src to be based on \p Dst. This handles
/// both register copies as well as spills and restores. Creates DBG_VALUEs
/// describing the movement.
void transferMlocs(LocIdx Src, LocIdx Dst, MachineBasicBlock::iterator Pos) {
  // Does Src still contain the value num we expect? If not, it's been
  // clobbered in the meantime, and our variable locations are stale.
  if (VarLocs[Src.asU64()] != MTracker->getNumAtPos(Src))
    return;

  // assert(ActiveMLocs[Dst].size() == 0);
  //^^^ Legitimate scenario on account of un-clobbered slot being assigned to?
  ActiveMLocs[Dst] = ActiveMLocs[Src];
  VarLocs[Dst.asU64()] = VarLocs[Src.asU64()];

  // For each variable based on Src; create a location at Dst.
  for (auto &Var : ActiveMLocs[Src]) {
    auto ActiveVLocIt = ActiveVLocs.find(Var);
    assert(ActiveVLocIt != ActiveVLocs.end())(static_cast <bool> (ActiveVLocIt != ActiveVLocs.end())
 ? void (0) : __assert_fail ("ActiveVLocIt != ActiveVLocs.end()"
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 1381, __extension__ __PRETTY_FUNCTION__));
    ActiveVLocIt->second.Loc = Dst;

    assert(Dst != 0)(static_cast <bool> (Dst != 0) ? void (0) : __assert_fail
 ("Dst != 0", "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 1384, __extension__ __PRETTY_FUNCTION__));
    MachineInstr *MI =
        MTracker->emitLoc(Dst, Var, ActiveVLocIt->second.Properties);
    PendingDbgValues.push_back(MI);
  }
  ActiveMLocs[Src].clear();
  flushDbgValues(Pos, nullptr);

  // XXX XXX XXX "pretend to be old LDV" means dropping all tracking data
  // about the old location.
  if (EmulateOldLDV)
    VarLocs[Src.asU64()] = ValueIDNum::EmptyValue;
}

MachineInstrBuilder emitMOLoc(const MachineOperand &MO,
                              const DebugVariable &Var,
                              const DbgValueProperties &Properties) {
  DebugLoc DL = DILocation::get(Var.getVariable()->getContext(), 0, 0,
                                Var.getVariable()->getScope(),
                                const_cast<DILocation *>(Var.getInlinedAt()));
  auto MIB = BuildMI(MF, DL, TII->get(TargetOpcode::DBG_VALUE));
  MIB.add(MO);
  if (Properties.Indirect)
    MIB.addImm(0);
  else
    MIB.addReg(0);
  MIB.addMetadata(Var.getVariable());
  MIB.addMetadata(Properties.DIExpr);
  return MIB;
}
1414};

1416class InstrRefBasedLDV : public LDVImpl {
1417private:
using FragmentInfo = DIExpression::FragmentInfo;
using OptFragmentInfo = Optional<DIExpression::FragmentInfo>;

// Helper while building OverlapMap, a map of all fragments seen for a given
// DILocalVariable.
using VarToFragments =
    DenseMap<const DILocalVariable *, SmallSet<FragmentInfo, 4>>;

/// Machine location/value transfer function, a mapping of which locations
/// are assigned which new values.
using MLocTransferMap = std::map<LocIdx, ValueIDNum>;

/// Live in/out structure for the variable values: a per-block map of
/// variables to their values. XXX, better name?
using LiveIdxT =
    DenseMap<const MachineBasicBlock *, DenseMap<DebugVariable, DbgValue> *>;

using VarAndLoc = std::pair<DebugVariable, DbgValue>;

/// Type for a live-in value: the predecessor block, and its value.
using InValueT = std::pair<MachineBasicBlock *, DbgValue *>;

/// Vector (per block) of a collection (inner smallvector) of live-ins.
/// Used as the result type for the variable value dataflow problem.
using LiveInsT = SmallVector<SmallVector<VarAndLoc, 8>, 8>;

const TargetRegisterInfo *TRI;
const TargetInstrInfo *TII;
const TargetFrameLowering *TFI;
const MachineFrameInfo *MFI;
BitVector CalleeSavedRegs;
LexicalScopes LS;
TargetPassConfig *TPC;

/// Object to track machine locations as we step through a block. Could
/// probably be a field rather than a pointer, as it's always used.
MLocTracker *MTracker;

/// Number of the current block LiveDebugValues is stepping through.
unsigned CurBB;

/// Number of the current instruction LiveDebugValues is evaluating.
unsigned CurInst;

/// Variable tracker -- listens to DBG_VALUEs occurring as InstrRefBasedImpl
/// steps through a block. Reads the values at each location from the
/// MLocTracker object.
VLocTracker *VTracker;

/// Tracker for transfers, listens to DBG_VALUEs and transfers of values
/// between locations during stepping, creates new DBG_VALUEs when values move
/// location.
TransferTracker *TTracker;

/// Blocks which are artificial, i.e. blocks which exclusively contain
/// instructions without DebugLocs, or with line 0 locations.
SmallPtrSet<const MachineBasicBlock *, 16> ArtificialBlocks;

// Mapping of blocks to and from their RPOT order.
DenseMap<unsigned int, MachineBasicBlock *> OrderToBB;
DenseMap<MachineBasicBlock *, unsigned int> BBToOrder;
DenseMap<unsigned, unsigned> BBNumToRPO;

/// Pair of MachineInstr, and its 1-based offset into the containing block.
using InstAndNum = std::pair<const MachineInstr *, unsigned>;
/// Map from debug instruction number to the MachineInstr labelled with that
/// number, and its location within the function. Used to transform
/// instruction numbers in DBG_INSTR_REFs into machine value numbers.
std::map<uint64_t, InstAndNum> DebugInstrNumToInstr;

/// Record of where we observed a DBG_PHI instruction.
class DebugPHIRecord {
public:
  uint64_t InstrNum;      ///< Instruction number of this DBG_PHI.
  MachineBasicBlock *MBB; ///< Block where DBG_PHI occurred.
  ValueIDNum ValueRead;   ///< The value number read by the DBG_PHI.
  LocIdx ReadLoc;         ///< Register/Stack location the DBG_PHI reads.

  operator unsigned() const { return InstrNum; }
};

/// Map from instruction numbers defined by DBG_PHIs to a record of what that
/// DBG_PHI read and where. Populated and edited during the machine value
/// location problem -- we use LLVMs SSA Updater to fix changes by
/// optimizations that destroy PHI instructions.
SmallVector<DebugPHIRecord, 32> DebugPHINumToValue;

// Map of overlapping variable fragments.
OverlapMap OverlapFragments;
VarToFragments SeenFragments;

/// Tests whether this instruction is a spill to a stack slot.
bool isSpillInstruction(const MachineInstr &MI, MachineFunction *MF);

/// Decide if @MI is a spill instruction and return true if it is. We use 2
/// criteria to make this decision:
/// - Is this instruction a store to a spill slot?
/// - Is there a register operand that is both used and killed?
/// TODO: Store optimization can fold spills into other stores (including
/// other spills). We do not handle this yet (more than one memory operand).
bool isLocationSpill(const MachineInstr &MI, MachineFunction *MF,
                     unsigned &Reg);

/// If a given instruction is identified as a spill, return the spill slot
/// and set \p Reg to the spilled register.
Optional<SpillLoc> isRestoreInstruction(const MachineInstr &MI,
                                        MachineFunction *MF, unsigned &Reg);

/// Given a spill instruction, extract the register and offset used to
/// address the spill slot in a target independent way.
SpillLoc extractSpillBaseRegAndOffset(const MachineInstr &MI);

/// Observe a single instruction while stepping through a block.
void process(MachineInstr &MI, ValueIDNum **MLiveOuts = nullptr,
             ValueIDNum **MLiveIns = nullptr);

/// Examines whether \p MI is a DBG_VALUE and notifies trackers.
/// \returns true if MI was recognized and processed.
bool transferDebugValue(const MachineInstr &MI);

/// Examines whether \p MI is a DBG_INSTR_REF and notifies trackers.
/// \returns true if MI was recognized and processed.
bool transferDebugInstrRef(MachineInstr &MI, ValueIDNum **MLiveOuts,
                           ValueIDNum **MLiveIns);

/// Stores value-information about where this PHI occurred, and what
/// instruction number is associated with it.
/// \returns true if MI was recognized and processed.
bool transferDebugPHI(MachineInstr &MI);

/// Examines whether \p MI is copy instruction, and notifies trackers.
/// \returns true if MI was recognized and processed.
bool transferRegisterCopy(MachineInstr &MI);

/// Examines whether \p MI is stack spill or restore  instruction, and
/// notifies trackers. \returns true if MI was recognized and processed.
bool transferSpillOrRestoreInst(MachineInstr &MI);

/// Examines \p MI for any registers that it defines, and notifies trackers.
void transferRegisterDef(MachineInstr &MI);

/// Copy one location to the other, accounting for movement of subregisters
/// too.
void performCopy(Register Src, Register Dst);

void accumulateFragmentMap(MachineInstr &MI);

/// Determine the machine value number referred to by (potentially several)
/// DBG_PHI instructions. Block duplication and tail folding can duplicate
/// DBG_PHIs, shifting the position where values in registers merge, and
/// forming another mini-ssa problem to solve.
/// \p Here the position of a DBG_INSTR_REF seeking a machine value number
/// \p InstrNum Debug instruction number defined by DBG_PHI instructions.
/// \returns The machine value number at position Here, or None.
Optional<ValueIDNum> resolveDbgPHIs(MachineFunction &MF,
                                    ValueIDNum **MLiveOuts,
                                    ValueIDNum **MLiveIns, MachineInstr &Here,
                                    uint64_t InstrNum);

/// Step through the function, recording register definitions and movements
/// in an MLocTracker. Convert the observations into a per-block transfer
/// function in \p MLocTransfer, suitable for using with the machine value
/// location dataflow problem.
void
produceMLocTransferFunction(MachineFunction &MF,
                            SmallVectorImpl<MLocTransferMap> &MLocTransfer,
                            unsigned MaxNumBlocks);

/// Solve the machine value location dataflow problem. Takes as input the
/// transfer functions in \p MLocTransfer. Writes the output live-in and
/// live-out arrays to the (initialized to zero) multidimensional arrays in
/// \p MInLocs and \p MOutLocs. The outer dimension is indexed by block
/// number, the inner by LocIdx.
void mlocDataflow(ValueIDNum **MInLocs, ValueIDNum **MOutLocs,
                  SmallVectorImpl<MLocTransferMap> &MLocTransfer);

/// Perform a control flow join (lattice value meet) of the values in machine
/// locations at \p MBB. Follows the algorithm described in the file-comment,
/// reading live-outs of predecessors from \p OutLocs, the current live ins
/// from \p InLocs, and assigning the newly computed live ins back into
/// \p InLocs. \returns two bools -- the first indicates whether a change
/// was made, the second whether a lattice downgrade occurred. If the latter
/// is true, revisiting this block is necessary.
std::tuple<bool, bool>
mlocJoin(MachineBasicBlock &MBB,
         SmallPtrSet<const MachineBasicBlock *, 16> &Visited,
         ValueIDNum **OutLocs, ValueIDNum *InLocs);

/// Solve the variable value dataflow problem, for a single lexical scope.
/// Uses the algorithm from the file comment to resolve control flow joins,
/// although there are extra hacks, see vlocJoin. Reads the
/// locations of values from the \p MInLocs and \p MOutLocs arrays (see
/// mlocDataflow) and reads the variable values transfer function from
/// \p AllTheVlocs. Live-in and Live-out variable values are stored locally,
/// with the live-ins permanently stored to \p Output once the fixedpoint is
/// reached.
/// \p VarsWeCareAbout contains a collection of the variables in \p Scope
/// that we should be tracking.
/// \p AssignBlocks contains the set of blocks that aren't in \p Scope, but
/// which do contain DBG_VALUEs, which VarLocBasedImpl tracks locations
/// through.
void vlocDataflow(const LexicalScope *Scope, const DILocation *DILoc,
                  const SmallSet<DebugVariable, 4> &VarsWeCareAbout,
                  SmallPtrSetImpl<MachineBasicBlock *> &AssignBlocks,
                  LiveInsT &Output, ValueIDNum **MOutLocs,
                  ValueIDNum **MInLocs,
                  SmallVectorImpl<VLocTracker> &AllTheVLocs);

/// Compute the live-ins to a block, considering control flow merges according
/// to the method in the file comment. Live out and live in variable values
/// are stored in \p VLOCOutLocs and \p VLOCInLocs. The live-ins for \p MBB
/// are computed and stored into \p VLOCInLocs. \returns true if the live-ins
/// are modified.
/// \p InLocsT Output argument, storage for calculated live-ins.
/// \returns two bools -- the first indicates whether a change
/// was made, the second whether a lattice downgrade occurred. If the latter
/// is true, revisiting this block is necessary.
std::tuple<bool, bool>
vlocJoin(MachineBasicBlock &MBB, LiveIdxT &VLOCOutLocs, LiveIdxT &VLOCInLocs,
         SmallPtrSet<const MachineBasicBlock *, 16> *VLOCVisited,
         unsigned BBNum, const SmallSet<DebugVariable, 4> &AllVars,
         ValueIDNum **MOutLocs, ValueIDNum **MInLocs,
         SmallPtrSet<const MachineBasicBlock *, 8> &InScopeBlocks,
         SmallPtrSet<const MachineBasicBlock *, 8> &BlocksToExplore,
         DenseMap<DebugVariable, DbgValue> &InLocsT);

/// Continue exploration of the variable-value lattice, as explained in the
/// file-level comment. \p OldLiveInLocation contains the current
/// exploration position, from which we need to descend further. \p Values
/// contains the set of live-in values, \p CurBlockRPONum the RPO number of
/// the current block, and \p CandidateLocations a set of locations that
/// should be considered as PHI locations, if we reach the bottom of the
/// lattice. \returns true if we should downgrade; the value is the agreeing
/// value number in a non-backedge predecessor.
bool vlocDowngradeLattice(const MachineBasicBlock &MBB,
                          const DbgValue &OldLiveInLocation,
                          const SmallVectorImpl<InValueT> &Values,
                          unsigned CurBlockRPONum);

/// For the given block and live-outs feeding into it, try to find a
/// machine location where they all join. If a solution for all predecessors
/// can't be found, a location where all non-backedge-predecessors join
/// will be returned instead. While this method finds a join location, this
/// says nothing as to whether it should be used.
/// \returns Pair of value ID if found, and true when the correct value
/// is available on all predecessor edges, or false if it's only available
/// for non-backedge predecessors.
std::tuple<Optional<ValueIDNum>, bool>
pickVPHILoc(MachineBasicBlock &MBB, const DebugVariable &Var,
            const LiveIdxT &LiveOuts, ValueIDNum **MOutLocs,
            ValueIDNum **MInLocs,
            const SmallVectorImpl<MachineBasicBlock *> &BlockOrders);

/// Given the solutions to the two dataflow problems, machine value locations
/// in \p MInLocs and live-in variable values in \p SavedLiveIns, runs the
/// TransferTracker class over the function to produce live-in and transfer
/// DBG_VALUEs, then inserts them. Groups of DBG_VALUEs are inserted in the
/// order given by AllVarsNumbering -- this could be any stable order, but
/// right now "order of appearence in function, when explored in RPO", so
/// that we can compare explictly against VarLocBasedImpl.
void emitLocations(MachineFunction &MF, LiveInsT SavedLiveIns,
                   ValueIDNum **MOutLocs, ValueIDNum **MInLocs,
                   DenseMap<DebugVariable, unsigned> &AllVarsNumbering,
                   const TargetPassConfig &TPC);

/// Boilerplate computation of some initial sets, artifical blocks and
/// RPOT block ordering.
void initialSetup(MachineFunction &MF);

bool ExtendRanges(MachineFunction &MF, TargetPassConfig *TPC) override;

1689public:
/// Default construct and initialize the pass.
InstrRefBasedLDV();

LLVM_DUMP_METHOD__attribute__((noinline)) __attribute__((__used__))
void dump_mloc_transfer(const MLocTransferMap &mloc_transfer) const;

bool isCalleeSaved(LocIdx L) {
  unsigned Reg = MTracker->LocIdxToLocID[L];
  for (MCRegAliasIterator RAI(Reg, TRI, true); RAI.isValid(); ++RAI)
    if (CalleeSavedRegs.test(*RAI))
      return true;
  return false;
}
1703};

1705} // end anonymous namespace

1707//===----------------------------------------------------------------------===//
1708//            Implementation
1709//===----------------------------------------------------------------------===//

1711ValueIDNum ValueIDNum::EmptyValue = {UINT_MAX(2147483647 *2U +1U), UINT_MAX(2147483647 *2U +1U), UINT_MAX(2147483647 *2U +1U)};

1713/// Default construct and initialize the pass.
1714InstrRefBasedLDV::InstrRefBasedLDV() {}

1716//===----------------------------------------------------------------------===//
1717//            Debug Range Extension Implementation
1718//===----------------------------------------------------------------------===//

1720#ifndef NDEBUG
1721// Something to restore in the future.
1722// void InstrRefBasedLDV::printVarLocInMBB(..)
1723#endif

1725SpillLoc
1726InstrRefBasedLDV::extractSpillBaseRegAndOffset(const MachineInstr &MI) {
assert(MI.hasOneMemOperand() &&(static_cast <bool> (MI.hasOneMemOperand() && "Spill instruction does not have exactly one memory operand?"
) ? void (0) : __assert_fail ("MI.hasOneMemOperand() && \"Spill instruction does not have exactly one memory operand?\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 1728, __extension__ __PRETTY_FUNCTION__))
       "Spill instruction does not have exactly one memory operand?")(static_cast <bool> (MI.hasOneMemOperand() && "Spill instruction does not have exactly one memory operand?"
) ? void (0) : __assert_fail ("MI.hasOneMemOperand() && \"Spill instruction does not have exactly one memory operand?\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 1728, __extension__ __PRETTY_FUNCTION__));
auto MMOI = MI.memoperands_begin();
const PseudoSourceValue *PVal = (*MMOI)->getPseudoValue();
assert(PVal->kind() == PseudoSourceValue::FixedStack &&(static_cast <bool> (PVal->kind() == PseudoSourceValue
::FixedStack && "Inconsistent memory operand in spill instruction"
) ? void (0) : __assert_fail ("PVal->kind() == PseudoSourceValue::FixedStack && \"Inconsistent memory operand in spill instruction\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 1732, __extension__ __PRETTY_FUNCTION__))
       "Inconsistent memory operand in spill instruction")(static_cast <bool> (PVal->kind() == PseudoSourceValue
::FixedStack && "Inconsistent memory operand in spill instruction"
) ? void (0) : __assert_fail ("PVal->kind() == PseudoSourceValue::FixedStack && \"Inconsistent memory operand in spill instruction\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 1732, __extension__ __PRETTY_FUNCTION__));
int FI = cast<FixedStackPseudoSourceValue>(PVal)->getFrameIndex();
const MachineBasicBlock *MBB = MI.getParent();
Register Reg;
StackOffset Offset = TFI->getFrameIndexReference(*MBB->getParent(), FI, Reg);
return {Reg, Offset};
1738}

1740/// End all previous ranges related to @MI and start a new range from @MI
1741/// if it is a DBG_VALUE instr.
1742bool InstrRefBasedLDV::transferDebugValue(const MachineInstr &MI) {
if (!MI.isDebugValue())
55
←
Calling 'MachineInstr::isDebugValue'→
57
←
Returning from 'MachineInstr::isDebugValue'→
58
←
Taking true branch→
  return false;
59
←
Returning zero, which participates in a condition later→

const DILocalVariable *Var = MI.getDebugVariable();
const DIExpression *Expr = MI.getDebugExpression();
const DILocation *DebugLoc = MI.getDebugLoc();
const DILocation *InlinedAt = DebugLoc->getInlinedAt();
assert(Var->isValidLocationForIntrinsic(DebugLoc) &&(static_cast <bool> (Var->isValidLocationForIntrinsic
(DebugLoc) && "Expected inlined-at fields to agree") ?
 void (0) : __assert_fail ("Var->isValidLocationForIntrinsic(DebugLoc) && \"Expected inlined-at fields to agree\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 1751, __extension__ __PRETTY_FUNCTION__))
       "Expected inlined-at fields to agree")(static_cast <bool> (Var->isValidLocationForIntrinsic
(DebugLoc) && "Expected inlined-at fields to agree") ?
 void (0) : __assert_fail ("Var->isValidLocationForIntrinsic(DebugLoc) && \"Expected inlined-at fields to agree\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 1751, __extension__ __PRETTY_FUNCTION__));

DebugVariable V(Var, Expr, InlinedAt);
DbgValueProperties Properties(MI);

// If there are no instructions in this lexical scope, do no location tracking
// at all, this variable shouldn't get a legitimate location range.
auto *Scope = LS.findLexicalScope(MI.getDebugLoc().get());
if (Scope == nullptr)
  return true; // handled it; by doing nothing

const MachineOperand &MO = MI.getOperand(0);

// MLocTracker needs to know that this register is read, even if it's only
// read by a debug inst.
if (MO.isReg() && MO.getReg() != 0)
  (void)MTracker->readReg(MO.getReg());

// If we're preparing for the second analysis (variables), the machine value
// locations are already solved, and we report this DBG_VALUE and the value
// it refers to to VLocTracker.
if (VTracker) {
  if (MO.isReg()) {
    // Feed defVar the new variable location, or if this is a
    // DBG_VALUE $noreg, feed defVar None.
    if (MO.getReg())
      VTracker->defVar(MI, Properties, MTracker->readReg(MO.getReg()));
    else
      VTracker->defVar(MI, Properties, None);
  } else if (MI.getOperand(0).isImm() || MI.getOperand(0).isFPImm() ||
             MI.getOperand(0).isCImm()) {
    VTracker->defVar(MI, MI.getOperand(0));
  }
}

// If performing final tracking of transfers, report this variable definition
// to the TransferTracker too.
if (TTracker)
  TTracker->redefVar(MI);
return true;
1791}

1793bool InstrRefBasedLDV::transferDebugInstrRef(MachineInstr &MI,
                                           ValueIDNum **MLiveOuts,
                                           ValueIDNum **MLiveIns) {
if (!MI.isDebugRef())
12
←
Taking true branch→
64
←
Calling 'MachineInstr::isDebugRef'→
67
←
Returning from 'MachineInstr::isDebugRef'→
68
←
Taking false branch→
  return false;
13
←
Returning without writing to 'MI.DebugInstrNum', which participates in a condition later→

// Only handle this instruction when we are building the variable value
// transfer function.
if (!VTracker)
69
←
Assuming field 'VTracker' is non-null→
70
←
Taking false branch→
  return false;

unsigned InstNo = MI.getOperand(0).getImm();
unsigned OpNo = MI.getOperand(1).getImm();

const DILocalVariable *Var = MI.getDebugVariable();
const DIExpression *Expr = MI.getDebugExpression();
const DILocation *DebugLoc = MI.getDebugLoc();
const DILocation *InlinedAt = DebugLoc->getInlinedAt();
assert(Var->isValidLocationForIntrinsic(DebugLoc) &&(static_cast <bool> (Var->isValidLocationForIntrinsic
(DebugLoc) && "Expected inlined-at fields to agree") ?
 void (0) : __assert_fail ("Var->isValidLocationForIntrinsic(DebugLoc) && \"Expected inlined-at fields to agree\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 1812, __extension__ __PRETTY_FUNCTION__))
71
←
'?' condition is true→
       "Expected inlined-at fields to agree")(static_cast <bool> (Var->isValidLocationForIntrinsic
(DebugLoc) && "Expected inlined-at fields to agree") ?
 void (0) : __assert_fail ("Var->isValidLocationForIntrinsic(DebugLoc) && \"Expected inlined-at fields to agree\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 1812, __extension__ __PRETTY_FUNCTION__));

DebugVariable V(Var, Expr, InlinedAt);

auto *Scope = LS.findLexicalScope(MI.getDebugLoc().get());
if (Scope == nullptr)
72
←
Assuming the condition is false→
73
←
Taking false branch→
  return true; // Handled by doing nothing. This variable is never in scope.

const MachineFunction &MF = *MI.getParent()->getParent();

// Various optimizations may have happened to the value during codegen,
// recorded in the value substitution table. Apply any substitutions to
// the instruction / operand number in this DBG_INSTR_REF, and collect
// any subregister extractions performed during optimization.

// Create dummy substitution with Src set, for lookup.
auto SoughtSub =
    MachineFunction::DebugSubstitution({InstNo, OpNo}, {0, 0}, 0);

SmallVector<unsigned, 4> SeenSubregs;
auto LowerBoundIt = llvm::lower_bound(MF.DebugValueSubstitutions, SoughtSub);
while (LowerBoundIt != MF.DebugValueSubstitutions.end() &&
74
←
Assuming the condition is false→
       LowerBoundIt->Src == SoughtSub.Src) {
  std::tie(InstNo, OpNo) = LowerBoundIt->Dest;
  SoughtSub.Src = LowerBoundIt->Dest;
  if (unsigned Subreg = LowerBoundIt->Subreg)
    SeenSubregs.push_back(Subreg);
  LowerBoundIt = llvm::lower_bound(MF.DebugValueSubstitutions, SoughtSub);
}

// Default machine value number is <None> -- if no instruction defines
// the corresponding value, it must have been optimized out.
Optional<ValueIDNum> NewID = None;

// Try to lookup the instruction number, and find the machine value number
// that it defines. It could be an instruction, or a PHI.
auto InstrIt = DebugInstrNumToInstr.find(InstNo);
auto PHIIt = std::lower_bound(DebugPHINumToValue.begin(),
                              DebugPHINumToValue.end(), InstNo);
if (InstrIt != DebugInstrNumToInstr.end()) {
75
←
Calling 'operator!='→
78
←
Returning from 'operator!='→
79
←
Taking false branch→
  const MachineInstr &TargetInstr = *InstrIt->second.first;
  uint64_t BlockNo = TargetInstr.getParent()->getNumber();

  // Pick out the designated operand.
  assert(OpNo < TargetInstr.getNumOperands())(static_cast <bool> (OpNo < TargetInstr.getNumOperands
()) ? void (0) : __assert_fail ("OpNo < TargetInstr.getNumOperands()"
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 1856, __extension__ __PRETTY_FUNCTION__));
  const MachineOperand &MO = TargetInstr.getOperand(OpNo);

  // Today, this can only be a register.
  assert(MO.isReg() && MO.isDef())(static_cast <bool> (MO.isReg() && MO.isDef()) ?
 void (0) : __assert_fail ("MO.isReg() && MO.isDef()"
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 1860, __extension__ __PRETTY_FUNCTION__));

  unsigned LocID = MTracker->getLocID(MO.getReg(), false);
  LocIdx L = MTracker->LocIDToLocIdx[LocID];
  NewID = ValueIDNum(BlockNo, InstrIt->second.second, L);
} else if (PHIIt != DebugPHINumToValue.end() && PHIIt->InstrNum == InstNo) {
80
←
Assuming the condition is true→
81
←
Assuming 'InstNo' is equal to field 'InstrNum'→
82
←
Taking true branch→
  // It's actually a PHI value. Which value it is might not be obvious, use
  // the resolver helper to find out.
  NewID = resolveDbgPHIs(*MI.getParent()->getParent(), MLiveOuts, MLiveIns,
83
←
Passing null pointer value via 3rd parameter 'MLiveIns'→
84
←
Calling 'InstrRefBasedLDV::resolveDbgPHIs'→
                         MI, InstNo);
}

// Apply any subregister extractions, in reverse. We might have seen code
// like this:
//    CALL64 @foo, implicit-def $rax
//    %0:gr64 = COPY $rax
//    %1:gr32 = COPY %0.sub_32bit
//    %2:gr16 = COPY %1.sub_16bit
//    %3:gr8  = COPY %2.sub_8bit
// In which case each copy would have been recorded as a substitution with
// a subregister qualifier. Apply those qualifiers now.
if (NewID && !SeenSubregs.empty()) {
  unsigned Offset = 0;
  unsigned Size = 0;

  // Look at each subregister that we passed through, and progressively
  // narrow in, accumulating any offsets that occur. Substitutions should
  // only ever be the same or narrower width than what they read from;
  // iterate in reverse order so that we go from wide to small.
  for (unsigned Subreg : reverse(SeenSubregs)) {
    unsigned ThisSize = TRI->getSubRegIdxSize(Subreg);
    unsigned ThisOffset = TRI->getSubRegIdxOffset(Subreg);
    Offset += ThisOffset;
    Size = (Size == 0) ? ThisSize : std::min(Size, ThisSize);
  }

  // If that worked, look for an appropriate subregister with the register
  // where the define happens. Don't look at values that were defined during
  // a stack write: we can't currently express register locations within
  // spills.
  LocIdx L = NewID->getLoc();
  if (NewID && !MTracker->isSpill(L)) {
    // Find the register class for the register where this def happened.
    // FIXME: no index for this?
    Register Reg = MTracker->LocIdxToLocID[L];
    const TargetRegisterClass *TRC = nullptr;
    for (auto *TRCI : TRI->regclasses())
      if (TRCI->contains(Reg))
        TRC = TRCI;
    assert(TRC && "Couldn't find target register class?")(static_cast <bool> (TRC && "Couldn't find target register class?"
) ? void (0) : __assert_fail ("TRC && \"Couldn't find target register class?\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 1909, __extension__ __PRETTY_FUNCTION__));

    // If the register we have isn't the right size or in the right place,
    // Try to find a subregister inside it.
    unsigned MainRegSize = TRI->getRegSizeInBits(*TRC);
    if (Size != MainRegSize || Offset) {
      // Enumerate all subregisters, searching.
      Register NewReg = 0;
      for (MCSubRegIterator SRI(Reg, TRI, false); SRI.isValid(); ++SRI) {
        unsigned Subreg = TRI->getSubRegIndex(Reg, *SRI);
        unsigned SubregSize = TRI->getSubRegIdxSize(Subreg);
        unsigned SubregOffset = TRI->getSubRegIdxOffset(Subreg);
        if (SubregSize == Size && SubregOffset == Offset) {
          NewReg = *SRI;
          break;
        }
      }

      // If we didn't find anything: there's no way to express our value.
      if (!NewReg) {
        NewID = None;
      } else {
        // Re-state the value as being defined within the subregister
        // that we found.
        LocIdx NewLoc = MTracker->lookupOrTrackRegister(NewReg);
        NewID = ValueIDNum(NewID->getBlock(), NewID->getInst(), NewLoc);
      }
    }
  } else {
    // If we can't handle subregisters, unset the new value.
    NewID = None;
  }
}

// We, we have a value number or None. Tell the variable value tracker about
// it. The rest of this LiveDebugValues implementation acts exactly the same
// for DBG_INSTR_REFs as DBG_VALUEs (just, the former can refer to values that
// aren't immediately available).
DbgValueProperties Properties(Expr, false);
VTracker->defVar(MI, Properties, NewID);

// If we're on the final pass through the function, decompose this INSTR_REF
// into a plain DBG_VALUE.
if (!TTracker)
  return true;

// Pick a location for the machine value number, if such a location exists.
// (This information could be stored in TransferTracker to make it faster).
Optional<LocIdx> FoundLoc = None;
for (auto Location : MTracker->locations()) {
  LocIdx CurL = Location.Idx;
  ValueIDNum ID = MTracker->LocIdxToIDNum[CurL];
  if (NewID && ID == NewID) {
    // If this is the first location with that value, pick it. Otherwise,
    // consider whether it's a "longer term" location.
    if (!FoundLoc) {
      FoundLoc = CurL;
      continue;
    }

    if (MTracker->isSpill(CurL))
      FoundLoc = CurL; // Spills are a longer term location.
    else if (!MTracker->isSpill(*FoundLoc) &&
             !MTracker->isSpill(CurL) &&
             !isCalleeSaved(*FoundLoc) &&
             isCalleeSaved(CurL))
      FoundLoc = CurL; // Callee saved regs are longer term than normal.
  }
}

// Tell transfer tracker that the variable value has changed.
TTracker->redefVar(MI, Properties, FoundLoc);

// If there was a value with no location; but the value is defined in a
// later instruction in this block, this is a block-local use-before-def.
if (!FoundLoc && NewID && NewID->getBlock() == CurBB &&
    NewID->getInst() > CurInst)
  TTracker->addUseBeforeDef(V, {MI.getDebugExpression(), false}, *NewID);

// Produce a DBG_VALUE representing what this DBG_INSTR_REF meant.
// This DBG_VALUE is potentially a $noreg / undefined location, if
// FoundLoc is None.
// (XXX -- could morph the DBG_INSTR_REF in the future).
MachineInstr *DbgMI = MTracker->emitLoc(FoundLoc, V, Properties);
TTracker->PendingDbgValues.push_back(DbgMI);
TTracker->flushDbgValues(MI.getIterator(), nullptr);
return true;
1996}

1998bool InstrRefBasedLDV::transferDebugPHI(MachineInstr &MI) {
if (!MI.isDebugPHI())
17
←
Taking true branch→
  return false;
18
←
Returning without writing to 'MI.DebugInstrNum', which participates in a condition later→

// Analyse these only when solving the machine value location problem.
if (VTracker || TTracker)
  return true;

// First operand is the value location, either a stack slot or register.
// Second is the debug instruction number of the original PHI.
const MachineOperand &MO = MI.getOperand(0);
unsigned InstrNum = MI.getOperand(1).getImm();

if (MO.isReg()) {
  // The value is whatever's currently in the register. Read and record it,
  // to be analysed later.
  Register Reg = MO.getReg();
  ValueIDNum Num = MTracker->readReg(Reg);
  auto PHIRec = DebugPHIRecord(
      {InstrNum, MI.getParent(), Num, MTracker->lookupOrTrackRegister(Reg)});
  DebugPHINumToValue.push_back(PHIRec);
} else {
  // The value is whatever's in this stack slot.
  assert(MO.isFI())(static_cast <bool> (MO.isFI()) ? void (0) : __assert_fail
 ("MO.isFI()", "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 2021, __extension__ __PRETTY_FUNCTION__));
  unsigned FI = MO.getIndex();

  // If the stack slot is dead, then this was optimized away.
  // FIXME: stack slot colouring should account for slots that get merged.
  if (MFI->isDeadObjectIndex(FI))
    return true;

  // Identify this spill slot.
  Register Base;
  StackOffset Offs = TFI->getFrameIndexReference(*MI.getMF(), FI, Base);
  SpillLoc SL = {Base, Offs};
  Optional<ValueIDNum> Num = MTracker->readSpill(SL);

  if (!Num)
    // Nothing ever writes to this slot. Curious, but nothing we can do.
    return true;

  // Record this DBG_PHI for later analysis.
  auto DbgPHI = DebugPHIRecord(
      {InstrNum, MI.getParent(), *Num, *MTracker->getSpillMLoc(SL)});
  DebugPHINumToValue.push_back(DbgPHI);
}

return true;
2046}

2048void InstrRefBasedLDV::transferRegisterDef(MachineInstr &MI) {
// Meta Instructions do not affect the debug liveness of any register they
// define.
if (MI.isImplicitDef()) {
39
←
Taking false branch→
  // Except when there's an implicit def, and the location it's defining has
  // no value number. The whole point of an implicit def is to announce that
  // the register is live, without be specific about it's value. So define
  // a value if there isn't one already.
  ValueIDNum Num = MTracker->readReg(MI.getOperand(0).getReg());
  // Has a legitimate value -> ignore the implicit def.
  if (Num.getLoc() != 0)
    return;
  // Otherwise, def it here.
} else if (MI.isMetaInstruction())
40
←
Taking false branch→
  return;

MachineFunction *MF = MI.getMF();
const TargetLowering *TLI = MF->getSubtarget().getTargetLowering();
Register SP = TLI->getStackPointerRegisterToSaveRestore();

// Find the regs killed by MI, and find regmasks of preserved regs.
// Max out the number of statically allocated elements in `DeadRegs`, as this
// prevents fallback to std::set::count() operations.
SmallSet<uint32_t, 32> DeadRegs;
SmallVector<const uint32_t *, 4> RegMasks;
SmallVector<const MachineOperand *, 4> RegMaskPtrs;
for (const MachineOperand &MO : MI.operands()) {
41
←
Assuming '__begin1' is equal to '__end1'→
  // Determine whether the operand is a register def.
  if (MO.isReg() && MO.isDef() && MO.getReg() &&
      Register::isPhysicalRegister(MO.getReg()) &&
      !(MI.isCall() && MO.getReg() == SP)) {
    // Remove ranges of all aliased registers.
    for (MCRegAliasIterator RAI(MO.getReg(), TRI, true); RAI.isValid(); ++RAI)
      // FIXME: Can we break out of this loop early if no insertion occurs?
      DeadRegs.insert(*RAI);
  } else if (MO.isRegMask()) {
    RegMasks.push_back(MO.getRegMask());
    RegMaskPtrs.push_back(&MO);
  }
}

// Tell MLocTracker about all definitions, of regmasks and otherwise.
for (uint32_t DeadReg : DeadRegs)
  MTracker->defReg(DeadReg, CurBB, CurInst);

for (auto *MO : RegMaskPtrs)
42
←
Assuming '__begin1' is equal to '__end1'→
  MTracker->writeRegMask(MO, CurBB, CurInst);

if (!TTracker)
43
←
Assuming field 'TTracker' is null→
44
←
Taking true branch→
  return;
45
←
Returning without writing to 'MI.DebugInstrNum', which participates in a condition later→

// When committing variable values to locations: tell transfer tracker that
// we've clobbered things. It may be able to recover the variable from a
// different location.

// Inform TTracker about any direct clobbers.
for (uint32_t DeadReg : DeadRegs) {
  LocIdx Loc = MTracker->lookupOrTrackRegister(DeadReg);
  TTracker->clobberMloc(Loc, MI.getIterator(), false);
}

// Look for any clobbers performed by a register mask. Only test locations
// that are actually being tracked.
for (auto L : MTracker->locations()) {
  // Stack locations can't be clobbered by regmasks.
  if (MTracker->isSpill(L.Idx))
    continue;

  Register Reg = MTracker->LocIdxToLocID[L.Idx];
  for (auto *MO : RegMaskPtrs)
    if (MO->clobbersPhysReg(Reg))
      TTracker->clobberMloc(L.Idx, MI.getIterator(), false);
}
2121}

2123void InstrRefBasedLDV::performCopy(Register SrcRegNum, Register DstRegNum) {
ValueIDNum SrcValue = MTracker->readReg(SrcRegNum);

MTracker->setReg(DstRegNum, SrcValue);

// In all circumstances, re-def the super registers. It's definitely a new
// value now. This doesn't uniquely identify the composition of subregs, for
// example, two identical values in subregisters composed in different
// places would not get equal value numbers.
for (MCSuperRegIterator SRI(DstRegNum, TRI); SRI.isValid(); ++SRI)
  MTracker->defReg(*SRI, CurBB, CurInst);

// If we're emulating VarLocBasedImpl, just define all the subregisters.
// DBG_VALUEs of them will expect to be tracked from the DBG_VALUE, not
// through prior copies.
if (EmulateOldLDV) {
  for (MCSubRegIndexIterator DRI(DstRegNum, TRI); DRI.isValid(); ++DRI)
    MTracker->defReg(DRI.getSubReg(), CurBB, CurInst);
  return;
}

// Otherwise, actually copy subregisters from one location to another.
// XXX: in addition, any subregisters of DstRegNum that don't line up with
// the source register should be def'd.
for (MCSubRegIndexIterator SRI(SrcRegNum, TRI); SRI.isValid(); ++SRI) {
  unsigned SrcSubReg = SRI.getSubReg();
  unsigned SubRegIdx = SRI.getSubRegIndex();
  unsigned DstSubReg = TRI->getSubReg(DstRegNum, SubRegIdx);
  if (!DstSubReg)
    continue;

  // Do copy. There are two matching subregisters, the source value should
  // have been def'd when the super-reg was, the latter might not be tracked
  // yet.
  // This will force SrcSubReg to be tracked, if it isn't yet.
  (void)MTracker->readReg(SrcSubReg);
  LocIdx SrcL = MTracker->getRegMLoc(SrcSubReg);
  assert(SrcL.asU64())(static_cast <bool> (SrcL.asU64()) ? void (0) : __assert_fail
 ("SrcL.asU64()", "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 2160, __extension__ __PRETTY_FUNCTION__));
  (void)MTracker->readReg(DstSubReg);
  LocIdx DstL = MTracker->getRegMLoc(DstSubReg);
  assert(DstL.asU64())(static_cast <bool> (DstL.asU64()) ? void (0) : __assert_fail
 ("DstL.asU64()", "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 2163, __extension__ __PRETTY_FUNCTION__));
  (void)DstL;
  ValueIDNum CpyValue = {SrcValue.getBlock(), SrcValue.getInst(), SrcL};

  MTracker->setReg(DstSubReg, CpyValue);
}
2169}

2171bool InstrRefBasedLDV::isSpillInstruction(const MachineInstr &MI,
                                        MachineFunction *MF) {
// TODO: Handle multiple stores folded into one.
if (!MI.hasOneMemOperand())
  return false;

if (!MI.getSpillSize(TII) && !MI.getFoldedSpillSize(TII))
  return false; // This is not a spill instruction, since no valid size was
                // returned from either function.

return true;
2182}

2184bool InstrRefBasedLDV::isLocationSpill(const MachineInstr &MI,
                                     MachineFunction *MF, unsigned &Reg) {
if (!isSpillInstruction(MI, MF))
  return false;

int FI;
Reg = TII->isStoreToStackSlotPostFE(MI, FI);
return Reg != 0;
2192}

2194Optional<SpillLoc>
2195InstrRefBasedLDV::isRestoreInstruction(const MachineInstr &MI,
                                     MachineFunction *MF, unsigned &Reg) {
if (!MI.hasOneMemOperand())
  return None;

// FIXME: Handle folded restore instructions with more than one memory
// operand.
if (MI.getRestoreSize(TII)) {
  Reg = MI.getOperand(0).getReg();
  return extractSpillBaseRegAndOffset(MI);
}
return None;
2207}

2209bool InstrRefBasedLDV::transferSpillOrRestoreInst(MachineInstr &MI) {
// XXX -- it's too difficult to implement VarLocBasedImpl's  stack location
// limitations under the new model. Therefore, when comparing them, compare
// versions that don't attempt spills or restores at all.
if (EmulateOldLDV)
28
←
Assuming the condition is false→
29
←
Taking false branch→
  return false;

MachineFunction *MF = MI.getMF();
unsigned Reg;
Optional<SpillLoc> Loc;

LLVM_DEBUG(dbgs() << "Examining instruction: "; MI.dump();)do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("livedebugvalues")) { dbgs() << "Examining instruction: "
; MI.dump();; } } while (false);
30
←
Assuming 'DebugFlag' is false→
31
←
Loop condition is false.  Exiting loop→

// First, if there are any DBG_VALUEs pointing at a spill slot that is
// written to, terminate that variable location. The value in memory
// will have changed. DbgEntityHistoryCalculator doesn't try to detect this.
if (isSpillInstruction(MI, MF)) {
32
←
Taking false branch→
  Loc = extractSpillBaseRegAndOffset(MI);

  if (TTracker) {
    Optional<LocIdx> MLoc = MTracker->getSpillMLoc(*Loc);
    if (MLoc) {
      // Un-set this location before clobbering, so that we don't salvage
      // the variable location back to the same place.
      MTracker->setMLoc(*MLoc, ValueIDNum::EmptyValue);
      TTracker->clobberMloc(*MLoc, MI.getIterator());
    }
  }
}

// Try to recognise spill and restore instructions that may transfer a value.
if (isLocationSpill(MI, MF, Reg)) {
33
←
Taking false branch→
  Loc = extractSpillBaseRegAndOffset(MI);
  auto ValueID = MTracker->readReg(Reg);

  // If the location is empty, produce a phi, signify it's the live-in value.
  if (ValueID.getLoc() == 0)
    ValueID = {CurBB, 0, MTracker->getRegMLoc(Reg)};

  MTracker->setSpill(*Loc, ValueID);
  auto OptSpillLocIdx = MTracker->getSpillMLoc(*Loc);
  assert(OptSpillLocIdx && "Spill slot set but has no LocIdx?")(static_cast <bool> (OptSpillLocIdx && "Spill slot set but has no LocIdx?"
) ? void (0) : __assert_fail ("OptSpillLocIdx && \"Spill slot set but has no LocIdx?\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 2250, __extension__ __PRETTY_FUNCTION__));
  LocIdx SpillLocIdx = *OptSpillLocIdx;

  // Tell TransferTracker about this spill, produce DBG_VALUEs for it.
  if (TTracker)
    TTracker->transferMlocs(MTracker->getRegMLoc(Reg), SpillLocIdx,
                            MI.getIterator());
} else {
  if (!(Loc = isRestoreInstruction(MI, MF, Reg)))
34
←
Taking true branch→
    return false;
35
←
Returning without writing to 'MI.DebugInstrNum', which participates in a condition later→

  // Is there a value to be restored?
  auto OptValueID = MTracker->readSpill(*Loc);
  if (OptValueID) {
    ValueIDNum ValueID = *OptValueID;
    LocIdx SpillLocIdx = *MTracker->getSpillMLoc(*Loc);
    // XXX -- can we recover sub-registers of this value? Until we can, first
    // overwrite all defs of the register being restored to.
    for (MCRegAliasIterator RAI(Reg, TRI, true); RAI.isValid(); ++RAI)
      MTracker->defReg(*RAI, CurBB, CurInst);

    // Now override the reg we're restoring to.
    MTracker->setReg(Reg, ValueID);

    // Report this restore to the transfer tracker too.
    if (TTracker)
      TTracker->transferMlocs(SpillLocIdx, MTracker->getRegMLoc(Reg),
                              MI.getIterator());
  } else {
    // There isn't anything in the location; not clear if this is a code path
    // that still runs. Def this register anyway just in case.
    for (MCRegAliasIterator RAI(Reg, TRI, true); RAI.isValid(); ++RAI)
      MTracker->defReg(*RAI, CurBB, CurInst);

    // Force the spill slot to be tracked.
    LocIdx L = MTracker->getOrTrackSpillLoc(*Loc);

    // Set the restored value to be a machine phi number, signifying that it's
    // whatever the spills live-in value is in this block. Definitely has
    // a LocIdx due to the setSpill above.
    ValueIDNum ValueID = {CurBB, 0, L};
    MTracker->setReg(Reg, ValueID);
    MTracker->setSpill(*Loc, ValueID);
  }
}
return true;
2296}

2298bool InstrRefBasedLDV::transferRegisterCopy(MachineInstr &MI) {
auto DestSrc = TII->isCopyInstr(MI);
if (!DestSrc)
22
←
Assuming the condition is true→
23
←
Taking true branch→
  return false;
24
←
Returning without writing to 'MI.DebugInstrNum', which participates in a condition later→

const MachineOperand *DestRegOp = DestSrc->Destination;
const MachineOperand *SrcRegOp = DestSrc->Source;

auto isCalleeSavedReg = [&](unsigned Reg) {
  for (MCRegAliasIterator RAI(Reg, TRI, true); RAI.isValid(); ++RAI)
    if (CalleeSavedRegs.test(*RAI))
      return true;
  return false;
};

Register SrcReg = SrcRegOp->getReg();
Register DestReg = DestRegOp->getReg();

// Ignore identity copies. Yep, these make it as far as LiveDebugValues.
if (SrcReg == DestReg)
  return true;

// For emulating VarLocBasedImpl:
// We want to recognize instructions where destination register is callee
// saved register. If register that could be clobbered by the call is
// included, there would be a great chance that it is going to be clobbered
// soon. It is more likely that previous register, which is callee saved, is
// going to stay unclobbered longer, even if it is killed.
//
// For InstrRefBasedImpl, we can track multiple locations per value, so
// ignore this condition.
if (EmulateOldLDV && !isCalleeSavedReg(DestReg))
  return false;

// InstrRefBasedImpl only followed killing copies.
if (EmulateOldLDV && !SrcRegOp->isKill())
  return false;

// Copy MTracker info, including subregs if available.
InstrRefBasedLDV::performCopy(SrcReg, DestReg);

// Only produce a transfer of DBG_VALUE within a block where old LDV
// would have. We might make use of the additional value tracking in some
// other way, later.
if (TTracker && isCalleeSavedReg(DestReg) && SrcRegOp->isKill())
  TTracker->transferMlocs(MTracker->getRegMLoc(SrcReg),
                          MTracker->getRegMLoc(DestReg), MI.getIterator());

// VarLocBasedImpl would quit tracking the old location after copying.
if (EmulateOldLDV && SrcReg != DestReg)
  MTracker->defReg(SrcReg, CurBB, CurInst);

// Finally, the copy might have clobbered variables based on the destination
// register. Tell TTracker about it, in case a backup location exists.
if (TTracker) {
  for (MCRegAliasIterator RAI(DestReg, TRI, true); RAI.isValid(); ++RAI) {
    LocIdx ClobberedLoc = MTracker->getRegMLoc(*RAI);
    TTracker->clobberMloc(ClobberedLoc, MI.getIterator(), false);
  }
}

return true;
2360}

2362/// Accumulate a mapping between each DILocalVariable fragment and other
2363/// fragments of that DILocalVariable which overlap. This reduces work during
2364/// the data-flow stage from "Find any overlapping fragments" to "Check if the
2365/// known-to-overlap fragments are present".
2366/// \param MI A previously unprocessed DEBUG_VALUE instruction to analyze for
2367///           fragment usage.
2368void InstrRefBasedLDV::accumulateFragmentMap(MachineInstr &MI) {
DebugVariable MIVar(MI.getDebugVariable(), MI.getDebugExpression(),
                    MI.getDebugLoc()->getInlinedAt());
FragmentInfo ThisFragment = MIVar.getFragmentOrDefault();

// If this is the first sighting of this variable, then we are guaranteed
// there are currently no overlapping fragments either. Initialize the set
// of seen fragments, record no overlaps for the current one, and return.
auto SeenIt = SeenFragments.find(MIVar.getVariable());
if (SeenIt == SeenFragments.end()) {
  SmallSet<FragmentInfo, 4> OneFragment;
  OneFragment.insert(ThisFragment);
  SeenFragments.insert({MIVar.getVariable(), OneFragment});

  OverlapFragments.insert({{MIVar.getVariable(), ThisFragment}, {}});
  return;
}

// If this particular Variable/Fragment pair already exists in the overlap
// map, it has already been accounted for.
auto IsInOLapMap =
    OverlapFragments.insert({{MIVar.getVariable(), ThisFragment}, {}});
if (!IsInOLapMap.second)
  return;

auto &ThisFragmentsOverlaps = IsInOLapMap.first->second;
auto &AllSeenFragments = SeenIt->second;

// Otherwise, examine all other seen fragments for this variable, with "this"
// fragment being a previously unseen fragment. Record any pair of
// overlapping fragments.
for (auto &ASeenFragment : AllSeenFragments) {
  // Does this previously seen fragment overlap?
  if (DIExpression::fragmentsOverlap(ThisFragment, ASeenFragment)) {
    // Yes: Mark the current fragment as being overlapped.
    ThisFragmentsOverlaps.push_back(ASeenFragment);
    // Mark the previously seen fragment as being overlapped by the current
    // one.
    auto ASeenFragmentsOverlaps =
        OverlapFragments.find({MIVar.getVariable(), ASeenFragment});
    assert(ASeenFragmentsOverlaps != OverlapFragments.end() &&(static_cast <bool> (ASeenFragmentsOverlaps != OverlapFragments
.end() && "Previously seen var fragment has no vector of overlaps"
) ? void (0) : __assert_fail ("ASeenFragmentsOverlaps != OverlapFragments.end() && \"Previously seen var fragment has no vector of overlaps\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 2409, __extension__ __PRETTY_FUNCTION__))
           "Previously seen var fragment has no vector of overlaps")(static_cast <bool> (ASeenFragmentsOverlaps != OverlapFragments
.end() && "Previously seen var fragment has no vector of overlaps"
) ? void (0) : __assert_fail ("ASeenFragmentsOverlaps != OverlapFragments.end() && \"Previously seen var fragment has no vector of overlaps\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 2409, __extension__ __PRETTY_FUNCTION__));
    ASeenFragmentsOverlaps->second.push_back(ThisFragment);
  }
}

AllSeenFragments.insert(ThisFragment);
2415}

2417void InstrRefBasedLDV::process(MachineInstr &MI, ValueIDNum **MLiveOuts,
                             ValueIDNum **MLiveIns) {
// Try to interpret an MI as a debug or transfer instruction. Only if it's
// none of these should we interpret it's register defs as new value
// definitions.
if (transferDebugValue(MI))
10
←
Taking false branch→
54
←
Calling 'InstrRefBasedLDV::transferDebugValue'→
60
←
Returning from 'InstrRefBasedLDV::transferDebugValue'→
61
←
Taking false branch→
  return;
if (transferDebugInstrRef(MI, MLiveOuts, MLiveIns))
11
←
Calling 'InstrRefBasedLDV::transferDebugInstrRef'→
14
←
Returning from 'InstrRefBasedLDV::transferDebugInstrRef'→
15
←
Taking false branch→
62
←
Passing null pointer value via 3rd parameter 'MLiveIns'→
63
←
Calling 'InstrRefBasedLDV::transferDebugInstrRef'→
  return;
if (transferDebugPHI(MI))
16
←
Calling 'InstrRefBasedLDV::transferDebugPHI'→
19
←
Returning from 'InstrRefBasedLDV::transferDebugPHI'→
20
←
Taking false branch→
  return;
if (transferRegisterCopy(MI))
21
←
Calling 'InstrRefBasedLDV::transferRegisterCopy'→
25
←
Returning from 'InstrRefBasedLDV::transferRegisterCopy'→
26
←
Taking false branch→
  return;
if (transferSpillOrRestoreInst(MI))
27
←
Calling 'InstrRefBasedLDV::transferSpillOrRestoreInst'→
36
←
Returning from 'InstrRefBasedLDV::transferSpillOrRestoreInst'→
37
←
Taking false branch→
  return;
transferRegisterDef(MI);
38
←
Calling 'InstrRefBasedLDV::transferRegisterDef'→
46
←
Returning from 'InstrRefBasedLDV::transferRegisterDef'→
2433}
47
←
Returning without writing to 'MI.DebugInstrNum', which participates in a condition later→

2435void InstrRefBasedLDV::produceMLocTransferFunction(
  MachineFunction &MF, SmallVectorImpl<MLocTransferMap> &MLocTransfer,
  unsigned MaxNumBlocks) {
// Because we try to optimize around register mask operands by ignoring regs
// that aren't currently tracked, we set up something ugly for later: RegMask
// operands that are seen earlier than the first use of a register, still need
// to clobber that register in the transfer function. But this information
// isn't actively recorded. Instead, we track each RegMask used in each block,
// and accumulated the clobbered but untracked registers in each block into
// the following bitvector. Later, if new values are tracked, we can add
// appropriate clobbers.
SmallVector<BitVector, 32> BlockMasks;
BlockMasks.resize(MaxNumBlocks);

// Reserve one bit per register for the masks described above.
unsigned BVWords = MachineOperand::getRegMaskSize(TRI->getNumRegs());
for (auto &BV : BlockMasks)
8
←
Assuming '__begin1' is equal to '__end1'→
  BV.resize(TRI->getNumRegs(), true);

// Step through all instructions and inhale the transfer function.
for (auto &MBB : MF) {
  // Object fields that are read by trackers to know where we are in the
  // function.
  CurBB = MBB.getNumber();
  CurInst = 1;

  // Set all machine locations to a PHI value. For transfer function
  // production only, this signifies the live-in value to the block.
  MTracker->reset();
  MTracker->setMPhis(CurBB);

  // Step through each instruction in this block.
  for (auto &MI : MBB) {
    process(MI);
9
←
Calling 'InstrRefBasedLDV::process'→
48
←
Returning from 'InstrRefBasedLDV::process'→
52
←
Passing null pointer value via 3rd parameter 'MLiveIns'→
53
←
Calling 'InstrRefBasedLDV::process'→
    // Also accumulate fragment map.
    if (MI.isDebugValue())
49
←
Taking false branch→
      accumulateFragmentMap(MI);

    // Create a map from the instruction number (if present) to the
    // MachineInstr and its position.
    if (uint64_t InstrNo = MI.peekDebugInstrNum()) {
50
←
Assuming 'InstrNo' is 0→
51
←
Taking false branch→
      auto InstrAndPos = std::make_pair(&MI, CurInst);
      auto InsertResult =
          DebugInstrNumToInstr.insert(std::make_pair(InstrNo, InstrAndPos));

      // There should never be duplicate instruction numbers.
      assert(InsertResult.second)(static_cast <bool> (InsertResult.second) ? void (0) : __assert_fail
 ("InsertResult.second", "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 2481, __extension__ __PRETTY_FUNCTION__));
      (void)InsertResult;
    }

    ++CurInst;
  }

  // Produce the transfer function, a map of machine location to new value. If
  // any machine location has the live-in phi value from the start of the
  // block, it's live-through and doesn't need recording in the transfer
  // function.
  for (auto Location : MTracker->locations()) {
    LocIdx Idx = Location.Idx;
    ValueIDNum &P = Location.Value;
    if (P.isPHI() && P.getLoc() == Idx.asU64())
      continue;

    // Insert-or-update.
    auto &TransferMap = MLocTransfer[CurBB];
    auto Result = TransferMap.insert(std::make_pair(Idx.asU64(), P));
    if (!Result.second)
      Result.first->second = P;
  }

  // Accumulate any bitmask operands into the clobberred reg mask for this
  // block.
  for (auto &P : MTracker->Masks) {
    BlockMasks[CurBB].clearBitsNotInMask(P.first->getRegMask(), BVWords);
  }
}

// Compute a bitvector of all the registers that are tracked in this block.
const TargetLowering *TLI = MF.getSubtarget().getTargetLowering();
Register SP = TLI->getStackPointerRegisterToSaveRestore();
BitVector UsedRegs(TRI->getNumRegs());
for (auto Location : MTracker->locations()) {
  unsigned ID = MTracker->LocIdxToLocID[Location.Idx];
  if (ID >= TRI->getNumRegs() || ID == SP)
    continue;
  UsedRegs.set(ID);
}

// Check that any regmask-clobber of a register that gets tracked, is not
// live-through in the transfer function. It needs to be clobbered at the
// very least.
for (unsigned int I = 0; I < MaxNumBlocks; ++I) {
  BitVector &BV = BlockMasks[I];
  BV.flip();
  BV &= UsedRegs;
  // This produces all the bits that we clobber, but also use. Check that
  // they're all clobbered or at least set in the designated transfer
  // elem.
  for (unsigned Bit : BV.set_bits()) {
    unsigned ID = MTracker->getLocID(Bit, false);
    LocIdx Idx = MTracker->LocIDToLocIdx[ID];
    auto &TransferMap = MLocTransfer[I];

    // Install a value representing the fact that this location is effectively
    // written to in this block. As there's no reserved value, instead use
    // a value number that is never generated. Pick the value number for the
    // first instruction in the block, def'ing this location, which we know
    // this block never used anyway.
    ValueIDNum NotGeneratedNum = ValueIDNum(I, 1, Idx);
    auto Result =
      TransferMap.insert(std::make_pair(Idx.asU64(), NotGeneratedNum));
    if (!Result.second) {
      ValueIDNum &ValueID = Result.first->second;
      if (ValueID.getBlock() == I && ValueID.isPHI())
        // It was left as live-through. Set it to clobbered.
        ValueID = NotGeneratedNum;
    }
  }
}
2554}

2556std::tuple<bool, bool>
2557InstrRefBasedLDV::mlocJoin(MachineBasicBlock &MBB,
                         SmallPtrSet<const MachineBasicBlock *, 16> &Visited,
                         ValueIDNum **OutLocs, ValueIDNum *InLocs) {
LLVM_DEBUG(dbgs() << "join MBB: " << MBB.getNumber() << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("livedebugvalues")) { dbgs() << "join MBB: " << MBB
.getNumber() << "\n"; } } while (false);
bool Changed = false;
bool DowngradeOccurred = false;

// Collect predecessors that have been visited. Anything that hasn't been
// visited yet is a backedge on the first iteration, and the meet of it's
// lattice value for all locations will be unaffected.
SmallVector<const MachineBasicBlock *, 8> BlockOrders;
for (auto Pred : MBB.predecessors()) {
  if (Visited.count(Pred)) {
    BlockOrders.push_back(Pred);
  }
}

// Visit predecessors in RPOT order.
auto Cmp = [&](const MachineBasicBlock *A, const MachineBasicBlock *B) {
  return BBToOrder.find(A)->second < BBToOrder.find(B)->second;
};
llvm::sort(BlockOrders, Cmp);

// Skip entry block.
if (BlockOrders.size() == 0)
  return std::tuple<bool, bool>(false, false);

// Step through all machine locations, then look at each predecessor and
// detect disagreements.
unsigned ThisBlockRPO = BBToOrder.find(&MBB)->second;
for (auto Location : MTracker->locations()) {
  LocIdx Idx = Location.Idx;
  // Pick out the first predecessors live-out value for this location. It's
  // guaranteed to be not a backedge, as we order by RPO.
  ValueIDNum BaseVal = OutLocs[BlockOrders[0]->getNumber()][Idx.asU64()];

  // Some flags for whether there's a disagreement, and whether it's a
  // disagreement with a backedge or not.
  bool Disagree = false;
  bool NonBackEdgeDisagree = false;

  // Loop around everything that wasn't 'base'.
  for (unsigned int I = 1; I < BlockOrders.size(); ++I) {
    auto *MBB = BlockOrders[I];
    if (BaseVal != OutLocs[MBB->getNumber()][Idx.asU64()]) {
      // Live-out of a predecessor disagrees with the first predecessor.
      Disagree = true;

      // Test whether it's a disagreemnt in the backedges or not.
      if (BBToOrder.find(MBB)->second < ThisBlockRPO) // might be self b/e
        NonBackEdgeDisagree = true;
    }
  }

  bool OverRide = false;
  if (Disagree && !NonBackEdgeDisagree) {
    // Only the backedges disagree. Consider demoting the livein
    // lattice value, as per the file level comment. The value we consider
    // demoting to is the value that the non-backedge predecessors agree on.
    // The order of values is that non-PHIs are \top, a PHI at this block
    // \bot, and phis between the two are ordered by their RPO number.
    // If there's no agreement, or we've already demoted to this PHI value
    // before, replace with a PHI value at this block.

    // Calculate order numbers: zero means normal def, nonzero means RPO
    // number.
    unsigned BaseBlockRPONum = BBNumToRPO[BaseVal.getBlock()] + 1;
    if (!BaseVal.isPHI())
      BaseBlockRPONum = 0;

    ValueIDNum &InLocID = InLocs[Idx.asU64()];
    unsigned InLocRPONum = BBNumToRPO[InLocID.getBlock()] + 1;
    if (!InLocID.isPHI())
      InLocRPONum = 0;

    // Should we ignore the disagreeing backedges, and override with the
    // value the other predecessors agree on (in "base")?
    unsigned ThisBlockRPONum = BBNumToRPO[MBB.getNumber()] + 1;
    if (BaseBlockRPONum > InLocRPONum && BaseBlockRPONum < ThisBlockRPONum) {
      // Override.
      OverRide = true;
      DowngradeOccurred = true;
    }
  }
  // else: if we disagree in the non-backedges, then this is definitely
  // a control flow merge where different values merge. Make it a PHI.

  // Generate a phi...
  ValueIDNum PHI = {(uint64_t)MBB.getNumber(), 0, Idx};
  ValueIDNum NewVal = (Disagree && !OverRide) ? PHI : BaseVal;
  if (InLocs[Idx.asU64()] != NewVal) {
    Changed |= true;
    InLocs[Idx.asU64()] = NewVal;
  }
}

// TODO: Reimplement NumInserted and NumRemoved.
return std::tuple<bool, bool>(Changed, DowngradeOccurred);
2655}

2657void InstrRefBasedLDV::mlocDataflow(
  ValueIDNum **MInLocs, ValueIDNum **MOutLocs,
  SmallVectorImpl<MLocTransferMap> &MLocTransfer) {
std::priority_queue<unsigned int, std::vector<unsigned int>,
                    std::greater<unsigned int>>
    Worklist, Pending;

// We track what is on the current and pending worklist to avoid inserting
// the same thing twice. We could avoid this with a custom priority queue,
// but this is probably not worth it.
SmallPtrSet<MachineBasicBlock *, 16> OnPending, OnWorklist;

// Initialize worklist with every block to be visited.
for (unsigned int I = 0; I < BBToOrder.size(); ++I) {
  Worklist.push(I);
  OnWorklist.insert(OrderToBB[I]);
}

MTracker->reset();

// Set inlocs for entry block -- each as a PHI at the entry block. Represents
// the incoming value to the function.
MTracker->setMPhis(0);
for (auto Location : MTracker->locations())
  MInLocs[0][Location.Idx.asU64()] = Location.Value;

SmallPtrSet<const MachineBasicBlock *, 16> Visited;
while (!Worklist.empty() || !Pending.empty()) {
  // Vector for storing the evaluated block transfer function.
  SmallVector<std::pair<LocIdx, ValueIDNum>, 32> ToRemap;

  while (!Worklist.empty()) {
    MachineBasicBlock *MBB = OrderToBB[Worklist.top()];
    CurBB = MBB->getNumber();
    Worklist.pop();

    // Join the values in all predecessor blocks.
    bool InLocsChanged, DowngradeOccurred;
    std::tie(InLocsChanged, DowngradeOccurred) =
        mlocJoin(*MBB, Visited, MOutLocs, MInLocs[CurBB]);
    InLocsChanged |= Visited.insert(MBB).second;

    // If a downgrade occurred, book us in for re-examination on the next
    // iteration.
    if (DowngradeOccurred && OnPending.insert(MBB).second)
      Pending.push(BBToOrder[MBB]);

    // Don't examine transfer function if we've visited this loc at least
    // once, and inlocs haven't changed.
    if (!InLocsChanged)
      continue;

    // Load the current set of live-ins into MLocTracker.
    MTracker->loadFromArray(MInLocs[CurBB], CurBB);

    // Each element of the transfer function can be a new def, or a read of
    // a live-in value. Evaluate each element, and store to "ToRemap".
    ToRemap.clear();
    for (auto &P : MLocTransfer[CurBB]) {
      if (P.second.getBlock() == CurBB && P.second.isPHI()) {
        // This is a movement of whatever was live in. Read it.
        ValueIDNum NewID = MTracker->getNumAtPos(P.second.getLoc());
        ToRemap.push_back(std::make_pair(P.first, NewID));
      } else {
        // It's a def. Just set it.
        assert(P.second.getBlock() == CurBB)(static_cast <bool> (P.second.getBlock() == CurBB) ? void
 (0) : __assert_fail ("P.second.getBlock() == CurBB", "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 2722, __extension__ __PRETTY_FUNCTION__));
        ToRemap.push_back(std::make_pair(P.first, P.second));
      }
    }

    // Commit the transfer function changes into mloc tracker, which
    // transforms the contents of the MLocTracker into the live-outs.
    for (auto &P : ToRemap)
      MTracker->setMLoc(P.first, P.second);

    // Now copy out-locs from mloc tracker into out-loc vector, checking
    // whether changes have occurred. These changes can have come from both
    // the transfer function, and mlocJoin.
    bool OLChanged = false;
    for (auto Location : MTracker->locations()) {
      OLChanged |= MOutLocs[CurBB][Location.Idx.asU64()] != Location.Value;
      MOutLocs[CurBB][Location.Idx.asU64()] = Location.Value;
    }

    MTracker->reset();

    // No need to examine successors again if out-locs didn't change.
    if (!OLChanged)
      continue;

    // All successors should be visited: put any back-edges on the pending
    // list for the next dataflow iteration, and any other successors to be
    // visited this iteration, if they're not going to be already.
    for (auto s : MBB->successors()) {
      // Does branching to this successor represent a back-edge?
      if (BBToOrder[s] > BBToOrder[MBB]) {
        // No: visit it during this dataflow iteration.
        if (OnWorklist.insert(s).second)
          Worklist.push(BBToOrder[s]);
      } else {
        // Yes: visit it on the next iteration.
        if (OnPending.insert(s).second)
          Pending.push(BBToOrder[s]);
      }
    }
  }

  Worklist.swap(Pending);
  std::swap(OnPending, OnWorklist);
  OnPending.clear();
  // At this point, pending must be empty, since it was just the empty
  // worklist
  assert(Pending.empty() && "Pending should be empty")(static_cast <bool> (Pending.empty() && "Pending should be empty"
) ? void (0) : __assert_fail ("Pending.empty() && \"Pending should be empty\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 2769, __extension__ __PRETTY_FUNCTION__));
}

// Once all the live-ins don't change on mlocJoin(), we've reached a
// fixedpoint.
2774}

2776bool InstrRefBasedLDV::vlocDowngradeLattice(
  const MachineBasicBlock &MBB, const DbgValue &OldLiveInLocation,
  const SmallVectorImpl<InValueT> &Values, unsigned CurBlockRPONum) {
// Ranking value preference: see file level comment, the highest rank is
// a plain def, followed by PHI values in reverse post-order. Numerically,
// we assign all defs the rank '0', all PHIs their blocks RPO number plus
// one, and consider the lowest value the highest ranked.
int OldLiveInRank = BBNumToRPO[OldLiveInLocation.ID.getBlock()] + 1;
if (!OldLiveInLocation.ID.isPHI())
  OldLiveInRank = 0;

// Allow any unresolvable conflict to be over-ridden.
if (OldLiveInLocation.Kind == DbgValue::NoVal) {
  // Although if it was an unresolvable conflict from _this_ block, then
  // all other seeking of downgrades and PHIs must have failed before hand.
  if (OldLiveInLocation.BlockNo == (unsigned)MBB.getNumber())
    return false;
  OldLiveInRank = INT_MIN(-2147483647 -1);
}

auto &InValue = *Values[0].second;

if (InValue.Kind == DbgValue::Const || InValue.Kind == DbgValue::NoVal)
  return false;

unsigned ThisRPO = BBNumToRPO[InValue.ID.getBlock()];
int ThisRank = ThisRPO + 1;
if (!InValue.ID.isPHI())
  ThisRank = 0;

// Too far down the lattice?
if (ThisRPO >= CurBlockRPONum)
  return false;

// Higher in the lattice than what we've already explored?
if (ThisRank <= OldLiveInRank)
  return false;

return true;
2815}

2817std::tuple<Optional<ValueIDNum>, bool> InstrRefBasedLDV::pickVPHILoc(
  MachineBasicBlock &MBB, const DebugVariable &Var, const LiveIdxT &LiveOuts,
  ValueIDNum **MOutLocs, ValueIDNum **MInLocs,
  const SmallVectorImpl<MachineBasicBlock *> &BlockOrders) {
// Collect a set of locations from predecessor where its live-out value can
// be found.
SmallVector<SmallVector<LocIdx, 4>, 8> Locs;
unsigned NumLocs = MTracker->getNumLocs();
unsigned BackEdgesStart = 0;

for (auto p : BlockOrders) {
  // Pick out where backedges start in the list of predecessors. Relies on
  // BlockOrders being sorted by RPO.
  if (BBToOrder[p] < BBToOrder[&MBB])
    ++BackEdgesStart;

  // For each predecessor, create a new set of locations.
  Locs.resize(Locs.size() + 1);
  unsigned ThisBBNum = p->getNumber();
  auto LiveOutMap = LiveOuts.find(p);
  if (LiveOutMap == LiveOuts.end())
    // This predecessor isn't in scope, it must have no live-in/live-out
    // locations.
    continue;

  auto It = LiveOutMap->second->find(Var);
  if (It == LiveOutMap->second->end())
    // There's no value recorded for this variable in this predecessor,
    // leave an empty set of locations.
    continue;

  const DbgValue &OutVal = It->second;

  if (OutVal.Kind == DbgValue::Const || OutVal.Kind == DbgValue::NoVal)
    // Consts and no-values cannot have locations we can join on.
    continue;

  assert(OutVal.Kind == DbgValue::Proposed || OutVal.Kind == DbgValue::Def)(static_cast <bool> (OutVal.Kind == DbgValue::Proposed ||
 OutVal.Kind == DbgValue::Def) ? void (0) : __assert_fail ("OutVal.Kind == DbgValue::Proposed || OutVal.Kind == DbgValue::Def"
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 2854, __extension__ __PRETTY_FUNCTION__));
  ValueIDNum ValToLookFor = OutVal.ID;

  // Search the live-outs of the predecessor for the specified value.
  for (unsigned int I = 0; I < NumLocs; ++I) {
    if (MOutLocs[ThisBBNum][I] == ValToLookFor)
      Locs.back().push_back(LocIdx(I));
  }
}

// If there were no locations at all, return an empty result.
if (Locs.empty())
  return std::tuple<Optional<ValueIDNum>, bool>(None, false);

// Lambda for seeking a common location within a range of location-sets.
using LocsIt = SmallVector<SmallVector<LocIdx, 4>, 8>::iterator;
auto SeekLocation =
    [&Locs](llvm::iterator_range<LocsIt> SearchRange) -> Optional<LocIdx> {
  // Starting with the first set of locations, take the intersection with
  // subsequent sets.
  SmallVector<LocIdx, 4> base = Locs[0];
  for (auto &S : SearchRange) {
    SmallVector<LocIdx, 4> new_base;
    std::set_intersection(base.begin(), base.end(), S.begin(), S.end(),
                          std::inserter(new_base, new_base.begin()));
    base = new_base;
  }
  if (base.empty())
    return None;

  // We now have a set of LocIdxes that contain the right output value in
  // each of the predecessors. Pick the lowest; if there's a register loc,
  // that'll be it.
  return *base.begin();
};

// Search for a common location for all predecessors. If we can't, then fall
// back to only finding a common location between non-backedge predecessors.
bool ValidForAllLocs = true;
auto TheLoc = SeekLocation(Locs);
if (!TheLoc) {
  ValidForAllLocs = false;
  TheLoc =
      SeekLocation(make_range(Locs.begin(), Locs.begin() + BackEdgesStart));
}

if (!TheLoc)
  return std::tuple<Optional<ValueIDNum>, bool>(None, false);

// Return a PHI-value-number for the found location.
LocIdx L = *TheLoc;
ValueIDNum PHIVal = {(unsigned)MBB.getNumber(), 0, L};
return std::tuple<Optional<ValueIDNum>, bool>(PHIVal, ValidForAllLocs);
2907}

2909std::tuple<bool, bool> InstrRefBasedLDV::vlocJoin(
  MachineBasicBlock &MBB, LiveIdxT &VLOCOutLocs, LiveIdxT &VLOCInLocs,
  SmallPtrSet<const MachineBasicBlock *, 16> *VLOCVisited, unsigned BBNum,
  const SmallSet<DebugVariable, 4> &AllVars, ValueIDNum **MOutLocs,
  ValueIDNum **MInLocs,
  SmallPtrSet<const MachineBasicBlock *, 8> &InScopeBlocks,
  SmallPtrSet<const MachineBasicBlock *, 8> &BlocksToExplore,
  DenseMap<DebugVariable, DbgValue> &InLocsT) {
bool DowngradeOccurred = false;

// To emulate VarLocBasedImpl, process this block if it's not in scope but
// _does_ assign a variable value. No live-ins for this scope are transferred
// in though, so we can return immediately.
if (InScopeBlocks.count(&MBB) == 0 && !ArtificialBlocks.count(&MBB)) {
  if (VLOCVisited)
    return std::tuple<bool, bool>(true, false);
  return std::tuple<bool, bool>(false, false);
}

LLVM_DEBUG(dbgs() << "join MBB: " << MBB.getNumber() << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("livedebugvalues")) { dbgs() << "join MBB: " << MBB
.getNumber() << "\n"; } } while (false);
bool Changed = false;

// Find any live-ins computed in a prior iteration.
auto ILSIt = VLOCInLocs.find(&MBB);
assert(ILSIt != VLOCInLocs.end())(static_cast <bool> (ILSIt != VLOCInLocs.end()) ? void (
0) : __assert_fail ("ILSIt != VLOCInLocs.end()", "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 2933, __extension__ __PRETTY_FUNCTION__));
auto &ILS = *ILSIt->second;

// Order predecessors by RPOT order, for exploring them in that order.
SmallVector<MachineBasicBlock *, 8> BlockOrders(MBB.predecessors());

auto Cmp = [&](MachineBasicBlock *A, MachineBasicBlock *B) {
  return BBToOrder[A] < BBToOrder[B];
};

llvm::sort(BlockOrders, Cmp);

unsigned CurBlockRPONum = BBToOrder[&MBB];

// Force a re-visit to loop heads in the first dataflow iteration.
// FIXME: if we could "propose" Const values this wouldn't be needed,
// because they'd need to be confirmed before being emitted.
if (!BlockOrders.empty() &&
    BBToOrder[BlockOrders[BlockOrders.size() - 1]] >= CurBlockRPONum &&
    VLOCVisited)
  DowngradeOccurred = true;

auto ConfirmValue = [&InLocsT](const DebugVariable &DV, DbgValue VR) {
  auto Result = InLocsT.insert(std::make_pair(DV, VR));
  (void)Result;
  assert(Result.second)(static_cast <bool> (Result.second) ? void (0) : __assert_fail
 ("Result.second", "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 2958, __extension__ __PRETTY_FUNCTION__));
};

auto ConfirmNoVal = [&ConfirmValue, &MBB](const DebugVariable &Var, const DbgValueProperties &Properties) {
  DbgValue NoLocPHIVal(MBB.getNumber(), Properties, DbgValue::NoVal);

  ConfirmValue(Var, NoLocPHIVal);
};

// Attempt to join the values for each variable.
for (auto &Var : AllVars) {
  // Collect all the DbgValues for this variable.
  SmallVector<InValueT, 8> Values;
  bool Bail = false;
  unsigned BackEdgesStart = 0;
  for (auto p : BlockOrders) {
    // If the predecessor isn't in scope / to be explored, we'll never be
    // able to join any locations.
    if (!BlocksToExplore.contains(p)) {
      Bail = true;
      break;
    }

    // Don't attempt to handle unvisited predecessors: they're implicitly
    // "unknown"s in the lattice.
    if (VLOCVisited && !VLOCVisited->count(p))
      continue;

    // If the predecessors OutLocs is absent, there's not much we can do.
    auto OL = VLOCOutLocs.find(p);
    if (OL == VLOCOutLocs.end()) {
      Bail = true;
      break;
    }

    // No live-out value for this predecessor also means we can't produce
    // a joined value.
    auto VIt = OL->second->find(Var);
    if (VIt == OL->second->end()) {
      Bail = true;
      break;
    }

    // Keep track of where back-edges begin in the Values vector. Relies on
    // BlockOrders being sorted by RPO.
    unsigned ThisBBRPONum = BBToOrder[p];
    if (ThisBBRPONum < CurBlockRPONum)
      ++BackEdgesStart;

    Values.push_back(std::make_pair(p, &VIt->second));
  }

  // If there were no values, or one of the predecessors couldn't have a
  // value, then give up immediately. It's not safe to produce a live-in
  // value.
  if (Bail || Values.size() == 0)
    continue;

  // Enumeration identifying the current state of the predecessors values.
  enum {
    Unset = 0,
    Agreed,       // All preds agree on the variable value.
    PropDisagree, // All preds agree, but the value kind is Proposed in some.
    BEDisagree,   // Only back-edges disagree on variable value.
    PHINeeded,    // Non-back-edge predecessors have conflicing values.
    NoSolution    // Conflicting Value metadata makes solution impossible.
  } OurState = Unset;

  // All (non-entry) blocks have at least one non-backedge predecessor.
  // Pick the variable value from the first of these, to compare against
  // all others.
  const DbgValue &FirstVal = *Values[0].second;
  const ValueIDNum &FirstID = FirstVal.ID;

  // Scan for variable values that can't be resolved: if they have different
  // DIExpressions, different indirectness, or are mixed constants /
  // non-constants.
  for (auto &V : Values) {
    if (V.second->Properties != FirstVal.Properties)
      OurState = NoSolution;
    if (V.second->Kind == DbgValue::Const && FirstVal.Kind != DbgValue::Const)
      OurState = NoSolution;
  }

  // Flags diagnosing _how_ the values disagree.
  bool NonBackEdgeDisagree = false;
  bool DisagreeOnPHINess = false;
  bool IDDisagree = false;
  bool Disagree = false;
  if (OurState == Unset) {
    for (auto &V : Values) {
      if (*V.second == FirstVal)
        continue; // No disagreement.

      Disagree = true;

      // Flag whether the value number actually diagrees.
      if (V.second->ID != FirstID)
        IDDisagree = true;

      // Distinguish whether disagreement happens in backedges or not.
      // Relies on Values (and BlockOrders) being sorted by RPO.
      unsigned ThisBBRPONum = BBToOrder[V.first];
      if (ThisBBRPONum < CurBlockRPONum)
        NonBackEdgeDisagree = true;

      // Is there a difference in whether the value is definite or only
      // proposed?
      if (V.second->Kind != FirstVal.Kind &&
          (V.second->Kind == DbgValue::Proposed ||
           V.second->Kind == DbgValue::Def) &&
          (FirstVal.Kind == DbgValue::Proposed ||
           FirstVal.Kind == DbgValue::Def))
        DisagreeOnPHINess = true;
    }

    // Collect those flags together and determine an overall state for
    // what extend the predecessors agree on a live-in value.
    if (!Disagree)
      OurState = Agreed;
    else if (!IDDisagree && DisagreeOnPHINess)
      OurState = PropDisagree;
    else if (!NonBackEdgeDisagree)
      OurState = BEDisagree;
    else
      OurState = PHINeeded;
  }

  // An extra indicator: if we only disagree on whether the value is a
  // Def, or proposed, then also flag whether that disagreement happens
  // in backedges only.
  bool PropOnlyInBEs = Disagree && !IDDisagree && DisagreeOnPHINess &&
                       !NonBackEdgeDisagree && FirstVal.Kind == DbgValue::Def;

  const auto &Properties = FirstVal.Properties;

  auto OldLiveInIt = ILS.find(Var);
  const DbgValue *OldLiveInLocation =
      (OldLiveInIt != ILS.end()) ? &OldLiveInIt->second : nullptr;

  bool OverRide = false;
  if (OurState == BEDisagree && OldLiveInLocation) {
    // Only backedges disagree: we can consider downgrading. If there was a
    // previous live-in value, use it to work out whether the current
    // incoming value represents a lattice downgrade or not.
    OverRide =
        vlocDowngradeLattice(MBB, *OldLiveInLocation, Values, CurBlockRPONum);
  }

  // Use the current state of predecessor agreement and other flags to work
  // out what to do next. Possibilities include:
  //  * Accept a value all predecessors agree on, or accept one that
  //    represents a step down the exploration lattice,
  //  * Use a PHI value number, if one can be found,
  //  * Propose a PHI value number, and see if it gets confirmed later,
  //  * Emit a 'NoVal' value, indicating we couldn't resolve anything.
  if (OurState == Agreed) {
    // Easiest solution: all predecessors agree on the variable value.
    ConfirmValue(Var, FirstVal);
  } else if (OurState == BEDisagree && OverRide) {
    // Only backedges disagree, and the other predecessors have produced
    // a new live-in value further down the exploration lattice.
    DowngradeOccurred = true;
    ConfirmValue(Var, FirstVal);
  } else if (OurState == PropDisagree) {
    // Predecessors agree on value, but some say it's only a proposed value.
    // Propagate it as proposed: unless it was proposed in this block, in
    // which case we're able to confirm the value.
    if (FirstID.getBlock() == (uint64_t)MBB.getNumber() && FirstID.isPHI()) {
      ConfirmValue(Var, DbgValue(FirstID, Properties, DbgValue::Def));
    } else if (PropOnlyInBEs) {
      // If only backedges disagree, a higher (in RPO) block confirmed this
      // location, and we need to propagate it into this loop.
      ConfirmValue(Var, DbgValue(FirstID, Properties, DbgValue::Def));
    } else {
      // Otherwise; a Def meeting a Proposed is still a Proposed.
      ConfirmValue(Var, DbgValue(FirstID, Properties, DbgValue::Proposed));
    }
  } else if ((OurState == PHINeeded || OurState == BEDisagree)) {
    // Predecessors disagree and can't be downgraded: this can only be
    // solved with a PHI. Use pickVPHILoc to go look for one.
    Optional<ValueIDNum> VPHI;
    bool AllEdgesVPHI = false;
    std::tie(VPHI, AllEdgesVPHI) =
        pickVPHILoc(MBB, Var, VLOCOutLocs, MOutLocs, MInLocs, BlockOrders);

    if (VPHI && AllEdgesVPHI) {
      // There's a PHI value that's valid for all predecessors -- we can use
      // it. If any of the non-backedge predecessors have proposed values
      // though, this PHI is also only proposed, until the predecessors are
      // confirmed.
      DbgValue::KindT K = DbgValue::Def;
      for (unsigned int I = 0; I < BackEdgesStart; ++I)
        if (Values[I].second->Kind == DbgValue::Proposed)
          K = DbgValue::Proposed;

      ConfirmValue(Var, DbgValue(*VPHI, Properties, K));
    } else if (VPHI) {
      // There's a PHI value, but it's only legal for backedges. Leave this
      // as a proposed PHI value: it might come back on the backedges,
      // and allow us to confirm it in the future.
      DbgValue NoBEValue = DbgValue(*VPHI, Properties, DbgValue::Proposed);
      ConfirmValue(Var, NoBEValue);
    } else {
      ConfirmNoVal(Var, Properties);
    }
  } else {
    // Otherwise: we don't know. Emit a "phi but no real loc" phi.
    ConfirmNoVal(Var, Properties);
  }
}

// Store newly calculated in-locs into VLOCInLocs, if they've changed.
Changed = ILS != InLocsT;
if (Changed)
  ILS = InLocsT;

return std::tuple<bool, bool>(Changed, DowngradeOccurred);
3176}

3178void InstrRefBasedLDV::vlocDataflow(
  const LexicalScope *Scope, const DILocation *DILoc,
  const SmallSet<DebugVariable, 4> &VarsWeCareAbout,
  SmallPtrSetImpl<MachineBasicBlock *> &AssignBlocks, LiveInsT &Output,
  ValueIDNum **MOutLocs, ValueIDNum **MInLocs,
  SmallVectorImpl<VLocTracker> &AllTheVLocs) {
// This method is much like mlocDataflow: but focuses on a single
// LexicalScope at a time. Pick out a set of blocks and variables that are
// to have their value assignments solved, then run our dataflow algorithm
// until a fixedpoint is reached.
std::priority_queue<unsigned int, std::vector<unsigned int>,
                    std::greater<unsigned int>>
    Worklist, Pending;
SmallPtrSet<MachineBasicBlock *, 16> OnWorklist, OnPending;

// The set of blocks we'll be examining.
SmallPtrSet<const MachineBasicBlock *, 8> BlocksToExplore;

// The order in which to examine them (RPO).
SmallVector<MachineBasicBlock *, 8> BlockOrders;

// RPO ordering function.
auto Cmp = [&](MachineBasicBlock *A, MachineBasicBlock *B) {
  return BBToOrder[A] < BBToOrder[B];
};

LS.getMachineBasicBlocks(DILoc, BlocksToExplore);

// A separate container to distinguish "blocks we're exploring" versus
// "blocks that are potentially in scope. See comment at start of vlocJoin.
SmallPtrSet<const MachineBasicBlock *, 8> InScopeBlocks = BlocksToExplore;

// Old LiveDebugValues tracks variable locations that come out of blocks
// not in scope, where DBG_VALUEs occur. This is something we could
// legitimately ignore, but lets allow it for now.
if (EmulateOldLDV)
  BlocksToExplore.insert(AssignBlocks.begin(), AssignBlocks.end());

// We also need to propagate variable values through any artificial blocks
// that immediately follow blocks in scope.
DenseSet<const MachineBasicBlock *> ToAdd;

// Helper lambda: For a given block in scope, perform a depth first search
// of all the artificial successors, adding them to the ToAdd collection.
auto AccumulateArtificialBlocks =
    [this, &ToAdd, &BlocksToExplore,
     &InScopeBlocks](const MachineBasicBlock *MBB) {
      // Depth-first-search state: each node is a block and which successor
      // we're currently exploring.
      SmallVector<std::pair<const MachineBasicBlock *,
                            MachineBasicBlock::const_succ_iterator>,
                  8>
          DFS;

      // Find any artificial successors not already tracked.
      for (auto *succ : MBB->successors()) {
        if (BlocksToExplore.count(succ) || InScopeBlocks.count(succ))
          continue;
        if (!ArtificialBlocks.count(succ))
          continue;
        DFS.push_back(std::make_pair(succ, succ->succ_begin()));
        ToAdd.insert(succ);
      }

      // Search all those blocks, depth first.
      while (!DFS.empty()) {
        const MachineBasicBlock *CurBB = DFS.back().first;
        MachineBasicBlock::const_succ_iterator &CurSucc = DFS.back().second;
        // Walk back if we've explored this blocks successors to the end.
        if (CurSucc == CurBB->succ_end()) {
          DFS.pop_back();
          continue;
        }

        // If the current successor is artificial and unexplored, descend into
        // it.
        if (!ToAdd.count(*CurSucc) && ArtificialBlocks.count(*CurSucc)) {
          DFS.push_back(std::make_pair(*CurSucc, (*CurSucc)->succ_begin()));
          ToAdd.insert(*CurSucc);
          continue;
        }

        ++CurSucc;
      }
    };

// Search in-scope blocks and those containing a DBG_VALUE from this scope
// for artificial successors.
for (auto *MBB : BlocksToExplore)
  AccumulateArtificialBlocks(MBB);
for (auto *MBB : InScopeBlocks)
  AccumulateArtificialBlocks(MBB);

BlocksToExplore.insert(ToAdd.begin(), ToAdd.end());
InScopeBlocks.insert(ToAdd.begin(), ToAdd.end());

// Single block scope: not interesting! No propagation at all. Note that
// this could probably go above ArtificialBlocks without damage, but
// that then produces output differences from original-live-debug-values,
// which propagates from a single block into many artificial ones.
if (BlocksToExplore.size() == 1)
  return;

// Picks out relevants blocks RPO order and sort them.
for (auto *MBB : BlocksToExplore)
  BlockOrders.push_back(const_cast<MachineBasicBlock *>(MBB));

llvm::sort(BlockOrders, Cmp);
unsigned NumBlocks = BlockOrders.size();

// Allocate some vectors for storing the live ins and live outs. Large.
SmallVector<DenseMap<DebugVariable, DbgValue>, 32> LiveIns, LiveOuts;
LiveIns.resize(NumBlocks);
LiveOuts.resize(NumBlocks);

// Produce by-MBB indexes of live-in/live-outs, to ease lookup within
// vlocJoin.
LiveIdxT LiveOutIdx, LiveInIdx;
LiveOutIdx.reserve(NumBlocks);
LiveInIdx.reserve(NumBlocks);
for (unsigned I = 0; I < NumBlocks; ++I) {
  LiveOutIdx[BlockOrders[I]] = &LiveOuts[I];
  LiveInIdx[BlockOrders[I]] = &LiveIns[I];
}

for (auto *MBB : BlockOrders) {
  Worklist.push(BBToOrder[MBB]);
  OnWorklist.insert(MBB);
}

// Iterate over all the blocks we selected, propagating variable values.
bool FirstTrip = true;
SmallPtrSet<const MachineBasicBlock *, 16> VLOCVisited;
while (!Worklist.empty() || !Pending.empty()) {
  while (!Worklist.empty()) {
    auto *MBB = OrderToBB[Worklist.top()];
    CurBB = MBB->getNumber();
    Worklist.pop();

    DenseMap<DebugVariable, DbgValue> JoinedInLocs;

    // Join values from predecessors. Updates LiveInIdx, and writes output
    // into JoinedInLocs.
    bool InLocsChanged, DowngradeOccurred;
    std::tie(InLocsChanged, DowngradeOccurred) = vlocJoin(
        *MBB, LiveOutIdx, LiveInIdx, (FirstTrip) ? &VLOCVisited : nullptr,
        CurBB, VarsWeCareAbout, MOutLocs, MInLocs, InScopeBlocks,
        BlocksToExplore, JoinedInLocs);

    bool FirstVisit = VLOCVisited.insert(MBB).second;

    // Always explore transfer function if inlocs changed, or if we've not
    // visited this block before.
    InLocsChanged |= FirstVisit;

    // If a downgrade occurred, book us in for re-examination on the next
    // iteration.
    if (DowngradeOccurred && OnPending.insert(MBB).second)
      Pending.push(BBToOrder[MBB]);

    if (!InLocsChanged)
      continue;

    // Do transfer function.
    auto &VTracker = AllTheVLocs[MBB->getNumber()];
    for (auto &Transfer : VTracker.Vars) {
      // Is this var we're mangling in this scope?
      if (VarsWeCareAbout.count(Transfer.first)) {
        // Erase on empty transfer (DBG_VALUE $noreg).
        if (Transfer.second.Kind == DbgValue::Undef) {
          JoinedInLocs.erase(Transfer.first);
        } else {
          // Insert new variable value; or overwrite.
          auto NewValuePair = std::make_pair(Transfer.first, Transfer.second);
          auto Result = JoinedInLocs.insert(NewValuePair);
          if (!Result.second)
            Result.first->second = Transfer.second;
        }
      }
    }

    // Did the live-out locations change?
    bool OLChanged = JoinedInLocs != *LiveOutIdx[MBB];

    // If they haven't changed, there's no need to explore further.
    if (!OLChanged)
      continue;

    // Commit to the live-out record.
    *LiveOutIdx[MBB] = JoinedInLocs;

    // We should visit all successors. Ensure we'll visit any non-backedge
    // successors during this dataflow iteration; book backedge successors
    // to be visited next time around.
    for (auto s : MBB->successors()) {
      // Ignore out of scope / not-to-be-explored successors.
      if (LiveInIdx.find(s) == LiveInIdx.end())
        continue;

      if (BBToOrder[s] > BBToOrder[MBB]) {
        if (OnWorklist.insert(s).second)
          Worklist.push(BBToOrder[s]);
      } else if (OnPending.insert(s).second && (FirstTrip || OLChanged)) {
        Pending.push(BBToOrder[s]);
      }
    }
  }
  Worklist.swap(Pending);
  std::swap(OnWorklist, OnPending);
  OnPending.clear();
  assert(Pending.empty())(static_cast <bool> (Pending.empty()) ? void (0) : __assert_fail
 ("Pending.empty()", "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 3388, __extension__ __PRETTY_FUNCTION__));
  FirstTrip = false;
}

// Dataflow done. Now what? Save live-ins. Ignore any that are still marked
// as being variable-PHIs, because those did not have their machine-PHI
// value confirmed. Such variable values are places that could have been
// PHIs, but are not.
for (auto *MBB : BlockOrders) {
  auto &VarMap = *LiveInIdx[MBB];
  for (auto &P : VarMap) {
    if (P.second.Kind == DbgValue::Proposed ||
        P.second.Kind == DbgValue::NoVal)
      continue;
    Output[MBB->getNumber()].push_back(P);
  }
}

BlockOrders.clear();
BlocksToExplore.clear();
3408}

3410#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
3411void InstrRefBasedLDV::dump_mloc_transfer(
  const MLocTransferMap &mloc_transfer) const {
for (auto &P : mloc_transfer) {
  std::string foo = MTracker->LocIdxToName(P.first);
  std::string bar = MTracker->IDAsString(P.second);
  dbgs() << "Loc " << foo << " --> " << bar << "\n";
}
3418}
3419#endif

3421void InstrRefBasedLDV::emitLocations(
  MachineFunction &MF, LiveInsT SavedLiveIns, ValueIDNum **MOutLocs,
  ValueIDNum **MInLocs, DenseMap<DebugVariable, unsigned> &AllVarsNumbering,
  const TargetPassConfig &TPC) {
TTracker = new TransferTracker(TII, MTracker, MF, *TRI, CalleeSavedRegs, TPC);
unsigned NumLocs = MTracker->getNumLocs();

// For each block, load in the machine value locations and variable value
// live-ins, then step through each instruction in the block. New DBG_VALUEs
// to be inserted will be created along the way.
for (MachineBasicBlock &MBB : MF) {
  unsigned bbnum = MBB.getNumber();
  MTracker->reset();
  MTracker->loadFromArray(MInLocs[bbnum], bbnum);
  TTracker->loadInlocs(MBB, MInLocs[bbnum], SavedLiveIns[MBB.getNumber()],
                       NumLocs);

  CurBB = bbnum;
  CurInst = 1;
  for (auto &MI : MBB) {
    process(MI, MOutLocs, MInLocs);
    TTracker->checkInstForNewValues(CurInst, MI.getIterator());
    ++CurInst;
  }
}

// We have to insert DBG_VALUEs in a consistent order, otherwise they appeaer
// in DWARF in different orders. Use the order that they appear when walking
// through each block / each instruction, stored in AllVarsNumbering.
auto OrderDbgValues = [&](const MachineInstr *A,
                          const MachineInstr *B) -> bool {
  DebugVariable VarA(A->getDebugVariable(), A->getDebugExpression(),
                     A->getDebugLoc()->getInlinedAt());
  DebugVariable VarB(B->getDebugVariable(), B->getDebugExpression(),
                     B->getDebugLoc()->getInlinedAt());
  return AllVarsNumbering.find(VarA)->second <
         AllVarsNumbering.find(VarB)->second;
};

// Go through all the transfers recorded in the TransferTracker -- this is
// both the live-ins to a block, and any movements of values that happen
// in the middle.
for (auto &P : TTracker->Transfers) {
  // Sort them according to appearance order.
  llvm::sort(P.Insts, OrderDbgValues);
  // Insert either before or after the designated point...
  if (P.MBB) {
    MachineBasicBlock &MBB = *P.MBB;
    for (auto *MI : P.Insts) {
      MBB.insert(P.Pos, MI);
    }
  } else {
    // Terminators, like tail calls, can clobber things. Don't try and place
    // transfers after them.
    if (P.Pos->isTerminator())
      continue;

    MachineBasicBlock &MBB = *P.Pos->getParent();
    for (auto *MI : P.Insts) {
      MBB.insertAfterBundle(P.Pos, MI);
    }
  }
}
3484}

3486void InstrRefBasedLDV::initialSetup(MachineFunction &MF) {
// Build some useful data structures.
auto hasNonArtificialLocation = [](const MachineInstr &MI) -> bool {
  if (const DebugLoc &DL = MI.getDebugLoc())
    return DL.getLine() != 0;
  return false;
};
// Collect a set of all the artificial blocks.
for (auto &MBB : MF)
  if (none_of(MBB.instrs(), hasNonArtificialLocation))
    ArtificialBlocks.insert(&MBB);

// Compute mappings of block <=> RPO order.
ReversePostOrderTraversal<MachineFunction *> RPOT(&MF);
unsigned int RPONumber = 0;
for (MachineBasicBlock *MBB : RPOT) {
  OrderToBB[RPONumber] = MBB;
  BBToOrder[MBB] = RPONumber;
  BBNumToRPO[MBB->getNumber()] = RPONumber;
  ++RPONumber;
}

// Order value substitutions by their "source" operand pair, for quick lookup.
llvm::sort(MF.DebugValueSubstitutions);

3511#ifdef EXPENSIVE_CHECKS
// As an expensive check, test whether there are any duplicate substitution
// sources in the collection.
if (MF.DebugValueSubstitutions.size() > 2) {
  for (auto It = MF.DebugValueSubstitutions.begin();
       It != std::prev(MF.DebugValueSubstitutions.end()); ++It) {
    assert(It->Src != std::next(It)->Src && "Duplicate variable location "(static_cast <bool> (It->Src != std::next(It)->Src
 && "Duplicate variable location " "substitution seen"
) ? void (0) : __assert_fail ("It->Src != std::next(It)->Src && \"Duplicate variable location \" \"substitution seen\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 3518, __extension__ __PRETTY_FUNCTION__))
                                            "substitution seen")(static_cast <bool> (It->Src != std::next(It)->Src
 && "Duplicate variable location " "substitution seen"
) ? void (0) : __assert_fail ("It->Src != std::next(It)->Src && \"Duplicate variable location \" \"substitution seen\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 3518, __extension__ __PRETTY_FUNCTION__));
  }
}
3521#endif
3522}

3524/// Calculate the liveness information for the given machine function and
3525/// extend ranges across basic blocks.
3526bool InstrRefBasedLDV::ExtendRanges(MachineFunction &MF,
                                  TargetPassConfig *TPC) {
// No subprogram means this function contains no debuginfo.
if (!MF.getFunction().getSubprogram())
1
Assuming the condition is false→
2
←
Taking false branch→
  return false;

LLVM_DEBUG(dbgs() << "\nDebug Range Extension\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("livedebugvalues")) { dbgs() << "\nDebug Range Extension\n"
; } } while (false);
3
←
Assuming 'DebugFlag' is false→
4
←
Loop condition is false.  Exiting loop→
this->TPC = TPC;

TRI = MF.getSubtarget().getRegisterInfo();
TII = MF.getSubtarget().getInstrInfo();
TFI = MF.getSubtarget().getFrameLowering();
TFI->getCalleeSaves(MF, CalleeSavedRegs);
MFI = &MF.getFrameInfo();
LS.initialize(MF);

MTracker =
    new MLocTracker(MF, *TII, *TRI, *MF.getSubtarget().getTargetLowering());
VTracker = nullptr;
TTracker = nullptr;

SmallVector<MLocTransferMap, 32> MLocTransfer;
SmallVector<VLocTracker, 8> vlocs;
LiveInsT SavedLiveIns;

int MaxNumBlocks = -1;
for (auto &MBB : MF)
  MaxNumBlocks = std::max(MBB.getNumber(), MaxNumBlocks);
assert(MaxNumBlocks >= 0)(static_cast <bool> (MaxNumBlocks >= 0) ? void (0) :
 __assert_fail ("MaxNumBlocks >= 0", "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 3554, __extension__ __PRETTY_FUNCTION__));
5
←
Assuming 'MaxNumBlocks' is >= 0→
6
←
'?' condition is true→
++MaxNumBlocks;

MLocTransfer.resize(MaxNumBlocks);
vlocs.resize(MaxNumBlocks);
SavedLiveIns.resize(MaxNumBlocks);

initialSetup(MF);

produceMLocTransferFunction(MF, MLocTransfer, MaxNumBlocks);
7
←
Calling 'InstrRefBasedLDV::produceMLocTransferFunction'→

// Allocate and initialize two array-of-arrays for the live-in and live-out
// machine values. The outer dimension is the block number; while the inner
// dimension is a LocIdx from MLocTracker.
ValueIDNum **MOutLocs = new ValueIDNum *[MaxNumBlocks];
ValueIDNum **MInLocs = new ValueIDNum *[MaxNumBlocks];
unsigned NumLocs = MTracker->getNumLocs();
for (int i = 0; i < MaxNumBlocks; ++i) {
  MOutLocs[i] = new ValueIDNum[NumLocs];
  MInLocs[i] = new ValueIDNum[NumLocs];
}

// Solve the machine value dataflow problem using the MLocTransfer function,
// storing the computed live-ins / live-outs into the array-of-arrays. We use
// both live-ins and live-outs for decision making in the variable value
// dataflow problem.
mlocDataflow(MInLocs, MOutLocs, MLocTransfer);

// Patch up debug phi numbers, turning unknown block-live-in values into
// either live-through machine values, or PHIs.
for (auto &DBG_PHI : DebugPHINumToValue) {
  // Identify unresolved block-live-ins.
  ValueIDNum &Num = DBG_PHI.ValueRead;
  if (!Num.isPHI())
    continue;

  unsigned BlockNo = Num.getBlock();
  LocIdx LocNo = Num.getLoc();
  Num = MInLocs[BlockNo][LocNo.asU64()];
}
// Later, we'll be looking up ranges of instruction numbers.
llvm::sort(DebugPHINumToValue);

// Walk back through each block / instruction, collecting DBG_VALUE
// instructions and recording what machine value their operands refer to.
for (auto &OrderPair : OrderToBB) {
  MachineBasicBlock &MBB = *OrderPair.second;
  CurBB = MBB.getNumber();
  VTracker = &vlocs[CurBB];
  VTracker->MBB = &MBB;
  MTracker->loadFromArray(MInLocs[CurBB], CurBB);
  CurInst = 1;
  for (auto &MI : MBB) {
    process(MI, MOutLocs, MInLocs);
    ++CurInst;
  }
  MTracker->reset();
}

// Number all variables in the order that they appear, to be used as a stable
// insertion order later.
DenseMap<DebugVariable, unsigned> AllVarsNumbering;

// Map from one LexicalScope to all the variables in that scope.
DenseMap<const LexicalScope *, SmallSet<DebugVariable, 4>> ScopeToVars;

// Map from One lexical scope to all blocks in that scope.
DenseMap<const LexicalScope *, SmallPtrSet<MachineBasicBlock *, 4>>
    ScopeToBlocks;

// Store a DILocation that describes a scope.
DenseMap<const LexicalScope *, const DILocation *> ScopeToDILocation;

// To mirror old LiveDebugValues, enumerate variables in RPOT order. Otherwise
// the order is unimportant, it just has to be stable.
for (unsigned int I = 0; I < OrderToBB.size(); ++I) {
  auto *MBB = OrderToBB[I];
  auto *VTracker = &vlocs[MBB->getNumber()];
  // Collect each variable with a DBG_VALUE in this block.
  for (auto &idx : VTracker->Vars) {
    const auto &Var = idx.first;
    const DILocation *ScopeLoc = VTracker->Scopes[Var];
    assert(ScopeLoc != nullptr)(static_cast <bool> (ScopeLoc != nullptr) ? void (0) : __assert_fail
 ("ScopeLoc != nullptr", "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 3636, __extension__ __PRETTY_FUNCTION__));
    auto *Scope = LS.findLexicalScope(ScopeLoc);

    // No insts in scope -> shouldn't have been recorded.
    assert(Scope != nullptr)(static_cast <bool> (Scope != nullptr) ? void (0) : __assert_fail
 ("Scope != nullptr", "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp"
, 3640, __extension__ __PRETTY_FUNCTION__));

    AllVarsNumbering.insert(std::make_pair(Var, AllVarsNumbering.size()));
    ScopeToVars[Scope].insert(Var);
    ScopeToBlocks[Scope].insert(VTracker->MBB);
    ScopeToDILocation[Scope] = ScopeLoc;
  }
}

// OK. Iterate over scopes: there might be something to be said for
// ordering them by size/locality, but that's for the future. For each scope,
// solve the variable value problem, producing a map of variables to values
// in SavedLiveIns.
for (auto &P : ScopeToVars) {
  vlocDataflow(P.first, ScopeToDILocation[P.first], P.second,
               ScopeToBlocks[P.first], SavedLiveIns, MOutLocs, MInLocs,
               vlocs);
}

// Using the computed value locations and variable values for each block,
// create the DBG_VALUE instructions representing the extended variable
// locations.
emitLocations(MF, SavedLiveIns, MOutLocs, MInLocs, AllVarsNumbering, *TPC);

for (int Idx = 0; Idx < MaxNumBlocks; ++Idx) {
  delete[] MOutLocs[Idx];
  delete[] MInLocs[Idx];
}
delete[] MOutLocs;
delete[] MInLocs;

// Did we actually make any changes? If we created any DBG_VALUEs, then yes.
bool Changed = TTracker->Transfers.size() != 0;

delete MTracker;
delete TTracker;
MTracker = nullptr;
VTracker = nullptr;
TTracker = nullptr;

ArtificialBlocks.clear();
OrderToBB.clear();
BBToOrder.clear();
BBNumToRPO.clear();
DebugInstrNumToInstr.clear();
DebugPHINumToValue.clear();

return Changed;
3688}

3690LDVImpl *llvm::makeInstrRefBasedLiveDebugValues() {
return new InstrRefBasedLDV();
3692}

3694namespace {
3695class LDVSSABlock;
3696class LDVSSAUpdater;

3698// Pick a type to identify incoming block values as we construct SSA. We
3699// can't use anything more robust than an integer unfortunately, as SSAUpdater
3700// expects to zero-initialize the type.
3701typedef uint64_t BlockValueNum;

3703/// Represents an SSA PHI node for the SSA updater class. Contains the block
3704/// this PHI is in, the value number it would have, and the expected incoming
3705/// values from parent blocks.
3706class LDVSSAPhi {
3707public:
SmallVector<std::pair<LDVSSABlock *, BlockValueNum>, 4> IncomingValues;
LDVSSABlock *ParentBlock;
BlockValueNum PHIValNum;
LDVSSAPhi(BlockValueNum PHIValNum, LDVSSABlock *ParentBlock)
    : ParentBlock(ParentBlock), PHIValNum(PHIValNum) {}

LDVSSABlock *getParent() { return ParentBlock; }
3715};

3717/// Thin wrapper around a block predecessor iterator. Only difference from a
3718/// normal block iterator is that it dereferences to an LDVSSABlock.
3719class LDVSSABlockIterator {
3720public:
MachineBasicBlock::pred_iterator PredIt;
LDVSSAUpdater &Updater;

LDVSSABlockIterator(MachineBasicBlock::pred_iterator PredIt,
                    LDVSSAUpdater &Updater)
    : PredIt(PredIt), Updater(Updater) {}

bool operator!=(const LDVSSABlockIterator &OtherIt) const {
  return OtherIt.PredIt != PredIt;
}

LDVSSABlockIterator &operator++() {
  ++PredIt;
  return *this;
}

LDVSSABlock *operator*();
3738};

3740/// Thin wrapper around a block for SSA Updater interface. Necessary because
3741/// we need to track the PHI value(s) that we may have observed as necessary
3742/// in this block.
3743class LDVSSABlock {
3744public:
MachineBasicBlock &BB;
LDVSSAUpdater &Updater;
using PHIListT = SmallVector<LDVSSAPhi, 1>;
/// List of PHIs in this block. There should only ever be one.
PHIListT PHIList;

LDVSSABlock(MachineBasicBlock &BB, LDVSSAUpdater &Updater)
    : BB(BB), Updater(Updater) {}

LDVSSABlockIterator succ_begin() {
  return LDVSSABlockIterator(BB.succ_begin(), Updater);
}

LDVSSABlockIterator succ_end() {
  return LDVSSABlockIterator(BB.succ_end(), Updater);
}

/// SSAUpdater has requested a PHI: create that within this block record.
LDVSSAPhi *newPHI(BlockValueNum Value) {
  PHIList.emplace_back(Value, this);
  return &PHIList.back();
}

/// SSAUpdater wishes to know what PHIs already exist in this block.
PHIListT &phis() { return PHIList; }
3770};

3772/// Utility class for the SSAUpdater interface: tracks blocks, PHIs and values
3773/// while SSAUpdater is exploring the CFG. It's passed as a handle / baton to
3774// SSAUpdaterTraits<LDVSSAUpdater>.
3775class LDVSSAUpdater {
3776public:
/// Map of value numbers to PHI records.
DenseMap<BlockValueNum, LDVSSAPhi *> PHIs;
/// Map of which blocks generate Undef values -- blocks that are not
/// dominated by any Def.
DenseMap<MachineBasicBlock *, BlockValueNum> UndefMap;
/// Map of machine blocks to our own records of them.
DenseMap<MachineBasicBlock *, LDVSSABlock *> BlockMap;
/// Machine location where any PHI must occur.
LocIdx Loc;
/// Table of live-in machine value numbers for blocks / locations.
ValueIDNum **MLiveIns;

LDVSSAUpdater(LocIdx L, ValueIDNum **MLiveIns) : Loc(L), MLiveIns(MLiveIns) {}

void reset() {
  for (auto &Block : BlockMap)
    delete Block.second;

  PHIs.clear();
  UndefMap.clear();
  BlockMap.clear();
}

~LDVSSAUpdater() { reset(); }

/// For a given MBB, create a wrapper block for it. Stores it in the
/// LDVSSAUpdater block map.
LDVSSABlock *getSSALDVBlock(MachineBasicBlock *BB) {
  auto it = BlockMap.find(BB);
  if (it == BlockMap.end()) {
    BlockMap[BB] = new LDVSSABlock(*BB, *this);
    it = BlockMap.find(BB);
  }
  return it->second;
}

/// Find the live-in value number for the given block. Looks up the value at
/// the PHI location on entry.
BlockValueNum getValue(LDVSSABlock *LDVBB) {
  return MLiveIns[LDVBB->BB.getNumber()][Loc.asU64()].asU64();
}
3818};

3820LDVSSABlock *LDVSSABlockIterator::operator*() {
return Updater.getSSALDVBlock(*PredIt);
3822}

3824#ifndef NDEBUG

3826raw_ostream &operator<<(raw_ostream &out, const LDVSSAPhi &PHI) {
out << "SSALDVPHI " << PHI.PHIValNum;
return out;
3829}

3831#endif

3833} // namespace

3835namespace llvm {

3837/// Template specialization to give SSAUpdater access to CFG and value
3838/// information. SSAUpdater calls methods in these traits, passing in the
3839/// LDVSSAUpdater object, to learn about blocks and the values they define.
3840/// It also provides methods to create PHI nodes and track them.
3841template <> class SSAUpdaterTraits<LDVSSAUpdater> {
3842public:
using BlkT = LDVSSABlock;
using ValT = BlockValueNum;
using PhiT = LDVSSAPhi;
using BlkSucc_iterator = LDVSSABlockIterator;

// Methods to access block successors -- dereferencing to our wrapper class.
static BlkSucc_iterator BlkSucc_begin(BlkT *BB) { return BB->succ_begin(); }
static BlkSucc_iterator BlkSucc_end(BlkT *BB) { return BB->succ_end(); }

/// Iterator for PHI operands.
class PHI_iterator {
private:
  LDVSSAPhi *PHI;
  unsigned Idx;

public:
  explicit PHI_iterator(LDVSSAPhi *P) // begin iterator
      : PHI(P), Idx(0) {}
  PHI_iterator(LDVSSAPhi *P, bool) // end iterator
      : PHI(P), Idx(PHI->IncomingValues.size()) {}

  PHI_iterator &operator++() {
    Idx++;
    return *this;
  }
  bool operator==(const PHI_iterator &X) const { return Idx == X.Idx; }
  bool operator!=(const PHI_iterator &X) const { return !operator==(X); }

  BlockValueNum getIncomingValue() { return PHI->IncomingValues[Idx].second; }

  LDVSSABlock *getIncomingBlock() { return PHI->IncomingValues[Idx].first; }
};

static inline PHI_iterator PHI_begin(PhiT *PHI) { return PHI_iterator(PHI); }

static inline PHI_iterator PHI_end(PhiT *PHI) {
  return PHI_iterator(PHI, true);
}

/// FindPredecessorBlocks - Put the predecessors of BB into the Preds
/// vector.
static void FindPredecessorBlocks(LDVSSABlock *BB,
                                  SmallVectorImpl<LDVSSABlock *> *Preds) {
  for (MachineBasicBlock::pred_iterator PI = BB->BB.pred_begin(),
                                        E = BB->BB.pred_end();
       PI != E; ++PI)
    Preds->push_back(BB->Updater.getSSALDVBlock(*PI));
}

/// GetUndefVal - Normally creates an IMPLICIT_DEF instruction with a new
/// register. For LiveDebugValues, represents a block identified as not having
/// any DBG_PHI predecessors.
static BlockValueNum GetUndefVal(LDVSSABlock *BB, LDVSSAUpdater *Updater) {
  // Create a value number for this block -- it needs to be unique and in the
  // "undef" collection, so that we know it's not real. Use a number
  // representing a PHI into this block.
  BlockValueNum Num = ValueIDNum(BB->BB.getNumber(), 0, Updater->Loc).asU64();
  Updater->UndefMap[&BB->BB] = Num;
  return Num;
}

/// CreateEmptyPHI - Create a (representation of a) PHI in the given block.
/// SSAUpdater will populate it with information about incoming values. The
/// value number of this PHI is whatever the  machine value number problem
/// solution determined it to be. This includes non-phi values if SSAUpdater
/// tries to create a PHI where the incoming values are identical.
static BlockValueNum CreateEmptyPHI(LDVSSABlock *BB, unsigned NumPreds,
                                 LDVSSAUpdater *Updater) {
  BlockValueNum PHIValNum = Updater->getValue(BB);
  LDVSSAPhi *PHI = BB->newPHI(PHIValNum);
  Updater->PHIs[PHIValNum] = PHI;
  return PHIValNum;
}

/// AddPHIOperand - Add the specified value as an operand of the PHI for
/// the specified predecessor block.
static void AddPHIOperand(LDVSSAPhi *PHI, BlockValueNum Val, LDVSSABlock *Pred) {
  PHI->IncomingValues.push_back(std::make_pair(Pred, Val));
}

/// ValueIsPHI - Check if the instruction that defines the specified value
/// is a PHI instruction.
static LDVSSAPhi *ValueIsPHI(BlockValueNum Val, LDVSSAUpdater *Updater) {
  auto PHIIt = Updater->PHIs.find(Val);
  if (PHIIt == Updater->PHIs.end())
    return nullptr;
  return PHIIt->second;
}

/// ValueIsNewPHI - Like ValueIsPHI but also check if the PHI has no source
/// operands, i.e., it was just added.
static LDVSSAPhi *ValueIsNewPHI(BlockValueNum Val, LDVSSAUpdater *Updater) {
  LDVSSAPhi *PHI = ValueIsPHI(Val, Updater);
  if (PHI && PHI->IncomingValues.size() == 0)
    return PHI;
  return nullptr;
}

/// GetPHIValue - For the specified PHI instruction, return the value
/// that it defines.
static BlockValueNum GetPHIValue(LDVSSAPhi *PHI) { return PHI->PHIValNum; }
3944};

3946} // end namespace llvm

3948Optional<ValueIDNum> InstrRefBasedLDV::resolveDbgPHIs(MachineFunction &MF,
                                                    ValueIDNum **MLiveOuts,
                                                    ValueIDNum **MLiveIns,
                                                    MachineInstr &Here,
                                                    uint64_t InstrNum) {
// Pick out records of DBG_PHI instructions that have been observed. If there
// are none, then we cannot compute a value number.
auto RangePair = std::equal_range(DebugPHINumToValue.begin(),
                                  DebugPHINumToValue.end(), InstrNum);
auto LowerIt = RangePair.first;
auto UpperIt = RangePair.second;

// No DBG_PHI means there can be no location.
if (LowerIt == UpperIt)
85
←
Assuming 'LowerIt' is not equal to 'UpperIt'→
86
←
Taking false branch→
  return None;

// If there's only one DBG_PHI, then that is our value number.
if (std::distance(LowerIt, UpperIt) == 1)
87
←
Assuming the condition is false→
88
←
Taking false branch→
  return LowerIt->ValueRead;

auto DBGPHIRange = make_range(LowerIt, UpperIt);

// Pick out the location (physreg, slot) where any PHIs must occur. It's
// technically possible for us to merge values in different registers in each
// block, but highly unlikely that LLVM will generate such code after register
// allocation.
LocIdx Loc = LowerIt->ReadLoc;

// We have several DBG_PHIs, and a use position (the Here inst). All each
// DBG_PHI does is identify a value at a program position. We can treat each
// DBG_PHI like it's a Def of a value, and the use position is a Use of a
// value, just like SSA. We use the bulk-standard LLVM SSA updater class to
// determine which Def is used at the Use, and any PHIs that happen along
// the way.
// Adapted LLVM SSA Updater:
LDVSSAUpdater Updater(Loc, MLiveIns);
// Map of which Def or PHI is the current value in each block.
DenseMap<LDVSSABlock *, BlockValueNum> AvailableValues;
// Set of PHIs that we have created along the way.
SmallVector<LDVSSAPhi *, 8> CreatedPHIs;

// Each existing DBG_PHI is a Def'd value under this model. Record these Defs
// for the SSAUpdater.
for (const auto &DBG_PHI : DBGPHIRange) {
89
←
Assuming '__begin1' is equal to '__end1'→
  LDVSSABlock *Block = Updater.getSSALDVBlock(DBG_PHI.MBB);
  const ValueIDNum &Num = DBG_PHI.ValueRead;
  AvailableValues.insert(std::make_pair(Block, Num.asU64()));
}

LDVSSABlock *HereBlock = Updater.getSSALDVBlock(Here.getParent());
const auto &AvailIt = AvailableValues.find(HereBlock);
if (AvailIt != AvailableValues.end()) {
90
←
Calling 'operator!='→
93
←
Returning from 'operator!='→
94
←
Taking false branch→
  // Actually, we already know what the value is -- the Use is in the same
  // block as the Def.
  return ValueIDNum::fromU64(AvailIt->second);
}

// Otherwise, we must use the SSA Updater. It will identify the value number
// that we are to use, and the PHIs that must happen along the way.
SSAUpdaterImpl<LDVSSAUpdater> Impl(&Updater, &AvailableValues, &CreatedPHIs);
BlockValueNum ResultInt = Impl.GetValue(Updater.getSSALDVBlock(Here.getParent()));
ValueIDNum Result = ValueIDNum::fromU64(ResultInt);

// We have the number for a PHI, or possibly live-through value, to be used
// at this Use. There are a number of things we have to check about it though:
//  * Does any PHI use an 'Undef' (like an IMPLICIT_DEF) value? If so, this
//    Use was not completely dominated by DBG_PHIs and we should abort.
//  * Are the Defs or PHIs clobbered in a block? SSAUpdater isn't aware that
//    we've left SSA form. Validate that the inputs to each PHI are the
//    expected values.
//  * Is a PHI we've created actually a merging of values, or are all the
//    predecessor values the same, leading to a non-PHI machine value number?
//    (SSAUpdater doesn't know that either). Remap validated PHIs into the
//    the ValidatedValues collection below to sort this out.
DenseMap<LDVSSABlock *, ValueIDNum> ValidatedValues;

// Define all the input DBG_PHI values in ValidatedValues.
for (const auto &DBG_PHI : DBGPHIRange) {
95
←
Assuming '__begin1' is equal to '__end1'→
  LDVSSABlock *Block = Updater.getSSALDVBlock(DBG_PHI.MBB);
  const ValueIDNum &Num = DBG_PHI.ValueRead;
  ValidatedValues.insert(std::make_pair(Block, Num));
}

// Sort PHIs to validate into RPO-order.
SmallVector<LDVSSAPhi *, 8> SortedPHIs;
for (auto &PHI : CreatedPHIs)
96
←
Assuming '__begin1' is equal to '__end1'→
  SortedPHIs.push_back(PHI);

std::sort(
    SortedPHIs.begin(), SortedPHIs.end(), [&](LDVSSAPhi *A, LDVSSAPhi *B) {
      return BBToOrder[&A->getParent()->BB] < BBToOrder[&B->getParent()->BB];
    });

for (auto &PHI : SortedPHIs) {
97
←
Assuming '__begin1' is not equal to '__end1'→
  ValueIDNum ThisBlockValueNum =
      MLiveIns[PHI->ParentBlock->BB.getNumber()][Loc.asU64()];
98
←
Array access (from variable 'MLiveIns') results in a null pointer dereference

  // Are all these things actually defined?
  for (auto &PHIIt : PHI->IncomingValues) {
    // Any undef input means DBG_PHIs didn't dominate the use point.
    if (Updater.UndefMap.find(&PHIIt.first->BB) != Updater.UndefMap.end())
      return None;

    ValueIDNum ValueToCheck;
    ValueIDNum *BlockLiveOuts = MLiveOuts[PHIIt.first->BB.getNumber()];

    auto VVal = ValidatedValues.find(PHIIt.first);
    if (VVal == ValidatedValues.end()) {
      // We cross a loop, and this is a backedge. LLVMs tail duplication
      // happens so late that DBG_PHI instructions should not be able to
      // migrate into loops -- meaning we can only be live-through this
      // loop.
      ValueToCheck = ThisBlockValueNum;
    } else {
      // Does the block have as a live-out, in the location we're examining,
      // the value that we expect? If not, it's been moved or clobbered.
      ValueToCheck = VVal->second;
    }

    if (BlockLiveOuts[Loc.asU64()] != ValueToCheck)
      return None;
  }

  // Record this value as validated.
  ValidatedValues.insert({PHI->ParentBlock, ThisBlockValueNum});
}

// All the PHIs are valid: we can return what the SSAUpdater said our value
// number was.
return Result;
4078}

←

/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/CodeGen/MachineInstr.h

→

1//===- llvm/CodeGen/MachineInstr.h - MachineInstr class ---------*- 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 contains the declaration of the MachineInstr class, which is the
10// basic representation for all target dependent machine instructions used by
11// the back end.
12//
13//===----------------------------------------------------------------------===//

15#ifndef LLVM_CODEGEN_MACHINEINSTR_H
16#define LLVM_CODEGEN_MACHINEINSTR_H

18#include "llvm/ADT/DenseMapInfo.h"
19#include "llvm/ADT/PointerSumType.h"
20#include "llvm/ADT/SmallSet.h"
21#include "llvm/ADT/ilist.h"
22#include "llvm/ADT/ilist_node.h"
23#include "llvm/ADT/iterator_range.h"
24#include "llvm/CodeGen/MachineMemOperand.h"
25#include "llvm/CodeGen/MachineOperand.h"
26#include "llvm/CodeGen/TargetOpcodes.h"
27#include "llvm/IR/DebugLoc.h"
28#include "llvm/IR/InlineAsm.h"
29#include "llvm/IR/PseudoProbe.h"
30#include "llvm/MC/MCInstrDesc.h"
31#include "llvm/MC/MCSymbol.h"
32#include "llvm/Support/ArrayRecycler.h"
33#include "llvm/Support/TrailingObjects.h"
34#include <algorithm>
35#include <cassert>
36#include <cstdint>
37#include <utility>

39namespace llvm {

41class AAResults;
42template <typename T> class ArrayRef;
43class DIExpression;
44class DILocalVariable;
45class MachineBasicBlock;
46class MachineFunction;
47class MachineRegisterInfo;
48class ModuleSlotTracker;
49class raw_ostream;
50template <typename T> class SmallVectorImpl;
51class SmallBitVector;
52class StringRef;
53class TargetInstrInfo;
54class TargetRegisterClass;
55class TargetRegisterInfo;

57//===----------------------------------------------------------------------===//
58/// Representation of each machine instruction.
59///
60/// This class isn't a POD type, but it must have a trivial destructor. When a
61/// MachineFunction is deleted, all the contained MachineInstrs are deallocated
62/// without having their destructor called.
63///
64class MachineInstr
  : public ilist_node_with_parent<MachineInstr, MachineBasicBlock,
                                  ilist_sentinel_tracking<true>> {
67public:
using mmo_iterator = ArrayRef<MachineMemOperand *>::iterator;

/// Flags to specify different kinds of comments to output in
/// assembly code.  These flags carry semantic information not
/// otherwise easily derivable from the IR text.
///
enum CommentFlag {
  ReloadReuse = 0x1,    // higher bits are reserved for target dep comments.
  NoSchedComment = 0x2,
  TAsmComments = 0x4    // Target Asm comments should start from this value.
};

enum MIFlag {
  NoFlags      = 0,
  FrameSetup   = 1 << 0,              // Instruction is used as a part of
                                      // function frame setup code.
  FrameDestroy = 1 << 1,              // Instruction is used as a part of
                                      // function frame destruction code.
  BundledPred  = 1 << 2,              // Instruction has bundled predecessors.
  BundledSucc  = 1 << 3,              // Instruction has bundled successors.
  FmNoNans     = 1 << 4,              // Instruction does not support Fast
                                      // math nan values.
  FmNoInfs     = 1 << 5,              // Instruction does not support Fast
                                      // math infinity values.
  FmNsz        = 1 << 6,              // Instruction is not required to retain
                                      // signed zero values.
  FmArcp       = 1 << 7,              // Instruction supports Fast math
                                      // reciprocal approximations.
  FmContract   = 1 << 8,              // Instruction supports Fast math
                                      // contraction operations like fma.
  FmAfn        = 1 << 9,              // Instruction may map to Fast math
                                      // instrinsic approximation.
  FmReassoc    = 1 << 10,             // Instruction supports Fast math
                                      // reassociation of operand order.
  NoUWrap      = 1 << 11,             // Instruction supports binary operator
                                      // no unsigned wrap.
  NoSWrap      = 1 << 12,             // Instruction supports binary operator
                                      // no signed wrap.
  IsExact      = 1 << 13,             // Instruction supports division is
                                      // known to be exact.
  NoFPExcept   = 1 << 14,             // Instruction does not raise
                                      // floatint-point exceptions.
  NoMerge      = 1 << 15,             // Passes that drop source location info
                                      // (e.g. branch folding) should skip
                                      // this instruction.
};

115private:
const MCInstrDesc *MCID;              // Instruction descriptor.
MachineBasicBlock *Parent = nullptr;  // Pointer to the owning basic block.

// Operands are allocated by an ArrayRecycler.
MachineOperand *Operands = nullptr;   // Pointer to the first operand.
unsigned NumOperands = 0;             // Number of operands on instruction.

uint16_t Flags = 0;                   // Various bits of additional
                                      // information about machine
                                      // instruction.

uint8_t AsmPrinterFlags = 0;          // Various bits of information used by
                                      // the AsmPrinter to emit helpful
                                      // comments.  This is *not* semantic
                                      // information.  Do not use this for
                                      // anything other than to convey comment
                                      // information to AsmPrinter.

// OperandCapacity has uint8_t size, so it should be next to AsmPrinterFlags
// to properly pack.
using OperandCapacity = ArrayRecycler<MachineOperand>::Capacity;
OperandCapacity CapOperands;          // Capacity of the Operands array.

/// Internal implementation detail class that provides out-of-line storage for
/// extra info used by the machine instruction when this info cannot be stored
/// in-line within the instruction itself.
///
/// This has to be defined eagerly due to the implementation constraints of
/// `PointerSumType` where it is used.
class ExtraInfo final
    : TrailingObjects<ExtraInfo, MachineMemOperand *, MCSymbol *, MDNode *> {
public:
  static ExtraInfo *create(BumpPtrAllocator &Allocator,
                           ArrayRef<MachineMemOperand *> MMOs,
                           MCSymbol *PreInstrSymbol = nullptr,
                           MCSymbol *PostInstrSymbol = nullptr,
                           MDNode *HeapAllocMarker = nullptr) {
    bool HasPreInstrSymbol = PreInstrSymbol != nullptr;
    bool HasPostInstrSymbol = PostInstrSymbol != nullptr;
    bool HasHeapAllocMarker = HeapAllocMarker != nullptr;
    auto *Result = new (Allocator.Allocate(
        totalSizeToAlloc<MachineMemOperand *, MCSymbol *, MDNode *>(
            MMOs.size(), HasPreInstrSymbol + HasPostInstrSymbol,
            HasHeapAllocMarker),
        alignof(ExtraInfo)))
        ExtraInfo(MMOs.size(), HasPreInstrSymbol, HasPostInstrSymbol,
                  HasHeapAllocMarker);

    // Copy the actual data into the trailing objects.
    std::copy(MMOs.begin(), MMOs.end(),
              Result->getTrailingObjects<MachineMemOperand *>());

    if (HasPreInstrSymbol)
      Result->getTrailingObjects<MCSymbol *>()[0] = PreInstrSymbol;
    if (HasPostInstrSymbol)
      Result->getTrailingObjects<MCSymbol *>()[HasPreInstrSymbol] =
          PostInstrSymbol;
    if (HasHeapAllocMarker)
      Result->getTrailingObjects<MDNode *>()[0] = HeapAllocMarker;

    return Result;
  }

  ArrayRef<MachineMemOperand *> getMMOs() const {
    return makeArrayRef(getTrailingObjects<MachineMemOperand *>(), NumMMOs);
  }

  MCSymbol *getPreInstrSymbol() const {
    return HasPreInstrSymbol ? getTrailingObjects<MCSymbol *>()[0] : nullptr;
  }

  MCSymbol *getPostInstrSymbol() const {
    return HasPostInstrSymbol
               ? getTrailingObjects<MCSymbol *>()[HasPreInstrSymbol]
               : nullptr;
  }

  MDNode *getHeapAllocMarker() const {
    return HasHeapAllocMarker ? getTrailingObjects<MDNode *>()[0] : nullptr;
  }

private:
  friend TrailingObjects;

  // Description of the extra info, used to interpret the actual optional
  // data appended.
  //
  // Note that this is not terribly space optimized. This leaves a great deal
  // of flexibility to fit more in here later.
  const int NumMMOs;
  const bool HasPreInstrSymbol;
  const bool HasPostInstrSymbol;
  const bool HasHeapAllocMarker;

  // Implement the `TrailingObjects` internal API.
  size_t numTrailingObjects(OverloadToken<MachineMemOperand *>) const {
    return NumMMOs;
  }
  size_t numTrailingObjects(OverloadToken<MCSymbol *>) const {
    return HasPreInstrSymbol + HasPostInstrSymbol;
  }
  size_t numTrailingObjects(OverloadToken<MDNode *>) const {
    return HasHeapAllocMarker;
  }

  // Just a boring constructor to allow us to initialize the sizes. Always use
  // the `create` routine above.
  ExtraInfo(int NumMMOs, bool HasPreInstrSymbol, bool HasPostInstrSymbol,
            bool HasHeapAllocMarker)
      : NumMMOs(NumMMOs), HasPreInstrSymbol(HasPreInstrSymbol),
        HasPostInstrSymbol(HasPostInstrSymbol),
        HasHeapAllocMarker(HasHeapAllocMarker) {}
};

/// Enumeration of the kinds of inline extra info available. It is important
/// that the `MachineMemOperand` inline kind has a tag value of zero to make
/// it accessible as an `ArrayRef`.
enum ExtraInfoInlineKinds {
  EIIK_MMO = 0,
  EIIK_PreInstrSymbol,
  EIIK_PostInstrSymbol,
  EIIK_OutOfLine
};

// We store extra information about the instruction here. The common case is
// expected to be nothing or a single pointer (typically a MMO or a symbol).
// We work to optimize this common case by storing it inline here rather than
// requiring a separate allocation, but we fall back to an allocation when
// multiple pointers are needed.
PointerSumType<ExtraInfoInlineKinds,
               PointerSumTypeMember<EIIK_MMO, MachineMemOperand *>,
               PointerSumTypeMember<EIIK_PreInstrSymbol, MCSymbol *>,
               PointerSumTypeMember<EIIK_PostInstrSymbol, MCSymbol *>,
               PointerSumTypeMember<EIIK_OutOfLine, ExtraInfo *>>
    Info;

DebugLoc debugLoc;                    // Source line information.

/// Unique instruction number. Used by DBG_INSTR_REFs to refer to the values
/// defined by this instruction.
unsigned DebugInstrNum;

// Intrusive list support
friend struct ilist_traits<MachineInstr>;
friend struct ilist_callback_traits<MachineBasicBlock>;
void setParent(MachineBasicBlock *P) { Parent = P; }

/// This constructor creates a copy of the given
/// MachineInstr in the given MachineFunction.
MachineInstr(MachineFunction &, const MachineInstr &);

/// This constructor create a MachineInstr and add the implicit operands.
/// It reserves space for number of operands specified by
/// MCInstrDesc.  An explicit DebugLoc is supplied.
MachineInstr(MachineFunction &, const MCInstrDesc &tid, DebugLoc dl,
             bool NoImp = false);

// MachineInstrs are pool-allocated and owned by MachineFunction.
friend class MachineFunction;

void
dumprImpl(const MachineRegisterInfo &MRI, unsigned Depth, unsigned MaxDepth,
          SmallPtrSetImpl<const MachineInstr *> &AlreadySeenInstrs) const;

280public:
MachineInstr(const MachineInstr &) = delete;
MachineInstr &operator=(const MachineInstr &) = delete;
// Use MachineFunction::DeleteMachineInstr() instead.
~MachineInstr() = delete;

const MachineBasicBlock* getParent() const { return Parent; }
MachineBasicBlock* getParent() { return Parent; }

/// Move the instruction before \p MovePos.
void moveBefore(MachineInstr *MovePos);

/// Return the function that contains the basic block that this instruction
/// belongs to.
///
/// Note: this is undefined behaviour if the instruction does not have a
/// parent.
const MachineFunction *getMF() const;
MachineFunction *getMF() {
  return const_cast<MachineFunction *>(
      static_cast<const MachineInstr *>(this)->getMF());
}

/// Return the asm printer flags bitvector.
uint8_t getAsmPrinterFlags() const { return AsmPrinterFlags; }

/// Clear the AsmPrinter bitvector.
void clearAsmPrinterFlags() { AsmPrinterFlags = 0; }

/// Return whether an AsmPrinter flag is set.
bool getAsmPrinterFlag(CommentFlag Flag) const {
  return AsmPrinterFlags & Flag;
}

/// Set a flag for the AsmPrinter.
void setAsmPrinterFlag(uint8_t Flag) {
  AsmPrinterFlags |= Flag;
}

/// Clear specific AsmPrinter flags.
void clearAsmPrinterFlag(CommentFlag Flag) {
  AsmPrinterFlags &= ~Flag;
}

/// Return the MI flags bitvector.
uint16_t getFlags() const {
  return Flags;
}

/// Return whether an MI flag is set.
bool getFlag(MIFlag Flag) const {
  return Flags & Flag;
}

/// Set a MI flag.
void setFlag(MIFlag Flag) {
  Flags |= (uint16_t)Flag;
}

void setFlags(unsigned flags) {
  // Filter out the automatically maintained flags.
  unsigned Mask = BundledPred | BundledSucc;
  Flags = (Flags & Mask) | (flags & ~Mask);
}

/// clearFlag - Clear a MI flag.
void clearFlag(MIFlag Flag) {
  Flags &= ~((uint16_t)Flag);
}

/// Return true if MI is in a bundle (but not the first MI in a bundle).
///
/// A bundle looks like this before it's finalized:
///   ----------------
///   |      MI      |
///   ----------------
///          |
///   ----------------
///   |      MI    * |
///   ----------------
///          |
///   ----------------
///   |      MI    * |
///   ----------------
/// In this case, the first MI starts a bundle but is not inside a bundle, the
/// next 2 MIs are considered "inside" the bundle.
///
/// After a bundle is finalized, it looks like this:
///   ----------------
///   |    Bundle    |
///   ----------------
///          |
///   ----------------
///   |      MI    * |
///   ----------------
///          |
///   ----------------
///   |      MI    * |
///   ----------------
///          |
///   ----------------
///   |      MI    * |
///   ----------------
/// The first instruction has the special opcode "BUNDLE". It's not "inside"
/// a bundle, but the next three MIs are.
bool isInsideBundle() const {
  return getFlag(BundledPred);
}

/// Return true if this instruction part of a bundle. This is true
/// if either itself or its following instruction is marked "InsideBundle".
bool isBundled() const {
  return isBundledWithPred() || isBundledWithSucc();
}

/// Return true if this instruction is part of a bundle, and it is not the
/// first instruction in the bundle.
bool isBundledWithPred() const { return getFlag(BundledPred); }

/// Return true if this instruction is part of a bundle, and it is not the
/// last instruction in the bundle.
bool isBundledWithSucc() const { return getFlag(BundledSucc); }

/// Bundle this instruction with its predecessor. This can be an unbundled
/// instruction, or it can be the first instruction in a bundle.
void bundleWithPred();

/// Bundle this instruction with its successor. This can be an unbundled
/// instruction, or it can be the last instruction in a bundle.
void bundleWithSucc();

/// Break bundle above this instruction.
void unbundleFromPred();

/// Break bundle below this instruction.
void unbundleFromSucc();

/// Returns the debug location id of this MachineInstr.
const DebugLoc &getDebugLoc() const { return debugLoc; }

/// Return the operand containing the offset to be used if this DBG_VALUE
/// instruction is indirect; will be an invalid register if this value is
/// not indirect, and an immediate with value 0 otherwise.
const MachineOperand &getDebugOffset() const {
  assert(isNonListDebugValue() && "not a DBG_VALUE")(static_cast <bool> (isNonListDebugValue() && "not a DBG_VALUE"
) ? void (0) : __assert_fail ("isNonListDebugValue() && \"not a DBG_VALUE\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/CodeGen/MachineInstr.h"
, 424, __extension__ __PRETTY_FUNCTION__));
  return getOperand(1);
}
MachineOperand &getDebugOffset() {
  assert(isNonListDebugValue() && "not a DBG_VALUE")(static_cast <bool> (isNonListDebugValue() && "not a DBG_VALUE"
) ? void (0) : __assert_fail ("isNonListDebugValue() && \"not a DBG_VALUE\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/CodeGen/MachineInstr.h"
, 428, __extension__ __PRETTY_FUNCTION__));
  return getOperand(1);
}

/// Return the operand for the debug variable referenced by
/// this DBG_VALUE instruction.
const MachineOperand &getDebugVariableOp() const;
MachineOperand &getDebugVariableOp();

/// Return the debug variable referenced by
/// this DBG_VALUE instruction.
const DILocalVariable *getDebugVariable() const;

/// Return the operand for the complex address expression referenced by
/// this DBG_VALUE instruction.
const MachineOperand &getDebugExpressionOp() const;
MachineOperand &getDebugExpressionOp();

/// Return the complex address expression referenced by
/// this DBG_VALUE instruction.
const DIExpression *getDebugExpression() const;

/// Return the debug label referenced by
/// this DBG_LABEL instruction.
const DILabel *getDebugLabel() const;

/// Fetch the instruction number of this MachineInstr. If it does not have
/// one already, a new and unique number will be assigned.
unsigned getDebugInstrNum();

/// Fetch instruction number of this MachineInstr -- but before it's inserted
/// into \p MF. Needed for transformations that create an instruction but
/// don't immediately insert them.
unsigned getDebugInstrNum(MachineFunction &MF);

/// Examine the instruction number of this MachineInstr. May be zero if
/// it hasn't been assigned a number yet.
unsigned peekDebugInstrNum() const { return DebugInstrNum; }

/// Set instruction number of this MachineInstr. Avoid using unless you're
/// deserializing this information.
void setDebugInstrNum(unsigned Num) { DebugInstrNum = Num; }

/// Drop any variable location debugging information associated with this
/// instruction. Use when an instruction is modified in such a way that it no
/// longer defines the value it used to. Variable locations using that value
/// will be dropped.
void dropDebugNumber() { DebugInstrNum = 0; }

/// Emit an error referring to the source location of this instruction.
/// This should only be used for inline assembly that is somehow
/// impossible to compile. Other errors should have been handled much
/// earlier.
///
/// If this method returns, the caller should try to recover from the error.
void emitError(StringRef Msg) const;

/// Returns the target instruction descriptor of this MachineInstr.
const MCInstrDesc &getDesc() const { return *MCID; }

/// Returns the opcode of this MachineInstr.
unsigned getOpcode() const { return MCID->Opcode; }

/// Retuns the total number of operands.
unsigned getNumOperands() const { return NumOperands; }

/// Returns the total number of operands which are debug locations.
unsigned getNumDebugOperands() const {
  return std::distance(debug_operands().begin(), debug_operands().end());
}

const MachineOperand& getOperand(unsigned i) const {
  assert(i < getNumOperands() && "getOperand() out of range!")(static_cast <bool> (i < getNumOperands() &&
 "getOperand() out of range!") ? void (0) : __assert_fail ("i < getNumOperands() && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/CodeGen/MachineInstr.h"
, 500, __extension__ __PRETTY_FUNCTION__));
  return Operands[i];
}
MachineOperand& getOperand(unsigned i) {
  assert(i < getNumOperands() && "getOperand() out of range!")(static_cast <bool> (i < getNumOperands() &&
 "getOperand() out of range!") ? void (0) : __assert_fail ("i < getNumOperands() && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/CodeGen/MachineInstr.h"
, 504, __extension__ __PRETTY_FUNCTION__));
  return Operands[i];
}

MachineOperand &getDebugOperand(unsigned Index) {
  assert(Index < getNumDebugOperands() && "getDebugOperand() out of range!")(static_cast <bool> (Index < getNumDebugOperands() &&
 "getDebugOperand() out of range!") ? void (0) : __assert_fail
 ("Index < getNumDebugOperands() && \"getDebugOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/CodeGen/MachineInstr.h"
, 509, __extension__ __PRETTY_FUNCTION__));
  return *(debug_operands().begin() + Index);
}
const MachineOperand &getDebugOperand(unsigned Index) const {
  assert(Index < getNumDebugOperands() && "getDebugOperand() out of range!")(static_cast <bool> (Index < getNumDebugOperands() &&
 "getDebugOperand() out of range!") ? void (0) : __assert_fail
 ("Index < getNumDebugOperands() && \"getDebugOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/CodeGen/MachineInstr.h"
, 513, __extension__ __PRETTY_FUNCTION__));
  return *(debug_operands().begin() + Index);
}

SmallSet<Register, 4> getUsedDebugRegs() const {
  assert(isDebugValue() && "not a DBG_VALUE*")(static_cast <bool> (isDebugValue() && "not a DBG_VALUE*"
) ? void (0) : __assert_fail ("isDebugValue() && \"not a DBG_VALUE*\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/CodeGen/MachineInstr.h"
, 518, __extension__ __PRETTY_FUNCTION__));
  SmallSet<Register, 4> UsedRegs;
  for (auto MO : debug_operands())
    if (MO.isReg() && MO.getReg())
      UsedRegs.insert(MO.getReg());
  return UsedRegs;
}

/// Returns whether this debug value has at least one debug operand with the
/// register \p Reg.
bool hasDebugOperandForReg(Register Reg) const {
  return any_of(debug_operands(), [Reg](const MachineOperand &Op) {
    return Op.isReg() && Op.getReg() == Reg;
  });
}

/// Returns a range of all of the operands that correspond to a debug use of
/// \p Reg.
template <typename Operand, typename Instruction>
static iterator_range<
    filter_iterator<Operand *, std::function<bool(Operand &Op)>>>
getDebugOperandsForReg(Instruction *MI, Register Reg) {
  std::function<bool(Operand & Op)> OpUsesReg(
      [Reg](Operand &Op) { return Op.isReg() && Op.getReg() == Reg; });
  return make_filter_range(MI->debug_operands(), OpUsesReg);
}
iterator_range<filter_iterator<const MachineOperand *,
                               std::function<bool(const MachineOperand &Op)>>>
getDebugOperandsForReg(Register Reg) const {
  return MachineInstr::getDebugOperandsForReg<const MachineOperand,
                                              const MachineInstr>(this, Reg);
}
iterator_range<filter_iterator<MachineOperand *,
                               std::function<bool(MachineOperand &Op)>>>
getDebugOperandsForReg(Register Reg) {
  return MachineInstr::getDebugOperandsForReg<MachineOperand, MachineInstr>(
      this, Reg);
}

bool isDebugOperand(const MachineOperand *Op) const {
  return Op >= adl_begin(debug_operands()) && Op <= adl_end(debug_operands());
}

unsigned getDebugOperandIndex(const MachineOperand *Op) const {
  assert(isDebugOperand(Op) && "Expected a debug operand.")(static_cast <bool> (isDebugOperand(Op) && "Expected a debug operand."
) ? void (0) : __assert_fail ("isDebugOperand(Op) && \"Expected a debug operand.\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/CodeGen/MachineInstr.h"
, 562, __extension__ __PRETTY_FUNCTION__));
  return std::distance(adl_begin(debug_operands()), Op);
}

/// Returns the total number of definitions.
unsigned getNumDefs() const {
  return getNumExplicitDefs() + MCID->getNumImplicitDefs();
}

/// Returns true if the instruction has implicit definition.
bool hasImplicitDef() const {
  for (unsigned I = getNumExplicitOperands(), E = getNumOperands();
    I != E; ++I) {
    const MachineOperand &MO = getOperand(I);
    if (MO.isDef() && MO.isImplicit())
      return true;
  }
  return false;
}

/// Returns the implicit operands number.
unsigned getNumImplicitOperands() const {
  return getNumOperands() - getNumExplicitOperands();
}

/// Return true if operand \p OpIdx is a subregister index.
bool isOperandSubregIdx(unsigned OpIdx) const {
  assert(getOperand(OpIdx).getType() == MachineOperand::MO_Immediate &&(static_cast <bool> (getOperand(OpIdx).getType() == MachineOperand
::MO_Immediate && "Expected MO_Immediate operand type."
) ? void (0) : __assert_fail ("getOperand(OpIdx).getType() == MachineOperand::MO_Immediate && \"Expected MO_Immediate operand type.\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/CodeGen/MachineInstr.h"
, 590, __extension__ __PRETTY_FUNCTION__))
         "Expected MO_Immediate operand type.")(static_cast <bool> (getOperand(OpIdx).getType() == MachineOperand
::MO_Immediate && "Expected MO_Immediate operand type."
) ? void (0) : __assert_fail ("getOperand(OpIdx).getType() == MachineOperand::MO_Immediate && \"Expected MO_Immediate operand type.\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/CodeGen/MachineInstr.h"
, 590, __extension__ __PRETTY_FUNCTION__));
  if (isExtractSubreg() && OpIdx == 2)
    return true;
  if (isInsertSubreg() && OpIdx == 3)
    return true;
  if (isRegSequence() && OpIdx > 1 && (OpIdx % 2) == 0)
    return true;
  if (isSubregToReg() && OpIdx == 3)
    return true;
  return false;
}

/// Returns the number of non-implicit operands.
unsigned getNumExplicitOperands() const;

/// Returns the number of non-implicit definitions.
unsigned getNumExplicitDefs() const;

/// iterator/begin/end - Iterate over all operands of a machine instruction.
using mop_iterator = MachineOperand *;
using const_mop_iterator = const MachineOperand *;

mop_iterator operands_begin() { return Operands; }
mop_iterator operands_end() { return Operands + NumOperands; }

const_mop_iterator operands_begin() const { return Operands; }
const_mop_iterator operands_end() const { return Operands + NumOperands; }

iterator_range<mop_iterator> operands() {
  return make_range(operands_begin(), operands_end());
}
iterator_range<const_mop_iterator> operands() const {
  return make_range(operands_begin(), operands_end());
}
iterator_range<mop_iterator> explicit_operands() {
  return make_range(operands_begin(),
                    operands_begin() + getNumExplicitOperands());
}
iterator_range<const_mop_iterator> explicit_operands() const {
  return make_range(operands_begin(),
                    operands_begin() + getNumExplicitOperands());
}
iterator_range<mop_iterator> implicit_operands() {
  return make_range(explicit_operands().end(), operands_end());
}
iterator_range<const_mop_iterator> implicit_operands() const {
  return make_range(explicit_operands().end(), operands_end());
}
/// Returns a range over all operands that are used to determine the variable
/// location for this DBG_VALUE instruction.
iterator_range<mop_iterator> debug_operands() {
  assert(isDebugValue() && "Must be a debug value instruction.")(static_cast <bool> (isDebugValue() && "Must be a debug value instruction."
) ? void (0) : __assert_fail ("isDebugValue() && \"Must be a debug value instruction.\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/CodeGen/MachineInstr.h"
, 641, __extension__ __PRETTY_FUNCTION__));
  return isDebugValueList()
             ? make_range(operands_begin() + 2, operands_end())
             : make_range(operands_begin(), operands_begin() + 1);
}
/// \copydoc debug_operands()
iterator_range<const_mop_iterator> debug_operands() const {
  assert(isDebugValue() && "Must be a debug value instruction.")(static_cast <bool> (isDebugValue() && "Must be a debug value instruction."
) ? void (0) : __assert_fail ("isDebugValue() && \"Must be a debug value instruction.\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/CodeGen/MachineInstr.h"
, 648, __extension__ __PRETTY_FUNCTION__));
  return isDebugValueList()
             ? make_range(operands_begin() + 2, operands_end())
             : make_range(operands_begin(), operands_begin() + 1);
}
/// Returns a range over all explicit operands that are register definitions.
/// Implicit definition are not included!
iterator_range<mop_iterator> defs() {
  return make_range(operands_begin(),
                    operands_begin() + getNumExplicitDefs());
}
/// \copydoc defs()
iterator_range<const_mop_iterator> defs() const {
  return make_range(operands_begin(),
                    operands_begin() + getNumExplicitDefs());
}
/// Returns a range that includes all operands that are register uses.
/// This may include unrelated operands which are not register uses.
iterator_range<mop_iterator> uses() {
  return make_range(operands_begin() + getNumExplicitDefs(), operands_end());
}
/// \copydoc uses()
iterator_range<const_mop_iterator> uses() const {
  return make_range(operands_begin() + getNumExplicitDefs(), operands_end());
}
iterator_range<mop_iterator> explicit_uses() {
  return make_range(operands_begin() + getNumExplicitDefs(),
                    operands_begin() + getNumExplicitOperands());
}
iterator_range<const_mop_iterator> explicit_uses() const {
  return make_range(operands_begin() + getNumExplicitDefs(),
                    operands_begin() + getNumExplicitOperands());
}

/// Returns the number of the operand iterator \p I points to.
unsigned getOperandNo(const_mop_iterator I) const {
  return I - operands_begin();
}

/// Access to memory operands of the instruction. If there are none, that does
/// not imply anything about whether the function accesses memory. Instead,
/// the caller must behave conservatively.
ArrayRef<MachineMemOperand *> memoperands() const {
  if (!Info)
    return {};

  if (Info.is<EIIK_MMO>())
    return makeArrayRef(Info.getAddrOfZeroTagPointer(), 1);

  if (ExtraInfo *EI = Info.get<EIIK_OutOfLine>())
    return EI->getMMOs();

  return {};
}

/// Access to memory operands of the instruction.
///
/// If `memoperands_begin() == memoperands_end()`, that does not imply
/// anything about whether the function accesses memory. Instead, the caller
/// must behave conservatively.
mmo_iterator memoperands_begin() const { return memoperands().begin(); }

/// Access to memory operands of the instruction.
///
/// If `memoperands_begin() == memoperands_end()`, that does not imply
/// anything about whether the function accesses memory. Instead, the caller
/// must behave conservatively.
mmo_iterator memoperands_end() const { return memoperands().end(); }

/// Return true if we don't have any memory operands which described the
/// memory access done by this instruction.  If this is true, calling code
/// must be conservative.
bool memoperands_empty() const { return memoperands().empty(); }

/// Return true if this instruction has exactly one MachineMemOperand.
bool hasOneMemOperand() const { return memoperands().size() == 1; }

/// Return the number of memory operands.
unsigned getNumMemOperands() const { return memoperands().size(); }

/// Helper to extract a pre-instruction symbol if one has been added.
MCSymbol *getPreInstrSymbol() const {
  if (!Info)
    return nullptr;
  if (MCSymbol *S = Info.get<EIIK_PreInstrSymbol>())
    return S;
  if (ExtraInfo *EI = Info.get<EIIK_OutOfLine>())
    return EI->getPreInstrSymbol();

  return nullptr;
}

/// Helper to extract a post-instruction symbol if one has been added.
MCSymbol *getPostInstrSymbol() const {
  if (!Info)
    return nullptr;
  if (MCSymbol *S = Info.get<EIIK_PostInstrSymbol>())
    return S;
  if (ExtraInfo *EI = Info.get<EIIK_OutOfLine>())
    return EI->getPostInstrSymbol();

  return nullptr;
}

/// Helper to extract a heap alloc marker if one has been added.
MDNode *getHeapAllocMarker() const {
  if (!Info)
    return nullptr;
  if (ExtraInfo *EI = Info.get<EIIK_OutOfLine>())
    return EI->getHeapAllocMarker();

  return nullptr;
}

/// API for querying MachineInstr properties. They are the same as MCInstrDesc
/// queries but they are bundle aware.

enum QueryType {
  IgnoreBundle,    // Ignore bundles
  AnyInBundle,     // Return true if any instruction in bundle has property
  AllInBundle      // Return true if all instructions in bundle have property
};

/// Return true if the instruction (or in the case of a bundle,
/// the instructions inside the bundle) has the specified property.
/// The first argument is the property being queried.
/// The second argument indicates whether the query should look inside
/// instruction bundles.
bool hasProperty(unsigned MCFlag, QueryType Type = AnyInBundle) const {
  assert(MCFlag < 64 &&(static_cast <bool> (MCFlag < 64 && "MCFlag out of range for bit mask in getFlags/hasPropertyInBundle."
) ? void (0) : __assert_fail ("MCFlag < 64 && \"MCFlag out of range for bit mask in getFlags/hasPropertyInBundle.\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/CodeGen/MachineInstr.h"
, 778, __extension__ __PRETTY_FUNCTION__))
         "MCFlag out of range for bit mask in getFlags/hasPropertyInBundle.")(static_cast <bool> (MCFlag < 64 && "MCFlag out of range for bit mask in getFlags/hasPropertyInBundle."
) ? void (0) : __assert_fail ("MCFlag < 64 && \"MCFlag out of range for bit mask in getFlags/hasPropertyInBundle.\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/CodeGen/MachineInstr.h"
, 778, __extension__ __PRETTY_FUNCTION__));
  // Inline the fast path for unbundled or bundle-internal instructions.
  if (Type == IgnoreBundle || !isBundled() || isBundledWithPred())
    return getDesc().getFlags() & (1ULL << MCFlag);

  // If this is the first instruction in a bundle, take the slow path.
  return hasPropertyInBundle(1ULL << MCFlag, Type);
}

/// Return true if this is an instruction that should go through the usual
/// legalization steps.
bool isPreISelOpcode(QueryType Type = IgnoreBundle) const {
  return hasProperty(MCID::PreISelOpcode, Type);
}

/// Return true if this instruction can have a variable number of operands.
/// In this case, the variable operands will be after the normal
/// operands but before the implicit definitions and uses (if any are
/// present).
bool isVariadic(QueryType Type = IgnoreBundle) const {
  return hasProperty(MCID::Variadic, Type);
}

/// Set if this instruction has an optional definition, e.g.
/// ARM instructions which can set condition code if 's' bit is set.
bool hasOptionalDef(QueryType Type = IgnoreBundle) const {
  return hasProperty(MCID::HasOptionalDef, Type);
}

/// Return true if this is a pseudo instruction that doesn't
/// correspond to a real machine instruction.
bool isPseudo(QueryType Type = IgnoreBundle) const {
  return hasProperty(MCID::Pseudo, Type);
}

bool isReturn(QueryType Type = AnyInBundle) const {
  return hasProperty(MCID::Return, Type);
}

/// Return true if this is an instruction that marks the end of an EH scope,
/// i.e., a catchpad or a cleanuppad instruction.
bool isEHScopeReturn(QueryType Type = AnyInBundle) const {
  return hasProperty(MCID::EHScopeReturn, Type);
}

bool isCall(QueryType Type = AnyInBundle) const {
  return hasProperty(MCID::Call, Type);
}

/// Return true if this is a call instruction that may have an associated
/// call site entry in the debug info.
bool isCandidateForCallSiteEntry(QueryType Type = IgnoreBundle) const;
/// Return true if copying, moving, or erasing this instruction requires
/// updating Call Site Info (see \ref copyCallSiteInfo, \ref moveCallSiteInfo,
/// \ref eraseCallSiteInfo).
bool shouldUpdateCallSiteInfo() const;

/// Returns true if the specified instruction stops control flow
/// from executing the instruction immediately following it.  Examples include
/// unconditional branches and return instructions.
bool isBarrier(QueryType Type = AnyInBundle) const {
  return hasProperty(MCID::Barrier, Type);
}

/// Returns true if this instruction part of the terminator for a basic block.
/// Typically this is things like return and branch instructions.
///
/// Various passes use this to insert code into the bottom of a basic block,
/// but before control flow occurs.
bool isTerminator(QueryType Type = AnyInBundle) const {
  return hasProperty(MCID::Terminator, Type);
}

/// Returns true if this is a conditional, unconditional, or indirect branch.
/// Predicates below can be used to discriminate between
/// these cases, and the TargetInstrInfo::analyzeBranch method can be used to
/// get more information.
bool isBranch(QueryType Type = AnyInBundle) const {
  return hasProperty(MCID::Branch, Type);
}

/// Return true if this is an indirect branch, such as a
/// branch through a register.
bool isIndirectBranch(QueryType Type = AnyInBundle) const {
  return hasProperty(MCID::IndirectBranch, Type);
}

/// Return true if this is a branch which may fall
/// through to the next instruction or may transfer control flow to some other
/// block.  The TargetInstrInfo::analyzeBranch method can be used to get more
/// information about this branch.
bool isConditionalBranch(QueryType Type = AnyInBundle) const {
  return isBranch(Type) && !isBarrier(Type) && !isIndirectBranch(Type);
}

/// Return true if this is a branch which always
/// transfers control flow to some other block.  The
/// TargetInstrInfo::analyzeBranch method can be used to get more information
/// about this branch.
bool isUnconditionalBranch(QueryType Type = AnyInBundle) const {
  return isBranch(Type) && isBarrier(Type) && !isIndirectBranch(Type);
}

/// Return true if this instruction has a predicate operand that
/// controls execution.  It may be set to 'always', or may be set to other
/// values.   There are various methods in TargetInstrInfo that can be used to
/// control and modify the predicate in this instruction.
bool isPredicable(QueryType Type = AllInBundle) const {
  // If it's a bundle than all bundled instructions must be predicable for this
  // to return true.
  return hasProperty(MCID::Predicable, Type);
}

/// Return true if this instruction is a comparison.
bool isCompare(QueryType Type = IgnoreBundle) const {
  return hasProperty(MCID::Compare, Type);
}

/// Return true if this instruction is a move immediate
/// (including conditional moves) instruction.
bool isMoveImmediate(QueryType Type = IgnoreBundle) const {
  return hasProperty(MCID::MoveImm, Type);
}

/// Return true if this instruction is a register move.
/// (including moving values from subreg to reg)
bool isMoveReg(QueryType Type = IgnoreBundle) const {
  return hasProperty(MCID::MoveReg, Type);
}

/// Return true if this instruction is a bitcast instruction.
bool isBitcast(QueryType Type = IgnoreBundle) const {
  return hasProperty(MCID::Bitcast, Type);
}

/// Return true if this instruction is a select instruction.
bool isSelect(QueryType Type = IgnoreBundle) const {
  return hasProperty(MCID::Select, Type);
}

/// Return true if this instruction cannot be safely duplicated.
/// For example, if the instruction has a unique labels attached
/// to it, duplicating it would cause multiple definition errors.
bool isNotDuplicable(QueryType Type = AnyInBundle) const {
  return hasProperty(MCID::NotDuplicable, Type);
}

/// Return true if this instruction is convergent.
/// Convergent instructions can not be made control-dependent on any
/// additional values.
bool isConvergent(QueryType Type = AnyInBundle) const {
  if (isInlineAsm()) {
    unsigned ExtraInfo = getOperand(InlineAsm::MIOp_ExtraInfo).getImm();
    if (ExtraInfo & InlineAsm::Extra_IsConvergent)
      return true;
  }
  return hasProperty(MCID::Convergent, Type);
}

/// Returns true if the specified instruction has a delay slot
/// which must be filled by the code generator.
bool hasDelaySlot(QueryType Type = AnyInBundle) const {
  return hasProperty(MCID::DelaySlot, Type);
}

/// Return true for instructions that can be folded as
/// memory operands in other instructions. The most common use for this
/// is instructions that are simple loads from memory that don't modify
/// the loaded value in any way, but it can also be used for instructions
/// that can be expressed as constant-pool loads, such as V_SETALLONES
/// on x86, to allow them to be folded when it is beneficial.
/// This should only be set on instructions that return a value in their
/// only virtual register definition.
bool canFoldAsLoad(QueryType Type = IgnoreBundle) const {
  return hasProperty(MCID::FoldableAsLoad, Type);
}

/// Return true if this instruction behaves
/// the same way as the generic REG_SEQUENCE instructions.
/// E.g., on ARM,
/// dX VMOVDRR rY, rZ
/// is equivalent to
/// dX = REG_SEQUENCE rY, ssub_0, rZ, ssub_1.
///
/// Note that for the optimizers to be able to take advantage of
/// this property, TargetInstrInfo::getRegSequenceLikeInputs has to be
/// override accordingly.
bool isRegSequenceLike(QueryType Type = IgnoreBundle) const {
  return hasProperty(MCID::RegSequence, Type);
}

/// Return true if this instruction behaves
/// the same way as the generic EXTRACT_SUBREG instructions.
/// E.g., on ARM,
/// rX, rY VMOVRRD dZ
/// is equivalent to two EXTRACT_SUBREG:
/// rX = EXTRACT_SUBREG dZ, ssub_0
/// rY = EXTRACT_SUBREG dZ, ssub_1
///
/// Note that for the optimizers to be able to take advantage of
/// this property, TargetInstrInfo::getExtractSubregLikeInputs has to be
/// override accordingly.
bool isExtractSubregLike(QueryType Type = IgnoreBundle) const {
  return hasProperty(MCID::ExtractSubreg, Type);
}

/// Return true if this instruction behaves
/// the same way as the generic INSERT_SUBREG instructions.
/// E.g., on ARM,
/// dX = VSETLNi32 dY, rZ, Imm
/// is equivalent to a INSERT_SUBREG:
/// dX = INSERT_SUBREG dY, rZ, translateImmToSubIdx(Imm)
///
/// Note that for the optimizers to be able to take advantage of
/// this property, TargetInstrInfo::getInsertSubregLikeInputs has to be
/// override accordingly.
bool isInsertSubregLike(QueryType Type = IgnoreBundle) const {
  return hasProperty(MCID::InsertSubreg, Type);
}

//===--------------------------------------------------------------------===//
// Side Effect Analysis
//===--------------------------------------------------------------------===//

/// Return true if this instruction could possibly read memory.
/// Instructions with this flag set are not necessarily simple load
/// instructions, they may load a value and modify it, for example.
bool mayLoad(QueryType Type = AnyInBundle) const {
  if (isInlineAsm()) {
    unsigned ExtraInfo = getOperand(InlineAsm::MIOp_ExtraInfo).getImm();
    if (ExtraInfo & InlineAsm::Extra_MayLoad)
      return true;
  }
  return hasProperty(MCID::MayLoad, Type);
}

/// Return true if this instruction could possibly modify memory.
/// Instructions with this flag set are not necessarily simple store
/// instructions, they may store a modified value based on their operands, or
/// may not actually modify anything, for example.
bool mayStore(QueryType Type = AnyInBundle) const {
  if (isInlineAsm()) {
    unsigned ExtraInfo = getOperand(InlineAsm::MIOp_ExtraInfo).getImm();
    if (ExtraInfo & InlineAsm::Extra_MayStore)
      return true;
  }
  return hasProperty(MCID::MayStore, Type);
}

/// Return true if this instruction could possibly read or modify memory.
bool mayLoadOrStore(QueryType Type = AnyInBundle) const {
  return mayLoad(Type) || mayStore(Type);
}

/// Return true if this instruction could possibly raise a floating-point
/// exception.  This is the case if the instruction is a floating-point
/// instruction that can in principle raise an exception, as indicated
/// by the MCID::MayRaiseFPException property, *and* at the same time,
/// the instruction is used in a context where we expect floating-point
/// exceptions are not disabled, as indicated by the NoFPExcept MI flag.
bool mayRaiseFPException() const {
  return hasProperty(MCID::MayRaiseFPException) &&
         !getFlag(MachineInstr::MIFlag::NoFPExcept);
}

//===--------------------------------------------------------------------===//
// Flags that indicate whether an instruction can be modified by a method.
//===--------------------------------------------------------------------===//

/// Return true if this may be a 2- or 3-address
/// instruction (of the form "X = op Y, Z, ..."), which produces the same
/// result if Y and Z are exchanged.  If this flag is set, then the
/// TargetInstrInfo::commuteInstruction method may be used to hack on the
/// instruction.
///
/// Note that this flag may be set on instructions that are only commutable
/// sometimes.  In these cases, the call to commuteInstruction will fail.
/// Also note that some instructions require non-trivial modification to
/// commute them.
bool isCommutable(QueryType Type = IgnoreBundle) const {
  return hasProperty(MCID::Commutable, Type);
}

/// Return true if this is a 2-address instruction
/// which can be changed into a 3-address instruction if needed.  Doing this
/// transformation can be profitable in the register allocator, because it
/// means that the instruction can use a 2-address form if possible, but
/// degrade into a less efficient form if the source and dest register cannot
/// be assigned to the same register.  For example, this allows the x86
/// backend to turn a "shl reg, 3" instruction into an LEA instruction, which
/// is the same speed as the shift but has bigger code size.
///
/// If this returns true, then the target must implement the
/// TargetInstrInfo::convertToThreeAddress method for this instruction, which
/// is allowed to fail if the transformation isn't valid for this specific
/// instruction (e.g. shl reg, 4 on x86).
///
bool isConvertibleTo3Addr(QueryType Type = IgnoreBundle) const {
  return hasProperty(MCID::ConvertibleTo3Addr, Type);
}

/// Return true if this instruction requires
/// custom insertion support when the DAG scheduler is inserting it into a
/// machine basic block.  If this is true for the instruction, it basically
/// means that it is a pseudo instruction used at SelectionDAG time that is
/// expanded out into magic code by the target when MachineInstrs are formed.
///
/// If this is true, the TargetLoweringInfo::InsertAtEndOfBasicBlock method
/// is used to insert this into the MachineBasicBlock.
bool usesCustomInsertionHook(QueryType Type = IgnoreBundle) const {
  return hasProperty(MCID::UsesCustomInserter, Type);
}

/// Return true if this instruction requires *adjustment*
/// after instruction selection by calling a target hook. For example, this
/// can be used to fill in ARM 's' optional operand depending on whether
/// the conditional flag register is used.
bool hasPostISelHook(QueryType Type = IgnoreBundle) const {
  return hasProperty(MCID::HasPostISelHook, Type);
}

/// Returns true if this instruction is a candidate for remat.
/// This flag is deprecated, please don't use it anymore.  If this
/// flag is set, the isReallyTriviallyReMaterializable() method is called to
/// verify the instruction is really rematable.
bool isRematerializable(QueryType Type = AllInBundle) const {
  // It's only possible to re-mat a bundle if all bundled instructions are
  // re-materializable.
  return hasProperty(MCID::Rematerializable, Type);
}

/// Returns true if this instruction has the same cost (or less) than a move
/// instruction. This is useful during certain types of optimizations
/// (e.g., remat during two-address conversion or machine licm)
/// where we would like to remat or hoist the instruction, but not if it costs
/// more than moving the instruction into the appropriate register. Note, we
/// are not marking copies from and to the same register class with this flag.
bool isAsCheapAsAMove(QueryType Type = AllInBundle) const {
  // Only returns true for a bundle if all bundled instructions are cheap.
  return hasProperty(MCID::CheapAsAMove, Type);
}

/// Returns true if this instruction source operands
/// have special register allocation requirements that are not captured by the
/// operand register classes. e.g. ARM::STRD's two source registers must be an
/// even / odd pair, ARM::STM registers have to be in ascending order.
/// Post-register allocation passes should not attempt to change allocations
/// for sources of instructions with this flag.
bool hasExtraSrcRegAllocReq(QueryType Type = AnyInBundle) const {
  return hasProperty(MCID::ExtraSrcRegAllocReq, Type);
}

/// Returns true if this instruction def operands
/// have special register allocation requirements that are not captured by the
/// operand register classes. e.g. ARM::LDRD's two def registers must be an
/// even / odd pair, ARM::LDM registers have to be in ascending order.
/// Post-register allocation passes should not attempt to change allocations
/// for definitions of instructions with this flag.
bool hasExtraDefRegAllocReq(QueryType Type = AnyInBundle) const {
  return hasProperty(MCID::ExtraDefRegAllocReq, Type);
}

enum MICheckType {
  CheckDefs,      // Check all operands for equality
  CheckKillDead,  // Check all operands including kill / dead markers
  IgnoreDefs,     // Ignore all definitions
  IgnoreVRegDefs  // Ignore virtual register definitions
};

/// Return true if this instruction is identical to \p Other.
/// Two instructions are identical if they have the same opcode and all their
/// operands are identical (with respect to MachineOperand::isIdenticalTo()).
/// Note that this means liveness related flags (dead, undef, kill) do not
/// affect the notion of identical.
bool isIdenticalTo(const MachineInstr &Other,
                   MICheckType Check = CheckDefs) const;

/// Unlink 'this' from the containing basic block, and return it without
/// deleting it.
///
/// This function can not be used on bundled instructions, use
/// removeFromBundle() to remove individual instructions from a bundle.
MachineInstr *removeFromParent();

/// Unlink this instruction from its basic block and return it without
/// deleting it.
///
/// If the instruction is part of a bundle, the other instructions in the
/// bundle remain bundled.
MachineInstr *removeFromBundle();

/// Unlink 'this' from the containing basic block and delete it.
///
/// If this instruction is the header of a bundle, the whole bundle is erased.
/// This function can not be used for instructions inside a bundle, use
/// eraseFromBundle() to erase individual bundled instructions.
void eraseFromParent();

/// Unlink 'this' from the containing basic block and delete it.
///
/// For all definitions mark their uses in DBG_VALUE nodes
/// as undefined. Otherwise like eraseFromParent().
void eraseFromParentAndMarkDBGValuesForRemoval();

/// Unlink 'this' form its basic block and delete it.
///
/// If the instruction is part of a bundle, the other instructions in the
/// bundle remain bundled.
void eraseFromBundle();

bool isEHLabel() const { return getOpcode() == TargetOpcode::EH_LABEL; }
bool isGCLabel() const { return getOpcode() == TargetOpcode::GC_LABEL; }
bool isAnnotationLabel() const {
  return getOpcode() == TargetOpcode::ANNOTATION_LABEL;
}

/// Returns true if the MachineInstr represents a label.
bool isLabel() const {
  return isEHLabel() || isGCLabel() || isAnnotationLabel();
}

bool isCFIInstruction() const {
  return getOpcode() == TargetOpcode::CFI_INSTRUCTION;
}

bool isPseudoProbe() const {
  return getOpcode() == TargetOpcode::PSEUDO_PROBE;
}

// True if the instruction represents a position in the function.
bool isPosition() const { return isLabel() || isCFIInstruction(); }

bool isNonListDebugValue() const {
  return getOpcode() == TargetOpcode::DBG_VALUE;
}
bool isDebugValueList() const {
  return getOpcode() == TargetOpcode::DBG_VALUE_LIST;
}
bool isDebugValue() const {
  return isNonListDebugValue() || isDebugValueList();
56
←
Returning zero, which participates in a condition later→
}
bool isDebugLabel() const { return getOpcode() == TargetOpcode::DBG_LABEL; }
bool isDebugRef() const { return getOpcode() == TargetOpcode::DBG_INSTR_REF; }
65
←
Assuming the condition is true→
66
←
Returning the value 1, which participates in a condition later→
bool isDebugPHI() const { return getOpcode() == TargetOpcode::DBG_PHI; }
bool isDebugInstr() const {
  return isDebugValue() || isDebugLabel() || isDebugRef() || isDebugPHI();
}
bool isDebugOrPseudoInstr() const {
  return isDebugInstr() || isPseudoProbe();
}

bool isDebugOffsetImm() const {
  return isNonListDebugValue() && getDebugOffset().isImm();
}

/// A DBG_VALUE is indirect iff the location operand is a register and
/// the offset operand is an immediate.
bool isIndirectDebugValue() const {
  return isDebugOffsetImm() && getDebugOperand(0).isReg();
}

/// A DBG_VALUE is an entry value iff its debug expression contains the
/// DW_OP_LLVM_entry_value operation.
bool isDebugEntryValue() const;

/// Return true if the instruction is a debug value which describes a part of
/// a variable as unavailable.
bool isUndefDebugValue() const {
  if (!isDebugValue())
    return false;
  // If any $noreg locations are given, this DV is undef.
  for (const MachineOperand &Op : debug_operands())
    if (Op.isReg() && !Op.getReg().isValid())
      return true;
  return false;
}

bool isPHI() const {
  return getOpcode() == TargetOpcode::PHI ||
         getOpcode() == TargetOpcode::G_PHI;
}
bool isKill() const { return getOpcode() == TargetOpcode::KILL; }
bool isImplicitDef() const { return getOpcode()==TargetOpcode::IMPLICIT_DEF; }
bool isInlineAsm() const {
  return getOpcode() == TargetOpcode::INLINEASM ||
         getOpcode() == TargetOpcode::INLINEASM_BR;
}

/// FIXME: Seems like a layering violation that the AsmDialect, which is X86
/// specific, be attached to a generic MachineInstr.
bool isMSInlineAsm() const {
  return isInlineAsm() && getInlineAsmDialect() == InlineAsm::AD_Intel;
}

bool isStackAligningInlineAsm() const;
InlineAsm::AsmDialect getInlineAsmDialect() const;

bool isInsertSubreg() const {
  return getOpcode() == TargetOpcode::INSERT_SUBREG;
}

bool isSubregToReg() const {
  return getOpcode() == TargetOpcode::SUBREG_TO_REG;
}

bool isRegSequence() const {
  return getOpcode() == TargetOpcode::REG_SEQUENCE;
}

bool isBundle() const {
  return getOpcode() == TargetOpcode::BUNDLE;
}

bool isCopy() const {
  return getOpcode() == TargetOpcode::COPY;
}

bool isFullCopy() const {
  return isCopy() && !getOperand(0).getSubReg() && !getOperand(1).getSubReg();
}

bool isExtractSubreg() const {
  return getOpcode() == TargetOpcode::EXTRACT_SUBREG;
}

/// Return true if the instruction behaves like a copy.
/// This does not include native copy instructions.
bool isCopyLike() const {
  return isCopy() || isSubregToReg();
}

/// Return true is the instruction is an identity copy.
bool isIdentityCopy() const {
  return isCopy() && getOperand(0).getReg() == getOperand(1).getReg() &&
    getOperand(0).getSubReg() == getOperand(1).getSubReg();
}

/// Return true if this instruction doesn't produce any output in the form of
/// executable instructions.
bool isMetaInstruction() const {
  switch (getOpcode()) {
  default:
    return false;
  case TargetOpcode::IMPLICIT_DEF:
  case TargetOpcode::KILL:
  case TargetOpcode::CFI_INSTRUCTION:
  case TargetOpcode::EH_LABEL:
  case TargetOpcode::GC_LABEL:
  case TargetOpcode::DBG_VALUE:
  case TargetOpcode::DBG_VALUE_LIST:
  case TargetOpcode::DBG_INSTR_REF:
  case TargetOpcode::DBG_PHI:
  case TargetOpcode::DBG_LABEL:
  case TargetOpcode::LIFETIME_START:
  case TargetOpcode::LIFETIME_END:
  case TargetOpcode::PSEUDO_PROBE:
    return true;
  }
}

/// Return true if this is a transient instruction that is either very likely
/// to be eliminated during register allocation (such as copy-like
/// instructions), or if this instruction doesn't have an execution-time cost.
bool isTransient() const {
  switch (getOpcode()) {
  default:
    return isMetaInstruction();
  // Copy-like instructions are usually eliminated during register allocation.
  case TargetOpcode::PHI:
  case TargetOpcode::G_PHI:
  case TargetOpcode::COPY:
  case TargetOpcode::INSERT_SUBREG:
  case TargetOpcode::SUBREG_TO_REG:
  case TargetOpcode::REG_SEQUENCE:
    return true;
  }
}

/// Return the number of instructions inside the MI bundle, excluding the
/// bundle header.
///
/// This is the number of instructions that MachineBasicBlock::iterator
/// skips, 0 for unbundled instructions.
unsigned getBundleSize() const;

/// Return true if the MachineInstr reads the specified register.
/// If TargetRegisterInfo is passed, then it also checks if there
/// is a read of a super-register.
/// This does not count partial redefines of virtual registers as reads:
///   %reg1024:6 = OP.
bool readsRegister(Register Reg,
                   const TargetRegisterInfo *TRI = nullptr) const {
  return findRegisterUseOperandIdx(Reg, false, TRI) != -1;
}

/// Return true if the MachineInstr reads the specified virtual register.
/// Take into account that a partial define is a
/// read-modify-write operation.
bool readsVirtualRegister(Register Reg) const {
  return readsWritesVirtualRegister(Reg).first;
}

/// Return a pair of bools (reads, writes) indicating if this instruction
/// reads or writes Reg. This also considers partial defines.
/// If Ops is not null, all operand indices for Reg are added.
std::pair<bool,bool> readsWritesVirtualRegister(Register Reg,
                              SmallVectorImpl<unsigned> *Ops = nullptr) const;

/// Return true if the MachineInstr kills the specified register.
/// If TargetRegisterInfo is passed, then it also checks if there is
/// a kill of a super-register.
bool killsRegister(Register Reg,
                   const TargetRegisterInfo *TRI = nullptr) const {
  return findRegisterUseOperandIdx(Reg, true, TRI) != -1;
}

/// Return true if the MachineInstr fully defines the specified register.
/// If TargetRegisterInfo is passed, then it also checks
/// if there is a def of a super-register.
/// NOTE: It's ignoring subreg indices on virtual registers.
bool definesRegister(Register Reg,
                     const TargetRegisterInfo *TRI = nullptr) const {
  return findRegisterDefOperandIdx(Reg, false, false, TRI) != -1;
}

/// Return true if the MachineInstr modifies (fully define or partially
/// define) the specified register.
/// NOTE: It's ignoring subreg indices on virtual registers.
bool modifiesRegister(Register Reg,
                      const TargetRegisterInfo *TRI = nullptr) const {
  return findRegisterDefOperandIdx(Reg, false, true, TRI) != -1;
}

/// Returns true if the register is dead in this machine instruction.
/// If TargetRegisterInfo is passed, then it also checks
/// if there is a dead def of a super-register.
bool registerDefIsDead(Register Reg,
                       const TargetRegisterInfo *TRI = nullptr) const {
  return findRegisterDefOperandIdx(Reg, true, false, TRI) != -1;
}

/// Returns true if the MachineInstr has an implicit-use operand of exactly
/// the given register (not considering sub/super-registers).
bool hasRegisterImplicitUseOperand(Register Reg) const;

/// Returns the operand index that is a use of the specific register or -1
/// if it is not found. It further tightens the search criteria to a use
/// that kills the register if isKill is true.
int findRegisterUseOperandIdx(Register Reg, bool isKill = false,
                              const TargetRegisterInfo *TRI = nullptr) const;

/// Wrapper for findRegisterUseOperandIdx, it returns
/// a pointer to the MachineOperand rather than an index.
MachineOperand *findRegisterUseOperand(Register Reg, bool isKill = false,
                                    const TargetRegisterInfo *TRI = nullptr) {
  int Idx = findRegisterUseOperandIdx(Reg, isKill, TRI);
  return (Idx == -1) ? nullptr : &getOperand(Idx);
}

const MachineOperand *findRegisterUseOperand(
  Register Reg, bool isKill = false,
  const TargetRegisterInfo *TRI = nullptr) const {
  return const_cast<MachineInstr *>(this)->
    findRegisterUseOperand(Reg, isKill, TRI);
}

/// Returns the operand index that is a def of the specified register or
/// -1 if it is not found. If isDead is true, defs that are not dead are
/// skipped. If Overlap is true, then it also looks for defs that merely
/// overlap the specified register. If TargetRegisterInfo is non-null,
/// then it also checks if there is a def of a super-register.
/// This may also return a register mask operand when Overlap is true.
int findRegisterDefOperandIdx(Register Reg,
                              bool isDead = false, bool Overlap = false,
                              const TargetRegisterInfo *TRI = nullptr) const;

/// Wrapper for findRegisterDefOperandIdx, it returns
/// a pointer to the MachineOperand rather than an index.
MachineOperand *
findRegisterDefOperand(Register Reg, bool isDead = false,
                       bool Overlap = false,
                       const TargetRegisterInfo *TRI = nullptr) {
  int Idx = findRegisterDefOperandIdx(Reg, isDead, Overlap, TRI);
  return (Idx == -1) ? nullptr : &getOperand(Idx);
}

const MachineOperand *
findRegisterDefOperand(Register Reg, bool isDead = false,
                       bool Overlap = false,
                       const TargetRegisterInfo *TRI = nullptr) const {
  return const_cast<MachineInstr *>(this)->findRegisterDefOperand(
      Reg, isDead, Overlap, TRI);
}

/// Find the index of the first operand in the
/// operand list that is used to represent the predicate. It returns -1 if
/// none is found.
int findFirstPredOperandIdx() const;

/// Find the index of the flag word operand that
/// corresponds to operand OpIdx on an inline asm instruction.  Returns -1 if
/// getOperand(OpIdx) does not belong to an inline asm operand group.
///
/// If GroupNo is not NULL, it will receive the number of the operand group
/// containing OpIdx.
int findInlineAsmFlagIdx(unsigned OpIdx, unsigned *GroupNo = nullptr) const;

/// Compute the static register class constraint for operand OpIdx.
/// For normal instructions, this is derived from the MCInstrDesc.
/// For inline assembly it is derived from the flag words.
///
/// Returns NULL if the static register class constraint cannot be
/// determined.
const TargetRegisterClass*
getRegClassConstraint(unsigned OpIdx,
                      const TargetInstrInfo *TII,
                      const TargetRegisterInfo *TRI) const;

/// Applies the constraints (def/use) implied by this MI on \p Reg to
/// the given \p CurRC.
/// If \p ExploreBundle is set and MI is part of a bundle, all the
/// instructions inside the bundle will be taken into account. In other words,
/// this method accumulates all the constraints of the operand of this MI and
/// the related bundle if MI is a bundle or inside a bundle.
///
/// Returns the register class that satisfies both \p CurRC and the
/// constraints set by MI. Returns NULL if such a register class does not
/// exist.
///
/// \pre CurRC must not be NULL.
const TargetRegisterClass *getRegClassConstraintEffectForVReg(
    Register Reg, const TargetRegisterClass *CurRC,
    const TargetInstrInfo *TII, const TargetRegisterInfo *TRI,
    bool ExploreBundle = false) const;

/// Applies the constraints (def/use) implied by the \p OpIdx operand
/// to the given \p CurRC.
///
/// Returns the register class that satisfies both \p CurRC and the
/// constraints set by \p OpIdx MI. Returns NULL if such a register class
/// does not exist.
///
/// \pre CurRC must not be NULL.
/// \pre The operand at \p OpIdx must be a register.
const TargetRegisterClass *
getRegClassConstraintEffect(unsigned OpIdx, const TargetRegisterClass *CurRC,
                            const TargetInstrInfo *TII,
                            const TargetRegisterInfo *TRI) const;

/// Add a tie between the register operands at DefIdx and UseIdx.
/// The tie will cause the register allocator to ensure that the two
/// operands are assigned the same physical register.
///
/// Tied operands are managed automatically for explicit operands in the
/// MCInstrDesc. This method is for exceptional cases like inline asm.
void tieOperands(unsigned DefIdx, unsigned UseIdx);

/// Given the index of a tied register operand, find the
/// operand it is tied to. Defs are tied to uses and vice versa. Returns the
/// index of the tied operand which must exist.
unsigned findTiedOperandIdx(unsigned OpIdx) const;

/// Given the index of a register def operand,
/// check if the register def is tied to a source operand, due to either
/// two-address elimination or inline assembly constraints. Returns the
/// first tied use operand index by reference if UseOpIdx is not null.
bool isRegTiedToUseOperand(unsigned DefOpIdx,
                           unsigned *UseOpIdx = nullptr) const {
  const MachineOperand &MO = getOperand(DefOpIdx);
  if (!MO.isReg() || !MO.isDef() || !MO.isTied())
    return false;
  if (UseOpIdx)
    *UseOpIdx = findTiedOperandIdx(DefOpIdx);
  return true;
}

/// Return true if the use operand of the specified index is tied to a def
/// operand. It also returns the def operand index by reference if DefOpIdx
/// is not null.
bool isRegTiedToDefOperand(unsigned UseOpIdx,
                           unsigned *DefOpIdx = nullptr) const {
  const MachineOperand &MO = getOperand(UseOpIdx);
  if (!MO.isReg() || !MO.isUse() || !MO.isTied())
    return false;
  if (DefOpIdx)
    *DefOpIdx = findTiedOperandIdx(UseOpIdx);
  return true;
}

/// Clears kill flags on all operands.
void clearKillInfo();

/// Replace all occurrences of FromReg with ToReg:SubIdx,
/// properly composing subreg indices where necessary.
void substituteRegister(Register FromReg, Register ToReg, unsigned SubIdx,
                        const TargetRegisterInfo &RegInfo);

/// We have determined MI kills a register. Look for the
/// operand that uses it and mark it as IsKill. If AddIfNotFound is true,
/// add a implicit operand if it's not found. Returns true if the operand
/// exists / is added.
bool addRegisterKilled(Register IncomingReg,
                       const TargetRegisterInfo *RegInfo,
                       bool AddIfNotFound = false);

/// Clear all kill flags affecting Reg.  If RegInfo is provided, this includes
/// all aliasing registers.
void clearRegisterKills(Register Reg, const TargetRegisterInfo *RegInfo);

/// We have determined MI defined a register without a use.
/// Look for the operand that defines it and mark it as IsDead. If
/// AddIfNotFound is true, add a implicit operand if it's not found. Returns
/// true if the operand exists / is added.
bool addRegisterDead(Register Reg, const TargetRegisterInfo *RegInfo,
                     bool AddIfNotFound = false);

/// Clear all dead flags on operands defining register @p Reg.
void clearRegisterDeads(Register Reg);

/// Mark all subregister defs of register @p Reg with the undef flag.
/// This function is used when we determined to have a subregister def in an
/// otherwise undefined super register.
void setRegisterDefReadUndef(Register Reg, bool IsUndef = true);

/// We have determined MI defines a register. Make sure there is an operand
/// defining Reg.
void addRegisterDefined(Register Reg,
                        const TargetRegisterInfo *RegInfo = nullptr);

/// Mark every physreg used by this instruction as
/// dead except those in the UsedRegs list.
///
/// On instructions with register mask operands, also add implicit-def
/// operands for all registers in UsedRegs.
void setPhysRegsDeadExcept(ArrayRef<Register> UsedRegs,
                           const TargetRegisterInfo &TRI);

/// Return true if it is safe to move this instruction. If
/// SawStore is set to true, it means that there is a store (or call) between
/// the instruction's location and its intended destination.
bool isSafeToMove(AAResults *AA, bool &SawStore) const;

/// Returns true if this instruction's memory access aliases the memory
/// access of Other.
//
/// Assumes any physical registers used to compute addresses
/// have the same value for both instructions.  Returns false if neither
/// instruction writes to memory.
///
/// @param AA Optional alias analysis, used to compare memory operands.
/// @param Other MachineInstr to check aliasing against.
/// @param UseTBAA Whether to pass TBAA information to alias analysis.
bool mayAlias(AAResults *AA, const MachineInstr &Other, bool UseTBAA) const;

/// Return true if this instruction may have an ordered
/// or volatile memory reference, or if the information describing the memory
/// reference is not available. Return false if it is known to have no
/// ordered or volatile memory references.
bool hasOrderedMemoryRef() const;

/// Return true if this load instruction never traps and points to a memory
/// location whose value doesn't change during the execution of this function.
///
/// Examples include loading a value from the constant pool or from the
/// argument area of a function (if it does not change).  If the instruction
/// does multiple loads, this returns true only if all of the loads are
/// dereferenceable and invariant.
bool isDereferenceableInvariantLoad(AAResults *AA) const;

/// If the specified instruction is a PHI that always merges together the
/// same virtual register, return the register, otherwise return 0.
unsigned isConstantValuePHI() const;

/// Return true if this instruction has side effects that are not modeled
/// by mayLoad / mayStore, etc.
/// For all instructions, the property is encoded in MCInstrDesc::Flags
/// (see MCInstrDesc::hasUnmodeledSideEffects(). The only exception is
/// INLINEASM instruction, in which case the side effect property is encoded
/// in one of its operands (see InlineAsm::Extra_HasSideEffect).
///
bool hasUnmodeledSideEffects() const;

/// Returns true if it is illegal to fold a load across this instruction.
bool isLoadFoldBarrier() const;

/// Return true if all the defs of this instruction are dead.
bool allDefsAreDead() const;

/// Return a valid size if the instruction is a spill instruction.
Optional<unsigned> getSpillSize(const TargetInstrInfo *TII) const;

/// Return a valid size if the instruction is a folded spill instruction.
Optional<unsigned> getFoldedSpillSize(const TargetInstrInfo *TII) const;

/// Return a valid size if the instruction is a restore instruction.
Optional<unsigned> getRestoreSize(const TargetInstrInfo *TII) const;

/// Return a valid size if the instruction is a folded restore instruction.
Optional<unsigned>
getFoldedRestoreSize(const TargetInstrInfo *TII) const;

/// Copy implicit register operands from specified
/// instruction to this instruction.
void copyImplicitOps(MachineFunction &MF, const MachineInstr &MI);

/// Debugging support
/// @{
/// Determine the generic type to be printed (if needed) on uses and defs.
LLT getTypeToPrint(unsigned OpIdx, SmallBitVector &PrintedTypes,
                   const MachineRegisterInfo &MRI) const;

/// Return true when an instruction has tied register that can't be determined
/// by the instruction's descriptor. This is useful for MIR printing, to
/// determine whether we need to print the ties or not.
bool hasComplexRegisterTies() const;

/// Print this MI to \p OS.
/// Don't print information that can be inferred from other instructions if
/// \p IsStandalone is false. It is usually true when only a fragment of the
/// function is printed.
/// Only print the defs and the opcode if \p SkipOpers is true.
/// Otherwise, also print operands if \p SkipDebugLoc is true.
/// Otherwise, also print the debug loc, with a terminating newline.
/// \p TII is used to print the opcode name.  If it's not present, but the
/// MI is in a function, the opcode will be printed using the function's TII.
void print(raw_ostream &OS, bool IsStandalone = true, bool SkipOpers = false,
           bool SkipDebugLoc = false, bool AddNewLine = true,
           const TargetInstrInfo *TII = nullptr) const;
void print(raw_ostream &OS, ModuleSlotTracker &MST, bool IsStandalone = true,
           bool SkipOpers = false, bool SkipDebugLoc = false,
           bool AddNewLine = true,
           const TargetInstrInfo *TII = nullptr) const;
void dump() const;
/// Print on dbgs() the current instruction and the instructions defining its
/// operands and so on until we reach \p MaxDepth.
void dumpr(const MachineRegisterInfo &MRI,
           unsigned MaxDepth = UINT_MAX(2147483647 *2U +1U)) const;
/// @}

//===--------------------------------------------------------------------===//
// Accessors used to build up machine instructions.

/// Add the specified operand to the instruction.  If it is an implicit
/// operand, it is added to the end of the operand list.  If it is an
/// explicit operand it is added at the end of the explicit operand list
/// (before the first implicit operand).
///
/// MF must be the machine function that was used to allocate this
/// instruction.
///
/// MachineInstrBuilder provides a more convenient interface for creating
/// instructions and adding operands.
void addOperand(MachineFunction &MF, const MachineOperand &Op);

/// Add an operand without providing an MF reference. This only works for
/// instructions that are inserted in a basic block.
///
/// MachineInstrBuilder and the two-argument addOperand(MF, MO) should be
/// preferred.
void addOperand(const MachineOperand &Op);

/// Replace the instruction descriptor (thus opcode) of
/// the current instruction with a new one.
void setDesc(const MCInstrDesc &tid) { MCID = &tid; }

/// Replace current source information with new such.
/// Avoid using this, the constructor argument is preferable.
void setDebugLoc(DebugLoc dl) {
  debugLoc = std::move(dl);
  assert(debugLoc.hasTrivialDestructor() && "Expected trivial destructor")(static_cast <bool> (debugLoc.hasTrivialDestructor() &&
 "Expected trivial destructor") ? void (0) : __assert_fail ("debugLoc.hasTrivialDestructor() && \"Expected trivial destructor\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/CodeGen/MachineInstr.h"
, 1747, __extension__ __PRETTY_FUNCTION__));
}

/// Erase an operand from an instruction, leaving it with one
/// fewer operand than it started with.
void RemoveOperand(unsigned OpNo);

/// Clear this MachineInstr's memory reference descriptor list.  This resets
/// the memrefs to their most conservative state.  This should be used only
/// as a last resort since it greatly pessimizes our knowledge of the memory
/// access performed by the instruction.
void dropMemRefs(MachineFunction &MF);

/// Assign this MachineInstr's memory reference descriptor list.
///
/// Unlike other methods, this *will* allocate them into a new array
/// associated with the provided `MachineFunction`.
void setMemRefs(MachineFunction &MF, ArrayRef<MachineMemOperand *> MemRefs);

/// Add a MachineMemOperand to the machine instruction.
/// This function should be used only occasionally. The setMemRefs function
/// is the primary method for setting up a MachineInstr's MemRefs list.
void addMemOperand(MachineFunction &MF, MachineMemOperand *MO);

/// Clone another MachineInstr's memory reference descriptor list and replace
/// ours with it.
///
/// Note that `*this` may be the incoming MI!
///
/// Prefer this API whenever possible as it can avoid allocations in common
/// cases.
void cloneMemRefs(MachineFunction &MF, const MachineInstr &MI);

/// Clone the merge of multiple MachineInstrs' memory reference descriptors
/// list and replace ours with it.
///
/// Note that `*this` may be one of the incoming MIs!
///
/// Prefer this API whenever possible as it can avoid allocations in common
/// cases.
void cloneMergedMemRefs(MachineFunction &MF,
                        ArrayRef<const MachineInstr *> MIs);

/// Set a symbol that will be emitted just prior to the instruction itself.
///
/// Setting this to a null pointer will remove any such symbol.
///
/// FIXME: This is not fully implemented yet.
void setPreInstrSymbol(MachineFunction &MF, MCSymbol *Symbol);

/// Set a symbol that will be emitted just after the instruction itself.
///
/// Setting this to a null pointer will remove any such symbol.
///
/// FIXME: This is not fully implemented yet.
void setPostInstrSymbol(MachineFunction &MF, MCSymbol *Symbol);

/// Clone another MachineInstr's pre- and post- instruction symbols and
/// replace ours with it.
void cloneInstrSymbols(MachineFunction &MF, const MachineInstr &MI);

/// Set a marker on instructions that denotes where we should create and emit
/// heap alloc site labels. This waits until after instruction selection and
/// optimizations to create the label, so it should still work if the
/// instruction is removed or duplicated.
void setHeapAllocMarker(MachineFunction &MF, MDNode *MD);

/// Return the MIFlags which represent both MachineInstrs. This
/// should be used when merging two MachineInstrs into one. This routine does
/// not modify the MIFlags of this MachineInstr.
uint16_t mergeFlagsWith(const MachineInstr& Other) const;

static uint16_t copyFlagsFromInstruction(const Instruction &I);

/// Copy all flags to MachineInst MIFlags
void copyIRFlags(const Instruction &I);

/// Break any tie involving OpIdx.
void untieRegOperand(unsigned OpIdx) {
  MachineOperand &MO = getOperand(OpIdx);
  if (MO.isReg() && MO.isTied()) {
    getOperand(findTiedOperandIdx(OpIdx)).TiedTo = 0;
    MO.TiedTo = 0;
  }
}

/// Add all implicit def and use operands to this instruction.
void addImplicitDefUseOperands(MachineFunction &MF);

/// Scan instructions immediately following MI and collect any matching
/// DBG_VALUEs.
void collectDebugValues(SmallVectorImpl<MachineInstr *> &DbgValues);

/// Find all DBG_VALUEs that point to the register def in this instruction
/// and point them to \p Reg instead.
void changeDebugValuesDefReg(Register Reg);

/// Returns the Intrinsic::ID for this instruction.
/// \pre Must have an intrinsic ID operand.
unsigned getIntrinsicID() const {
  return getOperand(getNumExplicitDefs()).getIntrinsicID();
}

/// Sets all register debug operands in this debug value instruction to be
/// undef.
void setDebugValueUndef() {
  assert(isDebugValue() && "Must be a debug value instruction.")(static_cast <bool> (isDebugValue() && "Must be a debug value instruction."
) ? void (0) : __assert_fail ("isDebugValue() && \"Must be a debug value instruction.\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/CodeGen/MachineInstr.h"
, 1853, __extension__ __PRETTY_FUNCTION__));
  for (MachineOperand &MO : debug_operands()) {
    if (MO.isReg()) {
      MO.setReg(0);
      MO.setSubReg(0);
    }
  }
}

PseudoProbeAttributes getPseudoProbeAttribute() const {
  assert(isPseudoProbe() && "Must be a pseudo probe instruction")(static_cast <bool> (isPseudoProbe() && "Must be a pseudo probe instruction"
) ? void (0) : __assert_fail ("isPseudoProbe() && \"Must be a pseudo probe instruction\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/CodeGen/MachineInstr.h"
, 1863, __extension__ __PRETTY_FUNCTION__));
  return (PseudoProbeAttributes)getOperand(3).getImm();
}

void addPseudoProbeAttribute(PseudoProbeAttributes Attr) {
  assert(isPseudoProbe() && "Must be a pseudo probe instruction")(static_cast <bool> (isPseudoProbe() && "Must be a pseudo probe instruction"
) ? void (0) : __assert_fail ("isPseudoProbe() && \"Must be a pseudo probe instruction\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/CodeGen/MachineInstr.h"
, 1868, __extension__ __PRETTY_FUNCTION__));
  MachineOperand &AttrOperand = getOperand(3);
  AttrOperand.setImm(AttrOperand.getImm() | (uint32_t)Attr);
}

1873private:
/// If this instruction is embedded into a MachineFunction, return the
/// MachineRegisterInfo object for the current function, otherwise
/// return null.
MachineRegisterInfo *getRegInfo();

/// Unlink all of the register operands in this instruction from their
/// respective use lists.  This requires that the operands already be on their
/// use lists.
void RemoveRegOperandsFromUseLists(MachineRegisterInfo&);

/// Add all of the register operands in this instruction from their
/// respective use lists.  This requires that the operands not be on their
/// use lists yet.
void AddRegOperandsToUseLists(MachineRegisterInfo&);

/// Slow path for hasProperty when we're dealing with a bundle.
bool hasPropertyInBundle(uint64_t Mask, QueryType Type) const;

/// Implements the logic of getRegClassConstraintEffectForVReg for the
/// this MI and the given operand index \p OpIdx.
/// If the related operand does not constrained Reg, this returns CurRC.
const TargetRegisterClass *getRegClassConstraintEffectForVRegImpl(
    unsigned OpIdx, Register Reg, const TargetRegisterClass *CurRC,
    const TargetInstrInfo *TII, const TargetRegisterInfo *TRI) const;

/// Stores extra instruction information inline or allocates as ExtraInfo
/// based on the number of pointers.
void setExtraInfo(MachineFunction &MF, ArrayRef<MachineMemOperand *> MMOs,
                  MCSymbol *PreInstrSymbol, MCSymbol *PostInstrSymbol,
                  MDNode *HeapAllocMarker);
1904};

1906/// Special DenseMapInfo traits to compare MachineInstr* by *value* of the
1907/// instruction rather than by pointer value.
1908/// The hashing and equality testing functions ignore definitions so this is
1909/// useful for CSE, etc.
1910struct MachineInstrExpressionTrait : DenseMapInfo<MachineInstr*> {
static inline MachineInstr *getEmptyKey() {
  return nullptr;
}

static inline MachineInstr *getTombstoneKey() {
  return reinterpret_cast<MachineInstr*>(-1);
}

static unsigned getHashValue(const MachineInstr* const &MI);

static bool isEqual(const MachineInstr* const &LHS,
                    const MachineInstr* const &RHS) {
  if (RHS == getEmptyKey() || RHS == getTombstoneKey() ||
      LHS == getEmptyKey() || LHS == getTombstoneKey())
    return LHS == RHS;
  return LHS->isIdenticalTo(*RHS, MachineInstr::IgnoreVRegDefs);
}
1928};

1930//===----------------------------------------------------------------------===//
1931// Debugging Support

1933inline raw_ostream& operator<<(raw_ostream &OS, const MachineInstr &MI) {
MI.print(OS);
return OS;
1936}

1938} // end namespace llvm

1940#endif // LLVM_CODEGEN_MACHINEINSTR_H

←

/usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/stl_tree.h

→

1// RB tree implementation -*- C++ -*-

3// Copyright (C) 2001-2020 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library.  This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.

11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14// GNU General Public License for more details.

16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.

20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23// <http://www.gnu.org/licenses/>.

25/*
*
* Copyright (c) 1996,1997
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation.  Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose.  It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation.  Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose.  It is provided "as is" without express or implied warranty.
*
*
*/

53/** @file bits/stl_tree.h
*  This is an internal header file, included by other library headers.
*  Do not attempt to use it directly. @headername{map,set}
*/

58#ifndef _STL_TREE_H1
59#define _STL_TREE_H1 1

61#pragma GCC system_header

63#include <bits/stl_algobase.h>
64#include <bits/allocator.h>
65#include <bits/stl_function.h>
66#include <bits/cpp_type_traits.h>
67#include <ext/alloc_traits.h>
68#if __cplusplus201402L >= 201103L
69# include <ext/aligned_buffer.h>
70#endif
71#if __cplusplus201402L > 201402L
72# include <bits/node_handle.h>
73#endif

75namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
76{
77_GLIBCXX_BEGIN_NAMESPACE_VERSION

79#if __cplusplus201402L > 201103L
80# define __cpp_lib_generic_associative_lookup201304 201304
81#endif

// Red-black tree class, designed for use in implementing STL
// associative containers (set, multiset, map, and multimap). The
// insertion and deletion algorithms are based on those in Cormen,
// Leiserson, and Rivest, Introduction to Algorithms (MIT Press,
// 1990), except that
//
// (1) the header cell is maintained with links not only to the root
// but also to the leftmost node of the tree, to enable constant
// time begin(), and to the rightmost node of the tree, to enable
// linear time performance when used with the generic set algorithms
// (set_union, etc.)
//
// (2) when a node being deleted has two children its successor node
// is relinked into its place, rather than copied, so that the only
// iterators invalidated are those referring to the deleted node.

enum _Rb_tree_color { _S_red = false, _S_black = true };

struct _Rb_tree_node_base
{
  typedef _Rb_tree_node_base* _Base_ptr;
  typedef const _Rb_tree_node_base* _Const_Base_ptr;

  _Rb_tree_color	_M_color;
  _Base_ptr		_M_parent;
  _Base_ptr		_M_left;
  _Base_ptr		_M_right;

  static _Base_ptr
  _S_minimum(_Base_ptr __x) _GLIBCXX_NOEXCEPTnoexcept
  {
    while (__x->_M_left != 0) __x = __x->_M_left;
    return __x;
  }

  static _Const_Base_ptr
  _S_minimum(_Const_Base_ptr __x) _GLIBCXX_NOEXCEPTnoexcept
  {
    while (__x->_M_left != 0) __x = __x->_M_left;
    return __x;
  }

  static _Base_ptr
  _S_maximum(_Base_ptr __x) _GLIBCXX_NOEXCEPTnoexcept
  {
    while (__x->_M_right != 0) __x = __x->_M_right;
    return __x;
  }

  static _Const_Base_ptr
  _S_maximum(_Const_Base_ptr __x) _GLIBCXX_NOEXCEPTnoexcept
  {
    while (__x->_M_right != 0) __x = __x->_M_right;
    return __x;
  }
};

// Helper type offering value initialization guarantee on the compare functor.
template<typename _Key_compare>
  struct _Rb_tree_key_compare
  {
    _Key_compare		_M_key_compare;

    _Rb_tree_key_compare()
    _GLIBCXX_NOEXCEPT_IF(noexcept(is_nothrow_default_constructible<_Key_compare>
::value)
is_nothrow_default_constructible<_Key_compare>::value)noexcept(is_nothrow_default_constructible<_Key_compare>
::value)
    : _M_key_compare()
    { }

    _Rb_tree_key_compare(const _Key_compare& __comp)
    : _M_key_compare(__comp)
    { }

156#if __cplusplus201402L >= 201103L
    // Copy constructor added for consistency with C++98 mode.
    _Rb_tree_key_compare(const _Rb_tree_key_compare&) = default;

    _Rb_tree_key_compare(_Rb_tree_key_compare&& __x)
noexcept(is_nothrow_copy_constructible<_Key_compare>::value)
    : _M_key_compare(__x._M_key_compare)
    { }
164#endif
  };

// Helper type to manage default initialization of node count and header.
struct _Rb_tree_header
{
  _Rb_tree_node_base	_M_header;
  size_t		_M_node_count; // Keeps track of size of tree.

  _Rb_tree_header() _GLIBCXX_NOEXCEPTnoexcept
  {
    _M_header._M_color = _S_red;
    _M_reset();
  }

179#if __cplusplus201402L >= 201103L
  _Rb_tree_header(_Rb_tree_header&& __x) noexcept
  {
    if (__x._M_header._M_parent != nullptr)
_M_move_data(__x);
    else
{
 _M_header._M_color = _S_red;
 _M_reset();
}
  }
190#endif

  void
  _M_move_data(_Rb_tree_header& __from)
  {
    _M_header._M_color = __from._M_header._M_color;
    _M_header._M_parent = __from._M_header._M_parent;
    _M_header._M_left = __from._M_header._M_left;
    _M_header._M_right = __from._M_header._M_right;
    _M_header._M_parent->_M_parent = &_M_header;
    _M_node_count = __from._M_node_count;

    __from._M_reset();
  }

  void
  _M_reset()
  {
    _M_header._M_parent = 0;
    _M_header._M_left = &_M_header;
    _M_header._M_right = &_M_header;
    _M_node_count = 0;
  }
};

template<typename _Val>
  struct _Rb_tree_node : public _Rb_tree_node_base
  {
    typedef _Rb_tree_node<_Val>* _Link_type;

220#if __cplusplus201402L < 201103L
    _Val _M_value_field;

    _Val*
    _M_valptr()
    { return std::__addressof(_M_value_field); }

    const _Val*
    _M_valptr() const
    { return std::__addressof(_M_value_field); }
230#else
    __gnu_cxx::__aligned_membuf<_Val> _M_storage;

    _Val*
    _M_valptr()
    { return _M_storage._M_ptr(); }

    const _Val*
    _M_valptr() const
    { return _M_storage._M_ptr(); }
240#endif
  };

_GLIBCXX_PURE__attribute__ ((__pure__)) _Rb_tree_node_base*
_Rb_tree_increment(_Rb_tree_node_base* __x) throw ();

_GLIBCXX_PURE__attribute__ ((__pure__)) const _Rb_tree_node_base*
_Rb_tree_increment(const _Rb_tree_node_base* __x) throw ();

_GLIBCXX_PURE__attribute__ ((__pure__)) _Rb_tree_node_base*
_Rb_tree_decrement(_Rb_tree_node_base* __x) throw ();

_GLIBCXX_PURE__attribute__ ((__pure__)) const _Rb_tree_node_base*
_Rb_tree_decrement(const _Rb_tree_node_base* __x) throw ();

template<typename _Tp>
  struct _Rb_tree_iterator
  {
    typedef _Tp  value_type;
    typedef _Tp& reference;
    typedef _Tp* pointer;

    typedef bidirectional_iterator_tag iterator_category;
    typedef ptrdiff_t			 difference_type;

    typedef _Rb_tree_iterator<_Tp>		_Self;
    typedef _Rb_tree_node_base::_Base_ptr	_Base_ptr;
    typedef _Rb_tree_node<_Tp>*		_Link_type;

    _Rb_tree_iterator() _GLIBCXX_NOEXCEPTnoexcept
    : _M_node() { }

    explicit
    _Rb_tree_iterator(_Base_ptr __x) _GLIBCXX_NOEXCEPTnoexcept
    : _M_node(__x) { }

    reference
    operator*() const _GLIBCXX_NOEXCEPTnoexcept
    { return *static_cast<_Link_type>(_M_node)->_M_valptr(); }

    pointer
    operator->() const _GLIBCXX_NOEXCEPTnoexcept
    { return static_cast<_Link_type> (_M_node)->_M_valptr(); }

    _Self&
    operator++() _GLIBCXX_NOEXCEPTnoexcept
    {
_M_node = _Rb_tree_increment(_M_node);
return *this;
    }

    _Self
    operator++(int) _GLIBCXX_NOEXCEPTnoexcept
    {
_Self __tmp = *this;
_M_node = _Rb_tree_increment(_M_node);
return __tmp;
    }

    _Self&
    operator--() _GLIBCXX_NOEXCEPTnoexcept
    {
_M_node = _Rb_tree_decrement(_M_node);
return *this;
    }

    _Self
    operator--(int) _GLIBCXX_NOEXCEPTnoexcept
    {
_Self __tmp = *this;
_M_node = _Rb_tree_decrement(_M_node);
return __tmp;
    }

    friend bool
    operator==(const _Self& __x, const _Self& __y) _GLIBCXX_NOEXCEPTnoexcept
    { return __x._M_node == __y._M_node; }

318#if ! __cpp_lib_three_way_comparison
    friend bool
    operator!=(const _Self& __x, const _Self& __y) _GLIBCXX_NOEXCEPTnoexcept
    { return __x._M_node != __y._M_node; }
76
←
Assuming '__x._M_node' is equal to '__y._M_node'→
77
←
Returning zero, which participates in a condition later→
322#endif

    _Base_ptr _M_node;
};

template<typename _Tp>
  struct _Rb_tree_const_iterator
  {
    typedef _Tp	 value_type;
    typedef const _Tp& reference;
    typedef const _Tp* pointer;

    typedef _Rb_tree_iterator<_Tp> iterator;

    typedef bidirectional_iterator_tag iterator_category;
    typedef ptrdiff_t			 difference_type;

    typedef _Rb_tree_const_iterator<_Tp>		_Self;
    typedef _Rb_tree_node_base::_Const_Base_ptr	_Base_ptr;
    typedef const _Rb_tree_node<_Tp>*			_Link_type;

    _Rb_tree_const_iterator() _GLIBCXX_NOEXCEPTnoexcept
    : _M_node() { }

    explicit
    _Rb_tree_const_iterator(_Base_ptr __x) _GLIBCXX_NOEXCEPTnoexcept
    : _M_node(__x) { }

    _Rb_tree_const_iterator(const iterator& __it) _GLIBCXX_NOEXCEPTnoexcept
    : _M_node(__it._M_node) { }

    iterator
    _M_const_cast() const _GLIBCXX_NOEXCEPTnoexcept
    { return iterator(const_cast<typename iterator::_Base_ptr>(_M_node)); }

    reference
    operator*() const _GLIBCXX_NOEXCEPTnoexcept
    { return *static_cast<_Link_type>(_M_node)->_M_valptr(); }

    pointer
    operator->() const _GLIBCXX_NOEXCEPTnoexcept
    { return static_cast<_Link_type>(_M_node)->_M_valptr(); }

    _Self&
    operator++() _GLIBCXX_NOEXCEPTnoexcept
    {
_M_node = _Rb_tree_increment(_M_node);
return *this;
    }

    _Self
    operator++(int) _GLIBCXX_NOEXCEPTnoexcept
    {
_Self __tmp = *this;
_M_node = _Rb_tree_increment(_M_node);
return __tmp;
    }

    _Self&
    operator--() _GLIBCXX_NOEXCEPTnoexcept
    {
_M_node = _Rb_tree_decrement(_M_node);
return *this;
    }

    _Self
    operator--(int) _GLIBCXX_NOEXCEPTnoexcept
    {
_Self __tmp = *this;
_M_node = _Rb_tree_decrement(_M_node);
return __tmp;
    }

    friend bool
    operator==(const _Self& __x, const _Self& __y) _GLIBCXX_NOEXCEPTnoexcept
    { return __x._M_node == __y._M_node; }

399#if ! __cpp_lib_three_way_comparison
    friend bool
    operator!=(const _Self& __x, const _Self& __y) _GLIBCXX_NOEXCEPTnoexcept
    { return __x._M_node != __y._M_node; }
403#endif

    _Base_ptr _M_node;
  };

void
_Rb_tree_insert_and_rebalance(const bool __insert_left,
		_Rb_tree_node_base* __x,
		_Rb_tree_node_base* __p,
		_Rb_tree_node_base& __header) throw ();

_Rb_tree_node_base*
_Rb_tree_rebalance_for_erase(_Rb_tree_node_base* const __z,
	       _Rb_tree_node_base& __header) throw ();

418#if __cplusplus201402L >= 201402L
template<typename _Cmp, typename _SfinaeType, typename = __void_t<>>
  struct __has_is_transparent
  { };

template<typename _Cmp, typename _SfinaeType>
  struct __has_is_transparent<_Cmp, _SfinaeType,
		__void_t<typename _Cmp::is_transparent>>
  { typedef void type; };

template<typename _Cmp, typename _SfinaeType>
  using __has_is_transparent_t
    = typename __has_is_transparent<_Cmp, _SfinaeType>::type;
431#endif

433#if __cplusplus201402L > 201402L
template<typename _Tree1, typename _Cmp2>
  struct _Rb_tree_merge_helper { };
436#endif

template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc = allocator<_Val> >
  class _Rb_tree
  {
    typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
rebind<_Rb_tree_node<_Val> >::other _Node_allocator;

    typedef __gnu_cxx::__alloc_traits<_Node_allocator> _Alloc_traits;

  protected:
    typedef _Rb_tree_node_base* 		_Base_ptr;
    typedef const _Rb_tree_node_base* 	_Const_Base_ptr;
    typedef _Rb_tree_node<_Val>* 		_Link_type;
    typedef const _Rb_tree_node<_Val>*	_Const_Link_type;

  private:
    // Functor recycling a pool of nodes and using allocation once the pool
    // is empty.
    struct _Reuse_or_alloc_node
    {
_Reuse_or_alloc_node(_Rb_tree& __t)
: _M_root(__t._M_root()), _M_nodes(__t._M_rightmost()), _M_t(__t)
{
 if (_M_root)
   {
     _M_root->_M_parent = 0;

     if (_M_nodes->_M_left)
_M_nodes = _M_nodes->_M_left;
   }
 else
   _M_nodes = 0;
}

472#if __cplusplus201402L >= 201103L
_Reuse_or_alloc_node(const _Reuse_or_alloc_node&) = delete;
474#endif

~_Reuse_or_alloc_node()
{ _M_t._M_erase(static_cast<_Link_type>(_M_root)); }

template<typename _Arg>
 _Link_type
481#if __cplusplus201402L < 201103L
 operator()(const _Arg& __arg)
483#else
 operator()(_Arg&& __arg)
485#endif
 {
   _Link_type __node = static_cast<_Link_type>(_M_extract());
   if (__node)
     {
_M_t._M_destroy_node(__node);
_M_t._M_construct_node(__node, _GLIBCXX_FORWARD(_Arg, __arg)std::forward<_Arg>(__arg));
return __node;
     }

   return _M_t._M_create_node(_GLIBCXX_FORWARD(_Arg, __arg)std::forward<_Arg>(__arg));
 }

    private:
_Base_ptr
_M_extract()
{
 if (!_M_nodes)
   return _M_nodes;

 _Base_ptr __node = _M_nodes;
 _M_nodes = _M_nodes->_M_parent;
 if (_M_nodes)
   {
     if (_M_nodes->_M_right == __node)
{
  _M_nodes->_M_right = 0;

  if (_M_nodes->_M_left)
    {
      _M_nodes = _M_nodes->_M_left;

      while (_M_nodes->_M_right)
	_M_nodes = _M_nodes->_M_right;

      if (_M_nodes->_M_left)
	_M_nodes = _M_nodes->_M_left;
    }
}
     else // __node is on the left.
_M_nodes->_M_left = 0;
   }
 else
   _M_root = 0;

 return __node;
}

_Base_ptr _M_root;
_Base_ptr _M_nodes;
_Rb_tree& _M_t;
    };

    // Functor similar to the previous one but without any pool of nodes to
    // recycle.
    struct _Alloc_node
    {
_Alloc_node(_Rb_tree& __t)
: _M_t(__t) { }

template<typename _Arg>
 _Link_type
547#if __cplusplus201402L < 201103L
 operator()(const _Arg& __arg) const
549#else
 operator()(_Arg&& __arg) const
551#endif
 { return _M_t._M_create_node(_GLIBCXX_FORWARD(_Arg, __arg)std::forward<_Arg>(__arg)); }

    private:
_Rb_tree& _M_t;
    };

  public:
    typedef _Key 				key_type;
    typedef _Val 				value_type;
    typedef value_type* 			pointer;
    typedef const value_type* 		const_pointer;
    typedef value_type& 			reference;
    typedef const value_type& 		const_reference;
    typedef size_t 				size_type;
    typedef ptrdiff_t 			difference_type;
    typedef _Alloc 				allocator_type;

    _Node_allocator&
    _M_get_Node_allocator() _GLIBCXX_NOEXCEPTnoexcept
    { return this->_M_impl; }

    const _Node_allocator&
    _M_get_Node_allocator() const _GLIBCXX_NOEXCEPTnoexcept
    { return this->_M_impl; }

    allocator_type
    get_allocator() const _GLIBCXX_NOEXCEPTnoexcept
    { return allocator_type(_M_get_Node_allocator()); }

  protected:
    _Link_type
    _M_get_node()
    { return _Alloc_traits::allocate(_M_get_Node_allocator(), 1); }

    void
    _M_put_node(_Link_type __p) _GLIBCXX_NOEXCEPTnoexcept
    { _Alloc_traits::deallocate(_M_get_Node_allocator(), __p, 1); }

590#if __cplusplus201402L < 201103L
    void
    _M_construct_node(_Link_type __node, const value_type& __x)
    {
__tryif (true)
 { get_allocator().construct(__node->_M_valptr(), __x); }
__catch(...)if (false)
 {
   _M_put_node(__node);
   __throw_exception_again;
 }
    }

    _Link_type
    _M_create_node(const value_type& __x)
    {
_Link_type __tmp = _M_get_node();
_M_construct_node(__tmp, __x);
return __tmp;
    }
610#else
    template<typename... _Args>
void
_M_construct_node(_Link_type __node, _Args&&... __args)
{
 __tryif (true)
   {
     ::new(__node) _Rb_tree_node<_Val>;
     _Alloc_traits::construct(_M_get_Node_allocator(),
		       __node->_M_valptr(),
		       std::forward<_Args>(__args)...);
   }
 __catch(...)if (false)
   {
     __node->~_Rb_tree_node<_Val>();
     _M_put_node(__node);
     __throw_exception_again;
   }
}

    template<typename... _Args>
_Link_type
_M_create_node(_Args&&... __args)
{
 _Link_type __tmp = _M_get_node();
 _M_construct_node(__tmp, std::forward<_Args>(__args)...);
 return __tmp;
}
638#endif

    void
    _M_destroy_node(_Link_type __p) _GLIBCXX_NOEXCEPTnoexcept
    {
643#if __cplusplus201402L < 201103L
get_allocator().destroy(__p->_M_valptr());
645#else
_Alloc_traits::destroy(_M_get_Node_allocator(), __p->_M_valptr());
__p->~_Rb_tree_node<_Val>();
648#endif
    }

    void
    _M_drop_node(_Link_type __p) _GLIBCXX_NOEXCEPTnoexcept
    {
_M_destroy_node(__p);
_M_put_node(__p);
    }

    template<typename _NodeGen>
_Link_type
_M_clone_node(_Const_Link_type __x, _NodeGen& __node_gen)
{
 _Link_type __tmp = __node_gen(*__x->_M_valptr());
 __tmp->_M_color = __x->_M_color;
 __tmp->_M_left = 0;
 __tmp->_M_right = 0;
 return __tmp;
}

  protected:
670#if _GLIBCXX_INLINE_VERSION0
    template<typename _Key_compare>
672#else
    // Unused _Is_pod_comparator is kept as it is part of mangled name.
    template<typename _Key_compare,
      bool /* _Is_pod_comparator */ = __is_pod(_Key_compare)>
676#endif
struct _Rb_tree_impl
: public _Node_allocator
, public _Rb_tree_key_compare<_Key_compare>
, public _Rb_tree_header
{
 typedef _Rb_tree_key_compare<_Key_compare> _Base_key_compare;

 _Rb_tree_impl()
   _GLIBCXX_NOEXCEPT_IF(noexcept(is_nothrow_default_constructible<_Node_allocator>
::value && is_nothrow_default_constructible<_Base_key_compare
>::value)
is_nothrow_default_constructible<_Node_allocator>::valuenoexcept(is_nothrow_default_constructible<_Node_allocator>
::value && is_nothrow_default_constructible<_Base_key_compare
>::value)
&& is_nothrow_default_constructible<_Base_key_compare>::value )noexcept(is_nothrow_default_constructible<_Node_allocator>
::value && is_nothrow_default_constructible<_Base_key_compare
>::value)
 : _Node_allocator()
 { }

 _Rb_tree_impl(const _Rb_tree_impl& __x)
 : _Node_allocator(_Alloc_traits::_S_select_on_copy(__x))
 , _Base_key_compare(__x._M_key_compare)
 { }

696#if __cplusplus201402L < 201103L
 _Rb_tree_impl(const _Key_compare& __comp, const _Node_allocator& __a)
 : _Node_allocator(__a), _Base_key_compare(__comp)
 { }
700#else
 _Rb_tree_impl(_Rb_tree_impl&&) = default;

 explicit
 _Rb_tree_impl(_Node_allocator&& __a)
 : _Node_allocator(std::move(__a))
 { }

 _Rb_tree_impl(_Rb_tree_impl&& __x, _Node_allocator&& __a)
 : _Node_allocator(std::move(__a)),
   _Base_key_compare(std::move(__x)),
   _Rb_tree_header(std::move(__x))
 { }

 _Rb_tree_impl(const _Key_compare& __comp, _Node_allocator&& __a)
 : _Node_allocator(std::move(__a)), _Base_key_compare(__comp)
 { }
717#endif
};

    _Rb_tree_impl<_Compare> _M_impl;

  protected:
    _Base_ptr&
    _M_root() _GLIBCXX_NOEXCEPTnoexcept
    { return this->_M_impl._M_header._M_parent; }

    _Const_Base_ptr
    _M_root() const _GLIBCXX_NOEXCEPTnoexcept
    { return this->_M_impl._M_header._M_parent; }

    _Base_ptr&
    _M_leftmost() _GLIBCXX_NOEXCEPTnoexcept
    { return this->_M_impl._M_header._M_left; }

    _Const_Base_ptr
    _M_leftmost() const _GLIBCXX_NOEXCEPTnoexcept
    { return this->_M_impl._M_header._M_left; }

    _Base_ptr&
    _M_rightmost() _GLIBCXX_NOEXCEPTnoexcept
    { return this->_M_impl._M_header._M_right; }

    _Const_Base_ptr
    _M_rightmost() const _GLIBCXX_NOEXCEPTnoexcept
    { return this->_M_impl._M_header._M_right; }

    _Link_type
    _M_begin() _GLIBCXX_NOEXCEPTnoexcept
    { return static_cast<_Link_type>(this->_M_impl._M_header._M_parent); }

    _Const_Link_type
    _M_begin() const _GLIBCXX_NOEXCEPTnoexcept
    {
return static_cast<_Const_Link_type>
 (this->_M_impl._M_header._M_parent);
    }

    _Base_ptr
    _M_end() _GLIBCXX_NOEXCEPTnoexcept
    { return &this->_M_impl._M_header; }

    _Const_Base_ptr
    _M_end() const _GLIBCXX_NOEXCEPTnoexcept
    { return &this->_M_impl._M_header; }

    static const _Key&
    _S_key(_Const_Link_type __x)
    {
769#if __cplusplus201402L >= 201103L
// If we're asking for the key we're presumably using the comparison
// object, and so this is a good place to sanity check it.
static_assert(__is_invocable<_Compare&, const _Key&, const _Key&>{},
      "comparison object must be invocable "
      "with two arguments of key type");
775# if __cplusplus201402L >= 201703L
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 2542. Missing const requirements for associative containers
if constexpr (__is_invocable<_Compare&, const _Key&, const _Key&>{})
 static_assert(
     is_invocable_v<const _Compare&, const _Key&, const _Key&>,
     "comparison object must be invocable as const");
782# endif // C++17
783#endif // C++11

return _KeyOfValue()(*__x->_M_valptr());
    }

    static _Link_type
    _S_left(_Base_ptr __x) _GLIBCXX_NOEXCEPTnoexcept
    { return static_cast<_Link_type>(__x->_M_left); }

    static _Const_Link_type
    _S_left(_Const_Base_ptr __x) _GLIBCXX_NOEXCEPTnoexcept
    { return static_cast<_Const_Link_type>(__x->_M_left); }

    static _Link_type
    _S_right(_Base_ptr __x) _GLIBCXX_NOEXCEPTnoexcept
    { return static_cast<_Link_type>(__x->_M_right); }

    static _Const_Link_type
    _S_right(_Const_Base_ptr __x) _GLIBCXX_NOEXCEPTnoexcept
    { return static_cast<_Const_Link_type>(__x->_M_right); }

    static const _Key&
    _S_key(_Const_Base_ptr __x)
    { return _S_key(static_cast<_Const_Link_type>(__x)); }

    static _Base_ptr
    _S_minimum(_Base_ptr __x) _GLIBCXX_NOEXCEPTnoexcept
    { return _Rb_tree_node_base::_S_minimum(__x); }

    static _Const_Base_ptr
    _S_minimum(_Const_Base_ptr __x) _GLIBCXX_NOEXCEPTnoexcept
    { return _Rb_tree_node_base::_S_minimum(__x); }

    static _Base_ptr
    _S_maximum(_Base_ptr __x) _GLIBCXX_NOEXCEPTnoexcept
    { return _Rb_tree_node_base::_S_maximum(__x); }

    static _Const_Base_ptr
    _S_maximum(_Const_Base_ptr __x) _GLIBCXX_NOEXCEPTnoexcept
    { return _Rb_tree_node_base::_S_maximum(__x); }

  public:
    typedef _Rb_tree_iterator<value_type>       iterator;
    typedef _Rb_tree_const_iterator<value_type> const_iterator;

    typedef std::reverse_iterator<iterator>       reverse_iterator;
    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

831#if __cplusplus201402L > 201402L
    using node_type = _Node_handle<_Key, _Val, _Node_allocator>;
    using insert_return_type = _Node_insert_return<
conditional_t<is_same_v<_Key, _Val>, const_iterator, iterator>,
node_type>;
836#endif

    pair<_Base_ptr, _Base_ptr>
    _M_get_insert_unique_pos(const key_type& __k);

    pair<_Base_ptr, _Base_ptr>
    _M_get_insert_equal_pos(const key_type& __k);

    pair<_Base_ptr, _Base_ptr>
    _M_get_insert_hint_unique_pos(const_iterator __pos,
		    const key_type& __k);

    pair<_Base_ptr, _Base_ptr>
    _M_get_insert_hint_equal_pos(const_iterator __pos,
		   const key_type& __k);

  private:
853#if __cplusplus201402L >= 201103L
    template<typename _Arg, typename _NodeGen>
iterator
_M_insert_(_Base_ptr __x, _Base_ptr __y, _Arg&& __v, _NodeGen&);

    iterator
    _M_insert_node(_Base_ptr __x, _Base_ptr __y, _Link_type __z);

    template<typename _Arg>
iterator
_M_insert_lower(_Base_ptr __y, _Arg&& __v);

    template<typename _Arg>
iterator
_M_insert_equal_lower(_Arg&& __x);

    iterator
    _M_insert_lower_node(_Base_ptr __p, _Link_type __z);

    iterator
    _M_insert_equal_lower_node(_Link_type __z);
874#else
    template<typename _NodeGen>
iterator
_M_insert_(_Base_ptr __x, _Base_ptr __y,
   const value_type& __v, _NodeGen&);

    // _GLIBCXX_RESOLVE_LIB_DEFECTS
    // 233. Insertion hints in associative containers.
    iterator
    _M_insert_lower(_Base_ptr __y, const value_type& __v);

    iterator
    _M_insert_equal_lower(const value_type& __x);
887#endif

    template<typename _NodeGen>
_Link_type
_M_copy(_Const_Link_type __x, _Base_ptr __p, _NodeGen&);

    template<typename _NodeGen>
_Link_type
_M_copy(const _Rb_tree& __x, _NodeGen& __gen)
{
 _Link_type __root = _M_copy(__x._M_begin(), _M_end(), __gen);
 _M_leftmost() = _S_minimum(__root);
 _M_rightmost() = _S_maximum(__root);
 _M_impl._M_node_count = __x._M_impl._M_node_count;
 return __root;
}

    _Link_type
    _M_copy(const _Rb_tree& __x)
    {
_Alloc_node __an(*this);
return _M_copy(__x, __an);
    }

    void
    _M_erase(_Link_type __x);

    iterator
    _M_lower_bound(_Link_type __x, _Base_ptr __y,
     const _Key& __k);

    const_iterator
    _M_lower_bound(_Const_Link_type __x, _Const_Base_ptr __y,
     const _Key& __k) const;

    iterator
    _M_upper_bound(_Link_type __x, _Base_ptr __y,
     const _Key& __k);

    const_iterator
    _M_upper_bound(_Const_Link_type __x, _Const_Base_ptr __y,
     const _Key& __k) const;

  public:
    // allocation/deallocation
932#if __cplusplus201402L < 201103L
    _Rb_tree() { }
934#else
    _Rb_tree() = default;
936#endif

    _Rb_tree(const _Compare& __comp,
      const allocator_type& __a = allocator_type())
    : _M_impl(__comp, _Node_allocator(__a)) { }

    _Rb_tree(const _Rb_tree& __x)
    : _M_impl(__x._M_impl)
    {
if (__x._M_root() != 0)
 _M_root() = _M_copy(__x);
    }

949#if __cplusplus201402L >= 201103L
    _Rb_tree(const allocator_type& __a)
    : _M_impl(_Node_allocator(__a))
    { }

    _Rb_tree(const _Rb_tree& __x, const allocator_type& __a)
    : _M_impl(__x._M_impl._M_key_compare, _Node_allocator(__a))
    {
if (__x._M_root() != nullptr)
 _M_root() = _M_copy(__x);
    }

    _Rb_tree(_Rb_tree&&) = default;

    _Rb_tree(_Rb_tree&& __x, const allocator_type& __a)
    : _Rb_tree(std::move(__x), _Node_allocator(__a))
    { }

  private:
    _Rb_tree(_Rb_tree&& __x, _Node_allocator&& __a, true_type)
    noexcept(is_nothrow_default_constructible<_Compare>::value)
    : _M_impl(std::move(__x._M_impl), std::move(__a))
    { }

    _Rb_tree(_Rb_tree&& __x, _Node_allocator&& __a, false_type)
    : _M_impl(__x._M_impl._M_key_compare, std::move(__a))
    {
if (__x._M_root() != nullptr)
 _M_move_data(__x, false_type{});
    }

  public:
    _Rb_tree(_Rb_tree&& __x, _Node_allocator&& __a)
    noexcept( noexcept(
_Rb_tree(std::declval<_Rb_tree&&>(), std::declval<_Node_allocator&&>(),
 std::declval<typename _Alloc_traits::is_always_equal>())) )
    : _Rb_tree(std::move(__x), std::move(__a),
 typename _Alloc_traits::is_always_equal{})
    { }
988#endif

    ~_Rb_tree() _GLIBCXX_NOEXCEPTnoexcept
    { _M_erase(_M_begin()); }

    _Rb_tree&
    operator=(const _Rb_tree& __x);

    // Accessors.
    _Compare
    key_comp() const
    { return _M_impl._M_key_compare; }

    iterator
    begin() _GLIBCXX_NOEXCEPTnoexcept
    { return iterator(this->_M_impl._M_header._M_left); }

    const_iterator
    begin() const _GLIBCXX_NOEXCEPTnoexcept
    { return const_iterator(this->_M_impl._M_header._M_left); }

    iterator
    end() _GLIBCXX_NOEXCEPTnoexcept
    { return iterator(&this->_M_impl._M_header); }

    const_iterator
    end() const _GLIBCXX_NOEXCEPTnoexcept
    { return const_iterator(&this->_M_impl._M_header); }

    reverse_iterator
    rbegin() _GLIBCXX_NOEXCEPTnoexcept
    { return reverse_iterator(end()); }

    const_reverse_iterator
    rbegin() const _GLIBCXX_NOEXCEPTnoexcept
    { return const_reverse_iterator(end()); }

    reverse_iterator
    rend() _GLIBCXX_NOEXCEPTnoexcept
    { return reverse_iterator(begin()); }

    const_reverse_iterator
    rend() const _GLIBCXX_NOEXCEPTnoexcept
    { return const_reverse_iterator(begin()); }

    _GLIBCXX_NODISCARD bool
    empty() const _GLIBCXX_NOEXCEPTnoexcept
    { return _M_impl._M_node_count == 0; }

    size_type
    size() const _GLIBCXX_NOEXCEPTnoexcept
    { return _M_impl._M_node_count; }

    size_type
    max_size() const _GLIBCXX_NOEXCEPTnoexcept
    { return _Alloc_traits::max_size(_M_get_Node_allocator()); }

    void
    swap(_Rb_tree& __t)
    _GLIBCXX_NOEXCEPT_IF(__is_nothrow_swappable<_Compare>::value)noexcept(__is_nothrow_swappable<_Compare>::value);

    // Insert/erase.
1050#if __cplusplus201402L >= 201103L
    template<typename _Arg>
pair<iterator, bool>
_M_insert_unique(_Arg&& __x);

    template<typename _Arg>
iterator
_M_insert_equal(_Arg&& __x);

    template<typename _Arg, typename _NodeGen>
iterator
_M_insert_unique_(const_iterator __pos, _Arg&& __x, _NodeGen&);

    template<typename _Arg>
iterator
_M_insert_unique_(const_iterator __pos, _Arg&& __x)
{
 _Alloc_node __an(*this);
 return _M_insert_unique_(__pos, std::forward<_Arg>(__x), __an);
}

    template<typename _Arg, typename _NodeGen>
iterator
_M_insert_equal_(const_iterator __pos, _Arg&& __x, _NodeGen&);

    template<typename _Arg>
iterator
_M_insert_equal_(const_iterator __pos, _Arg&& __x)
{
 _Alloc_node __an(*this);
 return _M_insert_equal_(__pos, std::forward<_Arg>(__x), __an);
}

    template<typename... _Args>
pair<iterator, bool>
_M_emplace_unique(_Args&&... __args);

    template<typename... _Args>
iterator
_M_emplace_equal(_Args&&... __args);

    template<typename... _Args>
iterator
_M_emplace_hint_unique(const_iterator __pos, _Args&&... __args);

    template<typename... _Args>
iterator
_M_emplace_hint_equal(const_iterator __pos, _Args&&... __args);

    template<typename _Iter>
using __same_value_type
 = is_same<value_type, typename iterator_traits<_Iter>::value_type>;

    template<typename _InputIterator>
__enable_if_t<__same_value_type<_InputIterator>::value>
_M_insert_range_unique(_InputIterator __first, _InputIterator __last)
{
 _Alloc_node __an(*this);
 for (; __first != __last; ++__first)
   _M_insert_unique_(end(), *__first, __an);
}

    template<typename _InputIterator>
__enable_if_t<!__same_value_type<_InputIterator>::value>
_M_insert_range_unique(_InputIterator __first, _InputIterator __last)
{
 for (; __first != __last; ++__first)
   _M_emplace_unique(*__first);
}

    template<typename _InputIterator>
__enable_if_t<__same_value_type<_InputIterator>::value>
_M_insert_range_equal(_InputIterator __first, _InputIterator __last)
{
 _Alloc_node __an(*this);
 for (; __first != __last; ++__first)
   _M_insert_equal_(end(), *__first, __an);
}

    template<typename _InputIterator>
__enable_if_t<!__same_value_type<_InputIterator>::value>
_M_insert_range_equal(_InputIterator __first, _InputIterator __last)
{
 _Alloc_node __an(*this);
 for (; __first != __last; ++__first)
   _M_emplace_equal(*__first);
}
1137#else
    pair<iterator, bool>
    _M_insert_unique(const value_type& __x);

    iterator
    _M_insert_equal(const value_type& __x);

    template<typename _NodeGen>
iterator
_M_insert_unique_(const_iterator __pos, const value_type& __x,
	  _NodeGen&);

    iterator
    _M_insert_unique_(const_iterator __pos, const value_type& __x)
    {
_Alloc_node __an(*this);
return _M_insert_unique_(__pos, __x, __an);
    }

    template<typename _NodeGen>
iterator
_M_insert_equal_(const_iterator __pos, const value_type& __x,
	 _NodeGen&);
    iterator
    _M_insert_equal_(const_iterator __pos, const value_type& __x)
    {
_Alloc_node __an(*this);
return _M_insert_equal_(__pos, __x, __an);
    }

    template<typename _InputIterator>
void
_M_insert_range_unique(_InputIterator __first, _InputIterator __last)
{
 _Alloc_node __an(*this);
 for (; __first != __last; ++__first)
   _M_insert_unique_(end(), *__first, __an);
}

    template<typename _InputIterator>
void
_M_insert_range_equal(_InputIterator __first, _InputIterator __last)
{
 _Alloc_node __an(*this);
 for (; __first != __last; ++__first)
   _M_insert_equal_(end(), *__first, __an);
}
1184#endif

  private:
    void
    _M_erase_aux(const_iterator __position);

    void
    _M_erase_aux(const_iterator __first, const_iterator __last);

  public:
1194#if __cplusplus201402L >= 201103L
    // _GLIBCXX_RESOLVE_LIB_DEFECTS
    // DR 130. Associative erase should return an iterator.
    _GLIBCXX_ABI_TAG_CXX11__attribute ((__abi_tag__ ("cxx11")))
    iterator
    erase(const_iterator __position)
    {
__glibcxx_assert(__position != end());
const_iterator __result = __position;
++__result;
_M_erase_aux(__position);
return __result._M_const_cast();
    }

    // LWG 2059.
    _GLIBCXX_ABI_TAG_CXX11__attribute ((__abi_tag__ ("cxx11")))
    iterator
    erase(iterator __position)
    {
__glibcxx_assert(__position != end());
iterator __result = __position;
++__result;
_M_erase_aux(__position);
return __result;
    }
1219#else
    void
    erase(iterator __position)
    {
__glibcxx_assert(__position != end());
_M_erase_aux(__position);
    }

    void
    erase(const_iterator __position)
    {
__glibcxx_assert(__position != end());
_M_erase_aux(__position);
    }
1233#endif

    size_type
    erase(const key_type& __x);

1238#if __cplusplus201402L >= 201103L
    // _GLIBCXX_RESOLVE_LIB_DEFECTS
    // DR 130. Associative erase should return an iterator.
    _GLIBCXX_ABI_TAG_CXX11__attribute ((__abi_tag__ ("cxx11")))
    iterator
    erase(const_iterator __first, const_iterator __last)
    {
_M_erase_aux(__first, __last);
return __last._M_const_cast();
    }
1248#else
    void
    erase(iterator __first, iterator __last)
    { _M_erase_aux(__first, __last); }

    void
    erase(const_iterator __first, const_iterator __last)
    { _M_erase_aux(__first, __last); }
1256#endif

    void
    clear() _GLIBCXX_NOEXCEPTnoexcept
    {
_M_erase(_M_begin());
_M_impl._M_reset();
    }

    // Set operations.
    iterator
    find(const key_type& __k);

    const_iterator
    find(const key_type& __k) const;

    size_type
    count(const key_type& __k) const;

    iterator
    lower_bound(const key_type& __k)
    { return _M_lower_bound(_M_begin(), _M_end(), __k); }

    const_iterator
    lower_bound(const key_type& __k) const
    { return _M_lower_bound(_M_begin(), _M_end(), __k); }

    iterator
    upper_bound(const key_type& __k)
    { return _M_upper_bound(_M_begin(), _M_end(), __k); }

    const_iterator
    upper_bound(const key_type& __k) const
    { return _M_upper_bound(_M_begin(), _M_end(), __k); }

    pair<iterator, iterator>
    equal_range(const key_type& __k);

    pair<const_iterator, const_iterator>
    equal_range(const key_type& __k) const;

1297#if __cplusplus201402L >= 201402L
    template<typename _Kt,
      typename _Req = __has_is_transparent_t<_Compare, _Kt>>
iterator
_M_find_tr(const _Kt& __k)
{
 const _Rb_tree* __const_this = this;
 return __const_this->_M_find_tr(__k)._M_const_cast();
}

    template<typename _Kt,
      typename _Req = __has_is_transparent_t<_Compare, _Kt>>
const_iterator
_M_find_tr(const _Kt& __k) const
{
 auto __j = _M_lower_bound_tr(__k);
 if (__j != end() && _M_impl._M_key_compare(__k, _S_key(__j._M_node)))
   __j = end();
 return __j;
}

    template<typename _Kt,
      typename _Req = __has_is_transparent_t<_Compare, _Kt>>
size_type
_M_count_tr(const _Kt& __k) const
{
 auto __p = _M_equal_range_tr(__k);
 return std::distance(__p.first, __p.second);
}

    template<typename _Kt,
      typename _Req = __has_is_transparent_t<_Compare, _Kt>>
iterator
_M_lower_bound_tr(const _Kt& __k)
{
 const _Rb_tree* __const_this = this;
 return __const_this->_M_lower_bound_tr(__k)._M_const_cast();
}

    template<typename _Kt,
      typename _Req = __has_is_transparent_t<_Compare, _Kt>>
const_iterator
_M_lower_bound_tr(const _Kt& __k) const
{
 auto __x = _M_begin();
 auto __y = _M_end();
 while (__x != 0)
   if (!_M_impl._M_key_compare(_S_key(__x), __k))
     {
__y = __x;
__x = _S_left(__x);
     }
   else
     __x = _S_right(__x);
 return const_iterator(__y);
}

    template<typename _Kt,
      typename _Req = __has_is_transparent_t<_Compare, _Kt>>
iterator
_M_upper_bound_tr(const _Kt& __k)
{
 const _Rb_tree* __const_this = this;
 return __const_this->_M_upper_bound_tr(__k)._M_const_cast();
}

    template<typename _Kt,
      typename _Req = __has_is_transparent_t<_Compare, _Kt>>
const_iterator
_M_upper_bound_tr(const _Kt& __k) const
{
 auto __x = _M_begin();
 auto __y = _M_end();
 while (__x != 0)
   if (_M_impl._M_key_compare(__k, _S_key(__x)))
     {
__y = __x;
__x = _S_left(__x);
     }
   else
     __x = _S_right(__x);
 return const_iterator(__y);
}

    template<typename _Kt,
      typename _Req = __has_is_transparent_t<_Compare, _Kt>>
pair<iterator, iterator>
_M_equal_range_tr(const _Kt& __k)
{
 const _Rb_tree* __const_this = this;
 auto __ret = __const_this->_M_equal_range_tr(__k);
 return { __ret.first._M_const_cast(), __ret.second._M_const_cast() };
}

    template<typename _Kt,
      typename _Req = __has_is_transparent_t<_Compare, _Kt>>
pair<const_iterator, const_iterator>
_M_equal_range_tr(const _Kt& __k) const
{
 auto __low = _M_lower_bound_tr(__k);
 auto __high = __low;
 auto& __cmp = _M_impl._M_key_compare;
 while (__high != end() && !__cmp(__k, _S_key(__high._M_node)))
   ++__high;
 return { __low, __high };
}
1403#endif

    // Debugging.
    bool
    __rb_verify() const;

1409#if __cplusplus201402L >= 201103L
    _Rb_tree&
    operator=(_Rb_tree&&)
    noexcept(_Alloc_traits::_S_nothrow_move()
      && is_nothrow_move_assignable<_Compare>::value);

    template<typename _Iterator>
void
_M_assign_unique(_Iterator, _Iterator);

    template<typename _Iterator>
void
_M_assign_equal(_Iterator, _Iterator);

  private:
    // Move elements from container with equal allocator.
    void
    _M_move_data(_Rb_tree& __x, true_type)
    { _M_impl._M_move_data(__x._M_impl); }

    // Move elements from container with possibly non-equal allocator,
    // which might result in a copy not a move.
    void
    _M_move_data(_Rb_tree&, false_type);

    // Move assignment from container with equal allocator.
    void
    _M_move_assign(_Rb_tree&, true_type);

    // Move assignment from container with possibly non-equal allocator,
    // which might result in a copy not a move.
    void
    _M_move_assign(_Rb_tree&, false_type);
1442#endif

1444#if __cplusplus201402L > 201402L
  public:
    /// Re-insert an extracted node.
    insert_return_type
    _M_reinsert_node_unique(node_type&& __nh)
    {
insert_return_type __ret;
if (__nh.empty())
 __ret.position = end();
else
 {
   __glibcxx_assert(_M_get_Node_allocator() == *__nh._M_alloc);

   auto __res = _M_get_insert_unique_pos(__nh._M_key());
   if (__res.second)
     {
__ret.position
  = _M_insert_node(__res.first, __res.second, __nh._M_ptr);
__nh._M_ptr = nullptr;
__ret.inserted = true;
     }
   else
     {
__ret.node = std::move(__nh);
__ret.position = iterator(__res.first);
__ret.inserted = false;
     }
 }
return __ret;
    }

    /// Re-insert an extracted node.
    iterator
    _M_reinsert_node_equal(node_type&& __nh)
    {
iterator __ret;
if (__nh.empty())
 __ret = end();
else
 {
   __glibcxx_assert(_M_get_Node_allocator() == *__nh._M_alloc);
   auto __res = _M_get_insert_equal_pos(__nh._M_key());
   if (__res.second)
     __ret = _M_insert_node(__res.first, __res.second, __nh._M_ptr);
   else
     __ret = _M_insert_equal_lower_node(__nh._M_ptr);
   __nh._M_ptr = nullptr;
 }
return __ret;
    }

    /// Re-insert an extracted node.
    iterator
    _M_reinsert_node_hint_unique(const_iterator __hint, node_type&& __nh)
    {
iterator __ret;
if (__nh.empty())
 __ret = end();
else
 {
   __glibcxx_assert(_M_get_Node_allocator() == *__nh._M_alloc);
   auto __res = _M_get_insert_hint_unique_pos(__hint, __nh._M_key());
   if (__res.second)
     {
__ret = _M_insert_node(__res.first, __res.second, __nh._M_ptr);
__nh._M_ptr = nullptr;
     }
   else
     __ret = iterator(__res.first);
 }
return __ret;
    }

    /// Re-insert an extracted node.
    iterator
    _M_reinsert_node_hint_equal(const_iterator __hint, node_type&& __nh)
    {
iterator __ret;
if (__nh.empty())
 __ret = end();
else
 {
   __glibcxx_assert(_M_get_Node_allocator() == *__nh._M_alloc);
   auto __res = _M_get_insert_hint_equal_pos(__hint, __nh._M_key());
   if (__res.second)
     __ret = _M_insert_node(__res.first, __res.second, __nh._M_ptr);
   else
     __ret = _M_insert_equal_lower_node(__nh._M_ptr);
   __nh._M_ptr = nullptr;
 }
return __ret;
    }

    /// Extract a node.
    node_type
    extract(const_iterator __pos)
    {
auto __ptr = _Rb_tree_rebalance_for_erase(
   __pos._M_const_cast()._M_node, _M_impl._M_header);
--_M_impl._M_node_count;
return { static_cast<_Link_type>(__ptr), _M_get_Node_allocator() };
    }

    /// Extract a node.
    node_type
    extract(const key_type& __k)
    {
node_type __nh;
auto __pos = find(__k);
if (__pos != end())
 __nh = extract(const_iterator(__pos));
return __nh;
    }

    template<typename _Compare2>
using _Compatible_tree
 = _Rb_tree<_Key, _Val, _KeyOfValue, _Compare2, _Alloc>;

    template<typename, typename>
friend class _Rb_tree_merge_helper;

    /// Merge from a compatible container into one with unique keys.
    template<typename _Compare2>
void
_M_merge_unique(_Compatible_tree<_Compare2>& __src) noexcept
{
 using _Merge_helper = _Rb_tree_merge_helper<_Rb_tree, _Compare2>;
 for (auto __i = __src.begin(), __end = __src.end(); __i != __end;)
   {
     auto __pos = __i++;
     auto __res = _M_get_insert_unique_pos(_KeyOfValue()(*__pos));
     if (__res.second)
{
  auto& __src_impl = _Merge_helper::_S_get_impl(__src);
  auto __ptr = _Rb_tree_rebalance_for_erase(
      __pos._M_node, __src_impl._M_header);
  --__src_impl._M_node_count;
  _M_insert_node(__res.first, __res.second,
		 static_cast<_Link_type>(__ptr));
}
   }
}

    /// Merge from a compatible container into one with equivalent keys.
    template<typename _Compare2>
void
_M_merge_equal(_Compatible_tree<_Compare2>& __src) noexcept
{
 using _Merge_helper = _Rb_tree_merge_helper<_Rb_tree, _Compare2>;
 for (auto __i = __src.begin(), __end = __src.end(); __i != __end;)
   {
     auto __pos = __i++;
     auto __res = _M_get_insert_equal_pos(_KeyOfValue()(*__pos));
     if (__res.second)
{
  auto& __src_impl = _Merge_helper::_S_get_impl(__src);
  auto __ptr = _Rb_tree_rebalance_for_erase(
      __pos._M_node, __src_impl._M_header);
  --__src_impl._M_node_count;
  _M_insert_node(__res.first, __res.second,
		 static_cast<_Link_type>(__ptr));
}
   }
}
1608#endif // C++17

    friend bool
    operator==(const _Rb_tree& __x, const _Rb_tree& __y)
    {
return __x.size() == __y.size()
 && std::equal(__x.begin(), __x.end(), __y.begin());
    }

1617#if __cpp_lib_three_way_comparison
    friend auto
    operator<=>(const _Rb_tree& __x, const _Rb_tree& __y)
    {
if constexpr (requires { typename __detail::__synth3way_t<_Val>; })
 return std::lexicographical_compare_three_way(__x.begin(), __x.end(),
					__y.begin(), __y.end(),
					__detail::__synth3way);
    }
1626#else
    friend bool
    operator<(const _Rb_tree& __x, const _Rb_tree& __y)
    {
return std::lexicographical_compare(__x.begin(), __x.end(),
			    __y.begin(), __y.end());
    }

    friend bool _GLIBCXX_DEPRECATED__attribute__ ((__deprecated__))
    operator!=(const _Rb_tree& __x, const _Rb_tree& __y)
    { return !(__x == __y); }

    friend bool _GLIBCXX_DEPRECATED__attribute__ ((__deprecated__))
    operator>(const _Rb_tree& __x, const _Rb_tree& __y)
    { return __y < __x; }

    friend bool _GLIBCXX_DEPRECATED__attribute__ ((__deprecated__))
    operator<=(const _Rb_tree& __x, const _Rb_tree& __y)
    { return !(__y < __x); }

    friend bool _GLIBCXX_DEPRECATED__attribute__ ((__deprecated__))
    operator>=(const _Rb_tree& __x, const _Rb_tree& __y)
    { return !(__x < __y); }
1649#endif
  };

template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
  inline void
  swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
  { __x.swap(__y); }

1659#if __cplusplus201402L >= 201103L
template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
  void
  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
  _M_move_data(_Rb_tree& __x, false_type)
  {
    if (_M_get_Node_allocator() == __x._M_get_Node_allocator())
_M_move_data(__x, true_type());
    else
{
 _Alloc_node __an(*this);
 auto __lbd =
   [&__an](const value_type& __cval)
   {
     auto& __val = const_cast<value_type&>(__cval);
     return __an(std::move_if_noexcept(__val));
   };
 _M_root() = _M_copy(__x, __lbd);
}
  }

template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
  inline void
  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
  _M_move_assign(_Rb_tree& __x, true_type)
  {
    clear();
    if (__x._M_root() != nullptr)
_M_move_data(__x, true_type());
    std::__alloc_on_move(_M_get_Node_allocator(),
	   __x._M_get_Node_allocator());
  }

template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
  void
  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
  _M_move_assign(_Rb_tree& __x, false_type)
  {
    if (_M_get_Node_allocator() == __x._M_get_Node_allocator())
return _M_move_assign(__x, true_type{});

    // Try to move each node reusing existing nodes and copying __x nodes
    // structure.
    _Reuse_or_alloc_node __roan(*this);
    _M_impl._M_reset();
    if (__x._M_root() != nullptr)
{
 auto __lbd =
   [&__roan](const value_type& __cval)
   {
     auto& __val = const_cast<value_type&>(__cval);
     return __roan(std::move(__val));
   };
 _M_root() = _M_copy(__x, __lbd);
 __x.clear();
}
  }

template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
  inline _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&
  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
  operator=(_Rb_tree&& __x)
  noexcept(_Alloc_traits::_S_nothrow_move()
    && is_nothrow_move_assignable<_Compare>::value)
  {
    _M_impl._M_key_compare = std::move(__x._M_impl._M_key_compare);
    _M_move_assign(__x, __bool_constant<_Alloc_traits::_S_nothrow_move()>());
    return *this;
  }

template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
  template<typename _Iterator>
    void
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_assign_unique(_Iterator __first, _Iterator __last)
    {
_Reuse_or_alloc_node __roan(*this);
_M_impl._M_reset();
for (; __first != __last; ++__first)
 _M_insert_unique_(end(), *__first, __roan);
    }

template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
  template<typename _Iterator>
    void
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_assign_equal(_Iterator __first, _Iterator __last)
    {
_Reuse_or_alloc_node __roan(*this);
_M_impl._M_reset();
for (; __first != __last; ++__first)
 _M_insert_equal_(end(), *__first, __roan);
    }
1758#endif

template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&
  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
  operator=(const _Rb_tree& __x)
  {
    if (this != &__x)
{
 // Note that _Key may be a constant type.
1769#if __cplusplus201402L >= 201103L
 if (_Alloc_traits::_S_propagate_on_copy_assign())
   {
     auto& __this_alloc = this->_M_get_Node_allocator();
     auto& __that_alloc = __x._M_get_Node_allocator();
     if (!_Alloc_traits::_S_always_equal()
  && __this_alloc != __that_alloc)
{
  // Replacement allocator cannot free existing storage, we need
  // to erase nodes first.
  clear();
  std::__alloc_on_copy(__this_alloc, __that_alloc);
}
   }
1783#endif

 _Reuse_or_alloc_node __roan(*this);
 _M_impl._M_reset();
 _M_impl._M_key_compare = __x._M_impl._M_key_compare;
 if (__x._M_root() != 0)
   _M_root() = _M_copy(__x, __roan);
}

    return *this;
  }

template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
1797#if __cplusplus201402L >= 201103L
  template<typename _Arg, typename _NodeGen>
1799#else
  template<typename _NodeGen>
1801#endif
    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_insert_(_Base_ptr __x, _Base_ptr __p,
1805#if __cplusplus201402L >= 201103L
 _Arg&& __v,
1807#else
 const _Val& __v,
1809#endif
 _NodeGen& __node_gen)
    {
bool __insert_left = (__x != 0 || __p == _M_end()
	      || _M_impl._M_key_compare(_KeyOfValue()(__v),
					_S_key(__p)));

_Link_type __z = __node_gen(_GLIBCXX_FORWARD(_Arg, __v)std::forward<_Arg>(__v));

_Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
		      this->_M_impl._M_header);
++_M_impl._M_node_count;
return iterator(__z);
    }

template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
1826#if __cplusplus201402L >= 201103L
  template<typename _Arg>
1828#endif
  typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
1831#if __cplusplus201402L >= 201103L
  _M_insert_lower(_Base_ptr __p, _Arg&& __v)
1833#else
  _M_insert_lower(_Base_ptr __p, const _Val& __v)
1835#endif
  {
    bool __insert_left = (__p == _M_end()
	    || !_M_impl._M_key_compare(_S_key(__p),
				       _KeyOfValue()(__v)));

    _Link_type __z = _M_create_node(_GLIBCXX_FORWARD(_Arg, __v)std::forward<_Arg>(__v));

    _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
		    this->_M_impl._M_header);
    ++_M_impl._M_node_count;
    return iterator(__z);
  }

template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
1851#if __cplusplus201402L >= 201103L
  template<typename _Arg>
1853#endif
  typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
1856#if __cplusplus201402L >= 201103L
  _M_insert_equal_lower(_Arg&& __v)
1858#else
  _M_insert_equal_lower(const _Val& __v)
1860#endif
  {
    _Link_type __x = _M_begin();
    _Base_ptr __y = _M_end();
    while (__x != 0)
{
 __y = __x;
 __x = !_M_impl._M_key_compare(_S_key(__x), _KeyOfValue()(__v)) ?
_S_left(__x) : _S_right(__x);
}
    return _M_insert_lower(__y, _GLIBCXX_FORWARD(_Arg, __v)std::forward<_Arg>(__v));
  }

template<typename _Key, typename _Val, typename _KoV,
  typename _Compare, typename _Alloc>
  template<typename _NodeGen>
    typename _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::_Link_type
    _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::
    _M_copy(_Const_Link_type __x, _Base_ptr __p, _NodeGen& __node_gen)
    {
// Structural copy. __x and __p must be non-null.
_Link_type __top = _M_clone_node(__x, __node_gen);
__top->_M_parent = __p;

__tryif (true)
 {
   if (__x->_M_right)
     __top->_M_right = _M_copy(_S_right(__x), __top, __node_gen);
   __p = __top;
   __x = _S_left(__x);

   while (__x != 0)
     {
_Link_type __y = _M_clone_node(__x, __node_gen);
__p->_M_left = __y;
__y->_M_parent = __p;
if (__x->_M_right)
  __y->_M_right = _M_copy(_S_right(__x), __y, __node_gen);
__p = __y;
__x = _S_left(__x);
     }
 }
__catch(...)if (false)
 {
   _M_erase(__top);
   __throw_exception_again;
 }
return __top;
    }

template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
  void
  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
  _M_erase(_Link_type __x)
  {
    // Erase without rebalancing.
    while (__x != 0)
{
 _M_erase(_S_right(__x));
 _Link_type __y = _S_left(__x);
 _M_drop_node(__x);
 __x = __y;
}
  }

template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
  typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::iterator
  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
  _M_lower_bound(_Link_type __x, _Base_ptr __y,
   const _Key& __k)
  {
    while (__x != 0)
if (!_M_impl._M_key_compare(_S_key(__x), __k))
 __y = __x, __x = _S_left(__x);
else
 __x = _S_right(__x);
    return iterator(__y);
  }

template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
  typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::const_iterator
  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
  _M_lower_bound(_Const_Link_type __x, _Const_Base_ptr __y,
   const _Key& __k) const
  {
    while (__x != 0)
if (!_M_impl._M_key_compare(_S_key(__x), __k))
 __y = __x, __x = _S_left(__x);
else
 __x = _S_right(__x);
    return const_iterator(__y);
  }

template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
  typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::iterator
  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
  _M_upper_bound(_Link_type __x, _Base_ptr __y,
   const _Key& __k)
  {
    while (__x != 0)
if (_M_impl._M_key_compare(__k, _S_key(__x)))
 __y = __x, __x = _S_left(__x);
else
 __x = _S_right(__x);
    return iterator(__y);
  }

template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
  typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::const_iterator
  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
  _M_upper_bound(_Const_Link_type __x, _Const_Base_ptr __y,
   const _Key& __k) const
  {
    while (__x != 0)
if (_M_impl._M_key_compare(__k, _S_key(__x)))
 __y = __x, __x = _S_left(__x);
else
 __x = _S_right(__x);
    return const_iterator(__y);
  }

template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
  pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
	   _Compare, _Alloc>::iterator,
typename _Rb_tree<_Key, _Val, _KeyOfValue,
	   _Compare, _Alloc>::iterator>
  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
  equal_range(const _Key& __k)
  {
    _Link_type __x = _M_begin();
    _Base_ptr __y = _M_end();
    while (__x != 0)
{
 if (_M_impl._M_key_compare(_S_key(__x), __k))
   __x = _S_right(__x);
 else if (_M_impl._M_key_compare(__k, _S_key(__x)))
   __y = __x, __x = _S_left(__x);
 else
   {
     _Link_type __xu(__x);
     _Base_ptr __yu(__y);
     __y = __x, __x = _S_left(__x);
     __xu = _S_right(__xu);
     return pair<iterator,
	  iterator>(_M_lower_bound(__x, __y, __k),
		    _M_upper_bound(__xu, __yu, __k));
   }
}
    return pair<iterator, iterator>(iterator(__y),
		      iterator(__y));
  }

template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
  pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
	   _Compare, _Alloc>::const_iterator,
typename _Rb_tree<_Key, _Val, _KeyOfValue,
	   _Compare, _Alloc>::const_iterator>
  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
  equal_range(const _Key& __k) const
  {
    _Const_Link_type __x = _M_begin();
    _Const_Base_ptr __y = _M_end();
    while (__x != 0)
{
 if (_M_impl._M_key_compare(_S_key(__x), __k))
   __x = _S_right(__x);
 else if (_M_impl._M_key_compare(__k, _S_key(__x)))
   __y = __x, __x = _S_left(__x);
 else
   {
     _Const_Link_type __xu(__x);
     _Const_Base_ptr __yu(__y);
     __y = __x, __x = _S_left(__x);
     __xu = _S_right(__xu);
     return pair<const_iterator,
	  const_iterator>(_M_lower_bound(__x, __y, __k),
			  _M_upper_bound(__xu, __yu, __k));
   }
}
    return pair<const_iterator, const_iterator>(const_iterator(__y),
				  const_iterator(__y));
  }

template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
  void
  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
  swap(_Rb_tree& __t)
  _GLIBCXX_NOEXCEPT_IF(__is_nothrow_swappable<_Compare>::value)noexcept(__is_nothrow_swappable<_Compare>::value)
  {
    if (_M_root() == 0)
{
 if (__t._M_root() != 0)
   _M_impl._M_move_data(__t._M_impl);
}
    else if (__t._M_root() == 0)
__t._M_impl._M_move_data(_M_impl);
    else
{
 std::swap(_M_root(),__t._M_root());
 std::swap(_M_leftmost(),__t._M_leftmost());
 std::swap(_M_rightmost(),__t._M_rightmost());

 _M_root()->_M_parent = _M_end();
 __t._M_root()->_M_parent = __t._M_end();
 std::swap(this->_M_impl._M_node_count, __t._M_impl._M_node_count);
}
    // No need to swap header's color as it does not change.
    std::swap(this->_M_impl._M_key_compare, __t._M_impl._M_key_compare);

    _Alloc_traits::_S_on_swap(_M_get_Node_allocator(),
		__t._M_get_Node_allocator());
  }

template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
  pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
	   _Compare, _Alloc>::_Base_ptr,
typename _Rb_tree<_Key, _Val, _KeyOfValue,
	   _Compare, _Alloc>::_Base_ptr>
  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
  _M_get_insert_unique_pos(const key_type& __k)
  {
    typedef pair<_Base_ptr, _Base_ptr> _Res;
    _Link_type __x = _M_begin();
    _Base_ptr __y = _M_end();
    bool __comp = true;
    while (__x != 0)
{
 __y = __x;
 __comp = _M_impl._M_key_compare(__k, _S_key(__x));
 __x = __comp ? _S_left(__x) : _S_right(__x);
}
    iterator __j = iterator(__y);
    if (__comp)
{
 if (__j == begin())
   return _Res(__x, __y);
 else
   --__j;
}
    if (_M_impl._M_key_compare(_S_key(__j._M_node), __k))
return _Res(__x, __y);
    return _Res(__j._M_node, 0);
  }

template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
  pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
	   _Compare, _Alloc>::_Base_ptr,
typename _Rb_tree<_Key, _Val, _KeyOfValue,
	   _Compare, _Alloc>::_Base_ptr>
  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
  _M_get_insert_equal_pos(const key_type& __k)
  {
    typedef pair<_Base_ptr, _Base_ptr> _Res;
    _Link_type __x = _M_begin();
    _Base_ptr __y = _M_end();
    while (__x != 0)
{
 __y = __x;
 __x = _M_impl._M_key_compare(__k, _S_key(__x)) ?
_S_left(__x) : _S_right(__x);
}
    return _Res(__x, __y);
  }

template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
2140#if __cplusplus201402L >= 201103L
  template<typename _Arg>
2142#endif
  pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
	   _Compare, _Alloc>::iterator, bool>
  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
2146#if __cplusplus201402L >= 201103L
  _M_insert_unique(_Arg&& __v)
2148#else
  _M_insert_unique(const _Val& __v)
2150#endif
  {
    typedef pair<iterator, bool> _Res;
    pair<_Base_ptr, _Base_ptr> __res
= _M_get_insert_unique_pos(_KeyOfValue()(__v));

    if (__res.second)
{
 _Alloc_node __an(*this);
 return _Res(_M_insert_(__res.first, __res.second,
		 _GLIBCXX_FORWARD(_Arg, __v)std::forward<_Arg>(__v), __an),
      true);
}

    return _Res(iterator(__res.first), false);
  }

template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
2169#if __cplusplus201402L >= 201103L
  template<typename _Arg>
2171#endif
  typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
2174#if __cplusplus201402L >= 201103L
  _M_insert_equal(_Arg&& __v)
2176#else
  _M_insert_equal(const _Val& __v)
2178#endif
  {
    pair<_Base_ptr, _Base_ptr> __res
= _M_get_insert_equal_pos(_KeyOfValue()(__v));
    _Alloc_node __an(*this);
    return _M_insert_(__res.first, __res.second,
	_GLIBCXX_FORWARD(_Arg, __v)std::forward<_Arg>(__v), __an);
  }

template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
  pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
	   _Compare, _Alloc>::_Base_ptr,
typename _Rb_tree<_Key, _Val, _KeyOfValue,
	   _Compare, _Alloc>::_Base_ptr>
  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
  _M_get_insert_hint_unique_pos(const_iterator __position,
		  const key_type& __k)
  {
    iterator __pos = __position._M_const_cast();
    typedef pair<_Base_ptr, _Base_ptr> _Res;

    // end()
    if (__pos._M_node == _M_end())
{
 if (size() > 0
     && _M_impl._M_key_compare(_S_key(_M_rightmost()), __k))
   return _Res(0, _M_rightmost());
 else
   return _M_get_insert_unique_pos(__k);
}
    else if (_M_impl._M_key_compare(__k, _S_key(__pos._M_node)))
{
 // First, try before...
 iterator __before = __pos;
 if (__pos._M_node == _M_leftmost()) // begin()
   return _Res(_M_leftmost(), _M_leftmost());
 else if (_M_impl._M_key_compare(_S_key((--__before)._M_node), __k))
   {
     if (_S_right(__before._M_node) == 0)
return _Res(0, __before._M_node);
     else
return _Res(__pos._M_node, __pos._M_node);
   }
 else
   return _M_get_insert_unique_pos(__k);
}
    else if (_M_impl._M_key_compare(_S_key(__pos._M_node), __k))
{
 // ... then try after.
 iterator __after = __pos;
 if (__pos._M_node == _M_rightmost())
   return _Res(0, _M_rightmost());
 else if (_M_impl._M_key_compare(__k, _S_key((++__after)._M_node)))
   {
     if (_S_right(__pos._M_node) == 0)
return _Res(0, __pos._M_node);
     else
return _Res(__after._M_node, __after._M_node);
   }
 else
   return _M_get_insert_unique_pos(__k);
}
    else
// Equivalent keys.
return _Res(__pos._M_node, 0);
  }

template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
2248#if __cplusplus201402L >= 201103L
  template<typename _Arg, typename _NodeGen>
2250#else
  template<typename _NodeGen>
2252#endif
    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_insert_unique_(const_iterator __position,
2256#if __cplusplus201402L >= 201103L
	_Arg&& __v,
2258#else
	const _Val& __v,
2260#endif
	_NodeGen& __node_gen)
  {
    pair<_Base_ptr, _Base_ptr> __res
= _M_get_insert_hint_unique_pos(__position, _KeyOfValue()(__v));

    if (__res.second)
return _M_insert_(__res.first, __res.second,
	  _GLIBCXX_FORWARD(_Arg, __v)std::forward<_Arg>(__v),
	  __node_gen);
    return iterator(__res.first);
  }

template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
  pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
	   _Compare, _Alloc>::_Base_ptr,
typename _Rb_tree<_Key, _Val, _KeyOfValue,
	   _Compare, _Alloc>::_Base_ptr>
  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
  _M_get_insert_hint_equal_pos(const_iterator __position, const key_type& __k)
  {
    iterator __pos = __position._M_const_cast();
    typedef pair<_Base_ptr, _Base_ptr> _Res;

    // end()
    if (__pos._M_node == _M_end())
{
 if (size() > 0
     && !_M_impl._M_key_compare(__k, _S_key(_M_rightmost())))
   return _Res(0, _M_rightmost());
 else
   return _M_get_insert_equal_pos(__k);
}
    else if (!_M_impl._M_key_compare(_S_key(__pos._M_node), __k))
{
 // First, try before...
 iterator __before = __pos;
 if (__pos._M_node == _M_leftmost()) // begin()
   return _Res(_M_leftmost(), _M_leftmost());
 else if (!_M_impl._M_key_compare(__k, _S_key((--__before)._M_node)))
   {
     if (_S_right(__before._M_node) == 0)
return _Res(0, __before._M_node);
     else
return _Res(__pos._M_node, __pos._M_node);
   }
 else
   return _M_get_insert_equal_pos(__k);
}
    else
{
 // ... then try after.
 iterator __after = __pos;
 if (__pos._M_node == _M_rightmost())
   return _Res(0, _M_rightmost());
 else if (!_M_impl._M_key_compare(_S_key((++__after)._M_node), __k))
   {
     if (_S_right(__pos._M_node) == 0)
return _Res(0, __pos._M_node);
     else
return _Res(__after._M_node, __after._M_node);
   }
 else
   return _Res(0, 0);
}
  }

template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
2330#if __cplusplus201402L >= 201103L
  template<typename _Arg, typename _NodeGen>
2332#else
  template<typename _NodeGen>
2334#endif
    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_insert_equal_(const_iterator __position,
2338#if __cplusplus201402L >= 201103L
       _Arg&& __v,
2340#else
       const _Val& __v,
2342#endif
       _NodeGen& __node_gen)
    {
pair<_Base_ptr, _Base_ptr> __res
 = _M_get_insert_hint_equal_pos(__position, _KeyOfValue()(__v));

if (__res.second)
 return _M_insert_(__res.first, __res.second,
	    _GLIBCXX_FORWARD(_Arg, __v)std::forward<_Arg>(__v),
	    __node_gen);

return _M_insert_equal_lower(_GLIBCXX_FORWARD(_Arg, __v)std::forward<_Arg>(__v));
    }

2356#if __cplusplus201402L >= 201103L
template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
  typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
  _M_insert_node(_Base_ptr __x, _Base_ptr __p, _Link_type __z)
  {
    bool __insert_left = (__x != 0 || __p == _M_end()
	    || _M_impl._M_key_compare(_S_key(__z),
				      _S_key(__p)));

    _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
		    this->_M_impl._M_header);
    ++_M_impl._M_node_count;
    return iterator(__z);
  }

template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
  typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
  _M_insert_lower_node(_Base_ptr __p, _Link_type __z)
  {
    bool __insert_left = (__p == _M_end()
	    || !_M_impl._M_key_compare(_S_key(__p),
				       _S_key(__z)));

    _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
		    this->_M_impl._M_header);
    ++_M_impl._M_node_count;
    return iterator(__z);
  }

template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
  typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
  _M_insert_equal_lower_node(_Link_type __z)
  {
    _Link_type __x = _M_begin();
    _Base_ptr __y = _M_end();
    while (__x != 0)
{
 __y = __x;
 __x = !_M_impl._M_key_compare(_S_key(__x), _S_key(__z)) ?
_S_left(__x) : _S_right(__x);
}
    return _M_insert_lower_node(__y, __z);
  }

template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
  template<typename... _Args>
    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
	     _Compare, _Alloc>::iterator, bool>
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_emplace_unique(_Args&&... __args)
    {
_Link_type __z = _M_create_node(std::forward<_Args>(__args)...);

__tryif (true)
 {
   typedef pair<iterator, bool> _Res;
   auto __res = _M_get_insert_unique_pos(_S_key(__z));
   if (__res.second)
     return _Res(_M_insert_node(__res.first, __res.second, __z), true);

   _M_drop_node(__z);
   return _Res(iterator(__res.first), false);
 }
__catch(...)if (false)
 {
   _M_drop_node(__z);
   __throw_exception_again;
 }
    }

template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
  template<typename... _Args>
    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_emplace_equal(_Args&&... __args)
    {
_Link_type __z = _M_create_node(std::forward<_Args>(__args)...);

__tryif (true)
 {
   auto __res = _M_get_insert_equal_pos(_S_key(__z));
   return _M_insert_node(__res.first, __res.second, __z);
 }
__catch(...)if (false)
 {
   _M_drop_node(__z);
   __throw_exception_again;
 }
    }

template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
  template<typename... _Args>
    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_emplace_hint_unique(const_iterator __pos, _Args&&... __args)
    {
_Link_type __z = _M_create_node(std::forward<_Args>(__args)...);

__tryif (true)
 {
   auto __res = _M_get_insert_hint_unique_pos(__pos, _S_key(__z));

   if (__res.second)
     return _M_insert_node(__res.first, __res.second, __z);

   _M_drop_node(__z);
   return iterator(__res.first);
 }
__catch(...)if (false)
 {
   _M_drop_node(__z);
   __throw_exception_again;
 }
    }

template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
  template<typename... _Args>
    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_emplace_hint_equal(const_iterator __pos, _Args&&... __args)
    {
_Link_type __z = _M_create_node(std::forward<_Args>(__args)...);

__tryif (true)
 {
   auto __res = _M_get_insert_hint_equal_pos(__pos, _S_key(__z));

   if (__res.second)
     return _M_insert_node(__res.first, __res.second, __z);

   return _M_insert_equal_lower_node(__z);
 }
__catch(...)if (false)
 {
   _M_drop_node(__z);
   __throw_exception_again;
 }
    }
2504#endif


template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
  void
  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
  _M_erase_aux(const_iterator __position)
  {
    _Link_type __y =
static_cast<_Link_type>(_Rb_tree_rebalance_for_erase
		(const_cast<_Base_ptr>(__position._M_node),
		 this->_M_impl._M_header));
    _M_drop_node(__y);
    --_M_impl._M_node_count;
  }

template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
  void
  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
  _M_erase_aux(const_iterator __first, const_iterator __last)
  {
    if (__first == begin() && __last == end())
clear();
    else
while (__first != __last)
 _M_erase_aux(__first++);
  }

template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
  typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type
  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
  erase(const _Key& __x)
  {
    pair<iterator, iterator> __p = equal_range(__x);
    const size_type __old_size = size();
    _M_erase_aux(__p.first, __p.second);
    return __old_size - size();
  }

template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
  typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::iterator
  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
  find(const _Key& __k)
  {
    iterator __j = _M_lower_bound(_M_begin(), _M_end(), __k);
    return (__j == end()
     || _M_impl._M_key_compare(__k,
			_S_key(__j._M_node))) ? end() : __j;
  }

template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
  typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::const_iterator
  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
  find(const _Key& __k) const
  {
    const_iterator __j = _M_lower_bound(_M_begin(), _M_end(), __k);
    return (__j == end()
     || _M_impl._M_key_compare(__k,
			_S_key(__j._M_node))) ? end() : __j;
  }

template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
  typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type
  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
  count(const _Key& __k) const
  {
    pair<const_iterator, const_iterator> __p = equal_range(__k);
    const size_type __n = std::distance(__p.first, __p.second);
    return __n;
  }

_GLIBCXX_PURE__attribute__ ((__pure__)) unsigned int
_Rb_tree_black_count(const _Rb_tree_node_base* __node,
       const _Rb_tree_node_base* __root) throw ();

template<typename _Key, typename _Val, typename _KeyOfValue,
  typename _Compare, typename _Alloc>
  bool
  _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::__rb_verify() const
  {
    if (_M_impl._M_node_count == 0 || begin() == end())
return _M_impl._M_node_count == 0 && begin() == end()
      && this->_M_impl._M_header._M_left == _M_end()
      && this->_M_impl._M_header._M_right == _M_end();

    unsigned int __len = _Rb_tree_black_count(_M_leftmost(), _M_root());
    for (const_iterator __it = begin(); __it != end(); ++__it)
{
 _Const_Link_type __x = static_cast<_Const_Link_type>(__it._M_node);
 _Const_Link_type __L = _S_left(__x);
 _Const_Link_type __R = _S_right(__x);

 if (__x->_M_color == _S_red)
   if ((__L && __L->_M_color == _S_red)
|| (__R && __R->_M_color == _S_red))
     return false;

 if (__L && _M_impl._M_key_compare(_S_key(__x), _S_key(__L)))
   return false;
 if (__R && _M_impl._M_key_compare(_S_key(__R), _S_key(__x)))
   return false;

 if (!__L && !__R && _Rb_tree_black_count(__x, _M_root()) != __len)
   return false;
}

    if (_M_leftmost() != _Rb_tree_node_base::_S_minimum(_M_root()))
return false;
    if (_M_rightmost() != _Rb_tree_node_base::_S_maximum(_M_root()))
return false;
    return true;
  }

2625#if __cplusplus201402L > 201402L
// Allow access to internals of compatible _Rb_tree specializations.
template<typename _Key, typename _Val, typename _Sel, typename _Cmp1,
  typename _Alloc, typename _Cmp2>
  struct _Rb_tree_merge_helper<_Rb_tree<_Key, _Val, _Sel, _Cmp1, _Alloc>,
		 _Cmp2>
  {
  private:
    friend class _Rb_tree<_Key, _Val, _Sel, _Cmp1, _Alloc>;

    static auto&
    _S_get_impl(_Rb_tree<_Key, _Val, _Sel, _Cmp2, _Alloc>& __tree)
    { return __tree._M_impl; }
  };
2639#endif // C++17

2641_GLIBCXX_END_NAMESPACE_VERSION
2642} // namespace

2644#endif

←

/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/ADT/DenseMap.h

1//===- llvm/ADT/DenseMap.h - Dense probed hash table ------------*- 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 DenseMap class.
10//
11//===----------------------------------------------------------------------===//

13#ifndef LLVM_ADT_DENSEMAP_H
14#define LLVM_ADT_DENSEMAP_H

16#include "llvm/ADT/DenseMapInfo.h"
17#include "llvm/ADT/EpochTracker.h"
18#include "llvm/Support/AlignOf.h"
19#include "llvm/Support/Compiler.h"
20#include "llvm/Support/MathExtras.h"
21#include "llvm/Support/MemAlloc.h"
22#include "llvm/Support/ReverseIteration.h"
23#include "llvm/Support/type_traits.h"
24#include <algorithm>
25#include <cassert>
26#include <cstddef>
27#include <cstring>
28#include <initializer_list>
29#include <iterator>
30#include <new>
31#include <type_traits>
32#include <utility>

34namespace llvm {

36namespace detail {

38// We extend a pair to allow users to override the bucket type with their own
39// implementation without requiring two members.
40template <typename KeyT, typename ValueT>
41struct DenseMapPair : public std::pair<KeyT, ValueT> {
using std::pair<KeyT, ValueT>::pair;

KeyT &getFirst() { return std::pair<KeyT, ValueT>::first; }
const KeyT &getFirst() const { return std::pair<KeyT, ValueT>::first; }
ValueT &getSecond() { return std::pair<KeyT, ValueT>::second; }
const ValueT &getSecond() const { return std::pair<KeyT, ValueT>::second; }
48};

50} // end namespace detail

52template <typename KeyT, typename ValueT,
        typename KeyInfoT = DenseMapInfo<KeyT>,
        typename Bucket = llvm::detail::DenseMapPair<KeyT, ValueT>,
        bool IsConst = false>
56class DenseMapIterator;

58template <typename DerivedT, typename KeyT, typename ValueT, typename KeyInfoT,
        typename BucketT>
60class DenseMapBase : public DebugEpochBase {
template <typename T>
using const_arg_type_t = typename const_pointer_or_const_ref<T>::type;

64public:
using size_type = unsigned;
using key_type = KeyT;
using mapped_type = ValueT;
using value_type = BucketT;

using iterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT>;
using const_iterator =
    DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT, true>;

inline iterator begin() {
  // When the map is empty, avoid the overhead of advancing/retreating past
  // empty buckets.
  if (empty())
    return end();
  if (shouldReverseIterate<KeyT>())
    return makeIterator(getBucketsEnd() - 1, getBuckets(), *this);
  return makeIterator(getBuckets(), getBucketsEnd(), *this);
}
inline iterator end() {
  return makeIterator(getBucketsEnd(), getBucketsEnd(), *this, true);
}
inline const_iterator begin() const {
  if (empty())
    return end();
  if (shouldReverseIterate<KeyT>())
    return makeConstIterator(getBucketsEnd() - 1, getBuckets(), *this);
  return makeConstIterator(getBuckets(), getBucketsEnd(), *this);
}
inline const_iterator end() const {
  return makeConstIterator(getBucketsEnd(), getBucketsEnd(), *this, true);
}

LLVM_NODISCARD[[clang::warn_unused_result]] bool empty() const {
  return getNumEntries() == 0;
}
unsigned size() const { return getNumEntries(); }

/// Grow the densemap so that it can contain at least \p NumEntries items
/// before resizing again.
void reserve(size_type NumEntries) {
  auto NumBuckets = getMinBucketToReserveForEntries(NumEntries);
  incrementEpoch();
  if (NumBuckets > getNumBuckets())
    grow(NumBuckets);
}

void clear() {
  incrementEpoch();
  if (getNumEntries() == 0 && getNumTombstones() == 0) return;

  // If the capacity of the array is huge, and the # elements used is small,
  // shrink the array.
  if (getNumEntries() * 4 < getNumBuckets() && getNumBuckets() > 64) {
    shrink_and_clear();
    return;
  }

  const KeyT EmptyKey = getEmptyKey(), TombstoneKey = getTombstoneKey();
  if (std::is_trivially_destructible<ValueT>::value) {
    // Use a simpler loop when values don't need destruction.
    for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P)
      P->getFirst() = EmptyKey;
  } else {
    unsigned NumEntries = getNumEntries();
    for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) {
      if (!KeyInfoT::isEqual(P->getFirst(), EmptyKey)) {
        if (!KeyInfoT::isEqual(P->getFirst(), TombstoneKey)) {
          P->getSecond().~ValueT();
          --NumEntries;
        }
        P->getFirst() = EmptyKey;
      }
    }
    assert(NumEntries == 0 && "Node count imbalance!")(static_cast <bool> (NumEntries == 0 && "Node count imbalance!"
) ? void (0) : __assert_fail ("NumEntries == 0 && \"Node count imbalance!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/ADT/DenseMap.h"
, 138, __extension__ __PRETTY_FUNCTION__));
  }
  setNumEntries(0);
  setNumTombstones(0);
}

/// Return 1 if the specified key is in the map, 0 otherwise.
size_type count(const_arg_type_t<KeyT> Val) const {
  const BucketT *TheBucket;
  return LookupBucketFor(Val, TheBucket) ? 1 : 0;
}

iterator find(const_arg_type_t<KeyT> Val) {
  BucketT *TheBucket;
  if (LookupBucketFor(Val, TheBucket))
    return makeIterator(TheBucket,
                        shouldReverseIterate<KeyT>() ? getBuckets()
                                                     : getBucketsEnd(),
                        *this, true);
  return end();
}
const_iterator find(const_arg_type_t<KeyT> Val) const {
  const BucketT *TheBucket;
  if (LookupBucketFor(Val, TheBucket))
    return makeConstIterator(TheBucket,
                             shouldReverseIterate<KeyT>() ? getBuckets()
                                                          : getBucketsEnd(),
                             *this, true);
  return end();
}

/// Alternate version of find() which allows a different, and possibly
/// less expensive, key type.
/// The DenseMapInfo is responsible for supplying methods
/// getHashValue(LookupKeyT) and isEqual(LookupKeyT, KeyT) for each key
/// type used.
template<class LookupKeyT>
iterator find_as(const LookupKeyT &Val) {
  BucketT *TheBucket;
  if (LookupBucketFor(Val, TheBucket))
    return makeIterator(TheBucket,
                        shouldReverseIterate<KeyT>() ? getBuckets()
                                                     : getBucketsEnd(),
                        *this, true);
  return end();
}
template<class LookupKeyT>
const_iterator find_as(const LookupKeyT &Val) const {
  const BucketT *TheBucket;
  if (LookupBucketFor(Val, TheBucket))
    return makeConstIterator(TheBucket,
                             shouldReverseIterate<KeyT>() ? getBuckets()
                                                          : getBucketsEnd(),
                             *this, true);
  return end();
}

/// lookup - Return the entry for the specified key, or a default
/// constructed value if no such entry exists.
ValueT lookup(const_arg_type_t<KeyT> Val) const {
  const BucketT *TheBucket;
  if (LookupBucketFor(Val, TheBucket))
    return TheBucket->getSecond();
  return ValueT();
}

// Inserts key,value pair into the map if the key isn't already in the map.
// If the key is already in the map, it returns false and doesn't update the
// value.
std::pair<iterator, bool> insert(const std::pair<KeyT, ValueT> &KV) {
  return try_emplace(KV.first, KV.second);
}

// Inserts key,value pair into the map if the key isn't already in the map.
// If the key is already in the map, it returns false and doesn't update the
// value.
std::pair<iterator, bool> insert(std::pair<KeyT, ValueT> &&KV) {
  return try_emplace(std::move(KV.first), std::move(KV.second));
}

// Inserts key,value pair into the map if the key isn't already in the map.
// The value is constructed in-place if the key is not in the map, otherwise
// it is not moved.
template <typename... Ts>
std::pair<iterator, bool> try_emplace(KeyT &&Key, Ts &&... Args) {
  BucketT *TheBucket;
  if (LookupBucketFor(Key, TheBucket))
    return std::make_pair(makeIterator(TheBucket,
                                       shouldReverseIterate<KeyT>()
                                           ? getBuckets()
                                           : getBucketsEnd(),
                                       *this, true),
                          false); // Already in map.

  // Otherwise, insert the new element.
  TheBucket =
      InsertIntoBucket(TheBucket, std::move(Key), std::forward<Ts>(Args)...);
  return std::make_pair(makeIterator(TheBucket,
                                     shouldReverseIterate<KeyT>()
                                         ? getBuckets()
                                         : getBucketsEnd(),
                                     *this, true),
                        true);
}

// Inserts key,value pair into the map if the key isn't already in the map.
// The value is constructed in-place if the key is not in the map, otherwise
// it is not moved.
template <typename... Ts>
std::pair<iterator, bool> try_emplace(const KeyT &Key, Ts &&... Args) {
  BucketT *TheBucket;
  if (LookupBucketFor(Key, TheBucket))
    return std::make_pair(makeIterator(TheBucket,
                                       shouldReverseIterate<KeyT>()
                                           ? getBuckets()
                                           : getBucketsEnd(),
                                       *this, true),
                          false); // Already in map.

  // Otherwise, insert the new element.
  TheBucket = InsertIntoBucket(TheBucket, Key, std::forward<Ts>(Args)...);
  return std::make_pair(makeIterator(TheBucket,
                                     shouldReverseIterate<KeyT>()
                                         ? getBuckets()
                                         : getBucketsEnd(),
                                     *this, true),
                        true);
}

/// Alternate version of insert() which allows a different, and possibly
/// less expensive, key type.
/// The DenseMapInfo is responsible for supplying methods
/// getHashValue(LookupKeyT) and isEqual(LookupKeyT, KeyT) for each key
/// type used.
template <typename LookupKeyT>
std::pair<iterator, bool> insert_as(std::pair<KeyT, ValueT> &&KV,
                                    const LookupKeyT &Val) {
  BucketT *TheBucket;
  if (LookupBucketFor(Val, TheBucket))
    return std::make_pair(makeIterator(TheBucket,
                                       shouldReverseIterate<KeyT>()
                                           ? getBuckets()
                                           : getBucketsEnd(),
                                       *this, true),
                          false); // Already in map.

  // Otherwise, insert the new element.
  TheBucket = InsertIntoBucketWithLookup(TheBucket, std::move(KV.first),
                                         std::move(KV.second), Val);
  return std::make_pair(makeIterator(TheBucket,
                                     shouldReverseIterate<KeyT>()
                                         ? getBuckets()
                                         : getBucketsEnd(),
                                     *this, true),
                        true);
}

/// insert - Range insertion of pairs.
template<typename InputIt>
void insert(InputIt I, InputIt E) {
  for (; I != E; ++I)
    insert(*I);
}

bool erase(const KeyT &Val) {
  BucketT *TheBucket;
  if (!LookupBucketFor(Val, TheBucket))
    return false; // not in map.

  TheBucket->getSecond().~ValueT();
  TheBucket->getFirst() = getTombstoneKey();
  decrementNumEntries();
  incrementNumTombstones();
  return true;
}
void erase(iterator I) {
  BucketT *TheBucket = &*I;
  TheBucket->getSecond().~ValueT();
  TheBucket->getFirst() = getTombstoneKey();
  decrementNumEntries();
  incrementNumTombstones();
}

value_type& FindAndConstruct(const KeyT &Key) {
  BucketT *TheBucket;
  if (LookupBucketFor(Key, TheBucket))
    return *TheBucket;

  return *InsertIntoBucket(TheBucket, Key);
}

ValueT &operator[](const KeyT &Key) {
  return FindAndConstruct(Key).second;
}

value_type& FindAndConstruct(KeyT &&Key) {
  BucketT *TheBucket;
  if (LookupBucketFor(Key, TheBucket))
    return *TheBucket;

  return *InsertIntoBucket(TheBucket, std::move(Key));
}

ValueT &operator[](KeyT &&Key) {
  return FindAndConstruct(std::move(Key)).second;
}

/// isPointerIntoBucketsArray - Return true if the specified pointer points
/// somewhere into the DenseMap's array of buckets (i.e. either to a key or
/// value in the DenseMap).
bool isPointerIntoBucketsArray(const void *Ptr) const {
  return Ptr >= getBuckets() && Ptr < getBucketsEnd();
}

/// getPointerIntoBucketsArray() - Return an opaque pointer into the buckets
/// array.  In conjunction with the previous method, this can be used to
/// determine whether an insertion caused the DenseMap to reallocate.
const void *getPointerIntoBucketsArray() const { return getBuckets(); }

357protected:
DenseMapBase() = default;

void destroyAll() {
  if (getNumBuckets() == 0) // Nothing to do.
    return;

  const KeyT EmptyKey = getEmptyKey(), TombstoneKey = getTombstoneKey();
  for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) {
    if (!KeyInfoT::isEqual(P->getFirst(), EmptyKey) &&
        !KeyInfoT::isEqual(P->getFirst(), TombstoneKey))
      P->getSecond().~ValueT();
    P->getFirst().~KeyT();
  }
}

void initEmpty() {
  setNumEntries(0);
  setNumTombstones(0);

  assert((getNumBuckets() & (getNumBuckets()-1)) == 0 &&(static_cast <bool> ((getNumBuckets() & (getNumBuckets
()-1)) == 0 && "# initial buckets must be a power of two!"
) ? void (0) : __assert_fail ("(getNumBuckets() & (getNumBuckets()-1)) == 0 && \"# initial buckets must be a power of two!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/ADT/DenseMap.h"
, 378, __extension__ __PRETTY_FUNCTION__))
         "# initial buckets must be a power of two!")(static_cast <bool> ((getNumBuckets() & (getNumBuckets
()-1)) == 0 && "# initial buckets must be a power of two!"
) ? void (0) : __assert_fail ("(getNumBuckets() & (getNumBuckets()-1)) == 0 && \"# initial buckets must be a power of two!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/ADT/DenseMap.h"
, 378, __extension__ __PRETTY_FUNCTION__));
  const KeyT EmptyKey = getEmptyKey();
  for (BucketT *B = getBuckets(), *E = getBucketsEnd(); B != E; ++B)
    ::new (&B->getFirst()) KeyT(EmptyKey);
}

/// Returns the number of buckets to allocate to ensure that the DenseMap can
/// accommodate \p NumEntries without need to grow().
unsigned getMinBucketToReserveForEntries(unsigned NumEntries) {
  // Ensure that "NumEntries * 4 < NumBuckets * 3"
  if (NumEntries == 0)
    return 0;
  // +1 is required because of the strict equality.
  // For example if NumEntries is 48, we need to return 401.
  return NextPowerOf2(NumEntries * 4 / 3 + 1);
}

void moveFromOldBuckets(BucketT *OldBucketsBegin, BucketT *OldBucketsEnd) {
  initEmpty();

  // Insert all the old elements.
  const KeyT EmptyKey = getEmptyKey();
  const KeyT TombstoneKey = getTombstoneKey();
  for (BucketT *B = OldBucketsBegin, *E = OldBucketsEnd; B != E; ++B) {
    if (!KeyInfoT::isEqual(B->getFirst(), EmptyKey) &&
        !KeyInfoT::isEqual(B->getFirst(), TombstoneKey)) {
      // Insert the key/value into the new table.
      BucketT *DestBucket;
      bool FoundVal = LookupBucketFor(B->getFirst(), DestBucket);
      (void)FoundVal; // silence warning.
      assert(!FoundVal && "Key already in new map?")(static_cast <bool> (!FoundVal && "Key already in new map?"
) ? void (0) : __assert_fail ("!FoundVal && \"Key already in new map?\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/ADT/DenseMap.h"
, 408, __extension__ __PRETTY_FUNCTION__));
      DestBucket->getFirst() = std::move(B->getFirst());
      ::new (&DestBucket->getSecond()) ValueT(std::move(B->getSecond()));
      incrementNumEntries();

      // Free the value.
      B->getSecond().~ValueT();
    }
    B->getFirst().~KeyT();
  }
}

template <typename OtherBaseT>
void copyFrom(
    const DenseMapBase<OtherBaseT, KeyT, ValueT, KeyInfoT, BucketT> &other) {
  assert(&other != this)(static_cast <bool> (&other != this) ? void (0) : __assert_fail
 ("&other != this", "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/ADT/DenseMap.h"
, 423, __extension__ __PRETTY_FUNCTION__));
  assert(getNumBuckets() == other.getNumBuckets())(static_cast <bool> (getNumBuckets() == other.getNumBuckets
()) ? void (0) : __assert_fail ("getNumBuckets() == other.getNumBuckets()"
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/ADT/DenseMap.h"
, 424, __extension__ __PRETTY_FUNCTION__));

  setNumEntries(other.getNumEntries());
  setNumTombstones(other.getNumTombstones());

  if (std::is_trivially_copyable<KeyT>::value &&
      std::is_trivially_copyable<ValueT>::value)
    memcpy(reinterpret_cast<void *>(getBuckets()), other.getBuckets(),
           getNumBuckets() * sizeof(BucketT));
  else
    for (size_t i = 0; i < getNumBuckets(); ++i) {
      ::new (&getBuckets()[i].getFirst())
          KeyT(other.getBuckets()[i].getFirst());
      if (!KeyInfoT::isEqual(getBuckets()[i].getFirst(), getEmptyKey()) &&
          !KeyInfoT::isEqual(getBuckets()[i].getFirst(), getTombstoneKey()))
        ::new (&getBuckets()[i].getSecond())
            ValueT(other.getBuckets()[i].getSecond());
    }
}

static unsigned getHashValue(const KeyT &Val) {
  return KeyInfoT::getHashValue(Val);
}

template<typename LookupKeyT>
static unsigned getHashValue(const LookupKeyT &Val) {
  return KeyInfoT::getHashValue(Val);
}

static const KeyT getEmptyKey() {
  static_assert(std::is_base_of<DenseMapBase, DerivedT>::value,
                "Must pass the derived type to this template!");
  return KeyInfoT::getEmptyKey();
}

static const KeyT getTombstoneKey() {
  return KeyInfoT::getTombstoneKey();
}

463private:
iterator makeIterator(BucketT *P, BucketT *E,
                      DebugEpochBase &Epoch,
                      bool NoAdvance=false) {
  if (shouldReverseIterate<KeyT>()) {
    BucketT *B = P == getBucketsEnd() ? getBuckets() : P + 1;
    return iterator(B, E, Epoch, NoAdvance);
  }
  return iterator(P, E, Epoch, NoAdvance);
}

const_iterator makeConstIterator(const BucketT *P, const BucketT *E,
                                 const DebugEpochBase &Epoch,
                                 const bool NoAdvance=false) const {
  if (shouldReverseIterate<KeyT>()) {
    const BucketT *B = P == getBucketsEnd() ? getBuckets() : P + 1;
    return const_iterator(B, E, Epoch, NoAdvance);
  }
  return const_iterator(P, E, Epoch, NoAdvance);
}

unsigned getNumEntries() const {
  return static_cast<const DerivedT *>(this)->getNumEntries();
}

void setNumEntries(unsigned Num) {
  static_cast<DerivedT *>(this)->setNumEntries(Num);
}

void incrementNumEntries() {
  setNumEntries(getNumEntries() + 1);
}

void decrementNumEntries() {
  setNumEntries(getNumEntries() - 1);
}

unsigned getNumTombstones() const {
  return static_cast<const DerivedT *>(this)->getNumTombstones();
}

void setNumTombstones(unsigned Num) {
  static_cast<DerivedT *>(this)->setNumTombstones(Num);
}

void incrementNumTombstones() {
  setNumTombstones(getNumTombstones() + 1);
}

void decrementNumTombstones() {
  setNumTombstones(getNumTombstones() - 1);
}

const BucketT *getBuckets() const {
  return static_cast<const DerivedT *>(this)->getBuckets();
}

BucketT *getBuckets() {
  return static_cast<DerivedT *>(this)->getBuckets();
}

unsigned getNumBuckets() const {
  return static_cast<const DerivedT *>(this)->getNumBuckets();
}

BucketT *getBucketsEnd() {
  return getBuckets() + getNumBuckets();
}

const BucketT *getBucketsEnd() const {
  return getBuckets() + getNumBuckets();
}

void grow(unsigned AtLeast) {
  static_cast<DerivedT *>(this)->grow(AtLeast);
}

void shrink_and_clear() {
  static_cast<DerivedT *>(this)->shrink_and_clear();
}

template <typename KeyArg, typename... ValueArgs>
BucketT *InsertIntoBucket(BucketT *TheBucket, KeyArg &&Key,
                          ValueArgs &&... Values) {
  TheBucket = InsertIntoBucketImpl(Key, Key, TheBucket);

  TheBucket->getFirst() = std::forward<KeyArg>(Key);
  ::new (&TheBucket->getSecond()) ValueT(std::forward<ValueArgs>(Values)...);
  return TheBucket;
}

template <typename LookupKeyT>
BucketT *InsertIntoBucketWithLookup(BucketT *TheBucket, KeyT &&Key,
                                    ValueT &&Value, LookupKeyT &Lookup) {
  TheBucket = InsertIntoBucketImpl(Key, Lookup, TheBucket);

  TheBucket->getFirst() = std::move(Key);
  ::new (&TheBucket->getSecond()) ValueT(std::move(Value));
  return TheBucket;
}

template <typename LookupKeyT>
BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
                              BucketT *TheBucket) {
  incrementEpoch();

  // If the load of the hash table is more than 3/4, or if fewer than 1/8 of
  // the buckets are empty (meaning that many are filled with tombstones),
  // grow the table.
  //
  // The later case is tricky.  For example, if we had one empty bucket with
  // tons of tombstones, failing lookups (e.g. for insertion) would have to
  // probe almost the entire table until it found the empty bucket.  If the
  // table completely filled with tombstones, no lookup would ever succeed,
  // causing infinite loops in lookup.
  unsigned NewNumEntries = getNumEntries() + 1;
  unsigned NumBuckets = getNumBuckets();
  if (LLVM_UNLIKELY(NewNumEntries * 4 >= NumBuckets * 3)__builtin_expect((bool)(NewNumEntries * 4 >= NumBuckets * 3
), false)) {
    this->grow(NumBuckets * 2);
    LookupBucketFor(Lookup, TheBucket);
    NumBuckets = getNumBuckets();
  } else if (LLVM_UNLIKELY(NumBuckets-(NewNumEntries+getNumTombstones()) <=__builtin_expect((bool)(NumBuckets-(NewNumEntries+getNumTombstones
()) <= NumBuckets/8), false)
                           NumBuckets/8)__builtin_expect((bool)(NumBuckets-(NewNumEntries+getNumTombstones
()) <= NumBuckets/8), false)) {
    this->grow(NumBuckets);
    LookupBucketFor(Lookup, TheBucket);
  }
  assert(TheBucket)(static_cast <bool> (TheBucket) ? void (0) : __assert_fail
 ("TheBucket", "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/ADT/DenseMap.h"
, 589, __extension__ __PRETTY_FUNCTION__));

  // Only update the state after we've grown our bucket space appropriately
  // so that when growing buckets we have self-consistent entry count.
  incrementNumEntries();

  // If we are writing over a tombstone, remember this.
  const KeyT EmptyKey = getEmptyKey();
  if (!KeyInfoT::isEqual(TheBucket->getFirst(), EmptyKey))
    decrementNumTombstones();

  return TheBucket;
}

/// LookupBucketFor - Lookup the appropriate bucket for Val, returning it in
/// FoundBucket.  If the bucket contains the key and a value, this returns
/// true, otherwise it returns a bucket with an empty marker or tombstone and
/// returns false.
template<typename LookupKeyT>
bool LookupBucketFor(const LookupKeyT &Val,
                     const BucketT *&FoundBucket) const {
  const BucketT *BucketsPtr = getBuckets();
  const unsigned NumBuckets = getNumBuckets();

  if (NumBuckets == 0) {
    FoundBucket = nullptr;
    return false;
  }

  // FoundTombstone - Keep track of whether we find a tombstone while probing.
  const BucketT *FoundTombstone = nullptr;
  const KeyT EmptyKey = getEmptyKey();
  const KeyT TombstoneKey = getTombstoneKey();
  assert(!KeyInfoT::isEqual(Val, EmptyKey) &&(static_cast <bool> (!KeyInfoT::isEqual(Val, EmptyKey) &&
 !KeyInfoT::isEqual(Val, TombstoneKey) && "Empty/Tombstone value shouldn't be inserted into map!"
) ? void (0) : __assert_fail ("!KeyInfoT::isEqual(Val, EmptyKey) && !KeyInfoT::isEqual(Val, TombstoneKey) && \"Empty/Tombstone value shouldn't be inserted into map!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/ADT/DenseMap.h"
, 624, __extension__ __PRETTY_FUNCTION__))
         !KeyInfoT::isEqual(Val, TombstoneKey) &&(static_cast <bool> (!KeyInfoT::isEqual(Val, EmptyKey) &&
 !KeyInfoT::isEqual(Val, TombstoneKey) && "Empty/Tombstone value shouldn't be inserted into map!"
) ? void (0) : __assert_fail ("!KeyInfoT::isEqual(Val, EmptyKey) && !KeyInfoT::isEqual(Val, TombstoneKey) && \"Empty/Tombstone value shouldn't be inserted into map!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/ADT/DenseMap.h"
, 624, __extension__ __PRETTY_FUNCTION__))
         "Empty/Tombstone value shouldn't be inserted into map!")(static_cast <bool> (!KeyInfoT::isEqual(Val, EmptyKey) &&
 !KeyInfoT::isEqual(Val, TombstoneKey) && "Empty/Tombstone value shouldn't be inserted into map!"
) ? void (0) : __assert_fail ("!KeyInfoT::isEqual(Val, EmptyKey) && !KeyInfoT::isEqual(Val, TombstoneKey) && \"Empty/Tombstone value shouldn't be inserted into map!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/ADT/DenseMap.h"
, 624, __extension__ __PRETTY_FUNCTION__));

  unsigned BucketNo = getHashValue(Val) & (NumBuckets-1);
  unsigned ProbeAmt = 1;
  while (true) {
    const BucketT *ThisBucket = BucketsPtr + BucketNo;
    // Found Val's bucket?  If so, return it.
    if (LLVM_LIKELY(KeyInfoT::isEqual(Val, ThisBucket->getFirst()))__builtin_expect((bool)(KeyInfoT::isEqual(Val, ThisBucket->
getFirst())), true)) {
      FoundBucket = ThisBucket;
      return true;
    }

    // If we found an empty bucket, the key doesn't exist in the set.
    // Insert it and return the default value.
    if (LLVM_LIKELY(KeyInfoT::isEqual(ThisBucket->getFirst(), EmptyKey))__builtin_expect((bool)(KeyInfoT::isEqual(ThisBucket->getFirst
(), EmptyKey)), true)) {
      // If we've already seen a tombstone while probing, fill it in instead
      // of the empty bucket we eventually probed to.
      FoundBucket = FoundTombstone ? FoundTombstone : ThisBucket;
      return false;
    }

    // If this is a tombstone, remember it.  If Val ends up not in the map, we
    // prefer to return it than something that would require more probing.
    if (KeyInfoT::isEqual(ThisBucket->getFirst(), TombstoneKey) &&
        !FoundTombstone)
      FoundTombstone = ThisBucket;  // Remember the first tombstone found.

    // Otherwise, it's a hash collision or a tombstone, continue quadratic
    // probing.
    BucketNo += ProbeAmt++;
    BucketNo &= (NumBuckets-1);
  }
}

template <typename LookupKeyT>
bool LookupBucketFor(const LookupKeyT &Val, BucketT *&FoundBucket) {
  const BucketT *ConstFoundBucket;
  bool Result = const_cast<const DenseMapBase *>(this)
    ->LookupBucketFor(Val, ConstFoundBucket);
  FoundBucket = const_cast<BucketT *>(ConstFoundBucket);
  return Result;
}

667public:
/// Return the approximate size (in bytes) of the actual map.
/// This is just the raw memory used by DenseMap.
/// If entries are pointers to objects, the size of the referenced objects
/// are not included.
size_t getMemorySize() const {
  return getNumBuckets() * sizeof(BucketT);
}
675};

677/// Equality comparison for DenseMap.
678///
679/// Iterates over elements of LHS confirming that each (key, value) pair in LHS
680/// is also in RHS, and that no additional pairs are in RHS.
681/// Equivalent to N calls to RHS.find and N value comparisons. Amortized
682/// complexity is linear, worst case is O(N^2) (if every hash collides).
683template <typename DerivedT, typename KeyT, typename ValueT, typename KeyInfoT,
        typename BucketT>
685bool operator==(
  const DenseMapBase<DerivedT, KeyT, ValueT, KeyInfoT, BucketT> &LHS,
  const DenseMapBase<DerivedT, KeyT, ValueT, KeyInfoT, BucketT> &RHS) {
if (LHS.size() != RHS.size())
  return false;

for (auto &KV : LHS) {
  auto I = RHS.find(KV.first);
  if (I == RHS.end() || I->second != KV.second)
    return false;
}

return true;
698}

700/// Inequality comparison for DenseMap.
701///
702/// Equivalent to !(LHS == RHS). See operator== for performance notes.
703template <typename DerivedT, typename KeyT, typename ValueT, typename KeyInfoT,
        typename BucketT>
705bool operator!=(
  const DenseMapBase<DerivedT, KeyT, ValueT, KeyInfoT, BucketT> &LHS,
  const DenseMapBase<DerivedT, KeyT, ValueT, KeyInfoT, BucketT> &RHS) {
return !(LHS == RHS);
709}

711template <typename KeyT, typename ValueT,
        typename KeyInfoT = DenseMapInfo<KeyT>,
        typename BucketT = llvm::detail::DenseMapPair<KeyT, ValueT>>
714class DenseMap : public DenseMapBase<DenseMap<KeyT, ValueT, KeyInfoT, BucketT>,
                                   KeyT, ValueT, KeyInfoT, BucketT> {
friend class DenseMapBase<DenseMap, KeyT, ValueT, KeyInfoT, BucketT>;

// Lift some types from the dependent base class into this class for
// simplicity of referring to them.
using BaseT = DenseMapBase<DenseMap, KeyT, ValueT, KeyInfoT, BucketT>;

BucketT *Buckets;
unsigned NumEntries;
unsigned NumTombstones;
unsigned NumBuckets;

727public:
/// Create a DenseMap with an optional \p InitialReserve that guarantee that
/// this number of elements can be inserted in the map without grow()
explicit DenseMap(unsigned InitialReserve = 0) { init(InitialReserve); }

DenseMap(const DenseMap &other) : BaseT() {
  init(0);
  copyFrom(other);
}

DenseMap(DenseMap &&other) : BaseT() {
  init(0);
  swap(other);
}

template<typename InputIt>
DenseMap(const InputIt &I, const InputIt &E) {
  init(std::distance(I, E));
  this->insert(I, E);
}

DenseMap(std::initializer_list<typename BaseT::value_type> Vals) {
  init(Vals.size());
  this->insert(Vals.begin(), Vals.end());
}

~DenseMap() {
  this->destroyAll();
  deallocate_buffer(Buckets, sizeof(BucketT) * NumBuckets, alignof(BucketT));
}

void swap(DenseMap& RHS) {
  this->incrementEpoch();
  RHS.incrementEpoch();
  std::swap(Buckets, RHS.Buckets);
  std::swap(NumEntries, RHS.NumEntries);
  std::swap(NumTombstones, RHS.NumTombstones);
  std::swap(NumBuckets, RHS.NumBuckets);
}

DenseMap& operator=(const DenseMap& other) {
  if (&other != this)
    copyFrom(other);
  return *this;
}

DenseMap& operator=(DenseMap &&other) {
  this->destroyAll();
  deallocate_buffer(Buckets, sizeof(BucketT) * NumBuckets, alignof(BucketT));
  init(0);
  swap(other);
  return *this;
}

void copyFrom(const DenseMap& other) {
  this->destroyAll();
  deallocate_buffer(Buckets, sizeof(BucketT) * NumBuckets, alignof(BucketT));
  if (allocateBuckets(other.NumBuckets)) {
    this->BaseT::copyFrom(other);
  } else {
    NumEntries = 0;
    NumTombstones = 0;
  }
}

void init(unsigned InitNumEntries) {
  auto InitBuckets = BaseT::getMinBucketToReserveForEntries(InitNumEntries);
  if (allocateBuckets(InitBuckets)) {
    this->BaseT::initEmpty();
  } else {
    NumEntries = 0;
    NumTombstones = 0;
  }
}

void grow(unsigned AtLeast) {
  unsigned OldNumBuckets = NumBuckets;
  BucketT *OldBuckets = Buckets;

  allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
  assert(Buckets)(static_cast <bool> (Buckets) ? void (0) : __assert_fail
 ("Buckets", "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/ADT/DenseMap.h"
, 807, __extension__ __PRETTY_FUNCTION__));
  if (!OldBuckets) {
    this->BaseT::initEmpty();
    return;
  }

  this->moveFromOldBuckets(OldBuckets, OldBuckets+OldNumBuckets);

  // Free the old table.
  deallocate_buffer(OldBuckets, sizeof(BucketT) * OldNumBuckets,
                    alignof(BucketT));
}

void shrink_and_clear() {
  unsigned OldNumBuckets = NumBuckets;
  unsigned OldNumEntries = NumEntries;
  this->destroyAll();

  // Reduce the number of buckets.
  unsigned NewNumBuckets = 0;
  if (OldNumEntries)
    NewNumBuckets = std::max(64, 1 << (Log2_32_Ceil(OldNumEntries) + 1));
  if (NewNumBuckets == NumBuckets) {
    this->BaseT::initEmpty();
    return;
  }

  deallocate_buffer(Buckets, sizeof(BucketT) * OldNumBuckets,
                    alignof(BucketT));
  init(NewNumBuckets);
}

839private:
unsigned getNumEntries() const {
  return NumEntries;
}

void setNumEntries(unsigned Num) {
  NumEntries = Num;
}

unsigned getNumTombstones() const {
  return NumTombstones;
}

void setNumTombstones(unsigned Num) {
  NumTombstones = Num;
}

BucketT *getBuckets() const {
  return Buckets;
}

unsigned getNumBuckets() const {
  return NumBuckets;
}

bool allocateBuckets(unsigned Num) {
  NumBuckets = Num;
  if (NumBuckets == 0) {
    Buckets = nullptr;
    return false;
  }

  Buckets = static_cast<BucketT *>(
      allocate_buffer(sizeof(BucketT) * NumBuckets, alignof(BucketT)));
  return true;
}
875};

877template <typename KeyT, typename ValueT, unsigned InlineBuckets = 4,
        typename KeyInfoT = DenseMapInfo<KeyT>,
        typename BucketT = llvm::detail::DenseMapPair<KeyT, ValueT>>
880class SmallDenseMap
  : public DenseMapBase<
        SmallDenseMap<KeyT, ValueT, InlineBuckets, KeyInfoT, BucketT>, KeyT,
        ValueT, KeyInfoT, BucketT> {
friend class DenseMapBase<SmallDenseMap, KeyT, ValueT, KeyInfoT, BucketT>;

// Lift some types from the dependent base class into this class for
// simplicity of referring to them.
using BaseT = DenseMapBase<SmallDenseMap, KeyT, ValueT, KeyInfoT, BucketT>;

static_assert(isPowerOf2_64(InlineBuckets),
              "InlineBuckets must be a power of 2.");

unsigned Small : 1;
unsigned NumEntries : 31;
unsigned NumTombstones;

struct LargeRep {
  BucketT *Buckets;
  unsigned NumBuckets;
};

/// A "union" of an inline bucket array and the struct representing
/// a large bucket. This union will be discriminated by the 'Small' bit.
AlignedCharArrayUnion<BucketT[InlineBuckets], LargeRep> storage;

906public:
explicit SmallDenseMap(unsigned NumInitBuckets = 0) {
  init(NumInitBuckets);
}

SmallDenseMap(const SmallDenseMap &other) : BaseT() {
  init(0);
  copyFrom(other);
}

SmallDenseMap(SmallDenseMap &&other) : BaseT() {
  init(0);
  swap(other);
}

template<typename InputIt>
SmallDenseMap(const InputIt &I, const InputIt &E) {
  init(NextPowerOf2(std::distance(I, E)));
  this->insert(I, E);
}

SmallDenseMap(std::initializer_list<typename BaseT::value_type> Vals)
    : SmallDenseMap(Vals.begin(), Vals.end()) {}

~SmallDenseMap() {
  this->destroyAll();
  deallocateBuckets();
}

void swap(SmallDenseMap& RHS) {
  unsigned TmpNumEntries = RHS.NumEntries;
  RHS.NumEntries = NumEntries;
  NumEntries = TmpNumEntries;
  std::swap(NumTombstones, RHS.NumTombstones);

  const KeyT EmptyKey = this->getEmptyKey();
  const KeyT TombstoneKey = this->getTombstoneKey();
  if (Small && RHS.Small) {
    // If we're swapping inline bucket arrays, we have to cope with some of
    // the tricky bits of DenseMap's storage system: the buckets are not
    // fully initialized. Thus we swap every key, but we may have
    // a one-directional move of the value.
    for (unsigned i = 0, e = InlineBuckets; i != e; ++i) {
      BucketT *LHSB = &getInlineBuckets()[i],
              *RHSB = &RHS.getInlineBuckets()[i];
      bool hasLHSValue = (!KeyInfoT::isEqual(LHSB->getFirst(), EmptyKey) &&
                          !KeyInfoT::isEqual(LHSB->getFirst(), TombstoneKey));
      bool hasRHSValue = (!KeyInfoT::isEqual(RHSB->getFirst(), EmptyKey) &&
                          !KeyInfoT::isEqual(RHSB->getFirst(), TombstoneKey));
      if (hasLHSValue && hasRHSValue) {
        // Swap together if we can...
        std::swap(*LHSB, *RHSB);
        continue;
      }
      // Swap separately and handle any asymmetry.
      std::swap(LHSB->getFirst(), RHSB->getFirst());
      if (hasLHSValue) {
        ::new (&RHSB->getSecond()) ValueT(std::move(LHSB->getSecond()));
        LHSB->getSecond().~ValueT();
      } else if (hasRHSValue) {
        ::new (&LHSB->getSecond()) ValueT(std::move(RHSB->getSecond()));
        RHSB->getSecond().~ValueT();
      }
    }
    return;
  }
  if (!Small && !RHS.Small) {
    std::swap(getLargeRep()->Buckets, RHS.getLargeRep()->Buckets);
    std::swap(getLargeRep()->NumBuckets, RHS.getLargeRep()->NumBuckets);
    return;
  }

  SmallDenseMap &SmallSide = Small ? *this : RHS;
  SmallDenseMap &LargeSide = Small ? RHS : *this;

  // First stash the large side's rep and move the small side across.
  LargeRep TmpRep = std::move(*LargeSide.getLargeRep());
  LargeSide.getLargeRep()->~LargeRep();
  LargeSide.Small = true;
  // This is similar to the standard move-from-old-buckets, but the bucket
  // count hasn't actually rotated in this case. So we have to carefully
  // move construct the keys and values into their new locations, but there
  // is no need to re-hash things.
  for (unsigned i = 0, e = InlineBuckets; i != e; ++i) {
    BucketT *NewB = &LargeSide.getInlineBuckets()[i],
            *OldB = &SmallSide.getInlineBuckets()[i];
    ::new (&NewB->getFirst()) KeyT(std::move(OldB->getFirst()));
    OldB->getFirst().~KeyT();
    if (!KeyInfoT::isEqual(NewB->getFirst(), EmptyKey) &&
        !KeyInfoT::isEqual(NewB->getFirst(), TombstoneKey)) {
      ::new (&NewB->getSecond()) ValueT(std::move(OldB->getSecond()));
      OldB->getSecond().~ValueT();
    }
  }

  // The hard part of moving the small buckets across is done, just move
  // the TmpRep into its new home.
  SmallSide.Small = false;
  new (SmallSide.getLargeRep()) LargeRep(std::move(TmpRep));
}

SmallDenseMap& operator=(const SmallDenseMap& other) {
  if (&other != this)
    copyFrom(other);
  return *this;
}

SmallDenseMap& operator=(SmallDenseMap &&other) {
  this->destroyAll();
  deallocateBuckets();
  init(0);
  swap(other);
  return *this;
}

void copyFrom(const SmallDenseMap& other) {
  this->destroyAll();
  deallocateBuckets();
  Small = true;
  if (other.getNumBuckets() > InlineBuckets) {
    Small = false;
    new (getLargeRep()) LargeRep(allocateBuckets(other.getNumBuckets()));
  }
  this->BaseT::copyFrom(other);
}

void init(unsigned InitBuckets) {
  Small = true;
  if (InitBuckets > InlineBuckets) {
    Small = false;
    new (getLargeRep()) LargeRep(allocateBuckets(InitBuckets));
  }
  this->BaseT::initEmpty();
}

void grow(unsigned AtLeast) {
  if (AtLeast > InlineBuckets)
    AtLeast = std::max<unsigned>(64, NextPowerOf2(AtLeast-1));

  if (Small) {
    // First move the inline buckets into a temporary storage.
    AlignedCharArrayUnion<BucketT[InlineBuckets]> TmpStorage;
    BucketT *TmpBegin = reinterpret_cast<BucketT *>(&TmpStorage);
    BucketT *TmpEnd = TmpBegin;

    // Loop over the buckets, moving non-empty, non-tombstones into the
    // temporary storage. Have the loop move the TmpEnd forward as it goes.
    const KeyT EmptyKey = this->getEmptyKey();
    const KeyT TombstoneKey = this->getTombstoneKey();
    for (BucketT *P = getBuckets(), *E = P + InlineBuckets; P != E; ++P) {
      if (!KeyInfoT::isEqual(P->getFirst(), EmptyKey) &&
          !KeyInfoT::isEqual(P->getFirst(), TombstoneKey)) {
        assert(size_t(TmpEnd - TmpBegin) < InlineBuckets &&(static_cast <bool> (size_t(TmpEnd - TmpBegin) < InlineBuckets
 && "Too many inline buckets!") ? void (0) : __assert_fail
 ("size_t(TmpEnd - TmpBegin) < InlineBuckets && \"Too many inline buckets!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/ADT/DenseMap.h"
, 1059, __extension__ __PRETTY_FUNCTION__))
               "Too many inline buckets!")(static_cast <bool> (size_t(TmpEnd - TmpBegin) < InlineBuckets
 && "Too many inline buckets!") ? void (0) : __assert_fail
 ("size_t(TmpEnd - TmpBegin) < InlineBuckets && \"Too many inline buckets!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/ADT/DenseMap.h"
, 1059, __extension__ __PRETTY_FUNCTION__));
        ::new (&TmpEnd->getFirst()) KeyT(std::move(P->getFirst()));
        ::new (&TmpEnd->getSecond()) ValueT(std::move(P->getSecond()));
        ++TmpEnd;
        P->getSecond().~ValueT();
      }
      P->getFirst().~KeyT();
    }

    // AtLeast == InlineBuckets can happen if there are many tombstones,
    // and grow() is used to remove them. Usually we always switch to the
    // large rep here.
    if (AtLeast > InlineBuckets) {
      Small = false;
      new (getLargeRep()) LargeRep(allocateBuckets(AtLeast));
    }
    this->moveFromOldBuckets(TmpBegin, TmpEnd);
    return;
  }

  LargeRep OldRep = std::move(*getLargeRep());
  getLargeRep()->~LargeRep();
  if (AtLeast <= InlineBuckets) {
    Small = true;
  } else {
    new (getLargeRep()) LargeRep(allocateBuckets(AtLeast));
  }

  this->moveFromOldBuckets(OldRep.Buckets, OldRep.Buckets+OldRep.NumBuckets);

  // Free the old table.
  deallocate_buffer(OldRep.Buckets, sizeof(BucketT) * OldRep.NumBuckets,
                    alignof(BucketT));
}

void shrink_and_clear() {
  unsigned OldSize = this->size();
  this->destroyAll();

  // Reduce the number of buckets.
  unsigned NewNumBuckets = 0;
  if (OldSize) {
    NewNumBuckets = 1 << (Log2_32_Ceil(OldSize) + 1);
    if (NewNumBuckets > InlineBuckets && NewNumBuckets < 64u)
      NewNumBuckets = 64;
  }
  if ((Small && NewNumBuckets <= InlineBuckets) ||
      (!Small && NewNumBuckets == getLargeRep()->NumBuckets)) {
    this->BaseT::initEmpty();
    return;
  }

  deallocateBuckets();
  init(NewNumBuckets);
}

1115private:
unsigned getNumEntries() const {
  return NumEntries;
}

void setNumEntries(unsigned Num) {
  // NumEntries is hardcoded to be 31 bits wide.
  assert(Num < (1U << 31) && "Cannot support more than 1<<31 entries")(static_cast <bool> (Num < (1U << 31) &&
 "Cannot support more than 1<<31 entries") ? void (0) :
 __assert_fail ("Num < (1U << 31) && \"Cannot support more than 1<<31 entries\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/ADT/DenseMap.h"
, 1122, __extension__ __PRETTY_FUNCTION__));
  NumEntries = Num;
}

unsigned getNumTombstones() const {
  return NumTombstones;
}

void setNumTombstones(unsigned Num) {
  NumTombstones = Num;
}

const BucketT *getInlineBuckets() const {
  assert(Small)(static_cast <bool> (Small) ? void (0) : __assert_fail (
"Small", "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/ADT/DenseMap.h"
, 1135, __extension__ __PRETTY_FUNCTION__));
  // Note that this cast does not violate aliasing rules as we assert that
  // the memory's dynamic type is the small, inline bucket buffer, and the
  // 'storage' is a POD containing a char buffer.
  return reinterpret_cast<const BucketT *>(&storage);
}

BucketT *getInlineBuckets() {
  return const_cast<BucketT *>(
    const_cast<const SmallDenseMap *>(this)->getInlineBuckets());
}

const LargeRep *getLargeRep() const {
  assert(!Small)(static_cast <bool> (!Small) ? void (0) : __assert_fail
 ("!Small", "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/ADT/DenseMap.h"
, 1148, __extension__ __PRETTY_FUNCTION__));
  // Note, same rule about aliasing as with getInlineBuckets.
  return reinterpret_cast<const LargeRep *>(&storage);
}

LargeRep *getLargeRep() {
  return const_cast<LargeRep *>(
    const_cast<const SmallDenseMap *>(this)->getLargeRep());
}

const BucketT *getBuckets() const {
  return Small ? getInlineBuckets() : getLargeRep()->Buckets;
}

BucketT *getBuckets() {
  return const_cast<BucketT *>(
    const_cast<const SmallDenseMap *>(this)->getBuckets());
}

unsigned getNumBuckets() const {
  return Small ? InlineBuckets : getLargeRep()->NumBuckets;
}

void deallocateBuckets() {
  if (Small)
    return;

  deallocate_buffer(getLargeRep()->Buckets,
                    sizeof(BucketT) * getLargeRep()->NumBuckets,
                    alignof(BucketT));
  getLargeRep()->~LargeRep();
}

LargeRep allocateBuckets(unsigned Num) {
  assert(Num > InlineBuckets && "Must allocate more buckets than are inline")(static_cast <bool> (Num > InlineBuckets && "Must allocate more buckets than are inline"
) ? void (0) : __assert_fail ("Num > InlineBuckets && \"Must allocate more buckets than are inline\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/ADT/DenseMap.h"
, 1182, __extension__ __PRETTY_FUNCTION__));
  LargeRep Rep = {static_cast<BucketT *>(allocate_buffer(
                      sizeof(BucketT) * Num, alignof(BucketT))),
                  Num};
  return Rep;
}
1188};

1190template <typename KeyT, typename ValueT, typename KeyInfoT, typename Bucket,
        bool IsConst>
1192class DenseMapIterator : DebugEpochBase::HandleBase {
friend class DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, true>;
friend class DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, false>;

1196public:
using difference_type = ptrdiff_t;
using value_type =
    typename std::conditional<IsConst, const Bucket, Bucket>::type;
using pointer = value_type *;
using reference = value_type &;
using iterator_category = std::forward_iterator_tag;

1204private:
pointer Ptr = nullptr;
pointer End = nullptr;

1208public:
DenseMapIterator() = default;

DenseMapIterator(pointer Pos, pointer E, const DebugEpochBase &Epoch,
                 bool NoAdvance = false)
    : DebugEpochBase::HandleBase(&Epoch), Ptr(Pos), End(E) {
  assert(isHandleInSync() && "invalid construction!")(static_cast <bool> (isHandleInSync() && "invalid construction!"
) ? void (0) : __assert_fail ("isHandleInSync() && \"invalid construction!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/ADT/DenseMap.h"
, 1214, __extension__ __PRETTY_FUNCTION__));

  if (NoAdvance) return;
  if (shouldReverseIterate<KeyT>()) {
    RetreatPastEmptyBuckets();
    return;
  }
  AdvancePastEmptyBuckets();
}

// Converting ctor from non-const iterators to const iterators. SFINAE'd out
// for const iterator destinations so it doesn't end up as a user defined copy
// constructor.
template <bool IsConstSrc,
          typename = std::enable_if_t<!IsConstSrc && IsConst>>
DenseMapIterator(
    const DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, IsConstSrc> &I)
    : DebugEpochBase::HandleBase(I), Ptr(I.Ptr), End(I.End) {}

reference operator*() const {
  assert(isHandleInSync() && "invalid iterator access!")(static_cast <bool> (isHandleInSync() && "invalid iterator access!"
) ? void (0) : __assert_fail ("isHandleInSync() && \"invalid iterator access!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/ADT/DenseMap.h"
, 1234, __extension__ __PRETTY_FUNCTION__));
  assert(Ptr != End && "dereferencing end() iterator")(static_cast <bool> (Ptr != End && "dereferencing end() iterator"
) ? void (0) : __assert_fail ("Ptr != End && \"dereferencing end() iterator\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/ADT/DenseMap.h"
, 1235, __extension__ __PRETTY_FUNCTION__));
  if (shouldReverseIterate<KeyT>())
    return Ptr[-1];
  return *Ptr;
}
pointer operator->() const {
  assert(isHandleInSync() && "invalid iterator access!")(static_cast <bool> (isHandleInSync() && "invalid iterator access!"
) ? void (0) : __assert_fail ("isHandleInSync() && \"invalid iterator access!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/ADT/DenseMap.h"
, 1241, __extension__ __PRETTY_FUNCTION__));
  assert(Ptr != End && "dereferencing end() iterator")(static_cast <bool> (Ptr != End && "dereferencing end() iterator"
) ? void (0) : __assert_fail ("Ptr != End && \"dereferencing end() iterator\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/ADT/DenseMap.h"
, 1242, __extension__ __PRETTY_FUNCTION__));
  if (shouldReverseIterate<KeyT>())
    return &(Ptr[-1]);
  return Ptr;
}

friend bool operator==(const DenseMapIterator &LHS,
                       const DenseMapIterator &RHS) {
  assert((!LHS.Ptr || LHS.isHandleInSync()) && "handle not in sync!")(static_cast <bool> ((!LHS.Ptr || LHS.isHandleInSync())
 && "handle not in sync!") ? void (0) : __assert_fail
 ("(!LHS.Ptr || LHS.isHandleInSync()) && \"handle not in sync!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/ADT/DenseMap.h"
, 1250, __extension__ __PRETTY_FUNCTION__));
  assert((!RHS.Ptr || RHS.isHandleInSync()) && "handle not in sync!")(static_cast <bool> ((!RHS.Ptr || RHS.isHandleInSync())
 && "handle not in sync!") ? void (0) : __assert_fail
 ("(!RHS.Ptr || RHS.isHandleInSync()) && \"handle not in sync!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/ADT/DenseMap.h"
, 1251, __extension__ __PRETTY_FUNCTION__));
  assert(LHS.getEpochAddress() == RHS.getEpochAddress() &&(static_cast <bool> (LHS.getEpochAddress() == RHS.getEpochAddress
() && "comparing incomparable iterators!") ? void (0)
 : __assert_fail ("LHS.getEpochAddress() == RHS.getEpochAddress() && \"comparing incomparable iterators!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/ADT/DenseMap.h"
, 1253, __extension__ __PRETTY_FUNCTION__))
         "comparing incomparable iterators!")(static_cast <bool> (LHS.getEpochAddress() == RHS.getEpochAddress
() && "comparing incomparable iterators!") ? void (0)
 : __assert_fail ("LHS.getEpochAddress() == RHS.getEpochAddress() && \"comparing incomparable iterators!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/ADT/DenseMap.h"
, 1253, __extension__ __PRETTY_FUNCTION__));
  return LHS.Ptr == RHS.Ptr;
}

friend bool operator!=(const DenseMapIterator &LHS,
                       const DenseMapIterator &RHS) {
  return !(LHS == RHS);
91
←
Assuming the condition is false→
92
←
Returning zero, which participates in a condition later→
}

inline DenseMapIterator& operator++() {  // Preincrement
  assert(isHandleInSync() && "invalid iterator access!")(static_cast <bool> (isHandleInSync() && "invalid iterator access!"
) ? void (0) : __assert_fail ("isHandleInSync() && \"invalid iterator access!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/ADT/DenseMap.h"
, 1263, __extension__ __PRETTY_FUNCTION__));
  assert(Ptr != End && "incrementing end() iterator")(static_cast <bool> (Ptr != End && "incrementing end() iterator"
) ? void (0) : __assert_fail ("Ptr != End && \"incrementing end() iterator\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/ADT/DenseMap.h"
, 1264, __extension__ __PRETTY_FUNCTION__));
  if (shouldReverseIterate<KeyT>()) {
    --Ptr;
    RetreatPastEmptyBuckets();
    return *this;
  }
  ++Ptr;
  AdvancePastEmptyBuckets();
  return *this;
}
DenseMapIterator operator++(int) {  // Postincrement
  assert(isHandleInSync() && "invalid iterator access!")(static_cast <bool> (isHandleInSync() && "invalid iterator access!"
) ? void (0) : __assert_fail ("isHandleInSync() && \"invalid iterator access!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/ADT/DenseMap.h"
, 1275, __extension__ __PRETTY_FUNCTION__));
  DenseMapIterator tmp = *this; ++*this; return tmp;
}

1279private:
void AdvancePastEmptyBuckets() {
  assert(Ptr <= End)(static_cast <bool> (Ptr <= End) ? void (0) : __assert_fail
 ("Ptr <= End", "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/ADT/DenseMap.h"
, 1281, __extension__ __PRETTY_FUNCTION__));
  const KeyT Empty = KeyInfoT::getEmptyKey();
  const KeyT Tombstone = KeyInfoT::getTombstoneKey();

  while (Ptr != End && (KeyInfoT::isEqual(Ptr->getFirst(), Empty) ||
                        KeyInfoT::isEqual(Ptr->getFirst(), Tombstone)))
    ++Ptr;
}

void RetreatPastEmptyBuckets() {
  assert(Ptr >= End)(static_cast <bool> (Ptr >= End) ? void (0) : __assert_fail
 ("Ptr >= End", "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include/llvm/ADT/DenseMap.h"
, 1291, __extension__ __PRETTY_FUNCTION__));
  const KeyT Empty = KeyInfoT::getEmptyKey();
  const KeyT Tombstone = KeyInfoT::getTombstoneKey();

  while (Ptr != End && (KeyInfoT::isEqual(Ptr[-1].getFirst(), Empty) ||
                        KeyInfoT::isEqual(Ptr[-1].getFirst(), Tombstone)))
    --Ptr;
}
1299};

1301template <typename KeyT, typename ValueT, typename KeyInfoT>
1302inline size_t capacity_in_bytes(const DenseMap<KeyT, ValueT, KeyInfoT> &X) {
return X.getMemorySize();
1304}

1306} // end namespace llvm

1308#endif // LLVM_ADT_DENSEMAP_H