[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

10328

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

3532

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.

3547

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

3591

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

3547

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

3547

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

992

clang/include/clang/Sema/Sema.h

758

10329–10334

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

clang/lib/Parse/ParsePragma.cpp

3555

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.

3558–3560

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

3564

Can we use ExpectAndConsume() here instead?

3588–3593

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

3564

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

3564

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?

1099

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

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

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

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

[aaron.ballman]

clang/test/Preprocessor/pragma_microsoft.c

210

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

281

[steplong]

• Updated line in docs

clang/docs/ReleaseNotes.rst

 -------------------------
 - Removed the ``-fno-concept-satisfaction-caching`` flag. The flag was added
   at the time when the draft of C++20 standard did not permit caching of
   atomic constraints. The final standard permits such caching, see
   `WG21 P2104R0 <http://wg21.link/p2104r0>`_.
 
 New Pragmas in Clang
 --------------------
+- Added support for MSVC's ``#pragma function``, which tells the compiler to
+  generate calls to functions listed in the pragma instead of using the
+  builtins.
 
 - ...
 
 Attribute Changes in Clang
 --------------------------
 
 - Added support for parameter pack expansion in ``clang::annotate``.
 

clang/include/clang/Basic/DiagnosticSemaKinds.td

def err_pragma_pack_identifer_not_supported : Error<
   "specifying an identifier within `#pragma pack` is not supported on this target">;
 def err_section_conflict : Error<"%0 causes a section type conflict with %1">;
 def err_no_base_classes : Error<"invalid use of '__super', %0 has no base classes">;
 def err_invalid_super_scope : Error<"invalid use of '__super', "
   "this keyword can only be used inside class or member function scope">;
 def err_super_in_lambda_unsupported : Error<
   "use of '__super' inside a lambda is unsupported">;
 
+def err_pragma_expected_file_scope : Error<
+  "'#pragma %0' can only appear at file scope">;
+
 def warn_pragma_unused_undeclared_var : Warning<
   "undeclared variable %0 used as an argument for '#pragma unused'">,
   InGroup<IgnoredPragmas>;
 def warn_atl_uuid_deprecated : Warning<
   "specifying 'uuid' as an ATL attribute is deprecated; use __declspec instead">,
   InGroup<DeprecatedDeclarations>;
 def warn_pragma_unused_expected_var_arg : Warning<
   "only variables can be arguments to '#pragma unused'">,

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;
private:
 
   void HandlePragmaMSPragma();
   bool HandlePragmaMSSection(StringRef PragmaName,
                              SourceLocation PragmaLocation);
   bool HandlePragmaMSSegment(StringRef PragmaName,
                              SourceLocation PragmaLocation);
   bool HandlePragmaMSInitSeg(StringRef PragmaName,
                              SourceLocation PragmaLocation);
+  bool HandlePragmaMSFunction(StringRef PragmaName,
+                              SourceLocation PragmaLocation);
 
   /// Handle the annotation token produced for
   /// #pragma align...
   void HandlePragmaAlign();
 
   /// Handle the annotation token produced for
   /// #pragma clang __debug dump...
   void HandlePragmaDump();

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;
 
+  /// Set of no-builtin functions listed by \#pragma function.
+  llvm::SmallSetVector<StringRef, 4> 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);
 
+  /// Call on well formed \#pragma function.
+  void
+  ActOnPragmaMSFunction(SourceLocation Loc,
+                        const llvm::SmallVectorImpl<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 AddImplicitMSFunctionNoBuiltinAttr(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

if (getLangOpts().MicrosoftExt) {
     MSBSSSeg = std::make_unique<PragmaMSPragma>("bss_seg");
     PP.AddPragmaHandler(MSBSSSeg.get());
     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());
+    MSFunction = std::make_unique<PragmaMSPragma>("function");
+    PP.AddPragmaHandler(MSFunction.get());
     MSRuntimeChecks = std::make_unique<PragmaMSRuntimeChecksHandler>();
     PP.AddPragmaHandler(MSRuntimeChecks.get());
     MSIntrinsic = std::make_unique<PragmaMSIntrinsicHandler>();
     PP.AddPragmaHandler(MSIntrinsic.get());
     MSOptimize = std::make_unique<PragmaMSOptimizeHandler>();
     PP.AddPragmaHandler(MSOptimize.get());
     MSFenvAccess = std::make_unique<PragmaMSFenvAccessHandler>();
     PP.AddPragmaHandler(MSFenvAccess.get());
if (getLangOpts().MicrosoftExt) {
     PP.RemovePragmaHandler(MSBSSSeg.get());
     MSBSSSeg.reset();
     PP.RemovePragmaHandler(MSConstSeg.get());
     MSConstSeg.reset();
     PP.RemovePragmaHandler(MSCodeSeg.get());
     MSCodeSeg.reset();
     PP.RemovePragmaHandler(MSSection.get());
     MSSection.reset();
+    PP.RemovePragmaHandler(MSFunction.get());
+    MSFunction.reset();
     PP.RemovePragmaHandler(MSRuntimeChecks.get());
     MSRuntimeChecks.reset();
     PP.RemovePragmaHandler(MSIntrinsic.get());
     MSIntrinsic.reset();
     PP.RemovePragmaHandler(MSOptimize.get());
     MSOptimize.reset();
     PP.RemovePragmaHandler(MSFenvAccess.get());
     MSFenvAccess.reset();
void Parser::HandlePragmaMSPragma() {
   SourceLocation PragmaLocation = ConsumeAnnotationToken();
   assert(Tok.isAnyIdentifier());
   StringRef PragmaName = Tok.getIdentifierInfo()->getName();
   PP.Lex(Tok); // pragma kind
 
   // Figure out which #pragma we're dealing with.  The switch has no default
   // because lex shouldn't emit the annotation token for unrecognized pragmas.
   typedef bool (Parser::*PragmaHandler)(StringRef, SourceLocation);
-  PragmaHandler Handler = llvm::StringSwitch<PragmaHandler>(PragmaName)
+  PragmaHandler Handler =
+      llvm::StringSwitch<PragmaHandler>(PragmaName)
           .Case("data_seg", &Parser::HandlePragmaMSSegment)
           .Case("bss_seg", &Parser::HandlePragmaMSSegment)
           .Case("const_seg", &Parser::HandlePragmaMSSegment)
           .Case("code_seg", &Parser::HandlePragmaMSSegment)
           .Case("section", &Parser::HandlePragmaMSSection)
-    .Case("init_seg", &Parser::HandlePragmaMSInitSeg);
+          .Case("init_seg", &Parser::HandlePragmaMSInitSeg)
+          .Case("function", &Parser::HandlePragmaMSFunction);
 
   if (!(this->*Handler)(PragmaName, PragmaLocation)) {
     // Pragma handling failed, and has been diagnosed.  Slurp up the tokens
     // until eof (really end of line) to prevent follow-on errors.
     while (Tok.isNot(tok::eof))
       PP.Lex(Tok);
     PP.Lex(Tok);
   }
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");
 
   while (Tok.is(tok::identifier)) {
     IdentifierInfo *II = Tok.getIdentifierInfo();
     if (!II->getBuiltinID())
       PP.Diag(Tok.getLocation(), diag::warn_pragma_intrinsic_builtin)
           << II << SuggestIntrinH;
 
     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";
 }
 
+bool Parser::HandlePragmaMSFunction(StringRef PragmaName,
+                                    SourceLocation PragmaLocation) {
+  Token FirstTok = Tok;
+
+  if (ExpectAndConsume(tok::l_paren, diag::warn_pragma_expected_lparen,
+                       PragmaName))
+    return false;
+
+  bool SuggestIntrinH = !PP.isMacroDefined("__INTRIN_H");
+
+  llvm::SmallVector<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.emplace_back(II->getName());
+
+    PP.Lex(Tok);
+    if (Tok.isNot(tok::comma))
+      break;
+    PP.Lex(Tok); // ,
+  }
+
+  if (ExpectAndConsume(tok::r_paren, diag::warn_pragma_expected_rparen,
+                       PragmaName) ||
+      ExpectAndConsume(tok::eof, diag::warn_pragma_extra_tokens_at_eol,
+                       PragmaName))
+    return false;
+
+  Actions.ActOnPragmaMSFunction(FirstTok.getLocation(), NoBuiltins);
+  return true;
+}
+
 // #pragma optimize("gsty", on|off)
 void PragmaMSOptimizeHandler::HandlePragma(Preprocessor &PP,
                                            PragmaIntroducer Introducer,
                                            Token &Tok) {
   SourceLocation StartLoc = Tok.getLocation();
   PP.Lex(Tok);
 
   if (Tok.isNot(tok::l_paren)) {
     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen) << "optimize";
     return;
   }

clang/lib/Sema/SemaAttr.cpp

 
 void Sema::ActOnPragmaOptimize(bool On, SourceLocation PragmaLoc) {
   if(On)
     OptimizeOffPragmaLocation = SourceLocation();
   else
     OptimizeOffPragmaLocation = PragmaLoc;
 }
 
+void Sema::ActOnPragmaMSFunction(
+    SourceLocation Loc, const llvm::SmallVectorImpl<StringRef> &NoBuiltins) {
+  if (!CurContext->getRedeclContext()->isFileContext()) {
+    Diag(Loc, diag::err_pragma_expected_file_scope) << "function";
+    return;
+  }
+
+  MSFunctionNoBuiltins.insert(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::AddImplicitMSFunctionNoBuiltinAttr(FunctionDecl *FD) {
+  SmallVector<StringRef> V(MSFunctionNoBuiltins.begin(),
+                           MSFunctionNoBuiltins.end());
+  if (!MSFunctionNoBuiltins.empty())
+    FD->addAttr(NoBuiltinAttr::CreateImplicit(Context, V.data(), V.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);
+    AddImplicitMSFunctionNoBuiltinAttr(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.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]+]]
+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]+]]
+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]+]]
+void foo3(char *s, char *d, size_t n) {
+  bar(s);
+  memset(s, 2, 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"{{.*}}}

clang/test/Preprocessor/pragma_microsoft.c

 #pragma intrinsic(asdf) // expected-warning {{'asdf' is not a recognized builtin; consider including <intrin.h>}}
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wignored-pragmas"
 #pragma intrinsic(asdf) // no-warning
 #pragma clang diagnostic pop
 #pragma intrinsic(asdf) // expected-warning {{'asdf' is not a recognized builtin; consider including <intrin.h>}}
 
+// Test pragma function
+#pragma function(memset)                 // no-warning
+#pragma function(memcpy, strlen, strlen) // no-warning
+#pragma function()                       // no-warning
+#pragma function(asdf)                   // expected-warning {{'asdf' is not a recognized builtin; consider including <intrin.h>}}
+#pragma function(main)                   // expected-warning {{'main' is not a recognized builtin; consider including <intrin.h>}}
+#pragma function(                        // expected-warning {{missing ')' after}}
+#pragma function(int)                    // expected-warning {{missing ')' after}}
+#pragma function(strcmp) asdf            // expected-warning {{extra tokens at end}}
+
+#define __INTRIN_H       // there should be no notes after defining __INTRIN_H
+#pragma function(asdf)   // expected-warning-re {{'asdf' is not a recognized builtin{{$}}}}
+#pragma function(memset) // no-warning
+#undef __INTRIN_H
+#pragma function(asdf) // expected-warning {{'asdf' is not a recognized builtin; consider including <intrin.h>}}
+
+// MSVC accepts this, but we decide to reject it based on the MS docs saying the pragma must appear at the global level
+void pragma_function_foo() {
+#pragma function(memset) // expected-error {{'#pragma function' can only appear at file scope}}
+}
+
 #pragma optimize          // expected-warning{{missing '(' after '#pragma optimize'}}
 #pragma optimize(         // expected-warning{{expected string literal in '#pragma optimize'}}
 #pragma optimize(a        // expected-warning{{expected string literal in '#pragma optimize'}}
 #pragma optimize("g"      // expected-warning{{expected ',' in '#pragma optimize'}}
 #pragma optimize("g",     // expected-warning{{missing argument to '#pragma optimize'; expected 'on' or 'off'}}
 #pragma optimize("g",xyz  // expected-warning{{unexpected argument 'xyz' to '#pragma optimize'; expected 'on' or 'off'}}
 #pragma optimize("g",on)  // expected-warning{{#pragma optimize' is not supported}}
 

clang/test/Preprocessor/pragma_microsoft.cpp

 // RUN: %clang_cc1 %s -fsyntax-only -std=c++11 -verify -fms-extensions
 
 #pragma warning(push, 4_D) // expected-warning {{requires a level between 0 and 4}}
+
+extern "C" {
+#pragma function(memset) // no-warning
+}