RTEMS-6
Annotated Report
libmd
Sun Feb 28 22:41:07 2021
400066cc <MD5Final>:
{
400066cc: 9d e3 bf 60 save %sp, -160, %sp
in[14] = mdContext->i[0];
400066d0: d4 06 40 00 ld [ %i1 ], %o2
in[15] = mdContext->i[1];
400066d4: c2 06 60 04 ld [ %i1 + 4 ], %g1
in[14] = mdContext->i[0];
400066d8: d4 27 bf f8 st %o2, [ %fp + -8 ]
mdi = (int)((mdContext->i[0] >> 3) & 0x3F);
400066dc: 95 32 a0 03 srl %o2, 3, %o2
400066e0: 94 0a a0 3f and %o2, 0x3f, %o2
padLen = (mdi < 56) ? (56 - mdi) : (120 - mdi);
400066e4: 80 a2 a0 37 cmp %o2, 0x37
400066e8: 14 80 00 2e bg 400067a0 <MD5Final+0xd4> <== NEVER TAKEN
400066ec: c2 27 bf fc st %g1, [ %fp + -4 ]
400066f0: 82 10 20 38 mov 0x38, %g1
400066f4: 94 20 40 0a sub %g1, %o2, %o2
MD5Update (mdContext, PADDING, padLen);
400066f8: 90 10 00 19 mov %i1, %o0
400066fc: 13 10 00 93 sethi %hi(0x40024c00), %o1
40006700: 7f ff ff bf call 400065fc <MD5Update>
40006704: 92 12 61 78 or %o1, 0x178, %o1 ! 40024d78 <PADDING>
for (i = 0, ii = 0; i < 14; i++, ii += 4)
40006708: b4 06 60 18 add %i1, 0x18, %i2
4000670c: 86 07 bf c0 add %fp, -64, %g3
40006710: 84 10 00 1a mov %i2, %g2
40006714: b6 07 bf f8 add %fp, -8, %i3
in[i] = (((UINT4)mdContext->in[ii+3]) << 24) |
40006718: c2 08 a0 03 ldub [ %g2 + 3 ], %g1
(((UINT4)mdContext->in[ii+2]) << 16) |
4000671c: fa 08 a0 02 ldub [ %g2 + 2 ], %i5
((UINT4)mdContext->in[ii]);
40006720: f8 08 80 00 ldub [ %g2 ], %i4
(((UINT4)mdContext->in[ii+1]) << 8) |
40006724: c8 08 a0 01 ldub [ %g2 + 1 ], %g4
in[i] = (((UINT4)mdContext->in[ii+3]) << 24) |
40006728: 83 28 60 18 sll %g1, 0x18, %g1
(((UINT4)mdContext->in[ii+2]) << 16) |
4000672c: bb 2f 60 10 sll %i5, 0x10, %i5
(((UINT4)mdContext->in[ii+1]) << 8) |
40006730: 89 29 20 08 sll %g4, 8, %g4
in[i] = (((UINT4)mdContext->in[ii+3]) << 24) |
40006734: 82 10 40 1d or %g1, %i5, %g1
(((UINT4)mdContext->in[ii+1]) << 8) |
40006738: 82 10 40 1c or %g1, %i4, %g1
4000673c: 82 10 40 04 or %g1, %g4, %g1
in[i] = (((UINT4)mdContext->in[ii+3]) << 24) |
40006740: c2 20 c0 00 st %g1, [ %g3 ]
for (i = 0, ii = 0; i < 14; i++, ii += 4)
40006744: 86 00 e0 04 add %g3, 4, %g3
40006748: 80 a6 c0 03 cmp %i3, %g3
4000674c: 12 bf ff f3 bne 40006718 <MD5Final+0x4c>
40006750: 84 00 a0 04 add %g2, 4, %g2
Transform (mdContext->buf, in);
40006754: 90 06 60 08 add %i1, 8, %o0
40006758: 92 07 bf c0 add %fp, -64, %o1
4000675c: 7f ff fc 58 call 400058bc <Transform>
40006760: ba 10 00 08 mov %o0, %i5
for (i = 0, ii = 0; i < 4; i++, ii += 4) {
40006764: 90 10 00 1d mov %i5, %o0
mdContext->digest[ii] = (unsigned char)(mdContext->buf[i] & 0xFF);
40006768: c2 02 00 00 ld [ %o0 ], %g1
4000676c: c2 2a 20 50 stb %g1, [ %o0 + 0x50 ]
(unsigned char)((mdContext->buf[i] >> 8) & 0xFF);
40006770: 87 30 60 08 srl %g1, 8, %g3
(unsigned char)((mdContext->buf[i] >> 16) & 0xFF);
40006774: 85 30 60 10 srl %g1, 0x10, %g2
(unsigned char)((mdContext->buf[i] >> 8) & 0xFF);
40006778: c6 2a 20 51 stb %g3, [ %o0 + 0x51 ]
(unsigned char)((mdContext->buf[i] >> 24) & 0xFF);
4000677c: 83 30 60 18 srl %g1, 0x18, %g1
(unsigned char)((mdContext->buf[i] >> 16) & 0xFF);
40006780: c4 2a 20 52 stb %g2, [ %o0 + 0x52 ]
for (i = 0, ii = 0; i < 4; i++, ii += 4) {
40006784: 90 02 20 04 add %o0, 4, %o0
40006788: 80 a6 80 08 cmp %i2, %o0
4000678c: 12 bf ff f7 bne 40006768 <MD5Final+0x9c>
40006790: c2 2a 20 4f stb %g1, [ %o0 + 0x4f ]
memcpy(hash, mdContext->digest, 16);
40006794: b4 10 20 10 mov 0x10, %i2
40006798: 40 00 4e d4 call 4001a2e8 <memcpy>
4000679c: 93 ee 60 58 restore %i1, 0x58, %o1
padLen = (mdi < 56) ? (56 - mdi) : (120 - mdi);
400067a0: 82 10 20 78 mov 0x78, %g1 <== NOT EXECUTED
400067a4: 10 bf ff d5 b 400066f8 <MD5Final+0x2c> <== NOT EXECUTED
400067a8: 94 20 40 0a sub %g1, %o2, %o2 <== NOT EXECUTED
400065fc <MD5Update>:
{
400065fc: 9d e3 bf 60 save %sp, -160, %sp
mdi = (int)((mdContext->i[0] >> 3) & 0x3F);
40006600: c2 06 00 00 ld [ %i0 ], %g1
mdContext->i[1]++;
40006604: c6 06 20 04 ld [ %i0 + 4 ], %g3
if ((mdContext->i[0] + ((UINT4)inLen << 3)) < mdContext->i[0])
40006608: 85 2e a0 03 sll %i2, 3, %g2
mdContext->i[1] += ((UINT4)inLen >> 29);
4000660c: 89 36 a0 1d srl %i2, 0x1d, %g4
40006610: 84 80 40 02 addcc %g1, %g2, %g2
40006614: 86 40 c0 04 addx %g3, %g4, %g3
mdContext->i[0] += ((UINT4)inLen << 3);
40006618: c4 26 00 00 st %g2, [ %i0 ]
mdi = (int)((mdContext->i[0] >> 3) & 0x3F);
4000661c: 83 30 60 03 srl %g1, 3, %g1
mdContext->i[1] += ((UINT4)inLen >> 29);
40006620: c6 26 20 04 st %g3, [ %i0 + 4 ]
40006624: a0 06 40 1a add %i1, %i2, %l0
mdi = (int)((mdContext->i[0] >> 3) & 0x3F);
40006628: 82 08 60 3f and %g1, 0x3f, %g1
while (inLen--) {
4000662c: b6 10 00 1e mov %fp, %i3
40006630: 80 a6 a0 00 cmp %i2, 0
40006634: 12 80 00 06 bne 4000664c <MD5Update+0x50> <== ALWAYS TAKEN
40006638: a2 06 20 08 add %i0, 8, %l1
4000663c: 30 80 00 22 b,a 400066c4 <MD5Update+0xc8> <== NOT EXECUTED
40006640: 80 a6 40 10 cmp %i1, %l0
40006644: 02 80 00 20 be 400066c4 <MD5Update+0xc8>
40006648: 01 00 00 00 nop
mdContext->in[mdi++] = *inBuf++;
4000664c: c6 0e 40 00 ldub [ %i1 ], %g3
40006650: 84 06 00 01 add %i0, %g1, %g2
40006654: c6 28 a0 18 stb %g3, [ %g2 + 0x18 ]
40006658: 82 00 60 01 inc %g1
if (mdi == 0x40) {
4000665c: 80 a0 60 40 cmp %g1, 0x40
40006660: 12 bf ff f8 bne 40006640 <MD5Update+0x44>
40006664: b2 06 60 01 inc %i1
40006668: 84 06 20 18 add %i0, 0x18, %g2
4000666c: 86 07 bf c0 add %fp, -64, %g3
in[i] = (((UINT4)mdContext->in[ii+3]) << 24) |
40006670: c2 08 a0 03 ldub [ %g2 + 3 ], %g1
(((UINT4)mdContext->in[ii+2]) << 16) |
40006674: fa 08 a0 02 ldub [ %g2 + 2 ], %i5
((UINT4)mdContext->in[ii]);
40006678: f8 08 80 00 ldub [ %g2 ], %i4
(((UINT4)mdContext->in[ii+1]) << 8) |
4000667c: c8 08 a0 01 ldub [ %g2 + 1 ], %g4
in[i] = (((UINT4)mdContext->in[ii+3]) << 24) |
40006680: 83 28 60 18 sll %g1, 0x18, %g1
(((UINT4)mdContext->in[ii+2]) << 16) |
40006684: bb 2f 60 10 sll %i5, 0x10, %i5
(((UINT4)mdContext->in[ii+1]) << 8) |
40006688: 89 29 20 08 sll %g4, 8, %g4
in[i] = (((UINT4)mdContext->in[ii+3]) << 24) |
4000668c: 82 10 40 1d or %g1, %i5, %g1
(((UINT4)mdContext->in[ii+1]) << 8) |
40006690: 82 10 40 1c or %g1, %i4, %g1
40006694: 82 10 40 04 or %g1, %g4, %g1
in[i] = (((UINT4)mdContext->in[ii+3]) << 24) |
40006698: c2 20 c0 00 st %g1, [ %g3 ]
for (i = 0, ii = 0; i < 16; i++, ii += 4)
4000669c: 86 00 e0 04 add %g3, 4, %g3
400066a0: 80 a6 c0 03 cmp %i3, %g3
400066a4: 12 bf ff f3 bne 40006670 <MD5Update+0x74>
400066a8: 84 00 a0 04 add %g2, 4, %g2
Transform (mdContext->buf, in);
400066ac: 92 07 bf c0 add %fp, -64, %o1
400066b0: 7f ff fc 83 call 400058bc <Transform>
400066b4: 90 10 00 11 mov %l1, %o0
while (inLen--) {
400066b8: 80 a6 40 10 cmp %i1, %l0
400066bc: 12 bf ff e4 bne 4000664c <MD5Update+0x50>
400066c0: 82 10 20 00 clr %g1
}
400066c4: 81 c7 e0 08 ret
400066c8: 81 e8 00 00 restore
4000902c <SHA256_Update>:
/* Add bytes into the hash */
void
SHA256_Update(SHA256_CTX * ctx, const void *in, size_t len)
{
4000902c: 9d e3 bf a0 save %sp, -96, %sp
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;
40009030: c4 1e 20 20 ldd [ %i0 + 0x20 ], %g2
/* Convert the length into a number of bits */
bitlen = len << 3;
40009034: 83 2e a0 03 sll %i2, 3, %g1
/* Update number of bits */
ctx->count += bitlen;
40009038: 9a 80 c0 01 addcc %g3, %g1, %o5
4000903c: 98 40 a0 00 addx %g2, 0, %o4
40009040: d8 3e 20 20 std %o4, [ %i0 + 0x20 ]
r = (ctx->count >> 3) & 0x3f;
40009044: b7 30 e0 03 srl %g3, 3, %i3
/* Handle the case where we don't need to perform any transforms */
if (len < 64 - r) {
40009048: ba 10 20 40 mov 0x40, %i5
r = (ctx->count >> 3) & 0x3f;
4000904c: b6 0e e0 3f and %i3, 0x3f, %i3
{
40009050: b8 10 00 18 mov %i0, %i4
if (len < 64 - r) {
40009054: ba 27 40 1b sub %i5, %i3, %i5
memcpy(&ctx->buf[r], src, len);
40009058: 90 06 e0 28 add %i3, 0x28, %o0
if (len < 64 - r) {
4000905c: 80 a7 40 1a cmp %i5, %i2
40009060: 18 80 00 1c bgu 400090d0 <SHA256_Update+0xa4>
40009064: 90 06 00 08 add %i0, %o0, %o0
return;
}
/* Finish the current block */
memcpy(&ctx->buf[r], src, 64 - r);
40009068: 94 10 00 1d mov %i5, %o2
4000906c: 40 00 44 9f call 4001a2e8 <memcpy>
40009070: 92 10 00 19 mov %i1, %o1
SHA256_Transform(ctx->state, ctx->buf);
40009074: b0 06 20 28 add %i0, 0x28, %i0
40009078: 90 10 00 1c mov %i4, %o0
4000907c: 7f ff f5 cc call 400067ac <SHA256_Transform>
40009080: 92 10 00 18 mov %i0, %o1
src += 64 - r;
40009084: b4 06 bf c0 add %i2, -64, %i2
len -= 64 - r;
40009088: b4 06 80 1b add %i2, %i3, %i2
/* Perform complete blocks */
while (len >= 64) {
4000908c: 80 a6 a0 3f cmp %i2, 0x3f
40009090: 08 80 00 12 bleu 400090d8 <SHA256_Update+0xac>
40009094: ba 06 40 1d add %i1, %i5, %i5
40009098: b2 06 bf c0 add %i2, -64, %i1
4000909c: b2 0e 7f c0 and %i1, -64, %i1
400090a0: b2 06 60 40 add %i1, 0x40, %i1
400090a4: b2 07 40 19 add %i5, %i1, %i1
SHA256_Transform(ctx->state, src);
400090a8: 92 10 00 1d mov %i5, %o1
400090ac: 7f ff f5 c0 call 400067ac <SHA256_Transform>
400090b0: 90 10 00 1c mov %i4, %o0
src += 64;
400090b4: ba 07 60 40 add %i5, 0x40, %i5
while (len >= 64) {
400090b8: 80 a7 40 19 cmp %i5, %i1
400090bc: 12 bf ff fc bne 400090ac <SHA256_Update+0x80> <== NEVER TAKEN
400090c0: 92 10 00 1d mov %i5, %o1
len -= 64;
400090c4: b4 0e a0 3f and %i2, 0x3f, %i2
}
/* Copy left over data into buffer */
memcpy(ctx->buf, src, len);
400090c8: 40 00 44 88 call 4001a2e8 <memcpy>
400090cc: 81 e8 00 00 restore
memcpy(&ctx->buf[r], src, len);
400090d0: 40 00 44 86 call 4001a2e8 <memcpy>
400090d4: 91 e8 00 08 restore %g0, %o0, %o0
memcpy(ctx->buf, src, len);
400090d8: 40 00 44 84 call 4001a2e8 <memcpy>
400090dc: 93 e8 00 1d restore %g0, %i5, %o1
40010900 <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)
{
40010900: 9d e3 bf 90 save %sp, -112, %sp
be64enc_vect(len, ctx->count, 16);
40010904: 94 10 20 10 mov 0x10, %o2
40010908: 92 06 60 40 add %i1, 0x40, %o1
4001090c: 40 00 26 77 call 4001a2e8 <memcpy>
40010910: 90 07 bf f0 add %fp, -16, %o0
r = (ctx->count[1] >> 3) & 0x7f;
40010914: c2 06 60 4c ld [ %i1 + 0x4c ], %g1
40010918: 83 30 60 03 srl %g1, 3, %g1
4001091c: 84 10 20 00 clr %g2
{
40010920: ba 10 00 19 mov %i1, %i5
plen = (r < 112) ? (112 - r) : (240 - r);
40010924: 80 a0 a0 00 cmp %g2, 0
40010928: 12 80 00 18 bne 40010988 <SHA512_Final+0x88> <== NEVER TAKEN
4001092c: 86 08 60 7f and %g1, 0x7f, %g3
40010930: 80 a0 e0 6f cmp %g3, 0x6f
40010934: 18 80 00 16 bgu 4001098c <SHA512_Final+0x8c>
40010938: 9a 10 20 f0 mov 0xf0, %o5
4001093c: 9a 10 20 70 mov 0x70, %o5
40010940: b6 a3 40 03 subcc %o5, %g3, %i3
SHA512_Update(ctx, PAD, (size_t)plen);
40010944: 94 10 00 1b mov %i3, %o2
40010948: 90 10 00 1d mov %i5, %o0
4001094c: 13 10 00 87 sethi %hi(0x40021c00), %o1
40010950: 7f ff ff af call 4001080c <SHA512_Update>
40010954: 92 12 63 20 or %o1, 0x320, %o1 ! 40021f20 <PAD>
SHA512_Update(ctx, len, 16);
40010958: 94 10 20 10 mov 0x10, %o2
4001095c: 92 07 bf f0 add %fp, -16, %o1
40010960: 7f ff ff ab call 4001080c <SHA512_Update>
40010964: 90 10 00 1d mov %i5, %o0
/* Add padding */
SHA512_Pad(ctx);
/* Write the hash */
be64enc_vect(digest, ctx->state, 64);
40010968: 90 10 00 18 mov %i0, %o0
4001096c: 94 10 20 40 mov 0x40, %o2
40010970: 92 10 00 1d mov %i5, %o1
40010974: 40 00 26 5d call 4001a2e8 <memcpy>
40010978: b4 10 20 d0 mov 0xd0, %i2
/* Clear the context state */
memset((void *)ctx, 0, sizeof(*ctx));
4001097c: b2 10 20 00 clr %i1
40010980: 40 00 26 99 call 4001a3e4 <memset>
40010984: 91 e8 00 1d restore %g0, %i5, %o0
plen = (r < 112) ? (112 - r) : (240 - r);
40010988: 9a 10 20 f0 mov 0xf0, %o5 <== NOT EXECUTED
4001098c: 10 bf ff ee b 40010944 <SHA512_Final+0x44>
40010990: b6 a3 40 03 subcc %o5, %g3, %i3
4001080c <SHA512_Update>:
/* Add bytes into the hash */
void
SHA512_Update(SHA512_CTX * ctx, const void *in, size_t len)
{
4001080c: 9d e3 bf a0 save %sp, -96, %sp
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;
40010810: c4 1e 20 48 ldd [ %i0 + 0x48 ], %g2
/* Convert the length into a number of bits */
bitlen[1] = ((uint64_t)len) << 3;
40010814: 99 36 a0 1d srl %i2, 0x1d, %o4
40010818: 9b 2e a0 03 sll %i2, 3, %o5
4001081c: 96 80 c0 0d addcc %g3, %o5, %o3
40010820: 94 c0 80 0c addxcc %g2, %o4, %o2
bitlen[0] = ((uint64_t)len) >> 61;
/* Update number of bits */
if ((ctx->count[1] += bitlen[1]) < bitlen[1])
40010824: d4 3e 20 48 std %o2, [ %i0 + 0x48 ]
r = (ctx->count[1] >> 3) & 0x7f;
40010828: 83 30 e0 03 srl %g3, 3, %g1
{
4001082c: b8 10 00 18 mov %i0, %i4
r = (ctx->count[1] >> 3) & 0x7f;
40010830: 84 10 20 00 clr %g2
if ((ctx->count[1] += bitlen[1]) < bitlen[1])
40010834: 1a 80 00 06 bcc 4001084c <SHA512_Update+0x40> <== ALWAYS TAKEN
40010838: 86 08 60 7f and %g1, 0x7f, %g3
ctx->count[0]++;
4001083c: d8 1e 20 40 ldd [ %i0 + 0x40 ], %o4 <== NOT EXECUTED
40010840: 96 83 60 01 addcc %o5, 1, %o3 <== NOT EXECUTED
40010844: 94 43 20 00 addx %o4, 0, %o2 <== NOT EXECUTED
40010848: d4 3e 20 40 std %o2, [ %i0 + 0x40 ] <== NOT EXECUTED
ctx->count[0] += bitlen[0];
/* Handle the case where we don't need to perform any transforms */
if (len < 128 - r) {
4001084c: 96 10 20 80 mov 0x80, %o3
40010850: 9a a2 c0 03 subcc %o3, %g3, %o5
memcpy(&ctx->buf[r], src, len);
40010854: 90 00 e0 50 add %g3, 0x50, %o0
if (len < 128 - r) {
40010858: 94 10 20 00 clr %o2
4001085c: b6 10 00 03 mov %g3, %i3
40010860: 98 62 80 02 subx %o2, %g2, %o4
40010864: 80 a3 20 00 cmp %o4, 0
40010868: 18 80 00 22 bgu 400108f0 <SHA512_Update+0xe4> <== NEVER TAKEN
4001086c: 90 07 00 08 add %i4, %o0, %o0
40010870: 02 80 00 1e be 400108e8 <SHA512_Update+0xdc> <== ALWAYS TAKEN
40010874: 80 a3 40 1a cmp %o5, %i2
return;
}
/* Finish the current block */
memcpy(&ctx->buf[r], src, 128 - r);
40010878: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4001087c: ba 10 20 80 mov 0x80, %i5
40010880: ba 27 40 1b sub %i5, %i3, %i5
40010884: 40 00 26 99 call 4001a2e8 <memcpy>
40010888: 94 10 00 1d mov %i5, %o2
SHA512_Transform(ctx->state, ctx->buf);
4001088c: b0 07 20 50 add %i4, 0x50, %i0
40010890: 90 10 00 1c mov %i4, %o0
40010894: 7f ff e2 3e call 4000918c <SHA512_Transform>
40010898: 92 10 00 18 mov %i0, %o1
src += 128 - r;
4001089c: b4 06 bf 80 add %i2, -128, %i2
len -= 128 - r;
400108a0: b4 06 c0 1a add %i3, %i2, %i2
/* Perform complete blocks */
while (len >= 128) {
400108a4: 80 a6 a0 7f cmp %i2, 0x7f
400108a8: 08 80 00 14 bleu 400108f8 <SHA512_Update+0xec> <== ALWAYS TAKEN
400108ac: ba 06 40 1d add %i1, %i5, %i5
400108b0: b2 06 bf 80 add %i2, -128, %i1 <== NOT EXECUTED
400108b4: b2 0e 7f 80 and %i1, -128, %i1 <== NOT EXECUTED
400108b8: b2 06 60 80 add %i1, 0x80, %i1 <== NOT EXECUTED
400108bc: b2 07 40 19 add %i5, %i1, %i1 <== NOT EXECUTED
SHA512_Transform(ctx->state, src);
400108c0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
400108c4: 7f ff e2 32 call 4000918c <SHA512_Transform> <== NOT EXECUTED
400108c8: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
src += 128;
400108cc: ba 07 60 80 add %i5, 0x80, %i5 <== NOT EXECUTED
while (len >= 128) {
400108d0: 80 a7 40 19 cmp %i5, %i1 <== NOT EXECUTED
400108d4: 12 bf ff fc bne 400108c4 <SHA512_Update+0xb8> <== NOT EXECUTED
400108d8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
len -= 128;
400108dc: b4 0e a0 7f and %i2, 0x7f, %i2 <== NOT EXECUTED
}
/* Copy left over data into buffer */
memcpy(ctx->buf, src, len);
400108e0: 40 00 26 82 call 4001a2e8 <memcpy> <== NOT EXECUTED
400108e4: 81 e8 00 00 restore <== NOT EXECUTED
if (len < 128 - r) {
400108e8: 08 bf ff e5 bleu 4001087c <SHA512_Update+0x70>
400108ec: 92 10 00 19 mov %i1, %o1
memcpy(&ctx->buf[r], src, len);
400108f0: 40 00 26 7e call 4001a2e8 <memcpy>
400108f4: 91 e8 00 08 restore %g0, %o0, %o0
memcpy(ctx->buf, src, len);
400108f8: 40 00 26 7c call 4001a2e8 <memcpy>
400108fc: 93 e8 00 1d restore %g0, %i5, %o1