drd_bitmap_test compiles again.

git-svn-id: svn://svn.valgrind.org/valgrind/trunk@9173

diff --git a/drd/drd_bitmap.c b/drd/drd_bitmap.c
index cd3ec1a250e8976692c9f9c240bcaa2e05d0f7d6..350988491c1f8b69f6810b02c56cea318204abc3 100644 (file)
--- a/drd/drd_bitmap.c
+++ b/drd/drd_bitmap.c
@@ -23,17 +23,18 @@
 */
 
 
-#include "pub_tool_basics.h"      // Addr, SizeT
-#include "pub_tool_debuginfo.h"   // VG_(get_objname)()
-#include "pub_tool_libcassert.h"  // tl_assert()
-#include "pub_tool_libcbase.h"    // VG_(memset)
-#include "pub_tool_libcprint.h"   // VG_(printf)
-#include "pub_tool_machine.h"     // VG_(get_IP)()
-#include "pub_tool_mallocfree.h"  // VG_(malloc), VG_(free)
-#include "pub_drd_bitmap.h"
+#include "drd_basics.h"           /* DRD_() */
 #include "drd_bitmap.h"
 #include "drd_error.h"
 #include "drd_suppression.h"
+#include "pub_drd_bitmap.h"
+#include "pub_tool_basics.h"      /* Addr, SizeT */
+#include "pub_tool_debuginfo.h"   /* VG_(get_objname)() */
+#include "pub_tool_libcassert.h"  /* tl_assert() */
+#include "pub_tool_libcbase.h"    /* VG_(memset) */
+#include "pub_tool_libcprint.h"   /* VG_(printf) */
+#include "pub_tool_machine.h"     /* VG_(get_IP)() */
+#include "pub_tool_mallocfree.h"  /* VG_(malloc), VG_(free) */
 
 
 /* Forward declarations. */

diff --git a/drd/tests/drd_bitmap_test.c b/drd/tests/drd_bitmap_test.c
index ea12300b97fcd5572bdfb1d4388657c0a893f7bb..9013c6f8f5d06af020fb9ea456b13413ae001ff0 100644 (file)
--- a/drd/tests/drd_bitmap_test.c
+++ b/drd/tests/drd_bitmap_test.c
@@ -72,48 +72,48 @@ void bm_test1(void)
   struct bitmap* bm2;
   unsigned i, j;
 
-  bm = bm_new();
+  bm = DRD_(bm_new)();
 
   for (i = 0; i < sizeof(s_test1_args)/sizeof(s_test1_args[0]); i++)
   {
-    bm_access_range(bm,
-                    s_test1_args[i].address,
-                    s_test1_args[i].address + s_test1_args[i].size,
-                    s_test1_args[i].access_type);
+    DRD_(bm_access_range)(bm,
+                          s_test1_args[i].address,
+                          s_test1_args[i].address + s_test1_args[i].size,
+                          s_test1_args[i].access_type);
   }
 
   if (s_verbose)
   {
     VG_(printf)("Bitmap contents:\n");
-    bm_print(bm);
+    DRD_(bm_print)(bm);
   }
 
   for (i = 0; i < sizeof(s_test1_args)/sizeof(s_test1_args[0]); i++)
   {
     for (j = 0; j < s_test1_args[i].size; j++)
     {
-      tl_assert(bm_has_1(bm,
-                         s_test1_args[i].address + j,
-                         s_test1_args[i].access_type));
+      tl_assert(DRD_(bm_has_1)(bm,
+                               s_test1_args[i].address + j,
+                               s_test1_args[i].access_type));
     }
   }
 
   if (s_verbose)
     VG_(printf)("Merge result:\n");
-  bm2 = bm_new();
-  bm_merge2(bm2, bm);
-  bm_merge2(bm2, bm);
+  bm2 = DRD_(bm_new)();
+  DRD_(bm_merge2)(bm2, bm);
+  DRD_(bm_merge2)(bm2, bm);
   if (s_verbose)
-    bm_print(bm2);
+    DRD_(bm_print)(bm2);
   //assert(bm_equal(bm, bm2));
-  assert(bm_equal(bm2, bm));
+  assert(DRD_(bm_equal)(bm2, bm));
 
   if (s_verbose)
     VG_(printf)("Deleting bitmap bm\n");
-  bm_delete(bm);
+  DRD_(bm_delete)(bm);
   if (s_verbose)
     VG_(printf)("Deleting bitmap bm2\n");
-  bm_delete(bm2);
+  DRD_(bm_delete)(bm2);
 }
 
 /** Test whether bm_equal() works correctly. */
@@ -122,20 +122,20 @@ void bm_test2()
   struct bitmap* bm1;
   struct bitmap* bm2;
 
-  bm1 = bm_new();
-  bm2 = bm_new();
-  bm_access_load_1(bm1, 7);
-  bm_access_load_1(bm2, ADDR0_COUNT + 7);
-  assert(! bm_equal(bm1, bm2));
-  assert(! bm_equal(bm2, bm1));
-  bm_access_load_1(bm2, 7);
-  assert(! bm_equal(bm1, bm2));
-  assert(! bm_equal(bm2, bm1));
-  bm_access_store_1(bm1, ADDR0_COUNT + 7);
-  assert(! bm_equal(bm1, bm2));
-  assert(! bm_equal(bm2, bm1));
-  bm_delete(bm2);
-  bm_delete(bm1);
+  bm1 = DRD_(bm_new)();
+  bm2 = DRD_(bm_new)();
+  DRD_(bm_access_load_1)(bm1, 7);
+  DRD_(bm_access_load_1)(bm2, ADDR0_COUNT + 7);
+  assert(! DRD_(bm_equal)(bm1, bm2));
+  assert(! DRD_(bm_equal)(bm2, bm1));
+  DRD_(bm_access_load_1)(bm2, 7);
+  assert(! DRD_(bm_equal)(bm1, bm2));
+  assert(! DRD_(bm_equal)(bm2, bm1));
+  DRD_(bm_access_store_1)(bm1, ADDR0_COUNT + 7);
+  assert(! DRD_(bm_equal)(bm1, bm2));
+  assert(! DRD_(bm_equal)(bm2, bm1));
+  DRD_(bm_delete)(bm2);
+  DRD_(bm_delete)(bm1);
 }
 
 /** Torture test of the functions that set or clear a range of bits. */
@@ -148,90 +148,90 @@ void bm_test3(const int outer_loop_step, const int inner_loop_step)
   assert(outer_loop_step >= 1);
   assert(inner_loop_step >= 1);
 
-  bm1 = bm_new();
-  bm2 = bm_new();
+  bm1 = DRD_(bm_new)();
+  bm2 = DRD_(bm_new)();
   for (i = ADDR0_COUNT - 2 * BITS_PER_UWORD;
        i < ADDR0_COUNT + 2 * BITS_PER_UWORD;
        i += outer_loop_step)
   {
     for (j = i + 1; j < ADDR0_COUNT + 2 * BITS_PER_UWORD; j += inner_loop_step)
     {
-      bm_access_range_load(bm1, i, j);
-      bm_clear_load(bm1, i, j);
-      assert(bm_equal(bm1, bm2));
-      bm_access_load_1(bm1, i);
-      bm_clear_load(bm1, i, i+1);
-      assert(bm_equal(bm1, bm2));
-      bm_access_load_2(bm1, i);
-      bm_clear_load(bm1, i, i+2);
-      assert(bm_equal(bm1, bm2));
-      bm_access_load_4(bm1, i);
-      bm_clear_load(bm1, i, i+4);
-      assert(bm_equal(bm1, bm2));
-      bm_access_load_8(bm1, i);
-      bm_clear_load(bm1, i, i+8);
-      assert(bm_equal(bm1, bm2));
-      bm_access_range_store(bm1, i, j);
-      bm_clear_store(bm1, i, j);
-      assert(bm_equal(bm1, bm2));
-      bm_access_store_1(bm1, i);
-      bm_clear_store(bm1, i, i + 1);
-      assert(bm_equal(bm1, bm2));
-      bm_access_store_2(bm1, i);
-      bm_clear_store(bm1, i, i + 2);
-      assert(bm_equal(bm1, bm2));
-      bm_access_store_4(bm1, i);
-      bm_clear_store(bm1, i, i + 4);
-      assert(bm_equal(bm1, bm2));
-      bm_access_store_8(bm1, i);
-      bm_clear_store(bm1, i, i + 8);
-      assert(bm_equal(bm1, bm2));
+      DRD_(bm_access_range_load)(bm1, i, j);
+      DRD_(bm_clear_load)(bm1, i, j);
+      assert(DRD_(bm_equal)(bm1, bm2));
+      DRD_(bm_access_load_1)(bm1, i);
+      DRD_(bm_clear_load)(bm1, i, i+1);
+      assert(DRD_(bm_equal)(bm1, bm2));
+      DRD_(bm_access_load_2)(bm1, i);
+      DRD_(bm_clear_load)(bm1, i, i+2);
+      assert(DRD_(bm_equal)(bm1, bm2));
+      DRD_(bm_access_load_4)(bm1, i);
+      DRD_(bm_clear_load)(bm1, i, i+4);
+      assert(DRD_(bm_equal)(bm1, bm2));
+      DRD_(bm_access_load_8)(bm1, i);
+      DRD_(bm_clear_load)(bm1, i, i+8);
+      assert(DRD_(bm_equal)(bm1, bm2));
+      DRD_(bm_access_range_store)(bm1, i, j);
+      DRD_(bm_clear_store)(bm1, i, j);
+      assert(DRD_(bm_equal)(bm1, bm2));
+      DRD_(bm_access_store_1)(bm1, i);
+      DRD_(bm_clear_store)(bm1, i, i + 1);
+      assert(DRD_(bm_equal)(bm1, bm2));
+      DRD_(bm_access_store_2)(bm1, i);
+      DRD_(bm_clear_store)(bm1, i, i + 2);
+      assert(DRD_(bm_equal)(bm1, bm2));
+      DRD_(bm_access_store_4)(bm1, i);
+      DRD_(bm_clear_store)(bm1, i, i + 4);
+      assert(DRD_(bm_equal)(bm1, bm2));
+      DRD_(bm_access_store_8)(bm1, i);
+      DRD_(bm_clear_store)(bm1, i, i + 8);
+      assert(DRD_(bm_equal)(bm1, bm2));
     }
   }
-  bm_access_range_load(bm1, 0, 2 * ADDR0_COUNT + 2 * BITS_PER_UWORD);
-  bm_access_range_store(bm1, 0, 2 * ADDR0_COUNT + 2 * BITS_PER_UWORD);
-  bm_access_range_load(bm2, 0, 2 * ADDR0_COUNT + 2 * BITS_PER_UWORD);
-  bm_access_range_store(bm2, 0, 2 * ADDR0_COUNT + 2 * BITS_PER_UWORD);
+  DRD_(bm_access_range_load)(bm1, 0, 2 * ADDR0_COUNT + 2 * BITS_PER_UWORD);
+  DRD_(bm_access_range_store)(bm1, 0, 2 * ADDR0_COUNT + 2 * BITS_PER_UWORD);
+  DRD_(bm_access_range_load)(bm2, 0, 2 * ADDR0_COUNT + 2 * BITS_PER_UWORD);
+  DRD_(bm_access_range_store)(bm2, 0, 2 * ADDR0_COUNT + 2 * BITS_PER_UWORD);
   for (i = ADDR0_COUNT - 2 * BITS_PER_UWORD;
        i < ADDR0_COUNT + 2 * BITS_PER_UWORD;
        i += outer_loop_step)
   {
     for (j = i + 1; j < ADDR0_COUNT + 2 * BITS_PER_UWORD; j += inner_loop_step)
     {
-      bm_clear_load(bm1, i, j);
-      bm_access_range_load(bm1, i, j);
-      assert(bm_equal(bm1, bm2));
-      bm_clear_load(bm1, i, i+1);
-      bm_access_load_1(bm1, i);
-      assert(bm_equal(bm1, bm2));
-      bm_clear_load(bm1, i, i+2);
-      bm_access_load_2(bm1, i);
-      assert(bm_equal(bm1, bm2));
-      bm_clear_load(bm1, i, i+4);
-      bm_access_load_4(bm1, i);
-      assert(bm_equal(bm1, bm2));
-      bm_clear_load(bm1, i, i+8);
-      bm_access_load_8(bm1, i);
-      assert(bm_equal(bm1, bm2));
-      bm_clear_store(bm1, i, j);
-      bm_access_range_store(bm1, i, j);
-      assert(bm_equal(bm1, bm2));
-      bm_clear_store(bm1, i, i+1);
-      bm_access_store_1(bm1, i);
-      assert(bm_equal(bm1, bm2));
-      bm_clear_store(bm1, i, i+2);
-      bm_access_store_2(bm1, i);
-      assert(bm_equal(bm1, bm2));
-      bm_clear_store(bm1, i, i+4);
-      bm_access_store_4(bm1, i);
-      assert(bm_equal(bm1, bm2));
-      bm_clear_store(bm1, i, i+8);
-      bm_access_store_8(bm1, i);
-      assert(bm_equal(bm1, bm2));
+      DRD_(bm_clear_load)(bm1, i, j);
+      DRD_(bm_access_range_load)(bm1, i, j);
+      assert(DRD_(bm_equal)(bm1, bm2));
+      DRD_(bm_clear_load)(bm1, i, i+1);
+      DRD_(bm_access_load_1)(bm1, i);
+      assert(DRD_(bm_equal)(bm1, bm2));
+      DRD_(bm_clear_load)(bm1, i, i+2);
+      DRD_(bm_access_load_2)(bm1, i);
+      assert(DRD_(bm_equal)(bm1, bm2));
+      DRD_(bm_clear_load)(bm1, i, i+4);
+      DRD_(bm_access_load_4)(bm1, i);
+      assert(DRD_(bm_equal)(bm1, bm2));
+      DRD_(bm_clear_load)(bm1, i, i+8);
+      DRD_(bm_access_load_8)(bm1, i);
+      assert(DRD_(bm_equal)(bm1, bm2));
+      DRD_(bm_clear_store)(bm1, i, j);
+      DRD_(bm_access_range_store)(bm1, i, j);
+      assert(DRD_(bm_equal)(bm1, bm2));
+      DRD_(bm_clear_store)(bm1, i, i+1);
+      DRD_(bm_access_store_1)(bm1, i);
+      assert(DRD_(bm_equal)(bm1, bm2));
+      DRD_(bm_clear_store)(bm1, i, i+2);
+      DRD_(bm_access_store_2)(bm1, i);
+      assert(DRD_(bm_equal)(bm1, bm2));
+      DRD_(bm_clear_store)(bm1, i, i+4);
+      DRD_(bm_access_store_4)(bm1, i);
+      assert(DRD_(bm_equal)(bm1, bm2));
+      DRD_(bm_clear_store)(bm1, i, i+8);
+      DRD_(bm_access_store_8)(bm1, i);
+      assert(DRD_(bm_equal)(bm1, bm2));
     }
   }
-  bm_delete(bm2);
-  bm_delete(bm1);
+  DRD_(bm_delete)(bm2);
+  DRD_(bm_delete)(bm1);
 }
 
 int main(int argc, char** argv)