diff -ru delme2/include/watch.h delme/include/watch.h
--- delme2/include/watch.h	2008-06-18 19:26:24.000000000 +0100
+++ delme/include/watch.h	2008-06-18 19:15:13.000000000 +0100
@@ -41,7 +41,7 @@
     void showVar(const char *args);
     void beginWatch(int isStart=1);
     void reportWatch(const char *header, uint32 pos
-                     , uint32 newval, uint32 changed);
+                     , uint32 newval, uint32 changed, uint32 addr);
 };
 #define REG_VAR_WATCHLIST(Pred, Name, Var, Desc)       \
     __REG_VAR(watchListVar, Var, Pred, Name, Desc)
Only in delme/include: watch.h.orig
Only in delme/include: watch.h.rej
diff -ru delme2/src/irq.cpp delme/src/irq.cpp
--- delme2/src/irq.cpp	2008-06-18 19:26:38.000000000 +0100
+++ delme/src/irq.cpp	2008-06-18 19:20:02.000000000 +0100
@@ -86,28 +86,34 @@
 report_memPoll(irqData *data, const char *header, traceitem *item)
 {
     watchListVar *w = (watchListVar*)item->d0;
-    uint32 pos=item->d1, val=item->d2, changed=item->d3;
-    w->reportWatch(header, pos, val, changed);
+    uint32 pos=item->d1, val=item->d2, changed=item->d3, addr=item->d4;
+    w->reportWatch(header, pos, val, changed, addr);
 }
 
+
 // Perform a set of memory polls and add to trace buffer.
 static void __irq
-checkPolls(struct irqData *data, pollinfo *info)
+checkPolls(struct irqData *data, pollinfo *info, uint32 addr)
 {
     for (uint i=0; i<info->count; i++) {
         memcheck *mc = &info->list[i];
         uint32 val, changed;
         int ret = testMem(mc, &val, &changed);
-        if (!ret)
-            continue;
+    if (!ret)
+        continue;        
+    
         ret = add_trace(data, report_memPoll, (uint32)info->cls, i
-                        , val, changed);
+                        , val, changed, addr);
+
         if (ret)
             // Couldn't add trace - reset compare function.
             mc->trySuppress = 0;
     }
+        
+    
 }
 
+
 // Handler for interrupt events.  Note that this is running in
 // "Modified Virtual Address" mode, so avoid reading any global
 // variables or calling any non local functions.
@@ -122,10 +128,11 @@
         // Separate routine for PXA chips
         PXA_irq_handler(data, regs);
 
+    uint32 faultaddr = MVAddr_irq(regs->old_pc - 4);    
     // Trace time memory polling.
     prePoll(data, isPXA);
-    checkPolls(data, &data->irqpoll);
-    checkPolls(data, &data->tracepoll);
+    checkPolls(data, &data->irqpoll, faultaddr);
+    checkPolls(data, &data->tracepoll, faultaddr);
     checkMMUMerge(data);
     postPoll(data, isPXA);
 }
@@ -142,9 +149,10 @@
         // Separate routine for PXA chips
         ret = PXA_abort_handler(data, regs);
 
+    uint32 faultaddr = MVAddr_irq(regs->old_pc - 4);    
     // Trace time memory polling.
     prePoll(data, isPXA);
-    checkPolls(data, &data->tracepoll);
+    checkPolls(data, &data->tracepoll, faultaddr);
     checkMMUMerge(data);
     postPoll(data, isPXA);
 
@@ -163,9 +171,10 @@
         // Separate routine for PXA chips
         ret = PXA_prefetch_handler(data, regs);
 
+    uint32 faultaddr = MVAddr_irq(regs->old_pc - 4);    
     // Trace time memory polling.
     prePoll(data, isPXA);
-    checkPolls(data, &data->tracepoll);
+    checkPolls(data, &data->tracepoll, faultaddr);
     checkMMUMerge(data);
     postPoll(data, isPXA);
 
@@ -189,7 +198,7 @@
         PXA_resume_handler(data, regs);
 
     add_trace(data, report_resume);
-    checkPolls(data, &data->resumepoll);
+    checkPolls(data, &data->resumepoll, 0);
 }
 
 
Only in delme/src: irq.cpp~
diff -ru delme2/src/irq.cpp.orig delme/src/irq.cpp.orig
--- delme2/src/irq.cpp.orig	2008-06-18 19:26:34.000000000 +0100
+++ delme/src/irq.cpp.orig	2008-06-18 19:12:11.000000000 +0100
@@ -19,6 +19,7 @@
 #include "lateload.h" // LATE_LOAD
 #include "winvectors.h" // findWinCEirq
 #include "irq.h"
+#include "memcmds.h"
 
 /*
  * Theory of operation:
@@ -509,6 +510,13 @@
 REG_VAR_INT(testWirqAvail,"MMUMergeCount",MMUMergeCount,
             "Number of MMU level 1 table entries to watch. Making this too big (~> 512) may seriously slow/crash your system!")
 
+static uint32 MMUMergeTargetStart = 0x40000000; //pxa regs
+REG_VAR_INT(testWirqAvail,"MMUMergeTargetStart",MMUMergeTargetStart,
+            "Physical address to scan the merged table for on completion of wirq.")
+static uint32 MMUMergeTargetSize = 0x10000000; //the whole bank
+REG_VAR_INT(testWirqAvail,"MMUMergeTargetSize",MMUMergeTargetSize,
+            "Size of physical address range to scan the merged table for on completion of wirq")
+
 
 // setup
 int prepMMUMerge(struct irqData *data)
@@ -517,7 +525,12 @@
 	data->mergeTableCount = MMUMergeCount;
 
 	if( !data->mergeTableCount ){
-		Output("MMU Table merging disabled");
+		Output("MMU table merging disabled");
+		return 0;
+	}
+	if( data->mergeTableCount > 4096){
+		Output("MMU table merging request too long (max = 4096)");
+		data->mergeTableCount = 0;
 		return 0;
 	}
 	
@@ -556,13 +569,25 @@
 void dumpMMUMerge(struct irqData *data){
 	if( !data->mergeTableCount ) return;
 
-	Output("MMU Merge table:");
-	Output("Index  ( vAddr  ) = Last entry  x Change count");
-	for(uint i=0;i < data->mergeTableCount;i++)
-		if(data->l1Changed[i]){
-			uint idx = data->mergeTableStart + i;
-			Output("%5i  (%08x) = %08x   x %i",idx,(idx << 20), data->l1Copy[i],data->l1Changed[i]);
-		}	
+	Output("Dumping MMU Merge table (last change mappings):");
+	Output("  Virtual | Physical | Description |  Flags");
+	Output("  address | address  |             |");
+	Output("----------+----------+-------------+------------------------");
+	//now search the entire table, l1s and l2s, for anything in the range we're interested in
+	for(uint i=0;i < data->mergeTableCount;i++){
+		if(!data->l1Changed[i])continue;
+
+		uint32 l1d = data->l1Copy[i]; 		
+		uint32 mb = data->mergeTableStart + i;
+		int count = parseL1Entry(mb,l1d,	//reuse part of the main 'MMU DUMP' code
+			0xffffffff,			//pL1=0xffffffff (no sense of previous here)
+			0,				//l1only = 0,
+			(MMUMergeTargetSize == 0),	//showall = 1 if no range given;
+			MMUMergeTargetStart, MMUMergeTargetSize);
+
+		if(count > 0)
+			Output("----- End L1 entry %5i (%08x) change count: %i  -----",mb,(mb << 20),data->l1Changed[i]);
+	}
 }
 
 // perform check and merge
Only in delme/src: irq.cpp.rej
diff -ru delme2/src/watch.cpp delme/src/watch.cpp
--- delme2/src/watch.cpp	2008-06-18 19:26:24.000000000 +0100
+++ delme/src/watch.cpp	2008-06-18 19:15:13.000000000 +0100
@@ -224,16 +224,16 @@
 
 void
 watchListVar::reportWatch(const char *header, uint32 pos
-                          , uint32 newval, uint32 changed)
+                          , uint32 newval, uint32 changed, uint32 addr)
 {
     memcheck *mc = &watchlist[pos];
     const char *atype = "mem";
     if (mc->isInsn)
         atype = "insn";
 
-    Output("%s %s %s(%d) %08x=%08x (%08x)"
+    Output("%s %s %s(%d) %08x=%08x (%08x) @~%08x"
            , header, atype, name, pos
-           , mc->addr, newval, changed);
+           , mc->addr, newval, changed, addr);
 }
 
 static watchListVar *
@@ -333,7 +333,7 @@
                 continue;
             char header[64];
             _snprintf(header, sizeof(header), "%06d:", cur_time - start_time);
-            wl->reportWatch(header, i, val, changed);
+            wl->reportWatch(header, i, val, changed, 0);
         }
 
         cur_time = GetTickCount();