1 //===- llvm/Support/DiagnosticInfo.cpp - Diagnostic Definitions -*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines the different classes involved in low level diagnostics.
12 // Diagnostics reporting is still done as part of the LLVMContext.
13 //===----------------------------------------------------------------------===//
15 #include "llvm/IR/DiagnosticInfo.h"
16 #include "LLVMContextImpl.h"
17 #include "llvm/ADT/StringExtras.h"
18 #include "llvm/ADT/Twine.h"
19 #include "llvm/ADT/iterator_range.h"
20 #include "llvm/IR/BasicBlock.h"
21 #include "llvm/IR/Constants.h"
22 #include "llvm/IR/DebugInfoMetadata.h"
23 #include "llvm/IR/DerivedTypes.h"
24 #include "llvm/IR/DiagnosticPrinter.h"
25 #include "llvm/IR/Function.h"
26 #include "llvm/IR/GlobalValue.h"
27 #include "llvm/IR/Instruction.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/CommandLine.h"
35 #include "llvm/Support/ErrorHandling.h"
36 #include "llvm/Support/Regex.h"
37 #include "llvm/Support/raw_ostream.h"
45 int llvm::getNextAvailablePluginDiagnosticKind() {
46 static std::atomic<int> PluginKindID(DK_FirstPluginKind);
47 return ++PluginKindID;
50 const char *OptimizationRemarkAnalysis::AlwaysPrint = "";
52 DiagnosticInfoInlineAsm::DiagnosticInfoInlineAsm(const Instruction &I,
54 DiagnosticSeverity Severity)
55 : DiagnosticInfo(DK_InlineAsm, Severity), MsgStr(MsgStr), Instr(&I) {
56 if (const MDNode *SrcLoc = I.getMetadata("srcloc")) {
57 if (SrcLoc->getNumOperands() != 0)
59 mdconst::dyn_extract<ConstantInt>(SrcLoc->getOperand(0)))
60 LocCookie = CI->getZExtValue();
64 void DiagnosticInfoInlineAsm::print(DiagnosticPrinter &DP) const {
67 DP << " at line " << getLocCookie();
70 void DiagnosticInfoResourceLimit::print(DiagnosticPrinter &DP) const {
71 DP << getResourceName() << " limit";
73 if (getResourceLimit() != 0)
74 DP << " of " << getResourceLimit();
76 DP << " exceeded (" << getResourceSize() << ") in " << getFunction();
79 void DiagnosticInfoDebugMetadataVersion::print(DiagnosticPrinter &DP) const {
80 DP << "ignoring debug info with an invalid version (" << getMetadataVersion()
81 << ") in " << getModule();
84 void DiagnosticInfoIgnoringInvalidDebugMetadata::print(
85 DiagnosticPrinter &DP) const {
86 DP << "ignoring invalid debug info in " << getModule().getModuleIdentifier();
89 void DiagnosticInfoSampleProfile::print(DiagnosticPrinter &DP) const {
90 if (!FileName.empty()) {
93 DP << ":" << getLineNum();
99 void DiagnosticInfoPGOProfile::print(DiagnosticPrinter &DP) const {
101 DP << getFileName() << ": ";
105 DiagnosticLocation::DiagnosticLocation(const DebugLoc &DL) {
108 Filename = DL->getFilename();
109 Line = DL->getLine();
110 Column = DL->getColumn();
113 DiagnosticLocation::DiagnosticLocation(const DISubprogram *SP) {
116 Filename = SP->getFilename();
117 Line = SP->getScopeLine();
121 void DiagnosticInfoWithLocationBase::getLocation(StringRef *Filename,
123 unsigned *Column) const {
124 *Filename = Loc.getFilename();
125 *Line = Loc.getLine();
126 *Column = Loc.getColumn();
129 const std::string DiagnosticInfoWithLocationBase::getLocationStr() const {
130 StringRef Filename("<unknown>");
133 if (isLocationAvailable())
134 getLocation(&Filename, &Line, &Column);
135 return (Filename + ":" + Twine(Line) + ":" + Twine(Column)).str();
138 DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, const Value *V)
140 if (auto *F = dyn_cast<Function>(V)) {
141 if (DISubprogram *SP = F->getSubprogram())
144 else if (auto *I = dyn_cast<Instruction>(V))
145 Loc = I->getDebugLoc();
147 // Only include names that correspond to user variables. FIXME: we should use
148 // debug info if available to get the name of the user variable.
149 if (isa<llvm::Argument>(V) || isa<GlobalValue>(V))
150 Val = GlobalValue::dropLLVMManglingEscape(V->getName());
151 else if (isa<Constant>(V)) {
152 raw_string_ostream OS(Val);
153 V->printAsOperand(OS, /*PrintType=*/false);
154 } else if (auto *I = dyn_cast<Instruction>(V))
155 Val = I->getOpcodeName();
158 DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, const Type *T)
160 raw_string_ostream OS(Val);
164 DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, StringRef S)
165 : Key(Key), Val(S.str()) {}
167 DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, int N)
168 : Key(Key), Val(itostr(N)) {}
170 DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, long N)
171 : Key(Key), Val(itostr(N)) {}
173 DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, long long N)
174 : Key(Key), Val(itostr(N)) {}
176 DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, unsigned N)
177 : Key(Key), Val(utostr(N)) {}
179 DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key,
181 : Key(Key), Val(utostr(N)) {}
183 DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key,
184 unsigned long long N)
185 : Key(Key), Val(utostr(N)) {}
187 DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, DebugLoc Loc)
188 : Key(Key), Loc(Loc) {
190 Val = (Loc->getFilename() + ":" + Twine(Loc.getLine()) + ":" +
191 Twine(Loc.getCol())).str();
193 Val = "<UNKNOWN LOCATION>";
197 void DiagnosticInfoOptimizationBase::print(DiagnosticPrinter &DP) const {
198 DP << getLocationStr() << ": " << getMsg();
200 DP << " (hotness: " << *Hotness << ")";
203 OptimizationRemark::OptimizationRemark(const char *PassName,
204 StringRef RemarkName,
205 const DiagnosticLocation &Loc,
206 const Value *CodeRegion)
207 : DiagnosticInfoIROptimization(
208 DK_OptimizationRemark, DS_Remark, PassName, RemarkName,
209 *cast<BasicBlock>(CodeRegion)->getParent(), Loc, CodeRegion) {}
211 OptimizationRemark::OptimizationRemark(const char *PassName,
212 StringRef RemarkName,
213 const Instruction *Inst)
214 : DiagnosticInfoIROptimization(DK_OptimizationRemark, DS_Remark, PassName,
215 RemarkName, *Inst->getParent()->getParent(),
216 Inst->getDebugLoc(), Inst->getParent()) {}
218 // Helper to allow for an assert before attempting to return an invalid
220 static const BasicBlock &getFirstFunctionBlock(const Function *Func) {
221 assert(!Func->empty() && "Function does not have a body");
222 return Func->front();
225 OptimizationRemark::OptimizationRemark(const char *PassName,
226 StringRef RemarkName,
227 const Function *Func)
228 : DiagnosticInfoIROptimization(DK_OptimizationRemark, DS_Remark, PassName,
229 RemarkName, *Func, Func->getSubprogram(),
230 &getFirstFunctionBlock(Func)) {}
232 bool OptimizationRemark::isEnabled() const {
233 const Function &Fn = getFunction();
234 LLVMContext &Ctx = Fn.getContext();
235 return Ctx.getDiagHandlerPtr()->isPassedOptRemarkEnabled(getPassName());
238 OptimizationRemarkMissed::OptimizationRemarkMissed(
239 const char *PassName, StringRef RemarkName, const DiagnosticLocation &Loc,
240 const Value *CodeRegion)
241 : DiagnosticInfoIROptimization(
242 DK_OptimizationRemarkMissed, DS_Remark, PassName, RemarkName,
243 *cast<BasicBlock>(CodeRegion)->getParent(), Loc, CodeRegion) {}
245 OptimizationRemarkMissed::OptimizationRemarkMissed(const char *PassName,
246 StringRef RemarkName,
247 const Instruction *Inst)
248 : DiagnosticInfoIROptimization(DK_OptimizationRemarkMissed, DS_Remark,
249 PassName, RemarkName,
250 *Inst->getParent()->getParent(),
251 Inst->getDebugLoc(), Inst->getParent()) {}
253 bool OptimizationRemarkMissed::isEnabled() const {
254 const Function &Fn = getFunction();
255 LLVMContext &Ctx = Fn.getContext();
256 return Ctx.getDiagHandlerPtr()->isMissedOptRemarkEnabled(getPassName());
259 OptimizationRemarkAnalysis::OptimizationRemarkAnalysis(
260 const char *PassName, StringRef RemarkName, const DiagnosticLocation &Loc,
261 const Value *CodeRegion)
262 : DiagnosticInfoIROptimization(
263 DK_OptimizationRemarkAnalysis, DS_Remark, PassName, RemarkName,
264 *cast<BasicBlock>(CodeRegion)->getParent(), Loc, CodeRegion) {}
266 OptimizationRemarkAnalysis::OptimizationRemarkAnalysis(const char *PassName,
267 StringRef RemarkName,
268 const Instruction *Inst)
269 : DiagnosticInfoIROptimization(DK_OptimizationRemarkAnalysis, DS_Remark,
270 PassName, RemarkName,
271 *Inst->getParent()->getParent(),
272 Inst->getDebugLoc(), Inst->getParent()) {}
274 OptimizationRemarkAnalysis::OptimizationRemarkAnalysis(
275 enum DiagnosticKind Kind, const char *PassName, StringRef RemarkName,
276 const DiagnosticLocation &Loc, const Value *CodeRegion)
277 : DiagnosticInfoIROptimization(Kind, DS_Remark, PassName, RemarkName,
278 *cast<BasicBlock>(CodeRegion)->getParent(),
281 bool OptimizationRemarkAnalysis::isEnabled() const {
282 const Function &Fn = getFunction();
283 LLVMContext &Ctx = Fn.getContext();
284 return Ctx.getDiagHandlerPtr()->isAnalysisRemarkEnabled(getPassName()) ||
288 void DiagnosticInfoMIRParser::print(DiagnosticPrinter &DP) const {
292 DiagnosticInfoOptimizationFailure::DiagnosticInfoOptimizationFailure(
293 const char *PassName, StringRef RemarkName, const DiagnosticLocation &Loc,
294 const Value *CodeRegion)
295 : DiagnosticInfoIROptimization(
296 DK_OptimizationFailure, DS_Warning, PassName, RemarkName,
297 *cast<BasicBlock>(CodeRegion)->getParent(), Loc, CodeRegion) {}
299 bool DiagnosticInfoOptimizationFailure::isEnabled() const {
300 // Only print warnings.
301 return getSeverity() == DS_Warning;
304 void DiagnosticInfoUnsupported::print(DiagnosticPrinter &DP) const {
306 raw_string_ostream OS(Str);
308 OS << getLocationStr() << ": in function " << getFunction().getName() << ' '
309 << *getFunction().getFunctionType() << ": " << Msg << '\n';
314 void DiagnosticInfoISelFallback::print(DiagnosticPrinter &DP) const {
315 DP << "Instruction selection used fallback path for " << getFunction();
318 void DiagnosticInfoOptimizationBase::insert(StringRef S) {
319 Args.emplace_back(S);
322 void DiagnosticInfoOptimizationBase::insert(Argument A) {
323 Args.push_back(std::move(A));
326 void DiagnosticInfoOptimizationBase::insert(setIsVerbose V) {
330 void DiagnosticInfoOptimizationBase::insert(setExtraArgs EA) {
331 FirstExtraArgIndex = Args.size();
334 std::string DiagnosticInfoOptimizationBase::getMsg() const {
336 raw_string_ostream OS(Str);
337 for (const DiagnosticInfoOptimizationBase::Argument &Arg :
338 make_range(Args.begin(), FirstExtraArgIndex == -1
340 : Args.begin() + FirstExtraArgIndex))
348 void MappingTraits<DiagnosticInfoOptimizationBase *>::mapping(
349 IO &io, DiagnosticInfoOptimizationBase *&OptDiag) {
350 assert(io.outputting() && "input not yet implemented");
352 if (io.mapTag("!Passed",
353 (OptDiag->getKind() == DK_OptimizationRemark ||
354 OptDiag->getKind() == DK_MachineOptimizationRemark)))
358 (OptDiag->getKind() == DK_OptimizationRemarkMissed ||
359 OptDiag->getKind() == DK_MachineOptimizationRemarkMissed)))
363 (OptDiag->getKind() == DK_OptimizationRemarkAnalysis ||
364 OptDiag->getKind() == DK_MachineOptimizationRemarkAnalysis)))
366 else if (io.mapTag("!AnalysisFPCommute",
367 OptDiag->getKind() ==
368 DK_OptimizationRemarkAnalysisFPCommute))
370 else if (io.mapTag("!AnalysisAliasing",
371 OptDiag->getKind() ==
372 DK_OptimizationRemarkAnalysisAliasing))
374 else if (io.mapTag("!Failure", OptDiag->getKind() == DK_OptimizationFailure))
377 llvm_unreachable("Unknown remark type");
379 // These are read-only for now.
380 DiagnosticLocation DL = OptDiag->getLocation();
382 GlobalValue::dropLLVMManglingEscape(OptDiag->getFunction().getName());
384 StringRef PassName(OptDiag->PassName);
385 io.mapRequired("Pass", PassName);
386 io.mapRequired("Name", OptDiag->RemarkName);
387 if (!io.outputting() || DL.isValid())
388 io.mapOptional("DebugLoc", DL);
389 io.mapRequired("Function", FN);
390 io.mapOptional("Hotness", OptDiag->Hotness);
391 io.mapOptional("Args", OptDiag->Args);
394 template <> struct MappingTraits<DiagnosticLocation> {
395 static void mapping(IO &io, DiagnosticLocation &DL) {
396 assert(io.outputting() && "input not yet implemented");
398 StringRef File = DL.getFilename();
399 unsigned Line = DL.getLine();
400 unsigned Col = DL.getColumn();
402 io.mapRequired("File", File);
403 io.mapRequired("Line", Line);
404 io.mapRequired("Column", Col);
407 static const bool flow = true;
410 // Implement this as a mapping for now to get proper quotation for the value.
411 template <> struct MappingTraits<DiagnosticInfoOptimizationBase::Argument> {
412 static void mapping(IO &io, DiagnosticInfoOptimizationBase::Argument &A) {
413 assert(io.outputting() && "input not yet implemented");
414 io.mapRequired(A.Key.data(), A.Val);
416 io.mapOptional("DebugLoc", A.Loc);
420 } // end namespace yaml
421 } // end namespace llvm
423 LLVM_YAML_IS_SEQUENCE_VECTOR(DiagnosticInfoOptimizationBase::Argument)