From 91db0c118d7135f69846bcedfb8a26c0afb44045 Mon Sep 17 00:00:00 2001
From: Brian Norris <banorris@uci.edu>
Date: Mon, 12 Nov 2012 16:48:30 -0800
Subject: [PATCH] unrelacy: instrument relacy-marked normal loads/stores

---
 include/unrelacy.h | 52 +++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 45 insertions(+), 7 deletions(-)

diff --git a/include/unrelacy.h b/include/unrelacy.h
index c16a373..729d76f 100644
--- a/include/unrelacy.h
+++ b/include/unrelacy.h
@@ -8,6 +8,7 @@
 #include <condition_variable>
 
 #include <model-assert.h>
+#include <librace.h>
 
 #define $
 
@@ -25,17 +26,54 @@
 
 namespace rl {
 
+	/* This 'useless' struct is declared just so we can use partial template
+	 * specialization in our store and load functions. */
+	template <typename T, size_t n>
+	struct useless {
+		static void store(void *addr, T val);
+		static T load(const void *addr);
+	};
+
+	template <typename T>
+	struct useless<T, 1> {
+		static void store(void *addr, T val) { store_8(addr, (uint8_t)val); }
+		static T load(const void *addr) { return (T)load_8(addr); }
+	};
+
+	template <typename T>
+	struct useless<T, 2> {
+		static void store(void *addr, T val) { store_16(addr, (uint16_t)val); }
+		static T load(const void *addr) { return (T)load_16(addr); }
+	};
+
+	template <typename T>
+	struct useless<T, 4> {
+		static void store(void *addr, T val) { store_32(addr, (uint32_t)val); }
+		static T load(const void *addr) { return (T)load_32(addr); }
+	};
+
+	template <typename T>
+	struct useless<T, 8> {
+		static void store(void *addr, T val) { store_64(addr, (uint64_t)val); }
+		static T load(const void *addr) { return (T)load_64(addr); }
+	};
+
 	template <typename T>
 	struct var {
-		var() { value = 0; }
-		var(T v) { value = v; }
-		var(var const& r) { value = r.value; }
+		var() { useless<T, sizeof(T)>::store(&value, 0); }
+		var(T v) { useless<T, sizeof(T)>::store(&value, v); }
+		var(var const& r) {
+			value = r.value;
+		}
 		~var() { }
 
-		void operator = (T v) { value = v; }
-		T operator () () { return value; }
-		void operator += (T v) { value += v; }
-		bool operator == (const struct var<T> v) const { return value == v.value; }
+		void operator = (T v) { useless<T, sizeof(T)>::store(&value, v); }
+		T operator () () { return useless<T, sizeof(T)>::load(&value); }
+		void operator += (T v) {
+			useless<T, sizeof(T)>::store(&value,
+					useless<T, sizeof(T)>::load(&value) + v);
+		}
+		bool operator == (const struct var<T> v) const { return useless<T, sizeof(T)>::load(&value) == useless<T, sizeof(T)>::load(&v.value); }
 
 		T value;
 	};
-- 
2.34.1