kernel/log.cc

   1 /*
   2  *  yosys -- Yosys Open SYnthesis Suite
   3  *
   4  *  Copyright (C) 2012  Clifford Wolf <clifford@clifford.at>
   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/ilang/ilang_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 static bool check_expected_logs = true;
  75 static bool display_error_log_msg = true;
  76
  77 static void log_id_cache_clear()
  78 {
  79         for (auto p : log_id_cache)
  80                 free(p);
  81         log_id_cache.clear();
  82 }
  83
  84 #if defined(_WIN32) && !defined(__MINGW32__)
  85 // this will get time information and return it in timeval, simulating gettimeofday()
  86 int gettimeofday(struct timeval *tv, struct timezone *tz)
  87 {
  88         LARGE_INTEGER counter;
  89         LARGE_INTEGER freq;
  90
  91         QueryPerformanceFrequency(&freq);
  92         QueryPerformanceCounter(&counter);
  93
  94         counter.QuadPart *= 1000000;
  95         counter.QuadPart /= freq.QuadPart;
  96
  97         tv->tv_sec = long(counter.QuadPart / 1000000);
  98         tv->tv_usec = counter.QuadPart % 1000000;
  99
 100         return 0;
 101 }
 102 #endif
 103
 104 void logv(const char *format, va_list ap)
 105 {
 106         while (format[0] == '\n' && format[1] != 0) {
 107                 log("\n");
 108                 format++;
 109         }
 110
 111         if (log_make_debug && !ys_debug(1))
 112                 return;
 113
 114         std::string str = vstringf(format, ap);
 115
 116         if (str.empty())
 117                 return;
 118
 119         size_t nnl_pos = str.find_last_not_of('\n');
 120         if (nnl_pos == std::string::npos)
 121                 log_newline_count += GetSize(str);
 122         else
 123                 log_newline_count = GetSize(str) - nnl_pos - 1;
 124
 125         if (log_hasher)
 126                 log_hasher->update(str);
 127
 128         if (log_time)
 129         {
 130                 std::string time_str;
 131
 132                 if (next_print_log || initial_tv.tv_sec == 0) {
 133                         next_print_log = false;
 134                         struct timeval tv;
 135                         gettimeofday(&tv, NULL);
 136                         if (initial_tv.tv_sec == 0)
 137                                 initial_tv = tv;
 138                         if (tv.tv_usec < initial_tv.tv_usec) {
 139                                 tv.tv_sec--;
 140                                 tv.tv_usec += 1000000;
 141                         }
 142                         tv.tv_sec -= initial_tv.tv_sec;
 143                         tv.tv_usec -= initial_tv.tv_usec;
 144                         time_str += stringf("[%05d.%06d] ", int(tv.tv_sec), int(tv.tv_usec));
 145                 }
 146
 147                 if (format[0] && format[strlen(format)-1] == '\n')
 148                         next_print_log = true;
 149
 150                 for (auto f : log_files)
 151                         fputs(time_str.c_str(), f);
 152
 153                 for (auto f : log_streams)
 154                         *f << time_str;
 155         }
 156
 157         for (auto f : log_files)
 158                 fputs(str.c_str(), f);
 159
 160         for (auto f : log_streams)
 161                 *f << str;
 162
 163         static std::string linebuffer;
 164         static bool log_warn_regex_recusion_guard = false;
 165
 166         if (!log_warn_regex_recusion_guard)
 167         {
 168                 log_warn_regex_recusion_guard = true;
 169
 170                 if (log_warn_regexes.empty() && log_expect_log.empty())
 171                 {
 172                         linebuffer.clear();
 173                 }
 174                 else
 175                 {
 176                         linebuffer += str;
 177
 178                         if (!linebuffer.empty() && linebuffer.back() == '\n') {
 179                                 for (auto &re : log_warn_regexes)
 180                                         if (YS_REGEX_NS::regex_search(linebuffer, re))
 181                                                 log_warning("Found log message matching -W regex:\n%s", str.c_str());
 182
 183                                 for (auto &item : log_expect_log)
 184                                         if (YS_REGEX_NS::regex_search(linebuffer, item.second.pattern))
 185                                                 item.second.current_count++;
 186
 187                                 linebuffer.clear();
 188                         }
 189                 }
 190
 191                 log_warn_regex_recusion_guard = false;
 192         }
 193 }
 194
 195 void logv_header(RTLIL::Design *design, const char *format, va_list ap)
 196 {
 197         bool pop_errfile = false;
 198
 199         log_spacer();
 200         if (header_count.size() > 0)
 201                 header_count.back()++;
 202
 203         if (int(header_count.size()) <= log_verbose_level && log_errfile != NULL) {
 204                 log_files.push_back(log_errfile);
 205                 pop_errfile = true;
 206         }
 207
 208         std::string header_id;
 209
 210         for (int c : header_count)
 211                 header_id += stringf("%s%d", header_id.empty() ? "" : ".", c);
 212
 213         log("%s. ", header_id.c_str());
 214         logv(format, ap);
 215         log_flush();
 216
 217         if (log_hdump_all)
 218                 log_hdump[header_id].insert("yosys_dump_" + header_id + ".il");
 219
 220         if (log_hdump.count(header_id) && design != nullptr)
 221                 for (auto &filename : log_hdump.at(header_id)) {
 222                         log("Dumping current design to '%s'.\n", filename.c_str());
 223                         if (yosys_xtrace)
 224                                 IdString::xtrace_db_dump();
 225                         Pass::call(design, {"dump", "-o", filename});
 226                         if (yosys_xtrace)
 227                                 log("#X# -- end of dump --\n");
 228                 }
 229
 230         if (pop_errfile)
 231                 log_files.pop_back();
 232 }
 233
 234 static void logv_warning_with_prefix(const char *prefix,
 235                                      const char *format, va_list ap)
 236 {
 237         std::string message = vstringf(format, ap);
 238         bool suppressed = false;
 239
 240         for (auto &re : log_nowarn_regexes)
 241                 if (YS_REGEX_NS::regex_search(message, re))
 242                         suppressed = true;
 243
 244         if (suppressed)
 245         {
 246                 log("Suppressed %s%s", prefix, message.c_str());
 247         }
 248         else
 249         {
 250                 int bak_log_make_debug = log_make_debug;
 251                 log_make_debug = 0;
 252
 253                 for (auto &re : log_werror_regexes)
 254                         if (YS_REGEX_NS::regex_search(message, re))
 255                                 log_error("%s",  message.c_str());
 256
 257                 bool warning_match = false;
 258                 for (auto &item : log_expect_warning)
 259                         if (YS_REGEX_NS::regex_search(message, item.second.pattern)) {
 260                                 item.second.current_count++;
 261                                 warning_match = true;
 262                         }
 263
 264                 if (log_warnings.count(message))
 265                 {
 266                         log("%s%s", prefix, message.c_str());
 267                         log_flush();
 268                 }
 269                 else
 270                 {
 271                         if (log_errfile != NULL && !log_quiet_warnings)
 272                                 log_files.push_back(log_errfile);
 273
 274                         log("%s%s", prefix, message.c_str());
 275                         log_flush();
 276
 277                         if (log_errfile != NULL && !log_quiet_warnings)
 278                                 log_files.pop_back();
 279
 280                         log_warnings.insert(message);
 281                 }
 282
 283                 if (!warning_match)
 284                         log_warnings_count_noexpect++;
 285                 log_warnings_count++;
 286                 log_make_debug = bak_log_make_debug;
 287         }
 288 }
 289
 290 void logv_warning(const char *format, va_list ap)
 291 {
 292         logv_warning_with_prefix("Warning: ", format, ap);
 293 }
 294
 295 void logv_warning_noprefix(const char *format, va_list ap)
 296 {
 297         logv_warning_with_prefix("", format, ap);
 298 }
 299
 300 void log_file_warning(const std::string &filename, int lineno,
 301                       const char *format, ...)
 302 {
 303         va_list ap;
 304         va_start(ap, format);
 305         std::string prefix = stringf("%s:%d: Warning: ",
 306                         filename.c_str(), lineno);
 307         logv_warning_with_prefix(prefix.c_str(), format, ap);
 308         va_end(ap);
 309 }
 310
 311 void log_file_info(const std::string &filename, int lineno,
 312                       const char *format, ...)
 313 {
 314         va_list ap;
 315         va_start(ap, format);
 316         std::string fmt = stringf("%s:%d: Info: %s",
 317                         filename.c_str(), lineno, format);
 318         logv(fmt.c_str(), ap);
 319         va_end(ap);
 320 }
 321
 322 [[noreturn]]
 323 static void logv_error_with_prefix(const char *prefix,
 324                                    const char *format, va_list ap)
 325 {
 326 #ifdef EMSCRIPTEN
 327         auto backup_log_files = log_files;
 328 #endif
 329         int bak_log_make_debug = log_make_debug;
 330         log_make_debug = 0;
 331         log_suppressed();
 332
 333         if (log_errfile != NULL)
 334                 log_files.push_back(log_errfile);
 335
 336         if (log_error_stderr)
 337                 for (auto &f : log_files)
 338                         if (f == stdout)
 339                                 f = stderr;
 340
 341         log_last_error = vstringf(format, ap);
 342         if (display_error_log_msg)
 343                 log("%s%s", prefix, log_last_error.c_str());
 344         log_flush();
 345
 346         log_make_debug = bak_log_make_debug;
 347
 348         if (log_error_atexit)
 349                 log_error_atexit();
 350
 351         for (auto &item : log_expect_error)
 352                 if (YS_REGEX_NS::regex_search(log_last_error, item.second.pattern))
 353                         item.second.current_count++;
 354
 355         if (check_expected_logs)
 356                 log_check_expected();
 357
 358         YS_DEBUGTRAP_IF_DEBUGGING;
 359
 360 #ifdef EMSCRIPTEN
 361         log_files = backup_log_files;
 362         throw 0;
 363 #elif defined(_MSC_VER)
 364         _exit(1);
 365 #else
 366         _Exit(1);
 367 #endif
 368 }
 369
 370 void logv_error(const char *format, va_list ap)
 371 {
 372         logv_error_with_prefix("ERROR: ", format, ap);
 373 }
 374
 375 void log_file_error(const string &filename, int lineno,
 376                     const char *format, ...)
 377 {
 378         va_list ap;
 379         va_start(ap, format);
 380         std::string prefix = stringf("%s:%d: ERROR: ",
 381                                      filename.c_str(), lineno);
 382         logv_error_with_prefix(prefix.c_str(), format, ap);
 383 }
 384
 385 void log(const char *format, ...)
 386 {
 387         va_list ap;
 388         va_start(ap, format);
 389         logv(format, ap);
 390         va_end(ap);
 391 }
 392
 393 void log_header(RTLIL::Design *design, const char *format, ...)
 394 {
 395         va_list ap;
 396         va_start(ap, format);
 397         logv_header(design, format, ap);
 398         va_end(ap);
 399 }
 400
 401 void log_warning(const char *format, ...)
 402 {
 403         va_list ap;
 404         va_start(ap, format);
 405         logv_warning(format, ap);
 406         va_end(ap);
 407 }
 408
 409 void log_experimental(const char *format, ...)
 410 {
 411         va_list ap;
 412         va_start(ap, format);
 413         string s = vstringf(format, ap);
 414         va_end(ap);
 415
 416         if (log_experimentals_ignored.count(s) == 0 && log_experimentals.count(s) == 0) {
 417                 log_warning("Feature '%s' is experimental.\n", s.c_str());
 418                 log_experimentals.insert(s);
 419         }
 420 }
 421
 422 void log_warning_noprefix(const char *format, ...)
 423 {
 424         va_list ap;
 425         va_start(ap, format);
 426         logv_warning_noprefix(format, ap);
 427         va_end(ap);
 428 }
 429
 430 void log_error(const char *format, ...)
 431 {
 432         va_list ap;
 433         va_start(ap, format);
 434         logv_error(format, ap);
 435 }
 436
 437 void log_cmd_error(const char *format, ...)
 438 {
 439         va_list ap;
 440         va_start(ap, format);
 441
 442         if (log_cmd_error_throw) {
 443                 log_last_error = vstringf(format, ap);
 444                 log("ERROR: %s", log_last_error.c_str());
 445                 log_flush();
 446                 throw log_cmd_error_exception();
 447         }
 448
 449         logv_error(format, ap);
 450 }
 451
 452 void log_spacer()
 453 {
 454         if (log_newline_count < 2) log("\n");
 455         if (log_newline_count < 2) log("\n");
 456 }
 457
 458 void log_push()
 459 {
 460         header_count.push_back(0);
 461 }
 462
 463 void log_pop()
 464 {
 465         header_count.pop_back();
 466         log_id_cache_clear();
 467         string_buf.clear();
 468         string_buf_index = -1;
 469         log_flush();
 470 }
 471
 472 #if (defined(__linux__) || defined(__FreeBSD__)) && defined(YOSYS_ENABLE_PLUGINS)
 473 void log_backtrace(const char *prefix, int levels)
 474 {
 475         if (levels <= 0) return;
 476
 477         Dl_info dli;
 478         void *p;
 479
 480         if ((p = __builtin_extract_return_addr(__builtin_return_address(0))) && dladdr(p, &dli)) {
 481                 log("%sframe #1: %p %s(%p) %s(%p)\n", prefix, p, dli.dli_fname, dli.dli_fbase, dli.dli_sname, dli.dli_saddr);
 482         } else {
 483                 log("%sframe #1: ---\n", prefix);
 484                 return;
 485         }
 486
 487         if (levels <= 1) return;
 488
 489 #ifndef DEBUG
 490         log("%sframe #2: [build Yosys with ENABLE_DEBUG for deeper backtraces]\n", prefix);
 491 #else
 492         if ((p = __builtin_extract_return_addr(__builtin_return_address(1))) && dladdr(p, &dli)) {
 493                 log("%sframe #2: %p %s(%p) %s(%p)\n", prefix, p, dli.dli_fname, dli.dli_fbase, dli.dli_sname, dli.dli_saddr);
 494         } else {
 495                 log("%sframe #2: ---\n", prefix);
 496                 return;
 497         }
 498
 499         if (levels <= 2) return;
 500
 501         if ((p = __builtin_extract_return_addr(__builtin_return_address(2))) && dladdr(p, &dli)) {
 502                 log("%sframe #3: %p %s(%p) %s(%p)\n", prefix, p, dli.dli_fname, dli.dli_fbase, dli.dli_sname, dli.dli_saddr);
 503         } else {
 504                 log("%sframe #3: ---\n", prefix);
 505                 return;
 506         }
 507
 508         if (levels <= 3) return;
 509
 510         if ((p = __builtin_extract_return_addr(__builtin_return_address(3))) && dladdr(p, &dli)) {
 511                 log("%sframe #4: %p %s(%p) %s(%p)\n", prefix, p, dli.dli_fname, dli.dli_fbase, dli.dli_sname, dli.dli_saddr);
 512         } else {
 513                 log("%sframe #4: ---\n", prefix);
 514                 return;
 515         }
 516
 517         if (levels <= 4) return;
 518
 519         if ((p = __builtin_extract_return_addr(__builtin_return_address(4))) && dladdr(p, &dli)) {
 520                 log("%sframe #5: %p %s(%p) %s(%p)\n", prefix, p, dli.dli_fname, dli.dli_fbase, dli.dli_sname, dli.dli_saddr);
 521         } else {
 522                 log("%sframe #5: ---\n", prefix);
 523                 return;
 524         }
 525
 526         if (levels <= 5) return;
 527
 528         if ((p = __builtin_extract_return_addr(__builtin_return_address(5))) && dladdr(p, &dli)) {
 529                 log("%sframe #6: %p %s(%p) %s(%p)\n", prefix, p, dli.dli_fname, dli.dli_fbase, dli.dli_sname, dli.dli_saddr);
 530         } else {
 531                 log("%sframe #6: ---\n", prefix);
 532                 return;
 533         }
 534
 535         if (levels <= 6) return;
 536
 537         if ((p = __builtin_extract_return_addr(__builtin_return_address(6))) && dladdr(p, &dli)) {
 538                 log("%sframe #7: %p %s(%p) %s(%p)\n", prefix, p, dli.dli_fname, dli.dli_fbase, dli.dli_sname, dli.dli_saddr);
 539         } else {
 540                 log("%sframe #7: ---\n", prefix);
 541                 return;
 542         }
 543
 544         if (levels <= 7) return;
 545
 546         if ((p = __builtin_extract_return_addr(__builtin_return_address(7))) && dladdr(p, &dli)) {
 547                 log("%sframe #8: %p %s(%p) %s(%p)\n", prefix, p, dli.dli_fname, dli.dli_fbase, dli.dli_sname, dli.dli_saddr);
 548         } else {
 549                 log("%sframe #8: ---\n", prefix);
 550                 return;
 551         }
 552
 553         if (levels <= 8) return;
 554
 555         if ((p = __builtin_extract_return_addr(__builtin_return_address(8))) && dladdr(p, &dli)) {
 556                 log("%sframe #9: %p %s(%p) %s(%p)\n", prefix, p, dli.dli_fname, dli.dli_fbase, dli.dli_sname, dli.dli_saddr);
 557         } else {
 558                 log("%sframe #9: ---\n", prefix);
 559                 return;
 560         }
 561
 562         if (levels <= 9) return;
 563 #endif
 564 }
 565 #else
 566 void log_backtrace(const char*, int) { }
 567 #endif
 568
 569 void log_reset_stack()
 570 {
 571         while (header_count.size() > 1)
 572                 header_count.pop_back();
 573         log_id_cache_clear();
 574         string_buf.clear();
 575         string_buf_index = -1;
 576         log_flush();
 577 }
 578
 579 void log_flush()
 580 {
 581         for (auto f : log_files)
 582                 fflush(f);
 583
 584         for (auto f : log_streams)
 585                 f->flush();
 586 }
 587
 588 void log_dump_val_worker(RTLIL::IdString v) {
 589         log("%s", log_id(v));
 590 }
 591
 592 void log_dump_val_worker(RTLIL::SigSpec v) {
 593         log("%s", log_signal(v));
 594 }
 595
 596 void log_dump_val_worker(RTLIL::State v) {
 597         log("%s", log_signal(v));
 598 }
 599
 600 const char *log_signal(const RTLIL::SigSpec &sig, bool autoint)
 601 {
 602         std::stringstream buf;
 603         ILANG_BACKEND::dump_sigspec(buf, sig, autoint);
 604
 605         if (string_buf.size() < 100) {
 606                 string_buf.push_back(buf.str());
 607                 return string_buf.back().c_str();
 608         } else {
 609                 if (++string_buf_index == 100)
 610                         string_buf_index = 0;
 611                 string_buf[string_buf_index] = buf.str();
 612                 return string_buf[string_buf_index].c_str();
 613         }
 614 }
 615
 616 const char *log_const(const RTLIL::Const &value, bool autoint)
 617 {
 618         if ((value.flags & RTLIL::CONST_FLAG_STRING) == 0)
 619                 return log_signal(value, autoint);
 620
 621         std::string str = "\"" + value.decode_string() + "\"";
 622
 623         if (string_buf.size() < 100) {
 624                 string_buf.push_back(str);
 625                 return string_buf.back().c_str();
 626         } else {
 627                 if (++string_buf_index == 100)
 628                         string_buf_index = 0;
 629                 string_buf[string_buf_index] = str;
 630                 return string_buf[string_buf_index].c_str();
 631         }
 632 }
 633
 634 const char *log_id(RTLIL::IdString str)
 635 {
 636         log_id_cache.push_back(strdup(str.c_str()));
 637         const char *p = log_id_cache.back();
 638         if (p[0] != '\\')
 639                 return p;
 640         if (p[1] == '$' || p[1] == '\\' || p[1] == 0)
 641                 return p;
 642         if (p[1] >= '0' && p[1] <= '9')
 643                 return p;
 644         return p+1;
 645 }
 646
 647 void log_module(RTLIL::Module *module, std::string indent)
 648 {
 649         std::stringstream buf;
 650         ILANG_BACKEND::dump_module(buf, indent, module, module->design, false);
 651         log("%s", buf.str().c_str());
 652 }
 653
 654 void log_cell(RTLIL::Cell *cell, std::string indent)
 655 {
 656         std::stringstream buf;
 657         ILANG_BACKEND::dump_cell(buf, indent, cell);
 658         log("%s", buf.str().c_str());
 659 }
 660
 661 void log_wire(RTLIL::Wire *wire, std::string indent)
 662 {
 663         std::stringstream buf;
 664         ILANG_BACKEND::dump_wire(buf, indent, wire);
 665         log("%s", buf.str().c_str());
 666 }
 667
 668 void log_check_expected()
 669 {
 670         check_expected_logs = false;
 671
 672         for (auto &item : log_expect_warning) {
 673                 if (item.second.current_count == 0) {
 674                         log_warn_regexes.clear();
 675                         log_error("Expected warning pattern '%s' not found !\n", item.first.c_str());
 676                 }
 677                 if (item.second.current_count != item.second.expected_count) {
 678                         log_warn_regexes.clear();
 679                         log_error("Expected warning pattern '%s' found %d time(s), instead of %d time(s) !\n",
 680                                 item.first.c_str(), item.second.current_count, item.second.expected_count);
 681                 }
 682         }
 683
 684         for (auto &item : log_expect_log) {
 685                 if (item.second.current_count == 0) {
 686                         log_warn_regexes.clear();
 687                         log_error("Expected log pattern '%s' not found !\n", item.first.c_str());
 688                 }
 689                 if (item.second.current_count != item.second.expected_count) {
 690                         log_warn_regexes.clear();
 691                         log_error("Expected log pattern '%s' found %d time(s), instead of %d time(s) !\n",
 692                                 item.first.c_str(), item.second.current_count, item.second.expected_count);
 693                 }
 694         }
 695
 696         for (auto &item : log_expect_error)
 697                 if (item.second.current_count == item.second.expected_count) {
 698                         log_warn_regexes.clear();
 699                         log("Expected error pattern '%s' found !!!\n", item.first.c_str());
 700                         #ifdef EMSCRIPTEN
 701                                 throw 0;
 702                         #elif defined(_MSC_VER)
 703                                 _exit(0);
 704                         #else
 705                                 _Exit(0);
 706                         #endif
 707                 } else {
 708                         display_error_log_msg = false;
 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