1 //===--- SerializedDiagnosticPrinter.cpp - Serializer for diagnostics -----===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include <vector>
11 #include "llvm/Support/raw_ostream.h"
12 #include "llvm/ADT/StringRef.h"
13 #include "llvm/ADT/SmallString.h"
14 #include "llvm/ADT/DenseSet.h"
15 #include "clang/Basic/SourceManager.h"
16 #include "clang/Basic/FileManager.h"
17 #include "clang/Basic/Diagnostic.h"
18 #include "clang/Basic/Version.h"
19 #include "clang/Frontend/SerializedDiagnosticPrinter.h"
20 
21 using namespace clang;
22 using namespace clang::serialized_diags;
23 
24 namespace {
25 
26 class AbbreviationMap {
27   llvm::DenseMap<unsigned, unsigned> Abbrevs;
28 public:
29   AbbreviationMap() {}
30 
31   void set(unsigned recordID, unsigned abbrevID) {
32     assert(Abbrevs.find(recordID) == Abbrevs.end()
33            && "Abbreviation already set.");
34     Abbrevs[recordID] = abbrevID;
35   }
36 
37   unsigned get(unsigned recordID) {
38     assert(Abbrevs.find(recordID) != Abbrevs.end() &&
39            "Abbreviation not set.");
40     return Abbrevs[recordID];
41   }
42 };
43 
44 typedef llvm::SmallVector<uint64_t, 64> RecordData;
45 typedef llvm::SmallVectorImpl<uint64_t> RecordDataImpl;
46 
47 class SDiagsWriter : public DiagnosticConsumer {
48 public:
49   SDiagsWriter(DiagnosticsEngine &diags, llvm::raw_ostream *os)
50     : Stream(Buffer), OS(os), Diags(diags), inNonNoteDiagnostic(false)
51   {
52     EmitPreamble();
53   };
54 
55   ~SDiagsWriter() {}
56 
57   void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
58                         const Diagnostic &Info);
59 
60   void EndSourceFile();
61 
62   DiagnosticConsumer *clone(DiagnosticsEngine &Diags) const {
63     // It makes no sense to clone this.
64     return 0;
65   }
66 
67 private:
68   /// \brief Emit the preamble for the serialized diagnostics.
69   void EmitPreamble();
70 
71   /// \brief Emit the BLOCKINFO block.
72   void EmitBlockInfoBlock();
73 
74   /// \brief Emit the META data block.
75   void EmitMetaBlock();
76 
77   /// \brief Emit a record for a CharSourceRange.
78   void EmitCharSourceRange(CharSourceRange R);
79 
80   /// \brief Emit the string information for the category for a diagnostic.
81   unsigned getEmitCategory(unsigned DiagID);
82 
83   /// \brief Emit the string information for diagnostic flags.
84   unsigned getEmitDiagnosticFlag(DiagnosticsEngine::Level DiagLevel,
85                                  const Diagnostic &Info);
86 
87   /// \brief Emit (lazily) the file string and retrieved the file identifier.
88   unsigned getEmitFile(SourceLocation Loc);
89 
90   /// \brief Add SourceLocation information the specified record.
91   void AddLocToRecord(SourceLocation Loc, RecordDataImpl &Record);
92 
93   /// \brief Add CharSourceRange information the specified record.
94   void AddCharSourceRangeToRecord(CharSourceRange R, RecordDataImpl &Record);
95 
96   /// \brief The version of the diagnostics file.
97   enum { Version = 1 };
98 
99   /// \brief The byte buffer for the serialized content.
100   std::vector<unsigned char> Buffer;
101 
102   /// \brief The BitStreamWriter for the serialized diagnostics.
103   llvm::BitstreamWriter Stream;
104 
105   /// \brief The name of the diagnostics file.
106   llvm::OwningPtr<llvm::raw_ostream> OS;
107 
108   /// \brief The DiagnosticsEngine tied to all diagnostic locations.
109   DiagnosticsEngine &Diags;
110 
111   /// \brief The set of constructed record abbreviations.
112   AbbreviationMap Abbrevs;
113 
114   /// \brief A utility buffer for constructing record content.
115   RecordData Record;
116 
117   /// \brief A text buffer for rendering diagnostic text.
118   llvm::SmallString<256> diagBuf;
119 
120   /// \brief The collection of diagnostic categories used.
121   llvm::DenseSet<unsigned> Categories;
122 
123   /// \brief The collection of files used.
124   llvm::DenseMap<const FileEntry *, unsigned> Files;
125 
126   typedef llvm::DenseMap<const void *, std::pair<unsigned, llvm::StringRef> >
127           DiagFlagsTy;
128 
129   /// \brief Map for uniquing strings.
130   DiagFlagsTy DiagFlags;
131 
132   /// \brief Flag indicating whether or not we are in the process of
133   /// emitting a non-note diagnostic.
134   bool inNonNoteDiagnostic;
135 };
136 } // end anonymous namespace
137 
138 namespace clang {
139 namespace serialized_diags {
140 DiagnosticConsumer *create(llvm::raw_ostream *OS, DiagnosticsEngine &Diags) {
141   return new SDiagsWriter(Diags, OS);
142 }
143 } // end namespace serialized_diags
144 } // end namespace clang
145 
146 //===----------------------------------------------------------------------===//
147 // Serialization methods.
148 //===----------------------------------------------------------------------===//
149 
150 /// \brief Emits a block ID in the BLOCKINFO block.
151 static void EmitBlockID(unsigned ID, const char *Name,
152                         llvm::BitstreamWriter &Stream,
153                         RecordDataImpl &Record) {
154   Record.clear();
155   Record.push_back(ID);
156   Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETBID, Record);
157 
158   // Emit the block name if present.
159   if (Name == 0 || Name[0] == 0)
160     return;
161 
162   Record.clear();
163 
164   while (*Name)
165     Record.push_back(*Name++);
166 
167   Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_BLOCKNAME, Record);
168 }
169 
170 /// \brief Emits a record ID in the BLOCKINFO block.
171 static void EmitRecordID(unsigned ID, const char *Name,
172                          llvm::BitstreamWriter &Stream,
173                          RecordDataImpl &Record){
174   Record.clear();
175   Record.push_back(ID);
176 
177   while (*Name)
178     Record.push_back(*Name++);
179 
180   Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETRECORDNAME, Record);
181 }
182 
183 void SDiagsWriter::AddLocToRecord(SourceLocation Loc,
184                                   RecordDataImpl &Record) {
185   if (Loc.isInvalid()) {
186     // Emit a "sentinel" location.
187     Record.push_back((unsigned) 0); // File.
188     Record.push_back(~(unsigned)0); // Line.
189     Record.push_back(~(unsigned)0); // Column.
190     Record.push_back(~(unsigned)0); // Offset.
191     return;
192   }
193 
194   SourceManager &SM = Diags.getSourceManager();
195   Loc = SM.getSpellingLoc(Loc);
196   Record.push_back(getEmitFile(Loc));
197   Record.push_back(SM.getSpellingLineNumber(Loc));
198   Record.push_back(SM.getSpellingColumnNumber(Loc));
199 
200   std::pair<FileID, unsigned> LocInfo = SM.getDecomposedLoc(Loc);
201   FileID FID = LocInfo.first;
202   unsigned FileOffset = LocInfo.second;
203   Record.push_back(FileOffset);
204 }
205 
206 void SDiagsWriter::AddCharSourceRangeToRecord(CharSourceRange Range,
207                                               RecordDataImpl &Record) {
208   AddLocToRecord(Range.getBegin(), Record);
209   AddLocToRecord(Range.getEnd(), Record);
210 }
211 
212 unsigned SDiagsWriter::getEmitFile(SourceLocation Loc) {
213   SourceManager &SM = Diags.getSourceManager();
214   assert(Loc.isValid());
215   const std::pair<FileID, unsigned> &LocInfo = SM.getDecomposedLoc(Loc);
216   const FileEntry *FE = SM.getFileEntryForID(LocInfo.first);
217   if (!FE)
218     return 0;
219 
220   unsigned &entry = Files[FE];
221   if (entry)
222     return entry;
223 
224   // Lazily generate the record for the file.
225   entry = Files.size();
226   RecordData Record;
227   Record.push_back(RECORD_FILENAME);
228   Record.push_back(entry);
229   Record.push_back(FE->getSize());
230   Record.push_back(FE->getModificationTime());
231   StringRef Name = FE->getName();
232   Record.push_back(Name.size());
233   Stream.EmitRecordWithBlob(Abbrevs.get(RECORD_FILENAME), Record, Name);
234 
235   return entry;
236 }
237 
238 void SDiagsWriter::EmitCharSourceRange(CharSourceRange R) {
239   Record.clear();
240   Record.push_back(RECORD_SOURCE_RANGE);
241   AddCharSourceRangeToRecord(R, Record);
242   Stream.EmitRecordWithAbbrev(Abbrevs.get(RECORD_SOURCE_RANGE), Record);
243 }
244 
245 /// \brief Emits the preamble of the diagnostics file.
246 void SDiagsWriter::EmitPreamble() {
247   // Emit the file header.
248   Stream.Emit((unsigned)'D', 8);
249   Stream.Emit((unsigned)'I', 8);
250   Stream.Emit((unsigned)'A', 8);
251   Stream.Emit((unsigned)'G', 8);
252 
253   EmitBlockInfoBlock();
254   EmitMetaBlock();
255 }
256 
257 static void AddSourceLocationAbbrev(llvm::BitCodeAbbrev *Abbrev) {
258   using namespace llvm;
259   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // File ID.
260   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Line.
261   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Column.
262   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Offset;
263 }
264 
265 static void AddRangeLocationAbbrev(llvm::BitCodeAbbrev *Abbrev) {
266   AddSourceLocationAbbrev(Abbrev);
267   AddSourceLocationAbbrev(Abbrev);
268 }
269 
270 void SDiagsWriter::EmitBlockInfoBlock() {
271   Stream.EnterBlockInfoBlock(3);
272 
273   using namespace llvm;
274 
275   // ==---------------------------------------------------------------------==//
276   // The subsequent records and Abbrevs are for the "Meta" block.
277   // ==---------------------------------------------------------------------==//
278 
279   EmitBlockID(BLOCK_META, "Meta", Stream, Record);
280   EmitRecordID(RECORD_VERSION, "Version", Stream, Record);
281   BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
282   Abbrev->Add(BitCodeAbbrevOp(RECORD_VERSION));
283   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
284   Abbrevs.set(RECORD_VERSION, Stream.EmitBlockInfoAbbrev(BLOCK_META, Abbrev));
285 
286   // ==---------------------------------------------------------------------==//
287   // The subsequent records and Abbrevs are for the "Diagnostic" block.
288   // ==---------------------------------------------------------------------==//
289 
290   EmitBlockID(BLOCK_DIAG, "Diag", Stream, Record);
291   EmitRecordID(RECORD_DIAG, "DiagInfo", Stream, Record);
292   EmitRecordID(RECORD_SOURCE_RANGE, "SrcRange", Stream, Record);
293   EmitRecordID(RECORD_CATEGORY, "CatName", Stream, Record);
294   EmitRecordID(RECORD_DIAG_FLAG, "DiagFlag", Stream, Record);
295   EmitRecordID(RECORD_FILENAME, "FileName", Stream, Record);
296   EmitRecordID(RECORD_FIXIT, "FixIt", Stream, Record);
297 
298   // Emit abbreviation for RECORD_DIAG.
299   Abbrev = new BitCodeAbbrev();
300   Abbrev->Add(BitCodeAbbrevOp(RECORD_DIAG));
301   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3));  // Diag level.
302   AddSourceLocationAbbrev(Abbrev);
303   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Category.
304   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Mapped Diag ID.
305   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Text size.
306   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Diagnostc text.
307   Abbrevs.set(RECORD_DIAG, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev));
308 
309   // Emit abbrevation for RECORD_CATEGORY.
310   Abbrev = new BitCodeAbbrev();
311   Abbrev->Add(BitCodeAbbrevOp(RECORD_CATEGORY));
312   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Category ID.
313   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));  // Text size.
314   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));      // Category text.
315   Abbrevs.set(RECORD_CATEGORY, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev));
316 
317   // Emit abbrevation for RECORD_SOURCE_RANGE.
318   Abbrev = new BitCodeAbbrev();
319   Abbrev->Add(BitCodeAbbrevOp(RECORD_SOURCE_RANGE));
320   AddRangeLocationAbbrev(Abbrev);
321   Abbrevs.set(RECORD_SOURCE_RANGE,
322               Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev));
323 
324   // Emit the abbreviation for RECORD_DIAG_FLAG.
325   Abbrev = new BitCodeAbbrev();
326   Abbrev->Add(BitCodeAbbrevOp(RECORD_DIAG_FLAG));
327   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Mapped Diag ID.
328   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Text size.
329   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Flag name text.
330   Abbrevs.set(RECORD_DIAG_FLAG, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG,
331                                                            Abbrev));
332 
333   // Emit the abbreviation for RECORD_FILENAME.
334   Abbrev = new BitCodeAbbrev();
335   Abbrev->Add(BitCodeAbbrevOp(RECORD_FILENAME));
336   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Mapped file ID.
337   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Size.
338   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Modifcation time.
339   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Text size.
340   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name text.
341   Abbrevs.set(RECORD_FILENAME, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG,
342                                                           Abbrev));
343 
344   // Emit the abbreviation for RECORD_FIXIT.
345   Abbrev = new BitCodeAbbrev();
346   Abbrev->Add(BitCodeAbbrevOp(RECORD_FIXIT));
347   AddRangeLocationAbbrev(Abbrev);
348   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Text size.
349   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));      // FixIt text.
350   Abbrevs.set(RECORD_FIXIT, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG,
351                                                        Abbrev));
352 
353   Stream.ExitBlock();
354 }
355 
356 void SDiagsWriter::EmitMetaBlock() {
357   Stream.EnterSubblock(BLOCK_META, 3);
358   Record.clear();
359   Record.push_back(RECORD_VERSION);
360   Record.push_back(Version);
361   Stream.EmitRecordWithAbbrev(Abbrevs.get(RECORD_VERSION), Record);
362   Stream.ExitBlock();
363 }
364 
365 unsigned SDiagsWriter::getEmitCategory(unsigned int DiagID) {
366   unsigned category = DiagnosticIDs::getCategoryNumberForDiag(DiagID);
367 
368   if (Categories.count(category))
369     return category;
370 
371   Categories.insert(category);
372 
373   // We use a local version of 'Record' so that we can be generating
374   // another record when we lazily generate one for the category entry.
375   RecordData Record;
376   Record.push_back(RECORD_CATEGORY);
377   Record.push_back(category);
378   StringRef catName = DiagnosticIDs::getCategoryNameFromID(category);
379   Record.push_back(catName.size());
380   Stream.EmitRecordWithBlob(Abbrevs.get(RECORD_CATEGORY), Record, catName);
381 
382   return category;
383 }
384 
385 unsigned SDiagsWriter::getEmitDiagnosticFlag(DiagnosticsEngine::Level DiagLevel,
386                                              const Diagnostic &Info) {
387   if (DiagLevel == DiagnosticsEngine::Note)
388     return 0; // No flag for notes.
389 
390   StringRef FlagName = DiagnosticIDs::getWarningOptionForDiag(Info.getID());
391   if (FlagName.empty())
392     return 0;
393 
394   // Here we assume that FlagName points to static data whose pointer
395   // value is fixed.  This allows us to unique by diagnostic groups.
396   const void *data = FlagName.data();
397   std::pair<unsigned, StringRef> &entry = DiagFlags[data];
398   if (entry.first == 0) {
399     entry.first = DiagFlags.size();
400     entry.second = FlagName;
401 
402     // Lazily emit the string in a separate record.
403     RecordData Record;
404     Record.push_back(RECORD_DIAG_FLAG);
405     Record.push_back(entry.first);
406     Record.push_back(FlagName.size());
407     Stream.EmitRecordWithBlob(Abbrevs.get(RECORD_DIAG_FLAG),
408                               Record, FlagName);
409   }
410 
411   return entry.first;
412 }
413 
414 void SDiagsWriter::HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
415                                     const Diagnostic &Info) {
416 
417   if (DiagLevel != DiagnosticsEngine::Note) {
418     if (inNonNoteDiagnostic) {
419       // We have encountered a non-note diagnostic.  Finish up the previous
420       // diagnostic block before starting a new one.
421       Stream.ExitBlock();
422     }
423     inNonNoteDiagnostic = true;
424   }
425 
426   Stream.EnterSubblock(BLOCK_DIAG, 4);
427 
428   // Emit the RECORD_DIAG record.
429   Record.clear();
430   Record.push_back(RECORD_DIAG);
431   Record.push_back(DiagLevel);
432   AddLocToRecord(Info.getLocation(), Record);
433   // Emit the category string lazily and get the category ID.
434   Record.push_back(getEmitCategory(Info.getID()));
435   // Emit the diagnostic flag string lazily and get the mapped ID.
436   Record.push_back(getEmitDiagnosticFlag(DiagLevel, Info));
437   // Emit the diagnostic text.
438   diagBuf.clear();
439   Info.FormatDiagnostic(diagBuf); // Compute the diagnostic text.
440   Record.push_back(diagBuf.str().size());
441   Stream.EmitRecordWithBlob(Abbrevs.get(RECORD_DIAG), Record, diagBuf.str());
442 
443   // Emit Source Ranges.
444   ArrayRef<CharSourceRange> Ranges = Info.getRanges();
445   for (ArrayRef<CharSourceRange>::iterator it=Ranges.begin(), ei=Ranges.end();
446        it != ei; ++it) {
447     EmitCharSourceRange(*it);
448   }
449 
450   // Emit FixIts.
451   for (unsigned i = 0, n = Info.getNumFixItHints(); i != n; ++i) {
452     const FixItHint &fix = Info.getFixItHint(i);
453     if (fix.isNull())
454       continue;
455     Record.clear();
456     Record.push_back(RECORD_FIXIT);
457     AddCharSourceRangeToRecord(fix.RemoveRange, Record);
458     Record.push_back(fix.CodeToInsert.size());
459     Stream.EmitRecordWithBlob(Abbrevs.get(RECORD_FIXIT), Record,
460                               fix.CodeToInsert);
461   }
462 
463   if (DiagLevel == DiagnosticsEngine::Note) {
464     // Notes currently cannot have child diagnostics.  Complete the
465     // diagnostic now.
466     Stream.ExitBlock();
467   }
468 }
469 
470 void SDiagsWriter::EndSourceFile() {
471   if (inNonNoteDiagnostic) {
472     // Finish off any diagnostics we were in the process of emitting.
473     Stream.ExitBlock();
474     inNonNoteDiagnostic = false;
475   }
476 
477   // Write the generated bitstream to "Out".
478   OS->write((char *)&Buffer.front(), Buffer.size());
479   OS->flush();
480 
481   OS.reset(0);
482 }
483 
484