applied_patches/0211-valgrind-alloc.diff

   1 Index: sal/rtl/source/alloc.c
   2 ===================================================================
   3 RCS file: /cvs/porting/sal/rtl/source/alloc.c,v
   4 retrieving revision 1.14
   5 diff -u -3 -p -r1.14 alloc.c
   6 --- sal/rtl/source/alloc.c      17 Dec 2003 17:10:01 -0000      1.14
   7 +++ sal/rtl/source/alloc.c      29 Feb 2004 17:50:41 -0000
   8 @@ -227,6 +227,39 @@ static sal_uInt32 __rtl_memory_vmpagesiz
   9
  10  /*===========================================================================
  11   *
  12 + * Determine allocation mode (debug/release) by examining environment
  13 + * variable "OOO_FORCE_SYSALLOC".
  14 + *
  15 + *=========================================================================*/
  16 +
  17 +#include <stdlib.h>   /* getenv */
  18 +#include <stdio.h>    /* stderr */
  19 +
  20 +typedef
  21 +   enum { AMode_CUSTOM, AMode_SYSTEM, AMode_UNSET }
  22 +   AllocMode;
  23 +
  24 +static AllocMode alloc_mode = AMode_UNSET;
  25 +
  26 +static void determine_alloc_mode ( void )
  27 +{
  28 +   /* This shouldn't happen, but still ... */
  29 +   if (alloc_mode != AMode_UNSET)
  30 +      return;
  31 +
  32 +   if (getenv("OOO_FORCE_SYSALLOC") != NULL) {
  33 +      alloc_mode = AMode_SYSTEM;
  34 +      fprintf(stderr, "OOo: Using system memory allocator.\n");
  35 +      fprintf(stderr, "OOo: This is for debugging only.  To disable,\n");
  36 +      fprintf(stderr, "OOo: unset the environment variable"
  37 +                      " OOO_FORCE_SYSALLOC.\n");
  38 +   } else {
  39 +      alloc_mode = AMode_CUSTOM;
  40 +   }
  41 +}
  42 +
  43 +/*===========================================================================
  44 + *
  45   * rtl_memory (global) internals.
  46   *
  47   *=========================================================================*/
  48 @@ -1165,8 +1165,8 @@ static void __rtl_memory_enqueue (memory
  49  /*
  50   * rtl_reallocateMemory.
  51   */
  52 -#ifndef FORCE_SYSALLOC
  53 -void* SAL_CALL rtl_reallocateMemory (void * p, sal_Size n) SAL_THROW_EXTERN_C()
  54 +static
  55 +void* SAL_CALL rtl_reallocateMemory_CUSTOM (void * p, sal_Size n) SAL_THROW_EXTERN_C()
  56  {
  57         memory_type * memory;
  58         if (!(!p || !n))
  59 @@ -1322,18 +1322,33 @@ void* SAL_CALL rtl_reallocateMemory (voi
  60         }
  61         return (p);
  62  }
  63 -#else  /* FORCE_SYSALLOC */
  64 -void* SAL_CALL rtl_reallocateMemory (void * p, sal_Size n) SAL_THROW_EXTERN_C()
  65 +
  66 +static
  67 +void* SAL_CALL rtl_reallocateMemory_SYSTEM (void * p, sal_Size n) SAL_THROW_EXTERN_C()
  68  {
  69         return realloc(p, (sal_Size)(n));
  70  }
  71 -#endif /* FORCE_SYSALLOC */
  72 +
  73 +void* SAL_CALL rtl_reallocateMemory (void * p, sal_Size n) SAL_THROW_EXTERN_C()
  74 +{
  75 +   while (1) {
  76 +      if (alloc_mode == AMode_CUSTOM) {
  77 +         return rtl_reallocateMemory_CUSTOM(p,n);
  78 +      }
  79 +      if (alloc_mode == AMode_SYSTEM) {
  80 +         return rtl_reallocateMemory_SYSTEM(p,n);
  81 +      }
  82 +      determine_alloc_mode();
  83 +   }
  84 +}
  85 +
  86 +
  87
  88  /*
  89   * rtl_allocateMemory.
  90   */
  91 -#ifndef FORCE_SYSALLOC
  92 -void* SAL_CALL rtl_allocateMemory (sal_Size n) SAL_THROW_EXTERN_C()
  93 +static
  94 +void* SAL_CALL rtl_allocateMemory_CUSTOM (sal_Size n) SAL_THROW_EXTERN_C()
  95  {
  96         void * p = 0;
  97         if (n > 0)
  98 @@ -1355,18 +1355,33 @@ void* SAL_CALL rtl_allocateMemory (sal_u
  99         }
 100         return (p);
 101  }
 102 -#else  /* FORCE_SYSALLOC */
 103 -void* SAL_CALL rtl_allocateMemory (sal_Size n) SAL_THROW_EXTERN_C()
 104 +
 105 +static
 106 +void* SAL_CALL rtl_allocateMemory_SYSTEM (sal_Size n) SAL_THROW_EXTERN_C()
 107  {
 108         return malloc((sal_Size)(n));
 109  }
 110 -#endif /* FORCE_SYSALLOC */
 111 +
 112 +void* SAL_CALL rtl_allocateMemory (sal_Size n) SAL_THROW_EXTERN_C()
 113 +{
 114 +   while (1) {
 115 +      if (alloc_mode == AMode_CUSTOM) {
 116 +         return rtl_allocateMemory_CUSTOM(n);
 117 +      }
 118 +      if (alloc_mode == AMode_SYSTEM) {
 119 +         return rtl_allocateMemory_SYSTEM(n);
 120 +      }
 121 +      determine_alloc_mode();
 122 +   }
 123 +}
 124 +
 125 +
 126
 127  /*
 128   * rtl_freeMemory.
 129   */
 130 -#ifndef FORCE_SYSALLOC
 131 -void SAL_CALL rtl_freeMemory (void * p) SAL_THROW_EXTERN_C()
 132 +static
 133 +void SAL_CALL rtl_freeMemory_CUSTOM (void * p) SAL_THROW_EXTERN_C()
 134  {
 135         if (p)
 136         {
 137 @@ -1387,18 +1387,34 @@ void SAL_CALL rtl_freeMemory (void * p)
 138                 RTL_MEMORY_LEAVE();
 139         }
 140  }
 141 -#else  /* FORCE_SYSALLOC */
 142 -void SAL_CALL rtl_freeMemory (void * p) SAL_THROW_EXTERN_C()
 143 +
 144 +static
 145 +void SAL_CALL rtl_freeMemory_SYSTEM (void * p) SAL_THROW_EXTERN_C()
 146  {
 147         free(p);
 148  }
 149 -#endif /* FORCE_SYSALLOC */
 150 +
 151 +void SAL_CALL rtl_freeMemory (void * p) SAL_THROW_EXTERN_C()
 152 +{
 153 +   while (1) {
 154 +      if (alloc_mode == AMode_CUSTOM) {
 155 +         rtl_freeMemory_CUSTOM(p);
 156 +        return;
 157 +      }
 158 +      if (alloc_mode == AMode_SYSTEM) {
 159 +         rtl_freeMemory_SYSTEM(p);
 160 +        return;
 161 +      }
 162 +      determine_alloc_mode();
 163 +   }
 164 +}
 165 +
 166
 167  /*
 168   * rtl_allocateZeroMemory.
 169   */
 170 -#ifndef FORCE_SYSALLOC
 171 -void* SAL_CALL rtl_allocateZeroMemory (sal_Size n) SAL_THROW_EXTERN_C()
 172 +static
 173 +void* SAL_CALL rtl_allocateZeroMemory_CUSTOM (sal_Size n) SAL_THROW_EXTERN_C()
 174  {
 175         void * p = 0;
 176         if (n > 0)
 177 @@ -1421,18 +1421,32 @@ void* SAL_CALL rtl_allocateZeroMemory (s
 178         }
 179         return (p);
 180  }
 181 -#else  /* FORCE_SYSALLOC */
 182 -void* SAL_CALL rtl_allocateZeroMemory (sal_Size n) SAL_THROW_EXTERN_C()
 183 +
 184 +static
 185 +void* SAL_CALL rtl_allocateZeroMemory_SYSTEM (sal_Size n) SAL_THROW_EXTERN_C()
 186  {
 187         return calloc((sal_Size)(n), 1);
 188  }
 189 -#endif /* FORCE_SYSALLOC */
 190 +
 191 +void* SAL_CALL rtl_allocateZeroMemory (sal_Size n) SAL_THROW_EXTERN_C()
 192 +{
 193 +   while (1) {
 194 +      if (alloc_mode == AMode_CUSTOM) {
 195 +         return rtl_allocateZeroMemory_CUSTOM(n);
 196 +      }
 197 +      if (alloc_mode == AMode_SYSTEM) {
 198 +         return rtl_allocateZeroMemory_SYSTEM(n);
 199 +      }
 200 +      determine_alloc_mode();
 201 +   }
 202 +}
 203 +
 204
 205  /*
 206   * rtl_freeZeroMemory.
 207   */
 208 -#ifndef FORCE_SYSALLOC
 209 -void SAL_CALL rtl_freeZeroMemory (void * p, sal_Size n) SAL_THROW_EXTERN_C()
 210 +static
 211 +void SAL_CALL rtl_freeZeroMemory_CUSTOM (void * p, sal_Size n) SAL_THROW_EXTERN_C()
 212  {
 213      (void) n; /* unused */
 214         if (p)
 215 @@ -1454,8 +1454,9 @@ void SAL_CALL rtl_freeZeroMemory (void *
 216                 RTL_MEMORY_LEAVE();
 217         }
 218  }
 219 -#else  /* FORCE_SYSALLOC */
 220 -void SAL_CALL rtl_freeZeroMemory (void * p, sal_Size n) SAL_THROW_EXTERN_C()
 221 +
 222 +static
 223 +void SAL_CALL rtl_freeZeroMemory_SYSTEM (void * p, sal_Size n) SAL_THROW_EXTERN_C()
 224  {
 225         if (p)
 226         {
 227 @@ -1463,7 +1463,21 @@ void SAL_CALL rtl_freeZeroMemory (void *
 228                 free(p);
 229         }
 230  }
 231 -#endif /* FORCE_SYSALLOC */
 232 +
 233 +void SAL_CALL rtl_freeZeroMemory (void * p, sal_Size n) SAL_THROW_EXTERN_C()
 234 +{
 235 +   while (1) {
 236 +      if (alloc_mode == AMode_CUSTOM) {
 237 +         rtl_freeZeroMemory_CUSTOM(p,n);
 238 +        return;
 239 +      }
 240 +      if (alloc_mode == AMode_SYSTEM) {
 241 +         rtl_freeZeroMemory_SYSTEM(p,n);
 242 +        return;
 243 +      }
 244 +      determine_alloc_mode();
 245 +   }
 246 +}
 247
 248  /*===========================================================================
 249   *
 250