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