[MSVC] Add support for pragma alloc_text

[steplong]

Summary

#pragma alloc_text is a MSVC pragma that names the code section where functions should be placed. It only
applies to functions with C linkage.

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

[steplong]

Update patch to error out if a function is not C linkage. Not sure how to check if a function has been declared

[aaron.ballman]

Thanks for working on this compatibility extension!

This is missing all of the lexing tests which validate that we correctly diagnose malformed pragmas. We're also missing all sema tests for the diagnostics added or emitted from there. When you add the sema tests, I think we should have diagnostics for:

// First case
#pragma alloc_text("abc", does_not_exist)

// Second case
void already_defined(void) {}
#pragma alloc_text("abc", already_defined)

Also, what should happen in a case like this?

__declspec(code_seg("text")) static void section_mismatch(void);
#pragma alloc_text("hoo boy", section_mismatch) // Pretty sure we want to diagnose this?

MSDN docs say that the pragma "can't be used in a function" which is subtly different from "at file scope". e.g., MSVC accepts:

void umm(void);
struct S {
#pragma alloc_text("hoo boy", umm)
  int a;
};

which is a bit of a silly example, but it also accepts:

extern "C" void umm(void);
namespace N {
#pragma alloc_text("hoo boy", umm)
}

// or
extern "C" {
 void okay(void);
#pragma alloc_text("hoo boy", okay)
}

which are far more reasonable for users to write. I think we should have tests for these situations to make sure we accept the same code as MSVC unless the behavior there seems like a bug.

In D125011#3494014, @steplong wrote:

Update patch to error out if a function is not C linkage. Not sure how to check if a function has been declared

At the time we're processing the pragma (within Sema), I would perform a lookup on the identifier given by the pragma to validate that it 1) can be found, 2) finds a function, 3) the function found is in an extern "C" context. To do the lookup, I'd probably use Sema::LookupSingleName() because this can't be used on an overloaded function. (And you should add tests for specifying a member function and an overloaded function.)

clang/include/clang/Sema/Sema.h

727

10353

This could probably have some comments with it.

clang/lib/Parse/ParsePragma.cpp

1166–1171

This looks like it can be replaced with ExpectAndConsume(). However, should we be diagnosing use of this pragma for non-MSVC compatible triples before we start parsing?

1182–1185

I think we want to test isAscii() instead of looking at the byte width; we don't want to accept u8"whatever" any more than we want to accept L"whatever".

(The diagnostic text is also pretty bad because it'll diagnose non-wide literals as being wide, but that's an existing deficiency with the diagnostic and can be addressed separately.)

1188

ExpectAndConsume()

1211–1215

ExpectAndConsume()

1222

ExpectAndConsume()

clang/lib/Sema/SemaAttr.cpp

1117–1118

Do we have to treat main() as being special?

1127

I think you need to use isInExternCContext() instead (and add test coverage for extern "C" { void func(void); }).

[steplong]

• Added Sema tests
• Added checking of c linkage
• Changed some parsing logic in the parser handler e.g #pragma alloc_text(a, foo without the right paren is only a warning

[aaron.ballman]

clang/include/clang/Basic/DiagnosticParseKinds.td

1136–1137 ↗

(On Diff #428536)

We use warn_pragma_expected_non_wide_string for all the other MS pragmas, so I think we should use that one here. Then, if we really care to, we can make warn_pragma_expected_non_wide_string more generally about non-ASCII string literals in a follow up.

clang/include/clang/Basic/DiagnosticSemaKinds.td

991–994

clang/lib/Parse/ParsePragma.cpp

1182–1185

Ugh, I'm sorry, but I steered you wrong with this comment. I didn't notice until now that all the other MS pragmas use getCharByteWidth() != 1 rather than isAscii(). I think we should replicate that mistake here, and then in a follow-up we can fix all the MS pragmas at once so that they consistently handle that case. WDYT?

1212

Should we be returning false if this comes back true? I'm worried about the case where there's a missing right paren, we warn about the pragma being ignored, find the EOL token and then actually handle the pragma.

clang/lib/Sema/SemaAttr.cpp

748

Same question here about whether we need to get the redecl context or not.

clang/test/Sema/pragma-ms-alloc-text.cpp

6

This shows we have the parsing logic wrong -- we shouldn't get the use of undeclared identifier a because we shouldn't have gotten into Sema for this one.

[steplong]

clang/test/Sema/pragma-ms-alloc-text.cpp

6

MSVC accepts it and only warns about the missing paren if the identifier is declared like on Line 14. That's why I decided to handle it that way. We can decide to reject it though

[aaron.ballman]

clang/test/Sema/pragma-ms-alloc-text.cpp

6

I think this is a case we'd probably rather reject -- if someone runs into a problem where they're relying on the MSVC behavior, we can always relax the diagnostic later.

[steplong]

• Reject #pragma alloc_text(a, a
• On Line 1180, I didn't use ExpectAndConsume() there because I wanted to accept both identifiers and strings (i.e pragma alloc_text(a, foo) and pragma alloc_text("a", foo)
• It looks like we need ->getRedeclContext() to accept

extern "C" {
void foo();
#pragma alloc_text(a, foo)
}

[aaron.ballman]

LGTM aside from some minor commenting nits that you can fix when landing. Can you also add a release note for the new pragma support?

clang/include/clang/Sema/Sema.h

727

Looks like this one was missed.

10353

Same here.

[steplong]

• Added description in release notes
• Fixed up some comments in Sema.h

Will merge once build passes

[steplong]

• Rebased patch

[steplong]

• Clang-formatted. It didn't like the empty line before the bracket in clang/test/CodeGen/msvc_pragma_alloc_text.cpp

clang/docs/ReleaseNotes.rst

- Removed the ``-fno-concept-satisfaction-caching`` flag. The flag was added
   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.
+- Added support for MSVC's ``#pragma alloc_text``. The pragma names the code
+  section functions are placed in. The pragma only applies to functions with
+  C linkage.
 
 - ...
 
 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 err_pragma_alloc_text_c_linkage: Error<
+  "'#pragma alloc_text' is applicable only to functions with C linkage">;
 
 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<

clang/include/clang/Parse/Parser.h

class Parser : public CodeCompletionHandler {
   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> MSAllocText;
   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;
   std::unique_ptr<PragmaHandler> NoUnrollAndJamHintHandler;
   std::unique_ptr<PragmaHandler> FPHandler;
private:
   bool HandlePragmaMSSection(StringRef PragmaName,
                              SourceLocation PragmaLocation);
   bool HandlePragmaMSSegment(StringRef PragmaName,
                              SourceLocation PragmaLocation);
   bool HandlePragmaMSInitSeg(StringRef PragmaName,
                              SourceLocation PragmaLocation);
   bool HandlePragmaMSFunction(StringRef PragmaName,
                               SourceLocation PragmaLocation);
+  bool HandlePragmaMSAllocText(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:
 
   /// A mapping that describes the nullability we've seen in each header file.
   FileNullabilityMap NullabilityMap;
 
   /// Last section used with #pragma init_seg.
   StringLiteral *CurInitSeg;
   SourceLocation CurInitSegLoc;
 
+  /// Sections used with #pragma alloc_text.
+  llvm::StringMap<std::tuple<StringRef, SourceLocation>> FunctionToSectionMap;
+
   /// VisContext - Manages the stack for \#pragma GCC visibility.
   void *VisContext; // Really a "PragmaVisStack*"
 
   /// This an attribute introduced by \#pragma clang attribute.
   struct PragmaAttributeEntry {
     SourceLocation Loc;
     ParsedAttr *Attribute;
     SmallVector<attr::SubjectMatchRule, 4> MatchRules;

   /// Called on well formed \#pragma section().
   void ActOnPragmaMSSection(SourceLocation PragmaLocation,
                             int SectionFlags, StringLiteral *SegmentName);
 
   /// Called on well-formed \#pragma init_seg().
   void ActOnPragmaMSInitSeg(SourceLocation PragmaLocation,
                             StringLiteral *SegmentName);
 
+  /// Called on well-formed \#pragma alloc_text().
+  void ActOnPragmaMSAllocText(
+      SourceLocation PragmaLocation, StringRef Section,
+      const SmallVector<std::tuple<IdentifierInfo *, SourceLocation>>
+          &Functions);
+
   /// Called on #pragma clang __debug dump II
   void ActOnPragmaDump(Scope *S, SourceLocation Loc, IdentifierInfo *II);
 
   /// ActOnPragmaDetectMismatch - Call on well-formed \#pragma detect_mismatch
   void ActOnPragmaDetectMismatch(SourceLocation Loc, StringRef Name,
                                  StringRef Value);
 
   /// Are precise floating point semantics currently enabled?
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);
 
+  /// Only called on function definitions; if there is a `#pragma alloc_text`
+  /// that decides which code section the function should be in, add
+  /// attribute section to the function.
+  void AddSectionMSAllocText(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.

clang/lib/Parse/ParsePragma.cpp

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());
     MSFunction = std::make_unique<PragmaMSPragma>("function");
     PP.AddPragmaHandler(MSFunction.get());
+    MSAllocText = std::make_unique<PragmaMSPragma>("alloc_text");
+    PP.AddPragmaHandler(MSAllocText.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(MSConstSeg.get());
     MSConstSeg.reset();
     PP.RemovePragmaHandler(MSCodeSeg.get());
     MSCodeSeg.reset();
     PP.RemovePragmaHandler(MSSection.get());
     MSSection.reset();
     PP.RemovePragmaHandler(MSFunction.get());
     MSFunction.reset();
+    PP.RemovePragmaHandler(MSAllocText.get());
+    MSAllocText.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() {
   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("function", &Parser::HandlePragmaMSFunction);
+          .Case("function", &Parser::HandlePragmaMSFunction)
+          .Case("alloc_text", &Parser::HandlePragmaMSAllocText);
 
   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 (ExpectAndConsume(tok::r_paren, diag::warn_pragma_expected_rparen,
       ExpectAndConsume(tok::eof, diag::warn_pragma_extra_tokens_at_eol,
                        PragmaName))
     return false;
 
   Actions.ActOnPragmaMSInitSeg(PragmaLocation, SegmentName);
   return true;
 }
 
+bool Parser::HandlePragmaMSAllocText(StringRef PragmaName,
+                                     SourceLocation PragmaLocation) {
+  Token FirstTok = Tok;
+  if (ExpectAndConsume(tok::l_paren, diag::warn_pragma_expected_lparen,
+                       PragmaName))
+    return false;
+
+  StringRef Section;
+  if (Tok.is(tok::string_literal)) {
+    ExprResult StringResult = ParseStringLiteralExpression();
+    if (StringResult.isInvalid())
+      return false; // Already diagnosed.
+    StringLiteral *SegmentName = cast<StringLiteral>(StringResult.get());
+    if (SegmentName->getCharByteWidth() != 1) {
+      PP.Diag(PragmaLocation, diag::warn_pragma_expected_non_wide_string)
+          << PragmaName;
+      return false;
+    }
+    Section = SegmentName->getString();
+  } else if (Tok.is(tok::identifier)) {
+    Section = Tok.getIdentifierInfo()->getName();
+    PP.Lex(Tok);
+  } else {
+    PP.Diag(PragmaLocation, diag::warn_pragma_expected_section_name)
+        << PragmaName;
+    return false;
+  }
+
+  if (ExpectAndConsume(tok::comma, diag::warn_pragma_expected_comma,
+                       PragmaName))
+    return false;
+
+  SmallVector<std::tuple<IdentifierInfo *, SourceLocation>> Functions;
+  while (true) {
+    if (Tok.isNot(tok::identifier)) {
+      PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
+          << PragmaName;
+      return false;
+    }
+
+    IdentifierInfo *II = Tok.getIdentifierInfo();
+    Functions.emplace_back(II, Tok.getLocation());
+
+    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.ActOnPragmaMSAllocText(FirstTok.getLocation(), Section, Functions);
+  return true;
+}
+
 namespace {
 struct PragmaLoopHintInfo {
   Token PragmaName;
   Token Option;
   ArrayRef<Token> Toks;
 };
 } // end anonymous namespace
 
 static std::string PragmaLoopHintString(Token PragmaName, Token Option) {

clang/lib/Sema/SemaAttr.cpp

void Sema::ActOnPragmaMSInitSeg(SourceLocation PragmaLocation,
                                 StringLiteral *SegmentName) {
   // There's no stack to maintain, so we just have a current section.  When we
   // see the default section, reset our current section back to null so we stop
   // tacking on unnecessary attributes.
   CurInitSeg = SegmentName->getString() == ".CRT$XCU" ? nullptr : SegmentName;
   CurInitSegLoc = PragmaLocation;
 }
 
+void Sema::ActOnPragmaMSAllocText(
+    SourceLocation PragmaLocation, StringRef Section,
+    const SmallVector<std::tuple<IdentifierInfo *, SourceLocation>>
+        &Functions) {
+  if (!CurContext->getRedeclContext()->isFileContext()) {
+    Diag(PragmaLocation, diag::err_pragma_expected_file_scope) << "alloc_text";
+    return;
+  }
+
+  for (auto &Function : Functions) {
+    IdentifierInfo *II;
+    SourceLocation Loc;
+    std::tie(II, Loc) = Function;
+
+    DeclarationName DN(II);
+    NamedDecl *ND = LookupSingleName(TUScope, DN, Loc, LookupOrdinaryName);
+    if (!ND) {
+      Diag(Loc, diag::err_undeclared_use) << II->getName();
+      return;
+    }
+
+    DeclContext *DC = ND->getDeclContext();
+    if (!DC->isExternCContext()) {
+      Diag(Loc, diag::err_pragma_alloc_text_c_linkage);
+      return;
+    }
+
+    FunctionToSectionMap[II->getName()] = std::make_tuple(Section, Loc);
+  }
+}
+
 void Sema::ActOnPragmaUnused(const Token &IdTok, Scope *curScope,
                              SourceLocation PragmaLoc) {
 
   IdentifierInfo *Name = IdTok.getIdentifierInfo();
   LookupResult Lookup(*this, Name, IdTok.getLocation(), LookupOrdinaryName);
   LookupParsedName(Lookup, curScope, nullptr, true);
 
   if (Lookup.empty()) {

 
 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::AddSectionMSAllocText(FunctionDecl *FD) {
+  if (!FD->getIdentifier())
+    return;
+
+  StringRef Name = FD->getName();
+  auto It = FunctionToSectionMap.find(Name);
+  if (It != FunctionToSectionMap.end()) {
+    StringRef Section;
+    SourceLocation Loc;
+    std::tie(Section, Loc) = It->second;
+
+    if (!FD->hasAttr<SectionAttr>())
+      FD->addAttr(SectionAttr::CreateImplicit(Context, Section));
+  }
+}
+
 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.

clang/lib/Sema/SemaDecl.cpp

Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC,
   // marking the function.
   AddCFAuditedAttribute(NewFD);
 
   // 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);
+    AddSectionMSAllocText(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);
 

clang/test/CodeGen/msvc_pragma_alloc_text.cpp

+// RUN: %clang_cc1 -fms-extensions -S -emit-llvm -o - %s | FileCheck %s
+
+extern "C" {
+
+void foo();
+void foo1();
+void foo2();
+void foo3();
+
+#pragma alloc_text("abc", foo, foo1)
+#pragma alloc_text("def", foo2)
+#pragma alloc_text("def", foo3)
+
+// CHECK-LABEL: define{{.*}} void @foo() {{.*}} section "abc"
+void foo() {}
+
+// CHECK-LABEL: define{{.*}} void @foo1() {{.*}} section "abc"
+void foo1() {}
+
+// CHECK-LABEL: define{{.*}} void @foo2() {{.*}} section "def"
+void foo2() {}
+
+// CHECK-LABEL: define{{.*}} void @foo3() {{.*}} section "def"
+void foo3() {}
+}

clang/test/Sema/pragma-ms-alloc-text.cpp

+// RUN: %clang_cc1 -fms-extensions -fsyntax-only -verify %s
+
+#pragma alloc_text()        // expected-warning {{expected a string literal for the section name in '#pragma alloc_text'}}
+#pragma alloc_text(a        // expected-warning {{expected ',' in '#pragma alloc_text'}}
+#pragma alloc_text(a, a     // expected-warning {{missing ')' after '#pragma alloc_text'}}
+#pragma alloc_text(a, a)    // expected-error {{use of undeclared a}}
+#pragma alloc_text(L"a", a) // expected-warning {{expected a string literal for the section name}}
+
+void foo();
+#pragma alloc_text(a, foo) // expected-error {{'#pragma alloc_text' is applicable only to functions with C linkage}}
+
+extern "C" void foo1();
+#pragma alloc_text(a, foo1)      // no-warning
+#pragma alloc_text(a, foo1) asdf // expected-warning {{extra tokens at end of '#pragma alloc_text'}}
+#pragma alloc_text(a, foo1       // expected-warning {{missing ')' after '#pragma alloc_text'}}
+
+namespace N {
+#pragma alloc_text(b, foo1) // no-warning
+}
+
+extern "C" {
+void foo2();
+#pragma alloc_text(a, foo2) // no-warning
+}
+
+void foo3() {
+#pragma alloc_text(a, foo1) // expected-error {{'#pragma alloc_text' can only appear at file scope}}
+}
+
+extern "C" void foo4();
+#pragma alloc_text(c, foo4) // no-warning
+void foo4() {}
+
+void foo5();                // expected-note {{previous declaration is here}}
+#pragma alloc_text(c, foo5) // expected-error {{'#pragma alloc_text' is applicable only to functions with C linkage}}
+extern "C" void foo5() {}   // expected-error {{declaration of 'foo5' has a different language linkage}}