1/*	$NetBSD: mem1.c,v 1.14 2011/01/17 03:04:10 christos Exp $	*/
2
3/*
4 * Copyright (c) 1994, 1995 Jochen Pohl
5 * All Rights Reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 * 3. All advertising materials mentioning features or use of this software
16 *    must display the following acknowledgement:
17 *      This product includes software developed by Jochen Pohl for
18 *	The NetBSD Project.
19 * 4. The name of the author may not be used to endorse or promote products
20 *    derived from this software without specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
23 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
24 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
25 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
27 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
31 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 */
33
34#if HAVE_NBTOOL_CONFIG_H
35#include "nbtool_config.h"
36#endif
37
38#include <sys/cdefs.h>
39#if defined(__RCSID) && !defined(lint)
40__RCSID("$NetBSD: mem1.c,v 1.14 2011/01/17 03:04:10 christos Exp $");
41#endif
42
43#include <sys/types.h>
44#include <sys/param.h>
45#include <stdlib.h>
46#include <string.h>
47#include <unistd.h>
48
49#include "lint1.h"
50
51/*
52 * Filenames allocated by fnalloc() and fnnalloc() are shared.
53 */
54typedef struct fn {
55	char	*fn_name;
56	size_t	fn_len;
57	int	fn_id;
58	struct	fn *fn_nxt;
59} fn_t;
60
61static	fn_t	*fnames;
62
63static	fn_t	*srchfn(const char *, size_t);
64
65/*
66 * Look for a Filename of length l.
67 */
68static fn_t *
69srchfn(const char *s, size_t len)
70{
71	fn_t	*fn;
72
73	for (fn = fnames; fn != NULL; fn = fn->fn_nxt) {
74		if (fn->fn_len == len && memcmp(fn->fn_name, s, len) == 0)
75			break;
76	}
77	return (fn);
78}
79
80/*
81 * Return a shared string for filename s.
82 */
83const char *
84fnalloc(const char *s)
85{
86
87	return (s != NULL ? fnnalloc(s, strlen(s)) : NULL);
88}
89
90const char *
91fnnalloc(const char *s, size_t len)
92{
93	fn_t	*fn;
94
95	static	int	nxt_id = 0;
96
97	if (s == NULL)
98		return (NULL);
99
100	if ((fn = srchfn(s, len)) == NULL) {
101		fn = xmalloc(sizeof (fn_t));
102		/* Do not used strdup() because string is not NUL-terminated.*/
103		fn->fn_name = xmalloc(len + 1);
104		(void)memcpy(fn->fn_name, s, len);
105		fn->fn_name[len] = '\0';
106		fn->fn_len = len;
107		fn->fn_id = nxt_id++;
108		fn->fn_nxt = fnames;
109		fnames = fn;
110		/* Write id of this filename to the output file. */
111		outclr();
112		outint(fn->fn_id);
113		outchar('s');
114		outstrg(fn->fn_name);
115	}
116	return (fn->fn_name);
117}
118
119/*
120 * Get id of a filename.
121 */
122int
123getfnid(const char *s)
124{
125	fn_t	*fn;
126
127	if (s == NULL || (fn = srchfn(s, strlen(s))) == NULL)
128		return (-1);
129	return (fn->fn_id);
130}
131
132/*
133 * Memory for declarations and other things which must be available
134 * until the end of a block (or the end of the translation unit)
135 * are associated with the level (mblklev) of the block (or with 0).
136 * Because this memory is allocated in large blocks associated with
137 * a given level it can be freed easily at the end of a block.
138 */
139#define	ML_INC	((size_t)32)		/* Increment for length of *mblks */
140
141typedef struct mbl {
142	void	*blk;			/* beginning of memory block */
143	void	*ffree;			/* first free byte */
144	size_t	nfree;			/* # of free bytes */
145	size_t	size;			/* total size of memory block */
146	struct	mbl *nxt;		/* next block */
147} mbl_t;
148
149/*
150 * Array of pointers to lists of memory blocks. mblklev is used as
151 * index into this array.
152 */
153static	mbl_t	**mblks;
154
155/* number of elements in *mblks */
156static	size_t	nmblks;
157
158/* free list for memory blocks */
159static	mbl_t	*frmblks;
160
161/* length of new allocated memory blocks */
162static	size_t	mblklen;
163
164static	void	*xgetblk(mbl_t **, size_t);
165static	void	xfreeblk(mbl_t **);
166static	mbl_t	*xnewblk(void);
167
168static mbl_t *
169xnewblk(void)
170{
171	mbl_t	*mb = xmalloc(sizeof (mbl_t));
172
173	/* use mmap instead of malloc to avoid malloc's size overhead */
174	mb->blk = xmapalloc(mblklen);
175	mb->size = mblklen;
176
177	return (mb);
178}
179
180/*
181 * Allocate new memory. If the first block of the list has not enough
182 * free space, or there is no first block, get a new block. The new
183 * block is taken from the free list or, if there is no block on the
184 * free list, is allocated using xnewblk(). If a new block is allocated
185 * it is initialized with zero. Blocks taken from the free list are
186 * zero'd in xfreeblk().
187 */
188static void *
189xgetblk(mbl_t **mbp, size_t s)
190{
191	mbl_t	*mb;
192	void	*p;
193	size_t	t = 0;
194
195	s = WORST_ALIGN(s);
196	if ((mb = *mbp) == NULL || mb->nfree < s) {
197		if ((mb = frmblks) == NULL || mb->size < s) {
198			if (s > mblklen) {
199				t = mblklen;
200				mblklen = s;
201			}
202			mb = xnewblk();
203			if (t)
204				mblklen = t;
205			(void)memset(mb->blk, 0, mb->size);
206		} else {
207			frmblks = mb->nxt;
208		}
209		mb->ffree = mb->blk;
210		mb->nfree = mb->size;
211		mb->nxt = *mbp;
212		*mbp = mb;
213	}
214	p = mb->ffree;
215	mb->ffree = (char *)mb->ffree + s;
216	mb->nfree -= s;
217	return (p);
218}
219
220/*
221 * Move all blocks from list *fmbp to free list. For each block, set all
222 * used memory to zero.
223 */
224static void
225xfreeblk(mbl_t **fmbp)
226{
227	mbl_t	*mb;
228
229	while ((mb = *fmbp) != NULL) {
230		*fmbp = mb->nxt;
231		mb->nxt = frmblks;
232		frmblks = mb;
233		(void)memset(mb->blk, 0, mb->size - mb->nfree);
234	}
235}
236
237void
238initmem(void)
239{
240	int	pgsz;
241
242	pgsz = getpagesize();
243	mblklen = ((MBLKSIZ + pgsz - 1) / pgsz) * pgsz;
244
245	mblks = xcalloc(nmblks = ML_INC, sizeof (mbl_t *));
246}
247
248
249/*
250 * Allocate memory associated with level l.
251 */
252void *
253getlblk(size_t l, size_t s)
254{
255
256	while (l >= nmblks) {
257		mblks = xrealloc(mblks, (nmblks + ML_INC) * sizeof (mbl_t *));
258		(void)memset(&mblks[nmblks], 0, ML_INC * sizeof (mbl_t *));
259		nmblks += ML_INC;
260	}
261	return (xgetblk(&mblks[l], s));
262}
263
264void *
265getblk(size_t s)
266{
267
268	return (getlblk(mblklev, s));
269}
270
271/*
272 * Free all memory associated with level l.
273 */
274void
275freelblk(int l)
276{
277
278	xfreeblk(&mblks[l]);
279}
280
281void
282freeblk(void)
283{
284
285	freelblk(mblklev);
286}
287
288/*
289 * tgetblk() returns memory which is associated with the current
290 * expression.
291 */
292static	mbl_t	*tmblk;
293
294void *
295tgetblk(size_t s)
296{
297
298	return (xgetblk(&tmblk, s));
299}
300
301/*
302 * Get memory for a new tree node.
303 */
304tnode_t *
305getnode(void)
306{
307
308	return (tgetblk(sizeof (tnode_t)));
309}
310
311/*
312 * Free all memory which is allocated by the current expression.
313 */
314void
315tfreeblk(void)
316{
317
318	xfreeblk(&tmblk);
319}
320
321/*
322 * Save the memory which is used by the current expression. This memory
323 * is not freed by the next tfreeblk() call. The pointer returned can be
324 * used to restore the memory.
325 */
326mbl_t *
327tsave(void)
328{
329	mbl_t	*tmem;
330
331	tmem = tmblk;
332	tmblk = NULL;
333	return (tmem);
334}
335
336/*
337 * Free all memory used for the current expression and the memory used
338 * be a previous expression and saved by tsave(). The next call to
339 * tfreeblk() frees the restored memory.
340 */
341void
342trestor(mbl_t *tmem)
343{
344
345	tfreeblk();
346	if (tmblk != NULL) {
347		free(tmblk->blk);
348		free(tmblk);
349	}
350	tmblk = tmem;
351}
352