xref: /freebsd/contrib/llvm-project/llvm/lib/Remarks/BitstreamRemarkSerializer.cpp (revision 7ef62cebc2f965b0f640263e179276928885e33d) 
1 //===- BitstreamRemarkSerializer.cpp --------------------------------------===//
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 file provides the implementation of the LLVM bitstream remark serializer
10 // using LLVM's bitstream writer.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "llvm/Remarks/BitstreamRemarkSerializer.h"
15 #include "llvm/Remarks/Remark.h"
16 #include <optional>
17 
18 using namespace llvm;
19 using namespace llvm::remarks;
20 
21 BitstreamRemarkSerializerHelper::BitstreamRemarkSerializerHelper(
22     BitstreamRemarkContainerType ContainerType)
23     : Bitstream(Encoded), ContainerType(ContainerType) {}
24 
25 static void push(SmallVectorImpl<uint64_t> &R, StringRef Str) {
26   append_range(R, Str);
27 }
28 
29 static void setRecordName(unsigned RecordID, BitstreamWriter &Bitstream,
30                           SmallVectorImpl<uint64_t> &R, StringRef Str) {
31   R.clear();
32   R.push_back(RecordID);
33   push(R, Str);
34   Bitstream.EmitRecord(bitc::BLOCKINFO_CODE_SETRECORDNAME, R);
35 }
36 
37 static void initBlock(unsigned BlockID, BitstreamWriter &Bitstream,
38                       SmallVectorImpl<uint64_t> &R, StringRef Str) {
39   R.clear();
40   R.push_back(BlockID);
41   Bitstream.EmitRecord(bitc::BLOCKINFO_CODE_SETBID, R);
42 
43   R.clear();
44   push(R, Str);
45   Bitstream.EmitRecord(bitc::BLOCKINFO_CODE_BLOCKNAME, R);
46 }
47 
48 void BitstreamRemarkSerializerHelper::setupMetaBlockInfo() {
49   // Setup the metadata block.
50   initBlock(META_BLOCK_ID, Bitstream, R, MetaBlockName);
51 
52   // The container information.
53   setRecordName(RECORD_META_CONTAINER_INFO, Bitstream, R,
54                 MetaContainerInfoName);
55 
56   auto Abbrev = std::make_shared<BitCodeAbbrev>();
57   Abbrev->Add(BitCodeAbbrevOp(RECORD_META_CONTAINER_INFO));
58   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Version.
59   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2));  // Type.
60   RecordMetaContainerInfoAbbrevID =
61       Bitstream.EmitBlockInfoAbbrev(META_BLOCK_ID, Abbrev);
62 }
63 
64 void BitstreamRemarkSerializerHelper::setupMetaRemarkVersion() {
65   setRecordName(RECORD_META_REMARK_VERSION, Bitstream, R,
66                 MetaRemarkVersionName);
67 
68   auto Abbrev = std::make_shared<BitCodeAbbrev>();
69   Abbrev->Add(BitCodeAbbrevOp(RECORD_META_REMARK_VERSION));
70   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Version.
71   RecordMetaRemarkVersionAbbrevID =
72       Bitstream.EmitBlockInfoAbbrev(META_BLOCK_ID, Abbrev);
73 }
74 
75 void BitstreamRemarkSerializerHelper::emitMetaRemarkVersion(
76     uint64_t RemarkVersion) {
77   // The remark version is emitted only if we emit remarks.
78   R.clear();
79   R.push_back(RECORD_META_REMARK_VERSION);
80   R.push_back(RemarkVersion);
81   Bitstream.EmitRecordWithAbbrev(RecordMetaRemarkVersionAbbrevID, R);
82 }
83 
84 void BitstreamRemarkSerializerHelper::setupMetaStrTab() {
85   setRecordName(RECORD_META_STRTAB, Bitstream, R, MetaStrTabName);
86 
87   auto Abbrev = std::make_shared<BitCodeAbbrev>();
88   Abbrev->Add(BitCodeAbbrevOp(RECORD_META_STRTAB));
89   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Raw table.
90   RecordMetaStrTabAbbrevID =
91       Bitstream.EmitBlockInfoAbbrev(META_BLOCK_ID, Abbrev);
92 }
93 
94 void BitstreamRemarkSerializerHelper::emitMetaStrTab(
95     const StringTable &StrTab) {
96   // The string table is not emitted if we emit remarks separately.
97   R.clear();
98   R.push_back(RECORD_META_STRTAB);
99 
100   // Serialize to a blob.
101   std::string Buf;
102   raw_string_ostream OS(Buf);
103   StrTab.serialize(OS);
104   StringRef Blob = OS.str();
105   Bitstream.EmitRecordWithBlob(RecordMetaStrTabAbbrevID, R, Blob);
106 }
107 
108 void BitstreamRemarkSerializerHelper::setupMetaExternalFile() {
109   setRecordName(RECORD_META_EXTERNAL_FILE, Bitstream, R, MetaExternalFileName);
110 
111   auto Abbrev = std::make_shared<BitCodeAbbrev>();
112   Abbrev->Add(BitCodeAbbrevOp(RECORD_META_EXTERNAL_FILE));
113   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Filename.
114   RecordMetaExternalFileAbbrevID =
115       Bitstream.EmitBlockInfoAbbrev(META_BLOCK_ID, Abbrev);
116 }
117 
118 void BitstreamRemarkSerializerHelper::emitMetaExternalFile(StringRef Filename) {
119   // The external file is emitted only if we emit the separate metadata.
120   R.clear();
121   R.push_back(RECORD_META_EXTERNAL_FILE);
122   Bitstream.EmitRecordWithBlob(RecordMetaExternalFileAbbrevID, R, Filename);
123 }
124 
125 void BitstreamRemarkSerializerHelper::setupRemarkBlockInfo() {
126   // Setup the remark block.
127   initBlock(REMARK_BLOCK_ID, Bitstream, R, RemarkBlockName);
128 
129   // The header of a remark.
130   {
131     setRecordName(RECORD_REMARK_HEADER, Bitstream, R, RemarkHeaderName);
132 
133     auto Abbrev = std::make_shared<BitCodeAbbrev>();
134     Abbrev->Add(BitCodeAbbrevOp(RECORD_REMARK_HEADER));
135     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // Type
136     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // Remark Name
137     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // Pass name
138     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // Function name
139     RecordRemarkHeaderAbbrevID =
140         Bitstream.EmitBlockInfoAbbrev(REMARK_BLOCK_ID, Abbrev);
141   }
142 
143   // The location of a remark.
144   {
145     setRecordName(RECORD_REMARK_DEBUG_LOC, Bitstream, R, RemarkDebugLocName);
146 
147     auto Abbrev = std::make_shared<BitCodeAbbrev>();
148     Abbrev->Add(BitCodeAbbrevOp(RECORD_REMARK_DEBUG_LOC));
149     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 7));    // File
150     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Line
151     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Column
152     RecordRemarkDebugLocAbbrevID =
153         Bitstream.EmitBlockInfoAbbrev(REMARK_BLOCK_ID, Abbrev);
154   }
155 
156   // The hotness of a remark.
157   {
158     setRecordName(RECORD_REMARK_HOTNESS, Bitstream, R, RemarkHotnessName);
159 
160     auto Abbrev = std::make_shared<BitCodeAbbrev>();
161     Abbrev->Add(BitCodeAbbrevOp(RECORD_REMARK_HOTNESS));
162     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Hotness
163     RecordRemarkHotnessAbbrevID =
164         Bitstream.EmitBlockInfoAbbrev(REMARK_BLOCK_ID, Abbrev);
165   }
166 
167   // An argument entry with a debug location attached.
168   {
169     setRecordName(RECORD_REMARK_ARG_WITH_DEBUGLOC, Bitstream, R,
170                   RemarkArgWithDebugLocName);
171 
172     auto Abbrev = std::make_shared<BitCodeAbbrev>();
173     Abbrev->Add(BitCodeAbbrevOp(RECORD_REMARK_ARG_WITH_DEBUGLOC));
174     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 7));    // Key
175     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 7));    // Value
176     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 7));    // File
177     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Line
178     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Column
179     RecordRemarkArgWithDebugLocAbbrevID =
180         Bitstream.EmitBlockInfoAbbrev(REMARK_BLOCK_ID, Abbrev);
181   }
182 
183   // An argument entry with no debug location attached.
184   {
185     setRecordName(RECORD_REMARK_ARG_WITHOUT_DEBUGLOC, Bitstream, R,
186                   RemarkArgWithoutDebugLocName);
187 
188     auto Abbrev = std::make_shared<BitCodeAbbrev>();
189     Abbrev->Add(BitCodeAbbrevOp(RECORD_REMARK_ARG_WITHOUT_DEBUGLOC));
190     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 7)); // Key
191     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 7)); // Value
192     RecordRemarkArgWithoutDebugLocAbbrevID =
193         Bitstream.EmitBlockInfoAbbrev(REMARK_BLOCK_ID, Abbrev);
194   }
195 }
196 
197 void BitstreamRemarkSerializerHelper::setupBlockInfo() {
198   // Emit magic number.
199   for (const char C : ContainerMagic)
200     Bitstream.Emit(static_cast<unsigned>(C), 8);
201 
202   Bitstream.EnterBlockInfoBlock();
203 
204   // Setup the main metadata. Depending on the container type, we'll setup the
205   // required records next.
206   setupMetaBlockInfo();
207 
208   switch (ContainerType) {
209   case BitstreamRemarkContainerType::SeparateRemarksMeta:
210     // Needs a string table that the separate remark file is using.
211     setupMetaStrTab();
212     // Needs to know where the external remarks file is.
213     setupMetaExternalFile();
214     break;
215   case BitstreamRemarkContainerType::SeparateRemarksFile:
216     // Contains remarks: emit the version.
217     setupMetaRemarkVersion();
218     // Contains remarks: emit the remark abbrevs.
219     setupRemarkBlockInfo();
220     break;
221   case BitstreamRemarkContainerType::Standalone:
222     // Contains remarks: emit the version.
223     setupMetaRemarkVersion();
224     // Needs a string table.
225     setupMetaStrTab();
226     // Contains remarks: emit the remark abbrevs.
227     setupRemarkBlockInfo();
228     break;
229   }
230 
231   Bitstream.ExitBlock();
232 }
233 
234 void BitstreamRemarkSerializerHelper::emitMetaBlock(
235     uint64_t ContainerVersion, std::optional<uint64_t> RemarkVersion,
236     std::optional<const StringTable *> StrTab,
237     std::optional<StringRef> Filename) {
238   // Emit the meta block
239   Bitstream.EnterSubblock(META_BLOCK_ID, 3);
240 
241   // The container version and type.
242   R.clear();
243   R.push_back(RECORD_META_CONTAINER_INFO);
244   R.push_back(ContainerVersion);
245   R.push_back(static_cast<uint64_t>(ContainerType));
246   Bitstream.EmitRecordWithAbbrev(RecordMetaContainerInfoAbbrevID, R);
247 
248   switch (ContainerType) {
249   case BitstreamRemarkContainerType::SeparateRemarksMeta:
250     assert(StrTab != std::nullopt && *StrTab != nullptr);
251     emitMetaStrTab(**StrTab);
252     assert(Filename != std::nullopt);
253     emitMetaExternalFile(*Filename);
254     break;
255   case BitstreamRemarkContainerType::SeparateRemarksFile:
256     assert(RemarkVersion != std::nullopt);
257     emitMetaRemarkVersion(*RemarkVersion);
258     break;
259   case BitstreamRemarkContainerType::Standalone:
260     assert(RemarkVersion != std::nullopt);
261     emitMetaRemarkVersion(*RemarkVersion);
262     assert(StrTab != std::nullopt && *StrTab != nullptr);
263     emitMetaStrTab(**StrTab);
264     break;
265   }
266 
267   Bitstream.ExitBlock();
268 }
269 
270 void BitstreamRemarkSerializerHelper::emitRemarkBlock(const Remark &Remark,
271                                                       StringTable &StrTab) {
272   Bitstream.EnterSubblock(REMARK_BLOCK_ID, 4);
273 
274   R.clear();
275   R.push_back(RECORD_REMARK_HEADER);
276   R.push_back(static_cast<uint64_t>(Remark.RemarkType));
277   R.push_back(StrTab.add(Remark.RemarkName).first);
278   R.push_back(StrTab.add(Remark.PassName).first);
279   R.push_back(StrTab.add(Remark.FunctionName).first);
280   Bitstream.EmitRecordWithAbbrev(RecordRemarkHeaderAbbrevID, R);
281 
282   if (const std::optional<RemarkLocation> &Loc = Remark.Loc) {
283     R.clear();
284     R.push_back(RECORD_REMARK_DEBUG_LOC);
285     R.push_back(StrTab.add(Loc->SourceFilePath).first);
286     R.push_back(Loc->SourceLine);
287     R.push_back(Loc->SourceColumn);
288     Bitstream.EmitRecordWithAbbrev(RecordRemarkDebugLocAbbrevID, R);
289   }
290 
291   if (std::optional<uint64_t> Hotness = Remark.Hotness) {
292     R.clear();
293     R.push_back(RECORD_REMARK_HOTNESS);
294     R.push_back(*Hotness);
295     Bitstream.EmitRecordWithAbbrev(RecordRemarkHotnessAbbrevID, R);
296   }
297 
298   for (const Argument &Arg : Remark.Args) {
299     R.clear();
300     unsigned Key = StrTab.add(Arg.Key).first;
301     unsigned Val = StrTab.add(Arg.Val).first;
302     bool HasDebugLoc = Arg.Loc != std::nullopt;
303     R.push_back(HasDebugLoc ? RECORD_REMARK_ARG_WITH_DEBUGLOC
304                             : RECORD_REMARK_ARG_WITHOUT_DEBUGLOC);
305     R.push_back(Key);
306     R.push_back(Val);
307     if (HasDebugLoc) {
308       R.push_back(StrTab.add(Arg.Loc->SourceFilePath).first);
309       R.push_back(Arg.Loc->SourceLine);
310       R.push_back(Arg.Loc->SourceColumn);
311     }
312     Bitstream.EmitRecordWithAbbrev(HasDebugLoc
313                                        ? RecordRemarkArgWithDebugLocAbbrevID
314                                        : RecordRemarkArgWithoutDebugLocAbbrevID,
315                                    R);
316   }
317   Bitstream.ExitBlock();
318 }
319 
320 void BitstreamRemarkSerializerHelper::flushToStream(raw_ostream &OS) {
321   OS.write(Encoded.data(), Encoded.size());
322   Encoded.clear();
323 }
324 
325 StringRef BitstreamRemarkSerializerHelper::getBuffer() {
326   return StringRef(Encoded.data(), Encoded.size());
327 }
328 
329 BitstreamRemarkSerializer::BitstreamRemarkSerializer(raw_ostream &OS,
330                                                      SerializerMode Mode)
331     : RemarkSerializer(Format::Bitstream, OS, Mode),
332       Helper(BitstreamRemarkContainerType::SeparateRemarksFile) {
333   assert(Mode == SerializerMode::Separate &&
334          "For SerializerMode::Standalone, a pre-filled string table needs to "
335          "be provided.");
336   // We always use a string table with bitstream.
337   StrTab.emplace();
338 }
339 
340 BitstreamRemarkSerializer::BitstreamRemarkSerializer(raw_ostream &OS,
341                                                      SerializerMode Mode,
342                                                      StringTable StrTabIn)
343     : RemarkSerializer(Format::Bitstream, OS, Mode),
344       Helper(Mode == SerializerMode::Separate
345                  ? BitstreamRemarkContainerType::SeparateRemarksFile
346                  : BitstreamRemarkContainerType::Standalone) {
347   StrTab = std::move(StrTabIn);
348 }
349 
350 void BitstreamRemarkSerializer::emit(const Remark &Remark) {
351   if (!DidSetUp) {
352     // Emit the metadata that is embedded in the remark file.
353     // If we're in standalone mode, serialize the string table as well.
354     bool IsStandalone =
355         Helper.ContainerType == BitstreamRemarkContainerType::Standalone;
356     BitstreamMetaSerializer MetaSerializer(
357         OS, Helper,
358         IsStandalone ? &*StrTab
359                      : std::optional<const StringTable *>(std::nullopt));
360     MetaSerializer.emit();
361     DidSetUp = true;
362   }
363 
364   assert(DidSetUp &&
365          "The Block info block and the meta block were not emitted yet.");
366   Helper.emitRemarkBlock(Remark, *StrTab);
367 
368   Helper.flushToStream(OS);
369 }
370 
371 std::unique_ptr<MetaSerializer> BitstreamRemarkSerializer::metaSerializer(
372     raw_ostream &OS, std::optional<StringRef> ExternalFilename) {
373   assert(Helper.ContainerType !=
374          BitstreamRemarkContainerType::SeparateRemarksMeta);
375   bool IsStandalone =
376       Helper.ContainerType == BitstreamRemarkContainerType::Standalone;
377   return std::make_unique<BitstreamMetaSerializer>(
378       OS,
379       IsStandalone ? BitstreamRemarkContainerType::Standalone
380                    : BitstreamRemarkContainerType::SeparateRemarksMeta,
381       &*StrTab, ExternalFilename);
382 }
383 
384 void BitstreamMetaSerializer::emit() {
385   Helper->setupBlockInfo();
386   Helper->emitMetaBlock(CurrentContainerVersion, CurrentRemarkVersion, StrTab,
387                         ExternalFilename);
388   Helper->flushToStream(OS);
389 }
390