object.cc revision 12952
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 "systemc/core/object.hh" 31 32#include "base/logging.hh" 33#include "systemc/core/module.hh" 34 35namespace sc_gem5 36{ 37 38namespace 39{ 40 41ObjectsIt 42findObjectIn(Objects &objects, const std::string &name) 43{ 44 ObjectsIt it; 45 for (it = objects.begin(); it != objects.end(); it++) 46 if (!strcmp((*it)->name(), name.c_str())) 47 break; 48 49 return it; 50} 51 52void 53addObject(Objects *objects, sc_core::sc_object *object) 54{ 55 objects->emplace(objects->end(), object); 56} 57 58void 59popObject(Objects *objects, const std::string &name) 60{ 61 ObjectsIt it = findObjectIn(*objects, name); 62 assert(it != objects->end()); 63 std::swap(objects->back(), *it); 64 objects->pop_back(); 65} 66 67} // anonymous namespace 68 69Object::Object(sc_core::sc_object *sc_obj) : Object(sc_obj, "object") {} 70 71Object::Object(sc_core::sc_object *sc_obj, const char *obj_name) : 72 sc_obj(sc_obj), _basename(obj_name), parent(nullptr) 73{ 74 if (_basename == "") 75 _basename = "object"; 76 77 Module *p = currentModule(); 78 79 Module *n = newModule(); 80 if (n) { 81 // We are a module in the process of being constructed. 82 n->finish(this); 83 } 84 85 if (p) { 86 // We're "within" a parent module, ie we're being created while its 87 // constructor is running. 88 parent = p->obj()->sc_obj; 89 addObject(&parent->_gem5_object->children, sc_obj); 90 } else if (false /* TODO Check if a process is running */) { 91 // The process is our parent. 92 } else { 93 // We're a top level object. 94 addObject(&topLevelObjects, sc_obj); 95 } 96 97 addObject(&allObjects, sc_obj); 98 99 _name = _basename; 100 sc_core::sc_object *sc_p = parent; 101 while (sc_p) { 102 _name = std::string(sc_p->basename()) + std::string(".") + _name; 103 sc_p = sc_p->get_parent_object(); 104 } 105} 106 107Object::Object(sc_core::sc_object *sc_obj, const Object &arg) : 108 Object(sc_obj, arg._basename.c_str()) 109{} 110 111Object & 112Object::operator = (const Object &) 113{ 114 return *this; 115} 116 117Object::~Object() 118{ 119 panic_if(!children.empty(), "Parent object still has children.\n"); 120 121 if (parent) 122 popObject(&parent->_gem5_object->children, _name); 123 else 124 popObject(&topLevelObjects, _name); 125 popObject(&allObjects, _name); 126} 127 128const char * 129Object::name() const 130{ 131 return _name.c_str(); 132} 133 134const char * 135Object::basename() const 136{ 137 return _basename.c_str(); 138} 139 140void 141Object::print(std::ostream &out) const 142{ 143 out << name(); 144} 145 146void 147Object::dump(std::ostream &out) const 148{ 149 out << "name = " << name() << "\n"; 150 out << "kind = " << sc_obj->kind() << "\n"; 151} 152 153const std::vector<sc_core::sc_object *> & 154Object::get_child_objects() const 155{ 156 return children; 157} 158 159const std::vector<sc_core::sc_event *> & 160Object::get_child_events() const 161{ 162 return events; 163} 164 165sc_core::sc_object *Object::get_parent_object() const 166{ 167 return parent; 168} 169 170bool 171Object::add_attribute(sc_core::sc_attr_base &attr) 172{ 173 return cltn.push_back(&attr); 174} 175 176sc_core::sc_attr_base * 177Object::get_attribute(const std::string &attr) 178{ 179 return cltn[attr]; 180} 181 182sc_core::sc_attr_base * 183Object::remove_attribute(const std::string &attr) 184{ 185 return cltn.remove(attr); 186} 187 188void 189Object::remove_all_attributes() 190{ 191 cltn.remove_all(); 192} 193 194int 195Object::num_attributes() const 196{ 197 return cltn.size(); 198} 199 200sc_core::sc_attr_cltn & 201Object::attr_cltn() 202{ 203 return cltn; 204} 205 206const sc_core::sc_attr_cltn & 207Object::attr_cltn() const 208{ 209 return cltn; 210} 211 212sc_core::sc_simcontext * 213Object::simcontext() const 214{ 215 warn("%s not implemented.\n", __PRETTY_FUNCTION__); 216 return nullptr; 217} 218 219 220Objects topLevelObjects; 221Objects allObjects; 222 223const std::vector<sc_core::sc_object *> & 224getTopLevelScObjects() 225{ 226 return topLevelObjects; 227} 228 229sc_core::sc_object * 230findObject(const char *name, const Objects &objects) 231{ 232 ObjectsIt it = findObjectIn(allObjects, name); 233 return it == allObjects.end() ? nullptr : *it; 234} 235 236} // namespace sc_gem5 237