blob: 34458c0620760f2944662c69e9b9c9c10c119c24 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
|
/* malloc.h - declarations for the allocator.
Copyright (c) 1989, 1993 Michael J. Haertel
You may redistribute this library under the terms of the
GNU Library General Public License (version 2 or any later
version) as published by the Free Software Foundation.
THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT ANY EXPRESS OR IMPLIED
WARRANTY. IN PARTICULAR, THE AUTHOR MAKES NO REPRESENTATION OR
WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY OF THIS
SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE. */
#include <sys/cdefs.h>
/* Underlying allocation function; successive calls should return
contiguous pieces of memory. */
extern void *(*__morecore)(long);
/* Default value of previous. */
extern void *__default_morecore_init(long);
extern void *__default_morecore(long);
/* The allocator divides the heap into blocks of fixed size; large
requests receive one or more whole blocks, and small requests
receive a fragment of a block. Fragment sizes are powers of two,
and all fragments of a block are the same size. When all the
fragments in a block have been freed, the block itself is freed.
WARNING: BLOCKSIZE must be set greater than or equal to the
machine's page size for valloc() to work correctly. The default
definition here is 4096 bytes. */
#define INT_BIT (CHAR_BIT * sizeof (int))
#define BLOCKLOG (INT_BIT > 16 ? 12 : 9)
#define BLOCKSIZE (1 << BLOCKLOG)
#define BLOCKIFY(SIZE) (((SIZE) + BLOCKSIZE - 1) / BLOCKSIZE)
/* Determine the amount of memory spanned by the initial heap table
(not an absolute limit). */
#define HEAP (INT_BIT > 16 ? 4194304 : 65536)
/* Number of contiguous free blocks allowed to build up at the end of
memory before they will be returned to the system. */
#define FINAL_FREE_BLOCKS 8
/* Data structure giving per-block information. */
union info {
struct {
int type; /* Zero for a large block, or positive
giving the logarithm to the base two
of the fragment size. */
union {
struct {
int nfree; /* Free fragments in a fragmented block. */
int first; /* First free fragment of the block. */
} frag;
int size; /* Size (in blocks) of a large cluster. */
} info;
} busy;
struct {
int size; /* Size (in blocks) of a free cluster. */
int next; /* Index of next free cluster. */
int prev; /* Index of previous free cluster. */
} free;
};
/* Pointer to first block of the heap. */
extern char *_heapbase;
/* Table indexed by block number giving per-block information. */
extern union info *_heapinfo;
/* Address to block number and vice versa. */
#define BLOCK(A) (((char *) (A) - _heapbase) / BLOCKSIZE + 1)
#define ADDRESS(B) ((void *) (((B) - 1) * BLOCKSIZE + _heapbase))
/* Current search index for the heap table. */
extern int _heapindex;
/* Limit of valid info table indices. */
extern int _heaplimit;
/* Doubly linked lists of free fragments. */
struct list {
struct list *next;
struct list *prev;
};
/* Count of blocks for each fragment size. */
extern int _fragblocks[];
/* Free list headers for each fragment size. */
extern struct list _fraghead[];
/* List of blocks allocated with `memalign' (or `valloc'). */
struct alignlist
{
struct alignlist *next;
__ptr_t aligned; /* The address that memaligned returned. */
__ptr_t exact; /* The address that malloc returned. */
};
extern struct alignlist *_aligned_blocks;
extern void _free_internal __P ((__ptr_t __ptr));
extern void free (void *);
extern void * malloc (size_t);
extern void * calloc (size_t, size_t);
extern void * valloc (size_t);
extern void * memalign (size_t, size_t);
extern void * realloc (void *, size_t);
|
