tools/libclang/CXLoadedDiagnostic.cpp

   1 /*===-- CXLoadedDiagnostic.cpp - Handling of persisent diags -*- C++ -*-===*\
   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 |* Implements handling of persisent diagnostics.                              *|
  11 |*                                                                            *|
  12 \*===----------------------------------------------------------------------===*/
  13
  14 #include "CXLoadedDiagnostic.h"
  15 #include "CXString.h"
  16 #include "clang/Basic/Diagnostic.h"
  17 #include "clang/Basic/FileManager.h"
  18 #include "clang/Frontend/SerializedDiagnosticPrinter.h"
  19 #include "llvm/ADT/StringRef.h"
  20 #include "llvm/ADT/Twine.h"
  21 #include "llvm/ADT/Optional.h"
  22 #include "clang/Basic/LLVM.h"
  23 #include "llvm/Support/ErrorHandling.h"
  24 #include "llvm/Bitcode/BitstreamReader.h"
  25 #include "llvm/Support/MemoryBuffer.h"
  26 #include <assert.h>
  27
  28 using namespace clang;
  29 using namespace clang::cxstring;
  30
  31 //===----------------------------------------------------------------------===//
  32 // Extend CXDiagnosticSetImpl which contains strings for diagnostics.
  33 //===----------------------------------------------------------------------===//
  34
  35 typedef llvm::DenseMap<unsigned, llvm::StringRef> Strings;
  36
  37 namespace {
  38 class CXLoadedDiagnosticSetImpl : public CXDiagnosticSetImpl {
  39 public:
  40   CXLoadedDiagnosticSetImpl() : CXDiagnosticSetImpl(true), FakeFiles(FO) {}
  41   virtual ~CXLoadedDiagnosticSetImpl() {}
  42
  43   llvm::StringRef makeString(const char *blob, unsigned blobLen);
  44
  45   llvm::BumpPtrAllocator Alloc;
  46   Strings Categories;
  47   Strings WarningFlags;
  48   Strings FileNames;
  49
  50   FileSystemOptions FO;
  51   FileManager FakeFiles;
  52   llvm::DenseMap<unsigned, const FileEntry *> Files;
  53 };
  54 }
  55
  56 llvm::StringRef CXLoadedDiagnosticSetImpl::makeString(const char *blob,
  57                                                       unsigned bloblen) {
  58   char *mem = Alloc.Allocate<char>(bloblen + 1);
  59   memcpy(mem, blob, bloblen);
  60   // Add a null terminator for those clients accessing the buffer
  61   // like a c-string.
  62   mem[bloblen] = '\0';
  63   return llvm::StringRef(mem, bloblen);
  64 }
  65
  66 //===----------------------------------------------------------------------===//
  67 // Cleanup.
  68 //===----------------------------------------------------------------------===//
  69
  70 CXLoadedDiagnostic::~CXLoadedDiagnostic() {}
  71
  72 //===----------------------------------------------------------------------===//
  73 // Public CXLoadedDiagnostic methods.
  74 //===----------------------------------------------------------------------===//
  75
  76 CXDiagnosticSeverity CXLoadedDiagnostic::getSeverity() const {
  77   // FIXME: possibly refactor with logic in CXStoredDiagnostic.
  78   switch (severity) {
  79     case DiagnosticsEngine::Ignored: return CXDiagnostic_Ignored;
  80     case DiagnosticsEngine::Note:    return CXDiagnostic_Note;
  81     case DiagnosticsEngine::Warning: return CXDiagnostic_Warning;
  82     case DiagnosticsEngine::Error:   return CXDiagnostic_Error;
  83     case DiagnosticsEngine::Fatal:   return CXDiagnostic_Fatal;
  84   }
  85
  86   llvm_unreachable("Invalid diagnostic level");
  87 }
  88
  89 static CXSourceLocation makeLocation(const CXLoadedDiagnostic::Location *DLoc) {
  90   // The lowest bit of ptr_data[0] is always set to 1 to indicate this
  91   // is a persistent diagnostic.
  92   uintptr_t V = (uintptr_t) DLoc;
  93   V |= 0x1;
  94   CXSourceLocation Loc = { {  (void*) V, 0 }, 0 };
  95   return Loc;
  96 }
  97
  98 CXSourceLocation CXLoadedDiagnostic::getLocation() const {
  99   // The lowest bit of ptr_data[0] is always set to 1 to indicate this
 100   // is a persistent diagnostic.
 101   return makeLocation(&DiagLoc);
 102 }
 103
 104 CXString CXLoadedDiagnostic::getSpelling() const {
 105   return cxstring::createCXString(Spelling, false);
 106 }
 107
 108 CXString CXLoadedDiagnostic::getDiagnosticOption(CXString *Disable) const {
 109   if (DiagOption.empty())
 110     return createCXString("");
 111
 112   // FIXME: possibly refactor with logic in CXStoredDiagnostic.
 113   if (Disable)
 114     *Disable = createCXString((Twine("-Wno-") + DiagOption).str());
 115   return createCXString((Twine("-W") + DiagOption).str());
 116 }
 117
 118 unsigned CXLoadedDiagnostic::getCategory() const {
 119   return category;
 120 }
 121
 122 CXString CXLoadedDiagnostic::getCategoryText() const {
 123   return cxstring::createCXString(CategoryText);
 124 }
 125
 126 unsigned CXLoadedDiagnostic::getNumRanges() const {
 127   return Ranges.size();
 128 }
 129
 130 CXSourceRange CXLoadedDiagnostic::getRange(unsigned Range) const {
 131   assert(Range < Ranges.size());
 132   return Ranges[Range];
 133 }
 134
 135 unsigned CXLoadedDiagnostic::getNumFixIts() const {
 136   return FixIts.size();
 137 }
 138
 139 CXString CXLoadedDiagnostic::getFixIt(unsigned FixIt,
 140                                       CXSourceRange *ReplacementRange) const {
 141   assert(FixIt < FixIts.size());
 142   if (ReplacementRange)
 143     *ReplacementRange = FixIts[FixIt].first;
 144   return FixIts[FixIt].second;
 145 }
 146
 147 void CXLoadedDiagnostic::decodeLocation(CXSourceLocation location,
 148                                         CXFile *file,
 149                                         unsigned int *line,
 150                                         unsigned int *column,
 151                                         unsigned int *offset) {
 152
 153
 154   // CXSourceLocation consists of the following fields:
 155   //
 156   //   void *ptr_data[2];
 157   //   unsigned int_data;
 158   //
 159   // The lowest bit of ptr_data[0] is always set to 1 to indicate this
 160   // is a persistent diagnostic.
 161   //
 162   // For now, do the unoptimized approach and store the data in a side
 163   // data structure.  We can optimize this case later.
 164
 165   uintptr_t V = (uintptr_t) location.ptr_data[0];
 166   assert((V & 0x1) == 1);
 167   V &= ~(uintptr_t)1;
 168
 169   const Location &Loc = *((Location*)V);
 170
 171   if (file)
 172     *file = Loc.file;
 173   if (line)
 174     *line = Loc.line;
 175   if (column)
 176     *column = Loc.column;
 177   if (offset)
 178     *offset = Loc.offset;
 179 }
 180
 181 //===----------------------------------------------------------------------===//
 182 // Deserialize diagnostics.
 183 //===----------------------------------------------------------------------===//
 184
 185 enum { MaxSupportedVersion = 1 };
 186 typedef SmallVector<uint64_t, 64> RecordData;
 187 enum LoadResult { Failure = 1, Success = 0 };
 188 enum StreamResult { Read_EndOfStream,
 189                     Read_BlockBegin,
 190                     Read_Failure,
 191                     Read_Record,
 192                     Read_BlockEnd };
 193
 194 namespace {
 195 class DiagLoader {
 196   enum CXLoadDiag_Error *error;
 197   CXString *errorString;
 198
 199   void reportBad(enum CXLoadDiag_Error code, llvm::StringRef err) {
 200     if (error)
 201       *error = code;
 202     if (errorString)
 203       *errorString = createCXString(err);
 204   }
 205
 206   void reportInvalidFile(llvm::StringRef err) {
 207     return reportBad(CXLoadDiag_InvalidFile, err);
 208   }
 209
 210   LoadResult readMetaBlock(llvm::BitstreamCursor &Stream);
 211
 212   LoadResult readDiagnosticBlock(llvm::BitstreamCursor &Stream,
 213                                  CXDiagnosticSetImpl &Diags,
 214                                  CXLoadedDiagnosticSetImpl &TopDiags);
 215
 216   StreamResult readToNextRecordOrBlock(llvm::BitstreamCursor &Stream,
 217                                        llvm::StringRef errorContext,
 218                                        unsigned &BlockOrRecordID,
 219                                        const bool atTopLevel = false);
 220
 221
 222   LoadResult readString(CXLoadedDiagnosticSetImpl &TopDiags,
 223                         Strings &strings, llvm::StringRef errorContext,
 224                         RecordData &Record,
 225                         const char *BlobStart,
 226                         unsigned BlobLen,
 227                         bool allowEmptyString = false);
 228
 229   LoadResult readString(CXLoadedDiagnosticSetImpl &TopDiags,
 230                         llvm::StringRef &RetStr,
 231                         llvm::StringRef errorContext,
 232                         RecordData &Record,
 233                         const char *BlobStart,
 234                         unsigned BlobLen,
 235                         bool allowEmptyString = false);
 236
 237   LoadResult readRange(CXLoadedDiagnosticSetImpl &TopDiags,
 238                        RecordData &Record, unsigned RecStartIdx,
 239                        CXSourceRange &SR);
 240
 241   LoadResult readLocation(CXLoadedDiagnosticSetImpl &TopDiags,
 242                           RecordData &Record, unsigned &offset,
 243                           CXLoadedDiagnostic::Location &Loc);
 244
 245 public:
 246   DiagLoader(enum CXLoadDiag_Error *e, CXString *es)
 247     : error(e), errorString(es) {
 248       if (error)
 249         *error = CXLoadDiag_None;
 250       if (errorString)
 251         *errorString = createCXString("");
 252     }
 253
 254   CXDiagnosticSet load(const char *file);
 255 };
 256 }
 257
 258 CXDiagnosticSet DiagLoader::load(const char *file) {
 259   // Open the diagnostics file.
 260   std::string ErrStr;
 261   FileSystemOptions FO;
 262   FileManager FileMgr(FO);
 263
 264   OwningPtr<llvm::MemoryBuffer> Buffer;
 265   Buffer.reset(FileMgr.getBufferForFile(file));
 266
 267   if (!Buffer) {
 268     reportBad(CXLoadDiag_CannotLoad, ErrStr);
 269     return 0;
 270   }
 271
 272   llvm::BitstreamReader StreamFile;
 273   StreamFile.init((const unsigned char *)Buffer->getBufferStart(),
 274                   (const unsigned char *)Buffer->getBufferEnd());
 275
 276   llvm::BitstreamCursor Stream;
 277   Stream.init(StreamFile);
 278
 279   // Sniff for the signature.
 280   if (Stream.Read(8) != 'D' ||
 281       Stream.Read(8) != 'I' ||
 282       Stream.Read(8) != 'A' ||
 283       Stream.Read(8) != 'G') {
 284     reportBad(CXLoadDiag_InvalidFile,
 285               "Bad header in diagnostics file");
 286     return 0;
 287   }
 288
 289   OwningPtr<CXLoadedDiagnosticSetImpl>
 290     Diags(new CXLoadedDiagnosticSetImpl());
 291
 292   while (true) {
 293     unsigned BlockID = 0;
 294     StreamResult Res = readToNextRecordOrBlock(Stream, "Top-level",
 295                                                BlockID, true);
 296     switch (Res) {
 297       case Read_EndOfStream:
 298         return (CXDiagnosticSet) Diags.take();
 299       case Read_Failure:
 300         return 0;
 301       case Read_Record:
 302         llvm_unreachable("Top-level does not have records");
 303       case Read_BlockEnd:
 304         continue;
 305       case Read_BlockBegin:
 306         break;
 307     }
 308
 309     switch (BlockID) {
 310       case serialized_diags::BLOCK_META:
 311         if (readMetaBlock(Stream))
 312           return 0;
 313         break;
 314       case serialized_diags::BLOCK_DIAG:
 315         if (readDiagnosticBlock(Stream, *Diags.get(), *Diags.get()))
 316           return 0;
 317         break;
 318       default:
 319         if (!Stream.SkipBlock()) {
 320           reportInvalidFile("Malformed block at top-level of diagnostics file");
 321           return 0;
 322         }
 323         break;
 324     }
 325   }
 326 }
 327
 328 StreamResult DiagLoader::readToNextRecordOrBlock(llvm::BitstreamCursor &Stream,
 329                                                  llvm::StringRef errorContext,
 330                                                  unsigned &blockOrRecordID,
 331                                                  const bool atTopLevel) {
 332
 333   blockOrRecordID = 0;
 334
 335   while (!Stream.AtEndOfStream()) {
 336     unsigned Code = Stream.ReadCode();
 337
 338     // Handle the top-level specially.
 339     if (atTopLevel) {
 340       if (Code == llvm::bitc::ENTER_SUBBLOCK) {
 341         unsigned BlockID = Stream.ReadSubBlockID();
 342         if (BlockID == llvm::bitc::BLOCKINFO_BLOCK_ID) {
 343           if (Stream.ReadBlockInfoBlock()) {
 344             reportInvalidFile("Malformed BlockInfoBlock in diagnostics file");
 345             return Read_Failure;
 346           }
 347           continue;
 348         }
 349         blockOrRecordID = BlockID;
 350         return Read_BlockBegin;
 351       }
 352       reportInvalidFile("Only blocks can appear at the top of a "
 353                         "diagnostic file");
 354       return Read_Failure;
 355     }
 356
 357     switch ((llvm::bitc::FixedAbbrevIDs)Code) {
 358       case llvm::bitc::ENTER_SUBBLOCK:
 359         blockOrRecordID = Stream.ReadSubBlockID();
 360         return Read_BlockBegin;
 361
 362       case llvm::bitc::END_BLOCK:
 363         if (Stream.ReadBlockEnd()) {
 364           reportInvalidFile("Cannot read end of block");
 365           return Read_Failure;
 366         }
 367         return Read_BlockEnd;
 368
 369       case llvm::bitc::DEFINE_ABBREV:
 370         Stream.ReadAbbrevRecord();
 371         continue;
 372
 373       case llvm::bitc::UNABBREV_RECORD:
 374         reportInvalidFile("Diagnostics file should have no unabbreviated "
 375                           "records");
 376         return Read_Failure;
 377
 378       default:
 379         // We found a record.
 380         blockOrRecordID = Code;
 381         return Read_Record;
 382     }
 383   }
 384
 385   if (atTopLevel)
 386     return Read_EndOfStream;
 387
 388   reportInvalidFile(Twine("Premature end of diagnostics file within ").str() +
 389                     errorContext.str());
 390   return Read_Failure;
 391 }
 392
 393 LoadResult DiagLoader::readMetaBlock(llvm::BitstreamCursor &Stream) {
 394   if (Stream.EnterSubBlock(clang::serialized_diags::BLOCK_META)) {
 395     reportInvalidFile("Malformed metadata block");
 396     return Failure;
 397   }
 398
 399   bool versionChecked = false;
 400
 401   while (true) {
 402     unsigned blockOrCode = 0;
 403     StreamResult Res = readToNextRecordOrBlock(Stream, "Metadata Block",
 404                                                blockOrCode);
 405
 406     switch(Res) {
 407       case Read_EndOfStream:
 408         llvm_unreachable("EndOfStream handled by readToNextRecordOrBlock");
 409       case Read_Failure:
 410         return Failure;
 411       case Read_Record:
 412         break;
 413       case Read_BlockBegin:
 414         if (Stream.SkipBlock()) {
 415           reportInvalidFile("Malformed metadata block");
 416           return Failure;
 417         }
 418       case Read_BlockEnd:
 419         if (!versionChecked) {
 420           reportInvalidFile("Diagnostics file does not contain version"
 421                             " information");
 422           return Failure;
 423         }
 424         return Success;
 425     }
 426
 427     RecordData Record;
 428     const char *Blob;
 429     unsigned BlobLen;
 430     unsigned recordID = Stream.ReadRecord(blockOrCode, Record, &Blob, &BlobLen);
 431
 432     if (recordID == serialized_diags::RECORD_VERSION) {
 433       if (Record.size() < 1) {
 434         reportInvalidFile("malformed VERSION identifier in diagnostics file");
 435         return Failure;
 436       }
 437       if (Record[0] > MaxSupportedVersion) {
 438         reportInvalidFile("diagnosics file is a newer version than the one "
 439                           "supported");
 440         return Failure;
 441       }
 442       versionChecked = true;
 443     }
 444   }
 445 }
 446
 447 LoadResult DiagLoader::readString(CXLoadedDiagnosticSetImpl &TopDiags,
 448                                   llvm::StringRef &RetStr,
 449                                   llvm::StringRef errorContext,
 450                                   RecordData &Record,
 451                                   const char *BlobStart,
 452                                   unsigned BlobLen,
 453                                   bool allowEmptyString) {
 454
 455   // Basic buffer overflow check.
 456   if (BlobLen > 65536) {
 457     reportInvalidFile(std::string("Out-of-bounds string in ") +
 458                       std::string(errorContext));
 459     return Failure;
 460   }
 461
 462   if (allowEmptyString && Record.size() >= 1 && BlobLen == 0) {
 463     RetStr = "";
 464     return Success;
 465   }
 466
 467   if (Record.size() < 1 || BlobLen == 0) {
 468     reportInvalidFile(std::string("Corrupted ") + std::string(errorContext)
 469                       + std::string(" entry"));
 470     return Failure;
 471   }
 472
 473   RetStr = TopDiags.makeString(BlobStart, BlobLen);
 474   return Success;
 475 }
 476
 477 LoadResult DiagLoader::readString(CXLoadedDiagnosticSetImpl &TopDiags,
 478                                   Strings &strings,
 479                                   llvm::StringRef errorContext,
 480                                   RecordData &Record,
 481                                   const char *BlobStart,
 482                                   unsigned BlobLen,
 483                                   bool allowEmptyString) {
 484   llvm::StringRef RetStr;
 485   if (readString(TopDiags, RetStr, errorContext, Record, BlobStart, BlobLen,
 486                  allowEmptyString))
 487     return Failure;
 488   strings[Record[0]] = RetStr;
 489   return Success;
 490 }
 491
 492 LoadResult DiagLoader::readLocation(CXLoadedDiagnosticSetImpl &TopDiags,
 493                                     RecordData &Record, unsigned &offset,
 494                                     CXLoadedDiagnostic::Location &Loc) {
 495   if (Record.size() < offset + 3) {
 496     reportInvalidFile("Corrupted source location");
 497     return Failure;
 498   }
 499
 500   unsigned fileID = Record[offset++];
 501   if (fileID == 0) {
 502     // Sentinel value.
 503     Loc.file = 0;
 504     Loc.line = 0;
 505     Loc.column = 0;
 506     Loc.offset = 0;
 507     return Success;
 508   }
 509
 510   const FileEntry *FE = TopDiags.Files[fileID];
 511   if (!FE) {
 512     reportInvalidFile("Corrupted file entry in source location");
 513     return Failure;
 514   }
 515   Loc.file = (void*) FE;
 516   Loc.line = Record[offset++];
 517   Loc.column = Record[offset++];
 518   Loc.offset = Record[offset++];
 519   return Success;
 520 }
 521
 522 LoadResult DiagLoader::readRange(CXLoadedDiagnosticSetImpl &TopDiags,
 523                                  RecordData &Record,
 524                                  unsigned int RecStartIdx,
 525                                  CXSourceRange &SR) {
 526   CXLoadedDiagnostic::Location *Start, *End;
 527   Start = TopDiags.Alloc.Allocate<CXLoadedDiagnostic::Location>();
 528   End = TopDiags.Alloc.Allocate<CXLoadedDiagnostic::Location>();
 529
 530   if (readLocation(TopDiags, Record, RecStartIdx, *Start))
 531     return Failure;
 532   if (readLocation(TopDiags, Record, RecStartIdx, *End))
 533     return Failure;
 534
 535   CXSourceLocation startLoc = makeLocation(Start);
 536   CXSourceLocation endLoc = makeLocation(End);
 537   SR = clang_getRange(startLoc, endLoc);
 538   return Success;
 539 }
 540
 541 LoadResult DiagLoader::readDiagnosticBlock(llvm::BitstreamCursor &Stream,
 542                                            CXDiagnosticSetImpl &Diags,
 543                                            CXLoadedDiagnosticSetImpl &TopDiags){
 544
 545   if (Stream.EnterSubBlock(clang::serialized_diags::BLOCK_DIAG)) {
 546     reportInvalidFile("malformed diagnostic block");
 547     return Failure;
 548   }
 549
 550   OwningPtr<CXLoadedDiagnostic> D(new CXLoadedDiagnostic());
 551   RecordData Record;
 552
 553   while (true) {
 554     unsigned blockOrCode = 0;
 555     StreamResult Res = readToNextRecordOrBlock(Stream, "Diagnostic Block",
 556                                                blockOrCode);
 557     switch (Res) {
 558       case Read_EndOfStream:
 559         llvm_unreachable("EndOfStream handled in readToNextRecordOrBlock");
 560       case Read_Failure:
 561         return Failure;
 562       case Read_BlockBegin: {
 563         // The only blocks we care about are subdiagnostics.
 564         if (blockOrCode != serialized_diags::BLOCK_DIAG) {
 565           if (!Stream.SkipBlock()) {
 566             reportInvalidFile("Invalid subblock in Diagnostics block");
 567             return Failure;
 568           }
 569         } else if (readDiagnosticBlock(Stream, D->getChildDiagnostics(),
 570                                        TopDiags)) {
 571           return Failure;
 572         }
 573
 574         continue;
 575       }
 576       case Read_BlockEnd:
 577         Diags.appendDiagnostic(D.take());
 578         return Success;
 579       case Read_Record:
 580         break;
 581     }
 582
 583     // Read the record.
 584     Record.clear();
 585     const char *BlobStart = 0;
 586     unsigned BlobLen = 0;
 587     unsigned recID = Stream.ReadRecord(blockOrCode, Record,
 588                                        BlobStart, BlobLen);
 589
 590     if (recID < serialized_diags::RECORD_FIRST ||
 591         recID > serialized_diags::RECORD_LAST)
 592       continue;
 593
 594     switch ((serialized_diags::RecordIDs)recID) {
 595       case serialized_diags::RECORD_VERSION:
 596         continue;
 597       case serialized_diags::RECORD_CATEGORY:
 598         if (readString(TopDiags, TopDiags.Categories, "category", Record,
 599                        BlobStart, BlobLen,
 600                        /* allowEmptyString */ true))
 601           return Failure;
 602         continue;
 603
 604       case serialized_diags::RECORD_DIAG_FLAG:
 605         if (readString(TopDiags, TopDiags.WarningFlags, "warning flag", Record,
 606                        BlobStart, BlobLen))
 607           return Failure;
 608         continue;
 609
 610       case serialized_diags::RECORD_FILENAME: {
 611         if (readString(TopDiags, TopDiags.FileNames, "filename", Record,
 612                        BlobStart, BlobLen))
 613           return Failure;
 614
 615         if (Record.size() < 3) {
 616           reportInvalidFile("Invalid file entry");
 617           return Failure;
 618         }
 619
 620         const FileEntry *FE =
 621           TopDiags.FakeFiles.getVirtualFile(TopDiags.FileNames[Record[0]],
 622                                             /* size */ Record[1],
 623                                             /* time */ Record[2]);
 624
 625         TopDiags.Files[Record[0]] = FE;
 626         continue;
 627       }
 628
 629       case serialized_diags::RECORD_SOURCE_RANGE: {
 630         CXSourceRange SR;
 631         if (readRange(TopDiags, Record, 0, SR))
 632           return Failure;
 633         D->Ranges.push_back(SR);
 634         continue;
 635       }
 636
 637       case serialized_diags::RECORD_FIXIT: {
 638         CXSourceRange SR;
 639         if (readRange(TopDiags, Record, 0, SR))
 640           return Failure;
 641         llvm::StringRef RetStr;
 642         if (readString(TopDiags, RetStr, "FIXIT", Record, BlobStart, BlobLen,
 643                        /* allowEmptyString */ true))
 644           return Failure;
 645         D->FixIts.push_back(std::make_pair(SR, createCXString(RetStr, false)));
 646         continue;
 647       }
 648
 649       case serialized_diags::RECORD_DIAG: {
 650         D->severity = Record[0];
 651         unsigned offset = 1;
 652         if (readLocation(TopDiags, Record, offset, D->DiagLoc))
 653           return Failure;
 654         D->category = Record[offset++];
 655         unsigned diagFlag = Record[offset++];
 656         D->DiagOption = diagFlag ? TopDiags.WarningFlags[diagFlag] : "";
 657         D->CategoryText = D->category ? TopDiags.Categories[D->category] : "";
 658         D->Spelling = TopDiags.makeString(BlobStart, BlobLen);
 659         continue;
 660       }
 661     }
 662   }
 663 }
 664
 665 extern "C" {
 666 CXDiagnosticSet clang_loadDiagnostics(const char *file,
 667                                       enum CXLoadDiag_Error *error,
 668                                       CXString *errorString) {
 669   DiagLoader L(error, errorString);
 670   return L.load(file);
 671 }
 672 } // end extern 'C'.