[MSVC] Add support for pragma function

[steplong]

Summary

MSVC pragma function tells the compiler to generate calls to functions in the pragma function list, instead of using the builtin. Needs https://reviews.llvm.org/D124701

https://docs.microsoft.com/en-us/cpp/preprocessor/function-c-cpp?view=msvc-170

[hans]

From the MS docs:

Once a function pragma is seen, it takes effect at the first function definition that contains a specified intrinsic function. The effect continues to the end of the source file, or to the appearance of an intrinsic pragma specifying the same intrinsic function. You can only use the function pragma outside of a function, at the global level.

Should we try to handle the interaction between pragma intrinsic and pragma function, i.e. that the former "undoes" the latter? And should we error/warn if the pragma occurs not in namespace scope?

clang/include/clang/Sema/Sema.h

10319

Pass by const-ref maybe?

[steplong]

In D124702#3485475, @hans wrote:

From the MS docs:

Once a function pragma is seen, it takes effect at the first function definition that contains a specified intrinsic function. The effect continues to the end of the source file, or to the appearance of an intrinsic pragma specifying the same intrinsic function. You can only use the function pragma outside of a function, at the global level.

Should we try to handle the interaction between pragma intrinsic and pragma function, i.e. that the former "undoes" the latter? And should we error/warn if the pragma occurs not in namespace scope?

Oh I wasn't sure how to check if the function pragma was outside of a function. Yup, we can try to handle pragma intrinsic

[steplong]

Removed unnecessary braces (mentioned in the LLVM coding standard)

[hans]

And should we error/warn if the pragma occurs not in namespace scope?

Oh I wasn't sure how to check if the function pragma was outside of a function.

In the ActOn.. methods I think you can check what the CurContext is.

clang/lib/Parse/ParsePragma.cpp

3542

SmallVector would be more common LLVM style, I think. The ActOn.. methods could take the argument as a const-ref to SmallVectorImpl<StringRef>. This applies to the function pragma below as well.

3561

since the above is just a warning, we should probably still call the ActOn.. method?

3605

same as above: since it's just a warning, maybe we still want to call the ActOn.. method?

clang/lib/Sema/SemaAttr.cpp

1079

Do we want to avoid duplicates in MSFunctionNoBuiltins? Or maybe it doesn't matter?

[steplong]

Changed std::vector to llvm::SmallVector

[steplong]

clang/lib/Parse/ParsePragma.cpp

3561

Hmm, I'm not sure because all the msgs above are also warnings (diag::warn_)

clang/lib/Sema/SemaAttr.cpp

1079

Yea, I didn't think it really mattered. I originally wanted to use a set, but I needed the strings to be stored in contiguous memory for NoBuitinAttr::CreateImplicit() in Sema::AddRangeBasedNoBuiltin()

[steplong]

Error if pragma function/intrinsic is used inside a function

[hans]

It needs tests for the warnings about badly formed pragmas, and for pragmas outside file/namespace scope.

clang/lib/Parse/ParsePragma.cpp

3561

Yes, but for those, (missing left paren, or unknown intrinsic) it makes sense to do nothing. If it's just the right paren missing, I don't think it makes sense to ignore the intrinsic? Can you check how we handle similar situations with other intrinsics?

clang/lib/Sema/SemaAttr.cpp

1079

A set would be nicer conceptually of course.

How about using an llvm::SmallSetVector. That will solve the problem of duplicates, it will be deterministic, and you can use getArrayRef() to get the values in contiguous memory, or maybe being() and end() will work too.

[steplong]

In D124702#3496534, @hans wrote:

It needs tests for the warnings about badly formed pragmas, and for pragmas outside file/namespace scope.

Appreciate the comments. I have a couple of questions:

Is the tests for badly formed pragmas, clang/test/Preprocessor/pragma_microsoft.c?
It looks like MSVC only cares about it not being in a function like mentioned in the comments in D125011. Do we try to mimic MSVC behavior because MSVC rejects #pragma function(memset whichout the right paren?
MSVC also rejects #pragma function(foo) if foo isn't extern C or declared. We probably to match that behavior even if it isn't documented?

[steplong]

clang/lib/Sema/SemaAttr.cpp

1079

Hmm do you know where I can find an Allocator? getArrayRef().data() returns a pointer to a constant StringRef, but CreateImplicit takes a pointer to a StringRef.

[steplong]

Changed it to use SmallSetVector instead of SmallVector. Had to use an temporary SmallVector in AddRangeBasedNoBuiltin() because I'm not sure how to get a pointer to StringRef. getArrayRef().copy().data() needs an Allocator.

Also, I can't figure out why the test pragma-ms-function-intrinsic.c is failing from the pragma not being in file context. The pragmas are not inside a function.

Will add Sema and parsing tests in the next update to this patch.

[aaron.ballman]

clang/include/clang/Basic/DiagnosticSemaKinds.td

988 ↗

(On Diff #427716)

clang/include/clang/Sema/Sema.h

758

10320–10325

This makes it easier for callers who have a SmallVector of a different extent but the correct type.

clang/lib/Parse/ParsePragma.cpp

3569

Given that this patch is about adding pragma function, I think it'd be better to split the changes to the intrinsic pragma out into their own patch set to keep a clear separation.

3572–3574

Formatting looks off here -- you should run your patch through clang-format (https://clang.llvm.org/docs/ClangFormat.html#script-for-patch-reformatting).

3578

Can we use ExpectAndConsume() here instead?

3602–3607

Another ExpectAndConsume()?

clang/lib/Sema/SemaAttr.cpp

1070

What is CurContext when this gets called for your .c test file? I would have expected it to be the TranslationUnitDecl which should be a file context (getting the redecl context shouldn't do anything in the cases I've seen).

[steplong]

clang/lib/Parse/ParsePragma.cpp

3578

I don't think we can use ExpectAndConsume() here because it's not a Parser

clang/lib/Sema/SemaAttr.cpp

1070

It looks like it's a FunctionDecl

[aaron.ballman]

clang/lib/Parse/ParsePragma.cpp

3578

Oh good point! Sorry for the noise.

clang/lib/Sema/SemaAttr.cpp

1070

Wha? That seems rather surprising -- which function does it think the pragma is scoped to?

You might consider putting breakpoints in PushDeclContext() and PopDeclContext() to see what's going on (or search for other places where we assign to CurContext and break on those).

[steplong]

• Clang-formatted patch
• Split out the pragma intrinsic stuff
• Replaced SmallSetVector in pragma handler with SmallVector. MSNoBuiltins is still a SmallSetVector in Sema.
• Commented out if not file scope block in ActOn.. method. Will investigate next
• Added pragma warnings test

[steplong]

clang/lib/Sema/SemaAttr.cpp

1070

This is what I see when I run it on pragma-ms-function.c:

PUSHING TranslationUnit
PUSHING Function foo1
FOUND PRAGMA FUNCTION
POPPING Function foo1
PUSHING TranslationUnit
PUSHING Function foo2
FOUND PRAGMA FUNCTION
POPPING Function foo2
PUSHING TranslationUnit
PUSHING Function foo3
POPPING Function foo3
PUSHING TranslationUnit

I'm logging the swap in PopDeclContext() with POPPING and PUSHING and the push in PushDeclContext() with just PUSHING.
I'm also logging FOUND PRAGMA in the pragma handler

[aaron.ballman]

clang/lib/Sema/SemaAttr.cpp

1070

Huh. For fun, can you try changing the test to:

void foo1(char *s, char *d, size_t n) {
  bar(s);
  memset(s, 0, n);
  memcpy(d, s, n);
}

int i; // Now there's a declaration here

#pragma function(strlen, memset)

and see if you get different results? I'm wondering if what's happening is that the CurContext is being updated after we've lexed the next token from the preprocessor, which means we're still in the context of foo1 until after we've processed the pragma due to it being a preprocessing token. It still wouldn't make much sense to me, because I think we should hit that on the } for foo1(), but it's a shot in the dark.

[steplong]

clang/lib/Sema/SemaAttr.cpp

1070

It looks like you're right. The int i makes the pragma show up after the TranslationUnit is pushed.

PUSHING TranslationUnit
PUSHING Function foo1
POPPING Function foo1
PUSHING TranslationUnit
FOUND PRAGMA FUNCTION
PUSHING Function foo2
POPPING Function foo2
PUSHING TranslationUnit
FOUND PRAGMA FUNCTION
PUSHING Function foo3
POPPING Function foo3
PUSHING TranslationUnit

I really appreciate the review and you helping me debug this

[aaron.ballman]

clang/lib/Sema/SemaAttr.cpp

1070

Ugggghhhhh I was hoping I was wrong because I think the solution requires some experimentation that may or may not pan out.

The way the pragma is currently being handled is: we parse everything at preprocessing time (PragmaMSFunctionHandler::HandlePragma()) and then call directly into Sema (Actions.ActOnPragmaMSFunction()).

The way I think we may have to handle the pragma is: identify the pragma at preprocessing time, emit an annotated token stream, parse that token stream from the parser, and then call Sema from there. e.g., more like:

https://github.com/llvm/llvm-project/blob/main/clang/lib/Parse/ParsePragma.cpp#L2698
https://github.com/llvm/llvm-project/blob/main/clang/lib/Parse/Parser.cpp#L830
https://github.com/llvm/llvm-project/blob/main/clang/lib/Parse/ParsePragma.cpp#L894 (you would call ActOnPragmaMSFunction() from here)

This way, the appropriate parsing contexts are all updated (hopefully)!

I really appreciate the review and you helping me debug this

I'm very happy to help!

[steplong]

• Changed pragma-ms-functions.c to only check that the no-builtin attributes are added to the functions
• Moved pragma handler to Parser
• Changed scope check to only file scope. MSVC accepts stuff like that we don't:

struct S {
  int a;
#pragma function(memset)
};

[aaron.ballman]

clang/lib/Sema/SemaAttr.cpp

1070

Now that we solved the mystery of the context -- do we need getRedeclContext() here?

1103

I think we should rename this function to be more specific to the pragma. How about AddImplicitMSFunctionNoBuiltinAttr() -- it's a mouthful, but it's at least a descriptive mouthful that won't be called too often.

clang/lib/Sema/SemaDecl.cpp

10224–10226

I'd be delighted if a follow-up NFC commit changed this name as well -- "RangeBased" doesn't tell me much of anything in these identifiers (it leaves me wondering why there's no range passed in to the function).

clang/test/Preprocessor/pragma_microsoft.c

210–211 ↗

(On Diff #428456)

It's a bit unfortunate that these don't suggest that an identifier is what's missing given that empty parens isn't a particularly useful pragma, however, I don't insist on a change either.

220 ↗

(On Diff #428456)

It'd be pretty reasonable to add the struct test here as well with a comment that Microsoft accepts it but we reject it on purpose with an appeal to the MS docs that say it must appear at file scope.

[steplong]

• Renamed AddRangeBasedNoBuiltin to AddImplicitMSFunctionNoBuiltinAttr
• Renamed err_pragma_intrinsic_function_scope to err_pragma_expected_file_scope
• Added comment about MSVC accepting struct test
• Removed ->getRedeclContext(). Seems to be ok (i.e. tests are still passing)

[aaron.ballman]

Thanks for all the hard work on this, LGTM! Can you please add a release note to clang/docs/ReleaseNotes.rst for the new functionality (probably best under the New Pragmas in Clang heading) when you land it?

[steplong]

clang/test/Preprocessor/pragma_microsoft.c

210 ↗

(On Diff #428657)

Hmm does it make sense for this to be a warning and not an error?

[aaron.ballman]

clang/test/Preprocessor/pragma_microsoft.c

210 ↗

(On Diff #428657)

I'm glad I'm not the only one who questioned this. :-D I tend to be of the opinion that syntax errors should be errors rather than warnings. However, this is using an existing warning that's used by a bunch of other pragmas so I think it's defensible to use it here, especially given that this pragma form is commonly used for compiler extensions (so who knows, the syntax could be valid for another compiler, I guess).

[aaron.ballman]

clang/lib/Sema/SemaAttr.cpp

1070

It looks like we need getRedeclContext() after all, consider:

#include <cstring>

extern "C" {
void foo();
#pragma function(memset)
}

[steplong]

• Added test case for the getRedeclContext() case
• Brought back getRedeclContext()
• Clang-formatted
• Added description in docs

[aaron.ballman]

LGTM, thanks for all the work here!

clang/docs/ReleaseNotes.rst

272 ↗

(On Diff #428941)

[steplong]

• Updated line in docs

clang/include/clang/Parse/Parser.h

class Parser : public CodeCompletionHandler {
   std::unique_ptr<PragmaHandler> MSInitSeg;
   std::unique_ptr<PragmaHandler> MSDataSeg;
   std::unique_ptr<PragmaHandler> MSBSSSeg;
   std::unique_ptr<PragmaHandler> MSConstSeg;
   std::unique_ptr<PragmaHandler> MSCodeSeg;
   std::unique_ptr<PragmaHandler> MSSection;
   std::unique_ptr<PragmaHandler> MSRuntimeChecks;
   std::unique_ptr<PragmaHandler> MSIntrinsic;
+  std::unique_ptr<PragmaHandler> MSFunction;
   std::unique_ptr<PragmaHandler> MSOptimize;
   std::unique_ptr<PragmaHandler> MSFenvAccess;
   std::unique_ptr<PragmaHandler> CUDAForceHostDeviceHandler;
   std::unique_ptr<PragmaHandler> OptimizeHandler;
   std::unique_ptr<PragmaHandler> LoopHintHandler;
   std::unique_ptr<PragmaHandler> UnrollHintHandler;
   std::unique_ptr<PragmaHandler> NoUnrollHintHandler;
   std::unique_ptr<PragmaHandler> UnrollAndJamHintHandler;

clang/include/clang/Sema/Sema.h

public:
   /// #pragma attribute stack.
   const Decl *PragmaAttributeCurrentTargetDecl;
 
   /// This represents the last location of a "#pragma clang optimize off"
   /// directive if such a directive has not been closed by an "on" yet. If
   /// optimizations are currently "on", this is set to an invalid location.
   SourceLocation OptimizeOffPragmaLocation;
 
+  std::vector<StringRef> MSFunctionNoBuiltins;
+
   /// Flag indicating if Sema is building a recovery call expression.
   ///
   /// This flag is used to avoid building recovery call expressions
   /// if Sema is already doing so, which would cause infinite recursions.
   bool IsBuildingRecoveryCallExpr;
 
   /// Used to control the generation of ExprWithCleanups.
   CleanupInfo Cleanup;

   /// '\#pragma clang attribute push' directives to the given declaration.
   void AddPragmaAttributes(Scope *S, Decl *D);
 
   void DiagnoseUnterminatedPragmaAttribute();
 
   /// Called on well formed \#pragma clang optimize.
   void ActOnPragmaOptimize(bool On, SourceLocation PragmaLoc);
 
+  void ActOnPragmaMSIntrinsic(const std::vector<StringRef> &Intrinsics);
+
+  void ActOnPragmaMSFunction(const std::vector<StringRef> &NoBuiltins);
+
   /// Get the location for the currently active "\#pragma clang optimize
   /// off". If this location is invalid, then the state of the pragma is "on".
   SourceLocation getOptimizeOffPragmaLocation() const {
     return OptimizeOffPragmaLocation;
   }
 
   /// Only called on function definitions; if there is a pragma in scope
   /// with the effect of a range-based optnone, consider marking the function
   /// with attribute optnone.
   void AddRangeBasedOptnone(FunctionDecl *FD);
 
   /// Adds the 'optnone' attribute to the function declaration if there
   /// are no conflicts; Loc represents the location causing the 'optnone'
   /// attribute to be added (usually because of a pragma).
   void AddOptnoneAttributeIfNoConflicts(FunctionDecl *FD, SourceLocation Loc);
 
+  /// Only called on function definitions; if there is a pragma in scope
+  /// with the effect of a range-based no_builtin, consider marking the function
+  /// with attribute no_builtin.
+  void AddRangeBasedNoBuiltin(FunctionDecl *FD);
+
   /// AddAlignedAttr - Adds an aligned attribute to a particular declaration.
   void AddAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E,
                       bool IsPackExpansion);
   void AddAlignedAttr(Decl *D, const AttributeCommonInfo &CI, TypeSourceInfo *T,
                       bool IsPackExpansion);
 
   /// AddAssumeAlignedAttr - Adds an assume_aligned attribute to a particular
   /// declaration.

clang/lib/Parse/ParsePragma.cpp

void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
                     Token &FirstToken) override;
 };
 
 struct PragmaMSRuntimeChecksHandler : public EmptyPragmaHandler {
   PragmaMSRuntimeChecksHandler() : EmptyPragmaHandler("runtime_checks") {}
 };
 
 struct PragmaMSIntrinsicHandler : public PragmaHandler {
-  PragmaMSIntrinsicHandler() : PragmaHandler("intrinsic") {}
+  PragmaMSIntrinsicHandler(Sema &S) : PragmaHandler("intrinsic"), Actions(S) {}
   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
                     Token &FirstToken) override;
+
+private:
+  Sema &Actions;
+};
+
+struct PragmaMSFunctionHandler : public PragmaHandler {
+  PragmaMSFunctionHandler(Sema &S) : PragmaHandler("function"), Actions(S) {}
+  void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
+                    Token &FirstToken) override;
+
+private:
+  Sema &Actions;
 };
 
 struct PragmaMSOptimizeHandler : public PragmaHandler {
   PragmaMSOptimizeHandler() : PragmaHandler("optimize") {}
   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
                     Token &FirstToken) override;
 };
 
if (getLangOpts().MicrosoftExt) {
     MSConstSeg = std::make_unique<PragmaMSPragma>("const_seg");
     PP.AddPragmaHandler(MSConstSeg.get());
     MSCodeSeg = std::make_unique<PragmaMSPragma>("code_seg");
     PP.AddPragmaHandler(MSCodeSeg.get());
     MSSection = std::make_unique<PragmaMSPragma>("section");
     PP.AddPragmaHandler(MSSection.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());
+    MSFunction = std::make_unique<PragmaMSFunctionHandler>(Actions);
+    PP.AddPragmaHandler(MSFunction.get());
     MSOptimize = std::make_unique<PragmaMSOptimizeHandler>();
     PP.AddPragmaHandler(MSOptimize.get());
     MSFenvAccess = std::make_unique<PragmaMSFenvAccessHandler>();
     PP.AddPragmaHandler(MSFenvAccess.get());
   }
 
   if (getLangOpts().CUDA) {
     CUDAForceHostDeviceHandler =
if (getLangOpts().MicrosoftExt) {
     PP.RemovePragmaHandler(MSCodeSeg.get());
     MSCodeSeg.reset();
     PP.RemovePragmaHandler(MSSection.get());
     MSSection.reset();
     PP.RemovePragmaHandler(MSRuntimeChecks.get());
     MSRuntimeChecks.reset();
     PP.RemovePragmaHandler(MSIntrinsic.get());
     MSIntrinsic.reset();
+    PP.RemovePragmaHandler(MSFunction.get());
+    MSFunction.reset();
     PP.RemovePragmaHandler(MSOptimize.get());
     MSOptimize.reset();
     PP.RemovePragmaHandler(MSFenvAccess.get());
     MSFenvAccess.reset();
   }
 
   if (getLangOpts().CUDA) {
     PP.RemovePragmaHandler("clang", CUDAForceHostDeviceHandler.get());
if (Tok.isNot(tok::l_paren)) {
     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen)
         << "intrinsic";
     return;
   }
   PP.Lex(Tok);
 
   bool SuggestIntrinH = !PP.isMacroDefined("__INTRIN_H");
 
+  std::vector<StringRef> Intrinsics;
   while (Tok.is(tok::identifier)) {
     IdentifierInfo *II = Tok.getIdentifierInfo();
-    if (!II->getBuiltinID())
+    if (!II->getBuiltinID()) {
       PP.Diag(Tok.getLocation(), diag::warn_pragma_intrinsic_builtin)
           << II << SuggestIntrinH;
+    } else {
+      Intrinsics.push_back(II->getName());
+    }
 
     PP.Lex(Tok);
     if (Tok.isNot(tok::comma))
       break;
     PP.Lex(Tok);
   }
 
   if (Tok.isNot(tok::r_paren)) {
     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_rparen)
         << "intrinsic";
     return;
   }
   PP.Lex(Tok);
 
   if (Tok.isNot(tok::eod))
     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
         << "intrinsic";
+
+  Actions.ActOnPragmaMSIntrinsic(Intrinsics);
+}
+
+void PragmaMSFunctionHandler::HandlePragma(Preprocessor &PP,
+                                            PragmaIntroducer Introducer,
+                                            Token &Tok) {
+  PP.Lex(Tok);
+
+  if (Tok.isNot(tok::l_paren)) {
+    PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen)
+        << "function";
+    return;
+  }
+  PP.Lex(Tok); // (
+
+  bool SuggestIntrinH = !PP.isMacroDefined("__INTRIN_H");
+
+  std::vector<StringRef> NoBuiltins;
+  while (Tok.is(tok::identifier)) {
+    IdentifierInfo *II = Tok.getIdentifierInfo();
+    if (!II->getBuiltinID()) {
+      PP.Diag(Tok.getLocation(), diag::warn_pragma_intrinsic_builtin)
+          << II << SuggestIntrinH;
+    } else {
+      NoBuiltins.push_back(II->getName());
+    }
+
+    PP.Lex(Tok);
+    if (Tok.isNot(tok::comma))
+      break;
+    PP.Lex(Tok); // ,
+  }
+
+  if (Tok.isNot(tok::r_paren)) {
+    PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_rparen)
+        << "function";
+    return;
+  }
+  PP.Lex(Tok); // )
+
+  if (Tok.isNot(tok::eod))
+    PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
+        << "function";
+
+  Actions.ActOnPragmaMSFunction(NoBuiltins);
 }
 
 // #pragma optimize("gsty", on|off)
 void PragmaMSOptimizeHandler::HandlePragma(Preprocessor &PP,
                                            PragmaIntroducer Introducer,
                                            Token &Tok) {
   SourceLocation StartLoc = Tok.getLocation();
   PP.Lex(Tok);

clang/lib/Sema/SemaAttr.cpp

 
 void Sema::ActOnPragmaOptimize(bool On, SourceLocation PragmaLoc) {
   if(On)
     OptimizeOffPragmaLocation = SourceLocation();
   else
     OptimizeOffPragmaLocation = PragmaLoc;
 }
 
+void Sema::ActOnPragmaMSIntrinsic(const std::vector<StringRef> &Intrinsics) {
+  for (auto &Intrinsic : Intrinsics) {
+    MSFunctionNoBuiltins.erase(std::remove(MSFunctionNoBuiltins.begin(),
+                                           MSFunctionNoBuiltins.end(),
+                                           Intrinsic),
+                               MSFunctionNoBuiltins.end());
+  }
+}
+
+void Sema::ActOnPragmaMSFunction(const std::vector<StringRef> &NoBuiltins) {
+  MSFunctionNoBuiltins.insert(MSFunctionNoBuiltins.end(),
+                              NoBuiltins.begin(), NoBuiltins.end());
+}
+
 void Sema::AddRangeBasedOptnone(FunctionDecl *FD) {
   // In the future, check other pragmas if they're implemented (e.g. pragma
   // optimize 0 will probably map to this functionality too).
   if(OptimizeOffPragmaLocation.isValid())
     AddOptnoneAttributeIfNoConflicts(FD, OptimizeOffPragmaLocation);
 }
 
 void Sema::AddOptnoneAttributeIfNoConflicts(FunctionDecl *FD,
                                             SourceLocation Loc) {
   // Don't add a conflicting attribute. No diagnostic is needed.
   if (FD->hasAttr<MinSizeAttr>() || FD->hasAttr<AlwaysInlineAttr>())
     return;
 
   // Add attributes only if required. Optnone requires noinline as well, but if
   // either is already present then don't bother adding them.
   if (!FD->hasAttr<OptimizeNoneAttr>())
     FD->addAttr(OptimizeNoneAttr::CreateImplicit(Context, Loc));
   if (!FD->hasAttr<NoInlineAttr>())
     FD->addAttr(NoInlineAttr::CreateImplicit(Context, Loc));
 }
 
+void Sema::AddRangeBasedNoBuiltin(FunctionDecl *FD) {
+  if (!MSFunctionNoBuiltins.empty()) {
+    FD->addAttr(NoBuiltinAttr::CreateImplicit(Context,
+                    MSFunctionNoBuiltins.data(), MSFunctionNoBuiltins.size()));
+  }
+}
+
 typedef std::vector<std::pair<unsigned, SourceLocation> > VisStack;
 enum : unsigned { NoVisibility = ~0U };
 
 void Sema::AddPushedVisibilityAttribute(Decl *D) {
   if (!VisContext)
     return;
 
   NamedDecl *ND = dyn_cast<NamedDecl>(D);

clang/lib/Sema/SemaDecl.cpp

Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC,
   // member, set the visibility of this function.
   if (!DC->isRecord() && NewFD->isExternallyVisible())
     AddPushedVisibilityAttribute(NewFD);
 
   // If there's a #pragma clang arc_cf_code_audited in scope, consider
   // marking the function.
   AddCFAuditedAttribute(NewFD);
 
-  // If this is a function definition, check if we have to apply optnone due to
-  // a pragma.
-  if(D.isFunctionDefinition())
+  // If this is a function definition, check if we have to apply any
+  // attributes (i.e. optnone and no_builtin) due to a pragma.
+  if(D.isFunctionDefinition()) {
     AddRangeBasedOptnone(NewFD);
+    AddRangeBasedNoBuiltin(NewFD);
+  }
 
   // If this is the first declaration of an extern C variable, update
   // the map of such variables.
   if (NewFD->isFirstDecl() && !NewFD->isInvalidDecl() &&
       isIncompleteDeclExternC(*this, NewFD))
     RegisterLocallyScopedExternCDecl(NewFD, S);
 
   // Set this FunctionDecl's range up to the right paren.

clang/test/CodeGen/pragma-ms-function-intrinsic.c

+// RUN: %clang_cc1 -emit-llvm -fms-extensions -o - %s | FileCheck %s
+
+typedef typeof(sizeof(0)) size_t;
+
+void bar(char *s);
+void *memset(void *s, int c, size_t n);
+void *memcpy(void *d, const void *s, size_t n);
+
+// CHECK: define{{.*}} void @foo1({{.*}}) #[[NO_NOBUILTIN:[0-9]+]]
+// CHECK:   call void @bar
+// CHECK:   call void @llvm.memset
+// CHECK:   call void @llvm.memcpy
+void foo1(char *s, char *d, size_t n)
+{
+    bar(s);
+    memset(s, 0, n);
+    memcpy(d, s, n);
+}
+
+#pragma function(strlen, memset)
+
+// CHECK: define{{.*}} void @foo2({{.*}}) #[[NOBUILTIN_MEMSET:[0-9]+]]
+// CHECK:   call void @bar
+// CHECK:   {{.*}}call {{.*}} @memset
+// CHECK:   call void @llvm.memcpy
+void foo2(char *s, char *d, size_t n)
+{
+    bar(s);
+    memset(s, 1, n);
+    memcpy(d, s, n);
+}
+
+#pragma function(memcpy)
+
+// CHECK: define{{.*}} void @foo3({{.*}}) #[[NOBUILTIN_MEMSET_MEMCPY:[0-9]+]]
+// CHECK:   call void @bar
+// CHECK:   {{.*}}call {{.*}} @memset
+// CHECK:   {{.*}}call {{.*}} @memcpy
+void foo3(char *s, char *d, size_t n)
+{
+    bar(s);
+    memset(s, 2, n);
+    memcpy(d, s, n);
+}
+
+#pragma intrinsic(memset, strlen)
+
+// CHECK: define{{.*}} void @foo4({{.*}}) #[[NOBUILTIN_MEMCPY:[0-9]+]]
+// CHECK:   call void @bar
+// CHECK:   call void @llvm.memset
+// CHECK:   {{.*}}call {{.*}} @memcpy
+void foo4(char *s, char *d, size_t n)
+{
+    bar(s);
+    memset(s, 3, n);
+    memcpy(d, s, n);
+}
+
+#pragma intrinsic(memcpy)
+
+// CHECK: define{{.*}} void @foo5({{.*}}) #[[NO_NOBUILTIN]]
+// CHECK:   call void @bar
+// CHECK:   call void @llvm.memset
+// CHECK:   call void @llvm.memcpy
+void foo5(char *s, char *d, size_t n)
+{
+    bar(s);
+    memset(s, 4, n);
+    memcpy(d, s, n);
+}
+
+// CHECK-NOT: attributes #[[NO_NOBUILTIN]] = {{{.*}}"no-builtin-memset"{{.*}}}
+// CHECK-NOT: attributes #[[NO_NOBUILTIN]] = {{{.*}}"no-builtin-memcpy"{{.*}}"no-builtin-memset"{{.*}}}
+// CHECK:     attributes #[[NOBUILTIN_MEMSET]] = {{{.*}}"no-builtin-memset"{{.*}}}
+// CHECK-NOT: attributes #[[NOBUILTIN_MEMSET]] = {{{.*}}"no-builtin-memcpy"{{.*}}"no-builtin-memset"{{.*}}}
+// CHECK:     attributes #[[NOBUILTIN_MEMSET_MEMCPY]] = {{{.*}}"no-builtin-memcpy"{{.*}}"no-builtin-memset"{{.*}}}
+// CHECK:     attributes #[[NOBUILTIN_MEMCPY]] = {{{.*}}"no-builtin-memcpy"{{.*}}}
+// CHECK-NOT: attributes #[[NOBUILTIN_MEMCPY]] = {{{.*}}"no-builtin-memcpy"{{.*}}"no-builtin-memset"{{.*}}}