[WIP][PGO] Add ability to mark cold functions as optsize/minsize/optnone

[aeubanks]

Summary

The performance of cold functions shouldn't matter too much, so if we care about binary sizes, add an option to mark cold functions as optsize/minsize for binary size, or optnone for compile times [1]. Clang patch will be in a future patch

Chrome size (ThinLTO + instrumented PGO):
base: 371004392
optsize: 366883296
minsize: 342128928

[1] https://discourse.llvm.org/t/rfc-new-feature-proposal-de-optimizing-cold-functions-using-pgo-info/56388

[aeubanks]

looking for feedback if this makes sense at all

[mtrofin]

high level question, why not have it as a pass that runs after profiles (of whatever kind - instrumented or sample-based) are ingested. The pass would attribute functions as described.

[tejohnson]

Previously @yamauchi did a bunch of work related to this called PGSO (Profile Guided Size Optimization). See the functions in https://github.com/llvm-mirror/llvm/blob/master/lib/Transforms/Utils/SizeOpts.cpp, which are used to guide a number of optimizations that can affect code size. Do you know why those weren't sufficient?

@davidxl may remember the details, but iirc fully using minsize/optnone for cold funcs might have been too big of a hammer performance-wise.

[aeubanks]

In D149800#4317275, @mtrofin wrote:

high level question, why not have it as a pass that runs after profiles (of whatever kind - instrumented or sample-based) are ingested. The pass would attribute functions as described.

that was also my initial thought, but I found it weird that only the ifdo pass marked functions as cold, but not the samplepgo pass. I remembered something about "precise" profiles and thought maybe that had something to do with not marking functions as cold with samplepgo? But maybe PSI->isFunctionColdInCallGraph(F, *BFI) takes care of all of that

In D149800#4317483, @tejohnson wrote:

Previously @yamauchi did a bunch of work related to this called PGSO (Profile Guided Size Optimization). See the functions in https://github.com/llvm-mirror/llvm/blob/master/lib/Transforms/Utils/SizeOpts.cpp, which are used to guide a number of optimizations that can affect code size. Do you know why those weren't sufficient?

I think there are still a lot of places that just look at optsize/minsize. I'll take a look at the inline cost model more to see how it interacts with hotness. Separately, it seems good for compile times to calculate once if a function is cold or not and save that result as optsize/minsize.

@davidxl may remember the details, but iirc fully using minsize/optnone for cold funcs might have been too big of a hammer performance-wise.

s/optnone/optsize? But I'm surprised that even minsize would make a perf difference just in functions that are supposedly cold. IIUC there aren't too many differences at least in the optimization pipeline for minsize functions aside from inlining thresholds (maybe there's more drastic changes in the backend?). It would be good to know if previous attempts at this sort of thing have shown perf regressions.

[davidxl]

This patch uses a cleaner method than the previous effort. There is some differences:

1. yamauchi's patch works for both iFDO and autoFDO, while this patch limits to iFDO
2. yamauchi's patch also handles size optimization (IIRC) at granularity smaller than function

Longer term, the previous functionality should fold into the new framework.

[aeubanks]

In D149800#4330831, @davidxl wrote:

This patch uses a cleaner method than the previous effort. There is some differences:

1. yamauchi's patch works for both iFDO and autoFDO, while this patch limits to iFDO
2. yamauchi's patch also handles size optimization (IIRC) at granularity smaller than function

Longer term, the previous functionality should fold into the new framework.

Could you clarify what "previous functionality" and "new framework" mean here?

[hjyamauchi]

In D149800#4330831, @davidxl wrote:

This patch uses a cleaner method than the previous effort. There is some differences:

1. yamauchi's patch works for both iFDO and autoFDO, while this patch limits to iFDO
2. yamauchi's patch also handles size optimization (IIRC) at granularity smaller than function

Longer term, the previous functionality should fold into the new framework.

IIRC 1) and 2) are correct. I don't have a strong preference on which folds into which.

[davidxl]

Sorry I missed the question. What I meant is that a lot of the profile guided size optimization (PGSO) done by Hiroshi can be adapted to use the attribute based method proposed in the patch as we don't need two different mechanisms.

[aeubanks]

reworked into https://github.com/llvm/llvm-project/pull/69030

clang/lib/CodeGen/BackendUtil.cpp

void EmitAssemblyHelper::RunOptimizationPipeline(
   std::optional<PGOOptions> PGOOpt;
 
   if (CodeGenOpts.hasProfileIRInstr())
     // -fprofile-generate.
     PGOOpt = PGOOptions(
         CodeGenOpts.InstrProfileOutput.empty() ? getDefaultProfileGenName()
                                                : CodeGenOpts.InstrProfileOutput,
         "", "", nullptr, PGOOptions::IRInstr, PGOOptions::NoCSAction,
-        CodeGenOpts.DebugInfoForProfiling);
+        PGOOptions::ColdFuncAttr::None, CodeGenOpts.DebugInfoForProfiling);
   else if (CodeGenOpts.hasProfileIRUse()) {
     // -fprofile-use.
     auto CSAction = CodeGenOpts.hasProfileCSIRUse() ? PGOOptions::CSIRUse
                                                     : PGOOptions::NoCSAction;
-    PGOOpt =
-        PGOOptions(CodeGenOpts.ProfileInstrumentUsePath, "",
-                   CodeGenOpts.ProfileRemappingFile, VFS, PGOOptions::IRUse,
-                   CSAction, CodeGenOpts.DebugInfoForProfiling);
+    PGOOpt = PGOOptions(
+        CodeGenOpts.ProfileInstrumentUsePath, "",
+        CodeGenOpts.ProfileRemappingFile, VFS, PGOOptions::IRUse, CSAction,
+        PGOOptions::ColdFuncAttr::None, CodeGenOpts.DebugInfoForProfiling);
   } else if (!CodeGenOpts.SampleProfileFile.empty())
     // -fprofile-sample-use
     PGOOpt = PGOOptions(
         CodeGenOpts.SampleProfileFile, "", CodeGenOpts.ProfileRemappingFile,
         VFS, PGOOptions::SampleUse, PGOOptions::NoCSAction,
-        CodeGenOpts.DebugInfoForProfiling, CodeGenOpts.PseudoProbeForProfiling);
+        PGOOptions::ColdFuncAttr::None, CodeGenOpts.DebugInfoForProfiling,
+        CodeGenOpts.PseudoProbeForProfiling);
   else if (CodeGenOpts.PseudoProbeForProfiling)
     // -fpseudo-probe-for-profiling
     PGOOpt = PGOOptions("", "", "", nullptr, PGOOptions::NoAction,
-                        PGOOptions::NoCSAction,
+                        PGOOptions::NoCSAction, PGOOptions::ColdFuncAttr::None,
                         CodeGenOpts.DebugInfoForProfiling, true);
   else if (CodeGenOpts.DebugInfoForProfiling)
     // -fdebug-info-for-profiling
     PGOOpt = PGOOptions("", "", "", nullptr, PGOOptions::NoAction,
-                        PGOOptions::NoCSAction, true);
+                        PGOOptions::NoCSAction, PGOOptions::ColdFuncAttr::None,
+                        true);
 
   // Check to see if we want to generate a CS profile.
   if (CodeGenOpts.hasProfileCSIRInstr()) {
     assert(!CodeGenOpts.hasProfileCSIRUse() &&
            "Cannot have both CSProfileUse pass and CSProfileGen pass at "
            "the same time");
     if (PGOOpt) {
       assert(PGOOpt->Action != PGOOptions::IRInstr &&
              PGOOpt->Action != PGOOptions::SampleUse &&
              "Cannot run CSProfileGen pass with ProfileGen or SampleUse "
              " pass");
       PGOOpt->CSProfileGenFile = CodeGenOpts.InstrProfileOutput.empty()
                                      ? getDefaultProfileGenName()
                                      : CodeGenOpts.InstrProfileOutput;
       PGOOpt->CSAction = PGOOptions::CSIRInstr;
     } else
-      PGOOpt =
-          PGOOptions("",
+      PGOOpt = PGOOptions("",
                           CodeGenOpts.InstrProfileOutput.empty()
                               ? getDefaultProfileGenName()
                               : CodeGenOpts.InstrProfileOutput,
-                     "", nullptr, PGOOptions::NoAction, PGOOptions::CSIRInstr,
+                          "", nullptr, PGOOptions::NoAction,
+                          PGOOptions::CSIRInstr, PGOOptions::ColdFuncAttr::None,
                           CodeGenOpts.DebugInfoForProfiling);
   }
   if (TM)
     TM->setPGOOption(PGOOpt);
 
   PipelineTuningOptions PTO;
   PTO.LoopUnrolling = CodeGenOpts.UnrollLoops;
   // For historical reasons, loop interleaving is set to mirror setting for loop
   // unrolling.

llvm/include/llvm/Support/PGOOptions.h

 namespace vfs {
 class FileSystem;
 } // namespace vfs
 
 /// A struct capturing PGO tunables.
 struct PGOOptions {
   enum PGOAction { NoAction, IRInstr, IRUse, SampleUse };
   enum CSPGOAction { NoCSAction, CSIRInstr, CSIRUse };
+  enum class ColdFuncAttr { None, OptSize, MinSize, OptNone };
   PGOOptions(std::string ProfileFile, std::string CSProfileGenFile,
              std::string ProfileRemappingFile,
              IntrusiveRefCntPtr<vfs::FileSystem> FS,
              PGOAction Action = NoAction, CSPGOAction CSAction = NoCSAction,
+             ColdFuncAttr ColdType = ColdFuncAttr::None,
              bool DebugInfoForProfiling = false,
              bool PseudoProbeForProfiling = false);
   PGOOptions(const PGOOptions &);
   ~PGOOptions();
   PGOOptions &operator=(const PGOOptions &);
 
   std::string ProfileFile;
   std::string CSProfileGenFile;
   std::string ProfileRemappingFile;
   PGOAction Action;
   CSPGOAction CSAction;
+  ColdFuncAttr ColdType;
   bool DebugInfoForProfiling;
   bool PseudoProbeForProfiling;
   IntrusiveRefCntPtr<vfs::FileSystem> FS;
 };
 } // namespace llvm
 
 #endif

llvm/include/llvm/Transforms/Instrumentation/PGOInstrumentation.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TRANSFORMS_INSTRUMENTATION_PGOINSTRUMENTATION_H
 #define LLVM_TRANSFORMS_INSTRUMENTATION_PGOINSTRUMENTATION_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/IR/PassManager.h"
+#include "llvm/Support/PGOOptions.h"
 #include <cstdint>
 #include <string>
 
 namespace llvm {
 
 class Function;
 class Instruction;
 class Module;

 private:
   // If this is a context sensitive instrumentation.
   bool IsCS;
 };
 
 /// The profile annotation (profile-instr-use) pass for IR based PGO.
 class PGOInstrumentationUse : public PassInfoMixin<PGOInstrumentationUse> {
 public:
-  PGOInstrumentationUse(std::string Filename = "",
-                        std::string RemappingFilename = "", bool IsCS = false,
-                        IntrusiveRefCntPtr<vfs::FileSystem> FS = nullptr);
+  PGOInstrumentationUse(
+      std::string Filename = "", std::string RemappingFilename = "",
+      bool IsCS = false,
+      PGOOptions::ColdFuncAttr ColdType = PGOOptions::ColdFuncAttr::None,
 
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
 
 private:
   std::string ProfileFileName;
   std::string ProfileRemappingFileName;
   // If this is a context sensitive instrumentation.
   bool IsCS;
+  PGOOptions::ColdFuncAttr ColdType;
   IntrusiveRefCntPtr<vfs::FileSystem> FS;
 };
 
 /// The indirect function call promotion pass.
 class PGOIndirectCallPromotion : public PassInfoMixin<PGOIndirectCallPromotion> {
 public:
   PGOIndirectCallPromotion(bool IsInLTO = false, bool SamplePGO = false)
       : InLTO(IsInLTO), SamplePGO(SamplePGO) {}

llvm/lib/LTO/LTOBackend.cpp

 static void runNewPMPasses(const Config &Conf, Module &Mod, TargetMachine *TM,
                            unsigned OptLevel, bool IsThinLTO,
                            ModuleSummaryIndex *ExportSummary,
                            const ModuleSummaryIndex *ImportSummary) {
   auto FS = vfs::getRealFileSystem();
   std::optional<PGOOptions> PGOOpt;
   if (!Conf.SampleProfile.empty())
     PGOOpt = PGOOptions(Conf.SampleProfile, "", Conf.ProfileRemapping, FS,
-                        PGOOptions::SampleUse, PGOOptions::NoCSAction, true);
+                        PGOOptions::SampleUse, PGOOptions::NoCSAction,
+                        PGOOptions::ColdFuncAttr::None, true);
   else if (Conf.RunCSIRInstr) {
-    PGOOpt = PGOOptions("", Conf.CSIRProfile, Conf.ProfileRemapping, FS,
-                        PGOOptions::IRUse, PGOOptions::CSIRInstr,
-                        Conf.AddFSDiscriminator);
+    PGOOpt =
+        PGOOptions("", Conf.CSIRProfile, Conf.ProfileRemapping, FS,
+                   PGOOptions::ColdFuncAttr::None, Conf.AddFSDiscriminator);
   } else if (!Conf.CSIRProfile.empty()) {
-    PGOOpt = PGOOptions(Conf.CSIRProfile, "", Conf.ProfileRemapping, FS,
-                        PGOOptions::IRUse, PGOOptions::CSIRUse,
-                        Conf.AddFSDiscriminator);
+    PGOOpt =
+        PGOOptions(Conf.CSIRProfile, "", Conf.ProfileRemapping, FS,
+                   PGOOptions::ColdFuncAttr::None, Conf.AddFSDiscriminator);
     NoPGOWarnMismatch = !Conf.PGOWarnMismatch;
   } else if (Conf.AddFSDiscriminator) {
     PGOOpt = PGOOptions("", "", "", nullptr, PGOOptions::NoAction,
-                        PGOOptions::NoCSAction, true);
+                        PGOOptions::NoCSAction, PGOOptions::ColdFuncAttr::None,
+                        true);
   }
   TM->setPGOOption(PGOOpt);
 
   LoopAnalysisManager LAM;
   FunctionAnalysisManager FAM;
   CGSCCAnalysisManager CGAM;
   ModuleAnalysisManager MAM;
 

llvm/lib/Passes/PassBuilderPipelines.cpp

if (!IsCS && !DisablePreInliner) {
     // Delete anything that is now dead to make sure that we don't instrument
     // dead code. Instrumentation can end up keeping dead code around and
     // dramatically increase code size.
     MPM.addPass(GlobalDCEPass());
   }
 
   if (!RunProfileGen) {
     assert(!ProfileFile.empty() && "Profile use expecting a profile file!");
-    MPM.addPass(
-        PGOInstrumentationUse(ProfileFile, ProfileRemappingFile, IsCS, FS));
+    MPM.addPass(PGOInstrumentationUse(ProfileFile, ProfileRemappingFile, IsCS,
+                                      PGOOpt->ColdType, FS));
     // Cache ProfileSummaryAnalysis once to avoid the potential need to insert
     // RequireAnalysisPass for PSI before subsequent non-module passes.
     MPM.addPass(RequireAnalysisPass<ProfileSummaryAnalysis, Module>());
     return;
   }
 
   // Perform PGO instrumentation.
   MPM.addPass(PGOInstrumentationGen(IsCS));

 }
 
 void PassBuilder::addPGOInstrPassesForO0(
     ModulePassManager &MPM, bool RunProfileGen, bool IsCS,
     std::string ProfileFile, std::string ProfileRemappingFile,
     IntrusiveRefCntPtr<vfs::FileSystem> FS) {
   if (!RunProfileGen) {
     assert(!ProfileFile.empty() && "Profile use expecting a profile file!");
-    MPM.addPass(
-        PGOInstrumentationUse(ProfileFile, ProfileRemappingFile, IsCS, FS));
+    MPM.addPass(PGOInstrumentationUse(ProfileFile, ProfileRemappingFile, IsCS,
+                                      PGOOpt->ColdType, FS));
     // Cache ProfileSummaryAnalysis once to avoid the potential need to insert
     // RequireAnalysisPass for PSI before subsequent non-module passes.
     MPM.addPass(RequireAnalysisPass<ProfileSummaryAnalysis, Module>());
     return;
   }
 
   // Perform PGO instrumentation.
   MPM.addPass(PGOInstrumentationGen(IsCS));

llvm/lib/Passes/PassRegistry.def

 MODULE_PASS("mergefunc", MergeFunctionsPass())
 MODULE_PASS("name-anon-globals", NameAnonGlobalPass())
 MODULE_PASS("no-op-module", NoOpModulePass())
 MODULE_PASS("objc-arc-apelim", ObjCARCAPElimPass())
 MODULE_PASS("partial-inliner", PartialInlinerPass())
 MODULE_PASS("memprof-context-disambiguation", MemProfContextDisambiguation())
 MODULE_PASS("pgo-icall-prom", PGOIndirectCallPromotion())
 MODULE_PASS("pgo-instr-gen", PGOInstrumentationGen())
-MODULE_PASS("pgo-instr-use", PGOInstrumentationUse())
+MODULE_PASS("pgo-instr-use", PGOInstrumentationUse("", "", false, PGOOpt ? PGOOpt->ColdType : PGOOptions::ColdFuncAttr::None))
 MODULE_PASS("print-profile-summary", ProfileSummaryPrinterPass(dbgs()))
 MODULE_PASS("print-callgraph", CallGraphPrinterPass(dbgs()))
 MODULE_PASS("print-callgraph-sccs", CallGraphSCCsPrinterPass(dbgs()))
 MODULE_PASS("print", PrintModulePass(dbgs()))
 MODULE_PASS("print-lcg", LazyCallGraphPrinterPass(dbgs()))
 MODULE_PASS("print-lcg-dot", LazyCallGraphDOTPrinterPass(dbgs()))
 MODULE_PASS("print-must-be-executed-contexts", MustBeExecutedContextPrinterPass(dbgs()))
 MODULE_PASS("print-stack-safety", StackSafetyGlobalPrinterPass(dbgs()))

llvm/lib/Support/PGOOptions.cpp

 //===------ PGOOptions.cpp -- PGO option tunables --------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/PGOOptions.h"
 #include "llvm/Support/VirtualFileSystem.h"
 
 using namespace llvm;
 
 PGOOptions::PGOOptions(std::string ProfileFile, std::string CSProfileGenFile,
                        std::string ProfileRemappingFile,
                        IntrusiveRefCntPtr<vfs::FileSystem> FS, PGOAction Action,
-                       CSPGOAction CSAction, bool DebugInfoForProfiling,
-                       bool PseudoProbeForProfiling)
+                       CSPGOAction CSAction, ColdFuncAttr ColdType,
+                       bool DebugInfoForProfiling, bool PseudoProbeForProfiling)
     : ProfileFile(ProfileFile), CSProfileGenFile(CSProfileGenFile),
       ProfileRemappingFile(ProfileRemappingFile), Action(Action),
-      CSAction(CSAction),
+      CSAction(CSAction), ColdType(ColdType),
       DebugInfoForProfiling(DebugInfoForProfiling ||
                             (Action == SampleUse && !PseudoProbeForProfiling)),
       PseudoProbeForProfiling(PseudoProbeForProfiling), FS(std::move(FS)) {
   // Note, we do allow ProfileFile.empty() for Action=IRUse LTO can
   // callback with IRUse action without ProfileFile.
 
   // If there is a CSAction, PGOAction cannot be IRInstr or SampleUse.
   assert(this->CSAction == NoCSAction ||

llvm/lib/Transforms/Instrumentation/PGOInstrumentation.cpp

 }
 
 static bool annotateAllFunctions(
     Module &M, StringRef ProfileFileName, StringRef ProfileRemappingFileName,
     vfs::FileSystem &FS,
     function_ref<TargetLibraryInfo &(Function &)> LookupTLI,
     function_ref<BranchProbabilityInfo *(Function &)> LookupBPI,
     function_ref<BlockFrequencyInfo *(Function &)> LookupBFI,
-    ProfileSummaryInfo *PSI, bool IsCS) {
+    ProfileSummaryInfo *PSI, bool IsCS, PGOOptions::ColdFuncAttr ColdType) {
   LLVM_DEBUG(dbgs() << "Read in profile counters: ");
   auto &Ctx = M.getContext();
   // Read the counter array from file.
   auto ReaderOrErr = IndexedInstrProfReader::create(ProfileFileName, FS,
                                                     ProfileRemappingFileName);
   if (Error E = ReaderOrErr.takeError()) {
     handleAllErrors(std::move(E), [&](const ErrorInfoBase &EI) {
       Ctx.diagnose(
if (F->hasFnAttribute(Attribute::Hot)) {
       std::string Msg = std::string("Function ") + F->getName().str() +
                         std::string(" is annotated as a hot function but"
                                     " the profile is cold");
       Ctx.diagnose(
           DiagnosticInfoPGOProfile(M.getName().data(), Msg, DS_Warning));
       continue;
     }
     F->addFnAttr(Attribute::Cold);
+    // Add optsize/minsize/optnone if requested.
+    switch (ColdType) {
+    case PGOOptions::ColdFuncAttr::None:
+      break;
+    case PGOOptions::ColdFuncAttr::OptSize:
+      if (!F->hasFnAttribute(Attribute::OptimizeNone) &&
+          !F->hasFnAttribute(Attribute::OptimizeForSize) &&
+          !F->hasFnAttribute(Attribute::MinSize)) {
+        F->addFnAttr(Attribute::OptimizeForSize);
+      }
+      break;
+    case PGOOptions::ColdFuncAttr::MinSize:
+      // Change optsize to minsize.
+      if (!F->hasFnAttribute(Attribute::OptimizeNone) &&
+          !F->hasFnAttribute(Attribute::MinSize)) {
+        F->removeFnAttr(Attribute::OptimizeForSize);
+        F->addFnAttr(Attribute::MinSize);
+      }
+      break;
+    case PGOOptions::ColdFuncAttr::OptNone:
+      // Strip optsize/minsize.
+      F->removeFnAttr(Attribute::OptimizeForSize);
+      F->removeFnAttr(Attribute::MinSize);
+      F->addFnAttr(Attribute::OptimizeNone);
+      F->addFnAttr(Attribute::NoInline);
+      break;
+    }
     LLVM_DEBUG(dbgs() << "Set cold attribute to function: " << F->getName()
                       << "\n");
   }
   return true;
 }
 
 PGOInstrumentationUse::PGOInstrumentationUse(
     std::string Filename, std::string RemappingFilename, bool IsCS,
-    IntrusiveRefCntPtr<vfs::FileSystem> VFS)
+    PGOOptions::ColdFuncAttr ColdType, IntrusiveRefCntPtr<vfs::FileSystem> VFS)
     : ProfileFileName(std::move(Filename)),
       ProfileRemappingFileName(std::move(RemappingFilename)), IsCS(IsCS),
-      FS(std::move(VFS)) {
+      ColdType(ColdType), FS(std::move(VFS)) {
   if (!PGOTestProfileFile.empty())
     ProfileFileName = PGOTestProfileFile;
   if (!PGOTestProfileRemappingFile.empty())
     ProfileRemappingFileName = PGOTestProfileRemappingFile;
   if (!FS)
     FS = vfs::getRealFileSystem();
 }
 
PreservedAnalyses PGOInstrumentationUse::run(Module &M,
   };
   auto LookupBFI = [&FAM](Function &F) {
     return &FAM.getResult<BlockFrequencyAnalysis>(F);
   };
 
   auto *PSI = &AM.getResult<ProfileSummaryAnalysis>(M);
 
   if (!annotateAllFunctions(M, ProfileFileName, ProfileRemappingFileName, *FS,
-                            LookupTLI, LookupBPI, LookupBFI, PSI, IsCS))
+                            LookupTLI, LookupBPI, LookupBFI, PSI, IsCS,
+                            ColdType))
     return PreservedAnalyses::all();
 
   return PreservedAnalyses::none();
 }
 
 static std::string getSimpleNodeName(const BasicBlock *Node) {
   if (!Node->getName().empty())
     return Node->getName().str();

llvm/test/Transforms/PGOProfile/Inputs/cold-func-attr.proftext

+# IR level Instrumentation Flag
+:ir
+:entry_first
+hot
+# Func Hash:
+742261418966908927
+# Num Counters:
+1
+# Counter Values:
+9000
+
+cold
+# Func Hash:
+742261418966908927
+# Num Counters:
+1
+# Counter Values:
+10
+
+cold1
+# Func Hash:
+742261418966908927
+# Num Counters:
+1
+# Counter Values:
+10
+
+cold2
+# Func Hash:
+742261418966908927
+# Num Counters:
+1
+# Counter Values:
+10
+
+cold3
+# Func Hash:
+742261418966908927
+# Num Counters:
+1
+# Counter Values:
+10

llvm/test/Transforms/PGOProfile/cold-func-attr.ll

+; RUN: llvm-profdata merge %S/Inputs/cold-func-attr.proftext -o %t.profdata
+; RUN: opt < %s -passes=pgo-instr-use -pgo-kind=pgo-instr-use-pipeline -pgo-test-profile-file=%t.profdata -S -pgo-cold-func-attr=none    | FileCheck %s --check-prefixes=NONE
+; RUN: opt < %s -passes=pgo-instr-use -pgo-kind=pgo-instr-use-pipeline -pgo-test-profile-file=%t.profdata -S -pgo-cold-func-attr=optsize | FileCheck %s --check-prefixes=OPTSIZE,CHECK
+; RUN: opt < %s -passes=pgo-instr-use -pgo-kind=pgo-instr-use-pipeline -pgo-test-profile-file=%t.profdata -S -pgo-cold-func-attr=minsize | FileCheck %s --check-prefixes=MINSIZE,CHECK
+; RUN: opt < %s -passes=pgo-instr-use -pgo-kind=pgo-instr-use-pipeline -pgo-test-profile-file=%t.profdata -S -pgo-cold-func-attr=optnone | FileCheck %s --check-prefixes=OPTNONE,CHECK
+
+; NONE: Function Attrs: cold{{$}}
+; OPTSIZE: Function Attrs: cold optsize{{$}}
+; MINSIZE: Function Attrs: cold minsize{{$}}
+; OPTNONE: Function Attrs: cold noinline optnone{{$}}
+; CHECK-NEXT: define void @cold()
+
+; NONE: Function Attrs: cold optsize{{$}}
+; OPTSIZE: Function Attrs: cold optsize{{$}}
+; MINSIZE: Function Attrs: cold minsize{{$}}
+; OPTNONE: Function Attrs: cold noinline optnone{{$}}
+; CHECK-NEXT: define void @cold1()
+
+; NONE: Function Attrs: cold minsize{{$}}
+; OPTSIZE: Function Attrs: cold minsize{{$}}
+; MINSIZE: Function Attrs: cold minsize{{$}}
+; OPTNONE: Function Attrs: cold noinline optnone{{$}}
+; CHECK-NEXT: define void @cold2()
+
+; CHECK: Function Attrs: cold noinline optnone{{$}}
+; CHECK-NEXT: define void @cold3()
+
+; CHECK-NOT: Function Attrs: {{.*}}optsize
+; CHECK-NOT: Function Attrs: {{.*}}minsize
+; CHECK-NOT: Function Attrs: {{.*}}optnone
+
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+@s = common dso_local local_unnamed_addr global i32 0, align 4
+
+define void @cold() {
+  store i32 1, ptr @s, align 4
+  ret void
+}
+
+define void @cold1() optsize {
+  store i32 1, ptr @s, align 4
+  ret void
+}
+
+define void @cold2() minsize {
+  store i32 1, ptr @s, align 4
+  ret void
+}
+
+define void @cold3() optnone noinline {
+  store i32 1, ptr @s, align 4
+  ret void
+}
+
+define void @hot() {
+  %l = load i32, ptr @s, align 4
+  %add = add nsw i32 %l, 4
+  store i32 %add, ptr @s, align 4
+  ret void
+}

llvm/tools/opt/NewPMDriver.cpp

static cl::opt<std::string> CSProfileGenFile(
     cl::desc("Path to the instrumented context sensitive profile."),
     cl::Hidden);
 
 static cl::opt<std::string>
     ProfileRemappingFile("profile-remapping-file",
                          cl::desc("Path to the profile remapping file."),
                          cl::Hidden);
 
+static cl::opt<PGOOptions::ColdFuncAttr> PGOColdFuncAttr(
+    "pgo-cold-func-attr", cl::init(PGOOptions::ColdFuncAttr::None), cl::Hidden,
+    cl::desc(
+        "Function attribute to apply to cold functions as determined by PGO"),
+    cl::values(clEnumValN(PGOOptions::ColdFuncAttr::None, "none", "None"),
+               clEnumValN(PGOOptions::ColdFuncAttr::OptSize, "optsize",
+                          "Mark cold functions with optsize."),
+               clEnumValN(PGOOptions::ColdFuncAttr::MinSize, "minsize",
+                          "Mark cold functions with minsize."),
+               clEnumValN(PGOOptions::ColdFuncAttr::OptNone, "optnone",
+                          "Mark cold functions with optnone.")));
+
 static cl::opt<bool> DebugInfoForProfiling(
     "debug-info-for-profiling", cl::init(false), cl::Hidden,
     cl::desc("Emit special debug info to enable PGO profile generation."));
 
 static cl::opt<bool> PseudoProbeForProfiling(
     "pseudo-probe-for-profiling", cl::init(false), cl::Hidden,
     cl::desc("Emit pseudo probes to enable PGO profile generation."));
 
bool llvm::runPassPipeline(StringRef Arg0, Module &M, TargetMachine *TM,
                            bool EmitSummaryIndex, bool EmitModuleHash,
                            bool EnableDebugify, bool VerifyDIPreserve) {
   bool VerifyEachPass = VK == VK_VerifyEachPass;
 
   auto FS = vfs::getRealFileSystem();
   std::optional<PGOOptions> P;
   switch (PGOKindFlag) {
   case InstrGen:
-    P = PGOOptions(ProfileFile, "", "", FS, PGOOptions::IRInstr);
+    P = PGOOptions(ProfileFile, "", "", FS, PGOOptions::IRInstr,
+                   PGOOptions::NoCSAction, PGOColdFuncAttr);
     break;
   case InstrUse:
-    P = PGOOptions(ProfileFile, "", ProfileRemappingFile, FS,
-                   PGOOptions::IRUse);
+    P = PGOOptions(ProfileFile, "", ProfileRemappingFile, FS, PGOOptions::IRUse,
+                   PGOOptions::NoCSAction, PGOColdFuncAttr);
     break;
   case SampleUse:
     P = PGOOptions(ProfileFile, "", ProfileRemappingFile, FS,
-                   PGOOptions::SampleUse);
+                   PGOOptions::SampleUse, PGOOptions::NoCSAction,
+                   PGOColdFuncAttr);
     break;
   case NoPGO:
     if (DebugInfoForProfiling || PseudoProbeForProfiling)
       P = PGOOptions("", "", "", nullptr, PGOOptions::NoAction,
-                     PGOOptions::NoCSAction, DebugInfoForProfiling,
-                     PseudoProbeForProfiling);
+                     PGOOptions::NoCSAction, PGOColdFuncAttr,
+                     DebugInfoForProfiling, PseudoProbeForProfiling);
     else
       P = std::nullopt;
   }
   if (CSPGOKindFlag != NoCSPGO) {
     if (P && (P->Action == PGOOptions::IRInstr ||
               P->Action == PGOOptions::SampleUse)) {
       errs() << "CSPGOKind cannot be used with IRInstr or SampleUse";
       return false;
     }
     if (CSPGOKindFlag == CSInstrGen) {
       if (CSProfileGenFile.empty()) {
         errs() << "CSInstrGen needs to specify CSProfileGenFile";
         return false;
       }
       if (P) {
         P->CSAction = PGOOptions::CSIRInstr;
         P->CSProfileGenFile = CSProfileGenFile;
       } else
         P = PGOOptions("", CSProfileGenFile, ProfileRemappingFile, FS,
-                       PGOOptions::NoAction, PGOOptions::CSIRInstr);
+                       PGOOptions::NoAction, PGOOptions::CSIRInstr,
+                       PGOColdFuncAttr);
     } else /* CSPGOKindFlag == CSInstrUse */ {
       if (!P) {
         errs() << "CSInstrUse needs to be together with InstrUse";
         return false;
       }
       P->CSAction = PGOOptions::CSIRUse;
     }
   }