Index: clang/lib/CodeGen/BackendUtil.cpp =================================================================== --- clang/lib/CodeGen/BackendUtil.cpp +++ clang/lib/CodeGen/BackendUtil.cpp @@ -1122,7 +1122,7 @@ break; case Backend_EmitBC: Conf.PreCodeGenModuleHook = [&](size_t Task, const Module &Mod) { - WriteBitcodeToFile(M, *OS, CGOpts.EmitLLVMUseLists); + WriteBitcodeToFile(*M, *OS, CGOpts.EmitLLVMUseLists); return false; }; break; @@ -1252,7 +1252,7 @@ // If the input is LLVM Assembly, bitcode is produced by serializing // the module. Use-lists order need to be perserved in this case. llvm::raw_string_ostream OS(Data); - llvm::WriteBitcodeToFile(M, OS, /* ShouldPreserveUseListOrder */ true); + llvm::WriteBitcodeToFile(*M, OS, /* ShouldPreserveUseListOrder */ true); ModuleData = ArrayRef((const uint8_t *)OS.str().data(), OS.str().size()); } else Index: clang/tools/clang-offload-bundler/ClangOffloadBundler.cpp =================================================================== --- clang/tools/clang-offload-bundler/ClangOffloadBundler.cpp +++ clang/tools/clang-offload-bundler/ClangOffloadBundler.cpp @@ -563,7 +563,7 @@ errs() << "error: unable to open temporary file.\n"; return true; } - WriteBitcodeToFile(AuxModule.get(), BitcodeFile); + WriteBitcodeToFile(*AuxModule, BitcodeFile); } bool Failed = sys::ExecuteAndWait(ClangBinary.get(), ClangArgs); Index: llvm/include/llvm/Bitcode/BitcodeWriter.h =================================================================== --- llvm/include/llvm/Bitcode/BitcodeWriter.h +++ llvm/include/llvm/Bitcode/BitcodeWriter.h @@ -86,7 +86,7 @@ /// Can be used to produce the same module hash for a minimized bitcode /// used just for the thin link as in the regular full bitcode that will /// be used in the backend. - void writeModule(const Module *M, bool ShouldPreserveUseListOrder = false, + void writeModule(const Module &M, bool ShouldPreserveUseListOrder = false, const ModuleSummaryIndex *Index = nullptr, bool GenerateHash = false, ModuleHash *ModHash = nullptr); @@ -97,7 +97,7 @@ /// /// ModHash is for use in ThinLTO incremental build, generated while the /// IR bitcode file writing. - void writeThinLinkBitcode(const Module *M, const ModuleSummaryIndex &Index, + void writeThinLinkBitcode(const Module &M, const ModuleSummaryIndex &Index, const ModuleHash &ModHash); void writeIndex( @@ -126,7 +126,7 @@ /// Can be used to produce the same module hash for a minimized bitcode /// used just for the thin link as in the regular full bitcode that will /// be used in the backend. - void WriteBitcodeToFile(const Module *M, raw_ostream &Out, + void WriteBitcodeToFile(const Module &M, raw_ostream &Out, bool ShouldPreserveUseListOrder = false, const ModuleSummaryIndex *Index = nullptr, bool GenerateHash = false, @@ -139,7 +139,7 @@ /// /// ModHash is for use in ThinLTO incremental build, generated while the IR /// bitcode file writing. - void WriteThinLinkBitcodeToFile(const Module *M, raw_ostream &Out, + void WriteThinLinkBitcodeToFile(const Module &M, raw_ostream &Out, const ModuleSummaryIndex &Index, const ModuleHash &ModHash); Index: llvm/lib/Bitcode/Writer/BitWriter.cpp =================================================================== --- llvm/lib/Bitcode/Writer/BitWriter.cpp +++ llvm/lib/Bitcode/Writer/BitWriter.cpp @@ -25,7 +25,7 @@ if (EC) return -1; - WriteBitcodeToFile(unwrap(M), OS); + WriteBitcodeToFile(*unwrap(M), OS); return 0; } @@ -33,7 +33,7 @@ int Unbuffered) { raw_fd_ostream OS(FD, ShouldClose, Unbuffered); - WriteBitcodeToFile(unwrap(M), OS); + WriteBitcodeToFile(*unwrap(M), OS); return 0; } @@ -45,6 +45,6 @@ std::string Data; raw_string_ostream OS(Data); - WriteBitcodeToFile(unwrap(M), OS); + WriteBitcodeToFile(*unwrap(M), OS); return wrap(MemoryBuffer::getMemBufferCopy(OS.str()).release()); } Index: llvm/lib/Bitcode/Writer/BitcodeWriter.cpp =================================================================== --- llvm/lib/Bitcode/Writer/BitcodeWriter.cpp +++ llvm/lib/Bitcode/Writer/BitcodeWriter.cpp @@ -170,12 +170,12 @@ public: /// Constructs a ModuleBitcodeWriterBase object for the given Module, /// writing to the provided \p Buffer. - ModuleBitcodeWriterBase(const Module *M, StringTableBuilder &StrtabBuilder, + ModuleBitcodeWriterBase(const Module &M, StringTableBuilder &StrtabBuilder, BitstreamWriter &Stream, bool ShouldPreserveUseListOrder, const ModuleSummaryIndex *Index) - : BitcodeWriterBase(Stream, StrtabBuilder), M(*M), - VE(*M, ShouldPreserveUseListOrder), Index(Index) { + : BitcodeWriterBase(Stream, StrtabBuilder), M(M), + VE(M, ShouldPreserveUseListOrder), Index(Index) { // Assign ValueIds to any callee values in the index that came from // indirect call profiles and were recorded as a GUID not a Value* // (which would have been assigned an ID by the ValueEnumerator). @@ -254,7 +254,7 @@ public: /// Constructs a ModuleBitcodeWriter object for the given Module, /// writing to the provided \p Buffer. - ModuleBitcodeWriter(const Module *M, SmallVectorImpl &Buffer, + ModuleBitcodeWriter(const Module &M, SmallVectorImpl &Buffer, StringTableBuilder &StrtabBuilder, BitstreamWriter &Stream, bool ShouldPreserveUseListOrder, const ModuleSummaryIndex *Index, bool GenerateHash, @@ -4038,7 +4038,7 @@ WroteStrtab = true; } -void BitcodeWriter::writeModule(const Module *M, +void BitcodeWriter::writeModule(const Module &M, bool ShouldPreserveUseListOrder, const ModuleSummaryIndex *Index, bool GenerateHash, ModuleHash *ModHash) { @@ -4048,8 +4048,8 @@ // Modules in case it needs to materialize metadata. But the bitcode writer // requires that the module is materialized, so we can cast to non-const here, // after checking that it is in fact materialized. - assert(M->isMaterialized()); - Mods.push_back(const_cast(M)); + assert(M.isMaterialized()); + Mods.push_back(const_cast(&M)); ModuleBitcodeWriter ModuleWriter(M, Buffer, StrtabBuilder, *Stream, ShouldPreserveUseListOrder, Index, @@ -4065,9 +4065,8 @@ IndexWriter.write(); } -/// WriteBitcodeToFile - Write the specified module to the specified output -/// stream. -void llvm::WriteBitcodeToFile(const Module *M, raw_ostream &Out, +/// Write the specified module to the specified output stream. +void llvm::WriteBitcodeToFile(const Module &M, raw_ostream &Out, bool ShouldPreserveUseListOrder, const ModuleSummaryIndex *Index, bool GenerateHash, ModuleHash *ModHash) { @@ -4076,7 +4075,7 @@ // If this is darwin or another generic macho target, reserve space for the // header. - Triple TT(M->getTargetTriple()); + Triple TT(M.getTargetTriple()); if (TT.isOSDarwin() || TT.isOSBinFormatMachO()) Buffer.insert(Buffer.begin(), BWH_HeaderSize, 0); @@ -4133,7 +4132,7 @@ const ModuleHash *ModHash; public: - ThinLinkBitcodeWriter(const Module *M, StringTableBuilder &StrtabBuilder, + ThinLinkBitcodeWriter(const Module &M, StringTableBuilder &StrtabBuilder, BitstreamWriter &Stream, const ModuleSummaryIndex &Index, const ModuleHash &ModHash) @@ -4251,7 +4250,7 @@ Stream.ExitBlock(); } -void BitcodeWriter::writeThinLinkBitcode(const Module *M, +void BitcodeWriter::writeThinLinkBitcode(const Module &M, const ModuleSummaryIndex &Index, const ModuleHash &ModHash) { assert(!WroteStrtab); @@ -4260,8 +4259,8 @@ // Modules in case it needs to materialize metadata. But the bitcode writer // requires that the module is materialized, so we can cast to non-const here, // after checking that it is in fact materialized. - assert(M->isMaterialized()); - Mods.push_back(const_cast(M)); + assert(M.isMaterialized()); + Mods.push_back(const_cast(&M)); ThinLinkBitcodeWriter ThinLinkWriter(M, StrtabBuilder, *Stream, Index, ModHash); @@ -4271,7 +4270,7 @@ // Write the specified thin link bitcode file to the given raw output stream, // where it will be written in a new bitcode block. This is used when // writing the per-module index file for ThinLTO. -void llvm::WriteThinLinkBitcodeToFile(const Module *M, raw_ostream &Out, +void llvm::WriteThinLinkBitcodeToFile(const Module &M, raw_ostream &Out, const ModuleSummaryIndex &Index, const ModuleHash &ModHash) { SmallVector Buffer; Index: llvm/lib/Bitcode/Writer/BitcodeWriterPass.cpp =================================================================== --- llvm/lib/Bitcode/Writer/BitcodeWriterPass.cpp +++ llvm/lib/Bitcode/Writer/BitcodeWriterPass.cpp @@ -23,7 +23,7 @@ const ModuleSummaryIndex *Index = EmitSummaryIndex ? &(AM.getResult(M)) : nullptr; - WriteBitcodeToFile(&M, OS, ShouldPreserveUseListOrder, Index, EmitModuleHash); + WriteBitcodeToFile(M, OS, ShouldPreserveUseListOrder, Index, EmitModuleHash); return PreservedAnalyses::all(); } @@ -55,7 +55,7 @@ EmitSummaryIndex ? &(getAnalysis().getIndex()) : nullptr; - WriteBitcodeToFile(&M, OS, ShouldPreserveUseListOrder, Index, + WriteBitcodeToFile(M, OS, ShouldPreserveUseListOrder, Index, EmitModuleHash); return false; } Index: llvm/lib/CodeGen/ParallelCG.cpp =================================================================== --- llvm/lib/CodeGen/ParallelCG.cpp +++ llvm/lib/CodeGen/ParallelCG.cpp @@ -44,7 +44,7 @@ if (OSs.size() == 1) { if (!BCOSs.empty()) - WriteBitcodeToFile(M.get(), *BCOSs[0]); + WriteBitcodeToFile(*M, *BCOSs[0]); codegen(M.get(), *OSs[0], TMFactory, FileType); return M; } @@ -66,7 +66,7 @@ // FIXME: Provide a more direct way to do this in LLVM. SmallString<0> BC; raw_svector_ostream BCOS(BC); - WriteBitcodeToFile(MPart.get(), BCOS); + WriteBitcodeToFile(*MPart, BCOS); if (!BCOSs.empty()) { BCOSs[ThreadCount]->write(BC.begin(), BC.size()); Index: llvm/lib/FuzzMutate/FuzzerCLI.cpp =================================================================== --- llvm/lib/FuzzMutate/FuzzerCLI.cpp +++ llvm/lib/FuzzMutate/FuzzerCLI.cpp @@ -169,7 +169,7 @@ std::string Buf; { raw_string_ostream OS(Buf); - WriteBitcodeToFile(&M, OS); + WriteBitcodeToFile(M, OS); } if (Buf.size() > MaxSize) return 0; Index: llvm/lib/LTO/LTOBackend.cpp =================================================================== --- llvm/lib/LTO/LTOBackend.cpp +++ llvm/lib/LTO/LTOBackend.cpp @@ -82,7 +82,7 @@ // directly and exit. if (EC) reportOpenError(Path, EC.message()); - WriteBitcodeToFile(&M, OS, /*ShouldPreserveUseListOrder=*/false); + WriteBitcodeToFile(M, OS, /*ShouldPreserveUseListOrder=*/false); return true; }; }; @@ -309,7 +309,7 @@ // FIXME: Provide a more direct way to do this in LLVM. SmallString<0> BC; raw_svector_ostream BCOS(BC); - WriteBitcodeToFile(MPart.get(), BCOS); + WriteBitcodeToFile(*MPart, BCOS); // Enqueue the task CodegenThreadPool.async( Index: llvm/lib/LTO/LTOCodeGenerator.cpp =================================================================== --- llvm/lib/LTO/LTOCodeGenerator.cpp +++ llvm/lib/LTO/LTOCodeGenerator.cpp @@ -220,7 +220,7 @@ } // write bitcode to it - WriteBitcodeToFile(MergedModule.get(), Out.os(), ShouldEmbedUselists); + WriteBitcodeToFile(*MergedModule, Out.os(), ShouldEmbedUselists); Out.os().close(); if (Out.os().has_error()) { Index: llvm/lib/LTO/ThinLTOCodeGenerator.cpp =================================================================== --- llvm/lib/LTO/ThinLTOCodeGenerator.cpp +++ llvm/lib/LTO/ThinLTOCodeGenerator.cpp @@ -82,7 +82,7 @@ if (EC) report_fatal_error(Twine("Failed to open ") + SaveTempPath + " to save optimized bitcode\n"); - WriteBitcodeToFile(&TheModule, OS, /* ShouldPreserveUseListOrder */ true); + WriteBitcodeToFile(TheModule, OS, /* ShouldPreserveUseListOrder */ true); } static const GlobalValueSummary * @@ -476,7 +476,7 @@ raw_svector_ostream OS(OutputBuffer); ProfileSummaryInfo PSI(TheModule); auto Index = buildModuleSummaryIndex(TheModule, nullptr, &PSI); - WriteBitcodeToFile(&TheModule, OS, true, &Index); + WriteBitcodeToFile(TheModule, OS, true, &Index); } return make_unique(std::move(OutputBuffer)); } Index: llvm/lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp =================================================================== --- llvm/lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp +++ llvm/lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp @@ -202,11 +202,11 @@ if (ModuleId.empty()) { // We couldn't generate a module ID for this module, just write it out as a // regular LTO module. - WriteBitcodeToFile(&M, OS); + WriteBitcodeToFile(M, OS); if (ThinLinkOS) // We don't have a ThinLTO part, but still write the module to the // ThinLinkOS if requested so that the expected output file is produced. - WriteBitcodeToFile(&M, *ThinLinkOS); + WriteBitcodeToFile(M, *ThinLinkOS); return; } @@ -374,10 +374,9 @@ // be used in the backends, and use that in the minimized bitcode // produced for the full link. ModuleHash ModHash = {{0}}; - W.writeModule(&M, /*ShouldPreserveUseListOrder=*/false, &Index, + W.writeModule(M, /*ShouldPreserveUseListOrder=*/false, &Index, /*GenerateHash=*/true, &ModHash); - W.writeModule(MergedM.get(), /*ShouldPreserveUseListOrder=*/false, - &MergedMIndex); + W.writeModule(*MergedM, /*ShouldPreserveUseListOrder=*/false, &MergedMIndex); W.writeSymtab(); W.writeStrtab(); OS << Buffer; @@ -389,8 +388,8 @@ Buffer.clear(); BitcodeWriter W2(Buffer); StripDebugInfo(M); - W2.writeThinLinkBitcode(&M, Index, ModHash); - W2.writeModule(MergedM.get(), /*ShouldPreserveUseListOrder=*/false, + W2.writeThinLinkBitcode(M, Index, ModHash); + W2.writeModule(*MergedM, /*ShouldPreserveUseListOrder=*/false, &MergedMIndex); W2.writeSymtab(); W2.writeStrtab(); @@ -423,13 +422,13 @@ // be used in the backends, and use that in the minimized bitcode // produced for the full link. ModuleHash ModHash = {{0}}; - WriteBitcodeToFile(&M, OS, /*ShouldPreserveUseListOrder=*/false, Index, + WriteBitcodeToFile(M, OS, /*ShouldPreserveUseListOrder=*/false, Index, /*GenerateHash=*/true, &ModHash); // If a minimized bitcode module was requested for the thin link, only // the information that is needed by thin link will be written in the // given OS. if (ThinLinkOS && Index) - WriteThinLinkBitcodeToFile(&M, *ThinLinkOS, *Index, ModHash); + WriteThinLinkBitcodeToFile(M, *ThinLinkOS, *Index, ModHash); } class WriteThinLTOBitcode : public ModulePass { Index: llvm/tools/bugpoint/OptimizerDriver.cpp =================================================================== --- llvm/tools/bugpoint/OptimizerDriver.cpp +++ llvm/tools/bugpoint/OptimizerDriver.cpp @@ -52,7 +52,7 @@ /// file. If an error occurs, true is returned. /// static bool writeProgramToFileAux(ToolOutputFile &Out, const Module *M) { - WriteBitcodeToFile(M, Out.os(), PreserveBitcodeUseListOrder); + WriteBitcodeToFile(*M, Out.os(), PreserveBitcodeUseListOrder); Out.os().close(); if (!Out.os().has_error()) { Out.keep(); @@ -69,7 +69,7 @@ bool BugDriver::writeProgramToFile(int FD, const Module *M) const { raw_fd_ostream OS(FD, /*shouldClose*/ false); - WriteBitcodeToFile(M, OS, PreserveBitcodeUseListOrder); + WriteBitcodeToFile(*M, OS, PreserveBitcodeUseListOrder); OS.flush(); if (!OS.has_error()) return false; @@ -158,7 +158,7 @@ DiscardTemp Discard{*Temp}; raw_fd_ostream OS(Temp->FD, /*shouldClose*/ false); - WriteBitcodeToFile(Program, OS, PreserveBitcodeUseListOrder); + WriteBitcodeToFile(*Program, OS, PreserveBitcodeUseListOrder); OS.flush(); if (OS.has_error()) { errs() << "Error writing bitcode file: " << Temp->TmpName << "\n"; Index: llvm/tools/gold/gold-plugin.cpp =================================================================== --- llvm/tools/gold/gold-plugin.cpp +++ llvm/tools/gold/gold-plugin.cpp @@ -784,7 +784,7 @@ raw_fd_ostream OS(output_name, EC, sys::fs::OpenFlags::F_None); if (EC) message(LDPL_FATAL, "Failed to write the output file."); - WriteBitcodeToFile(&M, OS, /* ShouldPreserveUseListOrder */ false); + WriteBitcodeToFile(M, OS, /* ShouldPreserveUseListOrder */ false); return false; }; break; Index: llvm/tools/llvm-as/llvm-as.cpp =================================================================== --- llvm/tools/llvm-as/llvm-as.cpp +++ llvm/tools/llvm-as/llvm-as.cpp @@ -85,7 +85,7 @@ } if (Force || !CheckBitcodeOutputToConsole(Out->os(), true)) - WriteBitcodeToFile(M, Out->os(), PreserveBitcodeUseListOrder, nullptr, + WriteBitcodeToFile(*M, Out->os(), PreserveBitcodeUseListOrder, nullptr, EmitModuleHash); // Declare success. Index: llvm/tools/llvm-cat/llvm-cat.cpp =================================================================== --- llvm/tools/llvm-cat/llvm-cat.cpp +++ llvm/tools/llvm-cat/llvm-cat.cpp @@ -73,7 +73,7 @@ Err.print(argv[0], errs()); return 1; } - Writer.writeModule(M.get()); + Writer.writeModule(*M); OwnedMods.push_back(std::move(M)); } Writer.writeStrtab(); Index: llvm/tools/llvm-link/llvm-link.cpp =================================================================== --- llvm/tools/llvm-link/llvm-link.cpp +++ llvm/tools/llvm-link/llvm-link.cpp @@ -398,7 +398,7 @@ if (OutputAssembly) { Composite->print(Out.os(), nullptr, PreserveAssemblyUseListOrder); } else if (Force || !CheckBitcodeOutputToConsole(Out.os(), true)) - WriteBitcodeToFile(Composite.get(), Out.os(), PreserveBitcodeUseListOrder); + WriteBitcodeToFile(*Composite, Out.os(), PreserveBitcodeUseListOrder); // Declare success. Out.keep(); Index: llvm/tools/llvm-lto/llvm-lto.cpp =================================================================== --- llvm/tools/llvm-lto/llvm-lto.cpp +++ llvm/tools/llvm-lto/llvm-lto.cpp @@ -462,7 +462,7 @@ raw_fd_ostream OS(Filename, EC, sys::fs::OpenFlags::F_None); error(EC, "error opening the file '" + Filename + "'"); maybeVerifyModule(TheModule); - WriteBitcodeToFile(&TheModule, OS, /* ShouldPreserveUseListOrder */ true); + WriteBitcodeToFile(TheModule, OS, /* ShouldPreserveUseListOrder */ true); } class ThinLTOProcessing { Index: llvm/tools/llvm-modextract/llvm-modextract.cpp =================================================================== --- llvm/tools/llvm-modextract/llvm-modextract.cpp +++ llvm/tools/llvm-modextract/llvm-modextract.cpp @@ -70,7 +70,7 @@ } std::unique_ptr M = ExitOnErr(Ms[ModuleIndex].parseModule(Context)); - WriteBitcodeToFile(M.get(), Out->os()); + WriteBitcodeToFile(*M, Out->os()); Out->keep(); return 0; Index: llvm/tools/llvm-opt-fuzzer/llvm-opt-fuzzer.cpp =================================================================== --- llvm/tools/llvm-opt-fuzzer/llvm-opt-fuzzer.cpp +++ llvm/tools/llvm-opt-fuzzer/llvm-opt-fuzzer.cpp @@ -77,7 +77,7 @@ std::string Buf; { raw_string_ostream OS(Buf); - WriteBitcodeToFile(M.get(), OS); + WriteBitcodeToFile(*M, OS); } if (Buf.size() > MaxSize) return 0; Index: llvm/tools/llvm-split/llvm-split.cpp =================================================================== --- llvm/tools/llvm-split/llvm-split.cpp +++ llvm/tools/llvm-split/llvm-split.cpp @@ -63,7 +63,7 @@ } verifyModule(*MPart); - WriteBitcodeToFile(MPart.get(), Out->os()); + WriteBitcodeToFile(*MPart, Out->os()); // Declare success. Out->keep(); Index: llvm/tools/verify-uselistorder/verify-uselistorder.cpp =================================================================== --- llvm/tools/verify-uselistorder/verify-uselistorder.cpp +++ llvm/tools/verify-uselistorder/verify-uselistorder.cpp @@ -132,7 +132,7 @@ return true; } - WriteBitcodeToFile(&M, OS, /* ShouldPreserveUseListOrder */ true); + WriteBitcodeToFile(M, OS, /* ShouldPreserveUseListOrder */ true); return false; } Index: llvm/unittests/Bitcode/BitReaderTest.cpp =================================================================== --- llvm/unittests/Bitcode/BitReaderTest.cpp +++ llvm/unittests/Bitcode/BitReaderTest.cpp @@ -44,7 +44,7 @@ static void writeModuleToBuffer(std::unique_ptr Mod, SmallVectorImpl &Buffer) { raw_svector_ostream OS(Buffer); - WriteBitcodeToFile(Mod.get(), OS); + WriteBitcodeToFile(*Mod, OS); } static std::unique_ptr getLazyModuleFromAssembly(LLVMContext &Context,