[llvm] [DTLTO][Windows] Expand short 8.3 form paths in ThinLTO module IDs (PR #178303)

via llvm-commits llvm-commits at lists.llvm.org
Thu Jan 29 05:18:40 PST 2026


llvmbot wrote:


<!--LLVM PR SUMMARY COMMENT-->

@llvm/pr-subscribers-llvm-support

Author: Ben Dunbobbin (bd1976bris)

<details>
<summary>Changes</summary>

Windows supports short 8.3 form filenames (e.g. `compile_commands.json` -> `COMPIL~1.JSO`) for legacy reasons. See:
https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file#short-vs-long-names.

Short 8.3 form paths are undesirable in distributed compilation scenarios because they are local mappings tied to a specific directory layout on a specific machine. As a result, they can break or defeat sandboxing and path-based isolation mechanisms used by distributed build systems.

We have observed such failures with DTLTO even in simple scenarios. For example, on Windows, running:

```
clang.exe hello.c -flto=thin -fuse-ld=lld -fthinlto-distributor=fastbuild.exe -###
```

on my development machine reveals a short 8.3 form path being passed to LLD (output paraphrased):

```
ld.lld -o a.out -plugin-opt=thinlto --thinlto-distributor=fastbuild.exe \
    --thinlto-remote-compiler=clang.exe C:\Users\DUNBOB~1\AppData\Local\Temp\hello-380d65.o
```

This behavior occurs because, on Windows, the system temporary directory is commonly derived from the `TMP`/`TEMP` environment variables. For historical compatibility reasons, these variables are often set to short 8.3 form paths, particularly on systems where user names exceed eight characters.

Whilst it's possible for users to work around these issues, in practice, especially in automated and CI environments, users often have limited control over their environment.

DTLTO generally tries to avoid embedding distribution-specific logic in the LLVM source tree, and this principle also applies to path normalization. However, on Windows, such short 8.3 form paths are undesirable for any distribution system. This normalization also cannot be delegated to distributors, as the ThinLTO module ID must be finalized early during LTO and cannot be modified later.

Given this, normalizing away short 8.3 paths on Windows is a pragmatic, targeted improvement, even though path normalization is not something a toolchain would typically perform in the general case.

SIE internal tracker: TOOLCHAIN-19185

---

Patch is 31.02 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/178303.diff


9 Files Affected:

- (added) cross-project-tests/dtlto/path.test (+90) 
- (modified) cross-project-tests/lit.site.cfg.py.in (+14-1) 
- (modified) llvm/include/llvm/DTLTO/DTLTO.h (+28-13) 
- (modified) llvm/include/llvm/LTO/LTO.h (+1-1) 
- (modified) llvm/include/llvm/Support/Windows/WindowsSupport.h (+5) 
- (modified) llvm/lib/DTLTO/DTLTO.cpp (+113-78) 
- (modified) llvm/lib/LTO/LTO.cpp (+1-1) 
- (modified) llvm/lib/Support/Windows/Path.inc (+77-15) 
- (modified) llvm/unittests/Support/Path.cpp (+133) 


``````````diff
diff --git a/cross-project-tests/dtlto/path.test b/cross-project-tests/dtlto/path.test
new file mode 100644
index 0000000000000..9fd249f912e35
--- /dev/null
+++ b/cross-project-tests/dtlto/path.test
@@ -0,0 +1,90 @@
+# REQUIRES: ld.lld,llvm-ar,tempshortpaths
+
+# Check that any short 8.3 form paths (containing '~' characters) in ThinLTO
+# Module IDs are expanded prior to being passed to the distributor.
+
+RUN: rm -rf %t && split-file %s %t && cd %t
+
+# Create an archive and a thin archive to confirm member paths are expanded.
+RUN: %clang --target=x86_64-linux-gnu -c foo.c moo.c start.c -flto=thin -O2
+RUN: prospero-llvm-ar rcs foo.a foo.o
+RUN: prospero-llvm-ar --thin rcs moo.a moo.o
+
+# Build with DTLTO.
+RUN: %python in-83-dir.py \
+RUN:   %clang --target=x86_64-linux-gnu -flto=thin -fuse-ld=lld -nostdlib \
+RUN:     foo.a moo.a start.o -Wl,--save-temps \
+RUN:     -fthinlto-distributor=%python \
+RUN:     -Xthinlto-distributor=%llvm_src_root/utils/dtlto/local.py
+
+# Check that all short 8.3 form paths have been expanded.
+RUN: FileCheck --input-file a.*.dist-file.json %s --check-prefix=TILDE
+TILDE-NOT: ~
+
+# It is important that cross-module inlining occurs for this test to show that
+# Clang can successfully load the bitcode file dependencies recorded in the
+# summary indices. Explicitly check that the expected importing has occurred.
+RUN: llvm-dis *.1.*.thinlto.bc -o - | \
+RUN:   FileCheck %s --check-prefixes=FOO,MOO,START
+RUN: llvm-dis *.2.*.thinlto.bc -o - | \
+RUN:   FileCheck %s --check-prefixes=FOO,MOO,START
+RUN: llvm-dis *.3.*.thinlto.bc -o - | \
+RUN:   FileCheck %s --check-prefixes=FOO,MOO,START
+FOO-DAG:   foo.o
+MOO-DAG:   moo.o
+START-DAG: start.o
+
+#--- foo.c
+extern int moo(int), _start(int);
+__attribute__((retain)) int foo(int x) { return x + moo(x) + _start(x); }
+
+#--- moo.c
+extern int foo(int), _start(int);
+__attribute__((retain)) int moo(int x) { return x + foo(x) + _start(x); }
+
+#--- start.c
+extern int foo(int), moo(int);
+__attribute__((retain)) int _start(int x) { return x + foo(x) + moo(x); }
+
+#--- in-83-dir.py
+import os, shutil, sys, uuid, subprocess
+from pathlib import Path
+import ctypes
+from ctypes import wintypes
+
+
+def get_short_path(p):
+    g = ctypes.windll.kernel32.GetShortPathNameW
+    g.argtypes = [wintypes.LPCWSTR, wintypes.LPWSTR, wintypes.DWORD]
+    g.restype = wintypes.DWORD
+    n = g(os.path.abspath(p), None, 0)  # First call gets required buffer size.
+    b = ctypes.create_unicode_buffer(n)
+    if g(os.path.abspath(p), b, n):  # Second call fills buffer.
+        return b.value
+    raise ctypes.WinError()
+
+
+temp = Path(os.environ["TEMP"])
+assert temp.is_dir()
+
+# Copy the CWD to a unique directory inside TEMP and ensure that one of the path
+# components is long enough to have a distinct short 8.3 form.
+# TEMP is likely to be on a drive that supports short 8.3 form paths.
+d = (temp / str(uuid.uuid4()) / "veryverylong").resolve()
+d.parent.mkdir(parents=True)
+try:
+    shutil.copytree(Path.cwd(), d)
+
+    # Replace the arguments of the command that name files with equivalents in
+    # our temp directory, prefixed with the short 8.3 form.
+    cmd = [
+        a if Path(a).is_absolute() or not (d / a).is_file() else get_short_path(d / a)
+        for a in sys.argv[1:]
+    ]
+
+    print(cmd)
+
+    sys.exit(subprocess.run(cmd).returncode)
+
+finally:
+    shutil.rmtree(d.parent)
diff --git a/cross-project-tests/lit.site.cfg.py.in b/cross-project-tests/lit.site.cfg.py.in
index 39458dfc79afd..b8992b6dca45e 100644
--- a/cross-project-tests/lit.site.cfg.py.in
+++ b/cross-project-tests/lit.site.cfg.py.in
@@ -1,7 +1,8 @@
 @LIT_SITE_CFG_IN_HEADER@
 
-import sys
+import shutil, sys, os, uuid
 import lit.util
+from pathlib import Path
 
 config.targets_to_build = "@TARGETS_TO_BUILD@".split()
 config.llvm_src_root = "@LLVM_SOURCE_DIR@"
@@ -22,7 +23,19 @@ config.mlir_src_root = "@MLIR_SOURCE_DIR@"
 config.llvm_use_sanitizer = "@LLVM_USE_SANITIZER@"
 
 import lit.llvm
+
 lit.llvm.initialize(lit_config, config)
 
 # Let the main config do the real work.
 lit_config.load_config(config, "@CROSS_PROJECT_TESTS_SOURCE_DIR@/lit.cfg.py")
+
+def are_short_names_enabled(path):
+    d = Path(path) / str(uuid.uuid4()) / "verylongdir"
+    d.mkdir(parents=True)
+    try:
+        return (d.parent / "verylo~1").exists()
+    finally:
+        shutil.rmtree(d.parent)
+
+if os.name == "nt" and are_short_names_enabled(config.environment.get("TEMP")):
+    config.available_features.add("tempshortpaths")
diff --git a/llvm/include/llvm/DTLTO/DTLTO.h b/llvm/include/llvm/DTLTO/DTLTO.h
index 02b098a68aec5..a72728299faa3 100644
--- a/llvm/include/llvm/DTLTO/DTLTO.h
+++ b/llvm/include/llvm/DTLTO/DTLTO.h
@@ -15,6 +15,22 @@
 namespace llvm {
 namespace lto {
 
+// The purpose of this class is to prepare inputs so that distributed ThinLTO
+// backend compilations can succeed.
+//
+// For distributed compilation, each input must exist as an individual bitcode
+// file on disk and be loadable via its ModuleID. This requirement is not met
+// for archive members, as an archive is a collection of files rather than a
+// standalone file. Similarly, for FatLTO objects, the bitcode is stored in a
+// section of the containing ELF object file. To address this, the class ensures
+// that an individual bitcode file exists for each input (by writing it out if
+// necessary) and that the ModuleID is updated to point to it. Module IDs are
+// also normalized on Windows to remove short 8.3 form paths that cannot be
+// loaded on remote machines.
+//
+// The class ensures that lto::InputFile objects are preserved until enough of
+// the LTO pipeline has executed to determine the required per-module
+// information, such as whether a module will participate in ThinLTO.
 class DTLTO : public LTO {
   using Base = LTO;
 
@@ -33,7 +49,10 @@ class DTLTO : public LTO {
   addInput(std::unique_ptr<InputFile> InputPtr) override;
 
 protected:
-  LLVM_ABI llvm::Error handleArchiveInputs() override;
+  // Save the contents of ThinLTO-enabled input files that must be serialized
+  // for distribution, such as archive members and FatLTO objects, to individual
+  // bitcode files named after the module ID.
+  LLVM_ABI llvm::Error serializeInputsForDistribution() override;
 
   LLVM_ABI void cleanup() override;
 
@@ -45,24 +64,20 @@ class DTLTO : public LTO {
   /// The output file to which this LTO invocation will contribute.
   StringRef LinkerOutputFile;
 
+  /// The normalized output directory, derived from LinkerOutputFile.
+  StringRef LinkerOutputDir;
+
   /// Controls preservation of any created temporary files.
   bool SaveTemps;
 
-  // Determines if a file at the given path is a thin archive file.
-  Expected<bool> isThinArchive(const StringRef ArchivePath);
-
-  // Write the archive member content to a file named after the module ID.
-  Error saveInputArchiveMember(lto::InputFile *Input);
-
-  // Iterates through all input files and saves their content
-  // to files if they are regular archive members.
-  Error saveInputArchiveMembers();
-
   // Array of input bitcode files for LTO.
   std::vector<std::shared_ptr<lto::InputFile>> InputFiles;
 
-  // A cache to avoid repeatedly reading the same archive file.
-  StringMap<bool> ArchiveFiles;
+  // Cache of whether a path refers to a thin archive.
+  StringMap<bool> ArchiveIsThinCache;
+
+  // Determines if the file at the given path is a thin archive.
+  Expected<bool> isThinArchive(const StringRef ArchivePath);
 };
 
 } // namespace lto
diff --git a/llvm/include/llvm/LTO/LTO.h b/llvm/include/llvm/LTO/LTO.h
index f992be9899e3d..fe8ef19759404 100644
--- a/llvm/include/llvm/LTO/LTO.h
+++ b/llvm/include/llvm/LTO/LTO.h
@@ -465,7 +465,7 @@ class LTO {
 
 protected:
   // Called at the start of run().
-  virtual Error handleArchiveInputs() { return Error::success(); }
+  virtual Error serializeInputsForDistribution() { return Error::success(); }
 
   // Called before returning from run().
   virtual void cleanup() {}
diff --git a/llvm/include/llvm/Support/Windows/WindowsSupport.h b/llvm/include/llvm/Support/Windows/WindowsSupport.h
index f35e7b55cb8d3..50a2540dba687 100644
--- a/llvm/include/llvm/Support/Windows/WindowsSupport.h
+++ b/llvm/include/llvm/Support/Windows/WindowsSupport.h
@@ -249,6 +249,11 @@ LLVM_ABI std::error_code widenPath(const Twine &Path8,
 /// ensuring we're not retrieving a malicious injected module but a module
 /// loaded from the system path.
 LLVM_ABI HMODULE loadSystemModuleSecure(LPCWSTR lpModuleName);
+
+/// Convert a UTF-8 path to a long form UTF-8 path expanding any short 8.3 form
+/// components.
+LLVM_ABI std::error_code makeLongFormPath(const Twine &Path8,
+                                          llvm::SmallVectorImpl<char> &Result8);
 } // end namespace windows
 } // end namespace sys
 } // end namespace llvm.
diff --git a/llvm/lib/DTLTO/DTLTO.cpp b/llvm/lib/DTLTO/DTLTO.cpp
index 4a1107e76e47b..0a24e49a85f77 100644
--- a/llvm/lib/DTLTO/DTLTO.cpp
+++ b/llvm/lib/DTLTO/DTLTO.cpp
@@ -8,7 +8,7 @@
 //
 // \file
 // This file implements support functions for Distributed ThinLTO, focusing on
-// archive file handling.
+// preparing input files for distribution.
 //
 //===----------------------------------------------------------------------===//
 
@@ -27,6 +27,9 @@
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/TimeProfiler.h"
 #include "llvm/Support/raw_ostream.h"
+#ifdef _WIN32
+#include "llvm/Support/Windows/WindowsSupport.h"
+#endif
 
 #include <string>
 
@@ -34,31 +37,54 @@ using namespace llvm;
 
 namespace {
 
-// Writes the content of a memory buffer into a file.
-llvm::Error saveBuffer(StringRef FileBuffer, StringRef FilePath) {
+// Saves the content of Buffer to Path overwriting any existing file.
+Error save(StringRef Buffer, StringRef Path) {
   std::error_code EC;
-  raw_fd_ostream OS(FilePath.str(), EC, sys::fs::OpenFlags::OF_None);
-  if (EC) {
+  raw_fd_ostream OS(Path.str(), EC, sys::fs::OpenFlags::OF_None);
+  if (EC)
     return createStringError(inconvertibleErrorCode(),
-                             "Failed to create file %s: %s", FilePath.data(),
+                             "Failed to create file %s: %s", Path.data(),
                              EC.message().c_str());
-  }
-  OS.write(FileBuffer.data(), FileBuffer.size());
-  if (OS.has_error()) {
+  OS.write(Buffer.data(), Buffer.size());
+  if (OS.has_error())
     return createStringError(inconvertibleErrorCode(),
-                             "Failed writing to file %s", FilePath.data());
-  }
+                             "Failed writing to file %s", Path.data());
   return Error::success();
 }
 
+// Saves the content of Input to Path overwriting any existing file.
+Error save(lto::InputFile *Input, StringRef Path) {
+  MemoryBufferRef MB = Input->getFileBuffer();
+  return save(MB.getBuffer(), Path);
+}
+
+// Normalize and save a path. Aside from expanding Windows 8.3 short paths,
+// no other normalization is currently required here. These paths are
+// machine-local and break distribution systems; other normalization is
+// handled by the DTLTO distributors.
+Expected<StringRef> normalizePath(StringRef Path, StringSaver &Saver) {
+#if defined(_WIN32)
+  if (Path.empty())
+    return Path;
+  SmallString<256> Expanded;
+  if (std::error_code EC = llvm::sys::windows::makeLongFormPath(Path, Expanded))
+    return createStringError(inconvertibleErrorCode(),
+                             "Normalization failed for path %s: %s",
+                             Path.str().c_str(), EC.message().c_str());
+  return Saver.save(Expanded.str());
+#else
+  return Saver.save(Path);
+#endif
+}
+
 // Compute the file path for a thin archive member.
 //
 // For thin archives, an archive member name is typically a file path relative
 // to the archive file's directory. This function resolves that path.
-SmallString<64> computeThinArchiveMemberPath(const StringRef ArchivePath,
-                                             const StringRef MemberName) {
+SmallString<256> computeThinArchiveMemberPath(StringRef ArchivePath,
+                                              StringRef MemberName) {
   assert(!ArchivePath.empty() && "An archive file path must be non empty.");
-  SmallString<64> MemberPath;
+  SmallString<256> MemberPath;
   if (sys::path::is_relative(MemberName)) {
     MemberPath = sys::path::parent_path(ArchivePath);
     sys::path::append(MemberPath, MemberName);
@@ -77,8 +103,8 @@ SmallString<64> computeThinArchiveMemberPath(const StringRef ArchivePath,
 // the archive type.
 Expected<bool> lto::DTLTO::isThinArchive(const StringRef ArchivePath) {
   // Return cached result if available.
-  auto Cached = ArchiveFiles.find(ArchivePath);
-  if (Cached != ArchiveFiles.end())
+  auto Cached = ArchiveIsThinCache.find(ArchivePath);
+  if (Cached != ArchiveIsThinCache.end())
     return Cached->second;
 
   uint64_t FileSize = -1;
@@ -112,108 +138,117 @@ Expected<bool> lto::DTLTO::isThinArchive(const StringRef ArchivePath) {
   IsThin = MemBuf.starts_with(object::ThinArchiveMagic);
 
   // Cache the result
-  ArchiveFiles[ArchivePath] = IsThin;
+  ArchiveIsThinCache[ArchivePath] = IsThin;
   return IsThin;
 }
 
+// Add an input file and prepare it for distribution.
+//
 // This function performs the following tasks:
-// 1. Adds the input file to the LTO object's list of input files.
-// 2. For thin archive members, generates a new module ID which is a path to a
-// thin archive member file.
-// 3. For regular archive members, generates a new unique module ID.
-// 4. Updates the bitcode module's identifier.
+// 1. Add the input file to the LTO object's list of input files.
+// 2. For individual bitcode file inputs on Windows only, overwrite the module
+//    ID with a normalized path to remove short 8.3 form components.
+// 3. For thin archive members, overwrite the module ID with the path
+//    (normalized on Windows) to the member file on disk.
+// 4. For archive members and FatLTO objects, overwrite the module ID with a
+//    unique path (normalized on Windows) naming a file that will contain the
+//    member content. The file is created and populated later (see
+//    serializeInputs()).
 Expected<std::shared_ptr<lto::InputFile>>
-lto::DTLTO::addInput(std::unique_ptr<lto::InputFile> InputPtr) {
+lto::DTLTO::addInput(std::unique_ptr<InputFile> InputPtr) {
   TimeTraceScope TimeScope("Add input for DTLTO");
 
   // Add the input file to the LTO object.
   InputFiles.emplace_back(InputPtr.release());
-  std::shared_ptr<lto::InputFile> &Input = InputFiles.back();
+  auto &Input = InputFiles.back();
+  BitcodeModule &BM = Input->getPrimaryBitcodeModule();
+
+  auto setIdFromPath = [&](StringRef Path) -> Error {
+    auto N = normalizePath(Path, Saver);
+    if (!N)
+      return N.takeError();
+    BM.setModuleIdentifier(*N);
+    return Error::success();
+  };
 
-  StringRef ModuleId = Input->getName();
   StringRef ArchivePath = Input->getArchivePath();
 
   // In most cases, the module ID already points to an individual bitcode file
-  // on disk, so no further preparation for distribution is required.
-  if (ArchivePath.empty() && !Input->isFatLTOObject())
+  // on disk, so no further preparation for distribution is required. However,
+  // on Windows we overwite the module ID to expand Windows 8.3 short form
+  // paths. These paths are machine-local and break distribution systems; other
+  // normalization is handled by the DTLTO distributors.
+  if (ArchivePath.empty() && !Input->isFatLTOObject()) {
+#if defined(_WIN32)
+    if (Error E = setIdFromPath(Input->getName()))
+      return std::move(E);
+#endif
     return Input;
-
-  SmallString<64> NewModuleId;
-  BitcodeModule &BM = Input->getPrimaryBitcodeModule();
+  }
 
   // For a member of a thin archive that is not a FatLTO object, there is an
   // existing file on disk that can be used, so we can avoid having to
-  // materialize.
+  // serialize.
   Expected<bool> UseThinMember =
       Input->isFatLTOObject() ? false : isThinArchive(ArchivePath);
   if (!UseThinMember)
     return UseThinMember.takeError();
-
   if (*UseThinMember) {
-    // For thin archives, use the path to the actual file.
-    NewModuleId =
+    // For thin archives, use the path to the actual member file on disk.
+    auto MemberFile =
         computeThinArchiveMemberPath(ArchivePath, Input->getMemberName());
-  } else {
-    // For regular archives and FatLTO objects, generate a unique name.
-    Input->setSerializeForDistribution(true);
+    if (Error E = setIdFromPath(MemberFile))
+      return std::move(E);
+    return Input;
+  }
 
-    // Create unique identifier using process ID and sequence number.
-    std::string PID = utohexstr(sys::Process::getProcessId());
-    std::string Seq = std::to_string(InputFiles.size());
+  // A new file on disk will be needed for archive members and FatLTO objects.
+  Input->setSerializeForDistribution(true);
 
-    NewModuleId = sys::path::parent_path(LinkerOutputFile);
-    sys::path::append(NewModuleId, sys::path::filename(ModuleId) + "." + Seq +
-                                       "." + PID + ".o");
+  // Get the normalized output directory, if we haven't already.
+  if (LinkerOutputDir.empty()) {
+    auto N = normalizePath(sys::path::parent_path(LinkerOutputFile), Saver);
+    if (!N)
+      return N.takeError();
+    LinkerOutputDir = *N;
   }
 
-  // Update the module identifier and save it.
-  BM.setModuleIdentifier(Saver.save(NewModuleId.str()));
-
+  // Create unique path by including the process ID and sequence number in the
+  // filename.
+  SmallString<256> Id(LinkerOutputDir);
+  sys::path::append(Id,
+                    Twine(sys::path::filename(Input->getName())) + "." +
+                        std::to_string(InputFiles.size()) /*Sequece number*/ +
+                        "." + utohexstr(sys::Process::getProcessId()) + ".o");
+  BM.setModuleIdentifier(Saver.save(Id.str()));
   return Input;
 }
 
-// Write the archive member content to a file named after the module ID.
-// If a file with that name already exists, it's likely a leftover from a
-// previously terminated linker process and can be safely overwritten.
-Error lto::DTLTO::saveInputArchiveMember(lto::InputFile *Input) {
-  StringRef ModuleId = Input->getName();
-  if (Input->getSerializeForDistribution()) {
+// Save the contents of ThinLTO-enabled input files that must be serialized for
+// distribution, such as archive members and FatLTO objects, to individual
+// bitcode files named after the module ID.
+//
+// Must be called after all input files are added but before optimization
+// begins. If a file with that name already exists, it is likely a leftover from
+// a previously terminated linker process and can be safely overwritten.
+llvm::Error lto::DTLTO::serializeInputsForDistribution() {
+  for (auto &Input : InputFiles) {
+    if (!Input->isThinLTO() || !Input->getSerializeForDistribution())
+      continue;
+    // Save the content of the input file to a file named after the module ID.
+    StringRef ModuleId = Input->getName();
     TimeTraceScope TimeScope("Serialize bitcode input for DTLTO", ModuleId);
     // Cleanup this file on abnormal process exit.
     if (!SaveTemps)
       llvm::sys::RemoveFileOnSignal(ModuleId);
-    MemoryBufferRef MemoryBufferRef = Input->getFileBuffer();
-    if (Error EC = saveBuffer(MemoryBufferRef.getBuffer(), ModuleId))
-      return EC;
-  }
-  return Error::success();
-}
-
-// Iterates through all ThinLTO-enabled input files and saves their content
-// to separate files if they are regular archive members.
-Error lto::DTLTO::saveInputArchiveMembers() {
-  for (auto &Input : InputFiles) {
-    if (!Input->isThinLTO())
-      continue;
-    if (Error EC = saveInputArchiveMember(Input.get()))
+    if (Error EC = save(Input.get(), ModuleId))
       return EC;
   }
-  return Error::success();
-}
-
-// Entry point for DTLTO archives support.
-//
-// Sets up the temporary file remover and processes archive members.
-// Must be called after all inputs are added but before optimization begins.
-llvm::Error lto::DTLTO::handleArchiveInputs() {
 
-  // Process and save archive members to separate files if needed.
-  if (Error EC = saveInputArchiveMembers())
-    return EC;
   return Error::success();
 }
 
-// Remove temporary archive member files created to enable distribution.
+// Remove serialized inputs crea...
[truncated]

``````````

</details>


https://github.com/llvm/llvm-project/pull/178303


More information about the llvm-commits mailing list