[DebugInfo] Support DW_AT_defaulted

[probinson]

Summary

DWARF v5 added the DW_AT_defaulted attribute, which describes whether
a C++ subprogram has = default on its in-class or an out-of-class
declaration. Pass this info to LLVM for the special member functions,
and have LLVM emit the attribute.

The metadata encoding doesn't permit distinguishing between "not defaulted"
and older bitcode that doesn't describe the defaulted state, so we don't
emit "not defaulted" in the DWARF.

[probinson]

I think this is the last of the new DWARF v5 tags/attributes.

[dblaikie]

Any particular use case in mind for this debug info? (generally I'd rather we not emit extra DWARF we don't have some use case for in mind)

(& if/when this is committed, should be in 3 parts - dwarfdump support, IR/codegen support (can be split into two if you like, but doesn't have to be), and Clang support)

clang/lib/CodeGen/CGDebugInfo.cpp

1792–1811

Looks like this'll do the right thing, but probably want to make sure there's a test case for "deleted as default".

something like:

struct t1 {
t1() = delete;
};
struct t2 {
  t1 v1;
  t2() = default; // this is deleted
};

at least I /think/ that'd tickle the case.

llvm/lib/IR/DebugInfoMetadata.cpp

854–855

How does Virtuality work? Can we avoid the special case for DefaultedOrDeleted in the same way that it is avoided for Virtuality?

llvm/test/DebugInfo/X86/DW_AT_defaulted.s

1

I'd tend to put pure dwarfdump tests in llvm/test/tools/llvm-dwarfdump (but I get that it's all a bit mixed/ambiguous - I know you mentioned a while back about the idea of keeping test/DebugInfo for the actual libDebugInfo tests, but it'd sort of already sailed/had lots of LLVM codegen tests in there - and equally in theory llvm/test/tools/llvm-dwarfdump could be just for tests of llvm-dwarfdump.cpp and related files, not the library implementation... ) ah well. Just a thought.

[probinson]

In D109970#3006806, @dblaikie wrote:

Any particular use case in mind for this debug info? (generally I'd rather we not emit extra DWARF we don't have some use case for in mind)

I don't think Sony has a use for it. The description in section 5.7.8 suggests in/out of class defaulting can affect calling conventions, and I see gcc emitting it, so I figured there was likely some use for it. I suppose I could see if any gdb tests would start working because of this, but apart from that, no I don't have a use-case in mind.

(& if/when this is committed, should be in 3 parts - dwarfdump support, IR/codegen support (can be split into two if you like, but doesn't have to be), and Clang support)

I did originally have this as separate LLVM and Clang commits, happy to split it back up. The dwarfdump support already existed, there just wasn't a test, so I tucked that into the IR/codegen changes; I guess adding the dump test could be its own thing. CodeGen is what makes use of the IR flags, splitting them means one patch defines new IR flags that... aren't used for anything? I figure they're better off in one patch.

clang/lib/CodeGen/CGDebugInfo.cpp

1792–1811

I didn't realize these things stacked that way. But yes, t2's default ctor is flagged as deleted.

llvm/lib/IR/DebugInfoMetadata.cpp

854–855

Virtuality occupies the low two bits of the flags, those flags carefully being defined to match the DW_VIRTUALITY_* constants; 00 = none, 01 = virtual, 10 = pure virtual. There's no special case here because 11 doesn't mean something; so, this splitFlags method, which essentially iterates over the flag bits, can iterate over the Virtuality flags without having anything go wrong.

We could do that for Defaulted as well, if we're willing to use a separate 2-bit field for it, because then like Virtuality there would be no special case for the 11 value. That would also make it feasible to avoid a switch statement in DwarfUnit.cpp, because we can just extract the field and (if it's nonzero) stuff it into the attribute.

Flag bits are not an endless resource, and so I followed the suggestion in the comment in DebugInfoFlags.def to have a single 2-bit field handle both the Defaulted and (mutually exclusive) Deleted cases. If you're willing to burn the extra bit and avoid a couple of special cases, I'm okay with doing it that way.

llvm/test/DebugInfo/X86/DW_AT_defaulted.s

1

Yeah, this is a long-standing thing and nobody is willing to go clean out the stables. This particular test placement is consistent with "code changed in DebugInfo, test goes in DebugInfo."
Recognizing that the *other* test is for a code change in CodeGen, and I'd be open to moving that test from DebugInfo to CodeGen, even though I'm just fiddling a test that was already there.

[dblaikie]

In D109970#3007280, @probinson wrote:

In D109970#3006806, @dblaikie wrote:

Any particular use case in mind for this debug info? (generally I'd rather we not emit extra DWARF we don't have some use case for in mind)

I don't think Sony has a use for it. The description in section 5.7.8 suggests in/out of class defaulting can affect calling conventions,

I think that came out of a misunderstanding that ultimately resulted in a more robust/complete solution involving the DW_AT_calling_convention attribute.

and I see gcc emitting it, so I figured there was likely some use for it. I suppose I could see if any gdb tests would start working because of this, but apart from that, no I don't have a use-case in mind.

Yeah, if there's any evidence this is being used, that'd be helpful I think - otherwise I'd be inclined to leave it until there's a motivating use case (especially given, to the best of my understanding of the conversations at the time, where this came out of & that DW_AT_calling_convention ended up being necessary anyway)

(& if/when this is committed, should be in 3 parts - dwarfdump support, IR/codegen support (can be split into two if you like, but doesn't have to be), and Clang support)

I did originally have this as separate LLVM and Clang commits, happy to split it back up.

I don't mind/think it's good to review it together, but separable parts should be committed separately when it comes to that.

The dwarfdump support already existed, there just wasn't a test, so I tucked that into the IR/codegen changes; I guess adding the dump test could be its own thing.

Yeah, that'd be great if you could commit the test coverage separately/ahead of the rest of any of this.

CodeGen is what makes use of the IR flags, splitting them means one patch defines new IR flags that... aren't used for anything? I figure they're better off in one patch.

Yeah, that's a marginal area where splitting may or may not be done - we're not especially serious about that. Though it can help separate a lot of mechanical work to plumb the stuff through IR (& that work will have its own test coverage - IR parsing/writing/bitcode/etc roundtripping) - even if it has no observable effect on the whole invocation of clang/llc/etc. Separating all that mechanical stuff from a few lines of semantic/more nuanced code in lib/CodeGen/AsmPrinter and testing those pieces separately.

[probinson]

I've poked around in the copy of gdb that we're using for testing; I see it noting DW_AT_defaulted, and factoring it into pass by reference/value decisions; but, if DW_AT_calling_convention is present, the latter takes precedence.
It looks like CGDebugInfo::CreateLimitedType will always set the CC flags for a CXXRecordDecl, and I think we always go through that path for complete type descriptions, so I accept that DW_AT_defaulted isn't really necessary.

On those grounds, I'll commit the dumper test (under the test/tools tree, not DebugInfo) but abandon the rest of it.

[dblaikie]

In D109970#3010195, @probinson wrote:

I've poked around in the copy of gdb that we're using for testing; I see it noting DW_AT_defaulted, and factoring it into pass by reference/value decisions; but, if DW_AT_calling_convention is present, the latter takes precedence.
It looks like CGDebugInfo::CreateLimitedType will always set the CC flags for a CXXRecordDecl, and I think we always go through that path for complete type descriptions, so I accept that DW_AT_defaulted isn't really necessary.

On those grounds, I'll commit the dumper test (under the test/tools tree, not DebugInfo) but abandon the rest of it.

Sounds good, thanks for checking around & for the extra test coverage!

clang/lib/CodeGen/CGDebugInfo.cpp

if (CGM.getTarget().getCXXABI().isItaniumFamily()) {
       // it knows the dynamic type of an object.
       ThisAdjustment = CGM.getCXXABI()
                            .getVirtualFunctionPrologueThisAdjustment(GD)
                            .getQuantity();
     }
     ContainingType = RecordTy;
   }
 
-  // We're checking for deleted C++ special member functions
-  // [Ctors,Dtors, Copy/Move]
-  auto checkAttrDeleted = [&](const auto *Method) {
-    if (Method->getCanonicalDecl()->isDeleted())
+  // We're checking for deleted/defaulted C++ special member functions
+  // [Ctors, Dtors, Copy/Move].
+  auto checkDeletedOrDefaulted = [&](const auto *Method) {
+    // '= delete' must be on the first declaration, so checking the
+    // canonical decl is sufficient.
+    if (Method->getCanonicalDecl()->isDeleted()) {
       SPFlags |= llvm::DISubprogram::SPFlagDeleted;
+      return;
+    }
+    // '= default' can be on any decl.
+    for (auto *Redecl : Method->redecls()) {
+      if (Redecl->isExplicitlyDefaulted()) {
+        if (Redecl->isOutOfLine())
+          SPFlags |= llvm::DISubprogram::SPFlagDefaultedOutOfClass;
+        else
+          SPFlags |= llvm::DISubprogram::SPFlagDefaultedInClass;
+        return;
+      }
+    }
   };
 
   switch (Method->getKind()) {
 
   case Decl::CXXConstructor:
   case Decl::CXXDestructor:
-    checkAttrDeleted(Method);
+    checkDeletedOrDefaulted(Method);
     break;
   case Decl::CXXMethod:
     if (Method->isCopyAssignmentOperator() ||
         Method->isMoveAssignmentOperator())
-      checkAttrDeleted(Method);
+      checkDeletedOrDefaulted(Method);
     break;
   default:
     break;
   }
 
   if (Method->isNoReturn())
     Flags |= llvm::DINode::FlagNoReturn;
 

clang/test/CodeGenCXX/debug-info-deleted-defaulted.cpp

-// Test for debug info for C++11 deleted member functions
+// Test for debug info for C++11 deleted/defaulted member functions.
 
 //Supported: -O0, standalone DI
 // RUN: %clang_cc1 -emit-llvm -triple x86_64-linux-gnu %s -o - \
 // RUN:   -O0 -disable-llvm-passes \
 // RUN:   -debug-info-kind=standalone \
 // RUN: | FileCheck %s -check-prefix=ATTR
 
-// ATTR: DISubprogram(name: "deleted", {{.*}}, flags: DIFlagPublic | DIFlagPrototyped,
+// ATTR: DISubprogram(name: "deleted", {{.*}}, flags: DIFlagPublic | DIFlagPrototyped, spFlags: DISPFlagDefaultedInClass
 // ATTR: DISubprogram(name: "deleted", {{.*}}, flags: DIFlagPublic | DIFlagPrototyped, spFlags: DISPFlagDeleted
 // ATTR: DISubprogram(name: "operator=", linkageName: "_ZN7deletedaSERKS_", {{.*}}, flags: DIFlagPublic | DIFlagPrototyped, spFlags: DISPFlagDeleted
 // ATTR: DISubprogram(name: "deleted", {{.*}}, flags: DIFlagPublic | DIFlagPrototyped, spFlags: DISPFlagDeleted
 // ATTR: DISubprogram(name: "operator=", linkageName: "_ZN7deletedaSEOS_", {{.*}}, flags: DIFlagPublic | DIFlagPrototyped, spFlags: DISPFlagDeleted
-// ATTR: DISubprogram(name: "~deleted", {{.*}}, flags: DIFlagPublic | DIFlagPrototyped,
+// ATTR: DISubprogram(name: "~deleted", {{.*}}, flags: DIFlagPublic | DIFlagPrototyped, spFlags: DISPFlagDefaultedOutOfClass
 class deleted {
 public:
   // Defaulted on purpose, so as to facilitate object creation
   deleted() = default;
 
   deleted(const deleted &) = delete;
   deleted &operator=(const deleted &) = delete;
 
   deleted(deleted &&) = delete;
   deleted &operator=(deleted &&) = delete;
 
-  ~deleted() = default;
+  ~deleted();
 };
 
+deleted::~deleted() = default;
+
 void foo() {
   deleted obj1;
 }

llvm/include/llvm/IR/DebugInfoFlags.def

 HANDLE_DISP_FLAG(2u, PureVirtual)
 HANDLE_DISP_FLAG((1u << 2), LocalToUnit)
 HANDLE_DISP_FLAG((1u << 3), Definition)
 HANDLE_DISP_FLAG((1u << 4), Optimized)
 HANDLE_DISP_FLAG((1u << 5), Pure)
 HANDLE_DISP_FLAG((1u << 6), Elemental)
 HANDLE_DISP_FLAG((1u << 7), Recursive)
 HANDLE_DISP_FLAG((1u << 8), MainSubprogram)
-// May also utilize this Flag in future, when adding support
-// for defaulted functions
+// The Deleted/Defaulted states are mutually exclusive and folded into a
+// two-bit field with these four states: none(0), deleted(1),
+// defaulted in-class(2), defaulted out-of-class(3).
+// Unfortunately the values do not match the DW_DEFAULTED_* constants.
 HANDLE_DISP_FLAG((1u << 9), Deleted)
+HANDLE_DISP_FLAG((1u << 10), DefaultedInClass)
 HANDLE_DISP_FLAG((1u << 11), ObjCDirect)
 
 #ifdef DISP_FLAG_LARGEST_NEEDED
 // Intended to be used with ADT/BitmaskEnum.h.
 // NOTE: Always must be equal to largest flag, check this when adding new flags.
 HANDLE_DISP_FLAG((1 << 11), Largest)
 #undef DISP_FLAG_LARGEST_NEEDED
 #endif
 
 #undef HANDLE_DI_FLAG
 #undef HANDLE_DISP_FLAG

llvm/include/llvm/IR/DebugInfoMetadata.h

 public:
   /// Debug info subprogram flags.
   enum DISPFlags : uint32_t {
 #define HANDLE_DISP_FLAG(ID, NAME) SPFlag##NAME = ID,
 #define DISP_FLAG_LARGEST_NEEDED
 #include "llvm/IR/DebugInfoFlags.def"
     SPFlagNonvirtual = SPFlagZero,
     SPFlagVirtuality = SPFlagVirtual | SPFlagPureVirtual,
+    SPFlagDeletedOrDefaulted = SPFlagDeleted | SPFlagDefaultedInClass,
+    SPFlagDefaultedOutOfClass = SPFlagDeletedOrDefaulted,
     LLVM_MARK_AS_BITMASK_ENUM(SPFlagLargest)
   };
 
   static DISPFlags getFlag(StringRef Flag);
   static StringRef getFlagString(DISPFlags Flag);
 
   /// Split up a flags bitfield for easier printing.
   ///
public:
   bool areAllCallsDescribed() const {
     return getFlags() & FlagAllCallsDescribed;
   }
   bool isPure() const { return getSPFlags() & SPFlagPure; }
   bool isElemental() const { return getSPFlags() & SPFlagElemental; }
   bool isRecursive() const { return getSPFlags() & SPFlagRecursive; }
   bool isObjCDirect() const { return getSPFlags() & SPFlagObjCDirect; }
 
+  /// Return a value indicating whether this function is deleted or
+  /// defaulted.
+  DISPFlags getDeletedOrDefaulted() const {
+    return getSPFlags() & SPFlagDeletedOrDefaulted;
+  }
+
   /// Check if this is deleted member function.
   ///
   /// Return true if this subprogram is a C++11 special
   /// member function declared deleted.
-  bool isDeleted() const { return getSPFlags() & SPFlagDeleted; }
+  bool isDeleted() const { return getDeletedOrDefaulted() == SPFlagDeleted; }
 
   /// Check if this is reference-qualified.
   ///
   /// Return true if this subprogram is a C++11 reference-qualified non-static
   /// member function (void foo() &).
   bool isLValueReference() const { return getFlags() & FlagLValueReference; }
 
   /// Check if this is rvalue-reference-qualified.

llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp

if (SP->isMainSubprogram())
     addFlag(SPDie, dwarf::DW_AT_main_subprogram);
   if (SP->isPure())
     addFlag(SPDie, dwarf::DW_AT_pure);
   if (SP->isElemental())
     addFlag(SPDie, dwarf::DW_AT_elemental);
   if (SP->isRecursive())
     addFlag(SPDie, dwarf::DW_AT_recursive);
 
-  if (DD->getDwarfVersion() >= 5 && SP->isDeleted())
+  if (DD->getDwarfVersion() >= 5) {
+    switch (SP->getDeletedOrDefaulted()) {
+    case DISubprogram::SPFlagDeleted:
       addFlag(SPDie, dwarf::DW_AT_deleted);
+      break;
+    case DISubprogram::SPFlagDefaultedInClass:
+      addUInt(SPDie, dwarf::DW_AT_defaulted, dwarf::DW_FORM_data1,
+              dwarf::DW_DEFAULTED_in_class);
+      break;
+    case DISubprogram::SPFlagDefaultedOutOfClass:
+      addUInt(SPDie, dwarf::DW_AT_defaulted, dwarf::DW_FORM_data1,
+              dwarf::DW_DEFAULTED_out_of_class);
+      break;
+    case DISubprogram::SPFlagZero:
+      // Older bitcode doesn't record the defaulted kind, so for backward
+      // compatibility, emit nothing instead of saying not-defaulted.
+      break;
+    default:
+      llvm_unreachable("Invalid value from getDefaultedOrDeleted()");
+    }
+  }
 }
 
 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, const DISubrange *SR,
                                      DIE *IndexTy) {
   DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
 
   // The LowerBound value defines the lower bounds which is typically zero for

llvm/lib/IR/DebugInfoMetadata.cpp

DILocalScope *DILocalScope::getNonLexicalBlockFileScope() const {
   if (auto *File = dyn_cast<DILexicalBlockFile>(this))
     return File->getScope()->getNonLexicalBlockFileScope();
   return const_cast<DILocalScope *>(this);
 }
 
 DISubprogram::DISPFlags DISubprogram::getFlag(StringRef Flag) {
   return StringSwitch<DISPFlags>(Flag)
 #define HANDLE_DISP_FLAG(ID, NAME) .Case("DISPFlag" #NAME, SPFlag##NAME)
+      // Handle the one multi-bit special case.
+      HANDLE_DISP_FLAG(Ignored, DefaultedOutOfClass)
 #include "llvm/IR/DebugInfoFlags.def"
           .Default(SPFlagZero);
 }
 
 StringRef DISubprogram::getFlagString(DISPFlags Flag) {
   switch (Flag) {
   // Appease a warning.
   case SPFlagVirtuality:
     return "";
 #define HANDLE_DISP_FLAG(ID, NAME)                                             \
   case SPFlag##NAME:                                                           \
     return "DISPFlag" #NAME;
+    // Handle the one multi-bit special case.
+    HANDLE_DISP_FLAG(Ignored, DefaultedOutOfClass)
 #include "llvm/IR/DebugInfoFlags.def"
   }
   return "";
 }
 
 DISubprogram::DISPFlags
 DISubprogram::splitFlags(DISPFlags Flags,
                          SmallVectorImpl<DISPFlags> &SplitFlags) {
-  // Multi-bit fields can require special handling. In our case, however, the
-  // only multi-bit field is virtuality, and all its values happen to be
+  // Multi-bit fields can require special handling. In our case, there
+  // are two: DeletedOrDefaulted, and Virtuality.  We special-case one
+  // value for DeletedOrDefaulted, but everything else happens to have
   // single-bit values, so the right behavior just falls out.
 #define HANDLE_DISP_FLAG(ID, NAME)                                             \
   if (DISPFlags Bit = Flags & SPFlag##NAME) {                                  \
     SplitFlags.push_back(Bit);                                                 \
     Flags &= ~Bit;                                                             \
   }
+  HANDLE_DISP_FLAG(Ignored, DefaultedOutOfClass)
 #include "llvm/IR/DebugInfoFlags.def"
   return Flags;
 }
 
 DISubprogram *DISubprogram::getImpl(
     LLVMContext &Context, Metadata *Scope, MDString *Name,
     MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type,
     unsigned ScopeLine, Metadata *ContainingType, unsigned VirtualIndex,

llvm/test/DebugInfo/X86/DW_AT_defaulted.s

+## Demonstrate dumping DW_AT_defaulted.
+## Any ELF-target triple will work.
+# RUN: llvm-mc -triple=x86_64--linux -filetype=obj < %s | \
+# RUN:     llvm-dwarfdump -v - | FileCheck %s
+
+# CHECK: .debug_abbrev contents:
+# CHECK: DW_AT_defaulted DW_FORM_data1
+# CHECK: .debug_info contents:
+# CHECK: DW_AT_defaulted [DW_FORM_data1] (DW_DEFAULTED_no)
+# CHECK: DW_AT_defaulted [DW_FORM_data1] (DW_DEFAULTED_in_class)
+# CHECK: DW_AT_defaulted [DW_FORM_data1] (DW_DEFAULTED_out_of_class)
+
+        .section        .debug_abbrev,"",@progbits
+        .byte   1                       # Abbreviation Code
+        .byte   17                      # DW_TAG_compile_unit
+        .byte   1                       # DW_CHILDREN_yes
+        .byte   0                       # EOM(1)
+        .byte   0                       # EOM(2)
+        .byte   2                       # Abbreviation Code
+        .byte   46                      # DW_TAG_subprogram
+        .byte   0                       # DW_CHILDREN_no
+        .byte   0x8b, 1                 # DW_AT_defaulted (ULEB)
+        .byte   11                      # DW_FORM_data1
+        .byte   0                       # EOM(1)
+        .byte   0                       # EOM(2)
+        .byte   0                       # EOM(3)
+
+        .section        .debug_info,"",@progbits
+        .long   .Ldebug_info_end0-.Ldebug_info_start0 # Length of Unit
+.Ldebug_info_start0:
+        .short  5                       # DWARF version number
+        .byte   1                       # Unit type
+        .byte   8                       # Address Size (in bytes)
+        .long   .debug_abbrev           # Offset Into Abbrev. Section
+        .byte   1                       # Abbrev [1] DW_TAG_compile_unit
+        .byte   2                       # Abbrev [2] DW_TAG_subprogram
+        .byte   0                       # DW_DEFAULTED_no
+        .byte   2                       # Abbrev [2] DW_TAG_subprogram
+        .byte   1                       # DW_DEFAULTED_in_class
+        .byte   2                       # Abbrev [2] DW_TAG_subprogram
+        .byte   2                       # DW_DEFAULTED_out_of_class
+        .byte   0                       # End Of Children Mark
+.Ldebug_info_end0:

llvm/test/DebugInfo/X86/DW_AT_deleted_defaulted.ll

-; RUN: llc < %s -filetype=obj -o %t
-; RUN: llvm-dwarfdump -v %t | FileCheck %s
+;; Test emitting DW_AT_deleted and DW_AT_defaulted.
+; RUN: llc < %s -filetype=obj | llvm-dwarfdump -v - | FileCheck %s
 
 ; C++ source to regenerate:
 ; class deleted {
 ; public:
 ;   // Defaulted on purpose, so as to facilitate object creation
 ;    deleted() = default;
 ; 
 ;   deleted(const deleted &) = delete;
 ;   deleted &operator=(const deleted &) = delete;
 ; 
 ;   deleted(deleted &&) = delete;
 ;   deleted &operator=(deleted &&) = delete;
 ; 
-;   ~deleted() = default;
+;   ~deleted();
 ; };
 ; 
+; deleted::~deleted() = default;
+;
 ; void foo() {
 ;   deleted obj1;
 ; }
 ; $ clang++ -O0 -g -gdwarf-5 debug-info-deleted.cpp -c
 
 
 ; CHECK: .debug_abbrev contents:
 
+; CHECK: [5] DW_TAG_subprogram   DW_CHILDREN_yes
+; CHECK: DW_AT_defaulted DW_FORM_data1
 ; CHECK: [7] DW_TAG_subprogram   DW_CHILDREN_yes
 ; CHECK: DW_AT_deleted   DW_FORM_flag_present
 ; CHECK: [9] DW_TAG_subprogram   DW_CHILDREN_yes
 ; CHECK: DW_AT_deleted   DW_FORM_flag_present
 
 ; CHECK: .debug_info contents:
 
+; CHECK: DW_TAG_subprogram [5]
+; CHECK-NEXT: DW_AT_name [DW_FORM_strx1]    (indexed (00000006) string = "deleted")
+; CHECK: DW_AT_defaulted [DW_FORM_data1] (DW_DEFAULTED_in_class)
+
 ; CHECK: DW_TAG_subprogram [7]
 ; CHECK-NEXT: DW_AT_name [DW_FORM_strx1]    (indexed (00000006) string = "deleted") 
 ; CHECK:  DW_AT_deleted [DW_FORM_flag_present]  (true)
 
 ; CHECK: DW_TAG_subprogram [9]
 ; CHECK-NEXT: DW_AT_linkage_name [DW_FORM_strx1]    (indexed (00000007) string = "_ZN7deletedaSERKS_") 
 ; CHECK:  DW_AT_deleted [DW_FORM_flag_present]  (true)
 
 ; CHECK: DW_TAG_subprogram [7]
 ; CHECK-NEXT: DW_AT_name [DW_FORM_strx1]    (indexed (00000006) string = "deleted") 
 ; CHECK:  DW_AT_deleted [DW_FORM_flag_present]  (true)
 
 ; CHECK: DW_TAG_subprogram [9]
 ; CHECK-NEXT: DW_AT_linkage_name [DW_FORM_strx1]    (indexed (00000009) string = "_ZN7deletedaSEOS_")
 ; CHECK-NEXT: DW_AT_name [DW_FORM_strx1]    (indexed (00000008) string = "operator=")
 ; CHECK:  DW_AT_deleted [DW_FORM_flag_present]  (true)
 
+; CHECK: DW_TAG_subprogram [5]
+; CHECK-NEXT: DW_AT_name [DW_FORM_strx1]    (indexed (0000000a) string = "~deleted")
+; CHECK: DW_AT_defaulted [DW_FORM_data1] (DW_DEFAULTED_out_of_class)
+
 ; ModuleID = 'debug-info-deleted.cpp'
 source_filename = "debug-info-deleted.cpp"
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 %class.deleted = type { i8 }
 
 ; Function Attrs: noinline nounwind optnone uwtable

 !5 = !{i32 1, !"wchar_size", i32 4}
 !6 = !{!"clang version 10.0.0 (https://github.com/llvm/llvm-project.git 715c47d5de9aa8860050992a7aaf27dca53f7f4a)"}
 !7 = distinct !DISubprogram(name: "foo", linkageName: "_Z3foov", scope: !1, file: !1, line: 14, type: !8, scopeLine: 14, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
 !8 = !DISubroutineType(types: !9)
 !9 = !{null}
 !10 = !DILocalVariable(name: "obj1", scope: !7, file: !1, line: 15, type: !11)
 !11 = distinct !DICompositeType(tag: DW_TAG_class_type, name: "deleted", file: !1, line: 1, size: 8, flags: DIFlagTypePassByReference, elements: !12, identifier: "_ZTS7deleted")
 !12 = !{!13, !17, !22, !26, !30, !33}
-!13 = !DISubprogram(name: "deleted", scope: !11, file: !1, line: 3, type: !14, scopeLine: 3, flags: DIFlagPublic | DIFlagPrototyped, spFlags: 0)
+!13 = !DISubprogram(name: "deleted", scope: !11, file: !1, line: 3, type: !14, scopeLine: 3, flags: DIFlagPublic | DIFlagPrototyped, spFlags: DISPFlagDefaultedInClass)
 !14 = !DISubroutineType(types: !15)
 !15 = !{null, !16}
 !16 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !11, size: 64, flags: DIFlagArtificial | DIFlagObjectPointer)
 !17 = !DISubprogram(name: "deleted", scope: !11, file: !1, line: 5, type: !18, scopeLine: 5, flags: DIFlagPublic | DIFlagPrototyped, spFlags: DISPFlagDeleted)
 !18 = !DISubroutineType(types: !19)
 !19 = !{null, !16, !20}
 !20 = !DIDerivedType(tag: DW_TAG_reference_type, baseType: !21, size: 64)
 !21 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !11)
 !22 = !DISubprogram(name: "operator=", linkageName: "_ZN7deletedaSERKS_", scope: !11, file: !1, line: 6, type: !23, scopeLine: 6, flags: DIFlagPublic | DIFlagPrototyped, spFlags: DISPFlagDeleted)
 !23 = !DISubroutineType(types: !24)
 !24 = !{!25, !16, !20}
 !25 = !DIDerivedType(tag: DW_TAG_reference_type, baseType: !11, size: 64)
 !26 = !DISubprogram(name: "deleted", scope: !11, file: !1, line: 8, type: !27, scopeLine: 8, flags: DIFlagPublic | DIFlagPrototyped, spFlags: DISPFlagDeleted)
 !27 = !DISubroutineType(types: !28)
 !28 = !{null, !16, !29}
 !29 = !DIDerivedType(tag: DW_TAG_rvalue_reference_type, baseType: !11, size: 64)
 !30 = !DISubprogram(name: "operator=", linkageName: "_ZN7deletedaSEOS_", scope: !11, file: !1, line: 9, type: !31, scopeLine: 9, flags: DIFlagPublic | DIFlagPrototyped, spFlags: DISPFlagDeleted)
 !31 = !DISubroutineType(types: !32)
 !32 = !{!25, !16, !29}
-!33 = !DISubprogram(name: "~deleted", scope: !11, file: !1, line: 11, type: !14, scopeLine: 11, flags: DIFlagPublic | DIFlagPrototyped, spFlags: 0)
+!33 = !DISubprogram(name: "~deleted", scope: !11, file: !1, line: 11, type: !14, scopeLine: 11, flags: DIFlagPublic | DIFlagPrototyped, spFlags: DISPFlagDefaultedOutOfClass)
 !34 = !DILocation(line: 15, column: 13, scope: !7)
 !35 = !DILocation(line: 16, column: 3, scope: !7)