|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
Derived Classes
include/llvm/IR/DebugInfoMetadata.h 118 class DINode : public MDNode {
1355 class DILocation : public MDNode {
2300 class DIExpression : public MDNode {
3049 class DIGlobalVariableExpression : public MDNode {
3096 class DIMacroNode : public MDNode {
include/llvm/IR/Metadata.h 1105 class MDTuple : public MDNode {
Declarations
include/llvm/Analysis/InstructionSimplify.h 54 class MDNode;
include/llvm/Analysis/Loads.h 24 class MDNode;
include/llvm/Analysis/LoopInfo.h 61 class MDNode;
include/llvm/Analysis/ScopedNoAliasAA.h 26 class MDNode;
include/llvm/Analysis/TypeBasedAliasAnalysis.h 27 class MDNode;
include/llvm/Analysis/ValueTracking.h 40 class MDNode;
include/llvm/CodeGen/AsmPrinter.h 70 class MDNode;
include/llvm/CodeGen/LexicalScopes.h 33 class MDNode;
include/llvm/CodeGen/MIRParser/MIParser.h 25 class MDNode;
include/llvm/CodeGen/MachineInstrBuilder.h 39 class MDNode;
include/llvm/CodeGen/MachineMemOperand.h 28 class MDNode;
include/llvm/CodeGen/MachineOperand.h 34 class MDNode;
include/llvm/IR/AutoUpgrade.h 23 class MDNode;
include/llvm/IR/ConstantRange.h 42 class MDNode;
include/llvm/IR/GlobalObject.h 27 class MDNode;
include/llvm/IR/IRBuilder.h 53 class MDNode;
include/llvm/IR/Instruction.h 35 class MDNode;
include/llvm/IR/MDBuilder.h 31 class MDNode;
include/llvm/IR/Metadata.def 80 HANDLE_MDNODE_BRANCH(MDNode)
include/llvm/IR/TypeFinder.h 22 class MDNode;
include/llvm/IR/Verifier.h 33 class MDNode;
include/llvm/ProfileData/InstrProf.h 53 class MDNode;
include/llvm/Transforms/Utils/BasicBlockUtils.h 35 class MDNode;
include/llvm/Transforms/Utils/FunctionComparator.h 38 class MDNode;
include/llvm/Transforms/Utils/Local.h 52 class MDNode;
include/llvm/Transforms/Utils/UnrollLoop.h 32 class MDNode;
include/llvm/Transforms/Utils/ValueMapper.h 28 class MDNode;
lib/AsmParser/LLParser.h 39 class MDNode;
lib/Bitcode/Reader/MetadataLoader.h 30 class MDNode;
lib/Bitcode/Writer/ValueEnumerator.h 35 class MDNode;
lib/CodeGen/AsmPrinter/DwarfCompileUnit.h 41 class MDNode;
lib/CodeGen/AsmPrinter/DwarfDebug.h 62 class MDNode;
lib/Target/AMDGPU/AMDGPUAliasAnalysis.h 27 class MDNode;
lib/Target/AMDGPU/AMDGPUHSAMetadataStreamer.h 30 class MDNode;
lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.h 27 class MDNode;
lib/Transforms/ObjCARC/PtrState.h 27 class MDNode;
tools/clang/lib/CodeGen/CGDebugInfo.h 33 class MDNode;
tools/clang/lib/CodeGen/CGLoopInfo.h 26 class MDNode;
tools/clang/lib/CodeGen/CGValue.h 26 class MDNode;
tools/clang/lib/CodeGen/CodeGenFunction.h 46 class MDNode;
tools/clang/lib/CodeGen/SanitizerMetadata.h 22 class MDNode;
References
include/llvm/ADT/ArrayRef.h 108 const ArrayRef<U *> &A,
110 std::is_convertible<U *const *, T const *>::value>::type * = nullptr)
118 const SmallVectorTemplateCommon<U *, DummyT> &Vec,
120 std::is_convertible<U *const *, T const *>::value>::type * = nullptr)
include/llvm/ADT/DenseMapInfo.h 39 static inline T* getEmptyKey() {
41 Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
45 static inline T* getTombstoneKey() {
47 Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
51 static unsigned getHashValue(const T *PtrVal) {
56 static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
56 static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
include/llvm/Analysis/CFGPrinter.h 156 MDNode *WeightsNode = TI->getMetadata(LLVMContext::MD_prof);
include/llvm/Analysis/InstructionSimplify.h 65 MDNode *getMetadata(const Instruction *I, unsigned KindID) const {
include/llvm/Analysis/LoopInfo.h 796 MDNode *getLoopID() const;
804 void setLoopID(MDNode *LoopID) const;
1238 MDNode *findOptionMDForLoopID(MDNode *LoopID, StringRef Name);
1238 MDNode *findOptionMDForLoopID(MDNode *LoopID, StringRef Name);
1245 MDNode *findOptionMDForLoop(const Loop *TheLoop, StringRef Name);
1254 bool isValidAsAccessGroup(MDNode *AccGroup);
1271 llvm::MDNode *
1272 makePostTransformationMetadata(llvm::LLVMContext &Context, MDNode *OrigLoopID,
1274 llvm::ArrayRef<llvm::MDNode *> AddAttrs);
include/llvm/Analysis/ScopedNoAliasAA.h 50 bool mayAliasInScopes(const MDNode *Scopes, const MDNode *NoAlias) const;
50 bool mayAliasInScopes(const MDNode *Scopes, const MDNode *NoAlias) const;
include/llvm/Analysis/TypeBasedAliasAnalysis.h 55 bool Aliases(const MDNode *A, const MDNode *B) const;
55 bool Aliases(const MDNode *A, const MDNode *B) const;
56 bool PathAliases(const MDNode *A, const MDNode *B) const;
56 bool PathAliases(const MDNode *A, const MDNode *B) const;
include/llvm/Analysis/ValueTracking.h 73 void computeKnownBitsFromRangeMetadata(const MDNode &Ranges,
include/llvm/Analysis/VectorUtils.h 240 MDNode *uniteAccessGroups(MDNode *AccGroups1, MDNode *AccGroups2);
240 MDNode *uniteAccessGroups(MDNode *AccGroups1, MDNode *AccGroups2);
240 MDNode *uniteAccessGroups(MDNode *AccGroups1, MDNode *AccGroups2);
248 MDNode *intersectAccessGroups(const Instruction *Inst1,
include/llvm/CodeGen/AsmPrinter.h 167 std::vector<const MDNode *> LocInfos;
664 const MDNode *LocMDNode = nullptr,
674 const MDNode *LocMDNode) const;
include/llvm/CodeGen/GlobalISel/CallLowering.h 89 MDNode *KnownCallees = nullptr;
include/llvm/CodeGen/GlobalISel/MachineIRBuilder.h 347 MachineInstrBuilder buildDirectDbgValue(Register Reg, const MDNode *Variable,
348 const MDNode *Expr);
354 const MDNode *Variable,
355 const MDNode *Expr);
360 MachineInstrBuilder buildFIDbgValue(int FI, const MDNode *Variable,
361 const MDNode *Expr);
366 const MDNode *Variable,
367 const MDNode *Expr);
371 MachineInstrBuilder buildDbgLabel(const MDNode *Label);
include/llvm/CodeGen/LexicalScopes.h 61 const MDNode *getDesc() const { return Desc; }
include/llvm/CodeGen/MIRParser/MIParser.h 228 bool parseMDNode(PerFunctionMIParsingState &PFS, MDNode *&Node, StringRef Src,
include/llvm/CodeGen/MachineFunction.h 327 std::vector<std::pair<MCSymbol *, MDNode *>> CodeViewAnnotations;
757 const MDNode *Ranges = nullptr,
805 MCSymbol *PostInstrSymbol = nullptr, MDNode *HeapAllocMarker = nullptr);
952 void addCodeViewAnnotation(MCSymbol *Label, MDNode *MD) {
956 ArrayRef<std::pair<MCSymbol *, MDNode *>> getCodeViewAnnotations() const {
include/llvm/CodeGen/MachineInstr.h 139 : TrailingObjects<ExtraInfo, MachineMemOperand *, MCSymbol *, MDNode *> {
145 MDNode *HeapAllocMarker = nullptr) {
150 totalSizeToAlloc<MachineMemOperand *, MCSymbol *, MDNode *>(
167 Result->getTrailingObjects<MDNode *>()[0] = HeapAllocMarker;
186 MDNode *getHeapAllocMarker() const {
187 return HasHeapAllocMarker ? getTrailingObjects<MDNode *>()[0] : nullptr;
210 size_t numTrailingObjects(OverloadToken<MDNode *>) const {
612 MDNode *getHeapAllocMarker() const {
1630 void setHeapAllocMarker(MachineFunction &MF, MDNode *MD);
1697 MDNode *HeapAllocMarker);
include/llvm/CodeGen/MachineInstrBuilder.h 227 const MachineInstrBuilder &addMetadata(const MDNode *MD) const {
434 Register Reg, const MDNode *Variable,
435 const MDNode *Expr);
441 MachineOperand &MO, const MDNode *Variable,
442 const MDNode *Expr);
450 Register Reg, const MDNode *Variable,
451 const MDNode *Expr);
458 MachineOperand &MO, const MDNode *Variable,
459 const MDNode *Expr);
include/llvm/CodeGen/MachineMemOperand.h 175 const MDNode *Ranges;
186 const MDNode *Ranges = nullptr,
238 const MDNode *getRanges() const { return Ranges; }
include/llvm/CodeGen/MachineOperand.h 172 const MDNode *MD; // For MO_Metadata.
639 const MDNode *getMetadata() const {
677 void setMetadata(const MDNode *MD) {
881 static MachineOperand CreateMetadata(const MDNode *Meta) {
include/llvm/CodeGen/SelectionDAG.h 275 MDNode *HeapAllocSite = nullptr;
1083 const MDNode *Ranges = nullptr);
1102 const MDNode *Ranges = nullptr);
1157 SDValue getMDNode(const MDNode *MD);
1702 void addHeapAllocSite(const SDNode *Node, MDNode *MD) {
1707 MDNode *getHeapAllocSite(const SDNode *Node) {
include/llvm/CodeGen/SelectionDAGNodes.h 1350 const MDNode *getRanges() const { return MMO->getRanges(); }
2035 const MDNode *MD;
2037 explicit MDNodeSDNode(const MDNode *md)
2042 const MDNode *getMD() const { return MD; }
include/llvm/IR/AutoUpgrade.h 66 MDNode *UpgradeTBAANode(MDNode &TBAANode);
66 MDNode *UpgradeTBAANode(MDNode &TBAANode);
88 MDNode *upgradeInstructionLoopAttachment(MDNode &N);
88 MDNode *upgradeInstructionLoopAttachment(MDNode &N);
include/llvm/IR/ConstantRange.h 479 ConstantRange getConstantRangeFromMetadata(const MDNode &RangeMD);
include/llvm/IR/DIBuilder.h 59 MapVector<MDNode *, SetVector<Metadata *>> AllMacrosPerParent;
70 DenseMap<MDNode *, SmallVector<TrackingMDNodeRef, 1>> PreservedVariables;
73 DenseMap<MDNode *, SmallVector<TrackingMDNodeRef, 1>> PreservedLabels;
78 void trackIfUnresolved(MDNode *N);
341 DIType *Ty, MDNode *PropertyNode);
378 DIType *VTableHolder = nullptr, MDNode *TemplateParms = nullptr,
585 DIExpression *Expr = nullptr, MDNode *Decl = nullptr,
592 unsigned LineNo, DIType *Ty, bool isLocalToUnit, MDNode *Decl = nullptr,
876 NodeTy *replaceTemporary(TempMDNode &&N, NodeTy *Replacement) {
876 NodeTy *replaceTemporary(TempMDNode &&N, NodeTy *Replacement) {
878 return cast<NodeTy>(MDNode::replaceWithUniqued(std::move(N)));
878 return cast<NodeTy>(MDNode::replaceWithUniqued(std::move(N)));
include/llvm/IR/DebugInfo.h 31 DISubprogram *getDISubprogram(const MDNode *Scope);
135 SmallPtrSet<const MDNode *, 32> NodesSeen;
include/llvm/IR/DebugInfoMetadata.h 85 MDNode::op_iterator I = nullptr;
89 explicit iterator(MDNode::op_iterator I) : I(I) {}
118 class DINode : public MDNode {
1355 class DILocation : public MDNode {
2300 class DIExpression : public MDNode {
3049 class DIGlobalVariableExpression : public MDNode {
3096 class DIMacroNode : public MDNode {
include/llvm/IR/DebugLoc.h 48 explicit DebugLoc(const MDNode *N);
79 static DebugLoc get(unsigned Line, unsigned Col, const MDNode *Scope,
80 const MDNode *InlinedAt = nullptr,
90 DenseMap<const MDNode *, MDNode *> &Cache,
90 DenseMap<const MDNode *, MDNode *> &Cache,
95 MDNode *getScope() const;
101 MDNode *getInlinedAtScope() const;
113 MDNode *getAsMDNode() const { return Loc; }
include/llvm/IR/GlobalObject.h 140 MDNode *getMetadata(unsigned KindID) const;
141 MDNode *getMetadata(StringRef Kind) const;
148 void getMetadata(unsigned KindID, SmallVectorImpl<MDNode *> &MDs) const;
149 void getMetadata(StringRef Kind, SmallVectorImpl<MDNode *> &MDs) const;
157 void setMetadata(unsigned KindID, MDNode *MD);
158 void setMetadata(StringRef Kind, MDNode *MD);
163 void addMetadata(unsigned KindID, MDNode &MD);
164 void addMetadata(StringRef Kind, MDNode &MD);
170 getAllMetadata(SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs) const;
include/llvm/IR/IRBuilder.h 96 MDNode *DefaultFPMathTag;
106 IRBuilderBase(LLVMContext &context, MDNode *FPMathTag = nullptr,
213 MDNode *getDefaultFPMathTag() const { return DefaultFPMathTag; }
222 void setDefaultFPMathTag(MDNode *FPMathTag) { DefaultFPMathTag = FPMathTag; }
304 MDNode *FPMathTag;
456 bool isVolatile = false, MDNode *TBAATag = nullptr,
457 MDNode *ScopeTag = nullptr,
458 MDNode *NoAliasTag = nullptr) {
464 bool isVolatile = false, MDNode *TBAATag = nullptr,
465 MDNode *ScopeTag = nullptr,
466 MDNode *NoAliasTag = nullptr);
477 MDNode *TBAATag = nullptr,
478 MDNode *ScopeTag = nullptr,
479 MDNode *NoAliasTag = nullptr) {
488 MDNode *TBAATag = nullptr,
489 MDNode *ScopeTag = nullptr,
490 MDNode *NoAliasTag = nullptr);
499 bool isVolatile = false, MDNode *TBAATag = nullptr,
500 MDNode *TBAAStructTag = nullptr,
501 MDNode *ScopeTag = nullptr,
502 MDNode *NoAliasTag = nullptr) {
510 bool isVolatile = false, MDNode *TBAATag = nullptr,
511 MDNode *TBAAStructTag = nullptr,
512 MDNode *ScopeTag = nullptr,
513 MDNode *NoAliasTag = nullptr);
525 uint64_t Size, uint32_t ElementSize, MDNode *TBAATag = nullptr,
526 MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr,
526 MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr,
527 MDNode *NoAliasTag = nullptr) {
535 uint32_t ElementSize, MDNode *TBAATag = nullptr,
536 MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr,
536 MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr,
537 MDNode *NoAliasTag = nullptr);
547 MDNode *TBAATag = nullptr, MDNode *ScopeTag = nullptr,
547 MDNode *TBAATag = nullptr, MDNode *ScopeTag = nullptr,
548 MDNode *NoAliasTag = nullptr) {
554 Value *Size, bool isVolatile = false, MDNode *TBAATag = nullptr,
555 MDNode *ScopeTag = nullptr,
556 MDNode *NoAliasTag = nullptr);
569 uint64_t Size, uint32_t ElementSize, MDNode *TBAATag = nullptr,
570 MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr,
570 MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr,
571 MDNode *NoAliasTag = nullptr) {
579 uint32_t ElementSize, MDNode *TBAATag = nullptr,
580 MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr,
580 MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr,
581 MDNode *NoAliasTag = nullptr);
799 MDNode *FPMathTag = nullptr,
804 explicit IRBuilder(LLVMContext &C, MDNode *FPMathTag = nullptr,
808 explicit IRBuilder(BasicBlock *TheBB, const T &F, MDNode *FPMathTag = nullptr,
814 explicit IRBuilder(BasicBlock *TheBB, MDNode *FPMathTag = nullptr,
820 explicit IRBuilder(Instruction *IP, MDNode *FPMathTag = nullptr,
827 MDNode *FPMathTag = nullptr,
834 MDNode *FPMathTag = nullptr,
865 InstTy *addBranchMetadata(InstTy *I, MDNode *Weights, MDNode *Unpredictable) {
865 InstTy *addBranchMetadata(InstTy *I, MDNode *Weights, MDNode *Unpredictable) {
906 MDNode *BranchWeights = nullptr,
907 MDNode *Unpredictable = nullptr) {
929 MDNode *BranchWeights = nullptr,
930 MDNode *Unpredictable = nullptr) {
1083 Instruction *setFPAttrs(Instruction *I, MDNode *FPMD,
1349 MDNode *FPMD = nullptr) {
1374 MDNode *FPMD = nullptr) {
1399 MDNode *FPMD = nullptr) {
1424 MDNode *FPMD = nullptr) {
1449 MDNode *FPMD = nullptr) {
1475 MDNode *FPMathTag = nullptr) {
1485 const Twine &Name = "", MDNode *FPMathTag = nullptr,
1521 MDNode *FPMathTag = nullptr) {
1547 MDNode *FPMathTag = nullptr) {
1560 MDNode *FPMathTag = nullptr) {
2080 MDNode *FPMathTag = nullptr,
2160 MDNode *FPMathTag = nullptr) {
2165 MDNode *FPMathTag = nullptr) {
2170 MDNode *FPMathTag = nullptr) {
2175 MDNode *FPMathTag = nullptr) {
2180 MDNode *FPMathTag = nullptr) {
2185 MDNode *FPMathTag = nullptr) {
2190 MDNode *FPMathTag = nullptr) {
2195 MDNode *FPMathTag = nullptr) {
2200 MDNode *FPMathTag = nullptr) {
2205 MDNode *FPMathTag = nullptr) {
2210 MDNode *FPMathTag = nullptr) {
2215 MDNode *FPMathTag = nullptr) {
2220 MDNode *FPMathTag = nullptr) {
2225 MDNode *FPMathTag = nullptr) {
2238 const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2259 MDNode *FPMathTag = nullptr) {
2270 const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2280 const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2287 const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2294 const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2303 const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2318 MDNode *Prof = MDFrom->getMetadata(LLVMContext::MD_prof);
2319 MDNode *Unpred = MDFrom->getMetadata(LLVMContext::MD_unpredictable);
2525 unsigned LastIndex, MDNode *DbgInfo) {
2554 MDNode *DbgInfo) {
2573 unsigned FieldIndex, MDNode *DbgInfo) {
include/llvm/IR/Instruction.h 244 MDNode *getMetadata(unsigned KindID) const {
251 MDNode *getMetadata(StringRef Kind) const {
260 getAllMetadata(SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs) const {
268 SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs) const {
280 void setMetadata(unsigned KindID, MDNode *Node);
281 void setMetadata(StringRef Kind, MDNode *Node);
465 MDNode *getMetadataImpl(unsigned KindID) const;
466 MDNode *getMetadataImpl(StringRef Kind) const;
468 getAllMetadataImpl(SmallVectorImpl<std::pair<unsigned, MDNode *>> &) const;
470 SmallVectorImpl<std::pair<unsigned, MDNode *>> &) const;
include/llvm/IR/Instructions.h 3471 static MDNode *getProfBranchWeightsMD(const SwitchInst &SI);
3473 MDNode *buildProfBranchWeightsMD();
include/llvm/IR/MDBuilder.h 54 MDNode *createFPMath(float Accuracy);
61 MDNode *createBranchWeights(uint32_t TrueWeight, uint32_t FalseWeight);
64 MDNode *createBranchWeights(ArrayRef<uint32_t> Weights);
67 MDNode *createUnpredictable();
73 MDNode *createFunctionEntryCount(uint64_t Count, bool Synthetic,
77 MDNode *createFunctionSectionPrefix(StringRef Prefix);
80 MDNode *createMisExpect(uint64_t Index, uint64_t LikelyWeight,
88 MDNode *createRange(const APInt &Lo, const APInt &Hi);
91 MDNode *createRange(Constant *Lo, Constant *Hi);
99 MDNode *createCallees(ArrayRef<Function *> Callees);
106 MDNode *createCallbackEncoding(unsigned CalleeArgNo, ArrayRef<int> Arguments,
110 MDNode *mergeCallbackEncodings(MDNode *ExistingCallbacks, MDNode *NewCB);
110 MDNode *mergeCallbackEncodings(MDNode *ExistingCallbacks, MDNode *NewCB);
110 MDNode *mergeCallbackEncodings(MDNode *ExistingCallbacks, MDNode *NewCB);
120 MDNode *createAnonymousAARoot(StringRef Name = StringRef(),
121 MDNode *Extra = nullptr);
127 MDNode *createAnonymousTBAARoot() {
134 MDNode *createAnonymousAliasScopeDomain(StringRef Name = StringRef()) {
141 MDNode *createAnonymousAliasScope(MDNode *Domain,
141 MDNode *createAnonymousAliasScope(MDNode *Domain,
149 MDNode *createTBAARoot(StringRef Name);
154 MDNode *createAliasScopeDomain(StringRef Name);
159 MDNode *createAliasScope(StringRef Name, MDNode *Domain);
159 MDNode *createAliasScope(StringRef Name, MDNode *Domain);
163 MDNode *createTBAANode(StringRef Name, MDNode *Parent,
163 MDNode *createTBAANode(StringRef Name, MDNode *Parent,
169 MDNode *Type;
170 TBAAStructField(uint64_t Offset, uint64_t Size, MDNode *Type) :
176 MDNode *createTBAAStructNode(ArrayRef<TBAAStructField> Fields);
180 MDNode *
182 ArrayRef<std::pair<MDNode *, uint64_t>> Fields);
186 MDNode *createTBAAScalarTypeNode(StringRef Name, MDNode *Parent,
186 MDNode *createTBAAScalarTypeNode(StringRef Name, MDNode *Parent,
191 MDNode *createTBAAStructTagNode(MDNode *BaseType, MDNode *AccessType,
191 MDNode *createTBAAStructTagNode(MDNode *BaseType, MDNode *AccessType,
191 MDNode *createTBAAStructTagNode(MDNode *BaseType, MDNode *AccessType,
196 MDNode *createTBAATypeNode(MDNode *Parent, uint64_t Size, Metadata *Id,
196 MDNode *createTBAATypeNode(MDNode *Parent, uint64_t Size, Metadata *Id,
204 MDNode *createTBAAAccessTag(MDNode *BaseType, MDNode *AccessType,
204 MDNode *createTBAAAccessTag(MDNode *BaseType, MDNode *AccessType,
204 MDNode *createTBAAAccessTag(MDNode *BaseType, MDNode *AccessType,
210 MDNode *createMutableTBAAAccessTag(MDNode *Tag);
210 MDNode *createMutableTBAAAccessTag(MDNode *Tag);
213 MDNode *createIrrLoopHeaderWeight(uint64_t Weight);
include/llvm/IR/Metadata.h 644 explicit AAMDNodes(MDNode *T = nullptr, MDNode *S = nullptr,
644 explicit AAMDNodes(MDNode *T = nullptr, MDNode *S = nullptr,
645 MDNode *N = nullptr)
657 MDNode *TBAA;
660 MDNode *Scope;
663 MDNode *NoAlias;
683 return AAMDNodes(DenseMapInfo<MDNode *>::getEmptyKey(),
688 return AAMDNodes(DenseMapInfo<MDNode *>::getTombstoneKey(),
693 return DenseMapInfo<MDNode *>::getHashValue(Val.TBAA) ^
694 DenseMapInfo<MDNode *>::getHashValue(Val.Scope) ^
695 DenseMapInfo<MDNode *>::getHashValue(Val.NoAlias);
839 inline void operator()(MDNode *Node) const;
902 MDNode(const MDNode &) = delete;
903 void operator=(const MDNode &) = delete;
921 static void deleteTemporary(MDNode *N);
970 static typename std::enable_if<std::is_base_of<MDNode, T>::value, T *>::type
982 static typename std::enable_if<std::is_base_of<MDNode, T>::value, T *>::type
982 static typename std::enable_if<std::is_base_of<MDNode, T>::value, T *>::type
982 static typename std::enable_if<std::is_base_of<MDNode, T>::value, T *>::type
983 replaceWithUniqued(std::unique_ptr<T, TempMDNodeDeleter> N) {
984 return cast<T>(N.release()->replaceWithUniquedImpl());
992 static typename std::enable_if<std::is_base_of<MDNode, T>::value, T *>::type
992 static typename std::enable_if<std::is_base_of<MDNode, T>::value, T *>::type
992 static typename std::enable_if<std::is_base_of<MDNode, T>::value, T *>::type
993 replaceWithDistinct(std::unique_ptr<T, TempMDNodeDeleter> N) {
994 return cast<T>(N.release()->replaceWithDistinctImpl());
998 MDNode *replaceWithPermanentImpl();
999 MDNode *replaceWithUniquedImpl();
1000 MDNode *replaceWithDistinctImpl();
1037 MDNode *uniquify();
1092 static MDNode *concatenate(MDNode *A, MDNode *B);
1092 static MDNode *concatenate(MDNode *A, MDNode *B);
1092 static MDNode *concatenate(MDNode *A, MDNode *B);
1093 static MDNode *intersect(MDNode *A, MDNode *B);
1093 static MDNode *intersect(MDNode *A, MDNode *B);
1093 static MDNode *intersect(MDNode *A, MDNode *B);
1094 static MDNode *getMostGenericTBAA(MDNode *A, MDNode *B);
1094 static MDNode *getMostGenericTBAA(MDNode *A, MDNode *B);
1094 static MDNode *getMostGenericTBAA(MDNode *A, MDNode *B);
1095 static MDNode *getMostGenericFPMath(MDNode *A, MDNode *B);
1095 static MDNode *getMostGenericFPMath(MDNode *A, MDNode *B);
1095 static MDNode *getMostGenericFPMath(MDNode *A, MDNode *B);
1096 static MDNode *getMostGenericRange(MDNode *A, MDNode *B);
1096 static MDNode *getMostGenericRange(MDNode *A, MDNode *B);
1096 static MDNode *getMostGenericRange(MDNode *A, MDNode *B);
1097 static MDNode *getMostGenericAliasScope(MDNode *A, MDNode *B);
1097 static MDNode *getMostGenericAliasScope(MDNode *A, MDNode *B);
1097 static MDNode *getMostGenericAliasScope(MDNode *A, MDNode *B);
1098 static MDNode *getMostGenericAlignmentOrDereferenceable(MDNode *A, MDNode *B);
1098 static MDNode *getMostGenericAlignmentOrDereferenceable(MDNode *A, MDNode *B);
1098 static MDNode *getMostGenericAlignmentOrDereferenceable(MDNode *A, MDNode *B);
1105 class MDTuple : public MDNode {
1182 void TempMDNodeDeleter::operator()(MDNode *Node) const {
1183 MDNode::deleteTemporary(Node);
1194 MDNode::op_iterator I = nullptr;
1198 explicit TypedMDOperandIterator(MDNode::op_iterator I) : I(I) {}
1339 public std::iterator<std::bidirectional_iterator_tag, T2> {
1394 MDNode *getOperand(unsigned i) const;
1396 void addOperand(MDNode *M);
1397 void setOperand(unsigned I, MDNode *New);
1407 using op_iterator = op_iterator_impl<MDNode *, MDNode>;
1407 using op_iterator = op_iterator_impl<MDNode *, MDNode>;
1412 using const_op_iterator = op_iterator_impl<const MDNode *, MDNode>;
1412 using const_op_iterator = op_iterator_impl<const MDNode *, MDNode>;
include/llvm/IR/Module.h 493 void addModuleFlag(MDNode *Node);
include/llvm/IR/TrackingMDRef.h 111 explicit TypedTrackingMDRef(T *MD) : Ref(static_cast<Metadata *>(MD)) {}
126 T *get() const { return (T *)Ref.get(); }
127 operator T *() const { return get(); }
128 T *operator->() const { return get(); }
129 T &operator*() const { return *get(); }
135 void reset(T *MD) { Ref.reset(static_cast<Metadata *>(MD)); }
141 using TrackingMDNodeRef = TypedTrackingMDRef<MDNode>;
160 using SimpleType = T *;
162 static SimpleType getSimplifiedValue(TypedTrackingMDRef<T> &MD) {
168 using SimpleType = T *;
170 static SimpleType getSimplifiedValue(const TypedTrackingMDRef<T> &MD) {
include/llvm/IR/TypeFinder.h 34 DenseSet<const MDNode *> VisitedMetadata;
61 DenseSet<const MDNode *> &getVisitedMetadata() { return VisitedMetadata; }
76 void incorporateMDNode(const MDNode *V);
include/llvm/IR/Verifier.h 54 DenseMap<const MDNode *, TBAABaseNodeSummary> TBAABaseNodes;
58 DenseMap<const MDNode *, bool> TBAAScalarNodes;
62 MDNode *getFieldNodeFromTBAABaseNode(Instruction &I, const MDNode *BaseNode,
62 MDNode *getFieldNodeFromTBAABaseNode(Instruction &I, const MDNode *BaseNode,
65 const MDNode *BaseNode,
68 const MDNode *BaseNode,
71 bool isValidScalarTBAANode(const MDNode *MD);
79 bool visitTBAAMetadata(Instruction &I, const MDNode *MD);
include/llvm/ProfileData/InstrProf.h 262 MDNode *getPGOFuncNameMetadata(const Function &F);
include/llvm/Support/Casting.h 34 using SimpleType = From; // The real type this represents...
37 static SimpleType &getSimplifiedValue(From &Val) { return Val; }
41 using NonConstSimpleType = typename simplify_type<From>::SimpleType;
47 static RetType getSimplifiedValue(const From& Val) {
57 static inline bool doit(const From &Val) {
58 return To::classof(&Val);
66 static inline bool doit(const From &) { return true; }
76 static inline bool doit(const From &Val) {
77 return isa_impl<To, From>::doit(Val);
90 static inline bool doit(const From *Val) {
92 return isa_impl<To, From>::doit(*Val);
92 return isa_impl<To, From>::doit(*Val);
104 static inline bool doit(const From *Val) {
106 return isa_impl<To, From>::doit(*Val);
106 return isa_impl<To, From>::doit(*Val);
122 return isa_impl_wrap<To, SimpleFrom,
132 return isa_impl_cl<To,FromTy>::doit(Val);
141 template <class X, class Y> LLVM_NODISCARD inline bool isa(const Y &Val) {
142 return isa_impl_wrap<X, const Y,
142 return isa_impl_wrap<X, const Y,
143 typename simplify_type<const Y>::SimpleType>::doit(Val);
172 using ret_type = To *; // Pointer arg case, return Ty*
176 using ret_type = const To *; // Constant pointer arg case, return const Ty*
198 using ret_type = typename cast_retty<To, SimpleFrom>::ret_type;
204 using ret_type = typename cast_retty_impl<To,FromTy>::ret_type;
210 To, From, typename simplify_type<From>::SimpleType>::ret_type;
218 static typename cast_retty<To, From>::ret_type doit(From &Val) {
219 return cast_convert_val<To, SimpleFrom,
227 static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
228 typename cast_retty<To, FromTy>::ret_type Res2
236 std::is_same<X, typename simplify_type<X>::SimpleType>::value;
236 std::is_same<X, typename simplify_type<X>::SimpleType>::value;
248 typename cast_retty<X, const Y>::ret_type>::type
252 X, const Y, typename simplify_type<const Y>::SimpleType>::doit(Val);
256 inline typename cast_retty<X, Y>::ret_type cast(Y &Val) {
258 return cast_convert_val<X, Y,
263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
265 return cast_convert_val<X, Y*,
265 return cast_convert_val<X, Y*,
266 typename simplify_type<Y*>::SimpleType>::doit(Val);
285 typename cast_retty<X, const Y>::ret_type>::type
290 return cast<X>(Val);
296 typename cast_retty<X, Y>::ret_type>::type
305 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
305 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
306 cast_or_null(Y *Val) {
309 return cast<X>(Val);
331 typename cast_retty<X, const Y>::ret_type>::type
333 return isa<X>(Val) ? cast<X>(Val) : nullptr;
333 return isa<X>(Val) ? cast<X>(Val) : nullptr;
337 LLVM_NODISCARD inline typename cast_retty<X, Y>::ret_type dyn_cast(Y &Val) {
342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
343 return isa<X>(Val) ? cast<X>(Val) : nullptr;
343 return isa<X>(Val) ? cast<X>(Val) : nullptr;
352 typename cast_retty<X, const Y>::ret_type>::type
354 return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
354 return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
360 typename cast_retty<X, Y>::ret_type>::type
362 return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
362 return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
366 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
366 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
367 dyn_cast_or_null(Y *Val) {
368 return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
368 return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
include/llvm/Support/PointerLikeTypeTraits.h 56 static inline void *getAsVoidPointer(T *P) { return P; }
57 static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
59 enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };
91 typedef PointerLikeTypeTraits<T *> NonConst;
93 static inline const void *getAsVoidPointer(const T *P) {
96 static inline const T *getFromVoidPointer(const void *P) {
include/llvm/Support/type_traits.h 55 struct add_const_past_pointer { using type = const T; };
include/llvm/Transforms/Instrumentation/AddressSanitizer.h 32 void parse(MDNode *MDN);
include/llvm/Transforms/Utils/BasicBlockUtils.h 303 MDNode *BranchWeights = nullptr,
325 MDNode *BranchWeights = nullptr);
include/llvm/Transforms/Utils/CallPromotionUtils.h 49 MDNode *BranchWeights = nullptr);
include/llvm/Transforms/Utils/FunctionComparator.h 334 int cmpRangeMetadata(const MDNode *L, const MDNode *R) const;
334 int cmpRangeMetadata(const MDNode *L, const MDNode *R) const;
include/llvm/Transforms/Utils/Local.h 471 void copyNonnullMetadata(const LoadInst &OldLI, MDNode *N, LoadInst &NewLI);
477 void copyRangeMetadata(const DataLayout &DL, const LoadInst &OldLI, MDNode *N,
include/llvm/Transforms/Utils/LoopUtils.h 210 Optional<MDNode *>
211 makeFollowupLoopID(MDNode *OrigLoopID, ArrayRef<StringRef> FollowupAttrs,
include/llvm/Transforms/Utils/LoopVersioning.h 136 DenseMap<const RuntimePointerChecking::CheckingPtrGroup *, MDNode *>
140 DenseMap<const RuntimePointerChecking::CheckingPtrGroup *, MDNode *>
include/llvm/Transforms/Utils/UnrollLoop.h 128 MDNode *GetUnrollMetadata(MDNode *LoopID, StringRef Name);
128 MDNode *GetUnrollMetadata(MDNode *LoopID, StringRef Name);
include/llvm/Transforms/Utils/ValueMapper.h 169 MDNode *mapMDNode(const MDNode &N);
169 MDNode *mapMDNode(const MDNode &N);
236 inline MDNode *MapMetadata(const MDNode *MD, ValueToValueMapTy &VM,
236 inline MDNode *MapMetadata(const MDNode *MD, ValueToValueMapTy &VM,
lib/Analysis/BranchProbabilityInfo.cpp 260 MDNode *WeightsNode = TI->getMetadata(LLVMContext::MD_prof);
lib/Analysis/LazyValueInfo.cpp 583 if (MDNode *Ranges = BBI->getMetadata(LLVMContext::MD_range))
1235 if (auto *Ranges = I->getMetadata(LLVMContext::MD_range))
lib/Analysis/LoopInfo.cpp 489 MDNode *Loop::getLoopID() const {
490 MDNode *LoopID = nullptr;
497 MDNode *MD = TI->getMetadata(LLVMContext::MD_loop);
513 void Loop::setLoopID(MDNode *LoopID) const {
528 MDNode *DisableUnrollMD =
529 MDNode::get(Context, MDString::get(Context, "llvm.loop.unroll.disable"));
530 MDNode *LoopID = getLoopID();
531 MDNode *NewLoopID = makePostTransformationMetadata(
537 MDNode *DesiredLoopIdMetadata = getLoopID();
542 MDNode *ParallelAccesses =
544 SmallPtrSet<MDNode *, 4>
548 MDNode *AccGroup = cast<MDNode>(MD.get());
548 MDNode *AccGroup = cast<MDNode>(MD.get());
565 if (MDNode *AccessGroup = I.getMetadata(LLVMContext::MD_access_group)) {
573 MDNode *AccGroup = cast<MDNode>(AccessListItem.get());
573 MDNode *AccGroup = cast<MDNode>(AccessListItem.get());
590 MDNode *LoopIdMD =
615 if (MDNode *LoopID = getLoopID()) {
976 MDNode *llvm::findOptionMDForLoopID(MDNode *LoopID, StringRef Name) {
976 MDNode *llvm::findOptionMDForLoopID(MDNode *LoopID, StringRef Name) {
987 MDNode *MD = dyn_cast<MDNode>(LoopID->getOperand(i));
987 MDNode *MD = dyn_cast<MDNode>(LoopID->getOperand(i));
1002 MDNode *llvm::findOptionMDForLoop(const Loop *TheLoop, StringRef Name) {
1006 bool llvm::isValidAsAccessGroup(MDNode *Node) {
1010 MDNode *llvm::makePostTransformationMetadata(LLVMContext &Context,
1011 MDNode *OrigLoopID,
1013 ArrayRef<MDNode *> AddAttrs) {
1018 TempMDTuple TempNode = MDNode::getTemporary(Context, None);
1027 if (MDNode *MD = dyn_cast<MDNode>(Op)) {
1027 if (MDNode *MD = dyn_cast<MDNode>(Op)) {
1044 MDNode *NewLoopID = MDNode::getDistinct(Context, MDs);
1044 MDNode *NewLoopID = MDNode::getDistinct(Context, MDs);
lib/Analysis/ModuleSummaryAnalysis.cpp 375 if (auto *MD = I.getMetadata(LLVMContext::MD_callees)) {
553 SmallVectorImpl<MDNode *> &Types) {
554 for (MDNode *Type : Types) {
572 SmallVectorImpl<MDNode *> &Types) {
755 SmallVector<MDNode *, 2> Types;
lib/Analysis/ScalarEvolution.cpp 5527 if (MDNode *MD = I->getMetadata(LLVMContext::MD_range))
lib/Analysis/ScopedNoAliasAA.cpp 58 const MDNode *Node = nullptr;
62 explicit AliasScopeNode(const MDNode *N) : Node(N) {}
65 const MDNode *getNode() const { return Node; }
68 const MDNode *getDomain() const {
71 return dyn_cast_or_null<MDNode>(Node->getOperand(1));
84 const MDNode *AScopes = LocA.AATags.Scope, *BScopes = LocB.AATags.Scope;
86 const MDNode *ANoAlias = LocA.AATags.NoAlias, *BNoAlias = LocB.AATags.NoAlias;
132 static void collectMDInDomain(const MDNode *List, const MDNode *Domain,
132 static void collectMDInDomain(const MDNode *List, const MDNode *Domain,
133 SmallPtrSetImpl<const MDNode *> &Nodes) {
135 if (const MDNode *MD = dyn_cast<MDNode>(MDOp))
135 if (const MDNode *MD = dyn_cast<MDNode>(MDOp))
140 bool ScopedNoAliasAAResult::mayAliasInScopes(const MDNode *Scopes,
141 const MDNode *NoAlias) const {
146 SmallPtrSet<const MDNode *, 16> Domains;
148 if (const MDNode *NAMD = dyn_cast<MDNode>(MDOp))
148 if (const MDNode *NAMD = dyn_cast<MDNode>(MDOp))
149 if (const MDNode *Domain = AliasScopeNode(NAMD).getDomain())
154 for (const MDNode *Domain : Domains) {
155 SmallPtrSet<const MDNode *, 16> ScopeNodes;
160 SmallPtrSet<const MDNode *, 16> NANodes;
165 for (const MDNode *SMD : ScopeNodes)
lib/Analysis/TypeBasedAliasAnalysis.cpp 135 static bool isNewFormatTypeNode(const MDNode *N) {
139 if (!isa<MDNode>(N->getOperand(0)))
192 using TBAANode = TBAANodeImpl<const MDNode>;
193 using MutableTBAANode = TBAANodeImpl<MDNode>;
222 return dyn_cast_or_null<MDNode>(Node->getOperand(0));
226 return dyn_cast_or_null<MDNode>(Node->getOperand(1));
256 using TBAAStructTagNode = TBAAStructTagNodeImpl<const MDNode>;
257 using MutableTBAAStructTagNode = TBAAStructTagNodeImpl<MDNode>;
265 const MDNode *Node = nullptr;
269 explicit TBAAStructTypeNode(const MDNode *N) : Node(N) {}
272 const MDNode *getNode() const { return Node; }
297 auto *TypeNode = cast<MDNode>(getNode()->getOperand(OpIndex));
297 auto *TypeNode = cast<MDNode>(getNode()->getOperand(OpIndex));
322 MDNode *P = dyn_cast_or_null<MDNode>(Node->getOperand(1));
322 MDNode *P = dyn_cast_or_null<MDNode>(Node->getOperand(1));
351 MDNode *P = dyn_cast_or_null<MDNode>(Node->getOperand(TheIdx));
351 MDNode *P = dyn_cast_or_null<MDNode>(Node->getOperand(TheIdx));
363 static bool isStructPathTBAA(const MDNode *MD) {
366 return isa<MDNode>(MD->getOperand(0)) && MD->getNumOperands() >= 3;
389 const MDNode *M = Loc.AATags.TBAA;
411 if (const MDNode *M = Call->getMetadata(LLVMContext::MD_tbaa))
430 if (const MDNode *L = Loc.AATags.TBAA)
431 if (const MDNode *M = Call->getMetadata(LLVMContext::MD_tbaa))
444 if (const MDNode *M1 = Call1->getMetadata(LLVMContext::MD_tbaa))
445 if (const MDNode *M2 = Call2->getMetadata(LLVMContext::MD_tbaa))
472 static bool matchAccessTags(const MDNode *A, const MDNode *B,
472 static bool matchAccessTags(const MDNode *A, const MDNode *B,
473 const MDNode **GenericTag = nullptr);
475 MDNode *MDNode::getMostGenericTBAA(MDNode *A, MDNode *B) {
475 MDNode *MDNode::getMostGenericTBAA(MDNode *A, MDNode *B) {
475 MDNode *MDNode::getMostGenericTBAA(MDNode *A, MDNode *B) {
476 const MDNode *GenericTag;
481 static const MDNode *getLeastCommonType(const MDNode *A, const MDNode *B) {
481 static const MDNode *getLeastCommonType(const MDNode *A, const MDNode *B) {
481 static const MDNode *getLeastCommonType(const MDNode *A, const MDNode *B) {
488 SmallSetVector<const MDNode *, 4> PathA;
497 SmallSetVector<const MDNode *, 4> PathB;
509 const MDNode *Ret = nullptr;
525 MDNode::getMostGenericTBAA(N.TBAA, getMetadata(LLVMContext::MD_tbaa));
530 N.Scope = MDNode::getMostGenericAliasScope(
537 MDNode::intersect(N.NoAlias, getMetadata(LLVMContext::MD_noalias));
542 static const MDNode *createAccessTag(const MDNode *AccessType) {
542 static const MDNode *createAccessTag(const MDNode *AccessType) {
560 return MDNode::get(AccessType->getContext(), Ops);
566 return MDNode::get(AccessType->getContext(), Ops);
588 const MDNode *CommonType,
589 const MDNode **GenericTag,
657 static bool matchAccessTags(const MDNode *A, const MDNode *B,
657 static bool matchAccessTags(const MDNode *A, const MDNode *B,
658 const MDNode **GenericTag) {
678 const MDNode *CommonType = getLeastCommonType(TagA.getAccessType(),
706 bool TypeBasedAAResult::Aliases(const MDNode *A, const MDNode *B) const {
706 bool TypeBasedAAResult::Aliases(const MDNode *A, const MDNode *B) const {
lib/Analysis/ValueTracking.cpp 438 void llvm::computeKnownBitsFromRangeMetadata(const MDNode &Ranges,
986 if (MDNode *MD =
1462 if (MDNode *MD =
1979 static bool rangeMetadataExcludesValue(const MDNode* Ranges, const APInt& Value) {
2042 if (MDNode *Ranges = Q.IIQ.getMetadata(I, LLVMContext::MD_range)) {
5708 if (auto *Range = IIQ.getMetadata(I, LLVMContext::MD_range))
lib/Analysis/VectorUtils.cpp 511 static void addToAccessGroupList(ListT &List, MDNode *AccGroups) {
520 auto *Item = cast<MDNode>(AccGroupListOp.get());
520 auto *Item = cast<MDNode>(AccGroupListOp.get());
526 MDNode *llvm::uniteAccessGroups(MDNode *AccGroups1, MDNode *AccGroups2) {
526 MDNode *llvm::uniteAccessGroups(MDNode *AccGroups1, MDNode *AccGroups2) {
526 MDNode *llvm::uniteAccessGroups(MDNode *AccGroups1, MDNode *AccGroups2) {
541 return cast<MDNode>(Union.front());
544 return MDNode::get(Ctx, Union.getArrayRef());
547 MDNode *llvm::intersectAccessGroups(const Instruction *Inst1,
559 MDNode *MD1 = Inst1->getMetadata(LLVMContext::MD_access_group);
560 MDNode *MD2 = Inst2->getMetadata(LLVMContext::MD_access_group);
577 auto *Item = cast<MDNode>(Node.get());
577 auto *Item = cast<MDNode>(Node.get());
587 return cast<MDNode>(Intersection.front());
590 return MDNode::get(Ctx, Intersection);
596 SmallVector<std::pair<unsigned, MDNode *>, 4> Metadata;
603 MDNode *MD = I0->getMetadata(Kind);
607 MDNode *IMD = IJ->getMetadata(Kind);
610 MD = MDNode::getMostGenericTBAA(MD, IMD);
613 MD = MDNode::getMostGenericAliasScope(MD, IMD);
616 MD = MDNode::getMostGenericFPMath(MD, IMD);
621 MD = MDNode::intersect(MD, IMD);
lib/AsmParser/LLParser.cpp 227 MDNode *MD = Inst->getMetadata(LLVMContext::MD_tbaa);
229 auto *UpgradedMD = UpgradeTBAANode(*MD);
485 std::vector<std::pair<unsigned, MDNode *>> MDs;
488 MDNode *N;
675 bool LLParser::ParseMDNodeID(MDNode *&Result) {
712 MDNode *N = nullptr;
737 MDNode *Init;
2020 bool LLParser::ParseMetadataAttachment(unsigned &Kind, MDNode *&MD) {
2038 MDNode *N;
2055 MDNode *N;
3723 bool LLParser::ParseMDTuple(MDNode *&MD, bool IsDistinct) {
3736 bool LLParser::ParseMDNode(MDNode *&N) {
3744 bool LLParser::ParseMDNodeTail(MDNode *&N) {
4374 bool LLParser::ParseSpecializedMDNode(MDNode *&N, bool IsDistinct) {
4410 bool LLParser::ParseDILocation(MDNode *&Result, bool IsDistinct) {
4428 bool LLParser::ParseGenericDINode(MDNode *&Result, bool IsDistinct) {
4444 bool LLParser::ParseDISubrange(MDNode *&Result, bool IsDistinct) {
4465 bool LLParser::ParseDIEnumerator(MDNode *&Result, bool IsDistinct) {
4488 bool LLParser::ParseDIBasicType(MDNode *&Result, bool IsDistinct) {
4509 bool LLParser::ParseDIDerivedType(MDNode *&Result, bool IsDistinct) {
4538 bool LLParser::ParseDICompositeType(MDNode *&Result, bool IsDistinct) {
4581 bool LLParser::ParseDISubroutineType(MDNode *&Result, bool IsDistinct) {
4599 bool LLParser::ParseDIFile(MDNode *&Result, bool IsDistinct) {
4632 bool LLParser::ParseDICompileUnit(MDNode *&Result, bool IsDistinct) {
4675 bool LLParser::ParseDISubprogram(MDNode *&Result, bool IsDistinct) {
4723 bool LLParser::ParseDILexicalBlock(MDNode *&Result, bool IsDistinct) {
4739 bool LLParser::ParseDILexicalBlockFile(MDNode *&Result, bool IsDistinct) {
4754 bool LLParser::ParseDICommonBlock(MDNode *&Result, bool IsDistinct) {
4772 bool LLParser::ParseDINamespace(MDNode *&Result, bool IsDistinct) {
4787 bool LLParser::ParseDIMacro(MDNode *&Result, bool IsDistinct) {
4803 bool LLParser::ParseDIMacroFile(MDNode *&Result, bool IsDistinct) {
4820 bool LLParser::ParseDIModule(MDNode *&Result, bool IsDistinct) {
4837 bool LLParser::ParseDITemplateTypeParameter(MDNode *&Result, bool IsDistinct) {
4852 bool LLParser::ParseDITemplateValueParameter(MDNode *&Result, bool IsDistinct) {
4871 bool LLParser::ParseDIGlobalVariable(MDNode *&Result, bool IsDistinct) {
4902 bool LLParser::ParseDILocalVariable(MDNode *&Result, bool IsDistinct) {
4923 bool LLParser::ParseDILabel(MDNode *&Result, bool IsDistinct) {
4939 bool LLParser::ParseDIExpression(MDNode *&Result, bool IsDistinct) {
4986 bool LLParser::ParseDIGlobalVariableExpression(MDNode *&Result,
5002 bool LLParser::ParseDIObjCProperty(MDNode *&Result, bool IsDistinct) {
5023 bool LLParser::ParseDIImportedEntity(MDNode *&Result, bool IsDistinct) {
5093 MDNode *N;
5122 MDNode *N;
lib/AsmParser/LLParser.h 337 bool ParseMDNodeID(MDNode *&Result);
520 bool ParseMDTuple(MDNode *&MD, bool IsDistinct = false);
521 bool ParseMDNode(MDNode *&N);
522 bool ParseMDNodeTail(MDNode *&N);
524 bool ParseMetadataAttachment(unsigned &Kind, MDNode *&MD);
536 bool ParseSpecializedMDNode(MDNode *&N, bool IsDistinct = false);
lib/Bitcode/Reader/BitcodeReader.cpp 2927 for (const MDOperand &MDOptions : cast<MDNode>(Val)->operands())
2928 LinkerOpts->addOperand(cast<MDNode>(MDOptions));
3847 MDNode *Scope = nullptr, *IA = nullptr;
3849 Scope = dyn_cast_or_null<MDNode>(
3855 IA = dyn_cast_or_null<MDNode>(
5274 MDNode *TBAA = I.getMetadata(LLVMContext::MD_tbaa);
lib/Bitcode/Reader/MetadataLoader.cpp 180 MDNode *getMDNodeFwdRefOrNull(unsigned Idx);
203 if (auto *MDN = dyn_cast<MDNode>(MD))
203 if (auto *MDN = dyn_cast<MDNode>(MD))
243 Metadata *MD = MDNode::getTemporary(Context, None).release();
250 if (auto *N = dyn_cast_or_null<MDNode>(MD))
250 if (auto *N = dyn_cast_or_null<MDNode>(MD))
256 MDNode *BitcodeReaderMetadataList::getMDNodeFwdRefOrNull(unsigned Idx) {
257 return dyn_cast_or_null<MDNode>(getMetadataFwdRef(Idx));
294 auto *N = dyn_cast_or_null<MDNode>(MD);
294 auto *N = dyn_cast_or_null<MDNode>(MD);
325 Ref = MDNode::getTemporary(Context, None);
386 auto *N = dyn_cast_or_null<MDNode>(MD);
386 auto *N = dyn_cast_or_null<MDNode>(MD);
405 if (auto *MDN = dyn_cast<MDNode>(MD))
405 if (auto *MDN = dyn_cast<MDNode>(MD))
514 SmallVector<MDNode *, 1> MDs;
517 for (auto *MD : MDs)
816 MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(Record[i]);
990 auto *N = cast<MDNode>(MD);
990 auto *N = cast<MDNode>(MD);
1127 MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(Record[i]);
1144 MetadataList.assignValue(MDNode::get(Context, None), NextMetadataNo);
1186 MetadataList.assignValue(MDNode::get(Context, Elts), NextMetadataNo);
1212 MetadataList.assignValue(IsDistinct ? MDNode::getDistinct(Context, Elts)
1213 : MDNode::get(Context, Elts),
1968 MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(Record[I + 1]);
2047 MDNode *MD = dyn_cast_or_null<MDNode>(Node);
2047 MDNode *MD = dyn_cast_or_null<MDNode>(Node);
lib/Bitcode/Writer/BitcodeWriter.cpp 1947 for (const MDNode *N : NMD.operands())
2017 if (const MDNode *N = dyn_cast<MDNode>(MD)) {
2017 if (const MDNode *N = dyn_cast<MDNode>(MD)) {
2147 SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
2168 SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
lib/Bitcode/Writer/ValueEnumerator.cpp 379 SmallVector<std::pair<unsigned, MDNode *>, 8> MDs;
581 SmallVector<const MDNode *, 64> Worklist;
595 if (auto *N = dyn_cast<MDNode>(MD.first))
614 SmallVector<const MDNode *, 32> DelayedDistinctNodes;
618 SmallVector<std::pair<const MDNode *, MDNode::op_iterator>, 32> Worklist;
618 SmallVector<std::pair<const MDNode *, MDNode::op_iterator>, 32> Worklist;
619 if (const MDNode *N = enumerateMetadataImpl(F, MD))
623 const MDNode *N = Worklist.back().first;
627 MDNode::op_iterator I = std::find_if(
631 auto *Op = cast<MDNode>(*I);
631 auto *Op = cast<MDNode>(*I);
650 for (const MDNode *N : DelayedDistinctNodes)
657 const MDNode *ValueEnumerator::enumerateMetadataImpl(unsigned F, const Metadata *MD) {
675 if (auto *N = dyn_cast<MDNode>(MD))
716 auto *N = dyn_cast<MDNode>(MD);
lib/Bitcode/Writer/ValueEnumerator.h 265 const MDNode *enumerateMetadataImpl(unsigned F, const Metadata *MD);
lib/CodeGen/AsmPrinter/AsmPrinter.cpp 2055 const MDNode *N = NMD->getOperand(i);
2077 const MDNode *N = NMD->getOperand(i);
lib/CodeGen/AsmPrinter/AsmPrinterInlineAsm.cpp 51 const MDNode *LocInfo = nullptr;
73 const MDNode *LocMDNode) const {
111 const MDNode *LocMDNode,
497 const MDNode *LocMD = nullptr;
lib/CodeGen/AsmPrinter/CodeViewDebug.cpp 770 const MDNode *Node = *CUs->operands().begin();
827 const MDNode *Node = *CUs->operands().begin(); // FIXME: Multiple CUs.
2860 if (MDNode *MD = MI.getHeapAllocMarker()) {
2991 for (const MDNode *Node : CUs->operands()) {
3058 for (const MDNode *Node : CUs->operands()) {
lib/CodeGen/AsmPrinter/CodeViewDebug.h 150 std::vector<std::pair<MCSymbol *, MDNode *>> Annotations;
lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp 793 for (const auto *IE : ImportedEntities[Scope->getScopeNode()])
lib/CodeGen/AsmPrinter/DwarfCompileUnit.h 61 using ImportedEntityList = SmallVector<const MDNode *, 8>;
62 using ImportedEntityMap = DenseMap<const MDNode *, ImportedEntityList>;
79 DenseMap<const MDNode *, DIE *> AbstractSPDies;
91 DenseMap<const MDNode *, DIE *> &getAbstractSPDies() {
lib/CodeGen/AsmPrinter/DwarfDebug.cpp 1245 const MDNode *ScopeNode) {
1254 const DINode *Node, const MDNode *ScopeNode) {
1665 const MDNode *Scope = DL.getScope();
1691 const MDNode *Scope = nullptr;
1718 const MDNode *Scope = DL.getScope();
1740 const MDNode *S, unsigned Flags, unsigned CUID,
1861 const MDNode *Scope = nullptr;
1899 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
lib/CodeGen/AsmPrinter/DwarfDebug.h 297 MapVector<const MDNode *, DwarfCompileUnit *> CUMap;
339 DenseMap<const MDNode *, uint64_t> TypeSignatures;
426 const MDNode *Scope);
429 const MDNode *Scope);
564 void recordSourceLine(unsigned Line, unsigned Col, const MDNode *Scope,
lib/CodeGen/AsmPrinter/DwarfFile.h 98 DenseMap<const MDNode *, DIE *> AbstractSPDies;
104 DenseMap<const MDNode *, DIE *> DITypeNodeToDieMap;
173 DenseMap<const MDNode *, DIE *> &getAbstractSPDies() {
181 void insertDIE(const MDNode *TypeMD, DIE *Die) {
185 DIE *getDIE(const MDNode *TypeMD) {
lib/CodeGen/AsmPrinter/DwarfUnit.cpp 680 DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
lib/CodeGen/AsmPrinter/DwarfUnit.h 63 DenseMap<const MDNode *, DIE *> MDNodeToDieMap;
237 DIE *getOrCreateTypeDIE(const MDNode *TyNode);
lib/CodeGen/GlobalISel/GISelKnownBits.cpp 296 if (const MDNode *Ranges = MMO->getRanges()) {
lib/CodeGen/GlobalISel/IRTranslator.cpp 884 const MDNode *Ranges =
lib/CodeGen/GlobalISel/MachineIRBuilder.cpp 90 MachineIRBuilder::buildDirectDbgValue(Register Reg, const MDNode *Variable,
91 const MDNode *Expr) {
103 MachineIRBuilder::buildIndirectDbgValue(Register Reg, const MDNode *Variable,
104 const MDNode *Expr) {
120 const MDNode *Variable,
121 const MDNode *Expr) {
139 const MDNode *Variable,
140 const MDNode *Expr) {
162 MachineInstrBuilder MachineIRBuilder::buildDbgLabel(const MDNode *Label) {
lib/CodeGen/ImplicitNullChecks.cpp 464 MDNode *BranchMD = nullptr;
lib/CodeGen/LexicalScopes.cpp 326 const MDNode *N = Desc;
lib/CodeGen/MIRParser/MIParser.cpp 403 bool parseStandaloneMDNode(MDNode *&Node);
442 bool parseMDNode(MDNode *&Node);
443 bool parseDIExpression(MDNode *&Expr);
444 bool parseDILocation(MDNode *&Expr);
939 MDNode *Node = nullptr;
1057 bool MIParser::parseStandaloneMDNode(MDNode *&Node) {
1827 bool MIParser::parseMDNode(MDNode *&Node) {
1845 bool MIParser::parseDIExpression(MDNode *&Expr) {
1891 bool MIParser::parseDILocation(MDNode *&Loc) {
1898 MDNode *Scope = nullptr;
1899 MDNode *InlinedAt = nullptr;
1995 MDNode *Node = nullptr;
2897 MDNode *Range = nullptr;
3087 MDNode *&Node, StringRef Src, SMDiagnostic &Error) {
lib/CodeGen/MIRParser/MIRParser.cpp 140 bool parseMDNode(PerFunctionMIParsingState &PFS, MDNode *&Node,
763 static bool typecheckMDNode(T *&Result, MDNode *Node,
781 MDNode *Var = nullptr, *Expr = nullptr, *Loc = nullptr;
800 MDNode *&Node, const yaml::StringValue &Source) {
lib/CodeGen/MachineFunction.cpp 402 unsigned base_alignment, const AAMDNodes &AAInfo, const MDNode *Ranges,
452 MCSymbol *PostInstrSymbol, MDNode *HeapAllocMarker) {
lib/CodeGen/MachineInstr.cpp 323 MDNode *HeapAllocMarker) {
497 void MachineInstr::setHeapAllocMarker(MachineFunction &MF, MDNode *Marker) {
1704 if (MDNode *HeapAllocMarker = getHeapAllocMarker()) {
1994 const MDNode *LocMD = nullptr;
2015 Register Reg, const MDNode *Variable,
2016 const MDNode *Expr) {
2031 MachineOperand &MO, const MDNode *Variable,
2032 const MDNode *Expr) {
lib/CodeGen/MachineOperand.cpp 1019 const MDNode *Ranges, SyncScope::ID SSID,
lib/CodeGen/MachinePipeliner.cpp 275 MDNode *LoopID = TI->getMetadata(LLVMContext::MD_loop);
283 MDNode *MD = dyn_cast<MDNode>(LoopID->getOperand(i));
283 MDNode *MD = dyn_cast<MDNode>(LoopID->getOperand(i));
lib/CodeGen/SafeStack.cpp 470 MDNode *Weights = MDBuilder(F.getContext())
lib/CodeGen/SelectionDAG/FastISel.cpp 1242 if (MDNode *MD = CLI.CS->getInstruction()->getMetadata("heapallocsite"))
2414 const MDNode *Ranges = I->getMetadata(LLVMContext::MD_range);
lib/CodeGen/SelectionDAG/InstrEmitter.cpp 679 MDNode *Var = SD->getVariable();
766 MDNode *Label = SD->getLabel();
1147 const MDNode *MD = cast<MDNodeSDNode>(MDV)->getMD();
lib/CodeGen/SelectionDAG/SDNodeDbgValue.h 145 MDNode *Label;
150 SDDbgLabel(MDNode *Label, DebugLoc dl, unsigned O)
154 MDNode *getLabel() const { return Label; }
lib/CodeGen/SelectionDAG/ScheduleDAGSDNodes.cpp 913 if (MDNode *MD = DAG->getHeapAllocSite(N))
926 if (MDNode *MD = DAG->getHeapAllocSite(SU->getNode())) {
lib/CodeGen/SelectionDAG/SelectionDAG.cpp 1843 SDValue SelectionDAG::getMDNode(const MDNode *MD) {
2977 } else if (const MDNode *Ranges = LD->getRanges()) {
6699 const AAMDNodes &AAInfo, const MDNode *Ranges) {
6771 const AAMDNodes &AAInfo, const MDNode *Ranges) {
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp 4032 const MDNode *Ranges = I.getMetadata(LLVMContext::MD_range);
4463 const MDNode *Ranges = I.getMetadata(LLVMContext::MD_range);
4506 const MDNode *Ranges = I.getMetadata(LLVMContext::MD_range);
5676 DAG.getMDNode(cast<MDNode>(cast<MetadataAsValue>(Reg)->getMetadata()));
5689 DAG.getMDNode(cast<MDNode>(cast<MetadataAsValue>(Reg)->getMetadata()));
6438 MF.addCodeViewAnnotation(Label, cast<MDNode>(MD));
8183 const MDNode *SrcLoc = CS.getInstruction()->getMetadata("srcloc");
8579 const MDNode *Range = I.getMetadata(LLVMContext::MD_range);
lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp 595 const MDNode *Variable = MI->getDebugVariable();
596 const MDNode *Expr = MI->getDebugExpression();
lib/CodeGen/StackProtector.cpp 509 MDNode *Weights = MDBuilder(F->getContext())
lib/CodeGen/TargetLoweringObjectFileImpl.cpp 277 if (cast<MDNode>(Operand)->getNumOperands() != 2)
279 for (const auto &Option : cast<MDNode>(Operand)->operands()) {
294 cast<MDString>(cast<MDNode>(Operand)->getOperand(0))->getString());
316 MDNode *CFGProfile = nullptr;
321 CFGProfile = cast<MDNode>(MFE.Val);
338 MDNode *E = cast<MDNode>(Edge);
338 MDNode *E = cast<MDNode>(Edge);
517 MDNode *MD = GO->getMetadata(LLVMContext::MD_associated);
890 for (const auto &Piece : cast<MDNode>(Option)->operands())
1453 for (const auto &Piece : cast<MDNode>(Option)->operands()) {
lib/ExecutionEngine/Orc/IndirectionUtils.cpp 369 for (auto *MF : MFs->operands())
lib/IR/AbstractCallSite.cpp 74 MDNode *CallbackMD = Callee->getMetadata(LLVMContext::MD_callback);
82 MDNode *CallbackEncMD = nullptr;
84 MDNode *OpMD = cast<MDNode>(Op.get());
84 MDNode *OpMD = cast<MDNode>(Op.get());
lib/IR/AsmWriter.cpp 696 DenseMap<const MDNode*, unsigned> mdnMap;
742 int getMetadataSlot(const MDNode *N);
763 using mdn_iterator = DenseMap<const MDNode*, unsigned>::iterator;
791 void CreateMetadataSlot(const MDNode *N);
1052 SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
1073 if (MDNode *N = dyn_cast<MDNode>(V->getMetadata()))
1073 if (MDNode *N = dyn_cast<MDNode>(V->getMetadata()))
1077 SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
1105 int SlotTracker::getMetadataSlot(const MDNode *N) {
1192 void SlotTracker::CreateMetadataSlot(const MDNode *N) {
1206 if (const MDNode *Op = dyn_cast_or_null<MDNode>(N->getOperand(i)))
1206 if (const MDNode *Op = dyn_cast_or_null<MDNode>(N->getOperand(i)))
2203 static void WriteMDNodeBodyInternal(raw_ostream &Out, const MDNode *Node,
2314 if (const MDNode *N = dyn_cast<MDNode>(MD)) {
2314 if (const MDNode *N = dyn_cast<MDNode>(MD)) {
2379 void printMDNodeBody(const MDNode *MD);
2398 void writeMDNode(unsigned Slot, const MDNode *Node);
2437 const SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs,
3169 MDNode *Op = NMD->getOperand(i);
3307 SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
3427 SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
3526 SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
4078 SmallVector<std::pair<unsigned, MDNode *>, 4> InstMD;
4087 const SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs,
4108 void AssemblyWriter::writeMDNode(unsigned Slot, const MDNode *Node) {
4115 SmallVector<const MDNode *, 16> Nodes;
4119 Nodes[I->second] = cast<MDNode>(I->first);
4126 void AssemblyWriter::printMDNodeBody(const MDNode *Node) {
4275 if (isa<MDNode>(V->getMetadata()))
4391 auto *N = dyn_cast<MDNode>(&MD);
4400 ModuleSlotTracker MST(M, isa<MDNode>(this));
4411 ModuleSlotTracker MST(M, isa<MDNode>(this));
lib/IR/AutoUpgrade.cpp 1673 MDNode *Node = MDNode::get(C, Elts);
1673 MDNode *Node = MDNode::get(C, Elts);
1700 MDNode *Node = MDNode::get(C, Elts);
1700 MDNode *Node = MDNode::get(C, Elts);
3024 MDNode *Node = MDNode::get(
3024 MDNode *Node = MDNode::get(
3743 MDNode *llvm::UpgradeTBAANode(MDNode &MD) {
3743 MDNode *llvm::UpgradeTBAANode(MDNode &MD) {
3745 if (isa<MDNode>(MD.getOperand(0)) && MD.getNumOperands() >= 3)
3751 MDNode *ScalarType = MDNode::get(Context, Elts);
3751 MDNode *ScalarType = MDNode::get(Context, Elts);
3757 return MDNode::get(Context, Elts2);
3762 return MDNode::get(Context, Elts);
3840 MDNode *Op = ModRetainReleaseMarker->getOperand(0);
3987 MDNode *Op = ModFlags->getOperand(I);
4008 ModFlags->setOperand(I, MDNode::get(M.getContext(), Ops));
4026 ModFlags->setOperand(I, MDNode::get(M.getContext(), Ops));
4122 MDNode *llvm::upgradeInstructionLoopAttachment(MDNode &N) {
4122 MDNode *llvm::upgradeInstructionLoopAttachment(MDNode &N) {
lib/IR/BasicBlock.cpp 481 if (MDNode *MDIrrLoopHeader =
lib/IR/ConstantRange.cpp 1494 ConstantRange llvm::getConstantRangeFromMetadata(const MDNode &Ranges) {
lib/IR/Core.cpp 866 if (auto *MD = I->getMetadata(KindID))
874 static MDNode *extractMDNode(MetadataAsValue *MAV) {
879 if (MDNode *N = dyn_cast<MDNode>(MD))
879 if (MDNode *N = dyn_cast<MDNode>(MD))
882 return MDNode::get(MAV->getContext(), MD);
886 MDNode *N = Val ? extractMDNode(unwrap<MetadataAsValue>(Val)) : nullptr;
896 using MetadataEntries = SmallVectorImpl<std::pair<unsigned, MDNode *>>;
900 SmallVector<std::pair<unsigned, MDNode *>, 8> MVEs;
934 if (isa<MDNode>(MD->getMetadata()) ||
973 static LLVMValueRef getMDNodeOperandImpl(LLVMContext &Context, const MDNode *N,
991 cast<MDNode>(MD->getMetadata()), Index);
1055 return wrap(MDNode::get(*unwrap(C), ArrayRef<Metadata*>(unwrap(MDs), Count)));
1093 return wrap(MetadataAsValue::get(Context, MDNode::get(Context, MDs)));
1127 return cast<MDNode>(MD->getMetadata())->getNumOperands();
1184 const auto *N = cast<MDNode>(MD->getMetadata());
1184 const auto *N = cast<MDNode>(MD->getMetadata());
2055 unwrap<GlobalObject>(Global)->setMetadata(Kind, unwrap<MDNode>(MD));
3041 unwrap(Builder)->SetCurrentDebugLocation(DebugLoc(unwrap<MDNode>(Loc)));
3047 MDNode *Loc =
3048 L ? cast<MDNode>(unwrap<MetadataAsValue>(L)->getMetadata()) : nullptr;
3066 ? unwrap<MDNode>(FPMathTag)
lib/IR/DIBuilder.cpp 38 void DIBuilder::trackIfUnresolved(MDNode *N) {
389 DIType *Ty, MDNode *PropertyNode) {
447 DIType *VTableHolder, MDNode *TemplateParams, StringRef UniqueIdentifier) {
539 return MDNode::replaceWithDistinct(std::move(NewSP));
545 return MDNode::replaceWithUniqued(std::move(NewTy));
614 if (Elements[i] && isa<MDNode>(Elements[i]))
619 return DITypeRefArray(MDNode::get(VMContext, Elts));
642 MDNode *Decl, MDTuple *templateParams, uint32_t AlignInBits) {
658 unsigned LineNumber, DIType *Ty, bool isLocalToUnit, MDNode *Decl,
671 DenseMap<MDNode *, SmallVector<TrackingMDNodeRef, 1>> &PreservedVariables,
996 if (auto *N = dyn_cast_or_null<MDNode>(O))
996 if (auto *N = dyn_cast_or_null<MDNode>(O))
lib/IR/DebugInfo.cpp 43 DISubprogram *llvm::getDISubprogram(const MDNode *Scope) {
199 auto *N = dyn_cast<MDNode>(DDI->getVariable());
199 auto *N = dyn_cast<MDNode>(DDI->getVariable());
214 auto *N = dyn_cast<MDNode>(DVI->getVariable());
214 auto *N = dyn_cast<MDNode>(DVI->getVariable());
281 static MDNode *stripDebugLocFromLoopID(MDNode *N) {
281 static MDNode *stripDebugLocFromLoopID(MDNode *N) {
299 auto TempNode = MDNode::getTemporary(N->getContext(), None);
308 MDNode *LoopID = MDNode::get(N->getContext(), Args);
308 MDNode *LoopID = MDNode::get(N->getContext(), Args);
320 DenseMap<MDNode*, MDNode*> LoopIDsMap;
320 DenseMap<MDNode*, MDNode*> LoopIDsMap;
339 if (auto *LoopID = TermInst->getMetadata(LLVMContext::MD_loop)) {
340 auto *NewLoopID = LoopIDsMap.lookup(LoopID);
388 MDNode *EmptySubroutineType;
407 MDNode::get(C, {}))) {}
418 MDNode *mapNode(Metadata *N) { return dyn_cast_or_null<MDNode>(map(N)); }
418 MDNode *mapNode(Metadata *N) { return dyn_cast_or_null<MDNode>(map(N)); }
422 void traverseAndRemap(MDNode *N) { traverse(N); }
506 MDNode *getReplacementMDNode(MDNode *N) {
506 MDNode *getReplacementMDNode(MDNode *N) {
512 auto *Ret = MDNode::get(N->getContext(), Ops);
517 void remap(MDNode *N) {
551 void traverse(MDNode *);
556 void DebugTypeInfoRemoval::traverse(MDNode *N) {
568 SmallVector<MDNode *, 16> ToVisit;
569 DenseSet<MDNode *> Opened;
574 auto *N = ToVisit.back();
582 if (auto *MDN = dyn_cast_or_null<MDNode>(I))
582 if (auto *MDN = dyn_cast_or_null<MDNode>(I))
623 auto *NewNode = Mapper.mapNode(Node);
641 auto *Scope = DL.getScope();
642 MDNode *InlinedAt = DL.getInlinedAt();
652 SmallVector<std::pair<unsigned, MDNode *>, 2> MDs;
667 SmallVector<MDNode *, 8> Ops;
668 for (MDNode *Op : NMD.operands())
675 for (auto *Op : Ops)
709 template <typename DIT> DIT *unwrapDI(LLVMMetadataRef Ref) {
710 return (DIT *)(Ref ? unwrap<MDNode>(Ref) : nullptr);
1084 unwrapDI<MDNode>(PropertyNode)));
1218 unwrapDI<MDNode>(TemplateParamsNode),
1293 unwrap<DIExpression>(Expr), unwrapDI<MDNode>(Decl),
1325 MDNode::deleteTemporary(unwrapDI<MDNode>(TempNode));
1325 MDNode::deleteTemporary(unwrapDI<MDNode>(TempNode));
1330 auto *Node = unwrapDI<MDNode>(TargetMetadata);
1330 auto *Node = unwrapDI<MDNode>(TargetMetadata);
1332 MDNode::deleteTemporary(Node);
1343 unwrapDI<MDNode>(Decl), nullptr, AlignInBits));
1439 unwrap<Instruction>(Inst)->setDebugLoc(DebugLoc(unwrap<MDNode>(Loc)));
lib/IR/DebugLoc.cpp 19 DebugLoc::DebugLoc(const MDNode *L) : Loc(const_cast<MDNode *>(L)) {}
35 MDNode *DebugLoc::getScope() const {
45 MDNode *DebugLoc::getInlinedAtScope() const {
51 const MDNode *Scope = getInlinedAtScope();
71 DebugLoc DebugLoc::get(unsigned Line, unsigned Col, const MDNode *Scope,
72 const MDNode *InlinedAt, bool ImplicitCode) {
84 DenseMap<const MDNode *, MDNode *> &Cache,
84 DenseMap<const MDNode *, MDNode *> &Cache,
93 if (auto *Found = Cache[IA]) {
lib/IR/DiagnosticInfo.cpp 57 if (const MDNode *SrcLoc = I.getMetadata("srcloc")) {
lib/IR/Function.cpp 1548 MDNode *MD = getMetadata(LLVMContext::MD_prof);
1571 if (MDNode *MD = getMetadata(LLVMContext::MD_prof))
1588 if (MDNode *MD = getMetadata(LLVMContext::MD_section_prefix)) {
lib/IR/Globals.cpp 307 MDNode *MD = GO->getMetadata(LLVMContext::MD_absolute_symbol);
lib/IR/IRBuilder.cpp 101 bool isVolatile, MDNode *TBAATag, MDNode *ScopeTag,
101 bool isVolatile, MDNode *TBAATag, MDNode *ScopeTag,
102 MDNode *NoAliasTag) {
129 MDNode *TBAATag, MDNode *ScopeTag, MDNode *NoAliasTag) {
129 MDNode *TBAATag, MDNode *ScopeTag, MDNode *NoAliasTag) {
129 MDNode *TBAATag, MDNode *ScopeTag, MDNode *NoAliasTag) {
159 Value *Size, bool isVolatile, MDNode *TBAATag,
160 MDNode *TBAAStructTag, MDNode *ScopeTag, MDNode *NoAliasTag) {
160 MDNode *TBAAStructTag, MDNode *ScopeTag, MDNode *NoAliasTag) {
160 MDNode *TBAAStructTag, MDNode *ScopeTag, MDNode *NoAliasTag) {
198 uint32_t ElementSize, MDNode *TBAATag, MDNode *TBAAStructTag,
198 uint32_t ElementSize, MDNode *TBAATag, MDNode *TBAAStructTag,
199 MDNode *ScopeTag, MDNode *NoAliasTag) {
199 MDNode *ScopeTag, MDNode *NoAliasTag) {
239 Value *Size, bool isVolatile, MDNode *TBAATag, MDNode *ScopeTag,
239 Value *Size, bool isVolatile, MDNode *TBAATag, MDNode *ScopeTag,
240 MDNode *NoAliasTag) {
274 uint32_t ElementSize, MDNode *TBAATag, MDNode *TBAAStructTag,
274 uint32_t ElementSize, MDNode *TBAATag, MDNode *TBAAStructTag,
275 MDNode *ScopeTag, MDNode *NoAliasTag) {
275 MDNode *ScopeTag, MDNode *NoAliasTag) {
lib/IR/Instruction.cpp 692 MDNode *ProfileData = getMetadata(LLVMContext::MD_prof);
705 MDNode::get(ProfileData->getContext(), Ops));
719 SmallVector<std::pair<unsigned, MDNode *>, 4> TheMDs;
lib/IR/Instructions.cpp 467 auto *ProfileData = getMetadata(LLVMContext::MD_prof);
512 setMetadata(LLVMContext::MD_prof, MDNode::get(getContext(), Vals));
2438 const MDNode *MD =
3891 MDNode *
3893 if (MDNode *ProfileData = SI.getMetadata(LLVMContext::MD_prof))
3900 MDNode *SwitchInstProfUpdateWrapper::buildProfBranchWeightsMD() {
3919 MDNode *ProfileData = getProfBranchWeightsMD(SI);
4006 if (MDNode *ProfileData = getProfBranchWeightsMD(SI))
lib/IR/LLVMContextImpl.cpp 60 for (auto *I : DistinctMDNodes)
74 for (MDNode *I : DistinctMDNodes)
182 unsigned MDNodeOpsKey::calculateHash(MDNode *N, unsigned Offset) {
lib/IR/LLVMContextImpl.h 229 static unsigned calculateHash(MDNode *N, unsigned Offset = 0);
233 static bool compareOps(ArrayRef<T> Ops, const MDNode *RHS, unsigned Offset) {
1183 MDNode *lookup(unsigned ID) const;
1189 void set(unsigned ID, MDNode &MD);
1200 void getAll(SmallVectorImpl<std::pair<unsigned, MDNode *>> &Result) const;
1227 void get(unsigned ID, SmallVectorImpl<MDNode *> &Result) const;
1231 MDNode *lookup(unsigned ID) const;
1233 void insert(unsigned ID, MDNode &MD);
1239 void getAll(SmallVectorImpl<std::pair<unsigned, MDNode *>> &Result) const;
1289 std::vector<MDNode *> DistinctMDNodes;
1367 int getOrAddScopeRecordIdxEntry(MDNode *N, int ExistingIdx);
1368 int getOrAddScopeInlinedAtIdxEntry(MDNode *Scope, MDNode *IA,int ExistingIdx);
1368 int getOrAddScopeInlinedAtIdxEntry(MDNode *Scope, MDNode *IA,int ExistingIdx);
lib/IR/MDBuilder.cpp 28 MDNode *MDBuilder::createFPMath(float Accuracy) {
34 return MDNode::get(Context, Op);
37 MDNode *MDBuilder::createBranchWeights(uint32_t TrueWeight,
42 MDNode *MDBuilder::createBranchWeights(ArrayRef<uint32_t> Weights) {
52 return MDNode::get(Context, Vals);
55 MDNode *MDBuilder::createUnpredictable() {
56 return MDNode::get(Context, None);
59 MDNode *MDBuilder::createFunctionEntryCount(
75 return MDNode::get(Context, Ops);
78 MDNode *MDBuilder::createFunctionSectionPrefix(StringRef Prefix) {
79 return MDNode::get(Context,
84 MDNode *MDBuilder::createRange(const APInt &Lo, const APInt &Hi) {
91 MDNode *MDBuilder::createRange(Constant *Lo, Constant *Hi) {
97 return MDNode::get(Context, {createConstant(Lo), createConstant(Hi)});
100 MDNode *MDBuilder::createCallees(ArrayRef<Function *> Callees) {
104 return MDNode::get(Context, Ops);
107 MDNode *MDBuilder::createCallbackEncoding(unsigned CalleeArgNo,
121 return MDNode::get(Context, Ops);
124 MDNode *MDBuilder::mergeCallbackEncodings(MDNode *ExistingCallbacks,
124 MDNode *MDBuilder::mergeCallbackEncodings(MDNode *ExistingCallbacks,
125 MDNode *NewCB) {
127 return MDNode::get(Context, {NewCB});
150 return MDNode::get(Context, Ops);
153 MDNode *MDBuilder::createAnonymousAARoot(StringRef Name, MDNode *Extra) {
153 MDNode *MDBuilder::createAnonymousAARoot(StringRef Name, MDNode *Extra) {
155 auto Dummy = MDNode::getTemporary(Context, None);
162 MDNode *Root = MDNode::get(Context, Args);
162 MDNode *Root = MDNode::get(Context, Args);
175 MDNode *MDBuilder::createTBAARoot(StringRef Name) {
176 return MDNode::get(Context, createString(Name));
181 MDNode *MDBuilder::createTBAANode(StringRef Name, MDNode *Parent,
181 MDNode *MDBuilder::createTBAANode(StringRef Name, MDNode *Parent,
185 return MDNode::get(Context,
188 return MDNode::get(Context, {createString(Name), Parent});
191 MDNode *MDBuilder::createAliasScopeDomain(StringRef Name) {
192 return MDNode::get(Context, createString(Name));
195 MDNode *MDBuilder::createAliasScope(StringRef Name, MDNode *Domain) {
195 MDNode *MDBuilder::createAliasScope(StringRef Name, MDNode *Domain) {
196 return MDNode::get(Context, {createString(Name), Domain});
201 MDNode *MDBuilder::createTBAAStructNode(ArrayRef<TBAAStructField> Fields) {
209 return MDNode::get(Context, Vals);
214 MDNode *MDBuilder::createTBAAStructTypeNode(
215 StringRef Name, ArrayRef<std::pair<MDNode *, uint64_t>> Fields) {
223 return MDNode::get(Context, Ops);
228 MDNode *MDBuilder::createTBAAScalarTypeNode(StringRef Name, MDNode *Parent,
228 MDNode *MDBuilder::createTBAAScalarTypeNode(StringRef Name, MDNode *Parent,
231 return MDNode::get(Context,
237 MDNode *MDBuilder::createTBAAStructTagNode(MDNode *BaseType, MDNode *AccessType,
237 MDNode *MDBuilder::createTBAAStructTagNode(MDNode *BaseType, MDNode *AccessType,
237 MDNode *MDBuilder::createTBAAStructTagNode(MDNode *BaseType, MDNode *AccessType,
242 return MDNode::get(Context, {BaseType, AccessType, createConstant(Off),
245 return MDNode::get(Context, {BaseType, AccessType, createConstant(Off)});
248 MDNode *MDBuilder::createTBAATypeNode(MDNode *Parent, uint64_t Size,
248 MDNode *MDBuilder::createTBAATypeNode(MDNode *Parent, uint64_t Size,
261 return MDNode::get(Context, Ops);
264 MDNode *MDBuilder::createTBAAAccessTag(MDNode *BaseType, MDNode *AccessType,
264 MDNode *MDBuilder::createTBAAAccessTag(MDNode *BaseType, MDNode *AccessType,
264 MDNode *MDBuilder::createTBAAAccessTag(MDNode *BaseType, MDNode *AccessType,
272 return MDNode::get(Context, {BaseType, AccessType, OffsetNode, SizeNode,
275 return MDNode::get(Context, {BaseType, AccessType, OffsetNode, SizeNode});
278 MDNode *MDBuilder::createMutableTBAAAccessTag(MDNode *Tag) {
278 MDNode *MDBuilder::createMutableTBAAAccessTag(MDNode *Tag) {
279 MDNode *BaseType = cast<MDNode>(Tag->getOperand(0));
279 MDNode *BaseType = cast<MDNode>(Tag->getOperand(0));
280 MDNode *AccessType = cast<MDNode>(Tag->getOperand(1));
280 MDNode *AccessType = cast<MDNode>(Tag->getOperand(1));
284 bool NewFormat = isa<MDNode>(AccessType->getOperand(0));
305 MDNode *MDBuilder::createIrrLoopHeaderWeight(uint64_t Weight) {
310 return MDNode::get(Context, Vals);
313 MDNode *MDBuilder::createMisExpect(uint64_t Index, uint64_t LikleyWeight,
322 return MDNode::get(Context, Vals);
lib/IR/Metadata.cpp 87 return MDNode::get(Context, None);
90 auto *N = dyn_cast<MDNode>(MD);
90 auto *N = dyn_cast<MDNode>(MD);
96 return MDNode::get(Context, None);
304 auto *OwnerMD = dyn_cast<MDNode>(Owner.get<Metadata *>());
304 auto *OwnerMD = dyn_cast<MDNode>(Owner.get<Metadata *>());
314 if (auto *N = dyn_cast<MDNode>(&MD))
314 if (auto *N = dyn_cast<MDNode>(&MD))
320 if (auto *N = dyn_cast<MDNode>(&MD))
320 if (auto *N = dyn_cast<MDNode>(&MD))
326 if (auto *N = dyn_cast<MDNode>(&MD))
493 MDNode *N = static_cast<MDNode *>(Mem);
533 if (auto *N = dyn_cast_or_null<MDNode>(Op))
533 if (auto *N = dyn_cast_or_null<MDNode>(Op))
629 auto *N = dyn_cast_or_null<MDNode>(Op);
629 auto *N = dyn_cast_or_null<MDNode>(Op);
640 static bool hasSelfReference(MDNode *N) {
647 MDNode *MDNode::replaceWithPermanentImpl() {
665 MDNode *MDNode::replaceWithUniquedImpl() {
667 MDNode *UniquedNode = uniquify();
680 MDNode *MDNode::replaceWithDistinctImpl() {
723 auto *Uniqued = uniquify();
781 MDNode *MDNode::uniquify() {
830 void MDNode::deleteTemporary(MDNode *N) {
881 static MDNode *getOrSelfReference(LLVMContext &Context,
884 if (MDNode *N = dyn_cast_or_null<MDNode>(Ops[0]))
884 if (MDNode *N = dyn_cast_or_null<MDNode>(Ops[0]))
888 return MDNode::get(Context, Ops);
892 return MDNode::get(Context, Ops);
895 MDNode *MDNode::concatenate(MDNode *A, MDNode *B) {
895 MDNode *MDNode::concatenate(MDNode *A, MDNode *B) {
895 MDNode *MDNode::concatenate(MDNode *A, MDNode *B) {
909 MDNode *MDNode::intersect(MDNode *A, MDNode *B) {
909 MDNode *MDNode::intersect(MDNode *A, MDNode *B) {
909 MDNode *MDNode::intersect(MDNode *A, MDNode *B) {
922 MDNode *MDNode::getMostGenericAliasScope(MDNode *A, MDNode *B) {
922 MDNode *MDNode::getMostGenericAliasScope(MDNode *A, MDNode *B) {
922 MDNode *MDNode::getMostGenericAliasScope(MDNode *A, MDNode *B) {
929 MDNode *MDNode::getMostGenericFPMath(MDNode *A, MDNode *B) {
929 MDNode *MDNode::getMostGenericFPMath(MDNode *A, MDNode *B) {
929 MDNode *MDNode::getMostGenericFPMath(MDNode *A, MDNode *B) {
977 MDNode *MDNode::getMostGenericRange(MDNode *A, MDNode *B) {
977 MDNode *MDNode::getMostGenericRange(MDNode *A, MDNode *B) {
977 MDNode *MDNode::getMostGenericRange(MDNode *A, MDNode *B) {
1046 return MDNode::get(A->getContext(), MDs);
1049 MDNode *MDNode::getMostGenericAlignmentOrDereferenceable(MDNode *A, MDNode *B) {
1049 MDNode *MDNode::getMostGenericAlignmentOrDereferenceable(MDNode *A, MDNode *B) {
1049 MDNode *MDNode::getMostGenericAlignmentOrDereferenceable(MDNode *A, MDNode *B) {
1080 MDNode *NamedMDNode::getOperand(unsigned i) const {
1083 return cast_or_null<MDNode>(N);
1086 void NamedMDNode::addOperand(MDNode *M) { getNMDOps(Operands).emplace_back(M); }
1088 void NamedMDNode::setOperand(unsigned I, MDNode *New) {
1102 void MDAttachmentMap::set(unsigned ID, MDNode &MD) {
1133 MDNode *MDAttachmentMap::lookup(unsigned ID) const {
1141 SmallVectorImpl<std::pair<unsigned, MDNode *>> &Result) const {
1149 void MDGlobalAttachmentMap::insert(unsigned ID, MDNode &MD) {
1153 MDNode *MDGlobalAttachmentMap::lookup(unsigned ID) const {
1161 SmallVectorImpl<MDNode *> &Result) const {
1176 SmallVectorImpl<std::pair<unsigned, MDNode *>> &Result) const {
1185 void Instruction::setMetadata(StringRef Kind, MDNode *Node) {
1191 MDNode *Instruction::getMetadataImpl(StringRef Kind) const {
1222 void Instruction::setMetadata(unsigned KindID, MDNode *Node) {
1267 MDNode *Instruction::getMetadataImpl(unsigned KindID) const {
1281 SmallVectorImpl<std::pair<unsigned, MDNode *>> &Result) const {
1301 SmallVectorImpl<std::pair<unsigned, MDNode *>> &Result) const {
1317 auto *ProfileData = getMetadata(LLVMContext::MD_prof);
1345 auto *ProfileData = getMetadata(LLVMContext::MD_prof);
1379 SmallVectorImpl<MDNode *> &MDs) const {
1385 SmallVectorImpl<MDNode *> &MDs) const {
1390 void GlobalObject::addMetadata(unsigned KindID, MDNode &MD) {
1397 void GlobalObject::addMetadata(StringRef Kind, MDNode &MD) {
1414 SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs) const {
1430 void GlobalObject::setMetadata(unsigned KindID, MDNode *N) {
1436 void GlobalObject::setMetadata(StringRef Kind, MDNode *N) {
1440 MDNode *GlobalObject::getMetadata(unsigned KindID) const {
1446 MDNode *GlobalObject::getMetadata(StringRef Kind) const {
1451 SmallVector<std::pair<unsigned, MDNode *>, 8> MDs;
1462 *MDNode::get(getContext(), {NewOffsetMD, TypeId}));
1468 auto *Attachment = MD.second;
1502 *MDNode::get(getContext(),
1508 if (MDNode *MD = getMetadata(LLVMContext::MD_vcall_visibility)) {
1541 SmallVector<MDNode *, 1> MDs;
1543 for (MDNode *MD : MDs)
lib/IR/Module.cpp 294 for (const MDNode *Flag : ModFlags->operands()) {
343 getOrInsertModuleFlagsMetadata()->addOperand(MDNode::get(Context, Ops));
354 void Module::addModuleFlag(MDNode *Node) {
lib/IR/TypeFinder.cpp 49 SmallVector<std::pair<unsigned, MDNode *>, 4> MDForInst;
122 if (const auto *N = dyn_cast<MDNode>(M->getMetadata()))
122 if (const auto *N = dyn_cast<MDNode>(M->getMetadata()))
150 void TypeFinder::incorporateMDNode(const MDNode *V) {
159 if (auto *N = dyn_cast<MDNode>(Op)) {
159 if (auto *N = dyn_cast<MDNode>(Op)) {
lib/IR/Value.cpp 633 if (MDNode *MD = LI->getMetadata(LLVMContext::MD_dereferenceable)) {
638 if (MDNode *MD =
646 if (MDNode *MD = IP->getMetadata(LLVMContext::MD_dereferenceable)) {
651 if (MDNode *MD =
727 if (MDNode *MD = LI->getMetadata(LLVMContext::MD_align)) {
lib/IR/Verifier.cpp 406 void visitMDNode(const MDNode &MD);
413 void visitModuleFlag(const MDNode *Op,
414 DenseMap<const MDString *, const MDNode *> &SeenIDs,
415 SmallVectorImpl<const MDNode *> &Requirements);
419 void visitRangeMetadata(Instruction &I, MDNode *Range, Type *Ty);
420 void visitDereferenceableMetadata(Instruction &I, MDNode *MD);
421 void visitProfMetadata(Instruction &I, MDNode *MD);
431 void visitTemplateParams(const MDNode &N, const Metadata &RawParams);
507 void verifyFunctionMetadata(ArrayRef<std::pair<unsigned, MDNode *>> MDs);
688 SmallVector<MDNode *, 1> MDs;
690 for (auto *MD : MDs) {
777 for (const MDNode *MD : NMD.operands()) {
788 void Verifier::visitMDNode(const MDNode &MD) {
811 if (auto *N = dyn_cast<MDNode>(Op)) {
854 if (auto *N = dyn_cast<MDNode>(MD)) {
854 if (auto *N = dyn_cast<MDNode>(MD)) {
955 void Verifier::visitTemplateParams(const MDNode &N, const Metadata &RawParams) {
1331 for (const MDNode *N : Idents->operands()) {
1349 for (const MDNode *N : CommandLines->operands()) {
1364 DenseMap<const MDString*, const MDNode*> SeenIDs;
1365 SmallVector<const MDNode*, 16> Requirements;
1366 for (const MDNode *MDN : Flags->operands())
1370 for (const MDNode *Requirement : Requirements) {
1374 const MDNode *Op = SeenIDs.lookup(Flag);
1391 Verifier::visitModuleFlag(const MDNode *Op,
1392 DenseMap<const MDString *, const MDNode *> &SeenIDs,
1393 SmallVectorImpl<const MDNode *> &Requirements) {
1430 MDNode *Value = dyn_cast<MDNode>(Op->getOperand(2));
1430 MDNode *Value = dyn_cast<MDNode>(Op->getOperand(2));
1478 for (const MDOperand &MDO : cast<MDNode>(Op->getOperand(2))->operands())
1491 auto Node = dyn_cast_or_null<MDNode>(MDO);
1848 ArrayRef<std::pair<unsigned, MDNode *>> MDs) {
1851 MDNode *MD = Pair.second;
2230 SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
2331 SmallPtrSet<const MDNode *, 32> Seen;
2367 VisitDebugLoc(I, dyn_cast_or_null<MDNode>(MD->getOperand(i)));
3321 void Verifier::visitRangeMetadata(Instruction &I, MDNode *Range, Type *Ty) {
4006 void Verifier::visitDereferenceableMetadata(Instruction& I, MDNode* MD) {
4019 void Verifier::visitProfMetadata(Instruction &I, MDNode *MD) {
4159 if (MDNode *MD = I.getMetadata(LLVMContext::MD_fpmath)) {
4175 if (MDNode *Range = I.getMetadata(LLVMContext::MD_range)) {
4190 if (MDNode *MD = I.getMetadata(LLVMContext::MD_dereferenceable))
4193 if (MDNode *MD = I.getMetadata(LLVMContext::MD_dereferenceable_or_null))
4196 if (MDNode *TBAA = I.getMetadata(LLVMContext::MD_tbaa))
4199 if (MDNode *AlignMD = I.getMetadata(LLVMContext::MD_align)) {
4215 if (MDNode *MD = I.getMetadata(LLVMContext::MD_prof))
4218 if (MDNode *N = I.getDebugLoc().getAsMDNode()) {
4929 if (MDNode *N = DII.getDebugLoc().getAsMDNode())
4964 if (MDNode *N = DLI.getDebugLoc().getAsMDNode())
5205 TBAAVerifier::verifyTBAABaseNode(Instruction &I, const MDNode *BaseNode,
5224 TBAAVerifier::verifyTBAABaseNodeImpl(Instruction &I, const MDNode *BaseNode,
5279 if (!isa<MDNode>(FieldTy)) {
5334 static bool IsRootTBAANode(const MDNode *MD) {
5338 static bool IsScalarTBAANodeImpl(const MDNode *MD,
5339 SmallPtrSetImpl<const MDNode *> &Visited) {
5352 auto *Parent = dyn_cast_or_null<MDNode>(MD->getOperand(1));
5352 auto *Parent = dyn_cast_or_null<MDNode>(MD->getOperand(1));
5357 bool TBAAVerifier::isValidScalarTBAANode(const MDNode *MD) {
5362 SmallPtrSet<const MDNode *, 4> Visited;
5375 MDNode *TBAAVerifier::getFieldNodeFromTBAABaseNode(Instruction &I,
5376 const MDNode *BaseNode,
5385 return cast<MDNode>(BaseNode->getOperand(1));
5404 return cast<MDNode>(BaseNode->getOperand(PrevIdx));
5412 return cast<MDNode>(BaseNode->getOperand(LastIdx));
5415 static bool isNewFormatTBAATypeNode(llvm::MDNode *Type) {
5421 MDNode *Parent = dyn_cast_or_null<MDNode>(Type->getOperand(0));
5421 MDNode *Parent = dyn_cast_or_null<MDNode>(Type->getOperand(0));
5428 bool TBAAVerifier::visitTBAAMetadata(Instruction &I, const MDNode *MD) {
5435 isa<MDNode>(MD->getOperand(0)) && MD->getNumOperands() >= 3;
5441 MDNode *BaseNode = dyn_cast_or_null<MDNode>(MD->getOperand(0));
5441 MDNode *BaseNode = dyn_cast_or_null<MDNode>(MD->getOperand(0));
5442 MDNode *AccessType = dyn_cast_or_null<MDNode>(MD->getOperand(1));
5442 MDNode *AccessType = dyn_cast_or_null<MDNode>(MD->getOperand(1));
5492 SmallPtrSet<MDNode *, 4> StructPath;
lib/LTO/LTOModule.cpp 632 MDNode *MDOptions = LinkerOptions->getOperand(i);
lib/Linker/IRMover.cpp 1186 for (const MDNode *Op : NMD.operands())
1209 DenseMap<MDString *, std::pair<MDNode *, unsigned>> Flags;
1210 SmallSetVector<MDNode *, 16> Requirements;
1212 MDNode *Op = DstModFlags->getOperand(I);
1217 Requirements.insert(cast<MDNode>(Op->getOperand(2)));
1226 MDNode *SrcOp = SrcModFlags->getOperand(I);
1230 MDNode *DstOp;
1239 if (Requirements.insert(cast<MDNode>(SrcOp->getOperand(2)))) {
1287 MDNode *Flag = MDNode::get(DstM.getContext(), FlagOps);
1287 MDNode *Flag = MDNode::get(DstM.getContext(), FlagOps);
1330 MDNode *DstValue = cast<MDNode>(DstOp->getOperand(2));
1330 MDNode *DstValue = cast<MDNode>(DstOp->getOperand(2));
1331 MDNode *SrcValue = cast<MDNode>(SrcOp->getOperand(2));
1331 MDNode *SrcValue = cast<MDNode>(SrcOp->getOperand(2));
1337 replaceDstValue(MDNode::get(DstM.getContext(), MDs));
1342 MDNode *DstValue = cast<MDNode>(DstOp->getOperand(2));
1342 MDNode *DstValue = cast<MDNode>(DstOp->getOperand(2));
1343 MDNode *SrcValue = cast<MDNode>(SrcOp->getOperand(2));
1343 MDNode *SrcValue = cast<MDNode>(SrcOp->getOperand(2));
1347 replaceDstValue(MDNode::get(DstM.getContext(),
1356 MDNode *Requirement = Requirements[I];
1360 MDNode *Op = Flags[Flag].first;
lib/Object/IRSymtab.cpp 139 for (MDNode *MDOptions : LinkerOptions->operands())
140 for (const MDOperand &MDOption : cast<MDNode>(MDOptions)->operands())
149 for (MDNode *MDOptions : N->operands()) {
151 cast<MDString>(cast<MDNode>(MDOptions)->getOperand(0))->getString();
lib/ProfileData/InstrProf.cpp 265 if (MDNode *MD = getPGOFuncNameMetadata(F)) {
973 Inst.setMetadata(LLVMContext::MD_prof, MDNode::get(Ctx, Vals));
981 MDNode *MD = Inst.getMetadata(LLVMContext::MD_prof);
1028 MDNode *getPGOFuncNameMetadata(const Function &F) {
1040 MDNode *N = MDNode::get(C, MDString::get(C, PGOFuncName));
1040 MDNode *N = MDNode::get(C, MDString::get(C, PGOFuncName));
lib/Target/AArch64/AArch64FalkorHWPFFix.cpp 169 MDNode::get(LoadI->getContext(), {}));
lib/Target/AMDGPU/AMDGPUAliasAnalysis.h 53 bool Aliases(const MDNode *A, const MDNode *B) const;
53 bool Aliases(const MDNode *A, const MDNode *B) const;
54 bool PathAliases(const MDNode *A, const MDNode *B) const;
54 bool PathAliases(const MDNode *A, const MDNode *B) const;
lib/Target/AMDGPU/AMDGPUAnnotateUniformValues.cpp 73 I->setMetadata("amdgpu.uniform", MDNode::get(I->getContext(), {}));
76 I->setMetadata("amdgpu.noclobber", MDNode::get(I->getContext(), {}));
lib/Target/AMDGPU/AMDGPUCodeGenPrepare.cpp 549 MDNode *FPMath = FDiv.getMetadata(LLVMContext::MD_fpmath);
948 if (auto *Range = WidenLoad->getMetadata(LLVMContext::MD_range)) {
962 MDNode::get(Mod->getContext(), LowAndHigh));
lib/Target/AMDGPU/AMDGPUHSAMetadataStreamer.cpp 200 MetadataStreamerV2::getWorkGroupDimensions(MDNode *Node) const {
311 const MDNode *Node;
641 MetadataStreamerV3::getWorkGroupDimensions(MDNode *Node) const {
728 const MDNode *Node;
lib/Target/AMDGPU/AMDGPUHSAMetadataStreamer.h 72 msgpack::ArrayDocNode getWorkGroupDimensions(MDNode *Node) const;
140 std::vector<uint32_t> getWorkGroupDimensions(MDNode *Node) const;
lib/Target/AMDGPU/AMDGPULowerKernelArguments.cpp 164 Load->setMetadata(LLVMContext::MD_invariant_load, MDNode::get(Ctx, {}));
170 Load->setMetadata(LLVMContext::MD_nonnull, MDNode::get(Ctx, {}));
176 MDNode::get(Ctx,
185 MDNode::get(Ctx,
194 MDNode::get(Ctx,
lib/Target/AMDGPU/AMDGPUPrintfRuntimeBinding.cpp 346 MDNode *myMD = MDNode::get(Ctx, fmtStrArray);
346 MDNode *myMD = MDNode::get(Ctx, fmtStrArray);
lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp 257 MDNode *MD = MDNode::get(Mod->getContext(), None);
257 MDNode *MD = MDNode::get(Mod->getContext(), None);
lib/Target/AMDGPU/AMDGPUSubtarget.cpp 488 MDNode *MaxWorkGroupSizeRange = MDB.createRange(APInt(32, MinSize),
lib/Target/AMDGPU/AMDGPUUnifyMetadata.cpp 62 MDNode *MaxMD = nullptr;
105 NamedMD->addOperand(MDNode::get(M.getContext(), MD));
lib/Target/AMDGPU/R600OpenCLImageTypeLoweringPass.cpp 92 GetFunctionFromMDNode(MDNode *Node) {
107 MDNode *ArgNode = dyn_cast_or_null<MDNode>(Node->getOperand(i + 1));
107 MDNode *ArgNode = dyn_cast_or_null<MDNode>(Node->getOperand(i + 1));
124 AccessQualFromMD(MDNode *KernelMDNode, unsigned ArgIdx) {
125 MDNode *ArgAQNode = cast<MDNode>(KernelMDNode->getOperand(2));
125 MDNode *ArgAQNode = cast<MDNode>(KernelMDNode->getOperand(2));
130 ArgTypeFromMD(MDNode *KernelMDNode, unsigned ArgIdx) {
131 MDNode *ArgTypeNode = cast<MDNode>(KernelMDNode->getOperand(3));
131 MDNode *ArgTypeNode = cast<MDNode>(KernelMDNode->getOperand(3));
139 MDNode *Node = cast<MDNode>(KernelMDNode->getOperand(i + 1));
139 MDNode *Node = cast<MDNode>(KernelMDNode->getOperand(i + 1));
228 bool replaceImageAndSamplerUses(Function *F, MDNode *KernelMDNode) {
268 std::tuple<Function *, MDNode *>
269 addImplicitArgs(Function *F, MDNode *KernelMDNode) {
325 KernelMDArgs.push_back(MDNode::get(*Context, NewArgMDs.ArgVector[i]));
326 MDNode *NewMDNode = MDNode::get(*Context, KernelMDArgs);
326 MDNode *NewMDNode = MDNode::get(*Context, KernelMDArgs);
338 MDNode *KernelMDNode = KernelsMDNode->getOperand(i);
344 MDNode *NewMDNode;
lib/Target/BPF/BPFAbstractMemberAccess.cpp 120 MDNode *Metadata;
151 bool IsValidAIChain(const MDNode *ParentMeta, uint32_t ParentAI,
152 const MDNode *ChildMeta);
164 std::string &AccessKey, MDNode *&BaseMeta);
348 bool BPFAbstractMemberAccess::IsValidAIChain(const MDNode *ParentType,
350 const MDNode *ChildType) {
697 MDNode *&TypeMeta) {
824 MDNode *MDN = CInfo.Metadata;
843 MDNode *TypeMeta;
lib/Target/BPF/BTFDebug.cpp 996 MDNode *MDN = GVar->getMetadata(LLVMContext::MD_preserve_access_index);
lib/Target/NVPTX/NVPTXAsmPrinter.cpp 427 if (MDNode *LoopID =
lib/Target/NVPTX/NVPTXUtilities.cpp 46 static void cacheAnnotationFromMD(const MDNode *md, key_val_pair_t &retval) {
79 const MDNode *elem = NMD->getOperand(i);
300 if (MDNode *alignNode = I.getMetadata("callalign")) {
lib/Target/NVPTX/NVVMIntrRange.cpp 76 C->setMetadata(LLVMContext::MD_range, MDNode::get(Context, LowAndHigh));
lib/Target/PowerPC/PPCISelLowering.h 969 const MDNode *Ranges = nullptr;
lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp 294 if (MDNode *Idx = F.getMetadata("wasm.index")) {
lib/Target/X86/X86FrameLowering.cpp 2539 MDNode *Node = HiPELiteralsMD->getOperand(i);
lib/Target/X86/X86ISelLowering.cpp 4111 if (MDNode *HeapAlloc = CLI.CS->getMetadata("heapallocsite"))
lib/Target/X86/X86OptimizeLEAs.cpp 580 const MDNode *Var = MI.getDebugVariable();
lib/Transforms/IPO/CalledValuePropagation.cpp 395 MDNode *Callees = MDB.createCallees(LV.getFunctions());
lib/Transforms/IPO/ConstantMerge.cpp 70 SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
lib/Transforms/IPO/CrossDSOCFI.cpp 48 MDNode *VeryLikelyWeights;
50 ConstantInt *extractNumericTypeId(MDNode *MD);
65 ConstantInt *CrossDSOCFI::extractNumericTypeId(MDNode *MD) {
83 SmallVector<MDNode *, 2> Types;
87 for (MDNode *Type : Types)
98 extractNumericTypeId(cast<MDNode>(Func->getOperand(I).get())))
lib/Transforms/IPO/DeadArgumentElimination.cpp 242 SmallVector<std::pair<unsigned, MDNode *>, 1> MDs;
1073 SmallVector<std::pair<unsigned, MDNode *>, 1> MDs;
lib/Transforms/IPO/FunctionImport.cpp 1122 MDNode::get(DestModule.getContext(),
1166 MDNode::get(DestModule.getContext(),
lib/Transforms/IPO/GlobalDCE.cpp 159 SmallVector<MDNode *, 2> Types;
177 for (MDNode *Type : Types) {
lib/Transforms/IPO/GlobalSplit.cpp 67 SmallVector<MDNode *, 2> Types;
91 for (MDNode *Type : Types) {
108 *MDNode::get(GV.getContext(),
lib/Transforms/IPO/LowerTypeTests.cpp 258 class GlobalTypeMember final : TrailingObjects<GlobalTypeMember, MDNode *> {
275 size_t numTrailingObjects(OverloadToken<MDNode *>) const { return NTypes; }
280 ArrayRef<MDNode *> Types) {
282 totalSizeToAlloc<MDNode *>(Types.size()), alignof(GlobalTypeMember)));
288 GTM->getTrailingObjects<MDNode *>());
304 ArrayRef<MDNode *> types() const {
305 return makeArrayRef(getTrailingObjects<MDNode *>(), NTypes);
469 void verifyTypeMDNode(GlobalObject *GO, MDNode *Type);
560 for (MDNode *Type : GlobalAndOffset.first->types()) {
690 SmallVector<MDNode *, 2> Types;
692 for (MDNode *Type : Types) {
993 MDNode::get(M.getContext(), {MinC, MaxC}));
1168 void LowerTypeTestsModule::verifyTypeMDNode(GlobalObject *GO, MDNode *Type) {
1574 MDNode *MD = MDNode::get(F->getContext(),
1574 MDNode *MD = MDNode::get(F->getContext(),
1602 for (MDNode *Type : GTM->types()) {
1830 SmallVector<MDNode *, 2> Types;
1838 MDNode *FuncMD; // {name, linkage, type[, type...]}
1888 MDNode *FuncMD = P.second.FuncMD;
1935 *cast<MDNode>(FuncMD->getOperand(I).get()));
1970 for (MDNode *Type : Types) {
lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp 92 if (isa<MDNode>(MD) && cast<MDNode>(MD)->isDistinct()) {
92 if (isa<MDNode>(MD) && cast<MDNode>(MD)->isDistinct()) {
121 SmallVector<MDNode *, 1> MDs;
133 *MDNode::get(M.getContext(), {MD->getOperand(0), I->second}));
229 if (MDNode *MD = GO->getMetadata(LLVMContext::MD_associated))
318 SmallVector<MDNode *, 8> CfiFunctionMDs;
321 SmallVector<MDNode *, 2> Types;
346 SmallVector<MDNode *, 8> FunctionAliases;
371 SmallVector<MDNode *, 8> Symvers;
lib/Transforms/IPO/WholeProgramDevirt.cpp 783 SmallVector<MDNode *, 2> Types;
799 for (MDNode *Type : Types) {
1288 MDNode::get(M.getContext(), {MinC, MaxC}));
lib/Transforms/InstCombine/InstCombineCalls.cpp 169 MDNode *CopyMD = nullptr;
170 if (MDNode *M = MI->getMetadata(LLVMContext::MD_tbaa)) {
172 } else if (MDNode *M = MI->getMetadata(LLVMContext::MD_tbaa_struct)) {
180 M->getOperand(2) && isa<MDNode>(M->getOperand(2)))
181 CopyMD = cast<MDNode>(M->getOperand(2));
192 MDNode *LoopMemParallelMD =
196 MDNode *AccessGroupMD = MI->getMetadata(LLVMContext::MD_access_group);
1251 MDNode::get(II.getContext(), LowAndHigh));
1288 MDNode::get(II.getContext(), LowAndHigh));
3692 MDNode *MD = MDNode::get(II->getContext(), MDArgs);
3692 MDNode *MD = MDNode::get(II->getContext(), MDArgs);
3958 MDNode *MD = MDNode::get(II->getContext(), None);
3958 MDNode *MD = MDNode::get(II->getContext(), None);
lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp 481 SmallVector<std::pair<unsigned, MDNode *>, 8> MD;
490 MDNode *N = MDPair.second;
lib/Transforms/InstCombine/InstCombineSelect.cpp 2482 if (MDNode *MD = SI.getMetadata(LLVMContext::MD_prof)) {
lib/Transforms/Instrumentation/AddressSanitizer.cpp 1113 void LocationMetadata::parse(MDNode *MDN) {
1143 if (auto *Loc = cast_or_null<MDNode>(MDN->getOperand(1)))
1143 if (auto *Loc = cast_or_null<MDNode>(MDN->getOperand(1)))
2074 MDNode *MD = MDNode::get(M.getContext(), ValueAsMetadata::get(G));
2074 MDNode *MD = MDNode::get(M.getContext(), ValueAsMetadata::get(G));
lib/Transforms/Instrumentation/CGProfile.cpp 94 Nodes.push_back(MDNode::get(Context, Vals));
97 M.addModuleFlag(Module::Append, "CG Profile", MDNode::get(Context, Nodes));
lib/Transforms/Instrumentation/ControlHeightReduction.cpp 608 static bool checkMDProf(MDNode *MD, BranchProbability &TrueProb,
lib/Transforms/Instrumentation/DataFlowSanitizer.cpp 353 MDNode *ColdCallWeights;
lib/Transforms/Instrumentation/GCOVProfiling.cpp 116 insertCounterWriteout(ArrayRef<std::pair<GlobalVariable *, MDNode *>>);
117 Function *insertFlush(ArrayRef<std::pair<GlobalVariable *, MDNode *>>);
525 MDNode *N = GCov->getOperand(i);
529 if (dyn_cast<MDNode>(N->getOperand(ThreeElement ? 2 : 1)) != CU)
776 SmallVector<std::pair<GlobalVariable *, MDNode *>, 8> CountersBySP;
941 ArrayRef<std::pair<GlobalVariable *, MDNode *> > CountersBySP) {
1190 insertFlush(ArrayRef<std::pair<GlobalVariable*, MDNode*> > CountersBySP) {
lib/Transforms/Instrumentation/HWAddressSanitizer.cpp 1024 MDNode *MD = MDNode::get(*C, {MDString::get(*C, Name)});
1024 MDNode *MD = MDNode::get(*C, {MDString::get(*C, Name)});
1306 MDNode::get(*C, ValueAsMetadata::get(NewGV)));
1399 MDNode::get(*C, ValueAsMetadata::get(Note)));
lib/Transforms/Instrumentation/IndirectCallPromotion.cpp 306 MDNode *BranchWeights = MDB.createBranchWeights(
lib/Transforms/Instrumentation/MemorySanitizer.cpp 583 MDNode *ColdCallWeights;
586 MDNode *OriginStoreWeights;
lib/Transforms/Instrumentation/SanitizerCoverage.cpp 221 MDNode::get(*C, None));
660 MDNode *MD = MDNode::get(F.getContext(), ValueAsMetadata::get(&F));
660 MDNode *MD = MDNode::get(F.getContext(), ValueAsMetadata::get(&F));
lib/Transforms/Instrumentation/ThreadSanitizer.cpp 300 if (MDNode *Tag = I->getMetadata(LLVMContext::MD_tbaa))
lib/Transforms/ObjCARC/ObjCARCOpts.cpp 866 MDNode::get(C, None));
1596 if (MDNode *M = ReleasesToMove.ReleaseMetadata)
lib/Transforms/ObjCARC/PtrState.cpp 192 MDNode *ReleaseMetadata =
357 MDNode *ReleaseMetadata =
lib/Transforms/ObjCARC/PtrState.h 76 MDNode *ReleaseMetadata = nullptr;
133 const MDNode *GetReleaseMetadata() const { return RRI.ReleaseMetadata; }
135 void SetReleaseMetadata(MDNode *NewValue) { RRI.ReleaseMetadata = NewValue; }
lib/Transforms/Scalar/GVN.cpp 1256 if (auto *MD = LI->getMetadata(LLVMContext::MD_invariant_load))
1258 if (auto *InvGroupMD = LI->getMetadata(LLVMContext::MD_invariant_group))
1260 if (auto *RangeMD = LI->getMetadata(LLVMContext::MD_range))
lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp 415 MDNode *Dummy = MDNode::get(Context, {});
415 MDNode *Dummy = MDNode::get(Context, {});
416 MDNode *DisableUnroll = MDNode::get(
416 MDNode *DisableUnroll = MDNode::get(
420 MDNode *DisableVectorize = MDNode::get(
420 MDNode *DisableVectorize = MDNode::get(
423 MDNode *DisableLICMVersioning = MDNode::get(
423 MDNode *DisableLICMVersioning = MDNode::get(
425 MDNode *DisableDistribution= MDNode::get(
425 MDNode *DisableDistribution= MDNode::get(
428 MDNode *NewLoopID =
429 MDNode::get(Context, {Dummy, DisableUnroll, DisableVectorize,
1147 MDNode::get(Ctx, {}));
lib/Transforms/Scalar/InferAddressSpaces.cpp 789 MDNode *TBAA = MI->getMetadata(LLVMContext::MD_tbaa);
790 MDNode *ScopeMD = MI->getMetadata(LLVMContext::MD_alias_scope);
791 MDNode *NoAliasMD = MI->getMetadata(LLVMContext::MD_noalias);
810 MDNode *TBAAStruct = MTI->getMetadata(LLVMContext::MD_tbaa_struct);
lib/Transforms/Scalar/JumpThreading.cpp 2148 MDNode *WeightsNode = TI->getMetadata(LLVMContext::MD_prof);
lib/Transforms/Scalar/LoopDistribute.cpp 458 MDNode *OrigLoopID = L->getLoopID();
598 void setNewLoopID(MDNode *OrigLoopID, InstPartition *Part) {
599 Optional<MDNode *> PartitionID = makeFollowupLoopID(
812 MDNode *OrigLoopID = L->getLoopID();
825 MDNode *UnversionedLoopID =
lib/Transforms/Scalar/LoopUnrollAndJamPass.cpp 93 static MDNode *GetUnrollMetadataForLoop(const Loop *L, StringRef Name) {
94 if (MDNode *LoopID = L->getLoopID())
102 if (MDNode *LoopID = L->getLoopID()) {
108 MDNode *MD = dyn_cast<MDNode>(LoopID->getOperand(i));
108 MDNode *MD = dyn_cast<MDNode>(LoopID->getOperand(i));
131 MDNode *MD = GetUnrollMetadataForLoop(L, "llvm.loop.unroll_and_jam.count");
360 MDNode *OrigOuterLoopID = L->getLoopID();
361 MDNode *OrigSubLoopID = SubLoop->getLoopID();
366 Optional<MDNode *> NewInnerEpilogueLoopID = makeFollowupLoopID(
394 Optional<MDNode *> NewOuterEpilogueLoopID = makeFollowupLoopID(
401 Optional<MDNode *> NewInnerLoopID =
410 Optional<MDNode *> NewOuterLoopID = makeFollowupLoopID(
lib/Transforms/Scalar/LoopUnrollPass.cpp 666 static MDNode *GetUnrollMetadataForLoop(const Loop *L, StringRef Name) {
667 if (MDNode *LoopID = L->getLoopID())
691 MDNode *MD = GetUnrollMetadataForLoop(L, "llvm.loop.unroll.count");
1129 MDNode *OrigLoopID = L->getLoopID();
1143 Optional<MDNode *> RemainderLoopID =
1151 Optional<MDNode *> NewLoopID =
lib/Transforms/Scalar/LoopVersioningLICM.cpp 540 MDNode *NewDomain = MDB.createAnonymousAliasScopeDomain("LVDomain");
543 MDNode *NewScope = MDB.createAnonymousAliasScope(NewDomain, Name);
556 MDNode::concatenate(Inst.getMetadata(LLVMContext::MD_noalias),
557 MDNode::get(Inst.getContext(), NoAliases)));
561 MDNode::concatenate(Inst.getMetadata(LLVMContext::MD_alias_scope),
562 MDNode::get(Inst.getContext(), Scopes)));
lib/Transforms/Scalar/LowerExpectIntrinsic.cpp 288 MDNode *Node;
289 MDNode *ExpNode;
lib/Transforms/Scalar/RewriteStatepointsForGC.cpp 948 BaseInst->setMetadata("is_base_value", MDNode::get(I->getContext(), {}));
995 BaseInst->setMetadata("is_base_value", MDNode::get(I->getContext(), {}));
2466 if (MDNode *Tag = I.getMetadata(LLVMContext::MD_tbaa)) {
2467 MDNode *MutableTBAA = Builder.createMutableTBAAAccessTag(Tag);
lib/Transforms/Scalar/SROA.cpp 2535 if (MDNode *N = LI.getMetadata(LLVMContext::MD_nonnull))
lib/Transforms/Scalar/Scalarizer.cpp 402 SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
lib/Transforms/Scalar/StructurizeCFG.cpp 1020 MDNode *MD = MDNode::get(R->getEntry()->getParent()->getContext(), {});
1020 MDNode *MD = MDNode::get(R->getEntry()->getParent()->getContext(), {});
lib/Transforms/Utils/BasicBlockUtils.cpp 813 MDNode *BranchWeights,
865 MDNode *BranchWeights) {
lib/Transforms/Utils/CallPromotionUtils.cpp 257 MDNode *BranchWeights) {
450 MDNode *BranchWeights) {
lib/Transforms/Utils/CloneFunction.cpp 44 DenseMap<const MDNode *, MDNode *> Cache;
44 DenseMap<const MDNode *, MDNode *> Cache;
143 SmallVector<std::pair<unsigned, MDNode *>, 1> MDs;
221 for (auto* Operand : NMD->operands())
lib/Transforms/Utils/CloneModule.cpp 132 SmallVector<std::pair<unsigned, MDNode *>, 1> MDs;
193 for (const auto* Operand : NewNMD->operands())
195 for (const auto* Operand : NMD.operands()) {
196 auto* MappedOperand = MapMetadata(Operand, VMap);
lib/Transforms/Utils/FunctionComparator.cpp 142 int FunctionComparator::cmpRangeMetadata(const MDNode *L,
143 const MDNode *R) const {
lib/Transforms/Utils/GuardUtils.cpp 44 if (auto *MD = Guard->getMetadata(LLVMContext::MD_make_implicit))
lib/Transforms/Utils/InlineFunction.cpp 772 MDNode *M =
774 MDNode *CallAccessGroup =
789 if (MDNode *PM =
791 M = MDNode::concatenate(PM, M);
799 MDNode *UnitedAccGroups = uniteAccessGroups(
815 SetVector<const MDNode *> MD;
824 if (const MDNode *M = J.getMetadata(LLVMContext::MD_alias_scope))
826 if (const MDNode *M = J.getMetadata(LLVMContext::MD_noalias))
837 const MDNode *M = cast<MDNode>(Queue.pop_back_val());
837 const MDNode *M = cast<MDNode>(Queue.pop_back_val());
839 if (const MDNode *M1 = dyn_cast<MDNode>(M->getOperand(i)))
839 if (const MDNode *M1 = dyn_cast<MDNode>(M->getOperand(i)))
847 DenseMap<const MDNode *, TrackingMDNodeRef> MDMap;
848 for (const MDNode *I : MD) {
856 for (const MDNode *I : MD) {
860 if (const MDNode *M = dyn_cast<MDNode>(V))
860 if (const MDNode *M = dyn_cast<MDNode>(V))
866 MDNode *NewM = MDNode::get(CalledFunc->getContext(), NewOps);
866 MDNode *NewM = MDNode::get(CalledFunc->getContext(), NewOps);
884 if (MDNode *M = NI->getMetadata(LLVMContext::MD_alias_scope)) {
885 MDNode *NewMD = MDMap[M];
889 if (MDNode *CSM =
891 NewMD = MDNode::concatenate(NewMD, CSM);
894 if (MDNode *M =
899 if (MDNode *M = NI->getMetadata(LLVMContext::MD_noalias)) {
900 MDNode *NewMD = MDMap[M];
904 if (MDNode *CSM =
906 NewMD = MDNode::concatenate(NewMD, CSM);
909 if (MDNode *M = CS.getInstruction()->getMetadata(LLVMContext::MD_noalias))
945 DenseMap<const Argument *, MDNode *> NewScopes;
949 MDNode *NewDomain =
966 MDNode *NewScope = MDB.createAnonymousAliasScope(NewDomain, Name);
1106 MDNode::concatenate(
1108 MDNode::get(CalledFunc->getContext(), NoAliases)));
1133 MDNode::concatenate(NI->getMetadata(LLVMContext::MD_alias_scope),
1134 MDNode::get(CalledFunc->getContext(), Scopes)));
1352 DenseMap<const MDNode *, MDNode *> &IANodes) {
1352 DenseMap<const MDNode *, MDNode *> &IANodes) {
1360 static MDNode *inlineLoopID(const MDNode *OrigLoopId, DILocation *InlinedAt,
1360 static MDNode *inlineLoopID(const MDNode *OrigLoopId, DILocation *InlinedAt,
1362 DenseMap<const MDNode *, MDNode *> &IANodes) {
1362 DenseMap<const MDNode *, MDNode *> &IANodes) {
1380 MDNode *NewLoopID = MDNode::getDistinct(Ctx, MDs);
1380 MDNode *NewLoopID = MDNode::getDistinct(Ctx, MDs);
1406 DenseMap<const MDNode *, MDNode *> IANodes;
1406 DenseMap<const MDNode *, MDNode *> IANodes;
1413 if (MDNode *LoopID = BI->getMetadata(LLVMContext::MD_loop)) {
1414 MDNode *NewLoopID =
lib/Transforms/Utils/LibCallsShrinkWrap.cpp 486 MDNode *BranchWeights =
lib/Transforms/Utils/Local.cpp 183 MDNode *MD = SI->getMetadata(LLVMContext::MD_prof);
275 MDNode *MD = SI->getMetadata(LLVMContext::MD_prof);
290 MDNode *MakeImplicitMD = SI->getMetadata(LLVMContext::MD_make_implicit);
1050 if (MDNode *LoopMD = TI->getMetadata(LoopMDKind))
1279 MDNode *Scope = DeclareLoc.getScope();
2284 SmallVector<std::pair<unsigned, MDNode *>, 4> Metadata;
2289 MDNode *JMD = J->getMetadata(Kind);
2290 MDNode *KMD = MD.second;
2299 K->setMetadata(Kind, MDNode::getMostGenericTBAA(JMD, KMD));
2302 K->setMetadata(Kind, MDNode::getMostGenericAliasScope(JMD, KMD));
2306 K->setMetadata(Kind, MDNode::intersect(JMD, KMD));
2321 K->setMetadata(Kind, MDNode::getMostGenericRange(JMD, KMD));
2324 K->setMetadata(Kind, MDNode::getMostGenericFPMath(JMD, KMD));
2340 MDNode::getMostGenericAlignmentOrDereferenceable(JMD, KMD));
2345 MDNode::getMostGenericAlignmentOrDereferenceable(JMD, KMD));
2358 if (auto *JMD = J->getMetadata(LLVMContext::MD_invariant_group))
2377 SmallVector<std::pair<unsigned, MDNode *>, 8> MD;
2384 MDNode *N = MDPair.second;
2541 void llvm::copyNonnullMetadata(const LoadInst &OldLI, MDNode *N,
2567 MDNode *N, LoadInst &NewLI) {
2579 MDNode *NN = MDNode::get(OldLI.getContext(), None);
2579 MDNode *NN = MDNode::get(OldLI.getContext(), None);
lib/Transforms/Utils/LoopRotationUtils.cpp 631 MDNode *LoopMD = L->getLoopID();
lib/Transforms/Utils/LoopSimplify.cpp 444 MDNode *LoopMD = nullptr;
lib/Transforms/Utils/LoopUnroll.cpp 962 MDNode *llvm::GetUnrollMetadata(MDNode *LoopID, StringRef Name) {
962 MDNode *llvm::GetUnrollMetadata(MDNode *LoopID, StringRef Name) {
968 MDNode *MD = dyn_cast<MDNode>(LoopID->getOperand(i));
968 MDNode *MD = dyn_cast<MDNode>(LoopID->getOperand(i));
lib/Transforms/Utils/LoopUnrollPeel.cpp 410 MDNode *WeightNode =
452 MDNode *WeightNode =
lib/Transforms/Utils/LoopUnrollRuntime.cpp 399 MDNode *LoopID = NewLoop->getLoopID();
407 Optional<MDNode *> NewLoopID = makeFollowupLoopID(
lib/Transforms/Utils/LoopUtils.cpp 200 static MDNode *createStringMetadata(Loop *TheLoop, StringRef Name, unsigned V) {
205 return MDNode::get(Context, MDs);
215 MDNode *LoopID = TheLoop->getLoopID();
218 MDNode *Node = cast<MDNode>(LoopID->getOperand(i));
218 MDNode *Node = cast<MDNode>(LoopID->getOperand(i));
240 MDNode *NewLoopID = MDNode::get(Context, MDs);
240 MDNode *NewLoopID = MDNode::get(Context, MDs);
253 MDNode *MD = findOptionMDForLoop(TheLoop, Name);
268 MDNode *MD = findOptionMDForLoop(TheLoop, Name);
302 Optional<MDNode *> llvm::makeFollowupLoopID(
303 MDNode *OrigLoopID, ArrayRef<StringRef> FollowupOptions,
322 MDNode *Op = cast<MDNode>(Existing.get());
322 MDNode *Op = cast<MDNode>(Existing.get());
353 MDNode *FollowupNode = findOptionMDForLoopID(OrigLoopID, OptionName);
378 MDTuple *FollowupLoopID = MDNode::get(OrigLoopID->getContext(), MDs);
lib/Transforms/Utils/LoopVersioning.cpp 184 MDNode *Domain = MDB.createAnonymousAliasScopeDomain("LVerDomain");
206 GroupToNonAliasingScopeList[Pair.first] = MDNode::get(Context, Pair.second);
237 MDNode::concatenate(
239 MDNode::get(Context, GroupToScope[Group->second])));
246 MDNode::concatenate(
lib/Transforms/Utils/MisExpect.cpp 97 if (auto *MisExpectData = I->getMetadata(LLVMContext::MD_misexpect)) {
148 if (auto *MD = I.getMetadata(LLVMContext::MD_prof)) {
lib/Transforms/Utils/SimplifyCFG.cpp 791 MDNode *N = nullptr;
804 MDNode *N = nullptr;
957 MDNode *ProfMD = I->getMetadata(LLVMContext::MD_prof);
970 MDNode *MD = TI->getMetadata(LLVMContext::MD_prof);
2861 if (MDNode *LoopMD = BI->getMetadata(LLVMContext::MD_loop))
lib/Transforms/Utils/ValueMapper.cpp 203 SmallVector<MDNode *, 16> POT; // Post-order traversal.
212 Metadata &getFwdReference(MDNode &Op);
216 SmallVector<MDNode *, 16> DistinctWorklist;
220 SmallVector<MDNode *, 16> POTStorage;
243 Metadata *map(const MDNode &N);
265 Metadata *mapTopLevelUniquedNode(const MDNode &FirstN);
284 MDNode *mapDistinctNode(const MDNode &N);
284 MDNode *mapDistinctNode(const MDNode &N);
303 bool createPOT(UniquedGraph &G, const MDNode &FirstN);
312 MDNode *visitOperands(UniquedGraph &G, MDNode::op_iterator &I,
312 MDNode *visitOperands(UniquedGraph &G, MDNode::op_iterator &I,
313 MDNode::op_iterator E, bool &HasChanged);
334 void remapOperands(MDNode &N, OperandMapper mapOperand);
533 const MDNode &N = *cast<MDNode>(Op);
533 const MDNode &N = *cast<MDNode>(Op);
539 static Metadata *cloneOrBuildODR(const MDNode &N) {
546 return MDNode::replaceWithDistinct(N.clone());
549 MDNode *MDNodeMapper::mapDistinctNode(const MDNode &N) {
549 MDNode *MDNodeMapper::mapDistinctNode(const MDNode &N) {
553 cast<MDNode>((M.Flags & RF_MoveDistinctMDs)
582 Metadata &MDNodeMapper::UniquedGraph::getFwdReference(MDNode &Op) {
598 void MDNodeMapper::remapOperands(MDNode &N, OperandMapper mapOperand) {
613 MDNode *N; ///< Current node.
614 MDNode::op_iterator Op; ///< Current operand of \c N.
620 POTWorklistEntry(MDNode &N) : N(&N), Op(N.op_begin()) {}
625 bool MDNodeMapper::createPOT(UniquedGraph &G, const MDNode &FirstN) {
637 if (MDNode *N = visitOperands(G, WE.Op, WE.N->op_end(), WE.HasChanged)) {
657 MDNode *MDNodeMapper::visitOperands(UniquedGraph &G, MDNode::op_iterator &I,
657 MDNode *MDNodeMapper::visitOperands(UniquedGraph &G, MDNode::op_iterator &I,
658 MDNode::op_iterator E, bool &HasChanged) {
668 MDNode &OpN = *cast<MDNode>(Op);
668 MDNode &OpN = *cast<MDNode>(Op);
681 for (MDNode *N : POT) {
699 SmallVector<MDNode *, 16> CyclicNodes;
700 for (auto *N : G.POT) {
718 return &G.getFwdReference(*cast<MDNode>(Old));
721 auto *NewN = MDNode::replaceWithUniqued(std::move(ClonedN));
721 auto *NewN = MDNode::replaceWithUniqued(std::move(ClonedN));
731 for (auto *N : CyclicNodes)
736 Metadata *MDNodeMapper::map(const MDNode &N) {
750 return mapTopLevelUniquedNode(*cast<MDNode>(Old));
755 Metadata *MDNodeMapper::mapTopLevelUniquedNode(const MDNode &FirstN) {
762 for (const MDNode *N : G.POT)
810 return MDNodeMapper(*this).map(*cast<MDNode>(MD));
878 SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
881 MDNode *Old = MI.second;
882 MDNode *New = cast_or_null<MDNode>(mapMetadata(Old));
882 MDNode *New = cast_or_null<MDNode>(mapMetadata(Old));
928 SmallVector<std::pair<unsigned, MDNode *>, 8> MDs;
932 GO.addMetadata(I.first, *cast<MDNode>(mapMetadata(I.second)));
1106 MDNode *ValueMapper::mapMDNode(const MDNode &N) {
1106 MDNode *ValueMapper::mapMDNode(const MDNode &N) {
1107 return cast_or_null<MDNode>(mapMetadata(N));
lib/Transforms/Vectorize/LoopVectorizationLegality.cpp 96 MDNode *IsVectorizedMD = MDNode::get(
96 MDNode *IsVectorizedMD = MDNode::get(
100 MDNode *LoopID = TheLoop->getLoopID();
101 MDNode *NewLoopID =
182 MDNode *LoopID = TheLoop->getLoopID();
196 if (const MDNode *MD = dyn_cast<MDNode>(LoopID->getOperand(i))) {
196 if (const MDNode *MD = dyn_cast<MDNode>(LoopID->getOperand(i))) {
lib/Transforms/Vectorize/LoopVectorize.cpp 2919 MDNode *OrigLoopID = OrigLoop->getLoopID();
3079 Optional<MDNode *> VectorizedLoopID =
3092 if (MDNode *LID = OrigLoop->getLoopID())
6585 MDNode *LoopID = L->getLoopID();
6589 auto *MD = dyn_cast<MDNode>(LoopID->getOperand(i));
6589 auto *MD = dyn_cast<MDNode>(LoopID->getOperand(i));
6605 MDNode *DisableNode = MDNode::get(Context, DisableOperands);
6605 MDNode *DisableNode = MDNode::get(Context, DisableOperands);
6607 MDNode *NewLoopID = MDNode::get(Context, MDs);
6607 MDNode *NewLoopID = MDNode::get(Context, MDs);
7745 MDNode *OrigLoopID = L->getLoopID();
7784 Optional<MDNode *> RemainderLoopID =
tools/bugpoint/CrashDebugger.cpp 878 class ReduceCrashingNamedMDOps : public ListReducer<const MDNode *> {
886 Expected<TestResult> doTest(std::vector<const MDNode *> &Prefix,
887 std::vector<const MDNode *> &Kept) override {
895 bool TestNamedMDOps(std::vector<const MDNode *> &NamedMDOps);
900 std::vector<const MDNode *> &NamedMDOps) {
902 SmallPtrSet<const MDNode *, 32> OldMDNodeOps;
923 for (MDNode *op : NamedMD.operands())
925 NewNamedMDNode->addOperand(cast<MDNode>(MapMetadata(op, VMap)));
938 for (const MDNode *Node : OldMDNodeOps)
939 NamedMDOps.push_back(cast<MDNode>(*VMap.getMappedMD(Node)));
1239 std::vector<const MDNode *> NamedMDOps;
tools/clang/lib/CodeGen/Address.h 108 template <class U> inline U cast(CodeGen::Address addr) {
tools/clang/lib/CodeGen/CGBuilder.h 306 llvm::MDNode *DbgInfo) {
tools/clang/lib/CodeGen/CGBuiltin.cpp 479 llvm::MDNode *RNode = MDHelper.createRange(APInt(32, low), APInt(32, high));
5930 llvm::MDNode *RegName = llvm::MDNode::get(Context, Ops);
5930 llvm::MDNode *RegName = llvm::MDNode::get(Context, Ops);
7256 llvm::MDNode *RegName = llvm::MDNode::get(Context, Ops);
7256 llvm::MDNode *RegName = llvm::MDNode::get(Context, Ops);
7429 llvm::MDNode *RegName = llvm::MDNode::get(Context, Ops);
7429 llvm::MDNode *RegName = llvm::MDNode::get(Context, Ops);
11338 llvm::MDNode *Node = llvm::MDNode::get(
11338 llvm::MDNode *Node = llvm::MDNode::get(
tools/clang/lib/CodeGen/CGDebugInfo.cpp 2053 llvm::MDNode *node;
2055 node = llvm::MDNode::get(CGM.getLLVMContext(), None);
2283 llvm::MDNode::replaceWithPermanent(llvm::TempDICompositeType(FwdDecl));
2493 llvm::MDNode *PropertyNode = DBuilder.createObjCProperty(
2572 llvm::MDNode *PropertyNode = nullptr;
3180 llvm::MDNode::replaceWithDistinct(llvm::TempDICompositeType(RealDecl));
3759 llvm::MDNode *Scope = LexicalBlockStack.back();
3765 llvm::MDNode *Back = nullptr;
4712 llvm::TempMDNode FwdDecl(cast<llvm::MDNode>(P.second));
4726 DBuilder.replaceTemporary(std::move(FwdDecl), cast<llvm::MDNode>(Repl));
4755 llvm::MDNode *Scope = LexicalBlockStack.back();
tools/clang/lib/CodeGen/CGDebugInfo.h 65 llvm::MDNode *CurInlinedAt = nullptr;
384 void setInlinedAt(llvm::MDNode *InlinedAt) { CurInlinedAt = InlinedAt; }
387 llvm::MDNode *getInlinedAt() const { return CurInlinedAt; }
tools/clang/lib/CodeGen/CGDeclCXX.cpp 309 llvm::MDNode *Weights;
tools/clang/lib/CodeGen/CGExpr.cpp 1577 llvm::MDNode *CodeGenFunction::getRangeForLoadFromType(QualType Ty) {
1674 llvm::MDNode *Node = llvm::MDNode::get(
1674 llvm::MDNode *Node = llvm::MDNode::get(
1685 if (llvm::MDNode *RangeInfo = getRangeForLoadFromType(Ty))
1755 llvm::MDNode *Node =
1756 llvm::MDNode::get(Store->getContext(),
1905 llvm::MDNode *RegName = cast<llvm::MDNode>(
1905 llvm::MDNode *RegName = cast<llvm::MDNode>(
2165 llvm::MDNode *RegName = cast<llvm::MDNode>(
2165 llvm::MDNode *RegName = cast<llvm::MDNode>(
2453 M->addOperand(llvm::MDNode::get(CGM.getLLVMContext(), Ops));
3058 llvm::MDNode *Node = MDHelper.createBranchWeights((1U << 20) - 1, 1);
3124 llvm::MDNode *Node = MDHelper.createBranchWeights((1U << 20) - 1, 1);
5003 llvm::MDNode *Node = MDHelper.createFPMath(Accuracy);
tools/clang/lib/CodeGen/CGExprAgg.cpp 2018 if (llvm::MDNode *TBAAStructTag = CGM.getTBAAStructInfo(Ty))
tools/clang/lib/CodeGen/CGExprComplex.cpp 721 llvm::MDNode *BrWeight = MDHelper.createBranchWeights(1, (1U << 20) - 1);
tools/clang/lib/CodeGen/CGLoopInfo.cpp 21 MDNode *
25 TempMDTuple TempNode = MDNode::getTemporary(Ctx, None);
29 MDNode *LoopID = MDNode::getDistinct(Ctx, NewLoopProperties);
29 MDNode *LoopID = MDNode::getDistinct(Ctx, NewLoopProperties);
34 MDNode *LoopInfo::createPipeliningMetadata(const LoopAttributes &Attrs,
50 MDNode::get(Ctx, {MDString::get(Ctx, "llvm.loop.pipeline.disable"),
59 TempMDTuple TempNode = MDNode::getTemporary(Ctx, None);
68 Args.push_back(MDNode::get(Ctx, Vals));
73 MDNode *LoopID = MDNode::getDistinct(Ctx, Args);
73 MDNode *LoopID = MDNode::getDistinct(Ctx, Args);
79 MDNode *
107 MDNode::get(Ctx, MDString::get(Ctx, "llvm.loop.unroll.disable")));
110 MDNode *Followup = createPipeliningMetadata(Attrs, FollowupLoopProperties,
114 TempMDTuple TempNode = MDNode::getTemporary(Ctx, None);
123 Args.push_back(MDNode::get(Ctx, Vals));
129 Args.push_back(MDNode::get(Ctx, Vals));
133 Args.push_back(MDNode::get(
136 MDNode *LoopID = MDNode::getDistinct(Ctx, Args);
136 MDNode *LoopID = MDNode::getDistinct(Ctx, Args);
142 MDNode *
159 NewLoopProperties.push_back(MDNode::get(
170 MDNode::get(Ctx, MDString::get(Ctx, "llvm.loop.unroll_and_jam.disable")));
173 MDNode *Followup = createPartialUnrollMetadata(Attrs, FollowupLoopProperties,
177 TempMDTuple TempNode = MDNode::getTemporary(Ctx, None);
187 Args.push_back(MDNode::get(Ctx, Vals));
192 Args.push_back(MDNode::get(Ctx, Vals));
196 Args.push_back(MDNode::get(
201 Args.push_back(MDNode::get(
205 MDNode *LoopID = MDNode::getDistinct(Ctx, Args);
205 MDNode *LoopID = MDNode::getDistinct(Ctx, Args);
211 MDNode *
230 MDNode::get(Ctx, {MDString::get(Ctx, "llvm.loop.vectorize.enable"),
244 MDNode::get(Ctx, MDString::get(Ctx, "llvm.loop.isvectorized")));
247 MDNode *Followup = createUnrollAndJamMetadata(Attrs, FollowupLoopProperties,
251 TempMDTuple TempNode = MDNode::getTemporary(Ctx, None);
268 Args.push_back(MDNode::get(Ctx, Vals));
277 Args.push_back(MDNode::get(Ctx, Vals));
286 Args.push_back(MDNode::get(Ctx, Vals));
299 Args.push_back(MDNode::get(Ctx, Vals));
303 Args.push_back(MDNode::get(
307 MDNode *LoopID = MDNode::get(Ctx, Args);
307 MDNode *LoopID = MDNode::get(Ctx, Args);
313 MDNode *
330 MDNode::get(Ctx, {MDString::get(Ctx, "llvm.loop.distribute.enable"),
340 MDNode *Followup =
344 TempMDTuple TempNode = MDNode::getTemporary(Ctx, None);
352 Args.push_back(MDNode::get(Ctx, Vals));
355 Args.push_back(MDNode::get(
359 MDNode *LoopID = MDNode::get(Ctx, Args);
359 MDNode *LoopID = MDNode::get(Ctx, Args);
365 MDNode *LoopInfo::createFullUnrollMetadata(const LoopAttributes &Attrs,
381 MDNode::get(Ctx, MDString::get(Ctx, "llvm.loop.unroll.disable")));
389 TempMDTuple TempNode = MDNode::getTemporary(Ctx, None);
392 Args.push_back(MDNode::get(Ctx, MDString::get(Ctx, "llvm.loop.unroll.full")));
397 MDNode *LoopID = MDNode::getDistinct(Ctx, Args);
397 MDNode *LoopID = MDNode::getDistinct(Ctx, Args);
403 MDNode *LoopInfo::createMetadata(
422 LoopProperties.push_back(MDNode::get(
464 AccGroup = MDNode::getDistinct(Ctx, {});
479 TempLoopID = MDNode::getTemporary(Header->getContext(), None);
488 MDNode *LoopID;
547 MDNode::get(Ctx, MDString::get(Ctx, "llvm.loop.isvectorized")));
550 MDNode *InnerFollowup = createMetadata(AfterJam, BeforeLoopProperties,
769 if (MDNode *Group = AL->getAccessGroup())
772 MDNode *UnionMD = nullptr;
774 UnionMD = cast<MDNode>(AccessGroups[0]);
776 UnionMD = MDNode::get(I->getContext(), AccessGroups);
tools/clang/lib/CodeGen/CGLoopInfo.h 88 llvm::MDNode *getLoopID() const { return TempLoopID.get(); }
97 llvm::MDNode *getAccessGroup() const { return AccGroup; }
111 llvm::MDNode *AccGroup = nullptr;
121 llvm::MDNode *UnrollAndJamInnerFollowup = nullptr;
124 llvm::MDNode *
144 llvm::MDNode *
148 llvm::MDNode *
152 llvm::MDNode *
156 llvm::MDNode *
160 llvm::MDNode *
164 llvm::MDNode *
182 llvm::MDNode *createMetadata(const LoopAttributes &Attrs,
212 llvm::MDNode *getCurLoopID() const { return getInfo().getLoopID(); }
tools/clang/lib/CodeGen/CGObjC.cpp 137 llvm::MDNode::get(getLLVMContext(), None));
2151 llvm::MDNode::get(Builder.getContext(), None));
2249 llvm::MDNode::get(Builder.getContext(), None));
2655 llvm::MDNode::get(Builder.getContext(), None));
3727 LinkerOptionsMetadata.push_back(llvm::MDNode::get(Context, Args));
tools/clang/lib/CodeGen/CGObjCGNU.cpp 548 llvm::MDNode *node,
687 llvm::Value *cmd, llvm::MDNode *node,
749 llvm::Value *cmd, llvm::MDNode *node,
2038 llvm::Value *cmd, llvm::MDNode *node,
2601 llvm::MDNode *node = llvm::MDNode::get(VMContext, impMD);
2601 llvm::MDNode *node = llvm::MDNode::get(VMContext, impMD);
2677 llvm::MDNode *node = llvm::MDNode::get(VMContext, impMD);
2677 llvm::MDNode *node = llvm::MDNode::get(VMContext, impMD);
tools/clang/lib/CodeGen/CGObjCMac.cpp 5006 llvm::MDNode::get(VMContext, Ops));
7077 llvm::MDNode::get(VMContext, None));
7481 llvm::MDNode::get(VMContext, None));
tools/clang/lib/CodeGen/CGOpenMPRuntime.cpp 1797 *llvm::MDNode::get(Ctx, {MDB.createCallbackEncoding(
2235 *llvm::MDNode::get(Ctx, {MDB.createCallbackEncoding(
4118 MD->addOperand(llvm::MDNode::get(C, Ops));
4146 MD->addOperand(llvm::MDNode::get(C, Ops));
4255 for (llvm::MDNode *MN : MD->operands()) {
tools/clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.cpp 1853 MD->addOperand(llvm::MDNode::get(Ctx, MDVals));
tools/clang/lib/CodeGen/CGStmt.cpp 1232 llvm::MDNode *Weights = nullptr;
1885 static llvm::MDNode *getAsmSrcLocInfo(const StringLiteral *Str,
1909 return llvm::MDNode::get(CGF.getLLVMContext(), Locs);
1939 llvm::MDNode::get(CGF.getLLVMContext(),
tools/clang/lib/CodeGen/CodeGenFunction.cpp 558 Fn->setMetadata("vec_type_hint", llvm::MDNode::get(Context, AttrMDArgs));
566 Fn->setMetadata("work_group_size_hint", llvm::MDNode::get(Context, AttrMDArgs));
574 Fn->setMetadata("reqd_work_group_size", llvm::MDNode::get(Context, AttrMDArgs));
582 llvm::MDNode::get(Context, AttrMDArgs));
1536 llvm::MDNode *Unpredictable = nullptr;
1549 llvm::MDNode *Weights =
tools/clang/lib/CodeGen/CodeGenFunction.h 1334 llvm::MDNode *createProfileWeights(uint64_t TrueCount, uint64_t FalseCount);
1335 llvm::MDNode *createProfileWeights(ArrayRef<uint64_t> Weights);
1336 llvm::MDNode *createProfileWeightsForLoop(const Stmt *Cond,
4158 llvm::MDNode *getRangeForLoadFromType(QualType Ty);
tools/clang/lib/CodeGen/CodeGenModule.cpp 462 for (auto *MD : ELFDependentLibraries)
505 llvm::MDNode::get(VMContext, Ops));
581 SPIRVerMD->addOperand(llvm::MDNode::get(Ctx, SPIRVerElts));
643 OCLVerMD->addOperand(llvm::MDNode::get(Ctx, OCLVerElts));
656 llvm::MDNode *CodeGenModule::getTBAATypeInfo(QualType QTy) {
675 llvm::MDNode *CodeGenModule::getTBAAStructInfo(QualType QTy) {
681 llvm::MDNode *CodeGenModule::getTBAABaseTypeInfo(QualType QTy) {
687 llvm::MDNode *CodeGenModule::getTBAAAccessTagInfo(TBAAAccessInfo Info) {
718 if (llvm::MDNode *Tag = getTBAAAccessTagInfo(TBAAInfo))
725 llvm::MDNode::get(getLLVMContext(), {}));
1418 llvm::MDNode::get(VMContext, addressQuals));
1420 llvm::MDNode::get(VMContext, accessQuals));
1422 llvm::MDNode::get(VMContext, argTypeNames));
1424 llvm::MDNode::get(VMContext, argBaseTypeNames));
1426 llvm::MDNode::get(VMContext, argTypeQuals));
1429 llvm::MDNode::get(VMContext, argNames));
1879 *llvm::MDNode::get(Ctx, {MDB.createCallbackEncoding(
1930 LinkerOptionsMetadata.push_back(llvm::MDNode::get(getLLVMContext(), MDOpts));
1937 LinkerOptionsMetadata.push_back(llvm::MDNode::get(getLLVMContext(), MDOpts));
1944 llvm::MDNode::get(C, llvm::MDString::get(C, Lib)));
1951 LinkerOptionsMetadata.push_back(llvm::MDNode::get(C, MDOpts));
1957 SmallVectorImpl<llvm::MDNode *> &Metadata,
1988 Metadata.push_back(llvm::MDNode::get(Context, Args));
1998 Metadata.push_back(llvm::MDNode::get(Context, Args));
2004 Metadata.push_back(llvm::MDNode::get(Context, OptString));
2058 SmallVector<llvm::MDNode *, 16> MetadataArgs;
2068 for (auto *MD : LinkerOptionsMetadata)
5572 GlobalMetadata->addOperand(llvm::MDNode::get(CGM.getLLVMContext(), Ops));
5637 DeclPtrKind, llvm::MDNode::get(
5653 IdentMetadata->addOperand(llvm::MDNode::get(Ctx, IdentNode));
5663 CommandLineMetadata->addOperand(llvm::MDNode::get(Ctx, CommandLineNode));
5697 llvm::MDNode *CU = CUNode->getOperand(i);
5699 GCov->addOperand(llvm::MDNode::get(Ctx, Elts));
5778 InternalId = llvm::MDNode::getDistinct(getLLVMContext(),
tools/clang/lib/CodeGen/CodeGenModule.h 325 llvm::MDNode *NoObjCARCExceptionsMetadata = nullptr;
474 SmallVector<llvm::MDNode *, 16> LinkerOptionsMetadata;
477 SmallVector<llvm::MDNode *, 16> ELFDependentLibraries;
661 llvm::MDNode *getNoObjCARCExceptionsMetadata() {
663 NoObjCARCExceptionsMetadata = llvm::MDNode::get(getLLVMContext(), None);
708 llvm::MDNode *getTBAATypeInfo(QualType QTy);
718 llvm::MDNode *getTBAAStructInfo(QualType QTy);
722 llvm::MDNode *getTBAABaseTypeInfo(QualType QTy);
725 llvm::MDNode *getTBAAAccessTagInfo(TBAAAccessInfo Info);
tools/clang/lib/CodeGen/CodeGenPGO.cpp 1011 llvm::MDNode *CodeGenFunction::createProfileWeights(uint64_t TrueCount,
1025 llvm::MDNode *
1048 llvm::MDNode *CodeGenFunction::createProfileWeightsForLoop(const Stmt *Cond,
tools/clang/lib/CodeGen/CodeGenTBAA.cpp 43 llvm::MDNode *CodeGenTBAA::getRoot() {
58 llvm::MDNode *CodeGenTBAA::createScalarTypeNode(StringRef Name,
59 llvm::MDNode *Parent,
68 llvm::MDNode *CodeGenTBAA::getChar() {
114 llvm::MDNode *CodeGenTBAA::getTypeInfoHelper(const Type *Ty) {
187 llvm::MDNode *CodeGenTBAA::getTypeInfo(QualType QTy) {
207 if (llvm::MDNode *N = MetadataCache[Ty])
213 llvm::MDNode *TypeNode = getTypeInfoHelper(Ty);
275 llvm::MDNode *TBAAType = MayAlias ? getChar() : getTypeInfo(QTy);
276 llvm::MDNode *TBAATag = getAccessTagInfo(TBAAAccessInfo(TBAAType, Size));
281 llvm::MDNode *
285 if (llvm::MDNode *N = StructMetadataCache[Ty])
296 llvm::MDNode *CodeGenTBAA::getBaseTypeInfoHelper(const Type *Ty) {
305 llvm::MDNode *TypeNode = isValidBaseType(FieldQTy) ?
327 llvm::MDNode *Parent = getChar();
334 SmallVector<std::pair<llvm::MDNode*, uint64_t>, 4> OffsetsAndTypes;
343 llvm::MDNode *CodeGenTBAA::getBaseTypeInfo(QualType QTy) {
348 if (llvm::MDNode *N = BaseTypeMetadataCache[Ty])
354 llvm::MDNode *TypeNode = getBaseTypeInfoHelper(Ty);
358 llvm::MDNode *CodeGenTBAA::getAccessTagInfo(TBAAAccessInfo Info) {
370 llvm::MDNode *&N = AccessTagMetadataCache[Info];
tools/clang/lib/CodeGen/CodeGenTBAA.h 43 TBAAAccessInfo(TBAAAccessKind Kind, llvm::MDNode *BaseType,
44 llvm::MDNode *AccessType, uint64_t Offset, uint64_t Size)
49 TBAAAccessInfo(llvm::MDNode *BaseType, llvm::MDNode *AccessType,
49 TBAAAccessInfo(llvm::MDNode *BaseType, llvm::MDNode *AccessType,
55 explicit TBAAAccessInfo(llvm::MDNode *AccessType, uint64_t Size)
101 llvm::MDNode *BaseType;
105 llvm::MDNode *AccessType;
129 llvm::DenseMap<const Type *, llvm::MDNode *> MetadataCache;
131 llvm::DenseMap<const Type *, llvm::MDNode *> BaseTypeMetadataCache;
133 llvm::DenseMap<TBAAAccessInfo, llvm::MDNode *> AccessTagMetadataCache;
137 llvm::DenseMap<const Type *, llvm::MDNode *> StructMetadataCache;
139 llvm::MDNode *Root;
140 llvm::MDNode *Char;
144 llvm::MDNode *getRoot();
148 llvm::MDNode *getChar();
159 llvm::MDNode *createScalarTypeNode(StringRef Name, llvm::MDNode *Parent,
159 llvm::MDNode *createScalarTypeNode(StringRef Name, llvm::MDNode *Parent,
164 llvm::MDNode *getTypeInfoHelper(const Type *Ty);
168 llvm::MDNode *getBaseTypeInfoHelper(const Type *Ty);
177 llvm::MDNode *getTypeInfo(QualType QTy);
189 llvm::MDNode *getTBAAStructInfo(QualType QTy);
193 llvm::MDNode *getBaseTypeInfo(QualType QTy);
196 llvm::MDNode *getAccessTagInfo(TBAAAccessInfo Info);
224 DenseMapInfo<MDNode *>::getEmptyKey(),
225 DenseMapInfo<MDNode *>::getEmptyKey(),
234 DenseMapInfo<MDNode *>::getTombstoneKey(),
235 DenseMapInfo<MDNode *>::getTombstoneKey(),
243 DenseMapInfo<MDNode *>::getHashValue(Val.BaseType) ^
244 DenseMapInfo<MDNode *>::getHashValue(Val.AccessType) ^
tools/clang/lib/CodeGen/ItaniumCXXABI.cpp 1807 llvm::MDNode::get(CGM.getLLVMContext(),
tools/clang/lib/CodeGen/SanitizerMetadata.cpp 56 llvm::MDNode *ThisGlobal = llvm::MDNode::get(VMContext, GlobalMetadata);
56 llvm::MDNode *ThisGlobal = llvm::MDNode::get(VMContext, GlobalMetadata);
87 llvm::MDNode::get(CGM.getLLVMContext(), None));
90 llvm::MDNode *SanitizerMetadata::getLocationMetadata(SourceLocation Loc) {
102 return llvm::MDNode::get(VMContext, LocMetadata);
tools/clang/lib/CodeGen/SanitizerMetadata.h 47 llvm::MDNode *getLocationMetadata(SourceLocation Loc);
tools/clang/lib/CodeGen/TargetInfo.cpp 6527 MD->addOperand(llvm::MDNode::get(Ctx, MDVals));
7419 OpenCLMetadata->addOperand(llvm::MDNode::get(Context, Operands));
8877 MD->addOperand(llvm::MDNode::get(Ctx, MDVals));
9975 F->setMetadata("kernel_arg_addr_space", llvm::MDNode::get(C, AddressQuals));
9976 F->setMetadata("kernel_arg_access_qual", llvm::MDNode::get(C, AccessQuals));
9977 F->setMetadata("kernel_arg_type", llvm::MDNode::get(C, ArgTypeNames));
9979 llvm::MDNode::get(C, ArgBaseTypeNames));
9980 F->setMetadata("kernel_arg_type_qual", llvm::MDNode::get(C, ArgTypeQuals));
9982 F->setMetadata("kernel_arg_name", llvm::MDNode::get(C, ArgNames));
tools/clang/unittests/CodeGen/IRMatchers.h 78 void push(const T *V, unsigned N = ~0) {
270 SmallVector<std::pair<unsigned, MDNode *>, 8> MDs;
tools/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp 128 llvm::MDNode *metadata_node =
129 dyn_cast<llvm::MDNode>(named_metadata->getOperand(node_index));
366 MDNode *persistent_global_md = MDNode::get(m_module->getContext(), value_ref);
366 MDNode *persistent_global_md = MDNode::get(m_module->getContext(), value_ref);
1077 MDNode *alloc_md = alloc->getMetadata("clang.decl.ptr");
1122 MDNode *persistent_global_md = MDNode::get(m_module->getContext(), value_ref);
1122 MDNode *persistent_global_md = MDNode::get(m_module->getContext(), value_ref);
tools/llvm-reduce/deltas/ReduceMetadata.cpp 26 std::set<MDNode *> &SeenNodes,
27 std::set<MDNode *> &NodesToKeep) {
28 SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
44 const std::set<MDNode *> &NodesToKeep) {
45 SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
56 std::set<MDNode *> SeenNodes;
57 std::set<MDNode *> NodesToKeep;
106 static void addMetadataToSet(T &MDUser, std::set<MDNode *> &UnnamedNodes) {
107 SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
115 std::set<MDNode *> UnnamedNodes;
tools/opt/Debugify.cpp 153 NMD->addOperand(MDNode::get(
tools/polly/include/polly/CodeGen/IRBuilder.h 104 llvm::SmallVector<llvm::MDNode *, 8> ParallelLoops;
107 llvm::MDNode *AliasScopeDomain;
110 llvm::MapVector<llvm::AssertingVH<llvm::Value>, llvm::MDNode *> AliasScopeMap;
113 llvm::DenseMap<llvm::AssertingVH<llvm::Value>, llvm::MDNode *>
117 llvm::DenseMap<const llvm::SCEV *, llvm::MDNode *> SecondLevelAliasScopeMap;
120 llvm::DenseMap<const llvm::SCEV *, llvm::MDNode *>
tools/polly/lib/CodeGen/IRBuilder.cpp 32 static MDNode *getID(LLVMContext &Ctx, Metadata *arg0 = nullptr,
34 MDNode *ID;
37 auto TempNode = MDNode::getTemporary(Ctx, None);
46 ID = MDNode::get(Ctx, Args);
84 MDNode *AliasScopeList = MDNode::get(Ctx, {});
84 MDNode *AliasScopeList = MDNode::get(Ctx, {});
91 MDNode::concatenate(AliasScopeList, MDNode::get(Ctx, Args));
91 MDNode::concatenate(AliasScopeList, MDNode::get(Ctx, Args));
105 MDNode *Id = getID(Header->getContext());
108 MDNode *Ids = ParallelLoops.empty()
110 : MDNode::concatenate(ParallelLoops.back(), Id);
125 MDNode *MData = nullptr;
133 MData = MDNode::concatenate(MData, getID(Ctx, MDNode::get(Ctx, Args)));
133 MData = MDNode::concatenate(MData, getID(Ctx, MDNode::get(Ctx, Args)));
138 MDNode *Ids = ParallelLoops.back();
139 MDNode *Id = cast<MDNode>(Ids->getOperand(Ids->getNumOperands() - 1));
139 MDNode *Id = cast<MDNode>(Ids->getOperand(Ids->getNumOperands() - 1));
140 MData = MDNode::concatenate(MData, Id);
182 SecondLevelAliasScopeMap[BasePtrSCEV] = MDNode::concatenate(
183 SecondLevelBasePtrAliasScopeList, MDNode::get(Ctx, Args));
185 SecondLevelOtherAliasScopeList = MDNode::concatenate(
240 auto *OtherAliasScopeList = OtherAliasScopeListMap[BasePtr];
unittests/Analysis/LoopInfoTest.cpp 92 if (MDNode *D = L->getLoopID()) {
141 MDNode *OldLoopID = L->getLoopID();
144 MDNode *NewLoopID = MDNode::get(Context, {nullptr});
144 MDNode *NewLoopID = MDNode::get(Context, {nullptr});
unittests/Analysis/MemorySSATest.cpp 787 Load->setMetadata(LLVMContext::MD_invariant_load, MDNode::get(C, {}));
unittests/Analysis/TBAATest.cpp 52 auto *RootMD = MD.createTBAARoot("Simple C/C++ TBAA");
53 auto *MD1 = MD.createTBAANode("omnipotent char", RootMD);
54 auto *MD2 = MD.createTBAANode("int", MD1);
72 auto *RootMD = MD.createTBAARoot("tbaa-root");
73 auto *MD1 = MD.createTBAANode("scalar-a", RootMD);
74 auto *StructTag1 = MD.createTBAAStructTagNode(MD1, MD1, 0);
75 auto *MD2 = MD.createTBAANode("scalar-b", RootMD);
76 auto *StructTag2 = MD.createTBAAStructTagNode(MD2, MD2, 0);
78 auto *GenericMD = MDNode::getMostGenericTBAA(StructTag1, StructTag2);
78 auto *GenericMD = MDNode::getMostGenericTBAA(StructTag1, StructTag2);
unittests/CodeGen/MachineInstrTest.cpp 389 MDNode *MDN = MDNode::getDistinct(Ctx, None);
389 MDNode *MDN = MDNode::getDistinct(Ctx, None);
435 MDNode *MDN = MDNode::getDistinct(Ctx, None);
435 MDNode *MDN = MDNode::getDistinct(Ctx, None);
472 MDNode *MDN = MDNode::getDistinct(Ctx, None);
472 MDNode *MDN = MDNode::getDistinct(Ctx, None);
unittests/CodeGen/MachineOperandTest.cpp 299 MDNode *Node = MDNode::get(Ctx, MDS);
299 MDNode *Node = MDNode::get(Ctx, MDS);
unittests/IR/AsmWriterTest.cpp 30 "", MDNode::get(Ctx, {ConstantAsMetadata::get(ConstantInt::get(Ty, 1))}));
unittests/IR/IRBuilderTest.cpp 340 MDNode *Weights = MDBuilder(Ctx).createBranchWeights(42, 13);
639 MDNode *FPMathA = MDB.createFPMath(0.01f);
640 MDNode *FPMathB = MDB.createFPMath(0.1f);
756 DenseMap<const MDNode *, MDNode *> IANodes;
756 DenseMap<const MDNode *, MDNode *> IANodes;
unittests/IR/InstructionsTest.cpp 413 MDNode *MD1 = MDHelper.createFPMath(1.0);
551 Call->setDebugLoc(DebugLoc(MDNode::get(C, None)));
581 Invoke->setDebugLoc(DebugLoc(MDNode::get(C, None)));
unittests/IR/MDBuilderTest.cpp 33 MDNode *MD0 = MDHelper.createFPMath(0.0);
34 MDNode *MD1 = MDHelper.createFPMath(1.0);
47 MDNode *R0 = MDHelper.createRange(A, A);
48 MDNode *R1 = MDHelper.createRange(A, B);
61 MDNode *R0 = MDHelper.createAnonymousTBAARoot();
62 MDNode *R1 = MDHelper.createAnonymousTBAARoot();
73 MDNode *R0 = MDHelper.createTBAARoot("Root");
74 MDNode *R1 = MDHelper.createTBAARoot("Root");
83 MDNode *R = MDHelper.createTBAARoot("Root");
84 MDNode *N0 = MDHelper.createTBAANode("Node", R);
85 MDNode *N1 = MDHelper.createTBAANode("edoN", R);
86 MDNode *N2 = MDHelper.createTBAANode("Node", R, true);
87 MDNode *N3 = MDHelper.createTBAANode("Node", R);
unittests/IR/MetadataTest.cpp 73 MDNode *getNode() { return MDNode::get(Context, None); }
73 MDNode *getNode() { return MDNode::get(Context, None); }
74 MDNode *getNode(Metadata *MD) { return MDNode::get(Context, MD); }
74 MDNode *getNode(Metadata *MD) { return MDNode::get(Context, MD); }
75 MDNode *getNode(Metadata *MD1, Metadata *MD2) {
77 return MDNode::get(Context, MDs);
187 MDNode *n1 = MDNode::get(Context, V);
187 MDNode *n1 = MDNode::get(Context, V);
189 MDNode *n2 = MDNode::get(Context, c1);
189 MDNode *n2 = MDNode::get(Context, c1);
191 MDNode *n3 = MDNode::get(Context, V);
191 MDNode *n3 = MDNode::get(Context, V);
192 MDNode *n4 = MDNode::getIfExists(Context, V);
192 MDNode *n4 = MDNode::getIfExists(Context, V);
193 MDNode *n5 = MDNode::getIfExists(Context, c1);
193 MDNode *n5 = MDNode::getIfExists(Context, c1);
194 MDNode *n6 = MDNode::getIfExists(Context, c2);
194 MDNode *n6 = MDNode::getIfExists(Context, c2);
215 MDNode *n = MDNode::get(Context, V);
215 MDNode *n = MDNode::get(Context, V);
227 auto Temp = MDNode::getTemporary(Context, None);
229 MDNode *Self = MDNode::get(Context, Args);
229 MDNode *Self = MDNode::get(Context, Args);
236 MDNode *Ref1 = MDNode::get(Context, Args);
236 MDNode *Ref1 = MDNode::get(Context, Args);
237 MDNode *Ref2 = MDNode::get(Context, Args);
237 MDNode *Ref2 = MDNode::get(Context, Args);
245 auto Temp = MDNode::getTemporary(Context, None);
246 Metadata *Args[] = {Temp.get(), MDNode::get(Context, None)};
247 MDNode *Self = MDNode::get(Context, Args);
247 MDNode *Self = MDNode::get(Context, Args);
254 MDNode *Ref1 = MDNode::get(Context, Args);
254 MDNode *Ref1 = MDNode::get(Context, Args);
255 MDNode *Ref2 = MDNode::get(Context, Args);
255 MDNode *Ref2 = MDNode::get(Context, Args);
264 MDNode *N0 = getNode();
265 MDNode *N1 = getNode(N0);
266 MDNode *N2 = getNode(N0, N1);
269 MDNode *N = MDNode::get(Context, Args);
269 MDNode *N = MDNode::get(Context, Args);
279 MDNode *Nodes[] = {N0, N1, N2};
280 for (auto *Node : Nodes)
305 MDNode *Arg = getNode();
306 TempMDNode Temp = MDNode::getTemporary(Context, Arg);
307 MDNode *N = getNode(Temp.get());
323 MDNode *N0 = getNode();
324 MDNode *N1 = getNode(N0);
325 MDNode *N2 = getNode(N0, N1);
328 MDNode *N = MDNode::get(Context, Args);
328 MDNode *N = MDNode::get(Context, Args);
355 auto *N0 = MDNode::getDistinct(Context, None);
356 auto *N1 = MDNode::getDistinct(Context, None);
381 auto *N0 = MDNode::getDistinct(Context, None);
382 auto *N1 = MDNode::getDistinct(Context, None);
416 auto *N0 = MDNode::getDistinct(Context, None);
428 MDNode *Empty = MDNode::get(Context, None);
428 MDNode *Empty = MDNode::get(Context, None);
432 MDNode *N = MDNode::get(Context, Ops);
432 MDNode *N = MDNode::get(Context, Ops);
441 MDNode *NullOp = MDNode::get(Context, Ops);
441 MDNode *NullOp = MDNode::get(Context, Ops);
448 MDNode *Empty = MDNode::get(Context, None);
448 MDNode *Empty = MDNode::get(Context, None);
454 MDNode *Wrapped1 = MDNode::get(Context, Wrapped1Ops);
454 MDNode *Wrapped1 = MDNode::get(Context, Wrapped1Ops);
461 MDNode *Wrapped2 = MDNode::get(Context, Wrapped2Ops);
461 MDNode *Wrapped2 = MDNode::get(Context, Wrapped2Ops);
509 MDNode *Empty = MDNode::get(Context, None);
509 MDNode *Empty = MDNode::get(Context, None);
515 MDNode *Distinct1 = MDNode::getDistinct(Context, None);
515 MDNode *Distinct1 = MDNode::getDistinct(Context, None);
516 MDNode *Distinct2 = MDNode::getDistinct(Context, None);
516 MDNode *Distinct2 = MDNode::getDistinct(Context, None);
528 MDNode *U = MDTuple::get(Context, None);
529 MDNode *D = MDTuple::getDistinct(Context, None);
537 MDNode *U = MDTuple::get(Context, None);
538 MDNode *D = MDTuple::getDistinct(Context, None);
546 MDNode *U = MDTuple::get(Context, None);
547 MDNode *D = MDTuple::getDistinct(Context, None);
561 MDNode *Distinct = MDNode::getDistinct(Context, Ops);
561 MDNode *Distinct = MDNode::getDistinct(Context, Ops);
566 MDNode *Empty = MDNode::get(Context, None);
566 MDNode *Empty = MDNode::get(Context, None);
573 MDNode *N0 = MDNode::get(Context, None);
573 MDNode *N0 = MDNode::get(Context, None);
578 MDNode *N1 = MDNode::get(Context, Ops1);
578 MDNode *N1 = MDNode::get(Context, Ops1);
582 MDNode *N2 = MDNode::get(Context, Ops2);
582 MDNode *N2 = MDNode::get(Context, Ops2);
586 MDNode *N3 = MDNode::get(Context, Ops3);
586 MDNode *N3 = MDNode::get(Context, Ops3);
591 MDNode *N4 = MDNode::get(Context, Ops4);
591 MDNode *N4 = MDNode::get(Context, Ops4);
605 MDNode *N5 = MDNode::getDistinct(Context, Ops5);
605 MDNode *N5 = MDNode::getDistinct(Context, Ops5);
607 MDNode *N6 = MDNode::getDistinct(Context, Ops6);
607 MDNode *N6 = MDNode::getDistinct(Context, Ops6);
643 MDNode *Empty = MDTuple::get(Context, ArrayRef<Metadata *>());
644 MDNode *N = MDTuple::get(Context, Ops);
670 FirstUniqued = MDNode::replaceWithUniqued(std::move(Temp));
681 auto *Uniqued = MDNode::replaceWithUniqued(std::move(Temp));
693 auto *Uniqued = MDNode::replaceWithUniqued(std::move(Temp));
783 auto *Distinct = MDNode::replaceWithDistinct(std::move(Temp));
796 auto *Distinct = MDNode::replaceWithDistinct(std::move(Temp));
823 auto *N = MDNode::replaceWithPermanent(std::move(Temp));
961 MDNode *N = getSubprogram();
970 MDNode *N = MDNode::get(Context, None);
970 MDNode *N = MDNode::get(Context, None);
977 MDNode *N = MDNode::get(Context, None);
977 MDNode *N = MDNode::get(Context, None);
1095 auto *Empty = MDNode::get(Context, None);
1751 auto *Clone = MDNode::replaceWithPermanent(std::move(Temp));
2485 MDNode *N = MDNode::get(Context, None);
2485 MDNode *N = MDNode::get(Context, None);
2495 MDNode *N = MDNode::get(Context, None);
2495 MDNode *N = MDNode::get(Context, None);
2497 MDNode *N2 = MDNode::get(Context, Ops);
2497 MDNode *N2 = MDNode::get(Context, Ops);
2515 auto *N = MDNode::get(Context, Ops);
2627 MDNode *n = MDNode::get(Context, V);
2627 MDNode *n = MDNode::get(Context, V);
2628 MDNode *n2 = MDNode::get(Context, V2);
2628 MDNode *n2 = MDNode::get(Context, V2);
2711 SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
unittests/Linker/LinkModulesTest.cpp 264 MDNode *M0 = F->getMetadata("attach");
265 MDNode *M1 =
266 cast<MDNode>(cast<MetadataAsValue>(CI->getArgOperand(0))->getMetadata());
267 MDNode *M2 = RI->getMetadata("attach");
268 MDNode *M3 = NMD->getOperand(0);
269 MDNode *M4 = NMD->getOperand(1);
unittests/Transforms/Utils/CloningTest.cpp 728 GV->addMetadata(LLVMContext::MD_type, *MDNode::get(C, {}));
unittests/Transforms/Utils/ValueMapperTest.cpp 32 MDNode *U0;
33 MDNode *U1;
40 U1 = MDNode::replaceWithUniqued(std::move(T));
75 MDNode *N0; // !0 = !{!1}
76 MDNode *N1; // !1 = !{!0, i8* @G0}
82 N0 = MDNode::replaceWithUniqued(std::move(T0));
96 MDNode *MappedN0 = ValueMapper(VM).mapMDNode(*N0);
97 MDNode *MappedN1 = ValueMapper(VM).mapMDNode(*N1);
usr/include/c++/7.4.0/bits/stl_iterator_base_types.h 123 typedef _Tp value_type;
usr/include/c++/7.4.0/bits/unique_ptr.h 122 using type = _Up*;
137 using pointer = typename _Ptr<_Tp, _Dp>::type;
161 typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;
163 __uniq_ptr_impl<_Tp, _Dp> _M_t;
166 using pointer = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
167 using element_type = _Tp;
252 unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
297 __safe_conversion_up<_Up, _Ep>,
301 operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
usr/include/c++/7.4.0/type_traits 215 : public __is_void_helper<typename remove_cv<_Tp>::type>::type
381 : public __is_pointer_helper<typename remove_cv<_Tp>::type>::type
581 : public __or_<is_lvalue_reference<_Tp>,
582 is_rvalue_reference<_Tp>>::type
601 : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
601 : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
602 is_void<_Tp>>>::type
638 : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
638 : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
1554 { typedef _Tp type; };
1558 { typedef _Tp type; };
1563 { typedef _Tp type; };
1574 remove_const<typename remove_volatile<_Tp>::type>::type type;
1645 { typedef _Tp& type; };
1650 : public __add_lvalue_reference_helper<_Tp>
1983 { typedef _Up type; };
utils/unittest/googletest/include/gtest/gtest-printers.h 407 T* p, ::std::ostream* os) {
416 if (IsTrue(ImplicitlyConvertible<T*, const void*>::value)) {
utils/unittest/googletest/include/gtest/gtest.h 1475 T* rhs) {