diff --git a/src/ordt/output/cppmod/CppModBuilder.java b/src/ordt/output/cppmod/CppModBuilder.java index be3b74e..21b8efa 100644 --- a/src/ordt/output/cppmod/CppModBuilder.java +++ b/src/ordt/output/cppmod/CppModBuilder.java @@ -222,7 +222,7 @@ public void write(String outName, String description, String commentPrefix) { writeStmt(commonHppBw, 0, "#include "); // min/max writeStmt(commonHppBw, 0, "#include "); writeStmt(commonHppBw, 0, "#include "); - writeStmt(commonHppBw, 0, "#define quote(x) #x"); // for debug display of vars + writeStmt(commonHppBw, 0, "#define quote(x) #x"); // for debug display of vars writeStmt(commonHppBw, 0, ""); // write the cpp file header @@ -236,7 +236,7 @@ public void write(String outName, String description, String commentPrefix) { writeStmts(commonHppBw, newClass.genMethods(true, true)); // template methods with namespace writeStmts(commonCppBw, newClass.genMethods(true)); // non-template methods with namespace - // close up hpp file + // close up hpp file writeStmt(commonHppBw, 0, "#endif // __ORDT_PIO_COMMON_HPP_INCLUDED__"); closeBufferedWriter(commonHppBw); @@ -256,14 +256,20 @@ public void write(String outName, String description, String commentPrefix) { writeStmt(hppBw, 0, ""); writeStmt(hppBw, 0, "#include "); writeStmt(hppBw, 0, "#include "); - writeStmt(hppBw, 0, "#include "); // unique_ptr, etc g++ + writeStmt(hppBw, 0, "#include "); // unique_ptr, etc g++ writeStmt(hppBw, 0, "#include "); writeStmt(hppBw, 0, "#include "); // min/max writeStmt(hppBw, 0, "#include "); writeStmt(hppBw, 0, "#include "); - writeStmt(hppBw, 0, "#include "); // reg mutex - writeStmt(hppBw, 0, "#include "); // field data atomic - writeStmt(hppBw, 0, "#define quote(x) #x"); // for debug display of vars + writeStmt(hppBw, 0, "#include "); // reg mutex + writeStmt(hppBw, 0, "#include "); // field data atomic + writeStmt(hppBw, 0, "#include "); // callback functions + writeStmt(hppBw, 0, "#include "); + writeStmt(hppBw, 0, "#define quote(x) #x"); // for debug display of vars + writeStmt(hppBw, 0, ""); + writeStmt(hppBw, 0, "#ifdef ORDT_NAMESPACE"); + writeStmt(hppBw, 0, "namespace ORDT_NAMESPACE {"); + writeStmt(hppBw, 0, "#endif"); writeStmt(hppBw, 0, ""); // write the cpp file header @@ -275,11 +281,35 @@ public void write(String outName, String description, String commentPrefix) { // define r/w modes writeStmt(hppBw, 0, "enum ordt_read_mode_t : uint8_t {r_none, r_std, r_clr};"); writeStmt(hppBw, 0, "enum ordt_write_mode_t : uint8_t {w_none, w_std, w_1clr, w_1set};"); + writeStmt(hppBw, 0, ""); + + // define callback types + writeStmt(hppBw, 0, "enum ordt_cb_result_t {"); + writeStmt(hppBw, 0, " cb_ok, // run to completion and respond as usual"); + writeStmt(hppBw, 0, " cb_abort, // return immediately and respond as usual"); + writeStmt(hppBw, 0, " cb_abort_ok, // return immediately with good response"); + writeStmt(hppBw, 0, " cb_abort_err, // return immediately with error response"); + writeStmt(hppBw, 0, " cb_force_ok, // run to completion and return good response"); + writeStmt(hppBw, 0, " cb_force_err, // run to completion and return error response"); + writeStmt(hppBw, 0, "};"); + writeStmt(hppBw, 0, "class ordt_addr_elem;"); + writeStmt(hppBw, 0, "//XXX Is it a good idea to provide the write data?"); + writeStmt(hppBw, 0, "typedef std::function<"); + writeStmt(hppBw, 0, " ordt_cb_result_t(ordt_addr_elem &, const uint64_t &, const ordt_data &)>"); + writeStmt(hppBw, 0, " ordt_write_cb_t;"); + writeStmt(hppBw, 0, "//XXX Allow the callback to return read data?"); + writeStmt(hppBw, 0, "typedef std::function<"); + writeStmt(hppBw, 0, " ordt_cb_result_t(ordt_addr_elem &, const uint64_t &)> ordt_read_cb_t;"); + writeStmt(hppBw, 0, ""); // write the model classes writeClasses(); - // close up hpp file + // close up hpp file + writeStmt(hppBw, 0, "#ifdef ORDT_NAMESPACE"); + writeStmt(hppBw, 0, "}"); + writeStmt(hppBw, 0, "#endif"); + writeStmt(hppBw, 0, "#endif // __ORDT_PIO_HPP_INCLUDED__"); closeBufferedWriter(hppBw); @@ -316,13 +346,82 @@ private void writeOrdtAddrElemClass() { CppModClass newClass = new CppModClass(className); newClass.addDefine(Vis.PROTECTED, "uint64_t m_startaddress"); newClass.addDefine(Vis.PROTECTED, "uint64_t m_endaddress"); + newClass.addDefine(Vis.PROTECTED, "int m_response"); + newClass.addDefine(Vis.PROTECTED, "bool m_response_forced"); + newClass.addDefine(Vis.PROTECTED, "std::list m_pre_write_cbs"); + newClass.addDefine(Vis.PROTECTED, "std::list m_post_write_cbs"); + newClass.addDefine(Vis.PROTECTED, "std::list m_pre_read_cbs"); + newClass.addDefine(Vis.PROTECTED, "std::list m_post_read_cbs"); // constructors CppMethod nMethod = newClass.addConstructor(Vis.PUBLIC, className + "(uint64_t _m_startaddress, uint64_t _m_endaddress)"); nMethod.addInitCall("m_startaddress(_m_startaddress)"); nMethod.addInitCall("m_endaddress(_m_endaddress)"); + nMethod.addInitCall("m_response(0)"); + nMethod.addInitCall("m_response_forced(false)"); + nMethod.addInitCall("m_pre_write_cbs()"); + nMethod.addInitCall("m_post_write_cbs()"); + nMethod.addInitCall("m_pre_read_cbs()"); + nMethod.addInitCall("m_post_read_cbs()"); // methods - newClass.addMethod(Vis.PUBLIC, "pure virtual int write(const uint64_t &addr, const ordt_data &wdata)"); - newClass.addMethod(Vis.PUBLIC, "pure virtual int read(const uint64_t &addr, ordt_data &rdata)"); + nMethod = newClass.addMethod(Vis.PROTECTED, "virtual bool pre_write(const uint64_t &addr, const ordt_data &wdata)"); + nMethod.addStatement("for (auto const& cb : m_pre_write_cbs) {"); + nMethod.addStatement(" ordt_cb_result_t cb_result = cb(*this, addr, wdata);"); + nMethod.addStatement(" bool return_now = interpret_cb_result(cb_result);"); + nMethod.addStatement(" if (return_now) return true;"); + nMethod.addStatement("}"); + nMethod.addStatement("return false;"); + + nMethod = newClass.addMethod(Vis.PROTECTED, "virtual bool post_write(const uint64_t &addr, const ordt_data &wdata)"); + nMethod.addStatement("for (auto const& cb : m_post_write_cbs) {"); + nMethod.addStatement(" ordt_cb_result_t cb_result = cb(*this, addr, wdata);"); + nMethod.addStatement(" bool return_now = interpret_cb_result(cb_result);"); + nMethod.addStatement(" if (return_now) return true;"); + nMethod.addStatement("}"); + nMethod.addStatement("return false;"); + + nMethod = newClass.addMethod(Vis.PROTECTED, "virtual bool pre_read(const uint64_t &addr)"); + nMethod.addStatement("for (auto const& cb : m_pre_read_cbs) {"); + nMethod.addStatement(" ordt_cb_result_t cb_result = cb(*this, addr);"); + nMethod.addStatement(" bool return_now = interpret_cb_result(cb_result);"); + nMethod.addStatement(" if (return_now) return true;"); + nMethod.addStatement("}"); + nMethod.addStatement("return false;"); + + nMethod = newClass.addMethod(Vis.PROTECTED, "virtual bool post_read(const uint64_t &addr)"); + nMethod.addStatement("for (auto const& cb : m_post_read_cbs) {"); + nMethod.addStatement(" ordt_cb_result_t cb_result = cb(*this, addr);"); + nMethod.addStatement(" bool return_now = interpret_cb_result(cb_result);"); + nMethod.addStatement(" if (return_now) return true;"); + nMethod.addStatement("}"); + nMethod.addStatement("return false;"); + + newClass.addMethod(Vis.PROTECTED, "pure virtual int write_body(const uint64_t &addr, const ordt_data &wdata)"); + newClass.addMethod(Vis.PROTECTED, "pure virtual int read_body(const uint64_t &addr, ordt_data &rdata)"); + + nMethod = newClass.addMethod(Vis.PUBLIC, "virtual int write(const uint64_t &addr, const ordt_data &wdata)"); + nMethod.addStatement("m_response = 0;"); + nMethod.addStatement("m_response_forced = false;"); + nMethod.addStatement("bool return_now = false;"); + nMethod.addStatement("return_now = pre_write(addr, wdata);"); + nMethod.addStatement("if (return_now) return m_response;"); + nMethod.addStatement("int body_response = write_body(addr, wdata);"); + nMethod.addStatement("if (!m_response_forced)"); + nMethod.addStatement(" m_response |= body_response;"); + nMethod.addStatement("post_write(addr, wdata);"); + nMethod.addStatement("return m_response;"); + + nMethod = newClass.addMethod(Vis.PUBLIC, "virtual int read(const uint64_t &addr, ordt_data &rdata)"); + nMethod.addStatement("m_response = 0;"); + nMethod.addStatement("m_response_forced = false;"); + nMethod.addStatement("bool return_now = false;"); + nMethod.addStatement("return_now = pre_read(addr);"); + nMethod.addStatement("if (return_now) return m_response;"); + nMethod.addStatement("int body_response = read_body(addr, rdata);"); + nMethod.addStatement("if (!m_response_forced)"); + nMethod.addStatement(" m_response |= body_response;"); + nMethod.addStatement("post_read(addr);"); + nMethod.addStatement("return m_response;"); + nMethod = newClass.addMethod(Vis.PUBLIC, "bool containsAddress(const uint64_t &addr)"); //nMethod.addStatement("std::cout << \"ordt_addr_elem containsAddress: addr=\"<< addr << \" start=\" << m_startaddress << \" end=\" << m_endaddress << \"\\n\";"); nMethod.addStatement("return ((addr >= m_startaddress) && (addr <= m_endaddress));"); @@ -336,6 +435,45 @@ private void writeOrdtAddrElemClass() { //nMethod.addStatement("std::cout << \"ordt_addr_elem hasStartAddress: addr=\"<< addr << \" start=\" << m_startaddress << \" end=\" << m_endaddress << \"\\n\";"); nMethod.addStatement("return (addr == m_startaddress);"); nMethod = newClass.addMethod(Vis.PUBLIC, "virtual void update_child_ptrs()"); // empty placeholder defined in design-specific regset classes - called after elem copy in jdrl_addr_elem_array to fix pointers + nMethod = newClass.addMethod(Vis.PUBLIC, "virtual void register_pre_write_cb(const ordt_write_cb_t &cb)"); + nMethod.addStatement("m_pre_write_cbs.push_back(cb);"); + nMethod = newClass.addMethod(Vis.PUBLIC, "virtual void register_post_write_cb(const ordt_write_cb_t &cb)"); + nMethod.addStatement("m_post_write_cbs.push_back(cb);"); + nMethod = newClass.addMethod(Vis.PUBLIC, "virtual void register_pre_read_cb(const ordt_read_cb_t &cb)"); + nMethod.addStatement("m_pre_read_cbs.push_back(cb);"); + nMethod = newClass.addMethod(Vis.PUBLIC, "virtual void register_post_read_cb(const ordt_read_cb_t &cb)"); + nMethod.addStatement("m_post_read_cbs.push_back(cb);"); + nMethod = newClass.addMethod(Vis.PRIVATE, "bool interpret_cb_result(const ordt_cb_result_t cb_result)"); + nMethod.addStatement("bool return_now = false;"); + nMethod.addStatement("switch(cb_result) {"); + nMethod.addStatement("case cb_ok:"); + nMethod.addStatement(" break;"); + nMethod.addStatement("case cb_abort:"); + nMethod.addStatement(" return_now = true;"); + nMethod.addStatement(" break;"); + nMethod.addStatement("case cb_abort_ok:"); + nMethod.addStatement(" return_now = true;"); + nMethod.addStatement(" m_response = 0;"); + nMethod.addStatement(" break;"); + nMethod.addStatement("case cb_abort_err:"); + nMethod.addStatement(" return_now = true;"); + nMethod.addStatement(" m_response = 8;"); + nMethod.addStatement(" break;"); + nMethod.addStatement("case cb_force_ok: "); + nMethod.addStatement(" if (!m_response_forced) {"); + nMethod.addStatement(" m_response = 0; "); + nMethod.addStatement(" m_response_forced = true;"); + nMethod.addStatement(" }"); + nMethod.addStatement(" break;"); + nMethod.addStatement("case cb_force_err:"); + nMethod.addStatement(" if (!m_response_forced) {"); + nMethod.addStatement(" m_response = 8;"); + nMethod.addStatement(" m_response_forced = true;"); + nMethod.addStatement(" }"); + nMethod.addStatement(" break;"); + nMethod.addStatement("}"); + nMethod.addStatement("return return_now;"); + // write class writeStmts(hppBw, newClass.genHeader(false)); // header with no include guards writeStmts(cppBw, newClass.genMethods(true)); // methods with namespace @@ -375,7 +513,7 @@ private void writeOrdtRegsetClass() { nMethod.addStatement("return nullptr;"); // methods - nMethod = newClass.addMethod(Vis.PUBLIC, "virtual int write(const uint64_t &addr, const ordt_data &wdata)"); + nMethod = newClass.addMethod(Vis.PROTECTED, "virtual int write_body(const uint64_t &addr, const ordt_data &wdata)"); //nMethod.addStatement(" std::cout << \"regset write: ---- addr=\"<< addr << \", data=\" << wdata.to_string() << \"\\n\";"); nMethod.addStatement(" if (this->containsAddress(addr)) {"); //nMethod.addStatement(" std::cout << \"regset write: ordt_regset contains addr=\"<< addr << \"\\n\";"); @@ -388,7 +526,7 @@ private void writeOrdtRegsetClass() { nMethod.addStatement("#endif"); nMethod.addStatement(" return 8;" ); - nMethod = newClass.addMethod(Vis.PUBLIC, "virtual int read(const uint64_t &addr, ordt_data &rdata)"); + nMethod = newClass.addMethod(Vis.PROTECTED, "virtual int read_body(const uint64_t &addr, ordt_data &rdata)"); //nMethod.addStatement(" std::cout << \"regset read: ---- addr=\"<< addr << \"\\n\";"); nMethod.addStatement(" if (this->containsAddress(addr)) {"); //nMethod.addStatement(" std::cout << \"regset read: ordt_regset contains addr=\"<< addr << \"\\n\";"); @@ -416,10 +554,10 @@ private void writeOrdtAddrElemArrayClass() { writeStmt(hppBw, 0, " protected:"); writeStmt(hppBw, 0, " std::vector vec;"); writeStmt(hppBw, 0, " uint64_t m_stride;"); + writeStmt(hppBw, 0, " virtual int write_body(const uint64_t &addr, const ordt_data &wdata);"); + writeStmt(hppBw, 0, " virtual int read_body(const uint64_t &addr, ordt_data &rdata);"); writeStmt(hppBw, 0, " public:"); writeStmt(hppBw, 0, " ordt_addr_elem_array(uint64_t _m_startaddress, uint64_t _m_endaddress, int _reps, uint64_t _m_stride);"); - writeStmt(hppBw, 0, " virtual int write(const uint64_t &addr, const ordt_data &wdata);"); - writeStmt(hppBw, 0, " virtual int read(const uint64_t &addr, ordt_data &rdata);"); writeStmt(hppBw, 0, "};"); writeStmt(hppBw, 0, ""); @@ -440,7 +578,7 @@ private void writeOrdtAddrElemArrayClass() { writeStmt(hppBw, 0, ""); writeStmt(hppBw, 0, "template"); - writeStmt(hppBw, 0, "int ordt_addr_elem_array::write(const uint64_t &addr, const ordt_data &wdata) {"); + writeStmt(hppBw, 0, "int ordt_addr_elem_array::write_body(const uint64_t &addr, const ordt_data &wdata) {"); //writeStmt(hppBw, 0, " std::cout << \"addr_elem array write: ---- addr=\"<< addr << \", data=\" << wdata.to_string() << \"\\n\";"); writeStmt(hppBw, 0, " if (this->containsAddress(addr)) {"); writeStmt(hppBw, 0, " uint64_t idx = (addr - m_startaddress) / m_stride;"); @@ -455,7 +593,7 @@ private void writeOrdtAddrElemArrayClass() { writeStmt(hppBw, 0, ""); writeStmt(hppBw, 0, "template"); - writeStmt(hppBw, 0, "int ordt_addr_elem_array::read(const uint64_t &addr, ordt_data &rdata) {"); + writeStmt(hppBw, 0, "int ordt_addr_elem_array::read_body(const uint64_t &addr, ordt_data &rdata) {"); //writeStmt(hppBw, 0, " std::cout << \"addr_elem array read: ---- addr=\"<< addr << \", start=\" << m_startaddress << \", end=\" << m_endaddress<< \", stride=\" << m_stride<< \"\\n\";"); writeStmt(hppBw, 0, " if (this->containsAddress(addr)) {"); writeStmt(hppBw, 0, " uint64_t idx = (addr - m_startaddress) / m_stride;"); @@ -478,6 +616,8 @@ private void writeOrdtRegClass() { newClass.addParent("ordt_addr_elem"); // define mutex for reg newClass.addDefine(Vis.PUBLIC, "std::mutex m_mutex"); + newClass.addDefine(Vis.PUBLIC, "using ordt_addr_elem::write"); + newClass.addDefine(Vis.PUBLIC, "using ordt_addr_elem::read"); // constructors CppMethod nMethod = newClass.addConstructor(Vis.PUBLIC, className + "(uint64_t _m_startaddress, uint64_t _m_endaddress)"); nMethod.addInitCall("ordt_addr_elem(_m_startaddress, _m_endaddress)"); @@ -486,13 +626,23 @@ private void writeOrdtRegClass() { nMethod.addInitCall("ordt_addr_elem(_old)"); nMethod.addInitCall("m_mutex()"); // write methods - nMethod = newClass.addMethod(Vis.PUBLIC, "virtual void write(const ordt_data &wdata)"); // will be overriden by child classes - nMethod = newClass.addMethod(Vis.PUBLIC, "virtual int write(const uint64_t &addr, const ordt_data &wdata)"); + nMethod = newClass.addMethod(Vis.PUBLIC, "virtual void write(const ordt_data &wdata)"); + nMethod.addStatement("bool return_now = pre_write(m_startaddress, wdata);"); + nMethod.addStatement("if (return_now) return;"); + nMethod.addStatement("set(wdata);"); + nMethod.addStatement("post_write(m_startaddress, wdata);"); + nMethod = newClass.addMethod(Vis.PUBLIC, "virtual int write_body(const uint64_t &addr, const ordt_data &wdata)"); nMethod.addStatement(" return 0;" ); + newClass.addMethod(Vis.PUBLIC, "virtual void set(const ordt_data &wdata)"); // will be overriden by child classes // read methods - nMethod = newClass.addMethod(Vis.PUBLIC, "virtual void read(ordt_data &rdata)"); // will be overriden by child classes - nMethod = newClass.addMethod(Vis.PUBLIC, "virtual int read(const uint64_t &addr, ordt_data &rdata)"); + nMethod = newClass.addMethod(Vis.PUBLIC, "virtual void read(ordt_data &rdata)"); + nMethod.addStatement("bool return_now = pre_read(m_startaddress);"); + nMethod.addStatement("if (return_now) return;"); + nMethod.addStatement("get(rdata);"); + nMethod.addStatement("post_read(m_startaddress);"); + nMethod = newClass.addMethod(Vis.PUBLIC, "virtual int read_body(const uint64_t &addr, ordt_data &rdata)"); nMethod.addStatement(" return 0;" ); + newClass.addMethod(Vis.PUBLIC, "virtual void get(ordt_data &rdata)"); // will be overriden by child classes // write class writeStmts(hppBw, newClass.genHeader(false)); // header with no include guards writeStmts(cppBw, newClass.genMethods(true)); // methods with namespace @@ -513,8 +663,11 @@ private void writeOrdtFieldClass() { writeStmt(hppBw, 0, " ordt_field(int _lobit, int _size, int _vsize, uint32_t _data, ordt_read_mode_t _r_mode, ordt_write_mode_t _w_mode);"); // special case for wide fields writeStmt(hppBw, 0, " ordt_field(int _lobit, int _size, T _init_data, ordt_read_mode_t _r_mode, ordt_write_mode_t _w_mode);"); // read/write - writeStmt(hppBw, 0, " void write(const ordt_data &wdata);"); - writeStmt(hppBw, 0, " void read(ordt_data &rdata);"); + writeStmt(hppBw, 0, " void write(const ordt_data &wdata) { set(wdata); }"); + writeStmt(hppBw, 0, " void read(ordt_data &rdata) { get(rdata); }"); + // get/set + writeStmt(hppBw, 0, " void set(const ordt_data &wdata);"); + writeStmt(hppBw, 0, " void get(ordt_data &rdata);"); // clear //writeStmt(hppBw, 0, " void clear(ordt_data &data);"); writeStmt(hppBw, 0, " void clear();"); @@ -533,7 +686,7 @@ private void writeOrdtFieldClass() { writeStmt(hppBw, 0, ""); // read/write writeStmt(hppBw, 0, "template"); - writeStmt(hppBw, 0, "void ordt_field::write(const ordt_data &wdata) {"); + writeStmt(hppBw, 0, "void ordt_field::set(const ordt_data &wdata) {"); //writeStmt(hppBw, 0, " std::cout << \"field write: \" << \", mode=\" << w_mode << \"\\n\";"); writeStmt(hppBw, 0, " if (w_mode == w_std) wdata.get_slice(lobit, size, data);"); writeStmt(hppBw, 0, " else if (w_mode == w_1set) {"); @@ -549,7 +702,7 @@ private void writeOrdtFieldClass() { writeStmt(hppBw, 0, "}"); writeStmt(hppBw, 0, ""); writeStmt(hppBw, 0, "template"); - writeStmt(hppBw, 0, "void ordt_field::read(ordt_data &rdata) {"); + writeStmt(hppBw, 0, "void ordt_field::get(ordt_data &rdata) {"); //writeStmt(hppBw, 0, " std::cout << \"field read: \" << \"\\n\";"); writeStmt(hppBw, 0, " rdata.set_slice(lobit, size, data);"); writeStmt(hppBw, 0, " if (r_mode == r_clr) clear();"); diff --git a/src/ordt/output/cppmod/CppModClass.java b/src/ordt/output/cppmod/CppModClass.java index e1f4f07..c85eebf 100644 --- a/src/ordt/output/cppmod/CppModClass.java +++ b/src/ordt/output/cppmod/CppModClass.java @@ -100,12 +100,12 @@ public static CppModClass createReg(String className) { nMethod.addInitCall("ordt_reg(_m_startaddress, _m_endaddress)"); // overload write methods - nMethod = newClass.addMethod(Vis.PUBLIC, "virtual int write(const uint64_t &addr, const ordt_data &wdata)"); + nMethod = newClass.addMethod(Vis.PUBLIC, "virtual int write_body(const uint64_t &addr, const ordt_data &wdata)"); nMethod.addStatement("#ifdef ORDT_PIO_VERBOSE"); nMethod.addStatement(" std::cout << \"--> write of reg " + className + " at addr=\"<< addr << \", data=\" << wdata.to_string() << \"\\n\";"); nMethod.addStatement("#endif"); nMethod.addStatement(" if (this->hasStartAddress(addr)) {"); - nMethod.addStatement(" this->write(wdata);"); + nMethod.addStatement(" this->set(wdata);"); nMethod.addStatement(" return 0;"); nMethod.addStatement(" }"); nMethod.addStatement("#ifdef ORDT_PIO_VERBOSE"); @@ -113,17 +113,17 @@ public static CppModClass createReg(String className) { nMethod.addStatement("#endif"); nMethod.addStatement(" return 8;" ); - nMethod = newClass.addMethod(Vis.PUBLIC, "virtual void write(const ordt_data &wdata)"); - newClass.tagMethod("write", nMethod); // tag this method so field info can be appended + nMethod = newClass.addMethod(Vis.PUBLIC, "virtual void set(const ordt_data &wdata)"); + newClass.tagMethod("set", nMethod); // tag this method so field info can be appended nMethod.addStatement("std::lock_guard m_guard(m_mutex);"); // grab reg lock // overload read methods - nMethod = newClass.addMethod(Vis.PUBLIC, "virtual int read(const uint64_t &addr, ordt_data &rdata)"); + nMethod = newClass.addMethod(Vis.PUBLIC, "virtual int read_body(const uint64_t &addr, ordt_data &rdata)"); nMethod.addStatement("#ifdef ORDT_PIO_VERBOSE"); nMethod.addStatement(" std::cout << \"--> read of reg " + className + " at addr=\"<< addr << \"\\n\";"); nMethod.addStatement("#endif"); nMethod.addStatement(" if (this->hasStartAddress(addr)) {"); - nMethod.addStatement(" this->read(rdata);"); + nMethod.addStatement(" this->get(rdata);"); nMethod.addStatement(" return 0;"); nMethod.addStatement(" }"); nMethod.addStatement("#ifdef ORDT_PIO_VERBOSE"); @@ -132,8 +132,8 @@ public static CppModClass createReg(String className) { nMethod.addStatement(" rdata.clear();"); nMethod.addStatement(" return 8;" ); - nMethod = newClass.addMethod(Vis.PUBLIC, "virtual void read(ordt_data &rdata)"); - newClass.tagMethod("read", nMethod); // tag this method so field info can be appended + nMethod = newClass.addMethod(Vis.PUBLIC, "virtual void get(ordt_data &rdata)"); + newClass.tagMethod("get", nMethod); // tag this method so field info can be appended nMethod.addStatement("rdata.clear();"); nMethod.addStatement("for (uint64_t widx=0; widx<((m_endaddress - m_startaddress + 1)/4); widx++) rdata.push_back(0);"); return newClass; @@ -191,11 +191,11 @@ else if (resetVal.isNonZero()) { else initStr = resetVal.toFormat(NumBase.Hex, NumFormat.Address); this.addInitCall(instName + "(" + lowIndex + ", " + width + ", " + initStr + ", " + rMode + ", " + wMode + ")"); } - // add field read/write calls in reg read method - CppMethod read = this.getTaggedMethod("read"); - read.addStatement(instName + ".read(rdata);"); - CppMethod write = this.getTaggedMethod("write"); - write.addStatement(instName + ".write(wdata);"); + // add field read/write calls in reg get/set methods + CppMethod get = this.getTaggedMethod("get"); + get.addStatement(instName + ".get(rdata);"); + CppMethod set = this.getTaggedMethod("set"); + set.addStatement(instName + ".set(wdata);"); } } diff --git a/src/ordt/output/drvmod/cpp/CppBaseModClass.java b/src/ordt/output/drvmod/cpp/CppBaseModClass.java index cd50145..6b606fc 100644 --- a/src/ordt/output/drvmod/cpp/CppBaseModClass.java +++ b/src/ordt/output/drvmod/cpp/CppBaseModClass.java @@ -366,8 +366,8 @@ public static CppBaseModClass getOrdtDataClass() { nMethod = newClass.addMethod(Vis.PUBLIC, "std::string to_string() const"); nMethod.addStatement("std::stringstream ss;"); nMethod.addStatement("ss << \"{\" << std::hex << std::showbase;"); - nMethod.addStatement("for (size_t idx=this->size() - 1; idx >= 0; idx--) "); - nMethod.addStatement(" ss << \" \" << this->at(idx);"); + nMethod.addStatement("for (size_t idx=this->size(); idx > 0; idx--) "); + nMethod.addStatement(" ss << \" \" << this->at(idx - 1);"); nMethod.addStatement("ss << \" }\";"); nMethod.addStatement("return ss.str();");