Bug Summary

File:src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Bitstream/BitstreamWriter.h
Warning:line 501, column 9
1st function call argument is an uninitialized value

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name BitcodeWriter.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -fhalf-no-semantic-interposition -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/libLLVM/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Analysis -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ASMParser -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/BinaryFormat -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Bitcode -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Bitcode -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Bitstream -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /include/llvm/CodeGen -I /include/llvm/CodeGen/PBQP -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/IR -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/IR -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/Coroutines -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ProfileData/Coverage -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo/CodeView -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo/DWARF -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo/MSF -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo/PDB -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Demangle -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ExecutionEngine -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ExecutionEngine/JITLink -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ExecutionEngine/Orc -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Frontend -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Frontend/OpenACC -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Frontend -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Frontend/OpenMP -I /include/llvm/CodeGen/GlobalISel -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/IRReader -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/InstCombine -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/Transforms/InstCombine -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/LTO -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Linker -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/MC -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/MC/MCParser -I /include/llvm/CodeGen/MIRParser -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Object -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Option -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Passes -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ProfileData -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/Scalar -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ADT -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Support -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo/Symbolize -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Target -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/Utils -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/Vectorize -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/IPO -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/libLLVM/../include -I /usr/src/gnu/usr.bin/clang/libLLVM/obj -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -D PIC -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/libLLVM/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -D_RET_PROTECTOR -ret-protector -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

/usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

→
1//===- Bitcode/Writer/BitcodeWriter.cpp - Bitcode Writer ------------------===//
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// Bitcode writer implementation.
10//
11//===----------------------------------------------------------------------===//
12
13#include "llvm/Bitcode/BitcodeWriter.h"
14#include "ValueEnumerator.h"
15#include "llvm/ADT/APFloat.h"
16#include "llvm/ADT/APInt.h"
17#include "llvm/ADT/ArrayRef.h"
18#include "llvm/ADT/DenseMap.h"
19#include "llvm/ADT/None.h"
20#include "llvm/ADT/Optional.h"
21#include "llvm/ADT/STLExtras.h"
22#include "llvm/ADT/SmallString.h"
23#include "llvm/ADT/SmallVector.h"
24#include "llvm/ADT/StringMap.h"
25#include "llvm/ADT/StringRef.h"
26#include "llvm/ADT/Triple.h"
27#include "llvm/Bitcode/BitcodeCommon.h"
28#include "llvm/Bitcode/BitcodeReader.h"
29#include "llvm/Bitcode/LLVMBitCodes.h"
30#include "llvm/Bitstream/BitCodes.h"
31#include "llvm/Bitstream/BitstreamWriter.h"
32#include "llvm/Config/llvm-config.h"
33#include "llvm/IR/Attributes.h"
34#include "llvm/IR/BasicBlock.h"
35#include "llvm/IR/Comdat.h"
36#include "llvm/IR/Constant.h"
37#include "llvm/IR/Constants.h"
38#include "llvm/IR/DebugInfoMetadata.h"
39#include "llvm/IR/DebugLoc.h"
40#include "llvm/IR/DerivedTypes.h"
41#include "llvm/IR/Function.h"
42#include "llvm/IR/GlobalAlias.h"
43#include "llvm/IR/GlobalIFunc.h"
44#include "llvm/IR/GlobalObject.h"
45#include "llvm/IR/GlobalValue.h"
46#include "llvm/IR/GlobalVariable.h"
47#include "llvm/IR/InlineAsm.h"
48#include "llvm/IR/InstrTypes.h"
49#include "llvm/IR/Instruction.h"
50#include "llvm/IR/Instructions.h"
51#include "llvm/IR/LLVMContext.h"
52#include "llvm/IR/Metadata.h"
53#include "llvm/IR/Module.h"
54#include "llvm/IR/ModuleSummaryIndex.h"
55#include "llvm/IR/Operator.h"
56#include "llvm/IR/Type.h"
57#include "llvm/IR/UseListOrder.h"
58#include "llvm/IR/Value.h"
59#include "llvm/IR/ValueSymbolTable.h"
60#include "llvm/MC/StringTableBuilder.h"
61#include "llvm/Object/IRSymtab.h"
62#include "llvm/Support/AtomicOrdering.h"
63#include "llvm/Support/Casting.h"
64#include "llvm/Support/CommandLine.h"
65#include "llvm/Support/Endian.h"
66#include "llvm/Support/Error.h"
67#include "llvm/Support/ErrorHandling.h"
68#include "llvm/Support/MathExtras.h"
69#include "llvm/Support/SHA1.h"
70#include "llvm/Support/TargetRegistry.h"
71#include "llvm/Support/raw_ostream.h"
72#include <algorithm>
73#include <cassert>
74#include <cstddef>
75#include <cstdint>
76#include <iterator>
77#include <map>
78#include <memory>
79#include <string>
80#include <utility>
81#include <vector>
82
83using namespace llvm;
84
85static cl::opt<unsigned>
86 IndexThreshold("bitcode-mdindex-threshold", cl::Hidden, cl::init(25),
87 cl::desc("Number of metadatas above which we emit an index "
88 "to enable lazy-loading"));
89static cl::opt<uint32_t> FlushThreshold(
90 "bitcode-flush-threshold", cl::Hidden, cl::init(512),
91 cl::desc("The threshold (unit M) for flushing LLVM bitcode."));
92
93static cl::opt<bool> WriteRelBFToSummary(
94 "write-relbf-to-summary", cl::Hidden, cl::init(false),
95 cl::desc("Write relative block frequency to function summary "));
96
97extern FunctionSummary::ForceSummaryHotnessType ForceSummaryEdgesCold;
98
99namespace {
100
101/// These are manifest constants used by the bitcode writer. They do not need to
102/// be kept in sync with the reader, but need to be consistent within this file.
103enum {
104 // VALUE_SYMTAB_BLOCK abbrev id's.
105 VST_ENTRY_8_ABBREV = bitc::FIRST_APPLICATION_ABBREV,
106 VST_ENTRY_7_ABBREV,
107 VST_ENTRY_6_ABBREV,
108 VST_BBENTRY_6_ABBREV,
109
110 // CONSTANTS_BLOCK abbrev id's.
111 CONSTANTS_SETTYPE_ABBREV = bitc::FIRST_APPLICATION_ABBREV,
112 CONSTANTS_INTEGER_ABBREV,
113 CONSTANTS_CE_CAST_Abbrev,
114 CONSTANTS_NULL_Abbrev,
115
116 // FUNCTION_BLOCK abbrev id's.
117 FUNCTION_INST_LOAD_ABBREV = bitc::FIRST_APPLICATION_ABBREV,
118 FUNCTION_INST_UNOP_ABBREV,
119 FUNCTION_INST_UNOP_FLAGS_ABBREV,
120 FUNCTION_INST_BINOP_ABBREV,
121 FUNCTION_INST_BINOP_FLAGS_ABBREV,
122 FUNCTION_INST_CAST_ABBREV,
123 FUNCTION_INST_RET_VOID_ABBREV,
124 FUNCTION_INST_RET_VAL_ABBREV,
125 FUNCTION_INST_UNREACHABLE_ABBREV,
126 FUNCTION_INST_GEP_ABBREV,
127};
128
129/// Abstract class to manage the bitcode writing, subclassed for each bitcode
130/// file type.
131class BitcodeWriterBase {
132protected:
133 /// The stream created and owned by the client.
134 BitstreamWriter &Stream;
135
136 StringTableBuilder &StrtabBuilder;
137
138public:
139 /// Constructs a BitcodeWriterBase object that writes to the provided
140 /// \p Stream.
141 BitcodeWriterBase(BitstreamWriter &Stream, StringTableBuilder &StrtabBuilder)
142 : Stream(Stream), StrtabBuilder(StrtabBuilder) {}
143
144protected:
145 void writeBitcodeHeader();
146 void writeModuleVersion();
147};
148
149void BitcodeWriterBase::writeModuleVersion() {
150 // VERSION: [version#]
151 Stream.EmitRecord(bitc::MODULE_CODE_VERSION, ArrayRef<uint64_t>{2});
152}
153
154/// Base class to manage the module bitcode writing, currently subclassed for
155/// ModuleBitcodeWriter and ThinLinkBitcodeWriter.
156class ModuleBitcodeWriterBase : public BitcodeWriterBase {
157protected:
158 /// The Module to write to bitcode.
159 const Module &M;
160
161 /// Enumerates ids for all values in the module.
162 ValueEnumerator VE;
163
164 /// Optional per-module index to write for ThinLTO.
165 const ModuleSummaryIndex *Index;
166
167 /// Map that holds the correspondence between GUIDs in the summary index,
168 /// that came from indirect call profiles, and a value id generated by this
169 /// class to use in the VST and summary block records.
170 std::map<GlobalValue::GUID, unsigned> GUIDToValueIdMap;
171
172 /// Tracks the last value id recorded in the GUIDToValueMap.
173 unsigned GlobalValueId;
174
175 /// Saves the offset of the VSTOffset record that must eventually be
176 /// backpatched with the offset of the actual VST.
177 uint64_t VSTOffsetPlaceholder = 0;
178
179public:
180 /// Constructs a ModuleBitcodeWriterBase object for the given Module,
181 /// writing to the provided \p Buffer.
182 ModuleBitcodeWriterBase(const Module &M, StringTableBuilder &StrtabBuilder,
183 BitstreamWriter &Stream,
184 bool ShouldPreserveUseListOrder,
185 const ModuleSummaryIndex *Index)
186 : BitcodeWriterBase(Stream, StrtabBuilder), M(M),
187 VE(M, ShouldPreserveUseListOrder), Index(Index) {
188 // Assign ValueIds to any callee values in the index that came from
189 // indirect call profiles and were recorded as a GUID not a Value*
190 // (which would have been assigned an ID by the ValueEnumerator).
191 // The starting ValueId is just after the number of values in the
192 // ValueEnumerator, so that they can be emitted in the VST.
193 GlobalValueId = VE.getValues().size();
194 if (!Index)
195 return;
196 for (const auto &GUIDSummaryLists : *Index)
197 // Examine all summaries for this GUID.
198 for (auto &Summary : GUIDSummaryLists.second.SummaryList)
199 if (auto FS = dyn_cast<FunctionSummary>(Summary.get()))
200 // For each call in the function summary, see if the call
201 // is to a GUID (which means it is for an indirect call,
202 // otherwise we would have a Value for it). If so, synthesize
203 // a value id.
204 for (auto &CallEdge : FS->calls())
205 if (!CallEdge.first.haveGVs() || !CallEdge.first.getValue())
206 assignValueId(CallEdge.first.getGUID());
207 }
208
209protected:
210 void writePerModuleGlobalValueSummary();
211
212private:
213 void writePerModuleFunctionSummaryRecord(SmallVector<uint64_t, 64> &NameVals,
214 GlobalValueSummary *Summary,
215 unsigned ValueID,
216 unsigned FSCallsAbbrev,
217 unsigned FSCallsProfileAbbrev,
218 const Function &F);
219 void writeModuleLevelReferences(const GlobalVariable &V,
220 SmallVector<uint64_t, 64> &NameVals,
221 unsigned FSModRefsAbbrev,
222 unsigned FSModVTableRefsAbbrev);
223
224 void assignValueId(GlobalValue::GUID ValGUID) {
225 GUIDToValueIdMap[ValGUID] = ++GlobalValueId;
226 }
227
228 unsigned getValueId(GlobalValue::GUID ValGUID) {
229 const auto &VMI = GUIDToValueIdMap.find(ValGUID);
230 // Expect that any GUID value had a value Id assigned by an
231 // earlier call to assignValueId.
232 assert(VMI != GUIDToValueIdMap.end() &&((void)0)
233 "GUID does not have assigned value Id")((void)0);
234 return VMI->second;
235 }
236
237 // Helper to get the valueId for the type of value recorded in VI.
238 unsigned getValueId(ValueInfo VI) {
239 if (!VI.haveGVs() || !VI.getValue())
240 return getValueId(VI.getGUID());
241 return VE.getValueID(VI.getValue());
242 }
243
244 std::map<GlobalValue::GUID, unsigned> &valueIds() { return GUIDToValueIdMap; }
245};
246
247/// Class to manage the bitcode writing for a module.
248class ModuleBitcodeWriter : public ModuleBitcodeWriterBase {
249 /// Pointer to the buffer allocated by caller for bitcode writing.
250 const SmallVectorImpl<char> &Buffer;
251
252 /// True if a module hash record should be written.
253 bool GenerateHash;
254
255 /// If non-null, when GenerateHash is true, the resulting hash is written
256 /// into ModHash.
257 ModuleHash *ModHash;
258
259 SHA1 Hasher;
260
261 /// The start bit of the identification block.
262 uint64_t BitcodeStartBit;
263
264public:
265 /// Constructs a ModuleBitcodeWriter object for the given Module,
266 /// writing to the provided \p Buffer.
267 ModuleBitcodeWriter(const Module &M, SmallVectorImpl<char> &Buffer,
268 StringTableBuilder &StrtabBuilder,
269 BitstreamWriter &Stream, bool ShouldPreserveUseListOrder,
270 const ModuleSummaryIndex *Index, bool GenerateHash,
271 ModuleHash *ModHash = nullptr)
272 : ModuleBitcodeWriterBase(M, StrtabBuilder, Stream,
273 ShouldPreserveUseListOrder, Index),
274 Buffer(Buffer), GenerateHash(GenerateHash), ModHash(ModHash),
275 BitcodeStartBit(Stream.GetCurrentBitNo()) {}
276
277 /// Emit the current module to the bitstream.
278 void write();
279
280private:
281 uint64_t bitcodeStartBit() { return BitcodeStartBit; }
282
283 size_t addToStrtab(StringRef Str);
284
285 void writeAttributeGroupTable();
286 void writeAttributeTable();
287 void writeTypeTable();
288 void writeComdats();
289 void writeValueSymbolTableForwardDecl();
290 void writeModuleInfo();
291 void writeValueAsMetadata(const ValueAsMetadata *MD,
292 SmallVectorImpl<uint64_t> &Record);
293 void writeMDTuple(const MDTuple *N, SmallVectorImpl<uint64_t> &Record,
294 unsigned Abbrev);
295 unsigned createDILocationAbbrev();
296 void writeDILocation(const DILocation *N, SmallVectorImpl<uint64_t> &Record,
297 unsigned &Abbrev);
298 unsigned createGenericDINodeAbbrev();
299 void writeGenericDINode(const GenericDINode *N,
300 SmallVectorImpl<uint64_t> &Record, unsigned &Abbrev);
301 void writeDISubrange(const DISubrange *N, SmallVectorImpl<uint64_t> &Record,
302 unsigned Abbrev);
303 void writeDIGenericSubrange(const DIGenericSubrange *N,
304 SmallVectorImpl<uint64_t> &Record,
305 unsigned Abbrev);
306 void writeDIEnumerator(const DIEnumerator *N,
307 SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);
308 void writeDIBasicType(const DIBasicType *N, SmallVectorImpl<uint64_t> &Record,
309 unsigned Abbrev);
310 void writeDIStringType(const DIStringType *N,
311 SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);
312 void writeDIDerivedType(const DIDerivedType *N,
313 SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);
314 void writeDICompositeType(const DICompositeType *N,
315 SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);
316 void writeDISubroutineType(const DISubroutineType *N,
317 SmallVectorImpl<uint64_t> &Record,
318 unsigned Abbrev);
319 void writeDIFile(const DIFile *N, SmallVectorImpl<uint64_t> &Record,
320 unsigned Abbrev);
321 void writeDICompileUnit(const DICompileUnit *N,
322 SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);
323 void writeDISubprogram(const DISubprogram *N,
324 SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);
325 void writeDILexicalBlock(const DILexicalBlock *N,
326 SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);
327 void writeDILexicalBlockFile(const DILexicalBlockFile *N,
328 SmallVectorImpl<uint64_t> &Record,
329 unsigned Abbrev);
330 void writeDICommonBlock(const DICommonBlock *N,
331 SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);
332 void writeDINamespace(const DINamespace *N, SmallVectorImpl<uint64_t> &Record,
333 unsigned Abbrev);
334 void writeDIMacro(const DIMacro *N, SmallVectorImpl<uint64_t> &Record,
335 unsigned Abbrev);
336 void writeDIMacroFile(const DIMacroFile *N, SmallVectorImpl<uint64_t> &Record,
337 unsigned Abbrev);
338 void writeDIArgList(const DIArgList *N, SmallVectorImpl<uint64_t> &Record,
339 unsigned Abbrev);
340 void writeDIModule(const DIModule *N, SmallVectorImpl<uint64_t> &Record,
341 unsigned Abbrev);
342 void writeDITemplateTypeParameter(const DITemplateTypeParameter *N,
343 SmallVectorImpl<uint64_t> &Record,
344 unsigned Abbrev);
345 void writeDITemplateValueParameter(const DITemplateValueParameter *N,
346 SmallVectorImpl<uint64_t> &Record,
347 unsigned Abbrev);
348 void writeDIGlobalVariable(const DIGlobalVariable *N,
349 SmallVectorImpl<uint64_t> &Record,
350 unsigned Abbrev);
351 void writeDILocalVariable(const DILocalVariable *N,
352 SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);
353 void writeDILabel(const DILabel *N,
354 SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);
355 void writeDIExpression(const DIExpression *N,
356 SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);
357 void writeDIGlobalVariableExpression(const DIGlobalVariableExpression *N,
358 SmallVectorImpl<uint64_t> &Record,
359 unsigned Abbrev);
360 void writeDIObjCProperty(const DIObjCProperty *N,
361 SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);
362 void writeDIImportedEntity(const DIImportedEntity *N,
363 SmallVectorImpl<uint64_t> &Record,
364 unsigned Abbrev);
365 unsigned createNamedMetadataAbbrev();
366 void writeNamedMetadata(SmallVectorImpl<uint64_t> &Record);
367 unsigned createMetadataStringsAbbrev();
368 void writeMetadataStrings(ArrayRef<const Metadata *> Strings,
369 SmallVectorImpl<uint64_t> &Record);
370 void writeMetadataRecords(ArrayRef<const Metadata *> MDs,
371 SmallVectorImpl<uint64_t> &Record,
372 std::vector<unsigned> *MDAbbrevs = nullptr,
373 std::vector<uint64_t> *IndexPos = nullptr);
374 void writeModuleMetadata();
375 void writeFunctionMetadata(const Function &F);
376 void writeFunctionMetadataAttachment(const Function &F);
377 void writeGlobalVariableMetadataAttachment(const GlobalVariable &GV);
378 void pushGlobalMetadataAttachment(SmallVectorImpl<uint64_t> &Record,
379 const GlobalObject &GO);
380 void writeModuleMetadataKinds();
381 void writeOperandBundleTags();
382 void writeSyncScopeNames();
383 void writeConstants(unsigned FirstVal, unsigned LastVal, bool isGlobal);
384 void writeModuleConstants();
385 bool pushValueAndType(const Value *V, unsigned InstID,
386 SmallVectorImpl<unsigned> &Vals);
387 void writeOperandBundles(const CallBase &CB, unsigned InstID);
388 void pushValue(const Value *V, unsigned InstID,
389 SmallVectorImpl<unsigned> &Vals);
390 void pushValueSigned(const Value *V, unsigned InstID,
391 SmallVectorImpl<uint64_t> &Vals);
392 void writeInstruction(const Instruction &I, unsigned InstID,
393 SmallVectorImpl<unsigned> &Vals);
394 void writeFunctionLevelValueSymbolTable(const ValueSymbolTable &VST);
395 void writeGlobalValueSymbolTable(
396 DenseMap<const Function *, uint64_t> &FunctionToBitcodeIndex);
397 void writeUseList(UseListOrder &&Order);
398 void writeUseListBlock(const Function *F);
399 void
400 writeFunction(const Function &F,
401 DenseMap<const Function *, uint64_t> &FunctionToBitcodeIndex);
402 void writeBlockInfo();
403 void writeModuleHash(size_t BlockStartPos);
404
405 unsigned getEncodedSyncScopeID(SyncScope::ID SSID) {
406 return unsigned(SSID);
407 }
408
409 unsigned getEncodedAlign(MaybeAlign Alignment) { return encode(Alignment); }
410};
411
412/// Class to manage the bitcode writing for a combined index.
413class IndexBitcodeWriter : public BitcodeWriterBase {
414 /// The combined index to write to bitcode.
415 const ModuleSummaryIndex &Index;
416
417 /// When writing a subset of the index for distributed backends, client
418 /// provides a map of modules to the corresponding GUIDs/summaries to write.
419 const std::map<std::string, GVSummaryMapTy> *ModuleToSummariesForIndex;
420
421 /// Map that holds the correspondence between the GUID used in the combined
422 /// index and a value id generated by this class to use in references.
423 std::map<GlobalValue::GUID, unsigned> GUIDToValueIdMap;
424
425 /// Tracks the last value id recorded in the GUIDToValueMap.
426 unsigned GlobalValueId = 0;
427
428public:
429 /// Constructs a IndexBitcodeWriter object for the given combined index,
430 /// writing to the provided \p Buffer. When writing a subset of the index
431 /// for a distributed backend, provide a \p ModuleToSummariesForIndex map.
432 IndexBitcodeWriter(BitstreamWriter &Stream, StringTableBuilder &StrtabBuilder,
433 const ModuleSummaryIndex &Index,
434 const std::map<std::string, GVSummaryMapTy>
435 *ModuleToSummariesForIndex = nullptr)
436 : BitcodeWriterBase(Stream, StrtabBuilder), Index(Index),
437 ModuleToSummariesForIndex(ModuleToSummariesForIndex) {
438 // Assign unique value ids to all summaries to be written, for use
439 // in writing out the call graph edges. Save the mapping from GUID
440 // to the new global value id to use when writing those edges, which
441 // are currently saved in the index in terms of GUID.
442 forEachSummary([&](GVInfo I, bool) {
443 GUIDToValueIdMap[I.first] = ++GlobalValueId;
444 });
445 }
446
447 /// The below iterator returns the GUID and associated summary.
448 using GVInfo = std::pair<GlobalValue::GUID, GlobalValueSummary *>;
449
450 /// Calls the callback for each value GUID and summary to be written to
451 /// bitcode. This hides the details of whether they are being pulled from the
452 /// entire index or just those in a provided ModuleToSummariesForIndex map.
453 template<typename Functor>
454 void forEachSummary(Functor Callback) {
455 if (ModuleToSummariesForIndex) {
456 for (auto &M : *ModuleToSummariesForIndex)
457 for (auto &Summary : M.second) {
458 Callback(Summary, false);
459 // Ensure aliasee is handled, e.g. for assigning a valueId,
460 // even if we are not importing the aliasee directly (the
461 // imported alias will contain a copy of aliasee).
462 if (auto *AS = dyn_cast<AliasSummary>(Summary.getSecond()))
463 Callback({AS->getAliaseeGUID(), &AS->getAliasee()}, true);
464 }
465 } else {
466 for (auto &Summaries : Index)
467 for (auto &Summary : Summaries.second.SummaryList)
468 Callback({Summaries.first, Summary.get()}, false);
469 }
470 }
471
472 /// Calls the callback for each entry in the modulePaths StringMap that
473 /// should be written to the module path string table. This hides the details
474 /// of whether they are being pulled from the entire index or just those in a
475 /// provided ModuleToSummariesForIndex map.
476 template <typename Functor> void forEachModule(Functor Callback) {
477 if (ModuleToSummariesForIndex) {
478 for (const auto &M : *ModuleToSummariesForIndex) {
479 const auto &MPI = Index.modulePaths().find(M.first);
480 if (MPI == Index.modulePaths().end()) {
481 // This should only happen if the bitcode file was empty, in which
482 // case we shouldn't be importing (the ModuleToSummariesForIndex
483 // would only include the module we are writing and index for).
484 assert(ModuleToSummariesForIndex->size() == 1)((void)0);
485 continue;
486 }
487 Callback(*MPI);
488 }
489 } else {
490 for (const auto &MPSE : Index.modulePaths())
491 Callback(MPSE);
492 }
493 }
494
495 /// Main entry point for writing a combined index to bitcode.
496 void write();
497
498private:
499 void writeModStrings();
500 void writeCombinedGlobalValueSummary();
501
502 Optional<unsigned> getValueId(GlobalValue::GUID ValGUID) {
503 auto VMI = GUIDToValueIdMap.find(ValGUID);
504 if (VMI == GUIDToValueIdMap.end())
505 return None;
506 return VMI->second;
507 }
508
509 std::map<GlobalValue::GUID, unsigned> &valueIds() { return GUIDToValueIdMap; }
510};
511
512} // end anonymous namespace
513
514static unsigned getEncodedCastOpcode(unsigned Opcode) {
515 switch (Opcode) {
516 default: llvm_unreachable("Unknown cast instruction!")__builtin_unreachable();
517 case Instruction::Trunc : return bitc::CAST_TRUNC;
518 case Instruction::ZExt : return bitc::CAST_ZEXT;
519 case Instruction::SExt : return bitc::CAST_SEXT;
520 case Instruction::FPToUI : return bitc::CAST_FPTOUI;
521 case Instruction::FPToSI : return bitc::CAST_FPTOSI;
522 case Instruction::UIToFP : return bitc::CAST_UITOFP;
523 case Instruction::SIToFP : return bitc::CAST_SITOFP;
524 case Instruction::FPTrunc : return bitc::CAST_FPTRUNC;
525 case Instruction::FPExt : return bitc::CAST_FPEXT;
526 case Instruction::PtrToInt: return bitc::CAST_PTRTOINT;
527 case Instruction::IntToPtr: return bitc::CAST_INTTOPTR;
528 case Instruction::BitCast : return bitc::CAST_BITCAST;
529 case Instruction::AddrSpaceCast: return bitc::CAST_ADDRSPACECAST;
530 }
531}
532
533static unsigned getEncodedUnaryOpcode(unsigned Opcode) {
534 switch (Opcode) {
535 default: llvm_unreachable("Unknown binary instruction!")__builtin_unreachable();
536 case Instruction::FNeg: return bitc::UNOP_FNEG;
537 }
538}
539
540static unsigned getEncodedBinaryOpcode(unsigned Opcode) {
541 switch (Opcode) {
542 default: llvm_unreachable("Unknown binary instruction!")__builtin_unreachable();
543 case Instruction::Add:
544 case Instruction::FAdd: return bitc::BINOP_ADD;
545 case Instruction::Sub:
546 case Instruction::FSub: return bitc::BINOP_SUB;
547 case Instruction::Mul:
548 case Instruction::FMul: return bitc::BINOP_MUL;
549 case Instruction::UDiv: return bitc::BINOP_UDIV;
550 case Instruction::FDiv:
551 case Instruction::SDiv: return bitc::BINOP_SDIV;
552 case Instruction::URem: return bitc::BINOP_UREM;
553 case Instruction::FRem:
554 case Instruction::SRem: return bitc::BINOP_SREM;
555 case Instruction::Shl: return bitc::BINOP_SHL;
556 case Instruction::LShr: return bitc::BINOP_LSHR;
557 case Instruction::AShr: return bitc::BINOP_ASHR;
558 case Instruction::And: return bitc::BINOP_AND;
559 case Instruction::Or: return bitc::BINOP_OR;
560 case Instruction::Xor: return bitc::BINOP_XOR;
561 }
562}
563
564static unsigned getEncodedRMWOperation(AtomicRMWInst::BinOp Op) {
565 switch (Op) {
566 default: llvm_unreachable("Unknown RMW operation!")__builtin_unreachable();
567 case AtomicRMWInst::Xchg: return bitc::RMW_XCHG;
568 case AtomicRMWInst::Add: return bitc::RMW_ADD;
569 case AtomicRMWInst::Sub: return bitc::RMW_SUB;
570 case AtomicRMWInst::And: return bitc::RMW_AND;
571 case AtomicRMWInst::Nand: return bitc::RMW_NAND;
572 case AtomicRMWInst::Or: return bitc::RMW_OR;
573 case AtomicRMWInst::Xor: return bitc::RMW_XOR;
574 case AtomicRMWInst::Max: return bitc::RMW_MAX;
575 case AtomicRMWInst::Min: return bitc::RMW_MIN;
576 case AtomicRMWInst::UMax: return bitc::RMW_UMAX;
577 case AtomicRMWInst::UMin: return bitc::RMW_UMIN;
578 case AtomicRMWInst::FAdd: return bitc::RMW_FADD;
579 case AtomicRMWInst::FSub: return bitc::RMW_FSUB;
580 }
581}
582
583static unsigned getEncodedOrdering(AtomicOrdering Ordering) {
584 switch (Ordering) {
585 case AtomicOrdering::NotAtomic: return bitc::ORDERING_NOTATOMIC;
586 case AtomicOrdering::Unordered: return bitc::ORDERING_UNORDERED;
587 case AtomicOrdering::Monotonic: return bitc::ORDERING_MONOTONIC;
588 case AtomicOrdering::Acquire: return bitc::ORDERING_ACQUIRE;
589 case AtomicOrdering::Release: return bitc::ORDERING_RELEASE;
590 case AtomicOrdering::AcquireRelease: return bitc::ORDERING_ACQREL;
591 case AtomicOrdering::SequentiallyConsistent: return bitc::ORDERING_SEQCST;
592 }
593 llvm_unreachable("Invalid ordering")__builtin_unreachable();
594}
595
596static void writeStringRecord(BitstreamWriter &Stream, unsigned Code,
597 StringRef Str, unsigned AbbrevToUse) {
598 SmallVector<unsigned, 64> Vals;
599
600 // Code: [strchar x N]
601 for (unsigned i = 0, e = Str.size(); i != e; ++i) {
602 if (AbbrevToUse && !BitCodeAbbrevOp::isChar6(Str[i]))
603 AbbrevToUse = 0;
604 Vals.push_back(Str[i]);
605 }
606
607 // Emit the finished record.
608 Stream.EmitRecord(Code, Vals, AbbrevToUse);
609}
610
611static uint64_t getAttrKindEncoding(Attribute::AttrKind Kind) {
612 switch (Kind) {
613 case Attribute::Alignment:
614 return bitc::ATTR_KIND_ALIGNMENT;
615 case Attribute::AllocSize:
616 return bitc::ATTR_KIND_ALLOC_SIZE;
617 case Attribute::AlwaysInline:
618 return bitc::ATTR_KIND_ALWAYS_INLINE;
619 case Attribute::ArgMemOnly:
620 return bitc::ATTR_KIND_ARGMEMONLY;
621 case Attribute::Builtin:
622 return bitc::ATTR_KIND_BUILTIN;
623 case Attribute::ByVal:
624 return bitc::ATTR_KIND_BY_VAL;
625 case Attribute::Convergent:
626 return bitc::ATTR_KIND_CONVERGENT;
627 case Attribute::InAlloca:
628 return bitc::ATTR_KIND_IN_ALLOCA;
629 case Attribute::Cold:
630 return bitc::ATTR_KIND_COLD;
631 case Attribute::Hot:
632 return bitc::ATTR_KIND_HOT;
633 case Attribute::ElementType:
634 return bitc::ATTR_KIND_ELEMENTTYPE;
635 case Attribute::InaccessibleMemOnly:
636 return bitc::ATTR_KIND_INACCESSIBLEMEM_ONLY;
637 case Attribute::InaccessibleMemOrArgMemOnly:
638 return bitc::ATTR_KIND_INACCESSIBLEMEM_OR_ARGMEMONLY;
639 case Attribute::InlineHint:
640 return bitc::ATTR_KIND_INLINE_HINT;
641 case Attribute::InReg:
642 return bitc::ATTR_KIND_IN_REG;
643 case Attribute::JumpTable:
644 return bitc::ATTR_KIND_JUMP_TABLE;
645 case Attribute::MinSize:
646 return bitc::ATTR_KIND_MIN_SIZE;
647 case Attribute::Naked:
648 return bitc::ATTR_KIND_NAKED;
649 case Attribute::Nest:
650 return bitc::ATTR_KIND_NEST;
651 case Attribute::NoAlias:
652 return bitc::ATTR_KIND_NO_ALIAS;
653 case Attribute::NoBuiltin:
654 return bitc::ATTR_KIND_NO_BUILTIN;
655 case Attribute::NoCallback:
656 return bitc::ATTR_KIND_NO_CALLBACK;
657 case Attribute::NoCapture:
658 return bitc::ATTR_KIND_NO_CAPTURE;
659 case Attribute::NoDuplicate:
660 return bitc::ATTR_KIND_NO_DUPLICATE;
661 case Attribute::NoFree:
662 return bitc::ATTR_KIND_NOFREE;
663 case Attribute::NoImplicitFloat:
664 return bitc::ATTR_KIND_NO_IMPLICIT_FLOAT;
665 case Attribute::NoInline:
666 return bitc::ATTR_KIND_NO_INLINE;
667 case Attribute::NoRecurse:
668 return bitc::ATTR_KIND_NO_RECURSE;
669 case Attribute::NoMerge:
670 return bitc::ATTR_KIND_NO_MERGE;
671 case Attribute::NonLazyBind:
672 return bitc::ATTR_KIND_NON_LAZY_BIND;
673 case Attribute::NonNull:
674 return bitc::ATTR_KIND_NON_NULL;
675 case Attribute::Dereferenceable:
676 return bitc::ATTR_KIND_DEREFERENCEABLE;
677 case Attribute::DereferenceableOrNull:
678 return bitc::ATTR_KIND_DEREFERENCEABLE_OR_NULL;
679 case Attribute::NoRedZone:
680 return bitc::ATTR_KIND_NO_RED_ZONE;
681 case Attribute::NoReturn:
682 return bitc::ATTR_KIND_NO_RETURN;
683 case Attribute::NoSync:
684 return bitc::ATTR_KIND_NOSYNC;
685 case Attribute::NoCfCheck:
686 return bitc::ATTR_KIND_NOCF_CHECK;
687 case Attribute::NoProfile:
688 return bitc::ATTR_KIND_NO_PROFILE;
689 case Attribute::NoUnwind:
690 return bitc::ATTR_KIND_NO_UNWIND;
691 case Attribute::NoSanitizeCoverage:
692 return bitc::ATTR_KIND_NO_SANITIZE_COVERAGE;
693 case Attribute::NullPointerIsValid:
694 return bitc::ATTR_KIND_NULL_POINTER_IS_VALID;
695 case Attribute::OptForFuzzing:
696 return bitc::ATTR_KIND_OPT_FOR_FUZZING;
697 case Attribute::OptimizeForSize:
698 return bitc::ATTR_KIND_OPTIMIZE_FOR_SIZE;
699 case Attribute::OptimizeNone:
700 return bitc::ATTR_KIND_OPTIMIZE_NONE;
701 case Attribute::ReadNone:
702 return bitc::ATTR_KIND_READ_NONE;
703 case Attribute::ReadOnly:
704 return bitc::ATTR_KIND_READ_ONLY;
705 case Attribute::Returned:
706 return bitc::ATTR_KIND_RETURNED;
707 case Attribute::ReturnsTwice:
708 return bitc::ATTR_KIND_RETURNS_TWICE;
709 case Attribute::SExt:
710 return bitc::ATTR_KIND_S_EXT;
711 case Attribute::Speculatable:
712 return bitc::ATTR_KIND_SPECULATABLE;
713 case Attribute::StackAlignment:
714 return bitc::ATTR_KIND_STACK_ALIGNMENT;
715 case Attribute::StackProtect:
716 return bitc::ATTR_KIND_STACK_PROTECT;
717 case Attribute::StackProtectReq:
718 return bitc::ATTR_KIND_STACK_PROTECT_REQ;
719 case Attribute::StackProtectStrong:
720 return bitc::ATTR_KIND_STACK_PROTECT_STRONG;
721 case Attribute::SafeStack:
722 return bitc::ATTR_KIND_SAFESTACK;
723 case Attribute::ShadowCallStack:
724 return bitc::ATTR_KIND_SHADOWCALLSTACK;
725 case Attribute::StrictFP:
726 return bitc::ATTR_KIND_STRICT_FP;
727 case Attribute::StructRet:
728 return bitc::ATTR_KIND_STRUCT_RET;
729 case Attribute::SanitizeAddress:
730 return bitc::ATTR_KIND_SANITIZE_ADDRESS;
731 case Attribute::SanitizeHWAddress:
732 return bitc::ATTR_KIND_SANITIZE_HWADDRESS;
733 case Attribute::SanitizeThread:
734 return bitc::ATTR_KIND_SANITIZE_THREAD;
735 case Attribute::SanitizeMemory:
736 return bitc::ATTR_KIND_SANITIZE_MEMORY;
737 case Attribute::SpeculativeLoadHardening:
738 return bitc::ATTR_KIND_SPECULATIVE_LOAD_HARDENING;
739 case Attribute::SwiftError:
740 return bitc::ATTR_KIND_SWIFT_ERROR;
741 case Attribute::SwiftSelf:
742 return bitc::ATTR_KIND_SWIFT_SELF;
743 case Attribute::SwiftAsync:
744 return bitc::ATTR_KIND_SWIFT_ASYNC;
745 case Attribute::UWTable:
746 return bitc::ATTR_KIND_UW_TABLE;
747 case Attribute::VScaleRange:
748 return bitc::ATTR_KIND_VSCALE_RANGE;
749 case Attribute::WillReturn:
750 return bitc::ATTR_KIND_WILLRETURN;
751 case Attribute::WriteOnly:
752 return bitc::ATTR_KIND_WRITEONLY;
753 case Attribute::ZExt:
754 return bitc::ATTR_KIND_Z_EXT;
755 case Attribute::ImmArg:
756 return bitc::ATTR_KIND_IMMARG;
757 case Attribute::SanitizeMemTag:
758 return bitc::ATTR_KIND_SANITIZE_MEMTAG;
759 case Attribute::Preallocated:
760 return bitc::ATTR_KIND_PREALLOCATED;
761 case Attribute::NoUndef:
762 return bitc::ATTR_KIND_NOUNDEF;
763 case Attribute::ByRef:
764 return bitc::ATTR_KIND_BYREF;
765 case Attribute::MustProgress:
766 return bitc::ATTR_KIND_MUSTPROGRESS;
767 case Attribute::EndAttrKinds:
768 llvm_unreachable("Can not encode end-attribute kinds marker.")__builtin_unreachable();
769 case Attribute::None:
770 llvm_unreachable("Can not encode none-attribute.")__builtin_unreachable();
771 case Attribute::EmptyKey:
772 case Attribute::TombstoneKey:
773 llvm_unreachable("Trying to encode EmptyKey/TombstoneKey")__builtin_unreachable();
774 }
775
776 llvm_unreachable("Trying to encode unknown attribute")__builtin_unreachable();
777}
778
779void ModuleBitcodeWriter::writeAttributeGroupTable() {
780 const std::vector<ValueEnumerator::IndexAndAttrSet> &AttrGrps =
781 VE.getAttributeGroups();
782 if (AttrGrps.empty()) return;
783
784 Stream.EnterSubblock(bitc::PARAMATTR_GROUP_BLOCK_ID, 3);
785
786 SmallVector<uint64_t, 64> Record;
787 for (ValueEnumerator::IndexAndAttrSet Pair : AttrGrps) {
788 unsigned AttrListIndex = Pair.first;
789 AttributeSet AS = Pair.second;
790 Record.push_back(VE.getAttributeGroupID(Pair));
791 Record.push_back(AttrListIndex);
792
793 for (Attribute Attr : AS) {
794 if (Attr.isEnumAttribute()) {
795 Record.push_back(0);
796 Record.push_back(getAttrKindEncoding(Attr.getKindAsEnum()));
797 } else if (Attr.isIntAttribute()) {
798 Record.push_back(1);
799 Record.push_back(getAttrKindEncoding(Attr.getKindAsEnum()));
800 Record.push_back(Attr.getValueAsInt());
801 } else if (Attr.isStringAttribute()) {
802 StringRef Kind = Attr.getKindAsString();
803 StringRef Val = Attr.getValueAsString();
804
805 Record.push_back(Val.empty() ? 3 : 4);
806 Record.append(Kind.begin(), Kind.end());
807 Record.push_back(0);
808 if (!Val.empty()) {
809 Record.append(Val.begin(), Val.end());
810 Record.push_back(0);
811 }
812 } else {
813 assert(Attr.isTypeAttribute())((void)0);
814 Type *Ty = Attr.getValueAsType();
815 Record.push_back(Ty ? 6 : 5);
816 Record.push_back(getAttrKindEncoding(Attr.getKindAsEnum()));
817 if (Ty)
818 Record.push_back(VE.getTypeID(Attr.getValueAsType()));
819 }
820 }
821
822 Stream.EmitRecord(bitc::PARAMATTR_GRP_CODE_ENTRY, Record);
823 Record.clear();
824 }
825
826 Stream.ExitBlock();
827}
828
829void ModuleBitcodeWriter::writeAttributeTable() {
830 const std::vector<AttributeList> &Attrs = VE.getAttributeLists();
831 if (Attrs.empty()) return;
832
833 Stream.EnterSubblock(bitc::PARAMATTR_BLOCK_ID, 3);
834
835 SmallVector<uint64_t, 64> Record;
836 for (unsigned i = 0, e = Attrs.size(); i != e; ++i) {
837 AttributeList AL = Attrs[i];
838 for (unsigned i = AL.index_begin(), e = AL.index_end(); i != e; ++i) {
839 AttributeSet AS = AL.getAttributes(i);
840 if (AS.hasAttributes())
841 Record.push_back(VE.getAttributeGroupID({i, AS}));
842 }
843
844 Stream.EmitRecord(bitc::PARAMATTR_CODE_ENTRY, Record);
845 Record.clear();
846 }
847
848 Stream.ExitBlock();
849}
850
851/// WriteTypeTable - Write out the type table for a module.
852void ModuleBitcodeWriter::writeTypeTable() {
853 const ValueEnumerator::TypeList &TypeList = VE.getTypes();
854
855 Stream.EnterSubblock(bitc::TYPE_BLOCK_ID_NEW, 4 /*count from # abbrevs */);
856 SmallVector<uint64_t, 64> TypeVals;
857
858 uint64_t NumBits = VE.computeBitsRequiredForTypeIndicies();
859
860 // Abbrev for TYPE_CODE_POINTER.
861 auto Abbv = std::make_shared<BitCodeAbbrev>();
862 Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_POINTER));
863 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, NumBits));
864 Abbv->Add(BitCodeAbbrevOp(0)); // Addrspace = 0
865 unsigned PtrAbbrev = Stream.EmitAbbrev(std::move(Abbv));
866
867 // Abbrev for TYPE_CODE_OPAQUE_POINTER.
868 Abbv = std::make_shared<BitCodeAbbrev>();
869 Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_OPAQUE_POINTER));
870 Abbv->Add(BitCodeAbbrevOp(0)); // Addrspace = 0
871 unsigned OpaquePtrAbbrev = Stream.EmitAbbrev(std::move(Abbv));
872
873 // Abbrev for TYPE_CODE_FUNCTION.
874 Abbv = std::make_shared<BitCodeAbbrev>();
875 Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_FUNCTION));
876 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isvararg
877 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
878 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, NumBits));
879 unsigned FunctionAbbrev = Stream.EmitAbbrev(std::move(Abbv));
880
881 // Abbrev for TYPE_CODE_STRUCT_ANON.
882 Abbv = std::make_shared<BitCodeAbbrev>();
883 Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_STRUCT_ANON));
884 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ispacked
885 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
886 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, NumBits));
887 unsigned StructAnonAbbrev = Stream.EmitAbbrev(std::move(Abbv));
888
889 // Abbrev for TYPE_CODE_STRUCT_NAME.
890 Abbv = std::make_shared<BitCodeAbbrev>();
891 Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_STRUCT_NAME));
892 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
893 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6));
894 unsigned StructNameAbbrev = Stream.EmitAbbrev(std::move(Abbv));
895
896 // Abbrev for TYPE_CODE_STRUCT_NAMED.
897 Abbv = std::make_shared<BitCodeAbbrev>();
898 Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_STRUCT_NAMED));
899 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ispacked
900 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
901 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, NumBits));
902 unsigned StructNamedAbbrev = Stream.EmitAbbrev(std::move(Abbv));
903
904 // Abbrev for TYPE_CODE_ARRAY.
905 Abbv = std::make_shared<BitCodeAbbrev>();
906 Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_ARRAY));
907 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // size
908 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, NumBits));
909 unsigned ArrayAbbrev = Stream.EmitAbbrev(std::move(Abbv));
910
911 // Emit an entry count so the reader can reserve space.
912 TypeVals.push_back(TypeList.size());
913 Stream.EmitRecord(bitc::TYPE_CODE_NUMENTRY, TypeVals);
914 TypeVals.clear();
915
916 // Loop over all of the types, emitting each in turn.
917 for (unsigned i = 0, e = TypeList.size(); i != e; ++i) {
918 Type *T = TypeList[i];
919 int AbbrevToUse = 0;
920 unsigned Code = 0;
921
922 switch (T->getTypeID()) {
923 case Type::VoidTyID: Code = bitc::TYPE_CODE_VOID; break;
924 case Type::HalfTyID: Code = bitc::TYPE_CODE_HALF; break;
925 case Type::BFloatTyID: Code = bitc::TYPE_CODE_BFLOAT; break;
926 case Type::FloatTyID: Code = bitc::TYPE_CODE_FLOAT; break;
927 case Type::DoubleTyID: Code = bitc::TYPE_CODE_DOUBLE; break;
928 case Type::X86_FP80TyID: Code = bitc::TYPE_CODE_X86_FP80; break;
929 case Type::FP128TyID: Code = bitc::TYPE_CODE_FP128; break;
930 case Type::PPC_FP128TyID: Code = bitc::TYPE_CODE_PPC_FP128; break;
931 case Type::LabelTyID: Code = bitc::TYPE_CODE_LABEL; break;
932 case Type::MetadataTyID: Code = bitc::TYPE_CODE_METADATA; break;
933 case Type::X86_MMXTyID: Code = bitc::TYPE_CODE_X86_MMX; break;
934 case Type::X86_AMXTyID: Code = bitc::TYPE_CODE_X86_AMX; break;
935 case Type::TokenTyID: Code = bitc::TYPE_CODE_TOKEN; break;
936 case Type::IntegerTyID:
937 // INTEGER: [width]
938 Code = bitc::TYPE_CODE_INTEGER;
939 TypeVals.push_back(cast<IntegerType>(T)->getBitWidth());
940 break;
941 case Type::PointerTyID: {
942 PointerType *PTy = cast<PointerType>(T);
943 unsigned AddressSpace = PTy->getAddressSpace();
944 if (PTy->isOpaque()) {
945 // OPAQUE_POINTER: [address space]
946 Code = bitc::TYPE_CODE_OPAQUE_POINTER;
947 TypeVals.push_back(AddressSpace);
948 if (AddressSpace == 0)
949 AbbrevToUse = OpaquePtrAbbrev;
950 } else {
951 // POINTER: [pointee type, address space]
952 Code = bitc::TYPE_CODE_POINTER;
953 TypeVals.push_back(VE.getTypeID(PTy->getElementType()));
954 TypeVals.push_back(AddressSpace);
955 if (AddressSpace == 0)
956 AbbrevToUse = PtrAbbrev;
957 }
958 break;
959 }
960 case Type::FunctionTyID: {
961 FunctionType *FT = cast<FunctionType>(T);
962 // FUNCTION: [isvararg, retty, paramty x N]
963 Code = bitc::TYPE_CODE_FUNCTION;
964 TypeVals.push_back(FT->isVarArg());
965 TypeVals.push_back(VE.getTypeID(FT->getReturnType()));
966 for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i)
967 TypeVals.push_back(VE.getTypeID(FT->getParamType(i)));
968 AbbrevToUse = FunctionAbbrev;
969 break;
970 }
971 case Type::StructTyID: {
972 StructType *ST = cast<StructType>(T);
973 // STRUCT: [ispacked, eltty x N]
974 TypeVals.push_back(ST->isPacked());
975 // Output all of the element types.
976 for (StructType::element_iterator I = ST->element_begin(),
977 E = ST->element_end(); I != E; ++I)
978 TypeVals.push_back(VE.getTypeID(*I));
979
980 if (ST->isLiteral()) {
981 Code = bitc::TYPE_CODE_STRUCT_ANON;
982 AbbrevToUse = StructAnonAbbrev;
983 } else {
984 if (ST->isOpaque()) {
985 Code = bitc::TYPE_CODE_OPAQUE;
986 } else {
987 Code = bitc::TYPE_CODE_STRUCT_NAMED;
988 AbbrevToUse = StructNamedAbbrev;
989 }
990
991 // Emit the name if it is present.
992 if (!ST->getName().empty())
993 writeStringRecord(Stream, bitc::TYPE_CODE_STRUCT_NAME, ST->getName(),
994 StructNameAbbrev);
995 }
996 break;
997 }
998 case Type::ArrayTyID: {
999 ArrayType *AT = cast<ArrayType>(T);
1000 // ARRAY: [numelts, eltty]
1001 Code = bitc::TYPE_CODE_ARRAY;
1002 TypeVals.push_back(AT->getNumElements());
1003 TypeVals.push_back(VE.getTypeID(AT->getElementType()));
1004 AbbrevToUse = ArrayAbbrev;
1005 break;
1006 }
1007 case Type::FixedVectorTyID:
1008 case Type::ScalableVectorTyID: {
1009 VectorType *VT = cast<VectorType>(T);
1010 // VECTOR [numelts, eltty] or
1011 // [numelts, eltty, scalable]
1012 Code = bitc::TYPE_CODE_VECTOR;
1013 TypeVals.push_back(VT->getElementCount().getKnownMinValue());
1014 TypeVals.push_back(VE.getTypeID(VT->getElementType()));
1015 if (isa<ScalableVectorType>(VT))
1016 TypeVals.push_back(true);
1017 break;
1018 }
1019 }
1020
1021 // Emit the finished record.
1022 Stream.EmitRecord(Code, TypeVals, AbbrevToUse);
1023 TypeVals.clear();
1024 }
1025
1026 Stream.ExitBlock();
1027}
1028
1029static unsigned getEncodedLinkage(const GlobalValue::LinkageTypes Linkage) {
1030 switch (Linkage) {
1031 case GlobalValue::ExternalLinkage:
1032 return 0;
1033 case GlobalValue::WeakAnyLinkage:
1034 return 16;
1035 case GlobalValue::AppendingLinkage:
1036 return 2;
1037 case GlobalValue::InternalLinkage:
1038 return 3;
1039 case GlobalValue::LinkOnceAnyLinkage:
1040 return 18;
1041 case GlobalValue::ExternalWeakLinkage:
1042 return 7;
1043 case GlobalValue::CommonLinkage:
1044 return 8;
1045 case GlobalValue::PrivateLinkage:
1046 return 9;
1047 case GlobalValue::WeakODRLinkage:
1048 return 17;
1049 case GlobalValue::LinkOnceODRLinkage:
1050 return 19;
1051 case GlobalValue::AvailableExternallyLinkage:
1052 return 12;
1053 }
1054 llvm_unreachable("Invalid linkage")__builtin_unreachable();
1055}
1056
1057static unsigned getEncodedLinkage(const GlobalValue &GV) {
1058 return getEncodedLinkage(GV.getLinkage());
1059}
1060
1061static uint64_t getEncodedFFlags(FunctionSummary::FFlags Flags) {
1062 uint64_t RawFlags = 0;
1063 RawFlags |= Flags.ReadNone;
1064 RawFlags |= (Flags.ReadOnly << 1);
1065 RawFlags |= (Flags.NoRecurse << 2);
1066 RawFlags |= (Flags.ReturnDoesNotAlias << 3);
1067 RawFlags |= (Flags.NoInline << 4);
1068 RawFlags |= (Flags.AlwaysInline << 5);
1069 return RawFlags;
1070}
1071
1072// Decode the flags for GlobalValue in the summary. See getDecodedGVSummaryFlags
1073// in BitcodeReader.cpp.
1074static uint64_t getEncodedGVSummaryFlags(GlobalValueSummary::GVFlags Flags) {
1075 uint64_t RawFlags = 0;
1076
1077 RawFlags |= Flags.NotEligibleToImport; // bool
1078 RawFlags |= (Flags.Live << 1);
1079 RawFlags |= (Flags.DSOLocal << 2);
1080 RawFlags |= (Flags.CanAutoHide << 3);
1081
1082 // Linkage don't need to be remapped at that time for the summary. Any future
1083 // change to the getEncodedLinkage() function will need to be taken into
1084 // account here as well.
1085 RawFlags = (RawFlags << 4) | Flags.Linkage; // 4 bits
1086
1087 RawFlags |= (Flags.Visibility << 8); // 2 bits
1088
1089 return RawFlags;
1090}
1091
1092static uint64_t getEncodedGVarFlags(GlobalVarSummary::GVarFlags Flags) {
1093 uint64_t RawFlags = Flags.MaybeReadOnly | (Flags.MaybeWriteOnly << 1) |
1094 (Flags.Constant << 2) | Flags.VCallVisibility << 3;
1095 return RawFlags;
1096}
1097
1098static unsigned getEncodedVisibility(const GlobalValue &GV) {
1099 switch (GV.getVisibility()) {
1100 case GlobalValue::DefaultVisibility: return 0;
1101 case GlobalValue::HiddenVisibility: return 1;
1102 case GlobalValue::ProtectedVisibility: return 2;
1103 }
1104 llvm_unreachable("Invalid visibility")__builtin_unreachable();
1105}
1106
1107static unsigned getEncodedDLLStorageClass(const GlobalValue &GV) {
1108 switch (GV.getDLLStorageClass()) {
1109 case GlobalValue::DefaultStorageClass: return 0;
1110 case GlobalValue::DLLImportStorageClass: return 1;
1111 case GlobalValue::DLLExportStorageClass: return 2;
1112 }
1113 llvm_unreachable("Invalid DLL storage class")__builtin_unreachable();
1114}
1115
1116static unsigned getEncodedThreadLocalMode(const GlobalValue &GV) {
1117 switch (GV.getThreadLocalMode()) {
1118 case GlobalVariable::NotThreadLocal: return 0;
1119 case GlobalVariable::GeneralDynamicTLSModel: return 1;
1120 case GlobalVariable::LocalDynamicTLSModel: return 2;
1121 case GlobalVariable::InitialExecTLSModel: return 3;
1122 case GlobalVariable::LocalExecTLSModel: return 4;
1123 }
1124 llvm_unreachable("Invalid TLS model")__builtin_unreachable();
1125}
1126
1127static unsigned getEncodedComdatSelectionKind(const Comdat &C) {
1128 switch (C.getSelectionKind()) {
1129 case Comdat::Any:
1130 return bitc::COMDAT_SELECTION_KIND_ANY;
1131 case Comdat::ExactMatch:
1132 return bitc::COMDAT_SELECTION_KIND_EXACT_MATCH;
1133 case Comdat::Largest:
1134 return bitc::COMDAT_SELECTION_KIND_LARGEST;
1135 case Comdat::NoDeduplicate:
1136 return bitc::COMDAT_SELECTION_KIND_NO_DUPLICATES;
1137 case Comdat::SameSize:
1138 return bitc::COMDAT_SELECTION_KIND_SAME_SIZE;
1139 }
1140 llvm_unreachable("Invalid selection kind")__builtin_unreachable();
1141}
1142
1143static unsigned getEncodedUnnamedAddr(const GlobalValue &GV) {
1144 switch (GV.getUnnamedAddr()) {
1145 case GlobalValue::UnnamedAddr::None: return 0;
1146 case GlobalValue::UnnamedAddr::Local: return 2;
1147 case GlobalValue::UnnamedAddr::Global: return 1;
1148 }
1149 llvm_unreachable("Invalid unnamed_addr")__builtin_unreachable();
1150}
1151
1152size_t ModuleBitcodeWriter::addToStrtab(StringRef Str) {
1153 if (GenerateHash)
1154 Hasher.update(Str);
1155 return StrtabBuilder.add(Str);
1156}
1157
1158void ModuleBitcodeWriter::writeComdats() {
1159 SmallVector<unsigned, 64> Vals;
1160 for (const Comdat *C : VE.getComdats()) {
1161 // COMDAT: [strtab offset, strtab size, selection_kind]
1162 Vals.push_back(addToStrtab(C->getName()));
1163 Vals.push_back(C->getName().size());
1164 Vals.push_back(getEncodedComdatSelectionKind(*C));
1165 Stream.EmitRecord(bitc::MODULE_CODE_COMDAT, Vals, /*AbbrevToUse=*/0);
1166 Vals.clear();
1167 }
1168}
1169
1170/// Write a record that will eventually hold the word offset of the
1171/// module-level VST. For now the offset is 0, which will be backpatched
1172/// after the real VST is written. Saves the bit offset to backpatch.
1173void ModuleBitcodeWriter::writeValueSymbolTableForwardDecl() {
1174 // Write a placeholder value in for the offset of the real VST,
1175 // which is written after the function blocks so that it can include
1176 // the offset of each function. The placeholder offset will be
1177 // updated when the real VST is written.
1178 auto Abbv = std::make_shared<BitCodeAbbrev>();
1179 Abbv->Add(BitCodeAbbrevOp(bitc::MODULE_CODE_VSTOFFSET));
1180 // Blocks are 32-bit aligned, so we can use a 32-bit word offset to
1181 // hold the real VST offset. Must use fixed instead of VBR as we don't
1182 // know how many VBR chunks to reserve ahead of time.
1183 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1184 unsigned VSTOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbv));
1185
1186 // Emit the placeholder
1187 uint64_t Vals[] = {bitc::MODULE_CODE_VSTOFFSET, 0};
1188 Stream.EmitRecordWithAbbrev(VSTOffsetAbbrev, Vals);
1189
1190 // Compute and save the bit offset to the placeholder, which will be
1191 // patched when the real VST is written. We can simply subtract the 32-bit
1192 // fixed size from the current bit number to get the location to backpatch.
1193 VSTOffsetPlaceholder = Stream.GetCurrentBitNo() - 32;
1194}
1195
1196enum StringEncoding { SE_Char6, SE_Fixed7, SE_Fixed8 };
1197
1198/// Determine the encoding to use for the given string name and length.
1199static StringEncoding getStringEncoding(StringRef Str) {
1200 bool isChar6 = true;
1201 for (char C : Str) {
1202 if (isChar6)
1203 isChar6 = BitCodeAbbrevOp::isChar6(C);
1204 if ((unsigned char)C & 128)
1205 // don't bother scanning the rest.
1206 return SE_Fixed8;
1207 }
1208 if (isChar6)
1209 return SE_Char6;
1210 return SE_Fixed7;
1211}
1212
1213/// Emit top-level description of module, including target triple, inline asm,
1214/// descriptors for global variables, and function prototype info.
1215/// Returns the bit offset to backpatch with the location of the real VST.
1216void ModuleBitcodeWriter::writeModuleInfo() {
1217 // Emit various pieces of data attached to a module.
1218 if (!M.getTargetTriple().empty())
1219 writeStringRecord(Stream, bitc::MODULE_CODE_TRIPLE, M.getTargetTriple(),
1220 0 /*TODO*/);
1221 const std::string &DL = M.getDataLayoutStr();
1222 if (!DL.empty())
1223 writeStringRecord(Stream, bitc::MODULE_CODE_DATALAYOUT, DL, 0 /*TODO*/);
1224 if (!M.getModuleInlineAsm().empty())
1225 writeStringRecord(Stream, bitc::MODULE_CODE_ASM, M.getModuleInlineAsm(),
1226 0 /*TODO*/);
1227
1228 // Emit information about sections and GC, computing how many there are. Also
1229 // compute the maximum alignment value.
1230 std::map<std::string, unsigned> SectionMap;
1231 std::map<std::string, unsigned> GCMap;
1232 MaybeAlign MaxAlignment;
1233 unsigned MaxGlobalType = 0;
1234 const auto UpdateMaxAlignment = [&MaxAlignment](const MaybeAlign A) {
1235 if (A)
1236 MaxAlignment = !MaxAlignment ? *A : std::max(*MaxAlignment, *A);
1237 };
1238 for (const GlobalVariable &GV : M.globals()) {
1239 UpdateMaxAlignment(GV.getAlign());
1240 MaxGlobalType = std::max(MaxGlobalType, VE.getTypeID(GV.getValueType()));
1241 if (GV.hasSection()) {
1242 // Give section names unique ID's.
1243 unsigned &Entry = SectionMap[std::string(GV.getSection())];
1244 if (!Entry) {
1245 writeStringRecord(Stream, bitc::MODULE_CODE_SECTIONNAME, GV.getSection(),
1246 0 /*TODO*/);
1247 Entry = SectionMap.size();
1248 }
1249 }
1250 }
1251 for (const Function &F : M) {
1252 UpdateMaxAlignment(F.getAlign());
1253 if (F.hasSection()) {
1254 // Give section names unique ID's.
1255 unsigned &Entry = SectionMap[std::string(F.getSection())];
1256 if (!Entry) {
1257 writeStringRecord(Stream, bitc::MODULE_CODE_SECTIONNAME, F.getSection(),
1258 0 /*TODO*/);
1259 Entry = SectionMap.size();
1260 }
1261 }
1262 if (F.hasGC()) {
1263 // Same for GC names.
1264 unsigned &Entry = GCMap[F.getGC()];
1265 if (!Entry) {
1266 writeStringRecord(Stream, bitc::MODULE_CODE_GCNAME, F.getGC(),
1267 0 /*TODO*/);
1268 Entry = GCMap.size();
1269 }
1270 }
1271 }
1272
1273 // Emit abbrev for globals, now that we know # sections and max alignment.
1274 unsigned SimpleGVarAbbrev = 0;
1275 if (!M.global_empty()) {
1276 // Add an abbrev for common globals with no visibility or thread localness.
1277 auto Abbv = std::make_shared<BitCodeAbbrev>();
1278 Abbv->Add(BitCodeAbbrevOp(bitc::MODULE_CODE_GLOBALVAR));
1279 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1280 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1281 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
1282 Log2_32_Ceil(MaxGlobalType+1)));
1283 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // AddrSpace << 2
1284 //| explicitType << 1
1285 //| constant
1286 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Initializer.
1287 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 5)); // Linkage.
1288 if (!MaxAlignment) // Alignment.
1289 Abbv->Add(BitCodeAbbrevOp(0));
1290 else {
1291 unsigned MaxEncAlignment = getEncodedAlign(MaxAlignment);
1292 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
1293 Log2_32_Ceil(MaxEncAlignment+1)));
1294 }
1295 if (SectionMap.empty()) // Section.
1296 Abbv->Add(BitCodeAbbrevOp(0));
1297 else
1298 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
1299 Log2_32_Ceil(SectionMap.size()+1)));
1300 // Don't bother emitting vis + thread local.
1301 SimpleGVarAbbrev = Stream.EmitAbbrev(std::move(Abbv));
1302 }
1303
1304 SmallVector<unsigned, 64> Vals;
1305 // Emit the module's source file name.
1306 {
1307 StringEncoding Bits = getStringEncoding(M.getSourceFileName());
1308 BitCodeAbbrevOp AbbrevOpToUse = BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8);
1309 if (Bits == SE_Char6)
1310 AbbrevOpToUse = BitCodeAbbrevOp(BitCodeAbbrevOp::Char6);
1311 else if (Bits == SE_Fixed7)
1312 AbbrevOpToUse = BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7);
1313
1314 // MODULE_CODE_SOURCE_FILENAME: [namechar x N]
1315 auto Abbv = std::make_shared<BitCodeAbbrev>();
1316 Abbv->Add(BitCodeAbbrevOp(bitc::MODULE_CODE_SOURCE_FILENAME));
1317 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1318 Abbv->Add(AbbrevOpToUse);
1319 unsigned FilenameAbbrev = Stream.EmitAbbrev(std::move(Abbv));
1320
1321 for (const auto P : M.getSourceFileName())
1322 Vals.push_back((unsigned char)P);
1323
1324 // Emit the finished record.
1325 Stream.EmitRecord(bitc::MODULE_CODE_SOURCE_FILENAME, Vals, FilenameAbbrev);
1326 Vals.clear();
1327 }
1328
1329 // Emit the global variable information.
1330 for (const GlobalVariable &GV : M.globals()) {
1331 unsigned AbbrevToUse = 0;
1332
1333 // GLOBALVAR: [strtab offset, strtab size, type, isconst, initid,
1334 // linkage, alignment, section, visibility, threadlocal,
1335 // unnamed_addr, externally_initialized, dllstorageclass,
1336 // comdat, attributes, DSO_Local]
1337 Vals.push_back(addToStrtab(GV.getName()));
1338 Vals.push_back(GV.getName().size());
1339 Vals.push_back(VE.getTypeID(GV.getValueType()));
1340 Vals.push_back(GV.getType()->getAddressSpace() << 2 | 2 | GV.isConstant());
1341 Vals.push_back(GV.isDeclaration() ? 0 :
1342 (VE.getValueID(GV.getInitializer()) + 1));
1343 Vals.push_back(getEncodedLinkage(GV));
1344 Vals.push_back(getEncodedAlign(GV.getAlign()));
1345 Vals.push_back(GV.hasSection() ? SectionMap[std::string(GV.getSection())]
1346 : 0);
1347 if (GV.isThreadLocal() ||
1348 GV.getVisibility() != GlobalValue::DefaultVisibility ||
1349 GV.getUnnamedAddr() != GlobalValue::UnnamedAddr::None ||
1350 GV.isExternallyInitialized() ||
1351 GV.getDLLStorageClass() != GlobalValue::DefaultStorageClass ||
1352 GV.hasComdat() ||
1353 GV.hasAttributes() ||
1354 GV.isDSOLocal() ||
1355 GV.hasPartition()) {
1356 Vals.push_back(getEncodedVisibility(GV));
1357 Vals.push_back(getEncodedThreadLocalMode(GV));
1358 Vals.push_back(getEncodedUnnamedAddr(GV));
1359 Vals.push_back(GV.isExternallyInitialized());
1360 Vals.push_back(getEncodedDLLStorageClass(GV));
1361 Vals.push_back(GV.hasComdat() ? VE.getComdatID(GV.getComdat()) : 0);
1362
1363 auto AL = GV.getAttributesAsList(AttributeList::FunctionIndex);
1364 Vals.push_back(VE.getAttributeListID(AL));
1365
1366 Vals.push_back(GV.isDSOLocal());
1367 Vals.push_back(addToStrtab(GV.getPartition()));
1368 Vals.push_back(GV.getPartition().size());
1369 } else {
1370 AbbrevToUse = SimpleGVarAbbrev;
1371 }
1372
1373 Stream.EmitRecord(bitc::MODULE_CODE_GLOBALVAR, Vals, AbbrevToUse);
1374 Vals.clear();
1375 }
1376
1377 // Emit the function proto information.
1378 for (const Function &F : M) {
1379 // FUNCTION: [strtab offset, strtab size, type, callingconv, isproto,
1380 // linkage, paramattrs, alignment, section, visibility, gc,
1381 // unnamed_addr, prologuedata, dllstorageclass, comdat,
1382 // prefixdata, personalityfn, DSO_Local, addrspace]
1383 Vals.push_back(addToStrtab(F.getName()));
1384 Vals.push_back(F.getName().size());
1385 Vals.push_back(VE.getTypeID(F.getFunctionType()));
1386 Vals.push_back(F.getCallingConv());
1387 Vals.push_back(F.isDeclaration());
1388 Vals.push_back(getEncodedLinkage(F));
1389 Vals.push_back(VE.getAttributeListID(F.getAttributes()));
1390 Vals.push_back(getEncodedAlign(F.getAlign()));
1391 Vals.push_back(F.hasSection() ? SectionMap[std::string(F.getSection())]
1392 : 0);
1393 Vals.push_back(getEncodedVisibility(F));
1394 Vals.push_back(F.hasGC() ? GCMap[F.getGC()] : 0);
1395 Vals.push_back(getEncodedUnnamedAddr(F));
1396 Vals.push_back(F.hasPrologueData() ? (VE.getValueID(F.getPrologueData()) + 1)
1397 : 0);
1398 Vals.push_back(getEncodedDLLStorageClass(F));
1399 Vals.push_back(F.hasComdat() ? VE.getComdatID(F.getComdat()) : 0);
1400 Vals.push_back(F.hasPrefixData() ? (VE.getValueID(F.getPrefixData()) + 1)
1401 : 0);
1402 Vals.push_back(
1403 F.hasPersonalityFn() ? (VE.getValueID(F.getPersonalityFn()) + 1) : 0);
1404
1405 Vals.push_back(F.isDSOLocal());
1406 Vals.push_back(F.getAddressSpace());
1407 Vals.push_back(addToStrtab(F.getPartition()));
1408 Vals.push_back(F.getPartition().size());
1409
1410 unsigned AbbrevToUse = 0;
1411 Stream.EmitRecord(bitc::MODULE_CODE_FUNCTION, Vals, AbbrevToUse);
1412 Vals.clear();
1413 }
1414
1415 // Emit the alias information.
1416 for (const GlobalAlias &A : M.aliases()) {
1417 // ALIAS: [strtab offset, strtab size, alias type, aliasee val#, linkage,
1418 // visibility, dllstorageclass, threadlocal, unnamed_addr,
1419 // DSO_Local]
1420 Vals.push_back(addToStrtab(A.getName()));
1421 Vals.push_back(A.getName().size());
1422 Vals.push_back(VE.getTypeID(A.getValueType()));
1423 Vals.push_back(A.getType()->getAddressSpace());
1424 Vals.push_back(VE.getValueID(A.getAliasee()));
1425 Vals.push_back(getEncodedLinkage(A));
1426 Vals.push_back(getEncodedVisibility(A));
1427 Vals.push_back(getEncodedDLLStorageClass(A));
1428 Vals.push_back(getEncodedThreadLocalMode(A));
1429 Vals.push_back(getEncodedUnnamedAddr(A));
1430 Vals.push_back(A.isDSOLocal());
1431 Vals.push_back(addToStrtab(A.getPartition()));
1432 Vals.push_back(A.getPartition().size());
1433
1434 unsigned AbbrevToUse = 0;
1435 Stream.EmitRecord(bitc::MODULE_CODE_ALIAS, Vals, AbbrevToUse);
1436 Vals.clear();
1437 }
1438
1439 // Emit the ifunc information.
1440 for (const GlobalIFunc &I : M.ifuncs()) {
1441 // IFUNC: [strtab offset, strtab size, ifunc type, address space, resolver
1442 // val#, linkage, visibility, DSO_Local]
1443 Vals.push_back(addToStrtab(I.getName()));
1444 Vals.push_back(I.getName().size());
1445 Vals.push_back(VE.getTypeID(I.getValueType()));
1446 Vals.push_back(I.getType()->getAddressSpace());
1447 Vals.push_back(VE.getValueID(I.getResolver()));
1448 Vals.push_back(getEncodedLinkage(I));
1449 Vals.push_back(getEncodedVisibility(I));
1450 Vals.push_back(I.isDSOLocal());
1451 Vals.push_back(addToStrtab(I.getPartition()));
1452 Vals.push_back(I.getPartition().size());
1453 Stream.EmitRecord(bitc::MODULE_CODE_IFUNC, Vals);
1454 Vals.clear();
1455 }
1456
1457 writeValueSymbolTableForwardDecl();
1458}
1459
1460static uint64_t getOptimizationFlags(const Value *V) {
1461 uint64_t Flags = 0;
1462
1463 if (const auto *OBO = dyn_cast<OverflowingBinaryOperator>(V)) {
1464 if (OBO->hasNoSignedWrap())
1465 Flags |= 1 << bitc::OBO_NO_SIGNED_WRAP;
1466 if (OBO->hasNoUnsignedWrap())
1467 Flags |= 1 << bitc::OBO_NO_UNSIGNED_WRAP;
1468 } else if (const auto *PEO = dyn_cast<PossiblyExactOperator>(V)) {
1469 if (PEO->isExact())
1470 Flags |= 1 << bitc::PEO_EXACT;
1471 } else if (const auto *FPMO = dyn_cast<FPMathOperator>(V)) {
1472 if (FPMO->hasAllowReassoc())
1473 Flags |= bitc::AllowReassoc;
1474 if (FPMO->hasNoNaNs())
1475 Flags |= bitc::NoNaNs;
1476 if (FPMO->hasNoInfs())
1477 Flags |= bitc::NoInfs;
1478 if (FPMO->hasNoSignedZeros())
1479 Flags |= bitc::NoSignedZeros;
1480 if (FPMO->hasAllowReciprocal())
1481 Flags |= bitc::AllowReciprocal;
1482 if (FPMO->hasAllowContract())
1483 Flags |= bitc::AllowContract;
1484 if (FPMO->hasApproxFunc())
1485 Flags |= bitc::ApproxFunc;
1486 }
1487
1488 return Flags;
1489}
1490
1491void ModuleBitcodeWriter::writeValueAsMetadata(
1492 const ValueAsMetadata *MD, SmallVectorImpl<uint64_t> &Record) {
1493 // Mimic an MDNode with a value as one operand.
1494 Value *V = MD->getValue();
1495 Record.push_back(VE.getTypeID(V->getType()));
1496 Record.push_back(VE.getValueID(V));
1497 Stream.EmitRecord(bitc::METADATA_VALUE, Record, 0);
1498 Record.clear();
1499}
1500
1501void ModuleBitcodeWriter::writeMDTuple(const MDTuple *N,
1502 SmallVectorImpl<uint64_t> &Record,
1503 unsigned Abbrev) {
1504 for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) {
1505 Metadata *MD = N->getOperand(i);
1506 assert(!(MD && isa<LocalAsMetadata>(MD)) &&((void)0)
1507 "Unexpected function-local metadata")((void)0);
1508 Record.push_back(VE.getMetadataOrNullID(MD));
1509 }
1510 Stream.EmitRecord(N->isDistinct() ? bitc::METADATA_DISTINCT_NODE
1511 : bitc::METADATA_NODE,
1512 Record, Abbrev);
1513 Record.clear();
1514}
1515
1516unsigned ModuleBitcodeWriter::createDILocationAbbrev() {
1517 // Assume the column is usually under 128, and always output the inlined-at
1518 // location (it's never more expensive than building an array size 1).
1519 auto Abbv = std::make_shared<BitCodeAbbrev>();
1520 Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_LOCATION));
1521 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1522 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1523 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1524 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1525 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1526 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1527 return Stream.EmitAbbrev(std::move(Abbv));
1528}
1529
1530void ModuleBitcodeWriter::writeDILocation(const DILocation *N,
1531 SmallVectorImpl<uint64_t> &Record,
1532 unsigned &Abbrev) {
1533 if (!Abbrev)
1534 Abbrev = createDILocationAbbrev();
1535
1536 Record.push_back(N->isDistinct());
1537 Record.push_back(N->getLine());
1538 Record.push_back(N->getColumn());
1539 Record.push_back(VE.getMetadataID(N->getScope()));
1540 Record.push_back(VE.getMetadataOrNullID(N->getInlinedAt()));
1541 Record.push_back(N->isImplicitCode());
1542
1543 Stream.EmitRecord(bitc::METADATA_LOCATION, Record, Abbrev);
1544 Record.clear();
1545}
1546
1547unsigned ModuleBitcodeWriter::createGenericDINodeAbbrev() {
1548 // Assume the column is usually under 128, and always output the inlined-at
1549 // location (it's never more expensive than building an array size 1).
1550 auto Abbv = std::make_shared<BitCodeAbbrev>();
1551 Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_GENERIC_DEBUG));
1552 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1553 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1554 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1555 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1556 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1557 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1558 return Stream.EmitAbbrev(std::move(Abbv));
1559}
1560
1561void ModuleBitcodeWriter::writeGenericDINode(const GenericDINode *N,
1562 SmallVectorImpl<uint64_t> &Record,
1563 unsigned &Abbrev) {
1564 if (!Abbrev)
1565 Abbrev = createGenericDINodeAbbrev();
1566
1567 Record.push_back(N->isDistinct());
1568 Record.push_back(N->getTag());
1569 Record.push_back(0); // Per-tag version field; unused for now.
1570
1571 for (auto &I : N->operands())
1572 Record.push_back(VE.getMetadataOrNullID(I));
1573
1574 Stream.EmitRecord(bitc::METADATA_GENERIC_DEBUG, Record, Abbrev);
1575 Record.clear();
1576}
1577
1578void ModuleBitcodeWriter::writeDISubrange(const DISubrange *N,
1579 SmallVectorImpl<uint64_t> &Record,
1580 unsigned Abbrev) {
1581 const uint64_t Version = 2 << 1;
1582 Record.push_back((uint64_t)N->isDistinct() | Version);
1583 Record.push_back(VE.getMetadataOrNullID(N->getRawCountNode()));
1584 Record.push_back(VE.getMetadataOrNullID(N->getRawLowerBound()));
1585 Record.push_back(VE.getMetadataOrNullID(N->getRawUpperBound()));
1586 Record.push_back(VE.getMetadataOrNullID(N->getRawStride()));
1587
1588 Stream.EmitRecord(bitc::METADATA_SUBRANGE, Record, Abbrev);
1589 Record.clear();
1590}
1591
1592void ModuleBitcodeWriter::writeDIGenericSubrange(
1593 const DIGenericSubrange *N, SmallVectorImpl<uint64_t> &Record,
1594 unsigned Abbrev) {
1595 Record.push_back((uint64_t)N->isDistinct());
1596 Record.push_back(VE.getMetadataOrNullID(N->getRawCountNode()));
1597 Record.push_back(VE.getMetadataOrNullID(N->getRawLowerBound()));
1598 Record.push_back(VE.getMetadataOrNullID(N->getRawUpperBound()));
1599 Record.push_back(VE.getMetadataOrNullID(N->getRawStride()));
1600
1601 Stream.EmitRecord(bitc::METADATA_GENERIC_SUBRANGE, Record, Abbrev);
1602 Record.clear();
1603}
1604
1605static void emitSignedInt64(SmallVectorImpl<uint64_t> &Vals, uint64_t V) {
1606 if ((int64_t)V >= 0)
1607 Vals.push_back(V << 1);
1608 else
1609 Vals.push_back((-V << 1) | 1);
1610}
1611
1612static void emitWideAPInt(SmallVectorImpl<uint64_t> &Vals, const APInt &A) {
1613 // We have an arbitrary precision integer value to write whose
1614 // bit width is > 64. However, in canonical unsigned integer
1615 // format it is likely that the high bits are going to be zero.
1616 // So, we only write the number of active words.
1617 unsigned NumWords = A.getActiveWords();
1618 const uint64_t *RawData = A.getRawData();
1619 for (unsigned i = 0; i < NumWords; i++)
1620 emitSignedInt64(Vals, RawData[i]);
1621}
1622
1623void ModuleBitcodeWriter::writeDIEnumerator(const DIEnumerator *N,
1624 SmallVectorImpl<uint64_t> &Record,
1625 unsigned Abbrev) {
1626 const uint64_t IsBigInt = 1 << 2;
1627 Record.push_back(IsBigInt | (N->isUnsigned() << 1) | N->isDistinct());
1628 Record.push_back(N->getValue().getBitWidth());
1629 Record.push_back(VE.getMetadataOrNullID(N->getRawName()));
1630 emitWideAPInt(Record, N->getValue());
1631
1632 Stream.EmitRecord(bitc::METADATA_ENUMERATOR, Record, Abbrev);
1633 Record.clear();
1634}
1635
1636void ModuleBitcodeWriter::writeDIBasicType(const DIBasicType *N,
1637 SmallVectorImpl<uint64_t> &Record,
1638 unsigned Abbrev) {
1639 Record.push_back(N->isDistinct());
1640 Record.push_back(N->getTag());
1641 Record.push_back(VE.getMetadataOrNullID(N->getRawName()));
1642 Record.push_back(N->getSizeInBits());
1643 Record.push_back(N->getAlignInBits());
1644 Record.push_back(N->getEncoding());
1645 Record.push_back(N->getFlags());
1646
1647 Stream.EmitRecord(bitc::METADATA_BASIC_TYPE, Record, Abbrev);
1648 Record.clear();
1649}
1650
1651void ModuleBitcodeWriter::writeDIStringType(const DIStringType *N,
1652 SmallVectorImpl<uint64_t> &Record,
1653 unsigned Abbrev) {
1654 Record.push_back(N->isDistinct());
1655 Record.push_back(N->getTag());
1656 Record.push_back(VE.getMetadataOrNullID(N->getRawName()));
1657 Record.push_back(VE.getMetadataOrNullID(N->getStringLength()));
1658 Record.push_back(VE.getMetadataOrNullID(N->getStringLengthExp()));
1659 Record.push_back(N->getSizeInBits());
1660 Record.push_back(N->getAlignInBits());
1661 Record.push_back(N->getEncoding());
1662
1663 Stream.EmitRecord(bitc::METADATA_STRING_TYPE, Record, Abbrev);
1664 Record.clear();
1665}
1666
1667void ModuleBitcodeWriter::writeDIDerivedType(const DIDerivedType *N,
1668 SmallVectorImpl<uint64_t> &Record,
1669 unsigned Abbrev) {
1670 Record.push_back(N->isDistinct());
1671 Record.push_back(N->getTag());
1672 Record.push_back(VE.getMetadataOrNullID(N->getRawName()));
1673 Record.push_back(VE.getMetadataOrNullID(N->getFile()));
1674 Record.push_back(N->getLine());
1675 Record.push_back(VE.getMetadataOrNullID(N->getScope()));
1676 Record.push_back(VE.getMetadataOrNullID(N->getBaseType()));
1677 Record.push_back(N->getSizeInBits());
1678 Record.push_back(N->getAlignInBits());
1679 Record.push_back(N->getOffsetInBits());
1680 Record.push_back(N->getFlags());
1681 Record.push_back(VE.getMetadataOrNullID(N->getExtraData()));
1682
1683 // DWARF address space is encoded as N->getDWARFAddressSpace() + 1. 0 means
1684 // that there is no DWARF address space associated with DIDerivedType.
1685 if (const auto &DWARFAddressSpace = N->getDWARFAddressSpace())
1686 Record.push_back(*DWARFAddressSpace + 1);
1687 else
1688 Record.push_back(0);
1689
1690 Stream.EmitRecord(bitc::METADATA_DERIVED_TYPE, Record, Abbrev);
1691 Record.clear();
1692}
1693
1694void ModuleBitcodeWriter::writeDICompositeType(
1695 const DICompositeType *N, SmallVectorImpl<uint64_t> &Record,
1696 unsigned Abbrev) {
1697 const unsigned IsNotUsedInOldTypeRef = 0x2;
1698 Record.push_back(IsNotUsedInOldTypeRef | (unsigned)N->isDistinct());
1699 Record.push_back(N->getTag());
1700 Record.push_back(VE.getMetadataOrNullID(N->getRawName()));
1701 Record.push_back(VE.getMetadataOrNullID(N->getFile()));
1702 Record.push_back(N->getLine());
1703 Record.push_back(VE.getMetadataOrNullID(N->getScope()));
1704 Record.push_back(VE.getMetadataOrNullID(N->getBaseType()));
1705 Record.push_back(N->getSizeInBits());
1706 Record.push_back(N->getAlignInBits());
1707 Record.push_back(N->getOffsetInBits());
1708 Record.push_back(N->getFlags());
1709 Record.push_back(VE.getMetadataOrNullID(N->getElements().get()));
1710 Record.push_back(N->getRuntimeLang());
1711 Record.push_back(VE.getMetadataOrNullID(N->getVTableHolder()));
1712 Record.push_back(VE.getMetadataOrNullID(N->getTemplateParams().get()));
1713 Record.push_back(VE.getMetadataOrNullID(N->getRawIdentifier()));
1714 Record.push_back(VE.getMetadataOrNullID(N->getDiscriminator()));
1715 Record.push_back(VE.getMetadataOrNullID(N->getRawDataLocation()));
1716 Record.push_back(VE.getMetadataOrNullID(N->getRawAssociated()));
1717 Record.push_back(VE.getMetadataOrNullID(N->getRawAllocated()));
1718 Record.push_back(VE.getMetadataOrNullID(N->getRawRank()));
1719
1720 Stream.EmitRecord(bitc::METADATA_COMPOSITE_TYPE, Record, Abbrev);
1721 Record.clear();
1722}
1723
1724void ModuleBitcodeWriter::writeDISubroutineType(
1725 const DISubroutineType *N, SmallVectorImpl<uint64_t> &Record,
1726 unsigned Abbrev) {
1727 const unsigned HasNoOldTypeRefs = 0x2;
1728 Record.push_back(HasNoOldTypeRefs | (unsigned)N->isDistinct());
1729 Record.push_back(N->getFlags());
1730 Record.push_back(VE.getMetadataOrNullID(N->getTypeArray().get()));
1731 Record.push_back(N->getCC());
1732
1733 Stream.EmitRecord(bitc::METADATA_SUBROUTINE_TYPE, Record, Abbrev);
1734 Record.clear();
1735}
1736
1737void ModuleBitcodeWriter::writeDIFile(const DIFile *N,
1738 SmallVectorImpl<uint64_t> &Record,
1739 unsigned Abbrev) {
1740 Record.push_back(N->isDistinct());
1741 Record.push_back(VE.getMetadataOrNullID(N->getRawFilename()));
1742 Record.push_back(VE.getMetadataOrNullID(N->getRawDirectory()));
1743 if (N->getRawChecksum()) {
1744 Record.push_back(N->getRawChecksum()->Kind);
1745 Record.push_back(VE.getMetadataOrNullID(N->getRawChecksum()->Value));
1746 } else {
1747 // Maintain backwards compatibility with the old internal representation of
1748 // CSK_None in ChecksumKind by writing nulls here when Checksum is None.
1749 Record.push_back(0);
1750 Record.push_back(VE.getMetadataOrNullID(nullptr));
1751 }
1752 auto Source = N->getRawSource();
1753 if (Source)
1754 Record.push_back(VE.getMetadataOrNullID(*Source));
1755
1756 Stream.EmitRecord(bitc::METADATA_FILE, Record, Abbrev);
1757 Record.clear();
1758}
1759
1760void ModuleBitcodeWriter::writeDICompileUnit(const DICompileUnit *N,
1761 SmallVectorImpl<uint64_t> &Record,
1762 unsigned Abbrev) {
1763 assert(N->isDistinct() && "Expected distinct compile units")((void)0);
1764 Record.push_back(/* IsDistinct */ true);
1765 Record.push_back(N->getSourceLanguage());
1766 Record.push_back(VE.getMetadataOrNullID(N->getFile()));
1767 Record.push_back(VE.getMetadataOrNullID(N->getRawProducer()));
1768 Record.push_back(N->isOptimized());
1769 Record.push_back(VE.getMetadataOrNullID(N->getRawFlags()));
1770 Record.push_back(N->getRuntimeVersion());
1771 Record.push_back(VE.getMetadataOrNullID(N->getRawSplitDebugFilename()));
1772 Record.push_back(N->getEmissionKind());
1773 Record.push_back(VE.getMetadataOrNullID(N->getEnumTypes().get()));
1774 Record.push_back(VE.getMetadataOrNullID(N->getRetainedTypes().get()));
1775 Record.push_back(/* subprograms */ 0);
1776 Record.push_back(VE.getMetadataOrNullID(N->getGlobalVariables().get()));
1777 Record.push_back(VE.getMetadataOrNullID(N->getImportedEntities().get()));
1778 Record.push_back(N->getDWOId());
1779 Record.push_back(VE.getMetadataOrNullID(N->getMacros().get()));
1780 Record.push_back(N->getSplitDebugInlining());
1781 Record.push_back(N->getDebugInfoForProfiling());
1782 Record.push_back((unsigned)N->getNameTableKind());
1783 Record.push_back(N->getRangesBaseAddress());
1784 Record.push_back(VE.getMetadataOrNullID(N->getRawSysRoot()));
1785 Record.push_back(VE.getMetadataOrNullID(N->getRawSDK()));
1786
1787 Stream.EmitRecord(bitc::METADATA_COMPILE_UNIT, Record, Abbrev);
1788 Record.clear();
1789}
1790
1791void ModuleBitcodeWriter::writeDISubprogram(const DISubprogram *N,
1792 SmallVectorImpl<uint64_t> &Record,
1793 unsigned Abbrev) {
1794 const uint64_t HasUnitFlag = 1 << 1;
1795 const uint64_t HasSPFlagsFlag = 1 << 2;
1796 Record.push_back(uint64_t(N->isDistinct()) | HasUnitFlag | HasSPFlagsFlag);
1797 Record.push_back(VE.getMetadataOrNullID(N->getScope()));
1798 Record.push_back(VE.getMetadataOrNullID(N->getRawName()));
1799 Record.push_back(VE.getMetadataOrNullID(N->getRawLinkageName()));
1800 Record.push_back(VE.getMetadataOrNullID(N->getFile()));
1801 Record.push_back(N->getLine());
1802 Record.push_back(VE.getMetadataOrNullID(N->getType()));
1803 Record.push_back(N->getScopeLine());
1804 Record.push_back(VE.getMetadataOrNullID(N->getContainingType()));
1805 Record.push_back(N->getSPFlags());
1806 Record.push_back(N->getVirtualIndex());
1807 Record.push_back(N->getFlags());
1808 Record.push_back(VE.getMetadataOrNullID(N->getRawUnit()));
1809 Record.push_back(VE.getMetadataOrNullID(N->getTemplateParams().get()));
1810 Record.push_back(VE.getMetadataOrNullID(N->getDeclaration()));
1811 Record.push_back(VE.getMetadataOrNullID(N->getRetainedNodes().get()));
1812 Record.push_back(N->getThisAdjustment());
1813 Record.push_back(VE.getMetadataOrNullID(N->getThrownTypes().get()));
1814
1815 Stream.EmitRecord(bitc::METADATA_SUBPROGRAM, Record, Abbrev);
1816 Record.clear();
1817}
1818
1819void ModuleBitcodeWriter::writeDILexicalBlock(const DILexicalBlock *N,
1820 SmallVectorImpl<uint64_t> &Record,
1821 unsigned Abbrev) {
1822 Record.push_back(N->isDistinct());
1823 Record.push_back(VE.getMetadataOrNullID(N->getScope()));
1824 Record.push_back(VE.getMetadataOrNullID(N->getFile()));
1825 Record.push_back(N->getLine());
1826 Record.push_back(N->getColumn());
1827
1828 Stream.EmitRecord(bitc::METADATA_LEXICAL_BLOCK, Record, Abbrev);
1829 Record.clear();
1830}
1831
1832void ModuleBitcodeWriter::writeDILexicalBlockFile(
1833 const DILexicalBlockFile *N, SmallVectorImpl<uint64_t> &Record,
1834 unsigned Abbrev) {
1835 Record.push_back(N->isDistinct());
1836 Record.push_back(VE.getMetadataOrNullID(N->getScope()));
1837 Record.push_back(VE.getMetadataOrNullID(N->getFile()));
1838 Record.push_back(N->getDiscriminator());
1839
1840 Stream.EmitRecord(bitc::METADATA_LEXICAL_BLOCK_FILE, Record, Abbrev);
1841 Record.clear();
1842}
1843
1844void ModuleBitcodeWriter::writeDICommonBlock(const DICommonBlock *N,
1845 SmallVectorImpl<uint64_t> &Record,
1846 unsigned Abbrev) {
1847 Record.push_back(N->isDistinct());
1848 Record.push_back(VE.getMetadataOrNullID(N->getScope()));
1849 Record.push_back(VE.getMetadataOrNullID(N->getDecl()));
1850 Record.push_back(VE.getMetadataOrNullID(N->getRawName()));
1851 Record.push_back(VE.getMetadataOrNullID(N->getFile()));
1852 Record.push_back(N->getLineNo());
1853
1854 Stream.EmitRecord(bitc::METADATA_COMMON_BLOCK, Record, Abbrev);
1855 Record.clear();
1856}
1857
1858void ModuleBitcodeWriter::writeDINamespace(const DINamespace *N,
1859 SmallVectorImpl<uint64_t> &Record,
1860 unsigned Abbrev) {
1861 Record.push_back(N->isDistinct() | N->getExportSymbols() << 1);
1862 Record.push_back(VE.getMetadataOrNullID(N->getScope()));
1863 Record.push_back(VE.getMetadataOrNullID(N->getRawName()));
1864
1865 Stream.EmitRecord(bitc::METADATA_NAMESPACE, Record, Abbrev);
1866 Record.clear();
1867}
1868
1869void ModuleBitcodeWriter::writeDIMacro(const DIMacro *N,
1870 SmallVectorImpl<uint64_t> &Record,
1871 unsigned Abbrev) {
1872 Record.push_back(N->isDistinct());
1873 Record.push_back(N->getMacinfoType());
1874 Record.push_back(N->getLine());
1875 Record.push_back(VE.getMetadataOrNullID(N->getRawName()));
1876 Record.push_back(VE.getMetadataOrNullID(N->getRawValue()));
1877
1878 Stream.EmitRecord(bitc::METADATA_MACRO, Record, Abbrev);
1879 Record.clear();
1880}
1881
1882void ModuleBitcodeWriter::writeDIMacroFile(const DIMacroFile *N,
1883 SmallVectorImpl<uint64_t> &Record,
1884 unsigned Abbrev) {
1885 Record.push_back(N->isDistinct());
1886 Record.push_back(N->getMacinfoType());
1887 Record.push_back(N->getLine());
1888 Record.push_back(VE.getMetadataOrNullID(N->getFile()));
1889 Record.push_back(VE.getMetadataOrNullID(N->getElements().get()));
1890
1891 Stream.EmitRecord(bitc::METADATA_MACRO_FILE, Record, Abbrev);
1892 Record.clear();
1893}
1894
1895void ModuleBitcodeWriter::writeDIArgList(const DIArgList *N,
1896 SmallVectorImpl<uint64_t> &Record,
1897 unsigned Abbrev) {
1898 Record.reserve(N->getArgs().size());
1899 for (ValueAsMetadata *MD : N->getArgs())
1900 Record.push_back(VE.getMetadataID(MD));
1901
1902 Stream.EmitRecord(bitc::METADATA_ARG_LIST, Record, Abbrev);
1903 Record.clear();
1904}
1905
1906void ModuleBitcodeWriter::writeDIModule(const DIModule *N,
1907 SmallVectorImpl<uint64_t> &Record,
1908 unsigned Abbrev) {
1909 Record.push_back(N->isDistinct());
1910 for (auto &I : N->operands())
1911 Record.push_back(VE.getMetadataOrNullID(I));
1912 Record.push_back(N->getLineNo());
1913 Record.push_back(N->getIsDecl());
1914
1915 Stream.EmitRecord(bitc::METADATA_MODULE, Record, Abbrev);
1916 Record.clear();
1917}
1918
1919void ModuleBitcodeWriter::writeDITemplateTypeParameter(
1920 const DITemplateTypeParameter *N, SmallVectorImpl<uint64_t> &Record,
1921 unsigned Abbrev) {
1922 Record.push_back(N->isDistinct());
1923 Record.push_back(VE.getMetadataOrNullID(N->getRawName()));
1924 Record.push_back(VE.getMetadataOrNullID(N->getType()));
1925 Record.push_back(N->isDefault());
1926
1927 Stream.EmitRecord(bitc::METADATA_TEMPLATE_TYPE, Record, Abbrev);
1928 Record.clear();
1929}
1930
1931void ModuleBitcodeWriter::writeDITemplateValueParameter(
1932 const DITemplateValueParameter *N, SmallVectorImpl<uint64_t> &Record,
1933 unsigned Abbrev) {
1934 Record.push_back(N->isDistinct());
1935 Record.push_back(N->getTag());
1936 Record.push_back(VE.getMetadataOrNullID(N->getRawName()));
1937 Record.push_back(VE.getMetadataOrNullID(N->getType()));
1938 Record.push_back(N->isDefault());
1939 Record.push_back(VE.getMetadataOrNullID(N->getValue()));
1940
1941 Stream.EmitRecord(bitc::METADATA_TEMPLATE_VALUE, Record, Abbrev);
1942 Record.clear();
1943}
1944
1945void ModuleBitcodeWriter::writeDIGlobalVariable(
1946 const DIGlobalVariable *N, SmallVectorImpl<uint64_t> &Record,
1947 unsigned Abbrev) {
1948 const uint64_t Version = 2 << 1;
1949 Record.push_back((uint64_t)N->isDistinct() | Version);
1950 Record.push_back(VE.getMetadataOrNullID(N->getScope()));
1951 Record.push_back(VE.getMetadataOrNullID(N->getRawName()));
1952 Record.push_back(VE.getMetadataOrNullID(N->getRawLinkageName()));
1953 Record.push_back(VE.getMetadataOrNullID(N->getFile()));
1954 Record.push_back(N->getLine());
1955 Record.push_back(VE.getMetadataOrNullID(N->getType()));
1956 Record.push_back(N->isLocalToUnit());
1957 Record.push_back(N->isDefinition());
1958 Record.push_back(VE.getMetadataOrNullID(N->getStaticDataMemberDeclaration()));
1959 Record.push_back(VE.getMetadataOrNullID(N->getTemplateParams()));
1960 Record.push_back(N->getAlignInBits());
1961
1962 Stream.EmitRecord(bitc::METADATA_GLOBAL_VAR, Record, Abbrev);
1963 Record.clear();
1964}
1965
1966void ModuleBitcodeWriter::writeDILocalVariable(
1967 const DILocalVariable *N, SmallVectorImpl<uint64_t> &Record,
1968 unsigned Abbrev) {
1969 // In order to support all possible bitcode formats in BitcodeReader we need
1970 // to distinguish the following cases:
1971 // 1) Record has no artificial tag (Record[1]),
1972 // has no obsolete inlinedAt field (Record[9]).
1973 // In this case Record size will be 8, HasAlignment flag is false.
1974 // 2) Record has artificial tag (Record[1]),
1975 // has no obsolete inlignedAt field (Record[9]).
1976 // In this case Record size will be 9, HasAlignment flag is false.
1977 // 3) Record has both artificial tag (Record[1]) and
1978 // obsolete inlignedAt field (Record[9]).
1979 // In this case Record size will be 10, HasAlignment flag is false.
1980 // 4) Record has neither artificial tag, nor inlignedAt field, but
1981 // HasAlignment flag is true and Record[8] contains alignment value.
1982 const uint64_t HasAlignmentFlag = 1 << 1;
1983 Record.push_back((uint64_t)N->isDistinct() | HasAlignmentFlag);
1984 Record.push_back(VE.getMetadataOrNullID(N->getScope()));
1985 Record.push_back(VE.getMetadataOrNullID(N->getRawName()));
1986 Record.push_back(VE.getMetadataOrNullID(N->getFile()));
1987 Record.push_back(N->getLine());
1988 Record.push_back(VE.getMetadataOrNullID(N->getType()));
1989 Record.push_back(N->getArg());
1990 Record.push_back(N->getFlags());
1991 Record.push_back(N->getAlignInBits());
1992
1993 Stream.EmitRecord(bitc::METADATA_LOCAL_VAR, Record, Abbrev);
1994 Record.clear();
1995}
1996
1997void ModuleBitcodeWriter::writeDILabel(
1998 const DILabel *N, SmallVectorImpl<uint64_t> &Record,
1999 unsigned Abbrev) {
2000 Record.push_back((uint64_t)N->isDistinct());
2001 Record.push_back(VE.getMetadataOrNullID(N->getScope()));
2002 Record.push_back(VE.getMetadataOrNullID(N->getRawName()));
2003 Record.push_back(VE.getMetadataOrNullID(N->getFile()));
2004 Record.push_back(N->getLine());
2005
2006 Stream.EmitRecord(bitc::METADATA_LABEL, Record, Abbrev);
2007 Record.clear();
2008}
2009
2010void ModuleBitcodeWriter::writeDIExpression(const DIExpression *N,
2011 SmallVectorImpl<uint64_t> &Record,
2012 unsigned Abbrev) {
2013 Record.reserve(N->getElements().size() + 1);
2014 const uint64_t Version = 3 << 1;
2015 Record.push_back((uint64_t)N->isDistinct() | Version);
2016 Record.append(N->elements_begin(), N->elements_end());
2017
2018 Stream.EmitRecord(bitc::METADATA_EXPRESSION, Record, Abbrev);
2019 Record.clear();
2020}
2021
2022void ModuleBitcodeWriter::writeDIGlobalVariableExpression(
2023 const DIGlobalVariableExpression *N, SmallVectorImpl<uint64_t> &Record,
2024 unsigned Abbrev) {
2025 Record.push_back(N->isDistinct());
2026 Record.push_back(VE.getMetadataOrNullID(N->getVariable()));
2027 Record.push_back(VE.getMetadataOrNullID(N->getExpression()));
2028
2029 Stream.EmitRecord(bitc::METADATA_GLOBAL_VAR_EXPR, Record, Abbrev);
2030 Record.clear();
2031}
2032
2033void ModuleBitcodeWriter::writeDIObjCProperty(const DIObjCProperty *N,
2034 SmallVectorImpl<uint64_t> &Record,
2035 unsigned Abbrev) {
2036 Record.push_back(N->isDistinct());
2037 Record.push_back(VE.getMetadataOrNullID(N->getRawName()));
2038 Record.push_back(VE.getMetadataOrNullID(N->getFile()));
2039 Record.push_back(N->getLine());
2040 Record.push_back(VE.getMetadataOrNullID(N->getRawSetterName()));
2041 Record.push_back(VE.getMetadataOrNullID(N->getRawGetterName()));
2042 Record.push_back(N->getAttributes());
2043 Record.push_back(VE.getMetadataOrNullID(N->getType()));
2044
2045 Stream.EmitRecord(bitc::METADATA_OBJC_PROPERTY, Record, Abbrev);
2046 Record.clear();
2047}
2048
2049void ModuleBitcodeWriter::writeDIImportedEntity(
2050 const DIImportedEntity *N, SmallVectorImpl<uint64_t> &Record,
2051 unsigned Abbrev) {
2052 Record.push_back(N->isDistinct());
2053 Record.push_back(N->getTag());
2054 Record.push_back(VE.getMetadataOrNullID(N->getScope()));
2055 Record.push_back(VE.getMetadataOrNullID(N->getEntity()));
2056 Record.push_back(N->getLine());
2057 Record.push_back(VE.getMetadataOrNullID(N->getRawName()));
2058 Record.push_back(VE.getMetadataOrNullID(N->getRawFile()));
2059
2060 Stream.EmitRecord(bitc::METADATA_IMPORTED_ENTITY, Record, Abbrev);
2061 Record.clear();
2062}
2063
2064unsigned ModuleBitcodeWriter::createNamedMetadataAbbrev() {
2065 auto Abbv = std::make_shared<BitCodeAbbrev>();
2066 Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_NAME));
2067 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
2068 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));
2069 return Stream.EmitAbbrev(std::move(Abbv));
2070}
2071
2072void ModuleBitcodeWriter::writeNamedMetadata(
2073 SmallVectorImpl<uint64_t> &Record) {
2074 if (M.named_metadata_empty())
2075 return;
2076
2077 unsigned Abbrev = createNamedMetadataAbbrev();
2078 for (const NamedMDNode &NMD : M.named_metadata()) {
2079 // Write name.
2080 StringRef Str = NMD.getName();
2081 Record.append(Str.bytes_begin(), Str.bytes_end());
2082 Stream.EmitRecord(bitc::METADATA_NAME, Record, Abbrev);
2083 Record.clear();
2084
2085 // Write named metadata operands.
2086 for (const MDNode *N : NMD.operands())
2087 Record.push_back(VE.getMetadataID(N));
2088 Stream.EmitRecord(bitc::METADATA_NAMED_NODE, Record, 0);
2089 Record.clear();
2090 }
2091}
2092
2093unsigned ModuleBitcodeWriter::createMetadataStringsAbbrev() {
2094 auto Abbv = std::make_shared<BitCodeAbbrev>();
2095 Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_STRINGS));
2096 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # of strings
2097 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // offset to chars
2098 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2099 return Stream.EmitAbbrev(std::move(Abbv));
2100}
2101
2102/// Write out a record for MDString.
2103///
2104/// All the metadata strings in a metadata block are emitted in a single
2105/// record. The sizes and strings themselves are shoved into a blob.
2106void ModuleBitcodeWriter::writeMetadataStrings(
2107 ArrayRef<const Metadata *> Strings, SmallVectorImpl<uint64_t> &Record) {
2108 if (Strings.empty())
2109 return;
2110
2111 // Start the record with the number of strings.
2112 Record.push_back(bitc::METADATA_STRINGS);
2113 Record.push_back(Strings.size());
2114
2115 // Emit the sizes of the strings in the blob.
2116 SmallString<256> Blob;
2117 {
2118 BitstreamWriter W(Blob);
2119 for (const Metadata *MD : Strings)
2120 W.EmitVBR(cast<MDString>(MD)->getLength(), 6);
2121 W.FlushToWord();
2122 }
2123
2124 // Add the offset to the strings to the record.
2125 Record.push_back(Blob.size());
2126
2127 // Add the strings to the blob.
2128 for (const Metadata *MD : Strings)
2129 Blob.append(cast<MDString>(MD)->getString());
2130
2131 // Emit the final record.
2132 Stream.EmitRecordWithBlob(createMetadataStringsAbbrev(), Record, Blob);
2133 Record.clear();
2134}
2135
2136// Generates an enum to use as an index in the Abbrev array of Metadata record.
2137enum MetadataAbbrev : unsigned {
2138#define HANDLE_MDNODE_LEAF(CLASS) CLASS##AbbrevID,
2139#include "llvm/IR/Metadata.def"
2140 LastPlusOne
2141};
2142
2143void ModuleBitcodeWriter::writeMetadataRecords(
2144 ArrayRef<const Metadata *> MDs, SmallVectorImpl<uint64_t> &Record,
2145 std::vector<unsigned> *MDAbbrevs, std::vector<uint64_t> *IndexPos) {
2146 if (MDs.empty())
2147 return;
2148
2149 // Initialize MDNode abbreviations.
2150#define HANDLE_MDNODE_LEAF(CLASS) unsigned CLASS##Abbrev = 0;
2151#include "llvm/IR/Metadata.def"
2152
2153 for (const Metadata *MD : MDs) {
2154 if (IndexPos)
2155 IndexPos->push_back(Stream.GetCurrentBitNo());
2156 if (const MDNode *N = dyn_cast<MDNode>(MD)) {
2157 assert(N->isResolved() && "Expected forward references to be resolved")((void)0);
2158
2159 switch (N->getMetadataID()) {
2160 default:
2161 llvm_unreachable("Invalid MDNode subclass")__builtin_unreachable();
2162#define HANDLE_MDNODE_LEAF(CLASS) \
2163 case Metadata::CLASS##Kind: \
2164 if (MDAbbrevs) \
2165 write##CLASS(cast<CLASS>(N), Record, \
2166 (*MDAbbrevs)[MetadataAbbrev::CLASS##AbbrevID]); \
2167 else \
2168 write##CLASS(cast<CLASS>(N), Record, CLASS##Abbrev); \
2169 continue;
2170#include "llvm/IR/Metadata.def"
2171 }
2172 }
2173 writeValueAsMetadata(cast<ValueAsMetadata>(MD), Record);
2174 }
2175}
2176
2177void ModuleBitcodeWriter::writeModuleMetadata() {
2178 if (!VE.hasMDs() && M.named_metadata_empty())
2179 return;
2180
2181 Stream.EnterSubblock(bitc::METADATA_BLOCK_ID, 4);
2182 SmallVector<uint64_t, 64> Record;
2183
2184 // Emit all abbrevs upfront, so that the reader can jump in the middle of the
2185 // block and load any metadata.
2186 std::vector<unsigned> MDAbbrevs;
2187
2188 MDAbbrevs.resize(MetadataAbbrev::LastPlusOne);
2189 MDAbbrevs[MetadataAbbrev::DILocationAbbrevID] = createDILocationAbbrev();
2190 MDAbbrevs[MetadataAbbrev::GenericDINodeAbbrevID] =
2191 createGenericDINodeAbbrev();
2192
2193 auto Abbv = std::make_shared<BitCodeAbbrev>();
2194 Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_INDEX_OFFSET));
2195 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2196 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2197 unsigned OffsetAbbrev = Stream.EmitAbbrev(std::move(Abbv));
2198
2199 Abbv = std::make_shared<BitCodeAbbrev>();
2200 Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_INDEX));
2201 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
2202 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
2203 unsigned IndexAbbrev = Stream.EmitAbbrev(std::move(Abbv));
2204
2205 // Emit MDStrings together upfront.
2206 writeMetadataStrings(VE.getMDStrings(), Record);
2207
2208 // We only emit an index for the metadata record if we have more than a given
2209 // (naive) threshold of metadatas, otherwise it is not worth it.
2210 if (VE.getNonMDStrings().size() > IndexThreshold) {
2211 // Write a placeholder value in for the offset of the metadata index,
2212 // which is written after the records, so that it can include
2213 // the offset of each entry. The placeholder offset will be
2214 // updated after all records are emitted.
2215 uint64_t Vals[] = {0, 0};
2216 Stream.EmitRecord(bitc::METADATA_INDEX_OFFSET, Vals, OffsetAbbrev);
2217 }
2218
2219 // Compute and save the bit offset to the current position, which will be
2220 // patched when we emit the index later. We can simply subtract the 64-bit
2221 // fixed size from the current bit number to get the location to backpatch.
2222 uint64_t IndexOffsetRecordBitPos = Stream.GetCurrentBitNo();
2223
2224 // This index will contain the bitpos for each individual record.
2225 std::vector<uint64_t> IndexPos;
2226 IndexPos.reserve(VE.getNonMDStrings().size());
2227
2228 // Write all the records
2229 writeMetadataRecords(VE.getNonMDStrings(), Record, &MDAbbrevs, &IndexPos);
2230
2231 if (VE.getNonMDStrings().size() > IndexThreshold) {
2232 // Now that we have emitted all the records we will emit the index. But
2233 // first
2234 // backpatch the forward reference so that the reader can skip the records
2235 // efficiently.
2236 Stream.BackpatchWord64(IndexOffsetRecordBitPos - 64,
2237 Stream.GetCurrentBitNo() - IndexOffsetRecordBitPos);
2238
2239 // Delta encode the index.
2240 uint64_t PreviousValue = IndexOffsetRecordBitPos;
2241 for (auto &Elt : IndexPos) {
2242 auto EltDelta = Elt - PreviousValue;
2243 PreviousValue = Elt;
2244 Elt = EltDelta;
2245 }
2246 // Emit the index record.
2247 Stream.EmitRecord(bitc::METADATA_INDEX, IndexPos, IndexAbbrev);
2248 IndexPos.clear();
2249 }
2250
2251 // Write the named metadata now.
2252 writeNamedMetadata(Record);
2253
2254 auto AddDeclAttachedMetadata = [&](const GlobalObject &GO) {
2255 SmallVector<uint64_t, 4> Record;
2256 Record.push_back(VE.getValueID(&GO));
2257 pushGlobalMetadataAttachment(Record, GO);
2258 Stream.EmitRecord(bitc::METADATA_GLOBAL_DECL_ATTACHMENT, Record);
2259 };
2260 for (const Function &F : M)
2261 if (F.isDeclaration() && F.hasMetadata())
2262 AddDeclAttachedMetadata(F);
2263 // FIXME: Only store metadata for declarations here, and move data for global
2264 // variable definitions to a separate block (PR28134).
2265 for (const GlobalVariable &GV : M.globals())
2266 if (GV.hasMetadata())
2267 AddDeclAttachedMetadata(GV);
2268
2269 Stream.ExitBlock();
2270}
2271
2272void ModuleBitcodeWriter::writeFunctionMetadata(const Function &F) {
2273 if (!VE.hasMDs())
2274 return;
2275
2276 Stream.EnterSubblock(bitc::METADATA_BLOCK_ID, 3);
2277 SmallVector<uint64_t, 64> Record;
2278 writeMetadataStrings(VE.getMDStrings(), Record);
2279 writeMetadataRecords(VE.getNonMDStrings(), Record);
2280 Stream.ExitBlock();
2281}
2282
2283void ModuleBitcodeWriter::pushGlobalMetadataAttachment(
2284 SmallVectorImpl<uint64_t> &Record, const GlobalObject &GO) {
2285 // [n x [id, mdnode]]
2286 SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
2287 GO.getAllMetadata(MDs);
2288 for (const auto &I : MDs) {
2289 Record.push_back(I.first);
2290 Record.push_back(VE.getMetadataID(I.second));
2291 }
2292}
2293
2294void ModuleBitcodeWriter::writeFunctionMetadataAttachment(const Function &F) {
2295 Stream.EnterSubblock(bitc::METADATA_ATTACHMENT_ID, 3);
2296
2297 SmallVector<uint64_t, 64> Record;
2298
2299 if (F.hasMetadata()) {
2300 pushGlobalMetadataAttachment(Record, F);
2301 Stream.EmitRecord(bitc::METADATA_ATTACHMENT, Record, 0);
2302 Record.clear();
2303 }
2304
2305 // Write metadata attachments
2306 // METADATA_ATTACHMENT - [m x [value, [n x [id, mdnode]]]
2307 SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
2308 for (const BasicBlock &BB : F)
2309 for (const Instruction &I : BB) {
2310 MDs.clear();
2311 I.getAllMetadataOtherThanDebugLoc(MDs);
2312
2313 // If no metadata, ignore instruction.
2314 if (MDs.empty()) continue;
2315
2316 Record.push_back(VE.getInstructionID(&I));
2317
2318 for (unsigned i = 0, e = MDs.size(); i != e; ++i) {
2319 Record.push_back(MDs[i].first);
2320 Record.push_back(VE.getMetadataID(MDs[i].second));
2321 }
2322 Stream.EmitRecord(bitc::METADATA_ATTACHMENT, Record, 0);
2323 Record.clear();
2324 }
2325
2326 Stream.ExitBlock();
2327}
2328
2329void ModuleBitcodeWriter::writeModuleMetadataKinds() {
2330 SmallVector<uint64_t, 64> Record;
2331
2332 // Write metadata kinds
2333 // METADATA_KIND - [n x [id, name]]
2334 SmallVector<StringRef, 8> Names;
2335 M.getMDKindNames(Names);
2336
2337 if (Names.empty()) return;
2338
2339 Stream.EnterSubblock(bitc::METADATA_KIND_BLOCK_ID, 3);
2340
2341 for (unsigned MDKindID = 0, e = Names.size(); MDKindID != e; ++MDKindID) {
2342 Record.push_back(MDKindID);
2343 StringRef KName = Names[MDKindID];
2344 Record.append(KName.begin(), KName.end());
2345
2346 Stream.EmitRecord(bitc::METADATA_KIND, Record, 0);
2347 Record.clear();
2348 }
2349
2350 Stream.ExitBlock();
2351}
2352
2353void ModuleBitcodeWriter::writeOperandBundleTags() {
2354 // Write metadata kinds
2355 //
2356 // OPERAND_BUNDLE_TAGS_BLOCK_ID : N x OPERAND_BUNDLE_TAG
2357 //
2358 // OPERAND_BUNDLE_TAG - [strchr x N]
2359
2360 SmallVector<StringRef, 8> Tags;
2361 M.getOperandBundleTags(Tags);
2362
2363 if (Tags.empty())
2364 return;
2365
2366 Stream.EnterSubblock(bitc::OPERAND_BUNDLE_TAGS_BLOCK_ID, 3);
2367
2368 SmallVector<uint64_t, 64> Record;
2369
2370 for (auto Tag : Tags) {
2371 Record.append(Tag.begin(), Tag.end());
2372
2373 Stream.EmitRecord(bitc::OPERAND_BUNDLE_TAG, Record, 0);
2374 Record.clear();
2375 }
2376
2377 Stream.ExitBlock();
2378}
2379
2380void ModuleBitcodeWriter::writeSyncScopeNames() {
2381 SmallVector<StringRef, 8> SSNs;
2382 M.getContext().getSyncScopeNames(SSNs);
2383 if (SSNs.empty())
2384 return;
2385
2386 Stream.EnterSubblock(bitc::SYNC_SCOPE_NAMES_BLOCK_ID, 2);
2387
2388 SmallVector<uint64_t, 64> Record;
2389 for (auto SSN : SSNs) {
2390 Record.append(SSN.begin(), SSN.end());
2391 Stream.EmitRecord(bitc::SYNC_SCOPE_NAME, Record, 0);
2392 Record.clear();
2393 }
2394
2395 Stream.ExitBlock();
2396}
2397
2398void ModuleBitcodeWriter::writeConstants(unsigned FirstVal, unsigned LastVal,
2399 bool isGlobal) {
2400 if (FirstVal == LastVal) return;
2401
2402 Stream.EnterSubblock(bitc::CONSTANTS_BLOCK_ID, 4);
2403
2404 unsigned AggregateAbbrev = 0;
2405 unsigned String8Abbrev = 0;
2406 unsigned CString7Abbrev = 0;
2407 unsigned CString6Abbrev = 0;
2408 // If this is a constant pool for the module, emit module-specific abbrevs.
2409 if (isGlobal) {
2410 // Abbrev for CST_CODE_AGGREGATE.
2411 auto Abbv = std::make_shared<BitCodeAbbrev>();
2412 Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_AGGREGATE));
2413 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
2414 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, Log2_32_Ceil(LastVal+1)));
2415 AggregateAbbrev = Stream.EmitAbbrev(std::move(Abbv));
2416
2417 // Abbrev for CST_CODE_STRING.
2418 Abbv = std::make_shared<BitCodeAbbrev>();
2419 Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_STRING));
2420 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
2421 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));
2422 String8Abbrev = Stream.EmitAbbrev(std::move(Abbv));
2423 // Abbrev for CST_CODE_CSTRING.
2424 Abbv = std::make_shared<BitCodeAbbrev>();
2425 Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_CSTRING));
2426 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
2427 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7));
2428 CString7Abbrev = Stream.EmitAbbrev(std::move(Abbv));
2429 // Abbrev for CST_CODE_CSTRING.
2430 Abbv = std::make_shared<BitCodeAbbrev>();
2431 Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_CSTRING));
2432 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
2433 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6));
2434 CString6Abbrev = Stream.EmitAbbrev(std::move(Abbv));
2435 }
2436
2437 SmallVector<uint64_t, 64> Record;
2438
2439 const ValueEnumerator::ValueList &Vals = VE.getValues();
2440 Type *LastTy = nullptr;
2441 for (unsigned i = FirstVal; i != LastVal; ++i) {
2442 const Value *V = Vals[i].first;
2443 // If we need to switch types, do so now.
2444 if (V->getType() != LastTy) {
2445 LastTy = V->getType();
2446 Record.push_back(VE.getTypeID(LastTy));
2447 Stream.EmitRecord(bitc::CST_CODE_SETTYPE, Record,
2448 CONSTANTS_SETTYPE_ABBREV);
2449 Record.clear();
2450 }
2451
2452 if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) {
2453 Record.push_back(
2454 unsigned(IA->hasSideEffects()) | unsigned(IA->isAlignStack()) << 1 |
2455 unsigned(IA->getDialect() & 1) << 2 | unsigned(IA->canThrow()) << 3);
2456
2457 // Add the asm string.
2458 const std::string &AsmStr = IA->getAsmString();
2459 Record.push_back(AsmStr.size());
2460 Record.append(AsmStr.begin(), AsmStr.end());
2461
2462 // Add the constraint string.
2463 const std::string &ConstraintStr = IA->getConstraintString();
2464 Record.push_back(ConstraintStr.size());
2465 Record.append(ConstraintStr.begin(), ConstraintStr.end());
2466 Stream.EmitRecord(bitc::CST_CODE_INLINEASM, Record);
2467 Record.clear();
2468 continue;
2469 }
2470 const Constant *C = cast<Constant>(V);
2471 unsigned Code = -1U;
2472 unsigned AbbrevToUse = 0;
2473 if (C->isNullValue()) {
2474 Code = bitc::CST_CODE_NULL;
2475 } else if (isa<PoisonValue>(C)) {
2476 Code = bitc::CST_CODE_POISON;
2477 } else if (isa<UndefValue>(C)) {
2478 Code = bitc::CST_CODE_UNDEF;
2479 } else if (const ConstantInt *IV = dyn_cast<ConstantInt>(C)) {
2480 if (IV->getBitWidth() <= 64) {
2481 uint64_t V = IV->getSExtValue();
2482 emitSignedInt64(Record, V);
2483 Code = bitc::CST_CODE_INTEGER;
2484 AbbrevToUse = CONSTANTS_INTEGER_ABBREV;
2485 } else { // Wide integers, > 64 bits in size.
2486 emitWideAPInt(Record, IV->getValue());
2487 Code = bitc::CST_CODE_WIDE_INTEGER;
2488 }
2489 } else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(C)) {
2490 Code = bitc::CST_CODE_FLOAT;
2491 Type *Ty = CFP->getType();
2492 if (Ty->isHalfTy() || Ty->isBFloatTy() || Ty->isFloatTy() ||
2493 Ty->isDoubleTy()) {
2494 Record.push_back(CFP->getValueAPF().bitcastToAPInt().getZExtValue());
2495 } else if (Ty->isX86_FP80Ty()) {
2496 // api needed to prevent premature destruction
2497 // bits are not in the same order as a normal i80 APInt, compensate.
2498 APInt api = CFP->getValueAPF().bitcastToAPInt();
2499 const uint64_t *p = api.getRawData();
2500 Record.push_back((p[1] << 48) | (p[0] >> 16));
2501 Record.push_back(p[0] & 0xffffLL);
2502 } else if (Ty->isFP128Ty() || Ty->isPPC_FP128Ty()) {
2503 APInt api = CFP->getValueAPF().bitcastToAPInt();
2504 const uint64_t *p = api.getRawData();
2505 Record.push_back(p[0]);
2506 Record.push_back(p[1]);
2507 } else {
2508 assert(0 && "Unknown FP type!")((void)0);
2509 }
2510 } else if (isa<ConstantDataSequential>(C) &&
2511 cast<ConstantDataSequential>(C)->isString()) {
2512 const ConstantDataSequential *Str = cast<ConstantDataSequential>(C);
2513 // Emit constant strings specially.
2514 unsigned NumElts = Str->getNumElements();
2515 // If this is a null-terminated string, use the denser CSTRING encoding.
2516 if (Str->isCString()) {
2517 Code = bitc::CST_CODE_CSTRING;
2518 --NumElts; // Don't encode the null, which isn't allowed by char6.
2519 } else {
2520 Code = bitc::CST_CODE_STRING;
2521 AbbrevToUse = String8Abbrev;
2522 }
2523 bool isCStr7 = Code == bitc::CST_CODE_CSTRING;
2524 bool isCStrChar6 = Code == bitc::CST_CODE_CSTRING;
2525 for (unsigned i = 0; i != NumElts; ++i) {
2526 unsigned char V = Str->getElementAsInteger(i);
2527 Record.push_back(V);
2528 isCStr7 &= (V & 128) == 0;
2529 if (isCStrChar6)
2530 isCStrChar6 = BitCodeAbbrevOp::isChar6(V);
2531 }
2532
2533 if (isCStrChar6)
2534 AbbrevToUse = CString6Abbrev;
2535 else if (isCStr7)
2536 AbbrevToUse = CString7Abbrev;
2537 } else if (const ConstantDataSequential *CDS =
2538 dyn_cast<ConstantDataSequential>(C)) {
2539 Code = bitc::CST_CODE_DATA;
2540 Type *EltTy = CDS->getElementType();
2541 if (isa<IntegerType>(EltTy)) {
2542 for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i)
2543 Record.push_back(CDS->getElementAsInteger(i));
2544 } else {
2545 for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i)
2546 Record.push_back(
2547 CDS->getElementAsAPFloat(i).bitcastToAPInt().getLimitedValue());
2548 }
2549 } else if (isa<ConstantAggregate>(C)) {
2550 Code = bitc::CST_CODE_AGGREGATE;
2551 for (const Value *Op : C->operands())
2552 Record.push_back(VE.getValueID(Op));
2553 AbbrevToUse = AggregateAbbrev;
2554 } else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {
2555 switch (CE->getOpcode()) {
2556 default:
2557 if (Instruction::isCast(CE->getOpcode())) {
2558 Code = bitc::CST_CODE_CE_CAST;
2559 Record.push_back(getEncodedCastOpcode(CE->getOpcode()));
2560 Record.push_back(VE.getTypeID(C->getOperand(0)->getType()));
2561 Record.push_back(VE.getValueID(C->getOperand(0)));
2562 AbbrevToUse = CONSTANTS_CE_CAST_Abbrev;
2563 } else {
2564 assert(CE->getNumOperands() == 2 && "Unknown constant expr!")((void)0);
2565 Code = bitc::CST_CODE_CE_BINOP;
2566 Record.push_back(getEncodedBinaryOpcode(CE->getOpcode()));
2567 Record.push_back(VE.getValueID(C->getOperand(0)));
2568 Record.push_back(VE.getValueID(C->getOperand(1)));
2569 uint64_t Flags = getOptimizationFlags(CE);
2570 if (Flags != 0)
2571 Record.push_back(Flags);
2572 }
2573 break;
2574 case Instruction::FNeg: {
2575 assert(CE->getNumOperands() == 1 && "Unknown constant expr!")((void)0);
2576 Code = bitc::CST_CODE_CE_UNOP;
2577 Record.push_back(getEncodedUnaryOpcode(CE->getOpcode()));
2578 Record.push_back(VE.getValueID(C->getOperand(0)));
2579 uint64_t Flags = getOptimizationFlags(CE);
2580 if (Flags != 0)
2581 Record.push_back(Flags);
2582 break;
2583 }
2584 case Instruction::GetElementPtr: {
2585 Code = bitc::CST_CODE_CE_GEP;
2586 const auto *GO = cast<GEPOperator>(C);
2587 Record.push_back(VE.getTypeID(GO->getSourceElementType()));
2588 if (Optional<unsigned> Idx = GO->getInRangeIndex()) {
2589 Code = bitc::CST_CODE_CE_GEP_WITH_INRANGE_INDEX;
2590 Record.push_back((*Idx << 1) | GO->isInBounds());
2591 } else if (GO->isInBounds())
2592 Code = bitc::CST_CODE_CE_INBOUNDS_GEP;
2593 for (unsigned i = 0, e = CE->getNumOperands(); i != e; ++i) {
2594 Record.push_back(VE.getTypeID(C->getOperand(i)->getType()));
2595 Record.push_back(VE.getValueID(C->getOperand(i)));
2596 }
2597 break;
2598 }
2599 case Instruction::Select:
2600 Code = bitc::CST_CODE_CE_SELECT;
2601 Record.push_back(VE.getValueID(C->getOperand(0)));
2602 Record.push_back(VE.getValueID(C->getOperand(1)));
2603 Record.push_back(VE.getValueID(C->getOperand(2)));
2604 break;
2605 case Instruction::ExtractElement:
2606 Code = bitc::CST_CODE_CE_EXTRACTELT;
2607 Record.push_back(VE.getTypeID(C->getOperand(0)->getType()));
2608 Record.push_back(VE.getValueID(C->getOperand(0)));
2609 Record.push_back(VE.getTypeID(C->getOperand(1)->getType()));
2610 Record.push_back(VE.getValueID(C->getOperand(1)));
2611 break;
2612 case Instruction::InsertElement:
2613 Code = bitc::CST_CODE_CE_INSERTELT;
2614 Record.push_back(VE.getValueID(C->getOperand(0)));
2615 Record.push_back(VE.getValueID(C->getOperand(1)));
2616 Record.push_back(VE.getTypeID(C->getOperand(2)->getType()));
2617 Record.push_back(VE.getValueID(C->getOperand(2)));
2618 break;
2619 case Instruction::ShuffleVector:
2620 // If the return type and argument types are the same, this is a
2621 // standard shufflevector instruction. If the types are different,
2622 // then the shuffle is widening or truncating the input vectors, and
2623 // the argument type must also be encoded.
2624 if (C->getType() == C->getOperand(0)->getType()) {
2625 Code = bitc::CST_CODE_CE_SHUFFLEVEC;
2626 } else {
2627 Code = bitc::CST_CODE_CE_SHUFVEC_EX;
2628 Record.push_back(VE.getTypeID(C->getOperand(0)->getType()));
2629 }
2630 Record.push_back(VE.getValueID(C->getOperand(0)));
2631 Record.push_back(VE.getValueID(C->getOperand(1)));
2632 Record.push_back(VE.getValueID(CE->getShuffleMaskForBitcode()));
2633 break;
2634 case Instruction::ICmp:
2635 case Instruction::FCmp:
2636 Code = bitc::CST_CODE_CE_CMP;
2637 Record.push_back(VE.getTypeID(C->getOperand(0)->getType()));
2638 Record.push_back(VE.getValueID(C->getOperand(0)));
2639 Record.push_back(VE.getValueID(C->getOperand(1)));
2640 Record.push_back(CE->getPredicate());
2641 break;
2642 }
2643 } else if (const BlockAddress *BA = dyn_cast<BlockAddress>(C)) {
2644 Code = bitc::CST_CODE_BLOCKADDRESS;
2645 Record.push_back(VE.getTypeID(BA->getFunction()->getType()));
2646 Record.push_back(VE.getValueID(BA->getFunction()));
2647 Record.push_back(VE.getGlobalBasicBlockID(BA->getBasicBlock()));
2648 } else if (const auto *Equiv = dyn_cast<DSOLocalEquivalent>(C)) {
2649 Code = bitc::CST_CODE_DSO_LOCAL_EQUIVALENT;
2650 Record.push_back(VE.getTypeID(Equiv->getGlobalValue()->getType()));
2651 Record.push_back(VE.getValueID(Equiv->getGlobalValue()));
2652 } else {
2653#ifndef NDEBUG1
2654 C->dump();
2655#endif
2656 llvm_unreachable("Unknown constant!")__builtin_unreachable();
2657 }
2658 Stream.EmitRecord(Code, Record, AbbrevToUse);
2659 Record.clear();
2660 }
2661
2662 Stream.ExitBlock();
2663}
2664
2665void ModuleBitcodeWriter::writeModuleConstants() {
2666 const ValueEnumerator::ValueList &Vals = VE.getValues();
2667
2668 // Find the first constant to emit, which is the first non-globalvalue value.
2669 // We know globalvalues have been emitted by WriteModuleInfo.
2670 for (unsigned i = 0, e = Vals.size(); i != e; ++i) {
2671 if (!isa<GlobalValue>(Vals[i].first)) {
2672 writeConstants(i, Vals.size(), true);
2673 return;
2674 }
2675 }
2676}
2677
2678/// pushValueAndType - The file has to encode both the value and type id for
2679/// many values, because we need to know what type to create for forward
2680/// references. However, most operands are not forward references, so this type
2681/// field is not needed.
2682///
2683/// This function adds V's value ID to Vals. If the value ID is higher than the
2684/// instruction ID, then it is a forward reference, and it also includes the
2685/// type ID. The value ID that is written is encoded relative to the InstID.
2686bool ModuleBitcodeWriter::pushValueAndType(const Value *V, unsigned InstID,
2687 SmallVectorImpl<unsigned> &Vals) {
2688 unsigned ValID = VE.getValueID(V);
2689 // Make encoding relative to the InstID.
2690 Vals.push_back(InstID - ValID);
2691 if (ValID >= InstID) {
2692 Vals.push_back(VE.getTypeID(V->getType()));
2693 return true;
2694 }
2695 return false;
2696}
2697
2698void ModuleBitcodeWriter::writeOperandBundles(const CallBase &CS,
2699 unsigned InstID) {
2700 SmallVector<unsigned, 64> Record;
2701 LLVMContext &C = CS.getContext();
2702
2703 for (unsigned i = 0, e = CS.getNumOperandBundles(); i != e; ++i) {
2704 const auto &Bundle = CS.getOperandBundleAt(i);
2705 Record.push_back(C.getOperandBundleTagID(Bundle.getTagName()));
2706
2707 for (auto &Input : Bundle.Inputs)
2708 pushValueAndType(Input, InstID, Record);
2709
2710 Stream.EmitRecord(bitc::FUNC_CODE_OPERAND_BUNDLE, Record);
2711 Record.clear();
2712 }
2713}
2714
2715/// pushValue - Like pushValueAndType, but where the type of the value is
2716/// omitted (perhaps it was already encoded in an earlier operand).
2717void ModuleBitcodeWriter::pushValue(const Value *V, unsigned InstID,
2718 SmallVectorImpl<unsigned> &Vals) {
2719 unsigned ValID = VE.getValueID(V);
2720 Vals.push_back(InstID - ValID);
2721}
2722
2723void ModuleBitcodeWriter::pushValueSigned(const Value *V, unsigned InstID,
2724 SmallVectorImpl<uint64_t> &Vals) {
2725 unsigned ValID = VE.getValueID(V);
2726 int64_t diff = ((int32_t)InstID - (int32_t)ValID);
2727 emitSignedInt64(Vals, diff);
2728}
2729
2730/// WriteInstruction - Emit an instruction to the specified stream.
2731void ModuleBitcodeWriter::writeInstruction(const Instruction &I,
2732 unsigned InstID,
2733 SmallVectorImpl<unsigned> &Vals) {
2734 unsigned Code = 0;
2735 unsigned AbbrevToUse = 0;
2736 VE.setInstructionID(&I);
2737 switch (I.getOpcode()) {
2738 default:
2739 if (Instruction::isCast(I.getOpcode())) {
2740 Code = bitc::FUNC_CODE_INST_CAST;
2741 if (!pushValueAndType(I.getOperand(0), InstID, Vals))
2742 AbbrevToUse = FUNCTION_INST_CAST_ABBREV;
2743 Vals.push_back(VE.getTypeID(I.getType()));
2744 Vals.push_back(getEncodedCastOpcode(I.getOpcode()));
2745 } else {
2746 assert(isa<BinaryOperator>(I) && "Unknown instruction!")((void)0);
2747 Code = bitc::FUNC_CODE_INST_BINOP;
2748 if (!pushValueAndType(I.getOperand(0), InstID, Vals))
2749 AbbrevToUse = FUNCTION_INST_BINOP_ABBREV;
2750 pushValue(I.getOperand(1), InstID, Vals);
2751 Vals.push_back(getEncodedBinaryOpcode(I.getOpcode()));
2752 uint64_t Flags = getOptimizationFlags(&I);
2753 if (Flags != 0) {
2754 if (AbbrevToUse == FUNCTION_INST_BINOP_ABBREV)
2755 AbbrevToUse = FUNCTION_INST_BINOP_FLAGS_ABBREV;
2756 Vals.push_back(Flags);
2757 }
2758 }
2759 break;
2760 case Instruction::FNeg: {
2761 Code = bitc::FUNC_CODE_INST_UNOP;
2762 if (!pushValueAndType(I.getOperand(0), InstID, Vals))
2763 AbbrevToUse = FUNCTION_INST_UNOP_ABBREV;
2764 Vals.push_back(getEncodedUnaryOpcode(I.getOpcode()));
2765 uint64_t Flags = getOptimizationFlags(&I);
2766 if (Flags != 0) {
2767 if (AbbrevToUse == FUNCTION_INST_UNOP_ABBREV)
2768 AbbrevToUse = FUNCTION_INST_UNOP_FLAGS_ABBREV;
2769 Vals.push_back(Flags);
2770 }
2771 break;
2772 }
2773 case Instruction::GetElementPtr: {
2774 Code = bitc::FUNC_CODE_INST_GEP;
2775 AbbrevToUse = FUNCTION_INST_GEP_ABBREV;
2776 auto &GEPInst = cast<GetElementPtrInst>(I);
2777 Vals.push_back(GEPInst.isInBounds());
2778 Vals.push_back(VE.getTypeID(GEPInst.getSourceElementType()));
2779 for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i)
2780 pushValueAndType(I.getOperand(i), InstID, Vals);
2781 break;
2782 }
2783 case Instruction::ExtractValue: {
2784 Code = bitc::FUNC_CODE_INST_EXTRACTVAL;
2785 pushValueAndType(I.getOperand(0), InstID, Vals);
2786 const ExtractValueInst *EVI = cast<ExtractValueInst>(&I);
2787 Vals.append(EVI->idx_begin(), EVI->idx_end());
2788 break;
2789 }
2790 case Instruction::InsertValue: {
2791 Code = bitc::FUNC_CODE_INST_INSERTVAL;
2792 pushValueAndType(I.getOperand(0), InstID, Vals);
2793 pushValueAndType(I.getOperand(1), InstID, Vals);
2794 const InsertValueInst *IVI = cast<InsertValueInst>(&I);
2795 Vals.append(IVI->idx_begin(), IVI->idx_end());
2796 break;
2797 }
2798 case Instruction::Select: {
2799 Code = bitc::FUNC_CODE_INST_VSELECT;
2800 pushValueAndType(I.getOperand(1), InstID, Vals);
2801 pushValue(I.getOperand(2), InstID, Vals);
2802 pushValueAndType(I.getOperand(0), InstID, Vals);
2803 uint64_t Flags = getOptimizationFlags(&I);
2804 if (Flags != 0)
2805 Vals.push_back(Flags);
2806 break;
2807 }
2808 case Instruction::ExtractElement:
2809 Code = bitc::FUNC_CODE_INST_EXTRACTELT;
2810 pushValueAndType(I.getOperand(0), InstID, Vals);
2811 pushValueAndType(I.getOperand(1), InstID, Vals);
2812 break;
2813 case Instruction::InsertElement:
2814 Code = bitc::FUNC_CODE_INST_INSERTELT;
2815 pushValueAndType(I.getOperand(0), InstID, Vals);
2816 pushValue(I.getOperand(1), InstID, Vals);
2817 pushValueAndType(I.getOperand(2), InstID, Vals);
2818 break;
2819 case Instruction::ShuffleVector:
2820 Code = bitc::FUNC_CODE_INST_SHUFFLEVEC;
2821 pushValueAndType(I.getOperand(0), InstID, Vals);
2822 pushValue(I.getOperand(1), InstID, Vals);
2823 pushValue(cast<ShuffleVectorInst>(I).getShuffleMaskForBitcode(), InstID,
2824 Vals);
2825 break;
2826 case Instruction::ICmp:
2827 case Instruction::FCmp: {
2828 // compare returning Int1Ty or vector of Int1Ty
2829 Code = bitc::FUNC_CODE_INST_CMP2;
2830 pushValueAndType(I.getOperand(0), InstID, Vals);
2831 pushValue(I.getOperand(1), InstID, Vals);
2832 Vals.push_back(cast<CmpInst>(I).getPredicate());
2833 uint64_t Flags = getOptimizationFlags(&I);
2834 if (Flags != 0)
2835 Vals.push_back(Flags);
2836 break;
2837 }
2838
2839 case Instruction::Ret:
2840 {
2841 Code = bitc::FUNC_CODE_INST_RET;
2842 unsigned NumOperands = I.getNumOperands();
2843 if (NumOperands == 0)
2844 AbbrevToUse = FUNCTION_INST_RET_VOID_ABBREV;
2845 else if (NumOperands == 1) {
2846 if (!pushValueAndType(I.getOperand(0), InstID, Vals))
2847 AbbrevToUse = FUNCTION_INST_RET_VAL_ABBREV;
2848 } else {
2849 for (unsigned i = 0, e = NumOperands; i != e; ++i)
2850 pushValueAndType(I.getOperand(i), InstID, Vals);
2851 }
2852 }
2853 break;
2854 case Instruction::Br:
2855 {
2856 Code = bitc::FUNC_CODE_INST_BR;
2857 const BranchInst &II = cast<BranchInst>(I);
2858 Vals.push_back(VE.getValueID(II.getSuccessor(0)));
2859 if (II.isConditional()) {
2860 Vals.push_back(VE.getValueID(II.getSuccessor(1)));
2861 pushValue(II.getCondition(), InstID, Vals);
2862 }
2863 }
2864 break;
2865 case Instruction::Switch:
2866 {
2867 Code = bitc::FUNC_CODE_INST_SWITCH;
2868 const SwitchInst &SI = cast<SwitchInst>(I);
2869 Vals.push_back(VE.getTypeID(SI.getCondition()->getType()));
2870 pushValue(SI.getCondition(), InstID, Vals);
2871 Vals.push_back(VE.getValueID(SI.getDefaultDest()));
2872 for (auto Case : SI.cases()) {
2873 Vals.push_back(VE.getValueID(Case.getCaseValue()));
2874 Vals.push_back(VE.getValueID(Case.getCaseSuccessor()));
2875 }
2876 }
2877 break;
2878 case Instruction::IndirectBr:
2879 Code = bitc::FUNC_CODE_INST_INDIRECTBR;
2880 Vals.push_back(VE.getTypeID(I.getOperand(0)->getType()));
2881 // Encode the address operand as relative, but not the basic blocks.
2882 pushValue(I.getOperand(0), InstID, Vals);
2883 for (unsigned i = 1, e = I.getNumOperands(); i != e; ++i)
2884 Vals.push_back(VE.getValueID(I.getOperand(i)));
2885 break;
2886
2887 case Instruction::Invoke: {
2888 const InvokeInst *II = cast<InvokeInst>(&I);
2889 const Value *Callee = II->getCalledOperand();
2890 FunctionType *FTy = II->getFunctionType();
2891
2892 if (II->hasOperandBundles())
2893 writeOperandBundles(*II, InstID);
2894
2895 Code = bitc::FUNC_CODE_INST_INVOKE;
2896
2897 Vals.push_back(VE.getAttributeListID(II->getAttributes()));
2898 Vals.push_back(II->getCallingConv() | 1 << 13);
2899 Vals.push_back(VE.getValueID(II->getNormalDest()));
2900 Vals.push_back(VE.getValueID(II->getUnwindDest()));
2901 Vals.push_back(VE.getTypeID(FTy));
2902 pushValueAndType(Callee, InstID, Vals);
2903
2904 // Emit value #'s for the fixed parameters.
2905 for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i)
2906 pushValue(I.getOperand(i), InstID, Vals); // fixed param.
2907
2908 // Emit type/value pairs for varargs params.
2909 if (FTy->isVarArg()) {
2910 for (unsigned i = FTy->getNumParams(), e = II->getNumArgOperands();
2911 i != e; ++i)
2912 pushValueAndType(I.getOperand(i), InstID, Vals); // vararg
2913 }
2914 break;
2915 }
2916 case Instruction::Resume:
2917 Code = bitc::FUNC_CODE_INST_RESUME;
2918 pushValueAndType(I.getOperand(0), InstID, Vals);
2919 break;
2920 case Instruction::CleanupRet: {
2921 Code = bitc::FUNC_CODE_INST_CLEANUPRET;
2922 const auto &CRI = cast<CleanupReturnInst>(I);
2923 pushValue(CRI.getCleanupPad(), InstID, Vals);
2924 if (CRI.hasUnwindDest())
2925 Vals.push_back(VE.getValueID(CRI.getUnwindDest()));
2926 break;
2927 }
2928 case Instruction::CatchRet: {
2929 Code = bitc::FUNC_CODE_INST_CATCHRET;
2930 const auto &CRI = cast<CatchReturnInst>(I);
2931 pushValue(CRI.getCatchPad(), InstID, Vals);
2932 Vals.push_back(VE.getValueID(CRI.getSuccessor()));
2933 break;
2934 }
2935 case Instruction::CleanupPad:
2936 case Instruction::CatchPad: {
2937 const auto &FuncletPad = cast<FuncletPadInst>(I);
2938 Code = isa<CatchPadInst>(FuncletPad) ? bitc::FUNC_CODE_INST_CATCHPAD
2939 : bitc::FUNC_CODE_INST_CLEANUPPAD;
2940 pushValue(FuncletPad.getParentPad(), InstID, Vals);
2941
2942 unsigned NumArgOperands = FuncletPad.getNumArgOperands();
2943 Vals.push_back(NumArgOperands);
2944 for (unsigned Op = 0; Op != NumArgOperands; ++Op)
2945 pushValueAndType(FuncletPad.getArgOperand(Op), InstID, Vals);
2946 break;
2947 }
2948 case Instruction::CatchSwitch: {
2949 Code = bitc::FUNC_CODE_INST_CATCHSWITCH;
2950 const auto &CatchSwitch = cast<CatchSwitchInst>(I);
2951
2952 pushValue(CatchSwitch.getParentPad(), InstID, Vals);
2953
2954 unsigned NumHandlers = CatchSwitch.getNumHandlers();
2955 Vals.push_back(NumHandlers);
2956 for (const BasicBlock *CatchPadBB : CatchSwitch.handlers())
2957 Vals.push_back(VE.getValueID(CatchPadBB));
2958
2959 if (CatchSwitch.hasUnwindDest())
2960 Vals.push_back(VE.getValueID(CatchSwitch.getUnwindDest()));
2961 break;
2962 }
2963 case Instruction::CallBr: {
2964 const CallBrInst *CBI = cast<CallBrInst>(&I);
2965 const Value *Callee = CBI->getCalledOperand();
2966 FunctionType *FTy = CBI->getFunctionType();
2967
2968 if (CBI->hasOperandBundles())
2969 writeOperandBundles(*CBI, InstID);
2970
2971 Code = bitc::FUNC_CODE_INST_CALLBR;
2972
2973 Vals.push_back(VE.getAttributeListID(CBI->getAttributes()));
2974
2975 Vals.push_back(CBI->getCallingConv() << bitc::CALL_CCONV |
2976 1 << bitc::CALL_EXPLICIT_TYPE);
2977
2978 Vals.push_back(VE.getValueID(CBI->getDefaultDest()));
2979 Vals.push_back(CBI->getNumIndirectDests());
2980 for (unsigned i = 0, e = CBI->getNumIndirectDests(); i != e; ++i)
2981 Vals.push_back(VE.getValueID(CBI->getIndirectDest(i)));
2982
2983 Vals.push_back(VE.getTypeID(FTy));
2984 pushValueAndType(Callee, InstID, Vals);
2985
2986 // Emit value #'s for the fixed parameters.
2987 for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i)
2988 pushValue(I.getOperand(i), InstID, Vals); // fixed param.
2989
2990 // Emit type/value pairs for varargs params.
2991 if (FTy->isVarArg()) {
2992 for (unsigned i = FTy->getNumParams(), e = CBI->getNumArgOperands();
2993 i != e; ++i)
2994 pushValueAndType(I.getOperand(i), InstID, Vals); // vararg
2995 }
2996 break;
2997 }
2998 case Instruction::Unreachable:
2999 Code = bitc::FUNC_CODE_INST_UNREACHABLE;
3000 AbbrevToUse = FUNCTION_INST_UNREACHABLE_ABBREV;
3001 break;
3002
3003 case Instruction::PHI: {
3004 const PHINode &PN = cast<PHINode>(I);
3005 Code = bitc::FUNC_CODE_INST_PHI;
3006 // With the newer instruction encoding, forward references could give
3007 // negative valued IDs. This is most common for PHIs, so we use
3008 // signed VBRs.
3009 SmallVector<uint64_t, 128> Vals64;
3010 Vals64.push_back(VE.getTypeID(PN.getType()));
3011 for (unsigned i = 0, e = PN.getNumIncomingValues(); i != e; ++i) {
3012 pushValueSigned(PN.getIncomingValue(i), InstID, Vals64);
3013 Vals64.push_back(VE.getValueID(PN.getIncomingBlock(i)));
3014 }
3015
3016 uint64_t Flags = getOptimizationFlags(&I);
3017 if (Flags != 0)
3018 Vals64.push_back(Flags);
3019
3020 // Emit a Vals64 vector and exit.
3021 Stream.EmitRecord(Code, Vals64, AbbrevToUse);
3022 Vals64.clear();
3023 return;
3024 }
3025
3026 case Instruction::LandingPad: {
3027 const LandingPadInst &LP = cast<LandingPadInst>(I);
3028 Code = bitc::FUNC_CODE_INST_LANDINGPAD;
3029 Vals.push_back(VE.getTypeID(LP.getType()));
3030 Vals.push_back(LP.isCleanup());
3031 Vals.push_back(LP.getNumClauses());
3032 for (unsigned I = 0, E = LP.getNumClauses(); I != E; ++I) {
3033 if (LP.isCatch(I))
3034 Vals.push_back(LandingPadInst::Catch);
3035 else
3036 Vals.push_back(LandingPadInst::Filter);
3037 pushValueAndType(LP.getClause(I), InstID, Vals);
3038 }
3039 break;
3040 }
3041
3042 case Instruction::Alloca: {
3043 Code = bitc::FUNC_CODE_INST_ALLOCA;
3044 const AllocaInst &AI = cast<AllocaInst>(I);
3045 Vals.push_back(VE.getTypeID(AI.getAllocatedType()));
3046 Vals.push_back(VE.getTypeID(I.getOperand(0)->getType()));
3047 Vals.push_back(VE.getValueID(I.getOperand(0))); // size.
3048 using APV = AllocaPackedValues;
3049 unsigned Record = 0;
3050 Bitfield::set<APV::Align>(Record, getEncodedAlign(AI.getAlign()));
3051 Bitfield::set<APV::UsedWithInAlloca>(Record, AI.isUsedWithInAlloca());
3052 Bitfield::set<APV::ExplicitType>(Record, true);
3053 Bitfield::set<APV::SwiftError>(Record, AI.isSwiftError());
3054 Vals.push_back(Record);
3055 break;
3056 }
3057
3058 case Instruction::Load:
3059 if (cast<LoadInst>(I).isAtomic()) {
3060 Code = bitc::FUNC_CODE_INST_LOADATOMIC;
3061 pushValueAndType(I.getOperand(0), InstID, Vals);
3062 } else {
3063 Code = bitc::FUNC_CODE_INST_LOAD;
3064 if (!pushValueAndType(I.getOperand(0), InstID, Vals)) // ptr
3065 AbbrevToUse = FUNCTION_INST_LOAD_ABBREV;
3066 }
3067 Vals.push_back(VE.getTypeID(I.getType()));
3068 Vals.push_back(getEncodedAlign(cast<LoadInst>(I).getAlign()));
3069 Vals.push_back(cast<LoadInst>(I).isVolatile());
3070 if (cast<LoadInst>(I).isAtomic()) {
3071 Vals.push_back(getEncodedOrdering(cast<LoadInst>(I).getOrdering()));
3072 Vals.push_back(getEncodedSyncScopeID(cast<LoadInst>(I).getSyncScopeID()));
3073 }
3074 break;
3075 case Instruction::Store:
3076 if (cast<StoreInst>(I).isAtomic())
3077 Code = bitc::FUNC_CODE_INST_STOREATOMIC;
3078 else
3079 Code = bitc::FUNC_CODE_INST_STORE;
3080 pushValueAndType(I.getOperand(1), InstID, Vals); // ptrty + ptr
3081 pushValueAndType(I.getOperand(0), InstID, Vals); // valty + val
3082 Vals.push_back(getEncodedAlign(cast<StoreInst>(I).getAlign()));
3083 Vals.push_back(cast<StoreInst>(I).isVolatile());
3084 if (cast<StoreInst>(I).isAtomic()) {
3085 Vals.push_back(getEncodedOrdering(cast<StoreInst>(I).getOrdering()));
3086 Vals.push_back(
3087 getEncodedSyncScopeID(cast<StoreInst>(I).getSyncScopeID()));
3088 }
3089 break;
3090 case Instruction::AtomicCmpXchg:
3091 Code = bitc::FUNC_CODE_INST_CMPXCHG;
3092 pushValueAndType(I.getOperand(0), InstID, Vals); // ptrty + ptr
3093 pushValueAndType(I.getOperand(1), InstID, Vals); // cmp.
3094 pushValue(I.getOperand(2), InstID, Vals); // newval.
3095 Vals.push_back(cast<AtomicCmpXchgInst>(I).isVolatile());
3096 Vals.push_back(
3097 getEncodedOrdering(cast<AtomicCmpXchgInst>(I).getSuccessOrdering()));
3098 Vals.push_back(
3099 getEncodedSyncScopeID(cast<AtomicCmpXchgInst>(I).getSyncScopeID()));
3100 Vals.push_back(
3101 getEncodedOrdering(cast<AtomicCmpXchgInst>(I).getFailureOrdering()));
3102 Vals.push_back(cast<AtomicCmpXchgInst>(I).isWeak());
3103 Vals.push_back(getEncodedAlign(cast<AtomicCmpXchgInst>(I).getAlign()));
3104 break;
3105 case Instruction::AtomicRMW:
3106 Code = bitc::FUNC_CODE_INST_ATOMICRMW;
3107 pushValueAndType(I.getOperand(0), InstID, Vals); // ptrty + ptr
3108 pushValueAndType(I.getOperand(1), InstID, Vals); // valty + val
3109 Vals.push_back(
3110 getEncodedRMWOperation(cast<AtomicRMWInst>(I).getOperation()));
3111 Vals.push_back(cast<AtomicRMWInst>(I).isVolatile());
3112 Vals.push_back(getEncodedOrdering(cast<AtomicRMWInst>(I).getOrdering()));
3113 Vals.push_back(
3114 getEncodedSyncScopeID(cast<AtomicRMWInst>(I).getSyncScopeID()));
3115 Vals.push_back(getEncodedAlign(cast<AtomicRMWInst>(I).getAlign()));
3116 break;
3117 case Instruction::Fence:
3118 Code = bitc::FUNC_CODE_INST_FENCE;
3119 Vals.push_back(getEncodedOrdering(cast<FenceInst>(I).getOrdering()));
3120 Vals.push_back(getEncodedSyncScopeID(cast<FenceInst>(I).getSyncScopeID()));
3121 break;
3122 case Instruction::Call: {
3123 const CallInst &CI = cast<CallInst>(I);
3124 FunctionType *FTy = CI.getFunctionType();
3125
3126 if (CI.hasOperandBundles())
3127 writeOperandBundles(CI, InstID);
3128
3129 Code = bitc::FUNC_CODE_INST_CALL;
3130
3131 Vals.push_back(VE.getAttributeListID(CI.getAttributes()));
3132
3133 unsigned Flags = getOptimizationFlags(&I);
3134 Vals.push_back(CI.getCallingConv() << bitc::CALL_CCONV |
3135 unsigned(CI.isTailCall()) << bitc::CALL_TAIL |
3136 unsigned(CI.isMustTailCall()) << bitc::CALL_MUSTTAIL |
3137 1 << bitc::CALL_EXPLICIT_TYPE |
3138 unsigned(CI.isNoTailCall()) << bitc::CALL_NOTAIL |
3139 unsigned(Flags != 0) << bitc::CALL_FMF);
3140 if (Flags != 0)
3141 Vals.push_back(Flags);
3142
3143 Vals.push_back(VE.getTypeID(FTy));
3144 pushValueAndType(CI.getCalledOperand(), InstID, Vals); // Callee
3145
3146 // Emit value #'s for the fixed parameters.
3147 for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i) {
3148 // Check for labels (can happen with asm labels).
3149 if (FTy->getParamType(i)->isLabelTy())
3150 Vals.push_back(VE.getValueID(CI.getArgOperand(i)));
3151 else
3152 pushValue(CI.getArgOperand(i), InstID, Vals); // fixed param.
3153 }
3154
3155 // Emit type/value pairs for varargs params.
3156 if (FTy->isVarArg()) {
3157 for (unsigned i = FTy->getNumParams(), e = CI.getNumArgOperands();
3158 i != e; ++i)
3159 pushValueAndType(CI.getArgOperand(i), InstID, Vals); // varargs
3160 }
3161 break;
3162 }
3163 case Instruction::VAArg:
3164 Code = bitc::FUNC_CODE_INST_VAARG;
3165 Vals.push_back(VE.getTypeID(I.getOperand(0)->getType())); // valistty
3166 pushValue(I.getOperand(0), InstID, Vals); // valist.
3167 Vals.push_back(VE.getTypeID(I.getType())); // restype.
3168 break;
3169 case Instruction::Freeze:
3170 Code = bitc::FUNC_CODE_INST_FREEZE;
3171 pushValueAndType(I.getOperand(0), InstID, Vals);
3172 break;
3173 }
3174
3175 Stream.EmitRecord(Code, Vals, AbbrevToUse);
3176 Vals.clear();
3177}
3178
3179/// Write a GlobalValue VST to the module. The purpose of this data structure is
3180/// to allow clients to efficiently find the function body.
3181void ModuleBitcodeWriter::writeGlobalValueSymbolTable(
3182 DenseMap<const Function *, uint64_t> &FunctionToBitcodeIndex) {
3183 // Get the offset of the VST we are writing, and backpatch it into
3184 // the VST forward declaration record.
3185 uint64_t VSTOffset = Stream.GetCurrentBitNo();
3186 // The BitcodeStartBit was the stream offset of the identification block.
3187 VSTOffset -= bitcodeStartBit();
3188 assert((VSTOffset & 31) == 0 && "VST block not 32-bit aligned")((void)0);
3189 // Note that we add 1 here because the offset is relative to one word
3190 // before the start of the identification block, which was historically
3191 // always the start of the regular bitcode header.
3192 Stream.BackpatchWord(VSTOffsetPlaceholder, VSTOffset / 32 + 1);
3193
3194 Stream.EnterSubblock(bitc::VALUE_SYMTAB_BLOCK_ID, 4);
3195
3196 auto Abbv = std::make_shared<BitCodeAbbrev>();
3197 Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_FNENTRY));
3198 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // value id
3199 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // funcoffset
3200 unsigned FnEntryAbbrev = Stream.EmitAbbrev(std::move(Abbv));
3201
3202 for (const Function &F : M) {
3203 uint64_t Record[2];
3204
3205 if (F.isDeclaration())
18
←
Assuming the condition is false
→
19
←
Taking false branch
→
3206 continue;
3207
3208 Record[0] = VE.getValueID(&F);
3209
3210 // Save the word offset of the function (from the start of the
3211 // actual bitcode written to the stream).
3212 uint64_t BitcodeIndex = FunctionToBitcodeIndex[&F] - bitcodeStartBit();
3213 assert((BitcodeIndex & 31) == 0 && "function block not 32-bit aligned")((void)0);
3214 // Note that we add 1 here because the offset is relative to one word
3215 // before the start of the identification block, which was historically
3216 // always the start of the regular bitcode header.
3217 Record[1] = BitcodeIndex / 32 + 1;
3218
3219 Stream.EmitRecord(bitc::VST_CODE_FNENTRY, Record, FnEntryAbbrev);
20
←
Calling 'BitstreamWriter::EmitRecord'
→
3220 }
3221
3222 Stream.ExitBlock();
3223}
3224
3225/// Emit names for arguments, instructions and basic blocks in a function.
3226void ModuleBitcodeWriter::writeFunctionLevelValueSymbolTable(
3227 const ValueSymbolTable &VST) {
3228 if (VST.empty())
3229 return;
3230
3231 Stream.EnterSubblock(bitc::VALUE_SYMTAB_BLOCK_ID, 4);
3232
3233 // FIXME: Set up the abbrev, we know how many values there are!
3234 // FIXME: We know if the type names can use 7-bit ascii.
3235 SmallVector<uint64_t, 64> NameVals;
3236
3237 for (const ValueName &Name : VST) {
3238 // Figure out the encoding to use for the name.
3239 StringEncoding Bits = getStringEncoding(Name.getKey());
3240
3241 unsigned AbbrevToUse = VST_ENTRY_8_ABBREV;
3242 NameVals.push_back(VE.getValueID(Name.getValue()));
3243
3244 // VST_CODE_ENTRY: [valueid, namechar x N]
3245 // VST_CODE_BBENTRY: [bbid, namechar x N]
3246 unsigned Code;
3247 if (isa<BasicBlock>(Name.getValue())) {
3248 Code = bitc::VST_CODE_BBENTRY;
3249 if (Bits == SE_Char6)
3250 AbbrevToUse = VST_BBENTRY_6_ABBREV;
3251 } else {
3252 Code = bitc::VST_CODE_ENTRY;
3253 if (Bits == SE_Char6)
3254 AbbrevToUse = VST_ENTRY_6_ABBREV;
3255 else if (Bits == SE_Fixed7)
3256 AbbrevToUse = VST_ENTRY_7_ABBREV;
3257 }
3258
3259 for (const auto P : Name.getKey())
3260 NameVals.push_back((unsigned char)P);
3261
3262 // Emit the finished record.
3263 Stream.EmitRecord(Code, NameVals, AbbrevToUse);
3264 NameVals.clear();
3265 }
3266
3267 Stream.ExitBlock();
3268}
3269
3270void ModuleBitcodeWriter::writeUseList(UseListOrder &&Order) {
3271 assert(Order.Shuffle.size() >= 2 && "Shuffle too small")((void)0);
3272 unsigned Code;
3273 if (isa<BasicBlock>(Order.V))
3274 Code = bitc::USELIST_CODE_BB;
3275 else
3276 Code = bitc::USELIST_CODE_DEFAULT;
3277
3278 SmallVector<uint64_t, 64> Record(Order.Shuffle.begin(), Order.Shuffle.end());
3279 Record.push_back(VE.getValueID(Order.V));
3280 Stream.EmitRecord(Code, Record);
3281}
3282
3283void ModuleBitcodeWriter::writeUseListBlock(const Function *F) {
3284 assert(VE.shouldPreserveUseListOrder() &&((void)0)
3285 "Expected to be preserving use-list order")((void)0);
3286
3287 auto hasMore = [&]() {
3288 return !VE.UseListOrders.empty() && VE.UseListOrders.back().F == F;
3289 };
3290 if (!hasMore())
3291 // Nothing to do.
3292 return;
3293
3294 Stream.EnterSubblock(bitc::USELIST_BLOCK_ID, 3);
3295 while (hasMore()) {
3296 writeUseList(std::move(VE.UseListOrders.back()));
3297 VE.UseListOrders.pop_back();
3298 }
3299 Stream.ExitBlock();
3300}
3301
3302/// Emit a function body to the module stream.
3303void ModuleBitcodeWriter::writeFunction(
3304 const Function &F,
3305 DenseMap<const Function *, uint64_t> &FunctionToBitcodeIndex) {
3306 // Save the bitcode index of the start of this function block for recording
3307 // in the VST.
3308 FunctionToBitcodeIndex[&F] = Stream.GetCurrentBitNo();
3309
3310 Stream.EnterSubblock(bitc::FUNCTION_BLOCK_ID, 4);
3311 VE.incorporateFunction(F);
3312
3313 SmallVector<unsigned, 64> Vals;
3314
3315 // Emit the number of basic blocks, so the reader can create them ahead of
3316 // time.
3317 Vals.push_back(VE.getBasicBlocks().size());
3318 Stream.EmitRecord(bitc::FUNC_CODE_DECLAREBLOCKS, Vals);
3319 Vals.clear();
3320
3321 // If there are function-local constants, emit them now.
3322 unsigned CstStart, CstEnd;
3323 VE.getFunctionConstantRange(CstStart, CstEnd);
3324 writeConstants(CstStart, CstEnd, false);
3325
3326 // If there is function-local metadata, emit it now.
3327 writeFunctionMetadata(F);
3328
3329 // Keep a running idea of what the instruction ID is.
3330 unsigned InstID = CstEnd;
3331
3332 bool NeedsMetadataAttachment = F.hasMetadata();
3333
3334 DILocation *LastDL = nullptr;
3335 // Finally, emit all the instructions, in order.
3336 for (Function::const_iterator BB = F.begin(), E = F.end(); BB != E; ++BB)
3337 for (BasicBlock::const_iterator I = BB->begin(), E = BB->end();
3338 I != E; ++I) {
3339 writeInstruction(*I, InstID, Vals);
3340
3341 if (!I->getType()->isVoidTy())
3342 ++InstID;
3343
3344 // If the instruction has metadata, write a metadata attachment later.
3345 NeedsMetadataAttachment |= I->hasMetadataOtherThanDebugLoc();
3346
3347 // If the instruction has a debug location, emit it.
3348 DILocation *DL = I->getDebugLoc();
3349 if (!DL)
3350 continue;
3351
3352 if (DL == LastDL) {
3353 // Just repeat the same debug loc as last time.
3354 Stream.EmitRecord(bitc::FUNC_CODE_DEBUG_LOC_AGAIN, Vals);
3355 continue;
3356 }
3357
3358 Vals.push_back(DL->getLine());
3359 Vals.push_back(DL->getColumn());
3360 Vals.push_back(VE.getMetadataOrNullID(DL->getScope()));
3361 Vals.push_back(VE.getMetadataOrNullID(DL->getInlinedAt()));
3362 Vals.push_back(DL->isImplicitCode());
3363 Stream.EmitRecord(bitc::FUNC_CODE_DEBUG_LOC, Vals);
3364 Vals.clear();
3365
3366 LastDL = DL;
3367 }
3368
3369 // Emit names for all the instructions etc.
3370 if (auto *Symtab = F.getValueSymbolTable())
3371 writeFunctionLevelValueSymbolTable(*Symtab);
3372
3373 if (NeedsMetadataAttachment)
3374 writeFunctionMetadataAttachment(F);
3375 if (VE.shouldPreserveUseListOrder())
3376 writeUseListBlock(&F);
3377 VE.purgeFunction();
3378 Stream.ExitBlock();
3379}
3380
3381// Emit blockinfo, which defines the standard abbreviations etc.
3382void ModuleBitcodeWriter::writeBlockInfo() {
3383 // We only want to emit block info records for blocks that have multiple
3384 // instances: CONSTANTS_BLOCK, FUNCTION_BLOCK and VALUE_SYMTAB_BLOCK.
3385 // Other blocks can define their abbrevs inline.
3386 Stream.EnterBlockInfoBlock();
3387
3388 { // 8-bit fixed-width VST_CODE_ENTRY/VST_CODE_BBENTRY strings.
3389 auto Abbv = std::make_shared<BitCodeAbbrev>();
3390 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3));
3391 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
3392 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
3393 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));
3394 if (Stream.EmitBlockInfoAbbrev(bitc::VALUE_SYMTAB_BLOCK_ID, Abbv) !=
3395 VST_ENTRY_8_ABBREV)
3396 llvm_unreachable("Unexpected abbrev ordering!")__builtin_unreachable();
3397 }
3398
3399 { // 7-bit fixed width VST_CODE_ENTRY strings.
3400 auto Abbv = std::make_shared<BitCodeAbbrev>();
3401 Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_ENTRY));
3402 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
3403 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
3404 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7));
3405 if (Stream.EmitBlockInfoAbbrev(bitc::VALUE_SYMTAB_BLOCK_ID, Abbv) !=
3406 VST_ENTRY_7_ABBREV)
3407 llvm_unreachable("Unexpected abbrev ordering!")__builtin_unreachable();
3408 }
3409 { // 6-bit char6 VST_CODE_ENTRY strings.
3410 auto Abbv = std::make_shared<BitCodeAbbrev>();
3411 Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_ENTRY));
3412 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
3413 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
3414 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6));
3415 if (Stream.EmitBlockInfoAbbrev(bitc::VALUE_SYMTAB_BLOCK_ID, Abbv) !=
3416 VST_ENTRY_6_ABBREV)
3417 llvm_unreachable("Unexpected abbrev ordering!")__builtin_unreachable();
3418 }
3419 { // 6-bit char6 VST_CODE_BBENTRY strings.
3420 auto Abbv = std::make_shared<BitCodeAbbrev>();
3421 Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_BBENTRY));
3422 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
3423 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
3424 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6));
3425 if (Stream.EmitBlockInfoAbbrev(bitc::VALUE_SYMTAB_BLOCK_ID, Abbv) !=
3426 VST_BBENTRY_6_ABBREV)
3427 llvm_unreachable("Unexpected abbrev ordering!")__builtin_unreachable();
3428 }
3429
3430 { // SETTYPE abbrev for CONSTANTS_BLOCK.
3431 auto Abbv = std::make_shared<BitCodeAbbrev>();
3432 Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_SETTYPE));
3433 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
3434 VE.computeBitsRequiredForTypeIndicies()));
3435 if (Stream.EmitBlockInfoAbbrev(bitc::CONSTANTS_BLOCK_ID, Abbv) !=
3436 CONSTANTS_SETTYPE_ABBREV)
3437 llvm_unreachable("Unexpected abbrev ordering!")__builtin_unreachable();
3438 }
3439
3440 { // INTEGER abbrev for CONSTANTS_BLOCK.
3441 auto Abbv = std::make_shared<BitCodeAbbrev>();
3442 Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_INTEGER));
3443 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
3444 if (Stream.EmitBlockInfoAbbrev(bitc::CONSTANTS_BLOCK_ID, Abbv) !=
3445 CONSTANTS_INTEGER_ABBREV)
3446 llvm_unreachable("Unexpected abbrev ordering!")__builtin_unreachable();
3447 }
3448
3449 { // CE_CAST abbrev for CONSTANTS_BLOCK.
3450 auto Abbv = std::make_shared<BitCodeAbbrev>();
3451 Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_CE_CAST));
3452 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // cast opc
3453 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, // typeid
3454 VE.computeBitsRequiredForTypeIndicies()));
3455 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // value id
3456
3457 if (Stream.EmitBlockInfoAbbrev(bitc::CONSTANTS_BLOCK_ID, Abbv) !=
3458 CONSTANTS_CE_CAST_Abbrev)
3459 llvm_unreachable("Unexpected abbrev ordering!")__builtin_unreachable();
3460 }
3461 { // NULL abbrev for CONSTANTS_BLOCK.
3462 auto Abbv = std::make_shared<BitCodeAbbrev>();
3463 Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_NULL));
3464 if (Stream.EmitBlockInfoAbbrev(bitc::CONSTANTS_BLOCK_ID, Abbv) !=
3465 CONSTANTS_NULL_Abbrev)
3466 llvm_unreachable("Unexpected abbrev ordering!")__builtin_unreachable();
3467 }
3468
3469 // FIXME: This should only use space for first class types!
3470
3471 { // INST_LOAD abbrev for FUNCTION_BLOCK.
3472 auto Abbv = std::make_shared<BitCodeAbbrev>();
3473 Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_LOAD));
3474 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Ptr
3475 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, // dest ty
3476 VE.computeBitsRequiredForTypeIndicies()));
3477 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // Align
3478 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // volatile
3479 if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) !=
3480 FUNCTION_INST_LOAD_ABBREV)
3481 llvm_unreachable("Unexpected abbrev ordering!")__builtin_unreachable();
3482 }
3483 { // INST_UNOP abbrev for FUNCTION_BLOCK.
3484 auto Abbv = std::make_shared<BitCodeAbbrev>();
3485 Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_UNOP));
3486 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LHS
3487 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // opc
3488 if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) !=
3489 FUNCTION_INST_UNOP_ABBREV)
3490 llvm_unreachable("Unexpected abbrev ordering!")__builtin_unreachable();
3491 }
3492 { // INST_UNOP_FLAGS abbrev for FUNCTION_BLOCK.
3493 auto Abbv = std::make_shared<BitCodeAbbrev>();
3494 Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_UNOP));
3495 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LHS
3496 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // opc
3497 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8)); // flags
3498 if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) !=
3499 FUNCTION_INST_UNOP_FLAGS_ABBREV)
3500 llvm_unreachable("Unexpected abbrev ordering!")__builtin_unreachable();
3501 }
3502 { // INST_BINOP abbrev for FUNCTION_BLOCK.
3503 auto Abbv = std::make_shared<BitCodeAbbrev>();
3504 Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_BINOP));
3505 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LHS
3506 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // RHS
3507 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // opc
3508 if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) !=
3509 FUNCTION_INST_BINOP_ABBREV)
3510 llvm_unreachable("Unexpected abbrev ordering!")__builtin_unreachable();
3511 }
3512 { // INST_BINOP_FLAGS abbrev for FUNCTION_BLOCK.
3513 auto Abbv = std::make_shared<BitCodeAbbrev>();
3514 Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_BINOP));
3515 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LHS
3516 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // RHS
3517 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // opc
3518 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8)); // flags
3519 if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) !=
3520 FUNCTION_INST_BINOP_FLAGS_ABBREV)
3521 llvm_unreachable("Unexpected abbrev ordering!")__builtin_unreachable();
3522 }
3523 { // INST_CAST abbrev for FUNCTION_BLOCK.
3524 auto Abbv = std::make_shared<BitCodeAbbrev>();
3525 Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_CAST));
3526 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // OpVal
3527 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, // dest ty
3528 VE.computeBitsRequiredForTypeIndicies()));
3529 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // opc
3530 if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) !=
3531 FUNCTION_INST_CAST_ABBREV)
3532 llvm_unreachable("Unexpected abbrev ordering!")__builtin_unreachable();
3533 }
3534
3535 { // INST_RET abbrev for FUNCTION_BLOCK.
3536 auto Abbv = std::make_shared<BitCodeAbbrev>();
3537 Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_RET));
3538 if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) !=
3539 FUNCTION_INST_RET_VOID_ABBREV)
3540 llvm_unreachable("Unexpected abbrev ordering!")__builtin_unreachable();
3541 }
3542 { // INST_RET abbrev for FUNCTION_BLOCK.
3543 auto Abbv = std::make_shared<BitCodeAbbrev>();
3544 Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_RET));
3545 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ValID
3546 if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) !=
3547 FUNCTION_INST_RET_VAL_ABBREV)
3548 llvm_unreachable("Unexpected abbrev ordering!")__builtin_unreachable();
3549 }
3550 { // INST_UNREACHABLE abbrev for FUNCTION_BLOCK.
3551 auto Abbv = std::make_shared<BitCodeAbbrev>();
3552 Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_UNREACHABLE));
3553 if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) !=
3554 FUNCTION_INST_UNREACHABLE_ABBREV)
3555 llvm_unreachable("Unexpected abbrev ordering!")__builtin_unreachable();
3556 }
3557 {
3558 auto Abbv = std::make_shared<BitCodeAbbrev>();
3559 Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_GEP));
3560 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
3561 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, // dest ty
3562 Log2_32_Ceil(VE.getTypes().size() + 1)));
3563 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
3564 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
3565 if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) !=
3566 FUNCTION_INST_GEP_ABBREV)
3567 llvm_unreachable("Unexpected abbrev ordering!")__builtin_unreachable();
3568 }
3569
3570 Stream.ExitBlock();
3571}
3572
3573/// Write the module path strings, currently only used when generating
3574/// a combined index file.
3575void IndexBitcodeWriter::writeModStrings() {
3576 Stream.EnterSubblock(bitc::MODULE_STRTAB_BLOCK_ID, 3);
3577
3578 // TODO: See which abbrev sizes we actually need to emit
3579
3580 // 8-bit fixed-width MST_ENTRY strings.
3581 auto Abbv = std::make_shared<BitCodeAbbrev>();
3582 Abbv->Add(BitCodeAbbrevOp(bitc::MST_CODE_ENTRY));
3583 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
3584 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
3585 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));
3586 unsigned Abbrev8Bit = Stream.EmitAbbrev(std::move(Abbv));
3587
3588 // 7-bit fixed width MST_ENTRY strings.
3589 Abbv = std::make_shared<BitCodeAbbrev>();
3590 Abbv->Add(BitCodeAbbrevOp(bitc::MST_CODE_ENTRY));
3591 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
3592 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
3593 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7));
3594 unsigned Abbrev7Bit = Stream.EmitAbbrev(std::move(Abbv));
3595
3596 // 6-bit char6 MST_ENTRY strings.
3597 Abbv = std::make_shared<BitCodeAbbrev>();
3598 Abbv->Add(BitCodeAbbrevOp(bitc::MST_CODE_ENTRY));
3599 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
3600 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
3601 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6));
3602 unsigned Abbrev6Bit = Stream.EmitAbbrev(std::move(Abbv));
3603
3604 // Module Hash, 160 bits SHA1. Optionally, emitted after each MST_CODE_ENTRY.
3605 Abbv = std::make_shared<BitCodeAbbrev>();
3606 Abbv->Add(BitCodeAbbrevOp(bitc::MST_CODE_HASH));
3607 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3608 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3609 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3610 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3611 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3612 unsigned AbbrevHash = Stream.EmitAbbrev(std::move(Abbv));
3613
3614 SmallVector<unsigned, 64> Vals;
3615 forEachModule(
3616 [&](const StringMapEntry<std::pair<uint64_t, ModuleHash>> &MPSE) {
3617 StringRef Key = MPSE.getKey();
3618 const auto &Value = MPSE.getValue();
3619 StringEncoding Bits = getStringEncoding(Key);
3620 unsigned AbbrevToUse = Abbrev8Bit;
3621 if (Bits == SE_Char6)
3622 AbbrevToUse = Abbrev6Bit;
3623 else if (Bits == SE_Fixed7)
3624 AbbrevToUse = Abbrev7Bit;
3625
3626 Vals.push_back(Value.first);
3627 Vals.append(Key.begin(), Key.end());
3628
3629 // Emit the finished record.
3630 Stream.EmitRecord(bitc::MST_CODE_ENTRY, Vals, AbbrevToUse);
3631
3632 // Emit an optional hash for the module now
3633 const auto &Hash = Value.second;
3634 if (llvm::any_of(Hash, [](uint32_t H) { return H; })) {
3635 Vals.assign(Hash.begin(), Hash.end());
3636 // Emit the hash record.
3637 Stream.EmitRecord(bitc::MST_CODE_HASH, Vals, AbbrevHash);
3638 }
3639
3640 Vals.clear();
3641 });
3642 Stream.ExitBlock();
3643}
3644
3645/// Write the function type metadata related records that need to appear before
3646/// a function summary entry (whether per-module or combined).
3647template <typename Fn>
3648static void writeFunctionTypeMetadataRecords(BitstreamWriter &Stream,
3649 FunctionSummary *FS,
3650 Fn GetValueID) {
3651 if (!FS->type_tests().empty())
3652 Stream.EmitRecord(bitc::FS_TYPE_TESTS, FS->type_tests());
3653
3654 SmallVector<uint64_t, 64> Record;
3655
3656 auto WriteVFuncIdVec = [&](uint64_t Ty,
3657 ArrayRef<FunctionSummary::VFuncId> VFs) {
3658 if (VFs.empty())
3659 return;
3660 Record.clear();
3661 for (auto &VF : VFs) {
3662 Record.push_back(VF.GUID);
3663 Record.push_back(VF.Offset);
3664 }
3665 Stream.EmitRecord(Ty, Record);
3666 };
3667
3668 WriteVFuncIdVec(bitc::FS_TYPE_TEST_ASSUME_VCALLS,
3669 FS->type_test_assume_vcalls());
3670 WriteVFuncIdVec(bitc::FS_TYPE_CHECKED_LOAD_VCALLS,
3671 FS->type_checked_load_vcalls());
3672
3673 auto WriteConstVCallVec = [&](uint64_t Ty,
3674 ArrayRef<FunctionSummary::ConstVCall> VCs) {
3675 for (auto &VC : VCs) {
3676 Record.clear();
3677 Record.push_back(VC.VFunc.GUID);
3678 Record.push_back(VC.VFunc.Offset);
3679 llvm::append_range(Record, VC.Args);
3680 Stream.EmitRecord(Ty, Record);
3681 }
3682 };
3683
3684 WriteConstVCallVec(bitc::FS_TYPE_TEST_ASSUME_CONST_VCALL,
3685 FS->type_test_assume_const_vcalls());
3686 WriteConstVCallVec(bitc::FS_TYPE_CHECKED_LOAD_CONST_VCALL,
3687 FS->type_checked_load_const_vcalls());
3688
3689 auto WriteRange = [&](ConstantRange Range) {
3690 Range = Range.sextOrTrunc(FunctionSummary::ParamAccess::RangeWidth);
3691 assert(Range.getLower().getNumWords() == 1)((void)0);
3692 assert(Range.getUpper().getNumWords() == 1)((void)0);
3693 emitSignedInt64(Record, *Range.getLower().getRawData());
3694 emitSignedInt64(Record, *Range.getUpper().getRawData());
3695 };
3696
3697 if (!FS->paramAccesses().empty()) {
3698 Record.clear();
3699 for (auto &Arg : FS->paramAccesses()) {
3700 size_t UndoSize = Record.size();
3701 Record.push_back(Arg.ParamNo);
3702 WriteRange(Arg.Use);
3703 Record.push_back(Arg.Calls.size());
3704 for (auto &Call : Arg.Calls) {
3705 Record.push_back(Call.ParamNo);
3706 Optional<unsigned> ValueID = GetValueID(Call.Callee);
3707 if (!ValueID) {
3708 // If ValueID is unknown we can't drop just this call, we must drop
3709 // entire parameter.
3710 Record.resize(UndoSize);
3711 break;
3712 }
3713 Record.push_back(*ValueID);
3714 WriteRange(Call.Offsets);
3715 }
3716 }
3717 if (!Record.empty())
3718 Stream.EmitRecord(bitc::FS_PARAM_ACCESS, Record);
3719 }
3720}
3721
3722/// Collect type IDs from type tests used by function.
3723static void
3724getReferencedTypeIds(FunctionSummary *FS,
3725 std::set<GlobalValue::GUID> &ReferencedTypeIds) {
3726 if (!FS->type_tests().empty())
3727 for (auto &TT : FS->type_tests())
3728 ReferencedTypeIds.insert(TT);
3729
3730 auto GetReferencedTypesFromVFuncIdVec =
3731 [&](ArrayRef<FunctionSummary::VFuncId> VFs) {
3732 for (auto &VF : VFs)
3733 ReferencedTypeIds.insert(VF.GUID);
3734 };
3735
3736 GetReferencedTypesFromVFuncIdVec(FS->type_test_assume_vcalls());
3737 GetReferencedTypesFromVFuncIdVec(FS->type_checked_load_vcalls());
3738
3739 auto GetReferencedTypesFromConstVCallVec =
3740 [&](ArrayRef<FunctionSummary::ConstVCall> VCs) {
3741 for (auto &VC : VCs)
3742 ReferencedTypeIds.insert(VC.VFunc.GUID);
3743 };
3744
3745 GetReferencedTypesFromConstVCallVec(FS->type_test_assume_const_vcalls());
3746 GetReferencedTypesFromConstVCallVec(FS->type_checked_load_const_vcalls());
3747}
3748
3749static void writeWholeProgramDevirtResolutionByArg(
3750 SmallVector<uint64_t, 64> &NameVals, const std::vector<uint64_t> &args,
3751 const WholeProgramDevirtResolution::ByArg &ByArg) {
3752 NameVals.push_back(args.size());
3753 llvm::append_range(NameVals, args);
3754
3755 NameVals.push_back(ByArg.TheKind);
3756 NameVals.push_back(ByArg.Info);
3757 NameVals.push_back(ByArg.Byte);
3758 NameVals.push_back(ByArg.Bit);
3759}
3760
3761static void writeWholeProgramDevirtResolution(
3762 SmallVector<uint64_t, 64> &NameVals, StringTableBuilder &StrtabBuilder,
3763 uint64_t Id, const WholeProgramDevirtResolution &Wpd) {
3764 NameVals.push_back(Id);
3765
3766 NameVals.push_back(Wpd.TheKind);
3767 NameVals.push_back(StrtabBuilder.add(Wpd.SingleImplName));
3768 NameVals.push_back(Wpd.SingleImplName.size());
3769
3770 NameVals.push_back(Wpd.ResByArg.size());
3771 for (auto &A : Wpd.ResByArg)
3772 writeWholeProgramDevirtResolutionByArg(NameVals, A.first, A.second);
3773}
3774
3775static void writeTypeIdSummaryRecord(SmallVector<uint64_t, 64> &NameVals,
3776 StringTableBuilder &StrtabBuilder,
3777 const std::string &Id,
3778 const TypeIdSummary &Summary) {
3779 NameVals.push_back(StrtabBuilder.add(Id));
3780 NameVals.push_back(Id.size());
3781
3782 NameVals.push_back(Summary.TTRes.TheKind);
3783 NameVals.push_back(Summary.TTRes.SizeM1BitWidth);
3784 NameVals.push_back(Summary.TTRes.AlignLog2);
3785 NameVals.push_back(Summary.TTRes.SizeM1);
3786 NameVals.push_back(Summary.TTRes.BitMask);
3787 NameVals.push_back(Summary.TTRes.InlineBits);
3788
3789 for (auto &W : Summary.WPDRes)
3790 writeWholeProgramDevirtResolution(NameVals, StrtabBuilder, W.first,
3791 W.second);
3792}
3793
3794static void writeTypeIdCompatibleVtableSummaryRecord(
3795 SmallVector<uint64_t, 64> &NameVals, StringTableBuilder &StrtabBuilder,
3796 const std::string &Id, const TypeIdCompatibleVtableInfo &Summary,
3797 ValueEnumerator &VE) {
3798 NameVals.push_back(StrtabBuilder.add(Id));
3799 NameVals.push_back(Id.size());
3800
3801 for (auto &P : Summary) {
3802 NameVals.push_back(P.AddressPointOffset);
3803 NameVals.push_back(VE.getValueID(P.VTableVI.getValue()));
3804 }
3805}
3806
3807// Helper to emit a single function summary record.
3808void ModuleBitcodeWriterBase::writePerModuleFunctionSummaryRecord(
3809 SmallVector<uint64_t, 64> &NameVals, GlobalValueSummary *Summary,
3810 unsigned ValueID, unsigned FSCallsAbbrev, unsigned FSCallsProfileAbbrev,
3811 const Function &F) {
3812 NameVals.push_back(ValueID);
3813
3814 FunctionSummary *FS = cast<FunctionSummary>(Summary);
3815
3816 writeFunctionTypeMetadataRecords(
3817 Stream, FS, [&](const ValueInfo &VI) -> Optional<unsigned> {
3818 return {VE.getValueID(VI.getValue())};
3819 });
3820
3821 auto SpecialRefCnts = FS->specialRefCounts();
3822 NameVals.push_back(getEncodedGVSummaryFlags(FS->flags()));
3823 NameVals.push_back(FS->instCount());
3824 NameVals.push_back(getEncodedFFlags(FS->fflags()));
3825 NameVals.push_back(FS->refs().size());
3826 NameVals.push_back(SpecialRefCnts.first); // rorefcnt
3827 NameVals.push_back(SpecialRefCnts.second); // worefcnt
3828
3829 for (auto &RI : FS->refs())
3830 NameVals.push_back(VE.getValueID(RI.getValue()));
3831
3832 bool HasProfileData =
3833 F.hasProfileData() || ForceSummaryEdgesCold != FunctionSummary::FSHT_None;
3834 for (auto &ECI : FS->calls()) {
3835 NameVals.push_back(getValueId(ECI.first));
3836 if (HasProfileData)
3837 NameVals.push_back(static_cast<uint8_t>(ECI.second.Hotness));
3838 else if (WriteRelBFToSummary)
3839 NameVals.push_back(ECI.second.RelBlockFreq);
3840 }
3841
3842 unsigned FSAbbrev = (HasProfileData ? FSCallsProfileAbbrev : FSCallsAbbrev);
3843 unsigned Code =
3844 (HasProfileData ? bitc::FS_PERMODULE_PROFILE
3845 : (WriteRelBFToSummary ? bitc::FS_PERMODULE_RELBF
3846 : bitc::FS_PERMODULE));
3847
3848 // Emit the finished record.
3849 Stream.EmitRecord(Code, NameVals, FSAbbrev);
3850 NameVals.clear();
3851}
3852
3853// Collect the global value references in the given variable's initializer,
3854// and emit them in a summary record.
3855void ModuleBitcodeWriterBase::writeModuleLevelReferences(
3856 const GlobalVariable &V, SmallVector<uint64_t, 64> &NameVals,
3857 unsigned FSModRefsAbbrev, unsigned FSModVTableRefsAbbrev) {
3858 auto VI = Index->getValueInfo(V.getGUID());
3859 if (!VI || VI.getSummaryList().empty()) {
3860 // Only declarations should not have a summary (a declaration might however
3861 // have a summary if the def was in module level asm).
3862 assert(V.isDeclaration())((void)0);
3863 return;
3864 }
3865 auto *Summary = VI.getSummaryList()[0].get();
3866 NameVals.push_back(VE.getValueID(&V));
3867 GlobalVarSummary *VS = cast<GlobalVarSummary>(Summary);
3868 NameVals.push_back(getEncodedGVSummaryFlags(VS->flags()));
3869 NameVals.push_back(getEncodedGVarFlags(VS->varflags()));
3870
3871 auto VTableFuncs = VS->vTableFuncs();
3872 if (!VTableFuncs.empty())
3873 NameVals.push_back(VS->refs().size());
3874
3875 unsigned SizeBeforeRefs = NameVals.size();
3876 for (auto &RI : VS->refs())
3877 NameVals.push_back(VE.getValueID(RI.getValue()));
3878 // Sort the refs for determinism output, the vector returned by FS->refs() has
3879 // been initialized from a DenseSet.
3880 llvm::sort(drop_begin(NameVals, SizeBeforeRefs));
3881
3882 if (VTableFuncs.empty())
3883 Stream.EmitRecord(bitc::FS_PERMODULE_GLOBALVAR_INIT_REFS, NameVals,
3884 FSModRefsAbbrev);
3885 else {
3886 // VTableFuncs pairs should already be sorted by offset.
3887 for (auto &P : VTableFuncs) {
3888 NameVals.push_back(VE.getValueID(P.FuncVI.getValue()));
3889 NameVals.push_back(P.VTableOffset);
3890 }
3891
3892 Stream.EmitRecord(bitc::FS_PERMODULE_VTABLE_GLOBALVAR_INIT_REFS, NameVals,
3893 FSModVTableRefsAbbrev);
3894 }
3895 NameVals.clear();
3896}
3897
3898/// Emit the per-module summary section alongside the rest of
3899/// the module's bitcode.
3900void ModuleBitcodeWriterBase::writePerModuleGlobalValueSummary() {
3901 // By default we compile with ThinLTO if the module has a summary, but the
3902 // client can request full LTO with a module flag.
3903 bool IsThinLTO = true;
3904 if (auto *MD =
3905 mdconst::extract_or_null<ConstantInt>(M.getModuleFlag("ThinLTO")))
3906 IsThinLTO = MD->getZExtValue();
3907 Stream.EnterSubblock(IsThinLTO ? bitc::GLOBALVAL_SUMMARY_BLOCK_ID
3908 : bitc::FULL_LTO_GLOBALVAL_SUMMARY_BLOCK_ID,
3909 4);
3910
3911 Stream.EmitRecord(
3912 bitc::FS_VERSION,
3913 ArrayRef<uint64_t>{ModuleSummaryIndex::BitcodeSummaryVersion});
3914
3915 // Write the index flags.
3916 uint64_t Flags = 0;
3917 // Bits 1-3 are set only in the combined index, skip them.
3918 if (Index->enableSplitLTOUnit())
3919 Flags |= 0x8;
3920 Stream.EmitRecord(bitc::FS_FLAGS, ArrayRef<uint64_t>{Flags});
3921
3922 if (Index->begin() == Index->end()) {
3923 Stream.ExitBlock();
3924 return;
3925 }
3926
3927 for (const auto &GVI : valueIds()) {
3928 Stream.EmitRecord(bitc::FS_VALUE_GUID,
3929 ArrayRef<uint64_t>{GVI.second, GVI.first});
3930 }
3931
3932 // Abbrev for FS_PERMODULE_PROFILE.
3933 auto Abbv = std::make_shared<BitCodeAbbrev>();
3934 Abbv->Add(BitCodeAbbrevOp(bitc::FS_PERMODULE_PROFILE));
3935 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid
3936 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // flags
3937 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // instcount
3938 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // fflags
3939 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // numrefs
3940 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // rorefcnt
3941 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // worefcnt
3942 // numrefs x valueid, n x (valueid, hotness)
3943 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
3944 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
3945 unsigned FSCallsProfileAbbrev = Stream.EmitAbbrev(std::move(Abbv));
3946
3947 // Abbrev for FS_PERMODULE or FS_PERMODULE_RELBF.
3948 Abbv = std::make_shared<BitCodeAbbrev>();
3949 if (WriteRelBFToSummary)
3950 Abbv->Add(BitCodeAbbrevOp(bitc::FS_PERMODULE_RELBF));
3951 else
3952 Abbv->Add(BitCodeAbbrevOp(bitc::FS_PERMODULE));
3953 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid
3954 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // flags
3955 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // instcount
3956 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // fflags
3957 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // numrefs
3958 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // rorefcnt
3959 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // worefcnt
3960 // numrefs x valueid, n x (valueid [, rel_block_freq])
3961 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
3962 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
3963 unsigned FSCallsAbbrev = Stream.EmitAbbrev(std::move(Abbv));
3964
3965 // Abbrev for FS_PERMODULE_GLOBALVAR_INIT_REFS.
3966 Abbv = std::make_shared<BitCodeAbbrev>();
3967 Abbv->Add(BitCodeAbbrevOp(bitc::FS_PERMODULE_GLOBALVAR_INIT_REFS));
3968 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid
3969 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // flags
3970 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); // valueids
3971 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
3972 unsigned FSModRefsAbbrev = Stream.EmitAbbrev(std::move(Abbv));
3973
3974 // Abbrev for FS_PERMODULE_VTABLE_GLOBALVAR_INIT_REFS.
3975 Abbv = std::make_shared<BitCodeAbbrev>();
3976 Abbv->Add(BitCodeAbbrevOp(bitc::FS_PERMODULE_VTABLE_GLOBALVAR_INIT_REFS));
3977 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid
3978 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // flags
3979 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // numrefs
3980 // numrefs x valueid, n x (valueid , offset)
3981 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
3982 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
3983 unsigned FSModVTableRefsAbbrev = Stream.EmitAbbrev(std::move(Abbv));
3984
3985 // Abbrev for FS_ALIAS.
3986 Abbv = std::make_shared<BitCodeAbbrev>();
3987 Abbv->Add(BitCodeAbbrevOp(bitc::FS_ALIAS));
3988 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid
3989 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // flags
3990 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid
3991 unsigned FSAliasAbbrev = Stream.EmitAbbrev(std::move(Abbv));
3992
3993 // Abbrev for FS_TYPE_ID_METADATA
3994 Abbv = std::make_shared<BitCodeAbbrev>();
3995 Abbv->Add(BitCodeAbbrevOp(bitc::FS_TYPE_ID_METADATA));
3996 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // typeid strtab index
3997 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // typeid length
3998 // n x (valueid , offset)
3999 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
4000 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
4001 unsigned TypeIdCompatibleVtableAbbrev = Stream.EmitAbbrev(std::move(Abbv));
4002
4003 SmallVector<uint64_t, 64> NameVals;
4004 // Iterate over the list of functions instead of the Index to
4005 // ensure the ordering is stable.
4006 for (const Function &F : M) {
4007 // Summary emission does not support anonymous functions, they have to
4008 // renamed using the anonymous function renaming pass.
4009 if (!F.hasName())
4010 report_fatal_error("Unexpected anonymous function when writing summary");
4011
4012 ValueInfo VI = Index->getValueInfo(F.getGUID());
4013 if (!VI || VI.getSummaryList().empty()) {
4014 // Only declarations should not have a summary (a declaration might
4015 // however have a summary if the def was in module level asm).
4016 assert(F.isDeclaration())((void)0);
4017 continue;
4018 }
4019 auto *Summary = VI.getSummaryList()[0].get();
4020 writePerModuleFunctionSummaryRecord(NameVals, Summary, VE.getValueID(&F),
4021 FSCallsAbbrev, FSCallsProfileAbbrev, F);
4022 }
4023
4024 // Capture references from GlobalVariable initializers, which are outside
4025 // of a function scope.
4026 for (const GlobalVariable &G : M.globals())
4027 writeModuleLevelReferences(G, NameVals, FSModRefsAbbrev,
4028 FSModVTableRefsAbbrev);
4029
4030 for (const GlobalAlias &A : M.aliases()) {
4031 auto *Aliasee = A.getBaseObject();
4032 if (!Aliasee->hasName())
4033 // Nameless function don't have an entry in the summary, skip it.
4034 continue;
4035 auto AliasId = VE.getValueID(&A);
4036 auto AliaseeId = VE.getValueID(Aliasee);
4037 NameVals.push_back(AliasId);
4038 auto *Summary = Index->getGlobalValueSummary(A);
4039 AliasSummary *AS = cast<AliasSummary>(Summary);
4040 NameVals.push_back(getEncodedGVSummaryFlags(AS->flags()));
4041 NameVals.push_back(AliaseeId);
4042 Stream.EmitRecord(bitc::FS_ALIAS, NameVals, FSAliasAbbrev);
4043 NameVals.clear();
4044 }
4045
4046 for (auto &S : Index->typeIdCompatibleVtableMap()) {
4047 writeTypeIdCompatibleVtableSummaryRecord(NameVals, StrtabBuilder, S.first,
4048 S.second, VE);
4049 Stream.EmitRecord(bitc::FS_TYPE_ID_METADATA, NameVals,
4050 TypeIdCompatibleVtableAbbrev);
4051 NameVals.clear();
4052 }
4053
4054 Stream.EmitRecord(bitc::FS_BLOCK_COUNT,
4055 ArrayRef<uint64_t>{Index->getBlockCount()});
4056
4057 Stream.ExitBlock();
4058}
4059
4060/// Emit the combined summary section into the combined index file.
4061void IndexBitcodeWriter::writeCombinedGlobalValueSummary() {
4062 Stream.EnterSubblock(bitc::GLOBALVAL_SUMMARY_BLOCK_ID, 3);
4063 Stream.EmitRecord(
4064 bitc::FS_VERSION,
4065 ArrayRef<uint64_t>{ModuleSummaryIndex::BitcodeSummaryVersion});
4066
4067 // Write the index flags.
4068 Stream.EmitRecord(bitc::FS_FLAGS, ArrayRef<uint64_t>{Index.getFlags()});
4069
4070 for (const auto &GVI : valueIds()) {
4071 Stream.EmitRecord(bitc::FS_VALUE_GUID,
4072 ArrayRef<uint64_t>{GVI.second, GVI.first});
4073 }
4074
4075 // Abbrev for FS_COMBINED.
4076 auto Abbv = std::make_shared<BitCodeAbbrev>();
4077 Abbv->Add(BitCodeAbbrevOp(bitc::FS_COMBINED));
4078 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid
4079 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // modid
4080 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // flags
4081 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // instcount
4082 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // fflags
4083 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // entrycount
4084 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // numrefs
4085 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // rorefcnt
4086 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // worefcnt
4087 // numrefs x valueid, n x (valueid)
4088 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
4089 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
4090 unsigned FSCallsAbbrev = Stream.EmitAbbrev(std::move(Abbv));
4091
4092 // Abbrev for FS_COMBINED_PROFILE.
4093 Abbv = std::make_shared<BitCodeAbbrev>();
4094 Abbv->Add(BitCodeAbbrevOp(bitc::FS_COMBINED_PROFILE));
4095 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid
4096 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // modid
4097 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // flags
4098 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // instcount
4099 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // fflags
4100 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // entrycount
4101 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // numrefs
4102 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // rorefcnt
4103 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // worefcnt
4104 // numrefs x valueid, n x (valueid, hotness)
4105 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
4106 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
4107 unsigned FSCallsProfileAbbrev = Stream.EmitAbbrev(std::move(Abbv));
4108
4109 // Abbrev for FS_COMBINED_GLOBALVAR_INIT_REFS.
4110 Abbv = std::make_shared<BitCodeAbbrev>();
4111 Abbv->Add(BitCodeAbbrevOp(bitc::FS_COMBINED_GLOBALVAR_INIT_REFS));
4112 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid
4113 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // modid
4114 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // flags
4115 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); // valueids
4116 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
4117 unsigned FSModRefsAbbrev = Stream.EmitAbbrev(std::move(Abbv));
4118
4119 // Abbrev for FS_COMBINED_ALIAS.
4120 Abbv = std::make_shared<BitCodeAbbrev>();
4121 Abbv->Add(BitCodeAbbrevOp(bitc::FS_COMBINED_ALIAS));
4122 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid
4123 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // modid
4124 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // flags
4125 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid
4126 unsigned FSAliasAbbrev = Stream.EmitAbbrev(std::move(Abbv));
4127
4128 // The aliases are emitted as a post-pass, and will point to the value
4129 // id of the aliasee. Save them in a vector for post-processing.
4130 SmallVector<AliasSummary *, 64> Aliases;
4131
4132 // Save the value id for each summary for alias emission.
4133 DenseMap<const GlobalValueSummary *, unsigned> SummaryToValueIdMap;
4134
4135 SmallVector<uint64_t, 64> NameVals;
4136
4137 // Set that will be populated during call to writeFunctionTypeMetadataRecords
4138 // with the type ids referenced by this index file.
4139 std::set<GlobalValue::GUID> ReferencedTypeIds;
4140
4141 // For local linkage, we also emit the original name separately
4142 // immediately after the record.
4143 auto MaybeEmitOriginalName = [&](GlobalValueSummary &S) {
4144 if (!GlobalValue::isLocalLinkage(S.linkage()))
4145 return;
4146 NameVals.push_back(S.getOriginalName());
4147 Stream.EmitRecord(bitc::FS_COMBINED_ORIGINAL_NAME, NameVals);
4148 NameVals.clear();
4149 };
4150
4151 std::set<GlobalValue::GUID> DefOrUseGUIDs;
4152 forEachSummary([&](GVInfo I, bool IsAliasee) {
4153 GlobalValueSummary *S = I.second;
4154 assert(S)((void)0);
4155 DefOrUseGUIDs.insert(I.first);
4156 for (const ValueInfo &VI : S->refs())
4157 DefOrUseGUIDs.insert(VI.getGUID());
4158
4159 auto ValueId = getValueId(I.first);
4160 assert(ValueId)((void)0);
4161 SummaryToValueIdMap[S] = *ValueId;
4162
4163 // If this is invoked for an aliasee, we want to record the above
4164 // mapping, but then not emit a summary entry (if the aliasee is
4165 // to be imported, we will invoke this separately with IsAliasee=false).
4166 if (IsAliasee)
4167 return;
4168
4169 if (auto *AS = dyn_cast<AliasSummary>(S)) {
4170 // Will process aliases as a post-pass because the reader wants all
4171 // global to be loaded first.
4172 Aliases.push_back(AS);
4173 return;
4174 }
4175
4176 if (auto *VS = dyn_cast<GlobalVarSummary>(S)) {
4177 NameVals.push_back(*ValueId);
4178 NameVals.push_back(Index.getModuleId(VS->modulePath()));
4179 NameVals.push_back(getEncodedGVSummaryFlags(VS->flags()));
4180 NameVals.push_back(getEncodedGVarFlags(VS->varflags()));
4181 for (auto &RI : VS->refs()) {
4182 auto RefValueId = getValueId(RI.getGUID());
4183 if (!RefValueId)
4184 continue;
4185 NameVals.push_back(*RefValueId);
4186 }
4187
4188 // Emit the finished record.
4189 Stream.EmitRecord(bitc::FS_COMBINED_GLOBALVAR_INIT_REFS, NameVals,
4190 FSModRefsAbbrev);
4191 NameVals.clear();
4192 MaybeEmitOriginalName(*S);
4193 return;
4194 }
4195
4196 auto GetValueId = [&](const ValueInfo &VI) -> Optional<unsigned> {
4197 GlobalValue::GUID GUID = VI.getGUID();
4198 Optional<unsigned> CallValueId = getValueId(GUID);
4199 if (CallValueId)
4200 return CallValueId;
4201 // For SamplePGO, the indirect call targets for local functions will
4202 // have its original name annotated in profile. We try to find the
4203 // corresponding PGOFuncName as the GUID.
4204 GUID = Index.getGUIDFromOriginalID(GUID);
4205 if (!GUID)
4206 return None;
4207 CallValueId = getValueId(GUID);
4208 if (!CallValueId)
4209 return None;
4210 // The mapping from OriginalId to GUID may return a GUID
4211 // that corresponds to a static variable. Filter it out here.
4212 // This can happen when
4213 // 1) There is a call to a library function which does not have
4214 // a CallValidId;
4215 // 2) There is a static variable with the OriginalGUID identical
4216 // to the GUID of the library function in 1);
4217 // When this happens, the logic for SamplePGO kicks in and
4218 // the static variable in 2) will be found, which needs to be
4219 // filtered out.
4220 auto *GVSum = Index.getGlobalValueSummary(GUID, false);
4221 if (GVSum && GVSum->getSummaryKind() == GlobalValueSummary::GlobalVarKind)
4222 return None;
4223 return CallValueId;
4224 };
4225
4226 auto *FS = cast<FunctionSummary>(S);
4227 writeFunctionTypeMetadataRecords(Stream, FS, GetValueId);
4228 getReferencedTypeIds(FS, ReferencedTypeIds);
4229
4230 NameVals.push_back(*ValueId);
4231 NameVals.push_back(Index.getModuleId(FS->modulePath()));
4232 NameVals.push_back(getEncodedGVSummaryFlags(FS->flags()));
4233 NameVals.push_back(FS->instCount());
4234 NameVals.push_back(getEncodedFFlags(FS->fflags()));
4235 NameVals.push_back(FS->entryCount());
4236
4237 // Fill in below
4238 NameVals.push_back(0); // numrefs
4239 NameVals.push_back(0); // rorefcnt
4240 NameVals.push_back(0); // worefcnt
4241
4242 unsigned Count = 0, RORefCnt = 0, WORefCnt = 0;
4243 for (auto &RI : FS->refs()) {
4244 auto RefValueId = getValueId(RI.getGUID());
4245 if (!RefValueId)
4246 continue;
4247 NameVals.push_back(*RefValueId);
4248 if (RI.isReadOnly())
4249 RORefCnt++;
4250 else if (RI.isWriteOnly())
4251 WORefCnt++;
4252 Count++;
4253 }
4254 NameVals[6] = Count;
4255 NameVals[7] = RORefCnt;
4256 NameVals[8] = WORefCnt;
4257
4258 bool HasProfileData = false;
4259 for (auto &EI : FS->calls()) {
4260 HasProfileData |=
4261 EI.second.getHotness() != CalleeInfo::HotnessType::Unknown;
4262 if (HasProfileData)
4263 break;
4264 }
4265
4266 for (auto &EI : FS->calls()) {
4267 // If this GUID doesn't have a value id, it doesn't have a function
4268 // summary and we don't need to record any calls to it.
4269 Optional<unsigned> CallValueId = GetValueId(EI.first);
4270 if (!CallValueId)
4271 continue;
4272 NameVals.push_back(*CallValueId);
4273 if (HasProfileData)
4274 NameVals.push_back(static_cast<uint8_t>(EI.second.Hotness));
4275 }
4276
4277 unsigned FSAbbrev = (HasProfileData ? FSCallsProfileAbbrev : FSCallsAbbrev);
4278 unsigned Code =
4279 (HasProfileData ? bitc::FS_COMBINED_PROFILE : bitc::FS_COMBINED);
4280
4281 // Emit the finished record.
4282 Stream.EmitRecord(Code, NameVals, FSAbbrev);
4283 NameVals.clear();
4284 MaybeEmitOriginalName(*S);
4285 });
4286
4287 for (auto *AS : Aliases) {
4288 auto AliasValueId = SummaryToValueIdMap[AS];
4289 assert(AliasValueId)((void)0);
4290 NameVals.push_back(AliasValueId);
4291 NameVals.push_back(Index.getModuleId(AS->modulePath()));
4292 NameVals.push_back(getEncodedGVSummaryFlags(AS->flags()));
4293 auto AliaseeValueId = SummaryToValueIdMap[&AS->getAliasee()];
4294 assert(AliaseeValueId)((void)0);
4295 NameVals.push_back(AliaseeValueId);
4296
4297 // Emit the finished record.
4298 Stream.EmitRecord(bitc::FS_COMBINED_ALIAS, NameVals, FSAliasAbbrev);
4299 NameVals.clear();
4300 MaybeEmitOriginalName(*AS);
4301
4302 if (auto *FS = dyn_cast<FunctionSummary>(&AS->getAliasee()))
4303 getReferencedTypeIds(FS, ReferencedTypeIds);
4304 }
4305
4306 if (!Index.cfiFunctionDefs().empty()) {
4307 for (auto &S : Index.cfiFunctionDefs()) {
4308 if (DefOrUseGUIDs.count(
4309 GlobalValue::getGUID(GlobalValue::dropLLVMManglingEscape(S)))) {
4310 NameVals.push_back(StrtabBuilder.add(S));
4311 NameVals.push_back(S.size());
4312 }
4313 }
4314 if (!NameVals.empty()) {
4315 Stream.EmitRecord(bitc::FS_CFI_FUNCTION_DEFS, NameVals);
4316 NameVals.clear();
4317 }
4318 }
4319
4320 if (!Index.cfiFunctionDecls().empty()) {
4321 for (auto &S : Index.cfiFunctionDecls()) {
4322 if (DefOrUseGUIDs.count(
4323 GlobalValue::getGUID(GlobalValue::dropLLVMManglingEscape(S)))) {
4324 NameVals.push_back(StrtabBuilder.add(S));
4325 NameVals.push_back(S.size());
4326 }
4327 }
4328 if (!NameVals.empty()) {
4329 Stream.EmitRecord(bitc::FS_CFI_FUNCTION_DECLS, NameVals);
4330 NameVals.clear();
4331 }
4332 }
4333
4334 // Walk the GUIDs that were referenced, and write the
4335 // corresponding type id records.
4336 for (auto &T : ReferencedTypeIds) {
4337 auto TidIter = Index.typeIds().equal_range(T);
4338 for (auto It = TidIter.first; It != TidIter.second; ++It) {
4339 writeTypeIdSummaryRecord(NameVals, StrtabBuilder, It->second.first,
4340 It->second.second);
4341 Stream.EmitRecord(bitc::FS_TYPE_ID, NameVals);
4342 NameVals.clear();
4343 }
4344 }
4345
4346 Stream.EmitRecord(bitc::FS_BLOCK_COUNT,
4347 ArrayRef<uint64_t>{Index.getBlockCount()});
4348
4349 Stream.ExitBlock();
4350}
4351
4352/// Create the "IDENTIFICATION_BLOCK_ID" containing a single string with the
4353/// current llvm version, and a record for the epoch number.
4354static void writeIdentificationBlock(BitstreamWriter &Stream) {
4355 Stream.EnterSubblock(bitc::IDENTIFICATION_BLOCK_ID, 5);
4356
4357 // Write the "user readable" string identifying the bitcode producer
4358 auto Abbv = std::make_shared<BitCodeAbbrev>();
4359 Abbv->Add(BitCodeAbbrevOp(bitc::IDENTIFICATION_CODE_STRING));
4360 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
4361 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6));
4362 auto StringAbbrev = Stream.EmitAbbrev(std::move(Abbv));
4363 writeStringRecord(Stream, bitc::IDENTIFICATION_CODE_STRING,
4364 "LLVM" LLVM_VERSION_STRING"13.0.0", StringAbbrev);
4365
4366 // Write the epoch version
4367 Abbv = std::make_shared<BitCodeAbbrev>();
4368 Abbv->Add(BitCodeAbbrevOp(bitc::IDENTIFICATION_CODE_EPOCH));
4369 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
4370 auto EpochAbbrev = Stream.EmitAbbrev(std::move(Abbv));
4371 constexpr std::array<unsigned, 1> Vals = {{bitc::BITCODE_CURRENT_EPOCH}};
4372 Stream.EmitRecord(bitc::IDENTIFICATION_CODE_EPOCH, Vals, EpochAbbrev);
4373 Stream.ExitBlock();
4374}
4375
4376void ModuleBitcodeWriter::writeModuleHash(size_t BlockStartPos) {
4377 // Emit the module's hash.
4378 // MODULE_CODE_HASH: [5*i32]
4379 if (GenerateHash) {
4380 uint32_t Vals[5];
4381 Hasher.update(ArrayRef<uint8_t>((const uint8_t *)&(Buffer)[BlockStartPos],
4382 Buffer.size() - BlockStartPos));
4383 StringRef Hash = Hasher.result();
4384 for (int Pos = 0; Pos < 20; Pos += 4) {
4385 Vals[Pos / 4] = support::endian::read32be(Hash.data() + Pos);
4386 }
4387
4388 // Emit the finished record.
4389 Stream.EmitRecord(bitc::MODULE_CODE_HASH, Vals);
4390
4391 if (ModHash)
4392 // Save the written hash value.
4393 llvm::copy(Vals, std::begin(*ModHash));
4394 }
4395}
4396
4397void ModuleBitcodeWriter::write() {
4398 writeIdentificationBlock(Stream);
4399
4400 Stream.EnterSubblock(bitc::MODULE_BLOCK_ID, 3);
4401 size_t BlockStartPos = Buffer.size();
4402
4403 writeModuleVersion();
4404
4405 // Emit blockinfo, which defines the standard abbreviations etc.
4406 writeBlockInfo();
4407
4408 // Emit information describing all of the types in the module.
4409 writeTypeTable();
4410
4411 // Emit information about attribute groups.
4412 writeAttributeGroupTable();
4413
4414 // Emit information about parameter attributes.
4415 writeAttributeTable();
4416
4417 writeComdats();
4418
4419 // Emit top-level description of module, including target triple, inline asm,
4420 // descriptors for global variables, and function prototype info.
4421 writeModuleInfo();
4422
4423 // Emit constants.
4424 writeModuleConstants();
4425
4426 // Emit metadata kind names.
4427 writeModuleMetadataKinds();
4428
4429 // Emit metadata.
4430 writeModuleMetadata();
4431
4432 // Emit module-level use-lists.
4433 if (VE.shouldPreserveUseListOrder())
12
←
Assuming the condition is false
→
13
←
Taking false branch
→
4434 writeUseListBlock(nullptr);
4435
4436 writeOperandBundleTags();
4437 writeSyncScopeNames();
4438
4439 // Emit function bodies.
4440 DenseMap<const Function *, uint64_t> FunctionToBitcodeIndex;
4441 for (Module::const_iterator F = M.begin(), E = M.end(); F != E; ++F)
14
←
Loop condition is false. Execution continues on line 4447
→
4442 if (!F->isDeclaration())
4443 writeFunction(*F, FunctionToBitcodeIndex);
4444
4445 // Need to write after the above call to WriteFunction which populates
4446 // the summary information in the index.
4447 if (Index)
15
←
Assuming field 'Index' is null
→
16
←
Taking false branch
→
4448 writePerModuleGlobalValueSummary();
4449
4450 writeGlobalValueSymbolTable(FunctionToBitcodeIndex);
17
←
Calling 'ModuleBitcodeWriter::writeGlobalValueSymbolTable'
→
4451
4452 writeModuleHash(BlockStartPos);
4453
4454 Stream.ExitBlock();
4455}
4456
4457static void writeInt32ToBuffer(uint32_t Value, SmallVectorImpl<char> &Buffer,
4458 uint32_t &Position) {
4459 support::endian::write32le(&Buffer[Position], Value);
4460 Position += 4;
4461}
4462
4463/// If generating a bc file on darwin, we have to emit a
4464/// header and trailer to make it compatible with the system archiver. To do
4465/// this we emit the following header, and then emit a trailer that pads the
4466/// file out to be a multiple of 16 bytes.
4467///
4468/// struct bc_header {
4469/// uint32_t Magic; // 0x0B17C0DE
4470/// uint32_t Version; // Version, currently always 0.
4471/// uint32_t BitcodeOffset; // Offset to traditional bitcode file.
4472/// uint32_t BitcodeSize; // Size of traditional bitcode file.
4473/// uint32_t CPUType; // CPU specifier.
4474/// ... potentially more later ...
4475/// };
4476static void emitDarwinBCHeaderAndTrailer(SmallVectorImpl<char> &Buffer,
4477 const Triple &TT) {
4478 unsigned CPUType = ~0U;
4479
4480 // Match x86_64-*, i[3-9]86-*, powerpc-*, powerpc64-*, arm-*, thumb-*,
4481 // armv[0-9]-*, thumbv[0-9]-*, armv5te-*, or armv6t2-*. The CPUType is a magic
4482 // number from /usr/include/mach/machine.h. It is ok to reproduce the
4483 // specific constants here because they are implicitly part of the Darwin ABI.
4484 enum {
4485 DARWIN_CPU_ARCH_ABI64 = 0x01000000,
4486 DARWIN_CPU_TYPE_X86 = 7,
4487 DARWIN_CPU_TYPE_ARM = 12,
4488 DARWIN_CPU_TYPE_POWERPC = 18
4489 };
4490
4491 Triple::ArchType Arch = TT.getArch();
4492 if (Arch == Triple::x86_64)
4493 CPUType = DARWIN_CPU_TYPE_X86 | DARWIN_CPU_ARCH_ABI64;
4494 else if (Arch == Triple::x86)
4495 CPUType = DARWIN_CPU_TYPE_X86;
4496 else if (Arch == Triple::ppc)
4497 CPUType = DARWIN_CPU_TYPE_POWERPC;
4498 else if (Arch == Triple::ppc64)
4499 CPUType = DARWIN_CPU_TYPE_POWERPC | DARWIN_CPU_ARCH_ABI64;
4500 else if (Arch == Triple::arm || Arch == Triple::thumb)
4501 CPUType = DARWIN_CPU_TYPE_ARM;
4502
4503 // Traditional Bitcode starts after header.
4504 assert(Buffer.size() >= BWH_HeaderSize &&((void)0)
4505 "Expected header size to be reserved")((void)0);
4506 unsigned BCOffset = BWH_HeaderSize;
4507 unsigned BCSize = Buffer.size() - BWH_HeaderSize;
4508
4509 // Write the magic and version.
4510 unsigned Position = 0;
4511 writeInt32ToBuffer(0x0B17C0DE, Buffer, Position);
4512 writeInt32ToBuffer(0, Buffer, Position); // Version.
4513 writeInt32ToBuffer(BCOffset, Buffer, Position);
4514 writeInt32ToBuffer(BCSize, Buffer, Position);
4515 writeInt32ToBuffer(CPUType, Buffer, Position);
4516
4517 // If the file is not a multiple of 16 bytes, insert dummy padding.
4518 while (Buffer.size() & 15)
4519 Buffer.push_back(0);
4520}
4521
4522/// Helper to write the header common to all bitcode files.
4523static void writeBitcodeHeader(BitstreamWriter &Stream) {
4524 // Emit the file header.
4525 Stream.Emit((unsigned)'B', 8);
4526 Stream.Emit((unsigned)'C', 8);
4527 Stream.Emit(0x0, 4);
4528 Stream.Emit(0xC, 4);
4529 Stream.Emit(0xE, 4);
4530 Stream.Emit(0xD, 4);
4531}
4532
4533BitcodeWriter::BitcodeWriter(SmallVectorImpl<char> &Buffer, raw_fd_stream *FS)
4534 : Buffer(Buffer), Stream(new BitstreamWriter(Buffer, FS, FlushThreshold)) {
4535 writeBitcodeHeader(*Stream);
4536}
4537
4538BitcodeWriter::~BitcodeWriter() { assert(WroteStrtab)((void)0); }
4539
4540void BitcodeWriter::writeBlob(unsigned Block, unsigned Record, StringRef Blob) {
4541 Stream->EnterSubblock(Block, 3);
4542
4543 auto Abbv = std::make_shared<BitCodeAbbrev>();
4544 Abbv->Add(BitCodeAbbrevOp(Record));
4545 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
4546 auto AbbrevNo = Stream->EmitAbbrev(std::move(Abbv));
4547
4548 Stream->EmitRecordWithBlob(AbbrevNo, ArrayRef<uint64_t>{Record}, Blob);
4549
4550 Stream->ExitBlock();
4551}
4552
4553void BitcodeWriter::writeSymtab() {
4554 assert(!WroteStrtab && !WroteSymtab)((void)0);
4555
4556 // If any module has module-level inline asm, we will require a registered asm
4557 // parser for the target so that we can create an accurate symbol table for
4558 // the module.
4559 for (Module *M : Mods) {
4560 if (M->getModuleInlineAsm().empty())
4561 continue;
4562
4563 std::string Err;
4564 const Triple TT(M->getTargetTriple());
4565 const Target *T = TargetRegistry::lookupTarget(TT.str(), Err);
4566 if (!T || !T->hasMCAsmParser())
4567 return;
4568 }
4569
4570 WroteSymtab = true;
4571 SmallVector<char, 0> Symtab;
4572 // The irsymtab::build function may be unable to create a symbol table if the
4573 // module is malformed (e.g. it contains an invalid alias). Writing a symbol
4574 // table is not required for correctness, but we still want to be able to
4575 // write malformed modules to bitcode files, so swallow the error.
4576 if (Error E = irsymtab::build(Mods, Symtab, StrtabBuilder, Alloc)) {
4577 consumeError(std::move(E));
4578 return;
4579 }
4580
4581 writeBlob(bitc::SYMTAB_BLOCK_ID, bitc::SYMTAB_BLOB,
4582 {Symtab.data(), Symtab.size()});
4583}
4584
4585void BitcodeWriter::writeStrtab() {
4586 assert(!WroteStrtab)((void)0);
4587
4588 std::vector<char> Strtab;
4589 StrtabBuilder.finalizeInOrder();
4590 Strtab.resize(StrtabBuilder.getSize());
4591 StrtabBuilder.write((uint8_t *)Strtab.data());
4592
4593 writeBlob(bitc::STRTAB_BLOCK_ID, bitc::STRTAB_BLOB,
4594 {Strtab.data(), Strtab.size()});
4595
4596 WroteStrtab = true;
4597}
4598
4599void BitcodeWriter::copyStrtab(StringRef Strtab) {
4600 writeBlob(bitc::STRTAB_BLOCK_ID, bitc::STRTAB_BLOB, Strtab);
4601 WroteStrtab = true;
4602}
4603
4604void BitcodeWriter::writeModule(const Module &M,
4605 bool ShouldPreserveUseListOrder,
4606 const ModuleSummaryIndex *Index,
4607 bool GenerateHash, ModuleHash *ModHash) {
4608 assert(!WroteStrtab)((void)0);
4609
4610 // The Mods vector is used by irsymtab::build, which requires non-const
4611 // Modules in case it needs to materialize metadata. But the bitcode writer
4612 // requires that the module is materialized, so we can cast to non-const here,
4613 // after checking that it is in fact materialized.
4614 assert(M.isMaterialized())((void)0);
4615 Mods.push_back(const_cast<Module *>(&M));
4616
4617 ModuleBitcodeWriter ModuleWriter(M, Buffer, StrtabBuilder, *Stream,
4618 ShouldPreserveUseListOrder, Index,
4619 GenerateHash, ModHash);
4620 ModuleWriter.write();
11
←
Calling 'ModuleBitcodeWriter::write'
→
4621}
4622
4623void BitcodeWriter::writeIndex(
4624 const ModuleSummaryIndex *Index,
4625 const std::map<std::string, GVSummaryMapTy> *ModuleToSummariesForIndex) {
4626 IndexBitcodeWriter IndexWriter(*Stream, StrtabBuilder, *Index,
4627 ModuleToSummariesForIndex);
4628 IndexWriter.write();
4629}
4630
4631/// Write the specified module to the specified output stream.
4632void llvm::WriteBitcodeToFile(const Module &M, raw_ostream &Out,
4633 bool ShouldPreserveUseListOrder,
4634 const ModuleSummaryIndex *Index,
4635 bool GenerateHash, ModuleHash *ModHash) {
4636 SmallVector<char, 0> Buffer;
4637 Buffer.reserve(256*1024);
4638
4639 // If this is darwin or another generic macho target, reserve space for the
4640 // header.
4641 Triple TT(M.getTargetTriple());
4642 if (TT.isOSDarwin() || TT.isOSBinFormatMachO())
8
←
Taking false branch
→
4643 Buffer.insert(Buffer.begin(), BWH_HeaderSize, 0);
4644
4645 BitcodeWriter Writer(Buffer, dyn_cast<raw_fd_stream>(&Out));
9
←
Assuming the object is not a 'raw_fd_stream'
→
4646 Writer.writeModule(M, ShouldPreserveUseListOrder, Index, GenerateHash,
10
←
Calling 'BitcodeWriter::writeModule'
→
4647 ModHash);
4648 Writer.writeSymtab();
4649 Writer.writeStrtab();
4650
4651 if (TT.isOSDarwin() || TT.isOSBinFormatMachO())
4652 emitDarwinBCHeaderAndTrailer(Buffer, TT);
4653
4654 // Write the generated bitstream to "Out".
4655 if (!Buffer.empty())
4656 Out.write((char *)&Buffer.front(), Buffer.size());
4657}
4658
4659void IndexBitcodeWriter::write() {
4660 Stream.EnterSubblock(bitc::MODULE_BLOCK_ID, 3);
4661
4662 writeModuleVersion();
4663
4664 // Write the module paths in the combined index.
4665 writeModStrings();
4666
4667 // Write the summary combined index records.
4668 writeCombinedGlobalValueSummary();
4669
4670 Stream.ExitBlock();
4671}
4672
4673// Write the specified module summary index to the given raw output stream,
4674// where it will be written in a new bitcode block. This is used when
4675// writing the combined index file for ThinLTO. When writing a subset of the
4676// index for a distributed backend, provide a \p ModuleToSummariesForIndex map.
4677void llvm::WriteIndexToFile(
4678 const ModuleSummaryIndex &Index, raw_ostream &Out,
4679 const std::map<std::string, GVSummaryMapTy> *ModuleToSummariesForIndex) {
4680 SmallVector<char, 0> Buffer;
4681 Buffer.reserve(256 * 1024);
4682
4683 BitcodeWriter Writer(Buffer);
4684 Writer.writeIndex(&Index, ModuleToSummariesForIndex);
4685 Writer.writeStrtab();
4686
4687 Out.write((char *)&Buffer.front(), Buffer.size());
4688}
4689
4690namespace {
4691
4692/// Class to manage the bitcode writing for a thin link bitcode file.
4693class ThinLinkBitcodeWriter : public ModuleBitcodeWriterBase {
4694 /// ModHash is for use in ThinLTO incremental build, generated while writing
4695 /// the module bitcode file.
4696 const ModuleHash *ModHash;
4697
4698public:
4699 ThinLinkBitcodeWriter(const Module &M, StringTableBuilder &StrtabBuilder,
4700 BitstreamWriter &Stream,
4701 const ModuleSummaryIndex &Index,
4702 const ModuleHash &ModHash)
4703 : ModuleBitcodeWriterBase(M, StrtabBuilder, Stream,
4704 /*ShouldPreserveUseListOrder=*/false, &Index),
4705 ModHash(&ModHash) {}
4706
4707 void write();
4708
4709private:
4710 void writeSimplifiedModuleInfo();
4711};
4712
4713} // end anonymous namespace
4714
4715// This function writes a simpilified module info for thin link bitcode file.
4716// It only contains the source file name along with the name(the offset and
4717// size in strtab) and linkage for global values. For the global value info
4718// entry, in order to keep linkage at offset 5, there are three zeros used
4719// as padding.
4720void ThinLinkBitcodeWriter::writeSimplifiedModuleInfo() {
4721 SmallVector<unsigned, 64> Vals;
4722 // Emit the module's source file name.
4723 {
4724 StringEncoding Bits = getStringEncoding(M.getSourceFileName());
4725 BitCodeAbbrevOp AbbrevOpToUse = BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8);
4726 if (Bits == SE_Char6)
4727 AbbrevOpToUse = BitCodeAbbrevOp(BitCodeAbbrevOp::Char6);
4728 else if (Bits == SE_Fixed7)
4729 AbbrevOpToUse = BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7);
4730
4731 // MODULE_CODE_SOURCE_FILENAME: [namechar x N]
4732 auto Abbv = std::make_shared<BitCodeAbbrev>();
4733 Abbv->Add(BitCodeAbbrevOp(bitc::MODULE_CODE_SOURCE_FILENAME));
4734 Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
4735 Abbv->Add(AbbrevOpToUse);
4736 unsigned FilenameAbbrev = Stream.EmitAbbrev(std::move(Abbv));
4737
4738 for (const auto P : M.getSourceFileName())
4739 Vals.push_back((unsigned char)P);
4740
4741 Stream.EmitRecord(bitc::MODULE_CODE_SOURCE_FILENAME, Vals, FilenameAbbrev);
4742 Vals.clear();
4743 }
4744
4745 // Emit the global variable information.
4746 for (const GlobalVariable &GV : M.globals()) {
4747 // GLOBALVAR: [strtab offset, strtab size, 0, 0, 0, linkage]
4748 Vals.push_back(StrtabBuilder.add(GV.getName()));
4749 Vals.push_back(GV.getName().size());
4750 Vals.push_back(0);
4751 Vals.push_back(0);
4752 Vals.push_back(0);
4753 Vals.push_back(getEncodedLinkage(GV));
4754
4755 Stream.EmitRecord(bitc::MODULE_CODE_GLOBALVAR, Vals);
4756 Vals.clear();
4757 }
4758
4759 // Emit the function proto information.
4760 for (const Function &F : M) {
4761 // FUNCTION: [strtab offset, strtab size, 0, 0, 0, linkage]
4762 Vals.push_back(StrtabBuilder.add(F.getName()));
4763 Vals.push_back(F.getName().size());
4764 Vals.push_back(0);
4765 Vals.push_back(0);
4766 Vals.push_back(0);
4767 Vals.push_back(getEncodedLinkage(F));
4768
4769 Stream.EmitRecord(bitc::MODULE_CODE_FUNCTION, Vals);
4770 Vals.clear();
4771 }
4772
4773 // Emit the alias information.
4774 for (const GlobalAlias &A : M.aliases()) {
4775 // ALIAS: [strtab offset, strtab size, 0, 0, 0, linkage]
4776 Vals.push_back(StrtabBuilder.add(A.getName()));
4777 Vals.push_back(A.getName().size());
4778 Vals.push_back(0);
4779 Vals.push_back(0);
4780 Vals.push_back(0);
4781 Vals.push_back(getEncodedLinkage(A));
4782
4783 Stream.EmitRecord(bitc::MODULE_CODE_ALIAS, Vals);
4784 Vals.clear();
4785 }
4786
4787 // Emit the ifunc information.
4788 for (const GlobalIFunc &I : M.ifuncs()) {
4789 // IFUNC: [strtab offset, strtab size, 0, 0, 0, linkage]
4790 Vals.push_back(StrtabBuilder.add(I.getName()));
4791 Vals.push_back(I.getName().size());
4792 Vals.push_back(0);
4793 Vals.push_back(0);
4794 Vals.push_back(0);
4795 Vals.push_back(getEncodedLinkage(I));
4796
4797 Stream.EmitRecord(bitc::MODULE_CODE_IFUNC, Vals);
4798 Vals.clear();
4799 }
4800}
4801
4802void ThinLinkBitcodeWriter::write() {
4803 Stream.EnterSubblock(bitc::MODULE_BLOCK_ID, 3);
4804
4805 writeModuleVersion();
4806
4807 writeSimplifiedModuleInfo();
4808
4809 writePerModuleGlobalValueSummary();
4810
4811 // Write module hash.
4812 Stream.EmitRecord(bitc::MODULE_CODE_HASH, ArrayRef<uint32_t>(*ModHash));
4813
4814 Stream.ExitBlock();
4815}
4816
4817void BitcodeWriter::writeThinLinkBitcode(const Module &M,
4818 const ModuleSummaryIndex &Index,
4819 const ModuleHash &ModHash) {
4820 assert(!WroteStrtab)((void)0);
4821
4822 // The Mods vector is used by irsymtab::build, which requires non-const
4823 // Modules in case it needs to materialize metadata. But the bitcode writer
4824 // requires that the module is materialized, so we can cast to non-const here,
4825 // after checking that it is in fact materialized.
4826 assert(M.isMaterialized())((void)0);
4827 Mods.push_back(const_cast<Module *>(&M));
4828
4829 ThinLinkBitcodeWriter ThinLinkWriter(M, StrtabBuilder, *Stream, Index,
4830 ModHash);
4831 ThinLinkWriter.write();
4832}
4833
4834// Write the specified thin link bitcode file to the given raw output stream,
4835// where it will be written in a new bitcode block. This is used when
4836// writing the per-module index file for ThinLTO.
4837void llvm::WriteThinLinkBitcodeToFile(const Module &M, raw_ostream &Out,
4838 const ModuleSummaryIndex &Index,
4839 const ModuleHash &ModHash) {
4840 SmallVector<char, 0> Buffer;
4841 Buffer.reserve(256 * 1024);
4842
4843 BitcodeWriter Writer(Buffer);
4844 Writer.writeThinLinkBitcode(M, Index, ModHash);
4845 Writer.writeSymtab();
4846 Writer.writeStrtab();
4847
4848 Out.write((char *)&Buffer.front(), Buffer.size());
4849}
4850
4851static const char *getSectionNameForBitcode(const Triple &T) {
4852 switch (T.getObjectFormat()) {
4853 case Triple::MachO:
4854 return "__LLVM,__bitcode";
4855 case Triple::COFF:
4856 case Triple::ELF:
4857 case Triple::Wasm:
4858 case Triple::UnknownObjectFormat:
4859 return ".llvmbc";
4860 case Triple::GOFF:
4861 llvm_unreachable("GOFF is not yet implemented")__builtin_unreachable();
4862 break;
4863 case Triple::XCOFF:
4864 llvm_unreachable("XCOFF is not yet implemented")__builtin_unreachable();
4865 break;
4866 }
4867 llvm_unreachable("Unimplemented ObjectFormatType")__builtin_unreachable();
4868}
4869
4870static const char *getSectionNameForCommandline(const Triple &T) {
4871 switch (T.getObjectFormat()) {
4872 case Triple::MachO:
4873 return "__LLVM,__cmdline";
4874 case Triple::COFF:
4875 case Triple::ELF:
4876 case Triple::Wasm:
4877 case Triple::UnknownObjectFormat:
4878 return ".llvmcmd";
4879 case Triple::GOFF:
4880 llvm_unreachable("GOFF is not yet implemented")__builtin_unreachable();
4881 break;
4882 case Triple::XCOFF:
4883 llvm_unreachable("XCOFF is not yet implemented")__builtin_unreachable();
4884 break;
4885 }
4886 llvm_unreachable("Unimplemented ObjectFormatType")__builtin_unreachable();
4887}
4888
4889void llvm::EmbedBitcodeInModule(llvm::Module &M, llvm::MemoryBufferRef Buf,
4890 bool EmbedBitcode, bool EmbedCmdline,
4891 const std::vector<uint8_t> &CmdArgs) {
4892 // Save llvm.compiler.used and remove it.
4893 SmallVector<Constant *, 2> UsedArray;
4894 SmallVector<GlobalValue *, 4> UsedGlobals;
4895 Type *UsedElementType = Type::getInt8Ty(M.getContext())->getPointerTo(0);
4896 GlobalVariable *Used = collectUsedGlobalVariables(M, UsedGlobals, true);
4897 for (auto *GV : UsedGlobals) {
1
Assuming '__begin1' is equal to '__end1'
→
4898 if (GV->getName() != "llvm.embedded.module" &&
4899 GV->getName() != "llvm.cmdline")
4900 UsedArray.push_back(
4901 ConstantExpr::getPointerBitCastOrAddrSpaceCast(GV, UsedElementType));
4902 }
4903 if (Used)
2
←
Assuming 'Used' is null
→
3
←
Taking false branch
→
4904 Used->eraseFromParent();
4905
4906 // Embed the bitcode for the llvm module.
4907 std::string Data;
4908 ArrayRef<uint8_t> ModuleData;
4909 Triple T(M.getTargetTriple());
4910
4911 if (EmbedBitcode) {
4
←
Assuming 'EmbedBitcode' is true
→
5
←
Taking true branch
→
4912 if (Buf.getBufferSize() == 0 ||
6
←
Assuming the condition is true
→
4913 !isBitcode((const unsigned char *)Buf.getBufferStart(),
4914 (const unsigned char *)Buf.getBufferEnd())) {
4915 // If the input is LLVM Assembly, bitcode is produced by serializing
4916 // the module. Use-lists order need to be preserved in this case.
4917 llvm::raw_string_ostream OS(Data);
4918 llvm::WriteBitcodeToFile(M, OS, /* ShouldPreserveUseListOrder */ true);
7
←
Calling 'WriteBitcodeToFile'
→
4919 ModuleData =
4920 ArrayRef<uint8_t>((const uint8_t *)OS.str().data(), OS.str().size());
4921 } else
4922 // If the input is LLVM bitcode, write the input byte stream directly.
4923 ModuleData = ArrayRef<uint8_t>((const uint8_t *)Buf.getBufferStart(),
4924 Buf.getBufferSize());
4925 }
4926 llvm::Constant *ModuleConstant =
4927 llvm::ConstantDataArray::get(M.getContext(), ModuleData);
4928 llvm::GlobalVariable *GV = new llvm::GlobalVariable(
4929 M, ModuleConstant->getType(), true, llvm::GlobalValue::PrivateLinkage,
4930 ModuleConstant);
4931 GV->setSection(getSectionNameForBitcode(T));
4932 // Set alignment to 1 to prevent padding between two contributions from input
4933 // sections after linking.
4934 GV->setAlignment(Align(1));
4935 UsedArray.push_back(
4936 ConstantExpr::getPointerBitCastOrAddrSpaceCast(GV, UsedElementType));
4937 if (llvm::GlobalVariable *Old =
4938 M.getGlobalVariable("llvm.embedded.module", true)) {
4939 assert(Old->hasOneUse() &&((void)0)
4940 "llvm.embedded.module can only be used once in llvm.compiler.used")((void)0);
4941 GV->takeName(Old);
4942 Old->eraseFromParent();
4943 } else {
4944 GV->setName("llvm.embedded.module");
4945 }
4946
4947 // Skip if only bitcode needs to be embedded.
4948 if (EmbedCmdline) {
4949 // Embed command-line options.
4950 ArrayRef<uint8_t> CmdData(const_cast<uint8_t *>(CmdArgs.data()),
4951 CmdArgs.size());
4952 llvm::Constant *CmdConstant =
4953 llvm::ConstantDataArray::get(M.getContext(), CmdData);
4954 GV = new llvm::GlobalVariable(M, CmdConstant->getType(), true,
4955 llvm::GlobalValue::PrivateLinkage,
4956 CmdConstant);
4957 GV->setSection(getSectionNameForCommandline(T));
4958 GV->setAlignment(Align(1));
4959 UsedArray.push_back(
4960 ConstantExpr::getPointerBitCastOrAddrSpaceCast(GV, UsedElementType));
4961 if (llvm::GlobalVariable *Old = M.getGlobalVariable("llvm.cmdline", true)) {
4962 assert(Old->hasOneUse() &&((void)0)
4963 "llvm.cmdline can only be used once in llvm.compiler.used")((void)0);
4964 GV->takeName(Old);
4965 Old->eraseFromParent();
4966 } else {
4967 GV->setName("llvm.cmdline");
4968 }
4969 }
4970
4971 if (UsedArray.empty())
4972 return;
4973
4974 // Recreate llvm.compiler.used.
4975 ArrayType *ATy = ArrayType::get(UsedElementType, UsedArray.size());
4976 auto *NewUsed = new GlobalVariable(
4977 M, ATy, false, llvm::GlobalValue::AppendingLinkage,
4978 llvm::ConstantArray::get(ATy, UsedArray), "llvm.compiler.used");
4979 NewUsed->setSection("llvm.metadata");
4980}
←

/usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Bitstream/BitstreamWriter.h

1//===- BitstreamWriter.h - Low-level bitstream writer interface -*- 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 the BitstreamWriter class. This class can be used to
10// write an arbitrary bitstream, regardless of its contents.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_BITSTREAM_BITSTREAMWRITER_H
15#define LLVM_BITSTREAM_BITSTREAMWRITER_H
16
17#include "llvm/ADT/ArrayRef.h"
18#include "llvm/ADT/Optional.h"
19#include "llvm/ADT/SmallVector.h"
20#include "llvm/ADT/StringRef.h"
21#include "llvm/Bitstream/BitCodes.h"
22#include "llvm/Support/Endian.h"
23#include "llvm/Support/MathExtras.h"
24#include "llvm/Support/raw_ostream.h"
25#include <algorithm>
26#include <vector>
27
28namespace llvm {
29
30class BitstreamWriter {
31 /// Out - The buffer that keeps unflushed bytes.
32 SmallVectorImpl<char> &Out;
33
34 /// FS - The file stream that Out flushes to. If FS is nullptr, it does not
35 /// support read or seek, Out cannot be flushed until all data are written.
36 raw_fd_stream *FS;
37
38 /// FlushThreshold - If FS is valid, this is the threshold (unit B) to flush
39 /// FS.
40 const uint64_t FlushThreshold;
41
42 /// CurBit - Always between 0 and 31 inclusive, specifies the next bit to use.
43 unsigned CurBit;
44
45 /// CurValue - The current value. Only bits < CurBit are valid.
46 uint32_t CurValue;
47
48 /// CurCodeSize - This is the declared size of code values used for the
49 /// current block, in bits.
50 unsigned CurCodeSize;
51
52 /// BlockInfoCurBID - When emitting a BLOCKINFO_BLOCK, this is the currently
53 /// selected BLOCK ID.
54 unsigned BlockInfoCurBID;
55
56 /// CurAbbrevs - Abbrevs installed at in this block.
57 std::vector<std::shared_ptr<BitCodeAbbrev>> CurAbbrevs;
58
59 struct Block {
60 unsigned PrevCodeSize;
61 size_t StartSizeWord;
62 std::vector<std::shared_ptr<BitCodeAbbrev>> PrevAbbrevs;
63 Block(unsigned PCS, size_t SSW) : PrevCodeSize(PCS), StartSizeWord(SSW) {}
64 };
65
66 /// BlockScope - This tracks the current blocks that we have entered.
67 std::vector<Block> BlockScope;
68
69 /// BlockInfo - This contains information emitted to BLOCKINFO_BLOCK blocks.
70 /// These describe abbreviations that all blocks of the specified ID inherit.
71 struct BlockInfo {
72 unsigned BlockID;
73 std::vector<std::shared_ptr<BitCodeAbbrev>> Abbrevs;
74 };
75 std::vector<BlockInfo> BlockInfoRecords;
76
77 void WriteByte(unsigned char Value) {
78 Out.push_back(Value);
79 FlushToFile();
80 }
81
82 void WriteWord(unsigned Value) {
83 Value = support::endian::byte_swap<uint32_t, support::little>(Value);
84 Out.append(reinterpret_cast<const char *>(&Value),
85 reinterpret_cast<const char *>(&Value + 1));
86 FlushToFile();
87 }
88
89 uint64_t GetNumOfFlushedBytes() const { return FS ? FS->tell() : 0; }
90
91 size_t GetBufferOffset() const { return Out.size() + GetNumOfFlushedBytes(); }
92
93 size_t GetWordIndex() const {
94 size_t Offset = GetBufferOffset();
95 assert((Offset & 3) == 0 && "Not 32-bit aligned")((void)0);
96 return Offset / 4;
97 }
98
99 /// If the related file stream supports reading, seeking and writing, flush
100 /// the buffer if its size is above a threshold.
101 void FlushToFile() {
102 if (!FS)
103 return;
104 if (Out.size() < FlushThreshold)
105 return;
106 FS->write((char *)&Out.front(), Out.size());
107 Out.clear();
108 }
109
110public:
111 /// Create a BitstreamWriter that writes to Buffer \p O.
112 ///
113 /// \p FS is the file stream that \p O flushes to incrementally. If \p FS is
114 /// null, \p O does not flush incrementially, but writes to disk at the end.
115 ///
116 /// \p FlushThreshold is the threshold (unit M) to flush \p O if \p FS is
117 /// valid.
118 BitstreamWriter(SmallVectorImpl<char> &O, raw_fd_stream *FS = nullptr,
119 uint32_t FlushThreshold = 512)
120 : Out(O), FS(FS), FlushThreshold(FlushThreshold << 20), CurBit(0),
121 CurValue(0), CurCodeSize(2) {}
122
123 ~BitstreamWriter() {
124 assert(CurBit == 0 && "Unflushed data remaining")((void)0);
125 assert(BlockScope.empty() && CurAbbrevs.empty() && "Block imbalance")((void)0);
126 }
127
128 /// Retrieve the current position in the stream, in bits.
129 uint64_t GetCurrentBitNo() const { return GetBufferOffset() * 8 + CurBit; }
130
131 /// Retrieve the number of bits currently used to encode an abbrev ID.
132 unsigned GetAbbrevIDWidth() const { return CurCodeSize; }
133
134 //===--------------------------------------------------------------------===//
135 // Basic Primitives for emitting bits to the stream.
136 //===--------------------------------------------------------------------===//
137
138 /// Backpatch a 32-bit word in the output at the given bit offset
139 /// with the specified value.
140 void BackpatchWord(uint64_t BitNo, unsigned NewWord) {
141 using namespace llvm::support;
142 uint64_t ByteNo = BitNo / 8;
143 uint64_t StartBit = BitNo & 7;
144 uint64_t NumOfFlushedBytes = GetNumOfFlushedBytes();
145
146 if (ByteNo >= NumOfFlushedBytes) {
147 assert((!endian::readAtBitAlignment<uint32_t, little, unaligned>(((void)0)
148 &Out[ByteNo - NumOfFlushedBytes], StartBit)) &&((void)0)
149 "Expected to be patching over 0-value placeholders")((void)0);
150 endian::writeAtBitAlignment<uint32_t, little, unaligned>(
151 &Out[ByteNo - NumOfFlushedBytes], NewWord, StartBit);
152 return;
153 }
154
155 // If the byte offset to backpatch is flushed, use seek to backfill data.
156 // First, save the file position to restore later.
157 uint64_t CurPos = FS->tell();
158
159 // Copy data to update into Bytes from the file FS and the buffer Out.
160 char Bytes[9]; // Use one more byte to silence a warning from Visual C++.
161 size_t BytesNum = StartBit ? 8 : 4;
162 size_t BytesFromDisk = std::min(static_cast<uint64_t>(BytesNum), NumOfFlushedBytes - ByteNo);
163 size_t BytesFromBuffer = BytesNum - BytesFromDisk;
164
165 // When unaligned, copy existing data into Bytes from the file FS and the
166 // buffer Out so that it can be updated before writing. For debug builds
167 // read bytes unconditionally in order to check that the existing value is 0
168 // as expected.
169#ifdef NDEBUG1
170 if (StartBit)
171#endif
172 {
173 FS->seek(ByteNo);
174 ssize_t BytesRead = FS->read(Bytes, BytesFromDisk);
175 (void)BytesRead; // silence warning
176 assert(BytesRead >= 0 && static_cast<size_t>(BytesRead) == BytesFromDisk)((void)0);
177 for (size_t i = 0; i < BytesFromBuffer; ++i)
178 Bytes[BytesFromDisk + i] = Out[i];
179 assert((!endian::readAtBitAlignment<uint32_t, little, unaligned>(((void)0)
180 Bytes, StartBit)) &&((void)0)
181 "Expected to be patching over 0-value placeholders")((void)0);
182 }
183
184 // Update Bytes in terms of bit offset and value.
185 endian::writeAtBitAlignment<uint32_t, little, unaligned>(Bytes, NewWord,
186 StartBit);
187
188 // Copy updated data back to the file FS and the buffer Out.
189 FS->seek(ByteNo);
190 FS->write(Bytes, BytesFromDisk);
191 for (size_t i = 0; i < BytesFromBuffer; ++i)
192 Out[i] = Bytes[BytesFromDisk + i];
193
194 // Restore the file position.
195 FS->seek(CurPos);
196 }
197
198 void BackpatchWord64(uint64_t BitNo, uint64_t Val) {
199 BackpatchWord(BitNo, (uint32_t)Val);
200 BackpatchWord(BitNo + 32, (uint32_t)(Val >> 32));
201 }
202
203 void Emit(uint32_t Val, unsigned NumBits) {
204 assert(NumBits && NumBits <= 32 && "Invalid value size!")((void)0);
205 assert((Val & ~(~0U >> (32-NumBits))) == 0 && "High bits set!")((void)0);
206 CurValue |= Val << CurBit;
207 if (CurBit + NumBits < 32) {
208 CurBit += NumBits;
209 return;
210 }
211
212 // Add the current word.
213 WriteWord(CurValue);
214
215 if (CurBit)
216 CurValue = Val >> (32-CurBit);
217 else
218 CurValue = 0;
219 CurBit = (CurBit+NumBits) & 31;
220 }
221
222 void FlushToWord() {
223 if (CurBit) {
224 WriteWord(CurValue);
225 CurBit = 0;
226 CurValue = 0;
227 }
228 }
229
230 void EmitVBR(uint32_t Val, unsigned NumBits) {
231 assert(NumBits <= 32 && "Too many bits to emit!")((void)0);
232 uint32_t Threshold = 1U << (NumBits-1);
233
234 // Emit the bits with VBR encoding, NumBits-1 bits at a time.
235 while (Val >= Threshold) {
236 Emit((Val & ((1 << (NumBits-1))-1)) | (1 << (NumBits-1)), NumBits);
237 Val >>= NumBits-1;
238 }
239
240 Emit(Val, NumBits);
241 }
242
243 void EmitVBR64(uint64_t Val, unsigned NumBits) {
244 assert(NumBits <= 32 && "Too many bits to emit!")((void)0);
245 if ((uint32_t)Val == Val)
246 return EmitVBR((uint32_t)Val, NumBits);
247
248 uint32_t Threshold = 1U << (NumBits-1);
249
250 // Emit the bits with VBR encoding, NumBits-1 bits at a time.
251 while (Val >= Threshold) {
252 Emit(((uint32_t)Val & ((1 << (NumBits-1))-1)) |
253 (1 << (NumBits-1)), NumBits);
254 Val >>= NumBits-1;
255 }
256
257 Emit((uint32_t)Val, NumBits);
258 }
259
260 /// EmitCode - Emit the specified code.
261 void EmitCode(unsigned Val) {
262 Emit(Val, CurCodeSize);
263 }
264
265 //===--------------------------------------------------------------------===//
266 // Block Manipulation
267 //===--------------------------------------------------------------------===//
268
269 /// getBlockInfo - If there is block info for the specified ID, return it,
270 /// otherwise return null.
271 BlockInfo *getBlockInfo(unsigned BlockID) {
272 // Common case, the most recent entry matches BlockID.
273 if (!BlockInfoRecords.empty() && BlockInfoRecords.back().BlockID == BlockID)
274 return &BlockInfoRecords.back();
275
276 for (unsigned i = 0, e = static_cast<unsigned>(BlockInfoRecords.size());
277 i != e; ++i)
278 if (BlockInfoRecords[i].BlockID == BlockID)
279 return &BlockInfoRecords[i];
280 return nullptr;
281 }
282
283 void EnterSubblock(unsigned BlockID, unsigned CodeLen) {
284 // Block header:
285 // [ENTER_SUBBLOCK, blockid, newcodelen, <align4bytes>, blocklen]
286 EmitCode(bitc::ENTER_SUBBLOCK);
287 EmitVBR(BlockID, bitc::BlockIDWidth);
288 EmitVBR(CodeLen, bitc::CodeLenWidth);
289 FlushToWord();
290
291 size_t BlockSizeWordIndex = GetWordIndex();
292 unsigned OldCodeSize = CurCodeSize;
293
294 // Emit a placeholder, which will be replaced when the block is popped.
295 Emit(0, bitc::BlockSizeWidth);
296
297 CurCodeSize = CodeLen;
298
299 // Push the outer block's abbrev set onto the stack, start out with an
300 // empty abbrev set.
301 BlockScope.emplace_back(OldCodeSize, BlockSizeWordIndex);
302 BlockScope.back().PrevAbbrevs.swap(CurAbbrevs);
303
304 // If there is a blockinfo for this BlockID, add all the predefined abbrevs
305 // to the abbrev list.
306 if (BlockInfo *Info = getBlockInfo(BlockID))
307 append_range(CurAbbrevs, Info->Abbrevs);
308 }
309
310 void ExitBlock() {
311 assert(!BlockScope.empty() && "Block scope imbalance!")((void)0);
312 const Block &B = BlockScope.back();
313
314 // Block tail:
315 // [END_BLOCK, <align4bytes>]
316 EmitCode(bitc::END_BLOCK);
317 FlushToWord();
318
319 // Compute the size of the block, in words, not counting the size field.
320 size_t SizeInWords = GetWordIndex() - B.StartSizeWord - 1;
321 uint64_t BitNo = uint64_t(B.StartSizeWord) * 32;
322
323 // Update the block size field in the header of this sub-block.
324 BackpatchWord(BitNo, SizeInWords);
325
326 // Restore the inner block's code size and abbrev table.
327 CurCodeSize = B.PrevCodeSize;
328 CurAbbrevs = std::move(B.PrevAbbrevs);
329 BlockScope.pop_back();
330 }
331
332 //===--------------------------------------------------------------------===//
333 // Record Emission
334 //===--------------------------------------------------------------------===//
335
336private:
337 /// EmitAbbreviatedLiteral - Emit a literal value according to its abbrev
338 /// record. This is a no-op, since the abbrev specifies the literal to use.
339 template<typename uintty>
340 void EmitAbbreviatedLiteral(const BitCodeAbbrevOp &Op, uintty V) {
341 assert(Op.isLiteral() && "Not a literal")((void)0);
342 // If the abbrev specifies the literal value to use, don't emit
343 // anything.
344 assert(V == Op.getLiteralValue() &&((void)0)
345 "Invalid abbrev for record!")((void)0);
346 }
347
348 /// EmitAbbreviatedField - Emit a single scalar field value with the specified
349 /// encoding.
350 template<typename uintty>
351 void EmitAbbreviatedField(const BitCodeAbbrevOp &Op, uintty V) {
352 assert(!Op.isLiteral() && "Literals should use EmitAbbreviatedLiteral!")((void)0);
353
354 // Encode the value as we are commanded.
355 switch (Op.getEncoding()) {
356 default: llvm_unreachable("Unknown encoding!")__builtin_unreachable();
357 case BitCodeAbbrevOp::Fixed:
358 if (Op.getEncodingData())
359 Emit((unsigned)V, (unsigned)Op.getEncodingData());
360 break;
361 case BitCodeAbbrevOp::VBR:
362 if (Op.getEncodingData())
363 EmitVBR64(V, (unsigned)Op.getEncodingData());
364 break;
365 case BitCodeAbbrevOp::Char6:
366 Emit(BitCodeAbbrevOp::EncodeChar6((char)V), 6);
367 break;
368 }
369 }
370
371 /// EmitRecordWithAbbrevImpl - This is the core implementation of the record
372 /// emission code. If BlobData is non-null, then it specifies an array of
373 /// data that should be emitted as part of the Blob or Array operand that is
374 /// known to exist at the end of the record. If Code is specified, then
375 /// it is the record code to emit before the Vals, which must not contain
376 /// the code.
377 template <typename uintty>
378 void EmitRecordWithAbbrevImpl(unsigned Abbrev, ArrayRef<uintty> Vals,
379 StringRef Blob, Optional<unsigned> Code) {
380 const char *BlobData = Blob.data();
381 unsigned BlobLen = (unsigned) Blob.size();
382 unsigned AbbrevNo = Abbrev-bitc::FIRST_APPLICATION_ABBREV;
383 assert(AbbrevNo < CurAbbrevs.size() && "Invalid abbrev #!")((void)0);
384 const BitCodeAbbrev *Abbv = CurAbbrevs[AbbrevNo].get();
385
386 EmitCode(Abbrev);
387
388 unsigned i = 0, e = static_cast<unsigned>(Abbv->getNumOperandInfos());
389 if (Code) {
390 assert(e && "Expected non-empty abbreviation")((void)0);
391 const BitCodeAbbrevOp &Op = Abbv->getOperandInfo(i++);
392
393 if (Op.isLiteral())
394 EmitAbbreviatedLiteral(Op, Code.getValue());
395 else {
396 assert(Op.getEncoding() != BitCodeAbbrevOp::Array &&((void)0)
397 Op.getEncoding() != BitCodeAbbrevOp::Blob &&((void)0)
398 "Expected literal or scalar")((void)0);
399 EmitAbbreviatedField(Op, Code.getValue());
400 }
401 }
402
403 unsigned RecordIdx = 0;
404 for (; i != e; ++i) {
405 const BitCodeAbbrevOp &Op = Abbv->getOperandInfo(i);
406 if (Op.isLiteral()) {
407 assert(RecordIdx < Vals.size() && "Invalid abbrev/record")((void)0);
408 EmitAbbreviatedLiteral(Op, Vals[RecordIdx]);
409 ++RecordIdx;
410 } else if (Op.getEncoding() == BitCodeAbbrevOp::Array) {
411 // Array case.
412 assert(i + 2 == e && "array op not second to last?")((void)0);
413 const BitCodeAbbrevOp &EltEnc = Abbv->getOperandInfo(++i);
414
415 // If this record has blob data, emit it, otherwise we must have record
416 // entries to encode this way.
417 if (BlobData) {
418 assert(RecordIdx == Vals.size() &&((void)0)
419 "Blob data and record entries specified for array!")((void)0);
420 // Emit a vbr6 to indicate the number of elements present.
421 EmitVBR(static_cast<uint32_t>(BlobLen), 6);
422
423 // Emit each field.
424 for (unsigned i = 0; i != BlobLen; ++i)
425 EmitAbbreviatedField(EltEnc, (unsigned char)BlobData[i]);
426
427 // Know that blob data is consumed for assertion below.
428 BlobData = nullptr;
429 } else {
430 // Emit a vbr6 to indicate the number of elements present.
431 EmitVBR(static_cast<uint32_t>(Vals.size()-RecordIdx), 6);
432
433 // Emit each field.
434 for (unsigned e = Vals.size(); RecordIdx != e; ++RecordIdx)
435 EmitAbbreviatedField(EltEnc, Vals[RecordIdx]);
436 }
437 } else if (Op.getEncoding() == BitCodeAbbrevOp::Blob) {
438 // If this record has blob data, emit it, otherwise we must have record
439 // entries to encode this way.
440
441 if (BlobData) {
442 assert(RecordIdx == Vals.size() &&((void)0)
443 "Blob data and record entries specified for blob operand!")((void)0);
444
445 assert(Blob.data() == BlobData && "BlobData got moved")((void)0);
446 assert(Blob.size() == BlobLen && "BlobLen got changed")((void)0);
447 emitBlob(Blob);
448 BlobData = nullptr;
449 } else {
450 emitBlob(Vals.slice(RecordIdx));
451 }
452 } else { // Single scalar field.
453 assert(RecordIdx < Vals.size() && "Invalid abbrev/record")((void)0);
454 EmitAbbreviatedField(Op, Vals[RecordIdx]);
455 ++RecordIdx;
456 }
457 }
458 assert(RecordIdx == Vals.size() && "Not all record operands emitted!")((void)0);
459 assert(BlobData == nullptr &&((void)0)
460 "Blob data specified for record that doesn't use it!")((void)0);
461 }
462
463public:
464 /// Emit a blob, including flushing before and tail-padding.
465 template <class UIntTy>
466 void emitBlob(ArrayRef<UIntTy> Bytes, bool ShouldEmitSize = true) {
467 // Emit a vbr6 to indicate the number of elements present.
468 if (ShouldEmitSize)
469 EmitVBR(static_cast<uint32_t>(Bytes.size()), 6);
470
471 // Flush to a 32-bit alignment boundary.
472 FlushToWord();
473
474 // Emit literal bytes.
475 for (const auto &B : Bytes) {
476 assert(isUInt<8>(B) && "Value too large to emit as byte")((void)0);
477 WriteByte((unsigned char)B);
478 }
479
480 // Align end to 32-bits.
481 while (GetBufferOffset() & 3)
482 WriteByte(0);
483 }
484 void emitBlob(StringRef Bytes, bool ShouldEmitSize = true) {
485 emitBlob(makeArrayRef((const uint8_t *)Bytes.data(), Bytes.size()),
486 ShouldEmitSize);
487 }
488
489 /// EmitRecord - Emit the specified record to the stream, using an abbrev if
490 /// we have one to compress the output.
491 template <typename Container>
492 void EmitRecord(unsigned Code, const Container &Vals, unsigned Abbrev = 0) {
493 if (!Abbrev) {
21
←
Assuming 'Abbrev' is 0
→
22
←
Taking true branch
→
494 // If we don't have an abbrev to use, emit this in its fully unabbreviated
495 // form.
496 auto Count = static_cast<uint32_t>(makeArrayRef(Vals).size());
497 EmitCode(bitc::UNABBREV_RECORD);
498 EmitVBR(Code, 6);
499 EmitVBR(Count, 6);
500 for (unsigned i = 0, e = Count; i != e; ++i)
23
←
Assuming 'i' is not equal to 'e'
→
24
←
Loop condition is true. Entering loop body
→
25
←
Assuming 'i' is not equal to 'e'
→
26
←
Loop condition is true. Entering loop body
→
27
←
The value 2 is assigned to 'i'
→
28
←
Assuming 'i' is not equal to 'e'
→
29
←
Loop condition is true. Entering loop body
→
501 EmitVBR64(Vals[i], 6);
30
←
1st function call argument is an uninitialized value
502 return;
503 }
504
505 EmitRecordWithAbbrevImpl(Abbrev, makeArrayRef(Vals), StringRef(), Code);
506 }
507
508 /// EmitRecordWithAbbrev - Emit a record with the specified abbreviation.
509 /// Unlike EmitRecord, the code for the record should be included in Vals as
510 /// the first entry.
511 template <typename Container>
512 void EmitRecordWithAbbrev(unsigned Abbrev, const Container &Vals) {
513 EmitRecordWithAbbrevImpl(Abbrev, makeArrayRef(Vals), StringRef(), None);
514 }
515
516 /// EmitRecordWithBlob - Emit the specified record to the stream, using an
517 /// abbrev that includes a blob at the end. The blob data to emit is
518 /// specified by the pointer and length specified at the end. In contrast to
519 /// EmitRecord, this routine expects that the first entry in Vals is the code
520 /// of the record.
521 template <typename Container>
522 void EmitRecordWithBlob(unsigned Abbrev, const Container &Vals,
523 StringRef Blob) {
524 EmitRecordWithAbbrevImpl(Abbrev, makeArrayRef(Vals), Blob, None);
525 }
526 template <typename Container>
527 void EmitRecordWithBlob(unsigned Abbrev, const Container &Vals,
528 const char *BlobData, unsigned BlobLen) {
529 return EmitRecordWithAbbrevImpl(Abbrev, makeArrayRef(Vals),
530 StringRef(BlobData, BlobLen), None);
531 }
532
533 /// EmitRecordWithArray - Just like EmitRecordWithBlob, works with records
534 /// that end with an array.
535 template <typename Container>
536 void EmitRecordWithArray(unsigned Abbrev, const Container &Vals,
537 StringRef Array) {
538 EmitRecordWithAbbrevImpl(Abbrev, makeArrayRef(Vals), Array, None);
539 }
540 template <typename Container>
541 void EmitRecordWithArray(unsigned Abbrev, const Container &Vals,
542 const char *ArrayData, unsigned ArrayLen) {
543 return EmitRecordWithAbbrevImpl(Abbrev, makeArrayRef(Vals),
544 StringRef(ArrayData, ArrayLen), None);
545 }
546
547 //===--------------------------------------------------------------------===//
548 // Abbrev Emission
549 //===--------------------------------------------------------------------===//
550
551private:
552 // Emit the abbreviation as a DEFINE_ABBREV record.
553 void EncodeAbbrev(const BitCodeAbbrev &Abbv) {
554 EmitCode(bitc::DEFINE_ABBREV);
555 EmitVBR(Abbv.getNumOperandInfos(), 5);
556 for (unsigned i = 0, e = static_cast<unsigned>(Abbv.getNumOperandInfos());
557 i != e; ++i) {
558 const BitCodeAbbrevOp &Op = Abbv.getOperandInfo(i);
559 Emit(Op.isLiteral(), 1);
560 if (Op.isLiteral()) {
561 EmitVBR64(Op.getLiteralValue(), 8);
562 } else {
563 Emit(Op.getEncoding(), 3);
564 if (Op.hasEncodingData())
565 EmitVBR64(Op.getEncodingData(), 5);
566 }
567 }
568 }
569public:
570
571 /// Emits the abbreviation \p Abbv to the stream.
572 unsigned EmitAbbrev(std::shared_ptr<BitCodeAbbrev> Abbv) {
573 EncodeAbbrev(*Abbv);
574 CurAbbrevs.push_back(std::move(Abbv));
575 return static_cast<unsigned>(CurAbbrevs.size())-1 +
576 bitc::FIRST_APPLICATION_ABBREV;
577 }
578
579 //===--------------------------------------------------------------------===//
580 // BlockInfo Block Emission
581 //===--------------------------------------------------------------------===//
582
583 /// EnterBlockInfoBlock - Start emitting the BLOCKINFO_BLOCK.
584 void EnterBlockInfoBlock() {
585 EnterSubblock(bitc::BLOCKINFO_BLOCK_ID, 2);
586 BlockInfoCurBID = ~0U;
587 BlockInfoRecords.clear();
588 }
589private:
590 /// SwitchToBlockID - If we aren't already talking about the specified block
591 /// ID, emit a BLOCKINFO_CODE_SETBID record.
592 void SwitchToBlockID(unsigned BlockID) {
593 if (BlockInfoCurBID == BlockID) return;
594 SmallVector<unsigned, 2> V;
595 V.push_back(BlockID);
596 EmitRecord(bitc::BLOCKINFO_CODE_SETBID, V);
597 BlockInfoCurBID = BlockID;
598 }
599
600 BlockInfo &getOrCreateBlockInfo(unsigned BlockID) {
601 if (BlockInfo *BI = getBlockInfo(BlockID))
602 return *BI;
603
604 // Otherwise, add a new record.
605 BlockInfoRecords.emplace_back();
606 BlockInfoRecords.back().BlockID = BlockID;
607 return BlockInfoRecords.back();
608 }
609
610public:
611
612 /// EmitBlockInfoAbbrev - Emit a DEFINE_ABBREV record for the specified
613 /// BlockID.
614 unsigned EmitBlockInfoAbbrev(unsigned BlockID, std::shared_ptr<BitCodeAbbrev> Abbv) {
615 SwitchToBlockID(BlockID);
616 EncodeAbbrev(*Abbv);
617
618 // Add the abbrev to the specified block record.
619 BlockInfo &Info = getOrCreateBlockInfo(BlockID);
620 Info.Abbrevs.push_back(std::move(Abbv));
621
622 return Info.Abbrevs.size()-1+bitc::FIRST_APPLICATION_ABBREV;
623 }
624};
625
626
627} // End llvm namespace
628
629#endif