Branch data Line data Source code
1 : : /*-------------------------------------------------------------------------
2 : : *
3 : : * fe_memutils.c
4 : : * memory management support for frontend code
5 : : *
6 : : * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
7 : : * Portions Copyright (c) 1994, Regents of the University of California
8 : : *
9 : : *
10 : : * IDENTIFICATION
11 : : * src/common/fe_memutils.c
12 : : *
13 : : *-------------------------------------------------------------------------
14 : : */
15 : :
16 : : #ifndef FRONTEND
17 : : #error "This file is not expected to be compiled for backend code"
18 : : #endif
19 : :
20 : : #include "postgres_fe.h"
21 : :
22 : : #include "common/int.h"
23 : :
24 : : pg_noreturn static pg_noinline void add_size_error(Size s1, Size s2);
25 : : pg_noreturn static pg_noinline void mul_size_error(Size s1, Size s2);
26 : :
27 : :
28 : : static inline void *
29 : 5167920 : pg_malloc_internal(size_t size, int flags)
30 : : {
31 : : void *tmp;
32 : :
33 : : /* Avoid unportable behavior of malloc(0) */
34 [ + + ]: 5167920 : if (size == 0)
35 : 3391 : size = 1;
36 : 5167920 : tmp = malloc(size);
37 [ - + ]: 5167920 : if (tmp == NULL)
38 : : {
39 [ # # ]: 0 : if ((flags & MCXT_ALLOC_NO_OOM) == 0)
40 : : {
41 : 0 : fprintf(stderr, _("out of memory\n"));
42 : 0 : exit(EXIT_FAILURE);
43 : : }
44 : 0 : return NULL;
45 : : }
46 : :
47 [ + + ]: 5167920 : if ((flags & MCXT_ALLOC_ZERO) != 0)
48 [ + - + + : 6478208 : MemSet(tmp, 0, size);
+ - + + +
+ ]
49 : 5167920 : return tmp;
50 : : }
51 : :
52 : : void *
53 : 2170821 : pg_malloc(size_t size)
54 : : {
55 : 2170821 : return pg_malloc_internal(size, 0);
56 : : }
57 : :
58 : : void *
59 : 1694859 : pg_malloc0(size_t size)
60 : : {
61 : 1694859 : return pg_malloc_internal(size, MCXT_ALLOC_ZERO);
62 : : }
63 : :
64 : : void *
65 : 247609 : pg_malloc_extended(size_t size, int flags)
66 : : {
67 : 247609 : return pg_malloc_internal(size, flags);
68 : : }
69 : :
70 : : void *
71 : 94962 : pg_realloc(void *ptr, size_t size)
72 : : {
73 : : void *tmp;
74 : :
75 : : /* Avoid unportable behavior of realloc(NULL, 0) */
76 [ + + - + ]: 94962 : if (ptr == NULL && size == 0)
77 : 0 : size = 1;
78 : 94962 : tmp = realloc(ptr, size);
79 [ - + ]: 94962 : if (!tmp)
80 : : {
81 : 0 : fprintf(stderr, _("out of memory\n"));
82 : 0 : exit(EXIT_FAILURE);
83 : : }
84 : 94962 : return tmp;
85 : : }
86 : :
87 : : /*
88 : : * "Safe" wrapper around strdup().
89 : : */
90 : : char *
91 : 8112243 : pg_strdup(const char *in)
92 : : {
93 : : char *tmp;
94 : :
95 [ - + ]: 8112243 : if (!in)
96 : : {
97 : 0 : fprintf(stderr,
98 : 0 : _("cannot duplicate null pointer (internal error)\n"));
99 : 0 : exit(EXIT_FAILURE);
100 : : }
101 : 8112243 : tmp = strdup(in);
102 [ - + ]: 8112243 : if (!tmp)
103 : : {
104 : 0 : fprintf(stderr, _("out of memory\n"));
105 : 0 : exit(EXIT_FAILURE);
106 : : }
107 : 8112243 : return tmp;
108 : : }
109 : :
110 : : void
111 : 8292970 : pg_free(void *ptr)
112 : : {
113 : 8292970 : free(ptr);
114 : 8292970 : }
115 : :
116 : : /*
117 : : * Frontend emulation of backend memory management functions. Useful for
118 : : * programs that compile backend files.
119 : : */
120 : : void *
121 : 1051017 : palloc(Size size)
122 : : {
123 : 1051017 : return pg_malloc_internal(size, 0);
124 : : }
125 : :
126 : : void *
127 : 3119 : palloc0(Size size)
128 : : {
129 : 3119 : return pg_malloc_internal(size, MCXT_ALLOC_ZERO);
130 : : }
131 : :
132 : : void *
133 : 495 : palloc_extended(Size size, int flags)
134 : : {
135 : 495 : return pg_malloc_internal(size, flags);
136 : : }
137 : :
138 : : void
139 : 2599526 : pfree(void *pointer)
140 : : {
141 : 2599526 : pg_free(pointer);
142 : 2599526 : }
143 : :
144 : : char *
145 : 1271178 : pstrdup(const char *in)
146 : : {
147 : 1271178 : return pg_strdup(in);
148 : : }
149 : :
150 : : char *
151 : 305 : pnstrdup(const char *in, Size size)
152 : : {
153 : : char *tmp;
154 : : int len;
155 : :
156 [ - + ]: 305 : if (!in)
157 : : {
158 : 0 : fprintf(stderr,
159 : 0 : _("cannot duplicate null pointer (internal error)\n"));
160 : 0 : exit(EXIT_FAILURE);
161 : : }
162 : :
163 : 305 : len = strnlen(in, size);
164 : 305 : tmp = malloc(len + 1);
165 [ - + ]: 305 : if (tmp == NULL)
166 : : {
167 : 0 : fprintf(stderr, _("out of memory\n"));
168 : 0 : exit(EXIT_FAILURE);
169 : : }
170 : :
171 : 305 : memcpy(tmp, in, len);
172 : 305 : tmp[len] = '\0';
173 : :
174 : 305 : return tmp;
175 : : }
176 : :
177 : : void *
178 : 58947 : repalloc(void *pointer, Size size)
179 : : {
180 : 58947 : return pg_realloc(pointer, size);
181 : : }
182 : :
183 : : /*
184 : : * Support for safe calculation of memory request sizes
185 : : *
186 : : * These functions perform the requested calculation, but throw error if the
187 : : * result overflows.
188 : : *
189 : : * An important property of these functions is that if an argument was a
190 : : * negative signed int before promotion (implying overflow in calculating it)
191 : : * we will detect that as an error. That happens because we reject results
192 : : * larger than SIZE_MAX / 2. In the backend we rely on later checks to do
193 : : * that, but in frontend we must do it here.
194 : : */
195 : : Size
196 : 0 : add_size(Size s1, Size s2)
197 : : {
198 : : Size result;
199 : :
200 [ # # # # : 0 : if (unlikely(pg_add_size_overflow(s1, s2, &result) ||
# # ]
201 : : result > (SIZE_MAX / 2)))
202 : 0 : add_size_error(s1, s2);
203 : 0 : return result;
204 : : }
205 : :
206 : : pg_noreturn static pg_noinline void
207 : 0 : add_size_error(Size s1, Size s2)
208 : : {
209 : 0 : fprintf(stderr, _("invalid memory allocation request size %zu + %zu\n"),
210 : : s1, s2);
211 : 0 : exit(EXIT_FAILURE);
212 : : }
213 : :
214 : : Size
215 : 0 : mul_size(Size s1, Size s2)
216 : : {
217 : : Size result;
218 : :
219 [ # # # # : 0 : if (unlikely(pg_mul_size_overflow(s1, s2, &result) ||
# # ]
220 : : result > (SIZE_MAX / 2)))
221 : 0 : mul_size_error(s1, s2);
222 : 0 : return result;
223 : : }
224 : :
225 : : pg_noreturn static pg_noinline void
226 : 0 : mul_size_error(Size s1, Size s2)
227 : : {
228 : 0 : fprintf(stderr, _("invalid memory allocation request size %zu * %zu\n"),
229 : : s1, s2);
230 : 0 : exit(EXIT_FAILURE);
231 : : }
232 : :
233 : : /*
234 : : * pg_malloc_mul
235 : : * Equivalent to pg_malloc(mul_size(s1, s2)).
236 : : */
237 : : void *
238 : 1201264 : pg_malloc_mul(Size s1, Size s2)
239 : : {
240 : : /* inline mul_size() for efficiency */
241 : : Size req;
242 : :
243 [ + - - + : 1201264 : if (unlikely(pg_mul_size_overflow(s1, s2, &req) ||
- + ]
244 : : req > (SIZE_MAX / 2)))
245 : 0 : mul_size_error(s1, s2);
246 : 1201264 : return pg_malloc(req);
247 : : }
248 : :
249 : : /*
250 : : * pg_malloc0_mul
251 : : * Equivalent to pg_malloc0(mul_size(s1, s2)).
252 : : *
253 : : * This is comparable to standard calloc's behavior.
254 : : */
255 : : void *
256 : 1567790 : pg_malloc0_mul(Size s1, Size s2)
257 : : {
258 : : /* inline mul_size() for efficiency */
259 : : Size req;
260 : :
261 [ + - - + : 1567790 : if (unlikely(pg_mul_size_overflow(s1, s2, &req) ||
- + ]
262 : : req > (SIZE_MAX / 2)))
263 : 0 : mul_size_error(s1, s2);
264 : 1567790 : return pg_malloc0(req);
265 : : }
266 : :
267 : : /*
268 : : * pg_malloc_mul_extended
269 : : * Equivalent to pg_malloc_extended(mul_size(s1, s2), flags).
270 : : */
271 : : void *
272 : 0 : pg_malloc_mul_extended(Size s1, Size s2, int flags)
273 : : {
274 : : /* inline mul_size() for efficiency */
275 : : Size req;
276 : :
277 [ # # # # : 0 : if (unlikely(pg_mul_size_overflow(s1, s2, &req) ||
# # ]
278 : : req > (SIZE_MAX / 2)))
279 : 0 : mul_size_error(s1, s2);
280 : 0 : return pg_malloc_extended(req, flags);
281 : : }
282 : :
283 : : /*
284 : : * pg_realloc_mul
285 : : * Equivalent to pg_realloc(p, mul_size(s1, s2)).
286 : : */
287 : : void *
288 : 34647 : pg_realloc_mul(void *p, Size s1, Size s2)
289 : : {
290 : : /* inline mul_size() for efficiency */
291 : : Size req;
292 : :
293 [ + - - + : 34647 : if (unlikely(pg_mul_size_overflow(s1, s2, &req) ||
- + ]
294 : : req > (SIZE_MAX / 2)))
295 : 0 : mul_size_error(s1, s2);
296 : 34647 : return pg_realloc(p, req);
297 : : }
298 : :
299 : : /*
300 : : * palloc_mul
301 : : * Equivalent to palloc(mul_size(s1, s2)).
302 : : */
303 : : void *
304 : 3806 : palloc_mul(Size s1, Size s2)
305 : : {
306 : : /* inline mul_size() for efficiency */
307 : : Size req;
308 : :
309 [ + - - + : 3806 : if (unlikely(pg_mul_size_overflow(s1, s2, &req) ||
- + ]
310 : : req > (SIZE_MAX / 2)))
311 : 0 : mul_size_error(s1, s2);
312 : 3806 : return palloc(req);
313 : : }
314 : :
315 : : /*
316 : : * palloc0_mul
317 : : * Equivalent to palloc0(mul_size(s1, s2)).
318 : : *
319 : : * This is comparable to standard calloc's behavior.
320 : : */
321 : : void *
322 : 0 : palloc0_mul(Size s1, Size s2)
323 : : {
324 : : /* inline mul_size() for efficiency */
325 : : Size req;
326 : :
327 [ # # # # : 0 : if (unlikely(pg_mul_size_overflow(s1, s2, &req) ||
# # ]
328 : : req > (SIZE_MAX / 2)))
329 : 0 : mul_size_error(s1, s2);
330 : 0 : return palloc0(req);
331 : : }
332 : :
333 : : /*
334 : : * palloc_mul_extended
335 : : * Equivalent to palloc_extended(mul_size(s1, s2), flags).
336 : : */
337 : : void *
338 : 0 : palloc_mul_extended(Size s1, Size s2, int flags)
339 : : {
340 : : /* inline mul_size() for efficiency */
341 : : Size req;
342 : :
343 [ # # # # : 0 : if (unlikely(pg_mul_size_overflow(s1, s2, &req) ||
# # ]
344 : : req > (SIZE_MAX / 2)))
345 : 0 : mul_size_error(s1, s2);
346 : 0 : return palloc_extended(req, flags);
347 : : }
348 : :
349 : : /*
350 : : * repalloc_mul
351 : : * Equivalent to repalloc(p, mul_size(s1, s2)).
352 : : */
353 : : void *
354 : 0 : repalloc_mul(void *p, Size s1, Size s2)
355 : : {
356 : : /* inline mul_size() for efficiency */
357 : : Size req;
358 : :
359 [ # # # # : 0 : if (unlikely(pg_mul_size_overflow(s1, s2, &req) ||
# # ]
360 : : req > (SIZE_MAX / 2)))
361 : 0 : mul_size_error(s1, s2);
362 : 0 : return repalloc(p, req);
363 : : }
|
