Single function compilation mode.

[hoy]

Summary

As I worked on analyzing hot spots for large applications I found that iterating on a particular function was painful primarily because recompilation took a long time. For example, compiling SPEC2017/blender in LTO mode takes 30 minutes. Also a debug-only dump is huge since that has to be done for all functions. In this change we are introducing a single method compilation mode where only a function and optionally all callee functions reachable from the specified function will be compiled. This aims at compiling the minimal part of the program to replay the compilation of the user-specified function.

It might be never possible to replay a method compilation accurately without compiling the whole program. For example, a top-down interprocedural pass may propagate a value down from the root entry to the target function. A callee function on the path from entry to the target may return a value that contributes to the target compilation. That said, this change can still help if the compilation it triggers generates the same code with the original full compilation.

To minimized callee function exploding, a profile is used to narrow down the potential indirect call targets. Without a profile, alias analysis or type analysis can be used instead. This is not done in this change.

The mode works with non-LTO, thinLTO and fullLTO modes. More specifically, the following switches are introduced. All switches can be specified multiple times in one invocation with input aggregated.

1. A clang switch -fsingle-func=Name for non-LTO.
2. A lld switch --lto-single-func=Name for LTO.
3. An opt switch -single-func=Name.

[• zino]

llvm/test/Other/extract-func.ll

2 ↗

(On Diff #310070)

Can you add a test to test multiple functions? and testing fullLTO for example

[lxfind]

llvm/lib/Transforms/IPO/ExtractGV.cpp

25

We might need a better name to reflect on the fact that there can be multiple functions.
Something like "only-compile-funcs"?

[hoy]

Addressing feedbacks.

[hoy]

llvm/lib/Transforms/IPO/ExtractGV.cpp

25

How about -compile-funcs=?

[hoy]

Updating D92806: Single function compilation mode.

[hoy]

@wmi Can you please recommend a reviewer for this? Thanks!

[wmi]

In D92806#2443435, @hoy wrote:

@wmi Can you please recommend a reviewer for this? Thanks!

Maybe Chandler ([e-mail]) or Hal ([e-mail])?

[hoy]

Adding LTO, linker and clang supports.

[aeubanks]

WDYT about adding optnone to all functions except the ones you're interested in? Would that cut down the compile times?
We could reuse ForceFunctionAttrsPass rather than adding so much plumbing. This is too much plumbing for my liking.

And since this is a debug thing, instead of creating new Clang flags, we can just pass flags like -Xclang -mllvm?

clang/include/clang/Basic/CodeGenOptions.h

public:
 
   /// The name of the relocation model to use.
   llvm::Reloc::Model RelocationModel;
 
   /// If not an empty string, trap intrinsics are lowered to calls to this
   /// function instead of to trap instructions.
   std::string TrapFuncName;
 
+  /// Specific functions to compile.
+  std::vector<std::string> FunctionsToCompile;
+
   /// A list of dependent libraries.
   std::vector<std::string> DependentLibraries;
 
   /// A list of linker options to embed in the object file.
   std::vector<std::string> LinkerOptions;
 
   /// Name of the profile file to use as output for -fprofile-instr-generate,
   /// -fprofile-generate, and -fcs-profile-generate.

clang/include/clang/Driver/Options.td

def fprofile_update_EQ : Joined<["-"], "fprofile-update=">,
     MarshallingInfoFlag<"CodeGenOpts.AtomicProfileUpdate">;
 defm pseudo_probe_for_profiling : BoolFOption<"pseudo-probe-for-profiling",
   "CodeGenOpts.PseudoProbeForProfiling", DefaultsToFalse,
   ChangedBy<PosFlag, [], "Emit">, ResetBy<NegFlag, [], "Do not emit">,
   BothFlags<[NoXarchOption, CC1Option], " pseudo probes for sample profiler">>;
 def forder_file_instrumentation : Flag<["-"], "forder-file-instrumentation">,
     Group<f_Group>, Flags<[CC1Option, CoreOption]>,
     HelpText<"Generate instrumented code to collect order file into default.profraw file (overridden by '=' form of option or LLVM_PROFILE_FILE env var)">;
+def fsingle_func : Joined<["-"], "fsingle-func=">,
+    Group<f_Group>, Flags<[CC1Option, CoreOption]>,
+    HelpText<"Specify a single function to compile in non-LTO mode, for debugging only">;
 
 defm addrsig : BoolFOption<"addrsig",
   "CodeGenOpts.Addrsig", DefaultsToFalse,
   ChangedBy<PosFlag, [], "Emit">, ResetBy<NegFlag, [], "Don't emit">,
   BothFlags<[CoreOption], " an address-significance table">>;
 defm blocks : OptInFFlag<"blocks", "Enable the 'blocks' language feature", "", "", [CoreOption]>;
 def fbootclasspath_EQ : Joined<["-"], "fbootclasspath=">, Group<f_Group>;
 defm borland_extensions : BoolFOption<"borland-extensions",

clang/lib/CodeGen/BackendUtil.cpp

#include "llvm/Support/Extension.def"
   FAM.registerPass([&] { return TargetLibraryAnalysis(*TLII); });
 
   // Register all the basic analyses with the managers.
   PB.registerModuleAnalyses(MAM);
   PB.registerCGSCCAnalyses(CGAM);
   PB.registerFunctionAnalyses(FAM);
   PB.registerLoopAnalyses(LAM);
   PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
+  PB.registerFunctionsToCompile(CodeGenOpts.FunctionsToCompile);
 
   ModulePassManager MPM(CodeGenOpts.DebugPassManager);
 
   if (!CodeGenOpts.DisableLLVMPasses) {
     // Map our optimization levels into one of the distinct levels used to
     // configure the pipeline.
     PassBuilder::OptimizationLevel Level = mapToLevel(CodeGenOpts);
 

clang/lib/Driver/ToolChains/Clang.cpp

if (Args.hasFlag(options::OPT_frelaxed_template_template_args,
     CmdArgs.push_back("-frelaxed-template-template-args");
 
   // -fsized-deallocation is off by default, as it is an ABI-breaking change for
   // most platforms.
   if (Args.hasFlag(options::OPT_fsized_deallocation,
                    options::OPT_fno_sized_deallocation, false))
     CmdArgs.push_back("-fsized-deallocation");
 
+  if (Args.hasArg(options::OPT_fsingle_func)) {
+    std::vector<std::string> Names =
+        Args.getAllArgValues(options::OPT_fsingle_func);
+    for (const auto &Name : Names)
+      CmdArgs.push_back(Args.MakeArgString("-fsingle-func=" + Name));
+  }
+
   // -faligned-allocation is on by default in C++17 onwards and otherwise off
   // by default.
   if (Arg *A = Args.getLastArg(options::OPT_faligned_allocation,
                                options::OPT_fno_aligned_allocation,
                                options::OPT_faligned_new_EQ)) {
     if (A->getOption().matches(options::OPT_fno_aligned_allocation))
       CmdArgs.push_back("-fno-aligned-allocation");
     else

clang/lib/Frontend/CompilerInvocation.cpp

if (O.matches(OPT_mabi_EQ_vec_default))
       Diags.Report(diag::err_aix_default_altivec_abi)
           << A->getSpelling() << T.str();
     else {
       assert(O.matches(OPT_mabi_EQ_vec_extabi));
       Opts.EnableAIXExtendedAltivecABI = 1;
     }
   }
 
+  Opts.FunctionsToCompile = Args.getAllArgValues(OPT_fsingle_func);
   Opts.DependentLibraries = Args.getAllArgValues(OPT_dependent_lib);
   Opts.LinkerOptions = Args.getAllArgValues(OPT_linker_option);
   bool NeedLocTracking = false;
 
   Opts.OptRecordFile = std::string(Args.getLastArgValue(OPT_opt_record_file));
   if (!Opts.OptRecordFile.empty())
     NeedLocTracking = true;
 

clang/test/CodeGen/single-func.c

+// RUN: %clang %s -O0 -fexperimental-new-pass-manager -fsingle-func=foo -S -o %t0 | FileCheck %s --check-prefix=FOO
+// RUN: FileCheck %s < %t0 --check-prefix=ASM-FOO
+// RUN: %clang %s -O1 -fexperimental-new-pass-manager -fsingle-func=foo -S -o %t1 | FileCheck %s --check-prefix=RECUR-FOO
+// RUN: FileCheck %s < %t1 --check-prefix=ASM-FOO
+// RUN: %clang %s -O2 -fexperimental-new-pass-manager -fsingle-func=bar -fsingle-func=go  -S -o %t2 | FileCheck %s --check-prefix=BAR-GO
+// RUN: FileCheck %s < %t2 --check-prefix=ASM-BAR-GO
+
+int g;
+
+void bar() {
+  g = 0;
+}
+
+void go() {
+  g = 1;
+}
+
+void foo(int x) {
+  if (x == 0)
+    bar();
+  else
+    go();
+}
+
+int main()
+{
+  foo(g);
+  return 0;
+}
+
+// Check only function foo is compiled.
+// FOO: Found Function foo to compile.
+// FOO-NOT: main
+// FOO-NOT: bar
+// FOO-NOT: go
+
+// Check only function foo has code generated.
+// ASM-FOO: foo:
+// ASM-FOO-NOT: main:
+// ASM-FOO-NOT: bar:
+// ASM-FOO-NOT: go:
+
+// Check only function foo, bar and go are compiled.
+// RECUR-FOO: Found Function foo to compile.
+// RECUR-FOO: Found Function bar to compile.
+// RECUR-FOO: Found Function go to compile.
+// RECUR-FOO-NOT: main
+
+// Check only function bar and go are compiled.
+// BAR-GO: Found Function bar to compile.
+// BAR-GO: Found Function go to compile.
+// FOO-NOT: main
+// FOO-NOT: foo
+
+// Check only function foo has code generated.
+// ASM-BAR-GO: bar:
+// ASM-BAR-GO: go:
+// ASM-BAR-GO-NOT: foo:
+// ASM-BAR-GO-NOT: main:

lld/ELF/Config.h

struct Configuration {
   std::pair<llvm::StringRef, llvm::StringRef> thinLTOObjectSuffixReplace;
   std::pair<llvm::StringRef, llvm::StringRef> thinLTOPrefixReplace;
   std::string rpath;
   std::vector<VersionDefinition> versionDefinitions;
   std::vector<llvm::StringRef> auxiliaryList;
   std::vector<llvm::StringRef> filterList;
   std::vector<llvm::StringRef> searchPaths;
   std::vector<llvm::StringRef> symbolOrderingFile;
+  std::vector<llvm::StringRef> LTOFunctionsToCompile;
   std::vector<llvm::StringRef> thinLTOModulesToCompile;
   std::vector<llvm::StringRef> undefined;
   std::vector<SymbolVersion> dynamicList;
   std::vector<uint8_t> buildIdVector;
   llvm::MapVector<std::pair<const InputSectionBase *, const InputSectionBase *>,
                   uint64_t>
       callGraphProfile;
   bool allowMultipleDefinition;

lld/ELF/Driver.cpp

config->thinLTOIndexOnly = args.hasArg(OPT_thinlto_index_only) ||
                              args.hasArg(OPT_thinlto_index_only_eq);
   config->thinLTOIndexOnlyArg = args.getLastArgValue(OPT_thinlto_index_only_eq);
   config->thinLTOObjectSuffixReplace =
       getOldNewOptions(args, OPT_thinlto_object_suffix_replace_eq);
   config->thinLTOPrefixReplace =
       getOldNewOptions(args, OPT_thinlto_prefix_replace_eq);
   config->thinLTOModulesToCompile =
       args::getStrings(args, OPT_thinlto_single_module_eq);
+  config->LTOFunctionsToCompile =
+      args::getStrings(args, OPT_lto_single_func_eq);
   config->timeTraceEnabled = args.hasArg(OPT_time_trace);
   config->timeTraceGranularity =
       args::getInteger(args, OPT_time_trace_granularity, 500);
   config->trace = args.hasArg(OPT_trace);
   config->undefined = args::getStrings(args, OPT_undefined);
   config->undefinedVersion =
       args.hasFlag(OPT_undefined_version, OPT_no_undefined_version, true);
   config->unique = args.hasArg(OPT_unique);
if (errorCount())
     return;
 
   // If -thinlto-index-only is given, we should create only "index
   // files" and not object files. Index file creation is already done
   // in addCombinedLTOObject, so we are done if that's the case.
   // Likewise, --plugin-opt=emit-llvm and --plugin-opt=emit-asm are the
   // options to create output files in bitcode or assembly code
   // repsectively. No object files are generated.
-  // Also bail out here when only certain thinLTO modules are specified for
-  // compilation. The intermediate object file are the expected output.
+  // Also bail out here when only certain functions or thinLTO modules are
+  // specified for compilation. The intermediate object file are the expected
+  // output.
   if (config->thinLTOIndexOnly || config->emitLLVM || config->ltoEmitAsm ||
-      !config->thinLTOModulesToCompile.empty())
+      !config->thinLTOModulesToCompile.empty() ||
+      !config->LTOFunctionsToCompile.empty())
     return;
 
   // Apply symbol renames for -wrap and combine foo@v1 and foo@@v1.
   redirectSymbols(wrapped);
 
   {
     llvm::TimeTraceScope timeScope("Aggregate sections");
     // Now that we have a complete list of input files.

lld/ELF/LTO.cpp

static lto::Config createConfig() {
   c.DwoDir = std::string(config->dwoDir);
 
   c.HasWholeProgramVisibility = config->ltoWholeProgramVisibility;
   c.AlwaysEmitRegularLTOObj = !config->ltoObjPath.empty();
 
   for (const llvm::StringRef &name : config->thinLTOModulesToCompile)
     c.ThinLTOModulesToCompile.emplace_back(name);
 
+  for (const llvm::StringRef &name : config->LTOFunctionsToCompile)
+    c.LTOFunctionsToCompile.emplace_back(name);
+
   c.TimeTraceEnabled = config->timeTraceEnabled;
   c.TimeTraceGranularity = config->timeTraceGranularity;
 
   c.CSIRProfile = std::string(config->ltoCSProfileFile);
   c.RunCSIRInstr = config->ltoCSProfileGenerate;
 
   if (config->emitLLVM) {
     c.PostInternalizeModuleHook = [](size_t task, const Module &m) {

lld/ELF/Options.td

 def thinlto_emit_imports_files: FF<"thinlto-emit-imports-files">;
 def thinlto_index_only: FF<"thinlto-index-only">;
 def thinlto_index_only_eq: JJ<"thinlto-index-only=">;
 def thinlto_jobs: JJ<"thinlto-jobs=">,
   HelpText<"Number of ThinLTO jobs. Default to --threads=">;
 def thinlto_object_suffix_replace_eq: JJ<"thinlto-object-suffix-replace=">;
 def thinlto_prefix_replace_eq: JJ<"thinlto-prefix-replace=">;
 def thinlto_single_module_eq: JJ<"thinlto-single-module=">,
-  HelpText<"Specific a single module to compile in ThinLTO mode, for debugging only">;
+  HelpText<"Specify a single module to compile in ThinLTO mode, for debugging only">;
+def lto_single_func_eq: JJ<"lto-single-func=">,
+  HelpText<"Specify a single function to compile in LTO mode, for debugging only">;
 
 def: J<"plugin-opt=O">, Alias<lto_O>, HelpText<"Alias for --lto-O">;
 def: F<"plugin-opt=debug-pass-manager">,
   Alias<lto_debug_pass_manager>, HelpText<"Alias for --lto-debug-pass-manager">;
 def: F<"plugin-opt=disable-verify">, Alias<disable_verify>, HelpText<"Alias for --disable-verify">;
 def plugin_opt_dwo_dir_eq: J<"plugin-opt=dwo_dir=">,
   HelpText<"Directory to store .dwo files when LTO and debug fission are used">;
 def plugin_opt_emit_asm: F<"plugin-opt=emit-asm">,

lld/test/ELF/lto/lto-single-func.ll

+; REQUIRES: x86
+; RUN: rm -fr %t && mkdir %t && cd %t
+
+; RUN: opt -thinlto-bc -o thin1.o %s
+; RUN: opt -thinlto-bc -o thin2.o %S/Inputs/thin2.ll
+; RUN: ld.lld thin1.o thin2.o --lto-single-func=foo --lto-obj-path=thin.o -plugin-opt=new-pass-manager  | FileCheck %s --check-prefix=RECUR-FOO
+; RUN: llvm-readelf -S -s thin.o | FileCheck %s --check-prefix=THIN-DEFAULT
+; RUN: llvm-readelf -S -s thin.o1 | FileCheck %s --check-prefix=THIN-FOO
+; RUN: not ls thin.o2
+
+; RUN: ld.lld thin1.o thin2.o --lto-single-func=foo  --lto-single-func=blah --lto-obj-path=thin.o -plugin-opt=new-pass-manager  | FileCheck %s --check-prefix=RECUR-FOO-BLAH
+; RUN: llvm-readelf -S -s thin.o | FileCheck %s --check-prefix=THIN-DEFAULT
+; RUN: llvm-readelf -S -s thin.o1 | FileCheck %s --check-prefix=THIN-FOO
+; RUN: llvm-readelf -S -s thin.o2 | FileCheck %s --check-prefix=THIN-BLAH
+
+; RUN: opt -o full1.o %s
+; RUN: opt -o full2.o %S/Inputs/thin2.ll
+; RUN: ld.lld full1.o full2.o --lto-single-func=foo --lto-obj-path=full.o -plugin-opt=new-pass-manager  | FileCheck %s --check-prefix=RECUR-FOO
+; RUN: llvm-readelf -S -s full.o | FileCheck %s --check-prefix=LTO-FOO
+
+;; Check only function foo, bar and go are compiled.
+; RECUR-FOO: Found Function foo to compile.
+; RECUR-FOO: Found Function bar to compile.
+; RECUR-FOO: Found Function go to compile.
+; RECUR-FOO-NOT: main
+
+;; Check only function foo and bar are compiled.
+; RECUR-FOO-BLAH: Found Function blah to compile.
+; RECUR-FOO-BLAH: Found Function foo to compile.
+; RECUR-FOO-BLAH: Found Function bar to compile.
+; RECUR-FOO-BLAH: Found Function go to compile.
+; RECUR-FOO-BLAH-NOT: main
+
+; THIN-DEFAULT:     Value        Size Type Bind   Vis     Ndx Name
+; THIN-DEFAULT: 0000000000000000    0 FILE LOCAL  DEFAULT ABS ld-temp.o
+; THIN-FOO:         Value        Size Type Bind   Vis     Ndx Name
+; THIN-FOO:     0000000000000000    0 FILE LOCAL  DEFAULT ABS lto-single-func.ll
+; THIN-FOO:     0000000000000000   28 FUNC GLOBAL HIDDEN   3  foo
+; THIN-FOO-NOT:  {{.*}} bar
+
+; THIN-BLAH     0000000000000000    0 FILE LOCAL  DEFAULT ABS thin2.ll
+; THIN-BLAH:    0000000000000000   4  FUNC GLOBAL HIDDEN   3  blah
+
+; LTO-FOO:     0000000000000000    0 FILE LOCAL  DEFAULT ABS ld-temp.o
+; LTO-FOO:     0000000000000000   28 FUNC GLOBAL HIDDEN   3  foo
+; LTO-FOO-NOT:  {{.*}} bar
+
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-scei-ps4"
+
+define dso_local i32 @main(i32 %x, i32 (i32)* %f) {
+  call i32 @foo(i32 %x, i32 (i32)* %f)
+  ret i32 1
+}
+
+define dso_local i32 @foo(i32 %x, i32 (i32)* %f) {
+entry:
+  %retval = alloca i32, align 4
+  %x.addr = alloca i32, align 4
+  store i32 %x, i32* %x.addr, align 4
+  %0 = load i32, i32* %x.addr, align 4
+  %cmp = icmp eq i32 %0, 0
+  br i1 %cmp, label %if.then, label %if.else
+
+if.then:
+  call i32 @bar()
+  store i32 1, i32* %retval, align 4
+  br label %return
+
+if.else:
+  call i32 %f(i32 1), !prof !0
+  store i32 2, i32* %retval, align 4
+  br label %return
+
+return:
+  %3 = load i32, i32* %retval, align 4
+  ret i32 %3
+}
+
+define dso_local i32 @bar() {
+entry:
+  ret i32 8
+}
+
+define dso_local i32 @go() {
+entry:
+  ret i32 6
+}
+
+!0 = !{!"VP", i32 0, i64 7, i64 -5182264717993193164, i64 5, i64 -1069303473483922844, i64 2}

llvm/include/llvm/LTO/Config.h

struct Config {
   bool DebugPassManager = false;
 
   /// Statistics output file path.
   std::string StatsFile;
 
   /// Specific thinLTO modules to compile.
   std::vector<std::string> ThinLTOModulesToCompile;
 
+  /// Specific functions to compile.
+  std::vector<std::string> LTOFunctionsToCompile;
+
   /// Time trace enabled.
   bool TimeTraceEnabled = false;
 
   /// Time trace granularity.
   unsigned TimeTraceGranularity = 500;
 
   bool ShouldDiscardValueNames = true;
   DiagnosticHandlerFunction DiagHandler;

llvm/include/llvm/Passes/PassBuilder.h

 /// of the built-in passes, and those may reference these members during
 /// construction.
 class PassBuilder {
   bool DebugLogging;
   TargetMachine *TM;
   PipelineTuningOptions PTO;
   Optional<PGOOptions> PGOOpt;
   PassInstrumentationCallbacks *PIC;
+  /// Specific functions to compile.
+  std::vector<std::string> FunctionsToCompile;
 
 public:
   /// A struct to capture parsed pass pipeline names.
   ///
   /// A pipeline is defined as a series of names, each of which may in itself
   /// recursively contain a nested pipeline. A name is either the name of a pass
   /// (e.g. "instcombine") or the name of a pipeline type (e.g. "cgscc"). If the
   /// name is the name of a pass, the InnerPipeline is empty, since passes
public:
 
   /// Registers all available loop analysis passes.
   ///
   /// This is an interface that can be used to populate a \c LoopAnalysisManager
   /// with all registered loop analyses. Callers can still manually register any
   /// additional analyses.
   void registerLoopAnalyses(LoopAnalysisManager &LAM);
 
+  /// Registers specific functions to compile.
+  void registerFunctionsToCompile(const std::vector<std::string> &Names);
+
   /// Construct the core LLVM function canonicalization and simplification
   /// pipeline.
   ///
   /// This is a long pipeline and uses most of the per-function optimization
   /// passes in LLVM to canonicalize and simplify the IR. It is suitable to run
   /// repeatedly over the IR and is not expected to destroy important
   /// information about the semantics of the IR.
   ///

llvm/include/llvm/Transforms/IPO/FuncExtractor.h

+//===- FuncExtractor.h - Function extraction pass ----------------*- C++
+//-*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+/// \file
+/// This file extracts necessary functions to favor -single-func complication.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_IPO_FUNCEXTRACTOR_H
+#define LLVM_TRANSFORMS_IPO_FUNCEXTRACTOR_H
+
+#include "llvm/IR/PassManager.h"
+#include <string>
+
+namespace llvm {
+
+class Module;
+
+class FuncExtractorPass : public PassInfoMixin<FuncExtractorPass> {
+  std::vector<std::string> FunctionsToCompile;
+  bool InLTO;
+  // Recursively extract possible callees.
+  bool Recursive;
+
+public:
+  FuncExtractorPass(const std::vector<std::string> &FunctionsToCompile,
+                    bool InLTO, bool Recursive = true)
+      : FunctionsToCompile(FunctionsToCompile), InLTO(InLTO),
+        Recursive(Recursive) {}
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+};
+
+} // end namespace llvm
+
+#endif // LLVM_TRANSFORMS_IPO_FUNCEXTRACTOR_H

llvm/lib/LTO/LTO.cpp

 Error LTO::addThinLTO(BitcodeModule BM, ArrayRef<InputFile::Symbol> Syms,
                       const SymbolResolution *&ResI,
                       const SymbolResolution *ResE) {
   if (Error Err =
           BM.readSummary(ThinLTO.CombinedIndex, BM.getModuleIdentifier(),
                          ThinLTO.ModuleMap.size()))
     return Err;
 
+  const SymbolResolution *OrigResI = ResI;
   for (const InputFile::Symbol &Sym : Syms) {
     assert(ResI != ResE);
     SymbolResolution Res = *ResI++;
 
     if (!Sym.getIRName().empty()) {
       auto GUID = GlobalValue::getGUID(GlobalValue::getGlobalIdentifier(
           Sym.getIRName(), GlobalValue::ExternalLinkage, ""));
       if (Res.Prevailing) {
for (const std::string &Name : Conf.ThinLTOModulesToCompile) {
       if (BM.getModuleIdentifier().contains(Name)) {
         ThinLTO.ModulesToCompile->insert({BM.getModuleIdentifier(), BM});
         llvm::errs() << "[ThinLTO] Selecting " << BM.getModuleIdentifier()
                      << " to compile\n";
       }
     }
   }
 
+  if (!Conf.LTOFunctionsToCompile.empty()) {
+    assert(Conf.ThinLTOModulesToCompile.empty() &&
+           "Single function mode should not be combined with single "
+           "module mode.");
+    if (!ThinLTO.ModulesToCompile)
+      ThinLTO.ModulesToCompile = ModuleMapType();
+    std::set<StringRef> FuncNames(Conf.LTOFunctionsToCompile.begin(),
+                                  Conf.LTOFunctionsToCompile.end());
+    for (const InputFile::Symbol &Sym : Syms) {
+      SymbolResolution Res = *OrigResI++;
+      // Only compile a name-matched function that is prevailing.
+      if (Res.Prevailing && FuncNames.count(Sym.getIRName()))
+        ThinLTO.ModulesToCompile->insert({BM.getModuleIdentifier(), BM});
+    }
+  }
+
   return Error::success();
 }
 
 unsigned LTO::getMaxTasks() const {
   CalledGetMaxTasks = true;
   auto ModuleCount = ThinLTO.ModulesToCompile ? ThinLTO.ModulesToCompile->size()
                                               : ThinLTO.ModuleMap.size();
   return RegularLTO.ParallelCodeGenParallelismLevel + ModuleCount;

llvm/lib/LTO/LTOBackend.cpp

static void runNewPMPasses(const Config &Conf, Module &Mod, TargetMachine *TM,
   FAM.registerPass([&] { return std::move(AA); });
 
   // Register all the basic analyses with the managers.
   PB.registerModuleAnalyses(MAM);
   PB.registerCGSCCAnalyses(CGAM);
   PB.registerFunctionAnalyses(FAM);
   PB.registerLoopAnalyses(LAM);
   PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
+  PB.registerFunctionsToCompile(Conf.LTOFunctionsToCompile);
 
   ModulePassManager MPM(Conf.DebugPassManager);
 
   if (!Conf.DisableVerify)
     MPM.addPass(VerifierPass());
 
   PassBuilder::OptimizationLevel OL;
 
static void runNewPMCustomPasses(const Config &Conf, Module &Mod,
   FAM.registerPass([&] { return std::move(AA); });
 
   // Register all the basic analyses with the managers.
   PB.registerModuleAnalyses(MAM);
   PB.registerCGSCCAnalyses(CGAM);
   PB.registerFunctionAnalyses(FAM);
   PB.registerLoopAnalyses(LAM);
   PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
+  PB.registerFunctionsToCompile(Conf.LTOFunctionsToCompile);
 
   ModulePassManager MPM;
 
   // Always verify the input.
   MPM.addPass(VerifierPass());
 
   // Now, add all the passes we've been requested to.
   if (auto Err = PB.parsePassPipeline(MPM, PipelineDesc))

llvm/lib/Passes/PassBuilder.cpp

 #include "llvm/Transforms/IPO/Attributor.h"
 #include "llvm/Transforms/IPO/BlockExtractor.h"
 #include "llvm/Transforms/IPO/CalledValuePropagation.h"
 #include "llvm/Transforms/IPO/ConstantMerge.h"
 #include "llvm/Transforms/IPO/CrossDSOCFI.h"
 #include "llvm/Transforms/IPO/DeadArgumentElimination.h"
 #include "llvm/Transforms/IPO/ElimAvailExtern.h"
 #include "llvm/Transforms/IPO/ForceFunctionAttrs.h"
+#include "llvm/Transforms/IPO/FuncExtractor.h"
 #include "llvm/Transforms/IPO/FunctionAttrs.h"
 #include "llvm/Transforms/IPO/FunctionImport.h"
 #include "llvm/Transforms/IPO/GlobalDCE.h"
 #include "llvm/Transforms/IPO/GlobalOpt.h"
 #include "llvm/Transforms/IPO/GlobalSplit.h"
 #include "llvm/Transforms/IPO/HotColdSplitting.h"
 #include "llvm/Transforms/IPO/InferFunctionAttrs.h"
 #include "llvm/Transforms/IPO/Inliner.h"
bool shouldPopulateClassToPassNames() {
   return !printBeforePasses().empty() || !printAfterPasses().empty();
 }
 
 } // namespace
 
 PassBuilder::PassBuilder(bool DebugLogging, TargetMachine *TM,
                          PipelineTuningOptions PTO, Optional<PGOOptions> PGOOpt,
                          PassInstrumentationCallbacks *PIC)
-    : DebugLogging(DebugLogging), TM(TM), PTO(PTO), PGOOpt(PGOOpt), PIC(PIC) {
+    : DebugLogging(DebugLogging), TM(TM), PTO(PTO), PGOOpt(PGOOpt), PIC(PIC),
+      FunctionsToCompile() {
   if (TM)
     TM->registerPassBuilderCallbacks(*this, DebugLogging);
   if (PIC && shouldPopulateClassToPassNames()) {
 #define MODULE_PASS(NAME, CREATE_PASS)                                         \
   PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
 #define MODULE_ANALYSIS(NAME, CREATE_PASS)                                     \
   PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
 #define FUNCTION_PASS(NAME, CREATE_PASS)                                       \

 #define LOOP_ANALYSIS(NAME, CREATE_PASS)                                       \
   LAM.registerPass([&] { return CREATE_PASS; });
 #include "PassRegistry.def"
 
   for (auto &C : LoopAnalysisRegistrationCallbacks)
     C(LAM);
 }
 
+void PassBuilder::registerFunctionsToCompile(
+    const std::vector<std::string> &Names) {
+  FunctionsToCompile.insert(FunctionsToCompile.end(), Names.begin(),
+                            Names.end());
+}
+
 // Helper to add AnnotationRemarksPass.
 static void addAnnotationRemarksPass(ModulePassManager &MPM) {
   FunctionPassManager FPM;
   FPM.addPass(AnnotationRemarksPass());
   MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
 }
 
 // TODO: Investigate the cost/benefit of tail call elimination on debugging.
if (Phase != ThinLTOPhase::PreLink)
       // We perform early indirect call promotion here, before globalopt.
       // This is important for the ThinLTO backend phase because otherwise
       // imported available_externally functions look unreferenced and are
       // removed.
       MPM.addPass(PGOIndirectCallPromotion(Phase == ThinLTOPhase::PostLink,
                                            true /* SamplePGO */));
   }
 
+  if (!FunctionsToCompile.empty())
+    MPM.addPass(
+        FuncExtractorPass(FunctionsToCompile, Phase == ThinLTOPhase::PostLink));
+
   if (AttributorRun & AttributorRunOption::MODULE)
     MPM.addPass(AttributorPass());
 
   // Lower type metadata and the type.test intrinsic in the ThinLTO
   // post link pipeline after ICP. This is to enable usage of the type
   // tests in ICP sequences.
   if (Phase == ThinLTOPhase::PostLink)
     MPM.addPass(LowerTypeTestsPass(nullptr, nullptr, true));
if (PGOOpt && PGOOpt->Action == PGOOptions::SampleUse) {
     MPM.addPass(SampleProfileLoaderPass(PGOOpt->ProfileFile,
                                         PGOOpt->ProfileRemappingFile,
                                         false /* ThinLTOPhase::PreLink */));
     // Cache ProfileSummaryAnalysis once to avoid the potential need to insert
     // RequireAnalysisPass for PSI before subsequent non-module passes.
     MPM.addPass(RequireAnalysisPass<ProfileSummaryAnalysis, Module>());
   }
 
+  if (!FunctionsToCompile.empty())
+    MPM.addPass(FuncExtractorPass(FunctionsToCompile, true));
+
   // Remove unused virtual tables to improve the quality of code generated by
   // whole-program devirtualization and bitset lowering.
   MPM.addPass(GlobalDCEPass());
 
   // Force any function attributes we want the rest of the pipeline to observe.
   MPM.addPass(ForceFunctionAttrsPass());
 
   // Do basic inference of function attributes from known properties of system

 
 ModulePassManager PassBuilder::buildO0DefaultPipeline(OptimizationLevel Level,
                                                       bool LTOPreLink) {
   assert(Level == OptimizationLevel::O0 &&
          "buildO0DefaultPipeline should only be used with O0");
 
   ModulePassManager MPM(DebugLogging);
 
+  if (!FunctionsToCompile.empty())
+    MPM.addPass(FuncExtractorPass(FunctionsToCompile, false, false));
+
   if (PGOOpt && (PGOOpt->Action == PGOOptions::IRInstr ||
                  PGOOpt->Action == PGOOptions::IRUse))
     addPGOInstrPassesForO0(
         MPM,
         /* RunProfileGen */ (PGOOpt->Action == PGOOptions::IRInstr),
         /* IsCS */ false, PGOOpt->ProfileFile, PGOOpt->ProfileRemappingFile);
 
   for (auto &C : PipelineStartEPCallbacks)

llvm/lib/Transforms/IPO/ExtractGV.cpp

 //===-- ExtractGV.cpp - Global Value extraction pass ----------------------===//
 //
 // 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 extracts global values
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/SetVector.h"
+#include "llvm/IR/Instructions.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Pass.h"
+#include "llvm/ProfileData/InstrProf.h"
 #include "llvm/Transforms/IPO.h"
+#include "llvm/Transforms/IPO/FuncExtractor.h"
 #include <algorithm>
 using namespace llvm;
 
 /// Make sure GV is visible from both modules. Delete is true if it is
 /// being deleted from this module.
 /// This also makes sure GV cannot be dropped so that references from
 /// the split module remain valid.
 static void makeVisible(GlobalValue &GV, bool Delete) {
   bool Local = GV.hasLocalLinkage();
   if (Local || Delete) {
     GV.setLinkage(GlobalValue::ExternalLinkage);
     if (Local)
       GV.setVisibility(GlobalValue::HiddenVisibility);
case GlobalValue::LinkOnceAnyLinkage:
     return;
   case GlobalValue::LinkOnceODRLinkage:
     GV.setLinkage(GlobalValue::WeakODRLinkage);
     return;
   }
 }
 
 namespace {
-  /// A pass to extract specific global values and their dependencies.
-  class GVExtractorPass : public ModulePass {
-    SetVector<GlobalValue *> Named;
-    bool deleteStuff;
-    bool keepConstInit;
-  public:
-    static char ID; // Pass identification, replacement for typeid
+class GVExtractor {
+  SetVector<GlobalValue *> &Named;
+  bool DeleteStuff;
+  bool KeepConstInit;
 
-    /// If deleteS is true, this pass deletes the specified global values.
-    /// Otherwise, it deletes as much of the module as possible, except for the
-    /// global values specified.
-    explicit GVExtractorPass(std::vector<GlobalValue*> &GVs,
-                             bool deleteS = true, bool keepConstInit = false)
-      : ModulePass(ID), Named(GVs.begin(), GVs.end()), deleteStuff(deleteS),
-        keepConstInit(keepConstInit) {}
-
-    bool runOnModule(Module &M) override {
-      if (skipModule(M))
-        return false;
+public:
+  GVExtractor(SetVector<GlobalValue *> &GVs, bool deleteS, bool KeepConstInit)
+      : Named(GVs), DeleteStuff(deleteS), KeepConstInit(KeepConstInit) {}
 
-      // Visit the global inline asm.
-      if (!deleteStuff)
-        M.setModuleInlineAsm("");
+  bool run(Module &M) {
+    if (!DeleteStuff)
 
-      // For simplicity, just give all GlobalValues ExternalLinkage. A trickier
-      // implementation could figure out which GlobalValues are actually
-      // referenced by the Named set, and which GlobalValues in the rest of
-      // the module are referenced by the NamedSet, and get away with leaving
-      // more internal and private things internal and private. But for now,
-      // be conservative and simple.
 
-      // Visit the GlobalVariables.
-      for (Module::global_iterator I = M.global_begin(), E = M.global_end();
-           I != E; ++I) {
-        bool Delete =
-            deleteStuff == (bool)Named.count(&*I) && !I->isDeclaration() &&
-            (!I->isConstant() || !keepConstInit);
-        if (!Delete) {
-          if (I->hasAvailableExternallyLinkage())
-            continue;
-          if (I->getName() == "llvm.global_ctors")
-            continue;
-        }
+      bool Delete = DeleteStuff == (bool)Named.count(&*I) &&
+                    !I->isDeclaration() && (!I->isConstant() || !KeepConstInit);
 
-        makeVisible(*I, Delete);
 
-        if (Delete) {
-          // Make this a declaration and drop it's comdat.
-          I->setInitializer(nullptr);
-          I->setComdat(nullptr);
-        }
-      }
 
-      // Visit the Functions.
-      for (Function &F : M) {
-        bool Delete =
-            deleteStuff == (bool)Named.count(&F) && !F.isDeclaration();
-        if (!Delete) {
-          if (F.hasAvailableExternallyLinkage())
-            continue;
-        }
+      bool Delete = DeleteStuff == (bool)Named.count(&F) && !F.isDeclaration();
 
-        makeVisible(F, Delete);
 
-        if (Delete) {
-          // Make this a declaration and drop it's comdat.
-          F.deleteBody();
-          F.setComdat(nullptr);
-        }
-      }
 
-      // Visit the Aliases.
-      for (Module::alias_iterator I = M.alias_begin(), E = M.alias_end();
-           I != E;) {
-        Module::alias_iterator CurI = I;
-        ++I;
 
-        bool Delete = deleteStuff == (bool)Named.count(&*CurI);
-        makeVisible(*CurI, Delete);
+      bool Delete = DeleteStuff == (bool)Named.count(&*CurI);
 
-        if (Delete) {
-          Type *Ty =  CurI->getValueType();
+        Type *Ty = CurI->getValueType();
 
-          CurI->removeFromParent();
-          llvm::Value *Declaration;
-          if (FunctionType *FTy = dyn_cast<FunctionType>(Ty)) {
-            Declaration = Function::Create(FTy, GlobalValue::ExternalLinkage,
-                                           CurI->getAddressSpace(),
-                                           CurI->getName(), &M);
+          Declaration =
+              Function::Create(FTy, GlobalValue::ExternalLinkage,
+                               CurI->getAddressSpace(), CurI->getName(), &M);
 
-          } else {
-            Declaration =
               new GlobalVariable(M, Ty, false, GlobalValue::ExternalLinkage,
                                  nullptr, CurI->getName());
-
-          }
-          CurI->replaceAllUsesWith(Declaration);
-          delete &*CurI;
-        }
-      }
 
-      return true;
-    }
-  };
 
-  char GVExtractorPass::ID = 0;
+/// A pass to extract specific global values and their dependencies.
+class GVExtractorPass : public ModulePass {
+  SetVector<GlobalValue *> Named;
+  bool DeleteStuff;
+  bool KeepConstInit;
+
+public:
+  static char ID; // Pass identification, replacement for typeid
+
+  /// If deleteS is true, this pass deletes the specified global values.
+  /// Otherwise, it deletes as much of the module as possible, except for the
+  /// global values specified.
+  explicit GVExtractorPass(std::vector<GlobalValue *> &GVs, bool deleteS = true,
+                           bool KeepConstInit = false)
+      : ModulePass(ID), Named(GVs.begin(), GVs.end()), DeleteStuff(deleteS),
+        KeepConstInit(KeepConstInit) {}
+
+  bool runOnModule(Module &M) override {
+    if (skipModule(M))
+      return false;
+
+    GVExtractor Extractor(Named, DeleteStuff, KeepConstInit);
+    Extractor.run(M);
+    return true;
   }
+};
+
+char GVExtractorPass::ID = 0;
+} // namespace
 
 ModulePass *llvm::createGVExtractionPass(std::vector<GlobalValue *> &GVs,
-                                         bool deleteFn, bool keepConstInit) {
-  return new GVExtractorPass(GVs, deleteFn, keepConstInit);
+                                         bool deleteFn, bool KeepConstInit) {
+  return new GVExtractorPass(GVs, deleteFn, KeepConstInit);
+}
+
+PreservedAnalyses FuncExtractorPass::run(Module &M, ModuleAnalysisManager &AM) {
+  if (FunctionsToCompile.empty())
+    return PreservedAnalyses::all();
+
+  // Figure out seed functions to compile.
+  SetVector<GlobalValue *> Seeds;
+  for (const auto &Name : FunctionsToCompile) {
+    if (Function *F = M.getFunction(Name))
+      if (!F->isDeclaration())
+        Seeds.insert(F);
+  }
+
+  SetVector<GlobalValue *> Functions(Seeds);
+
+  // Collect possible callee functions of the seed functions.
+  if (Recursive) {
+    InstrProfSymtab Symtab;
+    (void)(bool) Symtab.create(M, InLTO);
+
+    std::vector<llvm::Function *> Workqueue;
+    for (GlobalValue *GV : Seeds) {
+      if (auto *F = dyn_cast<Function>(GV)) {
+        Workqueue.push_back(F);
+      }
+    }
+
+    auto AddFunc = [&](Function *CF) {
+      if (CF && !CF->isDeclaration() && !Functions.count(CF)) {
+        Functions.insert(CF);
+        Workqueue.push_back(CF);
+      }
+    };
+
+    while (!Workqueue.empty()) {
+      Function *F = &*Workqueue.back();
+      Workqueue.pop_back();
+      for (auto &BB : *F) {
+        for (auto &I : BB) {
+          CallBase *CB = dyn_cast<CallBase>(&I);
+          if (!CB)
+            continue;
+          if (Function *CF = CB->getCalledFunction()) {
+            AddFunc(CF);
+          } else {
+            // Collect potential indirect call targets from the profile.
+            InstrProfValueData ValueData[8];
+            uint32_t ActualNumValueData;
+            uint64_t TotalC;
+            if (getValueProfDataFromInst(*CB, IPVK_IndirectCallTarget, 8,
+                                         ValueData, ActualNumValueData,
+                                         TotalC)) {
+              for (const auto &VD : ArrayRef<InstrProfValueData>(
+                       ValueData, ActualNumValueData)) {
+                AddFunc(Symtab.getFunction(VD.Value));
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  for (GlobalValue *GV : Functions) {
+    if (auto *F = dyn_cast<Function>(GV)) {
+      outs() << "Found Function " << F->getName() << " to compile.\n";
+    }
+  }
+
+  // Assign a linker declaration linkage to functions that are not
+  // user-specified to avoid emitting object code for them.
+  for (GlobalValue *GV : Functions) {
+    if (!Seeds.contains(GV)) {
+      GV->setLinkage(GlobalValue::AvailableExternallyLinkage);
+      auto *F = dyn_cast<Function>(GV);
+      assert(F);
+      // Reset comdat for linker declaration functions to favor the IR
+      // verifier.
+      F->setComdat(nullptr);
+    }
+  }
+
+  GVExtractor Extractor(Functions, false, true);
+  Extractor.run(M);
+  return PreservedAnalyses::none();
 }

llvm/test/Other/Inputs/single-func.ll

+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-scei-ps4"
+
+define dso_local i32 @other() {
+entry:
+  ret i32 16
+}

llvm/test/Other/single-func.ll

+; REQUIRES: x86_64-linux
+; RUN: opt < %s -passes='default<O0>' -single-func=foo -S -o %t0 | FileCheck %s --check-prefix=FOO
+; RUN: opt < %s -passes='default<O1>' -single-func=foo -S -o %t1 | FileCheck %s --check-prefix=RECUR-FOO
+; RUN: opt < %s -passes='default<O2>' -single-func=foo -single-func=bar -S -o %t2 | FileCheck %s --check-prefix=FOO-BAR
+; RUN: opt < %s -passes='default<O2>' -single-func=foo -single-func=bar -S -o %t2 | FileCheck %s --check-prefix=FOO-BAR
+
+; RUN: opt -thinlto-bc -o %t3.bc %s
+; RUN: opt -thinlto-bc -o %t4.bc %S/Inputs/single-func.ll
+; RUN: llvm-lto2 run -use-new-pm -single-func=foo %t3.bc %t4.bc -o %t5 -r %t3.bc,main,px -r %t3.bc,foo,px  -r %t3.bc,bar,px -r %t3.bc,go,px -r %t4.bc,other,px  | FileCheck %s --check-prefix=RECUR-FOO
+
+; RUN: opt -o %t3.bc %s
+; RUN: opt -o %t4.bc %S/Inputs/single-func.ll
+; RUN: llvm-lto2 run -use-new-pm -single-func=foo %t3.bc %t4.bc -o %t5 -r %t3.bc,main,px -r %t3.bc,foo,px  -r %t3.bc,bar,px -r %t3.bc,go,px -r %t4.bc,other,px  | FileCheck %s --check-prefix=RECUR-FOO
+
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-scei-ps4"
+
+define dso_local i32 @main(i32 %x, i32 (i32)* %f) {
+  call i32 @foo(i32 %x, i32 (i32)* %f)
+  ret i32 1
+}
+
+define dso_local i32 @foo(i32 %x, i32 (i32)* %f) {
+entry:
+  %retval = alloca i32, align 4
+  %x.addr = alloca i32, align 4
+  store i32 %x, i32* %x.addr, align 4
+  %0 = load i32, i32* %x.addr, align 4
+  %cmp = icmp eq i32 %0, 0
+  br i1 %cmp, label %if.then, label %if.else
+
+if.then:
+  call i32 @bar()
+  store i32 1, i32* %retval, align 4
+  br label %return
+
+if.else:
+  call i32 %f(i32 1), !prof !0
+  store i32 2, i32* %retval, align 4
+  br label %return
+
+return:
+  %3 = load i32, i32* %retval, align 4
+  ret i32 %3
+}
+
+define dso_local i32 @bar() {
+entry:
+  ret i32 8
+}
+
+define dso_local i32 @go() {
+entry:
+  ret i32 6
+}
+
+!0 = !{!"VP", i32 0, i64 7, i64 -5182264717993193164, i64 5, i64 -1069303473483922844, i64 2}
+
+;; Check only function foo is compiled.
+; FOO: Found Function foo to compile.
+; FOO-NOT: main
+; FOO-NOT: bar
+; FOO-NOT: go
+
+;; Check only function foo, bar and go are compiled.
+; RECUR-FOO: Found Function foo to compile.
+; RECUR-FOO: Found Function bar to compile.
+; RECUR-FOO: Found Function go to compile.
+; RECUR-FOO-NOT: main
+
+;; Check only function foo and bar are compiled.
+; FOO-BAR: Found Function foo to compile.
+; FOO-BAR: Found Function bar to compile.
+; FOO-NOT: main
+; FOO-NOT: go

llvm/tools/llvm-lto2/llvm-lto2.cpp

 
 static cl::opt<std::string>
     StatsFile("stats-file", cl::desc("Filename to write statistics to"));
 
 static cl::list<std::string>
     PassPlugins("load-pass-plugin",
                 cl::desc("Load passes from plugin library"));
 
+static cl::list<std::string>
+    SingleFuncList("single-func", cl::value_desc("function names"),
+                   cl::desc("Only compile functions whose name match this"),
+                   cl::CommaSeparated, cl::Hidden);
+
 static void check(Error E, std::string Msg) {
   if (!E)
     return;
   handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) {
     errs() << "llvm-lto2: " << Msg << ": " << EIB.message().c_str() << '\n';
   });
   exit(1);
 }
static int run(int argc, char **argv) {
   if (auto FT = codegen::getExplicitFileType())
     Conf.CGFileType = FT.getValue();
 
   Conf.OverrideTriple = OverrideTriple;
   Conf.DefaultTriple = DefaultTriple;
   Conf.StatsFile = StatsFile;
   Conf.PTO.LoopVectorization = Conf.OptLevel > 1;
   Conf.PTO.SLPVectorization = Conf.OptLevel > 1;
+  Conf.LTOFunctionsToCompile = SingleFuncList;
 
   ThinBackend Backend;
   if (ThinLTODistributedIndexes)
     Backend = createWriteIndexesThinBackend(/* OldPrefix */ "",
                                             /* NewPrefix */ "",
                                             /* ShouldEmitImportsFiles */ true,
                                             /* LinkedObjectsFile */ nullptr,
                                             /* OnWrite */ {});

llvm/tools/opt/NewPMDriver.cpp

cl::desc("A textual description of the module pass pipeline inserted at "
              "the EarlySimplification extension point into default pipelines"),
     cl::Hidden);
 static cl::opt<std::string> OptimizerLastEPPipeline(
     "passes-ep-optimizer-last",
     cl::desc("A textual description of the module pass pipeline inserted at "
              "the OptimizerLast extension point into default pipelines"),
     cl::Hidden);
 
+static cl::list<std::string> SingleFuncList(
+    "single-func", cl::value_desc("function names"),
+    cl::desc("Only compile functions whose names are in the list"),
+    cl::CommaSeparated, cl::Hidden);
+
 // Individual pipeline tuning options.
 extern cl::opt<bool> DisableLoopUnrolling;
 
 extern cl::opt<PGOKind> PGOKindFlag;
 extern cl::opt<std::string> ProfileFile;
 extern cl::opt<CSPGOKind> CSPGOKindFlag;
 extern cl::opt<std::string> CSProfileGenFile;
 extern cl::opt<bool> DisableBasicAA;
#include "llvm/Support/Extension.def"
   FAM.registerPass([&] { return TargetLibraryAnalysis(*TLII); });
 
   // Register all the basic analyses with the managers.
   PB.registerModuleAnalyses(MAM);
   PB.registerCGSCCAnalyses(CGAM);
   PB.registerFunctionAnalyses(FAM);
   PB.registerLoopAnalyses(LAM);
   PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
+  PB.registerFunctionsToCompile(SingleFuncList);
 
   ModulePassManager MPM(DebugPM);
   if (VK > VK_NoVerifier)
     MPM.addPass(VerifierPass());
   if (EnableDebugify)
     MPM.addPass(NewPMDebugifyPass());
 
   if (!PassPipeline.empty()) {