clang/lib/StaticAnalyzer/Core/SarifDiagnostics.cpp

   1 //===--- SarifDiagnostics.cpp - Sarif Diagnostics for Paths -----*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 //  This file defines the SarifDiagnostics object.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "clang/Analysis/MacroExpansionContext.h"
  14 #include "clang/Analysis/PathDiagnostic.h"
  15 #include "clang/Basic/FileManager.h"
  16 #include "clang/Basic/Sarif.h"
  17 #include "clang/Basic/SourceManager.h"
  18 #include "clang/Basic/Version.h"
  19 #include "clang/Lex/Preprocessor.h"
  20 #include "clang/StaticAnalyzer/Core/PathDiagnosticConsumers.h"
  21 #include "llvm/ADT/STLExtras.h"
  22 #include "llvm/ADT/StringMap.h"
  23 #include "llvm/Support/ConvertUTF.h"
  24 #include "llvm/Support/JSON.h"
  25 #include "llvm/Support/Path.h"
  26
  27 using namespace llvm;
  28 using namespace clang;
  29 using namespace ento;
  30
  31 namespace {
  32 class SarifDiagnostics : public PathDiagnosticConsumer {
  33   std::string OutputFile;
  34   const LangOptions &LO;
  35   SarifDocumentWriter SarifWriter;
  36
  37 public:
  38   SarifDiagnostics(const std::string &Output, const LangOptions &LO,
  39                    const SourceManager &SM)
  40       : OutputFile(Output), LO(LO), SarifWriter(SM) {}
  41   ~SarifDiagnostics() override = default;
  42
  43   void FlushDiagnosticsImpl(std::vector<const PathDiagnostic *> &Diags,
  44                             FilesMade *FM) override;
  45
  46   StringRef getName() const override { return "SarifDiagnostics"; }
  47   PathGenerationScheme getGenerationScheme() const override { return Minimal; }
  48   bool supportsLogicalOpControlFlow() const override { return true; }
  49   bool supportsCrossFileDiagnostics() const override { return true; }
  50 };
  51 } // end anonymous namespace
  52
  53 void ento::createSarifDiagnosticConsumer(
  54     PathDiagnosticConsumerOptions DiagOpts, PathDiagnosticConsumers &C,
  55     const std::string &Output, const Preprocessor &PP,
  56     const cross_tu::CrossTranslationUnitContext &CTU,
  57     const MacroExpansionContext &MacroExpansions) {
  58
  59   // TODO: Emit an error here.
  60   if (Output.empty())
  61     return;
  62
  63   C.push_back(
  64       new SarifDiagnostics(Output, PP.getLangOpts(), PP.getSourceManager()));
  65   createTextMinimalPathDiagnosticConsumer(std::move(DiagOpts), C, Output, PP,
  66                                           CTU, MacroExpansions);
  67 }
  68
  69 static StringRef getRuleDescription(StringRef CheckName) {
  70   return llvm::StringSwitch<StringRef>(CheckName)
  71 #define GET_CHECKERS
  72 #define CHECKER(FULLNAME, CLASS, HELPTEXT, DOC_URI, IS_HIDDEN)                 \
  73   .Case(FULLNAME, HELPTEXT)
  74 #include "clang/StaticAnalyzer/Checkers/Checkers.inc"
  75 #undef CHECKER
  76 #undef GET_CHECKERS
  77       ;
  78 }
  79
  80 static StringRef getRuleHelpURIStr(StringRef CheckName) {
  81   return llvm::StringSwitch<StringRef>(CheckName)
  82 #define GET_CHECKERS
  83 #define CHECKER(FULLNAME, CLASS, HELPTEXT, DOC_URI, IS_HIDDEN)                 \
  84   .Case(FULLNAME, DOC_URI)
  85 #include "clang/StaticAnalyzer/Checkers/Checkers.inc"
  86 #undef CHECKER
  87 #undef GET_CHECKERS
  88       ;
  89 }
  90
  91 static ThreadFlowImportance
  92 calculateImportance(const PathDiagnosticPiece &Piece) {
  93   switch (Piece.getKind()) {
  94   case PathDiagnosticPiece::Call:
  95   case PathDiagnosticPiece::Macro:
  96   case PathDiagnosticPiece::Note:
  97   case PathDiagnosticPiece::PopUp:
  98     // FIXME: What should be reported here?
  99     break;
 100   case PathDiagnosticPiece::Event:
 101     return Piece.getTagStr() == "ConditionBRVisitor"
 102                ? ThreadFlowImportance::Important
 103                : ThreadFlowImportance::Essential;
 104   case PathDiagnosticPiece::ControlFlow:
 105     return ThreadFlowImportance::Unimportant;
 106   }
 107   return ThreadFlowImportance::Unimportant;
 108 }
 109
 110 /// Accepts a SourceRange corresponding to a pair of the first and last tokens
 111 /// and converts to a Character granular CharSourceRange.
 112 static CharSourceRange convertTokenRangeToCharRange(const SourceRange &R,
 113                                                     const SourceManager &SM,
 114                                                     const LangOptions &LO) {
 115   // Caret diagnostics have the first and last locations pointed at the same
 116   // location, return these as-is.
 117   if (R.getBegin() == R.getEnd())
 118     return CharSourceRange::getCharRange(R);
 119
 120   SourceLocation BeginCharLoc = R.getBegin();
 121   // For token ranges, the raw end SLoc points at the first character of the
 122   // last token in the range. This must be moved to one past the end of the
 123   // last character using the lexer.
 124   SourceLocation EndCharLoc =
 125       Lexer::getLocForEndOfToken(R.getEnd(), /* Offset = */ 0, SM, LO);
 126   return CharSourceRange::getCharRange(BeginCharLoc, EndCharLoc);
 127 }
 128
 129 static SmallVector<ThreadFlow, 8> createThreadFlows(const PathDiagnostic *Diag,
 130                                                     const LangOptions &LO) {
 131   SmallVector<ThreadFlow, 8> Flows;
 132   const PathPieces &Pieces = Diag->path.flatten(false);
 133   for (const auto &Piece : Pieces) {
 134     auto Range = convertTokenRangeToCharRange(
 135         Piece->getLocation().asRange(), Piece->getLocation().getManager(), LO);
 136     auto Flow = ThreadFlow::create()
 137                     .setImportance(calculateImportance(*Piece))
 138                     .setRange(Range)
 139                     .setMessage(Piece->getString());
 140     Flows.push_back(Flow);
 141   }
 142   return Flows;
 143 }
 144
 145 static StringMap<uint32_t>
 146 createRuleMapping(const std::vector<const PathDiagnostic *> &Diags,
 147                   SarifDocumentWriter &SarifWriter) {
 148   StringMap<uint32_t> RuleMapping;
 149   llvm::StringSet<> Seen;
 150
 151   for (const PathDiagnostic *D : Diags) {
 152     StringRef CheckName = D->getCheckerName();
 153     std::pair<llvm::StringSet<>::iterator, bool> P = Seen.insert(CheckName);
 154     if (P.second) {
 155       auto Rule = SarifRule::create()
 156                       .setName(CheckName)
 157                       .setRuleId(CheckName)
 158                       .setDescription(getRuleDescription(CheckName))
 159                       .setHelpURI(getRuleHelpURIStr(CheckName));
 160       size_t RuleIdx = SarifWriter.createRule(Rule);
 161       RuleMapping[CheckName] = RuleIdx;
 162     }
 163   }
 164   return RuleMapping;
 165 }
 166
 167 static SarifResult createResult(const PathDiagnostic *Diag,
 168                                 const StringMap<uint32_t> &RuleMapping,
 169                                 const LangOptions &LO) {
 170
 171   StringRef CheckName = Diag->getCheckerName();
 172   uint32_t RuleIdx = RuleMapping.lookup(CheckName);
 173   auto Range = convertTokenRangeToCharRange(
 174       Diag->getLocation().asRange(), Diag->getLocation().getManager(), LO);
 175
 176   SmallVector<ThreadFlow, 8> Flows = createThreadFlows(Diag, LO);
 177   auto Result = SarifResult::create(RuleIdx)
 178                     .setRuleId(CheckName)
 179                     .setDiagnosticMessage(Diag->getVerboseDescription())
 180                     .setDiagnosticLevel(SarifResultLevel::Warning)
 181                     .setLocations({Range})
 182                     .setThreadFlows(Flows);
 183   return Result;
 184 }
 185
 186 void SarifDiagnostics::FlushDiagnosticsImpl(
 187     std::vector<const PathDiagnostic *> &Diags, FilesMade *) {
 188   // We currently overwrite the file if it already exists. However, it may be
 189   // useful to add a feature someday that allows the user to append a run to an
 190   // existing SARIF file. One danger from that approach is that the size of the
 191   // file can become large very quickly, so decoding into JSON to append a run
 192   // may be an expensive operation.
 193   std::error_code EC;
 194   llvm::raw_fd_ostream OS(OutputFile, EC, llvm::sys::fs::OF_TextWithCRLF);
 195   if (EC) {
 196     llvm::errs() << "warning: could not create file: " << EC.message() << '\n';
 197     return;
 198   }
 199
 200   std::string ToolVersion = getClangFullVersion();
 201   SarifWriter.createRun("clang", "clang static analyzer", ToolVersion);
 202   StringMap<uint32_t> RuleMapping = createRuleMapping(Diags, SarifWriter);
 203   for (const PathDiagnostic *D : Diags) {
 204     SarifResult Result = createResult(D, RuleMapping, LO);
 205     SarifWriter.appendResult(Result);
 206   }
 207   auto Document = SarifWriter.createDocument();
 208   OS << llvm::formatv("{0:2}\n", json::Value(std::move(Document)));
 209 }