[*] Binary protection state of ubinize
Partial RELRO No Canary found NX disabled No PIE No RPATH No RUNPATH No Symbols
[*] Function fprintf tear down of ubinize
; assembly | /* r2dec pseudo code output */
| /* /logs/firmware/unblob_extracted/firmware_extract/56048-12514271.gzip_extract/gzip.uncompressed_extract/5243916-15068666.gzip_extract/gzip.uncompressed_extract/usr/sbin/ubinize @ 0x12008 */
| #include <stdint.h>
|
; (fcn) fcn.00012008 () | void fcn_00012008 (int32_t arg1, int32_t arg2) {
| int32_t var_0h;
| char * * endptr;
| int32_t var_10h;
| r0 = arg1;
| r1 = arg2;
0x00012008 push {r0, r1, r2, r3, r4, r5, r6, lr} |
0x0001200c mov r6, r1 | r6 = r1;
0x00012010 mov r2, 0 | r2 = 0;
0x00012014 add r1, sp, 0xc | r1 += endptr;
0x00012018 mov r4, r0 | r4 = r0;
0x0001201c bl 0x10b0c | strtoul (r0, r1, r2);
0x00012020 ldrb r3, [r4] | r3 = *(r4);
0x00012024 cmp r3, 0 |
0x00012028 mov r5, r0 | r5 = r0;
| if (r3 != 0) {
0x0001202c beq 0x12040 |
0x00012030 ldr r3, [sp, 0xc] | r3 = endptr;
0x00012034 ldrb r3, [r3] | r3 = *(r3);
0x00012038 cmp r3, 0 |
| if (r3 == 0) {
0x0001203c beq 0x12064 | goto label_0;
| }
| }
0x00012040 ldr r0, [pc, 0x28] |
0x00012044 str r4, [sp] | *(sp) = r4;
0x00012048 ldr r3, [pc, 0x24] | r3 = stderr;
0x0001204c ldr r2, [pc, 0x24] | r2 = "strtoul";
0x00012050 ldr r1, [pc, 0x24] | r1 = "ubinize";
0x00012054 ldr r0, [r0] | r0 = *(0x1206c);
0x00012058 bl 0x10b48 | fprintf (r0, "ubinize", "strtoul", r3, r4)
0x0001205c mov r3, 1 | r3 = 1;
0x00012060 str r3, [r6] | *(r6) = r3;
| label_0:
0x00012064 mov r0, r5 | r0 = r5;
0x00012068 add sp, sp, 0x10 |
0x0001206c pop {r4, r5, r6, pc} |
| }
; assembly | /* r2dec pseudo code output */
| /* /logs/firmware/unblob_extracted/firmware_extract/56048-12514271.gzip_extract/gzip.uncompressed_extract/5243916-15068666.gzip_extract/gzip.uncompressed_extract/usr/sbin/ubinize @ 0x1211c */
| #include <stdint.h>
|
; (fcn) fcn.0001211c () | void fcn_0001211c (size_t size) {
| int32_t var_0h;
| int32_t var_4h;
| int32_t var_8h;
| r0 = size;
0x0001211c push {r0, r1, r4, r5, r6, r7, r8, lr} |
0x00012120 ldr r8, [r0, 0x18] | r8 = *((r0 + 0x18));
0x00012124 mov r7, r0 | r7 = r0;
0x00012128 mov r1, r8 | r1 = r8;
0x0001212c mov r0, 1 | r0 = 1;
0x00012130 bl 0x10b30 | r0 = calloc (r0, r1);
0x00012134 subs r6, r0, 0 | r6 = r0 - 0;
| if (r6 == r0) {
0x00012138 movne r4, r6 | r4 = r6;
| }
| if (r6 == r0) {
0x0001213c movne r5, 0 | r5 = 0;
| }
| if (r6 != r0) {
0x00012140 bne 0x121d4 | goto label_1;
| }
0x00012144 bl 0x10c08 | errno_location ();
0x00012148 ldr r5, [pc, 0x94] |
0x0001214c mov r3, r8 | r3 = r8;
0x00012150 ldr r2, [pc, 0x90] | r2 = stderr;
0x00012154 ldr r1, [pc, 0x90] | r1 = "libubigen";
0x00012158 ldr r4, [r0] | r4 = *(r0);
0x0001215c ldr r0, [r5] | r0 = *(0x121e0);
0x00012160 bl 0x10b48 | fprintf (r0, "libubigen", r2, r3, r4, r5)
0x00012164 mov r0, r4 | r0 = r4;
0x00012168 ldr r5, [r5] | r5 = *(0x121e0);
0x0001216c bl 0x10aa0 | strerror (r0);
0x00012170 str r4, [sp] | *(sp) = r4;
0x00012174 ldr r3, [pc, 0x74] | r3 = "_s:_error_:_cannot_allocate__d_bytes_of_memory";
0x00012178 mov r2, 0xb | r2 = 0xb;
0x0001217c ldr r1, [pc, 0x70] | r1 = *(0x121f0);
0x00012180 str r0, [sp, 4] | var_4h = r0;
0x00012184 mov r0, r5 | r0 = r5;
0x00012188 bl 0x10b48 | fprintf (r0, r1, r2, "_s:_error_:_cannot_allocate__d_bytes_of_memory", r4)
| label_0:
0x0001218c mov r0, r6 | r0 = r6;
0x00012190 add sp, sp, 8 |
0x00012194 pop {r4, r5, r6, r7, r8, pc} |
| do {
0x00012198 mov r2, 0xa8 | r2 = 0xa8;
0x0001219c mov r1, r4 | r1 = r4;
0x000121a0 mvn r0, 0 | r0 = ~0;
0x000121a4 bl 0x130d4 | fcn_000130d4 (r0);
0x000121a8 add r5, r5, 1 | r5++;
0x000121ac add r4, r4, 0xac | r4 += 0xac;
0x000121b0 lsr r3, r0, 0x18 | r3 = r0 >> 0x18;
0x000121b4 lsl r2, r0, 8 | r2 = r0 << 8;
0x000121b8 orr r3, r3, r0, lsl 24 | r3 |= (r0 << 24);
0x000121bc and r2, r2, 0xff0000 | r2 &= 0xff0000;
0x000121c0 lsr r0, r0, 8 | r0 >>= 8;
0x000121c4 orr r3, r3, r2 | r3 |= r2;
0x000121c8 and r0, r0, 0xff00 | r0 &= 0xff00;
0x000121cc orr r0, r3, r0 | r0 = r3 | r0;
0x000121d0 str r0, [r4, -4] | *((r4 - 4)) = r0;
| label_1:
0x000121d4 ldr r3, [r7, 0x1c] | r3 = *((r7 + 0x1c));
0x000121d8 cmp r3, r5 |
0x000121dc bgt 0x12198 |
| } while (r3 > r5);
0x000121e0 b 0x1218c | goto label_0;
| }
; assembly | /* r2dec pseudo code output */
| /* /logs/firmware/unblob_extracted/firmware_extract/56048-12514271.gzip_extract/gzip.uncompressed_extract/5243916-15068666.gzip_extract/gzip.uncompressed_extract/usr/sbin/ubinize @ 0x121f8 */
| #include <stdint.h>
|
; (fcn) fcn.000121f8 () | void fcn_000121f8 (int32_t arg_0h, int32_t arg1, int32_t arg2) {
| int32_t var_0h;
| int32_t var_ch;
| r0 = arg1;
| r1 = arg2;
0x000121f8 ldr r3, [r1] | r3 = *(r1);
0x000121fc push {r0, r1, r2, r4, r5, r6, r7, r8, sb, sl, fp, lr} |
0x00012200 mov r6, r2 | r6 = r2;
0x00012204 mov r5, r1 | r5 = r1;
0x00012208 mov r2, 0xac | r2 = 0xac;
0x0001220c ldr r1, [r0, 0x1c] | r1 = *(arg_0hx1c);
0x00012210 mul r8, r2, r3 | r8 = r2 * r3;
0x00012214 cmp r3, r1 |
0x00012218 add r4, r6, r8 | r4 = r6 + r8;
| if (r3 < r1) {
0x0001221c blt 0x12250 | goto label_1;
| }
0x00012220 str r1, [sp] | *(sp) = r1;
0x00012224 ldr r2, [pc, 0x1d0] | r2 = *(0x123f8);
0x00012228 ldr r1, [pc, 0x1d0] | r1 = "libubigen";
| do {
0x0001222c ldr r0, [pc, 0x1d0] |
0x00012230 ldr r0, [r0] | r0 = "_s:_error_:_too_high_volume_id__d__max._volumes_is__d";
0x00012234 bl 0x10b48 | r0 = fprintf ("_s:_error_:_too_high_volume_id__d__max._volumes_is__d", r1, r2)
0x00012238 bl 0x10c08 | errno_location ();
0x0001223c mov r3, 0x16 | r3 = 0x16;
0x00012240 str r3, [r0] | *(r0) = r3;
0x00012244 mvn r0, 0 | r0 = ~0;
| label_0:
0x00012248 add sp, sp, 0xc |
0x0001224c pop {r4, r5, r6, r7, r8, sb, sl, fp, pc} |
| label_1:
0x00012250 ldr r3, [r5, 8] | r3 = *((r5 + 8));
0x00012254 ldr r1, [r0] | r1 = *(r0);
0x00012258 mov r7, r0 | r7 = r0;
0x0001225c cmp r3, r1 |
| if (r3 < r1) {
0x00012260 strge r1, [sp] | *(sp) = r1;
| }
| if (r3 < r1) {
0x00012264 ldrge r2, [pc, 0x190] | r2 = "libubigen";
| }
| if (r3 < r1) {
0x00012268 ldrge r1, [pc, 0x198] | r1 = "%s: error!: too large alignment %d, max is %d (LEB size)\n";
| }
0x0001226c bge 0x1222c |
| } while (r3 >= r1);
0x00012270 mov r1, 0 | r1 = 0;
0x00012274 mov r0, r4 | r0 = r4;
0x00012278 bl 0x10bb4 | memset (r0, r1, r2);
0x0001227c ldr r7, [r7] | r7 = *(r7);
0x00012280 ldrd r0, r1, [r5, 0x28] | __asm ("ldrd r0, r1, [r5, 0x28]");
0x00012284 asr r3, r7, 0x1f | r3 = r7 >> 0x1f;
0x00012288 adds sl, r0, r7 | sl = r0 + r7;
0x0001228c adc fp, r1, r3 | __asm ("adc fp, r1, r3");
0x00012290 subs r0, sl, 1 | r0 = sl - 1;
0x00012294 sbc r1, fp, 0 | __asm ("sbc r1, arg_0h");
0x00012298 mov r2, r7 | r2 = r7;
0x0001229c bl 0x14144 | fcn_00014144 (r0);
0x000122a0 ldr r1, [r5, 8] | r1 = *((r5 + 8));
0x000122a4 mov sb, 0 | sb = 0;
0x000122a8 lsr r3, r0, 0x18 | r3 = r0 >> 0x18;
0x000122ac lsl r2, r0, 8 | r2 = r0 << 8;
0x000122b0 orr r3, r3, r0, lsl 24 | r3 |= (r0 << 24);
0x000122b4 and r2, r2, 0xff0000 | r2 &= 0xff0000;
0x000122b8 lsr r0, r0, 8 | r0 >>= 8;
0x000122bc orr r3, r3, r2 | r3 |= r2;
0x000122c0 and r0, r0, 0xff00 | r0 &= 0xff00;
0x000122c4 orr r0, r3, r0 | r0 = r3 | r0;
0x000122c8 lsr r3, r0, 8 | r3 = r0 >> 8;
0x000122cc strb r0, [r6, r8] | *((r6 + r8)) = r0;
0x000122d0 strb r3, [r4, 1] | *((r4 + 1)) = r3;
0x000122d4 lsr r3, r0, 0x10 | r3 = r0 >> 0x10;
0x000122d8 strb r3, [r4, 2] | *((r4 + 2)) = r3;
0x000122dc lsl r2, r1, 8 | r2 = r1 << 8;
0x000122e0 lsr r3, r1, 0x18 | r3 = r1 >> 0x18;
0x000122e4 orr r3, r3, r1, lsl 24 | r3 |= (r1 << 24);
0x000122e8 and r2, r2, 0xff0000 | r2 &= 0xff0000;
0x000122ec orr r3, r3, r2 | r3 |= r2;
0x000122f0 lsr r2, r1, 8 | r2 = r1 >> 8;
0x000122f4 and r2, r2, 0xff00 | r2 &= 0xff00;
0x000122f8 orr r3, r3, r2 | r3 |= r2;
0x000122fc lsr r2, r3, 8 | r2 = r3 >> 8;
0x00012300 strb r3, [r4, 4] | *((r4 + 4)) = r3;
0x00012304 strb r2, [r4, 5] | *((r4 + 5)) = r2;
0x00012308 lsr r2, r3, 0x10 | r2 = r3 >> 0x10;
0x0001230c lsr r3, r3, 0x18 | r3 >>= 0x18;
0x00012310 strb r3, [r4, 7] | *((r4 + 7)) = r3;
0x00012314 ldr r3, [r5, 4] | r3 = *((r5 + 4));
0x00012318 lsr r0, r0, 0x18 | r0 >>= 0x18;
0x0001231c strb r0, [r4, 3] | *((r4 + 3)) = r0;
0x00012320 strb r2, [r4, 6] | *((r4 + 6)) = r2;
0x00012324 strb r3, [r4, 0xc] | *((r4 + 0xc)) = r3;
0x00012328 mov r0, r7 | r0 = r7;
0x0001232c bl 0x14124 | fcn_00014124 (r0, r1);
0x00012330 add r0, r4, 0x10 | r0 = r4 + 0x10;
0x00012334 lsr r3, r1, 0x18 | r3 = r1 >> 0x18;
0x00012338 lsl r2, r1, 8 | r2 = r1 << 8;
0x0001233c orr r3, r3, r1, lsl 24 | r3 |= (r1 << 24);
0x00012340 and r2, r2, 0xff0000 | r2 &= 0xff0000;
0x00012344 lsr r1, r1, 8 | r1 >>= 8;
0x00012348 orr r3, r3, r2 | r3 |= r2;
0x0001234c and r1, r1, 0xff00 | r1 &= 0xff00;
0x00012350 orr r1, r3, r1 | r1 = r3 | r1;
0x00012354 lsr r3, r1, 8 | r3 = r1 >> 8;
0x00012358 strb r1, [r4, 8] | *((r4 + 8)) = r1;
0x0001235c strb r3, [r4, 9] | *((r4 + 9)) = r3;
0x00012360 lsr r3, r1, 0x10 | r3 = r1 >> 0x10;
0x00012364 lsr r1, r1, 0x18 | r1 >>= 0x18;
0x00012368 strb r1, [r4, 0xb] | *((r4 + 0xb)) = r1;
0x0001236c strb r3, [r4, 0xa] | *((r4 + 0xa)) = r3;
0x00012370 ldrb r3, [r5, 0x30] | r3 = *((r5 + 0x30));
0x00012374 strb r3, [r4, 0x90] | *((r4 + 0x90)) = r3;
0x00012378 ldr r2, [r5, 0x18] | r2 = *((r5 + 0x18));
0x0001237c ldr r1, [r5, 0x14] | r1 = *((r5 + 0x14));
0x00012380 bl 0x10adc | memcpy (r0, r1, r2);
0x00012384 ldr r2, [r5, 0x18] | r2 = *((r5 + 0x18));
0x00012388 mov r1, r4 | r1 = r4;
0x0001238c add r3, r4, r2 | r3 = r4 + r2;
0x00012390 strb sb, [r3, 0x10] | *((r3 + 0x10)) = sb;
0x00012394 lsl r3, r2, 0x10 | r3 = r2 << 0x10;
0x00012398 lsr r3, r3, 0x18 | r3 >>= 0x18;
0x0001239c orr r3, r3, r2, lsl 8 | r3 |= (r2 << 8);
0x000123a0 strb r3, [r4, 0xe] | *((r4 + 0xe)) = r3;
0x000123a4 lsr r3, r3, 8 | r3 >>= 8;
0x000123a8 strb r3, [r4, 0xf] | *((r4 + 0xf)) = r3;
0x000123ac mov r2, 0xa8 | r2 = 0xa8;
0x000123b0 mvn r0, 0 | r0 = ~0;
0x000123b4 bl 0x130d4 | r0 = fcn_000130d4 (r0);
0x000123b8 lsr r3, r0, 0x18 | r3 = r0 >> 0x18;
0x000123bc lsl r2, r0, 8 | r2 = r0 << 8;
0x000123c0 orr r3, r3, r0, lsl 24 | r3 |= (r0 << 24);
0x000123c4 and r2, r2, 0xff0000 | r2 &= 0xff0000;
0x000123c8 lsr r0, r0, 8 | r0 >>= 8;
0x000123cc orr r3, r3, r2 | r3 |= r2;
0x000123d0 and r0, r0, 0xff00 | r0 &= 0xff00;
0x000123d4 orr r3, r3, r0 | r3 |= r0;
0x000123d8 lsr r2, r3, 8 | r2 = r3 >> 8;
0x000123dc strb r3, [r4, 0xa8] | *((r4 + 0xa8)) = r3;
0x000123e0 strb r2, [r4, 0xa9] | *((r4 + 0xa9)) = r2;
0x000123e4 lsr r2, r3, 0x10 | r2 = r3 >> 0x10;
0x000123e8 lsr r3, r3, 0x18 | r3 >>= 0x18;
0x000123ec strb r2, [r4, 0xaa] | *((r4 + 0xaa)) = r2;
0x000123f0 strb r3, [r4, 0xab] | *((r4 + 0xab)) = r3;
0x000123f4 mov r0, sb | r0 = sb;
0x000123f8 b 0x12248 | goto label_0;
| }
; assembly | /* r2dec pseudo code output */
| /* /logs/firmware/unblob_extracted/firmware_extract/56048-12514271.gzip_extract/gzip.uncompressed_extract/5243916-15068666.gzip_extract/gzip.uncompressed_extract/usr/sbin/ubinize @ 0x128a0 */
| #include <stdint.h>
|
; (fcn) fcn.000128a0 () | void fcn_000128a0 (int32_t arg_38h, int32_t fildes, int32_t fd, int32_t arg1, int32_t arg2) {
| int32_t var_0h;
| int32_t var_4h;
| int32_t var_8h;
| int32_t var_8h_2;
| int32_t var_14h;
| r0 = arg1;
| r1 = arg2;
0x000128a0 push {r4, r5, r6, r7, r8, sb, sl, fp, lr} |
0x000128a4 ldr r5, [r1, 0x10] | r5 = *((r1 + 0x10));
0x000128a8 sub sp, sp, 0x14 |
0x000128ac strd r2, r3, [sp, 8] | __asm ("strd r2, r3, [var_8h]");
0x000128b0 ldr r3, [r1] | r3 = *(r1);
0x000128b4 ldr r2, [r0, 0x1c] | r2 = *(arg_38hx1c);
0x000128b8 ldrd r8, sb, [sp, 0x38] | __asm ("ldrd r8, sb, [arg_38h]");
0x000128bc cmp r3, r2 |
| if (r3 < r2) {
0x000128c0 blt 0x128f0 | goto label_3;
| }
0x000128c4 str r2, [sp] | *(sp) = r2;
0x000128c8 ldr r1, [pc, 0x274] | r1 = *(0x12b40);
0x000128cc ldr r2, [pc, 0x274] | r2 = "_s:_error_:_too_high_volume_id__d__max._volumes_is__d";
| do {
0x000128d0 ldr r0, [pc, 0x274] |
0x000128d4 ldr r0, [r0] | r0 = "libubigen";
0x000128d8 bl 0x10b48 | r0 = fprintf ("libubigen", r1, r2)
0x000128dc bl 0x10c08 | errno_location ();
0x000128e0 mov r3, 0x16 | r3 = 0x16;
0x000128e4 str r3, [r0] | *(r0) = r3;
| label_0:
0x000128e8 mvn r0, 0 | r0 = ~0;
0x000128ec b 0x12a14 | goto label_4;
| label_3:
0x000128f0 ldr r3, [r1, 8] | r3 = *((r1 + 8));
0x000128f4 ldr r6, [r0] | r6 = *(r0);
0x000128f8 mov r4, r0 | r4 = r0;
0x000128fc cmp r3, r6 |
0x00012900 mov sl, r1 | sl = r1;
| if (r3 < r6) {
0x00012904 strge r6, [sp] | *(sp) = r6;
| }
| if (r3 < r6) {
0x00012908 ldrge r2, [pc, 0x238] | r2 = "libubigen";
| }
| if (r3 < r6) {
0x0001290c ldrge r1, [pc, 0x23c] | r1 = "%s: error!: too large alignment %d, max is %d (LEB size)\n";
| }
0x00012910 bge 0x128d0 |
| } while (r3 >= r6);
0x00012914 mov r0, r6 | r0 = r6;
0x00012918 bl 0x10af4 | r0 = malloc (r0);
0x0001291c subs r7, r0, 0 | r7 = r0 - 0;
| if (r7 == r0) {
0x00012920 bne 0x12970 |
0x00012924 bl 0x10c08 | errno_location ();
0x00012928 ldr r5, [pc, 0x21c] |
0x0001292c mov r3, r6 | r3 = r6;
0x00012930 ldr r2, [pc, 0x210] | r2 = "_s:_error_:_too_high_volume_id__d__max._volumes_is__d";
0x00012934 ldr r1, [pc, 0x218] | r1 = "%s: error!: too large alignment %d, max is %d (LEB size)\n";
0x00012938 ldr r4, [r0] | r4 = *(r0);
0x0001293c ldr r0, [r5] | r0 = "libubigen";
0x00012940 bl 0x10b48 | fprintf ("libubigen", "%s: error!: too large alignment %d, max is %d (LEB size)\n", "_s:_error_:_too_high_volume_id__d__max._volumes_is__d", r3, r4, "libubigen")
0x00012944 mov r0, r4 | r0 = r4;
0x00012948 ldr r5, [r5] | r5 = "libubigen";
0x0001294c bl 0x10aa0 | strerror (r0);
0x00012950 str r4, [sp] | *(sp) = r4;
0x00012954 ldr r3, [pc, 0x1fc] | r3 = "_s:_error_:_cannot_allocate__d_bytes_of_memory";
0x00012958 mov r2, 0xb | r2 = 0xb;
0x0001295c ldr r1, [pc, 0x1f8] | r1 = *(0x12b58);
0x00012960 str r0, [sp, 4] | var_4h = r0;
0x00012964 mov r0, r5 | r0 = r5;
0x00012968 bl 0x10b48 | fprintf (r0, r1, r2, "_s:_error_:_cannot_allocate__d_bytes_of_memory", r4)
0x0001296c b 0x128e8 | goto label_0;
| }
0x00012970 ldr fp, [r4, 4] | fp = *((r4 + 4));
0x00012974 mov r0, fp | r0 = fp;
0x00012978 bl 0x10af4 | r0 = malloc (r0);
0x0001297c subs r6, r0, 0 | r6 = r0 - 0;
| if (r6 != r0) {
0x00012980 bne 0x129d8 | goto label_5;
| }
0x00012984 bl 0x10c08 | errno_location ();
0x00012988 ldr r5, [pc, 0x1bc] |
0x0001298c mov r3, fp | r3 = fp;
0x00012990 ldr r2, [pc, 0x1b0] | r2 = "_s:_error_:_too_high_volume_id__d__max._volumes_is__d";
0x00012994 ldr r1, [pc, 0x1b8] | r1 = "%s: error!: too large alignment %d, max is %d (LEB size)\n";
0x00012998 ldr r4, [r0] | r4 = *(r0);
0x0001299c ldr r0, [r5] | r0 = "libubigen";
0x000129a0 bl 0x10b48 | fprintf ("libubigen", "%s: error!: too large alignment %d, max is %d (LEB size)\n", "_s:_error_:_too_high_volume_id__d__max._volumes_is__d", r3, r4, "libubigen")
0x000129a4 mov r0, r4 | r0 = r4;
0x000129a8 ldr r5, [r5] | r5 = "libubigen";
0x000129ac bl 0x10aa0 | strerror (r0);
0x000129b0 str r4, [sp] | *(sp) = r4;
0x000129b4 ldr r3, [pc, 0x19c] | r3 = "_s:_error_:_cannot_allocate__d_bytes_of_memory";
0x000129b8 mov r2, 0xb | r2 = 0xb;
0x000129bc ldr r1, [pc, 0x198] | r1 = *(0x12b58);
0x000129c0 str r0, [sp, 4] | var_4h = r0;
0x000129c4 mov r0, r5 | r0 = r5;
0x000129c8 bl 0x10b48 | fprintf (r0, r1, r2, "_s:_error_:_cannot_allocate__d_bytes_of_memory", r4)
| do {
0x000129cc mov r0, r7 | r0 = r7;
0x000129d0 bl 0x10c74 | free (r0);
0x000129d4 b 0x128e8 | goto label_0;
| label_5:
0x000129d8 ldr r2, [r4, 0x10] | r2 = *((r4 + 0x10));
0x000129dc mov r1, 0xff | r1 = 0xff;
0x000129e0 bl 0x10bb4 | memset (r0, r1, r2);
0x000129e4 ldrd r2, r3, [sp, 8] | __asm ("ldrd r2, r3, [var_8h]");
0x000129e8 mov r1, r6 | r1 = r6;
0x000129ec mov r0, r4 | r0 = r4;
0x000129f0 bl 0x1240c | fcn_0001240c (r0, r1);
0x000129f4 mov fp, 0 |
| label_2:
0x000129f8 orrs r3, r8, sb | r3 = r8 | sb;
| if (r3 == r8) {
0x000129fc bne 0x12a1c |
0x00012a00 mov r0, r6 | r0 = r6;
0x00012a04 bl 0x10c74 | free (r0);
0x00012a08 mov r0, r7 | r0 = r7;
0x00012a0c bl 0x10c74 | free (r0);
0x00012a10 mov r0, 0 | r0 = 0;
| label_4:
0x00012a14 add sp, sp, 0x14 |
0x00012a18 pop {r4, r5, r6, r7, r8, sb, sl, fp, pc} |
| }
0x00012a1c cmp r8, r5 |
0x00012a20 asr r3, r5, 0x1f | r3 = r5 >> 0x1f;
0x00012a24 sbcs r3, sb, r3 | __asm ("sbcs r3, sb, r3");
| if (r8 >= r5) {
0x00012a28 movlt r5, r8 | r5 = r8;
| }
0x00012a2c subs r8, r8, r5 | r8 -= r5;
0x00012a30 mov r2, r5 | r2 = r5;
0x00012a34 mov r1, r7 | r1 = r7;
0x00012a38 ldr r0, [sp, 0x40] | r0 = *(fildes);
0x00012a3c sbc sb, sb, r5, asr 31 | __asm ("sbc sb, sb, r5, asr 31");
0x00012a40 bl 0x10b6c | r0 = read (r0, r1, r2);
0x00012a44 cmp r5, r0 |
| if (r5 == r0) {
0x00012a48 beq 0x12aa0 | goto label_6;
| }
0x00012a4c bl 0x10c08 | errno_location ();
0x00012a50 ldr r8, [pc, 0xf4] | r8 = "libubigen";
0x00012a54 mov r3, r5 | r3 = r5;
0x00012a58 ldr r2, [pc, 0xe8] | r2 = "_s:_error_:_too_high_volume_id__d__max._volumes_is__d";
0x00012a5c ldr r1, [pc, 0xfc] | r1 = "_serror__d___s_";
0x00012a60 ldr r4, [r0] | r4 = *(r0);
0x00012a64 ldr r0, [r8] | r0 = "libubigen";
0x00012a68 bl 0x10b48 | fprintf ("libubigen", "_serror__d___s_", "_s:_error_:_too_high_volume_id__d__max._volumes_is__d", r3, r4)
0x00012a6c ldr r5, [r8] | r5 = "libubigen";
| label_1:
0x00012a70 mov r0, r4 | r0 = r4;
0x00012a74 bl 0x10aa0 | strerror (r0);
0x00012a78 str r4, [sp] | *(sp) = r4;
0x00012a7c ldr r3, [pc, 0xd4] | r3 = "_s:_error_:_cannot_allocate__d_bytes_of_memory";
0x00012a80 mov r2, 0xb | r2 = 0xb;
0x00012a84 ldr r1, [pc, 0xd0] | r1 = *(0x12b58);
0x00012a88 str r0, [sp, 4] | var_4h = r0;
0x00012a8c mov r0, r5 | r0 = r5;
0x00012a90 bl 0x10b48 | fprintf (r0, r1, r2, "_s:_error_:_cannot_allocate__d_bytes_of_memory", r4)
0x00012a94 mov r0, r6 | r0 = r6;
0x00012a98 bl 0x10c74 | free (r0);
0x00012a9c b 0x129cc |
| } while (1);
| label_6:
0x00012aa0 ldr r2, [r4, 0xc] | r2 = *((r4 + 0xc));
0x00012aa4 mov r3, fp | r3 = fp;
0x00012aa8 add r2, r6, r2 | r2 = r6 + r2;
0x00012aac mov r1, sl | r1 = sl;
0x00012ab0 mov r0, r4 | r0 = r4;
0x00012ab4 str r5, [sp, 4] | var_4h = r5;
0x00012ab8 str r7, [sp] | *(sp) = r7;
0x00012abc bl 0x12664 | fcn_00012664 (r0, r1, r2, r3);
0x00012ac0 ldr r0, [r4, 0x10] | r0 = *((r4 + 0x10));
0x00012ac4 mov r2, r5 | r2 = r5;
0x00012ac8 mov r1, r7 | r1 = r7;
0x00012acc add r0, r6, r0 | r0 = r6 + r0;
0x00012ad0 bl 0x10adc | memcpy (r0, r1, r2);
0x00012ad4 ldr r0, [r4, 0x10] | r0 = *((r4 + 0x10));
0x00012ad8 ldr r2, [r4, 4] | r2 = *((r4 + 4));
0x00012adc mov r1, 0xff | r1 = 0xff;
0x00012ae0 sub r2, r2, r0 | r2 -= r0;
0x00012ae4 add r0, r0, r5 | r0 += r5;
0x00012ae8 sub r2, r2, r5 | r2 -= r5;
0x00012aec add r0, r6, r0 | r0 = r6 + r0;
0x00012af0 bl 0x10bb4 | memset (r0, r1, r2);
0x00012af4 ldr r2, [r4, 4] | r2 = *((r4 + 4));
0x00012af8 mov r1, r6 | r1 = r6;
0x00012afc ldr r0, [sp, 0x44] | r0 = *(fd);
0x00012b00 bl 0x10b3c | write (r0, r1, r2);
0x00012b04 ldr r3, [r4, 4] | r3 = *((r4 + 4));
0x00012b08 cmp r0, r3 |
| if (r0 != r3) {
0x00012b0c beq 0x12b3c |
0x00012b10 str r3, [sp, 8] | var_8h = r3;
0x00012b14 bl 0x10c08 | errno_location ();
0x00012b18 ldr r5, [pc, 0x2c] |
0x00012b1c ldr r3, [sp, 8] | r3 = var_8h;
0x00012b20 ldr r2, [pc, 0x20] | r2 = "_s:_error_:_too_high_volume_id__d__max._volumes_is__d";
0x00012b24 ldr r1, [pc, 0x38] | r1 = "%s: error!: cannot read %d bytes from the input file\n";
0x00012b28 ldr r4, [r0] | r4 = *(r0);
0x00012b2c ldr r0, [r5] | r0 = "libubigen";
0x00012b30 bl 0x10b48 | fprintf ("libubigen", "%s: error!: cannot read %d bytes from the input file\n", "_s:_error_:_too_high_volume_id__d__max._volumes_is__d", r3, r4, "libubigen")
0x00012b34 ldr r5, [r5] | r5 = "libubigen";
0x00012b38 b 0x12a70 | goto label_1;
| }
0x00012b3c add fp, fp, 1 |
0x00012b40 b 0x129f8 | goto label_2;
| }
; assembly | /* r2dec pseudo code output */
| /* /logs/firmware/unblob_extracted/firmware_extract/56048-12514271.gzip_extract/gzip.uncompressed_extract/5243916-15068666.gzip_extract/gzip.uncompressed_extract/usr/sbin/ubinize @ 0x12b68 */
| #include <stdint.h>
|
; (fcn) fcn.00012b68 () | void fcn_00012b68 (int32_t arg_70h, int32_t arg_78h, void * s2, int32_t fd, int32_t arg1, void * arg2) {
| int32_t var_0h;
| int32_t var_4h;
| int32_t var_ch;
| int32_t var_10h;
| int32_t var_14h;
| int32_t var_18h;
| int32_t var_1ch;
| int32_t var_20h;
| int32_t var_24h;
| int32_t var_28h;
| int32_t var_28h_2;
| int32_t var_38h;
| int32_t var_38h_2;
| int32_t var_4ch;
| r0 = arg1;
| r1 = arg2;
0x00012b68 push {r4, r5, r6, r7, r8, sb, sl, fp, lr} |
0x00012b6c mov fp, r1 |
0x00012b70 ldr r1, [r0] | r1 = *(r0);
0x00012b74 sub sp, sp, 0x4c |
0x00012b78 str r2, [sp, 0xc] | var_ch = r2;
0x00012b7c lsl r2, r1, 1 | r2 = r1 << 1;
0x00012b80 asr r3, r2, 0x1f | r3 = r2 >> 0x1f;
0x00012b84 strd r2, r3, [sp, 0x38] | __asm ("strd r2, r3, [var_38h]");
0x00012b88 ldr r3, [pc, 0x25c] | r3 = *(0x12de8);
0x00012b8c mov r8, 0xd | r8 = 0xd;
0x00012b90 mov sb, 5 | sb = 5;
0x00012b94 strd r8, sb, [sp, 0x28] | __asm ("strd r8, sb, [var_28h]");
0x00012b98 ldr r8, [r0, 4] | r8 = *((r0 + 4));
0x00012b9c str r3, [sp, 0x10] | var_10h = r3;
0x00012ba0 ldr r3, [pc, 0x248] | r3 = *(0x12dec);
0x00012ba4 mov r7, 1 | r7 = 1;
0x00012ba8 mov r4, r0 | r4 = r0;
0x00012bac mov r5, 0 | r5 = 0;
0x00012bb0 mov r0, r8 | r0 = r8;
0x00012bb4 str r7, [sp, 0x18] | var_18h = r7;
0x00012bb8 str r5, [sp, 0x1c] | var_1ch = r5;
0x00012bbc str r1, [sp, 0x20] | var_20h = r1;
0x00012bc0 str r7, [sp, 0x14] | var_14h = r7;
0x00012bc4 str r3, [sp, 0x24] | var_24h = r3;
0x00012bc8 bl 0x10af4 | r0 = malloc (r0);
0x00012bcc subs r6, r0, 0 | r6 = r0 - 0;
| if (r6 != r0) {
0x00012bd0 bne 0x12c24 | goto label_3;
| }
0x00012bd4 bl 0x10c08 | errno_location ();
0x00012bd8 ldr r5, [pc, 0x214] |
0x00012bdc mov r3, r8 | r3 = r8;
0x00012be0 ldr r2, [pc, 0x210] | r2 = stderr;
0x00012be4 ldr r1, [pc, 0x210] | r1 = "libubigen";
0x00012be8 ldr r4, [r0] | r4 = *(r0);
0x00012bec ldr r0, [r5] | r0 = "layout volume";
0x00012bf0 bl 0x10b48 | fprintf ("layout volume", "libubigen", r2, r3, r4, "layout volume")
0x00012bf4 mov r0, r4 | r0 = r4;
0x00012bf8 ldr r5, [r5] | r5 = "layout volume";
0x00012bfc bl 0x10aa0 | strerror (r0);
0x00012c00 str r4, [sp] | *(sp) = r4;
0x00012c04 ldr r3, [pc, 0x1f4] | r3 = "%s: error!: failed to allocate %d bytes\n";
0x00012c08 mov r2, 0xb | r2 = 0xb;
0x00012c0c ldr r1, [pc, 0x1f0] | r1 = *(0x12e00);
0x00012c10 str r0, [sp, 4] | var_4h = r0;
0x00012c14 mov r0, r5 | r0 = r5;
0x00012c18 bl 0x10b48 | fprintf (r0, r1, r2, "%s: error!: failed to allocate %d bytes\n", r4)
| do {
0x00012c1c mvn r0, 0 | r0 = ~0;
0x00012c20 b 0x12de4 | goto label_4;
| label_3:
0x00012c24 ldr r8, [r4, 0x10] | r8 = *((r4 + 0x10));
0x00012c28 mov r1, 0xff | r1 = 0xff;
0x00012c2c mov r2, r8 | r2 = r8;
0x00012c30 bl 0x10bb4 | memset (r0, r1, r2);
0x00012c34 ldr r2, [r4, 0x18] | r2 = *((r4 + 0x18));
0x00012c38 ldr r1, [sp, 0x80] | r1 = *(s2);
0x00012c3c add r0, r6, r8 | r0 = r6 + r8;
0x00012c40 ldr sl, [r4, 0xc] | sl = *((r4 + 0xc));
0x00012c44 bl 0x10adc | memcpy (r0, r1, r2);
0x00012c48 ldr r0, [r4, 0x10] | r0 = *((r4 + 0x10));
0x00012c4c ldr r2, [r4, 0x18] | r2 = *((r4 + 0x18));
0x00012c50 ldr r3, [r4, 4] | r3 = *((r4 + 4));
0x00012c54 mov r1, 0xff | r1 = 0xff;
0x00012c58 sub r3, r3, r0 | r3 -= r0;
0x00012c5c add r0, r0, r2 | r0 += r2;
0x00012c60 add r0, r6, r0 | r0 = r6 + r0;
0x00012c64 sub r2, r3, r2 | r2 = r3 - r2;
0x00012c68 bl 0x10bb4 | memset (r0, r1, r2);
0x00012c6c ldr r3, [r4, 4] | r3 = *((r4 + 4));
0x00012c70 ldr r0, [sp, 0x84] | r0 = *(fd);
0x00012c74 smull r8, sb, fp, r3 | r8:sb = fp * r3;
0x00012c78 str r5, [sp] | *(sp) = r5;
0x00012c7c mov r2, r8 | r2 = r8;
0x00012c80 mov r3, sb | r3 = sb;
0x00012c84 bl 0x10c2c | lseek64 ();
0x00012c88 add sl, r6, sl | sl = r6 + sl;
0x00012c8c cmp r1, sb |
0x00012c90 cmpeq r0, r8 | __asm ("cmpeq r0, r8");
| if (r1 == sb) {
0x00012c94 beq 0x12ce8 | goto label_5;
| }
| label_1:
0x00012c98 bl 0x10c08 | errno_location ();
0x00012c9c ldr r5, [pc, 0x150] | r5 = "layout volume";
0x00012ca0 ldr r2, [pc, 0x150] | r2 = stderr;
0x00012ca4 ldr r1, [pc, 0x15c] | r1 = "_serror__d___s_";
0x00012ca8 ldr r4, [r0] | r4 = *(r0);
0x00012cac ldr r0, [r5] | r0 = "layout volume";
0x00012cb0 bl 0x10b48 | fprintf ("layout volume", "_serror__d___s_", r2, r3, r4, "layout volume")
| label_0:
0x00012cb4 mov r0, r4 | r0 = r4;
0x00012cb8 ldr r5, [r5] | r5 = *(r5);
0x00012cbc bl 0x10aa0 | strerror (r0);
0x00012cc0 str r4, [sp] | *(sp) = r4;
0x00012cc4 ldr r3, [pc, 0x134] | r3 = "%s: error!: failed to allocate %d bytes\n";
0x00012cc8 mov r2, 0xb | r2 = 0xb;
0x00012ccc ldr r1, [pc, 0x130] | r1 = *(0x12e00);
0x00012cd0 str r0, [sp, 4] | var_4h = r0;
0x00012cd4 mov r0, r5 | r0 = r5;
0x00012cd8 bl 0x10b48 | fprintf (r0, r1, r2, "%s: error!: failed to allocate %d bytes\n", r4)
0x00012cdc mov r0, r6 | r0 = r6;
0x00012ce0 bl 0x10c74 | free (r0);
0x00012ce4 b 0x12c1c |
| } while (1);
| label_5:
0x00012ce8 ldrd r2, r3, [sp, 0x70] | __asm ("ldrd r2, r3, [arg_70h]");
0x00012cec mov r1, r6 | r1 = r6;
0x00012cf0 mov r0, r4 | r0 = r4;
0x00012cf4 bl 0x1240c | fcn_0001240c (r0, r1);
0x00012cf8 mov r3, r5 | r3 = r5;
0x00012cfc mov r2, sl | r2 = sl;
0x00012d00 add r1, sp, 0x10 | r1 += var_10h;
0x00012d04 mov r0, r4 | r0 = r4;
0x00012d08 str r5, [sp, 4] | var_4h = r5;
0x00012d0c str r5, [sp] | *(sp) = r5;
0x00012d10 bl 0x12664 | fcn_00012664 (r0, r1, r2, r3);
0x00012d14 ldr r2, [r4, 4] | r2 = *((r4 + 4));
0x00012d18 mov r1, r6 | r1 = r6;
0x00012d1c ldr r0, [sp, 0x84] | r0 = *(fd);
0x00012d20 bl 0x10b3c | write (r0, r1, r2);
0x00012d24 ldr fp, [r4, 4] | fp = *((r4 + 4));
0x00012d28 cmp fp, r0 |
| if (fp != r0) {
0x00012d2c beq 0x12d54 |
0x00012d30 bl 0x10c08 | errno_location ();
0x00012d34 ldr r5, [pc, 0xb8] | r5 = "layout volume";
0x00012d38 mov r3, fp | r3 = fp;
0x00012d3c ldr r4, [r0] | r4 = *(r0);
| label_2:
0x00012d40 ldr r2, [pc, 0xb0] | r2 = stderr;
0x00012d44 ldr r1, [pc, 0xc0] | r1 = "_s:_error_:_cannot_seek_output_file";
0x00012d48 ldr r0, [r5] | r0 = *(r5);
0x00012d4c bl 0x10b48 | fprintf (r0, "_s:_error_:_cannot_seek_output_file", r2, r3, r4, "layout volume")
0x00012d50 b 0x12cb4 | goto label_0;
| }
0x00012d54 ldr r3, [sp, 0xc] | r3 = var_ch;
0x00012d58 str r5, [sp] | *(sp) = r5;
0x00012d5c smull r8, sb, r3, fp | r8:sb = r3 * fp;
0x00012d60 ldr r0, [sp, 0x84] | r0 = *(fd);
0x00012d64 mov r2, r8 | r2 = r8;
0x00012d68 mov r3, sb | r3 = sb;
0x00012d6c bl 0x10c2c | lseek64 ();
0x00012d70 cmp r1, sb |
0x00012d74 cmpeq r0, r8 | __asm ("cmpeq r0, r8");
| if (r1 != sb) {
0x00012d78 bne 0x12c98 | goto label_1;
| }
0x00012d7c ldrd r2, r3, [sp, 0x78] | __asm ("ldrd r2, r3, [arg_78h]");
0x00012d80 mov r1, r6 | r1 = r6;
0x00012d84 mov r0, r4 | r0 = r4;
0x00012d88 bl 0x1240c | fcn_0001240c (r0, r1);
0x00012d8c mov r3, r7 | r3 = r7;
0x00012d90 mov r2, sl | r2 = sl;
0x00012d94 add r1, sp, 0x10 | r1 += var_10h;
0x00012d98 mov r0, r4 | r0 = r4;
0x00012d9c str r5, [sp, 4] | var_4h = r5;
0x00012da0 str r5, [sp] | *(sp) = r5;
0x00012da4 bl 0x12664 | fcn_00012664 (r0, r1, r2, r3);
0x00012da8 ldr r2, [r4, 4] | r2 = *((r4 + 4));
0x00012dac mov r1, r6 | r1 = r6;
0x00012db0 ldr r0, [sp, 0x84] | r0 = *(fd);
0x00012db4 bl 0x10b3c | write (r0, r1, r2);
0x00012db8 ldr r7, [r4, 4] | r7 = *((r4 + 4));
0x00012dbc cmp r7, r0 |
| if (r7 != r0) {
0x00012dc0 beq 0x12dd8 |
0x00012dc4 bl 0x10c08 | errno_location ();
0x00012dc8 ldr r5, [pc, 0x24] | r5 = "layout volume";
0x00012dcc mov r3, r7 | r3 = r7;
0x00012dd0 ldr r4, [r0] | r4 = *(r0);
0x00012dd4 b 0x12d40 | goto label_2;
| }
0x00012dd8 mov r0, r6 | r0 = r6;
0x00012ddc bl 0x10c74 | free (r0);
0x00012de0 mov r0, r5 | r0 = r5;
| label_4:
0x00012de4 add sp, sp, 0x4c |
0x00012de8 pop {r4, r5, r6, r7, r8, sb, sl, fp, pc} |
| }
; assembly | /* r2dec pseudo code output */
| /* /logs/firmware/unblob_extracted/firmware_extract/56048-12514271.gzip_extract/gzip.uncompressed_extract/5243916-15068666.gzip_extract/gzip.uncompressed_extract/usr/sbin/ubinize @ 0x12e10 */
| #include <stdint.h>
|
; (fcn) fcn.00012e10 () | void fcn_00012e10 (int32_t arg1) {
| char * * endptr;
| int32_t var_ch;
| r0 = arg1;
0x00012e10 push {r0, r1, r2, r4, r5, r6, r7, lr} |
0x00012e14 mov r2, 0 | r2 = 0;
0x00012e18 add r1, sp, 4 | r1 += endptr;
0x00012e1c mov r7, r0 | r7 = r0;
0x00012e20 bl 0x10b9c | strtoull (r0, r1, r2);
0x00012e24 ldr r6, [sp, 4] | r6 = endptr;
0x00012e28 sub r3, r6, r7 | r3 = r6 - r7;
0x00012e2c clz r3, r3 | r3 &= r3;
0x00012e30 lsr r3, r3, 5 | r3 >>= 5;
0x00012e34 orrs r3, r3, r1, lsr 31 | r3 |= (r1 >> 31);
| if (r3 == r3) {
0x00012e38 movne r2, r7 | r2 = r7;
| }
| if (r3 == r3) {
0x00012e3c ldrne r1, [pc, 0xc0] | r1 = "incorrect_amount_of_bytes:___s_";
| }
| if (r3 != r3) {
0x00012e40 bne 0x12eb8 | goto label_1;
| }
0x00012e44 ldrb r3, [r6] | r3 = *(r6);
0x00012e48 mov r4, r0 | r4 = r0;
0x00012e4c cmp r3, 0 |
0x00012e50 mov r5, r1 | r5 = r1;
| if (r3 == 0) {
0x00012e54 beq 0x12ecc | goto label_2;
| }
0x00012e58 mov r3, r6 | r3 = r6;
| do {
0x00012e5c mov r7, r3 | r7 = r3;
0x00012e60 ldrb r2, [r3], 1 | r2 = *(r3);
| r3++;
0x00012e64 cmp r2, 9 |
0x00012e68 cmpne r2, 0x20 | __asm ("cmpne r2, 0x20");
0x00012e6c beq 0x12e5c |
| } while (r2 == 9);
0x00012e70 ldr r1, [pc, 0x90] | r1 = "incorrect_amount_of_bytes:___s_";
0x00012e74 mov r0, r7 | r0 = r7;
0x00012e78 bl 0x10be4 | r0 = strcmp (r0, "incorrect_amount_of_bytes:___s_");
0x00012e7c cmp r0, 0 |
| if (r0 == 0) {
0x00012e80 beq 0x12edc | goto label_3;
| }
0x00012e84 ldr r1, [pc, 0x80] | r1 = "KiB";
0x00012e88 mov r0, r7 | r0 = r7;
0x00012e8c bl 0x10be4 | r0 = strcmp (r0, "KiB");
0x00012e90 cmp r0, 0 |
| if (r0 == 0) {
0x00012e94 beq 0x12efc | goto label_4;
| }
0x00012e98 ldr r1, [pc, 0x70] | r1 = "MiB";
0x00012e9c mov r0, r7 | r0 = r7;
0x00012ea0 bl 0x10be4 | r0 = strcmp (r0, "MiB");
0x00012ea4 cmp r0, 0 |
| if (r0 != 0) {
0x00012ea8 moveq r3, 0x40000000 | r3 = 0x40000000;
| }
| if (r0 == 0) {
0x00012eac beq 0x12ee0 | goto label_0;
| }
0x00012eb0 ldr r1, [pc, 0x5c] | r1 = "GiB";
0x00012eb4 mov r2, r6 | r2 = r6;
| label_1:
0x00012eb8 ldr r3, [pc, 0x58] | r3 = "bad size specifier: \"%s\" - should be 'KiB', 'MiB' or 'GiB'\n";
0x00012ebc mvn r4, 0 | r4 = ~0;
0x00012ec0 ldr r0, [r3] | r0 = "bad size specifier: \"%s\" - should be 'KiB', 'MiB' or 'GiB'\n";
0x00012ec4 bl 0x10b48 | fprintf ("bad size specifier: \"%s\" - should be 'KiB', 'MiB' or 'GiB'\n", "GiB", r2, "bad size specifier: \"%s\" - should be 'KiB', 'MiB' or 'GiB'\n", r4)
0x00012ec8 mvn r5, 0 | r5 = ~0;
| do {
| label_2:
0x00012ecc mov r0, r4 | r0 = r4;
0x00012ed0 mov r1, r5 | r1 = r5;
0x00012ed4 add sp, sp, 0xc |
0x00012ed8 pop {r4, r5, r6, r7, pc} |
| label_3:
0x00012edc mov r3, 0x400 | r3 = 0x400;
| label_0:
0x00012ee0 asr r1, r3, 0x1f | r1 = r3 >> 0x1f;
0x00012ee4 mul ip, r4, r1 |
0x00012ee8 mov r1, r4 | r1 = r4;
0x00012eec mla r2, r3, r5, ip | __asm ("mla r2, r3, r5, ip");
0x00012ef0 umull r4, r5, r1, r3 | r4:r5 = r1 * r3;
0x00012ef4 add r5, r2, r5 | r5 = r2 + r5;
0x00012ef8 b 0x12ecc |
| } while (1);
| label_4:
0x00012efc mov r3, 0x100000 | r3 = 0x100000;
0x00012f00 b 0x12ee0 | goto label_0;
| }
; assembly | /* r2dec pseudo code output */
| /* /logs/firmware/unblob_extracted/firmware_extract/56048-12514271.gzip_extract/gzip.uncompressed_extract/5243916-15068666.gzip_extract/gzip.uncompressed_extract/usr/sbin/ubinize @ 0x135b4 */
| #include <stdint.h>
|
; (fcn) fcn.000135b4 () | void fcn_000135b4 (FILE * stream, int32_t arg1) {
| char * src;
| char * var_400h;
| char * var_4h;
| char * var_800h;
| char * var_8h;
| int32_t var_810h;
| int32_t var_8h_2;
| char * var_c00h;
| char * var_ch;
| char * var_1000h;
| char * s1;
| char * s;
| char * dest;
| int32_t var_1800h;
| int32_t var_18h;
| int32_t var_1ch;
| r0 = arg1;
0x000135b4 push {r4, r5, r6, r7, r8, sb, sl, fp, lr} |
0x000135b8 ldr r1, [pc, 0x480] | r1 = *(0x13a3c);
0x000135bc sub sp, sp, 0x1800 |
0x000135c0 sub sp, sp, 0x1c |
0x000135c4 mov r8, r0 | r8 = r0;
0x000135c8 bl 0x10c80 | r0 = fopen64 ();
0x000135cc subs r6, r0, 0 | r6 = r0 - 0;
| if (r6 != r0) {
0x000135d0 bne 0x135fc | goto label_8;
| }
0x000135d4 ldr r3, [pc, 0x468] | r3 = *(0x13a40);
0x000135d8 mov r2, r8 | r2 = r8;
0x000135dc ldr r1, [pc, 0x464] | r1 = stderr;
0x000135e0 ldr r0, [r3] | r0 = *(0x13a40);
0x000135e4 bl 0x10b48 | fprintf (r0, r1, r2, r3)
| label_2:
0x000135e8 mov r5, 0 | r5 = 0;
| do {
0x000135ec mov r0, r5 | r0 = r5;
0x000135f0 add sp, sp, 0x1800 |
0x000135f4 add sp, sp, 0x1c |
0x000135f8 pop {r4, r5, r6, r7, r8, sb, sl, fp, pc} |
| label_8:
0x000135fc mov r0, 0 | r0 = 0;
0x00013600 bl 0x13b3c | r0 = fcn_00013b3c (r0);
0x00013604 subs r5, r0, 0 | r5 = r0 - 0;
| if (r5 != r0) {
0x00013608 bne 0x13618 | goto label_9;
| }
| label_0:
0x0001360c mov r0, r6 | r0 = r6;
0x00013610 bl 0x10bcc | fclose (r0);
0x00013614 b 0x135ec |
| } while (1);
| label_9:
0x00013618 mov r2, 0x400 | r2 = 0x400;
0x0001361c mov r1, 0 | r1 = 0;
0x00013620 mov r0, sp | r0 = sp;
0x00013624 bl 0x10bb4 | memset (r0, r1, r2);
0x00013628 add r0, sp, 0x400 | r0 += var_400h;
0x0001362c mov r2, 0x400 | r2 = 0x400;
0x00013630 mov r1, 0 | r1 = 0;
0x00013634 add r0, r0, 4 | r0 += var_4h;
0x00013638 bl 0x10bb4 | memset (r0, r1, r2);
0x0001363c add r0, sp, 0x800 | r0 += var_800h;
0x00013640 mov r2, 0x400 | r2 = 0x400;
0x00013644 mov r1, 0 | r1 = 0;
0x00013648 add r0, r0, 8 | r0 += var_8h;
0x0001364c bl 0x10bb4 | memset (r0, r1, r2);
0x00013650 ldr sl, [pc, 0x3f4] | sl = obj.__ctype_b;
0x00013654 add r0, sp, 0x1000 | r0 += var_1000h;
0x00013658 mov r4, 0 | r4 = 0;
0x0001365c mov r2, 0x400 | r2 = 0x400;
0x00013660 mov r1, 0 | r1 = 0;
0x00013664 add r0, r0, 0x10 | r0 += s1;
0x00013668 bl 0x10bb4 | memset (r0, r1, r2);
0x0001366c mov r7, r4 | r7 = r4;
0x00013670 mov r0, r4 | r0 = r4;
0x00013674 mov sb, r4 | sb = r4;
| label_1:
0x00013678 rsb r1, r0, 0x400 | r1 = 0x400 - r0;
0x0001367c mov r2, r6 | r2 = r6;
0x00013680 add r0, sp, r0 | r0 = sp + r0;
0x00013684 bl 0x10ad0 | r0 = fgets (r0, r1, r2);
0x00013688 cmp r0, 0 |
| if (r0 != 0) {
0x0001368c bne 0x1369c | goto label_10;
| }
0x00013690 cmp r4, 0 |
| if (r4 == 0) {
0x00013694 beq 0x1360c | goto label_0;
| }
0x00013698 b 0x13a28 | goto label_11;
| label_10:
0x0001369c mov r0, sp | r0 = sp;
0x000136a0 bl 0x10c20 | strlen (r0);
0x000136a4 add r3, sp, 0x810 | r3 += var_810h;
0x000136a8 add r3, r3, 8 | r3 += var_8h_2;
0x000136ac add r7, r7, 1 | r7++;
0x000136b0 sub r0, r0, 1 | r0--;
0x000136b4 add r3, r3, r0 | r3 += r0;
0x000136b8 ldrb r3, [r3, -0x818] | r3 = *((r3 - 0x818));
0x000136bc cmp r3, 0xa |
| if (r3 != 0xa) {
0x000136c0 bne 0x137d0 | goto label_12;
| }
0x000136c4 ldr r2, [sl] | r2 = *(sl);
| label_3:
0x000136c8 cmn r0, 1 |
| if (r0 != 1) {
0x000136cc beq 0x136ec |
0x000136d0 ldrb r3, [sp, r0] | r3 = *((sp + r0));
0x000136d4 cmp r3, 0xa |
| if (r3 == 0xa) {
0x000136d8 beq 0x137fc | goto label_13;
| }
0x000136dc lsl r3, r3, 1 | r3 <<= 1;
0x000136e0 ldrh r3, [r2, r3] | r3 = *((r2 + r3));
0x000136e4 tst r3, 0x20 |
| if ((r3 & 0x20) != 0) {
0x000136e8 bne 0x137fc | goto label_13;
| }
| }
0x000136ec add r3, sp, 0x810 | r3 += var_810h;
0x000136f0 add r3, r3, 8 | r3 += var_8h_2;
0x000136f4 add r3, r3, r0 | r3 += r0;
0x000136f8 ldrb r3, [r3, -0x818] | r3 = *((r3 - 0x818));
0x000136fc cmp r3, 0x5c |
| if (r3 == 0x5c) {
0x00013700 beq 0x13678 | goto label_1;
| }
0x00013704 mov r0, sp | r0 = sp;
0x00013708 bl 0x13160 | r0 = fcn_00013160 (r0);
0x0001370c mov r1, r0 | r1 = r0;
0x00013710 add r0, sp, 0x1400 | r0 += s;
0x00013714 add r0, r0, 0x14 | r0 += dest;
0x00013718 bl 0x10a88 | strcpy (r0, r1);
0x0001371c add r0, sp, 0x1400 | r0 += s;
0x00013720 add r0, r0, 0x14 | r0 += dest;
0x00013724 bl 0x10c20 | r0 = strlen (r0);
0x00013728 cmp r0, 0 |
| if (r0 == 0) {
0x0001372c beq 0x13a00 | goto label_14;
| }
0x00013730 add r3, sp, 0x1400 | r3 += s;
0x00013734 add r3, r3, 0x14 | r3 += dest;
0x00013738 ldrb r3, [r3] | r3 = *(r3);
0x0001373c cmp r3, 0x23 |
| if (r3 == 0x23) {
0x00013740 beq 0x13a00 | goto label_14;
| }
0x00013744 cmp r3, 0x5b |
| if (r3 == 0x5b) {
0x00013748 bne 0x13808 |
0x0001374c add r3, sp, 0x1800 | r3 += var_1800h;
0x00013750 add r3, r3, 0x18 | r3 += var_18h;
0x00013754 add r0, r3, r0 | r0 = r3 + r0;
0x00013758 ldrb r3, [r0, -0x405] | r3 = *((r0 - 0x405));
0x0001375c cmp r3, 0x5d |
| if (r3 != 0x5d) {
0x00013760 bne 0x13808 | goto label_15;
| }
0x00013764 add r2, sp, 0x400 | r2 += var_400h;
0x00013768 add r0, sp, 0x1400 | r0 += s;
0x0001376c add r2, r2, 4 | r2 += var_4h;
0x00013770 ldr r1, [pc, 0x2d8] | r1 = __ctype_b;
0x00013774 add r0, r0, 0x14 | r0 += dest;
0x00013778 bl 0x10b84 | sscanf (r0, r1, r2);
0x0001377c add r0, sp, 0x400 | r0 += var_400h;
0x00013780 add r0, r0, 4 | r0 += var_4h;
0x00013784 bl 0x13160 | r0 = fcn_00013160 (r0);
0x00013788 mov r1, r0 | r1 = r0;
0x0001378c add r0, sp, 0x400 | r0 += var_400h;
0x00013790 add r0, r0, 4 | r0 += var_4h;
0x00013794 bl 0x10a88 | strcpy (r0, r1);
0x00013798 add r0, sp, 0x400 | r0 += var_400h;
0x0001379c add r0, r0, 4 | r0 += var_4h;
0x000137a0 bl 0x130fc | r0 = fcn_000130fc (r0);
0x000137a4 mov r1, r0 | r1 = r0;
0x000137a8 add r0, sp, 0x400 | r0 += var_400h;
0x000137ac add r0, r0, 4 | r0 += var_4h;
0x000137b0 bl 0x10a88 | strcpy (r0, r1);
0x000137b4 add r1, sp, 0x400 | r1 += var_400h;
0x000137b8 mov r2, 0 | r2 = 0;
0x000137bc add r1, r1, 4 | r1 += var_4h;
| label_6:
0x000137c0 mov r0, r5 | r0 = r5;
0x000137c4 bl 0x13c88 | r0 = fcn_00013c88 (r0, r1);
0x000137c8 mov r4, r0 | r4 = r0;
0x000137cc b 0x13a00 | goto label_14;
| label_12:
0x000137d0 ldr r0, [pc, 0x26c] |
0x000137d4 mov r3, r7 | r3 = r7;
0x000137d8 mov r2, r8 | r2 = r8;
0x000137dc ldr r1, [pc, 0x270] | r1 = "[%[^]]";
0x000137e0 ldr r0, [r0] | r0 = *(0x13a40);
0x000137e4 bl 0x10b48 | fprintf (r0, "[%[^]]", r2, r3)
0x000137e8 mov r0, r5 | r0 = r5;
0x000137ec bl 0x13b9c | fcn_00013b9c (r0);
0x000137f0 mov r0, r6 | r0 = r6;
0x000137f4 bl 0x10bcc | fclose (r0);
0x000137f8 b 0x135e8 | goto label_2;
| label_13:
0x000137fc strb sb, [sp, r0] | *((sp + r0)) = sb;
0x00013800 sub r0, r0, 1 | r0--;
0x00013804 b 0x136c8 | goto label_3;
| }
| label_15:
0x00013808 add r3, sp, 0x1000 | r3 += var_1000h;
0x0001380c add r2, sp, 0x800 | r2 += var_800h;
0x00013810 add r0, sp, 0x1400 | r0 += s;
0x00013814 add r3, r3, 0x10 | r3 += s1;
0x00013818 add r2, r2, 8 | r2 += var_8h;
0x0001381c ldr r1, [pc, 0x234] | r1 = "iniparser:_input_line_too_long_in__s___d_";
0x00013820 add r0, r0, 0x14 | r0 += dest;
0x00013824 bl 0x10b84 | r0 = sscanf (r0, "iniparser:_input_line_too_long_in__s___d_", r2);
0x00013828 cmp r0, 2 |
0x0001382c bne 0x138ac |
| while (r0 == 2) {
| label_4:
0x00013830 add r0, sp, 0x800 | r0 += var_800h;
0x00013834 add r0, r0, 8 | r0 += var_8h;
0x00013838 bl 0x13160 | r0 = fcn_00013160 (r0);
0x0001383c mov r1, r0 | r1 = r0;
0x00013840 add r0, sp, 0x800 | r0 += var_800h;
0x00013844 add r0, r0, 8 | r0 += var_8h;
0x00013848 bl 0x10a88 | strcpy (r0, r1);
0x0001384c add r0, sp, 0x800 | r0 += var_800h;
0x00013850 add r0, r0, 8 | r0 += var_8h;
0x00013854 bl 0x130fc | r0 = fcn_000130fc (r0);
0x00013858 mov r1, r0 | r1 = r0;
0x0001385c add r0, sp, 0x800 | r0 += var_800h;
0x00013860 add r0, r0, 8 | r0 += var_8h;
0x00013864 bl 0x10a88 | strcpy (r0, r1);
0x00013868 add r0, sp, 0x1000 | r0 += var_1000h;
0x0001386c add r0, r0, 0x10 | r0 += s1;
0x00013870 bl 0x13160 | r0 = fcn_00013160 (r0);
0x00013874 mov r1, r0 | r1 = r0;
0x00013878 add r0, sp, 0x1000 | r0 += var_1000h;
0x0001387c add r0, r0, 0x10 | r0 += s1;
0x00013880 bl 0x10a88 | strcpy (r0, r1);
0x00013884 add r0, sp, 0x1000 | r0 += var_1000h;
0x00013888 ldr r1, [pc, 0x1cc] | r1 = "___________";
0x0001388c add r0, r0, 0x10 | r0 += s1;
0x00013890 bl 0x10be4 | r0 = strcmp (r0, "___________");
0x00013894 cmp r0, 0 |
| if (r0 != 0) {
0x00013898 bne 0x13960 | goto label_16;
| }
| label_5:
0x0001389c add r3, sp, 0x1000 | r3 += var_1000h;
0x000138a0 add r3, r3, 0x10 | r3 += s1;
0x000138a4 strb sb, [r3] | *(r3) = sb;
0x000138a8 b 0x13978 | goto label_17;
0x000138ac add r3, sp, 0x1000 | r3 += var_1000h;
0x000138b0 add r2, sp, 0x800 | r2 += var_800h;
0x000138b4 add r0, sp, 0x1400 | r0 += s;
0x000138b8 add r3, r3, 0x10 | r3 += s1;
0x000138bc add r2, r2, 8 | r2 += var_8h;
0x000138c0 ldr r1, [pc, 0x198] | r1 = "__";
0x000138c4 add r0, r0, 0x14 | r0 += dest;
0x000138c8 bl 0x10b84 | r0 = sscanf (r0, "__", r2);
0x000138cc cmp r0, 2 |
0x000138d0 beq 0x13830 |
| }
0x000138d4 add r3, sp, 0x1000 | r3 += var_1000h;
0x000138d8 add r2, sp, 0x800 | r2 += var_800h;
0x000138dc add r0, sp, 0x1400 | r0 += s;
0x000138e0 add r3, r3, 0x10 | r3 += s1;
0x000138e4 add r2, r2, 8 | r2 += var_8h;
0x000138e8 ldr r1, [pc, 0x174] | r1 = "%[^=] = '%[^']';
0x000138ec add r0, r0, 0x14 | r0 += dest;
0x000138f0 bl 0x10b84 | r0 = sscanf (r0, "%[^=] = '%[^']', r2);
0x000138f4 cmp r0, 2 |
| if (r0 == 2) {
0x000138f8 beq 0x13830 | goto label_4;
| }
0x000138fc add r3, sp, 0x1000 | r3 += var_1000h;
0x00013900 add r2, sp, 0x800 | r2 += var_800h;
0x00013904 add r0, sp, 0x1400 | r0 += s;
0x00013908 add r3, r3, 0x10 | r3 += s1;
0x0001390c add r2, r2, 8 | r2 += var_8h;
0x00013910 ldr r1, [pc, 0x150] | r1 = "%[^=] = %[^;#]";
0x00013914 add r0, r0, 0x14 | r0 += dest;
0x00013918 bl 0x10b84 | r0 = sscanf (r0, "%[^=] = %[^;#]", r2);
0x0001391c cmp r0, 2 |
| if (r0 != 2) {
0x00013920 bne 0x139ac | goto label_18;
| }
| label_7:
0x00013924 add r0, sp, 0x800 | r0 += var_800h;
0x00013928 add r0, r0, 8 | r0 += var_8h;
0x0001392c bl 0x13160 | r0 = fcn_00013160 (r0);
0x00013930 mov r1, r0 | r1 = r0;
0x00013934 add r0, sp, 0x800 | r0 += var_800h;
0x00013938 add r0, r0, 8 | r0 += var_8h;
0x0001393c bl 0x10a88 | strcpy (r0, r1);
0x00013940 add r0, sp, 0x800 | r0 += var_800h;
0x00013944 add r0, r0, 8 | r0 += var_8h;
0x00013948 bl 0x130fc | r0 = fcn_000130fc (r0);
0x0001394c mov r1, r0 | r1 = r0;
0x00013950 add r0, sp, 0x800 | r0 += var_800h;
0x00013954 add r0, r0, 8 | r0 += var_8h;
0x00013958 bl 0x10a88 | strcpy (r0, r1);
0x0001395c b 0x1389c | goto label_5;
| label_16:
0x00013960 add r0, sp, 0x1000 | r0 += var_1000h;
0x00013964 ldr r1, [pc, 0x100] | r1 = "%[^=] = %[;#]";
0x00013968 add r0, r0, 0x10 | r0 += s1;
0x0001396c bl 0x10be4 | r0 = strcmp (r0, "%[^=] = %[;#]");
0x00013970 cmp r0, 0 |
| if (r0 == 0) {
0x00013974 beq 0x1389c | goto label_5;
| }
| label_17:
0x00013978 add r3, sp, 0x800 | r3 += var_800h;
0x0001397c add r2, sp, 0x400 | r2 += var_400h;
0x00013980 add r0, sp, 0xc00 | r0 += var_c00h;
0x00013984 add r2, r2, 4 | r2 += var_4h;
0x00013988 ldr r1, [pc, 0xe0] | r1 = "_";
0x0001398c add r3, r3, 8 | r3 += var_8h;
0x00013990 add r0, r0, 0xc | r0 += var_ch;
0x00013994 bl 0x10bf0 | sprintf (r0, "_", r2);
0x00013998 add r2, sp, 0x1000 | r2 += var_1000h;
0x0001399c add r1, sp, 0xc00 | r1 += var_c00h;
0x000139a0 add r2, r2, 0x10 | r2 += s1;
0x000139a4 add r1, r1, 0xc | r1 += var_ch;
0x000139a8 b 0x137c0 | goto label_6;
| label_18:
0x000139ac add r3, sp, 0x1000 | r3 += var_1000h;
0x000139b0 add r2, sp, 0x800 | r2 += var_800h;
0x000139b4 add r0, sp, 0x1400 | r0 += s;
0x000139b8 add r3, r3, 0x10 | r3 += s1;
0x000139bc add r2, r2, 8 | r2 += var_8h;
0x000139c0 ldr r1, [pc, 0xac] | r1 = "_s:_s";
0x000139c4 add r0, r0, 0x14 | r0 += dest;
0x000139c8 bl 0x10b84 | r0 = sscanf (r0, "_s:_s", r2);
0x000139cc cmp r0, 2 |
| if (r0 == 2) {
0x000139d0 beq 0x13924 | goto label_7;
| }
0x000139d4 ldr fp, [pc, 0x68] | fp = obj.stderr;
0x000139d8 mov r3, r7 | r3 = r7;
0x000139dc mov r2, r8 | r2 = r8;
0x000139e0 ldr r1, [pc, 0x90] | r1 = "%[^=] %[=]";
0x000139e4 ldr r0, [fp] | r0 = *(fp);
0x000139e8 bl 0x10b48 | fprintf (r0, "%[^=] %[=]", r2, r3)
0x000139ec mov r2, sp | r2 = sp;
0x000139f0 ldr r1, [pc, 0x84] | r1 = "iniparser:_syntax_error_in__s___d_:";
0x000139f4 ldr r0, [fp] | r0 = *(fp);
0x000139f8 bl 0x10b48 | fprintf (r0, "iniparser:_syntax_error_in__s___d_:", r2)
0x000139fc add r4, r4, 1 | r4++;
| label_14:
0x00013a00 mov r2, 0x400 | r2 = 0x400;
0x00013a04 mov r1, 0 | r1 = 0;
0x00013a08 mov r0, sp | r0 = sp;
0x00013a0c bl 0x10bb4 | memset (r0, r1, r2);
0x00013a10 cmp r4, 0 |
| if (r4 < 0) {
0x00013a14 bge 0x13a38 |
0x00013a18 ldr r3, [pc, 0x24] | r3 = *(0x13a40);
0x00013a1c ldr r0, [pc, 0x5c] | r0 = "-> %s\n";
0x00013a20 ldr r1, [r3] | r1 = *(0x13a40);
0x00013a24 bl 0x10c44 | fputs ("-> %s\n", r1);
| label_11:
0x00013a28 mov r0, r5 | r0 = r5;
0x00013a2c bl 0x13b9c | fcn_00013b9c (r0);
0x00013a30 mov r5, 0 | r5 = 0;
0x00013a34 b 0x1360c | goto label_0;
| }
0x00013a38 mov r0, 0 | r0 = 0;
0x00013a3c b 0x13678 | goto label_1;
| }
; assembly | /* r2dec pseudo code output */
| /* /logs/firmware/unblob_extracted/firmware_extract/56048-12514271.gzip_extract/gzip.uncompressed_extract/5243916-15068666.gzip_extract/gzip.uncompressed_extract/usr/sbin/ubinize @ 0x10c90 */
| #include <stdint.h>
|
; (fcn) main () | int32_t main (char ** envp, int32_t argc, char ** argv) {
| int32_t var_0h;
| int32_t var_4h;
| int32_t var_8h;
| int32_t var_8h_2;
| int32_t var_10h;
| int32_t var_14h;
| size_t size;
| int32_t var_20h;
| int32_t var_24h;
| void * var_28h;
| void * ptr;
| int32_t var_30h;
| int32_t var_34h;
| int32_t var_3ch;
| int32_t var_40h;
| int32_t var_44h;
| int32_t var_48h;
| int32_t var_4ch;
| int32_t var_58h;
| int32_t var_5ch;
| int32_t var_60h;
| int32_t var_90h;
| int32_t var_90h_2;
| int32_t var_c8h;
| int32_t var_f8h;
| int32_t var_f8h_2;
| char * s;
| int32_t var_234h;
| r0 = argc;
| r1 = argv;
| /* [10] -r-x section size 14128 named .text */
0x00010c90 push {r4, r5, r6, r7, r8, sb, sl, fp, lr} |
0x00010c94 ldr r8, [pc, 0xf28] | r8 = *(0x11bc0);
0x00010c98 sub sp, sp, 0x234 |
0x00010c9c mov r6, r1 | r6 = r1;
0x00010ca0 mov r5, r0 | r5 = r0;
0x00010ca4 bl 0x13088 | fcn_00013088 ();
0x00010ca8 bl 0x10b60 | rand ();
0x00010cac ldr sb, [pc, 0xf14] | sb = "output";
0x00010cb0 ldr sl, [pc, 0xf14] | sl = "o:p:m:s:O:e:x:Q:vhV";
0x00010cb4 ldr r4, [pc, 0xf14] | r4 = "o:p:m:s:O:e:x:Q:vhV";
0x00010cb8 str r0, [r8, 0x24] | *((r8 + 0x24)) = r0;
| label_1:
0x00010cbc mov fp, 0 |
0x00010cc0 str fp, [sp] | *(sp) = fp;
0x00010cc4 mov r3, sb | r3 = sb;
0x00010cc8 mov r2, sl | r2 = sl;
0x00010ccc mov r1, r6 | r1 = r6;
0x00010cd0 mov r0, r5 | r0 = r5;
0x00010cd4 str fp, [sp, 0x130] | s = fp;
0x00010cd8 bl 0x10ab8 | r0 = getopt_long ();
0x00010cdc cmn r0, 1 |
0x00010ce0 mov r7, r0 | r7 = r0;
| if (r0 == 1) {
0x00010ce4 beq 0x10fec | goto label_20;
| }
0x00010ce8 cmp r0, 0x6d |
| if (r0 == 0x6d) {
0x00010cec beq 0x10e84 | goto label_21;
| }
| if (r0 > 0x6d) {
0x00010cf0 bgt 0x10d70 | goto label_22;
| }
0x00010cf4 cmp r0, 0x56 |
| if (r0 == 0x56) {
0x00010cf8 beq 0x10fd8 | goto label_23;
| }
| if (r0 > 0x56) {
0x00010cfc bgt 0x10d30 | goto label_24;
| }
0x00010d00 cmp r0, 0x4f |
| if (r0 == 0x4f) {
0x00010d04 beq 0x10f30 | goto label_25;
| }
0x00010d08 cmp r0, 0x51 |
| if (r0 == 0x51) {
0x00010d0c beq 0x10fa0 | goto label_26;
| }
| do {
| label_0:
0x00010d10 ldr r4, [pc, 0xebc] | r4 = optarg;
0x00010d14 ldr r0, [pc, 0xebc] | r0 = stderr;
0x00010d18 ldr r1, [r4] | r1 = optarg;
0x00010d1c bl 0x10c44 | fputs (r0, r1);
0x00010d20 ldr r1, [r4] | r1 = optarg;
0x00010d24 ldr r0, [pc, 0xeb0] | r0 = "Usage:_ubinize__options___ini_file_Generate_UBI_images._An_UBI_image_may_contain_one_or_more_UBI_volumes_whichhave_to_be_defined_in_the_input_configuration_ini_file._The_flashcharacteristics_are_defined_via_the_command_line_options.";
0x00010d28 bl 0x10c44 | fputs ("Usage:_ubinize__options___ini_file_Generate_UBI_images._An_UBI_image_may_contain_one_or_more_UBI_volumes_whichhave_to_be_defined_in_the_input_configuration_ini_file._The_flashcharacteristics_are_defined_via_the_command_line_options.", r1);
0x00010d2c b 0x10e68 | goto label_3;
| label_24:
0x00010d30 cmp r0, 0x65 |
| if (r0 == 0x65) {
0x00010d34 beq 0x10f68 | goto label_27;
| }
0x00010d38 cmp r0, 0x68 |
0x00010d3c bne 0x10d10 |
| } while (r0 != 0x68);
0x00010d40 ldr r4, [pc, 0xe98] | r4 = "Use -h for help\n\n";
0x00010d44 ldr r0, [pc, 0xe8c] | r0 = stderr;
0x00010d48 ldr r1, [r4] | r1 = "Use -h for help\n\n";
0x00010d4c bl 0x10c44 | fputs (r0, "Use -h for help\n\n");
0x00010d50 ldr r1, [r4] | r1 = "Use -h for help\n\n";
0x00010d54 ldr r0, [pc, 0xe88] | r0 = stdout;
0x00010d58 bl 0x10c44 | fputs (r0, "Use -h for help\n\n");
0x00010d5c ldr r1, [pc, 0xe84] | r1 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x00010d60 ldr r0, [pc, 0xe84] | r0 = "ubinize";
0x00010d64 bl 0x10a94 | printf ("ubinize", "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n");
| label_5:
0x00010d68 mov r0, fp | r0 = fp;
0x00010d6c bl 0x10c14 | r0 = exit (r0);
| label_22:
0x00010d70 cmp r0, 0x73 |
| if (r0 == 0x73) {
0x00010d74 beq 0x10ee0 | goto label_28;
| }
| if (r0 > 0x73) {
0x00010d78 bgt 0x10dbc | goto label_29;
| }
0x00010d7c cmp r0, 0x6f |
| if (r0 == 0x6f) {
0x00010d80 beq 0x10e04 | goto label_30;
| }
0x00010d84 cmp r0, 0x70 |
| if (r0 != 0x70) {
0x00010d88 bne 0x10d10 | goto label_0;
| }
0x00010d8c ldr r0, [r4] | r0 = *(r4);
0x00010d90 bl 0x12e10 | r0 = fcn_00012e10 (r0);
0x00010d94 cmp r0, 0 |
0x00010d98 str r0, [r8, 0xc] | *((r8 + 0xc)) = r0;
| if (r0 > 0) {
0x00010d9c bgt 0x10cbc | goto label_1;
| }
0x00010da0 ldr r3, [r4] | r3 = *(r4);
0x00010da4 ldr r2, [pc, 0xe3c] | r2 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x00010da8 ldr r1, [pc, 0xe40] | r1 = "For_more_information_see__man_8__s_";
| label_2:
0x00010dac ldr r0, [pc, 0xe20] |
0x00010db0 ldr r0, [r0] | r0 = optarg;
0x00010db4 bl 0x10b48 | fprintf (r0, "For_more_information_see__man_8__s_", "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n", r3)
0x00010db8 b 0x10e68 | goto label_3;
| label_29:
0x00010dbc cmp r0, 0x76 |
| if (r0 == 0x76) {
0x00010dc0 beq 0x10fcc | goto label_31;
| }
0x00010dc4 cmp r0, 0x78 |
| if (r0 != 0x78) {
0x00010dc8 bne 0x10d10 | goto label_0;
| }
0x00010dcc add r1, sp, 0x130 | r1 += s;
0x00010dd0 ldr r0, [r4] | r0 = *(r4);
0x00010dd4 bl 0x12008 | fcn_00012008 (r0, r1);
0x00010dd8 ldr r3, [sp, 0x130] | r3 = s;
0x00010ddc cmp r3, 0 |
0x00010de0 str r0, [r8, 0x20] | *((r8 + 0x20)) = r0;
| if (r3 != 0) {
0x00010de4 lsreq r0, r0, 0x1f | r0 >>= 0x1f;
| }
| if (r3 == 0) {
0x00010de8 movne r0, 1 | r0 = 1;
| }
0x00010dec cmp r0, 0 |
| if (r0 == 0) {
0x00010df0 beq 0x10cbc | goto label_1;
| }
0x00010df4 ldr r3, [r4] | r3 = *(r4);
0x00010df8 ldr r2, [pc, 0xde8] | r2 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x00010dfc ldr r1, [pc, 0xdf0] | r1 = "_s:_error_:_bad_physical_eraseblock_size:___s_";
0x00010e00 b 0x10dac | goto label_2;
| label_30:
0x00010e04 mov r2, 0x1b4 | r2 = 0x1b4;
0x00010e08 ldr r1, [pc, 0xde8] | r1 = "_s:_error_:_bad_UBI_version:___s_";
0x00010e0c ldr r0, [r4] | r0 = *(r4);
0x00010e10 bl 0x10bd8 | r0 = open64 ();
0x00010e14 cmn r0, 1 |
0x00010e18 str r0, [r8, 8] | *((r8 + 8)) = r0;
| if (r0 == 1) {
0x00010e1c bne 0x10e78 |
0x00010e20 bl 0x10c08 | errno_location ();
0x00010e24 ldr r6, [pc, 0xda8] | r6 = optarg;
0x00010e28 ldr r3, [r4] | r3 = *(r4);
0x00010e2c ldr r2, [pc, 0xdb4] | r2 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x00010e30 ldr r1, [pc, 0xdc4] | r1 = *(0x11bf8);
0x00010e34 ldr r5, [r0] | r5 = *(r0);
0x00010e38 ldr r0, [r6] | r0 = optarg;
0x00010e3c bl 0x10b48 | fprintf (r0, r1, "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n", r3, r4, r5, r6)
0x00010e40 mov r0, r5 | r0 = r5;
0x00010e44 ldr r4, [r6] | r4 = optarg;
0x00010e48 bl 0x10aa0 | strerror (r0);
0x00010e4c str r5, [sp] | *(sp) = r5;
0x00010e50 ldr r3, [pc, 0xf14] | r3 = "%s: error!: cannot open \"%s\"\n";
0x00010e54 mov r2, 9 | r2 = 9;
0x00010e58 ldr r1, [pc, 0xf10] | r1 = *(0x11d6c);
0x00010e5c str r0, [sp, 4] | var_4h = r0;
0x00010e60 mov r0, r4 | r0 = r4;
0x00010e64 bl 0x10b48 | fprintf (r0, r1, r2, "%s: error!: cannot open \"%s\"\n", r4, r5)
| label_3:
0x00010e68 mvn r7, 0 | r7 = ~0;
| label_6:
0x00010e6c mov r0, r7 | r0 = r7;
0x00010e70 add sp, sp, 0x234 |
0x00010e74 pop {r4, r5, r6, r7, r8, sb, sl, fp, pc} |
| }
0x00010e78 ldr r3, [r4] | r3 = *(r4);
0x00010e7c str r3, [r8, 4] | *((r8 + 4)) = r3;
0x00010e80 b 0x10cbc | goto label_1;
| label_21:
0x00010e84 ldr r0, [r4] | r0 = *(r4);
0x00010e88 bl 0x12e10 | r0 = fcn_00012e10 (r0);
0x00010e8c cmp r0, 0 |
0x00010e90 str r0, [r8, 0x10] | *((r8 + 0x10)) = r0;
| if (r0 > 0) {
0x00010e94 ldrle r3, [r4] | r3 = *(r4);
| }
| if (r0 > 0) {
0x00010e98 ldrle r2, [pc, 0xd48] | r2 = "ubinize";
| }
| if (r0 <= 0) {
0x00010e9c ldrle r1, [pc, 0xd5c] | r1 = "_s:_error_:_bad_min._I_O_unit_size:___s_";
| goto label_32;
| }
| if (r0 <= 0) {
| label_32:
0x00010ea0 ble 0x10dac | goto label_2;
| }
0x00010ea4 mov r2, r0 | r2 = r0;
0x00010ea8 asr r3, r0, 0x1f | r3 = r0 >> 0x1f;
0x00010eac subs r2, r2, 1 | r2--;
0x00010eb0 mov r1, r3 | r1 = r3;
0x00010eb4 sbc r3, r3, 0 | __asm ("sbc r3, r3, 0");
0x00010eb8 and r0, r0, r2 | r0 &= r2;
0x00010ebc and r1, r1, r3 | r1 &= r3;
0x00010ec0 orrs r3, r0, r1 | r3 = r0 | r1;
| if (r3 == r0) {
0x00010ec4 beq 0x10cbc | goto label_1;
| }
0x00010ec8 ldr r2, [pc, 0xd18] | r2 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x00010ecc ldr r1, [pc, 0xd30] | r1 = "_s:_error_:_bad_min._I_O_unit_size:___s_";
| label_4:
0x00010ed0 ldr r3, [pc, 0xcfc] | r3 = optarg;
0x00010ed4 ldr r0, [r3] | r0 = optarg;
0x00010ed8 bl 0x10b48 | fprintf (r0, "_s:_error_:_bad_min._I_O_unit_size:___s_", "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n", r3)
0x00010edc b 0x10e68 | goto label_3;
| label_28:
0x00010ee0 ldr r0, [r4] | r0 = *(r4);
0x00010ee4 bl 0x12e10 | r0 = fcn_00012e10 (r0);
0x00010ee8 cmp r0, 0 |
0x00010eec str r0, [r8, 0x14] | *((r8 + 0x14)) = r0;
| if (r0 > 0) {
0x00010ef0 ldrle r3, [r4] | r3 = *(r4);
| }
| if (r0 > 0) {
0x00010ef4 ldrle r2, [pc, 0xcec] | r2 = "ubinize";
| }
| if (r0 <= 0) {
0x00010ef8 ldrle r1, [pc, 0xd08] | r1 = "%s: error!: bad sub-page size: \"%s\"\n";
| goto label_33;
| }
| if (r0 <= 0) {
| label_33:
0x00010efc ble 0x10dac | goto label_2;
| }
0x00010f00 mov r2, r0 | r2 = r0;
0x00010f04 asr r3, r0, 0x1f | r3 = r0 >> 0x1f;
0x00010f08 subs r2, r2, 1 | r2--;
0x00010f0c mov r1, r3 | r1 = r3;
0x00010f10 sbc r3, r3, 0 | __asm ("sbc r3, r3, 0");
0x00010f14 and r0, r0, r2 | r0 &= r2;
0x00010f18 and r1, r1, r3 | r1 &= r3;
0x00010f1c orrs r3, r0, r1 | r3 = r0 | r1;
| if (r3 == r0) {
0x00010f20 beq 0x10cbc | goto label_1;
| }
0x00010f24 ldr r2, [pc, 0xcbc] | r2 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x00010f28 ldr r1, [pc, 0xcdc] | r1 = "%s: error!: bad sub-page size: \"%s\"\n";
0x00010f2c b 0x10ed0 | goto label_4;
| label_25:
0x00010f30 add r1, sp, 0x130 | r1 += s;
0x00010f34 ldr r0, [r4] | r0 = *(r4);
0x00010f38 bl 0x12008 | fcn_00012008 (r0, r1);
0x00010f3c ldr r3, [sp, 0x130] | r3 = s;
0x00010f40 cmp r3, 0 |
0x00010f44 str r0, [r8, 0x18] | *((r8 + 0x18)) = r0;
| if (r3 != 0) {
0x00010f48 lsreq r0, r0, 0x1f | r0 >>= 0x1f;
| }
| if (r3 == 0) {
0x00010f4c movne r0, 1 | r0 = 1;
| }
0x00010f50 cmp r0, 0 |
| if (r0 == 0) {
0x00010f54 beq 0x10cbc | goto label_1;
| }
0x00010f58 ldr r3, [r4] | r3 = *(r4);
0x00010f5c ldr r2, [pc, 0xc84] | r2 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x00010f60 ldr r1, [pc, 0xca8] | r1 = "_s:_error_:_sub_page_size_should_be_power_of_2";
0x00010f64 b 0x10dac | goto label_2;
| label_27:
0x00010f68 add r1, sp, 0x130 | r1 += s;
0x00010f6c ldr r0, [r4] | r0 = *(r4);
0x00010f70 bl 0x12008 | fcn_00012008 (r0, r1);
0x00010f74 ldr r3, [sp, 0x130] | r3 = s;
0x00010f78 cmp r3, 0 |
0x00010f7c str r0, [r8, 0x1c] | *((r8 + 0x1c)) = r0;
| if (r3 != 0) {
0x00010f80 lsreq r0, r0, 0x1f | r0 >>= 0x1f;
| }
| if (r3 == 0) {
0x00010f84 movne r0, 1 | r0 = 1;
| }
0x00010f88 cmp r0, 0 |
| if (r0 == 0) {
0x00010f8c beq 0x10cbc | goto label_1;
| }
0x00010f90 ldr r3, [r4] | r3 = *(r4);
0x00010f94 ldr r2, [pc, 0xc4c] | r2 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x00010f98 ldr r1, [pc, 0xc74] | r1 = "_s:_error_:_bad_VID_header_offset:___s_";
0x00010f9c b 0x10dac | goto label_2;
| label_26:
0x00010fa0 add r1, sp, 0x130 | r1 += s;
0x00010fa4 ldr r0, [r4] | r0 = *(r4);
0x00010fa8 bl 0x12008 | fcn_00012008 (r0, r1);
0x00010fac ldr r3, [sp, 0x130] | r3 = s;
0x00010fb0 cmp r3, 0 |
| if (r3 == 0) {
0x00010fb4 ldrne r3, [r4] | r3 = *(r4);
| }
| if (r3 == 0) {
0x00010fb8 ldrne r2, [pc, 0xc28] | r2 = "ubinize";
| }
| if (r3 != 0) {
0x00010fbc ldrne r1, [pc, 0xc54] | r1 = "%s: error!: bad UBI image sequence number: \"%s\"\n";
| goto label_34;
| }
| if (r3 != 0) {
| label_34:
0x00010fc0 bne 0x10dac | goto label_2;
| }
0x00010fc4 str r0, [r8, 0x24] | *((r8 + 0x24)) = r0;
0x00010fc8 b 0x10cbc | goto label_1;
| label_31:
0x00010fcc mov r3, 1 | r3 = 1;
0x00010fd0 str r3, [r8, 0x28] | *((r8 + 0x28)) = r3;
0x00010fd4 b 0x10cbc | goto label_1;
| label_23:
0x00010fd8 ldr r2, [pc, 0xc3c] | r2 = "%s: error!: bad UBI image sequence number: \"%s\"\n";
0x00010fdc ldr r1, [pc, 0xc04] | r1 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x00010fe0 ldr r0, [pc, 0xc38] | r0 = "_.1.0";
0x00010fe4 bl 0x10a94 | printf ("_.1.0", "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n", "%s: error!: bad UBI image sequence number: \"%s\"\n");
0x00010fe8 b 0x10d68 | goto label_5;
| label_20:
0x00010fec ldr r3, [pc, 0xc30] |
0x00010ff0 ldr r3, [r3] | r3 = "_s__mtd_utils___s";
0x00010ff4 cmp r5, r3 |
| if (r5 != r3) {
0x00010ff8 bne 0x11014 | goto label_35;
| }
0x00010ffc ldr r2, [pc, 0xbe4] | r2 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x00011000 ldr r1, [pc, 0xc20] | r1 = optind;
| do {
| label_7:
0x00011004 ldr r3, [pc, 0xbc8] | r3 = optarg;
0x00011008 ldr r0, [r3] | r0 = optarg;
0x0001100c bl 0x10b48 | fprintf (r0, r1, "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n", r3)
0x00011010 b 0x10e6c | goto label_6;
| label_35:
0x00011014 sub r5, r5, 1 | r5--;
0x00011018 cmp r3, r5 |
| if (r3 == r5) {
0x0001101c ldrne r2, [pc, 0xbc4] | r2 = "ubinize";
| }
| if (r3 == r5) {
0x00011020 ldrne r1, [pc, 0xc04] | r1 = "%s: error!: more then one configuration file was specified (use -h for help)\n";
| }
0x00011024 bne 0x11004 |
| } while (r3 != r5);
0x00011028 ldr r4, [r8, 0xc] | r4 = *((r8 + 0xc));
0x0001102c ldr r3, [r6, r3, lsl 2] | offset_0 = r3 << 2;
| r3 = *((r6 + offset_0));
0x00011030 cmp r4, 0 |
0x00011034 str r3, [r8] | *(r8) = r3;
| if (r4 >= 0) {
0x00011038 ldrlt r2, [pc, 0xba8] | r2 = "ubinize";
| }
| if (r4 < 0) {
0x0001103c ldrlt r1, [pc, 0xbec] | r1 = "%s: error!: physical eraseblock size was not specified (use -h for help)\n";
| goto label_36;
| }
| if (r4 < 0) {
| label_36:
0x00011040 blt 0x11004 | goto label_7;
| }
0x00011044 cmp r4, 0x200000 |
| if (r4 > 0x200000) {
0x00011048 ble 0x11068 |
0x0001104c ldr r0, [pc, 0xb80] |
0x00011050 mov r3, r4 | r3 = r4;
0x00011054 ldr r2, [pc, 0xb8c] | r2 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x00011058 ldr r1, [pc, 0xbd4] | r1 = "%s: error!: physical eraseblock size was not specified (use -h for help)\n";
0x0001105c ldr r0, [r0] | r0 = optarg;
0x00011060 bl 0x10b48 | fprintf (r0, "%s: error!: physical eraseblock size was not specified (use -h for help)\n", "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n", r3)
0x00011064 b 0x10e6c | goto label_6;
| }
0x00011068 ldr r5, [r8, 0x10] | r5 = *((r8 + 0x10));
0x0001106c cmp r5, 0 |
| if (r5 >= 0) {
0x00011070 ldrlt r2, [pc, 0xb70] | r2 = "ubinize";
| }
| if (r5 < 0) {
0x00011074 ldrlt r1, [pc, 0xbbc] | r1 = "%s: error!: min. I/O unit size was not specified (use -h for help)\n";
| goto label_37;
| }
| if (r5 < 0) {
| label_37:
0x00011078 blt 0x11004 | goto label_7;
| }
0x0001107c ldr r3, [r8, 0x14] | r3 = *((r8 + 0x14));
0x00011080 cmp r3, 0 |
| if (r3 >= 0) {
0x00011084 strlt r5, [r8, 0x14] | *((r8 + 0x14)) = r5;
| }
0x00011088 ldr r6, [r8, 0x14] | r6 = *((r8 + 0x14));
0x0001108c cmp r5, r6 |
| if (r5 >= r6) {
0x00011090 ldrlt r2, [pc, 0xb50] | r2 = "ubinize";
| }
| if (r5 < r6) {
0x00011094 ldrlt r1, [pc, 0xba0] | r1 = "%s: error!: sub-page cannot be larger then min. I/O unit\n";
| goto label_38;
| }
| if (r5 < r6) {
| label_38:
0x00011098 blt 0x11004 | goto label_7;
| }
0x0001109c mov r1, r5 | r1 = r5;
0x000110a0 mov r0, r4 | r0 = r4;
0x000110a4 bl 0x14124 | fcn_00014124 (r0, r1);
0x000110a8 cmp r1, 0 |
| if (r1 == 0) {
0x000110ac ldrne r2, [pc, 0xb34] | r2 = "ubinize";
| }
| if (r1 != 0) {
0x000110b0 ldrne r1, [pc, 0xb88] | r1 = "%s: error!: physical eraseblock should be multiple of min. I/O units\n";
| goto label_39;
| }
| if (r1 != 0) {
| label_39:
0x000110b4 bne 0x11004 | goto label_7;
| }
0x000110b8 mov r1, r6 | r1 = r6;
0x000110bc mov r0, r5 | r0 = r5;
0x000110c0 bl 0x14124 | fcn_00014124 (r0, r1);
0x000110c4 subs r3, r1, 0 | r3 = r1 - 0;
0x000110c8 str r3, [sp, 0x20] | var_20h = r3;
| if (r3 == r1) {
0x000110cc ldrne r2, [pc, 0xb14] | r2 = "ubinize";
| }
| if (r3 != r1) {
0x000110d0 ldrne r1, [pc, 0xb6c] | r1 = "%s: error!: min. I/O unit size should be multiple of sub-page size\n";
| goto label_40;
| }
| if (r3 != r1) {
| label_40:
0x000110d4 bne 0x11004 | goto label_7;
| }
0x000110d8 ldr r3, [r8, 4] | r3 = *((r8 + 4));
0x000110dc cmp r3, 0 |
| if (r3 != 0) {
0x000110e0 ldreq r2, [pc, 0xb00] | r2 = "ubinize";
| }
| if (r3 == 0) {
0x000110e4 ldreq r1, [pc, 0xb5c] | r1 = "%s: error!: output file was not specified (use -h for help)\n";
| goto label_41;
| }
| if (r3 == 0) {
| label_41:
0x000110e8 beq 0x11004 | goto label_7;
| }
0x000110ec ldr r2, [r8, 0x18] | r2 = *((r8 + 0x18));
0x000110f0 cmp r2, 0 |
| if (r2 == 0) {
0x000110f4 beq 0x1111c | goto label_42;
| }
0x000110f8 add r3, r2, 0x40 | r3 = r2 + 0x40;
0x000110fc cmp r4, r3 |
| if (r4 > r3) {
0x00011100 ldrle r2, [pc, 0xae0] | r2 = "ubinize";
| }
| if (r4 <= r3) {
0x00011104 ldrle r1, [pc, 0xb40] | r1 = "_s:_error_:_bad_VID_header_position";
| goto label_43;
| }
| if (r4 <= r3) {
| label_43:
0x00011108 ble 0x11004 | goto label_7;
| }
0x0001110c tst r2, 7 |
| if ((r2 & 7) == 0) {
0x00011110 ldrne r2, [pc, 0xad0] | r2 = "ubinize";
| }
| if ((r2 & 7) != 0) {
0x00011114 ldrne r1, [pc, 0xb34] | r1 = "%s: error!: VID header offset has to be multiple of min. I/O unit size\n";
| goto label_44;
| }
| if ((r2 & 7) != 0) {
| label_44:
0x00011118 bne 0x11004 | goto label_7;
| }
| label_42:
0x0001111c ldr r3, [r8, 0x24] | r3 = *((r8 + 0x24));
0x00011120 mov r1, r4 | r1 = r4;
0x00011124 str r3, [sp, 8] | var_8h = r3;
0x00011128 ldr r3, [r8, 0x20] | r3 = *((r8 + 0x20));
0x0001112c add r0, sp, 0x3c | r0 += var_3ch;
0x00011130 stm sp, {r2, r3} | *(sp) = r2;
| *((sp + 4)) = r3;
0x00011134 mov r3, r6 | r3 = r6;
0x00011138 mov r2, r5 | r2 = r5;
0x0001113c bl 0x12080 | fcn_00012080 (r0, r1, r2, r3, r4);
0x00011140 ldr r3, [r8, 0x28] | r3 = *((r8 + 0x28));
0x00011144 cmp r3, 0 |
| if (r3 != 0) {
0x00011148 beq 0x1115c |
0x0001114c ldr r2, [sp, 0x3c] | r2 = var_3ch;
0x00011150 ldr r1, [pc, 0xa90] | r1 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x00011154 ldr r0, [pc, 0xaf8] | r0 = "%s: error!: VID header offset has to be multiple of min. I/O unit size\n";
0x00011158 bl 0x10a94 | printf ("%s: error!: VID header offset has to be multiple of min. I/O unit size\n", "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n", r2);
| }
0x0001115c ldr r3, [r8, 0x28] | r3 = *((r8 + 0x28));
0x00011160 cmp r3, 0 |
| if (r3 != 0) {
0x00011164 beq 0x11178 |
0x00011168 ldr r2, [sp, 0x40] | r2 = var_40h;
0x0001116c ldr r1, [pc, 0xa74] | r1 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x00011170 ldr r0, [pc, 0xae0] | r0 = "%s: LEB size: %d\n";
0x00011174 bl 0x10a94 | printf ("%s: LEB size: %d\n", "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n", r2);
| }
0x00011178 ldr r3, [r8, 0x28] | r3 = *((r8 + 0x28));
0x0001117c cmp r3, 0 |
| if (r3 != 0) {
0x00011180 beq 0x11194 |
0x00011184 ldr r2, [sp, 0x44] | r2 = var_44h;
0x00011188 ldr r1, [pc, 0xa58] | r1 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x0001118c ldr r0, [pc, 0xac8] | r0 = "_s:_PEB_size:___________________d";
0x00011190 bl 0x10a94 | printf ("_s:_PEB_size:___________________d", "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n", r2);
| }
0x00011194 ldr r3, [r8, 0x28] | r3 = *((r8 + 0x28));
0x00011198 cmp r3, 0 |
| if (r3 != 0) {
0x0001119c beq 0x111b0 |
0x000111a0 ldr r2, [r8, 0x14] | r2 = *((r8 + 0x14));
0x000111a4 ldr r1, [pc, 0xa3c] | r1 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x000111a8 ldr r0, [pc, 0xab0] | r0 = "%s: min. I/O size: %d\n";
0x000111ac bl 0x10a94 | printf ("%s: min. I/O size: %d\n", "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n", r2);
| }
0x000111b0 ldr r3, [r8, 0x28] | r3 = *((r8 + 0x28));
0x000111b4 cmp r3, 0 |
| if (r3 != 0) {
0x000111b8 beq 0x111cc |
0x000111bc ldr r2, [sp, 0x48] | r2 = var_48h;
0x000111c0 ldr r1, [pc, 0xa20] | r1 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x000111c4 ldr r0, [pc, 0xa98] | r0 = "_s:_sub_page_size:______________d";
0x000111c8 bl 0x10a94 | printf ("_s:_sub_page_size:______________d", "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n", r2);
| }
0x000111cc ldr r3, [r8, 0x28] | r3 = *((r8 + 0x28));
0x000111d0 cmp r3, 0 |
| if (r3 != 0) {
0x000111d4 beq 0x111e8 |
0x000111d8 ldr r2, [sp, 0x4c] | r2 = var_4ch;
0x000111dc ldr r1, [pc, 0xa04] | r1 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x000111e0 ldr r0, [pc, 0xa80] | r0 = "%s: VID offset: %d\n";
0x000111e4 bl 0x10a94 | printf ("%s: VID offset: %d\n", "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n", r2);
| }
0x000111e8 ldr r3, [r8, 0x28] | r3 = *((r8 + 0x28));
0x000111ec cmp r3, 0 |
| if (r3 != 0) {
0x000111f0 beq 0x11204 |
0x000111f4 ldr r2, [sp, 0x5c] | r2 = var_5ch;
0x000111f8 ldr r1, [pc, 0x9e8] | r1 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x000111fc ldr r0, [pc, 0xa68] | r0 = "_s:_data_offset:________________d";
0x00011200 bl 0x10a94 | printf ("_s:_data_offset:________________d", "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n", r2);
| }
0x00011204 add r0, sp, 0x3c | r0 += var_3ch;
0x00011208 bl 0x1211c | fcn_0001211c (r0);
0x0001120c subs r3, r0, 0 | r3 -= var_3ch;
0x00011210 str r3, [sp, 0x2c] | ptr = r3;
| if (r3 == var_3ch) {
0x00011214 beq 0x1124c | goto label_45;
| }
0x00011218 ldr r0, [r8] | r0 = *(r8);
0x0001121c bl 0x135b4 | r0 = fcn_000135b4 (r0, r1);
0x00011220 cmp r0, 0 |
0x00011224 str r0, [r8, 0x2c] | *((r8 + 0x2c)) = r0;
| if (r0 != 0) {
0x00011228 bne 0x11268 | goto label_46;
| }
0x0001122c ldr r0, [pc, 0x9a0] |
0x00011230 ldr r3, [r8] | r3 = *(r8);
0x00011234 ldr r2, [pc, 0x9ac] | r2 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x00011238 ldr r1, [pc, 0xa30] | r1 = "%s: UBI image sequence number: %u\n";
0x0001123c ldr r0, [r0] | r0 = optarg;
0x00011240 bl 0x10b48 | fprintf (r0, "%s: UBI image sequence number: %u\n", "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n", r3)
| do {
0x00011244 ldr r0, [sp, 0x2c] | r0 = ptr;
0x00011248 bl 0x10c74 | free (r0);
| label_45:
0x0001124c ldr r4, [pc, 0x970] | r4 = *(0x11bc0);
0x00011250 ldr r0, [r4, 8] | r0 = "output";
0x00011254 bl 0x10c5c | close ("output");
0x00011258 ldr r0, [r4, 4] | r0 = *(0x11bc4);
0x0001125c bl 0x10b00 | remove (r0);
0x00011260 ldr r7, [sp, 0x20] | r7 = var_20h;
0x00011264 b 0x10e6c | goto label_6;
| label_46:
0x00011268 ldr r3, [r8, 0x28] | r3 = *((r8 + 0x28));
0x0001126c cmp r3, 0 |
| if (r3 != 0) {
0x00011270 beq 0x11284 |
0x00011274 ldr r2, [r8] | r2 = *(r8);
0x00011278 ldr r1, [pc, 0x968] | r1 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x0001127c ldr r0, [pc, 0x9f0] | r0 = "_s:_error_:_cannot_load_the_input_ini_file___s_";
0x00011280 bl 0x10a94 | printf ("_s:_error_:_cannot_load_the_input_ini_file___s_", "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n", r2);
| }
0x00011284 ldr r0, [r8, 0x2c] | r0 = *((r8 + 0x2c));
0x00011288 bl 0x131f4 | r0 = fcn_000131f4 (r0);
0x0001128c cmn r0, 1 |
0x00011290 str r0, [sp, 0x1c] | size = r0;
| if (r0 == 1) {
0x00011294 bne 0x112b0 |
0x00011298 ldr r2, [pc, 0x948] | r2 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x0001129c ldr r1, [pc, 0x9d4] | r1 = "%s: loaded the ini-file \"%s\"\n";
| label_9:
0x000112a0 ldr r3, [pc, 0x92c] | r3 = optarg;
0x000112a4 ldr r0, [r3] | r0 = optarg;
0x000112a8 bl 0x10b48 | fprintf (r0, "%s: loaded the ini-file \"%s\"\n", "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n", r3)
0x000112ac b 0x112f8 |
| } else {
0x000112b0 ldr r3, [r8, 0x28] | r3 = *((r8 + 0x28));
0x000112b4 cmp r3, 0 |
| if (r3 != 0) {
0x000112b8 beq 0x112cc |
0x000112bc ldr r2, [sp, 0x1c] | r2 = size;
0x000112c0 ldr r1, [pc, 0x920] | r1 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x000112c4 ldr r0, [pc, 0x9b0] | r0 = "%s: error!: ini-file parsing error (iniparser_getnsec)\n";
0x000112c8 bl 0x10a94 | printf ("%s: error!: ini-file parsing error (iniparser_getnsec)\n", "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n", r2);
| }
0x000112cc ldr r3, [sp, 0x1c] | r3 = size;
0x000112d0 cmp r3, 0 |
| if (r3 != 0) {
0x000112d4 bne 0x11308 | goto label_47;
| }
0x000112d8 ldr r0, [pc, 0x8f4] |
0x000112dc ldr r3, [r8] | r3 = *(r8);
0x000112e0 ldr r2, [pc, 0x900] | r2 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x000112e4 ldr r1, [pc, 0x994] | r1 = "%s: count of sections: %d\n";
0x000112e8 ldr r0, [r0] | r0 = optarg;
0x000112ec bl 0x10b48 | fprintf (r0, "%s: count of sections: %d\n", "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n", r3)
0x000112f0 ldr r3, [sp, 0x1c] | r3 = size;
0x000112f4 str r3, [sp, 0x20] | var_20h = r3;
| }
| label_8:
0x000112f8 ldr r3, [pc, 0x8c4] | r3 = *(0x11bc0);
0x000112fc ldr r0, [r3, 0x2c] | r0 = "For_more_information_see__man_8__s_";
0x00011300 bl 0x13a84 | fcn_00013a84 ("For_more_information_see__man_8__s_");
0x00011304 b 0x11244 |
| } while (1);
| label_47:
0x00011308 ldr r3, [sp, 0x58] | r3 = var_58h;
0x0001130c ldr r2, [sp, 0x1c] | r2 = size;
0x00011310 cmp r3, r2 |
| if (r3 < r2) {
0x00011314 bge 0x1134c |
0x00011318 ldr r3, [r8] | r3 = *(r8);
0x0001131c ldr r0, [pc, 0x8b0] |
0x00011320 str r3, [sp] | *(sp) = r3;
0x00011324 ldr r1, [pc, 0x958] | r1 = "_s:_error_:_no_sections_found_the_ini_file___s_";
0x00011328 mov r3, r2 | r3 = r2;
0x0001132c ldr r0, [r0] | r0 = optarg;
0x00011330 ldr r2, [pc, 0x8b0] | r2 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x00011334 bl 0x10b48 | fprintf (r0, "_s:_error_:_no_sections_found_the_ini_file___s_", "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n", r3)
0x00011338 ldr r2, [sp, 0x58] | r2 = var_58h;
0x0001133c ldr r1, [pc, 0x8a4] | r1 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x00011340 ldr r0, [pc, 0x940] | r0 = "%s: error!: too many sections (%d) in the ini-file \"%s\"\n";
0x00011344 bl 0x10a94 | printf ("%s: error!: too many sections (%d) in the ini-file \"%s\"\n", "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n", r2);
0x00011348 b 0x112f8 | goto label_8;
| }
0x0001134c ldr r1, [sp, 0x1c] | r1 = size;
0x00011350 mov r0, 0x38 | r0 = 0x38;
0x00011354 bl 0x10b30 | r0 = calloc (r0, r1);
0x00011358 subs r3, r0, 0 | r3 = r0 - 0;
0x0001135c str r3, [sp, 0x28] | var_28h = r3;
| if (r3 != r0) {
0x00011360 ldreq r2, [pc, 0x880] | r2 = "ubinize";
| }
| if (r3 == r0) {
0x00011364 ldreq r1, [pc, 0x920] | r1 = "%s: error!: cannot allocate memory\n";
| goto label_48;
| }
| if (r3 == r0) {
| label_48:
0x00011368 beq 0x112a0 | goto label_9;
| }
0x0001136c ldr r4, [sp, 0x40] | r4 = var_40h;
0x00011370 mov r6, 0 | r6 = 0;
0x00011374 lsl r4, r4, 1 | r4 <<= 1;
0x00011378 asr r5, r4, 0x1f | r5 = r4 >> 0x1f;
0x0001137c str r6, [sp] | *(sp) = r6;
0x00011380 mov r2, r4 | r2 = r4;
0x00011384 mov r3, r5 | r3 = r5;
0x00011388 ldr r0, [r8, 8] | r0 = *((r8 + 8));
0x0001138c bl 0x10c2c | lseek64 ();
0x00011390 cmp r1, r5 |
0x00011394 cmpeq r0, r4 | __asm ("cmpeq r0, r4");
| if (r1 == r5) {
0x00011398 bne 0x11418 |
0x0001139c str r6, [sp, 0x24] | var_24h = r6;
0x000113a0 ldr r4, [sp, 0x28] | r4 = var_28h;
0x000113a4 ldr r6, [pc, 0x818] | r6 = *(0x11bc0);
0x000113a8 ldr sb, [pc, 0x838] | sb = "ubinize";
0x000113ac ldr r3, [sp, 0x24] | r3 = var_24h;
0x000113b0 ldr r2, [sp, 0x1c] | r2 = size;
0x000113b4 cmp r3, r2 |
| if (r3 >= r2) {
0x000113b8 blt 0x11440 |
0x000113bc ldr r3, [r6, 0x28] | r3 = *((r6 + 0x28));
0x000113c0 cmp r3, 0 |
| if (r3 != 0) {
0x000113c4 beq 0x113d4 |
0x000113c8 ldr r1, [pc, 0x818] | r1 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x000113cc ldr r0, [pc, 0x8bc] | r0 = "%s: error!: cannot allocate memory\n";
0x000113d0 bl 0x10a94 | printf ("%s: error!: cannot allocate memory\n", "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n");
| }
0x000113d4 ldr r1, [r6, 8] | r1 = *((r6 + 8));
0x000113d8 ldr r2, [r6, 0x1c] | r2 = *((r6 + 0x1c));
0x000113dc str r1, [sp, 0x14] | var_14h = r1;
0x000113e0 ldr r1, [sp, 0x2c] | r1 = ptr;
0x000113e4 asr r3, r2, 0x1f | r3 = r2 >> 0x1f;
0x000113e8 str r1, [sp, 0x10] | var_10h = r1;
0x000113ec strd r2, r3, [sp, 8] | __asm ("strd r2, r3, [var_8h]");
0x000113f0 strd r2, r3, [sp] | __asm ("strd r2, r3, [sp]");
0x000113f4 mov r1, 0 | r1 = 0;
0x000113f8 mov r2, 1 | r2 = 1;
0x000113fc add r0, sp, 0x3c | r0 += var_3ch;
0x00011400 bl 0x12b68 | fcn_00012b68 (r0, r1, r2, r3, r4, r5);
0x00011404 subs r7, r0, 0 | r7 -= var_3ch;
| if (r7 == var_3ch) {
0x00011408 beq 0x11eb4 | goto label_49;
| }
0x0001140c ldr r2, [pc, 0x7d4] | r2 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x00011410 ldr r1, [pc, 0x87c] | r1 = "%s: writing layout volume\n";
0x00011414 b 0x1145c |
| } else {
0x00011418 bl 0x10c08 | errno_location ();
0x0001141c ldr r5, [pc, 0x7b0] | r5 = optarg;
0x00011420 ldr r3, [r8, 4] | r3 = *((r8 + 4));
0x00011424 ldr r2, [pc, 0x7bc] | r2 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x00011428 ldr r1, [pc, 0x868] | r1 = "_s:_error_:_cannot_write_layout_volume";
0x0001142c ldr r4, [r0] | r4 = *(r0);
| label_15:
0x00011430 ldr r0, [r5] | r0 = *(r5);
0x00011434 bl 0x10b48 | fprintf (r0, "_s:_error_:_cannot_write_layout_volume", "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n", r3, r4, r5)
0x00011438 ldr r5, [r5] | r5 = *(r5);
0x0001143c b 0x11684 | goto label_50;
| }
0x00011440 ldr r1, [sp, 0x24] | r1 = var_24h;
0x00011444 ldr r0, [r6, 0x2c] | r0 = *((r6 + 0x2c));
0x00011448 bl 0x13248 | r0 = fcn_00013248 (r0, r1);
0x0001144c subs r5, r0, 0 | r5 = r0 - 0;
| if (r5 != r0) {
0x00011450 bne 0x11468 | goto label_51;
| }
0x00011454 ldr r2, [pc, 0x78c] | r2 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x00011458 ldr r1, [pc, 0x83c] | r1 = "%s: error!: cannot seek file \"%s\"\n";
| }
0x0001145c ldr r3, [pc, 0x770] | r3 = optarg;
0x00011460 ldr r0, [r3] | r0 = optarg;
0x00011464 b 0x11510 | goto label_52;
| label_51:
0x00011468 ldr r3, [r6, 0x28] | r3 = *((r6 + 0x28));
0x0001146c cmp r3, 0 |
| if (r3 != 0) {
0x00011470 beq 0x1147c |
0x00011474 mov r0, 0xa | r0 = 0xa;
0x00011478 bl 0x10a7c | putchar (r0);
| }
0x0001147c ldr r3, [r6, 0x28] | r3 = *((r6 + 0x28));
0x00011480 cmp r3, 0 |
| if (r3 != 0) {
0x00011484 beq 0x11498 |
0x00011488 mov r2, r5 | r2 = r5;
0x0001148c mov r1, sb | r1 = sb;
0x00011490 ldr r0, [pc, 0x808] | r0 = "_s:_error_:_ini_file_parsing_error__iniparser_getsecname_";
0x00011494 bl 0x10a94 | printf ("_s:_error_:_ini_file_parsing_error__iniparser_getsecname_", r1, r2);
| }
0x00011498 mov r0, r5 | r0 = r5;
0x0001149c bl 0x10c20 | r0 = strlen (r0);
0x000114a0 cmp r0, 0x80 |
| if (r0 >= 0x80) {
0x000114a4 bls 0x114c4 |
0x000114a8 ldr r2, [pc, 0x738] | r2 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x000114ac ldr r1, [pc, 0x7f0] | r1 = "%s: parsing section \"%s\"\n";
0x000114b0 mov r3, r5 | r3 = r5;
| label_12:
0x000114b4 ldr r0, [pc, 0x718] |
0x000114b8 ldr r0, [r0] | r0 = optarg;
0x000114bc bl 0x10b48 | fprintf (r0, "%s: parsing section \"%s\"\n", "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n", r3)
0x000114c0 b 0x116a8 | goto label_11;
| }
0x000114c4 mov r2, r5 | r2 = r5;
0x000114c8 ldr r1, [pc, 0x7d8] | r1 = "%s: error!: too long section name \"%s\"\n";
0x000114cc add r0, sp, 0x130 | r0 += s;
0x000114d0 bl 0x10bf0 | sprintf (r0, "%s: error!: too long section name \"%s\"\n", r2);
0x000114d4 mov r2, 0 | r2 = 0;
0x000114d8 add r1, sp, 0x130 | r1 += s;
0x000114dc ldr r0, [r6, 0x2c] | r0 = *((r6 + 0x2c));
0x000114e0 bl 0x134b4 | r0 = fcn_000134b4 (r0, r1);
0x000114e4 cmp r0, 0 |
| if (r0 == 0) {
0x000114e8 bne 0x11518 |
0x000114ec ldr r4, [pc, 0x6e0] | r4 = optarg;
0x000114f0 ldr r2, [pc, 0x6f0] | r2 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x000114f4 ldr r1, [pc, 0x7b0] | r1 = "%s:mode";
0x000114f8 mov r3, r5 | r3 = r5;
0x000114fc ldr r0, [r4] | r0 = optarg;
0x00011500 bl 0x10b48 | fprintf (r0, "%s:mode", "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n", r3, r4)
0x00011504 ldr r2, [pc, 0x6dc] | r2 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x00011508 ldr r1, [pc, 0x7a0] | r1 = "%s: error!: \"mode\" key not found in section \"%s\"\n";
0x0001150c ldr r0, [r4] | r0 = optarg;
| label_52:
0x00011510 bl 0x10b48 | fprintf (r0, "%s: error!: \"mode\" key not found in section \"%s\"\n", "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n")
0x00011514 b 0x116a8 | goto label_11;
| }
0x00011518 ldr r1, [pc, 0x794] | r1 = "%s: error!: the \"mode\" key is mandatory and has to be \"mode=ubi\" if the section describes an UBI volume\n";
0x0001151c bl 0x10be4 | strcmp (r0, "%s: error!: the \"mode\" key is mandatory and has to be \"mode=ubi\" if the section describes an UBI volume\n");
0x00011520 ldr r8, [r6, 0x28] | r8 = *((r6 + 0x28));
0x00011524 cmp r0, 0 |
| if (r0 != 0) {
0x00011528 beq 0x115a4 |
0x0001152c cmp r8, 0 |
| if (r8 != 0) {
0x00011530 beq 0x11548 |
0x00011534 mov r2, r5 | r2 = r5;
0x00011538 mov r1, sb | r1 = sb;
0x0001153c ldr r0, [pc, 0x774] | r0 = "ubi";
0x00011540 bl 0x10a94 | printf ("ubi", r1, r2);
0x00011544 mov r8, 0 | r8 = 0;
| }
| label_17:
0x00011548 ldr r3, [r6, 0x28] | r3 = *((r6 + 0x28));
0x0001154c cmp r3, 0 |
| if (r3 != 0) {
0x00011550 beq 0x11564 |
0x00011554 ldr r2, [r4] | r2 = *(r4);
0x00011558 mov r1, sb | r1 = sb;
0x0001155c ldr r0, [pc, 0x758] | r0 = "_s:_skip_non_ubi_section___s_";
0x00011560 bl 0x10a94 | printf ("_s:_skip_non_ubi_section___s_", r1, r2);
| }
0x00011564 ldr r3, [sp, 0x24] | r3 = var_24h;
0x00011568 mov r2, 0x38 | r2 = 0x38;
0x0001156c mul r3, r2, r3 | r3 = r2 * r3;
0x00011570 mov fp, 0 |
0x00011574 mov r2, r3 | r2 = r3;
| label_19:
0x00011578 cmp r2, fp |
| if (r2 != fp) {
0x0001157c bne 0x11b14 | goto label_53;
| }
0x00011580 ldrb r3, [r4, 0x30] | r3 = *((r4 + 0x30));
0x00011584 tst r3, 2 |
| if ((r3 & 2) == 0) {
0x00011588 beq 0x11b78 | goto label_54;
| }
0x0001158c ldr r2, [r4, 4] | r2 = *((r4 + 4));
0x00011590 cmp r2, 2 |
| if (r2 == 2) {
0x00011594 beq 0x11b78 | goto label_54;
| }
0x00011598 ldr r2, [pc, 0x648] | r2 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x0001159c ldr r1, [pc, 0x71c] | r1 = "%s: adding volume %d\n";
0x000115a0 b 0x11004 | goto label_7;
| }
0x000115a4 cmp r8, 0 |
| if (r8 != 0) {
0x000115a8 beq 0x115b8 |
0x000115ac mov r1, sb | r1 = sb;
0x000115b0 ldr r0, [pc, 0x70c] | r0 = "_s:_error_:_skip_check_is_only_valid_for_static_volumes";
0x000115b4 bl 0x10a94 | printf ("_s:_error_:_skip_check_is_only_valid_for_static_volumes", r1);
| }
0x000115b8 mov r2, r5 | r2 = r5;
0x000115bc ldr r1, [pc, 0x704] | r1 = "%s: mode=ubi, keep parsing\n";
0x000115c0 add r0, sp, 0x130 | r0 += s;
0x000115c4 bl 0x10bf0 | sprintf (r0, "%s: mode=ubi, keep parsing\n", r2);
0x000115c8 mov r2, 0 | r2 = 0;
0x000115cc add r1, sp, 0x130 | r1 += s;
0x000115d0 ldr r0, [r6, 0x2c] | r0 = *((r6 + 0x2c));
0x000115d4 bl 0x134b4 | r0 = fcn_000134b4 (r0, r1);
0x000115d8 subs r8, r0, 0 | r8 = r0 - 0;
| if (r8 != r0) {
0x000115dc bne 0x116b8 | goto label_55;
| }
0x000115e0 mov r2, r5 | r2 = r5;
0x000115e4 mov r1, sb | r1 = sb;
0x000115e8 ldr r0, [pc, 0x6dc] | r0 = "%s:vol_type";
0x000115ec bl 0x10a94 | printf ("%s:vol_type", r1, r2);
| label_10:
0x000115f0 mov r3, 1 | r3 = 1;
| do {
0x000115f4 str r3, [r4, 4] | *((r4 + 4)) = r3;
0x000115f8 ldr r3, [r6, 0x28] | r3 = *((r6 + 0x28));
0x000115fc cmp r3, 0 |
| if (r3 != 0) {
0x00011600 beq 0x11624 |
0x00011604 ldr r1, [r4, 4] | r1 = *((r4 + 4));
0x00011608 ldr r3, [pc, 0x6c0] | r3 = "%s: volume type was not specified in section \"%s\", assume \"dynamic\"\n\n";
0x0001160c cmp r1, 1 |
0x00011610 ldr r2, [pc, 0x6bc] | r2 = "dynamic";
0x00011614 mov r1, sb | r1 = sb;
| if (r1 != 1) {
0x00011618 moveq r2, r3 | r2 = r3;
| }
0x0001161c ldr r0, [pc, 0x6b4] | r0 = "static";
0x00011620 bl 0x10a94 | printf ("static", r1, "dynamic", "%s: volume type was not specified in section \"%s\", assume \"dynamic\"\n\n");
| }
0x00011624 mov r2, r5 | r2 = r5;
0x00011628 ldr r1, [pc, 0x6ac] | r1 = "_s:_volume_type:__s";
0x0001162c add r0, sp, 0x130 | r0 += s;
0x00011630 bl 0x10bf0 | sprintf (r0, "_s:_volume_type:__s", r2);
0x00011634 mov r2, 0 | r2 = 0;
0x00011638 add r1, sp, 0x130 | r1 += s;
0x0001163c ldr r0, [r6, 0x2c] | r0 = *((r6 + 0x2c));
0x00011640 bl 0x134b4 | r0 = fcn_000134b4 (r0, r1);
0x00011644 subs r8, r0, 0 | r8 = r0 - 0;
| if (r8 == r0) {
0x00011648 beq 0x11720 | goto label_56;
| }
0x0001164c add r1, sp, 0x60 | r1 += var_60h;
0x00011650 bl 0x10aac | r0 = stat64 ();
0x00011654 cmp r0, 0 |
| if (r0 == 0) {
0x00011658 beq 0x11700 | goto label_57;
| }
0x0001165c bl 0x10c08 | errno_location ();
0x00011660 ldr r6, [pc, 0x56c] | r6 = optarg;
0x00011664 mov r3, r8 | r3 = r8;
0x00011668 ldr r2, [pc, 0x578] | r2 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x0001166c ldr r1, [pc, 0x66c] | r1 = "%s:image";
0x00011670 ldr r4, [r0] | r4 = *(r0);
0x00011674 str r5, [sp] | *(sp) = r5;
0x00011678 ldr r0, [r6] | r0 = optarg;
0x0001167c bl 0x10b48 | fprintf (r0, "%s:image", "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n", r3, r4, r5, r6)
0x00011680 ldr r5, [r6] | r5 = optarg;
| label_50:
0x00011684 mov r0, r4 | r0 = r4;
0x00011688 bl 0x10aa0 | strerror (r0);
0x0001168c ldr r3, [pc, 0x6d8] | r3 = "%s: error!: cannot open \"%s\"\n";
0x00011690 ldr r1, [pc, 0x6d8] | r1 = *(0x11d6c);
0x00011694 mov r2, 9 | r2 = 9;
0x00011698 str r4, [sp] | *(sp) = r4;
0x0001169c str r0, [sp, 4] | var_4h = r0;
0x000116a0 mov r0, r5 | r0 = r5;
| label_14:
0x000116a4 bl 0x10b48 | fprintf (r0, r1, r2, "%s: error!: cannot open \"%s\"\n", r4)
| label_11:
0x000116a8 ldr r0, [sp, 0x28] | r0 = var_28h;
0x000116ac bl 0x10c74 | free (r0);
0x000116b0 str r7, [sp, 0x20] | var_20h = r7;
0x000116b4 b 0x112f8 | goto label_8;
| label_55:
0x000116b8 ldr r1, [pc, 0x614] | r1 = "dynamic";
0x000116bc bl 0x10be4 | r0 = strcmp (r0, "dynamic");
0x000116c0 cmp r0, 0 |
| if (r0 != 0) {
0x000116c4 moveq r3, 2 | r3 = 2;
| }
0x000116c8 beq 0x115f4 |
| } while (r0 == 0);
0x000116cc ldr r1, [pc, 0x5fc] | r1 = "%s: volume type was not specified in section \"%s\", assume \"dynamic\"\n\n";
0x000116d0 mov r0, r8 | r0 = r8;
0x000116d4 bl 0x10be4 | r0 = strcmp (r0, "%s: volume type was not specified in section \"%s\", assume \"dynamic\"\n\n");
0x000116d8 cmp r0, 0 |
| if (r0 == 0) {
0x000116dc beq 0x115f0 | goto label_10;
| }
0x000116e0 ldr r2, [pc, 0x500] | r2 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x000116e4 ldr r1, [pc, 0x5f8] | r1 = "_s:_error_:_cannot_stat___s__referred_from_section___s_";
0x000116e8 mov r3, r8 | r3 = r8;
0x000116ec str r5, [sp] | *(sp) = r5;
| do {
| label_13:
0x000116f0 ldr r0, [pc, 0x4dc] |
0x000116f4 ldr r0, [r0] | r0 = optarg;
0x000116f8 bl 0x10b48 | fprintf (r0, "_s:_error_:_cannot_stat___s__referred_from_section___s_", "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n", r3, r4, r5)
0x000116fc b 0x116a8 | goto label_11;
| label_57:
0x00011700 ldrd r2, r3, [sp, 0x90] | __asm ("ldrd r2, r3, [var_90h]");
0x00011704 orrs r3, r2, r3 | r3 = r2 | r3;
| if (r3 != r2) {
0x00011708 bne 0x11738 | goto label_58;
| }
0x0001170c str r5, [sp] | *(sp) = r5;
0x00011710 mov r3, r8 | r3 = r8;
0x00011714 ldr r2, [pc, 0x4cc] | r2 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x00011718 ldr r1, [pc, 0x5c8] | r1 = "%s: error!: invalid volume type \"%s\" in section \"%s\"\n";
0x0001171c b 0x116f0 |
| } while (1);
| label_56:
0x00011720 ldr r3, [r4, 4] | r3 = *((r4 + 4));
0x00011724 cmp r3, 2 |
| if (r3 != 2) {
0x00011728 moveq r3, r5 | r3 = r5;
| }
| if (r3 != 2) {
0x0001172c ldreq r2, [pc, 0x4b4] | r2 = "ubinize";
| }
| if (r3 == 2) {
0x00011730 ldreq r1, [pc, 0x5b4] | r1 = "%s: error!: image is not specified for static volume in section \"%s\"\n";
| goto label_59;
| }
| if (r3 == 2) {
| label_59:
0x00011734 beq 0x114b4 | goto label_12;
| }
| label_58:
0x00011738 mov r2, r5 | r2 = r5;
0x0001173c ldr r1, [pc, 0x5ac] | r1 = "%s: error!: image is not specified for static volume in section \"%s\"\n";
0x00011740 add r0, sp, 0x130 | r0 += s;
0x00011744 bl 0x10bf0 | sprintf (r0, "%s: error!: image is not specified for static volume in section \"%s\"\n", r2);
0x00011748 mvn r2, 0 | r2 = ~0;
0x0001174c add r1, sp, 0x130 | r1 += s;
0x00011750 ldr r0, [r6, 0x2c] | r0 = *((r6 + 0x2c));
0x00011754 bl 0x134f0 | r0 = fcn_000134f0 (r0, r1);
0x00011758 cmn r0, 1 |
0x0001175c mov fp, r0 |
0x00011760 str r0, [r4] | *(r4) = r0;
| if (r0 == 1) {
0x00011764 bne 0x11788 |
0x00011768 ldr r2, [pc, 0x478] | r2 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x0001176c ldr r1, [pc, 0x580] | r1 = "%s:vol_id";
0x00011770 mov r3, r5 | r3 = r5;
0x00011774 ldr r0, [pc, 0x458] |
0x00011778 ldr r0, [r0] | r0 = optarg;
0x0001177c bl 0x10b48 | fprintf (r0, "%s:vol_id", "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n", r3)
0x00011780 mov r7, fp | r7 = fp;
0x00011784 b 0x116a8 | goto label_11;
| }
0x00011788 cmp r0, 0 |
| if (r0 >= 0) {
0x0001178c strlt r5, [sp] | *(sp) = r5;
| }
| if (r0 >= 0) {
0x00011790 movlt r3, r0 | r3 = r0;
| }
| if (r0 >= 0) {
0x00011794 ldrlt r2, [pc, 0x44c] | r2 = "ubinize";
| }
| if (r0 < 0) {
0x00011798 ldrlt r1, [pc, 0x558] | r1 = "%s: error!: negative volume ID %d in section \"%s\"\n";
| goto label_60;
| }
| if (r0 < 0) {
| label_60:
0x0001179c blt 0x116f0 | goto label_13;
| }
0x000117a0 ldr r3, [sp, 0x58] | r3 = var_58h;
0x000117a4 cmp r0, r3 |
| if (r0 >= r3) {
0x000117a8 blt 0x117cc |
0x000117ac str r3, [sp, 4] | var_4h = r3;
0x000117b0 mov r3, r0 | r3 = r0;
0x000117b4 ldr r0, [pc, 0x418] |
0x000117b8 str r5, [sp] | *(sp) = r5;
0x000117bc ldr r2, [pc, 0x424] | r2 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x000117c0 ldr r1, [pc, 0x534] | r1 = "%s: error!: negative volume ID %d in section \"%s\"\n";
0x000117c4 ldr r0, [r0] | r0 = optarg;
0x000117c8 b 0x116a4 | goto label_14;
| }
0x000117cc ldr r3, [r6, 0x28] | r3 = *((r6 + 0x28));
0x000117d0 cmp r3, 0 |
| if (r3 != 0) {
0x000117d4 beq 0x117e8 |
0x000117d8 mov r2, r0 | r2 = r0;
0x000117dc mov r1, sb | r1 = sb;
0x000117e0 ldr r0, [pc, 0x518] | r0 = "%s: error!: too high volume ID %d in section \"%s\", max. is %d\n";
0x000117e4 bl 0x10a94 | printf ("%s: error!: too high volume ID %d in section \"%s\", max. is %d\n", r1, r2);
| }
0x000117e8 mov r2, r5 | r2 = r5;
0x000117ec ldr r1, [pc, 0x510] | r1 = "_s:_volume_ID:__d";
0x000117f0 add r0, sp, 0x130 | r0 += s;
0x000117f4 bl 0x10bf0 | sprintf (r0, "_s:_volume_ID:__d", r2);
0x000117f8 mov r2, 0 | r2 = 0;
0x000117fc add r1, sp, 0x130 | r1 += s;
0x00011800 ldr r0, [r6, 0x2c] | r0 = *((r6 + 0x2c));
0x00011804 bl 0x134b4 | r0 = fcn_000134b4 (r0, r1);
0x00011808 subs fp, r0, 0 |
| if (fp == r0) {
0x0001180c beq 0x118cc | goto label_61;
| }
0x00011810 bl 0x12e10 | fcn_00012e10 (r0);
0x00011814 mov r3, r1 | r3 = r1;
0x00011818 cmp r0, 1 |
0x0001181c mov r2, r0 | r2 = r0;
0x00011820 sbcs r1, r3, 0 | __asm ("sbcs r1, r3, 0");
0x00011824 strd r2, r3, [r4, 0x28] | __asm ("strd r2, r3, [r4, 0x28]");
| if (r0 >= 1) {
0x00011828 strlt r5, [sp] | *(sp) = r5;
| }
| if (r0 >= 1) {
0x0001182c movlt r3, fp | r3 = fp;
| }
| if (r0 >= 1) {
0x00011830 ldrlt r2, [pc, 0x3b0] | r2 = "ubinize";
| }
| if (r0 < 1) {
0x00011834 ldrlt r1, [pc, 0x4cc] | r1 = "%s: error!: bad \"vol_size\" key value \"%s\" (section \"%s\")\n";
| goto label_62;
| }
| if (r0 < 1) {
| label_62:
0x00011838 blt 0x116f0 | goto label_13;
| }
0x0001183c cmp r8, 0 |
| if (r8 != 0) {
0x00011840 beq 0x1187c |
0x00011844 ldrd r0, r1, [sp, 0x90] | __asm ("ldrd r0, r1, [var_90h]");
0x00011848 cmp r2, r0 |
0x0001184c sbcs ip, r3, r1 | __asm ("sbcs ip, r3, r1");
| if (r2 >= r0) {
0x00011850 bge 0x1187c | goto label_63;
| }
0x00011854 strd r0, r1, [sp, 8] | __asm ("strd r0, r1, [var_8h]");
0x00011858 ldr r0, [pc, 0x374] |
0x0001185c strd r2, r3, [sp, 0x10] | __asm ("strd r2, r3, [var_14h]");
0x00011860 ldr r1, [pc, 0x4a4] | r1 = "%s: error!: bad \"vol_size\" key value \"%s\" (section \"%s\")\n";
0x00011864 str r8, [sp] | *(sp) = r8;
0x00011868 mov r3, r5 | r3 = r5;
0x0001186c ldr r2, [pc, 0x374] | r2 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x00011870 ldr r0, [r0] | r0 = optarg;
0x00011874 bl 0x10b48 | fprintf (r0, "%s: error!: bad \"vol_size\" key value \"%s\" (section \"%s\")\n", r2, r3)
0x00011878 b 0x116a8 | goto label_11;
| }
| label_63:
0x0001187c ldr r1, [r6, 0x28] | r1 = *((r6 + 0x28));
0x00011880 cmp r1, 0 |
| if (r1 != 0) {
0x00011884 beq 0x11894 |
0x00011888 mov r1, sb | r1 = sb;
0x0001188c ldr r0, [pc, 0x47c] | r0 = "%s: error!: error in section \"%s\": size of the image file \"%s\" is %lld, which is larger than volume size %lld\n";
0x00011890 bl 0x10a94 | printf ("%s: error!: error in section \"%s\": size of the image file \"%s\" is %lld, which is larger than volume size %lld\n", r1);
| }
| label_16:
0x00011894 mov r2, r5 | r2 = r5;
0x00011898 ldr r1, [pc, 0x474] | r1 = "_s:_volume_size:__lld_bytes";
0x0001189c add r0, sp, 0x130 | r0 += s;
0x000118a0 bl 0x10bf0 | sprintf (r0, "_s:_volume_size:__lld_bytes", r2);
0x000118a4 mov r2, 0 | r2 = 0;
0x000118a8 add r1, sp, 0x130 | r1 += s;
0x000118ac ldr r0, [r6, 0x2c] | r0 = *((r6 + 0x2c));
0x000118b0 bl 0x134b4 | r0 = fcn_000134b4 (r0, r1);
0x000118b4 subs fp, r0, 0 |
| if (fp != r0) {
0x000118b8 bne 0x1195c | goto label_64;
| }
0x000118bc mov r3, r5 | r3 = r5;
0x000118c0 ldr r2, [pc, 0x320] | r2 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x000118c4 ldr r1, [pc, 0x44c] | r1 = "%s:vol_name";
0x000118c8 b 0x114b4 | goto label_12;
| label_61:
0x000118cc cmp r8, 0 |
| if (r8 != 0) {
0x000118d0 moveq r3, r5 | r3 = r5;
| }
| if (r8 != 0) {
0x000118d4 ldreq r2, [pc, 0x30c] | r2 = "ubinize";
| }
| if (r8 == 0) {
0x000118d8 ldreq r1, [pc, 0x43c] | r1 = "%s: error!: neither image file (\"image=\") nor volume size (\"vol_size=\") specified in section \"%s\"\n";
| goto label_65;
| }
| if (r8 == 0) {
| label_65:
0x000118dc beq 0x114b4 | goto label_12;
| }
0x000118e0 add r1, sp, 0xc8 | r1 += var_c8h;
0x000118e4 mov r0, r8 | r0 = r8;
0x000118e8 bl 0x10aac | r0 = stat64 ();
0x000118ec cmp r0, 0 |
| if (r0 != 0) {
0x000118f0 beq 0x11910 |
0x000118f4 bl 0x10c08 | errno_location ();
0x000118f8 ldr r5, [pc, 0x2d4] | r5 = optarg;
0x000118fc mov r3, r8 | r3 = r8;
0x00011900 ldr r2, [pc, 0x2e0] | r2 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x00011904 ldr r1, [pc, 0x414] | r1 = "%s: error!: neither image file (\"image=\") nor volume size (\"vol_size=\") specified in section \"%s\"\n";
0x00011908 ldr r4, [r0] | r4 = *(r0);
0x0001190c b 0x11430 | goto label_15;
| }
0x00011910 ldrd r2, r3, [sp, 0xf8] | __asm ("ldrd r2, r3, [var_f8h]");
0x00011914 strd r2, r3, [r4, 0x28] | __asm ("strd r2, r3, [r4, 0x28]");
0x00011918 orrs r3, r2, r3 | r3 = r2 | r3;
| if (r3 != r2) {
0x0001191c streq r5, [sp] | *(sp) = r5;
| }
| if (r3 != r2) {
0x00011920 moveq r3, r8 | r3 = r8;
| }
| if (r3 != r2) {
0x00011924 ldreq r2, [pc, 0x2bc] | r2 = "ubinize";
| }
| if (r3 == r2) {
0x00011928 ldreq r1, [pc, 0x3f4] | r1 = "_s:_error_:_file___s__referred_from_section___s__is_empty";
| goto label_66;
| }
| if (r3 == r2) {
| label_66:
0x0001192c beq 0x116f0 | goto label_13;
| }
0x00011930 mov r3, r8 | r3 = r8;
0x00011934 mov r2, r5 | r2 = r5;
0x00011938 mov r1, sb | r1 = sb;
0x0001193c ldr r0, [pc, 0x3e4] | r0 = "_s:_error_:_file___s__referred_from_section___s__is_empty";
0x00011940 bl 0x10a94 | printf ("_s:_error_:_file___s__referred_from_section___s__is_empty", r1, r2, r3);
0x00011944 ldrd r0, r1, [r4, 0x28] | __asm ("ldrd r0, r1, [r4, 0x28]");
0x00011948 mov r2, 1 | r2 = 1;
0x0001194c bl 0x12f1c | fcn_00012f1c (r0, r1);
0x00011950 mov r0, 0xa | r0 = 0xa;
0x00011954 bl 0x10a7c | putchar (r0);
0x00011958 b 0x11894 | goto label_16;
| label_64:
0x0001195c str fp, [r4, 0x14] | *((r4 + 0x14)) = fp;
0x00011960 bl 0x10c20 | r0 = strlen (r0);
0x00011964 cmp r0, 0x7f |
0x00011968 str r0, [r4, 0x18] | *((r4 + 0x18)) = r0;
| if (r0 >= 0x7f) {
0x0001196c bls 0x11988 |
0x00011970 mov r3, 0x7f | r3 = 0x7f;
0x00011974 str r3, [sp] | *(sp) = r3;
0x00011978 ldr r2, [pc, 0x268] | r2 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x0001197c mov r3, fp | r3 = fp;
0x00011980 ldr r1, [pc, 0x3a4] | r1 = "%s: volume size was not specified in section \"%s\", assume minimum to fit image \"%s\";
0x00011984 b 0x116f0 | goto label_13;
| }
0x00011988 ldr r3, [r6, 0x28] | r3 = *((r6 + 0x28));
0x0001198c cmp r3, 0 |
| if (r3 != 0) {
0x00011990 beq 0x119a4 |
0x00011994 mov r2, fp | r2 = fp;
0x00011998 mov r1, sb | r1 = sb;
0x0001199c ldr r0, [pc, 0x38c] | r0 = "%s: error!: too long volume name in section \"%s\", max. is %d characters\n";
0x000119a0 bl 0x10a94 | printf ("%s: error!: too long volume name in section \"%s\", max. is %d characters\n", r1, r2);
| }
0x000119a4 mov r2, r5 | r2 = r5;
0x000119a8 ldr r1, [pc, 0x384] | r1 = "_s:_volume_name:__s";
0x000119ac add r0, sp, 0x130 | r0 += s;
0x000119b0 bl 0x10bf0 | sprintf (r0, "_s:_volume_name:__s", r2);
0x000119b4 mvn r2, 0 | r2 = ~0;
0x000119b8 add r1, sp, 0x130 | r1 += s;
0x000119bc ldr r0, [r6, 0x2c] | r0 = *((r6 + 0x2c));
0x000119c0 bl 0x134f0 | r0 = fcn_000134f0 (r0, r1);
0x000119c4 cmn r0, 1 |
0x000119c8 mov r3, r0 | r3 = r0;
| if (r0 != 1) {
0x000119cc moveq r3, 1 | r3 = 1;
| }
0x000119d0 str r0, [r4, 8] | *((r4 + 8)) = r0;
| if (r0 != 1) {
0x000119d4 streq r3, [r4, 8] | *((r4 + 8)) = r3;
| }
| if (r0 == 1) {
0x000119d8 beq 0x119f4 | goto label_67;
| }
0x000119dc ldr r2, [r4] | r2 = *(r4);
0x000119e0 cmp r2, 0 |
| if (r2 >= 0) {
0x000119e4 strlt r5, [sp] | *(sp) = r5;
| }
| if (r2 >= 0) {
0x000119e8 ldrlt r2, [pc, 0x1f8] | r2 = "ubinize";
| }
| if (r2 < 0) {
0x000119ec ldrlt r1, [pc, 0x344] | r1 = "_s:_error_:_negative_volume_alignement__d_in_section___s_";
| goto label_68;
| }
| if (r2 < 0) {
| label_68:
0x000119f0 blt 0x116f0 | goto label_13;
| }
| label_67:
0x000119f4 ldr r3, [r6, 0x28] | r3 = *((r6 + 0x28));
0x000119f8 cmp r3, 0 |
| if (r3 != 0) {
0x000119fc beq 0x11a10 |
0x00011a00 ldr r2, [r4, 8] | r2 = *((r4 + 8));
0x00011a04 mov r1, sb | r1 = sb;
0x00011a08 ldr r0, [pc, 0x32c] | r0 = "_s:_error_:_negative_volume_alignement__d_in_section___s_";
0x00011a0c bl 0x10a94 | printf ("_s:_error_:_negative_volume_alignement__d_in_section___s_", r1, r2);
| }
0x00011a10 mov r2, r5 | r2 = r5;
0x00011a14 ldr r1, [pc, 0x324] | r1 = "%s: volume alignment: %d\n";
0x00011a18 add r0, sp, 0x130 | r0 += s;
0x00011a1c bl 0x10bf0 | sprintf (r0, "%s: volume alignment: %d\n", r2);
0x00011a20 mov r2, 0 | r2 = 0;
0x00011a24 add r1, sp, 0x130 | r1 += s;
0x00011a28 ldr r0, [r6, 0x2c] | r0 = *((r6 + 0x2c));
0x00011a2c bl 0x134b4 | r0 = fcn_000134b4 (r0, r1);
0x00011a30 subs fp, r0, 0 |
| if (fp == r0) {
0x00011a34 beq 0x11a6c | goto label_69;
| }
0x00011a38 ldr r1, [pc, 0x304] | r1 = "%s:vol_flags";
0x00011a3c bl 0x10be4 | r0 = strcmp (r0, "%s:vol_flags");
0x00011a40 cmp r0, 0 |
| if (r0 != 0) {
0x00011a44 bne 0x11ac0 | goto label_70;
| }
0x00011a48 ldr r3, [r6, 0x28] | r3 = *((r6 + 0x28));
0x00011a4c cmp r3, 0 |
| if (r3 != 0) {
0x00011a50 beq 0x11a60 |
0x00011a54 mov r1, sb | r1 = sb;
0x00011a58 ldr r0, [pc, 0x2e8] | r0 = "autoresize";
0x00011a5c bl 0x10a94 | printf ("autoresize", r1);
| }
0x00011a60 ldrb r3, [r4, 0x30] | r3 = *((r4 + 0x30));
0x00011a64 orr r3, r3, 1 | r3 |= 1;
| do {
0x00011a68 strb r3, [r4, 0x30] | *((r4 + 0x30)) = r3;
| label_69:
0x00011a6c ldr fp, [sp, 0x3c] | fp = var_3ch;
0x00011a70 ldr r1, [r4, 8] | r1 = *((r4 + 8));
0x00011a74 mov r0, fp | r0 = fp;
0x00011a78 bl 0x14124 | fcn_00014124 (r0, r1);
0x00011a7c sub r2, fp, r1 | r2 = fp - r1;
0x00011a80 str r1, [r4, 0xc] | *((r4 + 0xc)) = r1;
0x00011a84 ldr r1, [r4, 4] | r1 = *((r4 + 4));
0x00011a88 str r2, [r4, 0x10] | *((r4 + 0x10)) = r2;
0x00011a8c cmp r1, 1 |
0x00011a90 asr r3, r2, 0x1f | r3 = r2 >> 0x1f;
| if (r1 != 1) {
0x00011a94 bne 0x11b0c | goto label_71;
| }
0x00011a98 ldrd r0, r1, [r4, 0x28] | __asm ("ldrd r0, r1, [r4, 0x28]");
| label_18:
0x00011a9c adds sl, r0, r2 | sl = r0 + r2;
0x00011aa0 adc fp, r1, r3 | __asm ("adc fp, r1, r3");
0x00011aa4 subs r0, sl, 1 | r0 = sl - 1;
0x00011aa8 sbc r1, fp, 0 | __asm ("sbc r1, envp");
0x00011aac bl 0x14144 | fcn_00014144 (r0);
0x00011ab0 mov r3, 0 | r3 = 0;
0x00011ab4 str r3, [r4, 0x1c] | *((r4 + 0x1c)) = r3;
0x00011ab8 str r0, [r4, 0x20] | *((r4 + 0x20)) = r0;
0x00011abc b 0x11548 | goto label_17;
| label_70:
0x00011ac0 ldr r1, [pc, 0x284] | r1 = "%s: autoresize flags found\n";
0x00011ac4 mov r0, fp | r0 = fp;
0x00011ac8 bl 0x10be4 | r0 = strcmp (r0, "%s: autoresize flags found\n");
0x00011acc cmp r0, 0 |
| if (r0 != 0) {
0x00011ad0 bne 0x11af8 | goto label_72;
| }
0x00011ad4 ldr r3, [r6, 0x28] | r3 = *((r6 + 0x28));
0x00011ad8 cmp r3, 0 |
| if (r3 != 0) {
0x00011adc beq 0x11aec |
0x00011ae0 mov r1, sb | r1 = sb;
0x00011ae4 ldr r0, [pc, 0x264] | r0 = "skip-check";
0x00011ae8 bl 0x10a94 | printf ("skip-check", r1);
| }
0x00011aec ldrb r3, [r4, 0x30] | r3 = *((r4 + 0x30));
0x00011af0 orr r3, r3, 2 | r3 |= 2;
0x00011af4 b 0x11a68 |
| } while (1);
| label_72:
0x00011af8 str r5, [sp] | *(sp) = r5;
0x00011afc mov r3, fp | r3 = fp;
0x00011b00 ldr r2, [pc, 0xe0] | r2 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x00011b04 ldr r1, [pc, 0x248] | r1 = "_s:_skip_check_flag_found";
0x00011b08 b 0x116f0 | goto label_13;
| label_71:
0x00011b0c ldrd r0, r1, [sp, 0x90] | __asm ("ldrd r0, r1, [var_90h]");
0x00011b10 b 0x11a9c | goto label_18;
| label_53:
0x00011b14 ldr r1, [sp, 0x28] | r1 = var_28h;
0x00011b18 ldr r3, [r4] | r3 = *(r4);
0x00011b1c ldr r1, [r1, fp] | r1 = *((r1 + fp));
0x00011b20 cmp r3, r1 |
| if (r3 != r1) {
0x00011b24 streq r5, [sp] | *(sp) = r5;
| }
| if (r3 != r1) {
0x00011b28 ldreq r2, [pc, 0xb8] | r2 = "ubinize";
| }
| if (r3 == r1) {
0x00011b2c ldreq r1, [pc, 0x224] | r1 = "%s: error!: volume IDs must be unique, but ID %d in section \"%s\" is not\n";
| goto label_73;
| }
| if (r3 == r1) {
| label_73:
0x00011b30 beq 0x116f0 | goto label_13;
| }
0x00011b34 str r2, [sp, 0x34] | var_34h = r2;
0x00011b38 ldr r2, [sp, 0x28] | r2 = var_28h;
0x00011b3c ldr r3, [r4, 0x14] | r3 = *((r4 + 0x14));
0x00011b40 add r1, r2, fp | r1 = r2 + fp;
0x00011b44 mov r0, r3 | r0 = r3;
0x00011b48 ldr r1, [r1, 0x14] | r1 = *((r1 + 0x14));
0x00011b4c str r3, [sp, 0x30] | var_30h = r3;
0x00011b50 bl 0x10be4 | strcmp (r0, r1);
0x00011b54 add fp, fp, 0x38 |
0x00011b58 ldr r3, [sp, 0x30] | r3 = var_30h;
0x00011b5c ldr r2, [sp, 0x34] | r2 = var_34h;
0x00011b60 cmp r0, 0 |
| if (r0 != 0) {
0x00011b64 bne 0x11578 | goto label_19;
| }
0x00011b68 str r5, [sp] | *(sp) = r5;
0x00011b6c ldr r2, [pc, 0x74] | r2 = "-o, --output=<file name> output file name\n-p, --peb-size=<bytes> size of the physical eraseblock of the flash\n this UBI image is created for in bytes,\n kilobytes (KiB), or megabytes (MiB)\n (mandatory parameter)\n-m, --min-io-size=<bytes> minimum input/output unit size of the flash\n in bytes\n-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n headers, e.g. sub-page size in case of NAND\n flash (equivalent to the minimum input/output\n unit size by default)\n-O, --vid-hdr-offset=<num> offset if the VID header from start of the\n physical eraseblock (default is the next\n minimum I/O unit or sub-page after the EC\n header)\n-e, --erase-counter=<num> the erase counter value to put to EC headers\n (default is 0)\n-x, --ubi-ver=<num> UBI version number to put to EC headers\n (default is 1)\n-Q, --image-seq=<num> 32-bit UBI image sequence number to use\n (by default a random number is picked)\n-v, --verbose be verbose\n-h, --help print help message\n-V, --version print program version\n\n";
0x00011b70 ldr r1, [pc, 0x1e4] | r1 = "%s: error!: volume IDs must be unique, but ID %d in section \"%s\" is not\n";
0x00011b74 b 0x116f0 | goto label_13;
| label_54:
0x00011b78 tst r3, 1 |
| if ((r3 & 1) == 0) {
0x00011b7c beq 0x11b9c | goto label_74;
| }
0x00011b80 ldr r3, [sp, 0x20] | r3 = var_20h;
0x00011b84 cmp r3, 0 |
| if (r3 == 0) {
0x00011b88 ldrne r2, [pc, 0x58] | r2 = "ubinize";
| }
| if (r3 != 0) {
0x00011b8c ldrne r1, [pc, 0x1cc] | r1 = "%s: error!: only one volume is allowed to have auto-resize flag\n";
| goto label_75;
| }
| if (r3 != 0) {
| label_75:
0x00011b90 bne 0x11004 | goto label_7;
| }
| label_74:
0x00011b9c ldr r2, [sp, 0x2c] | r2 = ptr;
0x00011ba0 mov r1, r4 | r1 = r4;
0x00011ba4 add r0, sp, 0x3c | r0 += var_3ch;
0x00011ba8 bl 0x121f8 | fcn_000121f8 (r0, r1, r2);
0x00011bac subs fp, r0, 0 |
| if (fp == var_3ch) {
0x00011bb0 beq 0x11d8c | void (*0x11d8c)() ();
| }
| label_49:
0x00011eb4 ldr r3, [r6, 0x28] | r3 = *((r6 + 0x28));
0x00011eb8 cmp r3, 0 |
| if (r3 != 0) {
0x00011ebc beq 0x11ecc |
0x00011ec0 ldr r1, [pc, -0x144] | r1 = "ubinize";
0x00011ec4 ldr r0, [pc, -0x144] | r0 = "_s:_done";
0x00011ec8 bl 0x10a94 | printf ("_s:_done", "ubinize");
| }
0x00011ecc ldr r0, [sp, 0x28] | r0 = var_28h;
0x00011ed0 bl 0x10c74 | free (r0);
0x00011ed4 ldr r0, [r6, 0x2c] | r0 = *((r6 + 0x2c));
0x00011ed8 bl 0x13a84 | fcn_00013a84 (r0);
0x00011edc ldr r0, [sp, 0x2c] | r0 = ptr;
0x00011ee0 bl 0x10c74 | free (r0);
0x00011ee4 ldr r0, [r6, 8] | r0 = *((r6 + 8));
0x00011ee8 bl 0x10c5c | close (r0);
0x00011eec b 0x10e6c | goto label_6;
| }
[*] Function fprintf used 42 times ubinize
