luke
/
yosys
mirror of https://github.com/YosysHQ/yosys.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

log: create LogManager singleton and move implementation

This commit is contained in:
Miodrag Milanovic 2026-08-19 15:59:46 +02:00
parent b17b5a19e0
commit 2e113f5eff
23 changed files with 561 additions and 368 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
frontends/ast/ast.cc
View File

@ -321,11 +321,11 @@ AstNode::~AstNode()
void AstNode::dumpAst(FILE *f, std::string indent) const void AstNode::dumpAst(FILE *f, std::string indent) const
{ {
if (f == NULL) { if (f == NULL) {
for (auto &s : log_sinks) { logger().for_each_sink([&](LogSink &sink) {
f = s->file_handle(); FILE *f = sink.file_handle();
if (f) if (f)
dumpAst(f, indent); dumpAst(f, indent);
} });
return; return;
} }
@ -428,11 +428,11 @@ void AstNode::dumpVlog(FILE *f, std::string indent) const
std::vector<AstNode*> rem_children1, rem_children2; std::vector<AstNode*> rem_children1, rem_children2;
if (f == NULL) { if (f == NULL) {
for (auto &s : log_sinks) { logger().for_each_sink([&](LogSink &sink) {
f = s->file_handle(); FILE *f = sink.file_handle();
if (f) if (f)
dumpVlog(f, indent); dumpVlog(f, indent);
} });
return; return;
} }
@ -1944,7 +1944,7 @@ void AstModule::loadconfig() const
void AstNode::formatted_input_error(std::string str) const void AstNode::formatted_input_error(std::string str) const
{ {
log_formatted_file_error(*location.begin.filename, location.begin.line, std::move(str)); log_file_error(*location.begin.filename, location.begin.line, "%s", std::move(str));
} }
YOSYS_NAMESPACE_END YOSYS_NAMESPACE_END

12
frontends/ast/genrtlil.cc
View File

@ -1386,11 +1386,11 @@ void AstNode::detectSignWidthWorker(int &width_hint, bool &sign_hint, bool *foun
// everything should have been handled above -> print error if not. // everything should have been handled above -> print error if not.
default: default:
AstNode *current_scope_ast = current_ast_mod == nullptr ? current_ast : current_ast_mod; AstNode *current_scope_ast = current_ast_mod == nullptr ? current_ast : current_ast_mod;
for (auto &s : log_sinks) { logger().for_each_sink([&](LogSink &sink) {
auto f = s->file_handle(); FILE *f = sink.file_handle();
if (f) if (f)
current_scope_ast->dumpAst(f, "verilog-ast> "); current_scope_ast->dumpAst(f, "verilog-ast> ");
} });
input_error("Don't know how to detect sign and width for %s node!\n", type2str(type)); input_error("Don't know how to detect sign and width for %s node!\n", type2str(type));
} }
@ -2365,11 +2365,11 @@ RTLIL::SigSpec AstNode::genRTLIL(int width_hint, bool sign_hint)
// everything should have been handled above -> print error if not. // everything should have been handled above -> print error if not.
default: default:
for (auto &s : log_sinks) { logger().for_each_sink([&](LogSink &sink) {
auto f = s->file_handle(); FILE *f = sink.file_handle();
if (f) if (f)
current_ast_mod->dumpAst(f, "verilog-ast> "); current_ast_mod->dumpAst(f, "verilog-ast> ");
} });
input_error("Don't know how to generate RTLIL code for %s node!\n", type2str(type)); input_error("Don't know how to generate RTLIL code for %s node!\n", type2str(type));
} }

27
frontends/ast/simplify.cc
View File

@ -2791,10 +2791,11 @@ bool AstNode::simplify(bool const_fold, int stage, int width_hint, bool sign_hin
auto buf = children[0]->clone(); auto buf = children[0]->clone();
while (buf->simplify(true, stage, width_hint, sign_hint)) { } while (buf->simplify(true, stage, width_hint, sign_hint)) { }
if (buf->type != AST_CONSTANT) { if (buf->type != AST_CONSTANT) {
// for (auto &s : log_sinks) { //logger().for_each_sink([&](LogSink &sink) {
// auto f = s->file_handle(); // FILE *f = sink.file_handle();
// if (f) // if (f)
// dumpAst(f, "verilog-ast> "); // dumpAst(f, "verilog-ast> ");
//});
input_error("Condition for generate if is not constant!\n"); input_error("Condition for generate if is not constant!\n");
} }
if (buf->asBool() != 0) { if (buf->asBool() != 0) {
@ -2830,10 +2831,11 @@ bool AstNode::simplify(bool const_fold, int stage, int width_hint, bool sign_hin
auto buf = children[0]->clone(); auto buf = children[0]->clone();
while (buf->simplify(true, stage, width_hint, sign_hint)) { } while (buf->simplify(true, stage, width_hint, sign_hint)) { }
if (buf->type != AST_CONSTANT) { if (buf->type != AST_CONSTANT) {
// for (auto &s : log_sinks) { //logger().for_each_sink([&](LogSink &sink) {
// auto f = s->file_handle(); // FILE *f = sink.file_handle();
// if (f) // if (f)
// dumpAst(f, "verilog-ast> "); // dumpAst(f, "verilog-ast> ");
//});
input_error("Condition for generate case is not constant!\n"); input_error("Condition for generate case is not constant!\n");
} }
@ -2866,10 +2868,11 @@ bool AstNode::simplify(bool const_fold, int stage, int width_hint, bool sign_hin
buf->set_in_param_flag(true); buf->set_in_param_flag(true);
while (buf->simplify(true, stage, width_hint, sign_hint)) { } while (buf->simplify(true, stage, width_hint, sign_hint)) { }
if (buf->type != AST_CONSTANT) { if (buf->type != AST_CONSTANT) {
// for (auto &s : log_sinks) { //logger().for_each_sink([&](LogSink &sink) {
// auto f = s->file_handle(); // FILE *f = sink.file_handle();
// if (f) // if (f)
// dumpAst(f, "verilog-ast> "); // dumpAst(f, "verilog-ast> ");
//});
input_error("Expression in generate case is not constant!\n"); input_error("Expression in generate case is not constant!\n");
} }

54
kernel/driver.cc
View File

@ -19,7 +19,6 @@
#include "kernel/yosys.h" #include "kernel/yosys.h"
#include "kernel/hashlib.h" #include "kernel/hashlib.h"
#include "libs/sha1/sha1.h"
#define CXXOPTS_VECTOR_DELIMITER '\0' #define CXXOPTS_VECTOR_DELIMITER '\0'
#include "libs/cxxopts/include/cxxopts.hpp" #include "libs/cxxopts/include/cxxopts.hpp"
#include <iostream> #include <iostream>
@ -287,7 +286,7 @@ int main(int argc, char **argv)
run_shell = false; run_shell = false;
} }
if (result.count("C")) run_tcl_shell = true; if (result.count("C")) run_tcl_shell = true;
if (result.count("g")) log_force_debug++; if (result.count("g")) logger().force_debug_on();
if (result.count("m")) plugin_filenames = result["m"].as<std::vector<std::string>>(); if (result.count("m")) plugin_filenames = result["m"].as<std::vector<std::string>>();
if (result.count("f")) frontend_command = result["f"].as<std::string>(); if (result.count("f")) frontend_command = result["f"].as<std::string>();
if (result.count("H")) { if (result.count("H")) {
@ -316,7 +315,7 @@ int main(int argc, char **argv)
if (result.count(key)) { if (result.count(key)) {
for (const auto& filename : result[key].as<std::vector<std::string>>()) { for (const auto& filename : result[key].as<std::vector<std::string>>()) {
try { try {
log_sinks.push_back(std::make_unique<FileLogSink>(filename, key[0] == 'L', false)); logger().add_sink<FileLogSink>(filename, key[0] == 'L', false);
} catch (const std::runtime_error &e) { } catch (const std::runtime_error &e) {
std::cerr << e.what(); std::cerr << e.what();
exit(1); exit(1);
@ -326,15 +325,15 @@ int main(int argc, char **argv)
} }
if (result.count("q")) { if (result.count("q")) {
mode_q = true; mode_q = true;
if (log_errfile == stderr) log_quiet_warnings = true; if (log_errfile == stderr) logger().set_quiet_warnings(true);
log_errfile = stderr; log_errfile = stderr;
} }
if (result.count("v")) { if (result.count("v")) {
mode_v = true; mode_v = true;
log_errfile = stderr; log_errfile = stderr;
log_verbose_level = result["v"].as<int>(); logger().set_verbose_level(result["v"].as<int>());
} }
if (result.count("t")) log_time = true; if (result.count("t")) logger().set_log_time(true);
if (result.count("d")) timing_details = true; if (result.count("d")) timing_details = true;
for (const auto& key : {"s", "c"}) { for (const auto& key : {"s", "c"}) {
if (result.count(key)) { if (result.count(key)) {
@ -353,11 +352,11 @@ int main(int argc, char **argv)
auto regexes = result[key].as<std::vector<std::string>>(); auto regexes = result[key].as<std::vector<std::string>>();
for (const auto& regex : regexes) { for (const auto& regex : regexes) {
if (std::string(key) == "W") if (std::string(key) == "W")
log_warn_regexes.push_back(std::regex(regex)); logger().add_warn(regex);
if (std::string(key) == "w") if (std::string(key) == "w")
log_nowarn_regexes.push_back(std::regex(regex)); logger().add_nowarn(regex);
if (std::string(key) == "e") if (std::string(key) == "e")
log_werror_regexes.push_back(std::regex(regex)); logger().add_werror(regex);
} }
} }
} }
@ -372,7 +371,7 @@ int main(int argc, char **argv)
std::cerr << "Invalid number of tokens in -P ALL." << std::endl; std::cerr << "Invalid number of tokens in -P ALL." << std::endl;
exit(1); exit(1);
} }
log_hdump_all = true; logger().set_hdump_all(true);
} else { } else {
if (!tokens.empty() && !tokens[0].empty() && tokens[0].back() == '.') if (!tokens.empty() && !tokens[0].empty() && tokens[0].back() == '.')
tokens[0].pop_back(); tokens[0].pop_back();
@ -382,14 +381,14 @@ int main(int argc, char **argv)
std::cerr << "Invalid number of tokens in -P." << std::endl; std::cerr << "Invalid number of tokens in -P." << std::endl;
exit(1); exit(1);
} }
log_hdump[tokens[0]].insert(tokens[1]); logger().add_hdump(tokens[0],tokens[1]);
} }
} }
} }
if (result.count("E")) depsfile = result["E"].as<std::string>(); if (result.count("E")) depsfile = result["E"].as<std::string>();
if (result.count("x")) { if (result.count("x")) {
auto ignores = result["x"].as<std::vector<std::string>>(); for (const auto &ignore : result["x"].as<std::vector<std::string>>())
log_experimentals_ignored.insert(ignores.begin(), ignores.end()); logger().add_experimental_ignore(ignore);
} }
if (result.count("perffile")) perffile = result["perffile"].as<std::string>(); if (result.count("perffile")) perffile = result["perffile"].as<std::string>();
if (result.count("infile")) { if (result.count("infile")) {
@ -405,10 +404,10 @@ int main(int argc, char **argv)
} }
if (log_errfile == NULL) { if (log_errfile == NULL) {
log_sinks.push_back(std::make_unique<ConsoleLogSink>()); logger().add_sink<ConsoleLogSink>();
log_error_stderr = true; logger().set_error_stderr(true);
} else { } else {
log_sinks.push_back(std::make_unique<StderrLogSink>()); logger().add_sink<StderrLogSink>();
} }
if (print_banner) if (print_banner)
@ -452,7 +451,7 @@ int main(int argc, char **argv)
#endif #endif
if (print_stats) if (print_stats)
log_hasher = new SHA1; logger().start_hasher();
#if defined(__OpenBSD__) #if defined(__OpenBSD__)
// save the executable origin for proc_self_dirname() // save the executable origin for proc_self_dirname()
@ -596,28 +595,19 @@ int main(int argc, char **argv)
fprintf(f, "\n"); fprintf(f, "\n");
} }
if (log_expect_no_warnings && log_warnings_count_noexpect) logger().report_unexpected_error();
log_error("Unexpected warnings found: %d unique messages, %d total, %d expected\n", GetSize(log_warnings),
log_warnings_count, log_warnings_count - log_warnings_count_noexpect);
if (print_stats) if (print_stats)
{ {
std::string hash = log_hasher->final().substr(0, 10); std::string hash = logger().finish_hasher();
delete log_hasher; logger().set_log_time(false);
log_hasher = nullptr;
log_time = false;
yosys_xtrace = 0; yosys_xtrace = 0;
log_spacer(); log_spacer();
if (mode_v && !mode_q) if (mode_v && !mode_q)
log_stderr_force = true; logger().set_stderr_force(true);
if (log_warnings_count) logger().report_warning_stats();
log("Warnings: %d unique messages, %d total\n", GetSize(log_warnings), log_warnings_count);
if (!log_experimentals.empty())
log("Warnings: %d experimental features used (not excluded with -x).\n", GetSize(log_experimentals));
#ifdef _WIN32 #ifdef _WIN32
log("End of script. Logfile hash: %s\n", hash); log("End of script. Logfile hash: %s\n", hash);
@ -719,7 +709,7 @@ int main(int argc, char **argv)
} }
} }
log_check_expected(); logger().check_expected();
yosys_atexit(); yosys_atexit();

184
kernel/log.cc
View File

@ -38,40 +38,19 @@
YOSYS_NAMESPACE_BEGIN YOSYS_NAMESPACE_BEGIN
std::vector<std::unique_ptr<LogSink>> log_sinks; LogManager &logger()
{
std::map<std::string, std::set<std::string>> log_hdump; static LogManager instance;
std::vector<std::regex> log_warn_regexes, log_nowarn_regexes, log_werror_regexes; return instance;
dict<std::string, LogExpectedItem> log_expect_log, log_expect_warning, log_expect_error; }
dict<std::string, LogExpectedItem> log_expect_prefix_log, log_expect_prefix_warning, log_expect_prefix_error;
std::set<std::string> log_warnings, log_experimentals, log_experimentals_ignored;
int log_warnings_count = 0;
int log_warnings_count_noexpect = 0;
bool log_expect_no_warnings = false;
bool log_hdump_all = false;
SHA1 *log_hasher = NULL;
bool log_time = false;
bool log_error_stderr = false;
bool log_cmd_error_throw = false;
bool log_quiet_warnings = false;
int log_verbose_level;
void (*log_error_atexit)() = NULL; void (*log_error_atexit)() = NULL;
void (*log_verific_callback)(int msg_type, const char *message_id, const char* file_path, unsigned int left_line, unsigned int left_col, unsigned int right_line, unsigned int right_col, const char *msg) = NULL; void (*log_verific_callback)(int msg_type, const char *message_id, const char* file_path, unsigned int left_line, unsigned int left_col, unsigned int right_line, unsigned int right_col, const char *msg) = NULL;
int log_make_debug = 0; // TODO: remove when log_id is removed
int log_force_debug = 0;
int log_debug_suppressed = 0;
bool log_stderr_force = false;
vector<int> header_count;
vector<char*> log_id_cache; vector<char*> log_id_cache;
static std::optional<std::chrono::steady_clock::time_point> initial_time;
static bool next_print_log = false; static bool next_print_log = false;
static int log_newline_count = 0;
FileLogSink::FileLogSink(const std::string &filename, bool line_buffered, bool append) FileLogSink::FileLogSink(const std::string &filename, bool line_buffered, bool append)
: file(fopen(filename.c_str(), append ? "at" : "wt")) : file(fopen(filename.c_str(), append ? "at" : "wt"))
@ -92,7 +71,7 @@ FileLogSink::~FileLogSink()
void FileLogSink::log(const LogMessage &msg) void FileLogSink::log(const LogMessage &msg)
{ {
fputs(msg.legacy_msg.c_str(), file); fputs(msg.cached_msg.c_str(), file);
} }
void FileLogSink::flush() void FileLogSink::flush()
@ -102,8 +81,8 @@ void FileLogSink::flush()
void ConsoleLogSink::log(const LogMessage &msg) void ConsoleLogSink::log(const LogMessage &msg)
{ {
FILE *file = (msg.severity == LogSeverity::LOG_ERROR && log_error_stderr) ? stderr : stdout; FILE *file = (msg.severity == LogSeverity::LOG_ERROR && logger().get_error_stderr()) ? stderr : stdout;
fputs(msg.legacy_msg.c_str(), file); fputs(msg.cached_msg.c_str(), file);
} }
void ConsoleLogSink::flush() void ConsoleLogSink::flush()
@ -115,14 +94,13 @@ void ConsoleLogSink::flush()
bool StderrLogSink::should_log(const LogMessage &msg) const bool StderrLogSink::should_log(const LogMessage &msg) const
{ {
return msg.severity == LogSeverity::LOG_ERROR || return msg.severity == LogSeverity::LOG_ERROR ||
(msg.severity == LogSeverity::LOG_WARNING && !log_quiet_warnings) || (msg.severity == LogSeverity::LOG_WARNING && !logger().get_quiet_warnings()) ||
/* (msg.severity == LogSeverity::LOG_HEADER && int(header_count.size()) <= log_verbose_level) || */ logger().get_stderr_force();
log_stderr_force;
} }
void StderrLogSink::log(const LogMessage &msg) void StderrLogSink::log(const LogMessage &msg)
{ {
fputs(msg.legacy_msg.c_str(), stderr); fputs(msg.cached_msg.c_str(), stderr);
} }
void StderrLogSink::flush() void StderrLogSink::flush()
@ -131,7 +109,7 @@ void StderrLogSink::flush()
} }
ScratchPadLogSink::ScratchPadLogSink(std::string scratchpad) ScratchPadLogSink::ScratchPadLogSink(std::string scratchpad)
: scratchpad(std::move(scratchpad)) : scratchpad(std::move(scratchpad))
{ {
} }
@ -141,7 +119,7 @@ void ScratchPadLogSink::log(const LogMessage &msg)
if (!design) if (!design)
return; return;
design->scratchpad[scratchpad].append(msg.legacy_msg); design->scratchpad[scratchpad].append(msg.cached_msg);
} }
LogMessage::LogMessage(LogSeverity severity, std::string_view prefix, std::string_view format, std::string_view message) : LogMessage::LogMessage(LogSeverity severity, std::string_view prefix, std::string_view format, std::string_view message) :
@ -152,13 +130,11 @@ LogMessage::LogMessage(LogSeverity severity, std::string_view prefix, std::strin
timestamp(std::chrono::steady_clock::now()) timestamp(std::chrono::steady_clock::now())
{ {
std::string time_str; std::string time_str;
if (log_time) if (logger().get_log_time())
{ {
if (next_print_log || !initial_time) { if (next_print_log) {
next_print_log = false; next_print_log = false;
if (!initial_time) auto elapsed = std::chrono::steady_clock::now() - logger().get_initial_time();
initial_time = std::chrono::steady_clock::now();
auto elapsed = std::chrono::steady_clock::now() - *initial_time;
auto us = std::chrono::duration_cast<std::chrono::microseconds>(elapsed); auto us = std::chrono::duration_cast<std::chrono::microseconds>(elapsed);
time_str += stringf("[%05d.%06d] ", int(us.count() / 1'000'000),int(us.count() % 1'000'000)); time_str += stringf("[%05d.%06d] ", int(us.count() / 1'000'000),int(us.count() % 1'000'000));
} }
@ -172,7 +148,7 @@ LogMessage::LogMessage(LogSeverity severity, std::string_view prefix, std::strin
if (format == "%s" && message.back() == '\n') if (format == "%s" && message.back() == '\n')
next_print_log = true; next_print_log = true;
} }
legacy_msg = stringf("%s%s%s", time_str, prefix, message); cached_msg = stringf("%s%s%s", time_str, prefix, message);
} }
static void log_id_cache_clear() static void log_id_cache_clear()
@ -182,7 +158,7 @@ static void log_id_cache_clear()
log_id_cache.clear(); log_id_cache.clear();
} }
static void logv_string(std::string_view prefix, std::string_view format, std::string str_in, LogSeverity severity) { void LogManager::logv_string(std::string_view prefix, std::string_view format, std::string str_in, LogSeverity severity) {
size_t remove_leading = 0; size_t remove_leading = 0;
while (format.size() > 1 && format[0] == '\n') { while (format.size() > 1 && format[0] == '\n') {
logv_string(prefix, "\n", "\n", severity); logv_string(prefix, "\n", "\n", severity);
@ -208,10 +184,7 @@ static void logv_string(std::string_view prefix, std::string_view format, std::s
log_hasher->update(str); log_hasher->update(str);
auto msg = LogMessage(severity, prefix, format, str_in); auto msg = LogMessage(severity, prefix, format, str_in);
for (auto &sink : log_sinks) { log(msg);
if (sink->should_log(msg))
sink->log(msg);
}
static std::string linebuffer; static std::string linebuffer;
static bool log_warn_regex_recusion_guard = false; static bool log_warn_regex_recusion_guard = false;
@ -245,16 +218,16 @@ static void logv_string(std::string_view prefix, std::string_view format, std::s
} }
} }
void log_formatted_string(std::string_view prefix, std::string_view format, std::string str, LogSeverity severity) void LogManager::log_formatted_string(std::string_view prefix, std::string_view format, std::string str, LogSeverity severity)
{ {
log_assert(!Multithreading::active()); log_assert(!Multithreading::active());
if (log_make_debug && !ys_debug(1)) if (log_make_debug && !is_debug(1))
return; return;
logv_string(prefix, format, std::move(str), severity); logv_string(prefix, format, std::move(str), severity);
} }
void log_formatted_header(RTLIL::Design *design, std::string_view format, std::string str) void LogManager::log_formatted_header(RTLIL::Design *design, std::string_view format, std::string str)
{ {
log_assert(!Multithreading::active()); log_assert(!Multithreading::active());
@ -273,24 +246,24 @@ void log_formatted_header(RTLIL::Design *design, std::string_view format, std::s
log_formatted_string(stringf("%s. ", header_id), {}, {}, LogSeverity::LOG_HEADER); log_formatted_string(stringf("%s. ", header_id), {}, {}, LogSeverity::LOG_HEADER);
log_formatted_string({}, format, std::move(str), LogSeverity::LOG_HEADER); log_formatted_string({}, format, std::move(str), LogSeverity::LOG_HEADER);
log_flush(); flush();
if (log_hdump_all) if (log_hdump_all)
log_hdump[header_id].insert("yosys_dump_" + header_id + ".il"); log_hdump[header_id].insert("yosys_dump_" + header_id + ".il");
if (log_hdump.count(header_id) && design != nullptr) if (log_hdump.count(header_id) && design != nullptr)
for (auto &filename : log_hdump.at(header_id)) { for (auto &filename : log_hdump.at(header_id)) {
log("Dumping current design to '%s'.\n", filename); YOSYS_NAMESPACE_PREFIX log("Dumping current design to '%s'.\n", filename);
if (yosys_xtrace) if (yosys_xtrace)
IdString::xtrace_db_dump(); IdString::xtrace_db_dump();
Pass::call(design, {"dump", "-o", filename}); Pass::call(design, {"dump", "-o", filename});
if (yosys_xtrace) if (yosys_xtrace)
log("#X# -- end of dump --\n"); YOSYS_NAMESPACE_PREFIX log("#X# -- end of dump --\n");
} }
log_stderr_force = false; log_stderr_force = false;
} }
void log_formatted_warning(std::string_view prefix, std::string message) void LogManager::log_formatted_warning(std::string_view prefix, std::string message)
{ {
log_assert(!Multithreading::active()); log_assert(!Multithreading::active());
@ -302,7 +275,7 @@ void log_formatted_warning(std::string_view prefix, std::string message)
if (suppressed) if (suppressed)
{ {
log("Suppressed %s%s", prefix, message); YOSYS_NAMESPACE_PREFIX log("Suppressed %s%s", prefix, message);
} }
else else
{ {
@ -329,12 +302,12 @@ void log_formatted_warning(std::string_view prefix, std::string message)
if (log_warnings.count(message)) if (log_warnings.count(message))
{ {
log_formatted_string(prefix, "%s", message, LogSeverity::LOG_INFO); log_formatted_string(prefix, "%s", message, LogSeverity::LOG_INFO);
log_flush(); flush();
} }
else else
{ {
log_formatted_string(prefix, "%s", message, LogSeverity::LOG_WARNING); log_formatted_string(prefix, "%s", message, LogSeverity::LOG_WARNING);
log_flush(); flush();
log_warnings.insert(message); log_warnings.insert(message);
} }
@ -345,18 +318,18 @@ void log_formatted_warning(std::string_view prefix, std::string message)
} }
} }
void log_formatted_file_warning(std::string_view filename, int lineno, std::string str) void LogManager::log_formatted_file_warning(std::string_view filename, int lineno, std::string str)
{ {
std::string prefix = stringf("%s:%d: Warning: ", filename, lineno); std::string prefix = stringf("%s:%d: Warning: ", filename, lineno);
log_formatted_warning(prefix, std::move(str)); log_formatted_warning(prefix, std::move(str));
} }
void log_formatted_file_info(std::string_view filename, int lineno, std::string str) void LogManager::log_formatted_file_info(std::string_view filename, int lineno, std::string str)
{ {
log("%s:%d: Info: %s", filename, lineno, str); YOSYS_NAMESPACE_PREFIX log("%s:%d: Info: %s", filename, lineno, str);
} }
void log_suppressed() { void LogManager::log_suppressed() {
if (log_debug_suppressed && !log_make_debug) { if (log_debug_suppressed && !log_make_debug) {
constexpr const char* format = "<suppressed ~%d debug messages>\n"; constexpr const char* format = "<suppressed ~%d debug messages>\n";
logv_string({}, format, stringf(format, log_debug_suppressed),LogSeverity::LOG_INFO); logv_string({}, format, stringf(format, log_debug_suppressed),LogSeverity::LOG_INFO);
@ -365,14 +338,14 @@ void log_suppressed() {
} }
[[noreturn]] [[noreturn]]
static void log_error_with_prefix(std::string_view prefix, std::string message) void LogManager::log_error_with_prefix(std::string_view prefix, std::string message)
{ {
int bak_log_make_debug = log_make_debug; int bak_log_make_debug = log_make_debug;
log_make_debug = 0; log_make_debug = 0;
log_suppressed(); log_suppressed();
log_formatted_string(prefix, "%s", message, LogSeverity::LOG_ERROR); log_formatted_string(prefix, "%s", message, LogSeverity::LOG_ERROR);
log_flush(); flush();
log_make_debug = bak_log_make_debug; log_make_debug = bak_log_make_debug;
@ -384,7 +357,7 @@ static void log_error_with_prefix(std::string_view prefix, std::string message)
if (std::regex_search(string(prefix) + message, item.pattern)) if (std::regex_search(string(prefix) + message, item.pattern))
item.current_count++; item.current_count++;
log_check_expected(); check_expected();
if (log_error_atexit) if (log_error_atexit)
log_error_atexit(); log_error_atexit();
@ -401,13 +374,13 @@ static void log_error_with_prefix(std::string_view prefix, std::string message)
#endif #endif
} }
void log_formatted_file_error(std::string_view filename, int lineno, std::string str) void LogManager::log_formatted_file_error(std::string_view filename, int lineno, std::string str)
{ {
std::string prefix = stringf("%s:%d: ERROR: ", filename, lineno); std::string prefix = stringf("%s:%d: ERROR: ", filename, lineno);
log_error_with_prefix(prefix, str); log_error_with_prefix(prefix, str);
} }
void log_experimental(const std::string &str) void LogManager::log_experimental(const std::string &str)
{ {
if (log_experimentals_ignored.count(str) == 0 && log_experimentals.count(str) == 0) { if (log_experimentals_ignored.count(str) == 0 && log_experimentals.count(str) == 0) {
log_warning("Feature '%s' is experimental.\n", str); log_warning("Feature '%s' is experimental.\n", str);
@ -415,7 +388,7 @@ void log_experimental(const std::string &str)
} }
} }
void log_formatted_error(std::string str) void LogManager::log_formatted_error(std::string str)
{ {
log_error_with_prefix("ERROR: ", std::move(str)); log_error_with_prefix("ERROR: ", std::move(str));
} }
@ -435,11 +408,11 @@ void log_yosys_abort_message(std::string_view file, int line, std::string_view f
log_error("Abort in %s:%d (%s): %s\n", file, line, func, message); log_error("Abort in %s:%d (%s): %s\n", file, line, func, message);
} }
void log_formatted_cmd_error(std::string message) void LogManager::log_formatted_cmd_error(std::string message)
{ {
if (log_cmd_error_throw) { if (log_cmd_error_throw) {
log_formatted_string("ERROR: ", "%s", message, LogSeverity::LOG_ERROR); log_formatted_string("ERROR: ", "%s", message, LogSeverity::LOG_ERROR);
log_flush(); flush();
throw log_cmd_error_exception(); throw log_cmd_error_exception();
} }
@ -447,22 +420,22 @@ void log_formatted_cmd_error(std::string message)
log_formatted_error(message); log_formatted_error(message);
} }
void log_spacer() void LogManager::log_spacer()
{ {
if (log_newline_count < 2) log("\n"); if (log_newline_count < 2) YOSYS_NAMESPACE_PREFIX log("\n");
if (log_newline_count < 2) log("\n"); if (log_newline_count < 2) YOSYS_NAMESPACE_PREFIX log("\n");
} }
void log_push() void LogManager::log_push()
{ {
header_count.push_back(0); header_count.push_back(0);
} }
void log_pop() void LogManager::log_pop()
{ {
header_count.pop_back(); header_count.pop_back();
log_id_cache_clear(); log_id_cache_clear();
log_flush(); flush();
} }
#if defined(YOSYS_ENABLE_DLOPEN) #if defined(YOSYS_ENABLE_DLOPEN)
@ -562,18 +535,12 @@ void log_backtrace(const char *prefix, int levels)
void log_backtrace(const char*, int) { } void log_backtrace(const char*, int) { }
#endif #endif
void log_reset_stack() void LogManager::log_reset_stack()
{ {
while (header_count.size() > 1) while (header_count.size() > 1)
header_count.pop_back(); header_count.pop_back();
log_id_cache_clear(); log_id_cache_clear();
log_flush(); flush();
}
void log_flush()
{
for (auto &sink : log_sinks)
sink->flush();
} }
void log_dump_val_worker(RTLIL::IdString v) { void log_dump_val_worker(RTLIL::IdString v) {
@ -631,7 +598,7 @@ void log_wire(RTLIL::Wire *wire, std::string indent)
log("%s", buf.str()); log("%s", buf.str());
} }
void log_check_expected() void LogManager::check_expected()
{ {
// copy out all of the expected logs so that they cannot be re-checked // copy out all of the expected logs so that they cannot be re-checked
// or match against themselves // or match against themselves
@ -668,7 +635,7 @@ void log_check_expected()
auto check_err = [&](const std::string kind, std::string pattern, LogExpectedItem item) { auto check_err = [&](const std::string kind, std::string pattern, LogExpectedItem item) {
if (item.current_count == item.expected_count) { if (item.current_count == item.expected_count) {
log_warn_regexes.clear(); log_warn_regexes.clear();
log("Expected %s pattern '%s' found !!!\n", kind, pattern); YOSYS_NAMESPACE_PREFIX log("Expected %s pattern '%s' found !!!\n", kind, pattern);
yosys_shutdown(); yosys_shutdown();
#if defined(_MSC_VER) #if defined(_MSC_VER)
_exit(0); _exit(0);
@ -686,4 +653,51 @@ void log_check_expected()
check_err("prefixed error", pattern, item); check_err("prefixed error", pattern, item);
} }
void LogManager::report_unexpected_error()
{
if (log_expect_no_warnings && log_warnings_count_noexpect)
log_error("Unexpected warnings found: %d unique messages, %d total, %d expected\n", GetSize(log_warnings),
log_warnings_count, log_warnings_count - log_warnings_count_noexpect);
}
void LogManager::report_warning_stats()
{
if (log_warnings_count)
YOSYS_NAMESPACE_PREFIX log("Warnings: %d unique messages, %d total\n", GetSize(log_warnings), log_warnings_count);
if (!log_experimentals.empty())
YOSYS_NAMESPACE_PREFIX log("Warnings: %d experimental features used (not excluded with -x).\n", GetSize(log_experimentals));
}
void LogManager::add_expect(std::string type, std::string pattern, int count)
{
if (type == "error")
log_expect_error[pattern] = LogExpectedItem(YS_REGEX_COMPILE(pattern), count);
else if (type == "prefix-error")
log_expect_prefix_error[pattern] = LogExpectedItem(YS_REGEX_COMPILE(pattern), count);
else if (type == "warning")
log_expect_warning[pattern] = LogExpectedItem(YS_REGEX_COMPILE(pattern), count);
else if (type == "prefix-warning")
log_expect_prefix_warning[pattern] = LogExpectedItem(YS_REGEX_COMPILE(pattern), count);
else if (type == "log")
log_expect_log[pattern] = LogExpectedItem(YS_REGEX_COMPILE(pattern), count);
else if (type == "prefix-log")
log_expect_prefix_log[pattern] = LogExpectedItem(YS_REGEX_COMPILE(pattern), count);
else log_abort();
}
void LogManager::start_hasher()
{
log_hasher = std::make_unique<SHA1>();
}
std::string LogManager::finish_hasher()
{
if (!log_hasher)
return {};
std::string hash = log_hasher->final().substr(0, 10);
log_hasher.reset();
return hash;
}
YOSYS_NAMESPACE_END YOSYS_NAMESPACE_END

459
kernel/log.h
View File

@ -102,237 +102,470 @@ struct LogMessage {
std::string format; std::string format;
std::string message; std::string message;
std::chrono::steady_clock::time_point timestamp; std::chrono::steady_clock::time_point timestamp;
//TODO: remove
std::string legacy_msg; std::string cached_msg;
}; };
class LogSink class LogSink
{ {
public: public:
virtual ~LogSink() = default; virtual ~LogSink() = default;
virtual bool should_log(const LogMessage &) const { return true; } virtual bool should_log(const LogMessage &) const { return true; }
virtual void log(const LogMessage &msg) = 0; virtual void log(const LogMessage &msg) = 0;
virtual void flush() {} virtual void flush() {}
// TODO: Remove when AST/read_verilog removed // TODO: Remove when AST/read_verilog removed
virtual FILE *file_handle() { return nullptr; } virtual FILE *file_handle() { return nullptr; }
}; };
extern std::vector<std::unique_ptr<LogSink>> log_sinks;
class LogSinkRef : public LogSink class LogSinkRef : public LogSink
{ {
public: public:
explicit LogSinkRef(LogSink *sink) : sink(sink) {} explicit LogSinkRef(LogSink *sink) : sink(sink) {}
bool should_log(const LogMessage &msg) const override { return sink->should_log(msg); } bool should_log(const LogMessage &msg) const override { return sink->should_log(msg); }
void log(const LogMessage &msg) override { sink->log(msg); } void log(const LogMessage &msg) override { sink->log(msg); }
void flush() override { sink->flush(); } void flush() override { sink->flush(); }
FILE *file_handle() override { return sink->file_handle(); } FILE *file_handle() override { return sink->file_handle(); }
private: private:
LogSink *sink; LogSink *sink;
}; };
class FileLogSink : public LogSink class FileLogSink : public LogSink
{ {
public: public:
explicit FileLogSink(const std::string &filename, bool line_buffered, bool append); explicit FileLogSink(const std::string &filename, bool line_buffered, bool append);
~FileLogSink() override; ~FileLogSink() override;
void log(const LogMessage &msg) override; void log(const LogMessage &msg) override;
void flush() override; void flush() override;
FILE *file_handle() override { return file; } FILE *file_handle() override { return file; }
private: private:
FILE *file; FILE *file;
}; };
class ConsoleLogSink : public LogSink class ConsoleLogSink : public LogSink
{ {
public: public:
void log(const LogMessage &msg) override; void log(const LogMessage &msg) override;
void flush() override; void flush() override;
FILE *file_handle() override { return stdout; }; FILE *file_handle() override { return stdout; };
}; };
class StderrLogSink : public LogSink class StderrLogSink : public LogSink
{ {
public: public:
bool should_log(const LogMessage &msg) const override; bool should_log(const LogMessage &msg) const override;
void log(const LogMessage &msg) override; void log(const LogMessage &msg) override;
void flush() override; void flush() override;
};
class StreamLogSink : public LogSink
{
public:
explicit StreamLogSink(std::ostream &stream) : stream(stream) {}
void log(const LogMessage &msg) override { stream << msg.message; }
void flush() override { stream.flush(); }
private:
std::ostream &stream;
}; };
class ScratchPadLogSink : public LogSink class ScratchPadLogSink : public LogSink
{ {
public: public:
explicit ScratchPadLogSink(std::string scratchpad); explicit ScratchPadLogSink(std::string scratchpad);
void log(const LogMessage &msg) override; void log(const LogMessage &msg) override;
private: private:
std::string scratchpad; std::string scratchpad;
}; };
extern bool log_stderr_force; class LogManager
{
private:
struct LogExpectedItem
{
LogExpectedItem(const std::regex &pat, int expected) :
pattern(pat), expected_count(expected), current_count(0) {}
LogExpectedItem() : expected_count(0), current_count(0) {}
extern std::map<std::string, std::set<std::string>> log_hdump; std::regex pattern;
extern std::vector<std::regex> log_warn_regexes, log_nowarn_regexes, log_werror_regexes; int expected_count;
extern std::set<std::string> log_warnings, log_experimentals, log_experimentals_ignored; int current_count;
extern int log_warnings_count; };
extern int log_warnings_count_noexpect;
extern bool log_expect_no_warnings; public:
extern bool log_hdump_all; LogManager() = default;
extern SHA1 *log_hasher;
LogManager(const LogManager &) = delete;
LogManager &operator=(const LogManager &) = delete;
LogManager(LogManager &&) = default;
LogManager &operator=(LogManager &&) = default;
template<typename T, typename... Args>
T &add_sink(Args&&... args)
{
auto sink = std::make_unique<T>(std::forward<Args>(args)...);
T &ref = *sink;
log_sinks.push_back(std::move(sink));
return ref;
}
template<typename F>
void for_each_sink(F &&func)
{
for (auto &sink : log_sinks)
func(*sink);
}
void log(const LogMessage &msg)
{
for (auto &sink : log_sinks) {
if (sink->should_log(msg))
sink->log(msg);
}
}
bool empty() { return log_sinks.empty(); }
void clear() { log_sinks.clear(); }
void flush() { for (auto &sink : log_sinks) sink->flush(); }
class Scoped
{
public:
explicit Scoped(LogManager &manager) :
manager(manager),
backup_log_sinks(std::move(manager.log_sinks)),
backup_log_verbose_level(manager.log_verbose_level)
{
manager.log_sinks.reserve(backup_log_sinks.size());
for (const auto &sink : backup_log_sinks)
manager.log_sinks.push_back(std::make_unique<LogSinkRef>(sink.get()));
}
~Scoped()
{
manager.log_sinks.clear();
manager.log_sinks = std::move(backup_log_sinks);
manager.log_verbose_level = backup_log_verbose_level;
}
Scoped(const Scoped &) = delete;
Scoped &operator=(const Scoped &) = delete;
private:
LogManager &manager;
std::vector<std::unique_ptr<LogSink>> backup_log_sinks;
int backup_log_verbose_level;
};
Scoped scoped()
{
return Scoped(*this);
}
class ScopedCmdErrorThrow
{
public:
explicit ScopedCmdErrorThrow(LogManager &manager)
: manager(manager), previous(manager.log_cmd_error_throw)
{
manager.log_cmd_error_throw = true;
}
~ScopedCmdErrorThrow()
{
manager.log_cmd_error_throw = previous;
}
private:
LogManager &manager;
bool previous;
};
ScopedCmdErrorThrow scoped_cmd_error_throw()
{
return ScopedCmdErrorThrow(*this);
}
class LogMakeDebugHdl
{
public:
explicit LogMakeDebugHdl(LogManager &manager, bool start_on = false)
: manager(manager)
{
if (start_on)
on();
}
~LogMakeDebugHdl()
{
off();
}
void on()
{
if (status)
return;
status = true;
manager.log_make_debug++;
}
void off_silent()
{
if (!status)
return;
status = false;
manager.log_make_debug--;
}
void off()
{
off_silent();
}
private:
LogManager &manager;
bool status = false;
};
LogMakeDebugHdl make_debug(bool start_on = false)
{
return LogMakeDebugHdl(*this, start_on);
}
class ForceDebug
{
public:
explicit ForceDebug(LogManager &manager, bool start_on = false)
: manager(manager)
{
if (start_on)
on();
}
~ForceDebug()
{
off();
}
void on()
{
if (active)
return;
active = true;
manager.log_force_debug++;
}
void off()
{
if (!active)
return;
active = false;
manager.log_force_debug--;
}
private:
LogManager &manager;
bool active = false;
};
ForceDebug force_debug(bool start_on = false)
{
return ForceDebug(*this, start_on);
}
void force_debug_on() { log_force_debug++; }
void force_debug_off() { if (log_force_debug > 0) log_force_debug--; }
void set_force_debug(bool enabled) { log_force_debug = enabled ? 1 : 0; }
void report_unexpected_error();
void report_warning_stats();
void add_experimental_ignore(std::string name) { log_experimentals_ignored.insert(name); }
void add_warn(std::string pattern) { log_warn_regexes.push_back(YS_REGEX_COMPILE(pattern)); }
void add_nowarn(std::string pattern) { log_nowarn_regexes.push_back(YS_REGEX_COMPILE(pattern)); }
void add_werror(std::string pattern) { log_werror_regexes.push_back(YS_REGEX_COMPILE(pattern)); }
void add_expect(std::string type, std::string pattern, int count);
void set_verbose_level(int level) { log_verbose_level = level; }
void add_verbose_level(int level) { log_verbose_level += level; }
void set_expect_no_warnings(bool value) { log_expect_no_warnings = value; }
void set_log_time(bool value) { log_time = value; }
void set_error_stderr(bool value) { log_error_stderr = value; }
void set_cmd_error_throw(bool value) { log_cmd_error_throw = value; }
void set_quiet_warnings(bool value) { log_quiet_warnings = value; }
void set_stderr_force(bool value) { log_stderr_force = value; }
void set_hdump_all(bool value) { log_hdump_all = value; }
int get_verbose_level() const { return log_verbose_level; }
bool get_log_time() const { return log_time; }
bool get_error_stderr() const { return log_error_stderr; }
bool get_quiet_warnings() const { return log_quiet_warnings; }
bool get_stderr_force() const { return log_stderr_force; }
std::chrono::steady_clock::time_point get_initial_time() const { return initial_time; }
void add_hdump(std::string name, std::string value) { log_hdump[name].insert(value); }
void log_formatted_string(std::string_view prefix, std::string_view format, std::string str, LogSeverity severity);
void log_formatted_header(RTLIL::Design *design, std::string_view format, std::string str);
void log_formatted_warning(std::string_view prefix, std::string message);
void log_formatted_file_warning(std::string_view filename, int lineno, std::string str);
void log_formatted_file_info(std::string_view filename, int lineno, std::string str);
void log_suppressed();
[[noreturn]] void log_formatted_file_error(std::string_view filename, int lineno, std::string str);
void log_experimental(const std::string &str);
[[noreturn]] void log_formatted_error(std::string str);
[[noreturn]] void log_formatted_cmd_error(std::string message);
void log_spacer();
void log_push();
void log_pop();
void log_reset_stack();
void check_expected();
bool expects_error() { return (log_expect_error.size() + log_expect_prefix_error.size())>0; }
#ifndef NDEBUG
bool is_debug(int n = 0) { if (log_force_debug) return true; log_debug_suppressed += n; return false; }
#else
bool is_debug(int = 0) { return false; }
#endif
void start_hasher();
std::string finish_hasher();
private:
void logv_string(std::string_view prefix, std::string_view format, std::string str_in, LogSeverity severity);
[[noreturn]] void log_error_with_prefix(std::string_view prefix, std::string message);
std::chrono::steady_clock::time_point initial_time = std::chrono::steady_clock::now();
std::vector<std::unique_ptr<LogSink>> log_sinks;
int log_verbose_level = 0;
int log_newline_count = 0;
vector<int> header_count;
int log_warnings_count = 0;
int log_warnings_count_noexpect = 0;
std::set<std::string> log_warnings, log_experimentals, log_experimentals_ignored;
std::vector<std::regex> log_warn_regexes, log_nowarn_regexes, log_werror_regexes;
dict<std::string, LogExpectedItem> log_expect_log, log_expect_warning, log_expect_error;
dict<std::string, LogExpectedItem> log_expect_prefix_log, log_expect_prefix_warning, log_expect_prefix_error;
bool log_expect_no_warnings = false;
bool log_time = false;
bool log_error_stderr = false;
bool log_cmd_error_throw = false;
bool log_quiet_warnings = false;
bool log_stderr_force = false;
std::map<std::string, std::set<std::string>> log_hdump;
bool log_hdump_all = false;
int log_debug_suppressed = 0;
int log_make_debug = 0;
int log_force_debug = 0;
std::unique_ptr<SHA1> log_hasher;
};
LogManager &logger();
extern bool log_time;
extern bool log_error_stderr;
extern bool log_cmd_error_throw;
extern bool log_quiet_warnings;
extern int log_verbose_level;
extern void (*log_error_atexit)(); extern void (*log_error_atexit)();
extern int log_make_debug;
extern int log_force_debug;
extern int log_debug_suppressed;
void set_verific_logging(void (*cb)(int msg_type, const char *message_id, const char* file_path, unsigned int left_line, unsigned int left_col, unsigned int right_line, unsigned int right_col, const char *msg)); void set_verific_logging(void (*cb)(int msg_type, const char *message_id, const char* file_path, unsigned int left_line, unsigned int left_col, unsigned int right_line, unsigned int right_col, const char *msg));
extern void (*log_verific_callback)(int msg_type, const char *message_id, const char* file_path, unsigned int left_line, unsigned int left_col, unsigned int right_line, unsigned int right_col, const char *msg); extern void (*log_verific_callback)(int msg_type, const char *message_id, const char* file_path, unsigned int left_line, unsigned int left_col, unsigned int right_line, unsigned int right_col, const char *msg);
#ifndef NDEBUG #ifndef NDEBUG
static inline bool ys_debug(int n = 0) { if (log_force_debug) return true; log_debug_suppressed += n; return false; } static inline bool ys_debug(int n = 0) { return logger().is_debug(n); }
#else #else
static inline bool ys_debug(int = 0) { return false; } static inline bool ys_debug(int = 0) { return false; }
#endif #endif
void log_formatted_string(std::string_view prefix, std::string_view format, std::string str, LogSeverity severity);
template <typename... Args> template <typename... Args>
inline void log(FmtString<TypeIdentity<Args>...> fmt, const Args &... args) inline void log(FmtString<TypeIdentity<Args>...> fmt, const Args &... args)
{ {
log_formatted_string({}, fmt.format_string(), fmt.format(args...), LogSeverity::LOG_INFO); logger().log_formatted_string({}, fmt.format_string(), fmt.format(args...), LogSeverity::LOG_INFO);
} }
template <typename... Args> template <typename... Args>
inline void log_comment(FmtString<TypeIdentity<Args>...> fmt, const Args &... args) inline void log_comment(FmtString<TypeIdentity<Args>...> fmt, const Args &... args)
{ {
log_formatted_string({}, fmt.format_string(), fmt.format(args...), LogSeverity::LOG_COMMENT); logger().log_formatted_string({}, fmt.format_string(), fmt.format(args...), LogSeverity::LOG_COMMENT);
} }
template <typename... Args> template <typename... Args>
inline void log_debug(FmtString<TypeIdentity<Args>...> fmt, const Args &... args) inline void log_debug(FmtString<TypeIdentity<Args>...> fmt, const Args &... args)
{ {
if (!ys_debug(1)) if (!ys_debug(1))
return; return;
log_formatted_string({}, fmt.format_string(), fmt.format(args...), LogSeverity::LOG_DEBUG); logger().log_formatted_string({}, fmt.format_string(), fmt.format(args...), LogSeverity::LOG_DEBUG);
} }
void log_formatted_header(RTLIL::Design *design, std::string_view format, std::string str);
template <typename... Args> template <typename... Args>
inline void log_header(RTLIL::Design *design, FmtString<TypeIdentity<Args>...> fmt, const Args &... args) inline void log_header(RTLIL::Design *design, FmtString<TypeIdentity<Args>...> fmt, const Args &... args)
{ {
log_formatted_header(design, fmt.format_string(), fmt.format(args...)); logger().log_formatted_header(design, fmt.format_string(), fmt.format(args...));
} }
void log_formatted_warning(std::string_view prefix, std::string str);
template <typename... Args> template <typename... Args>
inline void log_warning(FmtString<TypeIdentity<Args>...> fmt, const Args &... args) inline void log_warning(FmtString<TypeIdentity<Args>...> fmt, const Args &... args)
{ {
log_formatted_warning("Warning: ", fmt.format(args...)); logger().log_formatted_warning("Warning: ", fmt.format(args...));
} }
inline void log_formatted_warning_noprefix(std::string str)
{
log_formatted_warning({}, str);
}
template <typename... Args> template <typename... Args>
inline void log_warning_noprefix(FmtString<TypeIdentity<Args>...> fmt, const Args &... args) inline void log_warning_noprefix(FmtString<TypeIdentity<Args>...> fmt, const Args &... args)
{ {
log_formatted_warning({}, fmt.format(args...)); logger().log_formatted_warning({}, fmt.format(args...));
} }
void log_experimental(const std::string &str); inline void log_experimental(const std::string &str)
{
logger().log_experimental(str);
}
// Log with filename to report a problem in a source file. // Log with filename to report a problem in a source file.
void log_formatted_file_warning(std::string_view filename, int lineno, std::string str);
template <typename... Args> template <typename... Args>
void log_file_warning(std::string_view filename, int lineno, FmtString<TypeIdentity<Args>...> fmt, const Args &... args) void log_file_warning(std::string_view filename, int lineno, FmtString<TypeIdentity<Args>...> fmt, const Args &... args)
{ {
log_formatted_file_warning(filename, lineno, fmt.format(args...)); logger().log_formatted_file_warning(filename, lineno, fmt.format(args...));
} }
void log_formatted_file_info(std::string_view filename, int lineno, std::string str);
template <typename... Args> template <typename... Args>
void log_file_info(std::string_view filename, int lineno, FmtString<TypeIdentity<Args>...> fmt, const Args &... args) void log_file_info(std::string_view filename, int lineno, FmtString<TypeIdentity<Args>...> fmt, const Args &... args)
{ {
log_formatted_file_info(filename, lineno, fmt.format(args...)); logger().log_formatted_file_info(filename, lineno, fmt.format(args...));
} }
[[noreturn]] void log_formatted_error(std::string str);
template <typename... Args> template <typename... Args>
[[noreturn]] void log_error(FmtString<TypeIdentity<Args>...> fmt, const Args &... args) [[noreturn]] void log_error(FmtString<TypeIdentity<Args>...> fmt, const Args &... args)
{ {
log_formatted_error(fmt.format(args...)); logger().log_formatted_error(fmt.format(args...));
} }
[[noreturn]] void log_formatted_file_error(std::string_view filename, int lineno, std::string str);
template <typename... Args> template <typename... Args>
[[noreturn]] void log_file_error(std::string_view filename, int lineno, FmtString<TypeIdentity<Args>...> fmt, const Args &... args) [[noreturn]] void log_file_error(std::string_view filename, int lineno, FmtString<TypeIdentity<Args>...> fmt, const Args &... args)
{ {
log_formatted_file_error(filename, lineno, fmt.format(args...)); logger().log_formatted_file_error(filename, lineno, fmt.format(args...));
} }
[[noreturn]] void log_formatted_cmd_error(std::string str);
template <typename... Args> template <typename... Args>
[[noreturn]] void log_cmd_error(FmtString<TypeIdentity<Args>...> fmt, const Args &... args) [[noreturn]] void log_cmd_error(FmtString<TypeIdentity<Args>...> fmt, const Args &... args)
{ {
log_formatted_cmd_error(fmt.format(args...)); logger().log_formatted_cmd_error(fmt.format(args...));
} }
void log_suppressed(); inline void log_suppressed()
{
logger().log_suppressed();
}
struct LogMakeDebugHdl { inline void log_spacer() { logger().log_spacer(); }
bool status = false; inline void log_push() { logger().log_push(); }
LogMakeDebugHdl(bool start_on = false) { inline void log_pop() { logger().log_pop(); }
if (start_on)
on();
}
~LogMakeDebugHdl() {
off();
}
void on() {
if (status) return;
status=true;
log_make_debug++;
}
void off_silent() {
if (!status) return;
status=false;
log_make_debug--;
}
void off() {
off_silent();
}
};
void log_spacer(); inline void log_reset_stack() { logger().log_reset_stack(); }
void log_push(); inline void log_flush() { logger().flush(); }
void log_pop();
void log_backtrace(const char *prefix, int levels); void log_backtrace(const char *prefix, int levels);
void log_reset_stack();
void log_flush();
struct LogExpectedItem
{
LogExpectedItem(const std::regex &pat, int expected) :
pattern(pat), expected_count(expected), current_count(0) {}
LogExpectedItem() : expected_count(0), current_count(0) {}
std::regex pattern;
int expected_count;
int current_count;
};
extern dict<std::string, LogExpectedItem> log_expect_log, log_expect_warning, log_expect_error;
extern dict<std::string, LogExpectedItem> log_expect_prefix_log, log_expect_prefix_warning, log_expect_prefix_error;
void log_check_expected();
std::string log_signal(const RTLIL::SigSpec &sig, bool autoint = true); std::string log_signal(const RTLIL::SigSpec &sig, bool autoint = true);
std::string log_const(const RTLIL::Const &value, bool autoint = true); std::string log_const(const RTLIL::Const &value, bool autoint = true);

8
kernel/log_compat.cc
View File

@ -37,7 +37,7 @@ void log_cmd_error(const char *format, ...)
va_start(ap, format); va_start(ap, format);
std::string formatted = vstringf(format, ap); std::string formatted = vstringf(format, ap);
va_end(ap); va_end(ap);
log_formatted_cmd_error(formatted); logger().log_formatted_cmd_error(formatted);
} }
void log_warning(const char *format, ...) void log_warning(const char *format, ...)
@ -46,7 +46,7 @@ void log_warning(const char *format, ...)
va_start(ap, format); va_start(ap, format);
std::string formatted = vstringf(format, ap); std::string formatted = vstringf(format, ap);
va_end(ap); va_end(ap);
log_formatted_warning("Warning: ", formatted); logger().log_formatted_warning("Warning: ", formatted);
} }
void log_warning_noprefix(const char *format, ...) void log_warning_noprefix(const char *format, ...)
@ -55,7 +55,7 @@ void log_warning_noprefix(const char *format, ...)
va_start(ap, format); va_start(ap, format);
std::string formatted = vstringf(format, ap); std::string formatted = vstringf(format, ap);
va_end(ap); va_end(ap);
log_formatted_warning("", formatted); logger().log_formatted_warning("", formatted);
} }
void log_error(const char *format, ...) void log_error(const char *format, ...)
@ -64,7 +64,7 @@ void log_error(const char *format, ...)
va_start(ap, format); va_start(ap, format);
std::string formatted = vstringf(format, ap); std::string formatted = vstringf(format, ap);
va_end(ap); va_end(ap);
log_formatted_error(formatted); logger().log_formatted_error(formatted);
} }
static inline void log_formatted(std::string const &str) static inline void log_formatted(std::string const &str)

18
kernel/register.cc
View File

@ -753,16 +753,6 @@ static struct CellHelpMessages {
SimHelper get(string name) { return cell_help[get_cell_name(name)]; } SimHelper get(string name) { return cell_help[get_cell_name(name)]; }
} cell_help_messages; } cell_help_messages;
class HelpMsgLogSink : public LogSink
{
public:
explicit HelpMsgLogSink(std::ostream *buf) : buf(buf) {}
void log(const LogMessage &msg) override { *buf << msg.message; }
void flush() override { buf->flush(); }
private:
std::ostream *buf;
};
struct HelpPass : public Pass { struct HelpPass : public Pass {
HelpPass() : Pass("help", "display help messages") { } HelpPass() : Pass("help", "display help messages") { }
void help() override void help() override
@ -815,9 +805,11 @@ struct HelpPass : public Pass {
// dump command help // dump command help
std::ostringstream buf; std::ostringstream buf;
log_sinks.push_back(std::make_unique<HelpMsgLogSink>(&buf)); {
pass->help(); auto log_scope = logger().scoped();
log_sinks.pop_back(); logger().add_sink<StreamLogSink>(buf);
pass->help();
}
std::stringstream ss; std::stringstream ss;
ss << buf.str(); ss << buf.str();

4
kernel/satgen.cc
View File

@ -1400,9 +1400,9 @@ void report_missing_model(bool warn_only, RTLIL::Cell* cell)
s = stringf("No SAT model available for cell %s (%s).\n", cell, cell->type.unescape()); s = stringf("No SAT model available for cell %s (%s).\n", cell, cell->type.unescape());
if (warn_only) { if (warn_only) {
log_formatted_warning_noprefix(s); log_warning_noprefix("%s", s);
} else { } else {
log_formatted_error(s); log_error("%s", s);
} }
} }

7
kernel/tclapi.cc
View File

@ -100,10 +100,7 @@ static int tcl_yosys_cmd(ClientData, Tcl_Interp *interp, int argc, const char *a
yosys_get_design()->scratchpad_unset("result.string"); yosys_get_design()->scratchpad_unset("result.string");
bool in_repl = yosys_tcl_repl_active; bool in_repl = yosys_tcl_repl_active;
bool restore_log_cmd_error_throw = log_cmd_error_throw; auto guard = logger().scoped_cmd_error_throw();
log_cmd_error_throw = true;
try { try {
if (args.size() == 1) { if (args.size() == 1) {
Pass::call(yosys_get_design(), args[0]); Pass::call(yosys_get_design(), args[0]);
@ -120,14 +117,12 @@ static int tcl_yosys_cmd(ClientData, Tcl_Interp *interp, int argc, const char *a
Tcl_SetResult(interp, (char *)"Yosys command produced an error", TCL_STATIC); Tcl_SetResult(interp, (char *)"Yosys command produced an error", TCL_STATIC);
yosys_tcl_repl_active = in_repl; yosys_tcl_repl_active = in_repl;
log_cmd_error_throw = restore_log_cmd_error_throw;
return TCL_ERROR; return TCL_ERROR;
} catch (...) { } catch (...) {
log_error("uncaught exception during Yosys command invoked from TCL\n"); log_error("uncaught exception during Yosys command invoked from TCL\n");
} }
yosys_tcl_repl_active = in_repl; yosys_tcl_repl_active = in_repl;
log_cmd_error_throw = restore_log_cmd_error_throw;
auto &scratchpad = yosys_get_design()->scratchpad; auto &scratchpad = yosys_get_design()->scratchpad;
auto result = scratchpad.find("result.json"); auto result = scratchpad.find("result.json");

5
kernel/yosys.cc
View File

@ -286,7 +286,7 @@ void yosys_shutdown()
yosys_design = NULL; yosys_design = NULL;
RTLIL::OwningIdString::collect_garbage(); RTLIL::OwningIdString::collect_garbage();
log_sinks.clear(); logger().clear();
#ifdef YOSYS_ENABLE_TCL #ifdef YOSYS_ENABLE_TCL
if (yosys_tcl_interp != NULL) { if (yosys_tcl_interp != NULL) {
@ -995,7 +995,7 @@ void shell(RTLIL::Design *design)
static int recursion_counter = 0; static int recursion_counter = 0;
recursion_counter++; recursion_counter++;
log_cmd_error_throw = true; auto guard = logger().scoped_cmd_error_throw();
#if defined(YOSYS_ENABLE_READLINE) || defined(YOSYS_ENABLE_EDITLINE) #if defined(YOSYS_ENABLE_READLINE) || defined(YOSYS_ENABLE_EDITLINE)
rl_readline_name = (char*)"yosys"; rl_readline_name = (char*)"yosys";
@ -1055,7 +1055,6 @@ void shell(RTLIL::Design *design)
free(command); free(command);
#endif #endif
recursion_counter--; recursion_counter--;
log_cmd_error_throw = false;
} }
struct ShellPass : public Pass { struct ShellPass : public Pass {

40
passes/cmds/logger.cc
View File

@ -85,22 +85,22 @@ struct LoggerPass : public Pass {
{ {
if (args[argidx] == "-time") { if (args[argidx] == "-time") {
log_time = true; logger().set_log_time(true);
log("Enabled timestamp in logs.\n"); log("Enabled timestamp in logs.\n");
continue; continue;
} }
if (args[argidx] == "-notime") { if (args[argidx] == "-notime") {
log_time = false; logger().set_log_time(false);
log("Disabled timestamp in logs.\n"); log("Disabled timestamp in logs.\n");
continue; continue;
} }
if (args[argidx] == "-stderr") { if (args[argidx] == "-stderr") {
log_error_stderr = true; logger().set_error_stderr(true);
log("Enabled loggint errors to stderr.\n"); log("Enabled loggint errors to stderr.\n");
continue; continue;
} }
if (args[argidx] == "-nostderr") { if (args[argidx] == "-nostderr") {
log_error_stderr = false; logger().set_error_stderr(false);
log("Disabled loggint errors to stderr.\n"); log("Disabled loggint errors to stderr.\n");
continue; continue;
} }
@ -109,7 +109,7 @@ struct LoggerPass : public Pass {
if (pattern.front() == '\"' && pattern.back() == '\"') pattern = pattern.substr(1, pattern.size() - 2); if (pattern.front() == '\"' && pattern.back() == '\"') pattern = pattern.substr(1, pattern.size() - 2);
try { try {
log("Added regex '%s' for warnings to warn list.\n", pattern); log("Added regex '%s' for warnings to warn list.\n", pattern);
log_warn_regexes.push_back(YS_REGEX_COMPILE(pattern)); logger().add_warn(pattern);
} }
catch (const std::regex_error& e) { catch (const std::regex_error& e) {
log_cmd_error("Error in regex expression '%s' !\n", pattern); log_cmd_error("Error in regex expression '%s' !\n", pattern);
@ -121,7 +121,7 @@ struct LoggerPass : public Pass {
if (pattern.front() == '\"' && pattern.back() == '\"') pattern = pattern.substr(1, pattern.size() - 2); if (pattern.front() == '\"' && pattern.back() == '\"') pattern = pattern.substr(1, pattern.size() - 2);
try { try {
log("Added regex '%s' for warnings to nowarn list.\n", pattern); log("Added regex '%s' for warnings to nowarn list.\n", pattern);
log_nowarn_regexes.push_back(YS_REGEX_COMPILE(pattern)); logger().add_nowarn(pattern);
} }
catch (const std::regex_error& e) { catch (const std::regex_error& e) {
log_cmd_error("Error in regex expression '%s' !\n", pattern); log_cmd_error("Error in regex expression '%s' !\n", pattern);
@ -133,7 +133,7 @@ struct LoggerPass : public Pass {
if (pattern.front() == '\"' && pattern.back() == '\"') pattern = pattern.substr(1, pattern.size() - 2); if (pattern.front() == '\"' && pattern.back() == '\"') pattern = pattern.substr(1, pattern.size() - 2);
try { try {
log("Added regex '%s' for warnings to werror list.\n", pattern); log("Added regex '%s' for warnings to werror list.\n", pattern);
log_werror_regexes.push_back(YS_REGEX_COMPILE(pattern)); logger().add_werror(pattern);
} }
catch (const std::regex_error& e) { catch (const std::regex_error& e) {
log_cmd_error("Error in regex expression '%s' !\n", pattern); log_cmd_error("Error in regex expression '%s' !\n", pattern);
@ -141,19 +141,19 @@ struct LoggerPass : public Pass {
continue; continue;
} }
if (args[argidx] == "-debug") { if (args[argidx] == "-debug") {
log_force_debug = 1; logger().set_force_debug(true);
log("Enabled debug log messages.\n"); log("Enabled debug log messages.\n");
continue; continue;
} }
if (args[argidx] == "-nodebug") { if (args[argidx] == "-nodebug") {
log_force_debug = 0; logger().set_force_debug(false);
log("Disabled debug log messages.\n"); log("Disabled debug log messages.\n");
continue; continue;
} }
if (args[argidx] == "-experimental" && argidx+1 < args.size()) { if (args[argidx] == "-experimental" && argidx+1 < args.size()) {
std::string value = args[++argidx]; std::string value = args[++argidx];
log("Added '%s' experimental ignore list.\n", value); log("Added '%s' experimental ignore list.\n", value);
log_experimentals_ignored.insert(value); logger().add_experimental_ignore(value);
continue; continue;
} }
if (args[argidx] == "-expect" && argidx+3 < args.size()) { if (args[argidx] == "-expect" && argidx+3 < args.size()) {
@ -161,7 +161,7 @@ struct LoggerPass : public Pass {
if (type!="error" && type!="warning" && type!="log" if (type!="error" && type!="warning" && type!="log"
&& type!="prefix-error" && type!="prefix-warning" && type!="prefix-log") && type!="prefix-error" && type!="prefix-warning" && type!="prefix-log")
log_cmd_error("Expect command require type to be 'log', 'warning' or 'error' !\n"); log_cmd_error("Expect command require type to be 'log', 'warning' or 'error' !\n");
if ((type=="error" || type=="prefix-error") && log_expect_error.size()>0) if ((type=="error" || type=="prefix-error") && logger().expects_error())
log_cmd_error("Only single error message can be expected !\n"); log_cmd_error("Only single error message can be expected !\n");
std::string pattern = args[++argidx]; std::string pattern = args[++argidx];
if (pattern.front() == '\"' && pattern.back() == '\"') pattern = pattern.substr(1, pattern.size() - 2); if (pattern.front() == '\"' && pattern.back() == '\"') pattern = pattern.substr(1, pattern.size() - 2);
@ -173,19 +173,7 @@ struct LoggerPass : public Pass {
log("Added regex '%s' to expected %s messages list.\n", log("Added regex '%s' to expected %s messages list.\n",
pattern.c_str(), type.c_str()); pattern.c_str(), type.c_str());
try { try {
if (type == "error") logger().add_expect(type, pattern, count);
log_expect_error[pattern] = LogExpectedItem(YS_REGEX_COMPILE(pattern), count);
else if (type == "prefix-error")
log_expect_prefix_error[pattern] = LogExpectedItem(YS_REGEX_COMPILE(pattern), count);
else if (type == "warning")
log_expect_warning[pattern] = LogExpectedItem(YS_REGEX_COMPILE(pattern), count);
else if (type == "prefix-warning")
log_expect_prefix_warning[pattern] = LogExpectedItem(YS_REGEX_COMPILE(pattern), count);
else if (type == "log")
log_expect_log[pattern] = LogExpectedItem(YS_REGEX_COMPILE(pattern), count);
else if (type == "prefix-log")
log_expect_prefix_log[pattern] = LogExpectedItem(YS_REGEX_COMPILE(pattern), count);
else log_abort();
} }
catch (const std::regex_error& e) { catch (const std::regex_error& e) {
log_cmd_error("Error in regex expression '%s' !\n", pattern); log_cmd_error("Error in regex expression '%s' !\n", pattern);
@ -193,11 +181,11 @@ struct LoggerPass : public Pass {
continue; continue;
} }
if (args[argidx] == "-expect-no-warnings") { if (args[argidx] == "-expect-no-warnings") {
log_expect_no_warnings = true; logger().set_expect_no_warnings(true);
continue; continue;
} }
if (args[argidx] == "-check-expected") { if (args[argidx] == "-check-expected") {
log_check_expected(); logger().check_expected();
continue; continue;
} }
break; break;

28
passes/cmds/tee.cc
View File

@ -58,17 +58,13 @@ struct TeePass : public Pass {
} }
void execute(std::vector<std::string> args, RTLIL::Design *design) override void execute(std::vector<std::string> args, RTLIL::Design *design) override
{ {
int backup_log_verbose_level = log_verbose_level; auto log_scope = logger().scoped();
auto backup_log_sinks = std::move(log_sinks);
log_sinks.reserve(backup_log_sinks.size());
for (const auto &sink : backup_log_sinks)
log_sinks.push_back(std::make_unique<LogSinkRef>(sink.get()));
size_t argidx; size_t argidx;
for (argidx = 1; argidx < args.size(); argidx++) for (argidx = 1; argidx < args.size(); argidx++)
{ {
if (args[argidx] == "-q") { if (args[argidx] == "-q") {
log_sinks.clear(); logger().clear();
continue; continue;
} }
if ((args[argidx] == "-o" || args[argidx] == "-a") && argidx+1 < args.size()) { if ((args[argidx] == "-o" || args[argidx] == "-a") && argidx+1 < args.size()) {
@ -76,7 +72,7 @@ struct TeePass : public Pass {
auto path = args[++argidx]; auto path = args[++argidx];
rewrite_filename(path); rewrite_filename(path);
try { try {
log_sinks.push_back(std::make_unique<FileLogSink>(path.c_str(), false, is_append)); logger().add_sink<FileLogSink>(path.c_str(), false, is_append);
} catch (const std::runtime_error &e) { } catch (const std::runtime_error &e) {
std::cerr << e.what(); std::cerr << e.what();
exit(1); exit(1);
@ -86,28 +82,18 @@ struct TeePass : public Pass {
if (args[argidx] == "-s" && argidx+1 < args.size()) { if (args[argidx] == "-s" && argidx+1 < args.size()) {
auto name = args[++argidx]; auto name = args[++argidx];
design->scratchpad[name] = ""; design->scratchpad[name] = "";
log_sinks.push_back(std::make_unique<ScratchPadLogSink>(name)); logger().add_sink<ScratchPadLogSink>(name);
continue; continue;
} }
if (GetSize(args[argidx]) >= 2 && (args[argidx][0] == '-' || args[argidx][0] == '+') && args[argidx][1] >= '0' && args[argidx][1] <= '9') { if (GetSize(args[argidx]) >= 2 && (args[argidx][0] == '-' || args[argidx][0] == '+') && args[argidx][1] >= '0' && args[argidx][1] <= '9') {
log_verbose_level += atoi(args[argidx].c_str()); logger().add_verbose_level(atoi(args[argidx].c_str()));
continue; continue;
} }
break; break;
} }
try { std::vector<std::string> new_args(args.begin() + argidx, args.end());
std::vector<std::string> new_args(args.begin() + argidx, args.end()); Pass::call(design, new_args);
Pass::call(design, new_args);
} catch (...) {
log_sinks.clear();
log_sinks = std::move(backup_log_sinks);
throw;
}
log_verbose_level = backup_log_verbose_level;
log_sinks.clear();
log_sinks = std::move(backup_log_sinks);
} }
} TeePass; } TeePass;

18
passes/cmds/trace.cc
View File

@ -144,27 +144,19 @@ struct DebugPass : public Pass {
log_cmd_error("Cannot specify both -on and -off\n"); log_cmd_error("Cannot specify both -on and -off\n");
if (mode_on) { if (mode_on) {
log_force_debug++; logger().force_debug_on();
return; return;
} }
if (mode_off) { if (mode_off) {
if (log_force_debug > 0) logger().force_debug_off();
log_force_debug--;
return; return;
} }
log_force_debug++; auto force_debug = logger().force_debug(true);
try { std::vector<std::string> new_args(args.begin() + argidx, args.end());
std::vector<std::string> new_args(args.begin() + argidx, args.end()); Pass::call(design, new_args);
Pass::call(design, new_args);
} catch (...) {
log_force_debug--;
throw;
}
log_force_debug--;
} }
} DebugPass; } DebugPass;

2
passes/techmap/libparse.cc
View File

@ -39,7 +39,7 @@ void warn(std::string str) {
#else #else
#include "kernel/log.h" #include "kernel/log.h"
void warn(std::string str) { void warn(std::string str) {
Yosys::log_formatted_warning("", str); Yosys::log_warning_noprefix("%s", str);
} }
#endif #endif

2
passes/techmap/techmap.cc
View File

@ -419,7 +419,7 @@ struct TechmapWorker
bool log_continue = false; bool log_continue = false;
bool did_something = false; bool did_something = false;
LogMakeDebugHdl mkdebug; auto mkdebug = logger().make_debug();
SigMap sigmap(module); SigMap sigmap(module);
FfInitVals initvals(&sigmap, module); FfInitVals initvals(&sigmap, module);

10
pyosys/generator.py
View File

@ -119,21 +119,15 @@ global_denylist = frozenset(
{ {
# deprecated # deprecated
"builtin_ff_cell_types", "builtin_ff_cell_types",
"logv_file_error",
# no implementation # no implementation
"set_verific_logging", "set_verific_logging",
# can't bridge to python cleanly
## std::regex
"log_warn_regexes",
"log_nowarn_regexes",
"log_werror_regexes",
## function pointers ## function pointers
"log_error_atexit", "log_error_atexit",
"log_verific_callback", "log_verific_callback",
# incomplete type # incomplete type
"yosys_get_tcl_interp", "yosys_get_tcl_interp",
# unique ptr vector # manually added later
"log_sinks", "logger",
} }
) )
pyosys_headers = [ pyosys_headers = [

27
pyosys/wrappers_tpl.cc
View File

@ -168,8 +168,8 @@ namespace pyosys {
m.doc() = "python access to libyosys"; m.doc() = "python access to libyosys";
if (!yosys_already_setup()) { if (!yosys_already_setup()) {
log_sinks.push_back(std::make_unique<ConsoleLogSink>()); logger().add_sink<ConsoleLogSink>();
log_error_stderr = true; logger().set_error_stderr(true);
yosys_setup(); yosys_setup();
// Cleanup // Cleanup
@ -179,17 +179,24 @@ namespace pyosys {
} }
// Logging Methods // Logging Methods
m.def("log_header", [](Design *d, std::string s) { log_formatted_header(d, "%s", s); }); m.def("log_header", [](Design *d, std::string s) { logger().log_formatted_header(d, "%s", s); });
m.def("log", [](std::string s) { log_formatted_string({}, "%s", s, LogSeverity::LOG_INFO); }); m.def("log", [](std::string s) { logger().log_formatted_string({}, "%s", s, LogSeverity::LOG_INFO); });
m.def("log_file_info", [](std::string_view file, int line, std::string s) { log_formatted_file_info(file, line, s); }); m.def("log_file_info", [](std::string_view file, int line, std::string s) { logger().log_formatted_file_info(file, line, s); });
m.def("log_warning", [](std::string s) { log_formatted_warning("Warning: ", s); }); m.def("log_warning", [](std::string s) { logger().log_formatted_warning("Warning: ", s); });
m.def("log_warning_noprefix", [](std::string s) { log_formatted_warning("", s); }); m.def("log_warning_noprefix", [](std::string s) { logger().log_formatted_warning("", s); });
m.def("log_file_warning", [](std::string_view file, int line, std::string s) { log_formatted_file_warning(file, line, s); }); m.def("log_file_warning", [](std::string_view file, int line, std::string s) { logger().log_formatted_file_warning(file, line, s); });
m.def("log_error", [](std::string s) { log_formatted_error(s); }); m.def("log_error", [](std::string s) { logger().log_formatted_error(s); });
m.def("log_file_error", [](std::string_view file, int line, std::string s) { log_formatted_file_error(file, line, s); }); m.def("log_file_error", [](std::string_view file, int line, std::string s) { logger().log_formatted_file_error(file, line, s); });
// Namespace to host global objects // Namespace to host global objects
auto global_variables = py::class_<Globals>(m, "Globals"); auto global_variables = py::class_<Globals>(m, "Globals");
global_variables.def_property_readonly_static(
"logger",
[](const pyosys::Globals &) -> Yosys::LogManager & {
return logger();
},
pybind11::return_value_policy::reference
);
// Trampoline Classes // Trampoline Classes
py::class_<Pass, pyosys::PassTrampoline, std::unique_ptr<Pass, py::nodelete>>(m, "Pass") py::class_<Pass, pyosys::PassTrampoline, std::unique_ptr<Pass, py::nodelete>>(m, "Pass")

2
tests/unit/kernel/cellTypesTest.cc
View File

@ -11,7 +11,7 @@ YOSYS_NAMESPACE_BEGIN
TEST(CellTypesTest, basic) TEST(CellTypesTest, basic)
{ {
yosys_setup(); yosys_setup();
if (log_sinks.empty()) log_sinks.push_back(std::make_unique<ConsoleLogSink>()); if (logger().empty()) logger().add_sink<ConsoleLogSink>();
CellTypes older; CellTypes older;
NewCellTypes newer; NewCellTypes newer;
older.setup(nullptr); older.setup(nullptr);

2
tests/unit/kernel/modindexTest.cc
View File

@ -28,7 +28,7 @@ TEST(ModIndexSwapTest, has)
TEST(ModIndexDeleteTest, has) TEST(ModIndexDeleteTest, has)
{ {
if (log_sinks.empty()) log_sinks.push_back(std::make_unique<ConsoleLogSink>()); if (logger().empty()) logger().add_sink<ConsoleLogSink>();
Design* d = new Design; Design* d = new Design;
Module* m = d->addModule("$m"); Module* m = d->addModule("$m");
Wire* w = m->addWire("$w"); Wire* w = m->addWire("$w");

2
tests/unit/kernel/rtlilTest.cc
View File

@ -19,7 +19,7 @@ namespace RTLIL {
class KernelRtlilTest : public testing::Test { class KernelRtlilTest : public testing::Test {
protected: protected:
KernelRtlilTest() { KernelRtlilTest() {
if (log_sinks.empty()) log_sinks.push_back(std::make_unique<ConsoleLogSink>()); if (logger().empty()) logger().add_sink<ConsoleLogSink>();
} }
virtual void SetUp() override { virtual void SetUp() override {
IdString::ensure_prepopulated(); IdString::ensure_prepopulated();

2
tests/unit/kernel/threadingTest.cc
View File

@ -7,7 +7,7 @@ YOSYS_NAMESPACE_BEGIN
class ThreadingTest : public testing::Test { class ThreadingTest : public testing::Test {
protected: protected:
ThreadingTest() { ThreadingTest() {
if (log_sinks.empty()) log_sinks.push_back(std::make_unique<ConsoleLogSink>()); if (logger().empty()) logger().add_sink<ConsoleLogSink>();
} }
}; };

2
tests/unit/techmap/libparseTest.cc
View File

@ -8,7 +8,7 @@ namespace RTLIL {
class TechmapLibparseTest : public testing::Test { class TechmapLibparseTest : public testing::Test {
protected: protected:
TechmapLibparseTest() { TechmapLibparseTest() {
if (log_sinks.empty()) log_sinks.push_back(std::make_unique<ConsoleLogSink>()); if (logger().empty()) logger().add_sink<ConsoleLogSink>();
} }
void checkAll(std::initializer_list<std::string> expressions, std::string expected) { void checkAll(std::initializer_list<std::string> expressions, std::string expected) {
for (const auto& e : expressions) { for (const auto& e : expressions) {