Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===- llvm/ModuleSummaryIndex.h - Module Summary Index ---------*- C++ -*-===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

/// @file

/// ModuleSummaryIndex.h This file contains the declarations the classes that

///  hold the module index and summary for function importing.

//

//===----------------------------------------------------------------------===//

#ifndef LLVM_IR_MODULESUMMARYINDEX_H

#define LLVM_IR_MODULESUMMARYINDEX_H

#include "llvm/ADT/ArrayRef.h"

#include "llvm/ADT/DenseMap.h"

#include "llvm/ADT/STLExtras.h"

#include "llvm/ADT/SmallString.h"

#include "llvm/ADT/SmallVector.h"

#include "llvm/ADT/StringExtras.h"

#include "llvm/ADT/StringMap.h"

#include "llvm/ADT/StringRef.h"

#include "llvm/IR/ConstantRange.h"

#include "llvm/IR/GlobalValue.h"

#include "llvm/IR/Module.h"

#include "llvm/Support/Allocator.h"

#include "llvm/Support/MathExtras.h"

#include "llvm/Support/ScaledNumber.h"

#include "llvm/Support/StringSaver.h"

#include "llvm/Support/raw_ostream.h"

#include <algorithm>

#include <array>

#include <cassert>

#include <cstddef>

#include <cstdint>

#include <map>

#include <memory>

#include <optional>

#include <set>

#include <string>

#include <utility>

#include <vector>

namespace llvm {

template <class GraphType> struct GraphTraits;

namespace yaml {

template <typename T> struct MappingTraits;

} // end namespace yaml

/// Class to accumulate and hold information about a callee.

struct CalleeInfo {

  enum class HotnessType : uint8_t {

    Unknown = 0,

    Cold = 1,

    None = 2,

    Hot = 3,

    Critical = 4

  };

  // The size of the bit-field might need to be adjusted if more values are

  // added to HotnessType enum.

  uint32_t Hotness : 3;

  /// The value stored in RelBlockFreq has to be interpreted as the digits of

  /// a scaled number with a scale of \p -ScaleShift.

  uint32_t RelBlockFreq : 29;

  static constexpr int32_t ScaleShift = 8;

  static constexpr uint64_t MaxRelBlockFreq = (1 << 29) - 1;

  CalleeInfo()

      : Hotness(static_cast<uint32_t>(HotnessType::Unknown)), RelBlockFreq(0) {}

  explicit CalleeInfo(HotnessType Hotness, uint64_t RelBF)

      : Hotness(static_cast<uint32_t>(Hotness)), RelBlockFreq(RelBF) {}

  void updateHotness(const HotnessType OtherHotness) {

    Hotness = std::max(Hotness, static_cast<uint32_t>(OtherHotness));

  }

  HotnessType getHotness() const { return HotnessType(Hotness); }

  /// Update \p RelBlockFreq from \p BlockFreq and \p EntryFreq

  ///

  /// BlockFreq is divided by EntryFreq and added to RelBlockFreq. To represent

  /// fractional values, the result is represented as a fixed point number with

  /// scale of -ScaleShift.

  void updateRelBlockFreq(uint64_t BlockFreq, uint64_t EntryFreq) {

    if (EntryFreq == 0)

      return;

    using Scaled64 = ScaledNumber<uint64_t>;

    Scaled64 Temp(BlockFreq, ScaleShift);

    Temp /= Scaled64::get(EntryFreq);

    uint64_t Sum =

        SaturatingAdd<uint64_t>(Temp.toInt<uint64_t>(), RelBlockFreq);

    Sum = std::min(Sum, uint64_t(MaxRelBlockFreq));

    RelBlockFreq = static_cast<uint32_t>(Sum);

  }

};

inline const char *getHotnessName(CalleeInfo::HotnessType HT) {

  switch (HT) {

  case CalleeInfo::HotnessType::Unknown:

    return "unknown";

  case CalleeInfo::HotnessType::Cold:

    return "cold";

  case CalleeInfo::HotnessType::None:

    return "none";

  case CalleeInfo::HotnessType::Hot:

    return "hot";

  case CalleeInfo::HotnessType::Critical:

    return "critical";

  }

  llvm_unreachable("invalid hotness");

}

class GlobalValueSummary;

using GlobalValueSummaryList = std::vector<std::unique_ptr<GlobalValueSummary>>;

struct alignas(8) GlobalValueSummaryInfo {

  union NameOrGV {

    NameOrGV(bool HaveGVs) {

      if (HaveGVs)

        GV = nullptr;

      else

        Name = "";

    }

    /// The GlobalValue corresponding to this summary. This is only used in

    /// per-module summaries and when the IR is available. E.g. when module

    /// analysis is being run, or when parsing both the IR and the summary

    /// from assembly.

    const GlobalValue *GV;

    /// Summary string representation. This StringRef points to BC module

    /// string table and is valid until module data is stored in memory.

    /// This is guaranteed to happen until runThinLTOBackend function is

    /// called, so it is safe to use this field during thin link. This field

    /// is only valid if summary index was loaded from BC file.

    StringRef Name;

  } U;

  GlobalValueSummaryInfo(bool HaveGVs) : U(HaveGVs) {}

  /// List of global value summary structures for a particular value held

  /// in the GlobalValueMap. Requires a vector in the case of multiple

  /// COMDAT values of the same name.

  GlobalValueSummaryList SummaryList;

};

/// Map from global value GUID to corresponding summary structures. Use a

/// std::map rather than a DenseMap so that pointers to the map's value_type

/// (which are used by ValueInfo) are not invalidated by insertion. Also it will

/// likely incur less overhead, as the value type is not very small and the size

/// of the map is unknown, resulting in inefficiencies due to repeated

/// insertions and resizing.

using GlobalValueSummaryMapTy =

    std::map<GlobalValue::GUID, GlobalValueSummaryInfo>;

/// Struct that holds a reference to a particular GUID in a global value

/// summary.

struct ValueInfo {

  enum Flags { HaveGV = 1, ReadOnly = 2, WriteOnly = 4 };

  PointerIntPair<const GlobalValueSummaryMapTy::value_type *, 3, int>

      RefAndFlags;

  ValueInfo() = default;

  ValueInfo(bool HaveGVs, const GlobalValueSummaryMapTy::value_type *R) {

    RefAndFlags.setPointer(R);

    RefAndFlags.setInt(HaveGVs);

  }

  explicit operator bool() const { return getRef(); }

  GlobalValue::GUID getGUID() const { return getRef()->first; }

  const GlobalValue *getValue() const {

    assert(haveGVs());

    return getRef()->second.U.GV;

  }

  ArrayRef<std::unique_ptr<GlobalValueSummary>> getSummaryList() const {

    return getRef()->second.SummaryList;

  }

  StringRef name() const {

    return haveGVs() ? getRef()->second.U.GV->getName()

                     : getRef()->second.U.Name;

  }

  bool haveGVs() const { return RefAndFlags.getInt() & HaveGV; }

  bool isReadOnly() const {

    assert(isValidAccessSpecifier());

    return RefAndFlags.getInt() & ReadOnly;

  }

  bool isWriteOnly() const {

    assert(isValidAccessSpecifier());

    return RefAndFlags.getInt() & WriteOnly;

  }

  unsigned getAccessSpecifier() const {

    assert(isValidAccessSpecifier());

    return RefAndFlags.getInt() & (ReadOnly | WriteOnly);

  }

  bool isValidAccessSpecifier() const {

    unsigned BadAccessMask = ReadOnly | WriteOnly;

    return (RefAndFlags.getInt() & BadAccessMask) != BadAccessMask;

  }

  void setReadOnly() {

    // We expect ro/wo attribute to set only once during

    // ValueInfo lifetime.

    assert(getAccessSpecifier() == 0);

    RefAndFlags.setInt(RefAndFlags.getInt() | ReadOnly);

  }

  void setWriteOnly() {

    assert(getAccessSpecifier() == 0);

    RefAndFlags.setInt(RefAndFlags.getInt() | WriteOnly);

  }

  const GlobalValueSummaryMapTy::value_type *getRef() const {

    return RefAndFlags.getPointer();

  }

  /// Returns the most constraining visibility among summaries. The

  /// visibilities, ordered from least to most constraining, are: default,

  /// protected and hidden.

  GlobalValue::VisibilityTypes getELFVisibility() const;

  /// Checks if all summaries are DSO local (have the flag set). When DSOLocal

  /// propagation has been done, set the parameter to enable fast check.

  bool isDSOLocal(bool WithDSOLocalPropagation = false) const;

  /// Checks if all copies are eligible for auto-hiding (have flag set).

  bool canAutoHide() const;

};

inline raw_ostream &operator<<(raw_ostream &OS, const ValueInfo &VI) {

  OS << VI.getGUID();

  if (!VI.name().empty())

    OS << " (" << VI.name() << ")";

  return OS;

}

inline bool operator==(const ValueInfo &A, const ValueInfo &B) {

  assert(A.getRef() && B.getRef() &&

         "Need ValueInfo with non-null Ref for comparison");

  return A.getRef() == B.getRef();

}

inline bool operator!=(const ValueInfo &A, const ValueInfo &B) {

  assert(A.getRef() && B.getRef() &&

         "Need ValueInfo with non-null Ref for comparison");

  return A.getRef() != B.getRef();

}

inline bool operator<(const ValueInfo &A, const ValueInfo &B) {

  assert(A.getRef() && B.getRef() &&

         "Need ValueInfo with non-null Ref to compare GUIDs");

  return A.getGUID() < B.getGUID();

}

template <> struct DenseMapInfo<ValueInfo> {

  static inline ValueInfo getEmptyKey() {

    return ValueInfo(false, (GlobalValueSummaryMapTy::value_type *)-8);

  }

  static inline ValueInfo getTombstoneKey() {

    return ValueInfo(false, (GlobalValueSummaryMapTy::value_type *)-16);

  }

  static inline bool isSpecialKey(ValueInfo V) {

    return V == getTombstoneKey() || V == getEmptyKey();

  }

  static bool isEqual(ValueInfo L, ValueInfo R) {

    // We are not supposed to mix ValueInfo(s) with different HaveGVs flag

    // in a same container.

    assert(isSpecialKey(L) || isSpecialKey(R) || (L.haveGVs() == R.haveGVs()));

    return L.getRef() == R.getRef();

  }

  static unsigned getHashValue(ValueInfo I) { return (uintptr_t)I.getRef(); }

};

/// Summary of memprof callsite metadata.

struct CallsiteInfo {

  // Actual callee function.

  ValueInfo Callee;

  // Used to record whole program analysis cloning decisions.

  // The ThinLTO backend will need to create as many clones as there are entries

  // in the vector (it is expected and should be confirmed that all such

  // summaries in the same FunctionSummary have the same number of entries).

  // Each index records version info for the corresponding clone of this

  // function. The value is the callee clone it calls (becomes the appended

  // suffix id). Index 0 is the original version, and a value of 0 calls the

  // original callee.

  SmallVector<unsigned> Clones{0};

  // Represents stack ids in this context, recorded as indices into the

  // StackIds vector in the summary index, which in turn holds the full 64-bit

  // stack ids. This reduces memory as there are in practice far fewer unique

  // stack ids than stack id references.

  SmallVector<unsigned> StackIdIndices;

  CallsiteInfo(ValueInfo Callee, SmallVector<unsigned> StackIdIndices)

      : Callee(Callee), StackIdIndices(std::move(StackIdIndices)) {}

  CallsiteInfo(ValueInfo Callee, SmallVector<unsigned> Clones,

               SmallVector<unsigned> StackIdIndices)

      : Callee(Callee), Clones(std::move(Clones)),

        StackIdIndices(std::move(StackIdIndices)) {}

};

// Allocation type assigned to an allocation reached by a given context.

// More can be added but initially this is just noncold and cold.

// Values should be powers of two so that they can be ORed, in particular to

// track allocations that have different behavior with different calling

// contexts.

enum class AllocationType : uint8_t { None = 0, NotCold = 1, Cold = 2 };

/// Summary of a single MIB in a memprof metadata on allocations.

struct MIBInfo {

  // The allocation type for this profiled context.

  AllocationType AllocType;

  // Represents stack ids in this context, recorded as indices into the

  // StackIds vector in the summary index, which in turn holds the full 64-bit

  // stack ids. This reduces memory as there are in practice far fewer unique

  // stack ids than stack id references.

  SmallVector<unsigned> StackIdIndices;

  MIBInfo(AllocationType AllocType, SmallVector<unsigned> StackIdIndices)

      : AllocType(AllocType), StackIdIndices(std::move(StackIdIndices)) {}

};

/// Summary of memprof metadata on allocations.

struct AllocInfo {

  // Used to record whole program analysis cloning decisions.

  // The ThinLTO backend will need to create as many clones as there are entries

  // in the vector (it is expected and should be confirmed that all such

  // summaries in the same FunctionSummary have the same number of entries).

  // Each index records version info for the corresponding clone of this

  // function. The value is the allocation type of the corresponding allocation.

  // Index 0 is the original version. Before cloning, index 0 may have more than

  // one allocation type.

  SmallVector<uint8_t> Versions;

  // Vector of MIBs in this memprof metadata.

  std::vector<MIBInfo> MIBs;

  AllocInfo(std::vector<MIBInfo> MIBs) : MIBs(std::move(MIBs)) {

    Versions.push_back(0);

  }

  AllocInfo(SmallVector<uint8_t> Versions, std::vector<MIBInfo> MIBs)

      : Versions(std::move(Versions)), MIBs(std::move(MIBs)) {}

};

/// Function and variable summary information to aid decisions and

/// implementation of importing.

class GlobalValueSummary {

public:

  /// Sububclass discriminator (for dyn_cast<> et al.)

  enum SummaryKind : unsigned { AliasKind, FunctionKind, GlobalVarKind };

  /// Group flags (Linkage, NotEligibleToImport, etc.) as a bitfield.

  struct GVFlags {

    /// The linkage type of the associated global value.

    ///

    /// One use is to flag values that have local linkage types and need to

    /// have module identifier appended before placing into the combined

    /// index, to disambiguate from other values with the same name.

    /// In the future this will be used to update and optimize linkage

    /// types based on global summary-based analysis.

    unsigned Linkage : 4;

    /// Indicates the visibility.

    unsigned Visibility : 2;

    /// Indicate if the global value cannot be imported (e.g. it cannot

    /// be renamed or references something that can't be renamed).

    unsigned NotEligibleToImport : 1;

    /// In per-module summary, indicate that the global value must be considered

    /// a live root for index-based liveness analysis. Used for special LLVM

    /// values such as llvm.global_ctors that the linker does not know about.

    ///

    /// In combined summary, indicate that the global value is live.

    unsigned Live : 1;

    /// Indicates that the linker resolved the symbol to a definition from

    /// within the same linkage unit.

    unsigned DSOLocal : 1;

    /// In the per-module summary, indicates that the global value is

    /// linkonce_odr and global unnamed addr (so eligible for auto-hiding

    /// via hidden visibility). In the combined summary, indicates that the

    /// prevailing linkonce_odr copy can be auto-hidden via hidden visibility

    /// when it is upgraded to weak_odr in the backend. This is legal when

    /// all copies are eligible for auto-hiding (i.e. all copies were

    /// linkonce_odr global unnamed addr. If any copy is not (e.g. it was

    /// originally weak_odr, we cannot auto-hide the prevailing copy as it

    /// means the symbol was externally visible.

    unsigned CanAutoHide : 1;

    /// Convenience Constructors

    explicit GVFlags(GlobalValue::LinkageTypes Linkage,

                     GlobalValue::VisibilityTypes Visibility,

                     bool NotEligibleToImport, bool Live, bool IsLocal,

                     bool CanAutoHide)

        : Linkage(Linkage), Visibility(Visibility),

          NotEligibleToImport(NotEligibleToImport), Live(Live),

          DSOLocal(IsLocal), CanAutoHide(CanAutoHide) {}

  };

private:

  /// Kind of summary for use in dyn_cast<> et al.

  SummaryKind Kind;

  GVFlags Flags;

  /// This is the hash of the name of the symbol in the original file. It is

  /// identical to the GUID for global symbols, but differs for local since the

  /// GUID includes the module level id in the hash.

  GlobalValue::GUID OriginalName = 0;

  /// Path of module IR containing value's definition, used to locate

  /// module during importing.

  ///

  /// This is only used during parsing of the combined index, or when

  /// parsing the per-module index for creation of the combined summary index,

  /// not during writing of the per-module index which doesn't contain a

  /// module path string table.

  StringRef ModulePath;

  /// List of values referenced by this global value's definition

  /// (either by the initializer of a global variable, or referenced

  /// from within a function). This does not include functions called, which

  /// are listed in the derived FunctionSummary object.

  std::vector<ValueInfo> RefEdgeList;

protected:

  GlobalValueSummary(SummaryKind K, GVFlags Flags, std::vector<ValueInfo> Refs)

      : Kind(K), Flags(Flags), RefEdgeList(std::move(Refs)) {

    assert((K != AliasKind || Refs.empty()) &&

           "Expect no references for AliasSummary");

  }

public:

  virtual ~GlobalValueSummary() = default;

  /// Returns the hash of the original name, it is identical to the GUID for

  /// externally visible symbols, but not for local ones.

  GlobalValue::GUID getOriginalName() const { return OriginalName; }

  /// Initialize the original name hash in this summary.

  void setOriginalName(GlobalValue::GUID Name) { OriginalName = Name; }

  /// Which kind of summary subclass this is.

  SummaryKind getSummaryKind() const { return Kind; }

  /// Set the path to the module containing this function, for use in

  /// the combined index.

  void setModulePath(StringRef ModPath) { ModulePath = ModPath; }

  /// Get the path to the module containing this function.

  StringRef modulePath() const { return ModulePath; }

  /// Get the flags for this GlobalValue (see \p struct GVFlags).

  GVFlags flags() const { return Flags; }

  /// Return linkage type recorded for this global value.

  GlobalValue::LinkageTypes linkage() const {

    return static_cast<GlobalValue::LinkageTypes>(Flags.Linkage);

  }

  /// Sets the linkage to the value determined by global summary-based

  /// optimization. Will be applied in the ThinLTO backends.

  void setLinkage(GlobalValue::LinkageTypes Linkage) {

    Flags.Linkage = Linkage;

  }

  /// Return true if this global value can't be imported.

  bool notEligibleToImport() const { return Flags.NotEligibleToImport; }

  bool isLive() const { return Flags.Live; }

  void setLive(bool Live) { Flags.Live = Live; }

  void setDSOLocal(bool Local) { Flags.DSOLocal = Local; }

  bool isDSOLocal() const { return Flags.DSOLocal; }

  void setCanAutoHide(bool CanAutoHide) { Flags.CanAutoHide = CanAutoHide; }

  bool canAutoHide() const { return Flags.CanAutoHide; }

  GlobalValue::VisibilityTypes getVisibility() const {

    return (GlobalValue::VisibilityTypes)Flags.Visibility;

  }

  void setVisibility(GlobalValue::VisibilityTypes Vis) {

    Flags.Visibility = (unsigned)Vis;

  }

  /// Flag that this global value cannot be imported.

  void setNotEligibleToImport() { Flags.NotEligibleToImport = true; }

  /// Return the list of values referenced by this global value definition.

  ArrayRef<ValueInfo> refs() const { return RefEdgeList; }

  /// If this is an alias summary, returns the summary of the aliased object (a

  /// global variable or function), otherwise returns itself.

  GlobalValueSummary *getBaseObject();

  const GlobalValueSummary *getBaseObject() const;

  friend class ModuleSummaryIndex;

};

/// Alias summary information.

class AliasSummary : public GlobalValueSummary {

  ValueInfo AliaseeValueInfo;

  /// This is the Aliasee in the same module as alias (could get from VI, trades

  /// memory for time). Note that this pointer may be null (and the value info

  /// empty) when we have a distributed index where the alias is being imported

  /// (as a copy of the aliasee), but the aliasee is not.

  GlobalValueSummary *AliaseeSummary;

public:

  AliasSummary(GVFlags Flags)

      : GlobalValueSummary(AliasKind, Flags, ArrayRef<ValueInfo>{}),

        AliaseeSummary(nullptr) {}

  /// Check if this is an alias summary.

  static bool classof(const GlobalValueSummary *GVS) {

    return GVS->getSummaryKind() == AliasKind;

  }

  void setAliasee(ValueInfo &AliaseeVI, GlobalValueSummary *Aliasee) {

    AliaseeValueInfo = AliaseeVI;

    AliaseeSummary = Aliasee;

  }

  bool hasAliasee() const {

    assert(!!AliaseeSummary == (AliaseeValueInfo &&

                                !AliaseeValueInfo.getSummaryList().empty()) &&

           "Expect to have both aliasee summary and summary list or neither");

    return !!AliaseeSummary;

  }

  const GlobalValueSummary &getAliasee() const {

    assert(AliaseeSummary && "Unexpected missing aliasee summary");

    return *AliaseeSummary;

  }

  GlobalValueSummary &getAliasee() {

    return const_cast<GlobalValueSummary &>(

                         static_cast<const AliasSummary *>(this)->getAliasee());

  }

  ValueInfo getAliaseeVI() const {

    assert(AliaseeValueInfo && "Unexpected missing aliasee");

    return AliaseeValueInfo;

  }

  GlobalValue::GUID getAliaseeGUID() const {

    assert(AliaseeValueInfo && "Unexpected missing aliasee");

    return AliaseeValueInfo.getGUID();

  }

};

const inline GlobalValueSummary *GlobalValueSummary::getBaseObject() const {

  if (auto *AS = dyn_cast<AliasSummary>(this))

    return &AS->getAliasee();

  return this;

}

inline GlobalValueSummary *GlobalValueSummary::getBaseObject() {

  if (auto *AS = dyn_cast<AliasSummary>(this))

    return &AS->getAliasee();

  return this;

}

/// Function summary information to aid decisions and implementation of

/// importing.

class FunctionSummary : public GlobalValueSummary {

public:

  /// <CalleeValueInfo, CalleeInfo> call edge pair.

  using EdgeTy = std::pair<ValueInfo, CalleeInfo>;

  /// Types for -force-summary-edges-cold debugging option.

  enum ForceSummaryHotnessType : unsigned {

    FSHT_None,

    FSHT_AllNonCritical,

    FSHT_All

  };

  /// An "identifier" for a virtual function. This contains the type identifier

  /// represented as a GUID and the offset from the address point to the virtual

  /// function pointer, where "address point" is as defined in the Itanium ABI:

  /// https://itanium-cxx-abi.github.io/cxx-abi/abi.html#vtable-general

  struct VFuncId {

    GlobalValue::GUID GUID;

    uint64_t Offset;

  };

  /// A specification for a virtual function call with all constant integer

  /// arguments. This is used to perform virtual constant propagation on the

  /// summary.

  struct ConstVCall {

    VFuncId VFunc;

    std::vector<uint64_t> Args;

  };

  /// All type identifier related information. Because these fields are

  /// relatively uncommon we only allocate space for them if necessary.

  struct TypeIdInfo {

    /// List of type identifiers used by this function in llvm.type.test

    /// intrinsics referenced by something other than an llvm.assume intrinsic,

    /// represented as GUIDs.

    std::vector<GlobalValue::GUID> TypeTests;

    /// List of virtual calls made by this function using (respectively)

    /// llvm.assume(llvm.type.test) or llvm.type.checked.load intrinsics that do

    /// not have all constant integer arguments.

    std::vector<VFuncId> TypeTestAssumeVCalls, TypeCheckedLoadVCalls;

    /// List of virtual calls made by this function using (respectively)

    /// llvm.assume(llvm.type.test) or llvm.type.checked.load intrinsics with

    /// all constant integer arguments.

    std::vector<ConstVCall> TypeTestAssumeConstVCalls,

        TypeCheckedLoadConstVCalls;

  };

  /// Flags specific to function summaries.

  struct FFlags {

    // Function attribute flags. Used to track if a function accesses memory,

    // recurses or aliases.

    unsigned ReadNone : 1;

    unsigned ReadOnly : 1;

    unsigned NoRecurse : 1;

    unsigned ReturnDoesNotAlias : 1;

    // Indicate if the global value cannot be inlined.

    unsigned NoInline : 1;

    // Indicate if function should be always inlined.

    unsigned AlwaysInline : 1;

    // Indicate if function never raises an exception. Can be modified during

    // thinlink function attribute propagation

    unsigned NoUnwind : 1;

    // Indicate if function contains instructions that mayThrow

    unsigned MayThrow : 1;

    // If there are calls to unknown targets (e.g. indirect)

    unsigned HasUnknownCall : 1;

    // Indicate if a function must be an unreachable function.

    //

    // This bit is sufficient but not necessary;

    // if this bit is on, the function must be regarded as unreachable;

    // if this bit is off, the function might be reachable or unreachable.

    unsigned MustBeUnreachable : 1;

    FFlags &operator&=(const FFlags &RHS) {

      this->ReadNone &= RHS.ReadNone;

      this->ReadOnly &= RHS.ReadOnly;

      this->NoRecurse &= RHS.NoRecurse;

      this->ReturnDoesNotAlias &= RHS.ReturnDoesNotAlias;

      this->NoInline &= RHS.NoInline;

      this->AlwaysInline &= RHS.AlwaysInline;

      this->NoUnwind &= RHS.NoUnwind;

      this->MayThrow &= RHS.MayThrow;

      this->HasUnknownCall &= RHS.HasUnknownCall;

      this->MustBeUnreachable &= RHS.MustBeUnreachable;

      return *this;

    }

    bool anyFlagSet() {

      return this->ReadNone | this->ReadOnly | this->NoRecurse |

             this->ReturnDoesNotAlias | this->NoInline | this->AlwaysInline |

             this->NoUnwind | this->MayThrow | this->HasUnknownCall |

             this->MustBeUnreachable;

    }

    operator std::string() {

      std::string Output;

      raw_string_ostream OS(Output);

      OS << "funcFlags: (";

      OS << "readNone: " << this->ReadNone;

      OS << ", readOnly: " << this->ReadOnly;

      OS << ", noRecurse: " << this->NoRecurse;

      OS << ", returnDoesNotAlias: " << this->ReturnDoesNotAlias;

      OS << ", noInline: " << this->NoInline;

      OS << ", alwaysInline: " << this->AlwaysInline;

      OS << ", noUnwind: " << this->NoUnwind;

      OS << ", mayThrow: " << this->MayThrow;

      OS << ", hasUnknownCall: " << this->HasUnknownCall;

      OS << ", mustBeUnreachable: " << this->MustBeUnreachable;

      OS << ")";

      return OS.str();

    }

  };

  /// Describes the uses of a parameter by the function.

  struct ParamAccess {

    static constexpr uint32_t RangeWidth = 64;

    /// Describes the use of a value in a call instruction, specifying the

    /// call's target, the value's parameter number, and the possible range of

    /// offsets from the beginning of the value that are passed.

    struct Call {

      uint64_t ParamNo = 0;

      ValueInfo Callee;

      ConstantRange Offsets{/*BitWidth=*/RangeWidth, /*isFullSet=*/true};

      Call() = default;

      Call(uint64_t ParamNo, ValueInfo Callee, const ConstantRange &Offsets)

          : ParamNo(ParamNo), Callee(Callee), Offsets(Offsets) {}

    };

    uint64_t ParamNo = 0;

    /// The range contains byte offsets from the parameter pointer which

    /// accessed by the function. In the per-module summary, it only includes

    /// accesses made by the function instructions. In the combined summary, it

    /// also includes accesses by nested function calls.

    ConstantRange Use{/*BitWidth=*/RangeWidth, /*isFullSet=*/true};

    /// In the per-module summary, it summarizes the byte offset applied to each

    /// pointer parameter before passing to each corresponding callee.

    /// In the combined summary, it's empty and information is propagated by

    /// inter-procedural analysis and applied to the Use field.

    std::vector<Call> Calls;

    ParamAccess() = default;

    ParamAccess(uint64_t ParamNo, const ConstantRange &Use)

        : ParamNo(ParamNo), Use(Use) {}

  };

  /// Create an empty FunctionSummary (with specified call edges).

  /// Used to represent external nodes and the dummy root node.

  static FunctionSummary

  makeDummyFunctionSummary(std::vector<FunctionSummary::EdgeTy> Edges) {

    return FunctionSummary(

        FunctionSummary::GVFlags(

            GlobalValue::LinkageTypes::AvailableExternallyLinkage,

            GlobalValue::DefaultVisibility,

            /*NotEligibleToImport=*/true, /*Live=*/true, /*IsLocal=*/false,

            /*CanAutoHide=*/false),

        /*NumInsts=*/0, FunctionSummary::FFlags{}, /*EntryCount=*/0,

        std::vector<ValueInfo>(), std::move(Edges),

        std::vector<GlobalValue::GUID>(),

        std::vector<FunctionSummary::VFuncId>(),

        std::vector<FunctionSummary::VFuncId>(),

        std::vector<FunctionSummary::ConstVCall>(),

        std::vector<FunctionSummary::ConstVCall>(),

        std::vector<FunctionSummary::ParamAccess>(),

        std::vector<CallsiteInfo>(), std::vector<AllocInfo>());

  }

  /// A dummy node to reference external functions that aren't in the index

  static FunctionSummary ExternalNode;

private:

  /// Number of instructions (ignoring debug instructions, e.g.) computed

  /// during the initial compile step when the summary index is first built.

  unsigned InstCount;

  /// Function summary specific flags.

  FFlags FunFlags;

  /// The synthesized entry count of the function.

  /// This is only populated during ThinLink phase and remains unused while

  /// generating per-module summaries.

  uint64_t EntryCount = 0;

  /// List of <CalleeValueInfo, CalleeInfo> call edge pairs from this function.

  std::vector<EdgeTy> CallGraphEdgeList;

  std::unique_ptr<TypeIdInfo> TIdInfo;

  /// Uses for every parameter to this function.

  using ParamAccessesTy = std::vector<ParamAccess>;

  std::unique_ptr<ParamAccessesTy> ParamAccesses;

  /// Optional list of memprof callsite metadata summaries. The correspondence

  /// between the callsite summary and the callsites in the function is implied

  /// by the order in the vector (and can be validated by comparing the stack

  /// ids in the CallsiteInfo to those in the instruction callsite metadata).

  /// As a memory savings optimization, we only create these for the prevailing

  /// copy of a symbol when creating the combined index during LTO.

  using CallsitesTy = std::vector<CallsiteInfo>;

  std::unique_ptr<CallsitesTy> Callsites;

  /// Optional list of allocation memprof metadata summaries. The correspondence

  /// between the alloc memprof summary and the allocation callsites in the

  /// function is implied by the order in the vector (and can be validated by

  /// comparing the stack ids in the AllocInfo to those in the instruction

  /// memprof metadata).

  /// As a memory savings optimization, we only create these for the prevailing

  /// copy of a symbol when creating the combined index during LTO.