| // RUN: %clang_cc1 -triple=x86_64-unknown-linux -Wpragmas -verify -emit-llvm -o - %s | FileCheck %s --check-prefix=CHECK | |
| // RUN: %clang_cc1 -triple=x86_64-unknown-linux -Wpragmas -verify -emit-llvm -o - %s | FileCheck %s --check-prefix=CONTAINS | |
| /// Ensure nothing ever creates any identifiers with check_not_ in them. | |
| // CONTAINS-NOT: check_not_ | |
| /// Check that C functions are affected normally. | |
| #pragma redefine_extname check_not_foo_cfunc bar_cfunc | |
| #pragma redefine_extname check_not_foo_cvar bar_cvar | |
| extern "C" int check_not_foo_cfunc() { return 1; } | |
| // CHECK-DAG: @bar_cfunc | |
| extern "C" int check_not_foo_cvar = 1; | |
| // CHECK-DAG: @bar_cvar | |
| /// Check that there is a warning for C++ functions (which are not affected). | |
| #pragma redefine_extname foo_cppfunc check_not_bar_cppfunc | |
| int foo_cppfunc() { return 1; } // expected-warning {{#pragma redefine_extname is applicable to external C declarations only; not applied to function 'foo_cppfunc'}} | |
| // CHECK-DAG: {{@[^ ]*foo_cppfunc}} | |
| /// Check that there is a warning for C++ variables (which are not affected). | |
| #pragma redefine_extname foo_cppvar check_not_bar_cppvar | |
| int foo_cppvar = 1; // expected-warning {{#pragma redefine_extname is applicable to external C declarations only; not applied to variable 'foo_cppvar'}} | |
| // CHECK-DAG: {{@[^ ]*foo_cppvar}} | |
| /// Check that the warning goes away when doing it in a namespace. | |
| /// Such uses are clearly scoped and need no warning (and often can be intentional). | |
| #pragma redefine_extname foo_nsfunc check_not_bar_nsfunc | |
| #pragma redefine_extname foo_nsvar check_not_bar_nsvar | |
| namespace ns { | |
| int foo_nsfunc() { return 1; } | |
| // CHECK-DAG: {{@[^ ]*foo_nsfunc}} | |
| int foo_nsvar = 1; | |
| // CHECK-DAG: {{@[^ ]*foo_nsvar}} | |
| } // namespace ns | |
| /// Check that the warning goes away when doing it in a class. | |
| /// Such uses are clearly scoped and need no warning (and often can be intentional). | |
| #pragma redefine_extname foo_classmethod check_not_bar_classmethod | |
| #pragma redefine_extname foo_staticmethod check_not_bar_staticmethod | |
| #pragma redefine_extname foo_classmember check_not_bar_classmember | |
| #pragma redefine_extname foo_staticmember check_not_bar_staticmember | |
| class C { | |
| public: | |
| int foo_classmethod(); | |
| // CHECK-DAG: {{@[^ ]*foo_classmethod}} | |
| static int foo_staticmethod(); | |
| // CHECK-DAG: {{@[^ ]*foo_staticmethod}} | |
| int foo_classmember = 1; | |
| // CHECK-DAG: {{%[^ ]*foo_classmember}} | |
| static int foo_staticmember; | |
| // CHECK-DAG: {{@[^ ]*foo_staticmember}} | |
| }; | |
| int C::foo_classmethod() { return 1; } | |
| int C::foo_staticmethod() { return 1; } | |
| int C::foo_staticmember = 1; | |
| // Force C to be actually instantiated. Emits a reference to foo_classmember. | |
| void instantiate_C(C *p) { p = new C; } | |
| /// Check that the warning remains when doing it in an extern "C++" block. | |
| /// Such blocks do not affect scope. | |
| extern "C++" { | |
| #pragma redefine_extname foo_extcppfunc check_not_bar_extcppfunc | |
| #pragma redefine_extname foo_extcppvar check_not_bar_extcppvar | |
| int foo_extcppfunc() { return 1; } // expected-warning {{#pragma redefine_extname is applicable to external C declarations only; not applied to function 'foo_extcppfunc'}} | |
| // CHECK-DAG: {{@[^ ]*foo_extcppfunc}} | |
| int foo_extcppvar = 1; // expected-warning {{#pragma redefine_extname is applicable to external C declarations only; not applied to variable 'foo_extcppvar'}} | |
| // CHECK-DAG: {{@[^ ]*foo_extcppvar}} | |
| } | |
| /// Check that the warning remains when doing it in C++ class friends. | |
| /// These are actually in global scope. | |
| #pragma redefine_extname foo_friendcppfunc check_not_bar_friendcppfunc | |
| class F { | |
| public: | |
| friend int foo_friendcppfunc(F f) { return 1; } // expected-warning {{#pragma redefine_extname is applicable to external C declarations only; not applied to function 'foo_friendcppfunc'}} | |
| // CHECK-DAG: {{@[^ ]*foo_friendcppfunc}} | |
| }; | |
| // Force foo_friendcppfunc to be actually instantiated. | |
| int instantiate_friendcppfunc() { return foo_friendcppfunc(F{}); } | |
| /// Check that extern "C" friends can be renamed. | |
| #pragma redefine_extname check_not_foo_friendcfunc bar_friendcfunc | |
| extern "C" { | |
| class CF { | |
| public: | |
| friend int check_not_foo_friendcfunc(CF cf) { return 1; } | |
| // CHECK-DAG: @bar_friendcfunc | |
| }; | |
| // Force foo_friendcfunc to be actually instantiated. | |
| int instantiate_friendcfunc() { return check_not_foo_friendcfunc(CF{}); } | |
| } | |
| #pragma redefine_extname foo_arg check_not_bar_arg | |
| #pragma redefine_extname foo_local check_not_bar_local | |
| #pragma redefine_extname foo_staticlocal check_not_bar_staticlocal | |
| int func(int foo_arg = 1) { | |
| // CHECK-DAG: %foo_arg | |
| int foo_local = 2; | |
| // CHECK-DAG: %foo_local | |
| static int foo_staticlocal = 3; | |
| // CHECK-DAG: {{@[^ ]*foo_staticlocal}} | |
| /// A hard enough nonsense computation to force foo_local to exist. | |
| for (int i = 0; i < foo_arg; ++i) { | |
| foo_local += foo_staticlocal++; | |
| } | |
| return foo_arg + foo_local + foo_staticlocal; | |
| } |