Minor optimization: eliminated one if statement from each bm_clear*() function.

git-svn-id: svn://svn.valgrind.org/valgrind/trunk@9609 a5019735-40e9-0310-863c-91ae7b9d1cf9

2 files changed, 68 insertions, 70 deletions

diff --git a/drd/drd_bitmap.c b/drd/drd_bitmap.c
index a70a7e07f..75ad65833 100644
--- a/drd/drd_bitmap.c
+++ b/drd/drd_bitmap.c
@@ -489,38 +489,42 @@ void DRD_(bm_clear)(struct bitmap* const bm, const Addr a1, const Addr a2)
       /* start on an UWord boundary, start clearing the first addresses.  */
       if (UWORD_LSB(c))
       {
-	 Addr c_next = UWORD_MSB(c) + BITS_PER_UWORD;
-	 if (c_next > b_next)
-	    c_next = b_next;
-	 bm0_clear_range(p2->bm1.bm0_r, c & ADDR0_MASK, c_next - c);
-	 bm0_clear_range(p2->bm1.bm0_w, c & ADDR0_MASK, c_next - c);
-	 c = c_next;
+         Addr c_next = UWORD_MSB(c) + BITS_PER_UWORD;
+         if (c_next > b_next)
+            c_next = b_next;
+#ifdef ENABLE_DRD_CONSISTENCY_CHECKS
+         tl_assert(a1 <= b && b <= c && c <= c_next && c_next <= b_next
+                   && b_next <= a2);
+#endif
+         bm0_clear_range(p2->bm1.bm0_r, c & ADDR0_MASK, c_next - c);
+         bm0_clear_range(p2->bm1.bm0_w, c & ADDR0_MASK, c_next - c);
+         c = c_next;
       }
       /* If some UWords have to be cleared entirely, do this now. */
       if (UWORD_LSB(c) == 0)
       {
-	 const Addr c_next = UWORD_MSB(b_next);
+         const Addr c_next = UWORD_MSB(b_next);
 #ifdef ENABLE_DRD_CONSISTENCY_CHECKS
-	 tl_assert(UWORD_LSB(c) == 0);
-	 tl_assert(UWORD_LSB(c_next) == 0);
-	 tl_assert(c_next <= b_next);
-	 tl_assert(c <= c_next);
+         tl_assert(UWORD_LSB(c) == 0);
+         tl_assert(UWORD_LSB(c_next) == 0);
+         tl_assert(c_next <= b_next);
+         tl_assert(c <= c_next);
 #endif
-	 if (c_next > c)
-	 {
-	    UWord idx = (c & ADDR0_MASK) >> BITS_PER_BITS_PER_UWORD;
-	    VG_(memset)(&p2->bm1.bm0_r[idx], 0, (c_next - c) / 8);
-	    VG_(memset)(&p2->bm1.bm0_w[idx], 0, (c_next - c) / 8);
-	    c = c_next;
-	 }
+         if (c_next > c)
+         {
+            UWord idx = (c & ADDR0_MASK) >> BITS_PER_BITS_PER_UWORD;
+            VG_(memset)(&p2->bm1.bm0_r[idx], 0, (c_next - c) / 8);
+            VG_(memset)(&p2->bm1.bm0_w[idx], 0, (c_next - c) / 8);
+            c = c_next;
+         }
       }
       /* If the last address in the bitmap that must be cleared does not */
       /* fall on an UWord boundary, clear the last addresses.            */
-      if (c < b_next)
-      {
-         bm0_clear_range(p2->bm1.bm0_r, c & ADDR0_MASK, b_next - c);
-         bm0_clear_range(p2->bm1.bm0_w, c & ADDR0_MASK, b_next - c);
-      }
+#ifdef ENABLE_DRD_CONSISTENCY_CHECKS
+      tl_assert(a1 <= b && b <= c && c <= b_next && b_next <= a2);
+#endif
+      bm0_clear_range(p2->bm1.bm0_r, c & ADDR0_MASK, b_next - c);
+      bm0_clear_range(p2->bm1.bm0_w, c & ADDR0_MASK, b_next - c);
    }
 }
 
@@ -570,15 +574,15 @@ void DRD_(bm_clear_load)(struct bitmap* const bm, const Addr a1, const Addr a2)
 #endif
       if (UWORD_LSB(c))
       {
-	 Addr c_next = UWORD_MSB(c) + BITS_PER_UWORD;
-	 if (c_next > b_next)
-	    c_next = b_next;
+         Addr c_next = UWORD_MSB(c) + BITS_PER_UWORD;
+         if (c_next > b_next)
+            c_next = b_next;
 #ifdef ENABLE_DRD_CONSISTENCY_CHECKS
-	 tl_assert(a1 <= b && b <= c && c < c_next && c_next <= b_next
-		   && b_next <= a2);
+         tl_assert(a1 <= b && b <= c && c < c_next && c_next <= b_next
+                   && b_next <= a2);
 #endif
-	 bm0_clear_range(p2->bm1.bm0_r, c & ADDR0_MASK, c_next - c);
-	 c = c_next;
+         bm0_clear_range(p2->bm1.bm0_r, c & ADDR0_MASK, c_next - c);
+         c = c_next;
       }
       /* If some UWords have to be cleared entirely, do this now. */
 #ifdef ENABLE_DRD_CONSISTENCY_CHECKS
@@ -586,29 +590,26 @@ void DRD_(bm_clear_load)(struct bitmap* const bm, const Addr a1, const Addr a2)
 #endif
       if (UWORD_LSB(c) == 0)
       {
-	 const Addr c_next = UWORD_MSB(b_next);
+         const Addr c_next = UWORD_MSB(b_next);
 #ifdef ENABLE_DRD_CONSISTENCY_CHECKS
-	 tl_assert(UWORD_LSB(c) == 0);
-	 tl_assert(UWORD_LSB(c_next) == 0);
-	 tl_assert(a1 <= b && b <= c && c <= c_next && c_next <= b_next
-		   && b_next <= a2);
+         tl_assert(UWORD_LSB(c) == 0);
+         tl_assert(UWORD_LSB(c_next) == 0);
+         tl_assert(a1 <= b && b <= c && c <= c_next && c_next <= b_next
+                   && b_next <= a2);
 #endif
-	 if (c_next > c)
-	 {
-	    UWord idx = (c & ADDR0_MASK) >> BITS_PER_BITS_PER_UWORD;
-	    VG_(memset)(&p2->bm1.bm0_r[idx], 0, (c_next - c) / 8);
-	    c = c_next;
-	 }
+         if (c_next > c)
+         {
+            UWord idx = (c & ADDR0_MASK) >> BITS_PER_BITS_PER_UWORD;
+            VG_(memset)(&p2->bm1.bm0_r[idx], 0, (c_next - c) / 8);
+            c = c_next;
+         }
       }
       /* If the last address in the bitmap that must be cleared does not */
       /* fall on an UWord boundary, clear the last addresses.            */
 #ifdef ENABLE_DRD_CONSISTENCY_CHECKS
       tl_assert(a1 <= b && b <= c && c <= b_next && b_next <= a2);
 #endif
-      if (c < b_next)
-      {
-	 bm0_clear_range(p2->bm1.bm0_r, c & ADDR0_MASK, b_next - c);
-      }
+      bm0_clear_range(p2->bm1.bm0_r, c & ADDR0_MASK, b_next - c);
    }
 }
 
@@ -645,7 +646,7 @@ void DRD_(bm_clear_store)(struct bitmap* const bm,
       b_next = (b & ~ADDR0_MASK) + ADDR0_COUNT;
       if (b_next > a2)
       {
-	b_next = a2;
+        b_next = a2;
       }
 
       if (p2 == 0)
@@ -659,15 +660,15 @@ void DRD_(bm_clear_store)(struct bitmap* const bm,
 #endif
       if (UWORD_LSB(c))
       {
-	Addr c_next = UWORD_MSB(c) + BITS_PER_UWORD;
-	if (c_next > b_next)
-	  c_next = b_next;
+        Addr c_next = UWORD_MSB(c) + BITS_PER_UWORD;
+        if (c_next > b_next)
+          c_next = b_next;
 #ifdef ENABLE_DRD_CONSISTENCY_CHECKS
-	tl_assert(a1 <= b && b <= c && c < c_next && c_next <= b_next
-		  && b_next <= a2);
+        tl_assert(a1 <= b && b <= c && c < c_next && c_next <= b_next
+                  && b_next <= a2);
 #endif
-	bm0_clear_range(p2->bm1.bm0_w, c & ADDR0_MASK, c_next - c);
-	c = c_next;
+        bm0_clear_range(p2->bm1.bm0_w, c & ADDR0_MASK, c_next - c);
+        c = c_next;
       }
       /* If some UWords have to be cleared entirely, do this now. */
 #ifdef ENABLE_DRD_CONSISTENCY_CHECKS
@@ -675,29 +676,26 @@ void DRD_(bm_clear_store)(struct bitmap* const bm,
 #endif
       if (UWORD_LSB(c) == 0)
       {
-	const Addr c_next = UWORD_MSB(b_next);
+        const Addr c_next = UWORD_MSB(b_next);
 #ifdef ENABLE_DRD_CONSISTENCY_CHECKS
-	tl_assert(UWORD_LSB(c) == 0);
-	tl_assert(UWORD_LSB(c_next) == 0);
-	tl_assert(a1 <= b && b <= c && c <= c_next && c_next <= b_next
-		  && b_next <= a2);
+        tl_assert(UWORD_LSB(c) == 0);
+        tl_assert(UWORD_LSB(c_next) == 0);
+        tl_assert(a1 <= b && b <= c && c <= c_next && c_next <= b_next
+                  && b_next <= a2);
 #endif
-	if (c_next > c)
-	{
-	  UWord idx = (c & ADDR0_MASK) >> BITS_PER_BITS_PER_UWORD;
-	  VG_(memset)(&p2->bm1.bm0_w[idx], 0, (c_next - c) / 8);
-	  c = c_next;
-	}
+        if (c_next > c)
+        {
+           UWord idx = (c & ADDR0_MASK) >> BITS_PER_BITS_PER_UWORD;
+           VG_(memset)(&p2->bm1.bm0_w[idx], 0, (c_next - c) / 8);
+           c = c_next;
+        }
       }
       /* If the last address in the bitmap that must be cleared does not */
       /* fall on an UWord boundary, clear the last addresses.            */
 #ifdef ENABLE_DRD_CONSISTENCY_CHECKS
       tl_assert(a1 <= b && b <= c && c <= b_next && b_next <= a2);
 #endif
-      if (c < b_next)
-      {
-	bm0_clear_range(p2->bm1.bm0_w, c & ADDR0_MASK, b_next - c);
-      }
+      bm0_clear_range(p2->bm1.bm0_w, c & ADDR0_MASK, b_next - c);
    }
 }
 
diff --git a/drd/drd_bitmap.h b/drd/drd_bitmap.h
index 1689435df..0043cdcad 100644
--- a/drd/drd_bitmap.h
+++ b/drd/drd_bitmap.h
@@ -137,9 +137,9 @@ static __inline__ void bm0_clear_range(UWord* bm0,
 {
 #ifdef ENABLE_DRD_CONSISTENCY_CHECKS
    tl_assert(a1 < ADDR0_COUNT);
-   tl_assert(size > 0);
+   tl_assert(size >= 0);
    tl_assert(a1 + size <= ADDR0_COUNT);
-   tl_assert(UWORD_MSB(a1) == UWORD_MSB(a1 + size - 1));
+   tl_assert(size == 0 || UWORD_MSB(a1) == UWORD_MSB(a1 + size - 1));
 #endif
    bm0[a1 >> BITS_PER_BITS_PER_UWORD]
       &= ~((((UWord)1 << size) - 1) << UWORD_LSB(a1));