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

References

  148   addMainFunction(Mod.get());

  111   Module *M = Owner.get();

   67   Module *M = Owner.get();

   31                        Function::ExternalLinkage, "add1", M.get());

  769     VariableExprAST *LHSE = static_cast<VariableExprAST *>(LHS.get());
  995     ExprAST *Init = VarNames[i].second.get();
 1042       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());

  769     VariableExprAST *LHSE = static_cast<VariableExprAST *>(LHS.get());
  995     ExprAST *Init = VarNames[i].second.get();
 1042       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());

  134     auto FPM = std::make_unique<legacy::FunctionPassManager>(M.get());

  768     VariableExprAST *LHSE = static_cast<VariableExprAST *>(LHS.get());
  994     ExprAST *Init = VarNames[i].second.get();
 1041       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());

  210     auto FPM = std::make_unique<legacy::FunctionPassManager>(M.get());

  754     VariableExprAST *LHSE = static_cast<VariableExprAST *>(LHS.get());
  980     ExprAST *Init = VarNames[i].second.get();
 1027       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());

  227     auto FPM = std::make_unique<legacy::FunctionPassManager>(M.get());

  778     VariableExprAST *LHSE = static_cast<VariableExprAST *>(LHS.get());
 1004     ExprAST *Init = VarNames[i].second.get();
 1051       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());

  473       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());

  501       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());
  557   TheFPM = std::make_unique<legacy::FunctionPassManager>(TheModule.get());

  775       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());
  831   TheFPM = std::make_unique<legacy::FunctionPassManager>(TheModule.get());

  887       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());
  950   TheFPM = std::make_unique<legacy::FunctionPassManager>(TheModule.get());

  774     VariableExprAST *LHSE = static_cast<VariableExprAST *>(LHS.get());
 1000     ExprAST *Init = VarNames[i].second.get();
 1047       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());
 1118   TheFPM = std::make_unique<legacy::FunctionPassManager>(TheModule.get());

  773     VariableExprAST *LHSE = static_cast<VariableExprAST *>(LHS.get());
  999     ExprAST *Init = VarNames[i].second.get();
 1046       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());

  932     VariableExprAST *LHSE = static_cast<VariableExprAST *>(LHS.get());
 1164     ExprAST *Init = VarNames[i].second.get();
 1213       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());
 1283   KSDbgInfo.emitLocation(Body.get());

  263   Module *M = Owner.get();

  124     return I->second.get();
  131     return I->second.get();
  139     return CallsExternalNode.get();
  464     return P.second.get();
  491     return P.second.get();

  531     return PtrRtChecking.get();
  572   const OptimizationRemarkAnalysis *getReport() const { return Report.get(); }

  739     return MA == LiveOnEntryDef.get();
  743     return LiveOnEntryDef.get();
  805     return It == PerBlockAccesses.end() ? nullptr : It->second.get();
  811     return It == PerBlockDefs.end() ? nullptr : It->second.get();
  938     MemorySSA &getMSSA() { return *MSSA.get(); }

  738       updateRegionTree(RI, SubR.get());

   80         RegionQueue.push_back(Child.get());
   98         RegionQueue.push_back(Child.get());
  371   return at->second.get();
  397                          return R.get() == SubRegion;
  421     if (SubRegion->contains(R.get()) && R.get() != SubRegion) {
  421     if (SubRegion->contains(R.get()) && R.get() != SubRegion) {
  441         return R.get() == Child;

  336     N.Map = Maps.back().get();
  344     N.Array = Arrays.back().get();

  103     return *Info.get();

  216     return NormalUnits[index].get();
  222     return DWOUnits[index].get();
  344   const MCRegisterInfo *getRegisterInfo() const { return RegInfo.get(); }

   94     NativeRawSymbol *NRS = static_cast<NativeRawSymbol *>(Result.get());

  493                                      Init, GVsM.get());
  670                                   M.get());

   61   LLVMContext *getContext() { return S ? S->Ctx.get() : nullptr; }
   65   const LLVMContext *getContext() const { return S ? S->Ctx.get() : nullptr; }
  150   Module *getModuleUnlocked() { return M.get(); }
  153   const Module *getModuleUnlocked() const { return M.get(); }

  877       if (N.get() == Replacement)

  677   inline ValueSymbolTable *getValueSymbolTable() { return SymTab.get(); }
  679     return SymTab.get();

  508   GVMaterializer *getMaterializer() const { return Materializer.get(); }

  689   const TypeIdInfo *getTypeIdInfo() const { return TIdInfo.get(); };
 1013         dyn_cast<FunctionSummary>(V.getSummaryList().front().get());
 1041           !isa<FunctionSummary>(S.second.SummaryList.front().get()))
 1184     return Summary->get();
 1340         ModuleToDefinedGVSummaries[Summary->modulePath()][GUID] = Summary.get();

  239         if (auto *FSum = dyn_cast<FunctionSummary>(Sum.get())) {

  505       auto *P = Passes[Idx].get();

  286   MCAsmBackend *getBackendPtr() const { return Backend.get(); }
  288   MCCodeEmitter *getEmitterPtr() const { return Emitter.get(); }
  290   MCObjectWriter *getWriterPtr() const { return Writer.get(); }

  665     raw_fd_ostream *getSecureLog() { return SecureLog.get(); }

  266     return TargetStreamer.get();

  224   return Bin.get();
  228   return Bin.get();

  100   const Arg* getAlias() const { return Alias.get(); }

  174     assert(Symtab.get());
  175     return *Symtab.get();
  228     assert(Symtab.get());
  229     return *Symtab.get();
  516       return *(CS_Summary.get());
  519       return *(Summary.get());

  397   ProfileSummary &getSummary() const { return *(Summary.get()); }
  399   MemoryBuffer *getBuffer() const { return Buffer.get(); }
  686         GcovBuffer(Buffer.get()) {}

  272   assert(isa<X>(Val.get()) && "cast<Ty>() argument of incompatible type!");

   89     Children.push_back(C.get());
  331       return I->second.get();
  574                 std::make_unique<DomTreeNodeBase<NodeT>>(BB, IDomNode))).get();
  588       std::make_unique<DomTreeNodeBase<NodeT>>(BB, nullptr)).get();

  190         .get();
  590         .get();
  667               .get();
 1308       const TreeNodePtr TN = NodeToTN.second.get();
 1341       const TreeNodePtr TN = NodeToTN.second.get();
 1396       const TreeNodePtr Node = NodeToTN.second.get();
 1509       const TreeNodePtr TN = NodeToTN.second.get();
 1542       const TreeNodePtr TN = NodeToTN.second.get();

  134     return Buffers[i - 1].Buffer.get();

  609     Entry *getLastContent() const { return Contents.back().get(); }

  605   Document &operator*() { return *Doc->get(); }

 1709     return I == Classes.end() ? nullptr : I->second.get();
 1714     return I == Defs.end() ? nullptr : I->second.get();

  189   const MCAsmInfo *getMCAsmInfo() const { return AsmInfo.get(); }
  191   const MCRegisterInfo *getMCRegisterInfo() const { return MRI.get(); }
  192   const MCInstrInfo *getMCInstrInfo() const { return MII.get(); }
  193   const MCSubtargetInfo *getMCSubtargetInfo() const { return STI.get(); }

  267     return I->second.get();

   70     Node->addCalledFunction(nullptr, CallsExternalNode.get());
   81           Node->addCalledFunction(Call, CallsExternalNode.get());
   96     Nodes.push_back(I.second.get());
  150     return CGN.get();
  154   return CGN.get();

  201   dumpExampleDependence(OS, info.get());

 2406   return *LAI.get();

  529         const IndexedReference &Representative = *RefGroup.front().get();
  608   const IndexedReference *Representative = RG.front().get();

 1019   MDs.push_back(TempNode.get());

 1094     AccessList *Accesses = It->second.get();
 1118     AccessList *Accesses = It->second.get();
 1202     AccessList *Accesses = It->second.get();
 1204     Phi->addIncoming(LiveOnEntryDef.get(), BB);
 1217       UseOrDef->setDefiningAccess(LiveOnEntryDef.get());
 1253   return Res.first->second.get();
 1261   return Res.first->second.get();
 1548   renamePass(DT->getRootNode(), LiveOnEntryDef.get(), Visited);
 1565     return Walker.get();
 1572       std::make_unique<CachingWalker<AliasAnalysis>>(this, WalkerBase.get());
 1573   return Walker.get();
 1578     return SkipWalker.get();
 1585       std::make_unique<SkipSelfWalker<AliasAnalysis>>(this, WalkerBase.get());
 1586   return SkipWalker.get();

  772     return I.get();

  625   AS->setAliasee(AliaseeVI, AliaseeVI.getSummaryList()[0].get());
  745       BFI = BFIPtr.get();
  804     if (auto *FuncSummary = dyn_cast<FunctionSummary>(Summary.get())) {

   43   BFI = OwnedBFI.get();

 3799   return CouldNotCompute.get();
 6917       Preds->add(ENT.Predicate.get());

  692   Result = FwdRef.first.get();
  985     NumberedVals.push_back(GA.get());
  996     GVal->replaceAllUsesWith(GA.get());
 1002     M->getAliasList().push_back(cast<GlobalAlias>(GA.get()));
 1004     M->getIFuncList().push_back(cast<GlobalIFunc>(GA.get()));
 7956       AliaseeRef.first->setAliasee(VI, Summary.get());
 8220     FwdRef.first->second.push_back(std::make_pair(AS.get(), Loc));

   47   if (parseAssemblyInto(F, M.get(), nullptr, Err, Slots, UpgradeDebugInfo,
   78   if (parseAssemblyInto(F, M.get(), Index.get(), Err, Slots, UpgradeDebugInfo,
   78   if (parseAssemblyInto(F, M.get(), Index.get(), Err, Slots, UpgradeDebugInfo,

 6058       LastSeenSummary = FS.get();
 6074       LastSeenSummary = AS.get();
 6103       LastSeenSummary = FS.get();
 6470           R->parseBitcodeInto(M.get(), ShouldLazyLoadMetadata, IsImporting))

  326   return Ref.get();
  343   return OldTypeRefs.Arrays.back().second.get();

  195         if (auto FS = dyn_cast<FunctionSummary>(Summary.get()))
  455           Callback({Summaries.first, Summary.get()}, false);
 3690   auto *Summary = VI.getSummaryList()[0].get();
 3847     auto *Summary = VI.getSummaryList()[0].get();

  564         DD.useSplitDwarf() ? CU.value()->getSkeleton() : CU.value().get();

 1037       MDT = OwnedMDT.get();
 1045       MLI = OwnedMLI.get();
 3060     return GCPI->second.get();
 3071       return IterBool.first->second.get();
 3163     Sled.emit(WordSizeBytes, OutStreamer.get(), CurrentFnSym);

   84       DiagInfo->SrcMgr.setDiagHandler(srcMgrDiagHandler, DiagInfo.get());
  155   Parser->setTargetParser(*TAP.get());

 1335   CurFn = Insertion.first->second.get();
 2760       GI != ScopeGlobals.end() ? GI->second.get() : nullptr;
 2833   assert(CurFn == FnDebugInfo[&GV].get());
 3016         VariableList = Insertion.first->second.get();

 1071     return I->second.get();
 1082     DU->addScopeVariable(Scope, cast<DbgVariable>(Entity.get()));
 1086     DU->addScopeLabel(Scope, cast<DbgLabel>(Entity.get()));

  256   assert(!ValueLoc.get() && "Already initialized?");
  287   assert(DebugLocListIndex == ~0U && !ValueLoc.get() && "not an MMI entry");
  288   assert(V.DebugLocListIndex == ~0U && !V.ValueLoc.get() && "not an MMI entry");
 1039     Unit->finishEntityDefinition(Entity.get());
 1287     else if (InfoHolder.addScopeVariable(Scope, RegVar.get())) {
 1288       MFVars.insert({Var, RegVar.get()});
 1496         cast<DbgVariable>(ConcreteEntities.back().get()));
 1502         cast<DbgLabel>(ConcreteEntities.back().get()));
 1504   return ConcreteEntities.back().get();
 2955       InfoHolder.computeSizeAndOffsetsForUnit(TU.first.get());
 2956       InfoHolder.emitUnit(TU.first.get(), useSplitDwarf());

  142     assert(!ValueLoc.get() && "Already initialized?");
  171     assert(ValueLoc.get() && FrameIndexExprs.size() <= 1);
  178   const DbgValueLoc *getValueLoc() const { return ValueLoc.get(); }
  211     assert(ValueLoc.get() && "Expected DBG_VALUE, not MMI variable");

   34     emitUnit(TheU.get(), UseOffsets);
   76     SecOffset += computeSizeAndOffsetsForUnit(TheU.get());

  472     *BranchBB, *DestBB, DL, DestOffset - SrcOffset, RS.get());

 2725   return !Actions.empty() ? Actions.back().get() : nullptr;
 2737   while (!Actions.empty() && Point != Actions.back().get()) {

   76   GCFunctionInfo *GFI = Functions.back().get();
  156       GCStrategyMap[Name] = S.get();
  158       return GCStrategyList.back().get();

  217   assert(CSEOpt.get() && "CSEConfig not set");

  119   MachineIRBuilder &B = *Builder.get();

 2310   if (!CLI->lowerFormalArguments(*EntryBuilder.get(), F, VRegArgs)) {

  202   LegalizerHelper Helper(MF, WrapperObserver, *MIRBuilder.get());
  204   LegalizationArtifactCombiner ArtCombiner(*MIRBuilder.get(), MF.getRegInfo(),

   78       MDT = OwnedMDT.get();
   84     MLI = OwnedMLI.get();
   89   return *OwnedMBFI.get();

  582   return UVEntry = userValues.back().get();

 1731       Context = CtxPtr.get();

  267   return I != MachineFunctions.end() ? I->second.get() : nullptr;
  287     MF = I.first->second.get();

   47     codegen(M.get(), *OSs[0], TMFactory, FileType);
   88                 codegen(MPartInCtx.get(), *ThreadOS, TMFactory, FileType);

   74   if (!HazardRec.get())

  133   return V.get();
  142   return E.get();
  151   return E.get();

  504       updateSaveRestorePoints(MBB, RS.get());
  513       if (!useOrDefCSROrFI(MI, RS.get()))
  517       updateSaveRestorePoints(MBB, RS.get());
  571     updateSaveRestorePoints(*NewBB, RS.get());

  655   SymbolDeserializer Deserializer(ObjDelegate.get(), Container);
  656   CVSymbolDumperImpl Dumper(Types, ObjDelegate.get(), W, CompilationCPUType,
  669   SymbolDeserializer Deserializer(ObjDelegate.get(), Container);
  670   CVSymbolDumperImpl Dumper(Types, ObjDelegate.get(), W, CompilationCPUType,

  636       return dyn_cast<DWARFCompileUnit>(DWOCU.get());
  695     return Abbrev.get();
  701   return Abbrev.get();
  706     return AbbrevDWO.get();
  711   return AbbrevDWO.get();
  716     return Loc.get();
  725   return Loc.get();
  730     return LocDWO.get();
  741   return LocDWO.get();
  746     return Aranges.get();
  750   return Aranges.get();
  755     return DebugFrame.get();
  770   return DebugFrame.get();
  775     return EHFrame.get();
  781   return DebugFrame.get();
  786     return Macro.get();
  791   return Macro.get();
 1227     DWARFContext *Ctxt = S->Context.get();
 1234     DWARFContext *Ctxt = S->Context.get();
 1269   auto *Ctxt = S->Context.get();

  469       CIEs[StartOffset] = Cie.get();
  539     return It->get();

  126   return this->insert(I, std::move(Unit))->get();
  137     return CU->get();
  156     return CU->get();
  165   auto *NewCU = U.get();

  668     auto LineTable = DCtx.getLineTableForUnit(CU.get());
  703     auto LineTable = DCtx.getLineTableForUnit(CU.get());
 1454       auto *CU = cast<DWARFCompileUnit>(U.get());

   52   if (!MemBuffer.get())

  240   NativeRawSymbol *NRS = Cache[SymbolId].get();

   41   if (auto Func = dyn_cast_or_null<PDBSymbolFunc>(Symbol.get())) {
   43   } else if (auto Data = dyn_cast_or_null<PDBSymbolData>(Symbol.get())) {
  106   auto *Func = dyn_cast_or_null<PDBSymbolFunc>(FuncSymbol.get());
  114     if (auto *PS = dyn_cast_or_null<PDBSymbolPublicSymbol>(PublicSym.get())) {

  105   SymbolPtr->RawSymbol = RawSymbol.get();

   85   if (auto Builtin = llvm::dyn_cast_or_null<PDBSymbolTypeBuiltin>(Last.get())) {

   69     : LayoutItemBase(&Parent, Member.get(), Member->getName(),
   82     : LayoutItemBase(&Parent, Sym.get(), "<vbptr>", Offset, Size, false),
   98     : LayoutItemBase(&Parent, VT.get(), "<vtbl>", 0, getTypeLength(*VT), false),
  211     AllBases.push_back(BL.get());
  221     VTable = VTLayout.get();
  241         VBPtr = VBPL.get();
  254     AllBases.push_back(BL.get());
  297       LayoutItems.insert(Loc, Child.get());

   75     res->addSymbol(P.first, P.second, OpdExtractor.get(), OpdAddress);
  249          isa<DWARFContext>(DebugInfoContext.get());

   67     return symbolizeCodeCommon(I->second.get(), ModuleOffset);
  388       return I->second.get();
  397     ObjectFile *Res = ObjOrErr->get();
  422   return InsertResult.first->second.get();
  429     return I->second.get();

  145     Module *Found = I->get();

   76   auto *TmpCtx = Ctx.get();

  293   TargetMachine *getTargetMachine() override { return TM.get(); }

  740                             return H.get() == &G;
 1667         OS << I->second->MU.get() << ")\n";
 1835         return JD.get();

  235         CODLayer(createCODLayer(ES, CompileLayer, CCMgr.get(),

  317       if (I->get() == M)

  131     MemMgr = MemMgrs.back().get();

   63     RS.sample(Strategy.get(),

  841   Machine = MachineStorage.get();
 2318       Machine = MachineStorage.get();
 2706       SummaryToGUIDMap[Summary.get()] = GUID;

  650   return Slot.get();
  836   return Slot.get();
 1165   return pImpl->TheNoneToken.get();
 1372   return Entry.get();
 1438   return Entry.get();
 1451   return Entry.get();

  300   Args.push_back(TempNode.get());

  146   return pImpl->RemarkDiagStreamer.get();
  326   return pImpl->DiagHandler.get();

  157   SmallVector<Metadata *, 3> Args(1, Dummy.get());

   71       auto *Summary = dyn_cast_or_null<FunctionSummary>(GlobSummary.get());
   91   return Summary.get();
  102     if (isGlobalValueLive(I.get()))
  160       if (!isGlobalValueLive(S.get()))
  176         if (!canImportGlobalVar(S.get()) ||
  181       propagateAttributesToRefs(S.get());
  208         F = cast<FunctionSummary>(V.getSummaryList().front().get());

  143   return T.get();
  181   return *(Pair.first->second.get());
  201     const Timer *MyTimer = I.second.get();
  208     const Timer *MyTimer = I.second.get();

  323     if (isPrevailing(VI.getGUID(), S.get())) {
  341     else if (!isa<AliasSummary>(S.get()) &&
  342              !GlobalInvolvedWithAlias.count(S.get()))
  368       if (auto AS = dyn_cast<AliasSummary>(S.get()))
  399                 isPrevailing(GUID, S.get())) &&
  409                !isWeakObjectWithRWAccess(S.get()))
  573     writeToResolutionFile(*Conf.ResolutionFile, Input.get(), Res);
  881       auto *FS = dyn_cast<FunctionSummary>(S.get());

  387               codegen(C, TM.get(), AddStream, ThreadId, *MPartInCtx);
  446     if (!opt(C, TM.get(), 0, *Mod, /*IsThinLTO=*/false,
  452     codegen(C, TM.get(), AddStream, 0, *Mod);
  454     splitCodeGen(C, TM.get(), AddStream, ParallelCodeGenParallelismLevel,
  501     codegen(Conf, TM.get(), AddStream, Task, Mod);
  541   if (!opt(Conf, TM.get(), Task, Mod, /*IsThinLTO=*/true,
  545   codegen(Conf, TM.get(), AddStream, Task, Mod);

   48   SymTab.addModule(Mod.get());

   37       auto S = GVS.get()->getBaseObject();
   55       auto S = V.getSummaryList().front().get()->getBaseObject();
   66       auto S = GVS.get()->getBaseObject();

  111     return StrongDefForLinker->get();
  122   return FirstDefForLinker->get();
  148     ModuleMap[M->getName()] = M.get();
  919         auto TheModule = loadModuleFromInput(Mod.get(), Context, false,
 1087         auto TheModule = loadModuleFromInput(Mod.get(), Context, false,

  226   ::el_set(Data->EL, EL_CLIENTDATA, Data.get());

 1939     Inst.dump_pretty(GetCommentOS(), InstPrinter.get(), "\n ");

  678   if (!CVContext.get())
  680   return *CVContext.get();

   77   std::unique_ptr<MCContext> Ctx(new MCContext(MAI.get(), MRI.get(), nullptr));
   77   std::unique_ptr<MCContext> Ctx(new MCContext(MAI.get(), MRI.get(), nullptr));
   93       TT, GetOpInfo, SymbolLookUp, DisInfo, Ctx.get(), std::move(RelInfo)));

  109   const MCDisassembler *getDisAsm() const { return DisAsm.get(); }
  110   const MCAsmInfo *getAsmInfo() const { return MAI.get(); }
  111   const MCInstrInfo *getInstrInfo() const { return MII.get(); }
  112   const MCRegisterInfo *getRegisterInfo() const { return MRI.get(); }
  113   const MCSubtargetInfo *getSubtargetInfo() const { return MSI.get(); }
  114   MCInstPrinter *getIP() { return IP.get(); }

   41     return Assembler.get();

  786     OS = NewOS.get();

  684   CurrentWinFrameInfo = WinFrameInfos.back().get();
  719   CurrentWinFrameInfo = WinFrameInfos.back().get();

  230     ::EmitUnwindInfo(Streamer, CFI.get());
  237     EmitRuntimeFunction(Streamer, CFI.get());
  662     ARM64EmitUnwindInfo(Streamer, CFI.get());
  669     ARM64EmitRuntimeFunction(Streamer, CFI.get());

  243   return Symbols.back().get();
  255   return Sections.back().get();
  559     Arr.push_back(Section.get());

   78     Stage *Last = Stages.back().get();
   79     Last->setNextInSequence(S.get());

   37   CurrentInstruction = InstRef(SR.first, Inst.get());

  405       T->createMCInstrAnalysis(MII.get()));

   32     SymTab.addModule(M.get());
  102     return findBitcodeInObject(*ObjFile->get());

  359     Mods.push_back(MOrErr->get());

  101   MCContext MCCtx(MAI.get(), MRI.get(), &MOFI);
  101   MCContext MCCtx(MAI.get(), MRI.get(), &MOFI);

   88         IRObjectFile::findBitcodeInObject(*Obj->get());

   43                                                 *Parent->ParsedFile.get(),

  269   TreeNode *TypeNode = TypeIt->second.get();
  275   TreeNode *NameNode = NameIt->second.get();
  297   TreeNode *FirstNode = FirstIt->second.get();
  300   TreeNode *LastNode = LastIt->second.get();
  519   Result = ElementInserted.first->second.get();
  906         DataEntriesTreeOrder.push_back(Child.second.get());
  913         Queue.push(Child.second.get());
  925         DataEntriesTreeOrder.push_back(Child.second.get());
  932         Queue.push(Child.second.get());

  677       parseStringTable(Obj.get(), CurOffset);

  381     ELFYAML::Section *Sec = Doc.Sections[I].get();
 1137     if (auto VerNeed = dyn_cast<ELFYAML::VerneedSection>(Sec.get())) {
 1143     } else if (auto VerDef = dyn_cast<ELFYAML::VerdefSection>(Sec.get())) {

 1130     sectionMapping(IO, *cast<ELFYAML::DynamicSection>(Section.get()));
 1136     sectionMapping(IO, *cast<ELFYAML::RelocationSection>(Section.get()));
 1141     groupSectionMapping(IO, *cast<ELFYAML::Group>(Section.get()));
 1146     sectionMapping(IO, *cast<ELFYAML::NoBitsSection>(Section.get()));
 1151     sectionMapping(IO, *cast<ELFYAML::HashSection>(Section.get()));
 1156     sectionMapping(IO, *cast<ELFYAML::NoteSection>(Section.get()));
 1161     sectionMapping(IO, *cast<ELFYAML::MipsABIFlags>(Section.get()));
 1166     sectionMapping(IO, *cast<ELFYAML::VerdefSection>(Section.get()));
 1171     sectionMapping(IO, *cast<ELFYAML::SymverSection>(Section.get()));
 1176     sectionMapping(IO, *cast<ELFYAML::VerneedSection>(Section.get()));
 1181     sectionMapping(IO, *cast<ELFYAML::SymtabShndxSection>(Section.get()));
 1186     sectionMapping(IO, *cast<ELFYAML::AddrsigSection>(Section.get()));
 1200     if (auto S = dyn_cast<ELFYAML::RawContentSection>(Section.get()))
 1203       sectionMapping(IO, *cast<ELFYAML::StackSizesSection>(Section.get()));
 1210           dyn_cast<ELFYAML::RawContentSection>(Section.get())) {
 1217   if (const auto *SS = dyn_cast<ELFYAML::StackSizesSection>(Section.get())) {
 1237   if (const auto *HS = dyn_cast<ELFYAML::HashSection>(Section.get())) {
 1260   if (const auto *Sec = dyn_cast<ELFYAML::AddrsigSection>(Section.get())) {
 1285   if (const auto *NS = dyn_cast<ELFYAML::NoteSection>(Section.get())) {

  553     if (auto S = dyn_cast<WasmYAML::CustomSection>(Sec.get()))
  562     if (auto S = dyn_cast<WasmYAML::CustomSection>(Sec.get()))
  564     else if (auto S = dyn_cast<WasmYAML::TypeSection>(Sec.get()))
  566     else if (auto S = dyn_cast<WasmYAML::ImportSection>(Sec.get()))
  568     else if (auto S = dyn_cast<WasmYAML::FunctionSection>(Sec.get()))
  570     else if (auto S = dyn_cast<WasmYAML::TableSection>(Sec.get()))
  572     else if (auto S = dyn_cast<WasmYAML::MemorySection>(Sec.get()))
  574     else if (auto S = dyn_cast<WasmYAML::GlobalSection>(Sec.get()))
  576     else if (auto S = dyn_cast<WasmYAML::EventSection>(Sec.get()))
  578     else if (auto S = dyn_cast<WasmYAML::ExportSection>(Sec.get()))
  580     else if (auto S = dyn_cast<WasmYAML::StartSection>(Sec.get()))
  582     else if (auto S = dyn_cast<WasmYAML::ElemSection>(Sec.get()))
  584     else if (auto S = dyn_cast<WasmYAML::CodeSection>(Sec.get()))
  586     else if (auto S = dyn_cast<WasmYAML::DataSection>(Sec.get()))
  588     else if (auto S = dyn_cast<WasmYAML::DataCountSection>(Sec.get()))

  173       auto CustomSection = cast<WasmYAML::CustomSection>(Section.get());
  181       sectionMapping(IO, *cast<WasmYAML::DylinkSection>(Section.get()));
  185       sectionMapping(IO, *cast<WasmYAML::LinkingSection>(Section.get()));
  189       sectionMapping(IO, *cast<WasmYAML::NameSection>(Section.get()));
  193       sectionMapping(IO, *cast<WasmYAML::ProducersSection>(Section.get()));
  197       sectionMapping(IO, *cast<WasmYAML::TargetFeaturesSection>(Section.get()));
  201       sectionMapping(IO, *cast<WasmYAML::CustomSection>(Section.get()));
  208     sectionMapping(IO, *cast<WasmYAML::TypeSection>(Section.get()));
  213     sectionMapping(IO, *cast<WasmYAML::ImportSection>(Section.get()));
  218     sectionMapping(IO, *cast<WasmYAML::FunctionSection>(Section.get()));
  223     sectionMapping(IO, *cast<WasmYAML::TableSection>(Section.get()));
  228     sectionMapping(IO, *cast<WasmYAML::MemorySection>(Section.get()));
  233     sectionMapping(IO, *cast<WasmYAML::GlobalSection>(Section.get()));
  238     sectionMapping(IO, *cast<WasmYAML::EventSection>(Section.get()));
  243     sectionMapping(IO, *cast<WasmYAML::ExportSection>(Section.get()));
  248     sectionMapping(IO, *cast<WasmYAML::StartSection>(Section.get()));
  253     sectionMapping(IO, *cast<WasmYAML::ElemSection>(Section.get()));
  258     sectionMapping(IO, *cast<WasmYAML::CodeSection>(Section.get()));
  263     sectionMapping(IO, *cast<WasmYAML::DataSection>(Section.get()));
  268     sectionMapping(IO, *cast<WasmYAML::DataCountSection>(Section.get()));

  246   return SynthesizedArgs.back().get();
  255   return SynthesizedArgs.back().get();
  264   return SynthesizedArgs.back().get();
  273   return SynthesizedArgs.back().get();

  262   Arg *RawA = A.get();

  682   if (auto *Universal = dyn_cast<MachOUniversalBinary>(Bin.get())) {
  689   } else if (isa<ObjectFile>(Bin.get())) {
  754   if (auto *Universal = dyn_cast<MachOUniversalBinary>(Bin.get())) {
  774   if (auto *Ar = dyn_cast<Archive>(Bin.get())) {

  189       GCOVEdge *Edge = Edges.back().get();

  888   memcpy(VPD.get(), D, TotalSize);

  389   if (Error E = createSymtab(*NewSymtab.get()))
  465   VDataPtrOrErr.get()->deserializeTo(Record, Symtab.get());
  762     uint64_t *Dst = reinterpret_cast<uint64_t *>(SummaryData.get());
  855   if (Symtab.get())
  856     return *Symtab.get();
  859   if (Error E = Index->populateSymtab(*NewSymtab.get())) {
  864   return *Symtab.get();

  161       Out.write((const char *)VDataPtr.get(), S);
  352   setSummary(TheSummary.get(), *PS);
  360     setSummary(TheCSSummary.get(), *CSPS);
  369       {SummaryOffset, reinterpret_cast<uint64_t *>(TheSummary.get()),
  371       {CSSummaryOffset, reinterpret_cast<uint64_t *>(TheCSSummary.get()),

 1309   if (Error E = Remappings->read(*B.get())) {

   99       static_cast<raw_string_ostream *>(LocalBufStream.get())->str();

  842   return NumericVariables.back().get();
  850   return Substitutions.back().get();
  858   return Substitutions.back().get();
 1156         FileCheckPattern(Check::CheckNot, PatternContext.get()));
 1219     FileCheckPattern P(CheckTy, PatternContext.get(), LineNumber);
 1264         FileCheckPattern(Check::CheckEOF, PatternContext.get(), LineNumber + 1),

  108     if (!parse(FileOrErr.get().get(), Sections, ParseError)) {

  562   llvm::MemoryBuffer *getBuffer() const { return Buffer.get(); }
  639       return I->second.get();
  645         .first->second.get();
  713   detail::InMemoryDirectory *Dir = Root.get();
  852   auto FromNode = lookupInMemoryNode(*this, Root.get(), FromPath);
  853   auto ToNode = lookupInMemoryNode(*this, Root.get(), ToPath);
  863   auto Node = lookupInMemoryNode(*this, Root.get(), Path);
  871   auto Node = lookupInMemoryNode(*this, Root.get(), Path);
  936   auto Node = lookupInMemoryNode(*this, Root.get(), Dir);
 1112     dumpEntry(OS, Root.get());
 1130       dumpEntry(OS, SubEntry.get(), NumSpaces + 2);
 1220           ParentEntry = Root.get();
 1231                 Content.get());
 1246       ParentEntry = FS->Roots.back().get();
 1270         uniqueOverlayTree(FS, SubEntry.get(), NewParentE);
 1575       uniqueOverlayTree(FS, E.get());
 1618   if (!P.parse(Root, FS.get()))
 1648         lookupPath(Start, End, Root.get());
 1694         lookupPath(Start, End, DirEntry.get());
 1835       getVFSEntries(SubEntry.get(), Path, Entries);

  101     CurrentNode = TopNode.get();
  173   HNode *Value = MN->Mapping[Key].get();
  199       setError(NN.second.get(), Twine("unknown key '") + NN.first() + "'");
  232     CurrentNode = SQ->Entries[Index].get();
  249     CurrentNode = SQ->Entries[index].get();
  308       if (ScalarHNode *SN = dyn_cast<ScalarHNode>(N.get())) {
  331         setError(SQ->Entries[i].get(), "unknown bit value");

 1622     Record *NewRec = NewRecOwner.get();
 2366       Defs.push_back(D.second.get());

  293     return AddSubClass(Entry.Rec.get(), SubClass);
  420       MapResolver R(Rec.get());
  541     if (MultiClasses[Lex.getCurStrVal()].get())
  563   MultiClass *Result = MultiClasses[Lex.getCurStrVal()].get();
 1334       ParseRec = ParseRecTmp.get();
 1601       ParseRec = ParseRecTmp.get();
 2642     return ApplyLetStack(Entry.Rec.get());
 2710   if (ParseObjectBody(CurRec.get()))
 2839     CurRec = NewRec.get();
 2971   CurMultiClass = Result.first->second.get();
 3076     MultiClass *MC = MultiClasses[Ref.Rec->getName()].get();

  358     EC.insert(I.get());
  363         EC.unionSets(I.get(), J.get());
  363         EC.unionSets(I.get(), J.get());
  620     ActiveChains[DestReg] = G.get();
  665     ActiveChains[DestReg] = G.get();

  595     DT = DeleteDT.get();
  605     PDT = DeletePDT.get();

  196   return CallLoweringInfo.get();
  200   return InstSelector.get();
  204   return Legalizer.get();
  208   return RegBankInfo.get();

  326   return I.get();

   49     return TLOF.get();

 3493   auto Ext = static_cast<AArch64Operand*>(ExtOpnd.back().get());
 5704   auto Ext = static_cast<AArch64Operand *>(ExtOpnd.back().get());

 1019   if (auto *MF = dyn_cast<AMDGPUMangledLibFunc>(F.Impl.get()))
 1021   else if (auto *UMF = dyn_cast<AMDGPUUnmangledLibFunc>(F.Impl.get()))
 1038       Id, *cast<AMDGPUMangledLibFunc>(CopyFrom.Impl.get())));
 1050   return cast<AMDGPUMangledLibFunc>(Impl.get())->Leads;
 1054   return cast<const AMDGPUMangledLibFunc>(Impl.get())->Leads;

  288   *this, *static_cast<AMDGPURegisterBankInfo *>(RegBankInfo.get()), TM));

  421     return CallLoweringInfo.get();
  425     return InstSelector.get();
  429     return Legalizer.get();
  433     return RegBankInfo.get();

  490   return I.get();
  528   return I.get();

   53     return TLOF.get();

  364   assert(R.BestSchedule.get() && "No schedule specified");
  523         if (R->BestSchedule.get() &&
  602       if (R->BestSchedule.get() &&

  880     return PSV.first->second.get();
  889     return PSV.first->second.get();
  898     return GWSResourcePSV.get();

 1232       CurrentBlocks.push_back(BlockPtrs.rbegin()->get());

 1241           PotentialMatches[PotentialMI].push_back(Operand.get());

   44     return TLOF.get();

  599     MulCandidate *PMul0 = static_cast<MulCandidate*>(Muls[i].get());
  607       MulCandidate *PMul1 = static_cast<MulCandidate*>(Muls[j].get());

  125   return CallLoweringInfo.get();
  129   return InstSelector.get();
  133   return Legalizer.get();
  137   return RegBankInfo.get();

  526     return InstrInfo.get();
  534     return FrameLowering.get();

  295   return I.get();

   61     return TLOF.get();

  548     ElfMappingSymbolInfo *EMS = LastEMSInfo.get();
  616       ElfMappingSymbolInfo *EMS = LastEMSInfo.get();

   40     return this->TLOF.get();

   70       static_cast<BPFMCAsmInfo *>(const_cast<MCAsmInfo *>(AsmInfo.get()));

   38     return TLOF.get();

  466   StructTypes.push_back(TypeEntry.get());
  572           Fixup.second.push_back(TypeEntry.get());
  651   StructTypes.push_back(TypeEntry.get());

  587       ErrorLoc = (static_cast<HexagonOperand *>(InstOperands[ErrorInfo].get()))

  249   return I.get();

   44     return static_cast<HexagonTargetObjectFile*>(TLOF.get());

  881     Type = static_cast<LanaiOperand *>(Operands[0].get())->getToken();
 1127           static_cast<LanaiOperand *>(Operands[PossibleAluOpIdx].get()))

   50     return TLOF.get();

   42     return TLOF.get();

 7049         std::make_unique<MipsAssemblerOptions>(AssemblerOptions.back().get()));

  277   return CallLoweringInfo.get();
  281   return Legalizer.get();
  285   return RegBankInfo.get();
  289   return InstSelector.get();

  374   const MipsInstrInfo *getInstrInfo() const override { return InstrInfo.get(); }
  376     return FrameLowering.get();
  382     return TLInfo.get();

  206   return I.get();

   63     return TLOF.get();

   63     return TLOF.get();

  600     Op->Tok.Data = reinterpret_cast<const char *>(Op.get() + 1);

  351   return I.get();

   54     return TLOF.get();

   66   return CallLoweringInfo.get();
   70   return InstSelector.get();
   74   return Legalizer.get();
   78   return RegBankInfo.get();

   40     return TLOF.get();

  139   return I.get();

   40     return TLOF.get();

   49     return TLOF.get();

  509       if (parseSignature(Signature.get()))
  517       WasmSym->setSignature(Signature.get());
  705       if (parseSignature(Signature.get()))
  707       WasmSym->setSignature(Signature.get());
  723       WasmSym->setSignature(Signature.get());

  108         Sym->setSignature(Signature.get());
  286   WasmSym->setSignature(Signature.get());

   99         return LoopMap[ML].get();
  101       return LoopMap[ML].get();
  105         return ExceptionMap[WE].get();
  108       return ExceptionMap[WE].get();

   62     WasmSym->setSignature(Signature.get());
  119   WasmSym->setSignature(Signature.get());
  173   WasmSym->setSignature(Signature.get());

  145   return I.get();

   45     return TLOF.get();

 3374     X86Operand *X86Op = static_cast<X86Operand *>(Op.get());
 3402     auto *X86Op = static_cast<X86Operand *>(Operands[1].get());

  229                               (const void *)MII.get(), Address, fMode);

  395   const FPOData *FPO = I->second.get();

  129     return MBBInfos[MBB->getNumber()].get();

  104   SMShadowTracker.count(Inst, getSubtargetInfo(), CodeEmitter.get());
 2497     SMShadowTracker.count(TmpInst, getSubtargetInfo(), CodeEmitter.get());

  359   return CallLoweringInfo.get();
  363   return InstSelector.get();
  367   return Legalizer.get();
  371   return RegBankInfo.get();

  316   return I.get();

   53     return TLOF.get();

   48     return TLOF.get();

  133   object::Archive Archive(B.get()->getMemBufferRef(), Err);

  185         auto *GVSummary = SummaryPtr.get();
  257   return cast<GlobalValueSummary>(It->get());
  307       if (isa<GlobalVarSummary>(RefSummary.get()) &&
  308           canImportGlobalVar(RefSummary.get()) &&
  309           !LocalNotInModule(RefSummary.get())) {
  823       if (auto *AS = dyn_cast<AliasSummary>(Summary.get())) {
  834       if (auto *FS = dyn_cast<FunctionSummary>(Summary.get()))
  862         if (auto *GVS = dyn_cast<GlobalVarSummary>(S.get())) {
 1158         auto *Fn = replaceAliasWithAliasee(SrcModule.get(), &GA);

  682     return *ORE.get();
  714     return *ORE.get();

  805     CallGraphNode *CGN = I.second.get();

   82     for (line_iterator I(*Buf->get(), true), E; I != E; ++I)

 2058         if (!ExportSummary->isGlobalValueLive(S.get()))

  403     BFI = ScopedBFI.get();
  670   if (!CheckAndNormalizeCandidate(OutliningInfo.get()))
  736   if (hasProfileData(Cloner.OrigFunc, Cloner.ClonedOI.get()))
  940         CurrentCallerBFI = TempBFI.get();
 1134                      ClonedFuncBFI.get(), &BPI,
 1219                     ClonedFuncBFI.get(), &BPI, LookupAC(*ClonedFunc),
 1283       FunctionCloner Cloner(F, OMRI.get(), ORE, LookupAssumptionCache);
 1316   FunctionCloner Cloner(F, OI.get(), ORE, LookupAssumptionCache);

 1111     findEquivalencesFor(BB1, DominatedBBs, PDT.get());
 1822     ORE = OwnedORE.get();

  471       Index = NewIndex.get();

  853     const auto *VS = cast<GlobalVarSummary>(P.VTableVI.getSummaryList()[0].get());
 1821         auto *FS = dyn_cast<FunctionSummary>(S.get());
 1942       auto *FS = dyn_cast<FunctionSummary>(S.get());

 1082                               !CI->isIdenticalTo(EmptyInlineAsm.get()) &&

   83     assert(It->second.get() != nullptr);
   84     return *It->second.get();
   92     return It->second.get();

   75     StringRef Buf = FileOrErr->get()->getBuffer();
   90     StringRef Buf = FileOrErr->get()->getBuffer();
 1001     Region *NextSubR = NextIt != R->end() ? NextIt->get() : nullptr;
 1002     CHR_DEBUG(dbgs() << "Looking at subregion " << SubR.get()->getNameStr()
 1004     CHRScope *SubCHRScope = findScopes(SubR.get(), NextSubR, R, Scopes);
 2083   return CHR(F, BFI, DT, PSI, RI, *OwnedORE.get()).run();

  407       ORE = OwnedORE.get();

  470     PGOCounterPromoter Promoter(LoopPromotionCandidates, *Loop, LI, BFI.get());

  727     EdgeList.push_back(E.get());
  743     SrcInfo.addOutEdge(E.get());
  744     DestInfo.addInEdge(E.get());
 1104       setEdgeCount(E.get(), SrcInfo.CountValue);
 1111         setEdgeCount(E.get(), DestInfo.CountValue);
 1117     setEdgeCount(E.get(), 0);
 1574     if (!Func.readCounters(PGOReader.get(), AllZeros))

  390                           CurAST.get(), MSSAU.get(), &SafetyInfo, Flags, ORE);
  390                           CurAST.get(), MSSAU.get(), &SafetyInfo, Flags, ORE);
  394                            CurAST.get(), MSSAU.get(), &SafetyInfo, Flags, ORE);
  394                            CurAST.get(), MSSAU.get(), &SafetyInfo, Flags, ORE);
  431       if (!CurAST.get())
  432         CurAST = collectAliasInfoForLoopWithMSSA(L, AA, MSSAU.get());
  453             DT, TLI, L, CurAST.get(), MSSAU.get(), &SafetyInfo, ORE);
  453             DT, TLI, L, CurAST.get(), MSSAU.get(), &SafetyInfo, ORE);
  478   if (!MSSAU.get() && CurAST.get() && L->getParentLoop() && !DeleteAST)
  478   if (!MSSAU.get() && CurAST.get() && L->getParentLoop() && !DeleteAST)
  481   if (MSSAU.get() && VerifyMemorySSA)

  699                                            Changed, MSSAU.get())
  741                                                Changed, MSSAU.get())
  754           FindLIVLoopCondition(SC, currentLoop, Changed, MSSAU.get());
  815                                                Changed, MSSAU.get())
  989       CriticalEdgeSplittingOptions(DT, LI, MSSAU.get()).setPreserveLCSSA();
 1015   BasicBlock *NewPH = SplitEdge(loopPreheader, loopHeader, DT, LI, MSSAU.get());
 1027       SplitBlock(ExitBlock, &ExitBlock->front(), DT, LI, MSSAU.get());
 1131                                            Changed, MSSAU.get())
 1166                                            Changed, MSSAU.get())
 1225     SplitBlockPredecessors(ExitBlock, Preds, ".us-lcssa", DT, LI, MSSAU.get(),
 1255       SplitEdge(loopPreheader, loopHeader, DT, LI, MSSAU.get());
 1544     SplitEdge(Switch, SISucc, DT, LI, MSSAU.get());
 1609         ReplaceUsesOfWith(I, V, Worklist, L, LPM, MSSAU.get());
 1642         MergeBlockIntoPredecessor(Succ, &DTU, LI, MSSAU.get());

   78                          I.getAddressSpace(), I.getName(), New.get());
   95                               I->getAddressSpace(), I->getName(), New.get());
  109                                    I->getLinkage(), I->getName(), New.get());

  476       InstResult = AllocaTmps.back().get();

  850     MDMap[I].reset(DummyNodes.back().get());

  819     Changed |= simplifyLoop(*I, DT, LI, SE, AC, MSSAU.get(), PreserveLCSSA);
  850         simplifyLoop(*I, DT, LI, SE, AC, MSSAU.get(), /*PreserveLCSSA*/ false);

  267   findPartitions(M.get(), ClusterIDMap, N);

  499     BB = DelayedBBs.back().TempBB.get();

  565       BlockScheduling *BS = Iter.second.get();
 1392     TreeEntry *Last = VectorizableTree.back().get();
 2003     return R.VectorizableTree[0].get();
 2022     NodeRef operator*() { return It->get(); }
 2115     TreeEntry *Entry = TEPtr.get();
 2298   BlockScheduling &BS = *BSRef.get();
 3430     TreeEntry &TE = *VectorizableTree[I].get();
 4243     scheduleBlock(BSIter.second.get());
 4247   auto *VectorRoot = vectorizeTree(VectorizableTree[0].get());
 4357     TreeEntry *Entry = TEPtr.get();

  132     assert(isa<BufferExtents>(R.get()));
  133     auto BE = cast<BufferExtents>(R.get());
  180   if (auto BE = dyn_cast<BufferExtents>(R.get())) {

  145     if (!M.get())

  173   if (TestFn(BD, M.get())) {
  301     RemoveFunctionReferences(M.get(), "llvm.used");
  302     RemoveFunctionReferences(M.get(), "llvm.compiler.used");
  305   if (TestFn(BD, M.get())) {
  363   if (TestFn(BD, M.get())) {
  505   std::unique_ptr<Module> New = BD.runPassesOn(M.get(), Passes);
  513   if (TestFn(BD, M.get())) {
  612   std::unique_ptr<Module> New = BD.runPassesOn(M.get(), Passes);
  620   if (TestFn(BD, M.get())) {
  704   std::unique_ptr<Module> New = BD.runPassesOn(M.get(), Passes);
  712   if (TestFn(BD, M.get())) {
  794   if (TestFn(BD, M.get())) {
  869   if (TestFn(BD, M.get())) {
  934   if (TestFn(BD, M.get())) {
  974   if (TestFn(BD, M.get())) { // Still crashes?
 1068               if (TestFn(BD, M.get())) {
 1210     if (TestFn(BD, M.get()))
 1258     if (M && TestFn(BD, M.get()))

  120   std::unique_ptr<Module> New = runPassesOn(Clone.get(), Passes);
  143   std::unique_ptr<Module> New = runPassesOn(M.get(), CleanupPasses);
  361   SplitStaticCtorDtor("llvm.global_ctors", M, New.get(), NewVMap);
  362   SplitStaticCtorDtor("llvm.global_dtors", M, New.get(), NewVMap);

  280       SplitFunctionsOutOfModule(ToNotOptimize.get(), FuncsOnClone, VMap);
  318         ToNotOptimize.get(), MiscompiledFunctions, VMap);
  320         BD.extractLoop(ToOptimize.get());
  518       SplitFunctionsOutOfModule(ToNotOptimize.get(), FuncsOnClone, VMap);
  523           BD.extractMappedBlocksFromModule(BBsOnClone, ToOptimize.get())) {
  573       SplitFunctionsOutOfModule(ProgClone.get(), MiscompiledFunctions, VMap);
  575       BD.extractMappedBlocksFromModule(Blocks, ToExtract.get());
  704       BD.runPassesOn(Test.get(), BD.getPassesToRun());
  798                            GlobalValue::ExternalLinkage, "main", Test.get());
  803                                                 oldMain->getName(), Test.get());
  945   Test = CleanupAndPrepareModules(BD, std::move(Test), Safe.get());
 1033       SplitFunctionsOutOfModule(ToNotCodeGen.get(), *Funcs, VMap);
 1037       CleanupAndPrepareModules(*this, std::move(ToCodeGen), ToNotCodeGen.get());

   53   ASTImporterLookupTable *getLookupTable() { return LookupTable.get(); }

  213     return P.second.get();
  239     return P.second.get();

   31       : OwningPrimary(std::move(Primary)), Primary(OwningPrimary.get()),

  995   PPCallbacks *getPPCallbacks() const { return Callbacks.get(); }
 2150     return IsFileLexer(I.TheLexer.get(), I.ThePPLexer);
 2154     return IsFileLexer(CurLexer.get(), CurPPLexer);

  200   const CXXScopeSpec *getSS() const { return SS.get(); }
  203     return CorrectionValidator.get();

 1614         Reader.setListener(static_cast<ChainedASTReaderListener *>(New.get())
 1632   GlobalModuleIndex *getGlobalIndex() { return GlobalIndex.get(); }

  104     return Writers[Format].get();
  107     return Readers[Format].get();

  641     return eqClass.getReports()[0].get();
  769       return Tags.back().get();

  171   WorkList *getWorkList() const { return WList.get(); }

   56   ToolResults *getToolResults() override { return Results.get(); }

  547       std::move(CInvok), PCHContainerOps, Diags, ASTAction.get()));

  791   return *InterpContext.get();
10160   if (!VTContext.get()) {
10166   return VTContext.get();

  292           static_cast<LazyASTImporter *>(Importer.get())->GetReverse();

  191   return It == Funcs.end() ? nullptr : It->second.get();

  253         cast<ItaniumMangleContext>(Mangler.get()));

 3672     VBI = Entry.get();

  537              : it->second.get();

  224       addParentsForSyntheticStmts(cfg.get(), *PM);
  229   return cfg.get();
  243       addParentsForSyntheticStmts(completeCFG.get(), *PM);
  248   return completeCFG.get();
  253     return cfgStmtMap.get();
  257     return cfgStmtMap.get();
  265     return CFA.get();
  269     return CFA.get();
  306   return AC.get();

 1480   assert(cfg.get());

  196   return I->second.get();
  205     return Node.get();
  210     Root->addCallee(Node.get());
  211   return Node.get();

 1049   return StateMapsArray[Block->getBlockID()].get();
 1245       splitVarStateForIf(IfNode, PInfo.getVarTest(), CurrStates.get(),
 1246                          FalseStates.get());
 1250       splitVarStateForIfBinOp(PInfo, CurrStates.get(), FalseStates.get());
 1250       splitVarStateForIfBinOp(PInfo, CurrStates.get(), FalseStates.get());
 1321   ConsumedStmtVisitor Visitor(*this, CurrStates.get());
 1339     Visitor.reset(CurrStates.get());
 1384         auto *RawState = CurrStates.get();

  220     assert(orig != D.get());

 1080     Info = InfoPtr.get();
 1132     Info = It->second.get();

  109   NamedDirEnt.second = *UDE.get();
  388     UFE = VirtualFileEntries.back().get();
  503                                     StatCache.get(), *FS);
  509                                   StatCache.get(), *FS);
  543     UIDToFiles[VFE->getUID()] = VFE.get();

  507   return FakeBufferForRecovery.get();
  519   return FakeContentCacheForRecovery.get();

 1076   PassBuilder PB(TM.get(), PTO, PGOOpt, &PIC);
 1523         runThinLTOBackend(CombinedIndex.get(), M, HeaderOpts, CGOpts, TOpts,
 1536       M = EmptyModule.get();

  961   if (auto CAExp = dyn_cast<ConstantArrayExpansion>(Exp.get())) {
  964   if (auto RExp = dyn_cast<RecordExpansion>(Exp.get())) {
  972   if (isa<ComplexExpansion>(Exp.get()))
  974   assert(isa<NoExpansion>(Exp.get()));
  982   if (auto CAExp = dyn_cast<ConstantArrayExpansion>(Exp.get())) {
  986   } else if (auto RExp = dyn_cast<RecordExpansion>(Exp.get())) {
  991   } else if (auto CExp = dyn_cast<ComplexExpansion>(Exp.get())) {
  996     assert(isa<NoExpansion>(Exp.get()));
 1022   if (auto CAExp = dyn_cast<ConstantArrayExpansion>(Exp.get())) {
 1028   } else if (auto RExp = dyn_cast<RecordExpansion>(Exp.get())) {
 1045   } else if (isa<ComplexExpansion>(Exp.get())) {
 1050     assert(isa<NoExpansion>(Exp.get()));
 1059   if (auto CAExp = dyn_cast<ConstantArrayExpansion>(Exp.get())) {
 1070   } else if (auto RExp = dyn_cast<RecordExpansion>(Exp.get())) {
 1092   } else if (isa<ComplexExpansion>(Exp.get())) {
 1097     assert(isa<NoExpansion>(Exp.get()));

   26   NewLoopProperties.push_back(TempNode.get());
   60   Args.push_back(TempNode.get());
  115   Args.push_back(TempNode.get());
  178   Args.push_back(TempNode.get());
  252   Args.push_back(TempNode.get());
  345   Args.push_back(TempNode.get());
  390   Args.push_back(TempNode.get());
  568                    Active.empty() ? nullptr : Active.back().get()));

   88   llvm::MDNode *getLoopID() const { return TempLoopID.get(); }

  811   CGM.EmitVTableTypeMetadata(RD, VTable, *VTLayout.get());

  141     CodeGenerator *getCodeGenerator() { return Gen.get(); }
  210         CurLinkModule = LM.Module.get();
  939   BEConsumer = Result.get();
 1073     EmbedBitcode(TheModule.get(), CI.getCodeGenOpts(),
 1082                       CI.getTarget().getDataLayout(), TheModule.get(), BA,

  604   llvm::IndexedInstrProfReader *getPGOReader() const { return PGOReader.get(); }
  607     return CoverageMapping.get();
  659   CGDebugInfo *getModuleDebugInfo() { return DebugInfo.get(); }
 1243     return SanitizerMD.get();

  836                                 CGM.getLangOpts(), RegionCounterMap.get());

 1881         ->get()

   99       return M.get();
  134       return M.get();

  298           Ctx.getTargetInfo().getDataLayout(), M.get(),
  307                              M.get(), BackendAction::Backend_EmitObj,

  387     ASTUnit *Unit = LoadedUnit.get();
  401     return ASTCacheEntry->second.get();

  171       OS = OwnedStream.get();

  635     C.addOffloadDeviceToolChain(CudaTC.get(), OFK);
  650     C.addOffloadDeviceToolChain(HIPTC.get(), OFK);
  707               TC = CudaTC.get();
  966   bool HasConfigFile = !ContainsError && (CfgOptions.get() != nullptr);

  583     if (!SCL.get())

  117   if (!SanitizerArguments.get())
  119   return *SanitizerArguments.get();
  123   if (!XRayArguments.get())
  125   return *XRayArguments.get();
  254   return Clang.get();
  268   return Assemble.get();
  274   return Assemble.get();
  280   return Link.get();
  286   return IfsMerge.get();
  292   return OffloadBundler.get();
  298   return OffloadWrapper.get();

 5997   return CLFallback.get();

  884     return Lipo.get();
  888     return Dsymutil.get();
  892     return VerifyDebug.get();

 2518     return Preprocess.get();
 2522     return Compile.get();

  410     return Preprocessor.get();
  414     return Compiler.get();

  274     return Compiler.get();
  278     return Assembler.get();

  767     ASTUnitCleanup(AST.get());
 1113     Preamble->AddImplicitPreamble(*CCInvocation, VFS, OverrideMainBuffer.get());
 1131     CICleanup(Clang.get());
 1199     ActCleanup(Act.get());
 1201   if (!Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0]))
 1317                             MainFileBuffer.get(), MaxLines);
 1322     if (Preamble->CanReuse(PreambleInvocationIn, MainFileBuffer.get(), Bounds,
 1379         PreambleInvocationIn, MainFileBuffer.get(), Bounds, *Diagnostics, VFS,
 1528     AST = OwnAST.get();
 1548     ASTUnitCleanup(OwnAST.get());
 1564     CICleanup(Clang.get());
 1611     Act = TrackerAct.get();
 1616     ActCleanup(TrackerAct.get());
 1618   if (!Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0])) {
 1687     MemBufferCleanup(OverrideMainBuffer.get());
 1717     ASTUnitCleanup(AST.get());
 1808     ASTUnitCleanup(AST.get());
 2184     CICleanup(Clang.get());
 2271                                   OverrideMainBuffer.get());
 2288   if (Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0])) {

   94   VerboseOutputStream = OwnedVerboseOutputStream.get();
  234       OS = FileOS.get();

  977     llvm::BuryPointer(CI.takeASTConsumer().get());

  276   Inputs.push_back(FrontendInputFile(Buffer.get(), Kind, /*IsSystem*/false));
  707   llvm::raw_ostream &Out = OutFile.get()? *OutFile.get() : llvm::outs();
  707   llvm::raw_ostream &Out = OutFile.get()? *OutFile.get() : llvm::outs();
  836   DoPrintPreprocessedInput(CI.getPreprocessor(), OS.get(),

  336   return MutationListener.get();
  340   return DeserializationListener.get();
  357     if (SemaConsumer *SC = dyn_cast<SemaConsumer>(Consumer.get()))
  363     if (SemaConsumer *SC = dyn_cast<SemaConsumer>(Consumer.get()))

  285       Clang.get());
  333     PreprocessorOpts.addRemappedFile(MainFilePath, PreambleInputBuffer.get());
  345   if (!Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0]))

  891   PP.AddPragmaHandler(MicrosoftExtHandler.get());
  892   PP.AddPragmaHandler("GCC", GCCHandler.get());
  893   PP.AddPragmaHandler("clang", ClangHandler.get());
  903   PP.AddPragmaHandler("omp", OpenMPHandler.get());
  934   PP.RemovePragmaHandler(MicrosoftExtHandler.get());
  935   PP.RemovePragmaHandler("GCC", GCCHandler.get());
  936   PP.RemovePragmaHandler("clang", ClangHandler.get());
  937   PP.RemovePragmaHandler("omp", OpenMPHandler.get());

  106                                    CI.getLangOpts(), FixItOpts.get()));
  132                              CI.getLangOpts(), FixItOpts.get());
  191   RewriteMacrosInInput(CI.getPreprocessor(), OS.get());
  200   DoRewriteTest(CI.getPreprocessor(), OS.get());

  749   return State->MetaDiagnostics.get();

  121         return HeaderMaps[i].second.get();
  126     return HeaderMaps.back().second.get();

  820   return PendingSubmodules.back().get();

  551       MacroExpandingLexersStack.back().first == CurTokenLexer.get())

  891   PragmaNamespace *InsertNS = PragmaHandlers.get();
  922   PragmaNamespace *NS = PragmaHandlers.get();
  936   if (NS != PragmaHandlers.get() && NS->IsEmpty()) {

  109   llvm::CrashRecoveryContextCleanupRegistrar<Sema> CleanupSema(S.get());
  111   ParseAST(*S.get(), PrintStats, SkipFunctionBodies);
  133   Parser &P = *ParseOP.get();
  141     CleanupParser(ParseOP.get());

  269   PP.AddPragmaHandler(AlignHandler.get());
  272   PP.AddPragmaHandler("GCC", GCCVisibilityHandler.get());
  275   PP.AddPragmaHandler(OptionsHandler.get());
  278   PP.AddPragmaHandler(PackHandler.get());
  281   PP.AddPragmaHandler(MSStructHandler.get());
  284   PP.AddPragmaHandler(UnusedHandler.get());
  287   PP.AddPragmaHandler(WeakHandler.get());
  290   PP.AddPragmaHandler(RedefineExtnameHandler.get());
  293   PP.AddPragmaHandler("STDC", FPContractHandler.get());
  296   PP.AddPragmaHandler("STDC", STDCFENVHandler.get());
  299   PP.AddPragmaHandler("STDC", STDCCXLIMITHandler.get());
  302   PP.AddPragmaHandler("STDC", STDCUnknownHandler.get());
  305   PP.AddPragmaHandler("clang", PCSectionHandler.get());
  309     PP.AddPragmaHandler("OPENCL", OpenCLExtensionHandler.get());
  311     PP.AddPragmaHandler("OPENCL", FPContractHandler.get());
  317   PP.AddPragmaHandler(OpenMPHandler.get());
  322     PP.AddPragmaHandler(MSCommentHandler.get());
  328     PP.AddPragmaHandler(MSDetectMismatchHandler.get());
  330     PP.AddPragmaHandler(MSPointersToMembers.get());
  332     PP.AddPragmaHandler(MSVtorDisp.get());
  334     PP.AddPragmaHandler(MSInitSeg.get());
  336     PP.AddPragmaHandler(MSDataSeg.get());
  338     PP.AddPragmaHandler(MSBSSSeg.get());
  340     PP.AddPragmaHandler(MSConstSeg.get());
  342     PP.AddPragmaHandler(MSCodeSeg.get());
  344     PP.AddPragmaHandler(MSSection.get());
  346     PP.AddPragmaHandler(MSRuntimeChecks.get());
  348     PP.AddPragmaHandler(MSIntrinsic.get());
  350     PP.AddPragmaHandler(MSOptimize.get());
  356     PP.AddPragmaHandler("clang", CUDAForceHostDeviceHandler.get());
  360   PP.AddPragmaHandler("clang", OptimizeHandler.get());
  363   PP.AddPragmaHandler("clang", LoopHintHandler.get());
  366   PP.AddPragmaHandler(UnrollHintHandler.get());
  369   PP.AddPragmaHandler(NoUnrollHintHandler.get());
  373   PP.AddPragmaHandler(UnrollAndJamHintHandler.get());
  377   PP.AddPragmaHandler(NoUnrollAndJamHintHandler.get());
  380   PP.AddPragmaHandler("clang", FPHandler.get());
  384   PP.AddPragmaHandler("clang", AttributePragmaHandler.get());
  389   PP.RemovePragmaHandler(AlignHandler.get());
  391   PP.RemovePragmaHandler("GCC", GCCVisibilityHandler.get());
  393   PP.RemovePragmaHandler(OptionsHandler.get());
  395   PP.RemovePragmaHandler(PackHandler.get());
  397   PP.RemovePragmaHandler(MSStructHandler.get());
  399   PP.RemovePragmaHandler(UnusedHandler.get());
  401   PP.RemovePragmaHandler(WeakHandler.get());
  403   PP.RemovePragmaHandler(RedefineExtnameHandler.get());
  407     PP.RemovePragmaHandler("OPENCL", OpenCLExtensionHandler.get());
  409     PP.RemovePragmaHandler("OPENCL", FPContractHandler.get());
  411   PP.RemovePragmaHandler(OpenMPHandler.get());
  416     PP.RemovePragmaHandler(MSCommentHandler.get());
  420   PP.RemovePragmaHandler("clang", PCSectionHandler.get());
  424     PP.RemovePragmaHandler(MSDetectMismatchHandler.get());
  426     PP.RemovePragmaHandler(MSPointersToMembers.get());
  428     PP.RemovePragmaHandler(MSVtorDisp.get());
  430     PP.RemovePragmaHandler(MSInitSeg.get());
  432     PP.RemovePragmaHandler(MSDataSeg.get());
  434     PP.RemovePragmaHandler(MSBSSSeg.get());
  436     PP.RemovePragmaHandler(MSConstSeg.get());
  438     PP.RemovePragmaHandler(MSCodeSeg.get());
  440     PP.RemovePragmaHandler(MSSection.get());
  442     PP.RemovePragmaHandler(MSRuntimeChecks.get());
  444     PP.RemovePragmaHandler(MSIntrinsic.get());
  446     PP.RemovePragmaHandler(MSOptimize.get());
  451     PP.RemovePragmaHandler("clang", CUDAForceHostDeviceHandler.get());
  455   PP.RemovePragmaHandler("STDC", FPContractHandler.get());
  458   PP.RemovePragmaHandler("STDC", STDCFENVHandler.get());
  461   PP.RemovePragmaHandler("STDC", STDCCXLIMITHandler.get());
  464   PP.RemovePragmaHandler("STDC", STDCUnknownHandler.get());
  467   PP.RemovePragmaHandler("clang", OptimizeHandler.get());
  470   PP.RemovePragmaHandler("clang", LoopHintHandler.get());
  473   PP.RemovePragmaHandler(UnrollHintHandler.get());
  476   PP.RemovePragmaHandler(NoUnrollHintHandler.get());
  479   PP.RemovePragmaHandler(UnrollAndJamHintHandler.get());
  482   PP.RemovePragmaHandler(NoUnrollAndJamHintHandler.get());
  485   PP.RemovePragmaHandler("clang", FPHandler.get());
  488   PP.RemovePragmaHandler("clang", AttributePragmaHandler.get());

  596   llvm::MCContext Ctx(MAI.get(), MRI.get(), MOFI.get(), &TempSrcMgr);
  596   llvm::MCContext Ctx(MAI.get(), MRI.get(), MOFI.get(), &TempSrcMgr);
  596   llvm::MCContext Ctx(MAI.get(), MRI.get(), MOFI.get(), &TempSrcMgr);
  606       createMCAsmParser(TempSrcMgr, Ctx, *Str.get(), *MAI));
  616   Parser->setTargetParser(*TargetParser.get());
  634                                MII.get(), IP.get(), Callback))
  634                                MII.get(), IP.get(), Callback))

   67   PP.addCommentHandler(CommentSemaHandler.get());
  427   PP.removeCommentHandler(CommentSemaHandler.get());

  187   SemaPPCallbackHandler = Callbacks.get();
 1747     popOpenMPFunctionRegion(Scope.get());
 1751     AnalysisWarnings.IssueWarnings(*WP, Scope.get(), D, BlockType);

14552                         TypeTagForDatatypeMagicValues.get(), FoundWrongKind,

17283       Entry = Vec.get();

 4348   CXXScopeSpec *TempSS = SS.get();
 4366         TempSS = SS.get();
 4389     Candidate.setCorrectionRange(SS.get(), Result.getLookupNameInfo());
 4457           TC.setCorrectionRange(SS.get(), Result.getLookupNameInfo());

 4411   CapturedRegionScopeInfo *RSI = cast<CapturedRegionScopeInfo>(ScopeRAII.get());
 4428   CapturedRegionScopeInfo *RSI = cast<CapturedRegionScopeInfo>(ScopeRAII.get());

 4091   ModuleMgr.setGlobalIndex(GlobalIndex.get());
 4596       Listener.get(),
12132   if (++NumCurrentElementsDeserializing == 1 && ReadTimer.get())

   48   return I->second.Buffer.get();

  209   Module = Modules[Entry] = NewModule.get();
  214     PCHChain.push_back(NewModule.get());
  216     Roots.push_back(NewModule.get());

  589     BuiltinBug *BT = static_cast<BuiltinBug *>(BT_Null.get());
  609     BuiltinBug *BT = static_cast<BuiltinBug *>(BT_Bounds.get());

  326     emitBadCall(BT_call_undef.get(), C, Callee);
  337     emitBadCall(BT_call_null.get(), C, Callee);
  360     BugType *BT = BT_cxx_delete_undef.get();
  380       emitBadCall(BT_cxx_call_undef.get(), C, CC->getCXXThisExpr());
  392       emitBadCall(BT_cxx_call_null.get(), C, CC->getCXXThisExpr());
  468         BT = BT_msg_undef.get();
  474         BT = BT_objc_prop_undef.get();
  480         BT = BT_objc_subscript_undef.get();

  162     if (!InEH.get()) {
  164       EHCodeVisitor V(*InEH.get());
  201     if (!reachableCode.get()) {

  245   markInteresting(Report.get(), AP);
  499   markInteresting(Report.get(), AP);

  269     bug = NSBT.get();
  274     bug = CFBT.get();

 2847   if (auto PR = dyn_cast<PathSensitiveBugReport>(R.get()))
 2892     BugReport *R = EQ.getReports()[0].get();
 2894       if (auto *PR = dyn_cast<PathSensitiveBugReport>(J.get())) {
 2911     auto *R = dyn_cast<PathSensitiveBugReport>(I.get());

 3013         const auto *PR = dyn_cast<PathSensitiveBugReport>(I.get());
 3123           dyn_cast<PathSensitiveBugReport>(EI->getReports()[0].get());
 3144   if (!TrimmedG.get()) {
 3147     return llvm::WriteGraph(TrimmedG.get(), "TrimmedExprEngine",

  340                                             checkerMgr.get(), *Opts, Injector);

   67       Context(Results.get()), ThreadCount(ThreadCount) {}
   74       Results(new ThreadSafeToolResults), Context(Results.get()),
  135             if (Tool.run(Action.first.get()))

  221   const llvm::MemoryBuffer *getBufferPtr() const { return Buffer.get(); }

  164         Service.getSharedCache(), RealFS, PPSkipMappings.get());
  198                                     PPSkipMappings.get());

   66   if (Tool.run(Action.first.get()))

  340   this->Collector = CB.get();

  344       &Diagnostics, Compilation.get());
  357   return runInvocation(BinaryName, Compilation.get(), std::move(Invocation),

  187     bool err = migration.applyTransform(transforms[i], transformPrinter.get());

  229       std::move(CInvok), PCHContainerOps, Diags, IndexAction.get()));

  129                                      CI.getLangOpts(), FixItOpts.get()));
  187   return Tool.run(FrontendFactory.get());

  128   return Tool.run(newFrontendActionFactory<MapExtDefNamesAction>().get());

  310   FileID FileID = createInMemoryFile(AssumedFileName, Code.get(), Sources,
  402   if (fillRanges(Code.get(), Ranges))
  443     FileID ID = createInMemoryFile(AssumedFileName, Code.get(), Sources, Files,

  314   auto &CG = *static_cast<CodeGenerator *>(ASTConsumers.back().get());

  299     return ParsedSelection.get();
  403         TestConsumer ? TestConsumer.get() : Consumer.get();
  403         TestConsumer ? TestConsumer.get() : Consumer.get();
  541           MatchingRules.push_back(Rule.get());
  545             MatchingRules.push_back(Rule.get());
  631   if (Tool.run(ActionFactory->get()) != 0) {

  162   Tool.run(tooling::newFrontendActionFactory(&FindingAction).get());
  185     ExitCode = Tool.runAndSave(Factory.get());
  187     ExitCode = Tool.run(Factory.get());

  250     Success = ExecuteCompilerInvocation(Clang.get());

  382   MCContext Ctx(MAI.get(), MRI.get(), MOFI.get(), &SrcMgr, &MCOptions);
  382   MCContext Ctx(MAI.get(), MRI.get(), MOFI.get(), &SrcMgr, &MCOptions);
  382   MCContext Ctx(MAI.get(), MRI.get(), MOFI.get(), &SrcMgr, &MCOptions);
  436   raw_pwrite_stream *Out = FDOS.get();
  466       Out = BOS.get();
  482     Str.get()->InitSections(Opts.NoExecStack);
  491     Str.get()->SwitchSection(AsmLabel);
  492     Str.get()->EmitZeros(1);
  501       createMCAsmParser(SrcMgr, Ctx, *Str.get(), *MAI));
  521     Parser->setTargetParser(*TAP.get());

  122   if (!Lex.get())
  663   assert(Lex.get() &&
  665   if (!Lex.get())

  121   if (int Result = Tool.run(Factory.get()))

  355   return I->Children.back().get();
  360   return getCommentInfo(I.get());
  727   if (auto Err = readBlock(ID, static_cast<T *>(I.get())))

  209                              (&C + 1)->get()->Type != NodeType::NODE_TEXT))) {

   40   T *Tmp = static_cast<T *>(Merged.get());
   42     Tmp->merge(std::move(*static_cast<T *>(I.get())));

  193     return serialize(*static_cast<NamespaceInfo *>(I.get()));
  195     return serialize(*static_cast<RecordInfo *>(I.get()));
  197     return serialize(*static_cast<EnumInfo *>(I.get()));
  199     return serialize(*static_cast<FunctionInfo *>(I.get()));

  211       Exec->get()->getExecutionContext(),
  242       Exec->get()->execute(doc::newMapperActionFactory(CDCtx), ArgAdjuster);
  259   Exec->get()->getToolResults()->forEachResult(
  296       doc::Info *I = Reduced.get().get();
  318       if (auto Err = G->get()->generateDocForInfo(I, InfoOS, CDCtx))
  329   Err = G->get()->createResources(CDCtx);

  150   return Tool.run(Factory.get());

   23     const CallGraphNode *N = (I->second).get();
   60     return Node.get();
   63   return Node.get();
   68   return I == DeclMap.end() ? nullptr : I->second.get();

   83   const HelperDeclRefGraph *getGraph() const { return RG.get(); }

  618   Finder->addMatcher(MovedClass, MatchCallbacks.back().get());
  625       MatchCallbacks.back().get());
  630       MatchCallbacks.back().get());
  635                      MatchCallbacks.back().get());
  640       MatchCallbacks.back().get());
  648       MatchCallbacks.back().get());
  657                      MatchCallbacks.back().get());

   65     return Tool.runAndSave(Factory.get());
   67   int ExitCode = Tool.run(Factory.get());

  568   return HeaderFilter.get();

   95   return PP.get();

  105       std::make_unique<ExprSequence>(TheCFG.get(), FunctionBody, Context);
  106   BlockMap = std::make_unique<StmtToBlockMap>(TheCFG.get(), Context);

   63   PP->addCommentHandler(Handler.get());

   47     Context->setDiagnosticsEngine(DiagEngine.get());

  345   auto *OptionsProvider = OwningOptionsProvider.get();

  144     Next->get()->range = R;
  145     Next = &Next->get()->parent;
  488   CDB.emplace(BaseCDB.get(), Params.initializationOptions.fallbackFlags,

  130           std::make_unique<UpdateIndexCallbacks>(DynamicIdx.get(), DiagConsumer,
  137       this->Index = MergedIdx.back().get();
  150     AddIndex(BackgroundIdx.get());
  153     AddIndex(DynamicIdx.get());

 1088       ComputePreambleBounds(*CI->getLangOpts(), ContentsBuffer.get(), 0);
 1307     Recorder = RecorderOwner.get();

   83     Preamble->OverridePreamble(*CI, VFS, Buffer.get());
   86         CI->getFrontendOpts().Inputs[0].getFile(), Buffer.get());

   74       if (auto S = File->get()->status())

  191     Result.CDB = Entry->CDB.get();

  361   Clang->getPreprocessor().addCommentHandler(IWYUHandler.get());

   62     return IWYUHandler.get();
   99       ComputePreambleBounds(*CI.getLangOpts(), ContentsBuffer.get(), 0);
  103       OldPreamble->Preamble.CanReuse(CI, ContentsBuffer.get(), Bounds,
  137       CI, ContentsBuffer.get(), Bounds, *PreambleDiagsEngine,

  141   auto Includes = parseDriverOutput(BufOrError->get()->getBuffer());

  204   return S->get()->uriFromAbsolutePath(AbsolutePath);
  238   return S->get()->getAbsolutePath(Uri.Authority, Uri.Body, HintPath);
  265   return S->get()->getIncludeSpelling(Uri);

  132   return digest(Buf->get()->getBuffer()) != LS.Digest;
  308     Shard.Symbols = SS.get();
  309     Shard.Refs = RS.get();
  310     Shard.Relations = RelS.get();
  311     Shard.Sources = IG.get();
  352   auto Hash = digest(Buf->get()->getBuffer());

   66     if (auto I = readIndexFile(Buffer->get()->getBuffer()))
  123     return IndexStorage.get();

  139         PragmaHandler(collectIWYUHeaderMaps(this->Includes.get())) {}
  143     CI.getPreprocessor().addCommentHandler(PragmaHandler.get());
  222   Opts.Includes = Includes.get();

  677     if (auto I = readIndexFile(Buffer->get()->getBuffer())) {

  368       auto &NewChildren = static_cast<AndIterator *>(Child.get())->Children;
  396       auto &NewChildren = static_cast<OrIterator *>(Child.get())->Children;

  121   auto Err = Executor->get()->execute(

  596   Opts.StaticIndex = StaticIdx.get();

  107     Opts.Index = OverrideIndex.get();
  125     Opts.Index = OverrideIndex.get();
  160     Opts.Index = OverrideIndex.get();
  754   Opts.Index = I.get();
 1016   Opts.StaticIndex = Index.get();
 2545   Opts.Index = Index.get();

  547   TU.ExternalIndex = Index.get();
  587   TU.ExternalIndex = Index.get();
  617   TU.ExternalIndex = Index.get();
  654   TU.ExternalIndex = Index.get();
  673   TU.ExternalIndex = Index.get();
  708   TU.ExternalIndex = Index.get();
  730   TU.ExternalIndex = Index.get();
  757   TU.ExternalIndex = Index.get();
  797   TU.ExternalIndex = Index.get();
  821   TU.ExternalIndex = Index.get();

   90   OverlayCDB CDB(Base.get(), {}, std::string(""));
  106   OverlayCDB CDB(Base.get(), {"-DA=4"});
  143   OverlayCDB CDB(Base.get(), {}, std::string(""));

  181                                              Index.get()));
  247                                              Index.get()));

  267   MergedIndex M(I.get(), J.get());
  267   MergedIndex M(I.get(), J.get());
  286   EXPECT_THAT(match(MergedIndex(I.get(), J.get()), Req),
  286   EXPECT_THAT(match(MergedIndex(I.get(), J.get()), Req),

   37     return newJSONTransport(In.get(), Out, &Mirror, Pretty, Style);

  109   const SymbolIndex *Index = OtherFileIndex.get();

  263         CollectorOpts, PragmaHandler.get());

   99   Tweak::Selection S(Index.get(), AST, Selection.first, Selection.second);
  135                           ExtraFiles, Index.get());

  504   SymbolID Parent = findSymbolIDByName(Index.get(), "Parent");
  505   SymbolID Child1a = findSymbolIDByName(Index.get(), "Child1a");
  506   SymbolID Child1b = findSymbolIDByName(Index.get(), "Child1b");
  507   SymbolID Child2 = findSymbolIDByName(Index.get(), "Child2");
  509   EXPECT_THAT(collectSubtypes(Parent, Index.get()),
  511   EXPECT_THAT(collectSubtypes(Child1a, Index.get()), ElementsAre(Child2));
  525   SymbolID Parent1 = findSymbolIDByName(Index.get(), "Parent1");
  526   SymbolID Parent2 = findSymbolIDByName(Index.get(), "Parent2");
  527   SymbolID Parent3 = findSymbolIDByName(Index.get(), "Parent3");
  528   SymbolID Child = findSymbolIDByName(Index.get(), "Child");
  530   EXPECT_THAT(collectSubtypes(Parent1, Index.get()), ElementsAre(Child));
  531   EXPECT_THAT(collectSubtypes(Parent2, Index.get()), ElementsAre(Parent3));
  532   EXPECT_THAT(collectSubtypes(Parent3, Index.get()), ElementsAre(Child));
  546   SymbolID Parent = findSymbolIDByName(Index.get(), "Parent");
  547   SymbolID Child = findSymbolIDByName(Index.get(), "Child");
  549   EXPECT_THAT(collectSubtypes(Parent, Index.get()), ElementsAre(Child));
  568   SymbolID Parent = findSymbolIDByName(Index.get(), "Parent");
  569   SymbolID ParentSpec = findSymbolIDByName(Index.get(), "Parent", "<int>");
  570   SymbolID Child1 = findSymbolIDByName(Index.get(), "Child1");
  571   SymbolID Child2 = findSymbolIDByName(Index.get(), "Child2");
  573   EXPECT_THAT(collectSubtypes(Parent, Index.get()), ElementsAre(Child1));
  574   EXPECT_THAT(collectSubtypes(ParentSpec, Index.get()), ElementsAre(Child2));
  591   SymbolID Parent = findSymbolIDByName(Index.get(), "Parent");
  592   SymbolID ChildSpec = findSymbolIDByName(Index.get(), "Child", "<int>");
  594   EXPECT_THAT(collectSubtypes(Parent, Index.get()), ElementsAre(ChildSpec));
  609   SymbolID Parent = findSymbolIDByName(Index.get(), "Parent");
  610   SymbolID Child = findSymbolIDByName(Index.get(), "Child");
  612   EXPECT_THAT(collectSubtypes(Parent, Index.get()), ElementsAre(Child));
  629       TypeHierarchyDirection::Children, Index.get(), testPath(TU.Filename));
  639                        TypeHierarchyDirection::Children, Index.get());

  162     return clangd::locateSymbolAt(AST, Main.point(), Index.get());
  221     auto Locs = clangd::locateSymbolAt(AST, Test.point("p"), Index.get());
  226     auto Locs = clangd::locateSymbolAt(AST, Test.point("f"), Index.get());
 1845             getHover(AST, T.point(), format::getLLVMStyle(), Index.get())) {
 2141   EXPECT_THAT(findReferences(AST, Main.point(), 0, IndexedTU.index().get()),
 2145                                IndexedTU.index().get())
 2151   EXPECT_THAT(findReferences(AST, Main.point(), 0, TU.index().get()),

  124         ModMap.get());
  306   if (!collectModuleMapHeaders(ModMap.get()))

  308   if (!RootModule.get())
  312   return writeModuleMap(ModuleMapPath, HeaderPrefix, RootModule.get());

  102   ToolTemplateCallback Callback(*Executor->get()->getExecutionContext());
  113   auto Err = Executor->get()->execute(newFrontendActionFactory(&Finder));
  117   Executor->get()->getToolResults()->forEachResult(

   70   CheckNamespaceInfo(&I, InfoAsNamespace(ReadResults[0].get()));
   99   CheckRecordInfo(&I, InfoAsRecord(ReadResults[0].get()));
  119   CheckFunctionInfo(&I, InfoAsFunction(ReadResults[0].get()));
  141   CheckFunctionInfo(&I, InfoAsFunction(ReadResults[0].get()));
  159   CheckEnumInfo(&I, InfoAsEnum(ReadResults[0].get()));
  173   CommentInfo *BlankLine = Top.Children.back().get();
  179   CommentInfo *Brief = Top.Children.back().get();
  187   CommentInfo *Extended = Top.Children.back().get();
  197   CommentInfo *HTML = Top.Children.back().get();
  218   CommentInfo *Verbatim = Top.Children.back().get();
  227   CommentInfo *ParamOut = Top.Children.back().get();
  243   CommentInfo *ParamIn = Top.Children.back().get();
  258   CommentInfo *Return = Top.Children.back().get();
  275   CheckFunctionInfo(&F, InfoAsFunction(ReadResults[0].get()));

   23   Generator::addInfoToIndex(Idx, InfoA.get());
   30   Generator::addInfoToIndex(Idx, InfoC.get());
   42   Generator::addInfoToIndex(Idx, InfoF.get());
   44   Generator::addInfoToIndex(Idx, InfoG.get());

  382   CommentInfo *BlankLine = Top.Children.back().get();
  388   CommentInfo *Brief = Top.Children.back().get();
  396   CommentInfo *Extended = Top.Children.back().get();
  406   CommentInfo *Entities = Top.Children.back().get();

  225   CommentInfo *BlankLine = Top.Children.back().get();
  231   CommentInfo *Brief = Top.Children.back().get();
  239   CommentInfo *Extended = Top.Children.back().get();
  249   CommentInfo *HTML = Top.Children.back().get();
  270   CommentInfo *Verbatim = Top.Children.back().get();
  279   CommentInfo *ParamOut = Top.Children.back().get();
  295   CommentInfo *ParamIn = Top.Children.back().get();
  310   CommentInfo *Return = Top.Children.back().get();

   74   CheckNamespaceInfo(InfoAsNamespace(Expected.get()),
   75                      InfoAsNamespace(Actual.get().get()));
  149   CheckRecordInfo(InfoAsRecord(Expected.get()),
  150                   InfoAsRecord(Actual.get().get()));
  224   CheckFunctionInfo(InfoAsFunction(Expected.get()),
  225                     InfoAsFunction(Actual.get().get()));
  265   CheckEnumInfo(InfoAsEnum(Expected.get()), InfoAsEnum(Actual.get().get()));
  265   CheckEnumInfo(InfoAsEnum(Expected.get()), InfoAsEnum(Actual.get().get()));

   89   NamespaceInfo *A = InfoAsNamespace(Infos[0].get());
   93   NamespaceInfo *B = InfoAsNamespace(Infos[2].get());
   98   NamespaceInfo *BWithFunction = InfoAsNamespace(Infos[4].get());
  115   NamespaceInfo *A = InfoAsNamespace(Infos[0].get());
  139   RecordInfo *E = InfoAsRecord(Infos[0].get());
  147   RecordInfo *RecordWithEConstructor = InfoAsRecord(Infos[2].get());
  163   RecordInfo *RecordWithMethod = InfoAsRecord(Infos[3].get());
  178   RecordInfo *F = InfoAsRecord(Infos[4].get());
  186   RecordInfo *RecordWithTemplateMethod = InfoAsRecord(Infos[6].get());
  202   RecordInfo *TemplatedRecord = InfoAsRecord(Infos[7].get());
  222   RecordInfo *G = InfoAsRecord(Infos[8].get());
  238   NamespaceInfo *NamespaceWithEnum = InfoAsNamespace(Infos[0].get());
  248   NamespaceInfo *NamespaceWithScopedEnum = InfoAsNamespace(Infos[1].get());
  264   RecordInfo *E = InfoAsRecord(Infos[0].get());
  277   RecordInfo *E = InfoAsRecord(Infos[0].get());
  291   RecordInfo *E = InfoAsRecord(Infos[0].get());
  299   RecordInfo *G = InfoAsRecord(Infos[2].get());
  321   NamespaceInfo *BWithFunction = InfoAsNamespace(Infos[0].get());
  336   NamespaceInfo *BWithFunction = InfoAsNamespace(Infos[0].get());
  359   RecordInfo *F = InfoAsRecord(Infos[0].get());
  367   RecordInfo *G = InfoAsRecord(Infos[3].get());
  376   RecordInfo *E = InfoAsRecord(Infos[6].get());
  417   RecordInfo *H = InfoAsRecord(Infos[8].get());
  461   RecordInfo *I = InfoAsRecord(Infos[10].get());
  469   RecordInfo *J = InfoAsRecord(Infos[12].get());
  493   NamespaceInfo *BWithFunction = InfoAsNamespace(Infos[0].get());
  504   NamespaceInfo *BWithExportedFunction = InfoAsNamespace(Infos[1].get());
  523   NamespaceInfo *ParentA = InfoAsNamespace(Infos[1].get());
  529   RecordInfo *ParentB = InfoAsRecord(Infos[3].get());
  537   NamespaceInfo *ParentC = InfoAsNamespace(Infos[7].get());
  550   NamespaceInfo *ParentA = InfoAsNamespace(Infos[1].get());
  556   NamespaceInfo *ParentB = InfoAsNamespace(Infos[3].get());

  279   CommentInfo *BlankLine = Top.Children.back().get();
  285   CommentInfo *Brief = Top.Children.back().get();
  293   CommentInfo *Extended = Top.Children.back().get();
  303   CommentInfo *HTML = Top.Children.back().get();
  324   CommentInfo *Verbatim = Top.Children.back().get();
  333   CommentInfo *ParamOut = Top.Children.back().get();
  349   CommentInfo *ParamIn = Top.Children.back().get();
  364   CommentInfo *Return = Top.Children.back().get();

 3464     std::vector<ASTUnit::RemappedFile> > RemappedCleanup(RemappedFiles.get());
 3477     ArgsCleanup(Args.get());
 3531       CaptureDiagnostics, *RemappedFiles.get(),
 3546       printDiagsToStderr(Unit ? Unit.get() : ErrUnit.get());
 3546       printDiagsToStderr(Unit ? Unit.get() : ErrUnit.get());
 3549   if (isASTReadError(Unit ? Unit.get() : ErrUnit.get()))
 3549   if (isASTReadError(Unit ? Unit.get() : ErrUnit.get()))
 4114     std::vector<ASTUnit::RemappedFile> > RemappedCleanup(RemappedFiles.get());
 4123                         *RemappedFiles.get()))
 8644   CXTUResourceUsage usage = { (void*) entries.get(),

   42     return Diagnostics[i].get();

  371         *DataConsumer, ParsedLocsTracker.get()));
  497     ArgsCleanup(Args.get());
  531       BufOwner.get());
  536     CInvok->getPreprocessorOpts().addRemappedFile(UF.Filename, MB.get());
  558   auto *UPtr = Unit.get();
  564     CXTUCleanup(CXTU.get());
  578       SkipBodies ? IdxSession->SkipBodyData.get() : nullptr);
  582     IndexActionCleanup(IndexAction.get());
  617       IndexAction.get(), UPtr, Persistent, CXXIdx->getClangResourcesPath(),

  166       FromTU.import(SharedStatePtr, ToAST.get(), FoundDecls.front());
  198   Decl *To = FromTU->import(SharedStatePtr, ToAST.get(), From);
  208       FromTU->importOrError(SharedStatePtr, ToAST.get(), From);
  217   return FromTU->import(SharedStatePtr, ToAST.get(), FromType);

   95     auto Imported = importNode(FromAST.get(), ToAST.get(), Importer, ToImport);
   95     auto Imported = importNode(FromAST.get(), ToAST.get(), Importer, ToImport);
  171     EXPECT_TRUE(AST.get());
  211       ASTUnit *From = AllASTs[FromFile].get();
  212       ASTUnit *To = AllASTs[ToFile].get();
 4903   ASTImporter *Importer = findFromTU(FromSpec)->Importer.get();
 4928   ASTImporter *Importer = findFromTU(FromFoo)->Importer.get();
 4962   ASTImporter *Importer = findFromTU(FromProto)->Importer.get();
 4988   ASTImporter *Importer = findFromTU(FromX)->Importer.get();
 5055   ASTImporter *Importer = findFromTU(FromFRD)->Importer.get();
 5114   ASTImporter *Importer = findFromTU(FromX)->Importer.get();
 5160     ASTImporter *Importer = findFromTU(FromX)->Importer.get();
 5203     ASTImporter *Importer = findFromTU(FromX)->Importer.get();
 5242   ASTImporter *Importer = findFromTU(FromFooA)->Importer.get();

  146   const FunctionDecl *Func = getFunctionNode(AST.get(), "func");
  175   const FunctionDecl *CTorFunc = getFunctionNode(AST.get(), "A");
  226   Func = getFunctionNode(AST.get(), "parmvardecl_attr");

  135   ASSERT_TRUE(AST.get());
  161   ASSERT_TRUE(AST.get());
  169   ASSERT_TRUE(AST.get());

  346   if (!AST.get())

  394   EXPECT_TRUE(constructMatcher("hasInitializer", Error.get()).isNull());
  398   EXPECT_TRUE(constructMatcher("isArrow", StringRef(), Error.get()).isNull());
  402   EXPECT_TRUE(constructMatcher("anyOf", Error.get()).isNull());
  407                                Error.get()).isNull());
  413   EXPECT_TRUE(constructMatcher("ofClass", StringRef(), Error.get()).isNull());
  420                        constructMatcher("parameterCountIs", 3), Error.get())
  429                                Error.get()).isNull());
  439       Error.get()).isNull());

   29   CFG *getCFG() const { return Cfg.get(); }

  108   EXPECT_FALSE(isMutated(Results, AST.get()));
  118   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre(ModExpr));
  132   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre(ModExpr));
  143   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x.mf()"));
  153   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x.mf<T>()"));
  158   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x.mf()"));
  165   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x.mf()"));
  173   EXPECT_FALSE(isMutated(Results, AST.get()));
  181   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x = 10"));
  189   EXPECT_FALSE(isMutated(Results, AST.get()));
  196   EXPECT_FALSE(isMutated(Results, AST.get()));
  200   EXPECT_FALSE(isMutated(Results, AST.get()));
  205   EXPECT_FALSE(isMutated(Results, AST.get()));
  210   EXPECT_FALSE(isMutated(Results, AST.get()));
  214   EXPECT_FALSE(isMutated(Results, AST.get()));
  219   EXPECT_FALSE(isMutated(Results, AST.get()));
  225   EXPECT_FALSE(isMutated(Results, AST.get()));
  232   EXPECT_FALSE(isMutated(Results, AST.get()));
  236   EXPECT_FALSE(isMutated(Results, AST.get()));
  241   EXPECT_FALSE(isMutated(Results, AST.get()));
  246   EXPECT_FALSE(isMutated(Results, AST.get()));
  251   EXPECT_FALSE(isMutated(Results, AST.get()));
  257   EXPECT_FALSE(isMutated(Results, AST.get()));
  264   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x)"));
  269   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x)"));
  274   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x)"));
  281   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g<int>(x)"));
  286   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x)"));
  291   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x)"));
  296   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x + 1"));
  300   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x"));
  304   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x"));
  310   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("A<0>::mf(x)"));
  317   EXPECT_FALSE(isMutated(Results, AST.get()));
  322   EXPECT_FALSE(isMutated(Results, AST.get()));
  327   EXPECT_FALSE(isMutated(Results, AST.get()));
  335   EXPECT_FALSE(isMutated(Results, AST.get()));
  340   EXPECT_FALSE(isMutated(Results, AST.get()));
  345   EXPECT_FALSE(isMutated(Results, AST.get()));
  350   EXPECT_FALSE(isMutated(Results, AST.get()));
  358   EXPECT_THAT(mutatedBy(Results, AST.get()),
  364   EXPECT_THAT(mutatedBy(Results, AST.get()),
  370   EXPECT_THAT(mutatedBy(Results, AST.get()),
  376   EXPECT_THAT(mutatedBy(Results, AST.get()),
  385   EXPECT_FALSE(isMutated(Results, AST.get()));
  390   EXPECT_FALSE(isMutated(Results, AST.get()));
  395   EXPECT_FALSE(isMutated(Results, AST.get()));
  400   EXPECT_FALSE(isMutated(Results, AST.get()));
  408   EXPECT_FALSE(isMutated(Results, AST.get()));
  413   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("std::move(x) = y"));
  418   EXPECT_FALSE(isMutated(Results, AST.get()));
  425   EXPECT_FALSE(isMutated(Results, AST.get()));
  431   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("y = std::move(x)"));
  438   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("y = std::move(x)"));
  445   EXPECT_FALSE(isMutated(Results, AST.get()));
  451   EXPECT_FALSE(isMutated(Results, AST.get()));
  456   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("y = std::move(x)"));
  462   EXPECT_FALSE(isMutated(Results, AST.get()));
  471   EXPECT_FALSE(isMutated(Results, AST.get()));
  477   EXPECT_THAT(mutatedBy(Results, AST.get()),
  487   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x)"));
  493   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x)"));
  499   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(t, x)"));
  505   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("t.mf(x)"));
  512   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("s.mf(x)"));
  519   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("s.mf<T>(x)"));
  525   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("f(x)"));
  531   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("T(x)"));
  538   EXPECT_FALSE(isMutated(Results, AST.get()));
  542   EXPECT_FALSE(isMutated(Results, AST.get()));
  547   EXPECT_FALSE(isMutated(Results, AST.get()));
  554   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("return x;"));
  561   EXPECT_FALSE(isMutated(Results, AST.get()));
  569   EXPECT_THAT(mutatedBy(Results, AST.get()),
  578   EXPECT_FALSE(isMutated(Results, AST.get()));
  585   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("&x"));
  593   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x"));
  606   EXPECT_THAT(mutatedBy(ResultsX, AST.get()), ElementsAre("g(x)"));
  609   EXPECT_THAT(mutatedBy(ResultsY, AST.get()), ElementsAre("y"));
  618   EXPECT_THAT(mutatedBy(Results, AST.get()),
  626   EXPECT_THAT(mutatedBy(Results, AST.get()),
  636   EXPECT_FALSE(isMutated(Results, AST.get()));
  640   EXPECT_FALSE(isMutated(Results, AST.get()));
  647   EXPECT_FALSE(isMutated(Results, AST.get()));
  655   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("r", "r = 10"));
  663   EXPECT_FALSE(isMutated(Results, AST.get()));
  671   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x)"));
  678   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x)"));
  685   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x, y)"));
  687   EXPECT_FALSE(isMutated(Results, AST.get()));
  694   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(y, x)"));
  696   EXPECT_FALSE(isMutated(Results, AST.get()));
  701   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x"));
  707   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x"));
  713   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x"));
  723   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x)"));
  731   EXPECT_FALSE(isMutated(Results, AST.get()));
  736   EXPECT_FALSE(isMutated(Results, AST.get()));
  741   EXPECT_FALSE(isMutated(Results, AST.get()));
  746   EXPECT_FALSE(isMutated(Results, AST.get()));
  753   EXPECT_FALSE(isMutated(Results, AST.get()));
  758   EXPECT_FALSE(isMutated(Results, AST.get()));
  764   EXPECT_FALSE(isMutated(Results, AST.get()));
  770   EXPECT_FALSE(isMutated(Results, AST.get()));
  780   EXPECT_FALSE(isMutated(Results, AST.get()));
  787   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x[0] = 10"));
  794   EXPECT_FALSE(isMutated(Results, AST.get()));
  803   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x.vb.va.vi = 10"));
  809   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x.y.z = 10"));
  816   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x.y.z = 10"));
  825   EXPECT_FALSE(isMutated(Results, AST.get()));
  830   EXPECT_FALSE(isMutated(Results, AST.get()));
  837   EXPECT_FALSE(isMutated(Results, AST.get()));
  845   EXPECT_FALSE(isMutated(Results, AST.get()));
  853   EXPECT_THAT(mutatedBy(Results, AST.get()),
  859   EXPECT_THAT(mutatedBy(Results, AST.get()),
  868   EXPECT_FALSE(isMutated(Results, AST.get()));
  876   EXPECT_FALSE(isMutated(Results, AST.get()));
  881   EXPECT_FALSE(isMutated(Results, AST.get()));
  890   EXPECT_TRUE(isMutated(Results, AST.get()));
  899   EXPECT_TRUE(isMutated(Results, AST.get()));
  909   EXPECT_TRUE(isMutated(Results, AST.get()));
  919   EXPECT_FALSE(isMutated(Results, AST.get()));
  929   EXPECT_TRUE(isMutated(Results, AST.get()));
  939   EXPECT_TRUE(isMutated(Results, AST.get()));
  945   EXPECT_TRUE(isMutated(Results, AST.get()));
  956   EXPECT_TRUE(isMutated(Results, AST.get()));
  967   EXPECT_TRUE(isMutated(Results, AST.get()));
  975   EXPECT_FALSE(isMutated(Results, AST.get()));
  984   EXPECT_TRUE(isMutated(Results, AST.get()));
  994   EXPECT_TRUE(isMutated(Results, AST.get()));
 1012   EXPECT_TRUE(isMutated(Results, AST.get()));
 1019   EXPECT_FALSE(isMutated(Results, AST.get()));
 1026   EXPECT_FALSE(isMutated(Results, AST.get()));
 1033   EXPECT_THAT(mutatedBy(Results, AST.get()),
 1041   EXPECT_THAT(mutatedBy(Results, AST.get()),
 1050   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("e", "e = 10"));
 1055   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("e", "e = 10"));
 1063   EXPECT_FALSE(isMutated(Results, AST.get()));
 1070   EXPECT_FALSE(isMutated(Results, AST.get()));
 1075   EXPECT_FALSE(isMutated(Results, AST.get()));
 1081   EXPECT_FALSE(isMutated(Results, AST.get()));
 1089   EXPECT_FALSE(isMutated(Results, AST.get()));
 1094   EXPECT_FALSE(isMutated(Results, AST.get()));
 1103   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("e", "e = 10"));
 1111   EXPECT_FALSE(isMutated(Results, AST.get()));
 1120   EXPECT_FALSE(isMutated(Results, AST.get()));
 1129   EXPECT_FALSE(isMutated(Results, AST.get()));
 1136   EXPECT_FALSE(isMutated(Results, AST.get()));
 1140   EXPECT_FALSE(isMutated(Results, AST.get()));
 1144   EXPECT_FALSE(isMutated(Results, AST.get()));
 1148   EXPECT_FALSE(isMutated(Results, AST.get()));
 1152   EXPECT_FALSE(isMutated(Results, AST.get()));
 1156   EXPECT_FALSE(isMutated(Results, AST.get()));
 1162   EXPECT_FALSE(isMutated(Results, AST.get()));
 1167   EXPECT_FALSE(isMutated(Results, AST.get()));
 1174   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x++"));
 1182   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x.f()"));
 1201   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("* x = 10"));
 1205   EXPECT_FALSE(isMutated(Results, AST.get()));
 1210   EXPECT_FALSE(isMutated(Results, AST.get()));
 1215   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x"));
 1221   EXPECT_FALSE(isMutated(Results, AST.get()));
 1227   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x"));
 1233   EXPECT_FALSE(isMutated(Results, AST.get()));
 1239   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x->mf()"));
 1259   EXPECT_FALSE(isMutated(Results11, AST11.get()));

  146     Parser &P = *ParseOP.get();

   88       DiagOpts, DiagPrinter.get(), /*ShouldOwnClient=*/false);

  138   ASSERT_TRUE(AST.get());
  158   ASSERT_TRUE(AST.get());
  181   ASSERT_TRUE(AST.get());
  205   ASSERT_TRUE(AST.get());
  231   ASSERT_TRUE(AST.get());

   39   auto *RawB = B.get();
   57   auto *RawB = B.get();
   76   auto *RawB1 = B1.get();
   77   auto *RawB2 = B2.get();
  107   auto *RawB = B.get();

  170   EXPECT_EQ(Executor->get()->getExecutorName(),
  181   EXPECT_EQ(Executor->get()->getExecutorName(), TestToolExecutor::ExecutorName);

  121   ASSERT_TRUE(AST.get());
  122   EXPECT_TRUE(FindClassDeclX(AST.get()));
  125   ASSERT_TRUE(AST.get());
  126   EXPECT_FALSE(FindClassDeclX(AST.get()));
  133   EXPECT_TRUE(Action.get() != nullptr);
  147   EXPECT_TRUE(Action.get() != nullptr);
  232   Tool.run(Action.get());
  392   Tool.run(Action.get());
  400   Tool.run(Action.get());
  428   Tool.run(Action.get());
  447   EXPECT_EQ(0, Tool.run(Action.get()));
  469   Tool.run(Action.get());
  500   Tool.run(Action.get());
  624   Tool.run(Action.get());

 2477         static_cast<const EnumArgument *>(ai.get())->writeConversion(OS);
 2479         static_cast<const VariadicEnumArgument *>(ai.get())
 2694           SuperClass->SubClasses.push_back(Class.get());
 2737           return Class.get();

  849     return ScalarTypes[Name].get();
  858     return VectorTypes[key].get();
  865     return MultiVectorTypes[key].get();
  871     return PredicateTypes[key].get();
  878     return PointerTypes[key].get();
  976       const ScalarType *RT = kv.second.get();
 1266     const ScalarType *ST = kv.second.get();

  129     Result.push_back(Object.get());
  136     if (const auto *MachO = dyn_cast<object::MachOObjectFile>(Obj.get())) {

   69         const auto *Derived = dyn_cast<ObjectFileType>(Object.get());

  114   return CU != Units.end() ? CU->get() : nullptr;
 1007     AbbreviationsSet.InsertNode(Abbreviations.back().get(), InsertToken);
 2558     ObjectContexts.emplace_back(Map, *this, *Obj.get());

   70   MC.reset(new MCContext(MAI.get(), MRI.get(), MOFI.get()));
   70   MC.reset(new MCContext(MAI.get(), MRI.get(), MOFI.get()));
   70   MC.reset(new MCContext(MAI.get(), MRI.get(), MOFI.get()));
  222       Asm.get(), Table, CompUnits,
  233   emitAppleAccelTable(Asm.get(), Table, "namespac", SectionBegin);
  241   emitAppleAccelTable(Asm.get(), Table, "names", SectionBegin);
  249   emitAppleAccelTable(Asm.get(), Table, "objc", SectionBegin);
  257   emitAppleAccelTable(Asm.get(), Table, "types", SectionBegin);

   85     if (get_input_file(Handle, File.get()) != LDPS_OK)
 1002       LinkedObjects.get());

  537       OS = BOS.get();

  214   return ts.get()->session.get();

  186       Archive *archive = file.get();

  394   if (auto e = merger.merge(*defaultXmlCopy.get()))
  401     if (auto e = merger.merge(*manifest.get()))
  406   return merger.getMergedManifest().get()->getBuffer();
  435       .get()
  710     object::WindowsResource *rf = dyn_cast<object::WindowsResource>(bin.get());

  168   COFFObjectFile *coffObj = cast<COFFObjectFile>(coffObjPtr.get());
  188   if (auto *obj = dyn_cast<COFFObjectFile>(bin.get())) {

  155   COFFObjectFile *getCOFFObj() { return coffObj.get(); }

  103         config->thinLTOEmitImportsFiles, indexFile.get(), OnIndexWrite);

 1155     file.moduleDBI->addDebugSubsection(mergeInlineeLines(newChecksums.get()));

   24         dwarf->getLineTableForUnit(cu.get(), report);
   36       DWARFDie die(cu.get(), &entry);

  139         config->thinLTOEmitImportsFiles, indexFile.get(), onIndexWrite);

 1096   ctx = deleter.get();

   66   File *getFile() { return _file.get(); }

  102     auto *filePtr = file.get();

  185     if (FileNode *node = dyn_cast<FileNode>(inputs[i].get()))
  195   if (GroupEnd *group = dyn_cast<GroupEnd>(inputs[index].get())) {
  207   return cast<FileNode>(inputs[index++].get())->getFile();

  105   if (auto *archive = dyn_cast<ArchiveLibraryFile>(file.get())) {
  130   if (SharedLibraryFile *shl = dyn_cast<SharedLibraryFile>(file.get())) {
  176   StringRef buffer = mb->get()->getBuffer();
  206   StringRef buffer = mb->get()->getBuffer();
  264   StringRef buffer = mb->get()->getBuffer();
 1165     if (FileNode *node = dyn_cast<FileNode>(ie.get()))
 1185     merged = mergedFile.get();

   72     File *file = result.get();

  237   DebugInfo* debugInfo() const { return _debugInfo.get(); }

  176     FileNode *node = dyn_cast<FileNode>(nodes[i].get());
  687   MachODylibFile *result = reinterpret_cast<MachODylibFile *>(file.get());
  762     _flatNamespaceFile = result.back().get();
  806     _sectCreateFile = sectCreateFile.get();
  907   addDependencyInfoHelper(_dependencyInfo.get(), 0x00, "lld" /*FIXME*/);
  912   addDependencyInfoHelper(_dependencyInfo.get(), 0x10, path);
  916   addDependencyInfoHelper(_dependencyInfo.get(), 0x11, path);
  920   addDependencyInfoHelper(_dependencyInfo.get(), 0x40, path);
 1001   if (FileNode *node = dyn_cast<FileNode>(const_cast<Node *>(elem.get()))) {

  152   StringRef fileBuffer = b->get()->getBuffer();

 1593   NormalizedFile &normFile = *f.get();

 1405   if (auto ec = normalizedObjectToAtoms(file.get(), normalizedFile, copyRefs))
 1415   if (auto ec = normalizedDylibToAtoms(file.get(), normalizedFile, copyRefs))

  808   yamlContext._normalizeMachOFile = f.get();

   45     return writeBinary(*nFile->get(), path);

   68     auto *obj = cast<WasmObjectFile>(bin.get());
  253   auto *obj = dyn_cast<WasmObjectFile>(bin.get());

  101   const WasmObjectFile *getWasmObj() const { return wasmObj.get(); }

  150     assert(m_command_interpreter_up.get());

  445     if (synth_ptr && ((FrontEnd *)synth_ptr.get())->IsValid())

  107   FunctionCaller *GetFunctionCaller() { return m_caller_up.get(); }

   42   SymbolFile *GetSymbolFile() { return m_sym_file_up.get(); }

 2192   OperatingSystem *GetOperatingSystem() { return m_os_up.get(); }
 2205     return m_dynamic_checkers_up.get();
 2551     if (m_next_event_action_up.get())

 1161     ThreadSpec *GetThreadSpecifier() { return m_thread_spec_up.get(); }
 1280     Architecture *GetPlugin() const { return m_plugin_up.get(); }

   62   T *getItem() { return Item.get(); }
   63   const T *getItem() const { return Item.get(); }
   65   void *data() override { return Item.get(); }

  262     return static_cast<T *>(it->second.get());

  184 Address *SBAddress::operator->() { return m_opaque_up.get(); }
  186 const Address *SBAddress::operator->() const { return m_opaque_up.get(); }
  197   assert(m_opaque_up.get());
  201 Address *SBAddress::get() { return m_opaque_up.get(); }

  142   return m_opaque_up.get();

   62   return m_opaque_up.get() && m_opaque_up->IsValid();
   71   if (m_opaque_up.get() && m_opaque_up->GetFile())
  123   lldb_private::Declaration *lhs_ptr = m_opaque_up.get();
  124   lldb_private::Declaration *rhs_ptr = rhs.m_opaque_up.get();
  136   lldb_private::Declaration *lhs_ptr = m_opaque_up.get();
  137   lldb_private::Declaration *rhs_ptr = rhs.m_opaque_up.get();
  146   return m_opaque_up.get();
  177 lldb_private::Declaration *SBDeclaration::get() { return m_opaque_up.get(); }

  155 lldb_private::Status *SBError::operator->() { return m_opaque_up.get(); }
  157 lldb_private::Status *SBError::get() { return m_opaque_up.get(); }

  268   return m_opaque_up.get();
  272   return *(m_opaque_up.get());

  157   return m_opaque_up.get();
  161   return m_opaque_up.get();

   92   return m_opaque_up.get();
   96   return m_opaque_up.get();

   82   return m_opaque_up.get() && m_opaque_up->IsValid();
   89   if (m_opaque_up.get() && m_opaque_up->file)
  138   lldb_private::LineEntry *lhs_ptr = m_opaque_up.get();
  139   lldb_private::LineEntry *rhs_ptr = rhs.m_opaque_up.get();
  151   lldb_private::LineEntry *lhs_ptr = m_opaque_up.get();
  152   lldb_private::LineEntry *rhs_ptr = rhs.m_opaque_up.get();
  161   return m_opaque_up.get();
  190 lldb_private::LineEntry *SBLineEntry::get() { return m_opaque_up.get(); }

  135   return m_opaque_up.get();
  139   assert(m_opaque_up.get());

   94   m_opaque_up.reset(new SourceManagerImpl(*(rhs.m_opaque_up.get())));
  103   m_opaque_up.reset(new SourceManagerImpl(*(rhs.m_opaque_up.get())));

   49   return static_cast<StreamString *>(m_opaque_up.get())->GetData();
   60   return static_cast<StreamString *>(m_opaque_up.get())->GetSize();
   84       local_data = static_cast<StreamString *>(m_opaque_up.get())->GetString();
  132       local_data = static_cast<StreamString *>(m_opaque_up.get())->GetString();
  153       local_data = static_cast<StreamString *>(m_opaque_up.get())->GetString();
  165 lldb_private::Stream *SBStream::operator->() { return m_opaque_up.get(); }
  167 lldb_private::Stream *SBStream::get() { return m_opaque_up.get(); }
  184       static_cast<StreamString *>(m_opaque_up.get())->Clear();

   45   return m_opaque_up.get();

   32     : m_impl_up(new StructuredDataImpl(*rhs.m_impl_up.get())) {

  178   return m_opaque_up.get();
  182   assert(m_opaque_up.get());
  199   return m_opaque_up.get();
  225   if (m_opaque_up.get() && curr_frame_pc.IsValid()) {

   77   if (sc.IsValid() && m_opaque_up.get())
   85   if (sc_list.IsValid() && m_opaque_up.get())
  100   return m_opaque_up.get();
  104   assert(m_opaque_up.get());

   85                                                      args_data.m_impl_up.get());

  655   return m_opaque_up.get();

   45   return m_opaque_up.get();
   83   return m_opaque_up.get();
   88   return m_opaque_up.get();
   92   return m_opaque_up.get();

  117 ValueListImpl *SBValueList::operator->() { return m_opaque_up.get(); }
  122   return m_opaque_up.get();
  199 void *SBValueList::opaque_ptr() { return m_opaque_up.get(); }

  223 VariablesOptionsImpl *SBVariablesOptions::get() { return m_opaque_up.get(); }

  447 BreakpointOptions *Breakpoint::GetOptions() { return m_options_up.get(); }
  450   return m_options_up.get();

   60     return m_options_up.get();
  374   return m_options_up.get();

  334           interp->SetBreakpointCommandCallback(bp_options.get(), cmd_data_up);
  506   return m_thread_spec_up.get();
  515   return m_thread_spec_up.get();

  106   return m_thread_spec_up.get();
  113   return m_thread_spec_up.get();

  805           output_stream_p = output_stream_storage.get();

 1422       m_command_interpreter_up.get(),
 1449           } else if (broadcaster == m_command_interpreter_up.get()) {

 1258   return m_sections_up.get();
 1278   return m_sections_up.get();

  269                 static_cast<void *>(m_synth_filter_up.get()));

  610     return iter->second.get();

   46       m_module_up(module_up.release()), m_module(m_module_up.get()),
  320     m_execution_engine_up->setObjectCache(m_object_cache_up.get());

   65     return m_caller_up.get();
  109   return m_caller_up.get();

   90     return m_threads[idx].get();
   98       return thread.get();
  178       watchpoint_established_threads.push_back(thread.get());
  255       breakpoint_established_threads.push_back(thread.get());

  117     int err = ::tcgetattr(fd, m_termios_up.get());
  149       tcsetattr(fd, TCSANOW, m_termios_up.get());

 1130     m_alias_dict[alias_name] = CommandObjectSP(command_alias_up.get());

  809       interpreter, completion_mask, request, filter_up.get());

  282           mc_disasm_ptr = disasm->m_alternate_disasm_up.get();
  284           mc_disasm_ptr = disasm->m_disasm_up.get();
  916           return disasm->m_alternate_disasm_up.get();
  919       return disasm->m_disasm_up.get();
  960       new llvm::MCContext(asm_info_up.get(), reg_info_up.get(), nullptr));
  960       new llvm::MCContext(asm_info_up.get(), reg_info_up.get(), nullptr));
  977           context_up.get(), std::move(rel_info_up)));
 1245     if (disasm_up.get() && disasm_up->IsValid())

  162   assert(m_parser_vars.get());
  227         *m_merger_up.get(), scratch_ast_context->GetMergerUnchecked(),
  243   assert(m_parser_vars.get());
  355   assert(m_struct_vars.get());
  356   assert(m_parser_vars.get());
  442   assert(m_struct_vars.get());
  460   assert(m_struct_vars.get());
  477   assert(m_struct_vars.get());
  629   assert(m_parser_vars.get());
 1616   assert(m_parser_vars.get());
 1716   assert(m_parser_vars.get());
 1894   assert(m_parser_vars.get());

  358     if (!m_parser_vars.get())
  388     if (!m_struct_vars.get())

  521     SetupModuleHeaderPaths(m_compiler.get(), m_include_directories,
  592         static_cast<LLDBPreprocessorCallbacks *>(pp_callbacks.get());
  961       type_system_helper->ASTTransformer(m_code_generator.get());
  967     Consumer.reset(new ASTConsumerForwarder(m_code_generator.get()));
 1108     const auto *diagnostic = llvm::dyn_cast<ClangDiagnostic>(diag.get());
 1189     if (!FindFunctionInModule(function_name, llvm_module_up.get(),

  223   FileID FID = SM.createFileID(clang::SourceManager::Unowned, buf.get());
  233   Lexer lex(FID, buf.get(), SM, Opts);

  213   return m_struct_extractor.get();

  579   if (!DeclMap()->WillParse(exe_ctx, m_materializer_up.get())) {
  767   if (!DeclMap()->WillParse(exe_ctx, m_materializer_up.get())) {
  901   return m_result_synthesizer_up.get();

   59       return m_expr_decl_map_up.get();

   51       return m_expr_decl_map_up.get();

  148   assert(m_reg_info.get());
  151   assert(m_insn_info.get());
  158   assert(m_asm_info.get() && m_subtype_info.get());
  158   assert(m_asm_info.get() && m_subtype_info.get());
  161       new llvm::MCContext(m_asm_info.get(), m_reg_info.get(), nullptr));
  161       new llvm::MCContext(m_asm_info.get(), m_reg_info.get(), nullptr));
  162   assert(m_context.get());
  165   assert(m_disasm.get());
  175   assert(m_alt_subtype_info.get());
  179   assert(m_alt_disasm.get());

  152   assert(m_reg_info.get());
  155   assert(m_insn_info.get());
  162   assert(m_asm_info.get() && m_subtype_info.get());
  162   assert(m_asm_info.get() && m_subtype_info.get());
  165       new llvm::MCContext(m_asm_info.get(), m_reg_info.get(), nullptr));
  165       new llvm::MCContext(m_asm_info.get(), m_reg_info.get(), nullptr));
  166   assert(m_context.get());
  169   assert(m_disasm.get());

  154   FileID FID = SM.createFileID(clang::SourceManager::Unowned, buf.get());
  164   Lexer lex(FID, buf.get(), SM, Opts);

  240   return m_PrintForDebugger_addr.get();

 2021   return m_decl_vendor_up.get();

   87     return m_tagged_pointer_vendor_up.get();

 3147     alloc = m_allocations[alloc_id - 1].get();
 3154       alloc = a.get();
 3328     if (!RefreshAllocation(alloc.get(), frame_ptr)) {
 3358     if (alloc->ShouldRefresh() && !RefreshAllocation(alloc.get(), frame_ptr)) {
 3823         return s.get();
 3829     return m_scripts.back().get();
 3839         return a.get();
 3864   return m_allocations.back().get();
 4593         output_stream_p = output_stream_storage.get();

 2277   SectionList *section_list = m_sections_up.get();
 2502   SectionList *section_list = m_sections_up.get();
 2712       symbol_id += ParseSymbolTable(m_symtab_up.get(), symbol_id, symtab);
 2729         symbol_id += ParseSymbolTable(m_symtab_up.get(), symbol_id, dynsym);
 2757         ParseTrampolineSymbols(m_symtab_up.get(), symbol_id, reloc_header,
 2766       ParseUnwindSymbols(m_symtab_up.get(), eh_frame);
 2821   return m_symtab_up.get();

  131   return m_symtab_up.get();

  811     if (objfile_up.get() && objfile_up->ParseHeader())
 1256   return m_symtab_up.get();
 2156   Symtab *symtab = m_symtab_up.get();

  156   if (objfile_up.get() && objfile_up->ParseHeader()) {
  763   return m_symtab_up.get();

   59     if (os_up.get() && os_up->IsValid())
  138   return m_register_info_up.get();

  388     return m_adb_sync_svc.get();
  392   return (error.Success()) ? m_adb_sync_svc.get() : nullptr;

   58     options->Append(m_option_group_platform_rsync.get());
   59     options->Append(m_option_group_platform_ssh.get());
   60     options->Append(m_option_group_platform_caching.get());
   64   return m_options.at(&interpreter).get();
  464     if (m_option_group_platform_rsync.get() &&
  465         m_option_group_platform_ssh.get() &&
  466         m_option_group_platform_caching.get()) {

  606     auto *main_thread = static_cast<NativeThreadLinux *>(m_threads[0].get());
 1155       running_thread = thread.get();
 1160       stopped_thread = thread.get();
 1707       static_cast<NativeThreadLinux *>(thread.get())->RequestStop();

  357   m_iovec.iov_base = m_xstate.get();
  361   ::memset(m_xstate.get(), 0, xstate_size);
  528   uint8_t *src = (uint8_t *)m_xstate.get() + reg_info->byte_offset -
  637       uint8_t *dst = (uint8_t *)m_xstate.get() + reg_info->byte_offset -
  728     ::memcpy(dst, m_xstate.get(), sizeof(FPR));

  155       (reinterpret_cast<uint8_t *>(m_mmap_meta.get()) +
  165   return MutableArrayRef<uint8_t>(m_mmap_aux.get(), m_mmap_meta->aux_size);

  109           m_register_info_up.get());
  113         m_register_info_up.get());
  118         m_register_info_up.get());
  132           m_register_info_up.get());
  136         m_register_info_up.get());
  141         m_register_info_up.get());

  255   if (m_dyld_up.get() == nullptr)
  258   return m_dyld_up.get();

 1643     return SendWResponse(m_debugged_process_up.get());

 3984   if (m_dyld_up.get() == nullptr)
 3986   return m_dyld_up.get();

  504   if (m_dyld_up.get() == nullptr)
  508   return m_dyld_up.get();

   73   Symtab *GetSymtab() override { return m_symtab_up.get(); }

 2274               bp_option_data->m_extra_args_up.get());

  700         line_seq_up.get(), *next_addr, /*line*/ 0, /*column*/ 0,
  704     data.line_table_up->InsertSequence(line_seq_up.get());
  723         line_seq_up.get(), record->Address, record->LineNum, /*column*/ 0,

 1735         m_property_attributes, m_metadata_up.get());

   63       cu->BuildAddressRangeTable(m_cu_aranges_up.get());

  719   return m_dwo_symbol_file.get();
  727       die->BuildFunctionAddressRangeTable(this, m_func_aranges_up.get());
  734                                                 m_func_aranges_up.get());

  606     return m_abbr.get();
  622   return m_abbr.get();
  626   return m_abbr.get();
  637   return m_info.get();
  641   return m_info.get();
  672   return m_ranges.get();
  687   return m_rnglists.get();
 1019         debug_map_symfile->LinkOSOLineTable(this, line_table_up.get()));
 1167           block->SetInlinedFunctionInfo(name, mangled_name, decl_up.get(),
 1168                                         call_up.get());
 3854   return m_dwp_symfile.get();

  180     if (m_symfile_up.get() || !can_create)

  179   return iter->second.get();
  186   return iter->second.get();

 1053   table.AppendLineEntryToSequence(seq.get(), base_addr + block.CodeSize,

  251   auto parent_udt = llvm::dyn_cast<PDBSymbolTypeUDT>(parent.get());
  804     auto udt = llvm::dyn_cast<PDBSymbolTypeUDT>(symbol.get());
 1090     symbol = symbol_up.get();
 1092     symbol = global_up.get();

  192   lldbassert(m_global_scope_up.get());
  214   lldbassert(last_compiland_up.get());
  427           func_file_vm_addr, symbol_up.get(), block, false);
  445       pdb_func_up->getVirtualAddress(), pdb_func_up.get(), &parent_block, true);
  755       auto *pdb_func = llvm::dyn_cast<PDBSymbolFunc>(symbol_up.get());
  873                 auto pdb_func = llvm::dyn_cast<PDBSymbolFunc>(symbol_up.get());
 1117     auto pdb_data = llvm::dyn_cast<PDBSymbolData>(result.get());
 1486       if (auto enum_type = llvm::dyn_cast<PDBSymbolTypeEnum>(result.get()))
 1489                    llvm::dyn_cast<PDBSymbolTypeTypedef>(result.get()))
 1491       else if (auto class_type = llvm::dyn_cast<PDBSymbolTypeUDT>(result.get()))
 1819             sequence.get(), prev_addr + prev_length, prev_line, 0,
 1842         line_table->AppendLineEntryToSequence(sequence.get(), addr, lno, col,
 1856           sequence.get(), prev_addr + prev_length, prev_line, 0,
 1935                     symbol_up.get())) {

   57       m_inst_emulator_up.get()) {

   72     if (m_inst_emulator_up.get()) {

  649   GetASTMap().Erase(m_ast_up.get());
  666   assert(s == nullptr || &s->getASTContext() == m_ast_up.get());
  689   return m_ast_up.get();
  713   GetASTMap().Insert(m_ast_up.get(), this);
  731   return m_builtins_up.get();
  738   return m_identifier_table_up.get();
  748   return m_language_options_up.get();
  754   return m_selector_table_up.get();
  763   return m_file_manager_up.get();
  770   return m_source_manager_up.get();
  779   return m_diagnostics_engine_up.get();
  785   return m_mangle_ctx_up.get();
  816   return m_diagnostic_consumer_up.get();
  833   return m_target_info_up.get();
 8342     raw_bases.push_back(b.get());
 9852   return m_dwarf_ast_parser_up.get();
 9858   return m_pdb_ast_parser_up.get();
10340   return m_persistent_variables.get();

  148   return m_line_table_up.get();

  598               static_cast<void *>(m_symtab_up.get()));
  616   return m_sections_up.get();

 1066                                *(m_file_spec_up.get()), false))
 1074         if (!FileSpec::Equal(*(sc.comp_unit), *(m_file_spec_up.get()), false))

  176   return m_object_file_unwind_up.get();
  181   return m_eh_frame_up.get();
  186   return m_debug_frame_up.get();
  191   return m_compact_unwind_up.get();
  196   return m_arm_unwind_up.get();

   59     return iter->second.get();
  115     if (!callback(entry.second.get()))

 2648   return m_dyld_up.get();
 2664   return m_system_runtime_up.get();
 5977   return m_dlopen_utility_func_up.get();

 2499   return m_clang_modules_decl_vendor_up.get();

 2074   return m_unwinder_up.get();

  352   const RegularExpression *avoid_regexp_to_use = m_avoid_regexp_up.get();

  158   return e.first->getSecond().get();
  256   return m_data_recorders.back().get();
  301   return m_stream_up.get();

   72       std::make_pair(m_replayers[RunID].first.get(), std::move(signature));

  355   return T.run(newFrontendActionFactory<SBAction>().get());

  115           static_cast<TCPSocket *>(listener_socket_up.get());

  114   if (!input.read_expected(log.get(), "Content-Length: "))
  117   if (!input.read_line(log.get(), length_str))
  123   if (!input.read_expected(log.get(), "\r\n"))
  126   if (!input.read_full(log.get(), length, json_str))

   49   const Diagnostic *got = mgr.Diagnostics().front().get();

   42   std::thread accept_thread(AcceptThread, listen_socket_up.get(),
   56   EXPECT_NE(nullptr, a_up->get());
   62   EXPECT_NE(nullptr, b_up->get());

  208   ASSERT_NE(cfi.get(), nullptr);

   58       ConvertMinidumpContext_x86_32(ContextRef, RegInterface.get());
  119       ConvertMinidumpContext_x86_64(ContextRef, RegInterface.get());

  238   CompilerType bool_type(m_ast.get(), bool_ctype);
  423       CompilerDeclContext(m_ast.get(), m_ast->GetTranslationUnitDecl()));
  426       m_ast.get(),
  432   CompilerType int_type(m_ast.get(), m_ast->getASTContext()->IntTy.getAsOpaquePtr());

   65     if (const auto *Reply = llvm::dyn_cast<T>(m_stop_reply.get()))

  322                        GlobalValue::ExternalLinkage, "__main", M.get());
  388   Module *Mod = Owner.get();
  465     EE->setObjectCache(CacheManager.get());

  125   if (!M.get()) {
  134     if (verifyModule(*M.get(), &OS)) {
  144     errs() << "Here's the assembly:\n" << *M.get();
  145     if (Index.get() && Index->begin() != Index->end())
  150     WriteOutputFile(M.get(), Index.get());
  150     WriteOutputFile(M.get(), Index.get());

  264   return RegisterInfo.get();
  267 const MCInstrInfo *FileAnalysis::getMCInstrInfo() const { return MII.get(); }
  270   return MIA.get();
  367   Printer->printInst(&InstrMeta.Instruction, OS, "", *SubtargetInfo.get());
  407   Context.reset(new MCContext(AsmInfo.get(), RegisterInfo.get(), &MOFI));
  407   Context.reset(new MCContext(AsmInfo.get(), RegisterInfo.get(), &MOFI));
  416   MIA.reset(ObjectTarget->createMCInstrAnalysis(MII.get()));
  435       const auto &LineTable = DWARF->getLineTableForUnit(Unit.get());

  272   printIndirectCFInstructions(Analysis, SpecialCaseList.get());

  532   View->print(*OS.get(), /*Wholefile=*/true,
  905         if (Filters.matches(*Coverage.get(), Function))
  927         FunctionView->print(*OS.get(), /*WholeFile=*/false,
  952       writeSourceFileView(SourceFile, Coverage.get(), Printer.get(),
  952       writeSourceFileView(SourceFile, Coverage.get(), Printer.get(),
  959                  Coverage.get(), Printer.get(), ShowFilenames);
  959                  Coverage.get(), Printer.get(), ShowFilenames);
  988   CoverageReport Report(ViewOpts, *Coverage.get());
 1043     Exporter = std::make_unique<CoverageExporterJson>(*Coverage.get(),
 1051     Exporter = std::make_unique<CoverageExporterLcov>(*Coverage.get(),

  292     emitPrelude(*OS.get(), Opts);
  295     emitPrelude(*OS.get(), Opts, getPathToStyle(ViewPath));
  302   emitEpilog(*OS.get());
  405   raw_ostream &OSRef = *OS.get();

   37   raw_ostream &OSRef = *OS.get();

   52   GCOVBuffer GCNO_GB(GCNO_Buff.get().get());
   68     GCOVBuffer GCDA_GB(GCDA_Buff.get().get());

   87     Engine.diff(LModule.get(), RModule.get());
   87     Engine.diff(LModule.get(), RModule.get());

  201     M->print(Out->os(), Annotator.get(), PreserveAssemblyUseListOrder);

  317       DWARFDie Die = {CU.get(), &Entry};
  491   if (auto *Obj = dyn_cast<ObjectFile>(BinOrErr->get())) {
  497   else if (auto *Fat = dyn_cast<MachOUniversalBinary>(BinOrErr->get()))
  517   else if (auto *Arch = dyn_cast<Archive>(BinOrErr->get()))

  686   MCContext MC(MAI.get(), MRI.get(), &MOFI);
  686   MCContext MC(MAI.get(), MRI.get(), &MOFI);

  376   Binary *Bin = BinOrErr->get();

  176   Context_ = std::make_unique<MCContext>(AsmInfo_.get(), RegInfo_.get(),
  176   Context_ = std::make_unique<MCContext>(AsmInfo_.get(), RegInfo_.get(),

  165       FunctionID, Module.get(), &MMIWP.get()->getMMI());
  165       FunctionID, Module.get(), &MMIWP.get()->getMMI());
  178   auto MMIWP = std::make_unique<MachineModuleInfoWrapperPass>(TM.get());
  180       FunctionID, Module.get(), &MMIWP.get()->getMMI());
  180       FunctionID, Module.get(), &MMIWP.get()->getMMI());

  138                                       Scratch.get());

  145   if (!M.get()) {
  375   Passes.run(*M.get());

  705   MCContext Ctx(MAI.get(), MRI.get(), nullptr);
  705   MCContext Ctx(MAI.get(), MRI.get(), nullptr);
  742       Disassembler.get(), InstPrinter.get(), dbgs());
  742       Disassembler.get(), InstPrinter.get(), dbgs());

  284     if (!M.get()) {

  182       Binary *Bin = ChildOrErr.get().get();
  498         OS << Slice(MachOObjOrError->get()).getArchString() << " ";
  504         OS << Slice(ArchiveOrError->get()).getArchString() << " ";
  568   Binary *B = Obj ? static_cast<Binary *>(Obj->get())
  569                   : static_cast<Binary *>(Ar->get());
  638         Slices.emplace_back(ExtractedObjects.back().get(), O.getAlign());

  343         if (auto *FuncSummary = dyn_cast<FunctionSummary>(Summary.get())) {
  346         } else if (isa<AliasSummary>(Summary.get()))
  397     for (size_t I = 0, C = LTOModule::getDependentLibraryCount(Input.get());
  400       const char *S = LTOModule::getDependentLibrary(Input.get(), I, &L);
  899       auto Buffer = std::move(BufferOrErr.get());
  968     } else if (!CodeGen.addModule(Module.get())) {

  340   MemoryBuffer *Buffer = BufferPtr->get();
  373   MCContext Ctx(MAI.get(), MRI.get(), &MOFI, &SrcMgr, &MCOptions);
  373   MCContext Ctx(MAI.get(), MRI.get(), &MOFI, &SrcMgr, &MCOptions);
  482       OS = BOS.get();

   44     P.addEventListener(V.get());

  367   MCContext Ctx(MAI.get(), MRI.get(), &MOFI, &SrcMgr);
  367   MCContext Ctx(MAI.get(), MRI.get(), &MOFI, &SrcMgr);
  376       TheTarget->createMCInstrAnalysis(MCII.get()));
  430   mca::InstrBuilder IB(*STI, *MCII, *MRI, MCIA.get());

  222   Object *Obj = ObjOrErr->get();

  772   return Symbols[Index].get();
 1429   return Sections[Index - 1].get();
 1816         if (auto RelSec = dyn_cast<RelocationSectionBase>(Sec.get())) {
 1835       Segment->removeSection(RemoveSec.get());
 1836     RemoveSections.insert(RemoveSec.get());

 1045     return SecIt == Sections.end() ? nullptr : SecIt->get();
 1057     auto Ptr = Sec.get();

  294     SymbolEntry *Sym = Iter->get();

   10   return Symbols[Index].get();

  194     if (Error E = executeObjcopyOnBinary(Config, *ChildOrErr->get(), MB))
  283     if (Error E = ProcessRaw(Config, *BufOrErr->get(), FB))

 2420               printArchiveHeaders(Filename, A.get(), !NonVerbose,
 2481             printArchiveHeaders(Filename, A.get(), !NonVerbose,
 2534         printArchiveHeaders(Filename, A.get(), !NonVerbose,
 7220   MCContext Ctx(AsmInfo.get(), MRI.get(), nullptr);
 7220   MCContext Ctx(AsmInfo.get(), MRI.get(), nullptr);
 7271     ThumbCtx.reset(new MCContext(ThumbAsmInfo.get(), ThumbMRI.get(), nullptr));
 7271     ThumbCtx.reset(new MCContext(ThumbAsmInfo.get(), ThumbMRI.get(), nullptr));
 7273     MCContext *PtrThumbCtx = ThumbCtx.get();
 7370       createBinary(DSYMBuf.get()->getMemBufferRef());
 7378       if (ObjectFile *O = dyn_cast<ObjectFile>(DSYMBinary.get())) {
 7389       else if (auto UB = dyn_cast<MachOUniversalBinary>(DSYMBinary.get())){

 1559   MCContext Ctx(AsmInfo.get(), MRI.get(), &MOFI);
 1559   MCContext Ctx(AsmInfo.get(), MRI.get(), &MOFI);
 1585       TheTarget->createMCInstrAnalysis(MII.get()));
 1603   disassembleObject(TheTarget, Obj, Ctx, DisAsm.get(), SecondaryDisAsm.get(),
 1603   disassembleObject(TheTarget, Obj, Ctx, DisAsm.get(), SecondaryDisAsm.get(),
 1604                     MIA.get(), IP.get(), STI.get(), SecondarySTI.get(), PIP,
 1604                     MIA.get(), IP.get(), STI.get(), SecondarySTI.get(), PIP,
 1604                     MIA.get(), IP.get(), STI.get(), SecondarySTI.get(), PIP,
 1604                     MIA.get(), IP.get(), STI.get(), SecondarySTI.get(), PIP,

  131   PassBuilder PB(TM.get());
  236   PassBuilder PB(TM.get());

 1401       dumpFullTypeStream(P, Types, RefTracker.get(), 0, 0, {}, nullptr,
 1473       (StreamIdx == StreamTPI) ? RefTracker.get() : nullptr;

  297   IF.PdbOrObj = IF.UnknownFile.get();

  315   if (auto *FS = dyn_cast<PDBSymbolTypeFunctionSig>(P.get())) {
  324   if (auto *UDT = dyn_cast<PDBSymbolTypeUDT>(P.get())) {

  858   NativeSession *NS = static_cast<NativeSession *>(Session.get());

  321       loadInput(Input, Remapper, Contexts[0].get());
  328       Pool.async(loadInput, Input, Remapper, Contexts[Ctx].get());
  339         Pool.async(mergeWriterContexts, Contexts[I].get(),
  340                    Contexts[I + Mid].get());
  343         Pool.async(mergeWriterContexts, Contexts[0].get(),
  344                    Contexts[End - 1].get());
  489     const auto Reader = Readers.back().get();
  527   handleExtBinaryWriter(*Writer, OutputFormat, Buffer.get(), WriterList,
  668   parseInputFilenamesFile(Buffer.get(), WeightedInputs);
  685     mergeInstrProfile(WeightedInputs, Remapper.get(), OutputFilename,
  688     mergeSampleProfile(WeightedInputs, Remapper.get(), OutputFilename,
 1029     showSectionInfo(Reader.get(), OS);

 1179   const MenuDefinition *DefPtr = Def.get();
 1349     VersionInfoStmt *ItemPtr = Item.get();

  187     ExitOnErr(NullResource().visit(Visitor.get()));
  190     ExitOnErr(LanguageResource(0x09, 0x01).visit(Visitor.get()));
  199       ExitOnErr(Resource->visit(Visitor.get()));

   34   Module *getProgram() const { return Program.get(); }

  132       ExtractChunksFromModule(CurrentChunks, Clone.get());

  415         DWARFContext::create(*SymbolObj, LoadedObjInfo.get());
  591                                        CheckerFileBuf.get().get()))
  759   MCContext Ctx(MAI.get(), MRI.get(), nullptr);
  759   MCContext Ctx(MAI.get(), MRI.get(), nullptr);
  924           Disassembler.get(), InstPrinter.get(), dbgs());
  924           Disassembler.get(), InstPrinter.get(), dbgs());

   22   llvm::SpecialCaseList::create(Buf.get(), Error);

  687   auto SM = Modifiers.back().get();
  739   Function *F = GenEmptyFunction(M.get());
  764   Passes.run(*M.get());

   90     return msDemangle(FileOrErr->get()->getBuffer()) ? 0 : 1;

  190   return LTOModule::isBitcodeForTarget(Buffer->get(),
  215   return LTOModule::isBitcodeForTarget(buffer.get(),

  141           DWARFDie DIEWrapper(CU.get(), &DIE);

  680     return runPassPipeline(argv[0], *M, TM.get(), Out.get(), ThinLinkOut.get(),
  680     return runPassPipeline(argv[0], *M, TM.get(), Out.get(), ThinLinkOut.get(),
  680     return runPassPipeline(argv[0], *M, TM.get(), Out.get(), ThinLinkOut.get(),
  681                            RemarksFile.get(), PassPipeline, OK, VK,
  712     FPasses.reset(new legacy::FunctionPassManager(M.get()));
  751       AddOptimizationPasses(Passes, *FPasses, TM.get(), 0, 0);
  756       AddOptimizationPasses(Passes, *FPasses, TM.get(), 1, 0);
  761       AddOptimizationPasses(Passes, *FPasses, TM.get(), 2, 0);
  766       AddOptimizationPasses(Passes, *FPasses, TM.get(), 2, 1);
  771       AddOptimizationPasses(Passes, *FPasses, TM.get(), 2, 2);
  776       AddOptimizationPasses(Passes, *FPasses, TM.get(), 3, 0);
  826     AddOptimizationPasses(Passes, *FPasses, TM.get(), 0, 0);
  829     AddOptimizationPasses(Passes, *FPasses, TM.get(), 1, 0);
  832     AddOptimizationPasses(Passes, *FPasses, TM.get(), 2, 0);
  835     AddOptimizationPasses(Passes, *FPasses, TM.get(), 2, 1);
  838     AddOptimizationPasses(Passes, *FPasses, TM.get(), 2, 2);
  841     AddOptimizationPasses(Passes, *FPasses, TM.get(), 3, 0);
  872       OS = BOS.get();

 2526     ScopArrayInfoSet.remove(It->second.get());
 2782   Scop *getScop() { return S.get(); }
 2783   const Scop *getScop() const { return S.get(); }
 2830       return MapIt->second.get();
 2887   ScopInfo *getSI() { return Result.get(); }
 2888   const ScopInfo *getSI() const { return Result.get(); }

  819   if (Dependences *d = D[Level].get())
  846   if (auto d = DI.D[OptAnalysisLevel].get()) {
  861   if (Dependences *d = D[Level].get())
  882   if (auto d = D[OptAnalysisLevel].get()) {
  916         return *It->second.get();
  933     recomputeDependences(It.second.get(), Dependences::AL_Access);

  105       return It.second.get();

 2547   auto VUse = VirtualUse::create(scop.get(), UserStmt, Scope, V, false);
 3746   verifyUses(scop.get(), LI, DT);

 1397         getBBPairForRegion(ExpandedRegion.get()),
 1417         DetectionContextMap.erase(getBBPairForRegion(LastValidRegion.get()));
 1454     if (ValidRegions.count(SubRegion.get())) {
 1455       removeCachedResults(*SubRegion.get());
 1497     ToExpand.push_back(SubRegion.get());

  177       printRegionCluster(SD, SubRegion.get(), O, depth + 1);

 1830     ScopArrayInfoSet.insert(SAI.get());
 1838   return SAI.get();
 1860   auto *SAI = ScopArrayInfoMap[std::make_pair(BasePtr, Kind)].get();

  104       if (auto *scop = S.second.get())
  119     auto *scop = S.second.get();

   39   Args.push_back(TempNode.get());

  711       json::parse(result.get().get()->getBuffer());

  165       parseMapOrNull(Ctx.get(), Existing.OccupiedStr);
  166   auto ExistingUnused = parseSetOrNull(Ctx.get(), Existing.UndefStr);
  167   auto ExistingWritten = parseMapOrNull(Ctx.get(), Existing.WrittenStr);
  170       parseMapOrNull(Ctx.get(), Proposed.OccupiedStr);
  171   auto ProposedUnused = parseSetOrNull(Ctx.get(), Proposed.UndefStr);
  172   auto ProposedWritten = parseMapOrNull(Ctx.get(), Proposed.WrittenStr);
  175       Ctx.get(), ExistingOccupiedAndKnown, ExistingUnused, ExistingWritten,
  185   auto ExistingOccupied = parseSetOrNull(Ctx.get(), Existing.OccupiedStr);
  186   auto ExistingUnused = parseSetOrNull(Ctx.get(), Existing.UndefStr);
  187   auto ExistingWritten = parseSetOrNull(Ctx.get(), Existing.WrittenStr);
  189   auto ProposedOccupied = parseSetOrNull(Ctx.get(), Proposed.OccupiedStr);
  190   auto ProposedUnused = parseSetOrNull(Ctx.get(), Proposed.UndefStr);
  191   auto ProposedWritten = parseSetOrNull(Ctx.get(), Proposed.WrittenStr);
  194       Ctx.get(), isl::union_map::from_domain(ExistingOccupied), ExistingUnused,

  292   isl::val ValOne = isl::val(IslCtx.get(), 1);
  293   isl::val ValTwo = isl::val(IslCtx.get(), 2);
  294   isl::val ValThree = isl::val(IslCtx.get(), 3);
  295   isl::val ValFour = isl::val(IslCtx.get(), 4);
  296   isl::val ValNegOne = isl::val(IslCtx.get(), -1);
  297   isl::val ValNegTwo = isl::val(IslCtx.get(), -2);
  298   isl::val ValNegThree = isl::val(IslCtx.get(), -3);
  299   isl::val ValNegFour = isl::val(IslCtx.get(), -4);
  301   isl::space Space = isl::space(IslCtx.get(), 0, 0);
  391   auto MapSpace = isl::space(Ctx.get(), 0, 1, 1);
  398   auto SetSpace = isl::space(Ctx.get(), 0, 1);
  451     auto UPwAff = isl::union_pw_aff(TestUSet, isl::val::zero(Ctx.get()));
  487     auto TestPwAff = isl::pw_aff(TestSet, isl::val::zero(Ctx.get()));
  506   EXPECT_EQ(MAP("{ [] -> [i] : i <= 0 }"),
  507             beforeScatter(MAP("{ [] -> [0] }"), false));
  508   EXPECT_EQ(MAP("{ [] -> [i] : i < 0 }"),
  509             beforeScatter(MAP("{ [] -> [0] }"), true));
  512   EXPECT_EQ(UMAP("{ A[] -> [i] : i <= 0; B[] -> [i] : i <= 0 }"),
  513             beforeScatter(UMAP("{ A[] -> [0]; B[] -> [0] }"), false));
  514   EXPECT_EQ(UMAP("{ A[] -> [i] : i < 0; B[] -> [i] : i < 0 }"),
  515             beforeScatter(UMAP("{ A[] -> [0]; B[] -> [0] }"), true));
  518   EXPECT_EQ(UMAP("{ [] -> [i, j] : i < 0;  [] -> [i, j] : i = 0 and j <= 0 }"),
  519             beforeScatter(UMAP("{ [] -> [0, 0] }"), false));
  520   EXPECT_EQ(UMAP("{ [] -> [i, j] : i < 0;  [] -> [i, j] : i = 0 and j < 0 }"),
  521             beforeScatter(UMAP("{ [] -> [0, 0] }"), true));
  524   EXPECT_EQ(UMAP("{ [i] -> [j] : j <= i }"),
  525             beforeScatter(UMAP("{ [i] -> [i] }"), false));
  526   EXPECT_EQ(UMAP("{ [i] -> [j] : j < i }"),
  527             beforeScatter(UMAP("{ [i] -> [i] }"), true));
  530   EXPECT_EQ(UMAP("[i] -> { [] -> [j] : j <= i }"),
  531             beforeScatter(UMAP("[i] -> { [] -> [i] }"), false));
  532   EXPECT_EQ(UMAP("[i] -> { [] -> [j] : j < i }"),
  533             beforeScatter(UMAP("[i] -> { [] -> [i] }"), true));
  536   EXPECT_EQ(UMAP("{ [] -> [i] : i <= 10 }"),
  537             beforeScatter(UMAP("{ [] -> [0]; [] -> [10] }"), false));
  538   EXPECT_EQ(UMAP("{ [] -> [i] : i < 10 }"),
  539             beforeScatter(UMAP("{ [] -> [0]; [] -> [10] }"), true));
  542   EXPECT_EQ(UMAP("{ [] -> [i] : 1 = 0 }"),
  543             beforeScatter(UMAP("{ [] -> [i] : 1 = 0 }"), false));
  544   EXPECT_EQ(UMAP("{ [] -> [i] : 1 = 0 }"),
  545             beforeScatter(UMAP("{ [] -> [i] : 1 = 0 }"), true));
  553   EXPECT_EQ(MAP("{ [] -> [i] : i >= 0 }"),
  554             afterScatter(MAP("{ [] -> [0] }"), false));
  555   EXPECT_EQ(MAP("{ [] -> [i] : i > 0 }"),
  556             afterScatter(MAP("{ [] -> [0] }"), true));
  559   EXPECT_EQ(UMAP("{ A[] -> [i] : i >= 0; B[] -> [i] : i >= 0 }"),
  560             afterScatter(UMAP("{ A[] -> [0]; B[] -> [0] }"), false));
  561   EXPECT_EQ(UMAP("{ A[] -> [i] : i > 0; B[] -> [i] : i > 0 }"),
  562             afterScatter(UMAP("{ A[] -> [0]; B[] -> [0] }"), true));
  565   EXPECT_EQ(UMAP("{ [] -> [i, j] : i > 0;  [] -> [i, j] : i = 0 and j >= 0 }"),
  566             afterScatter(UMAP("{ [] -> [0, 0] }"), false));
  567   EXPECT_EQ(UMAP("{ [] -> [i, j] : i > 0;  [] -> [i, j] : i = 0 and j > 0 }"),
  568             afterScatter(UMAP("{ [] -> [0, 0] }"), true));
  571   EXPECT_EQ(UMAP("{ [i] -> [j] : j >= i }"),
  572             afterScatter(UMAP("{ [i] -> [i] }"), false));
  573   EXPECT_EQ(UMAP("{ [i] -> [j] : j > i }"),
  574             afterScatter(UMAP("{ [i] -> [i] }"), true));
  577   EXPECT_EQ(UMAP("[i] -> { [] -> [j] : j >= i }"),
  578             afterScatter(UMAP("[i] -> { [] -> [i] }"), false));
  579   EXPECT_EQ(UMAP("[i] -> { [] -> [j] : j > i }"),
  580             afterScatter(UMAP("[i] -> { [] -> [i] }"), true));
  583   EXPECT_EQ(UMAP("{ [] -> [i] : i >= 0 }"),
  584             afterScatter(UMAP("{ [] -> [0]; [] -> [10] }"), false));
  585   EXPECT_EQ(UMAP("{ [] -> [i] : i > 0 }"),
  586             afterScatter(UMAP("{ [] -> [0]; [] -> [10] }"), true));
  589   EXPECT_EQ(UMAP("{ }"), afterScatter(UMAP("{ }"), false));
  589   EXPECT_EQ(UMAP("{ }"), afterScatter(UMAP("{ }"), false));
  590   EXPECT_EQ(UMAP("{ }"), afterScatter(UMAP("{ }"), true));
  590   EXPECT_EQ(UMAP("{ }"), afterScatter(UMAP("{ }"), true));
  598   EXPECT_EQ(MAP("{ [] -> [i] : 0 < i < 10 }"),
  599             betweenScatter(MAP("{ [] -> [0] }"), MAP("{ [] -> [10] }"), false,
  599             betweenScatter(MAP("{ [] -> [0] }"), MAP("{ [] -> [10] }"), false,
  602       MAP("{ [] -> [i] : 0 <= i < 10 }"),
  603       betweenScatter(MAP("{ [] -> [0] }"), MAP("{ [] -> [10] }"), true, false));
  603       betweenScatter(MAP("{ [] -> [0] }"), MAP("{ [] -> [10] }"), true, false));
  605       MAP("{ [] -> [i] : 0 < i <= 10 }"),
  606       betweenScatter(MAP("{ [] -> [0] }"), MAP("{ [] -> [10] }"), false, true));
  606       betweenScatter(MAP("{ [] -> [0] }"), MAP("{ [] -> [10] }"), false, true));
  608       MAP("{ [] -> [i] : 0 <= i <= 10 }"),
  609       betweenScatter(MAP("{ [] -> [0] }"), MAP("{ [] -> [10] }"), true, true));
  609       betweenScatter(MAP("{ [] -> [0] }"), MAP("{ [] -> [10] }"), true, true));
  612   EXPECT_EQ(UMAP("{ A[] -> [i] : 0 < i < 10; B[] -> [i] : 0 < i < 10 }"),
  613             betweenScatter(UMAP("{ A[] -> [0]; B[] -> [0] }"),
  614                            UMAP("{ A[] -> [10]; B[] -> [10] }"), false, false));
  615   EXPECT_EQ(UMAP("{ A[] -> [i] : 0 <= i < 10; B[] -> [i] : 0 <= i < 10 }"),
  616             betweenScatter(UMAP("{ A[] -> [0]; B[] -> [0] }"),
  617                            UMAP("{ A[] -> [10]; B[] -> [10] }"), true, false));
  618   EXPECT_EQ(UMAP("{ A[] -> [i] : 0 < i <= 10; B[] -> [i] : 0 < i <= 10 }"),
  619             betweenScatter(UMAP("{ A[] -> [0]; B[] -> [0] }"),
  620                            UMAP("{ A[] -> [10]; B[] -> [10] }"), false, true));
  621   EXPECT_EQ(UMAP("{ A[] -> [i] : 0 <= i <= 10; B[] -> [i] : 0 <= i <= 10 }"),
  622             betweenScatter(UMAP("{ A[] -> [0]; B[] -> [0] }"),
  623                            UMAP("{ A[] -> [10]; B[] -> [10] }"), true, true));
  631   EXPECT_EQ(SET("{ [] : 1 = 0 }"), singleton(USET("{ }"), SPACE("{ [] }")));
  631   EXPECT_EQ(SET("{ [] : 1 = 0 }"), singleton(USET("{ }"), SPACE("{ [] }")));
  631   EXPECT_EQ(SET("{ [] : 1 = 0 }"), singleton(USET("{ }"), SPACE("{ [] }")));
  632   EXPECT_EQ(MAP("{ [] -> [] : 1 = 0  }"),
  633             singleton(UMAP("{  }"), SPACE("{ [] -> [] }")));
  633             singleton(UMAP("{  }"), SPACE("{ [] -> [] }")));
  636   EXPECT_EQ(SET("{ [] }"), singleton(USET("{ [] }"), SPACE("{ [] }")));
  636   EXPECT_EQ(SET("{ [] }"), singleton(USET("{ [] }"), SPACE("{ [] }")));
  636   EXPECT_EQ(SET("{ [] }"), singleton(USET("{ [] }"), SPACE("{ [] }")));
  637   EXPECT_EQ(MAP("{ [] -> [] }"),
  638             singleton(UMAP("{ [] -> [] }"), SPACE("{ [] -> [] }")));
  638             singleton(UMAP("{ [] -> [] }"), SPACE("{ [] -> [] }")));
  641   EXPECT_EQ(SET("{ [i] : 0 <= i < 10 }"),
  642             singleton(USET("{ [i] : 0 <= i < 10 }"), SPACE("{ [i] }")));
  642             singleton(USET("{ [i] : 0 <= i < 10 }"), SPACE("{ [i] }")));
  644       MAP("{ [i] -> [i] : 0 <= i < 10 }"),
  645       singleton(UMAP("{ [i] -> [i] : 0 <= i < 10 }"), SPACE("{ [i] -> [j] }")));
  645       singleton(UMAP("{ [i] -> [i] : 0 <= i < 10 }"), SPACE("{ [i] -> [j] }")));
  648   EXPECT_EQ(SET("[i] -> { [i] }"),
  649             singleton(USET("[i] -> { [i] }"), SPACE("{ [i] }")));
  649             singleton(USET("[i] -> { [i] }"), SPACE("{ [i] }")));
  650   EXPECT_EQ(MAP("[i] -> { [i] -> [i] }"),
  651             singleton(UMAP("[i] -> { [i] -> [i] }"), SPACE("{ [i] -> [j] }")));
  651             singleton(UMAP("[i] -> { [i] -> [i] }"), SPACE("{ [i] -> [j] }")));
  659   EXPECT_EQ(0u, getNumScatterDims(UMAP("{ [] -> [] }")));
  660   EXPECT_EQ(1u, getNumScatterDims(UMAP("{ [] -> [i] }")));
  661   EXPECT_EQ(2u, getNumScatterDims(UMAP("{ [] -> [i,j] }")));
  662   EXPECT_EQ(3u, getNumScatterDims(UMAP("{ [] -> [i,j,k] }")));
  665   EXPECT_EQ(0u, getNumScatterDims(UMAP("{ A[] -> []; [] -> []}")));
  666   EXPECT_EQ(1u, getNumScatterDims(UMAP("{ A[] -> []; [] -> [i] }")));
  667   EXPECT_EQ(2u, getNumScatterDims(UMAP("{ A[] -> [i]; [] -> [i,j] }")));
  668   EXPECT_EQ(3u, getNumScatterDims(UMAP("{ A[] -> [i]; [] -> [i,j,k] }")));
  676   EXPECT_EQ(SPACE("{ [] }"), getScatterSpace(UMAP("{ [] -> [] }")));
  676   EXPECT_EQ(SPACE("{ [] }"), getScatterSpace(UMAP("{ [] -> [] }")));
  677   EXPECT_EQ(SPACE("{ [i] }"), getScatterSpace(UMAP("{ [] -> [i] }")));
  677   EXPECT_EQ(SPACE("{ [i] }"), getScatterSpace(UMAP("{ [] -> [i] }")));
  678   EXPECT_EQ(SPACE("{ [i,j] }"), getScatterSpace(UMAP("{ [] -> [i,j] }")));
  678   EXPECT_EQ(SPACE("{ [i,j] }"), getScatterSpace(UMAP("{ [] -> [i,j] }")));
  679   EXPECT_EQ(SPACE("{ [i,j,k] }"), getScatterSpace(UMAP("{ [] -> [i,j,k] }")));
  679   EXPECT_EQ(SPACE("{ [i,j,k] }"), getScatterSpace(UMAP("{ [] -> [i,j,k] }")));
  682   EXPECT_EQ(SPACE("{ [] }"), getScatterSpace(UMAP("{ A[] -> []; [] -> [] }")));
  682   EXPECT_EQ(SPACE("{ [] }"), getScatterSpace(UMAP("{ A[] -> []; [] -> [] }")));
  683   EXPECT_EQ(SPACE("{ [i] }"),
  684             getScatterSpace(UMAP("{ A[] -> []; [] -> [i] }")));
  685   EXPECT_EQ(SPACE("{ [i,j] }"),
  686             getScatterSpace(UMAP("{ A[] -> [i]; [] -> [i,j] }")));
  687   EXPECT_EQ(SPACE("{ [i,j,k] }"),
  688             getScatterSpace(UMAP("{ A[] -> [i]; [] -> [i,j,k] }")));
  696   EXPECT_EQ(UMAP("{ [i] -> [i] }"), makeIdentityMap(USET("{ [0] }"), false));
  696   EXPECT_EQ(UMAP("{ [i] -> [i] }"), makeIdentityMap(USET("{ [0] }"), false));
  697   EXPECT_EQ(UMAP("{ [0] -> [0] }"), makeIdentityMap(USET("{ [0] }"), true));
  697   EXPECT_EQ(UMAP("{ [0] -> [0] }"), makeIdentityMap(USET("{ [0] }"), true));
  700   EXPECT_EQ(UMAP("{ [] -> []; [i] -> [i] }"),
  701             makeIdentityMap(USET("{ []; [0] }"), false));
  702   EXPECT_EQ(UMAP("{ [] -> []; [0] -> [0] }"),
  703             makeIdentityMap(USET("{ []; [0] }"), true));
  706   EXPECT_EQ(UMAP("{ }"), makeIdentityMap(USET("{ }"), false));
  706   EXPECT_EQ(UMAP("{ }"), makeIdentityMap(USET("{ }"), false));
  707   EXPECT_EQ(UMAP("{ }"), makeIdentityMap(USET("{ }"), true));
  707   EXPECT_EQ(UMAP("{ }"), makeIdentityMap(USET("{ }"), true));
  715   EXPECT_EQ(MAP("{ [B[] -> A[]] -> [] }"),
  716             reverseDomain(MAP("{ [A[] -> B[]] -> [] }")));
  717   EXPECT_EQ(UMAP("{ [B[] -> A[]] -> [] }"),
  718             reverseDomain(UMAP("{ [A[] -> B[]] -> [] }")));
  726   EXPECT_EQ(SET("{ [1] }"), shiftDim(SET("{ [0] }"), 0, 1));
  726   EXPECT_EQ(SET("{ [1] }"), shiftDim(SET("{ [0] }"), 0, 1));
  727   EXPECT_EQ(USET("{ [1] }"), shiftDim(USET("{ [0] }"), 0, 1));
  727   EXPECT_EQ(USET("{ [1] }"), shiftDim(USET("{ [0] }"), 0, 1));
  730   EXPECT_EQ(USET("{ [0,0,1] }"), shiftDim(USET("{ [0,0,0] }"), -1, 1));
  730   EXPECT_EQ(USET("{ [0,0,1] }"), shiftDim(USET("{ [0,0,0] }"), -1, 1));
  731   EXPECT_EQ(USET("{ [0,1,0] }"), shiftDim(USET("{ [0,0,0] }"), -2, 1));
  731   EXPECT_EQ(USET("{ [0,1,0] }"), shiftDim(USET("{ [0,0,0] }"), -2, 1));
  732   EXPECT_EQ(USET("{ [1,0,0] }"), shiftDim(USET("{ [0,0,0] }"), -3, 1));
  732   EXPECT_EQ(USET("{ [1,0,0] }"), shiftDim(USET("{ [0,0,0] }"), -3, 1));
  735   EXPECT_EQ(USET("[n] -> { [n+1] }"), shiftDim(USET("[n] -> { [n] }"), 0, 1));
  735   EXPECT_EQ(USET("[n] -> { [n+1] }"), shiftDim(USET("[n] -> { [n] }"), 0, 1));
  738   EXPECT_EQ(MAP("{ [1] -> [] }"),
  739             shiftDim(MAP("{ [0] -> [] }"), isl::dim::in, 0, 1));
  740   EXPECT_EQ(UMAP("{ [1] -> [] }"),
  741             shiftDim(UMAP("{ [0] -> [] }"), isl::dim::in, 0, 1));
  742   EXPECT_EQ(MAP("{ [] -> [1] }"),
  743             shiftDim(MAP("{ [] -> [0] }"), isl::dim::out, 0, 1));
  744   EXPECT_EQ(UMAP("{ [] -> [1] }"),
  745             shiftDim(UMAP("{ [] -> [0] }"), isl::dim::out, 0, 1));
  753   EXPECT_EQ(UMAP("{ [Elt[] -> [i]] -> Dom[] : 0 < i }"),
  754             computeReachingWrite(UMAP("{ Dom[] -> [0] }"),
  755                                  UMAP("{ Dom[] -> Elt[] }"), false, false,
  757   EXPECT_EQ(UMAP("{ [Elt[] -> [i]] -> Dom[] : 0 < i }"),
  758             computeReachingWrite(UMAP("{ Dom[] -> [0] }"),
  759                                  UMAP("{ Dom[] -> Elt[] }"), false, false,
  761   EXPECT_EQ(UMAP("{ [Elt[] -> [i]] -> Dom[] : 0 <= i }"),
  762             computeReachingWrite(UMAP("{ Dom[] -> [0] }"),
  763                                  UMAP("{ Dom[] -> Elt[] }"), false, true,
  765   EXPECT_EQ(UMAP("{ [Elt[] -> [i]] -> Dom[] : 0 <= i }"),
  766             computeReachingWrite(UMAP("{ Dom[] -> [0] }"),
  767                                  UMAP("{ Dom[] -> Elt[] }"), false, true,
  770   EXPECT_EQ(UMAP("{ [Elt[] -> [i]] -> Dom[] : i < 0 }"),
  771             computeReachingWrite(UMAP("{ Dom[] -> [0] }"),
  772                                  UMAP("{ Dom[] -> Elt[] }"), true, false,
  774   EXPECT_EQ(UMAP("{ [Elt[] -> [i]] -> Dom[] :  i <= 0 }"),
  775             computeReachingWrite(UMAP("{ Dom[] -> [0] }"),
  776                                  UMAP("{ Dom[] -> Elt[] }"), true, false,
  778   EXPECT_EQ(UMAP("{ [Elt[] -> [i]] -> Dom[] : i < 0 }"),
  779             computeReachingWrite(UMAP("{ Dom[] -> [0] }"),
  780                                  UMAP("{ Dom[] -> Elt[] }"), true, true,
  782   EXPECT_EQ(UMAP("{ [Elt[] -> [i]] -> Dom[] : i <= 0 }"),
  783             computeReachingWrite(UMAP("{ Dom[] -> [0] }"),
  784                                  UMAP("{ Dom[] -> Elt[] }"), true, true, true));
  787   EXPECT_EQ(UMAP("{ [Elt[] -> [i]] -> Dom1[] : 0 < i < 10; [Elt[] -> [i]] -> "
  789             computeReachingWrite(UMAP("{ Dom1[] -> [0]; Dom2[] -> [10] }"),
  790                                  UMAP("{ Dom1[] -> Elt[]; Dom2[] -> Elt[] }"),
  792   EXPECT_EQ(UMAP("{ [Elt[] -> [i]] -> Dom1[] : 0 <= i < 10; [Elt[] -> [i]] -> "
  794             computeReachingWrite(UMAP("{ Dom1[] -> [0]; Dom2[] -> [10] }"),
  795                                  UMAP("{ Dom1[] -> Elt[]; Dom2[] -> Elt[] }"),
  797   EXPECT_EQ(UMAP("{ [Elt[] -> [i]] -> Dom1[] : 0 < i <= 10; [Elt[] -> [i]] -> "
  799             computeReachingWrite(UMAP("{ Dom1[] -> [0]; Dom2[] -> [10] }"),
  800                                  UMAP("{ Dom1[] -> Elt[]; Dom2[] -> Elt[] }"),
  802   EXPECT_EQ(UMAP("{ [Elt[] -> [i]] -> Dom1[] : 0 <= i <= 10; [Elt[] -> [i]] -> "
  804             computeReachingWrite(UMAP("{ Dom1[] -> [0]; Dom2[] -> [10] }"),
  805                                  UMAP("{ Dom1[] -> Elt[]; Dom2[] -> Elt[] }"),
  808   EXPECT_EQ(UMAP("{ [Elt[] -> [i]] -> Dom2[] : 0 < i < 10; [Elt[] -> [i]] -> "
  810             computeReachingWrite(UMAP("{ Dom1[] -> [0]; Dom2[] -> [10] }"),
  811                                  UMAP("{ Dom1[] -> Elt[]; Dom2[] -> Elt[] }"),
  813   EXPECT_EQ(UMAP("{ [Elt[] -> [i]] -> Dom2[] : 0 <= i < 10; [Elt[] -> [i]] -> "
  815             computeReachingWrite(UMAP("{ Dom1[] -> [0]; Dom2[] -> [10] }"),
  816                                  UMAP("{ Dom1[] -> Elt[]; Dom2[] -> Elt[] }"),
  818   EXPECT_EQ(UMAP("{ [Elt[] -> [i]] -> Dom2[] : 0 < i <= 10; [Elt[] -> [i]] -> "
  820             computeReachingWrite(UMAP("{ Dom1[] -> [0]; Dom2[] -> [10] }"),
  821                                  UMAP("{ Dom1[] -> Elt[]; Dom2[] -> Elt[] }"),
  823   EXPECT_EQ(UMAP("{ [Elt[] -> [i]] -> Dom2[] : 0 <= i <= 10; [Elt[] -> [i]] -> "
  825             computeReachingWrite(UMAP("{ Dom1[] -> [0]; Dom2[] -> [10] }"),
  826                                  UMAP("{ Dom1[] -> Elt[]; Dom2[] -> Elt[] }"),
  830   EXPECT_EQ(UMAP("{ [Elt[] -> [i]] -> Dom[1] : 0 < i <= 10; [Elt[] -> [i]] -> "
  832             computeReachingWrite(UMAP("{ Dom[i] -> [10i - 10] }"),
  833                                  UMAP("{ Dom[1] -> Elt[]; Dom[2] -> Elt[] }"),
  837   EXPECT_EQ(UMAP("[p] -> { [Elt[] -> [i]] -> Dom[] : p < i }"),
  838             computeReachingWrite(UMAP("[p] -> { Dom[] -> [p] }"),
  839                                  UMAP("{ Dom[] -> Elt[] }"), false, false,
  844       UMAP("{ [Elt[] -> [i]] -> Dom[0] : 0 < i <= 3; [Elt[] -> [i]] -> Dom[1] "
  847       computeReachingWrite(UMAP("{ Dom[i] -> [3i] : 0 <= i <= 4 }"),
  848                            UMAP("{ Dom[i] -> Elt[] : 0 <= i <= 4 }"), false,
  862     EXPECT_EQ(UMAP("{ Elt[] -> [i] : 0 < i < 10 }"),
  863               computeArrayUnused(UMAP("{ Read[] -> [0]; Write[] -> [10] }"),
  864                                  UMAP("{ Write[] -> Elt[] }"),
  865                                  UMAP("{ Read[] -> Elt[] }"), ReadEltInSameInst,
  867     EXPECT_EQ(UMAP("{ Elt[] -> [i] : 0 < i <= 10 }"),
  868               computeArrayUnused(UMAP("{ Read[] -> [0]; Write[] -> [10] }"),
  869                                  UMAP("{ Write[] -> Elt[] }"),
  870                                  UMAP("{ Read[] -> Elt[] }"), ReadEltInSameInst,
  872     EXPECT_EQ(UMAP("{ Elt[] -> [i] : 0 <= i < 10 }"),
  873               computeArrayUnused(UMAP("{ Read[] -> [0]; Write[] -> [10] }"),
  874                                  UMAP("{ Write[] -> Elt[] }"),
  875                                  UMAP("{ Read[] -> Elt[] }"), ReadEltInSameInst,
  877     EXPECT_EQ(UMAP("{ Elt[] -> [i] : 0 <= i <= 10 }"),
  878               computeArrayUnused(UMAP("{ Read[] -> [0]; Write[] -> [10] }"),
  879                                  UMAP("{ Write[] -> Elt[] }"),
  880                                  UMAP("{ Read[] -> Elt[] }"), ReadEltInSameInst,
  884     EXPECT_EQ(UMAP("{ Elt[] -> [i] : 0 < i <= 10 }"),
  886                   UMAP("{ Read[0] -> [-10]; Read[1] -> [0]; Write[] -> [10] }"),
  887                   UMAP("{ Write[] -> Elt[] }"), UMAP("{ Read[i] -> Elt[] }"),
  887                   UMAP("{ Write[] -> Elt[] }"), UMAP("{ Read[i] -> Elt[] }"),
  891     EXPECT_EQ(UMAP("{}"),
  892               computeArrayUnused(UMAP("{ Read[] -> [0] }"), UMAP("{}"),
  892               computeArrayUnused(UMAP("{ Read[] -> [0] }"), UMAP("{}"),
  893                                  UMAP("{ Read[] -> Elt[] }"), ReadEltInSameInst,
  897     EXPECT_EQ(UMAP("{ Elt[] -> [i] : i <= 0 }"),
  898               computeArrayUnused(UMAP("{ Write[] -> [0] }"),
  899                                  UMAP("{ Write[] -> Elt[] }"), UMAP("{}"),
  899                                  UMAP("{ Write[] -> Elt[] }"), UMAP("{}"),
  904         UMAP("{ Elt[] -> [i] : i <= 10 }"),
  905         computeArrayUnused(UMAP("{ WriteA[] -> [0];  WriteB[] -> [10] }"),
  906                            UMAP("{ WriteA[] -> Elt[]; WriteB[] -> Elt[] }"),
  907                            UMAP("{}"), ReadEltInSameInst, false, true));
  912         UMAP("{ Elt[] -> [i] : 0 < i <= 10; Elt[] -> [i] : 20 < i <= 30 }"),
  913         computeArrayUnused(UMAP("{ ReadA[] -> [0]; WriteA[] -> [10]; ReadB[] "
  915                            UMAP("{ WriteA[] -> Elt[]; WriteB[] -> Elt[] }"),
  916                            UMAP("{ ReadA[] -> Elt[];  ReadB[] -> Elt[] }"),
  921         UMAP("{ Elt[] -> [i] : i <= 10 }"),
  923             UMAP("{ WriteA[] -> [0];  WriteB[] -> [10];  Read[] -> [20] }"),
  924             UMAP("{ WriteA[] -> Elt[]; WriteB[] -> Elt[] }"),
  925             UMAP("{ Read[] -> Elt[] }"), ReadEltInSameInst, false, true));
  928     EXPECT_EQ(UMAP("{ Elt[] -> [i] : i <= 0 }"),
  929               computeArrayUnused(UMAP("{ Write[] -> [0]; Read[] -> [10] }"),
  930                                  UMAP("{ Write[] -> Elt[] }"),
  931                                  UMAP("{ Read[] -> Elt[] }"), ReadEltInSameInst,
  935     EXPECT_EQ(UMAP("{ Elt[] -> [i] : 0 < i <= 10 }"),
  937                   UMAP("{ ReadA[] -> [0]; Write[] -> [10]; ReadB[] -> [20] }"),
  938                   UMAP("{ Write[] -> Elt[] }"),
  939                   UMAP("{ ReadA[] -> Elt[];  ReadB[] -> Elt[] }"),
  944         UMAP("{ Elt[] -> [i] : 0 < i <= 20 }"),
  946             UMAP("{ Read[] -> [0]; WriteA[] -> [10];  WriteB[] -> [20] }"),
  947             UMAP("{ WriteA[] -> Elt[]; WriteB[] -> Elt[] }"),
  948             UMAP("{ Read[] -> Elt[] }"), ReadEltInSameInst, false, true));
  952         UMAP("{ Elt[] -> [i] : 0 < i <= 20 }"),
  953         computeArrayUnused(UMAP("{ ReadA[] -> [0]; WriteA[] -> [10];  WriteB[] "
  955                            UMAP("{ WriteA[] -> Elt[]; WriteB[] -> Elt[] }"),
  956                            UMAP("{ ReadA[] -> Elt[];  ReadB[] -> Elt[] }"),
  961   EXPECT_EQ(UMAP("{ Elt[] -> [i] : i < 0 }"),
  962             computeArrayUnused(UMAP("{ RW[] -> [0] }"),
  963                                UMAP("{ RW[] -> Elt[] }"),
  964                                UMAP("{ RW[] -> Elt[] }"), true, false, false));
  965   EXPECT_EQ(UMAP("{ Elt[] -> [i] : i <= 0 }"),
  966             computeArrayUnused(UMAP("{ RW[] -> [0] }"),
  967                                UMAP("{ RW[] -> Elt[] }"),
  968                                UMAP("{ RW[] -> Elt[] }"), true, false, true));
  969   EXPECT_EQ(UMAP("{ Elt[] -> [0] }"),
  970             computeArrayUnused(UMAP("{ RW[] -> [0] }"),
  971                                UMAP("{ RW[] -> Elt[] }"),
  972                                UMAP("{ RW[] -> Elt[] }"), false, true, true));
  980   EXPECT_EQ(USET("{}"), convertZoneToTimepoints(USET("{}"), false, false));
  980   EXPECT_EQ(USET("{}"), convertZoneToTimepoints(USET("{}"), false, false));
  981   EXPECT_EQ(USET("{}"), convertZoneToTimepoints(USET("{}"), true, false));
  981   EXPECT_EQ(USET("{}"), convertZoneToTimepoints(USET("{}"), true, false));
  982   EXPECT_EQ(USET("{}"), convertZoneToTimepoints(USET("{}"), false, true));
  982   EXPECT_EQ(USET("{}"), convertZoneToTimepoints(USET("{}"), false, true));
  983   EXPECT_EQ(USET("{}"), convertZoneToTimepoints(USET("{}"), true, true));
  983   EXPECT_EQ(USET("{}"), convertZoneToTimepoints(USET("{}"), true, true));
  986   EXPECT_EQ(USET("{}"), convertZoneToTimepoints(USET("{ [1] }"), false, false));
  986   EXPECT_EQ(USET("{}"), convertZoneToTimepoints(USET("{ [1] }"), false, false));
  987   EXPECT_EQ(USET("{ [0] }"),
  988             convertZoneToTimepoints(USET("{ [1] }"), true, false));
  989   EXPECT_EQ(USET("{ [1] }"),
  990             convertZoneToTimepoints(USET("{ [1] }"), false, true));
  991   EXPECT_EQ(USET("{ [0]; [1] }"),
  992             convertZoneToTimepoints(USET("{ [1] }"), true, true));
  995   EXPECT_EQ(USET("{}"),
  996             convertZoneToTimepoints(USET("{ [1]; [11] }"), false, false));
  997   EXPECT_EQ(USET("{ [0]; [10] }"),
  998             convertZoneToTimepoints(USET("{ [1]; [11] }"), true, false));
  999   EXPECT_EQ(USET("{ [1]; [11] }"),
 1000             convertZoneToTimepoints(USET("{ [1]; [11] }"), false, true));
 1001   EXPECT_EQ(USET("{ [0]; [1]; [10]; [11] }"),
 1002             convertZoneToTimepoints(USET("{ [1]; [11] }"), true, true));
 1006       USET("{ [i] : 0 < i < 10 }"),
 1007       convertZoneToTimepoints(USET("{ [i] : 0 < i <= 10 }"), false, false));
 1009       USET("{ [i] : 0 <= i < 10 }"),
 1010       convertZoneToTimepoints(USET("{ [i] : 0 < i <= 10 }"), true, false));
 1012       USET("{ [i] : 0 < i <= 10 }"),
 1013       convertZoneToTimepoints(USET("{ [i] : 0 < i <= 10 }"), false, true));
 1014   EXPECT_EQ(USET("{ [i] : 0 <= i <= 10 }"),
 1015             convertZoneToTimepoints(USET("{ [i] : 0 < i <= 10 }"), true, true));
 1018   EXPECT_EQ(USET("{}"),
 1019             convertZoneToTimepoints(USET("{ [0,1] }"), false, false));
 1020   EXPECT_EQ(USET("{ [0,0] }"),
 1021             convertZoneToTimepoints(USET("{ [0,1] }"), true, false));
 1022   EXPECT_EQ(USET("{ [0,1] }"),
 1023             convertZoneToTimepoints(USET("{ [0,1] }"), false, true));
 1024   EXPECT_EQ(USET("{ [0,0]; [0,1] }"),
 1025             convertZoneToTimepoints(USET("{ [0,1] }"), true, true));
 1028   EXPECT_EQ(UMAP("{}"), convertZoneToTimepoints(UMAP("{ [1] -> [] }"),
 1028   EXPECT_EQ(UMAP("{}"), convertZoneToTimepoints(UMAP("{ [1] -> [] }"),
 1030   EXPECT_EQ(UMAP("{ [0] -> [] }"),
 1031             convertZoneToTimepoints(UMAP("{ [1] -> [] }"), isl::dim::in, true,
 1033   EXPECT_EQ(UMAP("{ [1] -> [] }"),
 1034             convertZoneToTimepoints(UMAP("{ [1] -> [] }"), isl::dim::in, false,
 1037       UMAP("{ [0] -> []; [1] -> [] }"),
 1038       convertZoneToTimepoints(UMAP("{ [1] -> [] }"), isl::dim::in, true, true));
 1041   EXPECT_EQ(UMAP("{}"), convertZoneToTimepoints(UMAP("{ [] -> [1] }"),
 1041   EXPECT_EQ(UMAP("{}"), convertZoneToTimepoints(UMAP("{ [] -> [1] }"),
 1043   EXPECT_EQ(UMAP("{ [] -> [0] }"),
 1044             convertZoneToTimepoints(UMAP("{ [] -> [1] }"), isl::dim::out, true,
 1046   EXPECT_EQ(UMAP("{ [] -> [1] }"),
 1047             convertZoneToTimepoints(UMAP("{ [] -> [1] }"), isl::dim::out, false,
 1049   EXPECT_EQ(UMAP("{ [] -> [0]; [] -> [1] }"),
 1050             convertZoneToTimepoints(UMAP("{ [] -> [1] }"), isl::dim::out, true,
 1059   EXPECT_EQ(MAP("{ [Domain[] -> Range1[]] -> [Domain[] -> Range2[]] }"),
 1060             distributeDomain(MAP("{ Domain[] -> [Range1[] -> Range2[]] }")));
 1062       MAP("{ [Domain[i,j] -> Range1[i,k]] -> [Domain[i,j] -> Range2[j,k]] }"),
 1063       distributeDomain(MAP("{ Domain[i,j] -> [Range1[i,k] -> Range2[j,k]] }")));
 1067       UMAP(
 1071           UMAP("{ DomainA[i,j] -> [RangeA1[i,k] -> RangeA2[j,k]];"
 1080   EXPECT_EQ(UMAP("{ [Factor[] -> Domain[]] -> [Factor[] -> Range[]] }"),
 1081             liftDomains(UMAP("{ Domain[] -> Range[] }"), USET("{ Factor[] }")));
 1081             liftDomains(UMAP("{ Domain[] -> Range[] }"), USET("{ Factor[] }")));
 1082   EXPECT_EQ(UMAP("{ [Factor[l] -> Domain[i,k]] -> [Factor[l] -> Range[j,k]] }"),
 1083             liftDomains(UMAP("{ Domain[i,k] -> Range[j,k] }"),
 1084                         USET("{ Factor[l] }")));
 1088       UMAP("{ [FactorA[] -> DomainA[]] -> [FactorA[] -> RangeA[]];"
 1092       liftDomains(UMAP("{ DomainA[] -> RangeA[]; DomainB[] -> RangeB[] }"),
 1093                   USET("{ FactorA[]; FactorB[] }")));
 1102       UMAP("{ [DomainDomain[] -> NewDomainRange[]] -> Range[] }"),
 1103       applyDomainRange(UMAP("{ [DomainDomain[] -> DomainRange[]] -> Range[] }"),
 1104                        UMAP("{ DomainRange[] -> NewDomainRange[] }")));
 1106       UMAP("{ [DomainDomain[i,k] -> NewDomainRange[j,k,l]] -> Range[i,j] }"),
 1108           UMAP("{ [DomainDomain[i,k] -> DomainRange[j,k]] -> Range[i,j] }"),
 1109           UMAP("{ DomainRange[j,k] -> NewDomainRange[j,k,l] }")));
 1112   EXPECT_EQ(UMAP("{ [DomainDomainA[] -> NewDomainRangeA[]] -> RangeA[];"
 1115                 UMAP("{ [DomainDomainA[] -> DomainRangeA[]] -> RangeA[];"
 1117                 UMAP("{ DomainRangeA[] -> NewDomainRangeA[];"