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 "clang/Frontend/SerializedDiagnosticPrinter.h"
11 #include "clang/Basic/Diagnostic.h"
12 #include "clang/Basic/DiagnosticOptions.h"
13 #include "clang/Basic/FileManager.h"
14 #include "clang/Basic/SourceManager.h"
15 #include "clang/Basic/Version.h"
16 #include "clang/Frontend/DiagnosticRenderer.h"
17 #include "clang/Lex/Lexer.h"
18 #include "llvm/ADT/DenseSet.h"
19 #include "llvm/ADT/SmallString.h"
20 #include "llvm/ADT/StringRef.h"
21 #include "llvm/Support/raw_ostream.h"
22 #include <vector>
23 
24 using namespace clang;
25 using namespace clang::serialized_diags;
26 
27 namespace {
28 
29 class AbbreviationMap {
30   llvm::DenseMap<unsigned, unsigned> Abbrevs;
31 public:
32   AbbreviationMap() {}
33 
34   void set(unsigned recordID, unsigned abbrevID) {
35     assert(Abbrevs.find(recordID) == Abbrevs.end()
36            && "Abbreviation already set.");
37     Abbrevs[recordID] = abbrevID;
38   }
39 
40   unsigned get(unsigned recordID) {
41     assert(Abbrevs.find(recordID) != Abbrevs.end() &&
42            "Abbreviation not set.");
43     return Abbrevs[recordID];
44   }
45 };
46 
47 typedef SmallVector<uint64_t, 64> RecordData;
48 typedef SmallVectorImpl<uint64_t> RecordDataImpl;
49 
50 class SDiagsWriter;
51 
52 class SDiagsRenderer : public DiagnosticNoteRenderer {
53   SDiagsWriter &Writer;
54 public:
55   SDiagsRenderer(SDiagsWriter &Writer, const LangOptions &LangOpts,
56                  DiagnosticOptions *DiagOpts)
57     : DiagnosticNoteRenderer(LangOpts, DiagOpts), Writer(Writer) {}
58 
59   virtual ~SDiagsRenderer() {}
60 
61 protected:
62   virtual void emitDiagnosticMessage(SourceLocation Loc,
63                                      PresumedLoc PLoc,
64                                      DiagnosticsEngine::Level Level,
65                                      StringRef Message,
66                                      ArrayRef<CharSourceRange> Ranges,
67                                      const SourceManager *SM,
68                                      DiagOrStoredDiag D);
69 
70   virtual void emitDiagnosticLoc(SourceLocation Loc, PresumedLoc PLoc,
71                                  DiagnosticsEngine::Level Level,
72                                  ArrayRef<CharSourceRange> Ranges,
73                                  const SourceManager &SM) {}
74 
75   virtual void emitNote(SourceLocation Loc, StringRef Message,
76                         const SourceManager *SM);
77 
78   virtual void emitCodeContext(SourceLocation Loc,
79                                DiagnosticsEngine::Level Level,
80                                SmallVectorImpl<CharSourceRange>& Ranges,
81                                ArrayRef<FixItHint> Hints,
82                                const SourceManager &SM);
83 
84   virtual void beginDiagnostic(DiagOrStoredDiag D,
85                                DiagnosticsEngine::Level Level);
86   virtual void endDiagnostic(DiagOrStoredDiag D,
87                              DiagnosticsEngine::Level Level);
88 };
89 
90 class SDiagsWriter : public DiagnosticConsumer {
91   friend class SDiagsRenderer;
92 
93   struct SharedState;
94 
95   explicit SDiagsWriter(IntrusiveRefCntPtr<SharedState> State)
96     : LangOpts(0), OriginalInstance(false), State(State) { }
97 
98 public:
99   SDiagsWriter(raw_ostream *os, DiagnosticOptions *diags)
100     : LangOpts(0), OriginalInstance(true), State(new SharedState(os, diags))
101   {
102     EmitPreamble();
103   }
104 
105   ~SDiagsWriter() {}
106 
107   void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
108                         const Diagnostic &Info);
109 
110   void BeginSourceFile(const LangOptions &LO,
111                        const Preprocessor *PP) {
112     LangOpts = &LO;
113   }
114 
115   virtual void finish();
116 
117   DiagnosticConsumer *clone(DiagnosticsEngine &Diags) const {
118     return new SDiagsWriter(State);
119   }
120 
121 private:
122   /// \brief Emit the preamble for the serialized diagnostics.
123   void EmitPreamble();
124 
125   /// \brief Emit the BLOCKINFO block.
126   void EmitBlockInfoBlock();
127 
128   /// \brief Emit the META data block.
129   void EmitMetaBlock();
130 
131   /// \brief Start a DIAG block.
132   void EnterDiagBlock();
133 
134   /// \brief End a DIAG block.
135   void ExitDiagBlock();
136 
137   /// \brief Emit a DIAG record.
138   void EmitDiagnosticMessage(SourceLocation Loc,
139                              PresumedLoc PLoc,
140                              DiagnosticsEngine::Level Level,
141                              StringRef Message,
142                              const SourceManager *SM,
143                              DiagOrStoredDiag D);
144 
145   /// \brief Emit FIXIT and SOURCE_RANGE records for a diagnostic.
146   void EmitCodeContext(SmallVectorImpl<CharSourceRange> &Ranges,
147                        ArrayRef<FixItHint> Hints,
148                        const SourceManager &SM);
149 
150   /// \brief Emit a record for a CharSourceRange.
151   void EmitCharSourceRange(CharSourceRange R, const SourceManager &SM);
152 
153   /// \brief Emit the string information for the category.
154   unsigned getEmitCategory(unsigned category = 0);
155 
156   /// \brief Emit the string information for diagnostic flags.
157   unsigned getEmitDiagnosticFlag(DiagnosticsEngine::Level DiagLevel,
158                                  unsigned DiagID = 0);
159 
160   /// \brief Emit (lazily) the file string and retrieved the file identifier.
161   unsigned getEmitFile(const char *Filename);
162 
163   /// \brief Add SourceLocation information the specified record.
164   void AddLocToRecord(SourceLocation Loc, const SourceManager *SM,
165                       PresumedLoc PLoc, RecordDataImpl &Record,
166                       unsigned TokSize = 0);
167 
168   /// \brief Add SourceLocation information the specified record.
169   void AddLocToRecord(SourceLocation Loc, RecordDataImpl &Record,
170                       const SourceManager *SM,
171                       unsigned TokSize = 0) {
172     AddLocToRecord(Loc, SM, SM ? SM->getPresumedLoc(Loc) : PresumedLoc(),
173                    Record, TokSize);
174   }
175 
176   /// \brief Add CharSourceRange information the specified record.
177   void AddCharSourceRangeToRecord(CharSourceRange R, RecordDataImpl &Record,
178                                   const SourceManager &SM);
179 
180   /// \brief The version of the diagnostics file.
181   enum { Version = 1 };
182 
183   /// \brief Language options, which can differ from one clone of this client
184   /// to another.
185   const LangOptions *LangOpts;
186 
187   /// \brief Whether this is the original instance (rather than one of its
188   /// clones), responsible for writing the file at the end.
189   bool OriginalInstance;
190 
191   /// \brief State that is shared among the various clones of this diagnostic
192   /// consumer.
193   struct SharedState : RefCountedBase<SharedState> {
194     SharedState(raw_ostream *os, DiagnosticOptions *diags)
195       : DiagOpts(diags), Stream(Buffer), OS(os), EmittedAnyDiagBlocks(false) { }
196 
197     /// \brief Diagnostic options.
198     IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts;
199 
200     /// \brief The byte buffer for the serialized content.
201     SmallString<1024> Buffer;
202 
203     /// \brief The BitStreamWriter for the serialized diagnostics.
204     llvm::BitstreamWriter Stream;
205 
206     /// \brief The name of the diagnostics file.
207     OwningPtr<raw_ostream> OS;
208 
209     /// \brief The set of constructed record abbreviations.
210     AbbreviationMap Abbrevs;
211 
212     /// \brief A utility buffer for constructing record content.
213     RecordData Record;
214 
215     /// \brief A text buffer for rendering diagnostic text.
216     SmallString<256> diagBuf;
217 
218     /// \brief The collection of diagnostic categories used.
219     llvm::DenseSet<unsigned> Categories;
220 
221     /// \brief The collection of files used.
222     llvm::DenseMap<const char *, unsigned> Files;
223 
224     typedef llvm::DenseMap<const void *, std::pair<unsigned, StringRef> >
225     DiagFlagsTy;
226 
227     /// \brief Map for uniquing strings.
228     DiagFlagsTy DiagFlags;
229 
230     /// \brief Whether we have already started emission of any DIAG blocks. Once
231     /// this becomes \c true, we never close a DIAG block until we know that we're
232     /// starting another one or we're done.
233     bool EmittedAnyDiagBlocks;
234   };
235 
236   /// \brief State shared among the various clones of this diagnostic consumer.
237   IntrusiveRefCntPtr<SharedState> State;
238 };
239 } // end anonymous namespace
240 
241 namespace clang {
242 namespace serialized_diags {
243 DiagnosticConsumer *create(raw_ostream *OS, DiagnosticOptions *diags) {
244   return new SDiagsWriter(OS, diags);
245 }
246 } // end namespace serialized_diags
247 } // end namespace clang
248 
249 //===----------------------------------------------------------------------===//
250 // Serialization methods.
251 //===----------------------------------------------------------------------===//
252 
253 /// \brief Emits a block ID in the BLOCKINFO block.
254 static void EmitBlockID(unsigned ID, const char *Name,
255                         llvm::BitstreamWriter &Stream,
256                         RecordDataImpl &Record) {
257   Record.clear();
258   Record.push_back(ID);
259   Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETBID, Record);
260 
261   // Emit the block name if present.
262   if (Name == 0 || Name[0] == 0)
263     return;
264 
265   Record.clear();
266 
267   while (*Name)
268     Record.push_back(*Name++);
269 
270   Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_BLOCKNAME, Record);
271 }
272 
273 /// \brief Emits a record ID in the BLOCKINFO block.
274 static void EmitRecordID(unsigned ID, const char *Name,
275                          llvm::BitstreamWriter &Stream,
276                          RecordDataImpl &Record){
277   Record.clear();
278   Record.push_back(ID);
279 
280   while (*Name)
281     Record.push_back(*Name++);
282 
283   Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETRECORDNAME, Record);
284 }
285 
286 void SDiagsWriter::AddLocToRecord(SourceLocation Loc,
287                                   const SourceManager *SM,
288                                   PresumedLoc PLoc,
289                                   RecordDataImpl &Record,
290                                   unsigned TokSize) {
291   if (PLoc.isInvalid()) {
292     // Emit a "sentinel" location.
293     Record.push_back((unsigned)0); // File.
294     Record.push_back((unsigned)0); // Line.
295     Record.push_back((unsigned)0); // Column.
296     Record.push_back((unsigned)0); // Offset.
297     return;
298   }
299 
300   Record.push_back(getEmitFile(PLoc.getFilename()));
301   Record.push_back(PLoc.getLine());
302   Record.push_back(PLoc.getColumn()+TokSize);
303   Record.push_back(SM->getFileOffset(Loc));
304 }
305 
306 void SDiagsWriter::AddCharSourceRangeToRecord(CharSourceRange Range,
307                                               RecordDataImpl &Record,
308                                               const SourceManager &SM) {
309   AddLocToRecord(Range.getBegin(), Record, &SM);
310   unsigned TokSize = 0;
311   if (Range.isTokenRange())
312     TokSize = Lexer::MeasureTokenLength(Range.getEnd(),
313                                         SM, *LangOpts);
314 
315   AddLocToRecord(Range.getEnd(), Record, &SM, TokSize);
316 }
317 
318 unsigned SDiagsWriter::getEmitFile(const char *FileName){
319   if (!FileName)
320     return 0;
321 
322   unsigned &entry = State->Files[FileName];
323   if (entry)
324     return entry;
325 
326   // Lazily generate the record for the file.
327   entry = State->Files.size();
328   RecordData Record;
329   Record.push_back(RECORD_FILENAME);
330   Record.push_back(entry);
331   Record.push_back(0); // For legacy.
332   Record.push_back(0); // For legacy.
333   StringRef Name(FileName);
334   Record.push_back(Name.size());
335   State->Stream.EmitRecordWithBlob(State->Abbrevs.get(RECORD_FILENAME), Record,
336                                    Name);
337 
338   return entry;
339 }
340 
341 void SDiagsWriter::EmitCharSourceRange(CharSourceRange R,
342                                        const SourceManager &SM) {
343   State->Record.clear();
344   State->Record.push_back(RECORD_SOURCE_RANGE);
345   AddCharSourceRangeToRecord(R, State->Record, SM);
346   State->Stream.EmitRecordWithAbbrev(State->Abbrevs.get(RECORD_SOURCE_RANGE),
347                                      State->Record);
348 }
349 
350 /// \brief Emits the preamble of the diagnostics file.
351 void SDiagsWriter::EmitPreamble() {
352   // Emit the file header.
353   State->Stream.Emit((unsigned)'D', 8);
354   State->Stream.Emit((unsigned)'I', 8);
355   State->Stream.Emit((unsigned)'A', 8);
356   State->Stream.Emit((unsigned)'G', 8);
357 
358   EmitBlockInfoBlock();
359   EmitMetaBlock();
360 }
361 
362 static void AddSourceLocationAbbrev(llvm::BitCodeAbbrev *Abbrev) {
363   using namespace llvm;
364   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // File ID.
365   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Line.
366   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Column.
367   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Offset;
368 }
369 
370 static void AddRangeLocationAbbrev(llvm::BitCodeAbbrev *Abbrev) {
371   AddSourceLocationAbbrev(Abbrev);
372   AddSourceLocationAbbrev(Abbrev);
373 }
374 
375 void SDiagsWriter::EmitBlockInfoBlock() {
376   State->Stream.EnterBlockInfoBlock(3);
377 
378   using namespace llvm;
379   llvm::BitstreamWriter &Stream = State->Stream;
380   RecordData &Record = State->Record;
381   AbbreviationMap &Abbrevs = State->Abbrevs;
382 
383   // ==---------------------------------------------------------------------==//
384   // The subsequent records and Abbrevs are for the "Meta" block.
385   // ==---------------------------------------------------------------------==//
386 
387   EmitBlockID(BLOCK_META, "Meta", Stream, Record);
388   EmitRecordID(RECORD_VERSION, "Version", Stream, Record);
389   BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
390   Abbrev->Add(BitCodeAbbrevOp(RECORD_VERSION));
391   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
392   Abbrevs.set(RECORD_VERSION, Stream.EmitBlockInfoAbbrev(BLOCK_META, Abbrev));
393 
394   // ==---------------------------------------------------------------------==//
395   // The subsequent records and Abbrevs are for the "Diagnostic" block.
396   // ==---------------------------------------------------------------------==//
397 
398   EmitBlockID(BLOCK_DIAG, "Diag", Stream, Record);
399   EmitRecordID(RECORD_DIAG, "DiagInfo", Stream, Record);
400   EmitRecordID(RECORD_SOURCE_RANGE, "SrcRange", Stream, Record);
401   EmitRecordID(RECORD_CATEGORY, "CatName", Stream, Record);
402   EmitRecordID(RECORD_DIAG_FLAG, "DiagFlag", Stream, Record);
403   EmitRecordID(RECORD_FILENAME, "FileName", Stream, Record);
404   EmitRecordID(RECORD_FIXIT, "FixIt", Stream, Record);
405 
406   // Emit abbreviation for RECORD_DIAG.
407   Abbrev = new BitCodeAbbrev();
408   Abbrev->Add(BitCodeAbbrevOp(RECORD_DIAG));
409   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3));  // Diag level.
410   AddSourceLocationAbbrev(Abbrev);
411   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Category.
412   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Mapped Diag ID.
413   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Text size.
414   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Diagnostc text.
415   Abbrevs.set(RECORD_DIAG, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev));
416 
417   // Emit abbrevation for RECORD_CATEGORY.
418   Abbrev = new BitCodeAbbrev();
419   Abbrev->Add(BitCodeAbbrevOp(RECORD_CATEGORY));
420   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Category ID.
421   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));  // Text size.
422   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));      // Category text.
423   Abbrevs.set(RECORD_CATEGORY, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev));
424 
425   // Emit abbrevation for RECORD_SOURCE_RANGE.
426   Abbrev = new BitCodeAbbrev();
427   Abbrev->Add(BitCodeAbbrevOp(RECORD_SOURCE_RANGE));
428   AddRangeLocationAbbrev(Abbrev);
429   Abbrevs.set(RECORD_SOURCE_RANGE,
430               Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev));
431 
432   // Emit the abbreviation for RECORD_DIAG_FLAG.
433   Abbrev = new BitCodeAbbrev();
434   Abbrev->Add(BitCodeAbbrevOp(RECORD_DIAG_FLAG));
435   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Mapped Diag ID.
436   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Text size.
437   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Flag name text.
438   Abbrevs.set(RECORD_DIAG_FLAG, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG,
439                                                            Abbrev));
440 
441   // Emit the abbreviation for RECORD_FILENAME.
442   Abbrev = new BitCodeAbbrev();
443   Abbrev->Add(BitCodeAbbrevOp(RECORD_FILENAME));
444   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Mapped file ID.
445   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Size.
446   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Modifcation time.
447   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Text size.
448   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name text.
449   Abbrevs.set(RECORD_FILENAME, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG,
450                                                           Abbrev));
451 
452   // Emit the abbreviation for RECORD_FIXIT.
453   Abbrev = new BitCodeAbbrev();
454   Abbrev->Add(BitCodeAbbrevOp(RECORD_FIXIT));
455   AddRangeLocationAbbrev(Abbrev);
456   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Text size.
457   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));      // FixIt text.
458   Abbrevs.set(RECORD_FIXIT, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG,
459                                                        Abbrev));
460 
461   Stream.ExitBlock();
462 }
463 
464 void SDiagsWriter::EmitMetaBlock() {
465   llvm::BitstreamWriter &Stream = State->Stream;
466   RecordData &Record = State->Record;
467   AbbreviationMap &Abbrevs = State->Abbrevs;
468 
469   Stream.EnterSubblock(BLOCK_META, 3);
470   Record.clear();
471   Record.push_back(RECORD_VERSION);
472   Record.push_back(Version);
473   Stream.EmitRecordWithAbbrev(Abbrevs.get(RECORD_VERSION), Record);
474   Stream.ExitBlock();
475 }
476 
477 unsigned SDiagsWriter::getEmitCategory(unsigned int category) {
478   if (State->Categories.count(category))
479     return category;
480 
481   State->Categories.insert(category);
482 
483   // We use a local version of 'Record' so that we can be generating
484   // another record when we lazily generate one for the category entry.
485   RecordData Record;
486   Record.push_back(RECORD_CATEGORY);
487   Record.push_back(category);
488   StringRef catName = DiagnosticIDs::getCategoryNameFromID(category);
489   Record.push_back(catName.size());
490   State->Stream.EmitRecordWithBlob(State->Abbrevs.get(RECORD_CATEGORY), Record,
491                                    catName);
492 
493   return category;
494 }
495 
496 unsigned SDiagsWriter::getEmitDiagnosticFlag(DiagnosticsEngine::Level DiagLevel,
497                                              unsigned DiagID) {
498   if (DiagLevel == DiagnosticsEngine::Note)
499     return 0; // No flag for notes.
500 
501   StringRef FlagName = DiagnosticIDs::getWarningOptionForDiag(DiagID);
502   if (FlagName.empty())
503     return 0;
504 
505   // Here we assume that FlagName points to static data whose pointer
506   // value is fixed.  This allows us to unique by diagnostic groups.
507   const void *data = FlagName.data();
508   std::pair<unsigned, StringRef> &entry = State->DiagFlags[data];
509   if (entry.first == 0) {
510     entry.first = State->DiagFlags.size();
511     entry.second = FlagName;
512 
513     // Lazily emit the string in a separate record.
514     RecordData Record;
515     Record.push_back(RECORD_DIAG_FLAG);
516     Record.push_back(entry.first);
517     Record.push_back(FlagName.size());
518     State->Stream.EmitRecordWithBlob(State->Abbrevs.get(RECORD_DIAG_FLAG),
519                                      Record, FlagName);
520   }
521 
522   return entry.first;
523 }
524 
525 void SDiagsWriter::HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
526                                     const Diagnostic &Info) {
527   // Enter the block for a non-note diagnostic immediately, rather than waiting
528   // for beginDiagnostic, in case associated notes are emitted before we get
529   // there.
530   if (DiagLevel != DiagnosticsEngine::Note) {
531     if (State->EmittedAnyDiagBlocks)
532       ExitDiagBlock();
533 
534     EnterDiagBlock();
535     State->EmittedAnyDiagBlocks = true;
536   }
537 
538   // Compute the diagnostic text.
539   State->diagBuf.clear();
540   Info.FormatDiagnostic(State->diagBuf);
541 
542   if (Info.getLocation().isInvalid()) {
543     // Special-case diagnostics with no location. We may not have entered a
544     // source file in this case, so we can't use the normal DiagnosticsRenderer
545     // machinery.
546 
547     // Make sure we bracket all notes as "sub-diagnostics".  This matches
548     // the behavior in SDiagsRenderer::emitDiagnostic().
549     if (DiagLevel == DiagnosticsEngine::Note)
550       EnterDiagBlock();
551 
552     EmitDiagnosticMessage(SourceLocation(), PresumedLoc(), DiagLevel,
553                           State->diagBuf, 0, &Info);
554 
555     if (DiagLevel == DiagnosticsEngine::Note)
556       ExitDiagBlock();
557 
558     return;
559   }
560 
561   assert(Info.hasSourceManager() && LangOpts &&
562          "Unexpected diagnostic with valid location outside of a source file");
563   SDiagsRenderer Renderer(*this, *LangOpts, &*State->DiagOpts);
564   Renderer.emitDiagnostic(Info.getLocation(), DiagLevel,
565                           State->diagBuf.str(),
566                           Info.getRanges(),
567                           llvm::makeArrayRef(Info.getFixItHints(),
568                                              Info.getNumFixItHints()),
569                           &Info.getSourceManager(),
570                           &Info);
571 }
572 
573 void SDiagsWriter::EmitDiagnosticMessage(SourceLocation Loc,
574                                          PresumedLoc PLoc,
575                                          DiagnosticsEngine::Level Level,
576                                          StringRef Message,
577                                          const SourceManager *SM,
578                                          DiagOrStoredDiag D) {
579   llvm::BitstreamWriter &Stream = State->Stream;
580   RecordData &Record = State->Record;
581   AbbreviationMap &Abbrevs = State->Abbrevs;
582 
583   // Emit the RECORD_DIAG record.
584   Record.clear();
585   Record.push_back(RECORD_DIAG);
586   Record.push_back(Level);
587   AddLocToRecord(Loc, SM, PLoc, Record);
588 
589   if (const Diagnostic *Info = D.dyn_cast<const Diagnostic*>()) {
590     // Emit the category string lazily and get the category ID.
591     unsigned DiagID = DiagnosticIDs::getCategoryNumberForDiag(Info->getID());
592     Record.push_back(getEmitCategory(DiagID));
593     // Emit the diagnostic flag string lazily and get the mapped ID.
594     Record.push_back(getEmitDiagnosticFlag(Level, Info->getID()));
595   } else {
596     Record.push_back(getEmitCategory());
597     Record.push_back(getEmitDiagnosticFlag(Level));
598   }
599 
600   Record.push_back(Message.size());
601   Stream.EmitRecordWithBlob(Abbrevs.get(RECORD_DIAG), Record, Message);
602 }
603 
604 void
605 SDiagsRenderer::emitDiagnosticMessage(SourceLocation Loc,
606                                       PresumedLoc PLoc,
607                                       DiagnosticsEngine::Level Level,
608                                       StringRef Message,
609                                       ArrayRef<clang::CharSourceRange> Ranges,
610                                       const SourceManager *SM,
611                                       DiagOrStoredDiag D) {
612   Writer.EmitDiagnosticMessage(Loc, PLoc, Level, Message, SM, D);
613 }
614 
615 void SDiagsWriter::EnterDiagBlock() {
616   State->Stream.EnterSubblock(BLOCK_DIAG, 4);
617 }
618 
619 void SDiagsWriter::ExitDiagBlock() {
620   State->Stream.ExitBlock();
621 }
622 
623 void SDiagsRenderer::beginDiagnostic(DiagOrStoredDiag D,
624                                      DiagnosticsEngine::Level Level) {
625   if (Level == DiagnosticsEngine::Note)
626     Writer.EnterDiagBlock();
627 }
628 
629 void SDiagsRenderer::endDiagnostic(DiagOrStoredDiag D,
630                                    DiagnosticsEngine::Level Level) {
631   // Only end note diagnostics here, because we can't be sure when we've seen
632   // the last note associated with a non-note diagnostic.
633   if (Level == DiagnosticsEngine::Note)
634     Writer.ExitDiagBlock();
635 }
636 
637 void SDiagsWriter::EmitCodeContext(SmallVectorImpl<CharSourceRange> &Ranges,
638                                    ArrayRef<FixItHint> Hints,
639                                    const SourceManager &SM) {
640   llvm::BitstreamWriter &Stream = State->Stream;
641   RecordData &Record = State->Record;
642   AbbreviationMap &Abbrevs = State->Abbrevs;
643 
644   // Emit Source Ranges.
645   for (ArrayRef<CharSourceRange>::iterator I = Ranges.begin(), E = Ranges.end();
646        I != E; ++I)
647     if (I->isValid())
648       EmitCharSourceRange(*I, SM);
649 
650   // Emit FixIts.
651   for (ArrayRef<FixItHint>::iterator I = Hints.begin(), E = Hints.end();
652        I != E; ++I) {
653     const FixItHint &Fix = *I;
654     if (Fix.isNull())
655       continue;
656     Record.clear();
657     Record.push_back(RECORD_FIXIT);
658     AddCharSourceRangeToRecord(Fix.RemoveRange, Record, SM);
659     Record.push_back(Fix.CodeToInsert.size());
660     Stream.EmitRecordWithBlob(Abbrevs.get(RECORD_FIXIT), Record,
661                               Fix.CodeToInsert);
662   }
663 }
664 
665 void SDiagsRenderer::emitCodeContext(SourceLocation Loc,
666                                      DiagnosticsEngine::Level Level,
667                                      SmallVectorImpl<CharSourceRange> &Ranges,
668                                      ArrayRef<FixItHint> Hints,
669                                      const SourceManager &SM) {
670   Writer.EmitCodeContext(Ranges, Hints, SM);
671 }
672 
673 void SDiagsRenderer::emitNote(SourceLocation Loc, StringRef Message,
674                               const SourceManager *SM) {
675   Writer.EnterDiagBlock();
676   PresumedLoc PLoc = SM ? SM->getPresumedLoc(Loc) : PresumedLoc();
677   Writer.EmitDiagnosticMessage(Loc, PLoc, DiagnosticsEngine::Note,
678                                Message, SM, DiagOrStoredDiag());
679   Writer.ExitDiagBlock();
680 }
681 
682 void SDiagsWriter::finish() {
683   // The original instance is responsible for writing the file.
684   if (!OriginalInstance)
685     return;
686 
687   // Finish off any diagnostic we were in the process of emitting.
688   if (State->EmittedAnyDiagBlocks)
689     ExitDiagBlock();
690 
691   // Write the generated bitstream to "Out".
692   State->OS->write((char *)&State->Buffer.front(), State->Buffer.size());
693   State->OS->flush();
694 
695   State->OS.reset(0);
696 }
697