reference, declarationdefinition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

examples/HowToUseJIT/HowToUseJIT.cpp
   88   assert(Add1F->arg_begin() != Add1F->arg_end()); // Make sure there's an arg
examples/HowToUseLLJIT/HowToUseLLJIT.cpp
   45   assert(Add1F->arg_begin() != Add1F->arg_end()); // Make sure there's an arg
examples/Kaleidoscope/BuildingAJIT/Chapter1/toy.cpp
  269     assert(isUnaryOp() || isBinaryOp());
  809   assert(F && "binary operator not found!");
 1162       assert(FP && "Failed to codegen function");
examples/Kaleidoscope/BuildingAJIT/Chapter2/toy.cpp
  269     assert(isUnaryOp() || isBinaryOp());
  809   assert(F && "binary operator not found!");
 1162       assert(FP && "Failed to codegen function");
examples/Kaleidoscope/BuildingAJIT/Chapter3/toy.cpp
  269     assert(isUnaryOp() || isBinaryOp());
  808   assert(F && "binary operator not found!");
 1149       assert(ExprSymbol && "Function not found");
examples/Kaleidoscope/BuildingAJIT/Chapter4/KaleidoscopeJIT.h
  161       assert(Sym && "Couldn't find compiled function?");
examples/Kaleidoscope/BuildingAJIT/Chapter4/toy.cpp
  269     assert(isUnaryOp() || isBinaryOp());
  794   assert(F && "binary operator not found!");
 1152       assert(ExprSymbol && "Function not found");
examples/Kaleidoscope/BuildingAJIT/Chapter5/KaleidoscopeJIT.h
  174       assert(Sym && "Couldn't find compiled function?");
examples/Kaleidoscope/BuildingAJIT/Chapter5/RemoteJITUtils.h
   34     assert(Dst && "Attempt to read into null.");
   52     assert(Src && "Attempt to append from null.");
examples/Kaleidoscope/BuildingAJIT/Chapter5/toy.cpp
  286     assert(isUnaryOp() || isBinaryOp());
  818   assert(F && "binary operator not found!");
 1176       assert(ExprSymbol && "Function not found");
examples/Kaleidoscope/Chapter4/toy.cpp
  611       assert(ExprSymbol && "Function not found");
examples/Kaleidoscope/Chapter5/toy.cpp
  885       assert(ExprSymbol && "Function not found");
examples/Kaleidoscope/Chapter6/toy.cpp
  252     assert(isUnaryOp() || isBinaryOp());
  707   assert(F && "binary operator not found!");
 1004       assert(ExprSymbol && "Function not found");
examples/Kaleidoscope/Chapter7/toy.cpp
  274     assert(isUnaryOp() || isBinaryOp());
  814   assert(F && "binary operator not found!");
 1174       assert(ExprSymbol && "Function not found");
examples/Kaleidoscope/Chapter8/toy.cpp
  275     assert(isUnaryOp() || isBinaryOp());
  813   assert(F && "binary operator not found!");
examples/Kaleidoscope/Chapter9/toy.cpp
  377     assert(isUnaryOp() || isBinaryOp());
  972   assert(F && "binary operator not found!");
examples/ParallelJIT/ParallelJIT.cpp
   66   assert(Add1F->arg_begin() != Add1F->arg_end()); // Make sure there's an arg
  149     assert( result == 0 );
  152     assert( result == 0 );
  159     assert( result == 0 );
  162     assert( result == 0 );
  170     assert( result == 0 );
  174     assert( waitFor == 0 || n <= waitFor );
  185       assert( result == 0 );
  190     assert( result == 0 );
  200     assert( result == 0 );
  214     assert( result == 0 );
  232     assert(result == 0);
gen/lib/Target/AArch64/AArch64GenAsmMatcher.inc
 6463   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
 6475       assert(OpIdx < (size_t)(std::end(TiedAsmOperandTable) -
 6796   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
12394   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
12400       assert(OpIdx < (size_t)(std::end(TiedAsmOperandTable) -
27454     assert(Mnemonic == it->getMnemonic());
40873     assert(Mnemonic == it->getMnemonic());
gen/lib/Target/AArch64/AArch64GenAsmWriter.inc
11741   assert(Bits != 0 && "Cannot print this instruction.");
14155   assert(RegNo && RegNo < 629 && "Invalid register number!");
14781     assert(*(AsmStrsNoRegAltName+RegAsmOffsetNoRegAltName[RegNo-1]) &&
14785     assert(*(AsmStrsvlist1+RegAsmOffsetvlist1[RegNo-1]) &&
14789     assert(*(AsmStrsvreg+RegAsmOffsetvreg[RegNo-1]) &&
gen/lib/Target/AArch64/AArch64GenAsmWriter1.inc
12738   assert(Bits != 0 && "Cannot print this instruction.");
14871   assert(RegNo && RegNo < 629 && "Invalid register number!");
15497     assert(*(AsmStrsNoRegAltName+RegAsmOffsetNoRegAltName[RegNo-1]) &&
15501     assert(*(AsmStrsvlist1+RegAsmOffsetvlist1[RegNo-1]) &&
15505     assert(*(AsmStrsvreg+RegAsmOffsetvreg[RegNo-1]) &&
gen/lib/Target/AArch64/AArch64GenDisassemblerTables.inc
   36   assert(startBit + numBits <= 64 && "Cannot support >64-bit extractions!");
   37   assert(startBit + numBits <= (sizeof(InsnType) * 8) &&
25814       assert(DecodeComplete);
25847         assert(S == MCDisassembler::Fail);
gen/lib/Target/AArch64/AArch64GenMCCodeEmitter.inc
21325   assert(Inst.getOpcode() < 5384);
gen/lib/Target/AArch64/AArch64GenRegisterBank.inc
  134     assert(Index++ == RB->getID() && "Index != ID");
gen/lib/Target/AArch64/AArch64GenRegisterInfo.inc
 6818   assert(Select < 2);
 6832   assert(Select < 2);
 6846   assert(Select < 2);
 6860   assert(Select < 2);
 6874   assert(Select < 2);
 6888   assert(Select < 2);
 8954   --IdxA; assert(IdxA < 99);
 8955   --IdxB; assert(IdxB < 99);
 9119   --IdxA; assert(IdxA < 99 && "Subregister index out of bounds");
 9133   --IdxA; assert(IdxA < 99 && "Subregister index out of bounds");
20056   assert(RC && "Missing regclass");
20059   assert(Idx < 99 && "Bad subreg");
20183   assert(RegUnit < 115 && "invalid register unit");
20331   assert(RegUnit < 115 && "invalid register unit");
gen/lib/Target/AMDGPU/AMDGPUGenAsmMatcher.inc
 3780   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
 3783   assert(OptionalOperandsMask.size() == 27);
 3798       assert(OpIdx < (size_t)(std::end(TiedAsmOperandTable) -
 4008   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
10314   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
10320       assert(OpIdx < (size_t)(std::end(TiedAsmOperandTable) -
23979     assert(Mnemonic == it->getMnemonic());
80425     assert(Mnemonic == it->getMnemonic());
gen/lib/Target/AMDGPU/AMDGPUGenAsmWriter.inc
32459   assert(Bits != 0 && "Cannot print this instruction.");
35780   assert(RegNo && RegNo < 3666 && "Invalid register number!");
39644   assert (*(AsmStrs+RegAsmOffset[RegNo-1]) &&
gen/lib/Target/AMDGPU/AMDGPUGenDAGISel.inc
78716   assert(N->getNumOperands() == 2);
78717   assert(N->getOperand(0).getValueType().getSizeInBits() == 16);
gen/lib/Target/AMDGPU/AMDGPUGenDisassemblerTables.inc
   36   assert(startBit + numBits <= 64 && "Cannot support >64-bit extractions!");
   37   assert(startBit + numBits <= (sizeof(InsnType) * 8) &&
42078       assert(DecodeComplete);
42111         assert(S == MCDisassembler::Fail);
gen/lib/Target/AMDGPU/AMDGPUGenMCCodeEmitter.inc
50357   assert(Inst.getOpcode() < 15263);
gen/lib/Target/AMDGPU/AMDGPUGenRegisterBank.inc
  233     assert(Index++ == RB->getID() && "Index != ID");
gen/lib/Target/AMDGPU/AMDGPUGenRegisterInfo.inc
25530   --IdxA; assert(IdxA < 192);
25531   --IdxB; assert(IdxB < 192);
25769   --IdxA; assert(IdxA < 192 && "Subregister index out of bounds");
25783   --IdxA; assert(IdxA < 192 && "Subregister index out of bounds");
47914   assert(RC && "Missing regclass");
47917   assert(Idx < 192 && "Bad subreg");
48047   assert(RegUnit < 699 && "invalid register unit");
48692   assert(RegUnit < 699 && "invalid register unit");
gen/lib/Target/AMDGPU/R600GenAsmWriter.inc
  795   assert(Bits != 0 && "Cannot print this instruction.");
 1184   assert(RegNo && RegNo < 1675 && "Invalid register number!");
 2822   assert (*(AsmStrs+RegAsmOffset[RegNo-1]) &&
gen/lib/Target/AMDGPU/R600GenMCCodeEmitter.inc
 2314   assert(Inst.getOpcode() < 514);
gen/lib/Target/AMDGPU/R600GenRegisterInfo.inc
11434   --IdxA; assert(IdxA < 16);
11435   --IdxB; assert(IdxB < 16);
11481   --IdxA; assert(IdxA < 16 && "Subregister index out of bounds");
11495   --IdxA; assert(IdxA < 16 && "Subregister index out of bounds");
12176   assert(RC && "Missing regclass");
12179   assert(Idx < 16 && "Bad subreg");
12232   assert(RegUnit < 1342 && "invalid register unit");
12336   assert(RegUnit < 1342 && "invalid register unit");
gen/lib/Target/ARC/ARCGenAsmWriter.inc
  759   assert(Bits != 0 && "Cannot print this instruction.");
  951   assert(RegNo && RegNo < 34 && "Invalid register number!");
  995   assert (*(AsmStrs+RegAsmOffset[RegNo-1]) &&
gen/lib/Target/ARC/ARCGenDisassemblerTables.inc
   36   assert(startBit + numBits <= 64 && "Cannot support >64-bit extractions!");
   37   assert(startBit + numBits <= (sizeof(InsnType) * 8) &&
 1549       assert(DecodeComplete);
 1582         assert(S == MCDisassembler::Fail);
gen/lib/Target/ARC/ARCGenRegisterInfo.inc
  715   assert(RegUnit < 33 && "invalid register unit");
  768   assert(RegUnit < 33 && "invalid register unit");
gen/lib/Target/ARM/ARMGenAsmMatcher.inc
 4347   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
 4359       assert(OpIdx < (size_t)(std::end(TiedAsmOperandTable) -
 4803   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
15118     assert(Mnemonic == it->getMnemonic());
15281       assert(!OperandNearMiss && "OperandNearMiss was handled earlier");
16359     assert(Mnemonic == it->getMnemonic());
gen/lib/Target/ARM/ARMGenAsmWriter.inc
 9142   assert(Bits != 0 && "Cannot print this instruction.");
11789   assert(RegNo && RegNo < 295 && "Invalid register number!");
12046     assert(*(AsmStrsNoRegAltName+RegAsmOffsetNoRegAltName[RegNo-1]) &&
gen/lib/Target/ARM/ARMGenDAGISel.inc
55064   assert(ARM::dsub_7 == ARM::dsub_0+7 && "Unexpected subreg numbering");
55078   assert(ARM::dsub_7 == ARM::dsub_0+7 && "Unexpected subreg numbering");
55135   assert(ARM::dsub_7 == ARM::dsub_0+7 && "Unexpected subreg numbering");
55149   assert(ARM::ssub_3 == ARM::ssub_0+3 && "Unexpected subreg numbering");
55157   assert(ARM::ssub_3 == ARM::ssub_0+3 && "Unexpected subreg numbering");
55165   assert(ARM::dsub_7 == ARM::dsub_0+7 && "Unexpected subreg numbering");
gen/lib/Target/ARM/ARMGenDisassemblerTables.inc
   36   assert(startBit + numBits <= 64 && "Cannot support >64-bit extractions!");
   37   assert(startBit + numBits <= (sizeof(InsnType) * 8) &&
21856       assert(DecodeComplete);
21889         assert(S == MCDisassembler::Fail);
gen/lib/Target/ARM/ARMGenRegisterBank.inc
  109     assert(Index++ == RB->getID() && "Index != ID");
gen/lib/Target/ARM/ARMGenRegisterInfo.inc
 5912   assert(Select < 3);
 5930   assert(Select < 3);
 5950   assert(Select < 4);
 5968   assert(Select < 3);
 5986   assert(Select < 3);
 6006   assert(Select < 4);
 6024   assert(Select < 3);
 6044   assert(Select < 4);
 6060   assert(Select < 2);
 6076   assert(Select < 2);
 6092   assert(Select < 2);
 6108   assert(Select < 2);
 6124   assert(Select < 2);
 6140   assert(Select < 2);
 6156   assert(Select < 2);
 6171   assert(Select < 2);
 6187   assert(Select < 2);
 6203   assert(Select < 2);
 6218   assert(Select < 2);
 6236   assert(Select < 3);
 6254   assert(Select < 3);
 6272   assert(Select < 3);
 6290   assert(Select < 3);
 6308   assert(Select < 3);
 6326   assert(Select < 3);
 6344   assert(Select < 3);
 6358   assert(Select < 2);
 6372   assert(Select < 2);
 6386   assert(Select < 2);
 6400   assert(Select < 2);
 6414   assert(Select < 2);
 6428   assert(Select < 2);
 6442   assert(Select < 2);
 6456   assert(Select < 2);
 6470   assert(Select < 2);
 6484   assert(Select < 2);
 6498   assert(Select < 2);
 6512   assert(Select < 2);
 6526   assert(Select < 2);
 6540   assert(Select < 2);
 8450   --IdxA; assert(IdxA < 56);
 8451   --IdxB; assert(IdxB < 56);
 8539   --IdxA; assert(IdxA < 56 && "Subregister index out of bounds");
 8553   --IdxA; assert(IdxA < 56 && "Subregister index out of bounds");
15644   assert(RC && "Missing regclass");
15647   assert(Idx < 56 && "Bad subreg");
15785   assert(RegUnit < 83 && "invalid register unit");
15926   assert(RegUnit < 83 && "invalid register unit");
gen/lib/Target/AVR/AVRGenAsmMatcher.inc
  496   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
  508       assert(OpIdx < (size_t)(std::end(TiedAsmOperandTable) -
  565   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
 1009   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
 1015       assert(OpIdx < (size_t)(std::end(TiedAsmOperandTable) -
 1307     assert(Mnemonic == it->getMnemonic());
 1518     assert(Mnemonic == it->getMnemonic());
gen/lib/Target/AVR/AVRGenAsmWriter.inc
  855   assert(Bits != 0 && "Cannot print this instruction.");
  977   assert(RegNo && RegNo < 53 && "Invalid register number!");
 1041     assert(*(AsmStrsNoRegAltName+RegAsmOffsetNoRegAltName[RegNo-1]) &&
 1045     assert(*(AsmStrsptr+RegAsmOffsetptr[RegNo-1]) &&
gen/lib/Target/AVR/AVRGenDisassemblerTables.inc
   36   assert(startBit + numBits <= 64 && "Cannot support >64-bit extractions!");
   37   assert(startBit + numBits <= (sizeof(InsnType) * 8) &&
  671       assert(DecodeComplete);
  704         assert(S == MCDisassembler::Fail);
gen/lib/Target/AVR/AVRGenRegisterInfo.inc
 1440   --IdxA; assert(IdxA < 2);
 1441   --IdxB; assert(IdxB < 2);
 1459   --IdxA; assert(IdxA < 2 && "Subregister index out of bounds");
 1473   --IdxA; assert(IdxA < 2 && "Subregister index out of bounds");
 1560   assert(RC && "Missing regclass");
 1563   assert(Idx < 2 && "Bad subreg");
 1597   assert(RegUnit < 35 && "invalid register unit");
 1668   assert(RegUnit < 35 && "invalid register unit");
gen/lib/Target/BPF/BPFGenAsmMatcher.inc
  268   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
  280       assert(OpIdx < (size_t)(std::end(TiedAsmOperandTable) -
  304   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
  697   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
  703       assert(OpIdx < (size_t)(std::end(TiedAsmOperandTable) -
gen/lib/Target/BPF/BPFGenAsmWriter.inc
  676   assert(Bits != 0 && "Cannot print this instruction.");
 1020   assert(RegNo && RegNo < 25 && "Invalid register number!");
 1054   assert (*(AsmStrs+RegAsmOffset[RegNo-1]) &&
gen/lib/Target/BPF/BPFGenDisassemblerTables.inc
   36   assert(startBit + numBits <= 64 && "Cannot support >64-bit extractions!");
   37   assert(startBit + numBits <= (sizeof(InsnType) * 8) &&
  608       assert(DecodeComplete);
  641         assert(S == MCDisassembler::Fail);
gen/lib/Target/BPF/BPFGenMCCodeEmitter.inc
  973   assert(Inst.getOpcode() < 309);
gen/lib/Target/BPF/BPFGenRegisterInfo.inc
  533   --IdxA; assert(IdxA < 1);
  534   --IdxB; assert(IdxB < 1);
  550   --IdxA; assert(IdxA < 1 && "Subregister index out of bounds");
  564   --IdxA; assert(IdxA < 1 && "Subregister index out of bounds");
  585   assert(RC && "Missing regclass");
  588   assert(Idx < 1 && "Bad subreg");
  606   assert(RegUnit < 12 && "invalid register unit");
  654   assert(RegUnit < 12 && "invalid register unit");
gen/lib/Target/Hexagon/HexagonGenAsmMatcher.inc
 2545   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
 2557       assert(OpIdx < (size_t)(std::end(TiedAsmOperandTable) -
 2608   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
 7480   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
 7486       assert(OpIdx < (size_t)(std::end(TiedAsmOperandTable) -
gen/lib/Target/Hexagon/HexagonGenAsmWriter.inc
 9077   assert(Bits != 0 && "Cannot print this instruction.");
16684   assert(RegNo && RegNo < 197 && "Invalid register number!");
16901   assert (*(AsmStrs+RegAsmOffset[RegNo-1]) &&
gen/lib/Target/Hexagon/HexagonGenDAGISel.inc
72557   assert(isPowerOf2_32(VecSize));
73066   assert(V >= 32);
73081   assert(V >= 1);
73166   assert(isUInt<8>(V));
73175   assert(isUInt<16>(V));
gen/lib/Target/Hexagon/HexagonGenDisassemblerTables.inc
   36   assert(startBit + numBits <= 64 && "Cannot support >64-bit extractions!");
   37   assert(startBit + numBits <= (sizeof(InsnType) * 8) &&
12295       assert(DecodeComplete);
12328         assert(S == MCDisassembler::Fail);
gen/lib/Target/Hexagon/HexagonGenMCCodeEmitter.inc
14636   assert(Inst.getOpcode() < 2978);
gen/lib/Target/Hexagon/HexagonGenRegisterInfo.inc
 3186   --IdxA; assert(IdxA < 9);
 3187   --IdxB; assert(IdxB < 9);
 3217   --IdxA; assert(IdxA < 9 && "Subregister index out of bounds");
 3231   --IdxA; assert(IdxA < 9 && "Subregister index out of bounds");
 3521   assert(RC && "Missing regclass");
 3524   assert(Idx < 9 && "Bad subreg");
 3565   assert(RegUnit < 127 && "invalid register unit");
 3631   assert(RegUnit < 127 && "invalid register unit");
gen/lib/Target/Lanai/LanaiGenAsmMatcher.inc
  344   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
  356       assert(OpIdx < (size_t)(std::end(TiedAsmOperandTable) -
  422   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
  863   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
  869       assert(OpIdx < (size_t)(std::end(TiedAsmOperandTable) -
 1091     assert(Mnemonic == it->getMnemonic());
 1326     assert(Mnemonic == it->getMnemonic());
gen/lib/Target/Lanai/LanaiGenAsmWriter.inc
  640   assert(Bits != 0 && "Cannot print this instruction.");
  842   assert(RegNo && RegNo < 41 && "Invalid register number!");
  891   assert (*(AsmStrs+RegAsmOffset[RegNo-1]) &&
gen/lib/Target/Lanai/LanaiGenDisassemblerTables.inc
   36   assert(startBit + numBits <= 64 && "Cannot support >64-bit extractions!");
   37   assert(startBit + numBits <= (sizeof(InsnType) * 8) &&
  549       assert(DecodeComplete);
  582         assert(S == MCDisassembler::Fail);
gen/lib/Target/Lanai/LanaiGenRegisterInfo.inc
  753   --IdxA; assert(IdxA < 1);
  754   --IdxB; assert(IdxB < 1);
  770   --IdxA; assert(IdxA < 1 && "Subregister index out of bounds");
  784   --IdxA; assert(IdxA < 1 && "Subregister index out of bounds");
  808   assert(RC && "Missing regclass");
  811   assert(Idx < 1 && "Bad subreg");
  830   assert(RegUnit < 33 && "invalid register unit");
  880   assert(RegUnit < 33 && "invalid register unit");
gen/lib/Target/MSP430/MSP430GenAsmMatcher.inc
  329   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
  341       assert(OpIdx < (size_t)(std::end(TiedAsmOperandTable) -
  392   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
  631   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
  637       assert(OpIdx < (size_t)(std::end(TiedAsmOperandTable) -
 1149     assert(Mnemonic == it->getMnemonic());
gen/lib/Target/MSP430/MSP430GenAsmWriter.inc
  600   assert(Bits != 0 && "Cannot print this instruction.");
  732   assert(RegNo && RegNo < 33 && "Invalid register number!");
  759   assert (*(AsmStrs+RegAsmOffset[RegNo-1]) &&
gen/lib/Target/MSP430/MSP430GenDisassemblerTables.inc
   36   assert(startBit + numBits <= 64 && "Cannot support >64-bit extractions!");
   37   assert(startBit + numBits <= (sizeof(InsnType) * 8) &&
 1426       assert(DecodeComplete);
 1459         assert(S == MCDisassembler::Fail);
gen/lib/Target/MSP430/MSP430GenRegisterInfo.inc
  466   --IdxA; assert(IdxA < 1);
  467   --IdxB; assert(IdxB < 1);
  483   --IdxA; assert(IdxA < 1 && "Subregister index out of bounds");
  497   --IdxA; assert(IdxA < 1 && "Subregister index out of bounds");
  518   assert(RC && "Missing regclass");
  521   assert(Idx < 1 && "Bad subreg");
  539   assert(RegUnit < 16 && "invalid register unit");
  587   assert(RegUnit < 16 && "invalid register unit");
gen/lib/Target/Mips/MipsGenAsmMatcher.inc
 1325   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
 1337       assert(OpIdx < (size_t)(std::end(TiedAsmOperandTable) -
 1562   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
 4880   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
 4886       assert(OpIdx < (size_t)(std::end(TiedAsmOperandTable) -
 8125     assert(Mnemonic == it->getMnemonic());
11698     assert(Mnemonic == it->getMnemonic());
gen/lib/Target/Mips/MipsGenAsmWriter.inc
 6674   assert(Bits != 0 && "Cannot print this instruction.");
 7326   assert(RegNo && RegNo < 442 && "Invalid register number!");
 7471   assert (*(AsmStrs+RegAsmOffset[RegNo-1]) &&
gen/lib/Target/Mips/MipsGenDisassemblerTables.inc
   36   assert(startBit + numBits <= 64 && "Cannot support >64-bit extractions!");
   37   assert(startBit + numBits <= (sizeof(InsnType) * 8) &&
10406       assert(DecodeComplete);
10439         assert(S == MCDisassembler::Fail);
gen/lib/Target/Mips/MipsGenRegisterBank.inc
   98     assert(Index++ == RB->getID() && "Index != ID");
gen/lib/Target/Mips/MipsGenRegisterInfo.inc
 4773   assert(Select < 2);
 4790   assert(Select < 2);
 6165   --IdxA; assert(IdxA < 11);
 6166   --IdxB; assert(IdxB < 11);
 6198   --IdxA; assert(IdxA < 11 && "Subregister index out of bounds");
 6212   --IdxA; assert(IdxA < 11 && "Subregister index out of bounds");
 7137   assert(RC && "Missing regclass");
 7140   assert(Idx < 11 && "Bad subreg");
 7226   assert(RegUnit < 321 && "invalid register unit");
 7323   assert(RegUnit < 321 && "invalid register unit");
gen/lib/Target/NVPTX/NVPTXGenAsmWriter.inc
12836   assert(Bits != 0 && "Cannot print this instruction.");
27102   assert(RegNo && RegNo < 96 && "Invalid register number!");
27212   assert (*(AsmStrs+RegAsmOffset[RegNo-1]) &&
gen/lib/Target/NVPTX/NVPTXGenRegisterInfo.inc
 1204   assert(RegUnit < 95 && "invalid register unit");
 1288   assert(RegUnit < 95 && "invalid register unit");
gen/lib/Target/PowerPC/PPCGenAsmMatcher.inc
 2081   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
 2093       assert(OpIdx < (size_t)(std::end(TiedAsmOperandTable) -
 2480   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
 4119   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
 4125       assert(OpIdx < (size_t)(std::end(TiedAsmOperandTable) -
 7054     assert(Mnemonic == it->getMnemonic());
gen/lib/Target/PowerPC/PPCGenAsmWriter.inc
 6073   assert(Bits != 0 && "Cannot print this instruction.");
 6673   assert(RegNo && RegNo < 344 && "Invalid register number!");
 6906   assert (*(AsmStrs+RegAsmOffset[RegNo-1]) &&
gen/lib/Target/PowerPC/PPCGenDisassemblerTables.inc
   36   assert(startBit + numBits <= 64 && "Cannot support >64-bit extractions!");
   37   assert(startBit + numBits <= (sizeof(InsnType) * 8) &&
 6656       assert(DecodeComplete);
 6689         assert(S == MCDisassembler::Fail);
gen/lib/Target/PowerPC/PPCGenMCCodeEmitter.inc
 8503   assert(Inst.getOpcode() < 2219);
gen/lib/Target/PowerPC/PPCGenRegisterInfo.inc
 4284   assert(Select < 2);
 4300   assert(Select < 2);
 4316   assert(Select < 2);
 4332   assert(Select < 2);
 4348   assert(Select < 2);
 4364   assert(Select < 2);
 5169   --IdxA; assert(IdxA < 6);
 5170   --IdxB; assert(IdxB < 6);
 5196   --IdxA; assert(IdxA < 6 && "Subregister index out of bounds");
 5210   --IdxA; assert(IdxA < 6 && "Subregister index out of bounds");
 5497   assert(RC && "Missing regclass");
 5500   assert(Idx < 6 && "Bad subreg");
 5550   assert(RegUnit < 171 && "invalid register unit");
 5637   assert(RegUnit < 171 && "invalid register unit");
gen/lib/Target/RISCV/RISCVGenAsmMatcher.inc
  950   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
  962       assert(OpIdx < (size_t)(std::end(TiedAsmOperandTable) -
 1040   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
 1767   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
 1773       assert(OpIdx < (size_t)(std::end(TiedAsmOperandTable) -
 2443     assert(Mnemonic == it->getMnemonic());
 2795     assert(Mnemonic == it->getMnemonic());
gen/lib/Target/RISCV/RISCVGenAsmWriter.inc
 1305   assert(Bits != 0 && "Cannot print this instruction.");
 1456   assert(RegNo && RegNo < 97 && "Invalid register number!");
 1588     assert(*(AsmStrsABIRegAltName+RegAsmOffsetABIRegAltName[RegNo-1]) &&
 1592     assert(*(AsmStrsNoRegAltName+RegAsmOffsetNoRegAltName[RegNo-1]) &&
gen/lib/Target/RISCV/RISCVGenDisassemblerTables.inc
   36   assert(startBit + numBits <= 64 && "Cannot support >64-bit extractions!");
   37   assert(startBit + numBits <= (sizeof(InsnType) * 8) &&
 1832       assert(DecodeComplete);
 1865         assert(S == MCDisassembler::Fail);
gen/lib/Target/RISCV/RISCVGenRegisterBank.inc
   61     assert(Index++ == RB->getID() && "Index != ID");
gen/lib/Target/RISCV/RISCVGenRegisterInfo.inc
 1607   --IdxA; assert(IdxA < 1);
 1608   --IdxB; assert(IdxB < 1);
 1624   --IdxA; assert(IdxA < 1 && "Subregister index out of bounds");
 1638   --IdxA; assert(IdxA < 1 && "Subregister index out of bounds");
 1689   assert(RC && "Missing regclass");
 1692   assert(Idx < 1 && "Bad subreg");
 1720   assert(RegUnit < 64 && "invalid register unit");
 1783   assert(RegUnit < 64 && "invalid register unit");
gen/lib/Target/Sparc/SparcGenAsmMatcher.inc
 1569   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
 1581       assert(OpIdx < (size_t)(std::end(TiedAsmOperandTable) -
 1668   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
 2334   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
 2340       assert(OpIdx < (size_t)(std::end(TiedAsmOperandTable) -
 4187     assert(Mnemonic == it->getMnemonic());
 4503     assert(Mnemonic == it->getMnemonic());
gen/lib/Target/Sparc/SparcGenAsmWriter.inc
 1074   assert(Bits != 0 && "Cannot print this instruction.");
 1366   assert(RegNo && RegNo < 236 && "Invalid register number!");
 1559   assert (*(AsmStrs+RegAsmOffset[RegNo-1]) &&
gen/lib/Target/Sparc/SparcGenDisassemblerTables.inc
   36   assert(startBit + numBits <= 64 && "Cannot support >64-bit extractions!");
   37   assert(startBit + numBits <= (sizeof(InsnType) * 8) &&
 2454       assert(DecodeComplete);
 2487         assert(S == MCDisassembler::Fail);
gen/lib/Target/Sparc/SparcGenMCCodeEmitter.inc
 2456   assert(Inst.getOpcode() < 704);
gen/lib/Target/Sparc/SparcGenRegisterInfo.inc
 2498   --IdxA; assert(IdxA < 6);
 2499   --IdxB; assert(IdxB < 6);
 2523   --IdxA; assert(IdxA < 6 && "Subregister index out of bounds");
 2537   --IdxA; assert(IdxA < 6 && "Subregister index out of bounds");
 2656   assert(RC && "Missing regclass");
 2659   assert(Idx < 6 && "Bad subreg");
 2688   assert(RegUnit < 171 && "invalid register unit");
 2748   assert(RegUnit < 171 && "invalid register unit");
gen/lib/Target/SystemZ/SystemZGenAsmMatcher.inc
 1342   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
 1354       assert(OpIdx < (size_t)(std::end(TiedAsmOperandTable) -
 1396   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
 2328   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
 2334       assert(OpIdx < (size_t)(std::end(TiedAsmOperandTable) -
 5382     assert(Mnemonic == it->getMnemonic());
 9221     assert(Mnemonic == it->getMnemonic());
gen/lib/Target/SystemZ/SystemZGenAsmWriter.inc
11373   assert(Bits != 0 && "Cannot print this instruction.");
12170   assert(RegNo && RegNo < 195 && "Invalid register number!");
12290   assert (*(AsmStrs+RegAsmOffset[RegNo-1]) &&
gen/lib/Target/SystemZ/SystemZGenDisassemblerTables.inc
   36   assert(startBit + numBits <= 64 && "Cannot support >64-bit extractions!");
   37   assert(startBit + numBits <= (sizeof(InsnType) * 8) &&
10827       assert(DecodeComplete);
10860         assert(S == MCDisassembler::Fail);
gen/lib/Target/SystemZ/SystemZGenMCCodeEmitter.inc
11984   assert(Inst.getOpcode() < 3004);
gen/lib/Target/SystemZ/SystemZGenRegisterInfo.inc
 2584   --IdxA; assert(IdxA < 6);
 2585   --IdxB; assert(IdxB < 6);
 2610   --IdxA; assert(IdxA < 6 && "Subregister index out of bounds");
 2624   --IdxA; assert(IdxA < 6 && "Subregister index out of bounds");
 2815   assert(RC && "Missing regclass");
 2818   assert(Idx < 6 && "Bad subreg");
 2856   assert(RegUnit < 98 && "invalid register unit");
 2914   assert(RegUnit < 98 && "invalid register unit");
gen/lib/Target/WebAssembly/WebAssemblyGenAsmMatcher.inc
  159   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
  171       assert(OpIdx < (size_t)(std::end(TiedAsmOperandTable) -
  198   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
  385   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
  391       assert(OpIdx < (size_t)(std::end(TiedAsmOperandTable) -
 1151     assert(Mnemonic == it->getMnemonic());
gen/lib/Target/WebAssembly/WebAssemblyGenAsmWriter.inc
 2094   assert(Bits != 0 && "Cannot print this instruction.");
 2300   assert(RegNo && RegNo < 13 && "Invalid register number!");
 2321   assert (*(AsmStrs+RegAsmOffset[RegNo-1]) &&
gen/lib/Target/WebAssembly/WebAssemblyGenRegisterInfo.inc
  478   assert(RegUnit < 12 && "invalid register unit");
  541   assert(RegUnit < 12 && "invalid register unit");
gen/lib/Target/X86/X86GenAsmMatcher.inc
 4940   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
 4952       assert(OpIdx < (size_t)(std::end(TiedAsmOperandTable) -
 5066   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
 7576   assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
 7582       assert(OpIdx < (size_t)(std::end(TiedAsmOperandTable) -
36982     assert(Mnemonic == it->getMnemonic());
gen/lib/Target/X86/X86GenAsmWriter.inc
47417   assert(Bits != 0 && "Cannot print this instruction.");
48554   assert(RegNo && RegNo < 282 && "Invalid register number!");
48838   assert (*(AsmStrs+RegAsmOffset[RegNo-1]) &&
gen/lib/Target/X86/X86GenAsmWriter1.inc
31877   assert(Bits != 0 && "Cannot print this instruction.");
32880   assert(RegNo && RegNo < 282 && "Invalid register number!");
33164   assert (*(AsmStrs+RegAsmOffset[RegNo-1]) &&
gen/lib/Target/X86/X86GenRegisterBank.inc
  152     assert(Index++ == RB->getID() && "Index != ID");
gen/lib/Target/X86/X86GenRegisterInfo.inc
 6262   assert(Select < 2);
 6278   assert(Select < 2);
 8113   --IdxA; assert(IdxA < 10);
 8114   --IdxB; assert(IdxB < 10);
 8145   --IdxA; assert(IdxA < 10 && "Subregister index out of bounds");
 8159   --IdxA; assert(IdxA < 10 && "Subregister index out of bounds");
 9590   assert(RC && "Missing regclass");
 9593   assert(Idx < 10 && "Bad subreg");
 9727   assert(RegUnit < 163 && "invalid register unit");
 9873   assert(RegUnit < 163 && "invalid register unit");
gen/lib/Target/XCore/XCoreGenAsmWriter.inc
  575   assert(Bits != 0 && "Cannot print this instruction.");
  852   assert(RegNo && RegNo < 17 && "Invalid register number!");
  878   assert (*(AsmStrs+RegAsmOffset[RegNo-1]) &&
gen/lib/Target/XCore/XCoreGenDAGISel.inc
 2477   assert(N->getZExtValue() % 4 == 0);
 2494   assert(-value % 4 == 0);
 2510   assert(isMask_32(N->getZExtValue()));
gen/lib/Target/XCore/XCoreGenDisassemblerTables.inc
   36   assert(startBit + numBits <= 64 && "Cannot support >64-bit extractions!");
   37   assert(startBit + numBits <= (sizeof(InsnType) * 8) &&
  898       assert(DecodeComplete);
  931         assert(S == MCDisassembler::Fail);
gen/lib/Target/XCore/XCoreGenRegisterInfo.inc
  478   assert(RegUnit < 16 && "invalid register unit");
  526   assert(RegUnit < 16 && "invalid register unit");
gen/tools/clang/include/clang/AST/AttrImpl.inc
  659   assert(!isAlignmentDependent());
gen/tools/clang/include/clang/AST/Attrs.inc
  992     assert(isalignmentExpr);
  996     assert(!isalignmentExpr);
 6197     assert(SpellingIndex == Pragma_clang_loop && "Unexpected spelling");
 6234     assert(SpellingIndex == Pragma_clang_loop && "Unexpected spelling");
 9067       assert(getCtxSelectorSet() != CtxSetUnknown &&
gen/tools/clang/include/clang/Driver/Options.inc
 3764 assert(ValuesWereAdded && "Couldn't add values to OptTable!");
 3777 assert(ValuesWereAdded && "Couldn't add values to OptTable!");
 3780 assert(ValuesWereAdded && "Couldn't add values to OptTable!");
gen/tools/clang/include/clang/Sema/AttrParsedAttrImpl.inc
 3556     assert(false && "Abstract matcher rule isn't allowed");
gen/tools/lldb/scripts/LLDBWrapPython.cpp
 2383               assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
 2471         assert(!newmemory); /* newmemory handling not yet implemented */
 2663   assert(!(flags & SWIG_BUILTIN_TP_INIT));
include/llvm/ADT/APFloat.h
  703       assert(&S == &PPCDoubleDouble());
  841     assert(&getSemantics() == &RHS.getSemantics() &&
  957     assert(&getSemantics() == &RHS.getSemantics() &&
  966     assert(&getSemantics() == &RHS.getSemantics() &&
  975     assert(&getSemantics() == &RHS.getSemantics() &&
  984     assert(&getSemantics() == &RHS.getSemantics() &&
  993     assert(&getSemantics() == &RHS.getSemantics() &&
 1002     assert(&getSemantics() == &RHS.getSemantics() &&
 1012     assert(&getSemantics() == &Multiplicand.getSemantics() &&
 1014     assert(&getSemantics() == &Addend.getSemantics() &&
 1118     assert(&getSemantics() == &RHS.getSemantics() &&
include/llvm/ADT/APInt.h
  279     assert(BitWidth && "bitwidth too small");
  450     assert(N && "N == 0 ???");
  456     assert(N && "N == 0 ???");
  495     assert(numBits != 0 && "numBits must be non-zero");
  496     assert(numBits <= BitWidth && "numBits out of range");
  753     assert(this != &that && "Self-move not supported");
  792     assert(BitWidth == RHS.BitWidth && "Bit widths must be the same");
  822     assert(BitWidth == RHS.BitWidth && "Bit widths must be the same");
  852     assert(BitWidth == RHS.BitWidth && "Bit widths must be the same");
  905     assert(ShiftAmt <= BitWidth && "Invalid shift amount");
  954     assert(ShiftAmt <= BitWidth && "Invalid shift amount");
  978     assert(ShiftAmt <= BitWidth && "Invalid shift amount");
 1121     assert(bitPosition < getBitWidth() && "Bit position out of bounds!");
 1134     assert(BitWidth == RHS.BitWidth && "Comparison requires equal bit widths");
 1325     assert(BitWidth == RHS.BitWidth && "Bit widths must be the same");
 1333     assert(BitWidth == RHS.BitWidth && "Bit widths must be the same");
 1407     assert(BitPosition < BitWidth && "BitPosition out of range");
 1422     assert(hiBit <= BitWidth && "hiBit out of range");
 1423     assert(loBit <= BitWidth && "loBit out of range");
 1424     assert(loBit <= hiBit && "loBit greater than hiBit");
 1466     assert(BitPosition < BitWidth && "BitPosition out of range");
 1476     assert(loBits <= BitWidth && "More bits than bitwidth");
 1578     assert(getActiveBits() <= 64 && "Too many bits for uint64_t");
 1590     assert(getMinSignedBits() <= 64 && "Too many bits for int64_t");
include/llvm/ADT/APSInt.h
   94     assert(getMinSignedBits() <= 64 && "Too many bits for int64_t");
  117     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
  125     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
  133     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
  137     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
  153     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
  157     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
  161     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
  165     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
  169     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
  224     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
  229     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
  234     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
  239     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
  244     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
  249     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
  255     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
  260     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
  265     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
  270     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
  274     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
  278     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
  319       assert(!I2.isSigned() && "Expected signed mismatch");
  323       assert(I2.isSigned() && "Expected signed mismatch");
include/llvm/ADT/AllocatorList.h
  231     assert(empty() && "Cannot reset allocator if not empty");
include/llvm/ADT/Any.h
  143   assert(Value && any_isa<T>(*Value) && "Bad any cast!");
  151   assert(Value && any_isa<U>(*Value) && "Bad any cast!");
include/llvm/ADT/ArrayRef.h
  152       assert(!empty());
  158       assert(!empty());
  179       assert(N+M <= size() && "Invalid specifier");
  188       assert(size() >= N && "Dropping more elements than exist");
  194       assert(size() >= N && "Dropping more elements than exist");
  240       assert(Index < Length && "Invalid index!");
  338       assert(!this->empty());
  344       assert(!this->empty());
  351       assert(N + M <= this->size() && "Invalid specifier");
  362       assert(this->size() >= N && "Dropping more elements than exist");
  367       assert(this->size() >= N && "Dropping more elements than exist");
  417       assert(Index < this->size() && "Invalid index!");
include/llvm/ADT/BitVector.h
   36     assert(Current != -1 && "Trying to advance past end.");
   61     assert(&Parent == &Other.Parent &&
   67     assert(&Parent == &Other.Parent &&
  208     assert(Begin <= End && End <= Size);
  237     assert(Begin <= End && End <= Size);
  268     assert(Begin <= End && End <= Size);
  299     assert(Begin <= End && End <= Size);
  404     assert(Bits.data() && "Bits never allocated");
  411     assert(I <= E && "Attempted to set backwards range!");
  412     assert(E <= size() && "Attempted to set out-of-bounds range!");
  450     assert(I <= E && "Attempted to reset backwards range!");
  451     assert(E <= size() && "Attempted to reset out-of-bounds range!");
  491     assert (Idx < Size && "Out-of-bounds Bit access.");
  496     assert (Idx < Size && "Out-of-bounds Bit access.");
  619     assert(N <= Size);
  624     assert(NumWords >= 1);
  668     assert(N <= Size);
  673     assert(NumWords >= 1);
  732     assert(NewCapacity > 0 && "negative capacity?");
  840     assert(Dest.size() == Src.size());
  886     assert(NewCapacity > 0 && "realloc-ing zero space");
include/llvm/ADT/BitmaskEnum.h
   92   assert(U >= 0 && "Negative enum values are not allowed.");
   93   assert(U <= Mask<E>() && "Enum value too large (or largest val too small?)");
include/llvm/ADT/CachedHashString.h
   41     assert(S.size() <= std::numeric_limits<uint32_t>::max());
   58     assert(!isEqual(S, getEmptyKey()) && "Cannot hash the empty key!");
   59     assert(!isEqual(S, getTombstoneKey()) && "Cannot hash the tombstone key!");
   92     assert(isEmptyOrTombstone());
  163     assert(!isEqual(S, getEmptyKey()) && "Cannot hash the empty key!");
  164     assert(!isEqual(S, getTombstoneKey()) && "Cannot hash the tombstone key!");
include/llvm/ADT/DenseMap.h
  138       assert(NumEntries == 0 && "Node count imbalance!");
  347     assert((getNumBuckets() & (getNumBuckets()-1)) == 0 &&
  378         assert(!FoundVal && "Key already in new map?");
  393     assert(&other != this);
  394     assert(getNumBuckets() == other.getNumBuckets());
  559     assert(TheBucket);
  592     assert(!KeyInfoT::isEqual(Val, EmptyKey) &&
  777     assert(Buckets);
 1028           assert(size_t(TmpEnd - TmpBegin) < InlineBuckets &&
 1089     assert(Num < (1U << 31) && "Cannot support more than 1<<31 entries");
 1102     assert(Small);
 1115     assert(!Small);
 1149     assert(Num > InlineBuckets && "Must allocate more buckets than are inline");
 1183     assert(isHandleInSync() && "invalid construction!");
 1203     assert(isHandleInSync() && "invalid iterator access!");
 1209     assert(isHandleInSync() && "invalid iterator access!");
 1216     assert((!Ptr || isHandleInSync()) && "handle not in sync!");
 1217     assert((!RHS.Ptr || RHS.isHandleInSync()) && "handle not in sync!");
 1218     assert(getEpochAddress() == RHS.getEpochAddress() &&
 1223     assert((!Ptr || isHandleInSync()) && "handle not in sync!");
 1224     assert((!RHS.Ptr || RHS.isHandleInSync()) && "handle not in sync!");
 1225     assert(getEpochAddress() == RHS.getEpochAddress() &&
 1231     assert(isHandleInSync() && "invalid iterator access!");
 1242     assert(isHandleInSync() && "invalid iterator access!");
 1248     assert(Ptr <= End);
 1258     assert(Ptr >= End);
include/llvm/ADT/DenseMapInfo.h
  233     assert(Val.data() != getEmptyKey().data() && "Cannot hash the empty key!");
  234     assert(Val.data() != getTombstoneKey().data() &&
  261     assert(Val.data() != getEmptyKey().data() && "Cannot hash the empty key!");
  262     assert(Val.data() != getTombstoneKey().data() &&
include/llvm/ADT/DirectedGraph.h
  108     assert(EL.empty() && "Expected the list of edges to be empty.");
  217     assert(EL.empty() && "Expected the list of edges to be empty.");
  256     assert(findNode(Src) != Nodes.end() && "Src node should be present.");
  257     assert(findNode(Dst) != Nodes.end() && "Dst node should be present.");
  258     assert((E.getTargetNode() == Dst) &&
include/llvm/ADT/EquivalenceClasses.h
   88       assert(isLeader() && "Cannot get the end of a list for a non-leader!");
   93       assert(getNext() == nullptr && "Already has a next pointer!");
  101       assert(RHS.isLeader() && RHS.getNext() == nullptr && "Not a singleton!");
  172     assert(MI != member_end() && "Value is not in the set!");
  181     assert(MI != member_end() && "Value is not in the set!");
  222     assert(L1 != member_end() && L2 != member_end() && "Illegal inputs!");
  269       assert(Node != nullptr && "Dereferencing end()!");
  275       assert(Node != nullptr && "++'d off the end of the list!");
include/llvm/ADT/FoldingSet.h
  460     assert(Inserted == N && "Node already inserted!");
include/llvm/ADT/Hashing.h
  411   assert(buffer_ptr == buffer_end);
include/llvm/ADT/ImmutableList.h
  133     assert(!isEmpty() && "Cannot get the head of an empty list.");
include/llvm/ADT/ImmutableSet.h
  279     assert(isMutable() && "Mutable flag already removed.");
  285     assert(!hasCachedDigest() && "NoCachedDigest flag already removed.");
  334     assert(refCount > 0);
  468       assert(T != L);
  469       assert(T != R);
  498       assert(!isEmpty(L) && "Left tree cannot be empty to have a height >= 2");
  506       assert(!isEmpty(LR) && "LR cannot be empty because it has a height >= 1");
  515       assert(!isEmpty(R) && "Right tree cannot be empty to have a height >= 2");
  523       assert(!isEmpty(RL) && "RL cannot be empty because it has a height >= 1");
  540     assert(!T->isMutable());
  561     assert(!T->isMutable());
  587     assert(!isEmpty(T));
  666     assert(!stack.empty());
  672     assert(!stack.empty());
  683     assert(!stack.empty());
  708     assert(!stack.empty());
  710     assert(Current);
  734     assert(!stack.empty());
  736     assert(Current);
include/llvm/ADT/IndexedMap.h
   46       assert(toIndex_(n) < storage_.size() && "index out of bounds!");
   51       assert(toIndex_(n) < storage_.size() && "index out of bounds!");
include/llvm/ADT/IntEqClasses.h
   76     assert(NumClasses && "operator[] called before compress()");
include/llvm/ADT/IntervalMap.h
  235     assert(i + Count <= M && "Invalid source range");
  236     assert(j + Count <= N && "Invalid dest range");
  248     assert(j <= i && "Use moveRight shift elements right");
  257     assert(i <= j && "Use moveLeft shift elements left");
  258     assert(j + Count <= N && "Invalid range");
  374     assert(CurSize[n] == NewSize[n] && "Insufficient element shuffle");
  508     assert(n <= NodeT::Capacity && "Size too big for node");
  533     assert(pip.getPointer() != RHS.pip.getPointer() && "Inconsistent NodeRefs");
  580     assert(i <= Size && Size <= N && "Bad indices");
  581     assert((i == 0 || Traits::stopLess(stop(i - 1), x)) &&
  595     assert(i < N && "Bad index");
  596     assert((i == 0 || Traits::stopLess(stop(i - 1), x)) &&
  599     assert(i < N && "Unsafe intervals");
  629   assert(i <= Size && Size <= N && "Invalid index");
  630   assert(!Traits::stopLess(b, a) && "Invalid interval");
  633   assert((i == 0 || Traits::stopLess(stop(i - 1), a)));
  634   assert((i == Size || !Traits::stopLess(stop(i), a)));
  635   assert((i == Size || Traits::stopLess(b, start(i))) && "Overlapping insert");
  715     assert(i <= Size && Size <= N && "Bad indices");
  716     assert((i == 0 || Traits::stopLess(stop(i - 1), x)) &&
  729     assert(i < N && "Bad index");
  730     assert((i == 0 || Traits::stopLess(stop(i - 1), x)) &&
  733     assert(i < N && "Unsafe intervals");
  750     assert(Size < N && "branch node overflow");
  751     assert(i <= Size && "Bad insert position");
  988     assert(!branched() && "Cannot acces leaf data in branched root");
  992     assert(!branched() && "Cannot acces leaf data in branched root");
  997     assert(branched() && "Cannot access branch data in non-branched root");
 1001     assert(branched() && "Cannot access branch data in non-branched root");
 1043     assert((uintptr_t(data.buffer) & (alignof(RootLeaf) - 1)) == 0 &&
 1060     assert(!empty() && "Empty IntervalMap has no start");
 1066     assert(!empty() && "Empty IntervalMap has no stop");
 1140     assert(Traits::nonEmpty(a, b));
 1156   assert(branched() && "treeLookup assumes a branched root");
 1313     assert(map && "Invalid iterator");
 1330     assert(valid() && "Cannot access invalid iterator");
 1337     assert(valid() && "Cannot access invalid iterator");
 1344     assert(valid() && "Cannot access invalid iterator");
 1375     assert(map == RHS.map && "Cannot compare iterators from different maps");
 1401     assert(valid() && "Cannot increment end()");
 1683   assert(Traits::nonEmpty(a, this->stop()) && "Cannot move start beyond stop");
 1699   assert(Traits::nonEmpty(this->start(), b) && "Cannot move stop beyond start");
 1737   assert(Level && "Cannot insert next to the root");
 1766     assert(!SplitRoot && "Cannot overflow after splitting the root");
 1856     assert(Size <= Leaf::Capacity && "overflow() didn't make room");
 1873   assert(P.valid() && "Cannot erase end()");
 1917   assert(Level && "Cannot erase root node");
include/llvm/ADT/IntrusiveRefCntPtr.h
   80     assert(RefCount > 0 && "Reference count is already zero.");
   98     assert(NewRefCount >= 0 && "Reference count was already zero.");
include/llvm/ADT/MapVector.h
  182       assert(I.second != Index && "Index was already erased!");
include/llvm/ADT/Optional.h
   73     assert(hasVal);
   77     assert(hasVal);
  173     assert(hasVal);
  177     assert(hasVal);
include/llvm/ADT/PackedVector.h
   38     assert((val >> BitNum) == 0 && "value is too big");
   61     assert((val >> (BitNum-1)) == 0 && "value is too big");
include/llvm/ADT/PointerEmbeddedInt.h
   64     assert((std::is_signed<IntT>::value ? isInt<Bits>(I) : isUInt<Bits>(I)) &&
include/llvm/ADT/PointerIntPair.h
   85     assert(Value == reinterpret_cast<intptr_t>(getPointer()) &&
  178     assert((PtrWord & ~PointerBitMask) == 0 &&
  186     assert((IntWord & ~IntMask) == 0 && "Integer too large for field");
include/llvm/ADT/PointerSumType.h
  102     assert((reinterpret_cast<uintptr_t>(V) & HelperT::TagMask) == 0 &&
  132     assert(is<N>() && "This instance has a different active member.");
  151     assert(is<HelperT::MinTag>() && "The active tag is not zero!");
  160     assert(InitialPtr == get<HelperT::MinTag>() &&
include/llvm/ADT/PointerUnion.h
  195     assert(is<T>() && "Invalid accessor called");
  216     assert(is<First>() && "Val is not the first pointer");
  217     assert(
include/llvm/ADT/PriorityWorklist.h
   85     assert(!empty() && "Cannot call back() on empty PriorityWorklist!");
   92     assert(X != T() && "Cannot insert a null (default constructed) value!");
  101     assert(V[Index] == X && "Value not actually at index in map!");
  146     assert(!empty() && "Cannot remove an element when empty!");
  147     assert(back() != T() && "Cannot have a null element at the back!");
  168     assert(V[I->second] == X && "Value not actually at index in map!");
include/llvm/ADT/SCCIterator.h
  109     assert(!CurrentSCC.empty() || VisitStack.empty());
  123     assert(!CurrentSCC.empty() && "Dereferencing END SCC iterator!");
  136     assert(nodeVisitNumbers.count(Old) && "Old not in scc_iterator?");
  156   assert(!VisitStack.empty());
  182     assert(VisitStack.back().NextChild == GT::child_end(visitingN));
  213     assert(!CurrentSCC.empty() && "Dereferencing END SCC iterator!");
include/llvm/ADT/STLExtras.h
  470     assert(!IsEarlyIncremented && "Cannot dereference twice!");
  479     assert(IsEarlyIncremented && "Cannot increment before dereferencing!");
  488     assert(!IsEarlyIncremented && "Cannot compare after dereferencing!");
 1390     assert(lhs);
 1391     assert(rhs);
 1445     assert(Result.Index != std::numeric_limits<size_t>::max());
include/llvm/ADT/ScopedHashTable.h
  174     assert(!CurScope && TopLevelMap.empty() && "Scope imbalance!");
  217     assert(S && "No scope active!");
  237   assert(HT.CurScope == this && "Scope imbalance!");
  244       assert(HT.TopLevelMap[ThisEntry->getKey()] == ThisEntry &&
  249       assert(KeyEntry == ThisEntry && "Scope imbalance!");
include/llvm/ADT/SetVector.h
  123     assert(!empty() && "Cannot call front() on empty SetVector!");
  129     assert(!empty() && "Cannot call back() on empty SetVector!");
  135     assert(n < vector_.size() && "SetVector access out of range!");
  160       assert(I != vector_.end() && "Corrupted SetVector instances!");
  173     assert(set_.count(V) && "Corrupted SetVector instances!");
  222     assert(!empty() && "Cannot remove an element from an empty SetVector!");
include/llvm/ADT/SmallBitVector.h
   95     assert(!isSmall());
  107     assert(!isSmall() && "Tried to use an unaligned pointer");
  113     assert(isSmall());
  118     assert(isSmall());
  373       assert(Idx <= static_cast<unsigned>(
  385     assert(I <= E && "Attempted to set backwards range!");
  386     assert(E <= size() && "Attempted to set out-of-bounds range!");
  416     assert(I <= E && "Attempted to reset backwards range!");
  417     assert(E <= size() && "Attempted to reset out-of-bounds range!");
  452     assert(Idx < size() && "Out-of-bounds Bit access.");
  457     assert(Idx < size() && "Out-of-bounds Bit access.");
  668     assert(MaskWords <= sizeof(uintptr_t) && "Mask is larger than base!");
include/llvm/ADT/SmallPtrSet.h
   77     assert(SmallSize && (SmallSize & (SmallSize-1)) == 0 &&
  167     assert(*Loc == Ptr && "broken find!");
  248     assert(Bucket <= End);
  255     assert(Bucket >= End);
  284     assert(isHandleInSync() && "invalid iterator access!");
  286       assert(Bucket > End);
  289     assert(Bucket < End);
  294     assert(isHandleInSync() && "invalid iterator access!");
include/llvm/ADT/SmallVector.h
   67     assert(N <= capacity());
  149     assert(idx < size());
  153     assert(idx < size());
  158     assert(!empty());
  162     assert(!empty());
  167     assert(!empty());
  171     assert(!empty());
  438     assert(I >= this->begin() && "Iterator to erase is out of bounds.");
  439     assert(I < this->end() && "Erasing at past-the-end iterator.");
  454     assert(S >= this->begin() && "Range to erase is out of bounds.");
  455     assert(S <= E && "Trying to erase invalid range.");
  456     assert(E <= this->end() && "Trying to erase past the end.");
  473     assert(I >= this->begin() && "Insertion iterator is out of bounds.");
  474     assert(I <= this->end() && "Inserting past the end of the vector.");
  503     assert(I >= this->begin() && "Insertion iterator is out of bounds.");
  504     assert(I <= this->end() && "Inserting past the end of the vector.");
  535     assert(I >= this->begin() && "Insertion iterator is out of bounds.");
  536     assert(I <= this->end() && "Inserting past the end of the vector.");
  590     assert(I >= this->begin() && "Insertion iterator is out of bounds.");
  591     assert(I <= this->end() && "Inserting past the end of the vector.");
include/llvm/ADT/SparseBitVector.h
   83     assert(Idx < BITWORDS_PER_ELEMENT);
  154     assert(WordPos <= BITWORDS_PER_ELEMENT
include/llvm/ADT/SparseMultiSet.h
  135     assert(ValIndexOf(Val) < Universe &&
  145     assert(D.isValid() && "Invalid node for head");
  152     assert(N.isValid() && "Invalid node for singleton");
  168     assert(Dense[Idx].isTombstone() && "Non-tombstone free?");
  205     assert(empty() && "Can only resize universe on an empty map");
  236       assert(Idx < SMS->Dense.size() && "Out of range, non-INVALID Idx?");
  257       assert(isKeyed() && SMS->sparseIndex(SMS->Dense[Idx].Data) == SparseIdx &&
  268         assert((isEnd() || SparseIdx == RHS.SparseIdx) &&
  282       assert(isKeyed() && "Decrementing an invalid iterator");
  283       assert((isEnd() || !SMS->isHead(SMS->Dense[Idx])) &&
  295       assert(!isEnd() && isKeyed() && "Incrementing an invalid/end iterator");
  336     assert(NumFree <= Dense.size() && "Out-of-bounds free entries");
  355     assert(Idx < Universe && "Key out of range");
  467     assert(I.isKeyed() && !I.isEnd() && !Dense[I.Idx].isTombstone() &&
  492       assert(N.Next == SMSNode::INVALID && "Singleton has next?");
include/llvm/ADT/SparseSet.h
  158     assert(empty() && "Can only resize universe on an empty map");
  205     assert(Idx < Universe && "Key out of range");
  209       assert(FoundIdx < Universe && "Invalid key in set. Did object mutate?");
  286     assert(unsigned(I - begin()) < size() && "Invalid iterator");
  290       assert(BackIdx < Universe && "Invalid key in set. Did object mutate?");
include/llvm/ADT/StringExtras.h
  163   assert(U1 != -1U && U2 != -1U);
  181   assert(Input.size() % 2 == 0);
include/llvm/ADT/StringMap.h
  189     assert(NewItem && "Unhandled out-of-memory");
  403     assert(NumItems + NumTombstones <= NumBuckets);
  443     assert(NumItems + NumTombstones <= NumBuckets);
include/llvm/ADT/StringRef.h
  155       assert(!empty());
  162       assert(!empty());
  249       assert(Index < Length && "Invalid index!");
  641       assert(size() >= N && "Dropping more elements than exist");
  649       assert(size() >= N && "Dropping more elements than exist");
include/llvm/ADT/StringSet.h
   39       assert(!Key.empty());
include/llvm/ADT/StringSwitch.h
  189     assert(Result && "Fell off the end of a string-switch");
include/llvm/ADT/TinyPtrVector.h
  219     assert(!Val.isNull() && "can't index into an empty vector");
  221       assert(i == 0 && "tinyvector index out of range");
  225     assert(i < Val.template get<VecTy*>()->size() &&
  231     assert(!empty() && "vector empty");
  238     assert(!empty() && "vector empty");
  248       assert(!Val.isNull() && "Can't add a null value");
  283     assert(I >= begin() && "Iterator to erase is out of bounds.");
  284     assert(I < end() && "Erasing at past-the-end iterator.");
  299     assert(S >= begin() && "Range to erase is out of bounds.");
  300     assert(S <= E && "Trying to erase invalid range.");
  301     assert(E <= end() && "Trying to erase past the end.");
  313     assert(I >= this->begin() && "Insertion iterator is out of bounds.");
  314     assert(I <= this->end() && "Inserting past the end of the vector.");
  319     assert(!Val.isNull() && "Null value with non-end insert iterator.");
  322       assert(I == begin());
  333     assert(I >= this->begin() && "Insertion iterator is out of bounds.");
  334     assert(I <= this->end() && "Inserting past the end of the vector.");
include/llvm/ADT/Triple.h
  440     assert(isMacOSX() && "Not an OS X triple!");
  447     assert(Major == 10 && "Unexpected major version");
  664     assert(isAndroid() && "Not an Android triple!");
include/llvm/ADT/Twine.h
  170       assert(isNullary() && "Invalid kind!");
  178       assert(isValid() && "Invalid twine!");
  184       assert(isValid() && "Invalid twine!");
  257       assert(isValid() && "Invalid twine!");
  274       assert(isValid() && "Invalid twine!");
  283       assert(isValid() && "Invalid twine!");
  289       assert(isValid() && "Invalid twine!");
  296       assert(isValid() && "Invalid twine!");
  303       assert(isValid() && "Invalid twine!");
  361       assert(isValid() && "Invalid twine!");
  369       assert(isValid() && "Invalid twine!");
  440       assert(isSingleStringRef() &&"This cannot be had as a single stringref!");
include/llvm/ADT/UniqueVector.h
   70     assert(ID-1 < size() && "ID is 0 or out of range!");
include/llvm/ADT/fallible_iterator.h
  128     assert(getErrPtr() && "Cannot increment end iterator");
  144     assert(getErrPtr() && "Cannot decrement end iterator");
  171     assert(LHS.isValid() && RHS.isValid() &&
include/llvm/ADT/ilist.h
  313     assert(!empty() && "pop_front() on empty list!");
  317     assert(!empty() && "pop_back() on empty list!");
include/llvm/ADT/ilist_base.h
   58     assert(&Next != &First &&
include/llvm/ADT/ilist_iterator.h
  139     assert(!NodePtr->isKnownSentinel());
include/llvm/ADT/simple_ilist.h
  197     assert(I != end() && "Cannot remove end of list!");
include/llvm/Analysis/AliasSetTracker.h
  102       assert(isSizeSet() && "Getting an unset size!");
  117       assert(AS && "No AliasSet yet!");
  128       assert(!AS && "Already have an alias set!");
  137         assert(*AS->PtrListEnd == nullptr && "List not terminated right!");
  193     assert(RefCount >= 1 && "Invalid reference count detected!");
  199     assert(i < UnknownInsts.size());
  252       assert(CurNode && "Dereferencing AliasSet.end()!");
  262       assert(CurNode && "Advancing past AliasSet.end()!");
include/llvm/Analysis/BlockFrequencyInfoImpl.h
  251       assert(isHeader(B) && "this is only valid on loop header blocks");
  450     assert(Head.Index < Working.size());
  451     assert(Working[Head.Index].isLoopHeader());
  537     assert(!Freqs.empty());
  568   assert(BB && "Unexpected nullptr");
  576   assert(BB && "Unexpected nullptr");
  874     assert(Node.Index < RPOT.size());
 1069   assert(RPOT.size() - 1 <= BlockNode::getMaxIndex() &&
 1101     assert(Header.isValid());
 1128     assert(Header.isValid());
 1130     assert(HeaderData.isLoopHeader());
 1197       assert(!getBlock(HeaderNode)->getIrrLoopHeaderWeight() &&
 1231   assert(!Working.empty() && "no blocks in function");
 1232   assert(!Working[0].isLoopHeader() && "entry block is a loop header");
 1315     assert(Loop != OuterLoop && "Cannot propagate mass in a packaged loop");
include/llvm/Analysis/BranchProbabilityInfo.h
  155       assert(BPI != nullptr);
include/llvm/Analysis/CFLAliasAnalysisUtils.h
   26     assert(Fn != nullptr);
   27     assert(Result != nullptr);
   37     assert(Result != nullptr);
include/llvm/Analysis/CGSCCPassManager.h
  507         assert(
  585       assert(CallHandles.empty() && "Must start with a clear set of handles.");
  630       assert(!UR.InvalidatedSCCs.count(C) && "Processing an invalid SCC!");
  631       assert(C->begin() != C->end() && "Cannot have an empty SCC!");
  770     assert(RCWorklist.empty() &&
  792       assert(CWorklist.empty() &&
  849           assert(!InvalidSCCSet.count(C) && "Processing an invalid SCC!");
  850           assert(C->begin() != C->end() && "Cannot have an empty SCC!");
  851           assert(&C->getOuterRefSCC() == RC &&
  881           assert(C->begin() != C->end() && "Cannot have an empty SCC!");
include/llvm/Analysis/CallGraph.h
  123     assert(I != FunctionMap.end() && "Function not in callgraph!");
  130     assert(I != FunctionMap.end() && "Function not in callgraph!");
  180     assert(NumReferences == 0 && "Node deleted while references remain");
  202     assert(i < CalledFunctions.size() && "Invalid index");
  226     assert(CalledFunctions.empty() &&
  233     assert(!Call || !Call->getCalledFunction() ||
include/llvm/Analysis/DDG.h
  123     assert(!InstList.empty() && "Instruction List is empty.");
  220     assert(Root && "Root node is not available yet. Graph construction may "
  277     assert(RN && "Failed to allocate memory for DDG root node.");
  283     assert(SN && "Failed to allocate memory for simple DDG node.");
  289     assert(E && "Failed to allocate memory for edge");
  295     assert(E && "Failed to allocate memory for edge");
  301     assert(E && "Failed to allocate memory for edge");
  302     assert(isa<RootDDGNode>(Src) && "Expected root node");
include/llvm/Analysis/DominanceFrontier.h
   63     assert(Roots.size() == 1 && "Should always have entry node!");
   88     assert(find(BB) == end() && "Block already in DominanceFrontier!");
  133     assert(DT.getRoots().size() == 1 &&
include/llvm/Analysis/DominanceFrontierImpl.h
   51   assert(find(BB) != end() && "Block is not in DominanceFrontier!");
   60   assert(I != end() && "BB is not in DominanceFrontier!");
   61   assert(I->second.count(Node) && "Node is not in DominanceFrontier of BB");
   68   assert(I != end() && "BB is not in DominanceFrontier!");
   69   assert(I->second.count(Node) && "Node is not in DominanceFrontier of BB");
  171     assert(currentW && "Missing work object.");
  177     assert(currentBB && "Invalid work object. Missing current Basic Block");
  178     assert(currentNode && "Invalid work object. Missing current Node");
include/llvm/Analysis/InlineCost.h
   81     assert((isVariable() || Reason) &&
   87     assert(Cost > AlwaysInlineCost && "Cost crosses sentinel value");
   88     assert(Cost < NeverInlineCost && "Cost crosses sentinel value");
  110     assert(isVariable() && "Invalid access of InlineCost");
  116     assert(isVariable() && "Invalid access of InlineCost");
  122     assert((Reason || isVariable()) &&
include/llvm/Analysis/IntervalIterator.h
  140     assert(!IntStack.empty() && "Attempting to use interval iterator at end!");
  201     assert(Int && "Null interval == bad!");
  202     assert(Node && "Null Node == bad!");
include/llvm/Analysis/IteratedDominanceFrontier.h
   28     assert(GD);
   51     assert(GD);
include/llvm/Analysis/LazyBlockFrequencyInfo.h
   51       assert(F && BPIPass && LI && "call setAnalysis");
include/llvm/Analysis/LazyBranchProbabilityInfo.h
   65         assert(F && LI && "call setAnalysis");
include/llvm/Analysis/LazyCallGraph.h
  263       assert(EdgeIndexMap.find(&N) != EdgeIndexMap.end() && "No such edge!");
  265       assert(E && "Dead or null edge!");
  351       assert(!G == !F &&
  923       assert(RC && "Cannot increment the end iterator!");
  947       assert(!PostOrderRefSCCs.empty() &&
  953       assert(!PostOrderRefSCCs.empty() &&
 1204     assert(IndexIt != RefSCCIndices.end() && "RefSCC doesn't have an index!");
 1205     assert(PostOrderRefSCCs[IndexIt->second] == &RC &&
 1219   assert(*this && "Queried a null edge!");
 1224   assert(*this && "Queried a null edge!");
 1229   assert(*this && "Queried a null edge!");
 1234   assert(*this && "Queried a null edge!");
include/llvm/Analysis/LazyValueInfo.h
  151     assert(!Info.PImpl && "releaseMemory not called");
include/llvm/Analysis/LoopCacheAnalysis.h
   56     assert(SubNum < getNumSubscripts() && "Invalid subscript number");
   60     assert(!Subscripts.empty() && "Expecting non-empty container");
   64     assert(!Subscripts.empty() && "Expecting non-empty container");
include/llvm/Analysis/LoopInfo.h
   98     assert(!isInvalid() && "Loop not in a valid state!");
  110     assert(!isInvalid() && "Loop not in a valid state!");
  116     assert(!isInvalid() && "Loop not in a valid state!");
  126     assert(!isInvalid() && "Loop not in a valid state!");
  137     assert(!isInvalid() && "Loop not in a valid state!");
  141     assert(!isInvalid() && "Loop not in a valid state!");
  155     assert(!isInvalid() && "Loop not in a valid state!");
  162     assert(!isInvalid() && "Loop not in a valid state!");
  169     assert(!isInvalid() && "Loop not in a valid state!");
  176     assert(!isInvalid() && "Loop not in a valid state!");
  182     assert(!isInvalid() && "Loop not in a valid state!");
  188     assert(!isInvalid() && "Loop not in a valid state!");
  209     assert(!isInvalid() && "Loop not in a valid state!");
  210     assert(contains(BB) && "Exiting block must be part of the loop");
  223     assert(!isInvalid() && "Loop not in a valid state!");
  224     assert(contains(BB) && "block does not belong to the loop");
  234     assert(!isInvalid() && "Loop not in a valid state!");
  315     assert(!isInvalid() && "Loop not in a valid state!");
  376     assert(!isInvalid() && "Loop not in a valid state!");
  377     assert(!NewChild->ParentLoop && "NewChild already has a parent!");
  385     assert(!isInvalid() && "Loop not in a valid state!");
  386     assert(I != SubLoops.end() && "Cannot remove end iterator!");
  388     assert(Child->ParentLoop == this && "Child is not a child of this loop!");
  404     assert(!isInvalid() && "Loop not in a valid state!");
  411     assert(!isInvalid() && "Loop not in a valid state!");
  417     assert(!isInvalid() && "Loop not in a valid state!");
  424     assert(!isInvalid() && "Loop not in a valid state!");
  428       assert(i != Blocks.size() && "Loop does not contain BB!");
  441     assert(!isInvalid() && "Loop not in a valid state!");
  443     assert(I != Blocks.end() && "N is not in this list!");
  950     assert(I != end() && "Cannot remove end iterator!");
  952     assert(!L->getParentLoop() && "Not a top-level loop!");
  972     assert(I != TopLevelLoops.end() && "Old loop not at top level!");
  974     assert(!NewLoop->ParentLoop && !OldLoop->ParentLoop &&
  980     assert(!New->getParentLoop() && "Loop already in subloop!");
 1097     assert(Inst->getFunction() == NewLoc->getFunction() &&
include/llvm/Analysis/LoopInfoImpl.h
   36   assert(!isInvalid() && "Loop not in a valid state!");
   50   assert(!isInvalid() && "Loop not in a valid state!");
   64   assert(!isInvalid() && "Loop not in a valid state!");
   76   assert(!isInvalid() && "Loop not in a valid state!");
  104   assert(!L->isInvalid() && "Loop not in a valid state!");
  125   assert(Latch && "Latch block must exists");
  143   assert(!isInvalid() && "Loop not in a valid state!");
  161   assert(!isInvalid() && "Loop not in a valid state!");
  189   assert(!isInvalid() && "Loop not in a valid state!");
  210   assert(!isInvalid() && "Loop not in a valid state!");
  237   assert(!isInvalid() && "Loop not in a valid state!");
  241     assert(contains(SameHeader) && getHeader() == SameHeader->getHeader() &&
  245   assert(NewBB && "Cannot add a null basic block to the loop!");
  246   assert(!LIB[NewBB] && "BasicBlock already in the loop!");
  267   assert(!isInvalid() && "Loop not in a valid state!");
  268   assert(OldChild->ParentLoop == this && "This loop is already broken!");
  269   assert(!NewChild->ParentLoop && "NewChild already has a parent!");
  271   assert(I != SubLoops.end() && "OldChild not in loop!");
  280   assert(!isInvalid() && "Loop not in a valid state!");
  282   assert(!Blocks.empty() && "Loop header is missing");
  300     assert(std::any_of(GraphTraits<BlockT *>::child_begin(BB),
  305     assert(std::any_of(GraphTraits<Inverse<BlockT *>>::child_begin(BB),
  319       assert(!OutsideLoopPreds.empty() && "Loop is unreachable!");
  327           assert(CB != OutsideLoopPreds[i] &&
  330     assert(BB != &getHeader()->getParent()->front() &&
  343     assert(false && "Unreachable block in loop");
  351       assert(contains(*BI) &&
  357     assert(is_contained(*ParentLoop, this) &&
  367   assert(!isInvalid() && "Loop not in a valid state!");
  593     assert(PreOrderWorklist.empty() &&
  643   assert(H == OtherH &&
  646   assert(L->getLoopDepth() == OtherL->getLoopDepth() &&
  650     assert(ParentL->getHeader() == OtherParentL->getHeader() &&
  659     assert(OtherSubL && "Inner loop is missing in computed loop info!");
  666   assert(compareVectors(BBs, OtherBBs) &&
  671   assert(BlocksSet.size() == OtherBlocksSet.size() &&
  685     assert(!(*I)->getParentLoop() && "Top-level loop has a parent!");
  694     assert(Loops.count(L) && "orphaned loop");
  695     assert(L->contains(BB) && "orphaned block");
  697       assert(!ChildLoop->contains(BB) &&
  718     assert(OtherL && "Top level loop is missing in computed loop info!");
include/llvm/Analysis/LoopIterator.h
  130     assert(isComplete() && "bad loop DFS");
  137     assert(isComplete() && "bad loop DFS");
  154     assert(I != PostNumbers.end() && "block not visited by DFS");
  155     assert(I->second && "block not finished by DFS");
  217     assert(DFS.PostBlocks.empty() && "Need clear DFS result before traversing");
  218     assert(DFS.L->getNumBlocks() && "po_iterator cannot handle an empty graph");
  241     assert(DFS.PostNumbers.count(BB) && "Loop DFS skipped preorder");
include/llvm/Analysis/LoopPass.h
  118     assert(N < PassVector.size() && "Pass number out of range!");
include/llvm/Analysis/MemoryDependenceAnalysis.h
  132     assert(Inst && "Def requires inst");
  136     assert(Inst && "Clobber requires inst");
include/llvm/Analysis/MemoryLocation.h
  127     assert(hasValue() && "Getting value from an unknown LocationSize!");
include/llvm/Analysis/MemorySSA.h
  535     assert(V && "PHI node got a null value!");
  548     assert(this == U.getUser() && "Iterator doesn't point to PHI's Uses?");
  559     assert(BB && "PHI node got a null basic block!");
  584     assert(Idx >= 0 && "Invalid basic block argument!");
  591     assert(I < E && "Cannot remove out of bounds Phi entry.");
  594     assert(E >= 2 && "Cannot only remove incoming values in MemoryPhis with "
  612     assert(getNumOperands() >= 1 &&
  665   assert((isa<MemoryDef>(this) || isa<MemoryPhi>(this)) &&
 1027     assert(MA && "Handed an instruction that MemorySSA doesn't recognize?");
 1103     assert(MP && "Tried to get phi arg block when not iterating over a PHI");
 1108     assert(Access && "Tried to access past the end of our iterator");
 1118     assert(Access && "Hit end of iterator");
 1202     assert(DefIterator != OriginalAccess->defs_end() &&
 1209     assert(DefIterator != OriginalAccess->defs_end() &&
include/llvm/Analysis/OptimizationRemarkEmitter.h
  147     assert(ORE && "pass not run yet");
include/llvm/Analysis/PtrUseVisitor.h
  224     assert(I.getType()->isPointerTy());
include/llvm/Analysis/RegionInfo.h
 1001   assert(!isSubRegion() && "This is not a BasicBlock RegionNode!");
 1009   assert(isSubRegion() && "This is not a subregion RegionNode!");
include/llvm/Analysis/RegionInfoImpl.h
   63   assert(exit && "No exit to replace!");
  157   assert(LI && BB && "LI and BB cannot be null!");
  347   assert(contains(R) && "BB not in current region!");
  360   assert(contains(BB) && "Can get BB node out of this region!");
  376   assert(contains(BB) && "Can get BB node out of this region!");
  394   assert(!SubRegion->parent && "SubRegion already has a parent!");
  395   assert(llvm::find_if(*this,
  407   assert(SubRegion->children.empty() &&
  437   assert(Child->parent == this && "Child is not a child of this region!");
  443   assert(I != children.end() && "Region does not exit. Unable to remove.");
  552   assert(R && "Re must be non-null");
  579   assert(entry && exit && "entry and exit must not be null!");
  622   assert(entry && exit && "entry and exit must not be null!");
  651   assert(entry && exit && "entry and exit must not be null!");
  665   assert(entry && exit && "entry and exit must not be null!");
  687   assert(entry);
  878   assert(A && B && "One of the Regions is NULL");
include/llvm/Analysis/RegionIterator.h
   71     assert(Node.getInt() == ItRgBegin && "Cannot advance region successor!");
   85     assert(succ && "BB not in Region or entered subregion!");
   91     assert(Node.getInt() == ItRgBegin && "Cannot get the region successor!");
  123     assert(isRegionMode() == x.isRegionMode() && "Broken iterator!");
  134     assert(!isExit(BB) && "Iterator out of range!");
  185     assert(!Node->isSubRegion() &&
  187     assert(Node->getParent() && "A BB node must have a parent!");
  198     assert(!Node->isSubRegion() &&
  203     assert(Node->getParent() == x.Node->getParent()
  219     assert(Parent->getExit() != BB && "iterator out of range!");
include/llvm/Analysis/RegionPass.h
  118     assert(N < PassVector.size() && "Pass number out of range!");
include/llvm/Analysis/ScalarEvolution.h
  338     assert((Flags & IncrementNoWrapMask) == Flags && "Invalid flags value!");
  339     assert((OffFlags & IncrementNoWrapMask) == OffFlags &&
  346     assert((Flags & IncrementNoWrapMask) == Flags && "Invalid flags value!");
  347     assert((Mask & IncrementNoWrapMask) == Mask && "Invalid mask value!");
  355     assert((Flags & IncrementNoWrapMask) == Flags && "Invalid flags value!");
  356     assert((OnFlags & IncrementNoWrapMask) == OnFlags &&
 1212       assert(!isa<SCEVUnionPredicate>(P) && "Only add leaf predicates here!");
include/llvm/Analysis/ScalarEvolutionExpander.h
  123         assert(SE->InsertPointGuards.back() == this);
  157       assert(InsertPointGuards.empty());
  241       assert(!CanonicalMode &&
  250       assert(!CanonicalMode &&
  276       assert(IP);
include/llvm/Analysis/ScalarEvolutionExpressions.h
  160       assert(i < NumOperands && "Operand index out of range!");
  381       assert(isMinMaxType(T));
  668       assert(Result.second && "Should insert a new entry");
include/llvm/Analysis/TargetLibraryInfo.h
  132       assert(CustomNames.find(F) != CustomNames.end());
  299     assert(State == TargetLibraryInfoImpl::CustomName);
include/llvm/Analysis/TargetTransformInfoImpl.h
   57       assert(OpTy && "Cast instructions must provide the operand type");
  127     assert(FTy && "FunctionType must be provided to this routine.");
  170     assert(F && "A concrete function must be provided to this routine.");
  700     assert(F && "A concrete function must be provided to this routine.");
  733     assert(PointeeType && Ptr && "can't get GEPCost of nullptr");
  735     assert(Ptr->getType()->getScalarType()->getPointerElementType() ==
  763         assert(ConstIdx && "Unexpected GEP index");
include/llvm/Analysis/Trace.h
   75     assert(B1Idx != -1 && B2Idx != -1 && "Block is not in the trace!");
include/llvm/Analysis/ValueLattice.h
  149     assert(isConstant() && "Cannot get the constant of a non-constant!");
  154     assert(isNotConstant() && "Cannot get the constant of a non-notconstant!");
  159     assert(isConstantRange() &&
  185     assert(V && "Marking constant with NULL");
  193     assert((!isConstant() || getConstant() == V) &&
  195     assert(isUndefined());
  201     assert(V && "Marking constant with NULL");
  209     assert((!isConstant() || getConstant() != V) &&
  211     assert((!isNotConstant() || getNotConstant() == V) &&
  213     assert(isUndefined() || isConstant());
  228     assert(isUndefined());
  267     assert(isConstantRange() && "New ValueLattice type?");
  285     assert(isConstant() && isa<ConstantInt>(getConstant()) &&
include/llvm/Analysis/ValueTracking.h
  281       assert(Delta < Length);
include/llvm/Analysis/VectorUtils.h
  391     assert(Factor > 1 && "Invalid interleave factor");
  487     assert(!getMember(0)->mayWriteToMemory() &&
  489     assert(!isReverse() && "Group should have been invalidated");
  640     assert(!InterleaveGroupMap.count(Instr) &&
include/llvm/BinaryFormat/COFF.h
  495     assert(isOrdinal() && "ILT entry is not an ordinal!");
  507     assert(!isOrdinal() && "ILT entry is not a Hint/Name RVA!");
include/llvm/BinaryFormat/MachO.def
   15 HANDLE_LOAD_COMMAND(LC_SEGMENT, 0x00000001u, segment_command)
   16 HANDLE_LOAD_COMMAND(LC_SYMTAB, 0x00000002u, symtab_command)
   18 HANDLE_LOAD_COMMAND(LC_SYMSEG, 0x00000003u, symseg_command)
   19 HANDLE_LOAD_COMMAND(LC_THREAD, 0x00000004u, thread_command)
   20 HANDLE_LOAD_COMMAND(LC_UNIXTHREAD, 0x00000005u, thread_command)
   22 HANDLE_LOAD_COMMAND(LC_LOADFVMLIB, 0x00000006u, fvmlib_command)
   24 HANDLE_LOAD_COMMAND(LC_IDFVMLIB, 0x00000007u, fvmlib_command)
   26 HANDLE_LOAD_COMMAND(LC_IDENT, 0x00000008u, ident_command)
   28 HANDLE_LOAD_COMMAND(LC_FVMFILE, 0x00000009u, fvmfile_command)
   30 HANDLE_LOAD_COMMAND(LC_PREPAGE, 0x0000000Au, load_command)
   31 HANDLE_LOAD_COMMAND(LC_DYSYMTAB, 0x0000000Bu, dysymtab_command)
   32 HANDLE_LOAD_COMMAND(LC_LOAD_DYLIB, 0x0000000Cu, dylib_command)
   33 HANDLE_LOAD_COMMAND(LC_ID_DYLIB, 0x0000000Du, dylib_command)
   34 HANDLE_LOAD_COMMAND(LC_LOAD_DYLINKER, 0x0000000Eu, dylinker_command)
   35 HANDLE_LOAD_COMMAND(LC_ID_DYLINKER, 0x0000000Fu, dylinker_command)
   37 HANDLE_LOAD_COMMAND(LC_PREBOUND_DYLIB, 0x00000010u, prebound_dylib_command)
   38 HANDLE_LOAD_COMMAND(LC_ROUTINES, 0x00000011u, routines_command)
   39 HANDLE_LOAD_COMMAND(LC_SUB_FRAMEWORK, 0x00000012u, sub_framework_command)
   40 HANDLE_LOAD_COMMAND(LC_SUB_UMBRELLA, 0x00000013u, sub_umbrella_command)
   41 HANDLE_LOAD_COMMAND(LC_SUB_CLIENT, 0x00000014u, sub_client_command)
   42 HANDLE_LOAD_COMMAND(LC_SUB_LIBRARY, 0x00000015u, sub_library_command)
   44 HANDLE_LOAD_COMMAND(LC_TWOLEVEL_HINTS, 0x00000016u, twolevel_hints_command)
   46 HANDLE_LOAD_COMMAND(LC_PREBIND_CKSUM, 0x00000017u, prebind_cksum_command)
   48 HANDLE_LOAD_COMMAND(LC_LOAD_WEAK_DYLIB, 0x80000018u, dylib_command)
   49 HANDLE_LOAD_COMMAND(LC_SEGMENT_64, 0x00000019u, segment_command_64)
   50 HANDLE_LOAD_COMMAND(LC_ROUTINES_64, 0x0000001Au, routines_command_64)
   51 HANDLE_LOAD_COMMAND(LC_UUID, 0x0000001Bu, uuid_command)
   52 HANDLE_LOAD_COMMAND(LC_RPATH, 0x8000001Cu, rpath_command)
   53 HANDLE_LOAD_COMMAND(LC_CODE_SIGNATURE, 0x0000001Du, linkedit_data_command)
   54 HANDLE_LOAD_COMMAND(LC_SEGMENT_SPLIT_INFO, 0x0000001Eu, linkedit_data_command)
   55 HANDLE_LOAD_COMMAND(LC_REEXPORT_DYLIB, 0x8000001Fu, dylib_command)
   56 HANDLE_LOAD_COMMAND(LC_LAZY_LOAD_DYLIB, 0x00000020u, dylib_command)
   57 HANDLE_LOAD_COMMAND(LC_ENCRYPTION_INFO, 0x00000021u, encryption_info_command)
   58 HANDLE_LOAD_COMMAND(LC_DYLD_INFO, 0x00000022u, dyld_info_command)
   59 HANDLE_LOAD_COMMAND(LC_DYLD_INFO_ONLY, 0x80000022u, dyld_info_command)
   60 HANDLE_LOAD_COMMAND(LC_LOAD_UPWARD_DYLIB, 0x80000023u, dylib_command)
   61 HANDLE_LOAD_COMMAND(LC_VERSION_MIN_MACOSX, 0x00000024u, version_min_command)
   62 HANDLE_LOAD_COMMAND(LC_VERSION_MIN_IPHONEOS, 0x00000025u, version_min_command)
   63 HANDLE_LOAD_COMMAND(LC_FUNCTION_STARTS, 0x00000026u, linkedit_data_command)
   64 HANDLE_LOAD_COMMAND(LC_DYLD_ENVIRONMENT, 0x00000027u, dylinker_command)
   65 HANDLE_LOAD_COMMAND(LC_MAIN, 0x80000028u, entry_point_command)
   66 HANDLE_LOAD_COMMAND(LC_DATA_IN_CODE, 0x00000029u, linkedit_data_command)
   67 HANDLE_LOAD_COMMAND(LC_SOURCE_VERSION, 0x0000002Au, source_version_command)
   68 HANDLE_LOAD_COMMAND(LC_DYLIB_CODE_SIGN_DRS, 0x0000002Bu, linkedit_data_command)
   69 HANDLE_LOAD_COMMAND(LC_ENCRYPTION_INFO_64, 0x0000002Cu,
   71 HANDLE_LOAD_COMMAND(LC_LINKER_OPTION, 0x0000002Du, linker_option_command)
   72 HANDLE_LOAD_COMMAND(LC_LINKER_OPTIMIZATION_HINT, 0x0000002Eu, linkedit_data_command)
   73 HANDLE_LOAD_COMMAND(LC_VERSION_MIN_TVOS, 0x0000002Fu, version_min_command)
   74 HANDLE_LOAD_COMMAND(LC_VERSION_MIN_WATCHOS, 0x00000030u, version_min_command)
   75 HANDLE_LOAD_COMMAND(LC_NOTE, 0x00000031u, note_command)
   76 HANDLE_LOAD_COMMAND(LC_BUILD_VERSION, 0x00000032u, build_version_command)
include/llvm/BinaryFormat/MsgPackDocument.h
   79     assert(getKind() == Type::Int);
   84     assert(getKind() == Type::UInt);
   89     assert(getKind() == Type::Boolean);
   94     assert(getKind() == Type::Float);
   99     assert(getKind() == Type::Int);
  104     assert(getKind() == Type::UInt);
  109     assert(getKind() == Type::Boolean);
  114     assert(getKind() == Type::Float);
  119     assert(getKind() == Type::String);
  127       assert(Convert);
  138       assert(Convert);
  200   MapDocNode(DocNode &N) : DocNode(N) { assert(getKind() == Type::Map); }
  220   ArrayDocNode(DocNode &N) : DocNode(N) { assert(getKind() == Type::Array); }
  228     assert(N.getDocument() == getDocument());
include/llvm/Bitstream/BitCodes.h
  116   uint64_t getLiteralValue() const { assert(isLiteral()); return Val; }
  119   Encoding getEncoding() const { assert(isEncoding()); return (Encoding)Enc; }
  121     assert(isEncoding() && hasEncodingData());
  157     assert((V & ~63) == 0 && "Not a Char6 encoded character!");
include/llvm/Bitstream/BitstreamReader.h
  133     assert(canSkipToPos(ByteNo) && "Invalid location");
  159     assert(!(BitNo % 8) && "Expected bit on byte boundary");
  192     assert(NumBits && NumBits <= BitsInWord &&
include/llvm/Bitstream/BitstreamWriter.h
   79     assert((Offset & 3) == 0 && "Not 32-bit aligned");
   88     assert(CurBit == 0 && "Unflushed data remaining");
   89     assert(BlockScope.empty() && CurAbbrevs.empty() && "Block imbalance");
  107     assert((!endian::readAtBitAlignment<uint32_t, little, unaligned>(
  120     assert(NumBits && NumBits <= 32 && "Invalid value size!");
  121     assert((Val & ~(~0U >> (32-NumBits))) == 0 && "High bits set!");
  147     assert(NumBits <= 32 && "Too many bits to emit!");
  160     assert(NumBits <= 32 && "Too many bits to emit!");
  229     assert(!BlockScope.empty() && "Block scope imbalance!");
  259     assert(Op.isLiteral() && "Not a literal");
  262     assert(V == Op.getLiteralValue() &&
  270     assert(!Op.isLiteral() && "Literals should use EmitAbbreviatedLiteral!");
  301     assert(AbbrevNo < CurAbbrevs.size() && "Invalid abbrev #!");
  308       assert(e && "Expected non-empty abbreviation");
  314         assert(Op.getEncoding() != BitCodeAbbrevOp::Array &&
  325         assert(RecordIdx < Vals.size() && "Invalid abbrev/record");
  330         assert(i + 2 == e && "array op not second to last?");
  336           assert(RecordIdx == Vals.size() &&
  360           assert(RecordIdx == Vals.size() &&
  363           assert(Blob.data() == BlobData && "BlobData got moved");
  364           assert(Blob.size() == BlobLen && "BlobLen got changed");
  371         assert(RecordIdx < Vals.size() && "Invalid abbrev/record");
  376     assert(RecordIdx == Vals.size() && "Not all record operands emitted!");
  377     assert(BlobData == nullptr &&
  394       assert(isUInt<8>(B) && "Value too large to emit as byte");
include/llvm/CodeGen/AccelTable.h
  208   assert(Buckets.empty() && "Already finalized!");
  212   assert(Iter->second.Name == Name);
include/llvm/CodeGen/BasicTTIImpl.h
   85     assert(Ty->isVectorTy() && "Can only shuffle vectors");
  102     assert(Ty->isVectorTy() && "Can only shuffle vectors");
  123     assert(Ty && Ty->isVectorTy() && SubTy && SubTy->isVectorTy() &&
  126     assert((Index + NumSubElts) <= (int)Ty->getVectorNumElements() &&
  145     assert(Ty && Ty->isVectorTy() && SubTy && SubTy->isVectorTy() &&
  148     assert((Index + NumSubElts) <= (int)Ty->getVectorNumElements() &&
  561     assert(Ty->isVectorTy() && "Can only scalarize vectors");
  589           assert((VF == 1 || VF == VecTy->getVectorNumElements()) &&
  603     assert(VecTy->isVectorTy());
  631     assert(ISD && "Invalid opcode");
  691     assert(ISD && "Invalid opcode");
  829     assert(ISD && "Invalid opcode");
  833       assert(CondTy && "CondTy must exist");
  875     assert(!Src->isVoidTy() && "Invalid type");
  911     assert(VT && "Expect a vector type for interleaved memory op");
  914     assert(Factor > 1 && NumElts % Factor == 0 && "Invalid interleave factor");
  983       assert(Indices.size() <= Factor &&
  987         assert(Index < Factor && "Invalid index for interleaved memory op");
 1064     assert((RetVF == 1 || VF == 1) && "VF > 1 and RetVF is a vector type");
 1073         assert(VF == 1 || !OpTy->isVectorTy());
 1095       assert(VF == 1 && "Can't vectorize types here.");
 1103       assert(VF == 1 && "Can't vectorize types here.");
 1597     assert(Ty->isVectorTy() && "Expect a vector type");
 1647     assert(Ty->isVectorTy() && "Expect a vector type");
 1656       assert(Ty->isIntOrIntVectorTy() &&
include/llvm/CodeGen/CallingConvLower.h
  150   Register getLocReg() const { assert(isRegLoc()); return Loc; }
  151   unsigned getLocMemOffset() const { assert(isMemLoc()); return Loc; }
  474     assert(InRegsParamRecordIndex < ByValRegs.size() &&
include/llvm/CodeGen/DIE.h
  515     assert(N.Next.getPointer() == &N && "Expected unlinked node");
  516     assert(N.Next.getInt() == true && "Expected unlinked node");
  526     assert(N.Next.getPointer() == &N && "Expected unlinked node");
  527     assert(N.Next.getInt() == true && "Expected unlinked node");
  820     assert(!Child->getParent() && "Child should be orphaned");
  827     assert(!Child->getParent() && "Child should be orphaned");
  873     assert(!this->Section);
include/llvm/CodeGen/DwarfStringPoolEntry.h
   47     assert(getMapEntry()->second.Symbol && "No symbol available!");
   53     assert(isIndexed());
   54     assert(getMapEntry()->getValue().isIndexed());
include/llvm/CodeGen/ExecutionDomainFix.h
   77     assert(domain <
include/llvm/CodeGen/FaultMaps.h
  101     assert(P + sizeof(T) <= E && "out of bounds read!");
  172       assert(Index < getNumFaultingPCs() && "index out of bounds!");
  183       assert(Begin < E && "out of bounds!");
  193     assert(Version == 1 && "only version 1 supported!");
include/llvm/CodeGen/FunctionLoweringInfo.h
  213     assert(R == 0 && "Already initialized this value register!");
  214     assert(VirtReg2Value.empty());
include/llvm/CodeGen/GlobalISel/CallLowering.h
   64       assert((Ty->isVoidTy() == (Regs.empty() || Regs[0] == 0)) &&
  268       assert(SwiftErrorVReg == 0 && "attempt to use unsupported swifterror");
include/llvm/CodeGen/GlobalISel/CombinerInfo.h
   35     assert(((AllowIllegalOps || !LegalizeIllegalOps) || LInfo) &&
include/llvm/CodeGen/GlobalISel/ConstantFoldingMIRBuilder.h
   47       assert(DstOps.size() == 1 && "Invalid dst ops");
   48       assert(SrcOps.size() == 2 && "Invalid src ops");
   58       assert(DstOps.size() == 1 && "Invalid dst ops");
   59       assert(SrcOps.size() == 2 && "Invalid src ops");
include/llvm/CodeGen/GlobalISel/GISelWorkList.h
   66     assert(WorklistMap.empty() && "Expecting empty worklistmap");
   79     assert(Finalized && "GISelWorkList used without finalizing");
   86     assert((Finalized || WorklistMap.empty()) && "Neither finalized nor empty");
  103     assert(Finalized && "GISelWorkList used without finalizing");
  108     assert(I && "Pop back on empty worklist");
include/llvm/CodeGen/GlobalISel/IRTranslator.h
  117       assert(ValToVRegs.find(&V) == ValToVRegs.end() && "Value already exists");
  127       assert(TypeToOffsets.find(V.getType()) == TypeToOffsets.end() &&
  530       assert(irt && "irt is null!");
  566     assert(Regs.size() == 1 &&
include/llvm/CodeGen/GlobalISel/InstructionSelectorImpl.h
   74     assert(CurrentIdx != ~0u && "Invalid MatchTable index");
   91       assert(NewInsnID != 0 && "Refusing to modify MIs[0]");
  113         assert((size_t)NewInsnID == State.MIs.size() &&
  142       assert(State.MIs[InsnID] != nullptr && "Used insn before defined");
  162       assert(State.MIs[InsnID] != nullptr && "Used insn before defined");
  190       assert(State.MIs[InsnID] != nullptr && "Used insn before defined");
  233       assert(State.MIs[InsnID] != nullptr && "Used insn before defined");
  247       assert(State.MIs[InsnID] != nullptr && "Used insn before defined");
  248       assert(State.MIs[InsnID]->getOpcode() == TargetOpcode::G_CONSTANT &&
  250       assert(Predicate > GIPFP_I64_Invalid && "Expected a valid predicate");
  271       assert(State.MIs[InsnID] != nullptr && "Used insn before defined");
  272       assert(State.MIs[InsnID]->getOpcode() == TargetOpcode::G_CONSTANT &&
  274       assert(Predicate > GIPFP_APInt_Invalid && "Expected a valid predicate");
  293       assert(State.MIs[InsnID] != nullptr && "Used insn before defined");
  294       assert(State.MIs[InsnID]->getOpcode() == TargetOpcode::G_FCONSTANT &&
  296       assert(State.MIs[InsnID]->getOperand(1).isFPImm() && "Expected FPImm operand");
  297       assert(Predicate > GIPFP_APFloat_Invalid && "Expected a valid predicate");
  312       assert(State.MIs[InsnID] != nullptr && "Used insn before defined");
  313       assert(Predicate > GIPFP_MI_Invalid && "Expected a valid predicate");
  326       assert(State.MIs[InsnID] != nullptr && "Used insn before defined");
  344       assert(State.MIs[InsnID] != nullptr && "Used insn before defined");
  362       assert(State.MIs[InsnID] != nullptr && "Used insn before defined");
  417       assert(State.MIs[InsnID] != nullptr && "Used insn before defined");
  446       assert(State.MIs[InsnID] != nullptr && "Used insn before defined");
  482       assert(State.MIs[InsnID] != nullptr && "Used insn before defined");
  525       assert(State.MIs[InsnID] != nullptr && "Used insn before defined");
  543       assert(State.MIs[InsnID] != nullptr && "Used insn before defined");
  554       assert(SizeInBits != 0 && "Pointer size must be known");
  573       assert(State.MIs[InsnID] != nullptr && "Used insn before defined");
  595       assert(State.MIs[InsnID] != nullptr && "Used insn before defined");
  616       assert(State.MIs[InsnID] != nullptr && "Used insn before defined");
  641       assert(State.MIs[InsnID] != nullptr && "Used insn before defined");
  658       assert(State.MIs[InsnID] != nullptr && "Used insn before defined");
  673       assert(State.MIs[InsnID] != nullptr && "Used insn before defined");
  686       assert(State.MIs[InsnID] != nullptr && "Used insn before defined");
  699       assert(State.MIs[InsnID] != nullptr && "Used insn before defined");
  711       assert(State.MIs[InsnID] != nullptr && "Used insn before defined");
  727       assert(State.MIs[InsnID] != nullptr && "Used insn before defined");
  728       assert(State.MIs[OtherInsnID] != nullptr && "Used insn before defined");
  778       assert(OutMIs[NewInsnID] && "Attempted to add to undefined instruction");
  792       assert(OutMIs[NewInsnID] && "Attempted to add to undefined instruction");
  810       assert(OutMIs[NewInsnID] && "Attempted to add to undefined instruction");
  823       assert(OutMIs[InsnID] && "Attempted to add to undefined instruction");
  834       assert(OutMIs[InsnID] && "Attempted to add to undefined instruction");
  846       assert(OutMIs[InsnID] && "Attempted to add to undefined instruction");
  859       assert(OutMIs[InsnID] && "Attempted to add to undefined instruction");
  871       assert(OutMIs[InsnID] && "Attempted to add to undefined instruction");
  882       assert(OutMIs[InsnID] && "Attempted to add to undefined instruction");
  894       assert(OutMIs[InsnID] && "Attempted to add to undefined instruction");
  907       assert(OutMIs[NewInsnID] && "Attempted to add to undefined instruction");
  908       assert(State.MIs[OldInsnID]->getOpcode() == TargetOpcode::G_CONSTANT && "Expected G_CONSTANT");
  926       assert(OutMIs[NewInsnID] && "Attempted to add to undefined instruction");
  927       assert(State.MIs[OldInsnID]->getOpcode() == TargetOpcode::G_FCONSTANT && "Expected G_FCONSTANT");
  943       assert(OutMIs[InsnID] && "Attempted to add to undefined instruction");
  956       assert(OutMIs[InsnID] && "Attempted to add to undefined instruction");
  968       assert(OutMIs[InsnID] && "Attempted to add to undefined instruction");
  980       assert(OutMIs[InsnID] && "Attempted to add to undefined instruction");
  999       assert(State.MIs[InsnID] &&
include/llvm/CodeGen/GlobalISel/LegalizationArtifactCombiner.h
   50     assert(MI.getOpcode() == TargetOpcode::G_ANYEXT);
   95     assert(MI.getOpcode() == TargetOpcode::G_ZEXT);
  136     assert(MI.getOpcode() == TargetOpcode::G_SEXT);
  162     assert(MI.getOpcode() == TargetOpcode::G_TRUNC);
  190     assert(Opcode == TargetOpcode::G_ANYEXT || Opcode == TargetOpcode::G_ZEXT ||
  251     assert(MI.getOpcode() == TargetOpcode::G_UNMERGE_VALUES);
  377     assert(MI.getOpcode() == TargetOpcode::G_EXTRACT);
  503           assert((TmpDef->getOpcode() == TargetOpcode::COPY ||
include/llvm/CodeGen/GlobalISel/LegalizerInfo.h
  339     assert(TypeIdx <=
  349     assert(ImmIdx <= (MCOI::OPERAND_LAST_GENERIC_IMM -
  366     assert(AliasOf == 0 &&
  469     assert((AliasOf == 0 || AliasOf == Opcode) &&
  471     assert(Rules.empty() && "Aliasing will discard rules");
  804     assert(MinTy.isScalar() && MaxTy.isScalar() && "Expected scalar types");
  899     assert(MinTy.getElementType() == MaxTy.getElementType() &&
  968     assert(!needsLegalizingToDifferentSize(Action));
 1035     assert(v.size() > 0 &&
 1059     assert(v.size() > 0 &&
 1241       assert(SizeAndAction.first > prev_size);
 1273       assert(SmallestLegalizableToSameSizeIdx != -1);
 1274       assert(SmallestNarrowIdx > SmallestLegalizableToSameSizeIdx);
 1277       assert(LargestWidenIdx < LargestLegalizableToSameSizeIdx);
 1286     assert(v.size() >= 1);
 1287     assert(v[0].first == 1);
include/llvm/CodeGen/GlobalISel/MachineIRBuilder.h
  101     assert(Ty == DstType::Ty_Reg && "Not a register");
  248     assert(State.TII && "TargetInstrInfo is not set");
  254     assert(State.MF && "MachineFunction is not set");
  259     assert(State.MF && "MachineFunction is not set");
  279     assert(State.MBB && "MachineBasicBlock is not set");
include/llvm/CodeGen/GlobalISel/RegBankSelect.h
  151         assert(canMaterialize() && "Impossible to materialize this point");
  155       assert(!isSplit() && "Wrong pre-condition");
  170         assert(canMaterialize() && "Impossible to materialize this point");
  174       assert(!isSplit() && "Wrong pre-condition");
  258       assert((!Beginning || MBB.getFirstNonPHI() == MBB.begin()) &&
  262       assert((Beginning || MBB.getFirstTerminator() == MBB.end()) &&
  291       assert(DstOrSplit && DstOrSplit->isPredecessor(&Src) &&
  399       assert(NewKind != Kind && "Already of the right Kind");
  404       assert(NewKind != RepairingKind::Insert &&
include/llvm/CodeGen/GlobalISel/RegisterBankInfo.h
  203       assert(i < getNumOperands() && "Out of bound operand");
  431     assert(ID < getNumRegBanks() && "Accessing an unknown register bank");
include/llvm/CodeGen/LatencyPriorityQueue.h
   69       assert(NodeNum < (*SUnits).size());
   74       assert(NodeNum < NumNodesSolelyBlocking.size());
include/llvm/CodeGen/LexicalScopes.h
   49     assert(D);
   50     assert(D->getSubprogram()->getUnit()->getEmissionKind() !=
   53     assert(D->isResolved() && "Expected resolved node");
   54     assert((!I || I->isResolved()) && "Expected resolved node");
   83     assert(FirstInsn && "MI Range is not open!");
   93     assert(LastInsn && "Last insn missing!");
include/llvm/CodeGen/LiveInterval.h
  171         assert(S < E && "Cannot create empty or backwards segment");
  181         assert((S < E) && "Backwards interval?");
  237       assert(Other.segmentSet == nullptr &&
  247       assert(Other.segmentSet == nullptr &&
  263       assert(I != end());
  271       assert(I != end());
  377       assert(!empty() && "Call to beginIndex() on empty range.");
  384       assert(!empty() && "Call to endIndex() on empty range.");
  620       assert(std::is_sorted(R.begin(), R.end()));
include/llvm/CodeGen/LiveIntervalUnion.h
  186       assert(idx <  Size && "idx out of bounds");
  191       assert(Idx < Size && "Idx out of bounds");
include/llvm/CodeGen/LiveIntervals.h
  132       assert(!hasInterval(Reg) && "Interval already exists!");
  261       assert(unsigned(MBB->getNumber()) == RegMaskBlocks.size() &&
include/llvm/CodeGen/LivePhysRegs.h
   80     assert(TRI && "LivePhysRegs is not initialized.");
   81     assert(Reg <= TRI->getNumRegs() && "Expected a physical register.");
   90     assert(TRI && "LivePhysRegs is not initialized.");
   91     assert(Reg <= TRI->getNumRegs() && "Expected a physical register.");
include/llvm/CodeGen/LiveRangeEdit.h
  151     assert(Parent && "No parent LiveInterval");
include/llvm/CodeGen/LiveRegUnits.h
   66         assert(O->isUse() && "Reg operand not a def and not a use");
include/llvm/CodeGen/LiveStacks.h
   64     assert(Slot >= 0 && "Spill slot indice must be >= 0");
   66     assert(I != S2IMap.end() && "Interval does not exist for stack slot");
   71     assert(Slot >= 0 && "Spill slot indice must be >= 0");
   73     assert(I != S2IMap.end() && "Interval does not exist for stack slot");
   80     assert(Slot >= 0 && "Spill slot indice must be >= 0");
   83     assert(I != S2RCMap.end() &&
include/llvm/CodeGen/LiveVariables.h
  224     assert(Removed && "Register is not used by this instruction!");
  259     assert(Removed && "Register is not defined by this instruction!");
include/llvm/CodeGen/MachineBasicBlock.h
  614     assert((I == end() || I->getParent() == this) &&
  621     assert((I == end() || I->getParent() == this) &&
  623     assert(!MI->isBundledWithPred() && !MI->isBundledWithSucc() &&
  630     assert((I == end() || I->getParent() == this) &&
  632     assert(!MI->isBundledWithPred() && !MI->isBundledWithSucc() &&
  640     assert((I == instr_end() || I->getParent() == this) &&
  642     assert(!MI->isBundledWithPred() && !MI->isBundledWithSucc() &&
  689     assert(!I->isBundled() && "Cannot remove bundled instructions");
  930     assert(I == BB->end() || I->getParent() == BB);
include/llvm/CodeGen/MachineDominators.h
  247     assert(Inserted &&
include/llvm/CodeGen/MachineFrameInfo.h
  406     assert (i >= 0 && (unsigned)i < LocalFrameObjects.size() &&
  444     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  451     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  458     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  465     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  472     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  484     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  492     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  494     assert(!isDeadObjectIndex(ObjectIdx) &&
  500     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  506     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  512     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  518     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  526     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  528     assert(!isDeadObjectIndex(ObjectIdx) &&
  534     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  540     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  542     assert(!isDeadObjectIndex(ObjectIdx) &&
  664     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  674     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  681     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  688     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  694     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  706     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  715     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  723     assert(unsigned(ObjectIdx + NumFixedObjects) < Objects.size() &&
  729     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  732     assert(isStatepointSpillSlotObjectIndex(ObjectIdx) && "inconsistent");
include/llvm/CodeGen/MachineFunction.h
   86     assert(this == &OldList && "never transfer MBBs between functions");
  390       assert(Arg < (1 << 16) && "Arg out of range");
  407     assert(MI->isCall() &&
  439     assert(TheDelegate == delegate &&
  447     assert(delegate && !TheDelegate &&
  587     assert(N < MBBNumbering.size() && "Illegal block number");
  588     assert(MBBNumbering[N] && "Block was removed from the machine function!");
  715     assert(N < MBBNumbering.size() && "Illegal basic block #");
  918     assert(hasWasmLandingPadIndex(LPad));
  924     assert(hasCallSiteLandingPad(Sym) &&
  941     assert(hasCallSiteBeginLabel(BeginLabel) &&
  986     assert(CallI->isCall());
include/llvm/CodeGen/MachineInstr.h
  432     assert(i < getNumOperands() && "getOperand() out of range!");
  436     assert(i < getNumOperands() && "getOperand() out of range!");
  463     assert(getOperand(OpIdx).getType() == MachineOperand::MO_Immediate &&
  636     assert(MCFlag < 64 &&
 1565     assert(debugLoc.hasTrivialDestructor() && "Expected trivial destructor");
include/llvm/CodeGen/MachineInstrBuilder.h
   90     assert((flags & 0x1) == 0 &&
  116     assert(!(Flags & RegState::Define) &&
  229     assert((MI->isDebugValue() ? static_cast<bool>(MI->getDebugVariable())
  232     assert((MI->isDebugLabel() ? static_cast<bool>(MI->getDebugLabel())
  497   assert(RegOp.isReg() && "Not a register operand");
  527     assert(B != E && "No instructions to bundle");
include/llvm/CodeGen/MachineInstrBundle.h
  138     assert(isValid() && "Cannot advance MIOperands beyond the last operand");
include/llvm/CodeGen/MachineInstrBundleIterator.h
  133     assert((!MI.getNodePtr() || MI.isEnd() || !MI->isBundledWithPred()) &&
  139     assert(!MI.isBundledWithPred() && "It's not legal to initialize "
  146     assert((!MI || !MI->isBundledWithPred()) && "It's not legal to initialize "
include/llvm/CodeGen/MachineModuleInfoImpls.h
   44     assert(Sym && "Key cannot be null");
   49     assert(Sym && "Key cannot be null");
   73     assert(Sym && "Key cannot be null");
   95     assert(Sym && "Key cannot be null");
include/llvm/CodeGen/MachineOperand.h
  222     assert(!isReg() && "Register operands can't have target flags");
  224     assert(SubReg_TargetFlags == F && "Target flags out of range");
  227     assert(!isReg() && "Register operands can't have target flags");
  229     assert((SubReg_TargetFlags & F) && "Target flags out of range");
  354     assert(isReg() && "This is not a register operand!");
  359     assert(isReg() && "Wrong MachineOperand accessor");
  364     assert(isReg() && "Wrong MachineOperand accessor");
  369     assert(isReg() && "Wrong MachineOperand accessor");
  374     assert(isReg() && "Wrong MachineOperand accessor");
  379     assert(isReg() && "Wrong MachineOperand accessor");
  384     assert(isReg() && "Wrong MachineOperand accessor");
  389     assert(isReg() && "Wrong MachineOperand accessor");
  425     assert(isReg() && "Wrong MachineOperand accessor");
  430     assert(isReg() && "Wrong MachineOperand accessor");
  435     assert(isReg() && "Wrong MachineOperand accessor");
  440     assert(isReg() && "Wrong MachineOperand accessor");
  452     assert(isReg() && "Wrong MachineOperand accessor");
  465     assert(isReg() && "Wrong MachineOperand mutator");
  467     assert(SubReg_TargetFlags == subReg && "SubReg out of range");
  489     assert(isReg() && "Wrong MachineOperand mutator");
  494     assert(isReg() && !IsDef && "Wrong MachineOperand mutator");
  495     assert((!Val || !isDebug()) && "Marking a debug operation as kill");
  500     assert(isReg() && IsDef && "Wrong MachineOperand mutator");
  505     assert(isReg() && "Wrong MachineOperand mutator");
  512     assert(isReg() && "Wrong MachineOperand mutator");
  517     assert(isReg() && IsDef && "Wrong MachineOperand mutator");
  522     assert(isReg() && !IsDef && "Wrong MachineOperand mutator");
  531     assert(isImm() && "Wrong MachineOperand accessor");
  536     assert(isCImm() && "Wrong MachineOperand accessor");
  541     assert(isFPImm() && "Wrong MachineOperand accessor");
  546     assert(isMBB() && "Wrong MachineOperand accessor");
  551     assert((isFI() || isCPI() || isTargetIndex() || isJTI()) &&
  557     assert(isGlobal() && "Wrong MachineOperand accessor");
  562     assert(isBlockAddress() && "Wrong MachineOperand accessor");
  567     assert(isMCSymbol() && "Wrong MachineOperand accessor");
  572     assert(isCFIIndex() && "Wrong MachineOperand accessor");
  577     assert(isIntrinsicID() && "Wrong MachineOperand accessor");
  582     assert(isPredicate() && "Wrong MachineOperand accessor");
  587     assert(isShuffleMask() && "Wrong MachineOperand accessor");
  594     assert((isGlobal() || isSymbol() || isMCSymbol() || isCPI() ||
  602     assert(isSymbol() && "Wrong MachineOperand accessor");
  612     assert(PhysReg < (1u << 30) && "Not a physical register");
  624     assert(isRegMask() && "Wrong MachineOperand accessor");
  635     assert(isRegLiveOut() && "Wrong MachineOperand accessor");
  640     assert(isMetadata() && "Wrong MachineOperand accessor");
  649     assert(isImm() && "Wrong MachineOperand mutator");
  654     assert(isCImm() && "Wrong MachineOperand mutator");
  659     assert(isFPImm() && "Wrong MachineOperand mutator");
  664     assert((isGlobal() || isSymbol() || isMCSymbol() || isCPI() ||
  672     assert((isFI() || isCPI() || isTargetIndex() || isJTI()) &&
  678     assert(isMetadata() && "Wrong MachineOperand mutator");
  683     assert(isMBB() && "Wrong MachineOperand mutator");
  692     assert(isRegMask() && "Wrong MachineOperand mutator");
  697     assert(isPredicate() && "Wrong MachineOperand mutator");
  781     assert(!(isDead && !isDef) && "Dead flag on non-def");
  782     assert(!(isKill && isDef) && "Kill flag on def");
  870     assert(Mask && "Missing register mask");
  876     assert(Mask && "Missing live-out register mask");
  944     assert(isReg() && "Can only add reg operand to use lists");
include/llvm/CodeGen/MachineOptimizationRemarkEmitter.h
  219     assert(ORE && "pass not run yet");
include/llvm/CodeGen/MachineOutliner.h
  139     assert(MBB->getParent()->getRegInfo().tracksLiveness() &&
include/llvm/CodeGen/MachinePipeliner.h
  564     assert(it != InstrToCycle.end() && "Instruction hasn't been scheduled.");
include/llvm/CodeGen/MachineRegionInfo.h
  114   assert(!isSubRegion() && "This is not a MachineBasicBlock RegionNode!");
  123   assert(isSubRegion() && "This is not a subregion RegionNode!");
include/llvm/CodeGen/MachineRegisterInfo.h
  124     assert(MO && MO->isReg() && "This is not a register operand!");
  161     assert(TheDelegate == delegate &&
  167     assert(delegate && !TheDelegate &&
  218     assert(VReg.isVirtual() && "Must pass a VReg");
  433     assert((Name.empty() || VRegNames.find(Name) == VRegNames.end()) &&
  632     assert(VRegInfo[Reg.id()].first.is<const TargetRegisterClass *>() &&
  763     assert(Register::isVirtualRegister(VReg));
  772     assert(Register::isVirtualRegister(VReg));
  783     assert (RegAllocHints[VReg].first == 0 &&
  793     assert(VReg.isVirtual());
  803     assert(VReg.isVirtual());
  812     assert(Register::isVirtualRegister(VReg));
  826       assert(MI->isDebugInstr());
  827       assert(MI->getOperand(0).isReg());
  887     assert(reservedRegsFrozen() &&
  988       assert(Op && "Cannot increment end iterator!");
  997             assert(!Op->isDebug() && "Can't have debug defs");
 1027       assert(Op && "Cannot increment end iterator!");
 1052       assert(Op && "Cannot dereference end iterator!");
 1058       assert(Op && "Cannot dereference end iterator!");
 1063       assert(Op && "Cannot dereference end iterator!");
 1094       assert(Op && "Cannot increment end iterator!");
 1103             assert(!Op->isDebug() && "Can't have debug defs");
 1133       assert(Op && "Cannot increment end iterator!");
 1157       assert(Op && "Cannot dereference end iterator!");
 1199     assert(isValid() && "Invalid PSetIterator.");
include/llvm/CodeGen/MachineScheduler.h
  871       assert(Best.Reason != NoCand && "uninitialized Sched candidate");
include/llvm/CodeGen/PBQP/Graph.h
  112         assert(ThisEdgeAdjIdxs[NIdx] == NodeEntry::getInvalidAdjEdgeIdx() &&
  127           assert(NId == NIds[1] && "Edge not connected to NId");
  133         assert(ThisEdgeAdjIdxs[NIdx] != NodeEntry::getInvalidAdjEdgeIdx() &&
  144           assert(NId == NIds[1] && "Edge does not connect NId");
  181       assert(NId < Nodes.size() && "Out of bound NodeId");
  185       assert(NId < Nodes.size() && "Out of bound NodeId");
  206       assert(findEdge(E.getN1Id(), E.getN2Id()) == invalidEdgeId() &&
  357       assert(!Solver && "Solver already set. Call unsetSolver().");
  367       assert(Solver && "Solver not set.");
  410       assert(getNodeCosts(N1Id).getLength() == Costs.getRows() &&
  436       assert(getNodeCosts(N1Id).getLength() == Costs->getRows() &&
include/llvm/CodeGen/PBQP/Math.h
   53     assert(Length != 0 && Data && "Invalid vector");
   61     assert(Length != 0 && Data && "Invalid vector");
   67     assert(Length != 0 && Data && "Invalid vector");
   68     assert(Index < Length && "Vector element access out of bounds.");
   74     assert(Length != 0 && Data && "Invalid vector");
   75     assert(Index < Length && "Vector element access out of bounds.");
   81     assert(Length != 0 && Data && "Invalid vector");
   82     assert(Length == V.Length && "Vector length mismatch.");
   90     assert(Length != 0 && Data && "Invalid vector");
  110   assert((V.getLength() != 0) && "Zero-length vector badness.");
  154     assert(Rows != 0 && Cols != 0 && Data && "Invalid matrix");
  162     assert(Rows != 0 && Cols != 0 && Data && "Invalid matrix");
  168     assert(Rows != 0 && Cols != 0 && Data && "Invalid matrix");
  174     assert(Rows != 0 && Cols != 0 && Data && "Invalid matrix");
  175     assert(R < Rows && "Row out of bounds.");
  181     assert(Rows != 0 && Cols != 0 && Data && "Invalid matrix");
  182     assert(R < Rows && "Row out of bounds.");
  188     assert(Rows != 0 && Cols != 0 && Data && "Invalid matrix");
  197     assert(Rows != 0 && Cols != 0 && Data && "Invalid matrix");
  206     assert(Rows != 0 && Cols != 0 && Data && "Invalid matrix");
  216     assert(Rows != 0 && Cols != 0 && Data && "Invalid matrix");
  217     assert(Rows == M.Rows && Cols == M.Cols &&
  225     assert(Rows != 0 && Cols != 0 && Data && "Invalid matrix");
  248   assert((M.getRows() != 0) && "Zero-row matrix badness.");
include/llvm/CodeGen/PBQP/ReductionRules.h
   37     assert(G.getNodeDegree(NId) == 1 &&
   81     assert(G.getNodeDegree(NId) == 2 &&
  198         assert(hasRegisterOptions(v) && "A conservatively allocatable node "
include/llvm/CodeGen/PBQP/Solution.h
   47       assert(sItr != selections.end() && "No selection for node.");
include/llvm/CodeGen/RegAllocPBQP.h
  215     assert(RS >= this->RS && "A node's reduction state can not be downgraded");
  299     assert(G.getNodeCosts(NId).getLength() > 1 &&
  366       assert(OptimallyReducibleNodes.find(NId) !=
  372       assert(ConservativelyAllocatableNodes.find(NId) !=
  378       assert(NotProvablyAllocatableNodes.find(NId) !=
  426     assert(!G.empty() && "Cannot reduce empty graph.");
include/llvm/CodeGen/Register.h
   51     assert(isStackSlot(Reg) && "Not a stack slot");
   57     assert(FI >= 0 && "Cannot hold a negative frame index.");
   70     assert(!isStackSlot(Reg) && "Not a register! Check isStackSlot() first.");
   77     assert(isVirtualRegister(Reg) && "Not a virtual register");
include/llvm/CodeGen/RegisterClassInfo.h
  113     assert(Register::isPhysicalRegister(PhysReg));
include/llvm/CodeGen/RegisterPressure.h
  110     assert(id < std::numeric_limits<uint16_t>::max() && "PSetID overflow.");
  116     assert(isValid() && "invalid PressureChange");
  212     assert(Idx < Size && "PressureDiff index out of bounds");
  281     assert(Reg < NumRegUnits);
  510     assert(isBottomClosed() && "Uninitialized pressure tracker");
  531     assert(isBottomClosed() && "Uninitialized pressure tracker");
include/llvm/CodeGen/ResourcePriorityQueue.h
   94       assert(NodeNum < (*SUnits).size());
   99       assert(NodeNum < NumNodesSolelyBlocking.size());
include/llvm/CodeGen/ScheduleDAG.h
  111         assert(Reg != 0 &&
  219       assert((getKind() == Data || getKind() == Anti || getKind() == Output) &&
  229       assert((getKind() == Data || getKind() == Anti || getKind() == Output) &&
  231       assert((getKind() != Anti || Reg != 0) &&
  233       assert((getKind() != Output || Reg != 0) &&
  349       assert(!Instr && "Setting SDNode of SUnit with MachineInstr!");
  356       assert(!Instr && "Reading SDNode of SUnit with MachineInstr!");
  367       assert(!Node && "Setting MachineInstr of SUnit with SDNode!");
  374       assert(!Node && "Reading MachineInstr of SUnit with SDNode!");
  521       assert(!HasReadyFilter && "The ready filter must override isReady()");
include/llvm/CodeGen/ScheduleDAGInstrs.h
  389     assert((Addr == nullptr || Addr == &SUnits[0]) &&
include/llvm/CodeGen/ScheduleDFS.h
  172     assert(SU->NodeNum < DFSNodeData.size() &&  "New Node");
include/llvm/CodeGen/ScoreboardHazardRecognizer.h
   61       assert(Depth && !(Depth & (Depth - 1)) &&
include/llvm/CodeGen/SelectionDAG.h
  299       assert(DAG.UpdateListeners == this &&
  484     assert((!N.getNode() || N.getValueType() == MVT::Other) &&
  770       assert((VT.getVectorElementType() == Op.getValueType() ||
  786       assert((VT.getVectorElementType() == Op.getValueType() ||
  979     assert(LHS.getValueType().isVector() == RHS.getValueType().isVector() &&
  981     assert(LHS.getValueType().isVector() == VT.isVector() &&
  983     assert(Cond != ISD::SETCC_INVALID &&
  992     assert(LHS.getValueType() == RHS.getValueType() &&
  994     assert(VT.isVector() == LHS.getValueType().isVector() &&
include/llvm/CodeGen/SelectionDAGNodes.h
  732     assert(isMachineOpcode() && "Not a MachineInstr opcode!");
  803       assert(Op && "Cannot increment end iterator!");
  814       assert(Op && "Cannot dereference end iterator!");
  824       assert(Op && "Cannot dereference end iterator!");
  952     assert(Num < NumOperands && "Invalid child # of SDNode!");
 1015     assert(ResNo < NumValues && "Illegal result number!");
 1109     assert(debugLoc.hasTrivialDestructor() && "Expected trivial destructor");
 1110     assert(NumValues == VTs.NumVTs &&
 1137     assert(Order >= 0 && "bad IROrder");
 1153   assert((!Node || !ResNo || ResNo < Node->getNumValues()) &&
 1155   assert(ResNo < -2U && "Cannot use result numbers reserved for DenseMaps.");
 1440     assert(((Opc != ISD::ATOMIC_LOAD && Opc != ISD::ATOMIC_STORE) ||
 1458     assert(isCompareAndSwap() && "Must be cmpxchg operation");
 1533     assert(Idx < getValueType(0).getVectorNumElements() && "Idx out of range!");
 1540     assert(isSplat() && "Cannot get splat index for non-splat!");
 1784     assert(hasOffset() && "offset is unknown");
 1788     assert(hasOffset() && "offset is unknown");
 1836     assert(Offset >= 0 && "Offset is too large");
 1845     assert(Offset >= 0 && "Offset is too large");
 1856     assert(!isMachineConstantPoolEntry() && "Wrong constantpool type");
 1861     assert(isMachineConstantPoolEntry() && "Wrong constantpool type");
 2113     assert(LabelSDNode::classof(this) && "not a label opcode");
 2206     assert(getAddressingMode() == AM && "Value truncated");
 2240     assert(readMem() && "Load MachineMemOperand is not a load!");
 2241     assert(!writeMem() && "Load MachineMemOperand is a store!");
 2268     assert(!readMem() && "Store MachineMemOperand is a load!");
 2269     assert(writeMem() && "Store MachineMemOperand is not a store!");
 2389     assert(getIndexType() == IndexType && "Value truncated");
 2548     assert(Node == Other.Node &&
include/llvm/CodeGen/SlotIndexes.h
  116       assert(isValid() && "Attempt to compare reserved index.");
  145       assert(lie.getPointer() != nullptr &&
  374       assert(indexList.front().getIndex() == 0 && "First index is not 0?");
  397       assert(!BundleNonDebug.isDebugInstr() &&
  400       assert(itr != mi2iMap.end() && "Instruction not found in maps.");
  427       assert(MBB && "MI must be inserted in a basic block");
  444       assert(MBB && "MI must be inserted in a basic block");
  527       assert(J != MBBIndexEnd() && J->first <= index &&
  539       assert(!MI.isInsideBundle() &&
  541       assert(mi2iMap.find(&MI) == mi2iMap.end() && "Instr already indexed.");
  544       assert(!MI.isDebugInstr() && "Cannot number debug instructions.");
  546       assert(MI.getParent() != nullptr && "Instr must be added to function.");
  597       assert(miEntry->getInstr() == &MI &&
  627       assert(prevMBB != mbb->getParent()->end() &&
  632       assert(unsigned(mbb->getNumber()) == MBBRanges.size() &&
include/llvm/CodeGen/StackMaps.h
   86     assert(Pos < MetaEnd && "Meta operand index out of range.");
include/llvm/CodeGen/TargetCallingConv.h
  134       assert(getByValAlign() == A.value() && "bitfield overflow");
  143       assert(getOrigAlign() == A.value() && "bitfield overflow");
  186       assert(OrigArgIndex != NoArgIndex && "Implicit machine-level argument");
include/llvm/CodeGen/TargetInstrInfo.h
  189     assert(isFrameInstr(I) && "Not a frame instruction");
  190     assert(I.getOperand(0).getImm() >= 0);
  199       assert(I.getOperand(1).getImm() >= 0 &&
  879     assert(MI.getDesc().isSelect() && "MI must be a select instruction");
 1624     assert((MIa.mayLoad() || MIa.mayStore()) &&
 1626     assert((MIb.mayLoad() || MIb.mayStore()) &&
include/llvm/CodeGen/TargetLowering.h
  700     assert(RC && "This value type is not natively supported!");
  741     assert(!VT.isSimple() ||
  796     assert(!VT.isVector());
 1100     assert(ExtType < ISD::LAST_LOADEXT_TYPE && ValI < MVT::LAST_VALUETYPE &&
 1125     assert(ValI < MVT::LAST_VALUETYPE && MemI < MVT::LAST_VALUETYPE &&
 1149     assert(IdxMode < ISD::LAST_INDEXED_MODE && VT.isValid() &&
 1167     assert(IdxMode < ISD::LAST_INDEXED_MODE && VT.isValid() &&
 1185     assert((unsigned)CC < array_lengthof(CondCodeActions) &&
 1192     assert(Action != Promote && "Can't promote condition code!");
 1211     assert(getOperationAction(Op, VT) == Promote &&
 1220     assert((VT.isInteger() || VT.isFloatingPoint()) &&
 1226       assert(NVT.isInteger() == VT.isInteger() && NVT != MVT::isVoid &&
 1289     assert((unsigned)VT.SimpleTy < array_lengthof(RegisterTypeForVT));
 1296       assert((unsigned)VT.getSimpleVT().SimpleTy <
 1324       assert((unsigned)VT.getSimpleVT().SimpleTy <
 1393     assert(unsigned(NT >> 3) < array_lengthof(TargetDAGCombineArray));
 2020     assert((unsigned)VT.SimpleTy < array_lengthof(RegClassForVT));
 2038     assert(Op < array_lengthof(OpActions[0]) && "Table isn't big enough!");
 2046     assert(ExtType < ISD::LAST_LOADEXT_TYPE && ValVT.isValid() &&
 2048     assert((unsigned)Action < 0x10 && "too many bits for bitfield array");
 2058     assert(ValVT.isValid() && MemVT.isValid() && "Table isn't big enough!");
 2069     assert(VT.isValid() && IdxMode < ISD::LAST_INDEXED_MODE &&
 2083     assert(VT.isValid() && IdxMode < ISD::LAST_INDEXED_MODE &&
 2094     assert(VT.isValid() && (unsigned)CC < array_lengthof(CondCodeActions) &&
 2096     assert((unsigned)Action < 0x10 && "too many bits for bitfield array");
 2124     assert(unsigned(NT >> 3) < array_lengthof(TargetDAGCombineArray));
 2390       assert(isa<SExtInst>(Ext) && "Unexpected ext type!");
 2500     assert(SrcVT.isFloatingPoint() && DestVT.isFloatingPoint() &&
 2509     assert(DestVT.isFloatingPoint() && SrcVT.isFloatingPoint() &&
 2521     assert(VT.isFloatingPoint());
 2528     assert(VT.isFloatingPoint());
 3764     assert(SI.isAtomic() && "violated precondition");
 3773     assert(LI.isAtomic() && "violated precondition");
include/llvm/CodeGen/TargetPassConfig.h
   68     assert(!IsInstance && "Not a Pass ID");
   73     assert(IsInstance && "Not a Pass Instance");
include/llvm/CodeGen/TargetRegisterInfo.h
  339     assert(SubIdx && SubIdx < getNumSubRegIndices() &&
  349     assert(SubIdx < getNumSubRegIndices() && "This is not a subregister index");
  553     assert(Idx == 0 && "Target has no sub-registers");
  672     assert(i < getNumRegClasses() && "Register Class ID out of range");
 1031     assert(isValid() && "Cannot move iterator past end.");
 1098     assert(NumBits < 32 && "Undefined behavior spotted!");
 1124     assert(isValid() && "Cannot move iterator past end.");
include/llvm/CodeGen/ValueTypes.h
   78       assert(!IsScalable && "We don't support extended scalable types yet");
   88       assert (!EC.Scalable && "We don't support extended scalable types yet");
   97         assert (!isScalableVector() &&
  106       assert(VecTy.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE &&
  253       assert(isSimple() && "Expected a SimpleValueType!");
  265       assert(isVector() && "Invalid vector type!");
  273       assert(isVector() && "Invalid vector type!");
  281       assert((isVector()) && "Invalid vector type!");
  285       assert(!isScalableVector() &&
  317       assert(isInteger() && !isVector() && "Invalid integer type!");
  328       assert(isInteger() && !isVector() && "Invalid integer type!");
  353       assert(!(EltCnt.Min & 1) && "Splitting vector, but not in half!");
include/llvm/CodeGen/VirtRegMap.h
   85       assert(MF && "getMachineFunction called before runOnMachineFunction");
  103       assert(virtReg.isVirtual());
  114       assert(virtReg.isVirtual());
  115       assert(Virt2PhysMap[virtReg.id()] != NO_PHYS_REG &&
  167       assert(virtReg.isVirtual());
include/llvm/DebugInfo/CodeView/CodeViewRecordIO.h
  250       assert(CurrentOffset >= BeginOffset);
include/llvm/DebugInfo/CodeView/GlobalTypeTableBuilder.h
   88         assert(Result.first->second.getIndex() ==
include/llvm/DebugInfo/CodeView/SymbolDeserializer.h
   64     assert(!Mapping && "Already in a symbol mapping!");
   69     assert(Mapping && "Not in a symbol mapping!");
include/llvm/DebugInfo/CodeView/TypeDeserializer.h
   68     assert(!Mapping && "Already in a type mapping!");
   78     assert(Mapping && "Not in a type mapping!");
  156     assert(Mapping.Reader.getOffset() == EndOffset);
include/llvm/DebugInfo/CodeView/TypeHashing.h
   82     assert(H.size() == 8);
include/llvm/DebugInfo/CodeView/TypeIndex.h
  118     assert(!isSimple());
  127     assert(isSimple());
  132     assert(isSimple());
  205     assert(Index >= N);
  252     assert(A.getIndex() >= N);
  259     assert(A >= B);
include/llvm/DebugInfo/CodeView/TypeRecord.h
  586     assert(GuidStr.size() == 16 && "guid isn't 16 bytes");
include/llvm/DebugInfo/DIContext.h
   88     assert(Index < Frames.size());
   93     assert(Index < Frames.size());
include/llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h
   32       assert(isImplicitConst());
   36       assert(!isImplicitConst());
   74       assert(isImplicitConst());
  101     assert(idx < AttributeSpecs.size());
  110     assert(idx < AttributeSpecs.size());
include/llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h
  536       assert(CurrentName <= CurrentIndex->getNameCount());
include/llvm/DebugInfo/DWARF/DWARFAddressRange.h
   38     assert(valid() && RHS.valid());
include/llvm/DebugInfo/DWARF/DWARFDebugRangeList.h
   53       assert(AddressSize == 4 || AddressSize == 8);
include/llvm/DebugInfo/DWARF/DWARFDie.h
   59     assert(isValid() && "must check validity prior to calling");
   67     assert(isValid() && "must check validity prior to calling");
   79     assert(isValid() && "must check validity prior to calling");
  412     assert(!AtEnd && "Incrementing rend");
  427     assert(!Die.isNULL() && "Decrementing rbegin");
  432     assert(Die.isValid());
include/llvm/DebugInfo/DWARF/DWARFExpression.h
  132     assert(AddressSize == 8 || AddressSize == 4 || AddressSize == 2);
include/llvm/DebugInfo/DWARF/DWARFListTable.h
  210   assert(*OffsetPtr == End &&
include/llvm/DebugInfo/DWARF/DWARFUnit.h
   89     assert((!DWOId || *DWOId == Id) && "setting DWOId to a different value");
  241     assert(Die >= First && Die < First + DieArray.size());
  336     assert(StringOffsetsTableContribution);
  341     assert(StringOffsetsTableContribution);
  460     assert(Index < DieArray.size());
  476     assert(!DieArray.empty());
include/llvm/DebugInfo/GSYM/LineTable.h
  162     assert(i < Lines.size());
  166     assert(i < Lines.size());
include/llvm/DebugInfo/GSYM/Range.h
   90     assert(i < Ranges.size());
include/llvm/DebugInfo/MSF/MSFCommon.h
   55     assert(SB->FreeBlockMapBlock == 1 || SB->FreeBlockMapBlock == 2);
  134   assert(FpmNumber == 1 || FpmNumber == 2);
include/llvm/DebugInfo/PDB/Native/HashTable.h
   72     assert(Map->Present.test(Index));
  246     assert(FirstUnused);
  260     assert(Iter != end());
  280       assert(isPresent(Entry.index()));
  281       assert(Traits.storageKeyToLookupKey(Buckets[Entry.index()].first) == K);
  288     assert(!isPresent(Entry.index()));
  289     assert(Entry.isEnd());
  297     assert((find_as(K, Traits)) != end());
  309     assert(capacity() != UINT32_MAX && "Can't grow Hash table!");
  326     assert(capacity() == NewCapacity);
  327     assert(size() == S);
include/llvm/Demangle/ItaniumDemangle.h
  619       assert(FirstChar == SecondChar);
  635     assert(isString());
  641     assert(isNode());
 2196   assert(0 && "unknown mangling node kind");
 2300     assert(Last != First && "Popping empty vector!");
 2305     assert(Index <= size() && "dropBack() can't expand!");
 2315     assert(Last != First && "Calling back() on empty vector!");
 2319     assert(Index < size() && "Invalid access!");
 2358       assert(Parser->TemplateParams.size() >= OldNumTemplateParamLists);
 2419     assert(FromPosition <= Names.size());
 3408   assert(SoFar != nullptr);
 5366     assert(ForwardRef->getKind() == Node::KForwardTemplateReference);
include/llvm/Demangle/MicrosoftDemangle.h
   50       assert(Head->Buf);
   59     assert(Head && Head->Buf);
   74     assert(Head && Head->Buf);
   93     assert(Head && Head->Buf);
include/llvm/Demangle/StringView.h
   75     assert(!empty());
   80     assert(!empty());
   85     assert(!empty());
include/llvm/ExecutionEngine/JITLink/JITLink.h
   79     assert(isRelocation() && "Not a relocation edge");
  109     assert(!(IsDefined && IsAbsolute) &&
  146     assert(isPowerOf2_64(Alignment) && "Alignment must be power of 2");
  147     assert(AlignmentOffset < Alignment &&
  149     assert(AlignmentOffset <= MaxAlignmentOffset &&
  160     assert(isPowerOf2_64(Alignment) && "Alignment must be power of 2");
  161     assert(AlignmentOffset < Alignment &&
  163     assert(AlignmentOffset <= MaxAlignmentOffset &&
  196     assert(Data && "Section does not contain content");
  298     assert(SymStorage && "Storage cannot be null");
  299     assert(!Name.empty() && "Common symbol name cannot be empty");
  300     assert(Base.isDefined() &&
  302     assert(static_cast<Block &>(Base).getSize() == Size &&
  311     assert(SymStorage && "Storage cannot be null");
  312     assert(!Base.isDefined() &&
  314     assert(!Name.empty() && "External symbol name cannot be empty");
  324     assert(SymStorage && "Storage cannot be null");
  325     assert(!Base.isDefined() &&
  336     assert(SymStorage && "Storage cannot be null");
  347     assert(SymStorage && "Storage cannot be null");
  348     assert(!Name.empty() && "Name cannot be empty");
  371     assert((!Name.empty() || getScope() == Scope::Local) &&
  379     assert(Base && "Attempt to access null symbol");
  386     assert(Base && "Attempting to access null symbol");
  401     assert(Base && "Attempt to access null symbol");
  407     assert(Base && "Attempt to access null symbol");
  413     assert(Base && "Cannot get underlying addressable for null symbol");
  419     assert(Base && "Cannot get underlying addressable for null symbol");
  425     assert(Base && "Cannot get block for null symbol");
  426     assert(Base->isDefined() && "Not a defined symbol");
  432     assert(Base && "Cannot get block for null symbol");
  433     assert(Base->isDefined() && "Not a defined symbol");
  461     assert((L == Linkage::Strong || (Base->isDefined() && !Name.empty())) &&
  471     assert((S == Scope::Default || Base->isDefined() || Base->isAbsolute()) &&
  478     assert(!A.isDefined() && "Attempting to make external with defined block");
  556     assert(!Symbols.count(&Sym) && "Symbol is already in this section");
  561     assert(Symbols.count(&Sym) && "symbol is not in this section");
  589     assert((!Last || First) && "First can not be null if end is non-null");
  593     assert((First || !Last) && "Last can not be null if start is non-null");
  597     assert((First || !Last) && "Last can not be null if start is non-null");
  678       assert(SymI != SecI->symbols().end() && "Dereferencing end?");
  840       assert(AbsoluteSymbols.count(&Sym) &&
  844       assert(Sym.isDefined() && "Sym is not a defined symbol");
  854     assert(!Sym.isDefined() && !Sym.isAbsolute() &&
  856     assert(ExternalSymbols.count(&Sym) && "Symbol is not in the externals set");
  865     assert(!Sym.isDefined() && Sym.isAbsolute() &&
  867     assert(AbsoluteSymbols.count(&Sym) &&
  877     assert(Sym.isDefined() && "Sym is not a defined symbol");
include/llvm/ExecutionEngine/JITLink/JITLinkMemoryManager.h
   40       assert(isPowerOf2_32(Alignment) && "Alignment must be power of 2");
include/llvm/ExecutionEngine/JITSymbol.h
   47   assert(IntPtr == Addr && "JITTargetAddress value out of range for uintptr_t");
  296     assert(!Flags.hasError() && "getAddress called on error value");
  301         assert(CachedAddr && "Symbol could not be materialized.");
include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h
  307     assert(!LogicalDylibs.count(K) && "VModuleKey K already in use");
  327     assert(I != LogicalDylibs.end() && "VModuleKey K not valid here");
  353     assert(LogicalDylibs.count(K) && "VModuleKey K is not valid here");
  507       assert(NewA && "Alias not cloned?");
include/llvm/ExecutionEngine/Orc/Core.h
  681       assert(static_cast<uint8_t>(State) < (1 << 6) &&
  960   assert(MU && "Can not define with a null MU");
  976   assert(MU && "Can not define with a null MU");
include/llvm/ExecutionEngine/Orc/IndirectionUtils.h
   95     assert(!AvailableTrampolines.empty() && "Failed to grow trampoline pool");
  144     assert(this->AvailableTrampolines.empty() && "Growing prematurely?");
  325     assert(StubAddr && "Missing stub address");
  341     assert(PtrAddr && "Missing pointer address");
  352     assert(I != StubIndexes.end() && "No stub pointer for symbol");
include/llvm/ExecutionEngine/Orc/LazyEmittingLayer.h
  168       assert(!MangledSymbols && "Mangled symbols map already exists?");
  206     assert(!ModuleMap.count(K) && "VModuleKey K already in use");
  248     assert(ModuleMap.count(K) && "VModuleKey K not valid here");
include/llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h
  292         assert(!Allocs.empty() && "No sections in allocated segment");
  386       assert(I != StubIndexes.end() && "No stub pointer for symbol");
  432       assert(RemoteIndirectStubsInfos[K.first].StubBase != 0 &&
  439       assert(RemoteIndirectStubsInfos[K.first].PtrBase != 0 &&
  462       assert(!AvailableTrampolines.empty() && "Failed to grow trampoline pool");
  561     assert(!CallbackManager && "CallbackManager already obtained");
include/llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h
  156     assert(NextId + 1 != ~0ULL && "All ids allocated");
include/llvm/ExecutionEngine/Orc/OrcRemoteTargetServer.h
  129       assert(Allocs.find(MB.base()) == Allocs.end() && "Duplicate alloc");
  153     assert(AddrOrErr && "Compile request failed");
include/llvm/ExecutionEngine/Orc/RPCSerialization.h
  342     assert(!Name.empty() &&
  360       assert(KeyName != nullptr && "No keyname pointer");
  365         assert(EIB.dynamicClassID() == ErrorInfoT::classID() &&
  403     assert(DI != Deserializers.end() && "No deserializer for error type");
  597     assert(V.empty() &&
  630     assert(S.empty() && "Expected default-constructed set to deserialize into");
  673     assert(M.empty() && "Expected default-constructed map to deserialize into");
include/llvm/ExecutionEngine/Orc/RPCUtils.h
 1037       assert(!PendingResponses.count(SeqNo) &&
 1137     assert(IdItr != LocalFunctionIds.end() &&
 1140     assert(HandlerItr != Handlers.end() &&
 1208     assert(PRHandler &&
include/llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h
  233       assert(PFC && "mapSectionAddress called on finalized LinkedObject");
  284       assert(PFC && "mapSectionAddress called on finalized LinkedObject");
  285       assert(PFC->RTDyld && "mapSectionAddress called on raw LinkedObject");
  396     assert(!LinkedObjects.count(K) && "VModuleKey already in use");
  416     assert(LinkedObjects.count(K) && "VModuleKey not associated with object");
  445     assert(LinkedObjects.count(K) && "VModuleKey not associated with object");
  453     assert(LinkedObjects.count(K) && "VModuleKey not associated with object");
  461     assert(LinkedObjects.count(K) && "VModuleKey not associated with object");
include/llvm/ExecutionEngine/Orc/RemoteObjectLayer.h
  199       assert(!InUseSymbols.count(Id) && "Symbol id already in use");
  338       assert(!Resolvers.count(Handle) && "Handle already in use?");
  472     assert(!BaseLayerHandles.count(Id) && "Id already in use?");
include/llvm/ExecutionEngine/Orc/Speculation.h
  186     assert(!IRNames.empty() && "No IRNames received to Intern?");
include/llvm/ExecutionEngine/Orc/SymbolStringPool.h
  146   assert(Pool.empty() && "Dangling references at pool destruction time");
include/llvm/ExecutionEngine/Orc/ThreadSafeModule.h
   55     assert(S->Ctx != nullptr &&
   68     assert(S && "Can not lock an empty ThreadSafeContext");
  124       assert(TSCtx.getContext() &&
  135     assert(M && "Can not call on null module");
include/llvm/ExecutionEngine/RuntimeDyld.h
  246     assert(!Dyld && "setProcessAllSections must be called before loadObject.");
include/llvm/ExecutionEngine/RuntimeDyldChecker.h
   91       assert(Size && "setContent/setZeroFill must be called first");
   97       assert(!ContentPtr && !Size && "Content/zero-fill already set");
  104       assert(!ContentPtr && !this->Size && "Content/zero-fill already set");
  110       assert(!isZeroFill() && "Can't get content for a zero-fill section");
  116       assert(isZeroFill() && "Can't get zero-fill length for content section");
  122       assert(!this->TargetAddress && "TargetAddress already set");
include/llvm/FuzzMutate/OpDescriptor.h
  196     assert(!Cur.empty() && "No first source yet");
  200     assert(!Cur.empty() && "No first source yet");
  209     assert(!Cur.empty() && "No first source yet");
  213     assert(!Cur.empty() && "No first source yet");
include/llvm/FuzzMutate/Random.h
   45     assert(!isEmpty() && "Nothing selected");
include/llvm/IR/Argument.h
   48     assert(Parent && "can't get number of unparented arg");
include/llvm/IR/Attributes.h
  758     assert((unsigned)A < Attribute::EndAttrKinds && "Attribute out of range!");
include/llvm/IR/BasicBlock.h
  317       assert(PN && "Cannot increment the end iterator!");
  439     assert((int)(signed char)getSubclassDataFromValue() >= 0 &&
include/llvm/IR/CFG.h
   74     assert(!It.atEnd() && "pred_iterator out of range!");
   80     assert(!It.atEnd() && "pred_iterator out of range!");
  212     assert(Inst == RHS.Inst && "Cannot compare iterators of different blocks!");
  218     assert(index_is_valid(NewIdx) && "Iterator index out of bound");
include/llvm/IR/CallSite.h
   63   CallSiteBase(CallTy *CI) : I(CI, 1) { assert(CI); }
   64   CallSiteBase(InvokeTy *II) : I(II, 0) { assert(II); }
   65   CallSiteBase(CallBrTy *CBI) : I(CBI, 2) { assert(CBI); }
  105     assert(getInstruction() && "Not a call, invoke or callbr instruction!");
  131     assert(getInstruction() && "Not a call, callbr, or invoke instruction!");
  132     assert(cast<PointerType>(V->getType())->getElementType() ==
  164     assert(getInstruction() == U->getUser());
  175     assert(getInstruction() == U->getUser());
  194     assert(arg_begin() + ArgNo < arg_end() && "Argument # out of range!");
  199     assert(getInstruction() && "Not a call, invoke or callbr instruction!");
  200     assert(arg_begin() + ArgNo < arg_end() && "Argument # out of range!");
  213     assert(getInstruction() && "Not a call, invoke or callbr instruction!");
  214     assert(isArgOperand(U) && "Argument # out of range!");
  237     assert(getInstruction() && "Not a call, invoke or callbr instruction!");
  238     assert(isDataOperand(U) && "Data operand # out of range!");
  254     assert(getInstruction() && "Not a call or invoke instruction!");
  258     assert(getInstruction() && "Not a call or invoke instruction!");
  804     assert(!CI.ParameterEncoding.empty() &&
  852     assert(isCallbackCall());
  853     assert(CI.ParameterEncoding.size() && CI.ParameterEncoding[0] > 0);
  861     assert(CalleeArgIdx >= 0 &&
include/llvm/IR/Constants.h
  656     assert(isString() && "Not a string");
  663     assert(isCString() && "Isn't a C string");
include/llvm/IR/DataLayout.h
  269     assert(StackNaturalAlign && "StackNaturalAlign must be defined");
  608     assert(Idx < NumElements && "Invalid element idx!");
  625   assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
include/llvm/IR/DebugInfoMetadata.h
  126     assert(Tag < 1u << 16);
  611     assert(isDistinct() && "Only distinct nodes can mutate");
  844     assert(getTag() == dwarf::DW_TAG_ptr_to_member_type);
  853     assert(getTag() == dwarf::DW_TAG_inheritance);
  861     assert(getTag() == dwarf::DW_TAG_member && isBitField());
  868     assert(getTag() == dwarf::DW_TAG_member && isStaticMember());
  874     assert(getTag() == dwarf::DW_TAG_member && !isStaticMember());
  909     assert(isDistinct() && "Only distinct nodes can mutate");
  910     assert(getRawIdentifier() && "Only ODR-uniqued nodes should mutate");
 1038       assert(is_contained(Elements->operands(), Op) &&
 1162     assert(Storage != Uniqued);
 1869     assert(Column < (1u << 16) && "Expected 16-bit column");
 2329     assert(I < Elements.size() && "Index out of range");
 2760     assert(Arg < (1 << 16) && "DILocalVariable: Arg out of range");
 3104     assert(MIType < 1u << 16);
 3229       assert(is_contained(Elements->operands(), Op) &&
include/llvm/IR/DerivedTypes.h
  180     assert((FnTy == nullptr) == (Callee == nullptr));
  273     assert(elt1 && "Cannot create a struct type with no elements with this");
  292     assert(elt1 && "Cannot create a struct type with no elements with this");
  329     assert(elt1 && "Cannot create a struct type with no elements with this");
  352     assert(N < NumContainedTys && "Element number out of range!");
  470     assert(EltBits && "Element size must be of a non-zero size");
  478     assert(VTy->isIntOrIntVectorTy() && "VTy expected to be a vector of ints.");
  501       assert((EltBits & 1) == 0 &&
  523     assert ((EltCnt.Min & 1) == 0 &&
  532     assert((VTy->getNumElements() * 2ull) <= UINT_MAX &&
  544     assert(MinimumEltCnt <= UINT_MAX && "Too many elements in vector");
  616   assert(
  626   assert(
include/llvm/IR/Function.h
  218     assert(!(ID & ~CallingConv::MaxID) && "Unsupported calling convention");
  719     assert (i < NumArgs && "getArg() out of range!");
include/llvm/IR/GetElementPtrTypeIterator.h
  120       assert(isBoundedSequential());
include/llvm/IR/GlobalObject.h
   94     assert(getGlobalObjectSubClassData() == Val && "representation error");
include/llvm/IR/GlobalValue.h
  168     assert(V < (1 << GlobalValueSubClassDataBits) && "It will not fit");
  243     assert((!hasLocalLinkage() || V == DefaultVisibility) &&
  255     assert(Val == NotThreadLocal || getValueID() != Value::FunctionVal);
include/llvm/IR/GlobalVariable.h
   79     assert(ptr != nullptr && "must not be nullptr");
  137     assert(hasInitializer() && "GV doesn't have initializer!");
  141     assert(hasInitializer() && "GV doesn't have initializer!");
include/llvm/IR/IRBuilder.h
  142     assert(InsertPt != BB->end() && "Can't read debug loc from end()");
  259     assert(BB && "Must have a basic block to set any function attributes!");
 1110     assert(RoundingStr.hasValue() && "Garbage strict rounding mode!");
 1126     assert(ExceptStr.hasValue() && "Garbage strict exception behavior!");
 1302     assert(!Ops.empty());
 1328     assert(!Ops.empty());
 1562       assert(Ops.size() == 2 && "Invalid number of operands!");
 1567       assert(Ops.size() == 1 && "Invalid number of operands!");
 1905     assert(V->getType()->isIntOrIntVectorTy() &&
 1920     assert(V->getType()->isIntOrIntVectorTy() &&
 2418     assert(LHS->getType() == RHS->getType() &&
 2433     assert(isa<PointerType>(Ptr->getType()) &&
 2444     assert(FnLaunderInvariantGroup->getReturnType() == Int8PtrTy &&
 2460     assert(isa<PointerType>(Ptr->getType()) &&
 2472     assert(FnStripInvariantGroup->getReturnType() == Int8PtrTy &&
 2487     assert(NumElts > 0 && "Cannot splat to an empty vector!");
 2526     assert(isa<PointerType>(Base->getType()) &&
 2555     assert(isa<PointerType>(Base->getType()) &&
 2574     assert(isa<PointerType>(Base->getType()) &&
 2643     assert(isa<PointerType>(PtrValue->getType()) &&
 2645     assert(Alignment != 0 && "Invalid Alignment");
 2670     assert(isa<PointerType>(PtrValue->getType()) &&
include/llvm/IR/InlineAsm.h
  270     assert(((NumOps << 3) & ~0xffff) == 0 && "Too many inline asm operands!");
  271     assert(Kind >= Kind_RegUse && Kind <= Kind_Mem && "Invalid Kind");
  290     assert(MatchedOperandNo <= 0x7fff && "Too big matched operand");
  291     assert((InputFlag & ~0xffff) == 0 && "High bits already contain data");
  303     assert(!isImmKind(InputFlag) && "Immediates cannot have a register class");
  304     assert(!isMemKind(InputFlag) && "Memory operand cannot have a register class");
  305     assert(RC <= 0x7fff && "Too large register class ID");
  306     assert((InputFlag & ~0xffff) == 0 && "High bits already contain data");
  313     assert(isMemKind(InputFlag) && "InputFlag is not a memory constraint!");
  314     assert(Constraint <= 0x7fff && "Too large a memory constraint ID");
  315     assert(Constraint <= Constraints_Max && "Unknown constraint ID");
  316     assert((InputFlag & ~0xffff) == 0 && "High bits already contain data");
  321     assert(isMemKind(InputFlag));
  330     assert(isMemKind(Flag));
include/llvm/IR/InstVisitor.h
  287     assert(CS);
include/llvm/IR/InstrTypes.h
 1189     assert(this == U->getUser() &&
 1206     assert(isDataOperand(U) && "Data operand # out of range!");
 1247     assert(i < getNumArgOperands() && "Out of bounds!");
 1252     assert(i < getNumArgOperands() && "Out of bounds!");
 1258     assert(i < getNumArgOperands() && "Out of bounds!");
 1262     assert(i < getNumArgOperands() && "Out of bounds!");
 1267     assert(this == U->getUser() &&
 1341     assert(FTy == cast<FunctionType>(
 1345     assert(getType() == FTy->getReturnType());
 1355     assert(!(ID & ~CallingConv::MaxID) && "Unsupported calling convention");
 1379     assert(Kind != Attribute::NoBuiltin &&
 1403     assert(ArgNo < getNumArgOperands() && "Out of bounds");
 1411     assert(ArgNo < getNumArgOperands() && "Out of bounds");
 1433     assert(ArgNo < getNumArgOperands() && "Out of bounds");
 1441     assert(ArgNo < getNumArgOperands() && "Out of bounds");
 1480     assert(ArgNo < getNumArgOperands() && "Out of bounds");
 1486     assert(ArgNo < getNumArgOperands() && "Out of bounds");
 1505     assert(i < (getNumArgOperands() + getNumTotalBundleOperands() + 1) &&
 1520     assert(hasOperandBundles() && i >= (getBundleOperandsStartIndex() + 1) &&
 1748     assert(hasOperandBundles() && "Don't call otherwise!");
 1754     assert(hasOperandBundles() && "Don't call otherwise!");
 1766     assert(this == U->getUser() &&
 1783     assert(Begin <= End && "Should be!");
 1789     assert(Index < getNumOperandBundles() && "Index out of bounds!");
 1820     assert(countOperandBundlesOfType(Name) < 2 && "Precondition violated!");
 1836     assert(countOperandBundlesOfType(ID) < 2 && "Precondition violated!");
 2171     assert(ParentPad);
include/llvm/IR/Instruction.h
  765     assert((D & HasMetadataBit) == 0 && "Out of range value put into field");
include/llvm/IR/Instructions.h
  596     assert(Ordering != AtomicOrdering::NotAtomic &&
  609     assert(Ordering != AtomicOrdering::NotAtomic &&
  803     assert(Ordering != AtomicOrdering::NotAtomic &&
  874   assert(Ty && "Invalid GetElementPtrInst indices for type!");
  916       assert(
  932       assert(
  984     assert(ResultElementType ==
 1123   assert(ResultElementType ==
 1137   assert(ResultElementType ==
 1154     assert(isIntPredicate() &&
 1156     assert(getOperand(0)->getType() == getOperand(1)->getType() &&
 1159     assert((getOperand(0)->getType()->isIntOrIntVectorTy() ||
 1296     assert(isFPPredicate() && "Invalid FCmp predicate value");
 1297     assert(getOperand(0)->getType() == getOperand(1)->getType() &&
 1300     assert(getOperand(0)->getType()->isFPOrFPVectorTy() &&
 1733     assert(!areInvalidOperands(C, S1, S2) && "Invalid operands for select");
 2070     assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.");
 2091     assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.");
 2128     assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.");
 2152     assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.");
 2172     assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.");
 2222     assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.");
 2244     assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.");
 2264       assert(Idx >= 0 && Idx < (int)InVecNumElts * 2 &&
 2648     assert(V && "PHI node got a null value!");
 2649     assert(getType() == V->getType() &&
 2672     assert(this == U.getUser() && "Iterator doesn't point to PHI's Uses?");
 2684     assert(BB && "PHI node got a null basic block!");
 2690     assert(New && Old && "PHI node got a null basic block!");
 2719     assert(Idx >= 0 && "Invalid basic block argument to remove!");
 2735     assert(Idx >= 0 && "Invalid basic block argument!");
 2741     assert(BB && "PHI node got a null basic block!");
 2749     assert(Found && "Invalid basic block argument to set!");
 3057     assert(isConditional() && "Cannot get condition of an uncond branch!");
 3062     assert(isConditional() && "Cannot set condition of unconditional branch!");
 3069     assert(i < getNumSuccessors() && "Successor # out of range for Branch!");
 3074     assert(idx < getNumSuccessors() && "Successor # out of range for Branch!");
 3186       assert((unsigned)Index < SI->getNumCases() &&
 3193       assert(((unsigned)Index < SI->getNumCases() ||
 3204       assert(((unsigned)Index == DefaultPseudoIndex ||
 3211       assert(SI == RHS.SI && "Incompatible operators.");
 3228       assert((unsigned)Index < SI->getNumCases() &&
 3261       assert(SuccessorIndex < SI->getNumSuccessors() &&
 3276       assert(Case.Index + N >= 0 &&
 3285       assert(Case.Index - N >= 0 &&
 3292       assert(Case.SI == RHS.Case.SI && "Incompatible operators.");
 3446     assert(idx < getNumSuccessors() &&"Successor idx out of range for switch!");
 3450     assert(idx < getNumSuccessors() && "Successor # out of range for switch!");
 3858     assert(i < 2 && "Successor # out of range for invoke!");
 3863     assert(i < 2 && "Successor # out of range for invoke!");
 4066     assert(i < getNumIndirectDests() && "Out of bounds!");
 4072     assert(i < getNumIndirectDests() && "Out of bounds!");
 4099     assert(i < getNumSuccessors() + 1 &&
 4105     assert(i < getNumIndirectDests() + 1 &&
 4289     assert(UnwindDest);
 4290     assert(hasUnwindDest());
 4366     assert(Idx < getNumSuccessors() &&
 4371     assert(Idx < getNumSuccessors() &&
 4468     assert(CatchSwitch);
 4501     assert(CatchPad);
 4502     assert(BB);
 4508     assert(CatchPad);
 4509     assert(BB);
 4519     assert(CatchPad);
 4525     assert(NewSucc);
 4546     assert(Idx < getNumSuccessors() && "Successor # out of range for catchret!");
 4551     assert(Idx < getNumSuccessors() && "Successor # out of range for catchret!");
 4586     assert(CleanupPad);
 4596     assert(CleanupPad);
 4615     assert(CleanupPad);
 4625     assert(NewDest);
 4626     assert(hasUnwindDest());
 4640     assert(Idx == 0);
 4645     assert(Idx == 0);
 5285   assert((isa<LoadInst>(I) || isa<StoreInst>(I)) &&
 5295   assert((isa<LoadInst>(I) || isa<StoreInst>(I)) &&
include/llvm/IR/IntrinsicInst.h
  409       assert(getRawDest()->getType() == Ptr->getType() &&
  422       assert(getLength()->getType() == L->getType() &&
  458       assert(getRawSource()->getType() == Ptr->getType() &&
  514       assert(V->getType() == Type::getInt8Ty(getContext()) &&
include/llvm/IR/Intrinsics.h
  126       assert(Kind == Argument || Kind == ExtendArgument ||
  135       assert(Kind == Argument || Kind == ExtendArgument ||
  146       assert(Kind == VecOfAnyPtrsToElt);
  150       assert(Kind == VecOfAnyPtrsToElt);
include/llvm/IR/LegacyPassManagers.h
  389     assert ( 0 && "Invalid use of getPassManagerType");
  512     assert ( N < PassVector.size() && "Pass number out of range!");
include/llvm/IR/Metadata.h
  293     assert(UseMap.empty() && "Cannot destroy in-use replaceable metadata");
  352     assert(V && "Expected valid value");
  431     assert(!isa<Constant>(Local) && "Expected local value");
  531   assert(MD && "Null pointer sent into hasa");
  747     assert(static_cast<void *>(this) == &MD && "Expected same address");
  777     assert(getReplaceableUses() && "Expected non-null replaceable uses");
  819     assert(ReplaceableUses && "Expected non-null replaceable uses");
  820     assert(&ReplaceableUses->getContext() == &getContext() &&
  830     assert(hasReplaceableUses() && "Expected to own replaceable uses");
  949     assert(isTemporary() && "Expected temporary node");
 1069     assert(I < NumOperands && "Out of range");
 1313     assert(!Use && "Use is still being tracked despite being untracked!");
include/llvm/IR/ModuleSummaryIndex.h
  179     assert(haveGVs());
  194     assert(isValidAccessSpecifier());
  198     assert(isValidAccessSpecifier());
  202     assert(isValidAccessSpecifier());
  212     assert(getAccessSpecifier() == 0);
  216     assert(getAccessSpecifier() == 0);
  238   assert(A.getRef() && B.getRef() &&
  244   assert(A.getRef() && B.getRef() &&
  250   assert(A.getRef() && B.getRef() &&
  271     assert(isSpecialKey(L) || isSpecialKey(R) || (L.haveGVs() == R.haveGVs()));
  358     assert((K != AliasKind || Refs.empty()) &&
  451     assert(!!AliaseeSummary == (AliaseeValueInfo &&
  458     assert(AliaseeSummary && "Unexpected missing aliasee summary");
  467     assert(AliaseeValueInfo && "Unexpected missing aliasee");
  471     assert(AliaseeValueInfo && "Unexpected missing aliasee");
  784     assert(!VTableFuncs);
 1014     assert(F != nullptr && "Expected FunctionSummary node");
 1113     assert(!HaveGVs);
 1121     assert(HaveGVs);
 1201     assert(GV.hasName() && "Can't get GlobalValueSummary for GV with no name");
 1229     assert(It != ModulePathStringTable.end() && "Module not registered");
 1262     assert(It != ModulePathStringTable.end() && "Module not registered");
 1432   assert(isa<GlobalVarSummary>(S->getBaseObject()));
include/llvm/IR/PassManager.h
  699       assert(RI != Results.end() &&
  714       assert(Inserted && "Should not have already inserted this ID, likely "
  736     assert(AnalysisResults.empty() == AnalysisResultLists.empty() &&
  778     assert(AnalysisPasses.count(PassT::ID()) &&
  797     assert(AnalysisPasses.count(PassT::ID()) &&
  895       assert(Inserted && "Should never have already inserted this ID, likely "
  925     assert(PI != AnalysisPasses.end() &&
  933     assert(PI != AnalysisPasses.end() &&
  968       assert(RI != AnalysisResults.end() && "we just inserted it!");
include/llvm/IR/PatternMatch.h
  234         assert(NumElts != 0 && "Constant vector with no elements?");
  293         assert(NumElts != 0 && "Constant vector with no elements?");
include/llvm/IR/Statepoint.h
  108     assert(*this && "check validity first!");
  128     assert(isInt<32>(NumPatchBytes) && "should fit in 32 bits!");
  171     assert(CallArgsBeginPos <= (int)getCall()->arg_size());
  176     assert((getCall()->arg_end() - I) >= 0);
  204     assert((getCall()->arg_end() - I) >= 0);
  209     assert((getCall()->arg_end() - I) >= 0);
  227     assert((getCall()->arg_end() - I) >= 0);
  232     assert((getCall()->arg_end() - I) >= 0);
  274     assert(getNumCallArgs() >= 0 &&
  342       assert(isStatepoint(Token));
  350     assert(InvokeBB && "safepoints should have unique landingpads");
  351     assert(InvokeBB->getTerminator() &&
  353     assert(isStatepoint(InvokeBB->getTerminator()));
include/llvm/IR/TrackingMDRef.h
   94     assert(MD == X.MD && "Expected values to match");
include/llvm/IR/Type.h
  100     assert(getSubclassData() == val && "Subclass data too large for field");
  337     assert(i < NumContainedTys && "Index out of range!");
  362     assert(isSequentialType(getTypeID()) && "Not a sequential type!");
  369     assert(getTypeID() == ArrayTyID);
  377     assert(getTypeID() == VectorTyID);
  382     assert(getTypeID() == PointerTyID);
include/llvm/IR/User.h
   75     assert(NumOps < (1u << NumUserOperandsBits) && "Too many operands");
   79     assert((!HasHungOffUses || !getOperandList()) &&
  156     assert(HasHungOffUses &&
  170     assert(i < NumUserOperands && "getOperand() out of range!");
  175     assert(i < NumUserOperands && "setOperand() out of range!");
  176     assert((!isa<Constant>((const Value*)this) ||
  183     assert(i < NumUserOperands && "getOperandUse() out of range!");
  187     assert(i < NumUserOperands && "getOperandUse() out of range!");
  208     assert(NumOps <= 1 && "GlobalVariable can only have 0 or 1 operands");
  216     assert(HasHungOffUses && "Must have hung off uses to use this method");
  217     assert(NumOps < (1u << NumUserOperandsBits) && "Too many operands");
include/llvm/IR/Value.h
  141       assert(U && "Cannot increment end iterator!");
  153       assert(U && "Cannot dereference end iterator!");
  303     assert(New && "Value::replaceUsesWithIf(<null>) is invalid!");
  304     assert(New->getType() == getType() &&
  789       assert(NumSlots <= MaxSlots && "Use list bigger than 2^32");
  797   assert(Next && "Expected one more Use");
  798   assert(!Next->Next && "Expected only one Use");
include/llvm/IR/ValueHandle.h
  332     assert(InnerHandle.pointsToAliveValue() &&
  339     assert(isa<ValueTy>(InnerHandle) &&
  465     assert(!Poisoned && "Tried to delete an already poisoned handle!");
  472     assert(!Poisoned && "Tried to RAUW an already poisoned handle!");
  484     assert(!Poisoned && "Accessed a poisoned value handle!");
include/llvm/IR/ValueMap.h
  272     assert(isa<KeySansPointerT>(new_key) &&
include/llvm/MC/MCAsmMacro.h
   91     assert(Kind == String && "This token isn't a string!");
  116     assert(Kind == Integer && "This token isn't an integer!");
  121     assert((Kind == Integer || Kind == BigNum) &&
include/llvm/MC/MCAssembler.h
  328     assert((Size == 0 || !(Size & (Size - 1))) &&
include/llvm/MC/MCCodeView.h
   79     assert(column <= UINT16_MAX);
  131     assert(isInlinedCallSite());
include/llvm/MC/MCContext.h
  564       assert(I != MCDwarfLineTablesCUMap.end());
include/llvm/MC/MCDwarf.h
  126     assert(column <= UINT16_MAX);
  132     assert(flags <= UINT8_MAX);
  138     assert(isa <= UINT8_MAX);
  469     assert(Op != OpRegister);
  474     assert(Op == OpRegister);
  581     assert(Operation == OpDefCfa || Operation == OpOffset ||
  589     assert(Operation == OpRegister);
  594     assert(Operation == OpDefCfa || Operation == OpOffset ||
  601     assert(Operation == OpEscape);
include/llvm/MC/MCFixup.h
   95     assert(Kind < MaxTargetFixupKind && "Kind out of range!");
  158       assert(!IsPCRel && "Invalid pc-relative fixup size!");
include/llvm/MC/MCFragment.h
  391     assert(isPowerOf2_64(PolicyMask) &&
  396     assert(isInstructionInitialized() && "Fragment has no instruction!");
  400     assert(isInstructionInitialized() && "Fragment has no instruction!");
  403     assert(InstInfo.InstFragment != nullptr &&
include/llvm/MC/MCInst.h
   65     assert(isReg() && "This is not a register operand!");
   71     assert(isReg() && "This is not a register operand!");
   76     assert(isImm() && "This is not an immediate");
   81     assert(isImm() && "This is not an immediate");
   86     assert(isFPImm() && "This is not an FP immediate");
   91     assert(isFPImm() && "This is not an FP immediate");
   96     assert(isExpr() && "This is not an expression");
  101     assert(isExpr() && "This is not an expression");
  106     assert(isInst() && "This is not a sub-instruction");
  111     assert(isInst() && "This is not a sub-instruction");
include/llvm/MC/MCInstrDesc.h
  107     assert(isGenericType() && "non-generic types don't have an index");
  117     assert(isGenericImm() && "non-generic immediates don't have an index");
include/llvm/MC/MCInstrInfo.h
   45     assert(Opcode < NumOpcodes && "Invalid opcode!");
   51     assert(Opcode < NumOpcodes && "Invalid opcode!");
include/llvm/MC/MCLinkerOptimizationHint.h
  119     assert(isValidMCLOHType(Kind) && "Invalid LOH directive type!");
include/llvm/MC/MCParser/MCAsmLexer.h
   74     assert(!CurTok.empty());
  111     assert(ReadCount == 1);
include/llvm/MC/MCParser/MCAsmParser.h
   68     assert(isKind(IK_Invalid) && "should be initialized only once");
   73     assert(isKind(IK_Invalid) && "should be initialized only once");
   78     assert(isKind(IK_Invalid) && "should be initialized only once");
include/llvm/MC/MCParser/MCTargetAsmParser.h
  259     assert(Kind == NearMissFeature);
  265     assert(Kind == NearMissPredicate);
  270     assert(Kind == NearMissOperand || Kind == NearMissTooFewOperands);
  275     assert(Kind == NearMissOperand || Kind == NearMissTooFewOperands);
  280     assert(Kind == NearMissOperand);
  286     assert(Kind == NearMissOperand);
  463     assert(Op1.isReg() && Op2.isReg() && "Operands not all regs");
include/llvm/MC/MCRegister.h
   53     assert(!isStackSlot(Reg) && "Not a register! Check isStackSlot() first.");
include/llvm/MC/MCRegisterInfo.h
   59     assert(i < getNumRegs() && "Register number out of range!");
  204       assert(isValid() && "Cannot move off the end of the list.");
  330     assert(RegNo < NumRegs &&
  427     assert(i < getNumRegClasses() && "Register Class ID out of range");
  437     assert(RegNo < NumRegs &&
  567     assert(Reg && "Null register has no regunits");
  636     assert(RegUnit < MCRI->getNumRegUnits() && "Invalid register unit");
  653     assert(isValid() && "Cannot move off the end of the list.");
  690     assert(SI.isValid() && "Cannot dereference an invalid iterator.");
  713     assert(isValid() && "Cannot move off the end of the list.");
include/llvm/MC/MCSchedule.h
  323     assert(hasExtraProcessorInfo() &&
  340     assert(hasInstrSchedModel() && "No scheduling machine model");
  342     assert(ProcResourceIdx < NumProcResourceKinds && "bad proc resource idx");
  347     assert(hasInstrSchedModel() && "No scheduling machine model");
  349     assert(SchedClassIdx < NumSchedClasses && "bad scheduling class idx");
include/llvm/MC/MCSection.h
  115     assert(!Begin);
include/llvm/MC/MCSectionCOFF.h
   60     assert((Characteristics & 0x00F00000) == 0 &&
include/llvm/MC/MCSectionWasm.h
   83     assert(isWasmData());
   87     assert(isWasmData());
include/llvm/MC/MCSectionXCOFF.h
   47     assert((ST == XCOFF::XTY_SD || ST == XCOFF::XTY_CM) &&
include/llvm/MC/MCStreamer.h
  417     assert(Section && "Cannot switch to a null section!");
include/llvm/MC/MCSubtargetInfo.h
  171     assert(DefIdx < SC->NumWriteLatencyEntries &&
include/llvm/MC/MCSymbol.h
  183       assert(F != AbsolutePseudoFragment);
  191     assert(FragmentAndHasName.getInt() && "Name is required");
  269     assert(isInSection() && "Invalid accessor!");
  275     assert(!isVariable() && "Cannot set fragment of variable");
  303     assert(isVariable() && "Invalid accessor!");
  325     assert((SymbolContents == SymContentsUnset ||
  331     assert((SymbolContents == SymContentsUnset ||
  340     assert(isCommon() && "Not a 'common' symbol!");
  350     assert(getOffset() == 0);
  354     assert((!Align || isPowerOf2_32(Align)) &&
  357     assert(Log2Align < (1U << NumCommonAlignmentBits) &&
  364     assert(isCommon() && "Not a 'common' symbol!");
  375     assert(isCommon() || getOffset() == 0);
  423     assert(Value < (1U << NumFlagsBits) && "Out of range flags");
  429     assert(Value < (1U << NumFlagsBits) && "Out of range flags");
include/llvm/MC/MCSymbolMachO.h
  106     assert(Value == (Value & SF_DescFlagsMask) &&
  120         assert((1U << Log2Size) == Align && "Invalid 'common' alignment!");
include/llvm/MC/MCSymbolWasm.h
   96     assert(GlobalType.hasValue());
  102     assert(EventType.hasValue());
include/llvm/MC/MCSymbolXCOFF.h
   27     assert((!StorageClass.hasValue() || StorageClass.getValue() == SC) &&
   33     assert(StorageClass.hasValue() &&
   39     assert((!ContainingCsect || ContainingCsect == C) &&
   46     assert(ContainingCsect &&
include/llvm/MC/SubtargetFeature.h
  209     assert(!Feature.empty() && "Empty string");
  223     assert(!Feature.empty() && "Empty string");
include/llvm/MCA/HardwareUnits/LSUnit.h
   82     assert(!isExecuted() && "Should have been removed!");
  104     assert(!isReady() && "Unexpected group-start event!");
  115     assert(!isReady() && "Inconsistent state found!");
  121     assert(!isExecuting() && "Invalid internal state!");
  143     assert(isReady() && !isExecuted() && "Invalid internal state!");
  156     assert(!getNumSuccessors() && "Cannot add instructions to this group!");
  279     assert(isValidGroupID(Index) && "Group doesn't exist!");
  284     assert(isValidGroupID(Index) && "Group doesn't exist!");
include/llvm/MCA/HardwareUnits/ResourceManager.h
  241     assert(isSubResourceReady(ID));
  246     assert(!isSubResourceReady(ID));
  274     assert(AvailableSlots <= static_cast<unsigned>(BufferSize));
  285     assert(AvailableSlots <= static_cast<unsigned>(BufferSize));
  394     assert(ResourceID < ProcResID2Mask.size() &&
include/llvm/MCA/HardwareUnits/Scheduler.h
  270     assert(find(WaitSet, IR) == WaitSet.end() && "Already in the wait set!");
  271     assert(find(ReadySet, IR) == ReadySet.end() && "Already in the ready set!");
  272     assert(find(IssuedSet, IR) == IssuedSet.end() && "Already executing!");
include/llvm/MCA/Instruction.h
  207     assert(Users.empty() && "Write is in an inconsistent state.");
  321     assert(End >= Cycles);
  540     assert(isExecuted() && "Instruction is in an invalid state!");
  615     assert(isValid() && "Invalid null WriteState found!");
include/llvm/MCA/SourceMgr.h
   45     assert(hasNext() && "Already at end of sequence!");
include/llvm/MCA/Stages/Stage.h
   58     assert(!NextInSequence && "This stage already has a NextInSequence!");
   71     assert(checkNextStage(IR) && "Next stage is not ready!");
include/llvm/MCA/Support.h
   59     assert(Denominator && "Invalid denominator (must be non-zero).");
  100   assert(Mask && "Processor Resource Mask cannot be zero!");
include/llvm/Object/Archive.h
  105       assert(!Parent || !other.Parent || Parent == other.Parent);
include/llvm/Object/COFF.h
  195     assert(isOrdinal() && "ILT entry is not an ordinal!");
  200     assert(!isOrdinal() && "ILT entry is not a Hint/Name RVA!");
  313     assert(isSet() && "COFFSymbolRef points to nothing!");
  318     assert(isSet() && "COFFSymbolRef points to nothing!");
  323     assert(isSet() && "COFFSymbolRef points to nothing!");
  334     assert(isSet() && "COFFSymbolRef points to nothing!");
  339     assert(isSet() && "COFFSymbolRef points to nothing!");
  344     assert(isSet() && "COFFSymbolRef points to nothing!");
  882     assert(!is64());
  887     assert(is64());
include/llvm/Object/ELF.h
  218     assert(Phdr.p_type == ELF::PT_NOTE && "Phdr is not of type PT_NOTE");
  237     assert(Shdr.sh_type == ELF::SHT_NOTE && "Shdr is not of type SHT_NOTE");
  322   assert(Sym->st_shndx == ELF::SHN_XINDEX);
  628   assert(Section.sh_type == ELF::SHT_SYMTAB_SHNDX);
include/llvm/Object/ELFObjectFile.h
  101     assert(isa<ELFObjectFileBase>(SectionRef::getObject()));
  124     assert(isa<ELFObjectFileBase>(B->getObject()));
  139     assert(isa<ELFObjectFileBase>(SymbolRef::getObject()));
  191     assert(isa<ELFObjectFileBase>(RelocationRef::getObject()));
  321     assert(SymTable->sh_type == ELF::SHT_SYMTAB ||
  927   assert(getRelSection(Rel)->sh_type == ELF::SHT_REL);
  937   assert(getRelSection(Rela)->sh_type == ELF::SHT_RELA);
include/llvm/Object/ELFTypes.h
  212     assert(v < 4 && "Invalid value for visibility");
  366     assert(!isMips64EL);
  370     assert(!IsMips64EL);
  669     assert(Start && "ELF note iterator starting at NULL");
  675     assert(Nhdr && "incremented ELF note end iterator");
  692     assert(Nhdr && "dereferenced ELF note end iterator");
  735     assert(kind == ELF::ODK_REGINFO);
include/llvm/Object/IRSymtab.h
  210     assert(isCommon());
  215     assert(isCommon());
  222     assert(isWeak() && isIndirect());
include/llvm/Object/Minidump.h
  112       assert(Storage.size() % Stride == 0);
  120       assert(Storage.size() >= sizeof(minidump::MemoryInfo));
include/llvm/Object/ObjectFile.h
  176     assert(isa<ObjectFile>(BasicSymbolRef::getObject()));
  293     assert(getSymbolFlags(Symb) & SymbolRef::SF_Common);
  424   assert(OwningObject == Other.OwningObject);
include/llvm/Object/StackMapParser.h
  131       assert(getKind() == LocationKind::Constant && "Not a small constant.");
  137       assert(getKind() == LocationKind::ConstantIndex &&
  144       assert((getKind() == LocationKind::Direct ||
  308     assert(StackMapSection[0] == 3 &&
include/llvm/Object/XCOFFObjectFile.h
  285     assert(!is64Bit() && "Symbol table handling not supported yet.");
include/llvm/ObjectYAML/CodeViewYAMLTypeHashing.h
   34     assert(S.size() == 8 && "Invalid hash size!");
   37     assert(S.size() == 8 && "Invalid hash size!");
include/llvm/Option/OptTable.h
   78     assert(id > 0 && id - 1 < getNumOptions() && "Invalid Option ID.");
include/llvm/Option/Option.h
   88     assert(Info && "Must have a valid info!");
   93     assert(Info && "Must have a valid info!");
   99     assert(Info && "Must have a valid info!");
  104     assert(Info && "Must have a valid info!");
  105     assert(Owner && "Must have a valid owner!");
  110     assert(Info && "Must have a valid info!");
  111     assert(Owner && "Must have a valid owner!");
  118     assert(Info && "Must have a valid info!");
  119     assert((!Info->AliasArgs || Info->AliasArgs[0] != 0) &&
include/llvm/PassAnalysisSupport.h
  202   assert(Resolver && "Pass not resident in a PassManager object!");
  221   assert(Resolver && "Pass has not been inserted into a PassManager object!");
  227   assert(PI && "getAnalysis for unregistered pass!");
  228   assert(Resolver&&"Pass has not been inserted into a PassManager object!");
  233   assert(ResultPass &&
  249   assert(Resolver &&"Pass has not been inserted into a PassManager object!");
  256   assert(PI && "getAnalysis for unregistered pass!");
  257   assert(Resolver && "Pass has not been inserted into a PassManager object!");
  262   assert(ResultPass && "Unable to find requested analysis info");
include/llvm/PassInfo.h
   97     assert((!isAnalysisGroup() || NormalCtor) &&
   99     assert(NormalCtor &&
include/llvm/Passes/PassBuilder.h
   47     assert(this->CSAction == NoCSAction ||
   51     assert(this->CSAction != CSIRInstr || !this->CSProfileGenFile.empty());
   55     assert(this->CSAction != CSIRUse || this->Action == IRUse);
   58     assert(this->Action != NoAction || this->CSAction != NoCSAction ||
include/llvm/ProfileData/Coverage/CoverageMapping.h
   69     assert(Err != coveragemap_error::success && "Not an error");
  356     assert(Current != Records.end() && "incremented past end");
  455     assert(hasName() && "Instantiations don't have a shared name");
include/llvm/ProfileData/GCOV.h
  337     assert(&Edge->Dst == this); // up to caller to ensure edge is valid
  342     assert(&Edge->Src == this); // up to caller to ensure edge is valid
include/llvm/ProfileData/InstrProf.h
  304     assert(Err != instrprof_error::success && "Not an error");
  322       assert(Err == instrprof_error::success && "Multiple errors encountered");
  357     assert(FirstError == instrprof_error::success &&
include/llvm/ProfileData/InstrProfReader.h
  174     assert(Symtab.get());
  228     assert(Symtab.get());
  267       assert(atEnd());
  485       assert(CS_Summary && "No context sensitive profile summary");
  488       assert(Summary && "No profile summary");
  515       assert(CS_Summary && "No context sensitive summary");
  518       assert(Summary && "No profile summary");
include/llvm/ProfileData/SampleProf.h
  520       assert(false && "internal error: unknown suffix elision policy");
  535     assert(GUIDToFuncNameMap && "GUIDToFuncNameMap needs to be popluated first");
include/llvm/ProfileData/SampleProfReader.h
  249     assert(Remappings && "Remappings cannot be nullptr");
include/llvm/Support/ARMWinEH.h
  117     assert(Flag() == RuntimeFunctionFlag::RFF_Unpacked &&
  123     assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
  129     assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
  135     assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
  138     assert(((UnwindData & 0x00006000) || L()) && "L must be set to 1");
  142     assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
  148     assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
  154     assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
  160     assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
  166     assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
  169     assert(((~UnwindData & 0x00200000) || L()) &&
  171     assert(((~UnwindData & 0x00200000) || (Reg() < 7) || R()) &&
  176     assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
  381     assert(!isAArch64 && "Fragments are only supported on ARMv7 WinEH");
  404     assert(E() == 0 && "epilogue scopes are only present when the E bit is 0");
  418     assert(X() && "Exception Handler RVA is only valid if the X bit is set");
  423     assert(X() && "Exception Handler RVA is only valid if the X bit is set");
include/llvm/Support/Alignment.h
   78     assert(Value > 0 && "Value must not be 0");
   79     assert(llvm::isPowerOf2_64(Value) && "Alignment is not a power of 2");
   81     assert(ShiftValue < 64 && "Broken invariant");
  135     assert((Value == 0 || llvm::isPowerOf2_64(Value)) &&
  153   ALIGN_CHECK_ISSET(Lhs);
  186   assert(static_cast<uintptr_t>(ArithAddr + Alignment.value() - 1) >=
  209   ALIGN_CHECK_ISSET(A);
  253   ALIGN_CHECK_ISPOSITIVE(Rhs);
  257   ALIGN_CHECK_ISPOSITIVE(Rhs);
  261   ALIGN_CHECK_ISPOSITIVE(Rhs);
  265   ALIGN_CHECK_ISPOSITIVE(Rhs);
  269   ALIGN_CHECK_ISPOSITIVE(Rhs);
  273   ALIGN_CHECK_ISPOSITIVE(Rhs);
  285   ALIGN_CHECK_ISSET(Lhs);
  286   ALIGN_CHECK_ISPOSITIVE(Rhs);
  290   ALIGN_CHECK_ISSET(Lhs);
  291   ALIGN_CHECK_ISPOSITIVE(Rhs);
  295   ALIGN_CHECK_ISSET(Lhs);
  296   ALIGN_CHECK_ISPOSITIVE(Rhs);
  300   ALIGN_CHECK_ISSET(Lhs);
  301   ALIGN_CHECK_ISPOSITIVE(Rhs);
  327   ALIGN_CHECK_ISSET(Rhs);
  331   ALIGN_CHECK_ISSET(Rhs);
  335   ALIGN_CHECK_ISSET(Rhs);
  339   ALIGN_CHECK_ISSET(Rhs);
  343   ALIGN_CHECK_ISSET(Rhs);
  347   ALIGN_CHECK_ISSET(Rhs);
  353   ALIGN_CHECK_ISSET(Lhs);
  357   ALIGN_CHECK_ISSET(Lhs);
  361   ALIGN_CHECK_ISSET(Lhs);
  365   ALIGN_CHECK_ISSET(Lhs);
  369   ALIGN_CHECK_ISSET(Lhs);
  373   ALIGN_CHECK_ISSET(Lhs);
  378   assert(llvm::isPowerOf2_64(Divisor) &&
  380   assert(Lhs != 1 && "Can't halve byte alignment");
  385   assert(llvm::isPowerOf2_64(Divisor) &&
include/llvm/Support/Allocator.h
  220     assert(Adjustment + Size >= Size && "Adjustment + Size must not overflow");
  251       assert(AlignedAddr + Size <= (uintptr_t)NewSlab + PaddedSize);
  261     assert(AlignedAddr + SizeToAllocate <= (uintptr_t)End &&
  272     assert(Alignment > 0 && "0-byte alignnment is not allowed. Use 1 instead.");
  324     assert(Out && "Wrong allocator used");
  341     assert(Out % alignof(T) == 0 && "Wrong alignment information");
  469       assert(Begin == (char *)alignAddr(Begin, Align::Of<T>()));
include/llvm/Support/ArrayRecycler.h
   57     assert(Ptr && "Cannot recycle NULL pointer");
   98     assert(Bucket.empty() && "Non-empty ArrayRecycler deleted!");
include/llvm/Support/Automaton.h
  213     assert(Transcriber &&
  245     assert(Transcriber && Transcribe &&
include/llvm/Support/BinaryItemStream.h
   80       assert(Len > 0 && "no empty items");
   94     assert(Idx < Items.size() && "binary search for offset failed");
include/llvm/Support/BinaryStreamArray.h
  117     assert(Begin >= Skew);
  179       assert(Array == R.Array);
  197     assert(Array && !HasError);
  266     assert(Stream.getLength() % sizeof(T) == 0);
  280     assert(Index < size());
  284       assert(false && "Unexpected failure reading from stream");
  289     assert(isAddrAligned(Align::Of<T>(), Data.data()));
  337     assert(Array == R.Array);
  347     assert(std::ptrdiff_t(Index) >= N);
  353     assert(Array == R.Array);
  354     assert(Index >= R.Index);
include/llvm/Support/BinaryStreamReader.h
  201     assert(isAddrAligned(Align::Of<T>(), Bytes.data()) &&
include/llvm/Support/BinaryStreamRef.h
  100     assert(N <= getLength());
  106     assert(N <= getLength());
include/llvm/Support/BranchProbability.h
   92     assert(N != UnknownN && RHS.N != UnknownN &&
  100     assert(N != UnknownN && RHS.N != UnknownN &&
  108     assert(N != UnknownN && RHS.N != UnknownN &&
  115     assert(N != UnknownN &&
  122     assert(N != UnknownN && RHS.N != UnknownN &&
  129     assert(N != UnknownN &&
  131     assert(RHS > 0 && "The divider cannot be zero.");
  176     assert(N != UnknownN && RHS.N != UnknownN &&
  182     assert(N != UnknownN && RHS.N != UnknownN &&
  188     assert(N != UnknownN && RHS.N != UnknownN &&
  194     assert(N != UnknownN && RHS.N != UnknownN &&
include/llvm/Support/CFGUpdate.h
   87     assert(std::abs(NumInsertions) <= 1 && "Unbalanced operations!");
include/llvm/Support/Casting.h
   84     assert(Val && "isa<> used on a null pointer");
   91     assert(Val && "isa<> used on a null pointer");
  105     assert(Val && "isa<> used on a null pointer");
  250   assert(isa<X>(Val) && "cast<Ty>() argument of incompatible type!");
  257   assert(isa<X>(Val) && "cast<Ty>() argument of incompatible type!");
  264   assert(isa<X>(Val) && "cast<Ty>() argument of incompatible type!");
  272   assert(isa<X>(Val.get()) && "cast<Ty>() argument of incompatible type!");
  289   assert(isa<X>(Val) && "cast_or_null<Ty>() argument of incompatible type!");
  300   assert(isa<X>(Val) && "cast_or_null<Ty>() argument of incompatible type!");
  308   assert(isa<X>(Val) && "cast_or_null<Ty>() argument of incompatible type!");
include/llvm/Support/Chrono.h
  149     assert(0 && "Unrecognised duration format");
  163       assert(!unit.empty());
include/llvm/Support/CommandLine.h
  530     assert(Valid && "invalid option value");
  813     assert(findOption(Name) == Values.size() && "Option already exists!");
  823     assert(N != Values.size() && "Option not found!");
 1209     assert((MF != Grouping || O.ArgStr.size() == 1) &&
 1239     assert(Location && "cl::location(...) not specified for a command "
 1442     assert(Location != 0 && "cl::location(...) not specified for a command "
 1584     assert(optnum < this->size() && "Invalid option index");
include/llvm/Support/DebugCounter.h
  109     assert(Result != Us.Counters.end() && "Asking about a non-set counter");
include/llvm/Support/Endian.h
  120   assert(startBit < 8);
  155   assert(startBit < 8);
include/llvm/Support/Error.h
  385     assert(!Payload1->isA<ErrorList>() && !Payload2->isA<ErrorList>() &&
  462     assert(Err && "Cannot create Expected<T> from Error success value.");
  626     assert(!HasError && "Cannot get value when an error exists!");
  636     assert(HasError && "Cannot get error when a value exists!");
  641     assert(HasError && "Cannot get error when a value exists!");
  795     assert(appliesTo(*E) && "Applying incorrect handler");
  809     assert(appliesTo(*E) && "Applying incorrect handler");
  825     assert(appliesTo(*E) && "Applying incorrect handler");
  841     assert(appliesTo(*E) && "Applying incorrect handler");
 1228     assert(Err && !FileName.empty() && "Trying to log after takeError().");
 1245     assert(E && "Cannot create FileError from Error success value.");
 1246     assert(!F.isTriviallyEmpty() &&
include/llvm/Support/ErrorOr.h
  243     assert(!HasError && "Cannot get value when an error exists!");
  248     assert(!HasError && "Cannot get value when an error exists!");
  253     assert(HasError && "Cannot get error when a value exists!");
include/llvm/Support/FileSystem.h
 1408     assert(State && "Cannot pop an end iterator!");
 1409     assert(State->Level > 0 && "Cannot pop an iterator with level < 1");
include/llvm/Support/Format.h
   55     assert(BufferSize && "Invalid buffer size!");
  188   assert(Width <= 18 && "hex width must be <= 18");
  201   assert(Width <= 16 && "hex width must be <= 16");
include/llvm/Support/FormatProviders.h
   68       assert(false && "Invalid precision specifier");
   71       assert(Prec < 100 && "Precision out of range");
  147     assert(Style.empty() && "Invalid integral format style!");
  205       assert(false && "Style is not a valid integer");
  368       assert(false && "Invalid range style");
  377         assert(false && "Missing range option end delimeter!");
  384     assert(false && "Invalid range style!");
  391     assert(Style.empty() && "Unexpected text in range option string!");
include/llvm/Support/GenericDomTree.h
  118     assert(IDom && "No immediate dominator?");
  122     assert(I != IDom->Children.end() &&
  149     assert(IDom);
  159         assert(C->IDom);
  383     assert(!this->isPostDominator() &&
  439     assert(this->Roots.size() == 1 && "Should always have entry node!");
  446     assert(A && B && "Pointers are not valid");
  447     assert(A->getParent() == B->getParent() &&
  534     assert(From);
  535     assert(To);
  536     assert(From->getParent() == Parent);
  537     assert(To->getParent() == Parent);
  552     assert(From);
  553     assert(To);
  554     assert(From->getParent() == Parent);
  555     assert(To->getParent() == Parent);
  569     assert(getNode(BB) == nullptr && "Block already in dominator tree!");
  571     assert(IDomNode && "Not immediate dominator specified for block!");
  583     assert(getNode(BB) == nullptr && "Block already in dominator tree!");
  584     assert(!this->isPostDominator() &&
  592       assert(Roots.size() == 1);
  608     assert(N && NewIDom && "Cannot change null node pointers!");
  622     assert(Node && "Removing node that isn't in dominator tree.");
  623     assert(Node->getChildren().empty() && "Node is not a leaf node.");
  631       assert(I != IDom->Children.end() &&
  694     assert((!Parent || ThisRoot) && "Empty constructed DomTree");
  775     assert(std::distance(GraphT::child_begin(NewBB),
  784     assert(!PredBlocks.empty() && "No predblocks?");
  829     assert(A != B);
  830     assert(isReachableFromEntry(B));
  831     assert(isReachableFromEntry(A));
include/llvm/Support/GenericDomTreeConstruction.h
  149           assert(llvm::find(Res, Child) != Res.end()
  157           assert(llvm::find(Res, Child) == Res.end() &&
  183     assert(IDom || DT.DomTreeNodes[nullptr]);
  221     assert(V);
  280     assert(Stack.empty());
  357     assert(IsPostDom && "Only postdominators have a virtual root");
  358     assert(NumToNode.size() == 1 && "SNCAInfo must be freshly constructed");
  371     assert(N && "N must be a valid node");
  376     assert(DT.Parent && "Parent not set");
  384     assert(DT.Parent && "Parent pointer is not set");
  488     assert((Total + 1 == Num) && "Everything should have been visited");
  512     assert(IsPostDom && "This function is for postdominators only");
  552       assert(DT.Roots.size() == 1 && "Dominators should have a singe root");
  623       assert(TN);
  651     assert((From || IsPostDom) &&
  653     assert(To && "Cannot be a nullptr");
  685     assert(IsPostDom && "This function is only for postdominators");
  716     assert(IsPostDom && "This function is only for postdominators");
  753     assert(NCDBlock || DT.isPostDominator());
  755     assert(NCD);
  787       assert(TN->getBlock() && II.Visited.count(TN) && "Preconditions!");
  801           assert(SuccTN &&
  860       assert(TN->getLevel() == TN->getIDom()->getLevel() + 1 &&
  898     assert(!DT.getNode(Root) && "Root must not be reachable");
  920     assert(From && To && "Cannot disconnect nullptrs");
  933     assert(!IsSuccessor(To, From) && "Deleted edge still exists in the CFG!");
  982     assert(ToIDom || DT.isPostDominator());
  984     assert(ToIDomTN);
 1041     assert(ToTN);
 1042     assert(ToTN->getBlock());
 1063       assert(TN);
 1083       assert(NCDBlock || DT.isPostDominator());
 1085       assert(NCD);
 1117     assert(PrevIDom);
 1137     assert(TN);
 1138     assert(TN->getNumChildren() == 0 && "Not a tree leaf");
 1141     assert(IDom);
 1144     assert(ChIt != IDom->Children.end());
 1224     assert(!BUI.Updates.empty() && "No updates to apply!");
 1238     assert(FS.back().getPointer() == CurrentUpdate.getTo() &&
 1244     assert(FP.back().getPointer() == CurrentUpdate.getFrom() &&
 1420         assert(FirstCh);
include/llvm/Support/JSON.h
  310       assert(false && "Invalid UTF-8 in value used as JSON");
  322       assert(false && "Invalid UTF-8 in value used as JSON");
  495       assert(false && "Invalid UTF-8 in value used as JSON");
  502       assert(false && "Invalid UTF-8 in value used as JSON");
  657     assert(*this && "Must check this is an object before calling map()");
  666     assert(*this && "Must check this is an object before calling map()");
  760     assert(Stack.size() == 1 && "Unmatched begin()/end()");
  761     assert(Stack.back().Ctx == Singleton);
  762     assert(Stack.back().HasValue && "Did not write top-level value");
include/llvm/Support/KnownBits.h
   40     assert(Zero.getBitWidth() == One.getBitWidth() &&
   50     assert(!hasConflict() && "KnownBits conflict!");
   57     assert(isConstant() && "Can only get value when all bits are known");
   72     assert(!hasConflict() && "KnownBits conflict!");
   78     assert(!hasConflict() && "KnownBits conflict!");
include/llvm/Support/LowLevelTypeImpl.h
   43     assert(SizeInBits > 0 && "invalid scalar size");
   50     assert(SizeInBits > 0 && "invalid pointer size");
   58     assert(NumElements > 1 && "invalid number of vector elements");
   59     assert(ScalarSizeInBits > 0 && "invalid vector element size");
   66     assert(NumElements > 1 && "invalid number of vector elements");
   67     assert(!ScalarTy.isVector() && "invalid vector element type");
  100     assert(IsVector && "cannot get number of elements on scalar/aggregate");
  134     assert(!getScalarType().isPointer() &&
  141     assert(RawData != 0 && "Invalid Type");
  156     assert(RawData != 0 && "Invalid Type");
  157     assert(IsPointer && "cannot get address space of non-pointer type");
  166     assert(isVector() && "cannot get element type of scalar/aggregate");
  236     assert(Val <= Mask && "Value too large for field");
  257       assert(NumElements > 1 && "invalid number of vector elements");
include/llvm/Support/MachineValueType.h
  398       assert(!(EltCnt.Min & 1) && "Splitting vector, but not in half!");
 1093         assert((int)VT <= MVT::MAX_ALLOWED_VALUETYPE &&
include/llvm/Support/MathExtras.h
  251   assert(N <= Bits && "Invalid bit index");
  403   assert(N > 0 && N <= 64 && "integer width out of range");
  414   assert(N > 0 && N <= 64 && "integer width out of range");
  421   assert(N > 0 && N <= 64 && "integer width out of range");
  718   assert(Align != 0u && "Align can't be 0.");
  738   assert(Align != 0u && "Align can't be 0.");
  754   assert(B > 0 && "Bit width can't be 0.");
  755   assert(B <= 32 && "Bit width out of range.");
  770   assert(B > 0 && "Bit width can't be 0.");
  771   assert(B <= 64 && "Bit width out of range.");
include/llvm/Support/Mutex.h
   54           assert(acquired && "Lock not acquired before release!");
include/llvm/Support/OnDiskHashTable.h
  179       assert(B.Off && "Cannot write a bucket at offset 0. Please add padding.");
  183       assert(B.Length != 0 && "Bucket has a head but zero length?");
  201         assert(offset_type(DataStart - KeyStart) == Len.first &&
  203         assert(offset_type(End - DataStart) == Len.second &&
  295     assert((reinterpret_cast<uintptr_t>(Buckets) & 0x3) == 0 &&
  304     assert((reinterpret_cast<uintptr_t>(Buckets) & 0x3) == 0 &&
  419     assert(Buckets > Base);
  478       assert(NumItemsInBucketLeft);
  480       assert(NumEntriesLeft);
  605     assert(Buckets > Base);
include/llvm/Support/RWMutex.h
  130     assert(readers > 0 && "Reader lock not acquired before release!");
  143     assert(writers == 0 && "Writer lock already acquired!");
  156     assert(writers == 1 && "Writer lock not acquired before release!");
include/llvm/Support/Recycler.h
   61     assert(!FreeList && "Non-empty recycler deleted!");
include/llvm/Support/SMLoc.h
   55     assert(Start.isValid() == End.isValid() &&
include/llvm/Support/SMTAPI.h
   43     assert(isBitvectorSort() && "Not a bitvector sort!");
   45     assert(Size && "Size is zero!");
   52     assert(isFloatSort() && "Not a floating-point sort!");
   54     assert(Size && "Size is zero!");
include/llvm/Support/ScaledNumber.h
  203   assert(LocalFloor >= 1);
  308   assert(ShiftL < getWidth<DigitsT>() && "can't shift more than width");
  322   assert(LScale == RScale && "scales should match");
  338   assert(LScale < INT16_MAX && "scale too large");
  339   assert(RScale < INT16_MAX && "scale too large");
  701     assert(Shift >= ScaledNumbers::MinScale && "Shift should be close to 0");
  702     assert(Shift <= ScaledNumbers::MaxScale - 64 &&
  789     assert(size_t(Scale) < sizeof(IntT) * 8);
  793     assert(size_t(-Scale) < sizeof(IntT) * 8);
  836   assert(Shift != INT32_MIN);
  866   assert(Shift != INT32_MIN);
include/llvm/Support/SourceMgr.h
  128     assert(isValidBufferID(i));
  133     assert(isValidBufferID(i));
  142     assert(getNumBuffers());
  147     assert(isValidBufferID(i));
  238     assert(Loc.isValid());
  244     assert(R.isValid());
include/llvm/Support/StringPool.h
  116       assert(*this && "Attempt to dereference empty PooledStringPtr!");
  121       assert(*this && "Attempt to dereference empty PooledStringPtr!");
  126       assert(*this && "Attempt to dereference empty PooledStringPtr!");
include/llvm/Support/TargetRegistry.h
  482       assert(T.isOSWindows() && "only Windows COFF is supported");
  620       assert(Current && "Cannot increment end iterator!");
  631       assert(Current && "Cannot dereference end iterator!");
include/llvm/Support/TaskQueue.h
   74     assert(Tasks.empty());
include/llvm/Support/Timer.h
   95     assert(!RHS.TG && "Can only copy uninitialized timers");
   98     assert(!TG && !T.TG && "Can only assign uninit timers");
include/llvm/Support/TrailingObjects.h
  377       assert(p && "FixedSizeStorageOwner owns null?");
include/llvm/Support/TypeName.h
   33   assert(!Name.empty() && "Unable to find the template parameter!");
   36   assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
include/llvm/Support/TypeSize.h
   89     assert(LHS.IsScalable == RHS.IsScalable &&
  125     assert(!IsScalable && "Request for a fixed size on a scalable object");
  194   assert(Align != 0u && "Align must be non-zero");
include/llvm/Support/UnicodeCharRanges.h
   58     assert(rangesAreValid());
include/llvm/Support/VirtualFileSystem.h
  164     assert(Impl.get() != nullptr && "requires non-null implementation");
  174     assert(Impl && "attempting to increment past end");
  235     assert(!State->Stack.empty() &&
include/llvm/Support/YAMLParser.h
  330     assert(Base && Base->CurrentEntry && "Attempted to access end iterator!");
  335     assert(Base && Base->CurrentEntry &&
  341     assert(Base && Base->CurrentEntry && "Attempted to access end iterator!");
  354       assert((Base->CurrentEntry == Other.Base->CurrentEntry)
  366     assert(Base && "Attempted to advance iterator past end!");
  381   assert(C.IsAtBeginning && "You may only iterate over a collection once!");
  390   assert((C.IsAtBeginning || C.IsAtEnd) && "Cannot skip mid parse!");
  595     assert(Doc && "incrementing iterator past the end.");
include/llvm/Support/YAMLTraits.h
  621   assert(State == FoundExponent && "Should have found exponent at this point.");
  905     assert(DefaultValue.hasValue() == false &&
 1062       assert(Err.empty() && "invalid struct trying to be written as yaml");
 1859     assert(PolymorphicTraits<T>::getKind(Val) != NodeKind::Scalar && "plain scalar documents are not supported");
include/llvm/Support/raw_ostream.h
  372       assert(Size + Offset <= Pos && "We don't support extending the stream");
include/llvm/TableGen/Record.h
  503     assert(Bit < 1 && "Bit index out of range!");
  558     assert(Bit < NumBits && "Bit index out of range!");
  687     assert(i < NumValues && "List element index out of range!");
  776     assert(Operands.size() == 1 &&
  784     assert(i == 0 && "Invalid operand id for unary operator");
  831     assert(Operands.size() == 2 &&
  886     assert(Operands.size() == 3 &&
  954     assert(Num < NumConds && "Condition number out of range!");
  959     assert(Num < NumConds && "Val number out of range!");
 1111     assert(T->getType() &&
 1135     assert(B < 1 && "Bit index out of range!");
 1150     assert(T->getType() && isa<ListRecTy>(T->getType()) &&
 1240     assert(i < NumArgs && "Argument index out of range!");
 1344     assert(Num < NumArgs && "Arg number out of range!");
 1349     assert(Num < NumArgNames && "Arg number out of range!");
 1541     assert(!isTemplateArg(Name) && "Template arg already defined!");
 1546     assert(getValue(RV.getNameInit()) == nullptr && "Value already added!");
 1583     assert(!TheInit && "changing type of record after it has been referenced");
 1584     assert(!isSubClassOf(R) && "Already subclassing record!");
 1728     assert(Ins && "Class already exists");
 1735     assert(Ins && "Record already exists");
 1741     assert(!getDef(Name));
 1742     assert(Ins && "Global already exists");
 1813       assert (i < Parts.size() && "Invalid idx!");
 1824     assert (LHSNumParts && RHSNumParts && "Expected at least one part!");
 1834       assert (LHSPart.first == false && RHSPart.first == false &&
 1843       assert (LHSPart.first == true && RHSPart.first == true &&
 1851       assert(!LHSFailed && "Unable to convert LHS to integer.");
 1853       assert(!RHSFailed && "Unable to convert RHS to integer.");
include/llvm/TableGen/StringToOffsetTable.h
   64       assert(i + 1 < AggregateString.size() && "Incomplete escape sequence!");
   66         assert(isdigit(AggregateString[i + 2]) &&
   84     assert(AggregateString.find(')') == std::string::npos &&
include/llvm/Transforms/IPO/Attributor.h
  240     assert(IRP.getAssociatedFunction());
  258     assert(KindOrArgNo != IRP_INVALID &&
  273     assert(KindOrArgNo != IRP_INVALID &&
  363     assert(KindOrArgNo != IRP_INVALID &&
  367     assert(isa<CallBase>(AnchorVal) && "Expected a call base!");
  402       assert(((isa<Argument>(getAnchorValue()) &&
  411     assert(KindOrArgNo < 0 &&
  790     assert(!KindToAbstractAttributeMap.count(&AAType::ID) &&
  823     assert(F.hasLocalLinkage() &&
  957     assert((QueryingAA || !TrackDependence) &&
include/llvm/Transforms/IPO/WholeProgramDevirt.h
   56     assert(Pos % 8 == 0);
   60       assert(!DataUsed.second[I]);
   68     assert(Pos % 8 == 0);
   72       assert(!DataUsed.second[Size - I - 1]);
   82     assert(!(*DataUsed.second & (1 << Pos % 8)));
  170     assert(Pos >= 8 * minBeforeBytes());
  176     assert(Pos >= 8 * minAfterBytes());
  184     assert(Pos >= 8 * minBeforeBytes());
  193     assert(Pos >= 8 * minAfterBytes());
  229     assert(!(ExportSummary && ImportSummary));
include/llvm/Transforms/InstCombine/InstCombineWorklist.h
   56     assert(Worklist.empty() && "Worklist must be empty to add initial group");
   98     assert(WorklistMap.empty() && "Worklist empty, but map not?");
include/llvm/Transforms/Instrumentation.h
  200   assert(Scaled <= std::numeric_limits<uint32_t>::max() && "overflow 32-bits");
include/llvm/Transforms/Scalar/GVNExpression.h
  168     assert(Operands && "Operands not allocated");
  169     assert(N < NumOperands && "Operand out of range");
  174     assert(Operands && "Operands not allocated before setting");
  175     assert(N < NumOperands && "Operand out of range");
  196     assert(NumOperands < MaxOperands && "Tried to add too many operands");
  197     assert(Operands && "Operandss not allocated before pushing");
  203     assert(!Operands && "Operands already allocated");
  445     assert(NumIntOperands < MaxIntOperands &&
  447     assert(IntOperands && "Operands not allocated before pushing");
  452     assert(!IntOperands && "Operands already allocated");
include/llvm/Transforms/Scalar/LoopPassManager.h
  122     assert(PreOrderLoops.empty() && "Must start with an empty preorder walk.");
  123     assert(PreOrderWorklist.empty() &&
  168     assert((&L == CurrentL || CurrentL->contains(&L)) &&
  188       assert(NewL->getParentLoop() == CurrentL && "All of the new loops must "
  209       assert(NewL->getParentLoop() == ParentL &&
  348       assert(L->isRecursivelyLCSSAForm(LAR.DT, LI) &&
include/llvm/Transforms/Utils/BasicBlockUtils.h
  207     assert(i != TI->getNumSuccessors() && "Edge doesn't exist!");
include/llvm/Transforms/Utils/Evaluator.h
   68     assert(R && "Reference to an uncomputed value!");
include/llvm/Transforms/Utils/SizeOpts.h
   38   assert(F);
   57   assert(BB);
lib/Analysis/AliasAnalysis.cpp
  714   assert(I1.getParent() == I2.getParent() &&
lib/Analysis/AliasSetTracker.cpp
   53   assert(!AS.Forward && "Alias set is already forwarding!");
   54   assert(!Forward && "This set is a forwarding set!!");
  107     assert(*AS.PtrListEnd == nullptr && "End of list is not null?");
  126     assert(AliasSets.empty() && "Tracker not empty");
  131   assert(RefCount == 0 && "Cannot remove non-dead alias set from tracker!");
  138   assert(!Entry.hasAliasSet() && "Entry already in set!");
  152         assert(Result != NoAlias && "Cannot be part of must set!");
  162   assert(*PtrListEnd == nullptr && "End of list is not null?");
  165   assert(*PtrListEnd == nullptr && "End of list is not null?");
  205     assert(UnknownInsts.empty() && "Illegal must alias set!");
  210     assert(SomePtr && "Empty must-alias set??");
  242   assert(Inst->mayReadOrWriteMemory() &&
  275     assert(!Addr->user_empty() &&
  368       assert(Entry.getAliasSet(*this) == AliasAnyAS &&
  521   assert(&AA == &AST.AA &&
  545   assert(MSSA && L && "MSSA and L must be available");
  591   assert(I->second->hasAliasSet() && "Dead entry?");
  605   assert(!AliasAnyAS && (TotalMayAliasSetSize > SaturationThreshold) &&
  718   assert(AST && "ASTCallbackVH called with a null AliasSetTracker!");
lib/Analysis/AssumptionCache.cpp
  171   assert(!Scanned && "Tried to scan the function twice!");
  172   assert(AssumeHandles.empty() && "Already have assumes when scanning!");
  190   assert(match(CI, m_Intrinsic<Intrinsic::assume>()) &&
  201   assert(CI->getParent() &&
  203   assert(&F == CI->getParent()->getParent() &&
  214     assert(&F == cast<Instruction>(VH)->getParent()->getParent() &&
  216     assert(match(cast<CallInst>(VH), m_Intrinsic<Intrinsic::assume>()) &&
  218     assert(AssumptionSet.insert(VH).second &&
  260   assert(IP.second && "Scanning function already in the map?");
lib/Analysis/BasicAliasAnalysis.cpp
  281   assert(V->getType()->isIntegerTy() && "Not an integer value");
  297     assert(Scale == 0 && "Constant values don't have a scale");
  436   assert(PointerSize <= Offset.getBitWidth() && "Invalid PointerSize!");
  655   assert(Visited.empty() && "Visited must be cleared after use!");
  842   assert(notDifferentParent(LocA.Ptr, LocB.Ptr) &&
  872   assert(notDifferentParent(Call, Loc.Ptr) &&
 1088   assert(GEP1->getPointerOperand()->stripPointerCastsAndInvariantGroups() ==
 1131   assert(GEP1->getNumIndices() > 1 && "Not enough GEP indices to examine");
 1327   assert(DecompGEP1.Base == UnderlyingV1 && DecompGEP2.Base == UnderlyingV2 &&
 1374       assert(BaseAlias == NoAlias || BaseAlias == MayAlias);
 1420       assert(R == NoAlias || R == MayAlias);
 1611         assert((CacheIt != AAQI.AliasCache.end()) &&
 1631         assert(!Pair.second && "Entry must have existed");
 1847       assert(!ItInsPair.second && "Entry must have existed");
 1864       assert(!Pair.second && "Entry must have existed");
 1880       assert(!Pair.second && "Entry must have existed");
 1892       assert(!Pair.second && "Entry must have existed");
 1901   assert(!Pair.second && "Entry must have existed");
lib/Analysis/BlockFrequencyInfo.cpp
  222   assert(BFI && "Expected analysis to be available");
  227   assert(BFI && "Expected analysis to be available");
  234   assert(BFI && "Expected analysis to be available");
lib/Analysis/BlockFrequencyInfoImpl.cpp
   54   assert(N < 16);
  113   assert(Weight && "invalid weight");
  114   assert(Weight <= RemWeight);
  125   assert(Amount && "invalid weight of 0");
  130   assert(!(DidOverflow && IsOverflow) && "unexpected repeated overflow");
  141   assert(OtherW.TargetNode.isValid());
  146   assert(W.Type == OtherW.Type);
  147   assert(W.TargetNode == OtherW.TargetNode);
  148   assert(OtherW.Amount && "Expected non-zero weight");
  207   assert(Shift >= 0);
  208   assert(Shift < 64);
  244     assert(Total == std::accumulate(Weights.begin(), Weights.end(), UINT64_C(0),
  260     assert(W.TargetNode.isValid());
  262     assert(W.Amount <= UINT32_MAX);
  267   assert(Total <= UINT32_MAX);
  332       assert((!OuterLoop || !OuterLoop->isIrreducible()) &&
  343     assert(OuterLoop && OuterLoop->isIrreducible() && !isLoopHeader(Resolved) &&
  444     assert(OuterLoop && "backedge or exit outside of loop");
  454     assert(W.Type == Weight::Exit);
  600   assert(Node.isValid() && "Expected valid node");
  601   assert(Node.Index < Freqs.size() && "Expected legal index");
  708   assert(Headers.size() >= 2 &&
  777   assert((OuterLoop == nullptr) == (Insert == Loops.begin()));
  806   assert(Loop.isIrreducible() && "this only makes sense on irreducible loops");
  836     assert(W.Type == Weight::Local && "all weights should be local");
  847     assert(W.Type == Weight::Local && "all weights should be local");
lib/Analysis/BranchProbabilityInfo.cpp
  175   assert(!PostDominatedByColdCall.count(BB));
  213   assert(TI->getNumSuccessors() > 1 && "expected more than one successor!");
  214   assert(!isa<InvokeInst>(TI) &&
  256   assert(TI->getNumSuccessors() > 1 && "expected more than one successor!");
  265   assert(TI->getNumSuccessors() < UINT32_MAX && "Too many successors");
  285     assert(Weight->getValue().getActiveBits() <= 32 &&
  294   assert(Weights.size() == TI->getNumSuccessors() && "Checked above");
  308   assert(WeightSum <= UINT32_MAX &&
  359   assert(TI->getNumSuccessors() > 1 && "expected more than one successor!");
  360   assert(!isa<InvokeInst>(TI) &&
  415   assert(CI->getOperand(1)->getType()->isPointerTy());
  444   assert(getSCCNum(BB, SccI) == SccNum);
  840   assert(LastF && "Cannot print prior to running over a function");
  954   assert(PostDominatedByUnreachable.empty());
  955   assert(PostDominatedByColdCall.empty());
lib/Analysis/CFG.cpp
   79     assert(i != e && "Didn't find edge?");
   90   assert(SuccNum < TI->getNumSuccessors() && "Illegal edge specification!");
   96   assert(TI->isTerminator() && "Must be a terminator to have successors!");
   99   assert(find(predecessors(Dest), TI->getParent()) != pred_end(Dest) &&
  105   assert(I != E && "No preds, but we have an edge to the block?");
  208   assert(A->getParent() == B->getParent() &&
  222   assert(A->getParent()->getParent() == B->getParent()->getParent() &&
lib/Analysis/CFLAndersAliasAnalysis.cpp
  172     assert(From != To);
  212     assert(LHS.DerefLevel > 0 && RHS.DerefLevel > 0);
  511   assert(V != nullptr);
  522   assert(LHS && RHS);
  611     assert(ValueInfo.getNumLevels() > 0);
  643   assert(NodeInfo != nullptr);
  814   assert(InsertPair.second &&
  833     assert(Iter != Cache.end());
  834     assert(Iter->second.hasValue());
  867     assert(!parentFunctionOfValue(ValB) || parentFunctionOfValue(ValB) == Fn);
  870   assert(Fn != nullptr);
lib/Analysis/CFLGraph.h
   86       assert(Level < Levels.size());
   90       assert(Level < Levels.size());
  113     assert(N.Val != nullptr);
  122     assert(Info != nullptr);
  128     assert(FromInfo != nullptr);
  130     assert(ToInfo != nullptr);
  145     assert(Info != nullptr);
  205       assert(Val != nullptr && Val->getType()->isPointerTy());
  220       assert(From != nullptr && To != nullptr);
  232       assert(From != nullptr && To != nullptr);
  377       assert(Fns.size() > 0);
  387         assert(Fn->arg_size() <= Call.arg_size());
  394         assert(Summary != nullptr);
lib/Analysis/CFLSteensAliasAnalysis.cpp
  164     assert(RetVal != nullptr);
  165     assert(RetVal->getType()->isPointerTy());
  196     assert(ValueInfo.getNumLevels() > 0);
  229   assert(InsertPair.second &&
  251     assert(Iter != Cache.end());
  252     assert(Iter->second.hasValue());
  287     assert((!MaybeFnB || MaybeFnB == MaybeFnA) &&
  293   assert(Fn != nullptr);
  295   assert(MaybeInfo.hasValue());
lib/Analysis/CGSCCPassManager.cpp
   96     assert(C->begin() != C->end() && "Cannot have an empty SCC!");
  229   assert(FAMProxy && "The CGSCC pass manager requires that the FAM module "
  383   assert(C != &*NewSCCRange.begin() &&
  386   assert(G.lookupSCC(N) == C && "Failed to update current SCC!");
  410     assert(C != &NewC && "No need to re-visit the current SCC!");
  411     assert(OldC != &NewC && "Already handled the original SCC!");
  461           assert(E && "No function transformations should introduce *new* "
  466           assert(Inserted && "We should never visit a function twice.");
  483     assert(E && "No function transformations should introduce *new* ref "
  488     assert(Inserted && "We should never visit a function twice.");
  556     assert(G.lookupSCC(N) == C && "Changed the SCC when splitting RefSCCs!");
  558     assert(G.lookupRefSCC(N) == RC && "Failed to update current RefSCC!");
  563     assert(NewRefSCCs.front() == RC &&
  567       assert(NewRC != RC && "Should not encounter the current RefSCC further "
  585       assert(RC->isAncestorOf(TargetRC) &&
  614       assert(RC->isAncestorOf(TargetRC) &&
  633             assert(MergedC != &TargetC && "Cannot merge away the target SCC!");
  655       assert(G.lookupSCC(N) == C && "Failed to update current SCC!");
  697   assert(!UR.InvalidatedSCCs.count(C) && "Invalidated the current SCC!");
  698   assert(!UR.InvalidatedRefSCCs.count(RC) && "Invalidated the current RefSCC!");
  699   assert(&C->getOuterRefSCC() == RC && "Current SCC not in current RefSCC!");
lib/Analysis/CallGraph.cpp
  121   assert(CGN->empty() && "Cannot remove function from call "
  135   assert(FunctionMap.count(From) && "No CallGraphNode for function!");
  136   assert(!FunctionMap.count(To) &&
  152   assert((!F || F->getParent() == &M) && "Function not in current module!");
  188     assert(I != CalledFunctions.end() && "Cannot find callsite to remove!");
  215     assert(I != CalledFunctions.end() && "Cannot find callee to remove!");
  232     assert(I != CalledFunctions.end() && "Cannot find callsite to remove!");
lib/Analysis/CallGraphSCCPass.cpp
   95     assert(N < PassVector.size() && "Pass number out of range!");
  166   assert(PM->getPassManagerType() == PMT_FunctionPassManager &&
  247         assert(!CheckingMode &&
  270       assert(!Calls.count(I->first) &&
  318           assert(!CheckingMode &&
  343         assert(!CheckingMode &&
  378     assert(Calls.empty() && "Dangling pointers found in call sites map");
  516       assert(PM->getPassManagerType() == PMT_FunctionPassManager &&
  531       assert(PM->getPassManagerType() == PMT_FunctionPassManager &&
  548   assert(Old != New && "Should not replace node with self");
  550     assert(i != Nodes.size() && "Node not in SCC");
  574   assert(!PMS.empty() && "Unable to handle Call Graph Pass");
  581     assert(!PMS.empty() && "Unable to create Call Graph Pass Manager");
lib/Analysis/CaptureTracking.cpp
  177   assert(!isa<GlobalValue>(V) &&
  206   assert(!isa<GlobalValue>(V) &&
  229   assert(V->getType()->isPointerTy() && "Capture is for pointers only!");
lib/Analysis/CodeMetrics.cpp
   54     assert(Visited.count(V) &&
  104     assert(I->getParent()->getParent() == F &&
lib/Analysis/ConstantFolding.cpp
   96   assert(CastInst::castIsValid(Instruction::BitCast, C, DestTy) &&
  380   assert(ByteOffset <= DL.getTypeAllocSize(C->getType()) &&
  477       assert(BytesWritten <= EltSize && "Not indexing into this element?");
  803   assert(Ptr->getType()->isPointerTy() && "Not a pointer type");
  851           assert((!CE || CE->getType() == IntPtrTy) &&
  999   assert(C->getType()->getPointerElementType() == Ty &&
 1112   assert(isa<ConstantVector>(C));
 1291   assert(Instruction::isUnaryOp(Opcode));
 1299   assert(Instruction::isBinaryOp(Opcode));
 1309   assert(Instruction::isCast(Opcode));
 1628   assert(ResultWidth <= 64 &&
 1690   assert(Operands.size() == 1 && "Wrong number of operands.");
 1981       assert(status == APFloat::opOK && !lost &&
 2029   assert(Operands.size() == 2 && "Wrong number of operands.");
 2205       assert(C1 && "Must be constant int");
 2282   assert(Operands.size() == 3 && "Wrong number of operands.");
 2318           assert(Scale < Width && "Illegal scale.");
lib/Analysis/DDG.cpp
   30   assert(IList.empty() && "Expected the IList to be empty on entry.");
   81   assert(InstList.empty() && "Expected empty list.");
   87   assert(((getKind() == NodeKind::SingleInstruction && InstList.size() == 1) ||
   94   assert(((getKind() == NodeKind::SingleInstruction && InstList.size() == 1) ||
  171   assert(!Root && "Root node is already added. No more nodes can be added.");
lib/Analysis/DependenceAnalysis.cpp
  264   assert(0 < Level && Level <= Levels && "Level out of range");
  271   assert(0 < Level && Level <= Levels && "Level out of range");
  280   assert(0 < Level && Level <= Levels && "Level out of range");
  288   assert(0 < Level && Level <= Levels && "Level out of range");
  296   assert(0 < Level && Level <= Levels && "Level out of range");
  303   assert(0 < Level && Level <= Levels && "Level out of range");
  314   assert(Kind == Point && "Kind should be Point");
  322   assert(Kind == Point && "Kind should be Point");
  330   assert((Kind == Line || Kind == Distance) &&
  339   assert((Kind == Line || Kind == Distance) &&
  348   assert((Kind == Line || Kind == Distance) &&
  357   assert(Kind == Distance && "Kind should be Distance");
  364   assert((Kind == Distance || Kind == Line || Kind == Point) &&
  435   assert(!Y->isPoint() && "Y must not be a Point");
  473   assert(!(X->isPoint() && Y->isPoint()) &&
  559   assert(!(X->isLine() && Y->isPoint()) && "This case should never occur");
  819       assert(SrcTy == DstTy && "This function only unify integer types and "
  835   assert(widestWidthSeen > 0);
  844       assert(SrcTy == DstTy && "This function only unify integer types and "
 1158   assert(0 < Level && Level <= CommonLevels && "level out of range");
 1291   assert(0 < Level && Level <= CommonLevels && "Level out of range");
 1315     assert(ConstCoeff &&
 1319   assert(SE->isKnownPositive(ConstCoeff) && "ConstCoeff should be positive");
 1504   assert(0 < Level && Level <= CommonLevels && "Level out of range");
 1716   assert(0 < Level && Level <= MaxLevels && "Level out of range");
 1825   assert(0 < Level && Level <= SrcLevels && "Level out of range");
 2166     assert(CurLoop == DstAddRec->getLoop() &&
 2383         assert(!Constant && "Surprised to find multiple constants");
 3135     assert(Charlie.srem(Beta) == 0 && "C should be evenly divisible by B");
 3150     assert(Charlie.srem(Alpha) == 0 && "C should be evenly divisible by A");
 3164     assert(Charlie.srem(Alpha) == 0 && "C should be evenly divisible by A");
 3266   assert(isLoadOrStore(Src) && "instruction is not load or store");
 3267   assert(isLoadOrStore(Dst) && "instruction is not load or store");
 3421   assert(isLoadOrStore(Src) && "instruction is not load or store");
 3422   assert(isLoadOrStore(Dst) && "instruction is not load or store");
 3834   assert(Dep.isSplitable(SplitLevel) &&
 3838   assert(Src->mayReadFromMemory() || Src->mayWriteToMemory());
 3839   assert(Dst->mayReadFromMemory() || Dst->mayWriteToMemory());
 3840   assert(isLoadOrStore(Src));
 3841   assert(isLoadOrStore(Dst));
 3844   assert(underlyingObjectsAlias(AA, F->getParent()->getDataLayout(),
 3932         assert(SplitIter != nullptr);
lib/Analysis/DependenceGraphBuilder.cpp
   40   assert(IMap.empty() && "Expected empty instruction map at start");
lib/Analysis/DivergenceAnalysis.cpp
  101   assert(isa<Instruction>(DivVal) || isa<Argument>(DivVal));
  102   assert(!isAlwaysUniform(DivVal) && "cannot be a divergent");
  114     assert(BranchTerm->isConditional());
  191   assert(DivLoop && "loopHeader is not actually part of a loop");
  212     assert(!DivLoop->contains(UserBlock) &&
  317     assert(BranchLoop);
  355     assert(BranchLoop);
lib/Analysis/DomTreeUpdater.cpp
   67     assert(I < E && "Iterator range invalid; there should be DomTree updates.");
   88     assert(I < E &&
  109     assert(BB->getInstList().size() == 1 &&
  216   assert(DelBB && "Invalid push_back of nullptr DelBB.");
  217   assert(pred_empty(DelBB) && "DelBB has one or more predecessors.");
  304   assert(DT && "Invalid acquisition of a null DomTree");
  311   assert(PDT && "Invalid acquisition of a null PostDomTree");
  320   assert(isUpdateValid({DominatorTree::Insert, From, To}) &&
  366   assert(isUpdateValid({DominatorTree::Delete, From, To}) &&
  424   assert(B <= E && "Iterator out of range.");
  490     assert(PendUpdates.begin() <= I && I <= PendUpdates.end() &&
  500     assert(PendUpdates.begin() <= I && I <= PendUpdates.end() &&
lib/Analysis/GlobalsModRef.cpp
  473     assert(!SCC.empty() && "SCC with no functions?");
  491     assert(!SCC.empty() && "SCC with no functions?");
  956     assert(H.GAR == &Arg);
lib/Analysis/IVDescriptors.cpp
  463   assert((isa<ICmpInst>(I) || isa<FCmpInst>(I) || isa<SelectInst>(I)) &&
  780   assert(IK != IK_NoInduction && "Not an induction");
  784   assert(StartValue && "StartValue is null");
  785   assert((IK != IK_PtrInduction || StartValue->getType()->isPointerTy()) &&
  787   assert((IK != IK_IntInduction || StartValue->getType()->isIntegerTy()) &&
  791   assert((!getConstIntStepValue() || !getConstIntStepValue()->isZero()) &&
  794   assert((IK != IK_PtrInduction || getConstIntStepValue()) &&
  796   assert((IK == IK_FpInduction || Step->getType()->isIntegerTy()) &&
  799   assert((IK != IK_FpInduction || Step->getType()->isFloatingPointTy()) &&
  801   assert((IK != IK_FpInduction ||
  832   assert(Phi->getType()->isFloatingPointTy() && "Unexpected Phi type");
  846     assert(TheLoop->contains(Phi->getIncomingBlock(1)) &&
  917   assert(CastInsts.empty() && "CastInsts is expected to be empty.");
  919   assert(PSE.getSCEV(PN) == AR && "Unexpected phi node SCEV expression");
 1077   assert(PhiTy->isPointerTy() && "The PHI must be a pointer");
lib/Analysis/IndirectCallPromotionAnalysis.cpp
   80     assert(Count <= RemainingCount);
lib/Analysis/InlineCost.cpp
  248     assert(UpperBound > 0 && UpperBound <= INT_MAX && "invalid upper bound");
  390   assert(IntPtrWidth == Offset.getBitWidth());
 1676     assert(V->getType()->isPointerTy() && "Unexpected operand type!");
 1741   assert(NumInstructions == 0);
 1742   assert(NumVectorInstructions == 0);
 1750   assert(Threshold >= 0);
 1751   assert(SingleBBBonus >= 0);
 1752   assert(VectorBonus >= 0);
 1790     assert(CAI != Call.arg_end());
lib/Analysis/InstructionPrecedenceTracking.cpp
   47     assert(FirstSpecialInsts.find(BB) != FirstSpecialInsts.end() && "Must be!");
   85       assert(It->second == &Insn &&
   90   assert(It->second == nullptr &&
  142     assert(cast<LoadInst>(Insn)->isVolatile() &&
  147     assert(cast<StoreInst>(Insn)->isVolatile() &&
lib/Analysis/InstructionSimplify.cpp
  233   assert(Instruction::isAssociative(Opcode) && "Not an associative operation!");
  340     assert(isa<SelectInst>(RHS) && "No select instruction operand!");
  413   assert(isa<SelectInst>(LHS) && "Not comparing with a select instruction!");
  497     assert(isa<PHINode>(RHS) && "No PHI instruction operand!");
  537   assert(isa<PHINode>(LHS) && "Not comparing with a phi instruction!");
  657   assert(V->getType()->isPtrOrPtrVectorTy());
 2729         assert(B == D);
 3185   assert(CmpInst::isIntPredicate(Pred) && "Not an integer compare!");
 3195   assert(!isa<UndefValue>(LHS) && "Unexpected icmp undef,%X");
 3480   assert(CmpInst::isFPPredicate(Pred) && "Not an FP compare!");
 3505   assert((FCmpInst::isOrdered(Pred) || FCmpInst::isUnordered(Pred)) &&
 3558       assert(!C->isNaN() && "Unexpected NaN constant!");
 4378   assert(MaskNumElts == Indices.size() &&
 5486   assert(I != SimpleV && "replaceAndRecursivelySimplify(X,X) is not valid!");
 5487   assert(SimpleV && "Must provide a simplified value.");
lib/Analysis/IntervalPartition.cpp
   73   assert(I != intervals_end(&F) && "No intervals in function!?!?!");
   95   assert(IP.getRootInterval() && "Cannot operate on empty IntervalPartitions!");
   99   assert(I != intervals_end(IP) && "No intervals in interval partition!?!?!");
lib/Analysis/LazyCallGraph.cpp
   73   assert(!Edges && "Must not have already populated the edges for this node!");
  136   assert(F != &NewF && "Must not replace a function with itself!");
  233   assert(OuterRefSCC && "Can't have a null RefSCC!");
  234   assert(!Nodes.empty() && "Can't have an empty SCC!");
  237     assert(N && "Can't have a null node!");
  238     assert(OuterRefSCC->G->lookupSCC(*N) == this &&
  240     assert(N->DFSNumber == -1 &&
  242     assert(N->LowLink == -1 &&
  245       assert(E.getNode().isPopulated() && "Can't have an unpopulated node!");
  307   assert(G && "Can't have a null graph!");
  308   assert(!SCCs.empty() && "Can't have an empty SCC!");
  313     assert(C && "Can't have a null SCC!");
  315     assert(&C->getOuterRefSCC() == this &&
  318     assert(Inserted && "Found a duplicate SCC!");
  320     assert(IndexIt != SCCIndices.end() &&
  328     assert(C && "Can't have a null SCC in the indices!");
  329     assert(SCCSet.count(C) && "Found an index for an SCC not in the RefSCC!");
  330     assert(SCCs[i] == C && "Index doesn't point to SCC!");
  342           assert(SCCIndices.find(&TargetSCC)->second <= i &&
  466   assert(SourceIdx < TargetIdx && "Cannot have equal indices here!");
  485     assert(SourceI > (SCCs.begin() + SourceIdx) &&
  487     assert(*std::prev(SourceI) == &TargetSCC &&
  495   assert(SCCs[TargetIdx] == &TargetSCC &&
  498   assert(SCCs[SourceIdx] == &SourceSCC &&
  517     assert(SCCs[TargetIdx] == &TargetSCC &&
  532   assert(!(*SourceN)[TargetN].isCall() && "Must start with a ref edge!");
  654     assert(C != &TargetSCC &&
  680   assert((*SourceN)[TargetN].isCall() && "Must start with a call edge!");
  689   assert(G->lookupRefSCC(SourceN) == this &&
  691   assert(G->lookupRefSCC(TargetN) == this &&
  693   assert(G->lookupSCC(SourceN) != G->lookupSCC(TargetN) &&
  702   assert((*SourceN)[TargetN].isCall() && "Must start with a call edge!");
  711   assert(G->lookupRefSCC(SourceN) == this &&
  713   assert(G->lookupRefSCC(TargetN) == this &&
  717   assert(G->lookupSCC(SourceN) == &TargetSCC && "Source and Target must be in "
  763     assert(DFSStack.empty() &&
  765     assert(PendingSCCStack.empty() &&
  770       assert(RootN->DFSNumber == -1 &&
  791           assert(!G->SCCMap.count(&ChildN) &&
  829         assert(ChildN.LowLink > 0 && "Must have a positive low-link number!");
  889   assert(!(*SourceN)[TargetN].isCall() && "Must start with a ref edge!");
  891   assert(G->lookupRefSCC(SourceN) == this && "Source must be in this RefSCC.");
  892   assert(G->lookupRefSCC(TargetN) != this &&
  911   assert((*SourceN)[TargetN].isCall() && "Must start with a call edge!");
  913   assert(G->lookupRefSCC(SourceN) == this && "Source must be in this RefSCC.");
  914   assert(G->lookupRefSCC(TargetN) != this &&
  933   assert(G->lookupRefSCC(SourceN) == this && "Source must be in this RefSCC.");
  934   assert(G->lookupRefSCC(TargetN) == this && "Target must be in this RefSCC.");
  949   assert(G->lookupRefSCC(SourceN) == this && "Source must be in this RefSCC.");
  951   assert(G->lookupRefSCC(TargetN) != this &&
  966   assert(G->lookupRefSCC(TargetN) == this && "Target must be in this RefSCC.");
  968   assert(&SourceC != this && "Source must not be in this RefSCC.");
  985   assert(SourceIdx < TargetIdx &&
 1058     assert(RC != this && "We're merging into the target RefSCC, so it "
 1109   assert(G->lookupRefSCC(SourceN) == this &&
 1111   assert(G->lookupRefSCC(TargetN) != this &&
 1124   assert(Removed && "Target not in the edge set for this caller?");
 1148     assert(!(*SourceN)[*TargetN].isCall() &&
 1153     assert(Removed && "Target not in the edge set for this caller?");
 1195     assert(DFSStack.empty() &&
 1197     assert(PendingRefSCCStack.empty() &&
 1203       assert(RootN->DFSNumber == -1 &&
 1218       assert(N->DFSNumber != 0 && "We should always assign a DFS number "
 1245         assert(ChildN.LowLink != 0 &&
 1259         assert(!DFSStack.empty() &&
 1302     assert(DFSStack.empty() && "Didn't flush the entire DFS stack!");
 1303     assert(PendingRefSCCStack.empty() && "Didn't flush all pending nodes!");
 1306   assert(PostOrderNumber > 1 &&
 1336       assert(N.LowLink == SCCNumber &&
 1370   assert(G->lookupRefSCC(SourceN) == this && "Source must be in this RefSCC.");
 1452   assert(G->lookupRefSCC(N) == this &&
 1455   assert(G->NodeMap.find(&NewF) == G->NodeMap.end() &&
 1464   assert(&OldF != &NewF && "Cannot replace a function with itself!");
 1465   assert(OldF.use_empty() &&
 1477   assert(SCCMap.empty() &&
 1484   assert(SCCMap.empty() &&
 1489   assert(Removed && "Target not in the edge set for this caller?");
 1495   assert(F.use_empty() &&
 1500   assert(!isLibFunction(F) &&
 1524   assert(CI != SCCMap.end() &&
 1533   assert(C.size() == 1 && "Dead functions must be in a singular SCC");
 1534   assert(RC.size() == 1 && "Dead functions must be in a singular RefSCC");
 1582     assert(DFSStack.empty() &&
 1584     assert(PendingSCCStack.empty() &&
 1589       assert(RootN->DFSNumber == -1 &&
 1626         assert(ChildN.LowLink > 0 && "Must have a positive low-link number!");
 1667   assert(RC.SCCs.empty() && "Already built SCCs!");
 1668   assert(RC.SCCIndices.empty() && "Already mapped SCC indices!");
 1671     assert(N->LowLink >= (*Nodes.begin())->LowLink &&
 1705   assert(RefSCCIndices.empty() && "Already mapped RefSCC indices!");
 1733         assert(Inserted && "Cannot already have this RefSCC in the index map!");
lib/Analysis/LazyValueInfo.cpp
  193           assert(It != ValueCache.end() && "Val was just added to the map!");
  484         assert(!DisabledDT && "Both DT and DisabledDT are not nullptr!");
  493         assert(!DT && "Both DT and DisabledDT are not nullptr!");
  539     assert(BlockValueSet.count(e) && "Stack value should be in BlockValueSet!");
  543       assert(BlockValueStack.back() == e && "Nothing should have been pushed!");
  544       assert(TheCache.hasCachedValueInfo(e.second, e.first) &&
  555       assert(BlockValueStack.back() != e && "Stack should have been pushed!");
  703   assert(Val->getType()->isPointerTy());
  723     assert(isa<Argument>(Val) && "Unknown live-in to the entry block");
  775   assert(!Result.isOverdefined());
  812   assert(!Result.isOverdefined() && "Possible PHI in entry block?");
  960         assert(A->getType() == B->getType());
 1085   assert(BO->getOperand(0)->getType()->isSized() &&
 1326   assert(Cond && "precondition");
 1351   assert(isOperationFoldable(Usr) && "Precondition");
 1355     assert(CI->getOperand(0) == Op && "Operand 0 isn't Op");
 1364     assert((Op0Match || Op1Match) &&
 1389       assert(BI->getSuccessor(!isTrueDest) == BBTo &&
 1408         assert(Result.isOverdefined() && "Result isn't overdefined");
 1464     assert((Condition == Val || ValUsesConditionAndMayBeFoldable) &&
 1556   assert(BlockValueStack.empty() && BlockValueSet.empty());
 1596     assert(WasFastQuery && "More work to do after problem solved?");
 1617     assert(DL && "getCache() called with a null DataLayout");
 1716   assert(V->getType()->isIntegerTy());
 1727   assert(!(Result.isConstant() && isa<ConstantInt>(Result.getConstant())) &&
 1766   assert(!(Result.isConstant() && isa<ConstantInt>(Result.getConstant())) &&
lib/Analysis/LegacyDivergenceAnalysis.cpp
  242   assert(PDT.properlyDominates(End, Start) &&
lib/Analysis/Lint.cpp
  741   assert(!F.isDeclaration() && "Cannot lint external functions");
lib/Analysis/Loads.cpp
   44     assert(APAlign.isPowerOf2() && "must be a power of 2!");
   77       assert(Ty->isSized() && "must be sized");
  239   assert(SE.isLoopInvariant(StartS, L) && "implied by addrec definition");
lib/Analysis/LoopAccessAnalysis.cpp
  204     assert(AR && "Invalid addrec expression");
  251   assert(Checks.empty() && "Checks is not empty");
  875           assert(((IsReadOnlyPtr && UseDeferred) || IsWrite ||
  994   assert(Ty->isPointerTy() && "Unexpected non-ptr");
 1103   assert(llvm::all_of(
 1412   assert(Stride > 1 && "The stride must be greater than 1");
 1413   assert(TypeByteSize > 0 && "The type size in byte must be non-zero");
 1414   assert(Distance > 0 && "The distance must be non-zero");
 1445   assert (AIdx < BIdx && "Must pass arguments in program order");
 1544   assert(Val.isStrictlyPositive() && "Expect a positive value");
 1675             assert(*I1 != *I2);
 2080   assert(TheLoop->contains(BB) && "Unknown block used");
 2089   assert(!Report && "Multiple reports generated");
 2226     assert((AS0 == B.End->getType()->getPointerAddressSpace()) &&
lib/Analysis/LoopCacheAnalysis.cpp
   56   assert(!Loops.empty() && "Expecting a non-empy loop vector");
   62     assert(Loops.size() == 1 && "Expecting a single loop");
   80   assert(AR->getLoop() && "AR should have a loop");
  131   assert((isa<StoreInst>(StoreOrLoadInst) || isa<LoadInst>(StoreOrLoadInst)) &&
  143   assert(IsValid && "Expecting a valid reference");
  200   assert(IsValid && "Expecting a valid reference");
  256   assert(IsValid && "Expecting a valid reference");
  308   assert(Subscripts.empty() && "Subscripts should be empty");
  309   assert(Sizes.empty() && "Sizes should be empty");
  310   assert(!IsValid && "Should be called once from the constructor");
  363   assert(Addr != nullptr && "Expecting either a load or a store instruction");
  364   assert(SE.isSCEVable(Addr->getType()) && "Addr should be SCEVable");
  400   assert(isa<SCEVAddRecExpr>(LastSubscript) &&
  419   assert(AR->getLoop() && "AR should have a loop");
  458   assert(!Loops.empty() && "Expecting a non-empty loop vector.");
  498     assert((std::find_if(LoopCosts.begin(), LoopCosts.end(),
  512   assert(RefGroups.empty() && "Reference groups should be empty");
  516   assert(InnerMostLoop != nullptr && "Expecting a valid innermost loop");
  606   assert(!RG.empty() && "Reference group should have at least one member.");
lib/Analysis/LoopInfo.cpp
  127   assert(PI != pred_end(H) && "Loop must have at least one backedge!");
  142   assert(Incoming && Backedge && "expected non-null incoming and backedges");
  230   assert(Latch && "Expecting valid latch");
  233   assert(BI && BI->isConditional() && "Expecting conditional latch branch");
  236   assert(LatchCmpInst &&
  295   assert(Header && "Expected a valid loop header");
  368   assert(Preheader && Latch &&
  389   assert(GuardBB->getTerminator() && "Expecting valid guard terminator");
  514   assert((!LoopID || LoopID->getNumOperands() > 0) &&
  516   assert((!LoopID || LoopID->getOperand(0) == LoopID) &&
  549       assert(isValidAsAccessGroup(AccGroup) &&
  568             assert(isValidAsAccessGroup(AG) && "Item must be an access group");
  574             assert(isValidAsAccessGroup(AccGroup) &&
  706         assert((NL != &Unloop && (!NL || NL->contains(&Unloop))) &&
  712         assert((FoundIB || Unloop.contains(L)) && "uninitialized successor");
  720     assert(NIters < Unloop.getNumBlocks() && "runaway iterative algorithm");
  732         assert(NL != &Unloop && (!NL || NL->contains(&Unloop)) &&
  757       assert(OldParent && "new loop is not an ancestor of the original");
  769     assert(SubloopParents.count(Subloop) && "DFS failed to visit subloop");
  794       assert(Subloop && "subloop is not an ancestor of the original loop");
  802     assert(!Subloop && "subloop blocks must have a successor");
  813       assert((FoundIB || !DFS.hasPostorder(*I)) && "should have seen IB");
  822       assert(L->getParentLoop() == &Unloop && "cannot skip into nested loops");
  858   assert(!Unloop->isInvalid() && "Loop has already been erased!");
  880       assert(I != end() && "Couldn't find loop");
  908     assert(I != ParentLoop->end() && "Couldn't find loop");
  982   assert(LoopID->getNumOperands() > 0 && "requires at least one operand");
  983   assert(LoopID->getOperand(0) == LoopID && "invalid loop id");
lib/Analysis/LoopPass.cpp
  144   assert((&L == CurrentLoop || CurrentLoop->contains(&L)) &&
  149   assert(LQ.back() == CurrentLoop && "Loop queue back isn't the current loop!");
  366     assert (!PMS.empty() && "Unable to create Loop Pass Manager");
lib/Analysis/LoopUnrollAnalyzer.cpp
  136   assert(CV && "Constant expected.");
lib/Analysis/MemDepPrinter.cpp
   68       assert(dep.isUnknown() && "unexpected dependence type");
  118       assert( (isa<LoadInst>(Inst) || isa<StoreInst>(Inst) ||
lib/Analysis/MemoryBuiltins.cpp
  358   assert(isMallocLikeFn(CI, TLI) && "getMallocType and not malloc call");
  402   assert(isMallocLikeFn(CI, TLI) && "getMallocArraySize and not malloc call");
  506   assert(ObjectSize->getIntrinsicID() == Intrinsic::objectsize &&
  921   assert(I.isArrayAllocation());
lib/Analysis/MemoryDependenceAnalysis.cpp
  103   assert(InstIt != ReverseMap.end() && "Reverse map out of sync?");
  105   assert(Found && "Invalid reverse map!");
  350   assert(InvariantGroupDependency.isUnknown() &&
  381     assert(Other && "Must call it with not null instruction");
  391     assert(Ptr && !isa<GlobalValue>(Ptr) &&
  779   assert(std::is_sorted(Cache.begin(), Cache.begin() + Count) &&
  786   assert(getDependency(QueryCall).isNonLocal() &&
  919   assert(FromBB);
  921   assert(Loc.Ptr->getType()->isPointerTy() &&
 1004     assert(ExistingResult->getResult().getInst()->getParent() == BB &&
 1036   assert(Inst && "Didn't depend on anything?");
 1258       assert(Visited.count(BB) && "Should check 'visited' before adding to WL");
 1461       assert((GotWorklistLimit || I.getResult().isNonLocal() ||
 1471     assert((foundBlock || GotWorklistLimit) && "Current block not in cache?");
 1515     assert(Target->getParent() == PInfo[i].getBB());
 1591     assert(!ReverseDepIt->second.empty() && !RemInst->isTerminator() &&
 1595       assert(InstDependingOnRemInst != RemInst &&
 1601       assert(NewDirtyVal.getInst() &&
 1622       assert(I != RemInst && "Already removed NonLocalDep info for RemInst");
 1659       assert(P.getPointer() != RemInst &&
 1696   assert(!NonLocalDeps.count(RemInst) && "RemInst got reinserted?");
 1707     assert(DepKV.first != D && "Inst occurs in data structures");
 1708     assert(DepKV.second.getInst() != D && "Inst occurs in data structures");
 1712     assert(DepKV.first.getPointer() != D && "Inst occurs in NLPD map key");
 1714       assert(Entry.getResult().getInst() != D && "Inst occurs as NLPD value");
 1718     assert(DepKV.first != D && "Inst occurs in data structures");
 1721       assert(Entry.getResult().getInst() != D &&
 1726     assert(DepKV.first != D && "Inst occurs in data structures");
 1728       assert(Inst != D && "Inst occurs in data structures");
 1732     assert(DepKV.first != D && "Inst occurs in data structures");
 1734       assert(Inst != D && "Inst occurs in data structures");
 1738     assert(DepKV.first != D && "Inst occurs in rev NLPD map");
 1741       assert(P != ValueIsLoadPair(D, false) && P != ValueIsLoadPair(D, true) &&
lib/Analysis/MemoryLocation.cpp
  144       assert((ArgIdx == 0 || ArgIdx == 1) &&
  154       assert(ArgIdx == 1 && "Invalid argument index");
  166       assert(ArgIdx == 2 && "Invalid argument index");
  174       assert(ArgIdx == 0 && "Invalid argument index");
  182       assert(ArgIdx == 0 && "Invalid argument index");
  198     assert((ArgIdx == 0 || ArgIdx == 1) &&
lib/Analysis/MemorySSA.cpp
  153     assert(IsCall);
  158     assert(!IsCall);
  265   assert(DefInst && "Defining instruction not actually an instruction");
  526     assert(From->getNumOperands() && "Phi with no operands?");
  556     assert(!isa<MemoryUse>(Desc.Last) && "Uses don't exist in my world");
  557     assert(UpwardWalkLimit && "Need a valid walk limit");
  590     assert(isa<MemoryPhi>(Desc.Last) &&
  626     assert(!PausedSearches.empty() && "No searches to continue?");
  657         assert(isa<MemoryDef>(Query->OriginalAccess));
  665         assert(Res.Result != StopWhere && Res.Result != SkipStopWhere);
  688       assert(!MSSA.isLiveOnEntryDef(Res.Result) && "liveOnEntry is a clobber");
  746     assert(!Paths.empty() && NP >= &Paths.front() && NP <= &Paths.back() &&
  766     assert(Paths.empty() && VisitedPhis.empty() &&
  783       assert(!Paths.empty() && "Need a path to move");
  795       assert(!MSSA.isLiveOnEntryDef(Current) &&
  801       assert(all_of(TerminatedPaths, [&](const TerminatedPath &P) {
  816         assert(Iter != def_path_iterator());
  819         assert(CurNode.Last == Current);
  876         assert(DefChainEnd && "Failed to find dominating phi/liveOnEntry");
  897       assert(all_of(NewPaused,
  914     assert(all_of(R.OtherClobbers, [&](const TerminatedPath &P) {
 1104       assert(ReplacementDone && "Incomplete phi during partial rename");
 1140   assert(Root && "Trying to rename accesses in an unreachable block");
 1188   assert(!DT->isReachableFromEntry(BB) &&
 1337     assert(
 1404     assert(LocInfo.LowerBound < VersionStack.size() &&
 1406     assert(LocInfo.LastKill < VersionStack.size() &&
 1431           assert(UpperBound != 0);
 1678     assert(Point == Beginning &&
 1684     assert(Inserted && "Cannot move a Phi to a block that already has one");
 1692   assert(!getMemoryAccess(BB) && "MemoryPhi already exists for this BB");
 1704   assert(!isa<PHINode>(I) && "Cannot create a defined access for a PHI");
 1707     assert(NewAccess != nullptr && "Tried to create a memory access for a "
 1758     assert(Def == DefCheck && (Def || Use == UseCheck) && "Invalid template");
 1808   assert(MA->use_empty() &&
 1945       assert(ThisNumberIter != BlockNumbering.end() &&
 1949       assert(ThisNumber > LastNumber &&
 1955   assert(ValidBlocks.empty() &&
 1980       assert((!MA || (AL && (isa<MemoryUse>(MA) || DL))) &&
 1995     assert(AL->size() == ActualAccesses.size() &&
 1998     assert((DL || ActualDefs.size() == 0) &&
 2000     assert((!DL || DL->size() == ActualDefs.size()) &&
 2006       assert(&*ALI == *AAI && "Not the same accesses in the same order");
 2015         assert(&*DLI == *ADI && "Not the same defs in the same order");
 2033         assert(dominates(MP, U) && "Memory PHI does not dominate it's uses");
 2041         assert(dominates(MD, U) && "Memory Def does not dominate it's uses");
 2053     assert(isLiveOnEntryDef(Use) &&
 2056     assert(is_contained(Def->users(), Use) &&
 2099   assert(AL != nullptr && "Asking to renumber an empty block");
 2112   assert((DominatorBlock == Dominatee->getBlock()) &&
 2133   assert(DominatorNum != 0 && "Block was not numbered properly");
 2135   assert(DominateeNum != 0 && "Block was not numbered properly");
 2439     assert(isa<MemoryDef>(Q.OriginalAccess));
lib/Analysis/MemorySSAUpdater.cpp
  102         assert(Phi->operands().empty() && "Expected empty Phi");
  208   assert(Phi && "Can only remove concrete Phi.");
  263     assert((!Defs || (++Defs->begin() == Defs->end())) &&
  294   assert(i != -1 && "Should have found the basic block in the phi");
  491         assert(!isa<MemoryPhi>(FirstDef) &&
  495         assert(MSSA->dominates(NewDef, FirstDef) &&
  554       assert(DefMUDI && "Found MemoryUseOrDef with no Instruction.");
  559           assert(InsnDefining && "Defining instruction cannot be nullptr.");
  566           assert(DefIt != MSSA->getBlockDefs(DefMUD->getBlock())->begin() &&
  578   assert(InsnDefining && "Defining instruction cannot be nullptr.");
  660     assert(Phi && NewPhi && "Invalid Phi nodes.");
  684           assert(IncI && "Found MemoryUseOrDef with no Instruction.");
  688             assert(IncMUD &&
  708     assert(!MSSA->getWritableBlockAccesses(NewBlock) &&
  855         assert(Count == 1 && Pred && "Single predecessor expected.");
  935       assert(pred_size(BB) == AddedBlockSet.size() && "Duplicate edges added.");
  944       assert(AddedBlockSet.size() == 1 &&
  971     assert(!PrevBlockSet.empty() &&
  983       assert(DefPn != nullptr && "Unable to find last definition.");
 1034     assert(DT.getNode(BB)->getIDom() && "BB does not have valid idom");
 1036     assert(PrevIDom && "Previous IDom should exists");
 1038     assert(NewIDom && "BB should have a new valid idom");
 1039     assert(DT.dominates(NewIDom, PrevIDom) &&
 1072       assert(IDFPhi && "Phi must exist");
 1111                 assert(IDom && "Block must have a valid IDom.");
 1173   assert(Start->getParent() == To && "Incorrect Start instruction");
 1204   assert(MSSA->getBlockAccesses(To) == nullptr &&
 1214   assert(From->getUniquePredecessor() == To &&
 1239   assert(!MSSA->getWritableBlockAccesses(New) &&
 1245     assert(pred_size(New) == Preds.size() &&
 1249     assert(!Preds.empty() && "Must be moving at least one predecessor to the "
 1256       assert(PredsSet.size() == Preds.size() &&
 1274   assert(!MSSA->isLiveOnEntryDef(MA) &&
 1286     assert((NewDefTarget || MP->use_empty()) &&
 1344     assert(TI && "Basic block expected to have a terminator instruction");
 1424   assert(I->getParent() == InsertPt->getBlock() &&
 1434   assert(I->getParent() == InsertPt->getBlock() &&
lib/Analysis/ModuleSummaryAnalysis.cpp
  249   assert(F.hasName());
  329         assert(!CalledFunction && "Expected null called function in callsite for alias");
  342         assert(CalledFunction->hasName());
  504     assert(STy);
  543     assert(P.VTableOffset >= PrevOffset);
  622   assert(AliaseeVI && "Alias expects aliasee summary to be available");
  623   assert(AliaseeVI.getSummaryList().size() == 1 &&
  642   assert(PSI);
  689           assert(GV->isDeclaration() && "Def in module asm already has definition");
  769     assert(Summary && "Missing summary for global value");
  787     assert(GlobalList.second.SummaryList.size() == 1 &&
lib/Analysis/MustExecute.cpp
   50   assert(CurLoop != nullptr && "CurLoop can't be null");
   58   assert(Header == *CurLoop->getBlocks().begin() &&
   77   assert(CurLoop != nullptr && "CurLoop can't be null");
  121   assert(CurLoop->contains(CondExitBlock) && "meaning of exit block");
  150   assert(ExitBlock == BI->getSuccessor(1) && "implied by above");
  160   assert(Predecessors.empty() && "Garbage in predecessors set?");
  161   assert(CurLoop->contains(BB) && "Should only be called for loop blocks!");
  171     assert(CurLoop->contains(Pred) && "Should only reach loop blocks!");
  190   assert(CurLoop->contains(BB) && "Should only be called for loop blocks!");
  274   assert(CurLoop->contains(BB) && "Should only be called for loop blocks!");
  295   assert(CurLoop->contains(BB) && "Should only be called for loop blocks!");
  477   assert(PP->isTerminator() && "Expected a terminator!");
  510   assert(CurInst && "Cannot advance an end iterator!");
lib/Analysis/OrderedBasicBlock.cpp
   37   assert(!(LastInstFound == BB->end() && NextInstPos != 0) &&
   39   assert(A->getParent() == BB && "Instruction supposed to be in the block!");
   40   assert(B->getParent() == BB && "Instruction supposed to be in the block!");
   56   assert(II != IE && "Instruction not found?");
   57   assert((Inst == A || Inst == B) && "Should find A or B");
   67   assert(A->getParent() == B->getParent() &&
   69   assert(A->getParent() == BB && "Instructions must be in the tracked block!");
lib/Analysis/OrderedInstructions.cpp
   18   assert(InstA->getParent() == InstB->getParent() &&
lib/Analysis/PHITransAddr.cpp
  134   assert(!isa<PHINode>(I) && "Error, removing something that isn't an input");
  315   assert(DT || !MustDominate);
  316   assert(Verify() && "Invalid PHITransAddr!");
  322   assert(Verify() && "Invalid PHITransAddr!");
lib/Analysis/PhiValues.cpp
   52   assert(DepthMap.lookup(Phi) == 0);
   53   assert(NextDepthNumber != UINT_MAX);
   64       assert(DepthMap.lookup(PhiPhiOp) != 0);
  117     assert(Stack.empty());
  119   assert(DepthMap.lookup(PN) != 0);
lib/Analysis/PostDominators.cpp
   54     assert(DT.verify(PostDominatorTree::VerificationLevel::Full));
   56     assert(DT.verify(PostDominatorTree::VerificationLevel::Basic));
lib/Analysis/ProfileSummaryInfo.cpp
  108   assert((isa<CallInst>(Inst) || isa<InvokeInst>(Inst)) &&
  253   assert(ColdCountThreshold <= HotCountThreshold &&
lib/Analysis/RegionPass.cpp
  253     assert (!PMS.empty() && "Unable to create Region Pass Manager");
lib/Analysis/RegionPrinter.cpp
  231   assert(RI && "Argument must be non-null");
  241   assert(F && "Argument must be non-null");
  242   assert(!F->isDeclaration() && "Function must have an implementation");
lib/Analysis/ScalarEvolution.cpp
  448   assert(Op->getType()->isIntOrPtrTy() && Ty->isIntOrPtrTy() &&
  455   assert(Op->getType()->isIntOrPtrTy() && Ty->isIntOrPtrTy() &&
  462   assert(Op->getType()->isIntOrPtrTy() && Ty->isIntOrPtrTy() &&
  705       assert(LHead != RHead && "Two loops share the same header?");
  709         assert(DT.dominates(RHead, LHead) &&
  888     assert(Numerator && Denominator && "Uninitialized SCEV");
 1256   assert(getTypeSizeInBits(Op->getType()) > getTypeSizeInBits(Ty) &&
 1258   assert(isSCEVable(Ty) &&
 1639   assert(getTypeSizeInBits(Op->getType()) < getTypeSizeInBits(Ty) &&
 1641   assert(isSCEVable(Ty) &&
 1945   assert(getTypeSizeInBits(Op->getType()) < getTypeSizeInBits(Ty) &&
 1947   assert(isSCEVable(Ty) &&
 2199   assert(getTypeSizeInBits(Op->getType()) < getTypeSizeInBits(Ty) &&
 2201   assert(isSCEVable(Ty) &&
 2347   assert(CanAnalyze && "don't call from other places!");
 2409   assert(!(Flags & ~(SCEV::FlagNUW | SCEV::FlagNSW)) &&
 2411   assert(!Ops.empty() && "Cannot get empty add!");
 2416     assert(getEffectiveSCEVType(Ops[i]->getType()) == ETy &&
 2429     assert(Idx < Ops.size());
 2744       assert(DT.dominates(
 2910   assert(Flags == maskFlags(Flags, SCEV::FlagNUW | SCEV::FlagNSW) &&
 2912   assert(!Ops.empty() && "Cannot get empty mul!");
 2917     assert(getEffectiveSCEVType(Ops[i]->getType()) == ETy &&
 3160   assert(getEffectiveSCEVType(LHS->getType()) ==
 3189   assert(getEffectiveSCEVType(LHS->getType()) ==
 3416     assert(getEffectiveSCEVType(Operands[i]->getType()) == ETy &&
 3419     assert(isLoopInvariant(Operands[i], L) &&
 3551   assert(!Ops.empty() && "Cannot get empty (u|s)(min|max)!");
 3556     assert(getEffectiveSCEVType(Ops[i]->getType()) == ETy &&
 3575     assert(Idx < Ops.size());
 3661   assert(!Ops.empty() && "Reduced smax down to nothing!");
 3747     assert(cast<SCEVUnknown>(S)->getValue() == V &&
 3774   assert(isSCEVable(Ty) && "Type is not SCEVable!");
 3784   assert(isSCEVable(Ty) && "Type is not SCEVable!");
 3790   assert(Ty->isPointerTy() && "Unexpected non-pointer non-integer type!");
 3850       assert(ValueExprMap.count(VE.first));
 3900   assert(isSCEVable(V->getType()) && "Value is not SCEVable!");
 3932   assert(isSCEVable(V->getType()) && "Value is not SCEVable!");
 4046   assert(SrcTy->isIntOrPtrTy() && Ty->isIntOrPtrTy() &&
 4058   assert(SrcTy->isIntOrPtrTy() && Ty->isIntOrPtrTy() &&
 4070   assert(SrcTy->isIntOrPtrTy() && Ty->isIntOrPtrTy() &&
 4072   assert(getTypeSizeInBits(SrcTy) <= getTypeSizeInBits(Ty) &&
 4082   assert(SrcTy->isIntOrPtrTy() && Ty->isIntOrPtrTy() &&
 4084   assert(getTypeSizeInBits(SrcTy) <= getTypeSizeInBits(Ty) &&
 4094   assert(SrcTy->isIntOrPtrTy() && Ty->isIntOrPtrTy() &&
 4096   assert(getTypeSizeInBits(SrcTy) <= getTypeSizeInBits(Ty) &&
 4106   assert(SrcTy->isIntOrPtrTy() && Ty->isIntOrPtrTy() &&
 4108   assert(getTypeSizeInBits(SrcTy) >= getTypeSizeInBits(Ty) &&
 4136   assert(!Ops.empty() && "At least one operand must be!");
 4331         assert(BI->getSuccessor(0) != BI->getSuccessor(1) &&
 4692   assert(L && "Expecting an integer loop header phi");
 4835     assert(isLoopInvariant(Expr, L) && "Expr is expected to be invariant");
 4911     assert(isa<SCEVAddRecExpr>(Rewrite.first) && "Expected an AddRec");
 4912     assert(!(Rewrite.second).empty() && "Expected to find Predicates");
 4963   assert(L && L->getHeader() == PN->getParent());
 4964   assert(BEValueV && StartValueV);
 5031   assert(ValueExprMap.find_as(PN) == ValueExprMap.end() &&
 5248   assert(RightEdge.isSingleEdge() && "Follows from LeftEdge.isSingleEdge()");
 5292     assert(IDom && "At least the entry block should dominate PN");
 5520   assert(InsertPair.second && "Should insert a new key");
 5718       assert(SignHint == ScalarEvolution::HINT_RANGE_SIGNED &&
 5743         assert(Erased && "Failed to erase Phi properly?");
 5822   assert(!isa<SCEVCouldNotCompute>(MaxBECount) &&
 5868       assert(SE.getTypeSizeInBits(S->getType()) == BitWidth &&
 6088         assert(BI->isConditional() && "Only possibility!");
 6127     assert(InsertPair.second && "We just checked!");
 6536   assert(ExitingBlock && "Must pass a non-null exiting block!");
 6537   assert(L->isLoopExiting(ExitingBlock) &&
 6573   assert(ExitingBlock && "Must pass a non-null exiting block!");
 6574   assert(L->isLoopExiting(ExitingBlock) &&
 6685     assert(isLoopInvariant(BEExact, L) &&
 6909     assert(BECount != SE->getCouldNotCompute() && "Bad exit SCEV!");
 6910     assert(SE->DT.dominates(ENT.ExitingBlock, Latch) &&
 6919     assert((Preds || ENT.hasAlwaysTruePredicate()) &&
 6957   assert((isa<SCEVCouldNotCompute>(getMax()) || isa<SCEVConstant>(getMax())) &&
 6985   assert((isa<SCEVCouldNotCompute>(MaxNotTaken) ||
 6994   assert((isa<SCEVCouldNotCompute>(ExactNotTaken) ||
 6997   assert((isa<SCEVCouldNotCompute>(MaxNotTaken) ||
 7009   assert((isa<SCEVCouldNotCompute>(MaxNotTaken) ||
 7017   assert((isa<SCEVCouldNotCompute>(MaxNotTaken) ||
 7048   assert((isa<SCEVCouldNotCompute>(MaxCount) || isa<SCEVConstant>(MaxCount)) &&
 7080     assert((AllowPredicates || EL.Predicates.empty()) &&
 7132   assert(L->contains(ExitingBlock) && "Exit count for non-loop block?");
 7142     assert(BI->isConditional() && "If unconditional, it can't be in loop!");
 7144     assert(ExitIfTrue == L->contains(BI->getSuccessor(1)) &&
 7161     assert(Exit && "Exiting block must have at least one exit");
 7185   assert(this->L == L && this->ExitIfTrue == ExitIfTrue &&
 7199   assert(this->L == L && this->ExitIfTrue == ExitIfTrue &&
 7204   assert(InsertResult.second && "Expected successful insertion!");
 7459   assert(!L->contains(ExitingBlock) && "Not an exiting block!");
 7465   assert(L->contains(Switch->getDefaultDest()) &&
 7483   assert(isa<SCEVConstant>(Val) &&
 7696   assert(Result->getType()->isIntegerTy(1) &&
 7889   assert(PN->getParent() == Header && "Can't evaluate PHI not in loop header!");
 7905   assert(BEs.getActiveBits() < CHAR_BIT * sizeof(unsigned) &&
 7969   assert(PN->getParent() == Header && "Can't evaluate PHI not in loop header!");
 7972   assert(Latch && "Should follow from NumIncomingValues == 2!");
 8396   assert(BW == SE.getTypeSizeInBits(B->getType()));
 8397   assert(A != 0 && "A must be non-zero.");
 8443   assert(AddRec->getNumOperands() == 3 && "This is not a quadratic chrec!");
 8459   assert(!N.isNullValue() && "This is not a quadratic addrec");
 8576   assert(AddRec->getOperand(0)->isZero() &&
 8582   assert(Range.contains(APInt(SE.getTypeSizeInBits(AddRec->getType()), 0)) &&
 8989         assert(!RA.isMinValue() && "Should have been caught earlier!");
 8995         assert(!RA.isMaxValue() && "Should have been caught earlier!");
 9001         assert(!RA.isMinSignedValue() && "Should have been caught earlier!");
 9007         assert(!RA.isMaxSignedValue() && "Should have been caught earlier!");
 9119   assert(PostInc != getCouldNotCompute() && "Unexpected could not compute");
 9137       assert((DT.dominates(L1->getHeader(), L2->getHeader()) ||
 9153   assert (SplitLHS.second != getCouldNotCompute() && "Unexpected CNC");
 9159   assert (SplitRHS.second != getCouldNotCompute() && "Unexpected CNC");
 9207   assert(Result == ResultSwapped && "should be able to analyze both!");
 9209     assert(Increasing == !IncreasingSwapped &&
 9460     assert(!verifyFunction(*L->getHeader()->getParent(), &dbgs()) &&
 9525     assert(DTN && "should reach the loop header before reaching the root!");
 9550       assert(DT.dominates(DominatingEdge, Latch) && "should be!");
 9570     assert(!verifyFunction(*L->getHeader()->getParent(), &dbgs()) &&
 9574   assert(isAvailableAtLoopEntry(LHS, L) &&
 9576   assert(isAvailableAtLoopEntry(RHS, L) &&
 9994     assert(Pred == CmpInst::ICMP_SLT && "Checked above!");
10013       assert(Erased && "Failed to erase LPhi!");
10018       assert(Erased && "Failed to erase RPhi!");
10057   assert(LPhi && "LPhi should definitely be a SCEVUnknown Phi!");
10088     assert(Predecessor && "Loop with AddRec with no predecessor?");
10093     assert(Latch && "Loop with AddRec with no latch?");
10213   assert(getTypeSizeInBits(LHS->getType()) ==
10216   assert(getTypeSizeInBits(FoundLHS->getType()) ==
10482   assert(isKnownPositive(Stride) && "Positive stride expected!");
10544   assert(!isKnownNonPositive(Stride) &&
10852     assert(Range.contains(
10869   assert(getNumOperands() > 1 && "AddRec with zero step?");
10886   assert(!Last->isZero() && "Recurrency with zero step?");
11357   assert(SE && "SCEVCallbackVH called with a null ScalarEvolution!");
11365   assert(SE && "SCEVCallbackVH called with a null ScalarEvolution!");
11470   assert(PendingLoopPredicates.empty() && "isImpliedCond garbage");
11471   assert(PendingPhiRanges.empty() && "getRangeRef garbage");
11472   assert(PendingMerges.empty() && "isImpliedViaMerge garbage");
11473   assert(!WalkingBEDominatingConds && "isLoopBackedgeGuardedByCond garbage!");
11474   assert(!ProvingSplitPredicate && "ProvingSplitPredicate garbage!");
11685     assert(!L->contains(AR->getLoop()) && "Containing loop's header does not"
12067   assert(LHS->getType() == RHS->getType() &&
12247   assert(LHS->getType() == RHS->getType() && "LHS and RHS types don't match");
12248   assert(LHS != RHS && "LHS and RHS are the same SCEV");
12370   assert(Key && "Only SCEVUnionPredicate doesn't have an "
lib/Analysis/ScalarEvolutionExpander.cpp
   80   assert(SE.DT.dominates(Ret, &*BIP));
  100     assert(!IP->isEHPad() && "unexpected eh pad!");
  111   assert((Op == Instruction::BitCast ||
  115   assert(SE.getTypeSizeInBits(V->getType()) == SE.getTypeSizeInBits(Ty) &&
  511     assert(!isa<Instruction>(V) ||
  795     assert(Exponent > 0 && "Trying to calculate a zeroth exponent of operand?");
  814     assert(Result && "Nothing was expanded?");
  837         assert(!Ty->isVectorTy() && "vector types are not SCEVable");
 1165   assert((!IVIncInsertLoop||IVIncInsertPos) && "Uninitialized insert position");
 1263   assert(L->getLoopPreheader() &&
 1270   assert(!isa<Instruction>(StartV) ||
 1372         assert(!PostLoopOffset && "Start not-null but PostLoopOffset set?");
 1404     assert(LatchBlock && "PostInc mode requires a unique loop latch!");
 1458     assert(S->isAffine() && "Can't linearly scale non-affine recurrences.");
 1545         assert(StartV->getType() == PTy && "Pointer type mismatch for GEP!");
 1597     assert(Ty == SE.getEffectiveSCEVType(CanonicalIV->getType()) &&
 1771     assert(SE.getTypeSizeInBits(Ty) == SE.getTypeSizeInBits(SH->getType()) &&
 1927   assert(Ty->isIntegerTy() && "Can only insert integer induction variables!");
 2214   assert(IP);
 2240   assert(AR->isAffine() && "Cannot generate RT check for "
 2247   assert(ExitCount != SE.getCouldNotCompute() && "Invalid loop count");
lib/Analysis/ScalarEvolutionNormalization.cpp
   68     assert(Kind == Normalize && "Only two possibilities!");
lib/Analysis/StackSafetyAnalysis.cpp
  241   assert(!Offset.isEmptySet());
  258   assert(!AccessRange.isEmptySet());
  291       assert(V == UI.get());
  343         assert(isa<Function>(Callee) || isa<GlobalAlias>(Callee));
  368   assert(!F.isDeclaration() &&
  463     assert(!CS.Offset.isEmptySet() &&
  535   assert(WorkList.empty());
  562   assert(Count == SSI.size() && "Unexpected functions in the result");
lib/Analysis/StratifiedSets.h
  102     assert(inbounds(Index));
  185       assert(!isRemapped());
  190       assert(!isRemapped());
  195       assert(!isRemapped());
  200       assert(!isRemapped());
  205       assert(!isRemapped());
  215       assert(!isRemapped());
  216       assert(hasBelow());
  221       assert(!isRemapped());
  222       assert(hasAbove());
  227       assert(!isRemapped());
  232       assert(!isRemapped());
  240       assert(!isRemapped());
  245       assert(isRemapped());
  251       assert(isRemapped());
  283         assert(Iter != Remaps.end());
  290         assert(Iter != Remaps.end());
  299       assert(Iter != Remaps.end());
  370     assert(has(Main));
  380     assert(has(Main));
  386     assert(has(Main));
  442     assert(inbounds(Idx1) && inbounds(Idx2));
  443     assert(&linksAt(Idx1) != &linksAt(Idx2) &&
  463     assert(inbounds(Idx1) && inbounds(Idx2));
  512     assert(inbounds(LowerIndex) && inbounds(UpperIndex));
lib/Analysis/SyncDependenceAnalysis.cpp
  222     assert(JoinBlocks);
  252     assert(ItBeginRPO != ItEndRPO);
  270       assert(DefBlock);
  312       assert(ParentLoop);
  317       assert(HeaderDefBlock && "no definition at header of carrying loop");
  321         assert((ItExitDef != DefMap.end()) &&
  353   assert(ItInserted.second);
  376   assert(ItInserted.second);
lib/Analysis/TargetLibraryInfo.cpp
   71   assert(std::is_sorted(StandardNames.begin(), StandardNames.end(),
lib/Analysis/TargetTransformInfo.cpp
  151   assert(Cost >= 0 && "TTI should not produce negative costs!");
  158   assert(Cost >= 0 && "TTI should not produce negative costs!");
  166   assert(Cost >= 0 && "TTI should not produce negative costs!");
  192   assert(Cost >= 0 && "TTI should not produce negative costs!");
  205   assert(Cost >= 0 && "TTI should not produce negative costs!");
  346   assert(Cost >= 0 && "TTI should not produce negative costs!");
  439   assert(Cost >= 0 && "TTI should not produce negative costs!");
  447   assert(Cost >= 0 && "TTI should not produce negative costs!");
  453   assert(Cost >= 0 && "TTI should not produce negative costs!");
  460   assert(Cost >= 0 && "TTI should not produce negative costs!");
  467   assert(Cost >= 0 && "TTI should not produce negative costs!");
  591   assert(Cost >= 0 && "TTI should not produce negative costs!");
  598   assert(Cost >= 0 && "TTI should not produce negative costs!");
  604   assert ((I == nullptr || I->getOpcode() == Opcode) &&
  607   assert(Cost >= 0 && "TTI should not produce negative costs!");
  615   assert(Cost >= 0 && "TTI should not produce negative costs!");
  621   assert(Cost >= 0 && "TTI should not produce negative costs!");
  627   assert ((I == nullptr || I->getOpcode() == Opcode) &&
  630   assert(Cost >= 0 && "TTI should not produce negative costs!");
  637   assert(Cost >= 0 && "TTI should not produce negative costs!");
  645   assert ((I == nullptr || I->getOpcode() == Opcode) &&
  648   assert(Cost >= 0 && "TTI should not produce negative costs!");
  657   assert(Cost >= 0 && "TTI should not produce negative costs!");
  666   assert(Cost >= 0 && "TTI should not produce negative costs!");
  678   assert(Cost >= 0 && "TTI should not produce negative costs!");
  687   assert(Cost >= 0 && "TTI should not produce negative costs!");
  694   assert(Cost >= 0 && "TTI should not produce negative costs!");
  701   assert(Cost >= 0 && "TTI should not produce negative costs!");
  713   assert(Cost >= 0 && "TTI should not produce negative costs!");
  719   assert(Cost >= 0 && "TTI should not produce negative costs!");
  726   assert(Cost >= 0 && "TTI should not produce negative costs!");
  735   assert(Cost >= 0 && "TTI should not produce negative costs!");
  882     assert(Kind != RK_None && "expected binary or min/max reduction only.");
  929   assert(I->getType()->isVectorTy() && "Expecting a vector type");
lib/Analysis/TypeBasedAliasAnalysis.cpp
  339         assert(Idx >= FirstFieldOpNo + NumOpsPerField &&
  614       assert(!NewFormat && "Did not see access type in access path!");
  674   assert(isStructPathTBAA(A) && "Access A is not struct-path aware!");
  675   assert(isStructPathTBAA(B) && "Access B is not struct-path aware!");
lib/Analysis/TypeMetadataUtils.cpp
   77   assert(CI->getCalledFunction()->getIntrinsicID() == Intrinsic::type_test);
  102   assert(CI->getCalledFunction()->getIntrinsicID() ==
lib/Analysis/VFABIDemangling.cpp
  388   assert(NGlobalPreds < 2 && "Cannot have more than one global predicate.");
  390     assert(Parameters.back().ParamKind == VFParamKind::GlobalPredicate &&
lib/Analysis/ValueTracking.cpp
  135     assert(NumExcluded <= Excluded.size());
  193   assert(LHS->getType() == RHS->getType() &&
  195   assert(LHS->getType()->isIntOrIntVectorTy() &&
  354   assert(!Known.hasConflict() && !Known2.hasConflict());
  442   assert(NumRanges >= 1);
  594     assert(I->getParent()->getParent() == Q.CxtI->getParent()->getParent() &&
  603     assert(I->getCalledFunction()->getIntrinsicID() == Intrinsic::assume &&
  609       assert(BitWidth == 1 && "assume operand is not i1?");
  615       assert(BitWidth == 1 && "assume operand is not i1?");
 1141     assert(SrcBitWidth && "SrcBitWidth can't be zero");
 1254         assert((Known.Zero & Known.One) == 0 && "Bits known to be one AND zero?");
 1636   assert(V && "No Value?");
 1637   assert(Depth <= MaxDepth && "Limit Search Depth");
 1640   assert((V->getType()->isIntOrIntVectorTy(BitWidth) ||
 1647   assert(ExpectedWidth == BitWidth && "V and Known should have same BitWidth");
 1704   assert(!isa<ConstantData>(V) && "Unhandled constant data!");
 1735   assert((Known.Zero & Known.One) == 0 && "Bits known to be one AND zero?");
 1744   assert(Depth <= MaxDepth && "Limit Search Depth");
 1852   assert(GEP->getType()->isPointerTy() && "We only support plain pointer GEP");
 1905   assert(V->getType()->isPointerTy() && "V must be pointer type");
 1906   assert(!isa<ConstantData>(V) && "Did not expect ConstantPointerNull");
 1937       assert(WorkList.empty() && "Should be!");
 1958           assert(BI->isConditional() && "uses a comparison!");
 1981   assert(NumRanges >= 1);
 2306   assert(isa<Operator>(Select) &&
 2363   assert(Result > 0 && "At least one sign bit needs to be present!");
 2375   assert(Depth <= MaxDepth && "Limit Search Depth");
 2619         assert(M < NumElts * 2 && "Invalid shuffle mask constant");
 2640       assert(Tmp <= V->getType()->getScalarSizeInBits() &&
 2669   assert(V && "No Value?");
 2670   assert(Depth <= MaxDepth && "Limit Search Depth");
 2671   assert(V->getType()->isIntegerTy() && "Not integer or pointer type!");
 3100   assert(V->getType()->isFPOrFPVectorTy() && "Querying for NaN on non-FP type");
 3236       assert(CI->getBitWidth() > 8 && "8 bits should be handled above!");
 3353   assert(InsertBefore && "Must have someplace to insert!");
 3376   assert((V->getType()->isStructTy() || V->getType()->isArrayTy()) &&
 3378   assert(ExtractValueInst::getIndexedType(V->getType(), idx_range) &&
 3443     assert(Idxs.size() == size
 3477   assert(V);
 3666   assert(Call &&
 3758     assert(V->getType()->isPointerTy() && "Unexpected operand type!");
 3829     assert(V->getType()->isIntegerTy() && "Unexpected operand type!");
 4182       assert(EVI->getNumIndices() == 1 && "Obvious from CI's type");
 4187         assert(EVI->getIndices()[0] == 1 && "Obvious from CI's type");
 4191             assert(B->isConditional() && "How else is it using an i1?");
 4578   assert(CmpInst::isIntPredicate(Pred) && "Expected integer comparison");
 4741   assert(X && Y && "Invalid operand");
 5137   assert(!LHS->getType()->isVectorTy() && "TODO: extend to handle vectors!");
 5320   assert((LHS->getOpcode() == Instruction::And ||
 5324   assert(Depth <= MaxDepth && "Hit recursion limit");
 5357   assert(OpTy->isIntOrIntVectorTy(1) && "Expected integer type only!");
 5367   assert(OpTy->isIntegerTy(1) && "implied by above");
 5389   assert(Cond->getType()->isIntOrIntVectorTy(1) && "Condition must be bool");
 5410   assert((TrueBB == ContextBB || FalseBB == ContextBB) &&
 5529         assert(Upper != Lower && "Upper part of range has wrapped!");
 5688   assert(V->getType()->isIntOrIntVectorTy() && "Expected integer instruction");
lib/Analysis/VectorUtils.cpp
  262   assert(V->getType()->isVectorTy() && "Not looking at a vector?");
  333   assert(Depth <= MaxDepth && "Limit Search Depth");
  514     assert(isValidAsAccessGroup(AccGroups) && "Node must be an access group");
  521     assert(isValidAsAccessGroup(Item) && "List item must be an access group");
  572     assert(isValidAsAccessGroup(MD1) && "Node must be an access group");
  578       assert(isValidAsAccessGroup(Item) && "List item must be an access group");
  645   assert(!Group.isReverse() && "Reversed group not supported.");
  706   assert(VecTy1 && VecTy2 &&
  712   assert(NumElts1 >= NumElts2 && "Unexpect the first vector has less elements");
  727   assert(NumVecs > 1 && "Should be at least two vectors");
  735       assert((V0->getType() == V1->getType() || i == NumVecs - 2) &&
lib/AsmParser/LLLexer.cpp
   79       assert(Buffer != End);
   99     assert(Buffer != End);
lib/AsmParser/LLParser.cpp
  228     assert(MD && "UpgradeInstWithTBAATag should have a TBAA tag");
  355   assert(Lex.getKind() == lltok::kw_module);
  370   assert(Lex.getKind() == lltok::kw_target);
  395   assert(Lex.getKind() == lltok::kw_source_filename);
  410   assert(Lex.getKind() == lltok::kw_deplibs);
  482   assert(Lex.getKind() == lltok::kw_declare);
  505   assert(Lex.getKind() == lltok::kw_define);
  590   assert(Lex.getKind() == lltok::GlobalVar);
  615   assert(Lex.getKind() == lltok::ComdatVar);
  700   assert(Lex.getKind() == lltok::MetadataVar);
  733   assert(Lex.getKind() == lltok::exclaim);
  760     assert(NumberedMetadata[MetadataID] == Init && "Tracking VH didn't work");
  809   assert(Lex.getKind() == lltok::SummaryID);
 1005   assert(GA->getName() == Name && "Should not be a name conflict!");
 1158   assert(Lex.getKind() == lltok::kw_attributes);
 2021   assert(Lex.getKind() == lltok::MetadataVar && "Expected metadata attachment");
 2098   assert((AttrKind == lltok::kw_dereferenceable ||
 2564   assert(Lex.getKind() == lltok::lparen);
 2645   assert(Lex.getKind() == lltok::lparen);
 2745   assert(Lex.getKind() == lltok::lbrace);
 3405       assert(Opc == Instruction::ICmp && "Unexpected opcode for CmpInst!");
 3640       assert(Opc == Instruction::InsertElement && "Unknown opcode");
 3914     assert(isMDSignedField() && "Wrong field type");
 3918     assert(isMDField() && "Wrong field type");
 3930     assert(isMDSignedField() && "Wrong field type");
 3934     assert(isMDUnsignedField() && "Wrong field type");
 3954   assert(Result.Val <= Result.Max && "Expected value in range");
 3979   assert(Tag <= Result.Max && "Expected valid DWARF tag");
 3999   assert(Macinfo <= Result.Max && "Expected valid DWARF macinfo type");
 4019   assert(Virtuality <= Result.Max && "Expected valid DWARF virtuality code");
 4037   assert(Lang <= Result.Max && "Expected valid DWARF language");
 4055   assert(CC <= Result.Max && "Expected valid DWARF calling convention");
 4073   assert(*Kind <= Result.Max && "Expected valid emission kind");
 4092   assert(((unsigned)*Kind) <= Result.Max && "Expected valid nameTable kind");
 4111   assert(Encoding <= Result.Max && "Expected valid DWARF language");
 4211   assert(Result.Val >= Result.Min && "Expected value in range");
 4212   assert(Result.Val <= Result.Max && "Expected value in range");
 4351   assert(Lex.getKind() == lltok::MetadataVar && "Expected metadata type name");
 4375   assert(Lex.getKind() == lltok::MetadataVar && "Expected metadata type name");
 4940   assert(Lex.getKind() == lltok::MetadataVar && "Expected metadata type name");
 5106   assert(Lex.getKind() == lltok::exclaim && "Expected '!' here");
 5263     assert(isa<Constant>(V) && "Expected a constant value");
 5484   assert(Fn->getAddressSpace() == AddrSpace && "Created function in wrong AS");
 5557     assert((BBID.Kind == ValID::t_LocalID || BBID.Kind == ValID::t_LocalName) &&
 6527     assert(Opc == Instruction::ICmp && "Unknown opcode for CmpInst!");
 7361   assert(Indexes.empty() && "Expected empty order vector");
 7408   assert(Lex.getKind() == lltok::kw_uselistorder_bb);
 7455   assert(Lex.getKind() == lltok::kw_module);
 7491   assert(Lex.getKind() == lltok::kw_typeid);
 7512       assert(!*TIDRef.first &&
 7551   assert(Lex.getKind() == lltok::kw_typeidCompatibleVTable);
 7601       assert(TI[P.first].VTableVI == EmptyVI &&
 7619       assert(!*TIDRef.first &&
 7689       assert(Val <= 0xff);
 7904   assert(!(ReadOnly && WriteOnly));
 7920     assert(Name.empty());
 7923     assert(!Name.empty());
 7926       assert(GV);
 7929       assert(
 7942       assert(VIRef.first->getRef() == FwdVIRef &&
 7953       assert(!AliaseeRef.first->hasAliasee() &&
 7955       assert(Summary && "Aliasee must be a definition");
 7981   assert(Lex.getKind() == lltok::kw_gv);
 8062   assert(Lex.getKind() == lltok::kw_function);
 8132   assert(Lex.getKind() == lltok::kw_variable);
 8187   assert(Lex.getKind() == lltok::kw_alias);
 8223     assert(Summary && "Aliasee must be a definition");
 8249   assert(Lex.getKind() == lltok::kw_funcFlags);
 8305   assert(Lex.getKind() == lltok::kw_calls);
 8354       assert(Calls[P.first].first.getRef() == FwdVIRef &&
 8399   assert(Lex.getKind() == lltok::kw_vTableFuncs);
 8441       assert(VTableFuncs[P.first].FuncVI == EmptyVI &&
 8459   assert(Lex.getKind() == lltok::kw_refs);
 8502       assert(Refs[P.first].getRef() == FwdVIRef &&
 8522   assert(Lex.getKind() == lltok::kw_typeIdInfo);
 8570   assert(Lex.getKind() == lltok::kw_typeTests);
 8597       assert(TypeTests[P.first] == 0 &&
 8616   assert(Lex.getKind() == Kind);
 8638       assert(VFuncIdList[P.first].GUID == 0 &&
 8655   assert(Lex.getKind() == Kind);
 8677       assert(ConstVCallList[P.first].VFunc.GUID == 0 &&
 8712   assert(Lex.getKind() == lltok::kw_vFuncId);
 8748   assert(Lex.getKind() == lltok::kw_flags);
 8764       assert(HasLinkage && "Linkage not optional in summary entry");
 8806   assert(Lex.getKind() == lltok::kw_varFlags);
 8852   assert(I != ModuleIdMap.end());
 8869     assert(NumberedValueInfos[GVId].getRef() != FwdVIRef);
lib/AsmParser/LLParser.h
   74       assert(!RHS.ConstantStructElts);
   80       assert((Kind == t_LocalName || Kind == t_GlobalName ||
lib/BinaryFormat/Dwarf.cpp
  491   assert(Arch != llvm::Triple::ArchType::UnknownArch);
lib/BinaryFormat/MsgPackDocument.cpp
   42   assert(!Key.isEmpty());
lib/BinaryFormat/MsgPackDocumentYAML.cpp
  100   assert((Tag == "!str" || Tag == "") && "unsupported tag");
lib/BinaryFormat/MsgPackWriter.cpp
  113     assert(Size <= UINT32_MAX && "String object too long to be encoded");
  122   assert(!Compatible && "Attempt to write Bin format in compatible mode");
  133     assert(Size <= UINT32_MAX && "Binary object too long to be encoded");
  200       assert(Size <= UINT32_MAX && "Ext size too large to be encoded");
lib/Bitcode/Reader/BitcodeAnalyzer.cpp
  917             assert(!(Val >> 32) && "Unexpected high bits set");
  937           assert(i + 2 == e && "Array op not second to last");
lib/Bitcode/Reader/BitcodeReader.cpp
  875     assert(F && "Expected valid function");
  891   assert(BasicBlockFwdRefs.empty() && "Function missing from queue");
 1339   assert((!Alignment || isPowerOf2_32(Alignment)) &&
 1640           assert(Record[i] == 0 && "Kind string not null terminated");
 1647             assert(Record[i] == 0 && "Value string not null terminated");
 1652           assert((Record[i] == 5 || Record[i] == 6) &&
 1916     assert(ResultTy && "Didn't read a type?");
 2047   assert(MaybeEntry.get().Kind == BitstreamEntry::SubBlock);
 2048   assert(MaybeEntry.get().ID == bitc::VALUE_SYMTAB_BLOCK_ID);
 2822     assert(V->getType() == flattenPointerTypes(CurFullTy) &&
 2875         assert(ID < FunctionBBs.size() && "Basic block not found");
 2949   assert(
 3014   assert(SeenValueSymbolTable);
 3157   assert(NewGV->getType() == flattenPointerTypes(FullTy) &&
 3223   assert(Func->getFunctionType() == flattenPointerTypes(FullFTy) &&
 3304   assert(Func->getType() == flattenPointerTypes(FullTy) &&
 3362   assert(NewGA->getValueType() == flattenPointerTypes(FullTy) &&
 3395   assert(NewGA->getType() == flattenPointerTypes(FullTy) &&
 3454           assert(VSTOffset == 0 || FunctionsWithBodies.empty());
 3461           assert(VSTOffset > 0);
 3478         assert(DeferredMetadataInfo.empty() && "Unexpected deferred metadata");
 3710     assert(I.getType() == flattenPointerTypes(FullFTy->getParamType(ArgNo)) &&
 3765         assert(DeferredMetadataInfo.empty() &&
 3808         assert(!BBRefs.empty() && "Unexpected empty array");
 3809         assert(!BBRefs.front() && "Invalid reference to entry block");
 4668         assert(isa<FPMathOperator>(I) && "Unexpected phi type");
 4685         assert(BitCode == bitc::FUNC_CODE_INST_LANDINGPAD_OLD);
 4718         assert((CT != LandingPadInst::Catch ||
 4721         assert((CT != LandingPadInst::Filter ||
 5145         assert(
 5155       assert(I->getType() == flattenPointerTypes(FullTy) &&
 5200     assert(VSTOffset == 0 || !F->hasName());
 5228   assert(DFII != DeferredFunctionInfo.end() && "Deferred function not found!");
 5366   assert(VGI.first);
 5403   assert(Offset > 0 && "Expected non-zero VST offset");
 5449       assert(!SourceFileName.empty());
 5451       assert(VLI != ValueIdToLinkageMap.end() &&
 5463       assert(!SourceFileName.empty());
 5465       assert(VLI != ValueIdToLinkageMap.end() &&
 5524         assert(((SeenValueSymbolTable && VSTOffset > 0) ||
 5535         assert(!SeenValueSymbolTable &&
 5585             assert(!(Val >> 32) && "Unexpected high bits set");
 5734   assert(ROCnt + WOCnt <= Refs.size());
 5820       assert(Flags <= 0x1f && "Unexpected bits in flag");
 5891       assert(Record.size() >= RefListStartIndex + NumRefs &&
 6036       assert(Record.size() >= RefListStartIndex + NumRefs &&
 6123       assert(PendingTypeTests.empty());
 6129       assert(PendingTypeTestAssumeVCalls.empty());
 6135       assert(PendingTypeCheckedLoadVCalls.empty());
 6234         assert(!(Val >> 32) && "Unexpected high bits set");
 6558       assert(Flags <= 0x1f && "Unexpected bits in flag");
lib/Bitcode/Reader/MetadataLoader.cpp
  153     assert(i < MetadataPtrs.size());
  164     assert(N <= size() && "Invalid shrinkTo request!");
  165     assert(ForwardReference.empty() && "Unexpected forward refs");
  166     assert(UnresolvedNodes.empty() && "Unexpected unresolved node");
  185     assert(hasFwdRefs());
  298     assert(!N->isTemporary() && "Unexpected forward reference");
  308   assert(CT.getRawIdentifier() == &UUID && "Mismatched UUID");
  369     assert(empty() && "PlaceholderQueue hasn't been flushed before being destroyed");
  403     assert(MD && "Flushing placeholder on unassigned MD");
  406       assert(MDN->isResolved() &&
  754         assert(Entry.Kind == BitstreamEntry::Record &&
  760           assert(MaybeCode.get() == bitc::METADATA_INDEX &&
  788           assert(Code == bitc::METADATA_NAME);
  804           assert(MaybeNextBitCode.get() == bitc::METADATA_NAMED_NODE);
  817           assert(MD && "Invalid metadata: expect fwd ref to MDNode");
  986   assert(ID < (MDStringRef.size()) + GlobalMetadataBitPosIndex.size());
  987   assert(ID >= MDStringRef.size() && "Unexpected lazy-loading of MDString");
 1180         assert(isa<ConstantAsMetadata>(MD) &&
 1963   assert(Record.size() % 2 == 0);
 2055           assert(!MD->isTemporary() && "should load MDs before attachments");
lib/Bitcode/Reader/ValueList.cpp
   77   assert(FullTypes[Idx] == nullptr || FullTypes[Idx] == FullTy);
  196           assert(It != ResolveConstants.end() && It->first == *I);
  212         assert(isa<ConstantExpr>(UserC) && "Must be a ConstantExpr.");
lib/Bitcode/Reader/ValueList.h
   60     assert(ResolveConstants.empty() && "Constants not resolved?");
   75     assert(ResolveConstants.empty() && "Constants not resolved?");
   81     assert(i < ValuePtrs.size());
   93     assert(N <= size() && "Invalid shrinkTo request!");
lib/Bitcode/Writer/BitcodeWriter.cpp
  228     assert(VMI != GUIDToValueIdMap.end() &&
  471           assert(ModuleToSummariesForIndex->size() == 1);
  771         assert(Attr.isTypeAttribute());
 1435     assert(!(MD && isa<LocalAsMetadata>(MD)) &&
 1642   assert(N->isDistinct() && "Expected distinct compile units");
 2018       assert(N->isResolved() && "Expected forward references to be resolved");
 2381         assert(0 && "Unknown FP type!");
 2437           assert(CE->getNumOperands() == 2 && "Unknown constant expr!");
 2448         assert(CE->getNumOperands() == 1 && "Unknown constant expr!");
 2615       assert(isa<BinaryOperator>(I) && "Unknown instruction!");
 2917     assert(Log2_32(Value::MaximumAlignment) + 1 < 1 << 5 &&
 2919     assert(AlignRecord < 1 << 5 && "alignment greater than 1 << 64");
 3051   assert((VSTOffset & 31) == 0 && "VST block not 32-bit aligned");
 3076     assert((BitcodeIndex & 31) == 0 && "function block not 32-bit aligned");
 3134   assert(Order.Shuffle.size() >= 2 && "Shuffle too small");
 3147   assert(VE.shouldPreserveUseListOrder() &&
 3687     assert(V.isDeclaration());
 3844       assert(F.isDeclaration());
 3988     assert(S);
 3994     assert(ValueId);
 4117     assert(AliasValueId);
 4122     assert(AliaseeValueId);
 4329   assert(Buffer.size() >= BWH_HeaderSize &&
 4363 BitcodeWriter::~BitcodeWriter() { assert(WroteStrtab); }
 4379   assert(!WroteStrtab && !WroteSymtab);
 4411   assert(!WroteStrtab);
 4433   assert(!WroteStrtab);
 4439   assert(M.isMaterialized());
 4644   assert(!WroteStrtab);
 4650   assert(M.isMaterialized());
lib/Bitcode/Writer/ValueEnumerator.cpp
  234   assert(List.size() == Stack.back().Shuffle.size() && "Wrong size");
  242   assert(IDPair.first && "Unmapped value");
  443   assert(I != InstructionMap.end() && "Instruction is not mapped!");
  449   assert(ComdatID && "Comdat not found!");
  462   assert(I != ValueMap.end() && "Value not in slotcalculator!");
  661   assert(
  693   assert(F && "Expected a function");
  698     assert(Index.F == F && "Expected the same function");
  726   assert(MetadataMap.size() == MDs.size() &&
  805   assert(!V->getType()->isVoidTy() && "Can't insert void values!");
  806   assert(!isa<MetadataAsValue>(V) && "EnumerateValue doesn't handle Metadata!");
  895   assert(!isa<MetadataAsValue>(V) && "Unexpected metadata operand");
  999     assert(ValueMap.count(FnLocalMDVector[i]->getValue()) &&
lib/Bitcode/Writer/ValueEnumerator.h
   85       assert(ID && "Expected non-zero ID");
   86       assert(ID <= MDs.size() && "Expected valid ID");
  155     assert(ID != 0 && "Metadata not in slotcalculator!");
  169     assert(I != TypeMap.end() && "Type not in ValueEnumerator!");
  179     assert(I != AttributeListMap.end() && "Attribute not in ValueEnumerator!");
  187     assert(I != AttributeGroupMap.end() && "Attribute not in ValueEnumerator!");
lib/Bitstream/Reader/BitstreamReader.cpp
   69   assert(!Op.isLiteral() && "Not to be used with literals!");
   77     assert((unsigned)Op.getEncodingData() <= Cursor.MaxChunkSize);
   80     assert((unsigned)Op.getEncodingData() <= Cursor.MaxChunkSize);
   93   assert(!Op.isLiteral() && "Not to be used with literals!");
  101     assert((unsigned)Op.getEncodingData() <= Cursor.MaxChunkSize);
  107     assert((unsigned)Op.getEncodingData() <= Cursor.MaxChunkSize);
  179       assert(i+2 == e && "array op not second to last?");
  188         assert((unsigned)EltEnc.getEncodingData() <= MaxChunkSize);
  194         assert((unsigned)EltEnc.getEncodingData() <= MaxChunkSize);
  210     assert(Op.getEncoding() == BitCodeAbbrevOp::Blob);
  259   assert(Abbv->getNumOperandInfos() != 0 && "no record code in abbreviation?");
  335     assert(Op.getEncoding() == BitCodeAbbrevOp::Blob);
lib/CodeGen/AggressiveAntiDepBreaker.cpp
   95   assert(GroupNodes[0] == 0 && "GroupNode 0 not parent!");
   96   assert(GroupNodeIndices[0] == 0 && "Reg 0 not in Group 0!");
  153   assert(!State);
  198   assert(Count < InsertPosIndex && "Instruction index out of expected range!");
  564   assert(!Regs.empty() && "Empty register group!");
  585       assert(BV.empty());
  793     assert(CriticalPathSU && "Failed to find SUnit critical path");
  859         assert(AntiDepReg != 0 && "Anti-dependence on reg0?");
  879           assert(AntiDepOp && "Can't find index for defined register operand");
  945         assert(AntiDepReg != 0);
  998             assert(((KillIndices[CurrReg] == ~0u) !=
lib/CodeGen/AllocationOrder.cpp
   51     assert(is_contained(Order, Hints[I]) &&
lib/CodeGen/Analysis.cpp
   53     assert(!Indices && "Unexpected out of bound");
   63       assert(*Indices < NumElts && "Unexpected out of bound");
  164     assert(Var->hasInitializer() &&
  171   assert((GV || isa<ConstantPointerNull>(V)) &&
  499     assert(!Path.empty() && "found a leaf but didn't set the path?");
  712       assert(P.first->second == EHScope && "MBB is part of two scopes!");
lib/CodeGen/AntiDepBreaker.h
   60     assert(MI.isDebugValue() && "MI is not DBG_VALUE!");
lib/CodeGen/AsmPrinter/ARMException.cpp
   43   assert(MoveType != AsmPrinter::CFI_M_EH &&
lib/CodeGen/AsmPrinter/AccelTable.cpp
  367   assert(CompUnitCount > 0 && "Index must have at least one CU.");
  391   assert(AugmentationStringSize % 4 == 0);
  459     assert(Abbrev.first != 0);
  478   assert(AbbrevIt != Abbreviations.end() &&
  491       assert(AttrEnc.Form == dwarf::DW_FORM_ref4);
  562     assert(CU.index() == CU.value()->getUniqueID());
lib/CodeGen/AsmPrinter/AsmPrinter.cpp
  176   assert(GVAlign && "GVAlign must be set");
  192   assert(!DD && Handlers.empty() && "Debug/EH info didn't get finalized");
  226   assert(MF && "getSubtargetInfo requires a valid MachineFunction!");
  235   assert(DD && "Dwarf debug file is not defined.");
  236   assert(OutStreamer->hasRawTextSupport() && "Expected assembly output mode.");
  289   assert(MI && "AsmPrinter didn't require GCModuleInfo?");
  451   assert(!(IsEmuTLSVar && GV->hasCommonLinkage()) &&
  810     assert(Op.isReg() && "KILL instruction must have only register operands");
  882       assert(MI->getOperand(0).isFI() && "Unknown operand type");
 1310     assert(GIS.hasLocalLinkage() && "Invalid alias or ifunc linkage");
 1365     assert(!Filename->empty() && "The filename can't be empty.");
 1516   assert(MI && "AsmPrinter didn't require GCModuleInfo?");
 1579       assert(LU->hasInitializer() &&
 1581       assert(isa<ArrayType>(LU->getValueType()) &&
 1659     assert(TM.getTargetTriple().isOSAIX() && "Function descriptor is only"
 1661     assert(CurrentFnDescSym && "The function descriptor symbol needs to be"
 1865   assert(MBB && MBB->getNumber() >= 0 && "Invalid basic block");
 1918   assert(Value && "Unknown entry kind!");
 1941   assert(GV->hasInitializer() && "Not a special LLVM global!");
 2056       assert(N->getNumOperands() == 1 &&
 2078     assert(N->getNumOperands() == 1 &&
 2330   assert(!Data.empty() && "Empty aggregates should be CAZ node");
 2343     assert(Size % 8 == 0);
 2355     assert(CA->getNumOperands() != 0 && "Should be a CAZ");
 2409   assert(EmittedSize <= Size && "Size cannot be less than EmittedSize!");
 2469   assert(SizeSoFar == Layout->getSizeInBytes() &&
 2474   assert(ET && "Unknown float type");
 2570     assert(Size && Size * 8 >= ExtraBitsSize &&
 2875   assert(Header && "No header for loop");
 2906   assert(MF != nullptr && "Machine function must be valid");
 2963     assert(MLI != nullptr && "MachineLoopInfo should has been computed");
 3079   assert(MI && "AsmPrinter didn't require GCModuleInfo?");
 3116   assert(Padding >= 0 && "Instrumentation map entry > 4 * Word Size");
 3130     assert(Associated != nullptr);
lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp
  173     assert(S.Symbol && "No symbol available");
  264     assert(V.getForm() && "Too many attributes for DIE (check abbreviation)");
lib/CodeGen/AsmPrinter/AsmPrinterInlineAsm.cpp
   47   assert(DiagInfo && "Diagnostic context not passed down?");
  113   assert(!Str.empty() && "Can't emit empty inline asm block");
  126   assert(MCAI && "No MCAsmInfo");
  469   assert(MI->isInlineAsm() && "printInlineAsm only works on inline asms");
  475     assert(NumDefs != MI->getNumOperands()-2 && "No asm string?");
  477   assert(MI->getOperand(NumDefs).isSymbol() && "No asm string?");
  604   assert(MO.isGlobal() && "caller should check MO.isGlobal");
lib/CodeGen/AsmPrinter/CodeViewDebug.cpp
  260     assert(Success && ".cv_file directive failed");
  360   assert(!isa<DIType>(Scope) && "shouldn't make a namespace scope for a type");
  375   assert(SP);
  442   assert(!SP->getDeclaration() && "should use declaration as key");
  467   assert(InsertResult.second && "DINode was already assigned a type index");
  561   assert(Asm != nullptr);
  696     assert(GHR.Hash.size() == 8);
  864     assert(TypeIndices.count({SP, nullptr}));
  886   assert(TypeIndices.count({Site.Inlinee, nullptr}));
  912     assert(I != FI.InlineSites.end() &&
  987   assert(Fn);
  994   assert(SP);
 1079       assert(I != FI.InlineSites.end() &&
 1096         assert(Str.data()[Str.size()] == '\0' && "non-nullterminated MDString");
 1135   assert(DR.DataOffset == Offset && "truncation");
 1152     assert(VI.Var->isValidLocationForIntrinsic(VI.Loc) &&
 1219     assert(DVInst->isDebugValue() && "Invalid History entry");
 1334   assert(Insertion.second && "function already has info");
 1571     assert(Element->getTag() == dwarf::DW_TAG_subrange_type);
 1574     assert(Subrange->getLowerBound() == 0 &&
 1769   assert(Ty->getTag() == dwarf::DW_TAG_ptr_to_member_type);
 1778   assert(Ty->getSizeInBits() / 8 <= 0xff && "pointer size too big");
 2116   assert(CurFn == nullptr);
 2138   assert((DDTy->getOffsetInBits() % 8) == 0 && "Unnamed bitfield member!");
 2341       assert(I->getOffsetInBits() % 8 == 0 &&
 2415     assert(!Methods.empty() && "Empty methods map entry");
 2478   assert(PtrTy->getTag() == dwarf::DW_TAG_pointer_type &&
 2678       assert(DefRange.DataOffset == 0 && "unexpected offset into register");
 2812   assert(Range.first && Range.second);
 2816   assert(Block.Begin && "missing label for scope begin");
 2817   assert(Block.End && "missing label for scope end");
 2832   assert(FnDebugInfo.count(&GV));
 2833   assert(CurFn == FnDebugInfo[&GV].get());
 2970     assert(shouldEmitUdt(T));
 3103     assert(DIE->isConstant() &&
lib/CodeGen/AsmPrinter/DIE.cpp
  199   assert(Unit && "DIE must be owned by a DIEUnit to get its absolute offset");
  297     assert(Abbrev.hasChildren() && "Children flag not set");
  321   assert((UnitTag == dwarf::DW_TAG_compile_unit ||
  514   assert(Offset < (1ULL << (ULEB128PadSize * 7)) && "Offset wont fit");
lib/CodeGen/AsmPrinter/DIEHash.cpp
   92   assert(Cur->getTag() == dwarf::DW_TAG_compile_unit ||
  176   assert(Tag != dwarf::DW_TAG_friend && "No current LLVM clients emit friend "
lib/CodeGen/AsmPrinter/DbgEntityHistoryCalculator.cpp
   42   assert(MI.isDebugValue());
   43   assert(MI.getNumOperands() == 4);
   58   assert(MI.isDebugValue() && "not a DBG_VALUE");
   87   assert(isDbgValue() && "Setting end index for non-debug value");
   88   assert(!isClosed() && "End index has already been set");
   93   assert(MI.isDebugLabel() && "not a DBG_LABEL");
  115   assert(RegNo != 0U && I != RegVars.end());
  118   assert(VarPos != VarSet.end());
  128   assert(RegNo != 0U);
  130   assert(!is_contained(VarSet, Var));
  146     assert(Entry.isDbgValue() && "Not a DBG_VALUE in LiveEntries");
  173       assert(Entry.isDbgValue() && "Not a DBG_VALUE in LiveEntries");
  243         assert(MI.getNumOperands() > 1 && "Invalid DBG_VALUE instruction!");
  248         assert(RawVar->isValidLocationForIntrinsic(MI.getDebugLoc()) &&
  254         assert(MI.getNumOperands() == 1 && "Invalid DBG_LABEL instruction!");
  256         assert(RawLabel->isValidLocationForIntrinsic(MI.getDebugLoc()) &&
  326           assert(Ent.isDbgValue() && !Ent.isClosed());
lib/CodeGen/AsmPrinter/DebugHandlerBase.cpp
  107       assert(R.first && "InsnRange does not have first instruction!");
  108       assert(R.second && "InsnRange does not have second instruction!");
  118   assert(Label && "Didn't insert label before instruction");
  136   assert(AfterInsn && "Expected label after instruction");
  144   assert(Ty);
  178   assert(SP->getUnit());
  205   assert(DbgValues.empty() && "DbgValues map wasn't cleaned!");
  206   assert(DbgLabels.empty() && "DbgLabels map wasn't cleaned!");
  283   assert(CurMI == nullptr);
  309   assert(CurMI != nullptr);
lib/CodeGen/AsmPrinter/DebugLocEntry.h
   57     assert(cast<DIExpression>(Expr)->isValid());
  130     assert((Values.size() == 1 || all_of(Values, [](DbgValueLoc V) {
lib/CodeGen/AsmPrinter/DebugLocStream.cpp
   36   assert(Lists.back().EntryOffset <= Entries.size() &&
lib/CodeGen/AsmPrinter/DebugLocStream.h
  129     assert(&Lists.front() <= &L && &L <= &Lists.back() &&
  134     assert(&Entries.front() <= &E && &E <= &Entries.back() &&
lib/CodeGen/AsmPrinter/DwarfCFIException.cpp
  147   assert(P && "Expected personality function");
lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp
  119   assert(GV);
  135     assert(SDMDecl->isStaticMember() && "Expected static member decl");
  136     assert(GV->isDefinition());
  241           assert((PointerSize == 4 || PointerSize == 8) &&
  368   assert(Begin && "Begin label should not be null!");
  369   assert(End && "End label should not be null!");
  370   assert(Begin->isDefined() && "Invalid starting label");
  371   assert(End->isDefined() && "Invalid end label");
  421   assert((Scope->getInlinedAt() || !isa<DISubprogram>(DS)) &&
  458     assert(ScopeDIE && "Scope DIE should not be null.");
  524   assert(Scope->getScopeNode());
  530   assert(OriginDIE && "Unable to find original DIE for an inlined subprogram.");
  759       assert(false && "dependency cycle in local variables");
  777   assert(Children.empty());
  815     assert(!Scope->getInlinedAt());
  816     assert(!Scope->isAbstractScope());
  955     assert(CalleeDIE && "Could not create DIE for call site entry origin");
  967     assert(PCAddr && "Missing PC information for a call");
  970     assert(PCOffset && "Missing return PC information for a call");
 1019   assert(EntityDie);
 1036     assert(D || includeMinimalInlineScopes());
 1077   assert(Scope && Scope->isAbstractScope());
lib/CodeGen/AsmPrinter/DwarfCompileUnit.h
  166     assert(Scope && "Invalid Scope encoding!");
  292     assert(getSection());
lib/CodeGen/AsmPrinter/DwarfDebug.cpp
  191   assert(Idx < (1ULL << (ULEB128PadSize * 7)) && "Idx wont fit");
  202   assert(!IsBuffering && "Already buffering?");
  234   assert(MI->getNumOperands() == 4);
  240     assert((!Op1.isImm() || (Op1.getImm() == 0)) && "unexpected offset");
  255   assert(FrameIndexExprs.empty() && "Already initialized?");
  256   assert(!ValueLoc.get() && "Already initialized?");
  258   assert(getVariable() == DbgValue->getDebugVariable() && "Wrong variable");
  259   assert(getInlinedAt() == DbgValue->getDebugLoc()->getInlinedAt() &&
  272   assert(llvm::all_of(FrameIndexExprs,
  287   assert(DebugLocListIndex == ~0U && !ValueLoc.get() && "not an MMI entry");
  288   assert(V.DebugLocListIndex == ~0U && !V.ValueLoc.get() && "not an MMI entry");
  289   assert(V.getVariable() == getVariable() && "conflicting variable");
  290   assert(V.getInlinedAt() == getInlinedAt() && "conflicting inlined-at location");
  292   assert(!FrameIndexExprs.empty() && "Expected an MMI entry");
  293   assert(!V.FrameIndexExprs.empty() && "Expected an MMI entry");
  312   assert((FrameIndexExprs.size() == 1 ||
  515   assert(Scope && Scope->getScopeNode());
  516   assert(Scope->isAbstractScope());
  517   assert(!Scope->getInlinedAt());
  562     assert(InsertedReg && "Single register used to forward two arguments?");
  704   assert(TII && "TargetInstrInfo not found: cannot label tail calls");
  758       assert((IsTail || PCOffset || PCAddr) &&
  942   assert(MMI->hasDebugInfo() == (NumDebugCUs > 0) &&
 1033     assert(Die);
 1038     assert(Unit);
 1045     assert(SP->getUnit()->getEmissionKind() != DICompileUnit::NoDebug);
 1168   assert(CurFn == nullptr);
 1169   assert(CurMI == nullptr);
 1270     assert(VI.Var->isValidLocationForIntrinsic(VI.Loc) &&
 1301   assert(DbgValue->getDebugLoc() && "DBG_VALUE without a debug location");
 1407     assert(StartLabel &&
 1420     assert(EndLabel && "Forgot label after instruction ending a range!");
 1539     assert(MInsn->isDebugValue() && "History must begin with debug value");
 1635   assert(CurMI);
 1783   assert(LScopes.empty() || SP == LScopes.getCurrentFunctionScope()->getScopeNode());
 1818   assert(CurFn == MF &&
 1825   assert(!FnScope || SP == FnScope->getScopeNode());
 1845     assert(InfoHolder.getScopeVariables().empty());
 1871       assert(LScopes.getAbstractScopesList().size() == NumAbstractScopes
 2153     assert(Op.getCode() != dwarf::DW_OP_const_type &&
 2163             assert(Offset < (1ULL << (ULEB128PadSize * 7)) && "Offset wont fit");
 2179     assert(Offset == Op.getEndOffset());
 2222   assert(!Values.empty() &&
 2224   assert(Begin != End && "unexpected location list entry with empty range");
 2231     assert(llvm::all_of(Values, [](DbgValueLoc P) {
 2234     assert(std::is_sorted(Values.begin(), Values.end()) &&
 2241     assert(Values.size() == 1 && "only fragments may have >1 value");
 2373       assert(!Base);
 2381       assert(Begin && "Range without a begin symbol?");
 2382       assert(End && "Range without an end symbol?");
 2519         assert(Cur.CU);
 2553         assert(Prev.CU);
 2671   assert(useRangesSection());
 2672   assert(llvm::none_of(CUMap, [](const decltype(CUMap)::value_type &Pair) {
 2690   assert(useSplitDwarf());
 2700   assert(getDwarfVersion() >= 5);
 2701   assert(useRangesSection());
 2702   assert(llvm::none_of(CUMap, [](const decltype(CUMap)::value_type &Pair) {
 2740   assert(F.getMacinfoType() == dwarf::DW_MACINFO_start_file);
 2812   assert(useSplitDwarf() && "No split dwarf debug info?");
 2820   assert(useSplitDwarf() && "No split dwarf?");
 2825   assert(useSplitDwarf() && "No split dwarf?");
 2832   assert(useSplitDwarf() && "No split dwarf?");
 2844   assert(useSplitDwarf() && "No split dwarf?");
 2966   assert(TypeUnitsUnderConstruction.empty() || !DD->AddrPool.hasBeenUsed());
lib/CodeGen/AsmPrinter/DwarfDebug.h
  141     assert(FrameIndexExprs.empty() && "Already initialized?");
  142     assert(!ValueLoc.get() && "Already initialized?");
  144     assert((!E || E->isValid()) && "Expected valid expression");
  145     assert(FI != std::numeric_limits<int>::max() && "Expected valid index");
  152     assert(FrameIndexExprs.empty() && "Already initialized?");
  153     assert(!ValueLoc && "Already initialized?");
  154     assert(!Value.getExpression()->isFragment() && "Fragments not supported.");
  171     assert(ValueLoc.get() && FrameIndexExprs.size() <= 1);
  211     assert(ValueLoc.get() && "Expected DBG_VALUE, not MMI variable");
  212     assert((FrameIndexExprs.empty() ||
  265     assert(Reg && "Parameter register cannot be undef");
lib/CodeGen/AsmPrinter/DwarfExpression.cpp
   43  assert(DwarfReg >= 0 && "invalid negative dwarf register number");
   44  assert((isUnknownLocation() || isRegisterLocation()) &&
   56   assert(DwarfReg >= 0 && "invalid negative dwarf register number");
   57   assert(!isRegisterLocation() && "location description already locked down");
  188   assert(isImplicitLocation() || isUnknownLocation());
  195   assert(isImplicitLocation() || isUnknownLocation());
  201   assert(isImplicitLocation() || isUnknownLocation());
  277   assert(DwarfRegs.size() == 1);
  281   assert(Reg.Size == 0 && "subregister has same size as superregister");
  323   assert(Op && Op->getOp() == dwarf::DW_OP_LLVM_entry_value);
  324   assert(!isMemoryLocation() &&
  326   assert(!IsEmittingEntryValue && "Already emitting entry value?");
  327   assert(Op->getArg(0) == 1 &&
  336   assert(IsEmittingEntryValue && "Entry value not open?");
  393       assert(OffsetInBits >= FragmentOffset && "fragment offset not added?");
  417       assert(!isRegisterLocation());
  438       assert(!isRegisterLocation());
  440       assert(!isParameterValue() && "Parameter entry values should not be "
  450       assert(!isRegisterLocation());
  493       assert(!isRegisterLocation());
  497       assert(!isRegisterLocation());
  528   assert(SubRegisterSizeInBits && "no subregister was registered");
  536   assert(DwarfRegs.size() == 0 && "dwarf registers not emitted");
  551   assert(FragmentOffset >= OffsetInBits &&
lib/CodeGen/AsmPrinter/DwarfExpression.h
   42       assert(Start == End);
  170     assert(SizeInBits < 65536 && OffsetInBits < 65536);
  292     assert(isUnknownLocation());
lib/CodeGen/AsmPrinter/DwarfStringPool.cpp
   36     assert(NumBytes > Entry.Offset && "Unexpected overflow");
   98     assert(ShouldCreateSymbols == static_cast<bool>(Entry->getValue().Symbol) &&
lib/CodeGen/AsmPrinter/DwarfUnit.cpp
   74   assert(!IsBuffering && "Already buffering?");
  236   assert(Form != dwarf::DW_FORM_implicit_const &&
  312   assert(File);
  426   assert(V);
  432   assert(G);
  438   assert(SP);
  444   assert(L);
  450   assert(Ty);
  456   assert(Ty);
  486     assert(T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type ||
  489     assert(DTy->getBaseType() && "Expected valid base type");
  495   assert((Encoding == dwarf::DW_ATE_unsigned ||
  511   assert(MO.isFPImm() && "Invalid machine operand!");
  544   assert(MO.isImm() && "Invalid machine operand!");
  698   assert(ContextDIE);
  727   assert(Ty && "Trying to add a type that doesn't exist?");
  829       assert(i == N-1 && "Unspecified parameter must be the last argument");
 1069       assert(isa<MDString>(Val));
 1161     assert(DeclDie && "This DIE should've already been constructed when the "
 1181   assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
 1355   assert(CTy && CTy->isVector() && "Composite type is not a vector");
 1360   assert(BaseTy && "Unknown vector element type.");
 1365   assert(Elements.size() == 1 &&
 1374   assert(ActualSize >= (NumVecElements * ElementSize) && "Invalid vector size");
 1564   assert(dwarf::isType(ContextDIE->getTag()) &&
 1709   assert(DD->getDwarfVersion() >= 5 &&
lib/CodeGen/AsmPrinter/EHStreamer.cpp
  118         assert(Actions.size());
  124           assert(PrevAction != (unsigned)-1 && "PrevAction is invalid!");
  134         assert(-1 - TypeID < (int)FilterOffsets.size() && "Unknown filter id!");
  169   assert(MI->isCall() && "This should be a call instruction!");
  210       assert(!PadMap.count(BeginLabel) && "Duplicate landing pad labels!");
  264       assert(BeginLabel == LandingPad->BeginLabels[P.RangeIndex] &&
  278       assert(BeginLabel && LastLabel && "Invalid landing pad!");
lib/CodeGen/AsmPrinter/WasmException.cpp
   55   assert(LSDALabel && ".GCC_exception_table has not been emitted!");
lib/CodeGen/AsmPrinter/WinException.cpp
  174   assert(MBB->isEHFuncletEntry());
  344     assert(UnusedReg ==
  353   assert(FuncInfo.EHRegNodeEndOffset != INT_MAX);
  405     assert(Begin != End);
  415     assert(BaseState == O.BaseState);
  513     assert(CurrentEndLabel != nullptr);
  626   assert(BeginLabel && EndLabel);
  653     assert(UME.ToState < State && "states should decrease");
  791       assert(0 <= TBME.TryLow && "bad trymap interval");
  792       assert(TBME.TryLow <= TBME.TryHigh && "bad trymap interval");
  793       assert(TBME.TryHigh < TBME.CatchHigh && "bad trymap interval");
  794       assert(TBME.CatchHigh < int(FuncInfo.CxxUnwindMap.size()) &&
  840           assert(Offset != 0 && "Illegal offset for catch object!");
  913       assert(FuncInfo.FuncletBaseStateMap.count(FuncletPad) != 0);
  917     assert(StartLabel && "need local function start label");
 1041   assert(!FuncInfo.SEHUnwindMap.empty());
 1110   assert(NumStates > 0 && "Don't need exception table!");
 1119     assert(FuncInfo.ClrEHUnwindMap[State].HandlerParentState < State &&
 1177     assert(HandlerStack.empty());
 1184         assert(CurrentState != NullState &&
 1216     assert(HandlerStack.empty());
 1299       assert(Clause.EnclosingState > MinClauseMap[Clause.State]);
 1313     assert(Entry.HandlerType != ClrHandlerType::Filter && "NYI: filters");
lib/CodeGen/AtomicExpandPass.cpp
  160   assert(Align != 0 && "An atomic LoadInst always has an explicit alignment");
  169   assert(Align != 0 && "An atomic StoreInst always has an explicit alignment");
  223     assert((LI || SI || RMWI || CASI) && "Unknown atomic instruction");
  288         assert(LI->getType()->isIntegerTy() && "invariant broken");
  298         assert(SI->getValueOperand()->getType()->isIntegerTy() &&
  329       assert(!CASI->getCompareOperand()->getType()->isFloatingPointTy() &&
  335         assert(CASI->getCompareOperand()->getType()->isIntegerTy() &&
  365   assert(BitWidth == VT.getSizeInBits() && "must be a power of two");
  652   assert(ValueSize < WordSize);
  744   assert(ExpansionKind == TargetLoweringBase::AtomicExpansionKind::CmpXChg);
  779   assert((Op == AtomicRMWInst::Or || Op == AtomicRMWInst::Xor ||
 1287     assert(EV->getNumIndices() == 1 && EV->getIndices()[0] <= 1 &&
 1397   assert(Success && NewLoaded);
 1419     assert(ValueSize >= MinCASSize &&
 1477   assert(expanded && "expandAtomicOpToLibcall shouldn't fail tor Load");
 1491   assert(expanded && "expandAtomicOpToLibcall shouldn't fail tor Store");
 1507   assert(expanded && "expandAtomicOpToLibcall shouldn't fail tor CAS");
 1613   assert(Libcalls.size() == 6);
 1629   assert(Ordering != AtomicOrdering::NotAtomic && "expect atomic MO");
 1634     assert(Ordering2 != AtomicOrdering::NotAtomic && "expect atomic MO");
lib/CodeGen/BranchFolding.cpp
  154   assert(MBB->pred_empty() && "MBB must be dead!");
  436       assert(P.LaneMask == LaneBitmask::getAll() &&
  648     assert(EHScope1 != EHScopeMembership.end());
  650     assert(EHScope2 != EHScopeMembership.end());
  856     assert(MBBI != MBBIE && "Reached BB end within common tail length!");
  867     assert(MBBICommon != MBBIECommon &&
  869     assert(MBBICommon->isIdenticalTo(*MBBI) && "Expected matching MIIs!");
  898       assert(SameTails[i].getTailStartPos() == MBB->begin() &&
  912       assert(Pos != SameTails[i].getBlock()->end() &&
  916         assert(Pos != SameTails[i].getBlock()->end() &&
  919       assert(MI.isIdenticalTo(*Pos) && "Expected matching MIIs!");
 1305   assert(I != MBB->end() && "empty block!");
 1315   assert(MBB1 && MBB2 && "Unknown MachineBasicBlock");
 1376   assert(IsEmptyBlock(&MBB) && "Expected an empty block (except debug info).");
 1402     assert(MBBEHScope != EHScopeMembership.end());
 1404     assert(FallThroughEHScope != EHScopeMembership.end());
 1498       assert(PrevBB.succ_empty());
 1677               assert(PriorCond.empty() && !PriorFBB &&
 1681               assert(!PriorFBB && "Machine CFG out of date!");
lib/CodeGen/BranchRelaxation.cpp
  131     assert(isAligned(MBB.getAlignment(), BlockInfo[Num].Offset));
  132     assert(!Num || BlockInfo[PrevNum].postOffset(MBB) <= BlockInfo[Num].Offset);
  133     assert(BlockInfo[Num].Size == computeBlockSize(MBB));
  188     assert(I != MBB->end() && "Didn't find MI in its own basic block?");
  340   assert(!Fail && "branches to be relaxed must be analyzable");
  447   assert(!TII->isBranchOffsetInRange(MI.getOpcode(), DestOffset - SrcOffset));
lib/CodeGen/BreakFalseDeps.cpp
  110   assert(MO.isUndef() && "Expected undef machine operand");
  178   assert(!MI->isDebugInstr() && "Won't process debug values");
lib/CodeGen/CalcSpillWeights.cpp
  100     assert(MI && "Dead valno in interval");
  124         assert(VNI && "Copy from non-existing value");
  128         assert(MI && "Dead valno in interval");
  174     assert(localMBB == LIS.getMBBFromIndex(*start) &&
lib/CodeGen/CallingConvLower.cpp
  225   assert(NumLocs < Locs.size() && "CC assignment failed to add location");
lib/CodeGen/CodeGenPrepare.cpp
  830       assert(SinglePred == BB &&
  950     assert(ToReplace->getBasePtrIndex() == RelocatedBase->getBasePtrIndex() &&
  975     assert(RelocatedBase->getNextNode() &&
 1113       assert(InsertPt != UserBB->end());
 1201     assert(isa<Constant>(Arg1) && "Unexpected input for usubo");
 1213   assert(InsertPt != nullptr && "Parent block did not contain cmp or binop");
 1387       assert(InsertPt != UserBB->end());
 1434   assert(!InsertedInsts.count(AndI) &&
 1567       assert(InsertPt != TruncUserBB->end());
 1580       assert(TruncInsertPt != TruncUserBB->end());
 1668       assert(InsertPt != UserBB->end());
 2173       assert(BaseReg == nullptr);
 2191       assert(ScaledReg == nullptr);
 2814     (void)Success; assert(Success && "Couldn't select *anything*?");
 2954   assert(CurrentIndex < Set->NodeList.size() &&
 2960   assert(CurrentIndex < Set->NodeList.size() &&
 3035     assert(To && Get(To) == To && "Replacement PHI node is already replaced.");
 3211     assert(CommonType && "At least one non-null value must be!");
 3385       assert(Map.find(Current) != Map.end() && "No node to fill!!!");
 3392         assert(Map.find(TrueValue) != Map.end() && "No True Value!");
 3395         assert(Map.find(FalseValue) != Map.end() && "No False Value!");
 3403           assert(Map.find(PV) != Map.end() && "No predecessor Value!");
 3420     assert((isa<PHINode>(Original) || isa<SelectInst>(Original)) &&
 3823   assert((isa<SExtInst>(Ext) || isa<ZExtInst>(Ext)) &&
 4275     assert(PromotedOperand &&
 4614     (void)Success; assert(Success && "Couldn't select *anything*?");
 4867           assert(cast<IntegerType>(IntPtrTy)->getBitWidth() <
 5059   assert(!Val->use_empty() && "Input must have at least one use");
 5151     assert(PromotedVal &&
 5481     assert(LI && ExtFedByLoad && "Expect a valid load and extension");
 5636       assert(InsertPt != UserBB->end());
 5889     assert(DefSI->getCondition() == SI->getCondition() &&
 5894   assert(V && "Failed to get select true/false value");
 5899   assert(Shift->isShift() && "Expected a shift");
 6046     assert(TrueBlock == nullptr &&
 6148       assert(InsertPt != UserBB->end());
 6321     assert(isa<ExtractElementInst>(Transition) &&
 6330     assert(isa<ExtractElementInst>(Transition) &&
 6468     assert(Transition && "Do not know how to promote null");
 6517     assert(canCombine(ToBeCombined) && "Unsupported instruction to combine");
 6554   assert(ToBePromoted->getType() == Transition->getType() &&
 6915   assert(find_if(GEPIOp->users(), [&](User *Usr) {
lib/CodeGen/CriticalAntiDepBreaker.cpp
  117   assert(Count < InsertPosIndex && "Instruction index out of expected range!");
  256   assert(!MI.isKill() && "Attempting to scan a kill instruction");
  412     assert(((KillIndices[AntiDepReg] == ~0u) != (DefIndices[AntiDepReg] == ~0u))
  414     assert(((KillIndices[NewReg] == ~0u) != (DefIndices[NewReg] == ~0u))
  460   assert(Max && "Failed to find bottom of the critical path");
  561           assert(AntiDepReg != 0 && "Anti-dependence on reg0?");
  631     assert((AntiDepReg == 0 || RC != nullptr) &&
  673         assert(((KillIndices[NewReg] == ~0u) !=
  680         assert(((KillIndices[AntiDepReg] == ~0u) !=
lib/CodeGen/DFAPacketizer.cpp
   67   assert((InsnClass.size() <= DFA_MAX_RESTERMS) &&
   93     assert((i++ < DFA_MAX_RESTERMS) && "Exceeded maximum number of DFA inputs");
  135   assert(!NfaPaths.empty() && "Invalid bundle!");
  233   assert(VLIWScheduler && "VLIW Scheduler is not initialized!");
  274     assert(SUI && "Missing SUnit Info!");
  290         assert(SUJ && "Missing SUnit Info!");
lib/CodeGen/DetectDeadLanes.cpp
  156   assert(lowersToCopies(MI));
  233   assert(lowersToCopies(MI) &&
  241     assert(OpNum % 2 == 1);
  261     assert(OpNum == 1);
  265     assert(OpNum == 1);
  327       assert(OpNum == 1 && "INSERT_SUBREG must have two operands");
  335     assert(OpNum == 1 && "EXTRACT_SUBREG must have one register operand only");
  346   assert(Def.getSubReg() == 0 &&
  390         assert(Register::isVirtualRegister(MOReg));
  412   assert(Def.getSubReg() == 0 &&
  429       assert(UseMI.getDesc().getNumDefs() == 1);
lib/CodeGen/EarlyIfConversion.cpp
  518     assert(Register::isVirtualRegister(PI.TReg) && "Bad PHI");
  519     assert(Register::isVirtualRegister(PI.FReg) && "Bad PHI");
  560   assert(Tail->pred_size() == 2 && "Cannot replace PHIs");
  562   assert(FirstTerm != Head->end() && "No terminators");
  582   assert(FirstTerm != Head->end() && "No terminators");
  625   assert(Head && Tail && TBB && FBB && "Call canConvertIf first.");
  675   assert(Head->succ_empty() && "Additional head successors?");
  757     assert(Node != HeadNode && "Cannot erase the head node");
  759       assert(Node->getBlock() == IfConv.Tail && "Unexpected children");
lib/CodeGen/ExecutionDomainFix.cpp
   20   assert(Reg < AliasMap.size() && "Invalid register");
   30   assert(dv->Refs == 0 && "Reference count wasn't cleared");
   31   assert(!dv->Next && "Chained DomainValue shouldn't have been recycled");
   37     assert(DV->Refs && "Bad DomainValue");
   71   assert(unsigned(rx) < NumRegs && "Invalid index");
   72   assert(!LiveRegs.empty() && "Must enter basic block first.");
   82   assert(unsigned(rx) < NumRegs && "Invalid index");
   83   assert(!LiveRegs.empty() && "Must enter basic block first.");
   92   assert(unsigned(rx) < NumRegs && "Invalid index");
   93   assert(!LiveRegs.empty() && "Must enter basic block first.");
  103       assert(LiveRegs[rx] && "Not live after collapse?");
  113   assert(dv->hasDomain(domain) && "Cannot collapse");
  128   assert(!A->isCollapsed() && "Cannot merge into collapsed");
  129   assert(!B->isCollapsed() && "Cannot merge from collapsed");
  145     assert(!LiveRegs.empty() && "no space allocated for live registers");
  170     assert(unsigned(pred->getNumber()) < MBBOutRegsInfos.size() &&
  210   assert(!LiveRegs.empty() && "Must enter basic block first.");
  212   assert(MBBNumber < MBBOutRegsInfos.size() &&
  236   assert(!MI->isDebugInstr() && "Won't process debug values");
  331     assert(!LiveRegs.empty() && "no space allocated for live registers");
  355       assert(dv->AvailableDomains && "Domain should have been filtered");
  368       assert(!LiveRegs.empty() && "no space allocated for live registers");
  420   assert(NumRegs == RC->getNumRegs() && "Bad regclass");
lib/CodeGen/ExpandMemCmp.cpp
  166   assert(NumNonOverlappingLoads && "there must be at least one load");
  188   assert(Size > 0 && Size < MaxLoadSize && "broken invariant");
  209   assert(Size > 0 && "zero blocks");
  215   assert(!LoadSizes.empty() && "cannot load Size bytes");
  222   assert(LoadSequence.size() <= Options.MaxNumLoads && "broken invariant");
  237   assert(LoadSequence.size() <= Options.MaxNumLoads && "broken invariant");
  316   assert(LoadIndex < getNumLoads() &&
  397     assert(Diff && "Failed to find comparison diff");
  446   assert(CurLoadEntry.LoadSize <= MaxLoadSize && "Unexpected load type");
  559   assert(LoadIndex == getNumLoads() && "some entries were not consumed");
lib/CodeGen/ExpandPostRAPseudos.cpp
   77   assert((MI->getOperand(0).isReg() && MI->getOperand(0).isDef()) &&
   84   assert(!MI->getOperand(2).getSubReg() && "SubIdx on physreg?");
   87   assert(SubIdx != 0 && "Invalid index for insert_subreg");
   90   assert(Register::isPhysicalRegister(DstReg) &&
   92   assert(Register::isPhysicalRegister(InsReg) &&
lib/CodeGen/FuncletLayout.cpp
   54     assert(FuncletX != FuncletMembership.end());
   55     assert(FuncletY != FuncletMembership.end());
lib/CodeGen/GCMetadata.cpp
   67   assert(!F.isDeclaration() && "Can only get GCFunctionInfo for a definition!");
   68   assert(F.hasGC());
  141   assert(GMI && "Printer didn't require GCModuleInfo?!");
lib/CodeGen/GCRootLowering.cpp
  107   assert(MI && "LowerIntrinsics didn't require GCModuleInfo!?");
  291   assert(TFI && "TargetRegisterInfo not available!");
lib/CodeGen/GlobalISel/CSEInfo.cpp
   97   assert(Removed && "Invalidation called on invalid UMI");
  119   assert(UMI);
  129   assert(InstrMapping.count(UMI->MI) == 0 &&
  135   assert(shouldCSE(MI->getOpcode()) && "Trying to CSE an unsupported Node");
  141   assert(MI);
  177   assert(shouldCSE(MI->getOpcode()) && "Invalid instruction for CSE");
  217   assert(CSEOpt.get() && "CSEConfig not set");
  348     assert(!MO.isImplicit() && "Unhandled case");
lib/CodeGen/GlobalISel/CSEMIRBuilder.cpp
   24   assert(A->getParent() == B->getParent() &&
   37   assert(CSEInfo && "Can't get here without setting CSEInfo");
  107   assert(canPerformCSEForOpc(MIB->getOpcode()) &&
  127   assert(checkCopyToDefsPossible(DstOps) &&
  158     assert(SrcOps.size() == 2 && "Invalid sources");
  159     assert(DstOps.size() == 1 && "Invalid dsts");
  166     assert(DstOps.size() == 1 && "Invalid dst ops");
  167     assert(SrcOps.size() == 2 && "Invalid src ops");
lib/CodeGen/GlobalISel/CallLowering.cpp
  128   assert(SrcRegs.size() > 1 && "Nothing to pack");
  138   assert(LLTs.size() == SrcRegs.size() && "Regs / types mismatch");
  154   assert(DstRegs.size() > 1 && "Nothing to unpack");
  161   assert(LLTs.size() == DstRegs.size() && "Regs / types mismatch");
  261         assert(Unmerge->getNumOperands() == NumParts + 1);
  286     assert(j < ArgLocs.size() && "Skipped too many arg locs");
  289     assert(VA.getValNo() == i && "Location doesn't correspond to current arg");
  309           assert((j + (NumArgRegs - 1)) < ArgLocs.size() &&
  343         assert((j + (Args[i].Regs.size() - 1)) < ArgLocs.size() &&
lib/CodeGen/GlobalISel/CombinerHelper.cpp
   57   assert(FromRegOp.getParent() && "Expected an operand in an MI");
  104   assert(MI.getOpcode() == TargetOpcode::G_CONCAT_VECTORS &&
  118     assert(Def && "Operand not defined");
  138       assert(MRI.getType(Undef->getOperand(0).getReg()) ==
  187   assert(MI.getOpcode() == TargetOpcode::G_SHUFFLE_VECTOR &&
  372   assert(LoadValue.isReg() && "Result wasn't a register?");
  417   assert(Preferred.Ty != LoadValueTy && "Extending to same type?");
  534   assert(DefMI.getParent() == UseMI.getParent());
  562   assert(Opcode == TargetOpcode::G_LOAD || Opcode == TargetOpcode::G_SEXTLOAD ||
  629   assert(Opcode == TargetOpcode::G_LOAD || Opcode == TargetOpcode::G_SEXTLOAD ||
  758   assert(std::next(BrIt) == MBB->end() && "expected G_BR to be a terminator");
  839     assert(Ty.getSizeInBits() > 0 && "Could not find valid type");
  855       assert(NewTySize > 0 && "Could not find appropriate type");
  915   assert(ExtType == Ty && "Vector memset value type not supported yet");
  927   assert(KnownLen != 0 && "Have a zero length memset length!");
  993       assert(I == MemOps.size() - 1 && I != 0);
 1041   assert(KnownLen != 0 && "Have a zero length memcpy length!");
 1149   assert(KnownLen != 0 && "Have a zero length memmove length!");
 1250   assert(MI.getOpcode() == TargetOpcode::G_INTRINSIC_W_SIDE_EFFECTS);
 1252   assert((ID == Intrinsic::memcpy || ID == Intrinsic::memmove ||
 1270     assert(MMOIt != MI.memoperands_end() && "Expected a second MMO on MI");
lib/CodeGen/GlobalISel/GISelKnownBits.cpp
  355     assert(SrcBitWidth && "SrcBitWidth can't be zero");
  365   assert(!Known.hasConflict() && "Bits known to be one AND zero?");
lib/CodeGen/GlobalISel/IRTranslator.cpp
  133     assert(getCurrentInst() && "Inserted instruction without a current MI");
  143     assert((CurrInst->getDebugLoc() == MI.getDebugLoc() ||
  162   assert(!VMap.contains(Val) && "Value already allocated in VMap");
  185   assert(Val.getType()->isSized() &&
  207     assert(SplitTys.size() == 1 && "unexpectedly split LLT");
  278   assert(MBB && "BasicBlock was not encountered before");
  283   assert(NewPred && "new predecessor must be a real MachineBasicBlock");
  354     assert(CI && "Instruction should be CmpInst");
  444     assert(Succ && "Could not find successor mbb in mapping");
  489   assert(!Clusters.empty());
  510   assert(JT.Reg != -1U && "Should lower JT Header first!");
  593     assert(CB.PredInfo.Pred == CmpInst::ICMP_SLE &&
  877     assert(Regs.size() == 1 && "swifterror should be single pointer");
  919     assert(Vals.size() == 1 && "swifterror should be single pointer");
 1319     assert(DI.getVariable() && "Missing variable");
 1327     assert(DI.getVariable()->isValidLocationForIntrinsic(
 1346     assert(DI.getLabel() && "Missing label");
 1348     assert(DI.getLabel()->isValidLocationForIntrinsic(
 1375     assert(DI.getVariable()->isValidLocationForIntrinsic(
 1554       assert(SwiftInVReg == 0 && "Expected only one swift error argument");
 1576     assert(!HasTailCall && "Can't tail call return twice from block?");
 1610   assert(ID != Intrinsic::not_intrinsic && "unknown intrinsic");
 1637         assert(CI->getBitWidth() <= 64 &&
 1761   assert(Tys.size() == 2 && "Only two-valued landingpads are supported");
 1840   assert(MF->getFrameInfo().hasVarSizedObjects());
 2252   assert(PendingPHIs.empty() && "stale PHIs");
 2305       assert(VRegs.size() == 1 && "Too many vregs for Swift error");
 2379   assert(EntryBB->succ_size() == 1 &&
 2383   assert(NewEntryBB.pred_size() == 1 &&
 2400   assert(&MF->front() == &NewEntryBB &&
lib/CodeGen/GlobalISel/InstructionSelect.cpp
   78   assert(ISel && "Cannot work without InstructionSelector");
lib/CodeGen/GlobalISel/Legalizer.cpp
  217     assert(RetryList.empty() && "Expected no instructions in RetryList");
  221       assert(isPreISelGenericOpcode(MI.getOpcode()) && "Expecting generic opcode");
  260       assert(isPreISelGenericOpcode(MI.getOpcode()) && "Expecting generic opcode");
lib/CodeGen/GlobalISel/LegalizerHelper.cpp
   42   assert(!LeftoverTy.isValid() && "this is an out argument");
   48   assert(Size > NarrowSize);
  134   assert(!LeftoverTy.isValid() && "this is an out argument");
  177     assert(OrigTy.getElementType() == TargetTy.getElementType());
  184     assert(OrigTy.getElementType() == TargetTy);
  188   assert(!OrigTy.isVector() && !TargetTy.isVector());
  201     assert(LeftoverRegs.empty());
  243     assert((Size == 32 || Size == 64 || Size == 128) && "Unsupported size");
  255     assert((Size == 32 || Size == 64 || Size == 128) && "Unsupported size");
  267     assert((Size == 32 || Size == 64) && "Unsupported size");
  270     assert((Size == 32 || Size == 64) && "Unsupported size");
  273     assert(Size == 32 && "Unsupported size");
  276     assert((Size == 32 || Size == 64) && "Unsupported size");
  279     assert((Size == 32 || Size == 64) && "Unsupported size");
  282     assert((Size == 32 || Size == 64) && "Unsupported size");
  285     assert((Size == 32 || Size == 64) && "Unsupported size");
  288     assert((Size == 32 || Size == 64) && "Unsupported size");
  291     assert((Size == 32 || Size == 64) && "Unsupported size");
  298     assert((Size == 32 || Size == 64) && "Unsupported size");
  301     assert((Size == 32 || Size == 64 || Size == 128) && "Unsupported size");
  305     assert((Size == 32 || Size == 64 || Size == 128) && "Unsupported size");
  309     assert((Size == 32 || Size == 64 || Size == 128) && "Unsupported size");
  313     assert((Size == 32 || Size == 64 || Size == 128) && "Unsupported size");
  317     assert((Size == 32 || Size == 64 || Size == 128) && "Unsupported size");
  321     assert((Size == 32 || Size == 64) && "Unsupported size");
  324     assert((Size == 32 || Size == 64) && "Unsupported size");
  394   assert(MI.getOpcode() == TargetOpcode::G_INTRINSIC_W_SIDE_EFFECTS);
  445     assert(Info.IsTailCall && "Lowered tail call when it wasn't a tail call?");
  448     assert(MI.getNextNode() && MI.getNextNode()->isReturn() &&
 1048         assert(PartialExtensionReg &&
 1183       assert(MRI.getType(SrcReg) == LLT::scalar(PartSize));
 1556       assert(TypeIdx == 1);
 1587       assert(TypeIdx == 1);
 1704     assert(!LosesInfo && "extend should always be lossless");
 1752     assert(TypeIdx == 1 && "unable to legalize pointer of GEP");
 1759     assert(TypeIdx == 0 && "Expecting only Idx 0");
 1852     assert(TypeIdx == 0);
 2260     assert(MI.getOperand(2).isImm() && "Expected immediate");
 2476       assert(NewInsts.size() == PartRegs.size() + LeftoverRegs.size());
 2631   assert(TypeIdx == 0 || CondTy.isVector());
 2801   assert(TypeIdx == 0 && "not a vector type index");
 3243   assert(TypeIdx == 0 && "Expecting only Idx 0");
 3577   assert(DstRegs.size() == (unsigned)NumParts && "not all parts covered");
 3593   assert(MI.getNumOperands() == 3 && TypeIdx == 0);
 3797   assert(MRI.getType(Src) == S64 && MRI.getType(Dst) == S32);
 4121     assert(Mask.size() == 1 && "Expected a single mask element");
lib/CodeGen/GlobalISel/LegalizerInfo.cpp
  193       assert(mutationIsSane(Rule, Query, Mutation) &&
  195       assert(hasNoSimpleLoops(Rule, Query, Mutation) && "Simple loop detected");
  285   assert(TablesInitialized == false);
  351           assert(BitsizeAndAction.first % ElementSize == 0);
  380   assert(TablesInitialized && "backend forgot to call computeTables");
  385   assert(Aspect.Type.isVector());
  393   assert(TypeIdx < MI.getNumOperands() && "Unexpected TypeIdx");
  403   assert(Opcode >= FirstOp && Opcode <= LastOp && "Unsupported opcode");
  413     assert(RulesForOpcode[OpcodeIdx].getAlias() == 0 && "Cannot chain aliases");
  428   assert(!Result.isAliasedByAnother() && "Modifying this opcode will modify aliases");
  436   assert(!llvm::empty(Opcodes) && Opcodes.begin() + 1 != Opcodes.end() &&
  449   assert(OpcodeTo != OpcodeFrom && "Cannot alias to self");
  450   assert(OpcodeTo >= FirstOp && OpcodeTo <= LastOp && "Unsupported opcode");
  564   assert(Size >= 1);
  570   assert(It != Vec.begin() && "Does Vec not start with size 1?");
  620   assert(Aspect.Type.isScalar() || Aspect.Type.isPointer());
  649   assert(Aspect.Type.isVector());
lib/CodeGen/GlobalISel/Localizer.cpp
  122     assert(MI.getDesc().getNumDefs() == 1 &&
  200     assert(II != MBB.end() && "Didn't find the user in the MBB");
lib/CodeGen/GlobalISel/MachineIRBuilder.cpp
   39   assert(&getMF() == MBB.getParent() &&
   44   assert(MI.getParent() && "Instruction is not part of a basic block");
   53   assert(MBB.getParent() == &getMF() &&
   92   assert(isa<DILocalVariable>(Variable) && "not a variable");
   93   assert(cast<DIExpression>(Expr)->isValid() && "not an expression");
   94   assert(
  105   assert(isa<DILocalVariable>(Variable) && "not a variable");
  106   assert(cast<DIExpression>(Expr)->isValid() && "not an expression");
  107   assert(
  122   assert(isa<DILocalVariable>(Variable) && "not a variable");
  123   assert(cast<DIExpression>(Expr)->isValid() && "not an expression");
  124   assert(
  141   assert(isa<DILocalVariable>(Variable) && "not a variable");
  142   assert(cast<DIExpression>(Expr)->isValid() && "not an expression");
  143   assert(
  163   assert(isa<DILabel>(Label) && "not a label");
  164   assert(cast<DILabel>(Label)->isValidLocationForIntrinsic(State.DL) &&
  174   assert(Res.getLLTTy(*getMRI()).isPointer() && "expected ptr dst type");
  184   assert(Res.getLLTTy(*getMRI()).isPointer() && "invalid operand type");
  193   assert(Res.getLLTTy(*getMRI()).isPointer() && "invalid operand type");
  194   assert(Res.getLLTTy(*getMRI()).getAddressSpace() ==
  212   assert((Res.isScalar() || Res.isVector()) && "invalid operand type");
  213   assert((Res == Op0 && Res == Op1) && "type mismatch");
  218   assert((Res.isScalar() || Res.isVector()) && "invalid operand type");
  219   assert((Res == Op0) && "type mismatch");
  225   assert(Res.getLLTTy(*getMRI()).isPointer() &&
  227   assert(Op1.getLLTTy(*getMRI()).isScalar() && "invalid offset type");
  235   assert(Res == 0 && "Res is a result argument");
  236   assert(ValueTy.isScalar()  && "invalid offset type");
  251   assert(Res.getLLTTy(*getMRI()).isPointer() &&
  266   assert(getMRI()->getType(Tgt).isPointer() && "invalid branch destination");
  273   assert(getMRI()->getType(TablePtr).isPointer() &&
  290   assert(EltTy.getScalarSizeInBits() == Val.getBitWidth() &&
  319   assert(APFloat::getSizeInBits(Val.getValueAPF().getSemantics())
  323   assert(!Ty.isPointer() && "invalid operand type");
  363   assert(getMRI()->getType(Tst).isScalar() && "invalid operand type");
  378   assert(Res.getLLTTy(*getMRI()).isValid() && "invalid operand type");
  379   assert(Addr.getLLTTy(*getMRI()).isPointer() && "invalid operand type");
  391   assert(Val.getLLTTy(*getMRI()).isValid() && "invalid operand type");
  392   assert(Addr.getLLTTy(*getMRI()).isPointer() && "invalid operand type");
  454   assert((TargetOpcode::G_ANYEXT == ExtOpc || TargetOpcode::G_ZEXT == ExtOpc ||
  457   assert(Res.getLLTTy(*getMRI()).isScalar() ||
  459   assert(Res.getLLTTy(*getMRI()).isScalar() ==
  470     assert(Res.getLLTTy(*getMRI()) == Op.getLLTTy(*getMRI()));
  503     assert(!SrcTy.isPointer() && !DstTy.isPointer() && "n G_ADDRCAST yet");
  517   assert(SrcTy.isValid() && "invalid operand type");
  518   assert(DstTy.isValid() && "invalid operand type");
  519   assert(Index + DstTy.getSizeInBits() <= SrcTy.getSizeInBits() &&
  524     assert(Index == 0 && "insertion past the end of a register");
  538   assert(Ops.size() == Indices.size() && "incompatible args");
  539   assert(!Ops.empty() && "invalid trivial sequence");
  540   assert(std::is_sorted(Indices.begin(), Indices.end()) &&
  543   assert(getMRI()->getType(Res).isValid() && "invalid operand type");
  545     assert(getMRI()->getType(Op).isValid() && "invalid operand type");
  586   assert(TmpVec.size() > 1);
  596   assert(TmpVec.size() > 1);
  615   assert(TmpVec.size() > 1);
  655   assert(Index + getMRI()->getType(Op).getSizeInBits() <=
  752   assert(OldValResTy.isScalar() && "invalid operand type");
  753   assert(SuccessResTy.isScalar() && "invalid operand type");
  754   assert(AddrTy.isPointer() && "invalid operand type");
  755   assert(CmpValTy.isValid() && "invalid operand type");
  756   assert(NewValTy.isValid() && "invalid operand type");
  757   assert(OldValResTy == CmpValTy && "type mismatch");
  758   assert(OldValResTy == NewValTy && "type mismatch");
  779   assert(OldValResTy.isScalar() && "invalid operand type");
  780   assert(AddrTy.isPointer() && "invalid operand type");
  781   assert(CmpValTy.isValid() && "invalid operand type");
  782   assert(NewValTy.isValid() && "invalid operand type");
  783   assert(OldValResTy == CmpValTy && "type mismatch");
  784   assert(OldValResTy == NewValTy && "type mismatch");
  804   assert(OldValResTy.isScalar() && "invalid operand type");
  805   assert(AddrTy.isPointer() && "invalid operand type");
  806   assert(ValTy.isValid() && "invalid operand type");
  807   assert(OldValResTy == ValTy && "type mismatch");
  808   assert(MMO.isAtomic() && "not atomic mem operand");
  912   assert(getMRI()->getType(Res).isPointer() && "invalid res type");
  922     assert(SrcTy.isVector() && "mismatched cast between vector and non-vector");
  923     assert(SrcTy.getNumElements() == DstTy.getNumElements() &&
  926     assert(DstTy.isScalar() && SrcTy.isScalar() && "invalid extend/trunc");
  929     assert(DstTy.getSizeInBits() > SrcTy.getSizeInBits() &&
  932     assert(DstTy.getSizeInBits() < SrcTy.getSizeInBits() &&
  940   assert((ResTy.isScalar() || ResTy.isVector() || ResTy.isPointer()) &&
  942   assert((ResTy == Op0Ty && ResTy == Op1Ty) && "type mismatch");
  944     assert(TstTy.isScalar() && "type mismatch");
  946     assert((TstTy.isScalar() ||
  961     assert(DstOps.size() == 1 && "Invalid select");
  962     assert(SrcOps.size() == 3 && "Invalid select");
  983     assert(DstOps.size() == 1 && "Invalid Dst");
  984     assert(SrcOps.size() == 2 && "Invalid Srcs");
  993     assert(DstOps.size() == 1 && "Invalid Dst");
  994     assert(SrcOps.size() == 2 && "Invalid Srcs");
 1003     assert(DstOps.size() == 1 && "Invalid Dst");
 1004     assert(SrcOps.size() == 1 && "Invalid Srcs");
 1010     assert(DstOps.size() == 1 && "Invalid Dst");
 1011     assert(SrcOps.size() == 1 && "Invalid Srcs");
 1017     assert(DstOps.size() == 1 && "Invalid Dst");
 1023     assert(DstOps.size() == 1 && "Invalid Dst Operands");
 1024     assert(SrcOps.size() == 3 && "Invalid Src Operands");
 1027     assert(SrcOps[0].getSrcOpKind() == SrcOp::SrcType::Ty_Predicate &&
 1029     assert([&]() -> bool {
 1034     assert(SrcOps[1].getLLTTy(*getMRI()) == SrcOps[2].getLLTTy(*getMRI()) &&
 1036     assert([&]() -> bool {
 1048     assert(!DstOps.empty() && "Invalid trivial sequence");
 1049     assert(SrcOps.size() == 1 && "Invalid src for Unmerge");
 1050     assert(std::all_of(DstOps.begin(), DstOps.end(),
 1056     assert(DstOps.size() * DstOps[0].getLLTTy(*getMRI()).getSizeInBits() ==
 1062     assert(!SrcOps.empty() && "invalid trivial sequence");
 1063     assert(DstOps.size() == 1 && "Invalid Dst");
 1064     assert(std::all_of(SrcOps.begin(), SrcOps.end(),
 1070     assert(SrcOps.size() * SrcOps[0].getLLTTy(*getMRI()).getSizeInBits() ==
 1083     assert(DstOps.size() == 1 && "Invalid Dst size");
 1084     assert(SrcOps.size() == 2 && "Invalid Src size");
 1085     assert(SrcOps[0].getLLTTy(*getMRI()).isVector() && "Invalid operand type");
 1086     assert((DstOps[0].getLLTTy(*getMRI()).isScalar() ||
 1089     assert(SrcOps[1].getLLTTy(*getMRI()).isScalar() && "Invalid operand type");
 1090     assert(SrcOps[0].getLLTTy(*getMRI()).getElementType() ==
 1096     assert(DstOps.size() == 1 && "Invalid dst size");
 1097     assert(SrcOps.size() == 3 && "Invalid src size");
 1098     assert(DstOps[0].getLLTTy(*getMRI()).isVector() &&
 1100     assert(DstOps[0].getLLTTy(*getMRI()).getElementType() ==
 1103     assert(SrcOps[2].getLLTTy(*getMRI()).isScalar() && "Invalid index");
 1104     assert(DstOps[0].getLLTTy(*getMRI()).getNumElements() ==
 1110     assert((!SrcOps.empty() || SrcOps.size() < 2) &&
 1112     assert(DstOps.size() == 1 && "Invalid DstOps");
 1113     assert(DstOps[0].getLLTTy(*getMRI()).isVector() &&
 1115     assert(std::all_of(SrcOps.begin(), SrcOps.end(),
 1121     assert(SrcOps.size() * SrcOps[0].getLLTTy(*getMRI()).getSizeInBits() ==
 1127     assert((!SrcOps.empty() || SrcOps.size() < 2) &&
 1129     assert(DstOps.size() == 1 && "Invalid DstOps");
 1130     assert(DstOps[0].getLLTTy(*getMRI()).isVector() &&
 1132     assert(std::all_of(SrcOps.begin(), SrcOps.end(),
 1144     assert(DstOps.size() == 1 && "Invalid DstOps");
 1145     assert((!SrcOps.empty() || SrcOps.size() < 2) &&
 1147     assert(std::all_of(SrcOps.begin(), SrcOps.end(),
 1154     assert(SrcOps.size() * SrcOps[0].getLLTTy(*getMRI()).getSizeInBits() ==
 1160     assert(DstOps.size() == 2 && "Invalid no of dst operands");
 1161     assert(SrcOps.size() == 3 && "Invalid no of src operands");
 1162     assert(DstOps[0].getLLTTy(*getMRI()).isScalar() && "Invalid operand");
 1163     assert((DstOps[0].getLLTTy(*getMRI()) == SrcOps[0].getLLTTy(*getMRI())) &&
 1166     assert(DstOps[1].getLLTTy(*getMRI()).isScalar() && "Invalid operand");
 1167     assert(DstOps[1].getLLTTy(*getMRI()) == SrcOps[2].getLLTTy(*getMRI()) &&
lib/CodeGen/GlobalISel/RegBankSelect.cpp
   83   assert(RBI && "Cannot work without RegisterBankInfo");
  128              assert(DesiredRegBrank && "The mapping must be valid");
  138   assert(ValMapping.NumBreakDowns == (unsigned)size(NewVRegs) &&
  142   assert(!NewVRegs.empty() && "We should not have to repair");
  156     assert((RepairPt.getNumInsertPoints() == 1 ||
  171     assert(ValMapping.partsAllUniform() && "irregular breakdowns not supported");
  180           assert(
  239   assert(MO.isReg() && "We should only repair register operand");
  240   assert(ValMapping.NumBreakDowns && "Nothing to map??");
  246   assert(CurRegBank || MO.isDef());
  291   assert(!PossibleMappings.empty() &&
  318     assert(BestMapping && "No suitable mapping for instruction");
  326   assert(RepairPt.hasSplit() && "We should not have to adjust for split");
  329   assert((MI.isPHI() || MI.isTerminator()) && "Why do we split?");
  331   assert(&MI.getOperand(RepairPt.getOpIdx()) == &MO &&
  338   assert((!MI.isPHI() || !MO.isDef()) && "Need split for phi def?");
  343       assert(&MI != &(*MI.getParent()->getFirstTerminator()) &&
  365   assert(MI.isTerminator() && MO.isDef() &&
  413     assert(&MI == &(*MI.getParent()->getFirstTerminator()) &&
  416     assert((!Next || Next->isUnconditionalBranch()) &&
  422       assert(!Next->readsRegister(Reg) && "Need to split between terminators");
  431       assert(false && "Repairing cost may not be accurate");
  445   assert((MBFI || !BestCost) && "Costs comparison require MBFI");
  453   assert(!Saturated && "Possible mapping saturated the cost");
  514     assert(MBFI && MBPI && "Cost computation requires MBFI and MBPI");
  539     assert(((RepairCost < RepairCost * PercentageForBias) &&
  544       assert(InsertPt->canMaterialize() && "We should not have made it here");
  552         assert(CostForInsertPt + Bias > CostForInsertPt &&
  591     assert(RepairPt.getKind() != RepairingPlacement::None &&
  601       assert(ValMapping.NumBreakDowns == 1 &&
  642   assert(BestMapping->verify(MI) && "Invalid instruction mapping");
  729   assert(MO.isReg() && "Trying to repair a non-reg operand");
  789         assert(!It->modifiesRegister(MO.getReg(), &TRI) &&
  807       assert(It->modifiesRegister(MO.getReg(), &TRI) &&
  843   assert((!Before || !Instr.isPHI()) &&
  845   assert((!Before || !Instr.getNextNode() || !Instr.getNextNode()->isPHI()) &&
  903   assert(Src.isSuccessor(DstOrSplit) && DstOrSplit->isPredecessor(&Src) &&
  906   assert(NewBB && "Invalid call to materialize");
  932   assert(Src.succ_size() > 1 && DstOrSplit->pred_size() > 1 &&
lib/CodeGen/GlobalISel/RegisterBank.cpp
   32   assert(isValid() && "Invalid register bank");
   52       assert(getSize() >= TRI.getRegSizeInBits(SubRC) &&
   54       assert(covers(SubRC) && "Not all subclasses are covered");
   61   assert(isValid() && "RB hasn't been initialized yet");
   75   assert((OtherRB.getID() != getID() || &OtherRB == this) &&
   99   assert(ContainedRegClasses.size() == TRI->getNumRegClasses() &&
lib/CodeGen/GlobalISel/RegisterBankInfo.cpp
   63     assert(RegBanks[Idx] != nullptr && "Invalid RegisterBank");
   64     assert(RegBanks[Idx]->isValid() && "RegisterBank should be valid");
   73     assert(Idx == RegBank.getID() &&
   76     assert(RegBank.verify(TRI) && "RegBank is invalid");
   88   assert(Reg && "NoRegister does not have a register bank");
  100   assert(Register::isPhysicalRegister(Reg) && "Reg must be a physreg");
  121   assert(RegBank.covers(*RC) &&
  253   assert(CompleteMapping && "Setting an uncomplete mapping");
  379   assert(((IsInvalid && ID == InvalidMappingID && Cost == 0 &&
  422     assert(Mapping->verify(MI) && "Mapping is invalid");
  450     assert(OpdMapper.getInstrMapping().getOperandMapping(OpIdx).NumBreakDowns !=
  453     assert(OpdMapper.getInstrMapping().getOperandMapping(OpIdx).NumBreakDowns ==
  477       assert(OrigTy.getSizeInBits() <= NewTy.getSizeInBits() &&
  497     assert(RC && "Expecting Register class");
  514   assert(RegBank && "Register bank not set");
  515   assert(Length && "Empty mapping");
  516   assert((StartIdx <= getHighBitIdx()) && "Overflow, switch to APInt?");
  518   assert(RegBank->getSize() >= Length && "Register bank too small for Mask");
  544   assert(NumBreakDowns && "Value mapped nowhere?!");
  549     assert(PartMap.verify() && "Partial mapping is invalid");
  555   assert(OrigValueBitWidth >= MeaningfulBitWidth &&
  565     assert((ValueMask & PartMapMask) == PartMapMask &&
  568   assert(ValueMask.isAllOnesValue() && "Value is not fully mapped");
  595   assert(NumOperands == (isCopyLike(MI) ? 1 : MI.getNumOperands()) &&
  597   assert(MI.getParent() && MI.getMF() &&
  606       assert(!getOperandMapping(Idx).isValid() &&
  613     assert(getOperandMapping(Idx).isValid() &&
  619     assert(MOMapping.verify(RBI->getSizeInBits(
  652   assert(InstrMapping.verify(MI) && "Invalid mapping for MI");
  657   assert(OpIdx < getInstrMapping().getNumOperands() && "Out-of-bound access");
  685   assert((NewVRegs.size() == StartIdx + NumVal ||
  693   assert(OpIdx < getInstrMapping().getNumOperands() && "Out-of-bound access");
  699     assert(PartMap != ValMapping.end() && "Out-of-bound access");
  700     assert(NewVReg == 0 && "Register has already been created");
  715   assert(OpIdx < getInstrMapping().getNumOperands() && "Out-of-bound access");
  716   assert(getInstrMapping().getOperandMapping(OpIdx).NumBreakDowns >
  721   assert(NewVRegs[OpToNewVRegIdx[OpIdx] + PartialMapIdx] == 0 &&
  730   assert(OpIdx < getInstrMapping().getNumOperands() && "Out-of-bound access");
  744     assert((VReg || ForDebug) && "Some registers are uninitialized");
lib/CodeGen/GlobalISel/Utils.cpp
   48   assert(Register::isVirtualRegister(Reg) && "PhysReg not implemented");
   61       assert(RegMO.isDef() && "Must be a definition");
   77   assert(Register::isVirtualRegister(Reg) && "PhysReg not implemented");
   92     assert((!isTargetSpecificOpcode(II.getOpcode()) || RegMO.isUse()) &&
  115   assert(!isPreISelGenericOpcode(I.getOpcode()) &&
  129     assert(MO.isReg() && "Unsupported non-reg operand");
  211   assert((!ValAndVReg || ValAndVReg->VReg == VReg) &&
  238       assert(Val.getBitWidth() == BitWidth &&
lib/CodeGen/GlobalMerge.cpp
  439   assert(Globals.size() > 1);
  624     assert(PT && "Global variable is not a pointer!");
lib/CodeGen/HardwareLoops.cpp
  240   assert(
  380     assert((isa<BranchInst>(BeginBB->getTerminator()) &&
lib/CodeGen/IfConversion.cpp
  845       assert(!E2->isBranch() && "Branch mis-match, one block is empty.");
  849       assert(!E1->isBranch() && "Branch mis-match, one block is empty.");
  854       assert(E1->isIdenticalTo(*E2) &&
 1890     assert(DI1 != MBB1.begin());
 1923     assert(DI2 != MBB2.begin());
 2049     assert((TailBB || !TrueBBI.IsBrAnalyzable) && "Unexpected!");
 2239   assert(!FromMBB.hasAddressTaken() &&
lib/CodeGen/ImplicitNullChecks.cpp
  106       assert((!PotentialDependence || CanReorder) &&
  238   assert(!llvm::any_of(MI->operands(), IsRegMask) &&
  248   assert(llvm::all_of(Block, canHandle) && "Check this first!");
  249   assert(!is_contained(Block, MI) && "Block must be exclusive of MI!");
  271   assert(canHandle(A) && canHandle(B) && "Precondition!");
  342     assert(MMO1->getValue() && "MMO1 should have a Value!");
  411   assert(canHandle(DependenceMI) && "Should never have reached here!");
  442     assert(!(DependenceMO.isDef() &&
  522   assert(MBP.ConditionDef->getParent() ==  &MBB && "Should be in basic block");
  622   assert(NumDefs <= 1 && "other cases unhandled!");
  627     assert(NumDefs == 1 && "expected exactly one def!");
  648         assert(MO.isDef() && "Expected def or use");
  671     assert(BranchesRemoved > 0 && "expected at least one branch!");
lib/CodeGen/IndirectBrExpandPass.cpp
  130     assert(std::find_if(std::next(BlockAddressUseIt), BB.use_end(),
lib/CodeGen/InlineSpiller.cpp
  376   assert(VNI && VNI->def == Idx.getRegSlot() && "Not defined by copy");
  390   assert(StackInt && "No stack slot assigned yet.");
  407     assert(DefMI && "Defining instruction disappeared");
  426   assert(VNI && "Missing value");
  429   assert(StackInt && "No stack slot assigned yet.");
  462            assert(DstVNI && "Missing defined value");
  463            assert(DstVNI->def == Idx.getRegSlot() && "Wrong copy def slot");
  513     assert(isRegToSpill(SnipLI.reg) && "Unexpected register in copy");
  515     assert(SnipVNI && "Snippet undefined before copy");
  656       assert(!MI.isDebugInstr() && "Did not expect to find a use in debug "
  702     assert(LIS.hasInterval(Reg) &&
  813     assert(MI == OpPair.first && "Instruction conflict during operand folding");
  859     assert(MO->isDead() && "Cannot fold physreg def");
  874   assert(!MIS.empty() && "Unexpected empty span of instructions!");
  925   assert(Def.getNumOperands() == 1 &&
  982     assert(!MI->isDebugInstr() && "Did not expect to find a use in debug "
 1075   assert(StackInt->getNumValNums() == 1 && "Bad stack interval values");
 1097       assert(SnippetCopies.count(&MI) && "Remaining use wasn't a snippet copy");
 1112   assert(!Register::isStackSlot(edit.getReg()) &&
 1123   assert(edit.getParent().isSpillable() &&
 1125   assert(DeadDefs.empty() && "Previous spill didn't remove dead defs");
 1183   assert(OrigLI.getVNInfoAt(Idx) == &OrigVNI && "Unexpected VNI");
 1302   assert(Orders.size() == WorkSet.size() &&
lib/CodeGen/InterferenceCache.cpp
  108   assert(!hasRefs() && "Cannot reset cache entry with references");
lib/CodeGen/InterferenceCache.h
  104       assert(!hasRefs() && "Cannot clear cache entry with references");
lib/CodeGen/InterleavedAccessPass.cpp
  386           assert(Extract->getOperand(0) == Shuffle->getOperand(0) &&
lib/CodeGen/InterleavedLoadCombinePass.cpp
  788     assert(ArgTy && "ShuffleVector Operand is not a VectorType");
  837       assert((i < 2 * (signed)ArgTy->getNumElements()) &&
 1102   assert(!LIs.empty() && "No load instructions given.");
 1110   assert(FLI != BB->end());
 1189   assert(!LIs.empty() && "There are no LoadInst to combine");
lib/CodeGen/IntrinsicLowering.cpp
   63   assert(V->getType()->isIntOrIntVectorTy() && "Can't bswap a non-integer type!");
  158   assert(V->getType()->isIntegerTy() && "Can't ctpop a non-integer type!");
  239   assert(Callee && "Cannot lower an indirect call!");
  483   assert(CI->use_empty() &&
lib/CodeGen/LLVMTargetMachine.cpp
   57   assert(TmpAsmInfo && "MCAsmInfo not initialized. "
  235   assert(TargetPassConfig::willCompleteCodeGenPipeline() &&
lib/CodeGen/LatencyPriorityQueue.cpp
  135   assert(!Queue.empty() && "Queue is empty!");
  137   assert(I != Queue.end() && "Queue doesn't contain the SU being removed!");
lib/CodeGen/LexicalScopes.cpp
  160   assert(Scope && "Invalid Scope encoding!");
  177     assert(cast<DISubprogram>(Scope)->describes(&MF->getFunction()));
  178     assert(!CurrentFnLexicalScope);
  189   assert(Scope && "Invalid Scope encoding!");
  212   assert(Scope && "Invalid Scope encoding!");
  234   assert(Scope && "Unable to calculate scope dominance graph!");
  264     assert(S && "Lost LexicalScope for a machine instruction!");
  281   assert(MF && "Method called on a uninitialized LexicalScopes object!");
  302   assert(MF && "Unexpected uninitialized LexicalScopes object!");
lib/CodeGen/LiveDebugValues.cpp
   85   assert(MI.isDebugValue() && "expected a DBG_VALUE");
   86   assert(MI.getNumOperands() == 4 && "malformed DBG_VALUE");
  227       assert(MI.isDebugValue() && "not a DBG_VALUE");
  228       assert(MI.getNumOperands() == 4 && "malformed DBG_VALUE");
  242       assert((Kind != ImmediateKind || !MI.isDebugEntryValue()) &&
  261       assert(VL.Kind == RegisterKind);
  271       assert(VL.Kind == RegisterKind);
  442       assert(Vars.empty() == VarLocs.empty() && "open ranges are inconsistent");
  654   assert(MI.hasOneMemOperand() &&
  658   assert(PVal->kind() == PseudoSourceValue::FixedStack &&
  678   assert(Var->isValidLocationForIntrinsic(DebugLoc) &&
  697     assert(MI.getOperand(0).isReg() && MI.getOperand(0).getReg() == 0 &&
  761     assert(NewReg &&
  787     assert(NewReg &&
 1107       assert(ASeenFragmentsOverlaps != OverlappingFragments.end() &&
 1197   assert((NumVisited || MBB.pred_empty()) &&
 1401     assert(Pending.empty() && "Pending should be empty");
lib/CodeGen/LiveDebugVariables.cpp
  105     assert(locNo() == LocNo && "location truncation");
  460     assert((!ModifiedMF || EmitDone) &&
  586   assert(Register::isVirtualRegister(VirtReg) && "Only map VirtRegs");
  587   assert(UserVarMap.find(UV->getId()) != UserVarMap.end() &&
  642   assert(!MI.getOperand(1).isImm() && "DBG_VALUE with indirect flag before "
  798     assert(DstVNI && DstVNI->def == Idx.getRegSlot() && "Bad copy value");
  823       assert(CopyMI && CopyMI->isCopy() && "Bad copy value");
 1066           assert(LocMapI.valid() && "Unexpected coalescing");
 1304   assert(cast<DILocalVariable>(Variable)
 1316   assert((!Spilled || MO.isFI()) && "a spilled location must be a frame index");
lib/CodeGen/LiveInterval.cpp
   89     assert(!Def.isDead() && "Cannot define a value at the dead slot");
   90     assert((!ForVNI || ForVNI->def == Def) &&
  101       assert((!ForVNI || ForVNI == S->valno) && "Value number mismatch");
  102       assert(S->valno->def == S->start && "Inconsistent existing value def");
  114     assert(SlotIndex::isEarlierInstr(Def, S->start) && "Already live at def");
  159     assert(I != segments().end() && "Not a valid segment!");
  166       assert(MergeTo->valno == ValNo && "Cannot merge with differing values!");
  187     assert(I != segments().end() && "Not a valid segment!");
  199       assert(MergeTo->valno == ValNo && "Cannot merge with differing values!");
  235         assert(B->end <= Start &&
  257         assert(I->start >= End &&
  406   assert(!empty() && "empty range");
  412   assert((StartPos->start <= i->start || StartPos == other.begin()) &&
  421       assert(StartPos < other.end() && i < end());
  447   assert(!empty() && "empty range");
  463     assert(J->end >= I->start);
  489   assert(Start < End && "Invalid range");
  538     assert(!VNI->isUnused() && "Unused valno used by live segment");
  560   assert(segments.empty() || segments.back().end <= S.start);
  587   assert(I != end() && "Segment is not in range!");
  588   assert(I->containsInterval(Start, End)
  669       assert(nextValNo && "Huh?");
  750   assert(V1 != V2 && "Identical value#'s are always equivalent!");
  805   assert(segmentSet != nullptr && "segment set must have been created");
  806   assert(
  901     assert(MI && "Cannot find the definition of a value");
  971   assert(Register::isVirtualRegister(reg));
  973   assert((VRegMask & LaneMask).any());
  979     assert(SubReg != 0 && "Undef should only be set on subreg defs");
 1007       assert(S.valno == getValNumInfo(S.valno->id) && "Bad VNInfo");
 1062     assert(I->start.isValid());
 1063     assert(I->end.isValid());
 1064     assert(I->start < I->end);
 1065     assert(I->valno != nullptr);
 1066     assert(I->valno->id < valnos.size());
 1067     assert(I->valno == valnos[I->valno->id]);
 1069       assert(I->end <= std::next(I)->start);
 1071         assert(I->valno != std::next(I)->valno);
 1085     assert((Mask & SR.LaneMask).none());
 1089     assert((Mask & ~MaxMask).none());
 1091     assert(!SR.empty());
 1095     assert(covers(SR));
 1138   assert(LR && "Can't have null LR in dirty updater.");
 1161   assert(A.start <= B.start && "Unordered live segments.");
 1166   assert(A.valno == B.valno && "Cannot overlap different values");
 1171   assert(LR && "Cannot add to a null destination");
 1185     assert(Spills.empty() && "Leftover spilled segments");
 1206   assert(ReadI == E || ReadI->end > Seg.start);
 1210     assert(ReadI->valno == Seg.valno && "Cannot overlap different values");
 1273   assert(NumMoved == size_t(Spills.end() - SpillSrc));
 1283   assert(LR && "Cannot add to a null destination");
 1328       assert(MBB && "Phi-def has no defining MBB");
 1400           assert(MainRangeVNI != nullptr
lib/CodeGen/LiveIntervalUnion.cpp
   67     assert(SegPos.value() == &VirtReg && "Inconsistent LiveInterval");
  142     assert(LRI != LREnd && "Reached end of LR");
  163     assert(LRI->end <= LiveUnionI.start() && "Expected non-overlap");
lib/CodeGen/LiveIntervals.cpp
  195   assert(LRCalc && "LRCalc not initialized.");
  196   assert(LI.empty() && "Should only compute empty intervals.");
  238       assert(!MBB.empty() && "empty return block?");
  264   assert(LRCalc && "LRCalc not initialized.");
  287   assert(IsReserved == MRI->isReservedRegUnit(Unit) &&
  374         assert(SR.LaneMask == M && "Expecting lane masks to match exactly");
  394       assert(ExtVNI == VNI && "Unexpected existing value number");
  422         assert(OldVNI == VNI && "Wrong value out of predecessor");
  429         assert(LaneMask.any() &&
  433         assert(LiveRangeCalc::isJointlyDominated(Pred, Undefs, *Indexes) &&
  444   assert(Register::isVirtualRegister(li->reg) &&
  508     assert(I != LI.end() && "Missing segment for VNI");
  531       assert(MI && "No instruction defining live value");
  544   assert(Register::isVirtualRegister(Reg) &&
  597     assert(Segment != nullptr && "Missing segment for VNI");
  615   assert(LRCalc && "LRCalc not initialized.");
  788             assert(MO.isDef());
  912     assert(*SlotI >= LiveI->start);
 1105     assert(OldIdxOut != E && SlotIndex::isSameInstr(OldIdx, OldIdxOut->start) &&
 1108     assert(OldIdxVNI->def == OldIdxOut->start && "Inconsistent def");
 1141         assert(INext != E && "Must have following segment");
 1187           assert(DefVNI != AfterNewIdx->valno);
 1197       assert(AfterNewIdx->valno != OldIdxVNI && "Multiple defs of value?");
 1205       assert(AfterNewIdx != OldIdxOut && "Inconsistent iterators");
 1255     assert(OldIdxOut != E && SlotIndex::isSameInstr(OldIdx, OldIdxOut->start) &&
 1258     assert(OldIdxVNI->def == OldIdxOut->start && "Inconsistent def");
 1265       assert(NewIdxOut->valno != OldIdxVNI &&
 1287           assert(NewIdxIn == LR.find(NewIdx.getBaseIndex()));
 1388     assert(RI != LIS.RegMaskSlots.end() && *RI == OldIdx.getRegSlot() &&
 1391     assert((RI == LIS.RegMaskSlots.begin() ||
 1394     assert((std::next(RI) == LIS.RegMaskSlots.end() ||
 1422     assert(Before < OldIdx && "Expected upwards move");
 1459   assert((!MI.isBundled() || MI.getOpcode() == TargetOpcode::BUNDLE) &&
 1464   assert(getMBBStartIdx(MI.getParent()) <= OldIndex &&
 1639     assert(VNI->def.getBaseIndex() == Pos.getBaseIndex());
 1670   assert(LRCalc && "LRCalc not initialized.");
lib/CodeGen/LivePhysRegs.cpp
   99         assert(O->isUse());
  162     assert(Mask.any() && "Invalid livein mask");
  258   assert(MBB.livein_empty() && "Expected empty live-in list");
  298       assert(Register::isPhysicalRegister(Reg));
  315       assert(Register::isPhysicalRegister(Reg));
lib/CodeGen/LiveRangeCalc.cpp
   75   assert(MRI && Indexes && "call reset() first");
  134   assert(MainRange.segments.empty() && MainRange.valnos.empty() &&
  148   assert(MRI && Indexes && "call reset() first");
  192       assert(!MO.isDef() && "Cannot handle PHI def of partial register.");
  222     assert(I.Value && "No live-in value found");
  232       assert(Seen.test(MBB->getNumber()));
  243   assert(Use.isValid() && "Invalid SlotIndex");
  244   assert(Indexes && "Missing SlotIndexes");
  245   assert(DomTree && "Missing dominator tree");
  248   assert(UseMBB && "No MBB at Use");
  270   assert(Indexes && "Missing SlotIndexes");
  271   assert(DomTree && "Missing dominator tree");
  435     assert(TheVNI != nullptr && TheVNI != &UndefVNI);
  483   assert(Indexes && "Missing SlotIndexes");
  484   assert(DomTree && "Missing dominator tree");
  550         assert(Alloc && "Need VNInfo allocator to create PHI-defs");
lib/CodeGen/LiveRangeEdit.cpp
   73   assert(DefMI && "Missing instruction");
  142   assert(ScannedRemattable && "Call anyRematerializable first");
  150   assert(RM.OrigMI && "No defining instruction for remattable value");
  170   assert(RM.OrigMI && "Invalid remat");
  262   assert(MI->allDefsAreDead() && "Def isn't really dead");
lib/CodeGen/LiveRangeUtils.h
   34       assert((SplitLRs[eq-1]->empty() || SplitLRs[eq-1]->expiredAt(I->start)) &&
lib/CodeGen/LiveRegMatrix.cpp
  106   assert(!VRM->hasPhys(VirtReg.reg) && "Duplicate VirtReg assignment");
lib/CodeGen/LiveStacks.cpp
   58   assert(Slot >= 0 && "Spill slot indice must be >= 0");
lib/CodeGen/LiveVariables.cpp
   86   assert(Register::isVirtualRegister(RegIdx) &&
  114   assert(MBB != &MF->front() && "Can't find reaching def for virtreg");
  133   assert(MRI->getVRegDef(reg) && "Register use before def!");
  149     assert(VRInfo.Kills[i]->getParent() != MBB && "entry should be at end!");
  379           assert(!MO->isDead());
  502   assert(!MI.isDebugInstr());
  530       assert(MO.isDef());
  568     assert(Register::isPhysicalRegister(LI.PhysReg) &&
  669     assert(Visited.count(&*i) != 0 && "unreachable basic block found");
  697         assert(removed && "kill not in register's VarInfo?");
lib/CodeGen/LocalStackSlotAllocation.cpp
  209     assert(!MFI.isObjectPreAllocated(StackProtectorFI) &&
  351     assert(MFI.isObjectPreAllocated(FrameIdx) &&
  373     assert(idx < MI.getNumOperands() && "Cannot find FI operand");
  434     assert(BaseReg != 0 && "Unable to allocate virtual base register!");
lib/CodeGen/LoopTraversal.cpp
   17   assert(MBBNumber < MBBInfos.size() && "Unexpected basic block number.");
   36     assert(MBBNumber < MBBInfos.size() && "Unexpected basic block number.");
   48         assert(SuccNumber < MBBInfos.size() &&
lib/CodeGen/LowLevelType.cpp
   33     assert(SizeInBits != 0 && "invalid zero-sized type");
lib/CodeGen/LowerEmuTLS.cpp
  142     assert(EmuTlsTmplVar && "Failed to create emualted TLS initializer");
lib/CodeGen/MIRParser/MILexer.cpp
   56     assert(C.Ptr >= Ptr && C.Ptr <= End);
  118   assert(Value.front() == '"' && Value.back() == '"');
  146   assert(C.peek() == '"');
  436   assert(C.peek() == '$');
lib/CodeGen/MIRParser/MIParser.cpp
  112   assert(TRI && "Expected target register info");
  119     assert(WasInserted && "Expected registers to be unique case-insensitively");
  137   assert(TII && "Expected target instruction info");
  156   assert(TRI && "Expected target register info");
  159   assert(RegMasks.size() == RegMaskNames.size());
  194   assert(TII && "Expected target instruction info");
  214   assert(TII && "Expected target instruction info");
  236   assert(TII && "Expected target instruction info");
  258   assert(TII && "Expected target instruction info");
  335   assert(RegName != "" && "Expected named reg.");
  360       assert(Operand.isReg() && Operand.isUse() &&
  538   assert(Loc >= Source.data() && Loc <= (Source.data() + Source.size()));
  586   assert(Token.is(MIToken::MachineBasicBlockLabel));
  696   assert(Token.is(MIToken::kw_liveins));
  729   assert(Token.is(MIToken::kw_successors));
  762   assert(Token.is(MIToken::MachineBasicBlockLabel));
  808       assert(IsInBundle);
  832     assert(Token.isNewlineOrEOF() && "MI is not fully parsed");
  863   assert(Token.is(MIToken::MachineBasicBlockLabel));
  879     assert(Token.is(MIToken::MachineBasicBlockLabel) || Token.is(MIToken::Eof));
 1076   assert(MO.isImplicit());
 1082   assert(Register::isPhysicalRegister(Reg) && "expected phys reg");
 1115   assert(TRI && "Expected target register info");
 1182   assert(Token.is(MIToken::NamedRegister) && "Needs NamedRegister token");
 1190   assert(Token.is(MIToken::NamedVirtualRegister) && "Expected NamedVReg token");
 1201   assert(Token.is(MIToken::VirtualRegister) && "Needs VirtualRegister token");
 1331   assert(Token.is(MIToken::dot));
 1479   assert(Token.is(MIToken::IntegerLiteral));
 1594   assert(Token.is(MIToken::Identifier));
 1653   assert(Token.is(MIToken::MachineBasicBlock) ||
 1681   assert(Token.is(MIToken::StackObject));
 1710   assert(Token.is(MIToken::FixedStackObject));
 1769   assert(Token.is(MIToken::ConstantPoolItem));
 1784   assert(Token.is(MIToken::JumpTableIndex));
 1797   assert(Token.is(MIToken::ExternalSymbol));
 1807   assert(Token.is(MIToken::MCSymbol));
 1817   assert(Token.is(MIToken::SubRegisterIndex));
 1828   assert(Token.is(MIToken::exclaim));
 1846   assert(Token.is(MIToken::md_diexpr));
 1892   assert(Token.is(MIToken::md_dilocation));
 2024   assert(TRI && "Expected target register info");
 2174   assert(Token.is(MIToken::kw_blockaddress));
 2205   assert(Token.is(MIToken::kw_intrinsic));
 2234   assert(Token.is(MIToken::kw_intpred) || Token.is(MIToken::kw_floatpred));
 2292   assert(Token.is(MIToken::kw_shufflemask));
 2335   assert(Token.is(MIToken::kw_target_index));
 2354   assert(Token.stringValue() == "CustomRegMask" && "Expected a custom RegMask");
 2381   assert(Token.is(MIToken::kw_liveout));
 2562   assert(Token.is(MIToken::kw_align));
 2577   assert(Token.is(MIToken::kw_addrspace));
 2651   assert(Token.is(MIToken::HexLiteral));
 2653   assert(S[0] == '0' && tolower(S[1]) == 'x');
 2942   assert((Token.is(MIToken::kw_pre_instr_symbol) ||
lib/CodeGen/MIRParser/MIRParser.cpp
  189   assert(Error.getKind() == SourceMgr::DK_Error && "Expected an error");
  415     assert(ConstantPool && "Constant pool must be created");
  497   assert(RegInfo.tracksLiveness());
  870   assert(SourceRange.isValid() && "Invalid source range");
  886   assert(SourceRange.isValid());
lib/CodeGen/MIRPrinter.cpp
  246   assert(RegMask && "Can't print an empty register mask");
  418       assert(StackObjectInfo != StackObjectOperandMapping.end() &&
  435     assert(StackObjectInfo != StackObjectOperandMapping.end() &&
  438     assert(!StackObject.IsFixed && "Expected a locally mapped stack object");
  454     assert(StackObjectInfo != StackObjectOperandMapping.end() &&
  606   assert(MBB.getNumber() >= 0 && "Invalid MBB number");
  710   assert(TRI && "Expected target register info");
  712   assert(TII && "Expected target instruction info");
  714     assert(MI.getNumOperands() == 1 && "Expected 1 operand in CFI instruction");
  811   assert(ObjectInfo != StackObjectOperandMapping.end() &&
lib/CodeGen/MIRVRegNamerUtils.cpp
   31     assert(Type != RSE_Reg && "Expected a non-Register Type.");
   40     assert(this->isReg() && "Expected a virtual or physical Register.");
  100     assert(TReg.isReg() && "Expected vreg or physreg.");
lib/CodeGen/MachineBasicBlock.cpp
   64     assert(getNumber() >= 0 && "cannot get label for unreachable MBB");
  111   assert(!N->getParent() && "machine instruction already in a basic block");
  124   assert(N->getParent() && "machine instruction not in a basic block");
  140   assert(Parent->getParent() == FromList.Parent->getParent() &&
  147   assert(Parent != FromList.Parent && "Two lists have the same parent?");
  156   assert(!MI->getParent() && "MI is still in a block!");
  164   assert((I == E || !I->isInsideBundle()) &&
  179   assert((I == E || !I->isInsideBundle()) &&
  194   assert((I == E || !I->isInsideBundle()) &&
  494   assert(getParent() && "MBB must be inserted in function");
  495   assert(PhysReg.isPhysical() && "Expected physreg");
  496   assert(RC && "Register class is required");
  497   assert((isEHPad() || this == &getParent()->front()) &&
  543   assert(!B && "UpdateTerminators requires analyzable predecessors!");
  557         assert(!TBB && "Found more than one non-landing-pad successor!");
  597     assert(!FallthroughBB && "Found more than one fallthrough successor.");
  649   assert((uint64_t)std::abs(Sum - BranchProbability::getDenominator()) <=
  678   assert(OldI != succ_end() && "Old is not a successor of this block!");
  679   assert(llvm::find(successors(), New) == succ_end() &&
  701   assert(I != Successors.end() && "Not a current successor!");
  736   assert(OldI != E && "Old is not a successor of this block");
  770   assert(I != Predecessors.end() && "Pred is not a predecessor of this block!");
 1039           assert(VNI &&
 1059         assert(VNI && "LiveInterval should have VNInfo where it is live.");
 1094           assert(DestLoop->getHeader() == Succ &&
 1169   assert(!MI->isBundledWithPred() && !MI->isBundledWithSucc() &&
 1182   assert(getParent() && "Not embedded in a function!");
 1189   assert(getParent() && "Not embedded in a function!");
 1197   assert(Old != New && "Cannot replace self with self!");
 1263     assert(DestA && DestB && IsCond &&
 1353   assert(!Prob.isUnknown());
 1363   assert(Probs.size() == Successors.size() && "Async probability list!");
 1365   assert(index < Probs.size() && "Not a current successor!");
 1372   assert(Probs.size() == Successors.size() && "Async probability list!");
 1374   assert(index < Probs.size() && "Not a current successor!");
 1498   assert(getParent()->getProperties().hasProperty(
lib/CodeGen/MachineBlockFrequencyInfo.cpp
  245   assert(MBFI && "Expected analysis to be available");
lib/CodeGen/MachineBlockPlacement.cpp
  238     assert(BB && "Cannot create a chain with a null basic block");
  271     assert(BB && "Can't merge a null block.");
  272     assert(!Blocks.empty() && "Can't merge into an empty chain.");
  276       assert(!BlockToChain[BB] &&
  283     assert(BB == *Chain->begin() && "Passed BB is not head of Chain.");
  284     assert(Chain->begin() != Chain->end());
  290       assert(BlockToChain[ChainBB] == Chain && "Incoming blocks not in chain.");
  530     assert(F);
 1153       assert(getKey()->isSuccessor(dst) &&
 1224       assert(InsertResult.second && "Block seen twice.");
 1247       assert(InsertResult.second && "Block seen twice.");
 1601     assert(MBB->isEHPad() == IsEHPad &&
 1608     assert(SuccChain.UnscheduledPredecessors == 0 &&
 1677   assert(
 1681     assert(BlockToChain[ChainBB] == &Chain &&
 1705   assert(HeadBB && "BB must not be null.\n");
 1706   assert(BlockToChain[HeadBB] == &Chain && "BlockToChainMap mis-match.\n");
 1713     assert(BB && "null block found at end of chain in loop.");
 1714     assert(BlockToChain[BB] == &Chain && "BlockToChainMap mis-match in loop.");
 1715     assert(*std::prev(Chain.end()) == BB && "BB Not found at end of chain.");
 2262     assert(std::next(ExitIt) != LoopChain.end() &&
 2470   assert(BlockWorkList.empty() &&
 2472   assert(EHPadWorkList.empty() &&
 2506   assert(LoopChain.UnscheduledPredecessors == 0 &&
 2550     assert(!BadLoop && "Detected problems with the placement of this loop.");
 2578       assert(NextFI != FE && "Can't fallthrough past the last block.");
 2596   assert(BlockWorkList.empty() &&
 2598   assert(EHPadWorkList.empty() &&
 2631     assert(!BadFunc && "Detected problems with the block placement.");
 2662       assert((!TII->analyzeBranch(*PrevBB, TBB, FBB, Cond) ||
 2842     assert(Removed && "Block must have been removed to be duplicated into its "
 2996   assert(BlockToChain.empty() &&
 2998   assert(ComputedEdges.empty() &&
lib/CodeGen/MachineCSE.cpp
  362       assert(CrossMBB && "Reaching end-of-MBB without finding MI?");
  505   assert(SI != ScopeMap.end());
  616       assert(Register::isVirtualRegister(OldReg) &&
  647         assert(Def != nullptr && "CSEd register has no unique definition?");
  807     assert(
  825         assert(MI->getOperand(0).isDef() &&
  874   assert(DT->dominates(CandidateBB, MBB) && "CandidateBB should dominate MBB");
  875   assert(DT->dominates(CandidateBB, MBB1) &&
lib/CodeGen/MachineCombiner.cpp
  161   assert(TSchedModel.hasInstrSchedModelOrItineraries() &&
  181         assert(II->second < InstrDepth.size() && "Bad Index");
  183         assert(DefInstr &&
  218   assert(TSchedModel.hasInstrSchedModelOrItineraries() &&
  278   assert(!InsInstrs.empty() && "Only support sequences that insert instrs.");
  306   assert(TSchedModel.hasInstrSchedModelOrItineraries() &&
  482     assert(CurrentLatencyDiff <= PrevLatencyDiff &&
lib/CodeGen/MachineCopyPropagation.cpp
  120     assert(MI->isCopy() && "Tracking non-copy?");
  268     assert(Def == PreviousDef);
  302   assert(Copy.isCopy());
  304   assert(CopyDef == Src || CopyDef == Def);
  474       assert(!Register::isVirtualRegister(Def) &&
  567       assert(!Register::isVirtualRegister(Reg) &&
  587         assert(!MRI->isReserved(Reg));
  622       assert(!MRI->isReserved(MaybeDead->getOperand(0).getReg()));
  625       assert(MaybeDead->isCopy());
lib/CodeGen/MachineDominators.cpp
  121         assert(PredBB->pred_size() == 1 && "A basic block resulting from a "
lib/CodeGen/MachineFrameInfo.cpp
   33     assert(Alignment <= StackAlignment &&
   54   assert(Size != 0 && "Cannot allocate zero size stack objects!");
   59   assert(Index >= 0 && "Bad frame index!");
   84   assert(Size != 0 && "Cannot allocate zero size fixed stack objects!");
  193   assert(FrameSetupOpcode != ~0u && FrameDestroyOpcode != ~0u &&
lib/CodeGen/MachineFunction.cpp
  199   assert(Target.isCompatibleDataLayout(getDataLayout()) &&
  305         assert(MBBNumbering[MBBI->getNumber()] == &*MBBI &&
  321   assert(BlockNo <= MBBNumbering.size() && "Mismatch!");
  371   assert((!MI->isCall(MachineInstr::IgnoreBundle) ||
  395   assert(MBB->getParent() == this && "MBB parent mismatch!");
  595     assert((VRegRC == RC || (VRegRC->contains(PReg) &&
  611   assert(JumpTableInfo && "No jump tables");
  612   assert(JTI < JumpTableInfo->getJumpTables().size() && "Invalid JTI!");
  693     assert(isa<CleanupPadInst>(FirstI) && "Invalid landingpad!");
  828   assert(New->isCall() && "Call site info refers only to call instructions!");
  848   assert(New->isCall() && "Call site info refers only to call instructions!");
  906   assert(!DestBBs.empty() && "Cannot create an empty jump table!");
  915   assert(Old != New && "Not making a change?");
  927   assert(Old != New && "Not making a change?");
 1062   assert(Alignment && "Alignment must be specified!");
 1082   assert(Alignment && "Alignment must be specified!");
lib/CodeGen/MachineInstr.cpp
  119   assert(debugLoc.hasTrivialDestructor() && "Expected trivial destructor");
  136   assert(debugLoc.hasTrivialDestructor() && "Expected trivial destructor");
  178   assert(MBB && "Use MachineInstrBuilder to add operands to dangling instrs");
  180   assert(MF && "Use MachineInstrBuilder to add operands to dangling instrs");
  200   assert(MCID && "Cannot add operands before providing an instr descriptor");
  223       assert(!Operands[OpNo].isTied() && "Cannot move tied operands");
  233   assert((isImpReg || Op.isRegMask() || MCID->isVariadic() ||
  296   assert(OpNo < getNumOperands() && "Invalid operand number");
  303       assert(!Operands[i].isTied() && "Cannot move tied operands");
  387   assert(&MF == MI.getMF() &&
  438   assert(&MF == MIs[0]->getMF() &&
  443     assert(&MF == MI.getMF() &&
  512   assert(&MF == MI.getMF() &&
  569   assert(!isBundledWithPred() && "Must be called on bundle header");
  596     assert(Other.isBundle() && "Expected that both instructions are bundles.");
  660   assert(getParent() && "Not embedded in a basic block!");
  665   assert(getParent() && "Not embedded in a basic block!");
  670   assert(getParent() && "Not embedded in a basic block!");
  675   assert(getParent() && "Not embedded in a basic block!");
  678   assert(MF && "Not embedded in a function!");
  695   assert(getParent() && "Not embedded in a basic block!");
  733   assert(!isBundledWithPred() && "MI is already bundled with its predecessor");
  737   assert(!Pred->isBundledWithSucc() && "Inconsistent bundle flags");
  742   assert(!isBundledWithSucc() && "MI is already bundled with its successor");
  746   assert(!Succ->isBundledWithPred() && "Inconsistent bundle flags");
  751   assert(isBundledWithPred() && "MI isn't bundled with its predecessor");
  755   assert(Pred->isBundledWithSucc() && "Inconsistent bundle flags");
  760   assert(isBundledWithSucc() && "MI isn't bundled with its successor");
  764   assert(Succ->isBundledWithPred() && "Inconsistent bundle flags");
  778   assert(isInlineAsm() && "getInlineAsmDialect() only works for inline asms!");
  785   assert(isInlineAsm() && "Expected an inline asm instruction");
  786   assert(OpIdx < getNumOperands() && "OpIdx out of range");
  812   assert(isDebugLabel() && "not a DBG_LABEL");
  817   assert(isDebugValue() && "not a DBG_VALUE");
  822   assert(isDebugValue() && "not a DBG_VALUE");
  834   assert(getParent() && "Can't have an MBB reference here!");
  835   assert(getMF() && "Can't have an MF reference here!");
  890   assert(CurRC && "Invalid initial register class");
  904   assert(MO.isReg() &&
  906   assert(CurRC && "Invalid initial register class");
 1053   assert(DefMO.isDef() && "DefIdx must be a def operand");
 1054   assert(UseMO.isUse() && "UseIdx must be a use operand");
 1055   assert(!DefMO.isTied() && "Def is already tied to another use");
 1056   assert(!UseMO.isTied() && "Use is already tied to another def");
 1064     assert(isInlineAsm() && "DefIdx out of range");
 1077   assert(MO.isTied() && "Operand isn't tied");
 1105     assert(FlagMO.isImm() && "Invalid tied operand on inline asm");
 1266   assert((OffsetA >= 0) && "Negative MachineMemOperand offset");
 1267   assert((OffsetB >= 0) && "Negative MachineMemOperand offset");
 1358   assert(getNumOperands() >= 3 &&
 1483     assert(getNumOperands() == 1 && "Expected 1 operand in CFI instruction");
 2017   assert(isa<DILocalVariable>(Variable) && "not a variable");
 2018   assert(cast<DIExpression>(Expr)->isValid() && "not an expression");
 2019   assert(cast<DILocalVariable>(Variable)->isValidLocationForIntrinsic(DL) &&
 2033   assert(isa<DILocalVariable>(Variable) && "not a variable");
 2034   assert(cast<DIExpression>(Expr)->isValid() && "not an expression");
 2035   assert(cast<DILocalVariable>(Variable)->isValidLocationForIntrinsic(DL) &&
 2073   assert(MI.getOperand(0).isReg() && "can't spill non-register");
 2074   assert(MI.getDebugVariable()->isValidLocationForIntrinsic(MI.getDebugLoc()) &&
 2079     assert(MI.getOperand(1).getImm() == 0 && "DBG_VALUE with nonzero offset");
lib/CodeGen/MachineInstrBundle.cpp
  127   assert(FirstMI != LastMI && "Empty bundle?");
  264     assert(!MII->isInsideBundle() &&
  319   assert(Register::isPhysicalRegister(Reg) &&
lib/CodeGen/MachineLICM.cpp
  429     assert(Register::isPhysicalRegister(Reg) &&
  684     assert(Node && "Null dominator tree node?");
  890   assert(MI.mayLoad() && "Expected MI that loads!");
  966   assert(Register::isVirtualRegister(CopyDstReg) &&
 1041     assert(MRI->getVRegDef(Reg) &&
 1313   assert(Success &&
 1316   assert(NewMIs.size() == 2 &&
 1379       assert((!MO.isReg() || MO.getReg() == 0 ||
lib/CodeGen/MachineLoopUtils.cpp
   85     assert(OrigPhi.isPHI());
  123     assert(CanAnalyzeBr && "Must be able to analyze the loop branch!");
lib/CodeGen/MachineModuleInfo.cpp
   87     assert(DeletedAddrLabelsNeedingEmission.empty() &&
  103   assert(BB->hasAddressTaken() &&
  109     assert(BB->getParent() == Entry.Fn && "Parent changed");
  143   assert(!Entry.Symbols.empty() && "Didn't have a symbol, why a callback?");
  146   assert((BB->getParent() == nullptr || BB->getParent() == Entry.Fn) &&
  165   assert(!OldEntry.Symbols.empty() && "Didn't have a symbol, why a callback?");
lib/CodeGen/MachineOperand.cpp
   76   assert(Reg.isVirtual());
   85   assert(Reg.isPhysical());
   99   assert(isReg() && "Wrong MachineOperand accessor");
  100   assert((!Val || !isDebug()) && "Marking a debug operation as def");
  103   assert(!IsDeadOrKill && "Changing def/use with dead/kill set not supported");
  116   assert(isReg() && "Wrong MachineOperand accessor");
  117   assert(Register::isPhysicalRegister(getReg()) &&
  129   assert(isUse() && "Reg is not def or use");
  134   assert(isReg() && "Wrong MachineOperand accessor");
  135   assert(Register::isPhysicalRegister(getReg()) &&
  154   assert((!isReg() || !isTied()) && "Cannot change a tied operand into an imm");
  163   assert((!isReg() || !isTied()) && "Cannot change a tied operand into an imm");
  173   assert((!isReg() || !isTied()) &&
  186   assert((!isReg() || !isTied()) &&
  198   assert((!isReg() || !isTied()) &&
  208   assert((!isReg() || !isTied()) &&
  219   assert((!isReg() || !isTied()) &&
  246   assert(!(isDead && !isDef) && "Dead flag on non-def");
  247   assert(!(isKill && isDef) && "Kill flag on def");
  405   assert(TII && "expected instruction info");
  543   assert(TII && "expected instruction info");
 1024   assert((PtrInfo.V.isNull() || PtrInfo.V.is<const PseudoSourceValue *>() ||
 1027   assert(getBaseAlignment() == a && a != 0 && "Alignment is not a power of 2!");
 1028   assert((isLoad() || isStore()) && "Not a load/store!");
 1031   assert(getSyncScopeID() == SSID && "Value truncated");
 1033   assert(getOrdering() == Ordering && "Value truncated");
 1035   assert(getFailureOrdering() == FailureOrdering && "Value truncated");
 1051   assert(MMO->getFlags() == getFlags() && "Flags mismatch!");
 1052   assert(MMO->getSize() == getSize() && "Size mismatch!");
 1093   assert((isLoad() || isStore()) &&
 1117     assert(PVal && "Expected a pseudo source value");
lib/CodeGen/MachineOutliner.cpp
  180     assert(*EndIdx != EmptyIdx && "EndIdx is undefined!");
  278     assert(StartIdx <= LeafEndIdx && "String can't start after it ends!");
  298     assert(StartIdx <= EndIdx && "String can't start after it ends!");
  299     assert(!(!Parent && StartIdx != EmptyIdx) &&
  325       assert(ChildPair.second && "Node had a null child!");
  360       assert(Active.Idx <= EndIdx && "Start index can't be after end index!");
  488     assert(Root && "Root node can't be nullptr!");
  681     assert(LegalInstrNumber != DenseMapInfo<unsigned>::getEmptyKey() &&
  683     assert(LegalInstrNumber != DenseMapInfo<unsigned>::getTombstoneKey() &&
  714     assert(LegalInstrNumber < IllegalInstrNumber &&
  717     assert(IllegalInstrNumber != DenseMapInfo<unsigned>::getEmptyKey() &&
  720     assert(IllegalInstrNumber != DenseMapInfo<unsigned>::getTombstoneKey() &&
  815     assert(DenseMapInfo<unsigned>::getEmptyKey() == (unsigned)-1 &&
  817     assert(DenseMapInfo<unsigned>::getTombstoneKey() == (unsigned)-2 &&
lib/CodeGen/MachinePipeliner.cpp
  279   assert(LoopID->getNumOperands() > 0 && "requires atleast one operand");
  280   assert(LoopID->getOperand(0) == LoopID && "invalid loop");
  294       assert(MD->getNumOperands() == 2 &&
  298       assert(II_setByPragma >= 1 && "Pipeline initiation interval must be positive.");
  354     assert(DefOp.getSubReg() == 0);
  383   assert(L.getBlocks().size() == 1 && "SMS works on single blocks only.");
  551     assert(NewInstrChanges.empty() &&
  583   assert(Phi.isPHI() && "Expecting a Phi.");
  593   assert(InitVal != 0 && LoopVal != 0 && "Unexpected Phi structure.");
  700               assert(TII->areMemAccessesTriviallyDisjoint(LdMI, MI) &&
 1069       assert(NewResource->canReserveResources(*MI) && "Reserve error.");
 1242     assert(SI != BU.end() && "Invalid B set.");
 2220   assert(SI != nullptr && DI != nullptr && "Expecting SUnit with an MI.");
 2310         assert(ProcItinResources.canReserveResources(*(*I)->getInstr()) &&
 2591   assert(Phi.isPHI() && "Expecting a Phi.");
 2648     assert(StageDef != -1 && "Instruction should have been scheduled.");
 2896   assert(SM.getNumProcResourceKinds() < 64 &&
lib/CodeGen/MachinePostDominators.cpp
   52   assert(!Blocks.empty());
lib/CodeGen/MachineRegisterInfo.cpp
   59   assert(RC && RC->isAllocatable() && "Invalid RC for virtual register");
  160   assert(RegClass && "Cannot create register without RegClass!");
  161   assert(RegClass->isAllocatable() &&
  251   assert(Valid && "Invalid use list");
  266   assert(!MO->isOnRegUseList() && "Already on list");
  281   assert(MO->getReg() == Head->getReg() && "Different regs on the same list!");
  285   assert(Last && "Inconsistent use list");
  286   assert(MO->getReg() == Last->getReg() && "Different regs on the same list!");
  305   assert(MO->isOnRegUseList() && "Operand not on use list");
  308   assert(Head && "List already empty");
  336   assert(Src != Dst && NumOps && "Noop moveOperands");
  355       assert(Head && "List empty, but operand is chained");
  356       assert(Prev && "Operand was not on use-def list");
  381   assert(FromReg != ToReg && "Cannot replace a reg with itself");
  403   assert((I.atEnd() || std::next(I) == def_instr_end()) &&
  501   assert(Register::isVirtualRegister(Reg));
  515   assert(ReservedRegs.size() == getTargetRegisterInfo()->getNumRegs() &&
  520   assert(Register::isPhysicalRegister(PhysReg));
  616   assert(Reg && (Reg < TRI->getNumRegs()) &&
lib/CodeGen/MachineScheduler.cpp
  279   assert(I != Beg && "reached the top of the region, cannot decrement");
  775     assert(!SU->isScheduled && "Node already scheduled");
  781       assert(SU->isTopReady() && "node still has unscheduled dependencies");
  787       assert(SU->isBottomReady() && "node still has unscheduled dependencies");
  807   assert(CurrentTop == CurrentBottom && "Nonempty unscheduled zone.");
  829     assert(!SU.isBoundaryNode() && "Boundary node should not be in SUnits");
  986   assert((!ShouldTrackLaneMasks || ShouldTrackPressure) &&
 1041   assert((BotRPTracker.getPos() == RegionEnd ||
 1124       assert(P.LaneMask.any());
 1141       assert(VNI && "No live value at use.");
 1223     assert(!SU->isScheduled && "Node already scheduled");
 1243   assert(CurrentTop == CurrentBottom && "Nonempty unscheduled zone.");
 1380     assert(TopRPTracker.getPos() == RegionBegin && "bad initial Top tracker");
 1391     assert(SU->isTopReady() && "node still has unscheduled dependencies");
 1413       assert(TopRPTracker.getPos() == CurrentTop && "out of sync");
 1420     assert(SU->isBottomReady() && "node still has unscheduled dependencies");
 1450       assert(BotRPTracker.getPos() == CurrentBottom && "out of sync");
 1753     assert(std::prev(GlobalSegment)->start < LocalLI->beginIndex() &&
 1814   assert(DAG->hasVRegLiveness() && "Expect VRegs with LiveIntervals");
 1883   assert(!ExecutedResCounts[0] && "nonzero count for bad resource");
 1967   assert(NumberOfInstances > 0 &&
 2089   assert(SU->getInstr() && "Scheduled SUnit must have instr");
 2115     assert(MinReadyCycle < std::numeric_limits<unsigned>::max() &&
 2173   assert(Rem->RemainingCounts[PIdx] >= Count && "resource double counted");
 2214   assert(
 2224     assert(ReadyCycle <= CurrCycle && "Broken PendingQueue");
 2246     assert(Rem->RemIssueCount >= DecRemIssue && "MOps double counted");
 2378     assert(Pending.isInQueue(SU) && "bad ready count");
 2715   assert(dag->hasVRegLiveness() &&
 2779   assert((!ForceTopDown || !ForceBottomUp) &&
 3157     assert(BotCand.Reason != NoCand && "failed to find the first candidate");
 3165       assert(TCand.SU == BotCand.SU &&
 3177     assert(TopCand.Reason != NoCand && "failed to find the first candidate");
 3185       assert(TCand.SU == TopCand.SU &&
 3192   assert(BotCand.isValid());
 3193   assert(TopCand.isValid());
 3210     assert(Top.Available.empty() && Top.Pending.empty() &&
 3222         assert(TopCand.Reason != NoCand && "failed to find a candidate");
 3233         assert(BotCand.Reason != NoCand && "failed to find a candidate");
 3417     assert(Top.Available.empty() && Top.Pending.empty() && "ReadyQ garbage");
 3432       assert(TopCand.Reason != NoCand && "failed to find a candidate");
 3508     assert(dag->hasVRegLiveness() && "ILPScheduler needs vreg liveness");
 3551     assert(!IsTopNode && "SchedDFSResult needs bottom-up");
 3659   assert((TopDown || !ForceTopDown) &&
lib/CodeGen/MachineSink.cpp
  243   assert(Register::isVirtualRegister(Reg) && "Only makes sense for vregs");
  408   assert(MI.isDebugValue() && "Expected DBG_VALUE for processing");
  543   assert (SuccToSinkTo && "Invalid SinkTo Candidate BB");
  629   assert (MBB && "Invalid MachineBasicBlock!");
  985   assert(MI.isCopy());
  986   assert(MI.getOperand(1).isReg());
 1004       assert(User.getOperand(0).isReg() &&
 1292     assert((!UsedOpsInCopy.empty() && !DefedRegsInCopy.empty()) &&
 1303     assert((SuccBB->pred_size() == 1 && *SuccBB->pred_begin() == &CurBB) &&
lib/CodeGen/MachineTraceMetrics.cpp
   98   assert(MBB && "No basic block");
  128       assert(PI->ProcResourceIdx < PRKinds && "Bad processor resource kind");
  145   assert(BlockInfo[MBBNum].hasResources() &&
  148   assert((MBBNum+1) * PRKinds <= ProcResourceCycles.size());
  193   assert(PredTBI->hasValidDepth() && "Trace above has not been computed yet");
  228   assert(SuccTBI->hasValidHeight() && "Trace below has not been computed yet");
  266   assert((MBBNum+1) * PRKinds <= ProcResourceDepths.size());
  279   assert((MBBNum+1) * PRKinds <= ProcResourceHeights.size());
  384   assert(strategy < TS_NumStrategies && "Invalid trace strategy enum");
  409   assert(BlockInfo.size() == MF->getNumBlockIDs() && "Outdated BlockInfo size");
  546         assert((!TBI.Succ || Pred->isSuccessor(TBI.Succ)) && "CFG changed");
  571         assert((!TBI.Pred || Succ->isPredecessor(TBI.Pred)) && "CFG changed");
  587   assert(BlockInfo.size() == MTM.MF->getNumBlockIDs() &&
  593       assert(MBB->isPredecessor(TBI.Pred) && "CFG doesn't match trace");
  594       assert(BlockInfo[TBI.Pred->getNumber()].hasValidDepth() &&
  597       assert(!(Loop && MBB == Loop->getHeader()) && "Trace contains backedge");
  601       assert(MBB->isSuccessor(TBI.Succ) && "CFG doesn't match trace");
  602       assert(BlockInfo[TBI.Succ->getNumber()].hasValidHeight() &&
  606       assert(!(Loop && Loop == SuccLoop && TBI.Succ == Loop->getHeader()) &&
  637     assert(Register::isVirtualRegister(VirtReg));
  639     assert(!DefI.atEnd() && "Register has no defs");
  642     assert((++DefI).atEnd() && "Register has multiple defs");
  687   assert(UseMI.isPHI() && UseMI.getNumOperands() % 2 && "Bad PHI");
  764   assert(TBI.HasValidInstrDepths && "Missing depth info");
  765   assert(TBI.HasValidInstrHeights && "Missing height info");
  799     assert(DepTBI.HasValidInstrDepths && "Inconsistent dependency");
  844     assert(TBI.hasValidDepth() && "Incomplete trace");
  980   assert(!Trace.empty() && "Trace should contain at least one block");
  982   assert(Register::isVirtualRegister(Reg));
 1006     assert(TBI.hasValidHeight() && "Incomplete trace");
 1174   assert(getBlockNum() == unsigned(MI.getParent()->getNumber()) &&
 1185   assert(Deps.size() == 1 && "PHI doesn't have MBB as a predecessor");
lib/CodeGen/MachineVerifier.cpp
  345     assert(!Last.isValid() || I->first > Last);
  475   assert(MF);
  490   assert(MBB);
  501   assert(MI);
  511   assert(MO);
 1092       assert(MI->getOpcode() == TargetOpcode::G_ADDRSPACE_CAST);
 1130     assert(MCID.getNumOperands() == 2 && "Expected 2 operands G_*{EXT,TRUNC}");
 1558       assert(SrcSize && "Expecting size here");
 1559       assert(DstSize && "Expecting size here");
 1899     assert(VNI && "NULL valno is not allowed");
 1921       assert(Register::isVirtualRegister(VRegOrUnit) &&
 2313   assert(LiveVars && "Don't call verifyLiveVariables without LiveVars");
 2339   assert(LiveInts && "Don't call verifyLiveIntervals without LiveInts");
 2354     assert(Reg == LI.reg && "Invalid reg to interval mapping");
 2462   assert(VNI && "Live segment has no valno");
 2620     assert(LiveInts->isLiveInToMBB(LR, &*MFI));
 2682   assert(Register::isVirtualRegister(Reg));
 2770       assert(Reachable.count(StackPred) &&
lib/CodeGen/ModuloSchedule.cpp
   37   assert(Phi.isPHI() && "Expecting a Phi.");
   47   assert(InitVal != 0 && LoopVal != 0 && "Unexpected Phi structure.");
  110   assert(LoopInfo && "Must be able to analyze loop!");
  258   assert(!checkBranch && "generateEpilog must be able to analyze the branch");
  265   assert(LoopExitI != KernelBB->succ_end() && "Expecting a successor");
  630       assert(StageScheduled != -1 && "Expecting scheduled instruction.");
  853   assert(PrologBBs.size() == EpilogBBs.size() && "Prolog/Epilog mismatch");
 1158     assert(OrigInstr != InstrMap.end() && "Instruction not scheduled.");
 1223       assert(MI.isPHI());
 1305   assert(FirstMI && "Failed to find first MI in schedule");
 1363     assert(ConsumerStage != -1 &&
 1365     assert(ConsumerStage >= ProducerStage);
 1382     assert(LoopProducer);
 1399     assert(LoopProducerCycle <= ConsumerCycle);
 1400     assert(LoopProducerStage == ConsumerStage + 1);
 1410     assert(ConsumerStage >= LoopProducerStage);
 1634   assert(Prologs.size() == Epilogs.size());
 1703   assert(CanAnalyzeBr && "Must be able to analyze the loop branch!");
 1747       assert(UseMI.isPHI());
 1764   assert(Info);
 1840   assert(LIS && "Requires LiveIntervals!");
 1876     assert(OI->getOpcode() == NI->getOpcode() && "Opcodes don't match?!");
lib/CodeGen/OptimizePHIs.cpp
   99   assert(MI->isPHI() && "IsSingleValuePHICycle expects a PHI instruction");
  143   assert(MI->isPHI() && "IsDeadPHICycle expects a PHI instruction");
  145   assert(Register::isVirtualRegister(DstReg) &&
lib/CodeGen/PHIElimination.cpp
  251   assert(MPhi->getOperand(0).getSubReg() == 0 && "Can't handle sub-reg PHIs");
  345     assert(DestLI.begin() != DestLI.end() &&
  352       assert(OrigDestVNI && "PHI destination should be live at block entry.");
  362       assert(DestVNI && "PHI destination should be live at its definition.");
  380     assert(Register::isVirtualRegister(SrcReg) &&
  468       assert(KillInst->readsRegister(SrcReg) && "Cannot find kill instruction");
  528           assert(KillInst->readsRegister(SrcReg) &&
  643   assert((LV || LIS) &&
  653   assert((LV || LIS) &&
lib/CodeGen/ParallelCG.cpp
   42   assert(BCOSs.empty() || BCOSs.size() == OSs.size());
lib/CodeGen/PatchableFunction.cpp
   63   assert(PatchType == "prologue-short-redirect" && "Only possibility today!");
   69     assert(FirstActualI != FirstMBB.end());
lib/CodeGen/PeepholeOptimizer.cpp
  312       assert(Idx < getNumSources() && "Reg pair source out of index");
  323       assert(Idx < getNumSources() && "Reg source out of index");
  328       assert(Idx < getNumSources() && "SubReg source out of index");
  694         assert(CurSrcRes == Res && "ValueTrackerResult found must match");
  758   assert(!SrcRegs.empty() && "No sources to create a PHI instruction?");
  763   assert(SrcRegs[0].SubReg == 0 && "should not have subreg operand");
  831     assert(MI.isCopy() && "Expected copy instruction");
  906     assert(MI.isInsertSubreg() && "Invalid instruction");
  959     assert(MI.isExtractSubreg() && "Invalid instruction");
 1018     assert(MI.isRegSequence() && "Invalid instruction");
 1168   assert(isCoalescableCopy(MI) && "Invalid argument");
 1169   assert(MI.getDesc().getNumDefs() == 1 &&
 1224   assert(!Register::isPhysicalRegister(Def.Reg) &&
 1270   assert(isUncoalescableCopy(MI) && "Invalid argument");
 1367     assert(II != ImmDefMIs.end() && "couldn't find immediate definition");
 1393   assert(MI.isCopy() && "expected a COPY machine instruction");
 1440   assert(MI.isCopy() && "expected a COPY machine instruction");
 1568     assert(isVirtualRegisterOperand(MO) && "Invalid PHI instruction");
 1808   assert(Def->isCopy() && "Invalid definition");
 1813   assert(Def->getNumOperands() - Def->getNumImplicitOperands() == 2 &&
 1815   assert(!Def->hasImplicitDef() && "Only implicit uses are allowed");
 1829   assert(Def->isBitcast() && "Invalid definition");
 1853     assert(!MO.isDef() && "We should have skipped all the definitions by now");
 1879   assert((Def->isRegSequence() || Def->isRegSequenceLike()) &&
 1923   assert((Def->isInsertSubreg() || Def->isInsertSubregLike()) &&
 1976   assert((Def->isExtractSubreg() ||
 2005   assert(Def->isSubregToReg() && "Invalid definition");
 2026   assert(Def->isPHI() && "Invalid definition");
 2037     assert(MO.isReg() && "Invalid PHI instruction");
 2049   assert(Def && "This method needs a valid definition");
 2051   assert(((Def->getOperand(DefIdx).isDef() &&
lib/CodeGen/PostRASchedulerList.cpp
  219   assert((AntiDepMode == TargetSubtargetInfo::ANTIDEP_NONE ||
  356     assert(Count == 0 && "Instruction count mismatch!");
  357     assert((MBB.begin() == Current || CurrentCount != 0) &&
  503   assert(CurCycle >= SU->getDepth() &&
  665   assert(Sequence.size() - Noops == ScheduledNodes &&
lib/CodeGen/PreISelIntrinsicLowering.cpp
   80     assert(CI->getCalledFunction() && "Cannot lower an indirect call!");
lib/CodeGen/ProcessImplicitDefs.cpp
  142   assert(MRI->isSSA() && "ProcessImplicitDefs only works on SSA form.");
  143   assert(WorkList.empty() && "Inconsistent worklist state");
lib/CodeGen/PrologEpilogInserter.cpp
  329   assert(!MFI.isMaxCallFrameSizeComputed() ||
  360     assert(MFI.getRestorePoint() && "Both restore and save must be set");
  580         assert(I != RestoreBlock.begin() &&
  595   assert(MF.getProperties().hasProperty(
  798   assert(LocalAreaOffset >= 0
 1155       assert(Reachable.count(StackPred) &&
 1176   assert(MF.getSubtarget().getRegisterInfo() &&
 1206         assert(i == 0 && "Frame indices can only appear as the first "
 1250         assert((!MI.isDebugValue() || i == 0) &&
lib/CodeGen/ReachingDefAnalysis.cpp
   27   assert(MBBNumber < MBBReachingDefs.size() &&
   56     assert(unsigned(pred->getNumber()) < MBBOutRegsInfos.size() &&
   79   assert(!LiveRegs.empty() && "Must enter basic block first.");
   81   assert(MBBNumber < MBBOutRegsInfos.size() &&
   96   assert(!MI->isDebugInstr() && "Won't process debug instructions");
   99   assert(MBBNumber < MBBReachingDefs.size() &&
  174   assert(InstIds.count(MI) && "Unexpected machine instuction.");
  178   assert(MBBNumber < MBBReachingDefs.size() &&
  193   assert(InstIds.count(MI) && "Unexpected machine instuction.");
lib/CodeGen/RegAllocBase.cpp
   90     assert(!VRM->hasPhys(VirtReg->reg) && "Register already assigned");
  145       assert(LIS->hasInterval(Reg));
  148       assert(!VRM->hasPhys(SplitVirtReg->reg) && "Register already assigned");
  150         assert(SplitVirtReg->empty() && "Non-empty but used interval");
  157       assert(Register::isVirtualRegister(SplitVirtReg->reg) &&
lib/CodeGen/RegAllocBasic.cpp
  223   assert(!Intfs.empty() && "expected interference");
  287     assert(!Matrix->checkInterference(VirtReg, *PhysRegI) &&
lib/CodeGen/RegAllocFast.cpp
  331     assert(NewDV->getParent() == MBB && "dangling parent pointer");
  389   assert(PhysRegState[LR.PhysReg] == LR.VirtReg &&
  397   assert(Register::isVirtualRegister(VirtReg) &&
  408   assert(Register::isVirtualRegister(VirtReg) &&
  411   assert(LRI != LiveVirtRegs.end() && LRI->PhysReg &&
  418   assert(PhysRegState[LR.PhysReg] == LR.VirtReg && "Broken RegState mapping");
  459   assert(Register::isPhysicalRegister(PhysReg) && "Bad usePhysReg operand");
  493       assert((TRI->isSuperRegister(PhysReg, Alias) ||
  576     assert(LRI != LiveVirtRegs.end() && LRI->PhysReg &&
  597       assert(LRI != LiveVirtRegs.end() && LRI->PhysReg &&
  614   assert(LR.PhysReg == 0 && "Already assigned a physreg");
  615   assert(PhysReg != 0 && "Trying to assign no register");
  630     assert(Register::isVirtualRegister(Reg));
  664   assert(Register::isVirtualRegister(VirtReg) &&
  752   assert(MO.isUndef() && "expected undef use");
  754   assert(Register::isVirtualRegister(VirtReg) && "Expected virtreg");
  763     assert(!AllocationOrder.empty() && "Allocation order must not be empty");
  779   assert(Register::isVirtualRegister(VirtReg) && "Not a virtual register");
  799   assert(LRI->PhysReg && "Register not assigned");
  812   assert(Register::isVirtualRegister(VirtReg) && "Not a virtual register");
  845   assert(LRI->PhysReg && "Register not assigned");
  990       assert(LRI != LiveVirtRegs.end() && LRI->PhysReg &&
  994       assert(LRI->PhysReg == Reg && "Bad inverse map");
 1005     assert(Register::isVirtualRegister(i->VirtReg) && "Bad map key");
 1006     assert(Register::isPhysicalRegister(i->PhysReg) && "Bad map value");
 1007     assert(PhysRegState[i->PhysReg] == i->VirtReg && "Bad inverse map");
 1130       assert(MO.isUndef() && "Should only have undef virtreg uses left");
 1250   assert(LiveVirtRegs.empty() && "Mapping not cleared from last block?");
lib/CodeGen/RegAllocGreedy.cpp
  688   assert(Register::isVirtualRegister(Reg) &&
  902       assert(Register::isVirtualRegister(Intf->reg) &&
 1083     assert((ExtraRegInfo[Intf->reg].Cascade < Cascade ||
 1271       assert(T < GroupSize && "Array overflow");
 1280     assert(B < GroupSize && "Array overflow");
 1684   assert(NumGlobalIntvs && "No global intervals configured");
 1998     assert(!Cand.PhysReg && "Compact region has no physreg");
 2021   assert(&SA->getParent() == &VirtReg && "Live range wasn't analyzed");
 2068   assert(SuperRC && "Invalid register class");
 2153   assert(SA->getUseBlocks().size() == 1 && "Not a local interval");
 2270       assert(!SlotIndex::isEarlierInstr(RMS[ri], Uses[i]));
 2440     assert(!ProgressRequired && "Didn't make progress when it was required.");
 2610   assert((getStage(VirtReg) >= RS_Done || !VirtReg.isSpillable()) &&
 2629   assert(!FixedRegisters.count(VirtReg.reg));
 2667       assert(VRM->hasPhys(ItVirtReg) &&
 2755       assert(LI->empty() && "Only empty live-range do not require a register");
 2938     assert(VRM->hasPhys(Reg) && "We have unallocated variable!!");
 3024     assert(Register::isVirtualRegister(LI->reg) &&
 3084   assert((NewVRegs.empty() || Depth) && "Cannot append to existing NewVRegs");
lib/CodeGen/RegAllocPBQP.cpp
  245     assert(NRegs != MRegs && "AllowedRegs can not be disjoint with itself");
  336       assert(!LI.empty() && "PBQP graph contains node for empty interval");
  509     assert(CostMat.getRows() == Allowed1.size() + 1 && "Size mismatch.");
  510     assert(CostMat.getCols() == Allowed2.size() + 1 && "Size mismatch.");
  695     assert(!LI.empty() && "Empty spill range.");
  728       assert(PReg != 0 && "Invalid preg selected.");
  764       assert(PReg &&
  891     assert(Costs.getLength() != 0 && "Empty vector in graph.");
  899     assert(N1Id != N2Id && "PBQP graphs should not have self-edges.");
  901     assert(M.getRows() != 0 && "No rows in matrix.");
  902     assert(M.getCols() != 0 && "No cols in matrix.");
lib/CodeGen/RegUsageInfoPropagate.cpp
   65     assert(RegMask.size() ==
lib/CodeGen/RegisterClassInfo.cpp
   55   assert(TRI && "no register info set");
   91   assert(RC && "no register class given");
  130   assert(RCI.NumRegs <= NumRegs && "Allocation order larger than regclass");
lib/CodeGen/RegisterCoalescer.cpp
  477   assert(Register::isVirtualRegister(Src) && "Src must be virtual");
  478   assert(!(Register::isPhysicalRegister(Dst) && DstSub) &&
  513     assert(!DstIdx && !SrcIdx && "Inconsistent CoalescerPair state.");
  557   assert(!CP.isPartial() && "This doesn't work for partial copies.");
  558   assert(!CP.isPhys() && "This doesn't work for physreg copies.");
  740   assert(!CP.isPhys());
  771   assert(BValNo != nullptr && BValNo->def == CopyIdx);
  775   assert(AValNo && !AValNo->isUnused() && "COPY source not live");
  786   assert(DefIdx != -1);
  875     assert(US != IntA.end() && "Use must be live");
  899     assert(DVNI->def == DefIdx);
  906       assert(SubBValNo->def == CopyIdx);
  946             assert(BSubValNo != nullptr);
 1027   assert(!CP.isPhys());
 1046   assert(AValNo && !AValNo->isUnused() && "COPY source not live");
 1161     assert(BValNo && "All sublanes should be live");
 1191   assert(!Register::isPhysicalRegister(Reg) &&
 1272       assert(Register::isVirtualRegister(DstReg) &&
 1294       assert(SrcIdx == 0 && CP.isFlipped()
 1318       assert(MO.isImplicit() && "No explicit operands after implicit operands.");
 1338       assert(MO.isImplicit() && MO.isDead() &&
 1352       assert(NewRC && "subreg chosen for remat incompatible with instruction");
 1431     assert(Register::isPhysicalRegister(DstReg) &&
 1549   assert(Seg != nullptr && "No segment for defining instruction");
 1579       assert(SVNI != nullptr && SlotIndex::isSameInstr(SVNI->def, RegIndex));
 1808       assert(ReadVNI && "No value before copy and no <undef> flag.");
 1809       assert(ReadVNI != DefVNI && "Cannot read and define the same value.");
 1981   assert(CP.isPhys() && "Must be a physreg copy");
 1982   assert(MRI->isReserved(DstReg) && "Not a reserved register");
 1986   assert(RHS.containsOneValue() && "Invalid join with reserved register");
 2411     assert(MI && "No defining instruction");
 2484   assert(!V.isAnalyzed() && "Value has already been analyzed!");
 2500     assert(DefMI != nullptr);
 2529         assert((TrackSubRegLiveness || V.RedefVNI) &&
 2558     assert(SlotIndex::isSameInstr(VNI->def, OtherVNI->def) && "Broken LRQ");
 2593   assert(!SlotIndex::isSameInstr(VNI->def, V.OtherVNI->def) && "Broken LRQ");
 2691     assert(VNI->def.isEarlyClobber() &&
 2725     assert(Assignments[ValNo] != -1 && "Bad recursion?");
 2732     assert(V.OtherVNI && "OtherVNI not assigned, can't merge.");
 2733     assert(Other.Vals[V.OtherVNI->id].isAnalyzed() && "Missing recursion");
 2744     assert(V.OtherVNI && "OtherVNI not assigned, can't prune");
 2792   assert(OtherI != Other.LR.end() && "No conflict?");
 2842     assert(V.Resolution != CR_Impossible && "Unresolvable conflict");
 2851     assert(V.OtherVNI && "Inconsistent conflict resolution.");
 2864     assert(!TaintExtent.empty() && "There should be at least one conflict.");
 2874     assert(!SlotIndex::isSameInstr(VNI->def, TaintExtent.front().first) &&
 2878     assert(LastMI && "Range must end at a proper instruction");
 2881       assert(MI != MBB->end() && "Bad LastMI");
 2891         assert(LastMI && "Range must end at a proper instruction");
 3088   assert(&static_cast<LiveRange&>(LI) == &LR);
 3140         assert(I != LR.end());
 3153         assert(static_cast<LiveRange*>(LI) == &LR);
 3190       assert(MI && "No instruction to erase");
 3337       assert(Mask.any());
 3513   assert(Copy.isCopyLike());
 3522   assert(Copy.isCopyLike());
 3637   assert(WorkList.empty() && LocalWorkList.empty() && "Old data still around.");
 3736             assert((S.LaneMask & ~MaxMask).none());
lib/CodeGen/RegisterPressure.cpp
   53   assert((PrevMask & ~NewMask).none() && "Must not remove bits");
   74     assert(CurrSetPressure[*PSetI] >= Weight && "register pressure underflow");
  280     assert(lis && "IntervalPressure requires LiveIntervals");
  325   assert(P.LiveInRegs.empty() && "inconsistent max pressure result");
  337   assert(P.LiveOutRegs.empty() && "inconsistent max pressure result");
  345     assert(LiveRegs.size() == 0 && "no region boundary");
  361   assert(isBottomClosed() && "need bottom-up tracking to intialize.");
  384   assert(Pair.LaneMask.any());
  410   assert(Pair.LaneMask.any());
  507       assert(MO.isDef());
  539       assert(MO.isDef());
  661   assert(!PDiff.begin()->isValid() && "stale PDiff");
  715   assert(Pair.LaneMask.any());
  765   assert(!CurrPos->isDebugInstr());
  804     assert(Use.LaneMask.any());
  823             assert(I->LaneMask.none());
  852   assert(CurrPos != MBB->begin());
  877     assert(CurrPos == MBB->begin());
  896   assert(!TrackUntiedDefs && "unsupported mode");
  897   assert(CurrPos != MBB->end());
 1042   assert(!MI->isDebugInstr() && "Expect a nondebug instruction.");
 1051   assert(RegOpers.DeadDefs.size() == 0);
 1109   assert(Delta.CriticalMax.getUnitInc() >= 0 &&
 1180     assert((PDiffI->getUnitInc() >= 0) == (PNew >= POld)
 1245   assert(RequireIntervals);
 1255   assert(RequireIntervals);
 1266   assert(RequireIntervals);
 1283   assert(!MI->isDebugInstr() && "Expect a nondebug instruction.");
 1355   assert(Delta.CriticalMax.getUnitInc() >= 0 &&
lib/CodeGen/RegisterScavenging.cpp
   63   assert((NumRegUnits == 0 || NumRegUnits == TRI->getNumRegUnits()) &&
  110   assert(Tracking && "Must be tracking to determine kills and defs");
  113   assert(!MI.isDebugInstr() && "Debug values have no kills or defs");
  147       assert(MO.isDef());
  157   assert(Tracking && "Cannot unprocess because we're not tracking");
  181     assert(MBBI != MBB->end() && "Already past the end of the basic block!");
  184   assert(MBBI != MBB->end() && "Already at the end of the basic block!");
  243       assert(MO.isDef());
  261   assert(Tracking && "Must be tracking to determine kills and defs");
  311   assert(Survivor > 0 && "No candidates for scavenging");
  314   assert(StartMI != ME && "MI already at terminator");
  362   assert(RestorePointMI != StartMI &&
  454     assert(i < MI.getNumOperands() && "Instr doesn't have FrameIndex operand!");
  594   assert(Reg != 0 && "No register left to scavenge!");
  635     assert(MBB == CommonMBB && "All defs+uses must be in the same basic block");
  639         assert((!RealDef || RealDef == &MI) &&
  645   assert(RealDef != nullptr && "Must have at least 1 Def");
  659   assert(FirstDef != MRI.def_end() &&
  727       assert(!MO.isInternalRead() && "Cannot assign inside bundles");
  728       assert((!MO.isUndef() || MO.isDef()) && "Cannot handle undef uses");
  742     assert(!MO.isInternalRead() && "Cannot assign inside bundles");
  743     assert((!MO.isUndef() || MO.isDef()) && "Cannot handle undef uses");
  744     assert(!MO.readsReg() && "Vreg use in first instruction not allowed");
lib/CodeGen/SafeStack.cpp
  292       assert(V == UI.get());
  430   assert(StaticTop && "The stack top isn't set.");
  541     assert(isPowerOf2_32(FrameAlignment));
  664     assert(isPowerOf2_32(Align));
  701         assert(II->use_empty());
  738   assert(F.hasFnAttribute(Attribute::SafeStack) &&
  740   assert(!F.isDeclaration() && "Can't run SafeStack on a function declaration");
  789   assert(BasePointer->getType() == StackPtrTy);
lib/CodeGen/SafeStackColoring.cpp
   43   assert(IT != AllocaNumbering.end());
  232         assert(!Started.test(AllocaNo) || Start[AllocaNo] == BBStart);
  239         assert(!Ended.test(AllocaNo));
lib/CodeGen/SafeStackColoring.h
  132     assert(NumInst >= 0);
lib/CodeGen/SafeStackLayout.cpp
   67   assert(Obj.Alignment <= MaxAlignment);
   74     assert(End >= R.Start);
lib/CodeGen/ScalarizeMaskedMemIntrin.cpp
  519   assert(isa<VectorType>(Src->getType()) &&
  521   assert(isa<VectorType>(Ptrs->getType()) &&
lib/CodeGen/ScheduleDAG.cpp
  139     assert(NumPreds < std::numeric_limits<unsigned>::max() &&
  141     assert(N->NumSuccs < std::numeric_limits<unsigned>::max() &&
  151       assert(NumPredsLeft < std::numeric_limits<unsigned>::max() &&
  161       assert(N->NumSuccsLeft < std::numeric_limits<unsigned>::max() &&
  185   assert(Succ != N->Succs.end() && "Mismatching preds / succs lists!");
  190     assert(NumPreds > 0 && "NumPreds will underflow!");
  191     assert(N->NumSuccs > 0 && "NumSuccs will underflow!");
  199       assert(NumPredsLeft > 0 && "NumPredsLeft will underflow!");
  207       assert(N->NumSuccsLeft > 0 && "NumSuccsLeft will underflow!");
  433   assert(!AnyNotSched);
  488       assert(SU.Succs.empty() && "SUnit should have no successors");
  516       assert(Node2Index[SU.NodeNum] > Node2Index[PD.getSUnit()->NodeNum] &&
  558     assert(!HasLoop && "Inserted edge creates a loop!");
  674   assert(Found && "Error in SUnit Graph!");
lib/CodeGen/ScheduleDAGInstrs.cpp
  160           assert(isIdentifiedObject(V));
  190   assert(bb == BB && "startBlock should set BB");
  231   assert(MO.isDef() && "expect physreg def");
  423     assert(deadDefHasNoUse(MO) && "Dead defs should have no uses");
  632       assert(NumNodes >= Itr->second.size());
  678   assert(BarrierChain != nullptr);
  689   assert(BarrierChain != nullptr);
  776   assert(Defs.empty() && Uses.empty() &&
  781   assert(CurrentVRegDefs.empty() && "nobody else should use CurrentVRegDefs");
  782   assert(CurrentVRegUses.empty() && "nobody else should use CurrentVRegUses");
  809     assert(SU && "No SUnit mapped to this MI");
  823       assert(&*RPTracker->getPos() == &MI && "RPTracker in sync");
  827     assert(
 1059   assert(N <= NodeNums.size());
 1319     assert(SubtreeClasses.getNumClasses() == RootSet.size()
 1355     assert(PredDep.getKind() == SDep::Data && "Subtrees are for data edges");
lib/CodeGen/ScoreboardHazardRecognizer.cpp
  139         assert((StageCycle - Stalls) < (int)RequiredScoreboard.getDepth() &&
  178   assert(MCID && "The scheduler must filter non-machineinstrs");
  193       assert(((cycle + i) < RequiredScoreboard.getDepth()) &&
lib/CodeGen/SelectionDAG/DAGCombiner.cpp
  207         assert(GoodWorklistEntry &&
  238       assert(N->getOpcode() != ISD::DELETED_NODE &&
  692       assert(LHSTy.isInteger() && "Shift amount is not an integer type!");
  971   assert(TLI.isCommutativeBinOp(Opc) && "Operation not commutative.");
  991   assert(N->getNumValues() == NumTo && "Broken CombineTo call!");
  997     assert((!To[i].getNode() ||
 1189     assert(PVT != VT && "Don't know what type to promote to!");
 1254     assert(PVT != VT && "Don't know what type to promote to!");
 1303     assert(PVT != VT && "Don't know what type to promote to!");
 1334     assert(PVT != VT && "Don't know what type to promote to!");
 1458     assert(N->getOpcode() != ISD::DELETED_NODE &&
 1467       assert(N->getValueType(0) == RV.getValueType() &&
 1627     assert(N->getOpcode() != ISD::DELETED_NODE &&
 1810       assert((OrigOpNumber != Ops.size()) &&
 1835     assert((OpWorkCount[CurOpNumber] > 0) &&
 1917   assert(TLI.isBinOp(BO->getOpcode()) && BO->getNumValues() == 1 &&
 1995   assert((N->getOpcode() == ISD::ADD || N->getOpcode() == ISD::SUB) &&
 2036   assert((N->getOpcode() == ISD::ADD || N->getOpcode() == ISD::SUB) &&
 2118       assert(Sub && "Constant folding failed");
 2127       assert(Add && "Constant folding failed");
 2947     assert(NewC && "Constant folding failed");
 2958       assert(NewC && "Constant folding failed");
 2969     assert(NewC && "Constant folding failed");
 2979     assert(NewC && "Constant folding failed");
 3338     assert((!N0IsConst ||
 3341     assert((!N1IsConst ||
 3426       assert(ShAmt < VT.getScalarSizeInBits() &&
 3564           assert(UserOpc == Opcode);
 4254   assert((LogicOpcode == ISD::AND || LogicOpcode == ISD::OR ||
 4256   assert(HandOpcode == N1.getOpcode() && "Bad input!");
 4370     assert(X.getValueType() == Y.getValueType() &&
 4419   assert(N0.getValueType() == N1.getValueType() &&
 4421   assert(LL.getValueType() == LR.getValueType() &&
 4637           assert(MaskBits <= Size);
 4757     assert(isa<StoreSDNode>(LDST) && "It is not a Load nor a Store SDNode");
 4853       assert(HasValue && "Node to be masked has no data result?");
 4917       assert(NewLoad &&
 4933   assert(N->getOpcode() == ISD::AND);
 4985   assert(And->getOpcode() == ISD::AND && "Expected an 'and' op");
 5712         assert((!ZeroN00 || !ZeroN01) && "Both inputs zero!");
 5713         assert((!ZeroN10 || !ZeroN11) && "Both inputs zero!");
 5741           assert((M0 >= 0 || M1 >= 0) && "Undef index!");
 5892   assert(OppShift && ExtractFrom && "Empty SDValue");
 5893   assert(
 6151     assert(LHS.getValueType() == RHS.getValueType());
 6333   assert(Op.getValueType().isScalarInteger() && "can't handle other types");
 6338   assert(Index < ByteWidth && "invalid index requested");
 6437   assert((BigEndian != LittleEndian) && "It should be either big endian or"
 6570   assert(FirstOffset != INT64_MAX && "First byte offset must be set");
 6571   assert(FirstStore && "First store must be set");
 6600     assert(CombinedValue.getValueType().getSizeInBits() > VT.getSizeInBits() &&
 6649   assert(N->getOpcode() == ISD::OR &&
 6667     assert(P.isMemory() && "Must be a memory byte provider");
 6669     assert(LoadBitWidth % 8 == 0 &&
 6693     assert(L->hasNUsesOfValue(1, 0) && L->isSimple() &&
 6696     assert(L->getOffset().isUndef() && "Unindexed load must have undef offset");
 6725   assert(!Loads.empty() && "All the bytes of the value must be loaded from "
 6727   assert(Base && "Base address of the accessed memory location must be set");
 6728   assert(FirstOffset != INT64_MAX && "First byte offset must be set");
 6736   assert(FirstByteProvider && "must be set");
 6788   assert(N->getOpcode() == ISD::XOR);
 6840     assert(TLI.hasAndNot(X) && "Only mask is a variable? Unreachable.");
 7076   assert(C1Node && "Expected a shift with constant operand");
 7130   assert(isConstOrConstSplat(N->getOperand(1)) && "Expected constant operand");
 7193   assert(isa<ConstantSDNode>(NewRHS) && "Folding was not successful!");
 7201   assert(N->getOpcode() == ISD::TRUNCATE);
 7202   assert(N->getOperand(0).getOpcode() == ISD::AND);
 8184   assert(isConstantOrConstantVector(C1) && isConstantOrConstantVector(C2) &&
 8519   assert(LHS.getOpcode() == ISD::CONCAT_VECTORS &&
 8556   assert(TopHalf && BottomHalf &&
 8893   assert((Opcode == ISD::SIGN_EXTEND || Opcode == ISD::ZERO_EXTEND ||
 9060   assert((N->getOpcode() == ISD::SIGN_EXTEND ||
 9111   assert(!DstVT.isScalableVector() && "Unexpected scalable vector type");
 9157   assert(N->getOpcode() == ISD::ZERO_EXTEND);
 9238   assert((CastOpcode == ISD::SIGN_EXTEND || CastOpcode == ISD::ZERO_EXTEND ||
 9381   assert((N->getOpcode() == ISD::SIGN_EXTEND ||
 9662   assert(Op0.getValueType() == Op1.getValueType());
 9680   assert((Extend->getOpcode() == ISD::ZERO_EXTEND ||
10124     assert(BigA_AssertVT.bitsLE(N0.getValueType()) &&
10144     assert(BigA_AssertVT.bitsLE(N0.getValueType()) &&
10597     assert(NVT.getSizeInBits() == VecTy.getSizeInBits() && "Invalid Size");
10676       assert((BuildVecNumElts % TruncVecNumElts) == 0 &&
10748       assert(V.getNode() && "The single defined operand is empty!");
10860   assert(N->getOpcode() == ISD::BUILD_PAIR);
11042       assert(VT.getSizeInBits() == 128);
11050         assert(N0.getOpcode() == ISD::FABS);
11068     assert(N0.getOpcode() == ISD::FABS);
11257   assert(SrcEltVT.isInteger() && DstEltVT.isInteger());
11834   assert(N->getOpcode() == ISD::FMUL && "Expected FMUL Operation");
13675     assert(OtherUses[i]->getOperand(!OffsetIdx).getNode() ==
13856   assert(AM != ISD::UNINDEXED);
13863   assert((Inc.getOpcode() != ISD::TargetConstant ||
13909   assert(Val.getValueType() == LDMemType &&
14061       assert(N->getValueType(2) == MVT::Other && "Malformed indexed loads?");
14108         assert(NewLoad.getNode() == N);
14274     assert(Origin && "No original load to compare against.");
14276     assert(Inst && "This slice is not bound to an instruction");
14277     assert(Inst->getValueSizeInBits(0) <= BitWidth &&
14289     assert(!(SliceSize & 0x7) && "Size is not a multiple of a byte.");
14296     assert(DAG && "Missing context");
14358     assert(DAG && "Missing context.");
14360     assert(!(Shift & 0x7) && "Shifts not aligned on Bytes are not supported.");
14363     assert(!(Origin->getValueSizeInBits(0) & 0x7) &&
14368     assert(TySizeInBytes > Offset &&
14382     assert(Inst && Origin && "Unable to replace a non-existing slice.");
14387     assert(Offset >= 0 && "Offset too big to fit in int64_t!");
14423     assert(DAG && "Missing context");
14485   assert(First.Origin == Second.Origin && First.Origin &&
14488   assert((UsedBits & Second.getUsedBits()) == 0 &&
14508     assert(LHS.Origin == RHS.Origin && "Different bases not implemented.");
14547     assert(GlobalLSCost.Loads > 0 && "We save more loads than we created!");
14688     assert(SliceInst->getOpcode() == ISD::LOAD &&
15101   assert(Chains.size() > 0 && "Chain should have generated a chain");
15195     assert(IsConstantSrc && "Merged vector elements should use vector store");
16163         assert(NewStore.getNode() == N);
16527       assert(NewMask[InsIndex] <
16659   assert(Ops.size() == NumElts && "Unexpected vector size");
16676   assert(OriginalLoad->isSimple());
16820       assert(InOp.getValueType().isInteger() && ScalarVT.isInteger());
16866       assert(X.getValueType().isScalarInteger() && ScalarVT.isScalarInteger() &&
16877         assert(XBitWidth % VecEltBitWidth == 0 &&
16914         assert(InOp.getValueType().isInteger() && ScalarVT.isInteger());
17122   assert(ElemRatio > 1 && "Invalid element size ratio");
17132     assert((Cast.getOpcode() == ISD::ANY_EXTEND ||
17143     assert(Index < Ops.size() && "Invalid index");
17149   assert(VecVT.getSizeInBits() == VT.getSizeInBits() &&
17191       assert(NumConcats >= 2 && "Concat needs at least two inputs!");
17273   assert(InVT1 == VecIn2.getValueType() && "Unexpected second input type.");
17283   assert(BV->getOpcode() == ISD::BUILD_VECTOR && "Expected build vector");
17660       assert(!V.isUndef() && "Splat of undef should have been handled earlier");
17857     assert(In.getValueType().isVector() && "Must concat vectors");