derek/gem5
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

sim: Retrofit the VPtr type.

Browse Source 
Rename it to be ProxyPtr and ConstProxyPtr, merge it with the
functionality of BufferArg and TypedBufferArg, etc., as described in
this design doc.

https://docs.google.com/document/d/1BYHBJcf7dB2Z25zAZ9snbeRKfstK9uERYH_3h66w_tc/

Change-Id: I2fddde20cc0ece257685bc50bd3419a4e9a00145
Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/29400
Reviewed-by: Ciro Santilli <ciro.santilli@arm.com>
Reviewed-by: Matthew Poremba <matthew.poremba@amd.com>
Maintainer: Gabe Black <gabeblack@google.com>
Tested-by: kokoro <noreply+kokoro@google.com>
This commit is contained in:
Gabe Black
2020-05-07 04:17:31 -07:00
parent ae58bd07f1
commit 30666c20ba
6 changed files with 375 additions and 136 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/arch/generic/freebsd/threadinfo.hh
View File

@@ -35,7 +35,6 @@
#include "cpu/thread_context.hh"
#include "sim/system.hh"
#include "sim/vptr.hh"
namespace FreeBSD {

1
src/arch/generic/linux/threadinfo.hh
View File

@@ -31,7 +31,6 @@
#include "cpu/thread_context.hh"
#include "sim/system.hh"
#include "sim/vptr.hh"
namespace Linux {

374
src/sim/proxy_ptr.hh Normal file
View File

@@ -0,0 +1,374 @@
/*
* Copyright (c) 2004-2005 The Regents of The University of Michigan
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met: redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer;
* redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution;
* neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __SIM_PROXY_PTR_HH__
#define __SIM_PROXY_PTR_HH__
#include <cstdint>
#include <memory>
#include <type_traits>
#include "base/logging.hh"
#include "base/types.hh"
#include "sim/guest_abi.hh"
template <typename Proxy>
class ProxyPtrBuffer
{
private:
std::shared_ptr<Proxy> proxy;
Addr ptr;
size_t size;
std::unique_ptr<uint8_t[]> data;
bool dirty = false;
void markClean() { dirty = false; }
public:
std::shared_ptr<Proxy> getProxy() const { return proxy; }
void markDirty() { dirty = true; }
bool isDirty() { return dirty; }
template <typename T>
T &
as()
{
assert(sizeof(T) <= size);
markDirty();
return *reinterpret_cast<T *>(data.get());
}
template <typename T>
const T &
asConst() const
{
assert(sizeof(T) <= size);
return *reinterpret_cast<T *>(data.get());
}
void
flush(bool force=false)
{
if (force || isDirty()) {
proxy->writeBlob(ptr, data.get(), size);
markClean();
}
}
void
load()
{
panic_if(isDirty(), "Overwriting dirty ProxyPtr.");
proxy->readBlob(ptr, data.get(), size);
}
Addr addr() const { return ptr; }
ProxyPtrBuffer(std::shared_ptr<Proxy> _proxy, Addr _ptr, size_t _size) :
proxy(_proxy), ptr(_ptr), size(_size), data(new uint8_t[_size])
{
load();
}
~ProxyPtrBuffer() { flush(); }
};
template <typename T, typename Proxy>
class ConstProxyPtr
{
protected:
std::shared_ptr<Proxy> proxy;
std::shared_ptr<ProxyPtrBuffer<Proxy>> buffer;
template <typename O, typename P>
friend class ProxyPtr;
void nullCheck() const { panic_if(!buffer, "Accessing null ProxyPtr."); }
void
setAddr(Addr ptr)
{
if (ptr)
buffer.reset(new ProxyPtrBuffer<Proxy>(proxy, ptr, sizeof(T)));
else
buffer.reset((ProxyPtrBuffer<Proxy> *)nullptr);
}
ConstProxyPtr(Addr _ptr, std::shared_ptr<Proxy> _proxy) : proxy(_proxy)
{
setAddr(_ptr);
}
using CPP = ConstProxyPtr<T, Proxy>;
public:
using Type = T;
template <typename ...Args,
typename std::enable_if<std::is_constructible<
Proxy, Args&&...>::value, int>::type = 0>
explicit ConstProxyPtr(Addr _ptr, Args&&... args) :
proxy(std::make_shared<Proxy>(args...))
{
setAddr(_ptr);
}
template <typename ...Args,
typename std::enable_if<std::is_constructible<
Proxy, Args&&...>::value, int>::type = 0>
explicit ConstProxyPtr(Args&&... args) :
proxy(std::make_shared<Proxy>(args...))
{
setAddr(0);
}
template <typename O, typename Enabled=
typename std::enable_if<std::is_assignable<T *, O *>::value>::type>
ConstProxyPtr(const ConstProxyPtr<O, Proxy> &other) :
proxy(other.proxy), buffer(other.buffer)
{}
ConstProxyPtr(const CPP &other) :
proxy(other.proxy), buffer(other.buffer)
{}
void
load()
{
nullCheck();
buffer->load();
}
Addr addr() const { return buffer ? buffer->addr() : 0; }
operator bool() const { return (bool)buffer; }
template <typename A>
typename std::enable_if<std::is_integral<A>::value, CPP>::type
operator + (A a) const
{
return CPP(addr() + a * sizeof(T), proxy);
}
template <typename A>
typename std::enable_if<std::is_integral<A>::value, CPP>::type
operator - (A a) const
{
return CPP(addr() - a * sizeof(T), proxy);
}
ptrdiff_t
operator - (const CPP &other) const
{
return (addr() - other.addr()) / sizeof(T);
}
CPP &
operator = (const CPP &other)
{
proxy = other.proxy;
buffer = other.buffer;
return *this;
}
CPP &
operator = (const Addr &a)
{
setAddr(a);
return *this;
}
operator const T *() const
{
return buffer ? &buffer->template asConst<T>() : nullptr;
}
const T &
operator *() const
{
nullCheck();
return buffer->template asConst<T>();
}
const T *
operator ->() const
{
nullCheck();
return &buffer->template asConst<T>();
}
};
template <typename T, typename Proxy, typename A>
typename std::enable_if<std::is_integral<A>::value,
ConstProxyPtr<T, Proxy>>::type
operator + (A a, const ConstProxyPtr<T, Proxy> &other)
{
return other + a;
}
template <typename T, typename Proxy>
class ProxyPtr : public ConstProxyPtr<T, Proxy>
{
protected:
using CPP = ConstProxyPtr<T, Proxy>;
using PP = ProxyPtr<T, Proxy>;
ProxyPtr(Addr _ptr, std::shared_ptr<Proxy> _proxy) : CPP(_ptr, _proxy) {}
public:
template <typename ...Args,
typename std::enable_if<std::is_constructible<
Proxy, Args&&...>::value, int>::type = 0>
explicit ProxyPtr(Addr _ptr, Args&&... args) : CPP(_ptr, args...) {}
template <typename ...Args,
typename std::enable_if<std::is_constructible<
Proxy, Args&&...>::value, int>::type = 0>
explicit ProxyPtr(Args&&... args) : CPP(0, args...) {}
template <typename O, typename Enabled=
typename std::enable_if<std::is_assignable<T *, O *>::value>::type>
ProxyPtr(const ProxyPtr<O, Proxy> &other) : CPP(other) {}
ProxyPtr(const PP &other) : CPP(other) {}
operator bool() const { return (bool)this->buffer; }
void
flush(bool force=false)
{
this->nullCheck();
this->buffer->flush(force);
}
template <typename A>
typename std::enable_if<std::is_integral<A>::value, PP>::type
operator + (A a) const
{
return PP(this->addr() + a * sizeof(T), this->proxy);
}
template <typename A>
typename std::enable_if<std::is_integral<A>::value, PP>::type
operator - (A a) const
{
return PP(this->addr() - a * sizeof(T), this->proxy);
}
ptrdiff_t
operator - (const PP &other) const
{
return (this->addr() - other.addr()) / sizeof(T);
}
PP &
operator = (const PP &other)
{
this->proxy = other.proxy;
this->buffer = other.buffer;
return *this;
}
PP &
operator = (const Addr &a)
{
this->setAddr(a);
return *this;
}
using CPP::operator const T *;
operator T *() const
{
return this->buffer ? &this->buffer->template as<T>() : nullptr;
}
using CPP::operator *;
T &
operator *() const
{
this->nullCheck();
return this->buffer->template as<T>();
}
using CPP::operator ->;
T *
operator ->() const
{
this->nullCheck();
return &this->buffer->template as<T>();
}
};
template <typename T, typename Proxy, typename A>
typename std::enable_if<std::is_integral<A>::value, ProxyPtr<T, Proxy>>::type
operator + (A a, const ProxyPtr<T, Proxy> &other)
{
return other + a;
}
namespace GuestABI
{
template <typename ABI, typename T, typename Proxy>
struct Argument<ABI, ProxyPtr<T, Proxy>>
{
static ProxyPtr<T, Proxy>
get(ThreadContext *tc, typename ABI::State &state)
{
return ProxyPtr<T, Proxy>(Argument<ABI, Addr>::get(tc, state), tc);
}
};
template <typename ABI, typename T, typename Proxy>
struct Argument<ABI, ConstProxyPtr<T, Proxy>>
{
static ConstProxyPtr<T, Proxy>
get(ThreadContext *tc, typename ABI::State &state)
{
return ConstProxyPtr<T, Proxy>(
Argument<ABI, Addr>::get(tc, state), tc);
}
};
} // namespace GuestABI
template <typename T, typename Proxy>
std::ostream &
operator << (std::ostream &os, const ConstProxyPtr<T, Proxy> &vptr)
{
ccprintf(os, "%#x", vptr.addr());
return os;
}
class SETranslatingPortProxy;
template <typename T>
using ConstVPtr = ConstProxyPtr<T, SETranslatingPortProxy>;
template <typename T>
using VPtr = ProxyPtr<T, SETranslatingPortProxy>;
#endif // __SIM_PROXY_PTR_HH__

1
src/sim/pseudo_inst.cc
View File

@@ -69,7 +69,6 @@
#include "sim/stat_control.hh"
#include "sim/stats.hh"
#include "sim/system.hh"
#include "sim/vptr.hh"
using namespace std;
using namespace Stats;

1
src/sim/syscall_emul.hh
View File

@@ -101,6 +101,7 @@
#include "sim/futex_map.hh"
#include "sim/guest_abi.hh"
#include "sim/process.hh"
#include "sim/proxy_ptr.hh"
#include "sim/syscall_debug_macros.hh"
#include "sim/syscall_desc.hh"
#include "sim/syscall_emul_buf.hh"

133
src/sim/vptr.hh
View File

@@ -1,133 +0,0 @@
/*
* Copyright (c) 2004-2005 The Regents of The University of Michigan
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met: redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer;
* redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution;
* neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __SIM_VPTR_HH__
#define __SIM_VPTR_HH__
#include "mem/port_proxy.hh"
class ThreadContext;
template <class T>
class VPtr
{
public:
typedef T Type;
protected:
ThreadContext *tc;
Addr ptr;
Addr buffer[(sizeof(T)-1)/sizeof(Addr) + 1];
public:
explicit VPtr(ThreadContext *_tc, Addr p = 0)
: tc(_tc), ptr(p)
{
refresh();
}
template <class U>
VPtr(const VPtr<U> &vp)
: tc(vp.tc), ptr(vp.ptr)
{
refresh();
}
~VPtr()
{}
void
refresh()
{
if (!ptr)
return;
PortProxy &proxy = tc->getVirtProxy();
proxy.readBlob(ptr, buffer, sizeof(T));
}
bool
operator!() const
{
return ptr == 0;
}
VPtr<T>
operator+(int offset)
{
return VPtr<T>(tc, ptr + offset);
}
const VPtr<T> &
operator+=(int offset)
{
ptr += offset;
refresh();
return *this;
}
const VPtr<T> &
operator=(Addr p)
{
ptr = p;
refresh();
return *this;
}
template <class U>
const VPtr<T> &
operator=(const VPtr<U> &vp)
{
tc = vp.tc;
ptr = vp.ptr;
refresh();
return *this;
}
operator T *()
{
return (T *)buffer;
}
T *
operator->()
{
return (T *)buffer;
}
T &
operator*()
{
return *(T *)buffer;
}
};
#endif // __SIM_VPTR_HH__