2011-10-29 08:12:39 +08:00
|
|
|
//===--- SerializedDiagnosticPrinter.cpp - Serializer for diagnostics -----===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include <vector>
|
|
|
|
#include "llvm/Support/raw_ostream.h"
|
|
|
|
#include "llvm/ADT/StringRef.h"
|
|
|
|
#include "llvm/ADT/SmallString.h"
|
|
|
|
#include "llvm/ADT/DenseSet.h"
|
|
|
|
#include "clang/Basic/SourceManager.h"
|
|
|
|
#include "clang/Basic/FileManager.h"
|
|
|
|
#include "clang/Basic/Diagnostic.h"
|
|
|
|
#include "clang/Basic/Version.h"
|
|
|
|
#include "clang/Frontend/SerializedDiagnosticPrinter.h"
|
|
|
|
|
|
|
|
using namespace clang;
|
2011-11-05 08:09:57 +08:00
|
|
|
using namespace clang::serialized_diags;
|
2011-10-29 08:12:39 +08:00
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
|
|
|
/// \brief A utility class for entering and exiting bitstream blocks.
|
|
|
|
class BlockEnterExit {
|
|
|
|
llvm::BitstreamWriter &Stream;
|
|
|
|
public:
|
|
|
|
BlockEnterExit(llvm::BitstreamWriter &stream, unsigned blockID,
|
|
|
|
unsigned codelen = 3)
|
|
|
|
: Stream(stream) {
|
|
|
|
Stream.EnterSubblock(blockID, codelen);
|
|
|
|
}
|
|
|
|
~BlockEnterExit() {
|
|
|
|
Stream.ExitBlock();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
class AbbreviationMap {
|
|
|
|
llvm::DenseMap<unsigned, unsigned> Abbrevs;
|
|
|
|
public:
|
|
|
|
AbbreviationMap() {}
|
|
|
|
|
|
|
|
void set(unsigned recordID, unsigned abbrevID) {
|
|
|
|
assert(Abbrevs.find(recordID) == Abbrevs.end()
|
|
|
|
&& "Abbreviation already set.");
|
|
|
|
Abbrevs[recordID] = abbrevID;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned get(unsigned recordID) {
|
|
|
|
assert(Abbrevs.find(recordID) != Abbrevs.end() &&
|
|
|
|
"Abbreviation not set.");
|
|
|
|
return Abbrevs[recordID];
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef llvm::SmallVector<uint64_t, 64> RecordData;
|
|
|
|
typedef llvm::SmallVectorImpl<uint64_t> RecordDataImpl;
|
|
|
|
|
|
|
|
class SDiagsWriter : public DiagnosticConsumer {
|
|
|
|
public:
|
|
|
|
SDiagsWriter(DiagnosticsEngine &diags, llvm::raw_ostream *os)
|
2011-11-05 08:09:47 +08:00
|
|
|
: Stream(Buffer), OS(os), Diags(diags), inNonNoteDiagnostic(false)
|
2011-10-29 08:12:39 +08:00
|
|
|
{
|
|
|
|
EmitPreamble();
|
|
|
|
};
|
|
|
|
|
|
|
|
~SDiagsWriter() {}
|
|
|
|
|
|
|
|
void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
|
|
|
|
const Diagnostic &Info);
|
|
|
|
|
|
|
|
void EndSourceFile();
|
|
|
|
|
|
|
|
DiagnosticConsumer *clone(DiagnosticsEngine &Diags) const {
|
|
|
|
// It makes no sense to clone this.
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
/// \brief Emit the preamble for the serialized diagnostics.
|
|
|
|
void EmitPreamble();
|
|
|
|
|
|
|
|
/// \brief Emit the BLOCKINFO block.
|
|
|
|
void EmitBlockInfoBlock();
|
|
|
|
|
|
|
|
/// \brief Emit the raw characters of the provided string.
|
|
|
|
void EmitRawStringContents(StringRef str);
|
|
|
|
|
|
|
|
/// \brief Emit the block containing categories and file names.
|
|
|
|
void EmitCategoriesAndFileNames();
|
|
|
|
|
2011-11-05 08:10:01 +08:00
|
|
|
/// \brief Emit a record for a CharSourceRange.
|
|
|
|
void EmitCharSourceRange(CharSourceRange R);
|
|
|
|
|
2011-11-05 08:10:07 +08:00
|
|
|
/// \brief Emit the string information for the category for a diagnostic.
|
|
|
|
unsigned getEmitCategory(unsigned DiagID);
|
|
|
|
|
|
|
|
/// \brief Emit the string information for diagnostic flags.
|
|
|
|
unsigned getEmitDiagnosticFlag(DiagnosticsEngine::Level DiagLevel,
|
|
|
|
const Diagnostic &Info);
|
2011-11-05 08:10:04 +08:00
|
|
|
|
2011-10-29 08:12:39 +08:00
|
|
|
/// \brief The version of the diagnostics file.
|
|
|
|
enum { Version = 1 };
|
|
|
|
|
|
|
|
/// \brief The byte buffer for the serialized content.
|
|
|
|
std::vector<unsigned char> Buffer;
|
|
|
|
|
|
|
|
/// \brief The BitStreamWriter for the serialized diagnostics.
|
|
|
|
llvm::BitstreamWriter Stream;
|
|
|
|
|
|
|
|
/// \brief The name of the diagnostics file.
|
|
|
|
llvm::OwningPtr<llvm::raw_ostream> OS;
|
|
|
|
|
|
|
|
/// \brief The DiagnosticsEngine tied to all diagnostic locations.
|
|
|
|
DiagnosticsEngine &Diags;
|
|
|
|
|
|
|
|
/// \brief The set of constructed record abbreviations.
|
|
|
|
AbbreviationMap Abbrevs;
|
|
|
|
|
|
|
|
/// \brief A utility buffer for constructing record content.
|
|
|
|
RecordData Record;
|
|
|
|
|
|
|
|
/// \brief A text buffer for rendering diagnostic text.
|
|
|
|
llvm::SmallString<256> diagBuf;
|
|
|
|
|
|
|
|
/// \brief The collection of diagnostic categories used.
|
|
|
|
llvm::DenseSet<unsigned> Categories;
|
|
|
|
|
|
|
|
/// \brief The collection of files used.
|
|
|
|
llvm::DenseSet<FileID> Files;
|
2011-11-05 08:09:50 +08:00
|
|
|
|
|
|
|
typedef llvm::DenseMap<const void *, std::pair<unsigned, llvm::StringRef> >
|
|
|
|
DiagFlagsTy;
|
|
|
|
|
|
|
|
/// \brief Map for uniquing strings.
|
|
|
|
DiagFlagsTy DiagFlags;
|
2011-10-29 08:12:39 +08:00
|
|
|
|
2011-11-05 08:09:47 +08:00
|
|
|
/// \brief Flag indicating whether or not we are in the process of
|
|
|
|
/// emitting a non-note diagnostic.
|
|
|
|
bool inNonNoteDiagnostic;
|
2011-10-29 08:12:39 +08:00
|
|
|
};
|
|
|
|
} // end anonymous namespace
|
|
|
|
|
|
|
|
namespace clang {
|
|
|
|
namespace serialized_diags {
|
|
|
|
DiagnosticConsumer *create(llvm::raw_ostream *OS, DiagnosticsEngine &Diags) {
|
|
|
|
return new SDiagsWriter(Diags, OS);
|
|
|
|
}
|
|
|
|
} // end namespace serialized_diags
|
|
|
|
} // end namespace clang
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Serialization methods.
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
/// \brief Emits a block ID in the BLOCKINFO block.
|
|
|
|
static void EmitBlockID(unsigned ID, const char *Name,
|
|
|
|
llvm::BitstreamWriter &Stream,
|
|
|
|
RecordDataImpl &Record) {
|
|
|
|
Record.clear();
|
|
|
|
Record.push_back(ID);
|
|
|
|
Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETBID, Record);
|
|
|
|
|
|
|
|
// Emit the block name if present.
|
|
|
|
if (Name == 0 || Name[0] == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
Record.clear();
|
|
|
|
|
|
|
|
while (*Name)
|
|
|
|
Record.push_back(*Name++);
|
|
|
|
|
|
|
|
Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_BLOCKNAME, Record);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// \brief Emits a record ID in the BLOCKINFO block.
|
|
|
|
static void EmitRecordID(unsigned ID, const char *Name,
|
|
|
|
llvm::BitstreamWriter &Stream,
|
|
|
|
RecordDataImpl &Record){
|
|
|
|
Record.clear();
|
|
|
|
Record.push_back(ID);
|
|
|
|
|
|
|
|
while (*Name)
|
|
|
|
Record.push_back(*Name++);
|
|
|
|
|
|
|
|
Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETRECORDNAME, Record);
|
|
|
|
}
|
|
|
|
|
2011-11-05 08:10:01 +08:00
|
|
|
static void AddLocToRecord(SourceManager &SM,
|
|
|
|
SourceLocation Loc,
|
|
|
|
RecordDataImpl &Record) {
|
|
|
|
if (Loc.isInvalid()) {
|
|
|
|
// Emit a "sentinel" location.
|
|
|
|
Record.push_back(~(unsigned)0); // Line.
|
|
|
|
Record.push_back(~(unsigned)0); // Column.
|
|
|
|
Record.push_back(~(unsigned)0); // Offset.
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
Loc = SM.getSpellingLoc(Loc);
|
|
|
|
Record.push_back(SM.getSpellingLineNumber(Loc));
|
|
|
|
Record.push_back(SM.getSpellingColumnNumber(Loc));
|
|
|
|
|
|
|
|
std::pair<FileID, unsigned> LocInfo = SM.getDecomposedLoc(Loc);
|
|
|
|
FileID FID = LocInfo.first;
|
|
|
|
unsigned FileOffset = LocInfo.second;
|
|
|
|
Record.push_back(FileOffset);
|
|
|
|
}
|
|
|
|
|
|
|
|
void SDiagsWriter::EmitCharSourceRange(CharSourceRange R) {
|
|
|
|
Record.clear();
|
|
|
|
Record.push_back(RECORD_SOURCE_RANGE);
|
|
|
|
AddLocToRecord(Diags.getSourceManager(), R.getBegin(), Record);
|
|
|
|
AddLocToRecord(Diags.getSourceManager(), R.getEnd(), Record);
|
|
|
|
Stream.EmitRecordWithAbbrev(Abbrevs.get(RECORD_SOURCE_RANGE), Record);
|
|
|
|
}
|
|
|
|
|
2011-10-29 08:12:39 +08:00
|
|
|
/// \brief Emits the preamble of the diagnostics file.
|
|
|
|
void SDiagsWriter::EmitPreamble() {
|
|
|
|
// EmitRawStringContents("CLANG_DIAGS");
|
|
|
|
// Stream.Emit(Version, 32);
|
|
|
|
|
|
|
|
// Emit the file header.
|
|
|
|
Stream.Emit((unsigned)'D', 8);
|
2011-11-05 08:09:53 +08:00
|
|
|
Stream.Emit((unsigned) Version, 32 - 8);
|
|
|
|
|
2011-10-29 08:12:39 +08:00
|
|
|
EmitBlockInfoBlock();
|
|
|
|
}
|
|
|
|
|
2011-11-05 08:10:01 +08:00
|
|
|
static void AddSourceLocationAbbrev(llvm::BitCodeAbbrev *Abbrev) {
|
|
|
|
using namespace llvm;
|
|
|
|
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Line.
|
|
|
|
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Column.
|
|
|
|
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Offset;
|
|
|
|
}
|
2011-10-29 08:12:39 +08:00
|
|
|
void SDiagsWriter::EmitBlockInfoBlock() {
|
|
|
|
Stream.EnterBlockInfoBlock(3);
|
|
|
|
|
|
|
|
// ==---------------------------------------------------------------------==//
|
|
|
|
// The subsequent records and Abbrevs are for the "Diagnostic" block.
|
|
|
|
// ==---------------------------------------------------------------------==//
|
|
|
|
|
2011-11-05 08:09:50 +08:00
|
|
|
EmitBlockID(BLOCK_DIAG, "Diag", Stream, Record);
|
|
|
|
EmitRecordID(RECORD_DIAG, "DiagInfo", Stream, Record);
|
2011-11-05 08:10:01 +08:00
|
|
|
EmitRecordID(RECORD_SOURCE_RANGE, "SrcRange", Stream, Record);
|
2011-11-05 08:10:04 +08:00
|
|
|
EmitRecordID(RECORD_CATEGORY, "CatName", Stream, Record);
|
2011-11-05 08:10:07 +08:00
|
|
|
EmitRecordID(RECORD_DIAG_FLAG, "DiagFlag", Stream, Record);
|
|
|
|
|
2011-10-29 08:12:39 +08:00
|
|
|
// Emit Abbrevs.
|
|
|
|
using namespace llvm;
|
|
|
|
|
|
|
|
// Emit abbreviation for RECORD_DIAG.
|
|
|
|
BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
|
|
|
|
Abbrev->Add(BitCodeAbbrevOp(RECORD_DIAG));
|
2011-11-05 08:09:50 +08:00
|
|
|
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // Diag level.
|
2011-11-05 08:10:01 +08:00
|
|
|
AddSourceLocationAbbrev(Abbrev);
|
2011-11-05 08:09:50 +08:00
|
|
|
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Category.
|
|
|
|
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Mapped Diag ID.
|
2011-10-29 08:12:39 +08:00
|
|
|
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Text size.
|
|
|
|
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Diagnostc text.
|
|
|
|
Abbrevs.set(RECORD_DIAG, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev));
|
2011-11-05 08:10:01 +08:00
|
|
|
|
2011-11-05 08:10:04 +08:00
|
|
|
// Emit abbrevation for RECORD_CATEGORY.
|
|
|
|
Abbrev = new BitCodeAbbrev();
|
|
|
|
Abbrev->Add(BitCodeAbbrevOp(RECORD_CATEGORY));
|
|
|
|
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Category ID.
|
|
|
|
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8)); // Text size.
|
|
|
|
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Category text.
|
|
|
|
Abbrevs.set(RECORD_CATEGORY, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev));
|
|
|
|
|
2011-11-05 08:10:01 +08:00
|
|
|
// Emit abbrevation for RECORD_SOURCE_RANGE.
|
|
|
|
Abbrev = new BitCodeAbbrev();
|
|
|
|
Abbrev->Add(BitCodeAbbrevOp(RECORD_SOURCE_RANGE));
|
|
|
|
AddSourceLocationAbbrev(Abbrev);
|
|
|
|
AddSourceLocationAbbrev(Abbrev);
|
|
|
|
Abbrevs.set(RECORD_SOURCE_RANGE,
|
|
|
|
Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev));
|
2011-11-05 08:10:07 +08:00
|
|
|
|
|
|
|
// Emit the abbreviation for RECORD_DIAG_FLAG.
|
|
|
|
Abbrev = new BitCodeAbbrev();
|
|
|
|
Abbrev->Add(BitCodeAbbrevOp(RECORD_DIAG_FLAG));
|
|
|
|
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Mapped Diag ID.
|
|
|
|
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Text size.
|
|
|
|
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Flag name text.
|
|
|
|
Abbrevs.set(RECORD_DIAG_FLAG, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG,
|
|
|
|
Abbrev));
|
2011-10-29 08:12:39 +08:00
|
|
|
|
|
|
|
// ==---------------------------------------------------------------------==//
|
|
|
|
// The subsequent records and Abbrevs are for the "Strings" block.
|
|
|
|
// ==---------------------------------------------------------------------==//
|
|
|
|
|
|
|
|
EmitBlockID(BLOCK_STRINGS, "Strings", Stream, Record);
|
2011-11-05 08:09:50 +08:00
|
|
|
EmitRecordID(RECORD_FILENAME, "FileName", Stream, Record);
|
2011-10-29 08:12:39 +08:00
|
|
|
|
|
|
|
Abbrev = new BitCodeAbbrev();
|
2011-11-05 08:09:43 +08:00
|
|
|
Abbrev->Add(BitCodeAbbrevOp(RECORD_FILENAME));
|
|
|
|
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 64)); // Size.
|
|
|
|
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 64)); // Modifcation time.
|
2011-10-29 08:12:39 +08:00
|
|
|
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Text size.
|
|
|
|
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name text.
|
|
|
|
Abbrevs.set(RECORD_FILENAME, Stream.EmitBlockInfoAbbrev(BLOCK_STRINGS,
|
|
|
|
Abbrev));
|
|
|
|
|
|
|
|
Stream.ExitBlock();
|
|
|
|
}
|
|
|
|
|
2011-11-05 08:10:07 +08:00
|
|
|
unsigned SDiagsWriter::getEmitCategory(unsigned int DiagID) {
|
|
|
|
unsigned category = DiagnosticIDs::getCategoryNumberForDiag(DiagID);
|
|
|
|
|
|
|
|
if (Categories.count(category))
|
|
|
|
return category;
|
2011-11-05 08:10:04 +08:00
|
|
|
|
2011-11-05 08:10:07 +08:00
|
|
|
Categories.insert(category);
|
2011-11-05 08:10:04 +08:00
|
|
|
|
|
|
|
// We use a local version of 'Record' so that we can be generating
|
|
|
|
// another record when we lazily generate one for the category entry.
|
|
|
|
RecordData Record;
|
|
|
|
Record.push_back(RECORD_CATEGORY);
|
2011-11-05 08:10:07 +08:00
|
|
|
Record.push_back(category);
|
|
|
|
StringRef catName = DiagnosticIDs::getCategoryNameFromID(category);
|
2011-11-05 08:10:04 +08:00
|
|
|
Record.push_back(catName.size());
|
|
|
|
Stream.EmitRecordWithBlob(Abbrevs.get(RECORD_CATEGORY), Record, catName);
|
2011-11-05 08:10:07 +08:00
|
|
|
|
|
|
|
return category;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned SDiagsWriter::getEmitDiagnosticFlag(DiagnosticsEngine::Level DiagLevel,
|
|
|
|
const Diagnostic &Info) {
|
|
|
|
if (DiagLevel == DiagnosticsEngine::Note)
|
|
|
|
return 0; // No flag for notes.
|
|
|
|
|
|
|
|
StringRef FlagName = DiagnosticIDs::getWarningOptionForDiag(Info.getID());
|
|
|
|
if (FlagName.empty())
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
// Here we assume that FlagName points to static data whose pointer
|
|
|
|
// value is fixed. This allows us to unique by diagnostic groups.
|
|
|
|
const void *data = FlagName.data();
|
|
|
|
std::pair<unsigned, StringRef> &entry = DiagFlags[data];
|
|
|
|
if (entry.first == 0) {
|
|
|
|
entry.first = DiagFlags.size();
|
|
|
|
entry.second = FlagName;
|
|
|
|
|
|
|
|
// Lazily emit the string in a separate record.
|
|
|
|
RecordData Record;
|
|
|
|
Record.push_back(RECORD_DIAG_FLAG);
|
|
|
|
Record.push_back(entry.first);
|
|
|
|
Record.push_back(FlagName.size());
|
|
|
|
Stream.EmitRecordWithBlob(Abbrevs.get(RECORD_DIAG_FLAG),
|
|
|
|
Record, FlagName);
|
|
|
|
}
|
|
|
|
|
|
|
|
return entry.first;
|
2011-11-05 08:10:04 +08:00
|
|
|
}
|
|
|
|
|
2011-10-29 08:12:39 +08:00
|
|
|
void SDiagsWriter::EmitRawStringContents(llvm::StringRef str) {
|
|
|
|
for (StringRef::const_iterator I = str.begin(), E = str.end(); I!=E; ++I)
|
|
|
|
Stream.Emit(*I, 8);
|
|
|
|
}
|
|
|
|
|
|
|
|
void SDiagsWriter::HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
|
|
|
|
const Diagnostic &Info) {
|
|
|
|
|
2011-11-05 08:09:47 +08:00
|
|
|
if (DiagLevel != DiagnosticsEngine::Note) {
|
|
|
|
if (inNonNoteDiagnostic) {
|
|
|
|
// We have encountered a non-note diagnostic. Finish up the previous
|
|
|
|
// diagnostic block before starting a new one.
|
|
|
|
Stream.ExitBlock();
|
|
|
|
}
|
|
|
|
inNonNoteDiagnostic = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
Stream.EnterSubblock(BLOCK_DIAG, 3);
|
2011-10-29 08:12:39 +08:00
|
|
|
|
|
|
|
// Emit the RECORD_DIAG record.
|
|
|
|
Record.clear();
|
|
|
|
Record.push_back(RECORD_DIAG);
|
|
|
|
Record.push_back(DiagLevel);
|
2011-11-05 08:10:07 +08:00
|
|
|
AddLocToRecord(Diags.getSourceManager(), Info.getLocation(), Record);
|
|
|
|
// Emit the category string lazily and get the category ID.
|
|
|
|
Record.push_back(getEmitCategory(Info.getID()));
|
|
|
|
// Emit the diagnostic flag string lazily and get the mapped ID.
|
|
|
|
Record.push_back(getEmitDiagnosticFlag(DiagLevel, Info));
|
|
|
|
|
2011-11-05 08:09:50 +08:00
|
|
|
|
2011-10-29 08:12:39 +08:00
|
|
|
diagBuf.clear();
|
|
|
|
Info.FormatDiagnostic(diagBuf); // Compute the diagnostic text.
|
|
|
|
Record.push_back(diagBuf.str().size());
|
|
|
|
Stream.EmitRecordWithBlob(Abbrevs.get(RECORD_DIAG), Record, diagBuf.str());
|
|
|
|
|
2011-11-05 08:10:01 +08:00
|
|
|
ArrayRef<CharSourceRange> Ranges = Info.getRanges();
|
|
|
|
for (ArrayRef<CharSourceRange>::iterator it=Ranges.begin(), ei=Ranges.end();
|
|
|
|
it != ei; ++it) {
|
|
|
|
EmitCharSourceRange(*it);
|
|
|
|
}
|
|
|
|
|
2011-10-29 08:12:39 +08:00
|
|
|
// FIXME: emit fixits
|
2011-11-05 08:09:47 +08:00
|
|
|
|
|
|
|
if (DiagLevel == DiagnosticsEngine::Note) {
|
|
|
|
// Notes currently cannot have child diagnostics. Complete the
|
|
|
|
// diagnostic now.
|
|
|
|
Stream.ExitBlock();
|
|
|
|
}
|
2011-10-29 08:12:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
static void populateAndSort(std::vector<T> &scribble,
|
|
|
|
llvm::DenseSet<T> &set) {
|
|
|
|
scribble.clear();
|
|
|
|
|
|
|
|
for (typename llvm::DenseSet<T>::iterator it = set.begin(), ei = set.end();
|
|
|
|
it != ei; ++it)
|
|
|
|
scribble.push_back(*it);
|
|
|
|
|
|
|
|
// Sort 'scribble' so we always have a deterministic ordering in the
|
|
|
|
// serialized file.
|
|
|
|
std::sort(scribble.begin(), scribble.end());
|
|
|
|
}
|
|
|
|
|
|
|
|
void SDiagsWriter::EmitCategoriesAndFileNames() {
|
|
|
|
if (Categories.empty() && Files.empty())
|
|
|
|
return;
|
2011-11-05 08:10:04 +08:00
|
|
|
|
2011-10-29 08:12:39 +08:00
|
|
|
BlockEnterExit BlockEnter(Stream, BLOCK_STRINGS);
|
|
|
|
|
|
|
|
// Emit the file names.
|
|
|
|
{
|
|
|
|
std::vector<FileID> scribble;
|
|
|
|
populateAndSort(scribble, Files);
|
|
|
|
for (std::vector<FileID>::iterator it = scribble.begin(),
|
|
|
|
ei = scribble.end(); it != ei; ++it) {
|
|
|
|
SourceManager &SM = Diags.getSourceManager();
|
|
|
|
const FileEntry *FE = SM.getFileEntryForID(*it);
|
|
|
|
StringRef Name = FE->getName();
|
|
|
|
|
|
|
|
Record.clear();
|
2011-11-05 08:09:43 +08:00
|
|
|
Record.push_back(FE->getSize());
|
|
|
|
Record.push_back(FE->getModificationTime());
|
2011-10-29 08:12:39 +08:00
|
|
|
Record.push_back(Name.size());
|
|
|
|
Stream.EmitRecordWithBlob(Abbrevs.get(RECORD_FILENAME), Record, Name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void SDiagsWriter::EndSourceFile() {
|
2011-11-05 08:09:47 +08:00
|
|
|
if (inNonNoteDiagnostic) {
|
|
|
|
// Finish off any diagnostics we were in the process of emitting.
|
|
|
|
Stream.ExitBlock();
|
|
|
|
inNonNoteDiagnostic = false;
|
|
|
|
}
|
|
|
|
|
2011-10-29 08:12:39 +08:00
|
|
|
EmitCategoriesAndFileNames();
|
|
|
|
|
|
|
|
// Write the generated bitstream to "Out".
|
|
|
|
OS->write((char *)&Buffer.front(), Buffer.size());
|
|
|
|
OS->flush();
|
|
|
|
|
|
|
|
OS.reset(0);
|
|
|
|
}
|
|
|
|
|