1 | /* Copyright (C) 2013-2024 Free Software Foundation, Inc. |
2 | This file is part of the GNU C Library. |
3 | |
4 | The GNU C Library is free software; you can redistribute it and/or |
5 | modify it under the terms of the GNU Lesser General Public |
6 | License as published by the Free Software Foundation; either |
7 | version 2.1 of the License, or (at your option) any later version. |
8 | |
9 | The GNU C Library is distributed in the hope that it will be useful, |
10 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
12 | Lesser General Public License for more details. |
13 | |
14 | You should have received a copy of the GNU Lesser General Public |
15 | License along with the GNU C Library; if not, see |
16 | <https://www.gnu.org/licenses/>. */ |
17 | |
18 | #include <errno.h> |
19 | #include <malloc.h> |
20 | #include <stdint.h> |
21 | #include <stdio.h> |
22 | #include <string.h> |
23 | #include <libc-diag.h> |
24 | #include <support/check.h> |
25 | |
26 | static int |
27 | do_test (void) |
28 | { |
29 | void *p; |
30 | unsigned char *c; |
31 | int save, i, ok; |
32 | |
33 | errno = 0; |
34 | |
35 | /* realloc (NULL, ...) behaves similarly to malloc (C89). */ |
36 | DIAG_PUSH_NEEDS_COMMENT; |
37 | #if __GNUC_PREREQ (7, 0) |
38 | /* GCC 7 warns about too-large allocations; here we want to test |
39 | that they fail. */ |
40 | DIAG_IGNORE_NEEDS_COMMENT (7, "-Walloc-size-larger-than=" ); |
41 | #endif |
42 | p = realloc (NULL, size: -1); |
43 | DIAG_POP_NEEDS_COMMENT; |
44 | save = errno; |
45 | |
46 | if (p != NULL) |
47 | FAIL_EXIT1 ("realloc (NULL, -1) succeeded." ); |
48 | |
49 | /* errno should be set to ENOMEM on failure (POSIX). */ |
50 | if (p == NULL && save != ENOMEM) |
51 | FAIL_EXIT1 ("errno is not set correctly" ); |
52 | |
53 | errno = 0; |
54 | |
55 | /* realloc (NULL, ...) behaves similarly to malloc (C89). */ |
56 | p = realloc (NULL, size: 10); |
57 | save = errno; |
58 | |
59 | if (p == NULL) |
60 | FAIL_EXIT1 ("realloc (NULL, 10) failed." ); |
61 | |
62 | free (ptr: p); |
63 | |
64 | p = calloc (nmemb: 20, size: 1); |
65 | if (p == NULL) |
66 | FAIL_EXIT1 ("calloc (20, 1) failed." ); |
67 | |
68 | /* Check increasing size preserves contents (C89). */ |
69 | p = realloc (ptr: p, size: 200); |
70 | if (p == NULL) |
71 | FAIL_EXIT1 ("realloc (p, 200) failed." ); |
72 | |
73 | c = p; |
74 | ok = 1; |
75 | |
76 | for (i = 0; i < 20; i++) |
77 | { |
78 | if (c[i] != 0) |
79 | ok = 0; |
80 | } |
81 | |
82 | if (ok == 0) |
83 | FAIL_EXIT1 ("first 20 bytes were not cleared" ); |
84 | |
85 | free (ptr: p); |
86 | |
87 | p = realloc (NULL, size: 100); |
88 | if (p == NULL) |
89 | FAIL_EXIT1 ("realloc (NULL, 100) failed." ); |
90 | |
91 | memset (p, 0xff, 100); |
92 | |
93 | /* Check decreasing size preserves contents (C89). */ |
94 | p = realloc (ptr: p, size: 16); |
95 | if (p == NULL) |
96 | FAIL_EXIT1 ("realloc (p, 16) failed." ); |
97 | |
98 | c = p; |
99 | ok = 1; |
100 | |
101 | for (i = 0; i < 16; i++) |
102 | { |
103 | if (c[i] != 0xff) |
104 | ok = 0; |
105 | } |
106 | |
107 | if (ok == 0) |
108 | FAIL_EXIT1 ("first 16 bytes were not correct" ); |
109 | |
110 | /* Check failed realloc leaves original untouched (C89). */ |
111 | DIAG_PUSH_NEEDS_COMMENT; |
112 | #if __GNUC_PREREQ (7, 0) |
113 | /* GCC 7 warns about too-large allocations; here we want to test |
114 | that they fail. */ |
115 | DIAG_IGNORE_NEEDS_COMMENT (7, "-Walloc-size-larger-than=" ); |
116 | #endif |
117 | c = realloc (ptr: p, size: -1); |
118 | DIAG_POP_NEEDS_COMMENT; |
119 | if (c != NULL) |
120 | FAIL_EXIT1 ("realloc (p, -1) succeeded." ); |
121 | |
122 | c = p; |
123 | ok = 1; |
124 | |
125 | for (i = 0; i < 16; i++) |
126 | { |
127 | if (c[i] != 0xff) |
128 | ok = 0; |
129 | } |
130 | |
131 | if (ok == 0) |
132 | FAIL_EXIT1 ("first 16 bytes were not correct after failed realloc" ); |
133 | |
134 | /* realloc (p, 0) frees p (C89) and returns NULL (glibc). */ |
135 | p = realloc (ptr: p, size: 0); |
136 | if (p != NULL) |
137 | FAIL_EXIT1 ("realloc (p, 0) returned non-NULL." ); |
138 | |
139 | /* realloc (NULL, 0) acts like malloc (0) (glibc). */ |
140 | p = realloc (NULL, size: 0); |
141 | if (p == NULL) |
142 | FAIL_EXIT1 ("realloc (NULL, 0) returned NULL." ); |
143 | |
144 | free (ptr: p); |
145 | |
146 | /* Smoke test to make sure that allocations do not move if they have enough |
147 | space to expand in the chunk. */ |
148 | for (size_t sz = 3; sz < 256 * 1024; sz += 2048) |
149 | { |
150 | p = realloc (NULL, size: sz); |
151 | if (p == NULL) |
152 | FAIL_EXIT1 ("realloc (NULL, %zu) returned NULL." , sz); |
153 | size_t newsz = malloc_usable_size (ptr: p); |
154 | printf (format: "size: %zu, usable size: %zu, extra: %zu\n" , |
155 | sz, newsz, newsz - sz); |
156 | uintptr_t oldp = (uintptr_t) p; |
157 | void *new_p = realloc (ptr: p, size: newsz); |
158 | if ((uintptr_t) new_p != oldp) |
159 | FAIL_EXIT1 ("Expanding (%zu bytes) to usable size (%zu) moved block" , |
160 | sz, newsz); |
161 | free (ptr: new_p); |
162 | |
163 | /* We encountered a large enough extra size at least once. */ |
164 | if (newsz - sz > 1024) |
165 | break; |
166 | } |
167 | |
168 | return 0; |
169 | } |
170 | |
171 | #define TEST_FUNCTION do_test () |
172 | #include "../test-skeleton.c" |
173 | |