usr.bin/xlint/lint1/mem1.c

   1 /*      $NetBSD: mem1.c,v 1.2 1995/07/03 21:24:25 cgd 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 #ifndef lint
  35 static char rcsid[] = "$NetBSD: mem1.c,v 1.2 1995/07/03 21:24:25 cgd Exp $";
  36 #endif
  37
  38 #include <sys/types.h>
  39 #include <sys/mman.h>
  40 #include <sys/param.h>
  41 #include <stdlib.h>
  42 #include <string.h>
  43 #include <unistd.h>
  44 #include <err.h>
  45
  46 #include "lint1.h"
  47
  48 /*
  49  * Filenames allocated by fnalloc() and fnnalloc() are shared.
  50  */
  51 typedef struct fn {
  52         char    *fn_name;
  53         size_t  fn_len;
  54         int     fn_id;
  55         struct  fn *fn_nxt;
  56 } fn_t;
  57
  58 static  fn_t    *fnames;
  59
  60 static  fn_t    *srchfn __P((const char *, size_t));
  61
  62 /*
  63  * Look for a Filename of length l.
  64  */
  65 static fn_t *
  66 srchfn(s, len)
  67         const   char *s;
  68         size_t  len;
  69 {
  70         fn_t    *fn;
  71
  72         for (fn = fnames; fn != NULL; fn = fn->fn_nxt) {
  73                 if (fn->fn_len == len && memcmp(fn->fn_name, s, len) == 0)
  74                         break;
  75         }
  76         return (fn);
  77 }
  78
  79 /*
  80  * Return a shared string for filename s.
  81  */
  82 const char *
  83 fnalloc(s)
  84         const   char *s;
  85 {
  86         return (s != NULL ? fnnalloc(s, strlen(s)) : NULL);
  87 }
  88
  89 const char *
  90 fnnalloc(s, len)
  91         const   char *s;
  92         size_t  len;
  93 {
  94         fn_t    *fn;
  95
  96         static  int     nxt_id = 0;
  97
  98         if (s == NULL)
  99                 return (NULL);
 100
 101         if ((fn = srchfn(s, len)) == NULL) {
 102                 fn = xmalloc(sizeof (fn_t));
 103                 /* Do not used strdup() because string is not NUL-terminated.*/
 104                 fn->fn_name = xmalloc(len + 1);
 105                 (void)memcpy(fn->fn_name, s, len);
 106                 fn->fn_name[len] = '\0';
 107                 fn->fn_len = len;
 108                 fn->fn_id = nxt_id++;
 109                 fn->fn_nxt = fnames;
 110                 fnames = fn;
 111                 /* Write id of this filename to the output file. */
 112                 outclr();
 113                 outint(fn->fn_id);
 114                 outchar('s');
 115                 outstrg(fn->fn_name);
 116         }
 117         return (fn->fn_name);
 118 }
 119
 120 /*
 121  * Get id of a filename.
 122  */
 123 int
 124 getfnid(s)
 125         const   char *s;
 126 {
 127         fn_t    *fn;
 128
 129         if (s == NULL || (fn = srchfn(s, strlen(s))) == NULL)
 130                 return (-1);
 131         return (fn->fn_id);
 132 }
 133
 134 /*
 135  * Memory for declarations and other things which must be available
 136  * until the end of a block (or the end of the translation unit)
 137  * are assoziated with the level (mblklev) of the block (or wiht 0).
 138  * Because these memory is allocated in large blocks associated with
 139  * a given level it can be freed easily at the end of a block.
 140  */
 141 #define ML_INC  ((size_t)32)            /* Increment for length of *mblks */
 142
 143 typedef struct mbl {
 144         void    *blk;                   /* beginning of memory block */
 145         void    *ffree;                 /* first free byte */
 146         size_t  nfree;                  /* # of free bytes */
 147         size_t  size;                   /* total size of memory block */
 148         struct  mbl *nxt;               /* next block */
 149 } mbl_t;
 150
 151 /*
 152  * Array of pointers to lists of memory blocks. mblklev is used as
 153  * index into this array.
 154  */
 155 static  mbl_t   **mblks;
 156
 157 /* number of elements in *mblks */
 158 static  size_t  nmblks;
 159
 160 /* free list for memory blocks */
 161 static  mbl_t   *frmblks;
 162
 163 /* length of new allocated memory blocks */
 164 static  size_t  mblklen;
 165
 166 static  void    *xgetblk __P((mbl_t **, size_t));
 167 static  void    xfreeblk __P((mbl_t **));
 168 static  mbl_t   *xnewblk __P((void));
 169
 170 static mbl_t *
 171 xnewblk()
 172 {
 173         mbl_t   *mb;
 174         int     prot, flags;
 175
 176         mb = xmalloc(sizeof (mbl_t));
 177
 178         /* use mmap instead of malloc to avoid malloc's size overhead */
 179
 180         prot = PROT_READ | PROT_WRITE;
 181         flags = MAP_ANON | MAP_PRIVATE;
 182         mb->blk = mmap(NULL, mblklen, prot, flags, -1, (off_t)0);
 183         if (mb->blk == (void *)MAP_FAILED)
 184                 err(1, "can't map memory");
 185         if (ALIGN((u_long)mb->blk) != (u_long)mb->blk)
 186                 errx(1, "mapped address is not aligned");
 187
 188         mb->size = mblklen;
 189
 190         return (mb);
 191 }
 192
 193 /*
 194  * Allocate new memory. If the first block of the list has not enough
 195  * free space, or there is no first block, get a new block. The new
 196  * block is taken from the free list or, if there is no block on the
 197  * free list, is allocated using xnewblk(). If a new block is allocated
 198  * it is initialized with zero. Blocks taken from the free list are
 199  * zero'd in xfreeblk().
 200  */
 201 static void *
 202 xgetblk(mbp, s)
 203         mbl_t   **mbp;
 204         size_t  s;
 205 {
 206         mbl_t   *mb;
 207         void    *p;
 208
 209         s = ALIGN(s);
 210         if ((mb = *mbp) == NULL || mb->nfree < s) {
 211                 if ((mb = frmblks) == NULL) {
 212                         mb = xnewblk();
 213                         (void)memset(mb->blk, 0, mb->size);
 214                 } else {
 215                         frmblks = mb->nxt;
 216                 }
 217                 mb->ffree = mb->blk;
 218                 mb->nfree = mb->size;;
 219                 mb->nxt = *mbp;
 220                 *mbp = mb;
 221         }
 222         p = mb->ffree;
 223         mb->ffree = (char *)mb->ffree + s;
 224         mb->nfree -= s;
 225         return (p);
 226 }
 227
 228 /*
 229  * Move all blocks from list *fmbp to free list. For each block, set all
 230  * used memory to zero.
 231  */
 232 static void
 233 xfreeblk(fmbp)
 234         mbl_t   **fmbp;
 235 {
 236         mbl_t   *mb;
 237
 238         while ((mb = *fmbp) != NULL) {
 239                 *fmbp = mb->nxt;
 240                 mb->nxt = frmblks;
 241                 frmblks = mb;
 242                 (void)memset(mb->blk, 0, mb->size - mb->nfree);
 243         }
 244 }
 245
 246 void
 247 initmem()
 248 {
 249         int     pgsz;
 250
 251         pgsz = getpagesize();
 252         mblklen = ((MBLKSIZ + pgsz - 1) / pgsz) * pgsz;
 253
 254         mblks = xcalloc(nmblks = ML_INC, sizeof (mbl_t *));
 255 }
 256
 257
 258 /*
 259  * Allocate memory associated with level l.
 260  */
 261 void *
 262 getlblk(l, s)
 263         int     l;
 264         size_t  s;
 265 {
 266         while (l >= nmblks) {
 267                 mblks = xrealloc(mblks, (nmblks + ML_INC) * sizeof (mbl_t *));
 268                 (void)memset(&mblks[nmblks], 0, ML_INC * sizeof (mbl_t *));
 269                 nmblks += ML_INC;
 270         }
 271         return (xgetblk(&mblks[l], s));
 272 }
 273
 274 void *
 275 getblk(s)
 276         size_t  s;
 277 {
 278         return (getlblk(mblklev, s));
 279 }
 280
 281 /*
 282  * Free all memory associated with level l.
 283  */
 284 void
 285 freelblk(l)
 286         int     l;
 287 {
 288         xfreeblk(&mblks[l]);
 289 }
 290
 291 void
 292 freeblk()
 293 {
 294         freelblk(mblklev);
 295 }
 296
 297 /*
 298  * tgetblk() returns memory which is associated with the current
 299  * expression.
 300  */
 301 static  mbl_t   *tmblk;
 302
 303 void *
 304 tgetblk(s)
 305         size_t  s;
 306 {
 307         return (xgetblk(&tmblk, s));
 308 }
 309
 310 /*
 311  * Get memory for a new tree node.
 312  */
 313 tnode_t *
 314 getnode()
 315 {
 316         return (tgetblk(sizeof (tnode_t)));
 317 }
 318
 319 /*
 320  * Free all memory which is allocated by the the current expression.
 321  */
 322 void
 323 tfreeblk()
 324 {
 325         xfreeblk(&tmblk);
 326 }
 327
 328 /*
 329  * Save the memory which is used by the current expression. This memory
 330  * is not freed by the next tfreeblk() call. The pointer returned can be
 331  * used to restore the memory.
 332  */
 333 mbl_t *
 334 tsave()
 335 {
 336         mbl_t   *tmem;
 337
 338         tmem = tmblk;
 339         tmblk = NULL;
 340         return (tmem);
 341 }
 342
 343 /*
 344  * Free all memory used for the current expression and the memory used
 345  * be a previous expression and saved by tsave(). The next call to
 346  * tfreeblk() frees the restored memory.
 347  */
 348 void
 349 trestor(tmem)
 350         mbl_t   *tmem;
 351 {
 352         tfreeblk();
 353         if (tmblk != NULL) {
 354                 free(tmblk->blk);
 355                 free(tmblk);
 356         }
 357         tmblk = tmem;
 358 }