Branch data Line data Source code
1 : : /* Internals of libgccjit: logging
2 : : Copyright (C) 2014-2025 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 : : #include "config.h"
22 : : #include "system.h"
23 : : #include "coretypes.h"
24 : : #include "toplev.h" /* for print_version */
25 : :
26 : : #include "jit-logging.h"
27 : :
28 : : namespace gcc {
29 : :
30 : : namespace jit {
31 : :
32 : : /* Implementation of class gcc::jit::logger. */
33 : :
34 : : /* The constructor for gcc::jit::logger, used by
35 : : gcc_jit_context_set_logfile. */
36 : :
37 : 1102 : logger::logger (FILE *f_out,
38 : : int, /* flags */
39 : 1102 : int /* verbosity */) :
40 : 1102 : m_refcount (0),
41 : 1102 : m_f_out (f_out),
42 : 1102 : m_indent_level (0),
43 : 1102 : m_log_refcount_changes (false)
44 : : {
45 : : /* Begin the log by writing the GCC version. */
46 : 1102 : print_version (f_out, "JIT:", false);
47 : 1102 : }
48 : :
49 : : /* The destructor for gcc::jit::logger, invoked via
50 : : the decref method when the refcount hits zero.
51 : : Note that we do not close the underlying FILE * (m_f_out). */
52 : :
53 : 1102 : logger::~logger ()
54 : : {
55 : : /* This should be the last message emitted. */
56 : 1102 : log ("%s", __PRETTY_FUNCTION__);
57 : 1102 : gcc_assert (m_refcount == 0);
58 : 1102 : }
59 : :
60 : : /* Increment the reference count of the gcc::jit::logger. */
61 : :
62 : : void
63 : 132684 : logger::incref (const char *reason)
64 : : {
65 : 132684 : m_refcount++;
66 : 132684 : if (m_log_refcount_changes)
67 : 0 : log ("%s: reason: %s refcount now %i ",
68 : : __PRETTY_FUNCTION__, reason, m_refcount);
69 : 132684 : }
70 : :
71 : : /* Decrement the reference count of the gcc::jit::logger,
72 : : deleting it if nothing is referring to it. */
73 : :
74 : : void
75 : 132684 : logger::decref (const char *reason)
76 : : {
77 : 132684 : gcc_assert (m_refcount > 0);
78 : 132684 : --m_refcount;
79 : 132684 : if (m_log_refcount_changes)
80 : 0 : log ("%s: reason: %s refcount now %i",
81 : : __PRETTY_FUNCTION__, reason, m_refcount);
82 : 132684 : if (m_refcount == 0)
83 : 1102 : delete this;
84 : 132684 : }
85 : :
86 : : /* Write a formatted message to the log, by calling the log_va method. */
87 : :
88 : : void
89 : 279282 : logger::log (const char *fmt, ...)
90 : : {
91 : 279282 : va_list ap;
92 : 279282 : va_start (ap, fmt);
93 : 279282 : log_va (fmt, ap);
94 : 279282 : va_end (ap);
95 : 279282 : }
96 : :
97 : : /* Write an indented line to the log file.
98 : :
99 : : We explicitly flush after each line: if something crashes the process,
100 : : we want the logfile/stream to contain the most up-to-date hint about the
101 : : last thing that was happening, without it being hidden in an in-process
102 : : buffer. */
103 : :
104 : : void
105 : 314860 : logger::log_va (const char *fmt, va_list ap)
106 : : {
107 : 314860 : fprintf (m_f_out, "JIT: ");
108 : 715050 : for (int i = 0; i < m_indent_level; i++)
109 : 400190 : fputc (' ', m_f_out);
110 : 314860 : vfprintf (m_f_out, fmt, ap);
111 : 314860 : fprintf (m_f_out, "\n");
112 : 314860 : fflush (m_f_out);
113 : 314860 : }
114 : :
115 : : /* Record the entry within a particular scope, indenting subsequent
116 : : log lines accordingly. */
117 : :
118 : : void
119 : 131178 : logger::enter_scope (const char *scope_name)
120 : : {
121 : 131178 : log ("entering: %s", scope_name);
122 : 131178 : m_indent_level += 1;
123 : 131178 : }
124 : :
125 : : /* Record the exit from a particular scope, restoring the indent level to
126 : : before the scope was entered. */
127 : :
128 : : void
129 : 131178 : logger::exit_scope (const char *scope_name)
130 : : {
131 : 131178 : if (m_indent_level)
132 : 131178 : m_indent_level -= 1;
133 : : else
134 : 0 : log ("(mismatching indentation)");
135 : 131178 : log ("exiting: %s", scope_name);
136 : 131178 : }
137 : :
138 : : /* Implementation of class gcc::jit::log_user. */
139 : :
140 : : /* The constructor for gcc::jit::log_user. */
141 : :
142 : 5570 : log_user::log_user (logger *logger) : m_logger (logger)
143 : : {
144 : 5570 : if (m_logger)
145 : 1536 : m_logger->incref("log_user ctor");
146 : 5570 : }
147 : :
148 : : /* The destructor for gcc::jit::log_user. */
149 : :
150 : 5568 : log_user::~log_user ()
151 : : {
152 : 5568 : if (m_logger)
153 : 2650 : m_logger->decref("log_user dtor");
154 : 5568 : }
155 : :
156 : : /* Set the logger for a gcc::jit::log_user, managing the reference counts
157 : : of the old and new logger (either of which might be NULL). */
158 : :
159 : : void
160 : 1114 : log_user::set_logger (logger *logger)
161 : : {
162 : 1114 : if (logger)
163 : 1114 : logger->incref ("log_user::set_logger");
164 : 1114 : if (m_logger)
165 : 0 : m_logger->decref ("log_user::set_logger");
166 : 1114 : m_logger = logger;
167 : 1114 : }
168 : :
169 : : } // namespace gcc::jit
170 : :
171 : : } // namespace gcc
|
