[clang] A Unified LTO Bitcode Frontend

[ormris]

Summary

The unified LTO pipeline creates a single LTO bitcode structure that can be
used by Thin or Full LTO. This means that LKTO mode can be chosen at link
time and that all LTO bitcode produced by the pipeline is compatible, from
an optimization perspective. This makes the behavior of LTO a bit more
predictable by normalizing the set of LTO features supported by each LTO
bitcode file.

Example usage:

clang -flto -funified-lto foo.c
clang -flto -funified-lto bar.c

ld.lld --lto=full foo.o bar.o -o baz.elf

The RFC discussing the details and rational for this change is here:
https://discourse.llvm.org/t/rfc-a-unified-lto-bitcode-frontend/61774

[tejohnson]

As mentioned on the RFC thread a little bit ago, I think the split LTO handling should be separated from the unified LTO pipeline. So some of these comments may be moot if that is done.

clang/lib/CodeGen/BackendUtil.cpp

1051–1054

I think this ?: logic is all equivalent to simply setting the flag to !CodeGenOpts.UnifiedLTO. While as noted elsewhere I'd like to separate the split LTO unit handling from the unified LTO pipeline model, I'm not sure I understand why you would want to set this module flag to false when CodeGenOpts.UnifiedLTO==true under the current patch intent.

clang/lib/Driver/ToolChains/Clang.cpp

4915

Why the PS4 special handling? Also, shouldn't LTO unit be enabled in unified LTO mode?

7325

I'd like to separate the split LTO unit setting from Unified LTO as I think they are orthogonal.

clang/lib/Frontend/CompilerInvocation.cpp

1773

Opts.PrepareForLTO was set to false a couple lines up, so I don't think this if condition will ever evaluate to true?

1784

Why is the default being set differently for PS4?

[ormris]

Add LLD driver changes to this patch. Disable split LTO units by default. As discussed here: https://discourse.llvm.org/t/rfc-a-unified-lto-bitcode-frontend/61774/15

[ormris]

Changelog:

• Rebased

[ormris]

Remove duplicated LLVM tests.

[ormris]

Attempt to fix premerge checks

[ormris]

clang-format

[ormris]

Use the ThinLTO pre-link pipeline as the Unified LTO pre-link pipeline, as discussed in the RFC.

[ormris]

Rebase

[ormris]

gentle ping

[MaskRay]

The lld side has no test. I think we normally create separate patches for clang and lld. So you may want to reuse D123805 for lld changes.
See lld/test/ELF/lto/ for tests.

[MaskRay]

clang/lib/CodeGen/BackendUtil.cpp

1008

Simplify this with if (IsThinLTO || (IsLTO && CodeGenOpts.UnifiedLTO))

clang/lib/Driver/ToolChains/Clang.cpp

4772

Search for Args.addOptInFlag

4915

Do you want to use isPS() special case both PS4 and PS5? Or is it that just PS4 is special?

Is only PS4 is special, the summary should mention why.

7302–7305

Add a comment why PS4 is special.

clang/test/CodeGen/asan-unified-lto.ll

9

Consider checking a few more things including the module flag metadata beside the global variable name.

16

ptr. Avoid obsoleted typed pointers.

clang/test/CodeGen/emit-summary-index.c

17

Add a comment with /// (for non-RUN non-CHECK lines) about the purpose of the two RUN lines.

clang/test/CodeGen/unified-lto-pipeline.c

2

Without --target, this uses the default target triple which may fail for some exotic platforms.

Prefer %clang_cc1 for non-driver tests. Instead of comparing the output files, test -fdebug-pass-manager output.

[MaskRay]

clang/test/Driver/unified-whole-program-vtables.c

1 ↗

(On Diff #529091)

I think it'll be more readable if you place all -funitied-lto related driver tests in one file, instead of spreading them into unified-whole-program-vtables.c and lto-unit.c

Use --target= for new tests. -target has been deprecated since Clang 3.4

[ormris]

clang/lib/CodeGen/BackendUtil.cpp

1008

Fixed

1051–1054

That's a good point. I've removed this change.

clang/lib/Driver/ToolChains/Clang.cpp

4772

There's driver code that depend on the value of this flag, so I do need to store it. Args.addOptInFlag doesn't return the value of the flag. Is there an advantage to calling addOptInFlag, then hasFlag?

4915

Fixed.

7302–7305

Fixed.

7325

Fixed

clang/test/CodeGen/asan-unified-lto.ll

16

Fixed

clang/test/CodeGen/emit-summary-index.c

17

Fixed

clang/test/CodeGen/unified-lto-pipeline.c

2

Why test the pipeline rather than binary equivalence? Identical bitcode files is a key part of this feature.

clang/test/Driver/unified-whole-program-vtables.c

1 ↗

(On Diff #529091)

Agreed. Fixed.

[ormris]

@MaskRay There are very few LLD changes in this review, but we can split this out if it would be more convenient.

[MaskRay]

In D123804#4486130, @ormris wrote:

@MaskRay There are very few LLD changes in this review, but we can split this out if it would be more convenient.

Yeah, preferably split. I use this convention for most features.

[ormris]

Remove LLD changes from this patch. They're now in D123805.

[MaskRay]

Thank you for the update.

IIUC -flto=full -funified-lto, -flto -funified-lto, and -flto=thin -funified-lto are identical.
-flto=full -funified-lto may be confusing as we treat it as it -flto=thin and use buildThinLTOPreLinkDefaultPipeline.

In the absence of -flto, -funified-lto seems a no-op (I do not see a test).

I wonder whether we should change -funified-lto to become -flto=unified instead.
(For the lld option, I guess --lto-mode={thin,full} may be clearer than --lto={thin,full}, but I don't have a strong opinion... )

clang/lib/Frontend/CompilerInvocation.cpp

1779

hasArg if you don't use A

clang/test/Driver/lto-unit.c

9

Is NOUNIT unused?

clang/test/Driver/unified-lto.c

6

Is NOUNIT-NOT used?

10

This test may be better placed in whole-program-vtables.c where this diagnostic is tested.

[MaskRay]

[WIP][clang][lld] A Unified LTO Bitcode Frontend

You may change the titles of this patch and the lld one... I guess it is named WIP so I ignored reading it for a long time (sorry!).

[ormris]

IIUC -flto=full -funified-lto, -flto -funified-lto, and -flto=thin -funified-lto are identical.

They're not completely identical. They change the flag passed to the linker when the linker is invoked by the compiler. I think it's worth preserving that workflow. It's used fairly often for manually compiling a project (e.g. clang -flto=thin -funified-lto hello.cpp), but also by CMake.

In the absence of -flto, -funified-lto seems a no-op (I do not see a test).

Good point. Fixed.

For the lld option, I guess --lto-mode={thin,full}

Maybe.... I was trying to mirror -flto and reduce the amount of typing required.

clang/lib/Frontend/CompilerInvocation.cpp

1779

Fixed.

clang/test/Driver/lto-unit.c

9

Fixed.

clang/test/Driver/unified-lto.c

6

No, but it should be. Fixed.

10

Fixed

[ormris]

Address comments

[MaskRay]

In D123804#4490463, @ormris wrote:

IIUC -flto=full -funified-lto, -flto -funified-lto, and -flto=thin -funified-lto are identical.

They're not completely identical. They change the flag passed to the linker when the linker is invoked by the compiler. I think it's worth preserving that workflow. It's used fairly often for manually compiling a project (e.g. clang -flto=thin -funified-lto hello.cpp), but also by CMake.

OK, sounds good. I think the description can be updated to include some examples.
The discourse link has quite a lot of discussions and the commit message/summary can be a good place to summarize all the information.
If I were a newcomer, I would find the discourse link too daunting to comprehend...

In the absence of -flto, -funified-lto seems a no-op (I do not see a test).

Good point. Fixed.

For the lld option, I guess --lto-mode={thin,full}

Maybe.... I was trying to mirror -flto and reduce the amount of typing required.

clang/test/CodeGen/unified-lto-pipeline.c

2

cmp %t.0 %t.1 should be retained. My point is that we probably should test some output to demonstrate that his is a ThinLTO pipeline.

// RUN: not cmp %t.2 %t.3 is probably less useful if we can demonstrate that the pipeline is different.

[ormris]

clang/test/CodeGen/unified-lto-pipeline.c

2

Ah that makes sense. Fixed.

[ormris]

Address comments. I've updated the review description as well.

[MaskRay]

Sorry for extra nitpicking:)

[clang] A Unified LTO Bitcode Frontend

I think we typically start with a verb and don't capitalize every words, e.g. [clang] Support Unified LTO Bitcode frontend

This means that LKTO mode can be chosen at link [...]

typo: LKTO?

Feel free to incorporate the following to your summary:

# Compile and link. Select regular LTO at link time.
clang -flto -funified-lto -fuse-ld=lld foo.c

# Compile and link. Select ThinLTO at link time.
clang -flto=thin -funified-lto -fuse-ld=lld foo.c

# Link separately, using ThinLTO.
clang -c -flto -funified-lto foo.c  # -flto={full,thin} are identical in terms of compilation actions
clang -flto=thin -fuse-ld=lld foo.o  # pass --lto=thin to ld.lld

# Link separately, using regular LTO.
clang -c -flto -funified-lto foo.c
clang -flto -fuse-ld=lld foo.o  # pass --lto=full to ld.lld

clang/lib/Driver/ToolChains/Clang.cpp

4772

One blank line is sufficient.

[MaskRay]

clang/test/CodeGenCXX/unified-cfi-lto.cpp

5

Did you forget FileCheck?

clang/test/Driver/unified-lto.c

11

If the path of %s contains -funified-lto, the NOT pattern will fail spuriously. -funified-lto may be unique enough to not cause an issue in practice, but other options did cause an issue IIRC. The conventional solution is to use a double quote to make it really unique enough.
In addition, we typically start with "-cc1" to indicate that we are testing cc1 command line.

// NOUNILTO:     "-cc1"
// NOUNILTO-NOT: "-funified-lto

clang/test/Driver/whole-program-vtables.c

9 ↗

(On Diff #539259)

Add a comment /// -funified-lto does not imply -flto, so we still get an error that fwhole-program-vtables has no effect without -flto

[ormris]

Thanks! Pushed as 048a0c246908291c82d2f4531d3df45a4c4a8a18.

[pcc]

Looks like this caused some buildbot failures, e.g.

https://lab.llvm.org/buildbot/#/builders/168/builds/14547

Can you please take a look?

[ormris]

Yes, looking now.

[ormris]

@pcc I'll remove the failing test while I work on a reproducing this.

clang/include/clang/Basic/CodeGenOptions.def

 CODEGENOPT(PrepareForThinLTO , 1, 0) ///< Set when -flto=thin is enabled on the
                                      ///< compile step.
 CODEGENOPT(LTOUnit, 1, 0) ///< Emit IR to support LTO unit features (CFI, whole
                           ///< program vtable opt).
 CODEGENOPT(EnableSplitLTOUnit, 1, 0) ///< Enable LTO unit splitting to support
              /// CFI and traditional whole program
              /// devirtualization that require whole
              /// program IR support.
+CODEGENOPT(UnifiedLTO, 1, 0) ///< Use the unified LTO pipeline.
 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(NoCommon          , 1, 0) ///< Set when -fno-common or C++ is enabled.
 CODEGENOPT(NoDwarfDirectoryAsm , 1, 0) ///< Set when -fno-dwarf-directory-asm is
                                        ///< enabled.

clang/include/clang/Driver/Options.td

 def flto_EQ : Joined<["-"], "flto=">, Flags<[CoreOption, CC1Option, FC1Option, FlangOption]>, Group<f_Group>,
   HelpText<"Set LTO mode">, Values<"thin,full">;
 def flto_EQ_jobserver : Flag<["-"], "flto=jobserver">, Group<f_Group>,
   Alias<flto_EQ>, AliasArgs<["full"]>, HelpText<"Enable LTO in 'full' mode">;
 def flto_EQ_auto : Flag<["-"], "flto=auto">, Group<f_Group>,
   Alias<flto_EQ>, AliasArgs<["full"]>, HelpText<"Enable LTO in 'full' mode">;
 def flto : Flag<["-"], "flto">, Flags<[CoreOption, CC1Option, FC1Option, FlangOption]>, Group<f_Group>,
   Alias<flto_EQ>, AliasArgs<["full"]>, HelpText<"Enable LTO in 'full' mode">;
+defm unified_lto : BoolFOption<"unified-lto",
+  CodeGenOpts<"UnifiedLTO">, DefaultFalse,
+  PosFlag<SetTrue, [], "Use the unified LTO pipeline">,
+  NegFlag<SetFalse, [], "Use distinct LTO pipelines">,
+  BothFlags<[CC1Option], "">>;
 def fno_lto : Flag<["-"], "fno-lto">, Flags<[CoreOption, CC1Option]>, Group<f_Group>,
   HelpText<"Disable LTO mode (default)">;
 def foffload_lto_EQ : Joined<["-"], "foffload-lto=">, Flags<[CoreOption]>, Group<f_Group>,
   HelpText<"Set LTO mode for offload compilation">, Values<"thin,full">;
 def foffload_lto : Flag<["-"], "foffload-lto">, Flags<[CoreOption]>, Group<f_Group>,
   Alias<foffload_lto_EQ>, AliasArgs<["full"]>, HelpText<"Enable LTO in 'full' mode for offload compilation">;
 def fno_offload_lto : Flag<["-"], "fno-offload-lto">, Flags<[CoreOption]>, Group<f_Group>,
   HelpText<"Disable LTO mode (default) for offload compilation">;

clang/lib/CodeGen/BackendUtil.cpp

void EmitAssemblyHelper::RunOptimizationPipeline(
   // unrolling.
   PTO.LoopInterleaving = CodeGenOpts.UnrollLoops;
   PTO.LoopVectorization = CodeGenOpts.VectorizeLoop;
   PTO.SLPVectorization = CodeGenOpts.VectorizeSLP;
   PTO.MergeFunctions = CodeGenOpts.MergeFunctions;
   // Only enable CGProfilePass when using integrated assembler, since
   // non-integrated assemblers don't recognize .cgprofile section.
   PTO.CallGraphProfile = !CodeGenOpts.DisableIntegratedAS;
+  PTO.UnifiedLTO = CodeGenOpts.UnifiedLTO;
 
   LoopAnalysisManager LAM;
   FunctionAnalysisManager FAM;
   CGSCCAnalysisManager CGAM;
   ModuleAnalysisManager MAM;
 
   bool DebugPassStructure = CodeGenOpts.DebugPass == "Structure";
   PassInstrumentationCallbacks PIC;
if (!CodeGenOpts.DisableLLVMPasses) {
     if (!CodeGenOpts.MemoryProfileOutput.empty()) {
       PB.registerOptimizerLastEPCallback(
           [](ModulePassManager &MPM, OptimizationLevel Level) {
             MPM.addPass(createModuleToFunctionPassAdaptor(MemProfilerPass()));
             MPM.addPass(ModuleMemProfilerPass());
           });
     }
 
-    if (IsThinLTO) {
+    if (IsThinLTO || (IsLTO && CodeGenOpts.UnifiedLTO)) {
       MPM = PB.buildThinLTOPreLinkDefaultPipeline(Level);
     } else if (IsLTO) {
       MPM = PB.buildLTOPreLinkDefaultPipeline(Level);
     } else {
       MPM = PB.buildPerModuleDefaultPipeline(Level);
     }
   }
 
if (CodeGenOpts.PrepareForThinLTO && !CodeGenOpts.DisableLLVMPasses) {
         TheModule->addModuleFlag(Module::Error, "EnableSplitLTOUnit",
                                  CodeGenOpts.EnableSplitLTOUnit);
       if (Action == Backend_EmitBC) {
         if (!CodeGenOpts.ThinLinkBitcodeFile.empty()) {
           ThinLinkOS = openOutputFile(CodeGenOpts.ThinLinkBitcodeFile);
           if (!ThinLinkOS)
             return;
         }
-        MPM.addPass(ThinLTOBitcodeWriterPass(*OS, ThinLinkOS ? &ThinLinkOS->os()
-                                                             : nullptr));
+        if (CodeGenOpts.UnifiedLTO)
+          TheModule->addModuleFlag(Module::Error, "UnifiedLTO", uint32_t(1));
+        MPM.addPass(ThinLTOBitcodeWriterPass(
+            *OS, ThinLinkOS ? &ThinLinkOS->os() : nullptr));
       } else {
         MPM.addPass(PrintModulePass(*OS, "", CodeGenOpts.EmitLLVMUseLists,
                                     /*EmitLTOSummary=*/true));
       }
 
     } else {
       // Emit a module summary by default for Regular LTO except for ld64
       // targets
       bool EmitLTOSummary = shouldEmitRegularLTOSummary();
       if (EmitLTOSummary) {
-        if (!TheModule->getModuleFlag("ThinLTO"))
+        if (!TheModule->getModuleFlag("ThinLTO") && !CodeGenOpts.UnifiedLTO)
           TheModule->addModuleFlag(Module::Error, "ThinLTO", uint32_t(0));
         if (!TheModule->getModuleFlag("EnableSplitLTOUnit"))
-          TheModule->addModuleFlag(Module::Error, "EnableSplitLTOUnit",
-                                   uint32_t(1));
+          TheModule->addModuleFlag(
+              Module::Error, "EnableSplitLTOUnit", !CodeGenOpts.UnifiedLTO);
+        if (CodeGenOpts.UnifiedLTO)
+          TheModule->addModuleFlag(Module::Error, "UnifiedLTO", uint32_t(1));
       }
       if (Action == Backend_EmitBC)
         MPM.addPass(BitcodeWriterPass(*OS, CodeGenOpts.EmitLLVMUseLists,
                                       EmitLTOSummary));
       else
         MPM.addPass(PrintModulePass(*OS, "", CodeGenOpts.EmitLLVMUseLists,
                                     EmitLTOSummary));
     }

clang/lib/Driver/ToolChains/Clang.cpp

void Clang::ConstructJob(Compilation &C, const JobAction &JA,
 
   // FIXME: Subclass ToolChain for SPIR and move this to addClangWarningOptions.
   if (Triple.isSPIR() || Triple.isSPIRV())
     CmdArgs.push_back("-Wspir-compat");
 
   // Select the appropriate action.
   RewriteKind rewriteKind = RK_None;
 
+  bool UnifiedLTO = Args.hasFlag(options::OPT_funified_lto,
+                                 options::OPT_fno_unified_lto, false);
+  if (UnifiedLTO)
+    CmdArgs.push_back("-funified-lto");
+
   // If CollectArgsForIntegratedAssembler() isn't called below, claim the args
   // it claims when not running an assembler. Otherwise, clang would emit
   // "argument unused" warnings for assembler flags when e.g. adding "-E" to
   // flags while debugging something. That'd be somewhat inconvenient, and it's
   // also inconsistent with most other flags -- we don't warn on
   // -ffunction-sections not being used in -E mode either for example, even
   // though it's not really used either.
   if (!isa<AssembleJobAction>(JA)) {
if (IsUsingLTO) {
                                options::OPT_foffload_lto_EQ)
                    ->getAsString(Args)
             << Triple.getTriple();
       } else if (Triple.isNVPTX() && !IsRDCMode &&
                  JA.isDeviceOffloading(Action::OFK_Cuda)) {
         D.Diag(diag::err_drv_unsupported_opt_for_language_mode)
             << Args.getLastArg(options::OPT_foffload_lto,
                                options::OPT_foffload_lto_EQ)
                    ->getAsString(Args)
             << "-fno-gpu-rdc";
       } else {
         assert(LTOMode == LTOK_Full || LTOMode == LTOK_Thin);
         CmdArgs.push_back(Args.MakeArgString(
             Twine("-flto=") + (LTOMode == LTOK_Thin ? "thin" : "full")));
+        // PS4 uses the legacy LTO API, which does not support some of the
+        // features enabled by -flto-unit.
+        if ((RawTriple.getOS() != llvm::Triple::PS4) ||
+            (D.getLTOMode() == LTOK_Full) || !UnifiedLTO)
           CmdArgs.push_back("-flto-unit");
       }
     }
   }
 
   Args.AddLastArg(CmdArgs, options::OPT_dumpdir);
 
   if (const Arg *A = Args.getLastArg(options::OPT_fthinlto_index_EQ)) {
     if (!types::isLLVMIR(Input.getType()))
bool WholeProgramVTables = Args.hasFlag(
       options::OPT_fno_whole_program_vtables, VirtualFunctionElimination);
   if (VirtualFunctionElimination && !WholeProgramVTables) {
     D.Diag(diag::err_drv_argument_not_allowed_with)
         << "-fno-whole-program-vtables"
         << "-fvirtual-function-elimination";
   }
 
   if (WholeProgramVTables) {
-    // Propagate -fwhole-program-vtables if this is an LTO compile.
-    if (IsUsingLTO)
-      CmdArgs.push_back("-fwhole-program-vtables");
+    // PS4 uses the legacy LTO API, which does not support this feature in
+    // ThinLTO mode.
+    bool IsPS4 = getToolChain().getTriple().isPS4();
+
     // Check if we passed LTO options but they were suppressed because this is a
     // device offloading action, or we passed device offload LTO options which
     // were suppressed because this is not the device offload action.
+    // Check if we are using PS4 in regular LTO mode.
     // Otherwise, issue an error.
-    else if (!D.isUsingLTO(!IsDeviceOffloadAction))
+    if ((!IsUsingLTO && !D.isUsingLTO(!IsDeviceOffloadAction)) ||
+        (IsPS4 && !UnifiedLTO && (D.getLTOMode() != LTOK_Full)))
       D.Diag(diag::err_drv_argument_only_allowed_with)
           << "-fwhole-program-vtables"
-          << "-flto";
+          << ((IsPS4 && !UnifiedLTO) ? "-flto=full" : "-flto");
+
+    // Propagate -fwhole-program-vtables if this is an LTO compile.
+    if (IsUsingLTO)
+      CmdArgs.push_back("-fwhole-program-vtables");
   }
 
   bool DefaultsSplitLTOUnit =
       (WholeProgramVTables || SanitizeArgs.needsLTO()) &&
       (LTOMode == LTOK_Full || TC.canSplitThinLTOUnit());
   bool SplitLTOUnit =
       Args.hasFlag(options::OPT_fsplit_lto_unit,
                    options::OPT_fno_split_lto_unit, DefaultsSplitLTOUnit);
   if (SanitizeArgs.needsLTO() && !SplitLTOUnit)
     D.Diag(diag::err_drv_argument_not_allowed_with) << "-fno-split-lto-unit"
                                                     << "-fsanitize=cfi";
   if (SplitLTOUnit)
     CmdArgs.push_back("-fsplit-lto-unit");
 

clang/lib/Driver/ToolChains/PS4CPU.cpp

if (IsPS4) {
 
       CmdArgs.push_back(Args.MakeArgString(Twine(Prefix) + PS4LTOArgs));
     }
   }
 
   if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs))
     TC.addSanitizerArgs(Args, CmdArgs, "-l", "");
 
+  if (D.isUsingLTO() && Args.hasArg(options::OPT_funified_lto)) {
+    if (D.getLTOMode() == LTOK_Thin)
+      CmdArgs.push_back("--lto=thin");
+    else if (D.getLTOMode() == LTOK_Full)
+      CmdArgs.push_back("--lto=full");
+  }
+
   Args.AddAllArgs(CmdArgs, options::OPT_L);
   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
   Args.AddAllArgs(CmdArgs, options::OPT_e);
   Args.AddAllArgs(CmdArgs, options::OPT_s);
   Args.AddAllArgs(CmdArgs, options::OPT_t);
   Args.AddAllArgs(CmdArgs, options::OPT_r);
 
   if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))

clang/lib/Frontend/CompilerInvocation.cpp

if (A->getOption().getID() == OPT_ftime_report_EQ) {
         Diags.Report(diag::err_drv_invalid_value)
             << A->getAsString(Args) << A->getValue();
     }
   }
 
   Opts.PrepareForLTO = false;
   Opts.PrepareForThinLTO = false;
   if (Arg *A = Args.getLastArg(OPT_flto_EQ)) {
     Opts.PrepareForLTO = true;
     StringRef S = A->getValue();
     if (S == "thin")
       Opts.PrepareForThinLTO = true;
     else if (S != "full")
       Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << S;
+    if (Arg *A = Args.getLastArg(OPT_funified_lto))
+      Opts.PrepareForThinLTO = true;
   }
   if (Arg *A = Args.getLastArg(OPT_fthinlto_index_EQ)) {
     if (IK.getLanguage() != Language::LLVM_IR)
       Diags.Report(diag::err_drv_argument_only_allowed_with)
           << A->getAsString(Args) << "-x ir";
     Opts.ThinLTOIndexFile =
         std::string(Args.getLastArgValue(OPT_fthinlto_index_EQ));
   }
   if (Arg *A = Args.getLastArg(OPT_save_temps_EQ))
     Opts.SaveTempsFilePrefix =
         llvm::StringSwitch<std::string>(A->getValue())
             .Case("obj", OutputFile)

clang/test/CodeGen/asan-unified-lto.ll

+; Verify that in the cases of explict distinct LTO piplines,
+; explicit unified LTO pipelines, and the default LTO pipeline,
+; there is no crash and the anonoymous global is named
+; as expected.
+
+; RUN: %clang_cc1 -emit-llvm-bc -O1 -flto -fsanitize=address -o - -x ir < %s | llvm-dis -o - | FileCheck %s
+; RUN: %clang_cc1 -emit-llvm-bc -O1 -flto -funified-lto -fsanitize=address -o - -x ir < %s | llvm-dis -o - | FileCheck %s
+; CHECK: @anon.3ee0898e5200a57350fed5485ae5d237
+
+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-pc-linux-gnu"
+
+@.str = private unnamed_addr constant [5 x i8] c"none\00", align 1
+
+define ptr @f() {
+  %ptr = getelementptr inbounds [5 x i8], ptr @.str, i32 0, i32 0
+  ret ptr %ptr
+}

clang/test/CodeGen/emit-summary-index.c

 // ; Check that the -flto=thin option emits a ThinLTO summary
 // RUN: %clang_cc1 -flto=thin -emit-llvm-bc < %s | llvm-bcanalyzer -dump | FileCheck %s
 // CHECK: <GLOBALVAL_SUMMARY_BLOCK
 //
 // ; Check that we do not emit a summary for regular LTO on Apple platforms
 // RUN: %clang_cc1 -flto -triple x86_64-apple-darwin -emit-llvm-bc < %s | llvm-bcanalyzer -dump | FileCheck --check-prefix=LTO %s
 // LTO-NOT: GLOBALVAL_SUMMARY_BLOCK
 //
 // ; Check that we emit a summary for regular LTO by default elsewhere
 // RUN: %clang_cc1 -flto -triple x86_64-pc-linux-gnu -emit-llvm-bc < %s | llvm-bcanalyzer -dump | FileCheck --check-prefix=LTOINDEX %s
 // LTOINDEX: <FULL_LTO_GLOBALVAL_SUMMARY_BLOCK
 //
 // ; Simulate -save-temps and check that it works (!"ThinLTO" module flag not added multiple times)
 // RUN: %clang_cc1 -flto -triple x86_64-pc-linux-gnu -emit-llvm-bc -disable-llvm-passes < %s -o %t.bc
 // RUN: %clang_cc1 -flto -triple x86_64-pc-linux-gnu -emit-llvm-bc -x ir < %t.bc | llvm-bcanalyzer -dump | FileCheck --check-prefix=LTOINDEX %s
 
+/// Check that emitting bitcode works for Unified LTO, when either LTO mode is specified
+// RUN: %clang_cc1 -flto=thin -funified-lto -emit-llvm-bc < %s | llvm-bcanalyzer -dump | FileCheck --check-prefix=UNITHIN %s
+// RUN: %clang_cc1 -flto -funified-lto -emit-llvm-bc < %s | llvm-bcanalyzer -dump | FileCheck --check-prefix=UNITHIN %s
+
+// UNITHIN: <GLOBALVAL_SUMMARY_BLOCK
+
 int main(void) {}

clang/test/CodeGen/unified-lto-pipeline.c

+// RUN: %clang --target=x86_64-unknown-unknown-linux -flto=thin -funified-lto -O2 -c %s -o %t.0
+// RUN: mv %t.0 %t.1
+// RUN: %clang --target=x86_64-unknown-unknown-linux -flto=full -funified-lto -O2 -c %s -o %t.0
+// RUN: %clang --target=x86_64-unknown-unknown-linux -flto=thin -O2 -c %s -o %t.2
+// RUN: mv %t.2 %t.3
+// RUN: %clang --target=x86_64-unknown-unknown-linux -flto=full -O2 -c %s -o %t.2
+// RUN: cmp %t.0 %t.1
+// RUN: not cmp %t.2 %t.3
+
+int foo() {
+  return 2 + 2;
+}
+
+int bar() {
+  return foo() + 1;
+}

clang/test/CodeGenCXX/unified-cfi-lto.cpp

+// Ensure that the frontend adds the proper metadata when CFI is
+// enabled.
+// RUN: %clang --target=x86_64-scei-ps4 -funified-lto -flto -fsanitize=cfi -fvisibility=hidden -c %s -o %t.o
+// RUN: llvm-dis %t.o
+
+typedef int (*FuncPtr)();
+
+int a() { return 1; }
+int b() { return 2; }
+int c() { return 3; }
+
+FuncPtr func[3] = {a,b,c};
+
+int
+main(int argc, char *argv[]) {
+  // CHECK: call i1 @llvm.type.test
+  return func[argc]();
+  // CHECK-LABEL: trap
+}
+
+// CHECK: typeTests:

clang/test/Driver/lto-unit.c

 // RUN: %clang --target=x86_64-unknown-linux -### %s -flto=full 2>&1 | FileCheck --check-prefix=UNIT %s
 // RUN: %clang --target=x86_64-unknown-linux -### %s -flto=thin 2>&1 | FileCheck --check-prefix=UNIT %s
 // RUN: %clang --target=x86_64-apple-darwin13.3.0 -### %s -flto=full 2>&1 | FileCheck --check-prefix=UNIT %s
 // RUN: %clang --target=x86_64-apple-darwin13.3.0 -### %s -flto=thin 2>&1 | FileCheck --check-prefix=UNIT %s
 // RUN: %clang --target=x86_64-scei-ps4 -### %s -flto=full 2>&1 | FileCheck --check-prefix=UNIT %s
 // RUN: %clang --target=x86_64-scei-ps4 -### %s -flto=thin 2>&1 | FileCheck --check-prefix=UNIT %s
 
 // UNIT: "-flto-unit"
+// NOUNIT-NOT: "-flto-unit"

clang/test/Driver/unified-lto.c

+// RUN: %clang --target=x86_64-unknown-linux -### %s -flto=full -funified-lto 2>&1 | FileCheck --check-prefix=UNIT %s
+// RUN: %clang --target=x86_64-unknown-linux -### %s -flto=thin -funified-lto 2>&1 | FileCheck --check-prefix=UNIT %s
+
+// UNIT: "-flto-unit"
+// NOUNIT-NOT: "-flto-unit"
+
+// RUN: %clang --target=x86_64-pc-linux-gnu -fwhole-program-vtables -funified-lto -### %s 2>&1 | FileCheck --check-prefix=WARN %s
+// RUN: %clang --target=x86_64-pc-linux-gnu -fwhole-program-vtables -fno-unified-lto -### %s 2>&1 | FileCheck --check-prefix=WARN %s
+// WARN: invalid argument '-fwhole-program-vtables' only allowed with '-flto'

lld/ELF/Config.h

 #include "lld/Common/ErrorHandler.h"
 #include "llvm/ADT/CachedHashString.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/BinaryFormat/ELF.h"
+#include "llvm/LTO/LTO.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/CachePruning.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Compression.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/GlobPattern.h"
 #include "llvm/Support/PrettyStackTrace.h"
struct Config {
   // mode.
   int androidMemtagMode;
   // Signal to the dynamic loader to enable heap MTE.
   bool androidMemtagHeap;
   // Signal to the dynamic loader that this binary expects stack MTE. Generally,
   // this means to map the primary and thread stacks as PROT_MTE. Note: This is
   // not supported on Android 11 & 12.
   bool androidMemtagStack;
+  // When using a unified pre-link LTO pipeline, specify the backend LTO mode.
+  llvm::lto::LTO::LTOKind forceLTOMode = llvm::lto::LTO::LTOK_Default;
 
   unsigned threadCount;
 
   // If an input file equals a key, remap it to the value.
   llvm::DenseMap<llvm::StringRef, llvm::StringRef> remapInputs;
   // If an input file matches a wildcard pattern, remap it to the value.
   llvm::SmallVector<std::pair<llvm::GlobPattern, llvm::StringRef>, 0>
       remapInputsWildcards;

lld/ELF/Driver.cpp

static void readConfigs(opt::InputArgList &args) {
   config->passPlugins = args::getStrings(args, OPT_load_pass_plugins);
 
   // Parse -mllvm options.
   for (const auto *arg : args.filtered(OPT_mllvm)) {
     parseClangOption(arg->getValue(), arg->getSpelling());
     config->mllvmOpts.emplace_back(arg->getValue());
   }
 
+  config->forceLTOMode = llvm::lto::LTO::LTOK_Default;
+  if (auto *arg = args.getLastArg(OPT_lto_type_eq)) {
+    StringRef s = arg->getValue();
+    if (s == "thin")
+      config->forceLTOMode = llvm::lto::LTO::LTOK_UnifiedThin;
+    else if (s == "full")
+      config->forceLTOMode = llvm::lto::LTO::LTOK_UnifiedRegular;
+    else if (s == "default")
+      config->forceLTOMode = llvm::lto::LTO::LTOK_Default;
+    else
+      error("unknown LTO mode: " + s);
+  }
+
   // --threads= takes a positive integer and provides the default value for
   // --thinlto-jobs=. If unspecified, cap the number of threads since
   // overhead outweighs optimization for used parallel algorithms for the
   // non-LTO parts.
   if (auto *arg = args.getLastArg(OPT_threads)) {
     StringRef v(arg->getValue());
     unsigned threads = 0;
     if (!llvm::to_integer(v, threads, 0) || threads == 0)

lld/ELF/LTO.cpp

backend = lto::createWriteIndexesThinBackend(
         config->thinLTOEmitImportsFiles, indexFile.get(), onIndexWrite);
   } else {
     backend = lto::createInProcessThinBackend(
         llvm::heavyweight_hardware_concurrency(config->thinLTOJobs),
         onIndexWrite, config->thinLTOEmitIndexFiles,
         config->thinLTOEmitImportsFiles);
   }
 
-  ltoObj = std::make_unique<lto::LTO>(createConfig(), backend,
-                                       config->ltoPartitions);
+  ltoObj = std::make_unique<lto::LTO>(
+      createConfig(), backend, config->ltoPartitions, config->forceLTOMode);
 
   // Initialize usedStartStop.
   if (ctx.bitcodeFiles.empty())
     return;
   for (Symbol *sym : symtab.getSymbols()) {
     if (sym->isPlaceholder())
       continue;
     StringRef s = sym->getName();

lld/ELF/Options.td

 def: Flag<["-"], "S">, Alias<strip_debug>, HelpText<"Alias for --strip-debug">;
 def: Flag<["-"], "t">, Alias<trace>, HelpText<"Alias for --trace">;
 def: Joined<["-", "--"], "Ttext-segment=">, Alias<Ttext_segment>;
 def: JoinedOrSeparate<["-"], "y">, Alias<trace_symbol>, HelpText<"Alias for --trace-symbol">;
 def: JoinedOrSeparate<["-"], "u">, Alias<undefined>, HelpText<"Alias for --undefined">;
 def: Flag<["-"], "V">, Alias<v>, HelpText<"Alias for -v">;
 
 // LTO-related options.
+
+def lto_type_eq: J<"lto=">, HelpText<"Set LTO backend">,
+                 MetaVarName<"[full,thin]">;
 def lto_aa_pipeline: JJ<"lto-aa-pipeline=">,
   HelpText<"AA pipeline to run during LTO. Used in conjunction with -lto-newpm-passes">;
 def lto_debug_pass_manager: FF<"lto-debug-pass-manager">,
   HelpText<"Debug new pass manager">;
 def lto_emit_asm: FF<"lto-emit-asm">,
   HelpText<"Emit assembly code">;
 def lto_newpm_passes: JJ<"lto-newpm-passes=">,
   HelpText<"Passes to run during LTO">;

lld/test/ELF/lto/unified-lto.ll

+; REQUIRES: x86
+; RUN: opt -thinlto-bc -thinlto-split-lto-unit -unified-lto %s -o %t0.o
+; RUN: opt -thinlto-bc -thinlto-split-lto-unit %s -o %t1.o
+; RUN: ld.lld --lto=full %t0.o -o %t2
+; RUN: llvm-readobj --symbols %t2 | FileCheck %s
+; RUN: ld.lld --lto=thin %t0.o -o %t2
+; RUN: llvm-readobj --symbols %t2 | FileCheck %s
+; RUN: ld.lld --lto=default %t0.o -o %t2
+; RUN: llvm-readobj --symbols %t2 | FileCheck %s
+; RUN: ld.lld --lto=default %t1.o -o %t2
+; RUN: llvm-readobj --symbols %t2 | FileCheck %s
+; RUN: ld.lld %t0.o -o %t2
+; RUN: llvm-readobj --symbols %t2 | FileCheck %s
+
+; CHECK:      Format: elf64-x86-64
+; CHECK-NEXT: Arch: x86_64
+; CHECK-NEXT: AddressSize: 64bit
+
+; CHECK:      Name: _start
+; CHECK-NEXT: Value:
+; CHECK-NEXT: Size: 1
+; CHECK-NEXT: Binding: Global
+; CHECK-NEXT: Type: Function
+; CHECK-NEXT: Other:
+; CHECK-NEXT: Section: .text
+
+target triple = "x86_64-unknown-linux-gnu"
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+
+define void @_start() {
+  ret void
+}