Preserve typedef names in debug info for template type parameters

[probinson]

Summary

If a template instantiation uses a typedef'd name as a template parameter, this is usually resolved
to its underlying type when we generate the name of the instance in the debug info.
PS4 prefers to see the original parameter as in the source. Define an option that makes that happen,
and have the default for the option depend on debugger tuning.

This also provides some motivation for D14358.

[aprantl]

include/clang/AST/PrettyPrinter.h

205

\brief is no longer necessary and just makes the source code harder to read.

include/clang/Basic/LangOptions.def

266

Perhaps PreserveSugarInTemplateTypes since it appears to also affect qualifiers?

[dblaikie]

include/clang/AST/TemplateBase.h

109–111

I'd like Richard Smith (currently on vacation) to take a look at the changes to the AST like this.

(maybe it should be preserving the type as written, including decltype, typeof, etc - and those can be stripped out later by debug info emission? Maybe there's a way this is useful for clang diagnostics as well - or could leverage/reuse techniques already used there)

include/clang/Basic/LangOptions.def

266

Which qualifiers did you have in mind? (normally qualifiers would have to be preserved, right? (eg: a template type parameter of 'const int' is distinct from a template type parameter of 'int', etc))

Though I tend to agree Sugar's probably a better/broader/more general term here - but would love to have concrete examples of what does end up being preserved here.

(also having 'debug' or similar (dwarf, etc) in the name of this option might be useful - not sure if there's prior art to draw from in terms of other debug related langopts)

[majnemer]

This might be a silly question but why not do this by default?

[probinson]

Abandoning. This change is irrelevant to the SCE debugger, and while I believe it could be made more complete and better reflect the original source (which is what the DWARF spec says names should be), I do not have time to pursue it.

If somebody else feels moved to take it up, go ahead.

include/clang/AST/PrettyPrinter.h

: Indentation(2), SuppressSpecifiers(false),
       ConstantArraySizeAsWritten(false), AnonymousTagLocations(true),
       SuppressStrongLifetime(false), SuppressLifetimeQualifiers(false),
       SuppressTemplateArgsInCXXConstructors(false),
       Bool(LO.Bool), Restrict(LO.C99),
       Alignof(LO.CPlusPlus11), UnderscoreAlignof(LO.C11),
       UseVoidForZeroParams(!LO.CPlusPlus),
       TerseOutput(false), PolishForDeclaration(false),
       Half(LO.Half), MSWChar(LO.MicrosoftExt && !LO.WChar),
-      IncludeNewlines(true), MSVCFormatting(false) { }
+      IncludeNewlines(true), MSVCFormatting(false),
+      PrintTemplateTypesWithTypedefs(LO.EmitTypedefNamesInTemplateTypes) { }
 
   /// \brief Adjust this printing policy for cases where it's known that
   /// we're printing C++ code (for instance, if AST dumping reaches a
   /// C++-only construct). This should not be used if a real LangOptions
   /// object is available.
   void adjustForCPlusPlus() {
     SuppressTagKeyword = true;
     Bool = true;
struct PrintingPolicy {
 
   /// \brief When true, include newlines after statements like "break", etc.
   unsigned IncludeNewlines : 1;
 
   /// \brief Use whitespace and punctuation like MSVC does. In particular, this
   /// prints anonymous namespaces as `anonymous namespace' and does not insert
   /// spaces after template arguments.
   bool MSVCFormatting : 1;
+
+  /// \brief When true, print template type arguments without removing typedefs.
+  unsigned PrintTemplateTypesWithTypedefs : 1;
 };
 
 } // end namespace clang
 
 #endif

include/clang/AST/TemplateBase.h

private:
   struct TA {
     unsigned Kind;
     unsigned NumExpansions;
     void *Name;
   };
   struct TV {
     unsigned Kind;
     uintptr_t V;
+    // This is the type that most closely resembles what is in the source.
+    // At the moment it is retaining typedefs, but not decltype or typeof.
+    uintptr_t DisplayType;
   };
   union {
     struct DA DeclArg;
     struct I Integer;
     struct A Args;
     struct TA TemplateArg;
     struct TV TypeOrValue;
   };
 
   TemplateArgument(TemplateName, bool) = delete;
   
 public:
   /// \brief Construct an empty, invalid template argument.
-  constexpr TemplateArgument() : TypeOrValue({Null, 0}) {}
+  constexpr TemplateArgument() : TypeOrValue({Null, 0, 0}) {}
 
   /// \brief Construct a template type argument.
   TemplateArgument(QualType T, bool isNullPtr = false) {
     TypeOrValue.Kind = isNullPtr ? NullPtr : Type;
+    TypeOrValue.V = TypeOrValue.DisplayType =
+      reinterpret_cast<uintptr_t>(T.getAsOpaquePtr());
+  }
+
+  /// Construct a template type argument and record the display type.
+  TemplateArgument(QualType T, QualType DisplayType, bool isNullPtr = false) {
+    TypeOrValue.Kind = isNullPtr ? NullPtr : Type;
     TypeOrValue.V = reinterpret_cast<uintptr_t>(T.getAsOpaquePtr());
+    TypeOrValue.DisplayType = 
+      reinterpret_cast<uintptr_t>(DisplayType.getAsOpaquePtr());
   }
 
   /// \brief Construct a template argument that refers to a
   /// declaration, which is either an external declaration or a
   /// template declaration.
   TemplateArgument(ValueDecl *D, QualType QT) {
     assert(D && "Expected decl");
     DeclArg.Kind = Declaration;
public:
   bool isPackExpansion() const;
   
   /// \brief Retrieve the type for a type template argument.
   QualType getAsType() const {
     assert(getKind() == Type && "Unexpected kind");
     return QualType::getFromOpaquePtr(reinterpret_cast<void*>(TypeOrValue.V));
   }
 
+  /// Retrieve the display type for a type template argument.
+  QualType getAsDisplayType() const {
+    assert(getKind() == Type && "Unexpected kind");
+    return QualType::getFromOpaquePtr(reinterpret_cast<void*>(TypeOrValue.DisplayType));
+  }
+
   /// \brief Retrieve the declaration for a declaration non-type
   /// template argument.
   ValueDecl *getAsDecl() const {
     assert(getKind() == Declaration && "Unexpected kind");
     return DeclArg.D;
   }
 
   QualType getParamTypeForDecl() const {

include/clang/AST/Type.h

public:
   QualType withoutLocalFastQualifiers() const {
     QualType T = *this;
     T.removeLocalFastQualifiers();
     return T;
   }
 
   QualType getCanonicalType() const;
 
+  /// Returns the type that should be used in contexts that require
+  /// representation that closely resembles what is written in the source. 
+  QualType getDisplayType(const ASTContext &Context) const;
+
   /// \brief Return this type with all of the instance-specific qualifiers
   /// removed, but without removing any qualifiers that may have been applied
   /// through typedefs.
   QualType getLocalUnqualifiedType() const { return QualType(getTypePtr(), 0); }
 
   /// \brief Retrieve the unqualified variant of the given type,
   /// removing as little sugar as possible.
   ///

include/clang/Basic/LangOptions.def

BENIGN_LANGOPT(BracketDepth, 32, 256,
                "maximum bracket nesting depth")
 BENIGN_LANGOPT(NumLargeByValueCopy, 32, 0,
         "if non-zero, warn about parameter or return Warn if parameter/return value is larger in bytes than this setting. 0 is no check.")
 VALUE_LANGOPT(MSCompatibilityVersion, 32, 0, "Microsoft Visual C/C++ Version")
 VALUE_LANGOPT(VtorDispMode, 2, 1, "How many vtordisps to insert")
 
 LANGOPT(ApplePragmaPack, 1, 0, "Apple gcc-compatible #pragma pack handling")
 
+// Emit template type names with typedef names in the template parameters,
+// when recording them in DWARF, rather than the canonical type.
+LANGOPT(EmitTypedefNamesInTemplateTypes, 1, 0,
+        "emit typedef names in template types (DWARF)")
+
 LANGOPT(RetainCommentsFromSystemHeaders, 1, 0, "retain documentation comments from system headers in the AST")
 
 LANGOPT(SanitizeAddressFieldPadding, 2, 0, "controls how aggressive is ASan "
                                            "field padding (0: none, 1:least "
                                            "aggressive, 2: more aggressive)")
 
 LANGOPT(XRayInstrument, 1, 0, "controls whether to do XRay instrumentation")
 

include/clang/Driver/Options.td

 def fno_standalone_debug : Flag<["-"], "fno-standalone-debug">, Group<f_Group>, Flags<[CoreOption]>,
   HelpText<"Limit debug information produced to reduce size of debug binary">;
 def flimit_debug_info : Flag<["-"], "flimit-debug-info">, Flags<[CoreOption]>, Alias<fno_standalone_debug>;
 def fno_limit_debug_info : Flag<["-"], "fno-limit-debug-info">, Flags<[CoreOption]>, Alias<fstandalone_debug>;
 def fdebug_macro : Flag<["-"], "fdebug-macro">, Group<f_Group>, Flags<[CoreOption]>,
   HelpText<"Emit macro debug information">;
 def fno_debug_macro : Flag<["-"], "fno-debug-macro">, Group<f_Group>, Flags<[CoreOption]>,
   HelpText<"Do not emit macro debug information">;
+def femit_typedefs_in_template_types :
+  Flag<["-"], "femit-typedefs-in-template-types">, Group<f_Group>,
+  Flags<[CC1Option, HelpHidden]>,
+  HelpText<"Preserve typedef names in debug info for template types">;
+def fno_emit_typedefs_in_template_types :
+  Flag<["-"], "fno-emit-typedefs-in-template-types">, Group<f_Group>,
+  Flags<[CC1Option, HelpHidden]>,
+  HelpText<"Use canonical type names in debug info for template types">;
 def fstrict_aliasing : Flag<["-"], "fstrict-aliasing">, Group<f_Group>,
   Flags<[DriverOption, CoreOption]>;
 def fstrict_enums : Flag<["-"], "fstrict-enums">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Enable optimizations based on the strict definition of an enum's "
            "value range">;
 def fstrict_vtable_pointers: Flag<["-"], "fstrict-vtable-pointers">,
   Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Enable optimizations based on the strict rules for overwriting "

lib/AST/TemplateBase.cpp

void TemplateArgument::print(const PrintingPolicy &Policy,
   switch (getKind()) {
   case Null:
     Out << "(no value)";
     break;
     
   case Type: {
     PrintingPolicy SubPolicy(Policy);
     SubPolicy.SuppressStrongLifetime = true;
+    if (SubPolicy.PrintTemplateTypesWithTypedefs)
+      getAsDisplayType().print(Out, SubPolicy);
+    else
       getAsType().print(Out, SubPolicy);
     break;
   }
     
   case Declaration: {
     NamedDecl *ND = cast<NamedDecl>(getAsDecl());
     Out << '&';
     if (ND->getDeclName()) {
       // FIXME: distinguish between pointer and reference args?

lib/AST/Type.cpp

case Type::Class: { \
       Cur = Ty->desugar(); \
       break; \
     }
 #include "clang/AST/TypeNodes.def"
     }
   }
 }
 
+// Returns a type that removes decltype and typeof but preserves typedef types
+// as well as all qualifers that are not provided by the typedef types
+// themselves.  The goal is to provide a type that looks reasonably close to
+// what is in the source.
+QualType QualType::getDisplayType(const ASTContext &Context) const {
+  QualifierCollector Qs;
+
+  QualType Cur = *this;
+  while (true) {
+    // Collect the qualifiers in Qs as we are desugaring the type 
+    const Type *CurTy = Qs.strip(Cur);
+    QualType Desugar = Cur.getSingleStepDesugaredType(Context); 
+    if (Cur == Desugar || CurTy->getTypeClass() == Type::Typedef)
+      return Qs.apply(Context, CurTy);
+    Cur = Desugar; 
+  }
+}
+
 SplitQualType QualType::getSplitUnqualifiedTypeImpl(QualType type) {
   SplitQualType split = type.split();
 
   // All the qualifiers we've seen so far.
   Qualifiers quals = split.Quals;
 
   // The last type node we saw with any nodes inside it.
   const Type *lastTypeWithQuals = split.Ty;

lib/Driver/ToolChains/Clang.cpp

#endif
   }
 
   if (Args.hasFlag(options::OPT_fdebug_types_section,
                    options::OPT_fno_debug_types_section, false)) {
     CmdArgs.push_back("-backend-option");
     CmdArgs.push_back("-generate-type-units");
   }
 
+  // PS4 prefers to keep typedef names in template parameters.
+  if (Args.hasFlag(options::OPT_femit_typedefs_in_template_types,
+                   options::OPT_fno_emit_typedefs_in_template_types,
+                   DebuggerTuning == llvm::DebuggerKind::SCE))
+    CmdArgs.push_back("-femit-typedefs-in-template-types");
+
   RenderDebugInfoCompressionArgs(Args, CmdArgs, D);
 
   bool UseSeparateSections = isUseSeparateSections(Triple);
 
   if (Args.hasFlag(options::OPT_ffunction_sections,
                    options::OPT_fno_function_sections, UseSeparateSections)) {
     CmdArgs.push_back("-ffunction-sections");
   }

lib/Frontend/CompilerInvocation.cpp

Diags.Report(diag::err_drv_invalid_value)
       << Args.getLastArg(OPT_stack_protector)->getAsString(Args) << SSP;
     break;
   case 0: Opts.setStackProtector(LangOptions::SSPOff); break;
   case 1: Opts.setStackProtector(LangOptions::SSPOn);  break;
   case 2: Opts.setStackProtector(LangOptions::SSPStrong); break;
   case 3: Opts.setStackProtector(LangOptions::SSPReq); break;
   }
 
+  // Whether to emit template type names while preserving typedef names in the
+  // template parameter types.
+  Opts.EmitTypedefNamesInTemplateTypes = 
+    Args.hasArg(OPT_femit_typedefs_in_template_types);
+
   // Parse -fsanitize= arguments.
   parseSanitizerKinds("-fsanitize=", Args.getAllArgValues(OPT_fsanitize_EQ),
                       Diags, Opts.Sanitize);
   // -fsanitize-address-field-padding=N has to be a LangOpt, parse it here.
   Opts.SanitizeAddressFieldPadding =
       getLastArgIntValue(Args, OPT_fsanitize_address_field_padding, 0, Diags);
   Opts.SanitizerBlacklistFiles = Args.getAllArgValues(OPT_fsanitize_blacklist);
 

lib/Sema/SemaTemplate.cpp

default: {
 
     return true;
   }
   }
 
   if (CheckTemplateArgument(Param, TSI))
     return true;
 
+  QualType DisplayArgType = ArgType.getDisplayType(Context);
+
   // Add the converted template type argument.
   ArgType = Context.getCanonicalType(ArgType);
 
   // Objective-C ARC:
   //   If an explicitly-specified template argument type is a lifetime type
   //   with no lifetime qualifier, the __strong lifetime qualifier is inferred.
   if (getLangOpts().ObjCAutoRefCount &&
       ArgType->isObjCLifetimeType() &&
       !ArgType.getObjCLifetime()) {
     Qualifiers Qs;
     Qs.setObjCLifetime(Qualifiers::OCL_Strong);
     ArgType = Context.getQualifiedType(ArgType, Qs);
   }
 
-  Converted.push_back(TemplateArgument(ArgType));
+  Converted.push_back(TemplateArgument(ArgType, DisplayArgType));
   return false;
 }
 
 /// \brief Substitute template arguments into the default template argument for
 /// the given template type parameter.
 ///
 /// \param SemaRef the semantic analysis object for which we are performing
 /// the substitution.

test/CodeGen/debug-template-types.cpp

+// RUN: %clang_cc1 -debug-info-kind=standalone -fgnu-keywords -std=c++11 -femit-typedefs-in-template-types -emit-llvm %s -o - | FileCheck %s
+
+// With -femit-typedefs-in-template-types, template parameter type names should
+// not be stripped of typedef names. This test tries some more complicated
+// cases to check that we don't drop qualifiers and attach them correctly to
+// the typename.
+
+
+class A
+{
+public:
+  int i;
+  A(){}
+};
+
+typedef A myA;
+
+myA a1;
+
+volatile decltype(a1) a;
+
+template <typename T> 
+class B
+{
+  T t;
+};
+
+// See that we collect all the qualifiers while finding the topmost typedef 
+B<const typeof(a)> b;
+// CHECK-DAG: !DICompositeType(tag: DW_TAG_class_type, name: "B<const volatile myA>"
+
+class C
+{
+public:
+  C(){}
+  C(volatile C&){}
+};
+
+typedef volatile C myC;
+
+const myC c;
+
+template <typename T> 
+class D
+{
+  T t;
+};
+
+// See that we don't add the typedef's qualifiers to the type name
+D<decltype(c)> d;
+// CHECK-DAG: !DICompositeType(tag: DW_TAG_class_type, name: "D<const myC>"
+
+
+typedef int func();
+typedef float myFloat;
+
+template <typename ...T>
+class F
+{
+  void foo(T...);
+};
+
+// See that we deal with parameter packs
+F<func, volatile myFloat> f;
+// CHECK-DAG: !DICompositeType(tag: DW_TAG_class_type, name: "F<func, volatile myFloat>"
+
+
+template <typename T, typename S = myA>
+class G
+{
+  T t;
+  S s;
+};
+
+// See that we display parameters that are template types and default 
+// parameters correctly
+G<D<myC>> g;
+// CHECK-DAG: !DICompositeType(tag: DW_TAG_class_type, name: "G<D<myC>, myA>"
+
+template <typename T>
+T foo(T t)
+{
+  return t;
+}
+
+template <> 
+const myC foo<const myC>(const myC)
+{
+  myC c;
+  return c;
+}
+
+// See that we do display the typedef names for function types also
+// CHECK-DAG: !DISubprogram(name: "foo<const myC>"

test/Driver/clang_f_opts.c

 // RUN: %clang -### -S -fdebug-info-for-profiling -fno-debug-info-for-profiling %s 2>&1 | FileCheck -check-prefix=CHECK-NO-PROFILE-DEBUG %s
 // CHECK-PROFILE-DEBUG: -fdebug-info-for-profiling
 // CHECK-NO-PROFILE-DEBUG-NOT: -fdebug-info-for-profiling
 
 // RUN: %clang -### -S -fallow-editor-placeholders %s 2>&1 | FileCheck -check-prefix=CHECK-ALLOW-PLACEHOLDERS %s
 // RUN: %clang -### -S -fno-allow-editor-placeholders %s 2>&1 | FileCheck -check-prefix=CHECK-NO-ALLOW-PLACEHOLDERS %s
 // CHECK-ALLOW-PLACEHOLDERS: -fallow-editor-placeholders
 // CHECK-NO-ALLOW-PLACEHOLDERS-NOT: -fallow-editor-placeholders
+
+// RUN: %clang -### -femit-typedefs-in-template-types %s 2>&1 | FileCheck -check-prefix=CHECK-EMIT-TYPEDEF-NAMES %s
+// RUN: %clang -### -fno-emit-typedefs-in-template-types %s 2>&1 | FileCheck -check-prefix=CHECK-NO-EMIT-TYPEDEF-NAMES %s
+// RUN: %clang -### -gsce %s 2>&1 | FileCheck -check-prefix=CHECK-EMIT-TYPEDEF-NAMES %s
+// RUN: %clang -### -ggdb %s 2>&1 | FileCheck -check-prefix=CHECK-NO-EMIT-TYPEDEF-NAMES %s
+// CHECK-EMIT-TYPEDEF-NAMES:        -femit-typedefs-in-template-types
+// CHECK-NO-EMIT-TYPEDEF-NAMES-NOT: -femit-typedefs-in-template-types

test/Index/print-type.cpp

 // CHECK: DeclRefExpr=z:22:35 [type=outer::inner::Bar::FooType] [typekind=Typedef] [canonicaltype=int] [canonicaltypekind=Int] [isPOD=1]
 // CHECK: TypedefDecl=OtherType:26:18 (Definition) [type=outer::inner::Bar::OtherType] [typekind=Typedef] [canonicaltype=double] [canonicaltypekind=Double] [isPOD=1]
 // CHECK: TypedefDecl=ArrayType:27:15 (Definition) [type=outer::inner::Bar::ArrayType] [typekind=Typedef] [canonicaltype=int [5]] [canonicaltypekind=ConstantArray] [isPOD=1]
 // CHECK: IntegerLiteral= [type=int] [typekind=Int] [isPOD=1]
 // CHECK: FieldDecl=baz:28:20 (Definition) [type=Baz<int, 1, Foo>] [typekind=Unexposed] [templateargs/3= [type=int] [typekind=Int]] [canonicaltype=outer::Baz<int, 1, Foo>] [canonicaltypekind=Record] [canonicaltemplateargs/3= [type=int] [typekind=Int]] [isPOD=1]
 // CHECK: TemplateRef=Baz:9:8 [type=] [typekind=Invalid] [isPOD=0]
 // CHECK: IntegerLiteral= [type=int] [typekind=Int] [isPOD=1]
 // CHECK: TemplateRef=Foo:4:8 [type=] [typekind=Invalid] [isPOD=0]
-// CHECK: FieldDecl=qux:29:38 (Definition) [type=Qux<int, char *, Foo<int>, outer::inner::Bar::FooType>] [typekind=Unexposed] [templateargs/4= [type=int] [typekind=Int] [type=char *] [typekind=Pointer] [type=Foo<int>] [typekind=Unexposed] [type=outer::inner::Bar::FooType] [typekind=Typedef]] [canonicaltype=outer::Qux<int, char *, outer::Foo<int>, int>] [canonicaltypekind=Record] [canonicaltemplateargs/4= [type=int] [typekind=Int] [type=char *] [typekind=Pointer] [type=outer::Foo<int>] [typekind=Record] [type=int] [typekind=Int]] [isPOD=1]
+// The expression in the next line is for -femit-typedefs-in-template-types
+// which is the default on PS4.
+// CHECK: FieldDecl=qux:29:38 (Definition) [type=Qux<int, char *, Foo<int>, outer::inner::Bar::FooType>] [typekind=Unexposed] [templateargs/4= [type=int] [typekind=Int] [type=char *] [typekind=Pointer] [type=Foo<int>] [typekind=Unexposed] [type=outer::inner::Bar::FooType] [typekind=Typedef]] [canonicaltype=outer::Qux<int, char *, outer::Foo<int>, {{int|outer::inner::Bar::FooType}}>] [canonicaltypekind=Record] [canonicaltemplateargs/4= [type=int] [typekind=Int] [type=char *] [typekind=Pointer] [type=outer::Foo<int>] [typekind=Record] [type=int] [typekind=Int]] [isPOD=1]
 // CHECK: TemplateRef=Qux:12:8 [type=] [typekind=Invalid] [isPOD=0]
 // CHECK: TemplateRef=Foo:4:8 [type=] [typekind=Invalid] [isPOD=0]
 // CHECK: FunctionTemplate=tbar:36:3 [type=T (int)] [typekind=FunctionProto] [canonicaltype=type-parameter-0-0 (int)] [canonicaltypekind=FunctionProto] [resulttype=T] [resulttypekind=Unexposed] [isPOD=0]
 // CHECK: TemplateTypeParameter=T:35:20 (Definition) [type=T] [typekind=Unexposed] [canonicaltype=type-parameter-0-0] [canonicaltypekind=Unexposed] [isPOD=0]
 // CHECK: TypeRef=T:35:20 [type=T] [typekind=Unexposed] [canonicaltype=type-parameter-0-0] [canonicaltypekind=Unexposed] [isPOD=0]
 // CHECK: ParmDecl=:36:11 (Definition) [type=int] [typekind=Int] [isPOD=1]
 // CHECK: FunctionTemplate=tbar:39:3 [type=T (int *)] [typekind=FunctionProto] [canonicaltype=type-parameter-0-0 (int *)] [canonicaltypekind=FunctionProto] [resulttype=T] [resulttypekind=Unexposed] [isPOD=0]
 // CHECK: TemplateTypeParameter=T:38:20 (Definition) [type=T] [typekind=Unexposed] [canonicaltype=type-parameter-0-0] [canonicaltypekind=Unexposed] [isPOD=0]