contrib/llvm/tools/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/Basic/Version.h"
  14 #include "clang/Lex/Preprocessor.h"
  15 #include "clang/StaticAnalyzer/Core/AnalyzerOptions.h"
  16 #include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h"
  17 #include "clang/StaticAnalyzer/Core/PathDiagnosticConsumers.h"
  18 #include "llvm/ADT/STLExtras.h"
  19 #include "llvm/ADT/StringMap.h"
  20 #include "llvm/Support/JSON.h"
  21 #include "llvm/Support/Path.h"
  22
  23 using namespace llvm;
  24 using namespace clang;
  25 using namespace ento;
  26
  27 namespace {
  28 class SarifDiagnostics : public PathDiagnosticConsumer {
  29   std::string OutputFile;
  30
  31 public:
  32   SarifDiagnostics(AnalyzerOptions &, const std::string &Output)
  33       : OutputFile(Output) {}
  34   ~SarifDiagnostics() override = default;
  35
  36   void FlushDiagnosticsImpl(std::vector<const PathDiagnostic *> &Diags,
  37                             FilesMade *FM) override;
  38
  39   StringRef getName() const override { return "SarifDiagnostics"; }
  40   PathGenerationScheme getGenerationScheme() const override { return Minimal; }
  41   bool supportsLogicalOpControlFlow() const override { return true; }
  42   bool supportsCrossFileDiagnostics() const override { return true; }
  43 };
  44 } // end anonymous namespace
  45
  46 void ento::createSarifDiagnosticConsumer(AnalyzerOptions &AnalyzerOpts,
  47                                          PathDiagnosticConsumers &C,
  48                                          const std::string &Output,
  49                                          const Preprocessor &) {
  50   C.push_back(new SarifDiagnostics(AnalyzerOpts, Output));
  51 }
  52
  53 static StringRef getFileName(const FileEntry &FE) {
  54   StringRef Filename = FE.tryGetRealPathName();
  55   if (Filename.empty())
  56     Filename = FE.getName();
  57   return Filename;
  58 }
  59
  60 static std::string percentEncodeURICharacter(char C) {
  61   // RFC 3986 claims alpha, numeric, and this handful of
  62   // characters are not reserved for the path component and
  63   // should be written out directly. Otherwise, percent
  64   // encode the character and write that out instead of the
  65   // reserved character.
  66   if (llvm::isAlnum(C) ||
  67       StringRef::npos != StringRef("-._~:@!$&'()*+,;=").find(C))
  68     return std::string(&C, 1);
  69   return "%" + llvm::toHex(StringRef(&C, 1));
  70 }
  71
  72 static std::string fileNameToURI(StringRef Filename) {
  73   llvm::SmallString<32> Ret = StringRef("file://");
  74
  75   // Get the root name to see if it has a URI authority.
  76   StringRef Root = sys::path::root_name(Filename);
  77   if (Root.startswith("//")) {
  78     // There is an authority, so add it to the URI.
  79     Ret += Root.drop_front(2).str();
  80   } else if (!Root.empty()) {
  81     // There is no authority, so end the component and add the root to the URI.
  82     Ret += Twine("/" + Root).str();
  83   }
  84
  85   auto Iter = sys::path::begin(Filename), End = sys::path::end(Filename);
  86   assert(Iter != End && "Expected there to be a non-root path component.");
  87   // Add the rest of the path components, encoding any reserved characters;
  88   // we skip past the first path component, as it was handled it above.
  89   std::for_each(++Iter, End, [&Ret](StringRef Component) {
  90     // For reasons unknown to me, we may get a backslash with Windows native
  91     // paths for the initial backslash following the drive component, which
  92     // we need to ignore as a URI path part.
  93     if (Component == "\\")
  94       return;
  95
  96     // Add the separator between the previous path part and the one being
  97     // currently processed.
  98     Ret += "/";
  99
 100     // URI encode the part.
 101     for (char C : Component) {
 102       Ret += percentEncodeURICharacter(C);
 103     }
 104   });
 105
 106   return Ret.str().str();
 107 }
 108
 109 static json::Object createFileLocation(const FileEntry &FE) {
 110   return json::Object{{"uri", fileNameToURI(getFileName(FE))}};
 111 }
 112
 113 static json::Object createFile(const FileEntry &FE) {
 114   return json::Object{{"fileLocation", createFileLocation(FE)},
 115                       {"roles", json::Array{"resultFile"}},
 116                       {"length", FE.getSize()},
 117                       {"mimeType", "text/plain"}};
 118 }
 119
 120 static json::Object createFileLocation(const FileEntry &FE,
 121                                        json::Array &Files) {
 122   std::string FileURI = fileNameToURI(getFileName(FE));
 123
 124   // See if the Files array contains this URI already. If it does not, create
 125   // a new file object to add to the array.
 126   auto I = llvm::find_if(Files, [&](const json::Value &File) {
 127     if (const json::Object *Obj = File.getAsObject()) {
 128       if (const json::Object *FileLoc = Obj->getObject("fileLocation")) {
 129         Optional<StringRef> URI = FileLoc->getString("uri");
 130         return URI && URI->equals(FileURI);
 131       }
 132     }
 133     return false;
 134   });
 135
 136   // Calculate the index within the file location array so it can be stored in
 137   // the JSON object.
 138   auto Index = static_cast<unsigned>(std::distance(Files.begin(), I));
 139   if (I == Files.end())
 140     Files.push_back(createFile(FE));
 141
 142   return json::Object{{"uri", FileURI}, {"fileIndex", Index}};
 143 }
 144
 145 static json::Object createTextRegion(SourceRange R, const SourceManager &SM) {
 146   return json::Object{
 147       {"startLine", SM.getExpansionLineNumber(R.getBegin())},
 148       {"endLine", SM.getExpansionLineNumber(R.getEnd())},
 149       {"startColumn", SM.getExpansionColumnNumber(R.getBegin())},
 150       {"endColumn", SM.getExpansionColumnNumber(R.getEnd())}};
 151 }
 152
 153 static json::Object createPhysicalLocation(SourceRange R, const FileEntry &FE,
 154                                            const SourceManager &SMgr,
 155                                            json::Array &Files) {
 156   return json::Object{{{"fileLocation", createFileLocation(FE, Files)},
 157                        {"region", createTextRegion(R, SMgr)}}};
 158 }
 159
 160 enum class Importance { Important, Essential, Unimportant };
 161
 162 static StringRef importanceToStr(Importance I) {
 163   switch (I) {
 164   case Importance::Important:
 165     return "important";
 166   case Importance::Essential:
 167     return "essential";
 168   case Importance::Unimportant:
 169     return "unimportant";
 170   }
 171   llvm_unreachable("Fully covered switch is not so fully covered");
 172 }
 173
 174 static json::Object createThreadFlowLocation(json::Object &&Location,
 175                                              Importance I) {
 176   return json::Object{{"location", std::move(Location)},
 177                       {"importance", importanceToStr(I)}};
 178 }
 179
 180 static json::Object createMessage(StringRef Text) {
 181   return json::Object{{"text", Text.str()}};
 182 }
 183
 184 static json::Object createLocation(json::Object &&PhysicalLocation,
 185                                    StringRef Message = "") {
 186   json::Object Ret{{"physicalLocation", std::move(PhysicalLocation)}};
 187   if (!Message.empty())
 188     Ret.insert({"message", createMessage(Message)});
 189   return Ret;
 190 }
 191
 192 static Importance calculateImportance(const PathDiagnosticPiece &Piece) {
 193   switch (Piece.getKind()) {
 194   case PathDiagnosticPiece::Call:
 195   case PathDiagnosticPiece::Macro:
 196   case PathDiagnosticPiece::Note:
 197   case PathDiagnosticPiece::PopUp:
 198     // FIXME: What should be reported here?
 199     break;
 200   case PathDiagnosticPiece::Event:
 201     return Piece.getTagStr() == "ConditionBRVisitor" ? Importance::Important
 202                                                      : Importance::Essential;
 203   case PathDiagnosticPiece::ControlFlow:
 204     return Importance::Unimportant;
 205   }
 206   return Importance::Unimportant;
 207 }
 208
 209 static json::Object createThreadFlow(const PathPieces &Pieces,
 210                                      json::Array &Files) {
 211   const SourceManager &SMgr = Pieces.front()->getLocation().getManager();
 212   json::Array Locations;
 213   for (const auto &Piece : Pieces) {
 214     const PathDiagnosticLocation &P = Piece->getLocation();
 215     Locations.push_back(createThreadFlowLocation(
 216         createLocation(createPhysicalLocation(P.asRange(),
 217                                               *P.asLocation().getFileEntry(),
 218                                               SMgr, Files),
 219                        Piece->getString()),
 220         calculateImportance(*Piece)));
 221   }
 222   return json::Object{{"locations", std::move(Locations)}};
 223 }
 224
 225 static json::Object createCodeFlow(const PathPieces &Pieces,
 226                                    json::Array &Files) {
 227   return json::Object{
 228       {"threadFlows", json::Array{createThreadFlow(Pieces, Files)}}};
 229 }
 230
 231 static json::Object createTool() {
 232   return json::Object{{"name", "clang"},
 233                       {"fullName", "clang static analyzer"},
 234                       {"language", "en-US"},
 235                       {"version", getClangFullVersion()}};
 236 }
 237
 238 static json::Object createResult(const PathDiagnostic &Diag, json::Array &Files,
 239                                  const StringMap<unsigned> &RuleMapping) {
 240   const PathPieces &Path = Diag.path.flatten(false);
 241   const SourceManager &SMgr = Path.front()->getLocation().getManager();
 242
 243   auto Iter = RuleMapping.find(Diag.getCheckName());
 244   assert(Iter != RuleMapping.end() && "Rule ID is not in the array index map?");
 245
 246   return json::Object{
 247       {"message", createMessage(Diag.getVerboseDescription())},
 248       {"codeFlows", json::Array{createCodeFlow(Path, Files)}},
 249       {"locations",
 250        json::Array{createLocation(createPhysicalLocation(
 251            Diag.getLocation().asRange(),
 252            *Diag.getLocation().asLocation().getFileEntry(), SMgr, Files))}},
 253       {"ruleIndex", Iter->getValue()},
 254       {"ruleId", Diag.getCheckName()}};
 255 }
 256
 257 static StringRef getRuleDescription(StringRef CheckName) {
 258   return llvm::StringSwitch<StringRef>(CheckName)
 259 #define GET_CHECKERS
 260 #define CHECKER(FULLNAME, CLASS, HELPTEXT, DOC_URI, IS_HIDDEN)                 \
 261   .Case(FULLNAME, HELPTEXT)
 262 #include "clang/StaticAnalyzer/Checkers/Checkers.inc"
 263 #undef CHECKER
 264 #undef GET_CHECKERS
 265       ;
 266 }
 267
 268 static StringRef getRuleHelpURIStr(StringRef CheckName) {
 269   return llvm::StringSwitch<StringRef>(CheckName)
 270 #define GET_CHECKERS
 271 #define CHECKER(FULLNAME, CLASS, HELPTEXT, DOC_URI, IS_HIDDEN)                 \
 272   .Case(FULLNAME, DOC_URI)
 273 #include "clang/StaticAnalyzer/Checkers/Checkers.inc"
 274 #undef CHECKER
 275 #undef GET_CHECKERS
 276       ;
 277 }
 278
 279 static json::Object createRule(const PathDiagnostic &Diag) {
 280   StringRef CheckName = Diag.getCheckName();
 281   json::Object Ret{
 282       {"fullDescription", createMessage(getRuleDescription(CheckName))},
 283       {"name", createMessage(CheckName)},
 284       {"id", CheckName}};
 285
 286   std::string RuleURI = getRuleHelpURIStr(CheckName);
 287   if (!RuleURI.empty())
 288     Ret["helpUri"] = RuleURI;
 289
 290   return Ret;
 291 }
 292
 293 static json::Array createRules(std::vector<const PathDiagnostic *> &Diags,
 294                                StringMap<unsigned> &RuleMapping) {
 295   json::Array Rules;
 296   llvm::StringSet<> Seen;
 297
 298   llvm::for_each(Diags, [&](const PathDiagnostic *D) {
 299     StringRef RuleID = D->getCheckName();
 300     std::pair<llvm::StringSet<>::iterator, bool> P = Seen.insert(RuleID);
 301     if (P.second) {
 302       RuleMapping[RuleID] = Rules.size(); // Maps RuleID to an Array Index.
 303       Rules.push_back(createRule(*D));
 304     }
 305   });
 306
 307   return Rules;
 308 }
 309
 310 static json::Object createResources(std::vector<const PathDiagnostic *> &Diags,
 311                                     StringMap<unsigned> &RuleMapping) {
 312   return json::Object{{"rules", createRules(Diags, RuleMapping)}};
 313 }
 314
 315 static json::Object createRun(std::vector<const PathDiagnostic *> &Diags) {
 316   json::Array Results, Files;
 317   StringMap<unsigned> RuleMapping;
 318   json::Object Resources = createResources(Diags, RuleMapping);
 319
 320   llvm::for_each(Diags, [&](const PathDiagnostic *D) {
 321     Results.push_back(createResult(*D, Files, RuleMapping));
 322   });
 323
 324   return json::Object{{"tool", createTool()},
 325                       {"resources", std::move(Resources)},
 326                       {"results", std::move(Results)},
 327                       {"files", std::move(Files)}};
 328 }
 329
 330 void SarifDiagnostics::FlushDiagnosticsImpl(
 331     std::vector<const PathDiagnostic *> &Diags, FilesMade *) {
 332   // We currently overwrite the file if it already exists. However, it may be
 333   // useful to add a feature someday that allows the user to append a run to an
 334   // existing SARIF file. One danger from that approach is that the size of the
 335   // file can become large very quickly, so decoding into JSON to append a run
 336   // may be an expensive operation.
 337   std::error_code EC;
 338   llvm::raw_fd_ostream OS(OutputFile, EC, llvm::sys::fs::F_Text);
 339   if (EC) {
 340     llvm::errs() << "warning: could not create file: " << EC.message() << '\n';
 341     return;
 342   }
 343   json::Object Sarif{
 344       {"$schema",
 345        "http://json.schemastore.org/sarif-2.0.0-csd.2.beta.2018-11-28"},
 346       {"version", "2.0.0-csd.2.beta.2018-11-28"},
 347       {"runs", json::Array{createRun(Diags)}}};
 348   OS << llvm::formatv("{0:2}\n", json::Value(std::move(Sarif)));
 349 }