You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
Warn when unique objects might be duplicated in shared libraries
When a hidden object is built into multiple shared libraries, each
instance of the library will get its own copy. If
the object was supposed to be globally unique (e.g. a global
variable or static member), this can cause very subtle bugs.
An object might be incorrectly duplicated if it:
- Is defined in a header (so it might appear in multiple TUs), and
- Has external linkage (otherwise it's supposed to be duplicated), and
- Has hidden visibility (or else the dynamic linker will handle it)
The duplication is only a problem if one of the following is true:
1. The object is mutable (the copies won't be in sync), or
2. Its initialization has side effects (it may now run more than once), or
3. The value of its address is used (which one?).
To detect this, we add a new -Wunique-object-duplication warning.
It warns on cases (1) and (2) above. To be conservative, we only
warn in case (2) if we are certain the initializer has side effects,
and we don't warn on `new` because the only side effect is some
extra memory usage.
We don't currently warn on case (3) because doing so is prone to
false positives: there are many reasons for taking the address which
aren't inherently problematic (e.g. passing to a function that expects
a pointer). We only run into problems if the code inspects the value
of the address.
The check is currently disabled for windows, which uses its own analogue
of visibility (declimport/declexport). The check is also disabled inside
templates, since it can give false positives if a template is never
instantiated.
Because the warning fires in several places, included third-party
libraries, it is currently disabled-by-default until all these
instances have been fixed. It should be enabled-by-default afterwards.
staticint disallowedStatic1 = 0; // hidden-warning {{'disallowedStatic1' is mutable, has hidden visibility, and external linkage; it may be duplicated when built into a shared library}}
41
+
// Initialization might run more than once
42
+
staticconstdouble disallowedStatic2 = disallowedStatic1++; // hidden-warning {{'disallowedStatic2' has hidden visibility, and external linkage; its initialization may run more than once when built into a shared library}}
43
+
44
+
// OK, because immutable and compile-time-initialized
staticint disallowedStatic1 = 3; // hidden-warning {{'disallowedStatic1' is mutable, has hidden visibility, and external linkage; it may be duplicated when built into a shared library}}
90
+
// expected-warning@-1 {{'disallowedStatic1' is mutable, has hidden visibility, and external linkage; it may be duplicated when built into a shared library}}
91
+
{
92
+
staticint disallowedStatic2 = 3; // hidden-warning {{'disallowedStatic2' is mutable, has hidden visibility, and external linkage; it may be duplicated when built into a shared library}}
93
+
// expected-warning@-1 {{'disallowedStatic2' is mutable, has hidden visibility, and external linkage; it may be duplicated when built into a shared library}}
94
+
}
95
+
96
+
auto lmb = []() {
97
+
staticint disallowedStatic3 = 3; // hidden-warning {{'disallowedStatic3' is mutable, has hidden visibility, and external linkage; it may be duplicated when built into a shared library}}
98
+
// expected-warning@-1 {{'disallowedStatic3' is mutable, has hidden visibility, and external linkage; it may be duplicated when built into a shared library}}
99
+
};
100
+
}
101
+
102
+
DEFAULT voidstatic_local_never_hidden() {
103
+
staticint allowedStatic1 = 3;
104
+
105
+
{
106
+
staticint allowedStatic2 = 3;
107
+
}
108
+
109
+
auto lmb = []() {
110
+
staticint allowedStatic3 = 3;
111
+
};
112
+
}
113
+
114
+
// Don't warn on this because it's not in a function
externint allowedAddressExtern; // Not a definition
119
+
}
120
+
121
+
inlinevoidhas_regular_local() {
122
+
int allowedAddressLocal = 0;
123
+
}
124
+
125
+
inlinevoidhas_thread_local() {
126
+
// thread_local variables are static by default
127
+
thread_localint disallowedThreadLocal = 0; // hidden-warning {{'disallowedThreadLocal' is mutable, has hidden visibility, and external linkage; it may be duplicated when built into a shared library}}
inlinefloat disallowedGlobal1 = 3.14; // hidden-warning {{'disallowedGlobal1' is mutable, has hidden visibility, and external linkage; it may be duplicated when built into a shared library}}
138
+
// Same as above, but explicitly marked inline
139
+
inlinefloat disallowedGlobal4 = 3.14; // hidden-warning {{'disallowedGlobal4' is mutable, has hidden visibility, and external linkage; it may be duplicated when built into a shared library}}
140
+
141
+
// Initialization might run more than once
142
+
inlineconstdouble disallowedGlobal5 = disallowedGlobal1++; // hidden-warning {{'disallowedGlobal5' has hidden visibility, and external linkage; its initialization may run more than once when built into a shared library}}
143
+
144
+
// OK because internal linkage, so duplication is intended
// OK, because immutable and compile-time-initialized
151
+
constexprint allowedGlobal5 = 0;
152
+
constfloat allowedGlobal6 = 1;
153
+
constexprint allowedGlobal7 = init_constexpr(2);
154
+
constint allowedGlobal8 = init_constexpr(3);
155
+
156
+
// We don't warn on this because non-inline variables can't (legally) appear
157
+
// in more than one TU.
158
+
float allowedGlobal9 = 3.14;
159
+
160
+
// Pointers need to be double-const-qualified
161
+
inlinefloat& nonConstReference = disallowedGlobal1; // hidden-warning {{'nonConstReference' is mutable, has hidden visibility, and external linkage; it may be duplicated when built into a shared library}}
162
+
constinlineint& constReference = allowedGlobal5;
163
+
164
+
inlineint* nonConstPointerToNonConst = nullptr; // hidden-warning {{'nonConstPointerToNonConst' is mutable, has hidden visibility, and external linkage; it may be duplicated when built into a shared library}}
165
+
inlineintconst* nonConstPointerToConst = nullptr; // hidden-warning {{'nonConstPointerToConst' is mutable, has hidden visibility, and external linkage; it may be duplicated when built into a shared library}}
166
+
inlineint* const constPointerToNonConst = nullptr; // hidden-warning {{'constPointerToNonConst' is mutable, has hidden visibility, and external linkage; it may be duplicated when built into a shared library}}
inlineintconst * const ** const * const nestedNonConstPointer = nullptr; // hidden-warning {{'nestedNonConstPointer' is mutable, has hidden visibility, and external linkage; it may be duplicated when built into a shared library}}
173
+
174
+
structTest {
175
+
staticinlinefloat disallowedStaticMember1; // hidden-warning {{'disallowedStaticMember1' is mutable, has hidden visibility, and external linkage; it may be duplicated when built into a shared library}}
176
+
// Defined below, in the header file
177
+
staticfloat disallowedStaticMember2;
178
+
// Defined in the cpp file, so won't get duplicated
179
+
staticfloat allowedStaticMember1;
180
+
181
+
// Tests here are sparse because the AddrTest case below will define plenty
182
+
// more, which aren't problematic to define (because they're immutable), but
183
+
// may still cause problems if their address is taken.
184
+
};
185
+
186
+
inlinefloat Test::disallowedStaticMember2 = 2.3; // hidden-warning {{'disallowedStaticMember2' is mutable, has hidden visibility, and external linkage; it may be duplicated when built into a shared library}}
0 commit comments