7bf871c39f
TableGen and .def files (which are meant to be used with the preprocessor) come with obvious downsides. One of those issues is that generated switch-case branches have to be identical. This pushes corner cases either to an outer code block, or into the generated code. Inspect the removed code in AnalysisConsumer::DigestAnalyzerOptions. You can see how corner cases like a not existing output file, the analysis output type being set to PD_NONE, or whether to complement the output with additional diagnostics on stderr lay around the preprocessor generated code. This is a bit problematic, as to how to deal with such errors is not in the hands of the users of this interface (those implementing output types, like PlistDiagnostics etc). This patch changes this by moving these corner cases into the generated code, more specifically, into the called functions. In addition, I introduced a new output type for convenience purposes, PD_TEXT_MINIMAL, which always existed conceptually, but never in the actual Analyses.def file. This refactoring allowed me to move TextDiagnostics (renamed from ClangDiagPathDiagConsumer) to its own file, which it really deserved. Also, those that had the misfortune to gaze upon Analyses.def will probably enjoy the sight that a clang-format did on it. Differential Revision: https://reviews.llvm.org/D76509
402 lines
15 KiB
C++
402 lines
15 KiB
C++
//===--- SarifDiagnostics.cpp - Sarif Diagnostics for Paths -----*- 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file defines the SarifDiagnostics object.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "clang/Analysis/PathDiagnostic.h"
|
|
#include "clang/Basic/FileManager.h"
|
|
#include "clang/Basic/Version.h"
|
|
#include "clang/Lex/Preprocessor.h"
|
|
#include "clang/StaticAnalyzer/Core/AnalyzerOptions.h"
|
|
#include "clang/StaticAnalyzer/Core/PathDiagnosticConsumers.h"
|
|
#include "llvm/ADT/STLExtras.h"
|
|
#include "llvm/ADT/StringMap.h"
|
|
#include "llvm/Support/ConvertUTF.h"
|
|
#include "llvm/Support/JSON.h"
|
|
#include "llvm/Support/Path.h"
|
|
|
|
using namespace llvm;
|
|
using namespace clang;
|
|
using namespace ento;
|
|
|
|
namespace {
|
|
class SarifDiagnostics : public PathDiagnosticConsumer {
|
|
std::string OutputFile;
|
|
const LangOptions &LO;
|
|
|
|
public:
|
|
SarifDiagnostics(AnalyzerOptions &, const std::string &Output,
|
|
const LangOptions &LO)
|
|
: OutputFile(Output), LO(LO) {}
|
|
~SarifDiagnostics() override = default;
|
|
|
|
void FlushDiagnosticsImpl(std::vector<const PathDiagnostic *> &Diags,
|
|
FilesMade *FM) override;
|
|
|
|
StringRef getName() const override { return "SarifDiagnostics"; }
|
|
PathGenerationScheme getGenerationScheme() const override { return Minimal; }
|
|
bool supportsLogicalOpControlFlow() const override { return true; }
|
|
bool supportsCrossFileDiagnostics() const override { return true; }
|
|
};
|
|
} // end anonymous namespace
|
|
|
|
void ento::createSarifDiagnosticConsumer(
|
|
AnalyzerOptions &AnalyzerOpts, PathDiagnosticConsumers &C,
|
|
const std::string &Output, const Preprocessor &PP,
|
|
const cross_tu::CrossTranslationUnitContext &CTU) {
|
|
|
|
// TODO: Emit an error here.
|
|
if (Output.empty())
|
|
return;
|
|
|
|
C.push_back(new SarifDiagnostics(AnalyzerOpts, Output, PP.getLangOpts()));
|
|
createTextMinimalPathDiagnosticConsumer(AnalyzerOpts, C, Output, PP, CTU);
|
|
}
|
|
|
|
static StringRef getFileName(const FileEntry &FE) {
|
|
StringRef Filename = FE.tryGetRealPathName();
|
|
if (Filename.empty())
|
|
Filename = FE.getName();
|
|
return Filename;
|
|
}
|
|
|
|
static std::string percentEncodeURICharacter(char C) {
|
|
// RFC 3986 claims alpha, numeric, and this handful of
|
|
// characters are not reserved for the path component and
|
|
// should be written out directly. Otherwise, percent
|
|
// encode the character and write that out instead of the
|
|
// reserved character.
|
|
if (llvm::isAlnum(C) ||
|
|
StringRef::npos != StringRef("-._~:@!$&'()*+,;=").find(C))
|
|
return std::string(&C, 1);
|
|
return "%" + llvm::toHex(StringRef(&C, 1));
|
|
}
|
|
|
|
static std::string fileNameToURI(StringRef Filename) {
|
|
llvm::SmallString<32> Ret = StringRef("file://");
|
|
|
|
// Get the root name to see if it has a URI authority.
|
|
StringRef Root = sys::path::root_name(Filename);
|
|
if (Root.startswith("//")) {
|
|
// There is an authority, so add it to the URI.
|
|
Ret += Root.drop_front(2).str();
|
|
} else if (!Root.empty()) {
|
|
// There is no authority, so end the component and add the root to the URI.
|
|
Ret += Twine("/" + Root).str();
|
|
}
|
|
|
|
auto Iter = sys::path::begin(Filename), End = sys::path::end(Filename);
|
|
assert(Iter != End && "Expected there to be a non-root path component.");
|
|
// Add the rest of the path components, encoding any reserved characters;
|
|
// we skip past the first path component, as it was handled it above.
|
|
std::for_each(++Iter, End, [&Ret](StringRef Component) {
|
|
// For reasons unknown to me, we may get a backslash with Windows native
|
|
// paths for the initial backslash following the drive component, which
|
|
// we need to ignore as a URI path part.
|
|
if (Component == "\\")
|
|
return;
|
|
|
|
// Add the separator between the previous path part and the one being
|
|
// currently processed.
|
|
Ret += "/";
|
|
|
|
// URI encode the part.
|
|
for (char C : Component) {
|
|
Ret += percentEncodeURICharacter(C);
|
|
}
|
|
});
|
|
|
|
return std::string(Ret);
|
|
}
|
|
|
|
static json::Object createArtifactLocation(const FileEntry &FE) {
|
|
return json::Object{{"uri", fileNameToURI(getFileName(FE))}};
|
|
}
|
|
|
|
static json::Object createArtifact(const FileEntry &FE) {
|
|
return json::Object{{"location", createArtifactLocation(FE)},
|
|
{"roles", json::Array{"resultFile"}},
|
|
{"length", FE.getSize()},
|
|
{"mimeType", "text/plain"}};
|
|
}
|
|
|
|
static json::Object createArtifactLocation(const FileEntry &FE,
|
|
json::Array &Artifacts) {
|
|
std::string FileURI = fileNameToURI(getFileName(FE));
|
|
|
|
// See if the Artifacts array contains this URI already. If it does not,
|
|
// create a new artifact object to add to the array.
|
|
auto I = llvm::find_if(Artifacts, [&](const json::Value &File) {
|
|
if (const json::Object *Obj = File.getAsObject()) {
|
|
if (const json::Object *FileLoc = Obj->getObject("location")) {
|
|
Optional<StringRef> URI = FileLoc->getString("uri");
|
|
return URI && URI->equals(FileURI);
|
|
}
|
|
}
|
|
return false;
|
|
});
|
|
|
|
// Calculate the index within the artifact array so it can be stored in
|
|
// the JSON object.
|
|
auto Index = static_cast<unsigned>(std::distance(Artifacts.begin(), I));
|
|
if (I == Artifacts.end())
|
|
Artifacts.push_back(createArtifact(FE));
|
|
|
|
return json::Object{{"uri", FileURI}, {"index", Index}};
|
|
}
|
|
|
|
static unsigned int adjustColumnPos(const SourceManager &SM, SourceLocation Loc,
|
|
unsigned int TokenLen = 0) {
|
|
assert(!Loc.isInvalid() && "invalid Loc when adjusting column position");
|
|
|
|
std::pair<FileID, unsigned> LocInfo = SM.getDecomposedExpansionLoc(Loc);
|
|
assert(LocInfo.second > SM.getExpansionColumnNumber(Loc) &&
|
|
"position in file is before column number?");
|
|
|
|
bool InvalidBuffer = false;
|
|
const MemoryBuffer *Buf = SM.getBuffer(LocInfo.first, &InvalidBuffer);
|
|
assert(!InvalidBuffer && "got an invalid buffer for the location's file");
|
|
assert(Buf->getBufferSize() >= (LocInfo.second + TokenLen) &&
|
|
"token extends past end of buffer?");
|
|
|
|
// Adjust the offset to be the start of the line, since we'll be counting
|
|
// Unicode characters from there until our column offset.
|
|
unsigned int Off = LocInfo.second - (SM.getExpansionColumnNumber(Loc) - 1);
|
|
unsigned int Ret = 1;
|
|
while (Off < (LocInfo.second + TokenLen)) {
|
|
Off += getNumBytesForUTF8(Buf->getBuffer()[Off]);
|
|
Ret++;
|
|
}
|
|
|
|
return Ret;
|
|
}
|
|
|
|
static json::Object createTextRegion(const LangOptions &LO, SourceRange R,
|
|
const SourceManager &SM) {
|
|
json::Object Region{
|
|
{"startLine", SM.getExpansionLineNumber(R.getBegin())},
|
|
{"startColumn", adjustColumnPos(SM, R.getBegin())},
|
|
};
|
|
if (R.getBegin() == R.getEnd()) {
|
|
Region["endColumn"] = adjustColumnPos(SM, R.getBegin());
|
|
} else {
|
|
Region["endLine"] = SM.getExpansionLineNumber(R.getEnd());
|
|
Region["endColumn"] = adjustColumnPos(
|
|
SM, R.getEnd(),
|
|
Lexer::MeasureTokenLength(R.getEnd(), SM, LO));
|
|
}
|
|
return Region;
|
|
}
|
|
|
|
static json::Object createPhysicalLocation(const LangOptions &LO,
|
|
SourceRange R, const FileEntry &FE,
|
|
const SourceManager &SMgr,
|
|
json::Array &Artifacts) {
|
|
return json::Object{
|
|
{{"artifactLocation", createArtifactLocation(FE, Artifacts)},
|
|
{"region", createTextRegion(LO, R, SMgr)}}};
|
|
}
|
|
|
|
enum class Importance { Important, Essential, Unimportant };
|
|
|
|
static StringRef importanceToStr(Importance I) {
|
|
switch (I) {
|
|
case Importance::Important:
|
|
return "important";
|
|
case Importance::Essential:
|
|
return "essential";
|
|
case Importance::Unimportant:
|
|
return "unimportant";
|
|
}
|
|
llvm_unreachable("Fully covered switch is not so fully covered");
|
|
}
|
|
|
|
static json::Object createThreadFlowLocation(json::Object &&Location,
|
|
Importance I) {
|
|
return json::Object{{"location", std::move(Location)},
|
|
{"importance", importanceToStr(I)}};
|
|
}
|
|
|
|
static json::Object createMessage(StringRef Text) {
|
|
return json::Object{{"text", Text.str()}};
|
|
}
|
|
|
|
static json::Object createLocation(json::Object &&PhysicalLocation,
|
|
StringRef Message = "") {
|
|
json::Object Ret{{"physicalLocation", std::move(PhysicalLocation)}};
|
|
if (!Message.empty())
|
|
Ret.insert({"message", createMessage(Message)});
|
|
return Ret;
|
|
}
|
|
|
|
static Importance calculateImportance(const PathDiagnosticPiece &Piece) {
|
|
switch (Piece.getKind()) {
|
|
case PathDiagnosticPiece::Call:
|
|
case PathDiagnosticPiece::Macro:
|
|
case PathDiagnosticPiece::Note:
|
|
case PathDiagnosticPiece::PopUp:
|
|
// FIXME: What should be reported here?
|
|
break;
|
|
case PathDiagnosticPiece::Event:
|
|
return Piece.getTagStr() == "ConditionBRVisitor" ? Importance::Important
|
|
: Importance::Essential;
|
|
case PathDiagnosticPiece::ControlFlow:
|
|
return Importance::Unimportant;
|
|
}
|
|
return Importance::Unimportant;
|
|
}
|
|
|
|
static json::Object createThreadFlow(const LangOptions &LO,
|
|
const PathPieces &Pieces,
|
|
json::Array &Artifacts) {
|
|
const SourceManager &SMgr = Pieces.front()->getLocation().getManager();
|
|
json::Array Locations;
|
|
for (const auto &Piece : Pieces) {
|
|
const PathDiagnosticLocation &P = Piece->getLocation();
|
|
Locations.push_back(createThreadFlowLocation(
|
|
createLocation(createPhysicalLocation(
|
|
LO, P.asRange(),
|
|
*P.asLocation().getExpansionLoc().getFileEntry(),
|
|
SMgr, Artifacts),
|
|
Piece->getString()),
|
|
calculateImportance(*Piece)));
|
|
}
|
|
return json::Object{{"locations", std::move(Locations)}};
|
|
}
|
|
|
|
static json::Object createCodeFlow(const LangOptions &LO,
|
|
const PathPieces &Pieces,
|
|
json::Array &Artifacts) {
|
|
return json::Object{
|
|
{"threadFlows", json::Array{createThreadFlow(LO, Pieces, Artifacts)}}};
|
|
}
|
|
|
|
static json::Object createResult(const LangOptions &LO,
|
|
const PathDiagnostic &Diag,
|
|
json::Array &Artifacts,
|
|
const StringMap<unsigned> &RuleMapping) {
|
|
const PathPieces &Path = Diag.path.flatten(false);
|
|
const SourceManager &SMgr = Path.front()->getLocation().getManager();
|
|
|
|
auto Iter = RuleMapping.find(Diag.getCheckerName());
|
|
assert(Iter != RuleMapping.end() && "Rule ID is not in the array index map?");
|
|
|
|
return json::Object{
|
|
{"message", createMessage(Diag.getVerboseDescription())},
|
|
{"codeFlows", json::Array{createCodeFlow(LO, Path, Artifacts)}},
|
|
{"locations",
|
|
json::Array{createLocation(createPhysicalLocation(
|
|
LO, Diag.getLocation().asRange(),
|
|
*Diag.getLocation().asLocation().getExpansionLoc().getFileEntry(),
|
|
SMgr, Artifacts))}},
|
|
{"ruleIndex", Iter->getValue()},
|
|
{"ruleId", Diag.getCheckerName()}};
|
|
}
|
|
|
|
static StringRef getRuleDescription(StringRef CheckName) {
|
|
return llvm::StringSwitch<StringRef>(CheckName)
|
|
#define GET_CHECKERS
|
|
#define CHECKER(FULLNAME, CLASS, HELPTEXT, DOC_URI, IS_HIDDEN) \
|
|
.Case(FULLNAME, HELPTEXT)
|
|
#include "clang/StaticAnalyzer/Checkers/Checkers.inc"
|
|
#undef CHECKER
|
|
#undef GET_CHECKERS
|
|
;
|
|
}
|
|
|
|
static StringRef getRuleHelpURIStr(StringRef CheckName) {
|
|
return llvm::StringSwitch<StringRef>(CheckName)
|
|
#define GET_CHECKERS
|
|
#define CHECKER(FULLNAME, CLASS, HELPTEXT, DOC_URI, IS_HIDDEN) \
|
|
.Case(FULLNAME, DOC_URI)
|
|
#include "clang/StaticAnalyzer/Checkers/Checkers.inc"
|
|
#undef CHECKER
|
|
#undef GET_CHECKERS
|
|
;
|
|
}
|
|
|
|
static json::Object createRule(const PathDiagnostic &Diag) {
|
|
StringRef CheckName = Diag.getCheckerName();
|
|
json::Object Ret{
|
|
{"fullDescription", createMessage(getRuleDescription(CheckName))},
|
|
{"name", CheckName},
|
|
{"id", CheckName}};
|
|
|
|
std::string RuleURI = std::string(getRuleHelpURIStr(CheckName));
|
|
if (!RuleURI.empty())
|
|
Ret["helpUri"] = RuleURI;
|
|
|
|
return Ret;
|
|
}
|
|
|
|
static json::Array createRules(std::vector<const PathDiagnostic *> &Diags,
|
|
StringMap<unsigned> &RuleMapping) {
|
|
json::Array Rules;
|
|
llvm::StringSet<> Seen;
|
|
|
|
llvm::for_each(Diags, [&](const PathDiagnostic *D) {
|
|
StringRef RuleID = D->getCheckerName();
|
|
std::pair<llvm::StringSet<>::iterator, bool> P = Seen.insert(RuleID);
|
|
if (P.second) {
|
|
RuleMapping[RuleID] = Rules.size(); // Maps RuleID to an Array Index.
|
|
Rules.push_back(createRule(*D));
|
|
}
|
|
});
|
|
|
|
return Rules;
|
|
}
|
|
|
|
static json::Object createTool(std::vector<const PathDiagnostic *> &Diags,
|
|
StringMap<unsigned> &RuleMapping) {
|
|
return json::Object{
|
|
{"driver", json::Object{{"name", "clang"},
|
|
{"fullName", "clang static analyzer"},
|
|
{"language", "en-US"},
|
|
{"version", getClangFullVersion()},
|
|
{"rules", createRules(Diags, RuleMapping)}}}};
|
|
}
|
|
|
|
static json::Object createRun(const LangOptions &LO,
|
|
std::vector<const PathDiagnostic *> &Diags) {
|
|
json::Array Results, Artifacts;
|
|
StringMap<unsigned> RuleMapping;
|
|
json::Object Tool = createTool(Diags, RuleMapping);
|
|
|
|
llvm::for_each(Diags, [&](const PathDiagnostic *D) {
|
|
Results.push_back(createResult(LO, *D, Artifacts, RuleMapping));
|
|
});
|
|
|
|
return json::Object{{"tool", std::move(Tool)},
|
|
{"results", std::move(Results)},
|
|
{"artifacts", std::move(Artifacts)},
|
|
{"columnKind", "unicodeCodePoints"}};
|
|
}
|
|
|
|
void SarifDiagnostics::FlushDiagnosticsImpl(
|
|
std::vector<const PathDiagnostic *> &Diags, FilesMade *) {
|
|
// We currently overwrite the file if it already exists. However, it may be
|
|
// useful to add a feature someday that allows the user to append a run to an
|
|
// existing SARIF file. One danger from that approach is that the size of the
|
|
// file can become large very quickly, so decoding into JSON to append a run
|
|
// may be an expensive operation.
|
|
std::error_code EC;
|
|
llvm::raw_fd_ostream OS(OutputFile, EC, llvm::sys::fs::OF_Text);
|
|
if (EC) {
|
|
llvm::errs() << "warning: could not create file: " << EC.message() << '\n';
|
|
return;
|
|
}
|
|
json::Object Sarif{
|
|
{"$schema",
|
|
"https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json"},
|
|
{"version", "2.1.0"},
|
|
{"runs", json::Array{createRun(LO, Diags)}}};
|
|
OS << llvm::formatv("{0:2}\n", json::Value(std::move(Sarif)));
|
|
}
|