xref: /freebsd/contrib/llvm-project/llvm/lib/IR/DiagnosticInfo.cpp (revision b64c5a0ace59af62eff52bfe110a521dc73c937b) 
1 //===- llvm/IR/DiagnosticInfo.cpp - Diagnostic Definitions ------*- 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 different classes involved in low level diagnostics.
10 //
11 // Diagnostics reporting is still done as part of the LLVMContext.
12 //===----------------------------------------------------------------------===//
13 
14 #include "llvm/IR/DiagnosticInfo.h"
15 #include "llvm/ADT/StringExtras.h"
16 #include "llvm/ADT/Twine.h"
17 #include "llvm/ADT/iterator_range.h"
18 #include "llvm/Demangle/Demangle.h"
19 #include "llvm/IR/BasicBlock.h"
20 #include "llvm/IR/Constants.h"
21 #include "llvm/IR/DebugInfoMetadata.h"
22 #include "llvm/IR/DerivedTypes.h"
23 #include "llvm/IR/DiagnosticPrinter.h"
24 #include "llvm/IR/Function.h"
25 #include "llvm/IR/GlobalValue.h"
26 #include "llvm/IR/Instruction.h"
27 #include "llvm/IR/Instructions.h"
28 #include "llvm/IR/LLVMContext.h"
29 #include "llvm/IR/Metadata.h"
30 #include "llvm/IR/Module.h"
31 #include "llvm/IR/Type.h"
32 #include "llvm/IR/Value.h"
33 #include "llvm/Support/Casting.h"
34 #include "llvm/Support/ErrorHandling.h"
35 #include "llvm/Support/InstructionCost.h"
36 #include "llvm/Support/Path.h"
37 #include "llvm/Support/ScopedPrinter.h"
38 #include "llvm/Support/raw_ostream.h"
39 #include <atomic>
40 #include <string>
41 
42 using namespace llvm;
43 
44 int llvm::getNextAvailablePluginDiagnosticKind() {
45   static std::atomic<int> PluginKindID(DK_FirstPluginKind);
46   return ++PluginKindID;
47 }
48 
49 const char *OptimizationRemarkAnalysis::AlwaysPrint = "";
50 
51 DiagnosticInfoInlineAsm::DiagnosticInfoInlineAsm(const Instruction &I,
52                                                  const Twine &MsgStr,
53                                                  DiagnosticSeverity Severity)
54     : DiagnosticInfo(DK_InlineAsm, Severity), MsgStr(MsgStr), Instr(&I) {
55   if (const MDNode *SrcLoc = I.getMetadata("srcloc")) {
56     if (SrcLoc->getNumOperands() != 0)
57       if (const auto *CI =
58               mdconst::dyn_extract<ConstantInt>(SrcLoc->getOperand(0)))
59         LocCookie = CI->getZExtValue();
60   }
61 }
62 
63 void DiagnosticInfoInlineAsm::print(DiagnosticPrinter &DP) const {
64   DP << getMsgStr();
65   if (getLocCookie())
66     DP << " at line " << getLocCookie();
67 }
68 
69 DiagnosticInfoResourceLimit::DiagnosticInfoResourceLimit(
70     const Function &Fn, const char *ResourceName, uint64_t ResourceSize,
71     uint64_t ResourceLimit, DiagnosticSeverity Severity, DiagnosticKind Kind)
72     : DiagnosticInfoWithLocationBase(Kind, Severity, Fn, Fn.getSubprogram()),
73       Fn(Fn), ResourceName(ResourceName), ResourceSize(ResourceSize),
74       ResourceLimit(ResourceLimit) {}
75 
76 void DiagnosticInfoResourceLimit::print(DiagnosticPrinter &DP) const {
77   DP << getLocationStr() << ": " << getResourceName() << " ("
78      << getResourceSize() << ") exceeds limit (" << getResourceLimit()
79      << ") in function '" << getFunction() << '\'';
80 }
81 
82 void DiagnosticInfoDebugMetadataVersion::print(DiagnosticPrinter &DP) const {
83   DP << "ignoring debug info with an invalid version (" << getMetadataVersion()
84      << ") in " << getModule();
85 }
86 
87 void DiagnosticInfoIgnoringInvalidDebugMetadata::print(
88     DiagnosticPrinter &DP) const {
89   DP << "ignoring invalid debug info in " << getModule().getModuleIdentifier();
90 }
91 
92 void DiagnosticInfoSampleProfile::print(DiagnosticPrinter &DP) const {
93   if (!FileName.empty()) {
94     DP << getFileName();
95     if (LineNum > 0)
96       DP << ":" << getLineNum();
97     DP << ": ";
98   }
99   DP << getMsg();
100 }
101 
102 void DiagnosticInfoPGOProfile::print(DiagnosticPrinter &DP) const {
103   if (getFileName())
104     DP << getFileName() << ": ";
105   DP << getMsg();
106 }
107 
108 void DiagnosticInfo::anchor() {}
109 void DiagnosticInfoStackSize::anchor() {}
110 void DiagnosticInfoWithLocationBase::anchor() {}
111 void DiagnosticInfoIROptimization::anchor() {}
112 
113 DiagnosticLocation::DiagnosticLocation(const DebugLoc &DL) {
114   if (!DL)
115     return;
116   File = DL->getFile();
117   Line = DL->getLine();
118   Column = DL->getColumn();
119 }
120 
121 DiagnosticLocation::DiagnosticLocation(const DISubprogram *SP) {
122   if (!SP)
123     return;
124 
125   File = SP->getFile();
126   Line = SP->getScopeLine();
127   Column = 0;
128 }
129 
130 StringRef DiagnosticLocation::getRelativePath() const {
131   return File->getFilename();
132 }
133 
134 std::string DiagnosticLocation::getAbsolutePath() const {
135   StringRef Name = File->getFilename();
136   if (sys::path::is_absolute(Name))
137     return std::string(Name);
138 
139   SmallString<128> Path;
140   sys::path::append(Path, File->getDirectory(), Name);
141   return sys::path::remove_leading_dotslash(Path).str();
142 }
143 
144 std::string DiagnosticInfoWithLocationBase::getAbsolutePath() const {
145   return Loc.getAbsolutePath();
146 }
147 
148 void DiagnosticInfoWithLocationBase::getLocation(StringRef &RelativePath,
149                                                  unsigned &Line,
150                                                  unsigned &Column) const {
151   RelativePath = Loc.getRelativePath();
152   Line = Loc.getLine();
153   Column = Loc.getColumn();
154 }
155 
156 std::string DiagnosticInfoWithLocationBase::getLocationStr() const {
157   StringRef Filename("<unknown>");
158   unsigned Line = 0;
159   unsigned Column = 0;
160   if (isLocationAvailable())
161     getLocation(Filename, Line, Column);
162   return (Filename + ":" + Twine(Line) + ":" + Twine(Column)).str();
163 }
164 
165 DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key,
166                                                    const Value *V)
167     : Key(std::string(Key)) {
168   if (auto *F = dyn_cast<Function>(V)) {
169     if (DISubprogram *SP = F->getSubprogram())
170       Loc = SP;
171   }
172   else if (auto *I = dyn_cast<Instruction>(V))
173     Loc = I->getDebugLoc();
174 
175   // Only include names that correspond to user variables.  FIXME: We should use
176   // debug info if available to get the name of the user variable.
177   if (isa<llvm::Argument>(V) || isa<GlobalValue>(V))
178     Val = std::string(GlobalValue::dropLLVMManglingEscape(V->getName()));
179   else if (isa<Constant>(V)) {
180     raw_string_ostream OS(Val);
181     V->printAsOperand(OS, /*PrintType=*/false);
182   } else if (auto *I = dyn_cast<Instruction>(V)) {
183     Val = I->getOpcodeName();
184   } else if (auto *MD = dyn_cast<MetadataAsValue>(V)) {
185     if (auto *S = dyn_cast<MDString>(MD->getMetadata()))
186       Val = S->getString();
187   }
188 }
189 
190 DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, const Type *T)
191     : Key(std::string(Key)) {
192   raw_string_ostream OS(Val);
193   OS << *T;
194 }
195 
196 DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, StringRef S)
197     : Key(std::string(Key)), Val(S.str()) {}
198 
199 DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, int N)
200     : Key(std::string(Key)), Val(itostr(N)) {}
201 
202 DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, float N)
203     : Key(std::string(Key)), Val(llvm::to_string(N)) {}
204 
205 DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, long N)
206     : Key(std::string(Key)), Val(itostr(N)) {}
207 
208 DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, long long N)
209     : Key(std::string(Key)), Val(itostr(N)) {}
210 
211 DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, unsigned N)
212     : Key(std::string(Key)), Val(utostr(N)) {}
213 
214 DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key,
215                                                    unsigned long N)
216     : Key(std::string(Key)), Val(utostr(N)) {}
217 
218 DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key,
219                                                    unsigned long long N)
220     : Key(std::string(Key)), Val(utostr(N)) {}
221 
222 DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key,
223                                                    ElementCount EC)
224     : Key(std::string(Key)) {
225   raw_string_ostream OS(Val);
226   EC.print(OS);
227 }
228 
229 DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key,
230                                                    InstructionCost C)
231     : Key(std::string(Key)) {
232   raw_string_ostream OS(Val);
233   C.print(OS);
234 }
235 
236 DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, DebugLoc Loc)
237     : Key(std::string(Key)), Loc(Loc) {
238   if (Loc) {
239     Val = (Loc->getFilename() + ":" + Twine(Loc.getLine()) + ":" +
240            Twine(Loc.getCol())).str();
241   } else {
242     Val = "<UNKNOWN LOCATION>";
243   }
244 }
245 
246 void DiagnosticInfoOptimizationBase::print(DiagnosticPrinter &DP) const {
247   DP << getLocationStr() << ": " << getMsg();
248   if (Hotness)
249     DP << " (hotness: " << *Hotness << ")";
250 }
251 
252 OptimizationRemark::OptimizationRemark(const char *PassName,
253                                        StringRef RemarkName,
254                                        const DiagnosticLocation &Loc,
255                                        const Value *CodeRegion)
256     : DiagnosticInfoIROptimization(
257           DK_OptimizationRemark, DS_Remark, PassName, RemarkName,
258           *cast<BasicBlock>(CodeRegion)->getParent(), Loc, CodeRegion) {}
259 
260 OptimizationRemark::OptimizationRemark(const char *PassName,
261                                        StringRef RemarkName,
262                                        const Instruction *Inst)
263     : DiagnosticInfoIROptimization(DK_OptimizationRemark, DS_Remark, PassName,
264                                    RemarkName, *Inst->getParent()->getParent(),
265                                    Inst->getDebugLoc(), Inst->getParent()) {}
266 
267 static const BasicBlock *getFirstFunctionBlock(const Function *Func) {
268   return Func->empty() ? nullptr : &Func->front();
269 }
270 
271 OptimizationRemark::OptimizationRemark(const char *PassName,
272                                        StringRef RemarkName,
273                                        const Function *Func)
274     : DiagnosticInfoIROptimization(DK_OptimizationRemark, DS_Remark, PassName,
275                                    RemarkName, *Func, Func->getSubprogram(),
276                                    getFirstFunctionBlock(Func)) {}
277 
278 bool OptimizationRemark::isEnabled() const {
279   const Function &Fn = getFunction();
280   LLVMContext &Ctx = Fn.getContext();
281   return Ctx.getDiagHandlerPtr()->isPassedOptRemarkEnabled(getPassName());
282 }
283 
284 OptimizationRemarkMissed::OptimizationRemarkMissed(
285     const char *PassName, StringRef RemarkName, const DiagnosticLocation &Loc,
286     const Value *CodeRegion)
287     : DiagnosticInfoIROptimization(
288           DK_OptimizationRemarkMissed, DS_Remark, PassName, RemarkName,
289           *cast<BasicBlock>(CodeRegion)->getParent(), Loc, CodeRegion) {}
290 
291 OptimizationRemarkMissed::OptimizationRemarkMissed(const char *PassName,
292                                                    StringRef RemarkName,
293                                                    const Instruction *Inst)
294     : DiagnosticInfoIROptimization(DK_OptimizationRemarkMissed, DS_Remark,
295                                    PassName, RemarkName,
296                                    *Inst->getParent()->getParent(),
297                                    Inst->getDebugLoc(), Inst->getParent()) {}
298 
299 OptimizationRemarkMissed::OptimizationRemarkMissed(const char *PassName,
300                                                    StringRef RemarkName,
301                                                    const Function *Func)
302     : DiagnosticInfoIROptimization(
303           DK_OptimizationRemarkMissed, DS_Remark, PassName, RemarkName, *Func,
304           Func->getSubprogram(), getFirstFunctionBlock(Func)) {}
305 
306 bool OptimizationRemarkMissed::isEnabled() const {
307   const Function &Fn = getFunction();
308   LLVMContext &Ctx = Fn.getContext();
309   return Ctx.getDiagHandlerPtr()->isMissedOptRemarkEnabled(getPassName());
310 }
311 
312 OptimizationRemarkAnalysis::OptimizationRemarkAnalysis(
313     const char *PassName, StringRef RemarkName, const DiagnosticLocation &Loc,
314     const Value *CodeRegion)
315     : DiagnosticInfoIROptimization(
316           DK_OptimizationRemarkAnalysis, DS_Remark, PassName, RemarkName,
317           *cast<BasicBlock>(CodeRegion)->getParent(), Loc, CodeRegion) {}
318 
319 OptimizationRemarkAnalysis::OptimizationRemarkAnalysis(const char *PassName,
320                                                        StringRef RemarkName,
321                                                        const Instruction *Inst)
322     : DiagnosticInfoIROptimization(DK_OptimizationRemarkAnalysis, DS_Remark,
323                                    PassName, RemarkName,
324                                    *Inst->getParent()->getParent(),
325                                    Inst->getDebugLoc(), Inst->getParent()) {}
326 
327 OptimizationRemarkAnalysis::OptimizationRemarkAnalysis(
328     enum DiagnosticKind Kind, const char *PassName, StringRef RemarkName,
329     const DiagnosticLocation &Loc, const Value *CodeRegion)
330     : DiagnosticInfoIROptimization(Kind, DS_Remark, PassName, RemarkName,
331                                    *cast<BasicBlock>(CodeRegion)->getParent(),
332                                    Loc, CodeRegion) {}
333 
334 OptimizationRemarkAnalysis::OptimizationRemarkAnalysis(const char *PassName,
335                                                        StringRef RemarkName,
336                                                        const Function *Func)
337     : DiagnosticInfoIROptimization(
338           DK_OptimizationRemarkAnalysis, DS_Remark, PassName, RemarkName, *Func,
339           Func->getSubprogram(), getFirstFunctionBlock(Func)) {}
340 
341 bool OptimizationRemarkAnalysis::isEnabled() const {
342   const Function &Fn = getFunction();
343   LLVMContext &Ctx = Fn.getContext();
344   return Ctx.getDiagHandlerPtr()->isAnalysisRemarkEnabled(getPassName()) ||
345          shouldAlwaysPrint();
346 }
347 
348 void DiagnosticInfoMIRParser::print(DiagnosticPrinter &DP) const {
349   DP << Diagnostic;
350 }
351 
352 void DiagnosticInfoSrcMgr::print(DiagnosticPrinter &DP) const {
353   DP << Diagnostic;
354 }
355 
356 DiagnosticInfoOptimizationFailure::DiagnosticInfoOptimizationFailure(
357     const char *PassName, StringRef RemarkName, const DiagnosticLocation &Loc,
358     const Value *CodeRegion)
359     : DiagnosticInfoIROptimization(
360           DK_OptimizationFailure, DS_Warning, PassName, RemarkName,
361           *cast<BasicBlock>(CodeRegion)->getParent(), Loc, CodeRegion) {}
362 
363 bool DiagnosticInfoOptimizationFailure::isEnabled() const {
364   // Only print warnings.
365   return getSeverity() == DS_Warning;
366 }
367 
368 void DiagnosticInfoUnsupported::print(DiagnosticPrinter &DP) const {
369   std::string Str;
370   raw_string_ostream OS(Str);
371 
372   OS << getLocationStr() << ": in function " << getFunction().getName() << ' '
373      << *getFunction().getFunctionType() << ": " << Msg << '\n';
374   OS.flush();
375   DP << Str;
376 }
377 
378 void DiagnosticInfoISelFallback::print(DiagnosticPrinter &DP) const {
379   DP << "Instruction selection used fallback path for " << getFunction();
380 }
381 
382 void DiagnosticInfoOptimizationBase::insert(StringRef S) {
383   Args.emplace_back(S);
384 }
385 
386 void DiagnosticInfoOptimizationBase::insert(Argument A) {
387   Args.push_back(std::move(A));
388 }
389 
390 void DiagnosticInfoOptimizationBase::insert(setIsVerbose V) {
391   IsVerbose = true;
392 }
393 
394 void DiagnosticInfoOptimizationBase::insert(setExtraArgs EA) {
395   FirstExtraArgIndex = Args.size();
396 }
397 
398 std::string DiagnosticInfoOptimizationBase::getMsg() const {
399   std::string Str;
400   raw_string_ostream OS(Str);
401   for (const DiagnosticInfoOptimizationBase::Argument &Arg :
402        make_range(Args.begin(), FirstExtraArgIndex == -1
403                                     ? Args.end()
404                                     : Args.begin() + FirstExtraArgIndex))
405     OS << Arg.Val;
406   return Str;
407 }
408 
409 DiagnosticInfoMisExpect::DiagnosticInfoMisExpect(const Instruction *Inst,
410                                                  Twine &Msg)
411     : DiagnosticInfoWithLocationBase(DK_MisExpect, DS_Warning,
412                                      *Inst->getParent()->getParent(),
413                                      Inst->getDebugLoc()),
414       Msg(Msg) {}
415 
416 void DiagnosticInfoMisExpect::print(DiagnosticPrinter &DP) const {
417   DP << getLocationStr() << ": " << getMsg();
418 }
419 
420 void OptimizationRemarkAnalysisFPCommute::anchor() {}
421 void OptimizationRemarkAnalysisAliasing::anchor() {}
422 
423 void llvm::diagnoseDontCall(const CallInst &CI) {
424   const auto *F =
425       dyn_cast<Function>(CI.getCalledOperand()->stripPointerCasts());
426 
427   if (!F)
428     return;
429 
430   for (int i = 0; i != 2; ++i) {
431     auto AttrName = i == 0 ? "dontcall-error" : "dontcall-warn";
432     auto Sev = i == 0 ? DS_Error : DS_Warning;
433 
434     if (F->hasFnAttribute(AttrName)) {
435       uint64_t LocCookie = 0;
436       auto A = F->getFnAttribute(AttrName);
437       if (MDNode *MD = CI.getMetadata("srcloc"))
438         LocCookie =
439             mdconst::extract<ConstantInt>(MD->getOperand(0))->getZExtValue();
440       DiagnosticInfoDontCall D(F->getName(), A.getValueAsString(), Sev,
441                                LocCookie);
442       F->getContext().diagnose(D);
443     }
444   }
445 }
446 
447 void DiagnosticInfoDontCall::print(DiagnosticPrinter &DP) const {
448   DP << "call to " << demangle(getFunctionName()) << " marked \"dontcall-";
449   if (getSeverity() == DiagnosticSeverity::DS_Error)
450     DP << "error\"";
451   else
452     DP << "warn\"";
453   if (!getNote().empty())
454     DP << ": " << getNote();
455 }
456