Return to memory.c CVS log

Up to [local] / OpenXM_contrib / gmp

Annotation of OpenXM_contrib/gmp/memory.c, Revision 1.1.1.3

1.1       maekawa     1: /* Memory allocation routines.
                      2:
1.1.1.3 ! ohara       3: Copyright 1991, 1993, 1994, 2000, 2001, 2002 Free Software Foundation, Inc.
1.1       maekawa     4:
                      5: This file is part of the GNU MP Library.
                      6:
                      7: The GNU MP Library is free software; you can redistribute it and/or modify
1.1.1.2   maekawa     8: it under the terms of the GNU Lesser General Public License as published by
                      9: the Free Software Foundation; either version 2.1 of the License, or (at your
1.1       maekawa    10: option) any later version.
                     11:
                     12: The GNU MP Library is distributed in the hope that it will be useful, but
                     13: WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
1.1.1.2   maekawa    14: or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
1.1       maekawa    15: License for more details.
                     16:
1.1.1.2   maekawa    17: You should have received a copy of the GNU Lesser General Public License
1.1       maekawa    18: along with the GNU MP Library; see the file COPYING.LIB.  If not, write to
                     19: the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
                     20: MA 02111-1307, USA. */
                     21:
                     22: #include <stdio.h>
1.1.1.2   maekawa    23: #include <stdlib.h> /* for malloc, realloc, free */
1.1       maekawa    24:
                     25: #include "gmp.h"
                     26: #include "gmp-impl.h"
                     27:
1.1.1.2   maekawa    28:
1.1.1.3 ! ohara      29: void * (*__gmp_allocate_func) _PROTO ((size_t)) = __gmp_default_allocate;
        !            30: void * (*__gmp_reallocate_func) _PROTO ((void *, size_t, size_t))
        !            31:      = __gmp_default_reallocate;
        !            32: void   (*__gmp_free_func) _PROTO ((void *, size_t)) = __gmp_default_free;
1.1.1.2   maekawa    33:
1.1       maekawa    34:
                     35: /* Default allocation functions.  In case of failure to allocate/reallocate
                     36:    an error message is written to stderr and the program aborts.  */
                     37:
                     38: void *
1.1.1.3 ! ohara      39: __gmp_default_allocate (size_t size)
1.1       maekawa    40: {
                     41:   void *ret;
1.1.1.2   maekawa    42: #ifdef DEBUG
                     43:   size_t req_size = size;
                     44:   size += 2 * BYTES_PER_MP_LIMB;
                     45: #endif
1.1       maekawa    46:   ret = malloc (size);
                     47:   if (ret == 0)
                     48:     {
1.1.1.3 ! ohara      49:       fprintf (stderr, "GNU MP: Cannot allocate memory (size=%u)\n", size);
1.1       maekawa    50:       abort ();
                     51:     }
1.1.1.2   maekawa    52:
                     53: #ifdef DEBUG
                     54:   {
                     55:     mp_ptr p = ret;
                     56:     p++;
                     57:     p[-1] = (0xdeadbeef << 31) + 0xdeafdeed;
                     58:     if (req_size % BYTES_PER_MP_LIMB == 0)
                     59:       p[req_size / BYTES_PER_MP_LIMB] = ~((0xdeadbeef << 31) + 0xdeafdeed);
                     60:     ret = p;
                     61:   }
                     62: #endif
1.1       maekawa    63:   return ret;
                     64: }
                     65:
                     66: void *
1.1.1.3 ! ohara      67: __gmp_default_reallocate (void *oldptr, size_t old_size, size_t new_size)
1.1       maekawa    68: {
                     69:   void *ret;
                     70:
1.1.1.2   maekawa    71: #ifdef DEBUG
                     72:   size_t req_size = new_size;
                     73:
                     74:   if (old_size != 0)
                     75:     {
                     76:       mp_ptr p = oldptr;
                     77:       if (p[-1] != (0xdeadbeef << 31) + 0xdeafdeed)
                     78:        {
                     79:          fprintf (stderr, "gmp: (realloc) data clobbered before allocation block\n");
                     80:          abort ();
                     81:        }
                     82:       if (old_size % BYTES_PER_MP_LIMB == 0)
                     83:        if (p[old_size / BYTES_PER_MP_LIMB] != ~((0xdeadbeef << 31) + 0xdeafdeed))
                     84:          {
                     85:            fprintf (stderr, "gmp: (realloc) data clobbered after allocation block\n");
                     86:            abort ();
                     87:          }
                     88:       oldptr = p - 1;
                     89:     }
                     90:
                     91:   new_size += 2 * BYTES_PER_MP_LIMB;
                     92: #endif
                     93:
1.1       maekawa    94:   ret = realloc (oldptr, new_size);
                     95:   if (ret == 0)
                     96:     {
1.1.1.3 ! ohara      97:       fprintf (stderr, "GNU MP: Cannot reallocate memory (old_size=%u new_size=%u)\n", old_size, new_size);
1.1       maekawa    98:       abort ();
                     99:     }
                    100:
1.1.1.2   maekawa   101: #ifdef DEBUG
                    102:   {
                    103:     mp_ptr p = ret;
                    104:     p++;
                    105:     p[-1] = (0xdeadbeef << 31) + 0xdeafdeed;
                    106:     if (req_size % BYTES_PER_MP_LIMB == 0)
                    107:       p[req_size / BYTES_PER_MP_LIMB] = ~((0xdeadbeef << 31) + 0xdeafdeed);
                    108:     ret = p;
                    109:   }
                    110: #endif
1.1       maekawa   111:   return ret;
                    112: }
                    113:
                    114: void
1.1.1.3 ! ohara     115: __gmp_default_free (void *blk_ptr, size_t blk_size)
1.1       maekawa   116: {
1.1.1.2   maekawa   117: #ifdef DEBUG
                    118:   {
                    119:     mp_ptr p = blk_ptr;
                    120:     if (blk_size != 0)
                    121:       {
                    122:        if (p[-1] != (0xdeadbeef << 31) + 0xdeafdeed)
                    123:          {
                    124:            fprintf (stderr, "gmp: (free) data clobbered before allocation block\n");
                    125:            abort ();
                    126:          }
                    127:        if (blk_size % BYTES_PER_MP_LIMB == 0)
                    128:          if (p[blk_size / BYTES_PER_MP_LIMB] != ~((0xdeadbeef << 31) + 0xdeafdeed))
                    129:            {
                    130:              fprintf (stderr, "gmp: (free) data clobbered after allocation block\n");
                    131:              abort ();
                    132:            }
                    133:       }
                    134:     blk_ptr = p - 1;
                    135:   }
                    136: #endif
1.1       maekawa   137:   free (blk_ptr);
                    138: }