usr.bin/xlint/lint1/mem1.c

   1 /*      $NetBSD: mem1.c,v 1.12 2009/04/15 01:20:57 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.12 2009/04/15 01:20:57 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 = ALIGN(s);
 196         if ((mb = *mbp) == NULL || mb->nfree < s) {
 197                 if ((mb = frmblks) == NULL) {
 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  */
 224 static void
 225 xfreeblk(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
 237 void
 238 initmem(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  */
 252 void *
 253 getlblk(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
 264 void *
 265 getblk(size_t s)
 266 {
 267
 268         return (getlblk(mblklev, s));
 269 }
 270
 271 /*
 272  * Free all memory associated with level l.
 273  */
 274 void
 275 freelblk(int l)
 276 {
 277
 278         xfreeblk(&mblks[l]);
 279 }
 280
 281 void
 282 freeblk(void)
 283 {
 284
 285         freelblk(mblklev);
 286 }
 287
 288 /*
 289  * tgetblk() returns memory which is associated with the current
 290  * expression.
 291  */
 292 static  mbl_t   *tmblk;
 293
 294 void *
 295 tgetblk(size_t s)
 296 {
 297
 298         return (xgetblk(&tmblk, s));
 299 }
 300
 301 /*
 302  * Get memory for a new tree node.
 303  */
 304 tnode_t *
 305 getnode(void)
 306 {
 307
 308         return (tgetblk(sizeof (tnode_t)));
 309 }
 310
 311 /*
 312  * Free all memory which is allocated by the current expression.
 313  */
 314 void
 315 tfreeblk(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  */
 326 mbl_t *
 327 tsave(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  */
 341 void
 342 trestor(mbl_t *tmem)
 343 {
 344
 345         tfreeblk();
 346         if (tmblk != NULL) {
 347                 free(tmblk->blk);
 348                 free(tmblk);
 349         }
 350         tmblk = tmem;
 351 }