apps/speed.c:688: error: INTEGER_OVERFLOW_L2
  ([1, +oo] - [-oo, 63]):unsigned64 by call to `SHA256`.
Showing all 9 steps of the trace


apps/speed.c:688:9: Call
686.       int count;
687.       for (count = 0; COND(c[D_SHA256][testnum]); count++)
688.           SHA256(buf, lengths[testnum], sha256);
               ^
689.       return count;
690.   }

crypto/sha/sha256.c:63:1: Parameter `n`
  61.   }
  62.   
  63. > unsigned char *SHA256(const unsigned char *d, size_t n, unsigned char *md)
  64.   {
  65.       SHA256_CTX c;

crypto/sha/sha256.c:71:5: Call
  69.           md = m;
  70.       SHA256_Init(&c);
  71.       SHA256_Update(&c, d, n);
            ^
  72.       SHA256_Final(md, &c);
  73.       OPENSSL_cleanse(&c, sizeof(c));

crypto/include/internal/md32_common.h:246:1: <LHS trace>
244.    */
245.   
246. > int HASH_UPDATE(HASH_CTX *c, const void *data_, size_t len)
247.   {
248.       const unsigned char *data = data_;

crypto/include/internal/md32_common.h:246:1: Parameter `len`
    244.    */
    245.   
    246. > int HASH_UPDATE(HASH_CTX *c, const void *data_, size_t len)
    247.   {
    248.       const unsigned char *data = data_;

crypto/include/internal/md32_common.h:246:1: <RHS trace>
244.    */
245.   
246. > int HASH_UPDATE(HASH_CTX *c, const void *data_, size_t len)
247.   {
248.       const unsigned char *data = data_;

crypto/include/internal/md32_common.h:246:1: Parameter `len`
    244.    */
    245.   
    246. > int HASH_UPDATE(HASH_CTX *c, const void *data_, size_t len)
    247.   {
    248.       const unsigned char *data = data_;

crypto/include/internal/md32_common.h:270:13: Assignment
    268.               memcpy(p + n, data, HASH_CBLOCK - n);
    269.               HASH_BLOCK_DATA_ORDER(c, p, 1);
    270.               n = HASH_CBLOCK - n;
                       ^
    271.               data += n;
    272.               len -= n;

crypto/include/internal/md32_common.h:272:13: Binary operation: ([1, +oo] - [-oo, 63]):unsigned64 by call to `SHA256` 
    270.               n = HASH_CBLOCK - n;
    271.               data += n;
    272.               len -= n;
                       ^
    273.               c->num = 0;
    274.               /*

int HASH_UPDATE(HASH_CTX *c, const void *data_, size_t len)
{
    const unsigned char *data = data_;
    unsigned char *p;
    HASH_LONG l;
    size_t n;
    if (len == 0)
        return 1;
    l = (c->Nl + (((HASH_LONG) len) << 3)) & 0xffffffffUL;
    if (l < c->Nl)
        c->Nh++;
    c->Nh += (HASH_LONG) (len >> 29);
    c->Nl = l;
    n = c->num;
    if (n != 0) {
        p = (unsigned char *)c->data;
        if (len >= HASH_CBLOCK || len + n >= HASH_CBLOCK) {
            memcpy(p + n, data, HASH_CBLOCK - n);
            HASH_BLOCK_DATA_ORDER(c, p, 1);
            n = HASH_CBLOCK - n;
            data += n;
            len -= n;
            c->num = 0;
            memset(p, 0, HASH_CBLOCK);
        } else {
            memcpy(p + n, data, len);
            c->num += (unsigned int)len;
            return 1;
        }
    }
    n = len / HASH_CBLOCK;
    if (n > 0) {
        HASH_BLOCK_DATA_ORDER(c, data, n);
        n *= HASH_CBLOCK;
        data += n;
        len -= n;
    }
    if (len != 0) {
        p = (unsigned char *)c->data;
        c->num = (unsigned int)len;
        memcpy(p, data, len);
    }
    return 1;
}
['static int SHA256_loop(void *args)\n{\n    loopargs_t *tempargs = *(loopargs_t **) args;\n    unsigned char *buf = tempargs->buf;\n    unsigned char sha256[SHA256_DIGEST_LENGTH];\n    int count;\n    for (count = 0; COND(c[D_SHA256][testnum]); count++)\n        SHA256(buf, lengths[testnum], sha256);\n    return count;\n}', 'unsigned char *SHA256(const unsigned char *d, size_t n, unsigned char *md)\n{\n    SHA256_CTX c;\n    static unsigned char m[SHA256_DIGEST_LENGTH];\n    if (md == NULL)\n        md = m;\n    SHA256_Init(&c);\n    SHA256_Update(&c, d, n);\n    SHA256_Final(md, &c);\n    OPENSSL_cleanse(&c, sizeof(c));\n    return md;\n}', 'int HASH_UPDATE(HASH_CTX *c, const void *data_, size_t len)\n{\n    const unsigned char *data = data_;\n    unsigned char *p;\n    HASH_LONG l;\n    size_t n;\n    if (len == 0)\n        return 1;\n    l = (c->Nl + (((HASH_LONG) len) << 3)) & 0xffffffffUL;\n    if (l < c->Nl)\n        c->Nh++;\n    c->Nh += (HASH_LONG) (len >> 29);\n    c->Nl = l;\n    n = c->num;\n    if (n != 0) {\n        p = (unsigned char *)c->data;\n        if (len >= HASH_CBLOCK || len + n >= HASH_CBLOCK) {\n            memcpy(p + n, data, HASH_CBLOCK - n);\n            HASH_BLOCK_DATA_ORDER(c, p, 1);\n            n = HASH_CBLOCK - n;\n            data += n;\n            len -= n;\n            c->num = 0;\n            memset(p, 0, HASH_CBLOCK);\n        } else {\n            memcpy(p + n, data, len);\n            c->num += (unsigned int)len;\n            return 1;\n        }\n    }\n    n = len / HASH_CBLOCK;\n    if (n > 0) {\n        HASH_BLOCK_DATA_ORDER(c, data, n);\n        n *= HASH_CBLOCK;\n        data += n;\n        len -= n;\n    }\n    if (len != 0) {\n        p = (unsigned char *)c->data;\n        c->num = (unsigned int)len;\n        memcpy(p, data, len);\n    }\n    return 1;\n}']