clang/test/CodeGenCXX/debug-info-simple-template-names.cpp

   1 // RUN: %clang_cc1 -emit-llvm -triple x86_64-unknown_unknown -std=c++17 %s -o - -w -debug-info-kind=limited -gsimple-template-names=mangled \
   2 // RUN:   | FileCheck %s
   3 // RUN: %clang_cc1 -emit-llvm -triple x86_64-unknown_unknown -std=c++17 %s -o - -w -debug-info-kind=limited -gsimple-template-names=simple \
   4 // RUN:   | FileCheck %s --implicit-check-not=_STN --check-prefix=SIMPLE
   5 // RUN: %clang_cc1 -emit-llvm -triple x86_64-unknown_unknown -std=c++17 %s -o - -w -debug-info-kind=limited \
   6 // RUN:   | FileCheck %s --implicit-check-not=_STN --check-prefix=FULL
   7 // RUN: %clang_cc1 -emit-llvm -triple x86_64-unknown_unknown -std=c++17 %s -o - -w -debug-info-kind=line-tables-only -gsimple-template-names=mangled -fdebug-info-for-profiling \
   8 // RUN:   | FileCheck %s --implicit-check-not=_STN --check-prefix=FULL
   9
  10 template <typename... T>
  11 void f1() {}
  12 template <typename T, T V>
  13 void f2() {}
  14 template <typename... T>
  15 struct t1 {};
  16 extern int x;
  17 int x;
  18 struct t2 {
  19   template <typename T = float>
  20   operator t1<int>() { __builtin_unreachable(); }
  21 };
  22 template <template <typename...> class T>
  23 void f3() {}
  24 namespace {
  25 enum LocalEnum { LocalEnum1 };
  26 }
  27 template<typename T, T ... ts>
  28 struct t3 { };
  29 struct t4 {
  30   t3<LocalEnum, LocalEnum1> m1;
  31 };
  32
  33 t4 v1;
  34 enum { UnnamedEnum1 };
  35 template<decltype(UnnamedEnum1)>
  36 void f4() {
  37 }
  38 // CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "t3<(anonymous namespace)::LocalEnum, ((anonymous namespace)::LocalEnum)0>"
  39 void f() {
  40   // Basic examples of simplifiable/rebuildable names
  41   f1<>();
  42   // CHECK: !DISubprogram(name: "_STN|f1|<>",
  43   // SIMPLE: !DISubprogram(name: "f1",
  44   // FULL: !DISubprogram(name: "f1<>",
  45   f1<int>();
  46   // CHECK: !DISubprogram(name: "_STN|f1|<int>",
  47   f1<void()>();
  48   // CHECK: !DISubprogram(name: "_STN|f1|<void ()>",
  49   f2<int, 42>();
  50   // CHECK: !DISubprogram(name: "_STN|f2|<int, 42>",
  51
  52   // Check that even though the nested name can't be rebuilt, it'll carry its
  53   // full name and the outer name can be rebuilt from that.
  54   f1<t1<void() noexcept>>();
  55   // CHECK: !DISubprogram(name: "_STN|f1|<t1<void () noexcept> >",
  56
  57   // Vector array types are encoded in DWARF but the decoding in llvm-dwarfdump
  58   // isn't implemented yet.
  59   f1<__attribute__((__vector_size__((sizeof(int) * 2)))) int>();
  60   // CHECK: !DISubprogram(name: "f1<__attribute__((__vector_size__(2 * sizeof(int)))) int>",
  61
  62   // noexcept is part of function types in C++17 onwards, but not encoded in
  63   // DWARF
  64   f1<void() noexcept>();
  65   // CHECK: !DISubprogram(name: "f1<void () noexcept>",
  66
  67   // Unnamed entities (lambdas, structs/classes, enums) can't be fully rebuilt
  68   // since we don't emit the column number. Also lambdas and unnamed classes are
  69   // ambiguous with each other - there's no DWARF that designates a lambda as
  70   // anything other than another unnamed class/struct.
  71   auto Lambda = [] {};
  72   f1<decltype(Lambda)>();
  73   // CHECK: !DISubprogram(name: "f1<(lambda at {{.*}}debug-info-simple-template-names.cpp:[[# @LINE - 2]]:17)>",
  74   f1<t1<t1<decltype(Lambda)>>>();
  75   // CHECK: !DISubprogram(name: "f1<t1<t1<(lambda at {{.*}}> > >",
  76   struct {
  77   } unnamed_struct;
  78   f1<decltype(unnamed_struct)>();
  79   // CHECK: !DISubprogram(name: "f1<(unnamed struct at {{.*}}debug-info-simple-template-names.cpp:[[# @LINE - 3]]:3)>",
  80   f1<void (decltype(unnamed_struct))>();
  81   // CHECK: !DISubprogram(name: "f1<void ((unnamed struct at {{.*}}debug-info-simple-template-names.cpp:[[# @LINE - 5]]:3))>",
  82   enum {} unnamed_enum;
  83   f1<decltype(unnamed_enum)>();
  84   // CHECK: !DISubprogram(name: "f1<(unnamed enum at {{.*}}debug-info-simple-template-names.cpp:[[# @LINE - 2]]:3)>",
  85
  86   // Declarations can't readily be reversed as the value in the DWARF only
  87   // contains the address of the value - we'd have to do symbol lookup to find
  88   // the name of that value (& rely on it not having been stripped out, etc).
  89   f2<int *, &x>();
  90   // CHECK: !DISubprogram(name: "f2<int *, &x>",
  91
  92   // We could probably handle \/ this case, but since it's a small subset of
  93   // pointer typed non-type-template parameters which can't be handled it
  94   // doesn't seem high priority.
  95   f2<decltype(nullptr), nullptr>();
  96   // CHECK: !DISubprogram(name: "f2<std::nullptr_t, nullptr>",
  97
  98   // These larger constants are encoded as data blocks which makes them a bit
  99   // harder to re-render. I think they might be missing sign information, or at
 100   // maybe it's just a question of doing APInt things to render such large
 101   // values. Punting on this for now.
 102   f2<__int128, ((__int128)9223372036854775807) * 2>();
 103   // CHECK: !DISubprogram(name: "f2<__int128, (__int128)18446744073709551614>",
 104
 105   t2().operator t1<int>();
 106   // FIXME: This should be something like "operator t1<int><float>"
 107   // CHECK: !DISubprogram(name: "operator t1<float>",
 108
 109   // Function pointer non-type-template parameters currently don't get any DWARF
 110   // value (GCC doesn't provide one either) and even if there was a value, if
 111   // it's like variable/pointer non-type template parameters, it couldn't be
 112   // rebuilt anyway (see the note above for details on that) so we don't have to
 113   // worry about seeing conversion operators as parameters to other templates.
 114
 115   f3<t1>();
 116   // CHECK: !DISubprogram(name: "_STN|f3|<t1>",
 117
 118   f1<_BitInt(3)>();
 119   // CHECK: !DISubprogram(name: "f1<_BitInt(3)>",
 120
 121   f1<const unsigned _BitInt(5)>();
 122   // CHECK: !DISubprogram(name: "f1<const unsigned _BitInt(5)>",
 123
 124   // Add a parameter just so this differs from other attributed function types
 125   // that don't mangle differently.
 126   int fnrt() __attribute__((noreturn));
 127   f1<decltype(fnrt)>();
 128   // CHECK: !DISubprogram(name: "f1<int () __attribute__((noreturn))>",
 129
 130   f4<UnnamedEnum1>();
 131   // CHECK: !DISubprogram(name: "f4<((unnamed enum at {{.*}}))0>"
 132 }