clang 8.0.0

SerializedDiagnosticPrinter.cpp
Go to the documentation of this file.
1 //===--- SerializedDiagnosticPrinter.cpp - Serializer for diagnostics -----===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 #include "clang/Frontend/SerializedDiagnosticPrinter.h"
11 #include "clang/Basic/Diagnostic.h"
12 #include "clang/Basic/DiagnosticOptions.h"
13 #include "clang/Basic/SourceManager.h"
14 #include "clang/Frontend/DiagnosticRenderer.h"
15 #include "clang/Frontend/FrontendDiagnostic.h"
16 #include "clang/Frontend/SerializedDiagnosticReader.h"
17 #include "clang/Frontend/SerializedDiagnostics.h"
18 #include "clang/Frontend/TextDiagnosticPrinter.h"
19 #include "clang/Lex/Lexer.h"
20 #include "llvm/ADT/DenseSet.h"
21 #include "llvm/ADT/STLExtras.h"
22 #include "llvm/ADT/SmallString.h"
23 #include "llvm/ADT/StringRef.h"
24 #include "llvm/Support/raw_ostream.h"
25 #include <utility>
26
27 using namespace clang;
28 using namespace clang::serialized_diags;
29
30 namespace {
31
32 class AbbreviationMap {
33 llvm::DenseMap<unsigned, unsigned> Abbrevs;
34 public:
35 AbbreviationMap() {}
36
37 void set(unsigned recordID, unsigned abbrevID) {
38 assert(Abbrevs.find(recordID) == Abbrevs.end()
39 && "Abbreviation already set.");
40 Abbrevs[recordID] = abbrevID;
41 }
42
43 unsigned get(unsigned recordID) {
44 assert(Abbrevs.find(recordID) != Abbrevs.end() &&
45 "Abbreviation not set.");
46 return Abbrevs[recordID];
47 }
48 };
49
50 typedef SmallVector<uint64_t, 64> RecordData;
51 typedef SmallVectorImpl<uint64_t> RecordDataImpl;
52 typedef ArrayRef<uint64_t> RecordDataRef;
53
54 class SDiagsWriter;
55
56 class SDiagsRenderer : public DiagnosticNoteRenderer {
57 SDiagsWriter &Writer;
58 public:
59 SDiagsRenderer(SDiagsWriter &Writer, const LangOptions &LangOpts,
60 DiagnosticOptions *DiagOpts)
61 : DiagnosticNoteRenderer(LangOpts, DiagOpts), Writer(Writer) {}
62
63 ~SDiagsRenderer() override {}
64
65 protected:
66 void emitDiagnosticMessage(FullSourceLoc Loc, PresumedLoc PLoc,
67 DiagnosticsEngine::Level Level, StringRef Message,
68 ArrayRef<CharSourceRange> Ranges,
69 DiagOrStoredDiag D) override;
70
71 void emitDiagnosticLoc(FullSourceLoc Loc, PresumedLoc PLoc,
72 DiagnosticsEngine::Level Level,
73 ArrayRef<CharSourceRange> Ranges) override {}
74
75 void emitNote(FullSourceLoc Loc, StringRef Message) override;
76
77 void emitCodeContext(FullSourceLoc Loc, DiagnosticsEngine::Level Level,
78 SmallVectorImpl<CharSourceRange> &Ranges,
79 ArrayRef<FixItHint> Hints) override;
80
81 void beginDiagnostic(DiagOrStoredDiag D,
82 DiagnosticsEngine::Level Level) override;
83 void endDiagnostic(DiagOrStoredDiag D,
84 DiagnosticsEngine::Level Level) override;
85 };
86
87 typedef llvm::DenseMap<unsigned, unsigned> AbbrevLookup;
88
89 class SDiagsMerger : SerializedDiagnosticReader {
90 SDiagsWriter &Writer;
91 AbbrevLookup FileLookup;
92 AbbrevLookup CategoryLookup;
93 AbbrevLookup DiagFlagLookup;
94
95 public:
96 SDiagsMerger(SDiagsWriter &Writer)
97 : SerializedDiagnosticReader(), Writer(Writer) {}
98
99 std::error_code mergeRecordsFromFile(const char *File) {
100 return readDiagnostics(File);
101 }
102
103 protected:
104 std::error_code visitStartOfDiagnostic() override;
105 std::error_code visitEndOfDiagnostic() override;
106 std::error_code visitCategoryRecord(unsigned ID, StringRef Name) override;
107 std::error_code visitDiagFlagRecord(unsigned ID, StringRef Name) override;
108 std::error_code visitDiagnosticRecord(
109 unsigned Severity, const serialized_diags::Location &Location,
110 unsigned Category, unsigned Flag, StringRef Message) override;
111 std::error_code visitFilenameRecord(unsigned ID, unsigned Size,
112 unsigned Timestamp,
113 StringRef Name) override;
114 std::error_code visitFixitRecord(const serialized_diags::Location &Start,
115 const serialized_diags::Location &End,
116 StringRef CodeToInsert) override;
117 std::error_code
118 visitSourceRangeRecord(const serialized_diags::Location &Start,
119 const serialized_diags::Location &End) override;
120
121 private:
122 std::error_code adjustSourceLocFilename(RecordData &Record,
123 unsigned int offset);
124
125 void adjustAbbrevID(RecordData &Record, AbbrevLookup &Lookup,
126 unsigned NewAbbrev);
127
128 void writeRecordWithAbbrev(unsigned ID, RecordData &Record);
129
130 void writeRecordWithBlob(unsigned ID, RecordData &Record, StringRef Blob);
131 };
132
133 class SDiagsWriter : public DiagnosticConsumer {
134 friend class SDiagsRenderer;
135 friend class SDiagsMerger;
136
137 struct SharedState;
138
139 explicit SDiagsWriter(std::shared_ptr<SharedState> State)
140 : LangOpts(nullptr), OriginalInstance(false), MergeChildRecords(false),
141 State(std::move(State)) {}
142
143 public:
144 SDiagsWriter(StringRef File, DiagnosticOptions *Diags, bool MergeChildRecords)
145 : LangOpts(nullptr), OriginalInstance(true),
146 MergeChildRecords(MergeChildRecords),
147 State(std::make_shared<SharedState>(File, Diags)) {
148 if (MergeChildRecords)
149 RemoveOldDiagnostics();
150 EmitPreamble();
151 }
152
153 ~SDiagsWriter() override {}
154
155 void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
156 const Diagnostic &Info) override;
157
158 void BeginSourceFile(const LangOptions &LO, const Preprocessor *PP) override {
159 LangOpts = &LO;
160 }
161
162 void finish() override;
163
164 private:
165 /// Build a DiagnosticsEngine to emit diagnostics about the diagnostics
166 DiagnosticsEngine *getMetaDiags();
167
168 /// Remove old copies of the serialized diagnostics. This is necessary
169 /// so that we can detect when subprocesses write diagnostics that we should
170 /// merge into our own.
171 void RemoveOldDiagnostics();
172
173 /// Emit the preamble for the serialized diagnostics.
174 void EmitPreamble();
175
176 /// Emit the BLOCKINFO block.
177 void EmitBlockInfoBlock();
178
179 /// Emit the META data block.
180 void EmitMetaBlock();
181
182 /// Start a DIAG block.
183 void EnterDiagBlock();
184
185 /// End a DIAG block.
186 void ExitDiagBlock();
187
188 /// Emit a DIAG record.
189 void EmitDiagnosticMessage(FullSourceLoc Loc, PresumedLoc PLoc,
190 DiagnosticsEngine::Level Level, StringRef Message,
191 DiagOrStoredDiag D);
192
193 /// Emit FIXIT and SOURCE_RANGE records for a diagnostic.
194 void EmitCodeContext(SmallVectorImpl<CharSourceRange> &Ranges,
195 ArrayRef<FixItHint> Hints,
196 const SourceManager &SM);
197
198 /// Emit a record for a CharSourceRange.
199 void EmitCharSourceRange(CharSourceRange R, const SourceManager &SM);
200
201 /// Emit the string information for the category.
202 unsigned getEmitCategory(unsigned category = 0);
203
204 /// Emit the string information for diagnostic flags.
205 unsigned getEmitDiagnosticFlag(DiagnosticsEngine::Level DiagLevel,
206 unsigned DiagID = 0);
207
208 unsigned getEmitDiagnosticFlag(StringRef DiagName);
209
210 /// Emit (lazily) the file string and retrieved the file identifier.
211 unsigned getEmitFile(const char *Filename);
212
213 /// Add SourceLocation information the specified record.
214 void AddLocToRecord(FullSourceLoc Loc, PresumedLoc PLoc,
215 RecordDataImpl &Record, unsigned TokSize = 0);
216
217 /// Add SourceLocation information the specified record.
218 void AddLocToRecord(FullSourceLoc Loc, RecordDataImpl &Record,
219 unsigned TokSize = 0) {
220 AddLocToRecord(Loc, Loc.hasManager() ? Loc.getPresumedLoc() : PresumedLoc(),
221 Record, TokSize);
222 }
223
224 /// Add CharSourceRange information the specified record.
225 void AddCharSourceRangeToRecord(CharSourceRange R, RecordDataImpl &Record,
226 const SourceManager &SM);
227
228 /// Language options, which can differ from one clone of this client
229 /// to another.
230 const LangOptions *LangOpts;
231
232 /// Whether this is the original instance (rather than one of its
233 /// clones), responsible for writing the file at the end.
234 bool OriginalInstance;
235
236 /// Whether this instance should aggregate diagnostics that are
237 /// generated from child processes.
238 bool MergeChildRecords;
239
240 /// State that is shared among the various clones of this diagnostic
241 /// consumer.
242 struct SharedState {
243 SharedState(StringRef File, DiagnosticOptions *Diags)
244 : DiagOpts(Diags), Stream(Buffer), OutputFile(File.str()),
245 EmittedAnyDiagBlocks(false) {}
246
247 /// Diagnostic options.
248 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts;
249
250 /// The byte buffer for the serialized content.
251 SmallString<1024> Buffer;
252
253 /// The BitStreamWriter for the serialized diagnostics.
254 llvm::BitstreamWriter Stream;
255
256 /// The name of the diagnostics file.
257 std::string OutputFile;
258
259 /// The set of constructed record abbreviations.
260 AbbreviationMap Abbrevs;
261
262 /// A utility buffer for constructing record content.
263 RecordData Record;
264
265 /// A text buffer for rendering diagnostic text.
266 SmallString<256> diagBuf;
267
268 /// The collection of diagnostic categories used.
269 llvm::DenseSet<unsigned> Categories;
270
271 /// The collection of files used.
272 llvm::DenseMap<const char *, unsigned> Files;
273
274 typedef llvm::DenseMap<const void *, std::pair<unsigned, StringRef> >
275 DiagFlagsTy;
276
277 /// Map for uniquing strings.
278 DiagFlagsTy DiagFlags;
279
280 /// Whether we have already started emission of any DIAG blocks. Once
281 /// this becomes \c true, we never close a DIAG block until we know that we're
282 /// starting another one or we're done.
283 bool EmittedAnyDiagBlocks;
284
285 /// Engine for emitting diagnostics about the diagnostics.
286 std::unique_ptr<DiagnosticsEngine> MetaDiagnostics;
287 };
288
289 /// State shared among the various clones of this diagnostic consumer.
290 std::shared_ptr<SharedState> State;
291 };
292 } // end anonymous namespace
293
294 namespace clang {
295 namespace serialized_diags {
296 std::unique_ptr<DiagnosticConsumer>
297 create(StringRef OutputFile, DiagnosticOptions *Diags, bool MergeChildRecords) {
298 return llvm::make_unique<SDiagsWriter>(OutputFile, Diags, MergeChildRecords);
299 }
300
301 } // end namespace serialized_diags
302 } // end namespace clang
303
304 //===----------------------------------------------------------------------===//
305 // Serialization methods.
306 //===----------------------------------------------------------------------===//
307
308 /// Emits a block ID in the BLOCKINFO block.
309 static void EmitBlockID(unsigned ID, const char *Name,
310 llvm::BitstreamWriter &Stream,
311 RecordDataImpl &Record) {
312 Record.clear();
313 Record.push_back(ID);
314 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETBID, Record);
315
316 // Emit the block name if present.
317 if (!Name || Name[0] == 0)
318 return;
319
320 Record.clear();
321
322 while (*Name)
323 Record.push_back(*Name++);
324
325 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_BLOCKNAME, Record);
326 }
327
328 /// Emits a record ID in the BLOCKINFO block.
329 static void EmitRecordID(unsigned ID, const char *Name,
330 llvm::BitstreamWriter &Stream,
331 RecordDataImpl &Record){
332 Record.clear();
333 Record.push_back(ID);
334
335 while (*Name)
336 Record.push_back(*Name++);
337
338 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETRECORDNAME, Record);
339 }
340
341 void SDiagsWriter::AddLocToRecord(FullSourceLoc Loc, PresumedLoc PLoc,
342 RecordDataImpl &Record, unsigned TokSize) {
343 if (PLoc.isInvalid()) {
344 // Emit a "sentinel" location.
345 Record.push_back((unsigned)0); // File.
346 Record.push_back((unsigned)0); // Line.
347 Record.push_back((unsigned)0); // Column.
348 Record.push_back((unsigned)0); // Offset.
349 return;
350 }
351
352 Record.push_back(getEmitFile(PLoc.getFilename()));
353 Record.push_back(PLoc.getLine());
354 Record.push_back(PLoc.getColumn()+TokSize);
355 Record.push_back(Loc.getFileOffset());
356 }
357
358 void SDiagsWriter::AddCharSourceRangeToRecord(CharSourceRange Range,
359 RecordDataImpl &Record,
360 const SourceManager &SM) {
361 AddLocToRecord(FullSourceLoc(Range.getBegin(), SM), Record);
362 unsigned TokSize = 0;
363 if (Range.isTokenRange())
364 TokSize = Lexer::MeasureTokenLength(Range.getEnd(),
365 SM, *LangOpts);
366
367 AddLocToRecord(FullSourceLoc(Range.getEnd(), SM), Record, TokSize);
368 }
369
370 unsigned SDiagsWriter::getEmitFile(const char *FileName){
371 if (!FileName)
372 return 0;
373
374 unsigned &entry = State->Files[FileName];
375 if (entry)
376 return entry;
377
378 // Lazily generate the record for the file.
379 entry = State->Files.size();
380 StringRef Name(FileName);
381 RecordData::value_type Record[] = {RECORD_FILENAME, entry, 0 /* For legacy */,
382 0 /* For legacy */, Name.size()};
383 State->Stream.EmitRecordWithBlob(State->Abbrevs.get(RECORD_FILENAME), Record,
384 Name);
385
386 return entry;
387 }
388
389 void SDiagsWriter::EmitCharSourceRange(CharSourceRange R,
390 const SourceManager &SM) {
391 State->Record.clear();
392 State->Record.push_back(RECORD_SOURCE_RANGE);
393 AddCharSourceRangeToRecord(R, State->Record, SM);
394 State->Stream.EmitRecordWithAbbrev(State->Abbrevs.get(RECORD_SOURCE_RANGE),
395 State->Record);
396 }
397
398 /// Emits the preamble of the diagnostics file.
399 void SDiagsWriter::EmitPreamble() {
400 // Emit the file header.
401 State->Stream.Emit((unsigned)'D', 8);
402 State->Stream.Emit((unsigned)'I', 8);
403 State->Stream.Emit((unsigned)'A', 8);
404 State->Stream.Emit((unsigned)'G', 8);
405
406 EmitBlockInfoBlock();
407 EmitMetaBlock();
408 }
409
410 static void AddSourceLocationAbbrev(llvm::BitCodeAbbrev &Abbrev) {
411 using namespace llvm;
412 Abbrev.Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // File ID.
413 Abbrev.Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Line.
414 Abbrev.Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Column.
415 Abbrev.Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Offset;
416 }
417
418 static void AddRangeLocationAbbrev(llvm::BitCodeAbbrev &Abbrev) {
419 AddSourceLocationAbbrev(Abbrev);
420 AddSourceLocationAbbrev(Abbrev);
421 }
422
423 void SDiagsWriter::EmitBlockInfoBlock() {
424 State->Stream.EnterBlockInfoBlock();
425
426 using namespace llvm;
427 llvm::BitstreamWriter &Stream = State->Stream;
428 RecordData &Record = State->Record;
429 AbbreviationMap &Abbrevs = State->Abbrevs;
430
431 // ==---------------------------------------------------------------------==//
432 // The subsequent records and Abbrevs are for the "Meta" block.
433 // ==---------------------------------------------------------------------==//
434
435 EmitBlockID(BLOCK_META, "Meta", Stream, Record);
436 EmitRecordID(RECORD_VERSION, "Version", Stream, Record);
437 auto Abbrev = std::make_shared<BitCodeAbbrev>();
438 Abbrev->Add(BitCodeAbbrevOp(RECORD_VERSION));
439 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
440 Abbrevs.set(RECORD_VERSION, Stream.EmitBlockInfoAbbrev(BLOCK_META, Abbrev));
441
442 // ==---------------------------------------------------------------------==//
443 // The subsequent records and Abbrevs are for the "Diagnostic" block.
444 // ==---------------------------------------------------------------------==//
445
446 EmitBlockID(BLOCK_DIAG, "Diag", Stream, Record);
447 EmitRecordID(RECORD_DIAG, "DiagInfo", Stream, Record);
448 EmitRecordID(RECORD_SOURCE_RANGE, "SrcRange", Stream, Record);
449 EmitRecordID(RECORD_CATEGORY, "CatName", Stream, Record);
450 EmitRecordID(RECORD_DIAG_FLAG, "DiagFlag", Stream, Record);
451 EmitRecordID(RECORD_FILENAME, "FileName", Stream, Record);
452 EmitRecordID(RECORD_FIXIT, "FixIt", Stream, Record);
453
454 // Emit abbreviation for RECORD_DIAG.
455 Abbrev = std::make_shared<BitCodeAbbrev>();
456 Abbrev->Add(BitCodeAbbrevOp(RECORD_DIAG));
457 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // Diag level.
458 AddSourceLocationAbbrev(*Abbrev);
459 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Category.
460 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Mapped Diag ID.
461 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // Text size.
462 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Diagnostc text.
463 Abbrevs.set(RECORD_DIAG, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev));
464
465 // Emit abbreviation for RECORD_CATEGORY.
466 Abbrev = std::make_shared<BitCodeAbbrev>();
467 Abbrev->Add(BitCodeAbbrevOp(RECORD_CATEGORY));
468 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Category ID.
469 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8)); // Text size.
470 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Category text.
471 Abbrevs.set(RECORD_CATEGORY, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev));
472
473 // Emit abbreviation for RECORD_SOURCE_RANGE.
474 Abbrev = std::make_shared<BitCodeAbbrev>();
475 Abbrev->Add(BitCodeAbbrevOp(RECORD_SOURCE_RANGE));
476 AddRangeLocationAbbrev(*Abbrev);
477 Abbrevs.set(RECORD_SOURCE_RANGE,
478 Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev));
479
480 // Emit the abbreviation for RECORD_DIAG_FLAG.
481 Abbrev = std::make_shared<BitCodeAbbrev>();
482 Abbrev->Add(BitCodeAbbrevOp(RECORD_DIAG_FLAG));
483 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Mapped Diag ID.
484 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Text size.
485 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Flag name text.
486 Abbrevs.set(RECORD_DIAG_FLAG, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG,
487 Abbrev));
488
489 // Emit the abbreviation for RECORD_FILENAME.
490 Abbrev = std::make_shared<BitCodeAbbrev>();
491 Abbrev->Add(BitCodeAbbrevOp(RECORD_FILENAME));
492 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Mapped file ID.
493 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Size.
494 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Modification time.
495 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Text size.
496 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name text.
497 Abbrevs.set(RECORD_FILENAME, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG,
498 Abbrev));
499
500 // Emit the abbreviation for RECORD_FIXIT.
501 Abbrev = std::make_shared<BitCodeAbbrev>();
502 Abbrev->Add(BitCodeAbbrevOp(RECORD_FIXIT));
503 AddRangeLocationAbbrev(*Abbrev);
504 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Text size.
505 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // FixIt text.
506 Abbrevs.set(RECORD_FIXIT, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG,
507 Abbrev));
508
509 Stream.ExitBlock();
510 }
511
512 void SDiagsWriter::EmitMetaBlock() {
513 llvm::BitstreamWriter &Stream = State->Stream;
514 AbbreviationMap &Abbrevs = State->Abbrevs;
515
516 Stream.EnterSubblock(BLOCK_META, 3);
517 RecordData::value_type Record[] = {RECORD_VERSION, VersionNumber};
518 Stream.EmitRecordWithAbbrev(Abbrevs.get(RECORD_VERSION), Record);
519 Stream.ExitBlock();
520 }
521
522 unsigned SDiagsWriter::getEmitCategory(unsigned int category) {
523 if (!State->Categories.insert(category).second)
524 return category;
525
526 // We use a local version of 'Record' so that we can be generating
527 // another record when we lazily generate one for the category entry.
528 StringRef catName = DiagnosticIDs::getCategoryNameFromID(category);
529 RecordData::value_type Record[] = {RECORD_CATEGORY, category, catName.size()};
530 State->Stream.EmitRecordWithBlob(State->Abbrevs.get(RECORD_CATEGORY), Record,
531 catName);
532
533 return category;
534 }
535
536 unsigned SDiagsWriter::getEmitDiagnosticFlag(DiagnosticsEngine::Level DiagLevel,
537 unsigned DiagID) {
538 if (DiagLevel == DiagnosticsEngine::Note)
539 return 0; // No flag for notes.
540
541 StringRef FlagName = DiagnosticIDs::getWarningOptionForDiag(DiagID);
542 return getEmitDiagnosticFlag(FlagName);
543 }
544
545 unsigned SDiagsWriter::getEmitDiagnosticFlag(StringRef FlagName) {
546 if (FlagName.empty())
547 return 0;
548
549 // Here we assume that FlagName points to static data whose pointer
550 // value is fixed. This allows us to unique by diagnostic groups.
551 const void *data = FlagName.data();
552 std::pair<unsigned, StringRef> &entry = State->DiagFlags[data];
553 if (entry.first == 0) {
554 entry.first = State->DiagFlags.size();
555 entry.second = FlagName;
556
557 // Lazily emit the string in a separate record.
558 RecordData::value_type Record[] = {RECORD_DIAG_FLAG, entry.first,
559 FlagName.size()};
560 State->Stream.EmitRecordWithBlob(State->Abbrevs.get(RECORD_DIAG_FLAG),
561 Record, FlagName);
562 }
563
564 return entry.first;
565 }
566
567 void SDiagsWriter::HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
568 const Diagnostic &Info) {
569 // Enter the block for a non-note diagnostic immediately, rather than waiting
570 // for beginDiagnostic, in case associated notes are emitted before we get
571 // there.
572 if (DiagLevel != DiagnosticsEngine::Note) {
573 if (State->EmittedAnyDiagBlocks)
574 ExitDiagBlock();
575
576 EnterDiagBlock();
577 State->EmittedAnyDiagBlocks = true;
578 }
579
580 // Compute the diagnostic text.
581 State->diagBuf.clear();
582 Info.FormatDiagnostic(State->diagBuf);
583
584 if (Info.getLocation().isInvalid()) {
585 // Special-case diagnostics with no location. We may not have entered a
586 // source file in this case, so we can't use the normal DiagnosticsRenderer
587 // machinery.
588
589 // Make sure we bracket all notes as "sub-diagnostics". This matches
590 // the behavior in SDiagsRenderer::emitDiagnostic().
591 if (DiagLevel == DiagnosticsEngine::Note)
592 EnterDiagBlock();
593
594 EmitDiagnosticMessage(FullSourceLoc(), PresumedLoc(), DiagLevel,
595 State->diagBuf, &Info);
596
597 if (DiagLevel == DiagnosticsEngine::Note)
598 ExitDiagBlock();
599
600 return;
601 }
602
603 assert(Info.hasSourceManager() && LangOpts &&
604 "Unexpected diagnostic with valid location outside of a source file");
605 SDiagsRenderer Renderer(*this, *LangOpts, &*State->DiagOpts);
606 Renderer.emitDiagnostic(
607 FullSourceLoc(Info.getLocation(), Info.getSourceManager()), DiagLevel,
608 State->diagBuf, Info.getRanges(), Info.getFixItHints(), &Info);
609 }
610
611 static serialized_diags::Level getStableLevel(DiagnosticsEngine::Level Level) {
612 switch (Level) {
613 #define CASE(X) case DiagnosticsEngine::X: return serialized_diags::X;
614 CASE(Ignored)
615 CASE(Note)
616 CASE(Remark)
617 CASE(Warning)
618 CASE(Error)
619 CASE(Fatal)
620 #undef CASE
621 }
622
623 llvm_unreachable("invalid diagnostic level");
624 }
625
626 void SDiagsWriter::EmitDiagnosticMessage(FullSourceLoc Loc, PresumedLoc PLoc,
627 DiagnosticsEngine::Level Level,
628 StringRef Message,
629 DiagOrStoredDiag D) {
630 llvm::BitstreamWriter &Stream = State->Stream;
631 RecordData &Record = State->Record;
632 AbbreviationMap &Abbrevs = State->Abbrevs;
633
634 // Emit the RECORD_DIAG record.
635 Record.clear();
636 Record.push_back(RECORD_DIAG);
637 Record.push_back(getStableLevel(Level));
638 AddLocToRecord(Loc, PLoc, Record);
639
640 if (const Diagnostic *Info = D.dyn_cast<const Diagnostic*>()) {
641 // Emit the category string lazily and get the category ID.
642 unsigned DiagID = DiagnosticIDs::getCategoryNumberForDiag(Info->getID());
643 Record.push_back(getEmitCategory(DiagID));
644 // Emit the diagnostic flag string lazily and get the mapped ID.
645 Record.push_back(getEmitDiagnosticFlag(Level, Info->getID()));
646 } else {
647 Record.push_back(getEmitCategory());
648 Record.push_back(getEmitDiagnosticFlag(Level));
649 }
650
651 Record.push_back(Message.size());
652 Stream.EmitRecordWithBlob(Abbrevs.get(RECORD_DIAG), Record, Message);
653 }
654
655 void SDiagsRenderer::emitDiagnosticMessage(
656 FullSourceLoc Loc, PresumedLoc PLoc, DiagnosticsEngine::Level Level,
657 StringRef Message, ArrayRef<clang::CharSourceRange> Ranges,
658 DiagOrStoredDiag D) {
659 Writer.EmitDiagnosticMessage(Loc, PLoc, Level, Message, D);
660 }
661
662 void SDiagsWriter::EnterDiagBlock() {
663 State->Stream.EnterSubblock(BLOCK_DIAG, 4);
664 }
665
666 void SDiagsWriter::ExitDiagBlock() {
667 State->Stream.ExitBlock();
668 }
669
670 void SDiagsRenderer::beginDiagnostic(DiagOrStoredDiag D,
671 DiagnosticsEngine::Level Level) {
672 if (Level == DiagnosticsEngine::Note)
673 Writer.EnterDiagBlock();
674 }
675
676 void SDiagsRenderer::endDiagnostic(DiagOrStoredDiag D,
677 DiagnosticsEngine::Level Level) {
678 // Only end note diagnostics here, because we can't be sure when we've seen
679 // the last note associated with a non-note diagnostic.
680 if (Level == DiagnosticsEngine::Note)
681 Writer.ExitDiagBlock();
682 }
683
684 void SDiagsWriter::EmitCodeContext(SmallVectorImpl<CharSourceRange> &Ranges,
685 ArrayRef<FixItHint> Hints,
686 const SourceManager &SM) {
687 llvm::BitstreamWriter &Stream = State->Stream;
688 RecordData &Record = State->Record;
689 AbbreviationMap &Abbrevs = State->Abbrevs;
690
691 // Emit Source Ranges.
692 for (ArrayRef<CharSourceRange>::iterator I = Ranges.begin(), E = Ranges.end();
693 I != E; ++I)
694 if (I->isValid())
695 EmitCharSourceRange(*I, SM);
696
697 // Emit FixIts.
698 for (ArrayRef<FixItHint>::iterator I = Hints.begin(), E = Hints.end();
699 I != E; ++I) {
700 const FixItHint &Fix = *I;
701 if (Fix.isNull())
702 continue;
703 Record.clear();
704 Record.push_back(RECORD_FIXIT);
705 AddCharSourceRangeToRecord(Fix.RemoveRange, Record, SM);
706 Record.push_back(Fix.CodeToInsert.size());
707 Stream.EmitRecordWithBlob(Abbrevs.get(RECORD_FIXIT), Record,
708 Fix.CodeToInsert);
709 }
710 }
711
712 void SDiagsRenderer::emitCodeContext(FullSourceLoc Loc,
713 DiagnosticsEngine::Level Level,
714 SmallVectorImpl<CharSourceRange> &Ranges,
715 ArrayRef<FixItHint> Hints) {
716 Writer.EmitCodeContext(Ranges, Hints, Loc.getManager());
717 }
718
719 void SDiagsRenderer::emitNote(FullSourceLoc Loc, StringRef Message) {
720 Writer.EnterDiagBlock();
721 PresumedLoc PLoc = Loc.hasManager() ? Loc.getPresumedLoc() : PresumedLoc();
722 Writer.EmitDiagnosticMessage(Loc, PLoc, DiagnosticsEngine::Note, Message,
723 DiagOrStoredDiag());
724 Writer.ExitDiagBlock();
725 }
726
727 DiagnosticsEngine *SDiagsWriter::getMetaDiags() {
728 // FIXME: It's slightly absurd to create a new diagnostics engine here, but
729 // the other options that are available today are worse:
730 //
731 // 1. Teach DiagnosticsConsumers to emit diagnostics to the engine they are a
732 // part of. The DiagnosticsEngine would need to know not to send
733 // diagnostics back to the consumer that failed. This would require us to
734 // rework ChainedDiagnosticsConsumer and teach the engine about multiple
735 // consumers, which is difficult today because most APIs interface with
736 // consumers rather than the engine itself.
737 //
738 // 2. Pass a DiagnosticsEngine to SDiagsWriter on creation - this would need
739 // to be distinct from the engine the writer was being added to and would
740 // normally not be used.
741 if (!State->MetaDiagnostics) {
742 IntrusiveRefCntPtr<DiagnosticIDs> IDs(new DiagnosticIDs());
743 auto Client =
744 new TextDiagnosticPrinter(llvm::errs(), State->DiagOpts.get());
745 State->MetaDiagnostics = llvm::make_unique<DiagnosticsEngine>(
746 IDs, State->DiagOpts.get(), Client);
747 }
748 return State->MetaDiagnostics.get();
749 }
750
751 void SDiagsWriter::RemoveOldDiagnostics() {
752 if (!llvm::sys::fs::remove(State->OutputFile))
753 return;
754
755 getMetaDiags()->Report(diag::warn_fe_serialized_diag_merge_failure);
756 // Disable merging child records, as whatever is in this file may be
757 // misleading.
758 MergeChildRecords = false;
759 }
760
761 void SDiagsWriter::finish() {
762 // The original instance is responsible for writing the file.
763 if (!OriginalInstance)
764 return;
765
766 // Finish off any diagnostic we were in the process of emitting.
767 if (State->EmittedAnyDiagBlocks)
768 ExitDiagBlock();
769
770 if (MergeChildRecords) {
771 if (!State->EmittedAnyDiagBlocks)
772 // We have no diagnostics of our own, so we can just leave the child
773 // process' output alone
774 return;
775
776 if (llvm::sys::fs::exists(State->OutputFile))
777 if (SDiagsMerger(*this).mergeRecordsFromFile(State->OutputFile.c_str()))
778 getMetaDiags()->Report(diag::warn_fe_serialized_diag_merge_failure);
779 }
780
781 std::error_code EC;
782 auto OS = llvm::make_unique<llvm::raw_fd_ostream>(State->OutputFile.c_str(),
783 EC, llvm::sys::fs::F_None);
784 if (EC) {
785 getMetaDiags()->Report(diag::warn_fe_serialized_diag_failure)
786 << State->OutputFile << EC.message();
787 return;
788 }
789
790 // Write the generated bitstream to "Out".
791 OS->write((char *)&State->Buffer.front(), State->Buffer.size());
792 OS->flush();
793 }
794
795 std::error_code SDiagsMerger::visitStartOfDiagnostic() {
796 Writer.EnterDiagBlock();
797 return std::error_code();
798 }
799
800 std::error_code SDiagsMerger::visitEndOfDiagnostic() {
801 Writer.ExitDiagBlock();
802 return std::error_code();
803 }
804
805 std::error_code
806 SDiagsMerger::visitSourceRangeRecord(const serialized_diags::Location &Start,
807 const serialized_diags::Location &End) {
808 RecordData::value_type Record[] = {
809 RECORD_SOURCE_RANGE, FileLookup[Start.FileID], Start.Line, Start.Col,
810 Start.Offset, FileLookup[End.FileID], End.Line, End.Col, End.Offset};
811 Writer.State->Stream.EmitRecordWithAbbrev(
812 Writer.State->Abbrevs.get(RECORD_SOURCE_RANGE), Record);
813 return std::error_code();
814 }
815
816 std::error_code SDiagsMerger::visitDiagnosticRecord(
817 unsigned Severity, const serialized_diags::Location &Location,
818 unsigned Category, unsigned Flag, StringRef Message) {
819 RecordData::value_type Record[] = {
820 RECORD_DIAG, Severity, FileLookup[Location.FileID], Location.Line,
821 Location.Col, Location.Offset, CategoryLookup[Category],
822 Flag ? DiagFlagLookup[Flag] : 0, Message.size()};
823
824 Writer.State->Stream.EmitRecordWithBlob(
825 Writer.State->Abbrevs.get(RECORD_DIAG), Record, Message);
826 return std::error_code();
827 }
828
829 std::error_code
830 SDiagsMerger::visitFixitRecord(const serialized_diags::Location &Start,
831 const serialized_diags::Location &End,
832 StringRef Text) {
833 RecordData::value_type Record[] = {RECORD_FIXIT, FileLookup[Start.FileID],
834 Start.Line, Start.Col, Start.Offset,
835 FileLookup[End.FileID], End.Line, End.Col,
836 End.Offset, Text.size()};
837
838 Writer.State->Stream.EmitRecordWithBlob(
839 Writer.State->Abbrevs.get(RECORD_FIXIT), Record, Text);
840 return std::error_code();
841 }
842
843 std::error_code SDiagsMerger::visitFilenameRecord(unsigned ID, unsigned Size,
844 unsigned Timestamp,
845 StringRef Name) {
846 FileLookup[ID] = Writer.getEmitFile(Name.str().c_str());
847 return std::error_code();
848 }
849
850 std::error_code SDiagsMerger::visitCategoryRecord(unsigned ID, StringRef Name) {
851 CategoryLookup[ID] = Writer.getEmitCategory(ID);
852 return std::error_code();
853 }
854
855 std::error_code SDiagsMerger::visitDiagFlagRecord(unsigned ID, StringRef Name) {
856 DiagFlagLookup[ID] = Writer.getEmitDiagnosticFlag(Name);
857 return std::error_code();
858 }
clang::DiagnosticIDs::getCategoryNumberForDiag
static unsigned getCategoryNumberForDiag(unsigned DiagID)
Return the category number that a specified DiagID belongs to, or 0 if no category.
Definition: DiagnosticIDs.cpp:192
clang::Builtin::ID
ID
Definition: Builtins.h:49
getStableLevel
static serialized_diags::Level getStableLevel(DiagnosticsEngine::Level Level)
Definition: SerializedDiagnosticPrinter.cpp:611
llvm
DominatorTree GraphTraits specialization so the DominatorTree can be iterable by generic graph iterat...
Definition: Dominators.h:30
clang::serialized_diags::Location::Line
unsigned Line
Definition: SerializedDiagnosticReader.h:49
SourceManager.h
Defines the SourceManager interface.
SerializedDiagnostics.h
clang::serialized_diags::Level
Level
A stable version of DiagnosticIDs::Level.
Definition: SerializedDiagnostics.h:44
llvm::DenseSet< unsigned >
clang::DiagOrStoredDiag
llvm::PointerUnion< const Diagnostic *, const StoredDiagnostic * > DiagOrStoredDiag
Definition: DiagnosticRenderer.h:34
clang::FixItHint::CodeToInsert
std::string CodeToInsert
The actual code to insert at the insertion location, as a string.
Definition: Diagnostic.h:78
clang::DiagnosticIDs::getCategoryNameFromID
static StringRef getCategoryNameFromID(unsigned CategoryID)
Given a category ID, return the name of the category.
Definition: DiagnosticIDs.cpp:241
AddSourceLocationAbbrev
static void AddSourceLocationAbbrev(llvm::BitCodeAbbrev &Abbrev)
Definition: SerializedDiagnosticPrinter.cpp:410
clang::diag::Severity
Severity
Enum values that allow the client to map NOTEs, WARNINGs, and EXTENSIONs to either Ignore (nothing)...
Definition: DiagnosticIDs.h:80
clang::DiagnosticConsumer
Abstract interface, implemented by clients of the front-end, which formats and prints fully processed...
Definition: Diagnostic.h:1488
clang::Diagnostic::hasSourceManager
bool hasSourceManager() const
Definition: Diagnostic.h:1328
SerializedDiagnosticReader.h
clang::serialized_diags::RECORD_FIXIT
Definition: SerializedDiagnostics.h:35
clang::Diagnostic::getID
unsigned getID() const
Definition: Diagnostic.h:1326
clang::CharSourceRange::getBegin
SourceLocation getBegin() const
Definition: SourceLocation.h:266
State
LineState State
Definition: UnwrappedLineFormatter.cpp:877
std
Definition: Format.h:2072
clang::DiagnosticsEngine::Note
Definition: Diagnostic.h:154
clang::serialized_diags::RECORD_CATEGORY
Definition: SerializedDiagnostics.h:33
Category
int Category
Definition: Format.cpp:1632
clang::FixItHint::isNull
bool isNull() const
Definition: Diagnostic.h:86
clang::LangOptions
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:50
llvm::SmallVectorImpl
Definition: LLVM.h:37
clang::serialized_diags::Error
Definition: SerializedDiagnostics.h:48
clang::serialized_diags::RECORD_DIAG_FLAG
Definition: SerializedDiagnostics.h:32
DiagnosticRenderer.h
clang::Diagnostic::getLocation
const SourceLocation & getLocation() const
Definition: Diagnostic.h:1327
clang::DiagnosticsEngine
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:149
Diagnostic.h
Defines the Diagnostic-related interfaces.
clang::FullSourceLoc::getPresumedLoc
PresumedLoc getPresumedLoc(bool UseLineDirectives=true) const
Definition: SourceLocation.cpp:161
clang::serialized_diags::Warning
Definition: SerializedDiagnostics.h:47
EmitRecordID
static void EmitRecordID(unsigned ID, const char *Name, llvm::BitstreamWriter &Stream, RecordDataImpl &Record)
Emits a record ID in the BLOCKINFO block.
Definition: SerializedDiagnosticPrinter.cpp:329
llvm::ArrayRef
Definition: LLVM.h:32
llvm::SmallString
Definition: LLVM.h:35
FrontendDiagnostic.h
clang::serialized_diags::Fatal
Definition: SerializedDiagnostics.h:49
llvm::str
return Out str()
CASE
#define CASE(X)
Filename
StringRef Filename
Definition: Format.cpp:1629
clang::serialized_diags
Definition: SerializedDiagnosticPrinter.h:26
clang::FullSourceLoc::hasManager
bool hasManager() const
Definition: SourceLocation.h:350
End
SourceLocation End
Definition: USRLocFinder.cpp:167
clang::CharSourceRange
Represents a character-granular source range.
Definition: SourceLocation.h:236
clang::PresumedLoc::isInvalid
bool isInvalid() const
Return true if this object is invalid or uninitialized.
Definition: SourceLocation.h:299
clang::Lexer::MeasureTokenLength
static unsigned MeasureTokenLength(SourceLocation Loc, const SourceManager &SM, const LangOptions &LangOpts)
MeasureTokenLength - Relex the token at the specified location and return its length in bytes in the ...
Definition: Lexer.cpp:436
clang::PresumedLoc::getLine
unsigned getLine() const
Return the presumed line number of this location.
Definition: SourceLocation.h:313
EmitBlockID
static void EmitBlockID(unsigned ID, const char *Name, llvm::BitstreamWriter &Stream, RecordDataImpl &Record)
Emits a block ID in the BLOCKINFO block.
Definition: SerializedDiagnosticPrinter.cpp:309
clang::FullSourceLoc::getManager
const SourceManager & getManager() const
Definition: SourceLocation.h:357
Lexer.h
clang::DiagnosticIDs::getWarningOptionForDiag
static StringRef getWarningOptionForDiag(unsigned DiagID)
Return the lowest-level warning option that enables the specified diagnostic.
Definition: DiagnosticIDs.cpp:523
clang::serialized_diags::RECORD_SOURCE_RANGE
Definition: SerializedDiagnostics.h:31
clang::PresumedLoc
Represents an unpacked "presumed" location which can be presented to the user.
Definition: SourceLocation.h:285
SM
const SourceManager & SM
Definition: Format.cpp:1490
clang::PresumedLoc::getFilename
const char * getFilename() const
Return the presumed filename of this location.
Definition: SourceLocation.h:305
clang::FixItHint::RemoveRange
CharSourceRange RemoveRange
Code that should be replaced to correct the error.
Definition: Diagnostic.h:70
false
#define false
Definition: stdbool.h:33
llvm::IntrusiveRefCntPtr
Definition: LLVM.h:45
clang::PresumedLoc::getColumn
unsigned getColumn() const
Return the presumed column number of this location.
Definition: SourceLocation.h:321
clang::DiagnosticNoteRenderer
Subclass of DiagnosticRender that turns all subdiagostics into explicit notes.
Definition: DiagnosticRenderer.h:143
clang::DiagnosticOptions
Options for controlling the compiler diagnostics engine.
Definition: DiagnosticOptions.h:64
clang::FullSourceLoc::getFileOffset
unsigned getFileOffset() const
Definition: SourceLocation.cpp:188
llvm::SmallVector
Definition: LLVM.h:36
clang::serialized_diags::RECORD_DIAG
Definition: SerializedDiagnostics.h:30
clang::Diagnostic::getSourceManager
SourceManager & getSourceManager() const
Definition: Diagnostic.h:1329
clang::serialized_diags::Ignored
Definition: SerializedDiagnostics.h:45
clang::CharSourceRange::isTokenRange
bool isTokenRange() const
Return true if the end of this range specifies the start of the last token.
Definition: SourceLocation.h:263
clang
Dataflow Directional Tag Classes.
Definition: CFGReachabilityAnalysis.h:22
clang::serialized_diags::SerializedDiagnosticReader
A base class that handles reading serialized diagnostics from a file.
Definition: SerializedDiagnosticReader.h:61
clang::TextDiagnosticPrinter
Definition: TextDiagnosticPrinter.h:28
clang::serialized_diags::Location
A location that is represented in the serialized diagnostics.
Definition: SerializedDiagnosticReader.h:47
clang::serialized_diags::create
std::unique_ptr< DiagnosticConsumer > create(StringRef OutputFile, DiagnosticOptions *Diags, bool MergeChildRecords=false)
Returns a DiagnosticConsumer that serializes diagnostics to a bitcode file.
Definition: SerializedDiagnosticPrinter.cpp:297
clang::DiagnosticIDs
Used for handling and querying diagnostic IDs.
Definition: DiagnosticIDs.h:164
clang::serialized_diags::Location::Col
unsigned Col
Definition: SerializedDiagnosticReader.h:50
TextDiagnosticPrinter.h
AddRangeLocationAbbrev
static void AddRangeLocationAbbrev(llvm::BitCodeAbbrev &Abbrev)
Definition: SerializedDiagnosticPrinter.cpp:418
clang::serialized_diags::Location::FileID
unsigned FileID
Definition: SerializedDiagnosticReader.h:48
clang::CharSourceRange::getEnd
SourceLocation getEnd() const
Definition: SourceLocation.h:267
clang::Diagnostic::getRanges
ArrayRef< CharSourceRange > getRanges() const
Return an array reference for this diagnostic&#39;s ranges.
Definition: Diagnostic.h:1404
clang::serialized_diags::Remark
Definition: SerializedDiagnostics.h:50
clang::Diagnostic::getFixItHints
ArrayRef< FixItHint > getFixItHints() const
Definition: Diagnostic.h:1417
clang::SourceLocation::isInvalid
bool isInvalid() const
Definition: SourceLocation.h:109
clang::DiagnosticsEngine::Level
Level
The level of the diagnostic, after it has been through mapping.
Definition: Diagnostic.h:152
clang::serialized_diags::Location::Offset
unsigned Offset
Definition: SerializedDiagnosticReader.h:51
clang::Diagnostic
A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine) ...
Definition: Diagnostic.h:1316
clang::FullSourceLoc
A SourceLocation and its associated SourceManager.
Definition: SourceLocation.h:340
DiagnosticOptions.h
clang::serialized_diags::VersionNumber
Definition: SerializedDiagnostics.h:54
clang::serialized_diags::RECORD_VERSION
Definition: SerializedDiagnostics.h:29
clang::serialized_diags::Note
Definition: SerializedDiagnostics.h:46
SerializedDiagnosticPrinter.h
clang::serialized_diags::BLOCK_DIAG
The this block acts as a container for all the information for a specific diagnostic.
Definition: SerializedDiagnostics.h:25
clang::FixItHint
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
Definition: Diagnostic.h:66
Text
StringRef Text
Definition: Format.cpp:1630
true
#define true
Definition: stdbool.h:32
clang::serialized_diags::BLOCK_META
A top-level block which represents any meta data associated with the diagostics, including versioning...
Definition: SerializedDiagnostics.h:21
clang::serialized_diags::RECORD_FILENAME
Definition: SerializedDiagnostics.h:34
clang::Diagnostic::FormatDiagnostic
void FormatDiagnostic(SmallVectorImpl< char > &OutStr) const
Format this diagnostic into a string, substituting the formal arguments into the %0 slots...
Definition: Diagnostic.cpp:764
clang::SourceManager
This class handles loading and caching of source files into memory.
Definition: SourceManager.h:582
clang::Preprocessor
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:125