src/systemc/core/sc_module.cc

   1 /*
   2  * Copyright 2018 Google, Inc.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met: redistributions of source code must retain the above copyright
   7  * notice, this list of conditions and the following disclaimer;
   8  * redistributions in binary form must reproduce the above copyright
   9  * notice, this list of conditions and the following disclaimer in the
  10  * documentation and/or other materials provided with the distribution;
  11  * neither the name of the copyright holders nor the names of its
  12  * contributors may be used to endorse or promote products derived from
  13  * this software without specific prior written permission.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  16  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  17  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  18  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  19  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  20  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  21  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  22  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  23  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  25  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  *
  27  * Authors: Gabe Black
  28  */
  29
  30 #include <memory>
  31 #include <vector>
  32
  33 #include "base/logging.hh"
  34 #include "systemc/core/module.hh"
  35 #include "systemc/ext/core/sc_module.hh"
  36 #include "systemc/ext/core/sc_module_name.hh"
  37
  38 namespace sc_core
  39 {
  40
  41 sc_bind_proxy::sc_bind_proxy(const sc_interface &_interface) :
  42     _interface(&_interface), _port(nullptr)
  43 {}
  44
  45 sc_bind_proxy::sc_bind_proxy(const sc_port_base &_port) :
  46     _interface(nullptr), _port(&_port)
  47 {}
  48
  49 const sc_bind_proxy SC_BIND_PROXY_NUL(*(const sc_port_base *)nullptr);
  50
  51 sc_module::~sc_module() {}
  52
  53 const sc_bind_proxy SC_BIND_PROXY_NIL(*(const sc_port_base *)nullptr);
  54
  55 void
  56 sc_module::operator () (const sc_bind_proxy &p001,
  57                         const sc_bind_proxy &p002,
  58                         const sc_bind_proxy &p003,
  59                         const sc_bind_proxy &p004,
  60                         const sc_bind_proxy &p005,
  61                         const sc_bind_proxy &p006,
  62                         const sc_bind_proxy &p007,
  63                         const sc_bind_proxy &p008,
  64                         const sc_bind_proxy &p009,
  65                         const sc_bind_proxy &p010,
  66                         const sc_bind_proxy &p011,
  67                         const sc_bind_proxy &p012,
  68                         const sc_bind_proxy &p013,
  69                         const sc_bind_proxy &p014,
  70                         const sc_bind_proxy &p015,
  71                         const sc_bind_proxy &p016,
  72                         const sc_bind_proxy &p017,
  73                         const sc_bind_proxy &p018,
  74                         const sc_bind_proxy &p019,
  75                         const sc_bind_proxy &p020,
  76                         const sc_bind_proxy &p021,
  77                         const sc_bind_proxy &p022,
  78                         const sc_bind_proxy &p023,
  79                         const sc_bind_proxy &p024,
  80                         const sc_bind_proxy &p025,
  81                         const sc_bind_proxy &p026,
  82                         const sc_bind_proxy &p027,
  83                         const sc_bind_proxy &p028,
  84                         const sc_bind_proxy &p029,
  85                         const sc_bind_proxy &p030,
  86                         const sc_bind_proxy &p031,
  87                         const sc_bind_proxy &p032,
  88                         const sc_bind_proxy &p033,
  89                         const sc_bind_proxy &p034,
  90                         const sc_bind_proxy &p035,
  91                         const sc_bind_proxy &p036,
  92                         const sc_bind_proxy &p037,
  93                         const sc_bind_proxy &p038,
  94                         const sc_bind_proxy &p039,
  95                         const sc_bind_proxy &p040,
  96                         const sc_bind_proxy &p041,
  97                         const sc_bind_proxy &p042,
  98                         const sc_bind_proxy &p043,
  99                         const sc_bind_proxy &p044,
 100                         const sc_bind_proxy &p045,
 101                         const sc_bind_proxy &p046,
 102                         const sc_bind_proxy &p047,
 103                         const sc_bind_proxy &p048,
 104                         const sc_bind_proxy &p049,
 105                         const sc_bind_proxy &p050,
 106                         const sc_bind_proxy &p051,
 107                         const sc_bind_proxy &p052,
 108                         const sc_bind_proxy &p053,
 109                         const sc_bind_proxy &p054,
 110                         const sc_bind_proxy &p055,
 111                         const sc_bind_proxy &p056,
 112                         const sc_bind_proxy &p057,
 113                         const sc_bind_proxy &p058,
 114                         const sc_bind_proxy &p059,
 115                         const sc_bind_proxy &p060,
 116                         const sc_bind_proxy &p061,
 117                         const sc_bind_proxy &p062,
 118                         const sc_bind_proxy &p063,
 119                         const sc_bind_proxy &p064)
 120 {
 121     warn("%s not implemented.\n", __PRETTY_FUNCTION__);
 122 }
 123
 124 const std::vector<sc_object *> &
 125 sc_module::get_child_objects() const
 126 {
 127     return _gem5_module->obj()->get_child_objects();
 128 }
 129
 130 const std::vector<sc_event *> &
 131 sc_module::get_child_events() const
 132 {
 133     return _gem5_module->obj()->get_child_events();
 134 }
 135
 136 sc_module::sc_module() :
 137     sc_object(sc_gem5::currentModule()->name()),
 138     _gem5_module(sc_gem5::currentModule())
 139 {}
 140
 141 sc_module::sc_module(const sc_module_name &) : sc_module() {}
 142 sc_module::sc_module(const char *_name) : sc_module(sc_module_name(_name)) {}
 143 sc_module::sc_module(const std::string &_name) :
 144     sc_module(sc_module_name(_name.c_str()))
 145 {}
 146
 147 void
 148 sc_module::reset_signal_is(const sc_in<bool> &, bool)
 149 {
 150     warn("%s not implemented.\n", __PRETTY_FUNCTION__);
 151 }
 152
 153 void
 154 sc_module::reset_signal_is(const sc_inout<bool> &, bool)
 155 {
 156     warn("%s not implemented.\n", __PRETTY_FUNCTION__);
 157 }
 158
 159 void
 160 sc_module::reset_signal_is(const sc_out<bool> &, bool)
 161 {
 162     warn("%s not implemented.\n", __PRETTY_FUNCTION__);
 163 }
 164
 165 void
 166 sc_module::reset_signal_is(const sc_signal_in_if<bool> &, bool)
 167 {
 168     warn("%s not implemented.\n", __PRETTY_FUNCTION__);
 169 }
 170
 171
 172 void
 173 sc_module::async_reset_signal_is(const sc_in<bool> &, bool)
 174 {
 175     warn("%s not implemented.\n", __PRETTY_FUNCTION__);
 176 }
 177
 178 void
 179 sc_module::async_reset_signal_is(const sc_inout<bool> &, bool)
 180 {
 181     warn("%s not implemented.\n", __PRETTY_FUNCTION__);
 182 }
 183
 184 void
 185 sc_module::async_reset_signal_is(const sc_out<bool> &, bool)
 186 {
 187     warn("%s not implemented.\n", __PRETTY_FUNCTION__);
 188 }
 189
 190 void
 191 sc_module::async_reset_signal_is(const sc_signal_in_if<bool> &, bool)
 192 {
 193     warn("%s not implemented.\n", __PRETTY_FUNCTION__);
 194 }
 195
 196
 197 void
 198 sc_module::dont_initialize()
 199 {
 200     warn("%s not implemented.\n", __PRETTY_FUNCTION__);
 201 }
 202
 203 void
 204 sc_module::set_stack_size(size_t)
 205 {
 206     warn("%s not implemented.\n", __PRETTY_FUNCTION__);
 207 }
 208
 209
 210 void sc_module::next_trigger() { ::sc_core::next_trigger(); }
 211
 212 void
 213 sc_module::next_trigger(const sc_event &e)
 214 {
 215     ::sc_core::next_trigger(e);
 216 }
 217
 218 void
 219 sc_module::next_trigger(const sc_event_or_list &eol)
 220 {
 221     ::sc_core::next_trigger(eol);
 222 }
 223
 224 void
 225 sc_module::next_trigger(const sc_event_and_list &eal)
 226 {
 227     ::sc_core::next_trigger(eal);
 228 }
 229
 230 void
 231 sc_module::next_trigger(const sc_time &t)
 232 {
 233     ::sc_core::next_trigger(t);
 234 }
 235
 236 void
 237 sc_module::next_trigger(double d, sc_time_unit u)
 238 {
 239     ::sc_core::next_trigger(d, u);
 240 }
 241
 242 void
 243 sc_module::next_trigger(const sc_time &t, const sc_event &e)
 244 {
 245     ::sc_core::next_trigger(t, e);
 246 }
 247
 248 void
 249 sc_module::next_trigger(double d, sc_time_unit u, const sc_event &e)
 250 {
 251     ::sc_core::next_trigger(d, u, e);
 252 }
 253
 254 void
 255 sc_module::next_trigger(const sc_time &t, const sc_event_or_list &eol)
 256 {
 257     ::sc_core::next_trigger(t, eol);
 258 }
 259
 260 void
 261 sc_module::next_trigger(double d, sc_time_unit u, const sc_event_or_list &eol)
 262 {
 263     ::sc_core::next_trigger(d, u, eol);
 264 }
 265
 266 void
 267 sc_module::next_trigger(const sc_time &t, const sc_event_and_list &eal)
 268 {
 269     ::sc_core::next_trigger(t, eal);
 270 }
 271
 272 void
 273 sc_module::next_trigger(double d, sc_time_unit u, const sc_event_and_list &eal)
 274 {
 275     ::sc_core::next_trigger(d, u, eal);
 276 }
 277
 278
 279 bool
 280 sc_module::timed_out()
 281 {
 282     warn("%s not implemented.\n", __PRETTY_FUNCTION__);
 283     return false;
 284 }
 285
 286
 287 void
 288 sc_module::wait()
 289 {
 290     ::sc_core::wait();
 291 }
 292
 293 void
 294 sc_module::wait(int i)
 295 {
 296     ::sc_core::wait(i);
 297 }
 298
 299 void
 300 sc_module::wait(const sc_event &e)
 301 {
 302     ::sc_core::wait(e);
 303 }
 304
 305 void
 306 sc_module::wait(const sc_event_or_list &eol)
 307 {
 308     ::sc_core::wait(eol);
 309 }
 310
 311 void
 312 sc_module::wait(const sc_event_and_list &eal)
 313 {
 314     ::sc_core::wait(eal);
 315 }
 316
 317 void
 318 sc_module::wait(const sc_time &t)
 319 {
 320     ::sc_core::wait(t);
 321 }
 322
 323 void
 324 sc_module::wait(double d, sc_time_unit u)
 325 {
 326     ::sc_core::wait(d, u);
 327 }
 328
 329 void
 330 sc_module::wait(const sc_time &t, const sc_event &e)
 331 {
 332     ::sc_core::wait(t, e);
 333 }
 334
 335 void
 336 sc_module::wait(double d, sc_time_unit u, const sc_event &e)
 337 {
 338     ::sc_core::wait(d, u, e);
 339 }
 340
 341 void
 342 sc_module::wait(const sc_time &t, const sc_event_or_list &eol)
 343 {
 344     ::sc_core::wait(t, eol);
 345 }
 346
 347 void
 348 sc_module::wait(double d, sc_time_unit u, const sc_event_or_list &eol)
 349 {
 350     ::sc_core::wait(d, u, eol);
 351 }
 352
 353 void
 354 sc_module::wait(const sc_time &t, const sc_event_and_list &eal)
 355 {
 356     ::sc_core::wait(t, eal);
 357 }
 358
 359 void
 360 sc_module::wait(double d, sc_time_unit u, const sc_event_and_list &eal)
 361 {
 362     ::sc_core::wait(d, u, eal);
 363 }
 364
 365
 366 void
 367 sc_module::halt()
 368 {
 369     ::sc_core::halt();
 370 }
 371
 372 void
 373 sc_module::at_posedge(const sc_signal_in_if<bool> &s)
 374 {
 375     ::sc_core::at_posedge(s);
 376 }
 377
 378 void
 379 sc_module::at_posedge(const sc_signal_in_if<sc_dt::sc_logic> &s)
 380 {
 381     ::sc_core::at_posedge(s);
 382 }
 383
 384 void
 385 sc_module::at_negedge(const sc_signal_in_if<bool> &s)
 386 {
 387     ::sc_core::at_negedge(s);
 388 }
 389
 390 void
 391 sc_module::at_negedge(const sc_signal_in_if<sc_dt::sc_logic> &s)
 392 {
 393     ::sc_core::at_negedge(s);
 394 }
 395
 396
 397 void
 398 next_trigger()
 399 {
 400     warn("%s not implemented.\n", __PRETTY_FUNCTION__);
 401 }
 402
 403 void
 404 next_trigger(const sc_event &)
 405 {
 406     warn("%s not implemented.\n", __PRETTY_FUNCTION__);
 407 }
 408
 409 void
 410 next_trigger(const sc_event_or_list &)
 411 {
 412     warn("%s not implemented.\n", __PRETTY_FUNCTION__);
 413 }
 414
 415 void
 416 next_trigger(const sc_event_and_list &)
 417 {
 418     warn("%s not implemented.\n", __PRETTY_FUNCTION__);
 419 }
 420
 421 void
 422 next_trigger(const sc_time &)
 423 {
 424     warn("%s not implemented.\n", __PRETTY_FUNCTION__);
 425 }
 426
 427 void
 428 next_trigger(double d, sc_time_unit u)
 429 {
 430     next_trigger(sc_time(d, u));
 431 }
 432
 433 void
 434 next_trigger(const sc_time &, const sc_event &)
 435 {
 436     warn("%s not implemented.\n", __PRETTY_FUNCTION__);
 437 }
 438
 439 void
 440 next_trigger(double d, sc_time_unit u, const sc_event &e)
 441 {
 442     next_trigger(sc_time(d, u), e);
 443 }
 444
 445 void
 446 next_trigger(const sc_time &, const sc_event_or_list &)
 447 {
 448     warn("%s not implemented.\n", __PRETTY_FUNCTION__);
 449 }
 450
 451 void
 452 next_trigger(double d, sc_time_unit u, const sc_event_or_list &eol)
 453 {
 454     next_trigger(sc_time(d, u), eol);
 455 }
 456
 457 void
 458 next_trigger(const sc_time &, const sc_event_and_list &)
 459 {
 460     warn("%s not implemented.\n", __PRETTY_FUNCTION__);
 461 }
 462
 463 void
 464 next_trigger(double d, sc_time_unit u, const sc_event_and_list &eal)
 465 {
 466     next_trigger(sc_time(d, u), eal);
 467 }
 468
 469 bool
 470 timed_out()
 471 {
 472     warn("%s not implemented.\n", __PRETTY_FUNCTION__);
 473     return false;
 474 }
 475
 476
 477 void
 478 wait()
 479 {
 480     warn("%s not implemented.\n", __PRETTY_FUNCTION__);
 481 }
 482
 483 void
 484 wait(int)
 485 {
 486     warn("%s not implemented.\n", __PRETTY_FUNCTION__);
 487 }
 488
 489 void
 490 wait(const sc_event &)
 491 {
 492     warn("%s not implemented.\n", __PRETTY_FUNCTION__);
 493 }
 494
 495 void
 496 wait(const sc_event_or_list &)
 497 {
 498     warn("%s not implemented.\n", __PRETTY_FUNCTION__);
 499 }
 500
 501 void
 502 wait(const sc_event_and_list &)
 503 {
 504     warn("%s not implemented.\n", __PRETTY_FUNCTION__);
 505 }
 506
 507 void
 508 wait(const sc_time &)
 509 {
 510     warn("%s not implemented.\n", __PRETTY_FUNCTION__);
 511 }
 512
 513 void
 514 wait(double d, sc_time_unit u)
 515 {
 516     wait(sc_time(d, u));
 517 }
 518
 519 void
 520 wait(const sc_time &, const sc_event &)
 521 {
 522     warn("%s not implemented.\n", __PRETTY_FUNCTION__);
 523 }
 524
 525 void
 526 wait(double d, sc_time_unit u, const sc_event &e)
 527 {
 528     wait(sc_time(d, u), e);
 529 }
 530
 531 void
 532 wait(const sc_time &, const sc_event_or_list &)
 533 {
 534     warn("%s not implemented.\n", __PRETTY_FUNCTION__);
 535 }
 536
 537 void
 538 wait(double d, sc_time_unit u, const sc_event_or_list &eol)
 539 {
 540     wait(sc_time(d, u), eol);
 541 }
 542
 543 void
 544 wait(const sc_time &, const sc_event_and_list &)
 545 {
 546     warn("%s not implemented.\n", __PRETTY_FUNCTION__);
 547 }
 548
 549 void
 550 wait(double d, sc_time_unit u, const sc_event_and_list &eal)
 551 {
 552     wait(sc_time(d, u), eal);
 553 }
 554
 555 void
 556 halt()
 557 {
 558     warn("%s not implemented.\n", __PRETTY_FUNCTION__);
 559 }
 560
 561 void
 562 at_posedge(const sc_signal_in_if<bool> &)
 563 {
 564     warn("%s not implemented.\n", __PRETTY_FUNCTION__);
 565 }
 566
 567 void
 568 at_posedge(const sc_signal_in_if<sc_dt::sc_logic> &)
 569 {
 570     warn("%s not implemented.\n", __PRETTY_FUNCTION__);
 571 }
 572
 573 void
 574 at_negedge(const sc_signal_in_if<bool> &)
 575 {
 576     warn("%s not implemented.\n", __PRETTY_FUNCTION__);
 577 }
 578
 579 void
 580 at_negedge(const sc_signal_in_if<sc_dt::sc_logic> &)
 581 {
 582     warn("%s not implemented.\n", __PRETTY_FUNCTION__);
 583 }
 584
 585 const char *
 586 sc_gen_unique_name(const char *)
 587 {
 588     warn("%s not implemented.\n", __PRETTY_FUNCTION__);
 589     return "";
 590 }
 591
 592 bool
 593 sc_hierarchical_name_exists(const char *name)
 594 {
 595     warn("%s not implemented.\n", __PRETTY_FUNCTION__);
 596     return false;
 597 }
 598
 599 bool
 600 sc_start_of_simulation_invoked()
 601 {
 602     warn("%s not implemented.\n", __PRETTY_FUNCTION__);
 603     return false;
 604 }
 605
 606 bool
 607 sc_end_of_simulation_invoked()
 608 {
 609     warn("%s not implemented.\n", __PRETTY_FUNCTION__);
 610     return false;
 611 }
 612
 613 sc_module *
 614 sc_module_sc_new(sc_module *mod)
 615 {
 616     static std::vector<std::unique_ptr<sc_module> > modules;
 617     modules.emplace_back(mod);
 618     return mod;
 619 }
 620
 621 } // namespace sc_core