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

References

gen/lib/Target/AArch64/AArch64GenDAGISel.inc
114927     return Align && *Align >= 4 && G->getOffset() % 4 == 0;
gen/tools/clang/include/clang/AST/Attrs.inc
  339       Out = *R;
 2293       Out = *R;
 3168       Out = *R;
 3805       Out = *R;
 4386       Out = *R;
 4618       Out = *R;
 6111       Out = *R;
 6147       Out = *R;
 6987       Out = *R;
 8391       Out = *R;
 8621       Out = *R;
 8801       Out = *R;
 8825       Out = *R;
 8991       Out = *R;
 9014       Out = *R;
 9037       Out = *R;
10064       Out = *R;
11339       Out = *R;
11524       Out = *R;
12251       Out = *R;
12743       Out = *R;
13161       Out = *R;
13862       Out = *R;
14380       Out = *R;
14943       Out = *R;
include/llvm/ADT/BreadthFirstIterator.h
   85     while (*ChildIt != GT::child_end(Node)) {
   86       NodeRef Next = *(*ChildIt)++;
include/llvm/ADT/DepthFirstIterator.h
  130       while (*Opt != GT::child_end(Node)) {
  131         NodeRef Next = *(*Opt)++;
include/llvm/ADT/StringSwitch.h
  183       return std::move(*Result);
  190     return std::move(*Result);
include/llvm/Analysis/BasicAliasAnalysis.h
  270     AAR.emplace(createLegacyPMAAResults(P, F, *BAR));
  271     return *AAR;
include/llvm/Analysis/DemandedBits.h
  100   DemandedBits &getDemandedBits() { return *DB; }
include/llvm/Analysis/LazyCallGraph.h
  378         return *Edges;
include/llvm/Analysis/MemoryDependenceAnalysis.h
  548   MemoryDependenceResults &getMemDep() { return *MemDep; }
include/llvm/Analysis/ModuleSummaryAnalysis.h
   63   ModuleSummaryIndex &getIndex() { return *Index; }
include/llvm/Analysis/ObjCARCAnalysisUtils.h
  281       return *ImpreciseReleaseMDKind;
  286       return *CopyOnEscapeMDKind;
  291       return *NoObjCARCExceptionsMDKind;
include/llvm/Analysis/VectorUtils.h
  412     int32_t Key = *MaybeKey;
  432       if (*MaybeLargestIndex >= static_cast<int64_t>(Factor))
include/llvm/CodeGen/GlobalISel/MIPatternMatch.h
   48       CR = *MaybeCst;
include/llvm/DebugInfo/CodeView/TypeCollection.h
   38       TypeIndex N = *Next;
include/llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h
   39         this->ByteSize.ByteSize = *ByteSize;
include/llvm/DebugInfo/DWARF/DWARFFormValue.h
  176       return *S;
include/llvm/DebugInfo/DWARF/DWARFUnit.h
   89     assert((!DWOId || *DWOId == Id) && "setting DWOId to a different value");
include/llvm/DebugInfo/PDB/Native/HashTable.h
  247     return const_iterator(*this, *FirstUnused, true);
  290     B.first = InternalKey ? *InternalKey : Traits.lookupKeyToStorageKey(K);
include/llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h
  569     RemoteCompileCallbackManager &Mgr = *CallbackManager;
include/llvm/IR/DataLayout.h
  510     return Alignment ? *Alignment : Align(getABITypeAlignment(Ty));
include/llvm/IR/DebugInfoMetadata.h
  509                    Source ? Optional<MDString *>(getCanonicalMDString(Context, *Source)) : None,
 2002     return cloneWithDiscriminator(*Encoded);
 2014     return cloneWithDiscriminator(*D);
include/llvm/IR/ValueMap.h
  118     return *MDMap;
include/llvm/MC/MCSubtargetInfo.h
  252       return *Size;
include/llvm/Remarks/BitstreamRemarkSerializer.h
  179     Helper = &*TmpHelper;
include/llvm/Support/Alignment.h
  154   return SizeInBytes % (*Lhs).value() == 0;
  226   return A && B ? commonAlignment(*A, *B) : A ? A : B;
  226   return A && B ? commonAlignment(*A, *B) : A ? A : B;
  232   return MaybeAlign(MinAlign((*A).value(), Offset));
  279   return Lhs ? (*Lhs).value() == Rhs : Rhs == 0;
  282   return Lhs ? (*Lhs).value() != Rhs : Rhs != 0;
  287   return (*Lhs).value() <= Rhs;
  292   return (*Lhs).value() >= Rhs;
  297   return (*Lhs).value() < Rhs;
  302   return (*Lhs).value() > Rhs;
  328   return Lhs.value() == (*Rhs).value();
  332   return Lhs.value() != (*Rhs).value();
  336   return Lhs.value() <= (*Rhs).value();
  340   return Lhs.value() >= (*Rhs).value();
  344   return Lhs.value() < (*Rhs).value();
  348   return Lhs.value() > (*Rhs).value();
  354   return Lhs && (*Lhs).value() == Rhs.value();
  358   return Lhs && (*Lhs).value() != Rhs.value();
  362   return Lhs && (*Lhs).value() <= Rhs.value();
  366   return Lhs && (*Lhs).value() >= Rhs.value();
  370   return Lhs && (*Lhs).value() < Rhs.value();
  374   return Lhs && (*Lhs).value() > Rhs.value();
  391   return Lhs && *Lhs > Rhs ? *Lhs : Rhs;
  391   return Lhs && *Lhs > Rhs ? *Lhs : Rhs;
  395   return Rhs && *Rhs > Lhs ? *Rhs : Lhs;
  395   return Rhs && *Rhs > Lhs ? *Rhs : Lhs;
include/llvm/Support/Allocator.h
  325     return *Out;
include/llvm/Support/BinaryStreamRef.h
   72       *Result.Length -= N;
   94     *Result.Length -= N;
include/llvm/Support/CheckedArithmetic.h
   77     return checkedAdd(*Product, C);
  106     return checkedAddUnsigned(*Product, C);
include/llvm/Support/JSON.h
  563     Out = *S;
  570     Out = *S;
  577     Out = *S;
  584     Out = *S;
  591     Out = *S;
include/llvm/Target/TargetMachine.h
  394     if (*CM == CodeModel::Tiny)
  396     if (*CM == CodeModel::Kernel)
  398     return *CM;
lib/Analysis/AliasAnalysisSummary.cpp
   92   return InstantiatedRelation{*From, *To, ERelation.Offset};
   92   return InstantiatedRelation{*From, *To, ERelation.Offset};
  100   return InstantiatedAttr{*Value, EAttr.Attr};
lib/Analysis/CFLAndersAliasAnalysis.cpp
  365     return InterfaceValue{*Index, IValue.DerefLevel};
  437           if (*Dst == *Src)
  437           if (*Dst == *Src)
  441             ExtRelations.push_back(ExternalRelation{*Dst, *Src, UnknownOffset});
  441             ExtRelations.push_back(ExternalRelation{*Dst, *Src, UnknownOffset});
  448                 ValueSummary::Record{*Dst, SrcIVal.DerefLevel});
  451                 ValueSummary::Record{*Dst, SrcIVal.DerefLevel});
  495         ExtAttributes.push_back(ExternalAttribute{*IVal, Attr});
  533   auto AttrsA = *MaybeAttrsA;
  534   auto AttrsB = *MaybeAttrsB;
  656       MemSet.insert(*FromNodeBelow, *ToNodeBelow)) {
  656       MemSet.insert(*FromNodeBelow, *ToNodeBelow)) {
  657     propagate(*FromNodeBelow, *ToNodeBelow,
  657     propagate(*FromNodeBelow, *ToNodeBelow,
  659     for (const auto &Mapping : ReachSet.reachableValueAliases(*FromNodeBelow)) {
  663           propagate(Src, *ToNodeBelow, ToState, ReachSet, WorkList);
  767         if (AttrMap.add(*DstBelow, DstAttr)) {
  768           NextList.push_back(*DstBelow);
  771         DstBelow = getNodeBelow(Graph, *DstBelow);
lib/Analysis/CFLSteensAliasAnalysis.cpp
  306   auto SetA = *MaybeA;
  307   auto SetB = *MaybeB;
lib/Analysis/CGSCCPassManager.cpp
  189         InnerAM->invalidate(C, *InnerPA);
  293       FAM->invalidate(F, *FunctionPA);
lib/Analysis/ConstantFolding.cpp
  989         NewIdxs.size() > *LastIRIndex) {
  991       for (unsigned I = 0; I <= *LastIRIndex; ++I)
lib/Analysis/InlineCost.cpp
  928     BlockFrequencyInfo *CallerBFI = GetBFI ? &((*GetBFI)(*Caller)) : nullptr;
lib/Analysis/InstructionSimplify.cpp
 3976     return *Imp ? TrueVal : FalseVal;
lib/Analysis/LazyCallGraph.cpp
  132   return *Edges;
lib/Analysis/LoopAnalysisManager.cpp
  116       InnerAM->invalidate(*L, *InnerPA);
lib/Analysis/LoopCacheAnalysis.cpp
  541         if ((HasTemporalReuse.hasValue() && *HasTemporalReuse) ||
  542             (HasSpacialReuse.hasValue() && *HasSpacialReuse)) {
lib/Analysis/MemorySSA.cpp
 2196       OS << " " << *AR;
 2236     OS << " " << *AR;
lib/Analysis/ProfileSummaryInfo.cpp
  319   return Count && isHotCount(*Count);
  325   return Count && isColdCount(*Count);
  332   return Count && isHotCountNthPercentile(PercentileCutoff, *Count);
  338   return C && isHotCount(*C);
  345     return isColdCount(*C);
lib/Analysis/ScalarEvolution.cpp
 5904         switch (*CastOp) {
 7215     return *MaybeEL;
 7648         (!PostShiftOpCode.hasValue() || *PostShiftOpCode == OpCodeOut);
 8500     return XW.slt(YW) ? *X : *Y;
 8500     return XW.slt(YW) ? *X : *Y;
 8504   return X.hasValue() ? *X : *Y;
 8504   return X.hasValue() ? *X : *Y;
 8549   std::tie(A, B, C, M, BitWidth) = *T;
 8555   ConstantInt *CX = ConstantInt::get(SE.getContext(), *X);
 8639     if (LeavesRange(*Min))
 8642     if (LeavesRange(*Max))
 8649   std::tie(A, B, C, M, BitWidth) = *T;
 9983   if (!LDiff || !RDiff || *LDiff != *RDiff)
 9983   if (!LDiff || !RDiff || *LDiff != *RDiff)
 9992     FoundRHSLimit = -(*RDiff);
 9995     FoundRHSLimit = APInt::getSignedMinValue(getTypeSizeInBits(RHS->getType())) - *RDiff;
10467   ConstantRange LHSRange = FoundLHSRange.add(ConstantRange(*Addend));
lib/Analysis/StratifiedSets.h
  565     auto *Info = *MaybeVal;
lib/Analysis/TargetLibraryInfo.cpp
 1593     return TargetLibraryInfo(*PresetInfoImpl);
lib/Analysis/TargetTransformInfo.cpp
  977     if (!NextLevelRD || !RD->hasSameData(*NextLevelRD))
 1110     if (!RDLevel || !RDLevel->hasSameData(*RD))
 1380   return *TTI;
lib/Analysis/ValueTracking.cpp
  942     if (!*ShifterOperandIsNonZero)
  964       if (*ShifterOperandIsNonZero)
 5777       OffsetVal += *Offset;
 5793       return -*Offset;
 5819   return *Offset2 - *Offset1;
 5819   return *Offset2 - *Offset1;
lib/Analysis/VectorUtils.cpp
  843       AccessStrideInfo[&I] = StrideDescriptor(Stride, Scev, Size, *Alignment);
lib/AsmParser/LLParser.cpp
 3611         if (*InRangeOp == 0)
 3614         --*InRangeOp;
 4073   assert(*Kind <= Result.Max && "Expected valid emission kind");
 4074   Result.assign(*Kind);
 4092   assert(((unsigned)*Kind) <= Result.Max && "Expected valid nameTable kind");
 4093   Result.assign((unsigned)*Kind);
 4329   Result.assign(*CSKind);
lib/BinaryFormat/AMDGPUMetadataVerifier.cpp
   57   if (Size && Array.size() != *Size)
lib/Bitcode/Reader/BitcodeAnalyzer.cpp
  544     BlockInfoStream.emplace(*BlockInfoBuffer);
  560     BitstreamCursor BlockInfoCursor(*BlockInfoStream);
  584         BlockInfo = std::move(*NewBlockInfo);
  652       O.OS << " (" << *BlockName << ")";
  715           O.OS << *CodeName << "\n";
  748     BlockInfo = std::move(*NewBlockInfo);
  767       O->OS << *BlockName;
  805           O->OS << *BlockName << ">\n";
  862         O->OS << *CodeName;
  906           Hasher.update(*CheckHash);
lib/Bitcode/Reader/BitcodeReader.cpp
 3050   BlockInfo = std::move(*NewBlockInfo);
lib/Bitcode/Writer/BitcodeWriter.cpp
 1633     Record.push_back(VE.getMetadataOrNullID(*Source));
 2463           Record.push_back((*Idx << 1) | GO->isInBounds());
 3995     SummaryToValueIdMap[S] = *ValueId;
 4011       NameVals.push_back(*ValueId);
 4019         NameVals.push_back(*RefValueId);
 4034     NameVals.push_back(*ValueId);
 4051       NameVals.push_back(*RefValueId);
 4100       NameVals.push_back(*CallValueId);
lib/CodeGen/AsmPrinter/AsmPrinter.cpp
  774     CommentOS << *Size << "-byte Reload\n";
  776     if (*Size)
  777       CommentOS << *Size << "-byte Folded Reload\n";
  779     CommentOS << *Size << "-byte Spill\n";
  781     if (*Size)
  782       CommentOS << *Size << "-byte Folded Spill\n";
 1363     Filename = *FilenameRef;
 1364     sys::fs::make_absolute(*Filename);
 1371       Filename ? RemarkSerializer.metaSerializer(OS, StringRef(*Filename))
lib/CodeGen/AsmPrinter/CodeViewDebug.cpp
  656     CVType Record = Table.getType(*B);
  658     Error E = codeview::visitTypeRecord(Record, *B, Pipeline);
  665     B = Table.getNext(*B);
 1236       if (canUseReferenceType(*Location))
 1240     } else if (needsReferenceType(*Location)) {
lib/CodeGen/AsmPrinter/DIE.cpp
  437     return *FixedSize;
lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp
  283             NVPTXAddressSpace ? *NVPTXAddressSpace : NVPTX_ADDR_global_space);
  680             NVPTXAddressSpace ? *NVPTXAddressSpace : NVPTX_ADDR_local_space);
  685             *DwarfExpr.TagOffset);
lib/CodeGen/AsmPrinter/DwarfUnit.cpp
  238   Die.addValue(DIEValueAllocator, Attribute, *Form, DIEInteger(Integer));
  250   Die.addValue(DIEValueAllocator, Attribute, *Form, DIEInteger(Integer));
lib/CodeGen/GlobalISel/CSEMIRBuilder.cpp
  102     B.addNodeIDFlag(*Flags);
lib/CodeGen/GlobalISel/GISelKnownBits.cpp
  146     Known.One = *CstVal;
lib/CodeGen/GlobalISel/MachineIRBuilder.cpp
 1179     MIB->setFlags(*Flags);
lib/CodeGen/GlobalISel/Utils.cpp
  273   APInt &Val = *MaybeVal;
  345     APInt C1(Ty.getSizeInBits(), *MaybeOp1Cst, true);
  346     APInt C2(Ty.getSizeInBits(), *MaybeOp2Cst, true);
  420     APInt C1(Ty.getSizeInBits(), *MaybeOp1Cst, true);
lib/CodeGen/ImplicitNullChecks.cpp
  403   auto DependenceItr = *DepResult.PotentialDependence;
lib/CodeGen/LiveDebugValues.cpp
  939       if (VL.Kind == VarLoc::SpillLocKind && VL.Loc.SpillLocation == *Loc) {
  982                VarLocIDs[ID].Loc.SpillLocation == *Loc) {
lib/CodeGen/MachineOperand.cpp
  433     OS << printReg(*Reg, TRI);
  456     MachineOperand::printIRSlotNumber(OS, *Slot);
lib/CodeGen/MachineSizeOpts.cpp
   33   return Count && PSI->isColdCount(*Count);
   42   return Count && PSI->isHotCountNthPercentile(PercentileCutoff, *Count);
lib/CodeGen/MachineTraceMetrics.cpp
  459       if (const MachineLoop *FromLoop = LB.Loops->getLoopFor(*From)) {
  461         if ((LB.Downward ? To : *From) == FromLoop->getHeader())
lib/CodeGen/ModuloSchedule.cpp
  874     } else if (*StaticallyGreater == false) {
 1485     MRI.constrainRegClass(R, MRI.getRegClass(*InitReg));
 1487       .addReg(InitReg.hasValue() ? *InitReg : undef(RC))
 1494     Phis[{LoopReg, *InitReg}] = R;
 1782     } else if (*StaticallyGreater == false) {
lib/CodeGen/PeepholeOptimizer.cpp
 1583         TII->commuteInstruction(*(RI.getMI()), false, (*CP).first,
 1584                                 (*CP).second);
lib/CodeGen/SelectionDAG/DAGCombiner.cpp
 6583   bool NeedsBswap = DAG.getDataLayout().isBigEndian() != *IsBigEndian;
 6714     ByteOffsetFromBase += MemoryByteOffset(*P);
 6740   if (MemoryByteOffset(*FirstByteProvider) != 0)
 6748   bool NeedsBswap = IsBigEndianTarget != *IsBigEndian;
20564       *MUC0.NumBytes == *MUC1.NumBytes && OrigAlignment0 > *MUC0.NumBytes) {
20564       *MUC0.NumBytes == *MUC1.NumBytes && OrigAlignment0 > *MUC0.NumBytes) {
20564       *MUC0.NumBytes == *MUC1.NumBytes && OrigAlignment0 > *MUC0.NumBytes) {
20570     if ((OffAlign0 + *MUC0.NumBytes) <= OffAlign1 ||
20571         (OffAlign1 + *MUC1.NumBytes) <= OffAlign0)
20587     int64_t Overlap0 = *MUC0.NumBytes + SrcValOffset0 - MinOffset;
20588     int64_t Overlap1 = *MUC1.NumBytes + SrcValOffset1 - MinOffset;
lib/CodeGen/SelectionDAG/FastISel.cpp
 1396               *Op, DI->getVariable(), Expr);
lib/CodeGen/SelectionDAG/SelectionDAG.cpp
 8062       Expr = *Fragment;
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
  310         Val = DAG.getNode(*AssertOp, DL, PartEVT, Val,
 1329           BitsToDescribe = *VarSize;
 1344           SDV = DAG.getVRegDbgValue(Var, *FragmentExpr, RegAndSize.first,
 5544                   RegAndSize.first, Variable, *FragmentExpr));
 5581               *Op, Variable, Expr));
lib/CodeGen/SelectionDAG/StatepointLowering.cpp
  179       if (MergedResult.hasValue() && *MergedResult != *SpillSlot)
  179       if (MergedResult.hasValue() && *MergedResult != *SpillSlot)
  246   auto SlotIt = find(StatepointSlots, *Index);
  267       Builder.DAG.getTargetFrameIndex(*Index, Builder.getFrameIndexTy());
 1001     assert(*IsManaged && "Non gc managed pointer relocated!");
 1019   unsigned Index = *DerivedPtrLocation;
lib/DebugInfo/CodeView/CVTypeVisitor.cpp
  161     CVType Type = Types.getType(*I);
  162     if (auto EC = visitTypeRecord(Type, *I))
  164     I = Types.getNext(*I);
lib/DebugInfo/CodeView/CodeViewRecordIO.cpp
   72       Min = (Min.hasValue()) ? std::min(*Min, *ThisMin) : *ThisMin;
   72       Min = (Min.hasValue()) ? std::min(*Min, *ThisMin) : *ThisMin;
   72       Min = (Min.hasValue()) ? std::min(*Min, *ThisMin) : *ThisMin;
   76   return *Min;
lib/DebugInfo/CodeView/ContinuationRecordBuilder.cpp
  174   RecordPrefix Prefix(getTypeLeafKind(*Kind));
lib/DebugInfo/CodeView/TypeRecordMapping.cpp
  375     MemberPointerInfo &M = *Record.MemberInfo;
lib/DebugInfo/CodeView/TypeStreamMerger.cpp
  241       LastError = joinErrors(std::move(*LastError), errorCorruptRecord());
  353     return std::move(*LastError);
lib/DebugInfo/DWARF/DWARFAbbreviationDeclaration.cpp
  101             FixedAttributeSize->NumBytes += *ByteSize;
  164     if (*MatchAttrIndex == AttrIndex) {
  176       Offset += *FixedSize;
  206     S = *FixedByteSize;
lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp
  190           StringRef Str = dwarf::AtomValueString(HdrData.Atoms[i].first, *Val);
  300     return dwarf::Tag(*Value);
  559   if (!Index || *Index >= NameIdx->getCUCount())
  561   return NameIdx->getCUOffset(*Index);
  675     W.printHex("Hash", *Hash);
  798   uint32_t Bucket = *Hash % Hdr.BucketCount;
  829   DataOffset = *Offset;
lib/DebugInfo/DWARF/DWARFContext.cpp
  371         U->getDIEForOffset(*DumpOffset)
  428       if (DumpOffset && Parser.getOffset() != *DumpOffset) {
  630         DWOCU->setDWOId(*DWOId);
  858   uint64_t stmtOffset = *Offset + U->getLineTableOffset();
 1004     uint64_t Size = *BaseSize;
 1012           Size *= *ElemCount;
 1019           Size *= *UpperBound - LowerBound + 1;
 1037         Local.FunctionName = *Name;
 1040         if (!Location->empty() && (*Location)[0] == DW_OP_fbreg)
 1051         Local.Name = *Name;
lib/DebugInfo/DWARF/DWARFDataExtractor.cpp
   30     R = E->Resolver(*E->Reloc2, E->SymbolValue2, R);
lib/DebugInfo/DWARF/DWARFDebugAbbrev.cpp
   92     if (!AbbrDecls.extract(*Data, &Offset))
  129     if (!AbbrDecls.extract(*Data, &Offset))
lib/DebugInfo/DWARF/DWARFDebugFrame.cpp
  427                   &Offset, *PersonalityEncoding,
  445               EndAugmentationOffset = Offset + *AugmentationLength;
  488           InitialLocation = *Val;
  492           AddressRange = *Val;
  546     if (auto *Entry = getEntryAtOffset(*Offset))
lib/DebugInfo/DWARF/DWARFDebugInfoEntry.cpp
   50     *OffsetPtr += *FixedSize;
   59       *OffsetPtr += *FixedSize;
lib/DebugInfo/DWARF/DWARFDebugLine.cpp
 1031     return StringRef(*source);
 1109         LineToUnit.insert(std::make_pair(*StmtOffset, &*CU));
 1113         LineToUnit.insert(std::make_pair(*StmtOffset, &*TU));
lib/DebugInfo/DWARF/DWARFDebugLoc.cpp
   75     if (auto *L = getLocationListAtOffset(*Offset))
  329     if (auto *L = getLocationListAtOffset(*Offset))
lib/DebugInfo/DWARF/DWARFDie.cpp
  165                    LanguageLowerBound(static_cast<dwarf::SourceLanguage>(*LC))))
  166             if (LB && *LB == *DefaultLB)
  166             if (LB && *LB == *DefaultLB)
  171         OS << '[' << (Count ? *Count : *UB - *DefaultLB + 1) << ']';
  171         OS << '[' << (Count ? *Count : *UB - *DefaultLB + 1) << ']';
  171         OS << '[' << (Count ? *Count : *UB - *DefaultLB + 1) << ']';
  175           OS << *LB;
  181             OS << *LB + *Count;
  181             OS << *LB + *Count;
  183             OS << "? + " << *Count;
  185           OS << *UB + 1;
  298     Name = AttributeValueString(Attr, *Val);
  335       dumpApplePropertyAttribute(OS, *OptVal);
  344             dwarf::DW_FORM_sec_offset, *RangeListOffset);
  425     return getAttributeValueAsReferencedDie(*F);
  452       return LowPC + *Offset;
  466     HighPC = *HighPcAddr;
lib/DebugInfo/DWARF/DWARFExpression.cpp
  222     if (const char *RegName = MRI->getName(*LLVMRegNum)) {
lib/DebugInfo/DWARF/DWARFFormValue.cpp
  173         *OffsetPtr += *FixedSize;
  412       dumpSectionedAddress(AddrOS, DumpOpts, *A);
  608     Offset = *StrOffset;
lib/DebugInfo/DWARF/DWARFUnit.cpp
  428     Header.setDWOId(*DWOId);
  508   if (sys::path::is_relative(*DWOFileName) && CompilationDir &&
  509       *CompilationDir) {
  510     sys::path::append(AbsolutePath, *CompilationDir);
  512   sys::path::append(AbsolutePath, *DWOFileName);
  520   DWARFCompileUnit *DWOCU = DWOContext->getDWOCompileUnitForHash(*DWOId);
  541     DWO->setRangesSection(RangeSection, DWORangesBase ? *DWORangesBase : 0);
  578     return findRnglistFromOffset(*Offset + RangeSectionBase);
  867     Offset = *OptOffset;
lib/DebugInfo/DWARF/DWARFVerifier.cpp
  454       if (*SectionOffset >= DObj.getRangesSection().Data.size())
  463       if (*SectionOffset >= DObj.getLineSection().Data.size())
  465                     llvm::formatv("{0:x8}", *SectionOffset));
  484       VerifyLocationExpr(*Expr);
  488         if (auto LocList = DebugLoc->getLocationListAtOffset(*LocOffset))
  559         ReferenceToDIEOffsets[*RefVal].insert(Die.getOffset());
  570       if (*RefVal >= DieCU->getInfoSection().Data.size()) {
  578         ReferenceToDIEOffsets[*RefVal].insert(Die.getOffset());
  586     if (SecOffset && *SecOffset >= DObj.getStrSection().size()) {
  667     const uint64_t LineTableOffset = *StmtSectionOffset;
 1298     if (ContainsInterestingOperators(*Expr))
 1304               DebugLoc->getLocationListAtOffset(*Offset)) {
lib/DebugInfo/GSYM/GsymReader.cpp
  254     auto ExpectedFI = FunctionInfo::decode(Data, *OptAddr);
lib/DebugInfo/PDB/Native/DbiStreamBuilder.cpp
  266   H->VersionHeader = *VerHeader;
lib/DebugInfo/PDB/Native/NativeEnumTypes.cpp
   29     CVType CVT = Types.getType(*TI);
   34         Matches.push_back(*TI);
   43           Matches.push_back(*TI);
   46     TI = Types.getNext(*TI);
lib/DebugInfo/PDB/Native/NativeTypeEnum.cpp
   71     CVType FieldList = Types.getType(*ContinuationIndex);
lib/DebugInfo/PDB/Native/PDBFileBuilder.cpp
  353     H->Signature = Sig.hasValue() ? *Sig : time(nullptr);
lib/DebugInfo/PDB/Native/TpiStreamBuilder.cpp
   59     TypeHashes.push_back(*Hash);
lib/ExecutionEngine/ExecutionEngineBindings.cpp
  204     builder.setCodeModel(*CM);
lib/ExecutionEngine/JITLink/MachOLinkGraphBuilder.cpp
  251         dbgs() << *Name;
  276         &createNormalizedSymbol(*Name, Value, Type, Sect, Desc,
  277                                 getLinkage(Type), getScope(*Name, Type));
  316             *NSym.Name, NSym.S, getCommonSection(), NSym.Value, 0,
  324         NSym.GraphSymbol = &G->addExternalSymbol(*NSym.Name, 0);
  332           *NSym.Name, NSym.Value, 0, Linkage::Strong, Scope::Default,
  341           (NSym.Name ? ("\"" + *NSym.Name + "\"") : Twine("<anon>")) +
  346           (NSym.Name ? ("\"" + *NSym.Name + "\"") : Twine("<anon>")) +
  352           (NSym.Name ? ("\"" + *NSym.Name + "\"") : Twine("<anon>")) +
  500                 ? G->addDefinedSymbol(B, NSym.Value - BlockStart, *NSym.Name,
  509             SymEnd = *LastCanonicalAddr;
lib/ExecutionEngine/Orc/CompileOnDemandLayer.cpp
  296         expandPartition(*GVsToExtract);
lib/ExecutionEngine/Orc/LLJIT.cpp
  121     auto CompileFunction = createCompileFunction(S, std::move(*S.JTMB));
lib/IR/AsmWriter.cpp
 1521         ++*InRangeOp;
 1525       if (InRangeOp && unsigned(OI - CE->op_begin()) == *InRangeOp)
 1691   if (Default && Value == *Default)
 4221     SlotTable = &*LocalST;
lib/IR/Attributes.cpp
  454       Result += utostr(*NumElems);
 1524   assert(*Align <= 0x40000000 && "Alignment too large.");
 1536   assert(*Align <= 0x100 && "Alignment too large.");
lib/IR/ConstantFold.cpp
 1172           if (GVAlign && *GVAlign > 1) {
 1174             unsigned SrcWidth = std::min(DstWidth, Log2(*GVAlign));
 2291         if (IRIndex && *IRIndex == CE->getNumOperands() - 2 && !Idx0->isNullValue())
 2347     if (InRangeIndex && i == *InRangeIndex + 1) {
lib/IR/Constants.cpp
 2056   if (InRangeIndex && *InRangeIndex < 63)
 2057     SubClassOptionalData |= (*InRangeIndex + 1) << 1;
lib/IR/DebugInfoMetadata.cpp
  415   auto *&CT = (*Context.pImpl->DITypeMap)[&Identifier];
  450   auto *&CT = (*Context.pImpl->DITypeMap)[&Identifier];
  506   assert((!Source || isCanonical(*Source)) && "Expected canonical MDString");
lib/IR/Instructions.cpp
 1250   assert((!Align || *Align <= MaximumAlignment) &&
 1341   assert((!Align || *Align <= MaximumAlignment) &&
 1420   assert((!Align || *Align <= MaximumAlignment) &&
 3915   return MDBuilder(SI.getParent()->getContext()).createBranchWeights(*Weights);
 3957   if (!Weights && W && *W) {
 3960     Weights.getValue()[SI.getNumSuccessors() - 1] = *W;
 3963     Weights.getValue().push_back(W ? *W : 0);
 3991   if (!Weights && *W)
 3996     if (*W != OldW) {
 3998       OldW = *W;
lib/IR/Module.cpp
  563     Entries.push_back(*Minor);
  565       Entries.push_back(*Subminor);
  588   VersionTuple Result = VersionTuple(*Major);
  590     Result = VersionTuple(*Major, *Minor);
  590     Result = VersionTuple(*Major, *Minor);
  592       Result = VersionTuple(*Major, *Minor, *Subminor);
  592       Result = VersionTuple(*Major, *Minor, *Subminor);
  592       Result = VersionTuple(*Major, *Minor, *Subminor);
lib/IR/PassManager.cpp
   78       InnerAM->invalidate(F, *FunctionPA);
lib/IR/Verifier.cpp
 1293       verifyFragmentExpression(*GVE.getVariable(), *Fragment, &GVE);
 1842     if (Args.second && !CheckParam("number of elements", *Args.second))
 5010   verifyFragmentExpression(*V, *Fragment, &I);
 5025   AssertDI(FragSize + FragOffset <= *VarSize,
 5027   AssertDI(FragSize != *VarSize, "fragment covers entire variable", Desc, &V);
lib/LTO/LTO.cpp
 1140               Err = joinErrors(std::move(*Err), std::move(E));
 1153       return std::move(*Err);
lib/LTO/LTOBackend.cpp
  137     RelocModel = *Conf.RelocModel;
  144     CodeModel = *Conf.CodeModel;
lib/Linker/IRMover.cpp
  537   ~IRLinker() { SharedMDs = std::move(*ValueMap.getMDMap()); }
 1442       return std::move(*FoundError);
lib/MC/MCAsmStreamer.cpp
  542     OS << ", " << *Minor;
  544       OS << ", " << *Subminor;
 1237     PrintQuotedString(*Source, OS);
 1539       InstPrinter->printRegName(OS, *LLVMRegister);
lib/MC/MCObjectStreamer.cpp
  101     EmitIntValue(*Diff, Size);
  110     EmitULEB128IntValue(*Diff);
  634   MCFixupKind Kind = *MaybeKind;
lib/MC/MCRegisterInfo.cpp
  105     return getDwarfRegNum(*LRegNum, false);
lib/Object/Minidump.cpp
   62       getDataSliceAs<minidump::MemoryInfoListHeader>(*Stream, 0, 1);
   67       getDataSlice(*Stream, H.SizeOfHeader, H.SizeOfEntry * H.NumberOfEntries);
   79   auto ExpectedSize = getDataSliceAs<support::ulittle32_t>(*Stream, 0, 1);
   92   return getDataSliceAs<T>(*Stream, ListOffset, ListSize);
lib/ObjectYAML/COFFEmitter.cpp
  249         S.SectionData = CodeViewYAML::toDebugH(*S.DebugH, CP.Allocator);
lib/ObjectYAML/ELFEmitter.cpp
  273       Doc.Header.SHEntSize ? (uint16_t)*Doc.Header.SHEntSize : sizeof(Elf_Shdr);
  279       Doc.Header.SHOff ? typename ELFT::uint(*Doc.Header.SHOff) : SHOff;
  281       Doc.Header.SHNum ? (uint16_t)*Doc.Header.SHNum : Doc.Sections.size();
  282   Header.e_shstrndx = Doc.Header.SHStrNdx ? (uint16_t)*Doc.Header.SHStrNdx
  356       Header.sh_name = *YAMLSec->ShName;
  358       Header.sh_offset = *YAMLSec->ShOffset;
  360       Header.sh_size = *YAMLSec->ShSize;
  401       SHeader.sh_flags = *Sec->Flags;
  412           SHeader.sh_size = *RawSec->Size;
  414           SHeader.sh_info = *RawSec->Info;
  417         SHeader.sh_entsize = *Sec->EntSize;
  457         SHeader.sh_name = *Sec->ShName;
  459         SHeader.sh_offset = *Sec->ShOffset;
  461         SHeader.sh_size = *Sec->ShSize;
  531     Symbols = *Doc.Symbols;
  575     SHeader.sh_flags = *YAMLSec->Flags;
  581   SHeader.sh_info = (RawSec && RawSec->Info) ? (unsigned)(*RawSec->Info)
  584                            ? (uint64_t)(*YAMLSec->EntSize)
  624     SHeader.sh_entsize = *YAMLSec->EntSize;
  627     SHeader.sh_info = *RawSec->Info;
  630     SHeader.sh_flags = *YAMLSec->Flags;
  664       PHeader.p_offset = *YamlPhdr.Offset;
  689     PHeader.p_filesz = YamlPhdr.FileSize ? uint64_t(*YamlPhdr.FileSize)
  691     PHeader.p_memsz = YamlPhdr.MemSize ? uint64_t(*YamlPhdr.MemSize)
  695       PHeader.p_align = *YamlPhdr.Align;
 1119     Build(*Doc.Symbols, SymN2I);
 1126     for (const ELFYAML::Symbol &Sym : *Doc.Symbols)
lib/ObjectYAML/ELFYAML.cpp
  878       if ((*Original & FlagValue) != FlagValue)
  880       *Original &= ~FlagValue;
  884     if (*Original != 0) {
  885       UnknownFlagsHolder = std::to_string(*Original);
  914     for (StOtherPiece &Val : *Other)
lib/ObjectYAML/MachOEmitter.cpp
  304           yaml::BinaryRef Content = *Sec.content;
lib/Passes/PassBuilder.cpp
 1844       MPM.addPass(createRepeatedPass(*Count, std::move(NestedMPM)));
 1964       CGPM.addPass(createRepeatedPass(*Count, std::move(NestedCGPM)));
 1973           createDevirtSCCRepeatedPass(std::move(NestedCGPM), *MaxRepetitions));
 2049       FPM.addPass(createRepeatedPass(*Count, std::move(NestedFPM)));
 2120       LPM.addPass(createRepeatedPass(*Count, std::move(NestedLPM)));
 2273       Pipeline = {{"cgscc", std::move(*Pipeline)}};
 2276       Pipeline = {{"function", std::move(*Pipeline)}};
 2278       Pipeline = {{"function", {{"loop", std::move(*Pipeline)}}}};
 2281         if (C(MPM, *Pipeline, VerifyEachPass, DebugLogging))
 2295           parseModulePassPipeline(MPM, *Pipeline, VerifyEachPass, DebugLogging))
 2319           parseCGSCCPassPipeline(CGPM, *Pipeline, VerifyEachPass, DebugLogging))
 2343   if (auto Err = parseFunctionPassPipeline(FPM, *Pipeline, VerifyEachPass,
 2360           parseLoopPassPipeline(CGPM, *Pipeline, VerifyEachPass, DebugLogging))
lib/ProfileData/Coverage/CoverageMapping.cpp
  426       assert((!Loc || CompletedRegion->endLoc() <= *Loc) &&
  433       if (Loc && CompletedSegmentLoc == *Loc)
  450     if (FirstCompletedRegion && Last->endLoc() != *Loc) {
  455     } else if (!FirstCompletedRegion && (!Loc || *Loc != Last->endLoc())) {
  639   if (I && SourceFile == Function.Filenames[*I])
  663         if (MainFileID && isExpansion(CR, *MainFileID))
  686     InstantiationSetCollector.insert(Function, *MainFileID);
  705   CoverageData FunctionCoverage(Function.Filenames[*MainFileID]);
  708     if (CR.FileID == *MainFileID) {
  710       if (isExpansion(CR, *MainFileID))
lib/Remarks/BitstreamRemarkParser.cpp
  243   BlockInfo = **MaybeBlockInfo;
  320       StrTab ? std::make_unique<BitstreamRemarkParser>(Buf, std::move(*StrTab))
  324     Parser->ExternalFilePrependPath = *ExternalFilePrependPath;
  369     ContainerVersion = *Version;
  377     if (*Type > static_cast<uint8_t>(BitstreamRemarkContainerType::Last))
  382     ContainerType = static_cast<BitstreamRemarkContainerType>(*Type);
  398   P.StrTab.emplace(*StrTabBuf);
  408   P.RemarkVersion = *RemarkVersion;
  420   sys::path::append(FullPath, *ExternalFilePath);
  508   if (*Helper.Type > static_cast<uint8_t>(Type::Last))
  513   R.RemarkType = static_cast<Type>(*Helper.Type);
  520   if (Expected<StringRef> RemarkName = (*StrTab)[*Helper.RemarkNameIdx])
  520   if (Expected<StringRef> RemarkName = (*StrTab)[*Helper.RemarkNameIdx])
  530   if (Expected<StringRef> PassName = (*StrTab)[*Helper.PassNameIdx])
  530   if (Expected<StringRef> PassName = (*StrTab)[*Helper.PassNameIdx])
  539   if (Expected<StringRef> FunctionName = (*StrTab)[*Helper.FunctionNameIdx])
  539   if (Expected<StringRef> FunctionName = (*StrTab)[*Helper.FunctionNameIdx])
  545     Expected<StringRef> SourceFileName = (*StrTab)[*Helper.SourceFileNameIdx];
  545     Expected<StringRef> SourceFileName = (*StrTab)[*Helper.SourceFileNameIdx];
  550     R.Loc->SourceLine = *Helper.SourceLine;
  551     R.Loc->SourceColumn = *Helper.SourceColumn;
  555     R.Hotness = *Helper.Hotness;
  560   for (const BitstreamRemarkParserHelper::Argument &Arg : *Helper.Args) {
  574     if (Expected<StringRef> Key = (*StrTab)[*Arg.KeyIdx])
  579     if (Expected<StringRef> Value = (*StrTab)[*Arg.ValueIdx])
  586               (*StrTab)[*Arg.SourceFileNameIdx]) {
lib/Remarks/BitstreamRemarkSerializer.cpp
  248     assert(StrTab != None && *StrTab != nullptr);
  249     emitMetaStrTab(**StrTab);
  251     emitMetaExternalFile(*Filename);
  255     emitMetaRemarkVersion(*RemarkVersion);
  259     emitMetaRemarkVersion(*RemarkVersion);
  260     assert(StrTab != None && *StrTab != nullptr);
  261     emitMetaStrTab(**StrTab);
  292     R.push_back(*Hotness);
  356         IsStandalone ? &*StrTab : Optional<const StringTable *>(None));
  363   Helper.emitRemarkBlock(Remark, *StrTab);
  378       &*StrTab, ExternalFilename);
lib/Remarks/RemarkParser.cpp
  118             StrTab ? createRemarkParser(ParserFormat, Buf, std::move(*StrTab))
lib/Remarks/YAMLRemarkParser.cpp
  146         FullPath = *ExternalFilePrependPath;
  163           ? std::make_unique<YAMLStrTabRemarkParser>(Buf, std::move(*StrTab))
  360   return RemarkLocation{*File, *Line, *Column};
  360   return RemarkLocation{*File, *Line, *Column};
  360   return RemarkLocation{*File, *Line, *Column};
  411   return Argument{*KeyStr, *ValueStr, Loc};
  411   return Argument{*KeyStr, *ValueStr, Loc};
  442   if (Expected<StringRef> Str = (*StrTab)[StrID])
lib/Remarks/YAMLRemarkSerializer.cpp
   63       StringTable &StrTab = *Serializer->StrTab;
   88       StringTable &StrTab = *Serializer->StrTab;
  143       StringTable &StrTab = *Serializer->StrTab;
  204                                                     *StrTab);
  223   uint64_t StrTabSize = StrTab ? (*StrTab)->SerializedSize : 0;
  231     (*StrTab)->serialize(OS);
  248     emitExternalFile(OS, *ExternalFilename);
  256     emitExternalFile(OS, *ExternalFilename);
lib/Support/CachePruning.cpp
  189       if (TimeStampAge <= *Policy.Interval) {
lib/Support/CommandLine.cpp
 1215   TokenizeGNUCommandLine(*envValue, Saver, newArgv);
 1233       TokenizeGNUCommandLine(*EnvValue, Saver, NewArgv);
lib/Support/DJB.cpp
   73     return *Result;
lib/Support/FileCheck.cpp
   31     return *Value;
  178   if (DefLineNumber && LineNumber && *DefLineNumber == *LineNumber)
  178   if (DefLineNumber && LineNumber && *DefLineNumber == *LineNumber)
  505           DefName = (*DefinedNumericVariable)->getName();
  520               *DefinedNumericVariable, CurParen};
  527               *DefinedNumericVariable;
 1854       (*DefinedNumericVariable)->setValue(*Value);
 1857       GlobalNumericVariableTable[(*DefinedNumericVariable)->getName()] =
 1858           *DefinedNumericVariable;
lib/Support/FormatVariadic.cpp
   44       Where = *Loc;
   47       Where = *Loc;
  134       return std::make_pair(*RI, Right);
lib/Support/JSON.cpp
  227     return std::move(*Err);
lib/Support/LockFileManager.cpp
  327     if (!processStillExecuting((*Owner).first, (*Owner).second))
  327     if (!processStillExecuting((*Owner).first, (*Owner).second))
lib/Support/SymbolRemappingReader.cpp
   60     switch (Canonicalizer.addEquivalence(*FragmentKind, Parts[1], Parts[2])) {
lib/Support/Unix/Program.inc
  104     File = *Path;
  195     EnvVector = toNullTerminatedCStringArray(*Env, Saver);
lib/Support/Unix/Threading.inc
   77     if ((errnum = ::pthread_attr_setstacksize(&Attr, *StackSizeInBytes)) != 0) {
lib/Support/VersionTuple.cpp
   30     Out << '.' << *Minor;
   32     Out << '.' << *Subminor;
   34     Out << '.' << *Build;
lib/Target/AArch64/AArch64FalkorHWPFFix.cpp
  684       Optional<unsigned> Tag = getTag(TRI, MI, *LInfo);
  687       TagMap[*Tag].push_back(&MI);
  724       LoadInfo LdI = *OptLdI;
  728       auto &OldCollisions = TagMap[*OptOldTag];
lib/Target/AArch64/AArch64InstrInfo.cpp
 3425       !AArch64InstrInfo::getMemOpInfo(*UnscaledOp, Scale, Width, MinOff, MaxOff))
 3446     *OutUnscaledOp = *UnscaledOp;
lib/Target/AArch64/AArch64InstructionSelector.cpp
 1224   for (auto &RenderFn : *Imm1Fn)
 1226   for (auto &RenderFn : *Imm2Fn)
 1770         int64_t Imm = *COff;
 1791       if (*CVal == 0 && Opcode == TargetOpcode::G_STORE) {
 2838     auto Copy = MIRBuilder.buildInstr(TargetOpcode::COPY, {*DstReg}, {})
 2840     RBI.constrainGenericRegister(*DstReg, *DstRC, MRI);
 2856       MIRBuilder.buildInstr(CopyOpc, {*DstReg}, {InsertReg}).addImm(LaneIdx);
 2860   RBI.constrainGenericRegister(*DstReg, *DstRC, MRI);
 3159     for (auto &RenderFn : *ImmFns)
 3185     for (auto &RenderFn : *ImmFns)
 3260     for (auto &RenderFn : *ImmFns)
 3323           .buildInstr(InsertOpc, {*Dst}, {WidenedOp1->getOperand(0).getReg()})
 3759     InsElt = MIRBuilder.buildInstr(Opc, {*DstReg}, {SrcReg})
 3764     InsElt = MIRBuilder.buildInstr(Opc, {*DstReg}, {SrcReg})
 4038   if (MaybeImmed == None || *MaybeImmed > 31)
 4040   uint64_t Enc = (32 - *MaybeImmed) & 0x1f;
 4047   if (MaybeImmed == None || *MaybeImmed > 31)
 4049   uint64_t Enc = 31 - *MaybeImmed;
 4056   if (MaybeImmed == None || *MaybeImmed > 63)
 4058   uint64_t Enc = (64 - *MaybeImmed) & 0x3f;
 4065   if (MaybeImmed == None || *MaybeImmed > 63)
 4067   uint64_t Enc = 63 - *MaybeImmed;
 4108   return select12BitValueWithLeftShift(*MaybeImmed);
 4122   uint64_t Immed = *MaybeImmed;
 4488   unsigned Val = *Immed & (NumBits - 1);
 4539   uint64_t AndMask = *MaybeAndMask;
 4594     ShiftVal = *MaybeShiftVal;
lib/Target/AArch64/AArch64StackTagging.cpp
  367       if (!IB.addStore(*Offset, NextStore, DL))
  384       if (!IB.addMemSet(*Offset, MSI))
lib/Target/AArch64/AArch64TargetMachine.cpp
  227   if (!RM.hasValue() || *RM == Reloc::DynamicNoPIC)
  229   return *RM;
  236     if (*CM != CodeModel::Small && *CM != CodeModel::Tiny &&
  236     if (*CM != CodeModel::Small && *CM != CodeModel::Tiny &&
  237         *CM != CodeModel::Large) {
  241       else if (*CM != CodeModel::Kernel)
  244     } else if (*CM == CodeModel::Tiny && !TT.isOSBinFormatELF())
  246     return *CM;
lib/Target/AArch64/AArch64TargetTransformInfo.cpp
  640       LT.second.is128BitVector() && (!Alignment || *Alignment < Align(16))) {
lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp
 2408       *PRFM, Tok.getString(), S, getContext()));
lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp
  355     OutStreamer->emitRawComment(" NumAgprs: " + Twine(*NumAGPR), false);
lib/Target/AMDGPU/AMDGPUHSAMetadataStreamer.cpp
  807       Arg[".address_space"] = Arg.getDocument()->getNode(*Qualifier, /*Copy=*/true);
  810     Arg[".access"] = Arg.getDocument()->getNode(*AQ, /*Copy=*/true);
lib/Target/AMDGPU/AsmParser/AMDGPUAsmParser.cpp
 2283   MCSymbol *Sym = getContext().getOrCreateSymbol(*SymbolName);
 2297   MCSymbol *Sym = getContext().getOrCreateSymbol(*SymbolName);
lib/Target/AMDGPU/SILoadStoreOptimizer.cpp
 1512   Addr.Offset = (*Offset0P & 0x00000000ffffffff) | (Offset1 << 32);
lib/Target/AMDGPU/SIPeepholeSDWA.cpp
  572     if (*Imm != 16 && *Imm != 24)
  572     if (*Imm != 16 && *Imm != 24)
  584           Dst, Src1, *Imm == 16 ? WORD_1 : BYTE_3, UNUSED_PAD);
  587           Src1, Dst, *Imm == 16 ? WORD_1 : BYTE_3, false, false,
  610     if (!Imm || *Imm != 8)
  660     if (*Offset == 0 && *Width == 8)
  660     if (*Offset == 0 && *Width == 8)
  662     else if (*Offset == 0 && *Width == 16)
  662     else if (*Offset == 0 && *Width == 16)
  664     else if (*Offset == 0 && *Width == 32)
  664     else if (*Offset == 0 && *Width == 32)
  666     else if (*Offset == 8 && *Width == 8)
  666     else if (*Offset == 8 && *Width == 8)
  668     else if (*Offset == 16 && *Width == 8)
  668     else if (*Offset == 16 && *Width == 8)
  670     else if (*Offset == 16 && *Width == 16)
  670     else if (*Offset == 16 && *Width == 16)
  672     else if (*Offset == 24 && *Width == 8)
  672     else if (*Offset == 24 && *Width == 8)
  704     if (!Imm || (*Imm != 0x0000ffff && *Imm != 0x000000ff))
  704     if (!Imm || (*Imm != 0x0000ffff && *Imm != 0x000000ff))
  714         ValSrc, Dst, *Imm == 0x0000ffff ? WORD_0 : BYTE_0);
lib/Target/AMDGPU/Utils/AMDGPUBaseInfo.cpp
  429       *EnableWavefrontSize32 :
lib/Target/ARC/ARCTargetMachine.cpp
   26   return *RM;
lib/Target/ARM/ARMTargetMachine.cpp
  194   if (*RM == Reloc::ROPI || *RM == Reloc::RWPI || *RM == Reloc::ROPI_RWPI)
  194   if (*RM == Reloc::ROPI || *RM == Reloc::RWPI || *RM == Reloc::ROPI_RWPI)
  194   if (*RM == Reloc::ROPI || *RM == Reloc::RWPI || *RM == Reloc::ROPI_RWPI)
  199   if (*RM == Reloc::DynamicNoPIC && !TT.isOSDarwin())
  202   return *RM;
lib/Target/ARM/ARMTargetTransformInfo.cpp
  744       (Alignment && *Alignment != Align(16)) &&
lib/Target/AVR/AVRTargetMachine.cpp
   40   return RM.hasValue() ? *RM : Reloc::Static;
lib/Target/BPF/BPFTargetMachine.cpp
   53   return *RM;
lib/Target/BPF/BTFDebug.cpp
  682     Buf = MemoryBuffer::getMemBufferCopy(*Source);
lib/Target/Hexagon/HexagonTargetMachine.cpp
  180   return *RM;
lib/Target/Hexagon/HexagonTargetTransformInfo.cpp
  173       if (!Alignment || *Alignment > RegAlign)
lib/Target/Lanai/LanaiTargetMachine.cpp
   53   return *RM;
lib/Target/MSP430/MSP430TargetMachine.cpp
   32   return *RM;
lib/Target/Mips/MipsSubtarget.cpp
  250     stackAlignment = *StackAlignOverride;
lib/Target/Mips/MipsTargetMachine.cpp
  102   return *RM;
lib/Target/PowerPC/PPCTargetMachine.cpp
  228     return *RM;
  246     if (*CM == CodeModel::Tiny)
  248     if (*CM == CodeModel::Kernel)
  250     return *CM;
lib/Target/RISCV/RISCVTargetMachine.cpp
   54   return *RM;
lib/Target/Sparc/SparcTargetMachine.cpp
   60   return *RM;
   77     if (*CM == CodeModel::Tiny)
   79     if (*CM == CodeModel::Kernel)
   81     return *CM;
lib/Target/SystemZ/SystemZTargetMachine.cpp
   97   if (!RM.hasValue() || *RM == Reloc::DynamicNoPIC)
   99   return *RM;
  135     if (*CM == CodeModel::Tiny)
  137     if (*CM == CodeModel::Kernel)
  139     return *CM;
lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp
  102   return *RM;
lib/Target/X86/X86InstructionSelector.cpp
  481       int64_t Imm = *COff;
 1114     if (*val != 0)
lib/Target/X86/X86SpeculativeLoadHardening.cpp
 2229     MI = *SingleUse;
lib/Target/X86/X86Subtarget.cpp
  291     stackAlignment = *StackAlignOverride;
lib/Target/X86/X86TargetMachine.cpp
  185   if (*RM == Reloc::DynamicNoPIC) {
  194   if (*RM == Reloc::Static && TT.isOSDarwin() && is64Bit)
  197   return *RM;
  203     if (*CM == CodeModel::Tiny)
  205     return *CM;
lib/Target/XCore/XCoreTargetMachine.cpp
   31   return *RM;
   37     if (*CM != CodeModel::Small && *CM != CodeModel::Large)
   37     if (*CM != CodeModel::Small && *CM != CodeModel::Large)
   39     return *CM;
lib/ToolDrivers/llvm-lib/LibDriver.cpp
   85   StringRef Env = Saver.save(*EnvOpt);
lib/Transforms/IPO/ArgumentPromotion.cpp
  349       (*ReplaceCallSite)(CS, NewCS);
lib/Transforms/IPO/Attributor.cpp
  559       *T &= AAS;
  570     S ^= *T;
  637       *T &= AAS;
  648     S ^= *T;
lib/Transforms/IPO/GlobalOpt.cpp
  448         Expr = *E;
lib/Transforms/IPO/Inliner.cpp
  664         setInlineRemark(CS, inlineCostStr(*OIC));
  691           setInlineRemark(CS, std::string(IR) + "; " + inlineCostStr(*OIC));
  702         emit_inlined_into(ORE, DLoc, Block, *Callee, *Caller, *OIC);
 1061         setInlineRemark(CS, inlineCostStr(*OIC));
 1080         setInlineRemark(CS, std::string(IR) + "; " + inlineCostStr(*OIC));
 1093       emit_inlined_into(ORE, DLoc, Block, Callee, F, *OIC);
lib/Transforms/IPO/LowerTypeTests.cpp
  833     MaxAlign = std::max(MaxAlign, *Alignment);
  834     uint64_t GVOffset = alignTo(CurOffset + DesiredPadding, *Alignment);
lib/Transforms/IPO/PartialInlining.cpp
  405     BFI = &(*GetBFI)(*F);
  943         CurrentCallerBFI = &(*GetBFI)(*Caller);
  959       CallSiteToProfCountMap[User] = *Count;
lib/Transforms/IPO/WholeProgramDevirt.cpp
 1984     if (tryFindVirtualCallTargets(TargetsForSlot, *TidSummary,
lib/Transforms/InstCombine/InstCombineCompares.cpp
 1481     return replaceInstUsesWith(Cmp, ConstantInt::get(Cmp.getType(), *Imp));
lib/Transforms/Instrumentation/CGProfile.cpp
   69         UpdateCounts(TTI, &F, CS.getCalledFunction(), *BBCount);
lib/Transforms/Instrumentation/PGOMemOPSizeOpt.cpp
  248     ActualCount = *BBEdgeCount;
lib/Transforms/Scalar/EarlyCSE.cpp
  802   MemoryLocation MemLoc = *MemLocOpt;
lib/Transforms/Scalar/GVNSink.cpp
  799     Candidates.emplace_back(*Cand);
lib/Transforms/Scalar/GuardWidening.cpp
  338           if (BPI->getEdgeProbability(BB, 0U) >= *LikelyTaken)
  340           else if (BPI->getEdgeProbability(BB, 1U) >= *LikelyTaken)
lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp
 1429       ExitPreLoopAtSCEV = *SR.LowLimit;
 1430     else if (cannotBeMinInLoop(*SR.HighLimit, &OriginalLoop, SE,
 1432       ExitPreLoopAtSCEV = SE.getAddExpr(*SR.HighLimit, MinusOneS);
 1436                         << *(*SR.HighLimit) << "\n");
 1456       ExitMainLoopAtSCEV = *SR.HighLimit;
 1457     else if (cannotBeMinInLoop(*SR.LowLimit, &OriginalLoop, SE,
 1459       ExitMainLoopAtSCEV = SE.getAddExpr(*SR.LowLimit, MinusOneS);
 1463                         << *(*SR.LowLimit) << "\n");
lib/Transforms/Scalar/JumpThreading.cpp
 1265       BasicBlock *KeepSucc = BI->getSuccessor(*Implication ? 0 : 1);
 1266       BasicBlock *RemoveSucc = BI->getSuccessor(*Implication ? 1 : 0);
 2701   if (Impl && *Impl)
 2706     if (Impl && *Impl)
lib/Transforms/Scalar/LoopDistribute.cpp
  947     const MDOperand *Op = *Value;
lib/Transforms/Scalar/LoopPredication.cpp
  706   LoopICmp CurrLatchCheck = *CurrLatchCheckOpt;
  718     return widenICmpRangeCheckIncrementingLoop(CurrLatchCheck, *RangeCheck,
  722     return widenICmpRangeCheckDecrementingLoop(CurrLatchCheck, *RangeCheck,
  891   normalizePredicate(SE, L, *Result);
  984   LatchCheck = *LatchCheckOpt;
lib/Transforms/Scalar/LoopUnrollPass.cpp
  250     UP.Threshold = *UserThreshold;
  251     UP.PartialThreshold = *UserThreshold;
  254     UP.Count = *UserCount;
  256     UP.Partial = *UserAllowPartial;
  258     UP.Runtime = *UserRuntime;
  260     UP.UpperBound = *UserUpperBound;
  262     UP.AllowPeeling = *UserAllowPeeling;
  264     UP.PeelProfiledIterations = *UserAllowProfileBasedPeeling;
  266     UP.FullUnrollMaxCount = *UserFullUnrollMaxCount;
  830             getFullUnrollBoostingFactor(*Cost, UP.MaxPercentThresholdBoost);
  940       if (*ProfileTripCount < FlatLoopTripCountThreshold)
lib/Transforms/Scalar/MemCpyOptimizer.cpp
  343       Ranges.addStore(*Offset, NextStore);
  356       Ranges.addMemSet(*Offset, MSI);
lib/Transforms/Scalar/RewriteStatepointsForGC.cpp
 1449     NumPatchBytes = *SD.NumPatchBytes;
 1451     StatepointID = *SD.StatepointID;
lib/Transforms/Scalar/SROA.cpp
 4387           if (Size > *VarSize)
 4388             Size = *VarSize;
 4389           if (Size == 0 || Start + Size > *VarSize)
 4394         if (!VarSize || *VarSize != Size) {
 4397             FragmentExpr = *E;
lib/Transforms/Scalar/SimpleLoopUnswitch.cpp
  754     uint64_t SW = *DefaultCaseWeight;
  759       SW += *W;
lib/Transforms/Utils/BypassSlowDivision.cpp
  168     CacheI = Cache.insert({Key, *OptResult}).first;
lib/Transforms/Utils/Local.cpp
 1260     return ValueSize >= *FragmentSize;
 1267         return ValueSize >= *FragmentSize;
 1774     DII->setOperand(2, MetadataAsValue::get(Ctx, *DVR));
 1864       bool Signed = *Signedness == DIBasicType::Signedness::Signed;
lib/Transforms/Utils/LoopUnrollPeel.cpp
  290     AlreadyPeeled = *Peeled;
  359     LLVM_DEBUG(dbgs() << "Profile-based estimated trip count is " << *PeelCount
  362     if (*PeelCount) {
  363       if ((*PeelCount + AlreadyPeeled <= UnrollPeelMaxCount) &&
  364           (LoopSize * (*PeelCount + 1) <= UP.Threshold)) {
  365         LLVM_DEBUG(dbgs() << "Peeling first " << *PeelCount
  367         UP.PeelCount = *PeelCount;
  370       LLVM_DEBUG(dbgs() << "Requested peel count: " << *PeelCount << "\n");
  373       LLVM_DEBUG(dbgs() << "Peel cost: " << LoopSize * (*PeelCount + 1)
  747     AlreadyPeeled = *Peeled;
lib/Transforms/Utils/SimplifyCFG.cpp
 3675       NewW = ((uint64_t(*W0) + 1) >> 1);
 3676       SIW.setSuccessorWeight(0, *NewW);
 5898     ConstantInt *TorF = *Imp ? ConstantInt::getTrue(BB->getContext())
lib/Transforms/Utils/SimplifyLibCalls.cpp
 3188     ConstantInt *Flag = dyn_cast<ConstantInt>(CI->getArgOperand(*FlagOp));
 3193   if (SizeOp && CI->getArgOperand(ObjSizeOp) == CI->getArgOperand(*SizeOp))
 3204       uint64_t Len = GetStringLength(CI->getArgOperand(*StrOp));
 3208         annotateDereferenceableBytes(CI, *StrOp, Len);
 3216               dyn_cast<ConstantInt>(CI->getArgOperand(*SizeOp)))
lib/Transforms/Utils/ValueMapper.cpp
  523       assert((!*MappedOp || M.getVM().count(CMD->getValue()) ||
  530     return *MappedOp;
  571     return *MappedOp;
  663       HasChanged |= Op != *MappedOp;
  715         return *MappedOp;
  749         return *MappedOp;
  780     return *NewMD;
  808     return *NewMD;
lib/Transforms/Vectorize/LoopVectorize.cpp
 5150   if (BestKnownTC && *BestKnownTC < TinyTripCountInterleaveThreshold)
 5216     MaxInterleaveCount = std::min(*BestKnownTC / VF, MaxInterleaveCount);
 7348     State.ILV->scalarizeInstruction(Ingredient, *State.Instance, IsPredicated);
 7357       State.ILV->packScalarIntoVectorValue(Ingredient, *State.Instance);
 7401       State.ValueMap.getScalarValue(PredInst, *State.Instance));
 7425     State.ValueMap.resetScalarValue(PredInst, *State.Instance, Phi);
 7577   if (ExpectedTC && *ExpectedTC < TinyTripCountVectorThreshold) {
 7647     VF = *MaybeVF;
lib/Transforms/Vectorize/SLPVectorizer.cpp
 2880     const unsigned ExtIdx = *Idx;
 6417         llvm::transform(*Order, ReorderedOps.begin(),
tools/clang/include/clang/AST/ASTContext.h
 2343       if (*SubTnullability == *SuperTnullability ||
 2343       if (*SubTnullability == *SuperTnullability ||
 2344           *SubTnullability == NullabilityKind::Unspecified ||
 2345           *SuperTnullability == NullabilityKind::Unspecified)
 2351         return (*SuperTnullability == NullabilityKind::NonNull &&
 2352                 *SubTnullability == NullabilityKind::Nullable);
 2357         return (*SuperTnullability == NullabilityKind::Nullable &&
 2358                 *SubTnullability == NullabilityKind::NonNull);
tools/clang/include/clang/AST/ExprCXX.h
 4038         NumExpansions(NumExpansions ? *NumExpansions + 1 : 0),
 4132         Length(Length ? *Length : PartialArgs.size()), Pack(Pack) {
 4556         NumExpansions(NumExpansions ? *NumExpansions + 1 : 0), Opcode(Opcode) {
tools/clang/include/clang/AST/TemplateBase.h
  199       TemplateArg.NumExpansions = *NumExpansions + 1;
tools/clang/include/clang/AST/Type.h
 5445         NumExpansions ? *NumExpansions + 1 : 0;
 5474       ID.AddInteger(*NumExpansions);
tools/clang/include/clang/Analysis/Analyses/ThreadSafetyTIL.h
  936       llvm::raw_string_ostream OS(*SlotName);
  939     return *SlotName;
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h
 1076       return static_cast<size_t>(*RequiredArgs);
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h
  703     return bindLoc(*L, V, LCtx);
  753     return getStateManager().StoreMgr->getLValueElement(ElementType, *N, Base);
tools/clang/include/clang/Tooling/Refactoring/Extract/Extract.h
   36         DeclName(DeclName ? std::move(*DeclName) : "extracted") {}
tools/clang/lib/ARCMigrate/Transforms.cpp
   30   return *EnableCFBridgeFns;
tools/clang/lib/AST/ASTContext.cpp
 5649         AttributedType::getNullabilityAttrKind(*Nullability), Result, Result);
tools/clang/lib/AST/ASTDiagnostic.cpp
   81             AttributedType::getNullabilityAttrKind(*nullability), RT, RT);
   93                 AttributedType::getNullabilityAttrKind(*nullability), PT, PT);
tools/clang/lib/AST/ASTImporter.cpp
  185       return import(*From);
 6928     if (Error Err = ImportDefaultArgOfParmVarDecl(*FromParam, ToParam))
 7944     return make_error<ImportError>(*Error);
 7951       setImportDeclError(FromD, *Error);
 7952       return make_error<ImportError>(*Error);
 8036     return make_error<ImportError>(*Err);
 8043     setImportDeclError(FromD, *Error);
 8044     return make_error<ImportError>(*Error);
tools/clang/lib/AST/ASTStructuralEquivalence.cpp
 1123         if (*Index1 != *Index2)
 1123         if (*Index1 != *Index2)
tools/clang/lib/AST/Decl.cpp
  712       LV.mergeVisibility(*Vis, true);
  722           LV.mergeVisibility(*Vis, true);
  934       LV.mergeVisibility(*Vis, true);
 1230         LV.mergeVisibility(*Vis, true);
 1250           LV.mergeVisibility(*Vis, true);
 1463     return *LI;
tools/clang/lib/AST/DeclPrinter.cpp
 1224       Out << getNullabilitySpelling(*nullability, true) << ' ';
 1535         if (*nullability == NullabilityKind::Unspecified &&
 1541               << getNullabilitySpelling(*nullability, true);
tools/clang/lib/AST/ExprCXX.cpp
  196     if (Expr *SizeExpr = *ArraySize) {
  205     getTrailingObjects<Stmt *>()[arraySizeOffset()] = *ArraySize;
 1767       NamedConcept(NamedConcept, IsSatisfied ? *IsSatisfied : true),
tools/clang/lib/AST/ExprConstant.cpp
 1974       Info.Note((*Alloc)->AllocExpr->getExprLoc(),
 3639     return CompleteObject(LVal.Base, &(*Alloc)->Value,
 6064   if (DeallocKind != (*Alloc)->getKind()) {
 6066         << DeallocKind << (*Alloc)->getKind() << AllocType;
 6416         ResultVal.getStructBase(I) = *SubObj;
 6441       ResultVal.getStructField(FieldIdx) = *SubObj;
 6469       ArrayValue.getArrayInitializedElt(I) = std::move(*ElementValue);
 6601       BufferToAPValueConverter::convert(Info, *Buffer, BCE);
 6605   DestValue = std::move(*MaybeDestValue);
 8517     const Expr *Stripped = *ArraySize;
 8536       Info.FFDiag(*ArraySize, diag::note_constexpr_new_negative)
 8537           << ArrayBound << (*ArraySize)->getSourceRange();
 8549       Info.FFDiag(*ArraySize, diag::note_constexpr_new_too_large)
 8550         << ArrayBound << (*ArraySize)->getSourceRange();
 8569         Info.FFDiag(*ArraySize, diag::note_constexpr_new_too_small)
 8572             << (*ArraySize)->getSourceRange();
13249                          (*Alloc)->Value, AllocType))
tools/clang/lib/AST/Interp/ByteCodeEmitter.cpp
   44       Ty = *T;
   63       return llvm::make_error<ByteCodeGenError>(*BailLocation);
tools/clang/lib/AST/Interp/ByteCodeExprGen.cpp
  136     return emitConst(*T, getIntWidth(LitTy), LE->getValue(), LE);
  183       return Discard(this->emitEQ(*LT, BO));
  185       return Discard(this->emitNE(*LT, BO));
  187       return Discard(this->emitLT(*LT, BO));
  189       return Discard(this->emitLE(*LT, BO));
  191       return Discard(this->emitGT(*LT, BO));
  193       return Discard(this->emitGE(*LT, BO));
  195       return Discard(this->emitSub(*T, BO));
  197       return Discard(this->emitAdd(*T, BO));
  199       return Discard(this->emitMul(*T, BO));
  266             return dereferenceParam(LV, *T, PD, AK, Direct, Indirect);
  268             return dereferenceVar(LV, *T, VD, AK, Direct, Indirect);
  275     return Indirect(*T);
  315       return this->emitGetPtrGlobal(*Idx, PD);
  356       if (!this->emitGetGlobal(T, *Idx, LV))
  363       if (!this->emitSetGlobal(T, *Idx, LV))
  365       return DiscardResult ? true : this->emitGetPtrGlobal(*Idx, LV);
  368       if (!this->emitGetGlobal(T, *Idx, LV))
  372       if (!this->emitSetGlobal(T, *Idx, LV))
  374       return DiscardResult ? true : this->emitGetPtrGlobal(*Idx, LV);
  475       return this->emitGetGlobalPtr(*Idx, E);
  477       return this->emitGetPtrGlobal(*Idx, E);
  525     return this->emitRet(*T, Exp);
  544       if (!this->emitDup(*T, VD))
  546       if (!this->emitInitGlobal(*T, *I, VD))
  546       if (!this->emitInitGlobal(*T, *I, VD))
  548       return this->emitRet(*T, VD);
  553         if (!visitGlobalInitializer(Init, *I))
  558       if (!this->emitGetPtrGlobal(*I, VD))
tools/clang/lib/AST/Interp/ByteCodeExprGen.h
  117       return *T;
  213     return (*InitFn)();
  293     this->Ctx->Descriptors[*Idx].emplace_back(Local);
  299     this->Ctx->emitDestroy(*Idx, SourceInfo{});
tools/clang/lib/AST/Interp/ByteCodeStmtGen.cpp
  173       return this->emitRet(*ReturnType, RS);
  240     auto Off = this->allocateLocalPrimitive(VD, *T, DT.isConstQualified());
  248     return this->emitSetLocal(*T, Off, VD);
  252       return this->visitLocalInitializer(VD->getInit(), *Off);
tools/clang/lib/AST/Interp/EvalEmitter.cpp
   33     return llvm::make_error<ByteCodeGenError>(*BailLocation);
   41     return llvm::make_error<ByteCodeGenError>(*BailLocation);
  127               TYPE_SWITCH(*T, Ok &= ReturnValue<T>(FP.deref<T>(), Value));
  149             TYPE_SWITCH(*T, Ok &= ReturnValue<T>(FP.deref<T>(), Value));
  181           TYPE_SWITCH(*T, Ok &= ReturnValue<T>(EP.deref<T>(), Slot));
tools/clang/lib/AST/Interp/InterpFrame.cpp
  126       PrimTy = *T;
tools/clang/lib/AST/Interp/Program.cpp
  104     GlobalIndices[VD] = *Index;
  116     GlobalIndices[VD] = *Idx;
  135     DummyParams[PD] = *Idx;
  152       GlobalIndices[P] = *Idx;
  153     return *Idx;
  169     Desc = createDescriptor(D, *T, IsConst, IsTemporary);
  278       Desc = createDescriptor(FD, *T, IsConst, /*isTemporary=*/false,
  313         unsigned ElemSize = primSize(*T);
  317         return allocateDescriptor(D, *T, NumElems, IsConst, IsTemporary,
  338         return allocateDescriptor(D, *T, IsTemporary,
tools/clang/lib/AST/ItaniumCXXABI.cpp
  118       return *Result;
tools/clang/lib/AST/JSONNodeDumper.cpp
  667     JOS.attribute("numExpansions", *N);
tools/clang/lib/AST/StmtPrinter.cpp
 2032     if (*Size)
 2033       (*Size)->printPretty(s, Helper, Policy);
tools/clang/lib/AST/TextNodeDumper.cpp
 1222     OS << " expansions " << *N;
tools/clang/lib/AST/Type.cpp
 1424     return substObjCTypeArgs(dc->getParentASTContext(), *subs, context);
tools/clang/lib/ASTMatchers/Dynamic/Parser.cpp
  361           *Value = VariantMatcher::SingleMatcher(*Bound);
  447     ScopedContextEntry SCE(this, Ctor ? *Ctor : nullptr);
  500       *Ctor, MatcherRange, BindID, Args, Error);
tools/clang/lib/ASTMatchers/Dynamic/Registry.cpp
  684       return VariantMatcher::SingleMatcher(*Bound);
tools/clang/lib/ASTMatchers/Dynamic/VariantValue.cpp
   76     DynMatchers.push_back(*Inner);
tools/clang/lib/Analysis/RetainSummaryManager.cpp
  866     return RetEffect::MakeOwned(*K);
  872     return RetEffect::MakeNotOwned(*K);
  912     Template->addArg(AF, parm_idx, ArgEffect(DecRef, *K));
  953     Template->addArg(AF, parm_idx, ArgEffect(UnretainedOutParameter, *K));
  985     Template->setRetEffect(*RetE);
 1012     Template->setRetEffect(*RetE);
tools/clang/lib/Basic/SourceManager.cpp
 2085       out << *NextStart << ">\n";
tools/clang/lib/CodeGen/BackendUtil.cpp
  697     MPM.add(createGCOVProfilerPass(*Options));
  704     MPM.add(createInstrProfilingLegacyPass(*Options, false));
 1119         MPM.addPass(GCOVProfilerPass(*Options));
 1122         MPM.addPass(InstrProfiling(*Options, false));
tools/clang/lib/CodeGen/CGCall.cpp
 3371                           *Nullability == NullabilityKind::NonNull &&
tools/clang/lib/CodeGen/CGDebugInfo.cpp
  436     CSInfo.emplace(*CSKind, Checksum);
  614     CSInfo.emplace(*CSKind, Checksum);
 2974       return getOrCreateModuleRef(*Info, /*SkeletonCU=*/true);
 4025                         Scope, Name, *ArgNo, Unit, Line, Ty,
tools/clang/lib/CodeGen/CGDecl.cpp
  725   if (!Nullability || *Nullability != NullabilityKind::NonNull)
 2511     if (Nullability && *Nullability == NullabilityKind::NonNull) {
tools/clang/lib/CodeGen/CGExpr.cpp
 2307   if (!Res || (*Res == OMPDeclareTargetDeclAttr::MT_To &&
 2310   assert(((*Res == OMPDeclareTargetDeclAttr::MT_Link) ||
 2311           (*Res == OMPDeclareTargetDeclAttr::MT_To &&
 4279     return lhs ? *lhs : *rhs;
 4279     return lhs ? *lhs : *rhs;
tools/clang/lib/CodeGen/CGExprConstant.cpp
  172   replace(Elems, *FirstElemToReplace, *LastElemToReplace, {C});
  172   replace(Elems, *FirstElemToReplace, *LastElemToReplace, {C});
  173   replace(Offsets, *FirstElemToReplace, *LastElemToReplace, {Offset});
  173   replace(Offsets, *FirstElemToReplace, *LastElemToReplace, {Offset});
  231       assert(*LastElemToUpdate - *FirstElemToUpdate < 2 &&
  231       assert(*LastElemToUpdate - *FirstElemToUpdate < 2 &&
  243       if (*FirstElemToUpdate == *LastElemToUpdate ||
  243       if (*FirstElemToUpdate == *LastElemToUpdate ||
  244           Elems[*FirstElemToUpdate]->isNullValue() ||
  245           isa<llvm::UndefValue>(Elems[*FirstElemToUpdate])) {
  250         llvm::Constant *&ToUpdate = Elems[*FirstElemToUpdate];
  502   size_t First = *FirstElemToReplace;
  507   size_t Last = *LastElemToReplace;
tools/clang/lib/CodeGen/CGExprScalar.cpp
  197   QualType LHSTy = *OptionalLHSTy;
  198   QualType RHSTy = *OptionalRHSTy;
  543         llvm::ConstantInt::get(CGF.CGM.Int32Ty, Min ? *Min : 0),
  544         llvm::ConstantInt::get(CGF.CGM.Int32Ty, SMin ? *SMin : 0),
tools/clang/lib/CodeGen/CGObjC.cpp
  506     return AdjustObjCObjectType(*this, E->getType(), RValue::get(*Val));
tools/clang/lib/CodeGen/CGOpenMPRuntime.cpp
 2674   if (Res && (*Res == OMPDeclareTargetDeclAttr::MT_Link ||
 2675               (*Res == OMPDeclareTargetDeclAttr::MT_To &&
 2882   if (!Res || *Res == OMPDeclareTargetDeclAttr::MT_Link ||
 2883       (*Res == OMPDeclareTargetDeclAttr::MT_To &&
 7521           if ((*Res == OMPDeclareTargetDeclAttr::MT_Link) ||
 7522               (*Res == OMPDeclareTargetDeclAttr::MT_To &&
 8451             !Res || *Res != OMPDeclareTargetDeclAttr::MT_Link)
 9587       if (DevTy && *DevTy == OMPDeclareTargetDeclAttr::DT_NoHost)
 9601     if (DevTy && *DevTy == OMPDeclareTargetDeclAttr::DT_Host)
 9635   if (!Res || *Res == OMPDeclareTargetDeclAttr::MT_Link ||
 9636       (*Res == OMPDeclareTargetDeclAttr::MT_To &&
 9700   if (*Res == OMPDeclareTargetDeclAttr::MT_To &&
 9725     assert(((*Res == OMPDeclareTargetDeclAttr::MT_Link) ||
 9726             (*Res == OMPDeclareTargetDeclAttr::MT_To &&
 9729     if (*Res == OMPDeclareTargetDeclAttr::MT_Link)
 9763     if (*Res == OMPDeclareTargetDeclAttr::MT_To &&
 9767       assert((*Res == OMPDeclareTargetDeclAttr::MT_Link ||
 9768               (*Res == OMPDeclareTargetDeclAttr::MT_To &&
tools/clang/lib/CodeGen/CodeGenFunction.cpp
  807     if (Nullability && *Nullability == NullabilityKind::NonNull) {
tools/clang/lib/CodeGen/CodeGenFunction.h
 1353     return *Count;
tools/clang/lib/CodeGen/CodeGenModule.cpp
 2503           if (*Res == OMPDeclareTargetDeclAttr::MT_To &&
 2507             assert(((*Res == OMPDeclareTargetDeclAttr::MT_Link) ||
 2508                     (*Res == OMPDeclareTargetDeclAttr::MT_To &&
tools/clang/lib/CodeGen/CodeGenPGO.cpp
 1054   if (*CondCount == 0)
 1057                               std::max(*CondCount, LoopCount) - LoopCount);
tools/clang/lib/CodeGen/CodeGenPGO.h
   75       setCurrentRegionCount(*Count);
tools/clang/lib/CodeGen/CoverageMappingGen.cpp
  298           *CovFileID, SR.LineStart, SR.ColumnStart, SR.LineEnd, SR.ColumnEnd);
  301       if (Region.LineStart >= FileLineRanges[*CovFileID].first &&
  302           Region.LineEnd <= FileLineRanges[*CovFileID].second)
  342             Region.getCounter(), *CovFileID, SR.LineStart, SR.ColumnStart,
  346             Region.getCounter(), *CovFileID, SR.LineStart, SR.ColumnStart,
  375           *ParentFileID, *ExpandedFileID, SR.LineStart, SR.ColumnStart,
  375           *ParentFileID, *ExpandedFileID, SR.LineStart, SR.ColumnStart,
  484       MostRecentLocation = *StartLoc;
  762           SourceRegions.emplace_back(*ParentCounter, FileStart,
tools/clang/lib/CrossTU/CrossTranslationUnit.cpp
  222     if (!ResultLookupName || *ResultLookupName != LookupName)
tools/clang/lib/DirectoryWatcher/linux/DirectoryWatcher-linux.cpp
  359       std::move(*InotifyPollingStopper));
tools/clang/lib/Driver/DarwinSDKInfo.cpp
   37       if (!Version.tryParse(*VersionString))
tools/clang/lib/Driver/Driver.cpp
  182     Mode = *M;
  943     StringRef CompilerPath = *CompilerPathValue;
 4569     return *P;
 4587     return *P;
 4590     return *P;
tools/clang/lib/Driver/ToolChain.cpp
   79       getFilePaths().push_back(*CXXStdlibPath);
   83     getLibraryPaths().push_back(*RuntimePath);
tools/clang/lib/Driver/ToolChains/AVR.cpp
   81                                  std::string(*FamilyName));
   83                                  std::string(*FamilyName));
   85                                  std::string(*FamilyName));
  144     CmdArgs.push_back(Args.MakeArgString(std::string("-m") + *FamilyName));
tools/clang/lib/Driver/ToolChains/Arch/RISCV.cpp
  367   if (MArch.hasValue() && !getArchFeatures(D, *MArch, Features, Args))
tools/clang/lib/Driver/ToolChains/Cuda.cpp
  690       llvm::SplitString(*LibPath, Frags, EnvPathSeparatorStr);
tools/clang/lib/Driver/ToolChains/Fuchsia.cpp
  181         SmallString<128> P(*CXXStdlibPath);
tools/clang/lib/Driver/ToolChains/MSVC.cpp
   78     Path = std::move(*VCToolsInstallDir);
   88     Path = std::move(*VCInstallDir);
   99     llvm::StringRef(*PathEnv).split(PathEntries, llvm::sys::EnvPathSeparator);
 1249     StringRef(*cl_include_dir)
tools/clang/lib/Edit/RewriteObjCFoundationAPI.cpp
  735   Info.U = *UpperU ? "U" : "u";
  736   Info.L = *UpperL ? "L" : "l";
  737   Info.LL = *UpperL ? "LL" : "ll";
  782   NSAPI::NSNumberLiteralMethodKind MK = *MKOpt;
  990   NSAPI::NSNumberLiteralMethodKind MK = *MKOpt;
tools/clang/lib/Format/ContinuationIndenter.cpp
  199       DelimiterStyle.insert({Delimiter, *LanguageStyle});
  202       EnclosingFunctionStyle.insert({EnclosingFunction, *LanguageStyle});
 1674     Penalty = reformatRawStringLiteral(Current, State, *RawStringStyle, DryRun,
 1748   auto RawStringStyle = RawStringFormats.getDelimiterStyle(*Delimiter);
tools/clang/lib/Format/Format.cpp
 2343       auto Err = Result.add(*Replace);
 2425         CurrentCode ? StringRef(*CurrentCode) : Code, PassFixes.first);
 2432             *CurrentCode, FileName,
tools/clang/lib/Frontend/CompilerInvocation.cpp
  548       return *RM;
 2712       Opts.setLaxVectorConversions(*Kind);
tools/clang/lib/Frontend/InitHeaderSearch.cpp
  160       std::make_pair(Group, DirectoryLookup(*DE, Type, isFramework)));
tools/clang/lib/Frontend/PrecompiledPreamble.cpp
  261                                      : PCHStorage(std::move(*TempFile));
  567   TemporaryFiles::getInstance().addFile(*this->FilePath);
  588     TemporaryFiles::getInstance().removeFile(*FilePath);
tools/clang/lib/Frontend/SerializedDiagnosticReader.cpp
   87       Stream.setBlockInfo(&*BlockInfo);
tools/clang/lib/Frontend/TextDiagnostic.cpp
 1182       Lines = maybeAddRange(Lines, *OptionalRange, MaxLines);
tools/clang/lib/Lex/HeaderMap.cpp
  181       return *S;
  227     if (!Filename.equals_lower(*Key))
tools/clang/lib/Lex/HeaderSearch.cpp
  415       return *Result;
  419     return *Res;
  622     return *File;
 1128   return *File;
tools/clang/lib/Lex/ModuleMap.cpp
 1147       LazyHeadersByModTime[*Header.ModTime].push_back(Mod);
 1149       LazyHeadersBySize[*Header.Size].push_back(Mod);
tools/clang/lib/Lex/PPDirectives.cpp
  433     CurLexer->skipOver(*SkipLength);
 1736         DirectoryLookup DL(*DE, SrcMgr::C_User, false);
 2075       Callbacks->FileSkipped(*File, FilenameTok, FileCharacter);
 2167   FileID FID = SourceMgr.createFileID(*File, IncludePos, FileCharacter);
tools/clang/lib/Lex/Preprocessor.cpp
  583         SourceMgr.createFileID(*File, SourceLocation(), SrcMgr::C_User));
tools/clang/lib/Lex/TokenLexer.cpp
  302         if (!*CalledWithVariadicArguments) {
tools/clang/lib/Parse/ParseDecl.cpp
 5322         (*CodeCompletionHandler)();
tools/clang/lib/Parse/ParseExpr.cpp
 3215       AvailSpecs.push_back(*Spec);
tools/clang/lib/Parse/ParsePragma.cpp
 1234     attr::SubjectMatchRule PrimaryRule = *Rule.first;
 1280       SubRule = *SubRuleOrNone;
 1291       SubRule = *SubRuleOrNone;
 2727         TokFPAnnotValue{*FlagKind, *FlagValue};
 2727         TokFPAnnotValue{*FlagKind, *FlagValue};
tools/clang/lib/Parse/ParseStmt.cpp
 1277         /*ShouldEnter=*/ConstexprCondition && !*ConstexprCondition);
 1311         /*ShouldEnter=*/ConstexprCondition && *ConstexprCondition);
tools/clang/lib/Sema/AnalysisBasedWarnings.cpp
 2091     AC.getCFGBuildOptions().Observer = &*LEH;
tools/clang/lib/Sema/Sema.cpp
  465   if (!ExprNullability || *ExprNullability != NullabilityKind::Nullable)
  469   if (!TypeNullability || *TypeNullability != NullabilityKind::NonNull)
 1312       if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
 1312       if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
 1314         (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
 1337       if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
 1337       if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
 1339         (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
 1359       if (*Info) {
 1361         (*Info)->addSuppressedDiagnostic(DiagInfo.getLocation(),
tools/clang/lib/Sema/SemaAttr.cpp
  679       auto It = Rules.find(*ParentRule);
  685             << attr::getSubjectMatchRuleSpelling(*ParentRule) << It->second
  694             std::make_pair(*ParentRule, Rule));
  703       auto It = RulesToFirstSpecifiedNegatedSubRule.find(*ParentRule);
tools/clang/lib/Sema/SemaChecking.cpp
 4114     if (*nullability == NullabilityKind::NonNull)
 4199     return *nullability == NullabilityKind::NonNull;
10740                               << OS.str() << *Result);
10754             << OtherIsBooleanDespiteType << *Result
10764         << RhsConstant << OtherT << E->getOpcodeStr() << OS.str() << *Result
13684   NSAPI::NSArrayMethodKind MK = *MKOpt;
13719   NSAPI::NSDictionaryMethodKind MK = *MKOpt;
13753   NSAPI::NSSetMethodKind MK = *MKOpt;
13781   int ArgIndex = *ArgOpt;
tools/clang/lib/Sema/SemaCodeComplete.cpp
 2667       switch (*nullability) {
 2760       Type = Type.substObjCTypeArgs(Param->getASTContext(), *ObjCSubsts,
 2841         ResultType.substObjCTypeArgs(BlockDecl->getASTContext(), *ObjCSubsts,
 3485               Ctx, *ObjCSubsts, ObjCSubstitutionContext::Parameter);
 7500     if (!WantInstanceMethods || M->isInstanceMethod() == *WantInstanceMethods) {
 8315           AddObjCKeyValueCompletions(P, *IsInstanceMethod, ReturnType, Context,
tools/clang/lib/Sema/SemaDecl.cpp
 2962       if (*Oldnullability != *Newnullability) {
 2962       if (*Oldnullability != *Newnullability) {
 2965                *Newnullability,
 2969                *Oldnullability,
 2977                          AttributedType::getNullabilityAttrKind(*Oldnullability),
12406     return *CacheHasConstInit;
17669       if (*DevTy == OMPDeclareTargetDeclAttr::DT_Host)
17686         if (*DevTy == OMPDeclareTargetDeclAttr::DT_NoHost) {
tools/clang/lib/Sema/SemaDeclObjC.cpp
 4432     if (*nullability == *prevNullability)
 4432     if (*nullability == *prevNullability)
 4437       << DiagNullabilityKind(*nullability, usesCSKeyword)
 4438       << DiagNullabilityKind(*prevNullability, prevUsesCSKeyword);
 4448            AttributedType::getNullabilityAttrKind(*prevNullability),
tools/clang/lib/Sema/SemaExpr.cpp
 5307   if (ArgSize && ParmSize && *ArgSize < *ParmSize) {
 5307   if (ArgSize && ParmSize && *ArgSize < *ParmSize) {
 7747       return *Kind;
tools/clang/lib/Sema/SemaExprCXX.cpp
 1829           Diag(ArraySize ? (*ArraySize)->getExprLoc() : TypeRange.getBegin(),
 1832           << (ArraySize ? (*ArraySize)->getSourceRange() : TypeRange));
 1898   if (ArraySize && *ArraySize &&
 1899       (*ArraySize)->getType()->isNonOverloadPlaceholderType()) {
 1900     ExprResult result = CheckPlaceholderExpr(*ArraySize);
 1912   if (ArraySize && *ArraySize && !(*ArraySize)->isTypeDependent()) {
 1912   if (ArraySize && *ArraySize && !(*ArraySize)->isTypeDependent()) {
 1917       ConvertedSize = PerformImplicitConversion(*ArraySize, Context.getSizeType(),
 1921           (*ArraySize)->getType()->getAs<RecordType>())
 1924           << (*ArraySize)->getType() << 0 << "'size_t'";
 1978       } SizeDiagnoser(*ArraySize);
 1980       ConvertedSize = PerformContextualImplicitConversion(StartLoc, *ArraySize,
 1987     QualType SizeType = (*ArraySize)->getType();
 1999     if (!(*ArraySize)->isValueDependent()) {
 2006       if ((*ArraySize)->isIntegerConstantExpr(Value, Context)) {
 2008           return ExprError(Diag((*ArraySize)->getBeginLoc(),
 2010                            << (*ArraySize)->getSourceRange());
 2018                 Diag((*ArraySize)->getBeginLoc(), diag::err_array_too_large)
 2019                 << Value.toString(10) << (*ArraySize)->getSourceRange());
 2025         Diag((*ArraySize)->getBeginLoc(), diag::ext_new_paren_array_nonconst)
 2026             << (*ArraySize)->getSourceRange()
 2121                       *KnownArraySize),
 2122           *ArraySize, ArrayType::Normal, 0);
 2150     if (ArraySize && !*ArraySize) {
tools/clang/lib/Sema/SemaExprObjC.cpp
  257   if (S.NSNumberLiteralMethods[*Kind])
  258     return S.NSNumberLiteralMethods[*Kind];
  260   Selector Sel = S.NSAPIObj->getNSNumberLiteralSelector(*Kind,
  308   S.NSNumberLiteralMethods[*Kind] = Method;
  595             AttributedType::getNullabilityAttrKind(*Nullability), BoxedType,
 1284                AttributedType::getNullabilityAttrKind(*nullability),
 1325                AttributedType::getNullabilityAttrKind(*nullability),
 1400               AttributedType::getNullabilityAttrKind(*Nullability),
 1416     receiverNullabilityIdx = 1 + static_cast<unsigned>(*nullability);
 1420     resultNullabilityIdx = 1 + static_cast<unsigned>(*nullability);
 1698                     *typeArgs,
tools/clang/lib/Sema/SemaLambda.cpp
  771            hasWeakerNullability(*RetTyNullability, *BlockNullability)))
  771            hasWeakerNullability(*RetTyNullability, *BlockNullability)))
tools/clang/lib/Sema/SemaLookup.cpp
  552                                   Decls[*ExistingI]))
  553         Decls[*ExistingI] = Decls[I];
tools/clang/lib/Sema/SemaModule.cpp
  647     diagExportedUnnamedDecl(S, *UDK, D, BlockStart);
tools/clang/lib/Sema/SemaObjCProperty.cpp
 2393         if (*nullability == NullabilityKind::Unspecified)
 2467           if (*nullability == NullabilityKind::Unspecified)
 2655       if (*nullability == NullabilityKind::NonNull)
tools/clang/lib/Sema/SemaOpenMP.cpp
 2091         *DevTy == OMPDeclareTargetDeclAttr::DT_Host)
 2095         *DevTy == OMPDeclareTargetDeclAttr::DT_NoHost)
 2103           *DevTy == OMPDeclareTargetDeclAttr::DT_Host) {
 2115           *DevTy == OMPDeclareTargetDeclAttr::DT_NoHost) {
 2816            !Res || *Res != OMPDeclareTargetDeclAttr::MT_Link))
 2901           *Res == OMPDeclareTargetDeclAttr::MT_Link) {
16226   if (DevTy.hasValue() && *DevTy != DT) {
16229         << OMPDeclareTargetDeclAttr::ConvertDevTypeTyToStr(*DevTy);
16241   } else if (*Res != MT) {
16259     if (!MapTy || *MapTy != OMPDeclareTargetDeclAttr::MT_To) {
16310     if (IdLoc.isValid() && Res && *Res == OMPDeclareTargetDeclAttr::MT_Link) {
16319         *DevTy != OMPDeclareTargetDeclAttr::DT_Host)
16322         *DevTy != OMPDeclareTargetDeclAttr::DT_NoHost)
tools/clang/lib/Sema/SemaOverload.cpp
 9224     (*Cand1A)->getCond()->Profile(Cand1ID, S.getASTContext(), true);
 9225     (*Cand2A)->getCond()->Profile(Cand2ID, S.getASTContext(), true);
tools/clang/lib/Sema/SemaTemplate.cpp
 3267           if (*DeductionInfo &&
 3268               (*DeductionInfo)->hasSFINAEDiagnostic() &&
 3269               (*DeductionInfo)->peekSFINAEDiagnostic().second.getDiagID() ==
 3281             (*DeductionInfo)->takeSFINAEDiagnostic(OldDiag);
 3285             (*DeductionInfo)->addSFINAEDiagnostic(
 5239       if (*Expansions == ArgumentPack.size()) {
tools/clang/lib/Sema/SemaTemplateDeduction.cpp
  789       PackElements += *FixedNumExpansions;
  834     return !FixedNumExpansions || *FixedNumExpansions > PackElements;
  943         if (*Expansions != PackElements) {
 1089         for (unsigned I = 0; I != *NumExpansions && ArgIdx < NumArgs;
 3042       if (!Expansions || Arg.pack_size() < *Expansions) {
 3933         for (unsigned I = 0; I != *NumExpansions && ArgIdx < Args.size();
tools/clang/lib/Sema/SemaTemplateInstantiate.cpp
 1977         for (unsigned I = 0; I != *NumExpansions; ++I) {
tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
  130     for (unsigned I = 0; I != *NumExpansions; ++I) {
 2488       for (unsigned I = 0; I != *NumExpansions; ++I) {
 2641       for (unsigned I = 0; I != *NumExpansions; ++I) {
 2888     if (D->getDeclContext()->isFunctionOrMethod() && *NumExpansions > 1) {
 2896     for (unsigned I = 0; I != *NumExpansions; ++I) {
 3860           for (unsigned I = 0; I != *NumArgumentsInExpansion; ++I) {
 3953       for (unsigned Arg = 0; Arg < *NumArgumentsInExpansion; ++Arg) {
 4956       for (unsigned I = 0; I != *NumExpansions; ++I) {
tools/clang/lib/Sema/SemaTemplateVariadic.cpp
  741     if (NewPackSize != *NumExpansions) {
  747           << FirstPack.first << Name << *NumExpansions << NewPackSize
  751           << Name << *NumExpansions << NewPackSize
  767     if (NumExpansions && *NumExpansions < *NumPartialExpansions) {
  767     if (NumExpansions && *NumExpansions < *NumPartialExpansions) {
  771         << PartialPack << *NumPartialExpansions << *NumExpansions
  771         << PartialPack << *NumPartialExpansions << *NumExpansions
  813         assert((!Result || *Result == Size) && "inconsistent pack sizes");
  828     assert((!Result || *Result == Size) && "inconsistent pack sizes");
tools/clang/lib/Sema/SemaType.cpp
 4301           S.getNullabilityKeyword(*inferNullability), SourceRange(pointerLoc),
 4364               createNullabilityAttr(Context, *attr, *inferNullability), T, T);
 6565       if (nullability == *existingNullability) {
 6576         << DiagNullabilityKind(*existingNullability, false);
 6588     if (nullability != *existingNullability) {
 6591         << DiagNullabilityKind(*existingNullability, false);
 6599           if (*typedefNullability == *existingNullability) {
 6599           if (*typedefNullability == *existingNullability) {
 6601               << DiagNullabilityKind(*existingNullability, false);
 6691       Attr *A = createNullabilityAttr(S.Context, attr, *nullability);
tools/clang/lib/Sema/TreeTransform.h
 3590       for (unsigned I = 0; I != *NumExpansions; ++I) {
 4188       for (unsigned I = 0; I != *NumExpansions; ++I) {
 5197           for (unsigned I = 0; I != *NumExpansions; ++I) {
 5293         for (unsigned I = 0; I != *NumExpansions; ++I) {
 5546       for (unsigned ArgIdx = 0; ArgIdx != *NumExpansions; ++ArgIdx) {
 6243             << DiagNullabilityKind(*nullability, false) << modifiedType;
 6554       for (unsigned ArgIdx = 0; ArgIdx != *NumExpansions; ++ArgIdx) {
 6838   if (!ConstexprConditionValue || *ConstexprConditionValue) {
 6848   if (!ConstexprConditionValue || !*ConstexprConditionValue) {
10626     if (*OldArraySize) {
10627       NewArraySize = getDerived().TransformExpr(*OldArraySize);
11044     for (unsigned I = 0; I != *NumExpansions; ++I) {
11442         for (unsigned I = 0; I != *NumExpansions; ++I) {
11630         for (unsigned I = 0; I != *NumExpansions; ++I) {
12048       Result = *Result + 1;
12079     Result = *Result + *NumExpansions;
12079     Result = *Result + *NumExpansions;
12087                                               E->getRParenLoc(), *Result, None);
12220   for (unsigned I = 0; I != *NumExpansions; ++I) {
12222         getSema(), LeftFold ? I : *NumExpansions - I - 1);
12385       for (unsigned I = 0; I != *NumExpansions; ++I) {
tools/clang/lib/Serialization/ASTReader.cpp
 6153     return *HFI;
 8361       assert(*PragmaPackCurrentValue == SemaObj->PackStack.DefaultValue &&
 8365       SemaObj->PackStack.CurrentValue = *PragmaPackCurrentValue;
tools/clang/lib/Serialization/ASTReaderDecl.cpp
 2924     (*Cand1A)->getCond()->Profile(Cand1ID, A->getASTContext(), true);
 2925     (*Cand2A)->getCond()->Profile(Cand2ID, B->getASTContext(), true);
tools/clang/lib/Serialization/ASTWriter.cpp
  510     Record.push_back(*NumExpansions + 1);
 2151           FilenameDup, *U.Size, IncludeTimestamps ? *U.ModTime : 0
 2151           FilenameDup, *U.Size, IncludeTimestamps ? *U.ModTime : 0
 4636     Record.push_back(*Minor + 1);
 4640     Record.push_back(*Subminor + 1);
 6053       Record->push_back(*NumExpansions + 1);
tools/clang/lib/Serialization/ASTWriterDecl.cpp
 2408       ModulesCodegen = *Linkage == GVA_StrongExternal;
 2416         ModulesCodegen = *Linkage != GVA_Internal;
tools/clang/lib/Serialization/ASTWriterStmt.cpp
 1112         NumExpansions = *Element.NumExpansions + 1;
tools/clang/lib/StaticAnalyzer/Checkers/ArrayBoundCheckerV2.cpp
  152       *NV = simplifiedOffsets.second;
  155     SVal lowerBound = svalBuilder.evalBinOpNN(state, BO_LT, rawOffsetVal, *NV,
  164       state->assume(*lowerBoundToCheck);
  204       state->assume(*upperboundToCheck);
tools/clang/lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp
  459   uint64_t CFNumberSize = *OptCFNumberSize;
  566   std::tie(stateNonNull, stateNull) = state->assume(*DefArgVal);
  867   std::tie(StNonNil, StNil) = State->assume(*KnownCollection);
  907   SVal Val = State->getSVal(*ElementLoc);
  941   return State->assume(*CountGreaterThanZero, Assumption);
 1181     return State->assume(*DV, true);
tools/clang/lib/StaticAnalyzer/Checkers/BoolAssignmentChecker.cpp
   87     svalBuilder.evalBinOp(state, BO_GE, *DV, zeroVal,
  100   std::tie(stateGE, stateLT) = CM.assumeDual(state, *greaterThanEqualToZero);
  123     svalBuilder.evalBinOp(state, BO_LE, *DV, OneVal,
  136   std::tie(stateLE, stateGT) = CM.assumeDual(state, *lessThanEqToOne);
tools/clang/lib/StaticAnalyzer/Checkers/CStringChecker.cpp
  276   return state->assume(svalBuilder.evalEQ(state, *val, zero));
  409   SVal Offset = svalBuilder.evalBinOpNN(state, BO_Sub, *Length, One, sizeTy);
  419     SVal BufEnd = svalBuilder.evalBinOpLN(state, BO_Add, *BufLoc,
  439       SVal BufEnd = svalBuilder.evalBinOpLN(state, BO_Add, *BufLoc,
  483     state->assume(svalBuilder.evalEQ(state, *firstLoc, *secondLoc));
  483     state->assume(svalBuilder.evalEQ(state, *firstLoc, *secondLoc));
  498                                          *firstLoc, *secondLoc, cmpTy);
  498                                          *firstLoc, *secondLoc, cmpTy);
  504   std::tie(stateTrue, stateFalse) = state->assume(*reverseTest);
  528   SVal FirstStart = svalBuilder.evalCast(*firstLoc, CharPtrTy,
  536                                  *FirstStartLoc, *Length, CharPtrTy);
  536                                  *FirstStartLoc, *Length, CharPtrTy);
  543                                 *FirstEndLoc, *secondLoc, cmpTy);
  543                                 *FirstEndLoc, *secondLoc, cmpTy);
  549   std::tie(stateTrue, stateFalse) = state->assume(*OverlapTest);
  693                                                 *maxMinusRightNL, cmpTy);
  782       SVal evalLength = svalBuilder.evalBinOpNN(state, BO_LE, *strLn,
  910   SVal Offset = svalBuilder.evalBinOpNN(state, BO_Sub, *Length, One, sizeTy);
  922       svalBuilder.evalBinOpLN(state, BO_Add, *BufLoc, LastOffset, PtrTy);
 1006   return state->killBinding(*L);
 1079         State->assume(svalBuilder.evalEQ(State, Extent, *SizeNL));
 1425               .evalBinOpNN(state, BO_GT, *strLengthNL, *maxlenValNL, cmpTy)
 1425               .evalBinOpNN(state, BO_GT, *strLengthNL, *maxlenValNL, cmpTy)
 1430         result = *maxlenValNL;
 1433         result = *strLengthNL;
 1448                                   state, BO_LE, resultNL, *strLengthNL, cmpTy)
 1454                                   state, BO_LE, resultNL, *maxlenValNL, cmpTy)
 1605           svalBuilder.evalBinOpNN(state, BO_GE, *strLengthNL, *lenValNL, cmpTy)
 1605           svalBuilder.evalBinOpNN(state, BO_GE, *strLengthNL, *lenValNL, cmpTy)
 1635                                                         *lenValNL,
 1636                                                         *dstStrLengthNL,
 1652           assumeZero(C, state, *lenValNL, sizeTy);
 1659             StateZeroSize = StateZeroSize->BindExpr(CE, LCtx, *lenValNL);
 1669         maxLastElementIndex = svalBuilder.evalBinOpNN(state, BO_Sub, *lenValNL,
 1690                                                              *amountCopiedNL,
 1691                                                              *lenValNL,
 1702                                                            *amountCopiedNL,
 1703                                                            *strLengthNL,
 1742       state = checkAdditionOverflow(C, state, *srcStrLengthNL, *dstStrLengthNL);
 1742       state = checkAdditionOverflow(C, state, *srcStrLengthNL, *dstStrLengthNL);
 1746       finalStrLength = svalBuilder.evalBinOpNN(state, BO_Add, *srcStrLengthNL,
 1747                                                *dstStrLengthNL, sizeTy);
 1762                                                         *finalStrLengthNL,
 1763                                                         *srcStrLengthNL,
 1774                                                       *finalStrLengthNL,
 1775                                                       *dstStrLengthNL,
 1813         SVal maxLastElement = svalBuilder.evalBinOpLN(state, BO_Add, *dstRegVal,
 1814             *maxLastNL, ptrTy);
 1824       SVal lastElement = svalBuilder.evalBinOpLN(state, BO_Add, *dstRegVal,
 1825           *knownStrLength, ptrTy);
 1848     state = InvalidateBuffer(C, state, Dst, *dstRegVal,
 2062     Result = State->getSVal(*SearchStrLoc, CharPtrTy);
 2071     State = State->bindLoc(*SearchStrLoc,
tools/clang/lib/StaticAnalyzer/Checkers/CastValueChecker.cpp
  431   Check(this, Call, *DV, C);
tools/clang/lib/StaticAnalyzer/Checkers/DivZeroChecker.cpp
   80   std::tie(stateNotZero, stateZero) = CM.assumeDual(C.getState(), *DV);
   88   bool TaintedD = isTainted(C.getState(), *DV);
   91               std::make_unique<taint::TaintBugVisitor>(*DV));
tools/clang/lib/StaticAnalyzer/Checkers/DynamicTypePropagation.cpp
  775         ASTCtxt, *TypeArgs, ObjCSubstitutionContext::Parameter);
  867       getReturnTypeForMethod(Method, *TypeArgs, *TrackedType, ASTCtxt);
tools/clang/lib/StaticAnalyzer/Checkers/ExprInspectionChecker.cpp
  363       return (*Str + " " + BinaryOperator::getOpcodeStr(S->getOpcode()) + " " +
  375         return (*Str1 + " " + BinaryOperator::getOpcodeStr(S->getOpcode()) +
  376                 " " + *Str2).str();
  384       return (Twine("(") + S->getType().getAsString() + ")" + *Str).str();
  410   reportBug(*Str, C);
tools/clang/lib/StaticAnalyzer/Checkers/GTestChecker.cpp
  266   return State->getSVal(*FieldLoc);
tools/clang/lib/StaticAnalyzer/Checkers/GenericTaintChecker.cpp
  220       return (V && isTainted(State, *V));
  519       State = addTaint(State, *V);
  580   return State->getSVal(*AddrLoc, ValTy);
  729   if (PointedToSVal && isTainted(State, *PointedToSVal))
  730     TaintedSVal = *PointedToSVal;
tools/clang/lib/StaticAnalyzer/Checkers/IteratorChecker.cpp
  999     const auto val = State->getRawSVal(*loc);
 1036     Value = State->getRawSVal(*ValAsLoc);
 2119     NewState = NewState->assume(*DV, true);
 2129     NewState = NewState->assume(*DV, true);
tools/clang/lib/StaticAnalyzer/Checkers/LocalizationChecker.cpp
 1022       PathDiagnosticLocation::create(*Point, BRC.getSourceManager());
tools/clang/lib/StaticAnalyzer/Checkers/MacOSKeychainAPIChecker.cpp
  215     SymbolRef sym = SM.getBinding(State->getStore(), *X).getAsLocSymbol();
tools/clang/lib/StaticAnalyzer/Checkers/MallocChecker.cpp
 1267       State->assume(SvalBuilder.evalEQ(State, *DefArgVal, Zero));
 1469     if (!*FreeWhenDone)
 1545         svalBuilder.evalEQ(State, Extent, *DefinedSize);
 2059     if (!BT_BadFree[*CheckKind])
 2060       BT_BadFree[*CheckKind].reset(new BugType(
 2061           CheckNames[*CheckKind], "Bad free", categories::MemoryError));
 2084     auto R = std::make_unique<PathSensitiveBugReport>(*BT_BadFree[*CheckKind],
 2105     if (!BT_FreeAlloca[*CheckKind])
 2106       BT_FreeAlloca[*CheckKind].reset(new BugType(
 2107           CheckNames[*CheckKind], "Free alloca()", categories::MemoryError));
 2110         *BT_FreeAlloca[*CheckKind],
 2192   if (!BT_OffsetFree[*CheckKind])
 2193     BT_OffsetFree[*CheckKind].reset(new BugType(
 2194         CheckNames[*CheckKind], "Offset free", categories::MemoryError));
 2225   auto R = std::make_unique<PathSensitiveBugReport>(*BT_OffsetFree[*CheckKind],
 2245     if (!BT_UseFree[*CheckKind])
 2246       BT_UseFree[*CheckKind].reset(new BugType(
 2247           CheckNames[*CheckKind], "Use-after-free", categories::MemoryError));
 2253         *BT_UseFree[*CheckKind],
 2283     if (!BT_DoubleFree[*CheckKind])
 2284       BT_DoubleFree[*CheckKind].reset(new BugType(
 2285           CheckNames[*CheckKind], "Double free", categories::MemoryError));
 2288         *BT_DoubleFree[*CheckKind],
 2339     if (!BT_UseZerroAllocated[*CheckKind])
 2340       BT_UseZerroAllocated[*CheckKind].reset(
 2341           new BugType(CheckNames[*CheckKind], "Use of zero allocated",
 2345         *BT_UseZerroAllocated[*CheckKind], "Use of zero-allocated memory", N);
 2367     if (!BT_BadFree[*CheckKind])
 2368       BT_BadFree[*CheckKind].reset(new BugType(
 2369           CheckNames[*CheckKind], "Bad free", categories::MemoryError));
 2384     auto R = std::make_unique<PathSensitiveBugReport>(*BT_BadFree[*CheckKind],
 2575   if (!BT_Leak[*CheckKind]) {
 2581     BT_Leak[*CheckKind].reset(new BugType(CheckNames[*CheckKind], "Memory leak",
 2581     BT_Leak[*CheckKind].reset(new BugType(CheckNames[*CheckKind], "Memory leak",
 2610       *BT_Leak[*CheckKind], os.str(), N, LocUsedForUniqueing,
 2956       return *FreeWhenDone;
 3374         Out << " (" << CheckNames[*CheckKind].getName() << ")";
tools/clang/lib/StaticAnalyzer/Checkers/NonNullParamChecker.cpp
  139     std::tie(stateNotNull, stateNull) = CM.assumeDual(state, *DV);
tools/clang/lib/StaticAnalyzer/Checkers/NonnullGlobalConstantsChecker.cpp
   83       ProgramStateRef OutputState = State->assume(*Constr, true);
tools/clang/lib/StaticAnalyzer/Checkers/NullabilityChecker.cpp
  346   auto StoredVal = State->getSVal(*RegionVal).getAs<loc::MemRegionVal>();
  350   if (getNullConstraint(*StoredVal, State) == NullConstraint::IsNull)
  561   NullConstraint Nullness = getNullConstraint(*RetSVal, State);
  604   const MemRegion *Region = getTrackRegion(*RetSVal);
  668     NullConstraint Nullness = getNullConstraint(*ArgSVal, State);
  696     const MemRegion *Region = getTrackRegion(*ArgSVal);
  796     NullConstraint Nullness = getNullConstraint(*DefOrUnknown, State);
  952   const MemRegion *Region = getTrackRegion(*RegionSVal);
  958     NullConstraint Nullness = getNullConstraint(*RegionSVal, State);
 1072   NullConstraint RhsNullness = getNullConstraint(*ValDefOrUnknown, State);
 1127   const MemRegion *ValueRegion = getTrackRegion(*ValDefOrUnknown);
tools/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.cpp
  292   SymbolRef Sym = State->getSVal(*IVarLoc).getAsSymbol();
  546       AssumeNonZeroReturn = AssumeNonZeroReturn->assume(*DL, true);
  547       AssumeZeroReturn = AssumeZeroReturn->assume(*DL, false);
  696       state = setRefBinding(state, Sym, *updatedRefVal);
  954         state = state->assume(*L, /*assumption=*/true);
 1344   const RetainSummary *FunctionSummary = SmrMgr.getSummary(*C);
tools/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.cpp
  176   for (unsigned Idx = 0; Idx < (*CE)->getNumArgs(); Idx++)
  177     if (const MemRegion *MR = (*CE)->getArgSVal(Idx).getAsRegion())
  206       return *Out;
  293     const ParmVarDecl *PVD = (*CE)->parameters()[*Idx];
  293     const ParmVarDecl *PVD = (*CE)->parameters()[*Idx];
  298     QualType RT = (*CE)->getResultType();
  300       SVal RV = (*CE)->getReturnValue();
  465     if (auto PD = annotateConsumedSummaryMismatch(N, *CE, SM, CEMgr))
  750     os << "object allocated and stored into '" << *RegionDescription << '\'';
  897     os << " stored into '" << *RegionDescription << '\'';
tools/clang/lib/StaticAnalyzer/Checkers/ReturnValueChecker.cpp
   79     return C.getState()->isNull(*ReturnDV).isConstrainedTrue();
   81   return C.getState()->isNull(*ReturnDV).isConstrainedFalse();
   97   if (*IsInvariantBreak)
  144   if (!*IsInvariantBreak)
tools/clang/lib/StaticAnalyzer/Checkers/StdLibraryFunctionsChecker.cpp
  256       State = CM.assumeInclusiveRange(State, *N, Min, Max, false);
  290       State = CM.assumeInclusiveRange(State, *N, MinusInf, Left, false);
  298       State = CM.assumeInclusiveRange(State, *N, Right, PlusInf, false);
  307       State = CM.assumeInclusiveRange(State, *N, Min, Max, false);
  335     State = State->assume(*CompV, true);
  354   const FunctionSummaryTy &Summary = *FoundSummary;
  384   const FunctionSummaryTy &Summary = *FoundSummary;
tools/clang/lib/StaticAnalyzer/Checkers/StreamChecker.cpp
  341   std::tie(stateNotNull, stateNull) = CM.assumeDual(state, *DV);
tools/clang/lib/StaticAnalyzer/Checkers/Taint.cpp
   68                                     .getDefaultBinding(*LCV)) {
tools/clang/lib/StaticAnalyzer/Checkers/TestAfterDivZeroChecker.cpp
  141   return !CM.assume(C.getState(), *DSV, true);
tools/clang/lib/StaticAnalyzer/Checkers/TrustNonnullChecker.cpp
   90         State = State->assume(*L, /*assumption=*/true);
  109         State = State->assume(*L, /*assumption=*/true);
tools/clang/lib/StaticAnalyzer/Checkers/UndefCapturedBlockVarChecker.cpp
   90             *V, VR, /*EnableNullFPSuppression*/ false,
tools/clang/lib/StaticAnalyzer/Checkers/VLASizeChecker.cpp
  147     std::tie(StateNeg, StatePos) = CM.assumeDual(state, *LessThanZeroDVal);
tools/clang/lib/StaticAnalyzer/Checkers/VforkChecker.cpp
  175   std::tie(ParentState, ChildState) = C.getState()->assume(*DVal);
tools/clang/lib/StaticAnalyzer/Core/AnalyzerOptions.cpp
  114   return *K >= Param;
  165   return *Ret;
tools/clang/lib/StaticAnalyzer/Core/BugReporter.cpp
 1174     Call->setCallee(*CE, SM);
 1195     auto Call = PathDiagnosticCallPiece::construct(*CE, SM);
 1233       generateMinimalDiagForBlockEdge(C, *BE);
 1280         if (isJumpToFalseBranch(&*BE)) {
 1652       if (s1Length && *s1Length <= MAX_SHORT_LINE_LENGTH) {
 1654         if (s2Length && *s2Length <= MAX_SHORT_LINE_LENGTH) {
 1719     if (*ByteWidth <= MAX_PUNY_EDGE_LENGTH) {
 2250   switch(*RKind) {
tools/clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp
  202         return State->getRawSVal(*FieldL, FD->getType());
  226     if (Optional<bugreporter::TrackingKind> K = B->getInterestingnessKind(*V))
  227       return *K == bugreporter::TrackingKind::Condition;
  235     return B->getInterestingnessKind(*V).hasValue();
  606           return maybeEmitNote(R, *Call, N, *P, RegionOfInterest, ParamName,
  815       if (isFunctionMacroExpansion(*Loc, SMgr)) {
  816         std::string MacroName = getMacroName(*Loc, BRC);
  987         RetVal = State->getSVal(*LValue);
  996         EnableNullFPSuppression = State->isNull(*RetLoc).isConstrainedTrue();
 1035         SVal RValue = State->getRawSVal(*LValue, RetE->getType());
 1163       if (!State->isNull(*ArgV).isConstrainedTrue())
 1488                   *KV, OriginalR, EnableNullFPSuppression, TKind, OriginSFC));
 1985             *KV, RR, EnableNullFPSuppression, TKind, SFC));
 2015         if (!DV->isZeroConstant() && LVState->isNull(*DV).isConstrainedTrue() &&
 2018               std::make_unique<SuppressInlineDefensiveChecksVisitor>(*DV,
 2023             *KV, R, EnableNullFPSuppression, TKind, SFC));
 2063             *KV, L->getRegion(), EnableNullFPSuppression, TKind, SFC));
 2902     auto Piece = std::make_shared<PathDiagnosticEventPiece>(Loc, *Msg);
tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp
  327           if (const VarRegion *VR = getParameterLocation(*AdjIdx, BlockCount))
 1283           if (!*Val)
 1302                     if (*Val)
 1306                 if (!*Val)
tools/clang/lib/StaticAnalyzer/Core/CoreEngine.cpp
  290     SubEng.processCFGElement(*E, Pred, 0, &Ctx);
tools/clang/lib/StaticAnalyzer/Core/ExprEngine.cpp
  268       if (ProgramStateRef newState = state->assume(*Constraint, true))
  284       state = state->assume(*LV, true);
  299           state = state->assume(*LV, true);
  376       State = State->BindExpr(Result, LC, *V);
  868             InitVal = State->getSVal(*LValueLoc);
 1440         State = State->BindExpr(S, LCtx, *ConstantVal);
 2378           DefaultSt->assumeInclusiveRange(*NL, V1, V2);
 2945       std::tie(StateTrue, StateFalse) = state->assume(*SEV);
 2981       state = state->bindLoc(*LV, UnknownVal(), Pred->getLocationContext());
tools/clang/lib/StaticAnalyzer/Core/ExprEngineC.cpp
  530                       CastE->path_begin(), CastE->path_end()), *PTMSV));
 1038             Result = evalBinOp(state, BO_EQ, *LV, X, U->getType());
tools/clang/lib/StaticAnalyzer/Core/ExprEngineCXX.cpp
   78     V = Pred->getState()->getSVal(*L);
  356           V = *OptV;
  366           V = *OptV;
  373           V = *OptV;
  408     Target = *ElidedTarget;
  412       State = State->BindExpr(CE, LCtx, State->getSVal(*L, CE->getType()));
  796             State = State->assume(*dSymVal, true);
tools/clang/lib/StaticAnalyzer/Core/ExprEngineCallAndReturn.cpp
  537       SVal VV = *V;
tools/clang/lib/StaticAnalyzer/Core/MemRegion.cpp
 1258           offset = *NewOffset;
 1470   return *cachedOffset;
tools/clang/lib/StaticAnalyzer/Core/ProgramState.cpp
  572     return scan(*X);
  584     return scan(*X);
tools/clang/lib/StaticAnalyzer/Core/RegionStore.cpp
 1055     const RegionStoreManager::SValListTy &Vals = RM.getInterestingValues(*LCS);
 1206       uint64_t UpperOffset = LowerOffset + *NumElements * ElemSize;
 1227             ((*ROffset >= LowerOffset && *ROffset < UpperOffset) ||
 1227             ((*ROffset >= LowerOffset && *ROffset < UpperOffset) ||
 1229               (*ROffset >= LowerOffset || *ROffset < UpperOffset)) ||
 1229               (*ROffset >= LowerOffset || *ROffset < UpperOffset)) ||
 1230              (LowerOffset == UpperOffset && *ROffset == LowerOffset))) {
 1313       const SValListTy &Vals = getInterestingValues(*LCS);
 1622   return *LCV;
 1731                 return *V;
 1791         return *V;
 1809                 return *V;
 1922       return *D;
 1987     return *V;
 1990     return *V;
 2004         return *V;
 2025           return *V;
 2081       const SValListTy &InnerList = getInterestingValues(*InnerLCV);
 2096     return *V;
 2247     SVal V = getBinding(B.asStore(), *MRV, R->getValueType());
 2388     if (Optional<RegionBindingsRef> NewB = tryBindSmallStruct(B, R, RD, *LCV))
 2389       return *NewB;
 2594     const RegionStoreManager::SValListTy &Vals = RM.getInterestingValues(*LCS);
tools/clang/lib/StaticAnalyzer/Core/SValBuilder.cpp
  350       return evalCast(*Val, CE->getType(), SE->getType());
  419       return evalBinOpLL(state, op, *LV, *RV, type);
  419       return evalBinOpLL(state, op, *LV, *RV, type);
  421     return evalBinOpLN(state, op, *LV, rhs.castAs<NonLoc>(), type);
  430     return evalBinOpLN(state, op, *RV, lhs.castAs<NonLoc>(), type);
  548       return evalCastFromLoc(*L, castTy);
tools/clang/lib/StaticAnalyzer/Core/SimpleConstraintManager.cpp
   38     Cond = SVB.evalCast(*LV, SVB.getContext().BoolTy, T).castAs<DefinedSVal>();
tools/clang/lib/StaticAnalyzer/Core/SimpleSValBuilder.cpp
  320     return !State->assume(*DV, false);
  756           lhs = *simplifiedLhsAsNonLoc;
  765         return *V;
  898           lhs.castAs<loc::ConcreteInt>().evalBinOp(BasicVals, op, *rInt);
  900         return evalCastFromNonLoc(*Result, resultTy);
 1031         LeftIndexVal = evalCastFromNonLoc(*LeftIndex, ArrayIndexTy);
 1041         RightIndexVal = evalCastFromNonLoc(*RightIndex, ArrayIndexTy);
 1048         return evalBinOpNN(state, op, *LeftIndex, *RightIndex, resultTy);
 1048         return evalBinOpNN(state, op, *LeftIndex, *RightIndex, resultTy);
 1113         for (const auto &I : *PTMSV)
 1203       return loc::MemRegionVal(MemMgr.getElementRegion(elementType, *indexV,
tools/clang/lib/StaticAnalyzer/Frontend/CheckerRegistry.cpp
  279     EnabledCheckers.set_union(*Deps);
tools/clang/lib/Tooling/Inclusions/HeaderIncludes.cpp
   63                  (!RawIDName || Tok.getRawIdentifier() == *RawIDName);
tools/clang/lib/Tooling/InterpolatingCompilationDatabase.cpp
  196     Type = foldType(*Type);
tools/clang/lib/Tooling/JSONCompilationDatabase.cpp
  427     auto Cmd = CompileCommandRef(Directory, File, *Command, Output);
tools/clang/lib/Tooling/Refactoring/ASTSelectionRequirements.cpp
   27   return std::move(*Selection);
   46   return std::move(*CodeRange);
tools/clang/lib/Tooling/Syntax/Tokens.cpp
  507       consumeEmptyMapping(File, SM.getFileOffset(*EndLoc), ExpandedIndex,
tools/clang/lib/Tooling/Transformer/RewriteRule.cpp
   50     T.Range = *EditRange;
tools/clang/lib/Tooling/Transformer/Stencil.cpp
  187   *Result += *Source;
  211       *Result += *S;
tools/clang/tools/clang-diff/ClangDiff.cpp
  369     printJsonString(OS, *Identifier);
  371     if (QualifiedIdentifier && *Identifier != *QualifiedIdentifier) {
  371     if (QualifiedIdentifier && *Identifier != *QualifiedIdentifier) {
  373       printJsonString(OS, *QualifiedIdentifier);
tools/clang/tools/clang-extdef-mapping/ClangExtDefMapGen.cpp
   97       Index[*LookupName] = CurrentFileName;
tools/clang/tools/clang-offload-bundler/ClangOffloadBundler.cpp
  427         return **TripleOrErr;
  756     StringRef CurTriple = **CurTripleOrErr;
tools/clang/tools/clang-refactor/ClangRefactor.cpp
  155         std::move(*ParsedTestSelection));
  159     return std::make_unique<SourceRangeSelectionArgument>(std::move(*Range));
tools/clang/tools/clang-refactor/TestSupport.cpp
  207         if (!HasResult && ErrorMessage == *CanonicalErrorMessage)
  212         if (HasResult && areChangesSame(*Result, *CanonicalResult))
  230         llvm::errs() << "error '" << *CanonicalErrorMessage << "'\n";
  235         dumpChanges(*CanonicalResult, llvm::errs());
  246       llvm::outs() << *CanonicalErrorMessage << "\n";
  250       if (printRewrittenSources(*CanonicalResult, llvm::outs()))
tools/clang/tools/driver/cc1gen_reproducer_main.cpp
  188     printReproducerInformation(llvm::outs(), InvocationInfo, *Report);
tools/clang/tools/extra/clang-doc/BitcodeReader.cpp
  719   Stream.setBlockInfo(&*BlockInfo);
tools/clang/tools/extra/clang-include-fixer/find-all-symbols/FindAllMacros.cpp
   36     ++FileSymbols[*Symbol].Seen;
   43     ++FileSymbols[*Symbol].Used;
tools/clang/tools/extra/clang-include-fixer/find-all-symbols/FindAllSymbols.cpp
  255     FileSymbols[*Symbol] += Signals;
tools/clang/tools/extra/clang-move/Move.cpp
  560         HasAnySymbolNames ? anyOf(*HasAnySymbolNames, HasName) : HasName;
  568       hasOutermostEnclosingClass(cxxRecordDecl(*HasAnySymbolNames));
  615   auto MovedClass = cxxRecordDecl(InOldFiles, *HasAnySymbolNames,
  622       cxxMethodDecl(InOldFiles, ofOutermostEnclosingClass(*HasAnySymbolNames),
  633   Finder->addMatcher(functionDecl(InOldFiles, *HasAnySymbolNames, TopLevelDecl)
  639       varDecl(InOldFiles, *HasAnySymbolNames, TopLevelDecl).bind("var"),
  646       enumDecl(InOldHeader, *HasAnySymbolNames, isDefinition(), TopLevelDecl)
  656                                InOldHeader, *HasAnySymbolNames, TopLevelDecl),
tools/clang/tools/extra/clang-query/Query.cpp
   93         MaybeBoundMatcher = *M;
tools/clang/tools/extra/clang-query/QueryParser.cpp
  234     return new MatchQuery(MatcherSource, *Matcher);
tools/clang/tools/extra/clang-query/tool/ClangQuery.cpp
  139       QueryRef Q = QueryParser::parse(*Line, QS);
tools/clang/tools/extra/clang-tidy/ClangTidyOptions.cpp
  132     Dest = (Dest && !Dest->empty() ? *Dest + "," : "") + *Src;
  259         CachedOptions[Path] = *Result;
  262       CachedOptions[Path] = *Result;
  264       RawOptions.push_back(*Result);
tools/clang/tools/extra/clang-tidy/abseil/DurationAdditionCheck.cpp
   46   llvm::StringRef TimeFactory = getTimeInverseForScale(*Scale);
   54          rewriteExprFromNumberToDuration(Result, *Scale, Binop->getRHS()) + ")")
   62          rewriteExprFromNumberToDuration(Result, *Scale, Binop->getLHS()) +
tools/clang/tools/extra/clang-tidy/abseil/DurationComparisonCheck.cpp
   45       rewriteExprFromNumberToDuration(Result, *Scale, Binop->getLHS());
   47       rewriteExprFromNumberToDuration(Result, *Scale, Binop->getRHS());
tools/clang/tools/extra/clang-tidy/abseil/DurationConversionCastCheck.cpp
   55     llvm::StringRef NewFuncName = getDurationInverseForScale(*Scale).second;
   70     llvm::StringRef NewFuncName = getDurationInverseForScale(*Scale).first;
tools/clang/tools/extra/clang-tidy/abseil/DurationFactoryFloatCheck.cpp
   65         << FixItHint::CreateReplacement(Arg->getSourceRange(), *SimpleArg);
tools/clang/tools/extra/clang-tidy/abseil/DurationFactoryScaleCheck.cpp
  109     if (std::get<1>(*result) == 1.0)
  110       return std::get<0>(*result);
  111     Multiplier = std::get<1>(*result);
  112     OldScale = std::get<0>(*result);
  167   DurationScale Scale = *MaybeScale;
  212                  (llvm::Twine(getDurationFactoryForScale(*NewScale)) + "(" +
  225                (llvm::Twine(getDurationFactoryForScale(*NewScale)) + "(" +
tools/clang/tools/extra/clang-tidy/abseil/DurationRewriter.cpp
  220     return *MaybeArg;
  225     return *MaybeArg;
  277     return *MaybeRewrite;
  295     return *MaybeRewrite;
tools/clang/tools/extra/clang-tidy/abseil/DurationSubtractionCheck.cpp
   46       rewriteExprFromNumberToDuration(Result, *Scale, Binop->getRHS());
tools/clang/tools/extra/clang-tidy/abseil/FasterStrsplitDelimiterCheck.cpp
  124                                       *Replacement);
tools/clang/tools/extra/clang-tidy/abseil/StringFindStartswithCheck.cpp
  112     Diagnostic << *IncludeHint;
tools/clang/tools/extra/clang-tidy/abseil/TimeComparisonCheck.cpp
   47       rewriteExprFromNumberToTime(Result, *Scale, Binop->getLHS());
   49       rewriteExprFromNumberToTime(Result, *Scale, Binop->getRHS());
tools/clang/tools/extra/clang-tidy/abseil/TimeSubtractionCheck.cpp
  112             callee(functionDecl(hasName(getDurationFactoryForScale(*Scale)))),
  153          rewriteExprFromNumberToTime(Result, *Scale, BinOp->getLHS()) + " - " +
  154          rewriteExprFromNumberToTime(Result, *Scale, BinOp->getRHS()) +
  164                                       getDurationFactoryForScale(*Scale)))))
  178            rewriteExprFromNumberToTime(Result, *Scale, BinOp->getLHS()) +
  180            rewriteExprFromNumberToTime(Result, *Scale, BinOp->getRHS()) +
  189                getDurationInverseForScale(*Scale).second.str().substr(2)) +
  190            "(" + rewriteExprFromNumberToTime(Result, *Scale, BinOp->getLHS()) +
  192            rewriteExprFromNumberToTime(Result, *Scale, BinOp->getRHS()) + ")")
tools/clang/tools/extra/clang-tidy/bugprone/NotNullTerminatedResultCheck.cpp
  690     return hasArgument(*CC.DestinationPos,
  698     return hasArgument(*CC.SourcePos, AnyOfSrcDecl);
  738                    hasArgument(*CC.DestinationPos, anything()));
  742                    hasArgument(*CC.SourcePos, anything()));
tools/clang/tools/extra/clang-tidy/cppcoreguidelines/InitVariablesCheck.cpp
   98         Diagnostic << *IncludeHint;
tools/clang/tools/extra/clang-tidy/google/TodoCommentCheck.cpp
   21       : Check(Check), User(User ? *User : "unknown"),
tools/clang/tools/extra/clang-tidy/google/UpgradeGoogletestCaseCheck.cpp
  111           CharSourceRange::getTokenRange(Loc, Loc), *Replacement);
tools/clang/tools/extra/clang-tidy/modernize/MakeSmartPtrCheck.cpp
  438     Diag << *IncludeFixit;
tools/clang/tools/extra/clang-tidy/modernize/PassByValueCheck.cpp
  229     Diag << *IncludeFixit;
tools/clang/tools/extra/clang-tidy/modernize/ReplaceAutoPtrCheck.cpp
  165       Diag << *Fix;
tools/clang/tools/extra/clang-tidy/modernize/UseTrailingReturnTypeCheck.cpp
  239       ClassifiedTokens.push_back(*CT);
  283   const SmallVector<ClassifiedToken, 8> &Tokens = *MaybeTokens;
  341   for (ClassifiedToken CT : *MaybeTokens) {
tools/clang/tools/extra/clang-tidy/performance/FasterStringFindCheck.cpp
   99              *Replacement);
tools/clang/tools/extra/clang-tidy/performance/ForRangeCopyCheck.cpp
   73   if (!Expensive || !*Expensive)
   90   if (LoopVar.getType().isConstQualified() || !Expensive || !*Expensive)
tools/clang/tools/extra/clang-tidy/performance/TypePromotionInMathFnCheck.cpp
  198       Diag << *IncludeFixit;
tools/clang/tools/extra/clang-tidy/performance/UnnecessaryValueParamCheck.cpp
  207     Diag << *IncludeFixit;
tools/clang/tools/extra/clang-tidy/readability/IdentifierNamingCheck.cpp
  224                       toString(*NamingStyles[i]->Case));
  281   if (Style.Case && !Matchers[static_cast<size_t>(*Style.Case)].match(Name))
  853     const NamingStyle &Style = *NamingStyles[SK];
  890   const NamingStyle &Style = *NamingStyles[SK_MacroDefinition];
tools/clang/tools/extra/clang-tidy/readability/IsolateDeclarationCheck.cpp
  260       *PotentialRanges, *Result.SourceManager, getLangOpts());
  265   std::vector<std::string> NewDecls = createIsolatedDecls(*PotentialSnippets);
tools/clang/tools/extra/clang-tidy/readability/UppercaseLiteralSuffixCheck.cpp
   84   return SourceRange(*Begin, *End);
   84   return SourceRange(*Begin, *End);
  128     ReplacementDsc.LiteralLocation = *Range;
  134       CharSourceRange::getTokenRange(*Range), SM, LO, &Invalid);
  170   if (!NewSuffix || ReplacementDsc.OldSuffix == *NewSuffix)
  174     ReplacementDsc.FixIt = FixItHint::CreateReplacement(*Range, *NewSuffix);
  174     ReplacementDsc.FixIt = FixItHint::CreateReplacement(*Range, *NewSuffix);
  226       Complaint << *(Details->FixIt);
tools/clang/tools/extra/clang-tidy/tool/ClangTidyMain.cpp
  380         if (It->first.Checks && GlobList(*It->first.Checks).contains(Check)) {
tools/clang/tools/extra/clang-tidy/utils/LexerUtils.h
   70     Token PotentialMatch = *CurrentToken;
tools/clang/tools/extra/clang-tidy/utils/Matchers.h
   36   return IsExpensive && *IsExpensive;
tools/clang/tools/extra/clang-tidy/utils/TransformerClangTidyCheck.cpp
   65     for (auto &Matcher : tooling::detail::buildMatchers(*Rule))
   75   RewriteRule::Case Case = tooling::detail::findSelectedCase(Result, *Rule);
  106       Diag << *Fix;
tools/clang/tools/extra/clangd/AST.cpp
  168     printTemplateArgumentList(OS, *Args, Policy);
tools/clang/tools/extra/clangd/ClangdLSPServer.cpp
  117       if (!It.second.canApplyTo(*Draft)) {
  209         if (ReplyCallbacks[Index].first == *IntID) {
  498                                  *NegotiatedOffsetEncoding);
  499     Server.emplace(*CDB, FSProvider, static_cast<DiagnosticsConsumer &>(*this),
  581     Result["offsetEncoding"] = *NegotiatedOffsetEncoding;
  659                                      ? *Response->failureReason
  689                    File = Params.tweakArgs->file, Code = std::move(*Code)](
  699         Msg.message = *R->ShowMessage;
  713         (*WE.changes)[URI::createFile(It.first()).toString()] =
  806   Reply(Server->formatOnType(*Code, File, Params.position, Params.ch));
  819   auto ReplacementsOrError = Server->formatRange(*Code, File, Params.range);
  821     Reply(replacementsToEdits(*Code, ReplacementsOrError.get()));
  836   auto ReplacementsOrError = Server->formatFile(*Code, File);
  838     Reply(replacementsToEdits(*Code, ReplacementsOrError.get()));
  853         SI.containerName = ParentName ? "" : *ParentName;
  923       [Reply = std::move(Reply), File, Code = std::move(*Code),
  939             Commands.push_back(std::move(*Command));
 1000   if (!Sym.Definition || *Sym.Definition == Sym.PreferredDeclaration)
 1007     return &*Sym.Definition;
 1058           return Reply(URIForFile::canonicalize(**Path, Params.uri.file()));
 1283   auto Offset = positionToOffset(*Code, Params.position,
 1294     return (*Code)[*Offset - 2] == '-'; // trigger only on '->'.
 1296     return (*Code)[*Offset - 2] == ':'; // trigger only on '::'.
tools/clang/tools/extra/clangd/ClangdServer.cpp
  325       return CB(*Range);
tools/clang/tools/extra/clangd/CodeComplete.cpp
  334           std::move(*Spelled),
  536           (AS + (UnresolvedQualifier ? *UnresolvedQualifier : "")).str());
  596     *Scopes.UnresolvedQualifier += "::";
  903           SS.IDForDoc ? FetchedDocs.find(*SS.IDForDoc) : FetchedDocs.end();
 1135   NestedNameSpecifier *NameSpec = (*Scope)->getScopeRep();
 1252           *SpecFuzzyFind->CachedReq, HeuristicPrefix);
 1253       SpecFuzzyFind->Result = startAsyncFuzzyFind(*Opts.Index, *SpecReq);
 1493     if (SpecFuzzyFind && SpecFuzzyFind->Result.valid() && (*SpecReq == Req)) {
 1555         auto I = IndexResults.find(*SymID);
 1609       Relevance.NameMatch = *FuzzyScore;
 1676                         Item, SemaCCS, QueryScopes, *Inserter, FileName,
tools/clang/tools/extra/clangd/CollectMacros.h
   84       Out.Ranges.push_back(*Range);
tools/clang/tools/extra/clangd/Diagnostics.cpp
  316   (*Action.edit->changes)[File.uri()] = {F.Edits.begin(), F.Edits.end()};
  506     fillNonLocationData(DiagLevel, Info, *LastDiag);
  526     D.Range = diagnosticRange(Info, *LangOpts);
  548       Edits.push_back(toTextEdit(FixIt, SM, *LangOpts));
  557           Lexer::getSourceText(FixIt.RemoveRange, SM, *LangOpts, &Invalid);
  601     FillDiagBase(*LastDiag);
  603       LastDiagWasAdjusted = adjustDiagFromHeader(*LastDiag, Info, *LangOpts);
  603       LastDiagWasAdjusted = adjustDiagFromHeader(*LastDiag, Info, *LangOpts);
  645   if (mentionsMainFile(*LastDiag) &&
  649     Output.push_back(std::move(*LastDiag));
tools/clang/tools/extra/clangd/ExpectedTypes.cpp
   94   return encode(Ctx, *T);
tools/clang/tools/extra/clangd/FS.cpp
  104         return *S;
tools/clang/tools/extra/clangd/FindSymbols.cpp
   89       Req.Limit ? *Req.Limit : std::numeric_limits<size_t>::max());
  111       Relevance.NameMatch = *NameMatch;
  209     Results.push_back(std::move(*Sym));
tools/clang/tools/extra/clangd/FindTarget.cpp
  576   return {*V.Ref};
tools/clang/tools/extra/clangd/FormattedString.cpp
  153     if (LastWasBlock.hasValue() && (IsBlock || *LastWasBlock))
tools/clang/tools/extra/clangd/GlobalCompilationDatabase.cpp
  267     : Base(Base), ResourceDir(ResourceDir ? std::move(*ResourceDir)
  289   adjustArguments(*Cmd, ResourceDir);
  312       Commands[CanonPath] = std::move(*Cmd);
tools/clang/tools/extra/clangd/HeaderSourceSwitch.cpp
   82       Request.IDs.insert(*ID);
tools/clang/tools/extra/clangd/Headers.cpp
  224     Edit = replacementToEdit(Code, *Insertion);
tools/clang/tools/extra/clangd/IncludeFixer.cpp
  130   llvm::Optional<const SymbolSlab *> Symbols = lookupCached(*ID);
  133   const SymbolSlab &Syms = **Symbols;
  159         std::move(*Spelled),
  179                     {std::move(*Edit)}});
  286       auto Split = splitQualifiedName(*QualifiedByUnresolved);
  356       Unresolved.Scopes.push_back(*Extracted->ResolvedScope);
  363         Scope += *Extracted->UnresolvedScope;
  398     return fixesForSymbols(**Syms);
tools/clang/tools/extra/clangd/JSONTransport.cpp
   37     return llvm::make_error<LSPError>(std::move(Msg), ErrorCode(*Code));
   88         if (auto Doc = llvm::json::parse(*JSON)) {
   94           vlog("<<< {0}\n", *JSON);
  151       return Handler.onReply(std::move(*ID), decodeError(*Err));
  156     return Handler.onReply(std::move(*ID), std::move(Result));
  164     return Handler.onCall(*Method, std::move(Params), std::move(*ID));
  164     return Handler.onCall(*Method, std::move(Params), std::move(*ID));
  166     return Handler.onNotify(*Method, std::move(Params));
tools/clang/tools/extra/clangd/ParsedAST.cpp
  293                                       DiagLevel, Info, *CTContext,
tools/clang/tools/extra/clangd/Protocol.cpp
   55     auto Parsed = URI::parse(*S);
   57       elog("Failed to parse URI {0}: {1}", *S, Parsed.takeError());
   62            *S);
  161     if (*S == "off") {
  164     } else if (*S == "messages") {
  167     } else if (*S == "verbose") {
  177     if (*T < static_cast<int>(SymbolKind::File) ||
  178         *T > static_cast<int>(SymbolKind::TypeParameter))
  180     Out = static_cast<SymbolKind>(*T);
  280         R.SemanticHighlighting = *SemanticHighlightingSupport;
  284         R.DiagnosticCategory = *CategorySupport;
  286         R.DiagnosticFixes = *CodeActions;
  288         R.DiagnosticRelatedInformation = *RelatedInfo;
  293           R.CompletionSnippets = *SnippetSupport;
  298           if (!fromJSON(*ValueSet, *R.CompletionItemKinds))
  303         R.CompletionFixes = *EditsNearCursor;
  312         R.HierarchicalDocumentSymbol = *HierarchicalSupport;
  330             R.OffsetsInSignatureHelp = *OffsetSupport;
  336         R.RenamePrepareSupport = *RenameSupport;
  344           if (!fromJSON(*ValueSet, *R.WorkspaceSymbolKinds))
  352     if (!fromJSON(*OffsetEncoding, *R.offsetEncoding))
  400     if (*T < static_cast<int>(FileChangeType::Created) ||
  401         *T > static_cast<int>(FileChangeType::Deleted))
  403     Out = static_cast<FileChangeType>(*T);
  727   if (*Str == "plaintext")
  729   else if (*Str == "markdown")
  732     elog("Unknown markup kind: {0}", *Str);
  763     if (*T < static_cast<int>(CompletionItemKind::Text) ||
  764         *T > static_cast<int>(CompletionItemKind::TypeParameter))
  766     Out = static_cast<CompletionItemKind>(*T);
  959   if (*T < static_cast<int>(TypeHierarchyDirection::Children) ||
  960       *T > static_cast<int>(TypeHierarchyDirection::Both))
  962   Out = static_cast<TypeHierarchyDirection>(*T);
 1048   OE = llvm::StringSwitch<OffsetEncoding>(*Str)
tools/clang/tools/extra/clangd/Quality.cpp
  332   auto D = Distance.distance(*SymbolScope);
tools/clang/tools/extra/clangd/QueryDriverDatabase.cpp
  254     return addSystemIncludes(*Cmd, SystemIncludes);
tools/clang/tools/extra/clangd/SemanticHighlighting.cpp
  221       addToken(L.getBeginLoc(), *K);
  227       addToken(L.getBeginLoc(), *K);
  266     addToken(D->getTypeSpecStartLoc(), *K);
  302       addToken(Loc, *K);
tools/clang/tools/extra/clangd/TUScheduler.cpp
  386       Inputs.CompileCommand = *Cmd;
  491       AST = NewAST ? std::make_unique<ParsedAST>(std::move(*NewAST)) : nullptr;
  492       if (!(*AST)) { // buildAST fails.
  508     if (*AST) {
  511       Callbacks.onMainAST(FileName, **AST, RunPublish);
  521     IdleASTs.put(this, std::move(*AST));
  546       AST = NewAST ? std::make_unique<ParsedAST>(std::move(*NewAST)) : nullptr;
  550         [&AST, this]() { IdleASTs.put(this, std::move(*AST)); });
  552     if (!*AST)
  555     Action(InputsAndAST{*CurrentInputs, **AST});
  681           SPAN_ATTACH(*Tracer, "next_request", Requests.front().Name);
  684             SPAN_ATTACH(*Tracer, "sleep_ms",
  772   switch (*UpdateType) {
tools/clang/tools/extra/clangd/Threading.cpp
  104          duration_cast<steady_clock::duration>(duration<double>(*Seconds));
tools/clang/tools/extra/clangd/XRefs.cpp
  229     L.uri = URIForFile::canonicalize(*FilePath, TUPath);
  230     L.range = *Range;
  254           URIForFile::canonicalize(Inc.Resolved, *MainFilePath), Range{}};
  270                                 M->Info->getDefinitionLoc(), *MainFilePath)) {
  273       Macro.PreferredDeclaration = *Loc;
  292                      *MainFilePath);
  299     Result.back().PreferredDeclaration = *Loc;
  302       Result.back().Definition = *Loc;
  306       ResultIndex[*ID] = Result.size() - 1;
  321         if (auto Loc = toLSPLocation(Sym.CanonicalDeclaration, *MainFilePath))
  322           R.PreferredDeclaration = *Loc;
  327                 getPreferredLocation(*R.Definition, Sym.Definition, Scratch),
  328                 *MainFilePath))
  329           R.Definition = *Loc;
  331         R.Definition = toLSPLocation(Sym.Definition, *MainFilePath);
  337                 *MainFilePath))
  338           R.PreferredDeclaration = *Loc;
  430       DH.range = *Range;
  528         *P.Type += "...";
  538       llvm::raw_string_ostream Out(*P.Type);
  545         llvm::raw_string_ostream Out(*P.Default);
  549       llvm::raw_string_ostream OS(*P.Type);
  560         llvm::raw_string_ostream Out(*P.Default);
  606   Req.IDs.insert(*ID);
  648       llvm::raw_string_ostream OS(*HI.ReturnType);
  658         llvm::raw_string_ostream OS(*P.Type);
  671         llvm::raw_string_ostream Out(*P.Default);
  677     llvm::raw_string_ostream TypeOS(*HI.Type);
  687     llvm::raw_string_ostream OS(*HI.Type);
  699         llvm::raw_string_ostream ValueOS(*HI.Value);
  891     HI = getHoverContents(*M, AST);
  951       Result.range = *Range;
  952       Result.uri = URIForFile::canonicalize(*MainFilePath, *MainFilePath);
  952       Result.uri = URIForFile::canonicalize(*MainFilePath, *MainFilePath);
  969         Req.IDs.insert(*ID);
  974       auto LSPLoc = toLSPLocation(R.Location, *MainFilePath);
  976       if (LSPLoc && LSPLoc->uri.file() != *MainFilePath)
  977         Results.push_back(std::move(*LSPLoc));
 1078   THI.uri = URIForFile::canonicalize(*FilePath, *TUPath);
 1078   THI.uri = URIForFile::canonicalize(*FilePath, *TUPath);
 1119         fillSubTypes(Object.ID, *ChildSym->children, Index, Levels - 1, TUPath);
 1121       SubTypes.emplace_back(std::move(*ChildSym));
 1147       fillSuperTypes(*ParentDecl, ASTCtx, *ParentSym->parents, RPSet);
 1148       SuperTypes.emplace_back(std::move(*ParentSym));
 1232     fillSuperTypes(*CXXRD, AST.getASTContext(), *Result->parents, RPSet);
 1242         fillSubTypes(*ID, *Result->children, Index, ResolveLevels, TUPath);
 1242         fillSubTypes(*ID, *Result->children, Index, ResolveLevels, TUPath);
 1262     if (Expected<SymbolID> ID = SymbolID::fromStr(*Item.data)) {
 1263       fillSubTypes(*ID, *Item.children, Index, ResolveLevels, Item.uri.file());
tools/clang/tools/extra/clangd/index/Background.cpp
  232   for (const auto &IndexIt : *Index.Sources) {
  246   for (const auto &Sym : *Index.Symbols) {
  268   for (const auto &SymRefs : *Index.Refs) {
  279   for (const auto &Rel : *Index.Relations) {
  391     auto D = ShardVersionsSnapshot.find(*AbsPath);
  434     for (auto &It : *Index.Sources)
  463               ? std::make_unique<SymbolSlab>(std::move(*LS.Shard->Symbols))
  466                     ? std::make_unique<RefSlab>(std::move(*LS.Shard->Refs))
  470               ? std::make_unique<RelationSlab>(std::move(*LS.Shard->Relations))
  506     NeedsReIndexing.emplace_back(std::move(*Cmd));
tools/clang/tools/extra/clangd/index/BackgroundIndexLoader.cpp
   71   for (const auto &It : *LS.Shard->Sources) {
tools/clang/tools/extra/clangd/index/IndexAction.cpp
   66     auto I = IG.try_emplace(*URI).first;
   73       assert(Digest && Node.Digest == *Digest &&
   79       Node.Digest = std::move(*Digest);
  100     auto NodeForInclude = IG.try_emplace(*IncludeURI).first->getKey();
  101     auto NodeForIncluding = IG.try_emplace(*IncludingURI);
  113     auto I = IG.try_emplace(*URI);
tools/clang/tools/extra/clangd/index/MemIndex.cpp
   50       if (Top.push({*Score * quality(*Sym), Sym}))
tools/clang/tools/extra/clangd/index/Serialization.cpp
  679         Symbols = std::move(*I->Symbols);
  681         Refs = std::move(*I->Refs);
  683         Relations = std::move(*I->Relations);
tools/clang/tools/extra/clangd/index/SymbolCollector.cpp
   61       AbsolutePath = *CanonPath;
  292   processRelations(*ND, *ID, Relations);
  327   const Symbol *BasicSymbol = Symbols.find(*ID);
  329     BasicSymbol = addDeclaration(*ND, std::move(*ID), IsMainFileOnly);
  335     BasicSymbol = addDeclaration(*OriginalDecl, std::move(*ID), IsMainFileOnly);
  385   if (Symbols.find(*ID) != nullptr)
  389   S.ID = std::move(*ID);
  401     S.CanonicalDeclaration = *DeclLoc;
  444     this->Relations.insert(Relation{ID, RelationKind::BaseOf, *ObjectID});
  468       IncRef(*ID);
  478             Symbols.erase(*ID);
  484           IncRef(*ID);
  498         NewSym.IncludeHeaders.push_back({*Header, 1});
  536             Refs.insert(*ID, R);
  580     S.CanonicalDeclaration = *DeclLoc;
  640     S.Definition = *DefLoc;
tools/clang/tools/extra/clangd/index/YAMLSerialization.cpp
  316       MappingTraits<Symbol>::mapping(IO, *Variant.Symbol);
  320       MappingTraits<RefBundle>::mapping(IO, *Variant.Refs);
  324       MappingTraits<Relation>::mapping(IO, *Variant.Relation);
  372       Symbols.insert(*Variant.Symbol);
  377       Relations.insert(*Variant.Relation);
tools/clang/tools/extra/clangd/index/dex/PostingList.cpp
  213     Delta = *MaybeDelta;
tools/clang/tools/extra/clangd/index/dex/dexp/Dexp.cpp
  298     llvm::StringRef(*Request).split(Args, '\0', /*MaxSplit=*/-1,
tools/clang/tools/extra/clangd/refactor/Rename.cpp
   50     Req.IDs.insert(*ID);
   56       if (*RefFilePath != MainFile)
   57         OtherFile = *RefFilePath;
  179     return makeError(*Reject);
tools/clang/tools/extra/clangd/refactor/Tweak.cpp
   97     return std::make_pair(*FilePath, std::move(Ed));
tools/clang/tools/extra/clangd/refactor/tweaks/DefineInline.cpp
  339     const tooling::Replacement SemicolonToFuncBody(SM, *Semicolon, 1,
  357     auto FE = Effect::fileEdit(SM, SM.getFileID(*Semicolon),
tools/clang/tools/extra/clangd/refactor/tweaks/ExpandAutoType.cpp
   85   if (isa<RecordType>(*DeducedType) &&
   86       dyn_cast<RecordType>(*DeducedType)->getDecl()->isLambda()) {
   99   std::string PrettyTypeName = printType(*DeducedType,
tools/clang/tools/extra/clangd/refactor/tweaks/ExpandMacro.cpp
  102   this->Expansion = *Expansion;
tools/clang/tools/extra/clangd/refactor/tweaks/ExtractFunction.cpp
  263     ExtZone.EnclosingFuncRange = *FuncRange;
  265     ExtZone.ZoneRange = *ZoneRange;
  650     ExtZone = std::move(*MaybeExtZone);
tools/clang/tools/extra/clangd/refactor/tweaks/SwapIfBranches.cpp
   81   auto ThenCode = toSourceCode(SrcMgr, *ThenRng);
   82   auto ElseCode = toSourceCode(SrcMgr, *ElseRng);
tools/clang/tools/extra/clangd/tool/ClangdMain.cpp
  514       Tracer = trace::createJSONTracer(*TraceStream, PrettyPrint);
  544     log("{0}: {1}", FlagsEnvVar, *EnvFlags);
tools/clang/tools/extra/clangd/unittests/BackgroundIndexTests.cpp
  223       *ShardHeader->Symbols,
  226   for (const auto &Ref : *ShardHeader->Refs)
  232   EXPECT_THAT(*ShardSource->Symbols,
  234   for (const auto &Ref : *ShardSource->Refs)
  240   SymbolID A = findSymbol(*ShardHeader->Symbols, "A_CC").ID;
  241   SymbolID B = findSymbol(*ShardSource->Symbols, "B_CC").ID;
  242   EXPECT_THAT(*ShardHeader->Relations,
  345   EXPECT_THAT(*ShardHeader->Symbols, Contains(Named("A_CCnew")));
  363   EXPECT_THAT(*ShardHeader->Symbols, Contains(Named("A_CCnew")));
  366   EXPECT_THAT(*ShardSource->Symbols,
  434   EXPECT_THAT(*ShardHeader->Symbols,
  498     EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre(Named("foo")));
  507     EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre(Named("foo")));
  515     EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre(Named("asdf")));
  523     EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre());
  554     tooling::CompileCommand CmdStored = *MSS.loadShard(testPath("A.cc"))->Cmd;
  568     tooling::CompileCommand CmdStored = *MSS.loadShard(testPath("A.cc"))->Cmd;
tools/clang/tools/extra/clangd/unittests/DexTests.cpp
  503   EXPECT_EQ(Matches.size(), *Req.Limit);
tools/clang/tools/extra/clangd/unittests/DraftStoreTests.cpp
  342   EXPECT_EQ(*Contents, OriginalContents);
tools/clang/tools/extra/clangd/unittests/ExpectedTypeTest.cpp
   35   const NamedDecl *decl(llvm::StringRef Name) { return &findDecl(*AST, Name); }
tools/clang/tools/extra/clangd/unittests/FuzzyMatchTests.cpp
   68            (!Score || ::testing::Value(*Result, ::testing::FloatEq(*Score)));
  220         } else if (LastScore && *LastScore < *Score) {
  220         } else if (LastScore && *LastScore < *Score) {
  221           *OS << "\nRanks '" << Str.Word << "'=" << *Score << " above '"
  222               << LastMatch->Word << "'=" << *LastScore << "\n"
tools/clang/tools/extra/clangd/unittests/HeadersTests.cpp
   47     PI.CompileCommand = *Cmd;
tools/clang/tools/extra/clangd/unittests/IndexActionTests.cpp
  124   auto Nodes = toMap(*IndexFile.Sources);
  153   auto Nodes = toMap(*IndexFile.Sources);
  188   auto Nodes = toMap(*IndexFile.Sources);
  220   auto Nodes = toMap(*IndexFile.Sources);
  250   EXPECT_THAT(*IndexFile.Symbols, ElementsAre(HasName("foo"), HasName("bar")));
tools/clang/tools/extra/clangd/unittests/IndexTests.cpp
  144   EXPECT_EQ(Matches.size(), *Req.Limit);
tools/clang/tools/extra/clangd/unittests/SerializationTests.cpp
  114       *ParsedYAML->Symbols,
  145       *ParsedYAML->Refs,
  156       *ParsedYAML->Relations,
  196   EXPECT_THAT(YAMLFromSymbols(*In2->Symbols),
  197               UnorderedElementsAreArray(YAMLFromSymbols(*In->Symbols)));
  198   EXPECT_THAT(YAMLFromRefs(*In2->Refs),
  199               UnorderedElementsAreArray(YAMLFromRefs(*In->Refs)));
  200   EXPECT_THAT(YAMLFromRelations(*In2->Relations),
  201               UnorderedElementsAreArray(YAMLFromRelations(*In->Relations)));
  231     EXPECT_THAT(YAMLFromSymbols(*In->Symbols),
  232                 UnorderedElementsAreArray(YAMLFromSymbols(*In->Symbols)));
  233     EXPECT_THAT(YAMLFromRefs(*In->Refs),
  234                 UnorderedElementsAreArray(YAMLFromRefs(*In->Refs)));
tools/clang/tools/extra/clangd/unittests/SourceCodeTests.cpp
  489   EXPECT_THAT(*Result, MacroName("MACRO"));
  563     Range HalfOpenRange = SourceRangeToRange(*FileRange);
tools/clang/tools/extra/clangd/unittests/SymbolCollectorTests.cpp
  126         Qualified ? findDecl(*AST, Name) : findUnqualifiedDecl(*AST, Name);
  126         Qualified ? findDecl(*AST, Name) : findUnqualifiedDecl(*AST, Name);
tools/clang/tools/extra/clangd/unittests/SyncAPI.cpp
   75   return std::move(*Result);
   82   return std::move(*Result);
   89   return std::move(*Result);
   96   return std::move(*Result);
  104   return std::move(*Result);
  110   return std::move(*Result);
  117   return std::move(*Result);
  124   return std::move(*Result);
  152   return std::move(*Result);
  159   return std::move(*Result);
tools/clang/tools/extra/clangd/unittests/TestTU.cpp
   78   return std::move(*AST);
tools/clang/tools/extra/clangd/unittests/TweakTesting.cpp
  110     return "message:\n" + *Result->ShowMessage;
tools/clang/tools/extra/clangd/unittests/TypeHierarchyTests.cpp
  378         *Result,
  417       *Result,
  449       *Result,
  457       *Result,
  632       *Result,
  638   resolveTypeHierarchy((*Result->children)[0], /*ResolveLevels=*/1,
  642       (*Result->children)[0],
tools/clang/tools/extra/clangd/unittests/XRefsTests.cpp
  129   if (Def && arg.Definition->range != *Def) {
  479       EXPECT_EQ(Results[0].PreferredDeclaration.range, *WantDecl) << Test;
tools/clang/tools/extra/unittests/clang-tidy/ClangTidyOptionsTest.cpp
   64   EXPECT_EQ("-*,misc-*", *Options->Checks);
   65   EXPECT_EQ(".*", *Options->HeaderFilterRegex);
   66   EXPECT_EQ("some.user", *Options->User);
   89   EXPECT_EQ("check1,check2,check3,check4", *Options.Checks);
   90   EXPECT_EQ("filter2", *Options.HeaderFilterRegex);
   91   EXPECT_EQ("user2", *Options.User);
tools/clang/tools/extra/unittests/clang-tidy/IncludeInserterTest.cpp
   52         Diag << *Fixit;
tools/clang/tools/extra/unittests/clang-tidy/LLVMModuleTest.cpp
   21   if (ExpectedWarning && *ExpectedWarning != Errors.back().Message.Message)
   43   if (ExpectedWarning && *ExpectedWarning != Errors.back().Message.Message)
tools/clang/tools/libclang/CIndex.cpp
 7822     Out.Minor = *Minor;
 7828     Out.Subminor = *Subminor;
tools/clang/tools/libclang/CXType.cpp
 1310     switch (*nullability) {
tools/clang/unittests/AST/ASTImporterTest.cpp
 3287     EXPECT_EQ(*ToIndex, FromIndex);
tools/clang/unittests/AST/ASTPrint.h
   30     (*PolicyAdjuster)(Policy);
tools/clang/unittests/ASTMatchers/Dynamic/RegistryTest.cpp
   48       Out = Registry::constructMatcher(*Ctor, SourceRange(), Args(), Error);
   61       Out = Registry::constructMatcher(*Ctor, SourceRange(), Args(Arg1), Error);
   75       Out = Registry::constructMatcher(*Ctor, SourceRange(), Args(Arg1, Arg2),
   94     Context.push_back(std::make_pair(*Ctor, ArgNo1));
  105     Context.push_back(std::make_pair(*Ctor, ArgNo1));
  109     Context.push_back(std::make_pair(*Ctor, ArgNo2));
tools/clang/unittests/CrossTU/CrossTranslationUnitTest.cpp
   93           SourceLocation OrigSLoc = (*SLocResult).first;
   94           ASTUnit *OrigUnit = (*SLocResult).second;
tools/clang/unittests/Lex/HeaderSearchTest.cpp
   44     auto DL = DirectoryLookup(*DE, SrcMgr::C_User, /*isFramework=*/false);
tools/clang/unittests/Lex/LexerTest.cpp
  553     GeneratedByNextToken.push_back(getSourceText(*T, *T));
  553     GeneratedByNextToken.push_back(getSourceText(*T, *T));
tools/clang/unittests/Lex/PPCallbacksTest.cpp
  149     DirectoryLookup DL(*DE, SrcMgr::C_User, false);
tools/clang/unittests/Tooling/ASTSelectionTest.cpp
  160         checkNode<TranslationUnitDecl>(*Node, SourceSelectionKind::None,
  695             CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
  703             CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
  712             CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
  721             CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
  724         EXPECT_TRUE(isa<DeclStmt>((*SelectedCode)[0]));
  741             CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
  744         EXPECT_TRUE(isa<CallExpr>((*SelectedCode)[0]));
  745         EXPECT_TRUE(isa<IfStmt>((*SelectedCode)[1]));
  762             CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
  765         EXPECT_TRUE(isa<CallExpr>((*SelectedCode)[0]));
  766         EXPECT_TRUE(isa<IfStmt>((*SelectedCode)[1]));
  767         EXPECT_TRUE(isa<BinaryOperator>((*SelectedCode)[2]));
  776             CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
  779         EXPECT_TRUE(isa<DeclStmt>((*SelectedCode)[0]));
  780         EXPECT_TRUE(isa<CallExpr>((*SelectedCode)[1]));
  781         EXPECT_TRUE(isa<IfStmt>((*SelectedCode)[2]));
  782         EXPECT_TRUE(isa<BinaryOperator>((*SelectedCode)[3]));
  796             CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
  799         EXPECT_TRUE(isa<BinaryOperator>((*SelectedCode)[0]));
  824             CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
  827         EXPECT_TRUE(isa<DeclStmt>((*SelectedCode)[0]));
  854             CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
  857         EXPECT_TRUE(isa<DeclStmt>((*SelectedCode)[0]));
  882             CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
  885         EXPECT_TRUE(isa<DeclStmt>((*SelectedCode)[0]));
  921             CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
  931             CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
  934         EXPECT_TRUE(isa<DeclStmt>((*SelectedCode)[0]));
  954             CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
  957         EXPECT_TRUE(isa<ObjCMessageExpr>((*SelectedCode)[0]));
  958         EXPECT_TRUE(isa<IfStmt>((*SelectedCode)[1]));
  986             CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
  989         EXPECT_TRUE(isa<ObjCStringLiteral>((*SelectedCode)[0]));
  998             CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
 1001         EXPECT_TRUE(isa<ObjCStringLiteral>((*SelectedCode)[0]));
 1029             CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
 1032         EXPECT_TRUE(isa<CXXMemberCallExpr>((*SelectedCode)[0]));
 1040             CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
 1043         EXPECT_TRUE(isa<CXXMemberCallExpr>((*SelectedCode)[0]));
 1051             CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
 1054         EXPECT_FALSE(isa<CXXMemberCallExpr>((*SelectedCode)[0]));
 1073             CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
 1076         EXPECT_TRUE(isa<CallExpr>((*SelectedCode)[0]));
tools/clang/unittests/Tooling/HeaderIncludesTest.cpp
   29     auto Result = applyAllReplacements(Code, Replacements(*R));
tools/clang/unittests/Tooling/RefactoringActionRulesTest.cpp
   55   return std::move(*C.Result);
  230   SymbolOccurrences Occurrences = std::move(*Result);
tools/clang/unittests/Tooling/Syntax/TokensTest.cpp
  104         Result = std::move(*Collector).consume();
tools/dsymutil/CompileUnit.cpp
   59           (*Block)[0] == dwarf::DW_OP_addr)
tools/dsymutil/CompileUnit.h
   91       HasODR = CanUseODR && (*Lang == dwarf::DW_LANG_C_plus_plus ||
   92                              *Lang == dwarf::DW_LANG_C_plus_plus_03 ||
   93                              *Lang == dwarf::DW_LANG_C_plus_plus_11 ||
   94                              *Lang == dwarf::DW_LANG_C_plus_plus_14 ||
   95                              *Lang == dwarf::DW_LANG_ObjC_plus_plus);
tools/dsymutil/DebugMap.cpp
   52     AddressToMapping[*ObjectAddress] = &*InsertResult.first;
  275       ObjAddress = *Mapping.ObjectAddress;
tools/dsymutil/DebugMap.h
  148         ObjectAddress = *ObjectAddr;
tools/dsymutil/DwarfLinker.cpp
  266       auto &Entry = ParseableSwiftInterfaces[*Name];
  276                 *Name + ": " + Entry + " and " + Path,
  644       getAttributeOffsets(Abbrev, *LocationIdx, Offset, OrigUnit);
  684       getAttributeOffsets(Abbrev, *LowPcIdx, Offset, OrigUnit);
  701     if (Unit.hasLabelAt(*LowPc))
  710     Unit.addLabelLowPc(*LowPc, MyInfo.AddrAdjust);
  716   Optional<uint64_t> HighPc = DIE.getHighPC(*LowPc);
  724   Ranges[*LowPc] = DebugMapObjectRange(*HighPc, MyInfo.AddrAdjust);
  724   Ranges[*LowPc] = DebugMapObjectRange(*HighPc, MyInfo.AddrAdjust);
  725   Unit.addFunctionRange(*LowPc, *HighPc, MyInfo.AddrAdjust);
  725   Unit.addFunctionRange(*LowPc, *HighPc, MyInfo.AddrAdjust);
 1279       Value = *OptionalValue;
 1281       Value = *OptionalValue;
 1283       Value = *OptionalValue;
 1308     Value = *OptionalValue;
 1823   uint64_t StmtOffset = *StmtList;
 1931     uint32_t PrologueEnd = *StmtList + 10 + LineTable.Prologue.PrologueLength;
 1942                                    LineData.slice(*StmtList + 4, PrologueEnd),
 2126             resolveDIEReference(Linker, DMO, CompileUnits, *Ref, DIE, RefCU)) {
 2154     return *DwoId;
tools/dsymutil/DwarfStreamer.cpp
  411     UnitPcOffset = int64_t(*OrigLowPc) - Unit.getLowPc();
tools/lld/COFF/DebugTypes.cpp
  183   auto it = TypeServerSource::instances.find(*p);
  192         *p, createStringError(inconvertibleErrorCode(), pdb.first.c_str()));
  226       *p, std::pair<std::string, TypeServerSource *>{});
  230   driver->enqueuePath(*p, false, false);
tools/lld/COFF/Driver.cpp
  368         enqueuePath(*path, false, false);
  438     bool seen = !visitedFiles.insert(*id).second;
  488     if (!visitedFiles.insert(*id).second)
  498   StringRef env = saver.save(*envOpt);
 1054       exporter.addWholeArchive(*path);
 1156         TarWriter::create(*path, sys::path::stem(*path));
 1156         TarWriter::create(*path, sys::path::stem(*path));
 1161       error("/linkrepro: failed to open " + *path + ": " +
 1560       if (Optional<sys::fs::UniqueID> id = getUniqueID(*path))
 1561         wholeArchives.insert(*id);
 1571       return wholeArchives.count(*id);
 1593         enqueuePath(*path, true, inLib);
 1597         enqueuePath(*path, isWholeArchive(*path), inLib);
 1597         enqueuePath(*path, isWholeArchive(*path), inLib);
 1609       enqueuePath(*path, false, false);
tools/lld/COFF/DriverUtils.cpp
  894     std::vector<const char *> v = tokenize(*s);
  898     std::vector<const char *> v = tokenize(*s);
tools/lld/COFF/InputFiles.cpp
  425       symbols[i] = *optSym;
tools/lld/COFF/PDB.cpp
  373   CVTypeArray &types = *file->debugTypes;
  398       hashes = getHashesFromDebugH(*debugH);
 1817             exitOnErr(getFileName(cVStrTab, checksums, *nameIndex));
 1818         return std::make_pair(filename, *lineNumber);
 1826   StringRef filename = exitOnErr(getFileName(cVStrTab, checksums, *nameIndex));
 1827   return std::make_pair(filename, *lineNumber);
tools/lld/COFF/SymbolTable.cpp
  117   const DILineInfo &lineInfo = *optionalLineInfo;
  156         locations.push_back({sym, *fileLine});
tools/lld/COFF/Writer.cpp
 1163           outputSymtab.push_back(*sym);
tools/lld/ELF/Driver.cpp
  195   MemoryBufferRef mbref = *buffer;
  275     addFile(*path, /*withLOption=*/true);
 1037       config->symbolOrderingFile = getSymbolOrderingFile(*buffer);
 1055       for (StringRef s : args::getLines(*buffer))
 1066         readDynamicList(*buffer);
 1082       if (Optional<MemoryBufferRef> buffer = readFile(*path))
 1083         readVersionScript(*buffer);
 1172         if (Optional<MemoryBufferRef> mb = readFile(*path))
 1173           readLinkerScript(*mb);
 1203         files.push_back(createObjectFile(*mb));
 1968         readCallGraph(*buffer);
tools/lld/ELF/InputFiles.cpp
  490     driver->addFile(*s, /*withLOption=*/true);
  492     driver->addFile(*s, /*withLOption=*/true);
tools/lld/ELF/LTO.cpp
   80     c.RelocModel = *relocModel;
tools/lld/ELF/LinkerScript.cpp
 1198       ret.push_back(*idx);
tools/lld/ELF/OutputSections.cpp
  485     return *filler;
tools/lld/ELF/Relocations.cpp
   86     msg += *loc;
tools/lld/ELF/ScriptParser.cpp
  302       driver->addFile(saver.save(*path), /*withLOption=*/true);
  350     if (Optional<MemoryBufferRef> mb = readFile(*path))
  351       tokenize(*mb);
 1316     return *val;
tools/lld/ELF/SymbolTable.cpp
  125       (*demangledSyms)[demangleItanium(sym->getName())].push_back(sym);
  128   return *demangledSyms;
tools/lld/ELF/SyntheticSections.cpp
  727   return gots[*f.mipsGotIndex];
tools/lld/ELF/Target.cpp
  182     return *config->imageBase;
tools/lld/MinGW/Driver.cpp
  127         return *s;
  135         return *s;
  137         return *s;
  140       return *s;
  143         return *s;
  145         error("lld doesn't support linking directly against " + *s +
  150         error("lld doesn't support linking directly against " + *s +
tools/lld/wasm/Driver.cpp
  184     for (StringRef sym : args::getLines(*buf))
  222   MemoryBufferRef mbref = *buffer;
  262       addFile(*s);
tools/lldb/include/lldb/Symbol/ClangASTContext.h
  695       return (*bit_size + 7) / 8;
tools/lldb/include/lldb/Target/ProcessStructReader.h
   62       if (!size || *size > 8)
   67           FieldImpl{field_type, byte_index, static_cast<size_t>(*size)};
   72     lldb::DataBufferSP buffer_sp(new DataBufferHeap(*total_size, 0));
   75                                     *total_size, error);
tools/lldb/source/API/SBType.cpp
  127       return *size;
tools/lldb/source/Breakpoint/BreakpointIDList.cpp
   58   m_breakpoint_ids.push_back(*bp_id);
   82   return FindBreakpointID(*bp_id, position);
   93       m_breakpoint_ids.push_back(*bp_id);
tools/lldb/source/Commands/CommandObjectFrame.cpp
   78         if (option_arg.getAsInteger(0, *address)) {
   87         if (option_arg.getAsInteger(0, *offset)) {
  318       if (*m_options.relative_frame_offset < 0) {
  320             -*m_options.relative_frame_offset)
  321           frame_idx += *m_options.relative_frame_offset;
  332       } else if (*m_options.relative_frame_offset > 0) {
  339             *m_options.relative_frame_offset)
  340           frame_idx += *m_options.relative_frame_offset;
tools/lldb/source/Commands/CommandObjectMemory.cpp
  488               user_defined_types.emplace(*type);
  541       m_format_options.GetByteSizeValue() = *size;
  661       bytes_read = *size * m_format_options.GetCountValue().GetCurrentValue();
  664         addr = addr + (*size * m_memory_options.m_offset.GetCurrentValue());
 1077         switch (*size) {
tools/lldb/source/Commands/CommandObjectReproducer.cpp
  238       loader = &(*loader_storage);
  314         auto command_buffer = llvm::MemoryBuffer::getFile(*command_file);
tools/lldb/source/Core/Debugger.cpp
 1598       language = *single_lang;
tools/lldb/source/Core/Highlighter.cpp
   34   if (!cursor_pos || *cursor_pos >= line.size()) {
   43   size_t column = *cursor_pos;
tools/lldb/source/Core/Module.cpp
 1272   return *m_unwind_table;
tools/lldb/source/Core/Value.cpp
  229       return *size;
  345       limit_byte_size = *size;
tools/lldb/source/Core/ValueObject.cpp
  780   const uint64_t bytes = item_count * *item_type_size;
  781   const uint64_t offset = item_idx * *item_type_size;
  846       if (max_bytes && *max_bytes > offset) {
  847         size_t bytes_read = std::min<uint64_t>(*max_bytes - offset, bytes);
 1848       new ValueObjectChild(*this, type, name_const_str, *size, offset, 0, 0,
 1890       new ValueObjectChild(*this, type, name_const_str, *size, offset, 0, 0,
tools/lldb/source/Core/ValueObjectChild.cpp
  194                 if (bitfield_end > *type_bit_size) {
  196                       (bitfield_end - *type_bit_size + 7) / 8;
tools/lldb/source/Core/ValueObjectConstResult.cpp
  203       SetByteSize(*size);
tools/lldb/source/DataFormatters/TypeFormat.cpp
  107             *size,                          // Byte size of item in "m_data"
tools/lldb/source/DataFormatters/VectorType.cpp
  178   if (container_size && element_size && *element_size) {
  179     if (*container_size % *element_size)
  179     if (*container_size % *element_size)
  181     return *container_size / *element_size;
  181     return *container_size / *element_size;
  205     auto offset = idx * *size;
tools/lldb/source/Expression/Materializer.cpp
  541         size_t byte_align = (*opt_bit_align + 7) / 8;
  801       size_t byte_align = (*opt_bit_align + 7) / 8;
  807           *byte_size, byte_align,
  810       m_temporary_allocation_size = *byte_size;
tools/lldb/source/Host/common/FileSystem.cpp
   45 FileSystem &FileSystem::Instance() { return *InstanceImpl(); }
tools/lldb/source/Host/common/HostInfoBase.cpp
  202     return HostInfo::GetArchitecture(*kind);
tools/lldb/source/Host/common/NativeProcessProtocol.cpp
   72       LLDB_LOG(log, "exit status already set to {0}", *m_exit_status);
tools/lldb/source/Host/posix/ConnectionFileDescriptorPosix.cpp
  162       return SocketListenAndAccept(*addr, error_ptr);
  165       return NamedSocketAccept(*addr, error_ptr);
  168       return NamedSocketAccept(*addr, error_ptr);
  170       return ConnectTCP(*addr, error_ptr);
  172       return ConnectTCP(*addr, error_ptr);
  174       return ConnectUDP(*addr, error_ptr);
  177       return NamedSocketConnect(*addr, error_ptr);
  180       return UnixAbstractSocketConnect(*addr, error_ptr);
  226           m_uri = *addr;
  755   return Result ? *Result : 0;
tools/lldb/source/Interpreter/CommandInterpreter.cpp
 1641         command_string = *hist_str;
 1642         original_command_string = *hist_str;
 1815         request.AddCompletion(*hist_str, "Previous command history event",
tools/lldb/source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.cpp
 1475         bit_width = *bit_size;
 1477         bit_width = *bit_size;
 1581     switch (*bit_width) {
 1602             if (*byte_size <= r0_reg_info->byte_size + r1_reg_info->byte_size +
 1607                   new DataBufferHeap(*byte_size, 0));
tools/lldb/source/Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.cpp
 1770       bit_width = *bit_size;
 1772       bit_width = *bit_size;
 2114   if (!byte_size || *byte_size == 0)
 2118       new DataBufferHeap(*byte_size, 0));
 2143         if (*base_byte_size > reg_info->byte_size)
 2152         if ((data_offset + *base_byte_size) <= heap_data_up->GetByteSize()) {
 2154               reg_info, heap_data_up->GetBytes() + data_offset, *base_byte_size,
 2156           if (bytes_copied != *base_byte_size)
 2171   if (*byte_size <= max_reg_byte_size) {
 2172     size_t bytes_left = *byte_size;
 2174     while (data_offset < *byte_size) {
 2278       if (*byte_size <= 8) {
 2286           switch (*byte_size) {
 2296                 if (*byte_size <=
 2299                       new DataBufferHeap(*byte_size, 0));
 2364         if (*byte_size <= sizeof(long double)) {
 2372               if (*byte_size == sizeof(float)) {
 2375               } else if (*byte_size == sizeof(double)) {
 2378               } else if (*byte_size == sizeof(long double)) {
 2392     if (*byte_size > 0) {
 2397         if (*byte_size <= v0_info->byte_size) {
 2399               new DataBufferHeap(*byte_size, 0));
tools/lldb/source/Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.cpp
  829         ReadIntegerArgument(value->GetScalar(), *bit_size, is_signed,
  832         ReadIntegerArgument(value->GetScalar(), *bit_size, false,
  942     switch (*bit_width) {
tools/lldb/source/Plugins/ABI/SysV-arm/ABISysV_arm.cpp
 1475           bit_width = *size;
 1587     switch (*bit_width) {
 1634     if (IsArmHardFloat(thread) && (*byte_size == 8 || *byte_size == 16)) {
 1634     if (IsArmHardFloat(thread) && (*byte_size == 8 || *byte_size == 16)) {
 1637       vfp_count = (*byte_size == 8 ? 1 : 2);
 1638     } else if (*byte_size <= 16) {
 1642       for (uint32_t i = 0; 4 * i < *byte_size; ++i) {
 1648       value.SetBytes(buffer.GetBytes(), *byte_size);
 1650       if (!GetReturnValuePassedInMemory(thread, reg_ctx, *byte_size, value))
 1655       switch (*bit_width) {
 1703         vfp_byte_size = *byte_size / 2;
 1705       } else if (!GetReturnValuePassedInMemory(thread, reg_ctx, *bit_width / 8,
 1722               (*base_byte_size == 8 || *base_byte_size == 16)) {
 1722               (*base_byte_size == 8 || *base_byte_size == 16)) {
 1725             vfp_count = (*base_byte_size == 8 ? homogeneous_count
 1732               vfp_byte_size = *base_byte_size;
 1751                     vfp_byte_size != *base_byte_size)
 1754                   vfp_byte_size = *base_byte_size;
 1770     if (*byte_size <= 4) {
 1774       value.SetBytes(&raw_value, *byte_size);
 1776       if (!GetReturnValuePassedInMemory(thread, reg_ctx, *byte_size, value))
 1788     DataBufferSP data_sp(new DataBufferHeap(*byte_size, 0));
 1823     if (data_offset == *byte_size) {
tools/lldb/source/Plugins/ABI/SysV-arm64/ABISysV_arm64.cpp
 1772         bit_width = *bit_size;
 1774         bit_width = *bit_size;
 2091   if (byte_size || *byte_size == 0)
 2095       new DataBufferHeap(*byte_size, 0));
 2120         if (*base_byte_size > reg_info->byte_size)
 2129         if ((data_offset + *base_byte_size) <= heap_data_up->GetByteSize()) {
 2131               reg_info, heap_data_up->GetBytes() + data_offset, *base_byte_size,
 2133           if (bytes_copied != *base_byte_size)
 2148   if (*byte_size <= max_reg_byte_size) {
 2149     size_t bytes_left = *byte_size;
 2151     while (data_offset < *byte_size) {
 2248       if (*byte_size <= 8) {
 2257           switch (*byte_size) {
 2268                 if (*byte_size <=
 2271                       new DataBufferHeap(*byte_size, 0));
 2336         if (*byte_size <= sizeof(long double)) {
 2344               if (*byte_size == sizeof(float)) {
 2347               } else if (*byte_size == sizeof(double)) {
 2350               } else if (*byte_size == sizeof(long double)) {
 2363   } else if (type_flags & eTypeIsVector && *byte_size <= 16) {
 2364     if (*byte_size > 0) {
 2369             new DataBufferHeap(*byte_size, 0));
 2386              (type_flags & eTypeIsVector && *byte_size > 16)) {
tools/lldb/source/Plugins/ABI/SysV-i386/ABISysV_i386.cpp
  313         ReadIntegerArgument(value->GetScalar(), *bit_size, is_signed,
  316         ReadIntegerArgument(value->GetScalar(), *bit_size, false,
  531       switch (*byte_size) {
  587       if (*byte_size <= 12) // handles float, double, long double, __float80
  599             if (*byte_size == 4) {
  603             } else if (*byte_size == 8) {
  610             } else if (*byte_size == 12) {
  621       } else if (*byte_size == 16) // handles __float128
  641     if (byte_size && *byte_size > 0) {
  647         if (*byte_size <= vec_reg->byte_size) {
  651                 new DataBufferHeap(*byte_size, 0));
  669         } else if (*byte_size <= vec_reg->byte_size * 2) {
  676                   new DataBufferHeap(*byte_size, 0));
tools/lldb/source/Plugins/ABI/SysV-mips/ABISysV_mips.cpp
  810     switch (*bit_width) {
  869       switch (*bit_width) {
  901         switch (*bit_width) {
tools/lldb/source/Plugins/ABI/SysV-mips64/ABISysV_mips64.cpp
  775       switch (*byte_size) {
  816         switch (*byte_size) {
  841         if (*byte_size <= sizeof(long double)) {
  852           if (*byte_size == sizeof(float)) {
  855           } else if (*byte_size == sizeof(double)) {
  858           } else if (*byte_size == sizeof(long double)) {
  873                   0, 8, data_sp->GetBytes(), *byte_size - 8, target_byte_order);
  877                   0, 8, data_sp->GetBytes() + 8, *byte_size - 8,
  882                   0, 8, data_sp->GetBytes() + 8, *byte_size - 8,
  887                   0, 8, data_sp->GetBytes(), *byte_size - 8, target_byte_order);
  904     if (*byte_size <= 16) {
  973               if (*field_byte_width == 16) {
  991                 f0_data.SetData(return_value, *field_byte_width,
 1005                 *field_byte_width > copy_from_extractor->GetByteSize())
 1010                 0, *field_byte_width,
 1011                 data_sp->GetBytes() + (field_bit_offset / 8), *field_byte_width,
 1039         if (!field_byte_width || *field_byte_width == 0)
 1051             if (integer_bytes + *field_byte_width + padding <= 8) {
 1054               integer_bytes = integer_bytes + *field_byte_width +
 1060               integer_bytes = integer_bytes + *field_byte_width +
 1067           else if (integer_bytes + *field_byte_width + padding <= 16) {
 1068             integer_bytes = integer_bytes + *field_byte_width + padding;
 1081         if (*byte_size <= 8)
tools/lldb/source/Plugins/ABI/SysV-ppc/ABISysV_ppc.cpp
  400       ReadIntegerArgument(value->GetScalar(), *bit_size, is_signed, thread,
  404       ReadIntegerArgument(value->GetScalar(), *bit_size, false, thread,
  469       if (*bit_width <= 64) {
  534       switch (*byte_size) {
  576         if (byte_size && *byte_size <= sizeof(long double)) {
  583               if (*byte_size == sizeof(float)) {
  586               } else if (*byte_size == sizeof(double)) {
  610     if (byte_size && *byte_size > 0) {
  613         if (*byte_size <= altivec_reg->byte_size) {
  617                 new DataBufferHeap(*byte_size, 0));
  665     if (*bit_width <= 128) {
  709         if (field_bit_offset % *field_bit_width != 0) {
  714         uint32_t field_byte_width = *field_bit_width / 8;
  747           if (*field_bit_width == 128) {
  750           } else if (*field_bit_width == 64) {
  753           } else if (*field_bit_width == 32) {
tools/lldb/source/Plugins/ABI/SysV-ppc64/ABISysV_ppc64.cpp
  277       ReadIntegerArgument(value->GetScalar(), *bit_size, is_signed, thread,
  281       ReadIntegerArgument(value->GetScalar(), *bit_size, false, thread,
  347       if (*bit_width <= 64) {
  647     switch (*byte_size) {
  795             m_data_up->GetBytes() + m_dst_offs, *elem_size, m_byte_order,
  797         if (rc != *elem_size) {
  801         m_dst_offs += *elem_size;
tools/lldb/source/Plugins/ABI/SysV-s390x/ABISysV_s390x.cpp
  377       ReadIntegerArgument(value->GetScalar(), *bit_size, is_signed, thread,
  381       ReadIntegerArgument(value->GetScalar(), *bit_size, false, thread,
  447       if (*bit_width <= 64) {
  515       switch (*byte_size) {
  557         if (byte_size && *byte_size <= sizeof(long double)) {
  564               if (*byte_size == sizeof(float)) {
  567               } else if (*byte_size == sizeof(double)) {
  570               } else if (*byte_size == sizeof(long double)) {
tools/lldb/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.cpp
  427       ReadIntegerArgument(value->GetScalar(), *bit_size, is_signed, thread,
  431       ReadIntegerArgument(value->GetScalar(), *bit_size, false, thread,
  497       if (*bit_width <= 64) {
  567       switch (*byte_size) {
  609         if (byte_size && *byte_size <= sizeof(long double)) {
  617               if (*byte_size == sizeof(float)) {
  620               } else if (*byte_size == sizeof(double)) {
  623               } else if (*byte_size == sizeof(long double)) {
  648     if (byte_size && *byte_size > 0) {
  655         if (*byte_size <= altivec_reg->byte_size) {
  659                 new DataBufferHeap(*byte_size, 0));
  677         } else if (*byte_size <= altivec_reg->byte_size * 2) {
  684                   new DataBufferHeap(*byte_size, 0));
  745     if (!field_bit_width || *field_bit_width == 0) {
  794       *bit_width <= 128 &&
tools/lldb/source/Plugins/ABI/Windows-x86_64/ABIWindows_x86_64.cpp
 1260       ReadIntegerArgument(value->GetScalar(), *bit_size, is_signed, thread,
 1264       ReadIntegerArgument(value->GetScalar(), *bit_size, false, thread,
 1330       if (*bit_width <= 64) {
 1401       switch (*byte_size) {
 1443         if (byte_size && *byte_size <= sizeof(long double)) {
 1451               if (*byte_size == sizeof(float)) {
 1454               } else if (*byte_size == sizeof(double)) {
 1481     if (byte_size && *byte_size > 0) {
 1488         if (*byte_size <= xmm_reg->byte_size) {
 1492                 new DataBufferHeap(*byte_size, 0));
 1544     if (!field_bit_width || *field_bit_width == 0) {
 1548     if (field_bit_offset % *field_bit_width != 0) {
 1613   bool is_memory = *bit_width > max_register_value_bit_width ||
 1614                    *bit_width & (*bit_width - 1);
 1614                    *bit_width & (*bit_width - 1);
tools/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp
  625     m_vdso_base = *vdso_base;
  629     m_interpreter_base = *interpreter_base;
  644   m_entry_point = static_cast<addr_t>(*entry_point);
tools/lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp
  797     AbsPosToLineColumnPos(*m_user_expression_start_pos, m_transformed_text,
tools/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp
 1256     lldb::offset_t value_alignment = (*opt_alignment + 7ull) / 8ull;
 1263              PrintType(value_type), *value_size, value_alignment);
 1267                                    llvm_value_ptr, *value_size,
tools/lldb/source/Plugins/Language/CPlusPlus/CxxStringTypes.cpp
  131   const uint32_t wchar_size = *size;
  254   const uint32_t wchar_size = *size;
tools/lldb/source/Plugins/Language/CPlusPlus/LibCxx.cpp
  261         DataBufferSP buffer_sp(new DataBufferHeap(*size, 0));
  589   switch (*wchar_t_size) {
tools/lldb/source/Plugins/Language/CPlusPlus/LibCxxBitset.cpp
   91     if (!bit_size || *bit_size == 0)
   93     chunk = m_first->GetChildAtIndex(idx / *bit_size, true);
  103   if (!bit_size || *bit_size == 0)
  105   size_t chunk_idx = idx % *bit_size;
tools/lldb/source/Plugins/Language/CPlusPlus/LibCxxInitializerList.cpp
   97     m_element_size = *size;
tools/lldb/source/Plugins/Language/CPlusPlus/LibCxxVariant.cpp
  145   uint64_t index_value = *optional_index_value;
  222   uint64_t index_value = *optional_index_value;
tools/lldb/source/Plugins/Language/CPlusPlus/LibCxxVector.cpp
  148     m_element_size = *size;
  218   DataBufferSP buffer_sp(new DataBufferHeap(*size, 0));
tools/lldb/source/Plugins/Language/CPlusPlus/LibStdcpp.cpp
  303       const uint32_t wchar_size = *size;
tools/lldb/source/Plugins/Language/ClangCommon/ClangHighlighter.cpp
  217     if (cursor_pos && end > *cursor_pos && !highlighted_cursor) {
tools/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp
  312         return *m_Foundation_major;
tools/lldb/source/Plugins/ObjectFile/Breakpad/BreakpadRecords.cpp
  385     if (!to_integer(Str, *Size, 16))
tools/lldb/source/Plugins/ObjectFile/Breakpad/ObjectFileBreakpad.cpp
  143         ConstString(toString(*current_section)), eSectionTypeOther,
tools/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp
 1789     provider.AddSegment(*InfoOr, std::move(Segment));
 1837     provider.AddSection(std::move(*InfoOr), std::move(section_sp));
tools/lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp
 4465         nlists.push_back(*nlist);
 5825   return *m_min_os_version;
tools/lldb/source/Plugins/Process/POSIX/NativeProcessELF.cpp
   55   lldb::addr_t phdr_addr = *maybe_phdr_addr;
   56   size_t phdr_entry_size = *maybe_phdr_entry_size;
   57   size_t phdr_num_entries = *maybe_phdr_num_entries;
tools/lldb/source/Plugins/Process/elf-core/RegisterUtilities.cpp
   34   uint32_t Type = *TypeOr;
tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp
  248     if (!m_condition_queue_not_empty.wait_for(lock, *timeout, pred))
tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp
 3679       result.push_back(*module_spec);
tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.cpp
  443       response.PutStringAsRawHex8(*name);
  463       response.PutStringAsRawHex8(*name);
tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp
  361            *wait_status);
  364   response.Format("{0:g}", *wait_status);
tools/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
 4276     for (const ModuleSpec &spec : *module_specs)
tools/lldb/source/Plugins/Process/minidump/ProcessMinidump.cpp
  342   std::tie(*m_memory_regions, is_complete) =
  350   auto pos = llvm::upper_bound(*m_memory_regions, load_addr);
  376   region_list = *m_memory_regions;
  771     MinidumpParser &minidump = *process->m_minidump_parser;
tools/lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.cpp
  211       spec = (*m_files)[record->FileNum];
  246   support_files = std::move(*data.support_files);
  514       AddressRange(base + init_record->Address, *init_record->Size,
  656     (*m_files)[record->Number] = FileSpec(record->Name, style);
  700         line_seq_up.get(), *next_addr, /*line*/ 0, /*column*/ 0,
  718     if (next_addr && *next_addr != record->Address) {
  731   data.support_files = map.translate(cu, *m_files);
  751             base + record->Address, *record->Size, It.GetBookmark()));
tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp
  705                   NULL, DW_ATE_signed, *attrs.byte_size * 8);
 1256           die.GetID(), dwarf, attrs.name, *clang_type_size, nullptr,
 1371   if (attrs.byte_size && *attrs.byte_size == 0 && attrs.name &&
 1834           llvm::APInt apint(*size, uval64, is_signed);
tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFContext.cpp
   36       data.data = LoadSection(m_dwo_section_list, *dwo_section_type);
tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp
   75         offset += *fixed_skip_size;
  584           offset += *fixed_skip_size;
tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp
  298       SetAddrBase(*addr_base);
  302       SetRangesBase(*ranges_base);
  357     dwo_cu->SetAddrBase(*addr_base);
  359     dwo_cu->SetAddrBase(*gnu_addr_base);
  362     dwo_cu->SetRangesBase(*ranges_base);
  364     dwo_cu->SetRangesBase(*gnu_ranges_base);
  632   return *m_comp_dir;
  638   return *m_file_spec;
tools/lldb/source/Plugins/SymbolFile/DWARF/DebugNamesDWARFIndex.cpp
   52   DWARFUnit *cu = m_debug_info.GetUnitAtOffset(DIERef::Section::DebugInfo, *cu_offset);
   64                   DIERef::Section::DebugInfo, cu->GetOffset() + *die_offset);
   72     offsets.push_back(*ref);
  162     DWARFUnit *cu = m_debug_info.GetUnit(*ref);
  164       incomplete_types.push_back(*ref);
  169     DWARFDIE die = m_debug_info.GetDIE(*ref);
  175       offsets.push_back(*ref);
  178       incomplete_types.push_back(*ref);
  232       ProcessFunctionDIE(name.GetStringRef(), *ref, dwarf, parent_decl_ctx,
tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp
  787             info->GetUnitAtIndex(*dwarf_idx)))
 1261   if (*dwo_num == 0x7fffffff)
 3222                       DataExtractor(debug_info_data, data_offset, *data_length),
 3242                                                              *data_length),
 3720       CallSiteParameter param = {*LocationInCallee, *LocationInCaller};
 3720       CallSiteParameter param = {*LocationInCallee, *LocationInCaller};
tools/lldb/source/Plugins/SymbolFile/NativePDB/CompileUnitIndex.cpp
   52       SymbolDeserializer::deserializeAs<Compile3Sym>(sym, *cci.m_compile_opts));
   58       SymbolDeserializer::deserializeAs<ObjNameSym>(sym, *cci.m_obj_name));
   75   llvm::cantFail(TypeDeserializer::deserializeAs<BuildInfoRecord>(*cvt, bir));
tools/lldb/source/Plugins/SymbolFile/NativePDB/DWARFLocationExpression.cpp
  155           stream.PutSLEB128(*relative_offset);
tools/lldb/source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.cpp
  284   for (auto ti = types.getFirst(); ti; ti = types.getNext(*ti)) {
  285     CVType type = types.getType(*ti);
  293       indices.forward = *ti;
  295       indices.full = *ti;
  343     ProcessTpiStream process(m_index, *ti, tag, m_parent_types);
  584       return GetOrCreateDeclContextForUid(*scope);
 1159       return_ct, arg_types.data(), arg_types.size(), is_variadic, 0, *cc);
 1206     if (llvm::StringRef(actual_ns).startswith(*parent)) {
tools/lldb/source/Plugins/SymbolFile/NativePDB/PdbIndex.cpp
  148   CompilandIndexItem &cci = compilands().GetOrCreateCompiland(*modi);
tools/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp
  700       auto full_iter = m_types.find(toOpaqueUid(*full_decl_uid));
  711   PdbTypeSymId best_decl_id = full_decl_uid ? *full_decl_uid : type_id;
  793     CompilandIndexItem &cci = m_index->compilands().GetOrCreateCompiland(*modi);
  967     CompilandIndexItem *cci = m_index->compilands().GetCompiland(*modi);
 1292   for (auto ti = types.getFirst(); ti; ti = types.getNext(*ti)) {
 1293     TypeSP type = GetOrCreateType(*ti);
 1355       comp_unit_sp.get(), *var_info.ranges, &decl, *var_info.location, false,
 1355       comp_unit_sp.get(), *var_info.ranges, &decl, *var_info.location, false,
tools/lldb/source/Symbol/ClangASTContext.cpp
 1004       m_pointer_byte_size = *size;
 4433         *stride = *size;
 6670             uint64_t base_class_clang_type_bit_size = *size;
 6703           child_byte_size = *size;
 6877             child_byte_size = *size;
 6901             child_byte_size = *size;
 6921             child_byte_size = *size;
 6960           child_byte_size = *size;
 6997             child_byte_size = *size;
tools/lldb/source/Symbol/ClangASTImporter.cpp
  934       m_decls_to_ignore.insert(*D);
  935       return *D;
tools/lldb/source/Symbol/CompilerType.cpp
  487     return (*bit_size + 7) / 8;
  802       if (*byte_size <= sizeof(unsigned long long)) {
  803         uint64_t uval64 = data.GetMaxU64(&offset, *byte_size);
  804         if (*byte_size <= sizeof(unsigned int)) {
  807         } else if (*byte_size <= sizeof(unsigned long)) {
  810         } else if (*byte_size <= sizeof(unsigned long long)) {
  819       if (*byte_size <= sizeof(long long)) {
  820         int64_t sval64 = data.GetMaxS64(&offset, *byte_size);
  821         if (*byte_size <= sizeof(int)) {
  824         } else if (*byte_size <= sizeof(long)) {
  827         } else if (*byte_size <= sizeof(long long)) {
  836       if (*byte_size <= sizeof(long double)) {
  839         if (*byte_size == sizeof(float)) {
  849         } else if (*byte_size == sizeof(double)) {
  859         } else if (*byte_size == sizeof(long double)) {
  895     if ((*bit_width % 8) != 0)
  898     const uint64_t byte_size = (*bit_width + 7) / 8;
  980   if (data.GetByteSize() < *byte_size) {
  981     lldb::DataBufferSP data_sp(new DataBufferHeap(*byte_size, '\0'));
  985   uint8_t *dst = const_cast<uint8_t *>(data.PeekData(0, *byte_size));
  991       memcpy(dst, reinterpret_cast<uint8_t *>(addr), *byte_size);
  999         return process->ReadMemory(addr, dst, *byte_size, error) == *byte_size;
  999         return process->ReadMemory(addr, dst, *byte_size, error) == *byte_size;
 1025   if (*byte_size > 0) {
 1028       memcpy((void *)addr, new_value.GetData(), *byte_size);
 1036         return process->WriteMemory(addr, new_value.GetData(), *byte_size,
 1037                                     error) == *byte_size;
tools/lldb/source/Symbol/PostfixExpression.cpp
   57       stack.push_back(MakeNode<BinaryOpNode>(alloc, *op_type, *left, *right));
   67       stack.push_back(MakeNode<UnaryOpNode>(alloc, *op_type, *operand));
tools/lldb/source/Symbol/SymbolFile.cpp
  168   lldb::CompUnitSP &cu_sp = (*m_compile_units)[idx];
  185   assert((*m_compile_units)[idx] == nullptr);
  186   (*m_compile_units)[idx] = cu_sp;
  222     for (const CompUnitSP &cu_sp : *m_compile_units) {
tools/lldb/source/Symbol/Type.cpp
  153     m_byte_size = *byte_size;
  351         m_byte_size = *size;
  358       m_byte_size = *size;
tools/lldb/source/Symbol/UnwindTable.cpp
  139   FuncUnwindersSP func_unwinder_sp(new FuncUnwinders(*this, *range_or));
  159   return std::make_shared<FuncUnwinders>(*this, *range_or);
tools/lldb/source/Target/Platform.cpp
  940     return HostInfo::GetArchitecture(*kind);
tools/lldb/source/Target/Process.cpp
  712         iohandler_id, *Result);
 4949                     llvm::to_string(now + *timeout).c_str());
 5137                   return_value = *result;
tools/lldb/source/Target/Target.cpp
  212       language = *single_lang;
tools/lldb/source/Utility/ProcessInfo.cpp
  205         s.Format(format, *name);
tools/lldb/source/Utility/Reproducer.cpp
   21 Reproducer &Reproducer::Instance() { return *InstanceImpl(); }
   83     return &(*m_generator);
   90     return &(*m_loader);
  107   m_generator.emplace(*root);
  124   m_loader.emplace(*root);
tools/lldb/source/Utility/SelectHelper.cpp
   90     vold = std::max(*vold, vnew);
  131   const unsigned nfds = static_cast<unsigned>(*max_fd) + 1;
tools/lldb/source/Utility/UserIDResolver.cpp
   25     return llvm::StringRef(*iter_bool.first->second);
tools/lldb/tools/driver/Driver.cpp
  837     return *exit_code;
tools/lldb/tools/lldb-vscode/JSONUtils.cpp
   35     return *s;
   42     return GetAsString(*value);
   57     return (uint64_t)*value;
   71     return *value;
   73     return *value != 0;
   87     return *value;
tools/lldb/unittests/Process/minidump/MinidumpParserTest.cpp
  327   check_mem_range_exists(*parser, 0x10000, 65536); // first range
  328   check_mem_range_exists(*parser, 0x40000, 4096);
  330   check_mem_range_exists(*parser, 0x77c12000, 8192);
  331   check_mem_range_exists(*parser, 0x7ffe0000, 4096); // last range
tools/lldb/unittests/TestingSupport/TestUtilities.cpp
   62           llvm::sys::fs::remove(*Name, /*IgnoreNonExisting*/ false))
tools/lldb/unittests/TestingSupport/TestUtilities.h
   43   llvm::StringRef name() { return *Name; }
tools/lldb/unittests/tools/lldb-server/tests/TestClient.cpp
  166   return *m_process_info;
tools/llvm-cov/SourceCoverageViewHTML.cpp
  540     return S && (!S->IsGapRegion || (Color && *Color == "red")) &&
tools/llvm-cov/SourceCoverageViewText.cpp
  116     colored_ostream(OS, Highlight ? *Highlight : raw_ostream::SAVEDCOLOR,
  123     if ((!S->IsGapRegion || (Highlight && *Highlight == raw_ostream::RED)) &&
  133   colored_ostream(OS, Highlight ? *Highlight : raw_ostream::SAVEDCOLOR,
tools/llvm-dwarfdump/Statistics.cpp
  252         if (auto List = DebugLoc->getLocationListAtOffset(*DebugLocOffset)) {
tools/llvm-dwarfdump/llvm-dwarfdump.cpp
  330       if (DWARFDie Die = DICtx.getDIEForOffset(*Off))
  343   DWARFCompileUnit *CU = DICtx.getCompileUnitForOffset(*CUOff);
  349     CU = DICtx.getDWOCompileUnitForHash(*DWOId);
  354   return CU->getDIEForOffset(CU->getOffset() + *Off);
tools/llvm-dwp/llvm-dwp.cpp
  196   ID.Signature = *Signature;
tools/llvm-elfabi/ELFObjHandler.cpp
  130   if (Dyn.SONameOffset.hasValue() && *Dyn.SONameOffset >= Dyn.StrSize) {
  135         *Dyn.SONameOffset);
  188     Expected<const uint8_t *> TablePtr = ElfFile.toMappedAddr(*Dyn.GnuHash);
  197     Expected<const uint8_t *> TablePtr = ElfFile.toMappedAddr(*Dyn.ElfHash);
  330         terminatedSubstr(DynStr, *DynEnt.SONameOffset);
tools/llvm-exegesis/lib/BenchmarkResult.cpp
  153       return MCOperand::createReg(*RegNo);
  269       RV.Register = *RegNo;
tools/llvm-lto2/llvm-lto2.cpp
  224     Conf.RelocModel = *RM;
tools/llvm-nm/llvm-nm.cpp
  800         Name = *Opt;
tools/llvm-objcopy/COFF/Reader.cpp
  167       if (*Sym.WeakTargetSymbolId >= RawSymbolTable.size())
  170       const Symbol *Target = RawSymbolTable[*Sym.WeakTargetSymbolId];
tools/llvm-objcopy/COFF/Writer.cpp
   83       const Symbol *Target = Obj.findSymbol(*Sym.WeakTargetSymbolId);
tools/llvm-objcopy/ELF/Object.cpp
 1259     if (Sec.Type == SHT_LLVM_PART_EHDR && Sec.Name == *ExtractPartition) {
 1264   error("could not find partition named '" + *ExtractPartition + "'");
tools/llvm-objcopy/MachO/MachOReader.cpp
  239       O.LoadCommands[*O.DataInCodeCommandIndex]
  250       O.LoadCommands[*O.FunctionStartsCommandIndex]
tools/llvm-objcopy/MachO/MachOWriter.cpp
   42         O.LoadCommands[*O.SymTabCommandIndex]
   51         O.LoadCommands[*O.DyLdInfoCommandIndex]
   84         O.LoadCommands[*O.DySymTabCommandIndex]
   94         O.LoadCommands[*O.DataInCodeCommandIndex]
  104         O.LoadCommands[*O.FunctionStartsCommandIndex]
  277       O.LoadCommands[*O.SymTabCommandIndex]
  288       O.LoadCommands[*O.SymTabCommandIndex]
  308       O.LoadCommands[*O.DyLdInfoCommandIndex]
  320       O.LoadCommands[*O.DyLdInfoCommandIndex]
  332       O.LoadCommands[*O.DyLdInfoCommandIndex]
  344       O.LoadCommands[*O.DyLdInfoCommandIndex]
  356       O.LoadCommands[*O.DyLdInfoCommandIndex]
  369       O.LoadCommands[*O.DySymTabCommandIndex]
  383       O.LoadCommands[*O.DataInCodeCommandIndex]
  395       O.LoadCommands[*O.FunctionStartsCommandIndex]
  410         O.LoadCommands[*O.SymTabCommandIndex]
  420         O.LoadCommands[*O.DyLdInfoCommandIndex]
  440         O.LoadCommands[*O.DySymTabCommandIndex]
  450         O.LoadCommands[*O.DataInCodeCommandIndex]
  460         O.LoadCommands[*O.FunctionStartsCommandIndex]
tools/llvm-objdump/llvm-objdump.cpp
  968         AllSymbols[*Plt].emplace_back(
tools/llvm-pdbutil/BytesOutputStyle.cpp
   91     auto &R = *opts::bytes::DumpBlockRange;
  108     auto &R = *opts::bytes::DumpByteRange;
tools/llvm-pdbutil/DumpOutputStyle.cpp
  705   for (Optional<TypeIndex> TI = Types.getFirst(); TI; TI = Types.getNext(*TI)) {
  706     CVType Type = Types.getType(*TI);
 1622   for (Optional<TypeIndex> TI = Types.getFirst(); TI; TI = Types.getNext(*TI)) {
 1623     CVType Type = File.types().getType(*TI);
 1625     if (RefTracker->isTypeReferenced(*TI)) {
tools/llvm-pdbutil/ExplainOutputStyle.cpp
   59     explainPdbStreamOffset(*Index);
tools/llvm-pdbutil/InputFile.cpp
  483   auto &Iter = *SectionIter;
tools/llvm-pdbutil/TypeReferenceTracker.cpp
   25   for (Optional<TypeIndex> TI = Types.getFirst(); TI; TI = Types.getNext(*TI))
  138     discoverTypeIndices(*Rec, DepList);
tools/llvm-pdbutil/llvm-pdbutil.cpp
  779     for (auto S : *YamlObj.StringTable)
 1411     if (!to_integer(Matches[3], *Parsed->Max))
tools/llvm-rc/ResourceFileWriter.cpp
 1540     return errorOrToExpected(MemoryBuffer::getFile(*Result, -1, false));
tools/llvm-readobj/ELFDumper.cpp
 2396     if (*DtGotSym > DynSymTotal)
 2401     GotSec = findNotEmptySectionByAddress(Obj, FileName, *DtPltGot);
 2404                               Twine::utohexstr(*DtPltGot)),
 2407     LocalNum = *DtLocalGotNum;
 2408     GlobalNum = DynSymTotal - *DtGotSym;
 2414     GotDynSyms = DynSyms.drop_front(*DtGotSym);
 2424     PltSec = findNotEmptySectionByAddress(Obj, FileName, * DtMipsPltGot);
 2427                          Twine::utohexstr(*DtMipsPltGot));
 2429     PltRelSec = findNotEmptySectionByAddress(Obj, FileName, * DtJmpRel);
 2432                          Twine::utohexstr(*DtJmpRel));
tools/llvm-xray/xray-extract.cpp
   63     YAMLSleds.push_back({*FuncId, Sled.Address, Sled.Function, Sled.Kind,
   65                          ExtractSymbolize ? FH.SymbolOrNumber(*FuncId) : ""});
tools/obj2yaml/dwarf2yaml.cpp
  250       uint64_t Offset = *StmtOffset;
  288           LineTableLength + *StmtOffset + SizeOfPrologueLength;
tools/obj2yaml/elf2yaml.cpp
  209     if (Error E = dumpSymbols(SymTab, *Y->Symbols))
  753   for (uint32_t &V : *S->Bucket)
  757   for (uint32_t &V : *S->Chain)
tools/opt/Debugify.cpp
  194     if (Signedness && *Signedness == DIBasicType::Signedness::Signed)
  195       HasBadSize = ValueOperandSize < *DbgVarSize;
  197     HasBadSize = ValueOperandSize != *DbgVarSize;
  202           << ", but its variable has size " << *DbgVarSize << ": ";
tools/polly/include/polly/ScopInfo.h
 2151     return *name;
tools/polly/lib/Analysis/ScopPass.cpp
  138         InnerAM->invalidate(*scop, *InnerPA);
unittests/ADT/APIntTest.cpp
 2786             if (NumLowBits >= 1 + *Bit)
unittests/BinaryFormat/DwarfTest.cpp
  152   EXPECT_EQ(*RefSize, *AddrSize);
  152   EXPECT_EQ(*RefSize, *AddrSize);
  160   EXPECT_EQ(*RefSize, *AddrSize);
  160   EXPECT_EQ(*RefSize, *AddrSize);
  166   EXPECT_EQ(*RefSize, 4);
  171   EXPECT_EQ(*RefSize, 4);
  176   EXPECT_EQ(*RefSize, 4);
  182   EXPECT_EQ(*RefSize, 8);
  187   EXPECT_EQ(*RefSize, 8);
  192   EXPECT_EQ(*RefSize, 8);
unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp
  306   EXPECT_STREQ(StringValue, *ExtractedStringValue);
  311     EXPECT_STREQ(StrxValue, *ExtractedStrxValue);
  315     EXPECT_STREQ(Strx1Value, *ExtractedStrx1Value);
  319     EXPECT_STREQ(Strx2Value, *ExtractedStrx2Value);
  323     EXPECT_STREQ(Strx3Value, *ExtractedStrx3Value);
  327     EXPECT_STREQ(Strx4Value, *ExtractedStrx4Value);
  332   EXPECT_STREQ(StrpValue, *ExtractedStrpValue);
 1056   EXPECT_STREQ(String1, *Extracted1);
 1063   EXPECT_STREQ(String2, *Extracted2);
 1070   EXPECT_STREQ(String1, *Extracted3);
 1452   EXPECT_EQ(CUPath, *ActualCUPath);
 1668   EXPECT_EQ(*BlockOpt, Array);
unittests/IR/ConstantsTest.cpp
  487     Func->setAlignment(*FunctionAlign);
unittests/Remarks/BitstreamRemarksSerializerTest.cpp
   44                                     std::move(*StrTab));
   63     checkAnalyze(MetaOS.str(), *ExpectedMeta);
unittests/Remarks/YAMLRemarksSerializerTest.cpp
   34                                     std::move(*StrTab));
   50     EXPECT_EQ(OS.str(), *ExpectedMeta);
unittests/Support/CachePruningTest.cpp
   29   EXPECT_EQ(std::chrono::minutes(2), *P->Interval);
   32   EXPECT_EQ(std::chrono::hours(3), *P->Interval);
unittests/Support/FileCheckTest.cpp
   78   EXPECT_EQ(42U, *Value);
utils/TableGen/GlobalISelEmitter.cpp
 1608     addPredicate<LLTOperandMatcher>(*OpTyOrNone);
 3862     InstructionOperandMatcher &InsnOperand = **MaybeInsnOperand;
 4144         InsertPt, DstMIBuilder.getInsnID(), 0, **SuperClass);
 4146         InsertPt, DstMIBuilder.getInsnID(), 1, **SuperClass);
 4148         InsertPt, DstMIBuilder.getInsnID(), 2, **SubClass);
 4167       (*SuperClass)->getMatchingSubClassWithSubRegs(CGRegs, *SubIdx);
 4167       (*SuperClass)->getMatchingSubClassWithSubRegs(CGRegs, *SubIdx);
 4192       InsertPt, DstMIBuilder.getInsnID(), 0, **SuperClass);
 4194       InsertPt, DstMIBuilder.getInsnID(), 2, **SubClass);
 4496   return *RC;
 4511     return *SuperRegisterClass;
 4663       OM.addPredicate<RegisterBankOperandMatcher>(**MaybeSuperClass);
 4674       OM.addPredicate<RegisterBankOperandMatcher>(**MaybeRegClass);
 4744       (*SuperClass)->getMatchingSubClassWithSubRegs(CGRegs, *SubIdx);
 4744       (*SuperClass)->getMatchingSubClassWithSubRegs(CGRegs, *SubIdx);
 4769     M.addAction<ConstrainOperandToRegClassAction>(0, 0, **SuperClass);
 4770     M.addAction<ConstrainOperandToRegClassAction>(0, 1, **SuperClass);
 4771     M.addAction<ConstrainOperandToRegClassAction>(0, 2, **SubClass);
 4794     M.addAction<ConstrainOperandToRegClassAction>(0, 0, **SuperClass);
 4795     M.addAction<ConstrainOperandToRegClassAction>(0, 2, **SubClass);
utils/TableGen/X86RecognizableInstr.cpp
  811       tables.setTableFields(*opcodeType, insnContext(), currentOpcode, *filter,
  816     tables.setTableFields(*opcodeType, insnContext(), opcodeToSet, *filter, UID,