Mercurial > hg > CbC > CbC_gcc
comparison gcc/jit/jit-logging.c @ 111:04ced10e8804
gcc 7
author | kono |
---|---|
date | Fri, 27 Oct 2017 22:46:09 +0900 |
parents | |
children | 84e7813d76e9 |
comparison
equal
deleted
inserted
replaced
68:561a7518be6b | 111:04ced10e8804 |
---|---|
1 /* Internals of libgccjit: logging | |
2 Copyright (C) 2014-2017 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 logger::logger (FILE *f_out, | |
38 int, /* flags */ | |
39 int /* verbosity */) : | |
40 m_refcount (0), | |
41 m_f_out (f_out), | |
42 m_indent_level (0), | |
43 m_log_refcount_changes (false) | |
44 { | |
45 /* Begin the log by writing the GCC version. */ | |
46 print_version (f_out, "JIT:", false); | |
47 } | |
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 logger::~logger () | |
54 { | |
55 /* This should be the last message emitted. */ | |
56 log ("%s", __PRETTY_FUNCTION__); | |
57 gcc_assert (m_refcount == 0); | |
58 } | |
59 | |
60 /* Increment the reference count of the gcc::jit::logger. */ | |
61 | |
62 void | |
63 logger::incref (const char *reason) | |
64 { | |
65 m_refcount++; | |
66 if (m_log_refcount_changes) | |
67 log ("%s: reason: %s refcount now %i ", | |
68 __PRETTY_FUNCTION__, reason, m_refcount); | |
69 } | |
70 | |
71 /* Decrement the reference count of the gcc::jit::logger, | |
72 deleting it if nothing is referring to it. */ | |
73 | |
74 void | |
75 logger::decref (const char *reason) | |
76 { | |
77 gcc_assert (m_refcount > 0); | |
78 --m_refcount; | |
79 if (m_log_refcount_changes) | |
80 log ("%s: reason: %s refcount now %i", | |
81 __PRETTY_FUNCTION__, reason, m_refcount); | |
82 if (0 == m_refcount) | |
83 delete this; | |
84 } | |
85 | |
86 /* Write a formatted message to the log, by calling the log_va method. */ | |
87 | |
88 void | |
89 logger::log (const char *fmt, ...) | |
90 { | |
91 va_list ap; | |
92 va_start (ap, fmt); | |
93 log_va (fmt, ap); | |
94 va_end (ap); | |
95 } | |
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 logger::log_va (const char *fmt, va_list ap) | |
106 { | |
107 fprintf (m_f_out, "JIT: "); | |
108 for (int i = 0; i < m_indent_level; i++) | |
109 fputc (' ', m_f_out); | |
110 vfprintf (m_f_out, fmt, ap); | |
111 fprintf (m_f_out, "\n"); | |
112 fflush (m_f_out); | |
113 } | |
114 | |
115 /* Record the entry within a particular scope, indenting subsequent | |
116 log lines accordingly. */ | |
117 | |
118 void | |
119 logger::enter_scope (const char *scope_name) | |
120 { | |
121 log ("entering: %s", scope_name); | |
122 m_indent_level += 1; | |
123 } | |
124 | |
125 /* Record the exit from a particular scope, restoring the indent level to | |
126 before the scope was entered. */ | |
127 | |
128 void | |
129 logger::exit_scope (const char *scope_name) | |
130 { | |
131 if (m_indent_level) | |
132 m_indent_level -= 1; | |
133 else | |
134 log ("(mismatching indentation)"); | |
135 log ("exiting: %s", scope_name); | |
136 } | |
137 | |
138 /* Implementation of class gcc::jit::log_user. */ | |
139 | |
140 /* The constructor for gcc::jit::log_user. */ | |
141 | |
142 log_user::log_user (logger *logger) : m_logger (logger) | |
143 { | |
144 if (m_logger) | |
145 m_logger->incref("log_user ctor"); | |
146 } | |
147 | |
148 /* The destructor for gcc::jit::log_user. */ | |
149 | |
150 log_user::~log_user () | |
151 { | |
152 if (m_logger) | |
153 m_logger->decref("log_user dtor"); | |
154 } | |
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 log_user::set_logger (logger *logger) | |
161 { | |
162 if (logger) | |
163 logger->incref ("log_user::set_logger"); | |
164 if (m_logger) | |
165 m_logger->decref ("log_user::set_logger"); | |
166 m_logger = logger; | |
167 } | |
168 | |
169 } // namespace gcc::jit | |
170 | |
171 } // namespace gcc |