106f32e7eSjoerg //===--- SerializedDiagnosticPrinter.cpp - Serializer for diagnostics -----===//
206f32e7eSjoerg //
306f32e7eSjoerg // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
406f32e7eSjoerg // See https://llvm.org/LICENSE.txt for license information.
506f32e7eSjoerg // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
606f32e7eSjoerg //
706f32e7eSjoerg //===----------------------------------------------------------------------===//
806f32e7eSjoerg
906f32e7eSjoerg #include "clang/Frontend/SerializedDiagnosticPrinter.h"
1006f32e7eSjoerg #include "clang/Basic/Diagnostic.h"
1106f32e7eSjoerg #include "clang/Basic/DiagnosticOptions.h"
1206f32e7eSjoerg #include "clang/Basic/SourceManager.h"
1306f32e7eSjoerg #include "clang/Frontend/DiagnosticRenderer.h"
1406f32e7eSjoerg #include "clang/Frontend/FrontendDiagnostic.h"
1506f32e7eSjoerg #include "clang/Frontend/SerializedDiagnosticReader.h"
1606f32e7eSjoerg #include "clang/Frontend/SerializedDiagnostics.h"
1706f32e7eSjoerg #include "clang/Frontend/TextDiagnosticPrinter.h"
1806f32e7eSjoerg #include "clang/Lex/Lexer.h"
1906f32e7eSjoerg #include "llvm/ADT/DenseSet.h"
2006f32e7eSjoerg #include "llvm/ADT/STLExtras.h"
2106f32e7eSjoerg #include "llvm/ADT/SmallString.h"
2206f32e7eSjoerg #include "llvm/ADT/StringRef.h"
2306f32e7eSjoerg #include "llvm/Bitstream/BitCodes.h"
2406f32e7eSjoerg #include "llvm/Bitstream/BitstreamReader.h"
25*13fbcb42Sjoerg #include "llvm/Support/FileSystem.h"
2606f32e7eSjoerg #include "llvm/Support/raw_ostream.h"
2706f32e7eSjoerg #include <utility>
2806f32e7eSjoerg
2906f32e7eSjoerg using namespace clang;
3006f32e7eSjoerg using namespace clang::serialized_diags;
3106f32e7eSjoerg
3206f32e7eSjoerg namespace {
3306f32e7eSjoerg
3406f32e7eSjoerg class AbbreviationMap {
3506f32e7eSjoerg llvm::DenseMap<unsigned, unsigned> Abbrevs;
3606f32e7eSjoerg public:
AbbreviationMap()3706f32e7eSjoerg AbbreviationMap() {}
3806f32e7eSjoerg
set(unsigned recordID,unsigned abbrevID)3906f32e7eSjoerg void set(unsigned recordID, unsigned abbrevID) {
4006f32e7eSjoerg assert(Abbrevs.find(recordID) == Abbrevs.end()
4106f32e7eSjoerg && "Abbreviation already set.");
4206f32e7eSjoerg Abbrevs[recordID] = abbrevID;
4306f32e7eSjoerg }
4406f32e7eSjoerg
get(unsigned recordID)4506f32e7eSjoerg unsigned get(unsigned recordID) {
4606f32e7eSjoerg assert(Abbrevs.find(recordID) != Abbrevs.end() &&
4706f32e7eSjoerg "Abbreviation not set.");
4806f32e7eSjoerg return Abbrevs[recordID];
4906f32e7eSjoerg }
5006f32e7eSjoerg };
5106f32e7eSjoerg
5206f32e7eSjoerg typedef SmallVector<uint64_t, 64> RecordData;
5306f32e7eSjoerg typedef SmallVectorImpl<uint64_t> RecordDataImpl;
5406f32e7eSjoerg typedef ArrayRef<uint64_t> RecordDataRef;
5506f32e7eSjoerg
5606f32e7eSjoerg class SDiagsWriter;
5706f32e7eSjoerg
5806f32e7eSjoerg class SDiagsRenderer : public DiagnosticNoteRenderer {
5906f32e7eSjoerg SDiagsWriter &Writer;
6006f32e7eSjoerg public:
SDiagsRenderer(SDiagsWriter & Writer,const LangOptions & LangOpts,DiagnosticOptions * DiagOpts)6106f32e7eSjoerg SDiagsRenderer(SDiagsWriter &Writer, const LangOptions &LangOpts,
6206f32e7eSjoerg DiagnosticOptions *DiagOpts)
6306f32e7eSjoerg : DiagnosticNoteRenderer(LangOpts, DiagOpts), Writer(Writer) {}
6406f32e7eSjoerg
~SDiagsRenderer()6506f32e7eSjoerg ~SDiagsRenderer() override {}
6606f32e7eSjoerg
6706f32e7eSjoerg protected:
6806f32e7eSjoerg void emitDiagnosticMessage(FullSourceLoc Loc, PresumedLoc PLoc,
6906f32e7eSjoerg DiagnosticsEngine::Level Level, StringRef Message,
7006f32e7eSjoerg ArrayRef<CharSourceRange> Ranges,
7106f32e7eSjoerg DiagOrStoredDiag D) override;
7206f32e7eSjoerg
emitDiagnosticLoc(FullSourceLoc Loc,PresumedLoc PLoc,DiagnosticsEngine::Level Level,ArrayRef<CharSourceRange> Ranges)7306f32e7eSjoerg void emitDiagnosticLoc(FullSourceLoc Loc, PresumedLoc PLoc,
7406f32e7eSjoerg DiagnosticsEngine::Level Level,
7506f32e7eSjoerg ArrayRef<CharSourceRange> Ranges) override {}
7606f32e7eSjoerg
7706f32e7eSjoerg void emitNote(FullSourceLoc Loc, StringRef Message) override;
7806f32e7eSjoerg
7906f32e7eSjoerg void emitCodeContext(FullSourceLoc Loc, DiagnosticsEngine::Level Level,
8006f32e7eSjoerg SmallVectorImpl<CharSourceRange> &Ranges,
8106f32e7eSjoerg ArrayRef<FixItHint> Hints) override;
8206f32e7eSjoerg
8306f32e7eSjoerg void beginDiagnostic(DiagOrStoredDiag D,
8406f32e7eSjoerg DiagnosticsEngine::Level Level) override;
8506f32e7eSjoerg void endDiagnostic(DiagOrStoredDiag D,
8606f32e7eSjoerg DiagnosticsEngine::Level Level) override;
8706f32e7eSjoerg };
8806f32e7eSjoerg
8906f32e7eSjoerg typedef llvm::DenseMap<unsigned, unsigned> AbbrevLookup;
9006f32e7eSjoerg
9106f32e7eSjoerg class SDiagsMerger : SerializedDiagnosticReader {
9206f32e7eSjoerg SDiagsWriter &Writer;
9306f32e7eSjoerg AbbrevLookup FileLookup;
9406f32e7eSjoerg AbbrevLookup CategoryLookup;
9506f32e7eSjoerg AbbrevLookup DiagFlagLookup;
9606f32e7eSjoerg
9706f32e7eSjoerg public:
SDiagsMerger(SDiagsWriter & Writer)9806f32e7eSjoerg SDiagsMerger(SDiagsWriter &Writer)
9906f32e7eSjoerg : SerializedDiagnosticReader(), Writer(Writer) {}
10006f32e7eSjoerg
mergeRecordsFromFile(const char * File)10106f32e7eSjoerg std::error_code mergeRecordsFromFile(const char *File) {
10206f32e7eSjoerg return readDiagnostics(File);
10306f32e7eSjoerg }
10406f32e7eSjoerg
10506f32e7eSjoerg protected:
10606f32e7eSjoerg std::error_code visitStartOfDiagnostic() override;
10706f32e7eSjoerg std::error_code visitEndOfDiagnostic() override;
10806f32e7eSjoerg std::error_code visitCategoryRecord(unsigned ID, StringRef Name) override;
10906f32e7eSjoerg std::error_code visitDiagFlagRecord(unsigned ID, StringRef Name) override;
11006f32e7eSjoerg std::error_code visitDiagnosticRecord(
11106f32e7eSjoerg unsigned Severity, const serialized_diags::Location &Location,
11206f32e7eSjoerg unsigned Category, unsigned Flag, StringRef Message) override;
11306f32e7eSjoerg std::error_code visitFilenameRecord(unsigned ID, unsigned Size,
11406f32e7eSjoerg unsigned Timestamp,
11506f32e7eSjoerg StringRef Name) override;
11606f32e7eSjoerg std::error_code visitFixitRecord(const serialized_diags::Location &Start,
11706f32e7eSjoerg const serialized_diags::Location &End,
11806f32e7eSjoerg StringRef CodeToInsert) override;
11906f32e7eSjoerg std::error_code
12006f32e7eSjoerg visitSourceRangeRecord(const serialized_diags::Location &Start,
12106f32e7eSjoerg const serialized_diags::Location &End) override;
12206f32e7eSjoerg
12306f32e7eSjoerg private:
12406f32e7eSjoerg std::error_code adjustSourceLocFilename(RecordData &Record,
12506f32e7eSjoerg unsigned int offset);
12606f32e7eSjoerg
12706f32e7eSjoerg void adjustAbbrevID(RecordData &Record, AbbrevLookup &Lookup,
12806f32e7eSjoerg unsigned NewAbbrev);
12906f32e7eSjoerg
13006f32e7eSjoerg void writeRecordWithAbbrev(unsigned ID, RecordData &Record);
13106f32e7eSjoerg
13206f32e7eSjoerg void writeRecordWithBlob(unsigned ID, RecordData &Record, StringRef Blob);
13306f32e7eSjoerg };
13406f32e7eSjoerg
13506f32e7eSjoerg class SDiagsWriter : public DiagnosticConsumer {
13606f32e7eSjoerg friend class SDiagsRenderer;
13706f32e7eSjoerg friend class SDiagsMerger;
13806f32e7eSjoerg
13906f32e7eSjoerg struct SharedState;
14006f32e7eSjoerg
SDiagsWriter(std::shared_ptr<SharedState> State)14106f32e7eSjoerg explicit SDiagsWriter(std::shared_ptr<SharedState> State)
14206f32e7eSjoerg : LangOpts(nullptr), OriginalInstance(false), MergeChildRecords(false),
14306f32e7eSjoerg State(std::move(State)) {}
14406f32e7eSjoerg
14506f32e7eSjoerg public:
SDiagsWriter(StringRef File,DiagnosticOptions * Diags,bool MergeChildRecords)14606f32e7eSjoerg SDiagsWriter(StringRef File, DiagnosticOptions *Diags, bool MergeChildRecords)
14706f32e7eSjoerg : LangOpts(nullptr), OriginalInstance(true),
14806f32e7eSjoerg MergeChildRecords(MergeChildRecords),
14906f32e7eSjoerg State(std::make_shared<SharedState>(File, Diags)) {
15006f32e7eSjoerg if (MergeChildRecords)
15106f32e7eSjoerg RemoveOldDiagnostics();
15206f32e7eSjoerg EmitPreamble();
15306f32e7eSjoerg }
15406f32e7eSjoerg
~SDiagsWriter()15506f32e7eSjoerg ~SDiagsWriter() override {}
15606f32e7eSjoerg
15706f32e7eSjoerg void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
15806f32e7eSjoerg const Diagnostic &Info) override;
15906f32e7eSjoerg
BeginSourceFile(const LangOptions & LO,const Preprocessor * PP)16006f32e7eSjoerg void BeginSourceFile(const LangOptions &LO, const Preprocessor *PP) override {
16106f32e7eSjoerg LangOpts = &LO;
16206f32e7eSjoerg }
16306f32e7eSjoerg
16406f32e7eSjoerg void finish() override;
16506f32e7eSjoerg
16606f32e7eSjoerg private:
16706f32e7eSjoerg /// Build a DiagnosticsEngine to emit diagnostics about the diagnostics
16806f32e7eSjoerg DiagnosticsEngine *getMetaDiags();
16906f32e7eSjoerg
17006f32e7eSjoerg /// Remove old copies of the serialized diagnostics. This is necessary
17106f32e7eSjoerg /// so that we can detect when subprocesses write diagnostics that we should
17206f32e7eSjoerg /// merge into our own.
17306f32e7eSjoerg void RemoveOldDiagnostics();
17406f32e7eSjoerg
17506f32e7eSjoerg /// Emit the preamble for the serialized diagnostics.
17606f32e7eSjoerg void EmitPreamble();
17706f32e7eSjoerg
17806f32e7eSjoerg /// Emit the BLOCKINFO block.
17906f32e7eSjoerg void EmitBlockInfoBlock();
18006f32e7eSjoerg
18106f32e7eSjoerg /// Emit the META data block.
18206f32e7eSjoerg void EmitMetaBlock();
18306f32e7eSjoerg
18406f32e7eSjoerg /// Start a DIAG block.
18506f32e7eSjoerg void EnterDiagBlock();
18606f32e7eSjoerg
18706f32e7eSjoerg /// End a DIAG block.
18806f32e7eSjoerg void ExitDiagBlock();
18906f32e7eSjoerg
19006f32e7eSjoerg /// Emit a DIAG record.
19106f32e7eSjoerg void EmitDiagnosticMessage(FullSourceLoc Loc, PresumedLoc PLoc,
19206f32e7eSjoerg DiagnosticsEngine::Level Level, StringRef Message,
19306f32e7eSjoerg DiagOrStoredDiag D);
19406f32e7eSjoerg
19506f32e7eSjoerg /// Emit FIXIT and SOURCE_RANGE records for a diagnostic.
19606f32e7eSjoerg void EmitCodeContext(SmallVectorImpl<CharSourceRange> &Ranges,
19706f32e7eSjoerg ArrayRef<FixItHint> Hints,
19806f32e7eSjoerg const SourceManager &SM);
19906f32e7eSjoerg
20006f32e7eSjoerg /// Emit a record for a CharSourceRange.
20106f32e7eSjoerg void EmitCharSourceRange(CharSourceRange R, const SourceManager &SM);
20206f32e7eSjoerg
20306f32e7eSjoerg /// Emit the string information for the category.
20406f32e7eSjoerg unsigned getEmitCategory(unsigned category = 0);
20506f32e7eSjoerg
20606f32e7eSjoerg /// Emit the string information for diagnostic flags.
20706f32e7eSjoerg unsigned getEmitDiagnosticFlag(DiagnosticsEngine::Level DiagLevel,
20806f32e7eSjoerg unsigned DiagID = 0);
20906f32e7eSjoerg
21006f32e7eSjoerg unsigned getEmitDiagnosticFlag(StringRef DiagName);
21106f32e7eSjoerg
21206f32e7eSjoerg /// Emit (lazily) the file string and retrieved the file identifier.
21306f32e7eSjoerg unsigned getEmitFile(const char *Filename);
21406f32e7eSjoerg
21506f32e7eSjoerg /// Add SourceLocation information the specified record.
21606f32e7eSjoerg void AddLocToRecord(FullSourceLoc Loc, PresumedLoc PLoc,
21706f32e7eSjoerg RecordDataImpl &Record, unsigned TokSize = 0);
21806f32e7eSjoerg
21906f32e7eSjoerg /// Add SourceLocation information the specified record.
AddLocToRecord(FullSourceLoc Loc,RecordDataImpl & Record,unsigned TokSize=0)22006f32e7eSjoerg void AddLocToRecord(FullSourceLoc Loc, RecordDataImpl &Record,
22106f32e7eSjoerg unsigned TokSize = 0) {
22206f32e7eSjoerg AddLocToRecord(Loc, Loc.hasManager() ? Loc.getPresumedLoc() : PresumedLoc(),
22306f32e7eSjoerg Record, TokSize);
22406f32e7eSjoerg }
22506f32e7eSjoerg
22606f32e7eSjoerg /// Add CharSourceRange information the specified record.
22706f32e7eSjoerg void AddCharSourceRangeToRecord(CharSourceRange R, RecordDataImpl &Record,
22806f32e7eSjoerg const SourceManager &SM);
22906f32e7eSjoerg
23006f32e7eSjoerg /// Language options, which can differ from one clone of this client
23106f32e7eSjoerg /// to another.
23206f32e7eSjoerg const LangOptions *LangOpts;
23306f32e7eSjoerg
23406f32e7eSjoerg /// Whether this is the original instance (rather than one of its
23506f32e7eSjoerg /// clones), responsible for writing the file at the end.
23606f32e7eSjoerg bool OriginalInstance;
23706f32e7eSjoerg
23806f32e7eSjoerg /// Whether this instance should aggregate diagnostics that are
23906f32e7eSjoerg /// generated from child processes.
24006f32e7eSjoerg bool MergeChildRecords;
24106f32e7eSjoerg
242*13fbcb42Sjoerg /// Whether we've started finishing and tearing down this instance.
243*13fbcb42Sjoerg bool IsFinishing = false;
244*13fbcb42Sjoerg
24506f32e7eSjoerg /// State that is shared among the various clones of this diagnostic
24606f32e7eSjoerg /// consumer.
24706f32e7eSjoerg struct SharedState {
SharedState__anon6ed50a5f0111::SDiagsWriter::SharedState24806f32e7eSjoerg SharedState(StringRef File, DiagnosticOptions *Diags)
24906f32e7eSjoerg : DiagOpts(Diags), Stream(Buffer), OutputFile(File.str()),
25006f32e7eSjoerg EmittedAnyDiagBlocks(false) {}
25106f32e7eSjoerg
25206f32e7eSjoerg /// Diagnostic options.
25306f32e7eSjoerg IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts;
25406f32e7eSjoerg
25506f32e7eSjoerg /// The byte buffer for the serialized content.
25606f32e7eSjoerg SmallString<1024> Buffer;
25706f32e7eSjoerg
25806f32e7eSjoerg /// The BitStreamWriter for the serialized diagnostics.
25906f32e7eSjoerg llvm::BitstreamWriter Stream;
26006f32e7eSjoerg
26106f32e7eSjoerg /// The name of the diagnostics file.
26206f32e7eSjoerg std::string OutputFile;
26306f32e7eSjoerg
26406f32e7eSjoerg /// The set of constructed record abbreviations.
26506f32e7eSjoerg AbbreviationMap Abbrevs;
26606f32e7eSjoerg
26706f32e7eSjoerg /// A utility buffer for constructing record content.
26806f32e7eSjoerg RecordData Record;
26906f32e7eSjoerg
27006f32e7eSjoerg /// A text buffer for rendering diagnostic text.
27106f32e7eSjoerg SmallString<256> diagBuf;
27206f32e7eSjoerg
27306f32e7eSjoerg /// The collection of diagnostic categories used.
27406f32e7eSjoerg llvm::DenseSet<unsigned> Categories;
27506f32e7eSjoerg
27606f32e7eSjoerg /// The collection of files used.
27706f32e7eSjoerg llvm::DenseMap<const char *, unsigned> Files;
27806f32e7eSjoerg
27906f32e7eSjoerg typedef llvm::DenseMap<const void *, std::pair<unsigned, StringRef> >
28006f32e7eSjoerg DiagFlagsTy;
28106f32e7eSjoerg
28206f32e7eSjoerg /// Map for uniquing strings.
28306f32e7eSjoerg DiagFlagsTy DiagFlags;
28406f32e7eSjoerg
28506f32e7eSjoerg /// Whether we have already started emission of any DIAG blocks. Once
28606f32e7eSjoerg /// this becomes \c true, we never close a DIAG block until we know that we're
28706f32e7eSjoerg /// starting another one or we're done.
28806f32e7eSjoerg bool EmittedAnyDiagBlocks;
28906f32e7eSjoerg
29006f32e7eSjoerg /// Engine for emitting diagnostics about the diagnostics.
29106f32e7eSjoerg std::unique_ptr<DiagnosticsEngine> MetaDiagnostics;
29206f32e7eSjoerg };
29306f32e7eSjoerg
29406f32e7eSjoerg /// State shared among the various clones of this diagnostic consumer.
29506f32e7eSjoerg std::shared_ptr<SharedState> State;
29606f32e7eSjoerg };
29706f32e7eSjoerg } // end anonymous namespace
29806f32e7eSjoerg
29906f32e7eSjoerg namespace clang {
30006f32e7eSjoerg namespace serialized_diags {
30106f32e7eSjoerg std::unique_ptr<DiagnosticConsumer>
create(StringRef OutputFile,DiagnosticOptions * Diags,bool MergeChildRecords)30206f32e7eSjoerg create(StringRef OutputFile, DiagnosticOptions *Diags, bool MergeChildRecords) {
30306f32e7eSjoerg return std::make_unique<SDiagsWriter>(OutputFile, Diags, MergeChildRecords);
30406f32e7eSjoerg }
30506f32e7eSjoerg
30606f32e7eSjoerg } // end namespace serialized_diags
30706f32e7eSjoerg } // end namespace clang
30806f32e7eSjoerg
30906f32e7eSjoerg //===----------------------------------------------------------------------===//
31006f32e7eSjoerg // Serialization methods.
31106f32e7eSjoerg //===----------------------------------------------------------------------===//
31206f32e7eSjoerg
31306f32e7eSjoerg /// Emits a block ID in the BLOCKINFO block.
EmitBlockID(unsigned ID,const char * Name,llvm::BitstreamWriter & Stream,RecordDataImpl & Record)31406f32e7eSjoerg static void EmitBlockID(unsigned ID, const char *Name,
31506f32e7eSjoerg llvm::BitstreamWriter &Stream,
31606f32e7eSjoerg RecordDataImpl &Record) {
31706f32e7eSjoerg Record.clear();
31806f32e7eSjoerg Record.push_back(ID);
31906f32e7eSjoerg Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETBID, Record);
32006f32e7eSjoerg
32106f32e7eSjoerg // Emit the block name if present.
32206f32e7eSjoerg if (!Name || Name[0] == 0)
32306f32e7eSjoerg return;
32406f32e7eSjoerg
32506f32e7eSjoerg Record.clear();
32606f32e7eSjoerg
32706f32e7eSjoerg while (*Name)
32806f32e7eSjoerg Record.push_back(*Name++);
32906f32e7eSjoerg
33006f32e7eSjoerg Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_BLOCKNAME, Record);
33106f32e7eSjoerg }
33206f32e7eSjoerg
33306f32e7eSjoerg /// Emits a record ID in the BLOCKINFO block.
EmitRecordID(unsigned ID,const char * Name,llvm::BitstreamWriter & Stream,RecordDataImpl & Record)33406f32e7eSjoerg static void EmitRecordID(unsigned ID, const char *Name,
33506f32e7eSjoerg llvm::BitstreamWriter &Stream,
33606f32e7eSjoerg RecordDataImpl &Record){
33706f32e7eSjoerg Record.clear();
33806f32e7eSjoerg Record.push_back(ID);
33906f32e7eSjoerg
34006f32e7eSjoerg while (*Name)
34106f32e7eSjoerg Record.push_back(*Name++);
34206f32e7eSjoerg
34306f32e7eSjoerg Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETRECORDNAME, Record);
34406f32e7eSjoerg }
34506f32e7eSjoerg
AddLocToRecord(FullSourceLoc Loc,PresumedLoc PLoc,RecordDataImpl & Record,unsigned TokSize)34606f32e7eSjoerg void SDiagsWriter::AddLocToRecord(FullSourceLoc Loc, PresumedLoc PLoc,
34706f32e7eSjoerg RecordDataImpl &Record, unsigned TokSize) {
34806f32e7eSjoerg if (PLoc.isInvalid()) {
34906f32e7eSjoerg // Emit a "sentinel" location.
35006f32e7eSjoerg Record.push_back((unsigned)0); // File.
35106f32e7eSjoerg Record.push_back((unsigned)0); // Line.
35206f32e7eSjoerg Record.push_back((unsigned)0); // Column.
35306f32e7eSjoerg Record.push_back((unsigned)0); // Offset.
35406f32e7eSjoerg return;
35506f32e7eSjoerg }
35606f32e7eSjoerg
35706f32e7eSjoerg Record.push_back(getEmitFile(PLoc.getFilename()));
35806f32e7eSjoerg Record.push_back(PLoc.getLine());
35906f32e7eSjoerg Record.push_back(PLoc.getColumn()+TokSize);
36006f32e7eSjoerg Record.push_back(Loc.getFileOffset());
36106f32e7eSjoerg }
36206f32e7eSjoerg
AddCharSourceRangeToRecord(CharSourceRange Range,RecordDataImpl & Record,const SourceManager & SM)36306f32e7eSjoerg void SDiagsWriter::AddCharSourceRangeToRecord(CharSourceRange Range,
36406f32e7eSjoerg RecordDataImpl &Record,
36506f32e7eSjoerg const SourceManager &SM) {
36606f32e7eSjoerg AddLocToRecord(FullSourceLoc(Range.getBegin(), SM), Record);
36706f32e7eSjoerg unsigned TokSize = 0;
36806f32e7eSjoerg if (Range.isTokenRange())
36906f32e7eSjoerg TokSize = Lexer::MeasureTokenLength(Range.getEnd(),
37006f32e7eSjoerg SM, *LangOpts);
37106f32e7eSjoerg
37206f32e7eSjoerg AddLocToRecord(FullSourceLoc(Range.getEnd(), SM), Record, TokSize);
37306f32e7eSjoerg }
37406f32e7eSjoerg
getEmitFile(const char * FileName)37506f32e7eSjoerg unsigned SDiagsWriter::getEmitFile(const char *FileName){
37606f32e7eSjoerg if (!FileName)
37706f32e7eSjoerg return 0;
37806f32e7eSjoerg
37906f32e7eSjoerg unsigned &entry = State->Files[FileName];
38006f32e7eSjoerg if (entry)
38106f32e7eSjoerg return entry;
38206f32e7eSjoerg
38306f32e7eSjoerg // Lazily generate the record for the file.
38406f32e7eSjoerg entry = State->Files.size();
38506f32e7eSjoerg StringRef Name(FileName);
38606f32e7eSjoerg RecordData::value_type Record[] = {RECORD_FILENAME, entry, 0 /* For legacy */,
38706f32e7eSjoerg 0 /* For legacy */, Name.size()};
38806f32e7eSjoerg State->Stream.EmitRecordWithBlob(State->Abbrevs.get(RECORD_FILENAME), Record,
38906f32e7eSjoerg Name);
39006f32e7eSjoerg
39106f32e7eSjoerg return entry;
39206f32e7eSjoerg }
39306f32e7eSjoerg
EmitCharSourceRange(CharSourceRange R,const SourceManager & SM)39406f32e7eSjoerg void SDiagsWriter::EmitCharSourceRange(CharSourceRange R,
39506f32e7eSjoerg const SourceManager &SM) {
39606f32e7eSjoerg State->Record.clear();
39706f32e7eSjoerg State->Record.push_back(RECORD_SOURCE_RANGE);
39806f32e7eSjoerg AddCharSourceRangeToRecord(R, State->Record, SM);
39906f32e7eSjoerg State->Stream.EmitRecordWithAbbrev(State->Abbrevs.get(RECORD_SOURCE_RANGE),
40006f32e7eSjoerg State->Record);
40106f32e7eSjoerg }
40206f32e7eSjoerg
40306f32e7eSjoerg /// Emits the preamble of the diagnostics file.
EmitPreamble()40406f32e7eSjoerg void SDiagsWriter::EmitPreamble() {
40506f32e7eSjoerg // Emit the file header.
40606f32e7eSjoerg State->Stream.Emit((unsigned)'D', 8);
40706f32e7eSjoerg State->Stream.Emit((unsigned)'I', 8);
40806f32e7eSjoerg State->Stream.Emit((unsigned)'A', 8);
40906f32e7eSjoerg State->Stream.Emit((unsigned)'G', 8);
41006f32e7eSjoerg
41106f32e7eSjoerg EmitBlockInfoBlock();
41206f32e7eSjoerg EmitMetaBlock();
41306f32e7eSjoerg }
41406f32e7eSjoerg
AddSourceLocationAbbrev(llvm::BitCodeAbbrev & Abbrev)41506f32e7eSjoerg static void AddSourceLocationAbbrev(llvm::BitCodeAbbrev &Abbrev) {
41606f32e7eSjoerg using namespace llvm;
41706f32e7eSjoerg Abbrev.Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // File ID.
41806f32e7eSjoerg Abbrev.Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Line.
41906f32e7eSjoerg Abbrev.Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Column.
42006f32e7eSjoerg Abbrev.Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Offset;
42106f32e7eSjoerg }
42206f32e7eSjoerg
AddRangeLocationAbbrev(llvm::BitCodeAbbrev & Abbrev)42306f32e7eSjoerg static void AddRangeLocationAbbrev(llvm::BitCodeAbbrev &Abbrev) {
42406f32e7eSjoerg AddSourceLocationAbbrev(Abbrev);
42506f32e7eSjoerg AddSourceLocationAbbrev(Abbrev);
42606f32e7eSjoerg }
42706f32e7eSjoerg
EmitBlockInfoBlock()42806f32e7eSjoerg void SDiagsWriter::EmitBlockInfoBlock() {
42906f32e7eSjoerg State->Stream.EnterBlockInfoBlock();
43006f32e7eSjoerg
43106f32e7eSjoerg using namespace llvm;
43206f32e7eSjoerg llvm::BitstreamWriter &Stream = State->Stream;
43306f32e7eSjoerg RecordData &Record = State->Record;
43406f32e7eSjoerg AbbreviationMap &Abbrevs = State->Abbrevs;
43506f32e7eSjoerg
43606f32e7eSjoerg // ==---------------------------------------------------------------------==//
43706f32e7eSjoerg // The subsequent records and Abbrevs are for the "Meta" block.
43806f32e7eSjoerg // ==---------------------------------------------------------------------==//
43906f32e7eSjoerg
44006f32e7eSjoerg EmitBlockID(BLOCK_META, "Meta", Stream, Record);
44106f32e7eSjoerg EmitRecordID(RECORD_VERSION, "Version", Stream, Record);
44206f32e7eSjoerg auto Abbrev = std::make_shared<BitCodeAbbrev>();
44306f32e7eSjoerg Abbrev->Add(BitCodeAbbrevOp(RECORD_VERSION));
44406f32e7eSjoerg Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
44506f32e7eSjoerg Abbrevs.set(RECORD_VERSION, Stream.EmitBlockInfoAbbrev(BLOCK_META, Abbrev));
44606f32e7eSjoerg
44706f32e7eSjoerg // ==---------------------------------------------------------------------==//
44806f32e7eSjoerg // The subsequent records and Abbrevs are for the "Diagnostic" block.
44906f32e7eSjoerg // ==---------------------------------------------------------------------==//
45006f32e7eSjoerg
45106f32e7eSjoerg EmitBlockID(BLOCK_DIAG, "Diag", Stream, Record);
45206f32e7eSjoerg EmitRecordID(RECORD_DIAG, "DiagInfo", Stream, Record);
45306f32e7eSjoerg EmitRecordID(RECORD_SOURCE_RANGE, "SrcRange", Stream, Record);
45406f32e7eSjoerg EmitRecordID(RECORD_CATEGORY, "CatName", Stream, Record);
45506f32e7eSjoerg EmitRecordID(RECORD_DIAG_FLAG, "DiagFlag", Stream, Record);
45606f32e7eSjoerg EmitRecordID(RECORD_FILENAME, "FileName", Stream, Record);
45706f32e7eSjoerg EmitRecordID(RECORD_FIXIT, "FixIt", Stream, Record);
45806f32e7eSjoerg
45906f32e7eSjoerg // Emit abbreviation for RECORD_DIAG.
46006f32e7eSjoerg Abbrev = std::make_shared<BitCodeAbbrev>();
46106f32e7eSjoerg Abbrev->Add(BitCodeAbbrevOp(RECORD_DIAG));
46206f32e7eSjoerg Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // Diag level.
46306f32e7eSjoerg AddSourceLocationAbbrev(*Abbrev);
46406f32e7eSjoerg Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Category.
46506f32e7eSjoerg Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Mapped Diag ID.
46606f32e7eSjoerg Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // Text size.
46706f32e7eSjoerg Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Diagnostc text.
46806f32e7eSjoerg Abbrevs.set(RECORD_DIAG, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev));
46906f32e7eSjoerg
47006f32e7eSjoerg // Emit abbreviation for RECORD_CATEGORY.
47106f32e7eSjoerg Abbrev = std::make_shared<BitCodeAbbrev>();
47206f32e7eSjoerg Abbrev->Add(BitCodeAbbrevOp(RECORD_CATEGORY));
47306f32e7eSjoerg Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Category ID.
47406f32e7eSjoerg Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8)); // Text size.
47506f32e7eSjoerg Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Category text.
47606f32e7eSjoerg Abbrevs.set(RECORD_CATEGORY, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev));
47706f32e7eSjoerg
47806f32e7eSjoerg // Emit abbreviation for RECORD_SOURCE_RANGE.
47906f32e7eSjoerg Abbrev = std::make_shared<BitCodeAbbrev>();
48006f32e7eSjoerg Abbrev->Add(BitCodeAbbrevOp(RECORD_SOURCE_RANGE));
48106f32e7eSjoerg AddRangeLocationAbbrev(*Abbrev);
48206f32e7eSjoerg Abbrevs.set(RECORD_SOURCE_RANGE,
48306f32e7eSjoerg Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev));
48406f32e7eSjoerg
48506f32e7eSjoerg // Emit the abbreviation for RECORD_DIAG_FLAG.
48606f32e7eSjoerg Abbrev = std::make_shared<BitCodeAbbrev>();
48706f32e7eSjoerg Abbrev->Add(BitCodeAbbrevOp(RECORD_DIAG_FLAG));
48806f32e7eSjoerg Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Mapped Diag ID.
48906f32e7eSjoerg Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Text size.
49006f32e7eSjoerg Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Flag name text.
49106f32e7eSjoerg Abbrevs.set(RECORD_DIAG_FLAG, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG,
49206f32e7eSjoerg Abbrev));
49306f32e7eSjoerg
49406f32e7eSjoerg // Emit the abbreviation for RECORD_FILENAME.
49506f32e7eSjoerg Abbrev = std::make_shared<BitCodeAbbrev>();
49606f32e7eSjoerg Abbrev->Add(BitCodeAbbrevOp(RECORD_FILENAME));
49706f32e7eSjoerg Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Mapped file ID.
49806f32e7eSjoerg Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Size.
49906f32e7eSjoerg Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Modification time.
50006f32e7eSjoerg Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Text size.
50106f32e7eSjoerg Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name text.
50206f32e7eSjoerg Abbrevs.set(RECORD_FILENAME, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG,
50306f32e7eSjoerg Abbrev));
50406f32e7eSjoerg
50506f32e7eSjoerg // Emit the abbreviation for RECORD_FIXIT.
50606f32e7eSjoerg Abbrev = std::make_shared<BitCodeAbbrev>();
50706f32e7eSjoerg Abbrev->Add(BitCodeAbbrevOp(RECORD_FIXIT));
50806f32e7eSjoerg AddRangeLocationAbbrev(*Abbrev);
50906f32e7eSjoerg Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Text size.
51006f32e7eSjoerg Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // FixIt text.
51106f32e7eSjoerg Abbrevs.set(RECORD_FIXIT, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG,
51206f32e7eSjoerg Abbrev));
51306f32e7eSjoerg
51406f32e7eSjoerg Stream.ExitBlock();
51506f32e7eSjoerg }
51606f32e7eSjoerg
EmitMetaBlock()51706f32e7eSjoerg void SDiagsWriter::EmitMetaBlock() {
51806f32e7eSjoerg llvm::BitstreamWriter &Stream = State->Stream;
51906f32e7eSjoerg AbbreviationMap &Abbrevs = State->Abbrevs;
52006f32e7eSjoerg
52106f32e7eSjoerg Stream.EnterSubblock(BLOCK_META, 3);
52206f32e7eSjoerg RecordData::value_type Record[] = {RECORD_VERSION, VersionNumber};
52306f32e7eSjoerg Stream.EmitRecordWithAbbrev(Abbrevs.get(RECORD_VERSION), Record);
52406f32e7eSjoerg Stream.ExitBlock();
52506f32e7eSjoerg }
52606f32e7eSjoerg
getEmitCategory(unsigned int category)52706f32e7eSjoerg unsigned SDiagsWriter::getEmitCategory(unsigned int category) {
52806f32e7eSjoerg if (!State->Categories.insert(category).second)
52906f32e7eSjoerg return category;
53006f32e7eSjoerg
53106f32e7eSjoerg // We use a local version of 'Record' so that we can be generating
53206f32e7eSjoerg // another record when we lazily generate one for the category entry.
53306f32e7eSjoerg StringRef catName = DiagnosticIDs::getCategoryNameFromID(category);
53406f32e7eSjoerg RecordData::value_type Record[] = {RECORD_CATEGORY, category, catName.size()};
53506f32e7eSjoerg State->Stream.EmitRecordWithBlob(State->Abbrevs.get(RECORD_CATEGORY), Record,
53606f32e7eSjoerg catName);
53706f32e7eSjoerg
53806f32e7eSjoerg return category;
53906f32e7eSjoerg }
54006f32e7eSjoerg
getEmitDiagnosticFlag(DiagnosticsEngine::Level DiagLevel,unsigned DiagID)54106f32e7eSjoerg unsigned SDiagsWriter::getEmitDiagnosticFlag(DiagnosticsEngine::Level DiagLevel,
54206f32e7eSjoerg unsigned DiagID) {
54306f32e7eSjoerg if (DiagLevel == DiagnosticsEngine::Note)
54406f32e7eSjoerg return 0; // No flag for notes.
54506f32e7eSjoerg
54606f32e7eSjoerg StringRef FlagName = DiagnosticIDs::getWarningOptionForDiag(DiagID);
54706f32e7eSjoerg return getEmitDiagnosticFlag(FlagName);
54806f32e7eSjoerg }
54906f32e7eSjoerg
getEmitDiagnosticFlag(StringRef FlagName)55006f32e7eSjoerg unsigned SDiagsWriter::getEmitDiagnosticFlag(StringRef FlagName) {
55106f32e7eSjoerg if (FlagName.empty())
55206f32e7eSjoerg return 0;
55306f32e7eSjoerg
55406f32e7eSjoerg // Here we assume that FlagName points to static data whose pointer
55506f32e7eSjoerg // value is fixed. This allows us to unique by diagnostic groups.
55606f32e7eSjoerg const void *data = FlagName.data();
55706f32e7eSjoerg std::pair<unsigned, StringRef> &entry = State->DiagFlags[data];
55806f32e7eSjoerg if (entry.first == 0) {
55906f32e7eSjoerg entry.first = State->DiagFlags.size();
56006f32e7eSjoerg entry.second = FlagName;
56106f32e7eSjoerg
56206f32e7eSjoerg // Lazily emit the string in a separate record.
56306f32e7eSjoerg RecordData::value_type Record[] = {RECORD_DIAG_FLAG, entry.first,
56406f32e7eSjoerg FlagName.size()};
56506f32e7eSjoerg State->Stream.EmitRecordWithBlob(State->Abbrevs.get(RECORD_DIAG_FLAG),
56606f32e7eSjoerg Record, FlagName);
56706f32e7eSjoerg }
56806f32e7eSjoerg
56906f32e7eSjoerg return entry.first;
57006f32e7eSjoerg }
57106f32e7eSjoerg
HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,const Diagnostic & Info)57206f32e7eSjoerg void SDiagsWriter::HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
57306f32e7eSjoerg const Diagnostic &Info) {
574*13fbcb42Sjoerg assert(!IsFinishing &&
575*13fbcb42Sjoerg "Received a diagnostic after we've already started teardown.");
576*13fbcb42Sjoerg if (IsFinishing) {
577*13fbcb42Sjoerg SmallString<256> diagnostic;
578*13fbcb42Sjoerg Info.FormatDiagnostic(diagnostic);
579*13fbcb42Sjoerg getMetaDiags()->Report(
580*13fbcb42Sjoerg diag::warn_fe_serialized_diag_failure_during_finalisation)
581*13fbcb42Sjoerg << diagnostic;
582*13fbcb42Sjoerg return;
583*13fbcb42Sjoerg }
584*13fbcb42Sjoerg
58506f32e7eSjoerg // Enter the block for a non-note diagnostic immediately, rather than waiting
58606f32e7eSjoerg // for beginDiagnostic, in case associated notes are emitted before we get
58706f32e7eSjoerg // there.
58806f32e7eSjoerg if (DiagLevel != DiagnosticsEngine::Note) {
58906f32e7eSjoerg if (State->EmittedAnyDiagBlocks)
59006f32e7eSjoerg ExitDiagBlock();
59106f32e7eSjoerg
59206f32e7eSjoerg EnterDiagBlock();
59306f32e7eSjoerg State->EmittedAnyDiagBlocks = true;
59406f32e7eSjoerg }
59506f32e7eSjoerg
59606f32e7eSjoerg // Compute the diagnostic text.
59706f32e7eSjoerg State->diagBuf.clear();
59806f32e7eSjoerg Info.FormatDiagnostic(State->diagBuf);
59906f32e7eSjoerg
60006f32e7eSjoerg if (Info.getLocation().isInvalid()) {
60106f32e7eSjoerg // Special-case diagnostics with no location. We may not have entered a
60206f32e7eSjoerg // source file in this case, so we can't use the normal DiagnosticsRenderer
60306f32e7eSjoerg // machinery.
60406f32e7eSjoerg
60506f32e7eSjoerg // Make sure we bracket all notes as "sub-diagnostics". This matches
60606f32e7eSjoerg // the behavior in SDiagsRenderer::emitDiagnostic().
60706f32e7eSjoerg if (DiagLevel == DiagnosticsEngine::Note)
60806f32e7eSjoerg EnterDiagBlock();
60906f32e7eSjoerg
61006f32e7eSjoerg EmitDiagnosticMessage(FullSourceLoc(), PresumedLoc(), DiagLevel,
61106f32e7eSjoerg State->diagBuf, &Info);
61206f32e7eSjoerg
61306f32e7eSjoerg if (DiagLevel == DiagnosticsEngine::Note)
61406f32e7eSjoerg ExitDiagBlock();
61506f32e7eSjoerg
61606f32e7eSjoerg return;
61706f32e7eSjoerg }
61806f32e7eSjoerg
61906f32e7eSjoerg assert(Info.hasSourceManager() && LangOpts &&
62006f32e7eSjoerg "Unexpected diagnostic with valid location outside of a source file");
62106f32e7eSjoerg SDiagsRenderer Renderer(*this, *LangOpts, &*State->DiagOpts);
62206f32e7eSjoerg Renderer.emitDiagnostic(
62306f32e7eSjoerg FullSourceLoc(Info.getLocation(), Info.getSourceManager()), DiagLevel,
62406f32e7eSjoerg State->diagBuf, Info.getRanges(), Info.getFixItHints(), &Info);
62506f32e7eSjoerg }
62606f32e7eSjoerg
getStableLevel(DiagnosticsEngine::Level Level)62706f32e7eSjoerg static serialized_diags::Level getStableLevel(DiagnosticsEngine::Level Level) {
62806f32e7eSjoerg switch (Level) {
62906f32e7eSjoerg #define CASE(X) case DiagnosticsEngine::X: return serialized_diags::X;
63006f32e7eSjoerg CASE(Ignored)
63106f32e7eSjoerg CASE(Note)
63206f32e7eSjoerg CASE(Remark)
63306f32e7eSjoerg CASE(Warning)
63406f32e7eSjoerg CASE(Error)
63506f32e7eSjoerg CASE(Fatal)
63606f32e7eSjoerg #undef CASE
63706f32e7eSjoerg }
63806f32e7eSjoerg
63906f32e7eSjoerg llvm_unreachable("invalid diagnostic level");
64006f32e7eSjoerg }
64106f32e7eSjoerg
EmitDiagnosticMessage(FullSourceLoc Loc,PresumedLoc PLoc,DiagnosticsEngine::Level Level,StringRef Message,DiagOrStoredDiag D)64206f32e7eSjoerg void SDiagsWriter::EmitDiagnosticMessage(FullSourceLoc Loc, PresumedLoc PLoc,
64306f32e7eSjoerg DiagnosticsEngine::Level Level,
64406f32e7eSjoerg StringRef Message,
64506f32e7eSjoerg DiagOrStoredDiag D) {
64606f32e7eSjoerg llvm::BitstreamWriter &Stream = State->Stream;
64706f32e7eSjoerg RecordData &Record = State->Record;
64806f32e7eSjoerg AbbreviationMap &Abbrevs = State->Abbrevs;
64906f32e7eSjoerg
65006f32e7eSjoerg // Emit the RECORD_DIAG record.
65106f32e7eSjoerg Record.clear();
65206f32e7eSjoerg Record.push_back(RECORD_DIAG);
65306f32e7eSjoerg Record.push_back(getStableLevel(Level));
65406f32e7eSjoerg AddLocToRecord(Loc, PLoc, Record);
65506f32e7eSjoerg
65606f32e7eSjoerg if (const Diagnostic *Info = D.dyn_cast<const Diagnostic*>()) {
65706f32e7eSjoerg // Emit the category string lazily and get the category ID.
65806f32e7eSjoerg unsigned DiagID = DiagnosticIDs::getCategoryNumberForDiag(Info->getID());
65906f32e7eSjoerg Record.push_back(getEmitCategory(DiagID));
66006f32e7eSjoerg // Emit the diagnostic flag string lazily and get the mapped ID.
66106f32e7eSjoerg Record.push_back(getEmitDiagnosticFlag(Level, Info->getID()));
66206f32e7eSjoerg } else {
66306f32e7eSjoerg Record.push_back(getEmitCategory());
66406f32e7eSjoerg Record.push_back(getEmitDiagnosticFlag(Level));
66506f32e7eSjoerg }
66606f32e7eSjoerg
66706f32e7eSjoerg Record.push_back(Message.size());
66806f32e7eSjoerg Stream.EmitRecordWithBlob(Abbrevs.get(RECORD_DIAG), Record, Message);
66906f32e7eSjoerg }
67006f32e7eSjoerg
emitDiagnosticMessage(FullSourceLoc Loc,PresumedLoc PLoc,DiagnosticsEngine::Level Level,StringRef Message,ArrayRef<clang::CharSourceRange> Ranges,DiagOrStoredDiag D)67106f32e7eSjoerg void SDiagsRenderer::emitDiagnosticMessage(
67206f32e7eSjoerg FullSourceLoc Loc, PresumedLoc PLoc, DiagnosticsEngine::Level Level,
67306f32e7eSjoerg StringRef Message, ArrayRef<clang::CharSourceRange> Ranges,
67406f32e7eSjoerg DiagOrStoredDiag D) {
67506f32e7eSjoerg Writer.EmitDiagnosticMessage(Loc, PLoc, Level, Message, D);
67606f32e7eSjoerg }
67706f32e7eSjoerg
EnterDiagBlock()67806f32e7eSjoerg void SDiagsWriter::EnterDiagBlock() {
67906f32e7eSjoerg State->Stream.EnterSubblock(BLOCK_DIAG, 4);
68006f32e7eSjoerg }
68106f32e7eSjoerg
ExitDiagBlock()68206f32e7eSjoerg void SDiagsWriter::ExitDiagBlock() {
68306f32e7eSjoerg State->Stream.ExitBlock();
68406f32e7eSjoerg }
68506f32e7eSjoerg
beginDiagnostic(DiagOrStoredDiag D,DiagnosticsEngine::Level Level)68606f32e7eSjoerg void SDiagsRenderer::beginDiagnostic(DiagOrStoredDiag D,
68706f32e7eSjoerg DiagnosticsEngine::Level Level) {
68806f32e7eSjoerg if (Level == DiagnosticsEngine::Note)
68906f32e7eSjoerg Writer.EnterDiagBlock();
69006f32e7eSjoerg }
69106f32e7eSjoerg
endDiagnostic(DiagOrStoredDiag D,DiagnosticsEngine::Level Level)69206f32e7eSjoerg void SDiagsRenderer::endDiagnostic(DiagOrStoredDiag D,
69306f32e7eSjoerg DiagnosticsEngine::Level Level) {
69406f32e7eSjoerg // Only end note diagnostics here, because we can't be sure when we've seen
69506f32e7eSjoerg // the last note associated with a non-note diagnostic.
69606f32e7eSjoerg if (Level == DiagnosticsEngine::Note)
69706f32e7eSjoerg Writer.ExitDiagBlock();
69806f32e7eSjoerg }
69906f32e7eSjoerg
EmitCodeContext(SmallVectorImpl<CharSourceRange> & Ranges,ArrayRef<FixItHint> Hints,const SourceManager & SM)70006f32e7eSjoerg void SDiagsWriter::EmitCodeContext(SmallVectorImpl<CharSourceRange> &Ranges,
70106f32e7eSjoerg ArrayRef<FixItHint> Hints,
70206f32e7eSjoerg const SourceManager &SM) {
70306f32e7eSjoerg llvm::BitstreamWriter &Stream = State->Stream;
70406f32e7eSjoerg RecordData &Record = State->Record;
70506f32e7eSjoerg AbbreviationMap &Abbrevs = State->Abbrevs;
70606f32e7eSjoerg
70706f32e7eSjoerg // Emit Source Ranges.
70806f32e7eSjoerg for (ArrayRef<CharSourceRange>::iterator I = Ranges.begin(), E = Ranges.end();
70906f32e7eSjoerg I != E; ++I)
71006f32e7eSjoerg if (I->isValid())
71106f32e7eSjoerg EmitCharSourceRange(*I, SM);
71206f32e7eSjoerg
71306f32e7eSjoerg // Emit FixIts.
71406f32e7eSjoerg for (ArrayRef<FixItHint>::iterator I = Hints.begin(), E = Hints.end();
71506f32e7eSjoerg I != E; ++I) {
71606f32e7eSjoerg const FixItHint &Fix = *I;
71706f32e7eSjoerg if (Fix.isNull())
71806f32e7eSjoerg continue;
71906f32e7eSjoerg Record.clear();
72006f32e7eSjoerg Record.push_back(RECORD_FIXIT);
72106f32e7eSjoerg AddCharSourceRangeToRecord(Fix.RemoveRange, Record, SM);
72206f32e7eSjoerg Record.push_back(Fix.CodeToInsert.size());
72306f32e7eSjoerg Stream.EmitRecordWithBlob(Abbrevs.get(RECORD_FIXIT), Record,
72406f32e7eSjoerg Fix.CodeToInsert);
72506f32e7eSjoerg }
72606f32e7eSjoerg }
72706f32e7eSjoerg
emitCodeContext(FullSourceLoc Loc,DiagnosticsEngine::Level Level,SmallVectorImpl<CharSourceRange> & Ranges,ArrayRef<FixItHint> Hints)72806f32e7eSjoerg void SDiagsRenderer::emitCodeContext(FullSourceLoc Loc,
72906f32e7eSjoerg DiagnosticsEngine::Level Level,
73006f32e7eSjoerg SmallVectorImpl<CharSourceRange> &Ranges,
73106f32e7eSjoerg ArrayRef<FixItHint> Hints) {
73206f32e7eSjoerg Writer.EmitCodeContext(Ranges, Hints, Loc.getManager());
73306f32e7eSjoerg }
73406f32e7eSjoerg
emitNote(FullSourceLoc Loc,StringRef Message)73506f32e7eSjoerg void SDiagsRenderer::emitNote(FullSourceLoc Loc, StringRef Message) {
73606f32e7eSjoerg Writer.EnterDiagBlock();
73706f32e7eSjoerg PresumedLoc PLoc = Loc.hasManager() ? Loc.getPresumedLoc() : PresumedLoc();
73806f32e7eSjoerg Writer.EmitDiagnosticMessage(Loc, PLoc, DiagnosticsEngine::Note, Message,
73906f32e7eSjoerg DiagOrStoredDiag());
74006f32e7eSjoerg Writer.ExitDiagBlock();
74106f32e7eSjoerg }
74206f32e7eSjoerg
getMetaDiags()74306f32e7eSjoerg DiagnosticsEngine *SDiagsWriter::getMetaDiags() {
74406f32e7eSjoerg // FIXME: It's slightly absurd to create a new diagnostics engine here, but
74506f32e7eSjoerg // the other options that are available today are worse:
74606f32e7eSjoerg //
74706f32e7eSjoerg // 1. Teach DiagnosticsConsumers to emit diagnostics to the engine they are a
74806f32e7eSjoerg // part of. The DiagnosticsEngine would need to know not to send
74906f32e7eSjoerg // diagnostics back to the consumer that failed. This would require us to
75006f32e7eSjoerg // rework ChainedDiagnosticsConsumer and teach the engine about multiple
75106f32e7eSjoerg // consumers, which is difficult today because most APIs interface with
75206f32e7eSjoerg // consumers rather than the engine itself.
75306f32e7eSjoerg //
75406f32e7eSjoerg // 2. Pass a DiagnosticsEngine to SDiagsWriter on creation - this would need
75506f32e7eSjoerg // to be distinct from the engine the writer was being added to and would
75606f32e7eSjoerg // normally not be used.
75706f32e7eSjoerg if (!State->MetaDiagnostics) {
75806f32e7eSjoerg IntrusiveRefCntPtr<DiagnosticIDs> IDs(new DiagnosticIDs());
75906f32e7eSjoerg auto Client =
76006f32e7eSjoerg new TextDiagnosticPrinter(llvm::errs(), State->DiagOpts.get());
76106f32e7eSjoerg State->MetaDiagnostics = std::make_unique<DiagnosticsEngine>(
76206f32e7eSjoerg IDs, State->DiagOpts.get(), Client);
76306f32e7eSjoerg }
76406f32e7eSjoerg return State->MetaDiagnostics.get();
76506f32e7eSjoerg }
76606f32e7eSjoerg
RemoveOldDiagnostics()76706f32e7eSjoerg void SDiagsWriter::RemoveOldDiagnostics() {
76806f32e7eSjoerg if (!llvm::sys::fs::remove(State->OutputFile))
76906f32e7eSjoerg return;
77006f32e7eSjoerg
77106f32e7eSjoerg getMetaDiags()->Report(diag::warn_fe_serialized_diag_merge_failure);
77206f32e7eSjoerg // Disable merging child records, as whatever is in this file may be
77306f32e7eSjoerg // misleading.
77406f32e7eSjoerg MergeChildRecords = false;
77506f32e7eSjoerg }
77606f32e7eSjoerg
finish()77706f32e7eSjoerg void SDiagsWriter::finish() {
778*13fbcb42Sjoerg assert(!IsFinishing);
779*13fbcb42Sjoerg IsFinishing = true;
780*13fbcb42Sjoerg
78106f32e7eSjoerg // The original instance is responsible for writing the file.
78206f32e7eSjoerg if (!OriginalInstance)
78306f32e7eSjoerg return;
78406f32e7eSjoerg
78506f32e7eSjoerg // Finish off any diagnostic we were in the process of emitting.
78606f32e7eSjoerg if (State->EmittedAnyDiagBlocks)
78706f32e7eSjoerg ExitDiagBlock();
78806f32e7eSjoerg
78906f32e7eSjoerg if (MergeChildRecords) {
79006f32e7eSjoerg if (!State->EmittedAnyDiagBlocks)
79106f32e7eSjoerg // We have no diagnostics of our own, so we can just leave the child
79206f32e7eSjoerg // process' output alone
79306f32e7eSjoerg return;
79406f32e7eSjoerg
79506f32e7eSjoerg if (llvm::sys::fs::exists(State->OutputFile))
79606f32e7eSjoerg if (SDiagsMerger(*this).mergeRecordsFromFile(State->OutputFile.c_str()))
79706f32e7eSjoerg getMetaDiags()->Report(diag::warn_fe_serialized_diag_merge_failure);
79806f32e7eSjoerg }
79906f32e7eSjoerg
80006f32e7eSjoerg std::error_code EC;
80106f32e7eSjoerg auto OS = std::make_unique<llvm::raw_fd_ostream>(State->OutputFile.c_str(),
80206f32e7eSjoerg EC, llvm::sys::fs::OF_None);
80306f32e7eSjoerg if (EC) {
80406f32e7eSjoerg getMetaDiags()->Report(diag::warn_fe_serialized_diag_failure)
80506f32e7eSjoerg << State->OutputFile << EC.message();
806*13fbcb42Sjoerg OS->clear_error();
80706f32e7eSjoerg return;
80806f32e7eSjoerg }
80906f32e7eSjoerg
81006f32e7eSjoerg // Write the generated bitstream to "Out".
81106f32e7eSjoerg OS->write((char *)&State->Buffer.front(), State->Buffer.size());
81206f32e7eSjoerg OS->flush();
813*13fbcb42Sjoerg
814*13fbcb42Sjoerg assert(!OS->has_error());
815*13fbcb42Sjoerg if (OS->has_error()) {
816*13fbcb42Sjoerg getMetaDiags()->Report(diag::warn_fe_serialized_diag_failure)
817*13fbcb42Sjoerg << State->OutputFile << OS->error().message();
818*13fbcb42Sjoerg OS->clear_error();
819*13fbcb42Sjoerg }
82006f32e7eSjoerg }
82106f32e7eSjoerg
visitStartOfDiagnostic()82206f32e7eSjoerg std::error_code SDiagsMerger::visitStartOfDiagnostic() {
82306f32e7eSjoerg Writer.EnterDiagBlock();
82406f32e7eSjoerg return std::error_code();
82506f32e7eSjoerg }
82606f32e7eSjoerg
visitEndOfDiagnostic()82706f32e7eSjoerg std::error_code SDiagsMerger::visitEndOfDiagnostic() {
82806f32e7eSjoerg Writer.ExitDiagBlock();
82906f32e7eSjoerg return std::error_code();
83006f32e7eSjoerg }
83106f32e7eSjoerg
83206f32e7eSjoerg std::error_code
visitSourceRangeRecord(const serialized_diags::Location & Start,const serialized_diags::Location & End)83306f32e7eSjoerg SDiagsMerger::visitSourceRangeRecord(const serialized_diags::Location &Start,
83406f32e7eSjoerg const serialized_diags::Location &End) {
83506f32e7eSjoerg RecordData::value_type Record[] = {
83606f32e7eSjoerg RECORD_SOURCE_RANGE, FileLookup[Start.FileID], Start.Line, Start.Col,
83706f32e7eSjoerg Start.Offset, FileLookup[End.FileID], End.Line, End.Col, End.Offset};
83806f32e7eSjoerg Writer.State->Stream.EmitRecordWithAbbrev(
83906f32e7eSjoerg Writer.State->Abbrevs.get(RECORD_SOURCE_RANGE), Record);
84006f32e7eSjoerg return std::error_code();
84106f32e7eSjoerg }
84206f32e7eSjoerg
visitDiagnosticRecord(unsigned Severity,const serialized_diags::Location & Location,unsigned Category,unsigned Flag,StringRef Message)84306f32e7eSjoerg std::error_code SDiagsMerger::visitDiagnosticRecord(
84406f32e7eSjoerg unsigned Severity, const serialized_diags::Location &Location,
84506f32e7eSjoerg unsigned Category, unsigned Flag, StringRef Message) {
84606f32e7eSjoerg RecordData::value_type Record[] = {
84706f32e7eSjoerg RECORD_DIAG, Severity, FileLookup[Location.FileID], Location.Line,
84806f32e7eSjoerg Location.Col, Location.Offset, CategoryLookup[Category],
84906f32e7eSjoerg Flag ? DiagFlagLookup[Flag] : 0, Message.size()};
85006f32e7eSjoerg
85106f32e7eSjoerg Writer.State->Stream.EmitRecordWithBlob(
85206f32e7eSjoerg Writer.State->Abbrevs.get(RECORD_DIAG), Record, Message);
85306f32e7eSjoerg return std::error_code();
85406f32e7eSjoerg }
85506f32e7eSjoerg
85606f32e7eSjoerg std::error_code
visitFixitRecord(const serialized_diags::Location & Start,const serialized_diags::Location & End,StringRef Text)85706f32e7eSjoerg SDiagsMerger::visitFixitRecord(const serialized_diags::Location &Start,
85806f32e7eSjoerg const serialized_diags::Location &End,
85906f32e7eSjoerg StringRef Text) {
86006f32e7eSjoerg RecordData::value_type Record[] = {RECORD_FIXIT, FileLookup[Start.FileID],
86106f32e7eSjoerg Start.Line, Start.Col, Start.Offset,
86206f32e7eSjoerg FileLookup[End.FileID], End.Line, End.Col,
86306f32e7eSjoerg End.Offset, Text.size()};
86406f32e7eSjoerg
86506f32e7eSjoerg Writer.State->Stream.EmitRecordWithBlob(
86606f32e7eSjoerg Writer.State->Abbrevs.get(RECORD_FIXIT), Record, Text);
86706f32e7eSjoerg return std::error_code();
86806f32e7eSjoerg }
86906f32e7eSjoerg
visitFilenameRecord(unsigned ID,unsigned Size,unsigned Timestamp,StringRef Name)87006f32e7eSjoerg std::error_code SDiagsMerger::visitFilenameRecord(unsigned ID, unsigned Size,
87106f32e7eSjoerg unsigned Timestamp,
87206f32e7eSjoerg StringRef Name) {
87306f32e7eSjoerg FileLookup[ID] = Writer.getEmitFile(Name.str().c_str());
87406f32e7eSjoerg return std::error_code();
87506f32e7eSjoerg }
87606f32e7eSjoerg
visitCategoryRecord(unsigned ID,StringRef Name)87706f32e7eSjoerg std::error_code SDiagsMerger::visitCategoryRecord(unsigned ID, StringRef Name) {
87806f32e7eSjoerg CategoryLookup[ID] = Writer.getEmitCategory(ID);
87906f32e7eSjoerg return std::error_code();
88006f32e7eSjoerg }
88106f32e7eSjoerg
visitDiagFlagRecord(unsigned ID,StringRef Name)88206f32e7eSjoerg std::error_code SDiagsMerger::visitDiagFlagRecord(unsigned ID, StringRef Name) {
88306f32e7eSjoerg DiagFlagLookup[ID] = Writer.getEmitDiagnosticFlag(Name);
88406f32e7eSjoerg return std::error_code();
88506f32e7eSjoerg }
886