RTEMS-6
Annotated Report
libmd
Sun Feb 28 23:31:44 2021
001066f0 <MD5Final>:
{
1066f0: 55 push %ebp
1066f1: 89 e5 mov %esp,%ebp
1066f3: 57 push %edi
1066f4: 56 push %esi
1066f5: 53 push %ebx
1066f6: 83 ec 4c sub $0x4c,%esp
1066f9: 8b 5d 0c mov 0xc(%ebp),%ebx
1066fc: 8b 7d 08 mov 0x8(%ebp),%edi
in[14] = mdContext->i[0];
1066ff: 8b 03 mov (%ebx),%eax
in[15] = mdContext->i[1];
106701: 8b 53 04 mov 0x4(%ebx),%edx
in[14] = mdContext->i[0];
106704: 89 45 ec mov %eax,-0x14(%ebp)
mdi = (int)((mdContext->i[0] >> 3) & 0x3F);
106707: c1 e8 03 shr $0x3,%eax
in[15] = mdContext->i[1];
10670a: 89 55 f0 mov %edx,-0x10(%ebp)
mdi = (int)((mdContext->i[0] >> 3) & 0x3F);
10670d: 83 e0 3f and $0x3f,%eax
padLen = (mdi < 56) ? (56 - mdi) : (120 - mdi);
106710: 83 f8 37 cmp $0x37,%eax
106713: 0f 8f a7 00 00 00 jg 1067c0 <MD5Final+0xd0> <== NEVER TAKEN
106719: ba 38 00 00 00 mov $0x38,%edx
10671e: 29 c2 sub %eax,%edx
MD5Update (mdContext, PADDING, padLen);
106720: 89 54 24 08 mov %edx,0x8(%esp)
106724: b8 20 4c 13 00 mov $0x134c20,%eax
106729: 89 44 24 04 mov %eax,0x4(%esp)
10672d: 89 1c 24 mov %ebx,(%esp)
106730: e8 db fe ff ff call 106610 <MD5Update>
for (i = 0, ii = 0; i < 14; i++, ii += 4)
106735: 31 d2 xor %edx,%edx
106737: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10673e: 66 90 xchg %ax,%ax
in[i] = (((UINT4)mdContext->in[ii+3]) << 24) |
106740: 0f b6 44 13 1b movzbl 0x1b(%ebx,%edx,1),%eax
(((UINT4)mdContext->in[ii+2]) << 16) |
106745: 0f b6 4c 13 1a movzbl 0x1a(%ebx,%edx,1),%ecx
in[i] = (((UINT4)mdContext->in[ii+3]) << 24) |
10674a: c1 e0 18 shl $0x18,%eax
(((UINT4)mdContext->in[ii+2]) << 16) |
10674d: c1 e1 10 shl $0x10,%ecx
in[i] = (((UINT4)mdContext->in[ii+3]) << 24) |
106750: 09 c8 or %ecx,%eax
((UINT4)mdContext->in[ii]);
106752: 0f b6 4c 13 18 movzbl 0x18(%ebx,%edx,1),%ecx
(((UINT4)mdContext->in[ii+1]) << 8) |
106757: 09 c8 or %ecx,%eax
106759: 0f b6 4c 13 19 movzbl 0x19(%ebx,%edx,1),%ecx
10675e: c1 e1 08 shl $0x8,%ecx
106761: 09 c8 or %ecx,%eax
106763: 89 44 15 b4 mov %eax,-0x4c(%ebp,%edx,1)
for (i = 0, ii = 0; i < 14; i++, ii += 4)
106767: 83 c2 04 add $0x4,%edx
10676a: 83 fa 38 cmp $0x38,%edx
10676d: 75 d1 jne 106740 <MD5Final+0x50>
Transform (mdContext->buf, in);
10676f: 8d 73 08 lea 0x8(%ebx),%esi
106772: 8d 55 b4 lea -0x4c(%ebp),%edx
106775: 89 f0 mov %esi,%eax
106777: e8 84 f7 ff ff call 105f00 <Transform>
for (i = 0, ii = 0; i < 4; i++, ii += 4) {
10677c: 89 f0 mov %esi,%eax
10677e: 8d 73 18 lea 0x18(%ebx),%esi
mdContext->digest[ii] = (unsigned char)(mdContext->buf[i] & 0xFF);
106781: 8b 10 mov (%eax),%edx
for (i = 0, ii = 0; i < 4; i++, ii += 4) {
106783: 83 c0 04 add $0x4,%eax
mdContext->digest[ii] = (unsigned char)(mdContext->buf[i] & 0xFF);
106786: 88 50 4c mov %dl,0x4c(%eax)
(unsigned char)((mdContext->buf[i] >> 16) & 0xFF);
106789: 89 d1 mov %edx,%ecx
(unsigned char)((mdContext->buf[i] >> 8) & 0xFF);
10678b: 88 70 4d mov %dh,0x4d(%eax)
(unsigned char)((mdContext->buf[i] >> 16) & 0xFF);
10678e: c1 e9 10 shr $0x10,%ecx
106791: 88 48 4e mov %cl,0x4e(%eax)
(unsigned char)((mdContext->buf[i] >> 24) & 0xFF);
106794: c1 ea 18 shr $0x18,%edx
106797: 88 50 4f mov %dl,0x4f(%eax)
for (i = 0, ii = 0; i < 4; i++, ii += 4) {
10679a: 39 c6 cmp %eax,%esi
10679c: 75 e3 jne 106781 <MD5Final+0x91>
memcpy(hash, mdContext->digest, 16);
10679e: 8b 53 58 mov 0x58(%ebx),%edx
1067a1: 89 17 mov %edx,(%edi)
1067a3: 8b 53 5c mov 0x5c(%ebx),%edx
1067a6: 89 57 04 mov %edx,0x4(%edi)
1067a9: 8b 53 60 mov 0x60(%ebx),%edx
1067ac: 89 57 08 mov %edx,0x8(%edi)
1067af: 8b 43 64 mov 0x64(%ebx),%eax
1067b2: 89 47 0c mov %eax,0xc(%edi)
}
1067b5: 83 c4 4c add $0x4c,%esp
1067b8: 5b pop %ebx
1067b9: 5e pop %esi
1067ba: 5f pop %edi
1067bb: 5d pop %ebp
1067bc: c3 ret
1067bd: 8d 76 00 lea 0x0(%esi),%esi
padLen = (mdi < 56) ? (56 - mdi) : (120 - mdi);
1067c0: ba 78 00 00 00 mov $0x78,%edx <== NOT EXECUTED
1067c5: 29 c2 sub %eax,%edx <== NOT EXECUTED
1067c7: e9 54 ff ff ff jmp 106720 <MD5Final+0x30> <== NOT EXECUTED
1067cc: 90 nop
1067cd: 90 nop
1067ce: 90 nop
1067cf: 90 nop
00106610 <MD5Update>:
{
106610: 55 push %ebp
106611: 89 e5 mov %esp,%ebp
106613: 57 push %edi
106614: 56 push %esi
106615: 53 push %ebx
106616: 83 ec 44 sub $0x44,%esp
106619: 8b 5d 08 mov 0x8(%ebp),%ebx
10661c: c7 45 b0 00 00 00 00 movl $0x0,-0x50(%ebp)
106623: 8b 55 10 mov 0x10(%ebp),%edx
106626: 8b 75 0c mov 0xc(%ebp),%esi
mdi = (int)((mdContext->i[0] >> 3) & 0x3F);
106629: 8b 3b mov (%ebx),%edi
if ((mdContext->i[0] + ((UINT4)inLen << 3)) < mdContext->i[0])
10662b: 8d 0c d5 00 00 00 00 lea 0x0(,%edx,8),%ecx
mdi = (int)((mdContext->i[0] >> 3) & 0x3F);
106632: 89 f8 mov %edi,%eax
106634: c1 e8 03 shr $0x3,%eax
106637: 83 e0 3f and $0x3f,%eax
if ((mdContext->i[0] + ((UINT4)inLen << 3)) < mdContext->i[0])
10663a: 01 f9 add %edi,%ecx
10663c: 0f 82 96 00 00 00 jb 1066d8 <MD5Update+0xc8> <== NEVER TAKEN
mdContext->i[0] += ((UINT4)inLen << 3);
106642: 89 0b mov %ecx,(%ebx)
mdContext->i[1]++;
106644: 8b 7b 04 mov 0x4(%ebx),%edi
mdContext->i[1] += ((UINT4)inLen >> 29);
106647: 89 d1 mov %edx,%ecx
mdContext->i[1]++;
106649: 83 7d b0 01 cmpl $0x1,-0x50(%ebp)
10664d: 83 df ff sbb $0xffffffff,%edi
mdContext->i[1] += ((UINT4)inLen >> 29);
106650: c1 e9 1d shr $0x1d,%ecx
106653: 01 cf add %ecx,%edi
while (inLen--) {
106655: 85 d2 test %edx,%edx
mdContext->i[1] += ((UINT4)inLen >> 29);
106657: 89 7b 04 mov %edi,0x4(%ebx)
Transform (mdContext->buf, in);
10665a: 8d 4b 08 lea 0x8(%ebx),%ecx
10665d: 89 4d b0 mov %ecx,-0x50(%ebp)
106660: 8d 3c 16 lea (%esi,%edx,1),%edi
while (inLen--) {
106663: 75 0f jne 106674 <MD5Update+0x64> <== ALWAYS TAKEN
106665: eb 69 jmp 1066d0 <MD5Update+0xc0> <== NOT EXECUTED
106667: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10666e: 66 90 xchg %ax,%ax <== NOT EXECUTED
106670: 39 fe cmp %edi,%esi
106672: 74 5c je 1066d0 <MD5Update+0xc0>
mdContext->in[mdi++] = *inBuf++;
106674: 0f b6 16 movzbl (%esi),%edx
106677: 46 inc %esi
106678: 88 54 03 18 mov %dl,0x18(%ebx,%eax,1)
if (mdi == 0x40) {
10667c: 40 inc %eax
10667d: 83 f8 40 cmp $0x40,%eax
106680: 75 ee jne 106670 <MD5Update+0x60>
for (i = 0, ii = 0; i < 16; i++, ii += 4)
106682: 31 d2 xor %edx,%edx
106684: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10668b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10668f: 90 nop
in[i] = (((UINT4)mdContext->in[ii+3]) << 24) |
106690: 0f b6 44 13 1b movzbl 0x1b(%ebx,%edx,1),%eax
(((UINT4)mdContext->in[ii+2]) << 16) |
106695: 0f b6 4c 13 1a movzbl 0x1a(%ebx,%edx,1),%ecx
in[i] = (((UINT4)mdContext->in[ii+3]) << 24) |
10669a: c1 e0 18 shl $0x18,%eax
(((UINT4)mdContext->in[ii+2]) << 16) |
10669d: c1 e1 10 shl $0x10,%ecx
in[i] = (((UINT4)mdContext->in[ii+3]) << 24) |
1066a0: 09 c8 or %ecx,%eax
((UINT4)mdContext->in[ii]);
1066a2: 0f b6 4c 13 18 movzbl 0x18(%ebx,%edx,1),%ecx
(((UINT4)mdContext->in[ii+1]) << 8) |
1066a7: 09 c8 or %ecx,%eax
1066a9: 0f b6 4c 13 19 movzbl 0x19(%ebx,%edx,1),%ecx
1066ae: c1 e1 08 shl $0x8,%ecx
1066b1: 09 c8 or %ecx,%eax
1066b3: 89 44 15 b4 mov %eax,-0x4c(%ebp,%edx,1)
for (i = 0, ii = 0; i < 16; i++, ii += 4)
1066b7: 83 c2 04 add $0x4,%edx
1066ba: 83 fa 40 cmp $0x40,%edx
1066bd: 75 d1 jne 106690 <MD5Update+0x80>
Transform (mdContext->buf, in);
1066bf: 8b 45 b0 mov -0x50(%ebp),%eax
1066c2: 8d 55 b4 lea -0x4c(%ebp),%edx
1066c5: e8 36 f8 ff ff call 105f00 <Transform>
mdi = 0;
1066ca: 31 c0 xor %eax,%eax
while (inLen--) {
1066cc: 39 fe cmp %edi,%esi
1066ce: 75 a4 jne 106674 <MD5Update+0x64>
}
1066d0: 83 c4 44 add $0x44,%esp
1066d3: 5b pop %ebx
1066d4: 5e pop %esi
1066d5: 5f pop %edi
1066d6: 5d pop %ebp
1066d7: c3 ret
1066d8: c7 45 b0 01 00 00 00 movl $0x1,-0x50(%ebp) <== NOT EXECUTED
1066df: e9 5e ff ff ff jmp 106642 <MD5Update+0x32> <== NOT EXECUTED
1066e4: 90 nop
1066e5: 90 nop
1066e6: 90 nop
1066e7: 90 nop
1066e8: 90 nop
1066e9: 90 nop
1066ea: 90 nop
1066eb: 90 nop
1066ec: 90 nop
1066ed: 90 nop
1066ee: 90 nop
1066ef: 90 nop
00108b70 <SHA256_Final>:
* SHA-256 finalization. Pads the input data, exports the hash value,
* and clears the context state.
*/
void
SHA256_Final(unsigned char digest[32], SHA256_CTX * ctx)
{
108b70: 55 push %ebp
108b71: 89 e5 mov %esp,%ebp
108b73: 57 push %edi
108b74: 56 push %esi
108b75: 53 push %ebx
108b76: 83 ec 24 sub $0x24,%esp
108b79: 8b 75 0c mov 0xc(%ebp),%esi
be64enc(len, ctx->count);
108b7c: 8b 56 24 mov 0x24(%esi),%edx
108b7f: 8b 46 20 mov 0x20(%esi),%eax
static __inline void
be32enc(void *pp, uint32_t u)
{
uint8_t *p = (uint8_t *)pp;
p[0] = (u >> 24) & 0xff;
108b82: 8b 4e 20 mov 0x20(%esi),%ecx
p[1] = (u >> 16) & 0xff;
p[2] = (u >> 8) & 0xff;
108b85: 88 75 ea mov %dh,-0x16(%ebp)
p[0] = (u >> 24) & 0xff;
108b88: 89 d3 mov %edx,%ebx
p[3] = u & 0xff;
108b8a: 88 55 eb mov %dl,-0x15(%ebp)
p[0] = (u >> 24) & 0xff;
108b8d: c1 eb 18 shr $0x18,%ebx
108b90: 88 5d e8 mov %bl,-0x18(%ebp)
r = (ctx->count >> 3) & 0x3f;
108b93: 0f ac d0 03 shrd $0x3,%edx,%eax
p[1] = (u >> 16) & 0xff;
108b97: 89 d3 mov %edx,%ebx
108b99: c1 eb 10 shr $0x10,%ebx
108b9c: 83 e0 3f and $0x3f,%eax
108b9f: 0f c9 bswap %ecx
108ba1: 88 5d e9 mov %bl,-0x17(%ebp)
plen = (r < 56) ? (56 - r) : (120 - r);
108ba4: 83 f8 37 cmp $0x37,%eax
p[0] = (u >> 24) & 0xff;
108ba7: 89 4d ec mov %ecx,-0x14(%ebp)
108baa: 0f 87 b0 00 00 00 ja 108c60 <SHA256_Final+0xf0>
108bb0: ba 38 00 00 00 mov $0x38,%edx
108bb5: 29 c2 sub %eax,%edx
SHA256_Update(ctx, PAD, (size_t)plen);
108bb7: 89 54 24 08 mov %edx,0x8(%esp)
108bbb: b8 80 f9 12 00 mov $0x12f980,%eax
108bc0: 89 44 24 04 mov %eax,0x4(%esp)
108bc4: 89 34 24 mov %esi,(%esp)
108bc7: e8 e4 fc ff ff call 1088b0 <SHA256_Update>
SHA256_Update(ctx, len, 8);
108bcc: 8d 45 e8 lea -0x18(%ebp),%eax
108bcf: ba 08 00 00 00 mov $0x8,%edx
108bd4: 89 54 24 08 mov %edx,0x8(%esp)
108bd8: 89 44 24 04 mov %eax,0x4(%esp)
108bdc: 89 34 24 mov %esi,(%esp)
108bdf: e8 cc fc ff ff call 1088b0 <SHA256_Update>
for (i = 0; i < len / 4; i++)
108be4: 8b 5d 08 mov 0x8(%ebp),%ebx
108be7: 31 c9 xor %ecx,%ecx
108be9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
be32enc(dst + i * 4, src[i]);
108bf0: 8b 04 8e mov (%esi,%ecx,4),%eax
p[2] = (u >> 8) & 0xff;
108bf3: 88 64 8b 02 mov %ah,0x2(%ebx,%ecx,4)
p[0] = (u >> 24) & 0xff;
108bf7: 89 c2 mov %eax,%edx
p[3] = u & 0xff;
108bf9: 88 44 8b 03 mov %al,0x3(%ebx,%ecx,4)
p[0] = (u >> 24) & 0xff;
108bfd: c1 ea 18 shr $0x18,%edx
108c00: 88 14 8b mov %dl,(%ebx,%ecx,4)
p[1] = (u >> 16) & 0xff;
108c03: 89 c2 mov %eax,%edx
108c05: c1 ea 10 shr $0x10,%edx
108c08: 88 54 8b 01 mov %dl,0x1(%ebx,%ecx,4)
for (i = 0; i < len / 4; i++)
108c0c: 41 inc %ecx
108c0d: 83 f9 08 cmp $0x8,%ecx
108c10: 75 de jne 108bf0 <SHA256_Final+0x80>
/* Write the hash */
be32enc_vect(digest, ctx->state, 32);
/* Clear the context state */
memset((void *)ctx, 0, sizeof(*ctx));
108c12: 31 d2 xor %edx,%edx
108c14: f7 c6 01 00 00 00 test $0x1,%esi
108c1a: bb 68 00 00 00 mov $0x68,%ebx
108c1f: 75 7f jne 108ca0 <SHA256_Final+0x130> <== NEVER TAKEN
108c21: f7 c6 02 00 00 00 test $0x2,%esi
108c27: 0f 85 93 00 00 00 jne 108cc0 <SHA256_Final+0x150> <== NEVER TAKEN
108c2d: 89 d9 mov %ebx,%ecx
108c2f: 31 c0 xor %eax,%eax
108c31: 83 e1 f8 and $0xfffffff8,%ecx
108c34: 89 14 06 mov %edx,(%esi,%eax,1)
108c37: 89 54 06 04 mov %edx,0x4(%esi,%eax,1)
108c3b: 83 c0 08 add $0x8,%eax
108c3e: 39 c8 cmp %ecx,%eax
108c40: 72 f2 jb 108c34 <SHA256_Final+0xc4>
108c42: 01 c6 add %eax,%esi
108c44: f6 c3 04 test $0x4,%bl
108c47: 75 47 jne 108c90 <SHA256_Final+0x120> <== NEVER TAKEN
108c49: f6 c3 02 test $0x2,%bl
108c4c: 75 32 jne 108c80 <SHA256_Final+0x110> <== NEVER TAKEN
108c4e: f6 c3 01 test $0x1,%bl
108c51: 75 1d jne 108c70 <SHA256_Final+0x100> <== NEVER TAKEN
}
108c53: 83 c4 24 add $0x24,%esp
108c56: 5b pop %ebx
108c57: 5e pop %esi
108c58: 5f pop %edi
108c59: 5d pop %ebp
108c5a: c3 ret
108c5b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
108c5f: 90 nop
plen = (r < 56) ? (56 - r) : (120 - r);
108c60: ba 78 00 00 00 mov $0x78,%edx
108c65: 29 c2 sub %eax,%edx
108c67: e9 4b ff ff ff jmp 108bb7 <SHA256_Final+0x47>
108c6c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
memset((void *)ctx, 0, sizeof(*ctx));
108c70: c6 06 00 movb $0x0,(%esi) <== NOT EXECUTED
}
108c73: 83 c4 24 add $0x24,%esp <== NOT EXECUTED
108c76: 5b pop %ebx <== NOT EXECUTED
108c77: 5e pop %esi <== NOT EXECUTED
108c78: 5f pop %edi <== NOT EXECUTED
108c79: 5d pop %ebp <== NOT EXECUTED
108c7a: c3 ret <== NOT EXECUTED
108c7b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
108c7f: 90 nop <== NOT EXECUTED
memset((void *)ctx, 0, sizeof(*ctx));
108c80: 66 c7 06 00 00 movw $0x0,(%esi) <== NOT EXECUTED
108c85: 83 c6 02 add $0x2,%esi <== NOT EXECUTED
108c88: f6 c3 01 test $0x1,%bl <== NOT EXECUTED
108c8b: 74 c6 je 108c53 <SHA256_Final+0xe3> <== NOT EXECUTED
108c8d: eb e1 jmp 108c70 <SHA256_Final+0x100> <== NOT EXECUTED
108c8f: 90 nop <== NOT EXECUTED
108c90: c7 06 00 00 00 00 movl $0x0,(%esi) <== NOT EXECUTED
108c96: 83 c6 04 add $0x4,%esi <== NOT EXECUTED
108c99: f6 c3 02 test $0x2,%bl <== NOT EXECUTED
108c9c: 74 b0 je 108c4e <SHA256_Final+0xde> <== NOT EXECUTED
108c9e: eb e0 jmp 108c80 <SHA256_Final+0x110> <== NOT EXECUTED
108ca0: c6 06 00 movb $0x0,(%esi) <== NOT EXECUTED
108ca3: 46 inc %esi <== NOT EXECUTED
108ca4: bb 67 00 00 00 mov $0x67,%ebx <== NOT EXECUTED
108ca9: f7 c6 02 00 00 00 test $0x2,%esi <== NOT EXECUTED
108caf: 0f 84 78 ff ff ff je 108c2d <SHA256_Final+0xbd> <== NOT EXECUTED
108cb5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
108cbc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
108cc0: 66 c7 06 00 00 movw $0x0,(%esi) <== NOT EXECUTED
108cc5: 83 eb 02 sub $0x2,%ebx <== NOT EXECUTED
108cc8: 83 c6 02 add $0x2,%esi <== NOT EXECUTED
108ccb: e9 5d ff ff ff jmp 108c2d <SHA256_Final+0xbd> <== NOT EXECUTED
001088b0 <SHA256_Update>:
/* Add bytes into the hash */
void
SHA256_Update(SHA256_CTX * ctx, const void *in, size_t len)
{
1088b0: 55 push %ebp
1088b1: 89 e5 mov %esp,%ebp
1088b3: 57 push %edi
1088b4: 56 push %esi
1088b5: 53 push %ebx
1088b6: 83 ec 14 sub $0x14,%esp
1088b9: 8b 75 08 mov 0x8(%ebp),%esi
uint64_t bitlen;
uint32_t r;
const unsigned char *src = in;
/* Number of bytes left in the buffer from previous updates */
r = (ctx->count >> 3) & 0x3f;
1088bc: 8b 56 24 mov 0x24(%esi),%edx
1088bf: 8b 46 20 mov 0x20(%esi),%eax
1088c2: 89 d3 mov %edx,%ebx
1088c4: 89 c1 mov %eax,%ecx
1088c6: 0f ac d9 03 shrd $0x3,%ebx,%ecx
/* Convert the length into a number of bits */
bitlen = len << 3;
1088ca: 31 db xor %ebx,%ebx
r = (ctx->count >> 3) & 0x3f;
1088cc: 89 cf mov %ecx,%edi
bitlen = len << 3;
1088ce: 8b 4d 10 mov 0x10(%ebp),%ecx
r = (ctx->count >> 3) & 0x3f;
1088d1: 83 e7 3f and $0x3f,%edi
1088d4: 89 7d ec mov %edi,-0x14(%ebp)
bitlen = len << 3;
1088d7: c1 e1 03 shl $0x3,%ecx
/* Update number of bits */
ctx->count += bitlen;
1088da: 01 c1 add %eax,%ecx
1088dc: 89 4e 20 mov %ecx,0x20(%esi)
1088df: 11 d3 adc %edx,%ebx
/* Handle the case where we don't need to perform any transforms */
if (len < 64 - r) {
1088e1: ba 40 00 00 00 mov $0x40,%edx
ctx->count += bitlen;
1088e6: 89 5e 24 mov %ebx,0x24(%esi)
if (len < 64 - r) {
1088e9: 29 fa sub %edi,%edx
1088eb: 3b 55 10 cmp 0x10(%ebp),%edx
memcpy(&ctx->buf[r], src, len);
1088ee: 8d 7c 3e 28 lea 0x28(%esi,%edi,1),%edi
if (len < 64 - r) {
1088f2: 0f 87 a8 01 00 00 ja 108aa0 <SHA256_Update+0x1f0>
return;
}
/* Finish the current block */
memcpy(&ctx->buf[r], src, 64 - r);
1088f8: 83 fa 04 cmp $0x4,%edx
1088fb: 8b 4d 0c mov 0xc(%ebp),%ecx
1088fe: 89 d3 mov %edx,%ebx
108900: 89 d0 mov %edx,%eax
108902: 0f 83 38 01 00 00 jae 108a40 <SHA256_Update+0x190>
108908: 31 d2 xor %edx,%edx
10890a: a8 02 test $0x2,%al
10890c: 0f 85 be 00 00 00 jne 1089d0 <SHA256_Update+0x120>
108912: a8 01 test $0x1,%al
108914: 0f 85 a6 00 00 00 jne 1089c0 <SHA256_Update+0x110>
SHA256_Transform(ctx->state, ctx->buf);
10891a: 8d 46 28 lea 0x28(%esi),%eax
10891d: 89 45 e8 mov %eax,-0x18(%ebp)
108920: 89 c2 mov %eax,%edx
108922: 89 f0 mov %esi,%eax
108924: e8 a7 de ff ff call 1067d0 <SHA256_Transform>
src += 64 - r;
108929: 8b 45 0c mov 0xc(%ebp),%eax
len -= 64 - r;
10892c: 8b 55 10 mov 0x10(%ebp),%edx
src += 64 - r;
10892f: 01 c3 add %eax,%ebx
len -= 64 - r;
108931: 8b 45 ec mov -0x14(%ebp),%eax
src += 64 - r;
108934: 89 df mov %ebx,%edi
len -= 64 - r;
108936: 8d 44 10 c0 lea -0x40(%eax,%edx,1),%eax
10893a: 89 45 ec mov %eax,-0x14(%ebp)
/* Perform complete blocks */
while (len >= 64) {
10893d: 83 f8 3f cmp $0x3f,%eax
108940: 76 22 jbe 108964 <SHA256_Update+0xb4>
108942: 8d 48 c0 lea -0x40(%eax),%ecx
108945: 83 e1 c0 and $0xffffffc0,%ecx
108948: 8d 5c 0b 40 lea 0x40(%ebx,%ecx,1),%ebx
10894c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
SHA256_Transform(ctx->state, src);
108950: 89 fa mov %edi,%edx
108952: 89 f0 mov %esi,%eax
108954: e8 77 de ff ff call 1067d0 <SHA256_Transform>
src += 64;
108959: 83 c7 40 add $0x40,%edi
while (len >= 64) {
10895c: 39 df cmp %ebx,%edi
10895e: 75 f0 jne 108950 <SHA256_Update+0xa0> <== NEVER TAKEN
len -= 64;
108960: 83 65 ec 3f andl $0x3f,-0x14(%ebp)
}
/* Copy left over data into buffer */
memcpy(ctx->buf, src, len);
108964: 8b 45 ec mov -0x14(%ebp),%eax
108967: 8b 7d e8 mov -0x18(%ebp),%edi
10896a: 83 f8 04 cmp $0x4,%eax
10896d: 0f 83 7d 00 00 00 jae 1089f0 <SHA256_Update+0x140>
108973: 31 c0 xor %eax,%eax
108975: f6 45 ec 02 testb $0x2,-0x14(%ebp)
108979: 75 25 jne 1089a0 <SHA256_Update+0xf0>
10897b: f6 45 ec 01 testb $0x1,-0x14(%ebp)
10897f: 75 0f jne 108990 <SHA256_Update+0xe0>
}
108981: 83 c4 14 add $0x14,%esp
108984: 5b pop %ebx
108985: 5e pop %esi
108986: 5f pop %edi
108987: 5d pop %ebp
108988: c3 ret
108989: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
memcpy(ctx->buf, src, len);
108990: 0f b6 14 03 movzbl (%ebx,%eax,1),%edx
108994: 88 14 07 mov %dl,(%edi,%eax,1)
}
108997: 83 c4 14 add $0x14,%esp
10899a: 5b pop %ebx
10899b: 5e pop %esi
10899c: 5f pop %edi
10899d: 5d pop %ebp
10899e: c3 ret
10899f: 90 nop
memcpy(ctx->buf, src, len);
1089a0: 0f b7 03 movzwl (%ebx),%eax
1089a3: 66 89 07 mov %ax,(%edi)
1089a6: b8 02 00 00 00 mov $0x2,%eax
1089ab: f6 45 ec 01 testb $0x1,-0x14(%ebp)
1089af: 74 d0 je 108981 <SHA256_Update+0xd1>
1089b1: eb dd jmp 108990 <SHA256_Update+0xe0>
1089b3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1089ba: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
memcpy(&ctx->buf[r], src, 64 - r);
1089c0: 0f b6 04 11 movzbl (%ecx,%edx,1),%eax
1089c4: 88 04 17 mov %al,(%edi,%edx,1)
1089c7: e9 4e ff ff ff jmp 10891a <SHA256_Update+0x6a>
1089cc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
1089d0: 0f b7 11 movzwl (%ecx),%edx
1089d3: a8 01 test $0x1,%al
1089d5: 66 89 17 mov %dx,(%edi)
1089d8: ba 02 00 00 00 mov $0x2,%edx
1089dd: 0f 84 37 ff ff ff je 10891a <SHA256_Update+0x6a>
1089e3: eb db jmp 1089c0 <SHA256_Update+0x110>
1089e5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1089ec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
memcpy(ctx->buf, src, len);
1089f0: f7 c7 01 00 00 00 test $0x1,%edi
1089f6: 0f 85 f2 00 00 00 jne 108aee <SHA256_Update+0x23e> <== NEVER TAKEN
1089fc: f7 c7 02 00 00 00 test $0x2,%edi
108a02: 0f 85 f6 00 00 00 jne 108afe <SHA256_Update+0x24e> <== NEVER TAKEN
108a08: 8b 45 ec mov -0x14(%ebp),%eax
108a0b: 83 f8 04 cmp $0x4,%eax
108a0e: 0f 82 5f ff ff ff jb 108973 <SHA256_Update+0xc3> <== NEVER TAKEN
108a14: 89 c1 mov %eax,%ecx
108a16: 31 c0 xor %eax,%eax
108a18: 83 e1 fc and $0xfffffffc,%ecx
108a1b: 8b 14 03 mov (%ebx,%eax,1),%edx
108a1e: 89 14 07 mov %edx,(%edi,%eax,1)
108a21: 83 c0 04 add $0x4,%eax
108a24: 39 c8 cmp %ecx,%eax
108a26: 72 f3 jb 108a1b <SHA256_Update+0x16b>
108a28: 01 c7 add %eax,%edi
108a2a: 01 c3 add %eax,%ebx
108a2c: 31 c0 xor %eax,%eax
108a2e: f6 45 ec 02 testb $0x2,-0x14(%ebp)
108a32: 0f 84 43 ff ff ff je 10897b <SHA256_Update+0xcb>
108a38: e9 63 ff ff ff jmp 1089a0 <SHA256_Update+0xf0>
108a3d: 8d 76 00 lea 0x0(%esi),%esi
memcpy(&ctx->buf[r], src, 64 - r);
108a40: f7 c7 01 00 00 00 test $0x1,%edi
108a46: 0f 85 c8 00 00 00 jne 108b14 <SHA256_Update+0x264>
108a4c: f7 c7 02 00 00 00 test $0x2,%edi
108a52: 0f 85 d4 00 00 00 jne 108b2c <SHA256_Update+0x27c>
108a58: 83 f8 04 cmp $0x4,%eax
108a5b: 0f 82 a7 fe ff ff jb 108908 <SHA256_Update+0x58> <== NEVER TAKEN
108a61: 89 45 e4 mov %eax,-0x1c(%ebp)
108a64: 89 c2 mov %eax,%edx
108a66: 83 e2 fc and $0xfffffffc,%edx
108a69: 89 55 e8 mov %edx,-0x18(%ebp)
108a6c: 31 d2 xor %edx,%edx
108a6e: 8b 04 11 mov (%ecx,%edx,1),%eax
108a71: 89 04 17 mov %eax,(%edi,%edx,1)
108a74: 83 c2 04 add $0x4,%edx
108a77: 3b 55 e8 cmp -0x18(%ebp),%edx
108a7a: 72 f2 jb 108a6e <SHA256_Update+0x1be>
108a7c: 8b 45 e4 mov -0x1c(%ebp),%eax
108a7f: 01 d7 add %edx,%edi
108a81: 01 d1 add %edx,%ecx
108a83: 31 d2 xor %edx,%edx
108a85: a8 02 test $0x2,%al
108a87: 0f 84 85 fe ff ff je 108912 <SHA256_Update+0x62> <== ALWAYS TAKEN
108a8d: e9 3e ff ff ff jmp 1089d0 <SHA256_Update+0x120> <== NOT EXECUTED
108a92: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
108a99: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
memcpy(&ctx->buf[r], src, len);
108aa0: 8b 4d 10 mov 0x10(%ebp),%ecx
108aa3: 8b 75 0c mov 0xc(%ebp),%esi
108aa6: 83 f9 08 cmp $0x8,%ecx
108aa9: 73 15 jae 108ac0 <SHA256_Update+0x210>
108aab: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
}
108aad: 83 c4 14 add $0x14,%esp
108ab0: 5b pop %ebx
108ab1: 5e pop %esi
108ab2: 5f pop %edi
108ab3: 5d pop %ebp
108ab4: c3 ret
108ab5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
108abc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
memcpy(&ctx->buf[r], src, len);
108ac0: f7 c7 01 00 00 00 test $0x1,%edi
108ac6: 0f 85 87 00 00 00 jne 108b53 <SHA256_Update+0x2a3>
108acc: f7 c7 02 00 00 00 test $0x2,%edi
108ad2: 75 6d jne 108b41 <SHA256_Update+0x291>
108ad4: f7 c7 04 00 00 00 test $0x4,%edi
108ada: 74 cf je 108aab <SHA256_Update+0x1fb>
108adc: 8b 06 mov (%esi),%eax
108ade: 83 c7 04 add $0x4,%edi
108ae1: 83 c6 04 add $0x4,%esi
108ae4: 83 e9 04 sub $0x4,%ecx
108ae7: 89 47 fc mov %eax,-0x4(%edi)
108aea: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
return;
108aec: eb bf jmp 108aad <SHA256_Update+0x1fd>
memcpy(ctx->buf, src, len);
108aee: 0f b6 03 movzbl (%ebx),%eax <== NOT EXECUTED
108af1: 47 inc %edi <== NOT EXECUTED
108af2: 43 inc %ebx <== NOT EXECUTED
108af3: 88 46 28 mov %al,0x28(%esi) <== NOT EXECUTED
108af6: ff 4d ec decl -0x14(%ebp) <== NOT EXECUTED
108af9: e9 fe fe ff ff jmp 1089fc <SHA256_Update+0x14c> <== NOT EXECUTED
108afe: 0f b7 03 movzwl (%ebx),%eax <== NOT EXECUTED
108b01: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
108b04: 83 c3 02 add $0x2,%ebx <== NOT EXECUTED
108b07: 66 89 47 fe mov %ax,-0x2(%edi) <== NOT EXECUTED
108b0b: 83 6d ec 02 subl $0x2,-0x14(%ebp) <== NOT EXECUTED
108b0f: e9 f4 fe ff ff jmp 108a08 <SHA256_Update+0x158> <== NOT EXECUTED
memcpy(&ctx->buf[r], src, 64 - r);
108b14: 0f b6 01 movzbl (%ecx),%eax
108b17: 47 inc %edi
108b18: 88 45 e8 mov %al,-0x18(%ebp)
108b1b: 88 47 ff mov %al,-0x1(%edi)
108b1e: 8b 45 0c mov 0xc(%ebp),%eax
108b21: 8d 48 01 lea 0x1(%eax),%ecx
108b24: 8d 42 ff lea -0x1(%edx),%eax
108b27: e9 20 ff ff ff jmp 108a4c <SHA256_Update+0x19c>
108b2c: 0f b7 11 movzwl (%ecx),%edx
108b2f: 83 c7 02 add $0x2,%edi
108b32: 83 c1 02 add $0x2,%ecx
108b35: 83 e8 02 sub $0x2,%eax
108b38: 66 89 57 fe mov %dx,-0x2(%edi)
108b3c: e9 17 ff ff ff jmp 108a58 <SHA256_Update+0x1a8>
memcpy(&ctx->buf[r], src, len);
108b41: 0f b7 06 movzwl (%esi),%eax
108b44: 83 c7 02 add $0x2,%edi
108b47: 83 c6 02 add $0x2,%esi
108b4a: 83 e9 02 sub $0x2,%ecx
108b4d: 66 89 47 fe mov %ax,-0x2(%edi)
108b51: eb 81 jmp 108ad4 <SHA256_Update+0x224>
108b53: 0f b6 06 movzbl (%esi),%eax
108b56: 47 inc %edi
108b57: 46 inc %esi
108b58: 49 dec %ecx
108b59: 88 47 ff mov %al,-0x1(%edi)
108b5c: e9 6b ff ff ff jmp 108acc <SHA256_Update+0x21c>
108b61: 90 nop
108b62: 90 nop
108b63: 90 nop
108b64: 90 nop
108b65: 90 nop
108b66: 90 nop
108b67: 90 nop
108b68: 90 nop
108b69: 90 nop
108b6a: 90 nop
108b6b: 90 nop
108b6c: 90 nop
108b6d: 90 nop
108b6e: 90 nop
108b6f: 90 nop
001136f0 <SHA512_Final>:
* SHA-512 finalization. Pads the input data, exports the hash value,
* and clears the context state.
*/
void
SHA512_Final(unsigned char digest[64], SHA512_CTX * ctx)
{
1136f0: 55 push %ebp
be64enc_vect(len, ctx->count, 16);
1136f1: b9 10 00 00 00 mov $0x10,%ecx
{
1136f6: 89 e5 mov %esp,%ebp
1136f8: 57 push %edi
1136f9: 56 push %esi
1136fa: 53 push %ebx
be64enc_vect(len, ctx->count, 16);
1136fb: 8d 75 d8 lea -0x28(%ebp),%esi
{
1136fe: 83 ec 2c sub $0x2c,%esp
113701: 8b 7d 0c mov 0xc(%ebp),%edi
be64enc_vect(len, ctx->count, 16);
113704: 89 f0 mov %esi,%eax
113706: 8d 57 40 lea 0x40(%edi),%edx
113709: e8 c2 55 ff ff call 108cd0 <be64enc_vect>
r = (ctx->count[1] >> 3) & 0x7f;
11370e: 8b 47 48 mov 0x48(%edi),%eax
plen = (r < 112) ? (112 - r) : (240 - r);
113711: b9 6f 00 00 00 mov $0x6f,%ecx
r = (ctx->count[1] >> 3) & 0x7f;
113716: 8b 57 4c mov 0x4c(%edi),%edx
113719: 0f ac d0 03 shrd $0x3,%edx,%eax
11371d: 89 c3 mov %eax,%ebx
11371f: 83 e3 7f and $0x7f,%ebx
plen = (r < 112) ? (112 - r) : (240 - r);
113722: 39 d9 cmp %ebx,%ecx
r = (ctx->count[1] >> 3) & 0x7f;
113724: 89 d8 mov %ebx,%eax
plen = (r < 112) ? (112 - r) : (240 - r);
113726: 0f 82 a4 00 00 00 jb 1137d0 <SHA512_Final+0xe0>
11372c: b9 70 00 00 00 mov $0x70,%ecx
SHA512_Update(ctx, PAD, (size_t)plen);
113731: 89 3c 24 mov %edi,(%esp)
plen = (r < 112) ? (112 - r) : (240 - r);
113734: 29 c1 sub %eax,%ecx
SHA512_Update(ctx, PAD, (size_t)plen);
113736: b8 c0 f9 12 00 mov $0x12f9c0,%eax
11373b: 89 4c 24 08 mov %ecx,0x8(%esp)
/* Write the hash */
be64enc_vect(digest, ctx->state, 64);
/* Clear the context state */
memset((void *)ctx, 0, sizeof(*ctx));
11373f: 89 fb mov %edi,%ebx
SHA512_Update(ctx, PAD, (size_t)plen);
113741: 89 44 24 04 mov %eax,0x4(%esp)
113745: e8 96 fc ff ff call 1133e0 <SHA512_Update>
SHA512_Update(ctx, len, 16);
11374a: ba 10 00 00 00 mov $0x10,%edx
11374f: 89 54 24 08 mov %edx,0x8(%esp)
113753: 89 74 24 04 mov %esi,0x4(%esp)
113757: 89 3c 24 mov %edi,(%esp)
11375a: e8 81 fc ff ff call 1133e0 <SHA512_Update>
be64enc_vect(digest, ctx->state, 64);
11375f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
113762: b9 40 00 00 00 mov $0x40,%ecx <== NOT EXECUTED
113767: 89 fa mov %edi,%edx <== NOT EXECUTED
113769: e8 62 55 ff ff call 108cd0 <be64enc_vect> <== NOT EXECUTED
memset((void *)ctx, 0, sizeof(*ctx));
11376e: 31 d2 xor %edx,%edx
113770: f6 c3 01 test $0x1,%bl
113773: b9 d0 00 00 00 mov $0xd0,%ecx
113778: 75 66 jne 1137e0 <SHA512_Final+0xf0> <== NEVER TAKEN
11377a: f6 c3 02 test $0x2,%bl
11377d: 75 71 jne 1137f0 <SHA512_Final+0x100> <== NEVER TAKEN
11377f: 89 ce mov %ecx,%esi
113781: 31 c0 xor %eax,%eax
113783: 83 e6 f8 and $0xfffffff8,%esi
113786: 89 14 03 mov %edx,(%ebx,%eax,1)
113789: 89 54 03 04 mov %edx,0x4(%ebx,%eax,1)
11378d: 83 c0 08 add $0x8,%eax
113790: 39 f0 cmp %esi,%eax
113792: 72 f2 jb 113786 <SHA512_Final+0x96>
113794: 01 c3 add %eax,%ebx
113796: f6 c1 04 test $0x4,%cl
113799: 74 09 je 1137a4 <SHA512_Final+0xb4> <== ALWAYS TAKEN
11379b: c7 03 00 00 00 00 movl $0x0,(%ebx) <== NOT EXECUTED
1137a1: 83 c3 04 add $0x4,%ebx <== NOT EXECUTED
1137a4: f6 c1 02 test $0x2,%cl
1137a7: 74 08 je 1137b1 <SHA512_Final+0xc1> <== ALWAYS TAKEN
1137a9: 66 c7 03 00 00 movw $0x0,(%ebx) <== NOT EXECUTED
1137ae: 83 c3 02 add $0x2,%ebx <== NOT EXECUTED
1137b1: f6 c1 01 test $0x1,%cl
1137b4: 74 03 je 1137b9 <SHA512_Final+0xc9> <== ALWAYS TAKEN
1137b6: c6 03 00 movb $0x0,(%ebx) <== NOT EXECUTED
}
1137b9: 83 c4 2c add $0x2c,%esp
1137bc: 5b pop %ebx
1137bd: 5e pop %esi
1137be: 5f pop %edi
1137bf: 5d pop %ebp
1137c0: c3 ret
1137c1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1137c8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1137cf: 90 nop
plen = (r < 112) ? (112 - r) : (240 - r);
1137d0: b9 f0 00 00 00 mov $0xf0,%ecx
1137d5: e9 57 ff ff ff jmp 113731 <SHA512_Final+0x41>
1137da: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
memset((void *)ctx, 0, sizeof(*ctx));
1137e0: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED
1137e3: 43 inc %ebx <== NOT EXECUTED
1137e4: b9 cf 00 00 00 mov $0xcf,%ecx <== NOT EXECUTED
1137e9: f6 c3 02 test $0x2,%bl <== NOT EXECUTED
1137ec: 74 91 je 11377f <SHA512_Final+0x8f> <== NOT EXECUTED
1137ee: 66 90 xchg %ax,%ax <== NOT EXECUTED
1137f0: 66 c7 03 00 00 movw $0x0,(%ebx) <== NOT EXECUTED
1137f5: 83 e9 02 sub $0x2,%ecx <== NOT EXECUTED
1137f8: 83 c3 02 add $0x2,%ebx <== NOT EXECUTED
1137fb: eb 82 jmp 11377f <SHA512_Final+0x8f> <== NOT EXECUTED
1137fd: 90 nop
1137fe: 90 nop
1137ff: 90 nop
001133e0 <SHA512_Update>:
/* Add bytes into the hash */
void
SHA512_Update(SHA512_CTX * ctx, const void *in, size_t len)
{
1133e0: 55 push %ebp
1133e1: 89 e5 mov %esp,%ebp
1133e3: 57 push %edi
1133e4: 56 push %esi
1133e5: 53 push %ebx
1133e6: 83 ec 14 sub $0x14,%esp
uint64_t bitlen[2];
uint64_t r;
const unsigned char *src = in;
/* Number of bytes left in the buffer from previous updates */
r = (ctx->count[1] >> 3) & 0x7f;
1133e9: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp)
{
1133f0: 8b 45 08 mov 0x8(%ebp),%eax
r = (ctx->count[1] >> 3) & 0x7f;
1133f3: 8b 70 48 mov 0x48(%eax),%esi
1133f6: 8b 78 4c mov 0x4c(%eax),%edi
1133f9: 89 f1 mov %esi,%ecx
1133fb: 89 fb mov %edi,%ebx
1133fd: 0f ac d9 03 shrd $0x3,%ebx,%ecx
113401: 89 ca mov %ecx,%edx
/* Convert the length into a number of bits */
bitlen[1] = ((uint64_t)len) << 3;
113403: 31 c9 xor %ecx,%ecx
113405: 89 4d e4 mov %ecx,-0x1c(%ebp)
r = (ctx->count[1] >> 3) & 0x7f;
113408: 83 e2 7f and $0x7f,%edx
bitlen[1] = ((uint64_t)len) << 3;
11340b: 89 cb mov %ecx,%ebx
r = (ctx->count[1] >> 3) & 0x7f;
11340d: 89 55 e8 mov %edx,-0x18(%ebp)
bitlen[1] = ((uint64_t)len) << 3;
113410: 8b 55 10 mov 0x10(%ebp),%edx
113413: 89 55 e0 mov %edx,-0x20(%ebp)
113416: 89 d1 mov %edx,%ecx
113418: 0f a4 cb 03 shld $0x3,%ecx,%ebx
11341c: c1 e1 03 shl $0x3,%ecx
11341f: 01 f1 add %esi,%ecx
113421: 11 fb adc %edi,%ebx
113423: 0f 82 b4 02 00 00 jb 1136dd <SHA512_Update+0x2fd> <== NEVER TAKEN
113429: 31 d2 xor %edx,%edx
bitlen[0] = ((uint64_t)len) >> 61;
/* Update number of bits */
if ((ctx->count[1] += bitlen[1]) < bitlen[1])
11342b: 89 48 48 mov %ecx,0x48(%eax)
11342e: 85 d2 test %edx,%edx
113430: 89 58 4c mov %ebx,0x4c(%eax)
113433: 74 08 je 11343d <SHA512_Update+0x5d> <== ALWAYS TAKEN
ctx->count[0]++;
113435: 83 40 40 01 addl $0x1,0x40(%eax) <== NOT EXECUTED
113439: 83 50 44 00 adcl $0x0,0x44(%eax) <== NOT EXECUTED
ctx->count[0] += bitlen[0];
/* Handle the case where we don't need to perform any transforms */
if (len < 128 - r) {
11343d: b9 80 00 00 00 mov $0x80,%ecx
113442: 31 db xor %ebx,%ebx
113444: 8b 55 e4 mov -0x1c(%ebp),%edx
113447: 2b 4d e8 sub -0x18(%ebp),%ecx
11344a: 8b 75 e8 mov -0x18(%ebp),%esi
11344d: 1b 5d ec sbb -0x14(%ebp),%ebx
113450: 39 4d 10 cmp %ecx,0x10(%ebp)
memcpy(&ctx->buf[r], src, len);
113453: 8d 7c 30 50 lea 0x50(%eax,%esi,1),%edi
if (len < 128 - r) {
113457: 19 da sbb %ebx,%edx
113459: 0f 82 c1 01 00 00 jb 113620 <SHA512_Update+0x240>
return;
}
/* Finish the current block */
memcpy(&ctx->buf[r], src, 128 - r);
11345f: ba 80 00 00 00 mov $0x80,%edx
113464: 8b 4d 0c mov 0xc(%ebp),%ecx
113467: 89 d3 mov %edx,%ebx
113469: 29 f3 sub %esi,%ebx
11346b: 89 5d e8 mov %ebx,-0x18(%ebp)
11346e: 83 fb 04 cmp $0x4,%ebx
113471: 0f 83 49 01 00 00 jae 1135c0 <SHA512_Update+0x1e0>
113477: 31 d2 xor %edx,%edx
113479: f6 45 e8 02 testb $0x2,-0x18(%ebp)
11347d: 0f 85 cd 00 00 00 jne 113550 <SHA512_Update+0x170>
113483: f6 45 e8 01 testb $0x1,-0x18(%ebp)
113487: 0f 85 b3 00 00 00 jne 113540 <SHA512_Update+0x160>
SHA512_Transform(ctx->state, ctx->buf);
11348d: 89 45 08 mov %eax,0x8(%ebp)
113490: 8d 50 50 lea 0x50(%eax),%edx
113493: 89 55 e8 mov %edx,-0x18(%ebp)
113496: e8 95 58 ff ff call 108d30 <SHA512_Transform>
src += 128 - r;
11349b: 8b 45 0c mov 0xc(%ebp),%eax
11349e: 01 c3 add %eax,%ebx
len -= 128 - r;
1134a0: 8b 45 10 mov 0x10(%ebp),%eax
src += 128 - r;
1134a3: 89 df mov %ebx,%edi
len -= 128 - r;
1134a5: 8d 74 06 80 lea -0x80(%esi,%eax,1),%esi
/* Perform complete blocks */
while (len >= 128) {
1134a9: 8b 45 08 mov 0x8(%ebp),%eax
1134ac: 83 fe 7f cmp $0x7f,%esi
1134af: 76 37 jbe 1134e8 <SHA512_Update+0x108> <== ALWAYS TAKEN
1134b1: 89 75 e0 mov %esi,-0x20(%ebp) <== NOT EXECUTED
1134b4: 8d 4e 80 lea -0x80(%esi),%ecx <== NOT EXECUTED
1134b7: 89 c6 mov %eax,%esi <== NOT EXECUTED
1134b9: 83 e1 80 and $0xffffff80,%ecx <== NOT EXECUTED
1134bc: 8d 9c 0b 80 00 00 00 lea 0x80(%ebx,%ecx,1),%ebx <== NOT EXECUTED
1134c3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1134ca: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
SHA512_Transform(ctx->state, src);
1134d0: 89 fa mov %edi,%edx <== NOT EXECUTED
1134d2: 89 f0 mov %esi,%eax <== NOT EXECUTED
1134d4: e8 57 58 ff ff call 108d30 <SHA512_Transform> <== NOT EXECUTED
src += 128;
1134d9: 83 ef 80 sub $0xffffff80,%edi <== NOT EXECUTED
while (len >= 128) {
1134dc: 39 df cmp %ebx,%edi <== NOT EXECUTED
1134de: 75 f0 jne 1134d0 <SHA512_Update+0xf0> <== NOT EXECUTED
len -= 128;
1134e0: 89 f0 mov %esi,%eax <== NOT EXECUTED
1134e2: 8b 75 e0 mov -0x20(%ebp),%esi <== NOT EXECUTED
1134e5: 83 e6 7f and $0x7f,%esi <== NOT EXECUTED
}
/* Copy left over data into buffer */
memcpy(ctx->buf, src, len);
1134e8: 83 fe 04 cmp $0x4,%esi
1134eb: 8b 7d e8 mov -0x18(%ebp),%edi
1134ee: 0f 83 7c 00 00 00 jae 113570 <SHA512_Update+0x190>
1134f4: 31 c0 xor %eax,%eax
1134f6: f7 c6 02 00 00 00 test $0x2,%esi
1134fc: 75 22 jne 113520 <SHA512_Update+0x140>
1134fe: 83 e6 01 and $0x1,%esi
113501: 75 0d jne 113510 <SHA512_Update+0x130>
}
113503: 83 c4 14 add $0x14,%esp
113506: 5b pop %ebx
113507: 5e pop %esi
113508: 5f pop %edi
113509: 5d pop %ebp
11350a: c3 ret
11350b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
11350f: 90 nop
memcpy(ctx->buf, src, len);
113510: 0f b6 1c 03 movzbl (%ebx,%eax,1),%ebx <== NOT EXECUTED
113514: 88 1c 07 mov %bl,(%edi,%eax,1) <== NOT EXECUTED
}
113517: 83 c4 14 add $0x14,%esp <== NOT EXECUTED
11351a: 5b pop %ebx <== NOT EXECUTED
11351b: 5e pop %esi <== NOT EXECUTED
11351c: 5f pop %edi <== NOT EXECUTED
11351d: 5d pop %ebp <== NOT EXECUTED
11351e: c3 ret <== NOT EXECUTED
11351f: 90 nop <== NOT EXECUTED
memcpy(ctx->buf, src, len);
113520: 0f b7 03 movzwl (%ebx),%eax
113523: 83 e6 01 and $0x1,%esi
113526: 66 89 07 mov %ax,(%edi)
113529: b8 02 00 00 00 mov $0x2,%eax
11352e: 74 d3 je 113503 <SHA512_Update+0x123>
113530: eb de jmp 113510 <SHA512_Update+0x130>
113532: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
113539: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
memcpy(&ctx->buf[r], src, 128 - r);
113540: 0f b6 0c 11 movzbl (%ecx,%edx,1),%ecx
113544: 88 0c 17 mov %cl,(%edi,%edx,1)
113547: e9 41 ff ff ff jmp 11348d <SHA512_Update+0xad>
11354c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
113550: 0f b7 11 movzwl (%ecx),%edx
113553: 66 89 17 mov %dx,(%edi)
113556: ba 02 00 00 00 mov $0x2,%edx
11355b: f6 45 e8 01 testb $0x1,-0x18(%ebp)
11355f: 0f 84 28 ff ff ff je 11348d <SHA512_Update+0xad>
113565: eb d9 jmp 113540 <SHA512_Update+0x160>
113567: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11356e: 66 90 xchg %ax,%ax
memcpy(ctx->buf, src, len);
113570: f7 c7 01 00 00 00 test $0x1,%edi
113576: 0f 85 f2 00 00 00 jne 11366e <SHA512_Update+0x28e> <== NEVER TAKEN
11357c: f7 c7 02 00 00 00 test $0x2,%edi
113582: 0f 85 20 01 00 00 jne 1136a8 <SHA512_Update+0x2c8> <== NEVER TAKEN
113588: 83 fe 04 cmp $0x4,%esi
11358b: 0f 82 63 ff ff ff jb 1134f4 <SHA512_Update+0x114> <== NEVER TAKEN
113591: 89 f1 mov %esi,%ecx
113593: 31 c0 xor %eax,%eax
113595: 83 e1 fc and $0xfffffffc,%ecx
113598: 8b 14 03 mov (%ebx,%eax,1),%edx
11359b: 89 14 07 mov %edx,(%edi,%eax,1)
11359e: 83 c0 04 add $0x4,%eax
1135a1: 39 c8 cmp %ecx,%eax
1135a3: 72 f3 jb 113598 <SHA512_Update+0x1b8>
1135a5: 01 c7 add %eax,%edi
1135a7: 01 c3 add %eax,%ebx
1135a9: 31 c0 xor %eax,%eax
1135ab: f7 c6 02 00 00 00 test $0x2,%esi
1135b1: 0f 84 47 ff ff ff je 1134fe <SHA512_Update+0x11e>
1135b7: e9 64 ff ff ff jmp 113520 <SHA512_Update+0x140>
1135bc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
memcpy(&ctx->buf[r], src, 128 - r);
1135c0: f7 c7 01 00 00 00 test $0x1,%edi
1135c6: 0f 85 b0 00 00 00 jne 11367c <SHA512_Update+0x29c>
1135cc: f7 c7 02 00 00 00 test $0x2,%edi
1135d2: 0f 85 ba 00 00 00 jne 113692 <SHA512_Update+0x2b2>
1135d8: 8b 55 e8 mov -0x18(%ebp),%edx
1135db: 83 fa 04 cmp $0x4,%edx
1135de: 0f 82 93 fe ff ff jb 113477 <SHA512_Update+0x97> <== NEVER TAKEN
1135e4: 89 45 08 mov %eax,0x8(%ebp)
1135e7: 83 e2 fc and $0xfffffffc,%edx
1135ea: 89 55 e0 mov %edx,-0x20(%ebp)
1135ed: 31 d2 xor %edx,%edx
1135ef: 8b 04 11 mov (%ecx,%edx,1),%eax
1135f2: 89 04 17 mov %eax,(%edi,%edx,1)
1135f5: 83 c2 04 add $0x4,%edx
1135f8: 3b 55 e0 cmp -0x20(%ebp),%edx
1135fb: 72 f2 jb 1135ef <SHA512_Update+0x20f>
1135fd: 01 d7 add %edx,%edi
1135ff: 01 d1 add %edx,%ecx
113601: 8b 45 08 mov 0x8(%ebp),%eax
113604: 31 d2 xor %edx,%edx
113606: f6 45 e8 02 testb $0x2,-0x18(%ebp)
11360a: 0f 84 73 fe ff ff je 113483 <SHA512_Update+0xa3> <== ALWAYS TAKEN
113610: e9 3b ff ff ff jmp 113550 <SHA512_Update+0x170> <== NOT EXECUTED
113615: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11361c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
memcpy(&ctx->buf[r], src, len);
113620: 8b 4d 10 mov 0x10(%ebp),%ecx
113623: 8b 75 0c mov 0xc(%ebp),%esi
113626: 83 f9 08 cmp $0x8,%ecx
113629: 73 15 jae 113640 <SHA512_Update+0x260>
11362b: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
}
11362d: 83 c4 14 add $0x14,%esp
113630: 5b pop %ebx
113631: 5e pop %esi
113632: 5f pop %edi
113633: 5d pop %ebp
113634: c3 ret
113635: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11363c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
memcpy(&ctx->buf[r], src, len);
113640: f7 c7 01 00 00 00 test $0x1,%edi
113646: 0f 85 83 00 00 00 jne 1136cf <SHA512_Update+0x2ef>
11364c: f7 c7 02 00 00 00 test $0x2,%edi
113652: 75 69 jne 1136bd <SHA512_Update+0x2dd>
113654: f7 c7 04 00 00 00 test $0x4,%edi
11365a: 74 cf je 11362b <SHA512_Update+0x24b>
11365c: 8b 06 mov (%esi),%eax
11365e: 83 c7 04 add $0x4,%edi
113661: 83 c6 04 add $0x4,%esi
113664: 83 e9 04 sub $0x4,%ecx
113667: 89 47 fc mov %eax,-0x4(%edi)
11366a: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
return;
11366c: eb bf jmp 11362d <SHA512_Update+0x24d>
memcpy(ctx->buf, src, len);
11366e: 0f b6 13 movzbl (%ebx),%edx <== NOT EXECUTED
113671: 47 inc %edi <== NOT EXECUTED
113672: 43 inc %ebx <== NOT EXECUTED
113673: 4e dec %esi <== NOT EXECUTED
113674: 88 50 50 mov %dl,0x50(%eax) <== NOT EXECUTED
113677: e9 00 ff ff ff jmp 11357c <SHA512_Update+0x19c> <== NOT EXECUTED
memcpy(&ctx->buf[r], src, 128 - r);
11367c: 0f b6 11 movzbl (%ecx),%edx
11367f: 47 inc %edi
113680: 88 57 ff mov %dl,-0x1(%edi)
113683: 8d 53 ff lea -0x1(%ebx),%edx
113686: 89 55 e8 mov %edx,-0x18(%ebp)
113689: 8b 4d 0c mov 0xc(%ebp),%ecx
11368c: 41 inc %ecx
11368d: e9 3a ff ff ff jmp 1135cc <SHA512_Update+0x1ec>
113692: 0f b7 11 movzwl (%ecx),%edx
113695: 83 c7 02 add $0x2,%edi
113698: 83 c1 02 add $0x2,%ecx
11369b: 66 89 57 fe mov %dx,-0x2(%edi)
11369f: 83 6d e8 02 subl $0x2,-0x18(%ebp)
1136a3: e9 30 ff ff ff jmp 1135d8 <SHA512_Update+0x1f8>
memcpy(ctx->buf, src, len);
1136a8: 0f b7 03 movzwl (%ebx),%eax <== NOT EXECUTED
1136ab: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
1136ae: 83 c3 02 add $0x2,%ebx <== NOT EXECUTED
1136b1: 83 ee 02 sub $0x2,%esi <== NOT EXECUTED
1136b4: 66 89 47 fe mov %ax,-0x2(%edi) <== NOT EXECUTED
1136b8: e9 cb fe ff ff jmp 113588 <SHA512_Update+0x1a8> <== NOT EXECUTED
memcpy(&ctx->buf[r], src, len);
1136bd: 0f b7 06 movzwl (%esi),%eax
1136c0: 83 c7 02 add $0x2,%edi
1136c3: 83 c6 02 add $0x2,%esi
1136c6: 83 e9 02 sub $0x2,%ecx
1136c9: 66 89 47 fe mov %ax,-0x2(%edi)
1136cd: eb 85 jmp 113654 <SHA512_Update+0x274>
1136cf: 0f b6 06 movzbl (%esi),%eax
1136d2: 47 inc %edi
1136d3: 46 inc %esi
1136d4: 49 dec %ecx
1136d5: 88 47 ff mov %al,-0x1(%edi)
1136d8: e9 6f ff ff ff jmp 11364c <SHA512_Update+0x26c>
1136dd: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED
1136e2: e9 44 fd ff ff jmp 11342b <SHA512_Update+0x4b> <== NOT EXECUTED
1136e7: 90 nop
1136e8: 90 nop
1136e9: 90 nop
1136ea: 90 nop
1136eb: 90 nop
1136ec: 90 nop
1136ed: 90 nop
1136ee: 90 nop
1136ef: 90 nop