Debug Info: Support DW_AT_calling_convention on composite types.

[aprantl]

Summary

This implements the DWARF 5 feature described at
http://www.dwarfstd.org/ShowIssue.php?issue=141215.1

This allows a consumer to understand whether a composite data type is
trivially copyable and thus should be passed by value instead of by
reference. The canonical example is being able to distinguish the
following two types:

// S is not trivially copyable because of the explicit destructor.
struct S {
   ~S() {}
};

// T is a POD type.
struct T {
  ~T() = default;
};

To avoid bloating the debug info with calling convention attributes,
this patch only adds them were the calling convention is not obvious
from the context.

Implicitly by value is everything that clearly looks like a C struct, i.e.:

• Non-C++ record types.
• Types that define none of destructor, copy/move constructor, copy/move assignment operator.

Implicitly by reference is everything clearly looks like a non-pod type:

• Types that define a destructor, a copy constructor, and a copy assignment operator.

[aprantl]

I related D41039 (Add support for attribute "trivial_abi") which will also benefit from this feature. It is not a hard dependency though, this patch is also useful for standard C++.

[rsmith]

lib/CodeGen/CGDebugInfo.cpp

2812–2814

I do not believe this is sufficient. Consider:

struct A {
  A(const A&) = default;
  A(A&);
};
struct B : A {};

Now, A is passed indirectly, because it has a non-trivial copy constructor (A::A(A&)). But B is passed directly, because it only has a trivial copy constructor, despite having an A subobject.

I would not expect debuggers to get intricacies like this right. (In general, determining how to pass a class like B can require performing template instantiation, which it's clearly not reasonable to expect a debugger to do.)

If you want to give the debugger a hint for any type that's non-POD (as the comment says), then use CXXRecordDecl::isPOD to determine that. I think it is reasonable to believe that a debugger will figure out that objects of POD types are passed direct.

2817

"isTriviallyCopyable()" is the wrong thing to check here. The best you can do to get a per-type "calling convention" value is to call CGCXXABI::getRecordArgABI.

However, that does not tell the full story: in particular, in the MS ABI, member functions always return objects of class type indirectly, regardless of whether they could otherwise be returned in registers. If DWARF 5 allows you to override the calling convention on a particular usage of a type, you can check whether a function's return type should be indirect by calling CGCXXABI::classifyReturnType.

2821–2822

The assignment operators are irrelevant here. Does any debugger really base its calling convention decision on their existence?

2825–2827

Why are you not checking for move operations on this side?

[aprantl]

Thanks! I think you got me convinced that we should probably stick the calling convention attribute unconditionally on all C++ types. At least in DWARF 5 it should be part of the abbreviation and thus almost free.

[aprantl]

Just unconditionally emit the flags for all CXXRecordDecls. Richard convinced me that a debugger does not want to be in the business of determining the correct calling convention.

[rsmith]

LGTM, thanks!

lib/CodeGen/CGDebugInfo.cpp

llvm::DICompositeType *CGDebugInfo::CreateLimitedType(const RecordType *Ty) {
   if (!D || !D->isCompleteDefinition())
     return getOrCreateRecordFwdDecl(Ty, RDContext);
 
   uint64_t Size = CGM.getContext().getTypeSize(Ty);
   auto Align = getDeclAlignIfRequired(D, CGM.getContext());
 
   SmallString<256> FullName = getUniqueTagTypeName(Ty, CGM, TheCU);
 
+  // Explicitly record the calling convention unless it is obvious
+  // from context.
+  // Implicitly by value is everything that clearly looks like a C struct, i.e.:
+  //   - Non-C++ record types.
+  //   - Types that define none of destructor, copy/move constructor,
+  //     copy/move assignment operator.
+  // Implicitly by reference is everything clearly looks like a non-pod type:
+  //  - Types that define a destructor, a copy constructor, and a copy
+  //    assignment operator.
+  auto Flags = llvm::DINode::FlagZero;
+  if (auto CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
+    if (CXXRD->isTriviallyCopyable()) {
+      if (CXXRD->hasUserDeclaredDestructor() ||
+          CXXRD->hasUserDeclaredCopyConstructor() ||
+          CXXRD->hasUserDeclaredMoveConstructor() ||
+          CXXRD->hasUserDeclaredCopyAssignment() ||
+          CXXRD->hasUserDeclaredMoveAssignment())
+        Flags |= llvm::DINode::FlagTypePassByValue;
+    } else {
+      if (!CXXRD->hasUserDeclaredDestructor() &&
+          !CXXRD->hasUserDeclaredCopyConstructor() &&
+          !CXXRD->hasUserDeclaredCopyAssignment())
+        Flags |= llvm::DINode::FlagTypePassByReference;
+    }
+  }
+
   llvm::DICompositeType *RealDecl = DBuilder.createReplaceableCompositeType(
       getTagForRecord(RD), RDName, RDContext, DefUnit, Line, 0, Size, Align,
-      llvm::DINode::FlagZero, FullName);
+      Flags, FullName);
 
   // Elements of composite types usually have back to the type, creating
   // uniquing cycles.  Distinct nodes are more efficient.
   switch (RealDecl->getTag()) {
   default:
     llvm_unreachable("invalid composite type tag");
 
   case llvm::dwarf::DW_TAG_array_type:

test/CodeGenCXX/debug-info-composite-cc.cpp

+// RUN: %clang_cc1 -emit-llvm -debug-info-kind=standalone -triple %itanium_abi_triple %s -o - | FileCheck %s
+
+// Not trivially copyable because of the explicit destructor.
+// CHECK-DAG: !DICompositeType({{.*}}, name: "RefDtor",{{.*size: [0-9]+, elem}}
+struct RefDtor {
+  int i;
+  ~RefDtor() {}
+} refDtor;
+
+// Not trivially copyable because of the explicit copy constructor.
+// CHECK-DAG: !DICompositeType({{.*}}, name: "RefCopy",{{.*size: [0-9]+, elem}}
+struct RefCopy {
+  int i;
+  RefCopy() {}
+  RefCopy(RefCopy &Copy) {}
+} refCopy;
+
+// Not trivially copyable because of the explicit move constructor.
+// CHECK-DAG: !DICompositeType({{.*}}, name: "RefMove",{{.*}}flags: DIFlagTypePassByReference
+struct RefMove {
+  int i;
+  RefMove(){}
+  RefMove(RefMove &&Move) {}
+} refMove;
+
+// Not trivially copyable because of the explicit copy assignment.
+// CHECK-DAG: !DICompositeType({{.*}}, name: "RefCopyAss",{{.*size: [0-9]+, elem}}
+struct RefCopyAss {
+  int i;
+  RefCopyAss &operator= (RefCopyAss &Copy) { return *this; }
+} refCopyAss;
+
+
+// POD-like type even though it defines a destructor.
+// CHECK-DAG: !DICompositeType({{.*}}, name: "Podlike", {{.*}}flags: DIFlagTypePassByValue
+struct Podlike {
+  int i;
+  Podlike() = default;
+  Podlike(Podlike &&Move) = default;
+  ~Podlike() = default;
+} podlike;
+
+
+// This is a POD type.
+// CHECK-DAG: !DICompositeType({{.*}}, name: "Pod",{{.*size: [0-9]+, elem}}
+struct Pod {
+  int i;
+} pod;
+
+// This is definitely not a POD type.
+// CHECK-DAG: !DICompositeType({{.*}}, name: "Complex",{{.*size: [0-9]+, elem}}
+struct Complex {
+  Complex() {}
+  Complex(Complex &Copy) : i(Copy.i) {};
+  int i;
+} complex;