src/sim/arguments.hh

   1 /*
   2  * Copyright (c) 2003-2005 The Regents of The University of Michigan
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are
   7  * met: redistributions of source code must retain the above copyright
   8  * notice, this list of conditions and the following disclaimer;
   9  * redistributions in binary form must reproduce the above copyright
  10  * notice, this list of conditions and the following disclaimer in the
  11  * documentation and/or other materials provided with the distribution;
  12  * neither the name of the copyright holders nor the names of its
  13  * contributors may be used to endorse or promote products derived from
  14  * this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #ifndef __SIM_ARGUMENTS_HH__
  30 #define __SIM_ARGUMENTS_HH__
  31
  32 #include <cassert>
  33 #include <memory>
  34
  35 #include "cpu/thread_context.hh"
  36 #include "mem/port_proxy.hh"
  37
  38 class Arguments
  39 {
  40   protected:
  41     ThreadContext *tc;
  42     int number;
  43     uint64_t getArg(uint16_t size = (uint16_t)(-1), bool fp = false);
  44
  45   protected:
  46     class Data
  47     {
  48       public:
  49         Data(){}
  50         ~Data();
  51
  52       private:
  53         std::list<char *> data;
  54
  55       public:
  56         char *alloc(size_t size);
  57     };
  58
  59     std::shared_ptr<Data> data;
  60
  61   public:
  62     Arguments(ThreadContext *ctx, int n = 0)
  63         : tc(ctx), number(n), data(new Data())
  64     { assert(number >= 0); }
  65     Arguments(const Arguments &args)
  66         : tc(args.tc), number(args.number), data(args.data) {}
  67     ~Arguments() {}
  68
  69     ThreadContext *getThreadContext() const { return tc; }
  70
  71     const Arguments &operator=(const Arguments &args) {
  72         if (this != &args) {
  73             tc = args.tc;
  74             number = args.number;
  75             data = args.data;
  76         }
  77         return *this;
  78     }
  79
  80     // for checking if an argument is NULL
  81     bool operator!() {
  82         return getArg() == 0;
  83     }
  84
  85     Arguments &operator++() {
  86         ++number;
  87         assert(number >= 0);
  88         return *this;
  89     }
  90
  91     Arguments operator++(int) {
  92         Arguments args = *this;
  93         ++number;
  94         assert(number >= 0);
  95         return args;
  96     }
  97
  98     Arguments &operator--() {
  99         --number;
 100         assert(number >= 0);
 101         return *this;
 102     }
 103
 104     Arguments operator--(int) {
 105         Arguments args = *this;
 106         --number;
 107         assert(number >= 0);
 108         return args;
 109     }
 110
 111     const Arguments &operator+=(int index) {
 112         number += index;
 113         assert(number >= 0);
 114         return *this;
 115     }
 116
 117     const Arguments &operator-=(int index) {
 118         number -= index;
 119         assert(number >= 0);
 120         return *this;
 121     }
 122
 123     Arguments operator[](int index) {
 124         return Arguments(tc, index);
 125     }
 126
 127     template <class T>
 128     operator T() {
 129         assert(sizeof(T) <= sizeof(uint64_t));
 130         T d = static_cast<T>(getArg(sizeof(T)));
 131         return d;
 132     }
 133
 134     template <class T>
 135     operator T *() {
 136         T *buf = (T *)data->alloc(sizeof(T));
 137         tc->getVirtProxy().readBlob(getArg(sizeof(T)), buf, sizeof(T));
 138         return buf;
 139     }
 140
 141     operator char *() {
 142         char *buf = data->alloc(2048);
 143         tc->getVirtProxy().readString(buf, getArg(), 2048);
 144         return buf;
 145     }
 146 };
 147
 148 #endif // __SIM_ARGUMENTS_HH__