replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Debug Info: Support DW_AT_calling_convention on composite types. 

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;
  };

<rdar://problem/36034993>
Differential Revision: https://reviews.llvm.org/D41039

llvm-svn: 321845
This commit is contained in:
Adrian Prantl 2018-01-05 01:13:52 +00:00
parent a29aac7b77
commit 6c5f03a1b2
2 changed files with 58 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
clang/lib/CodeGen/CGDebugInfo.cpp
View File

@ -2803,9 +2803,18 @@ llvm::DICompositeType *CGDebugInfo::CreateLimitedType(const RecordType *Ty) {
SmallString<256> FullName = getUniqueTagTypeName(Ty, CGM, TheCU); SmallString<256> FullName = getUniqueTagTypeName(Ty, CGM, TheCU);
// Explicitly record the calling convention for C++ records.
auto Flags = llvm::DINode::FlagZero;
if (auto CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
if (CGM.getCXXABI().getRecordArgABI(CXXRD) == CGCXXABI::RAA_Indirect)
Flags |= llvm::DINode::FlagTypePassByReference;
else
Flags |= llvm::DINode::FlagTypePassByValue;
}
llvm::DICompositeType *RealDecl = DBuilder.createReplaceableCompositeType( llvm::DICompositeType *RealDecl = DBuilder.createReplaceableCompositeType(
getTagForRecord(RD), RDName, RDContext, DefUnit, Line, 0, Size, Align, 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 // Elements of composite types usually have back to the type, creating
// uniquing cycles. Distinct nodes are more efficient. // uniquing cycles. Distinct nodes are more efficient.

48
clang/test/CodeGenCXX/debug-info-composite-cc.cpp Normal file
View File

@ -0,0 +1,48 @@
// 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",{{.*}}flags: DIFlagTypePassByReference
struct RefDtor {
int i;
~RefDtor() {}
} refDtor;
// Not trivially copyable because of the explicit copy constructor.
// CHECK-DAG: !DICompositeType({{.*}}, name: "RefCopy",{{.*}}flags: DIFlagTypePassByReference
struct RefCopy {
int i;
RefCopy() = default;
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() = default;
RefMove(RefMove &&Move) {}
} refMove;
// 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",{{.*}}flags: DIFlagTypePassByValue
struct Pod {
int i;
} pod;
// This is definitely not a POD type.
// CHECK-DAG: !DICompositeType({{.*}}, name: "Complex",{{.*}}flags: DIFlagTypePassByReference
struct Complex {
Complex() {}
Complex(Complex &Copy) : i(Copy.i) {};
int i;
} complex;