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

References

   54         return buildConstant(Dst, MaybeCst->getSExtValue());
   65         return buildConstant(Dst, MaybeCst->getSExtValue());

  130       return A ? A->value() : 0;
  139       return A ? A->value() : 0;

  421       return RngListTable->getOffsetEntry(Index);

  595             return CallbackManager->executeCompileCallback(Addr);

  506       MDChecksum.emplace(CS->Kind, getCanonicalMDString(Context, CS->Value));
  506       MDChecksum.emplace(CS->Kind, getCanonicalMDString(Context, CS->Value));

   77     return Align ? Align->value() : 0;

  192     if (Stream->size() >= sizeof(T))
  193       return *reinterpret_cast<const T *>(Stream->data());

  236 inline unsigned encode(MaybeAlign A) { return A ? A->ShiftValue + 1 : 0; }

  400             Graph.addNode(IRelation->From);
  401             Graph.addNode(IRelation->To);
  402             Graph.addEdge(IRelation->From, IRelation->To);
  402             Graph.addEdge(IRelation->From, IRelation->To);
  410             Graph.addNode(IAttr->IValue, IAttr->Attr);
  410             Graph.addNode(IAttr->IValue, IAttr->Attr);

  168       AddToRetParamRelations(0, RetInfo->Index);
  177         AddToRetParamRelations(I + 1, ParamInfo->Index);

  182               InnerPA->abandon(InnerAnalysisID);
  286             FunctionPA->abandon(InnerAnalysisID);

   77   DB->print(OS);

  107               addEdge(Edges->Edges, Edges->EdgeIndexMap, G->get(*Callee),
  107               addEdge(Edges->Edges, Edges->EdgeIndexMap, G->get(*Callee),
  121     addEdge(Edges->Edges, Edges->EdgeIndexMap, G->get(F),
  121     addEdge(Edges->Edges, Edges->EdgeIndexMap, G->get(F),
  129       addEdge(Edges->Edges, Edges->EdgeIndexMap, G->get(*F),
  129       addEdge(Edges->Edges, Edges->EdgeIndexMap, G->get(*F),

   42     const APInt APBaseAlign(Offset.getBitWidth(), BA->value());

  109             InnerPA->abandon(InnerAnalysisID);

  670   if (FnData->AllocTy == StrDupLike) {
  676     if (FnData->FstParam > 0) {
  678           dyn_cast<ConstantInt>(CS.getArgument(FnData->FstParam));
  689   ConstantInt *Arg = dyn_cast<ConstantInt>(CS.getArgument(FnData->FstParam));
  698   if (FnData->SndParam < 0)
  701   Arg = dyn_cast<ConstantInt>(CS.getArgument(FnData->SndParam));
  935   if (FnData->AllocTy == StrDupLike) {
  940   Value *FirstArg = CS.getArgument(FnData->FstParam);
  942   if (FnData->SndParam < 0)
  945   Value *SecondArg = CS.getArgument(FnData->SndParam);

  813         auto Iter = find_if(def_path(Blocker->LastNode), [&](const DefPath &N) {

 4970   if (BO->Opcode != Instruction::Add)
 4974   if (BO->LHS == PN && L->isLoopInvariant(BO->RHS))
 4974   if (BO->LHS == PN && L->isLoopInvariant(BO->RHS))
 4975     Accum = getSCEV(BO->RHS);
 4976   else if (BO->RHS == PN && L->isLoopInvariant(BO->LHS))
 4976   else if (BO->RHS == PN && L->isLoopInvariant(BO->LHS))
 4977     Accum = getSCEV(BO->LHS);
 4983   if (BO->IsNUW)
 4985   if (BO->IsNSW)
 5080           if (BO->Opcode == Instruction::Add && BO->LHS == PN) {
 5080           if (BO->Opcode == Instruction::Add && BO->LHS == PN) {
 5081             if (BO->IsNUW)
 5083             if (BO->IsNSW)
 6156     switch (BO->Opcode) {
 6166         if (BO->Op) {
 6167           if (auto *OpSCEV = getExistingSCEV(BO->Op)) {
 6179           const SCEV *RHS = getSCEV(BO->RHS);
 6180           SCEV::NoWrapFlags Flags = getNoWrapFlagsFromUB(BO->Op);
 6182             const SCEV *LHS = getSCEV(BO->LHS);
 6183             if (BO->Opcode == Instruction::Sub)
 6191         if (BO->Opcode == Instruction::Sub)
 6192           AddOps.push_back(getNegativeSCEV(getSCEV(BO->RHS)));
 6194           AddOps.push_back(getSCEV(BO->RHS));
 6196         auto NewBO = MatchBinaryOp(BO->LHS, DT);
 6197         if (!NewBO || (NewBO->Opcode != Instruction::Add &&
 6198                        NewBO->Opcode != Instruction::Sub)) {
 6199           AddOps.push_back(getSCEV(BO->LHS));
 6211         if (BO->Op) {
 6212           if (auto *OpSCEV = getExistingSCEV(BO->Op)) {
 6217           SCEV::NoWrapFlags Flags = getNoWrapFlagsFromUB(BO->Op);
 6220                 getMulExpr(getSCEV(BO->LHS), getSCEV(BO->RHS), Flags));
 6220                 getMulExpr(getSCEV(BO->LHS), getSCEV(BO->RHS), Flags));
 6225         MulOps.push_back(getSCEV(BO->RHS));
 6226         auto NewBO = MatchBinaryOp(BO->LHS, DT);
 6227         if (!NewBO || NewBO->Opcode != Instruction::Mul) {
 6228           MulOps.push_back(getSCEV(BO->LHS));
 6237       return getUDivExpr(getSCEV(BO->LHS), getSCEV(BO->RHS));
 6237       return getUDivExpr(getSCEV(BO->LHS), getSCEV(BO->RHS));
 6239       return getURemExpr(getSCEV(BO->LHS), getSCEV(BO->RHS));
 6239       return getURemExpr(getSCEV(BO->LHS), getSCEV(BO->RHS));
 6242       if (BO->Op)
 6243         Flags = getNoWrapFlagsFromUB(BO->Op);
 6244       return getMinusSCEV(getSCEV(BO->LHS), getSCEV(BO->RHS), Flags);
 6244       return getMinusSCEV(getSCEV(BO->LHS), getSCEV(BO->RHS), Flags);
 6249       if (ConstantInt *CI = dyn_cast<ConstantInt>(BO->RHS)) {
 6251           return getSCEV(BO->RHS);
 6253           return getSCEV(BO->LHS);
 6264         computeKnownBits(BO->LHS, Known, getDataLayout(),
 6271           const SCEV *LHS = getSCEV(BO->LHS);
 6292                   BO->LHS->getType()),
 6305       if (ConstantInt *CI = dyn_cast<ConstantInt>(BO->RHS)) {
 6306         const SCEV *LHS = getSCEV(BO->LHS);
 6325       if (ConstantInt *CI = dyn_cast<ConstantInt>(BO->RHS)) {
 6328           return getNotSCEV(getSCEV(BO->LHS));
 6334         if (auto *LBO = dyn_cast<BinaryOperator>(BO->LHS))
 6339                       dyn_cast<SCEVZeroExtendExpr>(getSCEV(BO->LHS))) {
 6340                 Type *UTy = BO->LHS->getType();
 6365       if (ConstantInt *SA = dyn_cast<ConstantInt>(BO->RHS)) {
 6382         if (BO->Op && SA->getValue().ult(BitWidth - 1))
 6383           Flags = getNoWrapFlagsFromUB(BO->Op);
 6387         return getMulExpr(getSCEV(BO->LHS), getSCEV(X), Flags);
 6393       ConstantInt *CI = dyn_cast<ConstantInt>(BO->RHS);
 6397       Type *OuterTy = BO->LHS->getType();
 6407         return getSCEV(BO->LHS); // shift by zero --> noop
 6412       Operator *L = dyn_cast<Operator>(BO->LHS);
 6419         if (L->getOperand(1) == BO->RHS)
 6462       if (BO->Opcode == Instruction::Sub && BO->IsNSW) {
 6462       if (BO->Opcode == Instruction::Sub && BO->IsNSW) {
 6464         auto *V1 = getSignExtendExpr(getSCEV(BO->LHS), Ty);
 6465         auto *V2 = getSignExtendExpr(getSCEV(BO->RHS), Ty);
 8497     unsigned W = std::max(X->getBitWidth(), Y->getBitWidth());
 8497     unsigned W = std::max(X->getBitWidth(), Y->getBitWidth());
 8498     APInt XW = X->sextOrSelf(W);
 8499     APInt YW = Y->sextOrSelf(W);
 8521   unsigned W = X->getBitWidth();
 8522   if (BitWidth > 1 && BitWidth < W && X->isIntN(BitWidth))
 8523     return X->trunc(BitWidth);
 9986   if (LDiff->isMinValue())
12196     for (auto *P : PredicatedRewrite->second){
12206     return PredicatedRewrite->first;

  935   ShuffleVectorInst *LS = dyn_cast<ShuffleVectorInst>(RD->LHS);
  938   ShuffleVectorInst *RS = dyn_cast<ShuffleVectorInst>(RD->RHS);
  963     if (NextLevelOpL && NextLevelOpL != RD->RHS)
  965     else if (NextLevelOpR && NextLevelOpR != RD->LHS)
  968     NextLevelOp = NextLevelOpL ? RD->RHS : RD->LHS;
  968     NextLevelOp = NextLevelOpL ? RD->RHS : RD->LHS;
  977     if (!NextLevelRD || !RD->hasSameData(*NextLevelRD))
  993     return RD->Kind;
 1047   Opcode = RD->Opcode;
 1050   return RD->Kind;
 1110     if (!RDLevel || !RDLevel->hasSameData(*RD))
 1116         getShuffleAndOtherOprd(RDLevel->LHS, RDLevel->RHS);
 1116         getShuffleAndOtherOprd(RDLevel->LHS, RDLevel->RHS);
 1139   Opcode = RD->Opcode;
 1141   return RD->Kind;

  479       O->OS << "<BITCODE_WRAPPER_HEADER"
  619     O.OS << "of " << Filename->data() << ":\n";
  739       O->OS << Indent << "<BLOCKINFO_BLOCK/>\n";
  765     O->OS << Indent << "<";
  767       O->OS << *BlockName;
  769       O->OS << "UnknownBlock" << BlockID;
  771     if (!O->Symbolic && BlockName)
  772       O->OS << " BlockID=" << BlockID;
  774     O->OS << " NumWords=" << NumWords
  803         O->OS << Indent << "</";
  805           O->OS << *BlockName << ">\n";
  807           O->OS << "UnknownBlock" << BlockID << ">\n";
  858       O->OS << Indent << "  <";
  862         O->OS << *CodeName;
  864         O->OS << "UnknownCode" << Code;
  865       if (!O->Symbolic && CodeName)
  866         O->OS << " codeid=" << Code;
  870         O->OS << " abbrevid=" << Entry.ID;
  874         O->OS << " op" << i << "=" << (int64_t)Record[i];
  881             O->OS << "(Invalid record)";
  888           O->OS << " (offset ";
  890             O->OS << "match)";
  892             O->OS << "mismatch: " << MetadataIndexOffset << " vs "
  901           O->OS << " (invalid)";
  924             O->OS << " (match)";
  926             O->OS << " (!mismatch!)";
  930       O->OS << "/>";
  948             O->OS << " record string = '" << Str << "'";
  955           if (Error E = decodeMetadataStringsBlob(Indent, Record, Blob, O->OS))
  958           O->OS << " blob data = ";
  959           if (O->ShowBinaryBlobs) {
  960             O->OS << "'";
  961             O->OS.write_escaped(Blob, /*hex=*/true) << "'";
  971               O->OS << "'" << Blob << "'";
  973               O->OS << "unprintable, " << Blob.size() << " bytes.";
  978       O->OS << "\n";

  635     return MDLoader->getMetadataFwdRefOrLoad(ID);
 2918     if (Error Err = MDLoader->parseModuleMetadata())
 2969     MDLoader->upgradeDebugIntrinsics(F);
 3479         if (Error Err = MDLoader->parseModuleMetadata())
 3483         if (Error Err = MDLoader->parseMetadataKinds())
 3699   if (MDLoader->hasFwdRefs())
 3704   unsigned ModuleMDLoaderSize = MDLoader->size();
 3761         if (Error Err = MDLoader->parseMetadataAttachment(*F, InstructionList))
 3767         if (Error Err = MDLoader->parseFunctionMetadata())
 3850             MDLoader->getMetadataFwdRefOrLoad(ScopeID - 1));
 3856             MDLoader->getMetadataFwdRefOrLoad(IAID - 1));
 5181   if (MDLoader->hasFwdRefs())
 5186   MDLoader->shrinkTo(ModuleMDLoaderSize);
 5268   if (DISubprogram *SP = MDLoader->lookupSubprogramForFunction(F))
 5272   if (!MDLoader->isStrippingTBAA()) {
 5277       MDLoader->setStripTBAA(true);

 1623     Record.push_back(N->getRawChecksum()->Kind);
 1624     Record.push_back(VE.getMetadataOrNullID(N->getRawChecksum()->Value));

 1365     assert(!Filename->empty() && "The filename can't be empty.");

  247       std::string Checksum = fromHex(F->getChecksum()->Value);
  252       switch (F->getChecksum()->Kind) {
 1237         Location->LoadChain.pop_back();
 1250     if (Location->Register == 0 || Location->LoadChain.size() > 1)
 1250     if (Location->Register == 0 || Location->LoadChain.size() > 1)
 1254       DR.CVRegister = TRI->getCodeViewRegNum(Location->Register);
 1255       DR.InMemory = !Location->LoadChain.empty();
 1257           !Location->LoadChain.empty() ? Location->LoadChain.back() : 0;
 1257           !Location->LoadChain.empty() ? Location->LoadChain.back() : 0;
 1258       if (Location->FragmentInfo) {
 1260         DR.StructOffset = Location->FragmentInfo->OffsetInBits / 8;
 1260         DR.StructOffset = Location->FragmentInfo->OffsetInBits / 8;

  178   return A.getExpression()->getFragmentInfo()->OffsetInBits <
  179          B.getExpression()->getFragmentInfo()->OffsetInBits;

  279                return A.Expr->getFragmentInfo()->OffsetInBits <
  280                       B.Expr->getFragmentInfo()->OffsetInBits;
  648       if (ParamValue->first.isImm()) {
  649         int64_t Val = ParamValue->first.getImm();
  650         DbgValueLoc DbgLocVal(ParamValue->second, Val);
  652       } else if (ParamValue->first.isReg()) {
  653         Register RegLoc = ParamValue->first.getReg();
  658           DbgValueLoc DbgLocVal(ParamValue->second,
  915         return FragmentA->OffsetInBits < FragmentB->OffsetInBits;
  915         return FragmentA->OffsetInBits < FragmentB->OffsetInBits;

  225   if (!addMachineReg(TRI, MachineReg, Fragment ? Fragment->SizeInBits : ~1U)) {
  232   if (Op && Op->getOp() != dwarf::DW_OP_LLVM_fragment)
  285   if (Op && (Op->getOp() == dwarf::DW_OP_plus_uconst)) {
  286     uint64_t Offset = Op->getArg(0);
  297   if (Op && Op->getOp() == dwarf::DW_OP_constu) {
  298     uint64_t Offset = Op->getArg(0);
  301     if (N && N->getOp() == dwarf::DW_OP_plus && Offset <= IntMax) {
  304     } else if (N && N->getOp() == dwarf::DW_OP_minus &&
  323   assert(Op && Op->getOp() == dwarf::DW_OP_LLVM_entry_value);
  327   assert(Op->getArg(0) == 1 &&
  353     switch (Op->getOp()) {
  369   if (SubRegisterSizeInBits && N && (N->getOp() != dwarf::DW_OP_LLVM_fragment))
  376     uint64_t OpNum = Op->getOp();
  382       addBReg(OpNum - dwarf::DW_OP_breg0, Op->getArg(0));
  388       unsigned SizeInBits = Op->getArg(1);
  389       unsigned FragmentOffset = Op->getArg(0);
  419       emitUnsigned(Op->getArg(0));
  451       emitConstu(Op->getArg(0));
  454       unsigned BitSize = Op->getArg(0);
  455       dwarf::TypeKind Encoding = static_cast<dwarf::TypeKind>(Op->getArg(1));
  477         if (PrevConvertOp && PrevConvertOp->getArg(0) < BitSize) {
  479             emitLegacySExt(PrevConvertOp->getArg(0));
  481             emitLegacyZExt(PrevConvertOp->getArg(0));
  502       emitData1(Op->getArg(0));
  505       TagOffset = Op->getArg(0);
  509       emitUnsigned(Op->getArg(0));
  513       emitUnsigned(Op->getArg(0));
  514       emitSigned(Op->getArg(1));
  550   uint64_t FragmentOffset = Expr->getFragmentInfo()->OffsetInBits;

  316   if (!Checksum || Checksum->Kind != DIFile::CSK_MD5)
  322   std::string ChecksumString = fromHex(Checksum->Value);

  162       return buildConstant(DstOps[0], Cst->getSExtValue());
  173       return buildConstant(Dst, MaybeCst->getSExtValue());

  896     unsigned KnownVal = ValVRegAndVal->Value;
  944   bool IsZeroVal = ValVRegAndVal && ValVRegAndVal->Value == 0;
 1279   unsigned KnownLen = LenVRegAndVal->Value;

 1663         MachinePointerInfo(Info.ptrVal), Info.flags, Size, Align->value()));

   53       return VRegVal->Value == Value;

  211   assert((!ValAndVReg || ValAndVReg->VReg == VReg) &&
  215   return ValAndVReg->Value;

 6350     if (LHS->isConstantZero())
 6352     if (RHS->isConstantZero())
 6555     else if (!Base->equalBaseIndex(Ptr, DAG, ByteOffsetFromBase))
 6689     if (!P || !P->isMemory()) // All the bytes must be loaded from memory
 6692     LoadSDNode *L = P->Load;
 6710     else if (!Base->equalBaseIndex(Ptr, DAG, ByteOffsetFromBase))
 6742   LoadSDNode *FirstLoad = FirstByteProvider->Load;

 8056         if (OffsetInBits + SizeInBits > FI->SizeInBits)

 1331           BitsToDescribe = Fragment->SizeInBits;
 4830         Info.align ? Info.align->value() : 0, Info.flags, Info.size, AAInfo);
 5576   IsIndirect = (Op->isReg()) ? IsIndirect : true;
 7153     Value *V = Bundle->Inputs[0];

  949           FuncletBundleOperand = BU->Inputs.front();

  167     CR->IndexRef = RefersTo->getIndex();

   78           ++FixedAttributeSize->NumAddrs;
   83           ++FixedAttributeSize->NumRefAddrs;
   93           ++FixedAttributeSize->NumDwarfOffsets;
  101             FixedAttributeSize->NumBytes += *ByteSize;

  152   switch (Value->getForm()) {
  158     return Value->getRawUValue() + DIEOffsetBase;
  160     return Value->getAsSectionOffset();
  299   if (Optional<uint64_t> Value = Tag->getAsUnsignedConstant())
  543     return Off->getAsReferenceUVal();
  549     return Off->getAsUnsignedConstant();

  150     dwarf::DwarfFormat Format = Contribution->getFormat();
  151     uint16_t Version = Contribution->getVersion();
  152     uint64_t ContributionHeader = Contribution->Base;
  177     OS << "Contribution size = " << (Contribution->Size + (Version < 5 ? 0 : 4))
  181     Offset = Contribution->Base;
  182     unsigned EntrySize = Contribution->getDwarfOffsetByteSize();
  183     while (Offset - Contribution->Base < Contribution->Size) {
  183     while (Offset - Contribution->Base < Contribution->Size) {
  975     if (Optional<uint64_t> Size = SizeAttr->getAsUnsignedConstant())
 1011                 ElemCountAttr->getAsUnsignedConstant())
 1015                 UpperBoundAttr->getAsSignedConstant()) {
 1018             LowerBound = LowerBoundAttr->getAsSignedConstant().getValueOr(0);
 1036       if (Optional<const char *> Name = NameAttr->getAsCString())
 1039       if (Optional<ArrayRef<uint8_t>> Location = LocationAttr->getAsBlock())
 1040         if (!Location->empty() && (*Location)[0] == DW_OP_fbreg)
 1042               decodeSLEB128(Location->data() + 1, nullptr, Location->end());
 1042               decodeSLEB128(Location->data() + 1, nullptr, Location->end());
 1044       Local.TagOffset = TagOffsetAttr->getAsUnsignedConstant();
 1050       if (Optional<const char *> Name = NameAttr->getAsCString())
 1057             DeclFileAttr->getAsUnsignedConstant().getValue(),
 1063       Local.DeclLine = DeclLineAttr->getAsUnsignedConstant().getValue();

   27     *SecNdx = E->SectionIndex;
   28   uint64_t R = E->Resolver(E->Reloc, E->SymbolValue, A);
   28   uint64_t R = E->Resolver(E->Reloc, E->SymbolValue, A);
   28   uint64_t R = E->Resolver(E->Reloc, E->SymbolValue, A);
   29   if (E->Reloc2)
   30     R = E->Resolver(*E->Reloc2, E->SymbolValue2, R);
   30     R = E->Resolver(*E->Reloc2, E->SymbolValue2, R);
   30     R = E->Resolver(*E->Reloc2, E->SymbolValue2, R);

   87   while (Data->isValidOffset(Offset)) {
  126   if (Data && CUAbbrOffset < Data->getData().size()) {

   87       E.LowPC += BaseAddr->Address;
   88       E.HighPC += BaseAddr->Address;
   90         E.SectionIndex = BaseAddr->SectionIndex;

  135       E.SectionIndex = BaseAddr->SectionIndex;
  142         E.LowPC += BaseAddr->Address;
  143         E.HighPC += BaseAddr->Address;
  158       E.SectionIndex = Start->SectionIndex;
  159       E.LowPC = Start->Address;
  206       CurrentBase = SA->Address;
  237       Start = SA->Address;

   99         BaseAddr = BA->Address;
  156         LB = L->getAsUnsignedConstant();
  158         Count = CountV->getAsUnsignedConstant();
  160         UB = UpperV->getAsUnsignedConstant();
  163         if (Optional<uint64_t> LC = LV->getAsUnsignedConstant())
  432     if (SpecRef->Unit)
  433       return SpecRef->Unit->getDIEForOffset(SpecRef->Unit->getOffset() + SpecRef->Offset);
  433       return SpecRef->Unit->getDIEForOffset(SpecRef->Unit->getOffset() + SpecRef->Offset);
  433       return SpecRef->Unit->getDIEForOffset(SpecRef->Unit->getOffset() + SpecRef->Offset);
  434     if (auto SpecUnit = U->getUnitVector().getUnitForOffset(SpecRef->Offset))
  435       return SpecUnit->getDIEForOffset(SpecRef->Offset);
  446     if (auto Address = FormValue->getAsAddress()) {
  450     if (auto Offset = FormValue->getAsUnsignedConstant()) {
  464   if (auto HighPcAddr = getHighPC(LowPcAddr->Address)) {
  465     LowPC = LowPcAddr->Address;
  467     SectionIndex = LowPcAddr->SectionIndex;
  483     if (Value->getForm() == DW_FORM_rnglistx)
  484       return U->findRnglistFromIndex(*Value->getAsSectionOffset());
  485     return U->findRnglistFromOffset(*Value->getAsSectionOffset());

  267           OS << " \"" << Name->getAsCString() << "\"";

  624     return SA->Address;
  646     return R->Unit ? R->Unit->getOffset() + R->Offset : R->Offset;
  646     return R->Unit ? R->Unit->getOffset() + R->Offset : R->Offset;
  646     return R->Unit ? R->Unit->getOffset() + R->Offset : R->Offset;
  646     return R->Unit ? R->Unit->getOffset() + R->Offset : R->Offset;

  486         RangeSectionBase = RngListTable->getHeaderSize();
  538       DWO->RangeSectionBase = DWO->RngListTable->getHeaderSize();
  564                                   isLittleEndian, RngListTable->getAddrSize());
  565     auto RangeListOrError = RngListTable->findList(RangesData, Offset);

 1296   if (Optional<ArrayRef<uint8_t>> Expr = Location->getAsBlock()) {
 1300   } else if (Optional<uint64_t> Offset = Location->getAsSectionOffset()) {

   81   NewFpoData->addFrameData(FD);
   94   DbgStreams[(int)Type]->Size = Data.size();
   95   DbgStreams[(int)Type]->WriteFn = [Data](BinaryStreamWriter &Writer) {
  294     DbgStreams[(int)DbgHeaderType::NewFPO]->Size =
  295         NewFpoData->calculateSerializedSize();
  296     DbgStreams[(int)DbgHeaderType::NewFPO]->WriteFn =
  298           return NewFpoData->commit(Writer);
  304     DbgStreams[(int)DbgHeaderType::FPO]->Size =
  306     DbgStreams[(int)DbgHeaderType::FPO]->WriteFn =
  315     auto ExpectedIndex = Msf.addStream(S->Size);
  318     S->StreamNumber = *ExpectedIndex;
  433       StreamNumber = Stream->StreamNumber;
  441     assert(Stream->StreamNumber != kInvalidStreamIndex);
  444         Layout, MsfBuffer, Stream->StreamNumber, Allocator);
  447     if (auto EC = Stream->WriteFn(DbgStreamWriter))

  110       assert((!Name || !Name->empty()) && "Name must be none or non-empty");

  351           OptionalChild->getAsBinary();

  269   if (GVsToExtract->empty()) {
  301           return GVsToExtract->count(&GV);

  267     auto ChildBuffer = (*Child)->getMemoryBufferRef();

   67     return S.CreateObjectLinkingLayer(ES, S.JTMB->getTargetTriple());
   75   if (S.JTMB->getTargetTriple().isOSBinFormatCOFF())
  113   if (auto DLOrErr = S.JTMB->getDefaultDataLayoutForTarget())
  172   TT = JTMB->getTargetTriple();

  402             OptionalChild->getAsBinary();

  130   for (const auto &Pred : makeArrayRef(OpDesc->SourcePreds).slice(1))
  133   if (Value *Op = OpDesc->BuilderFunc(Srcs, Insts[IP])) {

  925     *Len = Src->size();
  926     return Src->data();

  464   return Context.pImpl->DITypeMap->lookup(&Identifier);
  505   assert((!CS || isCanonical(CS->Value)) && "Expected canonical MDString");
  508   Metadata *Ops[] = {Filename, Directory, CS ? CS->Value : nullptr,

 1255     assert(getAlignment() == Align->value() &&
 1346     assert(getAlignment() == Align->value() &&
 1425     assert(getAlignment() == Align->value() &&
 3906   assert(SI.getNumSuccessors() == Weights->size() &&
 3940     assert(SI.getNumSuccessors() == Weights->size() &&
 3966     assert(SI.getNumSuccessors() == Weights->size() &&
 3975     Weights->resize(0);

   55     return Fragment->SizeInBits;

   71             FunctionPA->abandon(InnerAnalysisID);

   35       Filename(FilenameIn ? Optional<std::string>(FilenameIn->str()) : None) {}
  105     if (!Filter->match(Diag.getPassName()))

 1028     AssertDI(Checksum->Kind <= DIFile::ChecksumKind::CSK_Last,
 1031     switch (Checksum->Kind) {
 1039     AssertDI(Checksum->Value.size() == Size, "invalid checksum length", &N);
 1040     AssertDI(Checksum->Value.find_if_not(llvm::isHexDigit) == StringRef::npos,
 3630         FromPad = Bundle->Inputs[0];
 5310         !PrevOffset || PrevOffset->ule(OffsetEntryCI->getValue());

 1234     OS << " md5 0x" << Checksum->digest();

  257     LineStr->emitSection(MCOS);
  357     LineStr->emitRef(MCOS, DwarfFile.Name);
  371       LineStr->emitRef(MCOS, DwarfFile.Source.getValueOr(StringRef()));
  396     LineStr->emitRef(MCOS, CompDir);
  398       LineStr->emitRef(MCOS, Dir);

  426   Expected<StringRef> PltContents = Plt->getContents();
  431   auto PltEntries = MIA->findPltEntries(Plt->getAddress(),
  433                                         GotPlt->getAddress(), Triple);
  441   for (const auto &Relocation : RelaPlt->relocations()) {

   89   if (ListOffset + sizeof(T) * ListSize < Stream->size())

   56     return Obj.OptionalHeader->Header.FileAlignment;
  352   Header->SectionAlignment = CP.Obj.OptionalHeader->Header.SectionAlignment;
  353   Header->FileAlignment = CP.Obj.OptionalHeader->Header.FileAlignment;
  378       CP.Obj.OptionalHeader->Header.AddressOfEntryPoint; // RVA
  379   Header->ImageBase = CP.Obj.OptionalHeader->Header.ImageBase;
  381       CP.Obj.OptionalHeader->Header.MajorOperatingSystemVersion;
  383       CP.Obj.OptionalHeader->Header.MinorOperatingSystemVersion;
  384   Header->MajorImageVersion = CP.Obj.OptionalHeader->Header.MajorImageVersion;
  385   Header->MinorImageVersion = CP.Obj.OptionalHeader->Header.MinorImageVersion;
  387       CP.Obj.OptionalHeader->Header.MajorSubsystemVersion;
  389       CP.Obj.OptionalHeader->Header.MinorSubsystemVersion;
  392   Header->Subsystem = CP.Obj.OptionalHeader->Header.Subsystem;
  393   Header->DLLCharacteristics = CP.Obj.OptionalHeader->Header.DLLCharacteristics;
  394   Header->SizeOfStackReserve = CP.Obj.OptionalHeader->Header.SizeOfStackReserve;
  395   Header->SizeOfStackCommit = CP.Obj.OptionalHeader->Header.SizeOfStackCommit;
  396   Header->SizeOfHeapReserve = CP.Obj.OptionalHeader->Header.SizeOfHeapReserve;
  397   Header->SizeOfHeapCommit = CP.Obj.OptionalHeader->Header.SizeOfHeapCommit;
  460          CP.Obj.OptionalHeader->DataDirectories) {

  296   if (Section.content && Section.size < Section.content->binary_size())

  428   if (PGOOpt && PGOOpt->Action == PGOOptions::IRUse &&
  472        PGOOpt->Action != PGOOptions::SampleUse) &&
  541       (PGOOpt->Action == PGOOptions::IRUse ||
  542        PGOOpt->Action == PGOOptions::SampleUse))
  657   bool HasSampleProfile = PGOOpt && (PGOOpt->Action == PGOOptions::SampleUse);
  710     MPM.addPass(SampleProfileLoaderPass(PGOOpt->ProfileFile,
  711                                         PGOOpt->ProfileRemappingFile,
  762       (PGOOpt->Action == PGOOptions::IRInstr ||
  763        PGOOpt->Action == PGOOptions::IRUse)) {
  765                       /* RunProfileGen */ PGOOpt->Action == PGOOptions::IRInstr,
  766                       /* IsCS */ false, PGOOpt->ProfileFile,
  767                       PGOOpt->ProfileRemappingFile);
  771       PGOOpt->CSAction == PGOOptions::CSIRInstr)
  772     MPM.addPass(PGOInstrumentationGenCreateVar(PGOOpt->CSProfileGenFile));
  804       PGOOpt->Action == PGOOptions::SampleUse)
  874     if (PGOOpt->CSAction == PGOOptions::CSIRInstr)
  876                         /* IsCS */ true, PGOOpt->CSProfileGenFile,
  877                         PGOOpt->ProfileRemappingFile);
  878     else if (PGOOpt->CSAction == PGOOptions::CSIRUse)
  880                         /* IsCS */ true, PGOOpt->ProfileFile,
  881                         PGOOpt->ProfileRemappingFile);
 1035   if (PGOOpt && PGOOpt->SamplePGOSupport)
 1058   if (PGOOpt && PGOOpt->SamplePGOSupport)
 1150   if (PGOOpt && PGOOpt->Action == PGOOptions::SampleUse) {
 1152     MPM.addPass(SampleProfileLoaderPass(PGOOpt->ProfileFile,
 1153                                         PGOOpt->ProfileRemappingFile,
 1181         true /* InLTO */, PGOOpt && PGOOpt->Action == PGOOptions::SampleUse));
 1266     if (PGOOpt->CSAction == PGOOptions::CSIRInstr)
 1268                         /* IsCS */ true, PGOOpt->CSProfileGenFile,
 1269                         PGOOpt->ProfileRemappingFile);
 1270     else if (PGOOpt->CSAction == PGOOptions::CSIRUse)
 1272                         /* IsCS */ true, PGOOpt->ProfileFile,
 1273                         PGOOpt->ProfileRemappingFile);
 1879           (PGOOpt->Action == PGOOptions::IRInstr ||
 1880            PGOOpt->Action == PGOOptions::IRUse))
 1883             /* RunProfileGen */ (PGOOpt->Action == PGOOptions::IRInstr),
 1884             /* IsCS */ false, PGOOpt->ProfileFile,
 1885             PGOOpt->ProfileRemappingFile);
 2262   if (!Pipeline || Pipeline->empty())
 2269   StringRef FirstName = Pipeline->front().Name;
 2285       auto &InnerPipeline = Pipeline->front().InnerPipeline;
 2305   if (!Pipeline || Pipeline->empty())
 2310   StringRef FirstName = Pipeline->front().Name;
 2330   if (!Pipeline || Pipeline->empty())
 2335   StringRef FirstName = Pipeline->front().Name;
 2354   if (!Pipeline || Pipeline->empty())

  109       printIR(UnwrappedModule->first, Banner, UnwrappedModule->second);
  109       printIR(UnwrappedModule->first, Banner, UnwrappedModule->second);

  549     R.Loc->SourceFilePath = *SourceFileName;
  550     R.Loc->SourceLine = *Helper.SourceLine;
  551     R.Loc->SourceColumn = *Helper.SourceColumn;
  588         R.Args.back().Loc->SourceFilePath = *SourceFileName;
  589         R.Args.back().Loc->SourceLine = *Arg.SourceLine;
  590         R.Args.back().Loc->SourceColumn = *Arg.SourceColumn;

   47     Impl(R.Loc->SourceFilePath);
   52       Impl(Arg.Loc->SourceFilePath);

  100   if (Path->empty())

  970   if (!VRegAndVal || VRegAndVal->Value != 0) {
 2890   unsigned LaneIdx = VRegAndVal->Value;
 3209                    AArch64_AM::isLogicalImmediate(ValAndVReg->Value, RegSize);
 3215         AArch64_AM::encodeLogicalImmediate(ValAndVReg->Value, RegSize));
 3508     if (!ValAndVReg || ValAndVReg->Value != 0)
 3557     if (!ValAndVReg || ValAndVReg->Value != 0)
 3795   unsigned LaneIdx = VRegAndVal->Value;
 4029     Immed = ValAndVReg->Value;
 4238   int64_t ImmVal = ValAndVReg->Value;

  827       return ShiftedVal->first >= 0 && ShiftedVal->first <= 0xfff;
  827       return ShiftedVal->first >= 0 && ShiftedVal->first <= 0xfff;
  840       return ShiftedVal->first < 0 && -ShiftedVal->first <= 0xfff;
  840       return ShiftedVal->first < 0 && -ShiftedVal->first <= 0xfff;
  858       if (!(IsByte && ShiftedImm->second) &&
  859           AArch64_AM::isSVECpyImm<T>(uint64_t(ShiftedImm->first)
  860                                      << ShiftedImm->second))
  876       if (!(IsByte && ShiftedImm->second) &&
  877           AArch64_AM::isSVEAddSubImm<T>(ShiftedImm->first
  878                                         << ShiftedImm->second))
 1540       Inst.addOperand(MCOperand::createImm(ShiftedVal->first));
 1541       Inst.addOperand(MCOperand::createImm(ShiftedVal->second));
 1555       Inst.addOperand(MCOperand::createImm(-ShiftedVal->first));
 1556       Inst.addOperand(MCOperand::createImm(ShiftedVal->second));

 2870                                      Alignment ? Alignment->value() : 0);

  762     MachineOperand *OrSDWADef = Res->first;
  763     MachineOperand *OrOtherDef = Res->second;

 2891   if (Range->second == 0) {
 2893     NewN = EmitShift(ARM::tLSLri, X, 31 - Range->first);
 2895   } else if (Range->first == 31) {
 2897     NewN = EmitShift(ARM::tLSRri, X, Range->second);
 2899   } else if (Range->first == Range->second) {
 2899   } else if (Range->first == Range->second) {
 2902     NewN = EmitShift(ARM::tLSLri, X, 31 - Range->first);
 2909     NewN = EmitShift(ARM::tLSLri, X, 31 - Range->first);
 2911                      Range->second + (31 - Range->first));
 2911                      Range->second + (31 - Range->first));

  176       unsigned AlignWidth = 8 * Alignment->value();

  897   Cost += LT.first * ((SrcBytes / Alignment->value()) - 1);

 2391   return CR->getUnsignedMax().ult(1ull << 32);
 2576   if (!CR || CR->getUnsignedMax().uge(1ull << VT.getSizeInBits()))
 2633   return CR && CR->getSignedMin().sge(-1ull << Width) &&
 2634          CR->getSignedMax().slt(1ull << Width);

 1352       assert(Op->isReg() && "Only support arguments in registers");
 1353       SrcRegs[I] = getX86SubSuperRegister(Op->getReg(), 64);
 1448       assert(Op->isReg() && "Only supports arguments in registers");
 1449       SrcRegs[I] = getX86SubSuperRegister(Op->getReg(), 64);

  446   PS->PoisonReg = MRI->createVirtualRegister(PS->RC);
  446   PS->PoisonReg = MRI->createVirtualRegister(PS->RC);
  447   BuildMI(Entry, EntryInsertPt, Loc, TII->get(X86::MOV64ri32), PS->PoisonReg)
  475     PS->InitialReg = extractPredStateFromSP(Entry, EntryInsertPt, Loc);
  479     PS->InitialReg = MRI->createVirtualRegister(PS->RC);
  479     PS->InitialReg = MRI->createVirtualRegister(PS->RC);
  490             PS->InitialReg)
  503   PS->SSA.Initialize(PS->InitialReg);
  503   PS->SSA.Initialize(PS->InitialReg);
  504   PS->SSA.AddAvailableValue(&Entry, PS->InitialReg);
  504   PS->SSA.AddAvailableValue(&Entry, PS->InitialReg);
  523       PS->SSA.AddAvailableValue(
  548       if (!Op.isReg() || Op.getReg() != PS->InitialReg)
  551       PS->SSA.RewriteUse(Op);
  747           unsigned CurStateReg = PS->InitialReg;
  750             int PredStateSizeInBytes = TRI->getRegSizeInBits(*PS->RC) / 8;
  753             Register UpdatedStateReg = MRI->createVirtualRegister(PS->RC);
  759                              .addReg(PS->PoisonReg)
  772             if (CurStateReg == PS->InitialReg)
  781           PS->SSA.AddAvailableValue(&CheckingMBB, CurStateReg);
 1176     int PredStateSizeInBytes = TRI->getRegSizeInBits(*PS->RC) / 8;
 1178     Register UpdatedStateReg = MRI->createVirtualRegister(PS->RC);
 1181             .addReg(PS->InitialReg)
 1182             .addReg(PS->PoisonReg)
 1191     PS->SSA.AddAvailableValue(&MBB, UpdatedStateReg);
 1908   Register TmpReg = MRI->createVirtualRegister(PS->RC);
 1928   Register PredStateReg = MRI->createVirtualRegister(PS->RC);
 1929   Register TmpReg = MRI->createVirtualRegister(PS->RC);
 1939           .addImm(TRI->getRegSizeInBits(*PS->RC) - 1);
 2020   unsigned StateReg = PS->SSA.GetValueAtEndOfBlock(&MBB);
 2289   unsigned StateReg = PS->SSA.GetValueAtEndOfBlock(&MBB);
 2394   mergePredStateIntoSP(MBB, InsertPt, Loc, PS->SSA.GetValueAtEndOfBlock(&MBB));
 2452   unsigned StateReg = PS->SSA.GetValueAtEndOfBlock(&MBB);
 2557   int PredStateSizeInBytes = TRI->getRegSizeInBits(*PS->RC) / 8;
 2560   Register UpdatedStateReg = MRI->createVirtualRegister(PS->RC);
 2563                    .addReg(PS->PoisonReg)
 2569   PS->SSA.AddAvailableValue(&MBB, UpdatedStateReg);

  134       if (CR->getUnsignedMax().ult(128))

   57       Text = Text.drop_front(Name->size());

  241     auto *FromPad = cast<CleanupPadInst>(Bundle->Inputs[0]);

  564     return T->isValidState();
  642     return T->isValidState();

  616   unsigned LHSMask = MaskPair->first;
  617   unsigned RHSMask = MaskPair->second;

 2665     assert(FlippedStrictness->first == ICmpInst::ICMP_SGE && "Sanity check");
 2666     RHS2 = FlippedStrictness->second;
 5223   return new ICmpInst(FlippedStrictness->first, Op0, FlippedStrictness->second);
 5223   return new ICmpInst(FlippedStrictness->first, Op0, FlippedStrictness->second);

 1365   if (!MatchesSelectValue(FlippedStrictness->second))
 1373   Value *NewCmp = Builder.CreateICmp(Pred, X, FlippedStrictness->second,

  626     return MSan->sanitizeFunction(

  191   TSan->sanitizeFunction(F, TLI);

  564     for (const Use &ConstU : DeoptBundle->Inputs) {

  138         RemMap[Match->Key] = Match->Value;
  138         RemMap[Match->Key] = Match->Value;

  798     Cand->calculateCost(NumOrigPHIs, Preds.size());

 1709         NonNegativeUse = RangeInfo->getSignedMin().isNonNegative();

  679   LLVM_DEBUG(RangeCheck->dump());
  680   if (RangeCheck->Pred != ICmpInst::ICMP_ULT) {
  682                       << RangeCheck->Pred << ")!\n");
  685   auto *RangeCheckIV = RangeCheck->IV;
  865     Result->Pred = ICmpInst::getInversePredicate(Result->Pred);
  865     Result->Pred = ICmpInst::getInversePredicate(Result->Pred);
  869   if (!Result->IV->isAffine()) {
  874   auto *Step = Result->IV->getStepRecurrence(*SE);
  892   if (IsUnsupportedPredicate(Step, Result->Pred)) {
  893     LLVM_DEBUG(dbgs() << "Unsupported loop latch predicate(" << Result->Pred

  831         if (Cost->UnrolledCost < UP.Threshold * Boost / 100) {

 1438     TransitionArgs = TransitionBundle->Inputs;

 4367         uint64_t Offset = ExprFragment ? ExprFragment->OffsetInBits : 0;
 4372               ExprFragment->OffsetInBits + ExprFragment->SizeInBits;
 4372               ExprFragment->OffsetInBits + ExprFragment->SizeInBits;
 4380           assert(Start >= OrigFragment->OffsetInBits &&
 4382           Start -= OrigFragment->OffsetInBits;

  555       auto *FuncletPad = cast<Instruction>(FuncletBundle->Inputs[0]);
 1624         CallSiteEHPad = cast<FuncletPadInst>(ParentFunclet->Inputs.front());
 1759           MergedDeoptArgs.reserve(ParentDeopt->Inputs.size() +
 1763                                  ParentDeopt->Inputs.begin(),
 1764                                  ParentDeopt->Inputs.end());

 2714           Result->Provenance[i] = B->Provenance[i];
 2716           Result->Provenance[i] = A->Provenance[i];
 2737       auto &P = Result->Provenance;
 2771           Result->Provenance[i] = BitPart::Unset;
 2786         Result->Provenance[i] = Res->Provenance[i];
 2788         Result->Provenance[i] = BitPart::Unset;
 2797     Result->Provenance[i] = i;
 2843   auto &BitProvenance = Res->Provenance;
 2865     Value *Provider = Res->Provider;
 2882   InsertedInsts.push_back(CallInst::Create(F, Res->Provider, "rev", I));

 7352       if (State.Instance->Lane == 0) {
 7355         State.ValueMap.setVectorValue(Ingredient, State.Instance->Part, Undef);
 7374   unsigned Part = State.Instance->Part;
 7375   unsigned Lane = State.Instance->Lane;
 7412   unsigned Part = State.Instance->Part;

 6414       if (Order && Order->size() == VL.size()) {

  163                  !(State->Instance->Part == 0 && State->Instance->Lane == 0);
  163                  !(State->Instance->Part == 0 && State->Instance->Lane == 0);
  262     State->Instance->Part = Part;
  264       State->Instance->Lane = Lane;

 1268         ->template unconditionalConvertTo<T>();

  202         ->template convertTo<T>();

 1384           O(const_cast<Stmt*>(stmt->getStmt()));

  174       OS << I->getValue();

  139       return reinterpret_cast<const MemRegion*>(PSL->getLocationValue());

  252     const SymExpr *Sym = SymVal->getSymbol();

 5094   unsigned PathLength = DynType->PathLength;
 5210     return CastToDerivedClass(Info, E, Ptr, DynType->Type, DynType->PathLength);
 5210     return CastToDerivedClass(Info, E, Ptr, DynType->Type, DynType->PathLength);
 5227     if (!Paths && (declaresSameEntity(DynType->Type, C) ||
 5228                    DynType->Type->isDerivedFrom(C)))
 5240         << Info.Ctx.getRecordType(DynType->Type)
 5249        PathLength >= (int)DynType->PathLength; --PathLength) {
 5254     if (PathLength > (int)DynType->PathLength &&
 5264   if (DynType->Type->isDerivedFrom(C, Paths) && !Paths.isAmbiguous(CQT) &&
 5267     if (!CastToDerivedClass(Info, E, Ptr, DynType->Type, DynType->PathLength))
 5267     if (!CastToDerivedClass(Info, E, Ptr, DynType->Type, DynType->PathLength))
 7561         TypeInfoLValue(Info.Ctx.getRecordType(DynType->Type).getTypePtr());

  359         llvm::Optional<DynTypedMatcher> Bound = Result->tryBind(BindID);

  682     llvm::Optional<DynTypedMatcher> Bound = Result->tryBind(BindID);

 5082           const Stmt *stmt= SE->getStmt();
 5443       print_construction_context(OS, Helper, VTC->getConstructionContext());
 5452         print_construction_context(OS, Helper, CE->getConstructionContext());
 5824           if (isa<CXXThrowExpr>(StmtElm->getStmt()))
 5886   const Stmt *Cond = StmtElem->getStmt();

   56     CFGBlock *&Entry = SM[CS->getStmt()];

   66       return CS->getStmt()->getBeginLoc();
   85         return CS->getStmt()->getBeginLoc();

  514       val.liveDecls = DSetFact.add(val.liveDecls, Dtor->getVarDecl());
  574           const Stmt* stmt = cs->getStmt();

  653     const CFGBlock *BSrc = BE->getSrc();
  673     S = SP->getStmt();
  677     return PathDiagnosticLocation(PIP->getInitializer()->getSourceLocation(),
  680     return PathDiagnosticLocation(PIC->getLocation(), SMng);
  682     return PathDiagnosticLocation(PIE->getLocation(), SMng);
  684     return getLocationForCaller(CE->getCalleeContext(),
  685                                 CE->getLocationContext(),
  688     return getLocationForCaller(CEE->getCalleeContext(),
  689                                 CEE->getLocationContext(),
  692     if (const ReturnStmt *RS = CEB->getReturnStmt())
  694                                                  CEB->getLocationContext());
  696         CEB->getLocationContext()->getDecl()->getSourceRange().getEnd(), SMng);
  698     if (Optional<CFGElement> BlockFront = BE->getFirstElement()) {
  699       if (auto StmtElt = BlockFront->getAs<CFGStmt>()) {
  700         return PathDiagnosticLocation(StmtElt->getStmt()->getBeginLoc(), SMng);
  701       } else if (auto NewAllocElt = BlockFront->getAs<CFGNewAllocator>()) {
  703             NewAllocElt->getAllocatorExpr()->getBeginLoc(), SMng);
  709         BE->getBlock()->getTerminatorStmt()->getBeginLoc(), SMng);
  711     return PathDiagnosticLocation(FE->getStmt(), SMng,
  712                                   FE->getLocationContext());

   68         << ", \"block_id\": " << FEP->getBlock()->getBlockID()
   71     if (const ReturnStmt *RS = FEP->getStmt()) {

   76     if (const auto *CE = dyn_cast<CallExpr>(CS->getStmt())) {
   93         if (const ReturnStmt *RS = dyn_cast<ReturnStmt>(CS->getStmt())) {
  459       const Stmt *S = CS->getStmt();

  825           CurrBlockInfo->ExitLoc = CS->getStmt()->getBeginLoc();
  837           CurrBlockInfo->EntryLoc = CS->getStmt()->getBeginLoc();
 2242     if (isa<CXXThrowExpr>(S->getStmt()))

  859       tf.Visit(const_cast<Stmt *>(cs->getStmt()));

  692   const FileEntry *FE = &BypassFile->getFileEntry();

 1048       assert(PGOOpt->Action != PGOOptions::IRInstr &&
 1049              PGOOpt->Action != PGOOptions::SampleUse &&
 1052       PGOOpt->CSProfileGenFile = CodeGenOpts.InstrProfileOutput.empty()
 1055       PGOOpt->CSAction = PGOOptions::CSIRInstr;
 1132       if (PGOOpt && (PGOOpt->Action == PGOOptions::IRInstr ||
 1133                      PGOOpt->Action == PGOOptions::IRUse))
 1136             /* RunProfileGen */ (PGOOpt->Action == PGOOptions::IRInstr),
 1137             /* IsCS */ false, PGOOpt->ProfileFile,
 1138             PGOOpt->ProfileRemappingFile);

 4244   if (lhs && !lhs->isSimple())
 4257   if (rhs && !rhs->isSimple())
 4264     llvm::PHINode *phi = Builder.CreatePHI(lhs->getPointer()->getType(),
 4266     phi->addIncoming(lhs->getPointer(), lhsBlock);
 4267     phi->addIncoming(rhs->getPointer(), rhsBlock);
 4268     Address result(phi, std::min(lhs->getAlignment(), rhs->getAlignment()));
 4268     Address result(phi, std::min(lhs->getAlignment(), rhs->getAlignment()));
 4270       std::max(lhs->getBaseInfo().getAlignmentSource(),
 4271                rhs->getBaseInfo().getAlignmentSource());
 4273         lhs->getTBAAInfo(), rhs->getTBAAInfo());
 4273         lhs->getTBAAInfo(), rhs->getTBAAInfo());

 2293       SecIt = I->getSecond().SecondaryLocalVarData->begin();

 3914     Init = emitter->tryEmitForInitializer(*InitDecl);
 4030   if (emitter) emitter->finalize(GV);
 5053     InitialValue = emitter->emitForInitializer(*Value, AddrSpace,
 5083   if (emitter) emitter->finalize(GV);

  540     if (LastTerminatedRegion->second != RegionStack.size())
  543     SourceLocation Start = LastTerminatedRegion->first;
  646           RegionStack.size() < LastTerminatedRegion->second)
  971       fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), BodyCount);
  971       fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), BodyCount);
 1039       fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), BodyCount);
 1039       fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), BodyCount);
 1066       fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), BodyCount);
 1066       fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), BodyCount);
 1092       fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), BodyCount);
 1092       fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), BodyCount);
 1188       fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), ThenCount);
 1188       fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), ThenCount);
 1198         fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), ElseCount);
 1198         fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), ElseCount);
 1240         fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), TrueCount);
 1240         fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), TrueCount);

 1690       if (OSTarget->getPlatform() != OSVersionArgTarget->getPlatform() ||
 1690       if (OSTarget->getPlatform() != OSVersionArgTarget->getPlatform() ||
 1691           (Driver::GetReleaseVersion(OSTarget->getOSVersion(), TargetMajor,
 1693            Driver::GetReleaseVersion(OSVersionArgTarget->getOSVersion(),
 1700         if (OSTarget->getPlatform() == OSVersionArgTarget->getPlatform() &&
 1700         if (OSTarget->getPlatform() == OSVersionArgTarget->getPlatform() &&
 1701             !OSTarget->hasOSVersion()) {
 1702           OSTarget->setOSVersion(OSVersionArgTarget->getOSVersion());
 1702           OSTarget->setOSVersion(OSVersionArgTarget->getOSVersion());
 1707               OSVersionArgTarget->getAsString(Args, Opts);
 1708           std::string TargetArg = OSTarget->getAsString(Args, Opts);
 1727           OSTarget->setEnvironment(SDKTarget->getEnvironment());
 1727           OSTarget->setEnvironment(SDKTarget->getEnvironment());
 1738         SDKInfo = OSTarget->inferSDKInfo();
 1748   OSTarget->addOSVersionMinArgument(Args, Opts);
 1749   DarwinPlatformKind Platform = OSTarget->getPlatform();
 1755     if (!Driver::GetReleaseVersion(OSTarget->getOSVersion(), Major, Minor,
 1759           << OSTarget->getAsString(Args, Opts);
 1761     if (!Driver::GetReleaseVersion(OSTarget->getOSVersion(), Major, Minor,
 1765           << OSTarget->getAsString(Args, Opts);
 1771       if (OSTarget->isExplicitlySpecified()) {
 1773             << OSTarget->getAsString(Args, Opts);
 1782     if (!Driver::GetReleaseVersion(OSTarget->getOSVersion(), Major, Minor,
 1786           << OSTarget->getAsString(Args, Opts);
 1788     if (!Driver::GetReleaseVersion(OSTarget->getOSVersion(), Major, Minor,
 1792           << OSTarget->getAsString(Args, Opts);
 1796   DarwinEnvironmentKind Environment = OSTarget->getEnvironment();
 1799       OSTarget->canInferSimulatorFromArch() &&
 2333     OS << "-target-sdk-version=" << SDKInfo->getVersion();

  197     LanguageStyle->ColumnLimit = CodeStyle.ColumnLimit;
 1749   if (!RawStringStyle && Delimiter->empty())
 1754   RawStringStyle->ColumnLimit = getColumnLimit(State);

 2347             Result.getShiftedCodePosition(Replace->getOffset());
 2349                                             Replace->getReplacementText());

 1113     Preamble->AddImplicitPreamble(*CCInvocation, VFS, OverrideMainBuffer.get());
 1322     if (Preamble->CanReuse(PreambleInvocationIn, MainFileBuffer.get(), Bounds,
 2270     Preamble->AddImplicitPreamble(Clang->getInvocation(), VFS,

   55         llvm::sys::path::remove_leading_dotslash(File->getName());
   91         llvm::sys::path::remove_leading_dotslash(File->getName());

  298     Headers.push_back({Name, &FE->getFileEntry()});

  540         const FileEntry *FE = &File->getFileEntry();

  237       DestPath.append(Prefix->begin(), Prefix->end());
  237       DestPath.append(Prefix->begin(), Prefix->end());
  238       DestPath.append(Suffix->begin(), Suffix->end());
  238       DestPath.append(Suffix->begin(), Suffix->end());

  512   FrameworkName += getFrameworkDirRef()->getName();
  587     StringRef FrameworkPath = File->getFileEntry().getDir()->getName();
  611               &File->getFileEntry(), FrameworkPath, RequestingModule,
  615       if (!HS.findUsableModuleForHeader(&File->getFileEntry(), getDir(),
  816         HeaderFileInfo &ToHFI = getFileInfo(&FE->getFileEntry());
  833                                    &FE->getFileEntry());
  843           MSFE_FE = &FE->getFileEntry();
  844           MSFE_Name = FE->getName();
  925     HeaderFileInfo &HFI = getFileInfo(&File->getFileEntry());
  955     if (checkMSVCHeaderSearch(Diags, MSFE ? &MSFE->getFileEntry() : nullptr,
  956                               &File->getFileEntry(), IncludeLoc)) {
  966           &File->getFileEntry(), isAngled, FoundByHeaderMap);
  991       if (checkMSVCHeaderSearch(Diags, MSFE ? &MSFE->getFileEntry() : nullptr,
  992                                 File ? &File->getFileEntry() : nullptr,
 1006   if (checkMSVCHeaderSearch(Diags, MSFE ? &MSFE->getFileEntry() : nullptr,
 1120   getFileInfo(&File->getFileEntry()).DirInfo = DirInfo;
 1123   if (!findUsableModuleForFrameworkHeader(&File->getFileEntry(), FrameworkName,

 1274   if (!Tok || Tok->isNot(TKind))
 1276   SourceLocation TokenLoc = Tok->getLocation();
 1281     const char *TokenEnd = SM.getCharacterData(TokenLoc) + Tok->getLength();
 1298   return TokenLoc.getLocWithOffset(Tok->getLength() + NumWhitespaceChars);

  787       if (&FE->getFileEntry() == FromFile) {
  805           Filename, &FE->getFileEntry());
  821               Filename, &FE->getFileEntry());
  836                 FilenameLoc, Filename, &FE->getFileEntry());
 1931     if (File && isPCHThroughHeader(&File->getFileEntry()))
 1942       SourceMgr.translateFile(&File->getFileEntry()) ==
 1962       HeaderInfo.getFileInfo(&File->getFileEntry()).NumIncludes)
 2038     FileCharacter = std::max(HeaderInfo.getFileDirFlavor(&File->getFileEntry()),
 2053       !HeaderInfo.ShouldEnterIncludeFile(*this, &File->getFileEntry(),
 2071         File ? &File->getFileEntry() : nullptr, SearchPath, RelativePath,
 2085       << OriginalFilename << File->getName();
 2092       !IsMapped && !File->getFileEntry().tryGetRealPathName().empty();
 2096     StringRef RealPathName = File->getFileEntry().tryGetRealPathName();

 1221           PP.getHeaderSearchInfo().getFileDirFlavor(&File->getFileEntry());

  528   if (CurFile && CurFile->getModificationTime() < File->getModificationTime()) {

  676           PreambleConditionalStack.SkipInfo->HashTokenLoc,
  677           PreambleConditionalStack.SkipInfo->IfTokenLoc,
  678           PreambleConditionalStack.SkipInfo->FoundNonSkipPortion,
  679           PreambleConditionalStack.SkipInfo->FoundElse,
  680           PreambleConditionalStack.SkipInfo->ElseLoc);

  192     const CallExpr *CE = dyn_cast<CallExpr>(B.getAs<CFGStmt>()->getStmt());
  330       if (auto *Throw = dyn_cast<CXXThrowExpr>(S->getStmt()))
 1112               if (const AttributedStmt *AS = asFallThroughAttr(CS->getStmt())) {
 1199           return CS->getStmt();

 7368       << FixedLM->toString()
 7369       << FixItHint::CreateReplacement(LMRange, FixedLM->toString());
 7402       << FixedLM->toString()
 7403       << FixItHint::CreateReplacement(LMRange, FixedLM->toString());
 7430       << FixedCS->toString()
 7431       << FixItHint::CreateReplacement(CSRange, FixedCS->toString());

 7897           Insertion->Loc,
 7898           (llvm::Twine(Insertion->Prefix) + "API_AVAILABLE(" + PlatformName +
 7899            "(" + Introduced + "))" + Insertion->Suffix)

 5309         << ArgExpr->getSourceRange() << (unsigned)ArgSize->getQuantity()
 5310         << (unsigned)ParmSize->getQuantity() << 1;

 2510       AddSourceLocation(SkipInfo->HashTokenLoc, Record);
 2511       AddSourceLocation(SkipInfo->IfTokenLoc, Record);
 2512       Record.push_back(SkipInfo->FoundNonSkipPortion);
 2513       Record.push_back(SkipInfo->FoundElse);
 2514       AddSourceLocation(SkipInfo->ElseLoc, Record);

   63       const CFGBlock *CB = BE->getBlock();
  134           PathDiagnosticLocation::createBegin(CS->getStmt(), SM, LC));

   87   if (SymVal && SymVal->isExpression()) {
   88     if (const SymIntExpr *SIE = dyn_cast<SymIntExpr>(SymVal->getSymbol())) {
  146     if (NV->getAs<nonloc::ConcreteInt>()) {
  149                                NV->castAs<nonloc::ConcreteInt>(),

  452   uint64_t NumberKind = V->getValue().getLimitedValue();
  472   const TypedValueRegion* R = dyn_cast<TypedValueRegion>(LV->stripCasts());
  963     return BE->getSrc()->getLoopTarget() == FCS;

  806            << " is the address of the label '" << Label->getLabel()->getName()
  964   if (Optional<loc::MemRegionVal> MR = L->getAs<loc::MemRegionVal>()) {
  965     const MemRegion *R = MR->getRegion()->StripCasts();
 1865     state = setCStringLength(state, dstRegVal->getRegion(), finalStrLength);

  269     const LazyCompoundValData *D = LV->getCVData();

  235                   SM, LO)->getEndLoc();

   37   const Stmt *S = N->getLocationAs<PreStmt>()->getStmt();

 1011   auto *LiteralExpr = dyn_cast<ObjCStringLiteral>(Point->getStmt());

  164     if (!AC->getReturnType(C.getASTContext())

  166     const llvm::APSInt &ArrSize = Size.getAs<nonloc::ConcreteInt>()->getValue();

 1270     SymbolRef Sym = RetVal->getAsLocSymbol();
 1566   if (!RetVal->getAs<Loc>())
 1569   SymbolRef Sym = RetVal->getAsLocSymbol();
 1960     os << "an integer (" << IntVal->getValue() << ")";
 1962     os << "a constant address (" << ConstAddr->getValue() << ")";
 1964     os << "the address of the label '" << Label->getLabel()->getName() << "'";
 3344     Pos = PathDiagnosticLocation(PostImplCall->getLocation(),

  311         if (const CallExpr *TheCall = dyn_cast<CallExpr>(CS->getStmt())) {

   52     int64_t Prot = ProtLoc->getValue().getSExtValue();

  190     const MemRegion* R = X->getRegion();

  103     assert(!haveRefTypeParam || DV->getAs<Loc>());
  106     if (haveAttrNonNull && !DV->getAs<Loc>()) {
  117       auto CSV = DV->getAs<nonloc::CompoundVal>();
  123       V = *(CSV->begin());
  125       assert(++CSV->begin() == CSV->end());
  125       assert(++CSV->begin() == CSV->end());

   95   auto *Region = dyn_cast<VarRegion>(RegionVal->getAsRegion());

  281   const MemRegion *Region = RegionSVal->getRegion();
  347   if (!StoredVal || !isa<SymbolicRegion>(StoredVal->getRegion()))
  802     const MemRegion *SelfRegion = ValueRegionSVal->getRegion();
 1075   if (SymbolRef Sym = ValDefOrUnknown->getAsSymbol())

 1347   for (unsigned idx = 0, e = C->param_size(); idx != e; ++idx) {
 1348     const ParmVarDecl *Param = C->parameters()[idx];

  428   const CFGBlock *Src = PP->getSrc();
  678         const Stmt *CE = CEP->getCallExpr();
  684               InitMethodContext = CEP->getCalleeContext();
  698       if (const ObjCMessageExpr *ME = SP->getStmtAs<ObjCMessageExpr>())

  270   int64_t x = CI->getValue().getSExtValue();

   69       if (SymbolRef Sym = binding->getAsSymbol())
   70         return addPartialTaint(State, Sym, LCV->getRegion(), Kind);

  104     if (const BinaryOperator *BO = P->getStmtAs<BinaryOperator>()) {

   92         if (PS->getStmt() == Ex)

  170   if (DerefInfo->IsCyclic)
  173   const TypedValueRegion *R = DerefInfo->R;
  174   const bool NeedsCastBack = DerefInfo->NeedsCastBack;

   78       const CFGBlock *CB = BE->getBlock();
  133           if (const CallExpr *CE = dyn_cast<CallExpr>(S->getStmt())) {
  203       if (!isa<DeclStmt>(S->getStmt()))
  204         return S->getStmt();

  310       SVal PSV = N->getState()->getSVal(Reg->getRegion());
 1032       const Stmt *S = SP->getStmt();
 1132       const StackFrameContext *CalleeLC = CE->getCalleeContext();
 1155       const Decl *Caller = CE->getLocationContext()->getDecl();
 1172       C.updateLocCtxMap(&Call->path, CE->getCalleeContext());
 1200     C.updateLocCtxMap(&Call->path, CE->getCalleeContext());
 1224     if (!isa<ObjCForCollectionStmt>(PS->getStmt())) {
 1226           PathDiagnosticLocation(PS->getStmt(), SM, C.getCurrLocationContext());
 1238     if (const Stmt *Loop = BE->getSrc()->getLoopTarget()) {
 1267     const CFGBlock *BSrc = BE->getSrc();
 2318     if (BE->getBlock() == &Exit)
 2349       return PathDiagnosticLocation(PIE->getLocation(), SM);
 2351       if (const ReturnStmt *RS = FE->getStmt())
 2813       if (std::unique_ptr<PathDiagnostic> PD = PDB->generate(PC)) {
 3093       const Decl* D = CE->getCalleeContext()->getDecl();

  211     if (auto CI = V->getAs<nonloc::ConcreteInt>())
  212       return &CI->getValue();
  277     if (auto *BO = PS->getStmtAs<BinaryOperator>())
  647       if (CE->getCalleeContext() == OriginalSCtx)
  817         SourceLocation BugLoc = BugPoint->getStmt()->getBeginLoc();
  943         if (CEE->getCalleeContext()->getCallSite() == S)
  959           if (SP->getStmt() == S && CurrentSFC == PredSFC)
  976     const StackFrameContext *CalleeContext = CEE->getCalleeContext();
 1014     const auto *Ret = dyn_cast<ReturnStmt>(SP->getStmt());
 1079         Out << "Returning the value " << CI->getValue();
 1097       if (const MemRegion *MR = LValue->getAsRegion()) {
 1140     if (CE->getCalleeContext() != CalleeSFC)
 1221   const DeclStmt *DS = P->getStmtAs<DeclStmt>();
 1265     os << action << CVal->getValue();
 1301     os << "the value " << CI->getValue();
 1343       os << "The value " << CV->getValue() << " is assigned";
 1345       os << "Assigning " << CV->getValue();
 1383     const MemRegion *FieldReg = (const MemRegion *)PIP->getLocationValue();
 1386       InitE = PIP->getInitializer()->getInit();
 1401       if (!PS || PS->getLocationValue() != R)
 1410       if (const BinaryOperator *BO = P->getStmtAs<BinaryOperator>())
 1425           CallEventRef<> Call = CallMgr.getCaller(CE->getCalleeContext(),
 1431           InitE = cast<ObjCMessageExpr>(CE->getCalleeContext()->getCallSite())
 1468     const Stmt *S = PS->getStmt();
 1667       CurTerminatorStmt = BE->getSrc()->getTerminator().getStmt();
 1669       const Stmt *CurStmt = SP->getStmt();
 1684       SourceLocation BugLoc = BugPoint->getStmt()->getBeginLoc();
 1882         const CFGBlock *srcBlk = BE->getSrc();
 1885             bool TookTrueBranch = (*(srcBlk->succ_begin()) == BE->getDst());
 2015         if (!DV->isZeroConstant() && LVState->isNull(*DV).isConstrainedTrue() &&
 2042     if (const auto *SR = L->getRegionAs<SymbolicRegion>()) {
 2045     } else if (L->getRegionAs<AllocaRegion>())
 2055       RVal = LVState->getSVal(L->getRegion());
 2059           std::make_unique<UndefOrNullArgVisitor>(L->getRegion()));
 2063             *KV, L->getRegion(), EnableNullFPSuppression, TKind, SFC));
 2101   const Stmt *S = P->getStmt();
 2162     const CFGBlock *SrcBlock = BE->getSrc();
 2173       return VisitTerminator(Term, N, SrcBlock, BE->getDst(), BR, BRC);
 2179     const ProgramPointTag *CurrentNodeTag = PS->getTag();
 2184     return VisitTrueTest(cast<Expr>(PS->getStmt()), BRC, BR, N, TookTrue);
 2775   CallEventRef<> Call = CEMgr.getCaller(CEnter->getCalleeContext(), State);
 2805       BR.markInteresting(CEnter->getCalleeContext());

  217       if (StmtElem->getStmt() == E)
 1419     Trigger = AutoDtor->getTriggerStmt();
 1421     Trigger = DeleteDtor->getDeleteExpr();

  248         RS = dyn_cast<ReturnStmt>(LastStmt->getStmt());
  251         RS = dyn_cast<ReturnStmt>(AutoDtor->getTriggerStmt());

  145     if (CallEvent::isCallStmt(SP->getStmt()))
  295     return BEP->getBlock();
  336     return SP->getStmt();
  338     return BE->getSrc()->getTerminatorStmt();
  340     return CE->getCallExpr();
  342     return CEE->getCalleeContext()->getCallSite();
  344     return PIPP->getInitializer()->getInit();
  346     return CEB->getReturnStmt();
  348     return FEP->getStmt();

 1084     MR = V->getAsRegion();
 1871       if (SP->getStmt() == CE)
 2080     const Stmt *LastStmt = CS->getStmt();
 2225     const LabelDecl *L = LV->getLabel();
 2459     SVal V = VInfo->first;
 2460     bool IsReference = VInfo->second->isReferenceType();
 2800       LocReg = LocRegVal->getRegion();
 2940     if (SEV && SEV->isExpression()) {

  369           V = svalBuilder.makeTruthVal(!PTMSV->isNullMemberPointer(), ExTy);
  819       const Expr *ValEx = cast<Expr>(CS->getStmt());

  207             RTC->getConstructionContext(), CallOpts);
  424   const ConstructionContext *CC = C ? C->getConstructionContext() : nullptr;

   85         S = SP->getStmt();
   88         S = CEE->getCalleeContext()->getCallSite();
   99         } while (!CE || CE->getCalleeContext() != CEE->getCalleeContext());
   99         } while (!CE || CE->getCalleeContext() != CEE->getCalleeContext());
  103         Blk = BE->getSrc();
  107       if (CE->getCalleeContext() == SF)
  631     assert(RTC->getStmt() == Call.getOriginExpr());
  635                                      RTC->getConstructionContext(), CallOpts);
  706     const ConstructionContext *CC = CCE ? CCE->getConstructionContext()

   62       if (const auto *R = dyn_cast<TypedValueRegion>(MV->getRegion())) {

  239       S = BE->getBlock()->getTerminatorStmt();

  672       CI->getValue().toString(Idx);
 1245       int64_t i = CI->getValue().getSExtValue();
 1417         int64_t i = CI->getValue().getSExtValue();

  931     MacroLoc = LocAndUnit->first;
  932     PPToUse = &LocAndUnit->second->getPreprocessor();

  568     return scan(X->getRegion());
  575     return scan(X->getLoc());

  338   if (SymVal && SymVal->isExpression()) {
  339     const SymExpr *SE = SymVal->getSymbol();

  882     const llvm::APSInt &ExtentInt = ExtentCI->getValue();
 1127           if (const MemRegion *LR = L->getAsRegion())
 1598   Optional<nonloc::LazyCompoundVal> LCV = V->getAs<nonloc::LazyCompoundVal>();
 1607     QualType SourceRegionTy = LCV->getRegion()->getValueType();
 1633       return std::make_pair(V->getStore(), V->getRegion());
 1633       return std::make_pair(V->getStore(), V->getRegion());
 1691       int64_t i = CI->getValue().getSExtValue();
 1715             int64_t i = CI->getValue().getSExtValue();
 1917       if (D->getAs<nonloc::LazyCompoundVal>()) {
 2035       assert(!V->getAs<nonloc::LazyCompoundVal>());
 2156     if (const MemRegion* R = LV->getRegion())

  105     const llvm::APSInt& I = CI->getValue();
  395       return makeNonLoc(symLHS, Op, rInt->getValue(), ResultTy);
  399       return makeNonLoc(lInt->getValue(), Op, symRHS, ResultTy);
  567       if (const MemRegion *R = LV->getLoc().getAsRegion()) {
  572       return LV->getLoc();

   46     SymbolRef sym = SV->getSymbol();
   52     const MemRegion *R = RV->getRegion();
   65     const MemRegion* R = X->getRegion();
   72     if (const auto *MD = dyn_cast_or_null<CXXMethodDecl>(X->getDecl()))
   88     return X->getLoc().getAsLocSymbol(IncludeBaseRegions);
   91     const MemRegion *R = X->getRegion();
  107   const MemRegion *R = X->getRegion();
  130     return X->getSymbol();
  139     return X->getSymbol();
  153     return X->getRegion();
  156     return X->getLoc().getAsRegion();
  228     return LV->getValue() == I;
  230     return NV->getValue() == I;

  130         return URI && URI->equals(FileURI);

   32     const MemRegion *MR = LV->getAsRegion();

   81       return LI->getLoc();
   84     if (castSize == LI->getNumBits())
   86     return makeLocAsInteger(LI->getLoc(), castSize);
  936           return MakeSymIntVal(lSym, op, rInt->getValue(), resultTy);
  943       if (rInt->isZeroConstant()) {
 1108       if (PTMSV->isNullMemberPointer())
 1110       if (const FieldDecl *FD = PTMSV->getDeclAs<FieldDecl>()) {
 1139       const llvm::APSInt &leftI = lhsInt->getValue();
 1141       llvm::APSInt rightI(rhsInt->getValue(), /* isUnsigned */ true);
 1217     return &X->getValue();
 1220     return &X->getValue();

  159           BE->getBlock()->getBlockID(),
  235           BE->getBlock()->getBlockID(),
  296       NumVisited = NumReached[BE->getBlock()]++;

   73       Compilations(OptionsParser->getCompilations()),

  387           Command->push_back(Scalar);

  104   if (NextToken && NextToken->is(tok::semi) &&
  105       areOnSameLine(NextToken->getLocation(), End, SM)) {
  106     ExtractedRange.setEnd(NextToken->getLocation());

   46       Tool(OptionsParser->getCompilations(), OptionsParser->getSourcePathList(),
   46       Tool(OptionsParser->getCompilations(), OptionsParser->getSourcePathList(),

  154     return RootRange->getBegin();

   28   if (!Tok || !Tok->is(Next))
   30   return CharSourceRange::getTokenRange(Range.getBegin(), Tok->getLocation());

   83   assert(!LookupName->empty() && "Lookup name should be non-empty.");

  326         getDiags().Report(Diag->first, Diag->second.getDiagID()));
  326         getDiags().Report(Diag->first, Diag->second.getDiagID()));
  327     Diag->second.Emit(DB);

   71   OS << Diag->DiagID << "\n";

  294       this->RepositoryUrl->insert(0, "https://");

  510           AdjustedArgs.insert(I, Opts.ExtraArgsBefore->begin(),
  511                               Opts.ExtraArgsBefore->end());
  514           AdjustedArgs.insert(AdjustedArgs.end(), Opts.ExtraArgs->begin(),
  515                               Opts.ExtraArgs->end());

  123       Dest->insert(Dest->end(), Src->begin(), Src->end());
  123       Dest->insert(Dest->end(), Src->begin(), Src->end());
  132     Dest = (Dest && !Dest->empty() ? *Dest + "," : "") + *Src;

   42   TG->print(OS);
   48   OS << "\"file\": \"" << Storage->SourceFilename << "\",\n";
   49   OS << "\"timestamp\": \"" << Storage->Timestamp << "\",\n";
   51   TG->printJSONValues(OS, "");
   60   llvm::SmallString<256> OutputDirectory(Storage->StoreFilename);
   69   llvm::raw_fd_ostream OS(Storage->StoreFilename, EC, llvm::sys::fs::OF_None);
   71     llvm::errs() << "Error opening output file '" << Storage->StoreFilename

  211       return IntValue->toString(/*radix=*/10);

  256     addDeclRefs(match(findAll(DeclRefMatcher), *S->getStmt(), *Context));
  263         *S->getStmt(), *Context));
  337         match(findAll(ReinitMatcher), *S->getStmt(), *Context);

  116       CharSourceRange::getTokenRange(Tok->getLocation(), Tok->getLocation()));
  116       CharSourceRange::getTokenRange(Tok->getLocation(), Tok->getLocation()));

   78       CharSourceRange::getCharRange(Tok->getLocation(), Tok->getEndLoc());
   78       CharSourceRange::getCharRange(Tok->getLocation(), Tok->getEndLoc());
   88           CharSourceRange::getCharRange(T->getLocation(), T->getEndLoc())));
   88           CharSourceRange::getCharRange(T->getLocation(), T->getEndLoc())));

  222       if (NamingStyles[i]->Case) {
  224                       toString(*NamingStyles[i]->Case));
  227                     NamingStyles[i]->Prefix);
  229                     NamingStyles[i]->Suffix);

  161   Range->setBegin(Range->getBegin().getLocWithOffset(Skip));
  161   Range->setBegin(Range->getBegin().getLocWithOffset(Skip));
  220     if (Details->LiteralLocation.getBegin().isMacroID() && IgnoreMacros)
  222     auto Complaint = diag(Details->LiteralLocation.getBegin(),
  224                      << LiteralType::Name << Details->OldSuffix;
  225     if (Details->FixIt) // Similarly, a fix-it is not always possible.
  226       Complaint << *(Details->FixIt);

  191         Map[S->getStmt()] = B;

   86     if (Tok->is(tok::hash))

   35     assert(llvm::all_of(Rule->Cases, hasExplanation) &&
   44   assert(llvm::all_of(Rule->Cases, hasExplanation) &&
   53   if (Rule && llvm::any_of(Rule->Cases, [](const RewriteRule::Case &C) {

   62   CA.command->title = T.Title;
   63   CA.command->command = Command::CLANGD_APPLY_TWEAK;
   64   CA.command->tweakArgs.emplace();
   65   CA.command->tweakArgs->file = File;
   65   CA.command->tweakArgs->file = File;
   66   CA.command->tweakArgs->tweakID = T.ID;
   66   CA.command->tweakArgs->tweakID = T.ID;
   67   CA.command->tweakArgs->selection = Selection;
   67   CA.command->tweakArgs->selection = Selection;
  278       OldestCB->second(llvm::createStringError(
  281                         OldestCB->first)));
  601   if (Server->blockUntilIdleForTest(/*TimeoutSeconds=*/60))
  615   Server->addDocument(File, Contents, WantDiagnostics::Yes);
  633     Server->removeDocument(File);
  638   Server->addDocument(File, *Contents, WantDiags);
  642   Server->onFileEvent(Params);
  719     Server->applyTweak(Params.tweakArgs->file.file(),
  735   Server->workspaceSymbols(
  750   Server->prepareRename(Params.textDocument.uri.file(), Params.position,
  762   Server->rename(File, Params.position, Params.newName, /*WantFormat=*/true,
  778   Server->removeDocument(File);
  806   Reply(Server->formatOnType(*Code, File, Params.position, Params.ch));
  819   auto ReplacementsOrError = Server->formatRange(*Code, File, Params.range);
  836   auto ReplacementsOrError = Server->formatFile(*Code, File);
  861             !ParentName ? S.name : (ParentName->str() + "::" + S.name);
  873   Server->documentSymbols(
  944   Server->enumerateTweaks(File.file(), Params.range, std::move(ConsumeActions));
  955   Server->codeComplete(Params.textDocument.uri.file(), Params.position, CCOpts,
  974   Server->signatureHelp(Params.textDocument.uri.file(), Params.position,
 1002   if (Sym.Definition->uri.file() == Point.textDocument.uri.file() &&
 1003       Sym.Definition->range.contains(Point.position))
 1013   Server->locateSymbolAt(
 1032   Server->locateSymbolAt(
 1051   Server->switchSourceHeader(
 1066   Server->findDocumentHighlights(Params.textDocument.uri.file(),
 1072   Server->findHover(Params.textDocument.uri.file(), Params.position,
 1082                       R.range = (*H)->SymRange;
 1085                         R.contents.value = (*H)->present().renderAsPlainText();
 1088                         R.contents.value = (*H)->present().renderAsMarkdown();
 1098   Server->typeHierarchy(Params.textDocument.uri.file(), Params.position,
 1105   Server->resolveTypeHierarchy(Params.item, Params.resolve, Params.direction,
 1117     auto Old = CDB->getCompileCommand(File);
 1123       CDB->setCompileCommand(File, std::move(New));
 1154   Server->findReferences(Params.textDocument.uri.file(), Params.position,
 1160   Server->symbolInfo(Params.textDocument.uri.file(), Params.position,
 1175   Server->semanticRanges(
 1357     Server->addDocument(FilePath, *DraftMgr.getDraft(FilePath),

  212           SpecFuzzyFind->CachedReq =
  226     if (SpecFuzzyFind && SpecFuzzyFind->NewReq.hasValue()) {
  229           SpecFuzzyFind->NewReq.getValue();

  595   if (!Scopes.UnresolvedQualifier->empty())
 1273         Inserter->addExisting(Inc);
 1481     Req.Query = Filter->pattern();
 1488       Req.PreferredTypes.push_back(PreferredType->raw());
 1587         !C.Name.startswith_lower(Filter->pattern()))
 1589     return Filter->match(C.Name);
 1623             PreferredType->raw() == Candidate.IndexResult->Type) {
 1680         Builder->add(Item, SemaCCS);
 1682     return Builder->build();
 1827     if (isRangeConsecutive(FixIt.range, LSP.textEdit->range)) {
 1828       LSP.textEdit->newText = FixIt.newText + LSP.textEdit->newText;
 1828       LSP.textEdit->newText = FixIt.newText + LSP.textEdit->newText;
 1829       LSP.textEdit->range.start = FixIt.range.start;
 1835     LSP.textEdit->newText += SnippetSuffix;
 1839   LSP.insertText = LSP.textEdit->newText;

  315   Action.edit->changes.emplace();
  316   (*Action.edit->changes)[File.uri()] = {F.Edits.begin(), F.Edits.end()};
  345       Main.codeActions->push_back(toCodeAction(Fix, File));
  363       Main.relatedInformation->push_back(std::move(RelInfo));
  505     LastDiag->ID = Info.getID();
  507     LastDiag->InsideMainFile = true;
  509     LastDiag->Range.start = Position{0, 0};
  510     LastDiag->Range.end = Position{0, 0};
  582     LastDiag->Fixes.push_back(Fix{Message.str(), std::move(Edits)});
  600     LastDiag->ID = Info.getID();
  609       LastDiag->Fixes.insert(LastDiag->Fixes.end(), ExtraFixes.begin(),
  609       LastDiag->Fixes.insert(LastDiag->Fixes.end(), ExtraFixes.begin(),
  637       LastDiag->Notes.push_back(std::move(N));
  648        IncludeLinesWithErrors.insert(LastDiag->Range.start.line).second)) {
  651     vlog("Dropped diagnostic: {0}: {1}", LastDiag->File, LastDiag->Message);
  651     vlog("Dropped diagnostic: {0}: {1}", LastDiag->File, LastDiag->Message);

  208       traverseChildren(D, Sym->children);

  511       assert(!Ref->Qualifier.hasQualifier() && "qualifier already set");
  512       Ref->Qualifier = L.getQualifierLoc();

  113   auto Candidates = Res->CDB->getCompileCommands(File);
  261   return Res->PI;

  202     if (!CCTok->is(tok::coloncolon))
  204     auto IDTok = Lexer::findNextToken(CCTok->getLocation(), SM, LangOpts);
  205     if (!IDTok || !IDTok->is(tok::raw_identifier))
  207     Result.append(("::" + IDTok->getRawIdentifier()).str());
  208     NextLoc = IDTok->getLocation();
  297       Result.UnresolvedScope->append((Result.Name + Split.first).str());
  350     Unresolved.Name = Extracted->Name;
  352     if (!Extracted->ResolvedScope && !S) // Give up if no scope available.
  355     if (Extracted->ResolvedScope)
  356       Unresolved.Scopes.push_back(*Extracted->ResolvedScope);
  361     if (Extracted->UnresolvedScope) {
  363         Scope += *Extracted->UnresolvedScope;

  266     CTContext->setDiagnosticsEngine(&Clang->getDiagnostics());
  267     CTContext->setASTContext(&Clang->getASTContext());
  268     CTContext->setCurrentFile(Filename);
  273         std::string CheckName = CTContext->getCheckName(Info.getID());
  280               CTContext->treatAsError(CheckName)) {
  327       return FixIncludes->fix(DiagLevl, Info);
  329     Clang->setExternalSemaSource(FixIncludes->unresolvedNameRecorder());

  217     if (!Cmd || Cmd->CommandLine.empty())
  221     for (size_t I = 0, E = Cmd->CommandLine.size(); I < E; ++I) {
  222       llvm::StringRef Arg = Cmd->CommandLine[I];
  224         Lang = Cmd->CommandLine[I + 1];
  238     llvm::SmallString<128> Driver(Cmd->CommandLine.front());
  239     llvm::sys::fs::make_absolute(Cmd->Directory, Driver);

  396     dlog("{1}claimRange: {0}", Range->printToString(SM), indent());
  397     auto B = SM.getDecomposedLoc(Range->getBegin());
  398     auto E = SM.getDecomposedLoc(Range->getEnd());

   52     if (!SR.hasValue() || SM.getFileID(SR->getBegin()) != SM.getMainFileID()) {
   56     R.start = sourceLocToPosition(SM, SR->getBegin());
   57     R.end = sourceLocToPosition(SM, SR->getEnd());

  869     PreambleTasks->wait();
  871     WorkerThreads->wait();
  923   PreambleTasks->runAsync(Name, [Ctx = Context::current().clone(),
 1004   PreambleTasks->runAsync("task:" + llvm::sys::path::filename(File),

  270                                 M->Info->getDefinitionLoc(), *MainFilePath)) {
  272       Macro.Name = M->Name;
  617   if (!HI.NamespaceScope->empty())
  618     HI.NamespaceScope->append("::");
  654       HI.Parameters->emplace_back();
  655       auto &P = HI.Parameters->back();
  907       Style, HI->Definition, tooling::Range(0, HI->Definition.size()));
  907       Style, HI->Definition, tooling::Range(0, HI->Definition.size()));
  909           tooling::applyAllReplacements(HI->Definition, Replacements))
  910     HI->Definition = *Formatted;
  912   HI->SymRange =
  976       if (LSPLoc && LSPLoc->uri.file() != *MainFilePath)
 1015     NewMacro.name = M->Name;
 1017     if (!index::generateUSRForMacro(NewMacro.name, M->Info->getDefinitionLoc(),
 1118         ChildSym->children.emplace();
 1119         fillSubTypes(Object.ID, *ChildSym->children, Index, Levels - 1, TUPath);
 1146       ParentSym->parents.emplace();
 1147       fillSuperTypes(*ParentDecl, ASTCtx, *ParentSym->parents, RPSet);
 1229     Result->parents.emplace();
 1232     fillSuperTypes(*CXXRD, AST.getASTContext(), *Result->parents, RPSet);
 1238     Result->children.emplace();
 1242         fillSubTypes(*ID, *Result->children, Index, ResolveLevels, TUPath);

  424       Inputs.CompileCommand.Filename, Index.Symbols->size(),
  425       Index.Refs->numRefs(), Index.Sources->size());
  425       Index.Refs->numRefs(), Index.Sources->size());
  426   SPAN_ATTACH(Tracer, "symbols", int(Index.Symbols->size()));
  427   SPAN_ATTACH(Tracer, "refs", int(Index.Refs->numRefs()));
  428   SPAN_ATTACH(Tracer, "sources", int(Index.Sources->size()));

  119       CDBDirectory = PI->SourceRoot;

   37     if (Task->ThreadPri != llvm::ThreadPriority::Default &&
   39       llvm::set_thread_priority(Task->ThreadPri);
   40     Task->Run();
   41     if (Task->ThreadPri != llvm::ThreadPriority::Default)

  453       auto Entry = Result.Sources->try_emplace(IGN.URI).first;
  459         Include = Result.Sources->try_emplace(Include).first->getKey();
  504     Result.Cmd->Directory = Cmd.Directory;
  505     Result.Cmd->CommandLine.reserve(Cmd.CommandLine.size());
  507       Result.Cmd->CommandLine.emplace_back(C);

  534             R.Location.FileURI = FileURI->c_str();
  617       S.Type = TypeStorage->raw();

  374       for (const auto &Ref : Variant.Refs->second)
  375         Refs.insert(Variant.Refs->first, Ref);

  296     std::replace(Request->begin(), Request->end(), ' ', '\0');
  296     std::replace(Request->begin(), Request->end(), ' ', '\0');

   77   if (!NextTok || !NextTok->is(tok::semi))
   79   return NextTok->getLocation();
  217   unsigned BodyBegin = SM.getFileOffset(OrigBodyRange->getBegin());
  219       SM.getFileOffset(OrigBodyRange->getEnd()));
  223       SM.getBufferData(SM.getFileID(OrigBodyRange->getBegin())), Replacements);
  350     unsigned int SourceLen = SM.getFileOffset(DefRange->getEnd()) -
  351                              SM.getFileOffset(DefRange->getBegin());
  352     const tooling::Replacement DeleteFuncBody(SM, DefRange->getBegin(),
  364     if (!SM.isWrittenInSameFile(DefRange->getBegin(),

   63   Node->dump(OS, Inputs.AST.getASTContext().getSourceManager());

   77       getDeducedType(Inputs.AST, CachedLocation->getBeginLoc());
   80   if (DeducedType == llvm::None || DeducedType->isNull()) {
   94   if (DeducedType->getTypePtr()->isFunctionPointerType()) {
  103       Expansion(SrcMgr, CharSourceRange(CachedLocation->getSourceRange(), true),

  206     SR.setBegin(BeginFileRange->getBegin());
  211     SR.setEnd(EndFileRange->getEnd());

  177           ->getBegin();
  306           ->getBegin(),
  308           ->getEnd());

   75   if (!NextTok || NextTok->isNot(tok::semi))
   82       CharSourceRange::getTokenRange(D->getBeginLoc(), NextTok->getLocation()),

   86                                                  ThenRng->getBegin(),
   90                                                  ElseRng->getBegin(),

  496       InputMirrorStream->SetUnbuffered();

  245   EXPECT_EQ(ShardSource->Relations->size(), 0u);
  278   EXPECT_EQ(ShardSource->Sources->size(), 2U); // A.cc, A.h
  280       ShardSource->Sources->lookup("unittest:///root/A.cc").DirectIncludes,
  282   EXPECT_NE(ShardSource->Sources->lookup("unittest:///root/A.cc").Digest,
  284   EXPECT_THAT(ShardSource->Sources->lookup("unittest:///root/A.h"),
  289   EXPECT_EQ(ShardHeader->Sources->size(), 2U); // A.h, B.h
  291       ShardHeader->Sources->lookup("unittest:///root/A.h").DirectIncludes,
  293   EXPECT_NE(ShardHeader->Sources->lookup("unittest:///root/A.h").Digest,
  295   EXPECT_THAT(ShardHeader->Sources->lookup("unittest:///root/B.h"),
  404   EXPECT_TRUE(ShardHeader->Symbols->empty());
  499     EXPECT_THAT(Shard->Sources->keys(),
  502     EXPECT_THAT(Shard->Sources->lookup("unittest:///A.cc"), HadErrors());
  508     EXPECT_THAT(Shard->Sources->keys(),
  510     EXPECT_THAT(Shard->Sources->lookup("unittest:///A.h"), HadErrors());
  516     EXPECT_THAT(Shard->Sources->keys(),
  518     EXPECT_THAT(Shard->Sources->lookup("unittest:///B.h"), HadErrors());
  524     EXPECT_THAT(Shard->Sources->keys(),
  526     EXPECT_THAT(Shard->Sources->lookup("unittest:///C.h"), HadErrors());

 1781   EXPECT_EQ(R.textEdit->newText, "->Foo::x");
 1801   EXPECT_EQ(R.textEdit->newText, "Foo::x");

  191   Change.range->start.line = 0;
  192   Change.range->start.character = 0;
  193   Change.range->end.line = 0;
  194   Change.range->end.character = 2;
  213   Change.range->start.line = 0;
  214   Change.range->start.character = 5;
  215   Change.range->end.line = 0;
  216   Change.range->end.character = 3;
  233   Change.range->start.line = 0;
  234   Change.range->start.character = 100;
  235   Change.range->end.line = 0;
  236   Change.range->end.character = 100;
  254   Change.range->start.line = 0;
  255   Change.range->start.character = 0;
  256   Change.range->end.line = 0;
  257   Change.range->end.character = 100;
  275   Change.range->start.line = 100;
  276   Change.range->start.character = 0;
  277   Change.range->end.line = 100;
  278   Change.range->end.character = 0;
  295   Change.range->start.line = 0;
  296   Change.range->start.character = 0;
  297   Change.range->end.line = 100;
  298   Change.range->end.character = 0;
  319   Change1.range->start.line = 0;
  320   Change1.range->start.character = 0;
  321   Change1.range->end.line = 0;
  322   Change1.range->end.character = 0;
  328   Change2.range->start.line = 0;
  329   Change2.range->start.character = 5;
  330   Change2.range->end.line = 0;
  331   Change2.range->end.character = 100;

   69       Classes[Type->raw()].insert(Name);
   74   ASTContext &ASTCtx() { return AST->getASTContext(); }

   25     if (Word.size() == Annotated->size())

   91   EXPECT_THAT(CDB.getCompileCommand(testPath("foo.cc"))->CommandLine,
   97   EXPECT_THAT(CDB.getCompileCommand(testPath("foo.cc"))->CommandLine,
  101   EXPECT_THAT(CDB.getCompileCommand(testPath("missing.cc"))->CommandLine,
  117   EXPECT_THAT(CDB.getCompileCommand(testPath("bar.cc"))->CommandLine,
  163   EXPECT_THAT(CDB.getCompileCommand(testPath("foo.cc"))->CommandLine,

   44     VFS->setCurrentWorkingDirectory(Cmd->Directory);
   93                              CDB.getCompileCommand(MainFile)->Directory,
  112                              CDB.getCompileCommand(MainFile)->Directory,
  264   EXPECT_TRUE(StringRef(Edit->newText).contains("<y>"));

  249   ASSERT_NE(0u, IndexFile.Sources->size());

   51       offsetToPosition(Buffer, SM.getFileOffset(FileRange->getBegin())),
   52       offsetToPosition(Buffer, SM.getFileOffset(FileRange->getEnd()))};

  117   auto Sym1 = *ParsedYAML->Symbols->find(
  119   auto Sym2 = *ParsedYAML->Symbols->find(
  148   auto Ref1 = ParsedYAML->Refs->begin()->second.front();
  229     ASSERT_TRUE(In->Sources->count(IGN.URI));
  235     auto IGNDeserialized = In->Sources->lookup(IGN.URI);

  595   EXPECT_EQ(AST.getSourceManager().getFileOffset(Range->getBegin()),
  597   EXPECT_EQ(AST.getSourceManager().getFileOffset(Range->getEnd()),

  127     const SourceManager &SM = AST->getSourceManager();
  130         ND, AST->getASTContext(), SymbolCollector::Options(), MainFile);

  638   resolveTypeHierarchy((*Result->children)[0], /*ResolveLevels=*/1,
  642       (*Result->children)[0],

  129   if (Def && arg.Definition->range != *Def) {
  482         GotDef = Results[0].Definition->range;
 1021     EXPECT_EQ(H->NamespaceScope, Expected.NamespaceScope);
 1022     EXPECT_EQ(H->LocalScope, Expected.LocalScope);
 1023     EXPECT_EQ(H->Name, Expected.Name);
 1024     EXPECT_EQ(H->Kind, Expected.Kind);
 1025     EXPECT_EQ(H->Documentation, Expected.Documentation);
 1026     EXPECT_EQ(H->Definition, Expected.Definition);
 1027     EXPECT_EQ(H->Type, Expected.Type);
 1028     EXPECT_EQ(H->ReturnType, Expected.ReturnType);
 1029     EXPECT_EQ(H->Parameters, Expected.Parameters);
 1030     EXPECT_EQ(H->TemplateParameters, Expected.TemplateParameters);
 1031     EXPECT_EQ(H->SymRange, Expected.SymRange);
 1032     EXPECT_EQ(H->Value, Expected.Value);
 1847       EXPECT_EQ(H->present().renderForTests(), Test.ExpectedHover.str())
 2208       EXPECT_EQ(DeducedType->getAsString(), T.DeducedType);

  100     EXPECT_EQ(Expected->DefLoc->LineNumber, Actual->DefLoc->LineNumber);
  100     EXPECT_EQ(Expected->DefLoc->LineNumber, Actual->DefLoc->LineNumber);
  101     EXPECT_EQ(Expected->DefLoc->Filename, Actual->DefLoc->Filename);
  101     EXPECT_EQ(Expected->DefLoc->Filename, Actual->DefLoc->Filename);

   93   EXPECT_EQ("arg1,arg2,arg3,arg4", llvm::join(Options.ExtraArgs->begin(),
   94                                               Options.ExtraArgs->end(), ","));
   97             llvm::join(Options.ExtraArgsBefore->begin(),
   98                        Options.ExtraArgsBefore->end(), ","));

   22     return "expected: '" + ExpectedWarning->str() + "', saw: '" +
   44     return "expected: '" + ExpectedWarning->str() + "', saw: '" +

 4906   EXPECT_EQ(OptErr->Error, ImportError::NameConflict);
 4931   EXPECT_EQ(OptErr->Error, ImportError::UnsupportedConstruct);
 4965   EXPECT_EQ(OptErr->Error, ImportError::UnsupportedConstruct);
 4968   EXPECT_EQ(OptErr->Error, ImportError::UnsupportedConstruct);
 4991   EXPECT_EQ(OptErr->Error, ImportError::UnsupportedConstruct);
 4998   EXPECT_EQ(OptErr->Error, ImportError::UnsupportedConstruct);
 5123   EXPECT_EQ(OptErr->Error, ImportError::UnsupportedConstruct);
 5163     EXPECT_EQ(OptErr->Error, ImportError::UnsupportedConstruct);
 5172   EXPECT_EQ(OptErr->Error, ImportError::UnsupportedConstruct);
 5207     EXPECT_EQ(OptErr->Error, ImportError::UnsupportedConstruct);
 5246     EXPECT_EQ(OptErr->Error, ImportError::UnsupportedConstruct);

  159   EXPECT_EQ(ExpectedFoo, getSingleMatcher(Sema.Values[0])->getID().second);
  178   EXPECT_EQ(ExpectedBar, getSingleMatcher(Foo.Args[0].Value)->getID().second);
  179   EXPECT_EQ(ExpectedBaz, getSingleMatcher(Foo.Args[1].Value)->getID().second);
  215   Matcher<Decl> M = VarDecl->unconditionalConvertTo<Decl>();
  224   M = HasParameter->unconditionalConvertTo<Decl>();
  236   M = HasParameterWithNamedValues->unconditionalConvertTo<Decl>();
  259   auto M = OM->unconditionalConvertTo<Stmt>();
  387     auto M = TopLevelLetBinding->unconditionalConvertTo<Decl>();
  403     auto M = NestedLetBinding->unconditionalConvertTo<Decl>();

   87   EXPECT_EQ(ErrDiag->first, SourceLocation());
   88   EXPECT_EQ(ErrDiag->second.getDiagID(), diag::err_cannot_open_file);

  438   EXPECT_TRUE(BypassRef->isValid());
  439   EXPECT_EQ(BypassRef->getName(), Ref.getName());
  442   EXPECT_NE(&BypassRef->getFileEntry(), File);
  443   EXPECT_NE(BypassRef->getUID(), VirtualUID);
  444   EXPECT_NE(BypassRef->getSize(), Ref.getSize());

   22     EXPECT_EQ(PSR->FileName, Filename);
   23     EXPECT_EQ(PSR->Begin.first, BeginLine);
   24     EXPECT_EQ(PSR->Begin.second, BeginColumn);
   25     EXPECT_EQ(PSR->End.first, EndLine);
   26     EXPECT_EQ(PSR->End.second, EndColumn);

  551     if (T->is(tok::eof))
  554     Loc = T->getLocation();

   50       SelRange = SourceRange(SelectionRange->first.translate(SM),
   51                              SelectionRange->second.translate(SM));
  162         checkNode<FunctionDecl>(Node->Children[0],
  169         Node->Children[0].dump(OS);
  188                              Node->Children[0],
  202         EXPECT_EQ(Node->Children.size(), 1u);
  204             Node->Children[0], SourceSelectionKind::ContainsSelection,
  226         EXPECT_EQ(Node->Children.size(), 1u);
  228             Node->Children[0], SourceSelectionKind::ContainsSelection,
  242         EXPECT_EQ(Node->Children.size(), 1u);
  244             Node->Children[0], SourceSelectionKind::ContainsSelection,
  258         EXPECT_EQ(Node->Children.size(), 1u);
  260             Node->Children[0], SourceSelectionKind::ContainsSelection,
  282     EXPECT_EQ(Node->Children.size(), 2u);
  283     checkNode<FunctionDecl>(Node->Children[0],
  286     checkNode<FunctionDecl>(Node->Children[1],
  312         EXPECT_EQ(Node->Children.size(), 1u);
  314             Node->Children[0], SourceSelectionKind::ContainsSelection,
  333         EXPECT_EQ(Node->Children.size(), 1u);
  335             Node->Children[0], SourceSelectionKind::ContainsSelection,
  355         EXPECT_EQ(Node->Children.size(), 1u);
  357             Node->Children[0], SourceSelectionKind::ContainsSelection,
  403         EXPECT_EQ(Node->Children.size(), 1u);
  405             Node->Children[0], SourceSelectionKind::ContainsSelection,
  419         EXPECT_EQ(Node->Children.size(), 1u);
  421             Node->Children[0], SourceSelectionKind::ContainsSelection,
  435         EXPECT_EQ(Node->Children.size(), 2u);
  437             Node->Children[0], SourceSelectionKind::ContainsSelectionStart,
  445             Node->Children[1], SourceSelectionKind::ContainsSelectionEnd,
  458                          EXPECT_EQ(Node->Children.size(), 1u);
  460                              Node->Children[0],
  485         EXPECT_EQ(Node->Children.size(), 1u);
  487             Node->Children[0], SourceSelectionKind::ContainsSelection,
  511         EXPECT_EQ(Node->Children.size(), 1u);
  513             Node->Children[0], SourceSelectionKind::InsideSelection,
  531                          EXPECT_EQ(Node->Children.size(), 1u);
  533                              Node->Children[0],
  723         EXPECT_EQ(SelectedCode->size(), 1u);
  726             SelectedCode->getParents();
  743         EXPECT_EQ(SelectedCode->size(), 2u);
  747             SelectedCode->getParents();
  764         EXPECT_EQ(SelectedCode->size(), 3u);
  778         EXPECT_EQ(SelectedCode->size(), 4u);
  798         EXPECT_EQ(SelectedCode->size(), 1u);
  801             SelectedCode->getParents();
  826         EXPECT_EQ(SelectedCode->size(), 1u);
  829             SelectedCode->getParents();
  856         EXPECT_EQ(SelectedCode->size(), 1u);
  859             SelectedCode->getParents();
  884         EXPECT_EQ(SelectedCode->size(), 1u);
  887             SelectedCode->getParents();
  933         EXPECT_EQ(SelectedCode->size(), 1u);
  936             SelectedCode->getParents();
  956         EXPECT_EQ(SelectedCode->size(), 2u);
  960             SelectedCode->getParents();
  988         EXPECT_EQ(SelectedCode->size(), 1u);
 1000         EXPECT_EQ(SelectedCode->size(), 1u);
 1031         EXPECT_EQ(SelectedCode->size(), 1u);
 1042         EXPECT_EQ(SelectedCode->size(), 1u);
 1053         EXPECT_EQ(SelectedCode->size(), 1u);
 1071         Node->dump();
 1075         EXPECT_EQ(SelectedCode->size(), 1u);
 1078             SelectedCode->getParents()[SelectedCode->getParents().size() - 1]
 1078             SelectedCode->getParents()[SelectedCode->getParents().size() - 1]

  122         OS << "Expected existing replacement: " << ExpectedExisting->toString()
  131         OS << "Expected new replacement: " << ExpectedNew->toString() << "\n";

   73   EXPECT_EQ(Expected, Pred(*StmtMatch->Result.Nodes.getNodeAs<Expr>("expr")))
   85   EXPECT_EQ(Expected, Pred(*StmtMatch->Result.Nodes.getNodeAs<Expr>("arg")))
  134   EXPECT_THAT(Builder(*StmtMatch->Result.Nodes.getNodeAs<Expr>("expr"),
  135                       *StmtMatch->Result.Context),

   99     if (auto ResultOrErr = Stencil.eval(StmtMatch->Result)) {
  134   EXPECT_THAT_EXPECTED(Stencil.eval(StmtMatch->Result),
  153   EXPECT_THAT_EXPECTED(S(StmtMatch->Result),
  168   auto ResultOrErr = Stencil.eval(StmtMatch->Result);
  179   EXPECT_THAT_EXPECTED(Stencil.eval(StmtMatch->Result), HasValue(Expected));
  186   EXPECT_THAT_EXPECTED(Stencil.eval(StmtMatch->Result),
  318   EXPECT_THAT_EXPECTED(Stencil.eval(StmtMatch->Result),
  339   EXPECT_THAT_EXPECTED(Stencil.eval(StmtMatch->Result), HasValue("field"));

   57     if (auto Block = Value->getAsBlock()) {
   58       if (Block->size() > OrigUnit.getAddressByteSize() &&
   69     NextUnitOffset += NewUnit->getUnitDie().getSize();

  265     if (Optional<const char *> Name = Val->getAsCString()) {
 1759     Attr->set(Streamer->getRangesSectionSize());
 2121     if (!Ref->isFormClass(DWARFFormValue::FC_Reference))

  686     if (Expected<StringRef> E = Sec->getContents())

  807   return std::make_pair(saver.save(ret->first), ret->second);
  807   return std::make_pair(saver.save(ret->first), ret->second);

  542     os << fileLine->first << ":" << fileLine->second << "\n>>>            ";
  542     os << fileLine->first << ":" << fileLine->second << "\n>>>            ";

  237     return createFileLineMsg(info->FileName, info->Line);
  237     return createFileLineMsg(info->FileName, info->Line);
  242     return createFileLineMsg(fileLine->first, fileLine->second);
  242     return createFileLineMsg(fileLine->first, fileLine->second);

  305     return info->FileName + ":" + std::to_string(info->Line) + ":(" +
  305     return info->FileName + ":" + std::to_string(info->Line) + ":(" +

  364       config->features->push_back(s);

  322     FILE *fh = nextfile ? FileSystem::Instance().Fopen(nextfile->c_str(), "r")

  229     return m_opaque_ptr->m_timeout->count();

  543                  ->type;

  168             breakpoint_sp = target->GetBreakpointByID(bp_id->GetBreakpointID());
  172                                          bp_id->GetBreakpointID());
  182                 &canonical_id_str, bp_id->GetBreakpointID(), bp_loc->GetID());
  198         !target->GetBreakpointByID(start_bp->GetBreakpointID())) {
  207         !target->GetBreakpointByID(end_bp->GetBreakpointID())) {
  214     break_id_t start_bp_id = start_bp->GetBreakpointID();
  215     break_id_t start_loc_id = start_bp->GetLocationID();
  216     break_id_t end_bp_id = end_bp->GetBreakpointID();
  217     break_id_t end_loc_id = end_bp->GetLocationID();

  236   if (hw_debug_cap == llvm::None || hw_debug_cap->first == 0 ||
  237       hw_debug_cap->first <= m_hw_breakpoints_map.size())

  188       if (!addr->getAsInteger(0, fd)) {
  238       std::string addr_str = addr->str();

   84     return password->username;
  128     return FileSpec(password->shell);

   69     size = arg->value.getLimitedValue(capping_size);

 2664     cf_true = m_CFBoolean_values->second;
 2665     cf_false = m_CFBoolean_values->first;

   35   triple.setArch(Module->Arch);
   36   triple.setOS(Module->OS);
   41   UUID uuid = Info && Info->ID ? Info->ID : Module->ID;
   41   UUID uuid = Info && Info->ID ? Info->ID : Module->ID;
   41   UUID uuid = Info && Info->ID ? Info->ID : Module->ID;
   85                                 file_offset, length, std::move(header->arch),
   86                                 std::move(header->uuid));
  102   ModuleSpec spec(file, std::move(header->arch));
  103   spec.GetUUID() = std::move(header->uuid);

 1783         InfoOr->GetRangeBase(), InfoOr->GetByteSize(), PHdr.p_offset,
 1783         InfoOr->GetRangeBase(), InfoOr->GetByteSize(), PHdr.p_offset,
 1819         InfoOr->Segment, GetModule(), // Module to which this section belongs.
 1825         InfoOr->Range.GetRangeBase(), // VM address.
 1826         InfoOr->Range.GetByteSize(),  // VM size in bytes of this section.
 1835     (InfoOr->Segment ? InfoOr->Segment->GetChildren() : *m_sections_up)
 1835     (InfoOr->Segment ? InfoOr->Segment->GetChildren() : *m_sections_up)

  266             static_cast<void *>(m_owningbin->getBinary()));
  936     llvm::cast<llvm::object::COFFObjectFile>(m_owningbin->getBinary());
  949     return m_deps_filespec->GetSize();
  962             static_cast<void *>(m_owningbin->getBinary()));
  965       llvm::dyn_cast<llvm::object::COFFObjectFile>(m_owningbin->getBinary());
  991       m_deps_filespec->EmplaceBack(dll_fullpath);
  994       m_deps_filespec->EmplaceBack(dll_name);
  997   return m_deps_filespec->GetSize();
 1005     files.AppendIfUnique(m_deps_filespec->GetFileSpecAtIndex(i));
 1213       auto spec = m_deps_filespec->GetFileSpecAtIndex(i);

 3122     response.Printf("num:%d;", hw_debug_cap->second);

  252     return proc_status->GetPid();
  404   const size_t offset = addr - range->start;
  406   if (addr < range->start || offset >= range->range_ref.size())
  406   if (addr < range->start || offset >= range->range_ref.size())
  409   const size_t overlap = std::min(size, range->range_ref.size() - offset);
  410   return range->range_ref.slice(offset, overlap);

  220   m_thread_list = m_minidump_parser->GetThreads();
  221   m_active_exception = m_minidump_parser->GetExceptionStream();
  227   llvm::Optional<lldb::pid_t> pid = m_minidump_parser->GetPid();
  315   llvm::ArrayRef<uint8_t> mem = m_minidump_parser->GetMemory(addr, size);
  327     return m_minidump_parser->GetArchitecture();
  343       m_minidump_parser->BuildMemoryRegions();
  351   if (pos != m_memory_regions->begin() &&
  357   if (pos == m_memory_regions->begin())
  362   if (pos == m_memory_regions->end())
  395       context = m_minidump_parser->GetThreadContext(context_location);
  397       context = m_minidump_parser->GetThreadContextWow64(thread);
  407       m_minidump_parser->GetFilteredModuleList();
  412     std::string name = cantFail(m_minidump_parser->GetMinidumpFile().getString(
  425     const auto uuid = m_minidump_parser->GetModuleUUID(module);

  189   return m_cu_data->GetSize();
  193   if (index >= m_cu_data->GetSize())
  196   CompUnitData &data = m_cu_data->GetEntryRef(index).data;
  210     if (record && record->FileNum < m_files->size())
  210     if (record && record->FileNum < m_files->size())
  211       spec = (*m_files)[record->FileNum];
  230   CompUnitData &data = m_cu_data->GetEntryRef(comp_unit.GetID()).data;
  242   CompUnitData &data = m_cu_data->GetEntryRef(comp_unit.GetID()).data;
  260       m_cu_data->FindEntryIndexThatContains(so_addr.GetFileAddress());
  347       add_symbol(record->Address, record->Size, record->Name);
  347       add_symbol(record->Address, record->Size, record->Name);
  347       add_symbol(record->Address, record->Size, record->Name);
  352       add_symbol(record->Address, llvm::None, record->Name);
  352       add_symbol(record->Address, llvm::None, record->Name);
  365   if (auto *entry = m_unwind_data->win.FindEntryThatContains(
  370     return record->ParameterSize;
  440     llvm::StringRef lhs = rule->first;
  441     postfix::Node *rhs = postfix::ParseOneExpression(rule->second, node_alloc);
  443       LLDB_LOG(log, "Could not parse `{0}` as unwind rhs.", rule->second);
  461       LLDB_LOG(log, "Resolving symbols in `{0}` failed.", rule->second);
  487           m_unwind_data->cfi.FindEntryThatContains(address.GetFileAddress()))
  490           m_unwind_data->win.FindEntryThatContains(address.GetFileAddress()))
  505   assert(init_record.hasValue() && init_record->Size.hasValue() &&
  514       AddressRange(base + init_record->Address, *init_record->Size,
  514       AddressRange(base + init_record->Address, *init_record->Size,
  519   if (!ParseCFIUnwindRow(init_record->UnwindRules, resolver, *row_sp))
  526     if (record->Size.hasValue())
  530     row_sp->SetOffset(record->Address - init_record->Address);
  530     row_sp->SetOffset(record->Address - init_record->Address);
  531     if (!ParseCFIUnwindRow(record->UnwindRules, resolver, *row_sp))
  557       AddressRange(base + record->RVA, record->CodeSize,
  557       AddressRange(base + record->RVA, record->CodeSize,
  565       postfix::ParseFPOProgram(record->ProgramString, node_alloc);
  568     LLDB_LOG(log, "Invalid unwind rule: {0}.", record->ProgramString);
  589     row_sp->GetCFAValue().SetRaSearch(record->LocalSize +
  590                                       record->SavedRegisterSize);
  594                record->ProgramString);
  616                record->ProgramString);
  652     if (record->Number >= m_files->size())
  652     if (record->Number >= m_files->size())
  653       m_files->resize(record->Number + 1);
  653       m_files->resize(record->Number + 1);
  654     FileSpec::Style style = FileSpec::GuessPathStyle(record->Name)
  656     (*m_files)[record->Number] = FileSpec(record->Name, style);
  656     (*m_files)[record->Number] = FileSpec(record->Name, style);
  677       m_cu_data->Append(CompUnitMap::Entry(base + record->Address, record->Size,
  677       m_cu_data->Append(CompUnitMap::Entry(base + record->Address, record->Size,
  677       m_cu_data->Append(CompUnitMap::Entry(base + record->Address, record->Size,
  682   m_cu_data->Sort();
  716     record->Address += base;
  718     if (next_addr && *next_addr != record->Address) {
  723         line_seq_up.get(), record->Address, record->LineNum, /*column*/ 0,
  723         line_seq_up.get(), record->Address, record->LineNum, /*column*/ 0,
  724         map[record->FileNum], /*is_start_of_statement*/ true,
  727     next_addr = record->Address + record->Size;
  727     next_addr = record->Address + record->Size;
  749       if (record->Size)
  750         m_unwind_data->cfi.Append(UnwindMap::Entry(
  751             base + record->Address, *record->Size, It.GetBookmark()));
  751             base + record->Address, *record->Size, It.GetBookmark()));
  755   m_unwind_data->cfi.Sort();
  760       m_unwind_data->win.Append(UnwindMap::Entry(
  761           base + record->RVA, record->CodeSize, It.GetBookmark()));
  761           base + record->RVA, record->CodeSize, It.GetBookmark()));
  765   m_unwind_data->win.Sort();

 1167         attrs.byte_stride = array_info->byte_stride;
 1168         attrs.bit_stride = array_info->bit_stride;
 1216       if (array_info && array_info->element_orders.size() > 0) {
 1218         auto end = array_info->element_orders.rend();
 1219         for (auto pos = array_info->element_orders.rbegin(); pos != end;

  626   return m_comp_dir->GetPathStyle();
  714   if (m_file_spec->IsRelative())
  715     m_file_spec->MakeAbsolute(GetCompilationDirectory());

 1276     return decoded->dwarf.GetDIE(decoded->ref);
 1276     return decoded->dwarf.GetDIE(decoded->ref);

   71   if (!cvt || cvt->kind() != LF_BUILDINFO)

  543   StringView name{pub->Name.begin(), pub->Name.size()};
  543   StringView name{pub->Name.begin(), pub->Name.size()};

  574                          ->m_compile_opts->Machine;

  919   return TranslateLanguage(item->m_compile_opts->getLanguage());

 5637       num_children = array_info->element_orders.size()
 5638                          ? array_info->element_orders.back()

  168     return FDEToUnwindPlan(entry->data, addr, unwind_plan);

  160   return m_compile_units->size();

   82     DataExtractor extractor(expr.data(), expr.size(), order_and_width->first,
   83                             order_and_width->second);
   85                                                order_and_width->second,

  141                    std::make_pair(range_or->GetBaseAddress().GetFileAddress(),

   38       auto ec = sys::fs::create_directory(root->GetPath());
  125   if (auto e = m_loader->LoadIndex())

  111       strs.push_back(value.getAsString()->str());

  194   ASSERT_EQ(1u, result->size());
  219   ASSERT_EQ(1u, result->size());
  264     ASSERT_EQ(0u, result->size()) << "response was: " << response;

   52     ASSERT_GT(parser->GetData().size(), 0UL);
  111   thread_list = parser->GetThreads();
  118   llvm::ArrayRef<uint8_t> context = parser->GetThreadContext(thread);
  140             parser->GetArchitecture().GetMachine());
  142             parser->GetArchitecture().GetTriple().getOS());
  154   EXPECT_EQ(nullptr, parser->GetMiscInfo());
  186   llvm::Optional<LinuxProcStatus> proc_status = parser->GetLinuxProcStatus();
  188   lldb::pid_t pid = proc_status->GetPid();
  221   llvm::Optional<lldb::pid_t> pid = parser->GetPid();
  243   llvm::ArrayRef<minidump::Module> modules = parser->GetModuleList();
  245       parser->GetFilteredModuleList();
  249   EXPECT_THAT_EXPECTED(parser->GetMinidumpFile().getString(M.ModuleNameRVA),
  256       parser->GetExceptionStream();
  265   EXPECT_EQ(range_start, range->start);
  266   EXPECT_EQ(range_start + range_size, range->start + range->range_ref.size());
  266   EXPECT_EQ(range_start + range_size, range->start + range->range_ref.size());
  282   EXPECT_EQ(llvm::None, parser->FindMemoryRange(0x00));
  283   EXPECT_EQ(llvm::None, parser->FindMemoryRange(0x2a));
  285             parser->FindMemoryRange(0x401d46));
  286   EXPECT_EQ(llvm::None, parser->FindMemoryRange(0x401d46 + 2));
  291       parser->FindMemoryRange(0x7ffceb34a000 + 2));
  292   EXPECT_EQ(llvm::None, parser->FindMemoryRange(0x7ffceb34a000 + 5));
  309   EXPECT_EQ((llvm::ArrayRef<uint8_t>{0x54}), parser->GetMemory(0x401d46, 1));
  311             parser->GetMemory(0x401d46, 4));
  314             parser->GetMemory(0x7ffceb34a000, 5));
  316             parser->GetMemory(0x7ffceb34a000, 3));
  318   EXPECT_EQ(llvm::ArrayRef<uint8_t>(), parser->GetMemory(0x500000, 512));
  325   EXPECT_FALSE(parser->FindMemoryRange(0x00).hasValue());
  326   EXPECT_FALSE(parser->FindMemoryRange(0x2a).hasValue());
  329   EXPECT_FALSE(parser->FindMemoryRange(0x40000 + 4096).hasValue());
  332   EXPECT_FALSE(parser->FindMemoryRange(0x7ffe0000 + 4096).hasValue());
  379       parser->BuildMemoryRegions(),
  412       parser->BuildMemoryRegions(),
  427       parser->BuildMemoryRegions(),
  458       parser->BuildMemoryRegions(),
  501             parser->GetArchitecture().GetMachine());
  503             parser->GetArchitecture().GetTriple().getOS());
  515   EXPECT_EQ(llvm::None, parser->GetLinuxProcStatus());
  520   const MinidumpMiscInfo *misc_info = parser->GetMiscInfo();
  529   llvm::Optional<lldb::pid_t> pid = parser->GetPid();
  537   llvm::Optional<lldb::pid_t> pid = parser->GetPid();
  560   llvm::ArrayRef<minidump::Thread> thread_list = parser->GetThreads();
  562   llvm::ArrayRef<uint8_t> registers(parser->GetThreadContext(thread));
  603   llvm::ArrayRef<minidump::Thread> thread_list = parser->GetThreads();
  605   llvm::ArrayRef<uint8_t> registers(parser->GetThreadContext(thread));
  638   llvm::ArrayRef<minidump::Thread> thread_list = parser->GetThreads();
  640   llvm::ArrayRef<uint8_t> registers(parser->GetThreadContextWow64(thread));
  688       parser->GetFilteredModuleList();
  714       parser->GetFilteredModuleList();
  718       parser->GetMinidumpFile().getString(filtered_modules[0]->ModuleNameRVA),
  722       parser->GetMinidumpFile().getString(filtered_modules[1]->ModuleNameRVA),

  449     EXPECT_EQ(arg, result->value);
  450     EXPECT_EQ(int_type, result->type);

   60   m_module_sp = std::make_shared<Module>(ModuleSpec(FileSpec(m_file->name())));

   63     GTEST_LOG_(WARNING) << "Failed to delete `" << Name->c_str()

  251       message, m_process_info->GetEndian(), m_register_infos);

  761     Builder.getJITTargetMachineBuilder()->getTargetTriple().setArchName(MArch);
  764       ->setCPU(getCPUStr())

  399   std::string RemapFrom = nativeWithTrailing(PathRemapping->first);
  400   std::string RemapTo = nativeWithTrailing(PathRemapping->second);

  250       if (auto DebugLocOffset = FormValue->getAsSectionOffset()) {

  802       Kind = T->kind();
  803       RecordSize = T->length();

  139     addReferencedTypes(Rec->content(), DepList);
  146       switch (Rec->kind()) {

   87   Obj.Headers->SuperBlock.NumBlocks = File.getBlockCount();
   88   Obj.Headers->SuperBlock.BlockMapAddr = File.getBlockMapIndex();
   89   Obj.Headers->SuperBlock.BlockSize = File.getBlockSize();
   91   Obj.Headers->DirectoryBlocks.assign(Blocks.begin(), Blocks.end());
   92   Obj.Headers->NumDirectoryBlocks = File.getNumDirectoryBlocks();
   93   Obj.Headers->SuperBlock.NumDirectoryBytes = File.getNumDirectoryBytes();
   94   Obj.Headers->NumStreams =
   96   Obj.Headers->SuperBlock.FreeBlockMapBlock = File.getFreeBlockMapBlock();
   97   Obj.Headers->SuperBlock.Unknown1 = File.getUnknown1();
   98   Obj.Headers->FileSize = File.getFileSize();
  122     Obj.StringTable->push_back(*S);
  132   Obj.StreamSizes->assign(File.getStreamSizes().begin(),
  146     Obj.StreamMap->push_back(BlockList);
  162   Obj.PdbStream->Age = InfoS.getAge();
  163   Obj.PdbStream->Guid = InfoS.getGuid();
  164   Obj.PdbStream->Signature = InfoS.getSignature();
  165   Obj.PdbStream->Version = InfoS.getVersion();
  166   Obj.PdbStream->Features = InfoS.getFeatureSignatures();
  208   Obj.DbiStream->Age = DS.getAge();
  209   Obj.DbiStream->BuildNumber = DS.getBuildNumber();
  210   Obj.DbiStream->Flags = DS.getFlags();
  211   Obj.DbiStream->MachineType = DS.getMachineType();
  212   Obj.DbiStream->PdbDllRbld = DS.getPdbDllRbld();
  213   Obj.DbiStream->PdbDllVersion = DS.getPdbDllVersion();
  214   Obj.DbiStream->VerHeader = DS.getDbiVersion();
  220       Obj.DbiStream->ModInfos.emplace_back();
  221       yaml::PdbDbiModuleInfo &DMI = Obj.DbiStream->ModInfos.back();
  267         DMI.Modi->Signature = ModS.signature();
  274           DMI.Modi->Symbols.push_back(*ES);
  292   Obj.TpiStream->Version = TS.getTpiVersion();
  297     Obj.TpiStream->Records.push_back(*ExpectedRecord);
  319   Obj.IpiStream->Version = IS.getTpiVersion();
  325     Obj.IpiStream->Records.push_back(*ExpectedRecord);
  361     Obj.PublicsStream->PubSyms.push_back(*ES);

  764     BlockSize = YamlObj.Headers->SuperBlock.BlockSize;
 1406   if (!to_integer(Matches[1], Parsed->Min))
 1410     Parsed->Max.emplace();
 1411     if (!to_integer(Matches[3], *Parsed->Max))

 1143     writeInt<uint16_t>(Font->Size);
 1146       writeInt<uint16_t>(Font->Weight);
 1147       writeInt<uint8_t>(Font->IsItalic);
 1148       writeInt<uint8_t>(Font->Charset);
 1150     RETURN_IF_ERROR(writeCString(Font->Typeface));

   54   YAMLObj.OptionalHeader->Header.AddressOfEntryPoint =
   56   YAMLObj.OptionalHeader->Header.ImageBase = OptionalHeader->ImageBase;
   57   YAMLObj.OptionalHeader->Header.SectionAlignment =
   59   YAMLObj.OptionalHeader->Header.FileAlignment = OptionalHeader->FileAlignment;
   60   YAMLObj.OptionalHeader->Header.MajorOperatingSystemVersion =
   62   YAMLObj.OptionalHeader->Header.MinorOperatingSystemVersion =
   64   YAMLObj.OptionalHeader->Header.MajorImageVersion =
   66   YAMLObj.OptionalHeader->Header.MinorImageVersion =
   68   YAMLObj.OptionalHeader->Header.MajorSubsystemVersion =
   70   YAMLObj.OptionalHeader->Header.MinorSubsystemVersion =
   72   YAMLObj.OptionalHeader->Header.Subsystem = OptionalHeader->Subsystem;
   73   YAMLObj.OptionalHeader->Header.DLLCharacteristics =
   75   YAMLObj.OptionalHeader->Header.SizeOfStackReserve =
   77   YAMLObj.OptionalHeader->Header.SizeOfStackCommit =
   79   YAMLObj.OptionalHeader->Header.SizeOfHeapReserve =
   81   YAMLObj.OptionalHeader->Header.SizeOfHeapCommit =
   84   for (auto &DestDD : YAMLObj.OptionalHeader->DataDirectories) {
   89     DestDD->RelativeVirtualAddress = DD->RelativeVirtualAddress;
   90     DestDD->Size = DD->Size;

  242       if (P && (P->Action == PGOOptions::IRInstr ||
  243                 P->Action == PGOOptions::SampleUse))
  249           P->CSAction = PGOOptions::CSIRInstr;
  250           P->CSProfileGenFile = CSProfileGenFile;
  257         P->CSAction = PGOOptions::CSIRUse;

  133             InnerPA->abandon(InnerAnalysisID);

 2695             Validate(A, B, C, Width, S->getSExtValue());

  227   EXPECT_EQ(1, A->x);
  228   EXPECT_EQ(2, A->y);
  233   EXPECT_EQ(5, A->x);
  234   EXPECT_EQ(-5, A->y);
  283   EXPECT_EQ(3, O->val);
  295   EXPECT_EQ(3, B->val);
  306   EXPECT_EQ(3, O->val);
  319   EXPECT_EQ(3, B->val);
  344   EXPECT_EQ(3, B->val);
  380   EXPECT_EQ(4, A->val);

  113     EXPECT_EQ(S1->first, "Counter");
  114     EXPECT_EQ(S1->second, 2u);
  116     EXPECT_EQ(S2->first, "Counter2");
  117     EXPECT_EQ(S2->second, 1u);
  158     EXPECT_EQ(S1->first, "Counter");
  159     EXPECT_EQ(S1->second, 1u);
  161     EXPECT_EQ(S2->first, "Counter2");
  162     EXPECT_EQ(S2->second, 1u);

  275             dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
  277         EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
  279             dyn_cast_or_null<ConstantInt>(Bounds->getStepValue());
  281         EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub");
  282         EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
  283         EXPECT_EQ(Bounds->getDirection(),
  333             dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
  335         EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
  337             dyn_cast_or_null<ConstantInt>(Bounds->getStepValue());
  339         EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub");
  340         EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
  341         EXPECT_EQ(Bounds->getDirection(),
  391             dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
  393         EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
  395             dyn_cast_or_null<ConstantInt>(Bounds->getStepValue());
  397         EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub");
  398         EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
  399         EXPECT_EQ(Bounds->getDirection(),
  449             dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
  451         EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
  453             dyn_cast_or_null<ConstantInt>(Bounds->getStepValue());
  455         EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub");
  456         EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
  457         EXPECT_EQ(Bounds->getDirection(),
  507             dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
  509         EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
  511             dyn_cast_or_null<ConstantInt>(Bounds->getStepValue());
  513         EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub");
  514         EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
  515         EXPECT_EQ(Bounds->getDirection(),
  566             dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
  568         EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
  570             dyn_cast_or_null<ConstantInt>(Bounds->getStepValue());
  572         EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ubPlusOne");
  573         EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
  574         EXPECT_EQ(Bounds->getDirection(),
  624             dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
  626         EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
  627         EXPECT_EQ(Bounds->getStepValue()->getName(), "step");
  628         EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub");
  629         EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
  630         EXPECT_EQ(Bounds->getDirection(), Loop::LoopBounds::Direction::Unknown);
  679             dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
  681         EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
  683             dyn_cast_or_null<ConstantInt>(Bounds->getStepValue());
  685         EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub");
  686         EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_ULT);
  687         EXPECT_EQ(Bounds->getDirection(),
  736         EXPECT_EQ(Bounds->getInitialIVValue().getName(), "ub");
  737         EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
  739             dyn_cast_or_null<ConstantInt>(Bounds->getStepValue());
  742             dyn_cast<ConstantInt>(&Bounds->getFinalIVValue());
  744         EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SGT);
  745         EXPECT_EQ(Bounds->getDirection(),
  796             dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
  798         EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
  799         EXPECT_EQ(Bounds->getStepValue()->getName(), "step");
  800         EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub");
  801         EXPECT_EQ(Bounds->getCanonicalPredicate(),
  803         EXPECT_EQ(Bounds->getDirection(), Loop::LoopBounds::Direction::Unknown);
  855             dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
  857         EXPECT_EQ(Bounds->getStepInst().getName(), "indvars.iv.next");
  859             dyn_cast_or_null<ConstantInt>(Bounds->getStepValue());
  861         EXPECT_EQ(Bounds->getFinalIVValue().getName(), "wide.trip.count");
  862         EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_NE);
  863         EXPECT_EQ(Bounds->getDirection(),
  915             dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
  917         EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
  919             dyn_cast_or_null<ConstantInt>(Bounds->getStepValue());
  921         EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub");
  922         EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
  923         EXPECT_EQ(Bounds->getDirection(),
  975             dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
  977         EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
  979             dyn_cast_or_null<ConstantInt>(Bounds->getStepValue());
  981         EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub");
  982         EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
  983         EXPECT_EQ(Bounds->getDirection(),
 1027             dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
 1029         EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
 1031             dyn_cast_or_null<ConstantInt>(Bounds->getStepValue());
 1033         EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub");
 1034         EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
 1035         EXPECT_EQ(Bounds->getDirection(),
 1084             dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
 1086         EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
 1088             dyn_cast_or_null<ConstantInt>(Bounds->getStepValue());
 1090         EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub");
 1091         EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
 1092         EXPECT_EQ(Bounds->getDirection(),
 1154             dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
 1156         EXPECT_EQ(Bounds->getStepInst().getName(), "inc.outer");
 1158             dyn_cast_or_null<ConstantInt>(Bounds->getStepValue());
 1160         EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub");
 1161         EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
 1162         EXPECT_EQ(Bounds->getDirection(),
 1179             dyn_cast<ConstantInt>(&InnerBounds->getInitialIVValue());
 1181         EXPECT_EQ(InnerBounds->getStepInst().getName(), "inc");
 1182         StepValue = dyn_cast_or_null<ConstantInt>(InnerBounds->getStepValue());
 1184         EXPECT_EQ(InnerBounds->getFinalIVValue().getName(), "ub");
 1185         EXPECT_EQ(InnerBounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
 1186         EXPECT_EQ(InnerBounds->getDirection(),
 1245             dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
 1247         EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
 1249             dyn_cast_or_null<ConstantInt>(Bounds->getStepValue());
 1251         EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub");
 1252         EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
 1253         EXPECT_EQ(Bounds->getDirection(),

 1725       auto ExtDiff = ConstantDiffOrNone->getSExtValue();

  422                       MemberPointer.MemberInfo->ContainingType);
  459                       MemberPointer.MemberInfo->ContainingType);

  252   BlockDataOpt = FormValue->getAsBlock();
  260   BlockDataOpt = FormValue->getAsBlock();
  268   BlockDataOpt = FormValue->getAsBlock();
  276   BlockDataOpt = FormValue->getAsBlock();
  286     BlockDataOpt = FormValue->getAsBlock();
 1060   EXPECT_EQ(0u, Form2->getRawUValue());
 1067   EXPECT_EQ(1u, Form3->getRawUValue());
 1792     EXPECT_EQ(FormValue->getForm(), dwarf::DW_FORM_implicit_const);
 1794     const auto V = FormValue->getAsSignedConstant();
 1837     const auto V = FormValue->getAsSignedConstant();

   98   FI.OptLineTable->push(LineEntry(StartAddr,FileIdx,Line));
  134   FIWithLines.OptLineTable->push(LineEntry(StartAddr,FileIdx,Line));
  141   FIWithLinesAndInline.Inline->Ranges.insert(
  150   FIWithMoreLines.OptLineTable->push(LineEntry(StartAddr,FileIdx,Line+5));
  156   FIWithLinesWithHigherAddress.OptLineTable->get(0).Addr += 0x10;
  265     FI.OptLineTable->push(Line0);
  266     FI.OptLineTable->push(Line1);
  267     FI.OptLineTable->push(Line2);
  273     FI.Inline->Ranges.insert(AddressRange(FuncAddr, FuncAddr + FuncSize));
  279     FI.Inline->Children.push_back(Inline1);
  419   ASSERT_EQ(InlineInfos->size(), 1u);
  420   ASSERT_EQ(*InlineInfos->at(0), Inline1);
  423   ASSERT_EQ(InlineInfos->size(), 1u);
  424   ASSERT_EQ(*InlineInfos->at(0), Inline1);
  430   ASSERT_EQ(InlineInfos->size(), 2u);
  431   ASSERT_EQ(*InlineInfos->at(0), Inline1Sub1);
  432   ASSERT_EQ(*InlineInfos->at(1), Inline1);
  435   ASSERT_EQ(InlineInfos->size(), 2u);
  436   ASSERT_EQ(*InlineInfos->at(0), Inline1Sub1);
  437   ASSERT_EQ(*InlineInfos->at(1), Inline1);
  443   ASSERT_EQ(InlineInfos->size(), 2u);
  444   ASSERT_EQ(*InlineInfos->at(0), Inline1Sub2);
  445   ASSERT_EQ(*InlineInfos->at(1), Inline1);
  448   ASSERT_EQ(InlineInfos->size(), 2u);
  449   ASSERT_EQ(*InlineInfos->at(0), Inline1Sub2);
  450   ASSERT_EQ(*InlineInfos->at(1), Inline1);

  159   cantFail(BazR->notifyResolved({{Baz, BazSym}}));
  160   cantFail(BazR->notifyEmitted());
  376   FooR->addDependenciesForAll({{&JD, SymbolNameSet({Foo})}});
  377   EXPECT_THAT_ERROR(FooR->notifyResolved({{Foo, FooSym}}), Succeeded())
  379   EXPECT_THAT_ERROR(FooR->notifyEmitted(), Succeeded())
  477   FooR->addDependenciesForAll({{&JD, SymbolNameSet({Bar})}});
  478   BarR->addDependenciesForAll({{&JD, SymbolNameSet({Baz})}});
  479   BazR->addDependenciesForAll({{&JD, SymbolNameSet({Foo})}});
  483   FooR->addDependenciesForAll({{&JD, SymbolNameSet({Foo})}});
  484   BarR->addDependenciesForAll({{&JD, SymbolNameSet({Bar})}});
  485   BazR->addDependenciesForAll({{&JD, SymbolNameSet({Baz})}});
  493   EXPECT_THAT_ERROR(FooR->notifyResolved({{Foo, FooSym}}), Succeeded())
  495   EXPECT_THAT_ERROR(BarR->notifyResolved({{Bar, BarSym}}), Succeeded())
  497   EXPECT_THAT_ERROR(BazR->notifyResolved({{Baz, BazSym}}), Succeeded())
  510   EXPECT_THAT_ERROR(FooR->notifyEmitted(), Succeeded())
  512   EXPECT_THAT_ERROR(BarR->notifyEmitted(), Succeeded())
  521   EXPECT_THAT_ERROR(BazR->notifyEmitted(), Succeeded())
  567   FooR->addDependenciesForAll({{&JD, SymbolNameSet({Bar})}});
  570   BarR->failMaterialization();
  577   EXPECT_THAT_ERROR(FooR->notifyResolved({{Foo, FooSym}}), Failed())
  580   FooR->failMaterialization();
  630   FooR->addDependenciesForAll({{&JD, SymbolNameSet({Bar})}});
  631   BarR->addDependenciesForAll({{&JD, SymbolNameSet({Foo})}});
  634   BarR->failMaterialization();
  641   EXPECT_THAT_ERROR(FooR->notifyResolved({{Foo, FooSym}}), Failed())
  644   FooR->failMaterialization();
  694   BarR->failMaterialization();
  702   FooR->addDependenciesForAll({{&JD, SymbolNameSet({Bar})}});
  705   EXPECT_THAT_ERROR(FooR->notifyResolved({{Foo, FooSym}}), Failed())
  708   FooR->failMaterialization();
  758   FooR->addDependenciesForAll({{&JD, SymbolNameSet({Bar})}});
  759   BarR->addDependenciesForAll({{&JD, SymbolNameSet({Foo})}});
  762   EXPECT_THAT_ERROR(FooR->notifyResolved({{Foo, FooSym}}), Succeeded())
  764   EXPECT_THAT_ERROR(FooR->notifyEmitted(), Succeeded())
  768   BarR->failMaterialization();

  232   EXPECT_EQ(UpdateC->Action, CFGBuilder::ActionKind::Delete);
  233   EXPECT_EQ(UpdateC->Edge.From, "c");
  234   EXPECT_EQ(UpdateC->Edge.To, "d");

  696     EXPECT_EQ(LastUpdate->Action, Insert);
  697     BasicBlock *From = B.getOrAddBlock(LastUpdate->Edge.From);
  698     BasicBlock *To = B.getOrAddBlock(LastUpdate->Edge.To);
  723   EXPECT_EQ(LastUpdate->Action, Insert);
  724   BasicBlock *From = B.getOrAddBlock(LastUpdate->Edge.From);
  725   BasicBlock *To = B.getOrAddBlock(LastUpdate->Edge.To);
  750     EXPECT_EQ(LastUpdate->Action, Insert);
  751     BasicBlock *From = B.getOrAddBlock(LastUpdate->Edge.From);
  752     BasicBlock *To = B.getOrAddBlock(LastUpdate->Edge.To);
  772   EXPECT_EQ(LastUpdate->Action, Insert);
  773   BasicBlock *From = B.getOrAddBlock(LastUpdate->Edge.From);
  774   BasicBlock *To = B.getOrAddBlock(LastUpdate->Edge.To);
  801     EXPECT_EQ(LastUpdate->Action, Insert);
  802     BasicBlock *From = B.getOrAddBlock(LastUpdate->Edge.From);
  803     BasicBlock *To = B.getOrAddBlock(LastUpdate->Edge.To);
  831       EXPECT_EQ(LastUpdate->Action, Insert);
  832       BasicBlock *From = B.getOrAddBlock(LastUpdate->Edge.From);
  833       BasicBlock *To = B.getOrAddBlock(LastUpdate->Edge.To);
  858     EXPECT_EQ(LastUpdate->Action, Delete);
  859     BasicBlock *From = B.getOrAddBlock(LastUpdate->Edge.From);
  860     BasicBlock *To = B.getOrAddBlock(LastUpdate->Edge.To);
  884     EXPECT_EQ(LastUpdate->Action, Delete);
  885     BasicBlock *From = B.getOrAddBlock(LastUpdate->Edge.From);
  886     BasicBlock *To = B.getOrAddBlock(LastUpdate->Edge.To);
  914     BasicBlock *From = B.getOrAddBlock(LastUpdate->Edge.From);
  915     BasicBlock *To = B.getOrAddBlock(LastUpdate->Edge.To);
  916     if (LastUpdate->Action == Insert) {
  952       BasicBlock *From = B.getOrAddBlock(LastUpdate->Edge.From);
  953       BasicBlock *To = B.getOrAddBlock(LastUpdate->Edge.To);
  954       if (LastUpdate->Action == Insert) {

  142   R.Loc->SourceFilePath = "path";
  143   R.Loc->SourceLine = 99;
  144   R.Loc->SourceColumn = 55;
  231   R.Args.back().Loc->SourceFilePath = "path";
  232   R.Args.back().Loc->SourceLine = 99;
  233   R.Args.back().Loc->SourceColumn = 55;
  262   R.Loc->SourceFilePath = "path";
  263   R.Loc->SourceLine = 99;
  264   R.Loc->SourceColumn = 55;
  270   R.Args.back().Loc->SourceFilePath = "argpath";
  271   R.Args.back().Loc->SourceLine = 11;
  272   R.Args.back().Loc->SourceColumn = 66;
  312   R.Loc->SourceFilePath = "path";
  313   R.Loc->SourceLine = 99;
  314   R.Loc->SourceColumn = 55;
  320   R.Args.back().Loc->SourceFilePath = "argpath";
  321   R.Args.back().Loc->SourceLine = 11;
  322   R.Args.back().Loc->SourceColumn = 66;

  105   EXPECT_NE(R.Loc->SourceFilePath.data(), R2.Loc->SourceFilePath.data());
  105   EXPECT_NE(R.Loc->SourceFilePath.data(), R2.Loc->SourceFilePath.data());
  108   EXPECT_NE(R.Args.back().Loc->SourceFilePath.data(),
  109             R2.Args.back().Loc->SourceFilePath.data());
  115   EXPECT_EQ(StrTab.add(R.Loc->SourceFilePath).second.data(),
  116             R2.Loc->SourceFilePath.data());
  121   EXPECT_EQ(StrTab.add(R.Args.back().Loc->SourceFilePath).second.data(),
  122             R2.Args.back().Loc->SourceFilePath.data());

   74   EXPECT_STREQ(Stub->SoName->c_str(), "test.so");

  123             (!Regexpr || Regexpr->match(InstName.substr(Prefix.size())))) {
  150         if (!Regexpr || Regexpr->match(InstName.substr(Prefix.size()))) {

 1603     addPredicate<PointerToAnyOperandMatcher>(OpTyOrNone->get().getSizeInBits());
 1606                                                  OpTyOrNone->get().getSizeInBits()));
 3588             llvm::alignTo(MemTyOrNone->get().getSizeInBits(), 8);
 5005       if (!RuleCoverage->parse(*RuleCoverageBufOrErr.get(), Target.getName())) {
 5043       if (RuleCoverage->isCovered(MatcherOrErr->getRuleID()))