[PM/CC1] Add -f[no-]split-cold-code CC1 options to toggle splitting

[compnerd]

Summary

This patch adds -f[no-]split-cold-code CC1 options to clang. This allows
the splitting pass to be toggled on/off. The current method of passing
-mllvm -hot-cold-split=true to clang isn't ideal as it may not compose
correctly (say, with -O0 or -Oz).

To implement the -fsplit-cold-code option, an attribute is applied to
functions to indicate that they may be considered for splitting. This
removes some complexity from the old/new PM pipeline builders, and
behaves as expected when LTO is enabled.

[vsk]

• Fix a think-o in a comment.

[vsk]

Ping.

[hiraditya]

LGTM

[vsk]

Thanks @hiraditya. I'd also like to get a +1 from someone who's worked on the NewPM infrastructure extensively, just to make sure those changes look ok.

[vsk]

Rebase.

[tejohnson]

Overall it looks ok to me, but I'd like Chandler to comment regarding the preferred way to do this with the new PM, since we don't tend to use booleans there in the PassBuilder to control passes. Is it preferable to instead use a new function attribute instead of boolean flags on the PMs (e.g. the way -fno-inline is handled)?

clang/lib/Frontend/CompilerInvocation.cpp

1331

would it be appropriate to give a warning when being ignored?

[philip.pfaffe]

I'd prefer not adding this kind of state to PassBuilder. SplitColdCode is soemthing that refers to the construction of one particular pipeline, not to pipeline-building in general. It should be an argument passed down through the build*Pipeline calls.

[vsk]

I'd prefer not adding this kind of state to PassBuilder. SplitColdCode is soemthing that refers to the construction of one particular pipeline, not to pipeline-building in general. It should be an argument passed down through the build*Pipeline calls.

I'm not sure I understand the distinction being made here -- could you elaborate? Isn't enabling a pass related to pipeline-building in general? If not, I don't see how arguments to build*Pipeline do become related to pipeline-building in general.

For context, I've modeled the addition of the SplitColdCode member to PassBuilder on PGOOpt (c.f. PGOOptions::RunProfileGen). One thing I like about this approach is that it doesn't require changing IR, or changing very many different APIs. But if it's really not reasonable, I'm happy to take another shot at it.

clang/lib/Frontend/CompilerInvocation.cpp

1331

I think so, I'll add this in an update.

[fedor.sergeev]

In D57265#1393453, @vsk wrote:

I'd prefer not adding this kind of state to PassBuilder. SplitColdCode is soemthing that refers to the construction of one particular pipeline, not to pipeline-building in general. It should be an argument passed down through the build*Pipeline calls.

I'm not sure I understand the distinction being made here -- could you elaborate? Isn't enabling a pass related to pipeline-building in general? If not, I don't see how arguments to build*Pipeline do become related to pipeline-building in general.

For context, I've modeled the addition of the SplitColdCode member to PassBuilder on PGOOpt (c.f. PGOOptions::RunProfileGen). One thing I like about this approach is that it doesn't require changing IR, or changing very many different APIs. But if it's really not reasonable, I'm happy to take another shot at it.

I cant say for PGOOpt in particular, but overall idea of PassBuilder is that, well, it is not "builder" as per "builder pattern".
You do not fill it with parts of a complex pipeline object and then press a magical "build" button.
Instead you ask it to build various "named" pipelines, or just parse it from text.
If you compare with PassManagerBuilder, which contains a dozen of various data members that seem to drive the pipeline construction,
PassBuilder contains only a few. And the purpose of PassBuilder members is to be used during individual *pass*es creation.

Say, you wont find OptLevel there. Instead it is being passed as an argument to build*Pipeline functions.

As for PGOOpts - it seems to be the only member that stands out.
And to me it looks like we should remove it from PassBuilder either, and start passing it to build*Pipeline functions as well.
But honestly, this is the first time I really looked through the PGOOpts code, so I might be well mistaken.

[vsk]

In D57265#1393814, @fedor.sergeev wrote:

In D57265#1393453, @vsk wrote:

I'd prefer not adding this kind of state to PassBuilder. SplitColdCode is soemthing that refers to the construction of one particular pipeline, not to pipeline-building in general. It should be an argument passed down through the build*Pipeline calls.

I'm not sure I understand the distinction being made here -- could you elaborate? Isn't enabling a pass related to pipeline-building in general? If not, I don't see how arguments to build*Pipeline do become related to pipeline-building in general.

For context, I've modeled the addition of the SplitColdCode member to PassBuilder on PGOOpt (c.f. PGOOptions::RunProfileGen). One thing I like about this approach is that it doesn't require changing IR, or changing very many different APIs. But if it's really not reasonable, I'm happy to take another shot at it.

I cant say for PGOOpt in particular, but overall idea of PassBuilder is that, well, it is not "builder" as per "builder pattern".
You do not fill it with parts of a complex pipeline object and then press a magical "build" button.
Instead you ask it to build various "named" pipelines, or just parse it from text.
If you compare with PassManagerBuilder, which contains a dozen of various data members that seem to drive the pipeline construction,
PassBuilder contains only a few. And the purpose of PassBuilder members is to be used during individual *pass*es creation.

Say, you wont find OptLevel there. Instead it is being passed as an argument to build*Pipeline functions.

As for PGOOpts - it seems to be the only member that stands out.
And to me it looks like we should remove it from PassBuilder either, and start passing it to build*Pipeline functions as well.
But honestly, this is the first time I really looked through the PGOOpts code, so I might be well mistaken.

Thanks everyone for your patient feedback. I think I understand the advantages of keeping state out of the pipeline builder now.

Teresa's earlier suggestion to use an IR attribute seems like a promising approach. In particular, it makes it simple to correctly enable/disable splitting during LTO. I'll try to post an updated patch soon.

[vsk]

Use a function attribute to implement the -fsplit-cold-code option. This removes some complexity from the old/new PMs and ensures consistent behavior when LTO is enabled.

[vsk]

Ping.

[hiraditya]

it will be great to merge this patch.

[fhahn]

This seems fine to me.

IIUC the only potential drawback with the old pass manager is that we potentially have to run the required passes unconditionally, even if we do not use them. Vedant, did you have a chance to check the impact on overall compile time?

clang/test/CodeGen/split-cold-code.c

70

Could you extend the scope of the check to include a bit more context, i.e. make sure we emit a function attribute attached to the correct function?

llvm/test/Other/opt-Os-pipeline.ll

276

Are we missing an implementation of getPassName in HotColdSplitting?

[plotfi]

Why hasn't this patch landed in llvm.org? I see it on the github apple/master but not on llvm.org master.

[vsk]

Rebase, address Florian's feedback.

Apologies for the delay here. I haven't had time to push this forward, but I have also been waiting to get an additional lgtm specifically for the PassManager changes. My compile-time measurements are a year old (I'll work on getting fresh numbers), but as I remember the change was in the noise.

[rjf]

Would also really like to see this patch landed. Also, as of today (8/10/2020), the patch cannot be cleanly applied into trunk without inducing merge conflicts anymore.

[plotfi]

In D57265#2205797, @rjf wrote:

Would also really like to see this patch landed. Also, as of today (8/10/2020), the patch cannot be cleanly applied into trunk without inducing merge conflicts anymore.

You might have some luck merging from github.com/apple/llvm-project. You may also want to look at some of the upstreaming work some of the Apple folks are doing at https://github.com/llvm/llvm-project-staging

[plotfi]

@vsk any update on this? Is there anything we can do to help in landing this patch in llvm-project/main?

[vsk]

@plotfi Sorry this work has stalled, unfortunately I haven't had any bandwidth to drive it forward.

At this point I don't think there are any outstanding concerns with this patch. If anyone is willing to rebase and land it, I would be really grateful. It looks like part of the motivation behind this is removing some downstream diff with the apple/llvm-project fork (as in D89078). I think extra work might be needed to do that, since the HotColdSplitting pass is on-by-default in the Apple fork. Turning the pass on by default on llvm.org could result in a fair amount of fallout, as the pass might interact badly with the machine function splitter (https://lists.llvm.org/pipermail/llvm-dev/2020-August/144012.html). It also hasn't had as much testing on non-Darwin targets (afaik). One solution might be to enable -fsplit-cold-code under -O only for Darwin targets.

[compnerd]

Rebase; there are a 4 more test failures to go through

[compnerd]

Passes locally now

[vsk]

Thank you! LGTM.

[hans]

This broke Chromium's build, causing it to fail with
"Cannot pop empty stack!" from one of the backend passes.

That specific error is probably a perhaps a previously existing problem, but I think it was triggered by hot-cold-splitting getting enabled by this pass. This was a surprise to us, because we're not passing any flags to enable hot-cold-splitting, instead it seems to get enabled by this patch anyway in our PGO-enabled builds.

See https://bugs.chromium.org/p/chromium/issues/detail?id=1139384#c5 for a repro.

I've reverted in 0628bea5137047232f37c94b74bf26aa9b55f605 until this can be investigated.

[vsk]

Thanks Hans. I've merged the revert into the apple fork. While the commit was in-tree, we noticed that this enabled HCS during LTO. There was a surprising ~17% regression of 483.xalancbmk with LTO (+ PGO) enabled: 2020-10-16 CINT2006/483.xalancbmk 17.87%. We don't see the regression on the non-LTO performance bots. This is something we'll need to investigate before relanding.

[nickdesaulniers]

It looks like this caused breakage for us for x86 Linux kernels, too: https://github.com/ClangBuiltLinux/linux/issues/1177. The Linux kernel does not and will not link against libgcc_s/compiler-rt, so optimizations at -Oz tend to both produce libcalls that aren't implemented by the kernel's runtime, and larger code than -Os (see https://bugs.llvm.org/show_bug.cgi?id=47897 which was also filed in response to this patch's resulting bug). It appears with this patch applied, that any function marked __attribute__((cold)) (explicitly or due to AutoFDO profiles) would be optimized at -Oz, regardless of optimization level. (I think that approach is ok, but I would prefer -Os if possible to avoid the excessive code bloat that -Oz produces and avoid the libcalls; we have found -Oz to never be smaller than -Os for kernel builds).

clang/include/clang/Basic/CodeGenOptions.def

CODEGENOPT(EnableSplitLTOUnit, 1, 0) ///< Enable LTO unit splitting to support
              /// CFI and traditional whole program
              /// devirtualization that require whole
              /// program IR support.
 CODEGENOPT(IncrementalLinkerCompatible, 1, 0) ///< Emit an object file which can
                                               ///< be used with an incremental
                                               ///< linker.
 CODEGENOPT(MergeAllConstants , 1, 1) ///< Merge identical constants.
 CODEGENOPT(MergeFunctions    , 1, 0) ///< Set when -fmerge-functions is enabled.
+CODEGENOPT(SplitColdCode     , 1, 0) ///< Set when -fsplit-cold-code is enabled.
 CODEGENOPT(MemProf           , 1, 0) ///< Set when -fmemory-profile is enabled.
 CODEGENOPT(MSVolatile        , 1, 0) ///< Set when /volatile:ms is enabled.
 CODEGENOPT(NoCommon          , 1, 0) ///< Set when -fno-common or C++ is enabled.
 CODEGENOPT(NoDwarfDirectoryAsm , 1, 0) ///< Set when -fno-dwarf-directory-asm is
                                        ///< enabled.
 CODEGENOPT(NoExecStack       , 1, 0) ///< Set when -Wa,--noexecstack is enabled.
 CODEGENOPT(FatalWarnings     , 1, 0) ///< Set when -Wa,--fatal-warnings is
                                      ///< enabled.

clang/include/clang/Basic/DiagnosticFrontendKinds.td

def warn_atomic_op_oversized : Warning<
   "; the access size (%0 bytes) exceeds the max lock-free size (%1  bytes)">,
 InGroup<AtomicAlignment>;
 
 def warn_alias_with_section : Warning<
   "%select{alias|ifunc}1 will not be in section '%0' but in the same section "
   "as the %select{aliasee|resolver}2">,
   InGroup<IgnoredAttributes>;
 
+def warn_fe_ignored_opt_split_cold_code : Warning<
+  "'%0' has no effect when %select{optimizing for minimum size|optimizations are disabled}1">,
+  InGroup<IgnoredAttributes>;
+
 let CategoryName = "Instrumentation Issue" in {
 def warn_profile_data_out_of_date : Warning<
   "profile data may be out of date: of %0 function%s0, %1 %plural{1:has|:have}1"
   " mismatched data that will be ignored">,
   InGroup<ProfileInstrOutOfDate>;
 def warn_profile_data_missing : Warning<
   "profile data may be incomplete: of %0 function%s0, %1 %plural{1:has|:have}1"
   " no data">,

clang/include/clang/Driver/Options.td

 def fforbid_guard_variables : Flag<["-"], "fforbid-guard-variables">,
   HelpText<"Emit an error if a C++ static local initializer would need a guard variable">;
 def no_implicit_float : Flag<["-"], "no-implicit-float">,
   HelpText<"Don't generate implicit floating point instructions">;
 def fdump_vtable_layouts : Flag<["-"], "fdump-vtable-layouts">,
   HelpText<"Dump the layouts of all vtables that will be emitted in a translation unit">;
 def fmerge_functions : Flag<["-"], "fmerge-functions">,
   HelpText<"Permit merging of identical functions when optimizing.">;
+def fsplit_cold_code : Flag<["-"], "fsplit-cold-code">,
+  HelpText<"Permit splitting of cold code when optimizing (off by default).">;
+def fno_split_cold_code : Flag<["-"], "fno-split-cold-code">,
+  HelpText<"Disable splitting of cold code when optimizing.">;
 def femit_coverage_notes : Flag<["-"], "femit-coverage-notes">,
   HelpText<"Emit a gcov coverage notes file when compiling.">;
 def femit_coverage_data: Flag<["-"], "femit-coverage-data">,
   HelpText<"Instrument the program to emit gcov coverage data when run.">;
 def coverage_data_file : Separate<["-"], "coverage-data-file">,
   HelpText<"Emit coverage data to this filename.">;
 def coverage_data_file_EQ : Joined<["-"], "coverage-data-file=">,
   Alias<coverage_data_file>;

clang/lib/CodeGen/CodeGenModule.cpp

 #include "llvm/IR/ProfileSummary.h"
 #include "llvm/ProfileData/InstrProfReader.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MD5.h"
 #include "llvm/Support/TimeProfiler.h"
+#include "llvm/Transforms/IPO/HotColdSplitting.h"
 
 using namespace clang;
 using namespace CodeGen;
 
 static llvm::cl::opt<bool> LimitedCoverage(
     "limited-coverage-experimental", llvm::cl::ZeroOrMore, llvm::cl::Hidden,
     llvm::cl::desc("Emit limited coverage mapping information (experimental)"),
     llvm::cl::init(false));
if (!D->hasAttr<OptimizeNoneAttr>()) {
     if (D->hasAttr<ColdAttr>()) {
       if (!ShouldAddOptNone)
         B.addAttribute(llvm::Attribute::OptimizeForSize);
       B.addAttribute(llvm::Attribute::Cold);
     }
 
     if (D->hasAttr<MinSizeAttr>())
       B.addAttribute(llvm::Attribute::MinSize);
+
+    if (CodeGenOpts.SplitColdCode)
+      B.addAttribute(llvm::getHotColdSplittingAttrKind());
   }
 
   F->addAttributes(llvm::AttributeList::FunctionIndex, B);
 
   unsigned alignment = D->getMaxAlignment() / Context.getCharWidth();
   if (alignment)
     F->setAlignment(llvm::Align(alignment));
 

clang/lib/Frontend/CompilerInvocation.cpp

   }
 
   Opts.TLSSize = getLastArgIntValue(Args, OPT_mtls_size_EQ, 0, Diags);
 
   if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_EQ)) {
     StringRef Val = A->getValue();
     Opts.FPDenormalMode = llvm::parseDenormalFPAttribute(Val);
     if (!Opts.FPDenormalMode.isValid())
       Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
   }
 
   if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_f32_EQ)) {
     StringRef Val = A->getValue();
     Opts.FP32DenormalMode = llvm::parseDenormalFPAttribute(Val);
     if (!Opts.FP32DenormalMode.isValid())
       Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
   }

       std::string(Args.getLastArgValue(OPT_fsymbol_partition_EQ));
 
   Opts.ForceAAPCSBitfieldLoad = Args.hasArg(OPT_ForceAAPCSBitfieldLoad);
   Opts.AAPCSBitfieldWidth =
       Args.hasFlag(OPT_AAPCSBitfieldWidth, OPT_ForceNoAAPCSBitfieldWidth, true);
 
   Opts.PassByValueIsNoAlias = Args.hasArg(OPT_fpass_by_value_is_noalias);
 
+  // -f[no-]split-cold-code
+  // This may only be enabled when optimizing, and when small code size
+  // increases are tolerable.
+  Opts.SplitColdCode =
+      (Opts.OptimizationLevel > 0) && (Opts.OptimizeSize != 2) &&
+      Args.hasFlag(OPT_fsplit_cold_code, OPT_fno_split_cold_code, false);
+  if (Arg *A = Args.getLastArg(OPT_fsplit_cold_code))
+    if (!Opts.SplitColdCode)
+      Diags.Report(diag::warn_fe_ignored_opt_split_cold_code)
+          << A->getAsString(Args) << (Opts.OptimizeSize != 2);
+
   return Success;
 }
 
 static void ParseDependencyOutputArgs(DependencyOutputOptions &Opts,
                                       ArgList &Args) {
   Opts.OutputFile = std::string(Args.getLastArgValue(OPT_dependency_file));
   Opts.Targets = Args.getAllArgValues(OPT_MT);
   Opts.IncludeSystemHeaders = Args.hasArg(OPT_sys_header_deps);

clang/test/CodeGen/split-cold-code.c

+// === Old PM ===
+// No splitting at -O0.
+// RUN: %clang_cc1 -O0 -fsplit-cold-code -mllvm -debug-pass=Structure \
+// RUN:   -emit-llvm -o - %s 2>&1 | FileCheck --check-prefix=NO-SPLIT %s
+//
+// No splitting at -Oz.
+// RUN: %clang_cc1 -Oz -fsplit-cold-code -mllvm -debug-pass=Structure \
+// RUN:   -emit-llvm -o - %s 2>&1 | FileCheck --check-prefix=NO-SPLIT %s
+//
+// No splitting by default, even at -O3.
+// RUN: %clang_cc1 -O3 -mllvm -debug-pass=Structure \
+// RUN:   -emit-llvm -o - %s 2>&1 | FileCheck --check-prefix=NO-SPLIT %s
+//
+// No splitting when it's explicitly disabled.
+// RUN: %clang_cc1 -O3 -fno-split-cold-code -mllvm -debug-pass=Structure \
+// RUN:   -emit-llvm -o - %s 2>&1 | FileCheck --check-prefix=NO-SPLIT %s
+//
+// Split at -O1.
+// RUN: %clang_cc1 -O1 -fsplit-cold-code -mllvm -debug-pass=Structure \
+// RUN:   -emit-llvm -o - %s 2>&1 | FileCheck --check-prefix=SPLIT %s
+//
+// Split at -Os.
+// RUN: %clang_cc1 -Os -fsplit-cold-code -mllvm -debug-pass=Structure \
+// RUN:   -emit-llvm -o - %s 2>&1 | FileCheck --check-prefix=SPLIT %s
+//
+// Split at -O2.
+// RUN: %clang_cc1 -O2 -fsplit-cold-code -mllvm -debug-pass=Structure \
+// RUN:   -emit-llvm -o - %s 2>&1 | FileCheck --check-prefix=SPLIT %s
+//
+// Split at -O3.
+// RUN: %clang_cc1 -O3 -fsplit-cold-code -mllvm -debug-pass=Structure \
+// RUN:   -emit-llvm -o - %s 2>&1 | FileCheck --check-prefix=SPLIT %s
+
+// === New PM (ditto) ===
+// No splitting at -O0.
+// RUN: %clang_cc1 -O0 -fsplit-cold-code -fexperimental-new-pass-manager -fdebug-pass-manager \
+// RUN:   -emit-llvm -o - %s 2>&1 | FileCheck --check-prefix=NO-SPLIT %s
+//
+// No splitting at -Oz.
+// RUN: %clang_cc1 -Oz -fsplit-cold-code -fexperimental-new-pass-manager -fdebug-pass-manager \
+// RUN:   -emit-llvm -o - %s 2>&1 | FileCheck --check-prefix=NO-SPLIT %s
+//
+// No splitting by default, even at -O3.
+// RUN: %clang_cc1 -O3 -fexperimental-new-pass-manager -fdebug-pass-manager \
+// RUN:   -emit-llvm -o - %s 2>&1 | FileCheck --check-prefix=NO-SPLIT %s
+//
+// No splitting when it's explicitly disabled.
+// RUN: %clang_cc1 -O3 -fno-split-cold-code -fexperimental-new-pass-manager -fdebug-pass-manager \
+// RUN:   -emit-llvm -o - %s 2>&1 | FileCheck --check-prefix=NO-SPLIT %s
+//
+// Split at -O1.
+// RUN: %clang_cc1 -O1 -fsplit-cold-code -fexperimental-new-pass-manager -fdebug-pass-manager \
+// RUN:   -emit-llvm -o - %s 2>&1 | FileCheck --check-prefix=SPLIT %s
+//
+// Split at -Os.
+// RUN: %clang_cc1 -Os -fsplit-cold-code -fexperimental-new-pass-manager -fdebug-pass-manager \
+// RUN:   -emit-llvm -o - %s 2>&1 | FileCheck --check-prefix=SPLIT %s
+//
+// Split at -O2.
+// RUN: %clang_cc1 -O2 -fsplit-cold-code -fexperimental-new-pass-manager -fdebug-pass-manager \
+// RUN:   -emit-llvm -o - %s 2>&1 | FileCheck --check-prefix=SPLIT %s
+//
+// Split at -O3.
+// RUN: %clang_cc1 -O3 -fsplit-cold-code -fexperimental-new-pass-manager -fdebug-pass-manager \
+// RUN:   -emit-llvm -o - %s 2>&1 | FileCheck --check-prefix=SPLIT %s
+
+// NO-SPLIT-NOT: "hot-cold-split"
+
+// SPLIT: define {{.*}} @foo() [[ATTR:#[0-9]+]]
+// SPLIT: attributes [[ATTR]] = { {{.*}} "hot-cold-split"
+
+__attribute__((used))
+void foo() {}

clang/test/Frontend/split-cold-code.c

+// RUN: %clang_cc1 -O0 -fsplit-cold-code %s 2>&1 | FileCheck %s --check-prefix=O0
+// O0: warning: '-fsplit-cold-code' has no effect when optimizations are disabled
+
+// RUN: %clang_cc1 -Oz -fsplit-cold-code %s 2>&1 | FileCheck %s --check-prefix=Oz
+// Oz: warning: '-fsplit-cold-code' has no effect when optimizing for minimum size

llvm/include/llvm/Transforms/IPO/HotColdSplitting.h

 //===- HotColdSplitting.h ---- Outline Cold Regions -------------*- 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
 //===----------------------------------------------------------------------===//
 //
 // This pass outlines cold regions to a separate function.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TRANSFORMS_IPO_HOTCOLDSPLITTING_H
 #define LLVM_TRANSFORMS_IPO_HOTCOLDSPLITTING_H
 
+#include "llvm/ADT/StringRef.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 class Module;
 class ProfileSummaryInfo;
 class BlockFrequencyInfo;
 class TargetTransformInfo;
 class OptimizationRemarkEmitter;
 class AssumptionCache;
 class DominatorTree;
 class CodeExtractorAnalysisCache;
 
+/// Get the attribute kind used to mark functions for hot/cold splitting.
+StringRef getHotColdSplittingAttrKind();
+
 /// A sequence of basic blocks.
 ///
 /// A 0-sized SmallVector is slightly cheaper to move than a std::vector.
 using BlockSequence = SmallVector<BasicBlock *, 0>;
 
 class HotColdSplitting {
 public:
   HotColdSplitting(ProfileSummaryInfo *ProfSI,

llvm/lib/Passes/PassBuilder.cpp

PipelineTuningOptions::PipelineTuningOptions() {
   ForgetAllSCEVInLoopUnroll = ForgetSCEVInLoopUnroll;
   Coroutines = false;
   LicmMssaOptCap = SetLicmMssaOptCap;
   LicmMssaNoAccForPromotionCap = SetLicmMssaNoAccForPromotionCap;
   CallGraphProfile = true;
 }
 
 extern cl::opt<bool> EnableConstraintElimination;
-extern cl::opt<bool> EnableHotColdSplit;
 extern cl::opt<bool> EnableOrderFileInstrumentation;
 
 extern cl::opt<bool> FlattenedProfileUsed;
 
 extern cl::opt<AttributorRunOption> AttributorRun;
 extern cl::opt<bool> EnableKnowledgeRetention;
 
 extern cl::opt<bool> EnableMatrix;
ModulePassManager PassBuilder::buildModuleOptimizationPipeline(
 
   // Now that we've vectorized and unrolled loops, we may have more refined
   // alignment information, try to re-derive it here.
   OptimizePM.addPass(AlignmentFromAssumptionsPass());
 
   // Split out cold code. Splitting is done late to avoid hiding context from
   // other optimizations and inadvertently regressing performance. The tradeoff
   // is that this has a higher code size cost than splitting early.
-  if (EnableHotColdSplit && !LTOPreLink)
+  if (!LTOPreLink)
     MPM.addPass(HotColdSplittingPass());
 
   // LoopSink pass sinks instructions hoisted by LICM, which serves as a
   // canonicalization pass that enables other optimizations. As a result,
   // LoopSink pass needs to be a very late IR pass to avoid undoing LICM
   // result too early.
   OptimizePM.addPass(LoopSinkPass());
 
#endif
   // CFI is disabled.
   MPM.addPass(LowerTypeTestsPass(ExportSummary, nullptr));
   // Run a second time to clean up any type tests left behind by WPD for use
   // in ICP (which is performed earlier than this in the regular LTO pipeline).
   MPM.addPass(LowerTypeTestsPass(nullptr, nullptr, true));
 
   // Enable splitting late in the FullLTO post-link pipeline. This is done in
   // the same stage in the old pass manager (\ref addLateLTOOptimizationPasses).
-  if (EnableHotColdSplit)
-    MPM.addPass(HotColdSplittingPass());
 
   // Add late LTO optimization passes.
   // Delete basic blocks, which optimization passes may have killed.
   MPM.addPass(createModuleToFunctionPassAdaptor(SimplifyCFGPass()));
 
   // Drop bodies of available eternally objects to improve GlobalDCE.
   MPM.addPass(EliminateAvailableExternallyPass());
 

llvm/lib/Transforms/IPO/HotColdSplitting.cpp

 #include "llvm/Transforms/Utils/CodeExtractor.h"
 #include "llvm/Transforms/Utils/Local.h"
 #include "llvm/Transforms/Utils/ValueMapper.h"
 #include <algorithm>
 #include <cassert>
 #include <string>
 
 #define DEBUG_TYPE "hotcoldsplit"
+#define PASS_NAME "Hot Cold Splitting"
 
 STATISTIC(NumColdRegionsFound, "Number of cold regions found.");
 STATISTIC(NumColdRegionsOutlined, "Number of cold regions outlined.");
 
 using namespace llvm;
 
 static cl::opt<bool> EnableStaticAnalysis("hot-cold-static-analysis",
                                           cl::init(true), cl::Hidden);
public:
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequired<BlockFrequencyInfoWrapperPass>();
     AU.addRequired<ProfileSummaryInfoWrapperPass>();
     AU.addRequired<TargetTransformInfoWrapperPass>();
     AU.addUsedIfAvailable<AssumptionCacheTracker>();
   }
 
   bool runOnModule(Module &M) override;
+
+  StringRef getPassName() const override { return PASS_NAME; }
 };
 
 } // end anonymous namespace
 
 /// Check whether \p F is inherently cold.
 bool HotColdSplitting::isFunctionCold(const Function &F) const {
   if (F.hasFnAttribute(Attribute::Cold))
     return true;
 
   if (F.getCallingConv() == CallingConv::Cold)
     return true;
 
   if (PSI->isFunctionEntryCold(&F))
     return true;
 
   return false;
 }
 
 // Returns false if the function should not be considered for hot-cold split
 // optimization.
 bool HotColdSplitting::shouldOutlineFrom(const Function &F) const {
+  if (!F.hasFnAttribute(getHotColdSplittingAttrKind()))
+    return false;
+
   if (F.hasFnAttribute(Attribute::AlwaysInline))
     return false;
 
   if (F.hasFnAttribute(Attribute::NoInline))
     return false;
 
   // A function marked `noreturn` may contain unreachable terminators: these
   // should not be considered cold, as the function may be a trampoline.
HotColdSplittingPass::run(Module &M, ModuleAnalysisManager &AM) {
   ProfileSummaryInfo *PSI = &AM.getResult<ProfileSummaryAnalysis>(M);
 
   if (HotColdSplitting(PSI, GBFI, GTTI, &GetORE, LookupAC).run(M))
     return PreservedAnalyses::none();
   return PreservedAnalyses::all();
 }
 
 char HotColdSplittingLegacyPass::ID = 0;
-INITIALIZE_PASS_BEGIN(HotColdSplittingLegacyPass, "hotcoldsplit",
-                      "Hot Cold Splitting", false, false)
+INITIALIZE_PASS_BEGIN(HotColdSplittingLegacyPass, "hotcoldsplit", PASS_NAME,
+                      false, false)
 INITIALIZE_PASS_DEPENDENCY(ProfileSummaryInfoWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(BlockFrequencyInfoWrapperPass)
-INITIALIZE_PASS_END(HotColdSplittingLegacyPass, "hotcoldsplit",
-                    "Hot Cold Splitting", false, false)
+INITIALIZE_PASS_END(HotColdSplittingLegacyPass, "hotcoldsplit", PASS_NAME,
+                    false, false)
 
 ModulePass *llvm::createHotColdSplittingPass() {
   return new HotColdSplittingLegacyPass();
 }
+
+StringRef llvm::getHotColdSplittingAttrKind() {
+  return "hot-cold-split";
+}

llvm/lib/Transforms/IPO/PassManagerBuilder.cpp

 static cl::opt<bool>
     EnablePrepareForThinLTO("prepare-for-thinlto", cl::init(false), cl::Hidden,
                             cl::desc("Enable preparation for ThinLTO."));
 
 static cl::opt<bool>
     EnablePerformThinLTO("perform-thinlto", cl::init(false), cl::Hidden,
                          cl::desc("Enable performing ThinLTO."));
 
-cl::opt<bool> EnableHotColdSplit("hot-cold-split", cl::init(false),
-    cl::ZeroOrMore, cl::desc("Enable hot-cold splitting pass"));
-
 static cl::opt<bool> UseLoopVersioningLICM(
     "enable-loop-versioning-licm", cl::init(false), cl::Hidden,
     cl::desc("Enable the experimental Loop Versioning LICM pass"));
 
 static cl::opt<bool>
     DisablePreInliner("disable-preinline", cl::init(false), cl::Hidden,
                       cl::desc("Disable pre-instrumentation inliner"));
 
void PassManagerBuilder::populateModulePassManager(
   // late pass of GlobalDCE.  It is capable of deleting dead cycles.
   if (OptLevel > 1) {
     MPM.add(createGlobalDCEPass());         // Remove dead fns and globals.
     MPM.add(createConstantMergePass());     // Merge dup global constants
   }
 
   // See comment in the new PM for justification of scheduling splitting at
   // this stage (\ref buildModuleSimplificationPipeline).
-  if (EnableHotColdSplit && !(PrepareForLTO || PrepareForThinLTO))
+  if (!(PrepareForLTO || PrepareForThinLTO))
     MPM.add(createHotColdSplittingPass());
 
   if (MergeFunctions)
     MPM.add(createMergeFunctionsPass());
 
   // Add Module flag "CG Profile" based on Branch Frequency Information.
   if (CallGraphProfile)
     MPM.add(createCGProfileLegacyPass());
void PassManagerBuilder::addLTOOptimizationPasses(legacy::PassManagerBase &PM) {
 
   PM.add(createJumpThreadingPass(/*FreezeSelectCond*/ true));
 }
 
 void PassManagerBuilder::addLateLTOOptimizationPasses(
     legacy::PassManagerBase &PM) {
   // See comment in the new PM for justification of scheduling splitting at
   // this stage (\ref buildLTODefaultPipeline).
-  if (EnableHotColdSplit)
-    PM.add(createHotColdSplittingPass());
 
   // Delete basic blocks, which optimization passes may have killed.
   PM.add(createCFGSimplificationPass());
 
   // Drop bodies of available externally objects to improve GlobalDCE.
   PM.add(createEliminateAvailableExternallyPass());
 
   // Now that we have optimized the program, discard unreachable functions.

llvm/test/CodeGen/AMDGPU/opt-pipeline.ll

 ; GCN-O1-NEXT:       Lazy Branch Probability Analysis
 ; GCN-O1-NEXT:       Lazy Block Frequency Analysis
 ; GCN-O1-NEXT:       Loop Pass Manager
 ; GCN-O1-NEXT:         Loop Invariant Code Motion
 ; GCN-O1-NEXT:       Optimization Remark Emitter
 ; GCN-O1-NEXT:       Warn about non-applied transformations
 ; GCN-O1-NEXT:       Alignment from assumptions
 ; GCN-O1-NEXT:     Strip Unused Function Prototypes
+; GCN-O1-NEXT:     Hot Cold Splitting
+; GCN-O1-NEXT:       FunctionPass Manager
+; GCN-O1-NEXT:         Dominator Tree Construction
+; GCN-O1-NEXT:         Natural Loop Information
+; GCN-O1-NEXT:         Post-Dominator Tree Construction
+; GCN-O1-NEXT:         Branch Probability Analysis
+; GCN-O1-NEXT:         Block Frequency Analysis
 ; GCN-O1-NEXT:     Call Graph Profile
 ; GCN-O1-NEXT:       FunctionPass Manager
 ; GCN-O1-NEXT:         Dominator Tree Construction
 ; GCN-O1-NEXT:         Natural Loop Information
 ; GCN-O1-NEXT:         Lazy Branch Probability Analysis
 ; GCN-O1-NEXT:         Lazy Block Frequency Analysis
 ; GCN-O1-NEXT:     FunctionPass Manager
 ; GCN-O1-NEXT:       Dominator Tree Construction

 ; GCN-O2-NEXT:       Loop Pass Manager
 ; GCN-O2-NEXT:         Loop Invariant Code Motion
 ; GCN-O2-NEXT:       Optimization Remark Emitter
 ; GCN-O2-NEXT:       Warn about non-applied transformations
 ; GCN-O2-NEXT:       Alignment from assumptions
 ; GCN-O2-NEXT:     Strip Unused Function Prototypes
 ; GCN-O2-NEXT:     Dead Global Elimination
 ; GCN-O2-NEXT:     Merge Duplicate Global Constants
+; GCN-O2-NEXT:     Hot Cold Splitting
+; GCN-O2-NEXT:       FunctionPass Manager
+; GCN-O2-NEXT:         Dominator Tree Construction
+; GCN-O2-NEXT:         Natural Loop Information
+; GCN-O2-NEXT:         Post-Dominator Tree Construction
+; GCN-O2-NEXT:         Branch Probability Analysis
+; GCN-O2-NEXT:         Block Frequency Analysis
 ; GCN-O2-NEXT:     Call Graph Profile
 ; GCN-O2-NEXT:       FunctionPass Manager
 ; GCN-O2-NEXT:         Dominator Tree Construction
 ; GCN-O2-NEXT:         Natural Loop Information
 ; GCN-O2-NEXT:         Lazy Branch Probability Analysis
 ; GCN-O2-NEXT:         Lazy Block Frequency Analysis
 ; GCN-O2-NEXT:     FunctionPass Manager
 ; GCN-O2-NEXT:       Dominator Tree Construction

 ; GCN-O3-NEXT:       Loop Pass Manager
 ; GCN-O3-NEXT:         Loop Invariant Code Motion
 ; GCN-O3-NEXT:       Optimization Remark Emitter
 ; GCN-O3-NEXT:       Warn about non-applied transformations
 ; GCN-O3-NEXT:       Alignment from assumptions
 ; GCN-O3-NEXT:     Strip Unused Function Prototypes
 ; GCN-O3-NEXT:     Dead Global Elimination
 ; GCN-O3-NEXT:     Merge Duplicate Global Constants
+; GCN-O3-NEXT:     Hot Cold Splitting
+; GCN-O3-NEXT:       FunctionPass Manager
+; GCN-O3-NEXT:         Dominator Tree Construction
+; GCN-O3-NEXT:         Natural Loop Information
+; GCN-O3-NEXT:         Post-Dominator Tree Construction
+; GCN-O3-NEXT:         Branch Probability Analysis
+; GCN-O3-NEXT:         Block Frequency Analysis
 ; GCN-O3-NEXT:     Call Graph Profile
 ; GCN-O3-NEXT:       FunctionPass Manager
 ; GCN-O3-NEXT:         Dominator Tree Construction
 ; GCN-O3-NEXT:         Natural Loop Information
 ; GCN-O3-NEXT:         Lazy Branch Probability Analysis
 ; GCN-O3-NEXT:         Lazy Block Frequency Analysis
 ; GCN-O3-NEXT:     FunctionPass Manager
 ; GCN-O3-NEXT:       Dominator Tree Construction

llvm/test/Other/X86/lto-hot-cold-split.ll

 ; RUN: opt -module-summary %s -o %t.bc
-; RUN: llvm-lto -hot-cold-split=true -thinlto-action=run %t.bc -debug-pass=Structure 2>&1 | FileCheck %s -check-prefix=OLDPM-ANYLTO-POSTLINK-Os
-; RUN: llvm-lto -hot-cold-split=true %t.bc -debug-pass=Structure 2>&1 | FileCheck %s -check-prefix=OLDPM-ANYLTO-POSTLINK-Os
+; RUN: llvm-lto -thinlto-action=run %t.bc -debug-pass=Structure 2>&1 | FileCheck %s -check-prefix=OLDPM-ANYLTO-POSTLINK-Os
+; RUN: llvm-lto %t.bc -debug-pass=Structure 2>&1 | FileCheck %s -check-prefix=OLDPM-ANYLTO-POSTLINK-Os
 
 ; REQUIRES: asserts
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; OLDPM-ANYLTO-POSTLINK-Os: Hot Cold Splitting

llvm/test/Other/new-pm-defaults.ll

 ; The IR below was crafted so as:
 ; 1) To have a loop, so we create a loop pass manager
 ; 2) To be "immutable" in the sense that no pass in the standard
 ;    pipeline will modify it.
 ; Since no transformations take place, we don't expect any analyses
 ; to be invalidated.
 ; Any invalidation that shows up here is a bug, unless we started modifying
 ; the IR, in which case we need to make it immutable harder.
 
 ; RUN: opt -disable-verify -debug-pass-manager \
 ; RUN:     -passes='default<O1>' -S %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-O --check-prefix=CHECK-O1 \
-; RUN:      --check-prefix=%llvmcheckext
+; RUN:      --check-prefix=%llvmcheckext --check-prefix=CHECK-O-NOPRELINK
 ; RUN: opt -disable-verify -debug-pass-manager \
 ; RUN:     -passes='default<O2>' -S  %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-O --check-prefix=CHECK-O2 \
-; RUN:      --check-prefix=CHECK-O23SZ --check-prefix=%llvmcheckext
+; RUN:      --check-prefix=CHECK-O23SZ --check-prefix=%llvmcheckext \
+; RUN:      --check-prefix=CHECK-O-NOPRELINK
 ; RUN: opt -disable-verify -debug-pass-manager \
 ; RUN:     -passes='default<O3>' -S  %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-O --check-prefix=CHECK-O3 \
-; RUN:      --check-prefix=CHECK-O23SZ --check-prefix=%llvmcheckext
+; RUN:      --check-prefix=CHECK-O23SZ --check-prefix=%llvmcheckext \
+; RUN:      --check-prefix=CHECK-O-NOPRELINK
 ; RUN: opt -disable-verify -debug-pass-manager \
 ; RUN:     -passes='default<Os>' -S %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-O --check-prefix=CHECK-Os \
-; RUN:      --check-prefix=CHECK-O23SZ --check-prefix=%llvmcheckext
+; RUN:      --check-prefix=CHECK-O23SZ --check-prefix=%llvmcheckext \
+; RUN:      --check-prefix=CHECK-O-NOPRELINK
 ; RUN: opt -disable-verify -debug-pass-manager \
 ; RUN:     -passes='default<Oz>' -S %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-O --check-prefix=CHECK-Oz \
-; RUN:     --check-prefix=CHECK-O23SZ --check-prefix=%llvmcheckext
+; RUN:     --check-prefix=CHECK-O23SZ --check-prefix=%llvmcheckext \
+; RUN:     --check-prefix=CHECK-O-NOPRELINK
 ; RUN: opt -disable-verify -debug-pass-manager \
 ; RUN:     -passes='lto-pre-link<O2>' -S %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-O --check-prefix=CHECK-O2 \
 ; RUN:     --check-prefix=CHECK-O23SZ --check-prefix=%llvmcheckext \
 ; RUN:     --check-prefix=CHECK-O2-LTO
 
 ; RUN: opt -disable-verify -debug-pass-manager \
 ; RUN:     -passes-ep-peephole='no-op-function' \
 ; RUN:     -passes='default<O3>' -S  %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-O --check-prefix=CHECK-O3 \
 ; RUN:     --check-prefix=%llvmcheckext \
-; RUN:     --check-prefix=CHECK-EP-PEEPHOLE --check-prefix=CHECK-O23SZ
+; RUN:     --check-prefix=CHECK-EP-PEEPHOLE --check-prefix=CHECK-O23SZ \
+; RUN:     --check-prefix=CHECK-O-NOPRELINK
 ; RUN: opt -disable-verify -debug-pass-manager \
 ; RUN:     -passes-ep-late-loop-optimizations='no-op-loop' \
 ; RUN:     -passes='default<O3>' -S  %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-O --check-prefix=CHECK-O3 \
 ; RUN:     --check-prefix=%llvmcheckext \
-; RUN:     --check-prefix=CHECK-EP-LOOP-LATE --check-prefix=CHECK-O23SZ
+; RUN:     --check-prefix=CHECK-EP-LOOP-LATE --check-prefix=CHECK-O23SZ \
+; RUN:     --check-prefix=CHECK-O-NOPRELINK
 ; RUN: opt -disable-verify -debug-pass-manager \
 ; RUN:     -passes-ep-loop-optimizer-end='no-op-loop' \
 ; RUN:     -passes='default<O3>' -S  %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-O --check-prefix=CHECK-O3 \
 ; RUN:     --check-prefix=%llvmcheckext \
-; RUN:     --check-prefix=CHECK-EP-LOOP-END --check-prefix=CHECK-O23SZ
+; RUN:     --check-prefix=CHECK-EP-LOOP-END --check-prefix=CHECK-O23SZ \
+; RUN:     --check-prefix=CHECK-O-NOPRELINK
 ; RUN: opt -disable-verify -debug-pass-manager \
 ; RUN:     -passes-ep-scalar-optimizer-late='no-op-function' \
 ; RUN:     -passes='default<O3>' -S  %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-O --check-prefix=CHECK-O3 \
 ; RUN:     --check-prefix=%llvmcheckext \
-; RUN:     --check-prefix=CHECK-EP-SCALAR-LATE --check-prefix=CHECK-O23SZ
+; RUN:     --check-prefix=CHECK-EP-SCALAR-LATE --check-prefix=CHECK-O23SZ \
+; RUN:     --check-prefix=CHECK-O-NOPRELINK
 ; RUN: opt -disable-verify -debug-pass-manager \
 ; RUN:     -passes-ep-cgscc-optimizer-late='no-op-cgscc' \
 ; RUN:     -passes='default<O3>' -S  %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-O --check-prefix=CHECK-O3 \
 ; RUN:     --check-prefix=%llvmcheckext \
-; RUN:     --check-prefix=CHECK-EP-CGSCC-LATE --check-prefix=CHECK-O23SZ
+; RUN:     --check-prefix=CHECK-EP-CGSCC-LATE --check-prefix=CHECK-O23SZ \
+; RUN:     --check-prefix=CHECK-O-NOPRELINK
 ; RUN: opt -disable-verify -debug-pass-manager \
 ; RUN:     -passes-ep-vectorizer-start='no-op-function' \
 ; RUN:     -passes='default<O3>' -S  %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-O --check-prefix=CHECK-O3 \
 ; RUN:     --check-prefix=%llvmcheckext \
-; RUN:     --check-prefix=CHECK-EP-VECTORIZER-START --check-prefix=CHECK-O23SZ
+; RUN:     --check-prefix=CHECK-EP-VECTORIZER-START --check-prefix=CHECK-O23SZ \
+; RUN:     --check-prefix=CHECK-O-NOPRELINK
 ; RUN: opt -disable-verify -debug-pass-manager \
 ; RUN:     -passes-ep-pipeline-start='no-op-module' \
 ; RUN:     -passes='default<O3>' -S  %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-O --check-prefix=CHECK-O3 \
 ; RUN:     --check-prefix=%llvmcheckext \
-; RUN:     --check-prefix=CHECK-EP-PIPELINE-START --check-prefix=CHECK-O23SZ
+; RUN:     --check-prefix=CHECK-EP-PIPELINE-START --check-prefix=CHECK-O23SZ \
+; RUN:     --check-prefix=CHECK-O-NOPRELINK
 ; RUN: opt -disable-verify -debug-pass-manager \
 ; RUN:     -passes-ep-pipeline-start='no-op-module' \
 ; RUN:     -passes='lto-pre-link<O3>' -S  %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-O --check-prefix=CHECK-O3 \
 ; RUN:     --check-prefix=%llvmcheckext \
 ; RUN:     --check-prefix=CHECK-EP-PIPELINE-START --check-prefix=CHECK-O23SZ
 ; RUN: opt -disable-verify -debug-pass-manager \
 ; RUN:     -passes-ep-optimizer-last='no-op-function' \
 ; RUN:     -passes='default<O3>' -S  %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-O --check-prefix=CHECK-O3 \
 ; RUN:     --check-prefix=%llvmcheckext \
-; RUN:     --check-prefix=CHECK-EP-OPTIMIZER-LAST --check-prefix=CHECK-O23SZ
+; RUN:     --check-prefix=CHECK-EP-OPTIMIZER-LAST --check-prefix=CHECK-O23SZ \
+; RUN:     --check-prefix=CHECK-O-NOPRELINK
 
 ; CHECK-O: Starting llvm::Module pass manager run.
 ; CHECK-O-NEXT: Running pass: ForceFunctionAttrsPass
 ; CHECK-EP-PIPELINE-START-NEXT: Running pass: NoOpModulePass
 ; CHECK-O-NEXT: Running pass: InferFunctionAttrsPass
 ; CHECK-O-NEXT: Running analysis: InnerAnalysisManagerProxy
 ; CHECK-O-NEXT: Running analysis: TargetLibraryAnalysis
 ; CHECK-O-NEXT: Starting llvm::Function pass manager run.

 ; CHECK-EP-CGSCC-LATE-NEXT: Running pass: NoOpCGSCCPass
 ; CHECK-O-NEXT: Finished CGSCC pass manager run.
 ; CHECK-O-NEXT: Finished llvm::Module pass manager run.
 ; CHECK-O-NEXT: Running pass: GlobalOptPass
 ; CHECK-O-NEXT: Running pass: GlobalDCEPass
 ; CHECK-O2-LTO-NOT: Running pass: EliminateAvailableExternallyPass
 ; CHECK-O: Running pass: ReversePostOrderFunctionAttrsPass
 ; CHECK-O-NEXT: Running pass: RequireAnalysisPass<{{.*}}GlobalsAA
+; CHECK-O-NOPRELINK-NEXT: Running pass: HotColdSplittingPass
 ; CHECK-O-NEXT: Starting llvm::Function pass manager run.
 ; CHECK-O-NEXT: Running pass: Float2IntPass
 ; CHECK-O-NEXT: Running pass: LowerConstantIntrinsicsPass on foo
 ; CHECK-EP-VECTORIZER-START-NEXT: Running pass: NoOpFunctionPass
 ; CHECK-EXT: Running pass: {{.*}}::Bye on foo
 ; CHECK-O-NEXT: Starting llvm::Function pass manager run.
 ; CHECK-O-NEXT: Running pass: LoopSimplifyPass
 ; CHECK-O-NEXT: Running pass: LCSSAPass

llvm/test/Other/new-pm-lto-defaults.ll

 ; CHECK-O2-NEXT: Running pass: BDCEPass on foo
 ; CHECK-O2-NEXT: Running analysis: DemandedBitsAnalysis
 ; CHECK-O2-NEXT: Running pass: InstCombinePass
 ; CHECK-EP-Peephole-NEXT: Running pass: NoOpFunctionPass
 ; CHECK-O2-NEXT: Running pass: JumpThreadingPass
 ; CHECK-O2-NEXT: Running pass: CrossDSOCFIPass
 ; CHECK-O2-NEXT: Running pass: LowerTypeTestsPass
 ; CHECK-O-NEXT: Running pass: LowerTypeTestsPass
+; CHECK-O2-NEXT: Running pass: HotColdSplittingPass
 ; CHECK-O2-NEXT: Running pass: SimplifyCFGPass
 ; CHECK-O2-NEXT: Running pass: EliminateAvailableExternallyPass
 ; CHECK-O2-NEXT: Running pass: GlobalDCEPass
 ; CHECK-O-NEXT: Running pass: PrintModulePass
 
 ; Make sure we get the IR back out without changes when we print the module.
 ; CHECK-O-LABEL: define void @foo(i32 %n) local_unnamed_addr {
 ; CHECK-O-NEXT: entry:

llvm/test/Other/new-pm-pgo.ll

 ; RUN: opt -debug-pass-manager -passes='default<O2>' -pgo-kind=pgo-instr-gen-pipeline -profile-file='temp' %s 2>&1 |FileCheck %s --check-prefixes=GEN
 ; RUN: llvm-profdata merge %S/Inputs/new-pm-pgo.proftext -o %t.profdata
-; RUN: opt -debug-pass-manager -passes='default<O2>' -pgo-kind=pgo-instr-use-pipeline -profile-file='%t.profdata' %s 2>&1 |FileCheck %s --check-prefixes=USE
+; RUN: opt -debug-pass-manager -passes='default<O2>' -pgo-kind=pgo-instr-use-pipeline -profile-file='%t.profdata' %s 2>&1 |FileCheck %s --check-prefixes=USE,USE-NOPRELINK
 ; RUN: opt -debug-pass-manager -passes='thinlto-pre-link<O2>' -pgo-kind=pgo-instr-use-pipeline -profile-file='%t.profdata' %s 2>&1 |FileCheck %s --check-prefixes=USE
 ; RUN: opt -debug-pass-manager -passes='thinlto<O2>' -pgo-kind=pgo-instr-use-pipeline -profile-file='%t.profdata' %s 2>&1 |FileCheck %s --check-prefixes=USE_POST_LINK
-; RUN: opt -debug-pass-manager -passes='default<O2>' -hot-cold-split -pgo-kind=pgo-instr-use-pipeline -profile-file='%t.profdata' %s 2>&1 |FileCheck %s --check-prefixes=USE --check-prefixes=SPLIT
 ; RUN: opt -debug-pass-manager -passes='default<O2>' -pgo-kind=pgo-sample-use-pipeline -profile-file='%S/Inputs/new-pm-pgo.prof' %s 2>&1 \
 ; RUN:     |FileCheck %s --check-prefixes=SAMPLE_USE,SAMPLE_USE_O
 ; RUN: opt -debug-pass-manager -passes='thinlto-pre-link<O2>' -pgo-kind=pgo-sample-use-pipeline -profile-file='%S/Inputs/new-pm-pgo.prof' %s 2>&1 \
 ; RUN:     |FileCheck %s --check-prefixes=SAMPLE_USE,SAMPLE_USE_PRE_LINK
 ; RUN: opt -debug-pass-manager -passes='thinlto<O2>' -pgo-kind=pgo-sample-use-pipeline -profile-file='%S/Inputs/new-pm-pgo.prof' %s 2>&1 \
 ; RUN:     |FileCheck %s --check-prefixes=SAMPLE_USE,SAMPLE_USE_POST_LINK
 ; RUN: opt -debug-pass-manager -passes='default<O2>' -new-pm-debug-info-for-profiling %s 2>&1 |FileCheck %s --check-prefixes=SAMPLE_GEN
 ;

 ; SAMPLE_USE: Running pass: LowerExpectIntrinsicPass
 ; SAMPLE_USE_POST_LINK: Running pass: InstCombinePass
 ; SAMPLE_USE: Running pass: SampleProfileLoaderPass
 ; SAMPLE_USE_O: Running pass: PGOIndirectCallPromotion
 ; SAMPLE_USE_POST_LINK-NOT: Running pass: GlobalOptPass
 ; SAMPLE_USE_POST_LINK: Running pass: PGOIndirectCallPromotion
 ; SAMPLE_USE_PRE_LINK-NOT: Running pass: PGOIndirectCallPromotion
 ; SAMPLE_GEN: Running pass: AddDiscriminatorsPass
-; SPLIT: Running pass: HotColdSplittingPass
+; USE-NOPRELINK: Running pass: HotColdSplittingPass
 
 define void @foo() {
   ret void
 }

llvm/test/Other/new-pm-thinlto-defaults.ll

 ; CHECK-O-NEXT: Finished CGSCC pass manager run.
 ; CHECK-O-NEXT: Finished llvm::Module pass manager run.
 ; CHECK-PRELINK-O-NEXT: Running pass: GlobalOptPass
 ; CHECK-POSTLINK-O-NEXT: Running pass: GlobalOptPass
 ; CHECK-POSTLINK-O-NEXT: Running pass: GlobalDCEPass
 ; CHECK-POSTLINK-O-NEXT: Running pass: EliminateAvailableExternallyPass
 ; CHECK-POSTLINK-O-NEXT: Running pass: ReversePostOrderFunctionAttrsPass
 ; CHECK-POSTLINK-O-NEXT: Running pass: RequireAnalysisPass<{{.*}}GlobalsAA
+; CHECK-POSTLINK-O-NEXT: Running pass: HotColdSplittingPass
 ; CHECK-POSTLINK-O-NEXT: Starting llvm::Function pass manager run.
 ; CHECK-POSTLINK-O-NEXT: Running pass: Float2IntPass
 ; CHECK-POSTLINK-O-NEXT: Running pass: LowerConstantIntrinsicsPass
 ; CHECK-EXT: Running pass: {{.*}}::Bye
 ; CHECK-POSTLINK-O-NEXT: Starting llvm::Function pass manager run
 ; CHECK-POSTLINK-O-NEXT: Running pass: LoopSimplifyPass
 ; CHECK-POSTLINK-O-NEXT: Running pass: LCSSAPass
 ; CHECK-POSTLINK-O-NEXT: Finished llvm::Function pass manager run

llvm/test/Other/new-pm-thinlto-postlink-pgo-defaults.ll

 ; CHECK-O-NEXT: Finished {{.*}}Function pass manager run.
 ; CHECK-O-NEXT: Finished CGSCC pass manager run.
 ; CHECK-O-NEXT: Finished {{.*}}Module pass manager run.
 ; CHECK-O-NEXT: Running pass: GlobalOptPass
 ; CHECK-O-NEXT: Running pass: GlobalDCEPass
 ; CHECK-O-NEXT: Running pass: EliminateAvailableExternallyPass
 ; CHECK-O-NEXT: Running pass: ReversePostOrderFunctionAttrsPass
 ; CHECK-O-NEXT: Running pass: RequireAnalysisPass<{{.*}}GlobalsAA
+; CHECK-O-NEXT: Running pass: HotColdSplittingPass
 ; CHECK-O-NEXT: Starting {{.*}}Function pass manager run.
 ; CHECK-O-NEXT: Running pass: Float2IntPass
 ; CHECK-O-NEXT: Running pass: LowerConstantIntrinsicsPass
 ; CHECK-EXT: Running pass: {{.*}}::Bye
 ; CHECK-O-NEXT: Starting {{.*}}Function pass manager run.
 ; CHECK-O-NEXT: Running pass: LoopSimplifyPass on foo
 ; CHECK-O-NEXT: Running pass: LCSSAPass on foo
 ; CHECK-O-NEXT: Finished {{.*}}Function pass manager run.

llvm/test/Other/new-pm-thinlto-postlink-samplepgo-defaults.ll

 ; CHECK-O-NEXT: Finished {{.*}}Function pass manager run.
 ; CHECK-O-NEXT: Finished CGSCC pass manager run.
 ; CHECK-O-NEXT: Finished {{.*}}Module pass manager run.
 ; CHECK-O-NEXT: Running pass: GlobalOptPass
 ; CHECK-O-NEXT: Running pass: GlobalDCEPass
 ; CHECK-O-NEXT: Running pass: EliminateAvailableExternallyPass
 ; CHECK-O-NEXT: Running pass: ReversePostOrderFunctionAttrsPass
 ; CHECK-O-NEXT: Running pass: RequireAnalysisPass<{{.*}}GlobalsAA
+; CHECK-O-NEXT: Running pass: HotColdSplittingPass
 ; CHECK-O-NEXT: Starting {{.*}}Function pass manager run.
 ; CHECK-O-NEXT: Running pass: Float2IntPass
 ; CHECK-O-NEXT: Running pass: LowerConstantIntrinsicsPass
 ; CHECK-EXT: Running pass: {{.*}}::Bye
 ; CHECK-O-NEXT: Starting {{.*}}Function pass manager run
 ; CHECK-O-NEXT: Running pass: LoopSimplifyPass
 ; CHECK-O-NEXT: Running pass: LCSSAPass
 ; CHECK-O-NEXT: Finished {{.*}}Function pass manager run

llvm/test/Other/opt-O2-pipeline.ll

 ; CHECK-NEXT:       Loop Pass Manager
 ; CHECK-NEXT:         Loop Invariant Code Motion
 ; CHECK-NEXT:       Optimization Remark Emitter
 ; CHECK-NEXT:       Warn about non-applied transformations
 ; CHECK-NEXT:       Alignment from assumptions
 ; CHECK-NEXT:     Strip Unused Function Prototypes
 ; CHECK-NEXT:     Dead Global Elimination
 ; CHECK-NEXT:     Merge Duplicate Global Constants
+; CHECK-NEXT:     Hot Cold Splitting
+; CHECK-NEXT:       FunctionPass Manager
+; CHECK-NEXT:         Dominator Tree Construction
+; CHECK-NEXT:         Natural Loop Information
+; CHECK-NEXT:         Post-Dominator Tree Construction
+; CHECK-NEXT:         Branch Probability Analysis
+; CHECK-NEXT:         Block Frequency Analysis
 ; CHECK-NEXT:     Call Graph Profile
 ; CHECK-NEXT:       FunctionPass Manager
 ; CHECK-NEXT:         Dominator Tree Construction
 ; CHECK-NEXT:         Natural Loop Information
 ; CHECK-NEXT:         Lazy Branch Probability Analysis
 ; CHECK-NEXT:         Lazy Block Frequency Analysis
 ; CHECK-NEXT:     FunctionPass Manager
 ; CHECK-NEXT:       Dominator Tree Construction

llvm/test/Other/opt-O3-pipeline-enable-matrix.ll

 ; CHECK-NEXT:       Loop Pass Manager
 ; CHECK-NEXT:         Loop Invariant Code Motion
 ; CHECK-NEXT:       Optimization Remark Emitter
 ; CHECK-NEXT:       Warn about non-applied transformations
 ; CHECK-NEXT:       Alignment from assumptions
 ; CHECK-NEXT:     Strip Unused Function Prototypes
 ; CHECK-NEXT:     Dead Global Elimination
 ; CHECK-NEXT:     Merge Duplicate Global Constants
+; CHECK-NEXT:     Hot Cold Splitting
+; CHECK-NEXT:       FunctionPass Manager
+; CHECK-NEXT:         Dominator Tree Construction
+; CHECK-NEXT:         Natural Loop Information
+; CHECK-NEXT:         Post-Dominator Tree Construction
+; CHECK-NEXT:         Branch Probability Analysis
+; CHECK-NEXT:         Block Frequency Analysis
 ; CHECK-NEXT:     Call Graph Profile
 ; CHECK-NEXT:       FunctionPass Manager
 ; CHECK-NEXT:         Dominator Tree Construction
 ; CHECK-NEXT:         Natural Loop Information
 ; CHECK-NEXT:         Lazy Branch Probability Analysis
 ; CHECK-NEXT:         Lazy Block Frequency Analysis
 ; CHECK-NEXT:     FunctionPass Manager
 ; CHECK-NEXT:       Dominator Tree Construction

llvm/test/Other/opt-O3-pipeline.ll

 ; CHECK-NEXT:       Loop Pass Manager
 ; CHECK-NEXT:         Loop Invariant Code Motion
 ; CHECK-NEXT:       Optimization Remark Emitter
 ; CHECK-NEXT:       Warn about non-applied transformations
 ; CHECK-NEXT:       Alignment from assumptions
 ; CHECK-NEXT:     Strip Unused Function Prototypes
 ; CHECK-NEXT:     Dead Global Elimination
 ; CHECK-NEXT:     Merge Duplicate Global Constants
+; CHECK-NEXT:     Hot Cold Splitting
+; CHECK-NEXT:       FunctionPass Manager
+; CHECK-NEXT:         Dominator Tree Construction
+; CHECK-NEXT:         Natural Loop Information
+; CHECK-NEXT:         Post-Dominator Tree Construction
+; CHECK-NEXT:         Branch Probability Analysis
+; CHECK-NEXT:         Block Frequency Analysis
 ; CHECK-NEXT:     Call Graph Profile
 ; CHECK-NEXT:       FunctionPass Manager
 ; CHECK-NEXT:         Dominator Tree Construction
 ; CHECK-NEXT:         Natural Loop Information
 ; CHECK-NEXT:         Lazy Branch Probability Analysis
 ; CHECK-NEXT:         Lazy Block Frequency Analysis
 ; CHECK-NEXT:     FunctionPass Manager
 ; CHECK-NEXT:       Dominator Tree Construction

llvm/test/Other/opt-Os-pipeline.ll

 ; CHECK-NEXT:       Loop Pass Manager
 ; CHECK-NEXT:         Loop Invariant Code Motion
 ; CHECK-NEXT:       Optimization Remark Emitter
 ; CHECK-NEXT:       Warn about non-applied transformations
 ; CHECK-NEXT:       Alignment from assumptions
 ; CHECK-NEXT:     Strip Unused Function Prototypes
 ; CHECK-NEXT:     Dead Global Elimination
 ; CHECK-NEXT:     Merge Duplicate Global Constants
+; CHECK-NEXT:     Hot Cold Splitting
+; CHECK-NEXT:       FunctionPass Manager
+; CHECK-NEXT:         Dominator Tree Construction
+; CHECK-NEXT:         Natural Loop Information
+; CHECK-NEXT:         Post-Dominator Tree Construction
+; CHECK-NEXT:         Branch Probability Analysis
+; CHECK-NEXT:         Block Frequency Analysis
 ; CHECK-NEXT:     Call Graph Profile
 ; CHECK-NEXT:       FunctionPass Manager
 ; CHECK-NEXT:         Dominator Tree Construction
 ; CHECK-NEXT:         Natural Loop Information
 ; CHECK-NEXT:         Lazy Branch Probability Analysis
 ; CHECK-NEXT:         Lazy Block Frequency Analysis
 ; CHECK-NEXT:     FunctionPass Manager
 ; CHECK-NEXT:       Dominator Tree Construction

llvm/test/Other/opt-hot-cold-split.ll

-; RUN: opt -mtriple=x86_64-- -Os -hot-cold-split=true -debug-pass=Structure -enable-new-pm=0 < %s -o /dev/null 2>&1 | FileCheck %s -check-prefix=DEFAULT-Os
-; RUN: opt -mtriple=x86_64-- -hot-cold-split=true -passes='lto-pre-link<Os>' -debug-pass-manager < %s -o /dev/null 2>&1 | FileCheck %s -check-prefix=LTO-PRELINK-Os
-; RUN: opt -mtriple=x86_64-- -hot-cold-split=true -passes='thinlto-pre-link<Os>' -debug-pass-manager < %s -o /dev/null 2>&1 | FileCheck %s -check-prefix=THINLTO-PRELINK-Os
-; RUN: opt -mtriple=x86_64-- -hot-cold-split=true -passes='lto<Os>' -debug-pass-manager < %s -o /dev/null 2>&1 | FileCheck %s -check-prefix=LTO-POSTLINK-Os
-; RUN: opt -mtriple=x86_64-- -hot-cold-split=true -passes='thinlto<Os>' -debug-pass-manager < %s -o /dev/null 2>&1 | FileCheck %s -check-prefix=THINLTO-POSTLINK-Os
+; RUN: opt -mtriple=x86_64-- -Os -debug-pass=Structure -enable-new-pm=0 < %s -o /dev/null 2>&1 | FileCheck %s -check-prefix=DEFAULT-Os
+; RUN: opt -mtriple=x86_64-- -passes='lto-pre-link<Os>' -debug-pass-manager < %s -o /dev/null 2>&1 | FileCheck %s -check-prefix=LTO-PRELINK-Os
+; RUN: opt -mtriple=x86_64-- -passes='thinlto-pre-link<Os>' -debug-pass-manager < %s -o /dev/null 2>&1 | FileCheck %s -check-prefix=THINLTO-PRELINK-Os
+; RUN: opt -mtriple=x86_64-- -passes='lto<Os>' -debug-pass-manager < %s -o /dev/null 2>&1 | FileCheck %s -check-prefix=LTO-POSTLINK-Os
+; RUN: opt -mtriple=x86_64-- -passes='thinlto<Os>' -debug-pass-manager < %s -o /dev/null 2>&1 | FileCheck %s -check-prefix=THINLTO-POSTLINK-Os
 
 ; REQUIRES: asserts
 
 ; Splitting should occur late.
 
 ; DEFAULT-Os: Hot Cold Splitting
 ; DEFAULT-Os: Simplify the CFG
 
 ; LTO-PRELINK-Os-NOT: pass: HotColdSplittingPass
 
 ; THINLTO-PRELINK-Os-NOT: Running pass: HotColdSplittingPass
 
 ; LTO-POSTLINK-Os: HotColdSplitting
 ; THINLTO-POSTLINK-Os: HotColdSplitting

llvm/test/Other/pass-pipelines.ll

 ; Test the particular pass pipelines have the expected structure. This is
 ; particularly important in order to check that the implicit scheduling of the
 ; legacy pass manager doesn't introduce unexpected structural changes in the
 ; pass pipeline.
 ;
 ; RUN: opt -enable-new-pm=0 -disable-output -disable-verify -debug-pass=Structure \
 ; RUN:     -O2 %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-O2
 ; RUN: llvm-profdata merge %S/Inputs/pass-pipelines.proftext -o %t.profdata
 ; RUN: opt -enable-new-pm=0 -disable-output -disable-verify -debug-pass=Structure \
 ; RUN:     -pgo-kind=pgo-instr-use-pipeline -profile-file='%t.profdata' \
 ; RUN:     -O2 %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-O2 --check-prefix=PGOUSE
-; RUN: opt -enable-new-pm=0 -disable-output -disable-verify -debug-pass=Structure \
-; RUN:     -pgo-kind=pgo-instr-use-pipeline -profile-file='%t.profdata' \
-; RUN:     -hot-cold-split \
-; RUN:     -O2 %s 2>&1 \
-; RUN:     | FileCheck %s --check-prefix=CHECK-O2 --check-prefix=PGOUSE --check-prefix=SPLIT
 ;
 ; In the first pipeline there should just be a function pass manager, no other
 ; pass managers.
 ; CHECK-O2: Pass Arguments:
 ; CHECK-O2-NOT: Manager
 ; CHECK-O2: FunctionPass Manager
 ; CHECK-O2-NOT: Manager
 ;

 ; CHECK-O2: Loop Pass Manager
 ; CHECK-O2-NEXT: Unroll loops
 ; CHECK-O2-NOT: Manager
 ; After vectorization and unrolling we try to do any cleanup of inserted code,
 ; including a run of LICM. This shouldn't run in the same loop pass manager as
 ; the runtime unrolling though.
 ; CHECK-O2: Loop Pass Manager
 ; CHECK-O2-NEXT: Loop Invariant Code Motion
-; SPLIT: Hot Cold Splitting
+; CHECK-O2: Hot Cold Splitting
 ; CHECK-O2: FunctionPass Manager
 ; CHECK-O2: Loop Pass Manager
 ; CHECK-O2-NEXT: Loop Sink
 ; CHECK-O2: Simplify the CFG
 ; CHECK-O2-NOT: Manager
 ;
 ; FIXME: There really shouldn't be another pass manager, especially one that
 ; just builds the domtree. It doesn't even run the verifier.
 ; CHECK-O2: Pass Arguments:
 ; CHECK-O2: FunctionPass Manager
 ; CHECK-O2-NEXT: Dominator Tree Construction
 
 define void @foo() {
   ret void
 }

llvm/test/Transforms/CodeExtractor/extract-assume.ll

 ; RUN: opt -passes="function(slp-vectorizer),module(hotcoldsplit),function(slp-vectorizer,print<assumptions>)" -disable-output %s 2>&1 | FileCheck %s
 ;
 ; Make sure this compiles. Check that function assumption cache is refreshed
 ; after extracting blocks with assume calls from the function.
 
 ; CHECK: Cached assumptions for function: fun
 ; CHECK-NEXT: Cached assumptions for function: fun.cold
 ; CHECK-NOT: icmp uge
 
 declare void @fun2(i32) #0
 
-define void @fun(i32 %x) {
+define void @fun(i32 %x) "hot-cold-split" {
 entry:
   br i1 undef, label %if.then, label %if.else
 
 if.then:
   ret void
 
 if.else:
   %cmp = icmp uge i32 %x, 64

llvm/test/Transforms/HotColdSplit/X86/do-not-split.ll

 ; RUN: opt -hotcoldsplit -hotcoldsplit-threshold=2 -S < %s | FileCheck %s
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.14.0"
 
 ; Check that these functions are not split. Outlined functions are called from a
 ; basic block named codeRepl.
 
 ; The cold region is too small to split.
 ; CHECK-LABEL: @foo
 ; CHECK-NOT: foo.cold.1
-define void @foo() {
+define void @foo() "hot-cold-split" {
 entry:
   br i1 undef, label %if.then, label %if.end
 
 if.then:                                          ; preds = %entry
   unreachable
 
 if.end:                                           ; preds = %entry
   ret void
 }
 
 ; The cold region is still too small to split.
 ; CHECK-LABEL: @bar
 ; CHECK-NOT: bar.cold.1
-define void @bar() {
+define void @bar() "hot-cold-split" {
 entry:
   br i1 undef, label %if.then, label %if.end
 
 if.then:                                          ; preds = %entry
   call void @sink()
   ret void
 
 if.end:                                           ; preds = %entry
   ret void
 }
 
 ; Make sure we don't try to outline the entire function.
 ; CHECK-LABEL: @fun
 ; CHECK-NOT: fun.cold.1
-define void @fun() {
+define void @fun() "hot-cold-split" {
 entry:
   br i1 undef, label %if.then, label %if.end
 
 if.then:                                          ; preds = %entry
   call void @sink()
   br label %if.end
 
 if.end:                                           ; preds = %entry
   ret void
 }
 
 ; Make sure we don't try to outline the entire function, especially when the
 ; entry block is cold.
 ; CHECK: define void @cold_entry_block() [[COLD_ATTR:#[0-9]+]]
 ; CHECK-NOT: cold_entry_block.cold.1
-define void @cold_entry_block() {
+define void @cold_entry_block() "hot-cold-split" {
 entry:
   call void @sink()
   ret void
 }
 
 ; Do not split `noinline` functions.
 ; CHECK-LABEL: @noinline_func
 ; CHECK-NOT: noinline_func.cold.1
-define void @noinline_func() noinline {
+define void @noinline_func() noinline "hot-cold-split" {
 entry:
   br i1 undef, label %if.then, label %if.end
 
 if.then:                                          ; preds = %entry
   call void @sink()
   br label %if.end
 
 if.end:                                           ; preds = %entry
   ret void
 }
 
 ; Do not split `alwaysinline` functions.
 ; CHECK-LABEL: @alwaysinline_func
 ; CHECK-NOT: alwaysinline_func.cold.1
-define void @alwaysinline_func() alwaysinline {
+define void @alwaysinline_func() alwaysinline "hot-cold-split" {
 entry:
   br i1 undef, label %if.then, label %if.end
 
 if.then:                                          ; preds = %entry
   call void @sink()
   br label %if.end
 
 if.end:                                           ; preds = %entry
   ret void
 }
 
 ; Don't outline infinite loops.
 ; CHECK-LABEL: @infinite_loop
 ; CHECK-NOT: infinite_loop.cold.1
-define void @infinite_loop() {
+define void @infinite_loop() "hot-cold-split" {
 entry:
   br label %loop
 
 loop:
   call void @sink()
   br label %loop
 }
 
 ; Don't count debug intrinsics towards the outlining threshold.
 ; CHECK-LABEL: @dont_count_debug_intrinsics
 ; CHECK-NOT: dont_count_debug_intrinsics.cold.1
-define void @dont_count_debug_intrinsics(i32 %arg1) !dbg !6 {
+define void @dont_count_debug_intrinsics(i32 %arg1) "hot-cold-split" !dbg !6 {
 entry:
   %var = add i32 0, 0, !dbg !11
   br i1 undef, label %if.then, label %if.end
 
 if.then:                                          ; preds = %entry
   ret void
 
 if.end:                                           ; preds = %entry
   call void @llvm.dbg.value(metadata i32 %arg1, metadata !9, metadata !DIExpression()), !dbg !11
   call void @llvm.dbg.value(metadata i32 %arg1, metadata !9, metadata !DIExpression()), !dbg !11
   call void @sink()
   ret void
 }
 
 ; CHECK-LABEL: @sanitize_address
 ; CHECK-NOT: sanitize_address.cold.1
-define void @sanitize_address() sanitize_address {
+define void @sanitize_address() sanitize_address "hot-cold-split" {
 entry:
   br i1 undef, label %if.then, label %if.end
 
 if.then:                                          ; preds = %entry
   call void @sink()
   ret void
 
 if.end:                                           ; preds = %entry
   ret void
 }
 
 ; CHECK-LABEL: @sanitize_hwaddress
 ; CHECK-NOT: sanitize_hwaddress.cold.1
-define void @sanitize_hwaddress() sanitize_hwaddress {
+define void @sanitize_hwaddress() sanitize_hwaddress "hot-cold-split" {
 entry:
   br i1 undef, label %if.then, label %if.end
 
 if.then:                                          ; preds = %entry
   call void @sink()
   ret void
 
 if.end:                                           ; preds = %entry
   ret void
 }
 
 ; CHECK-LABEL: @sanitize_thread
 ; CHECK-NOT: sanitize_thread.cold.1
-define void @sanitize_thread() sanitize_thread {
+define void @sanitize_thread() sanitize_thread "hot-cold-split" {
 entry:
   br i1 undef, label %if.then, label %if.end
 
 if.then:                                          ; preds = %entry
   call void @sink()
   ret void
 
 if.end:                                           ; preds = %entry
   ret void
 }
 
 ; CHECK-LABEL: @sanitize_memory
 ; CHECK-NOT: sanitize_memory.cold.1
-define void @sanitize_memory() sanitize_memory {
+define void @sanitize_memory() sanitize_memory "hot-cold-split" {
 entry:
   br i1 undef, label %if.then, label %if.end
 
 if.then:                                          ; preds = %entry
   call void @sink()
   ret void
 
 if.end:                                           ; preds = %entry
   ret void
 }
 
 declare void @llvm.trap() cold noreturn
 
 ; CHECK-LABEL: @nosanitize_call
 ; CHECK-NOT: nosanitize_call.cold.1
-define void @nosanitize_call() sanitize_memory {
+define void @nosanitize_call() sanitize_memory "hot-cold-split" {
 entry:
   br i1 undef, label %if.then, label %if.end
 
 if.then:                                          ; preds = %entry
   call void @llvm.trap(), !nosanitize !2
   unreachable
 
 if.end:                                           ; preds = %entry

llvm/test/Transforms/HotColdSplit/addr-taken.ll

 ; RUN: opt -hotcoldsplit -hotcoldsplit-threshold=-1 -S < %s | FileCheck %s
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.14.0"
 
 ; CHECK: define {{.*}} @foo{{.*}}#[[outlined_func_attr:[0-9]+]]
-define void @foo() noreturn cold {
+define void @foo() noreturn cold "hot-cold-split" {
   unreachable
 }
 
 ; CHECK: define {{.*}} @bar.cold.1{{.*}}#[[outlined_func_attr]]
-define void @bar() {
+define void @bar() "hot-cold-split" {
   br i1 undef, label %normal, label %exit
 
 normal:
   unreachable
 
 exit:
   ret void
 }
 
 @take_addr_of_foo = global void ()* @foo
 @take_addr_of_bar = global void ()* @bar
 
 ; CHECK: attributes #[[outlined_func_attr]] = {
 ; CHECK-SAME: cold
 ; CHECK-SAME: minsize

llvm/test/Transforms/HotColdSplit/apply-noreturn-bonus.ll

 ; REQUIRES: asserts
 ; RUN: opt -hotcoldsplit -debug-only=hotcoldsplit -S < %s -o /dev/null 2>&1 | FileCheck %s
 
 declare void @sink() cold
 
-define void @foo(i32 %arg) {
+define void @foo(i32 %arg) "hot-cold-split" {
 entry:
   br i1 undef, label %cold1, label %exit
 
 cold1:
   ; CHECK: Applying bonus for: 4 non-returning terminators
   call void @sink()
   br i1 undef, label %cold2, label %cold3
 

llvm/test/Transforms/HotColdSplit/apply-penalty-for-inputs.ll

 ; REQUIRES: asserts
 ; RUN: opt -hotcoldsplit -debug-only=hotcoldsplit -S < %s -o /dev/null 2>&1 | FileCheck %s
 
 declare void @sink(i32*, i32, i32) cold
 
 @g = global i32 0
 
-define void @foo(i32 %arg) {
+define void @foo(i32 %arg) "hot-cold-split" {
   %local = load i32, i32* @g
   br i1 undef, label %cold, label %exit
 
 cold:
   ; CHECK: Applying penalty for: 2 inputs
   call void @sink(i32* @g, i32 %arg, i32 %local)
   ret void
 
 exit:
   ret void
 }

llvm/test/Transforms/HotColdSplit/apply-penalty-for-outputs.ll

 ; REQUIRES: asserts
 ; RUN: opt -hotcoldsplit -debug-only=hotcoldsplit -S < %s -o /dev/null 2>&1 | FileCheck %s
 
 declare void @sink() cold
 
 @g = global i32 0
 
-define i32 @foo(i32 %arg) {
+define i32 @foo(i32 %arg) "hot-cold-split" {
 entry:
   br i1 undef, label %cold, label %exit
 
 cold:
   ; CHECK: Applying penalty for: 1 output
   ; CHECK: Applying penalty for: 1 non-region successors
   %local = load i32, i32* @g
   call void @sink()
   br label %exit
 
 exit:
   %p = phi i32 [ %local, %cold ], [ 0, %entry ]
   ret i32 %p
 }

llvm/test/Transforms/HotColdSplit/apply-successor-penalty.ll

 ; REQUIRES: asserts
 ; RUN: opt -hotcoldsplit -debug-only=hotcoldsplit -S < %s -o /dev/null 2>&1 | FileCheck %s
 
 declare void @sink() cold
 
 ; CHECK-LABEL: Outlining in one_non_region_successor
-define void @one_non_region_successor(i32 %arg) {
+define void @one_non_region_successor(i32 %arg) "hot-cold-split" {
 entry:
   br i1 undef, label %cold1, label %exit
 
 cold1:
   ; CHECK: Applying penalty for: 1 non-region successor
   call void @sink()
   br i1 undef, label %cold2, label %cold3
 
 cold2:
   br i1 undef, label %cold4, label %exit
 
 cold3:
   br i1 undef, label %cold4, label %exit
 
 cold4:
   unreachable
 
 exit:
   ret void
 }
 
 ; CHECK-LABEL: Outlining in two_non_region_successor
-define void @two_non_region_successors(i32 %arg) {
+define void @two_non_region_successors(i32 %arg) "hot-cold-split" {
 entry:
   br i1 undef, label %cold1, label %exit1
 
 cold1:
   ; CHECK: Applying penalty for: 2 non-region successors
   call void @sink()
   br i1 undef, label %cold2, label %cold3
 

llvm/test/Transforms/HotColdSplit/assumption-cache-invalidation.ll

 ; CHECK-NOT: @llvm.assume
 ; CHECK: }
 ; CHECK: declare {{.*}}@llvm.assume
 ; CHECK: define {{.*}}@f.cold.1(i64 %0)
 ; CHECK-LABEL: newFuncRoot:
 ; CHECK: %1 = icmp eq i64 %0, 0
 ; CHECK-NOT: call void @llvm.assume
 
-define void @f() {
+define void @f() "hot-cold-split" {
 entry:
   %0 = getelementptr inbounds %a, %a* null, i64 0, i32 1
   br label %label
 
 label:
   %1 = bitcast i64* %0 to %b**
   %2 = load %b*, %b** %1, align 8
   %3 = getelementptr inbounds %b, %b* %2, i64 undef, i32 0

llvm/test/Transforms/HotColdSplit/coldentrycount.ll

 ; REQUIRES: x86-registered-target
 ; RUN: opt -hotcoldsplit -hotcoldsplit-threshold=0 -codegenprepare -S < %s | FileCheck %s
 
 ; Test to ensure that split cold function gets 0 entry count profile
 ; metadata when compiling with pgo.
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.14.0"
 
 ; CHECK: define {{.*}} @fun{{.*}} ![[HOTPROF:[0-9]+]] {{.*}}section_prefix ![[LIKELY:[0-9]+]]
 ; CHECK: call void @fun.cold.1
 
-define void @fun() !prof !14 {
+define void @fun() "hot-cold-split" !prof !14 {
 entry:
   br i1 undef, label %if.then, label %if.else
 
 if.then:
   ret void
 
 if.else:
   call void @sink()

llvm/test/Transforms/HotColdSplit/delete-use-without-def-dbg-val.ll

 ; RUN: opt -hotcoldsplit -hotcoldsplit-threshold=0 -S < %s | FileCheck %s
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.14.0"
 
 ; CHECK-LABEL: define {{.*}}@foo(
 ; CHECK-NOT: call {{.*}}llvm.dbg.value
 
 ; CHECK-LABEL: define {{.*}}@foo.cold
 ; CHECK-NOT: call {{.*}}llvm.dbg.value
 
-define void @foo() !dbg !6 {
+define void @foo() "hot-cold-split" !dbg !6 {
 entry:
   br i1 undef, label %if.then, label %if.end
 
 if.then:                                          ; preds = %entry
   br label %cleanup
 
 if.end:                                           ; preds = %entry
   ; We expect this block to be outlined. That kills the definition of %var.

llvm/test/Transforms/HotColdSplit/duplicate-phi-preds-crash.ll

 
 ; CHECK-LABEL: define {{.*}}@realloc2(
 ; CHECK: call {{.*}}@sideeffect(
 ; CHECK: call {{.*}}@realloc(
 ; CHECK-LABEL: codeRepl:
 ; CHECK: call {{.*}}@realloc2.cold.1(i64 %size, i8* %ptr, i8** %retval.0.ce.loc)
 ; CHECK-LABEL: cleanup:
 ; CHECK-NEXT: phi i8* [ null, %if.then ], [ %call, %if.end ], [ %retval.0.ce.reload, %codeRepl ]
-define i8* @realloc2(i8* %ptr, i64 %size) {
+define i8* @realloc2(i8* %ptr, i64 %size) "hot-cold-split" {
 entry:
   %0 = add i64 %size, -1
   %1 = icmp ugt i64 %0, 184549375
   br i1 %1, label %if.then, label %if.end
 
 if.then:                                          ; preds = %entry
   call void @sideeffect(i64 %size)
   br label %cleanup

llvm/test/Transforms/HotColdSplit/eh-pads.ll

 ; RUN: opt -S -hotcoldsplit -hotcoldsplit-threshold=0 < %s | FileCheck %s
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.14.0"
 
 ; CHECK-LABEL: define {{.*}}@foo(
 ; CHECK: landingpad
 ; CHECK: sideeffect(i32 2)
-define void @foo(i32 %cond) personality i8 0 {
+define void @foo(i32 %cond) "hot-cold-split" personality i8 0 {
 entry:
   invoke void @llvm.donothing() to label %normal unwind label %exception
 
 exception:
   ; Note: EH pads are not candidates for region entry points.
   %cleanup = landingpad i8 cleanup
   br label %continue_exception
 
 continue_exception:
   call void @sideeffect(i32 0)
   call void @sink()
   ret void
 
 normal:
   call void @sideeffect(i32 2)
   ret void
 }
 
 ; See llvm.org/PR39917. It's currently not safe to outline landingpad
 ; instructions.
 ;
 ; CHECK-LABEL: define {{.*}}@bar(
 ; CHECK: landingpad
-define void @bar(i32 %cond) personality i8 0 {
+define void @bar(i32 %cond) "hot-cold-split" personality i8 0 {
 entry:
   br i1 undef, label %exit, label %continue
 
 exit:
   ret void
 
 continue:
   invoke void @sink() to label %normal unwind label %exception
 
 exception:
   ; Note: EH pads are not candidates for region entry points.
   %cleanup = landingpad i8 cleanup
   br label %trivial-eh-handler
 
 trivial-eh-handler:
   call void @sideeffect(i32 1)
   br label %normal
 
 normal:
   call void @sideeffect(i32 0)
   ret void
 }
 
-define void @baz() personality i8 0 {
+define void @baz() "hot-cold-split" personality i8 0 {
 entry:
   br i1 undef, label %exit, label %cold1
 
 exit:
   ret void
 
 cold1:
   ; The predecessor of a cold invoke may still be extracted (see baz.cold.2).

llvm/test/Transforms/HotColdSplit/eh-typeid-for.ll

 ; RUN: opt -hotcoldsplit -hotcoldsplit-threshold=0 -S < %s | FileCheck %s
 
 ; Do not outline calls to @llvm.eh.typeid.for. See llvm.org/PR39545.
 
 @_ZTIi = external constant i8*
 
 ; CHECK-LABEL: @fun
 ; CHECK-NOT: call {{.*}}@fun.cold.1
-define void @fun() {
+define void @fun() "hot-cold-split" {
 entry:
   br i1 undef, label %if.then, label %if.else
 
 if.then:
   ret void
 
 if.else:
   %t = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*))
   call void @sink()
   ret void
 }
 
 declare void @sink() cold
 
 declare i32 @llvm.eh.typeid.for(i8*)

llvm/test/Transforms/HotColdSplit/forward-dfs-reaches-marked-block.ll

 ; RUN: opt -hotcoldsplit -hotcoldsplit-threshold=0 -S < %s | FileCheck %s
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.14.0"
 
 ; CHECK-LABEL: define {{.*}}@fun
 ; CHECK: call {{.*}}@fun.cold.1(
-define void @fun() {
+define void @fun() "hot-cold-split" {
 entry:
   br i1 undef, label %if.then, label %if.else
 
 if.then:
   ; This will be marked by the inverse DFS on sink-predecesors.
   br label %sink
 
 sink:

llvm/test/Transforms/HotColdSplit/lifetime-markers-on-inputs-1.ll

 ; RUN: opt -S -hotcoldsplit -hotcoldsplit-threshold=0 < %s 2>&1 | FileCheck %s
 
 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
 
 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
 
 declare void @use(i8*)
 
 declare void @cold_use2(i8*, i8*) cold
 
 ; CHECK-LABEL: define {{.*}}@foo(
-define void @foo() {
+define void @foo() "hot-cold-split" {
 entry:
   %local1 = alloca i256
   %local2 = alloca i256
   %local1_cast = bitcast i256* %local1 to i8*
   %local2_cast = bitcast i256* %local2 to i8*
   br i1 undef, label %normalPath, label %outlinedPath
 
 normalPath:

llvm/test/Transforms/HotColdSplit/lifetime-markers-on-inputs-2.ll

 ;
 ;            entry
 ;          /       \
 ;      codeRepl  no-extract1
 ;     (lt.start)   |
 ;          \      /
 ;            exit
 ;          (lt.end)
-define void @only_lifetime_start_is_cold() {
+define void @only_lifetime_start_is_cold() "hot-cold-split" {
 ; CHECK-LABEL: @only_lifetime_start_is_cold(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[LOCAL1:%.*]] = alloca i256, align 8
 ; CHECK-NEXT:    [[LOCAL1_CAST:%.*]] = bitcast i256* [[LOCAL1]] to i8*
 ; CHECK-NEXT:    br i1 undef, label [[CODEREPL:%.*]], label [[NO_EXTRACT1:%.*]]
 ; CHECK:       codeRepl:
 ; CHECK-NEXT:    call void @llvm.lifetime.start.p0i256(i64 -1, i256* [[LOCAL1]])
-; CHECK-NEXT:    [[TARGETBLOCK:%.*]] = call i1 @only_lifetime_start_is_cold.cold.1(i8* [[LOCAL1_CAST]]) [[ATTR3:#.*]]
+; CHECK-NEXT:    [[TARGETBLOCK:%.*]] = call i1 @only_lifetime_start_is_cold.cold.1(i8* [[LOCAL1_CAST]]) [[ATTR4:#.*]]
 ; CHECK-NEXT:    br i1 [[TARGETBLOCK]], label [[NO_EXTRACT1]], label [[EXIT:%.*]]
 ; CHECK:       no-extract1:
 ; CHECK-NEXT:    br label [[EXIT]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    call void @llvm.lifetime.end.p0i8(i64 1, i8* [[LOCAL1_CAST]])
 ; CHECK-NEXT:    ret void
 ;
 entry:

 ;
 ;            entry
 ;         (lt.start)
 ;        /          \
 ;   no-extract1  codeRepl
 ;    (lt.end)
 ;        \         /
 ;            exit
-define void @only_lifetime_end_is_cold() {
+define void @only_lifetime_end_is_cold() "hot-cold-split" {
 ; CHECK-LABEL: @only_lifetime_end_is_cold(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[LOCAL1:%.*]] = alloca i256, align 8
 ; CHECK-NEXT:    [[LOCAL1_CAST:%.*]] = bitcast i256* [[LOCAL1]] to i8*
 ; CHECK-NEXT:    call void @llvm.lifetime.start.p0i8(i64 1, i8* [[LOCAL1_CAST]])
 ; CHECK-NEXT:    br i1 undef, label [[NO_EXTRACT1:%.*]], label [[CODEREPL:%.*]]
 ; CHECK:       no-extract1:
 ; CHECK-NEXT:    call void @llvm.lifetime.end.p0i8(i64 1, i8* [[LOCAL1_CAST]])
 ; CHECK-NEXT:    br label [[EXIT:%.*]]
 ; CHECK:       codeRepl:
-; CHECK-NEXT:    call void @only_lifetime_end_is_cold.cold.1(i8* [[LOCAL1_CAST]]) [[ATTR3]]
+; CHECK-NEXT:    call void @only_lifetime_end_is_cold.cold.1(i8* [[LOCAL1_CAST]]) [[ATTR4]]
 ; CHECK-NEXT:    br label [[EXIT]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   ; lt.start
   %local1 = alloca i256
   %local1_cast = bitcast i256* %local1 to i8*
extract1:
   br label %exit
 
 exit:
   ret void
 }
 
 ; In this CFG, splitting will extract the blocks extract{1,2,3}. Lifting the
 ; lifetime.end marker would be a miscompile.
-define void @do_not_lift_lifetime_end() {
+define void @do_not_lift_lifetime_end() "hot-cold-split" {
 ; CHECK-LABEL: @do_not_lift_lifetime_end(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[LOCAL1:%.*]] = alloca i256, align 8
 ; CHECK-NEXT:    [[LOCAL1_CAST:%.*]] = bitcast i256* [[LOCAL1]] to i8*
 ; CHECK-NEXT:    call void @llvm.lifetime.start.p0i8(i64 1, i8* [[LOCAL1_CAST]])
 ; CHECK-NEXT:    br label [[HEADER:%.*]]
 ; CHECK:       header:
 ; CHECK-NEXT:    call void @use(i8* [[LOCAL1_CAST]])
 ; CHECK-NEXT:    br i1 undef, label [[EXIT:%.*]], label [[CODEREPL:%.*]]
 ; CHECK:       codeRepl:
-; CHECK-NEXT:    [[TARGETBLOCK:%.*]] = call i1 @do_not_lift_lifetime_end.cold.1(i8* [[LOCAL1_CAST]]) [[ATTR3]]
+; CHECK-NEXT:    [[TARGETBLOCK:%.*]] = call i1 @do_not_lift_lifetime_end.cold.1(i8* [[LOCAL1_CAST]]) [[ATTR4]]
 ; CHECK-NEXT:    br i1 [[TARGETBLOCK]], label [[HEADER]], label [[EXIT]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   ; lt.start
   %local1 = alloca i256
   %local1_cast = bitcast i256* %local1 to i8*

llvm/test/Transforms/HotColdSplit/mark-the-whole-func-cold.ll

 ; }
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.14.0"
 
 ; CHECK: define {{.*}}@_Z3fooii{{.*}}#[[outlined_func_attr:[0-9]+]]
 ; CHECK-NOT: _Z3fooii.cold
 ; CHECK: attributes #[[outlined_func_attr]] = { {{.*}}minsize
-define void @_Z3fooii(i32, i32) {
+define void @_Z3fooii(i32, i32) "hot-cold-split" {
   %3 = alloca i32, align 4
   %4 = alloca i32, align 4
   store i32 %0, i32* %3, align 4
   store i32 %1, i32* %4, align 4
   %5 = load i32, i32* %3, align 4
   %6 = icmp ne i32 %5, 0
   br i1 %6, label %7, label %13
 

llvm/test/Transforms/HotColdSplit/minsize.ll

 ; RUN: opt -hotcoldsplit -hotcoldsplit-threshold=0 -S < %s | FileCheck %s
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.14.0"
 
 ; CHECK-LABEL: @fun
 ; CHECK: call void @fun.cold.1
-define void @fun() {
+define void @fun() "hot-cold-split" {
 entry:
   br i1 undef, label %if.then, label %if.else
 
 if.then:
   ret void
 
 if.else:
   call void @sink()
   ret void
 }
 
 ; CHECK: define {{.*}} @foo{{.*}}#[[outlined_func_attr:[0-9]+]]
-define void @foo() cold {
+define void @foo() cold "hot-cold-split" {
   ret void
 }
 
 declare void @sink() cold
 
 ; CHECK: define {{.*}} @fun.cold.1{{.*}}#[[outlined_func_attr]]
 
 ; CHECK: attributes #[[outlined_func_attr]] = {
 ; CHECK-SAME: cold
 ; CHECK-SAME: minsize

llvm/test/Transforms/HotColdSplit/multiple-exits.ll

 ; CHECK: br i1 {{.*}}, label %exit1, label %codeRepl
 ; CHECK-LABEL: codeRepl:
 ; CHECK: [[targetBlock:%.*]] = call i1 @foo.cold.1(
 ; CHECK-NEXT: br i1 [[targetBlock]], label %exit1, label %[[return:.*]]
 ; CHECK-LABEL: exit1:
 ; CHECK: call {{.*}}@sideeffect(i32 1)
 ; CHECK: [[return]]:
 ; CHECK-NEXT: ret void
-define void @foo(i32 %cond) {
+define void @foo(i32 %cond) "hot-cold-split" {
 entry:
   %tobool = icmp eq i32 %cond, 0
   br i1 %tobool, label %exit1, label %if.then
 
 if.then:                                          ; preds = %entry
   tail call void (...) @sink()
   %cmp = icmp sgt i32 %cond, 10
   br i1 %cmp, label %exit1, label %exit2

llvm/test/Transforms/HotColdSplit/noreturn.ll

 ; RUN: opt -hotcoldsplit -hotcoldsplit-threshold=0 -S < %s | FileCheck %s
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.14.0"
 
 %struct.__jmp_buf_tag = type { [8 x i64], i32, %struct.__sigset_t }
 %struct.__sigset_t = type { [16 x i64] }
 
 ; Don't outline noreturn calls which aren't explicitly marked cold.
 
 ; CHECK-LABEL: define {{.*}}@foo(
 ; CHECK-NOT: foo.cold.1
-define void @foo(i32, %struct.__jmp_buf_tag*) {
+define void @foo(i32, %struct.__jmp_buf_tag*) "hot-cold-split" {
   %3 = icmp eq i32 %0, 0
   tail call void @_Z10sideeffectv()
   br i1 %3, label %5, label %4
 
 ; <label>:4:                                      ; preds = %2
   tail call void @longjmp(%struct.__jmp_buf_tag* %1, i32 0)
   unreachable
 
; <label>:4:                                      ; preds = %2
   ; Crash with an error message, "not supposed to return".
   unreachable
 }
 
 ; Do outline noreturn calls marked cold.
 
 ; CHECK-LABEL: define {{.*}}@bar(
 ; CHECK: call {{.*}}@bar.cold.1(
-define void @bar(i32) {
+define void @bar(i32) "hot-cold-split" {
   %2 = icmp eq i32 %0, 0
   tail call void @_Z10sideeffectv()
   br i1 %2, label %sink, label %exit
 
 sink:
   tail call void @_Z10sideeffectv()
   call void @llvm.trap()
   unreachable
 
 exit:
   ret void
 }
 
 ; Do outline noreturn calls preceded by a cold call.
 
 ; CHECK-LABEL: define {{.*}}@baz(
 ; CHECK: call {{.*}}@baz.cold.1(
-define void @baz(i32, %struct.__jmp_buf_tag*) {
+define void @baz(i32, %struct.__jmp_buf_tag*) "hot-cold-split" {
   %3 = icmp eq i32 %0, 0
   tail call void @_Z10sideeffectv()
   br i1 %3, label %5, label %4
 
 ; <label>:4:                                      ; preds = %2
   call void @sink()
   tail call void @longjmp(%struct.__jmp_buf_tag* %1, i32 0)
   unreachable

llvm/test/Transforms/HotColdSplit/outline-cold-asm.ll

 ; RUN: opt -hotcoldsplit -hotcoldsplit-threshold=0 -S < %s | FileCheck %s
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.14.0"
 
 ; CHECK-LABEL: define {{.*}}@fun(
 ; CHECK: call {{.*}}@fun.cold.1(
 
 ; CHECK-LABEL: define {{.*}}@fun.cold.1(
 ; CHECK: asm ""
 
-define void @fun() {
+define void @fun() "hot-cold-split" {
 entry:
   br i1 undef, label %if.then, label %if.else
 
 if.then:
   ret void
 
 if.else:
   call void asm "", ""()
   call void @sink()
   ret void
 }
 
 declare void @sink() cold

llvm/test/Transforms/HotColdSplit/outline-disjoint-diamonds.ll

 ; RUN: opt -S -hotcoldsplit -hotcoldsplit-threshold=-1 < %s 2>&1 | FileCheck %s
 
 ; CHECK-LABEL: define {{.*}}@fun
 ; CHECK: call {{.*}}@fun.cold.2(
 ; CHECK-NEXT: ret void
 ; CHECK: call {{.*}}@fun.cold.1(
 ; CHECK-NEXT: ret void
-define void @fun() {
+define void @fun() "hot-cold-split" {
 entry:
   br i1 undef, label %A.then, label %A.else
 
 A.else:
   br label %A.then4
 
 A.then4:
   br i1 undef, label %A.then5, label %A.end

llvm/test/Transforms/HotColdSplit/outline-if-then-else.ll

 target triple = "x86_64-apple-macosx10.14.0"
 
 ; CHECK-LABEL: define {{.*}}@foo(
 ; CHECK: br i1 {{.*}}, label %codeRepl, label %if.end2
 ; CHECK-LABEL: codeRepl:
 ; CHECK-NEXT: call void @foo.cold.1
 ; CHECK-LABEL: if.end2:
 ; CHECK: call void @sideeffect(i32 2)
-define void @foo(i32 %cond) {
+define void @foo(i32 %cond) "hot-cold-split" {
 entry:
   %cond.addr = alloca i32
   store i32 %cond, i32* %cond.addr
   %0 = load i32, i32* %cond.addr
   %tobool = icmp ne i32 %0, 0
   br i1 %tobool, label %if.then, label %if.end2
 
 if.then:                                          ; preds = %entry

llvm/test/Transforms/HotColdSplit/outline-multiple-entry-region.ll

 
 ; CHECK-LABEL: define {{.*}}@_Z3fooii.cold.2
 ; CHECK: call void @_Z10sideeffecti(i32 0)
 
 ; CHECK-LABEL: define {{.*}}@_Z3fooii.cold.3
 ; CHECK: call void @_Z4sinkv
 ; CHECK: call void @_Z10sideeffecti(i32 3)
 
-define void @_Z3fooii(i32, i32) {
+define void @_Z3fooii(i32, i32) "hot-cold-split" {
   %3 = alloca i32, align 4
   %4 = alloca i32, align 4
   store i32 %0, i32* %3, align 4
   store i32 %1, i32* %4, align 4
   br label %5
 
 ; <label>:5:                                      ; preds = %2
   %6 = load i32, i32* %3, align 4

llvm/test/Transforms/HotColdSplit/outline-while-loop.ll

 target triple = "x86_64-apple-macosx10.14.0"
 
 ; CHECK-LABEL: define {{.*}}@foo(
 ; CHECK: br i1 {{.*}}, label %if.end, label %codeRepl
 ; CHECK-LABEL: codeRepl:
 ; CHECK-NEXT: call void @foo.cold.1
 ; CHECK-LABEL: if.end:
 ; CHECK: call void @sideeffect(i32 1)
-define void @foo(i32 %cond) {
+define void @foo(i32 %cond) "hot-cold-split" {
 entry:
   %tobool = icmp eq i32 %cond, 0
   br i1 %tobool, label %if.end, label %while.cond.preheader
 
 while.cond.preheader:                             ; preds = %entry
   %cmp3 = icmp sgt i32 %cond, 10
   br i1 %cmp3, label %while.body.preheader, label %while.end
 

 
 ; This is the same as @foo, but the while loop comes after the sink block.
 ; CHECK-LABEL: define {{.*}}@while_loop_after_sink(
 ; CHECK: br i1 {{.*}}, label %if.end, label %codeRepl
 ; CHECK-LABEL: codeRepl:
 ; CHECK-NEXT: call void @while_loop_after_sink.cold.1
 ; CHECK-LABEL: if.end:
 ; CHECK: call void @sideeffect(i32 1)
-define void @while_loop_after_sink(i32 %cond) {
+define void @while_loop_after_sink(i32 %cond) "hot-cold-split" {
 entry:
   %tobool = icmp eq i32 %cond, 0
   br i1 %tobool, label %if.end, label %sink
 
 sink:
   tail call void (...) @sink()
   br label %while.cond.preheader
 

llvm/test/Transforms/HotColdSplit/phi-with-distinct-outlined-values.ll

 ; RUN: opt -S -hotcoldsplit -hotcoldsplit-threshold=0 < %s | FileCheck %s
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.14.0"
 
 ; CHECK-LABEL: define {{.*}}@foo(
 ; CHECK: phi i32 [ 0, %entry ], [ %p.ce.reload, %codeRepl ]
 
 ; CHECK-LABEL: define {{.*}}@foo.cold.1(
 ; CHECK: call {{.*}}@sink
 ; CHECK: %p.ce = phi i32 [ 1, %coldbb ], [ 3, %coldbb2 ]
 ; CHECK-NEXT: store i32 %p.ce, i32* %p.ce.out 
 
-define void @foo(i32 %cond) {
+define void @foo(i32 %cond) "hot-cold-split" {
 entry:
   %tobool = icmp eq i32 %cond, 0
   br i1 %tobool, label %if.end, label %coldbb
 
 coldbb:
   call void @sink()
   call void @sideeffect()
   br i1 undef, label %if.end, label %coldbb2

llvm/test/Transforms/HotColdSplit/region-overlap.ll

 ; }
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.14.0"
 
 ; CHECK-LABEL: define {{.*}}@_Z3fooii
 ; CHECK: call {{.*}}@_Z3fooii.cold.1
 ; CHECK-NOT: _Z3fooii.cold
-define void @_Z3fooii(i32, i32) {
+define void @_Z3fooii(i32, i32) "hot-cold-split" {
   %3 = alloca i32, align 4
   %4 = alloca i32, align 4
   store i32 %0, i32* %3, align 4
   store i32 %1, i32* %4, align 4
   %5 = load i32, i32* %3, align 4
   %6 = icmp ne i32 %5, 0
   br i1 %6, label %7, label %12
 

llvm/test/Transforms/HotColdSplit/resume.ll

 ; RUN: opt -hotcoldsplit -hotcoldsplit-threshold=-1 -S < %s | FileCheck %s
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.14.0"
 
 ; Consider `resume` to be cold.
 
 ; CHECK-LABEL: define {{.*}}@foo.cold.1(
 ; CHECK: call {{.*}}@sink(
 
 declare void @sink() cold
 
-define i32 @foo() personality i8 0 {
+define i32 @foo() "hot-cold-split" personality i8 0 {
 entry:
   br i1 undef, label %pre-resume-eh, label %normal
 
 pre-resume-eh:
   call void @sink()
   br label %resume-eh
 
 resume-eh:
   resume i32 undef
 
 normal:
   ret i32 0
 }

llvm/test/Transforms/HotColdSplit/retain-section.ll

 ; RUN: opt -hotcoldsplit -hotcoldsplit-threshold=0 -S < %s | FileCheck %s
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.14.0"
 
 ; Retain section after cold code is split off.
 
 ; CHECK-LABEL: @fun
 ; CHECK: call void @fun.cold.1{{.*}}
-define void @fun() section ".text.cold" {
+define void @fun() "hot-cold-split" section ".text.cold" {
 entry:
   br i1 undef, label %if.then, label %if.else
 
 if.then:
   ret void
 
 if.else:
   call void @sink()

llvm/test/Transforms/HotColdSplit/section-splitting-custom.ll

 ; CHECK: remark: <unknown>:0:0: fun split cold code into fun.cold.1
 ; CHECK-LABEL: @fun
 ; CHECK: codeRepl:
 ; CHECK-NEXT: call void @fun.cold.1
 
 ; CHECK: define {{.*}}@fun.cold.1{{.*}} [[cold_attr:#[0-9]+]] section "__cold_custom"
 ; CHECK: attributes [[cold_attr]] = { {{.*}}noreturn
 
-define void @fun() {
+define void @fun() "hot-cold-split" {
 entry:
   br i1 undef, label %if.then, label %if.else
 
 if.then:
   ret void
 
 if.else:
   br label %if.then4

llvm/test/Transforms/HotColdSplit/section-splitting-default.ll

 ; RUN: opt -hotcoldsplit -hotcoldsplit-threshold=-1 -pass-remarks=hotcoldsplit -enable-cold-section=true -S < %s 2>&1 | FileCheck %s
 ; RUN: opt -passes=hotcoldsplit -hotcoldsplit-threshold=-1 -pass-remarks=hotcoldsplit -enable-cold-section=true -S < %s 2>&1 | FileCheck %s
 
 ; This test case is copied over from split-cold-2.ll, modified
 ; to test the `-enable-cold-section` parameter in opt.
 ; Make sure this compiles. This test used to fail with an invalid phi node: the
 ; two predecessors were outlined and the SSA representation was invalid.
 
 ; CHECK: remark: <unknown>:0:0: fun split cold code into fun.cold.1
 ; CHECK-LABEL: @fun
 ; CHECK: codeRepl:
 ; CHECK-NEXT: call void @fun.cold.1
 
 ; CHECK: define {{.*}}@fun.cold.1{{.*}} [[cold_attr:#[0-9]+]] section "__llvm_cold"
 ; CHECK: attributes [[cold_attr]] = { {{.*}}noreturn
 
-define void @fun() {
+define void @fun() "hot-cold-split" {
 entry:
   br i1 undef, label %if.then, label %if.else
 
 if.then:
   ret void
 
 if.else:
   br label %if.then4

llvm/test/Transforms/HotColdSplit/split-cold-2.ll

 ; RUN: opt -hotcoldsplit -hotcoldsplit-threshold=-1 -pass-remarks=hotcoldsplit -S < %s 2>&1 | FileCheck %s
 ; RUN: opt -passes=hotcoldsplit -hotcoldsplit-threshold=-1 -pass-remarks=hotcoldsplit -S < %s 2>&1 | FileCheck %s
 
 ; Make sure this compiles. This test used to fail with an invalid phi node: the
 ; two predecessors were outlined and the SSA representation was invalid.
 
 ; CHECK: remark: <unknown>:0:0: fun split cold code into fun.cold.1
 ; CHECK-LABEL: @fun
 ; CHECK: codeRepl:
 ; CHECK-NEXT: call void @fun.cold.1
 
 ; CHECK: define {{.*}}@fun.cold.1{{.*}} [[cold_attr:#[0-9]+]]
 ; CHECK: attributes [[cold_attr]] = { {{.*}}noreturn
 
-define void @fun() {
+define void @fun() "hot-cold-split" {
 entry:
   br i1 undef, label %if.then, label %if.else
 
 if.then:
   ret void
 
 if.else:
   br label %if.then4

llvm/test/Transforms/HotColdSplit/split-out-dbg-label.ll

 ; CHECK-LABEL: define {{.*}}@foo.cold.1
 ; CHECK: llvm.dbg.label(metadata [[LABEL:![0-9]+]]), !dbg [[LINE:![0-9]+]]
 
 ; CHECK: [[FILE:![0-9]+]] = !DIFile
 ; CHECK: [[SCOPE:![0-9]+]] = distinct !DISubprogram(name: "foo.cold.1"
 ; CHECK: [[LINE]] = !DILocation(line: 1, column: 1, scope: [[SCOPE]]
 ; CHECK: [[LABEL]] = !DILabel(scope: [[SCOPE]], name: "bye", file: [[FILE]], line: 28
 
-define void @foo(i32 %arg1) !dbg !6 {
+define void @foo(i32 %arg1) "hot-cold-split" !dbg !6 {
 entry:
   %var = add i32 0, 0, !dbg !11
   br i1 undef, label %if.then, label %if.end
 
 if.then:                                          ; preds = %entry
   ret void
 
 if.end:                                           ; preds = %entry

llvm/test/Transforms/HotColdSplit/split-out-dbg-val-of-arg.ll

 ; RUN: opt -hotcoldsplit -hotcoldsplit-threshold=0 -S < %s | FileCheck %s
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.14.0"
 
 ; CHECK-LABEL: define {{.*}}@foo.cold
 ; CHECK-NOT: llvm.dbg.value
 
-define void @foo(i32 %arg1) !dbg !6 {
+define void @foo(i32 %arg1) "hot-cold-split" !dbg !6 {
 entry:
   %var = add i32 0, 0, !dbg !11
   br i1 undef, label %if.then, label %if.end
 
 if.then:                                          ; preds = %entry
   ret void
 
 if.end:                                           ; preds = %entry

llvm/test/Transforms/HotColdSplit/split-phis-in-exit-blocks.ll

 ; CHECK:    ret void
 
 ; CHECK-LABEL: define {{.*}}@pluto.cold.1(
 ; CHECK: call {{.*}}@sideeffect(i32 1)
 ; CHECK: call {{.*}}@sink(
 ; CHECK: call {{.*}}@sideeffect(i32 3)
 ; CHECK: call {{.*}}@sideeffect(i32 4)
 ; CHECK: call {{.*}}@sideeffect(i32 5)
-define void @pluto() {
+define void @pluto() "hot-cold-split" {
 bb:
   switch i8 undef, label %bb1 [
     i8 0, label %bb7
     i8 1, label %bb7
   ]
 
 bb1:                                              ; preds = %bb
   call void @sideeffect(i32 1)

llvm/test/Transforms/HotColdSplit/stale-assume-in-original-func.ll

 ; RUN: opt -S -hotcoldsplit -hotcoldsplit-threshold=-1 < %s 2>&1 | FileCheck %s
 
 ; CHECK-LABEL: define {{.*}} @foo(
 ; CHECK-NOT: llvm.assume
 ; CHECK: call void @foo.cold.1()
 ; CHECK: llvm.assume
 ; CHECK-NEXT: ret void
 
 ; CHECK-LABEL: define {{.*}} @foo.cold.1(
 ; CHECK-NOT: llvm.assume
 ; CHECK: call void @cold()
 ; CHECK-NOT: llvm.assume
 ; CHECK: }
 
-define void @foo(i1 %cond) {
+define void @foo(i1 %cond) "hot-cold-split" {
 entry:
   br i1 %cond, label %cold, label %cont
 
 cold:
   call void @llvm.assume(i1 %cond)
   call void @cold()
   br label %cont
 

llvm/test/Transforms/HotColdSplit/succ-block-with-self-edge.ll

 ; RUN: opt -S -hotcoldsplit -hotcoldsplit-threshold=0 < %s | FileCheck %s
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.14.0"
 
 ; CHECK-LABEL: define {{.*}}@exit_block_with_same_incoming_vals
 ; CHECK: call {{.*}}@exit_block_with_same_incoming_vals.cold.1(
 ; CHECK-NOT: br i1 undef
 ; CHECK: phi i32 [ 0, %entry ], [ %p.ce.reload, %codeRepl ]
-define void @exit_block_with_same_incoming_vals(i32 %cond) {
+define void @exit_block_with_same_incoming_vals(i32 %cond) "hot-cold-split" {
 entry:
   %tobool = icmp eq i32 %cond, 0
   br i1 %tobool, label %if.end, label %coldbb
 
 coldbb:
   call void @sink()
   call void @sideeffect()
   br i1 undef, label %if.end, label %coldbb2
 
 coldbb2:
   %p2 = phi i32 [0, %coldbb], [1, %coldbb2]
   br i1 undef, label %if.end, label %coldbb2
 
 if.end:
   %p = phi i32 [0, %entry], [1, %coldbb], [1, %coldbb2]
   ret void
 }
 
 ; CHECK-LABEL: define {{.*}}@exit_block_with_distinct_incoming_vals
 ; CHECK: call {{.*}}@exit_block_with_distinct_incoming_vals.cold.1(
 ; CHECK-NOT: br i1 undef
 ; CHECK: phi i32 [ 0, %entry ], [ %p.ce.reload, %codeRepl ]
-define void @exit_block_with_distinct_incoming_vals(i32 %cond) {
+define void @exit_block_with_distinct_incoming_vals(i32 %cond) "hot-cold-split" {
 entry:
   %tobool = icmp eq i32 %cond, 0
   br i1 %tobool, label %if.end, label %coldbb
 
 coldbb:
   call void @sink()
   call void @sideeffect()
   br i1 undef, label %if.end, label %coldbb2

llvm/test/Transforms/HotColdSplit/swifterror.ll

 ; RUN: opt -hotcoldsplit -hotcoldsplit-threshold=0 -S < %s | FileCheck %s
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.14.0"
 
 %swift_error = type {i64, i8}
 
 declare void @sink() cold
 
 ; CHECK-LABEL: define {{.*}}@in_arg(
 ; CHECK: call void @in_arg.cold.1(%swift_error** swifterror
-define void @in_arg(%swift_error** swifterror %error_ptr_ref) {
+define void @in_arg(%swift_error** swifterror %error_ptr_ref) "hot-cold-split" {
   br i1 undef, label %cold, label %exit
 
 cold:
   store %swift_error* undef, %swift_error** %error_ptr_ref
   call void @sink()
   br label %exit
 
 exit:
   ret void
 }
 
 ; CHECK-LABEL: define {{.*}}@in_alloca(
 ; CHECK: call void @in_alloca.cold.1(%swift_error** swifterror
-define void @in_alloca() {
+define void @in_alloca() "hot-cold-split" {
   %err = alloca swifterror %swift_error*
   br i1 undef, label %cold, label %exit
 
 cold:
   store %swift_error* undef, %swift_error** %err
   call void @sink()
   br label %exit
 

llvm/test/Transforms/HotColdSplit/transfer-debug-info.ll

 ; CHECK: [[FILE:![0-9]+]] = !DIFile(filename: "<stdin>"
 ; CHECK: [[EMPTY_MD:![0-9]+]] = !{}
 ; CHECK: [[EMPTY_TYPE:![0-9]+]] = !DISubroutineType(types: [[EMPTY_MD]])
 ; CHECK: [[NEWSCOPE:![0-9]+]] = distinct !DISubprogram(name: "foo.cold.1", linkageName: "foo.cold.1", scope: null, file: [[FILE]], type: [[EMPTY_TYPE]], spFlags: DISPFlagLocalToUnit | DISPFlagDefinition | DISPFlagOptimized
 
 ; - Line locations in @foo.cold.1 point to the new scope for @foo.cold.1
 ; CHECK: [[LINE1]] = !DILocation(line: 1, column: 1, scope: [[NEWSCOPE]])
 
-define void @foo(i32 %arg1) !dbg !6 {
+define void @foo(i32 %arg1) "hot-cold-split" !dbg !6 {
 entry:
   %var = add i32 0, 0, !dbg !11
   br i1 undef, label %if.then, label %if.end
 
 if.then:                                          ; preds = %entry
   ret void
 
 if.end:                                           ; preds = %entry

llvm/test/Transforms/HotColdSplit/unwind.ll

 ; RUN: opt -hotcoldsplit -hotcoldsplit-threshold=0 -S < %s | FileCheck %s
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.14.0"
 
 ; Do not split out `resume` instructions.
 
 ; CHECK-LABEL: define {{.*}}@foo.cold.1(
 ; CHECK: call {{.*}}@sink(
 ; CHECK-NOT: resume i32 undef
 
 ; CHECK-NOT: noreturn
 
-define i32 @foo() personality i8 0 {
+define i32 @foo() "hot-cold-split" personality i8 0 {
 entry:
   invoke void @llvm.donothing() to label %normal unwind label %exception
 
 exception:
   %cleanup = landingpad i32 cleanup
   br i1 undef, label %normal, label %continue_exception
 
 continue_exception:

llvm/test/Transforms/HotColdSplit/update-split-loop-metadata.ll

 ; RUN: opt -hotcoldsplit -hotcoldsplit-threshold=0 -S < %s | FileCheck %s
 
 ; Check that llvm.loop metadata extracted by CodeExtractor is updated so that
 ; the debug locations it contains have the right scope.
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.14.0"
 
 ; CHECK-LABEL: define {{.*}}@basic.cold.1
 ; CHECK: br i1 {{.*}}, !llvm.loop [[LOOP_MD:![0-9]+]]
 
 ; The scope for these debug locations should be @basic.cold.1, not @basic.
 ; CHECK: [[SCOPE:![0-9]+]] = distinct !DISubprogram(name: "basic.cold.1"
 ; CHECK: [[LOOP_MD]] = distinct !{[[LOOP_MD]], [[LINE:![0-9]+]], [[LINE]]}
 ; CHECK: [[LINE]] = !DILocation(line: 1, column: 1, scope: [[SCOPE]])
 
-define void @basic(i32* %p, i32 %k) !dbg !6 {
+define void @basic(i32* %p, i32 %k) "hot-cold-split" !dbg !6 {
 entry:
   %cmp3 = icmp slt i32 0, %k
   br i1 %cmp3, label %for.body.lr.ph, label %for.end
 
 for.body.lr.ph:                                   ; preds = %entry
   br label %for.body
 
 for.body:                                         ; preds = %for.body.lr.ph, %for.body

llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/generated_funcs.ll

 ; RUN: opt -hotcoldsplit -hotcoldsplit-threshold=0 -S < %s | FileCheck %s
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.14.0"
 
-define void @foo(i32) {
+define void @foo(i32) "hot-cold-split" {
   %2 = icmp eq i32 %0, 0
   tail call void @_Z10sideeffectv()
   br i1 %2, label %sink, label %exit
 
 sink:
   tail call void @_Z10sideeffectv()
   call void @llvm.trap()
   unreachable
 
 exit:
   ret void
 }
 
-define void @bar(i32) {
+define void @bar(i32) "hot-cold-split" {
   %2 = icmp eq i32 %0, 0
   tail call void @_Z10sideeffectv()
   br i1 %2, label %sink, label %exit
 
 sink:
   tail call void @_Z10sideeffectv()
   call void @llvm.trap()
   unreachable
 
 exit:
   ret void
 }
 
 declare void @llvm.trap() noreturn cold
 declare void @_Z10sideeffectv()

llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/generated_funcs.ll.generated.expected

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --include-generated-funcs
 ; RUN: opt -hotcoldsplit -hotcoldsplit-threshold=0 -S < %s | FileCheck %s
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.14.0"
 
-define void @foo(i32) {
+define void @foo(i32) "hot-cold-split" {
   %2 = icmp eq i32 %0, 0
   tail call void @_Z10sideeffectv()
   br i1 %2, label %sink, label %exit
 
 sink:
   tail call void @_Z10sideeffectv()
   call void @llvm.trap()
   unreachable
 
 exit:
   ret void
 }
 
-define void @bar(i32) {
+define void @bar(i32) "hot-cold-split" {
   %2 = icmp eq i32 %0, 0
   tail call void @_Z10sideeffectv()
   br i1 %2, label %sink, label %exit
 
 sink:
   tail call void @_Z10sideeffectv()
   call void @llvm.trap()
   unreachable
 
 exit:
   ret void
 }
 
 declare void @llvm.trap() noreturn cold
 declare void @_Z10sideeffectv()
 ; CHECK-LABEL: @foo(
 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i32 [[TMP0:%.*]], 0
 ; CHECK-NEXT:    tail call void @_Z10sideeffectv()
 ; CHECK-NEXT:    br i1 [[TMP2]], label [[CODEREPL:%.*]], label [[EXIT:%.*]]
 ; CHECK:       codeRepl:
-; CHECK-NEXT:    call void @foo.cold.1() [[ATTR2:#.*]]
+; CHECK-NEXT:    call void @foo.cold.1() [[ATTR3:#.*]]
 ; CHECK-NEXT:    ret void
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret void
 ;
 ;
 ; CHECK-LABEL: @bar(
 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i32 [[TMP0:%.*]], 0
 ; CHECK-NEXT:    tail call void @_Z10sideeffectv()
 ; CHECK-NEXT:    br i1 [[TMP2]], label [[CODEREPL:%.*]], label [[EXIT:%.*]]
 ; CHECK:       codeRepl:
-; CHECK-NEXT:    call void @bar.cold.1() [[ATTR2]]
+; CHECK-NEXT:    call void @bar.cold.1() [[ATTR3]]
 ; CHECK-NEXT:    ret void
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret void
 ;
 ;
 ; CHECK-LABEL: @foo.cold.1(
 ; CHECK-NEXT:  newFuncRoot:
 ; CHECK-NEXT:    br label [[SINK:%.*]]

llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/generated_funcs.ll.nogenerated.expected

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -hotcoldsplit -hotcoldsplit-threshold=0 -S < %s | FileCheck %s
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.14.0"
 
-define void @foo(i32) {
+define void @foo(i32) "hot-cold-split" {
 ; CHECK-LABEL: @foo(
 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i32 [[TMP0:%.*]], 0
 ; CHECK-NEXT:    tail call void @_Z10sideeffectv()
 ; CHECK-NEXT:    br i1 [[TMP2]], label [[CODEREPL:%.*]], label [[EXIT:%.*]]
 ; CHECK:       codeRepl:
-; CHECK-NEXT:    call void @foo.cold.1() [[ATTR2:#.*]]
+; CHECK-NEXT:    call void @foo.cold.1() [[ATTR3:#.*]]
 ; CHECK-NEXT:    ret void
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret void
 ;
   %2 = icmp eq i32 %0, 0
   tail call void @_Z10sideeffectv()
   br i1 %2, label %sink, label %exit
 
 sink:
   tail call void @_Z10sideeffectv()
   call void @llvm.trap()
   unreachable
 
 exit:
   ret void
 }
 
-define void @bar(i32) {
+define void @bar(i32) "hot-cold-split" {
 ; CHECK-LABEL: @bar(
 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i32 [[TMP0:%.*]], 0
 ; CHECK-NEXT:    tail call void @_Z10sideeffectv()
 ; CHECK-NEXT:    br i1 [[TMP2]], label [[CODEREPL:%.*]], label [[EXIT:%.*]]
 ; CHECK:       codeRepl:
-; CHECK-NEXT:    call void @bar.cold.1() [[ATTR2]]
+; CHECK-NEXT:    call void @bar.cold.1() [[ATTR3]]
 ; CHECK-NEXT:    ret void
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret void
 ;
   %2 = icmp eq i32 %0, 0
   tail call void @_Z10sideeffectv()
   br i1 %2, label %sink, label %exit