Clang Project

clang_source_code/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
5struct MyClass {
6  template <int i> int add(int j) {
7    return i + j;
8  }
9  virtual void func() {
10  }
11};
12
13int add2(int x) {
14  return MyClass().add<2>(x);
15}
16
17inline 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: "P", 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
77template<typename T>
78struct outer {
79  struct inner {
80    int i;
81  };
82};
83
84struct foo {
85  void func(outer<foo>::inner);
86};
87
88inline 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
95outer<foo>::inner x;
96
97template <typename T>
98struct virt {
99  T* values;
100  virtual ~virt();
101};
102struct elem {
103  static virt<elem> x; // ensure that completing 'elem' will require/completing 'virt<elem>'
104};
105inline void f1() {
106  elem e; // ensure 'elem' is required to be complete when it is emitted as a template argument for 'virt<elem>'
107};
108void 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
120template <typename T>
121T var = T();
122template <typename P>
123P var<P *> = P();
124template <typename T, int N>
125T varray[N];
126void f3() {
127  var<int> = 1;
128  var<int *> = 1;
129  varray<int, 1>[0] = 1;
130}
131
CodeThinker, Enjoy your reading code