SemaDeclCXX.cpp: Make -Wglobal-constructors more forgiving.

[ygribov]

Summary

This patch liberalizes -Wglobal-constructors to not emit warning if constructor is likely to be optimized away. This covers important LinkerInitialized idiom used e.g. in libsanitizer and Chromium:

enum LinkerInitialized { LINKER_INITIALIZED };
class Mutex {
public:
  inline Mutex(base::LinkerInitialized) {}
};
Mutex mu(LINKER_INITIALIZED);  // Will be optimized away

No regressions in check-all.

[thakis]

You can't know that all compilers will optimize this away, can you?

[ygribov]

You can't know that all compilers will optimize this away, can you?

Sure, even Clang won't optimize this at -O0. Basically this patch weakens the check to make a common programming idiom warning-free.

[ygribov]

As pointed out by David Blaikie in cfe-commits, this can be fixed in user code via constexpr so patch is probably not very important.

lib/Sema/SemaDecl.cpp

void Sema::CheckCompleteVariableDeclaration(VarDecl *var) {
   }
 
   Expr *Init = var->getInit();
   bool IsGlobal = var->hasGlobalStorage() && !var->isStaticLocal();
   QualType baseType = Context.getBaseElementType(type);
 
   if (!var->getDeclContext()->isDependentContext() &&
       Init && !Init->isValueDependent()) {
-    if (IsGlobal && !var->isConstexpr() &&
-        !getDiagnostics().isIgnored(diag::warn_global_constructor,
-                                    var->getLocation())) {
+    do {
+      if (!IsGlobal || var->isConstexpr() ||
+          getDiagnostics().isIgnored(diag::warn_global_constructor,
+                                      var->getLocation()))
+        break;
+
       // Warn about globals which don't have a constant initializer.  Don't
       // warn about globals with a non-trivial destructor because we already
       // warned about them.
       CXXRecordDecl *RD = baseType->getAsCXXRecordDecl();
-      if (!(RD && !RD->hasTrivialDestructor()) &&
-          !Init->isConstantInitializer(Context, baseType->isReferenceType()))
-        Diag(var->getLocation(), diag::warn_global_constructor)
-          << Init->getSourceRange();
-    }
+      if ((RD && !RD->hasTrivialDestructor()) ||
+          Init->isConstantInitializer(Context, baseType->isReferenceType()))
+        break;
+
+      CXXConstructExpr *CtorInit = dyn_cast_or_null<CXXConstructExpr>(Init);
+      if (CtorInit) {
+        // Do not warn if constructor will likely generate no code.
+        CXXConstructorDecl *CtorDecl = CtorInit->getConstructor();
+        Stmt *CtorBody = CtorDecl->getBody();
+        bool HasEmptyBody = CtorBody && CtorDecl->isDefined() && cast<CompoundStmt>(CtorBody)->body_empty();
+        bool HasNoInitializers = !CtorDecl->getNumCtorInitializers();
+        if (HasEmptyBody && HasNoInitializers)
+          break;
+      }
+
+    } while(0);
 
     if (var->isConstexpr()) {
       SmallVector<PartialDiagnosticAt, 8> Notes;
       if (!var->evaluateValue(Notes) || !var->isInitICE()) {
         SourceLocation DiagLoc = var->getLocation();
         // If the note doesn't add any useful information other than a source
         // location, fold it into the primary diagnostic.
         if (Notes.size() == 1 && Notes[0].second.getDiagID() ==

test/SemaCXX/warn-global-constructors.cpp

namespace pr19253 {
   };
   struct E : D {
     D d;
     ~E() = default;
   };
   E e;
 }
 
+namespace LinkerInitialized {
+  enum LinkerInitialized { LINKER_INITIALIZED = 0 };
+
+  struct BlockingMutex {
+    BlockingMutex(LinkerInitialized) {}
+    BlockingMutex() {}
+    char owner_;
+  };
+
+  BlockingMutex mu(LINKER_INITIALIZED);  // elided
+}
+
 namespace pr20420 {
 // No warning is expected. This used to crash.
 void *array_storage[1];
 const int &global_reference = *(int *)array_storage;
 }