]>
Commit | Line | Data |
---|---|---|
1eee94d3 GM |
1 | /* do not edit automatically generated by mc from SysStorage. */ |
2 | /* SysStorage.mod provides dynamic allocation for the system components. | |
3 | ||
83ffe9cd | 4 | Copyright (C) 2001-2023 Free Software Foundation, Inc. |
1eee94d3 GM |
5 | Contributed by Gaius Mulley <gaius.mulley@southwales.ac.uk>. |
6 | ||
7 | This file is part of GNU Modula-2. | |
8 | ||
9 | GNU Modula-2 is free software; you can redistribute it and/or modify | |
10 | it under the terms of the GNU General Public License as published by | |
11 | the Free Software Foundation; either version 3, or (at your option) | |
12 | any later version. | |
13 | ||
14 | GNU Modula-2 is distributed in the hope that it will be useful, but | |
15 | WITHOUT ANY WARRANTY; without even the implied warranty of | |
16 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
17 | General Public License for more details. | |
18 | ||
19 | Under Section 7 of GPL version 3, you are granted additional | |
20 | permissions described in the GCC Runtime Library Exception, version | |
21 | 3.1, as published by the Free Software Foundation. | |
22 | ||
23 | You should have received a copy of the GNU General Public License and | |
24 | a copy of the GCC Runtime Library Exception along with this program; | |
25 | see the files COPYING3 and COPYING.RUNTIME respectively. If not, see | |
26 | <http://www.gnu.org/licenses/>. */ | |
27 | ||
28 | #include "config.h" | |
29 | #include "system.h" | |
30 | # if !defined (PROC_D) | |
31 | # define PROC_D | |
32 | typedef void (*PROC_t) (void); | |
33 | typedef struct { PROC_t proc; } PROC; | |
34 | # endif | |
35 | ||
36 | # if !defined (TRUE) | |
37 | # define TRUE (1==1) | |
38 | # endif | |
39 | ||
40 | # if !defined (FALSE) | |
41 | # define FALSE (1==0) | |
42 | # endif | |
43 | ||
44 | #if defined(__cplusplus) | |
45 | # undef NULL | |
46 | # define NULL 0 | |
47 | #endif | |
48 | #define _SysStorage_H | |
49 | #define _SysStorage_C | |
50 | ||
51 | # include "Glibc.h" | |
52 | # include "GDebug.h" | |
53 | # include "GSYSTEM.h" | |
54 | ||
55 | # define enableDeallocation TRUE | |
56 | # define enableZero FALSE | |
57 | # define enableTrace FALSE | |
58 | static unsigned int callno; | |
59 | static unsigned int zero; | |
60 | static unsigned int trace; | |
61 | extern "C" void SysStorage_ALLOCATE (void * *a, unsigned int size); | |
62 | extern "C" void SysStorage_DEALLOCATE (void * *a, unsigned int size); | |
63 | ||
64 | /* | |
65 | REALLOCATE - attempts to reallocate storage. The address, | |
66 | a, should either be NIL in which case ALLOCATE | |
67 | is called, or alternatively it should have already | |
68 | been initialized by ALLOCATE. The allocated storage | |
69 | is resized accordingly. | |
70 | */ | |
71 | ||
72 | extern "C" void SysStorage_REALLOCATE (void * *a, unsigned int size); | |
73 | ||
74 | /* | |
75 | REALLOCATE - attempts to reallocate storage. The address, | |
76 | a, should either be NIL in which case ALLOCATE | |
77 | is called, or alternatively it should have already | |
78 | been initialized by ALLOCATE. The allocated storage | |
79 | is resized accordingly. | |
80 | */ | |
81 | ||
82 | extern "C" unsigned int SysStorage_Available (unsigned int size); | |
83 | ||
84 | /* | |
85 | Init - initializes the heap. This does nothing on a GNU/Linux system. | |
86 | But it remains here since it might be used in an embedded system. | |
87 | */ | |
88 | ||
89 | extern "C" void SysStorage_Init (void); | |
90 | ||
91 | extern "C" void SysStorage_ALLOCATE (void * *a, unsigned int size) | |
92 | { | |
93 | (*a) = libc_malloc (static_cast<size_t> (size)); | |
94 | if ((*a) == NULL) | |
95 | { | |
96 | Debug_Halt ((const char *) "out of memory error", 19, 50, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/SysStorage.mod", 58); | |
97 | } | |
98 | if (enableTrace && trace) | |
99 | { | |
100 | libc_printf ((const char *) "<DEBUG-CALL> %d SysStorage.ALLOCATE (0x%x, %d bytes)\\n", 54, callno, (*a), size); | |
101 | libc_printf ((const char *) "<MEM-ALLOC> %ld %d\\n", 20, (*a), size); | |
102 | callno += 1; | |
103 | } | |
104 | } | |
105 | ||
106 | extern "C" void SysStorage_DEALLOCATE (void * *a, unsigned int size) | |
107 | { | |
108 | if (enableTrace && trace) | |
109 | { | |
110 | libc_printf ((const char *) "<DEBUG-CALL> %d SysStorage.DEALLOCATE (0x%x, %d bytes)\\n", 56, callno, (*a), size); | |
111 | callno += 1; | |
112 | } | |
113 | if (enableZero && zero) | |
114 | { | |
115 | if (enableTrace && trace) | |
116 | { | |
117 | libc_printf ((const char *) " memset (0x%x, 0, %d bytes)\\n", 30, (*a), size); | |
118 | } | |
119 | if ((libc_memset ((*a), 0, static_cast<size_t> (size))) != (*a)) | |
120 | { | |
121 | Debug_Halt ((const char *) "memset should have returned the first parameter", 47, 76, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/SysStorage.mod", 58); | |
122 | } | |
123 | } | |
124 | if (enableDeallocation) | |
125 | { | |
126 | if (enableTrace && trace) | |
127 | { | |
128 | libc_printf ((const char *) " free (0x%x) %d bytes\\n", 26, (*a), size); | |
129 | libc_printf ((const char *) "<MEM-FREE> %ld %d\\n", 19, (*a), size); | |
130 | } | |
131 | libc_free ((*a)); | |
132 | } | |
133 | (*a) = NULL; | |
134 | } | |
135 | ||
136 | ||
137 | /* | |
138 | REALLOCATE - attempts to reallocate storage. The address, | |
139 | a, should either be NIL in which case ALLOCATE | |
140 | is called, or alternatively it should have already | |
141 | been initialized by ALLOCATE. The allocated storage | |
142 | is resized accordingly. | |
143 | */ | |
144 | ||
145 | extern "C" void SysStorage_REALLOCATE (void * *a, unsigned int size) | |
146 | { | |
147 | if ((*a) == NULL) | |
148 | { | |
149 | SysStorage_ALLOCATE (a, size); | |
150 | } | |
151 | else | |
152 | { | |
153 | if (enableTrace && trace) | |
154 | { | |
155 | libc_printf ((const char *) "<DEBUG-CALL> %d SysStorage.REALLOCATE (0x%x, %d bytes)\\n", 56, callno, (*a), size); | |
156 | callno += 1; | |
157 | } | |
158 | if (enableTrace && trace) | |
159 | { | |
160 | libc_printf ((const char *) " realloc (0x%x, %d bytes) -> ", 32, (*a), size); | |
161 | libc_printf ((const char *) "<MEM-FREE> %ld %d\\n", 19, (*a), size); | |
162 | } | |
163 | (*a) = libc_realloc ((*a), static_cast<size_t> (size)); | |
164 | if ((*a) == NULL) | |
165 | { | |
166 | Debug_Halt ((const char *) "out of memory error", 19, 119, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/SysStorage.mod", 58); | |
167 | } | |
168 | if (enableTrace && trace) | |
169 | { | |
170 | libc_printf ((const char *) "<MEM-ALLOC> %ld %d\\n", 20, (*a), size); | |
171 | libc_printf ((const char *) " 0x%x %d bytes\\n", 18, (*a), size); | |
172 | } | |
173 | } | |
174 | } | |
175 | ||
176 | ||
177 | /* | |
178 | REALLOCATE - attempts to reallocate storage. The address, | |
179 | a, should either be NIL in which case ALLOCATE | |
180 | is called, or alternatively it should have already | |
181 | been initialized by ALLOCATE. The allocated storage | |
182 | is resized accordingly. | |
183 | */ | |
184 | ||
185 | extern "C" unsigned int SysStorage_Available (unsigned int size) | |
186 | { | |
187 | void * a; | |
188 | ||
189 | if (enableTrace && trace) | |
190 | { | |
191 | libc_printf ((const char *) "<DEBUG-CALL> %d SysStorage.Available (%d bytes)\\n", 49, callno, size); | |
192 | callno += 1; | |
193 | } | |
194 | a = libc_malloc (static_cast<size_t> (size)); | |
195 | if (a == NULL) | |
196 | { | |
197 | if (enableTrace && trace) | |
198 | { | |
199 | libc_printf ((const char *) " no\\n", 7, size); | |
200 | } | |
201 | return FALSE; | |
202 | } | |
203 | else | |
204 | { | |
205 | if (enableTrace && trace) | |
206 | { | |
207 | libc_printf ((const char *) " yes\\n", 8, size); | |
208 | } | |
209 | libc_free (a); | |
210 | return TRUE; | |
211 | } | |
212 | /* static analysis guarentees a RETURN statement will be used before here. */ | |
213 | __builtin_unreachable (); | |
214 | } | |
215 | ||
216 | ||
217 | /* | |
218 | Init - initializes the heap. This does nothing on a GNU/Linux system. | |
219 | But it remains here since it might be used in an embedded system. | |
220 | */ | |
221 | ||
222 | extern "C" void SysStorage_Init (void) | |
223 | { | |
224 | } | |
225 | ||
226 | extern "C" void _M2_SysStorage_init (__attribute__((unused)) int argc,__attribute__((unused)) char *argv[],__attribute__((unused)) char *envp[]) | |
227 | { | |
228 | callno = 0; | |
229 | if (enableTrace) | |
230 | { | |
231 | trace = (libc_getenv (const_cast<void*> (reinterpret_cast<const void*>("M2DEBUG_SYSSTORAGE_trace")))) != NULL; | |
232 | } | |
233 | else | |
234 | { | |
235 | trace = FALSE; | |
236 | } | |
237 | if (enableZero) | |
238 | { | |
239 | zero = (libc_getenv (const_cast<void*> (reinterpret_cast<const void*>("M2DEBUG_SYSSTORAGE_zero")))) != NULL; | |
240 | } | |
241 | else | |
242 | { | |
243 | zero = FALSE; | |
244 | } | |
245 | } | |
246 | ||
247 | extern "C" void _M2_SysStorage_finish (__attribute__((unused)) int argc,__attribute__((unused)) char *argv[],__attribute__((unused)) char *envp[]) | |
248 | { | |
249 | } |