src/core/ngx_cycle.c:929: error: Integer Overflow L2
  ([0, +oo] - 3):unsigned64 by call to `ngx_slab_init`.

src/core/ngx_cycle.c:907:5: Assignment
905. 
906.     sp->end = zn->shm.addr + zn->shm.size;
907.     sp->min_shift = 3;
         ^
908.     sp->addr = zn->shm.addr;
909. 

src/core/ngx_cycle.c:929:5: Call
927.     }
928. 
929.     ngx_slab_init(sp);
         ^
930. 
931.     return NGX_OK;

src/core/ngx_slab.c:85:1: <LHS trace>
83. 
84. 
85. void
    ^
86. ngx_slab_init(ngx_slab_pool_t *pool)
87. {

src/core/ngx_slab.c:85:1: Global `ngx_pagesize_shift`
  83. 
  84. 
  85. void
      ^
  86. ngx_slab_init(ngx_slab_pool_t *pool)
  87. {

src/core/ngx_slab.c:85:1: <RHS trace>
83. 
84. 
85. void
    ^
86. ngx_slab_init(ngx_slab_pool_t *pool)
87. {

src/core/ngx_slab.c:85:1: Parameter `pool->min_shift`
  83. 
  84. 
  85. void
      ^
  86. ngx_slab_init(ngx_slab_pool_t *pool)
  87. {

src/core/ngx_slab.c:113:5: Binary operation: ([0, +oo] - 3):unsigned64 by call to `ngx_slab_init` 
  111.     ngx_slab_junk(p, size);
  112. 
  113.     n = ngx_pagesize_shift - pool->min_shift;
           ^
  114. 
  115.     for (i = 0; i < n; i++) {

void
ngx_slab_init(ngx_slab_pool_t *pool)
{
    u_char           *p;
    size_t            size;
    ngx_int_t         m;
    ngx_uint_t        i, n, pages;
    ngx_slab_page_t  *slots, *page;
    if (ngx_slab_max_size == 0) {
        ngx_slab_max_size = ngx_pagesize / 2;
        ngx_slab_exact_size = ngx_pagesize / (8 * sizeof(uintptr_t));
        for (n = ngx_slab_exact_size; n >>= 1; ngx_slab_exact_shift++) {
        }
    }
    pool->min_size = 1 << pool->min_shift;
    slots = ngx_slab_slots(pool);
    p = (u_char *) slots;
    size = pool->end - p;
    ngx_slab_junk(p, size);
    n = ngx_pagesize_shift - pool->min_shift;
    for (i = 0; i < n; i++) {
        slots[i].slab = 0;
        slots[i].next = &slots[i];
        slots[i].prev = 0;
    }
    p += n * sizeof(ngx_slab_page_t);
    pool->stats = (ngx_slab_stat_t *) p;
    ngx_memzero(pool->stats, n * sizeof(ngx_slab_stat_t));
    p += n * sizeof(ngx_slab_stat_t);
    size -= n * (sizeof(ngx_slab_page_t) + sizeof(ngx_slab_stat_t));
    pages = (ngx_uint_t) (size / (ngx_pagesize + sizeof(ngx_slab_page_t)));
    pool->pages = (ngx_slab_page_t *) p;
    ngx_memzero(pool->pages, pages * sizeof(ngx_slab_page_t));
    page = pool->pages;
    pool->free.slab = 0;
    pool->free.next = page;
    pool->free.prev = 0;
    page->slab = pages;
    page->next = &pool->free;
    page->prev = (uintptr_t) &pool->free;
    pool->start = ngx_align_ptr(p + pages * sizeof(ngx_slab_page_t),
                                ngx_pagesize);
    m = pages - (pool->end - pool->start) / ngx_pagesize;
    if (m > 0) {
        pages -= m;
        page->slab = pages;
    }
    pool->last = pool->pages + pages;
    pool->pfree = pages;
    pool->log_nomem = 1;
    pool->log_ctx = &pool->zero;
    pool->zero = '\0';
}
['static ngx_int_t\nngx_init_zone_pool(ngx_cycle_t *cycle, ngx_shm_zone_t *zn)\n{\n    u_char           *file;\n    ngx_slab_pool_t  *sp;\n    sp = (ngx_slab_pool_t *) zn->shm.addr;\n    if (zn->shm.exists) {\n        if (sp == sp->addr) {\n            return NGX_OK;\n        }\n#if (NGX_WIN32)\n        if (ngx_shm_remap(&zn->shm, sp->addr) != NGX_OK) {\n            return NGX_ERROR;\n        }\n        sp = (ngx_slab_pool_t *) zn->shm.addr;\n        if (sp == sp->addr) {\n            return NGX_OK;\n        }\n#endif\n        ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,\n                      "shared zone \\"%V\\" has no equal addresses: %p vs %p",\n                      &zn->shm.name, sp->addr, sp);\n        return NGX_ERROR;\n    }\n    sp->end = zn->shm.addr + zn->shm.size;\n    sp->min_shift = 3;\n    sp->addr = zn->shm.addr;\n#if (NGX_HAVE_ATOMIC_OPS)\n    file = NULL;\n#else\n    file = ngx_pnalloc(cycle->pool, cycle->lock_file.len + zn->shm.name.len);\n    if (file == NULL) {\n        return NGX_ERROR;\n    }\n    (void) ngx_sprintf(file, "%V%V%Z", &cycle->lock_file, &zn->shm.name);\n#endif\n    if (ngx_shmtx_create(&sp->mutex, &sp->lock, file) != NGX_OK) {\n        return NGX_ERROR;\n    }\n    ngx_slab_init(sp);\n    return NGX_OK;\n}', "void\nngx_slab_init(ngx_slab_pool_t *pool)\n{\n    u_char           *p;\n    size_t            size;\n    ngx_int_t         m;\n    ngx_uint_t        i, n, pages;\n    ngx_slab_page_t  *slots, *page;\n    if (ngx_slab_max_size == 0) {\n        ngx_slab_max_size = ngx_pagesize / 2;\n        ngx_slab_exact_size = ngx_pagesize / (8 * sizeof(uintptr_t));\n        for (n = ngx_slab_exact_size; n >>= 1; ngx_slab_exact_shift++) {\n        }\n    }\n    pool->min_size = 1 << pool->min_shift;\n    slots = ngx_slab_slots(pool);\n    p = (u_char *) slots;\n    size = pool->end - p;\n    ngx_slab_junk(p, size);\n    n = ngx_pagesize_shift - pool->min_shift;\n    for (i = 0; i < n; i++) {\n        slots[i].slab = 0;\n        slots[i].next = &slots[i];\n        slots[i].prev = 0;\n    }\n    p += n * sizeof(ngx_slab_page_t);\n    pool->stats = (ngx_slab_stat_t *) p;\n    ngx_memzero(pool->stats, n * sizeof(ngx_slab_stat_t));\n    p += n * sizeof(ngx_slab_stat_t);\n    size -= n * (sizeof(ngx_slab_page_t) + sizeof(ngx_slab_stat_t));\n    pages = (ngx_uint_t) (size / (ngx_pagesize + sizeof(ngx_slab_page_t)));\n    pool->pages = (ngx_slab_page_t *) p;\n    ngx_memzero(pool->pages, pages * sizeof(ngx_slab_page_t));\n    page = pool->pages;\n    pool->free.slab = 0;\n    pool->free.next = page;\n    pool->free.prev = 0;\n    page->slab = pages;\n    page->next = &pool->free;\n    page->prev = (uintptr_t) &pool->free;\n    pool->start = ngx_align_ptr(p + pages * sizeof(ngx_slab_page_t),\n                                ngx_pagesize);\n    m = pages - (pool->end - pool->start) / ngx_pagesize;\n    if (m > 0) {\n        pages -= m;\n        page->slab = pages;\n    }\n    pool->last = pool->pages + pages;\n    pool->pfree = pages;\n    pool->log_nomem = 1;\n    pool->log_ctx = &pool->zero;\n    pool->zero = '\\0';\n}"]