35 OnlyNamed = onlyNamed;
38 for (
const auto &
G : M.globals()) {
39 incorporateType(
G.getValueType());
40 if (
G.hasInitializer())
41 incorporateValue(
G.getInitializer());
45 for (
const auto &
A : M.aliases()) {
46 incorporateType(
A.getValueType());
47 if (
const Value *Aliasee =
A.getAliasee())
48 incorporateValue(Aliasee);
52 for (
const auto &GI : M.ifuncs())
53 incorporateType(GI.getValueType());
58 incorporateType(FI.getFunctionType());
59 incorporateAttributes(FI.getAttributes());
61 for (
const Use &U : FI.operands())
62 incorporateValue(U.get());
65 for (
const auto &
A : FI.args())
71 incorporateType(
I.getType());
75 for (
const auto &O :
I.operands())
76 if (&*O && !isa<Instruction>(&*O))
77 incorporateValue(&*O);
79 if (
auto *
GEP = dyn_cast<GetElementPtrInst>(&
I))
80 incorporateType(
GEP->getSourceElementType());
81 if (
auto *AI = dyn_cast<AllocaInst>(&
I))
82 incorporateType(AI->getAllocatedType());
83 if (
const auto *CB = dyn_cast<CallBase>(&
I))
84 incorporateAttributes(CB->getAttributes());
87 I.getAllMetadataOtherThanDebugLoc(MDForInst);
88 for (
const auto &MD : MDForInst)
89 incorporateMDNode(MD.second);
94 for (
const auto &NMD : M.named_metadata())
95 for (
const auto *MDOp : NMD.operands())
96 incorporateMDNode(MDOp);
100 VisitedConstants.
clear();
101 VisitedTypes.clear();
107void TypeFinder::incorporateType(
Type *Ty) {
109 if (!VisitedTypes.insert(Ty).second)
118 if (
StructType *STy = dyn_cast<StructType>(Ty))
119 if (!OnlyNamed || STy->hasName())
120 StructTypes.push_back(STy);
124 if (VisitedTypes.insert(SubTy).second)
126 }
while (!TypeWorklist.
empty());
133void TypeFinder::incorporateValue(
const Value *V) {
134 if (
const auto *M = dyn_cast<MetadataAsValue>(V)) {
135 if (
const auto *
N = dyn_cast<MDNode>(
M->getMetadata()))
136 return incorporateMDNode(
N);
137 if (
const auto *MDV = dyn_cast<ValueAsMetadata>(
M->getMetadata()))
138 return incorporateValue(MDV->getValue());
142 if (!isa<Constant>(V) || isa<GlobalValue>(V))
return;
145 if (!VisitedConstants.
insert(V).second)
149 incorporateType(
V->getType());
152 if (isa<Instruction>(V))
155 if (
auto *
GEP = dyn_cast<GEPOperator>(V))
156 incorporateType(
GEP->getSourceElementType());
159 const User *
U = cast<User>(V);
160 for (
const auto &
I :
U->operands())
161 incorporateValue(&*
I);
166void TypeFinder::incorporateMDNode(
const MDNode *V) {
168 if (!VisitedMetadata.insert(V).second)
173 if (
const auto *AL = dyn_cast<DIArgList>(V)) {
174 for (
auto *
Arg :
AL->getArgs())
175 incorporateValue(
Arg->getValue());
183 if (
auto *
N = dyn_cast<MDNode>(Op)) {
184 incorporateMDNode(
N);
187 if (
auto *
C = dyn_cast<ConstantAsMetadata>(Op)) {
188 incorporateValue(
C->getValue());
195 if (!VisitedAttributes.insert(AL).second)
200 if (
A.isTypeAttribute())
201 incorporateType(
A.getValueAsType());
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
Module.h This file contains the declarations for the Module class.
This file defines the SmallVector class.
This defines the Use class.
LLVM Basic Block Representation.
A Module instance is used to store all the information related to an LLVM module.
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Class to represent struct types.
void run(const Module &M, bool onlyNamed)
The instances of the Type class are immutable: once they are created, they are never changed.
ArrayRef< Type * > subtypes() const
A Use represents the edge between a Value definition and its users.
LLVM Value Representation.
std::pair< iterator, bool > insert(const ValueT &V)
@ C
The default llvm calling convention, compatible with C.
This is an optimization pass for GlobalISel generic memory operations.
auto reverse(ContainerTy &&C)