A modern Music Player Daemon based on Rockbox open source high quality audio player
tsiry-sandratraina.com
libadwaita
audio
rust
zig
deno
mpris
rockbox
mpd
1/*
2** $Id: lgc.c,v 2.38.1.2 2011/03/18 18:05:38 roberto Exp $
3** Garbage Collector
4** See Copyright Notice in lua.h
5*/
6
7#include <string.h>
8
9#define lgc_c
10#define LUA_CORE
11
12#include "lua.h"
13
14#include "ldebug.h"
15#include "ldo.h"
16#include "lfunc.h"
17#include "lgc.h"
18#include "lmem.h"
19#include "lobject.h"
20#include "lstate.h"
21#include "lstring.h"
22#include "ltable.h"
23#include "ltm.h"
24
25
26#define GCSTEPSIZE 1024u
27#define GCSWEEPMAX 40
28#define GCSWEEPCOST 10
29#define GCFINALIZECOST 100
30
31
32#define maskmarks cast_byte(~(bitmask(BLACKBIT)|WHITEBITS))
33
34#define makewhite(g,x) \
35 ((x)->gch.marked = cast_byte(((x)->gch.marked & maskmarks) | luaC_white(g)))
36
37#define white2gray(x) reset2bits((x)->gch.marked, WHITE0BIT, WHITE1BIT)
38#define black2gray(x) resetbit((x)->gch.marked, BLACKBIT)
39
40#define stringmark(s) reset2bits((s)->tsv.marked, WHITE0BIT, WHITE1BIT)
41
42
43#define isfinalized(u) testbit((u)->marked, FINALIZEDBIT)
44#define markfinalized(u) l_setbit((u)->marked, FINALIZEDBIT)
45
46
47#define KEYWEAK bitmask(KEYWEAKBIT)
48#define VALUEWEAK bitmask(VALUEWEAKBIT)
49
50
51
52#define markvalue(g,o) { checkconsistency(o); \
53 if (iscollectable(o) && iswhite(gcvalue(o))) reallymarkobject(g,gcvalue(o)); }
54
55#define markobject(g,t) { if (iswhite(obj2gco(t))) \
56 reallymarkobject(g, obj2gco(t)); }
57
58
59#define setthreshold(g) (g->GCthreshold = (g->estimate/100) * g->gcpause)
60
61#ifndef yield
62 #define yield() {}
63#endif
64
65static void removeentry (Node *n) {
66 lua_assert(ttisnil(gval(n)));
67 if (iscollectable(gkey(n)))
68 setttype(gkey(n), LUA_TDEADKEY); /* dead key; remove it */
69}
70
71
72static void reallymarkobject (global_State *g, GCObject *o) {
73 lua_assert(iswhite(o) && !isdead(g, o));
74 white2gray(o);
75 switch (o->gch.tt) {
76 case LUA_TSTRING: {
77 return;
78 }
79 case LUA_TUSERDATA: {
80 Table *mt = gco2u(o)->metatable;
81 gray2black(o); /* udata are never gray */
82 if (mt) markobject(g, mt);
83 markobject(g, gco2u(o)->env);
84 return;
85 }
86 case LUA_TUPVAL: {
87 UpVal *uv = gco2uv(o);
88 markvalue(g, uv->v);
89 if (uv->v == &uv->u.value) /* closed? */
90 gray2black(o); /* open upvalues are never black */
91 return;
92 }
93 case LUA_TFUNCTION: {
94 gco2cl(o)->c.gclist = g->gray;
95 g->gray = o;
96 break;
97 }
98 case LUA_TTABLE: {
99 gco2h(o)->gclist = g->gray;
100 g->gray = o;
101 break;
102 }
103 case LUA_TTHREAD: {
104 gco2th(o)->gclist = g->gray;
105 g->gray = o;
106 break;
107 }
108 case LUA_TPROTO: {
109 gco2p(o)->gclist = g->gray;
110 g->gray = o;
111 break;
112 }
113 default: lua_assert(0);
114 }
115}
116
117
118static void marktmu (global_State *g) {
119 GCObject *u = g->tmudata;
120 if (u) {
121 do {
122 u = u->gch.next;
123 makewhite(g, u); /* may be marked, if left from previous GC */
124 reallymarkobject(g, u);
125 } while (u != g->tmudata);
126 }
127}
128
129
130/* move `dead' udata that need finalization to list `tmudata' */
131size_t luaC_separateudata (lua_State *L, int all) {
132 global_State *g = G(L);
133 size_t deadmem = 0;
134 GCObject **p = &g->mainthread->next;
135 GCObject *curr;
136 while ((curr = *p) != NULL) {
137 if (!(iswhite(curr) || all) || isfinalized(gco2u(curr)))
138 p = &curr->gch.next; /* don't bother with them */
139 else if (fasttm(L, gco2u(curr)->metatable, TM_GC) == NULL) {
140 markfinalized(gco2u(curr)); /* don't need finalization */
141 p = &curr->gch.next;
142 }
143 else { /* must call its gc method */
144 deadmem += sizeudata(gco2u(curr));
145 markfinalized(gco2u(curr));
146 *p = curr->gch.next;
147 /* link `curr' at the end of `tmudata' list */
148 if (g->tmudata == NULL) /* list is empty? */
149 g->tmudata = curr->gch.next = curr; /* creates a circular list */
150 else {
151 curr->gch.next = g->tmudata->gch.next;
152 g->tmudata->gch.next = curr;
153 g->tmudata = curr;
154 }
155 }
156 }
157 return deadmem;
158}
159
160
161static int traversetable (global_State *g, Table *h) {
162 int i;
163 int weakkey = 0;
164 int weakvalue = 0;
165 const TValue *mode;
166 if (h->metatable)
167 markobject(g, h->metatable);
168 mode = gfasttm(g, h->metatable, TM_MODE);
169 if (mode && ttisstring(mode)) { /* is there a weak mode? */
170 weakkey = (strchr(svalue(mode), 'k') != NULL);
171 weakvalue = (strchr(svalue(mode), 'v') != NULL);
172 if (weakkey || weakvalue) { /* is really weak? */
173 h->marked &= ~(KEYWEAK | VALUEWEAK); /* clear bits */
174 h->marked |= cast_byte((weakkey << KEYWEAKBIT) |
175 (weakvalue << VALUEWEAKBIT));
176 h->gclist = g->weak; /* must be cleared after GC, ... */
177 g->weak = obj2gco(h); /* ... so put in the appropriate list */
178 }
179 }
180 if (weakkey && weakvalue) return 1;
181 if (!weakvalue) {
182 i = h->sizearray;
183 while (i--)
184 markvalue(g, &h->array[i]);
185 }
186 i = sizenode(h);
187 while (i--) {
188 Node *n = gnode(h, i);
189 lua_assert(ttype(gkey(n)) != LUA_TDEADKEY || ttisnil(gval(n)));
190 if (ttisnil(gval(n)))
191 removeentry(n); /* remove empty entries */
192 else {
193 lua_assert(!ttisnil(gkey(n)));
194 if (!weakkey) markvalue(g, gkey(n));
195 if (!weakvalue) markvalue(g, gval(n));
196 }
197 }
198 return weakkey || weakvalue;
199}
200
201
202/*
203** All marks are conditional because a GC may happen while the
204** prototype is still being created
205*/
206static void traverseproto (global_State *g, Proto *f) {
207 int i;
208 if (f->source) stringmark(f->source);
209 for (i=0; i<f->sizek; i++) /* mark literals */
210 markvalue(g, &f->k[i]);
211 for (i=0; i<f->sizeupvalues; i++) { /* mark upvalue names */
212 if (f->upvalues[i])
213 stringmark(f->upvalues[i]);
214 }
215 for (i=0; i<f->sizep; i++) { /* mark nested protos */
216 if (f->p[i])
217 markobject(g, f->p[i]);
218 }
219 for (i=0; i<f->sizelocvars; i++) { /* mark local-variable names */
220 if (f->locvars[i].varname)
221 stringmark(f->locvars[i].varname);
222 }
223}
224
225
226
227static void traverseclosure (global_State *g, Closure *cl) {
228 markobject(g, cl->c.env);
229 if (cl->c.isC) {
230 int i;
231 for (i=0; i<cl->c.nupvalues; i++) /* mark its upvalues */
232 markvalue(g, &cl->c.upvalue[i]);
233 }
234 else {
235 int i;
236 lua_assert(cl->l.nupvalues == cl->l.p->nups);
237 markobject(g, cl->l.p);
238 for (i=0; i<cl->l.nupvalues; i++) { /* mark its upvalues */
239 if(cl->l.upvals[i])
240 markobject(g, cl->l.upvals[i]);
241 }
242 }
243}
244
245
246static void checkstacksizes (lua_State *L, StkId max) {
247 int ci_used = cast_int(L->ci - L->base_ci); /* number of `ci' in use */
248 int s_used = cast_int(max - L->stack); /* part of stack in use */
249 if (L->size_ci > LUAI_MAXCALLS) /* handling overflow? */
250 return; /* do not touch the stacks */
251 if (4*ci_used < L->size_ci && 2*BASIC_CI_SIZE < L->size_ci)
252 luaD_reallocCI(L, L->size_ci/2); /* still big enough... */
253 condhardstacktests(luaD_reallocCI(L, ci_used + 1));
254 if (4*s_used < L->stacksize &&
255 2*(BASIC_STACK_SIZE+EXTRA_STACK) < L->stacksize)
256 luaD_reallocstack(L, L->stacksize/2); /* still big enough... */
257 condhardstacktests(luaD_reallocstack(L, s_used));
258}
259
260
261static void traversestack (global_State *g, lua_State *l) {
262 StkId o, lim;
263 CallInfo *ci;
264 markvalue(g, gt(l));
265 lim = l->top;
266 if(l->stack == NULL) return; /* no stack to traverse */
267 for (ci = l->base_ci; ci <= l->ci; ci++) {
268 lua_assert(ci->top <= l->stack_last);
269 if (lim < ci->top) lim = ci->top;
270 }
271 for (o = l->stack; o < l->top; o++)
272 markvalue(g, o);
273 for (; o <= lim; o++)
274 setnilvalue(o);
275 if (!isfixedstack(l)) /* if stack size is fixed, can't resize it. */
276 checkstacksizes(l, lim);
277}
278
279
280/*
281** traverse one gray object, turning it to black.
282** Returns `quantity' traversed.
283*/
284static l_mem propagatemark (global_State *g) {
285 GCObject *o = g->gray;
286 lua_assert(isgray(o));
287 gray2black(o);
288 switch (o->gch.tt) {
289 case LUA_TTABLE: {
290 Table *h = gco2h(o);
291 g->gray = h->gclist;
292 if (traversetable(g, h)) /* table is weak? */
293 black2gray(o); /* keep it gray */
294 return sizeof(Table) + sizeof(TValue) * h->sizearray +
295 sizeof(Node) * sizenode(h);
296 }
297 case LUA_TFUNCTION: {
298 Closure *cl = gco2cl(o);
299 g->gray = cl->c.gclist;
300 traverseclosure(g, cl);
301 return (cl->c.isC) ? sizeCclosure(cl->c.nupvalues) :
302 sizeLclosure(cl->l.nupvalues);
303 }
304 case LUA_TTHREAD: {
305 lua_State *th = gco2th(o);
306 g->gray = th->gclist;
307 th->gclist = g->grayagain;
308 g->grayagain = o;
309 black2gray(o);
310 traversestack(g, th);
311 return sizeof(lua_State) + sizeof(TValue) * th->stacksize +
312 sizeof(CallInfo) * th->size_ci;
313 }
314 case LUA_TPROTO: {
315 Proto *p = gco2p(o);
316 g->gray = p->gclist;
317 traverseproto(g, p);
318 return sizeof(Proto) + sizeof(Instruction) * p->sizecode +
319 sizeof(Proto *) * p->sizep +
320 sizeof(TValue) * p->sizek +
321 sizeof(LocVar) * p->sizelocvars +
322 sizeof(TString *) * p->sizeupvalues +
323#ifdef LUA_OPTIMIZE_DEBUG
324 p->sizelineinfo;
325#else
326 sizeof(int) * p->sizelineinfo;
327#endif
328 }
329 default: lua_assert(0); return 0;
330 }
331}
332
333
334static size_t propagateall (global_State *g) {
335 size_t m = 0;
336 while (g->gray) m += propagatemark(g);
337 return m;
338}
339
340
341/*
342** The next function tells whether a key or value can be cleared from
343** a weak table. Non-collectable objects are never removed from weak
344** tables. Strings behave as `values', so are never removed too. for
345** other objects: if really collected, cannot keep them; for userdata
346** being finalized, keep them in keys, but not in values
347*/
348static int iscleared (const TValue *o, int iskey) {
349 if (!iscollectable(o)) return 0;
350 if (ttisstring(o)) {
351 stringmark(rawtsvalue(o)); /* strings are `values', so are never weak */
352 return 0;
353 }
354 return iswhite(gcvalue(o)) ||
355 (ttisuserdata(o) && (!iskey && isfinalized(uvalue(o))));
356}
357
358
359/*
360** clear collected entries from weaktables
361*/
362static void cleartable (GCObject *l) {
363 while (l) {
364 Table *h = gco2h(l);
365 int i = h->sizearray;
366 lua_assert(testbit(h->marked, VALUEWEAKBIT) ||
367 testbit(h->marked, KEYWEAKBIT));
368 if (testbit(h->marked, VALUEWEAKBIT)) {
369 while (i--) {
370 TValue *o = &h->array[i];
371 if (iscleared(o, 0)) /* value was collected? */
372 setnilvalue(o); /* remove value */
373 }
374 }
375 i = sizenode(h);
376 while (i--) {
377 Node *n = gnode(h, i);
378 if (!ttisnil(gval(n)) && /* non-empty entry? */
379 (iscleared(key2tval(n), 1) || iscleared(gval(n), 0))) {
380 setnilvalue(gval(n)); /* remove value ... */
381 removeentry(n); /* remove entry from table */
382 }
383 }
384 l = h->gclist;
385 }
386}
387
388
389static void freeobj (lua_State *L, GCObject *o) {
390 switch (o->gch.tt) {
391 case LUA_TPROTO: luaF_freeproto(L, gco2p(o)); break;
392 case LUA_TFUNCTION: luaF_freeclosure(L, gco2cl(o)); break;
393 case LUA_TUPVAL: luaF_freeupval(L, gco2uv(o)); break;
394 case LUA_TTABLE: luaH_free(L, gco2h(o)); break;
395 case LUA_TTHREAD: {
396 lua_assert(gco2th(o) != L && gco2th(o) != G(L)->mainthread);
397 luaE_freethread(L, gco2th(o));
398 break;
399 }
400 case LUA_TSTRING: {
401 G(L)->strt.nuse--;
402 luaM_freemem(L, o, sizetstring((gco2ts(o))->type, (gco2ts(o))->len));
403 break;
404 }
405 case LUA_TUSERDATA: {
406 luaM_freemem(L, o, sizeudata(gco2u(o)));
407 break;
408 }
409 default: lua_assert(0);
410 }
411}
412
413
414
415#define sweepwholelist(L,p) sweeplist(L,p,MAX_LUMEM)
416
417
418static GCObject **sweeplist (lua_State *L, GCObject **p, lu_mem count) {
419 GCObject *curr;
420 global_State *g = G(L);
421 int deadmask = otherwhite(g);
422 while ((curr = *p) != NULL && count-- > 0) {
423 if (curr->gch.tt == LUA_TTHREAD) /* sweep open upvalues of each thread */
424 sweepwholelist(L, &gco2th(curr)->openupval);
425 if ((curr->gch.marked ^ WHITEBITS) & deadmask) { /* not dead? */
426 lua_assert(!isdead(g, curr) || testbit(curr->gch.marked, FIXEDBIT));
427 makewhite(g, curr); /* make it white (for next cycle) */
428 p = &curr->gch.next;
429 }
430 else { /* must erase `curr' */
431 lua_assert(isdead(g, curr) || deadmask == bitmask(SFIXEDBIT));
432 *p = curr->gch.next;
433 freeobj(L, curr);
434 }
435 }
436 return p;
437}
438
439
440static void checkSizes (lua_State *L) {
441 global_State *g = G(L);
442 /* check size of string hash */
443 if (g->strt.nuse < cast(lu_int32, g->strt.size/4) &&
444 g->strt.size > MINSTRTABSIZE*2)
445 luaS_resize(L, g->strt.size/2); /* table is too big */
446 /* it is not safe to re-size the buffer if it is in use. */
447 if (luaZ_bufflen(&g->buff) > 0) return;
448 /* check size of buffer */
449 if (luaZ_sizebuffer(&g->buff) > LUA_MINBUFFER*2) { /* buffer too big? */
450 size_t newsize = luaZ_sizebuffer(&g->buff) / 2;
451 luaZ_resizebuffer(L, &g->buff, newsize);
452 }
453}
454
455
456static void GCTM (lua_State *L) {
457 global_State *g = G(L);
458 GCObject *o = g->tmudata->gch.next; /* get first element */
459 Udata *udata = rawgco2u(o);
460 const TValue *tm;
461 /* remove udata from `tmudata' */
462 if (o == g->tmudata) /* last element? */
463 g->tmudata = NULL;
464 else
465 g->tmudata->gch.next = udata->uv.next;
466 udata->uv.next = g->mainthread->next; /* return it to `root' list */
467 g->mainthread->next = o;
468 makewhite(g, o);
469 tm = fasttm(L, udata->uv.metatable, TM_GC);
470 if (tm != NULL) {
471 lu_byte oldah = L->allowhook;
472 lu_mem oldt = g->GCthreshold;
473 L->allowhook = 0; /* stop debug hooks during GC tag method */
474 g->GCthreshold = 2*g->totalbytes; /* avoid GC steps */
475 setobj2s(L, L->top, tm);
476 setuvalue(L, L->top+1, udata);
477 L->top += 2;
478 luaD_call(L, L->top - 2, 0);
479 L->allowhook = oldah; /* restore hooks */
480 g->GCthreshold = oldt; /* restore threshold */
481 }
482}
483
484
485/*
486** Call all GC tag methods
487*/
488void luaC_callGCTM (lua_State *L) {
489 while (G(L)->tmudata)
490 GCTM(L);
491}
492
493
494void luaC_freeall (lua_State *L) {
495 global_State *g = G(L);
496 int i;
497 g->currentwhite = WHITEBITS | bitmask(SFIXEDBIT); /* mask to collect all elements */
498 sweepwholelist(L, &g->rootgc);
499 for (i = 0; i < g->strt.size; i++) /* free all string lists */
500 sweepwholelist(L, &g->strt.hash[i]);
501}
502
503
504static void markmt (global_State *g) {
505 int i;
506 for (i=0; i<NUM_TAGS; i++)
507 if (g->mt[i]) markobject(g, g->mt[i]);
508}
509
510
511/* mark root set */
512static void markroot (lua_State *L) {
513 global_State *g = G(L);
514 g->gray = NULL;
515 g->grayagain = NULL;
516 g->weak = NULL;
517 markobject(g, g->mainthread);
518 /* make global table be traversed before main stack */
519 markvalue(g, gt(g->mainthread));
520 markvalue(g, registry(L));
521 markmt(g);
522 g->gcstate = GCSpropagate;
523}
524
525
526static void remarkupvals (global_State *g) {
527 UpVal *uv;
528 for (uv = g->uvhead.u.l.next; uv != &g->uvhead; uv = uv->u.l.next) {
529 lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);
530 if (isgray(obj2gco(uv)))
531 markvalue(g, uv->v);
532 }
533}
534
535
536static void atomic (lua_State *L) {
537 global_State *g = G(L);
538 size_t udsize; /* total size of userdata to be finalized */
539 /* remark occasional upvalues of (maybe) dead threads */
540 remarkupvals(g);
541 /* traverse objects cautch by write barrier and by 'remarkupvals' */
542 propagateall(g);
543 /* remark weak tables */
544 g->gray = g->weak;
545 g->weak = NULL;
546 lua_assert(!iswhite(obj2gco(g->mainthread)));
547 markobject(g, L); /* mark running thread */
548 markmt(g); /* mark basic metatables (again) */
549 propagateall(g);
550 /* remark gray again */
551 g->gray = g->grayagain;
552 g->grayagain = NULL;
553 propagateall(g);
554 udsize = luaC_separateudata(L, 0); /* separate userdata to be finalized */
555 marktmu(g); /* mark `preserved' userdata */
556 udsize += propagateall(g); /* remark, to propagate `preserveness' */
557 cleartable(g->weak); /* remove collected objects from weak tables */
558 /* flip current white */
559 g->currentwhite = cast_byte(otherwhite(g));
560 g->sweepstrgc = 0;
561 g->sweepgc = &g->rootgc;
562 g->gcstate = GCSsweepstring;
563 g->estimate = g->totalbytes - udsize; /* first estimate */
564}
565
566static void sweepstrstep (global_State *g, lua_State *L) {
567 lu_mem old = g->totalbytes;
568 sweepwholelist(L, &g->strt.hash[g->sweepstrgc++]);
569 if (g->sweepstrgc >= g->strt.size) /* nothing more to sweep? */
570 g->gcstate = GCSsweep; /* end sweep-string phase */
571 lua_assert(old >= g->totalbytes);
572 g->estimate -= old - g->totalbytes;
573}
574
575
576static l_mem singlestep (lua_State *L) {
577 global_State *g = G(L);
578 /*lua_checkmemory(L);*/
579 switch (g->gcstate) {
580 case GCSpause: {
581 markroot(L); /* start a new collection */
582 return 0;
583 }
584 case GCSpropagate: {
585 if (g->gray)
586 return propagatemark(g);
587 else { /* no more `gray' objects */
588 atomic(L); /* finish mark phase */
589 return 0;
590 }
591 }
592 case GCSsweepstring: {
593 sweepstrstep(g, L);
594 return GCSWEEPCOST;
595 }
596 case GCSsweep: {
597 lu_mem old = g->totalbytes;
598 g->sweepgc = sweeplist(L, g->sweepgc, GCSWEEPMAX);
599 if (*g->sweepgc == NULL) { /* nothing more to sweep? */
600 checkSizes(L);
601 g->gcstate = GCSfinalize; /* end sweep phase */
602 }
603 lua_assert(old >= g->totalbytes);
604 g->estimate -= old - g->totalbytes;
605 return GCSWEEPMAX*GCSWEEPCOST;
606 }
607 case GCSfinalize: {
608 if (g->tmudata) {
609 GCTM(L);
610 if (g->estimate > GCFINALIZECOST)
611 g->estimate -= GCFINALIZECOST;
612 return GCFINALIZECOST;
613 }
614 else {
615 g->gcstate = GCSpause; /* end collection */
616 g->gcdept = 0;
617 return 0;
618 }
619 }
620 default: lua_assert(0); return 0;
621 }
622}
623
624
625void luaC_step (lua_State *L) {
626 global_State *g = G(L);
627 if(is_block_gc(L)) return;
628 set_block_gc(L);
629 l_mem lim = (GCSTEPSIZE/100) * g->gcstepmul;
630 if (lim == 0)
631 lim = (MAX_LUMEM-1)/2; /* no limit */
632 g->gcdept += g->totalbytes - g->GCthreshold;
633 if (g->estimate > g->totalbytes)
634 g->estimate = g->totalbytes;
635 do {
636 lim -= singlestep(L);
637 if (g->gcstate == GCSpause)
638 break;
639 } while (lim > 0);
640 if (g->gcstate != GCSpause) {
641 if (g->gcdept < GCSTEPSIZE)
642 g->GCthreshold = g->totalbytes + GCSTEPSIZE; /* - lim/g->gcstepmul;*/
643 else {
644 g->gcdept -= GCSTEPSIZE;
645 g->GCthreshold = g->totalbytes;
646 }
647 }
648 else {
649 setthreshold(g);
650 }
651 unset_block_gc(L);
652}
653
654
655int luaC_sweepstrgc (lua_State *L) {
656 global_State *g = G(L);
657 if (g->gcstate == GCSsweepstring) {
658 sweepstrstep(g, L);
659 return (g->gcstate == GCSsweepstring) ? 1 : 0;
660 }
661 return 0;
662}
663
664void luaC_fullgc (lua_State *L) {
665 global_State *g = G(L);
666 if(is_block_gc(L)) return;
667 set_block_gc(L);
668 if (g->gcstate <= GCSpropagate) {
669 /* reset sweep marks to sweep all elements (returning them to white) */
670 g->sweepstrgc = 0;
671 g->sweepgc = &g->rootgc;
672 /* reset other collector lists */
673 g->gray = NULL;
674 g->grayagain = NULL;
675 g->weak = NULL;
676 g->gcstate = GCSsweepstring;
677 }
678 lua_assert(g->gcstate != GCSpause && g->gcstate != GCSpropagate);
679 /* finish any pending sweep phase */
680 while (g->gcstate != GCSfinalize) {
681 lua_assert(g->gcstate == GCSsweepstring || g->gcstate == GCSsweep);
682 singlestep(L);
683 yield();
684 }
685 markroot(L);
686 while (g->gcstate != GCSpause) {
687 singlestep(L);
688 yield();
689 }
690 setthreshold(g);
691 unset_block_gc(L);
692}
693
694
695void luaC_barrierf (lua_State *L, GCObject *o, GCObject *v) {
696 global_State *g = G(L);
697 lua_assert(isblack(o) && iswhite(v) && !isdead(g, v) && !isdead(g, o));
698 lua_assert(g->gcstate != GCSfinalize && g->gcstate != GCSpause);
699 lua_assert(ttype(&o->gch) != LUA_TTABLE);
700 /* must keep invariant? */
701 if (g->gcstate == GCSpropagate)
702 reallymarkobject(g, v); /* restore invariant */
703 else /* don't mind */
704 makewhite(g, o); /* mark as white just to avoid other barriers */
705}
706
707
708void luaC_barrierback (lua_State *L, Table *t) {
709 global_State *g = G(L);
710 GCObject *o = obj2gco(t);
711 lua_assert(isblack(o) && !isdead(g, o));
712 lua_assert(g->gcstate != GCSfinalize && g->gcstate != GCSpause);
713 black2gray(o); /* make table gray (again) */
714 t->gclist = g->grayagain;
715 g->grayagain = o;
716}
717
718
719void luaC_marknew (lua_State *L, GCObject *o) {
720 global_State *g = G(L);
721 o->gch.marked = luaC_white(g);
722 if (g->gcstate == GCSpropagate)
723 reallymarkobject(g, o); /* mark new objects as gray during propagate state. */
724}
725
726
727void luaC_link (lua_State *L, GCObject *o, lu_byte tt) {
728 global_State *g = G(L);
729 o->gch.next = g->rootgc;
730 g->rootgc = o;
731 o->gch.marked = luaC_white(g);
732 o->gch.tt = tt;
733}
734
735
736void luaC_linkupval (lua_State *L, UpVal *uv) {
737 global_State *g = G(L);
738 GCObject *o = obj2gco(uv);
739 o->gch.next = g->rootgc; /* link upvalue into `rootgc' list */
740 g->rootgc = o;
741 if (isgray(o)) {
742 if (g->gcstate == GCSpropagate) {
743 gray2black(o); /* closed upvalues need barrier */
744 luaC_barrier(L, uv, uv->v);
745 }
746 else { /* sweep phase: sweep it (turning it into white) */
747 makewhite(g, o);
748 lua_assert(g->gcstate != GCSfinalize && g->gcstate != GCSpause);
749 }
750 }
751}
752