Zsh Mailing List Archive
Messages sorted by:
Reverse Date,
Date,
Thread,
Author
Re: [BUG] queueing_enabled grows infinitely when in .recursive-edit
- X-seq: zsh-workers 39544
- From: Sebastian Gniazdowski <sgniazdowski@xxxxxxxxx>
- To: Bart Schaefer <schaefer@xxxxxxxxxxxxxxxx>
- Subject: Re: [BUG] queueing_enabled grows infinitely when in .recursive-edit
- Date: Mon, 3 Oct 2016 12:00:05 +0200
- Cc: Zsh hackers list <zsh-workers@xxxxxxx>
- Dkim-signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20120113; h=mime-version:in-reply-to:references:from:date:message-id:subject:to :cc; bh=h6F0JtJblVSi2LxSoS+3T/uodX8OcKA0aMNyqNqqVQY=; b=URrPg6oMS4aXjzP83Auf9pvomdnZ4OEU/cvx+MmreSqLTy/OYg/4y64SXbkHNMf2mO 7iFKtrwduBWqnd220wBwE0CJV1WLFSyezHZmvXGwOruNeGVbClotx2SD7Z+Uu1fSKj3o LuV7y9cHcYYaiF8DCHf/ArSV8KgAXVpY7rF3rMZG0TKqgDWsgZTDTZ8dYzkPwJbqEl4p cLs1tvi3g8dccQa6y8g6qfEnV8/jFPN/cPO323OGSnZQ/IhbdeoayGyThCQwc6/Glty0 DxEcMwNdvY/0rzz+QE0bTOD9tfKiJS28salC5wYS787FG0ZEZhRZA4+DXtlXSE/Y2Vxg aPAA==
- In-reply-to: <161002162145.ZM22574@torch.brasslantern.com>
- List-help: <mailto:zsh-workers-help@zsh.org>
- List-id: Zsh Workers List <zsh-workers.zsh.org>
- List-post: <mailto:zsh-workers@zsh.org>
- Mailing-list: contact zsh-workers-help@xxxxxxx; run by ezmlm
- References: <CAKc7PVAoLMj+dwEugbvggrmcjQbLP3GutxiNHPbpwvLw-a9F=w@mail.gmail.com> <161002162145.ZM22574@torch.brasslantern.com>
On 3 October 2016 at 01:21, Bart Schaefer <schaefer@xxxxxxxxxxxxxxxx> wrote:
> There seem to be a bunch of inter-related things going on here.
>
> The first is that recursiveedit() calls zlecore() which calls
> getkeycmd() which cascades into raw_getbyte() with do_keytmout = 0
> which in some circumstances means that raw_getbyte() effectively
> does a blocking read on its first call and only runs the sched
> after a key is pressed. I haven't figured out what's wrong with
> the calc_timeout() logic that makes this possible, but it's a
> race -- it happens only once in a while.
It could be either way, if this is to be resolved. I mean, stopping
sched when in .recursive-edit has some, if not total sense. It's like
if user would be in an application.
> The second is that zlecore() expects to be entered with the signal
> queue disabled, but zle widgets are called with queueing enabled, so
> recursiveedit() needs save/zero/restore the queue level around the
> call to zlecore().
>
> The third is that somewhere below execstring() from checksched(),
> the signal queueing level is being incremented but not decremented.
> The problem is that the execution code calls itself recursively so
> deeply that I can't pinpoint the place this occurs. Even with a
> watchpoint on queueing_enabled, it looks as though we should be
> fine -- it's as if the recursive calls never quite unwind all the
> way back to the top, but printing stack traces in gdb doesn't show
> that happening at any place where queueing_enabled changes.
>
> Usually the third effect is hidden by the restore_queue_signals()
> in getbyte(), but when in recursiveedit() the queue_signal_level()
> in raw_getbyte() starts out > 0, and never goes all the way back
> down again. Or something like that. I expected fixing the second
> problem to again mask the third, but it does not.
>
> It's almost like there's a tail-call optimization occuring that is
> causing an unqueue_signals() to be skipped. And in fact there are
> cases where the queueing_enabled is decremented but the watchpoint
> mysteriously does not trigger -- I see the smaller "old" value the
> next time the watchpoint triggers on the *increment*, but I never
> see the assignment that reduces the value. I think this is because
> gdb actually stops on the NEXT instruction AFTER the watched location,
> and there are some places where there is no breakable next line (the
> unqueue_signals() is the last line of a function).
>
> It's quite normal for queueing_enabled to run up to 12 or so on a
> normal execution stack and still decrement all the way back to zero,
> so watching for a high-water mark is nearly useless.
Early this morning I read this text like if watchpoints didn't work
and now did whole path from recursiveedit to second raw_getbyte()
call. In lldb watchpoitns worked apparently always correctly, maybe
because I have no optimizations. Forgot to set breakpoint on
raw_getbyte() and ended in going multiple steps "repeated", but maybe
that's a luck, because vim/:setscrollbind shows nicely where
repetition starts and that queueing_enabled is off by 1:
https://asciinema.org/a/2c4p285gujuv0850uinrmj2le
The first common entry is #8. I submit and now start to think about
what's gathered.
Best regards,
Sebastian Gniazdowski
Process 19127 stopped
* thread #1: tid = 0x2cbd2c, 0x000000010f28b3ba zle.so`recursiveedit(args=0x000000010f38b0a0) + 26 at zle_main.c:1916, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1
frame #0: 0x000000010f28b3ba zle.so`recursiveedit(args=0x000000010f38b0a0) + 26 at zle_main.c:1916
1913 recursiveedit(UNUSED(char **args))
1914 {
1915 // MY DEBUG
-> 1916 FILE *_F = fopen("/tmp/recursive.txt", "a+");
1917 fprintf( _F, "recursiveedit() - queueing_enabled (%d)\n", queueing_enabled );
1918 fclose(_F);
1919
(lldb) p queueing_enabled
(int) $0 = 1
(lldb) watchpoint set variable queueing_enabled Watchpoint created: Watchpoint 1: addr = 0x10f016e28 size = 4 state = enabled type = w
watchpoint spec = 'queueing_enabled'
new value: 1
(lldb) c
, stop reason = watchpoint 1
frame #0: 0x000000010efa513d zsh-5.2-dev-2`zalloc(size=6) + 45 at mem.c:956
953 if (!size)
954 size = 1;
955 queue_signals();
-> 956 if (!(ptr = (void *) malloc(size))) {
957 zerr("fatal error: out of memory");
958 exit(1);
959 }
(lldb) p queueing_enabled
(int) $1 = 2
frame #0: 0x000000010efa51a2 zsh-5.2-dev-2`zalloc(size=6) + 146 at mem.c:960
957 zerr("fatal error: out of memory");
958 exit(1);
959 }
-> 960 unqueue_signals();
961
962 return ptr;
963 }
(lldb) p queueing_enabled
(int) $2 = 1
frame #0: 0x000000010efa4f96 zsh-5.2-dev-2`pushheap + 22 at mem.c:302
299 h_push++;
300 #endif
301
-> 302 for (h = heaps; h; h = h->next) {
303 DPUTS(!h->used && h->next, "BUG: empty heap");
304 hs = (Heapstack) zalloc(sizeof(*hs));
305 hs->next = h->sp;
(lldb) p queueing_enabled
(int) $3 = 2
frame #0: 0x000000010efa513d zsh-5.2-dev-2`zalloc(size=16) + 45 at mem.c:956
953 if (!size)
954 size = 1;
955 queue_signals();
-> 956 if (!(ptr = (void *) malloc(size))) {
957 zerr("fatal error: out of memory");
958 exit(1);
959 }
(lldb) p queueing_enabled
(int) $4 = 3
frame #0: 0x000000010efa51a2 zsh-5.2-dev-2`zalloc(size=16) + 146 at mem.c:960
957 zerr("fatal error: out of memory");
958 exit(1);
959 }
-> 960 unqueue_signals();
961
962 return ptr;
963 }
(lldb) p queueing_enabled
(int) $5 = 2
frame #0: 0x000000010efa505d zsh-5.2-dev-2`pushheap + 221 at mem.c:318
315 }
316 #endif
317 }
-> 318 unqueue_signals();
319 }
320
321 /* reset heaps to previous state */
(lldb) p queueing_enabled
(int) $6 = 1
frame #0: 0x000000010f2887ed zle.so`getbyte(do_keytmout=0, timeout=0x0000000000000000) + 237 at zle_main.c:903
900 else {
901 for (;;) {
902 int q = queue_signal_level();
-> 903 dont_queue_signals();
904 r = raw_getbyte(do_keytmout, &cc);
905 restore_queue_signals(q);
906 if (r == -2) {
(lldb) p queueing_enabled
(int) $7 = 0
frame #0: 0x000000010efa4f96 zsh-5.2-dev-2`pushheap + 22 at mem.c:302
299 h_push++;
300 #endif
301
-> 302 for (h = heaps; h; h = h->next) {
303 DPUTS(!h->used && h->next, "BUG: empty heap");
304 hs = (Heapstack) zalloc(sizeof(*hs));
305 hs->next = h->sp;
(lldb) p queueing_enabled
(int) $8 = 1
frame #0: 0x000000010efa513d zsh-5.2-dev-2`zalloc(size=16) + 45 at mem.c:956
953 if (!size)
954 size = 1;
955 queue_signals();
-> 956 if (!(ptr = (void *) malloc(size))) {
957 zerr("fatal error: out of memory");
958 exit(1);
959 }
(lldb) p queueing_enabled
(int) $9 = 2
frame #0: 0x000000010efa51a2 zsh-5.2-dev-2`zalloc(size=16) + 146 at mem.c:960
957 zerr("fatal error: out of memory");
958 exit(1);
959 }
-> 960 unqueue_signals();
961
962 return ptr;
963 }
(lldb) p queueing_enabled
(int) $10 = 1
frame #0: 0x000000010efa505d zsh-5.2-dev-2`pushheap + 221 at mem.c:318
315 }
316 #endif
317 }
-> 318 unqueue_signals();
319 }
320
321 /* reset heaps to previous state */
(lldb) p queueing_enabled
(int) $11 = 0
frame #0: 0x000000010ef60200 zsh-5.2-dev-2`zcontext_save_partial(parts=7) + 32 at context.c:58
55
56 queue_signals();
57
-> 58 cs = (struct context_stack *)malloc(sizeof(struct context_stack));
59
60 if (parts & ZCONTEXT_HIST) {
61 hist_context_save(&cs->hist_stack, !cstack);
(lldb) p queueing_enabled
(int) $12 = 1
frame #0: 0x000000010efa513d zsh-5.2-dev-2`zalloc(size=256) + 45 at mem.c:956
953 if (!size)
954 size = 1;
955 queue_signals();
-> 956 if (!(ptr = (void *) malloc(size))) {
957 zerr("fatal error: out of memory");
958 exit(1);
959 }
(lldb) p queueing_enabled
(int) $13 = 2
frame #0: 0x000000010efa51a2 zsh-5.2-dev-2`zalloc(size=256) + 146 at mem.c:960
957 zerr("fatal error: out of memory");
958 exit(1);
959 }
-> 960 unqueue_signals();
961
962 return ptr;
963 }
(lldb) p queueing_enabled
(int) $14 = 1
frame #0: 0x000000010ef602f1 zsh-5.2-dev-2`zcontext_save_partial(parts=7) + 273 at context.c:73
70 cs->next = cstack;
71 cstack = cs;
72
-> 73 unqueue_signals();
74 }
75
76 /* save context in full */
(lldb) p queueing_enabled
(int) $15 = 0
frame #0: 0x000000010ef90974 zsh-5.2-dev-2`inputsetline(str="fun", flags=64) + 36 at input.c:386
383 {
384 queue_signals();
385
-> 386 if ((inbufflags & INP_FREE) && inbuf) {
387 free(inbuf);
388 }
389 inbuf = inbufptr = str;
(lldb) p queueing_enabled
(int) $16 = 1
frame #0: 0x000000010ef90a33 zsh-5.2-dev-2`inputsetline(str="fun", flags=64) + 227 at input.c:404
401 inbufct = inbufleft;
402 inbufflags = flags;
403
-> 404 unqueue_signals();
405 }
406
(lldb) p queueing_enabled
(int) $17 = 0
frame #0: 0x000000010efbe9ed zsh-5.2-dev-2`init_parse + 29 at parse.c:469
466 {
467 queue_signals();
468
-> 469 if (ecbuf) zfree(ecbuf, eclen);
470
471 ecbuf = (Wordcode) zalloc((eclen = EC_INIT_SIZE) * sizeof(wordcode));
472 ecused = 0;
(lldb) p queueing_enabled
(int) $18 = 1
frame #0: 0x000000010efa513d zsh-5.2-dev-2`zalloc(size=1024) + 45 at mem.c:956
953 if (!size)
954 size = 1;
955 queue_signals();
-> 956 if (!(ptr = (void *) malloc(size))) {
957 zerr("fatal error: out of memory");
958 exit(1);
959 }
(lldb) p queueing_enabled
(int) $19 = 2
frame #0: 0x000000010efa51a2 zsh-5.2-dev-2`zalloc(size=1024) + 146 at mem.c:960
957 zerr("fatal error: out of memory");
958 exit(1);
959 }
-> 960 unqueue_signals();
961
962 return ptr;
963 }
(lldb) p queueing_enabled
(int) $20 = 1
frame #0: 0x000000010efbeabb zsh-5.2-dev-2`init_parse + 235 at parse.c:480
477
478 init_parse_status();
479
-> 480 unqueue_signals();
481 }
482
483 /* Build eprog. */
(lldb) p queueing_enabled
(int) $21 = 0
frame #0: 0x000000010efa5a96 zsh-5.2-dev-2`zhalloc(size=32) + 54 at mem.c:604
601 * but we think that nothing upstream of fheap has more free space,
602 * so why start over at heaps just because fheap has too little?
603 */
-> 604 for (h = (fheap ? fheap : heaps); h; h = h->next) {
605 hp = h;
606 if (ARENA_SIZEOF(h) >= (n = size + h->used)) {
607 void *ret;
(lldb) p queueing_enabled
(int) $22 = 1
frame #0: 0x000000010efa5b57 zsh-5.2-dev-2`zhalloc(size=32) + 247 at mem.c:611
608
609 h->used = n;
610 ret = arena(h) + n - size;
-> 611 unqueue_signals();
612 #ifdef ZSH_HEAP_DEBUG
613 last_heap_id = h->heap_id;
614 if (heap_debug_verbosity & HDV_ALLOC) {
(lldb) p queueing_enabled
(int) $23 = 0
frame #0: 0x000000010efa5a96 zsh-5.2-dev-2`zhalloc(size=8) + 54 at mem.c:604
601 * but we think that nothing upstream of fheap has more free space,
602 * so why start over at heaps just because fheap has too little?
603 */
-> 604 for (h = (fheap ? fheap : heaps); h; h = h->next) {
605 hp = h;
606 if (ARENA_SIZEOF(h) >= (n = size + h->used)) {
607 void *ret;
(lldb) p queueing_enabled
(int) $24 = 1
frame #0: 0x000000010efa5b57 zsh-5.2-dev-2`zhalloc(size=8) + 247 at mem.c:611
608
609 h->used = n;
610 ret = arena(h) + n - size;
-> 611 unqueue_signals();
612 #ifdef ZSH_HEAP_DEBUG
613 last_heap_id = h->heap_id;
614 if (heap_debug_verbosity & HDV_ALLOC) {
(lldb) p queueing_enabled
(int) $25 = 0
frame #0: 0x000000010efbef8b zsh-5.2-dev-2`bld_eprog(heap=1) + 27 at parse.c:505
502
503 queue_signals();
504
-> 505 ecadd(WCB_END());
506
507 ret = heap ? (Eprog) zhalloc(sizeof(*ret)) : (Eprog) zalloc(sizeof(*ret));
508 ret->len = ((ecnpats * sizeof(Patprog)) +
(lldb) p queueing_enabled
(int) $26 = 1
frame #0: 0x000000010efa5a96 zsh-5.2-dev-2`zhalloc(size=56) + 54 at mem.c:604
601 * but we think that nothing upstream of fheap has more free space,
602 * so why start over at heaps just because fheap has too little?
603 */
-> 604 for (h = (fheap ? fheap : heaps); h; h = h->next) {
605 hp = h;
606 if (ARENA_SIZEOF(h) >= (n = size + h->used)) {
607 void *ret;
(lldb) p queueing_enabled
(int) $27 = 2
frame #0: 0x000000010efa5b57 zsh-5.2-dev-2`zhalloc(size=56) + 247 at mem.c:611
608
609 h->used = n;
610 ret = arena(h) + n - size;
-> 611 unqueue_signals();
612 #ifdef ZSH_HEAP_DEBUG
613 last_heap_id = h->heap_id;
614 if (heap_debug_verbosity & HDV_ALLOC) {
(lldb) p queueing_enabled
(int) $28 = 1
frame #0: 0x000000010efa5a96 zsh-5.2-dev-2`zhalloc(size=24) + 54 at mem.c:604
601 * but we think that nothing upstream of fheap has more free space,
602 * so why start over at heaps just because fheap has too little?
603 */
-> 604 for (h = (fheap ? fheap : heaps); h; h = h->next) {
605 hp = h;
606 if (ARENA_SIZEOF(h) >= (n = size + h->used)) {
607 void *ret;
(lldb) p queueing_enabled
(int) $29 = 2
frame #0: 0x000000010efa5b57 zsh-5.2-dev-2`zhalloc(size=24) + 247 at mem.c:611
608
609 h->used = n;
610 ret = arena(h) + n - size;
-> 611 unqueue_signals();
612 #ifdef ZSH_HEAP_DEBUG
613 last_heap_id = h->heap_id;
614 if (heap_debug_verbosity & HDV_ALLOC) {
(lldb) p queueing_enabled
(int) $30 = 1
frame #0: 0x000000010efbf1bc zsh-5.2-dev-2`bld_eprog(heap=1) + 588 at parse.c:528
525 zfree(ecbuf, eclen);
526 ecbuf = NULL;
527
-> 528 unqueue_signals();
529
530 return ret;
531 }
(lldb) p queueing_enabled
(int) $31 = 0
frame #0: 0x000000010ef8106d zsh-5.2-dev-2`hend(prog=0x0000000000000000) + 125 at hist.c:1395
1392 DPUTS(stophist != 2 && !(inbufflags & INP_ALIAS) && !chline,
1393 "BUG: chline is NULL in hend()");
1394 queue_signals();
-> 1395 if (histdone & HISTFLAG_SETTY)
1396 settyinfo(&shttyinfo);
1397 if (!(histactive & HA_NOINC))
1398 unlinkcurline();
(lldb) p queueing_enabled
(int) $32 = 1
frame #0: 0x000000010ef81158 zsh-5.2-dev-2`hend(prog=0x0000000000000000) + 360 at hist.c:1405
1402 chline = hptr = NULL;
1403 chwords = NULL;
1404 histactive = 0;
-> 1405 unqueue_signals();
1406 return 1;
1407 }
1408 if (hist_ignore_all_dups != isset(HISTIGNOREALLDUPS)
(lldb) p queueing_enabled
(int) $33 = 0
frame #0: 0x000000010ef603f5 zsh-5.2-dev-2`zcontext_restore_partial(parts=7) + 69 at context.c:96
93 DPUTS(!cstack, "BUG: zcontext_restore() without zcontext_save()");
94
95 queue_signals();
-> 96 cstack = cstack->next;
97
98 if (parts & ZCONTEXT_HIST) {
99 hist_context_restore(&cs->hist_stack, !cstack);
(lldb) p queueing_enabled
(int) $34 = 1
frame #0: 0x000000010ef604de zsh-5.2-dev-2`zcontext_restore_partial(parts=7) + 302 at context.c:110
107
108 free(cs);
109
-> 110 unqueue_signals();
111 }
112
113 /* restore full context */
(lldb) p queueing_enabled
(int) $35 = 0
frame #0: 0x000000010ef61727 zsh-5.2-dev-2`execlist(state=0x00007fff50cb51f0, dont_change_job=0, exiting=0) + 55 at exec.c:1205
1202
1203 queue_signals();
1204
-> 1205 cj = thisjob;
1206 old_pline_level = pline_level;
1207 old_list_pipe = list_pipe;
1208 old_list_pipe_job = list_pipe_job;
(lldb) p queueing_enabled
(int) $36 = 1
frame #0: 0x000000010ef62892 zsh-5.2-dev-2`execpline(state=0x00007fff50cb51f0, slcode=3074, how=18, last1=0) + 194 at exec.c:1514
1511 */
1512 queue_signals();
1513
-> 1514 pj = thisjob;
1515 ipipe[0] = ipipe[1] = opipe[0] = opipe[1] = 0;
1516 child_block();
1517
(lldb) p queueing_enabled
(int) $37 = 2
frame #0: 0x000000010efa5a96 zsh-5.2-dev-2`zhalloc(size=48) + 54 at mem.c:604
601 * but we think that nothing upstream of fheap has more free space,
602 * so why start over at heaps just because fheap has too little?
603 */
-> 604 for (h = (fheap ? fheap : heaps); h; h = h->next) {
605 hp = h;
606 if (ARENA_SIZEOF(h) >= (n = size + h->used)) {
607 void *ret;
(lldb) p queueing_enabled
(int) $38 = 3
frame #0: 0x000000010efa5b57 zsh-5.2-dev-2`zhalloc(size=48) + 247 at mem.c:611
608
609 h->used = n;
610 ret = arena(h) + n - size;
-> 611 unqueue_signals();
612 #ifdef ZSH_HEAP_DEBUG
613 last_heap_id = h->heap_id;
614 if (heap_debug_verbosity & HDV_ALLOC) {
(lldb) p queueing_enabled
(int) $39 = 2
frame #0: 0x000000010efa5a96 zsh-5.2-dev-2`zhalloc(size=8) + 54 at mem.c:604
601 * but we think that nothing upstream of fheap has more free space,
602 * so why start over at heaps just because fheap has too little?
603 */
-> 604 for (h = (fheap ? fheap : heaps); h; h = h->next) {
605 hp = h;
606 if (ARENA_SIZEOF(h) >= (n = size + h->used)) {
607 void *ret;
(lldb) p queueing_enabled
(int) $40 = 3
frame #0: 0x000000010efa5b57 zsh-5.2-dev-2`zhalloc(size=8) + 247 at mem.c:611
608
609 h->used = n;
610 ret = arena(h) + n - size;
-> 611 unqueue_signals();
612 #ifdef ZSH_HEAP_DEBUG
613 last_heap_id = h->heap_id;
614 if (heap_debug_verbosity & HDV_ALLOC) {
(lldb) p queueing_enabled
(int) $41 = 2
frame #0: 0x000000010ef63daa zsh-5.2-dev-2`setunderscore(str="fun") + 26 at exec.c:2468
2465 setunderscore(char *str)
2466 {
2467 queue_signals();
-> 2468 if (str && *str) {
2469 int l = strlen(str) + 1, nl = (l + 31) & ~31;
2470
2471 if (nl > underscorelen || (underscorelen - nl) > 64) {
(lldb) p queueing_enabled
(int) $42 = 3
frame #0: 0x000000010ef63f15 zsh-5.2-dev-2`setunderscore(str="fun") + 389 at exec.c:2485
2482 *zunderscore = '\0';
2483 underscoreused = 1;
2484 }
-> 2485 unqueue_signals();
2486 }
2487
(lldb) p queueing_enabled
(int) $43 = 2
me #0: 0x000000010ef68bbd zsh-5.2-dev-2`execshfunc(shf=0x00007fa7ec8d3940, args=0x000000010f38b120) + 413 at exec.c:4993
4990 fflush(xtrerr);
4991 }
4992 queue_signals();
-> 4993 ocs = cmdstack;
4994 ocsp = cmdsp;
4995 cmdstack = (unsigned char *) zalloc(CMDSTACKSZ);
4996 cmdsp = 0;
(lldb) p queueing_enabled
(int) $44 = 3
frame #0: 0x000000010efa513d zsh-5.2-dev-2`zalloc(size=256) + 45 at mem.c:956
953 if (!size)
954 size = 1;
955 queue_signals();
-> 956 if (!(ptr = (void *) malloc(size))) {
957 zerr("fatal error: out of memory");
958 exit(1);
959 }
(lldb) p queueing_enabled
(int) $45 = 4
frame #0: 0x000000010efa51a2 zsh-5.2-dev-2`zalloc(size=256) + 146 at mem.c:960
957 zerr("fatal error: out of memory");
958 exit(1);
959 }
-> 960 unqueue_signals();
961
962 return ptr;
963 }
(lldb) p queueing_enabled
(int) $46 = 3
frame #0: 0x000000010efa5a96 zsh-5.2-dev-2`zhalloc(size=8) + 54 at mem.c:604
601 * but we think that nothing upstream of fheap has more free space,
602 * so why start over at heaps just because fheap has too little?
603 */
-> 604 for (h = (fheap ? fheap : heaps); h; h = h->next) {
605 hp = h;
606 if (ARENA_SIZEOF(h) >= (n = size + h->used)) {
607 void *ret;
(lldb) p queueing_enabled
(int) $47 = 4
frame #0: 0x000000010efa5b57 zsh-5.2-dev-2`zhalloc(size=8) + 247 at mem.c:611
608
609 h->used = n;
610 ret = arena(h) + n - size;
-> 611 unqueue_signals();
612 #ifdef ZSH_HEAP_DEBUG
613 last_heap_id = h->heap_id;
614 if (heap_debug_verbosity & HDV_ALLOC) {
(lldb) p queueing_enabled
(int) $48 = 3
frame #0: 0x000000010ef667a7 zsh-5.2-dev-2`doshfunc(shfunc=0x00007fa7ec8d3940, doshargs=0x000000010f38b120, noreturnval=0) + 151 at exec.c:5221
5218
5219 queue_signals(); /* Lots of memory and global state changes coming */
5220
-> 5221 NEWHEAPS(funcheap) {
5222 oargv0 = NULL;
5223 obreaks = breaks;
5224 ocontflag = contflag;
(lldb) p queueing_enabled
(int) $49 = 4
frame #0: 0x000000010efa4be6 zsh-5.2-dev-2`new_heaps + 22 at mem.c:199
196 Heap h;
197
198 queue_signals();
-> 199 h = heaps;
200
201 fheap = heaps = NULL;
202 unqueue_signals();
(lldb) p queueing_enabled
(int) $50 = 5
(lldb)
frame #0: 0x000000010efa4c38 zsh-5.2-dev-2`new_heaps + 104 at mem.c:202
199 h = heaps;
200
201 fheap = heaps = NULL;
-> 202 unqueue_signals();
203
204 #ifdef ZSH_HEAP_DEBUG
205 if (heap_debug_verbosity & HDV_NEW) {
(lldb) p queueing_enabled
(int) $51 = 4
frame #0: 0x000000010efa513d zsh-5.2-dev-2`zalloc(size=16) + 45 at mem.c:956
953 if (!size)
954 size = 1;
955 queue_signals();
-> 956 if (!(ptr = (void *) malloc(size))) {
957 zerr("fatal error: out of memory");
958 exit(1);
959 }
(lldb) p queueing_enabled
(int) $52 = 5
frame #0: 0x000000010efa51a2 zsh-5.2-dev-2`zalloc(size=16) + 146 at mem.c:960
957 zerr("fatal error: out of memory");
958 exit(1);
959 }
-> 960 unqueue_signals();
961
962 return ptr;
963 }
(lldb) p queueing_enabled
(int) $53 = 4
frame #0: 0x000000010efa5a96 zsh-5.2-dev-2`zhalloc(size=8) + 54 at mem.c:604
601 * but we think that nothing upstream of fheap has more free space,
602 * so why start over at heaps just because fheap has too little?
603 */
-> 604 for (h = (fheap ? fheap : heaps); h; h = h->next) {
605 hp = h;
606 if (ARENA_SIZEOF(h) >= (n = size + h->used)) {
607 void *ret;
(lldb) p queueing_enabled
(int) $54 = 5
frame #0: 0x000000010efa5d17 zsh-5.2-dev-2`zhalloc(size=8) + 695 at mem.c:672
669 heaps = h;
670 fheap = h;
671
-> 672 unqueue_signals();
673 #ifdef ZSH_HEAP_DEBUG
674 last_heap_id = h->heap_id;
675 if (heap_debug_verbosity & HDV_ALLOC) {
(lldb) p queueing_enabled
(int) $55 = 4
frame #0: 0x000000010efa690d zsh-5.2-dev-2`zshcalloc(size=16) + 45 at mem.c:974
971 if (!size)
972 size = 1;
973 queue_signals();
-> 974 if (!(ptr = (void *) malloc(size))) {
975 zerr("fatal error: out of memory");
976 exit(1);
977 }
(lldb) p queueing_enabled
(int) $56 = 5
frame #0: 0x000000010efa6972 zsh-5.2-dev-2`zshcalloc(size=16) + 146 at mem.c:978
975 zerr("fatal error: out of memory");
976 exit(1);
977 }
-> 978 unqueue_signals();
979 memset(ptr, 0, size);
980
981 return ptr;
(lldb) p queueing_enabled
(int) $57 = 4
frame #0: 0x000000010efa513d zsh-5.2-dev-2`zalloc(size=4) + 45 at mem.c:956
953 if (!size)
954 size = 1;
955 queue_signals();
-> 956 if (!(ptr = (void *) malloc(size))) {
957 zerr("fatal error: out of memory");
958 exit(1);
959 }
(lldb) p queueing_enabled
(int) $58 = 5
frame #0: 0x000000010efa51a2 zsh-5.2-dev-2`zalloc(size=4) + 146 at mem.c:960
957 zerr("fatal error: out of memory");
958 exit(1);
959 }
-> 960 unqueue_signals();
961
962 return ptr;
963 }
(lldb) p queueing_enabled
(int) $59 = 4
frame #0: 0x000000010efa5a96 zsh-5.2-dev-2`zhalloc(size=8) + 54 at mem.c:604
601 * but we think that nothing upstream of fheap has more free space,
602 * so why start over at heaps just because fheap has too little?
603 */
-> 604 for (h = (fheap ? fheap : heaps); h; h = h->next) {
605 hp = h;
606 if (ARENA_SIZEOF(h) >= (n = size + h->used)) {
607 void *ret;
(lldb) p queueing_enabled
(int) $60 = 5
frame #0: 0x000000010efa5b57 zsh-5.2-dev-2`zhalloc(size=8) + 247 at mem.c:611
608
609 h->used = n;
610 ret = arena(h) + n - size;
-> 611 unqueue_signals();
612 #ifdef ZSH_HEAP_DEBUG
613 last_heap_id = h->heap_id;
614 if (heap_debug_verbosity & HDV_ALLOC) {
(lldb) p queueing_enabled
(int) $61 = 4
frame #0: 0x000000010ef673ec zsh-5.2-dev-2`runshfunc(prog=0x00007fa7ec8c3b00, wrap=0x000000010f306300, name="fun") + 44 at exec.c:5488
5485
5486 queue_signals();
5487
-> 5488 ou = zalloc(ouu = underscoreused);
5489 if (ou)
5490 memcpy(ou, zunderscore, underscoreused);
5491
(lldb) p queueing_enabled
(int) $62 = 5
frame #0: 0x000000010efa513d zsh-5.2-dev-2`zalloc(size=4) + 45 at mem.c:956
953 if (!size)
954 size = 1;
955 queue_signals();
-> 956 if (!(ptr = (void *) malloc(size))) {
957 zerr("fatal error: out of memory");
958 exit(1);
959 }
(lldb) p queueing_enabled
(int) $63 = 6
frame #0: 0x000000010efa51a2 zsh-5.2-dev-2`zalloc(size=4) + 146 at mem.c:960
957 zerr("fatal error: out of memory");
958 exit(1);
959 }
-> 960 unqueue_signals();
961
962 return ptr;
963 }
(lldb) p queueing_enabled
(int) $64 = 5
frame #0: 0x000000010ef61727 zsh-5.2-dev-2`execlist(state=0x00007fff50cb4430, dont_change_job=1, exiting=0) + 55 at exec.c:1205
1202
1203 queue_signals();
1204
-> 1205 cj = thisjob;
1206 old_pline_level = pline_level;
1207 old_list_pipe = list_pipe;
1208 old_list_pipe_job = list_pipe_job;
(lldb) p queueing_enabled
(int) $65 = 6
frame #0: 0x000000010ef62892 zsh-5.2-dev-2`execpline(state=0x00007fff50cb4430, slcode=5122, how=18, last1=0) + 194 at exec.c:1514
1511 */
1512 queue_signals();
1513
-> 1514 pj = thisjob;
1515 ipipe[0] = ipipe[1] = opipe[0] = opipe[1] = 0;
1516 child_block();
1517
(lldb) p queueing_enabled
(int) $66 = 7
frame #0: 0x000000010efa5a96 zsh-5.2-dev-2`zhalloc(size=96) + 54 at mem.c:604
601 * but we think that nothing upstream of fheap has more free space,
602 * so why start over at heaps just because fheap has too little?
603 */
-> 604 for (h = (fheap ? fheap : heaps); h; h = h->next) {
605 hp = h;
606 if (ARENA_SIZEOF(h) >= (n = size + h->used)) {
607 void *ret;
(lldb) p queueing_enabled
(int) $67 = 8
frame #0: 0x000000010efa5b57 zsh-5.2-dev-2`zhalloc(size=96) + 247 at mem.c:611
608
609 h->used = n;
610 ret = arena(h) + n - size;
-> 611 unqueue_signals();
612 #ifdef ZSH_HEAP_DEBUG
613 last_heap_id = h->heap_id;
614 if (heap_debug_verbosity & HDV_ALLOC) {
(lldb) p queueing_enabled
(int) $68 = 7
frame #0: 0x000000010efa5a96 zsh-5.2-dev-2`zhalloc(size=8) + 54 at mem.c:604
601 * but we think that nothing upstream of fheap has more free space,
602 * so why start over at heaps just because fheap has too little?
603 */
-> 604 for (h = (fheap ? fheap : heaps); h; h = h->next) {
605 hp = h;
606 if (ARENA_SIZEOF(h) >= (n = size + h->used)) {
607 void *ret;
(lldb) p queueing_enabled
(int) $69 = 8
frame #0: 0x000000010efa5b57 zsh-5.2-dev-2`zhalloc(size=8) + 247 at mem.c:611
608
609 h->used = n;
610 ret = arena(h) + n - size;
-> 611 unqueue_signals();
612 #ifdef ZSH_HEAP_DEBUG
613 last_heap_id = h->heap_id;
614 if (heap_debug_verbosity & HDV_ALLOC) {
(lldb) p queueing_enabled
(int) $70 = 7
frame #0: 0x000000010efa5a96 zsh-5.2-dev-2`zhalloc(size=8) + 54 at mem.c:604
601 * but we think that nothing upstream of fheap has more free space,
602 * so why start over at heaps just because fheap has too little?
603 */
-> 604 for (h = (fheap ? fheap : heaps); h; h = h->next) {
605 hp = h;
606 if (ARENA_SIZEOF(h) >= (n = size + h->used)) {
607 void *ret;
(lldb) p queueing_enabled
(int) $71 = 8
frame #0: 0x000000010efa5b57 zsh-5.2-dev-2`zhalloc(size=8) + 247 at mem.c:611
608
609 h->used = n;
610 ret = arena(h) + n - size;
-> 611 unqueue_signals();
612 #ifdef ZSH_HEAP_DEBUG
613 last_heap_id = h->heap_id;
614 if (heap_debug_verbosity & HDV_ALLOC) {
(lldb) p queueing_enabled
(int) $72 = 7
frame #0: 0x000000010efa5a96 zsh-5.2-dev-2`zhalloc(size=8) + 54 at mem.c:604
601 * but we think that nothing upstream of fheap has more free space,
602 * so why start over at heaps just because fheap has too little?
603 */
-> 604 for (h = (fheap ? fheap : heaps); h; h = h->next) {
605 hp = h;
606 if (ARENA_SIZEOF(h) >= (n = size + h->used)) {
607 void *ret;
(lldb) p queueing_enabled
(int) $73 = 8
(lldb)
frame #0: 0x000000010efa5b57 zsh-5.2-dev-2`zhalloc(size=8) + 247 at mem.c:611
608
609 h->used = n;
610 ret = arena(h) + n - size;
-> 611 unqueue_signals();
612 #ifdef ZSH_HEAP_DEBUG
613 last_heap_id = h->heap_id;
614 if (heap_debug_verbosity & HDV_ALLOC) {
(lldb) p queueing_enabled
(int) $74 = 7
frame #0: 0x000000010ef63daa zsh-5.2-dev-2`setunderscore(str="fun") + 26 at exec.c:2468
2465 setunderscore(char *str)
2466 {
2467 queue_signals();
-> 2468 if (str && *str) {
2469 int l = strlen(str) + 1, nl = (l + 31) & ~31;
2470
2471 if (nl > underscorelen || (underscorelen - nl) > 64) {
(lldb) p queueing_enabled
(int) $75 = 8
frame #0: 0x000000010ef63f15 zsh-5.2-dev-2`setunderscore(str="fun") + 389 at exec.c:2485
2482 *zunderscore = '\0';
2483 underscoreused = 1;
2484 }
-> 2485 unqueue_signals();
2486 }
2487
(lldb) p queueing_enabled
(int) $76 = 7
frame #0: 0x000000010ef6e1c6 zsh-5.2-dev-2`execcmd(state=0x00007fff50cb4430, input=0, output=0, how=18, last1=2) + 18918 at exec.c:3782
3779 }
3780 state->pc = opc;
3781 }
-> 3782 dont_queue_signals();
3783 if (!errflag)
3784 lastval = execbuiltin(args, assigns, (Builtin) hn);
3785 if (do_save & BINF_COMMAND)
(lldb) p queueing_enabled
(int) $77 = 0
frame #0: 0x000000010efa5a96 zsh-5.2-dev-2`zhalloc(size=24) + 54 at mem.c:604
601 * but we think that nothing upstream of fheap has more free space,
602 * so why start over at heaps just because fheap has too little?
603 */
-> 604 for (h = (fheap ? fheap : heaps); h; h = h->next) {
605 hp = h;
606 if (ARENA_SIZEOF(h) >= (n = size + h->used)) {
607 void *ret;
(lldb) p queueing_enabled
(int) $78 = 1
frame #0: 0x000000010efa5b57 zsh-5.2-dev-2`zhalloc(size=24) + 247 at mem.c:611
608
609 h->used = n;
610 ret = arena(h) + n - size;
-> 611 unqueue_signals();
612 #ifdef ZSH_HEAP_DEBUG
613 last_heap_id = h->heap_id;
614 if (heap_debug_verbosity & HDV_ALLOC) {
(lldb) p queueing_enabled
(int) $79 = 0
frame #0: 0x000000010efa513d zsh-5.2-dev-2`zalloc(size=32) + 45 at mem.c:956
953 if (!size)
954 size = 1;
955 queue_signals();
-> 956 if (!(ptr = (void *) malloc(size))) {
957 zerr("fatal error: out of memory");
958 exit(1);
959 }
(lldb) p queueing_enabled
(int) $80 = 1
frame #0: 0x000000010efa51a2 zsh-5.2-dev-2`zalloc(size=32) + 146 at mem.c:960
957 zerr("fatal error: out of memory");
958 exit(1);
959 }
-> 960 unqueue_signals();
961
962 return ptr;
963 }
(lldb) p queueing_enabled
(int) $81 = 0
frame #0: 0x000000010efa513d zsh-5.2-dev-2`zalloc(size=4) + 45 at mem.c:956
953 if (!size)
954 size = 1;
955 queue_signals();
-> 956 if (!(ptr = (void *) malloc(size))) {
957 zerr("fatal error: out of memory");
958 exit(1);
959 }
(lldb) p queueing_enabled
(int) $82 = 1
frame #0: 0x000000010efa51a2 zsh-5.2-dev-2`zalloc(size=4) + 146 at mem.c:960
957 zerr("fatal error: out of memory");
958 exit(1);
959 }
-> 960 unqueue_signals();
961
962 return ptr;
963 }
(lldb) p queueing_enabled
(int) $83 = 0
frame #0: 0x000000010efa513d zsh-5.2-dev-2`zalloc(size=16) + 45 at mem.c:956
953 if (!size)
954 size = 1;
955 queue_signals();
-> 956 if (!(ptr = (void *) malloc(size))) {
957 zerr("fatal error: out of memory");
958 exit(1);
959 }
(lldb) p queueing_enabled
(int) $84 = 1
frame #0: 0x000000010efa51a2 zsh-5.2-dev-2`zalloc(size=16) + 146 at mem.c:960
957 zerr("fatal error: out of memory");
958 exit(1);
959 }
-> 960 unqueue_signals();
961
962 return ptr;
963 }
(lldb) p queueing_enabled
(int) $85 = 0
frame #0: 0x000000010efa513d zsh-5.2-dev-2`zalloc(size=24) + 45 at mem.c:956
953 if (!size)
954 size = 1;
955 queue_signals();
-> 956 if (!(ptr = (void *) malloc(size))) {
957 zerr("fatal error: out of memory");
958 exit(1);
959 }
(lldb) p queueing_enabled
(int) $86 = 1
frame #0: 0x000000010efa51a2 zsh-5.2-dev-2`zalloc(size=24) + 146 at mem.c:960
957 zerr("fatal error: out of memory");
958 exit(1);
959 }
-> 960 unqueue_signals();
961
962 return ptr;
963 }
(lldb) p queueing_enabled
(int) $87 = 0
frame #0: 0x000000010ef6e2d9 zsh-5.2-dev-2`execcmd(state=0x00007fff50cb4430, input=0, output=0, how=18, last1=2) + 19193 at exec.c:3788
3785 if (do_save & BINF_COMMAND)
3786 errflag &= ~ERRFLAG_ERROR;
3787 restore_queue_signals(q);
-> 3788 fflush(stdout);
3789 if (save[1] == -2) {
3790 if (ferror(stdout)) {
3791 zwarn("write error: %e", errno);
(lldb) p queueing_enabled
(int) $88 = 7
frame #0: 0x000000010ef6376e zsh-5.2-dev-2`execpline(state=0x00007fff50cb4430, slcode=5122, how=18, last1=0) + 3998 at exec.c:1779
1776 break;
1777 }
1778 child_unblock();
-> 1779 unqueue_signals();
1780
1781 if (list_pipe && (lastval & 0200) && pj >= 0 &&
1782 (!(jn->stat & STAT_INUSE) || (jn->stat & STAT_DONE))) {
(lldb) p queueing_enabled
(int) $89 = 6
frame #0: 0x000000010ef62439 zsh-5.2-dev-2`execlist(state=0x00007fff50cb4430, dont_change_job=1, exiting=0) + 3401 at exec.c:1477
1474 sigtrapped[SIGEXIT] = 0;
1475 }
1476
-> 1477 unqueue_signals();
1478 }
1479
(lldb) p queueing_enabled
(int) $90 = 5
frame #0: 0x000000010ef63daa zsh-5.2-dev-2`setunderscore(str="fun") + 26 at exec.c:2468
2465 setunderscore(char *str)
2466 {
2467 queue_signals();
-> 2468 if (str && *str) {
2469 int l = strlen(str) + 1, nl = (l + 31) & ~31;
2470
2471 if (nl > underscorelen || (underscorelen - nl) > 64) {
(lldb) p queueing_enabled
(int) $91 = 6
frame #0: 0x000000010ef63f15 zsh-5.2-dev-2`setunderscore(str="fun") + 389 at exec.c:2485
2482 *zunderscore = '\0';
2483 underscoreused = 1;
2484 }
-> 2485 unqueue_signals();
2486 }
2487
(lldb) p queueing_enabled
(int) $92 = 5
frame #0: 0x000000010efbd9a4 zsh-5.2-dev-2`endparamscope + 36 at params.c:5087
5084 endparamscope(void)
5085 {
5086 queue_signals();
-> 5087 locallevel--;
5088 /* This pops anything from a higher locallevel */
5089 saveandpophiststack(0, HFILE_USE_OPTIONS);
5090 scanhashtable(paramtab, 0, 0, 0, scanendscope, 0);
(lldb) p queueing_enabled
(int) $93 = 6
frame #0: 0x000000010efbda0b zsh-5.2-dev-2`endparamscope + 139 at params.c:5091
5088 /* This pops anything from a higher locallevel */
5089 saveandpophiststack(0, HFILE_USE_OPTIONS);
5090 scanhashtable(paramtab, 0, 0, 0, scanendscope, 0);
-> 5091 unqueue_signals();
5092 }
5093
5094 /**/
(lldb) p queueing_enabled
(int) $94 = 5
frame #0: 0x000000010ef67561 zsh-5.2-dev-2`runshfunc(prog=0x00007fa7ec8c3b00, wrap=0x0000000000000000, name="fun") + 417 at exec.c:5516
5513 }
5514 endparamscope();
5515
-> 5516 unqueue_signals();
5517 }
5518
(lldb) p queueing_enabled
(int) $95 = 4
frame #0: 0x000000010efa4d0a zsh-5.2-dev-2`old_heaps(old=0x000000010f38b000) + 26 at mem.c:225
222 Heap h, n;
223
224 queue_signals();
-> 225 for (h = heaps; h; h = n) {
226 n = h->next;
227 DPUTS(h->sp, "BUG: old_heaps() with pushed heaps");
228 #ifdef ZSH_HEAP_DEBUG
(lldb) p queueing_enabled
(int) $96 = 5
frame #0: 0x000000010efa4db8 zsh-5.2-dev-2`old_heaps(old=0x000000010f38b000) + 200 at mem.c:260
257 }
258 #endif
259 fheap = NULL;
-> 260 unqueue_signals();
261 }
262
263 /* Temporarily switch to other heaps (or back again). */
(lldb) p queueing_enabled
(int) $97 = 4
frame #0: 0x000000010ef67239 zsh-5.2-dev-2`doshfunc(shfunc=0x00007fa7ec8d3940, doshargs=0x000000010f38b120, noreturnval=0) + 2857 at exec.c:5446
5443 }
5444 } OLDHEAPS;
5445
-> 5446 unqueue_signals();
5447
(lldb) p queueing_enabled
(int) $98 = 3
frame #0: 0x000000010ef68cb3 zsh-5.2-dev-2`execshfunc(shf=0x00007fa7ec8d3940, args=0x000000010f38b120) + 659 at exec.c:5010
5007
5008 if (!list_pipe)
5009 deletefilelist(last_file_list, 0);
-> 5010 unqueue_signals();
5011 }
5012
(lldb) p queueing_enabled
(int) $99 = 2
frame #0: 0x000000010ef62439 zsh-5.2-dev-2`execlist(state=0x00007fff50cb51f0, dont_change_job=0, exiting=0) + 3401 at exec.c:1477
1474 sigtrapped[SIGEXIT] = 0;
1475 }
1476
-> 1477 unqueue_signals();
1478 }
1479
(lldb) p queueing_enabled
(int) $100 = 1
frame #0: 0x000000010efa55ce zsh-5.2-dev-2`popheap + 30 at mem.c:454
451 h_pop++;
452 #endif
453
-> 454 fheap = NULL;
455 for (h = heaps; h; h = hn) {
456 hn = h->next;
457 if ((hs = h->sp)) {
(lldb) p queueing_enabled
(int) $101 = 2
frame #0: 0x000000010efa57f4 zsh-5.2-dev-2`popheap + 580 at mem.c:516
513 else
514 heaps = NULL;
515
-> 516 unqueue_signals();
517 }
518
519 #ifdef USE_MMAP
(lldb) p queueing_enabled
(int) $102 = 1
frame #0: 0x000000010efa4f96 zsh-5.2-dev-2`pushheap + 22 at mem.c:302
299 h_push++;
300 #endif
301
-> 302 for (h = heaps; h; h = h->next) {
303 DPUTS(!h->used && h->next, "BUG: empty heap");
304 hs = (Heapstack) zalloc(sizeof(*hs));
305 hs->next = h->sp;
(lldb) p queueing_enabled
(int) $103 = 2
frame #0: 0x000000010efa513d zsh-5.2-dev-2`zalloc(size=16) + 45 at mem.c:956
953 if (!size)
954 size = 1;
955 queue_signals();
-> 956 if (!(ptr = (void *) malloc(size))) {
957 zerr("fatal error: out of memory");
958 exit(1);
959 }
(lldb) p queueing_enabled
(int) $104 = 3
frame #0: 0x000000010efa51a2 zsh-5.2-dev-2`zalloc(size=16) + 146 at mem.c:960
957 zerr("fatal error: out of memory");
958 exit(1);
959 }
-> 960 unqueue_signals();
961
962 return ptr;
963 }
(lldb) p queueing_enabled
(int) $105 = 2
frame #0: 0x000000010efa505d zsh-5.2-dev-2`pushheap + 221 at mem.c:318
315 }
316 #endif
317 }
-> 318 unqueue_signals();
319 }
320
321 /* reset heaps to previous state */
(lldb) p queueing_enabled
(int) $106 = 1
frame #0: 0x000000010ef60200 zsh-5.2-dev-2`zcontext_save_partial(parts=7) + 32 at context.c:58
55
56 queue_signals();
57
-> 58 cs = (struct context_stack *)malloc(sizeof(struct context_stack));
59
60 if (parts & ZCONTEXT_HIST) {
61 hist_context_save(&cs->hist_stack, !cstack);
(lldb) p queueing_enabled
(int) $107 = 2
frame #0: 0x000000010efa513d zsh-5.2-dev-2`zalloc(size=256) + 45 at mem.c:956
953 if (!size)
954 size = 1;
955 queue_signals();
-> 956 if (!(ptr = (void *) malloc(size))) {
957 zerr("fatal error: out of memory");
958 exit(1);
959 }
(lldb) p queueing_enabled
(int) $108 = 3
frame #0: 0x000000010efa51a2 zsh-5.2-dev-2`zalloc(size=256) + 146 at mem.c:960
957 zerr("fatal error: out of memory");
958 exit(1);
959 }
-> 960 unqueue_signals();
961
962 return ptr;
963 }
(lldb) p queueing_enabled
(int) $109 = 2
frame #0: 0x000000010ef602f1 zsh-5.2-dev-2`zcontext_save_partial(parts=7) + 273 at context.c:73
70 cs->next = cstack;
71 cstack = cs;
72
-> 73 unqueue_signals();
74 }
75
76 /* save context in full */
(lldb) p queueing_enabled
(int) $110 = 1
frame #0: 0x000000010ef90974 zsh-5.2-dev-2`inputsetline(str="fun", flags=64) + 36 at input.c:386
383 {
384 queue_signals();
385
-> 386 if ((inbufflags & INP_FREE) && inbuf) {
387 free(inbuf);
388 }
389 inbuf = inbufptr = str;
(lldb) p queueing_enabled
(int) $111 = 2
frame #0: 0x000000010ef90a33 zsh-5.2-dev-2`inputsetline(str="fun", flags=64) + 227 at input.c:404
401 inbufct = inbufleft;
402 inbufflags = flags;
403
-> 404 unqueue_signals();
405 }
406
(lldb) p queueing_enabled
(int) $112 = 1
frame #0: 0x000000010efbe9ed zsh-5.2-dev-2`init_parse + 29 at parse.c:469
466 {
467 queue_signals();
468
-> 469 if (ecbuf) zfree(ecbuf, eclen);
470
471 ecbuf = (Wordcode) zalloc((eclen = EC_INIT_SIZE) * sizeof(wordcode));
472 ecused = 0;
(lldb) p queueing_enabled
(int) $113 = 2
frame #0: 0x000000010efa513d zsh-5.2-dev-2`zalloc(size=1024) + 45 at mem.c:956
953 if (!size)
954 size = 1;
955 queue_signals();
-> 956 if (!(ptr = (void *) malloc(size))) {
957 zerr("fatal error: out of memory");
958 exit(1);
959 }
(lldb) p queueing_enabled
(int) $114 = 3
frame #0: 0x000000010efa51a2 zsh-5.2-dev-2`zalloc(size=1024) + 146 at mem.c:960
957 zerr("fatal error: out of memory");
958 exit(1);
959 }
-> 960 unqueue_signals();
961
962 return ptr;
963 }
(lldb) p queueing_enabled
(int) $115 = 2
frame #0: 0x000000010efbeabb zsh-5.2-dev-2`init_parse + 235 at parse.c:480
477
478 init_parse_status();
479
-> 480 unqueue_signals();
481 }
482
483 /* Build eprog. */
(lldb) p queueing_enabled
(int) $116 = 1
frame #0: 0x000000010efa5a96 zsh-5.2-dev-2`zhalloc(size=32) + 54 at mem.c:604
601 * but we think that nothing upstream of fheap has more free space,
602 * so why start over at heaps just because fheap has too little?
603 */
-> 604 for (h = (fheap ? fheap : heaps); h; h = h->next) {
605 hp = h;
606 if (ARENA_SIZEOF(h) >= (n = size + h->used)) {
607 void *ret;
(lldb) p queueing_enabled
(int) $117 = 2
frame #0: 0x000000010efa5b57 zsh-5.2-dev-2`zhalloc(size=32) + 247 at mem.c:611
608
609 h->used = n;
610 ret = arena(h) + n - size;
-> 611 unqueue_signals();
612 #ifdef ZSH_HEAP_DEBUG
613 last_heap_id = h->heap_id;
614 if (heap_debug_verbosity & HDV_ALLOC) {
(lldb) p queueing_enabled
(int) $118 = 1
frame #0: 0x000000010efa5a96 zsh-5.2-dev-2`zhalloc(size=8) + 54 at mem.c:604
601 * but we think that nothing upstream of fheap has more free space,
602 * so why start over at heaps just because fheap has too little?
603 */
-> 604 for (h = (fheap ? fheap : heaps); h; h = h->next) {
605 hp = h;
606 if (ARENA_SIZEOF(h) >= (n = size + h->used)) {
607 void *ret;
(lldb) p queueing_enabled
(int) $119 = 2
frame #0: 0x000000010efa5b57 zsh-5.2-dev-2`zhalloc(size=8) + 247 at mem.c:611
608
609 h->used = n;
610 ret = arena(h) + n - size;
-> 611 unqueue_signals();
612 #ifdef ZSH_HEAP_DEBUG
613 last_heap_id = h->heap_id;
614 if (heap_debug_verbosity & HDV_ALLOC) {
(lldb) p queueing_enabled
(int) $120 = 1
frame #0: 0x000000010efbef8b zsh-5.2-dev-2`bld_eprog(heap=1) + 27 at parse.c:505
502
503 queue_signals();
504
-> 505 ecadd(WCB_END());
506
507 ret = heap ? (Eprog) zhalloc(sizeof(*ret)) : (Eprog) zalloc(sizeof(*ret));
508 ret->len = ((ecnpats * sizeof(Patprog)) +
(lldb) p queueing_enabled
(int) $121 = 2
frame #0: 0x000000010efa5a96 zsh-5.2-dev-2`zhalloc(size=56) + 54 at mem.c:604
601 * but we think that nothing upstream of fheap has more free space,
602 * so why start over at heaps just because fheap has too little?
603 */
-> 604 for (h = (fheap ? fheap : heaps); h; h = h->next) {
605 hp = h;
606 if (ARENA_SIZEOF(h) >= (n = size + h->used)) {
607 void *ret;
(lldb) p queueing_enabled
(int) $122 = 3
frame #0: 0x000000010efa5b57 zsh-5.2-dev-2`zhalloc(size=56) + 247 at mem.c:611
608
609 h->used = n;
610 ret = arena(h) + n - size;
-> 611 unqueue_signals();
612 #ifdef ZSH_HEAP_DEBUG
613 last_heap_id = h->heap_id;
614 if (heap_debug_verbosity & HDV_ALLOC) {
(lldb) p queueing_enabled
(int) $123 = 2
frame #0: 0x000000010efa5a96 zsh-5.2-dev-2`zhalloc(size=24) + 54 at mem.c:604
601 * but we think that nothing upstream of fheap has more free space,
602 * so why start over at heaps just because fheap has too little?
603 */
-> 604 for (h = (fheap ? fheap : heaps); h; h = h->next) {
605 hp = h;
606 if (ARENA_SIZEOF(h) >= (n = size + h->used)) {
607 void *ret;
(lldb) p queueing_enabled
(int) $124 = 3
frame #0: 0x000000010efa5b57 zsh-5.2-dev-2`zhalloc(size=24) + 247 at mem.c:611
608
609 h->used = n;
610 ret = arena(h) + n - size;
-> 611 unqueue_signals();
612 #ifdef ZSH_HEAP_DEBUG
613 last_heap_id = h->heap_id;
614 if (heap_debug_verbosity & HDV_ALLOC) {
(lldb) p queueing_enabled
(int) $125 = 2
frame #0: 0x000000010efbf1bc zsh-5.2-dev-2`bld_eprog(heap=1) + 588 at parse.c:528
525 zfree(ecbuf, eclen);
526 ecbuf = NULL;
527
-> 528 unqueue_signals();
529
530 return ret;
531 }
(lldb) p queueing_enabled
(int) $126 = 1
frame #0: 0x000000010ef8106d zsh-5.2-dev-2`hend(prog=0x0000000000000000) + 125 at hist.c:1395
1392 DPUTS(stophist != 2 && !(inbufflags & INP_ALIAS) && !chline,
1393 "BUG: chline is NULL in hend()");
1394 queue_signals();
-> 1395 if (histdone & HISTFLAG_SETTY)
1396 settyinfo(&shttyinfo);
1397 if (!(histactive & HA_NOINC))
1398 unlinkcurline();
(lldb) p queueing_enabled
(int) $127 = 2
frame #0: 0x000000010ef81158 zsh-5.2-dev-2`hend(prog=0x0000000000000000) + 360 at hist.c:1405
1402 chline = hptr = NULL;
1403 chwords = NULL;
1404 histactive = 0;
-> 1405 unqueue_signals();
1406 return 1;
1407 }
1408 if (hist_ignore_all_dups != isset(HISTIGNOREALLDUPS)
(lldb) p queueing_enabled
(int) $128 = 1
frame #0: 0x000000010ef603f5 zsh-5.2-dev-2`zcontext_restore_partial(parts=7) + 69 at context.c:96
93 DPUTS(!cstack, "BUG: zcontext_restore() without zcontext_save()");
94
95 queue_signals();
-> 96 cstack = cstack->next;
97
98 if (parts & ZCONTEXT_HIST) {
99 hist_context_restore(&cs->hist_stack, !cstack);
(lldb) p queueing_enabled
(int) $129 = 2
frame #0: 0x000000010ef604de zsh-5.2-dev-2`zcontext_restore_partial(parts=7) + 302 at context.c:110
107
108 free(cs);
109
-> 110 unqueue_signals();
111 }
112
113 /* restore full context */
(lldb) p queueing_enabled
(int) $130 = 1
frame #0: 0x000000010ef61727 zsh-5.2-dev-2`execlist(state=0x00007fff50cb51f0, dont_change_job=0, exiting=0) + 55 at exec.c:1205
1202
1203 queue_signals();
1204
-> 1205 cj = thisjob;
1206 old_pline_level = pline_level;
1207 old_list_pipe = list_pipe;
1208 old_list_pipe_job = list_pipe_job;
(lldb) p queueing_enabled
(int) $131 = 2
frame #0: 0x000000010ef62892 zsh-5.2-dev-2`execpline(state=0x00007fff50cb51f0, slcode=3074, how=18, last1=0) + 194 at exec.c:1514
1511 */
1512 queue_signals();
1513
-> 1514 pj = thisjob;
1515 ipipe[0] = ipipe[1] = opipe[0] = opipe[1] = 0;
1516 child_block();
1517
(lldb) p queueing_enabled
(int) $132 = 3
frame #0: 0x000000010efa5a96 zsh-5.2-dev-2`zhalloc(size=48) + 54 at mem.c:604
601 * but we think that nothing upstream of fheap has more free space,
602 * so why start over at heaps just because fheap has too little?
603 */
-> 604 for (h = (fheap ? fheap : heaps); h; h = h->next) {
605 hp = h;
606 if (ARENA_SIZEOF(h) >= (n = size + h->used)) {
607 void *ret;
(lldb) p queueing_enabled
(int) $133 = 4
frame #0: 0x000000010efa5b57 zsh-5.2-dev-2`zhalloc(size=48) + 247 at mem.c:611
608
609 h->used = n;
610 ret = arena(h) + n - size;
-> 611 unqueue_signals();
612 #ifdef ZSH_HEAP_DEBUG
613 last_heap_id = h->heap_id;
614 if (heap_debug_verbosity & HDV_ALLOC) {
(lldb) p queueing_enabled
(int) $134 = 3
frame #0: 0x000000010efa5a96 zsh-5.2-dev-2`zhalloc(size=8) + 54 at mem.c:604
601 * but we think that nothing upstream of fheap has more free space,
602 * so why start over at heaps just because fheap has too little?
603 */
-> 604 for (h = (fheap ? fheap : heaps); h; h = h->next) {
605 hp = h;
606 if (ARENA_SIZEOF(h) >= (n = size + h->used)) {
607 void *ret;
(lldb) p queueing_enabled
(int) $135 = 4
frame #0: 0x000000010efa5b57 zsh-5.2-dev-2`zhalloc(size=8) + 247 at mem.c:611
608
609 h->used = n;
610 ret = arena(h) + n - size;
-> 611 unqueue_signals();
612 #ifdef ZSH_HEAP_DEBUG
613 last_heap_id = h->heap_id;
614 if (heap_debug_verbosity & HDV_ALLOC) {
(lldb) p queueing_enabled
(int) $136 = 3
frame #0: 0x000000010ef63daa zsh-5.2-dev-2`setunderscore(str="fun") + 26 at exec.c:2468
2465 setunderscore(char *str)
2466 {
2467 queue_signals();
-> 2468 if (str && *str) {
2469 int l = strlen(str) + 1, nl = (l + 31) & ~31;
2470
2471 if (nl > underscorelen || (underscorelen - nl) > 64) {
(lldb) p queueing_enabled
(int) $137 = 4
frame #0: 0x000000010ef63f15 zsh-5.2-dev-2`setunderscore(str="fun") + 389 at exec.c:2485
2482 *zunderscore = '\0';
2483 underscoreused = 1;
2484 }
-> 2485 unqueue_signals();
2486 }
2487
(lldb) p queueing_enabled
(int) $138 = 3
frame #0: 0x000000010ef68bbd zsh-5.2-dev-2`execshfunc(shf=0x00007fa7ec8d3940, args=0x000000010f38b120) + 413 at exec.c:4993
4990 fflush(xtrerr);
4991 }
4992 queue_signals();
-> 4993 ocs = cmdstack;
4994 ocsp = cmdsp;
4995 cmdstack = (unsigned char *) zalloc(CMDSTACKSZ);
4996 cmdsp = 0;
(lldb) p queueing_enabled
(int) $139 = 4
frame #0: 0x000000010efa513d zsh-5.2-dev-2`zalloc(size=256) + 45 at mem.c:956
953 if (!size)
954 size = 1;
955 queue_signals();
-> 956 if (!(ptr = (void *) malloc(size))) {
957 zerr("fatal error: out of memory");
958 exit(1);
959 }
(lldb) p queueing_enabled
(int) $140 = 5
frame #0: 0x000000010efa51a2 zsh-5.2-dev-2`zalloc(size=256) + 146 at mem.c:960
957 zerr("fatal error: out of memory");
958 exit(1);
959 }
-> 960 unqueue_signals();
961
962 return ptr;
963 }
(lldb) p queueing_enabled
(int) $141 = 4
frame #0: 0x000000010efa5a96 zsh-5.2-dev-2`zhalloc(size=8) + 54 at mem.c:604
601 * but we think that nothing upstream of fheap has more free space,
602 * so why start over at heaps just because fheap has too little?
603 */
-> 604 for (h = (fheap ? fheap : heaps); h; h = h->next) {
605 hp = h;
606 if (ARENA_SIZEOF(h) >= (n = size + h->used)) {
607 void *ret;
(lldb) p queueing_enabled
(int) $142 = 5
frame #0: 0x000000010efa5b57 zsh-5.2-dev-2`zhalloc(size=8) + 247 at mem.c:611
608
609 h->used = n;
610 ret = arena(h) + n - size;
-> 611 unqueue_signals();
612 #ifdef ZSH_HEAP_DEBUG
613 last_heap_id = h->heap_id;
614 if (heap_debug_verbosity & HDV_ALLOC) {
(lldb) p queueing_enabled
(int) $143 = 4
frame #0: 0x000000010ef667a7 zsh-5.2-dev-2`doshfunc(shfunc=0x00007fa7ec8d3940, doshargs=0x000000010f38b120, noreturnval=0) + 151 at exec.c:5221
5218
5219 queue_signals(); /* Lots of memory and global state changes coming */
5220
-> 5221 NEWHEAPS(funcheap) {
5222 oargv0 = NULL;
5223 obreaks = breaks;
5224 ocontflag = contflag;
(lldb) p queueing_enabled
(int) $144 = 5
frame #0: 0x000000010efa4be6 zsh-5.2-dev-2`new_heaps + 22 at mem.c:199
196 Heap h;
197
198 queue_signals();
-> 199 h = heaps;
200
201 fheap = heaps = NULL;
202 unqueue_signals();
(lldb) p queueing_enabled
(int) $145 = 6
// vim:ft=c
Messages sorted by:
Reverse Date,
Date,
Thread,
Author