r181634 - PR14992: Debug Info: Support more non-type template parameters
Eric Christopher
echristo at gmail.com
Fri May 10 16:53:38 PDT 2013
Cool deal.
-eric
On Fri, May 10, 2013 at 2:53 PM, David Blaikie <dblaikie at gmail.com> wrote:
> Author: dblaikie
> Date: Fri May 10 16:53:14 2013
> New Revision: 181634
>
> URL: http://llvm.org/viewvc/llvm-project?rev=181634&view=rev
> Log:
> PR14992: Debug Info: Support more non-type template parameters
>
> * Provide DW_TAG_template_value_parameter for pointers, function
> pointers, member pointers, and member function pointers (still missing
> support for template template parameters which GCC encodes as a
> DW_TAG_GNU_template_template_param)
> * Provide values for all but the (member & non-member) function pointer case.
> Simple constant integer values for member pointers (offset within the
> object) and address for the value pointer case. GCC doesn't provide a
> value for the member function pointer case so I'm not sure how, if at
> all, GDB supports encoding that. & non-member function pointers should
> follow shortly in a subsequent patch.
> * Null pointer value encodings of all of these types, including
> correctly encoding null data member pointers as -1.
>
> Modified:
> cfe/trunk/lib/CodeGen/CGDebugInfo.cpp
> cfe/trunk/test/CodeGenCXX/debug-info-template.cpp
>
> Modified: cfe/trunk/lib/CodeGen/CGDebugInfo.cpp
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGDebugInfo.cpp?rev=181634&r1=181633&r2=181634&view=diff
> ==============================================================================
> --- cfe/trunk/lib/CodeGen/CGDebugInfo.cpp (original)
> +++ cfe/trunk/lib/CodeGen/CGDebugInfo.cpp Fri May 10 16:53:14 2013
> @@ -13,6 +13,7 @@
>
> #include "CGDebugInfo.h"
> #include "CGBlocks.h"
> +#include "CGCXXABI.h"
> #include "CGObjCRuntime.h"
> #include "CodeGenFunction.h"
> #include "CodeGenModule.h"
> @@ -1188,17 +1189,88 @@ CollectTemplateParams(const TemplatePara
> for (unsigned i = 0, e = TAList.size(); i != e; ++i) {
> const TemplateArgument &TA = TAList[i];
> const NamedDecl *ND = TPList->getParam(i);
> - if (TA.getKind() == TemplateArgument::Type) {
> + switch (TA.getKind()) {
> + case TemplateArgument::Type: {
> llvm::DIType TTy = getOrCreateType(TA.getAsType(), Unit);
> llvm::DITemplateTypeParameter TTP =
> DBuilder.createTemplateTypeParameter(TheCU, ND->getName(), TTy);
> TemplateParams.push_back(TTP);
> - } else if (TA.getKind() == TemplateArgument::Integral) {
> + } break;
> + case TemplateArgument::Integral: {
> llvm::DIType TTy = getOrCreateType(TA.getIntegralType(), Unit);
> llvm::DITemplateValueParameter TVP =
> - DBuilder.createTemplateValueParameter(TheCU, ND->getName(), TTy,
> - TA.getAsIntegral().getZExtValue());
> - TemplateParams.push_back(TVP);
> + DBuilder.createTemplateValueParameter(
> + TheCU, ND->getName(), TTy,
> + llvm::ConstantInt::get(CGM.getLLVMContext(), TA.getAsIntegral()));
> + TemplateParams.push_back(TVP);
> + } break;
> + case TemplateArgument::Declaration: {
> + const ValueDecl *D = TA.getAsDecl();
> + bool InstanceMember = D->isCXXInstanceMember();
> + QualType T = InstanceMember
> + ? CGM.getContext().getMemberPointerType(
> + D->getType(), cast<RecordDecl>(D->getDeclContext())
> + ->getTypeForDecl())
> + : CGM.getContext().getPointerType(D->getType());
> + llvm::DIType TTy = getOrCreateType(T, Unit);
> + llvm::Value *V = 0;
> + // Variable pointer template parameters have a value that is the address
> + // of the variable.
> + if (const VarDecl *VD = dyn_cast<VarDecl>(D))
> + V = CGM.GetAddrOfGlobalVar(VD);
> + // Member function pointers have special support for building them, though
> + // this is currently unsupported in LLVM CodeGen.
> + if (InstanceMember)
> + if (const CXXMethodDecl *method = dyn_cast<CXXMethodDecl>(D))
> + V = CGM.getCXXABI().EmitMemberPointer(method);
> + // Member data pointers have special handling too to compute the fixed
> + // offset within the object.
> + if (isa<FieldDecl>(D)) {
> + // These five lines (& possibly the above member function pointer
> + // handling) might be able to be refactored to use similar code in
> + // CodeGenModule::getMemberPointerConstant
> + uint64_t fieldOffset = CGM.getContext().getFieldOffset(D);
> + CharUnits chars =
> + CGM.getContext().toCharUnitsFromBits((int64_t) fieldOffset);
> + V = CGM.getCXXABI().EmitMemberDataPointer(
> + cast<MemberPointerType>(T.getTypePtr()), chars);
> + }
> + llvm::DITemplateValueParameter TVP =
> + DBuilder.createTemplateValueParameter(TheCU, ND->getName(), TTy, V);
> + TemplateParams.push_back(TVP);
> + } break;
> + case TemplateArgument::NullPtr: {
> + QualType T = TA.getNullPtrType();
> + llvm::DIType TTy = getOrCreateType(T, Unit);
> + llvm::Value *V = 0;
> + // Special case member data pointer null values since they're actually -1
> + // instead of zero.
> + if (const MemberPointerType *MPT =
> + dyn_cast<MemberPointerType>(T.getTypePtr()))
> + // But treat member function pointers as simple zero integers because
> + // it's easier than having a special case in LLVM's CodeGen. If LLVM
> + // CodeGen grows handling for values of non-null member function
> + // pointers then perhaps we could remove this special case and rely on
> + // EmitNullMemberPointer for member function pointers.
> + if (MPT->isMemberDataPointer())
> + V = CGM.getCXXABI().EmitNullMemberPointer(MPT);
> + if (!V)
> + V = llvm::ConstantInt::get(CGM.Int8Ty, 0);
> + llvm::DITemplateValueParameter TVP =
> + DBuilder.createTemplateValueParameter(TheCU, ND->getName(), TTy, V);
> + TemplateParams.push_back(TVP);
> + } break;
> + case TemplateArgument::Template:
> + // We could support this with the GCC extension
> + // DW_TAG_GNU_template_template_param
> + break;
> + // these next 4 should never occur
> + case TemplateArgument::Expression:
> + case TemplateArgument::TemplateExpansion:
> + case TemplateArgument::Pack:
> + case TemplateArgument::Null:
> + llvm_unreachable(
> + "These argument types shouldn't exist in concrete types");
> }
> }
> return DBuilder.getOrCreateArray(TemplateParams);
>
> Modified: cfe/trunk/test/CodeGenCXX/debug-info-template.cpp
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGenCXX/debug-info-template.cpp?rev=181634&r1=181633&r2=181634&view=diff
> ==============================================================================
> --- cfe/trunk/test/CodeGenCXX/debug-info-template.cpp (original)
> +++ cfe/trunk/test/CodeGenCXX/debug-info-template.cpp Fri May 10 16:53:14 2013
> @@ -1,26 +1,69 @@
> -// RUN: %clang_cc1 -emit-llvm -g %s -o - -std=c++11 | FileCheck %s
> +// RUN: %clang -S -emit-llvm -target x86_64-unknown_unknown -g %s -o - -std=c++11 | FileCheck %s
>
> // CHECK: [[INT:![0-9]*]] = {{.*}} ; [ DW_TAG_base_type ] [int]
> // CHECK: metadata [[TCI:![0-9]*]], i32 0, i32 1, %class.TC* @tci, null} ; [ DW_TAG_variable ] [tci]
> -// CHECK: [[TC:![0-9]*]] = {{.*}}, metadata [[TCARGS:![0-9]*]]} ; [ DW_TAG_class_type ] [TC<int, 2, &glb, &foo::e, &foo::f, nullptr>]
> -// CHECK: [[TCARGS]] = metadata !{metadata [[TCARG1:![0-9]*]], metadata [[TCARG2:![0-9]*]]}
> +// CHECK: [[TC:![0-9]*]] = {{.*}}, metadata [[TCARGS:![0-9]*]]} ; [ DW_TAG_class_type ] [TC<unsigned int, 2, &glb, &foo::e, &foo::f>]
> +// CHECK: [[TCARGS]] = metadata !{metadata [[TCARG1:![0-9]*]], metadata [[TCARG2:![0-9]*]], metadata [[TCARG3:![0-9]*]], metadata [[TCARG4:![0-9]*]], metadata [[TCARG5:![0-9]*]]}
> //
> // We seem to be missing file/line/col info on template value parameters -
> -// metadata supports it but it's not populated.
> +// metadata supports it but it's not populated. GCC doesn't emit it either,
> +// perhaps we should just drop it from the metadata.
> //
> -// CHECK: [[TCARG1]] = {{.*}}metadata !"T", metadata [[INT]], {{.*}} ; [ DW_TAG_template_type_parameter ]
> -// CHECK: [[TCARG2]] = {{.*}}metadata !"", metadata [[UINT:![0-9]*]], i64 2, {{.*}} ; [ DW_TAG_template_value_parameter ]
> -// CHECK: [[UINT]] = {{.*}} ; [ DW_TAG_base_type ] [unsigned int]
> +// CHECK: [[TCARG1]] = {{.*}}metadata !"T", metadata [[UINT:![0-9]*]], {{.*}} ; [ DW_TAG_template_type_parameter ]
> +// CHECK: [[UINT:![0-9]*]] = {{.*}} ; [ DW_TAG_base_type ] [unsigned int]
> +// CHECK: [[TCARG2]] = {{.*}}metadata !"", metadata [[UINT:![0-9]*]], i32 2, {{.*}} ; [ DW_TAG_template_value_parameter ]
> +// CHECK: [[TCARG3]] = {{.*}}metadata !"x", metadata [[INTPTR:![0-9]*]], i32* @glb, {{.*}} ; [ DW_TAG_template_value_parameter ]
> +// CHECK: [[INTPTR]] = {{.*}}, metadata [[INT]]} ; [ DW_TAG_pointer_type ] [line 0, size 64, align 64, offset 0] [from int]
> +// CHECK: [[TCARG4]] = {{.*}}metadata !"a", metadata [[MEMINTPTR:![0-9]*]], i64 8, {{.*}} ; [ DW_TAG_template_value_parameter ]
> +// CHECK: [[MEMINTPTR]] = {{.*}}, metadata [[FOO:![0-9]*]]} ; [ DW_TAG_ptr_to_member_type ] {{.*}}[from int]
> +//
> +// We could just emit a declaration of 'foo' here, rather than the entire
> +// definition (same goes for any time we emit a member (function or data)
> +// pointer type)
> +// CHECK: [[FOO]] = {{.*}} ; [ DW_TAG_structure_type ] [foo]
> +// CHECK: metadata !"f", metadata !"_ZN3foo1fEv", i32 {{[0-9]*}}, metadata [[FTYPE:![0-9]*]],
> +// CHECK: [[FTYPE:![0-9]*]] = {{.*}}, metadata [[FARGS:![0-9]*]], i32 0, i32 0} ; [ DW_TAG_subroutine_type ]
> +// CHECK: [[FARGS]] = metadata !{null, metadata [[FARG1:![0-9]*]]}
> +// CHECK: [[FARG1]] = {{.*}} ; [ DW_TAG_pointer_type ] [line 0, size 64, align 64, offset 0] [artificial] [from foo]
> +//
> +// Currently Clang emits the pointer-to-member-function value, but LLVM doesn't
> +// use it (GCC doesn't emit a value for pointers to member functions either - so
> +// it's not clear what, if any, format would be acceptable to GDB)
> +//
> +// CHECK: [[TCARG5]] = {{.*}}metadata !"b", metadata [[MEMFUNPTR:![0-9]*]], { i64, i64 } { i64 ptrtoint (void (%struct.foo*)* @_ZN3foo1fEv to i64), i64 0 }, {{.*}} ; [ DW_TAG_template_value_parameter ]
> +// CHECK: [[MEMFUNPTR]] = {{.*}}, metadata [[FTYPE]], metadata [[FOO]]} ; [ DW_TAG_ptr_to_member_type ]
> +
>
> +// CHECK: metadata [[TCNT:![0-9]*]], i32 0, i32 1, %class.TC.0* @tcn, null} ; [ DW_TAG_variable ] [tcn]
> +// CHECK: [[TCNT:![0-9]*]] = {{.*}}, metadata [[TCNARGS:![0-9]*]]} ; [ DW_TAG_class_type ] [TC<int, -3, nullptr, nullptr, nullptr>]
> +// CHECK: [[TCNARGS]] = metadata !{metadata [[TCNARG1:![0-9]*]], metadata [[TCNARG2:![0-9]*]], metadata [[TCNARG3:![0-9]*]], metadata [[TCNARG4:![0-9]*]], metadata [[TCNARG5:![0-9]*]]}
> +// CHECK: [[TCNARG1]] = {{.*}}metadata !"T", metadata [[INT]], {{.*}} ; [ DW_TAG_template_type_parameter ]
> +// CHECK: [[TCNARG2]] = {{.*}}metadata !"", metadata [[INT]], i32 -3, {{.*}} ; [ DW_TAG_template_value_parameter ]
> +// CHECK: [[TCNARG3]] = {{.*}}metadata !"x", metadata [[INTPTR]], i8 0, {{.*}} ; [ DW_TAG_template_value_parameter ]
> +
> +// The interesting null pointer: -1 for member data pointers (since they are
> +// just an offset in an object, they can be zero and non-null for the first
> +// member)
> +
> +// CHECK: [[TCNARG4]] = {{.*}}metadata !"a", metadata [[MEMINTPTR]], i64 -1, {{.*}} ; [ DW_TAG_template_value_parameter ]
> +//
> +// In some future iteration we could possibly emit the value of a null member
> +// function pointer as '{ i64, i64 } zeroinitializer' as it may be handled
> +// naturally from the LLVM CodeGen side once we decide how to handle non-null
> +// member function pointers. For now, it's simpler just to emit the 'i8 0'.
> +//
> +// CHECK: [[TCNARG5]] = {{.*}}metadata !"b", metadata [[MEMFUNPTR:![0-9]*]], i8 0, {{.*}} ; [ DW_TAG_template_value_parameter ]
> struct foo {
> + char pad[8]; // make the member pointer to 'e' a bit more interesting (nonzero)
> int e;
> void f();
> };
>
> -template<typename T, unsigned, int *x, int foo::*a, void (foo::*b)(), int *n>
> +template<typename T, T, int *x, int foo::*a, void (foo::*b)()>
> class TC {
> };
>
> int glb;
>
> -TC<int, 2, &glb, &foo::e, &foo::f, nullptr> tci;
> +TC<unsigned, 2, &glb, &foo::e, &foo::f> tci;
> +TC<int, -3, nullptr, nullptr, nullptr> tcn;
>
>
> _______________________________________________
> cfe-commits mailing list
> cfe-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits
More information about the cfe-commits
mailing list