1/*
2 * Copyright (c) 2012, 2017 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 "sim/init.hh"
47
48#include <marshal.h>
49#include <zlib.h>
50
51#include <iostream>
52#include <list>
53#include <string>
54#include <vector>
55
56#include "base/cprintf.hh"
57#include "base/logging.hh"
58#include "base/types.hh"
59#include "config/have_protobuf.hh"
60#include "python/pybind11/pybind.hh"
61#include "sim/async.hh"
62#include "sim/core.hh"
63
64#if HAVE_PROTOBUF
65#include <google/protobuf/stubs/common.h>
66
67#endif
68
69using namespace std;
70namespace py = pybind11;
71
72// The python library is totally messed up with respect to constness,
73// so make a simple macro to make life a little easier
74#define PyCC(x) (const_cast<char *>(x))
75
76EmbeddedPython *EmbeddedPython::importer = NULL;
77PyObject *EmbeddedPython::importerModule = NULL;
78EmbeddedPython::EmbeddedPython(const char *filename, const char *abspath,
79    const char *modpath, const unsigned char *code, int zlen, int len)
80    : filename(filename), abspath(abspath), modpath(modpath), code(code),
81      zlen(zlen), len(len)
82{
83    // if we've added the importer keep track of it because we need it
84    // to bootstrap.
85    if (string(modpath) == string("importer"))
86        importer = this;
87    else
88        getList().push_back(this);
89}
90
91list<EmbeddedPython *> &
92EmbeddedPython::getList()
93{
94    static list<EmbeddedPython *> the_list;
95    return the_list;
96}
97
98/*
99 * Uncompress and unmarshal the code object stored in the
100 * EmbeddedPython
101 */
102PyObject *
103EmbeddedPython::getCode() const
104{
105    Bytef marshalled[len];
106    uLongf unzlen = len;
107    int ret = uncompress(marshalled, &unzlen, (const Bytef *)code, zlen);
108    if (ret != Z_OK)
109        panic("Could not uncompress code: %s\n", zError(ret));
110    assert(unzlen == (uLongf)len);
111
112    return PyMarshal_ReadObjectFromString((char *)marshalled, len);
113}
114
115bool
116EmbeddedPython::addModule() const
117{
118    PyObject *code = getCode();
119    PyObject *result = PyObject_CallMethod(importerModule, PyCC("add_module"),
120        PyCC("sssO"), filename, abspath, modpath, code);
121    if (!result) {
122        PyErr_Print();
123        return false;
124    }
125
126    Py_DECREF(result);
127    return true;
128}
129
130/*
131 * Load and initialize all of the python parts of M5.
132 */
133int
134EmbeddedPython::initAll()
135{
136    // Load the importer module
137    PyObject *code = importer->getCode();
138    importerModule = PyImport_ExecCodeModule(PyCC("importer"), code);
139    if (!importerModule) {
140        PyErr_Print();
141        return 1;
142    }
143
144    // Load the rest of the embedded python files into the embedded
145    // python importer
146    list<EmbeddedPython *>::iterator i = getList().begin();
147    list<EmbeddedPython *>::iterator end = getList().end();
148    for (; i != end; ++i)
149        if (!(*i)->addModule())
150            return 1;
151
152    return 0;
153}
154
155EmbeddedPyBind::EmbeddedPyBind(const char *_name,
156                               void (*init_func)(py::module &),
157                               const char *_base)
158    : initFunc(init_func), registered(false), name(_name), base(_base)
159{
160    getMap()[_name] = this;
161}
162
163EmbeddedPyBind::EmbeddedPyBind(const char *_name,
164                               void (*init_func)(py::module &))
165    : initFunc(init_func), registered(false), name(_name), base("")
166{
167    getMap()[_name] = this;
168}
169
170void
171EmbeddedPyBind::init(py::module &m)
172{
173    if (!registered) {
174        initFunc(m);
175        registered = true;
176    } else {
177        cprintf("Warning: %s already registered.\n", name);
178    }
179}
180
181bool
182EmbeddedPyBind::depsReady() const
183{
184    return base.empty() || getMap()[base]->registered;
185}
186
187std::map<std::string, EmbeddedPyBind *> &
188EmbeddedPyBind::getMap()
189{
190    static std::map<std::string, EmbeddedPyBind *> objs;
191    return objs;
192}
193
194#if PY_MAJOR_VERSION >= 3
195PyObject *
196#else
197void
198#endif
199EmbeddedPyBind::initAll()
200{
201    std::list<EmbeddedPyBind *> pending;
202
203    py::module m_m5 = py::module("_m5");
204    m_m5.attr("__package__") = py::cast("_m5");
205
206    pybind_init_core(m_m5);
207    pybind_init_debug(m_m5);
208
209    pybind_init_event(m_m5);
210    pybind_init_stats(m_m5);
211
212    for (auto &kv : getMap()) {
213        auto &obj = kv.second;
214        if (obj->base.empty()) {
215            obj->init(m_m5);
216        } else {
217            pending.push_back(obj);
218        }
219    }
220
221    while (!pending.empty()) {
222        for (auto it = pending.begin(); it != pending.end(); ) {
223            EmbeddedPyBind &obj = **it;
224            if (obj.depsReady()) {
225                obj.init(m_m5);
226                it = pending.erase(it);
227            } else {
228                ++it;
229            }
230        }
231    }
232
233#if PY_MAJOR_VERSION >= 3
234    return m_m5.ptr();
235#endif
236}
237
238void
239registerNativeModules()
240{
241    auto result = PyImport_AppendInittab("_m5", EmbeddedPyBind::initAll);
242    if (result == -1)
243        panic("Failed to add _m5 to Python's inittab\n");
244}
245
246/*
247 * Make the commands array weak so that they can be overridden (used
248 * by unit tests to specify a different python main function.
249 */
250const char * __attribute__((weak)) m5MainCommands[] = {
251    "import m5",
252    "m5.main()",
253    0 // sentinel is required
254};
255
256/*
257 * Start up the M5 simulator.  This mostly vectors into the python
258 * main function.
259 */
260int
261m5Main(int argc, char **_argv)
262{
263#if HAVE_PROTOBUF
264    // Verify that the version of the protobuf library that we linked
265    // against is compatible with the version of the headers we
266    // compiled against.
267    GOOGLE_PROTOBUF_VERIFY_VERSION;
268#endif
269
270
271#if PY_MAJOR_VERSION >= 3
272    typedef std::unique_ptr<wchar_t[], decltype(&PyMem_RawFree)> WArgUPtr;
273    std::vector<WArgUPtr> v_argv;
274    std::vector<wchar_t *> vp_argv;
275    v_argv.reserve(argc);
276    vp_argv.reserve(argc);
277    for (int i = 0; i < argc; i++) {
278        v_argv.emplace_back(Py_DecodeLocale(_argv[i], NULL), &PyMem_RawFree);
279        vp_argv.emplace_back(v_argv.back().get());
280    }
281
282    wchar_t **argv = vp_argv.data();
283#else
284    char **argv = _argv;
285#endif
286
287    PySys_SetArgv(argc, argv);
288
289    // We have to set things up in the special __main__ module
290    PyObject *module = PyImport_AddModule(PyCC("__main__"));
291    if (module == NULL)
292        panic("Could not import __main__");
293    PyObject *dict = PyModule_GetDict(module);
294
295    // import the main m5 module
296    PyObject *result;
297    const char **command = m5MainCommands;
298
299    // evaluate each command in the m5MainCommands array (basically a
300    // bunch of python statements.
301    while (*command) {
302        result = PyRun_String(*command, Py_file_input, dict, dict);
303        if (!result) {
304            PyErr_Print();
305            return 1;
306        }
307        Py_DECREF(result);
308
309        command++;
310    }
311
312#if HAVE_PROTOBUF
313    google::protobuf::ShutdownProtobufLibrary();
314#endif
315
316    return 0;
317}
318