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