1: /* Safe automatic memory allocation.
2: Copyright (C) 2003, 2006-2007, 2009-2011 Free Software Foundation, Inc.
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:
19: #define _GL_USE_STDLIB_ALLOC 1
20: #include <config.h>
21:
22: /* Specification. */
23: #include "malloca.h"
24:
25: #include "verify.h"
26:
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]; };
56: verify (HEADER_SIZE == sizeof (struct header));
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)
79: {
80: size_t slot;
81:
82: p += HEADER_SIZE;
83:
84: /* Put a magic number into the indicator word. */
85: ((int *) p)[-1] = MAGIC_NUMBER;
86:
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;
91:
92: return p;
93: }
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
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. */
117: if (((int *) p)[-1] == MAGIC_NUMBER)
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: }
136: /* At this point, we know it was not a mmalloca() result. */
137: }
138: }
139: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>