xref: /titanic_41/usr/src/lib/libast/common/vmalloc/vmhdr.h (revision 3e14f97f673e8a630f076077de35afdd43dc1587)
1 /***********************************************************************
2 *                                                                      *
3 *               This software is part of the ast package               *
4 *          Copyright (c) 1985-2010 AT&T Intellectual Property          *
5 *                      and is licensed under the                       *
6 *                  Common Public License, Version 1.0                  *
7 *                    by AT&T Intellectual Property                     *
8 *                                                                      *
9 *                A copy of the License is available at                 *
10 *            http://www.opensource.org/licenses/cpl1.0.txt             *
11 *         (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9)         *
12 *                                                                      *
13 *              Information and Software Systems Research               *
14 *                            AT&T Research                             *
15 *                           Florham Park NJ                            *
16 *                                                                      *
17 *                 Glenn Fowler <gsf@research.att.com>                  *
18 *                  David Korn <dgk@research.att.com>                   *
19 *                   Phong Vo <kpv@research.att.com>                    *
20 *                                                                      *
21 ***********************************************************************/
22 #ifndef _VMHDR_H
23 #define _VMHDR_H	1
24 #ifndef _BLD_vmalloc
25 #define _BLD_vmalloc	1
26 #endif
27 
28 /*	Common types, and macros for vmalloc functions.
29 **
30 **	Written by Kiem-Phong Vo, kpv@research.att.com, 01/16/94.
31 */
32 
33 #ifndef __STD_C	/* this is normally in vmalloc.h but it's included late here */
34 #ifdef __STDC__
35 #define	__STD_C		1
36 #else
37 #if __cplusplus || c_plusplus
38 #define __STD_C		1
39 #else
40 #define __STD_C		0
41 #endif /*__cplusplus*/
42 #endif /*__STDC__*/
43 #endif /*__STD_C*/
44 
45 #if _PACKAGE_ast
46 
47 #if !_UWIN
48 #define getpagesize		______getpagesize
49 #define _npt_getpagesize	1
50 #define brk			______brk
51 #define sbrk			______sbrk
52 #define _npt_sbrk		1
53 #endif
54 
55 #include	<ast.h>
56 
57 #if _npt_getpagesize
58 #undef				getpagesize
59 #endif
60 #if _npt_sbrk
61 #undef				brk
62 #undef				sbrk
63 #endif
64 
65 #else
66 
67 #include	<ast_common.h>
68 
69 #if !_UWIN
70 #define _npt_getpagesize	1
71 #define _npt_sbrk		1
72 #endif
73 
74 #ifndef integralof
75 #define integralof(x)		(((char*)(x))-((char*)0))
76 #endif
77 
78 #endif /*_PACKAGE_ast*/
79 
80 #include	"FEATURE/vmalloc"
81 
82 #include	<setjmp.h>
83 
84 /* the below macros decide which combinations of sbrk() or mmap() to used */
85 #if defined(_WIN32)
86 #define _mem_win32	1
87 #undef _mem_sbrk
88 #undef _mem_mmap_anon
89 #undef _mem_mmap_zero
90 #endif
91 
92 #if _mem_mmap_anon
93 #undef _mem_mmap_zero
94 #endif
95 
96 #if !_mem_win32 && !_mem_sbrk && !_mem_mmap_anon && !_mem_mmap_zero
97 #undef _std_malloc
98 #define _std_malloc	1	/* do not define malloc/free/realloc */
99 #endif
100 
101 typedef unsigned char	Vmuchar_t;
102 typedef unsigned long	Vmulong_t;
103 
104 typedef union _head_u	Head_t;
105 typedef union _body_u	Body_t;
106 typedef struct _block_s	Block_t;
107 typedef struct _seg_s	Seg_t;
108 typedef struct _pfobj_s	Pfobj_t;
109 
110 #if !_typ_ssize_t
111 typedef int		ssize_t;
112 #endif
113 
114 #define NIL(t)		((t)0)
115 #define reg		register
116 #if __STD_C
117 #define NOTUSED(x)	(void)(x)
118 #else
119 #define NOTUSED(x)	(&x,1)
120 #endif
121 
122 /* convert an address to an integral value */
123 #define VLONG(addr)	((Vmulong_t)((char*)(addr) - (char*)0) )
124 
125 /* Round x up to a multiple of y. ROUND2 does powers-of-2 and ROUNDX does others */
126 #define ROUND2(x,y)	(((x) + ((y)-1)) & ~((y)-1))
127 #define ROUNDX(x,y)	((((x) + ((y)-1)) / (y)) * (y))
128 #define ROUND(x,y)	(((y)&((y)-1)) ? ROUNDX((x),(y)) : ROUND2((x),(y)) )
129 
130 /* compute a value that is a common multiple of x and y */
131 #define MULTIPLE(x,y)	((x)%(y) == 0 ? (x) : (y)%(x) == 0 ? (y) : (y)*(x))
132 
133 #define VM_check	0x0001	/* enable detailed checks		*/
134 #define VM_abort	0x0002	/* abort() on assertion failure		*/
135 #define VM_region	0x0004	/* enable region segment checks		*/
136 #define VM_mmap		0x0010	/* favor mmap allocation		*/
137 
138 #if _UWIN
139 #include <ast_windows.h>
140 #endif
141 
142 #ifndef DEBUG
143 #ifdef _BLD_DEBUG
144 #define DEBUG		1
145 #endif /*_BLD_DEBUG*/
146 #endif /*DEBUG*/
147 #if DEBUG
148 extern void		_vmmessage _ARG_((const char*, long, const char*, long));
149 #define ABORT()		(_Vmassert & VM_abort)
150 #define CHECK()		(_Vmassert & VM_check)
151 #define ASSERT(p)	((p) ? 0 : (MESSAGE("Assertion failed"), ABORT() ? (abort(),0) : 0))
152 #define COUNT(n)	((n) += 1)
153 #define MESSAGE(s)	_vmmessage(__FILE__,__LINE__,s,0)
154 #else
155 #define ABORT()		(0)
156 #define ASSERT(p)
157 #define CHECK()		(0)
158 #define COUNT(n)
159 #define MESSAGE(s)	(0)
160 #endif /*DEBUG*/
161 
162 #define VMPAGESIZE	8192
163 
164 #if _AST_PAGESIZE > VMPAGESIZE
165 #undef	VMPAGESIZE
166 #define VMPAGESIZE	_AST_PAGESIZE
167 #endif
168 
169 #if _lib_getpagesize && !defined(_AST_PAGESIZE)
170 #define GETPAGESIZE(x)	((x) ? (x) : \
171 			 (((x)=getpagesize()) < VMPAGESIZE ? ((x)=VMPAGESIZE) : (x)) )
172 #else
173 #define GETPAGESIZE(x)	((x) = VMPAGESIZE)
174 #endif
175 
176 #ifdef	_AST_PAGESIZE
177 #define VMHEAPINCR	(_Vmpagesize*1)
178 #else
179 #define VMHEAPINCR	(_Vmpagesize*4)
180 #endif
181 
182 /* Blocks are allocated such that their sizes are 0%(BITS+1)
183 ** This frees up enough low order bits to store state information
184 */
185 #define BUSY		(01)	/* block is busy				*/
186 #define PFREE		(02)	/* preceding block is free			*/
187 #define JUNK		(04)	/* marked as freed but not yet processed	*/
188 #define BITS		(07)	/* (BUSY|PFREE|JUNK)				*/
189 #define ALIGNB		(8)	/* size must be a multiple of BITS+1		*/
190 
191 #define ISBITS(w)	((w) & BITS)
192 #define CLRBITS(w)	((w) &= ~BITS)
193 #define CPYBITS(w,f)	((w) |= ((f)&BITS) )
194 
195 #define ISBUSY(w)	((w) & BUSY)
196 #define SETBUSY(w)	((w) |= BUSY)
197 #define CLRBUSY(w)	((w) &= ~BUSY)
198 
199 #define ISPFREE(w)	((w) & PFREE)
200 #define SETPFREE(w)	((w) |= PFREE)
201 #define CLRPFREE(w)	((w) &= ~PFREE)
202 
203 #define ISJUNK(w)	((w) & JUNK)
204 #define SETJUNK(w)	((w) |= JUNK)
205 #define CLRJUNK(w)	((w) &= ~JUNK)
206 
207 #define OFFSET(t,e)	((size_t)(&(((t*)0)->e)) )
208 
209 /* these bits share the "mode" field with the public bits */
210 #define VM_AGAIN	0010000		/* research the arena for space */
211 #define VM_LOCK		0020000		/* region is locked		*/
212 #define VM_LOCAL	0040000		/* local call, bypass lock	*/
213 #define VM_INUSE	0004000		/* some operation is running	*/
214 #define VM_UNUSED	0100060
215 #define VMETHOD(vd)	((vd)->mode&VM_METHODS)
216 
217 /* test/set/clear lock state */
218 #define SETINUSE(vd,iu)	(((iu) = (vd)->mode&VM_INUSE), ((vd)->mode |= VM_INUSE) )
219 #define CLRINUSE(vd,iu)	((iu) ? 0 : ((vd)->mode &= ~VM_INUSE) )
220 #define SETLOCAL(vd)	((vd)->mode |= VM_LOCAL)
221 #define GETLOCAL(vd,l)	(((l) = (vd)->mode&VM_LOCAL), ((vd)->mode &= ~VM_LOCAL) )
222 #define ISLOCK(vd,l)	((l) ? 0 : ((vd)->mode &  VM_LOCK) )
223 #define SETLOCK(vd,l)	((l) ? 0 : ((vd)->mode |= VM_LOCK) )
224 #define CLRLOCK(vd,l)	((l) ? 0 : ((vd)->mode &= ~VM_LOCK) )
225 
226 /* announcing entry/exit of allocation calls */
227 #define ANNOUNCE(lc, vm,ev,dt,dc) \
228 		(( ((lc)&VM_LOCAL) || !(dc) || !(dc)->exceptf ) ? 0 : \
229 			(*(dc)->exceptf)((vm), (ev), (Void_t*)(dt), (dc)) )
230 
231 
232 /* local calls */
233 #define KPVALLOC(vm,sz,func)		(SETLOCAL((vm)->data), func((vm),(sz)) )
234 #define KPVALIGN(vm,sz,al,func)		(SETLOCAL((vm)->data), func((vm),(sz),(al)) )
235 #define KPVFREE(vm,d,func)		(SETLOCAL((vm)->data), func((vm),(d)) )
236 #define KPVRESIZE(vm,d,sz,mv,func)	(SETLOCAL((vm)->data), func((vm),(d),(sz),(mv)) )
237 #define KPVADDR(vm,addr,func)		(SETLOCAL((vm)->data), func((vm),(addr)) )
238 #define KPVCOMPACT(vm,func)		(SETLOCAL((vm)->data), func((vm)) )
239 
240 /* ALIGN is chosen so that a block can store all primitive types.
241 ** It should also be a multiple of ALIGNB==(BITS+1) so the size field
242 ** of Block_t will always be 0%(BITS+1) as noted above.
243 ** Of paramount importance is the ALIGNA macro below. If the local compile
244 ** environment is strange enough that the below method does not calculate
245 ** ALIGNA right, then the code below should be commented out and ALIGNA
246 ** redefined to the appropriate requirement.
247 */
248 union _align_u
249 {	char		c, *cp;
250 	int		i, *ip;
251 	long		l, *lp;
252 	double		d, *dp, ***dppp[8];
253 	size_t		s, *sp;
254 	void(*		fn)();
255 	union _align_u*	align;
256 	Head_t*		head;
257 	Body_t*		body;
258 	Block_t*	block;
259 	Vmuchar_t	a[ALIGNB];
260 	_ast_fltmax_t	ld, *ldp;
261 	jmp_buf		jmp;
262 };
263 struct _a_s
264 {	char		c;
265 	union _align_u	a;
266 };
267 #define ALIGNA	(sizeof(struct _a_s) - sizeof(union _align_u))
268 struct _align_s
269 {	char	data[MULTIPLE(ALIGNA,ALIGNB)];
270 };
271 #undef	ALIGN	/* bsd sys/param.h defines this */
272 #define ALIGN	sizeof(struct _align_s)
273 
274 /* make sure that the head of a block is a multiple of ALIGN */
275 struct _head_s
276 {	union
277 	{ Seg_t*	seg;	/* the containing segment	*/
278 	  Block_t*	link;	/* possible link list usage	*/
279 	  Pfobj_t*	pf;	/* profile structure pointer	*/
280 	  char*		file;	/* for file name in Vmdebug	*/
281 	} seg;
282 	union
283 	{ size_t	size;	/* size of data area in bytes	*/
284 	  Block_t*	link;	/* possible link list usage	*/
285 	  int		line;	/* for line number in Vmdebug	*/
286 	} size;
287 };
288 #define HEADSIZE	ROUND(sizeof(struct _head_s),ALIGN)
289 union _head_u
290 {	Vmuchar_t	data[HEADSIZE];	/* to standardize size		*/
291 	struct _head_s	head;
292 };
293 
294 /* now make sure that the body of a block is a multiple of ALIGN */
295 struct _body_s
296 {	Block_t*	link;	/* next in link list		*/
297 	Block_t*	left;	/* left child in free tree	*/
298 	Block_t*	right;	/* right child in free tree	*/
299 	Block_t**	self;	/* self pointer when free	*/
300 };
301 #define BODYSIZE	ROUND(sizeof(struct _body_s),ALIGN)
302 union _body_u
303 {	Vmuchar_t	data[BODYSIZE];	/* to standardize size		*/
304 	struct _body_s	body;
305 };
306 
307 /* After all the songs and dances, we should now have:
308 **	sizeof(Head_t)%ALIGN == 0
309 **	sizeof(Body_t)%ALIGN == 0
310 ** and	sizeof(Block_t) = sizeof(Head_t)+sizeof(Body_t)
311 */
312 struct _block_s
313 {	Head_t	head;
314 	Body_t	body;
315 };
316 
317 /* requirements for smallest block type */
318 struct _tiny_s
319 {	Block_t*	link;
320 	Block_t*	self;
321 };
322 #define TINYSIZE	ROUND(sizeof(struct _tiny_s),ALIGN)
323 #define S_TINY		1				/* # of tiny blocks	*/
324 #define MAXTINY		(S_TINY*ALIGN + TINYSIZE)
325 #define TLEFT(b)	((b)->head.head.seg.link)	/* instead of LEFT	*/
326 #define TINIEST(b)	(SIZE(b) == TINYSIZE)		/* this type uses TLEFT	*/
327 
328 #define DIV(x,y)	((y) == 8 ? ((x)>>3) : (x)/(y) )
329 #define INDEX(s)	DIV((s)-TINYSIZE,ALIGN)
330 
331 /* small block types kept in separate caches for quick allocation */
332 #define S_CACHE		6	/* # of types of small blocks to be cached	*/
333 #define N_CACHE		32	/* on allocation, create this many at a time	*/
334 #define MAXCACHE	(S_CACHE*ALIGN + TINYSIZE)
335 #define C_INDEX(s)	(s < MAXCACHE ? INDEX(s) : S_CACHE)
336 
337 #define TINY(vd)	((vd)->tiny)
338 #define CACHE(vd)	((vd)->cache)
339 
340 struct _vmdata_s
341 {	int		mode;		/* current mode for region		*/
342 	size_t		incr;		/* allocate in multiple of this		*/
343 	size_t		pool;		/* size	of an elt in a Vmpool region	*/
344 	Seg_t*		seg;		/* list of segments			*/
345 	Block_t*	free;		/* most recent free block		*/
346 	Block_t*	wild;		/* wilderness block			*/
347 	Block_t*	root;		/* root of free tree			*/
348 	Block_t*	tiny[S_TINY];	/* small blocks				*/
349 	Block_t*	cache[S_CACHE+1]; /* delayed free blocks		*/
350 };
351 /* Vmdata_t typedef in <vmalloc.h> */
352 
353 #include	"vmalloc.h"
354 
355 #if !_PACKAGE_ast
356 /* we don't use these here and they interfere with some local names */
357 #undef malloc
358 #undef free
359 #undef realloc
360 #endif
361 
362 /* segment structure */
363 struct _seg_s
364 {	Vmdata_t*	vmdt;	/* the data region holding this	*/
365 	Seg_t*		next;	/* next segment			*/
366 	Void_t*		addr;	/* starting segment address	*/
367 	size_t		extent;	/* extent of segment		*/
368 	Vmuchar_t*	baddr;	/* bottom of usable memory	*/
369 	size_t		size;	/* allocable size		*/
370 	Block_t*	free;	/* recent free blocks		*/
371 	Block_t*	last;	/* Vmlast last-allocated block	*/
372 };
373 
374 /* starting block of a segment */
375 #define SEGBLOCK(s)	((Block_t*)(((Vmuchar_t*)(s)) + ROUND(sizeof(Seg_t),ALIGN)))
376 
377 /* short-hands for block data */
378 #define SEG(b)		((b)->head.head.seg.seg)
379 #define SEGLINK(b)	((b)->head.head.seg.link)
380 #define	SIZE(b)		((b)->head.head.size.size)
381 #define SIZELINK(b)	((b)->head.head.size.link)
382 #define LINK(b)		((b)->body.body.link)
383 #define LEFT(b)		((b)->body.body.left)
384 #define RIGHT(b)	((b)->body.body.right)
385 #define VM(b)		(SEG(b)->vm)
386 
387 #define DATA(b)		((Void_t*)((b)->body.data) )
388 #define BLOCK(d)	((Block_t*)((char*)(d) - sizeof(Head_t)) )
389 #define SELF(b)		((Block_t**)((b)->body.data + SIZE(b) - sizeof(Block_t*)) )
390 #define LAST(b)		(*((Block_t**)(((char*)(b)) - sizeof(Block_t*)) ) )
391 #define NEXT(b)		((Block_t*)((b)->body.data + SIZE(b)) )
392 
393 /* functions to manipulate link lists of elts of the same size */
394 #define SETLINK(b)	(RIGHT(b) =  (b) )
395 #define ISLINK(b)	(RIGHT(b) == (b) )
396 #define UNLINK(vd,b,i,t) \
397 		((((t) = LINK(b)) ? (LEFT(t) = LEFT(b)) : NIL(Block_t*) ), \
398 		 (((t) = LEFT(b)) ? (LINK(t) = LINK(b)) : (TINY(vd)[i] = LINK(b)) ) )
399 
400 /* delete a block from a link list or the free tree.
401 ** The test in the below macro is worth scratching your head a bit.
402 ** Even though tiny blocks (size < BODYSIZE) are kept in separate lists,
403 ** only the TINIEST ones require TLEFT(b) for the back link. Since this
404 ** destroys the SEG(b) pointer, it must be carefully restored in bestsearch().
405 ** Other tiny blocks have enough space to use the usual LEFT(b).
406 ** In this case, I have also carefully arranged so that RIGHT(b) and
407 ** SELF(b) can be overlapped and the test ISLINK() will go through.
408 */
409 #define REMOVE(vd,b,i,t,func) \
410 		((!TINIEST(b) && ISLINK(b)) ? UNLINK((vd),(b),(i),(t)) : \
411 	 		func((vd),SIZE(b),(b)) )
412 
413 /* see if a block is the wilderness block */
414 #define SEGWILD(b)	(((b)->body.data+SIZE(b)+sizeof(Head_t)) >= SEG(b)->baddr)
415 #define VMWILD(vd,b)	(((b)->body.data+SIZE(b)+sizeof(Head_t)) >= vd->seg->baddr)
416 
417 #define VMFLF(vm,fi,ln,fn)	((fi) = (vm)->file, (vm)->file = NIL(char*), \
418 		 		 (ln) = (vm)->line, (vm)->line = 0 , \
419 		 		 (fn) = (vm)->func, (vm)->func = NIL(Void_t*) )
420 
421 /* The lay-out of a Vmprofile block is this:
422 **	seg_ size ----data---- _pf_ size
423 **	_________ ____________ _________
424 **	seg_, size: header required by Vmbest.
425 **	data:	actual data block.
426 **	_pf_:	pointer to the corresponding Pfobj_t struct
427 **	size:	the true size of the block.
428 ** So each block requires an extra Head_t.
429 */
430 #define PF_EXTRA   sizeof(Head_t)
431 #define PFDATA(d)  ((Head_t*)((Vmuchar_t*)(d)+(SIZE(BLOCK(d))&~BITS)-sizeof(Head_t)) )
432 #define PFOBJ(d)   (PFDATA(d)->head.seg.pf)
433 #define PFSIZE(d)  (PFDATA(d)->head.size.size)
434 
435 /* The lay-out of a block allocated by Vmdebug is this:
436 **	seg_ size file size seg_ magi ----data---- --magi-- magi line
437 **	--------- --------- --------- ------------ -------- ---------
438 **	seg_,size: header required by Vmbest management.
439 **	file:	the file where it was created.
440 **	size:	the true byte count of the block
441 **	seg_:	should be the same as the previous seg_.
442 **		This allows the function vmregion() to work.
443 **	magi:	magic bytes to detect overwrites.
444 **	data:	the actual data block.
445 **	magi:	more magic bytes.
446 **	line:	the line number in the file where it was created.
447 ** So for each allocated block, we'll need 3 extra Head_t.
448 */
449 
450 /* convenient macros for accessing the above fields */
451 #define DB_HEAD		(2*sizeof(Head_t))
452 #define DB_TAIL		(2*sizeof(Head_t))
453 #define DB_EXTRA	(DB_HEAD+DB_TAIL)
454 #define DBBLOCK(d)	((Block_t*)((Vmuchar_t*)(d) - 3*sizeof(Head_t)) )
455 #define DBBSIZE(d)	(SIZE(DBBLOCK(d)) & ~BITS)
456 #define DBSEG(d)	(((Head_t*)((Vmuchar_t*)(d) - sizeof(Head_t)))->head.seg.seg )
457 #define DBSIZE(d)	(((Head_t*)((Vmuchar_t*)(d) - 2*sizeof(Head_t)))->head.size.size )
458 #define DBFILE(d)	(((Head_t*)((Vmuchar_t*)(d) - 2*sizeof(Head_t)))->head.seg.file )
459 #define DBLN(d)		(((Head_t*)((Vmuchar_t*)DBBLOCK(d)+DBBSIZE(d)))->head.size.line )
460 #define DBLINE(d)	(DBLN(d) < 0 ? -DBLN(d) : DBLN(d))
461 
462 /* forward/backward translation for addresses between Vmbest and Vmdebug */
463 #define DB2BEST(d)	((Vmuchar_t*)(d) - 2*sizeof(Head_t))
464 #define DB2DEBUG(b)	((Vmuchar_t*)(b) + 2*sizeof(Head_t))
465 
466 /* set file and line number, note that DBLN > 0 so that DBISBAD will work  */
467 #define DBSETFL(d,f,l)	(DBFILE(d) = (f), DBLN(d) = (f) ? (l) : 1)
468 
469 /* set and test the state of known to be corrupted */
470 #define DBSETBAD(d)	(DBLN(d) > 0 ? (DBLN(d) = -DBLN(d)) : -1)
471 #define DBISBAD(d)	(DBLN(d) <= 0)
472 
473 #define DB_MAGIC	0255		/* 10101101	*/
474 
475 /* compute the bounds of the magic areas */
476 #define DBHEAD(d,begp,endp) \
477 		(((begp) = (Vmuchar_t*)(&DBSEG(d)) + sizeof(Seg_t*)), ((endp) = (d)) )
478 #define DBTAIL(d,begp,endp) \
479 		(((begp) = (Vmuchar_t*)(d)+DBSIZE(d)), ((endp) = (Vmuchar_t*)(&DBLN(d))) )
480 
481 /* external symbols for internal use by vmalloc */
482 typedef Block_t*	(*Vmsearch_f)_ARG_((Vmdata_t*, size_t, Block_t*));
483 typedef struct _vmextern_
484 {	Block_t*	(*vm_extend)_ARG_((Vmalloc_t*, size_t, Vmsearch_f ));
485 	ssize_t		(*vm_truncate)_ARG_((Vmalloc_t*, Seg_t*, size_t, int));
486 	size_t		vm_pagesize;
487 	char*		(*vm_strcpy)_ARG_((char*, const char*, int));
488 	char*		(*vm_itoa)_ARG_((Vmulong_t, int));
489 	void		(*vm_trace)_ARG_((Vmalloc_t*,
490 					  Vmuchar_t*, Vmuchar_t*, size_t, size_t));
491 	void		(*vm_pfclose)_ARG_((Vmalloc_t*));
492 	int		vm_assert;
493 	int		vm_options;
494 } Vmextern_t;
495 
496 #define _Vmextend	(_Vmextern.vm_extend)
497 #define _Vmtruncate	(_Vmextern.vm_truncate)
498 #define _Vmpagesize	(_Vmextern.vm_pagesize)
499 #define _Vmstrcpy	(_Vmextern.vm_strcpy)
500 #define _Vmitoa		(_Vmextern.vm_itoa)
501 #define _Vmtrace	(_Vmextern.vm_trace)
502 #define _Vmpfclose	(_Vmextern.vm_pfclose)
503 #define _Vmassert	(_Vmextern.vm_assert)
504 #define _Vmoptions	(_Vmextern.vm_options)
505 
506 #define VMOPTIONS()	do { if (!_Vmoptions) { _vmoptions(); } } while (0)
507 
508 extern void		_vmoptions _ARG_((void));
509 extern int		_vmbestcheck _ARG_((Vmdata_t*, Block_t*));
510 
511 _BEGIN_EXTERNS_
512 
513 extern Vmextern_t	_Vmextern;
514 
515 #if _PACKAGE_ast
516 
517 #if _npt_getpagesize
518 extern int		getpagesize _ARG_((void));
519 #endif
520 #if _npt_sbrk
521 extern int		brk _ARG_(( void* ));
522 extern Void_t*		sbrk _ARG_(( ssize_t ));
523 #endif
524 
525 #else
526 
527 #if _hdr_unistd
528 #include	<unistd.h>
529 #else
530 extern void		abort _ARG_(( void ));
531 extern ssize_t		write _ARG_(( int, const void*, size_t ));
532 extern int		getpagesize _ARG_((void));
533 extern Void_t*		sbrk _ARG_((ssize_t));
534 #endif
535 
536 #if !__STDC__ && !_hdr_stdlib
537 extern size_t		strlen _ARG_(( const char* ));
538 extern char*		strcpy _ARG_(( char*, const char* ));
539 extern int		strcmp _ARG_(( const char*, const char* ));
540 extern int		atexit _ARG_(( void(*)(void) ));
541 extern char*		getenv _ARG_(( const char* ));
542 extern Void_t*		memcpy _ARG_(( Void_t*, const Void_t*, size_t ));
543 extern Void_t*		memset _ARG_(( Void_t*, int, size_t ));
544 #else
545 #include	<stdlib.h>
546 #include	<string.h>
547 #endif
548 
549 /* for vmexit.c */
550 extern int		onexit _ARG_(( void(*)(void) ));
551 extern void		_exit _ARG_(( int ));
552 extern void		_cleanup _ARG_(( void ));
553 
554 #endif /*_PACKAGE_ast*/
555 
556 _END_EXTERNS_
557 
558 #if _UWIN
559 #define abort()		(DebugBreak(),abort())
560 #endif
561 
562 #endif /* _VMHDR_H */
563