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