1 //===--- SerializedDiagnosticPrinter.cpp - Serializer for diagnostics -----===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
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/Frontend/FrontendDiagnostic.h"
18 #include "clang/Frontend/SerializedDiagnosticReader.h"
19 #include "clang/Frontend/SerializedDiagnostics.h"
20 #include "clang/Frontend/TextDiagnosticPrinter.h"
21 #include "clang/Lex/Lexer.h"
22 #include "llvm/ADT/DenseSet.h"
23 #include "llvm/ADT/STLExtras.h"
24 #include "llvm/ADT/SmallString.h"
25 #include "llvm/ADT/StringRef.h"
26 #include "llvm/Support/raw_ostream.h"
29 using namespace clang;
30 using namespace clang::serialized_diags;
34 class AbbreviationMap {
35 llvm::DenseMap<unsigned, unsigned> Abbrevs;
39 void set(unsigned recordID, unsigned abbrevID) {
40 assert(Abbrevs.find(recordID) == Abbrevs.end()
41 && "Abbreviation already set.");
42 Abbrevs[recordID] = abbrevID;
45 unsigned get(unsigned recordID) {
46 assert(Abbrevs.find(recordID) != Abbrevs.end() &&
47 "Abbreviation not set.");
48 return Abbrevs[recordID];
52 typedef SmallVector<uint64_t, 64> RecordData;
53 typedef SmallVectorImpl<uint64_t> RecordDataImpl;
57 class SDiagsRenderer : public DiagnosticNoteRenderer {
60 SDiagsRenderer(SDiagsWriter &Writer, const LangOptions &LangOpts,
61 DiagnosticOptions *DiagOpts)
62 : DiagnosticNoteRenderer(LangOpts, DiagOpts), Writer(Writer) {}
64 ~SDiagsRenderer() override {}
67 void emitDiagnosticMessage(SourceLocation Loc,
69 DiagnosticsEngine::Level Level,
71 ArrayRef<CharSourceRange> Ranges,
72 const SourceManager *SM,
73 DiagOrStoredDiag D) override;
75 void emitDiagnosticLoc(SourceLocation Loc, PresumedLoc PLoc,
76 DiagnosticsEngine::Level Level,
77 ArrayRef<CharSourceRange> Ranges,
78 const SourceManager &SM) override {}
80 void emitNote(SourceLocation Loc, StringRef Message,
81 const SourceManager *SM) override;
83 void emitCodeContext(SourceLocation Loc,
84 DiagnosticsEngine::Level Level,
85 SmallVectorImpl<CharSourceRange>& Ranges,
86 ArrayRef<FixItHint> Hints,
87 const SourceManager &SM) override;
89 void beginDiagnostic(DiagOrStoredDiag D,
90 DiagnosticsEngine::Level Level) override;
91 void endDiagnostic(DiagOrStoredDiag D,
92 DiagnosticsEngine::Level Level) override;
95 typedef llvm::DenseMap<unsigned, unsigned> AbbrevLookup;
97 class SDiagsMerger : SerializedDiagnosticReader {
99 AbbrevLookup FileLookup;
100 AbbrevLookup CategoryLookup;
101 AbbrevLookup DiagFlagLookup;
104 SDiagsMerger(SDiagsWriter &Writer)
105 : SerializedDiagnosticReader(), Writer(Writer) {}
107 std::error_code mergeRecordsFromFile(const char *File) {
108 return readDiagnostics(File);
112 std::error_code visitStartOfDiagnostic() override;
113 std::error_code visitEndOfDiagnostic() override;
114 std::error_code visitCategoryRecord(unsigned ID, StringRef Name) override;
115 std::error_code visitDiagFlagRecord(unsigned ID, StringRef Name) override;
116 std::error_code visitDiagnosticRecord(
117 unsigned Severity, const serialized_diags::Location &Location,
118 unsigned Category, unsigned Flag, StringRef Message) override;
119 std::error_code visitFilenameRecord(unsigned ID, unsigned Size,
121 StringRef Name) override;
122 std::error_code visitFixitRecord(const serialized_diags::Location &Start,
123 const serialized_diags::Location &End,
124 StringRef CodeToInsert) override;
126 visitSourceRangeRecord(const serialized_diags::Location &Start,
127 const serialized_diags::Location &End) override;
130 std::error_code adjustSourceLocFilename(RecordData &Record,
131 unsigned int offset);
133 void adjustAbbrevID(RecordData &Record, AbbrevLookup &Lookup,
136 void writeRecordWithAbbrev(unsigned ID, RecordData &Record);
138 void writeRecordWithBlob(unsigned ID, RecordData &Record, StringRef Blob);
141 class SDiagsWriter : public DiagnosticConsumer {
142 friend class SDiagsRenderer;
143 friend class SDiagsMerger;
147 explicit SDiagsWriter(IntrusiveRefCntPtr<SharedState> State)
148 : LangOpts(nullptr), OriginalInstance(false), MergeChildRecords(false),
152 SDiagsWriter(StringRef File, DiagnosticOptions *Diags, bool MergeChildRecords)
153 : LangOpts(nullptr), OriginalInstance(true),
154 MergeChildRecords(MergeChildRecords),
155 State(new SharedState(File, Diags)) {
156 if (MergeChildRecords)
157 RemoveOldDiagnostics();
161 ~SDiagsWriter() override {}
163 void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
164 const Diagnostic &Info) override;
166 void BeginSourceFile(const LangOptions &LO, const Preprocessor *PP) override {
170 void finish() override;
173 /// \brief Build a DiagnosticsEngine to emit diagnostics about the diagnostics
174 DiagnosticsEngine *getMetaDiags();
176 /// \brief Remove old copies of the serialized diagnostics. This is necessary
177 /// so that we can detect when subprocesses write diagnostics that we should
178 /// merge into our own.
179 void RemoveOldDiagnostics();
181 /// \brief Emit the preamble for the serialized diagnostics.
184 /// \brief Emit the BLOCKINFO block.
185 void EmitBlockInfoBlock();
187 /// \brief Emit the META data block.
188 void EmitMetaBlock();
190 /// \brief Start a DIAG block.
191 void EnterDiagBlock();
193 /// \brief End a DIAG block.
194 void ExitDiagBlock();
196 /// \brief Emit a DIAG record.
197 void EmitDiagnosticMessage(SourceLocation Loc,
199 DiagnosticsEngine::Level Level,
201 const SourceManager *SM,
204 /// \brief Emit FIXIT and SOURCE_RANGE records for a diagnostic.
205 void EmitCodeContext(SmallVectorImpl<CharSourceRange> &Ranges,
206 ArrayRef<FixItHint> Hints,
207 const SourceManager &SM);
209 /// \brief Emit a record for a CharSourceRange.
210 void EmitCharSourceRange(CharSourceRange R, const SourceManager &SM);
212 /// \brief Emit the string information for the category.
213 unsigned getEmitCategory(unsigned category = 0);
215 /// \brief Emit the string information for diagnostic flags.
216 unsigned getEmitDiagnosticFlag(DiagnosticsEngine::Level DiagLevel,
217 unsigned DiagID = 0);
219 unsigned getEmitDiagnosticFlag(StringRef DiagName);
221 /// \brief Emit (lazily) the file string and retrieved the file identifier.
222 unsigned getEmitFile(const char *Filename);
224 /// \brief Add SourceLocation information the specified record.
225 void AddLocToRecord(SourceLocation Loc, const SourceManager *SM,
226 PresumedLoc PLoc, RecordDataImpl &Record,
227 unsigned TokSize = 0);
229 /// \brief Add SourceLocation information the specified record.
230 void AddLocToRecord(SourceLocation Loc, RecordDataImpl &Record,
231 const SourceManager *SM,
232 unsigned TokSize = 0) {
233 AddLocToRecord(Loc, SM, SM ? SM->getPresumedLoc(Loc) : PresumedLoc(),
237 /// \brief Add CharSourceRange information the specified record.
238 void AddCharSourceRangeToRecord(CharSourceRange R, RecordDataImpl &Record,
239 const SourceManager &SM);
241 /// \brief Language options, which can differ from one clone of this client
243 const LangOptions *LangOpts;
245 /// \brief Whether this is the original instance (rather than one of its
246 /// clones), responsible for writing the file at the end.
247 bool OriginalInstance;
249 /// \brief Whether this instance should aggregate diagnostics that are
250 /// generated from child processes.
251 bool MergeChildRecords;
253 /// \brief State that is shared among the various clones of this diagnostic
255 struct SharedState : RefCountedBase<SharedState> {
256 SharedState(StringRef File, DiagnosticOptions *Diags)
257 : DiagOpts(Diags), Stream(Buffer), OutputFile(File.str()),
258 EmittedAnyDiagBlocks(false) {}
260 /// \brief Diagnostic options.
261 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts;
263 /// \brief The byte buffer for the serialized content.
264 SmallString<1024> Buffer;
266 /// \brief The BitStreamWriter for the serialized diagnostics.
267 llvm::BitstreamWriter Stream;
269 /// \brief The name of the diagnostics file.
270 std::string OutputFile;
272 /// \brief The set of constructed record abbreviations.
273 AbbreviationMap Abbrevs;
275 /// \brief A utility buffer for constructing record content.
278 /// \brief A text buffer for rendering diagnostic text.
279 SmallString<256> diagBuf;
281 /// \brief The collection of diagnostic categories used.
282 llvm::DenseSet<unsigned> Categories;
284 /// \brief The collection of files used.
285 llvm::DenseMap<const char *, unsigned> Files;
287 typedef llvm::DenseMap<const void *, std::pair<unsigned, StringRef> >
290 /// \brief Map for uniquing strings.
291 DiagFlagsTy DiagFlags;
293 /// \brief Whether we have already started emission of any DIAG blocks. Once
294 /// this becomes \c true, we never close a DIAG block until we know that we're
295 /// starting another one or we're done.
296 bool EmittedAnyDiagBlocks;
298 /// \brief Engine for emitting diagnostics about the diagnostics.
299 std::unique_ptr<DiagnosticsEngine> MetaDiagnostics;
302 /// \brief State shared among the various clones of this diagnostic consumer.
303 IntrusiveRefCntPtr<SharedState> State;
305 } // end anonymous namespace
308 namespace serialized_diags {
309 std::unique_ptr<DiagnosticConsumer>
310 create(StringRef OutputFile, DiagnosticOptions *Diags, bool MergeChildRecords) {
311 return llvm::make_unique<SDiagsWriter>(OutputFile, Diags, MergeChildRecords);
314 } // end namespace serialized_diags
315 } // end namespace clang
317 //===----------------------------------------------------------------------===//
318 // Serialization methods.
319 //===----------------------------------------------------------------------===//
321 /// \brief Emits a block ID in the BLOCKINFO block.
322 static void EmitBlockID(unsigned ID, const char *Name,
323 llvm::BitstreamWriter &Stream,
324 RecordDataImpl &Record) {
326 Record.push_back(ID);
327 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETBID, Record);
329 // Emit the block name if present.
330 if (!Name || Name[0] == 0)
336 Record.push_back(*Name++);
338 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_BLOCKNAME, Record);
341 /// \brief Emits a record ID in the BLOCKINFO block.
342 static void EmitRecordID(unsigned ID, const char *Name,
343 llvm::BitstreamWriter &Stream,
344 RecordDataImpl &Record){
346 Record.push_back(ID);
349 Record.push_back(*Name++);
351 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETRECORDNAME, Record);
354 void SDiagsWriter::AddLocToRecord(SourceLocation Loc,
355 const SourceManager *SM,
357 RecordDataImpl &Record,
359 if (PLoc.isInvalid()) {
360 // Emit a "sentinel" location.
361 Record.push_back((unsigned)0); // File.
362 Record.push_back((unsigned)0); // Line.
363 Record.push_back((unsigned)0); // Column.
364 Record.push_back((unsigned)0); // Offset.
368 Record.push_back(getEmitFile(PLoc.getFilename()));
369 Record.push_back(PLoc.getLine());
370 Record.push_back(PLoc.getColumn()+TokSize);
371 Record.push_back(SM->getFileOffset(Loc));
374 void SDiagsWriter::AddCharSourceRangeToRecord(CharSourceRange Range,
375 RecordDataImpl &Record,
376 const SourceManager &SM) {
377 AddLocToRecord(Range.getBegin(), Record, &SM);
378 unsigned TokSize = 0;
379 if (Range.isTokenRange())
380 TokSize = Lexer::MeasureTokenLength(Range.getEnd(),
383 AddLocToRecord(Range.getEnd(), Record, &SM, TokSize);
386 unsigned SDiagsWriter::getEmitFile(const char *FileName){
390 unsigned &entry = State->Files[FileName];
394 // Lazily generate the record for the file.
395 entry = State->Files.size();
397 Record.push_back(RECORD_FILENAME);
398 Record.push_back(entry);
399 Record.push_back(0); // For legacy.
400 Record.push_back(0); // For legacy.
401 StringRef Name(FileName);
402 Record.push_back(Name.size());
403 State->Stream.EmitRecordWithBlob(State->Abbrevs.get(RECORD_FILENAME), Record,
409 void SDiagsWriter::EmitCharSourceRange(CharSourceRange R,
410 const SourceManager &SM) {
411 State->Record.clear();
412 State->Record.push_back(RECORD_SOURCE_RANGE);
413 AddCharSourceRangeToRecord(R, State->Record, SM);
414 State->Stream.EmitRecordWithAbbrev(State->Abbrevs.get(RECORD_SOURCE_RANGE),
418 /// \brief Emits the preamble of the diagnostics file.
419 void SDiagsWriter::EmitPreamble() {
420 // Emit the file header.
421 State->Stream.Emit((unsigned)'D', 8);
422 State->Stream.Emit((unsigned)'I', 8);
423 State->Stream.Emit((unsigned)'A', 8);
424 State->Stream.Emit((unsigned)'G', 8);
426 EmitBlockInfoBlock();
430 static void AddSourceLocationAbbrev(llvm::BitCodeAbbrev *Abbrev) {
431 using namespace llvm;
432 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // File ID.
433 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Line.
434 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Column.
435 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Offset;
438 static void AddRangeLocationAbbrev(llvm::BitCodeAbbrev *Abbrev) {
439 AddSourceLocationAbbrev(Abbrev);
440 AddSourceLocationAbbrev(Abbrev);
443 void SDiagsWriter::EmitBlockInfoBlock() {
444 State->Stream.EnterBlockInfoBlock(3);
446 using namespace llvm;
447 llvm::BitstreamWriter &Stream = State->Stream;
448 RecordData &Record = State->Record;
449 AbbreviationMap &Abbrevs = State->Abbrevs;
451 // ==---------------------------------------------------------------------==//
452 // The subsequent records and Abbrevs are for the "Meta" block.
453 // ==---------------------------------------------------------------------==//
455 EmitBlockID(BLOCK_META, "Meta", Stream, Record);
456 EmitRecordID(RECORD_VERSION, "Version", Stream, Record);
457 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
458 Abbrev->Add(BitCodeAbbrevOp(RECORD_VERSION));
459 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
460 Abbrevs.set(RECORD_VERSION, Stream.EmitBlockInfoAbbrev(BLOCK_META, Abbrev));
462 // ==---------------------------------------------------------------------==//
463 // The subsequent records and Abbrevs are for the "Diagnostic" block.
464 // ==---------------------------------------------------------------------==//
466 EmitBlockID(BLOCK_DIAG, "Diag", Stream, Record);
467 EmitRecordID(RECORD_DIAG, "DiagInfo", Stream, Record);
468 EmitRecordID(RECORD_SOURCE_RANGE, "SrcRange", Stream, Record);
469 EmitRecordID(RECORD_CATEGORY, "CatName", Stream, Record);
470 EmitRecordID(RECORD_DIAG_FLAG, "DiagFlag", Stream, Record);
471 EmitRecordID(RECORD_FILENAME, "FileName", Stream, Record);
472 EmitRecordID(RECORD_FIXIT, "FixIt", Stream, Record);
474 // Emit abbreviation for RECORD_DIAG.
475 Abbrev = new BitCodeAbbrev();
476 Abbrev->Add(BitCodeAbbrevOp(RECORD_DIAG));
477 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // Diag level.
478 AddSourceLocationAbbrev(Abbrev);
479 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Category.
480 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Mapped Diag ID.
481 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Text size.
482 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Diagnostc text.
483 Abbrevs.set(RECORD_DIAG, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev));
485 // Emit abbrevation for RECORD_CATEGORY.
486 Abbrev = new BitCodeAbbrev();
487 Abbrev->Add(BitCodeAbbrevOp(RECORD_CATEGORY));
488 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Category ID.
489 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8)); // Text size.
490 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Category text.
491 Abbrevs.set(RECORD_CATEGORY, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev));
493 // Emit abbrevation for RECORD_SOURCE_RANGE.
494 Abbrev = new BitCodeAbbrev();
495 Abbrev->Add(BitCodeAbbrevOp(RECORD_SOURCE_RANGE));
496 AddRangeLocationAbbrev(Abbrev);
497 Abbrevs.set(RECORD_SOURCE_RANGE,
498 Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev));
500 // Emit the abbreviation for RECORD_DIAG_FLAG.
501 Abbrev = new BitCodeAbbrev();
502 Abbrev->Add(BitCodeAbbrevOp(RECORD_DIAG_FLAG));
503 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Mapped Diag ID.
504 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Text size.
505 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Flag name text.
506 Abbrevs.set(RECORD_DIAG_FLAG, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG,
509 // Emit the abbreviation for RECORD_FILENAME.
510 Abbrev = new BitCodeAbbrev();
511 Abbrev->Add(BitCodeAbbrevOp(RECORD_FILENAME));
512 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Mapped file ID.
513 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Size.
514 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Modifcation time.
515 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Text size.
516 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name text.
517 Abbrevs.set(RECORD_FILENAME, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG,
520 // Emit the abbreviation for RECORD_FIXIT.
521 Abbrev = new BitCodeAbbrev();
522 Abbrev->Add(BitCodeAbbrevOp(RECORD_FIXIT));
523 AddRangeLocationAbbrev(Abbrev);
524 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Text size.
525 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // FixIt text.
526 Abbrevs.set(RECORD_FIXIT, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG,
532 void SDiagsWriter::EmitMetaBlock() {
533 llvm::BitstreamWriter &Stream = State->Stream;
534 RecordData &Record = State->Record;
535 AbbreviationMap &Abbrevs = State->Abbrevs;
537 Stream.EnterSubblock(BLOCK_META, 3);
539 Record.push_back(RECORD_VERSION);
540 Record.push_back(VersionNumber);
541 Stream.EmitRecordWithAbbrev(Abbrevs.get(RECORD_VERSION), Record);
545 unsigned SDiagsWriter::getEmitCategory(unsigned int category) {
546 if (!State->Categories.insert(category).second)
549 // We use a local version of 'Record' so that we can be generating
550 // another record when we lazily generate one for the category entry.
552 Record.push_back(RECORD_CATEGORY);
553 Record.push_back(category);
554 StringRef catName = DiagnosticIDs::getCategoryNameFromID(category);
555 Record.push_back(catName.size());
556 State->Stream.EmitRecordWithBlob(State->Abbrevs.get(RECORD_CATEGORY), Record,
562 unsigned SDiagsWriter::getEmitDiagnosticFlag(DiagnosticsEngine::Level DiagLevel,
564 if (DiagLevel == DiagnosticsEngine::Note)
565 return 0; // No flag for notes.
567 StringRef FlagName = DiagnosticIDs::getWarningOptionForDiag(DiagID);
568 return getEmitDiagnosticFlag(FlagName);
571 unsigned SDiagsWriter::getEmitDiagnosticFlag(StringRef FlagName) {
572 if (FlagName.empty())
575 // Here we assume that FlagName points to static data whose pointer
576 // value is fixed. This allows us to unique by diagnostic groups.
577 const void *data = FlagName.data();
578 std::pair<unsigned, StringRef> &entry = State->DiagFlags[data];
579 if (entry.first == 0) {
580 entry.first = State->DiagFlags.size();
581 entry.second = FlagName;
583 // Lazily emit the string in a separate record.
585 Record.push_back(RECORD_DIAG_FLAG);
586 Record.push_back(entry.first);
587 Record.push_back(FlagName.size());
588 State->Stream.EmitRecordWithBlob(State->Abbrevs.get(RECORD_DIAG_FLAG),
595 void SDiagsWriter::HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
596 const Diagnostic &Info) {
597 // Enter the block for a non-note diagnostic immediately, rather than waiting
598 // for beginDiagnostic, in case associated notes are emitted before we get
600 if (DiagLevel != DiagnosticsEngine::Note) {
601 if (State->EmittedAnyDiagBlocks)
605 State->EmittedAnyDiagBlocks = true;
608 // Compute the diagnostic text.
609 State->diagBuf.clear();
610 Info.FormatDiagnostic(State->diagBuf);
612 if (Info.getLocation().isInvalid()) {
613 // Special-case diagnostics with no location. We may not have entered a
614 // source file in this case, so we can't use the normal DiagnosticsRenderer
617 // Make sure we bracket all notes as "sub-diagnostics". This matches
618 // the behavior in SDiagsRenderer::emitDiagnostic().
619 if (DiagLevel == DiagnosticsEngine::Note)
622 EmitDiagnosticMessage(SourceLocation(), PresumedLoc(), DiagLevel,
623 State->diagBuf, nullptr, &Info);
625 if (DiagLevel == DiagnosticsEngine::Note)
631 assert(Info.hasSourceManager() && LangOpts &&
632 "Unexpected diagnostic with valid location outside of a source file");
633 SDiagsRenderer Renderer(*this, *LangOpts, &*State->DiagOpts);
634 Renderer.emitDiagnostic(Info.getLocation(), DiagLevel,
637 Info.getFixItHints(),
638 &Info.getSourceManager(),
642 static serialized_diags::Level getStableLevel(DiagnosticsEngine::Level Level) {
644 #define CASE(X) case DiagnosticsEngine::X: return serialized_diags::X;
654 llvm_unreachable("invalid diagnostic level");
657 void SDiagsWriter::EmitDiagnosticMessage(SourceLocation Loc,
659 DiagnosticsEngine::Level Level,
661 const SourceManager *SM,
662 DiagOrStoredDiag D) {
663 llvm::BitstreamWriter &Stream = State->Stream;
664 RecordData &Record = State->Record;
665 AbbreviationMap &Abbrevs = State->Abbrevs;
667 // Emit the RECORD_DIAG record.
669 Record.push_back(RECORD_DIAG);
670 Record.push_back(getStableLevel(Level));
671 AddLocToRecord(Loc, SM, PLoc, Record);
673 if (const Diagnostic *Info = D.dyn_cast<const Diagnostic*>()) {
674 // Emit the category string lazily and get the category ID.
675 unsigned DiagID = DiagnosticIDs::getCategoryNumberForDiag(Info->getID());
676 Record.push_back(getEmitCategory(DiagID));
677 // Emit the diagnostic flag string lazily and get the mapped ID.
678 Record.push_back(getEmitDiagnosticFlag(Level, Info->getID()));
680 Record.push_back(getEmitCategory());
681 Record.push_back(getEmitDiagnosticFlag(Level));
684 Record.push_back(Message.size());
685 Stream.EmitRecordWithBlob(Abbrevs.get(RECORD_DIAG), Record, Message);
689 SDiagsRenderer::emitDiagnosticMessage(SourceLocation Loc,
691 DiagnosticsEngine::Level Level,
693 ArrayRef<clang::CharSourceRange> Ranges,
694 const SourceManager *SM,
695 DiagOrStoredDiag D) {
696 Writer.EmitDiagnosticMessage(Loc, PLoc, Level, Message, SM, D);
699 void SDiagsWriter::EnterDiagBlock() {
700 State->Stream.EnterSubblock(BLOCK_DIAG, 4);
703 void SDiagsWriter::ExitDiagBlock() {
704 State->Stream.ExitBlock();
707 void SDiagsRenderer::beginDiagnostic(DiagOrStoredDiag D,
708 DiagnosticsEngine::Level Level) {
709 if (Level == DiagnosticsEngine::Note)
710 Writer.EnterDiagBlock();
713 void SDiagsRenderer::endDiagnostic(DiagOrStoredDiag D,
714 DiagnosticsEngine::Level Level) {
715 // Only end note diagnostics here, because we can't be sure when we've seen
716 // the last note associated with a non-note diagnostic.
717 if (Level == DiagnosticsEngine::Note)
718 Writer.ExitDiagBlock();
721 void SDiagsWriter::EmitCodeContext(SmallVectorImpl<CharSourceRange> &Ranges,
722 ArrayRef<FixItHint> Hints,
723 const SourceManager &SM) {
724 llvm::BitstreamWriter &Stream = State->Stream;
725 RecordData &Record = State->Record;
726 AbbreviationMap &Abbrevs = State->Abbrevs;
728 // Emit Source Ranges.
729 for (ArrayRef<CharSourceRange>::iterator I = Ranges.begin(), E = Ranges.end();
732 EmitCharSourceRange(*I, SM);
735 for (ArrayRef<FixItHint>::iterator I = Hints.begin(), E = Hints.end();
737 const FixItHint &Fix = *I;
741 Record.push_back(RECORD_FIXIT);
742 AddCharSourceRangeToRecord(Fix.RemoveRange, Record, SM);
743 Record.push_back(Fix.CodeToInsert.size());
744 Stream.EmitRecordWithBlob(Abbrevs.get(RECORD_FIXIT), Record,
749 void SDiagsRenderer::emitCodeContext(SourceLocation Loc,
750 DiagnosticsEngine::Level Level,
751 SmallVectorImpl<CharSourceRange> &Ranges,
752 ArrayRef<FixItHint> Hints,
753 const SourceManager &SM) {
754 Writer.EmitCodeContext(Ranges, Hints, SM);
757 void SDiagsRenderer::emitNote(SourceLocation Loc, StringRef Message,
758 const SourceManager *SM) {
759 Writer.EnterDiagBlock();
760 PresumedLoc PLoc = SM ? SM->getPresumedLoc(Loc) : PresumedLoc();
761 Writer.EmitDiagnosticMessage(Loc, PLoc, DiagnosticsEngine::Note,
762 Message, SM, DiagOrStoredDiag());
763 Writer.ExitDiagBlock();
766 DiagnosticsEngine *SDiagsWriter::getMetaDiags() {
767 // FIXME: It's slightly absurd to create a new diagnostics engine here, but
768 // the other options that are available today are worse:
770 // 1. Teach DiagnosticsConsumers to emit diagnostics to the engine they are a
771 // part of. The DiagnosticsEngine would need to know not to send
772 // diagnostics back to the consumer that failed. This would require us to
773 // rework ChainedDiagnosticsConsumer and teach the engine about multiple
774 // consumers, which is difficult today because most APIs interface with
775 // consumers rather than the engine itself.
777 // 2. Pass a DiagnosticsEngine to SDiagsWriter on creation - this would need
778 // to be distinct from the engine the writer was being added to and would
779 // normally not be used.
780 if (!State->MetaDiagnostics) {
781 IntrusiveRefCntPtr<DiagnosticIDs> IDs(new DiagnosticIDs());
783 new TextDiagnosticPrinter(llvm::errs(), State->DiagOpts.get());
784 State->MetaDiagnostics = llvm::make_unique<DiagnosticsEngine>(
785 IDs, State->DiagOpts.get(), Client);
787 return State->MetaDiagnostics.get();
790 void SDiagsWriter::RemoveOldDiagnostics() {
791 if (!llvm::sys::fs::remove(State->OutputFile))
794 getMetaDiags()->Report(diag::warn_fe_serialized_diag_merge_failure);
795 // Disable merging child records, as whatever is in this file may be
797 MergeChildRecords = false;
800 void SDiagsWriter::finish() {
801 // The original instance is responsible for writing the file.
802 if (!OriginalInstance)
805 // Finish off any diagnostic we were in the process of emitting.
806 if (State->EmittedAnyDiagBlocks)
809 if (MergeChildRecords) {
810 if (!State->EmittedAnyDiagBlocks)
811 // We have no diagnostics of our own, so we can just leave the child
812 // process' output alone
815 if (llvm::sys::fs::exists(State->OutputFile))
816 if (SDiagsMerger(*this).mergeRecordsFromFile(State->OutputFile.c_str()))
817 getMetaDiags()->Report(diag::warn_fe_serialized_diag_merge_failure);
821 auto OS = llvm::make_unique<llvm::raw_fd_ostream>(State->OutputFile.c_str(),
822 EC, llvm::sys::fs::F_None);
824 getMetaDiags()->Report(diag::warn_fe_serialized_diag_failure)
825 << State->OutputFile << EC.message();
829 // Write the generated bitstream to "Out".
830 OS->write((char *)&State->Buffer.front(), State->Buffer.size());
834 std::error_code SDiagsMerger::visitStartOfDiagnostic() {
835 Writer.EnterDiagBlock();
836 return std::error_code();
839 std::error_code SDiagsMerger::visitEndOfDiagnostic() {
840 Writer.ExitDiagBlock();
841 return std::error_code();
845 SDiagsMerger::visitSourceRangeRecord(const serialized_diags::Location &Start,
846 const serialized_diags::Location &End) {
848 Record.push_back(RECORD_SOURCE_RANGE);
849 Record.push_back(FileLookup[Start.FileID]);
850 Record.push_back(Start.Line);
851 Record.push_back(Start.Col);
852 Record.push_back(Start.Offset);
853 Record.push_back(FileLookup[End.FileID]);
854 Record.push_back(End.Line);
855 Record.push_back(End.Col);
856 Record.push_back(End.Offset);
858 Writer.State->Stream.EmitRecordWithAbbrev(
859 Writer.State->Abbrevs.get(RECORD_SOURCE_RANGE), Record);
860 return std::error_code();
863 std::error_code SDiagsMerger::visitDiagnosticRecord(
864 unsigned Severity, const serialized_diags::Location &Location,
865 unsigned Category, unsigned Flag, StringRef Message) {
866 RecordData MergedRecord;
867 MergedRecord.push_back(RECORD_DIAG);
868 MergedRecord.push_back(Severity);
869 MergedRecord.push_back(FileLookup[Location.FileID]);
870 MergedRecord.push_back(Location.Line);
871 MergedRecord.push_back(Location.Col);
872 MergedRecord.push_back(Location.Offset);
873 MergedRecord.push_back(CategoryLookup[Category]);
874 MergedRecord.push_back(Flag ? DiagFlagLookup[Flag] : 0);
875 MergedRecord.push_back(Message.size());
877 Writer.State->Stream.EmitRecordWithBlob(
878 Writer.State->Abbrevs.get(RECORD_DIAG), MergedRecord, Message);
879 return std::error_code();
883 SDiagsMerger::visitFixitRecord(const serialized_diags::Location &Start,
884 const serialized_diags::Location &End,
887 Record.push_back(RECORD_FIXIT);
888 Record.push_back(FileLookup[Start.FileID]);
889 Record.push_back(Start.Line);
890 Record.push_back(Start.Col);
891 Record.push_back(Start.Offset);
892 Record.push_back(FileLookup[End.FileID]);
893 Record.push_back(End.Line);
894 Record.push_back(End.Col);
895 Record.push_back(End.Offset);
896 Record.push_back(Text.size());
898 Writer.State->Stream.EmitRecordWithBlob(
899 Writer.State->Abbrevs.get(RECORD_FIXIT), Record, Text);
900 return std::error_code();
903 std::error_code SDiagsMerger::visitFilenameRecord(unsigned ID, unsigned Size,
906 FileLookup[ID] = Writer.getEmitFile(Name.str().c_str());
907 return std::error_code();
910 std::error_code SDiagsMerger::visitCategoryRecord(unsigned ID, StringRef Name) {
911 CategoryLookup[ID] = Writer.getEmitCategory(ID);
912 return std::error_code();
915 std::error_code SDiagsMerger::visitDiagFlagRecord(unsigned ID, StringRef Name) {
916 DiagFlagLookup[ID] = Writer.getEmitDiagnosticFlag(Name);
917 return std::error_code();