[LLD][ThinLTO] Add --thinlto-single-module to allow compiling partial modules.

[hoyFB]

Summary

This change introduces an LLD switch --thinlto-single-module to allow compiling only a part of the input modules. This is specifically enables:

1. Fast investigating/debugging modules of interest without spending time on compiling unrelated modules.
2. Compiler debug dump with -mllvm -debug-only= for specific modules.

It will be useful for large applications which has 1K+ input modules for thinLTO.

The switch can be combined with --lto-obj-path= or --lto-emit-asm to obtain intermediate object files or assembly files. So far the module name matching is implemented as a fuzzy name lookup where the modules with name containing the switch value are compiled.

E.g,
Command:

ld.lld main.o thin.a --thinlto-single-module=thin.a --lto-obj-path=single.o

log:

[ThinLTO] Selecting thin.a(thin1.o at 168) to compile
[ThinLTO] Selecting thin.a(thin2.o at 228) to compile

Command:

ld.lld main.o thin.a --thinlto-single-module=thin1.o --lto-obj-path=single.o

log:

[ThinLTO] Selecting thin.a(thin1.o at 168) to compile

[hoyFB]

Updating D80406: [LLD][ThinLTO] A switch to allow compilation of only one module.

[MaskRay]

lld/test/ELF/lto/thinlto-single-module.ll

9

llvm-readelf -S

See linkerscript/sizeof.s for an example

Check prefixes do not necessarily start with CHECK-

llvm/include/llvm/LTO/Config.h

134

If this can be extended to regular LTO, ThinLTO* is not appropriate.

std::vector<std::string> ModulesToCompile;

Needs a test specifying the option multiple times.

llvm/lib/LTO/LTO.cpp

879

The substring matching is not tested

881

This is an informational message. warning: is not suitable

[hoyFB]

Updating D80406: [LLD][ThinLTO] A switch to allow compilation of only one module.

[hoyFB]

llvm/include/llvm/LTO/Config.h

134

That's a good point. So far it's unclear to me what compiling a single module means in mono LTO mode. E.g, should cross-module inlining be allowed which would end up generating object code for other modules? If so, figuring out what inlinees should be compiled need additional work. I'd like to see a strong need first before addressing that, since thinLTO is currently our primary scenario. On the other hand, single module is naturally well-defined in thinLTO mode, and with this new switch we'll end up having exactly same code generated for a module as we would get with a full compilation.

Allowing multiple modules to be compiled with this switch is an interesting idea!

llvm/lib/LTO/LTO.cpp

879

It's tested by the --thinlto-single-module=thin.a line in the added test. The modules with name thin.a(thin1.o at ...) and thin.a(thin2.o at ...) are matched.

[hoyFB]

Updating D80406: [LLD][ThinLTO] A switch to allow compilation of only one module.

[hoyFB]

Fixed clang-tidy warnings.

[tejohnson]

Thanks for adding this, it looks really useful.

Can you beef up the testing? I.e. ensure that the save temps output files for just the specified module get created. Also please add a test to make sure this interacts well with distributed thinlto build options, i.e. -thinlto-index-only (e.g. that it creates the expected output files just for the specified module).

lld/test/ELF/lto/thinlto-single-module.ll

2

Some comments in this file as to what and how it is testing would be good. I'm don't quite understand how it is testing that the single module option is working.

llvm/include/llvm/LTO/Config.h

134

@MaskRay I'm also not sure how this would work in regular LTO mode. In ThinLTO mode the compilation of the selected module will not be affected by this option - it will still import and optimize the exact same way it normally would for that module. For regularLTO how do you isolate the compilation of one module without changing the way it is optimized? This seems very ThinLTO specific to me.

llvm/include/llvm/LTO/LTO.h

341

Please add comment (I realize this structure is missing comments, but think we should start adding them for new fields at least).

[hoyFB]

Updating D80406: [LLD][ThinLTO] A switch to allow compilation of only one module.

[hoyFB]

Address feedbacks.

[tejohnson]

llvm/include/llvm/LTO/LTO.h

343

This is the lld option, I wouldn't mention it here as the option name will be different for e.g. gold plugin if this is ported there. Just say if specified by the LTO Config.

[hoyFB]

Updating D80406: [LLD][ThinLTO] A switch to allow compilation of only one module.

llvm/include/llvm/LTO/LTO.h

343

Done.

[MaskRay]

lld/test/ELF/lto/thinlto-single-module.ll

9

Use ;; for comments.

There are efforts making FileCheck detect potentially disabled check directives. It may have some false positives. ;; is a good way (and already used a lot (## ) in other lld tests) to suppress them.

llvm/lib/LTO/LTO.cpp

878

const std::string &

[hoyFB]

Updating D80406: [LLD][ThinLTO] A switch to allow compilation of only one module.

[hoyFB]

Addressed feedbacks.

[tejohnson]

In D80406#2057639, @tejohnson wrote:

Can you beef up the testing? I.e. ensure that the save temps output files for just the specified module get created. Also please add a test to make sure this interacts well with distributed thinlto build options, i.e. -thinlto-index-only (e.g. that it creates the expected output files just for the specified module).

Not sure if you saw this comment from my earlier reply - please add additional testing as suggested above.

[hoyFB]

In D80406#2060565, @tejohnson wrote:

In D80406#2057639, @tejohnson wrote:

Can you beef up the testing? I.e. ensure that the save temps output files for just the specified module get created. Also please add a test to make sure this interacts well with distributed thinlto build options, i.e. -thinlto-index-only (e.g. that it creates the expected output files just for the specified module).

Not sure if you saw this comment from my earlier reply - please add additional testing as suggested above.

It's added. E.g, the not ls single1.o2 line checks only two intermediate objects are generated, one is the dummy ld-temp.o and the other has the symbol specified in the command line. The IDX checks are for thinlto index testing. Do you want me to add more? Thanks.

[tejohnson]

In D80406#2060623, @hoyFB wrote:

In D80406#2060565, @tejohnson wrote:

In D80406#2057639, @tejohnson wrote:

Can you beef up the testing? I.e. ensure that the save temps output files for just the specified module get created. Also please add a test to make sure this interacts well with distributed thinlto build options, i.e. -thinlto-index-only (e.g. that it creates the expected output files just for the specified module).

Not sure if you saw this comment from my earlier reply - please add additional testing as suggested above.

It's added. E.g, the not ls single1.o2 line checks only two intermediate objects are generated, one is the dummy ld-temp.o and the other has the symbol specified in the command line. The IDX checks are for thinlto index testing. Do you want me to add more? Thanks.

Oh I see now that a -thinlto-index-only invocation was added. What you should be testing for is the output file specific to the specified object. E.g. typically there is a *.thinlto.bc file emitted for each input object. We should get only the one corresponding to the specified module in this case.

Also the other test suggestion I had was to make sure that the save-temps output files work as expected (still get the ones corresponding to the specified module, and not for the other modules). There are a number of .bc files emitted for each object with save-temps but it would be fine to check for one of them I think.

[hoyFB]

In D80406#2060728, @tejohnson wrote:

In D80406#2060623, @hoyFB wrote:

In D80406#2060565, @tejohnson wrote:

In D80406#2057639, @tejohnson wrote:

Can you beef up the testing? I.e. ensure that the save temps output files for just the specified module get created. Also please add a test to make sure this interacts well with distributed thinlto build options, i.e. -thinlto-index-only (e.g. that it creates the expected output files just for the specified module).

Not sure if you saw this comment from my earlier reply - please add additional testing as suggested above.

It's added. E.g, the not ls single1.o2 line checks only two intermediate objects are generated, one is the dummy ld-temp.o and the other has the symbol specified in the command line. The IDX checks are for thinlto index testing. Do you want me to add more? Thanks.

Oh I see now that a -thinlto-index-only invocation was added. What you should be testing for is the output file specific to the specified object. E.g. typically there is a *.thinlto.bc file emitted for each input object. We should get only the one corresponding to the specified module in this case.

Also the other test suggestion I had was to make sure that the save-temps output files work as expected (still get the ones corresponding to the specified module, and not for the other modules). There are a number of .bc files emitted for each object with save-temps but it would be fine to check for one of them I think.

Gotcha, thanks for elaborating. Tests added correspondingly.

[hoyFB]

Updating D80406: [LLD][ThinLTO] A switch to allow compilation of only one module.

[hoyFB]

Updating D80406: [LLD][ThinLTO] A switch to allow compilation of only one module.

[hoyFB]

Rebased.

[MaskRay]

lld/ELF/LTO.cpp

143

const std::string & - Don't use auto unless it is obvious.

144

push_back. emplace_back makes people wonder whether you use a smart constructor

[hoyFB]

Addressed feedbacks.

lld/ELF/LTO.cpp

144

emplace_back is needed since name is not a std::string but a StringRef.

[hoyFB]

Updating D80406: [LLD][ThinLTO] A switch to allow compilation of only one module.

[MaskRay]

Mostly looks good, and I think this feature will be useful. Some test suggestions.

The subject should be more specific. It can be like: Add --thinlto-single-module to allow compiling partial modules.

lld/test/ELF/lto/thinlto-single-module.ll

13

Prefer --check-prefix to -check-prefix

15

Add a not ls a.out to check the output is suppressed

23

No need to use ; on empty lines.

25

thin1.o/single3.o is a redundant case. It can be deleted.

42

Move IDX lines here.

; FileCheck %s --check-prefix=IDX < single5.idx
; count 1 < single5.idx

; IDX: main.o

44

typo: temporary

61

Some reviewers prefer CHECK lines closer to the associated RUN lines. (I am one of them:))

i.e.

RUN: ...

DEFAULT:
MAIN:

RUN: ...

FOO: ...
BLAH: ...

64

superfluous space on this line

72

superfluous space on this line

[MaskRay]

lld/test/ELF/lto/thinlto-single-module.ll

30

This line has trailing whitespace.

42

not ls thin.*.thinlto.bc

This does not work when nullglob is enabled for your shell. Consider RUN: ls | FileCheck --implicit-check='...' /dev/null

[hoyFB]

Updating D80406: [LLD][ThinLTO] Add --thinlto-single-module to allow compiling partial modules.

[hoyFB]

Addressed feedbacks.

[MaskRay]

lld/test/ELF/lto/thinlto-single-module.ll

51

Omitted RUN:

[hoyFB]

Updating D80406: [LLD][ThinLTO] Add --thinlto-single-module to allow compiling partial modules.

[MaskRay]

Hope @tejohnson can confirm this is good.

lld/test/ELF/lto/thinlto-single-module.ll

49

This line does not check anything.

You need FileCheck --implicit-check-not='thin.{{.*}}.thinlto.bc' /dev/null

[hoyFB]

Updating D80406: [LLD][ThinLTO] Add --thinlto-single-module to allow compiling partial modules.

[hoyFB]

In D80406#2085563, @MaskRay wrote:

Hope @tejohnson can confirm this is good.

Thanks for signing off. @tejohnson Please let me know if the latest version looks good to you. Thanks.

[tejohnson]

lgtm

[wenlei]

Different but related, we also have other internal patches that help debugging/investigation. One example is a developer friendly IR printing mode (controls how IR printing works for -print-before/after*) that tweaks format and content of IR dump so it's more human readable. We found it helpful and we'd be happy send patch if folks think that can useful too.

[MaskRay]

In D80406#2086799, @wenlei wrote:

Different but related, we also have other internal patches that help debugging/investigation. One example is a developer friendly IR printing mode (controls how IR printing works for -print-before/after*) that tweaks format and content of IR dump so it's more human readable. We found it helpful and we'd be happy send patch if folks think that can useful too.

This is probably generic and not specific to LTO. Having facility to help debugging will be useful.

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> 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;
   bool allowShlibUndefined;

lld/ELF/Driver.cpp

static void readConfigs(opt::InputArgList &args) {
   config->thinLTOEmitImportsFiles = args.hasArg(OPT_thinlto_emit_imports_files);
   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->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.
-  if (config->thinLTOIndexOnly || config->emitLLVM || config->ltoEmitAsm)
+  // Also bail out here when only certain thinLTO modules are specified for
+  // compilation. The intermediate object file are the expected output.
+  if (config->thinLTOIndexOnly || config->emitLLVM || config->ltoEmitAsm ||
+      !config->thinLTOModulesToCompile.empty())
     return;
 
   // Apply symbol renames for -wrap.
   if (!wrapped.empty())
     wrapSymbols(wrapped);
 
   // Now that we have a complete list of input files.
   // Beyond this point, no new files are added.

lld/ELF/LTO.cpp

static lto::Config createConfig() {
   c.SampleProfile = std::string(config->ltoSampleProfile);
   c.UseNewPM = config->ltoNewPassManager;
   c.DebugPassManager = config->ltoDebugPassManager;
   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);
+
   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) {
std::vector<InputFile *> BitcodeCompiler::compile() {
   if (!bitcodeFiles.empty())
     checkError(ltoObj->run(
         [&](size_t task) {
           return std::make_unique<lto::NativeObjectStream>(
               std::make_unique<raw_svector_ostream>(buf[task]));
         },
         cache));
 
-  // Emit empty index files for non-indexed files
+  // Emit empty index files for non-indexed files but not in single-module mode.
+  if (config->thinLTOModulesToCompile.empty()) {
     for (StringRef s : thinIndices) {
       std::string path = getThinLTOOutputFile(s);
       openFile(path + ".thinlto.bc");
       if (config->thinLTOEmitImportsFiles)
         openFile(path + ".imports");
     }
+  }
 
   if (config->thinLTOIndexOnly) {
     thinLTOCreateEmptyIndexFiles();
 
     if (!config->ltoObjPath.empty())
       saveBuffer(buf[0], config->ltoObjPath);
 
     // ThinLTO with index only option is required to generate only the index

lld/ELF/Options.td

 defm thinlto_cache_policy: EEq<"thinlto-cache-policy", "Pruning policy for the ThinLTO cache">;
 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">;
 
 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/thinlto-single-module.ll

+; REQUIRES: x86
+; RUN: rm -fr %t && mkdir %t && cd %t
+; RUN: opt -thinlto-bc -o main.o %s
+; RUN: opt -thinlto-bc -o thin1.o %S/Inputs/thin1.ll
+; RUN: opt -thinlto-bc -o thin2.o %S/Inputs/thin2.ll
+; RUN: llvm-ar qcT thin.a thin1.o thin2.o
+
+;; --thinlto-single-module=main.o should result in only main.o compiled, of which
+;; the object code is saved in single1.o1. Note that single1.o is always the dummy
+;; output, aka ld-temp.o. There should be no more object files generated.
+; RUN: ld.lld main.o thin.a --thinlto-single-module=main.o --lto-obj-path=single1.o
+; RUN: llvm-readelf -S -s single1.o | FileCheck %s --check-prefix=DEFAULT
+; RUN: llvm-readelf -S -s single1.o1 | FileCheck %s --check-prefix=MAIN
+; RUN: not ls single1.o2
+; RUN: not ls a.out
+
+; DEFAULT:       Value        Size Type Bind   Vis     Ndx Name
+; DEFAULT:   0000000000000000    0 FILE LOCAL  DEFAULT ABS ld-temp.o
+; MAIN:          Value        Size Type Bind   Vis     Ndx Name
+; MAIN:      0000000000000000    0 FILE LOCAL  DEFAULT ABS thinlto-single-module.ll
+; MAIN-NEXT: 0000000000000000    3 FUNC GLOBAL DEFAULT   3 _start
+
+;; --thinlto-single-module=thin.a should result in only thin1.o and thin2.o compiled.
+; RUN: ld.lld main.o thin.a --thinlto-single-module=thin.a --lto-obj-path=single2.o
+; RUN: llvm-readelf -S -s single2.o | FileCheck %s --check-prefix=DEFAULT
+; RUN: llvm-readelf -S -s single2.o1 | FileCheck %s --check-prefix=FOO
+; RUN: llvm-readelf -S -s single2.o2 | FileCheck %s --check-prefix=BLAH
+; RUN: not ls single1.o3
+
+;; Multiple --thinlto-single-module uses should result in a combination of inputs compiled.
+; RUN: ld.lld main.o thin.a --thinlto-single-module=main.o --thinlto-single-module=thin2.o --lto-obj-path=single4.o
+; RUN: llvm-readelf -S -s single4.o | FileCheck %s --check-prefix=DEFAULT
+; RUN: llvm-readelf -S -s single4.o1 | FileCheck %s --check-prefix=MAIN
+; RUN: llvm-readelf -S -s single4.o2 | FileCheck %s --check-prefix=BLAH
+; RUN: not ls single4.o3
+
+; FOO:           Value        Size Type Bind   Vis     Ndx Name
+; FOO:       0000000000000000    0 FILE LOCAL  DEFAULT ABS thin1.ll
+; FOO-NEXT:  0000000000000000    6 FUNC GLOBAL DEFAULT   3 foo
+; BLAH:          Value        Size Type Bind   Vis     Ndx Name
+; BLAH:      0000000000000000    0 FILE LOCAL  DEFAULT ABS thin2.ll
+; BLAH-NEXT: 0000000000000000    4 FUNC GLOBAL DEFAULT   3 blah
+
+;; Check only main.o is in the result thin index file.
+;; Also check a *.thinlto.bc file generated for main.o only.
+; RUN: ld.lld main.o thin.a --thinlto-single-module=main.o --thinlto-index-only=single5.idx
+; RUN: ls main.o.thinlto.bc
+; RUN: ls | FileCheck --implicit-check-not='thin.{{.*}}.thinlto.bc' /dev/null
+; RUN: FileCheck %s --check-prefix=IDX < single5.idx
+; RUN: count 1 < single5.idx
+
+; IDX: main.o
+
+;; Check temporary output generated for main.o only.
+; RUN: ld.lld main.o thin.a --thinlto-single-module=main.o --save-temps
+; RUN: ls main.o.0.preopt.bc
+; RUN: not ls thin.*.0.preopt.bc
+
+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"
+
+declare i32 @blah(i32 %meh)
+declare i32 @foo(i32 %goo)
+
+define i32 @_start() {
+  call i32 @foo(i32 0)
+  call i32 @blah(i32 0)
+  ret i32 0
+}

llvm/include/llvm/LTO/Config.h

struct Config {
   std::string RemarksFormat = "";
 
   /// Whether to emit the pass manager debuggging informations.
   bool DebugPassManager = false;
 
   /// Statistics output file path.
   std::string StatsFile;
 
+  /// Specific thinLTO modules to compile.
+  std::vector<std::string> ThinLTOModulesToCompile;
+
   /// Time trace enabled.
   bool TimeTraceEnabled = false;
 
   /// Time trace granularity.
   unsigned TimeTraceGranularity = 500;
 
   bool ShouldDiscardValueNames = true;
   DiagnosticHandlerFunction DiagHandler;

llvm/include/llvm/LTO/LTO.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LTO_LTO_H
 #define LLVM_LTO_LTO_H
 
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/StringMap.h"
+#include "llvm/Bitcode/BitcodeReader.h"
 #include "llvm/IR/ModuleSummaryIndex.h"
 #include "llvm/LTO/Config.h"
 #include "llvm/Object/IRSymtab.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/thread.h"
 #include "llvm/Transforms/IPO/FunctionImport.h"
 
 namespace llvm {
 
-class BitcodeModule;
 class Error;
 class IRMover;
 class LLVMContext;
 class MemoryBufferRef;
 class Module;
 class raw_pwrite_stream;
 class Target;
 class ToolOutputFile;
struct RegularLTOState {
     struct AddedModule {
       std::unique_ptr<Module> M;
       std::vector<GlobalValue *> Keep;
     };
     std::vector<AddedModule> ModsWithSummaries;
     bool EmptyCombinedModule = true;
   } RegularLTO;
 
+  using ModuleMapType = MapVector<StringRef, BitcodeModule>;
+
   struct ThinLTOState {
     ThinLTOState(ThinBackend Backend);
 
     ThinBackend Backend;
     ModuleSummaryIndex CombinedIndex;
-    MapVector<StringRef, BitcodeModule> ModuleMap;
+    // The full set of bitcode modules in input order.
+    ModuleMapType ModuleMap;
+    // The bitcode modules to compile, if specified by the LTO Config.
+    Optional<ModuleMapType> ModulesToCompile;
     DenseMap<GlobalValue::GUID, StringRef> PrevailingModuleForGUID;
   } ThinLTO;
 
   // The global resolution for a particular (mangled) symbol name. This is in
   // particular necessary to track whether each symbol can be internalized.
   // Because any input file may introduce a new cross-partition reference, we
   // cannot make any final internalization decisions until all input files have
   // been added and the client has called run(). During run() we apply

llvm/lib/LTO/LTO.cpp

for (const InputFile::Symbol &Sym : Syms) {
     }
   }
 
   if (!ThinLTO.ModuleMap.insert({BM.getModuleIdentifier(), BM}).second)
     return make_error<StringError>(
         "Expected at most one ThinLTO module per bitcode file",
         inconvertibleErrorCode());
 
+  if (!Conf.ThinLTOModulesToCompile.empty()) {
+    if (!ThinLTO.ModulesToCompile)
+      ThinLTO.ModulesToCompile = ModuleMapType();
+    // This is a fuzzy name matching where only modules with name containing the
+    // specified switch values are going to be compiled.
+    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";
+      }
+    }
+  }
+
   return Error::success();
 }
 
 unsigned LTO::getMaxTasks() const {
   CalledGetMaxTasks = true;
-  return RegularLTO.ParallelCodeGenParallelismLevel + ThinLTO.ModuleMap.size();
+  auto ModuleCount = ThinLTO.ModulesToCompile ? ThinLTO.ModulesToCompile->size()
+                                              : ThinLTO.ModuleMap.size();
+  return RegularLTO.ParallelCodeGenParallelismLevel + ModuleCount;
 }
 
 // If only some of the modules were split, we cannot correctly handle
 // code that contains type tests or type checked loads.
 Error LTO::checkPartiallySplit() {
   if (!ThinLTO.CombinedIndex.partiallySplitLTOUnits())
     return Error::success();
 
ThinBackend lto::createWriteIndexesThinBackend(
   };
 }
 
 Error LTO::runThinLTO(AddStreamFn AddStream, NativeObjectCache Cache,
                       const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols) {
   if (ThinLTO.ModuleMap.empty())
     return Error::success();
 
+  if (ThinLTO.ModulesToCompile && ThinLTO.ModulesToCompile->empty()) {
+    llvm::errs() << "warning: [ThinLTO] No module compiled\n";
+    return Error::success();
+  }
+
   if (Conf.CombinedIndexHook &&
       !Conf.CombinedIndexHook(ThinLTO.CombinedIndex, GUIDPreservedSymbols))
     return Error::success();
 
   // Collect for each module the list of function it defines (GUID ->
   // Summary).
   StringMap<GVSummaryMapTy>
       ModuleToDefinedGVSummaries(ThinLTO.ModuleMap.size());
Error LTO::runThinLTO(AddStreamFn AddStream, NativeObjectCache Cache,
   };
   thinLTOResolvePrevailingInIndex(ThinLTO.CombinedIndex, isPrevailing,
                                   recordNewLinkage, GUIDPreservedSymbols);
 
   std::unique_ptr<ThinBackendProc> BackendProc =
       ThinLTO.Backend(Conf, ThinLTO.CombinedIndex, ModuleToDefinedGVSummaries,
                       AddStream, Cache);
 
+  auto &ModuleMap =
+      ThinLTO.ModulesToCompile ? *ThinLTO.ModulesToCompile : ThinLTO.ModuleMap;
+
   // Tasks 0 through ParallelCodeGenParallelismLevel-1 are reserved for combined
   // module and parallel code generation partitions.
   unsigned Task = RegularLTO.ParallelCodeGenParallelismLevel;
-  for (auto &Mod : ThinLTO.ModuleMap) {
+  for (auto &Mod : ModuleMap) {
     if (Error E = BackendProc->start(Task, Mod.second, ImportLists[Mod.first],
                                      ExportLists[Mod.first],
                                      ResolvedODR[Mod.first], ThinLTO.ModuleMap))
       return E;
     ++Task;
   }
 
   return BackendProc->wait();