[DebugInfo] Change to constructor homing debug info mode: skip constexpr constructed types

[akhuang]

Summary

In constructor type homing mode sometimes complete debug info for constexpr
types was missing, because there was not a constructor emitted. This change
makes constructor type homing ignore constexpr types.

[rnk]

clang/lib/CodeGen/CGDebugInfo.cpp

2264–2266

I'm not sure isLiteral is quite the right check. I think there are some ways to:

• have a type that is not literal
• construct it at compile time with the constexpr constructor
• skip object destruction

I came up with this example:

struct ConstexprCtor {
  constexpr ConstexprCtor(int a, int b) : a(a + 1), b(b + 1) {}
  ~ConstexprCtor();
  int a, b;
};

[[clang::no_destroy]] ConstexprCtor static_gv{1, 2};

I tried to find other ways to construct a class in a constexpr context without running the destructor, but wasn't able to.

It would also be interesting to know if StringRef and ArrayRef are literal or not. Those seem like types that we would want to apply this optimization to, and they have constexpr constructors. Maybe we can find a way to apply the optimization by figuring out if a constexpr constructor has been evaluated. You could look at who calls Sema::MarkFunctionReferenced and see if there are any callbacks into the ASTConsumer around there.

[dblaikie]

This comment was removed by dblaikie.

[dblaikie]

clang/lib/CodeGen/CGDebugInfo.cpp

2264–2266

Was (well did, and then realized you'd covered it) going to say the same thing about "is literal type" probably being too narrow here. Testing for the presence of a non-copy/move ctor constexpr ctor I think would be the right test.

I'd say it'd be best to fix this broadly first, then in a separate patch/work try to find a way to get some types with constexpr ctors back in - as I think that's going to be extra tricky with optimizations, linkages, etc. Maybe not - but I think there's enough to discuss there that we shouldn't tie that discussion together with this correctness issue.

[akhuang]

Change check to hasConstexprNonCopyMoveConstructor()

[akhuang]

clang/lib/CodeGen/CGDebugInfo.cpp

2264–2266

Sounds good! And yeah, I sort of started looking into how to not ignore all constexpr ctor types, makes sense to put it in a separate patch.

[rnk]

Sounds good to me, lgtm

clang/lib/CodeGen/CGDebugInfo.cpp

static bool shouldOmitDefinition(codegenoptions::DebugInfoKind DebugKind,
   if (CXXDecl->hasDefinition() && CXXDecl->isDynamicClass() &&
       !isClassOrMethodDLLImport(CXXDecl))
     return true;
 
   // In constructor debug mode, only emit debug info for a class when its
   // constructor is emitted. Skip this optimization if the class or any of
   // its methods are marked dllimport.
   if (DebugKind == codegenoptions::DebugInfoConstructor &&
-      !CXXDecl->isLambda() && !isClassOrMethodDLLImport(CXXDecl)) {
-    for (const auto *Ctor : CXXDecl->ctors()) {
+      !CXXDecl->isLambda() && !CXXDecl->hasConstexprNonCopyMoveConstructor() &&
+      !isClassOrMethodDLLImport(CXXDecl))
+    for (const auto *Ctor : CXXDecl->ctors())
       if (Ctor->isUserProvided())
         return true;
-    }
-  }
 
   TemplateSpecializationKind Spec = TSK_Undeclared;
   if (const auto *SD = dyn_cast<ClassTemplateSpecializationDecl>(RD))
     Spec = SD->getSpecializationKind();
 
   if (Spec == TSK_ExplicitInstantiationDeclaration &&
       hasExplicitMemberDefinition(CXXDecl->method_begin(),
                                   CXXDecl->method_end()))

clang/test/CodeGenCXX/debug-info-limited-ctor.cpp

 // RUN: %clang -cc1 -debug-info-kind=constructor -emit-llvm %s -o - | FileCheck %s
 
-// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "A"
-// CHECK-NOT:              DIFlagFwdDecl
-// CHECK-SAME:             ){{$}}
-struct A {};
-void TestA() { A a; }
+// CHECK-DAG: !DICompositeType(tag: DW_TAG_structure_type, name: "A"{{.*}}DIFlagTypePassByValue
+struct A {
+} TestA;
 
-// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "B"
-// CHECK-SAME:             flags: DIFlagFwdDecl
+// CHECK-DAG: !DICompositeType(tag: DW_TAG_structure_type, name: "B"{{.*}}flags: DIFlagFwdDecl
 struct B {
   B();
-};
-void TestB() { B b; }
+} TestB;
 
-// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "C"
-// CHECK-NOT:              flags: DIFlagFwdDecl
-// CHECK-SAME:             ){{$}}
+// CHECK-DAG: !DICompositeType(tag: DW_TAG_structure_type, name: "C"{{.*}}DIFlagTypePassByValue
 struct C {
   C() {}
-};
-void TestC() { C c; }
+} TestC;
 
-// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "D"
-// CHECK-NOT:              flags: DIFlagFwdDecl
-// CHECK-SAME:             ){{$}}
+// CHECK-DAG: !DICompositeType(tag: DW_TAG_structure_type, name: "D"{{.*}}DIFlagTypePassByValue
 struct D {
   D();
 };
 D::D() {}
+
+// CHECK-DAG: !DICompositeType(tag: DW_TAG_structure_type, name: "E"{{.*}}DIFlagTypePassByValue
+struct E {
+  constexpr E(){};
+} TestE;