crypto/md5/md5_sha1.c:92: error: INTEGER_OVERFLOW_L2
  ([0, 255] + [0, 4294967295]):unsigned32 by call to `SHA1_Update`.
Showing all 17 steps of the trace


crypto/md5/md5_sha1.c:74:10: Call
72.       /* Reinitialise context */
73.   
74.       if (!md5_sha1_init(mctx))
               ^
75.           return 0;
76.   

crypto/md5/md5_sha1.c:17:12: Call
  15.       if (!MD5_Init(&mctx->md5))
  16.           return 0;
  17.       return SHA1_Init(&mctx->sha1);
                   ^
  18.   }
  19.   

crypto/sha/sha_locl.h:60:5: Assignment
    58.       c->h2 = INIT_DATA_h2;
    59.       c->h3 = INIT_DATA_h3;
    60.       c->h4 = INIT_DATA_h4;
              ^
    61.       return 1;
    62.   }

crypto/md5/md5_sha1.c:77:9: Call
75.           return 0;
76.   
77.       if (md5_sha1_update(mctx, ms, mslen) <= 0)
              ^
78.           return 0;
79.   

crypto/md5/md5_sha1.c:20:1: Parameter `mctx->sha1.h4`
  18.   }
  19.   
  20. > int md5_sha1_update(MD5_SHA1_CTX *mctx, const void *data, size_t count)
  21.   {
  22.       if (!MD5_Update(&mctx->md5, data, count))

crypto/md5/md5_sha1.c:89:10: Call
87.           return 0;
88.   
89.       if (!SHA1_Update(&mctx->sha1, padtmp, 40))
               ^
90.           return 0;
91.   

crypto/include/internal/md32_common.h:128:1: Parameter `c->h4`
  126.    */
  127.   
  128. > int HASH_UPDATE(HASH_CTX *c, const void *data_, size_t len)
  129.   {
  130.       const unsigned char *data = data_;

crypto/md5/md5_sha1.c:92:10: Call
90.           return 0;
91.   
92.       if (!SHA1_Update(&mctx->sha1, sha1tmp, sizeof(sha1tmp)))
               ^
93.           return 0;
94.   

crypto/include/internal/md32_common.h:128:1: Parameter `*data_`
  126.    */
  127.   
  128. > int HASH_UPDATE(HASH_CTX *c, const void *data_, size_t len)
  129.   {
  130.       const unsigned char *data = data_;

crypto/include/internal/md32_common.h:151:13: Call
  149.           if (len >= HASH_CBLOCK || len + n >= HASH_CBLOCK) {
  150.               memcpy(p + n, data, HASH_CBLOCK - n);
  151.               HASH_BLOCK_DATA_ORDER(c, p, 1);
                     ^
  152.               n = HASH_CBLOCK - n;
  153.               data += n;

crypto/sha/sha_locl.h:136:1: <LHS trace>
134.   
135.   # if !defined(SHA1_ASM)
136. > static void HASH_BLOCK_DATA_ORDER(SHA_CTX *c, const void *p, size_t num)
137.   {
138.       const unsigned char *data = p;

crypto/sha/sha_locl.h:136:1: Parameter `*p`
    134.   
    135.   # if !defined(SHA1_ASM)
    136. > static void HASH_BLOCK_DATA_ORDER(SHA_CTX *c, const void *p, size_t num)
    137.   {
    138.       const unsigned char *data = p;

crypto/sha/sha_locl.h:165:13: Assignment
    163.               const SHA_LONG *W = (const SHA_LONG *)data;
    164.   
    165.               X(0) = W[0];
                       ^
    166.               X(1) = W[1];
    167.               BODY_00_15(0, A, B, C, D, E, T, X(0));

crypto/sha/sha_locl.h:136:1: <RHS trace>
134.   
135.   # if !defined(SHA1_ASM)
136. > static void HASH_BLOCK_DATA_ORDER(SHA_CTX *c, const void *p, size_t num)
137.   {
138.       const unsigned char *data = p;

crypto/sha/sha_locl.h:136:1: Parameter `c->h4`
    134.   
    135.   # if !defined(SHA1_ASM)
    136. > static void HASH_BLOCK_DATA_ORDER(SHA_CTX *c, const void *p, size_t num)
    137.   {
    138.       const unsigned char *data = p;

crypto/sha/sha_locl.h:151:5: Assignment
    149.       C = c->h2;
    150.       D = c->h3;
    151.       E = c->h4;
               ^
    152.   
    153.       for (;;) {

crypto/sha/sha_locl.h:167:13: Binary operation: ([0, 255] + [0, 4294967295]):unsigned32 by call to `SHA1_Update` 
    165.               X(0) = W[0];
    166.               X(1) = W[1];
    167.               BODY_00_15(0, A, B, C, D, E, T, X(0));
                       ^
    168.               X(2) = W[2];
    169.               BODY_00_15(1, T, A, B, C, D, E, X(1));
