| /* |
| * Copyright 2018 Google, Inc. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are |
| * met: redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer; |
| * redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution; |
| * neither the name of the copyright holders nor the names of its |
| * contributors may be used to endorse or promote products derived from |
| * this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| * Authors: Gabe Black |
| */ |
| |
| #include "systemc/utils/vcd.hh" |
| |
| #include <ctime> |
| #include <iomanip> |
| |
| #include "base/bitfield.hh" |
| #include "base/cprintf.hh" |
| #include "base/logging.hh" |
| #include "systemc/core/scheduler.hh" |
| #include "systemc/ext/core/sc_event.hh" |
| #include "systemc/ext/core/sc_main.hh" |
| #include "systemc/ext/core/sc_time.hh" |
| #include "systemc/ext/dt/bit/sc_bv_base.hh" |
| #include "systemc/ext/dt/bit/sc_logic.hh" |
| #include "systemc/ext/dt/bit/sc_lv_base.hh" |
| #include "systemc/ext/dt/fx/sc_fxnum.hh" |
| #include "systemc/ext/dt/fx/sc_fxval.hh" |
| #include "systemc/ext/dt/int/sc_int_base.hh" |
| #include "systemc/ext/dt/int/sc_signed.hh" |
| #include "systemc/ext/dt/int/sc_uint_base.hh" |
| #include "systemc/ext/dt/int/sc_unsigned.hh" |
| #include "systemc/ext/utils/functions.hh" |
| |
| namespace sc_gem5 |
| { |
| |
| namespace |
| { |
| |
| std::string |
| cleanName(std::string name) |
| { |
| for (int i = 0; i < name.length(); i++) { |
| if (name[i] == '[') |
| name[i] = '('; |
| else if (name[i] == ']') |
| name[i] = ')'; |
| } |
| return name; |
| } |
| |
| } // anonymous namespace |
| |
| class VcdTraceValBase : public TraceValBase |
| { |
| protected: |
| std::string _vcdName; |
| |
| const char * |
| stripLeadingBits(const char *orig) |
| { |
| const char first = orig[0]; |
| |
| if (first != 'z' && first != 'x' && first != '0') |
| return orig; |
| |
| const char *res = orig; |
| while (*++res == first) {} |
| |
| if (first != '0' || *res != '1') |
| res--; |
| |
| return res; |
| } |
| |
| char |
| scLogicToVcdState(char in) |
| { |
| switch (in) { |
| case 'U': |
| case 'X': |
| case 'W': |
| case 'D': |
| return 'x'; |
| case '0': |
| case 'L': |
| return '0'; |
| case '1': |
| case 'H': |
| return '1'; |
| case 'Z': |
| return 'z'; |
| default: |
| return '?'; |
| } |
| } |
| |
| void |
| printVal(std::ostream &os, const std::string &rep) |
| { |
| switch (width()) { |
| case 0: |
| return; |
| case 1: |
| os << rep << vcdName() << std::endl;; |
| return; |
| default: |
| os << "b" << stripLeadingBits(rep.c_str()) << " " << |
| vcdName() << std::endl; |
| return; |
| } |
| } |
| |
| public: |
| VcdTraceValBase(int width) : TraceValBase(width) {} |
| ~VcdTraceValBase() {} |
| |
| void vcdName(const std::string &vcd_name) { _vcdName = vcd_name; } |
| const std::string &vcdName() { return _vcdName; } |
| virtual std::string vcdType() { return "wire"; } |
| |
| virtual void output(std::ostream &os) = 0; |
| }; |
| |
| void |
| VcdTraceScope::addValue(const std::string &name, VcdTraceValBase *value) |
| { |
| size_t pos = name.find_first_of('.'); |
| if (pos == std::string::npos) { |
| values.emplace_back(name, value); |
| } else { |
| std::string sname = name.substr(0, pos); |
| auto it = scopes.find(sname); |
| if (it == scopes.end()) |
| it = scopes.emplace(sname, new VcdTraceScope).first; |
| it->second->addValue(name.substr(pos + 1), value); |
| } |
| } |
| |
| void |
| VcdTraceScope::output(const std::string &name, std::ostream &os) |
| { |
| os << "$scope module " << name << " $end" << std::endl; |
| |
| for (auto &p: values) { |
| const std::string &name = p.first; |
| VcdTraceValBase *value = p.second; |
| |
| int w = value->width(); |
| if (w <= 0) { |
| std::string msg = csprintf("'%s' has 0 bits", name); |
| // The typo in this error message is intentional to match the |
| // Accellera output. |
| SC_REPORT_ERROR("(E710) object cannot not be traced", msg.c_str()); |
| return; |
| } |
| |
| std::string clean_name = cleanName(name); |
| if (w == 1) { |
| ccprintf(os, "$var %s % 3d %s %s $end\n", |
| value->vcdType(), w, value->vcdName(), clean_name); |
| } else { |
| ccprintf(os, "$var %s % 3d %s %s [%d:0] $end\n", |
| value->vcdType(), w, value->vcdName(), clean_name, w - 1); |
| } |
| } |
| |
| for (auto &p: scopes) |
| p.second->output(p.first, os); |
| |
| os << "$upscope $end" << std::endl; |
| } |
| |
| template <typename T> |
| class VcdTraceVal : public TraceVal<T, VcdTraceValBase> |
| { |
| public: |
| typedef T TracedType; |
| |
| VcdTraceVal(const T* t, const std::string &vcd_name, int width) : |
| TraceVal<T, VcdTraceValBase>(t, width) |
| { |
| this->vcdName(vcd_name); |
| } |
| }; |
| |
| std::string |
| VcdTraceFile::nextSignalName() |
| { |
| std::string name(_nextName); |
| |
| bool carry = false; |
| int pos = NextNameChars - 1; |
| do { |
| carry = (_nextName[pos] == 'z'); |
| if (carry) |
| _nextName[pos--] = 'a'; |
| else |
| _nextName[pos--]++; |
| } while (carry && pos >= 0); |
| |
| return name; |
| } |
| |
| void |
| VcdTraceFile::initialize() |
| { |
| finalizeTime(); |
| |
| // Date. |
| stream() << "$date" << std::endl; |
| time_t long_time; |
| time(&long_time); |
| struct tm *p_tm = localtime(&long_time); |
| stream() << std::put_time(p_tm, " %b %d, %Y %H:%M:%S\n"); |
| stream() << "$end" << std::endl << std::endl; |
| |
| // Version. |
| stream() << "$version" << std::endl; |
| stream() << " " << ::sc_core::sc_version() << std::endl; |
| stream() << "$end" << std::endl << std::endl; |
| |
| // Timescale. |
| stream() << "$timescale" << std::endl; |
| stream() << " " << ::sc_core::sc_time::from_value(timeUnitTicks) << |
| std::endl; |
| stream() << "$end" << std::endl << std::endl; |
| |
| for (auto tv: traceVals) |
| tv->finalize(); |
| |
| topScope.output("SystemC", stream()); |
| |
| stream() << "$enddefinitions $end" << std::endl << std::endl; |
| |
| Tick now = scheduler.getCurTick(); |
| |
| std::string timedump_comment = |
| csprintf("All initial values are dumped below at time " |
| "%g sec = %g timescale units.", |
| static_cast<double>(now) / SimClock::Float::s, |
| static_cast<double>(now / timeUnitTicks)); |
| writeComment(timedump_comment); |
| |
| lastPrintedTime = now / timeUnitTicks; |
| |
| stream() << "$dumpvars" << std::endl; |
| for (auto tv: traceVals) |
| tv->output(stream()); |
| stream() << "$end" << std::endl << std::endl; |
| |
| initialized = true; |
| } |
| |
| VcdTraceFile::~VcdTraceFile() |
| { |
| for (auto tv: traceVals) |
| delete tv; |
| traceVals.clear(); |
| |
| if (timeUnitTicks) |
| ccprintf(stream(), "#%u\n", scheduler.getCurTick() / timeUnitTicks); |
| } |
| |
| void |
| VcdTraceFile::trace(bool delta) |
| { |
| if (!delta) |
| deltasAtNow = 0; |
| |
| uint64_t deltaOffset = deltasAtNow; |
| |
| if (delta) |
| deltaOffset = deltasAtNow++; |
| |
| if (_traceDeltas != delta) |
| return; |
| |
| if (!initialized) { |
| initialize(); |
| return; |
| } |
| |
| Tick now = scheduler.getCurTick() / timeUnitTicks + deltaOffset; |
| |
| if (now <= lastPrintedTime) { |
| // TODO warn about reversed time? |
| return; |
| } |
| |
| bool time_printed = false; |
| for (auto tv: traceVals) { |
| if (tv->check()) { |
| if (!time_printed) { |
| lastPrintedTime = now; |
| ccprintf(stream(), "#%u\n", now); |
| time_printed = true; |
| } |
| |
| tv->output(stream()); |
| } |
| } |
| if (time_printed) |
| stream() << std::endl; |
| } |
| |
| class VcdTraceValBool : public VcdTraceVal<bool> |
| { |
| public: |
| using VcdTraceVal<bool>::VcdTraceVal; |
| |
| void |
| output(std::ostream &os) override |
| { |
| printVal(os, this->value() ? "1" : "0"); |
| } |
| }; |
| |
| void |
| VcdTraceFile::addTraceVal(const bool *v, const std::string &name) |
| { |
| addNewTraceVal<VcdTraceValBool>(v, name); |
| } |
| |
| template <typename T> |
| class VcdTraceValFloat : public VcdTraceVal<T> |
| { |
| public: |
| using VcdTraceVal<T>::VcdTraceVal; |
| |
| std::string vcdType() override { return "real"; } |
| |
| void |
| output(std::ostream &os) override |
| { |
| ccprintf(os, "r%.16g %s\n", this->value(), this->vcdName()); |
| } |
| }; |
| |
| void |
| VcdTraceFile::addTraceVal(const float *v, const std::string &name) |
| { |
| addNewTraceVal<VcdTraceValFloat<float>>(v, name); |
| } |
| void |
| VcdTraceFile::addTraceVal(const double *v, const std::string &name) |
| { |
| addNewTraceVal<VcdTraceValFloat<double>>(v, name); |
| } |
| |
| class VcdTraceValScLogic : public VcdTraceVal<sc_dt::sc_logic> |
| { |
| public: |
| using VcdTraceVal<sc_dt::sc_logic>::VcdTraceVal; |
| |
| void |
| output(std::ostream &os) override |
| { |
| char str[2] = { |
| scLogicToVcdState(value().to_char()), |
| '\0' |
| }; |
| printVal(os, str); |
| } |
| }; |
| |
| void |
| VcdTraceFile::addTraceVal(const sc_dt::sc_logic *v, const std::string &name) |
| { |
| addNewTraceVal<VcdTraceValScLogic>(v, name); |
| } |
| |
| template <typename T> |
| class VcdTraceValFinite : public VcdTraceVal<T> |
| { |
| public: |
| using VcdTraceVal<T>::VcdTraceVal; |
| |
| void |
| finalize() override |
| { |
| VcdTraceVal<T>::finalize(); |
| this->_width = this->value().length(); |
| } |
| |
| void |
| output(std::ostream &os) override |
| { |
| std::string str; |
| const int w = this->width(); |
| |
| str.reserve(w); |
| for (int i = w - 1; i >= 0; i--) |
| str += this->value()[i].to_bool() ? '1' : '0'; |
| |
| this->printVal(os, str); |
| } |
| }; |
| |
| void |
| VcdTraceFile::addTraceVal(const sc_dt::sc_int_base *v, |
| const std::string &name) |
| { |
| addNewTraceVal<VcdTraceValFinite<sc_dt::sc_int_base>>(v, name); |
| } |
| void |
| VcdTraceFile::addTraceVal(const sc_dt::sc_uint_base *v, |
| const std::string &name) |
| { |
| addNewTraceVal<VcdTraceValFinite<sc_dt::sc_uint_base>>(v, name); |
| } |
| |
| void |
| VcdTraceFile::addTraceVal(const sc_dt::sc_signed *v, const std::string &name) |
| { |
| addNewTraceVal<VcdTraceValFinite<sc_dt::sc_signed>>(v, name); |
| } |
| void |
| VcdTraceFile::addTraceVal(const sc_dt::sc_unsigned *v, |
| const std::string &name) |
| { |
| addNewTraceVal<VcdTraceValFinite<sc_dt::sc_unsigned>>(v, name); |
| } |
| |
| template <typename T> |
| class VcdTraceValLogic : public VcdTraceVal<T> |
| { |
| public: |
| using VcdTraceVal<T>::VcdTraceVal; |
| |
| void |
| finalize() override |
| { |
| VcdTraceVal<T>::finalize(); |
| this->_width = this->value().length(); |
| } |
| |
| void |
| output(std::ostream &os) override |
| { |
| this->printVal(os, this->value().to_string()); |
| } |
| }; |
| |
| void |
| VcdTraceFile::addTraceVal(const sc_dt::sc_bv_base *v, const std::string &name) |
| { |
| addNewTraceVal<VcdTraceValLogic<::sc_dt::sc_bv_base>>(v, name); |
| } |
| void |
| VcdTraceFile::addTraceVal(const sc_dt::sc_lv_base *v, const std::string &name) |
| { |
| addNewTraceVal<VcdTraceValLogic<::sc_dt::sc_lv_base>>(v, name); |
| } |
| |
| template <typename T> |
| class VcdTraceValFxval : public VcdTraceVal<T> |
| { |
| public: |
| using VcdTraceVal<T>::VcdTraceVal; |
| |
| std::string vcdType() override { return "real"; } |
| |
| void |
| output(std::ostream &os) override |
| { |
| ccprintf(os, "r%.16g %s\n", |
| this->value().to_double(), this->vcdName()); |
| } |
| }; |
| |
| void |
| VcdTraceFile::addTraceVal(const sc_dt::sc_fxval *v, const std::string &name) |
| { |
| addNewTraceVal<VcdTraceValFxval<sc_dt::sc_fxval>>(v, name); |
| } |
| void |
| VcdTraceFile::addTraceVal(const sc_dt::sc_fxval_fast *v, |
| const std::string &name) |
| { |
| addNewTraceVal<VcdTraceValFxval<sc_dt::sc_fxval_fast>>(v, name); |
| } |
| |
| template <typename T> |
| class VcdTraceValFxnum : public VcdTraceVal<T> |
| { |
| public: |
| using VcdTraceVal<T>::VcdTraceVal; |
| |
| void |
| output(std::ostream &os) override |
| { |
| std::string str; |
| const int w = this->width(); |
| |
| str.reserve(w); |
| for (int i = w - 1; i >= 0; i--) |
| str += this->value()[i] ? '1' : '0'; |
| |
| this->printVal(os, str); |
| } |
| }; |
| |
| void |
| VcdTraceFile::addTraceVal(const sc_dt::sc_fxnum *v, const std::string &name) |
| { |
| addNewTraceVal<VcdTraceValFxnum<::sc_dt::sc_fxnum>>(v, name); |
| } |
| void |
| VcdTraceFile::addTraceVal(const sc_dt::sc_fxnum_fast *v, |
| const std::string &name) |
| { |
| addNewTraceVal<VcdTraceValFxnum<::sc_dt::sc_fxnum_fast>>(v, name); |
| } |
| |
| class VcdTraceValEvent : public VcdTraceVal<::sc_core::sc_event> |
| { |
| public: |
| using VcdTraceVal<::sc_core::sc_event>::VcdTraceVal; |
| |
| std::string vcdType() override { return "event"; } |
| |
| void |
| output(std::ostream &os) override |
| { |
| if (value()) |
| printVal(os, "1"); |
| else |
| os << std::endl; |
| } |
| }; |
| |
| void |
| VcdTraceFile::addTraceVal(const sc_core::sc_event *v, const std::string &name) |
| { |
| addNewTraceVal<VcdTraceValEvent>(v, name); |
| } |
| |
| class VcdTraceValTime : public VcdTraceVal<::sc_core::sc_time> |
| { |
| private: |
| static const int TimeWidth = 64; |
| |
| public: |
| using VcdTraceVal<::sc_core::sc_time>::VcdTraceVal; |
| |
| std::string vcdType() override { return "time"; } |
| |
| void |
| finalize() override |
| { |
| VcdTraceVal<::sc_core::sc_time>::finalize(); |
| _width = TimeWidth; |
| } |
| |
| void |
| output(std::ostream &os) override |
| { |
| char str[TimeWidth + 1]; |
| str[TimeWidth] = '\0'; |
| |
| const uint64_t val = value().value(); |
| for (int i = 0; i < TimeWidth; i++) |
| str[i] = ::bits(val, TimeWidth - i - 1) ? '1' : '0'; |
| |
| printVal(os, str); |
| } |
| }; |
| void |
| VcdTraceFile::addTraceVal(const sc_core::sc_time *v, const std::string &name) |
| { |
| addNewTraceVal<VcdTraceValTime>(v, name); |
| } |
| |
| template <typename T> |
| class VcdTraceValInt : public VcdTraceVal<T> |
| { |
| public: |
| using VcdTraceVal<T>::VcdTraceVal; |
| |
| void |
| output(std::ostream &os) override |
| { |
| const int w = this->width(); |
| char str[w + 1]; |
| str[w] = '\0'; |
| |
| const uint64_t val = |
| static_cast<uint64_t>(this->value()) & ::mask(sizeof(T) * 8); |
| |
| if (::mask(w) < val) { |
| for (int i = 0; i < w; i++) |
| str[i] = 'x'; |
| } else { |
| for (int i = 0; i < w; i++) |
| str[i] = ::bits(val, w - i - 1) ? '1' : '0'; |
| } |
| |
| this->printVal(os, str); |
| } |
| }; |
| |
| void |
| VcdTraceFile::addTraceVal(const unsigned char *v, const std::string &name, |
| int width) |
| { |
| addNewTraceVal<VcdTraceValInt<unsigned char>>(v, name, width); |
| } |
| void |
| VcdTraceFile::addTraceVal(const char *v, const std::string &name, int width) |
| { |
| addNewTraceVal<VcdTraceValInt<char>>(v, name, width); |
| } |
| void |
| VcdTraceFile::addTraceVal(const unsigned short *v, const std::string &name, |
| int width) |
| { |
| addNewTraceVal<VcdTraceValInt<unsigned short>>(v, name, width); |
| } |
| void |
| VcdTraceFile::addTraceVal(const short *v, const std::string &name, int width) |
| { |
| addNewTraceVal<VcdTraceValInt<short>>(v, name, width); |
| } |
| void |
| VcdTraceFile::addTraceVal(const unsigned int *v, const std::string &name, |
| int width) |
| { |
| addNewTraceVal<VcdTraceValInt<unsigned int>>(v, name, width); |
| } |
| void |
| VcdTraceFile::addTraceVal(const int *v, const std::string &name, int width) |
| { |
| addNewTraceVal<VcdTraceValInt<int>>(v, name, width); |
| } |
| void |
| VcdTraceFile::addTraceVal(const unsigned long *v, const std::string &name, |
| int width) |
| { |
| addNewTraceVal<VcdTraceValInt<unsigned long>>(v, name, width); |
| } |
| void |
| VcdTraceFile::addTraceVal(const long *v, const std::string &name, int width) |
| { |
| addNewTraceVal<VcdTraceValInt<long>>(v, name, width); |
| } |
| |
| void |
| VcdTraceFile::addTraceVal(const sc_dt::int64 *v, const std::string &name, |
| int width) |
| { |
| addNewTraceVal<VcdTraceValInt<sc_dt::int64>>(v, name, width); |
| } |
| void |
| VcdTraceFile::addTraceVal(const sc_dt::uint64 *v, const std::string &name, |
| int width) |
| { |
| addNewTraceVal<VcdTraceValInt<sc_dt::uint64>>(v, name, width); |
| } |
| |
| void |
| VcdTraceFile::addTraceVal(const unsigned int *v, const std::string &name, |
| const char **literals) |
| { |
| uint64_t count = 0; |
| while (*literals++) |
| count++; |
| |
| int bits = 0; |
| while (count >> bits) |
| bits++; |
| |
| addNewTraceVal<VcdTraceValInt<unsigned int>>(v, name, bits); |
| } |
| |
| void |
| VcdTraceFile::writeComment(const std::string &comment) |
| { |
| stream() << "$comment" << std::endl; |
| stream() << comment << std::endl; |
| stream() << "$end" << std::endl << std::endl; |
| } |
| |
| } // namespace sc_gem5 |