Zsh Mailing List Archive
Messages sorted by: Reverse Date, Date, Thread, Author

Re: [BUG] queueing_enabled grows infinitely when in .recursive-edit



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