Cool deal. -eric
On Fri, May 10, 2013 at 2:53 PM, David Blaikie <[email protected]> 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 > [email protected] > http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits _______________________________________________ cfe-commits mailing list [email protected] http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits
