clang 8.0.0

SarifDiagnostics.cpp
Go to the documentation of this file.
1 //===--- SarifDiagnostics.cpp - Sarif Diagnostics for Paths -----*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file defines the SarifDiagnostics object.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "clang/Basic/Version.h"
15 #include "clang/Lex/Preprocessor.h"
16 #include "clang/StaticAnalyzer/Core/AnalyzerOptions.h"
17 #include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h"
18 #include "clang/StaticAnalyzer/Core/PathDiagnosticConsumers.h"
19 #include "llvm/ADT/STLExtras.h"
20 #include "llvm/ADT/StringMap.h"
21 #include "llvm/Support/JSON.h"
22 #include "llvm/Support/Path.h"
23
24 using namespace llvm;
25 using namespace clang;
26 using namespace ento;
27
28 namespace {
29 class SarifDiagnostics : public PathDiagnosticConsumer {
30 std::string OutputFile;
31
32 public:
33 SarifDiagnostics(AnalyzerOptions &, const std::string &Output)
34 : OutputFile(Output) {}
35 ~SarifDiagnostics() override = default;
36
37 void FlushDiagnosticsImpl(std::vector<const PathDiagnostic *> &Diags,
38 FilesMade *FM) override;
39
40 StringRef getName() const override { return "SarifDiagnostics"; }
41 PathGenerationScheme getGenerationScheme() const override { return Minimal; }
42 bool supportsLogicalOpControlFlow() const override { return true; }
43 bool supportsCrossFileDiagnostics() const override { return true; }
44 };
45 } // end anonymous namespace
46
47 void ento::createSarifDiagnosticConsumer(AnalyzerOptions &AnalyzerOpts,
48 PathDiagnosticConsumers &C,
49 const std::string &Output,
50 const Preprocessor &) {
51 C.push_back(new SarifDiagnostics(AnalyzerOpts, Output));
52 }
53
54 static StringRef getFileName(const FileEntry &FE) {
55 StringRef Filename = FE.tryGetRealPathName();
56 if (Filename.empty())
57 Filename = FE.getName();
58 return Filename;
59 }
60
61 static std::string percentEncodeURICharacter(char C) {
62 // RFC 3986 claims alpha, numeric, and this handful of
63 // characters are not reserved for the path component and
64 // should be written out directly. Otherwise, percent
65 // encode the character and write that out instead of the
66 // reserved character.
67 if (llvm::isAlnum(C) ||
68 StringRef::npos != StringRef("-._~:@!$&'()*+,;=").find(C))
69 return std::string(&C, 1);
70 return "%" + llvm::toHex(StringRef(&C, 1));
71 }
72
73 static std::string fileNameToURI(StringRef Filename) {
74 llvm::SmallString<32> Ret = StringRef("file://");
75
76 // Get the root name to see if it has a URI authority.
77 StringRef Root = sys::path::root_name(Filename);
78 if (Root.startswith("//")) {
79 // There is an authority, so add it to the URI.
80 Ret += Root.drop_front(2).str();
81 } else if (!Root.empty()) {
82 // There is no authority, so end the component and add the root to the URI.
83 Ret += Twine("/" + Root).str();
84 }
85
86 auto Iter = sys::path::begin(Filename), End = sys::path::end(Filename);
87 assert(Iter != End && "Expected there to be a non-root path component.");
88 // Add the rest of the path components, encoding any reserved characters;
89 // we skip past the first path component, as it was handled it above.
90 std::for_each(++Iter, End, [&Ret](StringRef Component) {
91 // For reasons unknown to me, we may get a backslash with Windows native
92 // paths for the initial backslash following the drive component, which
93 // we need to ignore as a URI path part.
94 if (Component == "\\")
95 return;
96
97 // Add the separator between the previous path part and the one being
98 // currently processed.
99 Ret += "/";
100
101 // URI encode the part.
102 for (char C : Component) {
103 Ret += percentEncodeURICharacter(C);
104 }
105 });
106
107 return Ret.str().str();
108 }
109
110 static json::Object createFileLocation(const FileEntry &FE) {
111 return json::Object{{"uri", fileNameToURI(getFileName(FE))}};
112 }
113
114 static json::Object createFile(const FileEntry &FE) {
115 return json::Object{{"fileLocation", createFileLocation(FE)},
116 {"roles", json::Array{"resultFile"}},
117 {"length", FE.getSize()},
118 {"mimeType", "text/plain"}};
119 }
120
121 static json::Object createFileLocation(const FileEntry &FE,
122 json::Array &Files) {
123 std::string FileURI = fileNameToURI(getFileName(FE));
124
125 // See if the Files array contains this URI already. If it does not, create
126 // a new file object to add to the array.
127 auto I = llvm::find_if(Files, [&](const json::Value &File) {
128 if (const json::Object *Obj = File.getAsObject()) {
129 if (const json::Object *FileLoc = Obj->getObject("fileLocation")) {
130 Optional<StringRef> URI = FileLoc->getString("uri");
131 return URI && URI->equals(FileURI);
132 }
133 }
134 return false;
135 });
136
137 // Calculate the index within the file location array so it can be stored in
138 // the JSON object.
139 auto Index = static_cast<unsigned>(std::distance(Files.begin(), I));
140 if (I == Files.end())
141 Files.push_back(createFile(FE));
142
143 return json::Object{{"uri", FileURI}, {"fileIndex", Index}};
144 }
145
146 static json::Object createTextRegion(SourceRange R, const SourceManager &SM) {
147 return json::Object{
148 {"startLine", SM.getExpansionLineNumber(R.getBegin())},
149 {"endLine", SM.getExpansionLineNumber(R.getEnd())},
150 {"startColumn", SM.getExpansionColumnNumber(R.getBegin())},
151 {"endColumn", SM.getExpansionColumnNumber(R.getEnd())}};
152 }
153
154 static json::Object createPhysicalLocation(SourceRange R, const FileEntry &FE,
155 const SourceManager &SMgr,
156 json::Array &Files) {
157 return json::Object{{{"fileLocation", createFileLocation(FE, Files)},
158 {"region", createTextRegion(R, SMgr)}}};
159 }
160
161 enum class Importance { Important, Essential, Unimportant };
162
163 static StringRef importanceToStr(Importance I) {
164 switch (I) {
165 case Importance::Important:
166 return "important";
167 case Importance::Essential:
168 return "essential";
169 case Importance::Unimportant:
170 return "unimportant";
171 }
172 llvm_unreachable("Fully covered switch is not so fully covered");
173 }
174
175 static json::Object createThreadFlowLocation(json::Object &&Location,
176 Importance I) {
177 return json::Object{{"location", std::move(Location)},
178 {"importance", importanceToStr(I)}};
179 }
180
181 static json::Object createMessage(StringRef Text) {
182 return json::Object{{"text", Text.str()}};
183 }
184
185 static json::Object createLocation(json::Object &&PhysicalLocation,
186 StringRef Message = "") {
187 json::Object Ret{{"physicalLocation", std::move(PhysicalLocation)}};
188 if (!Message.empty())
189 Ret.insert({"message", createMessage(Message)});
190 return Ret;
191 }
192
193 static Importance calculateImportance(const PathDiagnosticPiece &Piece) {
194 switch (Piece.getKind()) {
195 case PathDiagnosticPiece::Kind::Call:
196 case PathDiagnosticPiece::Kind::Macro:
197 case PathDiagnosticPiece::Kind::Note:
198 // FIXME: What should be reported here?
199 break;
200 case PathDiagnosticPiece::Kind::Event:
201 return Piece.getTagStr() == "ConditionBRVisitor" ? Importance::Important
202 : Importance::Essential;
203 case PathDiagnosticPiece::Kind::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) \
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) \
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}", json::Value(std::move(Sarif)));
349 }
CHECKER
#define CHECKER(FULLNAME, CLASS, HELPTEXT, DOC_URI)
ento
clang::FileEntry::tryGetRealPathName
StringRef tryGetRealPathName() const
Definition: FileManager.h:86
Diag
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
Definition: LiteralSupport.cpp:78
getFileName
static StringRef getFileName(const FileEntry &FE)
Definition: SarifDiagnostics.cpp:54
clang::getClangFullVersion
std::string getClangFullVersion()
Retrieves a string representing the complete clang version, which includes the clang version number...
Definition: Version.cpp:118
llvm
DominatorTree GraphTraits specialization so the DominatorTree can be iterable by generic graph iterat...
Definition: Dominators.h:30
createTextRegion
static json::Object createTextRegion(SourceRange R, const SourceManager &SM)
Definition: SarifDiagnostics.cpp:146
PathDiagnosticConsumers.h
P
StringRef P
Definition: ASTMatchersInternal.cpp:439
createResult
static json::Object createResult(const PathDiagnostic &Diag, json::Array &Files, const StringMap< unsigned > &RuleMapping)
Definition: SarifDiagnostics.cpp:238
distance
float __ovld __cnfn distance(float p0, float p1)
Returns the distance between p0 and p1.
Value
Value
Definition: UninitializedValues.cpp:102
clang::CodeGen::getName
std::string getName(ArrayRef< StringRef > Parts) const
Get the platform-specific name separator.
Importance::Essential
AnalyzerOptions.h
clang::StructuralEquivalenceKind::Minimal
createThreadFlow
static json::Object createThreadFlow(const PathPieces &Pieces, json::Array &Files)
Definition: SarifDiagnostics.cpp:209
llvm::Optional
Definition: LLVM.h:38
createThreadFlowLocation
static json::Object createThreadFlowLocation(json::Object &&Location, Importance I)
Definition: SarifDiagnostics.cpp:175
createPhysicalLocation
static json::Object createPhysicalLocation(SourceRange R, const FileEntry &FE, const SourceManager &SMgr, json::Array &Files)
Definition: SarifDiagnostics.cpp:154
getRuleDescription
static StringRef getRuleDescription(StringRef CheckName)
Definition: SarifDiagnostics.cpp:257
Importance::Important
llvm::SmallString< 32 >
importanceToStr
static StringRef importanceToStr(Importance I)
Definition: SarifDiagnostics.cpp:163
calculateImportance
static Importance calculateImportance(const PathDiagnosticPiece &Piece)
Definition: SarifDiagnostics.cpp:193
Filename
StringRef Filename
Definition: Format.cpp:1629
End
SourceLocation End
Definition: USRLocFinder.cpp:167
Importance
Importance
Definition: SarifDiagnostics.cpp:161
Version.h
Defines version macros and version-related utility functions for Clang.
Preprocessor.h
Defines the clang::Preprocessor interface.
percentEncodeURICharacter
static std::string percentEncodeURICharacter(char C)
Definition: SarifDiagnostics.cpp:61
createRule
static json::Object createRule(const PathDiagnostic &Diag)
Definition: SarifDiagnostics.cpp:279
PathDiagnostic.h
clang::SourceRange::getEnd
SourceLocation getEnd() const
Definition: SourceLocation.h:208
clang::SourceManager::getExpansionLineNumber
unsigned getExpansionLineNumber(SourceLocation Loc, bool *Invalid=nullptr) const
Definition: SourceManager.cpp:1348
createFile
static json::Object createFile(const FileEntry &FE)
Definition: SarifDiagnostics.cpp:114
SM
const SourceManager & SM
Definition: Format.cpp:1490
createLocation
static json::Object createLocation(json::Object &&PhysicalLocation, StringRef Message="")
Definition: SarifDiagnostics.cpp:185
clang::FileEntry::getName
StringRef getName() const
Definition: FileManager.h:85
clang::ento::PathDiagnosticConsumers
std::vector< PathDiagnosticConsumer * > PathDiagnosticConsumers
Definition: PathDiagnosticConsumers.h:27
createCodeFlow
static json::Object createCodeFlow(const PathPieces &Pieces, json::Array &Files)
Definition: SarifDiagnostics.cpp:225
clang::FileEntry
Cached information about one file (either on disk or in the virtual file system). ...
Definition: FileManager.h:60
Importance::Unimportant
createTool
static json::Object createTool()
Definition: SarifDiagnostics.cpp:231
clang::SourceManager::getExpansionColumnNumber
unsigned getExpansionColumnNumber(SourceLocation Loc, bool *Invalid=nullptr) const
Definition: SourceManager.cpp:1180
clang
Dataflow Directional Tag Classes.
Definition: CFGReachabilityAnalysis.h:22
createFileLocation
static json::Object createFileLocation(const FileEntry &FE)
Definition: SarifDiagnostics.cpp:110
clang::FileEntry::getSize
off_t getSize() const
Definition: FileManager.h:88
createResources
static json::Object createResources(std::vector< const PathDiagnostic *> &Diags, StringMap< unsigned > &RuleMapping)
Definition: SarifDiagnostics.cpp:310
GET_CHECKERS
#define GET_CHECKERS
createRun
static json::Object createRun(std::vector< const PathDiagnostic *> &Diags)
Definition: SarifDiagnostics.cpp:315
createRules
static json::Array createRules(std::vector< const PathDiagnostic *> &Diags, StringMap< unsigned > &RuleMapping)
Definition: SarifDiagnostics.cpp:293
clang::AnalyzerOptions
Stores options for the analyzer from the command line.
Definition: AnalyzerOptions.h:163
getRuleHelpURIStr
static StringRef getRuleHelpURIStr(StringRef CheckName)
Definition: SarifDiagnostics.cpp:268
fileNameToURI
static std::string fileNameToURI(StringRef Filename)
Definition: SarifDiagnostics.cpp:73
clang::serialized_diags::Note
Definition: SerializedDiagnostics.h:46
Text
StringRef Text
Definition: Format.cpp:1630
clang::SourceRange
A trivial tuple used to represent a source range.
Definition: SourceLocation.h:198
createMessage
static json::Object createMessage(StringRef Text)
Definition: SarifDiagnostics.cpp:181
clang::SourceRange::getBegin
SourceLocation getBegin() const
Definition: SourceLocation.h:207
clang::SourceManager
This class handles loading and caching of source files into memory.
Definition: SourceManager.h:582
clang::Preprocessor
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:125