RTEMS-6
Annotated Report
libuntar
Sun Feb 28 22:37:53 2021
40005a50 <Untar_FromChunk_Print>:
{
40005a50: 9d e3 bf a0 save %sp, -96, %sp
context->base.printer = printer;
40005a54: f6 26 20 7c st %i3, [ %i0 + 0x7c ]
while (todo > 0) {
40005a58: 80 a6 a0 00 cmp %i2, 0
40005a5c: 02 80 00 25 be 40005af0 <Untar_FromChunk_Print+0xa0>
40005a60: ba 10 00 18 mov %i0, %i5
if (strncmp(&bufr[257], "ustar", 5)) {
40005a64: 21 10 00 60 sethi %hi(0x40018000), %l0
done = 0;
40005a68: b6 10 20 00 clr %i3
context->out_fd = -1;
40005a6c: aa 10 3f ff mov -1, %l5
context->state = UNTAR_CHUNK_SKIP;
40005a70: a4 10 20 01 mov 1, %l2
remaining = 512 - context->done_bytes;
40005a74: a2 10 22 00 mov 0x200, %l1
ctx->linkflag = -1;
40005a78: a8 10 3f ff mov -1, %l4
if (strncmp(&bufr[257], "ustar", 5)) {
40005a7c: a6 06 21 e9 add %i0, 0x1e9, %l3
40005a80: a0 14 22 20 or %l0, 0x220, %l0
&context->header[0]
40005a84: ac 06 20 e8 add %i0, 0xe8, %l6
context->state = UNTAR_CHUNK_WRITE;
40005a88: ae 10 20 02 mov 2, %l7
switch (context->state) {
40005a8c: c2 07 60 e4 ld [ %i5 + 0xe4 ], %g1
40005a90: 80 a0 60 01 cmp %g1, 1
40005a94: 02 80 00 08 be 40005ab4 <Untar_FromChunk_Print+0x64>
40005a98: 80 a0 60 02 cmp %g1, 2
40005a9c: 02 80 00 40 be 40005b9c <Untar_FromChunk_Print+0x14c>
40005aa0: 80 a0 60 00 cmp %g1, 0
40005aa4: 02 80 00 15 be 40005af8 <Untar_FromChunk_Print+0xa8> <== ALWAYS TAKEN
40005aa8: b0 10 20 01 mov 1, %i0
}
40005aac: 81 c7 e0 08 ret <== NOT EXECUTED
40005ab0: 81 e8 00 00 restore <== NOT EXECUTED
remaining = context->base.file_size - context->done_bytes;
40005ab4: c4 07 60 70 ld [ %i5 + 0x70 ], %g2
40005ab8: c2 07 62 e8 ld [ %i5 + 0x2e8 ], %g1
40005abc: b8 20 80 01 sub %g2, %g1, %i4
consume = MIN(remaining, todo);
40005ac0: 80 a7 00 1a cmp %i4, %i2
40005ac4: 38 80 00 02 bgu,a 40005acc <Untar_FromChunk_Print+0x7c>
40005ac8: b8 10 00 1a mov %i2, %i4
context->done_bytes += consume;
40005acc: 82 00 40 1c add %g1, %i4, %g1
if (context->done_bytes == context->base.file_size) {
40005ad0: 80 a0 80 01 cmp %g2, %g1
40005ad4: 12 80 00 04 bne 40005ae4 <Untar_FromChunk_Print+0x94>
40005ad8: c2 27 62 e8 st %g1, [ %i5 + 0x2e8 ]
context->state = UNTAR_CHUNK_HEADER;
40005adc: c0 27 60 e4 clr [ %i5 + 0xe4 ]
context->done_bytes = 0;
40005ae0: c0 27 62 e8 clr [ %i5 + 0x2e8 ]
while (todo > 0) {
40005ae4: b4 a6 80 1c subcc %i2, %i4, %i2
40005ae8: 12 bf ff e9 bne 40005a8c <Untar_FromChunk_Print+0x3c> <== NEVER TAKEN
40005aec: b6 06 c0 1c add %i3, %i4, %i3
return UNTAR_SUCCESSFUL;
40005af0: 81 c7 e0 08 ret
40005af4: 91 e8 20 00 restore %g0, 0, %o0
remaining = 512 - context->done_bytes;
40005af8: d0 07 62 e8 ld [ %i5 + 0x2e8 ], %o0
40005afc: b8 24 40 08 sub %l1, %o0, %i4
consume = MIN(remaining, todo);
40005b00: 80 a7 00 1a cmp %i4, %i2
40005b04: 38 80 00 4d bgu,a 40005c38 <Untar_FromChunk_Print+0x1e8>
40005b08: b8 10 00 1a mov %i2, %i4
memcpy(&context->header[context->done_bytes], &buf[done], consume);
40005b0c: 90 02 20 e8 add %o0, 0xe8, %o0
40005b10: 94 10 00 1c mov %i4, %o2
40005b14: 92 06 40 1b add %i1, %i3, %o1
40005b18: 40 00 33 9f call 40012994 <memcpy>
40005b1c: 90 07 40 08 add %i5, %o0, %o0
context->done_bytes += consume;
40005b20: c2 07 62 e8 ld [ %i5 + 0x2e8 ], %g1
40005b24: 82 07 00 01 add %i4, %g1, %g1
if (context->done_bytes == 512) {
40005b28: 80 a0 62 00 cmp %g1, 0x200
40005b2c: 12 bf ff ee bne 40005ae4 <Untar_FromChunk_Print+0x94> <== NEVER TAKEN
40005b30: c2 27 62 e8 st %g1, [ %i5 + 0x2e8 ]
ctx->file_name[0] = '\0';
40005b34: c2 07 60 04 ld [ %i5 + 4 ], %g1
40005b38: c0 28 40 00 clrb [ %g1 ]
if (strncmp(&bufr[257], "ustar", 5)) {
40005b3c: 94 10 20 05 mov 5, %o2
ctx->file_size = 0;
40005b40: c0 27 60 70 clr [ %i5 + 0x70 ]
if (strncmp(&bufr[257], "ustar", 5)) {
40005b44: 92 10 00 10 mov %l0, %o1
ctx->nblocks = 0;
40005b48: c0 27 60 74 clr [ %i5 + 0x74 ]
if (strncmp(&bufr[257], "ustar", 5)) {
40005b4c: 90 10 00 13 mov %l3, %o0
40005b50: 40 00 37 01 call 40013754 <strncmp>
40005b54: e8 2f 60 78 stb %l4, [ %i5 + 0x78 ]
40005b58: 80 a2 20 00 cmp %o0, 0
40005b5c: 12 80 00 0b bne 40005b88 <Untar_FromChunk_Print+0x138>
40005b60: 92 10 00 16 mov %l6, %o1
40005b64: 7f ff fd be call 4000525c <Untar_ProcessHeader.part.0>
40005b68: 90 10 00 1d mov %i5, %o0
if (retval != UNTAR_SUCCESSFUL) {
40005b6c: b0 92 20 00 orcc %o0, 0, %i0
40005b70: 12 80 00 4c bne 40005ca0 <Untar_FromChunk_Print+0x250> <== NEVER TAKEN
40005b74: 82 10 20 03 mov 3, %g1
if (context->base.linkflag == REGTYPE) {
40005b78: c2 0f 60 78 ldub [ %i5 + 0x78 ], %g1
40005b7c: 80 a0 60 30 cmp %g1, 0x30
40005b80: 22 80 00 3a be,a 40005c68 <Untar_FromChunk_Print+0x218>
40005b84: d2 07 60 6c ld [ %i5 + 0x6c ], %o1
context->done_bytes = 0;
40005b88: c0 27 62 e8 clr [ %i5 + 0x2e8 ]
while (todo > 0) {
40005b8c: b4 a6 80 1c subcc %i2, %i4, %i2
40005b90: 12 bf ff bf bne 40005a8c <Untar_FromChunk_Print+0x3c> <== NEVER TAKEN
40005b94: b6 06 c0 1c add %i3, %i4, %i3
40005b98: 30 bf ff d6 b,a 40005af0 <Untar_FromChunk_Print+0xa0>
remaining = context->base.file_size - context->done_bytes;
40005b9c: f8 07 60 70 ld [ %i5 + 0x70 ], %i4
40005ba0: c2 07 62 e8 ld [ %i5 + 0x2e8 ], %g1
40005ba4: b8 27 00 01 sub %i4, %g1, %i4
consume = MIN(remaining, todo);
40005ba8: 80 a7 00 1a cmp %i4, %i2
40005bac: 18 80 00 17 bgu 40005c08 <Untar_FromChunk_Print+0x1b8>
40005bb0: d0 07 62 ec ld [ %i5 + 0x2ec ], %o0
write(context->out_fd, &buf[done], consume);
40005bb4: 94 10 00 1c mov %i4, %o2
40005bb8: 7f ff f6 c2 call 400036c0 <write>
40005bbc: 92 06 40 1b add %i1, %i3, %o1
context->done_bytes += consume;
40005bc0: c2 07 62 e8 ld [ %i5 + 0x2e8 ], %g1
40005bc4: 82 07 00 01 add %i4, %g1, %g1
40005bc8: c2 27 62 e8 st %g1, [ %i5 + 0x2e8 ]
if (context->done_bytes == context->base.file_size) {
40005bcc: c4 07 60 70 ld [ %i5 + 0x70 ], %g2
40005bd0: 80 a0 40 02 cmp %g1, %g2
40005bd4: 32 bf ff c5 bne,a 40005ae8 <Untar_FromChunk_Print+0x98> <== NEVER TAKEN
40005bd8: b4 a6 80 1c subcc %i2, %i4, %i2 <== NOT EXECUTED
close(context->out_fd);
40005bdc: 7f ff ef df call 40001b58 <close>
40005be0: d0 07 62 ec ld [ %i5 + 0x2ec ], %o0
- context->base.file_size;
40005be4: c4 07 60 70 ld [ %i5 + 0x70 ], %g2
context->base.file_size = 512 * context->base.nblocks
40005be8: c2 07 60 74 ld [ %i5 + 0x74 ], %g1
40005bec: 83 28 60 09 sll %g1, 9, %g1
context->out_fd = -1;
40005bf0: ea 27 62 ec st %l5, [ %i5 + 0x2ec ]
- context->base.file_size;
40005bf4: 82 20 40 02 sub %g1, %g2, %g1
context->state = UNTAR_CHUNK_SKIP;
40005bf8: e4 27 60 e4 st %l2, [ %i5 + 0xe4 ]
context->base.file_size = 512 * context->base.nblocks
40005bfc: c2 27 60 70 st %g1, [ %i5 + 0x70 ]
context->done_bytes = 0;
40005c00: 10 bf ff e3 b 40005b8c <Untar_FromChunk_Print+0x13c>
40005c04: c0 27 62 e8 clr [ %i5 + 0x2e8 ]
consume = MIN(remaining, todo);
40005c08: b8 10 00 1a mov %i2, %i4
write(context->out_fd, &buf[done], consume);
40005c0c: 92 06 40 1b add %i1, %i3, %o1
40005c10: 7f ff f6 ac call 400036c0 <write>
40005c14: 94 10 00 1c mov %i4, %o2
context->done_bytes += consume;
40005c18: c2 07 62 e8 ld [ %i5 + 0x2e8 ], %g1
40005c1c: 82 07 00 01 add %i4, %g1, %g1
40005c20: c2 27 62 e8 st %g1, [ %i5 + 0x2e8 ]
if (context->done_bytes == context->base.file_size) {
40005c24: c4 07 60 70 ld [ %i5 + 0x70 ], %g2
40005c28: 80 a0 40 02 cmp %g1, %g2
40005c2c: 32 bf ff af bne,a 40005ae8 <Untar_FromChunk_Print+0x98> <== ALWAYS TAKEN
40005c30: b4 a6 80 1c subcc %i2, %i4, %i2
40005c34: 30 bf ff ea b,a 40005bdc <Untar_FromChunk_Print+0x18c> <== NOT EXECUTED
memcpy(&context->header[context->done_bytes], &buf[done], consume);
40005c38: 90 02 20 e8 add %o0, 0xe8, %o0
40005c3c: 94 10 00 1c mov %i4, %o2
40005c40: 92 06 40 1b add %i1, %i3, %o1
40005c44: 40 00 33 54 call 40012994 <memcpy>
40005c48: 90 07 40 08 add %i5, %o0, %o0
context->done_bytes += consume;
40005c4c: c2 07 62 e8 ld [ %i5 + 0x2e8 ], %g1
40005c50: 82 07 00 01 add %i4, %g1, %g1
if (context->done_bytes == 512) {
40005c54: 80 a0 62 00 cmp %g1, 0x200
40005c58: 12 bf ff a3 bne 40005ae4 <Untar_FromChunk_Print+0x94> <== ALWAYS TAKEN
40005c5c: c2 27 62 e8 st %g1, [ %i5 + 0x2e8 ]
ctx->file_name[0] = '\0';
40005c60: 10 bf ff b6 b 40005b38 <Untar_FromChunk_Print+0xe8> <== NOT EXECUTED
40005c64: c2 07 60 04 ld [ %i5 + 4 ], %g1 <== NOT EXECUTED
context->out_fd = creat(context->base.file_path,
40005c68: 40 00 32 61 call 400125ec <creat>
40005c6c: d0 07 40 00 ld [ %i5 ], %o0
if (context->out_fd >= 0) {
40005c70: 80 a2 20 00 cmp %o0, 0
40005c74: 06 80 00 05 bl 40005c88 <Untar_FromChunk_Print+0x238> <== NEVER TAKEN
40005c78: d0 27 62 ec st %o0, [ %i5 + 0x2ec ]
context->state = UNTAR_CHUNK_WRITE;
40005c7c: ee 27 60 e4 st %l7, [ %i5 + 0xe4 ]
context->done_bytes = 0;
40005c80: 10 bf ff 99 b 40005ae4 <Untar_FromChunk_Print+0x94>
40005c84: c0 27 62 e8 clr [ %i5 + 0x2e8 ]
context->base.file_size = 512 * context->base.nblocks;
40005c88: c2 07 60 74 ld [ %i5 + 0x74 ], %g1 <== NOT EXECUTED
40005c8c: 83 28 60 09 sll %g1, 9, %g1 <== NOT EXECUTED
context->state = UNTAR_CHUNK_SKIP;
40005c90: e4 27 60 e4 st %l2, [ %i5 + 0xe4 ] <== NOT EXECUTED
context->base.file_size = 512 * context->base.nblocks;
40005c94: c2 27 60 70 st %g1, [ %i5 + 0x70 ] <== NOT EXECUTED
context->done_bytes = 0;
40005c98: 10 bf ff 93 b 40005ae4 <Untar_FromChunk_Print+0x94> <== NOT EXECUTED
40005c9c: c0 27 62 e8 clr [ %i5 + 0x2e8 ] <== NOT EXECUTED
context->state = UNTAR_CHUNK_ERROR;
40005ca0: c2 27 60 e4 st %g1, [ %i5 + 0xe4 ] <== NOT EXECUTED
return retval;
40005ca4: 81 c7 e0 08 ret <== NOT EXECUTED
40005ca8: 81 e8 00 00 restore <== NOT EXECUTED
400058a4 <Untar_FromFile_Print>:
{
400058a4: 9d e3 be b8 save %sp, -328, %sp
if ((fd = open(tar_name, O_RDONLY)) < 0) {
400058a8: 92 10 20 00 clr %o1
400058ac: 90 10 00 18 mov %i0, %o0
400058b0: 7f ff f3 0a call 400024d8 <open>
400058b4: b0 10 20 01 mov 1, %i0
400058b8: 80 a2 20 00 cmp %o0, 0
400058bc: 06 80 00 53 bl 40005a08 <Untar_FromFile_Print+0x164> <== NEVER TAKEN
400058c0: b8 10 00 08 mov %o0, %i4
bufr = (char *)malloc(512);
400058c4: 40 00 0d fa call 400090ac <malloc>
400058c8: 90 10 22 00 mov 0x200, %o0
if (bufr == NULL) {
400058cc: ba 92 20 00 orcc %o0, 0, %i5
400058d0: 02 80 00 4c be 40005a00 <Untar_FromFile_Print+0x15c> <== NEVER TAKEN
400058d4: 82 07 bf 18 add %fp, -232, %g1
ctx.file_path = buf;
400058d8: c2 27 bf 80 st %g1, [ %fp + -128 ]
if (strncmp(&bufr[257], "ustar", 5)) {
400058dc: 37 10 00 60 sethi %hi(0x40018000), %i3
ctx.file_name = buf;
400058e0: c2 27 bf 84 st %g1, [ %fp + -124 ]
if (strncmp(&bufr[257], "ustar", 5)) {
400058e4: b6 16 e2 20 or %i3, 0x220, %i3
ctx.printer = printer;
400058e8: f2 27 bf fc st %i1, [ %fp + -4 ]
ctx->linkflag = -1;
400058ec: b4 10 3f ff mov -1, %i2
if (strncmp(&bufr[257], "ustar", 5)) {
400058f0: b2 07 61 01 add %i5, 0x101, %i1
if ((n = read(fd, bufr, 512)) != 512) {
400058f4: 94 10 22 00 mov 0x200, %o2
400058f8: 92 10 00 1d mov %i5, %o1
400058fc: 7f ff f3 e4 call 4000288c <read>
40005900: 90 10 00 1c mov %i4, %o0
40005904: 80 a2 22 00 cmp %o0, 0x200
40005908: 32 80 00 3c bne,a 400059f8 <Untar_FromFile_Print+0x154>
4000590c: b0 10 20 00 clr %i0
ctx->file_name[0] = '\0';
40005910: c2 07 bf 84 ld [ %fp + -124 ], %g1
40005914: c0 28 40 00 clrb [ %g1 ]
if (strncmp(&bufr[257], "ustar", 5)) {
40005918: 94 10 20 05 mov 5, %o2
ctx->file_size = 0;
4000591c: c0 27 bf f0 clr [ %fp + -16 ]
if (strncmp(&bufr[257], "ustar", 5)) {
40005920: 92 10 00 1b mov %i3, %o1
ctx->nblocks = 0;
40005924: c0 27 bf f4 clr [ %fp + -12 ]
if (strncmp(&bufr[257], "ustar", 5)) {
40005928: 90 10 00 19 mov %i1, %o0
4000592c: 40 00 37 8a call 40013754 <strncmp>
40005930: f4 2f bf f8 stb %i2, [ %fp + -8 ]
40005934: 80 a2 20 00 cmp %o0, 0
40005938: 12 bf ff ef bne 400058f4 <Untar_FromFile_Print+0x50>
4000593c: 92 10 00 1d mov %i5, %o1
40005940: 7f ff fe 47 call 4000525c <Untar_ProcessHeader.part.0>
40005944: 90 07 bf 80 add %fp, -128, %o0
if (retval != UNTAR_SUCCESSFUL)
40005948: b0 92 20 00 orcc %o0, 0, %i0
4000594c: 12 80 00 2b bne 400059f8 <Untar_FromFile_Print+0x154> <== NEVER TAKEN
40005950: c2 0f bf f8 ldub [ %fp + -8 ], %g1
if (ctx.linkflag == REGTYPE) {
40005954: 80 a0 60 30 cmp %g1, 0x30
40005958: 12 bf ff e8 bne 400058f8 <Untar_FromFile_Print+0x54>
4000595c: 94 10 22 00 mov 0x200, %o2
if ((out_fd = creat(ctx.file_path, ctx.mode)) == -1) {
40005960: d2 07 bf ec ld [ %fp + -20 ], %o1
40005964: 40 00 33 22 call 400125ec <creat>
40005968: d0 07 bf 80 ld [ %fp + -128 ], %o0
4000596c: 80 a2 3f ff cmp %o0, -1
40005970: 02 80 00 28 be 40005a10 <Untar_FromFile_Print+0x16c> <== NEVER TAKEN
40005974: a0 10 00 08 mov %o0, %l0
for (i = 0; i < ctx.nblocks; i++) {
40005978: c2 07 bf f4 ld [ %fp + -12 ], %g1
4000597c: 80 a0 60 00 cmp %g1, 0
40005980: 02 80 00 14 be 400059d0 <Untar_FromFile_Print+0x12c> <== NEVER TAKEN
40005984: 94 10 22 00 mov 0x200, %o2
n = read(fd, bufr, 512);
40005988: 92 10 00 1d mov %i5, %o1
4000598c: 7f ff f3 c0 call 4000288c <read>
40005990: 90 10 00 1c mov %i4, %o0
n = MIN(n, ctx.file_size - (i * 512UL));
40005994: c2 07 bf f0 ld [ %fp + -16 ], %g1
n = read(fd, bufr, 512);
40005998: 84 10 00 08 mov %o0, %g2
n = MIN(n, ctx.file_size - (i * 512UL));
4000599c: 95 2e 20 09 sll %i0, 9, %o2
(void) write(out_fd, bufr, n);
400059a0: 92 10 00 1d mov %i5, %o1
n = MIN(n, ctx.file_size - (i * 512UL));
400059a4: 94 20 40 0a sub %g1, %o2, %o2
400059a8: 80 a2 80 02 cmp %o2, %g2
400059ac: 08 80 00 03 bleu 400059b8 <Untar_FromFile_Print+0x114> <== ALWAYS TAKEN
400059b0: 90 10 00 10 mov %l0, %o0
400059b4: 94 10 00 02 mov %g2, %o2 <== NOT EXECUTED
(void) write(out_fd, bufr, n);
400059b8: 7f ff f7 42 call 400036c0 <write>
400059bc: b0 06 20 01 inc %i0
for (i = 0; i < ctx.nblocks; i++) {
400059c0: c2 07 bf f4 ld [ %fp + -12 ], %g1
400059c4: 80 a0 40 18 cmp %g1, %i0
400059c8: 18 bf ff f0 bgu 40005988 <Untar_FromFile_Print+0xe4> <== NEVER TAKEN
400059cc: 94 10 22 00 mov 0x200, %o2
close(out_fd);
400059d0: 7f ff f0 62 call 40001b58 <close>
400059d4: 90 10 00 10 mov %l0, %o0
if ((n = read(fd, bufr, 512)) != 512) {
400059d8: 94 10 22 00 mov 0x200, %o2
400059dc: 92 10 00 1d mov %i5, %o1
400059e0: 7f ff f3 ab call 4000288c <read>
400059e4: 90 10 00 1c mov %i4, %o0
400059e8: 80 a2 22 00 cmp %o0, 0x200
400059ec: 02 bf ff ca be 40005914 <Untar_FromFile_Print+0x70> <== ALWAYS TAKEN
400059f0: c2 07 bf 84 ld [ %fp + -124 ], %g1
400059f4: b0 10 20 00 clr %i0 <== NOT EXECUTED
free(bufr);
400059f8: 40 00 0d 0d call 40008e2c <free>
400059fc: 90 10 00 1d mov %i5, %o0
close(fd);
40005a00: 7f ff f0 56 call 40001b58 <close>
40005a04: 90 10 00 1c mov %i4, %o0
}
40005a08: 81 c7 e0 08 ret
40005a0c: 81 e8 00 00 restore
(void) lseek(fd, SEEK_CUR, 512UL * ctx.nblocks);
40005a10: d6 07 bf f4 ld [ %fp + -12 ], %o3 <== NOT EXECUTED
40005a14: 97 2a e0 09 sll %o3, 9, %o3 <== NOT EXECUTED
40005a18: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
40005a1c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
40005a20: 7f ff f1 1b call 40001e8c <lseek> <== NOT EXECUTED
40005a24: 92 10 20 00 clr %o1 <== NOT EXECUTED
40005a28: 10 bf ff b4 b 400058f8 <Untar_FromFile_Print+0x54> <== NOT EXECUTED
40005a2c: 94 10 22 00 mov 0x200, %o2 <== NOT EXECUTED
40005d08 <Untar_FromGzChunk_Print>:
Untar_GzChunkContext *ctx,
void *chunk,
size_t chunk_size,
const rtems_printer *printer
)
{
40005d08: 9d e3 bf a0 save %sp, -96, %sp
int untar_succesful;
int status;
ctx->strm.next_in = (Bytef *)chunk;
ctx->strm.avail_in = (size_t)chunk_size;
40005d0c: f4 26 22 f4 st %i2, [ %i0 + 0x2f4 ]
{
40005d10: ba 10 00 18 mov %i0, %i5
ctx->strm.next_in = (Bytef *)chunk;
40005d14: f2 26 22 f0 st %i1, [ %i0 + 0x2f0 ]
/* Inflate until output buffer is not full */
do {
ctx->strm.next_out = (Bytef *) ctx->inflateBuffer;
ctx->strm.avail_out = ctx->inflateBufferSize;
status = inflate(&ctx->strm, Z_NO_FLUSH);
40005d18: 10 80 00 0c b 40005d48 <Untar_FromGzChunk_Print+0x40>
40005d1c: b4 06 22 f0 add %i0, 0x2f0, %i2
}
} else {
untar_succesful = UNTAR_GZ_INFLATE_FAILED;
}
} while (ctx->strm.avail_out == 0 && ctx->strm.avail_in > 0
&& status == Z_OK);
40005d20: c2 07 63 00 ld [ %i5 + 0x300 ], %g1 <== NOT EXECUTED
40005d24: 80 a0 60 00 cmp %g1, 0
40005d28: 12 80 00 1f bne 40005da4 <Untar_FromGzChunk_Print+0x9c>
40005d2c: 80 a7 20 00 cmp %i4, 0
} while (ctx->strm.avail_out == 0 && ctx->strm.avail_in > 0
40005d30: c2 07 62 f4 ld [ %i5 + 0x2f4 ], %g1
40005d34: 80 a0 60 00 cmp %g1, 0
40005d38: 02 80 00 1b be 40005da4 <Untar_FromGzChunk_Print+0x9c>
40005d3c: 80 a7 20 00 cmp %i4, 0
&& status == Z_OK);
40005d40: 12 80 00 1b bne 40005dac <Untar_FromGzChunk_Print+0xa4> <== NEVER TAKEN
40005d44: 80 a6 20 00 cmp %i0, 0
ctx->strm.next_out = (Bytef *) ctx->inflateBuffer;
40005d48: c4 07 63 28 ld [ %i5 + 0x328 ], %g2
ctx->strm.avail_out = ctx->inflateBufferSize;
40005d4c: c2 07 63 2c ld [ %i5 + 0x32c ], %g1
ctx->strm.next_out = (Bytef *) ctx->inflateBuffer;
40005d50: c4 27 62 fc st %g2, [ %i5 + 0x2fc ]
status = inflate(&ctx->strm, Z_NO_FLUSH);
40005d54: 92 10 20 00 clr %o1
ctx->strm.avail_out = ctx->inflateBufferSize;
40005d58: c2 27 63 00 st %g1, [ %i5 + 0x300 ]
status = inflate(&ctx->strm, Z_NO_FLUSH);
40005d5c: 90 10 00 1a mov %i2, %o0
40005d60: 40 00 21 00 call 4000e160 <z_inflate>
40005d64: b0 10 20 04 mov 4, %i0
if (status == Z_OK || status == Z_STREAM_END) {
40005d68: 80 a2 20 01 cmp %o0, 1
40005d6c: 18 bf ff ed bgu 40005d20 <Untar_FromGzChunk_Print+0x18> <== NEVER TAKEN
40005d70: b8 10 00 08 mov %o0, %i4
size_t inflated_size =
40005d74: d4 07 63 2c ld [ %i5 + 0x32c ], %o2
40005d78: c2 07 63 00 ld [ %i5 + 0x300 ], %g1
untar_succesful = Untar_FromChunk_Print(&ctx->base,
40005d7c: d2 07 63 28 ld [ %i5 + 0x328 ], %o1
40005d80: 96 10 20 00 clr %o3
40005d84: 94 22 80 01 sub %o2, %g1, %o2
40005d88: 7f ff ff 32 call 40005a50 <Untar_FromChunk_Print>
40005d8c: 90 10 00 1d mov %i5, %o0
if (untar_succesful != UNTAR_SUCCESSFUL){
40005d90: b0 92 20 00 orcc %o0, 0, %i0
40005d94: 22 bf ff e4 be,a 40005d24 <Untar_FromGzChunk_Print+0x1c> <== ALWAYS TAKEN
40005d98: c2 07 63 00 ld [ %i5 + 0x300 ], %g1
if (status != Z_OK) {
rtems_printf(printer, "Zlib inflate end failed\n");
}
}
return untar_succesful;
}
40005d9c: 81 c7 e0 08 ret
40005da0: 81 e8 00 00 restore
if (status != Z_OK) {
40005da4: 02 bf ff fe be 40005d9c <Untar_FromGzChunk_Print+0x94>
40005da8: 80 a6 20 00 cmp %i0, 0
if (untar_succesful != UNTAR_SUCCESSFUL){
40005dac: 12 80 00 12 bne 40005df4 <Untar_FromGzChunk_Print+0xec> <== NEVER TAKEN
40005db0: 90 10 00 1b mov %i3, %o0
if (status != Z_STREAM_END) {
40005db4: 80 a7 20 01 cmp %i4, 1
40005db8: 02 80 00 05 be 40005dcc <Untar_FromGzChunk_Print+0xc4> <== ALWAYS TAKEN
40005dbc: 13 10 00 60 sethi %hi(0x40018000), %o1
rtems_printf(printer, "Zlib inflate failed\n");
40005dc0: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
40005dc4: 40 00 0d 3f call 400092c0 <rtems_printf> <== NOT EXECUTED
40005dc8: 92 12 62 78 or %o1, 0x278, %o1 <== NOT EXECUTED
status = inflateEnd(&ctx->strm);
40005dcc: 40 00 27 a7 call 4000fc68 <z_inflateEnd>
40005dd0: 90 10 00 1a mov %i2, %o0
if (status != Z_OK) {
40005dd4: 80 a2 20 00 cmp %o0, 0
40005dd8: 02 bf ff f1 be 40005d9c <Untar_FromGzChunk_Print+0x94> <== ALWAYS TAKEN
40005ddc: 90 10 00 1b mov %i3, %o0
rtems_printf(printer, "Zlib inflate end failed\n");
40005de0: 13 10 00 60 sethi %hi(0x40018000), %o1 <== NOT EXECUTED
40005de4: 40 00 0d 37 call 400092c0 <rtems_printf> <== NOT EXECUTED
40005de8: 92 12 62 90 or %o1, 0x290, %o1 ! 40018290 <IMFS_node_control_sym_link+0x140><== NOT EXECUTED
}
40005dec: 81 c7 e0 08 ret <== NOT EXECUTED
40005df0: 81 e8 00 00 restore <== NOT EXECUTED
rtems_printf(printer, "Untar not successful\n");
40005df4: 13 10 00 60 sethi %hi(0x40018000), %o1 <== NOT EXECUTED
40005df8: 40 00 0d 32 call 400092c0 <rtems_printf> <== NOT EXECUTED
40005dfc: 92 12 62 60 or %o1, 0x260, %o1 ! 40018260 <IMFS_node_control_sym_link+0x110><== NOT EXECUTED
if (status != Z_STREAM_END) {
40005e00: 10 bf ff ee b 40005db8 <Untar_FromGzChunk_Print+0xb0> <== NOT EXECUTED
40005e04: 80 a7 20 01 cmp %i4, 1 <== NOT EXECUTED
400056b8 <Untar_FromMemory_Print>:
{
400056b8: 9d e3 be b0 save %sp, -336, %sp
ctx.file_path = buf;
400056bc: 82 07 bf 18 add %fp, -232, %g1
ctx.printer = printer;
400056c0: f4 27 bf fc st %i2, [ %fp + -4 ]
rtems_printf(printer, "untar: memory at %p (%zu)\n", tar_buf, size);
400056c4: 96 10 00 19 mov %i1, %o3
ctx.file_path = buf;
400056c8: c2 27 bf 80 st %g1, [ %fp + -128 ]
rtems_printf(printer, "untar: memory at %p (%zu)\n", tar_buf, size);
400056cc: 94 10 00 18 mov %i0, %o2
ctx.file_name = buf;
400056d0: c2 27 bf 84 st %g1, [ %fp + -124 ]
rtems_printf(printer, "untar: memory at %p (%zu)\n", tar_buf, size);
400056d4: 90 10 00 1a mov %i2, %o0
400056d8: 13 10 00 60 sethi %hi(0x40018000), %o1
if (strncmp(&bufr[257], "ustar", 5)) {
400056dc: 21 10 00 60 sethi %hi(0x40018000), %l0
rtems_printf(printer, "untar: memory at %p (%zu)\n", tar_buf, size);
400056e0: 92 12 62 28 or %o1, 0x228, %o1
rtems_printf(printer, "untar: %s: %s: (%d) %s\n",
400056e4: 29 10 00 60 sethi %hi(0x40018000), %l4
400056e8: 25 10 00 60 sethi %hi(0x40018000), %l2
400056ec: 27 10 00 60 sethi %hi(0x40018000), %l3
{
400056f0: b6 10 00 18 mov %i0, %i3
rtems_printf(printer, "untar: memory at %p (%zu)\n", tar_buf, size);
400056f4: 40 00 0e f3 call 400092c0 <rtems_printf>
400056f8: ba 10 20 00 clr %i5
if (strncmp(&bufr[257], "ustar", 5)) {
400056fc: a0 14 22 20 or %l0, 0x220, %l0
rtems_printf(printer, "untar: %s: %s: (%d) %s\n",
40005700: a8 15 22 50 or %l4, 0x250, %l4
40005704: a4 14 a1 90 or %l2, 0x190, %l2
40005708: a6 14 e2 48 or %l3, 0x248, %l3
ctx->linkflag = -1;
4000570c: a2 10 3f ff mov -1, %l1
if (strncmp(&bufr[257], "ustar", 5)) {
40005710: 90 07 61 01 add %i5, 0x101, %o0
if (ptr + 512 > size) {
40005714: b8 07 62 00 add %i5, 0x200, %i4
if (strncmp(&bufr[257], "ustar", 5)) {
40005718: 94 10 20 05 mov 5, %o2
4000571c: 92 10 00 10 mov %l0, %o1
if (ptr + 512 > size) {
40005720: 80 a7 00 19 cmp %i4, %i1
40005724: 18 80 00 48 bgu 40005844 <Untar_FromMemory_Print+0x18c>
40005728: 90 06 c0 08 add %i3, %o0, %o0
ctx->file_name[0] = '\0';
4000572c: c2 07 bf 84 ld [ %fp + -124 ], %g1
40005730: c0 28 40 00 clrb [ %g1 ]
40005734: b0 06 c0 1d add %i3, %i5, %i0
ctx->file_size = 0;
40005738: c0 27 bf f0 clr [ %fp + -16 ]
ptr = 0;
4000573c: ba 10 00 1c mov %i4, %i5
ctx->nblocks = 0;
40005740: c0 27 bf f4 clr [ %fp + -12 ]
if (strncmp(&bufr[257], "ustar", 5)) {
40005744: 40 00 38 04 call 40013754 <strncmp>
40005748: e2 2f bf f8 stb %l1, [ %fp + -8 ]
4000574c: 92 10 00 18 mov %i0, %o1
40005750: 82 10 00 08 mov %o0, %g1
40005754: 80 a0 60 00 cmp %g1, 0
40005758: 12 bf ff ee bne 40005710 <Untar_FromMemory_Print+0x58>
4000575c: 90 07 bf 80 add %fp, -128, %o0
40005760: 7f ff fe bf call 4000525c <Untar_ProcessHeader.part.0>
40005764: 01 00 00 00 nop
if (retval != UNTAR_SUCCESSFUL)
40005768: b0 92 20 00 orcc %o0, 0, %i0
4000576c: 12 80 00 37 bne 40005848 <Untar_FromMemory_Print+0x190> <== NEVER TAKEN
40005770: c2 0f bf f8 ldub [ %fp + -8 ], %g1
if (ctx.linkflag == REGTYPE) {
40005774: 80 a0 60 30 cmp %g1, 0x30
40005778: 12 bf ff e7 bne 40005714 <Untar_FromMemory_Print+0x5c>
4000577c: 90 07 61 01 add %i5, 0x101, %o0
if ((fd = open(ctx.file_path,
40005780: d4 07 bf ec ld [ %fp + -20 ], %o2
40005784: d0 07 bf 80 ld [ %fp + -128 ], %o0
40005788: 7f ff f3 54 call 400024d8 <open>
4000578c: 92 10 26 01 mov 0x601, %o1
40005790: 80 a2 3f ff cmp %o0, -1
40005794: 02 80 00 2f be 40005850 <Untar_FromMemory_Print+0x198> <== NEVER TAKEN
40005798: ac 10 00 08 mov %o0, %l6
for (i = 0; i < ctx.nblocks; i++) {
4000579c: c2 07 bf f4 ld [ %fp + -12 ], %g1
400057a0: 80 a0 60 00 cmp %g1, 0
400057a4: 12 80 00 09 bne 400057c8 <Untar_FromMemory_Print+0x110> <== ALWAYS TAKEN
400057a8: ea 07 bf f0 ld [ %fp + -16 ], %l5
if (ptr + 512 > size) {
400057ac: 10 80 00 22 b 40005834 <Untar_FromMemory_Print+0x17c> <== NOT EXECUTED
400057b0: ba 10 00 1c mov %i4, %i5 <== NOT EXECUTED
for (i = 0; i < ctx.nblocks; i++) {
400057b4: c2 07 bf f4 ld [ %fp + -12 ], %g1
400057b8: b0 06 20 01 inc %i0
400057bc: 80 a0 40 18 cmp %g1, %i0
400057c0: 08 80 00 37 bleu 4000589c <Untar_FromMemory_Print+0x1e4> <== ALWAYS TAKEN
400057c4: aa 25 40 11 sub %l5, %l1, %l5
n = write(fd, &tar_ptr[ptr], len);
400057c8: 92 06 c0 1c add %i3, %i4, %o1
400057cc: 90 10 00 16 mov %l6, %o0
len = ((sizeToGo < 512L) ? (sizeToGo) : (512L));
400057d0: 80 a5 62 00 cmp %l5, 0x200
400057d4: 08 80 00 03 bleu 400057e0 <Untar_FromMemory_Print+0x128> <== ALWAYS TAKEN
400057d8: a2 10 00 15 mov %l5, %l1
400057dc: a2 10 22 00 mov 0x200, %l1 <== NOT EXECUTED
n = write(fd, &tar_ptr[ptr], len);
400057e0: 94 10 00 11 mov %l1, %o2
400057e4: 7f ff f7 b7 call 400036c0 <write>
400057e8: ba 10 00 1c mov %i4, %i5
if (n != len) {
400057ec: 80 a4 40 08 cmp %l1, %o0
400057f0: 02 bf ff f1 be 400057b4 <Untar_FromMemory_Print+0xfc> <== ALWAYS TAKEN
400057f4: b8 07 22 00 add %i4, 0x200, %i4
Print_Error(printer, "write", ctx.file_path);
400057f8: d6 07 bf 80 ld [ %fp + -128 ], %o3 <== NOT EXECUTED
message, path, errno, strerror(errno));
400057fc: 40 00 33 81 call 40012600 <__errno> <== NOT EXECUTED
40005800: d6 27 bf 10 st %o3, [ %fp + -240 ] <== NOT EXECUTED
rtems_printf(printer, "untar: %s: %s: (%d) %s\n",
40005804: d8 02 00 00 ld [ %o0 ], %o4 <== NOT EXECUTED
message, path, errno, strerror(errno));
40005808: 40 00 33 7e call 40012600 <__errno> <== NOT EXECUTED
4000580c: d8 27 bf 14 st %o4, [ %fp + -236 ] <== NOT EXECUTED
rtems_printf(printer, "untar: %s: %s: (%d) %s\n",
40005810: 40 00 37 7c call 40013600 <strerror> <== NOT EXECUTED
40005814: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
40005818: d8 07 bf 14 ld [ %fp + -236 ], %o4 <== NOT EXECUTED
4000581c: d6 07 bf 10 ld [ %fp + -240 ], %o3 <== NOT EXECUTED
40005820: 9a 10 00 08 mov %o0, %o5 <== NOT EXECUTED
40005824: 94 10 00 14 mov %l4, %o2 <== NOT EXECUTED
40005828: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED
4000582c: 40 00 0e a5 call 400092c0 <rtems_printf> <== NOT EXECUTED
40005830: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
close(fd);
40005834: 7f ff f0 c9 call 40001b58 <close>
40005838: 90 10 00 16 mov %l6, %o0
ctx->linkflag = -1;
4000583c: 10 bf ff b5 b 40005710 <Untar_FromMemory_Print+0x58>
40005840: a2 10 3f ff mov -1, %l1
retval = UNTAR_SUCCESSFUL;
40005844: b0 10 20 00 clr %i0
}
40005848: 81 c7 e0 08 ret
4000584c: 81 e8 00 00 restore
Print_Error(printer, "open", ctx.file_path);
40005850: d6 07 bf 80 ld [ %fp + -128 ], %o3 <== NOT EXECUTED
message, path, errno, strerror(errno));
40005854: 40 00 33 6b call 40012600 <__errno> <== NOT EXECUTED
40005858: d6 27 bf 10 st %o3, [ %fp + -240 ] <== NOT EXECUTED
rtems_printf(printer, "untar: %s: %s: (%d) %s\n",
4000585c: d8 02 00 00 ld [ %o0 ], %o4 <== NOT EXECUTED
message, path, errno, strerror(errno));
40005860: 40 00 33 68 call 40012600 <__errno> <== NOT EXECUTED
40005864: d8 27 bf 14 st %o4, [ %fp + -236 ] <== NOT EXECUTED
rtems_printf(printer, "untar: %s: %s: (%d) %s\n",
40005868: 40 00 37 66 call 40013600 <strerror> <== NOT EXECUTED
4000586c: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
40005870: d8 07 bf 14 ld [ %fp + -236 ], %o4 <== NOT EXECUTED
40005874: d6 07 bf 10 ld [ %fp + -240 ], %o3 <== NOT EXECUTED
40005878: 9a 10 00 08 mov %o0, %o5 <== NOT EXECUTED
4000587c: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED
40005880: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED
40005884: 40 00 0e 8f call 400092c0 <rtems_printf> <== NOT EXECUTED
40005888: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
ptr += 512 * ctx.nblocks;
4000588c: fa 07 bf f4 ld [ %fp + -12 ], %i5 <== NOT EXECUTED
40005890: bb 2f 60 09 sll %i5, 9, %i5 <== NOT EXECUTED
40005894: 10 bf ff 9e b 4000570c <Untar_FromMemory_Print+0x54> <== NOT EXECUTED
40005898: ba 07 40 1c add %i5, %i4, %i5 <== NOT EXECUTED
if (ptr + 512 > size) {
4000589c: 10 bf ff e6 b 40005834 <Untar_FromMemory_Print+0x17c>
400058a0: ba 10 00 1c mov %i4, %i5
400062c8 <Untar_ProcessHeader.part.0>:
return 0;
}
int
Untar_ProcessHeader(
400062c8: 9d e3 bf 30 save %sp, -208, %sp
num = 0;
400062cc: ba 10 20 00 clr %i5
Untar_ProcessHeader(
400062d0: b8 10 00 18 mov %i0, %i4
400062d4: 84 06 60 94 add %i1, 0x94, %g2
400062d8: 88 06 60 9c add %i1, 0x9c, %g4
if ((octascii[i] < '0') || (octascii[i] > '9')) {
400062dc: c2 08 80 00 ldub [ %g2 ], %g1
400062e0: 86 00 7f d0 add %g1, -48, %g3
400062e4: 86 08 e0 ff and %g3, 0xff, %g3
400062e8: 80 a0 e0 09 cmp %g3, 9
400062ec: 18 80 00 06 bgu 40006304 <Untar_ProcessHeader.part.0+0x3c>
400062f0: 83 28 60 18 sll %g1, 0x18, %g1
num = num * 8 + ((unsigned long)(octascii[i] - '0'));
400062f4: bb 2f 60 03 sll %i5, 3, %i5
400062f8: ba 07 7f d0 add %i5, -48, %i5
400062fc: 83 38 60 18 sra %g1, 0x18, %g1
40006300: ba 00 40 1d add %g1, %i5, %i5
for (i=0; i < len; i++) {
40006304: 84 00 a0 01 inc %g2
40006308: 80 a1 00 02 cmp %g4, %g2
4000630c: 32 bf ff f5 bne,a 400062e0 <Untar_ProcessHeader.part.0+0x18>
40006310: c2 08 80 00 ldub [ %g2 ], %g1
const char *bufr
)
{
int i, sum;
sum = 0;
40006314: 86 10 20 00 clr %g3
for (i=0; i<512; i++) {
40006318: 82 10 20 00 clr %g1
4000631c: 88 06 7f ff add %i1, -1, %g4
40006320: 84 00 60 01 add %g1, 1, %g2
if ((i >= 148) && (i < 156))
40006324: 82 00 7f 6c add %g1, -148, %g1
40006328: 80 a0 60 07 cmp %g1, 7
4000632c: 08 80 00 fb bleu 40006718 <Untar_ProcessHeader.part.0+0x450>
40006330: 80 a0 a2 00 cmp %g2, 0x200
sum += 0xff & ' ';
else
sum += 0xff & bufr[i];
40006334: c2 09 00 02 ldub [ %g4 + %g2 ], %g1
for (i=0; i<512; i++) {
40006338: 02 80 00 04 be 40006348 <Untar_ProcessHeader.part.0+0x80>
4000633c: 86 00 c0 01 add %g3, %g1, %g3
40006340: 10 bf ff f8 b 40006320 <Untar_ProcessHeader.part.0+0x58>
40006344: 82 10 00 02 mov %g2, %g1
if (sum != hdr_chksum) {
40006348: 80 a7 40 03 cmp %i5, %g3
4000634c: 12 80 00 af bne 40006608 <Untar_ProcessHeader.part.0+0x340> <== NEVER TAKEN
40006350: 94 10 20 64 mov 0x64, %o2
strlcpy(ctx->file_name, bufr, UNTAR_FILE_NAME_SIZE);
40006354: d0 07 20 04 ld [ %i4 + 4 ], %o0
40006358: 40 00 6f 24 call 40021fe8 <strlcpy>
4000635c: 92 10 00 19 mov %i1, %o1
ctx->mode = strtoul(&bufr[100], NULL, 8);
40006360: 94 10 20 08 mov 8, %o2
40006364: 92 10 20 00 clr %o1
40006368: 40 00 70 81 call 4002256c <strtoul>
4000636c: 90 06 60 64 add %i1, 0x64, %o0
40006370: d0 27 20 6c st %o0, [ %i4 + 0x6c ]
ctx->linkflag = bufr[156];
40006374: 86 06 60 7c add %i1, 0x7c, %g3
40006378: f4 0e 60 9c ldub [ %i1 + 0x9c ], %i2
4000637c: f4 2f 20 78 stb %i2, [ %i4 + 0x78 ]
for (i=0; i < len; i++) {
40006380: ba 06 60 88 add %i1, 0x88, %i5
num = 0;
40006384: 84 10 20 00 clr %g2
if ((octascii[i] < '0') || (octascii[i] > '9')) {
40006388: c2 08 c0 00 ldub [ %g3 ], %g1
4000638c: 88 00 7f d0 add %g1, -48, %g4
40006390: 88 09 20 ff and %g4, 0xff, %g4
40006394: 80 a1 20 09 cmp %g4, 9
40006398: 18 80 00 06 bgu 400063b0 <Untar_ProcessHeader.part.0+0xe8>
4000639c: 83 28 60 18 sll %g1, 0x18, %g1
num = num * 8 + ((unsigned long)(octascii[i] - '0'));
400063a0: 85 28 a0 03 sll %g2, 3, %g2
400063a4: 84 00 bf d0 add %g2, -48, %g2
400063a8: 83 38 60 18 sra %g1, 0x18, %g1
400063ac: 84 00 40 02 add %g1, %g2, %g2
for (i=0; i < len; i++) {
400063b0: 86 00 e0 01 inc %g3
400063b4: 80 a7 40 03 cmp %i5, %g3
400063b8: 32 bf ff f5 bne,a 4000638c <Untar_ProcessHeader.part.0+0xc4>
400063bc: c2 08 c0 00 ldub [ %g3 ], %g1
ctx->file_size = _rtems_octal2ulong(&bufr[124], 12);
400063c0: c4 27 20 70 st %g2, [ %i4 + 0x70 ]
if (Make_Path(ctx->printer, ctx->file_path) != 0) {
400063c4: f6 07 00 00 ld [ %i4 ], %i3
while (*path == '/') {
400063c8: c2 0e c0 00 ldub [ %i3 ], %g1
400063cc: 83 28 60 18 sll %g1, 0x18, %g1
400063d0: 85 38 60 18 sra %g1, 0x18, %g2
400063d4: 80 a0 a0 2f cmp %g2, 0x2f
400063d8: 12 80 00 08 bne 400063f8 <Untar_ProcessHeader.part.0+0x130> <== ALWAYS TAKEN
400063dc: e0 07 20 7c ld [ %i4 + 0x7c ], %l0
400063e0: c2 0e e0 01 ldub [ %i3 + 1 ], %g1 <== NOT EXECUTED
400063e4: 83 28 60 18 sll %g1, 0x18, %g1 <== NOT EXECUTED
400063e8: 85 38 60 18 sra %g1, 0x18, %g2 <== NOT EXECUTED
400063ec: 80 a0 a0 2f cmp %g2, 0x2f <== NOT EXECUTED
400063f0: 02 bf ff fc be 400063e0 <Untar_ProcessHeader.part.0+0x118> <== NOT EXECUTED
400063f4: b6 06 e0 01 inc %i3 <== NOT EXECUTED
if (p[0] == '\0') {
400063f8: 80 a0 60 00 cmp %g1, 0
400063fc: 02 80 00 1c be 4000646c <Untar_ProcessHeader.part.0+0x1a4> <== NEVER TAKEN
40006400: b0 10 20 00 clr %i0
40006404: ba 10 00 1b mov %i3, %i5
*p = '/';
40006408: b4 10 20 2f mov 0x2f, %i2
if (!S_ISDIR(sb.st_mode)) {
4000640c: 23 00 00 3c sethi %hi(0xf000), %l1
40006410: 31 00 00 10 sethi %hi(0x4000), %i0
} else if (p[0] != '/') {
40006414: 85 38 60 18 sra %g1, 0x18, %g2
40006418: 80 a0 a0 2f cmp %g2, 0x2f
4000641c: 12 80 00 0e bne 40006454 <Untar_ProcessHeader.part.0+0x18c>
40006420: c2 0f 60 01 ldub [ %i5 + 1 ], %g1
if (p[1] == '\0') {
40006424: 83 28 60 18 sll %g1, 0x18, %g1
40006428: 80 a0 60 00 cmp %g1, 0
4000642c: 02 80 00 97 be 40006688 <Untar_ProcessHeader.part.0+0x3c0> <== NEVER TAKEN
40006430: c0 2f 40 00 clrb [ %i5 ]
if (mkdir(path, S_IRWXU | S_IRWXG | S_IRWXO) != 0) {
40006434: 92 10 21 ff mov 0x1ff, %o1
40006438: 7f ff ef 56 call 40002190 <mkdir>
4000643c: 90 10 00 1b mov %i3, %o0
40006440: 80 a2 20 00 cmp %o0, 0
40006444: 12 80 00 15 bne 40006498 <Untar_ProcessHeader.part.0+0x1d0>
40006448: 01 00 00 00 nop
*p = '/';
4000644c: f4 2f 40 00 stb %i2, [ %i5 ]
if (p[0] == '\0') {
40006450: c2 0f 60 01 ldub [ %i5 + 1 ], %g1
40006454: 83 28 60 18 sll %g1, 0x18, %g1
40006458: 80 a0 60 00 cmp %g1, 0
4000645c: 12 bf ff ee bne 40006414 <Untar_ProcessHeader.part.0+0x14c>
40006460: ba 07 60 01 inc %i5
if (ctx->linkflag == SYMTYPE) {
40006464: f4 0f 20 78 ldub [ %i4 + 0x78 ], %i2
int retval = UNTAR_SUCCESSFUL;
40006468: b0 10 20 00 clr %i0
if (ctx->linkflag == SYMTYPE) {
4000646c: b4 0e a0 ff and %i2, 0xff, %i2
40006470: 80 a6 a0 32 cmp %i2, 0x32
40006474: 22 80 00 40 be,a 40006574 <Untar_ProcessHeader.part.0+0x2ac>
40006478: ba 07 20 08 add %i4, 8, %i5
} else if (ctx->linkflag == REGTYPE) {
4000647c: 80 a6 a0 30 cmp %i2, 0x30
40006480: 02 80 00 87 be 4000669c <Untar_ProcessHeader.part.0+0x3d4> <== ALWAYS TAKEN
40006484: 80 a6 a0 35 cmp %i2, 0x35
} else if (ctx->linkflag == DIRTYPE) {
40006488: 22 80 00 67 be,a 40006624 <Untar_ProcessHeader.part.0+0x35c> <== NOT EXECUTED
4000648c: d4 07 00 00 ld [ %i4 ], %o2 <== NOT EXECUTED
}
40006490: 81 c7 e0 08 ret <== NOT EXECUTED
40006494: 81 e8 00 00 restore <== NOT EXECUTED
if (errno == EEXIST || errno == EISDIR) {
40006498: 40 00 62 d3 call 4001efe4 <__errno>
4000649c: 01 00 00 00 nop
400064a0: c2 02 00 00 ld [ %o0 ], %g1
400064a4: 80 a0 60 11 cmp %g1, 0x11
400064a8: 02 80 00 09 be 400064cc <Untar_ProcessHeader.part.0+0x204> <== ALWAYS TAKEN
400064ac: 92 07 bf 98 add %fp, -104, %o1
400064b0: 40 00 62 cd call 4001efe4 <__errno> <== NOT EXECUTED
400064b4: 01 00 00 00 nop <== NOT EXECUTED
400064b8: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED
400064bc: 80 a0 60 15 cmp %g1, 0x15 <== NOT EXECUTED
400064c0: 32 bf ff e4 bne,a 40006450 <Untar_ProcessHeader.part.0+0x188> <== NOT EXECUTED
400064c4: f4 2f 40 00 stb %i2, [ %i5 ] <== NOT EXECUTED
if (stat(path, &sb) != 0) {
400064c8: 92 07 bf 98 add %fp, -104, %o1 <== NOT EXECUTED
400064cc: 7f ff f2 29 call 40002d70 <stat>
400064d0: 90 10 00 1b mov %i3, %o0
400064d4: 80 a2 20 00 cmp %o0, 0
400064d8: 12 80 00 20 bne 40006558 <Untar_ProcessHeader.part.0+0x290> <== NEVER TAKEN
400064dc: c2 07 bf a8 ld [ %fp + -88 ], %g1
if (!S_ISDIR(sb.st_mode)) {
400064e0: 82 08 40 11 and %g1, %l1, %g1
400064e4: 80 a0 40 18 cmp %g1, %i0
400064e8: 22 bf ff da be,a 40006450 <Untar_ProcessHeader.part.0+0x188> <== ALWAYS TAKEN
400064ec: f4 2f 40 00 stb %i2, [ %i5 ]
if (unlink(path) != 0) {
400064f0: 7f ff f6 c9 call 40004014 <unlink> <== NOT EXECUTED
400064f4: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
400064f8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400064fc: 12 80 00 75 bne 400066d0 <Untar_ProcessHeader.part.0+0x408> <== NOT EXECUTED
40006500: 92 10 21 ff mov 0x1ff, %o1 <== NOT EXECUTED
if (mkdir(path, S_IRWXU | S_IRWXG | S_IRWXO) != 0) {
40006504: 7f ff ef 23 call 40002190 <mkdir> <== NOT EXECUTED
40006508: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
4000650c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40006510: 22 bf ff d0 be,a 40006450 <Untar_ProcessHeader.part.0+0x188> <== NOT EXECUTED
40006514: f4 2f 40 00 stb %i2, [ %i5 ] <== NOT EXECUTED
message, path, errno, strerror(errno));
40006518: 40 00 62 b3 call 4001efe4 <__errno> <== NOT EXECUTED
4000651c: 01 00 00 00 nop <== NOT EXECUTED
rtems_printf(printer, "untar: %s: %s: (%d) %s\n",
40006520: d8 02 00 00 ld [ %o0 ], %o4 <== NOT EXECUTED
message, path, errno, strerror(errno));
40006524: 40 00 62 b0 call 4001efe4 <__errno> <== NOT EXECUTED
40006528: d8 27 bf 94 st %o4, [ %fp + -108 ] <== NOT EXECUTED
rtems_printf(printer, "untar: %s: %s: (%d) %s\n",
4000652c: 40 00 6e a8 call 40021fcc <strerror> <== NOT EXECUTED
40006530: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
40006534: d8 07 bf 94 ld [ %fp + -108 ], %o4 <== NOT EXECUTED
40006538: 9a 10 00 08 mov %o0, %o5 <== NOT EXECUTED
4000653c: 15 10 00 b4 sethi %hi(0x4002d000), %o2 <== NOT EXECUTED
40006540: 13 10 00 b4 sethi %hi(0x4002d000), %o1 <== NOT EXECUTED
40006544: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
40006548: 94 12 a3 80 or %o2, 0x380, %o2 <== NOT EXECUTED
4000654c: 92 12 63 68 or %o1, 0x368, %o1 <== NOT EXECUTED
40006550: 7f ff f1 52 call 40002a98 <rtems_printf> <== NOT EXECUTED
40006554: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
if (ctx->linkflag == SYMTYPE) {
40006558: f4 0f 20 78 ldub [ %i4 + 0x78 ], %i2 <== NOT EXECUTED
retval = UNTAR_FAIL;
4000655c: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
if (ctx->linkflag == SYMTYPE) {
40006560: b4 0e a0 ff and %i2, 0xff, %i2 <== NOT EXECUTED
40006564: 80 a6 a0 32 cmp %i2, 0x32 <== NOT EXECUTED
40006568: 12 bf ff c6 bne 40006480 <Untar_ProcessHeader.part.0+0x1b8> <== NOT EXECUTED
4000656c: 80 a6 a0 30 cmp %i2, 0x30 <== NOT EXECUTED
strlcpy(ctx->link_name, &bufr[157], sizeof(ctx->link_name));
40006570: ba 07 20 08 add %i4, 8, %i5 <== NOT EXECUTED
40006574: 94 10 20 64 mov 0x64, %o2
40006578: 92 06 60 9d add %i1, 0x9d, %o1
4000657c: 40 00 6e 9b call 40021fe8 <strlcpy>
40006580: 90 10 00 1d mov %i5, %o0
rtems_printf(ctx->printer, "untar: symlink: %s -> %s\n",
40006584: d6 07 00 00 ld [ %i4 ], %o3
40006588: d0 07 20 7c ld [ %i4 + 0x7c ], %o0
4000658c: 94 10 00 1d mov %i5, %o2
40006590: 13 10 00 b4 sethi %hi(0x4002d000), %o1
40006594: 7f ff f1 41 call 40002a98 <rtems_printf>
40006598: 92 12 63 90 or %o1, 0x390, %o1 ! 4002d390 <IMFS_node_control_sym_link+0x68>
r = symlink(ctx->link_name, ctx->file_path);
4000659c: d2 07 00 00 ld [ %i4 ], %o1
400065a0: 7f ff f6 8c call 40003fd0 <symlink>
400065a4: 90 10 00 1d mov %i5, %o0
if (r != 0) {
400065a8: 80 a2 20 00 cmp %o0, 0
400065ac: 02 80 00 47 be 400066c8 <Untar_ProcessHeader.part.0+0x400> <== ALWAYS TAKEN
400065b0: 01 00 00 00 nop
Print_Error(ctx->printer, "symlink", ctx->file_path);
400065b4: d6 07 00 00 ld [ %i4 ], %o3 <== NOT EXECUTED
400065b8: d6 27 bf 90 st %o3, [ %fp + -112 ] <== NOT EXECUTED
message, path, errno, strerror(errno));
400065bc: 40 00 62 8a call 4001efe4 <__errno> <== NOT EXECUTED
400065c0: fa 07 20 7c ld [ %i4 + 0x7c ], %i5 <== NOT EXECUTED
rtems_printf(printer, "untar: %s: %s: (%d) %s\n",
400065c4: d8 02 00 00 ld [ %o0 ], %o4 <== NOT EXECUTED
message, path, errno, strerror(errno));
400065c8: 40 00 62 87 call 4001efe4 <__errno> <== NOT EXECUTED
400065cc: d8 27 bf 94 st %o4, [ %fp + -108 ] <== NOT EXECUTED
rtems_printf(printer, "untar: %s: %s: (%d) %s\n",
400065d0: 40 00 6e 7f call 40021fcc <strerror> <== NOT EXECUTED
400065d4: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
400065d8: d8 07 bf 94 ld [ %fp + -108 ], %o4 <== NOT EXECUTED
400065dc: d6 07 bf 90 ld [ %fp + -112 ], %o3 <== NOT EXECUTED
400065e0: 15 10 00 b4 sethi %hi(0x4002d000), %o2 <== NOT EXECUTED
400065e4: 9a 10 00 08 mov %o0, %o5 <== NOT EXECUTED
400065e8: 94 12 a3 b0 or %o2, 0x3b0, %o2 <== NOT EXECUTED
retval = UNTAR_FAIL;
400065ec: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
rtems_printf(printer, "untar: %s: %s: (%d) %s\n",
400065f0: 13 10 00 b4 sethi %hi(0x4002d000), %o1 <== NOT EXECUTED
400065f4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
400065f8: 7f ff f1 28 call 40002a98 <rtems_printf> <== NOT EXECUTED
400065fc: 92 12 63 68 or %o1, 0x368, %o1 <== NOT EXECUTED
}
40006600: 81 c7 e0 08 ret <== NOT EXECUTED
40006604: 81 e8 00 00 restore <== NOT EXECUTED
rtems_printf(ctx->printer, "untar: file header checksum error\n");
40006608: d0 07 20 7c ld [ %i4 + 0x7c ], %o0 <== NOT EXECUTED
return UNTAR_INVALID_CHECKSUM;
4000660c: b0 10 20 02 mov 2, %i0 <== NOT EXECUTED
rtems_printf(ctx->printer, "untar: file header checksum error\n");
40006610: 13 10 00 b4 sethi %hi(0x4002d000), %o1 <== NOT EXECUTED
40006614: 7f ff f1 21 call 40002a98 <rtems_printf> <== NOT EXECUTED
40006618: 92 12 63 38 or %o1, 0x338, %o1 ! 4002d338 <IMFS_node_control_sym_link+0x10><== NOT EXECUTED
return UNTAR_INVALID_CHECKSUM;
4000661c: 81 c7 e0 08 ret <== NOT EXECUTED
40006620: 81 e8 00 00 restore <== NOT EXECUTED
rtems_printf(ctx->printer, "untar: dir: %s\n", ctx->file_path);
40006624: d0 07 20 7c ld [ %i4 + 0x7c ], %o0 <== NOT EXECUTED
40006628: 13 10 00 b4 sethi %hi(0x4002d000), %o1 <== NOT EXECUTED
4000662c: 7f ff f1 1b call 40002a98 <rtems_printf> <== NOT EXECUTED
40006630: 92 12 63 e0 or %o1, 0x3e0, %o1 ! 4002d3e0 <IMFS_node_control_sym_link+0xb8><== NOT EXECUTED
r = mkdir(ctx->file_path, ctx->mode);
40006634: d2 07 20 6c ld [ %i4 + 0x6c ], %o1 <== NOT EXECUTED
40006638: 7f ff ee d6 call 40002190 <mkdir> <== NOT EXECUTED
4000663c: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (r != 0) {
40006640: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40006644: 02 80 00 21 be 400066c8 <Untar_ProcessHeader.part.0+0x400> <== NOT EXECUTED
40006648: 01 00 00 00 nop <== NOT EXECUTED
Print_Error(ctx->printer, "mkdir", ctx->file_path);
4000664c: d6 07 00 00 ld [ %i4 ], %o3 <== NOT EXECUTED
40006650: d6 27 bf 90 st %o3, [ %fp + -112 ] <== NOT EXECUTED
message, path, errno, strerror(errno));
40006654: 40 00 62 64 call 4001efe4 <__errno> <== NOT EXECUTED
40006658: fa 07 20 7c ld [ %i4 + 0x7c ], %i5 <== NOT EXECUTED
rtems_printf(printer, "untar: %s: %s: (%d) %s\n",
4000665c: d8 02 00 00 ld [ %o0 ], %o4 <== NOT EXECUTED
message, path, errno, strerror(errno));
40006660: 40 00 62 61 call 4001efe4 <__errno> <== NOT EXECUTED
40006664: d8 27 bf 94 st %o4, [ %fp + -108 ] <== NOT EXECUTED
rtems_printf(printer, "untar: %s: %s: (%d) %s\n",
40006668: 40 00 6e 59 call 40021fcc <strerror> <== NOT EXECUTED
4000666c: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
40006670: 15 10 00 b4 sethi %hi(0x4002d000), %o2 <== NOT EXECUTED
40006674: d8 07 bf 94 ld [ %fp + -108 ], %o4 <== NOT EXECUTED
40006678: d6 07 bf 90 ld [ %fp + -112 ], %o3 <== NOT EXECUTED
4000667c: 9a 10 00 08 mov %o0, %o5 <== NOT EXECUTED
40006680: 10 bf ff db b 400065ec <Untar_ProcessHeader.part.0+0x324> <== NOT EXECUTED
40006684: 94 12 a3 f0 or %o2, 0x3f0, %o2 <== NOT EXECUTED
unlink(path);
40006688: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
4000668c: 7f ff f6 62 call 40004014 <unlink> <== NOT EXECUTED
40006690: b0 10 20 00 clr %i0 <== NOT EXECUTED
if (ctx->linkflag == SYMTYPE) {
40006694: 10 bf ff 76 b 4000646c <Untar_ProcessHeader.part.0+0x1a4> <== NOT EXECUTED
40006698: f4 0f 20 78 ldub [ %i4 + 0x78 ], %i2 <== NOT EXECUTED
rtems_printf(ctx->printer, "untar: file: %s (s:%lu,m:%04lo)\n",
4000669c: d8 07 20 6c ld [ %i4 + 0x6c ], %o4
400066a0: d6 07 20 70 ld [ %i4 + 0x70 ], %o3
400066a4: d4 07 00 00 ld [ %i4 ], %o2
400066a8: d0 07 20 7c ld [ %i4 + 0x7c ], %o0
400066ac: 13 10 00 b4 sethi %hi(0x4002d000), %o1
400066b0: 7f ff f0 fa call 40002a98 <rtems_printf>
400066b4: 92 12 63 b8 or %o1, 0x3b8, %o1 ! 4002d3b8 <IMFS_node_control_sym_link+0x90>
ctx->nblocks = (((ctx->file_size) + 511) & ~511) / 512;
400066b8: c2 07 20 70 ld [ %i4 + 0x70 ], %g1
400066bc: 82 00 61 ff add %g1, 0x1ff, %g1
400066c0: 83 30 60 09 srl %g1, 9, %g1
400066c4: c2 27 20 74 st %g1, [ %i4 + 0x74 ]
400066c8: 81 c7 e0 08 ret
400066cc: 81 e8 00 00 restore
message, path, errno, strerror(errno));
400066d0: 40 00 62 45 call 4001efe4 <__errno> <== NOT EXECUTED
400066d4: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
rtems_printf(printer, "untar: %s: %s: (%d) %s\n",
400066d8: d8 02 00 00 ld [ %o0 ], %o4 <== NOT EXECUTED
message, path, errno, strerror(errno));
400066dc: 40 00 62 42 call 4001efe4 <__errno> <== NOT EXECUTED
400066e0: d8 27 bf 94 st %o4, [ %fp + -108 ] <== NOT EXECUTED
rtems_printf(printer, "untar: %s: %s: (%d) %s\n",
400066e4: 40 00 6e 3a call 40021fcc <strerror> <== NOT EXECUTED
400066e8: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
400066ec: d8 07 bf 94 ld [ %fp + -108 ], %o4 <== NOT EXECUTED
400066f0: 9a 10 00 08 mov %o0, %o5 <== NOT EXECUTED
400066f4: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
400066f8: 15 10 00 b4 sethi %hi(0x4002d000), %o2 <== NOT EXECUTED
400066fc: 13 10 00 b4 sethi %hi(0x4002d000), %o1 <== NOT EXECUTED
40006700: 94 12 a3 60 or %o2, 0x360, %o2 <== NOT EXECUTED
40006704: 92 12 63 68 or %o1, 0x368, %o1 <== NOT EXECUTED
40006708: 7f ff f0 e4 call 40002a98 <rtems_printf> <== NOT EXECUTED
4000670c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
if (ctx->linkflag == SYMTYPE) {
40006710: 10 bf ff 94 b 40006560 <Untar_ProcessHeader.part.0+0x298> <== NOT EXECUTED
40006714: f4 0f 20 78 ldub [ %i4 + 0x78 ], %i2 <== NOT EXECUTED
sum += 0xff & ' ';
40006718: 86 00 e0 20 add %g3, 0x20, %g3
for (i=0; i<512; i++) {
4000671c: 10 bf ff 01 b 40006320 <Untar_ProcessHeader.part.0+0x58>
40006720: 82 10 00 02 mov %g2, %g1