sc_signal.hh revision 12945
13584Ssaidi@eecs.umich.edu/* 23584Ssaidi@eecs.umich.edu * Copyright 2018 Google, Inc. 33584Ssaidi@eecs.umich.edu * 43584Ssaidi@eecs.umich.edu * Redistribution and use in source and binary forms, with or without 53584Ssaidi@eecs.umich.edu * modification, are permitted provided that the following conditions are 63584Ssaidi@eecs.umich.edu * met: redistributions of source code must retain the above copyright 73584Ssaidi@eecs.umich.edu * notice, this list of conditions and the following disclaimer; 83584Ssaidi@eecs.umich.edu * redistributions in binary form must reproduce the above copyright 93584Ssaidi@eecs.umich.edu * notice, this list of conditions and the following disclaimer in the 103584Ssaidi@eecs.umich.edu * documentation and/or other materials provided with the distribution; 113584Ssaidi@eecs.umich.edu * neither the name of the copyright holders nor the names of its 123584Ssaidi@eecs.umich.edu * contributors may be used to endorse or promote products derived from 133584Ssaidi@eecs.umich.edu * this software without specific prior written permission. 143584Ssaidi@eecs.umich.edu * 153584Ssaidi@eecs.umich.edu * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 163584Ssaidi@eecs.umich.edu * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 173584Ssaidi@eecs.umich.edu * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 183584Ssaidi@eecs.umich.edu * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 193584Ssaidi@eecs.umich.edu * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 203584Ssaidi@eecs.umich.edu * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 213584Ssaidi@eecs.umich.edu * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 223584Ssaidi@eecs.umich.edu * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 233584Ssaidi@eecs.umich.edu * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 243584Ssaidi@eecs.umich.edu * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 253584Ssaidi@eecs.umich.edu * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 263584Ssaidi@eecs.umich.edu * 273584Ssaidi@eecs.umich.edu * Authors: Gabe Black 283584Ssaidi@eecs.umich.edu */ 293584Ssaidi@eecs.umich.edu 303584Ssaidi@eecs.umich.edu#ifndef __SYSTEMC_EXT_CHANNEL_SC_SIGNAL_HH__ 313584Ssaidi@eecs.umich.edu#define __SYSTEMC_EXT_CHANNEL_SC_SIGNAL_HH__ 323603Ssaidi@eecs.umich.edu 333584Ssaidi@eecs.umich.edu#include <iostream> 348232Snate@binkert.org#include <string> 353584Ssaidi@eecs.umich.edu#include <vector> 363584Ssaidi@eecs.umich.edu 3710880SCurtis.Dunham@arm.com#include "../core/sc_module.hh" // for sc_gen_unique_name 383584Ssaidi@eecs.umich.edu#include "../core/sc_prim.hh" 3910880SCurtis.Dunham@arm.com#include "sc_signal_inout_if.hh" 403584Ssaidi@eecs.umich.edu#include "warn_unimpl.hh" // for warn_unimpl 413584Ssaidi@eecs.umich.edu 423584Ssaidi@eecs.umich.edunamespace sc_core 4310880SCurtis.Dunham@arm.com{ 443584Ssaidi@eecs.umich.edu 4510880SCurtis.Dunham@arm.comclass sc_port_base; 463584Ssaidi@eecs.umich.educlass sc_trace_file; 473584Ssaidi@eecs.umich.edu 483584Ssaidi@eecs.umich.edu// Nonstandard 493584Ssaidi@eecs.umich.edu// Despite having a warning "FOR INTERNAL USE ONLY!" in all caps above this 503584Ssaidi@eecs.umich.edu// class definition in the Accellera implementation, it appears in their 513584Ssaidi@eecs.umich.edu// examples and test programs, and so we need to have it here as well. 523584Ssaidi@eecs.umich.edustruct sc_trace_params 533584Ssaidi@eecs.umich.edu{ 543584Ssaidi@eecs.umich.edu sc_trace_file *tf; 553584Ssaidi@eecs.umich.edu std::string name; 563584Ssaidi@eecs.umich.edu 573584Ssaidi@eecs.umich.edu sc_trace_params(sc_trace_file *tf, const std::string &name) : 583584Ssaidi@eecs.umich.edu tf(tf), name(name) 593584Ssaidi@eecs.umich.edu {} 603584Ssaidi@eecs.umich.edu}; 613584Ssaidi@eecs.umich.edutypedef std::vector<sc_trace_params *> sc_trace_params_vec; 623584Ssaidi@eecs.umich.edu 633584Ssaidi@eecs.umich.edutemplate <class T, sc_writer_policy WRITER_POLICY=SC_ONE_WRITER> 643584Ssaidi@eecs.umich.educlass sc_signal : public sc_signal_inout_if<T>, 653812Ssaidi@eecs.umich.edu public sc_prim_channel 663584Ssaidi@eecs.umich.edu{ 673904Ssaidi@eecs.umich.edu public: 683603Ssaidi@eecs.umich.edu sc_signal() : sc_signal_inout_if<T>(), 693812Ssaidi@eecs.umich.edu sc_prim_channel(sc_gen_unique_name("signal")) 703904Ssaidi@eecs.umich.edu {} 713584Ssaidi@eecs.umich.edu explicit sc_signal(const char *name) : sc_signal_inout_if<T>(), 723584Ssaidi@eecs.umich.edu sc_prim_channel(name) 733584Ssaidi@eecs.umich.edu {} 743584Ssaidi@eecs.umich.edu explicit sc_signal(const char *name, const T &initial_value) : 753812Ssaidi@eecs.umich.edu sc_signal_inout_if<T>(), sc_prim_channel(name) 763584Ssaidi@eecs.umich.edu { 773904Ssaidi@eecs.umich.edu // Need to consume initial_value. 783603Ssaidi@eecs.umich.edu sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 793812Ssaidi@eecs.umich.edu } 803904Ssaidi@eecs.umich.edu virtual ~sc_signal() {} 813584Ssaidi@eecs.umich.edu 823584Ssaidi@eecs.umich.edu virtual void 83 register_port(sc_port_base &, const char *) 84 { 85 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 86 } 87 88 virtual const T& 89 read() const 90 { 91 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 92 return *(const T *)nullptr; 93 } 94 operator const T&() const 95 { 96 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 97 return *(const T *)nullptr; 98 } 99 100 virtual sc_writer_policy 101 get_writer_policy() const 102 { 103 return WRITER_POLICY; 104 } 105 virtual void 106 write(const T&) 107 { 108 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 109 } 110 sc_signal<T, WRITER_POLICY> & 111 operator = (const T&) 112 { 113 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 114 return *this; 115 } 116 sc_signal<T, WRITER_POLICY> & 117 operator = (const sc_signal<T, WRITER_POLICY> &) 118 { 119 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 120 return *this; 121 } 122 123 virtual const sc_event & 124 default_event() const 125 { 126 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 127 return *(sc_event *)nullptr; 128 } 129 virtual const sc_event & 130 value_changed_event() const 131 { 132 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 133 return *(sc_event *)nullptr; 134 } 135 virtual bool 136 event() const 137 { 138 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 139 return false; 140 } 141 142 virtual void 143 print(std::ostream & =std::cout) const 144 { 145 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 146 } 147 virtual void 148 dump(std::ostream & =std::cout) const 149 { 150 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 151 } 152 virtual const char *kind() const { return "sc_signal"; } 153 154 protected: 155 virtual void 156 update() 157 { 158 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 159 } 160 161 // These members which store the current and future value of the signal 162 // are not specified in the standard but are referred to directly by one 163 // of the tests. 164 T m_cur_val; 165 T m_new_val; 166 167 private: 168 // Disabled 169 sc_signal(const sc_signal<T, WRITER_POLICY> &) : 170 sc_signal_inout_if<T>(), sc_prim_channel("") 171 {} 172}; 173 174template <class T, sc_writer_policy WRITER_POLICY> 175inline std::ostream & 176operator << (std::ostream &os, const sc_signal<T, WRITER_POLICY> &) 177{ 178 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 179 return os; 180} 181 182template <sc_writer_policy WRITER_POLICY> 183class sc_signal<bool, WRITER_POLICY> : 184 public sc_signal_inout_if<bool>, public sc_prim_channel 185{ 186 public: 187 sc_signal() 188 { 189 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 190 } 191 explicit sc_signal(const char *) 192 { 193 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 194 } 195 explicit sc_signal(const char *name, const bool &initial_value) : 196 sc_signal_inout_if<bool>(), sc_prim_channel(name) 197 { 198 // Need to consume initial_value. 199 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 200 } 201 virtual ~sc_signal() 202 { 203 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 204 } 205 206 virtual void 207 register_port(sc_port_base &, const char *) 208 { 209 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 210 } 211 212 virtual const bool & 213 read() const 214 { 215 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 216 return *(const bool *)nullptr; 217 } 218 operator const bool &() const 219 { 220 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 221 return *(const bool *)nullptr; 222 } 223 224 virtual sc_writer_policy 225 get_writer_policy() const 226 { 227 return WRITER_POLICY; 228 } 229 virtual void 230 write(const bool &) 231 { 232 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 233 } 234 sc_signal<bool, WRITER_POLICY> & 235 operator = (const bool &) 236 { 237 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 238 return *this; 239 } 240 sc_signal<bool, WRITER_POLICY> & 241 operator = (const sc_signal<bool, WRITER_POLICY> &) 242 { 243 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 244 return *this; 245 } 246 247 virtual const sc_event & 248 default_event() const 249 { 250 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 251 return *(sc_event *)nullptr; 252 } 253 254 virtual const sc_event & 255 value_changed_event() const 256 { 257 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 258 return *(sc_event *)nullptr; 259 } 260 virtual const sc_event & 261 posedge_event() const 262 { 263 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 264 return *(sc_event *)nullptr; 265 } 266 virtual const sc_event & 267 negedge_event() const 268 { 269 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 270 return *(sc_event *)nullptr; 271 } 272 273 virtual bool 274 event() const 275 { 276 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 277 return false; 278 } 279 virtual bool 280 posedge() const 281 { 282 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 283 return false; 284 } 285 virtual bool 286 negedge() const 287 { 288 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 289 return false; 290 } 291 292 virtual void 293 print(std::ostream & =std::cout) const 294 { 295 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 296 } 297 virtual void 298 dump(std::ostream & =std::cout) const 299 { 300 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 301 } 302 virtual const char *kind() const { return "sc_signal"; } 303 304 protected: 305 virtual void 306 update() 307 { 308 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 309 } 310 311 private: 312 // Disabled 313 sc_signal(const sc_signal<bool, WRITER_POLICY> &) : 314 sc_signal_inout_if<bool>(), sc_prim_channel("") 315 {} 316}; 317 318template <sc_writer_policy WRITER_POLICY> 319class sc_signal<sc_dt::sc_logic, WRITER_POLICY> : 320 public sc_signal_inout_if<sc_dt::sc_logic>, public sc_prim_channel 321{ 322 public: 323 sc_signal() 324 { 325 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 326 } 327 explicit sc_signal(const char *) 328 { 329 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 330 } 331 explicit sc_signal(const char *name, 332 const sc_dt::sc_logic &initial_value) : 333 sc_signal_inout_if<sc_dt::sc_logic>(), sc_prim_channel(name) 334 { 335 // Need to consume initial_value. 336 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 337 } 338 virtual ~sc_signal() 339 { 340 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 341 } 342 343 virtual void 344 register_port(sc_port_base &, const char *) 345 { 346 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 347 } 348 349 virtual const sc_dt::sc_logic & 350 read() const 351 { 352 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 353 return *(const sc_dt::sc_logic *)nullptr; 354 } 355 operator const sc_dt::sc_logic &() const 356 { 357 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 358 return *(const sc_dt::sc_logic *)nullptr; 359 } 360 361 virtual sc_writer_policy 362 get_writer_policy() const 363 { 364 return WRITER_POLICY; 365 } 366 virtual void 367 write(const sc_dt::sc_logic &) 368 { 369 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 370 } 371 sc_signal<sc_dt::sc_logic, WRITER_POLICY> & 372 operator = (const sc_dt::sc_logic &) 373 { 374 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 375 return *this; 376 } 377 sc_signal<sc_dt::sc_logic, WRITER_POLICY> & 378 operator = (const sc_signal<sc_dt::sc_logic, WRITER_POLICY> &) 379 { 380 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 381 return *this; 382 } 383 384 virtual const sc_event & 385 default_event() const 386 { 387 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 388 return *(sc_event *)nullptr; 389 } 390 391 virtual const sc_event & 392 value_changed_event() const 393 { 394 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 395 return *(sc_event *)nullptr; 396 } 397 virtual const sc_event & 398 posedge_event() const 399 { 400 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 401 return *(sc_event *)nullptr; 402 } 403 virtual const sc_event & 404 negedge_event() const 405 { 406 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 407 return *(sc_event *)nullptr; 408 } 409 410 virtual bool 411 event() const 412 { 413 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 414 return false; 415 } 416 virtual bool 417 posedge() const 418 { 419 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 420 return false; 421 } 422 virtual bool 423 negedge() const 424 { 425 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 426 return false; 427 } 428 429 virtual void 430 print(std::ostream & =std::cout) const 431 { 432 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 433 } 434 virtual void 435 dump(std::ostream & =std::cout) const 436 { 437 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 438 } 439 virtual const char *kind() const { return "sc_signal"; } 440 441 protected: 442 virtual void 443 update() 444 { 445 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 446 } 447 448 private: 449 // Disabled 450 sc_signal(const sc_signal<sc_dt::sc_logic, WRITER_POLICY> &) : 451 sc_signal_inout_if<sc_dt::sc_logic>(), sc_prim_channel("") 452 {} 453}; 454 455} // namespace sc_core 456 457#endif //__SYSTEMC_EXT_CHANNEL_SC_SIGNAL_HH__ 458