Go to the documentation of this file.
9 #ifndef LLVM_IR_MODULESUMMARYINDEXYAML_H
10 #define LLVM_IR_MODULESUMMARYINDEXYAML_H
31 io.mapOptional(
"Kind", res.
TheKind);
33 io.mapOptional(
"AlignLog2", res.
AlignLog2);
34 io.mapOptional(
"SizeM1", res.
SizeM1);
35 io.mapOptional(
"BitMask", res.
BitMask);
45 io.enumCase(value,
"UniformRetVal",
47 io.enumCase(value,
"UniqueRetVal",
49 io.enumCase(value,
"VirtualConstProp",
56 io.mapOptional(
"Kind", res.
TheKind);
57 io.mapOptional(
"Info", res.
Info);
58 io.mapOptional(
"Byte", res.
Byte);
59 io.mapOptional(
"Bit", res.
Bit);
64 struct CustomMappingTraits<
65 std::map<std::vector<uint64_t>, WholeProgramDevirtResolution::ByArg>> {
69 std::vector<uint64_t>
Args;
70 std::pair<StringRef, StringRef>
P = {
"",
Key};
71 while (!
P.second.empty()) {
72 P =
P.second.split(
',');
74 if (
P.first.getAsInteger(0,
Arg)) {
75 io.setError(
"key not an integer");
80 io.mapRequired(
Key.str().c_str(), V[
Args]);
92 io.mapRequired(
Key.c_str(),
P.second);
101 io.enumCase(value,
"BranchFunnel",
108 io.mapOptional(
"Kind", res.
TheKind);
110 io.mapOptional(
"ResByArg", res.
ResByArg);
115 struct CustomMappingTraits<
std::map<uint64_t, WholeProgramDevirtResolution>> {
117 std::map<uint64_t, WholeProgramDevirtResolution> &V) {
119 if (
Key.getAsInteger(0, KeyInt)) {
120 io.setError(
"key not an integer");
123 io.mapRequired(
Key.str().c_str(), V[KeyInt]);
125 static void output(IO &io, std::map<uint64_t, WholeProgramDevirtResolution> &V) {
127 io.mapRequired(llvm::utostr(
P.first).c_str(),
P.second);
133 io.mapOptional(
"TTRes", summary.
TTRes);
134 io.mapOptional(
"WPDRes", summary.
WPDRes);
157 io.mapOptional(
"GUID",
id.GUID);
158 io.mapOptional(
"Offset",
id.Offset);
164 io.mapOptional(
"VFunc",
id.VFunc);
165 io.mapOptional(
"Args",
id.
Args);
180 io.mapOptional(
"Linkage", summary.
Linkage);
181 io.mapOptional(
"Visibility", summary.
Visibility);
183 io.mapOptional(
"Live", summary.
Live);
184 io.mapOptional(
"Local", summary.
IsLocal);
185 io.mapOptional(
"CanAutoHide", summary.
CanAutoHide);
186 io.mapOptional(
"Refs", summary.
Refs);
187 io.mapOptional(
"TypeTests", summary.
TypeTests);
190 io.mapOptional(
"TypeTestAssumeConstVCalls",
192 io.mapOptional(
"TypeCheckedLoadConstVCalls",
208 std::vector<FunctionSummaryYaml> FSums;
209 io.mapRequired(
Key.str().c_str(), FSums);
211 if (
Key.getAsInteger(0, KeyInt)) {
212 io.setError(
"key not an integer");
215 if (!V.count(KeyInt))
216 V.emplace(KeyInt,
false);
217 auto &Elem = V.find(KeyInt)->second;
218 for (
auto &FSum : FSums) {
219 std::vector<ValueInfo> Refs;
220 for (
auto &RefGUID : FSum.Refs) {
221 if (!V.count(RefGUID))
222 V.emplace(RefGUID,
false);
223 Refs.push_back(
ValueInfo(
false, &*V.find(RefGUID)));
225 Elem.SummaryList.push_back(std::make_unique<FunctionSummary>(
229 FSum.NotEligibleToImport, FSum.Live, FSum.IsLocal,
235 std::move(FSum.TypeTestAssumeConstVCalls),
236 std::move(FSum.TypeCheckedLoadConstVCalls),
242 std::vector<FunctionSummaryYaml> FSums;
243 for (
auto &Sum :
P.second.SummaryList) {
244 if (
auto *FSum = dyn_cast<FunctionSummary>(Sum.get())) {
245 std::vector<uint64_t> Refs;
246 for (
auto &
VI : FSum->refs())
247 Refs.push_back(
VI.getGUID());
249 FSum->flags().Linkage, FSum->flags().Visibility,
250 static_cast<bool>(FSum->flags().NotEligibleToImport),
251 static_cast<bool>(FSum->flags().Live),
252 static_cast<bool>(FSum->flags().DSOLocal),
253 static_cast<bool>(FSum->flags().CanAutoHide), Refs,
254 FSum->type_tests(), FSum->type_test_assume_vcalls(),
255 FSum->type_checked_load_vcalls(),
256 FSum->type_test_assume_const_vcalls(),
257 FSum->type_checked_load_const_vcalls()});
261 io.mapRequired(llvm::utostr(
P.first).c_str(), FSums);
269 io.mapRequired(
Key.str().c_str(), TId);
273 for (
auto TidIter = V.begin(); TidIter != V.end(); TidIter++)
274 io.mapRequired(TidIter->second.first.c_str(), TidIter->second.second);
280 io.mapOptional(
"GlobalValueMap",
index.GlobalValueMap);
281 io.mapOptional(
"TypeIdMap",
index.TypeIdMap);
282 io.mapOptional(
"WithGlobalValueDeadStripping",
283 index.WithGlobalValueDeadStripping);
285 if (io.outputting()) {
286 std::vector<std::string> CfiFunctionDefs(
index.CfiFunctionDefs.begin(),
287 index.CfiFunctionDefs.end());
288 io.mapOptional(
"CfiFunctionDefs", CfiFunctionDefs);
289 std::vector<std::string> CfiFunctionDecls(
index.CfiFunctionDecls.begin(),
290 index.CfiFunctionDecls.end());
291 io.mapOptional(
"CfiFunctionDecls", CfiFunctionDecls);
293 std::vector<std::string> CfiFunctionDefs;
294 io.mapOptional(
"CfiFunctionDefs", CfiFunctionDefs);
295 index.CfiFunctionDefs = {CfiFunctionDefs.begin(), CfiFunctionDefs.end()};
296 std::vector<std::string> CfiFunctionDecls;
297 io.mapOptional(
"CfiFunctionDecls", CfiFunctionDecls);
298 index.CfiFunctionDecls = {CfiFunctionDecls.begin(),
299 CfiFunctionDecls.end()};
std::map< std::vector< uint64_t >, ByArg > ResByArg
Resolutions for calls with all constant integer arguments (excluding the first argument,...
static void mapping(IO &io, FunctionSummaryYaml &summary)
static void mapping(IO &io, TypeTestResolution &res)
This is an optimization pass for GlobalISel generic memory operations.
enum llvm::WholeProgramDevirtResolution::ByArg::Kind TheKind
std::map< GlobalValue::GUID, GlobalValueSummaryInfo > GlobalValueSummaryMapTy
Map from global value GUID to corresponding summary structures.
static void inputOne(IO &io, StringRef Key, std::map< std::vector< uint64_t >, WholeProgramDevirtResolution::ByArg > &V)
Kind
Specifies which kind of type check we should emit for this byte array.
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
static void output(IO &io, std::map< uint64_t, WholeProgramDevirtResolution > &V)
@ Unsat
Unsatisfiable type (i.e. no global has this type metadata)
#define LLVM_YAML_IS_SEQUENCE_VECTOR(type)
@ AllOnes
All-ones bit vector ("Eliminating Bit Vector Checks for All-Ones Bit Vectors")
static void mapping(IO &io, WholeProgramDevirtResolution::ByArg &res)
static void mapping(IO &io, WholeProgramDevirtResolution &res)
LinkageTypes
An enumeration for the kinds of linkage for global values.
std::vector< uint64_t > TypeTests
Group flags (Linkage, NotEligibleToImport, etc.) as a bitfield.
A specification for a virtual function call with all constant integer arguments.
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
static void mapping(IO &io, FunctionSummary::VFuncId &id)
VisibilityTypes
An enumeration for the kinds of visibility of global values.
@ BranchFunnel
When retpoline mitigation is enabled, use a branch funnel that is defined in the merged module.
@ Inline
Inlined bit vector ("Short Inline Bit Vectors")
@ SingleImpl
Single implementation devirtualization.
Struct that holds a reference to a particular GUID in a global value summary.
std::string SingleImplName
@ Single
Single element (last example in "Short Inline Bit Vectors")
@ UniformRetVal
Uniform return value optimization.
An "identifier" for a virtual function.
static void output(IO &io, std::map< std::vector< uint64_t >, WholeProgramDevirtResolution::ByArg > &V)
@ Indir
Just do a regular virtual call.
@ Indir
Just do a regular virtual call.
std::vector< FunctionSummary::ConstVCall > TypeTestAssumeConstVCalls
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
@ UniqueRetVal
Unique return value optimization.
static void mapping(IO &io, TypeIdSummary &summary)
std::vector< FunctionSummary::VFuncId > TypeCheckedLoadVCalls
static void inputOne(IO &io, StringRef Key, std::map< uint64_t, WholeProgramDevirtResolution > &V)
Flags specific to function summaries.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
std::vector< uint64_t > Refs
StringRef - Represent a constant reference to a string, i.e.
static void enumeration(IO &io, WholeProgramDevirtResolution::Kind &value)
std::vector< FunctionSummary::ConstVCall > TypeCheckedLoadConstVCalls
enum llvm::TypeTestResolution::Kind TheKind
@ Unknown
Unknown (analysis not performed, don't lower)
Function summary information to aid decisions and implementation of importing.
static void mapping(IO &io, ModuleSummaryIndex &index)
GUID getGUID() const
Return a 64-bit global unique ID constructed from global value name (i.e.
uint64_t Info
Additional information for the resolution:
@ VirtualConstProp
Virtual constant propagation.
std::map< uint64_t, WholeProgramDevirtResolution > WPDRes
Mapping from byte offset to whole-program devirt resolution for that (typeid, byte offset) pair.
enum llvm::WholeProgramDevirtResolution::Kind TheKind
Class to hold module path string table and global value map, and encapsulate methods for operating on...
std::vector< FunctionSummary::VFuncId > TypeTestAssumeVCalls
static void enumeration(IO &io, WholeProgramDevirtResolution::ByArg::Kind &value)
static void enumeration(IO &io, TypeTestResolution::Kind &value)
static void output(IO &io, TypeIdSummaryMapTy &V)
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
@ ByteArray
Test a byte array (first example)
std::multimap< GlobalValue::GUID, std::pair< std::string, TypeIdSummary > > TypeIdSummaryMapTy
Map of a type GUID to type id string and summary (multimap used in case of GUID conflicts).
static void inputOne(IO &io, StringRef Key, TypeIdSummaryMapTy &V)
static void mapping(IO &io, FunctionSummary::ConstVCall &id)
unsigned SizeM1BitWidth
Range of size-1 expressed as a bit width.
static void inputOne(IO &io, StringRef Key, GlobalValueSummaryMapTy &V)
static void output(IO &io, GlobalValueSummaryMapTy &V)