1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
|
#include <algorithm>
#include <cstdio>
#include <string>
inline int inline_ref_1 (int &value) __attribute__((always_inline));
inline int inline_ref_2 (int &value) __attribute__((always_inline));
int caller_ref_1 (int &value);
int caller_ref_2 (int &value);
int called_by_inline_ref (int &value);
inline void inline_trivial_1 () __attribute__((always_inline));
inline void inline_trivial_2 () __attribute__((always_inline));
// These three should share the same initial pc so we can test
// virtual inline stepping.
inline void caller_trivial_inline_1() __attribute__((always_inline));
inline void caller_trivial_inline_2() __attribute__((always_inline));
inline void caller_trivial_inline_3() __attribute__((always_inline));
void caller_trivial_1 ();
void caller_trivial_2 ();
void called_by_inline_trivial ();
static int inline_value;
int
function_to_call ()
{
return inline_value;
}
int
caller_ref_1 (int &value)
{
int increment = caller_ref_2(value); // In caller_ref_1.
value += increment; // At increment in caller_ref_1.
return value;
}
int
caller_ref_2 (int &value)
{
int increment = inline_ref_1 (value); // In caller_ref_2.
value += increment; // At increment in caller_ref_2.
return value;
}
int
called_by_inline_ref (int &value)
{
value += 1; // In called_by_inline_ref.
return value;
}
int
inline_ref_1 (int &value)
{
int increment = inline_ref_2(value); // In inline_ref_1.
value += increment; // At increment in inline_ref_1.
return value;
}
int
inline_ref_2 (int &value)
{
int increment = called_by_inline_ref (value); // In inline_ref_2.
value += 1; // At increment in inline_ref_2.
return value;
}
void
caller_trivial_1 ()
{
caller_trivial_2(); // In caller_trivial_1.
inline_value += 1;
}
void
caller_trivial_2 ()
{
asm volatile ("nop"); inline_trivial_1 (); // In caller_trivial_2.
inline_value += 1; // At increment in caller_trivial_2.
}
// When you call caller_trivial_inline_1, the inlined call-site
// should share a PC with all three of the following inlined
// functions, so we can exercise "virtual inline stepping".
void caller_trivial_inline_1() {
caller_trivial_inline_2(); // In caller_trivial_inline_1.
inline_value += 1;
}
void caller_trivial_inline_2() {
caller_trivial_inline_3(); // In caller_trivial_inline_2.
inline_value += 1; // After caller_trivial_inline_3
}
void caller_trivial_inline_3() {
inline_value += 1; // In caller_trivial_inline_3.
}
void
called_by_inline_trivial ()
{
inline_value += 1; // In called_by_inline_trivial.
}
void
inline_trivial_1 ()
{
asm volatile ("nop"); inline_trivial_2(); // In inline_trivial_1.
inline_value += 1; // At increment in inline_trivial_1.
}
void
inline_trivial_2 ()
{
inline_value += 1; // In inline_trivial_2.
called_by_inline_trivial (); // At caller_by_inline_trivial in inline_trivial_2.
}
template<typename T> T
max_value(const T& lhs, const T& rhs)
{
return std::max(lhs, rhs); // In max_value template
}
template<> std::string
max_value(const std::string& lhs, const std::string& rhs)
{
return (lhs.size() > rhs.size()) ? lhs : rhs; // In max_value specialized
}
int
main (int argc, char **argv)
{
inline_value = 0; // Stop here and step over to set up stepping over.
inline_trivial_1 (); // At inline_trivial_1 called from main.
caller_trivial_1(); // At first call of caller_trivial_1 in main.
caller_trivial_1(); // At second call of caller_trivial_1 in main.
caller_ref_1 (argc); // At first call of caller_ref_1 in main.
caller_ref_1 (argc); // At second call of caller_ref_1 in main.
function_to_call (); // Make sure debug info for this function gets generated.
max_value(123, 456); // Call max_value template
max_value(std::string("abc"), std::string("0022")); // Call max_value specialized
caller_trivial_inline_1(); // At caller_trivial_inline_1.
return 0; // About to return from main.
}
|
