recommit 1b978dd [CUDA][HIP][OpenMP] Emit deferred diagnostics by a post-parsing AST travese

Differential Revision: https://reviews.llvm.org/D70172

Author: yxsamliu

clang/include/clang/Sema/ExternalSemaSource.h

@@ -193,6 +193,15 @@ class ExternalSemaSource : public ExternalASTSource {
       llvm::MapVector<const FunctionDecl *, std::unique_ptr<LateParsedTemplate>>
           &LPTMap) {}
 
+  /// Read the set of decls to be checked for deferred diags.
+  ///
+  /// The external source should append its own potentially emitted function
+  /// and variable decls which may cause deferred diags. Note that this routine
+  /// may be invoked multiple times; the external source should take care not to
+  /// introduce the same declarations repeatedly.
+  virtual void ReadDeclsToCheckForDeferredDiags(
+      llvm::SmallVector<Decl *, 4> &Decls) {}
+
   /// \copydoc Sema::CorrectTypo
   /// \note LookupKind must correspond to a valid Sema::LookupNameKind
   ///

clang/include/clang/Sema/MultiplexExternalSemaSource.h

@@ -332,6 +332,15 @@ class MultiplexExternalSemaSource : public ExternalSemaSource {
       llvm::MapVector<const FunctionDecl *, std::unique_ptr<LateParsedTemplate>>
           &LPTMap) override;
 
+  /// Read the set of decls to be checked for deferred diags.
+  ///
+  /// The external source should append its own potentially emitted function
+  /// and variable decls which may cause deferred diags. Note that this routine
+  /// may be invoked multiple times; the external source should take care not to
+  /// introduce the same declarations repeatedly.
+  void ReadDeclsToCheckForDeferredDiags(
+      llvm::SmallVector<Decl *, 4> &Decls) override;
+
   /// \copydoc ExternalSemaSource::CorrectTypo
   /// \note Returns the first nonempty correction.
   TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo,

clang/include/clang/Sema/Sema.h

@@ -1492,6 +1492,18 @@ class Sema final {
 
   void emitAndClearUnusedLocalTypedefWarnings();
 
+  private:
+    /// Function or variable declarations to be checked for whether the deferred
+    /// diagnostics should be emitted.
+    SmallVector<Decl *, 4> DeclsToCheckForDeferredDiags;
+
+  public:
+  // Emit all deferred diagnostics.
+  void emitDeferredDiags();
+  // Emit any deferred diagnostics for FD and erase them from the map in which
+  // they're stored.
+  void emitDeferredDiags(FunctionDecl *FD, bool ShowCallStack);
+
   enum TUFragmentKind {
     /// The global module fragment, between 'module;' and a module-declaration.
     Global,
@@ -3767,7 +3779,8 @@ class Sema final {
     TemplateDiscarded, // Discarded due to uninstantiated templates
     Unknown,
   };
-  FunctionEmissionStatus getEmissionStatus(FunctionDecl *Decl);
+  FunctionEmissionStatus getEmissionStatus(FunctionDecl *Decl,
+                                           bool Final = false);
 
   // Whether the callee should be ignored in CUDA/HIP/OpenMP host/device check.
   bool shouldIgnoreInHostDeviceCheck(FunctionDecl *Callee);
@@ -9767,22 +9780,10 @@ class Sema final {
   /// Pop OpenMP function region for non-capturing function.
   void popOpenMPFunctionRegion(const sema::FunctionScopeInfo *OldFSI);
 
-  /// Check whether we're allowed to call Callee from the current function.
-  void checkOpenMPDeviceFunction(SourceLocation Loc, FunctionDecl *Callee,
-                                 bool CheckForDelayedContext = true);
-
-  /// Check whether we're allowed to call Callee from the current function.
-  void checkOpenMPHostFunction(SourceLocation Loc, FunctionDecl *Callee,
-                               bool CheckCaller = true);
-
   /// Check if the expression is allowed to be used in expressions for the
   /// OpenMP devices.
   void checkOpenMPDeviceExpr(const Expr *E);
 
-  /// Finishes analysis of the deferred functions calls that may be declared as
-  /// host/nohost during device/host compilation.
-  void finalizeOpenMPDelayedAnalysis();
-
   /// Checks if a type or a declaration is disabled due to the owning extension
   /// being disabled, and emits diagnostic messages if it is disabled.
   /// \param D type or declaration to be checked.
@@ -9973,6 +9974,11 @@ class Sema final {
   void
   checkDeclIsAllowedInOpenMPTarget(Expr *E, Decl *D,
                                    SourceLocation IdLoc = SourceLocation());
+  /// Finishes analysis of the deferred functions calls that may be declared as
+  /// host/nohost during device/host compilation.
+  void finalizeOpenMPDelayedAnalysis(const FunctionDecl *Caller,
+                                     const FunctionDecl *Callee,
+                                     SourceLocation Loc);
   /// Return true inside OpenMP declare target region.
   bool isInOpenMPDeclareTargetContext() const {
     return DeclareTargetNestingLevel > 0;
@@ -11359,18 +11365,6 @@ class Sema final {
                  /* Caller = */ FunctionDeclAndLoc>
       DeviceKnownEmittedFns;
 
-  /// A partial call graph maintained during CUDA/OpenMP device code compilation
-  /// to support deferred diagnostics.
-  ///
-  /// Functions are only added here if, at the time they're considered, they are
-  /// not known-emitted.  As soon as we discover that a function is
-  /// known-emitted, we remove it and everything it transitively calls from this
-  /// set and add those functions to DeviceKnownEmittedFns.
-  llvm::DenseMap</* Caller = */ CanonicalDeclPtr<FunctionDecl>,
-                 /* Callees = */ llvm::MapVector<CanonicalDeclPtr<FunctionDecl>,
-                                                 SourceLocation>>
-      DeviceCallGraph;
-
   /// Diagnostic builder for CUDA/OpenMP devices errors which may or may not be
   /// deferred.
   ///
@@ -11445,14 +11439,6 @@ class Sema final {
     llvm::Optional<unsigned> PartialDiagId;
   };
 
-  /// Indicate that this function (and thus everything it transtively calls)
-  /// will be codegen'ed, and emit any deferred diagnostics on this function and
-  /// its (transitive) callees.
-  void markKnownEmitted(
-      Sema &S, FunctionDecl *OrigCaller, FunctionDecl *OrigCallee,
-      SourceLocation OrigLoc,
-      const llvm::function_ref<bool(Sema &, FunctionDecl *)> IsKnownEmitted);
-
   /// Creates a DeviceDiagBuilder that emits the diagnostic if the current context
   /// is "used as device code".
   ///

clang/include/clang/Serialization/ASTBitCodes.h

@@ -650,7 +650,10 @@ namespace serialization {
       PP_CONDITIONAL_STACK = 62,
 
       /// A table of skipped ranges within the preprocessing record.
-      PPD_SKIPPED_RANGES = 63
+      PPD_SKIPPED_RANGES = 63,
+
+      /// Record code for the Decls to be checked for deferred diags.
+      DECLS_TO_CHECK_FOR_DEFERRED_DIAGS = 64,
     };
 
     /// Record types used within a source manager block.

clang/include/clang/Serialization/ASTReader.h

@@ -890,6 +890,12 @@ class ASTReader
   // A list of late parsed template function data.
   SmallVector<uint64_t, 1> LateParsedTemplates;
 
+  /// The IDs of all decls to be checked for deferred diags.
+  ///
+  /// Sema tracks these to emit deferred diags.
+  SmallVector<uint64_t, 4> DeclsToCheckForDeferredDiags;
+
+
 public:
   struct ImportedSubmodule {
     serialization::SubmoduleID ID;
@@ -1983,6 +1989,9 @@ class ASTReader
   void ReadUnusedLocalTypedefNameCandidates(
       llvm::SmallSetVector<const TypedefNameDecl *, 4> &Decls) override;
 
+  void ReadDeclsToCheckForDeferredDiags(
+      llvm::SmallVector<Decl *, 4> &Decls) override;
+
   void ReadReferencedSelectors(
            SmallVectorImpl<std::pair<Selector, SourceLocation>> &Sels) override;
 

clang/lib/Sema/MultiplexExternalSemaSource.cpp

@@ -275,6 +275,12 @@ void MultiplexExternalSemaSource::ReadExtVectorDecls(
     Sources[i]->ReadExtVectorDecls(Decls);
 }
 
+void MultiplexExternalSemaSource::ReadDeclsToCheckForDeferredDiags(
+    llvm::SmallVector<Decl *, 4> &Decls) {
+  for(size_t i = 0; i < Sources.size(); ++i)
+    Sources[i]->ReadDeclsToCheckForDeferredDiags(Decls);
+}
+
 void MultiplexExternalSemaSource::ReadUnusedLocalTypedefNameCandidates(
     llvm::SmallSetVector<const TypedefNameDecl *, 4> &Decls) {
   for(size_t i = 0; i < Sources.size(); ++i)

clang/lib/Sema/Sema.cpp

@@ -11,6 +11,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "UsedDeclVisitor.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTDiagnostic.h"
 #include "clang/AST/DeclCXX.h"
@@ -955,9 +956,7 @@ void Sema::ActOnEndOfTranslationUnitFragment(TUFragmentKind Kind) {
     PerformPendingInstantiations();
   }
 
-  // Finalize analysis of OpenMP-specific constructs.
-  if (LangOpts.OpenMP)
-    finalizeOpenMPDelayedAnalysis();
+  emitDeferredDiags();
 
   assert(LateParsedInstantiations.empty() &&
          "end of TU template instantiation should not create more "
@@ -1452,27 +1451,108 @@ static void emitCallStackNotes(Sema &S, FunctionDecl *FD) {
 
 // Emit any deferred diagnostics for FD and erase them from the map in which
 // they're stored.
-static void emitDeferredDiags(Sema &S, FunctionDecl *FD, bool ShowCallStack) {
-  auto It = S.DeviceDeferredDiags.find(FD);
-  if (It == S.DeviceDeferredDiags.end())
+void Sema::emitDeferredDiags(FunctionDecl *FD, bool ShowCallStack) {
+  auto It = DeviceDeferredDiags.find(FD);
+  if (It == DeviceDeferredDiags.end())
     return;
   bool HasWarningOrError = false;
+  bool FirstDiag = true;
   for (PartialDiagnosticAt &PDAt : It->second) {
     const SourceLocation &Loc = PDAt.first;
     const PartialDiagnostic &PD = PDAt.second;
-    HasWarningOrError |= S.getDiagnostics().getDiagnosticLevel(
+    HasWarningOrError |= getDiagnostics().getDiagnosticLevel(
                              PD.getDiagID(), Loc) >= DiagnosticsEngine::Warning;
-    DiagnosticBuilder Builder(S.Diags.Report(Loc, PD.getDiagID()));
-    Builder.setForceEmit();
-    PD.Emit(Builder);
+    {
+      DiagnosticBuilder Builder(Diags.Report(Loc, PD.getDiagID()));
+      Builder.setForceEmit();
+      PD.Emit(Builder);
+    }
+
+    // Emit the note on the first diagnostic in case too many diagnostics cause
+    // the note not emitted.
+    if (FirstDiag && HasWarningOrError && ShowCallStack) {
+      emitCallStackNotes(*this, FD);
+      FirstDiag = false;
+    }
   }
-  S.DeviceDeferredDiags.erase(It);
 
-  // FIXME: Should this be called after every warning/error emitted in the loop
-  // above, instead of just once per function?  That would be consistent with
-  // how we handle immediate errors, but it also seems like a bit much.
-  if (HasWarningOrError && ShowCallStack)
-    emitCallStackNotes(S, FD);
+}
+
+namespace {
+/// Helper class that emits deferred diagnostic messages if an entity directly
+/// or indirectly using the function that causes the deferred diagnostic
+/// messages is known to be emitted.
+class DeferredDiagnosticsEmitter
+    : public UsedDeclVisitor<DeferredDiagnosticsEmitter> {
+public:
+  typedef UsedDeclVisitor<DeferredDiagnosticsEmitter> Inherited;
+  llvm::SmallSet<CanonicalDeclPtr<Decl>, 4> Visited;
+  llvm::SmallVector<CanonicalDeclPtr<FunctionDecl>, 4> UseStack;
+  bool ShouldEmit;
+  unsigned InOMPDeviceContext;
+
+  DeferredDiagnosticsEmitter(Sema &S)
+      : Inherited(S), ShouldEmit(false), InOMPDeviceContext(0) {}
+
+  void VisitOMPTargetDirective(OMPTargetDirective *Node) {
+    ++InOMPDeviceContext;
+    Inherited::VisitOMPTargetDirective(Node);
+    --InOMPDeviceContext;
+  }
+
+  void visitUsedDecl(SourceLocation Loc, Decl *D) {
+    if (auto *FD = dyn_cast<FunctionDecl>(D)) {
+      FunctionDecl *Caller = UseStack.empty() ? nullptr : UseStack.back();
+      auto IsKnownEmitted = S.getEmissionStatus(FD, /*Final=*/true) ==
+                            Sema::FunctionEmissionStatus::Emitted;
+      if (!Caller)
+        ShouldEmit = IsKnownEmitted;
+      if ((!ShouldEmit && !S.getLangOpts().OpenMP && !Caller) ||
+          S.shouldIgnoreInHostDeviceCheck(FD) || Visited.count(D))
+        return;
+      // Finalize analysis of OpenMP-specific constructs.
+      if (Caller && S.LangOpts.OpenMP && UseStack.size() == 1)
+        S.finalizeOpenMPDelayedAnalysis(Caller, FD, Loc);
+      if (Caller)
+        S.DeviceKnownEmittedFns[FD] = {Caller, Loc};
+      if (ShouldEmit || InOMPDeviceContext)
+        S.emitDeferredDiags(FD, Caller);
+      Visited.insert(D);
+      UseStack.push_back(FD);
+      if (auto *S = FD->getBody()) {
+        this->Visit(S);
+      }
+      UseStack.pop_back();
+      Visited.erase(D);
+    } else if (auto *VD = dyn_cast<VarDecl>(D)) {
+      if (auto *Init = VD->getInit()) {
+        auto DevTy = OMPDeclareTargetDeclAttr::getDeviceType(VD);
+        bool IsDev = DevTy && (*DevTy == OMPDeclareTargetDeclAttr::DT_NoHost ||
+                               *DevTy == OMPDeclareTargetDeclAttr::DT_Any);
+        if (IsDev)
+          ++InOMPDeviceContext;
+        this->Visit(Init);
+        if (IsDev)
+          --InOMPDeviceContext;
+      }
+    } else
+      Inherited::visitUsedDecl(Loc, D);
+  }
+};
+} // namespace
+
+void Sema::emitDeferredDiags() {
+  if (ExternalSource)
+    ExternalSource->ReadDeclsToCheckForDeferredDiags(
+        DeclsToCheckForDeferredDiags);
+
+  if ((DeviceDeferredDiags.empty() && !LangOpts.OpenMP) ||
+      DeclsToCheckForDeferredDiags.empty())
+    return;
+
+  DeferredDiagnosticsEmitter DDE(*this);
+  for (auto D : DeclsToCheckForDeferredDiags)
+    DDE.visitUsedDecl(SourceLocation(), D);
 }
 
 // In CUDA, there are some constructs which may appear in semantically-valid
@@ -1545,71 +1625,6 @@ Sema::DeviceDiagBuilder::~DeviceDiagBuilder() {
   }
 }
 
-// Indicate that this function (and thus everything it transtively calls) will
-// be codegen'ed, and emit any deferred diagnostics on this function and its
-// (transitive) callees.
-void Sema::markKnownEmitted(
-    Sema &S, FunctionDecl *OrigCaller, FunctionDecl *OrigCallee,
-    SourceLocation OrigLoc,
-    const llvm::function_ref<bool(Sema &, FunctionDecl *)> IsKnownEmitted) {
-  // Nothing to do if we already know that FD is emitted.
-  if (IsKnownEmitted(S, OrigCallee)) {
-    assert(!S.DeviceCallGraph.count(OrigCallee));
-    return;
-  }
-
-  // We've just discovered that OrigCallee is known-emitted.  Walk our call
-  // graph to see what else we can now discover also must be emitted.
-
-  struct CallInfo {
-    FunctionDecl *Caller;
-    FunctionDecl *Callee;
-    SourceLocation Loc;
-  };
-  llvm::SmallVector<CallInfo, 4> Worklist = {{OrigCaller, OrigCallee, OrigLoc}};
-  llvm::SmallSet<CanonicalDeclPtr<FunctionDecl>, 4> Seen;
-  Seen.insert(OrigCallee);
-  while (!Worklist.empty()) {
-    CallInfo C = Worklist.pop_back_val();
-    assert(!IsKnownEmitted(S, C.Callee) &&
-           "Worklist should not contain known-emitted functions.");
-    S.DeviceKnownEmittedFns[C.Callee] = {C.Caller, C.Loc};
-    emitDeferredDiags(S, C.Callee, C.Caller);
-
-    // If this is a template instantiation, explore its callgraph as well:
-    // Non-dependent calls are part of the template's callgraph, while dependent
-    // calls are part of to the instantiation's call graph.
-    if (auto *Templ = C.Callee->getPrimaryTemplate()) {
-      FunctionDecl *TemplFD = Templ->getAsFunction();
-      if (!Seen.count(TemplFD) && !S.DeviceKnownEmittedFns.count(TemplFD)) {
-        Seen.insert(TemplFD);
-        Worklist.push_back(
-            {/* Caller = */ C.Caller, /* Callee = */ TemplFD, C.Loc});
-      }
-    }
-
-    // Add all functions called by Callee to our worklist.
-    auto CGIt = S.DeviceCallGraph.find(C.Callee);
-    if (CGIt == S.DeviceCallGraph.end())
-      continue;
-
-    for (std::pair<CanonicalDeclPtr<FunctionDecl>, SourceLocation> FDLoc :
-         CGIt->second) {
-      FunctionDecl *NewCallee = FDLoc.first;
-      SourceLocation CallLoc = FDLoc.second;
-      if (Seen.count(NewCallee) || IsKnownEmitted(S, NewCallee))
-        continue;
-      Seen.insert(NewCallee);
-      Worklist.push_back(
-          {/* Caller = */ C.Callee, /* Callee = */ NewCallee, CallLoc});
-    }
-
-    // C.Callee is now known-emitted, so we no longer need to maintain its list
-    // of callees in DeviceCallGraph.
-    S.DeviceCallGraph.erase(CGIt);
-  }
-}
-
 Sema::DeviceDiagBuilder Sema::targetDiag(SourceLocation Loc, unsigned DiagID) {
   if (LangOpts.OpenMP)
     return LangOpts.OpenMPIsDevice ? diagIfOpenMPDeviceCode(Loc, DiagID)