1/*
2 * Copyright 2018 Google, Inc.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are
6 * met: redistributions of source code must retain the above copyright
7 * notice, this list of conditions and the following disclaimer;
8 * redistributions in binary form must reproduce the above copyright
9 * notice, this list of conditions and the following disclaimer in the
10 * documentation and/or other materials provided with the distribution;
11 * neither the name of the copyright holders nor the names of its
12 * contributors may be used to endorse or promote products derived from
13 * this software without specific prior written permission.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
18 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
19 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
21 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 *
27 * Authors: Gabe Black
28 */
29
30#include <fstream>
31#include <map>
32#include <sstream>
33#include <string>
34
35#include "base/logging.hh"
36#include "systemc/core/process.hh"
37#include "systemc/core/scheduler.hh"
38#include "systemc/ext/core/sc_main.hh"
39#include "systemc/ext/utils/sc_report_handler.hh"
40#include "systemc/utils/report.hh"
41
42namespace sc_core
43{
44
45namespace
46{
47
48std::unique_ptr<std::string> logFileName;
49std::unique_ptr<std::ofstream> logFile;
50
51} // anonymous namespace
52
53void
54sc_report_handler::report(sc_severity severity, const char *msg_type,
55 const char *msg, const char *file, int line)
56{
57 report(severity, msg_type, msg, SC_MEDIUM, file, line);
58}
59
60void
61sc_report_handler::report(sc_severity severity, const char *msg_type,
62 const char *msg, int verbosity, const char *file,
63 int line)
64{
65 if (severity == SC_INFO && verbosity > sc_gem5::reportVerbosityLevel)
66 return;
67
68 sc_gem5::ReportSevInfo &sevInfo = sc_gem5::reportSevInfos[severity];
69 sc_gem5::ReportMsgInfo &msgInfo = sc_gem5::reportMsgInfoMap[msg_type];
70
71 sevInfo.count++;
72 msgInfo.count++;
73 msgInfo.sevCounts[severity]++;
74
75 sc_actions actions = SC_UNSPECIFIED;
76 if (msgInfo.sevActions[severity] != SC_UNSPECIFIED)
77 actions = msgInfo.sevActions[severity];
78 else if (msgInfo.actions != SC_UNSPECIFIED)
79 actions = msgInfo.actions;
80 else if (sevInfo.actions != SC_UNSPECIFIED)
81 actions = sevInfo.actions;
82
83 actions &= ~sc_gem5::reportSuppressedActions;
84 actions |= sc_gem5::reportForcedActions;
85
86 msgInfo.checkLimits(severity, actions);
87 sevInfo.checkLimit(actions);
88
89 ::sc_gem5::Process *current = ::sc_gem5::scheduler.current();
90 sc_report report(severity, msg_type, msg, verbosity, file, line,
91 sc_time::from_value(::sc_gem5::scheduler.getCurTick()),
92 current ? current->name() : nullptr, msgInfo.id);
93
94 if (actions & SC_CACHE_REPORT) {
95 if (current) {
96 current->lastReport(&report);
97 } else {
98 sc_gem5::globalReportCache =
99 std::unique_ptr<sc_report>(new sc_report(report));
100 }
101 }
102
103 sc_gem5::reportHandlerProc(report, actions);
104}
105
106void
107sc_report_handler::report(sc_severity severity, int id, const char *msg,
108 const char *file, int line)
109{
110 std::string &msg_type = sc_gem5::reportIdToMsgMap[id];
111
112 if (sc_gem5::reportWarningsAsErrors && severity == SC_WARNING)
113 severity = SC_ERROR;
114
115 report(severity, msg_type.c_str(), msg, file, line);
116}
117
118sc_actions
119sc_report_handler::set_actions(sc_severity severity, sc_actions actions)
120{
121 sc_gem5::ReportSevInfo &info = sc_gem5::reportSevInfos[severity];
122 sc_actions previous = info.actions;
123 info.actions = actions;
124 return previous;
125}
126
127sc_actions
128sc_report_handler::set_actions(const char *msg_type, sc_actions actions)
129{
130 sc_gem5::ReportMsgInfo &info = sc_gem5::reportMsgInfoMap[msg_type];
131 sc_actions previous = info.actions;
132 info.actions = actions;
133 return previous;
134}
135
136sc_actions
137sc_report_handler::set_actions(
138 const char *msg_type, sc_severity severity, sc_actions actions)
139{
140 sc_gem5::ReportMsgInfo &info = sc_gem5::reportMsgInfoMap[msg_type];
141 sc_actions previous = info.sevActions[severity];
142 info.sevActions[severity] = actions;
143 return previous;
144}
145
146int
147sc_report_handler::stop_after(sc_severity severity, int limit)
148{
149 sc_gem5::ReportSevInfo &info = sc_gem5::reportSevInfos[severity];
150 int previous = info.limit;
151 info.limit = limit;
152 return previous;
153}
154
155int
156sc_report_handler::stop_after(const char *msg_type, int limit)
157{
158 sc_gem5::ReportMsgInfo &info = sc_gem5::reportMsgInfoMap[msg_type];
159 int previous = info.limit;
160 info.limit = limit;
161 return previous;
162}
163
164int
165sc_report_handler::stop_after(
166 const char *msg_type, sc_severity severity, int limit)
167{
168 sc_gem5::ReportMsgInfo &info = sc_gem5::reportMsgInfoMap[msg_type];
169 int previous = info.sevLimits[severity];
170 info.sevLimits[severity] = limit;
171 return previous;
172}
173
174int
175sc_report_handler::get_count(sc_severity severity)
176{
177 return sc_gem5::reportSevInfos[severity].count;
178}
179
180int
181sc_report_handler::get_count(const char *msg_type)
182{
183 return sc_gem5::reportMsgInfoMap[msg_type].count;
184}
185
186int
187sc_report_handler::get_count(const char *msg_type, sc_severity severity)
188{
189 return sc_gem5::reportMsgInfoMap[msg_type].sevCounts[severity];
190}
191
192int
193sc_report_handler::set_verbosity_level(int vl)
194{
195 int previous = sc_gem5::reportVerbosityLevel;
196 sc_gem5::reportVerbosityLevel = vl;
197 return previous;
198}
199
200int
201sc_report_handler::get_verbosity_level()
202{
203 return sc_gem5::reportVerbosityLevel;
204}
205
206
207sc_actions
208sc_report_handler::suppress(sc_actions actions)
209{
210 sc_actions previous = sc_gem5::reportSuppressedActions;
211 sc_gem5::reportSuppressedActions = actions;
212 return previous;
213}
214
215sc_actions
216sc_report_handler::suppress()
217{
218 return suppress(SC_UNSPECIFIED);
219}
220
221sc_actions
222sc_report_handler::force(sc_actions actions)
223{
224 sc_actions previous = sc_gem5::reportForcedActions;
225 sc_gem5::reportForcedActions = actions;
226 return previous;
227}
228
229sc_actions
230sc_report_handler::force()
231{
232 return force(SC_UNSPECIFIED);
233}
234
235
236sc_actions
237sc_report_handler::set_catch_actions(sc_actions actions)
238{
239 sc_actions previous = sc_gem5::reportCatchActions;
240 sc_gem5::reportCatchActions = actions;
241 return previous;
242}
243
244sc_actions
245sc_report_handler::get_catch_actions()
246{
247 return sc_gem5::reportCatchActions;
248}
249
250
251void
252sc_report_handler::set_handler(sc_report_handler_proc proc)
253{
254 sc_gem5::reportHandlerProc = proc;
255}
256
257void
258sc_report_handler::default_handler(
259 const sc_report &report, const sc_actions &actions)
260{
261 if (actions & SC_DISPLAY)
262 cprintf("\n%s\n", sc_report_compose_message(report));
263
264 if ((actions & SC_LOG) && logFile) {
265 ccprintf(*logFile, "%s: %s\n", report.get_time().to_string(),
266 sc_report_compose_message(report));
267 }
268 if (actions & SC_STOP) {
269 sc_stop_here(report.get_msg_type(), report.get_severity());
270 sc_stop();
271 }
272 if (actions & SC_INTERRUPT)
273 sc_interrupt_here(report.get_msg_type(), report.get_severity());
274 if (actions & SC_ABORT)
275 sc_abort();
276 if (actions & SC_THROW) {
277 ::sc_gem5::Process *current = ::sc_gem5::scheduler.current();
278 if (current)
279 current->isUnwinding(false);
280 throw report;
281 }
282}
283
284sc_actions
285sc_report_handler::get_new_action_id()
286{
287 static sc_actions maxAction = SC_ABORT;
288 maxAction = maxAction << 1;
289 return maxAction;
290}
291
292sc_report *
293sc_report_handler::get_cached_report()
294{
295 ::sc_gem5::Process *current = ::sc_gem5::scheduler.current();
296 if (current)
297 return current->lastReport();
298 return ::sc_gem5::globalReportCache.get();
299}
300
301void
302sc_report_handler::clear_cached_report()
303{
304 ::sc_gem5::Process *current = ::sc_gem5::scheduler.current();
305 if (current) {
306 current->lastReport(nullptr);
307 } else {
308 ::sc_gem5::globalReportCache = nullptr;
309 }
310}
311
312bool
313sc_report_handler::set_log_file_name(const char *new_name)
314{
315 if (!new_name) {
316 logFile = nullptr;
317 logFileName = nullptr;
318 return false;
319 } else {
320 if (logFileName)
321 return false;
322 logFileName = std::unique_ptr<std::string>(new std::string(new_name));
323 logFile = std::unique_ptr<std::ofstream>(new std::ofstream(new_name));
324 return true;
325 }
326}
327
328const char *
329sc_report_handler::get_log_file_name()
330{
331 if (!logFileName)
332 return nullptr;
333 else
334 return logFileName->c_str();
335}
336
337void
338sc_interrupt_here(const char *msg_type, sc_severity)
339{
340 // Purposefully empty, for setting breakpoints supposedly.
341}
342
343void
344sc_stop_here(const char *msg_type, sc_severity)
345{
346 // Purposefully empty, for setting breakpoints supposedly.
347}
348
349const std::string
350sc_report_compose_message(const sc_report &report)
351{
352 std::ostringstream str;
353
354 const char *sevName = sc_gem5::reportSeverityNames[report.get_severity()];
355 int id = report.get_id();
356
357 str << sevName << ": ";
358 if (id >= 0) {
359 ccprintf(str, "(%c%d) ", sevName[0], id);
360 }
361 str << report.get_msg_type();
362
363 const char *msg = report.get_msg();
364 if (msg && msg[0])
365 str << ": " << msg;
366
367 if (report.get_severity() > SC_INFO) {
368 ccprintf(str, "\nIn file: %s:%d", report.get_file_name(),
369 report.get_line_number());
370
371 ::sc_gem5::Process *current = ::sc_gem5::scheduler.current();
372 const char *name = report.get_process_name();
373 if (current && sc_is_running() && name) {
374 ccprintf(str, "\nIn process: %s @ %s", name,
375 report.get_time().to_string());
376 }
377 }
378
379 return str.str();
380}
381
382bool
383sc_report_close_default_log()
384{
385 if (logFile) {
386 logFile = nullptr;
387 logFileName = nullptr;
388 return false;
389 }
390 return true;
391}
392
393} // namespace sc_core