mmt: resolve as much as possible at instrumentation time

resolve read/write size and number of parameters at
instrumentation time, instead of at runtime

3 files changed, 635 insertions, 158 deletions

diff --git a/mmt/mmt_instrument.c b/mmt/mmt_instrument.c
index 1c4a0bcd..fa591c82 100644
--- a/mmt/mmt_instrument.c
+++ b/mmt/mmt_instrument.c
@@ -1,7 +1,7 @@
 /*
    Copyright (C) 2006 Dave Airlie
    Copyright (C) 2007 Wladimir J. van der Laan
-   Copyright (C) 2009 Marcin Slusarz <marcin.slusarz@gmail.com>
+   Copyright (C) 2009,2011 Marcin Slusarz <marcin.slusarz@gmail.com>
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License as
@@ -28,43 +28,138 @@
 #include "pub_tool_libcprint.h"
 #include "pub_tool_libcassert.h"
 
+#define maybe_unused __attribute__((unused))
+
 int dump_load = True, dump_store = True;
 
-static void add_trace_load1(IRSB *bb, IRExpr *addr, Int size, Addr inst_addr, IRExpr *val1)
+static maybe_unused void
+__add_trace_load1_ia(IRSB *bb, IRExpr *addr, Int size, Addr inst_addr, IRExpr *val1)
+{
+	IRExpr **argv;
+	IRDirty *di;
+
+	argv = mkIRExprVec_3(addr, val1, mkIRExpr_HWord(inst_addr));
+	if (size == 1)
+		di = unsafeIRDirty_0_N(2, "trace_load_1", VG_(fnptr_to_fnentry)(mmt_trace_load_1_ia), argv);
+	else if (size == 2)
+		di = unsafeIRDirty_0_N(2, "trace_load_2", VG_(fnptr_to_fnentry)(mmt_trace_load_2_ia), argv);
+	else if (size == 4)
+		di = unsafeIRDirty_0_N(2, "trace_load_4", VG_(fnptr_to_fnentry)(mmt_trace_load_4_ia), argv);
+#ifdef MMT_64BIT
+	else if (size == 8)
+		di = unsafeIRDirty_0_N(2, "trace_load_8", VG_(fnptr_to_fnentry)(mmt_trace_load_8_ia), argv);
+#endif
+	else
+		tl_assert(0);
+
+	addStmtToIRSB(bb, IRStmt_Dirty(di));
+}
+
+static maybe_unused void
+__add_trace_load1(IRSB *bb, IRExpr *addr, Int size, Addr inst_addr, IRExpr *val1)
 {
-	IRExpr **argv = mkIRExprVec_4(addr, mkIRExpr_HWord(size),
-					  mkIRExpr_HWord(inst_addr), val1);
-	IRDirty *di = unsafeIRDirty_0_N(2,
-					"trace_load",
-					VG_(fnptr_to_fnentry) (mmt_trace_load),
-					argv);
+	IRExpr **argv;
+	IRDirty *di;
+
+	argv = mkIRExprVec_2(addr, val1);
+	if (size == 1)
+		di = unsafeIRDirty_0_N(2, "trace_load_1", VG_(fnptr_to_fnentry)(mmt_trace_load_1), argv);
+	else if (size == 2)
+		di = unsafeIRDirty_0_N(2, "trace_load_2", VG_(fnptr_to_fnentry)(mmt_trace_load_2), argv);
+	else if (size == 4)
+		di = unsafeIRDirty_0_N(2, "trace_load_4", VG_(fnptr_to_fnentry)(mmt_trace_load_4), argv);
+#ifdef MMT_64BIT
+	else if (size == 8)
+		di = unsafeIRDirty_0_N(2, "trace_load_8", VG_(fnptr_to_fnentry)(mmt_trace_load_8), argv);
+#endif
+	else
+		tl_assert(0);
+
 	addStmtToIRSB(bb, IRStmt_Dirty(di));
 }
 
-static void add_trace_load2(IRSB *bb, IRExpr *addr, Int size, Addr inst_addr, IRExpr *val1, IRExpr *val2)
+static maybe_unused void
+__add_trace_load2_ia(IRSB *bb, IRExpr *addr, Int size, Addr inst_addr, IRExpr *val1, IRExpr *val2)
 {
-	IRExpr **argv = mkIRExprVec_5(addr, mkIRExpr_HWord(size),
-					  mkIRExpr_HWord(inst_addr), val1, val2);
-	IRDirty *di = unsafeIRDirty_0_N(2,
-					"trace_load2",
-					VG_(fnptr_to_fnentry) (mmt_trace_load2),
-					argv);
+	IRExpr **argv;
+	IRDirty *di;
+
+	argv = mkIRExprVec_4(addr, val1, val2, mkIRExpr_HWord(inst_addr));
+
+	if (size == 4)
+		di = unsafeIRDirty_0_N(2, "trace_load_4_4", VG_(fnptr_to_fnentry) (mmt_trace_load_4_4_ia), argv);
+#ifdef MMT_64BIT
+	else if (size == 8)
+		di = unsafeIRDirty_0_N(2, "trace_load_8_8", VG_(fnptr_to_fnentry) (mmt_trace_load_8_8_ia), argv);
+#endif
+	else
+		tl_assert(0);
+
+	addStmtToIRSB(bb, IRStmt_Dirty(di));
+}
+static maybe_unused void
+__add_trace_load2(IRSB *bb, IRExpr *addr, Int size, Addr inst_addr, IRExpr *val1, IRExpr *val2)
+{
+	IRExpr **argv;
+	IRDirty *di;
+
+	argv = mkIRExprVec_3(addr, val1, val2);
+
+	if (size == 4)
+		di = unsafeIRDirty_0_N(2, "trace_load_4_4", VG_(fnptr_to_fnentry) (mmt_trace_load_4_4), argv);
+#ifdef MMT_64BIT
+	else if (size == 8)
+		di = unsafeIRDirty_0_N(2, "trace_load_8_8", VG_(fnptr_to_fnentry) (mmt_trace_load_8_8), argv);
+#endif
+	else
+		tl_assert(0);
+
 	addStmtToIRSB(bb, IRStmt_Dirty(di));
 }
 
 #ifndef MMT_64BIT
-static void add_trace_load4(IRSB *bb, IRExpr *addr, Int size, Addr inst_addr, IRExpr *val1, IRExpr *val2, IRExpr *val3, IRExpr *val4)
+static maybe_unused void
+__add_trace_load4_ia(IRSB *bb, IRExpr *addr, Int size, Addr inst_addr, IRExpr *val1, IRExpr *val2, IRExpr *val3, IRExpr *val4)
 {
-	IRExpr **argv = mkIRExprVec_7(addr, mkIRExpr_HWord(size),
-					  mkIRExpr_HWord(inst_addr), val1, val2, val3, val4);
-	IRDirty *di = unsafeIRDirty_0_N(2,
-					"trace_load4",
-					VG_(fnptr_to_fnentry) (mmt_trace_load4),
-					argv);
+	IRExpr **argv;
+	IRDirty *di;
+
+	argv = mkIRExprVec_6(addr, val1, val2, val3, val4, mkIRExpr_HWord(inst_addr));
+
+	if (size == 4)
+		di = unsafeIRDirty_0_N(2, "trace_load_4_4_4_4", VG_(fnptr_to_fnentry)(mmt_trace_load_4_4_4_4_ia), argv);
+	else
+		tl_assert(0);
+
+	addStmtToIRSB(bb, IRStmt_Dirty(di));
+}
+static maybe_unused void
+__add_trace_load4(IRSB *bb, IRExpr *addr, Int size, Addr inst_addr, IRExpr *val1, IRExpr *val2, IRExpr *val3, IRExpr *val4)
+{
+	IRExpr **argv;
+	IRDirty *di;
+
+	argv = mkIRExprVec_5(addr, val1, val2, val3, val4);
+
+	if (size == 4)
+		di = unsafeIRDirty_0_N(2, "trace_load_4_4_4_4", VG_(fnptr_to_fnentry)(mmt_trace_load_4_4_4_4), argv);
+	else
+		tl_assert(0);
+
 	addStmtToIRSB(bb, IRStmt_Dirty(di));
 }
 #endif
 
+#ifdef MMT_PRINT_FILENAMES
+#define add_trace_load1 __add_trace_load1_ia
+#define add_trace_load2 __add_trace_load2_ia
+#define add_trace_load4 __add_trace_load4_ia
+#else
+#define add_trace_load1 __add_trace_load1
+#define add_trace_load2 __add_trace_load2
+#define add_trace_load4 __add_trace_load4
+#endif
+
 #ifdef MMT_64BIT
 static void add_trace_load(IRSB *bb, IRExpr *addr, Int size, Addr inst_addr, IRExpr *data, IRType arg_ty)
 {
@@ -260,46 +355,139 @@ static void add_trace_load(IRSB *bb, IRExpr *addr, Int size, Addr inst_addr, IRE
 }
 #endif
 
-static void
-add_trace_store1(IRSB *bb, IRExpr *addr, Int size, Addr inst_addr,
-		IRExpr *data)
+static maybe_unused void
+__add_trace_store1_ia(IRSB *bb, IRExpr *addr, Int size, Addr inst_addr, IRExpr *data)
+{
+	IRExpr **argv;
+	IRDirty *di;
+
+	argv = mkIRExprVec_3(addr, data, mkIRExpr_HWord(inst_addr));
+
+	if (size == 1)
+		di = unsafeIRDirty_0_N(2, "trace_store_1", VG_(fnptr_to_fnentry)(mmt_trace_store_1_ia), argv);
+	else if (size == 2)
+		di = unsafeIRDirty_0_N(2, "trace_store_2", VG_(fnptr_to_fnentry)(mmt_trace_store_2_ia), argv);
+	else if (size == 4)
+		di = unsafeIRDirty_0_N(2, "trace_store_4", VG_(fnptr_to_fnentry)(mmt_trace_store_4_ia), argv);
+#ifdef MMT_64BIT
+	else if (size == 8)
+		di = unsafeIRDirty_0_N(2, "trace_store_8", VG_(fnptr_to_fnentry)(mmt_trace_store_8_ia), argv);
+#endif
+	else
+		tl_assert(0);
+
+	addStmtToIRSB(bb, IRStmt_Dirty(di));
+}
+
+static maybe_unused void
+__add_trace_store1(IRSB *bb, IRExpr *addr, Int size, Addr inst_addr, IRExpr *data)
+{
+	IRExpr **argv;
+	IRDirty *di;
+
+	argv = mkIRExprVec_2(addr, data);
+
+	if (size == 1)
+		di = unsafeIRDirty_0_N(2, "trace_store_1", VG_(fnptr_to_fnentry)(mmt_trace_store_1), argv);
+	else if (size == 2)
+		di = unsafeIRDirty_0_N(2, "trace_store_2", VG_(fnptr_to_fnentry)(mmt_trace_store_2), argv);
+	else if (size == 4)
+		di = unsafeIRDirty_0_N(2, "trace_store_4", VG_(fnptr_to_fnentry)(mmt_trace_store_4), argv);
+#ifdef MMT_64BIT
+	else if (size == 8)
+		di = unsafeIRDirty_0_N(2, "trace_store_8", VG_(fnptr_to_fnentry)(mmt_trace_store_8), argv);
+#endif
+	else
+		tl_assert(0);
+
+	addStmtToIRSB(bb, IRStmt_Dirty(di));
+}
+
+static maybe_unused void
+__add_trace_store2_ia(IRSB *bb, IRExpr *addr, Int size, Addr inst_addr,
+		IRExpr *data1, IRExpr *data2)
 {
-	IRExpr **argv = mkIRExprVec_4(addr, mkIRExpr_HWord(size),
-					mkIRExpr_HWord(inst_addr), data);
-	IRDirty *di = unsafeIRDirty_0_N(2,
-					"trace_store",
-					VG_(fnptr_to_fnentry) (mmt_trace_store),
-					argv);
+	IRExpr **argv;
+	IRDirty *di;
+
+	argv = mkIRExprVec_4(addr, data1, data2, mkIRExpr_HWord(inst_addr));
+
+	if (size == 4)
+		di = unsafeIRDirty_0_N(2, "trace_store_4_4", VG_(fnptr_to_fnentry)(mmt_trace_store_4_4_ia), argv);
+#ifdef MMT_64BIT
+	else if (size == 8)
+		di = unsafeIRDirty_0_N(2, "trace_store_8_8", VG_(fnptr_to_fnentry)(mmt_trace_store_8_8_ia), argv);
+#endif
+	else
+		tl_assert(0);
+
 	addStmtToIRSB(bb, IRStmt_Dirty(di));
 }
 
-static void
-add_trace_store2(IRSB *bb, IRExpr *addr, Int size, Addr inst_addr,
+static maybe_unused void
+__add_trace_store2(IRSB *bb, IRExpr *addr, Int size, Addr inst_addr,
 		IRExpr *data1, IRExpr *data2)
 {
-	IRExpr **argv = mkIRExprVec_5(addr, mkIRExpr_HWord(size),
-					mkIRExpr_HWord(inst_addr),
-					data1, data2);
-	IRDirty *di = unsafeIRDirty_0_N(2,
-					"trace_store2",
-					VG_(fnptr_to_fnentry) (mmt_trace_store2),
-					argv);
+	IRExpr **argv;
+	IRDirty *di;
+
+	argv = mkIRExprVec_3(addr, data1, data2);
+
+	if (size == 4)
+		di = unsafeIRDirty_0_N(2, "trace_store_4_4", VG_(fnptr_to_fnentry)(mmt_trace_store_4_4), argv);
+#ifdef MMT_64BIT
+	else if (size == 8)
+		di = unsafeIRDirty_0_N(2, "trace_store_8_8", VG_(fnptr_to_fnentry)(mmt_trace_store_8_8), argv);
+#endif
+	else
+		tl_assert(0);
+
 	addStmtToIRSB(bb, IRStmt_Dirty(di));
 }
 
 #ifndef MMT_64BIT
-static void
-add_trace_store4(IRSB *bb, IRExpr *addr, Addr inst_addr,
+static maybe_unused void
+__add_trace_store4_ia(IRSB *bb, IRExpr *addr, Int size, Addr inst_addr,
 		IRExpr *data1, IRExpr *data2, IRExpr *data3, IRExpr *data4)
 {
-	IRExpr **argv = mkIRExprVec_6(addr, mkIRExpr_HWord(inst_addr),
-					data1, data2, data3, data4);
-	IRDirty *di = unsafeIRDirty_0_N(2,
-					"trace_store4",
-					VG_(fnptr_to_fnentry) (mmt_trace_store4),
-					argv);
+	IRExpr **argv;
+	IRDirty *di;
+
+	argv = mkIRExprVec_6(addr, data1, data2, data3, data4, mkIRExpr_HWord(inst_addr));
+
+	if (size == 4)
+		di = unsafeIRDirty_0_N(2, "trace_store_4_4_4_4", VG_(fnptr_to_fnentry)(mmt_trace_store_4_4_4_4_ia), argv);
+	else
+		tl_assert(0);
+
 	addStmtToIRSB(bb, IRStmt_Dirty(di));
 }
+static maybe_unused void
+__add_trace_store4(IRSB *bb, IRExpr *addr, Int size, Addr inst_addr,
+		IRExpr *data1, IRExpr *data2, IRExpr *data3, IRExpr *data4)
+{
+	IRExpr **argv;
+	IRDirty *di;
+
+	argv = mkIRExprVec_5(addr, data1, data2, data3, data4);
+
+	if (size == 4)
+		di = unsafeIRDirty_0_N(2, "trace_store_4_4_4_4", VG_(fnptr_to_fnentry)(mmt_trace_store_4_4_4_4), argv);
+	else
+		tl_assert(0);
+
+	addStmtToIRSB(bb, IRStmt_Dirty(di));
+}
+#endif
+
+#ifdef MMT_PRINT_FILENAMES
+#define add_trace_store1 __add_trace_store1_ia
+#define add_trace_store2 __add_trace_store2_ia
+#define add_trace_store4 __add_trace_store4_ia
+#else
+#define add_trace_store1 __add_trace_store1
+#define add_trace_store2 __add_trace_store2
+#define add_trace_store4 __add_trace_store4
 #endif
 
 #ifdef MMT_64BIT
@@ -491,7 +679,7 @@ static void add_trace_store(IRSB *bbOut, IRExpr *destAddr, Addr inst_addr,
 			addStmtToIRSB(bbOut, cast);
 			data_expr4 = IRExpr_RdTmp(t);
 
-			add_trace_store4(bbOut, destAddr, inst_addr,
+			add_trace_store4(bbOut, destAddr, sizeofIRType(Ity_I32), inst_addr,
 					data_expr1, data_expr2, data_expr3, data_expr4);
 
 			break;
diff --git a/mmt/mmt_trace.c b/mmt/mmt_trace.c
index abd21c61..50c620e2 100644
--- a/mmt/mmt_trace.c
+++ b/mmt/mmt_trace.c
@@ -30,7 +30,7 @@
 #include "pub_tool_debuginfo.h"
 #include "pub_tool_libcassert.h"
 
-//#define MMT_PRINT_FILENAMES
+#define MMT_PRINT_DATA
 
 static struct mmt_mmap_data mmt_mmaps[MMT_MAX_REGIONS];
 static int mmt_last_region = -1;
@@ -437,8 +437,6 @@ struct mmt_mmap_data *mmt_add_region(int fd, Addr start, Addr end,
 	return region;
 }
 
-#ifdef MMT_PRINT_FILENAMES
-#define MMT_NAMESTR_LEN 256
 static void mydescribe(Addr inst_addr, char *namestr, int len)
 {
 	char filename[100];
@@ -452,182 +450,416 @@ static void mydescribe(Addr inst_addr, char *namestr, int len)
 	else
 		VG_(snprintf) (namestr, len, "@%08lx", inst_addr);
 }
+
+#ifdef MMT_PRINT_DATA
+#define print_store(fmt, ...) \
+	VG_(message)(Vg_DebugMsg, "w %d:0x%04x, " fmt "\n", \
+				region->id, (unsigned int)(addr - region->start), __VA_ARGS__)
+#define print_load(fmt, ...) \
+	VG_(message)(Vg_DebugMsg, "r %d:0x%04x, " fmt "\n", \
+				region->id, (unsigned int)(addr - region->start), __VA_ARGS__)
 #else
-#define MMT_NAMESTR_LEN 1
-static inline void mydescribe(Addr inst_addr, char *namestr, int len)
+#define print_store(fmt, ...) \
+	VG_(message)(Vg_DebugMsg, "", \
+		region->id, (unsigned int)(addr - region->start), __VA_ARGS__)
+#define print_load(fmt, ...) \
+	VG_(message)(Vg_DebugMsg, "", \
+			region->id, (unsigned int)(addr - region->start), __VA_ARGS__)
+#endif
+
+VG_REGPARM(2)
+void mmt_trace_store_1(Addr addr, UWord value)
 {
-	namestr[0] = 0;
+	struct mmt_mmap_data *region;
+
+	region = find_mmap(addr);
+	if (likely(!region))
+		return;
+
+	print_store("0x%02lx ", value);
 }
-#endif
 
 VG_REGPARM(2)
-void mmt_trace_store(Addr addr, SizeT size, Addr inst_addr, UWord value)
+void mmt_trace_store_1_ia(Addr addr, UWord value, Addr inst_addr)
 {
 	struct mmt_mmap_data *region;
-	char valstr[22];
-	char namestr[MMT_NAMESTR_LEN];
+	char namestr[256];
 
 	region = find_mmap(addr);
 	if (likely(!region))
 		return;
 
-	switch (size)
-	{
-		case 1:
-			VG_(sprintf) (valstr, "0x%02lx", value);
-			break;
-		case 2:
-			VG_(sprintf) (valstr, "0x%04lx", value);
-			break;
-		case 4:
-			VG_(sprintf) (valstr, "0x%08lx", value);
-			break;
+	mydescribe(inst_addr, namestr, 256);
+
+	print_store("0x%02lx %s", value, namestr);
+}
+
+VG_REGPARM(2)
+void mmt_trace_store_2(Addr addr, UWord value)
+{
+	struct mmt_mmap_data *region;
+
+	region = find_mmap(addr);
+	if (likely(!region))
+		return;
+
+	print_store("0x%04lx ", value);
+}
+
+VG_REGPARM(2)
+void mmt_trace_store_2_ia(Addr addr, UWord value, Addr inst_addr)
+{
+	struct mmt_mmap_data *region;
+	char namestr[256];
+
+	region = find_mmap(addr);
+	if (likely(!region))
+		return;
+
+	mydescribe(inst_addr, namestr, 256);
+
+	print_store("0x%04lx %s", value, namestr);
+}
+
+VG_REGPARM(2)
+void mmt_trace_store_4(Addr addr, UWord value)
+{
+	struct mmt_mmap_data *region;
+
+	region = find_mmap(addr);
+	if (likely(!region))
+		return;
+
+	print_store("0x%08lx ", value);
+}
+
+VG_REGPARM(2)
+void mmt_trace_store_4_ia(Addr addr, UWord value, Addr inst_addr)
+{
+	struct mmt_mmap_data *region;
+	char namestr[256];
+
+	region = find_mmap(addr);
+	if (likely(!region))
+		return;
+
+	mydescribe(inst_addr, namestr, 256);
+
+	print_store("0x%08lx %s", value, namestr);
+}
+
 #ifdef MMT_64BIT
-		case 8:
-			VG_(sprintf) (valstr, "0x%08lx,0x%08lx", value >> 32, value & 0xffffffff);
-			break;
+VG_REGPARM(2)
+void mmt_trace_store_8(Addr addr, UWord value)
+{
+	struct mmt_mmap_data *region;
+
+	region = find_mmap(addr);
+	if (likely(!region))
+		return;
+
+	print_store("0x%08lx,0x%08lx ", value >> 32, value & 0xffffffff);
+}
+VG_REGPARM(2)
+void mmt_trace_store_8_ia(Addr addr, UWord value, Addr inst_addr)
+{
+	struct mmt_mmap_data *region;
+	char namestr[256];
+
+	region = find_mmap(addr);
+	if (likely(!region))
+		return;
+
+	mydescribe(inst_addr, namestr, 256);
+
+	print_store("0x%08lx,0x%08lx %s", value >> 32, value & 0xffffffff, namestr);
+}
 #endif
-		default:
-			return;
-	}
-	mydescribe(inst_addr, namestr, MMT_NAMESTR_LEN);
 
-	VG_(message) (Vg_DebugMsg, "w %d:0x%04x, %s %s\n", region->id, (unsigned int)(addr - region->start), valstr, namestr);
+VG_REGPARM(2)
+void mmt_trace_store_4_4(Addr addr, UWord value1, UWord value2)
+{
+	struct mmt_mmap_data *region;
+
+	region = find_mmap(addr);
+	if (likely(!region))
+		return;
+
+	print_store("0x%08lx,0x%08lx ", value1, value2);
 }
 
 VG_REGPARM(2)
-void mmt_trace_store2(Addr addr, SizeT size, Addr inst_addr, UWord value1, UWord value2)
+void mmt_trace_store_4_4_ia(Addr addr, UWord value1, UWord value2, Addr inst_addr)
 {
 	struct mmt_mmap_data *region;
-	char valstr[44];
-	char namestr[MMT_NAMESTR_LEN];
+	char namestr[256];
 
 	region = find_mmap(addr);
 	if (likely(!region))
 		return;
 
-	switch (size)
-	{
-		case 4:
-			VG_(sprintf) (valstr, "0x%08lx,0x%08lx", value1, value2);
-			break;
+	mydescribe(inst_addr, namestr, 256);
+
+	print_store("0x%08lx,0x%08lx %s", value1, value2, namestr);
+}
+
 #ifdef MMT_64BIT
-		case 8:
-			VG_(sprintf) (valstr, "0x%08lx,0x%08lx,0x%08lx,0x%08lx",
-					value1 >> 32, value1 & 0xffffffff,
-					value2 >> 32, value2 & 0xffffffff);
-			break;
-#endif
-		default:
-			return;
-	}
+VG_REGPARM(2)
+void mmt_trace_store_8_8(Addr addr, UWord value1, UWord value2)
+{
+	struct mmt_mmap_data *region;
 
-	mydescribe(inst_addr, namestr, MMT_NAMESTR_LEN);
+	region = find_mmap(addr);
+	if (likely(!region))
+		return;
 
-	VG_(message) (Vg_DebugMsg, "w %d:0x%04x, %s %s\n", region->id, (unsigned int)(addr - region->start), valstr, namestr);
+	print_store("0x%08lx,0x%08lx,0x%08lx,0x%08lx ", value1 >> 32,
+			value1 & 0xffffffff, value2 >> 32, value2 & 0xffffffff);
 }
+VG_REGPARM(2)
+void mmt_trace_store_8_8_ia(Addr addr, UWord value1, UWord value2, Addr inst_addr)
+{
+	struct mmt_mmap_data *region;
+	char namestr[256];
+
+	region = find_mmap(addr);
+	if (likely(!region))
+		return;
+
+	mydescribe(inst_addr, namestr, 256);
+
+	print_store("0x%08lx,0x%08lx,0x%08lx,0x%08lx %s", value1 >> 32,
+			value1 & 0xffffffff, value2 >> 32, value2 & 0xffffffff, namestr);
+}
+#endif
 
 #ifndef MMT_64BIT
 VG_REGPARM(2)
-void mmt_trace_store4(Addr addr, Addr inst_addr, UWord value1, UWord value2, UWord value3, UWord value4)
+void mmt_trace_store_4_4_4_4(Addr addr, UWord value1, UWord value2,
+		UWord value3, UWord value4)
+{
+	struct mmt_mmap_data *region;
+
+	region = find_mmap(addr);
+	if (likely(!region))
+		return;
+
+	print_store("0x%08lx,0x%08lx,0x%08lx,0x%08lx ", value1, value2,
+			value3, value4);
+}
+VG_REGPARM(2)
+void mmt_trace_store_4_4_4_4_ia(Addr addr, UWord value1, UWord value2,
+		UWord value3, UWord value4, Addr inst_addr)
 {
 	struct mmt_mmap_data *region;
-	char valstr[44];
-	char namestr[MMT_NAMESTR_LEN];
+	char namestr[256];
 
 	region = find_mmap(addr);
 	if (likely(!region))
 		return;
 
-	VG_(sprintf) (valstr, "0x%08lx,0x%08lx,0x%08lx,0x%08lx", value1, value2, value3, value4);
-	mydescribe(inst_addr, namestr, MMT_NAMESTR_LEN);
+	mydescribe(inst_addr, namestr, 256);
 
-	VG_(message) (Vg_DebugMsg, "w %d:0x%04x, %s %s\n", region->id, (unsigned int)(addr - region->start), valstr, namestr);
+	print_store("0x%08lx,0x%08lx,0x%08lx,0x%08lx %s", value1, value2,
+			value3, value4, namestr);
 }
 #endif
 
 VG_REGPARM(2)
-void mmt_trace_load(Addr addr, SizeT size, UInt inst_addr, UWord value)
+void mmt_trace_load_1(Addr addr, UWord value)
 {
 	struct mmt_mmap_data *region;
-	char valstr[22];
-	char namestr[MMT_NAMESTR_LEN];
 
 	region = find_mmap(addr);
 	if (likely(!region))
 		return;
 
-	switch (size)
-	{
-		case 1:
-			VG_(sprintf) (valstr, "0x%02lx", value);
-			break;
-		case 2:
-			VG_(sprintf) (valstr, "0x%04lx", value);
-			break;
-		case 4:
-			VG_(sprintf) (valstr, "0x%08lx", value);
-			break;
+	print_load("0x%02lx ", value);
+}
+
+VG_REGPARM(2)
+void mmt_trace_load_1_ia(Addr addr, UWord value, Addr inst_addr)
+{
+	struct mmt_mmap_data *region;
+	char namestr[256];
+
+	region = find_mmap(addr);
+	if (likely(!region))
+		return;
+
+	mydescribe(inst_addr, namestr, 256);
+
+	print_load("0x%02lx %s", value, namestr);
+}
+
+VG_REGPARM(2)
+void mmt_trace_load_2(Addr addr, UWord value)
+{
+	struct mmt_mmap_data *region;
+
+	region = find_mmap(addr);
+	if (likely(!region))
+		return;
+
+	print_load("0x%04lx ", value);
+}
+
+VG_REGPARM(2)
+void mmt_trace_load_2_ia(Addr addr, UWord value, Addr inst_addr)
+{
+	struct mmt_mmap_data *region;
+	char namestr[256];
+
+	region = find_mmap(addr);
+	if (likely(!region))
+		return;
+
+	mydescribe(inst_addr, namestr, 256);
+
+	print_load("0x%04lx %s", value, namestr);
+}
+
+VG_REGPARM(2)
+void mmt_trace_load_4(Addr addr, UWord value)
+{
+	struct mmt_mmap_data *region;
+
+	region = find_mmap(addr);
+	if (likely(!region))
+		return;
+
+	print_load("0x%08lx ", value);
+}
+
+VG_REGPARM(2)
+void mmt_trace_load_4_ia(Addr addr, UWord value, Addr inst_addr)
+{
+	struct mmt_mmap_data *region;
+	char namestr[256];
+
+	region = find_mmap(addr);
+	if (likely(!region))
+		return;
+
+	mydescribe(inst_addr, namestr, 256);
+
+	print_load("0x%08lx %s", value, namestr);
+}
+
 #ifdef MMT_64BIT
-		case 8:
-			VG_(sprintf) (valstr, "0x%08lx,0x%08lx", value >> 32, value & 0xffffffff);
-			break;
+VG_REGPARM(2)
+void mmt_trace_load_8(Addr addr, UWord value)
+{
+	struct mmt_mmap_data *region;
+
+	region = find_mmap(addr);
+	if (likely(!region))
+		return;
+
+	print_load("0x%08lx,0x%08lx ", value >> 32, value & 0xffffffff);
+}
+VG_REGPARM(2)
+void mmt_trace_load_8_ia(Addr addr, UWord value, Addr inst_addr)
+{
+	struct mmt_mmap_data *region;
+	char namestr[256];
+
+	region = find_mmap(addr);
+	if (likely(!region))
+		return;
+
+	mydescribe(inst_addr, namestr, 256);
+
+	print_load("0x%08lx,0x%08lx %s", value >> 32, value & 0xffffffff, namestr);
+}
 #endif
-		default:
-			return;
-	}
-	mydescribe(inst_addr, namestr, MMT_NAMESTR_LEN);
 
-	VG_(message) (Vg_DebugMsg, "r %d:0x%04x, %s %s\n", region->id, (unsigned int)(addr - region->start), valstr, namestr);
+VG_REGPARM(2)
+void mmt_trace_load_4_4(Addr addr, UWord value1, UWord value2)
+{
+	struct mmt_mmap_data *region;
+
+	region = find_mmap(addr);
+	if (likely(!region))
+		return;
+
+	print_load("0x%08lx,0x%08lx ", value1, value2);
 }
 
 VG_REGPARM(2)
-void mmt_trace_load2(Addr addr, SizeT size, UInt inst_addr, UWord value1, UWord value2)
+void mmt_trace_load_4_4_ia(Addr addr, UWord value1, UWord value2, Addr inst_addr)
 {
 	struct mmt_mmap_data *region;
-	char valstr[44];
-	char namestr[MMT_NAMESTR_LEN];
+	char namestr[256];
 
 	region = find_mmap(addr);
 	if (likely(!region))
 		return;
 
-	switch (size)
-	{
-		case 4:
-			VG_(sprintf) (valstr, "0x%08lx,0x%08lx", value1, value2);
-			break;
+	mydescribe(inst_addr, namestr, 256);
+
+	print_load("0x%08lx,0x%08lx %s", value1, value2, namestr);
+}
+
 #ifdef MMT_64BIT
-		case 8:
-			VG_(sprintf) (valstr, "0x%08lx,0x%08lx,0x%08lx,0x%08lx",
-					value1 >> 32, value1 & 0xffffffff,
-					value2 >> 32, value2 & 0xffffffff);
-			break;
-#endif
-		default:
-			return;
-	}
-	mydescribe(inst_addr, namestr, MMT_NAMESTR_LEN);
+VG_REGPARM(2)
+void mmt_trace_load_8_8(Addr addr, UWord value1, UWord value2)
+{
+	struct mmt_mmap_data *region;
+
+	region = find_mmap(addr);
+	if (likely(!region))
+		return;
 
-	VG_(message) (Vg_DebugMsg, "r %d:0x%04x, %s %s\n", region->id, (unsigned int)(addr - region->start), valstr, namestr);
+	print_load("0x%08lx,0x%08lx,0x%08lx,0x%08lx ", value1 >> 32,
+			value1 & 0xffffffff, value2 >> 32, value2 & 0xffffffff);
 }
+VG_REGPARM(2)
+void mmt_trace_load_8_8_ia(Addr addr, UWord value1, UWord value2, Addr inst_addr)
+{
+	struct mmt_mmap_data *region;
+	char namestr[256];
+
+	region = find_mmap(addr);
+	if (likely(!region))
+		return;
+
+	mydescribe(inst_addr, namestr, 256);
+
+	print_load("0x%08lx,0x%08lx,0x%08lx,0x%08lx %s", value1 >> 32,
+			value1 & 0xffffffff, value2 >> 32, value2 & 0xffffffff, namestr);
+}
+#endif
 
 #ifndef MMT_64BIT
 VG_REGPARM(2)
-void mmt_trace_load4(Addr addr, SizeT size, UInt inst_addr, UWord value1, UWord value2, UWord value3, UWord value4)
+void mmt_trace_load_4_4_4_4(Addr addr, UWord value1, UWord value2,
+		UWord value3, UWord value4)
+{
+	struct mmt_mmap_data *region;
+
+	region = find_mmap(addr);
+	if (likely(!region))
+		return;
+
+	print_load("0x%08lx,0x%08lx,0x%08lx,0x%08lx ", value1, value2,
+			value3, value4);
+}
+VG_REGPARM(2)
+void mmt_trace_load_4_4_4_4_ia(Addr addr, UWord value1, UWord value2,
+		UWord value3, UWord value4, Addr inst_addr)
 {
 	struct mmt_mmap_data *region;
-	char valstr[44];
-	char namestr[MMT_NAMESTR_LEN];
+	char namestr[256];
 
 	region = find_mmap(addr);
 	if (likely(!region))
 		return;
 
-	VG_(sprintf) (valstr, "0x%08lx,0x%08lx,0x%08lx,0x%08lx", value1, value2, value3, value4);
-	mydescribe(inst_addr, namestr, MMT_NAMESTR_LEN);
+	mydescribe(inst_addr, namestr, 256);
 
-	VG_(message) (Vg_DebugMsg, "r %d:0x%04x, %s %s\n", region->id, (unsigned int)(addr - region->start), valstr, namestr);
+	print_load("0x%08lx,0x%08lx,0x%08lx,0x%08lx %s", value1, value2,
+			value3, value4, namestr);
 }
 #endif
 
diff --git a/mmt/mmt_trace.h b/mmt/mmt_trace.h
index 2318028a..06393634 100644
--- a/mmt/mmt_trace.h
+++ b/mmt/mmt_trace.h
@@ -9,6 +9,7 @@
 #define MMT_64BIT
 #endif
 
+//#define MMT_PRINT_FILENAMES
 #define MMT_MAX_TRACE_FILES 10
 #define MMT_MAX_REGIONS 1000
 
@@ -44,25 +45,81 @@ void mmt_pre_syscall(ThreadId tid, UInt syscallno, UWord *args, UInt nArgs);
 void mmt_post_syscall(ThreadId tid, UInt syscallno, UWord *args, UInt nArgs, SysRes res);
 
 VG_REGPARM(2)
-void mmt_trace_store(Addr addr, SizeT size, Addr inst_addr, UWord value);
+void mmt_trace_store_1(Addr addr, UWord value);
+VG_REGPARM(2)
+void mmt_trace_store_1_ia(Addr addr, UWord value, Addr inst_addr);
+VG_REGPARM(2)
+void mmt_trace_store_2(Addr addr, UWord value);
+VG_REGPARM(2)
+void mmt_trace_store_2_ia(Addr addr, UWord value, Addr inst_addr);
+VG_REGPARM(2)
+void mmt_trace_store_4(Addr addr, UWord value);
+VG_REGPARM(2)
+void mmt_trace_store_4_ia(Addr addr, UWord value, Addr inst_addr);
 
+#ifdef MMT_64BIT
+	VG_REGPARM(2)
+	void mmt_trace_store_8(Addr addr, UWord value);
+	VG_REGPARM(2)
+	void mmt_trace_store_8_ia(Addr addr, UWord value, Addr inst_addr);
+#endif
+
+VG_REGPARM(2)
+void mmt_trace_store_4_4(Addr addr, UWord value1, UWord value2);
 VG_REGPARM(2)
-void mmt_trace_store2(Addr addr, SizeT size, Addr inst_addr, UWord value1, UWord value2);
+void mmt_trace_store_4_4_ia(Addr addr, UWord value1, UWord value2, Addr inst_addr);
+
+#ifdef MMT_64BIT
+	VG_REGPARM(2)
+	void mmt_trace_store_8_8(Addr addr, UWord value1, UWord value2);
+	VG_REGPARM(2)
+	void mmt_trace_store_8_8_ia(Addr addr, UWord value1, UWord value2, Addr inst_addr);
+#endif
 
 #ifndef MMT_64BIT
-VG_REGPARM(2)
-void mmt_trace_store4(Addr addr, Addr inst_addr, UWord value1, UWord value2, UWord value3, UWord value4);
+	VG_REGPARM(2)
+	void mmt_trace_store_4_4_4_4(Addr addr, UWord value1, UWord value2, UWord value3, UWord value4);
+	VG_REGPARM(2)
+	void mmt_trace_store_4_4_4_4_ia(Addr addr, UWord value1, UWord value2, UWord value3, UWord value4, Addr inst_addr);
 #endif
 
 VG_REGPARM(2)
-void mmt_trace_load(Addr addr, SizeT size, UInt inst_addr, UWord value);
+void mmt_trace_load_1(Addr addr, UWord value);
+VG_REGPARM(2)
+void mmt_trace_load_1_ia(Addr addr, UWord value, Addr inst_addr);
+VG_REGPARM(2)
+void mmt_trace_load_2(Addr addr, UWord value);
+VG_REGPARM(2)
+void mmt_trace_load_2_ia(Addr addr, UWord value, Addr inst_addr);
+VG_REGPARM(2)
+void mmt_trace_load_4(Addr addr, UWord value);
+VG_REGPARM(2)
+void mmt_trace_load_4_ia(Addr addr, UWord value, Addr inst_addr);
 
+#ifdef MMT_64BIT
+	VG_REGPARM(2)
+	void mmt_trace_load_8(Addr addr, UWord value);
+	VG_REGPARM(2)
+	void mmt_trace_load_8_ia(Addr addr, UWord value, Addr inst_addr);
+#endif
+
+VG_REGPARM(2)
+void mmt_trace_load_4_4(Addr addr, UWord value1, UWord value2);
 VG_REGPARM(2)
-void mmt_trace_load2(Addr addr, SizeT size, UInt inst_addr, UWord value1, UWord value2);
+void mmt_trace_load_4_4_ia(Addr addr, UWord value1, UWord value2, Addr inst_addr);
+
+#ifdef MMT_64BIT
+	VG_REGPARM(2)
+	void mmt_trace_load_8_8(Addr addr, UWord value1, UWord value2);
+	VG_REGPARM(2)
+	void mmt_trace_load_8_8_ia(Addr addr, UWord value1, UWord value2, Addr inst_addr);
+#endif
 
 #ifndef MMT_64BIT
-VG_REGPARM(2)
-void mmt_trace_load4(Addr addr, SizeT size, UInt inst_addr, UWord value1, UWord value2, UWord value3, UWord value4);
+	VG_REGPARM(2)
+	void mmt_trace_load_4_4_4_4(Addr addr, UWord value1, UWord value2, UWord value3, UWord value4);
+	VG_REGPARM(2)
+	void mmt_trace_load_4_4_4_4_ia(Addr addr, UWord value1, UWord value2, UWord value3, UWord value4, Addr inst_addr);
 #endif