|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
References
examples/Kaleidoscope/BuildingAJIT/Chapter1/KaleidoscopeJIT.h 64 return std::make_unique<KaleidoscopeJIT>(std::move(*JTMB), std::move(*DL));
64 return std::make_unique<KaleidoscopeJIT>(std::move(*JTMB), std::move(*DL));
examples/Kaleidoscope/BuildingAJIT/Chapter2/KaleidoscopeJIT.h 75 return std::make_unique<KaleidoscopeJIT>(std::move(*JTMB), std::move(*DL));
75 return std::make_unique<KaleidoscopeJIT>(std::move(*JTMB), std::move(*DL));
examples/Kaleidoscope/BuildingAJIT/Chapter5/KaleidoscopeJIT.h 135 CompileCallbackMgr = &*CCMgrOrErr;
examples/LLJITExamples/LLJITWithObjectCache/LLJITWithObjectCache.cpp 63 TMOwningSimpleCompiler(std::move(*TM), &ObjCache));
examples/SpeculativeJIT/SpeculativeJIT.cpp 72 std::move(ES), std::move(*DL), std::move(*JTMB), std::move(*LCTMgr),
72 std::move(ES), std::move(*DL), std::move(*JTMB), std::move(*LCTMgr),
72 std::move(ES), std::move(*DL), std::move(*JTMB), std::move(*LCTMgr),
73 std::move(ISMBuilder), std::move(*ProcessSymbolsSearchGenerator)));
include/llvm/Bitcode/BitcodeReader.h 44 return std::move(*Val);
include/llvm/DebugInfo/CodeView/CVRecord.h 123 Item = *ExpectedRec;
include/llvm/ExecutionEngine/JITSymbol.h 300 CachedAddr = *CachedAddrOrErr;
include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h 420 return *FnImplAddrOrErr;
430 std::make_pair(*CCAddr, JITSymbolFlags::fromGlobalValue(F));
538 return *RS;
548 (*RS).insert(S);
550 return *RS;
595 auto &PartKey = *PartKeyOrErr;
600 JITTargetAddress FnBodyAddr = *FnBodyAddrOrErr;
707 return *RS;
718 (*RS).insert(S);
720 return *RS;
include/llvm/ExecutionEngine/Orc/ExecutionUtils.h 122 reinterpret_cast<CtorDtorTy>(static_cast<uintptr_t>(*AddrOrErr));
include/llvm/ExecutionEngine/Orc/IndirectionUtils.h 255 setTrampolinePool(std::move(*TP));
include/llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h 67 return (*TM)->createDataLayout();
include/llvm/ExecutionEngine/Orc/LazyReexports.h 126 setTrampolinePool(std::move(*TP));
include/llvm/ExecutionEngine/Orc/Legacy.h 152 S, JITEvaluatedSymbol(*Addr, Sym.getFlags()));
186 return std::move(*ResponsibilitySet);
include/llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h 410 std::tie(StubBase, PtrBase, NumStubsEmitted) = *StubInfoOrErr;
473 std::tie(BlockAddr, NumTrampolines) = *TrampolineInfoOrErr;
601 RemoteTrampolineSize, RemoteIndirectStubSize) = *RIOrErr;
655 return *AddrOrErr;
include/llvm/ExecutionEngine/Orc/OrcRemoteTargetServer.h 154 return *AddrOrErr;
include/llvm/ExecutionEngine/Orc/RPCSerialization.h 487 return SerializationTraits<ChannelT, T1, T2>::serialize(C, *ValOrErr);
500 return SerializationTraits<ChannelT, T1, T2>::deserialize(C, *ValOrErr);
include/llvm/ExecutionEngine/Orc/RPCUtils.h 382 C, *ResultOrErr))
1022 FnId = *FnIdOrErr;
1248 RemoteFunctionIds[Func::getPrototype()] = *RemoteIdOrErr;
1249 if (*RemoteIdOrErr == getInvalidFunctionId())
1251 return *RemoteIdOrErr;
include/llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h 307 std::make_pair(*SymbolName, JITEvaluatedSymbol(0, *Flags)));
307 std::make_pair(*SymbolName, JITEvaluatedSymbol(0, *Flags)));
401 *this, K, OwnedObject(std::move(*Obj), std::move(ObjBuffer)),
include/llvm/ExecutionEngine/Orc/RemoteObjectLayer.h 211 auto &RemoteSym = *RemoteSymOrErr;
260 return *AddrOrErr;
336 auto &Handle = *HandleOrErr;
483 BaseLayerHandles[Id] = std::move(*HandleOrErr);
include/llvm/ExecutionEngine/Orc/Speculation.h 148 auto RAddr = (*ReadySymbol)[Target].getAddress();
include/llvm/Object/Archive.h 171 C = std::move(*NextChild);
include/llvm/Object/ELF.h 344 return *ErrorOrIndex;
358 return getSection(Sym, *SymsOrErr, ShndxTable);
368 uint32_t Index = *IndexOrErr;
381 Elf_Sym_Range Symbols = *SymsOrErr;
560 return getEntry<T>(*SecOrErr, Entry);
586 return object::getSection<ELFT>(*TableOrErr, Index);
604 ArrayRef<char> Data = *V;
621 return getSHNDXTable(Section, *SectionsOrErr);
632 ArrayRef<Elf_Word> V = *VOrErr;
636 const Elf_Shdr &SymTable = **SymTableOrErr;
659 return getStringTableForSymtab(Sec, *SectionsOrErr);
674 return getStringTable(*SectionOrErr);
684 auto Table = getSectionStringTable(*SectionsOrErr, WarnHandler);
687 return getSectionName(Section, *Table);
include/llvm/Object/ELFObjectFile.h 311 return *RelSecOrErr;
330 uintptr_t SHT = reinterpret_cast<uintptr_t>((*SectionsOrErr).begin());
373 for (const Elf_Shdr &Sec : *SectionsOrErr) {
406 return *Ret;
460 const Elf_Shdr *SymTableSec = *SymTabOrErr;
464 const Elf_Shdr *StringTableSec = *StrTabOrErr;
468 Expected<StringRef> Name = ESym->getName(*SymStrTabOrErr);
476 return (*SecOrErr)->getName();
529 const Elf_Shdr *SymTab = *SymTabOrErr;
535 const Elf_Shdr *Section = *SectionOrErr;
627 if (DotSymtabSecSyms && ESym == (*DotSymtabSecSyms).begin())
630 if (DotDynSymSecSyms && ESym == (*DotDynSymSecSyms).begin())
635 StringRef Name = *NameOrErr;
670 const Elf_Shdr *ESec = *ESecOrErr;
686 const Elf_Shdr *SymTab = *SymTabOrErr;
774 for (const Elf_Shdr &Sec : *SectionsOrErr) {
786 for (const Elf_Shdr &Sec : *SectionsOrErr) {
819 uintptr_t SHT = reinterpret_cast<uintptr_t>((*SectionsOrErr).begin());
858 return section_iterator(SectionRef(toDRI(*SecOrErr), this));
931 return *Ret;
941 return *Ret;
950 auto EF = std::move(*EFOrErr);
959 for (const Elf_Shdr &Sec : *SectionsOrErr) {
975 ShndxTable = *TableOrErr;
1037 return section_iterator(SectionRef(toDRI((*SectionsOrErr).begin()), this));
1045 return section_iterator(SectionRef(toDRI((*SectionsOrErr).end()), this));
include/llvm/Support/BinaryItemStream.h 46 const auto &Item = Items[*ExpectedIndex];
60 Buffer = Traits::bytes(Items[*ExpectedIndex]);
include/llvm/Support/Error.h 733 return std::move(*ValOrErr);
764 return *ValOrErr;
1014 return std::move(*E);
1147 return std::move(*E);
1315 return std::move(*E);
1322 return *E;
include/llvm/Support/Process.h 58 return *PageSize;
include/llvm/Testing/Support/Error.h 43 bool result = Matcher.MatchAndExplain(*Holder.Exp, listener);
include/llvm/Testing/Support/SupportHelpers.h 53 *Out << "succeeded with value " << ::testing::PrintToString(*Item.Exp);
lib/Bitcode/Reader/BitcodeAnalyzer.cpp 553 CurStreamType = *MaybeType;
lib/Bitcode/Reader/BitcodeReader.cpp 3569 UseRelativeIDs = *VersionOrErr >= 1;
6329 BitstreamCursor &Stream = *StreamOrErr;
6394 I->Strtab = *Strtab;
6400 F.StrtabForSymtab = *Strtab;
6417 F.Symtab = *SymtabOrErr;
6456 ProducerIdentification = *ProducerIdentificationOrErr;
6596 *EnableSplitLTOUnit};
6605 *EnableSplitLTOUnit};
6630 return (*MsOrErr)[0];
6649 (*MOrErr)->setOwnedMemoryBuffer(std::move(Buffer));
6674 return readTriple(*StreamOrErr);
6682 return hasObjCCategory(*StreamOrErr);
6690 return readIdentificationCode(*StreamOrErr);
lib/DebugInfo/CodeView/SymbolDumper.cpp 372 W.printString("Program", *ExpectedProgram);
391 W.printString("Program", *ExpectedProgram);
lib/DebugInfo/CodeView/TypeStreamMerger.cpp 372 if (*R) {
lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp 458 if (isSentinel(*AttrEncOr))
461 Result.emplace_back(*AttrEncOr);
480 return Abbrev(Code, dwarf::Tag(Tag), std::move(*AttrEncOr));
513 if (isSentinel(*AbbrevOr))
516 if (!Abbrevs.insert(std::move(*AbbrevOr)).second)
821 CurrentEntry = std::move(*EntryOr);
lib/DebugInfo/DWARF/DWARFContext.cpp 842 return *ExpectedLineTable;
1315 RSec = *SectOrErr;
1316 Ret.Address = *SymAddrOrErr;
1514 Name = *NameOrErr;
1542 section_iterator RelocatedSection = *SecOrErr;
1546 Data = *E;
1592 RelSecName = *NameOrErr;
lib/DebugInfo/DWARF/DWARFDebugAranges.cpp 60 for (const auto &R : *CURanges)
lib/DebugInfo/DWARF/DWARFDebugLine.cpp 250 for (auto Descriptor : *DirDescriptors) {
287 for (auto Descriptor : *FileDescriptors) {
lib/DebugInfo/DWARF/DWARFDebugLoc.cpp 134 Locations.push_back(std::move(*LL));
209 Locations.push_back(std::move(*LL));
lib/DebugInfo/DWARF/DWARFUnit.cpp 458 StringOffsetsTableContribution = *StringOffsetOrError;
599 return *CUDIERangesOrError;
840 Desc = *DescOrError;
849 Desc = *DescOrError;
872 return *DescOrError;
891 return *DescOrError;
lib/DebugInfo/GSYM/GsymReader.cpp 250 assert(*AddressIndex < AddrInfoOffsets.size());
251 auto AddrInfoOffset = AddrInfoOffsets[*AddressIndex];
253 if (Optional<uint64_t> OptAddr = getAddress(*AddressIndex)) {
264 *AddressIndex);
lib/DebugInfo/GSYM/InlineInfo.cpp 110 Inline.Children.emplace_back(std::move(*Child));
lib/DebugInfo/MSF/MSFBuilder.cpp 344 Layout = std::move(*L);
351 FileBufferByteStream Buffer(std::move(*OutFileOrError),
lib/DebugInfo/PDB/Native/DbiModuleDescriptorBuilder.cpp 131 Layout.ModDiStream = *ExpectedSN;
lib/DebugInfo/PDB/Native/DbiModuleList.cpp 129 ThisValue = *ExpectedValue;
lib/DebugInfo/PDB/Native/DbiStream.cpp 264 auto &SHS = *ExpectedStream;
290 auto &FS = *ExpectedStream;
314 auto &FS = *ExpectedStream;
lib/DebugInfo/PDB/Native/DbiStreamBuilder.cpp 318 S->StreamNumber = *ExpectedIndex;
lib/DebugInfo/PDB/Native/GSIStreamBuilder.cpp 216 GSH->StreamIndex = *Idx;
220 PSH->StreamIndex = *Idx;
228 RecordStreamIdx = *Idx;
lib/DebugInfo/PDB/Native/NativeEnumInjectedSources.cpp 84 auto Data = readStreamData(**ExpectedFileStream, Entry.FileSize);
89 return *Data;
lib/DebugInfo/PDB/Native/NativeSession.cpp 205 return std::make_unique<NativeEnumInjectedSources>(*Pdb, *ISS, *Strings);
205 return std::make_unique<NativeEnumInjectedSources>(*Pdb, *ISS, *Strings);
lib/DebugInfo/PDB/Native/PDBFile.cpp 267 auto TempGlobals = std::make_unique<GlobalsStream>(std::move(*GlobalS));
280 auto TempInfo = std::make_unique<InfoStream>(std::move(*InfoS));
293 auto TempDbi = std::make_unique<DbiStream>(std::move(*DbiS));
306 auto TempTpi = std::make_unique<TpiStream>(*this, std::move(*TpiS));
322 auto TempIpi = std::make_unique<TpiStream>(*this, std::move(*IpiS));
340 auto TempPublics = std::make_unique<PublicsStream>(std::move(*PublicS));
359 auto TempSymbols = std::make_unique<SymbolStream>(std::move(*SymbolS));
374 BinaryStreamReader Reader(**NS);
378 StringTableStream = std::move(*NS);
394 auto IJ = std::make_unique<InjectedSourceStream>(std::move(*IJS));
395 if (auto EC = IJ->reload(*Strings))
466 assert(*ExpectedNSI < getNumStreams());
479 assert(*ExpectedNSI < getNumStreams());
504 uint32_t NameStreamIndex = *ExpectedNSI;
lib/DebugInfo/PDB/Native/PDBFileBuilder.cpp 45 Msf = std::make_unique<MSFBuilder>(std::move(*ExpectedMsf));
89 NamedStreams.set(Name, *ExpectedStream);
97 assert(NamedStreamData.count(*ExpectedIndex) == 0);
98 NamedStreamData[*ExpectedIndex] = Data;
274 FileBufferByteStream Buffer = std::move(*ExpectedMsfBuffer);
281 Layout, Buffer, *ExpectedSN, Allocator);
lib/DebugInfo/PDB/Native/PDBStringTable.cpp 132 if (*ExpectedStr == Str)
lib/DebugInfo/PDB/Native/SymbolCache.cpp 170 else if (*EFD != Index) {
171 assert(!isUdtForwardRef(Types.getType(*EFD)));
172 SymIndexId Result = findSymbolByTypeIndex(*EFD);
lib/DebugInfo/PDB/Native/TpiStream.cpp 87 BinaryStreamReader HSR(**HS);
112 HashStream = std::move(*HS);
lib/DebugInfo/PDB/Native/TpiStreamBuilder.cpp 127 HashStreamIndex = *ExpectedIndex;
lib/DebugInfo/Symbolize/SymbolizableObjectFile.cpp 61 if (*NameOrErr == ".opd") {
65 OpdExtractor.reset(new DataExtractor(*E, Obj->isLittleEndian(),
167 if (!Sec || (Obj && Obj->section_end() == *Sec))
172 SymbolRef::Type SymbolType = *SymbolTypeOrErr;
178 uint64_t SymbolAddress = *SymbolAddressOrErr;
198 StringRef SymbolName = *SymbolNameOrErr;
lib/DebugInfo/Symbolize/Symbolize.cpp 75 return symbolizeCodeCommon(*InfoOrErr, ModuleOffset);
84 return symbolizeCodeCommon(*InfoOrErr, ModuleOffset);
250 Name = *NameOrErr;
261 DataExtractor DE(*ContentsOrErr, Obj->isLittleEndian(), 0);
lib/ExecutionEngine/JITLink/EHFrameSupport.cpp 301 JITTargetAddress PCBegin = PCBeginAddress + *PCBeginDelta;
341 JITTargetAddress LSDA = LSDAAddress + *LSDADelta;
lib/ExecutionEngine/JITLink/JITLinkGeneric.cpp 29 G = std::move(*GraphOrErr);
95 applyLookupResult(*LR);
225 Alloc = std::move(*AllocOrErr);
lib/ExecutionEngine/JITLink/MachOLinkGraphBuilder.cpp 134 dbgs() << " " << *Name << ": " << formatv("{0:x16}", NSec.Address)
165 NSec.GraphSection = &G->createSection(*Name, Prot);
241 Name = *NameOrErr;
266 NSec = &*NSecOrErr;
lib/ExecutionEngine/JITLink/MachO_arm64.cpp 173 ToSymbol = &*ToSymbolOrErr;
223 dbgs() << "Processing " << getMachOARM64RelocationKindName(*Kind)
250 if (*Kind == PairedAddend) {
266 if (*Kind != Branch26 && *Kind != Page21 && *Kind != PageOffset12)
266 if (*Kind != Branch26 && *Kind != Page21 && *Kind != PageOffset12)
266 if (*Kind != Branch26 && *Kind != Page21 && *Kind != PageOffset12)
269 getMachOARM64RelocationKindName(*Kind));
272 dbgs() << " pair is " << getMachOARM64RelocationKindName(*Kind)
284 switch (*Kind) {
313 TargetSymbol = &*TargetSymbolOrErr;
365 parsePairRelocation(*BlockToFix, *Kind, RI, FixupAddress,
369 std::tie(*Kind, TargetSymbol, Addend) = *PairInfo;
369 std::tie(*Kind, TargetSymbol, Addend) = *PairInfo;
379 Edge GE(*Kind, FixupAddress - BlockToFix->getAddress(), *TargetSymbol,
382 getMachOARM64RelocationKindName(*Kind));
385 BlockToFix->addEdge(*Kind, FixupAddress - BlockToFix->getAddress(),
505 return MachOLinkGraphBuilder_arm64(**MachOObj).buildGraph();
lib/ExecutionEngine/JITLink/MachO_x86_64.cpp 175 ToSymbol = &*ToSymbolOrErr;
258 switch (*Kind) {
286 TargetSymbol = &*TargetSymbolOrErr;
300 (1 << (*Kind - PCRel32Minus1));
306 TargetSymbol = &*TargetSymbolOrErr;
316 static_cast<JITTargetAddress>(1ULL << (*Kind - PCRel32Minus1Anon));
320 TargetSymbol = &*TargetSymbolOrErr;
334 parsePairRelocation(*BlockToFix, *Kind, RI, FixupAddress,
338 std::tie(*Kind, TargetSymbol, Addend) = *PairInfo;
338 std::tie(*Kind, TargetSymbol, Addend) = *PairInfo;
348 Edge GE(*Kind, FixupAddress - BlockToFix->getAddress(), *TargetSymbol,
351 getMachOX86RelocationKindName(*Kind));
354 BlockToFix->addEdge(*Kind, FixupAddress - BlockToFix->getAddress(),
465 return MachOLinkGraphBuilder_x86_64(**MachOObj).buildGraph();
lib/ExecutionEngine/MCJIT/MCJIT.cpp 231 LoadedObjects.push_back(std::move(*LoadedObject));
325 return *AddrOrErr;
347 auto &OptionalChild = *OptionalChildOrErr;
615 static_cast<uintptr_t>(*AddrOrErr));
lib/ExecutionEngine/Orc/CompileOnDemandLayer.cpp 315 BaseLayer.emit(std::move(R), std::move(*ExtractedTSM));
lib/ExecutionEngine/Orc/Core.cpp 642 (*Result)[KV.second.Aliasee].getAddress(), KV.second.AliasFlags);
691 for (auto &KV : *Flags)
699 Result[Name] = SymbolAliasMapEntry(Name, (*Flags)[Name]);
721 for (auto &KV : *Flags) {
1364 auto NewDefs = DG->tryToGenerate(*this, *Unresolved);
1369 auto Unresolved2 = lookupFlagsImpl(Result, *NewDefs);
1377 for (auto &Name : *NewDefs)
1425 for (auto &D : *NewDefs)
1431 cantFail(lodgeQueryImpl(Q, *NewDefs, MatchNonExported, MUs));
1542 for (auto &D : *NewDefs)
1544 QueryComplete = lookupImpl(Q, MUs, *NewDefs);
1877 PromisedResult.set_value(std::move(*R));
2037 PromisedResult.set_value(std::move(*R));
lib/ExecutionEngine/Orc/ExecutionUtils.cpp 138 static_cast<uintptr_t>((*CtorDtorMap)[Name].getAddress()));
237 return Create(L, std::move(*ArchiveBuffer));
265 if (*Child == None)
267 auto ChildBuffer = (*Child)->getMemoryBufferRef();
lib/ExecutionEngine/Orc/IRCompileLayer.cpp 35 BaseLayer.emit(std::move(R), std::move(*Obj));
lib/ExecutionEngine/Orc/IRTransformLayer.cpp 25 BaseLayer.emit(std::move(R), std::move(*TransformedTSM));
lib/ExecutionEngine/Orc/IndirectionUtils.cpp 68 AddrToSymbol[*TrampolineAddr] = CallbackName;
73 return *TrampolineAddr;
lib/ExecutionEngine/Orc/LLJIT.cpp 22 JTMB = std::move(*JTMBOrErr);
101 return TMOwningSimpleCompiler(std::move(*TM));
114 DL = std::move(*DLOrErr);
127 *ES, *ObjLinkingLayer, std::move(*CompileFunction));
205 LCTMgr = std::move(*LCTMgrOrErr);
lib/ExecutionEngine/Orc/Layer.cpp 114 return JD.define(std::move(*ObjMU));
128 std::move(*SymbolFlags)));
162 for (auto &Sym : (*Obj)->symbols()) {
174 auto InternedName = ES.intern(*Name);
178 SymbolFlags[InternedName] = std::move(*SymFlags);
lib/ExecutionEngine/Orc/LazyReexports.cpp 35 Reexports[*Trampoline] = std::make_pair(&SourceJD, std::move(SymbolName));
36 Notifiers[*Trampoline] = std::move(NotifyResolved);
37 return *Trampoline;
170 std::make_pair(*CallThroughTrampoline, Alias.second.AliasFlags);
lib/ExecutionEngine/Orc/Legacy.cpp 34 for (auto &KV : *InternedResult)
lib/ExecutionEngine/Orc/ObjectLinkingLayer.cpp 71 for (auto &KV : *Result)
lib/ExecutionEngine/Orc/ObjectTransformLayer.cpp 25 BaseLayer.emit(std::move(R), std::move(*TransformedObj));
lib/ExecutionEngine/Orc/OrcCBindings.cpp 49 *RetAddr = *Addr;
78 *RetHandle = *Handle;
93 *RetHandle = *Handle;
108 *RetHandle = *Handle;
125 *RetAddr = *Addr;
137 *RetAddr = *Addr;
lib/ExecutionEngine/Orc/OrcCBindingsStack.h 157 S, JITEvaluatedSymbol(*Addr, Sym.getFlags()));
397 return *AddrOrErr;
415 return *AddrOrErr;
459 return std::move(*CCMgr);
lib/ExecutionEngine/Orc/OrcMCJITReplacement.h 180 S, JITEvaluatedSymbol(*Addr, Sym.getFlags()));
193 S, JITEvaluatedSymbol(*Addr, Sym2.getFlags()));
398 auto &OptionalChild = *OptionalChildOrErr;
lib/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp 39 for (auto &KV : *InternedResult)
110 for (auto &Sym : (*Obj)->symbols()) {
113 InternalSymbols->insert(*SymName);
137 **Obj, std::move(O), *MemMgr, Resolver, ProcessAllSections,
141 return onObjLoad(K, *SharedR, **Obj, std::move(LoadedObjInfo),
lib/ExecutionEngine/RuntimeDyld/JITSymbol.cpp 53 if (*SymbolType & object::SymbolRef::ST_Function)
77 Result[Symbol] = JITEvaluatedSymbol(*AddrOrErr, Sym.getFlags());
89 Result[Symbol] = JITEvaluatedSymbol(*AddrOrErr, Sym.getFlags());
lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp 175 Result = *AddressOrErr - Sec.getAddress();
221 Symbols.insert(*NameOrErr);
228 ResponsibilitySet = std::move(*ResultOrErr);
246 SymType = *SymTypeOrErr;
253 Name = *NameOrErr;
278 *JITSymFlags &= ~JITSymbolFlags::Weak;
280 *JITSymFlags &= ~JITSymbolFlags::Common;
294 Addr = *AddrOrErr;
304 GlobalSymbolTable[Name] = SymbolTableEntry(SectionID, Addr, *JITSymFlags);
312 SI = *SIOrErr;
328 SectionID = *SectionIDOrErr;
337 SymbolTableEntry(SectionID, SectOffset, *JITSymFlags);
356 section_iterator RelocatedSection = *RelSecOrErr;
370 SectionID = *SectionIDOrErr;
378 I = *IOrErr;
427 LLVM_DEBUG(dbgs() << "\tSectionID: " << (*SectionIDOrErr) << "\n");
546 StringRef Name = *NameOrErr;
660 section_iterator RelSecI = *RelSecOrErr;
745 Name = *NameOrErr;
763 SymbolTableEntry(SectionID, Offset, std::move(*JITSymFlags));
795 StringRef Name = *NameOrErr;
816 data = *E;
901 SectionID = *SectionIDOrErr;
1178 for (auto &RRKV : *NewResolverResults) {
1208 for (auto &KV : *Result)
lib/ExecutionEngine/RuntimeDyld/RuntimeDyldCOFF.cpp 64 return std::make_unique<LoadedCOFFObjectInfo>(*this, *ObjSectionToIDOrErr);
lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp 107 new DyldELFObject<ELFT>(std::move(*Obj)));
158 std::unique_ptr<DyldELFObject<ELFT>> Obj = std::move(*ObjOrErr);
169 if (*NameOrErr != "") {
211 return OwningBinary<ObjectFile>(std::move(*DebugObj), std::move(Buffer));
257 return std::make_unique<LoadedELFObjectInfo>(*this, *ObjSectionToIDOrErr);
578 StringRef SectionName = *NameOrErr;
586 Rel.SectionID = *SectionIDOrErr;
614 section_iterator RelSecI = *RelSecOrErr;
621 StringRef RelSectionName = *NameOrErr;
641 Addend = *AddendOrErr;
662 TSI = *TSIOrErr;
670 Rel.SectionID = *SectionIDOrErr;
1116 Addend = *AddendOrErr;
1125 TargetName = *TargetNameOrErr;
1147 SymType = *SymTypeOrErr;
1168 section_iterator si = *SectionOrErr;
1175 Value.SectionID = *SectionIDOrErr;
1884 section_iterator RelocatedSection = *RelSecOrErr;
1902 Name = *NameOrErr;
lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp 82 TargetSectionID = *TargetSectionIDOrErr;
112 TargetName = *TargetNameOrErr;
130 Value.SectionID = *SectionIDOrErr;
209 IndirectSymbolName = *IndirectSymbolNameOrErr;
237 Name = *NameOrErr;
246 TextSID = *TextSIDOrErr;
252 EHFrameSID = *EHFrameSIDOrErr;
258 ExceptTabSID = *ExceptTabSIDOrErr;
373 *ObjSectionToIDOrErr);
lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldCOFFI386.h 50 StringRef TargetName = *TargetNameOrErr;
55 auto Section = *SectionOrErr;
93 TargetSectionID = *TargetSectionIDOrErr;
lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldCOFFThumb.h 36 if (*SymTypeOrErr != object::SymbolRef::ST_Function)
72 StringRef TargetName = *TargetNameOrErr;
77 auto Section = *SectionOrErr;
113 TargetSectionID = *TargetSectionIDOrErr;
lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldCOFFX86_64.h 203 object::section_iterator SecI = *SectionOrError;
217 StringRef TargetName = *TargetNameOrErr;
260 TargetSectionID = *TargetSectionIDOrErr;
294 if ((*NameOrErr) == ".pdata")
lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOAArch64.h 317 RE.Addend = *Addend;
328 Value = *ValueOrErr;
496 auto SubtrahendI = GlobalSymbolTable.find(*SubtrahendNameOrErr);
506 auto MinuendI = GlobalSymbolTable.find(*MinuendNameOrErr);
lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOARM.h 118 TargetName = *TargetNameOrErr;
162 RE.Addend = *AddendOrErr;
169 Value = *ValueOrErr;
293 Name = *NameOrErr;
388 SectionAID = *SectionAIDOrErr;
401 SectionBID = *SectionBIDOrErr;
lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOI386.h 71 Value = *ValueOrErr;
132 Name = *NameOrErr;
177 SectionAID = *SectionAIDOrErr;
190 SectionBID = *SectionBIDOrErr;
239 addRelocationForSymbol(RE, *IndirectSymbolName);
lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOX86_64.h 54 Value = *ValueOrErr;
185 auto SubtrahendI = GlobalSymbolTable.find(*SubtrahendNameOrErr);
195 SectionBID = *SectionBIDOrErr;
211 auto MinuendI = GlobalSymbolTable.find(*MinuendNameOrErr);
221 SectionAID = *SectionAIDOrErr;
lib/IR/RemarkStreamer.cpp 162 auto Flags = *Format == remarks::Format::YAML ? sys::fs::OF_Text
173 *Format, remarks::SerializerMode::Separate, RemarksFile->os());
178 std::move(*RemarkSerializer), RemarksFilename));
203 remarks::createRemarkSerializer(*Format,
209 std::make_unique<RemarkStreamer>(std::move(*RemarkSerializer)));
lib/LTO/Caching.cpp 47 MemoryBuffer::getOpenFile(*FDOrErr, EntryPath,
50 sys::fs::closeFile(*FDOrErr);
147 AddBuffer, std::move(*Temp), EntryPath.str(), Task);
lib/LTO/LTO.cpp 618 return linkRegularLTO(std::move(*ModOrErr), /*LivenessFromIndex=*/false);
624 RegularLTO.ModsWithSummaries.push_back(std::move(*ModOrErr));
671 Module &M = **MOrErr;
672 Mod.M = std::move(*MOrErr);
1092 return thinBackend(Conf, Task, AddStream, **MOrErr, CombinedIndex,
1391 if (*ResultOrErr)
1392 (*ResultOrErr)->keep();
lib/LTO/LTOBackend.cpp 435 std::unique_ptr<TargetMachine> TM = createTargetMachine(C, *TOrErr, *Mod);
443 auto DiagnosticOutputFile = std::move(*DiagFileOrErr);
490 std::unique_ptr<TargetMachine> TM = createTargetMachine(Conf, *TOrErr, Mod);
498 auto DiagnosticOutputFile = std::move(*DiagFileOrErr);
lib/LTO/LTOCodeGenerator.cpp 535 DiagnosticOutputFile = std::move(*DiagFileOrErr);
lib/LTO/LTOModule.cpp 89 expectedToErrorOrAndEmitErrors(Context, getBitcodeTargetTriple(*BCOrErr));
102 Context, getBitcodeProducerString(*BCOrErr));
183 parseBitcodeFile(*MBOrErr, Context));
189 getLazyBitcodeModule(*MBOrErr, Context, true /*ShouldLazyLoadMetadata*/));
lib/LTO/ThinLTOCodeGenerator.cpp 201 return std::move(*ModuleOrErr);
362 *FDOrErr, EntryPath, /*FileSize=*/-1, /*RequiresNullTerminator=*/false);
363 sys::fs::closeFile(*FDOrErr);
516 auto TripleStr = (*InputOrError)->getTargetTriple();
528 Modules.emplace_back(std::move(*InputOrError));
lib/Linker/IRMover.cpp 583 if (!*NewProto)
586 GlobalValue *New = dyn_cast<GlobalValue>(*NewProto);
588 return *NewProto;
lib/MCA/InstrBuilder.cpp 614 const InstrDesc &D = *DescOrErr;
lib/Object/Archive.cpp 424 StringRef Name = *NameOrErr;
448 const std::string &FullName = *FullNameOrErr;
515 return MemoryBufferRef(*Buf, Name);
526 return std::move(*BinaryOrErr);
984 return Child(*MemberOrErr);
lib/Object/ArchiveWriter.cpp 53 M.Buf = MemoryBuffer::getMemBuffer(*BufOrErr, false);
82 sys::fs::file_t FD = *FDOrErr;
365 Obj = std::move(*ObjOrErr);
373 Obj = std::move(*ObjOrErr);
498 Ret.push_back({std::move(*Symbols), std::move(Header), Data, Padding});
566 std::vector<MemberData> &Data = *DataOrErr;
lib/Object/COFFImportFile.cpp 609 if (!E.AliasTarget.empty() && *Name != E.AliasTarget) {
610 Members.push_back(OF.createWeakExternal(E.AliasTarget, *Name, false));
611 Members.push_back(OF.createWeakExternal(E.AliasTarget, *Name, true));
616 OF.createShortImport(*Name, E.Ordinal, ImportType, NameType));
lib/Object/COFFObjectFile.cpp 979 if (*NameOrErr == SectionName) {
1754 if (*Name == ".rsrc" || *Name == ".rsrc$01")
1754 if (*Name == ".rsrc" || *Name == ".rsrc$01")
1767 BBS = BinaryByteStream(*Contents, support::little);
lib/Object/Decompressor.cpp 85 return isGnuStyle(*SecNameOrErr);
lib/Object/ELF.cpp 508 for (const Elf_Phdr &Phdr : *ProgramHeadersOrError) {
525 for (const Elf_Shdr &Sec : *SectionsOrError) {
531 Dyn = *DynOrError;
564 for (const Elf_Phdr &Phdr : *ProgramHeadersOrError)
lib/Object/ELFObjectFile.cpp 66 return std::make_unique<ELFObjectFile<ELFT>>(std::move(*Ret));
415 StringRef Name = *NameOrErr;
432 arrayRefFromStringRef(*PltContents),
lib/Object/IRObjectFile.cpp 82 return MemoryBufferRef(*Contents, Obj.getFileName());
116 getBitcodeModuleList(*BCOrErr);
121 for (auto BM : *BMsOrErr) {
128 Mods.push_back(std::move(*MOrErr));
132 new IRObjectFile(*BCOrErr, std::move(Mods)));
142 Expected<BitcodeFileContents> BFCOrErr = getBitcodeFileContents(*BCOrErr);
146 Expected<irsymtab::FileContents> FCOrErr = irsymtab::readBitcode(*BFCOrErr);
lib/Object/IRSymtab.cpp 280 Sym.ComdatIndex = *ComdatIndexOrErr;
360 OwnedMods.push_back(std::move(*MOrErr));
lib/Object/MachOObjectFile.cpp 192 return MachOObjectFile::LoadCommandInfo({Ptr, *CmdOrErr});
228 Header = *HeaderOrErr;
1291 Load = *LoadOrErr;
1606 Load = *LoadOrErr;
1831 section_iterator Sec = *SecOrError;
1998 if (*NameOrErr == SectionName)
2043 return (SegmentName == "__LLVM" && *NameOrErr == "__bitcode");
4006 Info.SectionName = *NameOrErr;
lib/Object/Minidump.cpp 33 size_t Size = (*ExpectedSize)[0];
47 copy(*ExpectedData, WStr.begin());
70 return make_range(MemoryInfoIterator(*Data, H.SizeOfEntry),
117 const minidump::Header &Hdr = (*ExpectedHeader)[0];
129 for (const auto &StreamDescriptor : llvm::enumerate(*ExpectedStreams)) {
154 new MinidumpFile(Source, Hdr, *ExpectedStreams, std::move(StreamMap)));
lib/Object/Object.cpp 228 *unwrap(Sect) = *SecOrErr;
322 return *Ret;
lib/Object/ObjectFile.cpp 47 return *this == **SymSec;
63 OS << *Name;
72 return *NameOrErr == ".llvmbc";
lib/Object/RelocationResolver.cpp 23 return *AddendOrErr;
lib/ObjectYAML/CodeViewYAMLDebugSections.cpp 550 Result.FileName = *ExpectedString;
574 Result->Checksums.push_back(*ConvertedCS);
594 Block.FileName = *EF;
630 Site.FileName = *ExpF;
638 Site.ExtraFiles.push_back(*ExpF2);
664 YCMI.ModuleName = *ExpectedStr;
684 Result->Symbols.push_back(*S);
730 YF.FrameFunc = *ES;
804 Subsection.Subsection = *Result;
815 Subsection.Subsection = *Result;
826 Subsection.Subsection = *Result;
837 Subsection.Subsection = *Result;
848 Subsection.Subsection = *Result;
858 Subsection.Subsection = *Result;
867 Subsection.Subsection = *Result;
877 Subsection.Subsection = *Result;
886 Subsection.Subsection = *Result;
lib/ObjectYAML/MinidumpYAML.cpp 474 return std::make_unique<ExceptionStream>(*ExpectedExceptionStream,
475 *ExpectedThreadContext);
479 return std::make_unique<MemoryInfoListStream>(*ExpectedList);
488 for (const MemoryDescriptor &MD : *ExpectedList) {
492 Ranges.push_back({MD, *ExpectedContent});
501 for (const Module &M : *ExpectedList) {
512 {M, std::move(*ExpectedName), *ExpectedCv, *ExpectedMisc});
512 {M, std::move(*ExpectedName), *ExpectedCv, *ExpectedMisc});
512 {M, std::move(*ExpectedName), *ExpectedCv, *ExpectedMisc});
526 return std::make_unique<SystemInfoStream>(*ExpectedInfo,
527 std::move(*ExpectedCSDVersion));
537 for (const Thread &T : *ExpectedList) {
544 Threads.push_back({T, *ExpectedStack, *ExpectedContext});
544 Threads.push_back({T, *ExpectedStack, *ExpectedContext});
559 Streams.push_back(std::move(*ExpectedStream));
lib/ObjectYAML/yaml2obj.cpp 70 return std::move(*ObjOrErr);
lib/ProfileData/Coverage/CoverageMapping.cpp 162 OS << '[' << *Value << ']';
183 return E.Kind == CounterExpression::Subtract ? *LHS - *RHS : *LHS + *RHS;
183 return E.Kind == CounterExpression::Subtract ? *LHS - *RHS : *LHS + *RHS;
183 return E.Kind == CounterExpression::Subtract ? *LHS - *RHS : *LHS + *RHS;
183 return E.Kind == CounterExpression::Subtract ? *LHS - *RHS : *LHS + *RHS;
251 Function.pushRegion(Region, *ExecutionCount);
287 const auto &Record = *RecordOrErr;
lib/ProfileData/Coverage/CoverageMappingReader.cpp 354 Data = *DataOrErr;
449 if (!*OldIsDummyExpected)
455 if (*NewIsDummyExpected)
673 if (stripSuffix(*NameOrErr) == Name)
724 if (Error E = ProfileNames.create(*NamesSection))
lib/Remarks/BitstreamRemarkParser.cpp 52 switch (*RecordID) {
79 return unknownRecord("BLOCK_META", *RecordID);
99 switch (*RecordID) {
152 return unknownRecord("BLOCK_REMARK", *RecordID);
216 Result[i] = *R;
238 if (!*MaybeBlockInfo)
243 BlockInfo = **MaybeBlockInfo;
300 if (!*isMetaBlock)
521 R.RemarkName = *RemarkName;
531 R.PassName = *PassName;
540 R.FunctionName = *FunctionName;
549 R.Loc->SourceFilePath = *SourceFileName;
575 R.Args.back().Key = *Key;
580 R.Args.back().Val = *Value;
588 R.Args.back().Loc->SourceFilePath = *SourceFileName;
lib/Remarks/RemarkStringTable.cpp 26 add(*MaybeStr);
lib/Remarks/YAMLRemarkParser.cpp 121 if (*isMeta) {
131 if (*StrTabSize != 0) {
135 Expected<ParsedStringTable> MaybeStrTab = parseStrTab(Buf, *StrTabSize);
138 StrTab = std::move(*MaybeStrTab);
214 TheRemark.RemarkType = *T;
221 StringRef KeyName = *MaybeKey;
225 TheRemark.PassName = *MaybeStr;
230 TheRemark.RemarkName = *MaybeStr;
235 TheRemark.FunctionName = *MaybeStr;
240 TheRemark.Hotness = *MaybeU;
245 TheRemark.Loc = *MaybeLoc;
255 TheRemark.Args.push_back(*MaybeArg);
334 StringRef KeyName = *MaybeKey;
338 File = *MaybeStr;
343 Column = *MaybeU;
348 Line = *MaybeU;
376 StringRef KeyName = *MaybeKey;
386 Loc = *MaybeLoc;
398 ValueStr = *MaybeStr;
427 return std::move(*MaybeResult);
438 StrID = *MaybeStrID;
443 Result = *Str;
lib/Support/CachePruning.cpp 89 Policy.Interval = *DurationOrErr;
94 Policy.Expiration = *DurationOrErr;
lib/Support/FileCheck.cpp 51 return EvalBinop(*LeftOp, *RightOp);
51 return EvalBinop(*LeftOp, *RightOp);
58 return utostr(*EvaluatedValue);
66 return Regex::escape(*VarVal);
263 std::move(*RightOpResult));
292 ParseResult = parseBinop(Expr, std::move(*ParseResult), IsLegacyLineExpr,
302 ExpressionAST = std::move(*ParseResult);
313 DefinedNumericVariable = *ParseResult;
501 ExpressionAST = std::move(*ParseResult);
750 OS.write_escaped(*MatchedValue) << "\"";
1461 size_t MatchPos = *MatchResult;
1583 size_t Pos = *MatchResult;
1645 size_t MatchPosBuf = *MatchResult;
1842 std::move(*ExpressionASTResult);
1854 (*DefinedNumericVariable)->setValue(*Value);
lib/Support/FileOutputBuffer.cpp 133 fs::TempFile File = std::move(*FileOrErr);
lib/Support/GlobPattern.cpp 138 Pat.Tokens.push_back(*BV);
lib/Support/MemoryBuffer.cpp 221 if (*ReadBytes == 0)
223 Buffer.set_size(Buffer.size() + *ReadBytes);
251 sys::fs::file_t FD = *FDOrErr;
370 sys::fs::file_t FD = *FDOrErr;
470 if (*ReadBytes == 0) {
474 ToRead = ToRead.drop_front(*ReadBytes);
475 Offset += *ReadBytes;
512 sys::fs::file_t FD = *FDOrErr;
lib/Support/VirtualFileSystem.cpp 304 new RealFile(*FDOrErr, Name.str(), RealName.str()));
lib/TextAPI/MachO/TextStub.cpp 418 Value = *Result;
lib/ToolDrivers/llvm-lib/LibDriver.cpp 175 switch (Triple(*TripleStr).getArch()) {
186 << ": unknown arch in target triple " << *TripleStr << '\n';
222 appendFile(Members, LibMachine, LibMachineSource, *ChildMB);
364 Member.MemberName = Saver.save(*PathOrErr);
lib/Transforms/IPO/FunctionImport.cpp 1095 std::unique_ptr<Module> SrcModule = std::move(*SrcModuleOrErr);
1221 std::unique_ptr<ModuleSummaryIndex> Index = std::move(*IndexPtrOrErr);
1267 return *Result;
lib/XRay/InstrumentationMap.cpp 72 return *NameOrErr == "xray_instr_map";
83 Contents = *E;
107 Relocs.insert({Reloc.getOffset(), *AddendOrErr});
237 if (auto E = loadYAML(*FdOrErr, FileSize, Filename, Map.Sleds,
240 } else if (auto E = loadObj(Filename, *ObjectFileOrError, Map.Sleds,
lib/XRay/Profile.cpp 274 *FdOrErr, sys::fs::mapped_file_region::mapmode::readonly, FileSize, 0,
276 sys::fs::closeFile(*FdOrErr);
lib/XRay/Trace.cpp 399 *FdOrErr, sys::fs::mapped_file_region::mapmode::readonly, FileSize, 0,
401 sys::fs::closeFile(*FdOrErr);
tools/bugpoint/BugDriver.cpp 222 if (!*Diff) {
tools/bugpoint/ExecutionDriver.cpp 280 DiscardTemp Discard{*Temp};
352 if (*RetVal == -1) {
371 outFile << "exit " << *RetVal << '\n';
399 if (Error E = cc->MakeSharedObject(OutputFile, *FT, SharedObjectFile,
430 ReferenceOutputFile = *Result;
451 if (int Diff = DiffFilesWithTolerance(ReferenceOutputFile, *Output,
460 sys::fs::remove(*Output);
tools/bugpoint/ExtractFunction.cpp 382 DiscardTemp Discard{*Temp};
tools/bugpoint/FindBugs.cpp 84 if (*Diff) {
tools/bugpoint/ListReducer.h 53 switch (*Result) {
104 if (*Result == KeepPrefix) {
126 switch (*Result) {
189 if (*Result == KeepSuffix) {
tools/bugpoint/Miscompilation.cpp 86 if (*Diff) {
127 if (*Diff) {
173 if (*Diff) {
204 if (*Ret)
211 if (*Ret)
241 Broken = *Diff;
339 if (!*New)
343 std::unique_ptr<Module> Old = BD.swapProgramIn(std::move(*New));
385 if (!*Result) {
464 if (*Ret)
471 if (*Ret)
558 if (*Ret) {
648 if (*Ret) {
672 if (*Ret) {
721 if (auto New = std::move(*Result)) {
740 if (!*Result)
762 SplitFunctionsOutOfModule(ToNotOptimize, *MiscompiledFunctions, VMap)
987 FileRemover SharedObjectRemover(*SharedObject, !SaveTemps);
992 BD.diffProgram(BD.getProgram(), TestModuleBC.str(), *SharedObject, false);
996 if (*Result)
1017 << "you: '" << *Result << "'.\n";
1033 SplitFunctionsOutOfModule(ToNotCodeGen.get(), *Funcs, VMap);
1075 outs() << " lli -load " << *SharedObject << " " << TestModuleBC;
1078 outs() << " cc " << *SharedObject << " " << TestModuleBC.str() << ".s -o "
1087 << " cc -xc temporary.c -O2 -o " << *SharedObject;
tools/bugpoint/OptimizerDriver.cpp 155 DiscardTemp Discard{*Temp};
tools/bugpoint/ToolRunner.cpp 501 return cc->ExecuteProgram(OutputAsmFile, Args, *FileKind, InputFile,
tools/clang/examples/clang-interpreter/main.cpp 82 auto DL = (*TM)->createDataLayout();
92 std::move(*TM), std::move(DL), std::move(*ProcessSymbolsGenerator)));
92 std::move(*TM), std::move(DL), std::move(*ProcessSymbolsGenerator)));
tools/clang/include/clang/AST/ASTImporter.h 344 To = *ToOrErr;
tools/clang/include/clang/Tooling/Refactoring/RefactoringActionRules.h 60 Consumer.handle(std::move(*Changes));
82 Consumer.handle(std::move(*Occurrences));
tools/clang/include/clang/Tooling/Refactoring/RefactoringActionRulesInternal.h 60 RuleType::initiate(Context, std::move((*std::get<Is>(Values)))...);
tools/clang/lib/AST/ASTImporter.cpp 155 To = cast_or_null<ImportT>(*ToOrErr);
166 return cast_or_null<T>(*ToOrErr);
194 return std::make_tuple<T>(std::move(*ToOrErr));
210 return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210 return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
280 ToD->addAttr(*ToAttrOrErr);
621 *Obegin = *ToOrErr;
660 TemplateArgumentListInfo ToTAInfo(*ToLAngleLocOrErr, *ToRAngleLocOrErr);
660 TemplateArgumentListInfo ToTAInfo(*ToLAngleLocOrErr, *ToRAngleLocOrErr);
727 *ToTemplateLocOrErr,
728 *ToLAngleLocOrErr,
730 *ToRAngleLocOrErr,
731 *ToRequiresClause);
745 return TemplateArgument(*ToTypeOrErr);
752 return TemplateArgument(From, *ToTypeOrErr);
762 return TemplateArgument(*ToOrErr, *ToTypeOrErr);
762 return TemplateArgument(*ToOrErr, *ToTypeOrErr);
769 return TemplateArgument(*ToTypeOrErr, /*isNullPtr*/true);
777 return TemplateArgument(*ToTemplateOrErr);
787 *ToTemplateOrErr, From.getNumTemplateExpansions());
792 return TemplateArgument(*ToExpr);
817 TemplateArgument Arg = *ArgOrErr;
826 ToInfo = TemplateArgumentLocInfo(*E);
829 ToInfo = TemplateArgumentLocInfo(*TSIOrErr);
846 *ToTemplateQualifierLocOrErr,
847 *ToTemplateNameLocOrErr,
848 *ToTemplateEllipsisLocOrErr);
863 ToDecls.push_back(*ToDOrErr);
886 return Designator(ToFieldName, *ToDotLocOrErr, *ToFieldLocOrErr);
886 return Designator(ToFieldName, *ToDotLocOrErr, *ToFieldLocOrErr);
899 *ToLBracketLocOrErr, *ToRBracketLocOrErr);
899 *ToLBracketLocOrErr, *ToRBracketLocOrErr);
907 D.getFirstExprIndex(), *ToLBracketLocOrErr, *ToEllipsisLocOrErr,
907 D.getFirstExprIndex(), *ToLBracketLocOrErr, *ToEllipsisLocOrErr,
908 *ToRBracketLocOrErr);
916 Var = *VarOrErr;
931 *LocationOrErr, From.isImplicit(), From.getCaptureKind(), Var,
975 return Importer.getToContext().getAtomicType(*UnderlyingTypeOrErr);
1036 return Importer.getToContext().getDecayedType(*ToOriginalTypeOrErr);
1044 return Importer.getToContext().getComplexType(*ToElementTypeOrErr);
1052 return Importer.getToContext().getPointerType(*ToPointeeTypeOrErr);
1061 return Importer.getToContext().getBlockPointerType(*ToPointeeTypeOrErr);
1071 return Importer.getToContext().getLValueReferenceType(*ToPointeeTypeOrErr);
1081 return Importer.getToContext().getRValueReferenceType(*ToPointeeTypeOrErr);
1096 *ToPointeeTypeOrErr, (*ClassTypeOrErr).getTypePtr());
1096 *ToPointeeTypeOrErr, (*ClassTypeOrErr).getTypePtr());
1104 std::tie(ToElementType, ToSizeExpr) = *Imp;
1119 return Importer.getToContext().getIncompleteArrayType(*ToElementTypeOrErr,
1131 std::tie(ToElementType, ToSizeExpr, ToBracketsRange) = *Imp;
1147 std::tie(ToElementType, ToSizeExpr, ToBracketsRange) = *Imp;
1163 return Importer.getToContext().getVectorType(*ToElementTypeOrErr,
1173 return Importer.getToContext().getExtVectorType(*ToElementTypeOrErr,
1185 return Importer.getToContext().getFunctionNoProtoType(*ToReturnTypeOrErr,
1201 ArgTypes.push_back(*TyOrErr);
1210 ExceptionTypes.push_back(*TyOrErr);
1233 ToEPI.ExceptionSpec.SourceTemplate) = *Imp;
1236 *ToReturnTypeOrErr, ArgTypes, ToEPI);
1244 std::tie(ToD, ToPrevD) = *Imp;
1257 return Importer.getToContext().getParenType(*ToInnerTypeOrErr);
1265 return Importer.getToContext().getTypeDeclType(*ToDeclOrErr);
1273 return Importer.getToContext().getTypeOfExprType(*ToExprOrErr);
1281 return Importer.getToContext().getTypeOfType(*ToUnderlyingTypeOrErr);
1295 *ToExprOrErr, *ToUnderlyingTypeOrErr);
1295 *ToExprOrErr, *ToUnderlyingTypeOrErr);
1309 *ToBaseTypeOrErr, *ToUnderlyingTypeOrErr, T->getUTTKind());
1309 *ToBaseTypeOrErr, *ToUnderlyingTypeOrErr, T->getUTTKind());
1318 return Importer.getToContext().getAutoType(*ToDeducedTypeOrErr,
1342 InjectedClassNameType(*ToDeclOrErr, *ToInjTypeOrErr), 0);
1342 InjectedClassNameType(*ToDeclOrErr, *ToInjTypeOrErr), 0);
1350 return Importer.getToContext().getTagDeclType(*ToDeclOrErr);
1358 return Importer.getToContext().getTagDeclType(*ToDeclOrErr);
1370 *ToModifiedTypeOrErr, *ToEquivalentTypeOrErr);
1370 *ToModifiedTypeOrErr, *ToEquivalentTypeOrErr);
1380 T->getDepth(), T->getIndex(), T->isParameterPack(), *ToDeclOrErr);
1389 cast<TemplateTypeParmType>((*ReplacedOrErr).getTypePtr());
1396 Replaced, (*ToReplacementTypeOrErr).getCanonicalType());
1415 ToCanonType = *TyOrErr;
1419 return Importer.getToContext().getTemplateSpecializationType(*ToTemplateOrErr,
1439 *ToQualifierOrErr,
1440 *ToNamedTypeOrErr,
1441 *ToOwnedTagDeclOrErr);
1450 return Importer.getToContext().getPackExpansionType(*ToPatternOrErr,
1469 T->getKeyword(), *ToQualifierOrErr, ToName, ToPack);
1483 Canon = (*TyOrErr).getCanonicalType();
1489 *ToQualifierOrErr,
1499 return Importer.getToContext().getObjCInterfaceType(*ToDeclOrErr);
1510 TypeArgs.push_back(*TyOrErr);
1518 Protocols.push_back(*ProtocolOrErr);
1524 return Importer.getToContext().getObjCObjectType(*ToBaseTypeOrErr, TypeArgs,
1535 return Importer.getToContext().getObjCObjectPointerType(*ToPointeeTypeOrErr);
1636 To.setCXXOperatorNameRange(*ToRangeOrErr);
1643 To.setCXXLiteralOperatorNameLoc(*LocOrErr);
1652 To.setNamedTypeInfo(*ToTInfoOrErr);
1724 DeclContext *ToDC = *ToDCOrErr;
1752 ToDC = *ToDCOrErr;
1759 ToLexicalDC = *ToLexicalDCOrErr;
1785 To->setTypedefNameForAnonDecl(cast<TypedefNameDecl>(*ToTypedefOrErr));
1856 EllipsisLoc = *LocOrErr;
1876 *RangeOrErr,
1880 *TSIOrErr,
1906 To->setInit(*ToInitOrErr);
1945 To->completeDefinition(*ToTypeOrErr, *ToPromotionTypeOrErr,
1945 To->completeDefinition(*ToTypeOrErr, *ToPromotionTypeOrErr,
1956 ToArgs.push_back(*ToOrErr);
1975 ToTAInfo.addArgument(*ToLocOrErr);
2106 if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(), DC, *LocOrErr))
2135 DeclContext *DC = *DCOrErr;
2139 DC, *LocOrErr, *ColonLocOrErr))
2139 DC, *LocOrErr, *ColonLocOrErr))
2154 DeclContext *DC = *DCOrErr;
2162 std::tie(ToLocation, ToAssertExpr, ToMessage, ToRParenLoc) = *Imp;
2233 *BeginLocOrErr, Loc, Name.getAsIdentifierInfo(),
2277 ToNamespace) = *Imp;
2353 std::tie(ToUnderlyingType, ToTypeSourceInfo, ToBeginLoc) = *Imp;
2429 std::tie(ToTemplateParameters, ToTemplatedDecl) = *Imp;
2465 Name.getAsIdentifierInfo(), *BeginLocOrErr))
2479 ToLabel->setStmt(*ToStmtOrErr);
2546 std::tie(ToBeginLoc, ToQualifierLoc, ToIntegerType) = *Imp;
2691 DC, *TInfoOrErr, Loc, DCXX->isDependentLambda(),
2697 D2CXX->setLambdaMangling(DCXX->getLambdaManglingNumber(), *CDeclOrErr,
2705 *BeginLocOrErr, Loc, Name.getAsIdentifierInfo(),
2712 D->getTagKind(), DC, *BeginLocOrErr, Loc,
2773 D2CXX->setInstantiationOfMemberClass(*ToInstOrErr, SK);
2780 *POIOrErr);
2787 D->getTagKind(), DC, *BeginLocOrErr, Loc,
2795 D2->setQualifierInfo(*QualifierLocOrErr);
2858 Name.getAsIdentifierInfo(), *TypeOrErr, *InitOrErr, D->getInitVal()))
2858 Name.getAsIdentifierInfo(), *TypeOrErr, *InitOrErr, D->getInitVal()))
2876 ToTPLists[I] = *ToTPListOrErr;
2895 ToFD->setInstantiationOfMemberFunction(*InstFDOrErr, TSK);
2901 ToFD->getMemberSpecializationInfo()->setPointOfInstantiation(*POIOrErr);
2915 Importer.getToContext(), std::get<1>(*FunctionAndArgsOrErr));
2934 std::get<0>(*FunctionAndArgsOrErr), ToTAList, /* InsertPos= */ nullptr,
2935 TSK, FromTAArgsAsWritten ? &ToTAInfo : nullptr, *POIOrErr);
2946 TemplDecls.addDecl(*ToFTDOrErr);
2977 std::tie(Template, ToTemplArgs) = *FunctionAndArgsOrErr;
2987 ToFD->setBody(*ToBodyOrErr);
3030 if (FunctionDecl *FoundFunction = *FoundFunctionOrErr) {
3142 std::tie(T, TInfo, ToInnerLocStart, ToQualifierLoc, ToEndLoc) = *Imp;
3150 Parameters.push_back(*ToPOrErr);
3163 std::tie(ExplicitExpr) = *Imp;
3184 std::tie(ToOperatorDelete, ToThisArg) = *Imp;
3202 std::tie(ExplicitExpr) = *Imp;
3269 ToFunction->setType(*TyOrErr);
3393 FoundField->setInClassInitializer(*ToInitializerOrErr);
3425 ToType, ToTInfo, ToBitWidth, ToInnerLocStart, ToInitializer) = *Imp;
3498 NamedChain[i++] = *ToD;
3505 Loc, Name.getAsIdentifierInfo(), *TypeOrErr, CH))
3555 ToFU = *TSIOrErr;
3564 ToTPLists[I] = *ListOrErr;
3578 *LocationOrErr, ToFU,
3579 *FriendLocOrErr, ToTPLists))
3624 std::tie(ToType, ToTypeSourceInfo, ToBitWidth, ToInnerLocStart) = *Imp;
3709 FoundVar->setType(*TyOrErr);
3747 std::tie(ToType, ToTypeSourceInfo, ToInnerLocStart, ToQualifierLoc) = *Imp;
3799 std::tie(ToDeclName, ToLocation, ToType) = *Imp;
3819 ToParam->setUninstantiatedDefaultArg(*ToDefArgOrErr);
3826 ToParam->setDefaultArg(*ToDefArgOrErr);
3848 ToTypeSourceInfo) = *Imp;
3958 std::tie(ToEndLoc, ToReturnType, ToReturnTypeSourceInfo) = *Imp;
3978 ToParams.push_back(*ToPOrErr);
4018 std::tie(ToVarianceLoc, ToLocation, ToColonLoc, ToTypeSourceInfo) = *Imp;
4061 ToIvarLBraceLoc, ToIvarRBraceLoc) = *Imp;
4079 ToCategory->setTypeParamList(*PListOrErr);
4093 Protocols.push_back(*ToProtoOrErr);
4098 ProtocolLocs.push_back(*ToProtoLocOrErr);
4119 ToCategory->setImplementation(*ToImplOrErr);
4149 Protocols.push_back(*ToProtoOrErr);
4154 ProtocolLocs.push_back(*ToProtoLocOrErr);
4179 return Importer.MapImported(D, *ImportedDefOrErr);
4212 *ToAtBeginLocOrErr,
4245 *ExternLocOrErr, *LangLocOrErr,
4245 *ExternLocOrErr, *LangLocOrErr,
4253 ToLinkageSpec->setRBraceLoc(*RBraceLocOrErr);
4276 std::tie(ToLoc, ToUsingLoc, ToQualifierLoc) = *Imp;
4297 ToUsing, *ToPatternOrErr);
4304 ToUsing->addShadowDecl(*ToShadowOrErr);
4333 *ToUsingOrErr, *ToTargetOrErr))
4333 *ToUsingOrErr, *ToTargetOrErr))
4343 ToShadow, *ToPatternOrErr);
4378 ToQualifierLoc, ToIdentLocation) = *Imp;
4388 ToNominatedNamespace, *ToComAncestorOrErr))
4413 std::tie(ToLoc, ToUsingLoc, ToQualifierLoc, ToEllipsisLoc) = *Imp;
4450 std::tie(ToUsingLoc, ToTypenameLoc, ToQualifierLoc, ToEllipsisLoc) = *Imp;
4475 FromSuper = *FromSuperOrErr;
4513 To->setSuperClass(*SuperTInfoOrErr);
4529 Protocols.push_back(*ToProtoOrErr);
4534 ProtocolLocs.push_back(*ToProtoLocOrErr);
4556 To->setImplementation(*ToImplOrErr);
4577 toTypeParams.push_back(*toTypeParamOrErr);
4591 *LAngleLocOrErr,
4593 *RAngleLocOrErr);
4603 return Importer.MapImported(D, *ImportedDefOrErr);
4638 *AtBeginLocOrErr, Name.getAsIdentifierInfo(),
4650 ToIface->setTypeParamList(*ToPListOrErr);
4676 std::tie(ToLocation, ToAtStartLoc, ToCategoryNameLoc) = *Imp;
4725 ToIvarLBraceLoc, ToIvarRBraceLoc) = *Imp;
4822 std::tie(ToType, ToTypeSourceInfo, ToAtLoc, ToLParenLoc) = *Imp;
4848 ToPropertyIvarDecl) = *Imp;
4890 std::tie(ToBeginLoc, ToLocation, ToPropertyIvarDeclLoc) = *Imp;
4962 *BeginLocOrErr, *LocationOrErr,
4962 *BeginLocOrErr, *LocationOrErr,
4979 ToInnerLocStart) = *Imp;
5017 Importer.getToContext().getTranslationUnitDecl(), *LocationOrErr,
5019 (*NameOrErr).getAsIdentifierInfo(),
5020 *TemplateParamsOrErr);
5103 *TemplateParamsOrErr, ToTemplated))
5241 *BeginLocOrErr, *IdLocOrErr, *ToTPListOrErr, ClassTemplate,
5241 *BeginLocOrErr, *IdLocOrErr, *ToTPListOrErr, ClassTemplate,
5241 *BeginLocOrErr, *IdLocOrErr, *ToTPListOrErr, ClassTemplate,
5257 *BeginLocOrErr, *IdLocOrErr, ClassTemplate, TemplateArgs,
5257 *BeginLocOrErr, *IdLocOrErr, ClassTemplate, TemplateArgs,
5280 D2->setQualifierInfo(*LocOrErr);
5286 D2->setTypeAsWritten(*TInfoOrErr);
5291 D2->setTemplateKeywordLoc(*LocOrErr);
5296 D2->setExternLoc(*LocOrErr);
5303 D2->setPointOfInstantiation(*POIOrErr);
5327 return Importer.MapImported(D, *ImportedDefOrErr);
5393 Name, *TemplateParamsOrErr, ToTemplated))
5418 return Importer.MapImported(D, *ImportedDefOrErr);
5498 *BeginLocOrErr, *IdLocOrErr, *ToTPListOrErr,
5498 *BeginLocOrErr, *IdLocOrErr, *ToTPListOrErr,
5498 *BeginLocOrErr, *IdLocOrErr, *ToTPListOrErr,
5499 VarTemplate, T, *TInfoOrErr,
5505 ToPartial->setInstantiatedFromMember(*ToInstOrErr);
5516 *BeginLocOrErr, *IdLocOrErr, VarTemplate,
5516 *BeginLocOrErr, *IdLocOrErr, VarTemplate,
5517 T, *TInfoOrErr,
5524 D2->setPointOfInstantiation(*POIOrErr);
5537 D2->setQualifierInfo(*LocOrErr);
5609 *ParamsOrErr, TemplatedFD))
5667 Clobbers.push_back(*ClobberOrErr);
5676 Constraints.push_back(*OutputOrErr);
5683 Constraints.push_back(*InputOrErr);
5713 *AsmLocOrErr,
5721 *AsmStrOrErr,
5725 *RParenLocOrErr);
5735 std::tie(ToDG, ToBeginLoc, ToEndLoc) = *Imp;
5745 *ToSemiLocOrErr, S->hasLeadingEmptyMacro());
5764 *ToLBracLocOrErr, *ToRBracLocOrErr);
5764 *ToLBracLocOrErr, *ToRBracLocOrErr);
5778 *Imp;
5794 std::tie(ToDefaultLoc, ToColonLoc, ToSubStmt) = *Imp;
5808 std::tie(ToIdentLoc, ToLabelDecl, ToSubStmt) = *Imp;
5827 Importer.getToContext(), *ToAttrLocOrErr, ToAttrs, *ToSubStmtOrErr);
5827 Importer.getToContext(), *ToAttrLocOrErr, ToAttrs, *ToSubStmtOrErr);
5843 *Imp;
5861 std::tie(ToInit, ToConditionVariable, ToCond, ToBody, ToSwitchLoc) = *Imp;
5876 LastChainedSwitchCase->setNextSwitchCase(*ToSCOrErr);
5878 ToStmt->setSwitchCaseList(*ToSCOrErr);
5879 LastChainedSwitchCase = *ToSCOrErr;
5895 std::tie(ToConditionVariable, ToCond, ToBody, ToWhileLoc) = *Imp;
5911 std::tie(ToBody, ToCond, ToDoLoc, ToWhileLoc, ToRParenLoc) = *Imp;
5931 ToLParenLoc, ToRParenLoc) = *Imp;
5946 std::tie(ToLabel, ToGotoLoc, ToLabelLoc) = *Imp;
5959 std::tie(ToGotoLoc, ToStarLoc, ToTarget) = *Imp;
5969 return new (Importer.getToContext()) ContinueStmt(*ToContinueLocOrErr);
5976 return new (Importer.getToContext()) BreakStmt(*ToBreakLocOrErr);
5988 std::tie(ToReturnLoc, ToRetValue, ToNRVOCandidate) = *Imp;
6003 std::tie(ToCatchLoc, ToExceptionDecl, ToHandlerBlock) = *Imp;
6022 ToHandlers[HI] = *ToHandlerOrErr;
6028 Importer.getToContext(), *ToTryLocOrErr,*ToTryBlockOrErr, ToHandlers);
6028 Importer.getToContext(), *ToTryLocOrErr,*ToTryBlockOrErr, ToHandlers);
6047 ToBody) = *Imp1;
6049 std::tie(ToForLoc, ToCoawaitLoc, ToColonLoc, ToRParenLoc) = *Imp2;
6067 std::tie(ToElement, ToCollection, ToBody, ToForLoc, ToRParenLoc) = *Imp;
6086 std::tie(ToAtCatchLoc, ToRParenLoc, ToCatchParamDecl, ToCatchBody) = *Imp;
6099 return new (Importer.getToContext()) ObjCAtFinallyStmt(*ToAtFinallyLocOrErr,
6100 *ToAtFinallyStmtOrErr);
6111 std::tie(ToAtTryLoc, ToTryBody, ToFinallyStmt) = *Imp;
6117 ToCatchStmts[CI] = *ToCatchStmtOrErr;
6138 std::tie(ToAtSynchronizedLoc, ToSynchExpr, ToSynchBody) = *Imp;
6152 *ToThrowLocOrErr, *ToThrowExprOrErr);
6152 *ToThrowLocOrErr, *ToThrowExprOrErr);
6163 return new (Importer.getToContext()) ObjCAutoreleasePoolStmt(*ToAtLocOrErr,
6164 *ToSubStmtOrErr);
6188 *Imp;
6206 std::tie(ToCond, ToLHS, ToRHS, ToBuiltinLoc, ToRParenLoc, ToType) = *Imp;
6232 return new (Importer.getToContext()) GNUNullExpr(*TypeOrErr, *BeginLocOrErr);
6232 return new (Importer.getToContext()) GNUNullExpr(*TypeOrErr, *BeginLocOrErr);
6244 std::tie(ToBeginLoc, ToType, ToFunctionName) = *Imp;
6262 *Imp;
6269 ToFoundD = *FoundDOrErr;
6295 return new (Importer.getToContext()) ImplicitValueInitExpr(*TypeOrErr);
6311 ToIndexExprs[I - 1] = *ToArgOrErr;
6322 ToIndexExprs, *ToEqualOrColonLocOrErr,
6323 E->usesGNUSyntax(), *ToInitOrErr);
6337 *ToTypeOrErr, *ToLocationOrErr);
6337 *ToTypeOrErr, *ToLocationOrErr);
6350 Importer.getToContext(), E->getValue(), *ToTypeOrErr, *ToLocationOrErr);
6350 Importer.getToContext(), E->getValue(), *ToTypeOrErr, *ToLocationOrErr);
6365 *ToTypeOrErr, *ToLocationOrErr);
6365 *ToTypeOrErr, *ToLocationOrErr);
6378 *ToSubExprOrErr, *ToTypeOrErr);
6378 *ToSubExprOrErr, *ToTypeOrErr);
6391 E->getValue(), E->getKind(), *ToTypeOrErr, *ToLocationOrErr);
6391 E->getValue(), E->getKind(), *ToTypeOrErr, *ToLocationOrErr);
6406 *ToTypeOrErr, ToLocations.data(), ToLocations.size());
6420 std::tie(ToLParenLoc, ToTypeSourceInfo, ToType, ToInitializer) = *Imp;
6435 std::tie(ToBuiltinLoc, ToType, ToRParenLoc) = *Imp;
6456 std::tie(ToAmpAmpLoc, ToLabelLoc, ToLabel, ToType) = *Imp;
6468 std::tie(ToSubExpr) = *Imp;
6487 std::tie(ToLParen, ToRParen, ToSubExpr) = *Imp;
6506 return ParenListExpr::Create(Importer.getToContext(), *ToLParenLocOrErr,
6507 ToExprs, *ToRParenLocOrErr);
6519 std::tie(ToSubStmt, ToType, ToLParenLoc, ToRParenLoc) = *Imp;
6534 std::tie(ToSubExpr, ToType, ToOperatorLoc) = *Imp;
6549 std::tie(ToType, ToOperatorLoc, ToRParenLoc) = *Imp;
6558 E->getKind(), *ToArgumentTypeInfoOrErr, ToType, ToOperatorLoc,
6567 E->getKind(), *ToArgumentExprOrErr, ToType, ToOperatorLoc, ToRParenLoc);
6579 std::tie(ToLHS, ToRHS, ToType, ToOperatorLoc) = *Imp;
6596 std::tie(ToCond, ToQuestionLoc, ToLHS, ToColonLoc, ToRHS, ToType) = *Imp;
6617 ToColonLoc, ToType) = *Imp;
6638 ToType) = *Imp;
6654 std::tie(ToBeginLoc, ToQueriedExpression, ToEndLoc, ToType) = *Imp;
6670 std::tie(ToLocation, ToType, ToSourceExpr) = *Imp;
6685 std::tie(ToLHS, ToRHS, ToType, ToRBracketLoc) = *Imp;
6704 ToOperatorLoc) = *Imp;
6717 Path.push_back(*SpecOrErr);
6738 Importer.getToContext(), *ToTypeOrErr, E->getCastKind(), *ToSubExprOrErr,
6738 Importer.getToContext(), *ToTypeOrErr, E->getCastKind(), *ToSubExprOrErr,
6739 &(*ToBasePathOrErr), E->getValueKind());
6751 std::tie(ToType, ToSubExpr, ToTypeInfoAsWritten) = *Imp1;
6756 CXXCastPath *ToBasePath = &(*ToBasePathOrErr);
6769 ToSubExpr, ToBasePath, ToTypeInfoAsWritten, *ToLParenLocOrErr,
6770 *ToRParenLocOrErr);
6783 E->getCastKind(), ToSubExpr, ToBasePath, *ToLParenLocOrErr,
6784 *ToRParenLocOrErr);
6796 *ToLParenLocOrErr, OCE->getBridgeKind(), E->getCastKind(),
6797 *ToBridgeKeywordLocOrErr, ToTypeInfoAsWritten, ToSubExpr);
6815 std::tie(ToBeginLoc, ToEndLoc) = *Imp;
6827 ToNodes.push_back(OffsetOfNode(*ToBSOrErr));
6834 ToNodes.push_back(OffsetOfNode(ToBeginLoc, *ToFieldOrErr, ToEndLoc));
6850 ToExprs[I] = *ToIndexExprOrErr;
6862 std::tie(ToType, ToTypeSourceInfo, ToOperatorLoc, ToRParenLoc) = *Imp;
6878 std::tie(ToType, ToOperand, ToBeginLoc, ToEndLoc) = *Imp;
6898 std::tie(ToSubExpr, ToType, ToThrowLoc) = *Imp;
6923 ParmVarDecl *ToParam = *ToParamOrErr;
6932 return CXXDefaultArgExpr::Create(Importer.getToContext(), *ToUsedLocOrErr,
6933 *ToParamOrErr, *UsedContextOrErr);
6933 *ToParamOrErr, *UsedContextOrErr);
6946 std::tie(ToType, ToTypeSourceInfo, ToRParenLoc) = *Imp;
6963 CXXTemporary *Temp = CXXTemporary::Create(ToCtx, *ToDtorOrErr);
6964 return CXXBindTemporaryExpr::Create(ToCtx, Temp, *ToSubExprOrErr);
6979 std::tie(ToConstructor, ToType, ToTypeSourceInfo, ToParenOrBraceRange) = *Imp;
7002 std::tie(ToType, ToTemporaryExpr, ToExtendingDecl) = *Imp;
7021 std::tie(ToType, ToPattern, ToEllipsisLoc) = *Imp;
7035 std::tie(ToOperatorLoc, ToPack, ToPackLoc, ToRParenLoc) = *Imp;
7073 ToType, ToAllocatedTypeSourceInfo, ToSourceRange, ToDirectInitRange) = *Imp;
7098 std::tie(ToType, ToOperatorDelete, ToArgument, ToBeginLoc) = *Imp;
7117 std::tie(ToType, ToLocation, ToConstructor, ToParenOrBraceRange) = *Imp;
7141 Importer.getToContext(), *ToSubExprOrErr, E->cleanupsHaveSideEffects(),
7154 std::tie(ToCallee, ToType, ToRParenLoc) = *Imp;
7174 *ToLocationOrErr, *ToTypeOrErr, E->isImplicit());
7174 *ToLocationOrErr, *ToTypeOrErr, E->isImplicit());
7187 E->getValue(), *ToTypeOrErr, *ToLocationOrErr);
7187 E->getValue(), *ToTypeOrErr, *ToLocationOrErr);
7204 ToType) = *Imp1;
7214 std::tie(ToDecl, ToName, ToLoc, ToLAngleLoc, ToRAngleLoc) = *Imp2;
7251 ToTildeLoc) = *Imp;
7259 Storage = PseudoDestructorTypeStorage(ToII, *ToDestroyedTypeLocOrErr);
7262 Storage = PseudoDestructorTypeStorage(*ToTIOrErr);
7286 ToFirstQualifierFoundInScope) = *Imp;
7291 ToBase = *ToBaseOrErr;
7309 std::get<0>(*ToMemberNameInfoOrErr), std::get<1>(*ToMemberNameInfoOrErr));
7309 std::get<0>(*ToMemberNameInfoOrErr), std::get<1>(*ToMemberNameInfoOrErr));
7334 ToLAngleLoc, ToRAngleLoc) = *Imp;
7363 std::tie(ToLParenLoc, ToRParenLoc, ToTypeSourceInfo) = *Imp;
7389 std::get<0>(*ToNameInfoOrErr), std::get<1>(*ToNameInfoOrErr));
7389 std::get<0>(*ToNameInfoOrErr), std::get<1>(*ToNameInfoOrErr));
7397 ToDecls.addDecl(cast<NamedDecl>(*ToDOrErr));
7413 Importer.getToContext(), *ToNamingClassOrErr, *ToQualifierLocOrErr,
7413 Importer.getToContext(), *ToNamingClassOrErr, *ToQualifierLocOrErr,
7414 *ToTemplateKeywordLocOrErr, ToNameInfo, E->requiresADL(), &ToTAInfo,
7419 Importer.getToContext(), *ToNamingClassOrErr, *ToQualifierLocOrErr,
7419 Importer.getToContext(), *ToNamingClassOrErr, *ToQualifierLocOrErr,
7435 std::tie(ToType, ToOperatorLoc, ToQualifierLoc, ToTemplateKeywordLoc) = *Imp1;
7440 DeclarationNameInfo ToNameInfo(std::get<0>(*Imp2), std::get<1>(*Imp2));
7440 DeclarationNameInfo ToNameInfo(std::get<0>(*Imp2), std::get<1>(*Imp2));
7448 ToDecls.addDecl(cast<NamedDecl>(*ToDOrErr));
7464 ToBase = *ToBaseOrErr;
7483 std::tie(ToCallee, ToType, ToRParenLoc) = *Imp;
7507 CXXRecordDecl *ToClass = *ToClassOrErr;
7517 ToCaptures.push_back(*ToCaptureOrErr);
7533 std::tie(ToIntroducerRange, ToCaptureDefaultLoc, ToEndLoc) = *Imp;
7550 std::tie(ToLBraceLoc, ToRBraceLoc, ToType) = *Imp;
7563 To->setArrayFiller(*ToFillerOrErr);
7570 To->setInitializedFieldInUnion(*ToFDOrErr);
7577 To->setSyntacticForm(*ToSyntFormOrErr);
7600 *ToTypeOrErr, *ToSubExprOrErr);
7600 *ToTypeOrErr, *ToSubExprOrErr);
7612 std::tie(ToLocation, ToType, ToConstructor) = *Imp;
7626 std::tie(ToType, ToCommonExpr, ToSubExpr) = *Imp;
7636 return new (Importer.getToContext()) ArrayInitIndexExpr(*ToTypeOrErr);
7653 Importer.getToContext(), *ToBeginLocOrErr, *ToFieldOrErr, *UsedContextOrErr);
7653 Importer.getToContext(), *ToBeginLocOrErr, *ToFieldOrErr, *UsedContextOrErr);
7653 Importer.getToContext(), *ToBeginLocOrErr, *ToFieldOrErr, *UsedContextOrErr);
7670 ToAngleBrackets) = *Imp;
7680 Importer.getToContext(), ToType, VK, CK, ToSubExpr, &(*ToBasePathOrErr),
7684 Importer.getToContext(), ToType, VK, CK, ToSubExpr, &(*ToBasePathOrErr),
7688 Importer.getToContext(), ToType, VK, CK, ToSubExpr, &(*ToBasePathOrErr),
7711 std::tie(ToType, ToExprLoc, ToParameter, ToReplacement) = *Imp;
7725 std::tie(ToType, ToBeginLoc, ToEndLoc) = *Imp;
7752 *ToTypeOrErr, *ToTSIOrErr, *ToSourceRangeOrErr);
7752 *ToTypeOrErr, *ToTSIOrErr, *ToSourceRangeOrErr);
7752 *ToTypeOrErr, *ToTSIOrErr, *ToSourceRangeOrErr);
7762 *ToTypeOrErr, *ToExprOperandOrErr, *ToSourceRangeOrErr);
7762 *ToTypeOrErr, *ToExprOperandOrErr, *ToSourceRangeOrErr);
7762 *ToTypeOrErr, *ToExprOperandOrErr, *ToSourceRangeOrErr);
7771 (*ImportedOrErr)->getCanonicalDecl()));
7886 ImportedTypes[FromTy] = (*ToTOrErr).getTypePtr();
7888 return ToContext.getQualifiedType(*ToTOrErr, FromT.getLocalQualifiers());
7904 return ToContext.getTrivialTypeSourceInfo(*TOrErr, *BeginLocOrErr);
7904 return ToContext.getTrivialTypeSourceInfo(*TOrErr, *BeginLocOrErr);
7910 ToAttr->setRange(*ToRangeOrErr);
8027 ToD = *ToDOrErr;
8065 auto *ToDC = cast<DeclContext>(*ToDCOrErr);
8120 return cast_or_null<Expr>(*ToSOrErr);
8140 if (auto *ToE = dyn_cast<Expr>(*ToSOrErr)) {
8154 ImportedStmts[FromS] = *ToSOrErr;
8176 cast<NamespaceDecl>(*NSOrErr));
8183 cast<NamespaceAliasDecl>(*NSADOrErr));
8193 cast<CXXRecordDecl>(*RDOrErr));
8297 return TemplateName(cast<TemplateDecl>(*ToTemplateOrErr));
8306 ToTemplates.addDecl(cast<NamedDecl>(*ToOrErr));
8319 return ToContext.getAssumedTemplateName(*DeclNameOrErr);
8330 *QualifierOrErr, QTN->hasTemplateKeyword(),
8331 cast<TemplateDecl>(*ToTemplateOrErr));
8343 return ToContext.getDependentTemplateName(*QualifierOrErr,
8347 return ToContext.getDependentTemplateName(*QualifierOrErr,
8363 cast<TemplateTemplateParmDecl>(*ParamOrErr), *ReplacementOrErr);
8363 cast<TemplateTemplateParmDecl>(*ParamOrErr), *ReplacementOrErr);
8380 cast<TemplateTemplateParmDecl>(*ParamOrErr), *ArgPackOrErr);
8380 cast<TemplateTemplateParmDecl>(*ParamOrErr), *ArgPackOrErr);
8399 return ToSM.getComposedLoc(*ToFileIDOrErr, Decomposed.second);
8434 MLoc = ToSM.createMacroArgExpansionLoc(*ToSpLoc, *ToExLocS, TokenLen);
8434 MLoc = ToSM.createMacroArgExpansionLoc(*ToSpLoc, *ToExLocS, TokenLen);
8437 MLoc = ToSM.createExpansionLoc(*ToSpLoc, *ToExLocS, *ToExLocE, TokenLen,
8437 MLoc = ToSM.createExpansionLoc(*ToSpLoc, *ToExLocS, *ToExLocE, TokenLen,
8437 MLoc = ToSM.createExpansionLoc(*ToSpLoc, *ToExLocS, *ToExLocE, TokenLen,
8463 ToID = ToSM.createFileID(*Entry, *ToIncludeLoc,
8520 ToContext, *ToTInfoOrErr, From->isBaseVirtual(), *LParenLocOrErr,
8520 ToContext, *ToTInfoOrErr, From->isBaseVirtual(), *LParenLocOrErr,
8521 *ToExprOrErr, *RParenLocOrErr, EllipsisLoc);
8521 *ToExprOrErr, *RParenLocOrErr, EllipsisLoc);
8532 ToContext, cast_or_null<FieldDecl>(*ToFieldOrErr), *MemberLocOrErr,
8532 ToContext, cast_or_null<FieldDecl>(*ToFieldOrErr), *MemberLocOrErr,
8533 *LParenLocOrErr, *ToExprOrErr, *RParenLocOrErr);
8533 *LParenLocOrErr, *ToExprOrErr, *RParenLocOrErr);
8533 *LParenLocOrErr, *ToExprOrErr, *RParenLocOrErr);
8544 ToContext, cast_or_null<IndirectFieldDecl>(*ToIFieldOrErr),
8545 *MemberLocOrErr, *LParenLocOrErr, *ToExprOrErr, *RParenLocOrErr);
8545 *MemberLocOrErr, *LParenLocOrErr, *ToExprOrErr, *RParenLocOrErr);
8545 *MemberLocOrErr, *LParenLocOrErr, *ToExprOrErr, *RParenLocOrErr);
8545 *MemberLocOrErr, *LParenLocOrErr, *ToExprOrErr, *RParenLocOrErr);
8552 CXXCtorInitializer(ToContext, *ToTInfoOrErr, *LParenLocOrErr,
8552 CXXCtorInitializer(ToContext, *ToTInfoOrErr, *LParenLocOrErr,
8553 *ToExprOrErr, *RParenLocOrErr);
8553 *ToExprOrErr, *RParenLocOrErr);
8576 *ToSourceRange, BaseSpec->isVirtual(), BaseSpec->isBaseOfClass(),
8577 BaseSpec->getAccessSpecifierAsWritten(), *ToTSI, *ToEllipsisLoc);
8577 BaseSpec->getAccessSpecifierAsWritten(), *ToTSI, *ToEllipsisLoc);
8586 Decl *To = *ToOrErr;
8637 return DeclarationName(*ToSelOrErr);
8644 ToContext.getCanonicalType(*ToTyOrErr));
8652 ToContext.getCanonicalType(*ToTyOrErr));
8660 cast<TemplateDecl>(*ToTemplateOrErr));
8668 ToContext.getCanonicalType(*ToTyOrErr));
8798 if (ToContext.hasSameType(*ToFromOrErr, To))
tools/clang/lib/AST/ExternalASTMerger.cpp 64 Source<DeclarationName> SourceName = *SourceNameOrErr;
180 Decl *D = *DeclOrErr;
498 SourceDC.get()->lookup(*FromNameOrErr);
515 NamedDecl *ND = cast_or_null<NamedDecl>(*NDOrErr);
539 assert(!(*ImportedDeclOrErr) ||
540 IsSameDC((*ImportedDeclOrErr)->getDeclContext(), DC));
tools/clang/lib/AST/Interp/Context.cpp 35 Func = *R;
138 return *R ? InterpResult::Success : InterpResult::Fail;
tools/clang/lib/CodeGen/BackendUtil.cpp 1346 if (const BitcodeModule *Bm = FindThinLTOModule(*BMsOrErr))
1417 ModuleMap.insert({I.first(), *BMOrErr});
1517 std::unique_ptr<ModuleSummaryIndex> CombinedIndex = std::move(*IndexOrErr);
tools/clang/lib/CodeGen/CodeGenAction.cpp 295 std::move(*OptRecordFileOrErr);
1001 BitcodeModule *Bm = FindThinLTOModule(*BMsOrErr);
1015 return std::move(*MOrErr);
tools/clang/lib/CodeGen/ObjectFilePCHContainerOperations.cpp 339 Name = *NameOrErr;
345 return *E;
tools/clang/lib/CrossTU/CrossTranslationUnit.cpp 245 ASTUnit *Unit = *ASTUnitOrError;
431 NameASTUnitMap[FunctionName] = *FoundForFile;
432 return *FoundForFile;
466 NameFileMap = *IndexMapping;
490 if (!*Unit)
524 auto *ToDecl = cast<T>(*ToDeclOrError);
tools/clang/lib/Driver/ToolChains/Darwin.cpp 1648 return *SDKInfoOrErr;
tools/clang/lib/Format/ContinuationIndenter.cpp 1631 *NewCode, FirstStartColumn, Style.TabWidth, Encoding);
tools/clang/lib/Format/Format.cpp 2244 ProcessFunc(Style, *NewCode, ChangedRanges, FileName);
2271 return processReplacements(Reformat, Code, *SortedReplaces, Style);
2430 CurrentCode = std::move(*NewCode);
tools/clang/lib/Frontend/ASTMerge.cpp 71 DeclGroupRef DGR(*ToDOrError);
tools/clang/lib/Frontend/CompilerInstance.cpp 850 FileEntryRef File = *FileOrErr;
tools/clang/lib/Index/CommentToXML.cpp 598 Declaration = *FormattedStringDecl;
tools/clang/lib/Lex/HeaderSearch.cpp 345 return *File;
tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp 588 return RuntimeDefinition(*CTUDeclOrError);
tools/clang/lib/Tooling/Execution.cpp 74 Plugin->create(*OptionsParser);
81 return std::move(*Executor);
tools/clang/lib/Tooling/Refactoring.cpp 95 format::formatReplacements(Code, CurReplaces, *CurStyle);
100 Result = applyAllReplacements(*NewReplacements, Rewrite) && Result;
tools/clang/lib/Tooling/Refactoring/ASTSelectionRequirements.cpp 23 findSelectedASTNodes(Context.getASTContext(), *Range);
38 std::make_unique<SelectedASTNode>(std::move(*ASTSelection));
tools/clang/lib/Tooling/Refactoring/AtomicChange.cpp 311 Replacements AllReplaces = std::move(*Replaces);
312 for (const auto &R : *HeaderReplacements) {
326 AllReplaces = std::move(*CleanReplaces);
340 Spec.Style, *ChangedCode, AllReplaces.getAffectedRanges(), FilePath);
341 ChangedCode = applyAllReplacements(*ChangedCode, HeaderSortingReplacements);
350 *ChangedCode, Spec.Style.ColumnLimit, Spec.Format, AllReplaces);
353 format::reformat(Spec.Style, *ChangedCode, FormatRanges, FilePath);
354 ChangedCode = applyAllReplacements(*ChangedCode, FormatReplacements);
tools/clang/lib/Tooling/Refactoring/Rename/RenamingAction.cpp 87 *Occurrences, Context.getASTContext().getSourceManager(), Name);
229 convertChangesToFileReplacements(*Change, &FileToReplaces);
tools/clang/lib/Tooling/Tooling.cpp 476 AbsolutePaths.push_back(std::move(*AbsPath));
tools/clang/lib/Tooling/Transformer/RangeSelector.cpp 135 ? tooling::getExtendedRange(*Node, tok::TokenKind::semi,
146 return tooling::getExtendedRange(*Node, tok::TokenKind::semi,
191 auto &Node = *N;
312 return Result.SourceManager->getExpansionRange(*SRange);
tools/clang/lib/Tooling/Transformer/RewriteRule.cpp 41 tooling::getRangeForEdit(*Range, *Result.Context);
51 T.Replacement = std::move(*Replacement);
tools/clang/lib/Tooling/Transformer/Stencil.cpp 196 *Result += tooling::getText(*Range, *Match.Context);
232 *Result += *Value;
tools/clang/lib/Tooling/Transformer/Transformer.cpp 51 (*Transformations)[0].Range.getBegin());
52 for (const auto &T : *Transformations) {
tools/clang/tools/clang-format/ClangFormat.cpp 416 Replacements Replaces = sortIncludes(*FormatStyle, Code->getBuffer(), Ranges,
427 reformat(*FormatStyle, *ChangedCode, Ranges, AssumedFileName, &Status);
427 reformat(*FormatStyle, *ChangedCode, Ranges, AssumedFileName, &Status);
500 std::string Config = clang::format::configurationAsText(*FormatStyle);
tools/clang/tools/clang-import-test/clang-import-test.cpp 361 ImportCIs.push_back(std::move(*ImportCI));
380 Forget(*ExpressionCI, (Direct && !UseOrigins) ? ImportCIs : IndirectCIs);
tools/clang/tools/clang-offload-bundler/ClangOffloadBundler.cpp 426 if (*TripleOrErr)
427 return **TripleOrErr;
625 if (errorToBool(BinaryOrErr.takeError()) || !isa<ObjectFile>(*BinaryOrErr))
691 std::unique_ptr<FileHandler> &FH = *FileHandlerOrErr;
729 std::unique_ptr<FileHandler> &FH = *FileHandlerOrErr;
753 if (!*CurTripleOrErr)
756 StringRef CurTriple = **CurTripleOrErr;
tools/clang/tools/clang-refactor/ClangRefactor.cpp 376 auto Rule = getMatchingRule(**Subcommand);
380 SelectedSubcommand = *Subcommand;
381 MatchingRule = *Rule;
507 OS << *Result;
511 llvm::outs() << *Result;
tools/clang/tools/clang-refactor/TestSupport.cpp 104 OS << *Result;
198 CanonicalResult = std::move(*Result);
212 if (HasResult && areChangesSame(*Result, *CanonicalResult))
237 dumpChanges(*Result, llvm::errs());
tools/clang/tools/clang-scan-deps/ClangScanDeps.cpp 117 OS.applyLocked([&](raw_ostream &OS) { OS << *MaybeFile; });
tools/clang/tools/extra/clang-apply-replacements/tool/ClangApplyReplacementsMain.cpp 105 format::FormatStyle FormatStyle = std::move(*FormatStyleOrError);
160 FileStream << *NewFileData;
tools/clang/tools/extra/clang-change-namespace/ChangeNamespace.cpp 1026 format::cleanupAroundReplacements(Code, Replaces, *Style);
1031 FileToReplacements[FilePath] = *CleanReplacements;
tools/clang/tools/extra/clang-include-fixer/IncludeFixer.cpp 420 auto Replaces = std::move(*CleanReplaces);
tools/clang/tools/extra/clang-include-fixer/tool/ClangIncludeFixer.cpp 230 return std::move(*DB);
333 Code->getBuffer(), Context, *InsertStyle,
342 tooling::applyAllReplacements(Code->getBuffer(), *Replacements);
347 llvm::outs() << *ChangedCode;
420 Buffer.get()->getBuffer(), Context, *InsertStyle);
426 FixerReplacements.push_back(*Replacements);
447 llvm::outs() << *ChangedCode;
tools/clang/tools/extra/clang-move/Move.cpp 788 Code, Context->FileToReplacements[FilePath], *Style);
794 Context->FileToReplacements[FilePath] = *CleanReplacements;
tools/clang/tools/extra/clang-tidy/ClangTidy.cpp 207 *Style);
213 format::formatReplacements(Code, *Replacements, *Style)) {
213 format::formatReplacements(Code, *Replacements, *Style)) {
tools/clang/tools/extra/clang-tidy/utils/TransformerClangTidyCheck.cpp 97 diag((*Transformations)[0].Range.getBegin(), *Explanation);
97 diag((*Transformations)[0].Range.getBegin(), *Explanation);
98 for (const auto &T : *Transformations)
tools/clang/tools/extra/clangd/ClangdLSPServer.cpp 359 (*TraceArgs)["Reply"] = *Reply;
638 Server->addDocument(File, *Contents, WantDiags);
707 if (auto Err = validateEdits(DraftMgr, *R))
741 for (auto &Sym : *Items)
744 Reply(std::move(*Items));
769 WE.changes = {{Params.textDocument.uri.uri(), *Edits}};
879 adjustSymbolKinds(*Items, SupportedSymbolKinds);
881 return Reply(std::move(*Items));
883 return Reply(flattenSymbolHierarchy(*Items, FileURI));
931 for (const auto &T : *Tweaks)
980 return Reply(std::move(*Signature));
987 return Reply(std::move(*Signature));
1020 for (auto &S : *Symbols) {
1039 for (auto &S : *Symbols) {
1057 if (*Path)
1058 return Reply(URIForFile::canonicalize(**Path, Params.uri.file()));
1077 if (!*H)
1082 R.range = (*H)->SymRange;
1085 R.contents.value = (*H)->present().renderAsPlainText();
1088 R.contents.value = (*H)->present().renderAsMarkdown();
1183 Result.emplace_back(render(std::move(*Ranges)));
1290 if (*Offset < 2)
1294 return (*Code)[*Offset - 2] == '-'; // trigger only on '->'.
1296 return (*Code)[*Offset - 2] == ':'; // trigger only on '::'.
tools/clang/tools/extra/clangd/ClangdLSPServer.h 173 } else if (fromJSON(*RawResponse, Rsp)) {
176 elog("Failed to decode {0} response", *RawResponse);
tools/clang/tools/extra/clangd/ClangdServer.cpp 276 return formatCode(Code, File, {tooling::Range(*Begin, *End - *Begin)});
276 return formatCode(Code, File, {tooling::Range(*Begin, *End - *Begin)});
276 return formatCode(Code, File, {tooling::Range(*Begin, *End - *Begin)});
299 formatIncremental(Code, *CursorPos, TriggerText, *Style))
299 formatIncremental(Code, *CursorPos, TriggerText, *Style))
347 cleanupAndFormat(InpAST->Inputs.Contents, *Changes, Style))
348 *Changes = std::move(*Formatted);
348 *Changes = std::move(*Formatted);
354 for (const auto &Rep : *Changes)
370 return Tweak::Selection(AST.Inputs.Index, AST.AST, *Begin, *End);
370 return Tweak::Selection(AST.Inputs.Index, AST.AST, *Begin, *End);
379 auto Selection = tweakSelection(Sel, *InpAST);
383 for (auto &T : prepareTweaks(*Selection, TweakFilter))
399 auto Selection = tweakSelection(Sel, *InpAST);
402 auto A = prepareTweak(TweakID, *Selection);
405 auto Effect = (*A)->apply(*Selection);
405 auto Effect = (*A)->apply(*Selection);
415 return CB(std::move(*Effect));
485 Style, *Changed,
tools/clang/tools/extra/clangd/CodeComplete.cpp 329 auto Spelled = Includes.calculateIncludePath(*ResolvedInserted, FileName);
335 Includes.shouldInsertInclude(*ResolvedDeclaring, *ResolvedInserted));
335 Includes.shouldInsertInclude(*ResolvedDeclaring, *ResolvedInserted));
1744 ? std::move(Flow).runWithoutSema(Contents, *Offset, VFS)
1746 {FileName, Command, Preamble, Contents, *Offset, VFS});
1770 {FileName, Command, Preamble, Contents, *Offset, std::move(VFS)});
tools/clang/tools/extra/clangd/DraftStore.cpp 72 if (*EndIndex < *StartIndex)
72 if (*EndIndex < *StartIndex)
87 lspLength(Contents.substr(*StartIndex, *EndIndex - *StartIndex));
87 lspLength(Contents.substr(*StartIndex, *EndIndex - *StartIndex));
87 lspLength(Contents.substr(*StartIndex, *EndIndex - *StartIndex));
97 NewContents.reserve(*StartIndex + Change.text.length() +
98 (Contents.length() - *EndIndex));
100 NewContents = Contents.substr(0, *StartIndex);
102 NewContents += Contents.substr(*EndIndex);
tools/clang/tools/extra/clangd/FindSymbols.cpp 56 L.uri = URIForFile::canonicalize(*Path, HintPath);
103 SK, *Loc, ScopeRef};
tools/clang/tools/extra/clangd/HeaderSourceSwitch.cpp 87 if (*TargetPath != OriginalFile) // exclude the original file.
88 ++Candidates[*TargetPath];
tools/clang/tools/extra/clangd/Headers.cpp 85 auto IncludePath = URI::includeSpelling(*U);
89 return HeaderFile{std::move(*IncludePath), /*Verbatim=*/true};
91 auto Resolved = URI::resolve(*U, HintPath);
94 return HeaderFile{std::move(*Resolved), /*Verbatim=*/false};
tools/clang/tools/extra/clangd/IncludeFixer.cpp 154 auto Spelled = Inserter->calculateIncludePath(*ResolvedInserted, File);
160 Inserter->shouldInsertInclude(*ResolvedDeclaring, *ResolvedInserted));
160 Inserter->shouldInsertInclude(*ResolvedDeclaring, *ResolvedInserted));
tools/clang/tools/extra/clangd/JSONTransport.cpp 71 {"result", std::move(*Result)},
89 vlog(Pretty ? "<<< {0:2}\n" : "<<< {0}\n", *Doc);
90 if (!handleMessage(std::move(*Doc), Handler))
tools/clang/tools/extra/clangd/Protocol.cpp 42 return URIForFile(std::move(*Resolved));
50 return URIForFile(std::move(*Resolved));
66 auto U = URIForFile::fromURI(*Parsed, /*HintPath=*/"");
71 R = std::move(*U);
tools/clang/tools/extra/clangd/RIFF.cpp 63 F.Chunks.push_back(*Chunk);
tools/clang/tools/extra/clangd/SemanticSelection.cpp 42 SelectionTree ST(AST.getASTContext(), AST.getTokens(), *Offset);
tools/clang/tools/extra/clangd/SourceCode.cpp 304 SourceLocation InputLoc = SM.getComposedLoc(FID, *Offset);
305 if (*Offset == 0) // Case 1 or 4.
307 SourceLocation Before = SM.getComposedLoc(FID, *Offset - 1);
585 return SM.getLocForStartOfFile(SM.getMainFileID()).getLocWithOffset(*Offset);
710 return *Style;
719 return formatReplacements(Code, std::move(*CleanReplaces), Style);
1052 E.Replacements = std::move(*NewEdits);
tools/clang/tools/extra/clangd/URI.cpp 191 auto Path = URI::resolve(*Uri, HintPath);
194 return *Path;
220 return std::move(*URI);
230 return std::move(*U);
tools/clang/tools/extra/clangd/XRefs.cpp 95 auto U = URIForFile::fromURI(*Uri, TUPath);
102 LSPLoc.uri = std::move(*U);
910 HI->Definition = *Formatted;
1263 fillSubTypes(*ID, *Item.children, Index, ResolveLevels, Item.uri.file());
tools/clang/tools/extra/clangd/index/Background.cpp 78 I.first->second = *Path;
tools/clang/tools/extra/clangd/index/BackgroundIndexLoader.cpp 78 if (*AbsPath != StartSourceFile) {
79 Edges.push_back(*AbsPath);
tools/clang/tools/extra/clangd/index/BackgroundIndexStorage.cpp 67 return std::make_unique<IndexFileIn>(std::move(*I));
tools/clang/tools/extra/clangd/index/Serialization.cpp 656 return std::move(*YAMLContents);
tools/clang/tools/extra/clangd/index/YAMLSerialization.cpp 83 return *ID;
tools/clang/tools/extra/clangd/index/dex/dexp/Dexp.cpp 182 IDs.push_back(*SID);
229 IDs.push_back(*SID);
tools/clang/tools/extra/clangd/refactor/Rename.cpp 33 auto U = URIForFile::fromURI(*Uri, HintFilePath);
tools/clang/tools/extra/clangd/refactor/tweaks/AnnotateHighlightings.cpp 69 FilePath, *InsertOffset, 0,
tools/clang/tools/extra/clangd/refactor/tweaks/DefineInline.cpp 340 *QualifiedBody);
361 Edits.push_back(std::move(*FE));
371 Edits.push_back(std::move(*FE));
tools/clang/tools/extra/clangd/refactor/tweaks/ExtractFunction.cpp 664 if (auto Err = Result.add(createFunctionDefinition(*ExtractedFunc, SM)))
666 if (auto Err = Result.add(replaceWithFuncCall(*ExtractedFunc, SM, LangOpts)))
tools/clang/tools/extra/clangd/refactor/tweaks/RemoveUsingNamespace.cpp 188 if (auto Err = R.add(*RemoveUsing))
tools/clang/tools/extra/clangd/unittests/BackgroundIndexTests.cpp 77 return std::make_unique<IndexFileIn>(std::move(*IndexFile));
tools/clang/tools/extra/clangd/unittests/ClangdTests.cpp 463 EXPECT_THAT(*Locations, ElementsAre(DeclAt(FooCpp, FooSource.range("one"))));
478 EXPECT_THAT(*Locations, ElementsAre(DeclAt(FooCpp, FooSource.range("two"))));
853 auto Changed = tooling::applyAllReplacements(Code, *Replaces);
855 EXPECT_EQ(Expected, *Changed);
tools/clang/tools/extra/clangd/unittests/DraftStoreTests.cpp 29 return *End - *Start;
29 return *End - *Start;
53 EXPECT_EQ(*Result, SrcAfter.code());
83 EXPECT_EQ(*Result, FinalSrc.code());
tools/clang/tools/extra/clangd/unittests/FindSymbolsTests.cpp 77 return *SymbolInfos;
335 return *SymbolInfos;
tools/clang/tools/extra/clangd/unittests/FormatTests.cpp 38 return *NewCode;
tools/clang/tools/extra/clangd/unittests/JSONTransportTests.cpp 81 Log << "Reply(" << ID << "): " << *Params << "\n";
tools/clang/tools/extra/clangd/unittests/RIFFTests.cpp 32 EXPECT_EQ(*Parsed, File);
tools/clang/tools/extra/clangd/unittests/RenameTests.cpp 86 tooling::applyAllReplacements(Code.code(), *RenameResult);
89 EXPECT_EQ(T.After, *ApplyResult) << T.Before;
197 EXPECT_THAT(*Results, UnorderedElementsAreArray(Expected));
tools/clang/tools/extra/clangd/unittests/SemanticSelectionTests.cpp 177 EXPECT_THAT(*Ranges, ElementsAreArray(SourceAnnotations.ranges()));
tools/clang/tools/extra/clangd/unittests/SerializationTests.cpp 185 IndexFileOut Out(*In);
218 IndexFileOut Out(*In);
255 IndexFileOut Out(*In);
tools/clang/tools/extra/clangd/unittests/TweakTesting.cpp 106 llvm::Expected<Tweak::Effect> Result = (*T)->apply(S);
119 llvm::StringRef Unwrapped = unwrap(Context, *NewText);
tools/clang/tools/extra/clangd/unittests/URITests.cpp 42 return *U;
67 return *Path;
144 return *Path;
166 EXPECT_THAT(resolveOrDie(*U), Path);
tools/clang/tools/extra/clangd/unittests/XRefsTests.cpp 583 EXPECT_THAT(*Locations, ElementsAre(Sym("foo", SourceAnnotations.range())));
589 *Locations,
595 EXPECT_THAT(*Locations,
1885 EXPECT_THAT(*Locations, ElementsAre(Sym("foo.h", HeaderAnnotations.range())));
1890 EXPECT_THAT(*Locations, ElementsAre(Sym("foo.h", HeaderAnnotations.range())));
1894 EXPECT_THAT(*Locations, ElementsAre(Sym("foo.h", HeaderAnnotations.range())));
1899 EXPECT_THAT(*Locations, ElementsAre(Sym("foo.h", HeaderAnnotations.range())));
1904 EXPECT_THAT(*Locations, IsEmpty());
1908 EXPECT_THAT(*Locations, ElementsAre(Sym("foo.h", HeaderAnnotations.range())));
1912 EXPECT_THAT(*Locations, ElementsAre(Sym("foo.h", HeaderAnnotations.range())));
1924 EXPECT_THAT(*Locations, ElementsAre(Sym("foo.h", HeaderAnnotations.range())));
2207 auto DeducedType = getDeducedType(AST, *Location);
tools/clang/tools/extra/pp-trace/PPTrace.cpp 145 Filters.emplace_back(std::move(*Pat), Enabled);
tools/clang/tools/extra/unittests/clang-change-namespace/ChangeNamespaceTests.cpp 62 return *ChangedCode;
tools/clang/tools/extra/unittests/clang-include-fixer/IncludeFixerTest.cpp 113 tooling::applyAllReplacements(*Replaces, Context.Rewrite);
tools/clang/tools/extra/unittests/clang-tidy/ClangTidyTest.h 163 return *Result;
tools/clang/unittests/AST/ASTImporterFixtures.cpp 83 return *ImportedOrErr;
102 return *ImportedOrErr;
tools/clang/unittests/AST/ASTImporterFixtures.h 211 << (*ValOrErr) << "\"";
tools/clang/unittests/AST/ASTImporterODRStrategiesTest.cpp 268 Decl *ImportedD = *Result;
tools/clang/unittests/AST/ASTImporterTest.cpp 54 (*Imported)->dump(ToNothing);
105 return Verifier.match(*Imported, WrapperMatcher);
tools/clang/unittests/Basic/DiagnosticTest.cpp 92 EXPECT_EQ(*Value, std::make_pair(20, 1));
tools/clang/unittests/CrossTU/CrossTranslationUnitTest.cpp 84 const FunctionDecl *NewFD = *NewFDorError;
tools/clang/unittests/DirectoryWatcher/DirectoryWatcherTest.cpp 71 closeFile(*ft);
tools/clang/unittests/Format/CleanupTest.cpp 33 return *Result;
312 auto Result = applyAllReplacements(Code, *CleanReplaces);
314 return *Result;
322 auto FormattedReplaces = formatReplacements(Code, *CleanReplaces, Style);
325 auto Result = applyAllReplacements(Code, *FormattedReplaces);
327 return *Result;
tools/clang/unittests/Format/FormatTest.cpp 51 LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
52 return *Result;
14273 ASSERT_EQ(*Style1, getGoogleStyle());
14286 ASSERT_EQ(*Style1, getLLVMStyle());
14293 ASSERT_EQ(*Style2, getMozillaStyle());
14298 ASSERT_EQ(*Style2, getNoStyle());
14306 ASSERT_EQ(*Style2, getLLVMStyle());
14311 ASSERT_EQ(*Style2, getLLVMStyle());
14321 ASSERT_EQ(*Style3, getGoogleStyle());
14352 ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen));
14384 auto Result = applyAllReplacements(Code, *FormattedReplaces);
14386 EXPECT_EQ(Expected, *Result);
14413 auto Result = applyAllReplacements(Code, *FormattedReplaces);
14415 EXPECT_EQ(Expected, *Result);
tools/clang/unittests/Format/FormatTestCSharp.cpp 29 LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
30 return *Result;
tools/clang/unittests/Format/FormatTestComments.cpp 54 LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
55 return *Result;
tools/clang/unittests/Format/FormatTestJS.cpp 32 LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
33 return *Result;
tools/clang/unittests/Format/FormatTestJava.cpp 29 LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
30 return *Result;
tools/clang/unittests/Format/FormatTestObjC.cpp 55 LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
56 return *Result;
tools/clang/unittests/Format/FormatTestProto.cpp 29 LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
30 return *Result;
tools/clang/unittests/Format/FormatTestRawStrings.cpp 49 LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
50 return *Result;
tools/clang/unittests/Format/FormatTestSelective.cpp 32 LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
33 return *Result;
tools/clang/unittests/Format/FormatTestTableGen.cpp 29 LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
30 return *Result;
tools/clang/unittests/Format/FormatTestTextProto.cpp 29 LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
30 return *Result;
tools/clang/unittests/Format/NamespaceEndCommentsFixerTest.cpp 33 LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
34 return *Result;
tools/clang/unittests/Format/SortImportsTestJS.cpp 31 *Sorted, reformat(Style, *Sorted, Ranges, FileName));
31 *Sorted, reformat(Style, *Sorted, Ranges, FileName));
33 return *Formatted;
tools/clang/unittests/Format/SortImportsTestJava.cpp 22 *Sorted, reformat(FmtStyle, *Sorted, Ranges, "input.java"));
22 *Sorted, reformat(FmtStyle, *Sorted, Ranges, "input.java"));
24 return *Result;
tools/clang/unittests/Format/SortIncludesTest.cpp 36 *Sorted, reformat(FmtStyle, *Sorted, Ranges, FileName));
36 *Sorted, reformat(FmtStyle, *Sorted, Ranges, FileName));
38 return *Result;
tools/clang/unittests/Format/UsingDeclarationsSorterTest.cpp 31 LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
32 return *Result;
tools/clang/unittests/Rename/ClangRenameTest.h 104 return *ChangedCode;
tools/clang/unittests/Tooling/HeaderIncludesTest.cpp 31 return *Result;
40 return *Result;
tools/clang/unittests/Tooling/RangeSelectorTest.cpp 62 return tooling::getText(*Range, *Match.Result.Context);
tools/clang/unittests/Tooling/RefactoringActionRulesTest.cpp 93 return std::make_pair(*R, 20);
110 AtomicChanges Result = std::move(*ErrorOrResult);
tools/clang/unittests/Tooling/RefactoringCallbacksTest.cpp 102 expectRewritten(Code, Expected, declStmt().bind("id"), **Callback);
112 **Callback);
123 **Callback);
tools/clang/unittests/Tooling/RefactoringTest.cpp 923 auto InSequenceRewrite = applyAllReplacements(*AfterFirst, Second);
925 EXPECT_EQ(Intermediate, *AfterFirst);
926 EXPECT_EQ(Result, *InSequenceRewrite);
931 EXPECT_EQ(*InSequenceRewrite, *MergedRewrite);
931 EXPECT_EQ(*InSequenceRewrite, *MergedRewrite);
932 if (*InSequenceRewrite != *MergedRewrite)
932 if (*InSequenceRewrite != *MergedRewrite)
941 auto InSequenceRewrite = applyAllReplacements(*AfterFirst, Second);
945 EXPECT_EQ(*InSequenceRewrite, *MergedRewrite);
945 EXPECT_EQ(*InSequenceRewrite, *MergedRewrite);
946 if (*InSequenceRewrite != *MergedRewrite)
946 if (*InSequenceRewrite != *MergedRewrite)
1336 return *ChangedCode;
tools/clang/unittests/Tooling/RewriterTest.cpp 48 EXPECT_EQ("line1\nreplaced\nline3\nline4", *Rewritten);
tools/clang/unittests/Tooling/StencilTest.cpp 100 ADD_FAILURE() << "Expected failure but succeeded: " << *ResultOrErr;
170 << "Expected unbound node, got " << *ResultOrErr;
tools/clang/unittests/Tooling/TransformerTest.cpp 61 return *Formatted;
105 return *ChangedCode;
111 Changes.push_back(std::move(*C));
tools/dsymutil/BinaryHolder.cpp 68 FatBinary = std::move(*ErrOrFat);
80 Archives.push_back(std::move(*ErrOrArchive));
107 FatBinary = std::move(*ErrOrFat);
118 Objects.push_back(std::move(*ErrOrObjectFile));
171 if (*NameOrErr == ObjectFilename) {
191 object::ObjectFile::createObjectFile(*ErrOrMem);
195 OE.Objects.push_back(std::move(*ErrOrObjectFile));
tools/dsymutil/BinaryHolder.h 87 return cast<ObjectFileType>(*Object);
tools/dsymutil/DebugMap.cpp 265 SymbolAddresses[*Name] = Address;
tools/dsymutil/DwarfLinker.cpp 445 DataExtractor Data(*ContentsOrErr, Obj.isLittleEndian(), 0);
497 if (const auto *Mapping = DMO.lookupSymbol(*SymbolName))
542 SectionName = *NameOrErr;
2234 return *Object;
tools/dsymutil/DwarfStreamer.cpp 35 SectionName = *NameOrErr;
687 MS->EmitBytes(*E);
tools/dsymutil/MachODebugMapParser.cpp 179 loadCurrentObjectFileSymbols(*Object);
367 for (const auto *Object : *Objects)
389 for (const auto *Object : *Objects)
497 CurrentObjectAddresses[*Name] = None;
499 CurrentObjectAddresses[*Name] = None;
500 CommonSymbols.push_back(*Name);
502 CurrentObjectAddresses[*Name] = Addr;
541 SymbolRef::Type Type = *TypeOrErr;
561 Section = *SectionOrErr;
571 StringRef Name = *NameOrErr;
tools/dsymutil/MachOUtils.cpp 38 File = std::make_unique<sys::fs::TempFile>(std::move(*T));
365 auto &InputBinary = *Object;
tools/dsymutil/dsymutil.cpp 225 Options.LinkOpts.TheAccelTableKind = *AccelKind;
238 Options.InputFiles = std::move(*InputFiles);
475 auto &Options = *OptionsOrErr;
tools/gold/gold-plugin.cpp 488 return std::move(*E);
544 std::unique_ptr<InputFile> Obj = std::move(*ObjOrErr);
tools/llc/llc.cpp 343 std::unique_ptr<ToolOutputFile> RemarksFile = std::move(*RemarksFileOrErr);
tools/lld/COFF/Chunks.cpp 40 sectionName = *e;
tools/lld/COFF/DebugTypes.cpp 245 TypeServerSource::instances[path] = {{}, *ts};
tools/lld/COFF/Driver.cpp 1159 tar = std::move(*errOrWriter);
tools/lld/COFF/DriverUtils.cpp 745 MemoryBufferRef mbref = **e;
746 make<std::unique_ptr<MemoryBuffer>>(std::move(*e)); // take ownership
tools/lld/COFF/InputFiles.cpp 237 name = *e;
319 parentName = *e;
tools/lld/COFF/PDB.cpp 332 tpiBuilder.addTypeRecord(type.RecordData, *hash);
443 maybeIpi = &*expectedIpi;
495 const CVIndexMap &precompIndexMap = *e;
983 return pdbStrTable.insert(*expectedString);
1188 DebugSHandler dsh(*this, *file, *indexMapResult);
tools/lld/Common/DWARF.cpp 27 lt = *expectedLT;
tools/lld/Common/Strings.cpp 40 patterns.push_back(*pat);
tools/lld/ELF/Driver.cpp 458 tar = std::move(*errOrWriter);
tools/lld/ELF/SyntheticSections.cpp 2576 for (DWARFAddressRange &r : *ranges) {
tools/lld/ELF/Writer.cpp 2605 buffer = std::move(*bufferOrErr);
tools/lld/include/lld/Common/ErrorHandler.h 139 return std::move(*e);
153 return std::move(*e);
tools/lld/lib/ReaderWriter/MachO/File.h 247 if (auto ec = normalized::normalizedObjectToAtoms(this, **normFile, false))
337 if (auto ec = normalized::normalizedDylibToAtoms(this, **normFile, false))
tools/lld/lib/ReaderWriter/MachO/MachONormalizedFileBinaryWriter.cpp 1538 std::unique_ptr<llvm::FileOutputBuffer> &fob = *fobOrErr;
tools/lld/lib/ReaderWriter/MachO/MachONormalizedFileToAtoms.cpp 918 tu.name = *eName;
926 tu.path = *eName;
981 file.setDebugInfo(std::make_unique<DwarfDebugInfo>(std::move(*tuOrErr)));
tools/lld/unittests/MachOTests/MachONormalizedFileBinaryReaderTests.cpp 37 return std::move(*r);
tools/lld/unittests/MachOTests/MachONormalizedFileToAtomsTests.cpp 32 EXPECT_EQ(0U, (*atom_f)->defined().size());
72 const lld::File &file = **atom_f;
tools/lld/unittests/MachOTests/MachONormalizedFileYAMLTests.cpp 34 return std::move(*r);
tools/lld/wasm/Driver.cpp 669 tar = std::move(*errOrWriter);
tools/lld/wasm/Writer.cpp 1087 buffer = std::move(*bufferOrErr);
tools/lldb/source/Commands/CommandObjectReproducer.cpp 281 result.AppendMessage(*version);
292 result.AppendMessage(*cwd);
tools/lldb/source/Core/Communication.cpp 209 m_read_thread = *maybe_thread;
tools/lldb/source/Core/Debugger.cpp 1513 m_event_handler_thread = *event_handler_thread;
1554 m_io_handler_thread = *io_handler_thread;
tools/lldb/source/Core/DumpDataExtractor.cpp 563 auto &type_system = *type_system_or_err;
tools/lldb/source/Host/common/NativeProcessProtocol.cpp 373 m_software_breakpoints.emplace(addr, std::move(*expected_bkpt));
506 *expected_trap) {
516 return SoftwareBreakpoint{1, saved_opcode_bytes, *expected_trap};
tools/lldb/source/Initialization/SystemInitializerCommon.cpp 83 llvm::StringRef working_dir = llvm::StringRef(*cwd).rtrim();
tools/lldb/source/Interpreter/CommandAlias.cpp 53 args = std::move(*args_or);
tools/lldb/source/Interpreter/CommandObject.cpp 112 args = std::move(*args_or);
tools/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.cpp 235 return SaveSOEntriesFromRemote(*module_list);
237 return AddSOEntriesFromRemote(*module_list);
239 return RemoveSOEntriesFromRemote(*module_list);
tools/lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp 1998 return *type_or_error;
2018 return *decl_or_error;
tools/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp 200 return *ret_or_error;
tools/lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp 258 m_owningbin = OWNBINType(std::move(*binary));
tools/lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp 282 pid, -1, native_delegate, Info.GetArchitecture(), mainloop, *tids_or));
1602 std::make_pair(thread_id, std::move(*traceMonitor)));
1859 return (*perf_monitor).ReadPerfTraceData(buffer, offset);
1877 return (*perf_monitor).ReadPerfTraceAux(buffer, offset);
1897 error = (*perf_monitor).GetTraceConfig(config);
1920 std::make_pair(thread_sp->GetID(), std::move(*traceInstance)));
1967 lldb::user_id_t ret_trace_id = (*traceMonitor)->GetTraceID();
1969 std::make_pair(threadid, std::move(*traceMonitor)));
tools/lldb/source/Plugins/Process/POSIX/NativeProcessELF.cpp 171 library_list.push_back(*info);
tools/lldb/source/Plugins/Process/Utility/RegisterContextLLDB.cpp 1923 hint += *expected_size;
tools/lldb/source/Plugins/Process/elf-core/ProcessElfCore.cpp 866 return parseFreeBSDNotes(*notes_or_error);
868 return parseLinuxNotes(*notes_or_error);
870 return parseNetBSDNotes(*notes_or_error);
872 return parseOpenBSDNotes(*notes_or_error);
tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp 898 m_listen_thread = *listen_thread;
tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationReplayServer.cpp 212 m_async_thread = *async_thread;
tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp 237 m_debugged_process_up = std::move(*process_or);
306 m_debugged_process_up = std::move(*process_or);
532 thread_obj.try_emplace("registers", std::move(*registers));
668 unescaped_response.AsRawOstream() << std::move(*threads_info);
2778 for (auto const &library : *library_list) {
2830 .insert(std::make_pair(buffer_key, std::move(*buffer_up)))
3096 response.AsRawOstream() << *threads_info;
tools/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp 3635 m_async_thread = *async_thread;
tools/lldb/source/Plugins/Process/minidump/MinidumpParser.cpp 34 return MinidumpParser(data_sp, std::move(*ExpectedFile));
95 return *ExpectedThreads;
261 return *ExpectedModules;
284 for (const auto &module : *ExpectedModules) {
298 *ExpectedName, filtered_modules.size());
320 return &*ExpectedStream;
338 for (const auto &memory_desc : *ExpectedMemory) {
353 return minidump::Range(range_start, *ExpectedSlice);
441 for (const MemoryInfo &entry : *ExpectedInfo) {
477 for (const MemoryDescriptor &memory_desc : *ExpectedMemory) {
tools/lldb/source/Plugins/Process/minidump/ProcessMinidump.cpp 199 m_minidump_parser = std::move(*expected_parser);
tools/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp 1243 size_t num_args = *maybe_args;
tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugAbbrev.cpp 37 if (*es == DWARFEnumState::Complete)
tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.cpp 87 assert(*unit_sp);
88 m_units.push_back(*unit_sp);
89 offset = (*unit_sp)->GetNextUnitOffset();
tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp 211 return std::move(*expected_ranges);
tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp 821 new DWARFTypeUnit(dwarf, uid, *expected_header, *abbrevs, section));
823 new DWARFCompileUnit(dwarf, uid, *expected_header, *abbrevs, section));
tools/lldb/source/Plugins/SymbolFile/DWARF/DebugNamesDWARFIndex.cpp 114 Append(*entry_or, offsets);
136 Append(*entry_or, offsets);
258 Append(*entry_or, offsets);
tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp 179 return *line_table;
466 m_index = std::move(*index_or);
tools/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp 120 OwningBinary<Binary> binary = std::move(*expected_binary);
307 m_index = std::move(*expected_index);
693 else if (*expected_full_ti != type_id.index) {
694 full_decl_uid = PdbTypeSymId(*expected_full_ti, false);
1109 auto fn_iter = llvm::find(cci->m_file_list, *efn);
tools/lldb/source/Symbol/ClangASTContext.cpp 1278 return *ret_or_error;
tools/lldb/source/Symbol/ClangASTImporter.cpp 76 return *ret_or_error;
144 return *result;
1024 dyn_cast<ObjCInterfaceDecl>(*imported_from_superclass_decl);
tools/lldb/source/Symbol/CxxModuleHandler.cpp 139 auto lookup_result = emulateLookupInCtxt(sema, ns_name, *parent);
213 emulateLookupInCtxt(*m_sema, td->getName(), *to_context);
235 imported_args.push_back(TemplateArgument(*type));
247 TemplateArgument(d->getASTContext(), integral, *type));
tools/lldb/source/Target/Process.cpp 3536 m_private_state_thread = *private_state_thread;
tools/lldb/source/Target/ThreadPlanCallFunction.cpp 76 m_start_addr = *start_address;
tools/lldb/source/Utility/Reproducer.cpp 255 m_data_recorders.push_back(std::move(*recorder_or_error));
tools/lldb/source/Utility/StructuredData.cpp 34 return ParseJSONValue(*value);
tools/lldb/tools/lldb-test/lldb-test.cpp 446 ContextOr->IsValid() ? &*ContextOr : nullptr;
502 ContextOr->IsValid() ? &*ContextOr : nullptr;
520 ContextOr->IsValid() ? &*ContextOr : nullptr;
569 ContextOr->IsValid() ? &*ContextOr : nullptr;
801 auto Action = *ActionOr;
tools/lldb/unittests/Expression/DWARFExpressionTest.cpp 136 m_sections_map = std::move(*sections_map);
tools/lldb/unittests/Process/minidump/MinidumpParserTest.cpp 51 parser = std::move(*expected_parser);
69 parser = std::move(*expected_parser);
tools/lldb/unittests/Symbol/TestLineEntry.cpp 59 m_file.emplace(std::move(*ExpectedFile));
tools/lldb/unittests/TestingSupport/Host/NativeProcessTestUtils.h 88 BytesWritten = *ExpectedBytes;
tools/lldb/unittests/tools/lldb-server/tests/LLGSTest.cpp 30 auto &Client = **ClientOr;
48 auto &Client = **ClientOr;
61 auto &Client = **ClientOr;
tools/lldb/unittests/tools/lldb-server/tests/MessageObjects.cpp 26 auto &elements = *elements_or_error;
90 Result[Register] = std::move(*RegValOr);
127 ThreadInfo(name, reason, std::move(*RegsOr), signal);
141 auto &Elements = *ElementsOr;
261 Result[Reg] = std::move(*RegValOr);
315 ThreadPcs[Id] = std::move(*PcOr);
324 std::move(*RegistersOr), Reason);
tools/lldb/unittests/tools/lldb-server/tests/TestBase.h 50 Client = std::move(*ClientOr);
tools/lldb/unittests/tools/lldb-server/tests/TestClient.cpp 217 m_process_info = std::move(*InfoOr);
229 m_register_infos.emplace_back(std::move(*InfoOr));
255 m_stop_reply = std::move(*StopReplyOr);
tools/llvm-ar/llvm-ar.cpp 267 Archives.push_back(std::move(*LibOrErr));
445 StringRef Data = *DataOrErr;
645 if (sys::path::is_absolute(*FileNameOrErr)) {
646 NMOrErr->MemberName = Saver.save(sys::path::convert_to_slash(*FileNameOrErr));
651 computeArchiveRelativePath(ArchiveName, *FileNameOrErr);
653 PathOrErr ? *PathOrErr : sys::path::convert_to_slash(*FileNameOrErr));
653 PathOrErr ? *PathOrErr : sys::path::convert_to_slash(*FileNameOrErr));
660 object::Archive &Lib = readLibrary(*FileNameOrErr);
671 Members.push_back(std::move(*NMOrErr));
692 PathOrErr ? *PathOrErr : sys::path::convert_to_slash(FileName));
709 Members.push_back(std::move(*NMOrErr));
868 return isa<object::MachOObjectFile>(**OptionalObject)
tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp 78 std::unique_ptr<MemoryBuffer> MemBuf = std::move(*MemBufOrErr);
tools/llvm-cfi-verify/lib/FileAnalysis.cpp 456 if (NameOrErr && *NameOrErr == ".plt")
463 ArrayRef<uint8_t> SectionBytes = arrayRefFromStringRef(*Contents);
559 else if (TrapOnFailFunctions.count(*SymNameOrErr) > 0) {
564 TrapOnFailFunctionAddresses.insert(*AddrOrErr);
573 else if (TrapOnFailFunctions.count(*SymNameOrErr) > 0)
tools/llvm-cov/TestingSupport.cpp 55 Name = *NameOrErr;
79 CoverageMappingData = *E;
85 ProfileNamesData = *E;
tools/llvm-cvtres/llvm-cvtres.cpp 203 std::unique_ptr<FileOutputBuffer> FileBuffer = std::move(*FileOrErr);
tools/llvm-cxxdump/llvm-cxxdump.cpp 62 return std::move(*EO);
98 *I = *RelocSymName;
120 Collection[std::make_pair(SymName, Offset - SymOffset)] = *RelocSymName;
181 section_iterator Sec2 = *ErrOrSec;
196 StringRef SymName = *SymNameOrErr;
199 object::section_iterator SecI = *SecIOrErr;
210 uint64_t SymAddress = *SymAddressOrErr;
tools/llvm-dwarfdump/llvm-dwarfdump.cpp 502 auto &Obj = **MachOOrErr;
tools/llvm-dwp/llvm-dwp.cpp 175 ID.Name = *EName;
183 ID.DWOName = *EName;
412 StringRef Name = *NameOrErr;
417 StringRef Contents = *ContentsOrErr;
541 Objects.push_back(std::move(*ErrOrObj));
573 const auto &ID = *EID;
601 const auto &ID = *EID;
tools/llvm-elfabi/ELFObjHandler.cpp 279 ELFSymbol Sym = createELFSym<ELFT>(*SymName, RawSym);
311 if (Error Err = populateDynamic<ELFT>(DynEnt, *DynTable))
334 DestStub->SoName = *NameOrErr;
344 DestStub->NeededLibs.push_back(*LibNameOrErr);
351 if (*SymCount > 0) {
359 ArrayRef<Elf_Sym>(reinterpret_cast<const Elf_Sym *>(*DynSymPtr),
360 *SymCount);
tools/llvm-elfabi/llvm-elfabi.cpp 91 return std::move(*StubFromELF);
102 return std::move(*StubFromTBE);
tools/llvm-exegesis/lib/BenchmarkRunner.cpp 127 << *ObjectFilePath << "\n";
128 ObjectFile = getObjectFromFile(*ObjectFilePath);
144 InstrBenchmark.Measurements = std::move(*Measurements);
tools/llvm-exegesis/lib/Latency.cpp 195 if (*ExpectedCounterValue < MinValue)
196 MinValue = *ExpectedCounterValue;
tools/llvm-exegesis/lib/Uops.cpp 236 *ExpectedCounterValue));
244 BenchmarkMeasure::Create("NumMicroOps", *ExpectedCounterValue));
tools/llvm-lipo/llvm-lipo.cpp 456 InputBinaries.push_back(std::move(*BinaryOrErr));
tools/llvm-lto/llvm-lto.cpp 502 maybeVerifyModule(**ModuleOrErr);
506 (*ModuleOrErr)->setModuleIdentifier(ThinLTOModuleId);
508 return std::move(*ModuleOrErr);
tools/llvm-lto2/llvm-lto2.cpp 151 return std::move(*E);
tools/llvm-mca/llvm-mca.cpp 391 const mca::CodeRegions &Regions = *RegionsOrErr;
tools/llvm-mt/llvm-mt.cpp 154 std::unique_ptr<FileOutputBuffer> FileBuffer = std::move(*FileOrErr);
tools/llvm-nm/llvm-nm.cpp 513 Sec = *SecOrErr;
524 SectionName = *NameOrErr;
909 elf_section_iterator SecI = *SecIOrErr;
925 if ((*NameOrErr).startswith(".debug"))
945 char Ret = StringSwitch<char>(*Name)
960 section_iterator SecI = *SecIOrErr;
1020 section_iterator Sec = *SecOrErr;
1026 SectionName = *NameOrErr;
1100 if (*SecIOrErr == ELFObj->section_end())
1103 Expected<StringRef> NameOrErr = (*SecIOrErr)->getName();
1108 SecName = *NameOrErr;
1160 SectionName = *NameOrErr;
1233 S.Address = *AddressOrErr;
1366 SectionName = *NameOrErr;
1690 SectionName = *NameOrErr;
1887 std::unique_ptr<Archive> &A = *AOrErr;
1958 std::unique_ptr<Archive> &A = *AOrErr;
2023 std::unique_ptr<Archive> &A = *AOrErr;
tools/llvm-objcopy/Buffer.cpp 44 Buf = std::move(*BufferOrErr);
tools/llvm-objcopy/COFF/Reader.cpp 74 S.Name = *NameOrErr;
93 COFFSymbolRef SymRef = *SymOrErr;
tools/llvm-objcopy/CopyConfig.cpp 152 SR.NewFlags = *ParsedFlagSet;
194 SFU.NewFlags = *ParsedFlagSet;
310 return NameOrPattern(std::make_shared<GlobPattern>(*GlobOrErr),
543 if (!Config.SectionsToRename.try_emplace(SR->OriginalName, *SR).second)
560 if (!Config.SetSectionFlags.try_emplace(SFU->Name, *SFU).second)
tools/llvm-objcopy/CopyConfig.h 135 PosMatchers.push_back(std::move(*Matcher));
137 NegMatchers.push_back(std::move(*Matcher));
232 ELF = *ELFConfig;
tools/llvm-objcopy/ELF/ELFConfig.cpp 125 ELFConfig.SymbolsToAdd.push_back(*NSI);
tools/llvm-objcopy/ELF/ELFObjcopy.cpp 174 for (const auto &Phdr : *PhdrsOrErr) {
296 std::unique_ptr<FileOutputBuffer> Buf = std::move(*BufferOrErr);
784 BuildIdBytes = *BuildIdBytesOrErr;
tools/llvm-objcopy/ELF/Object.cpp 1651 Records.push_back(*R);
tools/llvm-objcopy/llvm-objcopy.cpp 190 return createFileError(Ar.getFileName() + "(" + *ChildNameOrErr + ")",
203 NewArchiveMembers.push_back(std::move(*Member));
tools/llvm-objcopy/llvm-objcopy.h 31 return *EO;
tools/llvm-objdump/COFFDump.cpp 165 ResolvedAddr = *ResolvedAddrOrErr;
169 ResolvedSection = Obj->getCOFFSection(**Iter);
215 Name = *NameOrErr;
483 StringRef SymName = *SymNameOrErr;
666 if (std::error_code EC = coff->getSymbolName(*Symbol, Name))
tools/llvm-objdump/ELFDump.cpp 30 for (const typename ELFT::Dyn &Dyn : *DynamicEntriesOrError) {
35 return StringRef(reinterpret_cast<const char *>(*MappedAddrOrError));
44 for (const typename ELFT::Shdr &Sec : *SectionsOrError) {
70 if ((*SecOrErr)->sh_type == ELF::SHT_RELA) {
74 } else if ((*SecOrErr)->sh_type != ELF::SHT_REL) {
91 Obj->getSection((*SymSI)->getRawDataRefImpl());
95 Fmt << *SecName;
101 Fmt << demangle(*SymName);
103 Fmt << *SymName;
138 for (const typename ELFT::Phdr &Phdr : *PhdrRangeOrErr)
193 for (const typename ELFT::Phdr &Phdr : *ProgramHeaderOrError) {
tools/llvm-objdump/MachODump.cpp 241 SymbolRef::Type AType = *ATypeOrErr;
245 SymbolRef::Type BType = *BTypeOrErr;
491 S = *NameOrErr;
1025 outs() << "(" << SegName << "," << *NameOrErr << ")\n";
1081 outs() << "Relocation information (" << SegName << "," << *NameOrErr
1101 outs() << "Relocation information (" << SegName << "," << *NameOrErr
1536 SectName = *SectNameOrErr;
1753 SectName = *SecNameOrErr;
1854 SectName = *SecNameOrErr;
1955 SectName = *NameOrErr;
2414 std::unique_ptr<Archive> &A = *AOrErr;
2478 std::unique_ptr<Archive> &A = *AOrErr;
2528 std::unique_ptr<Archive> &A = *AOrErr;
3294 SectName = *SecNameOrErr;
4091 SectName = *SecNameOrErr;
4113 SectName = *SecNameOrErr;
5841 SectName = *SecNameOrErr;
5909 SectName = *SecNameOrErr;
5960 SectName = *SecNameOrErr;
6022 SectName = *SecNameOrErr;
6077 SectName = *SecNameOrErr;
7413 DSYMBinary = std::move(*MachDSYM);
7435 if (*SecNameOrErr != DisSectName)
7834 Name = *NameOrErr;
7857 Name = *NameOrErr;
8215 section_iterator Section = *SectOrErr;
8226 SectName = *NameOrErr;
tools/llvm-objdump/WasmDump.cpp 44 StringRef SymName = *SymNameOrErr;
tools/llvm-objdump/llvm-objdump.cpp 368 StringRef SecName = *SecNameOrErr;
618 LineInfo = *ExpectedLineInfo;
956 if (*SecNameOrErr == ".plt")
1007 section_iterator Relocated = *RelocatedOrErr;
1505 if (SymSI && *SymSI != Obj->section_end() &&
1506 shouldAdjustVA(**SymSI))
1630 SecToRelSec[**SecOrErr].push_back(Section);
1821 Name = *NameOrErr;
1949 Name = *NameOrErr;
1985 Name = *NameOrErr;
tools/llvm-objdump/llvm-objdump.h 151 return std::move(*EO);
tools/llvm-opt-report/OptReport.cpp 167 remarks::createRemarkParserFromMeta(*Format, (*Buf)->getBuffer());
175 remarks::RemarkParser &Parser = **MaybeParser;
193 const remarks::Remark &Remark = **MaybeRemark;
tools/llvm-pdbutil/BytesOutputStyle.cpp 74 Result.push_back(*ESS);
222 P.formatBinary(Label, *ExpectedData, Base, 0);
tools/llvm-pdbutil/DumpOutputStyle.cpp 539 std::tie(Stream, Headers) = std::move(*ExpectedHeaders);
1034 Module = *ExpectedModule;
1199 Str.append(*ES);
1375 StringRef SectionName = *NameOrErr;
1391 BinaryStreamReader Reader(*ContentsOrErr, llvm::support::little);
1518 P.formatLine("`{0}` -> {1}", *ExpectedStr, TI);
1590 ModuleDebugStreamRef &ModS = *ExpectedModS;
1819 if (auto E = Visitor.visitSymbolRecord(*Sym, PubSymOff))
1889 std::tie(Stream, Headers) = std::move(*ExpectedHeaders);
tools/llvm-pdbutil/InputFile.cpp 70 if (*NameOrErr != Name)
83 Reader = BinaryStreamReader(*ContentsOrErr, support::little);
185 DebugStream = std::make_shared<ModuleDebugStreamRef>(std::move(*MDS));
199 ChecksumsByFile[*S] = Entry;
247 formatInternal(Printer, Append, "{0} (no checksum)", *ExpectedFile);
249 formatInternal(Printer, Append, "{0} ({1}: {2})", *ExpectedFile,
270 IF.CoffObject = std::move(*BinaryOrErr);
tools/llvm-pdbutil/MinimalSymbolDumper.cpp 486 typeIndex(FS.Index), FS.ModFilenameOffset, *FileName,
732 Filename = *MaybeFile;
tools/llvm-pdbutil/MinimalTypeDumper.cpp 46 const char *Direction = (*ETI == CurrentTypeIndex)
48 : ((*ETI < CurrentTypeIndex) ? "<-" : "->");
50 formatv("forward ref ({0} {1})", Direction, *ETI).str();
237 uint32_t OurHash = *MaybeHash;
tools/llvm-pdbutil/YAMLOutputStyle.cpp 122 Obj.StringTable->push_back(*S);
249 *ExpectedChecksums);
260 DMI.Subsections.push_back(*Converted);
274 DMI.Modi->Symbols.push_back(*ES);
297 Obj.TpiStream->Records.push_back(*ExpectedRecord);
325 Obj.IpiStream->Records.push_back(*ExpectedRecord);
342 PublicsStream &Publics = *ExpectedPublics;
357 auto ES = CodeViewYAML::SymbolRecord::fromCodeViewSymbol(*Sym);
361 Obj.PublicsStream->PubSyms.push_back(*ES);
tools/llvm-rc/ResourceFileWriter.cpp 409 *FS << (*File)->getBuffer();
711 StringRef Buffer = (*File)->getBuffer();
889 BinaryStreamReader Reader((*File)->getBuffer(), support::little);
tools/llvm-rc/ResourceScriptParser.cpp 87 Result = parseUserDefinedResource(*TypeToken);
90 (*Result)->setName(*NameToken);
90 (*Result)->setName(*NameToken);
150 return (*Value).getValue();
156 IntWithNotMask Result = *FirstResult;
164 Result += *NextResult;
168 Result -= *NextResult;
172 Result |= *NextResult;
176 Result &= *NextResult;
198 return -(*Result);
204 return ~(*Result);
214 return *Result;
221 return IntWithNotMask(0, (*Result).getValue());
313 Result.push_back(*IntResult);
386 Result.addStmt(std::move(*SingleParse));
432 std::move(*OptStatements), MemoryFlags);
442 Accels->addAccelerator(*EventResult, *IDResult, *FlagsResult);
442 Accels->addAccelerator(*EventResult, *IDResult, *FlagsResult);
442 Accels->addAccelerator(*EventResult, *IDResult, *FlagsResult);
452 return std::make_unique<CursorResource>(*Arg, MemoryFlags);
467 HelpID = *HelpIDResult;
479 (*LocResult)[0], (*LocResult)[1], (*LocResult)[2], (*LocResult)[3],
479 (*LocResult)[0], (*LocResult)[1], (*LocResult)[2], (*LocResult)[3],
479 (*LocResult)[0], (*LocResult)[1], (*LocResult)[2], (*LocResult)[3],
479 (*LocResult)[0], (*LocResult)[1], (*LocResult)[2], (*LocResult)[3],
480 HelpID, std::move(*OptStatements), IsExtended, MemoryFlags);
484 Dialog->addControl(std::move(*ControlDefResult));
517 Data.push_back(*Item);
530 std::move(**BlockResult), std::move(*FixedResult), MemoryFlags);
530 std::move(**BlockResult), std::move(*FixedResult), MemoryFlags);
551 Caption = *CaptionResult;
563 Class = *ClassStr;
566 Style = *StyleVal;
577 Style = *Val;
584 ExStyle = *Val;
589 HelpID = *Val;
592 return Control(*ClassResult, Caption, *ID, (*Args)[0], (*Args)[1],
592 return Control(*ClassResult, Caption, *ID, (*Args)[0], (*Args)[1],
592 return Control(*ClassResult, Caption, *ID, (*Args)[0], (*Args)[1],
592 return Control(*ClassResult, Caption, *ID, (*Args)[0], (*Args)[1],
593 (*Args)[2], (*Args)[3], Style, ExStyle, HelpID, Class);
593 (*Args)[2], (*Args)[3], Style, ExStyle, HelpID, Class);
600 return std::make_unique<BitmapResource>(*Arg, MemoryFlags);
607 return std::make_unique<IconResource>(*Arg, MemoryFlags);
614 return std::make_unique<HTMLResource>(*Arg, MemoryFlags);
622 return std::make_unique<MenuResource>(std::move(*OptStatements),
623 std::move(*Items), MemoryFlags);
663 MenuResult = *IntResult;
673 *CaptionResult, *FlagsResult, std::move(*SubMenuResult)));
673 *CaptionResult, *FlagsResult, std::move(*SubMenuResult)));
673 *CaptionResult, *FlagsResult, std::move(*SubMenuResult)));
679 std::make_unique<MenuItem>(*CaptionResult, MenuResult, *FlagsResult));
679 std::make_unique<MenuItem>(*CaptionResult, MenuResult, *FlagsResult));
691 auto Table = std::make_unique<StringTableResource>(std::move(*OptStatements),
702 Table->addString(*IDResult, *StrResult);
702 Table->addString(*IDResult, *StrResult);
716 Contents->addStmt(std::move(*Stmt));
730 return parseVersionInfoBlockContents(*NameResult);
746 Values.push_back(*ValueResult);
749 return std::make_unique<VersionInfoValue>(*KeyResult, std::move(Values),
764 auto FixedType = RetType::getFixedType(*TypeResult);
784 return std::make_unique<LanguageResource>((*Args)[0], (*Args)[1]);
784 return std::make_unique<LanguageResource>((*Args)[0], (*Args)[1]);
789 return std::make_unique<CharacteristicsStmt>(*Arg);
794 return std::make_unique<VersionStmt>(*Arg);
799 return std::make_unique<CaptionStmt>(*Arg);
804 return std::make_unique<ClassStmt>(*Arg);
822 FontWeight = (*Args)[0];
824 FontItalic = (*Args)[1] != 0;
826 FontCharset = (*Args)[2];
829 return std::make_unique<FontStmt>(*SizeResult, *NameResult, FontWeight,
829 return std::make_unique<FontStmt>(*SizeResult, *NameResult, FontWeight,
835 return std::make_unique<StyleStmt>(*Arg);
840 return std::make_unique<ExStyleStmt>(*Arg);
tools/llvm-readobj/ARMEHABIPrinter.h 374 StringRef StrTable = *StrTableOrErr;
385 return *NameOrErr;
409 const Elf_Shdr *SymTab = *SymTabOrErr;
426 return *Ret;
558 SW.printString("ExceptionHandlingTable", *Name);
580 SW.printString("SectionName", *SectionName);
tools/llvm-readobj/ARMWinEHPrinter.cpp 229 if (FunctionOnly && *Type != SymbolRef::ST_Function)
235 if (*Address == VA)
913 SW.printString("Routine", formatSymbol(*Name, Address));
950 FunctionName = *FunctionNameOrErr;
959 FunctionAddress = *FunctionAddressOrErr;
984 uint64_t Address = *AddressOrErr;
986 SW.printString("ExceptionRecord", formatSymbol(*Name, Address));
994 section_iterator SI = *SIOrErr;
1033 FunctionName = *FunctionNameOrErr;
1042 FunctionAddress = *FunctionAddressOrErr;
tools/llvm-readobj/COFFDumper.cpp 288 Name = *NameOrErr;
1405 SymbolName = *SymbolNameOrErr;
1466 SectionName = *NameOrErr;
1500 if (std::error_code EC = Obj->getSymbolName(*Linked, LinkedName))
1542 AssocName = *Res;
1557 if (std::error_code EC = Obj->getSymbolName(*ReferredSym, ReferredName))
1889 Name = *NameOrErr;
1920 Name = *NameOrErr;
1953 if (std::error_code EC = Obj->getSymbolName(*Sym, SymName))
tools/llvm-readobj/DwarfCFIEHPrinter.h 54 for (const auto &Shdr : *Sections)
69 for (const auto &Phdr : *PHs) {
88 for (const auto &Shdr : *Sections) {
93 if (*SectionName == ".eh_frame")
114 W.printString("Corresponding Section", *SectionName);
tools/llvm-readobj/ELFDumper.cpp 769 Expected<StringRef> NameOrErr = (*SymOrErr)->getName(*StrTabOrErr);
769 Expected<StringRef> NameOrErr = (*SymOrErr)->getName(*StrTabOrErr);
772 return maybeDemangle(*NameOrErr);
1584 DynamicStringTable = *E;
3645 Name = maybeDemangle(*ErrOrName);
4651 printCoreNote<ELFT>(OS, *Note);
4700 return *NameOrErr;
4710 return maybeDemangle(*NameOrErr);
4728 if (Symbol.getELFType() == ELF::STT_FUNC && *SymAddrOrErr == SymValue) {
4793 } else if (*SectionOrErr != FunctionSec) {
4800 FunctionSec = **SectionOrErr;
4805 RelocSymValue = *RelocSymValueOrErr;
4878 SectionName = *NameOrErr;
4906 Obj->getSection((*RelSecOrErr)->getRawDataRefImpl());
4913 if (*ContentsSectionNameOrErr != ".stack_sizes")
5787 for (uint64_t Sym : *V) {
5790 W.printNumber("Sym", *NameOrErr, Sym);
5897 printCoreNoteLLVMStyle(*Note, W);
tools/llvm-readobj/MachODumper.cpp 560 TargetName = *TargetNameOrErr;
626 SymbolName = *SymbolNameOrErr;
636 section_iterator SecI = *SecIOrErr;
669 Name = *NameOrErr;
tools/llvm-readobj/Win64EHDumper.cpp 124 OS << *Name;
153 ResolvedAddress = *ResolvedAddressOrErr;
158 ResolvedSection = Ctx.COFF.getCOFFSection(**SI);
310 Name = *NameOrErr;
tools/llvm-readobj/WindowsResourceDumper.cpp 43 auto EntryPtr = *EntryPtrOrErr;
tools/llvm-readobj/llvm-readobj.cpp 619 CVTypes.Binaries.push_back(std::move(*BinaryOrErr));
tools/llvm-readobj/llvm-readobj.h 29 return *EO;
tools/llvm-rtdyld/llvm-rtdyld.cpp 391 ObjectFile &Obj = **MaybeObj;
429 SymbolRef::Type Type = *TypeOrErr;
443 uint64_t Addr = *AddrOrErr;
458 object::section_iterator Sec = *SecOrErr;
467 outs() << "Function: " << *Name << ", Size = " << Size
526 ObjectFile &Obj = **MaybeObj;
867 SecInfo.setTargetAddress(Dyld.getSectionLoadAddress(*SectionID));
868 SecInfo.setContent(Dyld.getSectionContent(*SectionID));
918 ObjectFile &Obj = **MaybeObj;
tools/llvm-size/llvm-size.cpp 617 std::unique_ptr<Archive> &UA = *AOrErr;
706 std::unique_ptr<Archive> &UA = *AOrErr;
783 std::unique_ptr<Archive> &UA = *AOrErr;
tools/llvm-symbolizer/llvm-symbolizer.cpp 244 for (DILocal Local : *ResOrErr)
tools/llvm-xray/func-id-helper.cpp 38 auto &DI = *ResOrErr;
70 auto &DI = *ResOrErr;
tools/llvm-xray/xray-account.cpp 420 Map = std::move(*InstrumentationMapOrError);
442 auto &T = *TraceOrErr;
tools/llvm-xray/xray-converter.cpp 379 Map = std::move(*InstrumentationMapOrError);
404 auto &T = *TraceOrErr;
tools/llvm-xray/xray-extract.cpp 92 exportAsYAML(*InstrumentationMapOrError, OS, FuncIdHelper);
tools/llvm-xray/xray-fdr-dump.cpp 49 *FDOrErr, sys::fs::mapped_file_region::mapmode::readonly, FileSize, 0,
51 sys::fs::closeFile(*FDOrErr);
tools/llvm-xray/xray-graph-diff.cpp 452 Factories[i].Trace = std::move(*TraceOrErr);
459 auto GraphRenderer = *GraphRendererOrErr;
470 auto &GDR = *GDROrErr;
tools/llvm-xray/xray-graph.cpp 434 Map = std::move(*InstrumentationMapOrError);
502 F.Trace = std::move(*TraceOrErr);
506 auto &GR = *GROrError;
tools/llvm-xray/xray-stacks.cpp 701 Map = std::move(*InstrumentationMapOrError);
738 auto &T = *TraceOrErr;
tools/obj2yaml/coff2yaml.cpp 117 if ((*SectionNameOrErr) != ".debug$S")
159 NewYAMLSection.Name = *NameOrErr;
209 if (SymbolUnique.lookup(*SymbolNameOrErr))
210 Rel.SymbolName = *SymbolNameOrErr;
tools/obj2yaml/elf2yaml.cpp 104 StringRef Name = *NameOrErr;
122 StringRef Name = *SymbolNameOrErr;
127 return getUniquedSectionName(*ShdrOrErr);
169 Sections = *SectionsOrErr;
204 ShndxTable = *TableOrErr;
223 Y->Sections.emplace_back(*SecOrErr);
236 Y->Sections.emplace_back(*SecOrErr);
244 Y->Sections.emplace_back(*SecOrErr);
251 Y->Sections.emplace_back(*GroupOrErr);
258 Y->Sections.emplace_back(*SecOrErr);
265 Y->Sections.emplace_back(*SecOrErr);
272 Y->Sections.emplace_back(*SecOrErr);
279 Y->Sections.emplace_back(*SecOrErr);
286 Y->Sections.emplace_back(*SecOrErr);
293 Y->Sections.emplace_back(*SecOrErr);
300 Y->Sections.emplace_back(*SecOrErr);
307 Y->Sections.emplace_back(*SecOrErr);
328 if (*SpecialSecOrErr) {
329 Y->Sections.emplace_back(*SpecialSecOrErr);
338 Y->Sections.emplace_back(*SecOrErr);
355 StringRef StrTable = *StrTableOrErr;
362 SymTable = *SymtabOrErr;
366 for (const auto &Sym : (*SymtabOrErr).drop_front()) {
399 const Elf_Shdr *Shdr = *ShdrOrErr;
425 const Elf_Sym *Sym = *SymOrErr;
432 auto StrTabOrErr = Obj.getStringTable(*StrTabSec);
437 getUniquedSymbolName(Sym, *StrTabOrErr, SymTab);
471 NameOrErr = getUniquedSectionName(*LinkSection);
487 if (ELFYAML::StackSizesSection::nameMatches(*NameOrErr))
502 auto NameOrErr = getUniquedSectionName(*InfoSection);
521 ArrayRef<uint8_t> Content = *ContentOrErr;
554 ArrayRef<uint8_t> Content = *ContentOrErr;
570 Symbols.emplace_back(*SymbolName);
594 for (const Elf_Dyn &Dyn : *DynTagsOrErr)
610 const Elf_Shdr *SymTab = *SymTabOrErr;
616 for (const Elf_Rel &Rel : *Rels) {
626 for (const Elf_Rela &Rel : *Rels) {
650 ArrayRef<uint8_t> Content = *ContentOrErr;
672 for (const Elf_Word &E : *EntriesOrErr)
700 ArrayRef<uint8_t> Content = *ContentOrErr;
703 S->Content = yaml::BinaryRef(*ContentOrErr);
709 S->Content = yaml::BinaryRef(*ContentOrErr);
735 ArrayRef<uint8_t> Content = *ContentOrErr;
781 auto StringTableOrErr = Obj.getStringTable(*StringTableShdrOrErr);
789 llvm::ArrayRef<uint8_t> Data = *Contents;
827 for (const Elf_Half &E : *VersionsOrErr)
853 auto StringTableOrErr = Obj.getStringTable(*StringTableShdrOrErr);
857 llvm::ArrayRef<uint8_t> Data = *Contents;
897 const Elf_Shdr *Symtab = *SymtabOrErr;
905 return getUniquedSymbolName(*SymOrErr, *StrTabOrErr, Symtab);
905 return getUniquedSymbolName(*SymOrErr, *StrTabOrErr, Symtab);
918 S->Signature = *SymbolName;
924 for (Elf_Word Member : *MembersOrErr) {
933 auto NameOrErr = getUniquedSectionName(*SHdrOrErr);
936 S->Members.push_back({*NameOrErr});
tools/obj2yaml/minidump2yaml.cpp 22 Output << *ExpectedObject;
tools/opt/opt.cpp 565 std::unique_ptr<ToolOutputFile> RemarksFile = std::move(*RemarksFileOrErr);
tools/sancov/sancov.cpp 563 if (B.isBlacklisted(*LineInfo))
568 Infos.insert(*LineInfo);
569 Point.Locs.push_back(*LineInfo);
753 ArrayRef<uint8_t> Bytes = arrayRefFromStringRef(*BytesStr);
884 if (B.isBlacklisted(*LineInfo))
unittests/BinaryFormat/MsgPackReaderTest.cpp 27 EXPECT_TRUE(*ContinueOrErr);
33 EXPECT_TRUE(*ContinueOrErr);
40 EXPECT_FALSE(*ContinueOrErr);
49 EXPECT_TRUE(*ContinueOrErr);
58 EXPECT_TRUE(*ContinueOrErr);
68 EXPECT_TRUE(*ContinueOrErr);
83 EXPECT_TRUE(*ContinueOrErr);
94 EXPECT_TRUE(*ContinueOrErr);
104 EXPECT_TRUE(*ContinueOrErr);
114 EXPECT_TRUE(*ContinueOrErr);
124 EXPECT_TRUE(*ContinueOrErr);
134 EXPECT_TRUE(*ContinueOrErr);
144 EXPECT_TRUE(*ContinueOrErr);
154 EXPECT_TRUE(*ContinueOrErr);
164 EXPECT_TRUE(*ContinueOrErr);
174 EXPECT_TRUE(*ContinueOrErr);
184 EXPECT_TRUE(*ContinueOrErr);
194 EXPECT_TRUE(*ContinueOrErr);
204 EXPECT_TRUE(*ContinueOrErr);
217 EXPECT_TRUE(*ContinueOrErr);
228 EXPECT_TRUE(*ContinueOrErr);
238 EXPECT_TRUE(*ContinueOrErr);
248 EXPECT_TRUE(*ContinueOrErr);
258 EXPECT_TRUE(*ContinueOrErr);
268 EXPECT_TRUE(*ContinueOrErr);
278 EXPECT_TRUE(*ContinueOrErr);
288 EXPECT_TRUE(*ContinueOrErr);
298 EXPECT_TRUE(*ContinueOrErr);
308 EXPECT_TRUE(*ContinueOrErr);
318 EXPECT_TRUE(*ContinueOrErr);
328 EXPECT_TRUE(*ContinueOrErr);
338 EXPECT_TRUE(*ContinueOrErr);
348 EXPECT_TRUE(*ContinueOrErr);
358 EXPECT_TRUE(*ContinueOrErr);
368 EXPECT_TRUE(*ContinueOrErr);
379 EXPECT_TRUE(*ContinueOrErr);
391 EXPECT_TRUE(*ContinueOrErr);
401 EXPECT_TRUE(*ContinueOrErr);
412 EXPECT_TRUE(*ContinueOrErr);
423 EXPECT_TRUE(*ContinueOrErr);
433 EXPECT_TRUE(*ContinueOrErr);
444 EXPECT_TRUE(*ContinueOrErr);
455 EXPECT_TRUE(*ContinueOrErr);
465 EXPECT_TRUE(*ContinueOrErr);
476 EXPECT_TRUE(*ContinueOrErr);
487 EXPECT_TRUE(*ContinueOrErr);
497 EXPECT_TRUE(*ContinueOrErr);
508 EXPECT_TRUE(*ContinueOrErr);
519 EXPECT_TRUE(*ContinueOrErr);
529 EXPECT_TRUE(*ContinueOrErr);
540 EXPECT_TRUE(*ContinueOrErr);
551 EXPECT_TRUE(*ContinueOrErr);
561 EXPECT_TRUE(*ContinueOrErr);
572 EXPECT_TRUE(*ContinueOrErr);
583 EXPECT_TRUE(*ContinueOrErr);
593 EXPECT_TRUE(*ContinueOrErr);
603 EXPECT_TRUE(*ContinueOrErr);
613 EXPECT_TRUE(*ContinueOrErr);
624 EXPECT_TRUE(*ContinueOrErr);
634 EXPECT_TRUE(*ContinueOrErr);
644 EXPECT_TRUE(*ContinueOrErr);
654 EXPECT_TRUE(*ContinueOrErr);
664 EXPECT_TRUE(*ContinueOrErr);
674 EXPECT_TRUE(*ContinueOrErr);
684 EXPECT_TRUE(*ContinueOrErr);
694 EXPECT_TRUE(*ContinueOrErr);
704 EXPECT_TRUE(*ContinueOrErr);
715 EXPECT_TRUE(*ContinueOrErr);
725 EXPECT_TRUE(*ContinueOrErr);
735 EXPECT_TRUE(*ContinueOrErr);
745 EXPECT_TRUE(*ContinueOrErr);
755 EXPECT_TRUE(*ContinueOrErr);
765 EXPECT_TRUE(*ContinueOrErr);
778 EXPECT_TRUE(*ContinueOrErr);
790 EXPECT_TRUE(*ContinueOrErr);
802 EXPECT_TRUE(*ContinueOrErr);
814 EXPECT_TRUE(*ContinueOrErr);
826 EXPECT_TRUE(*ContinueOrErr);
838 EXPECT_TRUE(*ContinueOrErr);
850 EXPECT_TRUE(*ContinueOrErr);
862 EXPECT_TRUE(*ContinueOrErr);
874 EXPECT_TRUE(*ContinueOrErr);
886 EXPECT_TRUE(*ContinueOrErr);
unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp 230 std::unique_ptr<DWARFContext> DwarfContext = DWARFContext::create(**Obj);
494 std::unique_ptr<DWARFContext> DwarfContext = DWARFContext::create(**Obj);
671 std::unique_ptr<DWARFContext> DwarfContext = DWARFContext::create(**Obj);
881 std::unique_ptr<DWARFContext> DwarfContext = DWARFContext::create(**Obj);
1044 std::unique_ptr<DWARFContext> DwarfContext = DWARFContext::create(**Obj);
1097 std::unique_ptr<DWARFContext> DwarfContext = DWARFContext::create(**Obj);
1150 std::unique_ptr<DWARFContext> DwarfContext = DWARFContext::create(**Obj);
1322 std::unique_ptr<DWARFContext> DwarfContext = DWARFContext::create(**Obj);
1385 DWARFContext::create(*ErrOrSections, 8);
1433 std::unique_ptr<DWARFContext> DwarfContext = DWARFContext::create(**Obj);
1502 std::unique_ptr<DWARFContext> DwarfContext = DWARFContext::create(**Obj);
1705 std::unique_ptr<DWARFContext> DwarfContext = DWARFContext::create(**Obj);
1769 std::unique_ptr<DWARFContext> DwarfContext = DWARFContext::create(**Obj);
1924 DWARFContext::create(*ErrOrSections, 8);
1973 DWARFContext::create(*ErrOrSections, 8);
2010 DWARFContext::create(*ErrOrSections, 8);
2047 DWARFContext::create(*ErrOrSections, 8);
2080 DWARFContext::create(*ErrOrSections, 8);
2128 DWARFContext::create(*ErrOrSections, 8);
2199 DWARFContext::create(*ErrOrSections, 8);
2271 DWARFContext::create(*ErrOrSections, 8);
2343 DWARFContext::create(*ErrOrSections, 8);
2420 DWARFContext::create(*ErrOrSections, 8);
2502 DWARFContext::create(*ErrOrSections, 8);
2536 DWARFContext::create(**Obj, nullptr, [&](Error E) {
2546 DWARFContext::create(**Obj, nullptr, [&](Error E) {
2605 DWARFContext::create(*ErrOrSections, 8);
2670 DWARFContext::create(*ErrOrSections, 8);
2727 DWARFContext::create(*ErrOrSections, 8);
2801 DWARFContext::create(*ErrOrSections, 8);
2851 DWARFContext::create(*ErrOrSections, 8);
2915 DWARFContext::create(*ErrOrSections, 8);
2982 DWARFContext::create(*ErrOrSections, 8);
unittests/DebugInfo/DWARF/DWARFDebugLineTest.cpp 65 return DWARFContext::create(**Obj);
262 const DWARFDebugLine::LineTable *Expected = *ExpectedLineTable;
273 const DWARFDebugLine::LineTable *Expected2 = *ExpectedLineTable2;
286 EXPECT_EQ(Expected, *ExpectedLineTable3);
293 EXPECT_EQ(Expected2, *ExpectedLineTable4);
479 EXPECT_EQ((*ExpectedLineTable)->Rows.size(), 6u);
481 EXPECT_EQ((*ExpectedLineTable)->Sequences.size(), 1u);
unittests/DebugInfo/GSYM/GSYMTest.cpp 1120 EXPECT_EQ(FI, *DecodedFI);
unittests/DebugInfo/MSF/MSFBuilderTest.cpp 91 auto &Msf = *ExpectedMsf;
112 auto &Msf = *ExpectedMsf;
116 MSFLayout &L1 = *ExpectedL1;
123 auto &Msf2 = *ExpectedMsf2;
133 MSFLayout &L2 = *ExpectedL2;
146 auto &Msf = *ExpectedMsf;
153 MSFLayout &L1 = *ExpectedL1;
163 auto &Msf = *ExpectedMsf;
185 auto &Msf = *ExpectedMsf;
206 auto &Msf = *ExpectedMsf;
227 auto &Msf = *ExpectedMsf;
247 auto &Msf = *ExpectedMsf;
260 auto &Msf = *ExpectedMsf;
281 auto &Msf = *ExpectedMsf;
293 MSFLayout &L = *ExpectedLayout;
312 auto &Msf = *ExpectedMsf;
320 MSFLayout &L = *ExpectedLayout;
333 auto &Msf = *ExpectedMsf;
342 MSFLayout &L = *ExpectedLayout;
351 auto &Msf = *ExpectedMsf;
360 MSFLayout &L = *ExpectedLayout;
368 auto &Msf = *ExpectedMsf;
380 MSFLayout &L = *ExpectedLayout;
381 auto BlocksRef = L.StreamMap[*SN];
383 EXPECT_EQ(StreamSize, L.StreamSizes[*SN]);
unittests/ExecutionEngine/JITLink/MachO_x86_64_Tests.cpp 43 **TR, [&](LinkGraph &G) { RunGraphTest(G, (*TR)->getDisassembler()); });
43 **TR, [&](LinkGraph &G) { RunGraphTest(G, (*TR)->getDisassembler()); });
unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp 30 auto &Resolved = *Result;
276 EXPECT_EQ((*Result)[Baz].getAddress(), FooSym.getAddress())
278 EXPECT_EQ((*Result)[Qux].getAddress(), QuxSym.getAddress())
291 EXPECT_EQ((*Result)[Bar].getAddress(), FooSym.getAddress())
293 EXPECT_EQ((*Result)[Baz].getAddress(), FooSym.getAddress())
1194 EXPECT_EQ((*Result)[Foo].getAddress(), FooSym.getAddress())
1196 EXPECT_EQ((*Result)[Bar].getAddress(), BarSym.getAddress())
unittests/ExecutionEngine/Orc/LazyCallThroughAndReexportsTest.cpp 61 auto CallThroughTrampoline = cantFail((*LCTM)->getCallThroughTrampoline(
unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp 53 EXPECT_EQ((*Result)[Foo].getAddress(), FooSym.getAddress())
55 EXPECT_EQ((*Result)[Bar].getAddress(), BarSym.getAddress())
106 EXPECT_EQ((*Result)[Foo].getAddress(), FooAddr) << "Wrong address for foo";
107 EXPECT_EQ((*Result)[Foo].getFlags(), FooSym.getFlags())
109 EXPECT_EQ((*Result)[Bar].getAddress(), BarAddr) << "Wrong address for bar";
110 EXPECT_EQ((*Result)[Bar].getFlags(), BarSym.getFlags())
unittests/ExecutionEngine/Orc/RPCUtilsTest.cpp 260 EXPECT_EQ(*Result, 42)
351 EXPECT_EQ(*Result, 42)
402 EXPECT_EQ(*Result, 42)
702 EXPECT_EQ(*ValOrErr, 42ULL)
777 A = *Result;
788 B = *Result;
799 C = *Result;
unittests/Object/MinidumpTest.cpp 39 const MinidumpFile &File = **ExpectedFile;
199 const MinidumpFile &File = **ExpectedFile;
229 const MinidumpFile &File = **ExpectedFile;
233 const SystemInfo &Info = *ExpectedInfo;
275 const MinidumpFile &File = **ExpectedFile;
349 const MinidumpFile &File = **ExpectedFile;
396 const MinidumpFile &File = **ExpectedFile;
449 const MinidumpFile &File = **ExpectedFile;
504 const MinidumpFile &File = **ExpectedFile;
589 const MinidumpFile &File = **ExpectedFile;
706 EXPECT_THAT(to_vector<3>(map_range(*ExpectedInfo,
753 const MinidumpFile &File = **ExpectedFile;
unittests/ObjectYAML/MinidumpYAMLTest.cpp 48 object::MinidumpFile &File = **ExpectedFile;
55 const SystemInfo &SysInfo = *ExpectedSysInfo;
81 object::MinidumpFile &File = **ExpectedFile;
102 object::MinidumpFile &File = **ExpectedFile;
108 const SystemInfo &SysInfo = *ExpectedSysInfo;
129 object::MinidumpFile &File = **ExpectedFile;
135 const SystemInfo &SysInfo = *ExpectedSysInfo;
161 object::MinidumpFile &File = **ExpectedFile;
170 const minidump::ExceptionStream &Stream = *ExpectedStream;
186 *ExpectedContext);
204 object::MinidumpFile &File = **ExpectedFile;
213 const minidump::ExceptionStream &Stream = *ExpectedStream;
227 *ExpectedContext);
260 object::MinidumpFile &File = **ExpectedFile;
269 const minidump::ExceptionStream &Stream = *ExpectedStream;
287 *ExpectedContext);
311 object::MinidumpFile &File = **ExpectedFile;
320 const minidump::ExceptionStream &Stream = *ExpectedStream;
337 *ExpectedContext);
unittests/Remarks/BitstreamRemarksParsingTest.cpp 31 EXPECT_TRUE(*MaybeParser != nullptr);
34 remarks::RemarkParser &Parser = **MaybeParser;
37 EXPECT_TRUE(*Remark != nullptr); // At least one remark.
39 FromYAMLRemark = std::move(*Remark);
55 (*BSSerializer)->emit(*FromYAMLRemark);
61 EXPECT_TRUE(*MaybeBSParser != nullptr);
64 remarks::RemarkParser &BSParser = **MaybeBSParser;
67 EXPECT_TRUE(*BSRemark != nullptr); // At least one remark.
69 FromBSRemark = std::move(*BSRemark);
162 EXPECT_TRUE(*MaybeParser != nullptr);
164 remarks::RemarkParser &Parser = **MaybeParser;
168 EXPECT_TRUE(*MaybeRemark != nullptr); // At least one remark.
170 const remarks::Remark &Remark = **MaybeRemark;
263 (*BSSerializer)->emit(ToSerializeRemark);
329 EXPECT_TRUE(*MaybeBSParser != nullptr);
331 remarks::RemarkParser &BSParser = **MaybeBSParser;
unittests/Remarks/BitstreamRemarksSerializerTest.cpp 50 std::move(*MaybeSerializer);
unittests/Remarks/RemarksStrTabParsingTest.cpp 29 EXPECT_EQ(*Result, "str1");
32 EXPECT_EQ(*Result, "str2");
35 EXPECT_EQ(*Result, "str3");
38 EXPECT_EQ(*Result, "str4");
unittests/Remarks/YAMLRemarksParsingTest.cpp 20 EXPECT_TRUE(*MaybeParser != nullptr);
22 remarks::RemarkParser &Parser = **MaybeParser;
25 EXPECT_TRUE(*Remark != nullptr); // At least one remark.
36 EXPECT_TRUE(*MaybeParser != nullptr);
38 remarks::RemarkParser &Parser = **MaybeParser;
41 EXPECT_TRUE(*Remark != nullptr); // At least one remark.
53 EXPECT_TRUE(*MaybeParser != nullptr);
55 remarks::RemarkParser &Parser = **MaybeParser;
404 EXPECT_TRUE(*MaybeParser != nullptr);
406 remarks::RemarkParser &Parser = **MaybeParser;
410 EXPECT_TRUE(*MaybeRemark != nullptr); // At least one remark.
412 const remarks::Remark &Remark = **MaybeRemark;
576 EXPECT_TRUE(*MaybeParser != nullptr);
578 remarks::RemarkParser &Parser = **MaybeParser;
582 EXPECT_TRUE(*MaybeRemark != nullptr); // At least one remark.
584 const remarks::Remark &Remark = **MaybeRemark;
652 EXPECT_TRUE(*MaybeParser != nullptr);
654 remarks::RemarkParser &Parser = **MaybeParser;
unittests/Remarks/YAMLRemarksSerializerTest.cpp 39 std::unique_ptr<remarks::RemarkSerializer> S = std::move(*MaybeS);
unittests/Support/ErrorTest.cpp 539 EXPECT_EQ(*A, 7) << "Incorrect Expected non-error value";
548 int &C = *B;
568 EXPECT_DEATH({ Expected<int> A = 7; *A; },
600 EXPECT_DEATH(*A, "Expected<T> must be checked before access or destruction.")
644 EXPECT_EQ(*ValOrErr, 42)
686 EXPECT_EQ(*ValOrErr, 42)
unittests/Support/FileCheckTest.cpp 25 EXPECT_EQ(10U, *Value);
31 EXPECT_EQ(std::numeric_limits<uint64_t>::max(), *Value);
81 EXPECT_EQ(42U, *EvalResult);
106 EXPECT_EQ(60U, *Value);
429 EXPECT_EQ("42", *SubstValue);
432 EXPECT_EQ("10", *SubstValue);
450 EXPECT_EQ("BAR", *SubstValue);
524 EXPECT_EQ(*LocalVar, "FOO");
528 Expected<uint64_t> ExpressionVal = (*ExpressionAST)->eval();
530 EXPECT_EQ(*ExpressionVal, 18U);
536 ExpressionVal = (*ExpressionAST)->eval();
538 EXPECT_EQ(*ExpressionVal, 20U);
540 EXPECT_EQ(*EmptyVar, "");
551 EXPECT_TRUE(errorToBool((*ExpressionAST)->eval().takeError()));
557 ExpressionVal = (*ExpressionAST)->eval();
563 ExpressionVal = (*ExpressionAST)->eval();
579 EXPECT_EQ(*GlobalVar, "BAR");
585 ExpressionVal = (*ExpressionAST)->eval();
587 EXPECT_EQ(*ExpressionVal, 36U);
597 ExpressionVal = (*ExpressionAST)->eval();
599 EXPECT_EQ(*ExpressionVal, 36U);
unittests/Support/FileOutputBufferTest.cpp 48 std::unique_ptr<FileOutputBuffer> &Buffer = *BufferOrErr;
70 std::unique_ptr<FileOutputBuffer> &Buffer2 = *Buffer2OrErr;
87 std::unique_ptr<FileOutputBuffer> &Buffer = *BufferOrErr;
108 std::unique_ptr<FileOutputBuffer> &Buffer = *BufferOrErr;
unittests/Support/JSONTest.cpp 127 EXPECT_EQ(*E, Expected);
128 EXPECT_EQ(sp(*E), sp(Expected));
322 EXPECT_EQ(T.Val, *Doc) << T.Desc;
323 EXPECT_EQ(T.Str, s(*Doc)) << T.Desc;
unittests/Support/MemoryBufferTest.cpp 113 make_scope_exit([&] { ASSERT_NO_ERROR(sys::fs::closeFile(*File)); });
114 ErrorOr<OwningBuffer> MB = MemoryBuffer::getOpenFile(*File, TestPath, 6);
123 make_scope_exit([&] { ASSERT_NO_ERROR(sys::fs::closeFile(*File)); });
124 ASSERT_ERROR(MemoryBuffer::getOpenFile(*File, TestPath, 6).getError());
unittests/Support/Path.cpp 591 fs::TempFile File = std::move(*TempFileOrError);
603 fs::TempFile File = std::move(*TempFileOrError);
707 TempFiles.push_back(std::move(*T));
1526 auto Close = make_scope_exit([&] { fs::closeFile(*FD); });
1528 *FD, makeMutableArrayRef(&*Buf.begin(), Buf.size())))
1529 return Buf.substr(0, *BytesRead);
1543 auto Close = make_scope_exit([&] { fs::closeFile(*FD); });
1548 *FD, makeMutableArrayRef(&*Buf.begin(), Buf.size()), Offset))
1549 return Buf.substr(0, *BytesRead);
unittests/Support/TarWriterTest.cpp 50 std::unique_ptr<TarWriter> Tar = std::move(*TarOrErr);
131 std::unique_ptr<TarWriter> Tar = std::move(*TarOrErr);
149 std::unique_ptr<TarWriter> Tar = std::move(*TarOrErr);
168 std::unique_ptr<TarWriter> Tar = std::move(*TarOrErr);
unittests/tools/llvm-exegesis/X86/SnippetFileTest.cpp 79 ASSERT_THAT(*Snippets, SizeIs(1));
80 const auto &Snippet = (*Snippets)[0];