[clang] 4f3a92c - DebugInfo: Refactor/deduplicate various template argument list emission
David Blaikie via cfe-commits
cfe-commits at lists.llvm.org
Mon Aug 30 22:40:19 PDT 2021
Author: David Blaikie
Date: 2021-08-30T22:39:46-07:00
New Revision: 4f3a92ca0aff115ee17649610c46d8705e550a03
URL: https://github.com/llvm/llvm-project/commit/4f3a92ca0aff115ee17649610c46d8705e550a03
DIFF: https://github.com/llvm/llvm-project/commit/4f3a92ca0aff115ee17649610c46d8705e550a03.diff
LOG: DebugInfo: Refactor/deduplicate various template argument list emission
Streamline template arguments across types, variables, and functions -
for convenient reuse in experiments related to template argument list
reconstitution (not including template argument lists in the "name" of
those entities, and leaving it to debug info consumers to rebuild the
full template name from the semantic descriptions of the argument lists)
But the change seems like a good refactoring/cleanup anyway.
I'd certainly be open to suggestions about how this might be more
streamlined - like is there no generic way to query template argument
lists across the 3 kinds of entities, rather than needing special case
code?
Added:
Modified:
clang/lib/CodeGen/CGDebugInfo.cpp
clang/lib/CodeGen/CGDebugInfo.h
Removed:
################################################################################
diff --git a/clang/lib/CodeGen/CGDebugInfo.cpp b/clang/lib/CodeGen/CGDebugInfo.cpp
index fcccd42c116da..0a20ce39135ac 100644
--- a/clang/lib/CodeGen/CGDebugInfo.cpp
+++ b/clang/lib/CodeGen/CGDebugInfo.cpp
@@ -1888,23 +1888,25 @@ void CGDebugInfo::CollectCXXBasesAux(
}
llvm::DINodeArray
-CGDebugInfo::CollectTemplateParams(const TemplateParameterList *TPList,
- ArrayRef<TemplateArgument> TAList,
+CGDebugInfo::CollectTemplateParams(Optional<TemplateArgs> OArgs,
llvm::DIFile *Unit) {
+ if (!OArgs)
+ return llvm::DINodeArray();
+ TemplateArgs &Args = *OArgs;
SmallVector<llvm::Metadata *, 16> TemplateParams;
- for (unsigned i = 0, e = TAList.size(); i != e; ++i) {
- const TemplateArgument &TA = TAList[i];
+ for (unsigned i = 0, e = Args.Args.size(); i != e; ++i) {
+ const TemplateArgument &TA = Args.Args[i];
StringRef Name;
bool defaultParameter = false;
- if (TPList)
- Name = TPList->getParam(i)->getName();
+ if (Args.TList)
+ Name = Args.TList->getParam(i)->getName();
switch (TA.getKind()) {
case TemplateArgument::Type: {
llvm::DIType *TTy = getOrCreateType(TA.getAsType(), Unit);
- if (TPList)
+ if (Args.TList)
if (auto *templateType =
- dyn_cast_or_null<TemplateTypeParmDecl>(TPList->getParam(i)))
+ dyn_cast_or_null<TemplateTypeParmDecl>(Args.TList->getParam(i)))
if (templateType->hasDefaultArgument())
defaultParameter =
templateType->getDefaultArgument() == TA.getAsType();
@@ -1915,9 +1917,9 @@ CGDebugInfo::CollectTemplateParams(const TemplateParameterList *TPList,
} break;
case TemplateArgument::Integral: {
llvm::DIType *TTy = getOrCreateType(TA.getIntegralType(), Unit);
- if (TPList && CGM.getCodeGenOpts().DwarfVersion >= 5)
- if (auto *templateType =
- dyn_cast_or_null<NonTypeTemplateParmDecl>(TPList->getParam(i)))
+ if (Args.TList && CGM.getCodeGenOpts().DwarfVersion >= 5)
+ if (auto *templateType = dyn_cast_or_null<NonTypeTemplateParmDecl>(
+ Args.TList->getParam(i)))
if (templateType->hasDefaultArgument() &&
!templateType->getDefaultArgument()->isValueDependent())
defaultParameter = llvm::APSInt::isSameValue(
@@ -2002,7 +2004,7 @@ CGDebugInfo::CollectTemplateParams(const TemplateParameterList *TPList,
case TemplateArgument::Pack:
TemplateParams.push_back(DBuilder.createTemplateParameterPack(
TheCU, Name, nullptr,
- CollectTemplateParams(nullptr, TA.getPackAsArray(), Unit)));
+ CollectTemplateParams({{nullptr, TA.getPackAsArray()}}, Unit)));
break;
case TemplateArgument::Expression: {
const Expr *E = TA.getAsExpr();
@@ -2025,43 +2027,58 @@ CGDebugInfo::CollectTemplateParams(const TemplateParameterList *TPList,
return DBuilder.getOrCreateArray(TemplateParams);
}
-llvm::DINodeArray
-CGDebugInfo::CollectFunctionTemplateParams(const FunctionDecl *FD,
- llvm::DIFile *Unit) {
+Optional<CGDebugInfo::TemplateArgs>
+CGDebugInfo::GetTemplateArgs(const FunctionDecl *FD) const {
if (FD->getTemplatedKind() ==
FunctionDecl::TK_FunctionTemplateSpecialization) {
const TemplateParameterList *TList = FD->getTemplateSpecializationInfo()
->getTemplate()
->getTemplateParameters();
- return CollectTemplateParams(
- TList, FD->getTemplateSpecializationArgs()->asArray(), Unit);
+ return {{TList, FD->getTemplateSpecializationArgs()->asArray()}};
}
- return llvm::DINodeArray();
+ return None;
}
-
-llvm::DINodeArray CGDebugInfo::CollectVarTemplateParams(const VarDecl *VL,
- llvm::DIFile *Unit) {
+Optional<CGDebugInfo::TemplateArgs>
+CGDebugInfo::GetTemplateArgs(const VarDecl *VD) const {
// Always get the full list of parameters, not just the ones from the
// specialization. A partial specialization may have fewer parameters than
// there are arguments.
- auto *TS = dyn_cast<VarTemplateSpecializationDecl>(VL);
+ auto *TS = dyn_cast<VarTemplateSpecializationDecl>(VD);
if (!TS)
- return llvm::DINodeArray();
+ return None;
VarTemplateDecl *T = TS->getSpecializedTemplate();
const TemplateParameterList *TList = T->getTemplateParameters();
auto TA = TS->getTemplateArgs().asArray();
- return CollectTemplateParams(TList, TA, Unit);
+ return {{TList, TA}};
+}
+Optional<CGDebugInfo::TemplateArgs>
+CGDebugInfo::GetTemplateArgs(const RecordDecl *RD) const {
+ if (auto *TSpecial = dyn_cast<ClassTemplateSpecializationDecl>(RD)) {
+ // Always get the full list of parameters, not just the ones from the
+ // specialization. A partial specialization may have fewer parameters than
+ // there are arguments.
+ TemplateParameterList *TPList =
+ TSpecial->getSpecializedTemplate()->getTemplateParameters();
+ const TemplateArgumentList &TAList = TSpecial->getTemplateArgs();
+ return {{TPList, TAList.asArray()}};
+ }
+ return None;
}
-llvm::DINodeArray CGDebugInfo::CollectCXXTemplateParams(
- const ClassTemplateSpecializationDecl *TSpecial, llvm::DIFile *Unit) {
- // Always get the full list of parameters, not just the ones from the
- // specialization. A partial specialization may have fewer parameters than
- // there are arguments.
- TemplateParameterList *TPList =
- TSpecial->getSpecializedTemplate()->getTemplateParameters();
- const TemplateArgumentList &TAList = TSpecial->getTemplateArgs();
- return CollectTemplateParams(TPList, TAList.asArray(), Unit);
+llvm::DINodeArray
+CGDebugInfo::CollectFunctionTemplateParams(const FunctionDecl *FD,
+ llvm::DIFile *Unit) {
+ return CollectTemplateParams(GetTemplateArgs(FD), Unit);
+}
+
+llvm::DINodeArray CGDebugInfo::CollectVarTemplateParams(const VarDecl *VL,
+ llvm::DIFile *Unit) {
+ return CollectTemplateParams(GetTemplateArgs(VL), Unit);
+}
+
+llvm::DINodeArray CGDebugInfo::CollectCXXTemplateParams(const RecordDecl *RD,
+ llvm::DIFile *Unit) {
+ return CollectTemplateParams(GetTemplateArgs(RD), Unit);
}
llvm::DINodeArray CGDebugInfo::CollectBTFTagAnnotations(const Decl *D) {
diff --git a/clang/lib/CodeGen/CGDebugInfo.h b/clang/lib/CodeGen/CGDebugInfo.h
index 0d22accb93b66..6e873aab91400 100644
--- a/clang/lib/CodeGen/CGDebugInfo.h
+++ b/clang/lib/CodeGen/CGDebugInfo.h
@@ -272,9 +272,12 @@ class CGDebugInfo {
llvm::DenseSet<CanonicalDeclPtr<const CXXRecordDecl>> &SeenTypes,
llvm::DINode::DIFlags StartingFlags);
+ struct TemplateArgs {
+ const TemplateParameterList *TList;
+ llvm::ArrayRef<TemplateArgument> Args;
+ };
/// A helper function to collect template parameters.
- llvm::DINodeArray CollectTemplateParams(const TemplateParameterList *TPList,
- ArrayRef<TemplateArgument> TAList,
+ llvm::DINodeArray CollectTemplateParams(Optional<TemplateArgs> Args,
llvm::DIFile *Unit);
/// A helper function to collect debug info for function template
/// parameters.
@@ -286,11 +289,14 @@ class CGDebugInfo {
llvm::DINodeArray CollectVarTemplateParams(const VarDecl *VD,
llvm::DIFile *Unit);
+ Optional<TemplateArgs> GetTemplateArgs(const VarDecl *) const;
+ Optional<TemplateArgs> GetTemplateArgs(const RecordDecl *) const;
+ Optional<TemplateArgs> GetTemplateArgs(const FunctionDecl *) const;
+
/// A helper function to collect debug info for template
/// parameters.
- llvm::DINodeArray
- CollectCXXTemplateParams(const ClassTemplateSpecializationDecl *TS,
- llvm::DIFile *F);
+ llvm::DINodeArray CollectCXXTemplateParams(const RecordDecl *TS,
+ llvm::DIFile *F);
/// A helper function to collect debug info for btf_tag annotations.
llvm::DINodeArray CollectBTFTagAnnotations(const Decl *D);
More information about the cfe-commits
mailing list