Line data Source code
1 : /* Concrete classes for selftests involving diagnostic paths.
2 : Copyright (C) 2019-2026 Free Software Foundation, Inc.
3 : Contributed by David Malcolm <dmalcolm@redhat.com>
4 :
5 : This file is part of GCC.
6 :
7 : GCC is free software; you can redistribute it and/or modify it under
8 : the terms of the GNU General Public License as published by the Free
9 : Software Foundation; either version 3, or (at your option) any later
10 : version.
11 :
12 : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 : WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 : FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 : for more details.
16 :
17 : You should have received a copy of the GNU General Public License
18 : along with GCC; see the file COPYING3. If not see
19 : <http://www.gnu.org/licenses/>. */
20 :
21 :
22 : #include "config.h"
23 : #define INCLUDE_VECTOR
24 : #include "system.h"
25 : #include "coretypes.h"
26 : #include "version.h"
27 : #include "diagnostics/selftest-paths.h"
28 :
29 : #if CHECKING_P
30 :
31 : namespace diagnostics {
32 : namespace paths {
33 : namespace selftest {
34 :
35 : /* class test_path : public diagnostics::paths::path. */
36 :
37 1660 : test_path::
38 : test_path (logical_locations::selftest::test_manager &logical_loc_mgr,
39 1660 : pretty_printer *event_pp)
40 : : path (logical_loc_mgr),
41 1660 : m_test_logical_loc_mgr (logical_loc_mgr),
42 1660 : m_event_pp (event_pp)
43 : {
44 1660 : add_thread ("main");
45 1660 : }
46 :
47 : /* Implementation of path::num_events vfunc for
48 : test_path: simply get the number of events in the vec. */
49 :
50 : unsigned
51 5744 : test_path::num_events () const
52 : {
53 5744 : return m_events.length ();
54 : }
55 :
56 : /* Implementation of path::get_event vfunc for
57 : test_path: simply return the event in the vec. */
58 :
59 : const event &
60 18988 : test_path::get_event (int idx) const
61 : {
62 18988 : return *m_events[idx];
63 : }
64 :
65 : unsigned
66 4 : test_path::num_threads () const
67 : {
68 4 : return m_threads.length ();
69 : }
70 :
71 : const thread &
72 1284 : test_path::get_thread (thread_id_t idx) const
73 : {
74 1284 : return *m_threads[idx];
75 : }
76 :
77 : bool
78 6264 : test_path::same_function_p (int event_idx_a,
79 : int event_idx_b) const
80 : {
81 6264 : return (m_events[event_idx_a]->get_logical_location ()
82 6264 : == m_events[event_idx_b]->get_logical_location ());
83 : }
84 :
85 : thread_id_t
86 1660 : test_path::add_thread (const char *name)
87 : {
88 1660 : m_threads.safe_push (new test_thread (name));
89 1660 : return m_threads.length () - 1;
90 : }
91 :
92 : /* Add an event to this path at LOC within function FNDECL at
93 : stack depth DEPTH.
94 :
95 : Use m_context's printer to format FMT, as the text of the new
96 : event.
97 :
98 : Return the id of the new event. */
99 :
100 : event_id_t
101 4548 : test_path::add_event (location_t loc,
102 : const char *funcname,
103 : int depth,
104 : const char *fmt, ...)
105 : {
106 4548 : pretty_printer *pp = m_event_pp;
107 4548 : pp_clear_output_area (pp);
108 :
109 4548 : rich_location rich_loc (line_table, UNKNOWN_LOCATION);
110 :
111 4548 : va_list ap;
112 :
113 4548 : va_start (ap, fmt);
114 :
115 : /* No localization is done on FMT. */
116 4548 : text_info ti (fmt, &ap, 0, nullptr, &rich_loc);
117 4548 : pp_format (pp, &ti);
118 4548 : pp_output_formatted_text (pp);
119 :
120 4548 : va_end (ap);
121 :
122 4548 : test_event *new_event
123 : = new test_event (loc,
124 : logical_location_from_funcname (funcname),
125 : depth,
126 4548 : pp_formatted_text (pp));
127 4548 : m_events.safe_push (new_event);
128 :
129 4548 : pp_clear_output_area (pp);
130 :
131 9096 : return event_id_t (m_events.length () - 1);
132 4548 : }
133 :
134 : event_id_t
135 120 : test_path::add_thread_event (thread_id_t thread_id,
136 : location_t loc,
137 : const char *funcname,
138 : int depth,
139 : const char *fmt, ...)
140 : {
141 120 : pretty_printer *pp = m_event_pp;
142 120 : pp_clear_output_area (pp);
143 :
144 120 : rich_location rich_loc (line_table, UNKNOWN_LOCATION);
145 :
146 120 : va_list ap;
147 :
148 120 : va_start (ap, fmt);
149 :
150 : /* No localization is done on FMT. */
151 120 : text_info ti (fmt, &ap, 0, nullptr, &rich_loc);
152 :
153 120 : pp_format (pp, &ti);
154 120 : pp_output_formatted_text (pp);
155 :
156 120 : va_end (ap);
157 :
158 120 : test_event *new_event
159 : = new test_event (loc,
160 : logical_location_from_funcname (funcname),
161 : depth,
162 : pp_formatted_text (pp),
163 120 : thread_id);
164 120 : m_events.safe_push (new_event);
165 :
166 120 : pp_clear_output_area (pp);
167 :
168 240 : return event_id_t (m_events.length () - 1);
169 120 : }
170 :
171 : /* Mark the most recent event on this path (which must exist) as being
172 : connected to the next one to be added. */
173 :
174 : void
175 2016 : test_path::connect_to_next_event ()
176 : {
177 2016 : gcc_assert (m_events.length () > 0);
178 2016 : m_events[m_events.length () - 1]->connect_to_next_event ();
179 2016 : }
180 :
181 : void
182 60 : test_path::add_entry (const char *callee_name,
183 : int stack_depth,
184 : thread_id_t thread_id)
185 : {
186 60 : add_thread_event (thread_id, UNKNOWN_LOCATION, callee_name, stack_depth,
187 : "entering %qs", callee_name);
188 60 : }
189 :
190 : void
191 12 : test_path::add_return (const char *caller_name,
192 : int stack_depth,
193 : thread_id_t thread_id)
194 : {
195 12 : add_thread_event (thread_id, UNKNOWN_LOCATION, caller_name, stack_depth,
196 : "returning to %qs", caller_name);
197 12 : }
198 :
199 : void
200 48 : test_path::add_call (const char *caller_name,
201 : int caller_stack_depth,
202 : const char *callee_name,
203 : thread_id_t thread_id)
204 : {
205 48 : add_thread_event (thread_id, UNKNOWN_LOCATION,
206 : caller_name, caller_stack_depth,
207 : "calling %qs", callee_name);
208 48 : add_entry (callee_name, caller_stack_depth + 1, thread_id);
209 48 : }
210 :
211 : logical_locations::key
212 4668 : test_path::logical_location_from_funcname (const char *funcname)
213 : {
214 4668 : return m_test_logical_loc_mgr.logical_location_from_funcname (funcname);
215 : }
216 :
217 : /* struct test_event. */
218 :
219 : /* test_event's ctor. */
220 :
221 4668 : test_event::
222 : test_event (location_t loc,
223 : logical_location logical_loc,
224 : int depth,
225 : const char *desc,
226 4668 : thread_id_t thread_id)
227 4668 : : m_loc (loc),
228 4668 : m_logical_loc (logical_loc),
229 4668 : m_depth (depth), m_desc (xstrdup (desc)),
230 4668 : m_connected_to_next_event (false),
231 4668 : m_thread_id (thread_id)
232 : {
233 4668 : }
234 :
235 : /* test_event's dtor. */
236 :
237 9336 : test_event::~test_event ()
238 : {
239 4668 : free (m_desc);
240 9336 : }
241 :
242 : } // namespace diagnostics::paths::selftest
243 : } // namespace diagnostics::paths
244 : } // namespace diagnostics
245 :
246 : #endif /* #if CHECKING_P */
|
