freebsd-dev/usr.bin/xlint/lint1/mem1.c
2002-07-19 16:38:21 +00:00

365 lines
7.7 KiB
C

/* $NetBSD: mem1.c,v 1.7 2002/01/31 19:36:54 tv Exp $ */
/*
* Copyright (c) 1994, 1995 Jochen Pohl
* All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by Jochen Pohl for
* The NetBSD Project.
* 4. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <sys/cdefs.h>
#if defined(__RCSID) && !defined(lint)
__RCSID("$NetBSD: mem1.c,v 1.7 2002/01/31 19:36:54 tv Exp $");
#endif
__FBSDID("$FreeBSD$");
#include <sys/types.h>
#include <sys/mman.h>
#include <sys/param.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "lint1.h"
/*
* Filenames allocated by fnalloc() and fnnalloc() are shared.
*/
typedef struct fn {
char *fn_name;
size_t fn_len;
int fn_id;
struct fn *fn_nxt;
} fn_t;
static fn_t *fnames;
static fn_t *srchfn(const char *, size_t);
/*
* Look for a Filename of length l.
*/
static fn_t *
srchfn(const char *s, size_t len)
{
fn_t *fn;
for (fn = fnames; fn != NULL; fn = fn->fn_nxt) {
if (fn->fn_len == len && memcmp(fn->fn_name, s, len) == 0)
break;
}
return (fn);
}
/*
* Return a shared string for filename s.
*/
const char *
fnalloc(const char *s)
{
return (s != NULL ? fnnalloc(s, strlen(s)) : NULL);
}
const char *
fnnalloc(const char *s, size_t len)
{
fn_t *fn;
static int nxt_id = 0;
if (s == NULL)
return (NULL);
if ((fn = srchfn(s, len)) == NULL) {
if ((fn = malloc(sizeof (fn_t))) == NULL)
nomem();
/* Do not used strdup() because string is not NUL-terminated.*/
if ((fn->fn_name = malloc(len + 1)) == NULL)
nomem();
(void)memcpy(fn->fn_name, s, len);
fn->fn_name[len] = '\0';
fn->fn_len = len;
fn->fn_id = nxt_id++;
fn->fn_nxt = fnames;
fnames = fn;
/* Write id of this filename to the output file. */
outclr();
outint(fn->fn_id);
outchar('s');
outstrg(fn->fn_name);
}
return (fn->fn_name);
}
/*
* Get id of a filename.
*/
int
getfnid(const char *s)
{
fn_t *fn;
if (s == NULL || (fn = srchfn(s, strlen(s))) == NULL)
return (-1);
return (fn->fn_id);
}
/*
* Memory for declarations and other things which must be available
* until the end of a block (or the end of the translation unit)
* are assoziated with the level (mblklev) of the block (or wiht 0).
* Because these memory is allocated in large blocks associated with
* a given level it can be freed easily at the end of a block.
*/
#define ML_INC ((size_t)32) /* Increment for length of *mblks */
typedef struct mbl {
void *blk; /* beginning of memory block */
void *ffree; /* first free byte */
size_t nfree; /* # of free bytes */
size_t size; /* total size of memory block */
struct mbl *nxt; /* next block */
} mbl_t;
/*
* Array of pointers to lists of memory blocks. mblklev is used as
* index into this array.
*/
static mbl_t **mblks;
/* number of elements in *mblks */
static size_t nmblks;
/* free list for memory blocks */
static mbl_t *frmblks;
/* length of new allocated memory blocks */
static size_t mblklen;
static void *xgetblk(mbl_t **, size_t);
static void xfreeblk(mbl_t **);
static mbl_t *xnewblk(void);
static mbl_t *
xnewblk(void)
{
mbl_t *mb;
int prot, flags;
if ((mb = malloc(sizeof (mbl_t))) == NULL)
nomem();
/* use mmap instead of malloc to avoid malloc's size overhead */
prot = PROT_READ | PROT_WRITE;
flags = MAP_ANON | MAP_PRIVATE;
mb->blk = mmap(NULL, mblklen, prot, flags, -1, (off_t)0);
if (mb->blk == (void *)MAP_FAILED)
err(1, "can't map memory");
mb->size = mblklen;
return (mb);
}
/*
* Allocate new memory. If the first block of the list has not enough
* free space, or there is no first block, get a new block. The new
* block is taken from the free list or, if there is no block on the
* free list, is allocated using xnewblk(). If a new block is allocated
* it is initialized with zero. Blocks taken from the free list are
* zero'd in xfreeblk().
*/
static void *
xgetblk(mbl_t **mbp, size_t s)
{
mbl_t *mb;
void *p;
size_t t = 0;
s = ALIGN(s);
if ((mb = *mbp) == NULL || mb->nfree < s) {
if ((mb = frmblks) == NULL) {
if (s > mblklen) {
t = mblklen;
mblklen = s;
}
mb = xnewblk();
if (t)
mblklen = t;
(void)memset(mb->blk, 0, mb->size);
} else {
frmblks = mb->nxt;
}
mb->ffree = mb->blk;
mb->nfree = mb->size;;
mb->nxt = *mbp;
*mbp = mb;
}
p = mb->ffree;
mb->ffree = (char *)mb->ffree + s;
mb->nfree -= s;
return (p);
}
/*
* Move all blocks from list *fmbp to free list. For each block, set all
* used memory to zero.
*/
static void
xfreeblk(mbl_t **fmbp)
{
mbl_t *mb;
while ((mb = *fmbp) != NULL) {
*fmbp = mb->nxt;
mb->nxt = frmblks;
frmblks = mb;
(void)memset(mb->blk, 0, mb->size - mb->nfree);
}
}
void
initmem(void)
{
int pgsz;
pgsz = getpagesize();
mblklen = ((MBLKSIZ + pgsz - 1) / pgsz) * pgsz;
if ((mblks = calloc(nmblks = ML_INC, sizeof (mbl_t *))) == NULL)
nomem();
}
/*
* Allocate memory associated with level l.
*/
void *
getlblk(int l, size_t s)
{
while (l >= nmblks) {
if ((mblks = realloc(mblks, (nmblks + ML_INC) *
sizeof (mbl_t *))) == NULL)
nomem();
(void)memset(&mblks[nmblks], 0, ML_INC * sizeof (mbl_t *));
nmblks += ML_INC;
}
return (xgetblk(&mblks[l], s));
}
void *
getblk(size_t s)
{
return (getlblk(mblklev, s));
}
/*
* Free all memory associated with level l.
*/
void
freelblk(int l)
{
xfreeblk(&mblks[l]);
}
void
freeblk(void)
{
freelblk(mblklev);
}
/*
* tgetblk() returns memory which is associated with the current
* expression.
*/
static mbl_t *tmblk;
void *
tgetblk(size_t s)
{
return (xgetblk(&tmblk, s));
}
/*
* Get memory for a new tree node.
*/
tnode_t *
getnode(void)
{
return (tgetblk(sizeof (tnode_t)));
}
/*
* Free all memory which is allocated by the current expression.
*/
void
tfreeblk(void)
{
xfreeblk(&tmblk);
}
/*
* Save the memory which is used by the current expression. This memory
* is not freed by the next tfreeblk() call. The pointer returned can be
* used to restore the memory.
*/
mbl_t *
tsave(void)
{
mbl_t *tmem;
tmem = tmblk;
tmblk = NULL;
return (tmem);
}
/*
* Free all memory used for the current expression and the memory used
* be a previous expression and saved by tsave(). The next call to
* tfreeblk() frees the restored memory.
*/
void
trestor(mbl_t *tmem)
{
tfreeblk();
if (tmblk != NULL) {
free(tmblk->blk);
free(tmblk);
}
tmblk = tmem;
}