sc_module.cc revision 12951:9db2476bea4e 
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
38namespace sc_core
39{
40
41sc_bind_proxy::sc_bind_proxy(const sc_interface &_interface) :
42    _interface(&_interface), _port(nullptr)
43{}
44
45sc_bind_proxy::sc_bind_proxy(const sc_port_base &_port) :
46    _interface(nullptr), _port(&_port)
47{}
48
49const sc_bind_proxy SC_BIND_PROXY_NUL(*(const sc_port_base *)nullptr);
50
51sc_module::~sc_module() {}
52
53const sc_bind_proxy SC_BIND_PROXY_NIL(*(const sc_port_base *)nullptr);
54
55void
56sc_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
124const std::vector<sc_object *> &
125sc_module::get_child_objects() const
126{
127    return _gem5_module->obj()->get_child_objects();
128}
129
130const std::vector<sc_event *> &
131sc_module::get_child_events() const
132{
133    return _gem5_module->obj()->get_child_events();
134}
135
136sc_module::sc_module() :
137    sc_object(sc_gem5::currentModule()->name()),
138    _gem5_module(sc_gem5::currentModule())
139{}
140
141sc_module::sc_module(const sc_module_name &) : sc_module() {}
142sc_module::sc_module(const char *_name) : sc_module(sc_module_name(_name)) {}
143sc_module::sc_module(const std::string &_name) :
144    sc_module(sc_module_name(_name.c_str()))
145{}
146
147void
148sc_module::reset_signal_is(const sc_in<bool> &, bool)
149{
150    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
151}
152
153void
154sc_module::reset_signal_is(const sc_inout<bool> &, bool)
155{
156    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
157}
158
159void
160sc_module::reset_signal_is(const sc_out<bool> &, bool)
161{
162    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
163}
164
165void
166sc_module::reset_signal_is(const sc_signal_in_if<bool> &, bool)
167{
168    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
169}
170
171
172void
173sc_module::async_reset_signal_is(const sc_in<bool> &, bool)
174{
175    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
176}
177
178void
179sc_module::async_reset_signal_is(const sc_inout<bool> &, bool)
180{
181    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
182}
183
184void
185sc_module::async_reset_signal_is(const sc_out<bool> &, bool)
186{
187    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
188}
189
190void
191sc_module::async_reset_signal_is(const sc_signal_in_if<bool> &, bool)
192{
193    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
194}
195
196
197void
198sc_module::dont_initialize()
199{
200    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
201}
202
203void
204sc_module::set_stack_size(size_t)
205{
206    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
207}
208
209
210void sc_module::next_trigger() { ::sc_core::next_trigger(); }
211
212void
213sc_module::next_trigger(const sc_event &e)
214{
215    ::sc_core::next_trigger(e);
216}
217
218void
219sc_module::next_trigger(const sc_event_or_list &eol)
220{
221    ::sc_core::next_trigger(eol);
222}
223
224void
225sc_module::next_trigger(const sc_event_and_list &eal)
226{
227    ::sc_core::next_trigger(eal);
228}
229
230void
231sc_module::next_trigger(const sc_time &t)
232{
233    ::sc_core::next_trigger(t);
234}
235
236void
237sc_module::next_trigger(double d, sc_time_unit u)
238{
239    ::sc_core::next_trigger(d, u);
240}
241
242void
243sc_module::next_trigger(const sc_time &t, const sc_event &e)
244{
245    ::sc_core::next_trigger(t, e);
246}
247
248void
249sc_module::next_trigger(double d, sc_time_unit u, const sc_event &e)
250{
251    ::sc_core::next_trigger(d, u, e);
252}
253
254void
255sc_module::next_trigger(const sc_time &t, const sc_event_or_list &eol)
256{
257    ::sc_core::next_trigger(t, eol);
258}
259
260void
261sc_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
266void
267sc_module::next_trigger(const sc_time &t, const sc_event_and_list &eal)
268{
269    ::sc_core::next_trigger(t, eal);
270}
271
272void
273sc_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
279bool
280sc_module::timed_out()
281{
282    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
283    return false;
284}
285
286
287void
288sc_module::wait()
289{
290    ::sc_core::wait();
291}
292
293void
294sc_module::wait(int i)
295{
296    ::sc_core::wait(i);
297}
298
299void
300sc_module::wait(const sc_event &e)
301{
302    ::sc_core::wait(e);
303}
304
305void
306sc_module::wait(const sc_event_or_list &eol)
307{
308    ::sc_core::wait(eol);
309}
310
311void
312sc_module::wait(const sc_event_and_list &eal)
313{
314    ::sc_core::wait(eal);
315}
316
317void
318sc_module::wait(const sc_time &t)
319{
320    ::sc_core::wait(t);
321}
322
323void
324sc_module::wait(double d, sc_time_unit u)
325{
326    ::sc_core::wait(d, u);
327}
328
329void
330sc_module::wait(const sc_time &t, const sc_event &e)
331{
332    ::sc_core::wait(t, e);
333}
334
335void
336sc_module::wait(double d, sc_time_unit u, const sc_event &e)
337{
338    ::sc_core::wait(d, u, e);
339}
340
341void
342sc_module::wait(const sc_time &t, const sc_event_or_list &eol)
343{
344    ::sc_core::wait(t, eol);
345}
346
347void
348sc_module::wait(double d, sc_time_unit u, const sc_event_or_list &eol)
349{
350    ::sc_core::wait(d, u, eol);
351}
352
353void
354sc_module::wait(const sc_time &t, const sc_event_and_list &eal)
355{
356    ::sc_core::wait(t, eal);
357}
358
359void
360sc_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
366void
367sc_module::halt()
368{
369    ::sc_core::halt();
370}
371
372void
373sc_module::at_posedge(const sc_signal_in_if<bool> &s)
374{
375    ::sc_core::at_posedge(s);
376}
377
378void
379sc_module::at_posedge(const sc_signal_in_if<sc_dt::sc_logic> &s)
380{
381    ::sc_core::at_posedge(s);
382}
383
384void
385sc_module::at_negedge(const sc_signal_in_if<bool> &s)
386{
387    ::sc_core::at_negedge(s);
388}
389
390void
391sc_module::at_negedge(const sc_signal_in_if<sc_dt::sc_logic> &s)
392{
393    ::sc_core::at_negedge(s);
394}
395
396
397void
398next_trigger()
399{
400    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
401}
402
403void
404next_trigger(const sc_event &)
405{
406    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
407}
408
409void
410next_trigger(const sc_event_or_list &)
411{
412    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
413}
414
415void
416next_trigger(const sc_event_and_list &)
417{
418    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
419}
420
421void
422next_trigger(const sc_time &)
423{
424    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
425}
426
427void
428next_trigger(double d, sc_time_unit u)
429{
430    next_trigger(sc_time(d, u));
431}
432
433void
434next_trigger(const sc_time &, const sc_event &)
435{
436    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
437}
438
439void
440next_trigger(double d, sc_time_unit u, const sc_event &e)
441{
442    next_trigger(sc_time(d, u), e);
443}
444
445void
446next_trigger(const sc_time &, const sc_event_or_list &)
447{
448    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
449}
450
451void
452next_trigger(double d, sc_time_unit u, const sc_event_or_list &eol)
453{
454    next_trigger(sc_time(d, u), eol);
455}
456
457void
458next_trigger(const sc_time &, const sc_event_and_list &)
459{
460    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
461}
462
463void
464next_trigger(double d, sc_time_unit u, const sc_event_and_list &eal)
465{
466    next_trigger(sc_time(d, u), eal);
467}
468
469bool
470timed_out()
471{
472    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
473    return false;
474}
475
476
477void
478wait()
479{
480    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
481}
482
483void
484wait(int)
485{
486    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
487}
488
489void
490wait(const sc_event &)
491{
492    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
493}
494
495void
496wait(const sc_event_or_list &)
497{
498    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
499}
500
501void
502wait(const sc_event_and_list &)
503{
504    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
505}
506
507void
508wait(const sc_time &)
509{
510    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
511}
512
513void
514wait(double d, sc_time_unit u)
515{
516    wait(sc_time(d, u));
517}
518
519void
520wait(const sc_time &, const sc_event &)
521{
522    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
523}
524
525void
526wait(double d, sc_time_unit u, const sc_event &e)
527{
528    wait(sc_time(d, u), e);
529}
530
531void
532wait(const sc_time &, const sc_event_or_list &)
533{
534    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
535}
536
537void
538wait(double d, sc_time_unit u, const sc_event_or_list &eol)
539{
540    wait(sc_time(d, u), eol);
541}
542
543void
544wait(const sc_time &, const sc_event_and_list &)
545{
546    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
547}
548
549void
550wait(double d, sc_time_unit u, const sc_event_and_list &eal)
551{
552    wait(sc_time(d, u), eal);
553}
554
555void
556halt()
557{
558    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
559}
560
561void
562at_posedge(const sc_signal_in_if<bool> &)
563{
564    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
565}
566
567void
568at_posedge(const sc_signal_in_if<sc_dt::sc_logic> &)
569{
570    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
571}
572
573void
574at_negedge(const sc_signal_in_if<bool> &)
575{
576    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
577}
578
579void
580at_negedge(const sc_signal_in_if<sc_dt::sc_logic> &)
581{
582    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
583}
584
585const char *
586sc_gen_unique_name(const char *)
587{
588    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
589    return "";
590}
591
592bool
593sc_hierarchical_name_exists(const char *name)
594{
595    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
596    return false;
597}
598
599bool
600sc_start_of_simulation_invoked()
601{
602    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
603    return false;
604}
605
606bool
607sc_end_of_simulation_invoked()
608{
609    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
610    return false;
611}
612
613sc_module *
614sc_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
622