xref: /netbsd-src/usr.bin/xlint/lint1/mem1.c (revision b7b7574d3bf8eeb51a1fa3977b59142ec6434a55)
1 /*	$NetBSD: mem1.c,v 1.17 2014/04/18 00:21:14 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.17 2014/04/18 00:21:14 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  */
54 typedef struct fn {
55 	char	*fn_name;
56 	size_t	fn_len;
57 	int	fn_id;
58 	struct	fn *fn_nxt;
59 } fn_t;
60 
61 static	fn_t	*fnames;
62 
63 static	fn_t	*srchfn(const char *, size_t);
64 
65 /*
66  * Look for a Filename of length l.
67  */
68 static fn_t *
69 srchfn(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  */
83 const char *
84 fnalloc(const char *s)
85 {
86 
87 	return (s != NULL ? fnnalloc(s, strlen(s)) : NULL);
88 }
89 
90 const char *
91 fnnalloc(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  */
122 int
123 getfnid(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 
141 typedef 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  */
153 static	mbl_t	**mblks;
154 
155 /* number of elements in *mblks */
156 static	size_t	nmblks;
157 
158 /* free list for memory blocks */
159 static	mbl_t	*frmblks;
160 
161 /* length of new allocated memory blocks */
162 static	size_t	mblklen;
163 
164 static	void	*xgetblk(mbl_t **, size_t);
165 static	void	xfreeblk(mbl_t **);
166 static	mbl_t	*xnewblk(void);
167 
168 static mbl_t *
169 xnewblk(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  */
188 static void *
189 xgetblk(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 #ifndef BLKDEBUG
204 			(void)memset(mb->blk, 0, mb->size);
205 #endif
206 			if (t)
207 				mblklen = t;
208 		} else {
209 			frmblks = mb->nxt;
210 		}
211 		mb->ffree = mb->blk;
212 		mb->nfree = mb->size;
213 		mb->nxt = *mbp;
214 		*mbp = mb;
215 	}
216 	p = mb->ffree;
217 	mb->ffree = (char *)mb->ffree + s;
218 	mb->nfree -= s;
219 #ifdef BLKDEBUG
220 	(void)memset(p, 0, s);
221 #endif
222 	return (p);
223 }
224 
225 /*
226  * Move all blocks from list *fmbp to free list. For each block, set all
227  * used memory to zero.
228  */
229 static void
230 xfreeblk(mbl_t **fmbp)
231 {
232 	mbl_t	*mb;
233 
234 	while ((mb = *fmbp) != NULL) {
235 		*fmbp = mb->nxt;
236 		mb->nxt = frmblks;
237 		frmblks = mb;
238 		(void)memset(mb->blk, ZERO, mb->size - mb->nfree);
239 	}
240 }
241 
242 void
243 initmem(void)
244 {
245 	int	pgsz;
246 
247 	pgsz = getpagesize();
248 	mblklen = ((MBLKSIZ + pgsz - 1) / pgsz) * pgsz;
249 
250 	mblks = xcalloc(nmblks = ML_INC, sizeof (mbl_t *));
251 }
252 
253 
254 /*
255  * Allocate memory associated with level l.
256  */
257 void *
258 getlblk(size_t l, size_t s)
259 {
260 
261 	while (l >= nmblks) {
262 		mblks = xrealloc(mblks, (nmblks + ML_INC) * sizeof (mbl_t *));
263 		(void)memset(&mblks[nmblks], 0, ML_INC * sizeof (mbl_t *));
264 		nmblks += ML_INC;
265 	}
266 	return (xgetblk(&mblks[l], s));
267 }
268 
269 void *
270 getblk(size_t s)
271 {
272 
273 	return (getlblk(mblklev, s));
274 }
275 
276 /*
277  * Free all memory associated with level l.
278  */
279 void
280 freelblk(int l)
281 {
282 
283 	xfreeblk(&mblks[l]);
284 }
285 
286 void
287 freeblk(void)
288 {
289 
290 	freelblk(mblklev);
291 }
292 
293 /*
294  * tgetblk() returns memory which is associated with the current
295  * expression.
296  */
297 static	mbl_t	*tmblk;
298 
299 void *
300 tgetblk(size_t s)
301 {
302 
303 	return (xgetblk(&tmblk, s));
304 }
305 
306 /*
307  * Get memory for a new tree node.
308  */
309 tnode_t *
310 getnode(void)
311 {
312 
313 	return (tgetblk(sizeof (tnode_t)));
314 }
315 
316 /*
317  * Free all memory which is allocated by the current expression.
318  */
319 void
320 tfreeblk(void)
321 {
322 
323 	xfreeblk(&tmblk);
324 }
325 
326 /*
327  * Save the memory which is used by the current expression. This memory
328  * is not freed by the next tfreeblk() call. The pointer returned can be
329  * used to restore the memory.
330  */
331 mbl_t *
332 tsave(void)
333 {
334 	mbl_t	*tmem;
335 
336 	tmem = tmblk;
337 	tmblk = NULL;
338 	return (tmem);
339 }
340 
341 /*
342  * Free all memory used for the current expression and the memory used
343  * be a previous expression and saved by tsave(). The next call to
344  * tfreeblk() frees the restored memory.
345  */
346 void
347 trestor(mbl_t *tmem)
348 {
349 
350 	tfreeblk();
351 	if (tmblk != NULL) {
352 		free(tmblk->blk);
353 		free(tmblk);
354 	}
355 	tmblk = tmem;
356 }
357