clang/test/CodeGenCXX/debug-info-template-member.cpp

   1 // RUN: %clang_cc1 -emit-llvm -debug-info-kind=limited -triple x86_64-apple-darwin %s -o - | FileCheck %s
   2
   3 // CHECK: @x ={{.*}} global %"struct.outer<foo>::inner" zeroinitializer, align 4, !dbg [[X:![0-9]+]]
   4
   5 struct MyClass {
   6   template <int i> int add(int j) {
   7     return i + j;
   8   }
   9   virtual void func() {
  10   }
  11 };
  12
  13 int add2(int x) {
  14   return MyClass().add<2>(x);
  15 }
  16
  17 inline int add3(int x) {
  18   return MyClass().add<3>(x); // even though add<3> is ODR used, don't emit it since we don't codegen it
  19 }
  20
  21 // The compile unit pulls in the global variables first.
  22 // CHECK: [[X]] = !DIGlobalVariableExpression(var: [[XV:.*]], expr: !DIExpression())
  23 // CHECK: [[XV]] = distinct !DIGlobalVariable(name: "x",
  24 // CHECK-SAME:                                type: ![[OUTER_FOO_INNER_ID:[0-9]+]]
  25 //
  26 // CHECK: {{![0-9]+}} = distinct !DIGlobalVariable(
  27 // CHECK-SAME: name: "var"
  28 // CHECK-SAME: templateParams: {{![0-9]+}}
  29 // CHECK: !DITemplateTypeParameter(name: "T", type: [[TY:![0-9]+]])
  30 // CHECK: {{![0-9]+}} = distinct !DIGlobalVariable(
  31 // CHECK-SAME: name: "var"
  32 // CHECK-SAME: templateParams: {{![0-9]+}}
  33 // CHECK: !DITemplateTypeParameter(name: "T", type: {{![0-9]+}})
  34 // CHECK: {{![0-9]+}} = distinct !DIGlobalVariable(
  35 // CHECK-SAME: name: "varray"
  36 // CHECK-SAME: templateParams: {{![0-9]+}}
  37 // CHECK: !DITemplateValueParameter(name: "N", type: [[TY]], value: i32 1)
  38
  39 // CHECK: ![[OUTER_FOO_INNER_ID:[0-9]*]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "inner"{{.*}}, identifier:
  40 // CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "foo"
  41 // CHECK-SAME:             elements: [[FOO_MEM:![0-9]*]]
  42 // CHECK-SAME:             identifier: "_ZTS3foo"
  43 // CHECK: [[FOO_MEM]] = !{[[FOO_FUNC:![0-9]*]]}
  44 // CHECK: [[FOO_FUNC]] = !DISubprogram(name: "func", linkageName: "_ZN3foo4funcEN5outerIS_E5innerE",
  45 // CHECK-SAME:                         type: [[FOO_FUNC_TYPE:![0-9]*]]
  46 // CHECK: [[FOO_FUNC_TYPE]] = !DISubroutineType(types: [[FOO_FUNC_PARAMS:![0-9]*]])
  47 // CHECK: [[FOO_FUNC_PARAMS]] = !{null, !{{[0-9]*}}, ![[OUTER_FOO_INNER_ID]]}
  48
  49 // CHECK: [[C:![0-9]*]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "MyClass"
  50 // CHECK-SAME:                             elements: [[C_MEM:![0-9]*]]
  51 // CHECK-SAME:                             vtableHolder: [[C]]
  52 // CHECK-SAME:                             identifier: "_ZTS7MyClass")
  53 // CHECK: [[C_MEM]] = !{[[C_VPTR:![0-9]*]], [[C_FUNC:![0-9]*]]}
  54 // CHECK: [[C_VPTR]] = !DIDerivedType(tag: DW_TAG_member, name: "_vptr$MyClass"
  55
  56 // CHECK: [[C_FUNC]] = !DISubprogram(name: "func",{{.*}} line: 9,
  57
  58 // CHECK: !DISubprogram(name: "add<2>"
  59 // CHECK-SAME:          scope: [[C]]
  60 //
  61 // CHECK: [[VIRT_TEMP:![0-9]+]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "virt<elem>"
  62 // CHECK-SAME:             elements: [[VIRT_MEM:![0-9]*]]
  63 // CHECK-SAME:             vtableHolder: [[VIRT_TEMP]]
  64 // CHECK-SAME:             templateParams: [[VIRT_TEMP_PARAM:![0-9]*]]
  65 // CHECK-SAME:             identifier: "_ZTS4virtI4elemE"
  66
  67 // CHECK: [[ELEM:![0-9]+]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "elem"
  68 // CHECK-SAME:                                elements: [[ELEM_MEM:![0-9]*]]
  69 // CHECK-SAME:                                identifier: "_ZTS4elem"
  70 // CHECK: [[ELEM_MEM]] = !{[[ELEM_X:![0-9]*]]}
  71 // CHECK: [[ELEM_X]] = !DIDerivedType(tag: DW_TAG_member, name: "x", scope: [[ELEM]]
  72 // CHECK-SAME:                        baseType: [[VIRT_TEMP:![0-9]+]]
  73
  74 // CHECK: [[VIRT_TEMP_PARAM]] = !{[[VIRT_T:![0-9]*]]}
  75 // CHECK: [[VIRT_T]] = !DITemplateTypeParameter(name: "T", type: [[ELEM]])
  76
  77 template<typename T>
  78 struct outer {
  79   struct inner {
  80     int i;
  81   };
  82 };
  83
  84 struct foo {
  85   void func(outer<foo>::inner);
  86 };
  87
  88 inline void func() {
  89   // require 'foo' to be complete before the emission of 'inner' so that, when
  90   // constructing the context chain for 'x' we emit the full definition of
  91   // 'foo', which requires the definition of 'inner' again
  92   foo f;
  93 }
  94
  95 outer<foo>::inner x;
  96
  97 template <typename T>
  98 struct virt {
  99   T* values;
 100   virtual ~virt();
 101 };
 102 struct elem {
 103   static virt<elem> x; // ensure that completing 'elem' will require/completing 'virt<elem>'
 104 };
 105 inline void f1() {
 106   elem e; // ensure 'elem' is required to be complete when it is emitted as a template argument for 'virt<elem>'
 107 };
 108 void f2() {
 109   virt<elem> d; // emit 'virt<elem>'
 110 }
 111
 112 // Check that the member function template specialization and implicit special
 113 // members (the default ctor) refer to their class by scope, even though they
 114 // didn't appear in the class's member list (C_MEM). This prevents the functions
 115 // from being added to type units, while still appearing in the type
 116 // declaration/reference in the compile unit.
 117 // CHECK: !DISubprogram(name: "MyClass"
 118 // CHECK-SAME:          scope: [[C]]
 119
 120 template <typename T>
 121 T var = T();
 122 template <typename P>
 123 P var<P *> = P();
 124 template <typename T, int N>
 125 T varray[N];
 126 void f3() {
 127   var<int> = 1;
 128   var<int *> = 1;
 129   varray<int, 1>[0] = 1;
 130 }