LLVM 20.0.0git
BitcodeWriter.h
Go to the documentation of this file.
1//===- llvm/Bitcode/BitcodeWriter.h - Bitcode writers -----------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This header defines interfaces to write LLVM bitcode files/streams.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_BITCODE_BITCODEWRITER_H
14#define LLVM_BITCODE_BITCODEWRITER_H
15
16#include "llvm/ADT/StringRef.h"
21#include <map>
22#include <memory>
23#include <string>
24#include <vector>
25
26namespace llvm {
27
28class BitstreamWriter;
29class Module;
30class raw_ostream;
31
33 std::unique_ptr<BitstreamWriter> Stream;
34
36
37 // Owns any strings created by the irsymtab writer until we create the
38 // string table.
39 BumpPtrAllocator Alloc;
40
41 bool WroteStrtab = false, WroteSymtab = false;
42
43 void writeBlob(unsigned Block, unsigned Record, StringRef Blob);
44
45 std::vector<Module *> Mods;
46
47public:
48 /// Create a BitcodeWriter that writes to Buffer.
51
53
54 /// Attempt to write a symbol table to the bitcode file. This must be called
55 /// at most once after all modules have been written.
56 ///
57 /// A reader does not require a symbol table to interpret a bitcode file;
58 /// the symbol table is needed only to improve link-time performance. So
59 /// this function may decide not to write a symbol table. It may so decide
60 /// if, for example, the target is unregistered or the IR is malformed.
61 void writeSymtab();
62
63 /// Write the bitcode file's string table. This must be called exactly once
64 /// after all modules and the optional symbol table have been written.
65 void writeStrtab();
66
67 /// Copy the string table for another module into this bitcode file. This
68 /// should be called after copying the module itself into the bitcode file.
69 void copyStrtab(StringRef Strtab);
70
71 /// Write the specified module to the buffer specified at construction time.
72 ///
73 /// If \c ShouldPreserveUseListOrder, encode the use-list order for each \a
74 /// Value in \c M. These will be reconstructed exactly when \a M is
75 /// deserialized.
76 ///
77 /// If \c Index is supplied, the bitcode will contain the summary index
78 /// (currently for use in ThinLTO optimization).
79 ///
80 /// \p GenerateHash enables hashing the Module and including the hash in the
81 /// bitcode (currently for use in ThinLTO incremental build).
82 ///
83 /// If \p ModHash is non-null, when GenerateHash is true, the resulting
84 /// hash is written into ModHash. When GenerateHash is false, that value
85 /// is used as the hash instead of computing from the generated bitcode.
86 /// Can be used to produce the same module hash for a minimized bitcode
87 /// used just for the thin link as in the regular full bitcode that will
88 /// be used in the backend.
89 void writeModule(const Module &M, bool ShouldPreserveUseListOrder = false,
90 const ModuleSummaryIndex *Index = nullptr,
91 bool GenerateHash = false, ModuleHash *ModHash = nullptr);
92
93 /// Write the specified thin link bitcode file (i.e., the minimized bitcode
94 /// file) to the buffer specified at construction time. The thin link
95 /// bitcode file is used for thin link, and it only contains the necessary
96 /// information for thin link.
97 ///
98 /// ModHash is for use in ThinLTO incremental build, generated while the
99 /// IR bitcode file writing.
101 const ModuleHash &ModHash);
102
103 void writeIndex(
105 const std::map<std::string, GVSummaryMapTy> *ModuleToSummariesForIndex,
106 const GVSummaryPtrSet *DecSummaries);
107};
108
109/// Write the specified module to the specified raw output stream.
110///
111/// For streams where it matters, the given stream should be in "binary"
112/// mode.
113///
114/// If \c ShouldPreserveUseListOrder, encode the use-list order for each \a
115/// Value in \c M. These will be reconstructed exactly when \a M is
116/// deserialized.
117///
118/// If \c Index is supplied, the bitcode will contain the summary index
119/// (currently for use in ThinLTO optimization).
120///
121/// \p GenerateHash enables hashing the Module and including the hash in the
122/// bitcode (currently for use in ThinLTO incremental build).
123///
124/// If \p ModHash is non-null, when GenerateHash is true, the resulting
125/// hash is written into ModHash. When GenerateHash is false, that value
126/// is used as the hash instead of computing from the generated bitcode.
127/// Can be used to produce the same module hash for a minimized bitcode
128/// used just for the thin link as in the regular full bitcode that will
129/// be used in the backend.
130void WriteBitcodeToFile(const Module &M, raw_ostream &Out,
131 bool ShouldPreserveUseListOrder = false,
132 const ModuleSummaryIndex *Index = nullptr,
133 bool GenerateHash = false,
134 ModuleHash *ModHash = nullptr);
135
136/// Write the specified thin link bitcode file (i.e., the minimized bitcode
137/// file) to the given raw output stream, where it will be written in a new
138/// bitcode block. The thin link bitcode file is used for thin link, and it
139/// only contains the necessary information for thin link.
140///
141/// ModHash is for use in ThinLTO incremental build, generated while the IR
142/// bitcode file writing.
145 const ModuleHash &ModHash);
146
147/// Write the specified module summary index to the given raw output stream,
148/// where it will be written in a new bitcode block. This is used when
149/// writing the combined index file for ThinLTO. When writing a subset of the
150/// index for a distributed backend, provide the \p ModuleToSummariesForIndex
151/// map. \p DecSummaries specifies the set of summaries for which the
152/// corresponding value should be imported as a declaration (prototype).
154 const std::map<std::string, GVSummaryMapTy>
155 *ModuleToSummariesForIndex = nullptr,
156 const GVSummaryPtrSet *DecSummaries = nullptr);
157
158/// If EmbedBitcode is set, save a copy of the llvm IR as data in the
159/// __LLVM,__bitcode section (.llvmbc on non-MacOS).
160/// If available, pass the serialized module via the Buf parameter. If not,
161/// pass an empty (default-initialized) MemoryBufferRef, and the serialization
162/// will be handled by this API. The same behavior happens if the provided Buf
163/// is not bitcode (i.e. if it's invalid data or even textual LLVM assembly).
164/// If EmbedCmdline is set, the command line is also exported in
165/// the corresponding section (__LLVM,_cmdline / .llvmcmd) - even if CmdArgs
166/// were empty.
168 bool EmbedCmdline,
169 const std::vector<uint8_t> &CmdArgs);
170
171} // end namespace llvm
172
173#endif // LLVM_BITCODE_BITCODEWRITER_H
This file defines the BumpPtrAllocator interface.
static cl::opt< LTOBitcodeEmbedding > EmbedBitcode("lto-embed-bitcode", cl::init(LTOBitcodeEmbedding::DoNotEmbed), cl::values(clEnumValN(LTOBitcodeEmbedding::DoNotEmbed, "none", "Do not embed"), clEnumValN(LTOBitcodeEmbedding::EmbedOptimized, "optimized", "Embed after all optimization passes"), clEnumValN(LTOBitcodeEmbedding::EmbedPostMergePreOptimized, "post-merge-pre-opt", "Embed post merge, but before optimizations")), cl::desc("Embed LLVM bitcode in object files produced by LTO"))
Machine Check Debug Module
ModuleSummaryIndex.h This file contains the declarations the classes that hold the module index and s...
void writeThinLinkBitcode(const Module &M, const ModuleSummaryIndex &Index, const ModuleHash &ModHash)
Write the specified thin link bitcode file (i.e., the minimized bitcode file) to the buffer specified...
void copyStrtab(StringRef Strtab)
Copy the string table for another module into this bitcode file.
void writeStrtab()
Write the bitcode file's string table.
void writeSymtab()
Attempt to write a symbol table to the bitcode file.
void writeIndex(const ModuleSummaryIndex *Index, const std::map< std::string, GVSummaryMapTy > *ModuleToSummariesForIndex, const GVSummaryPtrSet *DecSummaries)
void writeModule(const Module &M, bool ShouldPreserveUseListOrder=false, const ModuleSummaryIndex *Index=nullptr, bool GenerateHash=false, ModuleHash *ModHash=nullptr)
Write the specified module to the buffer specified at construction time.
Allocate memory in an ever growing pool, as if by bump-pointer.
Definition: Allocator.h:66
Class to hold module path string table and global value map, and encapsulate methods for operating on...
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:586
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
Utility for building string tables with deduplicated suffixes.
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
void WriteBitcodeToFile(const Module &M, raw_ostream &Out, bool ShouldPreserveUseListOrder=false, const ModuleSummaryIndex *Index=nullptr, bool GenerateHash=false, ModuleHash *ModHash=nullptr)
Write the specified module to the specified raw output stream.
void writeThinLinkBitcodeToFile(const Module &M, raw_ostream &Out, const ModuleSummaryIndex &Index, const ModuleHash &ModHash)
Write the specified thin link bitcode file (i.e., the minimized bitcode file) to the given raw output...
void embedBitcodeInModule(Module &M, MemoryBufferRef Buf, bool EmbedBitcode, bool EmbedCmdline, const std::vector< uint8_t > &CmdArgs)
If EmbedBitcode is set, save a copy of the llvm IR as data in the __LLVM,__bitcode section (....
void writeIndexToFile(const ModuleSummaryIndex &Index, raw_ostream &Out, const std::map< std::string, GVSummaryMapTy > *ModuleToSummariesForIndex=nullptr, const GVSummaryPtrSet *DecSummaries=nullptr)
Write the specified module summary index to the given raw output stream, where it will be written in ...
std::unordered_set< GlobalValueSummary * > GVSummaryPtrSet
A set of global value summary pointers.
std::array< uint32_t, 5 > ModuleHash
160 bits SHA1