diff --git a/memcheck/mc_leakcheck.c b/memcheck/mc_leakcheck.c
new file mode 100644
index 0000000..1ac39ee
--- /dev/null
+++ b/memcheck/mc_leakcheck.c
@@ -0,0 +1,824 @@
+
+/*--------------------------------------------------------------------*/
+/*--- The leak checker.                             mc_leakcheck.c ---*/
+/*--------------------------------------------------------------------*/
+
+/*
+   This file is part of MemCheck, a heavyweight Valgrind tool for
+   detecting memory errors.
+
+   Copyright (C) 2000-2005 Julian Seward 
+      jseward@acm.org
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2 of the
+   License, or (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307, USA.
+
+   The GNU General Public License is contained in the file COPYING.
+*/
+
+#include "pub_tool_basics.h"
+#include "pub_tool_aspacemgr.h"
+#include "pub_tool_execontext.h"
+#include "pub_tool_hashtable.h"
+#include "pub_tool_libcbase.h"
+#include "pub_tool_libcassert.h"
+#include "pub_tool_libcprint.h"
+#include "pub_tool_libcsignal.h"
+#include "pub_tool_machine.h"
+#include "pub_tool_mallocfree.h"
+#include "pub_tool_options.h"
+#include "pub_tool_signals.h"
+#include "pub_tool_tooliface.h"     // Needed for mc_include.h
+
+#include "mc_include.h"
+
+#include <setjmp.h>                 // For jmp_buf
+
+
+/* Define to debug the memory-leak-detector. */
+#define VG_DEBUG_LEAKCHECK 0
+#define VG_DEBUG_CLIQUE	   0
+
+/*------------------------------------------------------------*/
+/*--- Low-level address-space scanning, for the leak       ---*/
+/*--- detector.                                            ---*/
+/*------------------------------------------------------------*/
+
+static 
+jmp_buf memscan_jmpbuf;
+
+
+static
+void scan_all_valid_memory_catcher ( Int sigNo, Addr addr )
+{
+   if (0)
+      VG_(printf)("OUCH! sig=%d addr=%p\n", sigNo, addr);
+   if (sigNo == VKI_SIGSEGV || sigNo == VKI_SIGBUS)
+      __builtin_longjmp(memscan_jmpbuf, 1);
+}
+
+
+/* TODO: GIVE THIS A PROPER HOME
+   TODO: MERGE THIS WITH DUPLICATE IN m_main.c and coredump-elf.c.
+   Extract from aspacem a vector of the current segment start
+   addresses.  The vector is dynamically allocated and should be freed
+   by the caller when done.  REQUIRES m_mallocfree to be running.
+   Writes the number of addresses required into *n_acquired. */
+
+static Addr* get_seg_starts ( /*OUT*/Int* n_acquired )
+{
+   Addr* starts;
+   Int   n_starts, r = 0;
+
+   n_starts = 1;
+   while (True) {
+      starts = VG_(malloc)( n_starts * sizeof(Addr) );
+      if (starts == NULL)
+         break;
+      r = VG_(am_get_segment_starts)( starts, n_starts );
+      if (r >= 0)
+         break;
+      VG_(free)(starts);
+      n_starts *= 2;
+   }
+
+   if (starts == NULL) {
+     *n_acquired = 0;
+     return NULL;
+   }
+
+   *n_acquired = r;
+   return starts;
+}
+
+
+/*------------------------------------------------------------*/
+/*--- Detecting leaked (unreachable) malloc'd blocks.      ---*/
+/*------------------------------------------------------------*/
+
+/* A block is either 
+   -- Proper-ly reached; a pointer to its start has been found
+   -- Interior-ly reached; only an interior pointer to it has been found
+   -- Unreached; so far, no pointers to any part of it have been found. 
+   -- IndirectLeak; leaked, but referred to by another leaked block
+*/
+typedef 
+   enum { 
+      Unreached    =0, 
+      IndirectLeak =1,
+      Interior     =2, 
+      Proper       =3
+  }
+  Reachedness;
+
+/* An entry in the mark stack */
+typedef 
+   struct {
+      Int   next:30;	/* Index of next in mark stack */
+      UInt  state:2;	/* Reachedness */
+      SizeT indirect;	/* if Unreached, how much is unreachable from here */
+   } 
+   MarkStack;
+
+/* A block record, used for generating err msgs. */
+typedef
+   struct _LossRecord {
+      struct _LossRecord* next;
+      /* Where these lost blocks were allocated. */
+      ExeContext*  allocated_at;
+      /* Their reachability. */
+      Reachedness  loss_mode;
+      /* Number of blocks and total # bytes involved. */
+      SizeT        total_bytes;
+      SizeT        indirect_bytes;
+      UInt         num_blocks;
+   }
+   LossRecord;
+
+/* The 'extra' struct for leak errors. */
+typedef 
+   struct {
+      UInt        n_this_record;
+      UInt        n_total_records;
+      LossRecord* lossRecord;
+   }
+   LeakExtra;
+
+/* Find the i such that ptr points at or inside the block described by
+   shadows[i].  Return -1 if none found.  This assumes that shadows[]
+   has been sorted on the ->data field. */
+
+#if VG_DEBUG_LEAKCHECK
+/* Used to sanity-check the fast binary-search mechanism. */
+static 
+Int find_shadow_for_OLD ( Addr       ptr, 
+                          MC_Chunk** shadows,
+                          Int        n_shadows )
+
+{
+   Int  i;
+   Addr a_lo, a_hi;
+   PROF_EVENT(70, "find_shadow_for_OLD");
+   for (i = 0; i < n_shadows; i++) {
+      PROF_EVENT(71, "find_shadow_for_OLD(loop)");
+      a_lo = shadows[i]->data;
+      a_hi = ((Addr)shadows[i]->data) + shadows[i]->size;
+      if (a_lo <= ptr && ptr <= a_hi)
+         return i;
+   }
+   return -1;
+}
+#endif
+
+
+static 
+Int find_shadow_for ( Addr       ptr, 
+                      MC_Chunk** shadows,
+                      Int        n_shadows )
+{
+   Addr a_mid_lo, a_mid_hi;
+   Int lo, mid, hi, retVal;
+   /* VG_(printf)("find shadow for %p = ", ptr); */
+   retVal = -1;
+   lo = 0;
+   hi = n_shadows-1;
+   while (True) {
+      /* invariant: current unsearched space is from lo to hi, inclusive. */
+      if (lo > hi) break; /* not found */
+
+      mid      = (lo + hi) / 2;
+      a_mid_lo = shadows[mid]->data;
+      a_mid_hi = shadows[mid]->data + shadows[mid]->size;
+
+      if (ptr < a_mid_lo) {
+         hi = mid-1;
+         continue;
+      } 
+      if (ptr > a_mid_hi) {
+         lo = mid+1;
+         continue;
+      }
+      tl_assert(ptr >= a_mid_lo && ptr <= a_mid_hi);
+      retVal = mid;
+      break;
+   }
+
+#  if VG_DEBUG_LEAKCHECK
+   tl_assert(retVal == find_shadow_for_OLD ( ptr, shadows, n_shadows ));
+#  endif
+   /* VG_(printf)("%d\n", retVal); */
+   return retVal;
+}
+
+/* Globals, for the following callback used by VG_(detect_memory_leaks). */
+static MC_Chunk** lc_shadows;
+static Int        lc_n_shadows;
+static MarkStack* lc_markstack;
+static Int	  lc_markstack_top;
+static Addr       lc_min_mallocd_addr;
+static Addr       lc_max_mallocd_addr;
+static SizeT	  lc_scanned;
+
+static Bool	  (*lc_is_within_valid_secondary) (Addr addr);
+static Bool	  (*lc_is_valid_aligned_word)     (Addr addr);
+
+static const HChar* str_lossmode ( Reachedness lossmode )
+{
+   const HChar *loss = "?";
+   switch (lossmode) {
+      case Unreached:    loss = "definitely lost"; break;
+      case IndirectLeak: loss = "indirectly lost"; break;
+      case Interior:     loss = "possibly lost"; break;
+      case Proper:       loss = "still reachable"; break;
+   }
+   return loss;
+}
+
+static const HChar* xml_kind ( Reachedness lossmode )
+{
+   const HChar *loss = "?";
+   switch (lossmode) {
+      case Unreached:    loss = "Leak_DefinitelyLost"; break;
+      case IndirectLeak: loss = "Leak_IndirectlyLost"; break;
+      case Interior:     loss = "Leak_PossiblyLost"; break;
+      case Proper:       loss = "Leak_StillReachable"; break;
+   }
+   return loss;
+}
+
+
+/* Used for printing leak errors, avoids exposing the LossRecord type (which
+   comes in as void*, requiring a cast. */
+void MC_(pp_LeakError)(void* vextra)
+{
+   HChar* xpre  = VG_(clo_xml) ? "  <what>" : "";
+   HChar* xpost = VG_(clo_xml) ? "</what>"  : "";
+
+   LeakExtra* extra = (LeakExtra*)vextra;
+   LossRecord* l    = extra->lossRecord;
+   const Char *loss = str_lossmode(l->loss_mode);
+
+   if (VG_(clo_xml)) {
+      VG_(message)(Vg_UserMsg, "  <kind>%t</kind>", xml_kind(l->loss_mode));
+   } else {
+      VG_(message)(Vg_UserMsg, "");
+   }
+
+   if (l->indirect_bytes) {
+      VG_(message)(Vg_UserMsg, 
+         "%s%,lu (%,lu direct, %,lu indirect) bytes in %,u blocks"
+         " are %s in loss record %,u of %,u%s",
+         xpre,
+         l->total_bytes + l->indirect_bytes, 
+         l->total_bytes, l->indirect_bytes, l->num_blocks,
+         loss, extra->n_this_record, extra->n_total_records,
+         xpost
+      );
+      if (VG_(clo_xml)) {
+         // Nb: don't put commas in these XML numbers 
+         VG_(message)(Vg_UserMsg, "  <leakedbytes>%lu</leakedbytes>", 
+                                  l->total_bytes + l->indirect_bytes);
+         VG_(message)(Vg_UserMsg, "  <leakedblocks>%u</leakedblocks>", 
+                                  l->num_blocks);
+      }
+   } else {
+      VG_(message)(
+         Vg_UserMsg, 
+         "%s%,lu bytes in %,u blocks are %s in loss record %,u of %,u%s",
+         xpre,
+         l->total_bytes, l->num_blocks,
+         loss, extra->n_this_record, extra->n_total_records,
+         xpost
+      );
+      if (VG_(clo_xml)) {
+         VG_(message)(Vg_UserMsg, "  <leakedbytes>%d</leakedbytes>", 
+                                  l->total_bytes);
+         VG_(message)(Vg_UserMsg, "  <leakedblocks>%d</leakedblocks>", 
+                                  l->num_blocks);
+      }
+   }
+   VG_(pp_ExeContext)(l->allocated_at);
+}
+
+SizeT MC_(bytes_leaked)     = 0;
+SizeT MC_(bytes_indirect)   = 0;
+SizeT MC_(bytes_dubious)    = 0;
+SizeT MC_(bytes_reachable)  = 0;
+SizeT MC_(bytes_suppressed) = 0;
+
+static Int lc_compar(void* n1, void* n2)
+{
+   MC_Chunk* mc1 = *(MC_Chunk**)n1;
+   MC_Chunk* mc2 = *(MC_Chunk**)n2;
+   return (mc1->data < mc2->data ? -1 : 1);
+}
+
+/* If ptr is pointing to a heap-allocated block which hasn't been seen
+   before, push it onto the mark stack.  Clique is the index of the
+   clique leader; -1 if none. */
+static void lc_markstack_push_WRK(Addr ptr, Int clique)
+{
+   Int sh_no;
+
+   /* quick filter */
+   if (!VG_(am_is_valid_for_client)(ptr, 1, VKI_PROT_NONE))
+      return;
+
+   sh_no = find_shadow_for(ptr, lc_shadows, lc_n_shadows);
+
+   if (VG_DEBUG_LEAKCHECK)
+      VG_(printf)("ptr=%p -> block %d\n", ptr, sh_no);
+
+   if (sh_no == -1)
+      return;
+
+   tl_assert(sh_no >= 0 && sh_no < lc_n_shadows);
+   tl_assert(ptr <= lc_shadows[sh_no]->data + lc_shadows[sh_no]->size);
+
+   if (lc_markstack[sh_no].state == Unreached) {
+      if (0)
+	 VG_(printf)("pushing %p-%p\n", lc_shadows[sh_no]->data, 
+		     lc_shadows[sh_no]->data + lc_shadows[sh_no]->size);
+
+      tl_assert(lc_markstack[sh_no].next == -1);
+      lc_markstack[sh_no].next = lc_markstack_top;
+      lc_markstack_top = sh_no;
+   }
+
+   tl_assert(clique >= -1 && clique < lc_n_shadows);
+
+   if (clique != -1) {
+      if (0)
+	 VG_(printf)("mopup: %d: %p is %d\n", 
+		     sh_no, lc_shadows[sh_no]->data, lc_markstack[sh_no].state);
+
+      /* An unmarked block - add it to the clique.  Add its size to
+	 the clique-leader's indirect size.  If the new block was
+	 itself a clique leader, it isn't any more, so add its
+	 indirect to the new clique leader.
+
+	 If this block *is* the clique leader, it means this is a
+	 cyclic structure, so none of this applies. */
+      if (lc_markstack[sh_no].state == Unreached) {
+	 lc_markstack[sh_no].state = IndirectLeak;
+
+	 if (sh_no != clique) {
+	    if (VG_DEBUG_CLIQUE) {
+	       if (lc_markstack[sh_no].indirect)
+		  VG_(printf)("  clique %d joining clique %d adding %d+%d bytes\n", 
+			      sh_no, clique, 
+			      lc_shadows[sh_no]->size, lc_markstack[sh_no].indirect);
+	       else
+		  VG_(printf)("  %d joining %d adding %d\n", 
+			      sh_no, clique, lc_shadows[sh_no]->size);
+	    }
+
+	    lc_markstack[clique].indirect += lc_shadows[sh_no]->size;
+	    lc_markstack[clique].indirect += lc_markstack[sh_no].indirect;
+	    lc_markstack[sh_no].indirect = 0; /* shouldn't matter */
+	 }
+      }
+   } else if (ptr == lc_shadows[sh_no]->data) {
+      lc_markstack[sh_no].state = Proper;
+   } else {
+      if (lc_markstack[sh_no].state == Unreached)
+	 lc_markstack[sh_no].state = Interior;
+   }
+}
+
+static void lc_markstack_push(Addr ptr)
+{
+   lc_markstack_push_WRK(ptr, -1);
+}
+
+/* Return the top of the mark stack, if any. */
+static Int lc_markstack_pop(void)
+{
+   Int ret = lc_markstack_top;
+
+   if (ret != -1) {
+      lc_markstack_top = lc_markstack[ret].next;
+      lc_markstack[ret].next = -1;
+   }
+
+   return ret;
+}
+
+
+/* Scan a block of memory between [start, start+len).  This range may
+   be bogus, inaccessable, or otherwise strange; we deal with it.
+
+   If clique != -1, it means we're gathering leaked memory into
+   cliques, and clique is the index of the current clique leader. */
+static void lc_scan_memory_WRK(Addr start, SizeT len, Int clique)
+{
+   Addr ptr = VG_ROUNDUP(start, sizeof(Addr));
+   Addr end = VG_ROUNDDN(start+len, sizeof(Addr));
+   vki_sigset_t sigmask;
+
+   if (VG_DEBUG_LEAKCHECK)
+      VG_(printf)("scan %p-%p\n", start, start+len);
+   VG_(sigprocmask)(VKI_SIG_SETMASK, NULL, &sigmask);
+   VG_(set_fault_catcher)(scan_all_valid_memory_catcher);
+
+   //   lc_scanned += end-ptr;
+
+   if (!VG_(am_is_valid_for_client)(ptr, sizeof(Addr), VKI_PROT_READ))
+      ptr = VG_PGROUNDUP(ptr+1);	/* first page bad */
+
+   while (ptr < end) {
+      Addr addr;
+
+      /* Skip invalid chunks */
+      if (!(*lc_is_within_valid_secondary)(ptr)) {
+	 ptr = VG_ROUNDUP(ptr+1, SM_SIZE);
+	 continue;
+      }
+
+      /* Look to see if this page seems reasonble */
+      if ((ptr % VKI_PAGE_SIZE) == 0) {
+	 if (!VG_(am_is_valid_for_client)(ptr, sizeof(Addr), VKI_PROT_READ))
+	    ptr += VKI_PAGE_SIZE; /* bad page - skip it */
+      }
+
+      if (__builtin_setjmp(memscan_jmpbuf) == 0) {
+	 if ((*lc_is_valid_aligned_word)(ptr)) {
+            lc_scanned += sizeof(Addr);
+	    addr = *(Addr *)ptr;
+	    lc_markstack_push_WRK(addr, clique);
+	 } else if (0 && VG_DEBUG_LEAKCHECK)
+	    VG_(printf)("%p not valid\n", ptr);
+	 ptr += sizeof(Addr);
+      } else {
+	 /* We need to restore the signal mask, because we were
+	    longjmped out of a signal handler. */
+	 VG_(sigprocmask)(VKI_SIG_SETMASK, &sigmask, NULL);
+
+	 ptr = VG_PGROUNDUP(ptr+1);	/* bad page - skip it */
+      }
+   }
+
+   VG_(sigprocmask)(VKI_SIG_SETMASK, &sigmask, NULL);
+   VG_(set_fault_catcher)(NULL);
+}
+
+
+static void lc_scan_memory(Addr start, SizeT len)
+{
+   lc_scan_memory_WRK(start, len, -1);
+}
+
+/* Process the mark stack until empty.  If mopup is true, then we're
+   actually gathering leaked blocks, so they should be marked
+   IndirectLeak. */
+static void lc_do_leakcheck(Int clique)
+{
+   Int top;
+
+   while((top = lc_markstack_pop()) != -1) {
+      tl_assert(top >= 0 && top < lc_n_shadows);      
+      tl_assert(lc_markstack[top].state != Unreached);
+
+      lc_scan_memory_WRK(lc_shadows[top]->data, lc_shadows[top]->size, clique);
+   }
+}
+
+static SizeT blocks_leaked;
+static SizeT blocks_indirect;
+static SizeT blocks_dubious;
+static SizeT blocks_reachable;
+static SizeT blocks_suppressed;
+
+static void full_report(ThreadId tid)
+{
+   Int i;
+   Int    n_lossrecords;
+   LossRecord* errlist;
+   LossRecord* p;
+   Bool   is_suppressed;
+   LeakExtra leak_extra;
+
+   /* Go through and group lost structures into cliques.  For each
+      Unreached block, push it onto the mark stack, and find all the
+      blocks linked to it.  These are marked IndirectLeak, and their
+      size is added to the clique leader's indirect size.  If one of
+      the found blocks was itself a clique leader (from a previous
+      pass), then the cliques are merged. */
+   for (i = 0; i < lc_n_shadows; i++) {
+      if (VG_DEBUG_CLIQUE)
+	 VG_(printf)("cliques: %d at %p -> %s\n",
+		     i, lc_shadows[i]->data, str_lossmode(lc_markstack[i].state));
+      if (lc_markstack[i].state != Unreached)
+	 continue;
+
+      tl_assert(lc_markstack_top == -1);
+
+      if (VG_DEBUG_CLIQUE)
+	 VG_(printf)("%d: gathering clique %p\n", i, lc_shadows[i]->data);
+      
+      lc_markstack_push_WRK(lc_shadows[i]->data, i);
+
+      lc_do_leakcheck(i);
+
+      tl_assert(lc_markstack_top == -1);
+      tl_assert(lc_markstack[i].state == IndirectLeak
+                /* jrs 20051218: Ashley Pittman supplied a
+                   custom-allocator test program which causes the ==
+                   IndirectLeak condition to fail - it causes .state
+                   to be Unreached.  Since I have no idea how this
+                   clique stuff works and no time to figure it out,
+                   just allow that condition too.  This could well be
+                   a completely bogus fix.  It doesn't seem unsafe
+                   given that in any case the .state field is
+                   immediately overwritten by the next statement. */
+                || lc_markstack[i].state == Unreached);
+
+      lc_markstack[i].state = Unreached; /* Return to unreached state,
+					    to indicate its a clique
+					    leader */
+   }
+      
+   /* Common up the lost blocks so we can print sensible error messages. */
+   n_lossrecords = 0;
+   errlist       = NULL;
+   for (i = 0; i < lc_n_shadows; i++) {
+      ExeContext* where = lc_shadows[i]->where;
+
+      for (p = errlist; p != NULL; p = p->next) {
+         if (p->loss_mode == lc_markstack[i].state
+             && VG_(eq_ExeContext) ( MC_(clo_leak_resolution),
+                                     p->allocated_at, 
+                                     where) ) {
+            break;
+	 }
+      }
+      if (p != NULL) {
+         p->num_blocks  ++;
+         p->total_bytes += lc_shadows[i]->size;
+	 p->indirect_bytes += lc_markstack[i].indirect;
+      } else {
+         n_lossrecords ++;
+         p = VG_(malloc)(sizeof(LossRecord));
+         p->loss_mode    = lc_markstack[i].state;
+         p->allocated_at = where;
+         p->total_bytes  = lc_shadows[i]->size;
+	 p->indirect_bytes = lc_markstack[i].indirect;
+         p->num_blocks   = 1;
+         p->next         = errlist;
+         errlist         = p;
+      }
+   }
+
+   /* Print out the commoned-up blocks and collect summary stats. */
+   for (i = 0; i < n_lossrecords; i++) {
+      Bool        print_record;
+      LossRecord* p_min = NULL;
+      SizeT       n_min = ~(0x0L);
+      for (p = errlist; p != NULL; p = p->next) {
+         if (p->num_blocks > 0 && p->total_bytes < n_min) {
+            n_min = p->total_bytes + p->indirect_bytes;
+            p_min = p;
+         }
+      }
+      tl_assert(p_min != NULL);
+
+      /* Ok to have tst==NULL;  it's only used if --gdb-attach=yes, and
+         we disallow that when --leak-check=yes.  
+         
+         Prints the error if not suppressed, unless it's reachable (Proper
+         or IndirectLeak) and --show-reachable=no */
+
+      print_record = ( MC_(clo_show_reachable) || 
+		       Unreached == p_min->loss_mode || 
+                       Interior == p_min->loss_mode );
+
+      // Nb: because VG_(unique_error) does all the error processing
+      // immediately, and doesn't save the error, leakExtra can be
+      // stack-allocated.
+      leak_extra.n_this_record   = i+1;
+      leak_extra.n_total_records = n_lossrecords;
+      leak_extra.lossRecord      = p_min;
+      is_suppressed = 
+         MC_(record_leak_error) ( tid, &leak_extra, p_min->allocated_at,
+                                  print_record );
+
+      if (is_suppressed) {
+         blocks_suppressed     += p_min->num_blocks;
+         MC_(bytes_suppressed) += p_min->total_bytes;
+
+      } else if (Unreached == p_min->loss_mode) {
+         blocks_leaked       += p_min->num_blocks;
+         MC_(bytes_leaked)   += p_min->total_bytes;
+
+      } else if (IndirectLeak == p_min->loss_mode) {
+         blocks_indirect     += p_min->num_blocks;
+         MC_(bytes_indirect) += p_min->total_bytes;
+
+      } else if (Interior   == p_min->loss_mode) {
+         blocks_dubious     += p_min->num_blocks;
+         MC_(bytes_dubious) += p_min->total_bytes;
+
+      } else if (Proper       == p_min->loss_mode) {
+         blocks_reachable     += p_min->num_blocks;
+         MC_(bytes_reachable) += p_min->total_bytes;
+
+      } else {
+         VG_(tool_panic)("generic_detect_memory_leaks: unknown loss mode");
+      }
+      p_min->num_blocks = 0;
+   }
+}
+
+/* Compute a quick summary of the leak check. */
+static void make_summary(void)
+{
+   Int i;
+
+   for(i = 0; i < lc_n_shadows; i++) {
+      SizeT size = lc_shadows[i]->size;
+
+      switch(lc_markstack[i].state) {
+      case Unreached:
+	 blocks_leaked++;
+	 MC_(bytes_leaked) += size;
+	 break;
+
+      case Proper:
+	 blocks_reachable++;
+	 MC_(bytes_reachable) += size;
+	 break;
+
+      case Interior:
+	 blocks_dubious++;
+	 MC_(bytes_dubious) += size;
+	 break;
+	 
+      case IndirectLeak:	/* shouldn't happen */
+	 blocks_indirect++;
+	 MC_(bytes_indirect) += size;
+	 break;
+      }
+   }
+}
+
+/* Top level entry point to leak detector.  Call here, passing in
+   suitable address-validating functions (see comment at top of
+   scan_all_valid_memory above).  These functions used to encapsulate the
+   differences between Memcheck and Addrcheck;  they no longer do but it
+   doesn't hurt to keep them here.
+*/
+void MC_(do_detect_memory_leaks) (
+   ThreadId tid, LeakCheckMode mode,
+   Bool (*is_within_valid_secondary) ( Addr ),
+   Bool (*is_valid_aligned_word)     ( Addr )
+)
+{
+   Int i;
+   
+   tl_assert(mode != LC_Off);
+
+   /* VG_(HT_to_array) allocates storage for shadows */
+   lc_shadows = (MC_Chunk**)VG_(HT_to_array)( MC_(malloc_list),
+                                              &lc_n_shadows );
+
+   /* Sort the array. */
+   VG_(ssort)((void*)lc_shadows, lc_n_shadows, sizeof(VgHashNode*), lc_compar);
+
+   /* Sanity check; assert that the blocks are now in order */
+   for (i = 0; i < lc_n_shadows-1; i++) {
+      tl_assert( lc_shadows[i]->data <= lc_shadows[i+1]->data);
+   }
+
+   /* Sanity check -- make sure they don't overlap */
+   for (i = 0; i < lc_n_shadows-1; i++) {
+      tl_assert( lc_shadows[i]->data + lc_shadows[i]->size
+                 <= lc_shadows[i+1]->data );
+   }
+
+   if (lc_n_shadows == 0) {
+      tl_assert(lc_shadows == NULL);
+      if (VG_(clo_verbosity) >= 1 && !VG_(clo_xml)) {
+         VG_(message)(Vg_UserMsg, 
+                      "All heap blocks were freed -- no leaks are possible.");
+      }
+      return;
+   }
+
+   if (VG_(clo_verbosity) > 0 && !VG_(clo_xml))
+      VG_(message)(Vg_UserMsg, 
+                   "searching for pointers to %,d not-freed blocks.", 
+                   lc_n_shadows );
+
+   lc_min_mallocd_addr = lc_shadows[0]->data;
+   lc_max_mallocd_addr = lc_shadows[lc_n_shadows-1]->data
+                         + lc_shadows[lc_n_shadows-1]->size;
+
+   lc_markstack = VG_(malloc)( lc_n_shadows * sizeof(*lc_markstack) );
+   for (i = 0; i < lc_n_shadows; i++) {
+      lc_markstack[i].next = -1;
+      lc_markstack[i].state = Unreached;
+      lc_markstack[i].indirect = 0;
+   }
+   lc_markstack_top = -1;
+
+   lc_is_within_valid_secondary = is_within_valid_secondary;
+   lc_is_valid_aligned_word     = is_valid_aligned_word;
+
+   lc_scanned = 0;
+
+   /* Push roots onto the mark stack.  Roots are:
+      - the integer registers of all threads
+      - all mappings belonging to the client, including stacks
+      - .. but excluding any client heap segments.
+      Client heap segments are excluded because we wish to differentiate
+      client heap blocks which are referenced only from inside the heap
+      from those outside.  This facilitates the indirect vs direct loss
+      categorisation, which [if the users ever manage to understand it]
+      is really useful for detecting lost cycles.
+   */
+   { NSegment* seg;
+     Addr*     seg_starts;
+     Int       n_seg_starts;
+     seg_starts = get_seg_starts( &n_seg_starts );
+     tl_assert(seg_starts && n_seg_starts > 0);
+     /* VG_(am_show_nsegments)( 0,"leakcheck"); */
+     for (i = 0; i < n_seg_starts; i++) {
+        seg = VG_(am_find_nsegment)( seg_starts[i] );
+        tl_assert(seg);
+        if (seg->kind != SkFileC && seg->kind != SkAnonC) 
+           continue;
+        if (!(seg->hasR && seg->hasW))
+           continue;
+        if (seg->isCH)
+           continue;
+        if (0)
+           VG_(printf)("ACCEPT %2d  %p %p\n", i, seg->start, seg->end);
+        lc_scan_memory(seg->start, seg->end+1 - seg->start);
+     }
+   }
+
+   /* Push registers onto mark stack */
+   VG_(apply_to_GP_regs)(lc_markstack_push);
+
+   /* Keep walking the heap until everything is found */
+   lc_do_leakcheck(-1);
+
+   if (VG_(clo_verbosity) > 0 && !VG_(clo_xml))
+      VG_(message)(Vg_UserMsg, "checked %,lu bytes.", lc_scanned);
+
+   blocks_leaked     = MC_(bytes_leaked)     = 0;
+   blocks_indirect   = MC_(bytes_indirect)   = 0;
+   blocks_dubious    = MC_(bytes_dubious)    = 0;
+   blocks_reachable  = MC_(bytes_reachable)  = 0;
+   blocks_suppressed = MC_(bytes_suppressed) = 0;
+
+   if (mode == LC_Full)
+      full_report(tid);
+   else
+      make_summary();
+
+   if (VG_(clo_verbosity) > 0 && !VG_(clo_xml)) {
+      VG_(message)(Vg_UserMsg, "");
+      VG_(message)(Vg_UserMsg, "LEAK SUMMARY:");
+      VG_(message)(Vg_UserMsg, "   definitely lost: %,lu bytes in %,lu blocks.",
+                               MC_(bytes_leaked), blocks_leaked );
+      if (blocks_indirect > 0)
+	 VG_(message)(Vg_UserMsg, "   indirectly lost: %,lu bytes in %,lu blocks.",
+		      MC_(bytes_indirect), blocks_indirect );
+      VG_(message)(Vg_UserMsg, "     possibly lost: %,lu bytes in %,lu blocks.",
+                               MC_(bytes_dubious), blocks_dubious );
+      VG_(message)(Vg_UserMsg, "   still reachable: %,lu bytes in %,lu blocks.",
+                               MC_(bytes_reachable), blocks_reachable );
+      VG_(message)(Vg_UserMsg, "        suppressed: %,lu bytes in %,lu blocks.",
+                               MC_(bytes_suppressed), blocks_suppressed );
+      if (mode == LC_Summary && blocks_leaked > 0)
+	 VG_(message)(Vg_UserMsg,
+		      "Use --leak-check=full to see details of leaked memory.");
+      else if (!MC_(clo_show_reachable)) {
+         VG_(message)(Vg_UserMsg, 
+           "Reachable blocks (those to which a pointer was found) are not shown.");
+         VG_(message)(Vg_UserMsg, 
+            "To see them, rerun with: --show-reachable=yes");
+      }
+   }
+
+   VG_(free) ( lc_shadows );
+   VG_(free) ( lc_markstack );
+}
+
+/*--------------------------------------------------------------------*/
+/*--- end                                                          ---*/
+/*--------------------------------------------------------------------*/
+