maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/test/Sema/dllimport.c

220 lines
10 KiB
C
Raw Normal View History

__declspec is not a core Clang language extension. Instead, require -fms-extensions or -fborland to enable the language extension. Note: __declspec is also temporarily enabled when compiling for a CUDA target because there are implementation details relying on __declspec(property) support currently. When those details change, __declspec should be disabled for CUDA targets. llvm-svn: 238238
2015-05-27 03:44:52 +08:00
// RUN: %clang_cc1 -triple i686-win32 -fsyntax-only -fms-extensions -verify -std=c99 -DMS %s
// RUN: %clang_cc1 -triple x86_64-win32 -fsyntax-only -fms-extensions -verify -std=c11 -DMS %s
// RUN: %clang_cc1 -triple i686-mingw32 -fsyntax-only -fms-extensions -verify -std=c11 -DGNU %s
// RUN: %clang_cc1 -triple x86_64-mingw32 -fsyntax-only -fms-extensions -verify -std=c99 -DGNU %s
Reorganize and improve semantic tests for dllexport/import llvm-svn: 201947
2014-02-23 03:47:30 +08:00
// Invalid usage.
Sema: support __declspec(dll*) on ObjC interfaces Extend the __declspec(dll*) attribute to cover ObjC interfaces. This was requested by Microsoft for their ObjC support. Cover both import and export. This only adds the semantic analysis portion of the support, code-generation still remains outstanding. Add some basic initial documentation on the attributes that were previously empty. Tweak the previous tests to use the relative expected-warnings to make the tests easier to read. llvm-svn: 275610
2016-07-16 04:41:10 +08:00
__declspec(dllimport) typedef int typedef1;
// expected-warning@-1{{'dllimport' attribute only applies to variables and functions}}
typedef __declspec(dllimport) int typedef2;
// expected-warning@-1{{'dllimport' attribute only applies to variables and functions}}
typedef int __declspec(dllimport) typedef3;
// expected-warning@-1{{'dllimport' attribute only applies to variables and functions}}
typedef __declspec(dllimport) void (*FunTy)();
// expected-warning@-1{{'dllimport' attribute only applies to variables and functions}}
enum __declspec(dllimport) Enum { EnumVal };
// expected-warning@-1{{'dllimport' attribute only applies to variables and functions}}
struct __declspec(dllimport) Record {};
// expected-warning@-1{{'dllimport' attribute only applies to variables and functions}}
Reorganize and improve semantic tests for dllexport/import llvm-svn: 201947
2014-02-23 03:47:30 +08:00
//===----------------------------------------------------------------------===//
// Globals
//===----------------------------------------------------------------------===//
// Import declaration.
__declspec(dllimport) extern int ExternGlobalDecl;
Sema: Definition of dllimport globals is not allowed Upgrades the warning to an error and clarifies the message by treating the definition as error instead of the attribute. llvm-svn: 202300
2014-02-27 05:27:13 +08:00
// dllimport implies a declaration.
__declspec(dllimport) int GlobalDecl;
Treat dllimport globals without explicit storage class as extern dllimport implies a definition which means the 'extern' keyword is optional when declaring imported variables. llvm-svn: 204576
2014-03-24 05:24:01 +08:00
int **__attribute__((dllimport))* GlobalDeclChunkAttr;
int GlobalDeclAttr __attribute__((dllimport));
Reorganize and improve semantic tests for dllexport/import llvm-svn: 201947
2014-02-23 03:47:30 +08:00
AST: Initialization with dllimport functions in C The C++ language requires that the address of a function be the same across all translation units. To make __declspec(dllimport) useful, this means that a dllimported function must also obey this rule. MSVC implements this by dynamically querying the import address table located in the linked executable. This means that the address of such a function in C++ is not constant (which violates other rules). However, the C language has no notion of ODR nor does it permit dynamic initialization whatsoever. This requires implementations to _not_ dynamically query the import address table and instead utilize a wrapper function that will be synthesized by the linker which will eventually query the import address table. The effect this has is, to say the least, perplexing. Consider the following C program: __declspec(dllimport) void f(void); typedef void (*fp)(void); static const fp var = &f; const fp fun() { return &f; } int main() { return fun() == var; } MSVC will statically initialize "var" with the address of the wrapper function and "fun" returns the address of the actual imported function. This means that "main" will return false! Note that LLVM's optimizers are strong enough to figure out that "main" should return true. However, this result is dependent on having optimizations enabled! N.B. This change also permits the usage of dllimport declarators inside of template arguments; they are sufficiently constant for such a purpose. Add tests to make sure we don't regress here. llvm-svn: 211677
2014-06-25 16:15:07 +08:00
// Address of variables can't be used for initialization in C language modes.
int *VarForInit = &GlobalDecl; // expected-error{{initializer element is not a compile-time constant}}
Reorganize and improve semantic tests for dllexport/import llvm-svn: 201947
2014-02-23 03:47:30 +08:00
// Not allowed on definitions.
Sema: Definition of dllimport globals is not allowed Upgrades the warning to an error and clarifies the message by treating the definition as error instead of the attribute. llvm-svn: 202300
2014-02-27 05:27:13 +08:00
__declspec(dllimport) extern int ExternGlobalInit = 1; // expected-error{{definition of dllimport data}}
__declspec(dllimport) int GlobalInit1 = 1; // expected-error{{definition of dllimport data}}
int __declspec(dllimport) GlobalInit2 = 1; // expected-error{{definition of dllimport data}}
Reorganize and improve semantic tests for dllexport/import llvm-svn: 201947
2014-02-23 03:47:30 +08:00
// Declare, then reject definition.
[ms][dll] #26935 Defining a dllimport function should cause it to be exported If we have some function with dllimport attribute and then we have the function definition in the same module but without dllimport attribute we should add dllexport attribute to this function definition. The same should be done for variables. Example: struct __declspec(dllimport) C3 { ~C3(); }; C3::~C3() {;} // we should export this definition. Patch by Andrew V. Tischenko Differential revision: http://reviews.llvm.org/D18953 llvm-svn: 270686
2016-05-25 19:32:42 +08:00
#ifdef GNU
// expected-note@+2{{previous attribute is here}}
#endif
__declspec(dllimport) extern int ExternGlobalDeclInit; // expected-note{{previous declaration is here}}
#ifdef MS
// expected-warning@+4{{'ExternGlobalDeclInit' redeclared without 'dllimport' attribute: 'dllexport' attribute added}}
#else
// expected-warning@+2{{'ExternGlobalDeclInit' redeclared without 'dllimport' attribute: previous 'dllimport' ignored}}
#endif
int ExternGlobalDeclInit = 1;
Reorganize and improve semantic tests for dllexport/import llvm-svn: 201947
2014-02-23 03:47:30 +08:00
[ms][dll] #26935 Defining a dllimport function should cause it to be exported If we have some function with dllimport attribute and then we have the function definition in the same module but without dllimport attribute we should add dllexport attribute to this function definition. The same should be done for variables. Example: struct __declspec(dllimport) C3 { ~C3(); }; C3::~C3() {;} // we should export this definition. Patch by Andrew V. Tischenko Differential revision: http://reviews.llvm.org/D18953 llvm-svn: 270686
2016-05-25 19:32:42 +08:00
#ifdef GNU
// expected-note@+2{{previous attribute is here}}
#endif
__declspec(dllimport) int GlobalDeclInit; // expected-note{{previous declaration is here}}
#ifdef MS
// expected-warning@+4{{'GlobalDeclInit' redeclared without 'dllimport' attribute: 'dllexport' attribute added}}
#else
// expected-warning@+2{{'GlobalDeclInit' redeclared without 'dllimport' attribute: previous 'dllimport' ignored}}
#endif
int GlobalDeclInit = 1;
Treat dllimport globals without explicit storage class as extern dllimport implies a definition which means the 'extern' keyword is optional when declaring imported variables. llvm-svn: 204576
2014-03-24 05:24:01 +08:00
[ms][dll] #26935 Defining a dllimport function should cause it to be exported If we have some function with dllimport attribute and then we have the function definition in the same module but without dllimport attribute we should add dllexport attribute to this function definition. The same should be done for variables. Example: struct __declspec(dllimport) C3 { ~C3(); }; C3::~C3() {;} // we should export this definition. Patch by Andrew V. Tischenko Differential revision: http://reviews.llvm.org/D18953 llvm-svn: 270686
2016-05-25 19:32:42 +08:00
#ifdef GNU
// expected-note@+2{{previous attribute is here}}
#endif
int *__attribute__((dllimport)) GlobalDeclChunkAttrInit; // expected-note{{previous declaration is here}}
#ifdef MS
// expected-warning@+4{{'GlobalDeclChunkAttrInit' redeclared without 'dllimport' attribute: 'dllexport' attribute added}}
#else
// expected-warning@+2{{'GlobalDeclChunkAttrInit' redeclared without 'dllimport' attribute: previous 'dllimport' ignored}}
#endif
int *GlobalDeclChunkAttrInit = 0;
Treat dllimport globals without explicit storage class as extern dllimport implies a definition which means the 'extern' keyword is optional when declaring imported variables. llvm-svn: 204576
2014-03-24 05:24:01 +08:00
[ms][dll] #26935 Defining a dllimport function should cause it to be exported If we have some function with dllimport attribute and then we have the function definition in the same module but without dllimport attribute we should add dllexport attribute to this function definition. The same should be done for variables. Example: struct __declspec(dllimport) C3 { ~C3(); }; C3::~C3() {;} // we should export this definition. Patch by Andrew V. Tischenko Differential revision: http://reviews.llvm.org/D18953 llvm-svn: 270686
2016-05-25 19:32:42 +08:00
#ifdef GNU
// expected-note@+2{{previous attribute is here}}
#endif
int GlobalDeclAttrInit __attribute__((dllimport)); // expected-note{{previous declaration is here}}
#ifdef MS
// expected-warning@+4{{'GlobalDeclAttrInit' redeclared without 'dllimport' attribute: 'dllexport' attribute added}}
#else
// expected-warning@+2{{'GlobalDeclAttrInit' redeclared without 'dllimport' attribute: previous 'dllimport' ignored}}
#endif
int GlobalDeclAttrInit = 1;
Treat dllimport globals without explicit storage class as extern dllimport implies a definition which means the 'extern' keyword is optional when declaring imported variables. llvm-svn: 204576
2014-03-24 05:24:01 +08:00
Reorganize and improve semantic tests for dllexport/import llvm-svn: 201947
2014-02-23 03:47:30 +08:00
// Redeclarations
__declspec(dllimport) extern int GlobalRedecl1;
__declspec(dllimport) extern int GlobalRedecl1;
Treat dllimport globals without explicit storage class as extern dllimport implies a definition which means the 'extern' keyword is optional when declaring imported variables. llvm-svn: 204576
2014-03-24 05:24:01 +08:00
__declspec(dllimport) int GlobalRedecl2a;
__declspec(dllimport) int GlobalRedecl2a;
int *__attribute__((dllimport)) GlobalRedecl2b;
int *__attribute__((dllimport)) GlobalRedecl2b;
int GlobalRedecl2c __attribute__((dllimport));
int GlobalRedecl2c __attribute__((dllimport));
[ms][dll] #26935 Defining a dllimport function should cause it to be exported If we have some function with dllimport attribute and then we have the function definition in the same module but without dllimport attribute we should add dllexport attribute to this function definition. The same should be done for variables. Example: struct __declspec(dllimport) C3 { ~C3(); }; C3::~C3() {;} // we should export this definition. Patch by Andrew V. Tischenko Differential revision: http://reviews.llvm.org/D18953 llvm-svn: 270686
2016-05-25 19:32:42 +08:00
// We follow GCC and drop the dllimport with a warning.
Sema: Check dll attributes on redeclarations A redeclaration may not add dllimport or dllexport attributes. dllexport is sticky and can be omitted on redeclarations while dllimport cannot. llvm-svn: 205197
2014-03-31 22:56:15 +08:00
__declspec(dllimport) extern int GlobalRedecl3; // expected-note{{previous declaration is here}} expected-note{{previous attribute is here}}
extern int GlobalRedecl3; // expected-warning{{'GlobalRedecl3' redeclared without 'dllimport' attribute: previous 'dllimport' ignored}}
Allow adding dll attributes on certain redecls with a warning if the decl hasn't been used yet (PR20746) This shouldn't really be allowed, but it comes up in real code (see PR). As long as the decl hasn't been used there's no technical difficulty in supporting it, so downgrade the error to a warning. Differential Revision: http://reviews.llvm.org/D5087 llvm-svn: 216619
2014-08-28 05:27:40 +08:00
// Adding an attribute on redeclaration.
Sema: Check dll attributes on redeclarations A redeclaration may not add dllimport or dllexport attributes. dllexport is sticky and can be omitted on redeclarations while dllimport cannot. llvm-svn: 205197
2014-03-31 22:56:15 +08:00
extern int GlobalRedecl4; // expected-note{{previous declaration is here}}
Allow adding dll attributes on certain redecls with a warning if the decl hasn't been used yet (PR20746) This shouldn't really be allowed, but it comes up in real code (see PR). As long as the decl hasn't been used there's no technical difficulty in supporting it, so downgrade the error to a warning. Differential Revision: http://reviews.llvm.org/D5087 llvm-svn: 216619
2014-08-28 05:27:40 +08:00
int useGlobalRedecl4() { return GlobalRedecl4; }
Sema: Check dll attributes on redeclarations A redeclaration may not add dllimport or dllexport attributes. dllexport is sticky and can be omitted on redeclarations while dllimport cannot. llvm-svn: 205197
2014-03-31 22:56:15 +08:00
__declspec(dllimport) extern int GlobalRedecl4; // expected-error{{redeclaration of 'GlobalRedecl4' cannot add 'dllimport' attribute}}
Allow adding dll attributes on certain redecls with a warning if the decl hasn't been used yet (PR20746) This shouldn't really be allowed, but it comes up in real code (see PR). As long as the decl hasn't been used there's no technical difficulty in supporting it, so downgrade the error to a warning. Differential Revision: http://reviews.llvm.org/D5087 llvm-svn: 216619
2014-08-28 05:27:40 +08:00
// Allow with a warning if the decl hasn't been used yet.
extern int GlobalRedecl5; // expected-note{{previous declaration is here}}
__declspec(dllimport) extern int GlobalRedecl5; // expected-warning{{redeclaration of 'GlobalRedecl5' should not add 'dllimport' attribute}}
Sema: Require external linkage for dll attributes llvm-svn: 205198
2014-03-31 22:56:58 +08:00
// External linkage is required.
__declspec(dllimport) static int StaticGlobal; // expected-error{{'StaticGlobal' must have external linkage when declared 'dllimport'}}
MS ABI: Disallow dllimported/exported variables from having TLS Windows TLS relies on indexing through a tls_index in order to get at the DLL's thread local variables. However, this index is not exported along with the variable: it is assumed that all accesses to thread local variables are inside the same module which created the variable in the first place. While there are several implementation techniques we could adopt to fix this (notably, the Itanium ABI gets this for free), it is not worth the heroics. Instead, let's just ban this combination. We could revisit this in the future if we need to. This fixes PR21111. llvm-svn: 219049
2014-10-04 14:51:54 +08:00
// Thread local variables are invalid.
__declspec(dllimport) __thread int ThreadLocalGlobal; // expected-error{{'ThreadLocalGlobal' cannot be thread local when declared 'dllimport'}}
Sema: Require external linkage for dll attributes llvm-svn: 205198
2014-03-31 22:56:58 +08:00
Reorganize and improve semantic tests for dllexport/import llvm-svn: 201947
2014-02-23 03:47:30 +08:00
// Import in local scope.
[Sema] Emit a better diagnostic when variable redeclarations disagree We referred to all declaration in definitions in our diagnostic messages which is can be inaccurate. Instead, classify the declaration and emit an appropriate diagnostic for the new declaration and an appropriate note pointing to the old one. This fixes PR24116. llvm-svn: 242190
2015-07-15 04:08:49 +08:00
__declspec(dllimport) float LocalRedecl1; // expected-note{{previous declaration is here}}
__declspec(dllimport) float LocalRedecl2; // expected-note{{previous declaration is here}}
__declspec(dllimport) float LocalRedecl3; // expected-note{{previous declaration is here}}
Local extern redeclarations of dllimport variables stay dllimport even if they don't specify the attribute llvm-svn: 214425
2014-08-01 03:29:39 +08:00
__declspec(dllimport) float LocalRedecl4;
Reorganize and improve semantic tests for dllexport/import llvm-svn: 201947
2014-02-23 03:47:30 +08:00
void functionScope() {
[Sema] Emit a better diagnostic when variable redeclarations disagree We referred to all declaration in definitions in our diagnostic messages which is can be inaccurate. Instead, classify the declaration and emit an appropriate diagnostic for the new declaration and an appropriate note pointing to the old one. This fixes PR24116. llvm-svn: 242190
2015-07-15 04:08:49 +08:00
__declspec(dllimport) int LocalRedecl1; // expected-error{{redeclaration of 'LocalRedecl1' with a different type: 'int' vs 'float'}}
int *__attribute__((dllimport)) LocalRedecl2; // expected-error{{redeclaration of 'LocalRedecl2' with a different type: 'int *' vs 'float'}}
int LocalRedecl3 __attribute__((dllimport)); // expected-error{{redeclaration of 'LocalRedecl3' with a different type: 'int' vs 'float'}}
Treat dllimport globals without explicit storage class as extern dllimport implies a definition which means the 'extern' keyword is optional when declaring imported variables. llvm-svn: 204576
2014-03-24 05:24:01 +08:00
Sema: Definition of dllimport globals is not allowed Upgrades the warning to an error and clarifies the message by treating the definition as error instead of the attribute. llvm-svn: 202300
2014-02-27 05:27:13 +08:00
__declspec(dllimport) int LocalVarDecl;
__declspec(dllimport) int LocalVarDef = 1; // expected-error{{definition of dllimport data}}
Reorganize and improve semantic tests for dllexport/import llvm-svn: 201947
2014-02-23 03:47:30 +08:00
__declspec(dllimport) extern int ExternLocalVarDecl;
Sema: Definition of dllimport globals is not allowed Upgrades the warning to an error and clarifies the message by treating the definition as error instead of the attribute. llvm-svn: 202300
2014-02-27 05:27:13 +08:00
__declspec(dllimport) extern int ExternLocalVarDef = 1; // expected-error{{definition of dllimport data}}
Sema: Require external linkage for dll attributes llvm-svn: 205198
2014-03-31 22:56:58 +08:00
__declspec(dllimport) static int StaticLocalVar; // expected-error{{'StaticLocalVar' must have external linkage when declared 'dllimport'}}
Local extern redeclarations of dllimport variables stay dllimport even if they don't specify the attribute llvm-svn: 214425
2014-08-01 03:29:39 +08:00
// Local extern redeclaration does not drop the attribute.
extern float LocalRedecl4;
Reorganize and improve semantic tests for dllexport/import llvm-svn: 201947
2014-02-23 03:47:30 +08:00
}
//===----------------------------------------------------------------------===//
// Functions
//===----------------------------------------------------------------------===//
// Import function declaration. Check different placements.
__attribute__((dllimport)) void decl1A(); // Sanity check with __attribute__
__declspec(dllimport) void decl1B();
void __attribute__((dllimport)) decl2A();
void __declspec(dllimport) decl2B();
AST: Initialization with dllimport functions in C The C++ language requires that the address of a function be the same across all translation units. To make __declspec(dllimport) useful, this means that a dllimported function must also obey this rule. MSVC implements this by dynamically querying the import address table located in the linked executable. This means that the address of such a function in C++ is not constant (which violates other rules). However, the C language has no notion of ODR nor does it permit dynamic initialization whatsoever. This requires implementations to _not_ dynamically query the import address table and instead utilize a wrapper function that will be synthesized by the linker which will eventually query the import address table. The effect this has is, to say the least, perplexing. Consider the following C program: __declspec(dllimport) void f(void); typedef void (*fp)(void); static const fp var = &f; const fp fun() { return &f; } int main() { return fun() == var; } MSVC will statically initialize "var" with the address of the wrapper function and "fun" returns the address of the actual imported function. This means that "main" will return false! Note that LLVM's optimizers are strong enough to figure out that "main" should return true. However, this result is dependent on having optimizations enabled! N.B. This change also permits the usage of dllimport declarators inside of template arguments; they are sufficiently constant for such a purpose. Add tests to make sure we don't regress here. llvm-svn: 211677
2014-06-25 16:15:07 +08:00
// Address of functions can be used for initialization in C language modes.
// However, the address of the thunk wrapping the function is used instead of
// the address in the import address table.
void (*FunForInit)() = &decl2A;
Reorganize and improve semantic tests for dllexport/import llvm-svn: 201947
2014-02-23 03:47:30 +08:00
// Not allowed on function definitions.
Allow dllimport/dllexport on inline functions and adjust the linkage. This is a step towards handling these attributes on classes (PR11170). Differential Revision: http://reviews.llvm.org/D3772 llvm-svn: 208925
2014-05-16 06:07:49 +08:00
__declspec(dllimport) void def() {} // expected-error{{dllimport cannot be applied to non-inline function definition}}
Reorganize and improve semantic tests for dllexport/import llvm-svn: 201947
2014-02-23 03:47:30 +08:00
// Import inline function.
Don't dllimport inline functions when targeting MinGW (PR21366) It turns out that MinGW never dllimports of exports inline functions. This means that code compiled with Clang would fail to link with MinGW-compiled libraries since we might try to import functions that are not imported. To fix this, make Clang never dllimport inline functions when targeting MinGW. llvm-svn: 221154
2014-11-03 22:24:45 +08:00
#ifdef GNU
// expected-warning@+3{{'dllimport' attribute ignored on inline function}}
// expected-warning@+3{{'dllimport' attribute ignored on inline function}}
#endif
Allow dllimport/dllexport on inline functions and adjust the linkage. This is a step towards handling these attributes on classes (PR11170). Differential Revision: http://reviews.llvm.org/D3772 llvm-svn: 208925
2014-05-16 06:07:49 +08:00
__declspec(dllimport) inline void inlineFunc1() {}
inline void __attribute__((dllimport)) inlineFunc2() {}
Reorganize and improve semantic tests for dllexport/import llvm-svn: 201947
2014-02-23 03:47:30 +08:00
// Redeclarations
__declspec(dllimport) void redecl1();
__declspec(dllimport) void redecl1();
Sema: Check dll attributes on redeclarations A redeclaration may not add dllimport or dllexport attributes. dllexport is sticky and can be omitted on redeclarations while dllimport cannot. llvm-svn: 205197
2014-03-31 22:56:15 +08:00
__declspec(dllimport) void redecl2(); // expected-note{{previous declaration is here}} expected-note{{previous attribute is here}}
void redecl2(); // expected-warning{{'redecl2' redeclared without 'dllimport' attribute: previous 'dllimport' ignored}}
[ms][dll] #26935 Defining a dllimport function should cause it to be exported If we have some function with dllimport attribute and then we have the function definition in the same module but without dllimport attribute we should add dllexport attribute to this function definition. The same should be done for variables. Example: struct __declspec(dllimport) C3 { ~C3(); }; C3::~C3() {;} // we should export this definition. Patch by Andrew V. Tischenko Differential revision: http://reviews.llvm.org/D18953 llvm-svn: 270686
2016-05-25 19:32:42 +08:00
#ifdef GNU
// expected-note@+2{{previous attribute is here}}
#endif
__declspec(dllimport) void redecl3(); // expected-note{{previous declaration is here}}
// NB: Both MSVC and Clang issue a warning and make redecl3 dllexport.
#ifdef MS
// expected-warning@+4{{'redecl3' redeclared without 'dllimport' attribute: 'dllexport' attribute added}}
#else
// expected-warning@+2{{'redecl3' redeclared without 'dllimport' attribute: previous 'dllimport' ignored}}
#endif
void redecl3() {}
Sema: Check dll attributes on redeclarations A redeclaration may not add dllimport or dllexport attributes. dllexport is sticky and can be omitted on redeclarations while dllimport cannot. llvm-svn: 205197
2014-03-31 22:56:15 +08:00
void redecl4(); // expected-note{{previous declaration is here}}
Allow adding dll attributes on certain redecls with a warning if the decl hasn't been used yet (PR20746) This shouldn't really be allowed, but it comes up in real code (see PR). As long as the decl hasn't been used there's no technical difficulty in supporting it, so downgrade the error to a warning. Differential Revision: http://reviews.llvm.org/D5087 llvm-svn: 216619
2014-08-28 05:27:40 +08:00
void useRedecl4() { redecl4(); }
Downgrade error about adding 'dllimport' to used free function to warning (PR24215) The code will still work as it can reference the function via its thunk. llvm-svn: 242973
2015-07-23 07:54:51 +08:00
__declspec(dllimport) void redecl4(); // expected-warning{{redeclaration of 'redecl4' should not add 'dllimport' attribute}}
Sema: Require external linkage for dll attributes llvm-svn: 205198
2014-03-31 22:56:58 +08:00
Allow adding dll attributes on certain redecls with a warning if the decl hasn't been used yet (PR20746) This shouldn't really be allowed, but it comes up in real code (see PR). As long as the decl hasn't been used there's no technical difficulty in supporting it, so downgrade the error to a warning. Differential Revision: http://reviews.llvm.org/D5087 llvm-svn: 216619
2014-08-28 05:27:40 +08:00
// Allow with a warning if the decl hasn't been used yet.
void redecl5(); // expected-note{{previous declaration is here}}
__declspec(dllimport) void redecl5(); // expected-warning{{redeclaration of 'redecl5' should not add 'dllimport' attribute}}
Don't dllimport inline functions when targeting MinGW (PR21366) It turns out that MinGW never dllimports of exports inline functions. This means that code compiled with Clang would fail to link with MinGW-compiled libraries since we might try to import functions that are not imported. To fix this, make Clang never dllimport inline functions when targeting MinGW. llvm-svn: 221154
2014-11-03 22:24:45 +08:00
// Inline redeclarations.
#ifdef GNU
// expected-warning@+3{{'redecl6' redeclared inline; 'dllimport' attribute ignored}}
#endif
Allow adding dll attributes on certain redecls with a warning if the decl hasn't been used yet (PR20746) This shouldn't really be allowed, but it comes up in real code (see PR). As long as the decl hasn't been used there's no technical difficulty in supporting it, so downgrade the error to a warning. Differential Revision: http://reviews.llvm.org/D5087 llvm-svn: 216619
2014-08-28 05:27:40 +08:00
__declspec(dllimport) void redecl6();
inline void redecl6() {}
Sema: Add more tests for dll attributes on inline functions llvm-svn: 209542
2014-05-24 03:07:49 +08:00
Don't dllimport inline functions when targeting MinGW (PR21366) It turns out that MinGW never dllimports of exports inline functions. This means that code compiled with Clang would fail to link with MinGW-compiled libraries since we might try to import functions that are not imported. To fix this, make Clang never dllimport inline functions when targeting MinGW. llvm-svn: 221154
2014-11-03 22:24:45 +08:00
#ifdef MS
// expected-note@+5{{previous declaration is here}}
// expected-warning@+5{{redeclaration of 'redecl7' should not add 'dllimport' attribute}}
#else
// expected-warning@+3{{'dllimport' attribute ignored on inline function}}
#endif
void redecl7();
__declspec(dllimport) inline void redecl7() {}
An inline function redeclaration does not drop the dllimport attribute llvm-svn: 209449
2014-05-22 23:46:15 +08:00
Sema: Require external linkage for dll attributes llvm-svn: 205198
2014-03-31 22:56:58 +08:00
// External linkage is required.
__declspec(dllimport) static int staticFunc(); // expected-error{{'staticFunc' must have external linkage when declared 'dllimport'}}
Don't allow dllexport/import on static local variables They might technically have external linkage, but it still doesn't make sense for the user to try and export such variables. This matches MSVC's and MinGW's behaviour. llvm-svn: 246864
2015-09-05 03:59:39 +08:00
// Static locals don't count as having external linkage.
void staticLocalFunc() {
__declspec(dllimport) static int staticLocal; // expected-error{{'staticLocal' must have external linkage when declared 'dllimport'}}
}