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 * Authors: Nathan Binkert 29 */ 30 31#ifndef __SIM_ARGUMENTS_HH__ 32#define __SIM_ARGUMENTS_HH__ 33 34#include <cassert>
|
35#include <memory> |
36
|
36#include "base/refcnt.hh"
|
37#include "base/types.hh" 38#include "mem/fs_translating_port_proxy.hh" 39 40class ThreadContext; 41 42class Arguments 43{ 44 protected: 45 ThreadContext *tc; 46 int number; 47 uint64_t getArg(uint16_t size = (uint16_t)(-1), bool fp = false); 48 49 protected:
|
50 class Data : public RefCounted
|
50 class Data |
51 { 52 public: 53 Data(){} 54 ~Data(); 55 56 private: 57 std::list<char *> data; 58 59 public: 60 char *alloc(size_t size); 61 }; 62
|
63 RefCountingPtr<Data> data;
|
63 std::shared_ptr<Data> data; |
64 65 public: 66 Arguments(ThreadContext *ctx, int n = 0)
|
67 : tc(ctx), number(n), data(NULL)
68 { assert(number >= 0); data = new Data;}
|
67 : tc(ctx), number(n), data(new Data()) 68 { assert(number >= 0); } |
69 Arguments(const Arguments &args) 70 : tc(args.tc), number(args.number), data(args.data) {} 71 ~Arguments() {} 72 73 ThreadContext *getThreadContext() const { return tc; } 74 75 const Arguments &operator=(const Arguments &args) {
|
76 tc = args.tc;
77 number = args.number;
78 data = args.data;
|
76 if (this != &args) { 77 tc = args.tc; 78 number = args.number; 79 data = args.data; 80 } |
81 return *this; 82 } 83 84 // for checking if an argument is NULL 85 bool operator!() { 86 return getArg() == 0; 87 } 88 89 Arguments &operator++() { 90 ++number; 91 assert(number >= 0); 92 return *this; 93 } 94 95 Arguments operator++(int) { 96 Arguments args = *this; 97 ++number; 98 assert(number >= 0); 99 return args; 100 } 101 102 Arguments &operator--() { 103 --number; 104 assert(number >= 0); 105 return *this; 106 } 107 108 Arguments operator--(int) { 109 Arguments args = *this; 110 --number; 111 assert(number >= 0); 112 return args; 113 } 114 115 const Arguments &operator+=(int index) { 116 number += index; 117 assert(number >= 0); 118 return *this; 119 } 120 121 const Arguments &operator-=(int index) { 122 number -= index; 123 assert(number >= 0); 124 return *this; 125 } 126 127 Arguments operator[](int index) { 128 return Arguments(tc, index); 129 } 130 131 template <class T> 132 operator T() { 133 assert(sizeof(T) <= sizeof(uint64_t)); 134 T d = static_cast<T>(getArg(sizeof(T))); 135 return d; 136 } 137 138 template <class T> 139 operator T *() { 140 T *buf = (T *)data->alloc(sizeof(T)); 141 CopyOut(tc, buf, getArg(sizeof(T)), sizeof(T)); 142 return buf; 143 } 144 145 operator char *() { 146 char *buf = data->alloc(2048); 147 CopyStringOut(tc, buf, getArg(), 2048); 148 return buf; 149 } 150}; 151 152#endif // __SIM_ARGUMENTS_HH__
|