rework change to rely on pragma intrinsic

Signed-off-by: Sarnie, Nick <[email protected]>

Author: sarnex

clang/include/clang/Sema/Sema.h

@@ -1825,6 +1825,11 @@ class Sema final : public SemaBase {
   /// Set of no-builtin functions listed by \#pragma function.
   llvm::SmallSetVector<StringRef, 4> MSFunctionNoBuiltins;
 
+  /// Map of BuiltinIDs to source locations that have #pragma intrinsic calls
+  /// that refer to them.
+  llvm::DenseMap<unsigned, llvm::SmallSetVector<SourceLocation, 4>>
+      PragmaIntrinsicBuiltinIDMap;
+
   /// AddAlignmentAttributesForRecord - Adds any needed alignment attributes to
   /// a the record decl, to handle '\#pragma pack' and '\#pragma options align'.
   void AddAlignmentAttributesForRecord(RecordDecl *RD);
@@ -4345,6 +4350,11 @@ class Sema final : public SemaBase {
   /// contain non-field names.
   Scope *getNonFieldDeclScope(Scope *S);
 
+  // Determine if the given builtin usage at the given source location
+  // was previously specified in a #pragma intrinsic.
+  bool isBuiltinSpecifiedInPragmaIntrinsic(unsigned BuiltinID,
+                                           SourceLocation UsageLoc) const;
+
   FunctionDecl *CreateBuiltin(IdentifierInfo *II, QualType Type, unsigned ID,
                               SourceLocation Loc);
 

clang/lib/Parse/ParsePragma.cpp

@@ -301,9 +301,13 @@ struct PragmaMSRuntimeChecksHandler : public EmptyPragmaHandler {
 };
 
 struct PragmaMSIntrinsicHandler : public PragmaHandler {
-  PragmaMSIntrinsicHandler() : PragmaHandler("intrinsic") {}
+  PragmaMSIntrinsicHandler(Sema &Actions)
+      : PragmaHandler("intrinsic"), Actions(Actions) {}
   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
                     Token &FirstToken) override;
+
+private:
+  Sema &Actions;
 };
 
 // "\#pragma fenv_access (on)".
@@ -517,7 +521,7 @@ void Parser::initializePragmaHandlers() {
     PP.AddPragmaHandler(MSOptimize.get());
     MSRuntimeChecks = std::make_unique<PragmaMSRuntimeChecksHandler>();
     PP.AddPragmaHandler(MSRuntimeChecks.get());
-    MSIntrinsic = std::make_unique<PragmaMSIntrinsicHandler>();
+    MSIntrinsic = std::make_unique<PragmaMSIntrinsicHandler>(Actions);
     PP.AddPragmaHandler(MSIntrinsic.get());
     MSFenvAccess = std::make_unique<PragmaMSFenvAccessHandler>();
     PP.AddPragmaHandler(MSFenvAccess.get());
@@ -3803,7 +3807,10 @@ void PragmaMSIntrinsicHandler::HandlePragma(Preprocessor &PP,
     if (!II->getBuiltinID())
       PP.Diag(Tok.getLocation(), diag::warn_pragma_intrinsic_builtin)
           << II << SuggestIntrinH;
-
+    /// Store the location at which the builtin was used in a #pragma intrinsic
+    /// so we don't emit a missing header warning later.
+    Actions.PragmaIntrinsicBuiltinIDMap[II->getBuiltinID()].insert(
+        Tok.getLocation());
     PP.Lex(Tok);
     if (Tok.isNot(tok::comma))
       break;

clang/lib/Sema/SemaDecl.cpp

@@ -2299,6 +2299,21 @@ static StringRef getHeaderName(Builtin::Context &BuiltinInfo, unsigned ID,
   llvm_unreachable("unhandled error kind");
 }
 
+bool Sema::isBuiltinSpecifiedInPragmaIntrinsic(unsigned BuiltinID,
+                                               SourceLocation UsageLoc) const {
+  assert(Context.BuiltinInfo(BuiltinID) && "Invalid builtin id");
+  assert(UsageLoc.isValid() && "Invalid source location");
+  auto It = PragmaIntrinsicBuiltinIDMap.find(BuiltinID);
+  if (It == PragmaIntrinsicBuiltinIDMap.end())
+    return false;
+  for (const SourceLocation &PragmaIntrinLoc : It->second) {
+    if (Context.getSourceManager().isBeforeInTranslationUnit(PragmaIntrinLoc,
+                                                             UsageLoc))
+      return true;
+  }
+  return false;
+}
+
 FunctionDecl *Sema::CreateBuiltin(IdentifierInfo *II, QualType Type,
                                   unsigned ID, SourceLocation Loc) {
   DeclContext *Parent = Context.getTranslationUnitDecl();
@@ -2370,20 +2385,17 @@ NamedDecl *Sema::LazilyCreateBuiltin(IdentifierInfo *II, unsigned ID,
 
     // Generally, we emit a warning that the declaration requires the
     // appropriate header.
-    Diag(Loc, diag::warn_implicit_decl_requires_sysheader)
-        << getHeaderName(Context.BuiltinInfo, ID, Error)
-        << Context.BuiltinInfo.getName(ID);
+    if (!isBuiltinSpecifiedInPragmaIntrinsic(ID, Loc))
+      Diag(Loc, diag::warn_implicit_decl_requires_sysheader)
+          << getHeaderName(Context.BuiltinInfo, ID, Error)
+          << Context.BuiltinInfo.getName(ID);
     return nullptr;
   }
 
-  // Warn for implicit uses of header dependent libraries,
-  // except in system headers.
   if (!ForRedeclaration &&
       (Context.BuiltinInfo.isPredefinedLibFunction(ID) ||
        Context.BuiltinInfo.isHeaderDependentFunction(ID)) &&
-      (!getDiagnostics().getSuppressSystemWarnings() ||
-       !Context.getSourceManager().isInSystemHeader(
-           Context.getSourceManager().getSpellingLoc(Loc)))) {
+      !isBuiltinSpecifiedInPragmaIntrinsic(ID, Loc)) {
     Diag(Loc, LangOpts.C99 ? diag::ext_implicit_lib_function_decl_c99
                            : diag::ext_implicit_lib_function_decl)
         << Context.BuiltinInfo.getName(ID) << R;

clang/test/Sema/Inputs/builtin-system-header.h

@@ -1 +1,9 @@
+#ifdef USE_PRAGMA_BEFORE
+#pragma intrinsic(_InterlockedOr64)
+#endif
+
 #define MACRO(x,y) _InterlockedOr64(x,y);
+
+#ifdef USE_PRAGMA_AFTER
+#pragma intrinsic(_InterlockedOr64)
+#endif

clang/test/Sema/builtin-pragma-intrinsic.c

@@ -0,0 +1,25 @@
+// RUN: %clang_cc1 -fms-extensions -fsyntax-only -verify -triple arm64-windows -isystem %S/Inputs %s -DUSE_PRAGMA_BEFORE
+// RUN: %clang_cc1 -fms-extensions -fsyntax-only -verify -triple arm64-windows -isystem %S/Inputs %s -DUSE_PRAGMA_AFTER
+// RUN: %clang_cc1 -fms-extensions -fsyntax-only -verify -triple arm64-windows -isystem %S/Inputs %s -DUSE_PRAGMA_AFTER_USE
+// RUN: %clang_cc1 -fms-extensions -fsyntax-only -verify -triple arm64-windows -isystem %S/Inputs %s -DUSE_PRAGMA_SAME_FILE
+// RUN: %clang_cc1 -fms-extensions -fsyntax-only -verify -triple arm64-windows -isystem %S/Inputs %s
+
+#if defined(USE_PRAGMA_BEFORE) || defined(USE_PRAGMA_AFTER) || defined(USE_PRAGMA_SAME_FILE)
+// expected-no-diagnostics
+#else
+// expected-error@+10 {{call to undeclared library function '_InterlockedOr64'}}
+// expected-note@+9 {{include the header <intrin.h> or explicitly provide a declaration for '_InterlockedOr64'}}
+#endif
+#include <builtin-system-header.h>
+
+#ifdef USE_PRAGMA_SAME_FILE
+#pragma intrinsic(_InterlockedOr64)
+#endif
+
+void foo() {
+  MACRO(0,0);
+}
+
+#ifdef USE_PRAGMA_AFTER_USE
+#pragma intrinsic(_InterlockedOr64)
+#endif