Pass TargetMachine from from Clang to BitcodeWriterand

Garvit Gupta · Garvit Gupta · commit 2ce59cc209f7 · 2025-08-03T11:24:32.000-07:00
`ThinLTOBitcodeWriter` pass for thin and fat LTO respectively. Currently in the `initializeRecordStreamer` function in the ModuleSymbolTable file, MCTargetOptions are initalized again even though they get populated in BackendUtil.cpp. Because of this, during lto, `IASSearchPaths` field of MCOptions which holds all include paths gets override and thus compiler is not able to locate files included using `.include` asm directive. This patch fixes the above issue. Fixes #112920 Change-Id: I099a940a46c3d8403207bc5f06fede2010163c34
diff --git a/clang/lib/CodeGen/BackendUtil.cpp b/clang/lib/CodeGen/BackendUtil.cpp
@@ -1155,7 +1155,8 @@ void EmitAssemblyHelper::RunOptimizationPipeline(
             return;
         }
         MPM.addPass(ThinLTOBitcodeWriterPass(
-            *OS, ThinLinkOS ? &ThinLinkOS->os() : nullptr));
+            *OS, ThinLinkOS ? &ThinLinkOS->os() : nullptr,
+            /* ShouldPreserveUseListOrder */ false, TM.get()));
       } else if (Action == Backend_EmitLL) {
         MPM.addPass(PrintModulePass(*OS, "", CodeGenOpts.EmitLLVMUseLists,
                                     /*EmitLTOSummary=*/true));
@@ -1173,7 +1174,7 @@ void EmitAssemblyHelper::RunOptimizationPipeline(
       }
       if (Action == Backend_EmitBC) {
         MPM.addPass(BitcodeWriterPass(*OS, CodeGenOpts.EmitLLVMUseLists,
-                                      EmitLTOSummary));
+                                      EmitLTOSummary, false, TM.get()));
       } else if (Action == Backend_EmitLL) {
         MPM.addPass(PrintModulePass(*OS, "", CodeGenOpts.EmitLLVMUseLists,
                                     EmitLTOSummary));
diff --git a/clang/test/CodeGen/Inputs/macros.s b/clang/test/CodeGen/Inputs/macros.s
diff --git a/clang/test/CodeGen/RISCV/include.c b/clang/test/CodeGen/RISCV/include.c
@@ -0,0 +1,11 @@
+// RUN: %clang --target=riscv32-unknown-elf -I %S/../Inputs/ -flto %s -c -o %t.full.bc
+// RUN: llvm-dis %t.full.bc -o - | FileCheck %s
+// RUN: %clang --target=riscv32-unknown-elf -I %S/../Inputs/ -flto=thin %s -c -o %t.thin.bc
+// RUN: llvm-dis %t.thin.bc -o - | FileCheck %s
+__asm__(".include \"macros.s\"");
+
+void test() {
+}
+
+// CHECK: module asm ".include \22macros.s\22"
+
diff --git a/llvm/include/llvm/Analysis/ModuleSummaryAnalysis.h b/llvm/include/llvm/Analysis/ModuleSummaryAnalysis.h
@@ -27,6 +27,7 @@ class Function;
 class Module;
 class ProfileSummaryInfo;
 class StackSafetyInfo;
+class TargetMachine;
 
 /// Direct function to compute a \c ModuleSummaryIndex from a given module.
 ///
@@ -37,7 +38,7 @@ class StackSafetyInfo;
 LLVM_ABI ModuleSummaryIndex buildModuleSummaryIndex(
     const Module &M,
     std::function<BlockFrequencyInfo *(const Function &F)> GetBFICallback,
-    ProfileSummaryInfo *PSI,
+    ProfileSummaryInfo *PSI, const TargetMachine *TM = nullptr,
     std::function<const StackSafetyInfo *(const Function &F)> GetSSICallback =
         [](const Function &F) -> const StackSafetyInfo * { return nullptr; });
 
@@ -51,7 +52,8 @@ class ModuleSummaryIndexAnalysis
 public:
   using Result = ModuleSummaryIndex;
 
-  LLVM_ABI Result run(Module &M, ModuleAnalysisManager &AM);
+  LLVM_ABI Result run(Module &M, ModuleSummaryIndexAnalysisManager &AM,
+                      const TargetMachine *TM = nullptr);
 };
 
 /// Legacy wrapper pass to provide the ModuleSummaryIndex object.
diff --git a/llvm/include/llvm/Bitcode/BitcodeWriter.h b/llvm/include/llvm/Bitcode/BitcodeWriter.h
@@ -29,6 +29,7 @@ namespace llvm {
 class BitstreamWriter;
 class Module;
 class raw_ostream;
+class TargetMachine;
 
 class BitcodeWriter {
   std::unique_ptr<BitstreamWriter> Stream;
@@ -45,10 +46,13 @@ class BitcodeWriter {
 
   std::vector<Module *> Mods;
 
+  const TargetMachine *TM;
+
 public:
   /// Create a BitcodeWriter that writes to Buffer.
-  LLVM_ABI BitcodeWriter(SmallVectorImpl<char> &Buffer);
-  LLVM_ABI BitcodeWriter(raw_ostream &FS);
+  LLVM_ABI BitcodeWriter(SmallVectorImpl<char> &Buffer,
+                         const TargetMachine *TM = nullptr);
+  LLVM_ABI BitcodeWriter(raw_ostream &FS, const TargetMachine *TM = nullptr);
 
   LLVM_ABI ~BitcodeWriter();
 
@@ -135,7 +139,8 @@ LLVM_ABI void WriteBitcodeToFile(const Module &M, raw_ostream &Out,
                                  bool ShouldPreserveUseListOrder = false,
                                  const ModuleSummaryIndex *Index = nullptr,
                                  bool GenerateHash = false,
-                                 ModuleHash *ModHash = nullptr);
+                                 ModuleHash *ModHash = nullptr,
+                                 const TargetMachine *TM = nullptr);
 
 /// Write the specified thin link bitcode file (i.e., the minimized bitcode
 /// file) to the given raw output stream, where it will be written in a new
@@ -146,7 +151,8 @@ LLVM_ABI void WriteBitcodeToFile(const Module &M, raw_ostream &Out,
 /// bitcode file writing.
 LLVM_ABI void writeThinLinkBitcodeToFile(const Module &M, raw_ostream &Out,
                                          const ModuleSummaryIndex &Index,
-                                         const ModuleHash &ModHash);
+                                         const ModuleHash &ModHash,
+                                         const TargetMachine *TM = nullptr);
 
 /// Write the specified module summary index to the given raw output stream,
 /// where it will be written in a new bitcode block. This is used when
diff --git a/llvm/include/llvm/Bitcode/BitcodeWriterPass.h b/llvm/include/llvm/Bitcode/BitcodeWriterPass.h
@@ -22,6 +22,7 @@ class Module;
 class ModulePass;
 class Pass;
 class raw_ostream;
+class TargetMachine;
 
 /// Create and return a pass that writes the module to the specified
 /// ostream. Note that this pass is designed for use with the legacy pass
@@ -31,7 +32,8 @@ class raw_ostream;
 /// reproduced when deserialized.
 LLVM_ABI ModulePass *
 createBitcodeWriterPass(raw_ostream &Str,
-                        bool ShouldPreserveUseListOrder = false);
+                        bool ShouldPreserveUseListOrder = false,
+                        const TargetMachine *TM = nullptr);
 
 /// Check whether a pass is a BitcodeWriterPass.
 LLVM_ABI bool isBitcodeWriterPass(Pass *P);
@@ -45,6 +47,7 @@ class BitcodeWriterPass : public PassInfoMixin<BitcodeWriterPass> {
   bool ShouldPreserveUseListOrder;
   bool EmitSummaryIndex;
   bool EmitModuleHash;
+  const TargetMachine *TM;
 
 public:
   /// Construct a bitcode writer pass around a particular output stream.
@@ -57,13 +60,16 @@ class BitcodeWriterPass : public PassInfoMixin<BitcodeWriterPass> {
   explicit BitcodeWriterPass(raw_ostream &OS,
                              bool ShouldPreserveUseListOrder = false,
                              bool EmitSummaryIndex = false,
-                             bool EmitModuleHash = false)
+                             bool EmitModuleHash = false,
+                             const TargetMachine *TM = nullptr)
       : OS(OS), ShouldPreserveUseListOrder(ShouldPreserveUseListOrder),
-  EmitSummaryIndex(EmitSummaryIndex), EmitModuleHash(EmitModuleHash) {}
+        EmitSummaryIndex(EmitSummaryIndex), EmitModuleHash(EmitModuleHash),
+        TM(TM) {}
 
   /// Run the bitcode writer pass, and output the module to the selected
   /// output stream.
-  LLVM_ABI PreservedAnalyses run(Module &M, ModuleAnalysisManager &);
+  LLVM_ABI PreservedAnalyses run(Module &M,
+                                 ModuleSummaryIndexAnalysisManager &AM);
 
   static bool isRequired() { return true; }
 };
diff --git a/llvm/include/llvm/IR/PassManager.h b/llvm/include/llvm/IR/PassManager.h
@@ -59,6 +59,7 @@ namespace llvm {
 
 class Function;
 class Module;
+class TargetMachine;
 
 // Forward declare the analysis manager template.
 template <typename IRUnitT, typename... ExtraArgTs> class AnalysisManager;
@@ -542,6 +543,13 @@ extern template class LLVM_TEMPLATE_ABI AnalysisManager<Module>;
 /// Convenience typedef for the Module analysis manager.
 using ModuleAnalysisManager = AnalysisManager<Module>;
 
+extern template class LLVM_TEMPLATE_ABI
+    AnalysisManager<Module, const TargetMachine *>;
+
+/// Separate typedef for ModuleSummaryAnalysisPass to pass TargetMachine to it.
+using ModuleSummaryIndexAnalysisManager =
+    AnalysisManager<Module, const TargetMachine *>;
+
 extern template class LLVM_TEMPLATE_ABI AnalysisManager<Function>;
 
 /// Convenience typedef for the Function analysis manager.
diff --git a/llvm/include/llvm/Object/IRSymtab.h b/llvm/include/llvm/Object/IRSymtab.h
@@ -41,6 +41,7 @@ namespace llvm {
 
 struct BitcodeFileContents;
 class StringTableBuilder;
+class TargetMachine;
 
 namespace irsymtab {
 
@@ -164,8 +165,8 @@ struct Header {
 /// Fills in Symtab and StrtabBuilder with a valid symbol and string table for
 /// Mods.
 LLVM_ABI Error build(ArrayRef<Module *> Mods, SmallVector<char, 0> &Symtab,
-                     StringTableBuilder &StrtabBuilder,
-                     BumpPtrAllocator &Alloc);
+                     StringTableBuilder &StrtabBuilder, BumpPtrAllocator &Alloc,
+                     const TargetMachine *TM = nullptr);
 
 /// This represents a symbol that has been read from a storage::Symbol and
 /// possibly a storage::Uncommon.
diff --git a/llvm/include/llvm/Object/ModuleSymbolTable.h b/llvm/include/llvm/Object/ModuleSymbolTable.h
@@ -30,6 +30,7 @@ namespace llvm {
 
 class GlobalValue;
 class Module;
+class TargetMachine;
 
 class ModuleSymbolTable {
 public:
@@ -45,7 +46,7 @@ class ModuleSymbolTable {
 
 public:
   ArrayRef<Symbol> symbols() const { return SymTab; }
-  LLVM_ABI void addModule(Module *M);
+  LLVM_ABI void addModule(Module *M, const TargetMachine *TM = nullptr);
 
   LLVM_ABI void printSymbolName(raw_ostream &OS, Symbol S) const;
   LLVM_ABI uint32_t getSymbolFlags(Symbol S) const;
@@ -57,7 +58,8 @@ class ModuleSymbolTable {
   /// and the associated flags.
   LLVM_ABI static void CollectAsmSymbols(
       const Module &M,
-      function_ref<void(StringRef, object::BasicSymbolRef::Flags)> AsmSymbol);
+      function_ref<void(StringRef, object::BasicSymbolRef::Flags)> AsmSymbol,
+      const TargetMachine *TM = nullptr);
 
   /// Parse inline ASM and collect the symvers directives that are defined in
   /// the current module.
diff --git a/llvm/include/llvm/Transforms/IPO/EmbedBitcodePass.h b/llvm/include/llvm/Transforms/IPO/EmbedBitcodePass.h
@@ -45,7 +45,8 @@ class EmbedBitcodePass : public PassInfoMixin<EmbedBitcodePass> {
   EmbedBitcodePass(bool IsThinLTO, bool EmitLTOSummary)
       : IsThinLTO(IsThinLTO), EmitLTOSummary(EmitLTOSummary) {}
 
-  LLVM_ABI PreservedAnalyses run(Module &M, ModuleAnalysisManager &);
+  LLVM_ABI PreservedAnalyses run(Module &M,
+                                 ModuleSummaryIndexAnalysisManager &AM);
 
   static bool isRequired() { return true; }
 };
diff --git a/llvm/include/llvm/Transforms/IPO/ThinLTOBitcodeWriter.h b/llvm/include/llvm/Transforms/IPO/ThinLTOBitcodeWriter.h
@@ -22,22 +22,26 @@
 namespace llvm {
 class Module;
 class raw_ostream;
+class TargetMachine;
 
 class ThinLTOBitcodeWriterPass
     : public PassInfoMixin<ThinLTOBitcodeWriterPass> {
   raw_ostream &OS;
   raw_ostream *ThinLinkOS;
   const bool ShouldPreserveUseListOrder;
+  const TargetMachine *TM;
 
 public:
   // Writes bitcode to OS. Also write thin link file to ThinLinkOS, if
   // it's not nullptr.
   ThinLTOBitcodeWriterPass(raw_ostream &OS, raw_ostream *ThinLinkOS,
-                           bool ShouldPreserveUseListOrder = false)
+                           bool ShouldPreserveUseListOrder = false,
+                           const TargetMachine *TM = nullptr)
       : OS(OS), ThinLinkOS(ThinLinkOS),
-        ShouldPreserveUseListOrder(ShouldPreserveUseListOrder) {}
+        ShouldPreserveUseListOrder(ShouldPreserveUseListOrder), TM(TM) {}
 
-  LLVM_ABI PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  LLVM_ABI PreservedAnalyses run(Module &M,
+                                 ModuleSummaryIndexAnalysisManager &AM);
 
   static bool isRequired() { return true; }
 };
diff --git a/llvm/lib/Analysis/ModuleSummaryAnalysis.cpp b/llvm/lib/Analysis/ModuleSummaryAnalysis.cpp
@@ -43,6 +43,7 @@
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/ModuleSummaryIndex.h"
+#include "llvm/IR/PassManager.h"
 #include "llvm/IR/Use.h"
 #include "llvm/IR/User.h"
 #include "llvm/InitializePasses.h"
@@ -934,7 +935,7 @@ static void setLiveRoot(ModuleSummaryIndex &Index, StringRef Name) {
 ModuleSummaryIndex llvm::buildModuleSummaryIndex(
     const Module &M,
     std::function<BlockFrequencyInfo *(const Function &F)> GetBFICallback,
-    ProfileSummaryInfo *PSI,
+    ProfileSummaryInfo *PSI, const TargetMachine *TM,
     std::function<const StackSafetyInfo *(const Function &F)> GetSSICallback) {
   assert(PSI);
   bool EnableSplitLTOUnit = false;
@@ -978,7 +979,8 @@ ModuleSummaryIndex llvm::buildModuleSummaryIndex(
     // be listed on the llvm.used or llvm.compiler.used global and marked as
     // referenced from there.
     ModuleSymbolTable::CollectAsmSymbols(
-        M, [&](StringRef Name, object::BasicSymbolRef::Flags Flags) {
+        M,
+        [&](StringRef Name, object::BasicSymbolRef::Flags Flags) {
           // Symbols not marked as Weak or Global are local definitions.
           if (Flags & (object::BasicSymbolRef::SF_Weak |
                        object::BasicSymbolRef::SF_Global))
@@ -987,7 +989,8 @@ ModuleSummaryIndex llvm::buildModuleSummaryIndex(
           GlobalValue *GV = M.getNamedValue(Name);
           if (!GV)
             return;
-          assert(GV->isDeclaration() && "Def in module asm already has definition");
+          assert(GV->isDeclaration() &&
+                 "Def in module asm already has definition");
           GlobalValueSummary::GVFlags GVFlags(
               GlobalValue::InternalLinkage, GlobalValue::DefaultVisibility,
               /* NotEligibleToImport = */ true,
@@ -1031,7 +1034,8 @@ ModuleSummaryIndex llvm::buildModuleSummaryIndex(
                     SmallVector<ValueInfo, 0>{});
             Index.addGlobalValueSummary(*GV, std::move(Summary));
           }
-        });
+        },
+        TM);
   }
 
   bool IsThinLTO = true;
@@ -1144,18 +1148,19 @@ ModuleSummaryIndex llvm::buildModuleSummaryIndex(
 
 AnalysisKey ModuleSummaryIndexAnalysis::Key;
 
-ModuleSummaryIndex
-ModuleSummaryIndexAnalysis::run(Module &M, ModuleAnalysisManager &AM) {
-  ProfileSummaryInfo &PSI = AM.getResult<ProfileSummaryAnalysis>(M);
-  auto &FAM = AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
+ModuleSummaryIndex ModuleSummaryIndexAnalysis::run(
+    Module &M, ModuleSummaryIndexAnalysisManager &AM, const TargetMachine *TM) {
+  ProfileSummaryInfo &PSI = AM.getResult<ProfileSummaryAnalysis>(M, TM);
+  auto &FAM =
+      AM.getResult<FunctionAnalysisManagerModuleProxy>(M, TM).getManager();
   bool NeedSSI = needsParamAccessSummary(M);
   return buildModuleSummaryIndex(
       M,
       [&FAM](const Function &F) {
         return &FAM.getResult<BlockFrequencyAnalysis>(
             *const_cast<Function *>(&F));
       },
-      &PSI,
+      &PSI, TM,
       [&FAM, NeedSSI](const Function &F) -> const StackSafetyInfo * {
         return NeedSSI ? &FAM.getResult<StackSafetyAnalysis>(
                              const_cast<Function &>(F))
@@ -1190,7 +1195,7 @@ bool ModuleSummaryIndexWrapperPass::runOnModule(Module &M) {
                          *const_cast<Function *>(&F))
                      .getBFI());
       },
-      PSI,
+      PSI, nullptr,
       [&](const Function &F) -> const StackSafetyInfo * {
         return NeedSSI ? &getAnalysis<StackSafetyInfoWrapperPass>(
                               const_cast<Function &>(F))
diff --git a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -5364,13 +5364,14 @@ static void writeBitcodeHeader(BitstreamWriter &Stream) {
   Stream.Emit(0xD, 4);
 }
 
-BitcodeWriter::BitcodeWriter(SmallVectorImpl<char> &Buffer)
-    : Stream(new BitstreamWriter(Buffer)) {
+BitcodeWriter::BitcodeWriter(SmallVectorImpl<char> &Buffer,
+                             const TargetMachine *TM)
+    : Stream(new BitstreamWriter(Buffer)), TM(TM) {
   writeBitcodeHeader(*Stream);
 }
 
-BitcodeWriter::BitcodeWriter(raw_ostream &FS)
-    : Stream(new BitstreamWriter(FS, FlushThreshold)) {
+BitcodeWriter::BitcodeWriter(raw_ostream &FS, const TargetMachine *TM)
+    : Stream(new BitstreamWriter(FS, FlushThreshold)), TM(TM) {
   writeBitcodeHeader(*Stream);
 }
 
@@ -5412,7 +5413,7 @@ void BitcodeWriter::writeSymtab() {
   // module is malformed (e.g. it contains an invalid alias). Writing a symbol
   // table is not required for correctness, but we still want to be able to
   // write malformed modules to bitcode files, so swallow the error.
-  if (Error E = irsymtab::build(Mods, Symtab, StrtabBuilder, Alloc)) {
+  if (Error E = irsymtab::build(Mods, Symtab, StrtabBuilder, Alloc, TM)) {
     consumeError(std::move(E));
     return;
   }
@@ -5472,7 +5473,8 @@ void BitcodeWriter::writeIndex(
 void llvm::WriteBitcodeToFile(const Module &M, raw_ostream &Out,
                               bool ShouldPreserveUseListOrder,
                               const ModuleSummaryIndex *Index,
-                              bool GenerateHash, ModuleHash *ModHash) {
+                              bool GenerateHash, ModuleHash *ModHash,
+                              const TargetMachine *TM) {
   auto Write = [&](BitcodeWriter &Writer) {
     Writer.writeModule(M, ShouldPreserveUseListOrder, Index, GenerateHash,
                        ModHash);
@@ -5493,7 +5495,7 @@ void llvm::WriteBitcodeToFile(const Module &M, raw_ostream &Out,
     emitDarwinBCHeaderAndTrailer(Buffer, TT);
     Out.write(Buffer.data(), Buffer.size());
   } else {
-    BitcodeWriter Writer(Out);
+    BitcodeWriter Writer(Out, TM);
     Write(Writer);
   }
 }
@@ -5679,11 +5681,12 @@ void BitcodeWriter::writeThinLinkBitcode(const Module &M,
 // writing the per-module index file for ThinLTO.
 void llvm::writeThinLinkBitcodeToFile(const Module &M, raw_ostream &Out,
                                       const ModuleSummaryIndex &Index,
-                                      const ModuleHash &ModHash) {
+                                      const ModuleHash &ModHash,
+                                      const TargetMachine *TM) {
   SmallVector<char, 0> Buffer;
   Buffer.reserve(256 * 1024);
 
-  BitcodeWriter Writer(Buffer);
+  BitcodeWriter Writer(Buffer, TM);
   Writer.writeThinLinkBitcode(M, Index, ModHash);
   Writer.writeSymtab();
   Writer.writeStrtab();
diff --git a/llvm/lib/Bitcode/Writer/BitcodeWriterPass.cpp b/llvm/lib/Bitcode/Writer/BitcodeWriterPass.cpp
diff --git a/llvm/lib/Object/IRSymtab.cpp b/llvm/lib/Object/IRSymtab.cpp
diff --git a/llvm/lib/Object/ModuleSymbolTable.cpp b/llvm/lib/Object/ModuleSymbolTable.cpp
diff --git a/llvm/lib/Transforms/IPO/EmbedBitcodePass.cpp b/llvm/lib/Transforms/IPO/EmbedBitcodePass.cpp
diff --git a/llvm/lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp b/llvm/lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp
