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 ↗

(On Diff #128664)

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 ↗

(On Diff #128664)

"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 ↗

(On Diff #128664)

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

2825–2827 ↗

(On Diff #128664)

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!

llvm/trunk/include/llvm-c/DebugInfo.h

typedef enum {
   LLVMDIFlagReserved = 1 << 15,
   LLVMDIFlagSingleInheritance = 1 << 16,
   LLVMDIFlagMultipleInheritance = 2 << 16,
   LLVMDIFlagVirtualInheritance = 3 << 16,
   LLVMDIFlagIntroducedVirtual = 1 << 18,
   LLVMDIFlagBitField = 1 << 19,
   LLVMDIFlagNoReturn = 1 << 20,
   LLVMDIFlagMainSubprogram = 1 << 21,
+  LLVMDIFlagTypePassByValue = 1 << 22,
+  LLVMDIFlagTypePassByReference = 1 << 23,
   LLVMDIFlagIndirectVirtualBase = (1 << 2) | (1 << 5),
   LLVMDIFlagAccessibility = LLVMDIFlagPrivate | LLVMDIFlagProtected |
                             LLVMDIFlagPublic,
   LLVMDIFlagPtrToMemberRep = LLVMDIFlagSingleInheritance |
                              LLVMDIFlagMultipleInheritance |
                              LLVMDIFlagVirtualInheritance
 } LLVMDIFlags;
 

llvm/trunk/include/llvm/IR/DebugInfoFlags.def

 HANDLE_DI_FLAG((1 << 15), Reserved)
 HANDLE_DI_FLAG((1 << 16), SingleInheritance)
 HANDLE_DI_FLAG((2 << 16), MultipleInheritance)
 HANDLE_DI_FLAG((3 << 16), VirtualInheritance)
 HANDLE_DI_FLAG((1 << 18), IntroducedVirtual)
 HANDLE_DI_FLAG((1 << 19), BitField)
 HANDLE_DI_FLAG((1 << 20), NoReturn)
 HANDLE_DI_FLAG((1 << 21), MainSubprogram)
+HANDLE_DI_FLAG((1 << 22), TypePassByValue)
+HANDLE_DI_FLAG((1 << 23), TypePassByReference)
 
 // To avoid needing a dedicated value for IndirectVirtualBase, we use
 // the bitwise or of Virtual and FwdDecl, which does not otherwise
 // make sense for inheritance.
 HANDLE_DI_FLAG((1 << 2) | (1 << 5), IndirectVirtualBase)
 
 #ifdef DI_FLAG_LARGEST_NEEDED
 // intended to be used with ADT/BitmaskEnum.h
 // NOTE: always must be equal to largest flag, check this when adding new flag
-HANDLE_DI_FLAG((1 << 21), Largest)
+HANDLE_DI_FLAG((1 << 23), Largest)
 #undef DI_FLAG_LARGEST_NEEDED
 #endif
 
 #undef HANDLE_DI_FLAG

llvm/trunk/include/llvm/IR/DebugInfoMetadata.h

public:
   bool isObjcClassComplete() const {
     return getFlags() & FlagObjcClassComplete;
   }
   bool isVector() const { return getFlags() & FlagVector; }
   bool isBitField() const { return getFlags() & FlagBitField; }
   bool isStaticMember() const { return getFlags() & FlagStaticMember; }
   bool isLValueReference() const { return getFlags() & FlagLValueReference; }
   bool isRValueReference() const { return getFlags() & FlagRValueReference; }
+  bool isTypePassByValue() const { return getFlags() & FlagTypePassByValue; }
+  bool isTypePassByReference() const {
+    return getFlags() & FlagTypePassByReference;
+  }
 
   static bool classof(const Metadata *MD) {
     switch (MD->getMetadataID()) {
     default:
       return false;
     case DIBasicTypeKind:
     case DIDerivedTypeKind:
     case DICompositeTypeKind:

llvm/trunk/lib/CodeGen/AsmPrinter/DwarfUnit.cpp

if (CTy->isObjcClassComplete())
       addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
 
     // Add template parameters to a class, structure or union types.
     // FIXME: The support isn't in the metadata for this yet.
     if (Tag == dwarf::DW_TAG_class_type ||
         Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
       addTemplateParams(Buffer, CTy->getTemplateParams());
 
+    // Add the type's non-standard calling convention.
+    uint8_t CC = 0;
+    if (CTy->isTypePassByValue())
+      CC = dwarf::DW_CC_pass_by_value;
+    else if (CTy->isTypePassByReference())
+      CC = dwarf::DW_CC_pass_by_reference;
+    if (CC)
+      addUInt(Buffer, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1,
+              CC);
     break;
   }
   default:
     break;
   }
 
   // Add name if not anonymous or intermediate type.
   if (!Name.empty())

llvm/trunk/lib/IR/Verifier.cpp

void Verifier::visitDIDerivedType(const DIDerivedType &N) {
   if (N.getDWARFAddressSpace()) {
     AssertDI(N.getTag() == dwarf::DW_TAG_pointer_type ||
                  N.getTag() == dwarf::DW_TAG_reference_type,
              "DWARF address space only applies to pointer or reference types",
              &N);
   }
 }
 
+/// Detect mutually exclusive flags.
 static bool hasConflictingReferenceFlags(unsigned Flags) {
-  return (Flags & DINode::FlagLValueReference) &&
-         (Flags & DINode::FlagRValueReference);
+  return ((Flags & DINode::FlagLValueReference) &&
+          (Flags & DINode::FlagRValueReference)) ||
+         ((Flags & DINode::FlagTypePassByValue) &&
+          (Flags & DINode::FlagTypePassByReference));
 }
 
 void Verifier::visitTemplateParams(const MDNode &N, const Metadata &RawParams) {
   auto *Params = dyn_cast<MDTuple>(&RawParams);
   AssertDI(Params, "invalid template params", &N, &RawParams);
   for (Metadata *Op : Params->operands()) {
     AssertDI(Op && isa<DITemplateParameter>(Op), "invalid template parameter",
              &N, Params, Op);

llvm/trunk/test/DebugInfo/Generic/pass-by-value.ll

+; RUN: %llc_dwarf -O0 -filetype=obj < %s | llvm-dwarfdump -debug-info - | FileCheck %s
+;
+; // S is not trivially copyable.
+; struct S {
+;    ~S() {}
+; };
+;
+; // T is a POD.
+; struct T {
+;    ~T() = default;
+; };
+;  
+; S s;
+; T t;
+;
+; CHECK: DW_TAG_structure_type
+; CHECK-NEXT: DW_AT_calling_convention  (DW_CC_pass_by_reference)
+; CHECK-NEXT: DW_AT_name  ("S")
+;
+; CHECK: DW_TAG_structure_type
+; CHECK-NEXT: DW_AT_calling_convention  (DW_CC_pass_by_value)
+; CHECK-NEXT: DW_AT_name  ("T")
+
+source_filename = "pass.cpp"
+target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-apple-macosx10.13.0"
+
+%struct.S = type { i8 }
+%struct.T = type { i8 }
+
+@s = global %struct.S zeroinitializer, align 1, !dbg !0
+@__dso_handle = external hidden global i8
+@t = global %struct.T zeroinitializer, align 1, !dbg !6
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!20, !21, !22, !23}
+!llvm.ident = !{!24}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "s", scope: !2, file: !3, line: 9, type: !14, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !3, producer: "clang version 7.0.0 (trunk 321763) (llvm/trunk 321758)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5)
+!3 = !DIFile(filename: "pass.cpp", directory: "/")
+!4 = !{}
+!5 = !{!0, !6}
+!6 = !DIGlobalVariableExpression(var: !7, expr: !DIExpression())
+!7 = distinct !DIGlobalVariable(name: "t", scope: !2, file: !3, line: 10, type: !8, isLocal: false, isDefinition: true)
+!8 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "T", file: !3, line: 5, size: 8, elements: !9, identifier: "_ZTS1T", flags: DIFlagTypePassByValue)
+!9 = !{!10}
+!10 = !DISubprogram(name: "~T", scope: !8, file: !3, line: 6, type: !11, isLocal: false, isDefinition: false, scopeLine: 6, flags: DIFlagPrototyped, isOptimized: false)
+!11 = !DISubroutineType(types: !12)
+!12 = !{null, !13}
+!13 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !8, size: 64, flags: DIFlagArtificial | DIFlagObjectPointer)
+!14 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "S", file: !3, line: 1, size: 8, elements: !15, identifier: "_ZTS1S", flags: DIFlagTypePassByReference)
+!15 = !{!16}
+!16 = !DISubprogram(name: "~S", scope: !14, file: !3, line: 2, type: !17, isLocal: false, isDefinition: false, scopeLine: 2, flags: DIFlagPrototyped, isOptimized: false)
+!17 = !DISubroutineType(types: !18)
+!18 = !{null, !19}
+!19 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !14, size: 64, flags: DIFlagArtificial | DIFlagObjectPointer)
+!20 = !{i32 2, !"Dwarf Version", i32 4}
+!21 = !{i32 2, !"Debug Info Version", i32 3}
+!22 = !{i32 1, !"wchar_size", i32 4}
+!23 = !{i32 7, !"PIC Level", i32 2}
+!24 = !{!"clang version 7.0.0 (trunk 321763) (llvm/trunk 321758)"}

llvm/trunk/test/Verifier/cc-flags.ll

+; RUN: not opt -S < %s 2>&1 | FileCheck %s
+
+!named = !{!0}
+!0 = !DICompositeType(tag: DW_TAG_structure_type, name: "A", size: 1, flags: DIFlagTypePassByReference | DIFlagTypePassByValue)
+; CHECK: invalid reference flags