2946cd7010
to reflect the new license. We understand that people may be surprised that we're moving the header entirely to discuss the new license. We checked this carefully with the Foundation's lawyer and we believe this is the correct approach. Essentially, all code in the project is now made available by the LLVM project under our new license, so you will see that the license headers include that license only. Some of our contributors have contributed code under our old license, and accordingly, we have retained a copy of our old license notice in the top-level files in each project and repository. llvm-svn: 351636
395 lines
13 KiB
C++
395 lines
13 KiB
C++
//===-- CXLoadedDiagnostic.cpp - Handling of persisent diags ----*- C++ -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Implements handling of persisent diagnostics.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "CXLoadedDiagnostic.h"
|
|
#include "CXString.h"
|
|
#include "clang/Basic/Diagnostic.h"
|
|
#include "clang/Basic/FileManager.h"
|
|
#include "clang/Basic/LLVM.h"
|
|
#include "clang/Frontend/SerializedDiagnosticReader.h"
|
|
#include "clang/Frontend/SerializedDiagnostics.h"
|
|
#include "llvm/ADT/STLExtras.h"
|
|
#include "llvm/ADT/StringRef.h"
|
|
#include "llvm/ADT/Twine.h"
|
|
#include "llvm/Bitcode/BitstreamReader.h"
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
|
|
using namespace clang;
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Extend CXDiagnosticSetImpl which contains strings for diagnostics.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
typedef llvm::DenseMap<unsigned, const char *> Strings;
|
|
|
|
namespace {
|
|
class CXLoadedDiagnosticSetImpl : public CXDiagnosticSetImpl {
|
|
public:
|
|
CXLoadedDiagnosticSetImpl() : CXDiagnosticSetImpl(true), FakeFiles(FO) {}
|
|
~CXLoadedDiagnosticSetImpl() override {}
|
|
|
|
llvm::BumpPtrAllocator Alloc;
|
|
Strings Categories;
|
|
Strings WarningFlags;
|
|
Strings FileNames;
|
|
|
|
FileSystemOptions FO;
|
|
FileManager FakeFiles;
|
|
llvm::DenseMap<unsigned, const FileEntry *> Files;
|
|
|
|
/// Copy the string into our own allocator.
|
|
const char *copyString(StringRef Blob) {
|
|
char *mem = Alloc.Allocate<char>(Blob.size() + 1);
|
|
memcpy(mem, Blob.data(), Blob.size());
|
|
mem[Blob.size()] = '\0';
|
|
return mem;
|
|
}
|
|
};
|
|
} // end anonymous namespace
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Cleanup.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
CXLoadedDiagnostic::~CXLoadedDiagnostic() {}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Public CXLoadedDiagnostic methods.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
CXDiagnosticSeverity CXLoadedDiagnostic::getSeverity() const {
|
|
// FIXME: Fail more softly if the diagnostic level is unknown?
|
|
auto severityAsLevel = static_cast<serialized_diags::Level>(severity);
|
|
assert(severity == static_cast<unsigned>(severityAsLevel) &&
|
|
"unknown serialized diagnostic level");
|
|
|
|
switch (severityAsLevel) {
|
|
#define CASE(X) case serialized_diags::X: return CXDiagnostic_##X;
|
|
CASE(Ignored)
|
|
CASE(Note)
|
|
CASE(Warning)
|
|
CASE(Error)
|
|
CASE(Fatal)
|
|
#undef CASE
|
|
// The 'Remark' level isn't represented in the stable API.
|
|
case serialized_diags::Remark: return CXDiagnostic_Warning;
|
|
}
|
|
|
|
llvm_unreachable("Invalid diagnostic level");
|
|
}
|
|
|
|
static CXSourceLocation makeLocation(const CXLoadedDiagnostic::Location *DLoc) {
|
|
// The lowest bit of ptr_data[0] is always set to 1 to indicate this
|
|
// is a persistent diagnostic.
|
|
uintptr_t V = (uintptr_t) DLoc;
|
|
V |= 0x1;
|
|
CXSourceLocation Loc = { { (void*) V, nullptr }, 0 };
|
|
return Loc;
|
|
}
|
|
|
|
CXSourceLocation CXLoadedDiagnostic::getLocation() const {
|
|
// The lowest bit of ptr_data[0] is always set to 1 to indicate this
|
|
// is a persistent diagnostic.
|
|
return makeLocation(&DiagLoc);
|
|
}
|
|
|
|
CXString CXLoadedDiagnostic::getSpelling() const {
|
|
return cxstring::createRef(Spelling);
|
|
}
|
|
|
|
CXString CXLoadedDiagnostic::getDiagnosticOption(CXString *Disable) const {
|
|
if (DiagOption.empty())
|
|
return cxstring::createEmpty();
|
|
|
|
// FIXME: possibly refactor with logic in CXStoredDiagnostic.
|
|
if (Disable)
|
|
*Disable = cxstring::createDup((Twine("-Wno-") + DiagOption).str());
|
|
return cxstring::createDup((Twine("-W") + DiagOption).str());
|
|
}
|
|
|
|
unsigned CXLoadedDiagnostic::getCategory() const {
|
|
return category;
|
|
}
|
|
|
|
CXString CXLoadedDiagnostic::getCategoryText() const {
|
|
return cxstring::createDup(CategoryText);
|
|
}
|
|
|
|
unsigned CXLoadedDiagnostic::getNumRanges() const {
|
|
return Ranges.size();
|
|
}
|
|
|
|
CXSourceRange CXLoadedDiagnostic::getRange(unsigned Range) const {
|
|
assert(Range < Ranges.size());
|
|
return Ranges[Range];
|
|
}
|
|
|
|
unsigned CXLoadedDiagnostic::getNumFixIts() const {
|
|
return FixIts.size();
|
|
}
|
|
|
|
CXString CXLoadedDiagnostic::getFixIt(unsigned FixIt,
|
|
CXSourceRange *ReplacementRange) const {
|
|
assert(FixIt < FixIts.size());
|
|
if (ReplacementRange)
|
|
*ReplacementRange = FixIts[FixIt].first;
|
|
return cxstring::createRef(FixIts[FixIt].second);
|
|
}
|
|
|
|
void CXLoadedDiagnostic::decodeLocation(CXSourceLocation location,
|
|
CXFile *file,
|
|
unsigned int *line,
|
|
unsigned int *column,
|
|
unsigned int *offset) {
|
|
|
|
|
|
// CXSourceLocation consists of the following fields:
|
|
//
|
|
// void *ptr_data[2];
|
|
// unsigned int_data;
|
|
//
|
|
// The lowest bit of ptr_data[0] is always set to 1 to indicate this
|
|
// is a persistent diagnostic.
|
|
//
|
|
// For now, do the unoptimized approach and store the data in a side
|
|
// data structure. We can optimize this case later.
|
|
|
|
uintptr_t V = (uintptr_t) location.ptr_data[0];
|
|
assert((V & 0x1) == 1);
|
|
V &= ~(uintptr_t)1;
|
|
|
|
const Location &Loc = *((Location*)V);
|
|
|
|
if (file)
|
|
*file = Loc.file;
|
|
if (line)
|
|
*line = Loc.line;
|
|
if (column)
|
|
*column = Loc.column;
|
|
if (offset)
|
|
*offset = Loc.offset;
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Deserialize diagnostics.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace {
|
|
class DiagLoader : serialized_diags::SerializedDiagnosticReader {
|
|
enum CXLoadDiag_Error *error;
|
|
CXString *errorString;
|
|
std::unique_ptr<CXLoadedDiagnosticSetImpl> TopDiags;
|
|
SmallVector<std::unique_ptr<CXLoadedDiagnostic>, 8> CurrentDiags;
|
|
|
|
std::error_code reportBad(enum CXLoadDiag_Error code, llvm::StringRef err) {
|
|
if (error)
|
|
*error = code;
|
|
if (errorString)
|
|
*errorString = cxstring::createDup(err);
|
|
return serialized_diags::SDError::HandlerFailed;
|
|
}
|
|
|
|
std::error_code reportInvalidFile(llvm::StringRef err) {
|
|
return reportBad(CXLoadDiag_InvalidFile, err);
|
|
}
|
|
|
|
std::error_code readRange(const serialized_diags::Location &SDStart,
|
|
const serialized_diags::Location &SDEnd,
|
|
CXSourceRange &SR);
|
|
|
|
std::error_code readLocation(const serialized_diags::Location &SDLoc,
|
|
CXLoadedDiagnostic::Location &LoadedLoc);
|
|
|
|
protected:
|
|
std::error_code visitStartOfDiagnostic() override;
|
|
std::error_code visitEndOfDiagnostic() override;
|
|
|
|
std::error_code visitCategoryRecord(unsigned ID, StringRef Name) override;
|
|
|
|
std::error_code visitDiagFlagRecord(unsigned ID, StringRef Name) override;
|
|
|
|
std::error_code visitDiagnosticRecord(
|
|
unsigned Severity, const serialized_diags::Location &Location,
|
|
unsigned Category, unsigned Flag, StringRef Message) override;
|
|
|
|
std::error_code visitFilenameRecord(unsigned ID, unsigned Size,
|
|
unsigned Timestamp,
|
|
StringRef Name) override;
|
|
|
|
std::error_code visitFixitRecord(const serialized_diags::Location &Start,
|
|
const serialized_diags::Location &End,
|
|
StringRef CodeToInsert) override;
|
|
|
|
std::error_code
|
|
visitSourceRangeRecord(const serialized_diags::Location &Start,
|
|
const serialized_diags::Location &End) override;
|
|
|
|
public:
|
|
DiagLoader(enum CXLoadDiag_Error *e, CXString *es)
|
|
: SerializedDiagnosticReader(), error(e), errorString(es) {
|
|
if (error)
|
|
*error = CXLoadDiag_None;
|
|
if (errorString)
|
|
*errorString = cxstring::createEmpty();
|
|
}
|
|
|
|
CXDiagnosticSet load(const char *file);
|
|
};
|
|
} // end anonymous namespace
|
|
|
|
CXDiagnosticSet DiagLoader::load(const char *file) {
|
|
TopDiags = llvm::make_unique<CXLoadedDiagnosticSetImpl>();
|
|
|
|
std::error_code EC = readDiagnostics(file);
|
|
if (EC) {
|
|
switch (EC.value()) {
|
|
case static_cast<int>(serialized_diags::SDError::HandlerFailed):
|
|
// We've already reported the problem.
|
|
break;
|
|
case static_cast<int>(serialized_diags::SDError::CouldNotLoad):
|
|
reportBad(CXLoadDiag_CannotLoad, EC.message());
|
|
break;
|
|
default:
|
|
reportInvalidFile(EC.message());
|
|
break;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
return (CXDiagnosticSet)TopDiags.release();
|
|
}
|
|
|
|
std::error_code
|
|
DiagLoader::readLocation(const serialized_diags::Location &SDLoc,
|
|
CXLoadedDiagnostic::Location &LoadedLoc) {
|
|
unsigned FileID = SDLoc.FileID;
|
|
if (FileID == 0)
|
|
LoadedLoc.file = nullptr;
|
|
else {
|
|
LoadedLoc.file = const_cast<FileEntry *>(TopDiags->Files[FileID]);
|
|
if (!LoadedLoc.file)
|
|
return reportInvalidFile("Corrupted file entry in source location");
|
|
}
|
|
LoadedLoc.line = SDLoc.Line;
|
|
LoadedLoc.column = SDLoc.Col;
|
|
LoadedLoc.offset = SDLoc.Offset;
|
|
return std::error_code();
|
|
}
|
|
|
|
std::error_code
|
|
DiagLoader::readRange(const serialized_diags::Location &SDStart,
|
|
const serialized_diags::Location &SDEnd,
|
|
CXSourceRange &SR) {
|
|
CXLoadedDiagnostic::Location *Start, *End;
|
|
Start = TopDiags->Alloc.Allocate<CXLoadedDiagnostic::Location>();
|
|
End = TopDiags->Alloc.Allocate<CXLoadedDiagnostic::Location>();
|
|
|
|
std::error_code EC;
|
|
if ((EC = readLocation(SDStart, *Start)))
|
|
return EC;
|
|
if ((EC = readLocation(SDEnd, *End)))
|
|
return EC;
|
|
|
|
CXSourceLocation startLoc = makeLocation(Start);
|
|
CXSourceLocation endLoc = makeLocation(End);
|
|
SR = clang_getRange(startLoc, endLoc);
|
|
return std::error_code();
|
|
}
|
|
|
|
std::error_code DiagLoader::visitStartOfDiagnostic() {
|
|
CurrentDiags.push_back(llvm::make_unique<CXLoadedDiagnostic>());
|
|
return std::error_code();
|
|
}
|
|
|
|
std::error_code DiagLoader::visitEndOfDiagnostic() {
|
|
auto D = CurrentDiags.pop_back_val();
|
|
if (CurrentDiags.empty())
|
|
TopDiags->appendDiagnostic(std::move(D));
|
|
else
|
|
CurrentDiags.back()->getChildDiagnostics().appendDiagnostic(std::move(D));
|
|
return std::error_code();
|
|
}
|
|
|
|
std::error_code DiagLoader::visitCategoryRecord(unsigned ID, StringRef Name) {
|
|
// FIXME: Why do we care about long strings?
|
|
if (Name.size() > 65536)
|
|
return reportInvalidFile("Out-of-bounds string in category");
|
|
TopDiags->Categories[ID] = TopDiags->copyString(Name);
|
|
return std::error_code();
|
|
}
|
|
|
|
std::error_code DiagLoader::visitDiagFlagRecord(unsigned ID, StringRef Name) {
|
|
// FIXME: Why do we care about long strings?
|
|
if (Name.size() > 65536)
|
|
return reportInvalidFile("Out-of-bounds string in warning flag");
|
|
TopDiags->WarningFlags[ID] = TopDiags->copyString(Name);
|
|
return std::error_code();
|
|
}
|
|
|
|
std::error_code DiagLoader::visitFilenameRecord(unsigned ID, unsigned Size,
|
|
unsigned Timestamp,
|
|
StringRef Name) {
|
|
// FIXME: Why do we care about long strings?
|
|
if (Name.size() > 65536)
|
|
return reportInvalidFile("Out-of-bounds string in filename");
|
|
TopDiags->FileNames[ID] = TopDiags->copyString(Name);
|
|
TopDiags->Files[ID] =
|
|
TopDiags->FakeFiles.getVirtualFile(Name, Size, Timestamp);
|
|
return std::error_code();
|
|
}
|
|
|
|
std::error_code
|
|
DiagLoader::visitSourceRangeRecord(const serialized_diags::Location &Start,
|
|
const serialized_diags::Location &End) {
|
|
CXSourceRange SR;
|
|
if (std::error_code EC = readRange(Start, End, SR))
|
|
return EC;
|
|
CurrentDiags.back()->Ranges.push_back(SR);
|
|
return std::error_code();
|
|
}
|
|
|
|
std::error_code
|
|
DiagLoader::visitFixitRecord(const serialized_diags::Location &Start,
|
|
const serialized_diags::Location &End,
|
|
StringRef CodeToInsert) {
|
|
CXSourceRange SR;
|
|
if (std::error_code EC = readRange(Start, End, SR))
|
|
return EC;
|
|
// FIXME: Why do we care about long strings?
|
|
if (CodeToInsert.size() > 65536)
|
|
return reportInvalidFile("Out-of-bounds string in FIXIT");
|
|
CurrentDiags.back()->FixIts.push_back(
|
|
std::make_pair(SR, TopDiags->copyString(CodeToInsert)));
|
|
return std::error_code();
|
|
}
|
|
|
|
std::error_code DiagLoader::visitDiagnosticRecord(
|
|
unsigned Severity, const serialized_diags::Location &Location,
|
|
unsigned Category, unsigned Flag, StringRef Message) {
|
|
CXLoadedDiagnostic &D = *CurrentDiags.back();
|
|
D.severity = Severity;
|
|
if (std::error_code EC = readLocation(Location, D.DiagLoc))
|
|
return EC;
|
|
D.category = Category;
|
|
D.DiagOption = Flag ? TopDiags->WarningFlags[Flag] : "";
|
|
D.CategoryText = Category ? TopDiags->Categories[Category] : "";
|
|
D.Spelling = TopDiags->copyString(Message);
|
|
return std::error_code();
|
|
}
|
|
|
|
CXDiagnosticSet clang_loadDiagnostics(const char *file,
|
|
enum CXLoadDiag_Error *error,
|
|
CXString *errorString) {
|
|
DiagLoader L(error, errorString);
|
|
return L.load(file);
|
|
}
|