Coverage Report

Created: 2024-05-21 06:29

/src/binutils-gdb/libiberty/objalloc.c
Line
Count
Source (jump to first uncovered line)
1
/* objalloc.c -- routines to allocate memory for objects
2
   Copyright (C) 1997-2024 Free Software Foundation, Inc.
3
   Written by Ian Lance Taylor, Cygnus Solutions.
4
5
This program is free software; you can redistribute it and/or modify it
6
under the terms of the GNU General Public License as published by the
7
Free Software Foundation; either version 2, or (at your option) any
8
later version.
9
10
This program is distributed in the hope that it will be useful,
11
but WITHOUT ANY WARRANTY; without even the implied warranty of
12
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
GNU General Public License for more details.
14
15
You should have received a copy of the GNU General Public License
16
along with this program; if not, write to the Free Software
17
Foundation, 51 Franklin Street - Fifth Floor,
18
Boston, MA 02110-1301, USA.  */
19
20
#include "config.h"
21
#include "ansidecl.h"
22
23
#include "objalloc.h"
24
25
/* Get a definition for NULL.  */
26
#include <stdio.h>
27
28
#if VMS
29
#include <stdlib.h>
30
#include <unixlib.h>
31
#else
32
33
/* Get a definition for size_t.  */
34
#include <stddef.h>
35
36
#ifdef HAVE_STDLIB_H
37
#include <stdlib.h>
38
#else
39
/* For systems with larger pointers than ints, this must be declared.  */
40
extern void *malloc (size_t);
41
extern void free (void *);
42
#endif
43
44
#endif
45
46
/* These routines allocate space for an object.  Freeing allocated
47
   space may or may not free all more recently allocated space.
48
49
   We handle large and small allocation requests differently.  If we
50
   don't have enough space in the current block, and the allocation
51
   request is for more than 512 bytes, we simply pass it through to
52
   malloc.  */
53
54
/* The objalloc structure is defined in objalloc.h.  */
55
56
/* This structure appears at the start of each chunk.  */
57
58
struct objalloc_chunk
59
{
60
  /* Next chunk.  */
61
  struct objalloc_chunk *next;
62
  /* If this chunk contains large objects, this is the value of
63
     current_ptr when this chunk was allocated.  If this chunk
64
     contains small objects, this is NULL.  */
65
  char *current_ptr;
66
};
67
68
/* The aligned size of objalloc_chunk.  */
69
70
#define CHUNK_HEADER_SIZE         \
71
224M
  ((sizeof (struct objalloc_chunk) + OBJALLOC_ALIGN - 1) \
72
224M
   &~ (OBJALLOC_ALIGN - 1))
73
74
/* We ask for this much memory each time we create a chunk which is to
75
   hold small objects.  */
76
77
1.13G
#define CHUNK_SIZE (4096 - 32)
78
79
/* A request for this amount or more is just passed through to malloc.  */
80
81
58.7M
#define BIG_REQUEST (512)
82
83
/* Create an objalloc structure.  */
84
85
struct objalloc *
86
objalloc_create (void)
87
6.71M
{
88
6.71M
  struct objalloc *ret;
89
6.71M
  struct objalloc_chunk *chunk;
90
91
6.71M
  ret = (struct objalloc *) malloc (sizeof *ret);
92
6.71M
  if (ret == NULL)
93
0
    return NULL;
94
95
6.71M
  ret->chunks = (void *) malloc (CHUNK_SIZE);
96
6.71M
  if (ret->chunks == NULL)
97
0
    {
98
0
      free (ret);
99
0
      return NULL;
100
0
    }
101
102
6.71M
  chunk = (struct objalloc_chunk *) ret->chunks;
103
6.71M
  chunk->next = NULL;
104
6.71M
  chunk->current_ptr = NULL;
105
106
6.71M
  ret->current_ptr = (char *) chunk + CHUNK_HEADER_SIZE;
107
6.71M
  ret->current_space = CHUNK_SIZE - CHUNK_HEADER_SIZE;
108
109
6.71M
  return ret;
110
6.71M
}
111
112
/* Allocate space from an objalloc structure.  */
113
114
void *
115
_objalloc_alloc (struct objalloc *o, unsigned long original_len)
116
58.7M
{
117
58.7M
  unsigned long len = original_len;
118
119
  /* We avoid confusion from zero sized objects by always allocating
120
     at least 1 byte.  */
121
58.7M
  if (len == 0)
122
0
    len = 1;
123
124
58.7M
  len = (len + OBJALLOC_ALIGN - 1) &~ (OBJALLOC_ALIGN - 1);
125
126
  /* Check for overflow in the alignment operation above and the
127
     malloc argument below. */
128
58.7M
  if (len + CHUNK_HEADER_SIZE < original_len)
129
0
    return NULL;
130
131
58.7M
  if (len <= o->current_space)
132
0
    {
133
0
      o->current_ptr += len;
134
0
      o->current_space -= len;
135
0
      return (void *) (o->current_ptr - len);
136
0
    }
137
138
58.7M
  if (len >= BIG_REQUEST)
139
34.2M
    {
140
34.2M
      char *ret;
141
34.2M
      struct objalloc_chunk *chunk;
142
143
34.2M
      ret = (char *) malloc (CHUNK_HEADER_SIZE + len);
144
34.2M
      if (ret == NULL)
145
0
  return NULL;
146
147
34.2M
      chunk = (struct objalloc_chunk *) ret;
148
34.2M
      chunk->next = (struct objalloc_chunk *) o->chunks;
149
34.2M
      chunk->current_ptr = o->current_ptr;
150
151
34.2M
      o->chunks = (void *) chunk;
152
153
34.2M
      return (void *) (ret + CHUNK_HEADER_SIZE);
154
34.2M
    }
155
24.4M
  else
156
24.4M
    {
157
24.4M
      struct objalloc_chunk *chunk;
158
159
24.4M
      chunk = (struct objalloc_chunk *) malloc (CHUNK_SIZE);
160
24.4M
      if (chunk == NULL)
161
0
  return NULL;
162
24.4M
      chunk->next = (struct objalloc_chunk *) o->chunks;
163
24.4M
      chunk->current_ptr = NULL;
164
165
24.4M
      o->current_ptr = (char *) chunk + CHUNK_HEADER_SIZE;
166
24.4M
      o->current_space = CHUNK_SIZE - CHUNK_HEADER_SIZE;
167
168
24.4M
      o->chunks = (void *) chunk;
169
170
24.4M
      return objalloc_alloc (o, len);
171
24.4M
    }
172
58.7M
}
173
174
/* Free an entire objalloc structure.  */
175
176
void
177
objalloc_free (struct objalloc *o)
178
6.71M
{
179
6.71M
  struct objalloc_chunk *l;
180
181
6.71M
  l = (struct objalloc_chunk *) o->chunks;
182
52.6M
  while (l != NULL)
183
45.9M
    {
184
45.9M
      struct objalloc_chunk *next;
185
186
45.9M
      next = l->next;
187
45.9M
      free (l);
188
45.9M
      l = next;
189
45.9M
    }
190
191
6.71M
  free (o);
192
6.71M
}
193
194
/* Free a block from an objalloc structure.  This also frees all more
195
   recently allocated blocks.  */
196
197
void
198
objalloc_free_block (struct objalloc *o, void *block)
199
537M
{
200
537M
  struct objalloc_chunk *p, *small;
201
537M
  char *b = (char *) block;
202
203
  /* First set P to the chunk which contains the block we are freeing,
204
     and set Q to the last small object chunk we see before P.  */
205
537M
  small = NULL;
206
576M
  for (p = (struct objalloc_chunk *) o->chunks; p != NULL; p = p->next)
207
576M
    {
208
576M
      if (p->current_ptr == NULL)
209
541M
  {
210
541M
    if (b > (char *) p && b < (char *) p + CHUNK_SIZE)
211
536M
      break;
212
4.72M
    small = p;
213
4.72M
  }
214
34.4M
      else
215
34.4M
  {
216
34.4M
    if (b == (char *) p + CHUNK_HEADER_SIZE)
217
20.8k
      break;
218
34.4M
  }
219
576M
    }
220
221
  /* If we can't find the chunk, the caller has made a mistake.  */
222
537M
  if (p == NULL)
223
0
    abort ();
224
225
537M
  if (p->current_ptr == NULL)
226
536M
    {
227
536M
      struct objalloc_chunk *q;
228
536M
      struct objalloc_chunk *first;
229
230
      /* The block is in a chunk containing small objects.  We can
231
   free every chunk through SMALL, because they have certainly
232
   been allocated more recently.  After SMALL, we will not see
233
   any chunks containing small objects; we can free any big
234
   chunk if the current_ptr is greater than or equal to B.  We
235
   can then reset the new current_ptr to B.  */
236
237
536M
      first = NULL;
238
536M
      q = (struct objalloc_chunk *) o->chunks;
239
576M
      while (q != p)
240
39.1M
  {
241
39.1M
    struct objalloc_chunk *next;
242
243
39.1M
    next = q->next;
244
39.1M
    if (small != NULL)
245
10.7M
      {
246
10.7M
        if (small == q)
247
474k
    small = NULL;
248
10.7M
        free (q);
249
10.7M
      }
250
28.3M
    else if (q->current_ptr > b)
251
8.62M
      free (q);
252
19.6M
    else if (first == NULL)
253
16.6M
      first = q;
254
255
39.1M
    q = next;
256
39.1M
  }
257
258
536M
      if (first == NULL)
259
520M
  first = p;
260
536M
      o->chunks = (void *) first;
261
262
      /* Now start allocating from this small block again.  */
263
536M
      o->current_ptr = b;
264
536M
      o->current_space = ((char *) p + CHUNK_SIZE) - b;
265
536M
    }
266
20.8k
  else
267
20.8k
    {
268
20.8k
      struct objalloc_chunk *q;
269
20.8k
      char *current_ptr;
270
271
      /* This block is in a large chunk by itself.  We can free
272
         everything on the list up to and including this block.  We
273
         then start allocating from the next chunk containing small
274
         objects, setting current_ptr from the value stored with the
275
         large chunk we are freeing.  */
276
277
20.8k
      current_ptr = p->current_ptr;
278
20.8k
      p = p->next;
279
280
20.8k
      q = (struct objalloc_chunk *) o->chunks;
281
75.7k
      while (q != p)
282
54.8k
  {
283
54.8k
    struct objalloc_chunk *next;
284
285
54.8k
    next = q->next;
286
54.8k
    free (q);
287
54.8k
    q = next;
288
54.8k
  }
289
290
20.8k
      o->chunks = (void *) p;
291
292
39.4k
      while (p->current_ptr != NULL)
293
18.5k
  p = p->next;
294
295
20.8k
      o->current_ptr = current_ptr;
296
20.8k
      o->current_space = ((char *) p + CHUNK_SIZE) - current_ptr;
297
20.8k
    }
298
537M
}