[MS ABI] dllimport'd class cannot have constexpr ctors

[majnemer]

Summary

The installation of a class's vptr cannot be performed without code
being executed. This implies that the constructor of a class cannot be
constexpr.

This fixes PR26506.

[thakis]

Thanks for jumping on this so quickly! Hans can probably just stamp this, but I lack the background, so I must ask:

test/SemaCXX/dllimport.cpp

1262

cl.exe seems to accept this – do you know how they do that? Do they just silently ignore the constexpr?

1269

nit: I feel diagnostics are easier to understand if their text is stand-alone and not spread across diag and its note. That is "dllimported constructors cannot be marked constexpr" "note: dllimported here" or something like this (this also helps with the mythical localization of diagnostics).

[majnemer]

test/SemaCXX/dllimport.cpp

1262

They silently ignore the constexpr:

struct __declspec(dllimport) PR26506_test1 {
  virtual ~PR26506_test1() {}
  constexpr PR26506_test1() = default;
};
constexpr PR26506_test1 x;

They report:

Microsoft (R) C/C++ Optimizing Compiler Version 19.00.23506 for x64
Copyright (C) Microsoft Corporation.  All rights reserved.

t.cpp
t.cpp(5): error C2127: 'x': illegal initialization of 'constexpr' entity with a non-constant expression

1269

I chose this style because it is most consistent with our diagnostic for a constexpr constructor for a class with virtual bases.

[thakis]

Cool, lgtm. Maybe we'll have to downgrade this to a warning eventually since cl allows it, but for now let's see how this goes.

test/SemaCXX/dllimport.cpp

1269

Hm, I suppose I feel we should change those too then :-) (but that's a discussion for somewhere else then)

[hans]

lgtm

[Eugene.Zelenko]

Looks like patch was not committed.

[thakis]

David landed a better fix in r260388.

include/clang/Basic/DiagnosticSemaKinds.td

def warn_cxx14_compat_constexpr_not_const : Warning<
   InGroup<DiagGroup<"constexpr-not-const">>;
 def err_invalid_constexpr : Error<
   "%select{function parameter|typedef|non-static data member}0 "
   "cannot be constexpr">;
 def err_invalid_constexpr_member : Error<"non-static data member cannot be "
   "constexpr%select{; did you intend to make it %select{const|static}0?|}1">;
 def err_constexpr_tag : Error<
   "%select{class|struct|interface|union|enum}0 cannot be marked constexpr">;
+def err_constexpr_ctor : Error<"constructor cannot be marked constexpr">;
+def note_due_to_dllimported_class : Note<
+  "due to %0 being dllimported">;
 def err_constexpr_dtor : Error<"destructor cannot be marked constexpr">;
 def err_constexpr_no_declarators : Error<
   "constexpr can only be used in variable and function declarations">;
 def err_invalid_constexpr_var_decl : Error<
   "constexpr variable declaration must be a definition">;
 def err_constexpr_static_mem_var_requires_init : Error<
   "declaration of constexpr static data member %0 requires an initializer">;
 def err_constexpr_var_non_literal : Error<

lib/AST/DeclCXX.cpp

if (Method->isVirtual()) {
 
       // C++0x [class]p7:
       //   A standard-layout class is a class that: [...]
       //    -- has no virtual functions
       data().IsStandardLayout = false;
     }
   }
 
+  // We cannot have a constexpr default constructor if the class is polymorphic
+  // because it is impossible to synthesize a reference to the imported vtable
+  // without generating code.
+  if (data().Polymorphic && hasAttr<DLLImportAttr>())
+    data().DefaultedDefaultConstructorIsConstexpr = false;
+
   // Notify the listener if an implicit member was added after the definition
   // was completed.
   if (!isBeingDefined() && D->isImplicit())
     if (ASTMutationListener *L = getASTMutationListener())
       L->AddedCXXImplicitMember(data().Definition, D);
 
   // The kind of special member this declaration is, if any.
   unsigned SMKind = 0;

lib/Sema/SemaDeclCXX.cpp

 bool Sema::CheckConstexprFunctionDecl(const FunctionDecl *NewFD) {
   const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD);
   if (MD && MD->isInstance()) {
     // C++11 [dcl.constexpr]p4:
     //  The definition of a constexpr constructor shall satisfy the following
     //  constraints:
     //  - the class shall not have any virtual base classes;
     const CXXRecordDecl *RD = MD->getParent();
+    bool IsCtor = isa<CXXConstructorDecl>(NewFD);
     if (RD->getNumVBases()) {
       Diag(NewFD->getLocation(), diag::err_constexpr_virtual_base)
-        << isa<CXXConstructorDecl>(NewFD)
+        << IsCtor
         << getRecordDiagFromTagKind(RD->getTagKind()) << RD->getNumVBases();
       for (const auto &I : RD->vbases())
         Diag(I.getLocStart(),
              diag::note_constexpr_virtual_base_here) << I.getSourceRange();
       return false;
     }
+    // A constructor for a polymorphic class cannot be constexpr if the class
+    // has been marked dllimport.  This is because dllimport data cannot be
+    // resolved in a constant: code must be executed to dereference the __imp
+    // symbol.
+    if (IsCtor && RD->isPolymorphic() && RD->hasAttr<DLLImportAttr>()) {
+      Diag(NewFD->getLocation(), diag::err_constexpr_ctor);
+      Diag(RD->getLocStart(), diag::note_due_to_dllimported_class) << RD;
+      return false;
+    }
   }
 
   if (!isa<CXXConstructorDecl>(NewFD)) {
     // C++11 [dcl.constexpr]p3:
     //  The definition of a constexpr function shall satisfy the following
     //  constraints:
     // - it shall not be virtual;
     const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD);

test/CodeGenCXX/dllimport.cpp

 
 struct __declspec(dllimport) W { virtual void foo() {} };
 USECLASS(W)
 // vftable:
 // MO1-DAG: @"\01??_7W@@6B@" = available_externally dllimport unnamed_addr constant [1 x i8*] [i8* bitcast (void (%struct.W*)* @"\01?foo@W@@UAEXXZ" to i8*)]
 // GO1-DAG: @_ZTV1W = available_externally dllimport unnamed_addr constant [3 x i8*] [i8* null, i8* null, i8* bitcast (void (%struct.W*)* @_ZN1W3fooEv to i8*)]
 
 struct __declspec(dllimport) KeyFuncClass {
-  constexpr KeyFuncClass() {}
+  KeyFuncClass() {}
   virtual void foo();
 };
-extern constexpr KeyFuncClass keyFuncClassVar = {};
+extern KeyFuncClass keyFuncClassVar = {};
 // G32-DAG: @_ZTV12KeyFuncClass = external dllimport unnamed_addr constant [3 x i8*]
 
 struct __declspec(dllimport) X : public virtual W {};
 USECLASS(X)
 // vbtable:
 // MO1-DAG: @"\01??_8X@@7B@" = available_externally dllimport unnamed_addr constant [2 x i32] [i32 0, i32 4]
 
 struct __declspec(dllimport) Y {

test/SemaCXX/dllimport.cpp

 // expected-warning@+3{{'dllimport' attribute ignored}}
 #endif
 template <typename T> struct PartiallySpecializedClassTemplate {};
 template <typename T> struct __declspec(dllimport) PartiallySpecializedClassTemplate<T*> { void f() {} };
 
 template <typename T> struct ExpliciallySpecializedClassTemplate {};
 template <> struct __declspec(dllimport) ExpliciallySpecializedClassTemplate<int> { void f() {} };
 
+struct __declspec(dllimport) PR26506_test1 {
+  virtual ~PR26506_test1() {}
+  constexpr PR26506_test1() = default; // expected-error{{defaulted definition of default constructor is not constexpr}}
+};
+
+struct __declspec(dllimport) PR26506_test2 { // expected-note{{due to 'PR26506_test2' being dllimported}}
+  virtual ~PR26506_test2() {}
+  constexpr PR26506_test2() {} // expected-error{{constructor cannot be marked constexpr}}
+};
 
 //===----------------------------------------------------------------------===//
 // Classes with template base classes
 //===----------------------------------------------------------------------===//
 
 template <typename T> class __declspec(dllexport) ExportedClassTemplate {};
 
 template <typename T> class __declspec(dllimport) ImportedClassTemplate {};