contrib/llvm/lib/IR/DiagnosticInfo.cpp

   1 //===- llvm/Support/DiagnosticInfo.cpp - Diagnostic Definitions -*- 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 different classes involved in low level diagnostics.
  11 //
  12 // Diagnostics reporting is still done as part of the LLVMContext.
  13 //===----------------------------------------------------------------------===//
  14
  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"
  38 #include "llvm/Support/ScopedPrinter.h"
  39 #include <atomic>
  40 #include <cassert>
  41 #include <memory>
  42 #include <string>
  43
  44 using namespace llvm;
  45
  46 int llvm::getNextAvailablePluginDiagnosticKind() {
  47   static std::atomic<int> PluginKindID(DK_FirstPluginKind);
  48   return ++PluginKindID;
  49 }
  50
  51 const char *OptimizationRemarkAnalysis::AlwaysPrint = "";
  52
  53 DiagnosticInfoInlineAsm::DiagnosticInfoInlineAsm(const Instruction &I,
  54                                                  const Twine &MsgStr,
  55                                                  DiagnosticSeverity Severity)
  56     : DiagnosticInfo(DK_InlineAsm, Severity), MsgStr(MsgStr), Instr(&I) {
  57   if (const MDNode *SrcLoc = I.getMetadata("srcloc")) {
  58     if (SrcLoc->getNumOperands() != 0)
  59       if (const auto *CI =
  60               mdconst::dyn_extract<ConstantInt>(SrcLoc->getOperand(0)))
  61         LocCookie = CI->getZExtValue();
  62   }
  63 }
  64
  65 void DiagnosticInfoInlineAsm::print(DiagnosticPrinter &DP) const {
  66   DP << getMsgStr();
  67   if (getLocCookie())
  68     DP << " at line " << getLocCookie();
  69 }
  70
  71 void DiagnosticInfoResourceLimit::print(DiagnosticPrinter &DP) const {
  72   DP << getResourceName() << " limit";
  73
  74   if (getResourceLimit() != 0)
  75     DP << " of " << getResourceLimit();
  76
  77   DP << " exceeded (" <<  getResourceSize() << ") in " << getFunction();
  78 }
  79
  80 void DiagnosticInfoDebugMetadataVersion::print(DiagnosticPrinter &DP) const {
  81   DP << "ignoring debug info with an invalid version (" << getMetadataVersion()
  82      << ") in " << getModule();
  83 }
  84
  85 void DiagnosticInfoIgnoringInvalidDebugMetadata::print(
  86     DiagnosticPrinter &DP) const {
  87   DP << "ignoring invalid debug info in " << getModule().getModuleIdentifier();
  88 }
  89
  90 void DiagnosticInfoSampleProfile::print(DiagnosticPrinter &DP) const {
  91   if (!FileName.empty()) {
  92     DP << getFileName();
  93     if (LineNum > 0)
  94       DP << ":" << getLineNum();
  95     DP << ": ";
  96   }
  97   DP << getMsg();
  98 }
  99
 100 void DiagnosticInfoPGOProfile::print(DiagnosticPrinter &DP) const {
 101   if (getFileName())
 102     DP << getFileName() << ": ";
 103   DP << getMsg();
 104 }
 105
 106 DiagnosticLocation::DiagnosticLocation(const DebugLoc &DL) {
 107   if (!DL)
 108     return;
 109   Filename = DL->getFilename();
 110   Line = DL->getLine();
 111   Column = DL->getColumn();
 112 }
 113
 114 DiagnosticLocation::DiagnosticLocation(const DISubprogram *SP) {
 115   if (!SP)
 116     return;
 117   Filename = SP->getFilename();
 118   Line = SP->getScopeLine();
 119   Column = 0;
 120 }
 121
 122 void DiagnosticInfoWithLocationBase::getLocation(StringRef *Filename,
 123                                                  unsigned *Line,
 124                                                  unsigned *Column) const {
 125   *Filename = Loc.getFilename();
 126   *Line = Loc.getLine();
 127   *Column = Loc.getColumn();
 128 }
 129
 130 const std::string DiagnosticInfoWithLocationBase::getLocationStr() const {
 131   StringRef Filename("<unknown>");
 132   unsigned Line = 0;
 133   unsigned Column = 0;
 134   if (isLocationAvailable())
 135     getLocation(&Filename, &Line, &Column);
 136   return (Filename + ":" + Twine(Line) + ":" + Twine(Column)).str();
 137 }
 138
 139 DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, const Value *V)
 140     : Key(Key) {
 141   if (auto *F = dyn_cast<Function>(V)) {
 142     if (DISubprogram *SP = F->getSubprogram())
 143       Loc = SP;
 144   }
 145   else if (auto *I = dyn_cast<Instruction>(V))
 146     Loc = I->getDebugLoc();
 147
 148   // Only include names that correspond to user variables.  FIXME: We should use
 149   // debug info if available to get the name of the user variable.
 150   if (isa<llvm::Argument>(V) || isa<GlobalValue>(V))
 151     Val = GlobalValue::dropLLVMManglingEscape(V->getName());
 152   else if (isa<Constant>(V)) {
 153     raw_string_ostream OS(Val);
 154     V->printAsOperand(OS, /*PrintType=*/false);
 155   } else if (auto *I = dyn_cast<Instruction>(V))
 156     Val = I->getOpcodeName();
 157 }
 158
 159 DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, const Type *T)
 160     : Key(Key) {
 161   raw_string_ostream OS(Val);
 162   OS << *T;
 163 }
 164
 165 DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, StringRef S)
 166     : Key(Key), Val(S.str()) {}
 167
 168 DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, int N)
 169     : Key(Key), Val(itostr(N)) {}
 170
 171 DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, float N)
 172     : Key(Key), Val(llvm::to_string(N)) {}
 173
 174 DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, long N)
 175     : Key(Key), Val(itostr(N)) {}
 176
 177 DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, long long N)
 178     : Key(Key), Val(itostr(N)) {}
 179
 180 DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, unsigned N)
 181     : Key(Key), Val(utostr(N)) {}
 182
 183 DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key,
 184                                                    unsigned long N)
 185     : Key(Key), Val(utostr(N)) {}
 186
 187 DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key,
 188                                                    unsigned long long N)
 189     : Key(Key), Val(utostr(N)) {}
 190
 191 DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, DebugLoc Loc)
 192     : Key(Key), Loc(Loc) {
 193   if (Loc) {
 194     Val = (Loc->getFilename() + ":" + Twine(Loc.getLine()) + ":" +
 195            Twine(Loc.getCol())).str();
 196   } else {
 197     Val = "<UNKNOWN LOCATION>";
 198   }
 199 }
 200
 201 void DiagnosticInfoOptimizationBase::print(DiagnosticPrinter &DP) const {
 202   DP << getLocationStr() << ": " << getMsg();
 203   if (Hotness)
 204     DP << " (hotness: " << *Hotness << ")";
 205 }
 206
 207 OptimizationRemark::OptimizationRemark(const char *PassName,
 208                                        StringRef RemarkName,
 209                                        const DiagnosticLocation &Loc,
 210                                        const Value *CodeRegion)
 211     : DiagnosticInfoIROptimization(
 212           DK_OptimizationRemark, DS_Remark, PassName, RemarkName,
 213           *cast<BasicBlock>(CodeRegion)->getParent(), Loc, CodeRegion) {}
 214
 215 OptimizationRemark::OptimizationRemark(const char *PassName,
 216                                        StringRef RemarkName,
 217                                        const Instruction *Inst)
 218     : DiagnosticInfoIROptimization(DK_OptimizationRemark, DS_Remark, PassName,
 219                                    RemarkName, *Inst->getParent()->getParent(),
 220                                    Inst->getDebugLoc(), Inst->getParent()) {}
 221
 222 // Helper to allow for an assert before attempting to return an invalid
 223 // reference.
 224 static const BasicBlock &getFirstFunctionBlock(const Function *Func) {
 225   assert(!Func->empty() && "Function does not have a body");
 226   return Func->front();
 227 }
 228
 229 OptimizationRemark::OptimizationRemark(const char *PassName,
 230                                        StringRef RemarkName,
 231                                        const Function *Func)
 232     : DiagnosticInfoIROptimization(DK_OptimizationRemark, DS_Remark, PassName,
 233                                    RemarkName, *Func, Func->getSubprogram(),
 234                                    &getFirstFunctionBlock(Func)) {}
 235
 236 bool OptimizationRemark::isEnabled() const {
 237   const Function &Fn = getFunction();
 238   LLVMContext &Ctx = Fn.getContext();
 239   return Ctx.getDiagHandlerPtr()->isPassedOptRemarkEnabled(getPassName());
 240 }
 241
 242 OptimizationRemarkMissed::OptimizationRemarkMissed(
 243     const char *PassName, StringRef RemarkName, const DiagnosticLocation &Loc,
 244     const Value *CodeRegion)
 245     : DiagnosticInfoIROptimization(
 246           DK_OptimizationRemarkMissed, DS_Remark, PassName, RemarkName,
 247           *cast<BasicBlock>(CodeRegion)->getParent(), Loc, CodeRegion) {}
 248
 249 OptimizationRemarkMissed::OptimizationRemarkMissed(const char *PassName,
 250                                                    StringRef RemarkName,
 251                                                    const Instruction *Inst)
 252     : DiagnosticInfoIROptimization(DK_OptimizationRemarkMissed, DS_Remark,
 253                                    PassName, RemarkName,
 254                                    *Inst->getParent()->getParent(),
 255                                    Inst->getDebugLoc(), Inst->getParent()) {}
 256
 257 bool OptimizationRemarkMissed::isEnabled() const {
 258   const Function &Fn = getFunction();
 259   LLVMContext &Ctx = Fn.getContext();
 260   return Ctx.getDiagHandlerPtr()->isMissedOptRemarkEnabled(getPassName());
 261 }
 262
 263 OptimizationRemarkAnalysis::OptimizationRemarkAnalysis(
 264     const char *PassName, StringRef RemarkName, const DiagnosticLocation &Loc,
 265     const Value *CodeRegion)
 266     : DiagnosticInfoIROptimization(
 267           DK_OptimizationRemarkAnalysis, DS_Remark, PassName, RemarkName,
 268           *cast<BasicBlock>(CodeRegion)->getParent(), Loc, CodeRegion) {}
 269
 270 OptimizationRemarkAnalysis::OptimizationRemarkAnalysis(const char *PassName,
 271                                                        StringRef RemarkName,
 272                                                        const Instruction *Inst)
 273     : DiagnosticInfoIROptimization(DK_OptimizationRemarkAnalysis, DS_Remark,
 274                                    PassName, RemarkName,
 275                                    *Inst->getParent()->getParent(),
 276                                    Inst->getDebugLoc(), Inst->getParent()) {}
 277
 278 OptimizationRemarkAnalysis::OptimizationRemarkAnalysis(
 279     enum DiagnosticKind Kind, const char *PassName, StringRef RemarkName,
 280     const DiagnosticLocation &Loc, const Value *CodeRegion)
 281     : DiagnosticInfoIROptimization(Kind, DS_Remark, PassName, RemarkName,
 282                                    *cast<BasicBlock>(CodeRegion)->getParent(),
 283                                    Loc, CodeRegion) {}
 284
 285 bool OptimizationRemarkAnalysis::isEnabled() const {
 286   const Function &Fn = getFunction();
 287   LLVMContext &Ctx = Fn.getContext();
 288   return Ctx.getDiagHandlerPtr()->isAnalysisRemarkEnabled(getPassName()) ||
 289          shouldAlwaysPrint();
 290 }
 291
 292 void DiagnosticInfoMIRParser::print(DiagnosticPrinter &DP) const {
 293   DP << Diagnostic;
 294 }
 295
 296 DiagnosticInfoOptimizationFailure::DiagnosticInfoOptimizationFailure(
 297     const char *PassName, StringRef RemarkName, const DiagnosticLocation &Loc,
 298     const Value *CodeRegion)
 299     : DiagnosticInfoIROptimization(
 300           DK_OptimizationFailure, DS_Warning, PassName, RemarkName,
 301           *cast<BasicBlock>(CodeRegion)->getParent(), Loc, CodeRegion) {}
 302
 303 bool DiagnosticInfoOptimizationFailure::isEnabled() const {
 304   // Only print warnings.
 305   return getSeverity() == DS_Warning;
 306 }
 307
 308 void DiagnosticInfoUnsupported::print(DiagnosticPrinter &DP) const {
 309   std::string Str;
 310   raw_string_ostream OS(Str);
 311
 312   OS << getLocationStr() << ": in function " << getFunction().getName() << ' '
 313      << *getFunction().getFunctionType() << ": " << Msg << '\n';
 314   OS.flush();
 315   DP << Str;
 316 }
 317
 318 void DiagnosticInfoISelFallback::print(DiagnosticPrinter &DP) const {
 319   DP << "Instruction selection used fallback path for " << getFunction();
 320 }
 321
 322 void DiagnosticInfoOptimizationBase::insert(StringRef S) {
 323   Args.emplace_back(S);
 324 }
 325
 326 void DiagnosticInfoOptimizationBase::insert(Argument A) {
 327   Args.push_back(std::move(A));
 328 }
 329
 330 void DiagnosticInfoOptimizationBase::insert(setIsVerbose V) {
 331   IsVerbose = true;
 332 }
 333
 334 void DiagnosticInfoOptimizationBase::insert(setExtraArgs EA) {
 335   FirstExtraArgIndex = Args.size();
 336 }
 337
 338 std::string DiagnosticInfoOptimizationBase::getMsg() const {
 339   std::string Str;
 340   raw_string_ostream OS(Str);
 341   for (const DiagnosticInfoOptimizationBase::Argument &Arg :
 342        make_range(Args.begin(), FirstExtraArgIndex == -1
 343                                     ? Args.end()
 344                                     : Args.begin() + FirstExtraArgIndex))
 345     OS << Arg.Val;
 346   return OS.str();
 347 }
 348
 349 namespace llvm {
 350 namespace yaml {
 351
 352 void MappingTraits<DiagnosticInfoOptimizationBase *>::mapping(
 353     IO &io, DiagnosticInfoOptimizationBase *&OptDiag) {
 354   assert(io.outputting() && "input not yet implemented");
 355
 356   if (io.mapTag("!Passed",
 357                 (OptDiag->getKind() == DK_OptimizationRemark ||
 358                  OptDiag->getKind() == DK_MachineOptimizationRemark)))
 359     ;
 360   else if (io.mapTag(
 361                "!Missed",
 362                (OptDiag->getKind() == DK_OptimizationRemarkMissed ||
 363                 OptDiag->getKind() == DK_MachineOptimizationRemarkMissed)))
 364     ;
 365   else if (io.mapTag(
 366                "!Analysis",
 367                (OptDiag->getKind() == DK_OptimizationRemarkAnalysis ||
 368                 OptDiag->getKind() == DK_MachineOptimizationRemarkAnalysis)))
 369     ;
 370   else if (io.mapTag("!AnalysisFPCommute",
 371                      OptDiag->getKind() ==
 372                          DK_OptimizationRemarkAnalysisFPCommute))
 373     ;
 374   else if (io.mapTag("!AnalysisAliasing",
 375                      OptDiag->getKind() ==
 376                          DK_OptimizationRemarkAnalysisAliasing))
 377     ;
 378   else if (io.mapTag("!Failure", OptDiag->getKind() == DK_OptimizationFailure))
 379     ;
 380   else
 381     llvm_unreachable("Unknown remark type");
 382
 383   // These are read-only for now.
 384   DiagnosticLocation DL = OptDiag->getLocation();
 385   StringRef FN =
 386       GlobalValue::dropLLVMManglingEscape(OptDiag->getFunction().getName());
 387
 388   StringRef PassName(OptDiag->PassName);
 389   io.mapRequired("Pass", PassName);
 390   io.mapRequired("Name", OptDiag->RemarkName);
 391   if (!io.outputting() || DL.isValid())
 392     io.mapOptional("DebugLoc", DL);
 393   io.mapRequired("Function", FN);
 394   io.mapOptional("Hotness", OptDiag->Hotness);
 395   io.mapOptional("Args", OptDiag->Args);
 396 }
 397
 398 template <> struct MappingTraits<DiagnosticLocation> {
 399   static void mapping(IO &io, DiagnosticLocation &DL) {
 400     assert(io.outputting() && "input not yet implemented");
 401
 402     StringRef File = DL.getFilename();
 403     unsigned Line = DL.getLine();
 404     unsigned Col = DL.getColumn();
 405
 406     io.mapRequired("File", File);
 407     io.mapRequired("Line", Line);
 408     io.mapRequired("Column", Col);
 409   }
 410
 411   static const bool flow = true;
 412 };
 413
 414 // Implement this as a mapping for now to get proper quotation for the value.
 415 template <> struct MappingTraits<DiagnosticInfoOptimizationBase::Argument> {
 416   static void mapping(IO &io, DiagnosticInfoOptimizationBase::Argument &A) {
 417     assert(io.outputting() && "input not yet implemented");
 418     io.mapRequired(A.Key.data(), A.Val);
 419     if (A.Loc.isValid())
 420       io.mapOptional("DebugLoc", A.Loc);
 421   }
 422 };
 423
 424 } // end namespace yaml
 425 } // end namespace llvm
 426
 427 LLVM_YAML_IS_SEQUENCE_VECTOR(DiagnosticInfoOptimizationBase::Argument)