Annotation of embedaddon/libiconv/srclib/malloca.c, revision 1.1.1.2
1.1 misho 1: /* Safe automatic memory allocation.
1.1.1.2 ! misho 2: Copyright (C) 2003, 2006-2007, 2009-2011 Free Software Foundation, Inc.
1.1 misho 3: Written by Bruno Haible <bruno@clisp.org>, 2003.
4:
5: This program is free software; you can redistribute it and/or modify
6: it under the terms of the GNU General Public License as published by
7: the Free Software Foundation; either version 3, or (at your option)
8: any later version.
9:
10: This program is distributed in the hope that it will be useful,
11: but WITHOUT ANY WARRANTY; without even the implied warranty of
12: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13: GNU General Public License for more details.
14:
15: You should have received a copy of the GNU General Public License
16: along with this program; if not, write to the Free Software Foundation,
17: Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
18:
1.1.1.2 ! misho 19: #define _GL_USE_STDLIB_ALLOC 1
1.1 misho 20: #include <config.h>
21:
22: /* Specification. */
23: #include "malloca.h"
24:
1.1.1.2 ! misho 25: #include "verify.h"
! 26:
1.1 misho 27: /* The speed critical point in this file is freea() applied to an alloca()
28: result: it must be fast, to match the speed of alloca(). The speed of
29: mmalloca() and freea() in the other case are not critical, because they
30: are only invoked for big memory sizes. */
31:
32: #if HAVE_ALLOCA
33:
34: /* Store the mmalloca() results in a hash table. This is needed to reliably
35: distinguish a mmalloca() result and an alloca() result.
36:
37: Although it is possible that the same pointer is returned by alloca() and
38: by mmalloca() at different times in the same application, it does not lead
39: to a bug in freea(), because:
40: - Before a pointer returned by alloca() can point into malloc()ed memory,
41: the function must return, and once this has happened the programmer must
42: not call freea() on it anyway.
43: - Before a pointer returned by mmalloca() can point into the stack, it
44: must be freed. The only function that can free it is freea(), and
45: when freea() frees it, it also removes it from the hash table. */
46:
47: #define MAGIC_NUMBER 0x1415fb4a
48: #define MAGIC_SIZE sizeof (int)
49: /* This is how the header info would look like without any alignment
50: considerations. */
51: struct preliminary_header { void *next; char room[MAGIC_SIZE]; };
52: /* But the header's size must be a multiple of sa_alignment_max. */
53: #define HEADER_SIZE \
54: (((sizeof (struct preliminary_header) + sa_alignment_max - 1) / sa_alignment_max) * sa_alignment_max)
55: struct header { void *next; char room[HEADER_SIZE - sizeof (struct preliminary_header) + MAGIC_SIZE]; };
1.1.1.2 ! misho 56: verify (HEADER_SIZE == sizeof (struct header));
1.1 misho 57: /* We make the hash table quite big, so that during lookups the probability
58: of empty hash buckets is quite high. There is no need to make the hash
59: table resizable, because when the hash table gets filled so much that the
60: lookup becomes slow, it means that the application has memory leaks. */
61: #define HASH_TABLE_SIZE 257
62: static void * mmalloca_results[HASH_TABLE_SIZE];
63:
64: #endif
65:
66: void *
67: mmalloca (size_t n)
68: {
69: #if HAVE_ALLOCA
70: /* Allocate one more word, that serves as an indicator for malloc()ed
71: memory, so that freea() of an alloca() result is fast. */
72: size_t nplus = n + HEADER_SIZE;
73:
74: if (nplus >= n)
75: {
76: char *p = (char *) malloc (nplus);
77:
78: if (p != NULL)
1.1.1.2 ! misho 79: {
! 80: size_t slot;
1.1 misho 81:
1.1.1.2 ! misho 82: p += HEADER_SIZE;
1.1 misho 83:
1.1.1.2 ! misho 84: /* Put a magic number into the indicator word. */
! 85: ((int *) p)[-1] = MAGIC_NUMBER;
1.1 misho 86:
1.1.1.2 ! misho 87: /* Enter p into the hash table. */
! 88: slot = (unsigned long) p % HASH_TABLE_SIZE;
! 89: ((struct header *) (p - HEADER_SIZE))->next = mmalloca_results[slot];
! 90: mmalloca_results[slot] = p;
1.1 misho 91:
1.1.1.2 ! misho 92: return p;
! 93: }
1.1 misho 94: }
95: /* Out of memory. */
96: return NULL;
97: #else
98: # if !MALLOC_0_IS_NONNULL
99: if (n == 0)
100: n = 1;
101: # endif
102: return malloc (n);
103: #endif
104: }
105:
106: #if HAVE_ALLOCA
107: void
108: freea (void *p)
109: {
110: /* mmalloca() may have returned NULL. */
111: if (p != NULL)
112: {
113: /* Attempt to quickly distinguish the mmalloca() result - which has
1.1.1.2 ! misho 114: a magic indicator word - and the alloca() result - which has an
! 115: uninitialized indicator word. It is for this test that sa_increment
! 116: additional bytes are allocated in the alloca() case. */
1.1 misho 117: if (((int *) p)[-1] == MAGIC_NUMBER)
1.1.1.2 ! misho 118: {
! 119: /* Looks like a mmalloca() result. To see whether it really is one,
! 120: perform a lookup in the hash table. */
! 121: size_t slot = (unsigned long) p % HASH_TABLE_SIZE;
! 122: void **chain = &mmalloca_results[slot];
! 123: for (; *chain != NULL;)
! 124: {
! 125: if (*chain == p)
! 126: {
! 127: /* Found it. Remove it from the hash table and free it. */
! 128: char *p_begin = (char *) p - HEADER_SIZE;
! 129: *chain = ((struct header *) p_begin)->next;
! 130: free (p_begin);
! 131: return;
! 132: }
! 133: chain = &((struct header *) ((char *) *chain - HEADER_SIZE))->next;
! 134: }
! 135: }
1.1 misho 136: /* At this point, we know it was not a mmalloca() result. */
137: }
138: }
139: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to malloca.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libiconv / srclib