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