src/sim/proxy_ptr.test.cc - public/gem5 - Git at Google

 /*
  * Copyright 2020 Google, Inc.
  *
  * 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.
  */

 #include <gtest/gtest.h>

 #include <vector>

 #include "sim/proxy_ptr.hh"

 struct Access
 {
     bool read;
     Addr addr;
     Addr size;

     Access(bool _read, Addr _addr, Addr _size) :
         read(_read), addr(_addr), size(_size)
     {}

     bool
     operator == (const Access &other) const
     {
         return read == other.read &&
                addr == other.addr &&
                size == other.size;
     }

     bool
     operator != (const Access &other) const
     {
         return !(*this == other);
     }
 };

 using Accesses = std::vector<Access>;

 class BackingStore
 {
   public:
     std::vector<uint8_t> store;
     Addr base;

     BackingStore(Addr _base, size_t _size) : store(_size, 0), base(_base) {}

     void
     rangeCheck(Addr addr, Addr size)
     {
         panic_if(addr < base || addr + size > base + store.size(),
                  "Range [%#x,%#x) outside of [%#x,%#x).",
                  addr, addr + size, base, base + store.size());
     }

     mutable Accesses accesses;

     ::testing::AssertionResult
     expect_access(size_t idx, const Access &other) const
     {
         if (idx >= accesses.size()) {
             return ::testing::AssertionFailure() << "index " << idx <<
                 " out of bounds";
         }

         if (accesses[idx] != other) {
             return ::testing::AssertionFailure() << "access[" << idx <<
                 "] was " << accesses[idx] << ", expected " << other;
         }
         return ::testing::AssertionSuccess();
     }

     ::testing::AssertionResult
     expect_accesses(Accesses expected) const
     {
         if (accesses.size() != expected.size()) {
             return ::testing::AssertionFailure() <<
                 "Wrong number of accesses, was " << accesses.size() <<
                 " expected " << expected.size();
         }

         auto failure = ::testing::AssertionFailure();
         bool success = true;
         if (accesses.size() == expected.size()) {
             for (size_t idx = 0; idx < expected.size(); idx++) {
                 auto result = expect_access(idx, expected[idx]);
                 if (!result) {
                     failure << result.message();
                     success = false;
                 }
             }
         }

         if (!success)
             return failure;
         else
             return ::testing::AssertionSuccess();
     }

     void
     writeBlob(Addr ptr, const void *data, int size)
     {
         rangeCheck(ptr, size);
         accesses.emplace_back(false, ptr, size);
         memcpy(store.data() + (ptr - base), data, size);
     }

     void
     readBlob(Addr ptr, void *data, int size)
     {
         rangeCheck(ptr, size);
         accesses.emplace_back(true, ptr, size);
         memcpy(data, store.data() + (ptr - base), size);
     }
 };

 ::testing::AssertionResult
 accessed(const char *expr1, const char *expr2,
          const BackingStore &store, const Accesses &expected)
 {
     return store.expect_accesses(expected);
 }

 #define EXPECT_ACCESSES(store, ...) \
     do { \
         Accesses expected({__VA_ARGS__}); \
         EXPECT_PRED_FORMAT2(accessed, store, expected); \
         store.accesses.clear(); \
     } while (false)

 std::ostream &
 operator << (std::ostream &os, const Access &access)
 {
     ccprintf(os, "%s(%#x, %d)", access.read ? "read" : "write",
             access.addr, access.size);
     return os;
 }

 class TestProxy
 {
   public:
     BackingStore &store;

     TestProxy(BackingStore &_store) : store(_store) {}
     // Sneaky constructor for testing GuestABI integration.
     TestProxy(ThreadContext *tc) : store(*(BackingStore *)tc) {}

     void
     writeBlob(Addr ptr, const void *data, int size)
     {
         store.writeBlob(ptr, data, size);
     }

     void
     readBlob(Addr ptr, void *data, int size)
     {
         store.readBlob(ptr, data, size);
     }
 };

 template <typename T>
 using TestPtr = ProxyPtr<T, TestProxy>;

 template <typename T>
 using ConstTestPtr = ConstProxyPtr<T, TestProxy>;

 TEST(ProxyPtr, Clean)
 {
     BackingStore store(0x1000, 0x1000);

     EXPECT_ACCESSES(store);

     {
         ConstTestPtr<uint32_t> test_ptr(0x1100, store);

         EXPECT_ACCESSES(store, { true, test_ptr.addr(), sizeof(uint32_t) });
     }

     EXPECT_ACCESSES(store);

     {
         TestPtr<uint32_t> test_ptr(0x1100, store);

         EXPECT_ACCESSES(store, { true, test_ptr.addr(), sizeof(uint32_t) });
     }

     EXPECT_ACCESSES(store);
 }

 TEST(ProxyPtr, Dirty)
 {
     BackingStore store(0x1000, 0x1100);

     EXPECT_ACCESSES(store);

     {
         TestPtr<uint32_t> test_ptr(0x1100, store);

         *test_ptr = 0xa5a5a5a5;

         EXPECT_ACCESSES(store, { true, test_ptr.addr(), sizeof(uint32_t) });
     }

     EXPECT_ACCESSES(store, { false, 0x1100, sizeof(uint32_t) });
     EXPECT_EQ(store.store[0x100], 0xa5);
     EXPECT_EQ(store.store[0x101], 0xa5);
     EXPECT_EQ(store.store[0x102], 0xa5);
     EXPECT_EQ(store.store[0x103], 0xa5);
 }


 TEST(ProxyPtr, LoadAndFlush)
 {
     BackingStore store(0x1000, 0x1100);

     store.store[0x100] = 0xa5;
     store.store[0x101] = 0xa5;
     store.store[0x102] = 0xa5;
     store.store[0x103] = 0xa5;

     TestPtr<uint32_t> test_ptr(0x1100, store);

     // Check that the backing store is unmodified.
     EXPECT_EQ(store.store[0x100], 0xa5);
     EXPECT_EQ(store.store[0x101], 0xa5);
     EXPECT_EQ(store.store[0x102], 0xa5);
     EXPECT_EQ(store.store[0x103], 0xa5);

     // Change the value in our local buffered copy.
     *test_ptr = 0x5a5a5a5a;

     // Verify that the backing store hasn't been changed.
     EXPECT_EQ(store.store[0x100], 0xa5);
     EXPECT_EQ(store.store[0x101], 0xa5);
     EXPECT_EQ(store.store[0x102], 0xa5);
     EXPECT_EQ(store.store[0x103], 0xa5);

     // Flush out our modifications.
     test_ptr.flush();

     // Verify that they've been written back to the store.
     EXPECT_EQ(store.store[0x100], 0x5a);
     EXPECT_EQ(store.store[0x101], 0x5a);
     EXPECT_EQ(store.store[0x102], 0x5a);
     EXPECT_EQ(store.store[0x103], 0x5a);

     // Update the store and try to flush again.
     store.store[0x100] = 0xaa;
     test_ptr.flush();

     // Verify that no flush happened, since our ptr was "clean".
     EXPECT_EQ(store.store[0x100], 0xaa);

     // Force a flush.
     test_ptr.flush(true);

     // Verify that the flush happened even though the ptr was "clean".
     EXPECT_EQ(store.store[0x100], 0x5a);

     // Update the store.
     store.store[0x100] = 0xa5;
     store.store[0x101] = 0xa5;
     store.store[0x102] = 0xa5;
     store.store[0x103] = 0xa5;

     // Verify that our local copy hasn't changed.
     EXPECT_EQ(*(const uint32_t *)test_ptr, 0x5a5a5a5a);

     // Reload the pointer from the store.
     test_ptr.load();
     EXPECT_EQ(*(const uint32_t *)test_ptr, 0xa5a5a5a5);
 }

 TEST(ProxyPtr, ConstOperators)
 {
     bool is_same;

     BackingStore store(0x1000, 0x1000);

     const Addr addr1 = 0x1100;
     const Addr addr2 = 0x1200;

     using PtrType = uint32_t;

     ConstTestPtr<PtrType> test_ptr1(addr1, store);
     EXPECT_EQ(test_ptr1.addr(), addr1);

     ConstTestPtr<PtrType> test_ptr2(addr2, store);
     EXPECT_EQ(test_ptr2.addr(), addr2);

     // Pointer +/- integer.
     auto next_ptr = test_ptr1 + 2;
     EXPECT_EQ(next_ptr.addr(), addr1 + 2 * sizeof(PtrType));

     auto reverse_next_ptr = 2 + test_ptr1;
     EXPECT_EQ(reverse_next_ptr.addr(), addr1 + 2 * sizeof(PtrType));

     auto prev_ptr = test_ptr1 - 2;
     EXPECT_EQ(prev_ptr.addr(), addr1 - 2 * sizeof(PtrType));

     // Pointer-pointer subtraction.
     auto diff = test_ptr2 - test_ptr1;
     EXPECT_EQ(diff, (addr2 - addr1) / sizeof(PtrType));

     // Assignment.
     ConstTestPtr<PtrType> target(addr2, store);
     EXPECT_EQ(target.addr(), addr2);

     target = test_ptr1;
     EXPECT_EQ(target.addr(), addr1);

     // Conversions.
     EXPECT_TRUE(test_ptr1);
     ConstTestPtr<PtrType> null(0, store);
     EXPECT_FALSE(null);

     EXPECT_NE((const PtrType *)test_ptr1, nullptr);
     EXPECT_EQ((const PtrType *)null, nullptr);

     // Dereferences.
     is_same = std::is_same<decltype(*test_ptr1), const PtrType &>::value;
     EXPECT_TRUE(is_same);

     store.store[0x100] = 0x55;
     store.store[0x101] = 0x55;
     store.store[0x102] = 0x55;
     store.store[0x103] = 0x55;

     // Force an update since we changed the backing store behind our ptrs back.
     test_ptr1.load();

     EXPECT_EQ(*test_ptr1, 0x55555555);

     store.store[0x100] = 0x11;
     store.store[0x101] = 0x22;
     store.store[0x102] = 0x33;
     store.store[0x103] = 0x44;

     struct TestStruct
     {
         uint8_t a;
         uint8_t b;
         uint8_t c;
         uint8_t d;
     };

     ConstTestPtr<TestStruct> struct_ptr(addr1, store);
     EXPECT_EQ(struct_ptr->a, 0x11);
     EXPECT_EQ(struct_ptr->b, 0x22);
     EXPECT_EQ(struct_ptr->c, 0x33);
     EXPECT_EQ(struct_ptr->d, 0x44);

     is_same = std::is_same<decltype((struct_ptr->a)), const uint8_t &>::value;
     EXPECT_TRUE(is_same);
 }

 TEST(ProxyPtr, NonConstOperators)
 {
     bool is_same;

     BackingStore store(0x1000, 0x1000);

     const Addr addr1 = 0x1100;
     const Addr addr2 = 0x1200;

     using PtrType = uint32_t;

     TestPtr<PtrType> test_ptr1(addr1, store);
     EXPECT_EQ(test_ptr1.addr(), addr1);

     TestPtr<PtrType> test_ptr2(addr2, store);
     EXPECT_EQ(test_ptr2.addr(), addr2);

     // Pointer +/- integer.
     auto next_ptr = test_ptr1 + 2;
     EXPECT_EQ(next_ptr.addr(), addr1 + 2 * sizeof(PtrType));

     auto reverse_next_ptr = 2 + test_ptr1;
     EXPECT_EQ(reverse_next_ptr.addr(), addr1 + 2 * sizeof(PtrType));

     auto prev_ptr = test_ptr1 - 2;
     EXPECT_EQ(prev_ptr.addr(), addr1 - 2 * sizeof(PtrType));

     // Pointer-pointer subtraction.
     auto diff = test_ptr2 - test_ptr1;
     EXPECT_EQ(diff, (addr2 - addr1) / sizeof(PtrType));

     // Assignment.
     TestPtr<PtrType> target(addr2, store);
     EXPECT_EQ(target.addr(), addr2);

     target = test_ptr1;
     EXPECT_EQ(target.addr(), addr1);

     // Conversions.
     EXPECT_TRUE(test_ptr1);
     TestPtr<PtrType> null(0, store);
     EXPECT_FALSE(null);

     EXPECT_NE((PtrType *)test_ptr1, nullptr);
     EXPECT_EQ((PtrType *)null, nullptr);
     EXPECT_NE((const PtrType *)test_ptr1, nullptr);
     EXPECT_EQ((const PtrType *)null, nullptr);

     // Dereferences.
     is_same = std::is_same<decltype(*test_ptr1), PtrType &>::value;
     EXPECT_TRUE(is_same);

     // Flush test_ptr1, which has been conservatively marked as dirty.
     test_ptr1.flush();

     store.store[0x100] = 0x55;
     store.store[0x101] = 0x55;
     store.store[0x102] = 0x55;
     store.store[0x103] = 0x55;

     // Force an update since we changed the backing store behind our ptrs back.
     test_ptr1.load();

     EXPECT_EQ(*test_ptr1, 0x55555555);

     store.store[0x100] = 0x11;
     store.store[0x101] = 0x22;
     store.store[0x102] = 0x33;
     store.store[0x103] = 0x44;

     struct TestStruct
     {
         uint8_t a;
         uint8_t b;
         uint8_t c;
         uint8_t d;
     };

     TestPtr<TestStruct> struct_ptr(addr1, store);
     EXPECT_EQ(struct_ptr->a, 0x11);
     EXPECT_EQ(struct_ptr->b, 0x22);
     EXPECT_EQ(struct_ptr->c, 0x33);
     EXPECT_EQ(struct_ptr->d, 0x44);

     is_same = std::is_same<decltype((struct_ptr->a)), uint8_t &>::value;
     EXPECT_TRUE(is_same);
 }

 struct TestABI
 {
     using UintPtr = uint64_t;
     using State = int;
 };

 namespace GuestABI
 {

 template <>
 struct Argument<TestABI, Addr>
 {
     static Addr
     get(ThreadContext *tc, typename TestABI::State &state)
     {
         return 0x1000;
     }
 };

 }

 bool abiCalled = false;
 bool abiCalledConst = false;

 void
 abiTestFunc(ThreadContext *tc, TestPtr<uint8_t> ptr)
 {
     abiCalled = true;
     EXPECT_EQ(ptr.addr(), 0x1000);
 }

 void
 abiTestFuncConst(ThreadContext *tc, ConstTestPtr<uint8_t> ptr)
 {
     abiCalledConst = true;
     EXPECT_EQ(ptr.addr(), 0x1000);
 }

 TEST(ProxyPtr, GuestABI)
 {
     BackingStore store(0x1000, 0x1000);

     EXPECT_FALSE(abiCalled);
     EXPECT_FALSE(abiCalledConst);

     invokeSimcall<TestABI>((ThreadContext *)&store, abiTestFunc);

     EXPECT_TRUE(abiCalled);
     EXPECT_FALSE(abiCalledConst);

     invokeSimcall<TestABI>((ThreadContext *)&store, abiTestFuncConst);

     EXPECT_TRUE(abiCalled);
     EXPECT_TRUE(abiCalledConst);
 }
	/*
	* Copyright 2020 Google, Inc.
	*
	* 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.
	*/

	#include <gtest/gtest.h>

	#include <vector>

	#include "sim/proxy_ptr.hh"

	struct Access
	{
	bool read;
	Addr addr;
	Addr size;

	Access(bool _read, Addr _addr, Addr _size) :
	read(_read), addr(_addr), size(_size)
	{}

	bool
	operator == (const Access &other) const
	{
	return read == other.read &&
	addr == other.addr &&
	size == other.size;
	}

	bool
	operator != (const Access &other) const
	{
	return !(*this == other);
	}
	};

	using Accesses = std::vector<Access>;

	class BackingStore
	{
	public:
	std::vector<uint8_t> store;
	Addr base;

	BackingStore(Addr _base, size_t _size) : store(_size, 0), base(_base) {}

	void
	rangeCheck(Addr addr, Addr size)
	{
	panic_if(addr < base \|\| addr + size > base + store.size(),
	"Range [%#x,%#x) outside of [%#x,%#x).",
	addr, addr + size, base, base + store.size());
	}

	mutable Accesses accesses;

	::testing::AssertionResult
	expect_access(size_t idx, const Access &other) const
	{
	if (idx >= accesses.size()) {
	return ::testing::AssertionFailure() << "index " << idx <<
	" out of bounds";
	}

	if (accesses[idx] != other) {
	return ::testing::AssertionFailure() << "access[" << idx <<
	"] was " << accesses[idx] << ", expected " << other;
	}
	return ::testing::AssertionSuccess();
	}

	::testing::AssertionResult
	expect_accesses(Accesses expected) const
	{
	if (accesses.size() != expected.size()) {
	return ::testing::AssertionFailure() <<
	"Wrong number of accesses, was " << accesses.size() <<
	" expected " << expected.size();
	}

	auto failure = ::testing::AssertionFailure();
	bool success = true;
	if (accesses.size() == expected.size()) {
	for (size_t idx = 0; idx < expected.size(); idx++) {
	auto result = expect_access(idx, expected[idx]);
	if (!result) {
	failure << result.message();
	success = false;
	}
	}
	}

	if (!success)
	return failure;
	else
	return ::testing::AssertionSuccess();
	}

	void
	writeBlob(Addr ptr, const void *data, int size)
	{
	rangeCheck(ptr, size);
	accesses.emplace_back(false, ptr, size);
	memcpy(store.data() + (ptr - base), data, size);
	}

	void
	readBlob(Addr ptr, void *data, int size)
	{
	rangeCheck(ptr, size);
	accesses.emplace_back(true, ptr, size);
	memcpy(data, store.data() + (ptr - base), size);
	}
	};

	::testing::AssertionResult
	accessed(const char expr1, const char expr2,
	const BackingStore &store, const Accesses &expected)
	{
	return store.expect_accesses(expected);
	}

	#define EXPECT_ACCESSES(store, ...) \
	do { \
	Accesses expected({__VA_ARGS__}); \
	EXPECT_PRED_FORMAT2(accessed, store, expected); \
	store.accesses.clear(); \
	} while (false)

	std::ostream &
	operator << (std::ostream &os, const Access &access)
	{
	ccprintf(os, "%s(%#x, %d)", access.read ? "read" : "write",
	access.addr, access.size);
	return os;
	}

	class TestProxy
	{
	public:
	BackingStore &store;

	TestProxy(BackingStore &_store) : store(_store) {}
	// Sneaky constructor for testing GuestABI integration.
	TestProxy(ThreadContext tc) : store((BackingStore *)tc) {}

	void
	writeBlob(Addr ptr, const void *data, int size)
	{
	store.writeBlob(ptr, data, size);
	}

	void
	readBlob(Addr ptr, void *data, int size)
	{
	store.readBlob(ptr, data, size);
	}
	};

	template <typename T>
	using TestPtr = ProxyPtr<T, TestProxy>;

	template <typename T>
	using ConstTestPtr = ConstProxyPtr<T, TestProxy>;

	TEST(ProxyPtr, Clean)
	{
	BackingStore store(0x1000, 0x1000);

	EXPECT_ACCESSES(store);

	{
	ConstTestPtr<uint32_t> test_ptr(0x1100, store);

	EXPECT_ACCESSES(store, { true, test_ptr.addr(), sizeof(uint32_t) });
	}

	EXPECT_ACCESSES(store);

	{
	TestPtr<uint32_t> test_ptr(0x1100, store);

	EXPECT_ACCESSES(store, { true, test_ptr.addr(), sizeof(uint32_t) });
	}

	EXPECT_ACCESSES(store);
	}

	TEST(ProxyPtr, Dirty)
	{
	BackingStore store(0x1000, 0x1100);

	EXPECT_ACCESSES(store);

	{
	TestPtr<uint32_t> test_ptr(0x1100, store);

	*test_ptr = 0xa5a5a5a5;

	EXPECT_ACCESSES(store, { true, test_ptr.addr(), sizeof(uint32_t) });
	}

	EXPECT_ACCESSES(store, { false, 0x1100, sizeof(uint32_t) });
	EXPECT_EQ(store.store[0x100], 0xa5);
	EXPECT_EQ(store.store[0x101], 0xa5);
	EXPECT_EQ(store.store[0x102], 0xa5);
	EXPECT_EQ(store.store[0x103], 0xa5);
	}


	TEST(ProxyPtr, LoadAndFlush)
	{
	BackingStore store(0x1000, 0x1100);

	store.store[0x100] = 0xa5;
	store.store[0x101] = 0xa5;
	store.store[0x102] = 0xa5;
	store.store[0x103] = 0xa5;

	TestPtr<uint32_t> test_ptr(0x1100, store);

	// Check that the backing store is unmodified.
	EXPECT_EQ(store.store[0x100], 0xa5);
	EXPECT_EQ(store.store[0x101], 0xa5);
	EXPECT_EQ(store.store[0x102], 0xa5);
	EXPECT_EQ(store.store[0x103], 0xa5);

	// Change the value in our local buffered copy.
	*test_ptr = 0x5a5a5a5a;

	// Verify that the backing store hasn't been changed.
	EXPECT_EQ(store.store[0x100], 0xa5);
	EXPECT_EQ(store.store[0x101], 0xa5);
	EXPECT_EQ(store.store[0x102], 0xa5);
	EXPECT_EQ(store.store[0x103], 0xa5);

	// Flush out our modifications.
	test_ptr.flush();

	// Verify that they've been written back to the store.
	EXPECT_EQ(store.store[0x100], 0x5a);
	EXPECT_EQ(store.store[0x101], 0x5a);
	EXPECT_EQ(store.store[0x102], 0x5a);
	EXPECT_EQ(store.store[0x103], 0x5a);

	// Update the store and try to flush again.
	store.store[0x100] = 0xaa;
	test_ptr.flush();

	// Verify that no flush happened, since our ptr was "clean".
	EXPECT_EQ(store.store[0x100], 0xaa);

	// Force a flush.
	test_ptr.flush(true);

	// Verify that the flush happened even though the ptr was "clean".
	EXPECT_EQ(store.store[0x100], 0x5a);

	// Update the store.
	store.store[0x100] = 0xa5;
	store.store[0x101] = 0xa5;
	store.store[0x102] = 0xa5;
	store.store[0x103] = 0xa5;

	// Verify that our local copy hasn't changed.
	EXPECT_EQ((const uint32_t )test_ptr, 0x5a5a5a5a);

	// Reload the pointer from the store.
	test_ptr.load();
	EXPECT_EQ((const uint32_t )test_ptr, 0xa5a5a5a5);
	}

	TEST(ProxyPtr, ConstOperators)
	{
	bool is_same;

	BackingStore store(0x1000, 0x1000);

	const Addr addr1 = 0x1100;
	const Addr addr2 = 0x1200;

	using PtrType = uint32_t;

	ConstTestPtr<PtrType> test_ptr1(addr1, store);
	EXPECT_EQ(test_ptr1.addr(), addr1);

	ConstTestPtr<PtrType> test_ptr2(addr2, store);
	EXPECT_EQ(test_ptr2.addr(), addr2);

	// Pointer +/- integer.
	auto next_ptr = test_ptr1 + 2;
	EXPECT_EQ(next_ptr.addr(), addr1 + 2 * sizeof(PtrType));

	auto reverse_next_ptr = 2 + test_ptr1;
	EXPECT_EQ(reverse_next_ptr.addr(), addr1 + 2 * sizeof(PtrType));

	auto prev_ptr = test_ptr1 - 2;
	EXPECT_EQ(prev_ptr.addr(), addr1 - 2 * sizeof(PtrType));

	// Pointer-pointer subtraction.
	auto diff = test_ptr2 - test_ptr1;
	EXPECT_EQ(diff, (addr2 - addr1) / sizeof(PtrType));

	// Assignment.
	ConstTestPtr<PtrType> target(addr2, store);
	EXPECT_EQ(target.addr(), addr2);

	target = test_ptr1;
	EXPECT_EQ(target.addr(), addr1);

	// Conversions.
	EXPECT_TRUE(test_ptr1);
	ConstTestPtr<PtrType> null(0, store);
	EXPECT_FALSE(null);

	EXPECT_NE((const PtrType *)test_ptr1, nullptr);
	EXPECT_EQ((const PtrType *)null, nullptr);

	// Dereferences.
	is_same = std::is_same<decltype(*test_ptr1), const PtrType &>::value;
	EXPECT_TRUE(is_same);

	store.store[0x100] = 0x55;
	store.store[0x101] = 0x55;
	store.store[0x102] = 0x55;
	store.store[0x103] = 0x55;

	// Force an update since we changed the backing store behind our ptrs back.
	test_ptr1.load();

	EXPECT_EQ(*test_ptr1, 0x55555555);

	store.store[0x100] = 0x11;
	store.store[0x101] = 0x22;
	store.store[0x102] = 0x33;
	store.store[0x103] = 0x44;

	struct TestStruct
	{
	uint8_t a;
	uint8_t b;
	uint8_t c;
	uint8_t d;
	};

	ConstTestPtr<TestStruct> struct_ptr(addr1, store);
	EXPECT_EQ(struct_ptr->a, 0x11);
	EXPECT_EQ(struct_ptr->b, 0x22);
	EXPECT_EQ(struct_ptr->c, 0x33);
	EXPECT_EQ(struct_ptr->d, 0x44);

	is_same = std::is_same<decltype((struct_ptr->a)), const uint8_t &>::value;
	EXPECT_TRUE(is_same);
	}

	TEST(ProxyPtr, NonConstOperators)
	{
	bool is_same;

	BackingStore store(0x1000, 0x1000);

	const Addr addr1 = 0x1100;
	const Addr addr2 = 0x1200;

	using PtrType = uint32_t;

	TestPtr<PtrType> test_ptr1(addr1, store);
	EXPECT_EQ(test_ptr1.addr(), addr1);

	TestPtr<PtrType> test_ptr2(addr2, store);
	EXPECT_EQ(test_ptr2.addr(), addr2);

	// Pointer +/- integer.
	auto next_ptr = test_ptr1 + 2;
	EXPECT_EQ(next_ptr.addr(), addr1 + 2 * sizeof(PtrType));

	auto reverse_next_ptr = 2 + test_ptr1;
	EXPECT_EQ(reverse_next_ptr.addr(), addr1 + 2 * sizeof(PtrType));

	auto prev_ptr = test_ptr1 - 2;
	EXPECT_EQ(prev_ptr.addr(), addr1 - 2 * sizeof(PtrType));

	// Pointer-pointer subtraction.
	auto diff = test_ptr2 - test_ptr1;
	EXPECT_EQ(diff, (addr2 - addr1) / sizeof(PtrType));

	// Assignment.
	TestPtr<PtrType> target(addr2, store);
	EXPECT_EQ(target.addr(), addr2);

	target = test_ptr1;
	EXPECT_EQ(target.addr(), addr1);

	// Conversions.
	EXPECT_TRUE(test_ptr1);
	TestPtr<PtrType> null(0, store);
	EXPECT_FALSE(null);

	EXPECT_NE((PtrType *)test_ptr1, nullptr);
	EXPECT_EQ((PtrType *)null, nullptr);
	EXPECT_NE((const PtrType *)test_ptr1, nullptr);
	EXPECT_EQ((const PtrType *)null, nullptr);

	// Dereferences.
	is_same = std::is_same<decltype(*test_ptr1), PtrType &>::value;
	EXPECT_TRUE(is_same);

	// Flush test_ptr1, which has been conservatively marked as dirty.
	test_ptr1.flush();

	store.store[0x100] = 0x55;
	store.store[0x101] = 0x55;
	store.store[0x102] = 0x55;
	store.store[0x103] = 0x55;

	// Force an update since we changed the backing store behind our ptrs back.
	test_ptr1.load();

	EXPECT_EQ(*test_ptr1, 0x55555555);

	store.store[0x100] = 0x11;
	store.store[0x101] = 0x22;
	store.store[0x102] = 0x33;
	store.store[0x103] = 0x44;

	struct TestStruct
	{
	uint8_t a;
	uint8_t b;
	uint8_t c;
	uint8_t d;
	};

	TestPtr<TestStruct> struct_ptr(addr1, store);
	EXPECT_EQ(struct_ptr->a, 0x11);
	EXPECT_EQ(struct_ptr->b, 0x22);
	EXPECT_EQ(struct_ptr->c, 0x33);
	EXPECT_EQ(struct_ptr->d, 0x44);

	is_same = std::is_same<decltype((struct_ptr->a)), uint8_t &>::value;
	EXPECT_TRUE(is_same);
	}

	struct TestABI
	{
	using UintPtr = uint64_t;
	using State = int;
	};

	namespace GuestABI
	{

	template <>
	struct Argument<TestABI, Addr>
	{
	static Addr
	get(ThreadContext *tc, typename TestABI::State &state)
	{
	return 0x1000;
	}
	};

	}

	bool abiCalled = false;
	bool abiCalledConst = false;

	void
	abiTestFunc(ThreadContext *tc, TestPtr<uint8_t> ptr)
	{
	abiCalled = true;
	EXPECT_EQ(ptr.addr(), 0x1000);
	}

	void
	abiTestFuncConst(ThreadContext *tc, ConstTestPtr<uint8_t> ptr)
	{
	abiCalledConst = true;
	EXPECT_EQ(ptr.addr(), 0x1000);
	}

	TEST(ProxyPtr, GuestABI)
	{
	BackingStore store(0x1000, 0x1000);

	EXPECT_FALSE(abiCalled);
	EXPECT_FALSE(abiCalledConst);

	invokeSimcall<TestABI>((ThreadContext *)&store, abiTestFunc);

	EXPECT_TRUE(abiCalled);
	EXPECT_FALSE(abiCalledConst);

	invokeSimcall<TestABI>((ThreadContext *)&store, abiTestFuncConst);

	EXPECT_TRUE(abiCalled);
	EXPECT_TRUE(abiCalledConst);
	}