Draft, not for discuss

[mingmingl]

modify a draft of revision

clang/docs/ThinLTO.rst

 
 1. The host compiler_ must be a version of clang that supports ThinLTO.
 #. The host linker_ must support ThinLTO (and in the case of gold, must be
    `configured with plugins enabled <https://llvm.org/docs/GoldPlugin.html>`_).
 #. Use the following additional `CMake variables
    <https://llvm.org/docs/CMake.html#options-and-variables>`_
    when configuring the bootstrap compiler build:
 
-  * ``-DLLVM_ENABLE_LTO=thin``
+  * ``-DLLVM_ENABLE_LTO=Thin``
   * ``-DCMAKE_C_COMPILER=/path/to/host/clang``
   * ``-DCMAKE_CXX_COMPILER=/path/to/host/clang++``
   * ``-DCMAKE_RANLIB=/path/to/host/llvm-ranlib``
   * ``-DCMAKE_AR=/path/to/host/llvm-ar``
 
   Or, on Windows:
 
-  * ``-DLLVM_ENABLE_LTO=thin``
+  * ``-DLLVM_ENABLE_LTO=Thin``
   * ``-DCMAKE_C_COMPILER=/path/to/host/clang-cl.exe``
   * ``-DCMAKE_CXX_COMPILER=/path/to/host/clang-cl.exe``
   * ``-DCMAKE_LINKER=/path/to/host/lld-link.exe``
   * ``-DCMAKE_RANLIB=/path/to/host/llvm-ranlib.exe``
   * ``-DCMAKE_AR=/path/to/host/llvm-ar.exe``
 
 #. To use additional linker arguments for controlling the backend
    parallelism_ or enabling incremental_ builds of the bootstrap compiler,

llvm/include/llvm/IR/ModuleSummaryIndex.h

FFlags &operator&=(const FFlags &RHS) {
       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;
     }
 
+    // This is used to print human-readable information.
     bool anyFlagSet() {
       return this->ReadNone | this->ReadOnly | this->NoRecurse |
              this->ReturnDoesNotAlias | this->NoInline | this->AlwaysInline |
              this->NoUnwind | this->MayThrow | this->HasUnknownCall;
     }
 
     operator std::string() {
       std::string Output;
return FunctionSummary(
             /*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<FunctionSummary::ParamAccess>(), false);
   }
 
   /// 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.
private:
   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;
 
+  // If true, the function must be unreachable.
+  // Note, a function might still be unreachable (not detected)
+  // even if this bit is off.
+  //
+  // For example, the destructor of a abstract class is unreachable.
+  bool mustBeUnreachable = false;
+
 public:
   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)
+                  std::vector<ParamAccess> Params, bool mustBeUnreachable)
       : GlobalValueSummary(FunctionKind, Flags, std::move(Refs)),
         InstCount(NumInsts), FunFlags(FunFlags), EntryCount(EntryCount),
-        CallGraphEdgeList(std::move(CGEdges)) {
+        CallGraphEdgeList(std::move(CGEdges)),
+        mustBeUnreachable(mustBeUnreachable) {
     if (!TypeTests.empty() || !TypeTestAssumeVCalls.empty() ||
         !TypeCheckedLoadVCalls.empty() || !TypeTestAssumeConstVCalls.empty() ||
         !TypeCheckedLoadConstVCalls.empty())
       TIdInfo = std::make_unique<TypeIdInfo>(
           TypeIdInfo{std::move(TypeTests), std::move(TypeTestAssumeVCalls),
                      std::move(TypeCheckedLoadVCalls),
                      std::move(TypeTestAssumeConstVCalls),
                      std::move(TypeCheckedLoadConstVCalls)});
     if (!Params.empty())
       ParamAccesses = std::make_unique<ParamAccessesTy>(std::move(Params));
   }
   // Gets the number of readonly and writeonly refs in RefEdgeList
   std::pair<unsigned, unsigned> specialRefCounts() const;
 
   /// Check if this is a function summary.
   static bool classof(const GlobalValueSummary *GVS) {
     return GVS->getSummaryKind() == FunctionKind;
   }
 
   /// Get function summary flags.
   FFlags fflags() const { return FunFlags; }
 
+  bool isUnreachableFunction() const { return mustBeUnreachable; }
+
   void setNoRecurse() { FunFlags.NoRecurse = true; }
 
   void setNoUnwind() { FunFlags.NoUnwind = true; }
 
   /// Get the instruction count recorded for this function.
   unsigned instCount() const { return InstCount; }
 
   /// Get the synthetic entry count for this function.
ValueInfo getOrInsertValueInfo(GlobalValue::GUID GUID, StringRef Name) {
     auto VP = getOrInsertValuePtr(GUID);
     VP->second.U.Name = Name;
     return ValueInfo(HaveGVs, VP);
   }
 
   /// Return a ValueInfo for \p GV and mark it as belonging to GV.
   ValueInfo getOrInsertValueInfo(const GlobalValue *GV) {
     assert(HaveGVs);
+    errs() << "\tGV->GUID is " << GV->getGUID() << "\n";
     auto VP = getOrInsertValuePtr(GV->getGUID());
     VP->second.U.GV = GV;
     return ValueInfo(HaveGVs, VP);
   }
 
   /// Return the GUID for \p OriginalId in the OidGuidMap.
   GlobalValue::GUID getGUIDFromOriginalID(GlobalValue::GUID OriginalID) const {
     const auto I = OidGuidMap.find(OriginalID);
addGlobalValueSummary(getOrInsertValueInfo(GlobalValue::getGUID(ValueName)),
                           std::move(Summary));
   }
 
   /// Add a global value summary for the given ValueInfo.
   void addGlobalValueSummary(ValueInfo VI,
                              std::unique_ptr<GlobalValueSummary> Summary) {
     if (const FunctionSummary *FS = dyn_cast<FunctionSummary>(Summary.get()))
       HasParamAccess |= !FS->paramAccesses().empty();
+    errs() << "\tGoing to add original name " << Summary->getOriginalName()
+           << " to GUID " << VI.getGUID() << "\n";
     addOriginalName(VI.getGUID(), Summary->getOriginalName());
     // Here we have a notionally const VI, but the value it points to is owned
     // by the non-const *this.
     const_cast<GlobalValueSummaryMapTy::value_type *>(VI.getRef())
         ->second.SummaryList.push_back(std::move(Summary));
   }
 
   /// Add an original name for the value of the given GUID.
   void addOriginalName(GlobalValue::GUID ValueGUID,
                        GlobalValue::GUID OrigGUID) {
-    if (OrigGUID == 0 || ValueGUID == OrigGUID)
+    if (OrigGUID == 0 || ValueGUID == OrigGUID) {
+      errs() << "\t\tOrigGUID is zero or the same as ValueGUID [ " << OrigGUID
+             << ", " << ValueGUID << "\n";
       return;
+    }
     if (OidGuidMap.count(OrigGUID) && OidGuidMap[OrigGUID] != ValueGUID)
       OidGuidMap[OrigGUID] = 0;
     else
       OidGuidMap[OrigGUID] = ValueGUID;
+    errs() << "\t\tMap origGUID to new guid " << OrigGUID << ", " << ValueGUID
+           << "\n";
   }
 
   /// Find the summary for ValueInfo \p VI in module \p ModuleId, or nullptr if
   /// not found.
   GlobalValueSummary *findSummaryInModule(ValueInfo VI, StringRef ModuleId) const {
     auto SummaryList = VI.getSummaryList();
     auto Summary =
         llvm::find_if(SummaryList,

llvm/include/llvm/IR/ModuleSummaryIndexYAML.h

for (auto &FSum : FSums) {
               FSum.NotEligibleToImport, FSum.Live, FSum.IsLocal,
               FSum.CanAutoHide),
           /*NumInsts=*/0, FunctionSummary::FFlags{}, /*EntryCount=*/0, Refs,
           ArrayRef<FunctionSummary::EdgeTy>{}, std::move(FSum.TypeTests),
           std::move(FSum.TypeTestAssumeVCalls),
           std::move(FSum.TypeCheckedLoadVCalls),
           std::move(FSum.TypeTestAssumeConstVCalls),
           std::move(FSum.TypeCheckedLoadConstVCalls),
-          ArrayRef<FunctionSummary::ParamAccess>{}));
+          ArrayRef<FunctionSummary::ParamAccess>{}, false));
     }
   }
   static void output(IO &io, GlobalValueSummaryMapTy &V) {
     for (auto &P : V) {
       std::vector<FunctionSummaryYaml> FSums;
       for (auto &Sum : P.second.SummaryList) {
         if (auto *FSum = dyn_cast<FunctionSummary>(Sum.get())) {
           std::vector<uint64_t> Refs;

llvm/lib/Analysis/ModuleSummaryAnalysis.cpp

 
 static bool isNonVolatileStore(const Instruction *I) {
   if (const auto *SI = dyn_cast<StoreInst>(I))
     return !SI->isVolatile();
 
   return false;
 }
 
+// Returns true if `F` must be an unreachable function.
+static bool mustBeUnreachableFunction(const Function &F) {
+  if (!F.empty()) {
+    const BasicBlock &entryBlock = F.getEntryBlock();
+    if (!entryBlock.empty()) {
+      const Instruction *inst = &(*entryBlock.rbegin());
+      if (inst->getOpcode() == Instruction::Unreachable) {
+        // TODO(mingmingl): delete
+        errs() << "unreachable function: ";
+        F.dump();
+        errs() << "\n";
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
 static void computeFunctionSummary(
     ModuleSummaryIndex &Index, const Module &M, const Function &F,
     BlockFrequencyInfo *BFI, ProfileSummaryInfo *PSI, DominatorTree &DT,
     bool HasLocalsInUsedOrAsm, DenseSet<GlobalValue::GUID> &CantBePromoted,
     bool IsThinLTO,
     std::function<const StackSafetyInfo *(const Function &F)> GetSSICallback) {
   // Summary not currently supported for anonymous functions, they should
   // have been named.
static void computeFunctionSummary(
   std::vector<FunctionSummary::ParamAccess> ParamAccesses;
   if (auto *SSI = GetSSICallback(F))
     ParamAccesses = SSI->getParamAccesses(Index);
   auto FuncSummary = std::make_unique<FunctionSummary>(
       Flags, NumInsts, FunFlags, /*EntryCount=*/0, std::move(Refs),
       CallGraphEdges.takeVector(), TypeTests.takeVector(),
       TypeTestAssumeVCalls.takeVector(), TypeCheckedLoadVCalls.takeVector(),
       TypeTestAssumeConstVCalls.takeVector(),
-      TypeCheckedLoadConstVCalls.takeVector(), std::move(ParamAccesses));
+      TypeCheckedLoadConstVCalls.takeVector(), std::move(ParamAccesses),
+      mustBeUnreachableFunction(F));
   if (NonRenamableLocal)
     CantBePromoted.insert(F.getGUID());
+  errs() << "Going to add F " << F.getName()
+         << " to global value summary and its unreachable mark is "
+         << FuncSummary->isUnreachableFunction() << "\n";
   Index.addGlobalValueSummary(F, std::move(FuncSummary));
 }
 
 /// Find function pointers referenced within the given vtable initializer
 /// (or subset of an initializer) \p I. The starting offset of \p I within
 /// the vtable initializer is \p StartingOffset. Any discovered function
 /// pointers are added to \p VTableFuncs along with their cumulative offset
 /// within the initializer.
ModuleSymbolTable::CollectAsmSymbols(
                         /* HasUnknownCall */ true},
                     /*EntryCount=*/0, ArrayRef<ValueInfo>{},
                     ArrayRef<FunctionSummary::EdgeTy>{},
                     ArrayRef<GlobalValue::GUID>{},
                     ArrayRef<FunctionSummary::VFuncId>{},
                     ArrayRef<FunctionSummary::VFuncId>{},
                     ArrayRef<FunctionSummary::ConstVCall>{},
                     ArrayRef<FunctionSummary::ConstVCall>{},
-                    ArrayRef<FunctionSummary::ParamAccess>{});
+                    ArrayRef<FunctionSummary::ParamAccess>{}, false);
             Index.addGlobalValueSummary(*GV, std::move(Summary));
           } else {
             std::unique_ptr<GlobalVarSummary> Summary =
                 std::make_unique<GlobalVarSummary>(
                     GVFlags,
                     GlobalVarSummary::GVarFlags(
                         false, false, cast<GlobalVariable>(GV)->isConstant(),
                         GlobalObject::VCallVisibilityPublic),

llvm/lib/AsmParser/LLParser.cpp

bool LLParser::parseFunctionSummary(std::string Name, GlobalValue::GUID GUID,
 
   auto FS = std::make_unique<FunctionSummary>(
       GVFlags, InstCount, FFlags, /*EntryCount=*/0, std::move(Refs),
       std::move(Calls), std::move(TypeIdInfo.TypeTests),
       std::move(TypeIdInfo.TypeTestAssumeVCalls),
       std::move(TypeIdInfo.TypeCheckedLoadVCalls),
       std::move(TypeIdInfo.TypeTestAssumeConstVCalls),
       std::move(TypeIdInfo.TypeCheckedLoadConstVCalls),
-      std::move(ParamAccesses));
+      std::move(ParamAccesses), false);
 
   FS->setModulePath(ModulePath);
 
   addGlobalValueToIndex(Name, GUID, (GlobalValue::LinkageTypes)GVFlags.Linkage,
                         ID, std::move(FS));
 
   return false;
 }

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

while (true) {
     //                numrefs x valueid, n x (valueid)]
     // FS_PERMODULE_PROFILE: [valueid, flags, instcount, fflags, numrefs,
     //                        numrefs x valueid,
     //                        n x (valueid, hotness)]
     // FS_PERMODULE_RELBF: [valueid, flags, instcount, fflags, numrefs,
     //                      numrefs x valueid,
     //                      n x (valueid, relblockfreq)]
     case bitc::FS_PERMODULE:
+      dbgs() << "Mingming  FS_PERMODULE\n";
+      [[clang::fallthrough]];
     case bitc::FS_PERMODULE_RELBF:
+      dbgs() << "Mingming FS_PERMODULE_RELBF\n";
+      [[clang::fallthrough]];
     case bitc::FS_PERMODULE_PROFILE: {
+      dbgs() << "Mingming FS_PERMODULE_PROFILE\n";
       unsigned ValueID = Record[0];
       uint64_t RawFlags = Record[1];
       unsigned InstCount = Record[2];
       uint64_t RawFunFlags = 0;
       unsigned NumRefs = Record[3];
       unsigned NumRORefs = 0, NumWORefs = 0;
+      bool isUnreachableFunc = false;
       int RefListStartIndex = 4;
       if (Version >= 4) {
         RawFunFlags = Record[3];
         NumRefs = Record[4];
         RefListStartIndex = 5;
         if (Version >= 5) {
           NumRORefs = Record[5];
           RefListStartIndex = 6;
           if (Version >= 7) {
             NumWORefs = Record[6];
-            RefListStartIndex = 7;
+            isUnreachableFunc = (Record[7] == 1) ? true : false;
+            RefListStartIndex = 8;
           }
         }
       }
 
       auto Flags = getDecodedGVSummaryFlags(RawFlags, Version);
       // The module path string ref set in the summary must be owned by the
       // index's module string table. Since we don't have a module path
       // string table section in the per-module index, we create a single
case bitc::FS_PERMODULE_PROFILE: {
       setSpecialRefs(Refs, NumRORefs, NumWORefs);
       auto FS = std::make_unique<FunctionSummary>(
           Flags, InstCount, getDecodedFFlags(RawFunFlags), /*EntryCount=*/0,
           std::move(Refs), std::move(Calls), std::move(PendingTypeTests),
           std::move(PendingTypeTestAssumeVCalls),
           std::move(PendingTypeCheckedLoadVCalls),
           std::move(PendingTypeTestAssumeConstVCalls),
           std::move(PendingTypeCheckedLoadConstVCalls),
-          std::move(PendingParamAccesses));
+          std::move(PendingParamAccesses), isUnreachableFunc);
       auto VIAndOriginalGUID = getValueInfoFromValueId(ValueID);
       FS->setModulePath(getThisModule()->first());
       FS->setOriginalName(VIAndOriginalGUID.second);
       TheIndex.addGlobalValueSummary(VIAndOriginalGUID.first, std::move(FS));
       break;
     }
     // FS_ALIAS: [valueid, flags, valueid]
     // Aliases must be emitted (and parsed) after all FS_PERMODULE entries, as
case bitc::FS_PERMODULE_GLOBALVAR_INIT_REFS: {
       FS->setOriginalName(GUID.second);
       TheIndex.addGlobalValueSummary(GUID.first, std::move(FS));
       break;
     }
     // FS_PERMODULE_VTABLE_GLOBALVAR_INIT_REFS: [valueid, flags, varflags,
     //                        numrefs, numrefs x valueid,
     //                        n x (valueid, offset)]
     case bitc::FS_PERMODULE_VTABLE_GLOBALVAR_INIT_REFS: {
+      dbgs() << "Mingming FS_PERMODULE_VTABLE_GLOBALVAR_INIT_REFS"
+             << "\n";
       unsigned ValueID = Record[0];
       uint64_t RawFlags = Record[1];
       GlobalVarSummary::GVarFlags GVF = getDecodedGVarFlags(Record[2]);
       unsigned NumRefs = Record[3];
       unsigned RefListStartIndex = 4;
       unsigned VTableListStartIndex = RefListStartIndex + NumRefs;
       auto Flags = getDecodedGVSummaryFlags(RawFlags, Version);
       std::vector<ValueInfo> Refs = makeRefList(
case bitc::FS_COMBINED_PROFILE: {
       uint64_t ModuleId = Record[1];
       uint64_t RawFlags = Record[2];
       unsigned InstCount = Record[3];
       uint64_t RawFunFlags = 0;
       uint64_t EntryCount = 0;
       unsigned NumRefs = Record[4];
       unsigned NumRORefs = 0, NumWORefs = 0;
       int RefListStartIndex = 5;
+      bool isUnreachableFunction = false;
 
+      dbgs() << "Mingming Version is " << Version << "\n";
       if (Version >= 4) {
         RawFunFlags = Record[4];
         RefListStartIndex = 6;
         size_t NumRefsIndex = 5;
         if (Version >= 5) {
           unsigned NumRORefsOffset = 1;
           RefListStartIndex = 7;
           if (Version >= 6) {
             NumRefsIndex = 6;
             EntryCount = Record[5];
             RefListStartIndex = 8;
             if (Version >= 7) {
-              RefListStartIndex = 9;
+              RefListStartIndex = 10;
               NumWORefs = Record[8];
-              NumRORefsOffset = 2;
+              isUnreachableFunction = (Record[9] == 1) ? true : false;
+              NumRORefsOffset = 3;
             }
           }
           NumRORefs = Record[RefListStartIndex - NumRORefsOffset];
         }
         NumRefs = Record[NumRefsIndex];
       }
 
+      dbgs() << "Mingming func is unreachable function "
+             << isUnreachableFunction << "\n";
       auto Flags = getDecodedGVSummaryFlags(RawFlags, Version);
       int CallGraphEdgeStartIndex = RefListStartIndex + NumRefs;
       assert(Record.size() >= RefListStartIndex + NumRefs &&
              "Record size inconsistent with number of references");
       std::vector<ValueInfo> Refs = makeRefList(
           ArrayRef<uint64_t>(Record).slice(RefListStartIndex, NumRefs));
       bool HasProfile = (BitCode == bitc::FS_COMBINED_PROFILE);
       std::vector<FunctionSummary::EdgeTy> Edges = makeCallList(
           ArrayRef<uint64_t>(Record).slice(CallGraphEdgeStartIndex),
           IsOldProfileFormat, HasProfile, false);
       ValueInfo VI = getValueInfoFromValueId(ValueID).first;
       setSpecialRefs(Refs, NumRORefs, NumWORefs);
       auto FS = std::make_unique<FunctionSummary>(
           Flags, InstCount, getDecodedFFlags(RawFunFlags), EntryCount,
           std::move(Refs), std::move(Edges), std::move(PendingTypeTests),
           std::move(PendingTypeTestAssumeVCalls),
           std::move(PendingTypeCheckedLoadVCalls),
           std::move(PendingTypeTestAssumeConstVCalls),
           std::move(PendingTypeCheckedLoadConstVCalls),
-          std::move(PendingParamAccesses));
+          std::move(PendingParamAccesses), isUnreachableFunction);
       LastSeenSummary = FS.get();
       LastSeenGUID = VI.getGUID();
       FS->setModulePath(ModuleIdMap[ModuleId]);
       TheIndex.addGlobalValueSummary(VI, std::move(FS));
       break;
     }
     // FS_COMBINED_ALIAS: [valueid, modid, flags, valueid]
     // Aliases must be emitted (and parsed) after all FS_COMBINED entries, as

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

 #include "llvm/IR/Value.h"
 #include "llvm/IR/ValueSymbolTable.h"
 #include "llvm/MC/StringTableBuilder.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Object/IRSymtab.h"
 #include "llvm/Support/AtomicOrdering.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Debug.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/SHA1.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
void ModuleBitcodeWriterBase::writePerModuleFunctionSummaryRecord(
 
   FunctionSummary *FS = cast<FunctionSummary>(Summary);
 
   writeFunctionTypeMetadataRecords(
       Stream, FS, [&](const ValueInfo &VI) -> Optional<unsigned> {
         return {VE.getValueID(VI.getValue())};
       });
 
+  dbgs() << "Mingming function name is ";
+  F.dump();
+  dbgs() << "\n";
   auto SpecialRefCnts = FS->specialRefCounts();
+  dbgs() << "Mingming EncodedGVSummary index is " << NameVals.size() << "\n";
   NameVals.push_back(getEncodedGVSummaryFlags(FS->flags()));
+  dbgs() << "Mingming instCount index is " << NameVals.size() << "\n";
   NameVals.push_back(FS->instCount());
+  dbgs() << "Mingming fflags index is " << NameVals.size() << "\n";
   NameVals.push_back(getEncodedFFlags(FS->fflags()));
+  dbgs() << "Mingming refCount index is " << NameVals.size() << "\n";
   NameVals.push_back(FS->refs().size());
+  dbgs() << "Mingming rorefcnt index is " << NameVals.size() << "\n";
   NameVals.push_back(SpecialRefCnts.first);  // rorefcnt
+  dbgs() << "Mingming worefcnt index is " << NameVals.size() << "\n";
   NameVals.push_back(SpecialRefCnts.second); // worefcnt
 
+  dbgs() << "Mingming isUnreachable function index is " << NameVals.size()
+         << " and value is " << FS->isUnreachableFunction() << "\n";
+  NameVals.push_back(FS->isUnreachableFunction() ? 1 : 0);
+
   for (auto &RI : FS->refs())
     NameVals.push_back(VE.getValueID(RI.getValue()));
 
   bool HasProfileData =
       F.hasProfileData() || ForceSummaryEdgesCold != FunctionSummary::FSHT_None;
   for (auto &ECI : FS->calls()) {
     NameVals.push_back(getValueId(ECI.first));
     if (HasProfileData)

llvm/lib/IR/AsmWriter.cpp

static const char *getVisibilityName(GlobalValue::VisibilityTypes Vis) {
   case GlobalValue::ProtectedVisibility:
     return "protected";
   }
   llvm_unreachable("invalid visibility");
 }
 
 void AssemblyWriter::printFunctionSummary(const FunctionSummary *FS) {
   Out << ", insts: " << FS->instCount();
+  Out << ", unreachable: " << FS->isUnreachableFunction();
   if (FS->fflags().anyFlagSet())
     Out << ", " << FS->fflags();
 
   if (!FS->calls().empty()) {
     Out << ", calls: (";
     FieldSeparator IFS;
     for (auto &Call : FS->calls()) {
       Out << IFS;

llvm/lib/Transforms/IPO/WholeProgramDevirt.cpp

struct DevirtModule {
   void scanTypeCheckedLoadUsers(Function *TypeCheckedLoadFunc);
 
   void buildTypeIdentifierMap(
       std::vector<VTableBits> &Bits,
       DenseMap<Metadata *, std::set<TypeMemberInfo>> &TypeIdMap);
   bool
   tryFindVirtualCallTargets(std::vector<VirtualCallTarget> &TargetsForSlot,
                             const std::set<TypeMemberInfo> &TypeMemberInfos,
-                            uint64_t ByteOffset);
+                            uint64_t ByteOffset,
+                            ModuleSummaryIndex *ExportSummary);
 
   void applySingleImplDevirt(VTableSlotInfo &SlotInfo, Constant *TheFn,
                              bool &IsExported);
   bool trySingleImplDevirt(ModuleSummaryIndex *ExportSummary,
                            MutableArrayRef<VirtualCallTarget> TargetsForSlot,
                            VTableSlotInfo &SlotInfo,
                            WholeProgramDevirtResolution *Res);
 
struct DevirtModule {
   bool run();
 
   // Lower the module using the action and summary passed as command line
   // arguments. For testing purposes only.
   static bool
   runForTesting(Module &M, function_ref<AAResults &(Function &)> AARGetter,
                 function_ref<OptimizationRemarkEmitter &(Function *)> OREGetter,
                 function_ref<DominatorTree &(Function &)> LookupDomTree);
+
+  // Returns true if the function is unreachable from all summaries.
+  static bool mustBeUnreachableFunction(Function *TheFn,
+                                        ModuleSummaryIndex *exportSummary);
 };
 
 struct DevirtIndex {
   ModuleSummaryIndex &ExportSummary;
   // The set in which to record GUIDs exported from their module by
   // devirtualization, used by client to ensure they are not internalized.
   std::set<GlobalValue::GUID> &ExportedGUIDs;
   // A map in which to record the information necessary to locate the WPD
if (StringRef(ClWriteSummary).endswith(".bc")) {
       yaml::Output Out(OS);
       Out << *Summary;
     }
   }
 
   return Changed;
 }
 
+bool DevirtModule::mustBeUnreachableFunction(
+    Function *TheFn, ModuleSummaryIndex *ExportSummary) {
+  assert(((TheFn != nullptr) && (ExportSummary != nullptr)) &&
+         "TheFn and ExportSummary must not be nullptr");
+  errs() << "Func GUID is " << TheFn->getGUID() << "\n";
+
+  errs() << "Func current identifier is " << TheFn->getGlobalIdentifier()
+         << "\n";
+  const std::string rewrittenFuncGlobalIdentifier =
+      GlobalValue::getGlobalIdentifier(TheFn->getName(),
+                                       GlobalValue::ExternalLinkage,
+                                       TheFn->getParent()->getSourceFileName());
+  errs() << "rewritten identifier is " << rewrittenFuncGlobalIdentifier << "\n";
+  errs() << "GUID before is "
+         << GlobalValue::getGUID(TheFn->getGlobalIdentifier())
+         << " and after is "
+         << GlobalValue::getGUID(rewrittenFuncGlobalIdentifier) << "\n";
+
+  if (ValueInfo TheFnVI = ExportSummary->getValueInfo(
+          GlobalValue::getGUID(rewrittenFuncGlobalIdentifier))) {
+    bool AllSummariesAreFunctionSummary = true;
+    bool AllFunctionSummariesIndicateUnreachable = true;
+    for (auto &Summary : TheFnVI.getSummaryList()) {
+      if (auto *FS = dyn_cast<FunctionSummary>(Summary.get())) {
+        if (!FS->isUnreachableFunction()) {
+          AllFunctionSummariesIndicateUnreachable = false;
+          break;
+        }
+      } else {
+        AllSummariesAreFunctionSummary = false;
+        break;
+      }
+    }
+    if (AllSummariesAreFunctionSummary &&
+        AllFunctionSummariesIndicateUnreachable) {
+      return true;
+    }
+  } else {
+    errs() << "No value info for func: ";
+    TheFn->dump();
+  }
+  return false;
+}
+
 void DevirtModule::buildTypeIdentifierMap(
     std::vector<VTableBits> &Bits,
     DenseMap<Metadata *, std::set<TypeMemberInfo>> &TypeIdMap) {
   DenseMap<GlobalVariable *, VTableBits *> GVToBits;
   Bits.reserve(M.getGlobalList().size());
   SmallVector<MDNode *, 2> Types;
   for (GlobalVariable &GV : M.globals()) {
     Types.clear();
for (MDNode *Type : Types) {
 
       TypeIdMap[TypeID].insert({BitsPtr, Offset});
     }
   }
 }
 
 bool DevirtModule::tryFindVirtualCallTargets(
     std::vector<VirtualCallTarget> &TargetsForSlot,
-    const std::set<TypeMemberInfo> &TypeMemberInfos, uint64_t ByteOffset) {
+    const std::set<TypeMemberInfo> &TypeMemberInfos, uint64_t ByteOffset,
+    ModuleSummaryIndex *ExportSummary) {
+  errs() << "DevirtModule::tryFindVirtualCallTargets\n";
+  ExportSummary->dump();
   for (const TypeMemberInfo &TM : TypeMemberInfos) {
     if (!TM.Bits->GV->isConstant())
       return false;
 
     // We cannot perform whole program devirtualization analysis on a vtable
     // with public LTO visibility.
     if (TM.Bits->GV->getVCallVisibility() ==
         GlobalObject::VCallVisibilityPublic)
for (const TypeMemberInfo &TM : TypeMemberInfos) {
     if (FunctionsToSkip.match(Fn->getName()))
       return false;
 
     // We can disregard __cxa_pure_virtual as a possible call target, as
     // calls to pure virtuals are UB.
     if (Fn->getName() == "__cxa_pure_virtual")
       continue;
 
+    if (mustBeUnreachableFunction(Fn, ExportSummary)) {
+      errs() << "Function " << Fn->getName() << " is unreachable\n";
+      continue;
+    }
+    if (Fn->getName() == "_ZN4BaseD0Ev") {
+      errs() << "not skipping skip _ZN4BaseD0Ev\n";
+      // continue;
+    }
+
     TargetsForSlot.push_back({Fn, &TM});
   }
 
   // Give up if we couldn't find any targets.
   return !TargetsForSlot.empty();
 }
 
 bool DevirtIndex::tryFindVirtualCallTargets(
for (auto &P : SlotInfo.ConstCSInfo)
     AddCalls(P.second);
   return IsExported;
 }
 
 bool DevirtModule::trySingleImplDevirt(
     ModuleSummaryIndex *ExportSummary,
     MutableArrayRef<VirtualCallTarget> TargetsForSlot, VTableSlotInfo &SlotInfo,
     WholeProgramDevirtResolution *Res) {
+  ExportSummary->dump();
   // See if the program contains a single implementation of this virtual
   // function.
   Function *TheFn = TargetsForSlot[0].Fn;
-  for (auto &&Target : TargetsForSlot)
-    if (TheFn != Target.Fn)
+  errs() << "First func: ";
+  TheFn->dump();
+  errs() << "\n";
+  for (auto &&Target : TargetsForSlot) {
+    errs() << "Target func: ";
+    Target.Fn->dump();
+    errs() << "\n";
+    if (mustBeUnreachableFunction(Target.Fn, ExportSummary)) {
+      errs() << "\t\t\t???Found an unreachable function "
+             << Target.Fn->getName() << "\n";
+      continue;
+    }
+    if (TheFn != Target.Fn) {
       return false;
+    }
+  }
 
   // If so, update each call site to call that implementation directly.
   if (RemarksEnabled)
     TargetsForSlot[0].WasDevirt = true;
 
   bool IsExported = false;
   applySingleImplDevirt(SlotInfo, TheFn, IsExported);
   if (!IsExported)
     return false;
 
   // If the only implementation has local linkage, we must promote to external
   // to make it visible to thin LTO objects. We can only get here during the
   // ThinLTO export phase.
   if (TheFn->hasLocalLinkage()) {
+    errs() << TheFn->getName() << " has local linkage\n";
     std::string NewName = (TheFn->getName() + ".llvm.merged").str();
 
     // Since we are renaming the function, any comdats with the same name must
     // also be renamed. This is required when targeting COFF, as the comdat name
     // must match one of the names of the symbols in the comdat.
     if (Comdat *C = TheFn->getComdat()) {
       if (C->getName() == TheFn->getName()) {
         Comdat *NewC = M.getOrInsertComdat(NewName);
for (auto &&U : NumUnsafeUsesForTypeTest) {
     if (U.second == 0) {
       U.first->replaceAllUsesWith(True);
       U.first->eraseFromParent();
     }
   }
 }
 
 bool DevirtModule::run() {
+  errs() << "devirt module::run\n";
   // If only some of the modules were split, we cannot correctly perform
   // this transformation. We already checked for the presense of type tests
   // with partially split modules during the thin link, and would have emitted
   // an error if any were found, so here we can simply return.
   if ((ExportSummary && ExportSummary->partiallySplitLTOUnits()) ||
       (ImportSummary && ImportSummary->partiallySplitLTOUnits()))
     return false;
 
if (ExportSummary && isa<MDString>(S.first.TypeID) &&
       // a global's type metadata, the TypeIdMap entry set will be empty, and
       // we don't want to create an entry (with the default Unknown type
       // resolution), which can prevent detection of the Unsat.
       Res = &ExportSummary
                  ->getOrInsertTypeIdSummary(
                      cast<MDString>(S.first.TypeID)->getString())
                  .WPDRes[S.first.ByteOffset];
     if (tryFindVirtualCallTargets(TargetsForSlot, TypeMemberInfos,
-                                  S.first.ByteOffset)) {
+                                  S.first.ByteOffset, ExportSummary)) {
 
       if (!trySingleImplDevirt(ExportSummary, TargetsForSlot, S.second, Res)) {
         DidVirtualConstProp |=
             tryVirtualConstProp(TargetsForSlot, S.second, Res, S.first);
 
         tryICallBranchFunnel(TargetsForSlot, S.second, Res, S.first);
       }