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

References

   88   assert(Add1F->arg_begin() != Add1F->arg_end()); // Make sure there's an arg

   45   assert(Add1F->arg_begin() != Add1F->arg_end()); // Make sure there's an arg

  269     assert(isUnaryOp() || isBinaryOp());
  809   assert(F && "binary operator not found!");
 1162       assert(FP && "Failed to codegen function");

  269     assert(isUnaryOp() || isBinaryOp());
  809   assert(F && "binary operator not found!");
 1162       assert(FP && "Failed to codegen function");

  269     assert(isUnaryOp() || isBinaryOp());
  808   assert(F && "binary operator not found!");
 1149       assert(ExprSymbol && "Function not found");

  161       assert(Sym && "Couldn't find compiled function?");

  269     assert(isUnaryOp() || isBinaryOp());
  794   assert(F && "binary operator not found!");
 1152       assert(ExprSymbol && "Function not found");

  174       assert(Sym && "Couldn't find compiled function?");

   34     assert(Dst && "Attempt to read into null.");
   52     assert(Src && "Attempt to append from null.");

  286     assert(isUnaryOp() || isBinaryOp());
  818   assert(F && "binary operator not found!");
 1176       assert(ExprSymbol && "Function not found");

  611       assert(ExprSymbol && "Function not found");

  885       assert(ExprSymbol && "Function not found");

  252     assert(isUnaryOp() || isBinaryOp());
  707   assert(F && "binary operator not found!");
 1004       assert(ExprSymbol && "Function not found");

  274     assert(isUnaryOp() || isBinaryOp());
  814   assert(F && "binary operator not found!");
 1174       assert(ExprSymbol && "Function not found");

  275     assert(isUnaryOp() || isBinaryOp());
  813   assert(F && "binary operator not found!");

  377     assert(isUnaryOp() || isBinaryOp());
  972   assert(F && "binary operator not found!");

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

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

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]) &&

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]) &&

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

21325   assert(Inst.getOpcode() < 5384);

  134     assert(Index++ == RB->getID() && "Index != ID");

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

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

32459   assert(Bits != 0 && "Cannot print this instruction.");
35780   assert(RegNo && RegNo < 3666 && "Invalid register number!");
39644   assert (*(AsmStrs+RegAsmOffset[RegNo-1]) &&

78716   assert(N->getNumOperands() == 2);
78717   assert(N->getOperand(0).getValueType().getSizeInBits() == 16);

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

50357   assert(Inst.getOpcode() < 15263);

  233     assert(Index++ == RB->getID() && "Index != ID");

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

  795   assert(Bits != 0 && "Cannot print this instruction.");
 1184   assert(RegNo && RegNo < 1675 && "Invalid register number!");
 2822   assert (*(AsmStrs+RegAsmOffset[RegNo-1]) &&

 2314   assert(Inst.getOpcode() < 514);

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

  759   assert(Bits != 0 && "Cannot print this instruction.");
  951   assert(RegNo && RegNo < 34 && "Invalid register number!");
  995   assert (*(AsmStrs+RegAsmOffset[RegNo-1]) &&

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

  715   assert(RegUnit < 33 && "invalid register unit");
  768   assert(RegUnit < 33 && "invalid register unit");

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

 9142   assert(Bits != 0 && "Cannot print this instruction.");
11789   assert(RegNo && RegNo < 295 && "Invalid register number!");
12046     assert(*(AsmStrsNoRegAltName+RegAsmOffsetNoRegAltName[RegNo-1]) &&

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

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

  109     assert(Index++ == RB->getID() && "Index != ID");

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

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

  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]) &&

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

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

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

  676   assert(Bits != 0 && "Cannot print this instruction.");
 1020   assert(RegNo && RegNo < 25 && "Invalid register number!");
 1054   assert (*(AsmStrs+RegAsmOffset[RegNo-1]) &&

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

  973   assert(Inst.getOpcode() < 309);

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

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

 9077   assert(Bits != 0 && "Cannot print this instruction.");
16684   assert(RegNo && RegNo < 197 && "Invalid register number!");
16901   assert (*(AsmStrs+RegAsmOffset[RegNo-1]) &&

72557   assert(isPowerOf2_32(VecSize));
73066   assert(V >= 32);
73081   assert(V >= 1);
73166   assert(isUInt<8>(V));
73175   assert(isUInt<16>(V));

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

14636   assert(Inst.getOpcode() < 2978);

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

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

  640   assert(Bits != 0 && "Cannot print this instruction.");
  842   assert(RegNo && RegNo < 41 && "Invalid register number!");
  891   assert (*(AsmStrs+RegAsmOffset[RegNo-1]) &&

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

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

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

  600   assert(Bits != 0 && "Cannot print this instruction.");
  732   assert(RegNo && RegNo < 33 && "Invalid register number!");
  759   assert (*(AsmStrs+RegAsmOffset[RegNo-1]) &&

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

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

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

 6674   assert(Bits != 0 && "Cannot print this instruction.");
 7326   assert(RegNo && RegNo < 442 && "Invalid register number!");
 7471   assert (*(AsmStrs+RegAsmOffset[RegNo-1]) &&

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

   98     assert(Index++ == RB->getID() && "Index != ID");

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

12836   assert(Bits != 0 && "Cannot print this instruction.");
27102   assert(RegNo && RegNo < 96 && "Invalid register number!");
27212   assert (*(AsmStrs+RegAsmOffset[RegNo-1]) &&

 1204   assert(RegUnit < 95 && "invalid register unit");
 1288   assert(RegUnit < 95 && "invalid register unit");

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

 6073   assert(Bits != 0 && "Cannot print this instruction.");
 6673   assert(RegNo && RegNo < 344 && "Invalid register number!");
 6906   assert (*(AsmStrs+RegAsmOffset[RegNo-1]) &&

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

 8503   assert(Inst.getOpcode() < 2219);

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

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

 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]) &&

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

   61     assert(Index++ == RB->getID() && "Index != ID");

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

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

 1074   assert(Bits != 0 && "Cannot print this instruction.");
 1366   assert(RegNo && RegNo < 236 && "Invalid register number!");
 1559   assert (*(AsmStrs+RegAsmOffset[RegNo-1]) &&

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

 2456   assert(Inst.getOpcode() < 704);

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

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

11373   assert(Bits != 0 && "Cannot print this instruction.");
12170   assert(RegNo && RegNo < 195 && "Invalid register number!");
12290   assert (*(AsmStrs+RegAsmOffset[RegNo-1]) &&

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

11984   assert(Inst.getOpcode() < 3004);

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

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

 2094   assert(Bits != 0 && "Cannot print this instruction.");
 2300   assert(RegNo && RegNo < 13 && "Invalid register number!");
 2321   assert (*(AsmStrs+RegAsmOffset[RegNo-1]) &&

  478   assert(RegUnit < 12 && "invalid register unit");
  541   assert(RegUnit < 12 && "invalid register unit");

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

47417   assert(Bits != 0 && "Cannot print this instruction.");
48554   assert(RegNo && RegNo < 282 && "Invalid register number!");
48838   assert (*(AsmStrs+RegAsmOffset[RegNo-1]) &&

31877   assert(Bits != 0 && "Cannot print this instruction.");
32880   assert(RegNo && RegNo < 282 && "Invalid register number!");
33164   assert (*(AsmStrs+RegAsmOffset[RegNo-1]) &&

  152     assert(Index++ == RB->getID() && "Index != ID");

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

  575   assert(Bits != 0 && "Cannot print this instruction.");
  852   assert(RegNo && RegNo < 17 && "Invalid register number!");
  878   assert (*(AsmStrs+RegAsmOffset[RegNo-1]) &&

 2477   assert(N->getZExtValue() % 4 == 0);
 2494   assert(-value % 4 == 0);
 2510   assert(isMask_32(N->getZExtValue()));

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

  478   assert(RegUnit < 16 && "invalid register unit");
  526   assert(RegUnit < 16 && "invalid register unit");

  659   assert(!isAlignmentDependent());

  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 &&

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

 3556     assert(false && "Abstract matcher rule isn't allowed");

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

  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() &&

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

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

  231     assert(empty() && "Cannot reset allocator if not empty");

  143   assert(Value && any_isa<T>(*Value) && "Bad any cast!");
  151   assert(Value && any_isa<U>(*Value) && "Bad any cast!");

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

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

   92   assert(U >= 0 && "Negative enum values are not allowed.");
   93   assert(U <= Mask<E>() && "Enum value too large (or largest val too small?)");

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

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

  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() &&

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

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

  460     assert(Inserted == N && "Node already inserted!");

  411   assert(buffer_ptr == buffer_end);

  133     assert(!isEmpty() && "Cannot get the head of an empty list.");

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

   46       assert(toIndex_(n) < storage_.size() && "index out of bounds!");
   51       assert(toIndex_(n) < storage_.size() && "index out of bounds!");

   76     assert(NumClasses && "operator[] called before compress()");

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

   80     assert(RefCount > 0 && "Reference count is already zero.");
   98     assert(NewRefCount >= 0 && "Reference count was already zero.");

  182       assert(I.second != Index && "Index was already erased!");

   73     assert(hasVal);
   77     assert(hasVal);
  173     assert(hasVal);
  177     assert(hasVal);

   38     assert((val >> BitNum) == 0 && "value is too big");
   61     assert((val >> (BitNum-1)) == 0 && "value is too big");

   64     assert((std::is_signed<IntT>::value ? isInt<Bits>(I) : isUInt<Bits>(I)) &&

   85     assert(Value == reinterpret_cast<intptr_t>(getPointer()) &&
  178     assert((PtrWord & ~PointerBitMask) == 0 &&
  186     assert((IntWord & ~IntMask) == 0 && "Integer too large for field");

  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>() &&

  195     assert(is<T>() && "Invalid accessor called");
  216     assert(is<First>() && "Val is not the first pointer");
  217     assert(

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

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

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

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

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

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

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

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

   83     assert(Idx < BITWORDS_PER_ELEMENT);
  154     assert(WordPos <= BITWORDS_PER_ELEMENT

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

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

  163   assert(U1 != -1U && U2 != -1U);
  181   assert(Input.size() % 2 == 0);

  189     assert(NewItem && "Unhandled out-of-memory");
  403     assert(NumItems + NumTombstones <= NumBuckets);
  443     assert(NumItems + NumTombstones <= NumBuckets);

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

   39       assert(!Key.empty());

  189     assert(Result && "Fell off the end of a string-switch");

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

  440     assert(isMacOSX() && "Not an OS X triple!");
  447     assert(Major == 10 && "Unexpected major version");
  664     assert(isAndroid() && "Not an Android triple!");

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

   70     assert(ID-1 < size() && "ID is 0 or out of range!");

  128     assert(getErrPtr() && "Cannot increment end iterator");
  144     assert(getErrPtr() && "Cannot decrement end iterator");
  171     assert(LHS.isValid() && RHS.isValid() &&

  313     assert(!empty() && "pop_front() on empty list!");
  317     assert(!empty() && "pop_back() on empty list!");

   58     assert(&Next != &First &&

  139     assert(!NodePtr->isKnownSentinel());

  197     assert(I != end() && "Cannot remove end of list!");

  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()!");

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

  155       assert(BPI != nullptr);

   26     assert(Fn != nullptr);
   27     assert(Result != nullptr);
   37     assert(Result != nullptr);

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

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

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

   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 &&

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

   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()) &&

  140     assert(!IntStack.empty() && "Attempting to use interval iterator at end!");
  201     assert(Int && "Null interval == bad!");
  202     assert(Node && "Null Node == bad!");

   28     assert(GD);
   51     assert(GD);

   51       assert(F && BPIPass && LI && "call setAnalysis");

   65         assert(F && LI && "call setAnalysis");

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

  151     assert(!Info.PImpl && "releaseMemory not called");

   56     assert(SubNum < getNumSubscripts() && "Invalid subscript number");
   60     assert(!Subscripts.empty() && "Expecting non-empty container");
   64     assert(!Subscripts.empty() && "Expecting non-empty container");

   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() &&

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

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

  118     assert(N < PassVector.size() && "Pass number out of range!");

  132     assert(Inst && "Def requires inst");
  136     assert(Inst && "Clobber requires inst");

  127     assert(hasValue() && "Getting value from an unknown LocationSize!");

  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() &&

  147     assert(ORE && "pass not run yet");

  224     assert(I.getType()->isPointerTy());

 1001   assert(!isSubRegion() && "This is not a BasicBlock RegionNode!");
 1009   assert(isSubRegion() && "This is not a subregion RegionNode!");

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

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

  118     assert(N < PassVector.size() && "Pass number out of range!");

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

  123         assert(SE->InsertPointGuards.back() == this);
  157       assert(InsertPointGuards.empty());
  241       assert(!CanonicalMode &&
  250       assert(!CanonicalMode &&
  276       assert(IP);

  160       assert(i < NumOperands && "Operand index out of range!");
  381       assert(isMinMaxType(T));
  668       assert(Result.second && "Should insert a new entry");

  132       assert(CustomNames.find(F) != CustomNames.end());
  299     assert(State == TargetLibraryInfoImpl::CustomName);

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

   75     assert(B1Idx != -1 && B2Idx != -1 && "Block is not in the trace!");

  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()) &&

  281       assert(Delta < Length);

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

  495     assert(isOrdinal() && "ILT entry is not an ordinal!");
  507     assert(!isOrdinal() && "ILT entry is not a Hint/Name RVA!");

   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)

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

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

  133     assert(canSkipToPos(ByteNo) && "Invalid location");
  159     assert(!(BitNo % 8) && "Expected bit on byte boundary");
  192     assert(NumBits && NumBits <= BitsInWord &&

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

  208   assert(Buckets.empty() && "Already finalized!");
  212   assert(Iter->second.Name == Name);

   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() &&

  150   Register getLocReg() const { assert(isRegLoc()); return Loc; }
  151   unsigned getLocMemOffset() const { assert(isMemLoc()); return Loc; }
  474     assert(InRegsParamRecordIndex < ByValRegs.size() &&

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

   47     assert(getMapEntry()->second.Symbol && "No symbol available!");
   53     assert(isIndexed());
   54     assert(getMapEntry()->getValue().isIndexed());

   77     assert(domain <

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

  213     assert(R == 0 && "Already initialized this value register!");
  214     assert(VirtReg2Value.empty());

   64       assert((Ty->isVoidTy() == (Regs.empty() || Regs[0] == 0)) &&
  268       assert(SwiftErrorVReg == 0 && "attempt to use unsupported swifterror");

   35     assert(((AllowIllegalOps || !LegalizeIllegalOps) || LInfo) &&

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

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

  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 &&

   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] &&

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

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

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

  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 &&

  203       assert(i < getNumOperands() && "Out of bound operand");
  431     assert(ID < getNumRegBanks() && "Accessing an unknown register bank");

   69       assert(NodeNum < (*SUnits).size());
   74       assert(NodeNum < NumNodesSolelyBlocking.size());

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

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

  186       assert(idx <  Size && "idx out of bounds");
  191       assert(Idx < Size && "Idx out of bounds");

  132       assert(!hasInterval(Reg) && "Interval already exists!");
  261       assert(unsigned(MBB->getNumber()) == RegMaskBlocks.size() &&

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

  151     assert(Parent && "No parent LiveInterval");

   66         assert(O->isUse() && "Reg operand not a def and not a use");

   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() &&

  224     assert(Removed && "Register is not used by this instruction!");
  259     assert(Removed && "Register is not defined by this instruction!");

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

  247     assert(Inserted &&

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

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

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

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

  138     assert(isValid() && "Cannot advance MIOperands beyond the last operand");

  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 "

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

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

  219     assert(ORE && "pass not run yet");

  139     assert(MBB->getParent()->getRegInfo().tracksLiveness() &&

  564     assert(it != InstrToCycle.end() && "Instruction hasn't been scheduled.");

  114   assert(!isSubRegion() && "This is not a MachineBasicBlock RegionNode!");
  123   assert(isSubRegion() && "This is not a subregion RegionNode!");

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

  871       assert(Best.Reason != NoCand && "uninitialized Sched candidate");

  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() &&

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

   37     assert(G.getNodeDegree(NId) == 1 &&
   81     assert(G.getNodeDegree(NId) == 2 &&
  198         assert(hasRegisterOptions(v) && "A conservatively allocatable node "

   47       assert(sItr != selections.end() && "No selection for node.");

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

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

  113     assert(Register::isPhysicalRegister(PhysReg));

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

   94       assert(NodeNum < (*SUnits).size());
   99       assert(NodeNum < NumNodesSolelyBlocking.size());

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

  389     assert((Addr == nullptr || Addr == &SUnits[0]) &&

  172     assert(SU->NodeNum < DFSNodeData.size() &&  "New Node");

   61       assert(Depth && !(Depth & (Depth - 1)) &&

  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() &&

  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 &&

  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() &&

   86     assert(Pos < MetaEnd && "Meta operand index out of range.");

  134       assert(getByValAlign() == A.value() && "bitfield overflow");
  143       assert(getOrigAlign() == A.value() && "bitfield overflow");
  186       assert(OrigArgIndex != NoArgIndex && "Implicit machine-level argument");

  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()) &&

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

   68     assert(!IsInstance && "Not a Pass ID");
   73     assert(IsInstance && "Not a Pass Instance");

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

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

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

  250       assert(CurrentOffset >= BeginOffset);

   88         assert(Result.first->second.getIndex() ==

   64     assert(!Mapping && "Already in a symbol mapping!");
   69     assert(Mapping && "Not in a symbol mapping!");

   68     assert(!Mapping && "Already in a type mapping!");
   78     assert(Mapping && "Not in a type mapping!");
  156     assert(Mapping.Reader.getOffset() == EndOffset);

   82     assert(H.size() == 8);

  118     assert(!isSimple());
  127     assert(isSimple());
  132     assert(isSimple());
  205     assert(Index >= N);
  252     assert(A.getIndex() >= N);
  259     assert(A >= B);

  586     assert(GuidStr.size() == 16 && "guid isn't 16 bytes");

   88     assert(Index < Frames.size());
   93     assert(Index < Frames.size());

   32       assert(isImplicitConst());
   36       assert(!isImplicitConst());
   74       assert(isImplicitConst());
  101     assert(idx < AttributeSpecs.size());
  110     assert(idx < AttributeSpecs.size());

  536       assert(CurrentName <= CurrentIndex->getNameCount());

   38     assert(valid() && RHS.valid());

   53       assert(AddressSize == 4 || AddressSize == 8);

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

  132     assert(AddressSize == 8 || AddressSize == 4 || AddressSize == 2);

  210   assert(*OffsetPtr == End &&

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

  162     assert(i < Lines.size());
  166     assert(i < Lines.size());

   90     assert(i < Ranges.size());

   55     assert(SB->FreeBlockMapBlock == 1 || SB->FreeBlockMapBlock == 2);
  134   assert(FpmNumber == 1 || FpmNumber == 2);

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

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

   50       assert(Head->Buf);
   59     assert(Head && Head->Buf);
   74     assert(Head && Head->Buf);
   93     assert(Head && Head->Buf);

   75     assert(!empty());
   80     assert(!empty());
   85     assert(!empty());

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

   40       assert(isPowerOf2_32(Alignment) && "Alignment must be power of 2");

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

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

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

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

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

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

  156     assert(NextId + 1 != ~0ULL && "All ids allocated");

  129       assert(Allocs.find(MB.base()) == Allocs.end() && "Duplicate alloc");
  153     assert(AddrOrErr && "Compile request failed");

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

 1037       assert(!PendingResponses.count(SeqNo) &&
 1137     assert(IdItr != LocalFunctionIds.end() &&
 1140     assert(HandlerItr != Handlers.end() &&
 1208     assert(PRHandler &&

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

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

  186     assert(!IRNames.empty() && "No IRNames received to Intern?");

  146   assert(Pool.empty() && "Dangling references at pool destruction time");

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

  246     assert(!Dyld && "setProcessAllSections must be called before loadObject.");

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

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

   45     assert(!isEmpty() && "Nothing selected");

   48     assert(Parent && "can't get number of unparented arg");

  758     assert((unsigned)A < Attribute::EndAttrKinds && "Attribute out of range!");

  317       assert(PN && "Cannot increment the end iterator!");
  439     assert((int)(signed char)getSubclassDataFromValue() >= 0 &&

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

   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 &&

  656     assert(isString() && "Not a string");
  663     assert(isCString() && "Isn't a C string");

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

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

  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(

  218     assert(!(ID & ~CallingConv::MaxID) && "Unsupported calling convention");
  719     assert (i < NumArgs && "getArg() out of range!");

  120       assert(isBoundedSequential());

   94     assert(getGlobalObjectSubClassData() == Val && "representation error");

  168     assert(V < (1 << GlobalValueSubClassDataBits) && "It will not fit");
  243     assert((!hasLocalLinkage() || V == DefaultVisibility) &&
  255     assert(Val == NotThreadLocal || getValueID() != Value::FunctionVal);

   79     assert(ptr != nullptr && "must not be nullptr");
  137     assert(hasInitializer() && "GV doesn't have initializer!");
  141     assert(hasInitializer() && "GV doesn't have initializer!");

  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()) &&

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

  287     assert(CS);

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

  765     assert((D & HasMetadataBit) == 0 && "Out of range value put into field");

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

  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()) &&

  126       assert(Kind == Argument || Kind == ExtendArgument ||
  135       assert(Kind == Argument || Kind == ExtendArgument ||
  146       assert(Kind == VecOfAnyPtrsToElt);
  150       assert(Kind == VecOfAnyPtrsToElt);

  389     assert ( 0 && "Invalid use of getPassManagerType");
  512     assert ( N < PassVector.size() && "Pass number out of range!");

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

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

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

  234         assert(NumElts != 0 && "Constant vector with no elements?");
  293         assert(NumElts != 0 && "Constant vector with no elements?");

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

   94     assert(MD == X.MD && "Expected values to match");

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

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

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

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

  272     assert(isa<KeySansPointerT>(new_key) &&

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

  328     assert((Size == 0 || !(Size & (Size - 1))) &&

   79     assert(column <= UINT16_MAX);
  131     assert(isInlinedCallSite());

  564       assert(I != MCDwarfLineTablesCUMap.end());

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

   95     assert(Kind < MaxTargetFixupKind && "Kind out of range!");
  158       assert(!IsPCRel && "Invalid pc-relative fixup size!");

  391     assert(isPowerOf2_64(PolicyMask) &&
  396     assert(isInstructionInitialized() && "Fragment has no instruction!");
  400     assert(isInstructionInitialized() && "Fragment has no instruction!");
  403     assert(InstInfo.InstFragment != nullptr &&

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

  107     assert(isGenericType() && "non-generic types don't have an index");
  117     assert(isGenericImm() && "non-generic immediates don't have an index");

   45     assert(Opcode < NumOpcodes && "Invalid opcode!");
   51     assert(Opcode < NumOpcodes && "Invalid opcode!");

  119     assert(isValidMCLOHType(Kind) && "Invalid LOH directive type!");

   74     assert(!CurTok.empty());
  111     assert(ReadCount == 1);

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

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

   53     assert(!isStackSlot(Reg) && "Not a register! Check isStackSlot() first.");

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

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

  115     assert(!Begin);

   60     assert((Characteristics & 0x00F00000) == 0 &&

   83     assert(isWasmData());
   87     assert(isWasmData());

   47     assert((ST == XCOFF::XTY_SD || ST == XCOFF::XTY_CM) &&

  417     assert(Section && "Cannot switch to a null section!");

  171     assert(DefIdx < SC->NumWriteLatencyEntries &&

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

  106     assert(Value == (Value & SF_DescFlagsMask) &&
  120         assert((1U << Log2Size) == Align && "Invalid 'common' alignment!");

   96     assert(GlobalType.hasValue());
  102     assert(EventType.hasValue());

   27     assert((!StorageClass.hasValue() || StorageClass.getValue() == SC) &&
   33     assert(StorageClass.hasValue() &&
   39     assert((!ContainingCsect || ContainingCsect == C) &&
   46     assert(ContainingCsect &&

  209     assert(!Feature.empty() && "Empty string");
  223     assert(!Feature.empty() && "Empty string");

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

  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() &&

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

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

   45     assert(hasNext() && "Already at end of sequence!");

   58     assert(!NextInSequence && "This stage already has a NextInSequence!");
   71     assert(checkNextStage(IR) && "Next stage is not ready!");

   59     assert(Denominator && "Invalid denominator (must be non-zero).");
  100   assert(Mask && "Processor Resource Mask cannot be zero!");

  105       assert(!Parent || !other.Parent || Parent == other.Parent);

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

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

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

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

  210     assert(isCommon());
  215     assert(isCommon());
  222     assert(isWeak() && isIndirect());

  112       assert(Storage.size() % Stride == 0);
  120       assert(Storage.size() >= sizeof(minidump::MemoryInfo));

  176     assert(isa<ObjectFile>(BasicSymbolRef::getObject()));
  293     assert(getSymbolFlags(Symb) & SymbolRef::SF_Common);
  424   assert(OwningObject == Other.OwningObject);

  131       assert(getKind() == LocationKind::Constant && "Not a small constant.");
  137       assert(getKind() == LocationKind::ConstantIndex &&
  144       assert((getKind() == LocationKind::Direct ||
  308     assert(StackMapSection[0] == 3 &&

  285     assert(!is64Bit() && "Symbol table handling not supported yet.");

   34     assert(S.size() == 8 && "Invalid hash size!");
   37     assert(S.size() == 8 && "Invalid hash size!");

   78     assert(id > 0 && id - 1 < getNumOptions() && "Invalid Option ID.");

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

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

   97     assert((!isAnalysisGroup() || NormalCtor) &&
   99     assert(NormalCtor &&

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

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

  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

  304     assert(Err != instrprof_error::success && "Not an error");
  322       assert(Err == instrprof_error::success && "Multiple errors encountered");
  357     assert(FirstError == instrprof_error::success &&

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

  520       assert(false && "internal error: unknown suffix elision policy");
  535     assert(GUIDToFuncNameMap && "GUIDToFuncNameMap needs to be popluated first");

  249     assert(Remappings && "Remappings cannot be nullptr");

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