WIP

[nickdesaulniers]

Summary

Rather than have a "srcloc" associated with each call of dontcall-warn
or dontcall-error attributed function, we could reuse the existing
DILocation metadata (if it's emitted).

TODO: child commit that converts to emitting such DILocations.
TODO: remove mention of srcloc from langref.
TODO: update tests.
TODO: make clang stop emitting srcloc.

Alternative to
https://reviews.llvm.org/D141451

[nickdesaulniers]

• add link

[nickdesaulniers]

• drop hunk

[nickdesaulniers]

• redrop hunk

clang/include/clang/Basic/CodeGenOptions.def

 
 /// The threshold to put data into small data section.
 VALUE_CODEGENOPT(SmallDataLimit, 32, 0)
 
 /// The lower bound for a buffer to be considered for stack protection.
 VALUE_CODEGENOPT(SSPBufferSize, 32, 0)
 
 /// The kind of generated debug info.
-ENUM_CODEGENOPT(DebugInfo, codegenoptions::DebugInfoKind, 4, codegenoptions::NoDebugInfo)
+/// DO NOT COMMIT
+ENUM_CODEGENOPT(DebugInfo, codegenoptions::DebugInfoKind, 4, codegenoptions::LocTrackingOnly)
 
 /// Whether to generate macro debug info.
 CODEGENOPT(MacroDebugInfo, 1, 0)
 
 /// Tune the debug info for this debugger.
 ENUM_CODEGENOPT(DebuggerTuning, llvm::DebuggerKind, 3,
                 llvm::DebuggerKind::Default)
 

clang/include/clang/Basic/DiagnosticFrontendKinds.td

 def err_fe_backend_unsupported : Error<"%0">, BackendInfo;
 def warn_fe_backend_unsupported : Warning<"%0">, BackendInfo;
 
 def err_fe_backend_error_attr :
   Error<"call to '%0' declared with 'error' attribute: %1">, BackendInfo;
 def warn_fe_backend_warning_attr :
   Warning<"call to '%0' declared with 'warning' attribute: %1">, BackendInfo,
   InGroup<BackendWarningAttributes>;
+def note_fe_backend_inlined : Note<"In '%0' which inlined '%1'">;
+def note_fe_backend_inlined2 : Note<"In '%0' which called '%1'">;
 
 def err_fe_invalid_code_complete_file : Error<
     "cannot locate code-completion file %0">, DefaultFatal;
 def err_fe_dependency_file_requires_MT : Error<
     "-dependency-file requires at least one -MT or -MQ option">;
 def err_fe_invalid_plugin_name : Error<
     "unable to find plugin '%0'">;
 def err_fe_expected_compiler_job : Error<

clang/lib/CodeGen/CodeGenAction.cpp

EmitOptimizationMessage(
         D, diag::remark_fe_backend_optimization_remark_analysis_aliasing);
 }
 
 void BackendConsumer::OptimizationFailureHandler(
     const llvm::DiagnosticInfoOptimizationFailure &D) {
   EmitOptimizationMessage(D, diag::warn_fe_backend_optimization_failure);
 }
 
-void BackendConsumer::DontCallDiagHandler(const DiagnosticInfoDontCall &D) {
-  SourceLocation LocCookie =
-      SourceLocation::getFromRawEncoding(D.getLocCookie());
+static StringRef getName(DILocation *L) {
+  if (L)
+    if (DILocalScope *S = L->getScope())
+      if (DISubprogram *P = S->getSubprogram())
+        return P->getName();
+  return "";
+}
 
-  // FIXME: we can't yet diagnose indirect calls. When/if we can, we
-  // should instead assert that LocCookie.isValid().
-  if (!LocCookie.isValid())
-    return;
+void BackendConsumer::DontCallDiagHandler(const DiagnosticInfoDontCall &D) {
+  SourceManager &SourceMgr = Context->getSourceManager();
+  FileManager &FileMgr = SourceMgr.getFileManager();
+  const DebugLoc &DL = D.getDebugLoc();
+  // TODO: getFilename should be added to DebugLoc interface.
+  llvm::ErrorOr<const FileEntry *> FE = FileMgr.getFile(DL->getFilename());
+  SourceLocation Loc =
+      SourceMgr.translateFileLineCol(*FE, DL.getLine(), DL.getCol());
 
-  Diags.Report(LocCookie, D.getSeverity() == DiagnosticSeverity::DS_Error
-                              ? diag::err_fe_backend_error_attr
-                              : diag::warn_fe_backend_warning_attr)
+  auto DiagType = D.getSeverity() == DiagnosticSeverity::DS_Error
+                      : diag::warn_fe_backend_warning_attr;
+  Diags.Report(Loc, DiagType)
       << llvm::demangle(D.getFunctionName().str()) << D.getNote();
+
+  llvm::SmallVector<DebugLoc, 8> DS = D.getInliningDecisions();
+
+  for (unsigned i = DS.size() - 1; i; --i) {
+    DebugLoc &DL = DS[i];
+    StringRef Caller = getName(DS[i].get());
+    StringRef Callee = getName(DS[i - 1].get());
+    Loc = SourceMgr.translateFileLineCol(*FE, DL.getLine(), DL.getCol());
+    Diags.Report(Loc, diag::note_fe_backend_inlined)
+        << llvm::demangle(Caller.str()) << llvm::demangle(Callee.str());
+  }
+  {
+    DebugLoc &DL = DS[0];
+    Loc = SourceMgr.translateFileLineCol(*FE, DL.getLine(), DL.getCol());
+    StringRef Caller = getName(DL.get());
+    StringRef Callee = D.getFunctionName();
+    Diags.Report(Loc, diag::note_fe_backend_inlined2)
+        << llvm::demangle(Caller.str()) << llvm::demangle(Callee.str());
+  }
 }
 
 void BackendConsumer::MisExpectDiagHandler(
     const llvm::DiagnosticInfoMisExpect &D) {
   StringRef Filename;
   unsigned Line, Column;
   bool BadDebugInfo = false;
   FullSourceLoc Loc =

llvm/include/llvm/IR/DiagnosticInfo.h

public:
   }
 };
 
 void diagnoseDontCall(const CallInst &CI);
 
 class DiagnosticInfoDontCall : public DiagnosticInfo {
   StringRef CalleeName;
   StringRef Note;
-  unsigned LocCookie;
+  const DebugLoc &DL;
 
 public:
   DiagnosticInfoDontCall(StringRef CalleeName, StringRef Note,
-                         DiagnosticSeverity DS, unsigned LocCookie)
+                         DiagnosticSeverity DS, const DebugLoc &Loc)
       : DiagnosticInfo(DK_DontCall, DS), CalleeName(CalleeName), Note(Note),
-        LocCookie(LocCookie) {}
+        DL(Loc) {}
   StringRef getFunctionName() const { return CalleeName; }
   StringRef getNote() const { return Note; }
-  unsigned getLocCookie() const { return LocCookie; }
+  const DebugLoc &getDebugLoc() const { return DL; }
   void print(DiagnosticPrinter &DP) const override;
   static bool classof(const DiagnosticInfo *DI) {
     return DI->getKind() == DK_DontCall;
   }
+  SmallVector<DebugLoc> getInliningDecisions() const;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_IR_DIAGNOSTICINFO_H

llvm/lib/IR/DiagnosticInfo.cpp

 void DiagnosticInfoMisExpect::print(DiagnosticPrinter &DP) const {
   DP << getLocationStr() << ": " << getMsg();
 }
 
 void OptimizationRemarkAnalysisFPCommute::anchor() {}
 void OptimizationRemarkAnalysisAliasing::anchor() {}
 
 void llvm::diagnoseDontCall(const CallInst &CI) {
-  const auto *F =
+  const auto *Callee =
       dyn_cast<Function>(CI.getCalledOperand()->stripPointerCasts());
 
-  if (!F)
+  if (!Callee)
     return;
 
   for (int i = 0; i != 2; ++i) {
     auto AttrName = i == 0 ? "dontcall-error" : "dontcall-warn";
     auto Sev = i == 0 ? DS_Error : DS_Warning;
 
-    if (F->hasFnAttribute(AttrName)) {
-      unsigned LocCookie = 0;
-      auto A = F->getFnAttribute(AttrName);
-      if (MDNode *MD = CI.getMetadata("srcloc"))
-        LocCookie =
-            mdconst::extract<ConstantInt>(MD->getOperand(0))->getZExtValue();
-      DiagnosticInfoDontCall D(F->getName(), A.getValueAsString(), Sev,
-                               LocCookie);
-      F->getContext().diagnose(D);
+    if (Callee->hasFnAttribute(AttrName)) {
+      auto A = Callee->getFnAttribute(AttrName);
+      DiagnosticInfoDontCall D(Callee->getName(), A.getValueAsString(), Sev,
+                               CI.getDebugLoc());
+      Callee->getContext().diagnose(D);
     }
   }
 }
 
 void DiagnosticInfoDontCall::print(DiagnosticPrinter &DP) const {
   DP << "call to " << demangle(getFunctionName().str())
      << " marked \"dontcall-";
   if (getSeverity() == DiagnosticSeverity::DS_Error)
     DP << "error\"";
   else
     DP << "warn\"";
   if (!getNote().empty())
     DP << ": " << getNote();
 }
+
+SmallVector<DebugLoc> DiagnosticInfoDontCall::getInliningDecisions() const {
+  SmallVector<DebugLoc, 8> Locs;
+  DILocation *DIL = getDebugLoc().get();
+  do {
+    Locs.emplace_back(DIL);
+  } while ((DIL = DIL->getInlinedAt()));
+  return Locs;
+}