[StackSafety] Control paramer access summary from frontend

[vitalybuka]

Summary

MAYBE? let me know if you think we need it. I'll improve the patch.

This way we don't need to rely on MTE attributes and let
clang to controll when to include this info into summary.

Depends on D81242.

[eugenis]

I like this in principle. Makes a lot more sense to control this directly from clang than to rely on function attributes.

llvm/lib/Bitcode/Writer/BitcodeWriterPass.cpp

31

What does this chunk do?

llvm/lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp

456

Why do you need to turn ModuleSummaryIndex into a getter?

clang/lib/CodeGen/BackendUtil.cpp

if (CodeGenOpts.PrepareForThinLTO && !CodeGenOpts.DisableLLVMPasses) {
       if (!CodeGenOpts.ThinLinkBitcodeFile.empty()) {
         ThinLinkOS = openOutputFile(CodeGenOpts.ThinLinkBitcodeFile);
         if (!ThinLinkOS)
           return;
       }
       TheModule->addModuleFlag(Module::Error, "EnableSplitLTOUnit",
                                CodeGenOpts.EnableSplitLTOUnit);
       PerModulePasses.add(createWriteThinLTOBitcodePass(
-          *OS, ThinLinkOS ? &ThinLinkOS->os() : nullptr));
+          *OS, ThinLinkOS ? &ThinLinkOS->os() : nullptr,
+          CodeGenOpts.OptimizationLevel > 0 &&
+              LangOpts.Sanitize.has(SanitizerKind::MemTag)));
     } else {
       // Emit a module summary by default for Regular LTO except for ld64
       // targets
       bool EmitLTOSummary =
           (CodeGenOpts.PrepareForLTO &&
            !CodeGenOpts.DisableLLVMPasses &&
            llvm::Triple(TheModule->getTargetTriple()).getVendor() !=
                llvm::Triple::Apple);
       if (EmitLTOSummary) {
         if (!TheModule->getModuleFlag("ThinLTO"))
           TheModule->addModuleFlag(Module::Error, "ThinLTO", uint32_t(0));
         TheModule->addModuleFlag(Module::Error, "EnableSplitLTOUnit",
                                  uint32_t(1));
       }
 
       PerModulePasses.add(createBitcodeWriterPass(
-          *OS, CodeGenOpts.EmitLLVMUseLists, EmitLTOSummary));
+          *OS, CodeGenOpts.EmitLLVMUseLists, EmitLTOSummary, false,
+          EmitLTOSummary && CodeGenOpts.OptimizationLevel > 0 &&
+              LangOpts.Sanitize.has(SanitizerKind::MemTag)));
     }
     break;
 
   case Backend_EmitLL:
     PerModulePasses.add(
         createPrintModulePass(*OS, "", CodeGenOpts.EmitLLVMUseLists));
     break;
 
case Backend_EmitBC:
     if (CodeGenOpts.PrepareForThinLTO && !CodeGenOpts.DisableLLVMPasses) {
       if (!CodeGenOpts.ThinLinkBitcodeFile.empty()) {
         ThinLinkOS = openOutputFile(CodeGenOpts.ThinLinkBitcodeFile);
         if (!ThinLinkOS)
           return;
       }
       TheModule->addModuleFlag(Module::Error, "EnableSplitLTOUnit",
                                CodeGenOpts.EnableSplitLTOUnit);
-      MPM.addPass(ThinLTOBitcodeWriterPass(*OS, ThinLinkOS ? &ThinLinkOS->os()
-                                                           : nullptr));
+      MPM.addPass(ThinLTOBitcodeWriterPass(
+          *OS, ThinLinkOS ? &ThinLinkOS->os() : nullptr,
+          CodeGenOpts.OptimizationLevel > 0 &&
+              LangOpts.Sanitize.has(SanitizerKind::MemTag)));
     } else {
       // Emit a module summary by default for Regular LTO except for ld64
       // targets
       bool EmitLTOSummary =
           (CodeGenOpts.PrepareForLTO &&
            !CodeGenOpts.DisableLLVMPasses &&
            llvm::Triple(TheModule->getTargetTriple()).getVendor() !=
                llvm::Triple::Apple);

llvm/include/llvm/Analysis/ModuleSummaryAnalysis.h

 /// If operating within a pass manager which has defined ways to compute the \c
 /// BlockFrequencyInfo for a given function, that can be provided via
 /// a std::function callback. Otherwise, this routine will manually construct
 /// that information.
 ModuleSummaryIndex buildModuleSummaryIndex(
     const Module &M,
     std::function<BlockFrequencyInfo *(const Function &F)> GetBFICallback,
     ProfileSummaryInfo *PSI,
-    std::function<const StackSafetyInfo *(const Function &F)> GetSSICallback =
-        [](const Function &F) -> const StackSafetyInfo * { return nullptr; });
+    std::function<const StackSafetyInfo *(const Function &F)> GetSSICallback);
 
 /// Analysis pass to provide the ModuleSummaryIndex object.
 class ModuleSummaryIndexAnalysis
     : public AnalysisInfoMixin<ModuleSummaryIndexAnalysis> {
   friend AnalysisInfoMixin<ModuleSummaryIndexAnalysis>;
 
   static AnalysisKey Key;
 
 public:
-  using Result = ModuleSummaryIndex;
+  using Result = std::function<ModuleSummaryIndex(bool StackSafety)>;
 
   Result run(Module &M, ModuleAnalysisManager &AM);
 };
 
 /// Legacy wrapper pass to provide the ModuleSummaryIndex object.
 class ModuleSummaryIndexWrapperPass : public ModulePass {
-  Optional<ModuleSummaryIndex> Index;
-
 public:
   static char ID;
+  std::function<ModuleSummaryIndex(bool StackSafety)> Getter;
 
-  ModuleSummaryIndexWrapperPass();
+  explicit ModuleSummaryIndexWrapperPass();
 
   /// Get the index built by pass
-  ModuleSummaryIndex &getIndex() { return *Index; }
-  const ModuleSummaryIndex &getIndex() const { return *Index; }
+  ModuleSummaryIndex getIndex(bool StackSafety) { return Getter(StackSafety); }
 
   bool runOnModule(Module &M) override;
-  bool doFinalization(Module &M) override;
   void getAnalysisUsage(AnalysisUsage &AU) const override;
 };
 
 //===--------------------------------------------------------------------===//
 //
 // createModuleSummaryIndexWrapperPass - This pass builds a ModuleSummaryIndex
 // object for the module, to be written to bitcode or LLVM assembly.
 //

llvm/include/llvm/Analysis/StackSafetyAnalysis.h

public:
   const StackSafetyGlobalInfo &getResult() const { return SSGI; }
 
   void print(raw_ostream &O, const Module *M) const override;
   void getAnalysisUsage(AnalysisUsage &AU) const override;
 
   bool runOnModule(Module &M) override;
 };
 
-bool needsParamAccessSummary(const Module &M);
-
 void processParamAccessSummary(ModuleSummaryIndex &Index);
 
 } // end namespace llvm
 
 #endif // LLVM_ANALYSIS_STACKSAFETYANALYSIS_H

llvm/include/llvm/Bitcode/BitcodeWriterPass.h

 /// reproduced when deserialized.
 ///
 /// If \c EmitSummaryIndex, emit the summary index (currently for use in ThinLTO
 /// optimization).
 ///
 /// If \c EmitModuleHash, compute and emit the module hash in the bitcode
 /// (currently for use in ThinLTO incremental build).
 ModulePass *createBitcodeWriterPass(raw_ostream &Str,
-                                    bool ShouldPreserveUseListOrder = false,
-                                    bool EmitSummaryIndex = false,
-                                    bool EmitModuleHash = false);
+                                    bool ShouldPreserveUseListOrder,
+                                    bool EmitSummaryIndex, bool EmitModuleHash,
+                                    bool StackSafety);
 
 /// Check whether a pass is a BitcodeWriterPass.
 bool isBitcodeWriterPass(Pass *P);
 
 /// Pass for writing a module of IR out to a bitcode file.
 ///
 /// Note that this is intended for use with the new pass manager. To construct
 /// a pass for the legacy pass manager, use the function above.

llvm/include/llvm/Transforms/IPO.h

 //===----------------------------------------------------------------------===//
 // SampleProfilePass - Loads sample profile data from disk and generates
 // IR metadata to reflect the profile.
 ModulePass *createSampleProfileLoaderPass();
 ModulePass *createSampleProfileLoaderPass(StringRef Name);
 
 /// Write ThinLTO-ready bitcode to Str.
 ModulePass *createWriteThinLTOBitcodePass(raw_ostream &Str,
-                                          raw_ostream *ThinLinkOS = nullptr);
+                                          raw_ostream *ThinLinkOS,
+                                          bool StackSafety = false);
 
 } // End llvm namespace
 
 #endif

llvm/include/llvm/Transforms/IPO/ThinLTOBitcodeWriter.h

 #include <llvm/Support/raw_ostream.h>
 
 namespace llvm {
 
 class ThinLTOBitcodeWriterPass
     : public PassInfoMixin<ThinLTOBitcodeWriterPass> {
   raw_ostream &OS;
   raw_ostream *ThinLinkOS;
+  bool StackSafety;
 
 public:
   // Writes bitcode to OS. Also write thin link file to ThinLinkOS, if
   // it's not nullptr.
-  ThinLTOBitcodeWriterPass(raw_ostream &OS, raw_ostream *ThinLinkOS)
-      : OS(OS), ThinLinkOS(ThinLinkOS) {}
+  ThinLTOBitcodeWriterPass(raw_ostream &OS, raw_ostream *ThinLinkOS,
+                           bool StackSafety)
+      : OS(OS), ThinLinkOS(ThinLinkOS), StackSafety(StackSafety) {}
 
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
 };
 
 } // namespace llvm
 
 #endif

llvm/lib/Analysis/ModuleSummaryAnalysis.cpp

if (!ModuleSummaryDotFile.empty()) {
     Index.exportToDot(OSDot, {});
   }
 
   return Index;
 }
 
 AnalysisKey ModuleSummaryIndexAnalysis::Key;
 
-ModuleSummaryIndex
+ModuleSummaryIndexAnalysis::Result
 ModuleSummaryIndexAnalysis::run(Module &M, ModuleAnalysisManager &AM) {
   ProfileSummaryInfo &PSI = AM.getResult<ProfileSummaryAnalysis>(M);
   auto &FAM = AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
-  bool NeedSSI = needsParamAccessSummary(M);
+  return [&](bool StackSafety) -> ModuleSummaryIndex {
     return buildModuleSummaryIndex(
         M,
         [&FAM](const Function &F) {
           return &FAM.getResult<BlockFrequencyAnalysis>(
               *const_cast<Function *>(&F));
         },
         &PSI,
-      [&FAM, NeedSSI](const Function &F) -> const StackSafetyInfo * {
-        return NeedSSI ? &FAM.getResult<StackSafetyAnalysis>(
-                             const_cast<Function &>(F))
-                       : nullptr;
+        [&](const Function &F) -> const StackSafetyInfo * {
+          return (StackSafety /*|| ModuleSummaryStackSafety*/)
+                     ? &FAM.getResult<StackSafetyAnalysis>(
         });
+  };
 }
 
 char ModuleSummaryIndexWrapperPass::ID = 0;
 
 INITIALIZE_PASS_BEGIN(ModuleSummaryIndexWrapperPass, "module-summary-analysis",
                       "Module Summary Analysis", false, true)
 INITIALIZE_PASS_DEPENDENCY(BlockFrequencyInfoWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(ProfileSummaryInfoWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(StackSafetyInfoWrapperPass)
 INITIALIZE_PASS_END(ModuleSummaryIndexWrapperPass, "module-summary-analysis",
                     "Module Summary Analysis", false, true)
 
 ModulePass *llvm::createModuleSummaryIndexWrapperPass() {
   return new ModuleSummaryIndexWrapperPass();
 }
 
 ModuleSummaryIndexWrapperPass::ModuleSummaryIndexWrapperPass()
     : ModulePass(ID) {
   initializeModuleSummaryIndexWrapperPassPass(*PassRegistry::getPassRegistry());
 }
 
 bool ModuleSummaryIndexWrapperPass::runOnModule(Module &M) {
+  Getter = [this, &M](bool StackSafety) {
     auto *PSI = &getAnalysis<ProfileSummaryInfoWrapperPass>().getPSI();
-  bool NeedSSI = needsParamAccessSummary(M);
-  Index.emplace(buildModuleSummaryIndex(
+    return buildModuleSummaryIndex(
         M,
         [this](const Function &F) {
           return &(this->getAnalysis<BlockFrequencyInfoWrapperPass>(
                            *const_cast<Function *>(&F))
                        .getBFI());
         },
         PSI,
         [&](const Function &F) -> const StackSafetyInfo * {
-        return NeedSSI ? &getAnalysis<StackSafetyInfoWrapperPass>(
+          return StackSafety ? &getAnalysis<StackSafetyInfoWrapperPass>(
                                     const_cast<Function &>(F))
                                     .getResult()
                              : nullptr;
-      }));
-  return false;
-}
-
-bool ModuleSummaryIndexWrapperPass::doFinalization(Module &M) {
-  Index.reset();
+        });
+  };
   return false;
 }
 
 void ModuleSummaryIndexWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.setPreservesAll();
   AU.addRequired<BlockFrequencyInfoWrapperPass>();
   AU.addRequired<ProfileSummaryInfoWrapperPass>();
   AU.addRequired<StackSafetyInfoWrapperPass>();

llvm/lib/Analysis/StackSafetyAnalysis.cpp

const StackSafetyGlobalInfo::InfoTy &StackSafetyGlobalInfo::getInfo() const {
   }
   return *Info;
 }
 
 // Converts a StackSafetyFunctionInfo to the relevant FunctionSummary
 // constructor fields
 std::vector<FunctionSummary::ParamAccess>
 StackSafetyInfo::getParamAccesses() const {
-  assert(needsParamAccessSummary(*F->getParent()));
-
   std::vector<FunctionSummary::ParamAccess> ParamAccesses;
   for (const auto &KV : getInfo().Info.Params) {
     auto &PS = KV.second;
     if (PS.Range.isFullSet())
       continue;
 
     ParamAccesses.emplace_back(KV.first, PS.Range);
     FunctionSummary::ParamAccess &Param = ParamAccesses.back();
bool StackSafetyGlobalInfoWrapperPass::runOnModule(Module &M) {
   SSGI = {&M,
           [this](Function &F) -> const StackSafetyInfo & {
             return getAnalysis<StackSafetyInfoWrapperPass>(F).getResult();
           },
           ImportSummary};
   return false;
 }
 
-bool llvm::needsParamAccessSummary(const Module &M) {
-  if (StackSafetyRun)
-    return true;
-  for (auto &F : M.functions())
-    if (F.hasFnAttribute(Attribute::SanitizeMemTag))
-      return true;
-  return false;
-}
-
 void llvm::processParamAccessSummary(ModuleSummaryIndex &Index) {
   const ConstantRange FullSet(FunctionSummary::ParamAccess::RangeWidth, true);
   std::map<const FunctionSummary *, FunctionInfo<FunctionSummary>> Functions;
 
   // Convert the ModuleSummaryIndex to a FunctionMap
   for (auto &GVS : Index) {
     for (auto &GV : GVS.second.SummaryList) {
       FunctionSummary *FS = dyn_cast<FunctionSummary>(GV.get());

llvm/lib/Bitcode/Writer/BitcodeWriterPass.cpp

 #include "llvm/Bitcode/BitcodeWriter.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Pass.h"
 using namespace llvm;
 
 PreservedAnalyses BitcodeWriterPass::run(Module &M, ModuleAnalysisManager &AM) {
-  const ModuleSummaryIndex *Index =
-      EmitSummaryIndex ? &(AM.getResult<ModuleSummaryIndexAnalysis>(M))
-                       : nullptr;
-  WriteBitcodeToFile(M, OS, ShouldPreserveUseListOrder, Index, EmitModuleHash);
+  if (EmitSummaryIndex) {
+    ModuleSummaryIndex Index =
+        AM.getResult<ModuleSummaryIndexAnalysis>(M)(false);
+    WriteBitcodeToFile(M, OS, ShouldPreserveUseListOrder, &Index,
+                       EmitModuleHash);
+  } else {
+    WriteBitcodeToFile(M, OS, ShouldPreserveUseListOrder, nullptr,
+                       EmitModuleHash);
+  }
   return PreservedAnalyses::all();
 }
 
 namespace {
   class WriteBitcodePass : public ModulePass {
     raw_ostream &OS; // raw_ostream to print on
     bool ShouldPreserveUseListOrder;
     bool EmitSummaryIndex;
     bool EmitModuleHash;
+    bool StackSafety;
 
   public:
     static char ID; // Pass identification, replacement for typeid
     WriteBitcodePass() : ModulePass(ID), OS(dbgs()) {
       initializeWriteBitcodePassPass(*PassRegistry::getPassRegistry());
     }
 
     explicit WriteBitcodePass(raw_ostream &o, bool ShouldPreserveUseListOrder,
-                              bool EmitSummaryIndex, bool EmitModuleHash)
+                              bool EmitSummaryIndex, bool EmitModuleHash,
+                              bool StackSafety)
         : ModulePass(ID), OS(o),
           ShouldPreserveUseListOrder(ShouldPreserveUseListOrder),
-          EmitSummaryIndex(EmitSummaryIndex), EmitModuleHash(EmitModuleHash) {
+          EmitSummaryIndex(EmitSummaryIndex), EmitModuleHash(EmitModuleHash),
+          StackSafety(StackSafety) {
       initializeWriteBitcodePassPass(*PassRegistry::getPassRegistry());
     }
 
     StringRef getPassName() const override { return "Bitcode Writer"; }
 
     bool runOnModule(Module &M) override {
-      const ModuleSummaryIndex *Index =
-          EmitSummaryIndex
-              ? &(getAnalysis<ModuleSummaryIndexWrapperPass>().getIndex())
-              : nullptr;
-      WriteBitcodeToFile(M, OS, ShouldPreserveUseListOrder, Index,
+      if (EmitSummaryIndex) {
+        ModuleSummaryIndex Index =
+            getAnalysis<ModuleSummaryIndexWrapperPass>().getIndex(StackSafety);
+        WriteBitcodeToFile(M, OS, ShouldPreserveUseListOrder, &Index,
                            EmitModuleHash);
+      } else {
+        WriteBitcodeToFile(M, OS, ShouldPreserveUseListOrder, nullptr,
+                           EmitModuleHash);
+      }
       return false;
     }
     void getAnalysisUsage(AnalysisUsage &AU) const override {
       AU.setPreservesAll();
       if (EmitSummaryIndex)
         AU.addRequired<ModuleSummaryIndexWrapperPass>();
     }
   };
 }
 
 char WriteBitcodePass::ID = 0;
 INITIALIZE_PASS_BEGIN(WriteBitcodePass, "write-bitcode", "Write Bitcode", false,
                       true)
 INITIALIZE_PASS_DEPENDENCY(ModuleSummaryIndexWrapperPass)
 INITIALIZE_PASS_END(WriteBitcodePass, "write-bitcode", "Write Bitcode", false,
                     true)
 
 ModulePass *llvm::createBitcodeWriterPass(raw_ostream &Str,
                                           bool ShouldPreserveUseListOrder,
-                                          bool EmitSummaryIndex, bool EmitModuleHash) {
-  return new WriteBitcodePass(Str, ShouldPreserveUseListOrder,
-                              EmitSummaryIndex, EmitModuleHash);
+                                          bool EmitSummaryIndex,
+                                          bool EmitModuleHash,
+                                          bool StackSafety) {
+  return new WriteBitcodePass(Str, ShouldPreserveUseListOrder, EmitSummaryIndex,
+                              EmitModuleHash, StackSafety);
 }
 
 bool llvm::isBitcodeWriterPass(Pass *P) {
   return P->getPassID() == (llvm::AnalysisID)&WriteBitcodePass::ID;
 }

llvm/lib/LTO/ThinLTOCodeGenerator.cpp

 
 #include "llvm/LTO/legacy/ThinLTOCodeGenerator.h"
 #include "llvm/Support/CommandLine.h"
 
 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Analysis/ModuleSummaryAnalysis.h"
 #include "llvm/Analysis/ProfileSummaryInfo.h"
+#include "llvm/Analysis/StackSafetyAnalysis.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/Bitcode/BitcodeReader.h"
 #include "llvm/Bitcode/BitcodeWriter.h"
 #include "llvm/Bitcode/BitcodeWriterPass.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/DiagnosticPrinter.h"
ProcessThinLTOModule(Module &TheModule, ModuleSummaryIndex &Index,
   optimizeModule(TheModule, TM, OptLevel, Freestanding, &Index);
 
   saveTempBitcode(TheModule, SaveTempsDir, count, ".4.opt.bc");
 
   if (DisableCodeGen) {
     // Configured to stop before CodeGen, serialize the bitcode and return.
     SmallVector<char, 128> OutputBuffer;
     {
+      // TODO: No unit tests reach this
+      // legacy::PassManager PM;
+      // PM.add(createWriteThinLTOBitcodePass(OS, nullptr));
+      // PM.run(TheModule);
+
       raw_svector_ostream OS(OutputBuffer);
       ProfileSummaryInfo PSI(TheModule);
-      auto Index = buildModuleSummaryIndex(TheModule, nullptr, &PSI);
+      auto Index = buildModuleSummaryIndex(TheModule, nullptr, &PSI, nullptr);
       WriteBitcodeToFile(TheModule, OS, true, &Index);
     }
     return std::make_unique<SmallVectorMemoryBuffer>(std::move(OutputBuffer));
   }
 
   return codegenModule(TheModule, TM);
 }
 

llvm/lib/Transforms/IPO/PassManagerBuilder.cpp

 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Analysis/BasicAliasAnalysis.h"
 #include "llvm/Analysis/CFLAndersAliasAnalysis.h"
 #include "llvm/Analysis/CFLSteensAliasAnalysis.h"
 #include "llvm/Analysis/GlobalsModRef.h"
 #include "llvm/Analysis/InlineCost.h"
 #include "llvm/Analysis/Passes.h"
 #include "llvm/Analysis/ScopedNoAliasAA.h"
+#include "llvm/Analysis/StackSafetyAnalysis.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/TypeBasedAliasAnalysis.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Transforms/AggressiveInstCombine/AggressiveInstCombine.h"

llvm/lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp

 //===- ThinLTOBitcodeWriter.cpp - Bitcode writing pass for ThinLTO --------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Transforms/IPO/ThinLTOBitcodeWriter.h"
 #include "llvm/Analysis/BasicAliasAnalysis.h"
 #include "llvm/Analysis/ModuleSummaryAnalysis.h"
 #include "llvm/Analysis/ProfileSummaryInfo.h"
+#include "llvm/Analysis/StackSafetyAnalysis.h"
 #include "llvm/Analysis/TypeMetadataUtils.h"
 #include "llvm/Bitcode/BitcodeWriter.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Object/ModuleSymbolTable.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/IPO.h"
 #include "llvm/Transforms/IPO/FunctionAttrs.h"
 #include "llvm/Transforms/IPO/FunctionImport.h"
 #include "llvm/Transforms/IPO/LowerTypeTests.h"
 #include "llvm/Transforms/Utils/Cloning.h"
 #include "llvm/Transforms/Utils/ModuleUtils.h"
+#include <memory>
 using namespace llvm;
 
 namespace {
 
 // Promote each local-linkage entity defined by ExportM and used by ImportM by
 // changing visibility and appending the given ModuleId.
 void promoteInternals(Module &ExportM, Module &ImportM, StringRef ModuleId,
                       SetVector<GlobalValue *> &PromoteExtra) {
for (Value *Op : C->operands())
     forEachVirtualFunction(cast<Constant>(Op), Fn);
 }
 
 // If it's possible to split M into regular and thin LTO parts, do so and write
 // a multi-module bitcode file with the two parts to OS. Otherwise, write only a
 // regular LTO bitcode file to OS.
 void splitAndWriteThinLTOBitcode(
     raw_ostream &OS, raw_ostream *ThinLinkOS,
-    function_ref<AAResults &(Function &)> AARGetter, Module &M) {
+    function_ref<AAResults &(Function &)> AARGetter, Module &M,
+    function_ref<const StackSafetyInfo *(const Function &)> SSIGetter) {
   std::string ModuleId = getUniqueModuleId(&M);
   if (ModuleId.empty()) {
     // We couldn't generate a module ID for this module, write it out as a
     // regular LTO module with an index for summary-based dead stripping.
     ProfileSummaryInfo PSI(M);
     M.addModuleFlag(Module::Error, "ThinLTO", uint32_t(0));
-    ModuleSummaryIndex Index = buildModuleSummaryIndex(M, nullptr, &PSI);
+    ModuleSummaryIndex Index =
+        buildModuleSummaryIndex(M, nullptr, &PSI, SSIGetter);
     WriteBitcodeToFile(M, OS, /*ShouldPreserveUseListOrder=*/false, &Index);
 
     if (ThinLinkOS)
       // We don't have a ThinLTO part, but still write the module to the
       // ThinLinkOS if requested so that the expected output file is produced.
       WriteBitcodeToFile(M, *ThinLinkOS, /*ShouldPreserveUseListOrder=*/false,
                          &Index);
 
if (!Symvers.empty()) {
     for (auto MD : Symvers)
       NMD->addOperand(MD);
   }
 
   simplifyExternals(*MergedM);
 
   // FIXME: Try to re-use BSI and PFI from the original module here.
   ProfileSummaryInfo PSI(M);
-  ModuleSummaryIndex Index = buildModuleSummaryIndex(M, nullptr, &PSI);
+  ModuleSummaryIndex Index =
+      buildModuleSummaryIndex(M, nullptr, &PSI, SSIGetter);
 
   // Mark the merged module as requiring full LTO. We still want an index for
   // it though, so that it can participate in summary-based dead stripping.
   MergedM->addModuleFlag(Module::Error, "ThinLTO", uint32_t(0));
   ModuleSummaryIndex MergedMIndex =
-      buildModuleSummaryIndex(*MergedM, nullptr, &PSI);
+      buildModuleSummaryIndex(*MergedM, nullptr, &PSI, SSIGetter);
 
   SmallVector<char, 0> Buffer;
 
   BitcodeWriter W(Buffer);
   // Save the module hash produced for the full bitcode, which will
   // be used in the backends, and use that in the minimized bitcode
   // produced for the full link.
   ModuleHash ModHash = {{0}};

 bool hasTypeMetadata(Module &M) {
   for (auto &GO : M.global_objects()) {
     if (GO.hasMetadata(LLVMContext::MD_type))
       return true;
   }
   return false;
 }
 
-void writeThinLTOBitcode(raw_ostream &OS, raw_ostream *ThinLinkOS,
-                         function_ref<AAResults &(Function &)> AARGetter,
-                         Module &M, const ModuleSummaryIndex *Index) {
-  std::unique_ptr<ModuleSummaryIndex> NewIndex = nullptr;
+void writeThinLTOBitcode(
+    raw_ostream &OS, raw_ostream *ThinLinkOS,
+    function_ref<AAResults &(Function &)> AARGetter, Module &M,
+    function_ref<ModuleSummaryIndex()> IndexGetter,
+    function_ref<const StackSafetyInfo *(const Function &)> SSIGetter) {
+  std::unique_ptr<ModuleSummaryIndex> Index;
   // See if this module has any type metadata. If so, we try to split it
   // or at least promote type ids to enable WPD.
   if (hasTypeMetadata(M)) {
     if (enableSplitLTOUnit(M))
-      return splitAndWriteThinLTOBitcode(OS, ThinLinkOS, AARGetter, M);
+      return splitAndWriteThinLTOBitcode(OS, ThinLinkOS, AARGetter, M,
+                                         SSIGetter);
     // Promote type ids as needed for index-based WPD.
     std::string ModuleId = getUniqueModuleId(&M);
     if (!ModuleId.empty()) {
       promoteTypeIds(M, ModuleId);
       // Need to rebuild the index so that it contains type metadata
       // for the newly promoted type ids.
       // FIXME: Probably should not bother building the index at all
       // in the caller of writeThinLTOBitcode (which does so via the
       // ModuleSummaryIndexAnalysis pass), since we have to rebuild it
       // anyway whenever there is type metadata (here or in
       // splitAndWriteThinLTOBitcode). Just always build it once via the
       // buildModuleSummaryIndex when Module(s) are ready.
       ProfileSummaryInfo PSI(M);
-      NewIndex = std::make_unique<ModuleSummaryIndex>(
-          buildModuleSummaryIndex(M, nullptr, &PSI));
-      Index = NewIndex.get();
+      Index = std::make_unique<ModuleSummaryIndex>(
+          buildModuleSummaryIndex(M, nullptr, &PSI, SSIGetter));
     }
   }
+  if (!Index)
+    Index = std::make_unique<ModuleSummaryIndex>(IndexGetter());
 
   // Write it out as an unsplit ThinLTO module.
 
   // Save the module hash produced for the full bitcode, which will
   // be used in the backends, and use that in the minimized bitcode
   // produced for the full link.
   ModuleHash ModHash = {{0}};
-  WriteBitcodeToFile(M, OS, /*ShouldPreserveUseListOrder=*/false, Index,
+  WriteBitcodeToFile(M, OS, /*ShouldPreserveUseListOrder=*/false, Index.get(),
                      /*GenerateHash=*/true, &ModHash);
   // If a minimized bitcode module was requested for the thin link, only
   // the information that is needed by thin link will be written in the
   // given OS.
   if (ThinLinkOS && Index)
     WriteThinLinkBitcodeToFile(M, *ThinLinkOS, *Index, ModHash);
 }
 
 class WriteThinLTOBitcode : public ModulePass {
   raw_ostream &OS; // raw_ostream to print on
   // The output stream on which to emit a minimized module for use
   // just in the thin link, if requested.
   raw_ostream *ThinLinkOS;
+  bool StackSafety;
 
 public:
   static char ID; // Pass identification, replacement for typeid
   WriteThinLTOBitcode() : ModulePass(ID), OS(dbgs()), ThinLinkOS(nullptr) {
     initializeWriteThinLTOBitcodePass(*PassRegistry::getPassRegistry());
   }
 
-  explicit WriteThinLTOBitcode(raw_ostream &o, raw_ostream *ThinLinkOS)
-      : ModulePass(ID), OS(o), ThinLinkOS(ThinLinkOS) {
+  explicit WriteThinLTOBitcode(raw_ostream &o, raw_ostream *ThinLinkOS,
+                               bool StackSafety)
+      : ModulePass(ID), OS(o), ThinLinkOS(ThinLinkOS),
+        StackSafety(StackSafety) {
     initializeWriteThinLTOBitcodePass(*PassRegistry::getPassRegistry());
   }
 
   StringRef getPassName() const override { return "ThinLTO Bitcode Writer"; }
 
   bool runOnModule(Module &M) override {
-    const ModuleSummaryIndex *Index =
-        &(getAnalysis<ModuleSummaryIndexWrapperPass>().getIndex());
-    writeThinLTOBitcode(OS, ThinLinkOS, LegacyAARGetter(*this), M, Index);
+    writeThinLTOBitcode(
+        OS, ThinLinkOS, LegacyAARGetter(*this), M,
+        [&]() {
+          return getAnalysis<ModuleSummaryIndexWrapperPass>().getIndex(
+              StackSafety);
+        },
+        [&](const Function &F) -> const StackSafetyInfo * {
+          return StackSafety ? &getAnalysis<StackSafetyInfoWrapperPass>(
+                                    const_cast<Function &>(F))
+                                    .getResult()
+                             : nullptr;
+        });
     return true;
   }
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.setPreservesAll();
     AU.addRequired<AssumptionCacheTracker>();
     AU.addRequired<ModuleSummaryIndexWrapperPass>();
+    AU.addRequired<StackSafetyInfoWrapperPass>();
     AU.addRequired<TargetLibraryInfoWrapperPass>();
   }
 };
 } // anonymous namespace
 
 char WriteThinLTOBitcode::ID = 0;
 INITIALIZE_PASS_BEGIN(WriteThinLTOBitcode, "write-thinlto-bitcode",
                       "Write ThinLTO Bitcode", false, true)
 INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
 INITIALIZE_PASS_DEPENDENCY(ModuleSummaryIndexWrapperPass)
+INITIALIZE_PASS_DEPENDENCY(StackSafetyInfoWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
 INITIALIZE_PASS_END(WriteThinLTOBitcode, "write-thinlto-bitcode",
                     "Write ThinLTO Bitcode", false, true)
 
 ModulePass *llvm::createWriteThinLTOBitcodePass(raw_ostream &Str,
-                                                raw_ostream *ThinLinkOS) {
-  return new WriteThinLTOBitcode(Str, ThinLinkOS);
+                                                raw_ostream *ThinLinkOS,
+                                                bool StackSafety) {
+  return new WriteThinLTOBitcode(Str, ThinLinkOS, StackSafety);
 }
 
 PreservedAnalyses
 llvm::ThinLTOBitcodeWriterPass::run(Module &M, ModuleAnalysisManager &AM) {
   FunctionAnalysisManager &FAM =
       AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
-  writeThinLTOBitcode(OS, ThinLinkOS,
-                      [&FAM](Function &F) -> AAResults & {
-                        return FAM.getResult<AAManager>(F);
-                      },
-                      M, &AM.getResult<ModuleSummaryIndexAnalysis>(M));
+  writeThinLTOBitcode(
+      OS, ThinLinkOS,
+      M,
+      [&]() {
+        return AM.getResult<ModuleSummaryIndexAnalysis>(M)(StackSafety);
+      },
+      [&](const Function &F) -> const StackSafetyInfo * {
+        return StackSafety ? &FAM.getResult<StackSafetyAnalysis>(
+                                 const_cast<Function &>(F))
+                           : nullptr;
+      });
   return PreservedAnalyses::all();
 }

llvm/test/Analysis/StackSafetyAnalysis/ipa-alias.ll

 ; REQUIRES: aarch64-registered-target
 
 ; Test IPA over a single combined file
 ; RUN: llvm-as %s -o %t0.bc
 ; RUN: llvm-as %S/Inputs/ipa-alias.ll -o %t1.bc
 ; RUN: llvm-link %t0.bc %t1.bc -o %t.combined.bc
 
 ; RUN: opt -S -analyze -stack-safety-local %t.combined.bc | FileCheck %s --check-prefixes=CHECK,LOCAL
 ; RUN: opt -S -passes="print<stack-safety-local>" -disable-output %t.combined.bc 2>&1 | FileCheck %s --check-prefixes=CHECK,LOCAL
 
 ; RUN: opt -S -analyze -stack-safety %t.combined.bc | FileCheck %s --check-prefixes=CHECK,GLOBAL,NOLTO
 ; RUN: opt -S -passes="print-stack-safety" -disable-output %t.combined.bc 2>&1 | FileCheck %s --check-prefixes=CHECK,GLOBAL,NOLTO
 
 ; Do an end-to-test using the new LTO API
-; RUN: opt -module-summary %s -o %t.summ0.bc
-; RUN: opt -module-summary %S/Inputs/ipa-alias.ll -o %t.summ1.bc
+; RUN: opt -module-summary -module-summary-stack-safety %s -o %t.summ0.bc
+; RUN: opt -module-summary -module-summary-stack-safety %S/Inputs/ipa-alias.ll -o %t.summ1.bc
 
 ; RUN: llvm-lto2 run %t.summ0.bc %t.summ1.bc -o %t.lto -stack-safety-print -stack-safety-run -save-temps -thinlto-threads 1 -O0 \
 ; RUN:  -r %t.summ0.bc,PreemptableAliasWrite1, \
 ; RUN:  -r %t.summ0.bc,AliasToPreemptableAliasWrite1, \
 ; RUN:  -r %t.summ0.bc,InterposableAliasWrite1, \
 ; RUN:  -r %t.summ0.bc,AliasWrite1, \
 ; RUN:  -r %t.summ0.bc,BitcastAliasWrite1, \
 ; RUN:  -r %t.summ0.bc,AliasToBitcastAliasWrite1, \

llvm/test/Analysis/StackSafetyAnalysis/ipa.ll

 ; REQUIRES: aarch64-registered-target
 
 ; RUN: llvm-as %s -o %t0.bc
 ; RUN: llvm-as %S/Inputs/ipa.ll -o %t1.bc
 ; RUN: llvm-link -disable-lazy-loading %t0.bc %t1.bc -o %t.combined.bc
 
 ; RUN: opt -S -analyze -stack-safety-local %t.combined.bc | FileCheck %s --check-prefixes=CHECK,LOCAL
 ; RUN: opt -S -passes="print<stack-safety-local>" -disable-output %t.combined.bc 2>&1 | FileCheck %s --check-prefixes=CHECK,LOCAL
 
 ; RUN: opt -S -analyze -stack-safety %t.combined.bc | FileCheck %s --check-prefixes=CHECK,GLOBAL,NOLTO
 ; RUN: opt -S -passes="print-stack-safety" -disable-output %t.combined.bc 2>&1 | FileCheck %s --check-prefixes=CHECK,GLOBAL,NOLTO
 
 ; Do an end-to-test using the new LTO API
 ; TODO: Hideous llvm-lto2 invocation, add a --default-symbol-resolution to llvm-lto2?
-; RUN: opt -module-summary %s -o %t.summ0.bc
-; RUN: opt -module-summary %S/Inputs/ipa.ll -o %t.summ1.bc
+; RUN: opt -module-summary -module-summary-stack-safety %s -o %t.summ0.bc
+; RUN: opt -module-summary -module-summary-stack-safety %S/Inputs/ipa.ll -o %t.summ1.bc
 
 ; RUN: llvm-lto2 run %t.summ0.bc %t.summ1.bc -o %t.lto -stack-safety-print -stack-safety-run -save-temps -thinlto-threads 1 -O0 \
 ; RUN:  -r %t.summ0.bc,Write1, \
 ; RUN:  -r %t.summ0.bc,Write4, \
 ; RUN:  -r %t.summ0.bc,Write4_2, \
 ; RUN:  -r %t.summ0.bc,Write8, \
 ; RUN:  -r %t.summ0.bc,WriteAndReturn8, \
 ; RUN:  -r %t.summ0.bc,TestUpdateArg,px \

llvm/test/Bitcode/thinlto-function-summary-paramaccess.ll

 ; REQUIRES: aarch64-registered-target
 
 ; For convenience, to show what is being serialized.
 ; RUN: opt -S -passes="print<stack-safety-local>" -disable-output < %s 2>&1 | FileCheck %s --check-prefixes=SSI
 
-; RUN: opt -module-summary %s -o %t.bc
+; RUN: opt -module-summary -module-summary-stack-safety %s -o %t.bc
 ; RUN: llvm-bcanalyzer -dump %t.bc | FileCheck %s -check-prefixes=BC
 
 ; RUN: llvm-dis -o - %t.bc | FileCheck %s --check-prefix=DIS
 ; Round trip it through llvm-as
 ; RUN: llvm-dis -o - %t.bc | llvm-as -o - | llvm-dis -o - | FileCheck %s --check-prefix=DIS
 
-; RUN: opt -thinlto-bc %s -o %t.bc
+; RUN: opt -thinlto-bc -module-summary-stack-safety %s -o %t.bc
 ; RUN: llvm-bcanalyzer -dump %t.bc | FileCheck %s -check-prefixes=BC
 
 ; RUN: llvm-dis -o - %t.bc | FileCheck %s --check-prefix=DIS
 ; Round trip it through llvm-as
 ; RUN: llvm-dis -o - %t.bc | llvm-as -o - | llvm-dis -o - | FileCheck %s --check-prefix=DIS
 
 ; DIS: ^0 = module: (path: "{{.*}}", hash: ({{.*}}))
 ; ModuleID = 'thinlto-function-summary-paramaccess.ll'

 ; BC-NEXT: <PERMODULE
 ; DIS-DAG: = gv: (name: "Ret", summaries: {{.*}} ; guid = 6707380319572075172
 define i8* @Ret(i8* %p) #0 {
 entry:
   ret i8* %p
 }
 
 ; BC-NOT: <PERMODULE
-; BC-NOT: <PARAM_ACCESS1
+; BC-NOT: <PARAM_ACCESS
 
 

llvm/tools/llvm-extract/llvm-extract.cpp

if (EC) {
     errs() << EC.message() << '\n';
     return 1;
   }
 
   if (OutputAssembly)
     Passes.add(
         createPrintModulePass(Out.os(), "", PreserveAssemblyUseListOrder));
   else if (Force || !CheckBitcodeOutputToConsole(Out.os(), true))
-    Passes.add(createBitcodeWriterPass(Out.os(), PreserveBitcodeUseListOrder));
+    Passes.add(createBitcodeWriterPass(Out.os(), PreserveBitcodeUseListOrder,
+                                       false, false, false));
 
   Passes.run(*M.get());
 
   // Declare success.
   Out.keep();
 
   return 0;
 }

llvm/tools/opt/NewPMDriver.h

 /// nullptr.
 bool runPassPipeline(StringRef Arg0, Module &M, TargetMachine *TM,
                      ToolOutputFile *Out, ToolOutputFile *ThinLinkOut,
                      ToolOutputFile *OptRemarkFile, StringRef PassPipeline,
                      opt_tool::OutputKind OK, opt_tool::VerifierKind VK,
                      bool ShouldPreserveAssemblyUseListOrder,
                      bool ShouldPreserveBitcodeUseListOrder,
                      bool EmitSummaryIndex, bool EmitModuleHash,
-                     bool EnableDebugify, bool Coroutines);
+                     bool EnableDebugify, bool Coroutines,
+                     bool ModuleSummaryStackSafety);
 } // namespace llvm
 
 #endif

llvm/tools/opt/NewPMDriver.cpp

 bool llvm::runPassPipeline(StringRef Arg0, Module &M, TargetMachine *TM,
                            ToolOutputFile *Out, ToolOutputFile *ThinLTOLinkOut,
                            ToolOutputFile *OptRemarkFile,
                            StringRef PassPipeline, OutputKind OK,
                            VerifierKind VK,
                            bool ShouldPreserveAssemblyUseListOrder,
                            bool ShouldPreserveBitcodeUseListOrder,
                            bool EmitSummaryIndex, bool EmitModuleHash,
-                           bool EnableDebugify, bool Coroutines) {
+                           bool EnableDebugify, bool Coroutines,
+                           bool ModuleSummaryStackSafety) {
   bool VerifyEachPass = VK == VK_VerifyEachPass;
 
   Optional<PGOOptions> P;
   switch (PGOKindFlag) {
   case InstrGen:
     P = PGOOptions(ProfileFile, "", "", PGOOptions::IRInstr);
     break;
   case InstrUse:
MPM.addPass(
         PrintModulePass(Out->os(), "", ShouldPreserveAssemblyUseListOrder));
     break;
   case OK_OutputBitcode:
     MPM.addPass(BitcodeWriterPass(Out->os(), ShouldPreserveBitcodeUseListOrder,
                                   EmitSummaryIndex, EmitModuleHash));
     break;
   case OK_OutputThinLTOBitcode:
     MPM.addPass(ThinLTOBitcodeWriterPass(
-        Out->os(), ThinLTOLinkOut ? &ThinLTOLinkOut->os() : nullptr));
+        Out->os(), ThinLTOLinkOut ? &ThinLTOLinkOut->os() : nullptr,
+        ModuleSummaryStackSafety));
     break;
   }
 
   // Before executing passes, print the final values of the LLVM options.
   cl::PrintOptionValues();
 
   // Now that we have all of the passes ready, run them.
   MPM.run(M, MAM);

llvm/tools/opt/opt.cpp

 
 static cl::opt<bool> EmitSummaryIndex("module-summary",
                                       cl::desc("Emit module summary index"),
                                       cl::init(false));
 
 static cl::opt<bool> EmitModuleHash("module-hash", cl::desc("Emit module hash"),
                                     cl::init(false));
 
+cl::opt<bool> ModuleSummaryStackSafety("module-summary-stack-safety",
+                                       cl::init(false), cl::Hidden,
+                                       cl::desc("Emit Stack Safety summary."));
+
 static cl::opt<bool>
 DisableSimplifyLibCalls("disable-simplify-libcalls",
                         cl::desc("Disable simplify-libcalls"));
 
 static cl::list<std::string>
 DisableBuiltins("disable-builtin",
                 cl::desc("Disable specific target library builtin function"),
                 cl::ZeroOrMore);
if (PassPipeline.getNumOccurrences() > 0) {
 
     // The user has asked to use the new pass manager and provided a pipeline
     // string. Hand off the rest of the functionality to the new code for that
     // layer.
     return runPassPipeline(argv[0], *M, TM.get(), Out.get(), ThinLinkOut.get(),
                            RemarksFile.get(), PassPipeline, OK, VK,
                            PreserveAssemblyUseListOrder,
                            PreserveBitcodeUseListOrder, EmitSummaryIndex,
-                           EmitModuleHash, EnableDebugify, Coroutines)
+                           EmitModuleHash, EnableDebugify, Coroutines,
+                           ModuleSummaryStackSafety)
                ? 0
                : 1;
   }
 
   // Create a PassManager to hold and optimize the collection of passes we are
   // about to build.
   OptCustomPassManager Passes;
   bool AddOneTimeDebugifyPasses = EnableDebugify && !DebugifyEach;
if (ShouldEmitOutput || RunTwice) {
     if (OutputAssembly) {
       if (EmitSummaryIndex)
         report_fatal_error("Text output is incompatible with -module-summary");
       if (EmitModuleHash)
         report_fatal_error("Text output is incompatible with -module-hash");
       Passes.add(createPrintModulePass(*OS, "", PreserveAssemblyUseListOrder));
     } else if (OutputThinLTOBC)
       Passes.add(createWriteThinLTOBitcodePass(
-          *OS, ThinLinkOut ? &ThinLinkOut->os() : nullptr));
+          *OS, ThinLinkOut ? &ThinLinkOut->os() : nullptr,
+          ModuleSummaryStackSafety));
     else
       Passes.add(createBitcodeWriterPass(*OS, PreserveBitcodeUseListOrder,
-                                         EmitSummaryIndex, EmitModuleHash));
+                                         EmitSummaryIndex, EmitModuleHash,
+                                         ModuleSummaryStackSafety));
   }
 
   // Before executing passes, print the final values of the LLVM options.
   cl::PrintOptionValues();
 
   if (!RunTwice) {
     // Now that we have all of the passes ready, run them.
     Passes.run(*M);