/src/testdir/build/lua-master/source/lmem.c
Line | Count | Source (jump to first uncovered line) |
1 | | /* |
2 | | ** $Id: lmem.c $ |
3 | | ** Interface to Memory Manager |
4 | | ** See Copyright Notice in lua.h |
5 | | */ |
6 | | |
7 | | #define lmem_c |
8 | | #define LUA_CORE |
9 | | |
10 | | #include "lprefix.h" |
11 | | |
12 | | |
13 | | #include <stddef.h> |
14 | | |
15 | | #include "lua.h" |
16 | | |
17 | | #include "ldebug.h" |
18 | | #include "ldo.h" |
19 | | #include "lgc.h" |
20 | | #include "lmem.h" |
21 | | #include "lobject.h" |
22 | | #include "lstate.h" |
23 | | |
24 | | |
25 | | |
26 | | /* |
27 | | ** About the realloc function: |
28 | | ** void *frealloc (void *ud, void *ptr, size_t osize, size_t nsize); |
29 | | ** ('osize' is the old size, 'nsize' is the new size) |
30 | | ** |
31 | | ** - frealloc(ud, p, x, 0) frees the block 'p' and returns NULL. |
32 | | ** Particularly, frealloc(ud, NULL, 0, 0) does nothing, |
33 | | ** which is equivalent to free(NULL) in ISO C. |
34 | | ** |
35 | | ** - frealloc(ud, NULL, x, s) creates a new block of size 's' |
36 | | ** (no matter 'x'). Returns NULL if it cannot create the new block. |
37 | | ** |
38 | | ** - otherwise, frealloc(ud, b, x, y) reallocates the block 'b' from |
39 | | ** size 'x' to size 'y'. Returns NULL if it cannot reallocate the |
40 | | ** block to the new size. |
41 | | */ |
42 | | |
43 | | |
44 | | /* |
45 | | ** Macro to call the allocation function. |
46 | | */ |
47 | 39.2k | #define callfrealloc(g,block,os,ns) ((*g->frealloc)(g->ud, block, os, ns)) |
48 | | |
49 | | |
50 | | /* |
51 | | ** When an allocation fails, it will try again after an emergency |
52 | | ** collection, except when it cannot run a collection. The GC should |
53 | | ** not be called while the state is not fully built, as the collector |
54 | | ** is not yet fully initialized. Also, it should not be called when |
55 | | ** 'gcstopem' is true, because then the interpreter is in the middle of |
56 | | ** a collection step. |
57 | | */ |
58 | 0 | #define cantryagain(g) (completestate(g) && !g->gcstopem) |
59 | | |
60 | | |
61 | | |
62 | | |
63 | | #if defined(EMERGENCYGCTESTS) |
64 | | /* |
65 | | ** First allocation will fail except when freeing a block (frees never |
66 | | ** fail) and when it cannot try again; this fail will trigger 'tryagain' |
67 | | ** and a full GC cycle at every allocation. |
68 | | */ |
69 | | static void *firsttry (global_State *g, void *block, size_t os, size_t ns) { |
70 | | if (ns > 0 && cantryagain(g)) |
71 | | return NULL; /* fail */ |
72 | | else /* normal allocation */ |
73 | | return callfrealloc(g, block, os, ns); |
74 | | } |
75 | | #else |
76 | 19.7k | #define firsttry(g,block,os,ns) callfrealloc(g, block, os, ns) |
77 | | #endif |
78 | | |
79 | | |
80 | | |
81 | | |
82 | | |
83 | | /* |
84 | | ** {================================================================== |
85 | | ** Functions to allocate/deallocate arrays for the Parser |
86 | | ** =================================================================== |
87 | | */ |
88 | | |
89 | | /* |
90 | | ** Minimum size for arrays during parsing, to avoid overhead of |
91 | | ** reallocating to size 1, then 2, and then 4. All these arrays |
92 | | ** will be reallocated to exact sizes or erased when parsing ends. |
93 | | */ |
94 | 0 | #define MINSIZEARRAY 4 |
95 | | |
96 | | |
97 | | void *luaM_growaux_ (lua_State *L, void *block, int nelems, int *psize, |
98 | 0 | int size_elems, int limit, const char *what) { |
99 | 0 | void *newblock; |
100 | 0 | int size = *psize; |
101 | 0 | if (nelems + 1 <= size) /* does one extra element still fit? */ |
102 | 0 | return block; /* nothing to be done */ |
103 | 0 | if (size >= limit / 2) { /* cannot double it? */ |
104 | 0 | if (l_unlikely(size >= limit)) /* cannot grow even a little? */ |
105 | 0 | luaG_runerror(L, "too many %s (limit is %d)", what, limit); |
106 | 0 | size = limit; /* still have at least one free place */ |
107 | 0 | } |
108 | 0 | else { |
109 | 0 | size *= 2; |
110 | 0 | if (size < MINSIZEARRAY) |
111 | 0 | size = MINSIZEARRAY; /* minimum size */ |
112 | 0 | } |
113 | 0 | lua_assert(nelems + 1 <= size && size <= limit); |
114 | | /* 'limit' ensures that multiplication will not overflow */ |
115 | 0 | newblock = luaM_saferealloc_(L, block, cast_sizet(*psize) * size_elems, |
116 | 0 | cast_sizet(size) * size_elems); |
117 | 0 | *psize = size; /* update only when everything else is OK */ |
118 | 0 | return newblock; |
119 | 0 | } |
120 | | |
121 | | |
122 | | /* |
123 | | ** In prototypes, the size of the array is also its number of |
124 | | ** elements (to save memory). So, if it cannot shrink an array |
125 | | ** to its number of elements, the only option is to raise an |
126 | | ** error. |
127 | | */ |
128 | | void *luaM_shrinkvector_ (lua_State *L, void *block, int *size, |
129 | 0 | int final_n, int size_elem) { |
130 | 0 | void *newblock; |
131 | 0 | size_t oldsize = cast_sizet((*size) * size_elem); |
132 | 0 | size_t newsize = cast_sizet(final_n * size_elem); |
133 | 0 | lua_assert(newsize <= oldsize); |
134 | 0 | newblock = luaM_saferealloc_(L, block, oldsize, newsize); |
135 | 0 | *size = final_n; |
136 | 0 | return newblock; |
137 | 0 | } |
138 | | |
139 | | /* }================================================================== */ |
140 | | |
141 | | |
142 | 0 | l_noret luaM_toobig (lua_State *L) { |
143 | 0 | luaG_runerror(L, "memory allocation error: block too big"); |
144 | 0 | } |
145 | | |
146 | | |
147 | | /* |
148 | | ** Free memory |
149 | | */ |
150 | 19.5k | void luaM_free_ (lua_State *L, void *block, size_t osize) { |
151 | 19.5k | global_State *g = G(L); |
152 | 19.5k | lua_assert((osize == 0) == (block == NULL)); |
153 | 19.5k | callfrealloc(g, block, osize, 0); |
154 | 19.5k | g->GCdebt -= osize; |
155 | 19.5k | } |
156 | | |
157 | | |
158 | | /* |
159 | | ** In case of allocation fail, this function will do an emergency |
160 | | ** collection to free some memory and then try the allocation again. |
161 | | */ |
162 | | static void *tryagain (lua_State *L, void *block, |
163 | 0 | size_t osize, size_t nsize) { |
164 | 0 | global_State *g = G(L); |
165 | 0 | if (cantryagain(g)) { |
166 | 0 | luaC_fullgc(L, 1); /* try to free some memory... */ |
167 | 0 | return callfrealloc(g, block, osize, nsize); /* try again */ |
168 | 0 | } |
169 | 0 | else return NULL; /* cannot run an emergency collection */ |
170 | 0 | } |
171 | | |
172 | | |
173 | | /* |
174 | | ** Generic allocation routine. |
175 | | */ |
176 | 924 | void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) { |
177 | 924 | void *newblock; |
178 | 924 | global_State *g = G(L); |
179 | 924 | lua_assert((osize == 0) == (block == NULL)); |
180 | 924 | newblock = firsttry(g, block, osize, nsize); |
181 | 924 | if (l_unlikely(newblock == NULL && nsize > 0)) { |
182 | 0 | newblock = tryagain(L, block, osize, nsize); |
183 | 0 | if (newblock == NULL) /* still no memory? */ |
184 | 0 | return NULL; /* do not update 'GCdebt' */ |
185 | 0 | } |
186 | 924 | lua_assert((nsize == 0) == (newblock == NULL)); |
187 | 924 | g->GCdebt = (g->GCdebt + nsize) - osize; |
188 | 924 | return newblock; |
189 | 924 | } |
190 | | |
191 | | |
192 | | void *luaM_saferealloc_ (lua_State *L, void *block, size_t osize, |
193 | 0 | size_t nsize) { |
194 | 0 | void *newblock = luaM_realloc_(L, block, osize, nsize); |
195 | 0 | if (l_unlikely(newblock == NULL && nsize > 0)) /* allocation failed? */ |
196 | 0 | luaM_error(L); |
197 | 0 | return newblock; |
198 | 0 | } |
199 | | |
200 | | |
201 | 18.7k | void *luaM_malloc_ (lua_State *L, size_t size, int tag) { |
202 | 18.7k | if (size == 0) |
203 | 0 | return NULL; /* that's all */ |
204 | 18.7k | else { |
205 | 18.7k | global_State *g = G(L); |
206 | 18.7k | void *newblock = firsttry(g, NULL, tag, size); |
207 | 18.7k | if (l_unlikely(newblock == NULL)) { |
208 | 0 | newblock = tryagain(L, NULL, tag, size); |
209 | 0 | if (newblock == NULL) |
210 | 0 | luaM_error(L); |
211 | 0 | } |
212 | 18.7k | g->GCdebt += size; |
213 | 18.7k | return newblock; |
214 | 18.7k | } |
215 | 18.7k | } |