kernel/log.cc

   1 /*
   2  *  yosys -- Yosys Open SYnthesis Suite
   3  *
   4  *  Copyright (C) 2012  Claire Xenia Wolf <claire@yosyshq.com>
   5  *
   6  *  Permission to use, copy, modify, and/or distribute this software for any
   7  *  purpose with or without fee is hereby granted, provided that the above
   8  *  copyright notice and this permission notice appear in all copies.
   9  *
  10  *  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11  *  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  *  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  13  *  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  *  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15  *  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  16  *  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  *
  18  */
  19
  20 #include "kernel/yosys.h"
  21 #include "libs/sha1/sha1.h"
  22 #include "backends/rtlil/rtlil_backend.h"
  23
  24 #if !defined(_WIN32) || defined(__MINGW32__)
  25 #  include <sys/time.h>
  26 #endif
  27
  28 #if defined(__linux__) || defined(__FreeBSD__)
  29 #  include <dlfcn.h>
  30 #endif
  31
  32 #include <stdlib.h>
  33 #include <stdio.h>
  34 #include <string.h>
  35 #include <stdarg.h>
  36 #include <vector>
  37 #include <list>
  38
  39 YOSYS_NAMESPACE_BEGIN
  40
  41 std::vector<FILE*> log_files;
  42 std::vector<std::ostream*> log_streams;
  43 std::map<std::string, std::set<std::string>> log_hdump;
  44 std::vector<YS_REGEX_TYPE> log_warn_regexes, log_nowarn_regexes, log_werror_regexes;
  45 dict<std::string, LogExpectedItem> log_expect_log, log_expect_warning, log_expect_error;
  46 std::set<std::string> log_warnings, log_experimentals, log_experimentals_ignored;
  47 int log_warnings_count = 0;
  48 int log_warnings_count_noexpect = 0;
  49 bool log_expect_no_warnings = false;
  50 bool log_hdump_all = false;
  51 FILE *log_errfile = NULL;
  52 SHA1 *log_hasher = NULL;
  53
  54 bool log_time = false;
  55 bool log_error_stderr = false;
  56 bool log_cmd_error_throw = false;
  57 bool log_quiet_warnings = false;
  58 int log_verbose_level;
  59 string log_last_error;
  60 void (*log_error_atexit)() = NULL;
  61
  62 int log_make_debug = 0;
  63 int log_force_debug = 0;
  64 int log_debug_suppressed = 0;
  65
  66 vector<int> header_count;
  67 vector<char*> log_id_cache;
  68 vector<shared_str> string_buf;
  69 int string_buf_index = -1;
  70
  71 static struct timeval initial_tv = { 0, 0 };
  72 static bool next_print_log = false;
  73 static int log_newline_count = 0;
  74
  75 static void log_id_cache_clear()
  76 {
  77         for (auto p : log_id_cache)
  78                 free(p);
  79         log_id_cache.clear();
  80 }
  81
  82 #if defined(_WIN32) && !defined(__MINGW32__)
  83 // this will get time information and return it in timeval, simulating gettimeofday()
  84 int gettimeofday(struct timeval *tv, struct timezone *tz)
  85 {
  86         LARGE_INTEGER counter;
  87         LARGE_INTEGER freq;
  88
  89         QueryPerformanceFrequency(&freq);
  90         QueryPerformanceCounter(&counter);
  91
  92         counter.QuadPart *= 1000000;
  93         counter.QuadPart /= freq.QuadPart;
  94
  95         tv->tv_sec = long(counter.QuadPart / 1000000);
  96         tv->tv_usec = counter.QuadPart % 1000000;
  97
  98         return 0;
  99 }
 100 #endif
 101
 102 void logv(const char *format, va_list ap)
 103 {
 104         while (format[0] == '\n' && format[1] != 0) {
 105                 log("\n");
 106                 format++;
 107         }
 108
 109         if (log_make_debug && !ys_debug(1))
 110                 return;
 111
 112         std::string str = vstringf(format, ap);
 113
 114         if (str.empty())
 115                 return;
 116
 117         size_t nnl_pos = str.find_last_not_of('\n');
 118         if (nnl_pos == std::string::npos)
 119                 log_newline_count += GetSize(str);
 120         else
 121                 log_newline_count = GetSize(str) - nnl_pos - 1;
 122
 123         if (log_hasher)
 124                 log_hasher->update(str);
 125
 126         if (log_time)
 127         {
 128                 std::string time_str;
 129
 130                 if (next_print_log || initial_tv.tv_sec == 0) {
 131                         next_print_log = false;
 132                         struct timeval tv;
 133                         gettimeofday(&tv, NULL);
 134                         if (initial_tv.tv_sec == 0)
 135                                 initial_tv = tv;
 136                         if (tv.tv_usec < initial_tv.tv_usec) {
 137                                 tv.tv_sec--;
 138                                 tv.tv_usec += 1000000;
 139                         }
 140                         tv.tv_sec -= initial_tv.tv_sec;
 141                         tv.tv_usec -= initial_tv.tv_usec;
 142                         time_str += stringf("[%05d.%06d] ", int(tv.tv_sec), int(tv.tv_usec));
 143                 }
 144
 145                 if (format[0] && format[strlen(format)-1] == '\n')
 146                         next_print_log = true;
 147
 148                 for (auto f : log_files)
 149                         fputs(time_str.c_str(), f);
 150
 151                 for (auto f : log_streams)
 152                         *f << time_str;
 153         }
 154
 155         for (auto f : log_files)
 156                 fputs(str.c_str(), f);
 157
 158         for (auto f : log_streams)
 159                 *f << str;
 160
 161         static std::string linebuffer;
 162         static bool log_warn_regex_recusion_guard = false;
 163
 164         if (!log_warn_regex_recusion_guard)
 165         {
 166                 log_warn_regex_recusion_guard = true;
 167
 168                 if (log_warn_regexes.empty() && log_expect_log.empty())
 169                 {
 170                         linebuffer.clear();
 171                 }
 172                 else
 173                 {
 174                         linebuffer += str;
 175
 176                         if (!linebuffer.empty() && linebuffer.back() == '\n') {
 177                                 for (auto &re : log_warn_regexes)
 178                                         if (YS_REGEX_NS::regex_search(linebuffer, re))
 179                                                 log_warning("Found log message matching -W regex:\n%s", str.c_str());
 180
 181                                 for (auto &item : log_expect_log)
 182                                         if (YS_REGEX_NS::regex_search(linebuffer, item.second.pattern))
 183                                                 item.second.current_count++;
 184
 185                                 linebuffer.clear();
 186                         }
 187                 }
 188
 189                 log_warn_regex_recusion_guard = false;
 190         }
 191 }
 192
 193 void logv_header(RTLIL::Design *design, const char *format, va_list ap)
 194 {
 195         bool pop_errfile = false;
 196
 197         log_spacer();
 198         if (header_count.size() > 0)
 199                 header_count.back()++;
 200
 201         if (int(header_count.size()) <= log_verbose_level && log_errfile != NULL) {
 202                 log_files.push_back(log_errfile);
 203                 pop_errfile = true;
 204         }
 205
 206         std::string header_id;
 207
 208         for (int c : header_count)
 209                 header_id += stringf("%s%d", header_id.empty() ? "" : ".", c);
 210
 211         log("%s. ", header_id.c_str());
 212         logv(format, ap);
 213         log_flush();
 214
 215         if (log_hdump_all)
 216                 log_hdump[header_id].insert("yosys_dump_" + header_id + ".il");
 217
 218         if (log_hdump.count(header_id) && design != nullptr)
 219                 for (auto &filename : log_hdump.at(header_id)) {
 220                         log("Dumping current design to '%s'.\n", filename.c_str());
 221                         if (yosys_xtrace)
 222                                 IdString::xtrace_db_dump();
 223                         Pass::call(design, {"dump", "-o", filename});
 224                         if (yosys_xtrace)
 225                                 log("#X# -- end of dump --\n");
 226                 }
 227
 228         if (pop_errfile)
 229                 log_files.pop_back();
 230 }
 231
 232 static void logv_warning_with_prefix(const char *prefix,
 233                                      const char *format, va_list ap)
 234 {
 235         std::string message = vstringf(format, ap);
 236         bool suppressed = false;
 237
 238         for (auto &re : log_nowarn_regexes)
 239                 if (YS_REGEX_NS::regex_search(message, re))
 240                         suppressed = true;
 241
 242         if (suppressed)
 243         {
 244                 log("Suppressed %s%s", prefix, message.c_str());
 245         }
 246         else
 247         {
 248                 int bak_log_make_debug = log_make_debug;
 249                 log_make_debug = 0;
 250
 251                 for (auto &re : log_werror_regexes)
 252                         if (YS_REGEX_NS::regex_search(message, re))
 253                                 log_error("%s",  message.c_str());
 254
 255                 bool warning_match = false;
 256                 for (auto &item : log_expect_warning)
 257                         if (YS_REGEX_NS::regex_search(message, item.second.pattern)) {
 258                                 item.second.current_count++;
 259                                 warning_match = true;
 260                         }
 261
 262                 if (log_warnings.count(message))
 263                 {
 264                         log("%s%s", prefix, message.c_str());
 265                         log_flush();
 266                 }
 267                 else
 268                 {
 269                         if (log_errfile != NULL && !log_quiet_warnings)
 270                                 log_files.push_back(log_errfile);
 271
 272                         log("%s%s", prefix, message.c_str());
 273                         log_flush();
 274
 275                         if (log_errfile != NULL && !log_quiet_warnings)
 276                                 log_files.pop_back();
 277
 278                         log_warnings.insert(message);
 279                 }
 280
 281                 if (!warning_match)
 282                         log_warnings_count_noexpect++;
 283                 log_warnings_count++;
 284                 log_make_debug = bak_log_make_debug;
 285         }
 286 }
 287
 288 void logv_warning(const char *format, va_list ap)
 289 {
 290         logv_warning_with_prefix("Warning: ", format, ap);
 291 }
 292
 293 void logv_warning_noprefix(const char *format, va_list ap)
 294 {
 295         logv_warning_with_prefix("", format, ap);
 296 }
 297
 298 void log_file_warning(const std::string &filename, int lineno,
 299                       const char *format, ...)
 300 {
 301         va_list ap;
 302         va_start(ap, format);
 303         std::string prefix = stringf("%s:%d: Warning: ",
 304                         filename.c_str(), lineno);
 305         logv_warning_with_prefix(prefix.c_str(), format, ap);
 306         va_end(ap);
 307 }
 308
 309 void log_file_info(const std::string &filename, int lineno,
 310                       const char *format, ...)
 311 {
 312         va_list ap;
 313         va_start(ap, format);
 314         std::string fmt = stringf("%s:%d: Info: %s",
 315                         filename.c_str(), lineno, format);
 316         logv(fmt.c_str(), ap);
 317         va_end(ap);
 318 }
 319
 320 [[noreturn]]
 321 static void logv_error_with_prefix(const char *prefix,
 322                                    const char *format, va_list ap)
 323 {
 324 #ifdef EMSCRIPTEN
 325         auto backup_log_files = log_files;
 326 #endif
 327         int bak_log_make_debug = log_make_debug;
 328         log_make_debug = 0;
 329         log_suppressed();
 330
 331         if (log_errfile != NULL)
 332                 log_files.push_back(log_errfile);
 333
 334         if (log_error_stderr)
 335                 for (auto &f : log_files)
 336                         if (f == stdout)
 337                                 f = stderr;
 338
 339         log_last_error = vstringf(format, ap);
 340         log("%s%s", prefix, log_last_error.c_str());
 341         log_flush();
 342
 343         log_make_debug = bak_log_make_debug;
 344
 345         for (auto &item : log_expect_error)
 346                 if (YS_REGEX_NS::regex_search(log_last_error, item.second.pattern))
 347                         item.second.current_count++;
 348
 349         log_check_expected();
 350
 351         if (log_error_atexit)
 352                 log_error_atexit();
 353
 354         YS_DEBUGTRAP_IF_DEBUGGING;
 355
 356 #ifdef EMSCRIPTEN
 357         log_files = backup_log_files;
 358         throw 0;
 359 #elif defined(_MSC_VER)
 360         _exit(1);
 361 #else
 362         _Exit(1);
 363 #endif
 364 }
 365
 366 void logv_error(const char *format, va_list ap)
 367 {
 368         logv_error_with_prefix("ERROR: ", format, ap);
 369 }
 370
 371 void log_file_error(const string &filename, int lineno,
 372                     const char *format, ...)
 373 {
 374         va_list ap;
 375         va_start(ap, format);
 376         std::string prefix = stringf("%s:%d: ERROR: ",
 377                                      filename.c_str(), lineno);
 378         logv_error_with_prefix(prefix.c_str(), format, ap);
 379 }
 380
 381 void log(const char *format, ...)
 382 {
 383         va_list ap;
 384         va_start(ap, format);
 385         logv(format, ap);
 386         va_end(ap);
 387 }
 388
 389 void log_header(RTLIL::Design *design, const char *format, ...)
 390 {
 391         va_list ap;
 392         va_start(ap, format);
 393         logv_header(design, format, ap);
 394         va_end(ap);
 395 }
 396
 397 void log_warning(const char *format, ...)
 398 {
 399         va_list ap;
 400         va_start(ap, format);
 401         logv_warning(format, ap);
 402         va_end(ap);
 403 }
 404
 405 void log_experimental(const char *format, ...)
 406 {
 407         va_list ap;
 408         va_start(ap, format);
 409         string s = vstringf(format, ap);
 410         va_end(ap);
 411
 412         if (log_experimentals_ignored.count(s) == 0 && log_experimentals.count(s) == 0) {
 413                 log_warning("Feature '%s' is experimental.\n", s.c_str());
 414                 log_experimentals.insert(s);
 415         }
 416 }
 417
 418 void log_warning_noprefix(const char *format, ...)
 419 {
 420         va_list ap;
 421         va_start(ap, format);
 422         logv_warning_noprefix(format, ap);
 423         va_end(ap);
 424 }
 425
 426 void log_error(const char *format, ...)
 427 {
 428         va_list ap;
 429         va_start(ap, format);
 430         logv_error(format, ap);
 431 }
 432
 433 void log_cmd_error(const char *format, ...)
 434 {
 435         va_list ap;
 436         va_start(ap, format);
 437
 438         if (log_cmd_error_throw) {
 439                 log_last_error = vstringf(format, ap);
 440                 log("ERROR: %s", log_last_error.c_str());
 441                 log_flush();
 442                 throw log_cmd_error_exception();
 443         }
 444
 445         logv_error(format, ap);
 446 }
 447
 448 void log_spacer()
 449 {
 450         if (log_newline_count < 2) log("\n");
 451         if (log_newline_count < 2) log("\n");
 452 }
 453
 454 void log_push()
 455 {
 456         header_count.push_back(0);
 457 }
 458
 459 void log_pop()
 460 {
 461         header_count.pop_back();
 462         log_id_cache_clear();
 463         string_buf.clear();
 464         string_buf_index = -1;
 465         log_flush();
 466 }
 467
 468 #if (defined(__linux__) || defined(__FreeBSD__)) && defined(YOSYS_ENABLE_PLUGINS)
 469 void log_backtrace(const char *prefix, int levels)
 470 {
 471         if (levels <= 0) return;
 472
 473         Dl_info dli;
 474         void *p;
 475
 476         if ((p = __builtin_extract_return_addr(__builtin_return_address(0))) && dladdr(p, &dli)) {
 477                 log("%sframe #1: %p %s(%p) %s(%p)\n", prefix, p, dli.dli_fname, dli.dli_fbase, dli.dli_sname, dli.dli_saddr);
 478         } else {
 479                 log("%sframe #1: ---\n", prefix);
 480                 return;
 481         }
 482
 483         if (levels <= 1) return;
 484
 485 #ifndef DEBUG
 486         log("%sframe #2: [build Yosys with ENABLE_DEBUG for deeper backtraces]\n", prefix);
 487 #else
 488         if ((p = __builtin_extract_return_addr(__builtin_return_address(1))) && dladdr(p, &dli)) {
 489                 log("%sframe #2: %p %s(%p) %s(%p)\n", prefix, p, dli.dli_fname, dli.dli_fbase, dli.dli_sname, dli.dli_saddr);
 490         } else {
 491                 log("%sframe #2: ---\n", prefix);
 492                 return;
 493         }
 494
 495         if (levels <= 2) return;
 496
 497         if ((p = __builtin_extract_return_addr(__builtin_return_address(2))) && dladdr(p, &dli)) {
 498                 log("%sframe #3: %p %s(%p) %s(%p)\n", prefix, p, dli.dli_fname, dli.dli_fbase, dli.dli_sname, dli.dli_saddr);
 499         } else {
 500                 log("%sframe #3: ---\n", prefix);
 501                 return;
 502         }
 503
 504         if (levels <= 3) return;
 505
 506         if ((p = __builtin_extract_return_addr(__builtin_return_address(3))) && dladdr(p, &dli)) {
 507                 log("%sframe #4: %p %s(%p) %s(%p)\n", prefix, p, dli.dli_fname, dli.dli_fbase, dli.dli_sname, dli.dli_saddr);
 508         } else {
 509                 log("%sframe #4: ---\n", prefix);
 510                 return;
 511         }
 512
 513         if (levels <= 4) return;
 514
 515         if ((p = __builtin_extract_return_addr(__builtin_return_address(4))) && dladdr(p, &dli)) {
 516                 log("%sframe #5: %p %s(%p) %s(%p)\n", prefix, p, dli.dli_fname, dli.dli_fbase, dli.dli_sname, dli.dli_saddr);
 517         } else {
 518                 log("%sframe #5: ---\n", prefix);
 519                 return;
 520         }
 521
 522         if (levels <= 5) return;
 523
 524         if ((p = __builtin_extract_return_addr(__builtin_return_address(5))) && dladdr(p, &dli)) {
 525                 log("%sframe #6: %p %s(%p) %s(%p)\n", prefix, p, dli.dli_fname, dli.dli_fbase, dli.dli_sname, dli.dli_saddr);
 526         } else {
 527                 log("%sframe #6: ---\n", prefix);
 528                 return;
 529         }
 530
 531         if (levels <= 6) return;
 532
 533         if ((p = __builtin_extract_return_addr(__builtin_return_address(6))) && dladdr(p, &dli)) {
 534                 log("%sframe #7: %p %s(%p) %s(%p)\n", prefix, p, dli.dli_fname, dli.dli_fbase, dli.dli_sname, dli.dli_saddr);
 535         } else {
 536                 log("%sframe #7: ---\n", prefix);
 537                 return;
 538         }
 539
 540         if (levels <= 7) return;
 541
 542         if ((p = __builtin_extract_return_addr(__builtin_return_address(7))) && dladdr(p, &dli)) {
 543                 log("%sframe #8: %p %s(%p) %s(%p)\n", prefix, p, dli.dli_fname, dli.dli_fbase, dli.dli_sname, dli.dli_saddr);
 544         } else {
 545                 log("%sframe #8: ---\n", prefix);
 546                 return;
 547         }
 548
 549         if (levels <= 8) return;
 550
 551         if ((p = __builtin_extract_return_addr(__builtin_return_address(8))) && dladdr(p, &dli)) {
 552                 log("%sframe #9: %p %s(%p) %s(%p)\n", prefix, p, dli.dli_fname, dli.dli_fbase, dli.dli_sname, dli.dli_saddr);
 553         } else {
 554                 log("%sframe #9: ---\n", prefix);
 555                 return;
 556         }
 557
 558         if (levels <= 9) return;
 559 #endif
 560 }
 561 #else
 562 void log_backtrace(const char*, int) { }
 563 #endif
 564
 565 void log_reset_stack()
 566 {
 567         while (header_count.size() > 1)
 568                 header_count.pop_back();
 569         log_id_cache_clear();
 570         string_buf.clear();
 571         string_buf_index = -1;
 572         log_flush();
 573 }
 574
 575 void log_flush()
 576 {
 577         for (auto f : log_files)
 578                 fflush(f);
 579
 580         for (auto f : log_streams)
 581                 f->flush();
 582 }
 583
 584 void log_dump_val_worker(RTLIL::IdString v) {
 585         log("%s", log_id(v));
 586 }
 587
 588 void log_dump_val_worker(RTLIL::SigSpec v) {
 589         log("%s", log_signal(v));
 590 }
 591
 592 void log_dump_val_worker(RTLIL::State v) {
 593         log("%s", log_signal(v));
 594 }
 595
 596 const char *log_signal(const RTLIL::SigSpec &sig, bool autoint)
 597 {
 598         std::stringstream buf;
 599         RTLIL_BACKEND::dump_sigspec(buf, sig, autoint);
 600
 601         if (string_buf.size() < 100) {
 602                 string_buf.push_back(buf.str());
 603                 return string_buf.back().c_str();
 604         } else {
 605                 if (++string_buf_index == 100)
 606                         string_buf_index = 0;
 607                 string_buf[string_buf_index] = buf.str();
 608                 return string_buf[string_buf_index].c_str();
 609         }
 610 }
 611
 612 const char *log_const(const RTLIL::Const &value, bool autoint)
 613 {
 614         if ((value.flags & RTLIL::CONST_FLAG_STRING) == 0)
 615                 return log_signal(value, autoint);
 616
 617         std::string str = "\"" + value.decode_string() + "\"";
 618
 619         if (string_buf.size() < 100) {
 620                 string_buf.push_back(str);
 621                 return string_buf.back().c_str();
 622         } else {
 623                 if (++string_buf_index == 100)
 624                         string_buf_index = 0;
 625                 string_buf[string_buf_index] = str;
 626                 return string_buf[string_buf_index].c_str();
 627         }
 628 }
 629
 630 const char *log_id(RTLIL::IdString str)
 631 {
 632         log_id_cache.push_back(strdup(str.c_str()));
 633         const char *p = log_id_cache.back();
 634         if (p[0] != '\\')
 635                 return p;
 636         if (p[1] == '$' || p[1] == '\\' || p[1] == 0)
 637                 return p;
 638         if (p[1] >= '0' && p[1] <= '9')
 639                 return p;
 640         return p+1;
 641 }
 642
 643 void log_module(RTLIL::Module *module, std::string indent)
 644 {
 645         std::stringstream buf;
 646         RTLIL_BACKEND::dump_module(buf, indent, module, module->design, false);
 647         log("%s", buf.str().c_str());
 648 }
 649
 650 void log_cell(RTLIL::Cell *cell, std::string indent)
 651 {
 652         std::stringstream buf;
 653         RTLIL_BACKEND::dump_cell(buf, indent, cell);
 654         log("%s", buf.str().c_str());
 655 }
 656
 657 void log_wire(RTLIL::Wire *wire, std::string indent)
 658 {
 659         std::stringstream buf;
 660         RTLIL_BACKEND::dump_wire(buf, indent, wire);
 661         log("%s", buf.str().c_str());
 662 }
 663
 664 void log_check_expected()
 665 {
 666         // copy out all of the expected logs so that they cannot be re-checked
 667         // or match against themselves
 668         dict<std::string, LogExpectedItem> expect_log, expect_warning, expect_error;
 669         std::swap(expect_warning, log_expect_warning);
 670         std::swap(expect_log, log_expect_log);
 671         std::swap(expect_error, log_expect_error);
 672
 673         for (auto &item : expect_warning) {
 674                 if (item.second.current_count == 0) {
 675                         log_warn_regexes.clear();
 676                         log_error("Expected warning pattern '%s' not found !\n", item.first.c_str());
 677                 }
 678                 if (item.second.current_count != item.second.expected_count) {
 679                         log_warn_regexes.clear();
 680                         log_error("Expected warning pattern '%s' found %d time(s), instead of %d time(s) !\n",
 681                                 item.first.c_str(), item.second.current_count, item.second.expected_count);
 682                 }
 683         }
 684
 685         for (auto &item : expect_log) {
 686                 if (item.second.current_count == 0) {
 687                         log_warn_regexes.clear();
 688                         log_error("Expected log pattern '%s' not found !\n", item.first.c_str());
 689                 }
 690                 if (item.second.current_count != item.second.expected_count) {
 691                         log_warn_regexes.clear();
 692                         log_error("Expected log pattern '%s' found %d time(s), instead of %d time(s) !\n",
 693                                 item.first.c_str(), item.second.current_count, item.second.expected_count);
 694                 }
 695         }
 696
 697         for (auto &item : expect_error)
 698                 if (item.second.current_count == item.second.expected_count) {
 699                         log_warn_regexes.clear();
 700                         log("Expected error pattern '%s' found !!!\n", item.first.c_str());
 701                         #ifdef EMSCRIPTEN
 702                                 throw 0;
 703                         #elif defined(_MSC_VER)
 704                                 _exit(0);
 705                         #else
 706                                 _Exit(0);
 707                         #endif
 708                 } else {
 709                         log_warn_regexes.clear();
 710                         log_error("Expected error pattern '%s' not found !\n", item.first.c_str());
 711                 }
 712 }
 713
 714 // ---------------------------------------------------
 715 // This is the magic behind the code coverage counters
 716 // ---------------------------------------------------
 717 #if defined(YOSYS_ENABLE_COVER) && (defined(__linux__) || defined(__FreeBSD__))
 718
 719 dict<std::string, std::pair<std::string, int>> extra_coverage_data;
 720
 721 void cover_extra(std::string parent, std::string id, bool increment) {
 722         if (extra_coverage_data.count(id) == 0) {
 723                 for (CoverData *p = __start_yosys_cover_list; p != __stop_yosys_cover_list; p++)
 724                         if (p->id == parent)
 725                                 extra_coverage_data[id].first = stringf("%s:%d:%s", p->file, p->line, p->func);
 726                 log_assert(extra_coverage_data.count(id));
 727         }
 728         if (increment)
 729                 extra_coverage_data[id].second++;
 730 }
 731
 732 dict<std::string, std::pair<std::string, int>> get_coverage_data()
 733 {
 734         dict<std::string, std::pair<std::string, int>> coverage_data;
 735
 736         for (auto &it : pass_register) {
 737                 std::string key = stringf("passes.%s", it.first.c_str());
 738                 coverage_data[key].first = stringf("%s:%d:%s", __FILE__, __LINE__, __FUNCTION__);
 739                 coverage_data[key].second += it.second->call_counter;
 740         }
 741
 742         for (auto &it : extra_coverage_data) {
 743                 if (coverage_data.count(it.first))
 744                         log_warning("found duplicate coverage id \"%s\".\n", it.first.c_str());
 745                 coverage_data[it.first].first = it.second.first;
 746                 coverage_data[it.first].second += it.second.second;
 747         }
 748
 749         for (CoverData *p = __start_yosys_cover_list; p != __stop_yosys_cover_list; p++) {
 750                 if (coverage_data.count(p->id))
 751                         log_warning("found duplicate coverage id \"%s\".\n", p->id);
 752                 coverage_data[p->id].first = stringf("%s:%d:%s", p->file, p->line, p->func);
 753                 coverage_data[p->id].second += p->counter;
 754         }
 755
 756         for (auto &it : coverage_data)
 757                 if (!it.second.first.compare(0, strlen(YOSYS_SRC "/"), YOSYS_SRC "/"))
 758                         it.second.first = it.second.first.substr(strlen(YOSYS_SRC "/"));
 759
 760         return coverage_data;
 761 }
 762
 763 #endif
 764
 765 YOSYS_NAMESPACE_END