Branch data Line data Source code
1 : : /* Hierarchical log messages for the analyzer.
2 : : Copyright (C) 2014-2024 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
8 : : under the terms of the GNU General Public License as published by
9 : : the Free Software Foundation; either version 3, or (at your option)
10 : : any later version.
11 : :
12 : : GCC is distributed in the hope that it will be useful, but
13 : : WITHOUT ANY WARRANTY; without even the implied warranty of
14 : : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 : : General Public License 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 : : /* Adapted from jit-logging.h. */
22 : :
23 : : #ifndef ANALYZER_LOGGING_H
24 : : #define ANALYZER_LOGGING_H
25 : :
26 : : #include "diagnostic-core.h"
27 : :
28 : : namespace ana {
29 : :
30 : : /* A logger encapsulates a logging stream: a way to send
31 : : lines of pertinent information to a FILE *. */
32 : :
33 : : class logger
34 : : {
35 : : public:
36 : : logger (FILE *f_out, int flags, int verbosity, const pretty_printer &reference_pp);
37 : : ~logger ();
38 : :
39 : : void incref (const char *reason);
40 : : void decref (const char *reason);
41 : :
42 : : void log (const char *fmt, ...)
43 : : ATTRIBUTE_GCC_DIAG(2, 3);
44 : : void log_va (const char *fmt, va_list *ap)
45 : : ATTRIBUTE_GCC_DIAG(2, 0);
46 : : void start_log_line ();
47 : : void log_partial (const char *fmt, ...)
48 : : ATTRIBUTE_GCC_DIAG(2, 3);
49 : : void log_va_partial (const char *fmt, va_list *ap)
50 : : ATTRIBUTE_GCC_DIAG(2, 0);
51 : : void end_log_line ();
52 : :
53 : : void enter_scope (const char *scope_name);
54 : : void enter_scope (const char *scope_name, const char *fmt, va_list *ap)
55 : : ATTRIBUTE_GCC_DIAG(3, 0);
56 : : void exit_scope (const char *scope_name);
57 : 2598 : void inc_indent () { m_indent_level++; }
58 : 2598 : void dec_indent () { m_indent_level--; }
59 : :
60 : 3338 : pretty_printer *get_printer () const { return m_pp; }
61 : 2 : FILE *get_file () const { return m_f_out; }
62 : :
63 : : private:
64 : : DISABLE_COPY_AND_ASSIGN (logger);
65 : :
66 : : int m_refcount;
67 : : FILE *m_f_out;
68 : : int m_indent_level;
69 : : bool m_log_refcount_changes;
70 : : pretty_printer *m_pp;
71 : : };
72 : :
73 : : /* The class log_scope is an RAII-style class intended to make
74 : : it easy to notify a logger about entering and exiting the body of a
75 : : given function. */
76 : :
77 : : class log_scope
78 : : {
79 : : public:
80 : : log_scope (logger *logger, const char *name);
81 : : log_scope (logger *logger, const char *name, const char *fmt, ...)
82 : : ATTRIBUTE_GCC_DIAG(4, 5);
83 : : ~log_scope ();
84 : :
85 : : private:
86 : : DISABLE_COPY_AND_ASSIGN (log_scope);
87 : :
88 : : logger *m_logger;
89 : : const char *m_name;
90 : : };
91 : :
92 : : /* The constructor for log_scope.
93 : :
94 : : The normal case is that the logger is NULL, in which case this should
95 : : be largely a no-op.
96 : :
97 : : If we do have a logger, notify it that we're entering the given scope.
98 : : We also need to hold a reference on it, to avoid a use-after-free
99 : : when logging the cleanup of the owner of the logger. */
100 : :
101 : : inline
102 : 5794813 : log_scope::log_scope (logger *logger, const char *name) :
103 : 5794813 : m_logger (logger),
104 : 5794813 : m_name (name)
105 : : {
106 : 5794813 : if (m_logger)
107 : : {
108 : 1673 : m_logger->incref ("log_scope ctor");
109 : 1673 : m_logger->enter_scope (m_name);
110 : : }
111 : 5794813 : }
112 : :
113 : : inline
114 : 1604219 : log_scope::log_scope (logger *logger, const char *name, const char *fmt, ...):
115 : 1604219 : m_logger (logger),
116 : 1604219 : m_name (name)
117 : : {
118 : 1604219 : if (m_logger)
119 : : {
120 : 429 : m_logger->incref ("log_scope ctor");
121 : 429 : va_list ap;
122 : 429 : va_start (ap, fmt);
123 : 429 : m_logger->enter_scope (m_name, fmt, &ap);
124 : 429 : va_end (ap);
125 : : }
126 : 1604219 : }
127 : :
128 : :
129 : : /* The destructor for log_scope; essentially the opposite of
130 : : the constructor. */
131 : :
132 : : inline
133 : 7399026 : log_scope::~log_scope ()
134 : : {
135 : 7399026 : if (m_logger)
136 : : {
137 : 2102 : m_logger->exit_scope (m_name);
138 : 2102 : m_logger->decref ("log_scope dtor");
139 : : }
140 : 7399026 : }
141 : :
142 : : /* A log_user is something that potentially uses a logger (which could be NULL).
143 : :
144 : : The log_user class keeps the reference-count of a logger up-to-date. */
145 : :
146 : : class log_user
147 : : {
148 : : public:
149 : : log_user (logger *logger);
150 : : ~log_user ();
151 : :
152 : 10372623 : logger * get_logger () const { return m_logger; }
153 : : void set_logger (logger * logger);
154 : :
155 : : void log (const char *fmt, ...) const
156 : : ATTRIBUTE_GCC_DIAG(2, 3);
157 : :
158 : : void start_log_line () const;
159 : : void end_log_line () const;
160 : :
161 : : void enter_scope (const char *scope_name);
162 : : void exit_scope (const char *scope_name);
163 : :
164 : : pretty_printer *get_logger_pp () const
165 : : {
166 : : gcc_assert (m_logger);
167 : : return m_logger->get_printer ();
168 : : }
169 : :
170 : 3739 : FILE *get_logger_file () const
171 : : {
172 : 3737 : if (m_logger == NULL)
173 : : return NULL;
174 : 2 : return m_logger->get_file ();
175 : : }
176 : :
177 : : private:
178 : : DISABLE_COPY_AND_ASSIGN (log_user);
179 : :
180 : : logger *m_logger;
181 : : };
182 : :
183 : : /* A shortcut for calling log from a log_user, handling the common
184 : : case where the underlying logger is NULL via a no-op. */
185 : :
186 : : inline void
187 : 73959 : log_user::log (const char *fmt, ...) const
188 : : {
189 : 73959 : if (m_logger)
190 : : {
191 : 154 : va_list ap;
192 : 154 : va_start (ap, fmt);
193 : 154 : m_logger->log_va (fmt, &ap);
194 : 154 : va_end (ap);
195 : : }
196 : 73959 : }
197 : :
198 : : /* A shortcut for starting a log line from a log_user,
199 : : handling the common case where the underlying logger is NULL via
200 : : a no-op. */
201 : :
202 : : inline void
203 : 100 : log_user::start_log_line () const
204 : : {
205 : 100 : if (m_logger)
206 : 100 : m_logger->start_log_line ();
207 : : }
208 : :
209 : : /* A shortcut for ending a log line from a log_user,
210 : : handling the common case where the underlying logger is NULL via
211 : : a no-op. */
212 : :
213 : : inline void
214 : 100 : log_user::end_log_line () const
215 : : {
216 : 100 : if (m_logger)
217 : 100 : m_logger->end_log_line ();
218 : : }
219 : :
220 : : /* A shortcut for recording entry into a scope from a log_user,
221 : : handling the common case where the underlying logger is NULL via
222 : : a no-op. */
223 : :
224 : : inline void
225 : : log_user::enter_scope (const char *scope_name)
226 : : {
227 : : if (m_logger)
228 : : m_logger->enter_scope (scope_name);
229 : : }
230 : :
231 : : /* A shortcut for recording exit from a scope from a log_user,
232 : : handling the common case where the underlying logger is NULL via
233 : : a no-op. */
234 : :
235 : : inline void
236 : : log_user::exit_scope (const char *scope_name)
237 : : {
238 : : if (m_logger)
239 : : m_logger->exit_scope (scope_name);
240 : : }
241 : :
242 : : /* If the given logger is non-NULL, log entry/exit of this scope to
243 : : it, identifying it using __PRETTY_FUNCTION__. */
244 : :
245 : : #define LOG_SCOPE(LOGGER) \
246 : : log_scope s (LOGGER, __PRETTY_FUNCTION__)
247 : :
248 : : /* If the given logger is non-NULL, log entry/exit of this scope to
249 : : it, identifying it using __func__. */
250 : :
251 : : #define LOG_FUNC(LOGGER) \
252 : : log_scope s (LOGGER, __func__)
253 : :
254 : : #define LOG_FUNC_1(LOGGER, FMT, A0) \
255 : : log_scope s (LOGGER, __func__, FMT, A0)
256 : :
257 : : #define LOG_FUNC_2(LOGGER, FMT, A0, A1) \
258 : : log_scope s (LOGGER, __func__, FMT, A0, A1)
259 : :
260 : : #define LOG_FUNC_3(LOGGER, FMT, A0, A1, A2) \
261 : : log_scope s (LOGGER, __func__, FMT, A0, A1, A2)
262 : :
263 : : #define LOG_FUNC_4(LOGGER, FMT, A0, A1, A2, A3) \
264 : : log_scope s (LOGGER, __func__, FMT, A0, A1, A2, A3)
265 : :
266 : : } // namespace ana
267 : :
268 : : #endif /* ANALYZER_LOGGING_H */
|
