LLVM 18.0.0git
ModuleSummaryIndex.h
Go to the documentation of this file.
1//===- llvm/ModuleSummaryIndex.h - Module Summary Index ---------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9/// @file
10/// ModuleSummaryIndex.h This file contains the declarations the classes that
11/// hold the module index and summary for function importing.
12//
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_IR_MODULESUMMARYINDEX_H
16#define LLVM_IR_MODULESUMMARYINDEX_H
17
18#include "llvm/ADT/ArrayRef.h"
19#include "llvm/ADT/DenseMap.h"
20#include "llvm/ADT/STLExtras.h"
24#include "llvm/ADT/StringMap.h"
25#include "llvm/ADT/StringRef.h"
27#include "llvm/IR/GlobalValue.h"
28#include "llvm/IR/Module.h"
34#include <algorithm>
35#include <array>
36#include <cassert>
37#include <cstddef>
38#include <cstdint>
39#include <map>
40#include <memory>
41#include <optional>
42#include <set>
43#include <string>
44#include <utility>
45#include <vector>
46
47namespace llvm {
48
49template <class GraphType> struct GraphTraits;
50
51namespace yaml {
52
53template <typename T> struct MappingTraits;
54
55} // end namespace yaml
56
57/// Class to accumulate and hold information about a callee.
58struct CalleeInfo {
59 enum class HotnessType : uint8_t {
60 Unknown = 0,
61 Cold = 1,
62 None = 2,
63 Hot = 3,
64 Critical = 4
65 };
66
67 // The size of the bit-field might need to be adjusted if more values are
68 // added to HotnessType enum.
70
71 /// The value stored in RelBlockFreq has to be interpreted as the digits of
72 /// a scaled number with a scale of \p -ScaleShift.
74 static constexpr int32_t ScaleShift = 8;
75 static constexpr uint64_t MaxRelBlockFreq = (1 << 29) - 1;
76
78 : Hotness(static_cast<uint32_t>(HotnessType::Unknown)), RelBlockFreq(0) {}
80 : Hotness(static_cast<uint32_t>(Hotness)), RelBlockFreq(RelBF) {}
81
82 void updateHotness(const HotnessType OtherHotness) {
83 Hotness = std::max(Hotness, static_cast<uint32_t>(OtherHotness));
84 }
85
87
88 /// Update \p RelBlockFreq from \p BlockFreq and \p EntryFreq
89 ///
90 /// BlockFreq is divided by EntryFreq and added to RelBlockFreq. To represent
91 /// fractional values, the result is represented as a fixed point number with
92 /// scale of -ScaleShift.
93 void updateRelBlockFreq(uint64_t BlockFreq, uint64_t EntryFreq) {
94 if (EntryFreq == 0)
95 return;
97 Scaled64 Temp(BlockFreq, ScaleShift);
98 Temp /= Scaled64::get(EntryFreq);
99
100 uint64_t Sum =
101 SaturatingAdd<uint64_t>(Temp.toInt<uint64_t>(), RelBlockFreq);
102 Sum = std::min(Sum, uint64_t(MaxRelBlockFreq));
103 RelBlockFreq = static_cast<uint32_t>(Sum);
104 }
105};
106
108 switch (HT) {
110 return "unknown";
112 return "cold";
114 return "none";
116 return "hot";
118 return "critical";
119 }
120 llvm_unreachable("invalid hotness");
121}
122
123class GlobalValueSummary;
124
125using GlobalValueSummaryList = std::vector<std::unique_ptr<GlobalValueSummary>>;
126
127struct alignas(8) GlobalValueSummaryInfo {
128 union NameOrGV {
129 NameOrGV(bool HaveGVs) {
130 if (HaveGVs)
131 GV = nullptr;
132 else
133 Name = "";
134 }
135
136 /// The GlobalValue corresponding to this summary. This is only used in
137 /// per-module summaries and when the IR is available. E.g. when module
138 /// analysis is being run, or when parsing both the IR and the summary
139 /// from assembly.
141
142 /// Summary string representation. This StringRef points to BC module
143 /// string table and is valid until module data is stored in memory.
144 /// This is guaranteed to happen until runThinLTOBackend function is
145 /// called, so it is safe to use this field during thin link. This field
146 /// is only valid if summary index was loaded from BC file.
148 } U;
149
150 inline GlobalValueSummaryInfo(bool HaveGVs);
151
152 /// List of global value summary structures for a particular value held
153 /// in the GlobalValueMap. Requires a vector in the case of multiple
154 /// COMDAT values of the same name.
156};
157
158/// Map from global value GUID to corresponding summary structures. Use a
159/// std::map rather than a DenseMap so that pointers to the map's value_type
160/// (which are used by ValueInfo) are not invalidated by insertion. Also it will
161/// likely incur less overhead, as the value type is not very small and the size
162/// of the map is unknown, resulting in inefficiencies due to repeated
163/// insertions and resizing.
165 std::map<GlobalValue::GUID, GlobalValueSummaryInfo>;
166
167/// Struct that holds a reference to a particular GUID in a global value
168/// summary.
169struct ValueInfo {
170 enum Flags { HaveGV = 1, ReadOnly = 2, WriteOnly = 4 };
173
174 ValueInfo() = default;
175 ValueInfo(bool HaveGVs, const GlobalValueSummaryMapTy::value_type *R) {
177 RefAndFlags.setInt(HaveGVs);
178 }
179
180 explicit operator bool() const { return getRef(); }
181
182 GlobalValue::GUID getGUID() const { return getRef()->first; }
183 const GlobalValue *getValue() const {
184 assert(haveGVs());
185 return getRef()->second.U.GV;
186 }
187
189 return getRef()->second.SummaryList;
190 }
191
192 StringRef name() const {
193 return haveGVs() ? getRef()->second.U.GV->getName()
194 : getRef()->second.U.Name;
195 }
196
197 bool haveGVs() const { return RefAndFlags.getInt() & HaveGV; }
198 bool isReadOnly() const {
200 return RefAndFlags.getInt() & ReadOnly;
201 }
202 bool isWriteOnly() const {
204 return RefAndFlags.getInt() & WriteOnly;
205 }
206 unsigned getAccessSpecifier() const {
208 return RefAndFlags.getInt() & (ReadOnly | WriteOnly);
209 }
211 unsigned BadAccessMask = ReadOnly | WriteOnly;
212 return (RefAndFlags.getInt() & BadAccessMask) != BadAccessMask;
213 }
214 void setReadOnly() {
215 // We expect ro/wo attribute to set only once during
216 // ValueInfo lifetime.
219 }
223 }
224
225 const GlobalValueSummaryMapTy::value_type *getRef() const {
226 return RefAndFlags.getPointer();
227 }
228
229 /// Returns the most constraining visibility among summaries. The
230 /// visibilities, ordered from least to most constraining, are: default,
231 /// protected and hidden.
233
234 /// Checks if all summaries are DSO local (have the flag set). When DSOLocal
235 /// propagation has been done, set the parameter to enable fast check.
236 bool isDSOLocal(bool WithDSOLocalPropagation = false) const;
237
238 /// Checks if all copies are eligible for auto-hiding (have flag set).
239 bool canAutoHide() const;
240};
241
243 OS << VI.getGUID();
244 if (!VI.name().empty())
245 OS << " (" << VI.name() << ")";
246 return OS;
247}
248
249inline bool operator==(const ValueInfo &A, const ValueInfo &B) {
250 assert(A.getRef() && B.getRef() &&
251 "Need ValueInfo with non-null Ref for comparison");
252 return A.getRef() == B.getRef();
253}
254
255inline bool operator!=(const ValueInfo &A, const ValueInfo &B) {
256 assert(A.getRef() && B.getRef() &&
257 "Need ValueInfo with non-null Ref for comparison");
258 return A.getRef() != B.getRef();
259}
260
261inline bool operator<(const ValueInfo &A, const ValueInfo &B) {
262 assert(A.getRef() && B.getRef() &&
263 "Need ValueInfo with non-null Ref to compare GUIDs");
264 return A.getGUID() < B.getGUID();
265}
266
267template <> struct DenseMapInfo<ValueInfo> {
268 static inline ValueInfo getEmptyKey() {
269 return ValueInfo(false, (GlobalValueSummaryMapTy::value_type *)-8);
270 }
271
272 static inline ValueInfo getTombstoneKey() {
273 return ValueInfo(false, (GlobalValueSummaryMapTy::value_type *)-16);
274 }
275
276 static inline bool isSpecialKey(ValueInfo V) {
277 return V == getTombstoneKey() || V == getEmptyKey();
278 }
279
280 static bool isEqual(ValueInfo L, ValueInfo R) {
281 // We are not supposed to mix ValueInfo(s) with different HaveGVs flag
282 // in a same container.
283 assert(isSpecialKey(L) || isSpecialKey(R) || (L.haveGVs() == R.haveGVs()));
284 return L.getRef() == R.getRef();
285 }
286 static unsigned getHashValue(ValueInfo I) { return (uintptr_t)I.getRef(); }
287};
288
289/// Summary of memprof callsite metadata.
291 // Actual callee function.
293
294 // Used to record whole program analysis cloning decisions.
295 // The ThinLTO backend will need to create as many clones as there are entries
296 // in the vector (it is expected and should be confirmed that all such
297 // summaries in the same FunctionSummary have the same number of entries).
298 // Each index records version info for the corresponding clone of this
299 // function. The value is the callee clone it calls (becomes the appended
300 // suffix id). Index 0 is the original version, and a value of 0 calls the
301 // original callee.
303
304 // Represents stack ids in this context, recorded as indices into the
305 // StackIds vector in the summary index, which in turn holds the full 64-bit
306 // stack ids. This reduces memory as there are in practice far fewer unique
307 // stack ids than stack id references.
309
316};
317
319 OS << "Callee: " << SNI.Callee;
320 bool First = true;
321 OS << " Clones: ";
322 for (auto V : SNI.Clones) {
323 if (!First)
324 OS << ", ";
325 First = false;
326 OS << V;
327 }
328 First = true;
329 OS << " StackIds: ";
330 for (auto Id : SNI.StackIdIndices) {
331 if (!First)
332 OS << ", ";
333 First = false;
334 OS << Id;
335 }
336 return OS;
337}
338
339// Allocation type assigned to an allocation reached by a given context.
340// More can be added, now this is cold, notcold and hot.
341// Values should be powers of two so that they can be ORed, in particular to
342// track allocations that have different behavior with different calling
343// contexts.
344enum class AllocationType : uint8_t {
345 None = 0,
346 NotCold = 1,
347 Cold = 2,
348 Hot = 4,
349 All = 7 // This should always be set to the OR of all values.
350};
351
352/// Summary of a single MIB in a memprof metadata on allocations.
353struct MIBInfo {
354 // The allocation type for this profiled context.
356
357 // Represents stack ids in this context, recorded as indices into the
358 // StackIds vector in the summary index, which in turn holds the full 64-bit
359 // stack ids. This reduces memory as there are in practice far fewer unique
360 // stack ids than stack id references.
362
365};
366
368 OS << "AllocType " << (unsigned)MIB.AllocType;
369 bool First = true;
370 OS << " StackIds: ";
371 for (auto Id : MIB.StackIdIndices) {
372 if (!First)
373 OS << ", ";
374 First = false;
375 OS << Id;
376 }
377 return OS;
378}
379
380/// Summary of memprof metadata on allocations.
381struct AllocInfo {
382 // Used to record whole program analysis cloning decisions.
383 // The ThinLTO backend will need to create as many clones as there are entries
384 // in the vector (it is expected and should be confirmed that all such
385 // summaries in the same FunctionSummary have the same number of entries).
386 // Each index records version info for the corresponding clone of this
387 // function. The value is the allocation type of the corresponding allocation.
388 // Index 0 is the original version. Before cloning, index 0 may have more than
389 // one allocation type.
391
392 // Vector of MIBs in this memprof metadata.
393 std::vector<MIBInfo> MIBs;
394
395 AllocInfo(std::vector<MIBInfo> MIBs) : MIBs(std::move(MIBs)) {
397 }
400};
401
403 bool First = true;
404 OS << "Versions: ";
405 for (auto V : AE.Versions) {
406 if (!First)
407 OS << ", ";
408 First = false;
409 OS << (unsigned)V;
410 }
411 OS << " MIB:\n";
412 for (auto &M : AE.MIBs) {
413 OS << "\t\t" << M << "\n";
414 }
415 return OS;
416}
417
418/// Function and variable summary information to aid decisions and
419/// implementation of importing.
421public:
422 /// Sububclass discriminator (for dyn_cast<> et al.)
424
425 /// Group flags (Linkage, NotEligibleToImport, etc.) as a bitfield.
426 struct GVFlags {
427 /// The linkage type of the associated global value.
428 ///
429 /// One use is to flag values that have local linkage types and need to
430 /// have module identifier appended before placing into the combined
431 /// index, to disambiguate from other values with the same name.
432 /// In the future this will be used to update and optimize linkage
433 /// types based on global summary-based analysis.
434 unsigned Linkage : 4;
435
436 /// Indicates the visibility.
437 unsigned Visibility : 2;
438
439 /// Indicate if the global value cannot be imported (e.g. it cannot
440 /// be renamed or references something that can't be renamed).
442
443 /// In per-module summary, indicate that the global value must be considered
444 /// a live root for index-based liveness analysis. Used for special LLVM
445 /// values such as llvm.global_ctors that the linker does not know about.
446 ///
447 /// In combined summary, indicate that the global value is live.
448 unsigned Live : 1;
449
450 /// Indicates that the linker resolved the symbol to a definition from
451 /// within the same linkage unit.
452 unsigned DSOLocal : 1;
453
454 /// In the per-module summary, indicates that the global value is
455 /// linkonce_odr and global unnamed addr (so eligible for auto-hiding
456 /// via hidden visibility). In the combined summary, indicates that the
457 /// prevailing linkonce_odr copy can be auto-hidden via hidden visibility
458 /// when it is upgraded to weak_odr in the backend. This is legal when
459 /// all copies are eligible for auto-hiding (i.e. all copies were
460 /// linkonce_odr global unnamed addr. If any copy is not (e.g. it was
461 /// originally weak_odr, we cannot auto-hide the prevailing copy as it
462 /// means the symbol was externally visible.
463 unsigned CanAutoHide : 1;
464
465 /// Convenience Constructors
468 bool NotEligibleToImport, bool Live, bool IsLocal,
469 bool CanAutoHide)
472 DSOLocal(IsLocal), CanAutoHide(CanAutoHide) {}
473 };
474
475private:
476 /// Kind of summary for use in dyn_cast<> et al.
477 SummaryKind Kind;
478
479 GVFlags Flags;
480
481 /// This is the hash of the name of the symbol in the original file. It is
482 /// identical to the GUID for global symbols, but differs for local since the
483 /// GUID includes the module level id in the hash.
484 GlobalValue::GUID OriginalName = 0;
485
486 /// Path of module IR containing value's definition, used to locate
487 /// module during importing.
488 ///
489 /// This is only used during parsing of the combined index, or when
490 /// parsing the per-module index for creation of the combined summary index,
491 /// not during writing of the per-module index which doesn't contain a
492 /// module path string table.
493 StringRef ModulePath;
494
495 /// List of values referenced by this global value's definition
496 /// (either by the initializer of a global variable, or referenced
497 /// from within a function). This does not include functions called, which
498 /// are listed in the derived FunctionSummary object.
499 std::vector<ValueInfo> RefEdgeList;
500
501protected:
502 GlobalValueSummary(SummaryKind K, GVFlags Flags, std::vector<ValueInfo> Refs)
503 : Kind(K), Flags(Flags), RefEdgeList(std::move(Refs)) {
504 assert((K != AliasKind || Refs.empty()) &&
505 "Expect no references for AliasSummary");
506 }
507
508public:
509 virtual ~GlobalValueSummary() = default;
510
511 /// Returns the hash of the original name, it is identical to the GUID for
512 /// externally visible symbols, but not for local ones.
513 GlobalValue::GUID getOriginalName() const { return OriginalName; }
514
515 /// Initialize the original name hash in this summary.
516 void setOriginalName(GlobalValue::GUID Name) { OriginalName = Name; }
517
518 /// Which kind of summary subclass this is.
519 SummaryKind getSummaryKind() const { return Kind; }
520
521 /// Set the path to the module containing this function, for use in
522 /// the combined index.
523 void setModulePath(StringRef ModPath) { ModulePath = ModPath; }
524
525 /// Get the path to the module containing this function.
526 StringRef modulePath() const { return ModulePath; }
527
528 /// Get the flags for this GlobalValue (see \p struct GVFlags).
529 GVFlags flags() const { return Flags; }
530
531 /// Return linkage type recorded for this global value.
533 return static_cast<GlobalValue::LinkageTypes>(Flags.Linkage);
534 }
535
536 /// Sets the linkage to the value determined by global summary-based
537 /// optimization. Will be applied in the ThinLTO backends.
539 Flags.Linkage = Linkage;
540 }
541
542 /// Return true if this global value can't be imported.
543 bool notEligibleToImport() const { return Flags.NotEligibleToImport; }
544
545 bool isLive() const { return Flags.Live; }
546
547 void setLive(bool Live) { Flags.Live = Live; }
548
549 void setDSOLocal(bool Local) { Flags.DSOLocal = Local; }
550
551 bool isDSOLocal() const { return Flags.DSOLocal; }
552
553 void setCanAutoHide(bool CanAutoHide) { Flags.CanAutoHide = CanAutoHide; }
554
555 bool canAutoHide() const { return Flags.CanAutoHide; }
556
558 return (GlobalValue::VisibilityTypes)Flags.Visibility;
559 }
561 Flags.Visibility = (unsigned)Vis;
562 }
563
564 /// Flag that this global value cannot be imported.
565 void setNotEligibleToImport() { Flags.NotEligibleToImport = true; }
566
567 /// Return the list of values referenced by this global value definition.
568 ArrayRef<ValueInfo> refs() const { return RefEdgeList; }
569
570 /// If this is an alias summary, returns the summary of the aliased object (a
571 /// global variable or function), otherwise returns itself.
573 const GlobalValueSummary *getBaseObject() const;
574
575 friend class ModuleSummaryIndex;
576};
577
579
580/// Alias summary information.
582 ValueInfo AliaseeValueInfo;
583
584 /// This is the Aliasee in the same module as alias (could get from VI, trades
585 /// memory for time). Note that this pointer may be null (and the value info
586 /// empty) when we have a distributed index where the alias is being imported
587 /// (as a copy of the aliasee), but the aliasee is not.
588 GlobalValueSummary *AliaseeSummary;
589
590public:
593 AliaseeSummary(nullptr) {}
594
595 /// Check if this is an alias summary.
596 static bool classof(const GlobalValueSummary *GVS) {
597 return GVS->getSummaryKind() == AliasKind;
598 }
599
600 void setAliasee(ValueInfo &AliaseeVI, GlobalValueSummary *Aliasee) {
601 AliaseeValueInfo = AliaseeVI;
602 AliaseeSummary = Aliasee;
603 }
604
605 bool hasAliasee() const {
606 assert(!!AliaseeSummary == (AliaseeValueInfo &&
607 !AliaseeValueInfo.getSummaryList().empty()) &&
608 "Expect to have both aliasee summary and summary list or neither");
609 return !!AliaseeSummary;
610 }
611
613 assert(AliaseeSummary && "Unexpected missing aliasee summary");
614 return *AliaseeSummary;
615 }
616
618 return const_cast<GlobalValueSummary &>(
619 static_cast<const AliasSummary *>(this)->getAliasee());
620 }
622 assert(AliaseeValueInfo && "Unexpected missing aliasee");
623 return AliaseeValueInfo;
624 }
626 assert(AliaseeValueInfo && "Unexpected missing aliasee");
627 return AliaseeValueInfo.getGUID();
628 }
629};
630
632 if (auto *AS = dyn_cast<AliasSummary>(this))
633 return &AS->getAliasee();
634 return this;
635}
636
638 if (auto *AS = dyn_cast<AliasSummary>(this))
639 return &AS->getAliasee();
640 return this;
641}
642
643/// Function summary information to aid decisions and implementation of
644/// importing.
646public:
647 /// <CalleeValueInfo, CalleeInfo> call edge pair.
648 using EdgeTy = std::pair<ValueInfo, CalleeInfo>;
649
650 /// Types for -force-summary-edges-cold debugging option.
651 enum ForceSummaryHotnessType : unsigned {
655 };
656
657 /// An "identifier" for a virtual function. This contains the type identifier
658 /// represented as a GUID and the offset from the address point to the virtual
659 /// function pointer, where "address point" is as defined in the Itanium ABI:
660 /// https://itanium-cxx-abi.github.io/cxx-abi/abi.html#vtable-general
661 struct VFuncId {
664 };
665
666 /// A specification for a virtual function call with all constant integer
667 /// arguments. This is used to perform virtual constant propagation on the
668 /// summary.
669 struct ConstVCall {
671 std::vector<uint64_t> Args;
672 };
673
674 /// All type identifier related information. Because these fields are
675 /// relatively uncommon we only allocate space for them if necessary.
676 struct TypeIdInfo {
677 /// List of type identifiers used by this function in llvm.type.test
678 /// intrinsics referenced by something other than an llvm.assume intrinsic,
679 /// represented as GUIDs.
680 std::vector<GlobalValue::GUID> TypeTests;
681
682 /// List of virtual calls made by this function using (respectively)
683 /// llvm.assume(llvm.type.test) or llvm.type.checked.load intrinsics that do
684 /// not have all constant integer arguments.
686
687 /// List of virtual calls made by this function using (respectively)
688 /// llvm.assume(llvm.type.test) or llvm.type.checked.load intrinsics with
689 /// all constant integer arguments.
690 std::vector<ConstVCall> TypeTestAssumeConstVCalls,
692 };
693
694 /// Flags specific to function summaries.
695 struct FFlags {
696 // Function attribute flags. Used to track if a function accesses memory,
697 // recurses or aliases.
698 unsigned ReadNone : 1;
699 unsigned ReadOnly : 1;
700 unsigned NoRecurse : 1;
701 unsigned ReturnDoesNotAlias : 1;
702
703 // Indicate if the global value cannot be inlined.
704 unsigned NoInline : 1;
705 // Indicate if function should be always inlined.
706 unsigned AlwaysInline : 1;
707 // Indicate if function never raises an exception. Can be modified during
708 // thinlink function attribute propagation
709 unsigned NoUnwind : 1;
710 // Indicate if function contains instructions that mayThrow
711 unsigned MayThrow : 1;
712
713 // If there are calls to unknown targets (e.g. indirect)
714 unsigned HasUnknownCall : 1;
715
716 // Indicate if a function must be an unreachable function.
717 //
718 // This bit is sufficient but not necessary;
719 // if this bit is on, the function must be regarded as unreachable;
720 // if this bit is off, the function might be reachable or unreachable.
721 unsigned MustBeUnreachable : 1;
722
724 this->ReadNone &= RHS.ReadNone;
725 this->ReadOnly &= RHS.ReadOnly;
726 this->NoRecurse &= RHS.NoRecurse;
728 this->NoInline &= RHS.NoInline;
729 this->AlwaysInline &= RHS.AlwaysInline;
730 this->NoUnwind &= RHS.NoUnwind;
731 this->MayThrow &= RHS.MayThrow;
732 this->HasUnknownCall &= RHS.HasUnknownCall;
734 return *this;
735 }
736
737 bool anyFlagSet() {
738 return this->ReadNone | this->ReadOnly | this->NoRecurse |
739 this->ReturnDoesNotAlias | this->NoInline | this->AlwaysInline |
740 this->NoUnwind | this->MayThrow | this->HasUnknownCall |
741 this->MustBeUnreachable;
742 }
743
744 operator std::string() {
745 std::string Output;
746 raw_string_ostream OS(Output);
747 OS << "funcFlags: (";
748 OS << "readNone: " << this->ReadNone;
749 OS << ", readOnly: " << this->ReadOnly;
750 OS << ", noRecurse: " << this->NoRecurse;
751 OS << ", returnDoesNotAlias: " << this->ReturnDoesNotAlias;
752 OS << ", noInline: " << this->NoInline;
753 OS << ", alwaysInline: " << this->AlwaysInline;
754 OS << ", noUnwind: " << this->NoUnwind;
755 OS << ", mayThrow: " << this->MayThrow;
756 OS << ", hasUnknownCall: " << this->HasUnknownCall;
757 OS << ", mustBeUnreachable: " << this->MustBeUnreachable;
758 OS << ")";
759 return OS.str();
760 }
761 };
762
763 /// Describes the uses of a parameter by the function.
764 struct ParamAccess {
765 static constexpr uint32_t RangeWidth = 64;
766
767 /// Describes the use of a value in a call instruction, specifying the
768 /// call's target, the value's parameter number, and the possible range of
769 /// offsets from the beginning of the value that are passed.
770 struct Call {
773 ConstantRange Offsets{/*BitWidth=*/RangeWidth, /*isFullSet=*/true};
774
775 Call() = default;
778 };
779
781 /// The range contains byte offsets from the parameter pointer which
782 /// accessed by the function. In the per-module summary, it only includes
783 /// accesses made by the function instructions. In the combined summary, it
784 /// also includes accesses by nested function calls.
785 ConstantRange Use{/*BitWidth=*/RangeWidth, /*isFullSet=*/true};
786 /// In the per-module summary, it summarizes the byte offset applied to each
787 /// pointer parameter before passing to each corresponding callee.
788 /// In the combined summary, it's empty and information is propagated by
789 /// inter-procedural analysis and applied to the Use field.
790 std::vector<Call> Calls;
791
792 ParamAccess() = default;
794 : ParamNo(ParamNo), Use(Use) {}
795 };
796
797 /// Create an empty FunctionSummary (with specified call edges).
798 /// Used to represent external nodes and the dummy root node.
799 static FunctionSummary
800 makeDummyFunctionSummary(std::vector<FunctionSummary::EdgeTy> Edges) {
801 return FunctionSummary(
805 /*NotEligibleToImport=*/true, /*Live=*/true, /*IsLocal=*/false,
806 /*CanAutoHide=*/false),
807 /*NumInsts=*/0, FunctionSummary::FFlags{}, /*EntryCount=*/0,
808 std::vector<ValueInfo>(), std::move(Edges),
809 std::vector<GlobalValue::GUID>(),
810 std::vector<FunctionSummary::VFuncId>(),
811 std::vector<FunctionSummary::VFuncId>(),
812 std::vector<FunctionSummary::ConstVCall>(),
813 std::vector<FunctionSummary::ConstVCall>(),
814 std::vector<FunctionSummary::ParamAccess>(),
815 std::vector<CallsiteInfo>(), std::vector<AllocInfo>());
816 }
817
818 /// A dummy node to reference external functions that aren't in the index
820
821private:
822 /// Number of instructions (ignoring debug instructions, e.g.) computed
823 /// during the initial compile step when the summary index is first built.
824 unsigned InstCount;
825
826 /// Function summary specific flags.
827 FFlags FunFlags;
828
829 /// The synthesized entry count of the function.
830 /// This is only populated during ThinLink phase and remains unused while
831 /// generating per-module summaries.
832 uint64_t EntryCount = 0;
833
834 /// List of <CalleeValueInfo, CalleeInfo> call edge pairs from this function.
835 std::vector<EdgeTy> CallGraphEdgeList;
836
837 std::unique_ptr<TypeIdInfo> TIdInfo;
838
839 /// Uses for every parameter to this function.
840 using ParamAccessesTy = std::vector<ParamAccess>;
841 std::unique_ptr<ParamAccessesTy> ParamAccesses;
842
843 /// Optional list of memprof callsite metadata summaries. The correspondence
844 /// between the callsite summary and the callsites in the function is implied
845 /// by the order in the vector (and can be validated by comparing the stack
846 /// ids in the CallsiteInfo to those in the instruction callsite metadata).
847 /// As a memory savings optimization, we only create these for the prevailing
848 /// copy of a symbol when creating the combined index during LTO.
849 using CallsitesTy = std::vector<CallsiteInfo>;
850 std::unique_ptr<CallsitesTy> Callsites;
851
852 /// Optional list of allocation memprof metadata summaries. The correspondence
853 /// between the alloc memprof summary and the allocation callsites in the
854 /// function is implied by the order in the vector (and can be validated by
855 /// comparing the stack ids in the AllocInfo to those in the instruction
856 /// memprof metadata).
857 /// As a memory savings optimization, we only create these for the prevailing
858 /// copy of a symbol when creating the combined index during LTO.
859 using AllocsTy = std::vector<AllocInfo>;
860 std::unique_ptr<AllocsTy> Allocs;
861
862public:
863 FunctionSummary(GVFlags Flags, unsigned NumInsts, FFlags FunFlags,
864 uint64_t EntryCount, std::vector<ValueInfo> Refs,
865 std::vector<EdgeTy> CGEdges,
866 std::vector<GlobalValue::GUID> TypeTests,
867 std::vector<VFuncId> TypeTestAssumeVCalls,
868 std::vector<VFuncId> TypeCheckedLoadVCalls,
869 std::vector<ConstVCall> TypeTestAssumeConstVCalls,
870 std::vector<ConstVCall> TypeCheckedLoadConstVCalls,
871 std::vector<ParamAccess> Params, CallsitesTy CallsiteList,
872 AllocsTy AllocList)
873 : GlobalValueSummary(FunctionKind, Flags, std::move(Refs)),
874 InstCount(NumInsts), FunFlags(FunFlags), EntryCount(EntryCount),
875 CallGraphEdgeList(std::move(CGEdges)) {
876 if (!TypeTests.empty() || !TypeTestAssumeVCalls.empty() ||
877 !TypeCheckedLoadVCalls.empty() || !TypeTestAssumeConstVCalls.empty() ||
878 !TypeCheckedLoadConstVCalls.empty())
879 TIdInfo = std::make_unique<TypeIdInfo>(
880 TypeIdInfo{std::move(TypeTests), std::move(TypeTestAssumeVCalls),
881 std::move(TypeCheckedLoadVCalls),
882 std::move(TypeTestAssumeConstVCalls),
883 std::move(TypeCheckedLoadConstVCalls)});
884 if (!Params.empty())
885 ParamAccesses = std::make_unique<ParamAccessesTy>(std::move(Params));
886 if (!CallsiteList.empty())
887 Callsites = std::make_unique<CallsitesTy>(std::move(CallsiteList));
888 if (!AllocList.empty())
889 Allocs = std::make_unique<AllocsTy>(std::move(AllocList));
890 }
891 // Gets the number of readonly and writeonly refs in RefEdgeList
892 std::pair<unsigned, unsigned> specialRefCounts() const;
893
894 /// Check if this is a function summary.
895 static bool classof(const GlobalValueSummary *GVS) {
896 return GVS->getSummaryKind() == FunctionKind;
897 }
898
899 /// Get function summary flags.
900 FFlags fflags() const { return FunFlags; }
901
902 void setNoRecurse() { FunFlags.NoRecurse = true; }
903
904 void setNoUnwind() { FunFlags.NoUnwind = true; }
905
906 /// Get the instruction count recorded for this function.
907 unsigned instCount() const { return InstCount; }
908
909 /// Get the synthetic entry count for this function.
910 uint64_t entryCount() const { return EntryCount; }
911
912 /// Set the synthetic entry count for this function.
913 void setEntryCount(uint64_t EC) { EntryCount = EC; }
914
915 /// Return the list of <CalleeValueInfo, CalleeInfo> pairs.
916 ArrayRef<EdgeTy> calls() const { return CallGraphEdgeList; }
917
918 std::vector<EdgeTy> &mutableCalls() { return CallGraphEdgeList; }
919
920 void addCall(EdgeTy E) { CallGraphEdgeList.push_back(E); }
921
922 /// Returns the list of type identifiers used by this function in
923 /// llvm.type.test intrinsics other than by an llvm.assume intrinsic,
924 /// represented as GUIDs.
926 if (TIdInfo)
927 return TIdInfo->TypeTests;
928 return {};
929 }
930
931 /// Returns the list of virtual calls made by this function using
932 /// llvm.assume(llvm.type.test) intrinsics that do not have all constant
933 /// integer arguments.
935 if (TIdInfo)
936 return TIdInfo->TypeTestAssumeVCalls;
937 return {};
938 }
939
940 /// Returns the list of virtual calls made by this function using
941 /// llvm.type.checked.load intrinsics that do not have all constant integer
942 /// arguments.
944 if (TIdInfo)
945 return TIdInfo->TypeCheckedLoadVCalls;
946 return {};
947 }
948
949 /// Returns the list of virtual calls made by this function using
950 /// llvm.assume(llvm.type.test) intrinsics with all constant integer
951 /// arguments.
953 if (TIdInfo)
954 return TIdInfo->TypeTestAssumeConstVCalls;
955 return {};
956 }
957
958 /// Returns the list of virtual calls made by this function using
959 /// llvm.type.checked.load intrinsics with all constant integer arguments.
961 if (TIdInfo)
962 return TIdInfo->TypeCheckedLoadConstVCalls;
963 return {};
964 }
965
966 /// Returns the list of known uses of pointer parameters.
968 if (ParamAccesses)
969 return *ParamAccesses;
970 return {};
971 }
972
973 /// Sets the list of known uses of pointer parameters.
974 void setParamAccesses(std::vector<ParamAccess> NewParams) {
975 if (NewParams.empty())
976 ParamAccesses.reset();
977 else if (ParamAccesses)
978 *ParamAccesses = std::move(NewParams);
979 else
980 ParamAccesses = std::make_unique<ParamAccessesTy>(std::move(NewParams));
981 }
982
983 /// Add a type test to the summary. This is used by WholeProgramDevirt if we
984 /// were unable to devirtualize a checked call.
986 if (!TIdInfo)
987 TIdInfo = std::make_unique<TypeIdInfo>();
988 TIdInfo->TypeTests.push_back(Guid);
989 }
990
991 const TypeIdInfo *getTypeIdInfo() const { return TIdInfo.get(); };
992
994 if (Callsites)
995 return *Callsites;
996 return {};
997 }
998
999 CallsitesTy &mutableCallsites() {
1000 assert(Callsites);
1001 return *Callsites;
1002 }
1003
1005 if (Allocs)
1006 return *Allocs;
1007 return {};
1008 }
1009
1010 AllocsTy &mutableAllocs() {
1011 assert(Allocs);
1012 return *Allocs;
1013 }
1014
1015 friend struct GraphTraits<ValueInfo>;
1016};
1017
1018template <> struct DenseMapInfo<FunctionSummary::VFuncId> {
1019 static FunctionSummary::VFuncId getEmptyKey() { return {0, uint64_t(-1)}; }
1020
1022 return {0, uint64_t(-2)};
1023 }
1024
1026 return L.GUID == R.GUID && L.Offset == R.Offset;
1027 }
1028
1029 static unsigned getHashValue(FunctionSummary::VFuncId I) { return I.GUID; }
1030};
1031
1032template <> struct DenseMapInfo<FunctionSummary::ConstVCall> {
1034 return {{0, uint64_t(-1)}, {}};
1035 }
1036
1038 return {{0, uint64_t(-2)}, {}};
1039 }
1040
1043 return DenseMapInfo<FunctionSummary::VFuncId>::isEqual(L.VFunc, R.VFunc) &&
1044 L.Args == R.Args;
1045 }
1046
1048 return I.VFunc.GUID;
1049 }
1050};
1051
1052/// The ValueInfo and offset for a function within a vtable definition
1053/// initializer array.
1056 : FuncVI(VI), VTableOffset(Offset) {}
1057
1060};
1061/// List of functions referenced by a particular vtable definition.
1062using VTableFuncList = std::vector<VirtFuncOffset>;
1063
1064/// Global variable summary information to aid decisions and
1065/// implementation of importing.
1066///
1067/// Global variable summary has two extra flag, telling if it is
1068/// readonly or writeonly. Both readonly and writeonly variables
1069/// can be optimized in the backed: readonly variables can be
1070/// const-folded, while writeonly vars can be completely eliminated
1071/// together with corresponding stores. We let both things happen
1072/// by means of internalizing such variables after ThinLTO import.
1074private:
1075 /// For vtable definitions this holds the list of functions and
1076 /// their corresponding offsets within the initializer array.
1077 std::unique_ptr<VTableFuncList> VTableFuncs;
1078
1079public:
1080 struct GVarFlags {
1081 GVarFlags(bool ReadOnly, bool WriteOnly, bool Constant,
1083 : MaybeReadOnly(ReadOnly), MaybeWriteOnly(WriteOnly),
1085
1086 // If true indicates that this global variable might be accessed
1087 // purely by non-volatile load instructions. This in turn means
1088 // it can be internalized in source and destination modules during
1089 // thin LTO import because it neither modified nor its address
1090 // is taken.
1091 unsigned MaybeReadOnly : 1;
1092 // If true indicates that variable is possibly only written to, so
1093 // its value isn't loaded and its address isn't taken anywhere.
1094 // False, when 'Constant' attribute is set.
1095 unsigned MaybeWriteOnly : 1;
1096 // Indicates that value is a compile-time constant. Global variable
1097 // can be 'Constant' while not being 'ReadOnly' on several occasions:
1098 // - it is volatile, (e.g mapped device address)
1099 // - its address is taken, meaning that unlike 'ReadOnly' vars we can't
1100 // internalize it.
1101 // Constant variables are always imported thus giving compiler an
1102 // opportunity to make some extra optimizations. Readonly constants
1103 // are also internalized.
1104 unsigned Constant : 1;
1105 // Set from metadata on vtable definitions during the module summary
1106 // analysis.
1107 unsigned VCallVisibility : 2;
1109
1111 std::vector<ValueInfo> Refs)
1112 : GlobalValueSummary(GlobalVarKind, Flags, std::move(Refs)),
1113 VarFlags(VarFlags) {}
1114
1115 /// Check if this is a global variable summary.
1116 static bool classof(const GlobalValueSummary *GVS) {
1117 return GVS->getSummaryKind() == GlobalVarKind;
1118 }
1119
1120 GVarFlags varflags() const { return VarFlags; }
1121 void setReadOnly(bool RO) { VarFlags.MaybeReadOnly = RO; }
1122 void setWriteOnly(bool WO) { VarFlags.MaybeWriteOnly = WO; }
1123 bool maybeReadOnly() const { return VarFlags.MaybeReadOnly; }
1124 bool maybeWriteOnly() const { return VarFlags.MaybeWriteOnly; }
1125 bool isConstant() const { return VarFlags.Constant; }
1128 }
1131 }
1132
1134 assert(!VTableFuncs);
1135 VTableFuncs = std::make_unique<VTableFuncList>(std::move(Funcs));
1136 }
1137
1139 if (VTableFuncs)
1140 return *VTableFuncs;
1141 return {};
1142 }
1143};
1144
1146 /// Specifies which kind of type check we should emit for this byte array.
1147 /// See http://clang.llvm.org/docs/ControlFlowIntegrityDesign.html for full
1148 /// details on each kind of check; the enumerators are described with
1149 /// reference to that document.
1150 enum Kind {
1151 Unsat, ///< Unsatisfiable type (i.e. no global has this type metadata)
1152 ByteArray, ///< Test a byte array (first example)
1153 Inline, ///< Inlined bit vector ("Short Inline Bit Vectors")
1154 Single, ///< Single element (last example in "Short Inline Bit Vectors")
1155 AllOnes, ///< All-ones bit vector ("Eliminating Bit Vector Checks for
1156 /// All-Ones Bit Vectors")
1157 Unknown, ///< Unknown (analysis not performed, don't lower)
1159
1160 /// Range of size-1 expressed as a bit width. For example, if the size is in
1161 /// range [1,256], this number will be 8. This helps generate the most compact
1162 /// instruction sequences.
1163 unsigned SizeM1BitWidth = 0;
1164
1165 // The following fields are only used if the target does not support the use
1166 // of absolute symbols to store constants. Their meanings are the same as the
1167 // corresponding fields in LowerTypeTestsModule::TypeIdLowering in
1168 // LowerTypeTests.cpp.
1169
1172 uint8_t BitMask = 0;
1174};
1175
1177 enum Kind {
1178 Indir, ///< Just do a regular virtual call
1179 SingleImpl, ///< Single implementation devirtualization
1180 BranchFunnel, ///< When retpoline mitigation is enabled, use a branch funnel
1181 ///< that is defined in the merged module. Otherwise same as
1182 ///< Indir.
1184
1185 std::string SingleImplName;
1186
1187 struct ByArg {
1188 enum Kind {
1189 Indir, ///< Just do a regular virtual call
1190 UniformRetVal, ///< Uniform return value optimization
1191 UniqueRetVal, ///< Unique return value optimization
1192 VirtualConstProp, ///< Virtual constant propagation
1194
1195 /// Additional information for the resolution:
1196 /// - UniformRetVal: the uniform return value.
1197 /// - UniqueRetVal: the return value associated with the unique vtable (0 or
1198 /// 1).
1200
1201 // The following fields are only used if the target does not support the use
1202 // of absolute symbols to store constants.
1203
1206 };
1207
1208 /// Resolutions for calls with all constant integer arguments (excluding the
1209 /// first argument, "this"), where the key is the argument vector.
1210 std::map<std::vector<uint64_t>, ByArg> ResByArg;
1211};
1212
1215
1216 /// Mapping from byte offset to whole-program devirt resolution for that
1217 /// (typeid, byte offset) pair.
1218 std::map<uint64_t, WholeProgramDevirtResolution> WPDRes;
1219};
1220
1221/// 160 bits SHA1
1222using ModuleHash = std::array<uint32_t, 5>;
1223
1224/// Type used for iterating through the global value summary map.
1225using const_gvsummary_iterator = GlobalValueSummaryMapTy::const_iterator;
1226using gvsummary_iterator = GlobalValueSummaryMapTy::iterator;
1227
1228/// String table to hold/own module path strings, as well as a hash
1229/// of the module. The StringMap makes a copy of and owns inserted strings.
1231
1232/// Map of global value GUID to its summary, used to identify values defined in
1233/// a particular module, and provide efficient access to their summary.
1235
1236/// Map of a type GUID to type id string and summary (multimap used
1237/// in case of GUID conflicts).
1239 std::multimap<GlobalValue::GUID, std::pair<std::string, TypeIdSummary>>;
1240
1241/// The following data structures summarize type metadata information.
1242/// For type metadata overview see https://llvm.org/docs/TypeMetadata.html.
1243/// Each type metadata includes both the type identifier and the offset of
1244/// the address point of the type (the address held by objects of that type
1245/// which may not be the beginning of the virtual table). Vtable definitions
1246/// are decorated with type metadata for the types they are compatible with.
1247///
1248/// Holds information about vtable definitions decorated with type metadata:
1249/// the vtable definition value and its address point offset in a type
1250/// identifier metadata it is decorated (compatible) with.
1254
1257};
1258/// List of vtable definitions decorated by a particular type identifier,
1259/// and their corresponding offsets in that type identifier's metadata.
1260/// Note that each type identifier may be compatible with multiple vtables, due
1261/// to inheritance, which is why this is a vector.
1262using TypeIdCompatibleVtableInfo = std::vector<TypeIdOffsetVtableInfo>;
1263
1264/// Class to hold module path string table and global value map,
1265/// and encapsulate methods for operating on them.
1267private:
1268 /// Map from value name to list of summary instances for values of that
1269 /// name (may be duplicates in the COMDAT case, e.g.).
1270 GlobalValueSummaryMapTy GlobalValueMap;
1271
1272 /// Holds strings for combined index, mapping to the corresponding module ID.
1273 ModulePathStringTableTy ModulePathStringTable;
1274
1275 /// Mapping from type identifier GUIDs to type identifier and its summary
1276 /// information. Produced by thin link.
1277 TypeIdSummaryMapTy TypeIdMap;
1278
1279 /// Mapping from type identifier to information about vtables decorated
1280 /// with that type identifier's metadata. Produced by per module summary
1281 /// analysis and consumed by thin link. For more information, see description
1282 /// above where TypeIdCompatibleVtableInfo is defined.
1283 std::map<std::string, TypeIdCompatibleVtableInfo, std::less<>>
1284 TypeIdCompatibleVtableMap;
1285
1286 /// Mapping from original ID to GUID. If original ID can map to multiple
1287 /// GUIDs, it will be mapped to 0.
1288 std::map<GlobalValue::GUID, GlobalValue::GUID> OidGuidMap;
1289
1290 /// Indicates that summary-based GlobalValue GC has run, and values with
1291 /// GVFlags::Live==false are really dead. Otherwise, all values must be
1292 /// considered live.
1293 bool WithGlobalValueDeadStripping = false;
1294
1295 /// Indicates that summary-based attribute propagation has run and
1296 /// GVarFlags::MaybeReadonly / GVarFlags::MaybeWriteonly are really
1297 /// read/write only.
1298 bool WithAttributePropagation = false;
1299
1300 /// Indicates that summary-based DSOLocal propagation has run and the flag in
1301 /// every summary of a GV is synchronized.
1302 bool WithDSOLocalPropagation = false;
1303
1304 /// Indicates that we have whole program visibility.
1305 bool WithWholeProgramVisibility = false;
1306
1307 /// Indicates that summary-based synthetic entry count propagation has run
1308 bool HasSyntheticEntryCounts = false;
1309
1310 /// Indicates that we linked with allocator supporting hot/cold new operators.
1311 bool WithSupportsHotColdNew = false;
1312
1313 /// Indicates that distributed backend should skip compilation of the
1314 /// module. Flag is suppose to be set by distributed ThinLTO indexing
1315 /// when it detected that the module is not needed during the final
1316 /// linking. As result distributed backend should just output a minimal
1317 /// valid object file.
1318 bool SkipModuleByDistributedBackend = false;
1319
1320 /// If true then we're performing analysis of IR module, or parsing along with
1321 /// the IR from assembly. The value of 'false' means we're reading summary
1322 /// from BC or YAML source. Affects the type of value stored in NameOrGV
1323 /// union.
1324 bool HaveGVs;
1325
1326 // True if the index was created for a module compiled with -fsplit-lto-unit.
1327 bool EnableSplitLTOUnit;
1328
1329 // True if the index was created for a module compiled with -funified-lto
1330 bool UnifiedLTO;
1331
1332 // True if some of the modules were compiled with -fsplit-lto-unit and
1333 // some were not. Set when the combined index is created during the thin link.
1334 bool PartiallySplitLTOUnits = false;
1335
1336 /// True if some of the FunctionSummary contains a ParamAccess.
1337 bool HasParamAccess = false;
1338
1339 std::set<std::string> CfiFunctionDefs;
1340 std::set<std::string> CfiFunctionDecls;
1341
1342 // Used in cases where we want to record the name of a global, but
1343 // don't have the string owned elsewhere (e.g. the Strtab on a module).
1344 BumpPtrAllocator Alloc;
1345 StringSaver Saver;
1346
1347 // The total number of basic blocks in the module in the per-module summary or
1348 // the total number of basic blocks in the LTO unit in the combined index.
1349 // FIXME: Putting this in the distributed ThinLTO index files breaks LTO
1350 // backend caching on any BB change to any linked file. It is currently not
1351 // used except in the case of a SamplePGO partial profile, and should be
1352 // reevaluated/redesigned to allow more effective incremental builds in that
1353 // case.
1354 uint64_t BlockCount;
1355
1356 // List of unique stack ids (hashes). We use a 4B index of the id in the
1357 // stack id lists on the alloc and callsite summaries for memory savings,
1358 // since the number of unique ids is in practice much smaller than the
1359 // number of stack id references in the summaries.
1360 std::vector<uint64_t> StackIds;
1361
1362 // Temporary map while building StackIds list. Clear when index is completely
1363 // built via releaseTemporaryMemory.
1364 std::map<uint64_t, unsigned> StackIdToIndex;
1365
1366 // YAML I/O support.
1368
1369 GlobalValueSummaryMapTy::value_type *
1370 getOrInsertValuePtr(GlobalValue::GUID GUID) {
1371 return &*GlobalValueMap.emplace(GUID, GlobalValueSummaryInfo(HaveGVs))
1372 .first;
1373 }
1374
1375public:
1376 // See HaveGVs variable comment.
1377 ModuleSummaryIndex(bool HaveGVs, bool EnableSplitLTOUnit = false,
1378 bool UnifiedLTO = false)
1379 : HaveGVs(HaveGVs), EnableSplitLTOUnit(EnableSplitLTOUnit),
1380 UnifiedLTO(UnifiedLTO), Saver(Alloc), BlockCount(0) {}
1381
1382 // Current version for the module summary in bitcode files.
1383 // The BitcodeSummaryVersion should be bumped whenever we introduce changes
1384 // in the way some record are interpreted, like flags for instance.
1385 // Note that incrementing this may require changes in both BitcodeReader.cpp
1386 // and BitcodeWriter.cpp.
1387 static constexpr uint64_t BitcodeSummaryVersion = 9;
1388
1389 // Regular LTO module name for ASM writer
1390 static constexpr const char *getRegularLTOModuleName() {
1391 return "[Regular LTO]";
1392 }
1393
1394 bool haveGVs() const { return HaveGVs; }
1395
1396 uint64_t getFlags() const;
1397 void setFlags(uint64_t Flags);
1398
1399 uint64_t getBlockCount() const { return BlockCount; }
1400 void addBlockCount(uint64_t C) { BlockCount += C; }
1401 void setBlockCount(uint64_t C) { BlockCount = C; }
1402
1403 gvsummary_iterator begin() { return GlobalValueMap.begin(); }
1404 const_gvsummary_iterator begin() const { return GlobalValueMap.begin(); }
1405 gvsummary_iterator end() { return GlobalValueMap.end(); }
1406 const_gvsummary_iterator end() const { return GlobalValueMap.end(); }
1407 size_t size() const { return GlobalValueMap.size(); }
1408
1409 const std::vector<uint64_t> &stackIds() const { return StackIds; }
1410
1411 unsigned addOrGetStackIdIndex(uint64_t StackId) {
1412 auto Inserted = StackIdToIndex.insert({StackId, StackIds.size()});
1413 if (Inserted.second)
1414 StackIds.push_back(StackId);
1415 return Inserted.first->second;
1416 }
1417
1419 assert(StackIds.size() > Index);
1420 return StackIds[Index];
1421 }
1422
1423 // Facility to release memory from data structures only needed during index
1424 // construction (including while building combined index). Currently this only
1425 // releases the temporary map used while constructing a correspondence between
1426 // stack ids and their index in the StackIds vector. Mostly impactful when
1427 // building a large combined index.
1429 assert(StackIdToIndex.size() == StackIds.size());
1430 StackIdToIndex.clear();
1431 StackIds.shrink_to_fit();
1432 }
1433
1434 /// Convenience function for doing a DFS on a ValueInfo. Marks the function in
1435 /// the FunctionHasParent map.
1437 std::map<ValueInfo, bool> &FunctionHasParent) {
1438 if (!V.getSummaryList().size())
1439 return; // skip external functions that don't have summaries
1440
1441 // Mark discovered if we haven't yet
1442 auto S = FunctionHasParent.emplace(V, false);
1443
1444 // Stop if we've already discovered this node
1445 if (!S.second)
1446 return;
1447
1449 dyn_cast<FunctionSummary>(V.getSummaryList().front().get());
1450 assert(F != nullptr && "Expected FunctionSummary node");
1451
1452 for (const auto &C : F->calls()) {
1453 // Insert node if necessary
1454 auto S = FunctionHasParent.emplace(C.first, true);
1455
1456 // Skip nodes that we're sure have parents
1457 if (!S.second && S.first->second)
1458 continue;
1459
1460 if (S.second)
1461 discoverNodes(C.first, FunctionHasParent);
1462 else
1463 S.first->second = true;
1464 }
1465 }
1466
1467 // Calculate the callgraph root
1469 // Functions that have a parent will be marked in FunctionHasParent pair.
1470 // Once we've marked all functions, the functions in the map that are false
1471 // have no parent (so they're the roots)
1472 std::map<ValueInfo, bool> FunctionHasParent;
1473
1474 for (auto &S : *this) {
1475 // Skip external functions
1476 if (!S.second.SummaryList.size() ||
1477 !isa<FunctionSummary>(S.second.SummaryList.front().get()))
1478 continue;
1479 discoverNodes(ValueInfo(HaveGVs, &S), FunctionHasParent);
1480 }
1481
1482 std::vector<FunctionSummary::EdgeTy> Edges;
1483 // create edges to all roots in the Index
1484 for (auto &P : FunctionHasParent) {
1485 if (P.second)
1486 continue; // skip over non-root nodes
1487 Edges.push_back(std::make_pair(P.first, CalleeInfo{}));
1488 }
1489 if (Edges.empty()) {
1490 // Failed to find root - return an empty node
1492 }
1493 auto CallGraphRoot = FunctionSummary::makeDummyFunctionSummary(Edges);
1494 return CallGraphRoot;
1495 }
1496
1498 return WithGlobalValueDeadStripping;
1499 }
1501 WithGlobalValueDeadStripping = true;
1502 }
1503
1504 bool withAttributePropagation() const { return WithAttributePropagation; }
1506 WithAttributePropagation = true;
1507 }
1508
1509 bool withDSOLocalPropagation() const { return WithDSOLocalPropagation; }
1510 void setWithDSOLocalPropagation() { WithDSOLocalPropagation = true; }
1511
1512 bool withWholeProgramVisibility() const { return WithWholeProgramVisibility; }
1513 void setWithWholeProgramVisibility() { WithWholeProgramVisibility = true; }
1514
1515 bool isReadOnly(const GlobalVarSummary *GVS) const {
1516 return WithAttributePropagation && GVS->maybeReadOnly();
1517 }
1518 bool isWriteOnly(const GlobalVarSummary *GVS) const {
1519 return WithAttributePropagation && GVS->maybeWriteOnly();
1520 }
1521
1522 bool hasSyntheticEntryCounts() const { return HasSyntheticEntryCounts; }
1523 void setHasSyntheticEntryCounts() { HasSyntheticEntryCounts = true; }
1524
1525 bool withSupportsHotColdNew() const { return WithSupportsHotColdNew; }
1526 void setWithSupportsHotColdNew() { WithSupportsHotColdNew = true; }
1527
1529 return SkipModuleByDistributedBackend;
1530 }
1532 SkipModuleByDistributedBackend = true;
1533 }
1534
1535 bool enableSplitLTOUnit() const { return EnableSplitLTOUnit; }
1536 void setEnableSplitLTOUnit() { EnableSplitLTOUnit = true; }
1537
1538 bool hasUnifiedLTO() const { return UnifiedLTO; }
1539 void setUnifiedLTO() { UnifiedLTO = true; }
1540
1541 bool partiallySplitLTOUnits() const { return PartiallySplitLTOUnits; }
1542 void setPartiallySplitLTOUnits() { PartiallySplitLTOUnits = true; }
1543
1544 bool hasParamAccess() const { return HasParamAccess; }
1545
1546 bool isGlobalValueLive(const GlobalValueSummary *GVS) const {
1547 return !WithGlobalValueDeadStripping || GVS->isLive();
1548 }
1549 bool isGUIDLive(GlobalValue::GUID GUID) const;
1550
1551 /// Return a ValueInfo for the index value_type (convenient when iterating
1552 /// index).
1553 ValueInfo getValueInfo(const GlobalValueSummaryMapTy::value_type &R) const {
1554 return ValueInfo(HaveGVs, &R);
1555 }
1556
1557 /// Return a ValueInfo for GUID if it exists, otherwise return ValueInfo().
1559 auto I = GlobalValueMap.find(GUID);
1560 return ValueInfo(HaveGVs, I == GlobalValueMap.end() ? nullptr : &*I);
1561 }
1562
1563 /// Return a ValueInfo for \p GUID.
1565 return ValueInfo(HaveGVs, getOrInsertValuePtr(GUID));
1566 }
1567
1568 // Save a string in the Index. Use before passing Name to
1569 // getOrInsertValueInfo when the string isn't owned elsewhere (e.g. on the
1570 // module's Strtab).
1572
1573 /// Return a ValueInfo for \p GUID setting value \p Name.
1575 assert(!HaveGVs);
1576 auto VP = getOrInsertValuePtr(GUID);
1577 VP->second.U.Name = Name;
1578 return ValueInfo(HaveGVs, VP);
1579 }
1580
1581 /// Return a ValueInfo for \p GV and mark it as belonging to GV.
1583 assert(HaveGVs);
1584 auto VP = getOrInsertValuePtr(GV->getGUID());
1585 VP->second.U.GV = GV;
1586 return ValueInfo(HaveGVs, VP);
1587 }
1588
1589 /// Return the GUID for \p OriginalId in the OidGuidMap.
1591 const auto I = OidGuidMap.find(OriginalID);
1592 return I == OidGuidMap.end() ? 0 : I->second;
1593 }
1594
1595 std::set<std::string> &cfiFunctionDefs() { return CfiFunctionDefs; }
1596 const std::set<std::string> &cfiFunctionDefs() const { return CfiFunctionDefs; }
1597
1598 std::set<std::string> &cfiFunctionDecls() { return CfiFunctionDecls; }
1599 const std::set<std::string> &cfiFunctionDecls() const { return CfiFunctionDecls; }
1600
1601 /// Add a global value summary for a value.
1603 std::unique_ptr<GlobalValueSummary> Summary) {
1604 addGlobalValueSummary(getOrInsertValueInfo(&GV), std::move(Summary));
1605 }
1606
1607 /// Add a global value summary for a value of the given name.
1609 std::unique_ptr<GlobalValueSummary> Summary) {
1611 std::move(Summary));
1612 }
1613
1614 /// Add a global value summary for the given ValueInfo.
1616 std::unique_ptr<GlobalValueSummary> Summary) {
1617 if (const FunctionSummary *FS = dyn_cast<FunctionSummary>(Summary.get()))
1618 HasParamAccess |= !FS->paramAccesses().empty();
1619 addOriginalName(VI.getGUID(), Summary->getOriginalName());
1620 // Here we have a notionally const VI, but the value it points to is owned
1621 // by the non-const *this.
1622 const_cast<GlobalValueSummaryMapTy::value_type *>(VI.getRef())
1623 ->second.SummaryList.push_back(std::move(Summary));
1624 }
1625
1626 /// Add an original name for the value of the given GUID.
1628 GlobalValue::GUID OrigGUID) {
1629 if (OrigGUID == 0 || ValueGUID == OrigGUID)
1630 return;
1631 if (OidGuidMap.count(OrigGUID) && OidGuidMap[OrigGUID] != ValueGUID)
1632 OidGuidMap[OrigGUID] = 0;
1633 else
1634 OidGuidMap[OrigGUID] = ValueGUID;
1635 }
1636
1637 /// Find the summary for ValueInfo \p VI in module \p ModuleId, or nullptr if
1638 /// not found.
1640 auto SummaryList = VI.getSummaryList();
1641 auto Summary =
1642 llvm::find_if(SummaryList,
1643 [&](const std::unique_ptr<GlobalValueSummary> &Summary) {
1644 return Summary->modulePath() == ModuleId;
1645 });
1646 if (Summary == SummaryList.end())
1647 return nullptr;
1648 return Summary->get();
1649 }
1650
1651 /// Find the summary for global \p GUID in module \p ModuleId, or nullptr if
1652 /// not found.
1654 StringRef ModuleId) const {
1655 auto CalleeInfo = getValueInfo(ValueGUID);
1656 if (!CalleeInfo)
1657 return nullptr; // This function does not have a summary
1658 return findSummaryInModule(CalleeInfo, ModuleId);
1659 }
1660
1661 /// Returns the first GlobalValueSummary for \p GV, asserting that there
1662 /// is only one if \p PerModuleIndex.
1664 bool PerModuleIndex = true) const {
1665 assert(GV.hasName() && "Can't get GlobalValueSummary for GV with no name");
1666 return getGlobalValueSummary(GV.getGUID(), PerModuleIndex);
1667 }
1668
1669 /// Returns the first GlobalValueSummary for \p ValueGUID, asserting that
1670 /// there
1671 /// is only one if \p PerModuleIndex.
1673 bool PerModuleIndex = true) const;
1674
1675 /// Table of modules, containing module hash and id.
1677 return ModulePathStringTable;
1678 }
1679
1680 /// Table of modules, containing hash and id.
1681 StringMap<ModuleHash> &modulePaths() { return ModulePathStringTable; }
1682
1683 /// Get the module SHA1 hash recorded for the given module path.
1684 const ModuleHash &getModuleHash(const StringRef ModPath) const {
1685 auto It = ModulePathStringTable.find(ModPath);
1686 assert(It != ModulePathStringTable.end() && "Module not registered");
1687 return It->second;
1688 }
1689
1690 /// Convenience method for creating a promoted global name
1691 /// for the given value name of a local, and its original module's ID.
1692 static std::string getGlobalNameForLocal(StringRef Name, ModuleHash ModHash) {
1693 std::string Suffix = utostr((uint64_t(ModHash[0]) << 32) |
1694 ModHash[1]); // Take the first 64 bits
1695 return getGlobalNameForLocal(Name, Suffix);
1696 }
1697
1698 static std::string getGlobalNameForLocal(StringRef Name, StringRef Suffix) {
1699 SmallString<256> NewName(Name);
1700 NewName += ".llvm.";
1701 NewName += Suffix;
1702 return std::string(NewName.str());
1703 }
1704
1705 /// Helper to obtain the unpromoted name for a global value (or the original
1706 /// name if not promoted). Split off the rightmost ".llvm.${hash}" suffix,
1707 /// because it is possible in certain clients (not clang at the moment) for
1708 /// two rounds of ThinLTO optimization and therefore promotion to occur.
1710 std::pair<StringRef, StringRef> Pair = Name.rsplit(".llvm.");
1711 return Pair.first;
1712 }
1713
1715
1716 /// Add a new module with the given \p Hash, mapped to the given \p
1717 /// ModID, and return a reference to the module.
1719 return &*ModulePathStringTable.insert({ModPath, Hash}).first;
1720 }
1721
1722 /// Return module entry for module with the given \p ModPath.
1724 auto It = ModulePathStringTable.find(ModPath);
1725 assert(It != ModulePathStringTable.end() && "Module not registered");
1726 return &*It;
1727 }
1728
1729 /// Return module entry for module with the given \p ModPath.
1730 const ModuleInfo *getModule(StringRef ModPath) const {
1731 auto It = ModulePathStringTable.find(ModPath);
1732 assert(It != ModulePathStringTable.end() && "Module not registered");
1733 return &*It;
1734 }
1735
1736 /// Check if the given Module has any functions available for exporting
1737 /// in the index. We consider any module present in the ModulePathStringTable
1738 /// to have exported functions.
1739 bool hasExportedFunctions(const Module &M) const {
1740 return ModulePathStringTable.count(M.getModuleIdentifier());
1741 }
1742
1743 const TypeIdSummaryMapTy &typeIds() const { return TypeIdMap; }
1744
1745 /// Return an existing or new TypeIdSummary entry for \p TypeId.
1746 /// This accessor can mutate the map and therefore should not be used in
1747 /// the ThinLTO backends.
1749 auto TidIter = TypeIdMap.equal_range(GlobalValue::getGUID(TypeId));
1750 for (auto It = TidIter.first; It != TidIter.second; ++It)
1751 if (It->second.first == TypeId)
1752 return It->second.second;
1753 auto It = TypeIdMap.insert(
1754 {GlobalValue::getGUID(TypeId), {std::string(TypeId), TypeIdSummary()}});
1755 return It->second.second;
1756 }
1757
1758 /// This returns either a pointer to the type id summary (if present in the
1759 /// summary map) or null (if not present). This may be used when importing.
1761 auto TidIter = TypeIdMap.equal_range(GlobalValue::getGUID(TypeId));
1762 for (auto It = TidIter.first; It != TidIter.second; ++It)
1763 if (It->second.first == TypeId)
1764 return &It->second.second;
1765 return nullptr;
1766 }
1767
1769 return const_cast<TypeIdSummary *>(
1770 static_cast<const ModuleSummaryIndex *>(this)->getTypeIdSummary(
1771 TypeId));
1772 }
1773
1774 const auto &typeIdCompatibleVtableMap() const {
1775 return TypeIdCompatibleVtableMap;
1776 }
1777
1778 /// Return an existing or new TypeIdCompatibleVtableMap entry for \p TypeId.
1779 /// This accessor can mutate the map and therefore should not be used in
1780 /// the ThinLTO backends.
1783 return TypeIdCompatibleVtableMap[std::string(TypeId)];
1784 }
1785
1786 /// For the given \p TypeId, this returns the TypeIdCompatibleVtableMap
1787 /// entry if present in the summary map. This may be used when importing.
1788 std::optional<TypeIdCompatibleVtableInfo>
1790 auto I = TypeIdCompatibleVtableMap.find(TypeId);
1791 if (I == TypeIdCompatibleVtableMap.end())
1792 return std::nullopt;
1793 return I->second;
1794 }
1795
1796 /// Collect for the given module the list of functions it defines
1797 /// (GUID -> Summary).
1799 GVSummaryMapTy &GVSummaryMap) const;
1800
1801 /// Collect for each module the list of Summaries it defines (GUID ->
1802 /// Summary).
1803 template <class Map>
1804 void
1805 collectDefinedGVSummariesPerModule(Map &ModuleToDefinedGVSummaries) const {
1806 for (const auto &GlobalList : *this) {
1807 auto GUID = GlobalList.first;
1808 for (const auto &Summary : GlobalList.second.SummaryList) {
1809 ModuleToDefinedGVSummaries[Summary->modulePath()][GUID] = Summary.get();
1810 }
1811 }
1812 }
1813
1814 /// Print to an output stream.
1815 void print(raw_ostream &OS, bool IsForDebug = false) const;
1816
1817 /// Dump to stderr (for debugging).
1818 void dump() const;
1819
1820 /// Export summary to dot file for GraphViz.
1821 void
1823 const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols) const;
1824
1825 /// Print out strongly connected components for debugging.
1826 void dumpSCCs(raw_ostream &OS);
1827
1828 /// Do the access attribute and DSOLocal propagation in combined index.
1830
1831 /// Checks if we can import global variable from another module.
1832 bool canImportGlobalVar(const GlobalValueSummary *S, bool AnalyzeRefs) const;
1833};
1834
1835/// GraphTraits definition to build SCC for the index
1836template <> struct GraphTraits<ValueInfo> {
1839
1841 return P.first;
1842 }
1845 decltype(&valueInfoFromEdge)>;
1846
1847 using ChildEdgeIteratorType = std::vector<FunctionSummary::EdgeTy>::iterator;
1848
1849 static NodeRef getEntryNode(ValueInfo V) { return V; }
1850
1852 if (!N.getSummaryList().size()) // handle external function
1853 return ChildIteratorType(
1854 FunctionSummary::ExternalNode.CallGraphEdgeList.begin(),
1855 &valueInfoFromEdge);
1857 cast<FunctionSummary>(N.getSummaryList().front()->getBaseObject());
1858 return ChildIteratorType(F->CallGraphEdgeList.begin(), &valueInfoFromEdge);
1859 }
1860
1862 if (!N.getSummaryList().size()) // handle external function
1863 return ChildIteratorType(
1864 FunctionSummary::ExternalNode.CallGraphEdgeList.end(),
1865 &valueInfoFromEdge);
1867 cast<FunctionSummary>(N.getSummaryList().front()->getBaseObject());
1868 return ChildIteratorType(F->CallGraphEdgeList.end(), &valueInfoFromEdge);
1869 }
1870
1872 if (!N.getSummaryList().size()) // handle external function
1873 return FunctionSummary::ExternalNode.CallGraphEdgeList.begin();
1874
1876 cast<FunctionSummary>(N.getSummaryList().front()->getBaseObject());
1877 return F->CallGraphEdgeList.begin();
1878 }
1879
1881 if (!N.getSummaryList().size()) // handle external function
1882 return FunctionSummary::ExternalNode.CallGraphEdgeList.end();
1883
1885 cast<FunctionSummary>(N.getSummaryList().front()->getBaseObject());
1886 return F->CallGraphEdgeList.end();
1887 }
1888
1889 static NodeRef edge_dest(EdgeRef E) { return E.first; }
1890};
1891
1892template <>
1895 std::unique_ptr<GlobalValueSummary> Root =
1896 std::make_unique<FunctionSummary>(I->calculateCallGraphRoot());
1897 GlobalValueSummaryInfo G(I->haveGVs());
1898 G.SummaryList.push_back(std::move(Root));
1899 static auto P =
1900 GlobalValueSummaryMapTy::value_type(GlobalValue::GUID(0), std::move(G));
1901 return ValueInfo(I->haveGVs(), &P);
1902 }
1903};
1904} // end namespace llvm
1905
1906#endif // LLVM_IR_MODULESUMMARYINDEX_H
for(const MachineOperand &MO :llvm::drop_begin(OldMI.operands(), Desc.getNumOperands()))
This file defines the StringMap class.
This file defines the BumpPtrAllocator interface.
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
Looks at all the uses of the given value Returns the Liveness deduced from the uses of this value Adds all uses that cause the result to be MaybeLive to MaybeLiveRetUses If the result is Live
This file defines the DenseMap class.
std::string Name
static const char * PreservedSymbols[]
Definition: IRSymtab.cpp:48
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
#define G(x, y, z)
Definition: MD5.cpp:56
AllocType
Module.h This file contains the declarations for the Module class.
#define P(N)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file contains some templates that are useful if you are working with the STL at all.
raw_pwrite_stream & OS
This file defines the SmallString class.
This file defines the SmallVector class.
This file contains some functions that are useful when dealing with strings.
ScaledNumber< uint64_t > Scaled64
Value * RHS
Alias summary information.
GlobalValue::GUID getAliaseeGUID() const
const GlobalValueSummary & getAliasee() const
ValueInfo getAliaseeVI() const
static bool classof(const GlobalValueSummary *GVS)
Check if this is an alias summary.
AliasSummary(GVFlags Flags)
GlobalValueSummary & getAliasee()
void setAliasee(ValueInfo &AliaseeVI, GlobalValueSummary *Aliasee)
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
Allocate memory in an ever growing pool, as if by bump-pointer.
Definition: Allocator.h:66
This class represents a range of values.
Definition: ConstantRange.h:47
This is an important base class in LLVM.
Definition: Constant.h:41
Implements a dense probed hash-table based set.
Definition: DenseSet.h:271
Function summary information to aid decisions and implementation of importing.
static FunctionSummary ExternalNode
A dummy node to reference external functions that aren't in the index.
FunctionSummary(GVFlags Flags, unsigned NumInsts, FFlags FunFlags, uint64_t EntryCount, std::vector< ValueInfo > Refs, std::vector< EdgeTy > CGEdges, std::vector< GlobalValue::GUID > TypeTests, std::vector< VFuncId > TypeTestAssumeVCalls, std::vector< VFuncId > TypeCheckedLoadVCalls, std::vector< ConstVCall > TypeTestAssumeConstVCalls, std::vector< ConstVCall > TypeCheckedLoadConstVCalls, std::vector< ParamAccess > Params, CallsitesTy CallsiteList, AllocsTy AllocList)
ArrayRef< VFuncId > type_test_assume_vcalls() const
Returns the list of virtual calls made by this function using llvm.assume(llvm.type....
ArrayRef< ConstVCall > type_test_assume_const_vcalls() const
Returns the list of virtual calls made by this function using llvm.assume(llvm.type....
static FunctionSummary makeDummyFunctionSummary(std::vector< FunctionSummary::EdgeTy > Edges)
Create an empty FunctionSummary (with specified call edges).
std::pair< ValueInfo, CalleeInfo > EdgeTy
<CalleeValueInfo, CalleeInfo> call edge pair.
std::pair< unsigned, unsigned > specialRefCounts() const
void setEntryCount(uint64_t EC)
Set the synthetic entry count for this function.
ArrayRef< AllocInfo > allocs() const
ArrayRef< CallsiteInfo > callsites() const
void addTypeTest(GlobalValue::GUID Guid)
Add a type test to the summary.
uint64_t entryCount() const
Get the synthetic entry count for this function.
std::vector< EdgeTy > & mutableCalls()
ArrayRef< VFuncId > type_checked_load_vcalls() const
Returns the list of virtual calls made by this function using llvm.type.checked.load intrinsics that ...
void setParamAccesses(std::vector< ParamAccess > NewParams)
Sets the list of known uses of pointer parameters.
unsigned instCount() const
Get the instruction count recorded for this function.
const TypeIdInfo * getTypeIdInfo() const
ArrayRef< ConstVCall > type_checked_load_const_vcalls() const
Returns the list of virtual calls made by this function using llvm.type.checked.load intrinsics with ...
ArrayRef< EdgeTy > calls() const
Return the list of <CalleeValueInfo, CalleeInfo> pairs.
ArrayRef< ParamAccess > paramAccesses() const
Returns the list of known uses of pointer parameters.
CallsitesTy & mutableCallsites()
ForceSummaryHotnessType
Types for -force-summary-edges-cold debugging option.
FFlags fflags() const
Get function summary flags.
ArrayRef< GlobalValue::GUID > type_tests() const
Returns the list of type identifiers used by this function in llvm.type.test intrinsics other than by...
static bool classof(const GlobalValueSummary *GVS)
Check if this is a function summary.
Function and variable summary information to aid decisions and implementation of importing.
SummaryKind
Sububclass discriminator (for dyn_cast<> et al.)
GVFlags flags() const
Get the flags for this GlobalValue (see struct GVFlags).
StringRef modulePath() const
Get the path to the module containing this function.
GlobalValueSummary * getBaseObject()
If this is an alias summary, returns the summary of the aliased object (a global variable or function...
SummaryKind getSummaryKind() const
Which kind of summary subclass this is.
GlobalValue::GUID getOriginalName() const
Returns the hash of the original name, it is identical to the GUID for externally visible symbols,...
GlobalValue::VisibilityTypes getVisibility() const
ArrayRef< ValueInfo > refs() const
Return the list of values referenced by this global value definition.
GlobalValueSummary(SummaryKind K, GVFlags Flags, std::vector< ValueInfo > Refs)
void setLinkage(GlobalValue::LinkageTypes Linkage)
Sets the linkage to the value determined by global summary-based optimization.
void setVisibility(GlobalValue::VisibilityTypes Vis)
virtual ~GlobalValueSummary()=default
void setModulePath(StringRef ModPath)
Set the path to the module containing this function, for use in the combined index.
void setNotEligibleToImport()
Flag that this global value cannot be imported.
void setCanAutoHide(bool CanAutoHide)
GlobalValue::LinkageTypes linkage() const
Return linkage type recorded for this global value.
bool notEligibleToImport() const
Return true if this global value can't be imported.
void setOriginalName(GlobalValue::GUID Name)
Initialize the original name hash in this summary.
GUID getGUID() const
Return a 64-bit global unique ID constructed from global value name (i.e.
Definition: GlobalValue.h:591
VisibilityTypes
An enumeration for the kinds of visibility of global values.
Definition: GlobalValue.h:62
@ DefaultVisibility
The GV is visible.
Definition: GlobalValue.h:63
static GUID getGUID(StringRef GlobalName)
Return a 64-bit global unique ID constructed from global value name (i.e.
Definition: GlobalValue.h:587
LinkageTypes
An enumeration for the kinds of linkage for global values.
Definition: GlobalValue.h:47
@ AvailableExternallyLinkage
Available for inspection, not emission.
Definition: GlobalValue.h:49
Global variable summary information to aid decisions and implementation of importing.
void setVCallVisibility(GlobalObject::VCallVisibility Vis)
struct llvm::GlobalVarSummary::GVarFlags VarFlags
GVarFlags varflags() const
ArrayRef< VirtFuncOffset > vTableFuncs() const
GlobalObject::VCallVisibility getVCallVisibility() const
static bool classof(const GlobalValueSummary *GVS)
Check if this is a global variable summary.
GlobalVarSummary(GVFlags Flags, GVarFlags VarFlags, std::vector< ValueInfo > Refs)
void setVTableFuncs(VTableFuncList Funcs)
Class to hold module path string table and global value map, and encapsulate methods for operating on...
std::set< std::string > & cfiFunctionDecls()
const std::set< std::string > & cfiFunctionDecls() const
TypeIdSummary & getOrInsertTypeIdSummary(StringRef TypeId)
Return an existing or new TypeIdSummary entry for TypeId.
std::optional< TypeIdCompatibleVtableInfo > getTypeIdCompatibleVtableSummary(StringRef TypeId) const
For the given TypeId, this returns the TypeIdCompatibleVtableMap entry if present in the summary map.
gvsummary_iterator end()
void addGlobalValueSummary(ValueInfo VI, std::unique_ptr< GlobalValueSummary > Summary)
Add a global value summary for the given ValueInfo.
ModulePathStringTableTy::value_type ModuleInfo
ValueInfo getOrInsertValueInfo(GlobalValue::GUID GUID)
Return a ValueInfo for GUID.
bool withGlobalValueDeadStripping() const
const std::set< std::string > & cfiFunctionDefs() const
static void discoverNodes(ValueInfo V, std::map< ValueInfo, bool > &FunctionHasParent)
Convenience function for doing a DFS on a ValueInfo.
StringRef saveString(StringRef String)
const TypeIdSummaryMapTy & typeIds() const
static StringRef getOriginalNameBeforePromote(StringRef Name)
Helper to obtain the unpromoted name for a global value (or the original name if not promoted).
const TypeIdSummary * getTypeIdSummary(StringRef TypeId) const
This returns either a pointer to the type id summary (if present in the summary map) or null (if not ...
bool isGUIDLive(GlobalValue::GUID GUID) const
gvsummary_iterator begin()
const_gvsummary_iterator end() const
bool isReadOnly(const GlobalVarSummary *GVS) const
void setFlags(uint64_t Flags)
const_gvsummary_iterator begin() const
bool isWriteOnly(const GlobalVarSummary *GVS) const
const std::vector< uint64_t > & stackIds() const
GlobalValueSummary * findSummaryInModule(GlobalValue::GUID ValueGUID, StringRef ModuleId) const
Find the summary for global GUID in module ModuleId, or nullptr if not found.
ValueInfo getValueInfo(const GlobalValueSummaryMapTy::value_type &R) const
Return a ValueInfo for the index value_type (convenient when iterating index).
const ModuleHash & getModuleHash(const StringRef ModPath) const
Get the module SHA1 hash recorded for the given module path.
static constexpr const char * getRegularLTOModuleName()
void addGlobalValueSummary(StringRef ValueName, std::unique_ptr< GlobalValueSummary > Summary)
Add a global value summary for a value of the given name.
ModuleSummaryIndex(bool HaveGVs, bool EnableSplitLTOUnit=false, bool UnifiedLTO=false)
void collectDefinedFunctionsForModule(StringRef ModulePath, GVSummaryMapTy &GVSummaryMap) const
Collect for the given module the list of functions it defines (GUID -> Summary).
const auto & typeIdCompatibleVtableMap() const
void dumpSCCs(raw_ostream &OS)
Print out strongly connected components for debugging.
bool isGlobalValueLive(const GlobalValueSummary *GVS) const
const ModuleInfo * getModule(StringRef ModPath) const
Return module entry for module with the given ModPath.
void propagateAttributes(const DenseSet< GlobalValue::GUID > &PreservedSymbols)
Do the access attribute and DSOLocal propagation in combined index.
const StringMap< ModuleHash > & modulePaths() const
Table of modules, containing module hash and id.
void dump() const
Dump to stderr (for debugging).
Definition: AsmWriter.cpp:5145
ModuleInfo * addModule(StringRef ModPath, ModuleHash Hash=ModuleHash{{0}})
Add a new module with the given Hash, mapped to the given ModID, and return a reference to the module...
void collectDefinedGVSummariesPerModule(Map &ModuleToDefinedGVSummaries) const
Collect for each module the list of Summaries it defines (GUID -> Summary).
void addGlobalValueSummary(const GlobalValue &GV, std::unique_ptr< GlobalValueSummary > Summary)
Add a global value summary for a value.
bool hasExportedFunctions(const Module &M) const
Check if the given Module has any functions available for exporting in the index.
static std::string getGlobalNameForLocal(StringRef Name, ModuleHash ModHash)
Convenience method for creating a promoted global name for the given value name of a local,...
static constexpr uint64_t BitcodeSummaryVersion
void exportToDot(raw_ostream &OS, const DenseSet< GlobalValue::GUID > &GUIDPreservedSymbols) const
Export summary to dot file for GraphViz.
uint64_t getStackIdAtIndex(unsigned Index) const
StringMap< ModuleHash > & modulePaths()
Table of modules, containing hash and id.
void print(raw_ostream &OS, bool IsForDebug=false) const
Print to an output stream.
Definition: AsmWriter.cpp:5075
bool skipModuleByDistributedBackend() const
ValueInfo getOrInsertValueInfo(const GlobalValue *GV)
Return a ValueInfo for GV and mark it as belonging to GV.
GlobalValueSummary * findSummaryInModule(ValueInfo VI, StringRef ModuleId) const
Find the summary for ValueInfo VI in module ModuleId, or nullptr if not found.
ValueInfo getValueInfo(GlobalValue::GUID GUID) const
Return a ValueInfo for GUID if it exists, otherwise return ValueInfo().
unsigned addOrGetStackIdIndex(uint64_t StackId)
GlobalValue::GUID getGUIDFromOriginalID(GlobalValue::GUID OriginalID) const
Return the GUID for OriginalId in the OidGuidMap.
GlobalValueSummary * getGlobalValueSummary(const GlobalValue &GV, bool PerModuleIndex=true) const
Returns the first GlobalValueSummary for GV, asserting that there is only one if PerModuleIndex.
std::set< std::string > & cfiFunctionDefs()
ModuleInfo * getModule(StringRef ModPath)
Return module entry for module with the given ModPath.
ValueInfo getOrInsertValueInfo(GlobalValue::GUID GUID, StringRef Name)
Return a ValueInfo for GUID setting value Name.
bool canImportGlobalVar(const GlobalValueSummary *S, bool AnalyzeRefs) const
Checks if we can import global variable from another module.
static std::string getGlobalNameForLocal(StringRef Name, StringRef Suffix)
void addOriginalName(GlobalValue::GUID ValueGUID, GlobalValue::GUID OrigGUID)
Add an original name for the value of the given GUID.
FunctionSummary calculateCallGraphRoot()
TypeIdSummary * getTypeIdSummary(StringRef TypeId)
TypeIdCompatibleVtableInfo & getOrInsertTypeIdCompatibleVtableSummary(StringRef TypeId)
Return an existing or new TypeIdCompatibleVtableMap entry for TypeId.
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
PointerIntPair - This class implements a pair of a pointer and small integer.
void setPointer(PointerTy PtrVal) &
IntType getInt() const
void setInt(IntType IntVal) &
PointerTy getPointer() const
Simple representation of a scaled number.
Definition: ScaledNumber.h:493
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:26
StringRef str() const
Explicit conversion to StringRef.
Definition: SmallString.h:261
void push_back(const T &Elt)
Definition: SmallVector.h:416
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1200
StringMapEntry - This is used to represent one value that is inserted into a StringMap.
iterator end()
Definition: StringMap.h:205
iterator find(StringRef Key)
Definition: StringMap.h:218
size_type count(StringRef Key) const
count - Return 1 if the element is in the map, 0 otherwise.
Definition: StringMap.h:257
bool insert(MapEntryTy *KeyValue)
insert - Insert the specified key/value pair into the map.
Definition: StringMap.h:287
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
Saves strings in the provided stable storage and returns a StringRef with a stable character pointer.
Definition: StringSaver.h:21
StringRef save(const char *S)
Definition: StringSaver.h:30
A Use represents the edge between a Value definition and its users.
Definition: Use.h:43
bool hasName() const
Definition: Value.h:261
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:642
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ Cold
Attempts to make code in the caller as efficient as possible under the assumption that the call is no...
Definition: CallingConv.h:47
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
GlobalValueSummaryMapTy::iterator gvsummary_iterator
@ Offset
Definition: DWP.cpp:456
bool operator<(int64_t V1, const APSInt &V2)
Definition: APSInt.h:361
const char * getHotnessName(CalleeInfo::HotnessType HT)
bool operator!=(uint64_t V1, const APInt &V2)
Definition: APInt.h:2036
bool operator==(const AddressRangeValuePair &LHS, const AddressRangeValuePair &RHS)
std::vector< VirtFuncOffset > VTableFuncList
List of functions referenced by a particular vtable definition.
std::vector< std::unique_ptr< GlobalValueSummary > > GlobalValueSummaryList
@ First
Helpers to iterate all locations in the MemoryEffectsBase class.
@ None
Not a recurrence.
GlobalValueSummaryMapTy::const_iterator const_gvsummary_iterator
Type used for iterating through the global value summary map.
raw_ostream & operator<<(raw_ostream &OS, const APFixedPoint &FX)
Definition: APFixedPoint.h:292
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1853
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).
auto find_if(R &&Range, UnaryPredicate P)
Provide wrappers to std::find_if which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1753
std::array< uint32_t, 5 > ModuleHash
160 bits SHA1
std::map< GlobalValue::GUID, GlobalValueSummaryInfo > GlobalValueSummaryMapTy
Map from global value GUID to corresponding summary structures.
std::vector< TypeIdOffsetVtableInfo > TypeIdCompatibleVtableInfo
List of vtable definitions decorated by a particular type identifier, and their corresponding offsets...
Implement std::hash so that hash_code can be used in STL containers.
Definition: BitVector.h:858
#define N
Summary of memprof metadata on allocations.
AllocInfo(std::vector< MIBInfo > MIBs)
AllocInfo(SmallVector< uint8_t > Versions, std::vector< MIBInfo > MIBs)
SmallVector< uint8_t > Versions
std::vector< MIBInfo > MIBs
Class to accumulate and hold information about a callee.
static constexpr uint64_t MaxRelBlockFreq
uint32_t RelBlockFreq
The value stored in RelBlockFreq has to be interpreted as the digits of a scaled number with a scale ...
void updateHotness(const HotnessType OtherHotness)
HotnessType getHotness() const
static constexpr int32_t ScaleShift
CalleeInfo(HotnessType Hotness, uint64_t RelBF)
void updateRelBlockFreq(uint64_t BlockFreq, uint64_t EntryFreq)
Update RelBlockFreq from BlockFreq and EntryFreq.
Summary of memprof callsite metadata.
SmallVector< unsigned > StackIdIndices
SmallVector< unsigned > Clones
CallsiteInfo(ValueInfo Callee, SmallVector< unsigned > StackIdIndices)
CallsiteInfo(ValueInfo Callee, SmallVector< unsigned > Clones, SmallVector< unsigned > StackIdIndices)
static FunctionSummary::ConstVCall getEmptyKey()
static FunctionSummary::ConstVCall getTombstoneKey()
static unsigned getHashValue(FunctionSummary::ConstVCall I)
static bool isEqual(FunctionSummary::ConstVCall L, FunctionSummary::ConstVCall R)
static FunctionSummary::VFuncId getEmptyKey()
static bool isEqual(FunctionSummary::VFuncId L, FunctionSummary::VFuncId R)
static FunctionSummary::VFuncId getTombstoneKey()
static unsigned getHashValue(FunctionSummary::VFuncId I)
static bool isEqual(ValueInfo L, ValueInfo R)
static bool isSpecialKey(ValueInfo V)
static unsigned getHashValue(ValueInfo I)
An information struct used to provide DenseMap with the various necessary components for a given valu...
Definition: DenseMapInfo.h:50
A specification for a virtual function call with all constant integer arguments.
Flags specific to function summaries.
FFlags & operator&=(const FFlags &RHS)
Describes the use of a value in a call instruction, specifying the call's target, the value's paramet...
Call(uint64_t ParamNo, ValueInfo Callee, const ConstantRange &Offsets)
Describes the uses of a parameter by the function.
ParamAccess(uint64_t ParamNo, const ConstantRange &Use)
std::vector< Call > Calls
In the per-module summary, it summarizes the byte offset applied to each pointer parameter before pas...
static constexpr uint32_t RangeWidth
All type identifier related information.
std::vector< ConstVCall > TypeCheckedLoadConstVCalls
std::vector< VFuncId > TypeCheckedLoadVCalls
std::vector< ConstVCall > TypeTestAssumeConstVCalls
List of virtual calls made by this function using (respectively) llvm.assume(llvm....
std::vector< GlobalValue::GUID > TypeTests
List of type identifiers used by this function in llvm.type.test intrinsics referenced by something o...
std::vector< VFuncId > TypeTestAssumeVCalls
List of virtual calls made by this function using (respectively) llvm.assume(llvm....
An "identifier" for a virtual function.
GlobalValueSummaryList SummaryList
List of global value summary structures for a particular value held in the GlobalValueMap.
union llvm::GlobalValueSummaryInfo::NameOrGV U
Group flags (Linkage, NotEligibleToImport, etc.) as a bitfield.
GVFlags(GlobalValue::LinkageTypes Linkage, GlobalValue::VisibilityTypes Visibility, bool NotEligibleToImport, bool Live, bool IsLocal, bool CanAutoHide)
Convenience Constructors.
unsigned DSOLocal
Indicates that the linker resolved the symbol to a definition from within the same linkage unit.
unsigned CanAutoHide
In the per-module summary, indicates that the global value is linkonce_odr and global unnamed addr (s...
unsigned NotEligibleToImport
Indicate if the global value cannot be imported (e.g.
unsigned Linkage
The linkage type of the associated global value.
unsigned Visibility
Indicates the visibility.
unsigned Live
In per-module summary, indicate that the global value must be considered a live root for index-based ...
GVarFlags(bool ReadOnly, bool WriteOnly, bool Constant, GlobalObject::VCallVisibility Vis)
static NodeRef getEntryNode(ModuleSummaryIndex *I)
static NodeRef valueInfoFromEdge(FunctionSummary::EdgeTy &P)
static ChildIteratorType child_begin(NodeRef N)
static ChildEdgeIteratorType child_edge_begin(NodeRef N)
static NodeRef edge_dest(EdgeRef E)
std::vector< FunctionSummary::EdgeTy >::iterator ChildEdgeIteratorType
static NodeRef getEntryNode(ValueInfo V)
static ChildIteratorType child_end(NodeRef N)
static ChildEdgeIteratorType child_edge_end(NodeRef N)
FunctionSummary::EdgeTy & EdgeRef
Summary of a single MIB in a memprof metadata on allocations.
MIBInfo(AllocationType AllocType, SmallVector< unsigned > StackIdIndices)
AllocationType AllocType
SmallVector< unsigned > StackIdIndices
The following data structures summarize type metadata information.
TypeIdOffsetVtableInfo(uint64_t Offset, ValueInfo VI)
std::map< uint64_t, WholeProgramDevirtResolution > WPDRes
Mapping from byte offset to whole-program devirt resolution for that (typeid, byte offset) pair.
TypeTestResolution TTRes
Kind
Specifies which kind of type check we should emit for this byte array.
@ Unknown
Unknown (analysis not performed, don't lower)
@ Single
Single element (last example in "Short Inline Bit Vectors")
@ Inline
Inlined bit vector ("Short Inline Bit Vectors")
@ Unsat
Unsatisfiable type (i.e. no global has this type metadata)
@ AllOnes
All-ones bit vector ("Eliminating Bit Vector Checks for All-Ones Bit Vectors")
@ ByteArray
Test a byte array (first example)
unsigned SizeM1BitWidth
Range of size-1 expressed as a bit width.
enum llvm::TypeTestResolution::Kind TheKind
Struct that holds a reference to a particular GUID in a global value summary.
PointerIntPair< const GlobalValueSummaryMapTy::value_type *, 3, int > RefAndFlags
GlobalValue::VisibilityTypes getELFVisibility() const
Returns the most constraining visibility among summaries.
bool isValidAccessSpecifier() const
const GlobalValueSummaryMapTy::value_type * getRef() const
ArrayRef< std::unique_ptr< GlobalValueSummary > > getSummaryList() const
StringRef name() const
bool isWriteOnly() const
const GlobalValue * getValue() const
ValueInfo(bool HaveGVs, const GlobalValueSummaryMapTy::value_type *R)
bool isReadOnly() const
bool canAutoHide() const
Checks if all copies are eligible for auto-hiding (have flag set).
unsigned getAccessSpecifier() const
ValueInfo()=default
bool isDSOLocal(bool WithDSOLocalPropagation=false) const
Checks if all summaries are DSO local (have the flag set).
GlobalValue::GUID getGUID() const
bool haveGVs() const
The ValueInfo and offset for a function within a vtable definition initializer array.
VirtFuncOffset(ValueInfo VI, uint64_t Offset)
@ UniformRetVal
Uniform return value optimization.
@ VirtualConstProp
Virtual constant propagation.
@ UniqueRetVal
Unique return value optimization.
@ Indir
Just do a regular virtual call.
uint64_t Info
Additional information for the resolution:
enum llvm::WholeProgramDevirtResolution::ByArg::Kind TheKind
enum llvm::WholeProgramDevirtResolution::Kind TheKind
std::map< std::vector< uint64_t >, ByArg > ResByArg
Resolutions for calls with all constant integer arguments (excluding the first argument,...
@ SingleImpl
Single implementation devirtualization.
@ Indir
Just do a regular virtual call.
@ BranchFunnel
When retpoline mitigation is enabled, use a branch funnel that is defined in the merged module.
const GlobalValue * GV
The GlobalValue corresponding to this summary.
StringRef Name
Summary string representation.