contrib/llvm/tools/clang/lib/Frontend/SerializedDiagnosticPrinter.cpp

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