src/sim/init.cc

   1 /*
   2  * Copyright (c) 2012 ARM Limited
   3  * All rights reserved
   4  *
   5  * The license below extends only to copyright in the software and shall
   6  * not be construed as granting a license to any other intellectual
   7  * property including but not limited to intellectual property relating
   8  * to a hardware implementation of the functionality of the software
   9  * licensed hereunder.  You may use the software subject to the license
  10  * terms below provided that you ensure that this notice is replicated
  11  * unmodified and in its entirety in all distributions of the software,
  12  * modified or unmodified, in source code or in binary form.
  13  *
  14  * Copyright (c) 2000-2005 The Regents of The University of Michigan
  15  * Copyright (c) 2008 The Hewlett-Packard Development Company
  16  * All rights reserved.
  17  *
  18  * Redistribution and use in source and binary forms, with or without
  19  * modification, are permitted provided that the following conditions are
  20  * met: redistributions of source code must retain the above copyright
  21  * notice, this list of conditions and the following disclaimer;
  22  * redistributions in binary form must reproduce the above copyright
  23  * notice, this list of conditions and the following disclaimer in the
  24  * documentation and/or other materials provided with the distribution;
  25  * neither the name of the copyright holders nor the names of its
  26  * contributors may be used to endorse or promote products derived from
  27  * this software without specific prior written permission.
  28  *
  29  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  30  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  31  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  32  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  33  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  34  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  35  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  36  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  37  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  38  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  39  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  40  *
  41  * Authors: Nathan Binkert
  42  */
  43
  44 #include <Python.h>
  45
  46 #include <marshal.h>
  47 #include <zlib.h>
  48
  49 #include <iostream>
  50 #include <list>
  51 #include <string>
  52
  53 #include "base/cprintf.hh"
  54 #include "base/misc.hh"
  55 #include "base/types.hh"
  56 #include "config/have_protobuf.hh"
  57 #include "sim/async.hh"
  58 #include "sim/core.hh"
  59 #include "sim/init.hh"
  60
  61 #if HAVE_PROTOBUF
  62 #include <google/protobuf/stubs/common.h>
  63 #endif
  64
  65 using namespace std;
  66
  67 // The python library is totally messed up with respect to constness,
  68 // so make a simple macro to make life a little easier
  69 #define PyCC(x) (const_cast<char *>(x))
  70
  71 EmbeddedPython *EmbeddedPython::importer = NULL;
  72 PyObject *EmbeddedPython::importerModule = NULL;
  73 EmbeddedPython::EmbeddedPython(const char *filename, const char *abspath,
  74     const char *modpath, const unsigned char *code, int zlen, int len)
  75     : filename(filename), abspath(abspath), modpath(modpath), code(code),
  76       zlen(zlen), len(len)
  77 {
  78     // if we've added the importer keep track of it because we need it
  79     // to bootstrap.
  80     if (string(modpath) == string("importer"))
  81         importer = this;
  82     else
  83         getList().push_back(this);
  84 }
  85
  86 list<EmbeddedPython *> &
  87 EmbeddedPython::getList()
  88 {
  89     static list<EmbeddedPython *> the_list;
  90     return the_list;
  91 }
  92
  93 /*
  94  * Uncompress and unmarshal the code object stored in the
  95  * EmbeddedPython
  96  */
  97 PyObject *
  98 EmbeddedPython::getCode() const
  99 {
 100     Bytef marshalled[len];
 101     uLongf unzlen = len;
 102     int ret = uncompress(marshalled, &unzlen, (const Bytef *)code, zlen);
 103     if (ret != Z_OK)
 104         panic("Could not uncompress code: %s\n", zError(ret));
 105     assert(unzlen == (uLongf)len);
 106
 107     return PyMarshal_ReadObjectFromString((char *)marshalled, len);
 108 }
 109
 110 bool
 111 EmbeddedPython::addModule() const
 112 {
 113     PyObject *code = getCode();
 114     PyObject *result = PyObject_CallMethod(importerModule, PyCC("add_module"),
 115         PyCC("sssO"), filename, abspath, modpath, code);
 116     if (!result) {
 117         PyErr_Print();
 118         return false;
 119     }
 120
 121     Py_DECREF(result);
 122     return true;
 123 }
 124
 125 /*
 126  * Load and initialize all of the python parts of M5, including Swig
 127  * and the embedded module importer.
 128  */
 129 int
 130 EmbeddedPython::initAll()
 131 {
 132     // Load the importer module
 133     PyObject *code = importer->getCode();
 134     importerModule = PyImport_ExecCodeModule(PyCC("importer"), code);
 135     if (!importerModule) {
 136         PyErr_Print();
 137         return 1;
 138     }
 139
 140     // Load the rest of the embedded python files into the embedded
 141     // python importer
 142     list<EmbeddedPython *>::iterator i = getList().begin();
 143     list<EmbeddedPython *>::iterator end = getList().end();
 144     for (; i != end; ++i)
 145         if (!(*i)->addModule())
 146             return 1;
 147
 148     return 0;
 149 }
 150
 151 EmbeddedSwig::EmbeddedSwig(void (*init_func)(), const string& _context)
 152     : initFunc(init_func), context(_context)
 153 {
 154     getList().push_back(this);
 155 }
 156
 157 list<EmbeddedSwig *> &
 158 EmbeddedSwig::getList()
 159 {
 160     static list<EmbeddedSwig *> the_list;
 161     return the_list;
 162 }
 163
 164 void
 165 EmbeddedSwig::initAll()
 166 {
 167     char* old_context = _Py_PackageContext;
 168     // initialize SWIG modules. initFunc() is autogenerated and calls
 169     // all of the individual swig initialization functions.
 170     for (auto i : getList()) {
 171         // to ensure that the loaded modules are placed in the right
 172         // package we have to be a bit unorthodox and directly
 173         // manipulate the package context since swig simply calls
 174         // Py_InitModule with nothing but the module name of the
 175         // wrapper
 176         char* cstr = new char[i->context.size() + 1];
 177         strcpy(cstr, i->context.c_str());
 178         _Py_PackageContext = cstr;
 179         i->initFunc();
 180         delete[] cstr;
 181     }
 182     _Py_PackageContext = old_context;
 183 }
 184
 185 int
 186 initM5Python()
 187 {
 188     EmbeddedSwig::initAll();
 189     return EmbeddedPython::initAll();
 190 }
 191
 192 /*
 193  * Make the commands array weak so that they can be overridden (used
 194  * by unit tests to specify a different python main function.
 195  */
 196 const char * __attribute__((weak)) m5MainCommands[] = {
 197     "import m5",
 198     "m5.main()",
 199     0 // sentinel is required
 200 };
 201
 202 /*
 203  * Start up the M5 simulator.  This mostly vectors into the python
 204  * main function.
 205  */
 206 int
 207 m5Main(int argc, char **argv)
 208 {
 209 #if HAVE_PROTOBUF
 210     // Verify that the version of the protobuf library that we linked
 211     // against is compatible with the version of the headers we
 212     // compiled against.
 213     GOOGLE_PROTOBUF_VERIFY_VERSION;
 214 #endif
 215
 216     PySys_SetArgv(argc, argv);
 217
 218     // We have to set things up in the special __main__ module
 219     PyObject *module = PyImport_AddModule(PyCC("__main__"));
 220     if (module == NULL)
 221         panic("Could not import __main__");
 222     PyObject *dict = PyModule_GetDict(module);
 223
 224     // import the main m5 module
 225     PyObject *result;
 226     const char **command = m5MainCommands;
 227
 228     // evaluate each command in the m5MainCommands array (basically a
 229     // bunch of python statements.
 230     while (*command) {
 231         result = PyRun_String(*command, Py_file_input, dict, dict);
 232         if (!result) {
 233             PyErr_Print();
 234             return 1;
 235         }
 236         Py_DECREF(result);
 237
 238         command++;
 239     }
 240
 241 #if HAVE_PROTOBUF
 242     google::protobuf::ShutdownProtobufLibrary();
 243 #endif
 244
 245     return 0;
 246 }
 247
 248 PyMODINIT_FUNC
 249 initm5(void)
 250 {
 251     initM5Python();
 252     PyImport_ImportModule(PyCC("m5"));
 253 }