[MSVC] Fix pragma alloc_text failing for C files

[steplong]

Summary

isExternCContext() is returning false for functions in C files

[rnk]

lgtm

[steplong]

It looks like MSVC also accepts

// foo.c
static void foo();
#pragma alloc_text("hello", foo)
void foo() {}

and

// foo.cpp
extern "C" {
static void foo();
#pragma alloc_text("hello", foo)
void foo() {}
}

Do you know of a way I can check whether a function is coming from c or c++? isExternC() returns false for the static case

[aaron.ballman]

In D126559#3547921, @steplong wrote:

It looks like MSVC also accepts

// foo.c
static void foo();
#pragma alloc_text("hello", foo)
void foo() {}

and

// foo.cpp
extern "C" {
static void foo();
#pragma alloc_text("hello", foo)
void foo() {}
}

Do you know of a way I can check whether a function is coming from c or c++? isExternC() returns false for the static case

You can look at !LangOpts.CPlusPlus to know that you're in C mode (or C++ mode)

[steplong]

• Handle static C/C++ functions and C functions in general

[aaron.ballman]

LGTM!

[steplong]

Hmm, it looks like MSVC is accepting:

extern "C" {
static void foo();
}

static int foo();
#pragma alloc_text("s", foo)
static void foo() {}

Ignoring the pragma alloc_text, it looks like GCC compiles the following foo with C linkage vs LLVM which compiles with C++ linkage (foo's name is mangled):

extern "C" {
static int foo();
}

static int foo();
static int foo() {
  return 3;
}

int bar() {
  return foo();
}

[hans]

Ignoring the pragma alloc_text, it looks like GCC compiles the following foo with C linkage vs LLVM which compiles with C++ linkage (foo's name is mangled):

The mangled name shouldn't matter since it has internal linkage. I tried dropping the static, and then foo doesn't seem to get mangled: https://godbolt.org/z/arzW5TbYz

[steplong]

In D126559#3598885, @hans wrote:

Ignoring the pragma alloc_text, it looks like GCC compiles the following foo with C linkage vs LLVM which compiles with C++ linkage (foo's name is mangled):

The mangled name shouldn't matter since it has internal linkage. I tried dropping the static, and then foo doesn't seem to get mangled: https://godbolt.org/z/arzW5TbYz

Oh I see, that makes sense. We aren't accepting https://godbolt.org/z/9Yej9vhYd. Do you know of a way to get the NamedDecl with extern "C" instead of the second declaration?

[hans]

Oh I see, that makes sense. We aren't accepting https://godbolt.org/z/9Yej9vhYd. Do you know of a way to get the NamedDecl with extern "C" instead of the second declaration?

I'm not sure I understand the question, but it seems the current code is checking isExternCContext(). I think instead you want to check FunctionDecl::isExternC().

[steplong]

In D126559#3598950, @hans wrote:

Oh I see, that makes sense. We aren't accepting https://godbolt.org/z/9Yej9vhYd. Do you know of a way to get the NamedDecl with extern "C" instead of the second declaration?

I'm not sure I understand the question, but it seems the current code is checking isExternCContext(). I think instead you want to check FunctionDecl::isExternC().

Oh, that answers my question. I'll give that a try. Thanks!

[steplong]

I tried the following:

FunctionDecl *FD = ND->getAsFunction();
DeclContext *DC = ND->getDeclContext();
DEBUG_WITH_TYPE("foo", llvm::dbgs() << "[FOO] DC->isExternCContext()         : " << DC->isExternCContext()         << "\n");
DEBUG_WITH_TYPE("foo", llvm::dbgs() << "[FOO] FD->isExternC()                : " << FD->isExternC()                << "\n");
DEBUG_WITH_TYPE("foo", llvm::dbgs() << "[FOO] FD->isInExternCContext()       : " << FD->isInExternCContext()       << "\n");
llvm::dbgs() << "[FOO] "; ND->dump();
if (getLangOpts().CPlusPlus && !DC->isExternCContext()) {
  Diag(Loc, diag::err_pragma_alloc_text_c_linkage);
  return;
}

and I'm getting the following output:

[FOO] DC->isExternCContext()         : 0
[FOO] FD->isExternC()                : 0
[FOO] FD->isInExternCContext()       : 0
[FOO] FunctionDecl 0x10ec0250 prev 0x10ec0148 <foo.cpp:4:1, col:17> col:13 foo 'void ()' static

The C file is:

1 extern "C" {
2 static void foo();
3 }
4 static void foo();
5 #pragma alloc_text("s", foo)
6 static void foo() {}

clang/lib/Sema/SemaAttr.cpp

for (auto &Function : Functions) {
     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()) {
+    if (getLangOpts().CPlusPlus && !DC->isExternCContext()) {
       Diag(Loc, diag::err_pragma_alloc_text_c_linkage);
       return;
     }
 
     FunctionToSectionMap[II->getName()] = std::make_tuple(Section, Loc);
   }
 }
 

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

+// RUN: %clang_cc1 -fms-extensions -fsyntax-only -verify %s
+
+void foo();
+#pragma alloc_text("hello", foo) // expected-no-diagnostics
+void foo() {}
+
+static void foo1();
+#pragma alloc_text("hello", foo1) // expected-no-diagnostics
+void foo1() {}

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

 
 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}}
+
+extern "C" {
+static void foo6();
+#pragma alloc_text(c, foo6) // no-warning
+void foo6() {}
+}