Skip to content

Instantly share code, notes, and snippets.

@hanetzer

hanetzer/$ cat bootblock.S;

Created October 6, 2020 15:00
Show Gist options
  • Save hanetzer/1cdf8de484a16789165d6d55f90de1af to your computer and use it in GitHub Desktop.
Save hanetzer/1cdf8de484a16789165d6d55f90de1af to your computer and use it in GitHub Desktop.
Download ZIP
$ cat bootblock.S;
Raw
$ cat bootblock.S;
$ cat bootblock.S
build/cbfs/fallback/bootblock.elf: file format elf64-powerpc
Disassembly of section .text:
0000000000000000 <_start>:
#define SAVE_GPR(reg,sp) std r##reg,STACK_GPR##reg(sp)
#define REST_GPR(reg,sp) ld r##reg,STACK_GPR##reg(sp)
ENTRY(_start)
FIXUP_ENDIAN
0: 08 00 00 48 tdi 0,r0,72
4: 48 00 00 2c b 30 <_start+0x30>
8: a6 00 60 7d .long 0xa600607d
c: 01 00 6b 69 .long 0x1006b69
10: a6 4b 7b 7d lhzu r18,31613(r11)
14: a6 02 68 7d lhzu r16,26749(r2)
18: 05 00 9f 42 .long 0x5009f42
1c: a6 02 88 7d lhzu r16,-30595(r2)
20: 14 00 8c 39 .long 0x14008c39
24: a6 4b 9a 7d lhzu r18,-25987(r11)
28: a6 03 68 7d lhzu r16,26749(r3)
2c: 24 02 00 4c dozi r0,r2,76
/* Set thread priority high. */
or 2,2,2
30: 7c 42 13 78 mr r2,r2
/* Clear MSR[TA] (bit 1) */
mfmsr r20
34: 7e 80 00 a6 mfmsr r20
/* Clear bit 1 - result [1-63,0] */
rldicl r20, r20, 1, 1
38: 7a 94 08 40 rldicl r20,r20,1,1
/* Rotate right 1 - result [0,63] */
rotrdi r20, r20, 1
3c: 7a 94 f8 02 rotldi r20,r20,63
/* Set up srr0/srr1 to enable new MSR */
mtmsr r20
40: 7e 80 01 24 mtmsr r20
/* Want to default NAP value */
lis r20, 0x31
44: 3e 80 00 31 lis r20,49
/* Value is 0x310001 */
ori r20, r20, 1
48: 62 94 00 01 ori r20,r20,1
/* Set actual psscr */
mtspr 855, r20
4c: 7e 97 d3 a6 mtspr 855,r20
0000000000000050 <_start_postmsr>:
_start_postmsr:
/* bl relative_toc */
/* Determine if this is the first thread */
li r4, 2
50: 38 80 00 02 li r4,2
/* Read spinlock value */
lis r20, kernel_other_thread_spinlock@ha
54: 3e 80 00 00 lis r20,0
56: R_PPC64_ADDR16_HA kernel_other_thread_spinlock
ori r20, r20, kernel_other_thread_spinlock@l
58: 62 94 4d 80 ori r20,r20,19840
5a: R_PPC64_ADDR16_LO kernel_other_thread_spinlock
lwsync
5c: 7c 20 04 ac lwsync
1:
ldarx r3, 0, r20
60: 7c 60 a0 a8 ldarx r3,0,r20
cmpwi r3, 0
64: 2c 03 00 00 cmpwi r3,0
bnel cr0, _other_thread_spinlock
68: 40 82 20 31 bnel 2098 <_other_thread_spinlock>
68: R_PPC64_REL14 _other_thread_spinlock
stdcx. r4, 0, r20
6c: 7c 80 a1 ad stdcx. r4,0,r20
bne 1b
70: 40 82 ff f0 bne 60 <_start_postmsr+0x10>
isync
74: 4c 00 01 2c isync
b call_bootblock
78: 48 00 20 44 b 20bc <call_bootblock>
78: R_PPC64_REL24 .text+0x20bc
...
0000000000000100 <sreset_vector>:
/* .balign 8 */
/* p_toc: .8byte _toc + 0x8000 - 0b */
. = 0x100
sreset_vector:
FIXUP_ENDIAN
100: 08 00 00 48 tdi 0,r0,72
104: 48 00 00 2c b 130 <sreset_vector+0x30>
108: a6 00 60 7d .long 0xa600607d
10c: 01 00 6b 69 .long 0x1006b69
110: a6 4b 7b 7d lhzu r18,31613(r11)
114: a6 02 68 7d lhzu r16,26749(r2)
118: 05 00 9f 42 .long 0x5009f42
11c: a6 02 88 7d lhzu r16,-30595(r2)
120: 14 00 8c 39 .long 0x14008c39
124: a6 4b 9a 7d lhzu r18,-25987(r11)
128: a6 03 68 7d lhzu r16,26749(r3)
12c: 24 02 00 4c dozi r0,r2,76
li r3, 0
130: 38 60 00 00 li r3,0
oris r3, r3, 0xa
134: 64 63 00 0a oris r3,r3,10
b _start
138: 4b ff fe c8 b 0 <_start>
138: R_PPC64_REL24 _start
...
. = 0x180
. = 0x200
mtsprg0 r3
200: 7c 70 43 a6 mtsprg 0,r3
mtsprg1 r4
204: 7c 91 43 a6 mtsprg 1,r4
mfspr r3, SPR_SRR1
208: 7c 7b 02 a6 mfsrr1 r3
mfcr r4
20c: 7c 80 00 26 mfcr r4
rldicl. r3, r3, 48, 62
210: 78 63 87 a3 rldicl. r3,r3,48,62
bne 1f
214: 40 82 00 14 bne 228 <sreset_vector+0x128>
mtcr r4
218: 7c 8f f1 20 mtcr r4
mfspr r3, SPR_CFAR
21c: 7c 7c 02 a6 mfcfar r3
li r4, 0x200
220: 38 80 02 00 li r4,512
b _exception
224: 48 00 1b dc b 1e00 <_exception>
1:
cmpdi r3, 0x1
228: 2c 23 00 01 cmpdi r3,1
bne 2f
22c: 40 82 00 10 bne 23c <sreset_vector+0x13c>
LOAD_IMM32(r3, sreset_vector - _start)
230: 3c 60 00 00 lis r3,0
234: 60 63 01 00 ori r3,r3,256
b 3f
238: 48 00 00 0c b 244 <sreset_vector+0x144>
2:
LOAD_IMM32(r3, sreset_vector - _start)
23c: 3c 60 00 00 lis r3,0
240: 60 63 01 00 ori r3,r3,256
3:
LOAD_IMM64(r5, _start)
244: 3c a0 00 00 lis r5,0
246: R_PPC64_ADDR16_HIGHEST _start
248: 60 a5 00 00 ori r5,r5,0
24a: R_PPC64_ADDR16_HIGHER _start
24c: 78 a5 07 c6 rldicr r5,r5,32,31
250: 64 a5 00 00 oris r5,r5,0
252: R_PPC64_ADDR16_HI _start
254: 60 a5 00 00 ori r5,r5,0
256: R_PPC64_ADDR16_LO _start
add r3, r5, r3
258: 7c 65 1a 14 add r3,r5,r3
mtctr r3
25c: 7c 69 03 a6 mtctr r3
li r3, 0x200
260: 38 60 02 00 li r3,512
bctr
264: 4e 80 04 20 bctr
...
mfspr r3, SPR_CFAR ;\
mtsprg1 r4 ;\
li r4, nr ;\
b _exception
EXCEPTION(0x300)
300: 7c 70 43 a6 mtsprg 0,r3
304: 7c 7c 02 a6 mfcfar r3
308: 7c 91 43 a6 mtsprg 1,r4
30c: 38 80 03 00 li r4,768
310: 48 00 1a f0 b 1e00 <_exception>
...
EXCEPTION(0x380)
380: 7c 70 43 a6 mtsprg 0,r3
384: 7c 7c 02 a6 mfcfar r3
388: 7c 91 43 a6 mtsprg 1,r4
38c: 38 80 03 80 li r4,896
390: 48 00 1a 70 b 1e00 <_exception>
...
EXCEPTION(0x400)
400: 7c 70 43 a6 mtsprg 0,r3
404: 7c 7c 02 a6 mfcfar r3
408: 7c 91 43 a6 mtsprg 1,r4
40c: 38 80 04 00 li r4,1024
410: 48 00 19 f0 b 1e00 <_exception>
...
EXCEPTION(0x480)
480: 7c 70 43 a6 mtsprg 0,r3
484: 7c 7c 02 a6 mfcfar r3
488: 7c 91 43 a6 mtsprg 1,r4
48c: 38 80 04 80 li r4,1152
490: 48 00 19 70 b 1e00 <_exception>
...
EXCEPTION(0x500)
500: 7c 70 43 a6 mtsprg 0,r3
504: 7c 7c 02 a6 mfcfar r3
508: 7c 91 43 a6 mtsprg 1,r4
50c: 38 80 05 00 li r4,1280
510: 48 00 18 f0 b 1e00 <_exception>
...
EXCEPTION(0x600)
600: 7c 70 43 a6 mtsprg 0,r3
604: 7c 7c 02 a6 mfcfar r3
608: 7c 91 43 a6 mtsprg 1,r4
60c: 38 80 06 00 li r4,1536
610: 48 00 17 f0 b 1e00 <_exception>
...
EXCEPTION(0x700)
700: 7c 70 43 a6 mtsprg 0,r3
704: 7c 7c 02 a6 mfcfar r3
708: 7c 91 43 a6 mtsprg 1,r4
70c: 38 80 07 00 li r4,1792
710: 48 00 16 f0 b 1e00 <_exception>
...
EXCEPTION(0x800)
800: 7c 70 43 a6 mtsprg 0,r3
804: 7c 7c 02 a6 mfcfar r3
808: 7c 91 43 a6 mtsprg 1,r4
80c: 38 80 08 00 li r4,2048
810: 48 00 15 f0 b 1e00 <_exception>
...
EXCEPTION(0x900)
900: 7c 70 43 a6 mtsprg 0,r3
904: 7c 7c 02 a6 mfcfar r3
908: 7c 91 43 a6 mtsprg 1,r4
90c: 38 80 09 00 li r4,2304
910: 48 00 14 f0 b 1e00 <_exception>
...
EXCEPTION(0x980)
980: 7c 70 43 a6 mtsprg 0,r3
984: 7c 7c 02 a6 mfcfar r3
988: 7c 91 43 a6 mtsprg 1,r4
98c: 38 80 09 80 li r4,2432
990: 48 00 14 70 b 1e00 <_exception>
...
EXCEPTION(0xa00)
a00: 7c 70 43 a6 mtsprg 0,r3
a04: 7c 7c 02 a6 mfcfar r3
a08: 7c 91 43 a6 mtsprg 1,r4
a0c: 38 80 0a 00 li r4,2560
a10: 48 00 13 f0 b 1e00 <_exception>
...
EXCEPTION(0xb00)
b00: 7c 70 43 a6 mtsprg 0,r3
b04: 7c 7c 02 a6 mfcfar r3
b08: 7c 91 43 a6 mtsprg 1,r4
b0c: 38 80 0b 00 li r4,2816
b10: 48 00 12 f0 b 1e00 <_exception>
...
EXCEPTION(0xc00)
c00: 7c 70 43 a6 mtsprg 0,r3
c04: 7c 7c 02 a6 mfcfar r3
c08: 7c 91 43 a6 mtsprg 1,r4
c0c: 38 80 0c 00 li r4,3072
c10: 48 00 11 f0 b 1e00 <_exception>
...
EXCEPTION(0xd00)
d00: 7c 70 43 a6 mtsprg 0,r3
d04: 7c 7c 02 a6 mfcfar r3
d08: 7c 91 43 a6 mtsprg 1,r4
d0c: 38 80 0d 00 li r4,3328
d10: 48 00 10 f0 b 1e00 <_exception>
...
EXCEPTION(0xe00)
e00: 7c 70 43 a6 mtsprg 0,r3
e04: 7c 7c 02 a6 mfcfar r3
e08: 7c 91 43 a6 mtsprg 1,r4
e0c: 38 80 0e 00 li r4,3584
e10: 48 00 0f f0 b 1e00 <_exception>
...
EXCEPTION(0xe20)
e20: 7c 70 43 a6 mtsprg 0,r3
e24: 7c 7c 02 a6 mfcfar r3
e28: 7c 91 43 a6 mtsprg 1,r4
e2c: 38 80 0e 20 li r4,3616
e30: 48 00 0f d0 b 1e00 <_exception>
...
EXCEPTION(0xe40)
e40: 7c 70 43 a6 mtsprg 0,r3
e44: 7c 7c 02 a6 mfcfar r3
e48: 7c 91 43 a6 mtsprg 1,r4
e4c: 38 80 0e 40 li r4,3648
e50: 48 00 0f b0 b 1e00 <_exception>
...
EXCEPTION(0xe60)
e60: 7c 70 43 a6 mtsprg 0,r3
e64: 7c 7c 02 a6 mfcfar r3
e68: 7c 91 43 a6 mtsprg 1,r4
e6c: 38 80 0e 60 li r4,3680
e70: 48 00 0f 90 b 1e00 <_exception>
...
EXCEPTION(0xe80)
e80: 7c 70 43 a6 mtsprg 0,r3
e84: 7c 7c 02 a6 mfcfar r3
e88: 7c 91 43 a6 mtsprg 1,r4
e8c: 38 80 0e 80 li r4,3712
e90: 48 00 0f 70 b 1e00 <_exception>
...
EXCEPTION(0xf00)
f00: 7c 70 43 a6 mtsprg 0,r3
f04: 7c 7c 02 a6 mfcfar r3
f08: 7c 91 43 a6 mtsprg 1,r4
f0c: 38 80 0f 00 li r4,3840
f10: 48 00 0e f0 b 1e00 <_exception>
...
EXCEPTION(0xf20)
f20: 7c 70 43 a6 mtsprg 0,r3
f24: 7c 7c 02 a6 mfcfar r3
f28: 7c 91 43 a6 mtsprg 1,r4
f2c: 38 80 0f 20 li r4,3872
f30: 48 00 0e d0 b 1e00 <_exception>
...
EXCEPTION(0xf40)
f40: 7c 70 43 a6 mtsprg 0,r3
f44: 7c 7c 02 a6 mfcfar r3
f48: 7c 91 43 a6 mtsprg 1,r4
f4c: 38 80 0f 40 li r4,3904
f50: 48 00 0e b0 b 1e00 <_exception>
...
EXCEPTION(0xf60)
f60: 7c 70 43 a6 mtsprg 0,r3
f64: 7c 7c 02 a6 mfcfar r3
f68: 7c 91 43 a6 mtsprg 1,r4
f6c: 38 80 0f 60 li r4,3936
f70: 48 00 0e 90 b 1e00 <_exception>
...
EXCEPTION(0xf80)
f80: 7c 70 43 a6 mtsprg 0,r3
f84: 7c 7c 02 a6 mfcfar r3
f88: 7c 91 43 a6 mtsprg 1,r4
f8c: 38 80 0f 80 li r4,3968
f90: 48 00 0e 70 b 1e00 <_exception>
...
EXCEPTION(0x1000)
1000: 7c 70 43 a6 mtsprg 0,r3
1004: 7c 7c 02 a6 mfcfar r3
1008: 7c 91 43 a6 mtsprg 1,r4
100c: 38 80 10 00 li r4,4096
1010: 48 00 0d f0 b 1e00 <_exception>
...
EXCEPTION(0x1100)
1100: 7c 70 43 a6 mtsprg 0,r3
1104: 7c 7c 02 a6 mfcfar r3
1108: 7c 91 43 a6 mtsprg 1,r4
110c: 38 80 11 00 li r4,4352
1110: 48 00 0c f0 b 1e00 <_exception>
...
EXCEPTION(0x1200)
1200: 7c 70 43 a6 mtsprg 0,r3
1204: 7c 7c 02 a6 mfcfar r3
1208: 7c 91 43 a6 mtsprg 1,r4
120c: 38 80 12 00 li r4,4608
1210: 48 00 0b f0 b 1e00 <_exception>
...
EXCEPTION(0x1300)
1300: 7c 70 43 a6 mtsprg 0,r3
1304: 7c 7c 02 a6 mfcfar r3
1308: 7c 91 43 a6 mtsprg 1,r4
130c: 38 80 13 00 li r4,4864
1310: 48 00 0a f0 b 1e00 <_exception>
...
EXCEPTION(0x1400)
1400: 7c 70 43 a6 mtsprg 0,r3
1404: 7c 7c 02 a6 mfcfar r3
1408: 7c 91 43 a6 mtsprg 1,r4
140c: 38 80 14 00 li r4,5120
1410: 48 00 09 f0 b 1e00 <_exception>
...
EXCEPTION(0x1500)
1500: 7c 70 43 a6 mtsprg 0,r3
1504: 7c 7c 02 a6 mfcfar r3
1508: 7c 91 43 a6 mtsprg 1,r4
150c: 38 80 15 00 li r4,5376
1510: 48 00 08 f0 b 1e00 <_exception>
...
EXCEPTION(0x1600)
1600: 7c 70 43 a6 mtsprg 0,r3
1604: 7c 7c 02 a6 mfcfar r3
1608: 7c 91 43 a6 mtsprg 1,r4
160c: 38 80 16 00 li r4,5632
1610: 48 00 07 f0 b 1e00 <_exception>
...
0000000000001e00 <_exception>:
. = 0x1e00
_exception:
stdu r1, -INT_FRAMESIZE(r1)
1e00: f8 21 fc f1 stdu r1,-784(r1)
std r3, STACK_CFAR(r1)
1e04: f8 61 01 b8 std r3,440(r1)
std r4, STACK_TYPE(r1)
1e08: f8 81 00 80 std r4,128(r1)
mfspr r3, SPR_SRR0
1e0c: 7c 7a 02 a6 mfsrr0 r3
mfspr r4, SPR_SRR1
1e10: 7c 9b 02 a6 mfsrr1 r4
std r3, STACK_SRR0(r1)
1e14: f8 61 01 c0 std r3,448(r1)
std r3, 16(r1)
1e18: f8 61 00 10 std r3,16(r1)
std r4, STACK_SRR1(r1)
1e1c: f8 81 01 c8 std r4,456(r1)
mfspr r3, SPR_DSISR
1e20: 7c 72 02 a6 mfdsisr r3
mfspr r4, SPR_DAR
1e24: 7c 93 02 a6 mfdar r4
stw r3, STACK_DSISR(r1)
1e28: 90 61 01 90 stw r3,400(r1)
std r4, STACK_DAR(r1)
1e2c: f8 81 01 e0 std r4,480(r1)
mfmsr r3
1e30: 7c 60 00 a6 mfmsr r3
li r4, MSR_RI
1e34: 38 80 00 02 li r4,2
std r3,STACK_MSR(r1)
1e38: f8 61 01 b0 std r3,432(r1)
mtmsrd r4,1
1e3c: 7c 81 01 64 mtmsrd r4,1
mfspr r3, SPR_HSRR0
1e40: 7c 7a 4a a6 mfspr r3,314
mfspr r4, SPR_HSRR1
1e44: 7c 9b 4a a6 mfspr r4,315
std r3, STACK_HSRR0(r1)
1e48: f8 61 01 d0 std r3,464(r1)
std r4, STACK_HSRR1(r1)
1e4c: f8 81 01 d8 std r4,472(r1)
mfsprg0 r3
1e50: 7c 70 42 a6 mfsprg r3,0
mfsprg1 r4
1e54: 7c 91 42 a6 mfsprg r4,1
SAVE_GPR(0, r1)
1e58: f8 01 00 88 std r0,136(r1)
SAVE_GPR(1, r1)
1e5c: f8 21 00 90 std r1,144(r1)
SAVE_GPR(2, r1)
1e60: f8 41 00 98 std r2,152(r1)
SAVE_GPR(3, r1)
1e64: f8 61 00 a0 std r3,160(r1)
SAVE_GPR(4, r1)
1e68: f8 81 00 a8 std r4,168(r1)
SAVE_GPR(5, r1)
1e6c: f8 a1 00 b0 std r5,176(r1)
SAVE_GPR(6, r1)
1e70: f8 c1 00 b8 std r6,184(r1)
SAVE_GPR(7, r1)
1e74: f8 e1 00 c0 std r7,192(r1)
SAVE_GPR(8, r1)
1e78: f9 01 00 c8 std r8,200(r1)
SAVE_GPR(9, r1)
1e7c: f9 21 00 d0 std r9,208(r1)
SAVE_GPR(10, r1)
1e80: f9 41 00 d8 std r10,216(r1)
SAVE_GPR(11, r1)
1e84: f9 61 00 e0 std r11,224(r1)
SAVE_GPR(12, r1)
1e88: f9 81 00 e8 std r12,232(r1)
SAVE_GPR(13, r1)
1e8c: f9 a1 00 f0 std r13,240(r1)
SAVE_GPR(14, r1)
1e90: f9 c1 00 f8 std r14,248(r1)
SAVE_GPR(15, r1)
1e94: f9 e1 01 00 std r15,256(r1)
SAVE_GPR(16, r1)
1e98: fa 01 01 08 std r16,264(r1)
SAVE_GPR(17, r1)
1e9c: fa 21 01 10 std r17,272(r1)
SAVE_GPR(18, r1)
1ea0: fa 41 01 18 std r18,280(r1)
SAVE_GPR(19, r1)
1ea4: fa 61 01 20 std r19,288(r1)
SAVE_GPR(20, r1)
1ea8: fa 81 01 28 std r20,296(r1)
SAVE_GPR(21, r1)
1eac: fa a1 01 30 std r21,304(r1)
SAVE_GPR(22, r1)
1eb0: fa c1 01 38 std r22,312(r1)
SAVE_GPR(23, r1)
1eb4: fa e1 01 40 std r23,320(r1)
SAVE_GPR(24, r1)
1eb8: fb 01 01 48 std r24,328(r1)
SAVE_GPR(25, r1)
1ebc: fb 21 01 50 std r25,336(r1)
SAVE_GPR(26, r1)
1ec0: fb 41 01 58 std r26,344(r1)
SAVE_GPR(27, r1)
1ec4: fb 61 01 60 std r27,352(r1)
SAVE_GPR(28, r1)
1ec8: fb 81 01 68 std r28,360(r1)
SAVE_GPR(29, r1)
1ecc: fb a1 01 70 std r29,368(r1)
SAVE_GPR(30, r1)
1ed0: fb c1 01 78 std r30,376(r1)
SAVE_GPR(31, r1)
1ed4: fb e1 01 80 std r31,384(r1)
mfcr r3
1ed8: 7c 60 00 26 mfcr r3
mfxer r4
1edc: 7c 81 02 a6 mfxer r4
mfctr r5
1ee0: 7c a9 02 a6 mfctr r5
mflr r6
1ee4: 7c c8 02 a6 mflr r6
stw r3, STACK_CR(r1)
1ee8: 90 61 01 88 stw r3,392(r1)
stw r4, STACK_XER(r1)
1eec: 90 81 01 8c stw r4,396(r1)
std r5, STACK_CTR(r1)
1ef0: f8 a1 01 98 std r5,408(r1)
std r6, STACK_LR(r1)
1ef4: f8 c1 01 a0 std r6,416(r1)
LOAD_IMM64(r3, STACK_INT_MAGIC)
1ef8: 3c 60 0b 1a lis r3,2842
1efc: 60 63 b1 af ori r3,r3,45487
1f00: 78 63 07 c6 rldicr r3,r3,32,31
1f04: 64 63 00 ba oris r3,r3,186
1f08: 60 63 12 34 ori r3,r3,4660
std r3, STACK_MAGIC(r1)
1f0c: f8 61 00 78 std r3,120(r1)
LOAD_IMM64(r4, _start)
1f10: 3c 80 00 00 lis r4,0
1f12: R_PPC64_ADDR16_HIGHEST _start
1f14: 60 84 00 00 ori r4,r4,0
1f16: R_PPC64_ADDR16_HIGHER _start
1f18: 78 84 07 c6 rldicr r4,r4,32,31
1f1c: 64 84 00 00 oris r4,r4,0
1f1e: R_PPC64_ADDR16_HI _start
1f20: 60 84 00 00 ori r4,r4,0
1f22: R_PPC64_ADDR16_LO _start
LOAD_IMM32(r5, _toc_start - _start)
1f24: 3c a0 00 01 lis r5,1
1f26: R_PPC64_REL16_HI _toc_start+0x1f26
1f28: 60 a5 80 00 ori r5,r5,32768
1f2a: R_PPC64_REL16_LO _toc_start+0x1f2a
LOAD_IMM32(r6, exception_entry_foo - _start)
1f2c: 3c c0 00 00 lis r6,0
1f30: 60 c6 1f 48 ori r6,r6,8008
add r2, r4, r5
1f34: 7c 44 2a 14 add r2,r4,r5
mr r3, r1
1f38: 7c 23 0b 78 mr r3,r1
add r4, r4, r6
1f3c: 7c 84 32 14 add r4,r4,r6
mtctr r4
1f40: 7c 89 03 a6 mtctr r4
bctr
1f44: 4e 80 04 20 bctr
0000000000001f48 <exception_entry_foo>:
exception_entry_foo:
bl exception_entry
1f48: 48 00 01 a1 bl 20e8 <exception_entry+0x8>
1f48: R_PPC64_REL24 exception_entry
/* Restore HSRRs in case a NMI interrupted an HSRR-live section
* and the NMI uses HSRRs for something. Possibly does not happen
* in current code, but good to be careful.
*/
ld r3, STACK_HSRR0(r1)
1f4c: e8 61 01 d0 ld r3,464(r1)
ld r4, STACK_HSRR1(r1)
1f50: e8 81 01 d8 ld r4,472(r1)
mtspr SPR_HSRR0, r3
1f54: 7c 7a 4b a6 mtspr 314,r3
mtspr SPR_HSRR1, r4
1f58: 7c 9b 4b a6 mtspr 315,r4
lwz r3, STACK_CR(r1)
1f5c: 80 61 01 88 lwz r3,392(r1)
lwz r4, STACK_XER(r1)
1f60: 80 81 01 8c lwz r4,396(r1)
ld r5, STACK_CTR(r1)
1f64: e8 a1 01 98 ld r5,408(r1)
ld r6, STACK_LR(r1)
1f68: e8 c1 01 a0 ld r6,416(r1)
mtcr r3
1f6c: 7c 6f f1 20 mtcr r3
mtxer r4
1f70: 7c 81 03 a6 mtxer r4
mtctr r5
1f74: 7c a9 03 a6 mtctr r5
mtlr r6
1f78: 7c c8 03 a6 mtlr r6
REST_GPR(0, r1)
1f7c: e8 01 00 88 ld r0,136(r1)
REST_GPR(2, r1)
1f80: e8 41 00 98 ld r2,152(r1)
REST_GPR(4, r1)
1f84: e8 81 00 a8 ld r4,168(r1)
REST_GPR(5, r1)
1f88: e8 a1 00 b0 ld r5,176(r1)
REST_GPR(6, r1)
1f8c: e8 c1 00 b8 ld r6,184(r1)
REST_GPR(7, r1)
1f90: e8 e1 00 c0 ld r7,192(r1)
REST_GPR(8, r1)
1f94: e9 01 00 c8 ld r8,200(r1)
REST_GPR(9, r1)
1f98: e9 21 00 d0 ld r9,208(r1)
REST_GPR(10, r1)
1f9c: e9 41 00 d8 ld r10,216(r1)
REST_GPR(11, r1)
1fa0: e9 61 00 e0 ld r11,224(r1)
REST_GPR(12, r1)
1fa4: e9 81 00 e8 ld r12,232(r1)
REST_GPR(13, r1)
1fa8: e9 a1 00 f0 ld r13,240(r1)
REST_GPR(14, r1)
1fac: e9 c1 00 f8 ld r14,248(r1)
REST_GPR(15, r1)
1fb0: e9 e1 01 00 ld r15,256(r1)
REST_GPR(16, r1)
1fb4: ea 01 01 08 ld r16,264(r1)
REST_GPR(17, r1)
1fb8: ea 21 01 10 ld r17,272(r1)
REST_GPR(18, r1)
1fbc: ea 41 01 18 ld r18,280(r1)
REST_GPR(19, r1)
1fc0: ea 61 01 20 ld r19,288(r1)
REST_GPR(20, r1)
1fc4: ea 81 01 28 ld r20,296(r1)
REST_GPR(21, r1)
1fc8: ea a1 01 30 ld r21,304(r1)
REST_GPR(22, r1)
1fcc: ea c1 01 38 ld r22,312(r1)
REST_GPR(23, r1)
1fd0: ea e1 01 40 ld r23,320(r1)
REST_GPR(24, r1)
1fd4: eb 01 01 48 ld r24,328(r1)
REST_GPR(25, r1)
1fd8: eb 21 01 50 ld r25,336(r1)
REST_GPR(26, r1)
1fdc: eb 41 01 58 ld r26,344(r1)
REST_GPR(27, r1)
1fe0: eb 61 01 60 ld r27,352(r1)
REST_GPR(28, r1)
1fe4: eb 81 01 68 ld r28,360(r1)
REST_GPR(29, r1)
1fe8: eb a1 01 70 ld r29,368(r1)
REST_GPR(30, r1)
1fec: eb c1 01 78 ld r30,376(r1)
REST_GPR(31, r1)
1ff0: eb e1 01 80 ld r31,384(r1)
li r3, 0
1ff4: 38 60 00 00 li r3,0
mtmsrd r3, 1 /* Clear MSR[RI] */
1ff8: 7c 61 01 64 mtmsrd r3,1
ld r3, STACK_SRR0(r1)
1ffc: e8 61 01 c0 ld r3,448(r1)
mtspr SPR_SRR0,r3
2000: 7c 7a 03 a6 mtsrr0 r3
ld r3, STACK_SRR1(r1)
2004: e8 61 01 c8 ld r3,456(r1)
mtspr SPR_SRR1, r3
2008: 7c 7b 03 a6 mtsrr1 r3
REST_GPR(3, r1)
200c: e8 61 00 a0 ld r3,160(r1)
addi r1, r1, INT_FRAMESIZE
2010: 38 21 03 10 addi r1,r1,784
rfid
2014: 4c 00 00 24 rfid
b .
2018: 48 00 00 00 b 2018 <exception_entry_foo+0xd0>
000000000000201c <timer_monotonic_get>:
unsigned long tb;
/* We use a memory clobber to avoid this being
* moved in the instruction stream
*/
asm volatile("mftb %0" : "=r"(tb) : : "memory");
201c: 7d 2c 42 a6 mftb r9
{
// TODO: see src/kernel/timemgr.C
// looks right for now.
uint64_t value = mftb();
uint64_t freq = 512000000ULL;
long usecs = (value * 1000000) / freq;
2020: 3d 40 00 0f lis r10,15
2024: 61 4a 42 40 ori r10,r10,16960
2028: 7d 29 51 d2 mulld r9,r9,r10
202c: 3d 40 1e 84 lis r10,7812
2030: 61 4a 80 00 ori r10,r10,32768
2034: 7d 29 53 92 divdu r9,r9,r10
int timer_sched_callback(struct timeout_callback *tocb, unsigned long us);
/* Set an absolute time to a number of microseconds. */
static inline void mono_time_set_usecs(struct mono_time *mt, long us)
{
mt->microseconds = us;
2038: f9 23 00 00 std r9,0(r3)
mono_time_set_usecs(mt, usecs);
}
203c: 4e 80 00 20 blr
...
000000000000204c <arch_prog_run>:
/* SPDX-License-Identifier: GPL-2.0-only */
#include <program_loading.h>
void arch_prog_run(struct prog *prog)
{
204c: 3c 40 00 02 lis r2,2
204e: R_PPC64_ADDR16_HA .TOC.
2050: 38 42 80 00 addi r2,r2,-32768
2052: R_PPC64_ADDR16_LO .TOC.
2054: 7c 08 02 a6 mflr r0
2058: 7c 69 1b 78 mr r9,r3
void (*doit)(void *) = prog_entry(prog);
doit(prog_entry_arg(prog));
205c: e9 89 00 30 ld r12,48(r9)
{
2060: f8 01 00 10 std r0,16(r1)
2064: f8 21 ff e1 stdu r1,-32(r1)
doit(prog_entry_arg(prog));
2068: e8 63 00 38 ld r3,56(r3)
206c: 7d 89 03 a6 mtctr r12
2070: f8 41 00 18 std r2,24(r1)
2074: 4e 80 04 21 bctrl
2078: e8 41 00 18 ld r2,24(r1)
}
207c: 38 21 00 20 addi r1,r1,32
2080: e8 01 00 10 ld r0,16(r1)
2084: 7c 08 03 a6 mtlr r0
2088: 4e 80 00 20 blr
208c: 00 00 00 00 .long 0x0
2090: 00 00 00 01 .long 0x1
2094: 80 00 00 00 lwz r0,0(0)
0000000000002098 <_other_thread_spinlock>:
ENTRY(_other_thread_spinlock)
/* Read spinlock value */
lis r2, kernel_other_thread_spinlock@ha
2098: 3c 40 00 00 lis r2,0
209a: R_PPC64_ADDR16_HA kernel_other_thread_spinlock
ori r2, r2, kernel_other_thread_spinlock@l
209c: 60 42 4d 80 ori r2,r2,19840
209e: R_PPC64_ADDR16_LO kernel_other_thread_spinlock
1:
ld r3, 0(r2)
20a0: e8 62 00 00 ld r3,0(r2)
/* Loop until value is 1 */
cmpwi cr0, r3, 1
20a4: 2c 03 00 01 cmpwi r3,1
beq _other_thread_spinlock_complete
20a8: 41 82 00 0c beq 20b4 <_other_thread_spinlock_complete>
/* Lower thread priority */
or 1,1,1
20ac: 7c 21 0b 78 mr r1,r1
b 1b
20b0: 4b ff ff f0 b 20a0 <_other_thread_spinlock+0x8>
00000000000020b4 <_other_thread_spinlock_complete>:
_other_thread_spinlock_complete:
/* Raise thread priority */
or 2,2,2
20b4: 7c 42 13 78 mr r2,r2
isync
20b8: 4c 00 01 2c isync
00000000000020bc <call_bootblock>:
ENDPROC(_other_thread_spinlock)
call_bootblock:
li r3, 0
20bc: 38 60 00 00 li r3,0
lis r1, _estack@h
20c0: 3c 20 00 07 lis r1,7
20c2: R_PPC64_ADDR16_HI _estack
ori r1, r1, _estack@l
20c4: 60 21 ff 00 ori r1,r1,65280
20c6: R_PPC64_ADDR16_LO _estack
std r3, 0(r1)
20c8: f8 61 00 00 std r3,0(r1)
std r3, 8(r1)
20cc: f8 61 00 08 std r3,8(r1)
std r3, 16(r1)
20d0: f8 61 00 10 std r3,16(r1)
/* std r0, 0(r1) */
/* addi r1, r1, 8 */
/* cmpd cr0, r1, r3 */
/* bne init_stack_loop */
bl main
20d4: 48 00 1c bd bl 3d90 <main+0x8>
20d4: R_PPC64_REL24 main
nop
20d8: 60 00 00 00 nop
b .
20dc: 48 00 00 00 b 20dc <call_bootblock+0x20>
00000000000020e0 <exception_entry>:
#define EXCEPTION_MAX_STR 320
void exception_entry(struct stack_frame *);
void exception_entry(struct stack_frame *stack)
{
20e0: 3c 40 00 02 lis r2,2
20e2: R_PPC64_ADDR16_HA .TOC.
20e4: 38 42 80 00 addi r2,r2,-32768
20e6: R_PPC64_ADDR16_LO .TOC.
uint64_t nip;
uint64_t msr;
char buf[EXCEPTION_MAX_STR];
size_t l;
switch(stack->type) {
20e8: e9 23 00 80 ld r9,128(r3)
{
20ec: 7c 08 02 a6 mflr r0
switch(stack->type) {
20f0: 2b a9 0e 40 cmpldi cr7,r9,3648
{
20f4: 48 00 2b d9 bl 4ccc <_savegpr0_29>
20f4: R_PPC64_REL24 _savegpr0_29
20f8: f8 21 fe 41 stdu r1,-448(r1)
20fc: 7c 7f 1b 78 mr r31,r3
switch(stack->type) {
2100: 41 9e 00 1c beq cr7,211c <exception_entry+0x3c>
2104: 41 9d 00 a8 bgt cr7,21ac <exception_entry+0xcc>
2108: 2b a9 09 80 cmpldi cr7,r9,2432
210c: 41 9e 00 10 beq cr7,211c <exception_entry+0x3c>
2110: 41 9d 00 8c bgt cr7,219c <exception_entry+0xbc>
2114: 2b a9 05 00 cmpldi cr7,r9,1280
2118: 40 9e 00 b8 bne cr7,21d0 <exception_entry+0xf0>
hv = false;
break;
}
if (hv) {
nip = stack->hsrr0;
211c: eb df 01 d0 ld r30,464(r31)
msr = stack->hsrr1;
2120: eb bf 01 d8 ld r29,472(r31)
if (!(msr & MSR_RI))
fatal = true;
l = 0;
switch (stack->type) {
2124: 2b a9 01 00 cmpldi cr7,r9,256
2128: 3c 82 ff ff addis r4,r2,-1
212a: R_PPC64_TOC16_HA .text+0x4998
stack->msr = msr;
212c: fb bf 01 b0 std r29,432(r31)
stack->pc = nip;
2130: fb df 01 a8 std r30,424(r31)
"System Reset at "REG" ", nip);
}
break;
default:
fatal = true;
printk(BIOS_ERR, "***********************************************\n");
2134: 38 60 00 03 li r3,3
2138: 38 84 c9 98 addi r4,r4,-13928
213a: R_PPC64_TOC16_LO .text+0x4998
switch (stack->type) {
213c: 40 9e 00 a0 bne cr7,21dc <exception_entry+0xfc>
printk(BIOS_ERR, "***********************************************\n");
2140: 48 00 10 0d bl 314c <do_printk+0x8>
2140: R_PPC64_REL24 do_printk
2144: 60 00 00 00 nop
l += snprintf(buf + l, EXCEPTION_MAX_STR -l,
2148: 3c a2 ff ff addis r5,r2,-1
214a: R_PPC64_TOC16_HA .text+0x49c9
if (fatal) {
214c: 73 a9 00 02 andi. r9,r29,2
l += snprintf(buf + l, EXCEPTION_MAX_STR -l,
2150: 7f c6 f3 78 mr r6,r30
2154: 38 a5 c9 c9 addi r5,r5,-13879
2156: R_PPC64_TOC16_LO .text+0x49c9
if (fatal) {
2158: 41 82 00 0c beq 2164 <exception_entry+0x84>
l += snprintf(buf + l, EXCEPTION_MAX_STR -l,
215c: 3c a2 ff ff addis r5,r2,-1
215e: R_PPC64_TOC16_HA .text+0x49cf
2160: 38 a5 c9 cf addi r5,r5,-13873
2162: R_PPC64_TOC16_LO .text+0x49cf
2164: 38 80 01 40 li r4,320
2168: 38 61 00 60 addi r3,r1,96
216c: 48 00 11 59 bl 32c4 <snprintf+0x8>
216c: R_PPC64_REL24 snprintf
2170: 60 00 00 00 nop
l += snprintf(buf + l, EXCEPTION_MAX_STR -l,
"Fatal Exception 0x%llx at "REG" ", stack->type, nip);
break;
}
l += snprintf(buf + l, EXCEPTION_MAX_STR - l, " MSR"REG, msr);
2174: 39 21 00 60 addi r9,r1,96
2178: 3c a2 ff ff addis r5,r2,-1
217a: R_PPC64_TOC16_HA .text+0x4a0e
217c: 20 83 01 40 subfic r4,r3,320
2180: 7f a6 eb 78 mr r6,r29
2184: 38 a5 ca 0e addi r5,r5,-13810
2186: R_PPC64_TOC16_LO .text+0x4a0e
2188: 7c 69 1a 14 add r3,r9,r3
218c: 48 00 11 39 bl 32c4 <snprintf+0x8>
218c: R_PPC64_REL24 snprintf
2190: 60 00 00 00 nop
}
2194: 38 21 01 c0 addi r1,r1,448
2198: 48 00 2b 84 b 4d1c <_restgpr0_29>
2198: R_PPC64_REL24 _restgpr0_29
switch(stack->type) {
219c: 2b a9 0e 00 cmpldi cr7,r9,3584
21a0: 41 9e ff 7c beq cr7,211c <exception_entry+0x3c>
21a4: 2b a9 0e 20 cmpldi cr7,r9,3616
21a8: 4b ff ff 70 b 2118 <exception_entry+0x38>
21ac: 2b a9 0e 80 cmpldi cr7,r9,3712
21b0: 41 9e ff 6c beq cr7,211c <exception_entry+0x3c>
21b4: 41 9d 00 0c bgt cr7,21c0 <exception_entry+0xe0>
21b8: 2b a9 0e 60 cmpldi cr7,r9,3680
21bc: 4b ff ff 5c b 2118 <exception_entry+0x38>
21c0: 2b a9 0e a0 cmpldi cr7,r9,3744
21c4: 41 9e ff 58 beq cr7,211c <exception_entry+0x3c>
21c8: 2b a9 0f 80 cmpldi cr7,r9,3968
21cc: 4b ff ff 4c b 2118 <exception_entry+0x38>
nip = stack->srr0;
21d0: eb df 01 c0 ld r30,448(r31)
msr = stack->srr1;
21d4: eb bf 01 c8 ld r29,456(r31)
21d8: 4b ff ff 4c b 2124 <exception_entry+0x44>
printk(BIOS_ERR, "***********************************************\n");
21dc: 48 00 0f 71 bl 314c <do_printk+0x8>
21dc: R_PPC64_REL24 do_printk
21e0: 60 00 00 00 nop
l += snprintf(buf + l, EXCEPTION_MAX_STR -l,
21e4: 3c a2 ff ff addis r5,r2,-1
21e6: R_PPC64_TOC16_HA .text+0x49ea
21e8: e8 df 00 80 ld r6,128(r31)
21ec: 7f c7 f3 78 mr r7,r30
21f0: 38 80 01 40 li r4,320
21f4: 38 61 00 60 addi r3,r1,96
21f8: 38 a5 c9 ea addi r5,r5,-13846
21fa: R_PPC64_TOC16_LO .text+0x49ea
21fc: 48 00 10 c9 bl 32c4 <snprintf+0x8>
21fc: R_PPC64_REL24 snprintf
2200: 60 00 00 00 nop
break;
2204: 4b ff ff 70 b 2174 <exception_entry+0x94>
2208: 00 00 00 00 .long 0x0
220c: 00 00 00 01 .long 0x1
2210: 80 03 00 00 lwz r0,0(r3)
0000000000002214 <boot_device_ro>:
#define rom_base ((void *) (uintptr_t)(0x6030000000000ULL-CONFIG_ROM_SIZE))
static const struct mem_region_device boot_dev =
MEM_REGION_DEV_RO_INIT(rom_base, CONFIG_ROM_SIZE);
const struct region_device *boot_device_ro(void)
{
2214: 3c 40 00 02 lis r2,2
2216: R_PPC64_ADDR16_HA .TOC.
2218: 38 42 80 00 addi r2,r2,-32768
221a: R_PPC64_ADDR16_LO .TOC.
return &boot_dev.rdev;
}
221c: 3c 62 ff ff addis r3,r2,-1
221e: R_PPC64_TOC16_HA .data+0x48
2220: 38 63 cd 90 addi r3,r3,-12912
2222: R_PPC64_TOC16_LO .data+0x48
2224: 4e 80 00 20 blr
...
0000000000002234 <ulz4fn.part.0>:
#include "lz4.c.inc" /* #include for inlining, do not link! */
#define LZ4F_MAGICNUMBER 0x184D2204
#define LZ4F_BLOCKUNCOMPRESSED_FLAG 0x80000000U
size_t ulz4fn(const void *src, size_t srcn, void *dst, size_t dstn)
2234: 3c 40 00 02 lis r2,2
2236: R_PPC64_ADDR16_HA .TOC.
2238: 38 42 80 00 addi r2,r2,-32768
223a: R_PPC64_ADDR16_LO .TOC.
return be32_to_cpu(big_endian_32bits);
}
static inline uint32_t le32toh(uint32_t little_endian_32bits)
{
return le32_to_cpu(little_endian_32bits);
223c: 7d 20 1c 2c lwbrx r9,0,r3
2240: 7c 08 02 a6 mflr r0
2244: 7d 80 00 26 mfcr r12
independent_blocks = (flags >> 5) & 0x1;
has_block_checksum = (flags >> 4) & 1;
has_content_size = (flags >> 3) & 0x1;
/* We assume there's always only a single, standard frame. */
if (magic != LZ4F_MAGICNUMBER || version != 1)
2248: 6d 2a 18 4d xoris r10,r9,6221
224c: 2f 8a 22 04 cmpwi cr7,r10,8708
size_t ulz4fn(const void *src, size_t srcn, void *dst, size_t dstn)
2250: 48 00 2a 41 bl 4c90 <_etext>
2250: R_PPC64_REL24 _savegpr0_14
2254: 91 81 00 08 stw r12,8(r1)
2258: f8 21 fe e1 stdu r1,-288(r1)
if (magic != LZ4F_MAGICNUMBER || version != 1)
225c: 40 9e 02 74 bne cr7,24d0 <ulz4fn.part.0+0x29c>
flags = *(const uint8_t *)in;
2260: 89 03 00 04 lbz r8,4(r3)
if (magic != LZ4F_MAGICNUMBER || version != 1)
2264: 79 09 d0 22 rldicl r9,r8,58,32
2268: 2f 89 00 01 cmpwi cr7,r9,1
226c: 40 9e 02 64 bne cr7,24d0 <ulz4fn.part.0+0x29c>
return 0; /* unknown format */
if ((flags & 0x03) || (block_desc & 0x8f))
2270: 89 43 00 05 lbz r10,5(r3)
2274: 55 09 07 be clrlwi r9,r8,30
2278: 71 4a 00 8f andi. r10,r10,143
227c: 7d 49 4b 78 or r9,r10,r9
2280: 2f 89 00 00 cmpwi cr7,r9,0
2284: 40 9e 02 4c bne cr7,24d0 <ulz4fn.part.0+0x29c>
return 0; /* reserved bits must be zero */
if (!independent_blocks)
2288: 79 09 d8 22 rldicl r9,r8,59,32
228c: 2f 89 00 02 cmpwi cr7,r9,2
2290: 41 9e 02 40 beq cr7,24d0 <ulz4fn.part.0+0x29c>
return 0; /* we don't support block dependency */
if (has_content_size) {
2294: 71 09 00 08 andi. r9,r8,8
in += sizeof(uint8_t);
2298: 38 e3 00 06 addi r7,r3,6
if (has_content_size) {
229c: 41 82 00 10 beq 22ac <ulz4fn.part.0+0x78>
if (srcn < sizeof(uint32_t) + 3*sizeof(uint8_t) + sizeof(uint64_t))
22a0: 2b a4 00 0e cmpldi cr7,r4,14
22a4: 40 9d 02 2c ble cr7,24d0 <ulz4fn.part.0+0x29c>
return 0; /* input overrun */
in += sizeof(uint64_t);
22a8: 38 e3 00 0e addi r7,r3,14
break; /* decompression error */
out += ret;
}
in += block_size;
if (has_block_checksum)
22ac: 71 09 00 10 andi. r9,r8,16
BYTE* cpy;
BYTE* oexit = op + targetOutputSize;
const BYTE* const lowLimit = lowPrefix - dictSize;
const BYTE* const dictEnd = (const BYTE*)dictStart + dictSize;
const unsigned dec32table[] = {4, 1, 2, 1, 4, 4, 4, 4};
22b0: 3f 42 ff ff addis r26,r2,-1
22b2: R_PPC64_TOC16_HA .text+0x4958
22b4: 7c bb 2b 78 mr r27,r5
22b8: 7c 97 23 78 mr r23,r4
22bc: 7c 79 1b 78 mr r25,r3
in += sizeof(uint8_t);
22c0: 38 e7 00 01 addi r7,r7,1
void *out = dst;
22c4: 7c bc 2b 78 mr r28,r5
22c8: 7f 05 32 14 add r24,r5,r6
22cc: 3b 5a c9 58 addi r26,r26,-13992
22ce: R_PPC64_TOC16_LO .text+0x4958
const int dec64table[] = {0, 0, 0, -1, 0, 1, 2, 3};
const int safeDecode = (endOnInput==endOnInputSize);
const int checkOffset = ((safeDecode) && (dictSize < (int)(64 KB)));
const int inPlaceDecode = ((ip >= op) && (ip < oend));
22d0: 3a a0 00 00 li r21,0
/* copy match within block */
cpy = op + length;
if (unlikely(offset<8))
{
const int dec64 = dec64table[offset];
22d4: 3a c1 00 20 addi r22,r1,32
const int inPlaceDecode = ((ip >= op) && (ip < oend));
22d8: 3a 80 00 01 li r20,1
if (has_block_checksum)
22dc: 4e 00 00 00 mcrf cr4,cr0
22e0: 7d 40 3c 2c lwbrx r10,0,r7
in += sizeof(uint32_t);
22e4: 3a 67 00 04 addi r19,r7,4
if ((size_t)(in - src) + block_size > srcn)
22e8: 7d 39 98 50 subf r9,r25,r19
block_size = block_header & ~LZ4F_BLOCKUNCOMPRESSED_FLAG;
22ec: 55 48 00 7e clrlwi r8,r10,1
22f0: 79 12 00 20 clrldi r18,r8,32
if ((size_t)(in - src) + block_size > srcn)
22f4: 7d 29 92 14 add r9,r9,r18
22f8: 7f b7 48 40 cmpld cr7,r23,r9
22fc: 41 9c 01 d4 blt cr7,24d0 <ulz4fn.part.0+0x29c>
if (!block_size) {
2300: 2f b2 00 00 cmpdi cr7,r18,0
2304: 40 9e 00 18 bne cr7,231c <ulz4fn.part.0+0xe8>
out_size = out - dst;
2308: 7c 7b e0 50 subf r3,r27,r28
in += sizeof(uint32_t);
}
return out_size;
}
230c: 38 21 01 20 addi r1,r1,288
2310: 81 81 00 08 lwz r12,8(r1)
2314: 7d 81 81 20 mtcrf 24,r12
2318: 48 00 29 c8 b 4ce0 <_restgpr0_14>
2318: R_PPC64_REL24 _restgpr0_14
if (block_header & LZ4F_BLOCKUNCOMPRESSED_FLAG) {
231c: 2f 8a 00 00 cmpwi cr7,r10,0
size_t size = MIN((uintptr_t)block_size, (uintptr_t)dst
2320: 7f fc c0 50 subf r31,r28,r24
if (block_header & LZ4F_BLOCKUNCOMPRESSED_FLAG) {
2324: 40 9c 00 3c bge cr7,2360 <ulz4fn.part.0+0x12c>
size_t size = MIN((uintptr_t)block_size, (uintptr_t)dst
2328: 7f bf 90 40 cmpld cr7,r31,r18
memcpy(out, in, size);
232c: 7e 64 9b 78 mr r4,r19
2330: 7f 83 e3 78 mr r3,r28
size_t size = MIN((uintptr_t)block_size, (uintptr_t)dst
2334: 7f f2 ff 5e isel r31,r18,r31,29
memcpy(out, in, size);
2338: 7f e5 fb 78 mr r5,r31
233c: 48 00 22 61 bl 459c <memcpy>
233c: R_PPC64_REL24 memcpy
2340: 60 00 00 00 nop
if (size < block_size)
2344: 7f b2 f8 40 cmpld cr7,r18,r31
2348: 41 9d 01 88 bgt cr7,24d0 <ulz4fn.part.0+0x29c>
out += ret;
234c: 7f 9c fa 14 add r28,r28,r31
in += block_size;
2350: 7c f3 92 14 add r7,r19,r18
if (has_block_checksum)
2354: 41 92 ff 8c beq cr4,22e0 <ulz4fn.part.0+0xac>
2358: 38 e7 00 04 addi r7,r7,4
235c: 4b ff ff 84 b 22e0 <ulz4fn.part.0+0xac>
const unsigned dec32table[] = {4, 1, 2, 1, 4, 4, 4, 4};
2360: e8 ba 00 00 ld r5,0(r26)
2364: e8 da 00 08 ld r6,8(r26)
2368: e9 5a 00 10 ld r10,16(r26)
236c: e9 3a 00 18 ld r9,24(r26)
const int inPlaceDecode = ((ip >= op) && (ip < oend));
2370: 7f b3 e0 40 cmpld cr7,r19,r28
int ret = LZ4_decompress_generic(in, out, block_size,
2374: 7f ff 07 b4 extsw r31,r31
const BYTE* const iend = ip + inputSize;
2378: 7e 13 92 14 add r16,r19,r18
BYTE* const oend = op + outputSize;
237c: 7e 3c fa 14 add r17,r28,r31
const unsigned dec32table[] = {4, 1, 2, 1, 4, 4, 4, 4};
2380: f8 a1 00 40 std r5,64(r1)
2384: f8 c1 00 48 std r6,72(r1)
2388: f9 41 00 50 std r10,80(r1)
238c: f9 21 00 58 std r9,88(r1)
const int dec64table[] = {0, 0, 0, -1, 0, 1, 2, 3};
2390: e8 ba 00 20 ld r5,32(r26)
2394: e9 3a 00 38 ld r9,56(r26)
2398: e8 da 00 28 ld r6,40(r26)
239c: e9 5a 00 30 ld r10,48(r26)
23a0: f9 21 00 38 std r9,56(r1)
23a4: f8 a1 00 20 std r5,32(r1)
23a8: f8 c1 00 28 std r6,40(r1)
23ac: f9 41 00 30 std r10,48(r1)
const int inPlaceDecode = ((ip >= op) && (ip < oend));
23b0: 39 20 00 00 li r9,0
23b4: 41 9c 00 10 blt cr7,23c4 <ulz4fn.part.0+0x190>
23b8: 7f b3 88 40 cmpld cr7,r19,r17
23bc: 7d 34 af 1e isel r9,r20,r21,28
23c0: 7d 29 07 b4 extsw r9,r9
if ((endOnInput) && (unlikely(outputSize==0))) return ((inputSize==1) && (*ip==0)) ? 0 : -1; /* Empty output buffer */
23c4: 2f bf 00 00 cmpdi cr7,r31,0
23c8: 7f 9d e3 78 mr r29,r28
in += sizeof(uint32_t);
23cc: 7e 6a 9b 78 mr r10,r19
23d0: 41 9e 00 ec beq cr7,24bc <ulz4fn.part.0+0x288>
if (unlikely((inPlaceDecode) && (op + WILDCOPYLENGTH > ip))) goto _output_error; /* output stream ran over input stream */
23d4: 2d a9 00 00 cmpdi cr3,r9,0
if ((endOnInput) && unlikely(ip>=iend-RUN_MASK)) goto _output_error; /* overflow detection */
23d8: 39 d0 ff f1 addi r14,r16,-15
if (((endOnInput) && ((cpy>(partialDecoding?oexit:oend-MFLIMIT)) || (ip+length>iend-(2+1+LASTLITERALS))) )
23dc: 39 11 ff f4 addi r8,r17,-12
23e0: 38 f0 ff f8 addi r7,r16,-8
if ((endOnInput) && (ip > iend-LASTLITERALS)) goto _output_error;
23e4: 38 d0 ff fb addi r6,r16,-5
} else { LZ4_copy8(op, match); match+=8; }
op += 8;
if (unlikely(cpy>oend-12))
{
BYTE* const oCopyLimit = oend-(WILDCOPYLENGTH-1);
23e8: 39 f1 ff f9 addi r15,r17,-7
if (cpy > oend-LASTLITERALS) goto _output_error; /* Error : last LASTLITERALS bytes must be literals (uncompressed) */
23ec: 39 71 ff fb addi r11,r17,-5
if (unlikely((inPlaceDecode) && (op + WILDCOPYLENGTH > ip))) goto _output_error; /* output stream ran over input stream */
23f0: 41 8e 00 10 beq cr3,2400 <ulz4fn.part.0+0x1cc>
23f4: 39 3d 00 08 addi r9,r29,8
23f8: 7f aa 48 40 cmpld cr7,r10,r9
23fc: 41 9c 02 7c blt cr7,2678 <ulz4fn.part.0+0x444>
token = *ip++;
2400: 88 8a 00 00 lbz r4,0(r10)
2404: 3b ea 00 01 addi r31,r10,1
if ((length=(token>>ML_BITS)) == RUN_MASK)
2408: 54 89 e1 3e rlwinm r9,r4,28,4,31
240c: 2b 89 00 0f cmplwi cr7,r9,15
2410: 79 25 00 20 clrldi r5,r9,32
2414: 40 9e 00 5c bne cr7,2470 <ulz4fn.part.0+0x23c>
if ((endOnInput) && unlikely(ip>=iend-RUN_MASK)) goto _output_error; /* overflow detection */
2418: 7f bf 70 40 cmpld cr7,r31,r14
241c: 40 9c 02 60 bge cr7,267c <ulz4fn.part.0+0x448>
2420: 39 4a 00 02 addi r10,r10,2
2424: 7d 3f 70 50 subf r9,r31,r14
2428: 38 a0 00 0f li r5,15
242c: 7f ae 50 40 cmpld cr7,r14,r10
2430: 39 40 00 01 li r10,1
2434: 7d 2a 4f 1e isel r9,r10,r9,28
s = *ip++;
2438: 3b ff 00 01 addi r31,r31,1
while ( likely(endOnInput ? ip<iend-RUN_MASK : 1) && (s==255) );
243c: 2c 29 00 01 cmpdi r9,1
s = *ip++;
2440: 89 5f ff ff lbz r10,-1(r31)
while ( likely(endOnInput ? ip<iend-RUN_MASK : 1) && (s==255) );
2444: 39 29 ff ff addi r9,r9,-1
length += s;
2448: 7c a5 52 14 add r5,r5,r10
while ( likely(endOnInput ? ip<iend-RUN_MASK : 1) && (s==255) );
244c: 41 82 00 0c beq 2458 <ulz4fn.part.0+0x224>
2450: 2b 8a 00 ff cmplwi cr7,r10,255
2454: 41 9e ff e4 beq cr7,2438 <ulz4fn.part.0+0x204>
if ((safeDecode) && unlikely((size_t)(op+length)<(size_t)(op))) goto _output_error; /* overflow detection */
2458: 7d 3d 2a 14 add r9,r29,r5
245c: 7f bd 48 40 cmpld cr7,r29,r9
2460: 41 9d 02 1c bgt cr7,267c <ulz4fn.part.0+0x448>
if ((safeDecode) && unlikely((size_t)(ip+length)<(size_t)(ip))) goto _output_error; /* overflow detection */
2464: 7d 3f 2a 14 add r9,r31,r5
2468: 7f bf 48 40 cmpld cr7,r31,r9
246c: 41 9d 02 10 bgt cr7,267c <ulz4fn.part.0+0x448>
cpy = op+length;
2470: 7f dd 2a 14 add r30,r29,r5
if (((endOnInput) && ((cpy>(partialDecoding?oexit:oend-MFLIMIT)) || (ip+length>iend-(2+1+LASTLITERALS))) )
2474: 7d 3f 2a 14 add r9,r31,r5
2478: 7f be 40 40 cmpld cr7,r30,r8
247c: 41 9d 00 0c bgt cr7,2488 <ulz4fn.part.0+0x254>
2480: 7f a9 38 40 cmpld cr7,r9,r7
2484: 40 9d 00 54 ble cr7,24d8 <ulz4fn.part.0+0x2a4>
if ((endOnInput) && ((ip+length != iend) || (cpy > oend))) goto _output_error; /* Error : input must be consumed */
2488: 7f b0 48 40 cmpld cr7,r16,r9
248c: 40 9e 01 f0 bne cr7,267c <ulz4fn.part.0+0x448>
2490: 7f b1 f0 40 cmpld cr7,r17,r30
2494: 41 9c 01 e8 blt cr7,267c <ulz4fn.part.0+0x448>
memmove(op, ip, length);
2498: 7f e4 fb 78 mr r4,r31
249c: 7f a3 eb 78 mr r3,r29
op=cpy; /* correction */
}
/* end of decoding */
if (endOnInput)
return (int) (((char*)op)-dest); /* Nb of output bytes decoded */
24a0: 7f fc f0 50 subf r31,r28,r30
memmove(op, ip, length);
24a4: 48 00 21 39 bl 45dc <memmove>
24a4: R_PPC64_REL24 memmove
24a8: 60 00 00 00 nop
else
return (int) (((const char*)ip)-source); /* Nb of input bytes read */
/* Overflow error detected */
_output_error:
return (int) (-(((const char*)ip)-source))-1;
24ac: 7f ff 07 b4 extsw r31,r31
if (ret < 0)
24b0: 2f 9f 00 00 cmpwi cr7,r31,0
24b4: 40 9c fe 98 bge cr7,234c <ulz4fn.part.0+0x118>
24b8: 48 00 00 18 b 24d0 <ulz4fn.part.0+0x29c>
if ((endOnInput) && (unlikely(outputSize==0))) return ((inputSize==1) && (*ip==0)) ? 0 : -1; /* Empty output buffer */
24bc: 2b 88 00 01 cmplwi cr7,r8,1
24c0: 40 9e 00 10 bne cr7,24d0 <ulz4fn.part.0+0x29c>
24c4: 89 27 00 04 lbz r9,4(r7)
24c8: 2f 89 00 00 cmpwi cr7,r9,0
24cc: 41 9e fe 80 beq cr7,234c <ulz4fn.part.0+0x118>
return 0; /* unknown format */
24d0: 38 60 00 00 li r3,0
24d4: 4b ff fe 38 b 230c <ulz4fn.part.0+0xd8>
24d8: 3b ff ff f8 addi r31,r31,-8
*(uint64_t *)dst = *(const uint64_t *)src;
24dc: e9 5f 00 09 ldu r10,8(r31)
do { LZ4_copy8(d,s); d+=8; s+=8; } while (d<e);
24e0: 3b bd 00 08 addi r29,r29,8
24e4: f9 5d ff f8 std r10,-8(r29)
24e8: 7f be e8 40 cmpld cr7,r30,r29
24ec: 41 9d ff f0 bgt cr7,24dc <ulz4fn.part.0+0x2a8>
return le16_to_cpu(little_endian_16bits);
24f0: 7d 40 4e 2c lhbrx r10,0,r9
offset = LZ4_readLE16(ip); ip+=2;
24f4: 3b e9 00 02 addi r31,r9,2
match = op - offset;
24f8: 7d 2a f0 50 subf r9,r10,r30
if ((checkOffset) && (unlikely(match < lowLimit))) goto _output_error; /* Error : offset outside buffers */
24fc: 7f bc 48 40 cmpld cr7,r28,r9
2500: 41 9d 01 7c bgt cr7,267c <ulz4fn.part.0+0x448>
length = token & ML_MASK;
2504: 78 9d 07 20 clrldi r29,r4,60
if (length == ML_MASK)
2508: 2b 9d 00 0f cmplwi cr7,r29,15
250c: 40 9e 00 30 bne cr7,253c <ulz4fn.part.0+0x308>
length = token & ML_MASK;
2510: 3b a0 00 0f li r29,15
if ((endOnInput) && (ip > iend-LASTLITERALS)) goto _output_error;
2514: 7f bf 30 40 cmpld cr7,r31,r6
2518: 41 9d 01 64 bgt cr7,267c <ulz4fn.part.0+0x448>
s = *ip++;
251c: 3b ff 00 01 addi r31,r31,1
2520: 88 bf ff ff lbz r5,-1(r31)
} while (s==255);
2524: 2b 85 00 ff cmplwi cr7,r5,255
length += s;
2528: 7f bd 2a 14 add r29,r29,r5
} while (s==255);
252c: 41 9e ff e8 beq cr7,2514 <ulz4fn.part.0+0x2e0>
if ((safeDecode) && unlikely((size_t)(op+length)<(size_t)op)) goto _output_error; /* overflow detection */
2530: 7c be ea 14 add r5,r30,r29
2534: 7f be 28 40 cmpld cr7,r30,r5
2538: 41 9d 01 44 bgt cr7,267c <ulz4fn.part.0+0x448>
if (unlikely(offset<8))
253c: 2b aa 00 07 cmpldi cr7,r10,7
length += MINMATCH;
2540: 3b bd 00 04 addi r29,r29,4
cpy = op + length;
2544: 7f be ea 14 add r29,r30,r29
if (unlikely(offset<8))
2548: 41 9d 00 e8 bgt cr7,2630 <ulz4fn.part.0+0x3fc>
const int dec64 = dec64table[offset];
254c: 79 4a 17 64 rldicr r10,r10,2,61
memcpy(op+4, match, 4);
2550: 38 7e 00 04 addi r3,r30,4
2554: f9 61 00 88 std r11,136(r1)
2558: f8 c1 00 80 std r6,128(r1)
255c: f8 e1 00 78 std r7,120(r1)
2560: f9 01 00 70 std r8,112(r1)
const int dec64 = dec64table[offset];
2564: 7c 16 52 aa lwax r0,r22,r10
2568: 7c b6 52 14 add r5,r22,r10
op[0] = match[0];
256c: 89 49 00 00 lbz r10,0(r9)
2570: 99 5e 00 00 stb r10,0(r30)
op[1] = match[1];
2574: 89 49 00 01 lbz r10,1(r9)
const int dec64 = dec64table[offset];
2578: f8 01 00 68 std r0,104(r1)
op[1] = match[1];
257c: 99 5e 00 01 stb r10,1(r30)
op[2] = match[2];
2580: 89 49 00 02 lbz r10,2(r9)
2584: 99 5e 00 02 stb r10,2(r30)
op[3] = match[3];
2588: 89 49 00 03 lbz r10,3(r9)
258c: 99 5e 00 03 stb r10,3(r30)
match += dec32table[offset];
2590: 81 45 00 20 lwz r10,32(r5)
memcpy(op+4, match, 4);
2594: 38 a0 00 04 li r5,4
match += dec32table[offset];
2598: 7d 29 52 14 add r9,r9,r10
memcpy(op+4, match, 4);
259c: 7d 24 4b 78 mr r4,r9
25a0: f9 21 00 60 std r9,96(r1)
25a4: 48 00 1f f9 bl 459c <memcpy>
25a4: R_PPC64_REL24 memcpy
25a8: 60 00 00 00 nop
match -= dec64;
25ac: e9 21 00 60 ld r9,96(r1)
25b0: e8 01 00 68 ld r0,104(r1)
25b4: e9 01 00 70 ld r8,112(r1)
25b8: e8 e1 00 78 ld r7,120(r1)
25bc: e8 c1 00 80 ld r6,128(r1)
25c0: e9 61 00 88 ld r11,136(r1)
25c4: 7d 20 48 50 subf r9,r0,r9
if (unlikely(cpy>oend-12))
25c8: 7f a8 e8 40 cmpld cr7,r8,r29
op += 8;
25cc: 3b de 00 08 addi r30,r30,8
if (unlikely(cpy>oend-12))
25d0: 38 a9 ff f8 addi r5,r9,-8
25d4: 40 9c 00 8c bge cr7,2660 <ulz4fn.part.0+0x42c>
if (cpy > oend-LASTLITERALS) goto _output_error; /* Error : last LASTLITERALS bytes must be literals (uncompressed) */
25d8: 7f bd 58 40 cmpld cr7,r29,r11
25dc: 41 9d 00 a0 bgt cr7,267c <ulz4fn.part.0+0x448>
if (op < oCopyLimit)
25e0: 7f be 78 40 cmpld cr7,r30,r15
25e4: 40 9c 00 28 bge cr7,260c <ulz4fn.part.0+0x3d8>
25e8: 7f ca f3 78 mr r10,r30
25ec: e8 85 00 09 ldu r4,8(r5)
do { LZ4_copy8(d,s); d+=8; s+=8; } while (d<e);
25f0: 39 4a 00 08 addi r10,r10,8
25f4: f8 8a ff f8 std r4,-8(r10)
25f8: 7f af 50 40 cmpld cr7,r15,r10
25fc: 41 9d ff f0 bgt cr7,25ec <ulz4fn.part.0+0x3b8>
match += oCopyLimit - op;
2600: 7f de 78 50 subf r30,r30,r15
2604: 7d 29 f2 14 add r9,r9,r30
2608: 7d fe 7b 78 mr r30,r15
260c: 7f be e8 40 cmpld cr7,r30,r29
2610: 7d 5e e8 50 subf r10,r30,r29
2614: 38 a9 ff ff addi r5,r9,-1
2618: 39 4a 00 01 addi r10,r10,1
261c: 41 9d 00 0c bgt cr7,2628 <ulz4fn.part.0+0x3f4>
2620: 2f bd 00 00 cmpdi cr7,r29,0
2624: 40 9e 00 28 bne cr7,264c <ulz4fn.part.0+0x418>
2628: 39 40 00 01 li r10,1
262c: 48 00 00 20 b 264c <ulz4fn.part.0+0x418>
2630: e9 49 00 00 ld r10,0(r9)
} else { LZ4_copy8(op, match); match+=8; }
2634: 39 29 00 08 addi r9,r9,8
2638: f9 5e 00 00 std r10,0(r30)
263c: 4b ff ff 8c b 25c8 <ulz4fn.part.0+0x394>
while (op<cpy) *op++ = *match++;
2640: 8d 25 00 01 lbzu r9,1(r5)
2644: 3b de 00 01 addi r30,r30,1
2648: 99 3e ff ff stb r9,-1(r30)
264c: 2c 2a 00 01 cmpdi r10,1
2650: 39 4a ff ff addi r10,r10,-1
2654: 40 82 ff ec bne 2640 <ulz4fn.part.0+0x40c>
cpy = op + length;
2658: 7f ea fb 78 mr r10,r31
265c: 4b ff fd 94 b 23f0 <ulz4fn.part.0+0x1bc>
2660: e9 25 00 09 ldu r9,8(r5)
do { LZ4_copy8(d,s); d+=8; s+=8; } while (d<e);
2664: 3b de 00 08 addi r30,r30,8
2668: f9 3e ff f8 std r9,-8(r30)
266c: 7f bd f0 40 cmpld cr7,r29,r30
2670: 41 9d ff f0 bgt cr7,2660 <ulz4fn.part.0+0x42c>
2674: 4b ff ff e4 b 2658 <ulz4fn.part.0+0x424>
if (unlikely((inPlaceDecode) && (op + WILDCOPYLENGTH > ip))) goto _output_error; /* output stream ran over input stream */
2678: 7d 5f 53 78 mr r31,r10
return (int) (-(((const char*)ip)-source))-1;
267c: 7f f3 f8 50 subf r31,r19,r31
2680: 7f ff f8 f8 not r31,r31
2684: 4b ff fe 28 b 24ac <ulz4fn.part.0+0x278>
2688: 00 00 00 00 .long 0x0
268c: 00 00 00 03 .long 0x3
2690: 80 12 00 00 lwz r0,0(r18)
0000000000002694 <ulz4fn>:
{
2694: 3c 40 00 02 lis r2,2
2696: R_PPC64_ADDR16_HA .TOC.
2698: 38 42 80 00 addi r2,r2,-32768
269a: R_PPC64_ADDR16_LO .TOC.
if (srcn < sizeof(uint32_t) + 3*sizeof(uint8_t))
269c: 2b a4 00 06 cmpldi cr7,r4,6
26a0: 40 9d 00 08 ble cr7,26a8 <ulz4fn+0x14>
26a4: 4b ff fb 98 b 223c <ulz4fn.part.0+0x8>
26a4: R_PPC64_REL24 ulz4fn.part.0
}
26a8: 38 60 00 00 li r3,0
26ac: 4e 80 00 20 blr
...
00000000000026bc <read_be32>:
static inline uint32_t read_be32(const void *src)
{
const uint8_t *s = src;
return (((uint32_t)s[0]) << 24) | (((uint32_t)s[1]) << 16) |
(((uint32_t)s[2]) << 8) | (((uint32_t)s[3]) << 0);
}
26bc: 80 63 00 00 lwz r3,0(r3)
26c0: 4e 80 00 20 blr
...
00000000000026d0 <cbfs_for_each_file>:
return 0;
}
int cbfs_for_each_file(const struct region_device *cbfs,
const struct cbfsf *prev, struct cbfsf *fh)
{
26d0: 3c 40 00 02 lis r2,2
26d2: R_PPC64_ADDR16_HA .TOC.
26d4: 38 42 80 00 addi r2,r2,-32768
26d6: R_PPC64_ADDR16_LO .TOC.
26d8: 7c 08 02 a6 mflr r0
26dc: 48 00 25 ed bl 4cc8 <_savegpr0_28>
26dc: R_PPC64_REL24 _savegpr0_28
if (f == NULL)
26e0: 7c 9c 23 79 mr. r28,r4
{
26e4: f8 21 ff a1 stdu r1,-96(r1)
26e8: 7c 7e 1b 78 mr r30,r3
26ec: 7c bd 2b 78 mr r29,r5
26f0: 3b e0 00 00 li r31,0
if (f == NULL)
26f4: 41 82 00 20 beq 2714 <cbfs_for_each_file+0x44>
offset = rdev_relative_offset(cbfs, &f->data);
26f8: 38 9c 00 20 addi r4,r28,32
26fc: 48 00 03 9d bl 2a98 <rdev_relative_offset+0x8>
26fc: R_PPC64_REL24 rdev_relative_offset
2700: 60 00 00 00 nop
return ALIGN_UP(offset, CBFS_ALIGNMENT);
2704: eb fc 00 38 ld r31,56(r28)
2708: 3b ff 00 3f addi r31,r31,63
270c: 7f ff 1a 14 add r31,r31,r3
2710: 7b ff 06 64 rldicr r31,r31,0,57
/* Can't read file. Nothing else to do but bail out. */
if (rdev_readat(cbfs, &file, offset, fsz) != fsz)
break;
if (memcmp(file.magic, CBFS_FILE_MAGIC, sizeof(file.magic))) {
2714: 3f 82 ff ff addis r28,r2,-1
2716: R_PPC64_TOC16_HA .text+0x4a1b
2718: 3b 9c ca 1b addi r28,r28,-13797
271a: R_PPC64_TOC16_LO .text+0x4a1b
if (offset >= region_device_sz(cbfs))
271c: e9 3e 00 18 ld r9,24(r30)
2720: 7f bf 48 40 cmpld cr7,r31,r9
2724: 40 9c 00 ac bge cr7,27d0 <cbfs_for_each_file+0x100>
if (rdev_readat(cbfs, &file, offset, fsz) != fsz)
2728: 38 c0 00 18 li r6,24
272c: 7f e5 fb 78 mr r5,r31
2730: 38 81 00 20 addi r4,r1,32
2734: 7f c3 f3 78 mr r3,r30
2738: 48 00 04 f9 bl 2c30 <rdev_readat+0x8>
2738: R_PPC64_REL24 rdev_readat
273c: 60 00 00 00 nop
2740: 2f a3 00 18 cmpdi cr7,r3,24
2744: 40 9e 00 94 bne cr7,27d8 <cbfs_for_each_file+0x108>
if (memcmp(file.magic, CBFS_FILE_MAGIC, sizeof(file.magic))) {
2748: 38 a0 00 08 li r5,8
274c: 7f 84 e3 78 mr r4,r28
2750: 38 61 00 20 addi r3,r1,32
2754: 48 00 1e 01 bl 4554 <memcmp>
2754: R_PPC64_REL24 memcmp
2758: 60 00 00 00 nop
275c: 2f a3 00 00 cmpdi cr7,r3,0
2760: 41 9e 00 0c beq cr7,276c <cbfs_for_each_file+0x9c>
offset++;
offset = ALIGN_UP(offset, CBFS_ALIGNMENT);
2764: 3b ff 00 40 addi r31,r31,64
continue;
2768: 4b ff ff b4 b 271c <cbfs_for_each_file+0x4c>
}
file.len = read_be32(&file.len);
276c: 38 61 00 28 addi r3,r1,40
2770: 4b ff ff 4d bl 26bc <read_be32>
2770: R_PPC64_REL24 .text+0x26bc
2774: 90 61 00 28 stw r3,40(r1)
file.offset = read_be32(&file.offset);
2778: 38 61 00 34 addi r3,r1,52
277c: 4b ff ff 41 bl 26bc <read_be32>
277c: R_PPC64_REL24 .text+0x26bc
DEBUG("File @ offset %zx size %x\n", offset, file.len);
/* Keep track of both the metadata and the data for the file. */
if (rdev_chain(&fh->metadata, cbfs, offset, file.offset))
2780: 7f e5 fb 78 mr r5,r31
2784: 7f c4 f3 78 mr r4,r30
file.offset = read_be32(&file.offset);
2788: 7c 66 1b 78 mr r6,r3
278c: 90 61 00 34 stw r3,52(r1)
if (rdev_chain(&fh->metadata, cbfs, offset, file.offset))
2790: 7f a3 eb 78 mr r3,r29
2794: 48 00 05 31 bl 2cc4 <rdev_chain+0x8>
2794: R_PPC64_REL24 rdev_chain
2798: 60 00 00 00 nop
279c: 2f a3 00 00 cmpdi cr7,r3,0
27a0: 40 9e 00 38 bne cr7,27d8 <cbfs_for_each_file+0x108>
break;
if (rdev_chain(&fh->data, cbfs, offset + file.offset, file.len))
27a4: 80 a1 00 34 lwz r5,52(r1)
27a8: 80 c1 00 28 lwz r6,40(r1)
27ac: 7f c4 f3 78 mr r4,r30
27b0: 38 7d 00 20 addi r3,r29,32
27b4: 7c a5 fa 14 add r5,r5,r31
27b8: 48 00 05 0d bl 2cc4 <rdev_chain+0x8>
27b8: R_PPC64_REL24 rdev_chain
27bc: 60 00 00 00 nop
27c0: 2c 23 00 00 cmpdi r3,0
27c4: 40 82 00 14 bne 27d8 <cbfs_for_each_file+0x108>
/* Success. */
return 0;
}
return -1;
}
27c8: 38 21 00 60 addi r1,r1,96
27cc: 48 00 25 4c b 4d18 <_restgpr0_28>
27cc: R_PPC64_REL24 _restgpr0_28
return 1;
27d0: 38 60 00 01 li r3,1
27d4: 4b ff ff f4 b 27c8 <cbfs_for_each_file+0xf8>
return -1;
27d8: 38 60 ff ff li r3,-1
27dc: 4b ff ff ec b 27c8 <cbfs_for_each_file+0xf8>
27e0: 00 00 00 00 .long 0x0
27e4: 00 00 00 01 .long 0x1
27e8: 80 04 00 00 lwz r0,0(r4)
00000000000027ec <cbfsf_file_type>:
rdev_munmap(&fh->metadata, metadata);
return 0;
}
int cbfsf_file_type(struct cbfsf *fh, uint32_t *ftype)
{
27ec: 3c 40 00 02 lis r2,2
27ee: R_PPC64_ADDR16_HA .TOC.
27f0: 38 42 80 00 addi r2,r2,-32768
27f2: R_PPC64_ADDR16_LO .TOC.
27f4: 7c 08 02 a6 mflr r0
27f8: fb e1 ff f8 std r31,-8(r1)
const size_t sz = sizeof(*ftype);
if (rdev_readat(&fh->metadata, ftype,
27fc: 38 c0 00 04 li r6,4
2800: 38 a0 00 0c li r5,12
{
2804: 7c 9f 23 78 mr r31,r4
2808: f8 01 00 10 std r0,16(r1)
280c: f8 21 ff d1 stdu r1,-48(r1)
if (rdev_readat(&fh->metadata, ftype,
2810: 48 00 04 21 bl 2c30 <rdev_readat+0x8>
2810: R_PPC64_REL24 rdev_readat
2814: 60 00 00 00 nop
2818: 2f a3 00 04 cmpdi cr7,r3,4
281c: 40 9e 00 1c bne cr7,2838 <cbfsf_file_type+0x4c>
offsetof(struct cbfs_file, type), sz) != sz)
return -1;
*ftype = read_be32(ftype);
2820: 7f e3 fb 78 mr r3,r31
2824: 4b ff fe 99 bl 26bc <read_be32>
2824: R_PPC64_REL24 .text+0x26bc
2828: 90 7f 00 00 stw r3,0(r31)
return 0;
282c: 38 60 00 00 li r3,0
}
2830: 38 21 00 30 addi r1,r1,48
2834: 48 00 25 04 b 4d38 <_restgpr0_31>
2834: R_PPC64_REL24 _restgpr0_31
return -1;
2838: 38 60 ff ff li r3,-1
283c: 4b ff ff f4 b 2830 <cbfsf_file_type+0x44>
2840: 00 00 00 00 .long 0x0
2844: 00 00 00 01 .long 0x1
2848: 80 01 00 00 lwz r0,0(r1)
000000000000284c <cbfs_locate>:
int cbfs_locate(struct cbfsf *fh, const struct region_device *cbfs,
const char *name, uint32_t *type)
{
284c: 3c 40 00 02 lis r2,2
284e: R_PPC64_ADDR16_HA .TOC.
2850: 38 42 80 00 addi r2,r2,-32768
2852: R_PPC64_ADDR16_LO .TOC.
2854: 7c 08 02 a6 mflr r0
2858: 7d 90 80 26 mfocrf r12,8
285c: 91 81 00 08 stw r12,8(r1)
2860: 48 00 24 61 bl 4cc0 <_savegpr0_26>
2860: R_PPC64_REL24 _savegpr0_26
2864: 7c 9c 23 78 mr r28,r4
struct cbfsf *prev;
LOG("Locating '%s'\n", name);
2868: 3c 82 ff ff addis r4,r2,-1
286a: R_PPC64_TOC16_HA .text+0x4a24
{
286c: 7c dd 33 78 mr r29,r6
2870: f8 21 ff 61 stdu r1,-160(r1)
2874: 7c 7f 1b 78 mr r31,r3
LOG("Locating '%s'\n", name);
2878: 38 60 00 06 li r3,6
{
287c: 7c bb 2b 78 mr r27,r5
LOG("Locating '%s'\n", name);
2880: 38 84 ca 24 addi r4,r4,-13788
2882: R_PPC64_TOC16_LO .text+0x4a24
DEBUG(" Unmatched '%s' at %zx\n", fname,
rdev_relative_offset(cbfs, &fh->metadata));
continue;
}
if (type != NULL) {
2884: 2e 3d 00 00 cmpdi cr4,r29,0
LOG("Locating '%s'\n", name);
2888: 48 00 08 c5 bl 314c <do_printk+0x8>
2888: R_PPC64_REL24 do_printk
288c: 60 00 00 00 nop
prev = NULL;
2890: 38 80 00 00 li r4,0
ret = cbfs_for_each_file(cbfs, prev, fh);
2894: 7f e5 fb 78 mr r5,r31
2898: 7f 83 e3 78 mr r3,r28
289c: 4b ff fe 3d bl 26d8 <cbfs_for_each_file+0x8>
289c: R_PPC64_REL24 cbfs_for_each_file
if (ret < 0 || ret > 0)
28a0: 2f a3 00 00 cmpdi cr7,r3,0
28a4: 40 9e 00 88 bne cr7,292c <cbfs_locate+0xe0>
fname = rdev_mmap(&fh->metadata, fsz,
28a8: e8 bf 00 18 ld r5,24(r31)
28ac: 38 80 00 18 li r4,24
28b0: 7f e3 fb 78 mr r3,r31
28b4: 38 a5 ff e8 addi r5,r5,-24
28b8: 48 00 02 75 bl 2b2c <rdev_mmap+0x8>
28b8: R_PPC64_REL24 rdev_mmap
28bc: 60 00 00 00 nop
if (fname == NULL)
28c0: 7c 7a 1b 79 mr. r26,r3
28c4: 41 82 00 68 beq 292c <cbfs_locate+0xe0>
name_match = !strcmp(fname, name);
28c8: 7f 64 db 78 mr r4,r27
28cc: 48 00 1f f5 bl 48c0 <strcmp>
28cc: R_PPC64_REL24 strcmp
28d0: 60 00 00 00 nop
rdev_munmap(&fh->metadata, fname);
28d4: 7f 44 d3 78 mr r4,r26
name_match = !strcmp(fname, name);
28d8: 7c 7e 1b 78 mr r30,r3
rdev_munmap(&fh->metadata, fname);
28dc: 7f e3 fb 78 mr r3,r31
28e0: 48 00 02 e5 bl 2bc4 <rdev_munmap+0x8>
28e0: R_PPC64_REL24 rdev_munmap
28e4: 60 00 00 00 nop
if (!name_match) {
28e8: 2f be 00 00 cmpdi cr7,r30,0
28ec: 7f e4 fb 78 mr r4,r31
28f0: 40 9e ff a4 bne cr7,2894 <cbfs_locate+0x48>
if (type != NULL) {
28f4: 41 92 00 5c beq cr4,2950 <cbfs_locate+0x104>
uint32_t ftype;
if (cbfsf_file_type(fh, &ftype))
28f8: 38 81 00 60 addi r4,r1,96
28fc: 7f e3 fb 78 mr r3,r31
2900: 4b ff fe f5 bl 27f4 <cbfsf_file_type+0x8>
2900: R_PPC64_REL24 cbfsf_file_type
2904: 2f a3 00 00 cmpdi cr7,r3,0
2908: 40 9e 00 24 bne cr7,292c <cbfs_locate+0xe0>
break;
if (*type != 0 && *type != ftype) {
290c: 81 3d 00 00 lwz r9,0(r29)
2910: 81 41 00 60 lwz r10,96(r1)
2914: 2f a9 00 00 cmpdi cr7,r9,0
2918: 41 9e 00 34 beq cr7,294c <cbfs_locate+0x100>
291c: 7f 89 50 40 cmplw cr7,r9,r10
2920: 41 9e 00 30 beq cr7,2950 <cbfs_locate+0x104>
DEBUG(" Unmatched type %x at %zx\n", ftype,
rdev_relative_offset(cbfs,
&fh->metadata));
continue;
2924: 7f e4 fb 78 mr r4,r31
2928: 4b ff ff 6c b 2894 <cbfs_locate+0x48>
/* Success. */
return 0;
}
LOG("'%s' not found.\n", name);
292c: 3c 82 ff ff addis r4,r2,-1
292e: R_PPC64_TOC16_HA .text+0x4a5c
2930: 7f 65 db 78 mr r5,r27
2934: 38 60 00 06 li r3,6
return -1;
2938: 3b c0 ff ff li r30,-1
LOG("'%s' not found.\n", name);
293c: 38 84 ca 5c addi r4,r4,-13732
293e: R_PPC64_TOC16_LO .text+0x4a5c
2940: 48 00 08 0d bl 314c <do_printk+0x8>
2940: R_PPC64_REL24 do_printk
2944: 60 00 00 00 nop
return -1;
2948: 48 00 00 34 b 297c <cbfs_locate+0x130>
*type = ftype;
294c: 91 5d 00 00 stw r10,0(r29)
LOG("Found @ offset %zx size %zx\n",
2950: 7f e4 fb 78 mr r4,r31
2954: 7f 83 e3 78 mr r3,r28
2958: 48 00 01 41 bl 2a98 <rdev_relative_offset+0x8>
2958: R_PPC64_REL24 rdev_relative_offset
295c: 60 00 00 00 nop
2960: 3c 82 ff ff addis r4,r2,-1
2962: R_PPC64_TOC16_HA .text+0x4a39
2964: e8 df 00 38 ld r6,56(r31)
2968: 7c 65 1b 78 mr r5,r3
296c: 38 84 ca 39 addi r4,r4,-13767
296e: R_PPC64_TOC16_LO .text+0x4a39
2970: 38 60 00 06 li r3,6
2974: 48 00 07 d9 bl 314c <do_printk+0x8>
2974: R_PPC64_REL24 do_printk
2978: 60 00 00 00 nop
}
297c: 38 21 00 a0 addi r1,r1,160
2980: 7f c3 f3 78 mr r3,r30
2984: 81 81 00 08 lwz r12,8(r1)
2988: 7d 90 81 20 mtocrf 8,r12
298c: 48 00 23 84 b 4d10 <_restgpr0_26>
298c: R_PPC64_REL24 _restgpr0_26
2990: 00 00 00 00 .long 0x0
2994: 00 00 00 03 .long 0x3
2998: 80 06 00 00 lwz r0,0(r6)
000000000000299c <mdev_mmap>:
{
const struct mem_region_device *mdev;
mdev = container_of(rd, __typeof__(*mdev), rdev);
return &mdev->base[offset];
299c: e8 63 ff f8 ld r3,-8(r3)
}
29a0: 7c 63 22 14 add r3,r3,r4
29a4: 4e 80 00 20 blr
...
00000000000029b4 <mdev_munmap>:
static int mdev_munmap(const struct region_device *rd __unused,
void *mapping __unused)
{
return 0;
}
29b4: 38 60 00 00 li r3,0
29b8: 4e 80 00 20 blr
...
00000000000029c8 <mdev_readat>:
static ssize_t mdev_readat(const struct region_device *rd, void *b,
size_t offset, size_t size)
{
29c8: 3c 40 00 02 lis r2,2
29ca: R_PPC64_ADDR16_HA .TOC.
29cc: 38 42 80 00 addi r2,r2,-32768
29ce: R_PPC64_ADDR16_LO .TOC.
29d0: 7c 08 02 a6 mflr r0
29d4: 7c 89 23 78 mr r9,r4
29d8: fb e1 ff f8 std r31,-8(r1)
29dc: 7c df 33 78 mr r31,r6
29e0: f8 01 00 10 std r0,16(r1)
const struct mem_region_device *mdev;
mdev = container_of(rd, __typeof__(*mdev), rdev);
memcpy(b, &mdev->base[offset], size);
29e4: e8 83 ff f8 ld r4,-8(r3)
{
29e8: f8 21 ff d1 stdu r1,-48(r1)
memcpy(b, &mdev->base[offset], size);
29ec: 7d 23 4b 78 mr r3,r9
29f0: 7c 84 2a 14 add r4,r4,r5
29f4: 7c c5 33 78 mr r5,r6
29f8: 48 00 1b a5 bl 459c <memcpy>
29f8: R_PPC64_REL24 memcpy
29fc: 60 00 00 00 nop
return size;
}
2a00: 38 21 00 30 addi r1,r1,48
2a04: 7f e3 fb 78 mr r3,r31
2a08: 48 00 23 30 b 4d38 <_restgpr0_31>
2a08: R_PPC64_REL24 _restgpr0_31
2a0c: 00 00 00 00 .long 0x0
2a10: 00 00 00 01 .long 0x1
2a14: 80 01 00 00 lwz r0,0(r1)
0000000000002a18 <region_is_subregion>:
if (region_offset(c) < region_offset(p))
2a18: e9 44 00 00 ld r10,0(r4)
2a1c: e9 23 00 00 ld r9,0(r3)
2a20: 7f aa 48 40 cmpld cr7,r10,r9
2a24: 41 9c 00 30 blt cr7,2a54 <region_is_subregion+0x3c>
return r->size;
}
static inline size_t region_end(const struct region *r)
{
return region_offset(r) + region_sz(r);
2a28: e8 e3 00 08 ld r7,8(r3)
2a2c: e9 04 00 08 ld r8,8(r4)
return 0;
2a30: 38 60 00 00 li r3,0
2a34: 7d 0a 42 14 add r8,r10,r8
2a38: 7d 29 3a 14 add r9,r9,r7
if (region_end(c) > region_end(p))
2a3c: 7f a9 40 40 cmpld cr7,r9,r8
2a40: 4d 9c 00 20 bltlr cr7
return 0;
2a44: 7f aa 40 40 cmpld cr7,r10,r8
2a48: 38 60 00 01 li r3,1
2a4c: 7c 60 1f 5e isel r3,0,r3,29
2a50: 4e 80 00 20 blr
2a54: 38 60 00 00 li r3,0
}
2a58: 4e 80 00 20 blr
...
0000000000002a68 <normalize_and_ok>:
{
2a68: 3c 40 00 02 lis r2,2
2a6a: R_PPC64_ADDR16_HA .TOC.
2a6c: 38 42 80 00 addi r2,r2,-32768
2a6e: R_PPC64_ADDR16_LO .TOC.
inner->offset += region_offset(outer);
2a70: e9 24 00 00 ld r9,0(r4)
2a74: e9 03 00 00 ld r8,0(r3)
2a78: 7d 29 42 14 add r9,r9,r8
2a7c: f9 24 00 00 std r9,0(r4)
return region_is_subregion(outer, inner);
2a80: 4b ff ff 98 b 2a18 <region_is_subregion>
2a80: R_PPC64_REL24 region_is_subregion
...
0000000000002a90 <rdev_relative_offset>:
{
2a90: 3c 40 00 02 lis r2,2
2a92: R_PPC64_ADDR16_HA .TOC.
2a94: 38 42 80 00 addi r2,r2,-32768
2a96: R_PPC64_ADDR16_LO .TOC.
if (rdev->root == NULL)
2a98: e9 43 00 00 ld r10,0(r3)
2a9c: 2f aa 00 00 cmpdi cr7,r10,0
2aa0: 40 9e 00 08 bne cr7,2aa8 <rdev_relative_offset+0x18>
return rdev;
2aa4: 7c 6a 1b 78 mr r10,r3
if (rdev->root == NULL)
2aa8: e9 04 00 00 ld r8,0(r4)
2aac: 2f a8 00 00 cmpdi cr7,r8,0
2ab0: 40 9e 00 08 bne cr7,2ab8 <rdev_relative_offset+0x28>
return rdev;
2ab4: 7c 88 23 78 mr r8,r4
if (rdev_root(p) != rdev_root(c))
2ab8: 7f aa 40 40 cmpld cr7,r10,r8
return -1;
2abc: 39 20 ff ff li r9,-1
if (rdev_root(p) != rdev_root(c))
2ac0: 40 9e 00 50 bne cr7,2b10 <rdev_relative_offset+0x80>
{
2ac4: 7c 08 02 a6 mflr r0
2ac8: fb c1 ff f0 std r30,-16(r1)
2acc: fb e1 ff f8 std r31,-8(r1)
2ad0: 7c 9e 23 78 mr r30,r4
2ad4: 7c 7f 1b 78 mr r31,r3
if (!region_is_subregion(&p->region, &c->region))
2ad8: 38 84 00 10 addi r4,r4,16
2adc: 38 63 00 10 addi r3,r3,16
{
2ae0: f8 01 00 10 std r0,16(r1)
2ae4: f8 21 ff d1 stdu r1,-48(r1)
if (!region_is_subregion(&p->region, &c->region))
2ae8: 4b ff ff 31 bl 2a18 <region_is_subregion>
2ae8: R_PPC64_REL24 region_is_subregion
return -1;
2aec: 39 20 ff ff li r9,-1
if (!region_is_subregion(&p->region, &c->region))
2af0: 2f a3 00 00 cmpdi cr7,r3,0
2af4: 41 9e 00 10 beq cr7,2b04 <rdev_relative_offset+0x74>
return region_device_offset(c) - region_device_offset(p);
2af8: e9 5e 00 10 ld r10,16(r30)
2afc: e9 3f 00 10 ld r9,16(r31)
2b00: 7d 29 50 50 subf r9,r9,r10
}
2b04: 38 21 00 30 addi r1,r1,48
2b08: 7d 23 4b 78 mr r3,r9
2b0c: 48 00 22 28 b 4d34 <_restgpr0_30>
2b0c: R_PPC64_REL24 _restgpr0_30
2b10: 7d 23 4b 78 mr r3,r9
2b14: 4e 80 00 20 blr
2b18: 00 00 00 00 .long 0x0
2b1c: 00 00 00 01 .long 0x1
2b20: 80 02 00 00 lwz r0,0(r2)
0000000000002b24 <rdev_mmap>:
{
2b24: 3c 40 00 02 lis r2,2
2b26: R_PPC64_ADDR16_HA .TOC.
2b28: 38 42 80 00 addi r2,r2,-32768
2b2a: R_PPC64_ADDR16_LO .TOC.
2b2c: 7c 08 02 a6 mflr r0
2b30: fb e1 ff f8 std r31,-8(r1)
2b34: 7c 7f 1b 78 mr r31,r3
if (!normalize_and_ok(&rd->region, &req))
2b38: 38 63 00 10 addi r3,r3,16
{
2b3c: f8 01 00 10 std r0,16(r1)
2b40: f8 21 ff c1 stdu r1,-64(r1)
struct region req = {
2b44: f8 81 00 20 std r4,32(r1)
if (!normalize_and_ok(&rd->region, &req))
2b48: 38 81 00 20 addi r4,r1,32
struct region req = {
2b4c: f8 a1 00 28 std r5,40(r1)
if (!normalize_and_ok(&rd->region, &req))
2b50: 4b ff ff 21 bl 2a70 <normalize_and_ok+0x8>
2b50: R_PPC64_REL24 normalize_and_ok
2b54: 2f a3 00 00 cmpdi cr7,r3,0
2b58: 41 9e 00 50 beq cr7,2ba8 <rdev_mmap+0x84>
if (rdev->root == NULL)
2b5c: e9 3f 00 00 ld r9,0(r31)
2b60: 2f a9 00 00 cmpdi cr7,r9,0
2b64: 40 9e 00 08 bne cr7,2b6c <rdev_mmap+0x48>
return rdev;
2b68: 7f e9 fb 78 mr r9,r31
if (rdev->ops->mmap == NULL)
2b6c: e9 49 00 08 ld r10,8(r9)
return NULL;
2b70: 38 60 00 00 li r3,0
if (rdev->ops->mmap == NULL)
2b74: e9 4a 00 00 ld r10,0(r10)
2b78: 2f aa 00 00 cmpdi cr7,r10,0
2b7c: 41 9e 00 24 beq cr7,2ba0 <rdev_mmap+0x7c>
return rdev->ops->mmap(rdev, req.offset, req.size);
2b80: e8 a1 00 28 ld r5,40(r1)
2b84: e8 81 00 20 ld r4,32(r1)
2b88: 7d 23 4b 78 mr r3,r9
2b8c: f8 41 00 18 std r2,24(r1)
2b90: 7d 4c 53 78 mr r12,r10
2b94: 7d 49 03 a6 mtctr r10
2b98: 4e 80 04 21 bctrl
2b9c: e8 41 00 18 ld r2,24(r1)
}
2ba0: 38 21 00 40 addi r1,r1,64
2ba4: 48 00 21 94 b 4d38 <_restgpr0_31>
2ba4: R_PPC64_REL24 _restgpr0_31
return NULL;
2ba8: 38 60 00 00 li r3,0
2bac: 4b ff ff f4 b 2ba0 <rdev_mmap+0x7c>
2bb0: 00 00 00 00 .long 0x0
2bb4: 00 00 00 01 .long 0x1
2bb8: 80 01 00 00 lwz r0,0(r1)
0000000000002bbc <rdev_munmap>:
{
2bbc: 3c 40 00 02 lis r2,2
2bbe: R_PPC64_ADDR16_HA .TOC.
2bc0: 38 42 80 00 addi r2,r2,-32768
2bc2: R_PPC64_ADDR16_LO .TOC.
if (rdev->root == NULL)
2bc4: e9 23 00 00 ld r9,0(r3)
2bc8: 2f a9 00 00 cmpdi cr7,r9,0
2bcc: 40 9e 00 08 bne cr7,2bd4 <rdev_munmap+0x18>
return rdev;
2bd0: 7c 69 1b 78 mr r9,r3
if (rdev->ops->munmap == NULL)
2bd4: e9 49 00 08 ld r10,8(r9)
return -1;
2bd8: 38 60 ff ff li r3,-1
if (rdev->ops->munmap == NULL)
2bdc: e9 4a 00 08 ld r10,8(r10)
2be0: 2f aa 00 00 cmpdi cr7,r10,0
2be4: 4d 9e 00 20 beqlr cr7
{
2be8: 7c 08 02 a6 mflr r0
return rdev->ops->munmap(rdev, mapping);
2bec: 7d 23 4b 78 mr r3,r9
2bf0: 7d 4c 53 78 mr r12,r10
2bf4: 7d 49 03 a6 mtctr r10
{
2bf8: f8 01 00 10 std r0,16(r1)
2bfc: f8 21 ff e1 stdu r1,-32(r1)
return rdev->ops->munmap(rdev, mapping);
2c00: f8 41 00 18 std r2,24(r1)
2c04: 4e 80 04 21 bctrl
2c08: e8 41 00 18 ld r2,24(r1)
}
2c0c: 38 21 00 20 addi r1,r1,32
2c10: e8 01 00 10 ld r0,16(r1)
2c14: 7c 08 03 a6 mtlr r0
2c18: 4e 80 00 20 blr
2c1c: 00 00 00 00 .long 0x0
2c20: 00 00 00 01 .long 0x1
2c24: 80 00 00 00 lwz r0,0(0)
0000000000002c28 <rdev_readat>:
{
2c28: 3c 40 00 02 lis r2,2
2c2a: R_PPC64_ADDR16_HA .TOC.
2c2c: 38 42 80 00 addi r2,r2,-32768
2c2e: R_PPC64_ADDR16_LO .TOC.
2c30: 7c 08 02 a6 mflr r0
2c34: fb c1 ff f0 std r30,-16(r1)
2c38: fb e1 ff f8 std r31,-8(r1)
2c3c: 7c 9e 23 78 mr r30,r4
2c40: 7c 7f 1b 78 mr r31,r3
if (!normalize_and_ok(&rd->region, &req))
2c44: 38 63 00 10 addi r3,r3,16
{
2c48: f8 01 00 10 std r0,16(r1)
2c4c: f8 21 ff c1 stdu r1,-64(r1)
if (!normalize_and_ok(&rd->region, &req))
2c50: 38 81 00 20 addi r4,r1,32
struct region req = {
2c54: f8 a1 00 20 std r5,32(r1)
2c58: f8 c1 00 28 std r6,40(r1)
if (!normalize_and_ok(&rd->region, &req))
2c5c: 4b ff fe 15 bl 2a70 <normalize_and_ok+0x8>
2c5c: R_PPC64_REL24 normalize_and_ok
2c60: 2f a3 00 00 cmpdi cr7,r3,0
2c64: 41 9e 00 44 beq cr7,2ca8 <rdev_readat+0x80>
if (rdev->root == NULL)
2c68: e8 7f 00 00 ld r3,0(r31)
2c6c: 2f a3 00 00 cmpdi cr7,r3,0
2c70: 40 9e 00 08 bne cr7,2c78 <rdev_readat+0x50>
return rdev;
2c74: 7f e3 fb 78 mr r3,r31
return rdev->ops->readat(rdev, b, req.offset, req.size);
2c78: e9 23 00 08 ld r9,8(r3)
2c7c: e8 c1 00 28 ld r6,40(r1)
2c80: e8 a1 00 20 ld r5,32(r1)
2c84: 7f c4 f3 78 mr r4,r30
2c88: e9 29 00 10 ld r9,16(r9)
2c8c: f8 41 00 18 std r2,24(r1)
2c90: 7d 2c 4b 78 mr r12,r9
2c94: 7d 29 03 a6 mtctr r9
2c98: 4e 80 04 21 bctrl
2c9c: e8 41 00 18 ld r2,24(r1)
}
2ca0: 38 21 00 40 addi r1,r1,64
2ca4: 48 00 20 90 b 4d34 <_restgpr0_30>
2ca4: R_PPC64_REL24 _restgpr0_30
return -1;
2ca8: 38 60 ff ff li r3,-1
2cac: 4b ff ff f4 b 2ca0 <rdev_readat+0x78>
2cb0: 00 00 00 00 .long 0x0
2cb4: 00 00 00 01 .long 0x1
2cb8: 80 02 00 00 lwz r0,0(r2)
0000000000002cbc <rdev_chain>:
{
2cbc: 3c 40 00 02 lis r2,2
2cbe: R_PPC64_ADDR16_HA .TOC.
2cc0: 38 42 80 00 addi r2,r2,-32768
2cc2: R_PPC64_ADDR16_LO .TOC.
2cc4: 7c 08 02 a6 mflr r0
2cc8: fb c1 ff f0 std r30,-16(r1)
2ccc: fb e1 ff f8 std r31,-8(r1)
2cd0: 7c 9e 23 78 mr r30,r4
2cd4: 7c 7f 1b 78 mr r31,r3
if (!normalize_and_ok(&parent->region, &req))
2cd8: 38 7e 00 10 addi r3,r30,16
{
2cdc: f8 01 00 10 std r0,16(r1)
2ce0: f8 21 ff c1 stdu r1,-64(r1)
if (!normalize_and_ok(&parent->region, &req))
2ce4: 38 81 00 20 addi r4,r1,32
struct region req = {
2ce8: f8 a1 00 20 std r5,32(r1)
2cec: f8 c1 00 28 std r6,40(r1)
if (!normalize_and_ok(&parent->region, &req))
2cf0: 4b ff fd 81 bl 2a70 <normalize_and_ok+0x8>
2cf0: R_PPC64_REL24 normalize_and_ok
2cf4: 2f a3 00 00 cmpdi cr7,r3,0
2cf8: 41 9e 00 3c beq cr7,2d34 <rdev_chain+0x78>
if (rdev->root == NULL)
2cfc: e9 3e 00 00 ld r9,0(r30)
2d00: 2f a9 00 00 cmpdi cr7,r9,0
2d04: 40 9e 00 08 bne cr7,2d0c <rdev_chain+0x50>
return rdev;
2d08: 7f c9 f3 78 mr r9,r30
child->root = rdev_root(parent);
2d0c: f9 3f 00 00 std r9,0(r31)
child->ops = NULL;
2d10: 39 20 00 00 li r9,0
return 0;
2d14: 38 60 00 00 li r3,0
child->ops = NULL;
2d18: f9 3f 00 08 std r9,8(r31)
child->region.offset = req.offset;
2d1c: e9 21 00 20 ld r9,32(r1)
2d20: f9 3f 00 10 std r9,16(r31)
child->region.size = req.size;
2d24: e9 21 00 28 ld r9,40(r1)
2d28: f9 3f 00 18 std r9,24(r31)
}
2d2c: 38 21 00 40 addi r1,r1,64
2d30: 48 00 20 04 b 4d34 <_restgpr0_30>
2d30: R_PPC64_REL24 _restgpr0_30
return -1;
2d34: 38 60 ff ff li r3,-1
2d38: 4b ff ff f4 b 2d2c <rdev_chain+0x70>
2d3c: 00 00 00 00 .long 0x0
2d40: 00 00 00 01 .long 0x1
2d44: 80 02 00 00 lwz r0,0(r2)
0000000000002d48 <mem_region_device_ro_init>:
{
2d48: 3c 40 00 02 lis r2,2
2d4a: R_PPC64_ADDR16_HA .TOC.
2d4c: 38 42 80 00 addi r2,r2,-32768
2d4e: R_PPC64_ADDR16_LO .TOC.
2d50: 7c 08 02 a6 mflr r0
2d54: 48 00 1f 79 bl 4ccc <_savegpr0_29>
2d54: R_PPC64_REL24 _savegpr0_29
2d58: f8 21 ff c1 stdu r1,-64(r1)
2d5c: 7c 9d 23 78 mr r29,r4
2d60: 7c be 2b 78 mr r30,r5
memset(mdev, 0, sizeof(*mdev));
2d64: 38 80 00 00 li r4,0
2d68: 38 a0 00 28 li r5,40
{
2d6c: 7c 7f 1b 78 mr r31,r3
memset(mdev, 0, sizeof(*mdev));
2d70: 48 00 18 d5 bl 4644 <memset>
2d70: R_PPC64_REL24 memset
2d74: 60 00 00 00 nop
mdev->rdev.ops = ops;
2d78: 3d 22 ff ff addis r9,r2,-1
2d7a: R_PPC64_TOC16_HA .text+0x4a78
}
2d7c: 38 21 00 40 addi r1,r1,64
mdev->base = base;
2d80: fb bf 00 00 std r29,0(r31)
mdev->rdev.region.size = size;
2d84: fb df 00 20 std r30,32(r31)
mdev->rdev.ops = ops;
2d88: 39 29 ca 78 addi r9,r9,-13704
2d8a: R_PPC64_TOC16_LO .text+0x4a78
2d8c: f9 3f 00 10 std r9,16(r31)
}
2d90: 48 00 1f 8c b 4d1c <_restgpr0_29>
2d90: R_PPC64_REL24 _restgpr0_29
2d94: 00 00 00 00 .long 0x0
2d98: 00 00 00 01 .long 0x1
2d9c: 80 03 00 00 lwz r0,0(r3)
0000000000002da0 <console_hw_init>:
#include <console/spi.h>
#include <console/flash.h>
#include <console/system76_ec.h>
void console_hw_init(void)
{
2da0: 3c 40 00 02 lis r2,2
2da2: R_PPC64_ADDR16_HA .TOC.
2da4: 38 42 80 00 addi r2,r2,-32768
2da6: R_PPC64_ADDR16_LO .TOC.
2da8: 7c 08 02 a6 mflr r0
2dac: f8 01 00 10 std r0,16(r1)
2db0: f8 21 ff e1 stdu r1,-32(r1)
#define __CBMEM_CONSOLE_ENABLE__ (CONFIG(CONSOLE_CBMEM) && \
(ENV_RAMSTAGE || ENV_SEPARATE_VERSTAGE || ENV_POSTCAR || \
ENV_ROMSTAGE || (ENV_BOOTBLOCK && CONFIG(BOOTBLOCK_CONSOLE))))
#if __CBMEM_CONSOLE_ENABLE__
static inline void __cbmemc_init(void) { cbmemc_init(); }
2db4: 48 00 13 0d bl 40c0 <cbmemc_init+0x8>
2db4: R_PPC64_REL24 cbmemc_init
2db8: 60 00 00 00 nop
__ne2k_init();
__usbdebug_init();
__spiconsole_init();
__flashconsole_init();
__system76_ec_init();
}
2dbc: 38 21 00 20 addi r1,r1,32
2dc0: e8 01 00 10 ld r0,16(r1)
2dc4: 7c 08 03 a6 mtlr r0
2dc8: 4e 80 00 20 blr
2dcc: 00 00 00 00 .long 0x0
2dd0: 00 00 00 01 .long 0x1
2dd4: 80 00 00 00 lwz r0,0(0)
0000000000002dd8 <console_tx_byte>:
void console_tx_byte(unsigned char byte)
{
2dd8: 3c 40 00 02 lis r2,2
2dda: R_PPC64_ADDR16_HA .TOC.
2ddc: 38 42 80 00 addi r2,r2,-32768
2dde: R_PPC64_ADDR16_LO .TOC.
2de0: 7c 08 02 a6 mflr r0
2de4: f8 01 00 10 std r0,16(r1)
2de8: f8 21 ff e1 stdu r1,-32(r1)
static inline void __cbmemc_tx_byte(u8 data) { cbmemc_tx_byte(data); }
2dec: 48 00 13 6d bl 4158 <cbmemc_tx_byte+0x8>
2dec: R_PPC64_REL24 cbmemc_tx_byte
2df0: 60 00 00 00 nop
__ne2k_tx_byte(byte);
__usb_tx_byte(byte);
__spiconsole_tx_byte(byte);
__flashconsole_tx_byte(byte);
__system76_ec_tx_byte(byte);
}
2df4: 38 21 00 20 addi r1,r1,32
2df8: e8 01 00 10 ld r0,16(r1)
2dfc: 7c 08 03 a6 mtlr r0
2e00: 4e 80 00 20 blr
2e04: 00 00 00 00 .long 0x0
2e08: 00 00 00 01 .long 0x1
2e0c: 80 00 00 00 lwz r0,0(0)
0000000000002e10 <console_tx_flush>:
__uart_tx_flush();
__ne2k_tx_flush();
__usb_tx_flush();
__flashconsole_tx_flush();
__system76_ec_tx_flush();
}
2e10: 4e 80 00 20 blr
...
0000000000002e20 <die_notify>:
* EC is capable of controlling LEDs or a buzzer the method can be overwritten
* in EC directory instead.
*/
__weak void die_notify(void)
{
}
2e20: 4e 80 00 20 blr
...
0000000000002e30 <die>:
/* Report a fatal error */
void __noreturn die(const char *fmt, ...)
{
2e30: 3c 40 00 02 lis r2,2
2e32: R_PPC64_ADDR16_HA .TOC.
2e34: 38 42 80 00 addi r2,r2,-32768
2e36: R_PPC64_ADDR16_LO .TOC.
2e38: 7c 08 02 a6 mflr r0
2e3c: f8 01 00 10 std r0,16(r1)
2e40: f8 21 ff e1 stdu r1,-32(r1)
2e44: f8 81 00 48 std r4,72(r1)
2e48: f8 a1 00 50 std r5,80(r1)
va_list args;
va_start(args, fmt);
vprintk(BIOS_EMERG, fmt, args);
2e4c: 7c 64 1b 78 mr r4,r3
2e50: 38 a1 00 48 addi r5,r1,72
2e54: 38 60 00 00 li r3,0
{
2e58: f8 c1 00 58 std r6,88(r1)
2e5c: f8 e1 00 60 std r7,96(r1)
2e60: f9 01 00 68 std r8,104(r1)
2e64: f9 21 00 70 std r9,112(r1)
2e68: f9 41 00 78 std r10,120(r1)
vprintk(BIOS_EMERG, fmt, args);
2e6c: 48 00 02 39 bl 30a4 <do_vprintk+0x8>
2e6c: R_PPC64_REL24 do_vprintk
2e70: 60 00 00 00 nop
va_end(args);
die_notify();
2e74: 4b ff ff ad bl 2e20 <die_notify>
2e74: R_PPC64_REL24 die_notify
2e78: 60 00 00 00 nop
halt();
2e7c: 48 00 16 c9 bl 4544 <halt>
2e7c: R_PPC64_REL24 halt
2e80: 60 00 00 00 nop
2e84: 00 00 00 00 .long 0x0
2e88: 00 00 00 01 .long 0x1
2e8c: 80 00 00 00 lwz r0,0(0)
0000000000002e90 <console_log_level>:
set_log_level(debug_level);
}
int console_log_level(int msg_level)
{
2e90: 3c 40 00 02 lis r2,2
2e92: R_PPC64_ADDR16_HA .TOC.
2e94: 38 42 80 00 addi r2,r2,-32768
2e96: R_PPC64_ADDR16_LO .TOC.
if (console_inited == 0)
2e98: 3d 42 ff ff addis r10,r2,-1
2e9a: R_PPC64_TOC16_HA .bss
{
2e9c: 7c 69 1b 78 mr r9,r3
if (console_inited == 0)
2ea0: e8 6a cd e2 lwa r3,-12832(r10)
2ea2: R_PPC64_TOC16_LO_DS .bss
2ea4: 2f a3 00 00 cmpdi cr7,r3,0
2ea8: 4d 9e 00 20 beqlr cr7
return console_loglevel;
2eac: 3d 42 ff ff addis r10,r2,-1
2eae: R_PPC64_TOC16_HA .data+0x68
int log_level = get_log_level();
if (log_level < 0)
return CONSOLE_LOG_NONE;
2eb0: 38 60 00 00 li r3,0
return console_loglevel;
2eb4: e9 4a cd b2 lwa r10,-12880(r10)
2eb6: R_PPC64_TOC16_LO_DS .data+0x68
if (log_level < 0)
2eb8: 2f 8a 00 00 cmpwi cr7,r10,0
2ebc: 4d 9c 00 20 bltlr cr7
if (msg_level <= log_level)
2ec0: 7f 89 50 00 cmpw cr7,r9,r10
return CONSOLE_LOG_ALL;
2ec4: 38 60 00 02 li r3,2
if (msg_level <= log_level)
2ec8: 4c 9d 00 20 blelr cr7
return CONSOLE_LOG_NONE;
2ecc: 2f 89 00 07 cmpwi cr7,r9,7
2ed0: 39 20 00 01 li r9,1
2ed4: 7c 60 4f 5e isel r3,0,r9,29
if (CONFIG(CONSOLE_CBMEM) && (msg_level <= BIOS_DEBUG))
return CONSOLE_LOG_FAST;
return 0;
}
2ed8: 4e 80 00 20 blr
...
0000000000002ee8 <console_init>:
asmlinkage void console_init(void)
{
2ee8: 3c 40 00 02 lis r2,2
2eea: R_PPC64_ADDR16_HA .TOC.
2eec: 38 42 80 00 addi r2,r2,-32768
2eee: R_PPC64_ADDR16_LO .TOC.
2ef0: 7c 08 02 a6 mflr r0
2ef4: fb e1 ff f8 std r31,-8(r1)
console_loglevel = new_level;
2ef8: 39 20 00 07 li r9,7
2efc: 3f e2 ff ff addis r31,r2,-1
2efe: R_PPC64_TOC16_HA .data+0x68
2f00: 91 3f cd b0 stw r9,-12880(r31)
2f02: R_PPC64_TOC16_LO .data+0x68
{
2f04: f8 01 00 10 std r0,16(r1)
2f08: f8 21 ff 91 stdu r1,-112(r1)
console_inited = 1;
if (CONFIG(EARLY_PCI_BRIDGE) && (ENV_BOOTBLOCK || ENV_ROMSTAGE))
pci_early_bridge_init();
console_hw_init();
2f0c: 4b ff fe 9d bl 2da8 <console_hw_init+0x8>
2f0c: R_PPC64_REL24 console_hw_init
2f10: 60 00 00 00 nop
console_inited = 1;
printk(BIOS_NOTICE, "\n\ncoreboot-%s%s %s " ENV_STRING " starting (log level: %i)...\n",
2f14: e9 1f cd b2 lwa r8,-12880(r31)
2f16: R_PPC64_TOC16_LO_DS .data+0x68
2f18: 3c e2 ff ff addis r7,r2,-1
2f1a: R_PPC64_TOC16_HA coreboot_build
2f1c: 38 e7 cc 50 addi r7,r7,-13232
2f1e: R_PPC64_TOC16_LO coreboot_build
2f20: 3c c2 ff ff addis r6,r2,-1
2f22: R_PPC64_TOC16_HA coreboot_extra_version
2f24: 38 c6 cc 70 addi r6,r6,-13200
2f26: R_PPC64_TOC16_LO coreboot_extra_version
2f28: 3c a2 ff ff addis r5,r2,-1
2f2a: R_PPC64_TOC16_HA coreboot_version
2f2c: 38 a5 cc 78 addi r5,r5,-13192
2f2e: R_PPC64_TOC16_LO coreboot_version
2f30: 3c 82 ff ff addis r4,r2,-1
2f32: R_PPC64_TOC16_HA .text+0x4aa0
console_inited = 1;
2f34: 39 20 00 01 li r9,1
2f38: 3d 42 ff ff addis r10,r2,-1
2f3a: R_PPC64_TOC16_HA .bss
printk(BIOS_NOTICE, "\n\ncoreboot-%s%s %s " ENV_STRING " starting (log level: %i)...\n",
2f3c: 38 60 00 05 li r3,5
2f40: 38 84 ca a0 addi r4,r4,-13664
2f42: R_PPC64_TOC16_LO .text+0x4aa0
console_inited = 1;
2f44: 91 2a cd e0 stw r9,-12832(r10)
2f46: R_PPC64_TOC16_LO .bss
printk(BIOS_NOTICE, "\n\ncoreboot-%s%s %s " ENV_STRING " starting (log level: %i)...\n",
2f48: 48 00 02 05 bl 314c <do_printk+0x8>
2f48: R_PPC64_REL24 do_printk
2f4c: 60 00 00 00 nop
coreboot_version, coreboot_extra_version, coreboot_build,
get_log_level());
}
2f50: 38 21 00 70 addi r1,r1,112
2f54: 48 00 1d e4 b 4d38 <_restgpr0_31>
2f54: R_PPC64_REL24 _restgpr0_31
2f58: 00 00 00 00 .long 0x0
2f5c: 00 00 00 01 .long 0x1
2f60: 80 01 00 00 lwz r0,0(r1)
0000000000002f64 <arch_post_code>:
2f64: 4e 80 00 20 blr
...
0000000000002f74 <mainboard_post>:
void __weak arch_post_code(uint8_t value) { }
/* Some mainboards have very nice features beyond just a simple display.
* They can override this function.
*/
void __weak mainboard_post(uint8_t value) { }
2f74: 4e 80 00 20 blr
...
0000000000002f84 <post_code>:
void post_code(uint8_t value)
{
2f84: 3c 40 00 02 lis r2,2
2f86: R_PPC64_ADDR16_HA .TOC.
2f88: 38 42 80 00 addi r2,r2,-32768
2f8a: R_PPC64_ADDR16_LO .TOC.
2f8c: 7c 08 02 a6 mflr r0
2f90: fb e1 ff f8 std r31,-8(r1)
2f94: 7c 7f 1b 78 mr r31,r3
2f98: f8 01 00 10 std r0,16(r1)
2f9c: f8 21 ff d1 stdu r1,-48(r1)
if (!CONFIG(NO_POST)) {
/* Assume this to be the most reliable and simplest type
for displaying POST so keep it first. */
arch_post_code(value);
2fa0: 4b ff ff c5 bl 2f64 <arch_post_code>
2fa0: R_PPC64_REL24 arch_post_code
2fa4: 60 00 00 00 nop
if (CONFIG(CONSOLE_POST))
printk(BIOS_EMERG, "POST: 0x%02x\n", value);
mainboard_post(value);
2fa8: 7f e3 fb 78 mr r3,r31
2fac: 4b ff ff c9 bl 2f74 <mainboard_post>
2fac: R_PPC64_REL24 mainboard_post
2fb0: 60 00 00 00 nop
}
}
2fb4: 38 21 00 30 addi r1,r1,48
2fb8: 48 00 1d 80 b 4d38 <_restgpr0_31>
2fb8: R_PPC64_REL24 _restgpr0_31
2fbc: 00 00 00 00 .long 0x0
2fc0: 00 00 00 01 .long 0x1
2fc4: 80 01 00 00 lwz r0,0(r1)
0000000000002fc8 <wrap_putchar>:
console_tx_byte(byte);
console_time_stop();
}
static void wrap_putchar(unsigned char byte, void *data)
{
2fc8: 3c 40 00 02 lis r2,2
2fca: R_PPC64_ADDR16_HA .TOC.
2fcc: 38 42 80 00 addi r2,r2,-32768
2fce: R_PPC64_ADDR16_LO .TOC.
2fd0: 7c 08 02 a6 mflr r0
2fd4: f8 01 00 10 std r0,16(r1)
2fd8: f8 21 ff e1 stdu r1,-32(r1)
console_tx_byte(byte);
2fdc: 4b ff fe 05 bl 2de0 <console_tx_byte+0x8>
2fdc: R_PPC64_REL24 console_tx_byte
2fe0: 60 00 00 00 nop
}
2fe4: 38 21 00 20 addi r1,r1,32
2fe8: e8 01 00 10 ld r0,16(r1)
2fec: 7c 08 03 a6 mtlr r0
2ff0: 4e 80 00 20 blr
2ff4: 00 00 00 00 .long 0x0
2ff8: 00 00 00 01 .long 0x1
2ffc: 80 00 00 00 lwz r0,0(0)
0000000000003000 <console_time_stop>:
{
3000: 3c 40 00 02 lis r2,2
3002: R_PPC64_ADDR16_HA .TOC.
3004: 38 42 80 00 addi r2,r2,-32768
3006: R_PPC64_ADDR16_LO .TOC.
3008: 7c 08 02 a6 mflr r0
timer_monotonic_get(&mt_stop);
300c: 3c 62 ff ff addis r3,r2,-1
300e: R_PPC64_TOC16_HA .bss+0x18
3010: 38 63 cd f8 addi r3,r3,-12808
3012: R_PPC64_TOC16_LO .bss+0x18
{
3014: f8 01 00 10 std r0,16(r1)
3018: f8 21 ff e1 stdu r1,-32(r1)
timer_monotonic_get(&mt_stop);
301c: 4b ff f0 01 bl 201c <timer_monotonic_get>
301c: R_PPC64_REL24 timer_monotonic_get
3020: 60 00 00 00 nop
/* Return time difference between t1 and t2. i.e. t2 - t1. */
static inline long mono_time_diff_microseconds(const struct mono_time *t1,
const struct mono_time *t2)
{
return t2->microseconds - t1->microseconds;
3024: 3d 42 ff ff addis r10,r2,-1
3026: R_PPC64_TOC16_HA .bss+0x18
3028: e9 4a cd f8 ld r10,-12808(r10)
302a: R_PPC64_TOC16_LO_DS .bss+0x18
302c: 3d 22 ff ff addis r9,r2,-1
302e: R_PPC64_TOC16_HA .bss+0x10
3030: e9 29 cd f0 ld r9,-12816(r9)
3032: R_PPC64_TOC16_LO_DS .bss+0x10
console_usecs += mono_time_diff_microseconds(&mt_start, &mt_stop);
3034: 3d 02 ff ff addis r8,r2,-1
3036: R_PPC64_TOC16_HA .bss+0x8
}
3038: 38 21 00 20 addi r1,r1,32
303c: e8 01 00 10 ld r0,16(r1)
3040: 7d 29 50 50 subf r9,r9,r10
console_usecs += mono_time_diff_microseconds(&mt_start, &mt_stop);
3044: e9 48 cd e8 ld r10,-12824(r8)
3046: R_PPC64_TOC16_LO_DS .bss+0x8
}
3048: 7c 08 03 a6 mtlr r0
console_usecs += mono_time_diff_microseconds(&mt_start, &mt_stop);
304c: 7d 29 52 14 add r9,r9,r10
3050: f9 28 cd e8 std r9,-12824(r8)
3052: R_PPC64_TOC16_LO_DS .bss+0x8
}
3054: 4e 80 00 20 blr
3058: 00 00 00 00 .long 0x0
305c: 00 00 00 01 .long 0x1
3060: 80 00 00 00 lwz r0,0(0)
0000000000003064 <wrap_putchar_cbmemc>:
static void wrap_putchar_cbmemc(unsigned char byte, void *data)
{
3064: 3c 40 00 02 lis r2,2
3066: R_PPC64_ADDR16_HA .TOC.
3068: 38 42 80 00 addi r2,r2,-32768
306a: R_PPC64_ADDR16_LO .TOC.
306c: 7c 08 02 a6 mflr r0
3070: f8 01 00 10 std r0,16(r1)
3074: f8 21 ff e1 stdu r1,-32(r1)
3078: 48 00 10 e1 bl 4158 <cbmemc_tx_byte+0x8>
3078: R_PPC64_REL24 cbmemc_tx_byte
307c: 60 00 00 00 nop
__cbmemc_tx_byte(byte);
}
3080: 38 21 00 20 addi r1,r1,32
3084: e8 01 00 10 ld r0,16(r1)
3088: 7c 08 03 a6 mtlr r0
308c: 4e 80 00 20 blr
3090: 00 00 00 00 .long 0x0
3094: 00 00 00 01 .long 0x1
3098: 80 00 00 00 lwz r0,0(0)
000000000000309c <do_vprintk>:
int do_vprintk(int msg_level, const char *fmt, va_list args)
{
309c: 3c 40 00 02 lis r2,2
309e: R_PPC64_ADDR16_HA .TOC.
30a0: 38 42 80 00 addi r2,r2,-32768
30a2: R_PPC64_ADDR16_LO .TOC.
30a4: 7c 08 02 a6 mflr r0
30a8: 48 00 1c 25 bl 4ccc <_savegpr0_29>
30a8: R_PPC64_REL24 _savegpr0_29
30ac: f8 21 ff c1 stdu r1,-64(r1)
30b0: 7c 9e 23 78 mr r30,r4
30b4: 7c bd 2b 78 mr r29,r5
if (CONFIG(SQUELCH_EARLY_SMP) && ENV_ROMSTAGE_OR_BEFORE && !boot_cpu())
return 0;
log_this = console_log_level(msg_level);
if (log_this < CONSOLE_LOG_FAST)
return 0;
30b8: 3b e0 00 00 li r31,0
log_this = console_log_level(msg_level);
30bc: 4b ff fd dd bl 2e98 <console_log_level+0x8>
30bc: R_PPC64_REL24 console_log_level
30c0: 60 00 00 00 nop
if (log_this < CONSOLE_LOG_FAST)
30c4: 2f 83 00 00 cmpwi cr7,r3,0
30c8: 40 9d 00 44 ble cr7,310c <do_vprintk+0x70>
30cc: 7c 7f 1b 78 mr r31,r3
timer_monotonic_get(&mt_start);
30d0: 3c 62 ff ff addis r3,r2,-1
30d2: R_PPC64_TOC16_HA .bss+0x10
30d4: 38 63 cd f0 addi r3,r3,-12816
30d6: R_PPC64_TOC16_LO .bss+0x10
30d8: 4b ff ef 45 bl 201c <timer_monotonic_get>
30d8: R_PPC64_REL24 timer_monotonic_get
30dc: 60 00 00 00 nop
DISABLE_TRACE;
spin_lock(&console_lock);
console_time_run();
if (log_this == CONSOLE_LOG_FAST) {
30e0: 2f 9f 00 01 cmpwi cr7,r31,1
i = vtxprintf(wrap_putchar_cbmemc, fmt, args, NULL);
30e4: 38 c0 00 00 li r6,0
30e8: 7f a5 eb 78 mr r5,r29
30ec: 7f c4 f3 78 mr r4,r30
if (log_this == CONSOLE_LOG_FAST) {
30f0: 40 9e 00 28 bne cr7,3118 <do_vprintk+0x7c>
i = vtxprintf(wrap_putchar_cbmemc, fmt, args, NULL);
30f4: 3c 62 ff ff addis r3,r2,-1
30f6: R_PPC64_TOC16_HA .text+0x3064
30f8: 38 63 b0 64 addi r3,r3,-20380
30fa: R_PPC64_TOC16_LO .text+0x3064
30fc: 48 00 05 9d bl 3698 <vtxprintf+0x8>
30fc: R_PPC64_REL24 vtxprintf
3100: 60 00 00 00 nop
3104: 7c 7f 1b 78 mr r31,r3
} else {
i = vtxprintf(wrap_putchar, fmt, args, NULL);
console_tx_flush();
}
console_time_stop();
3108: 4b ff ff 01 bl 3008 <console_time_stop+0x8>
3108: R_PPC64_REL24 console_time_stop
spin_unlock(&console_lock);
ENABLE_TRACE;
return i;
}
310c: 38 21 00 40 addi r1,r1,64
3110: 7f e3 fb 78 mr r3,r31
3114: 48 00 1c 08 b 4d1c <_restgpr0_29>
3114: R_PPC64_REL24 _restgpr0_29
i = vtxprintf(wrap_putchar, fmt, args, NULL);
3118: 3c 62 ff ff addis r3,r2,-1
311a: R_PPC64_TOC16_HA .text+0x2fc8
311c: 38 63 af c8 addi r3,r3,-20536
311e: R_PPC64_TOC16_LO .text+0x2fc8
3120: 48 00 05 79 bl 3698 <vtxprintf+0x8>
3120: R_PPC64_REL24 vtxprintf
3124: 60 00 00 00 nop
3128: 7c 7f 1b 78 mr r31,r3
console_tx_flush();
312c: 4b ff fc e5 bl 2e10 <console_tx_flush>
312c: R_PPC64_REL24 console_tx_flush
3130: 60 00 00 00 nop
3134: 4b ff ff d4 b 3108 <do_vprintk+0x6c>
3138: 00 00 00 00 .long 0x0
313c: 00 00 00 01 .long 0x1
3140: 80 03 00 00 lwz r0,0(r3)
0000000000003144 <do_printk>:
int do_printk(int msg_level, const char *fmt, ...)
{
3144: 3c 40 00 02 lis r2,2
3146: R_PPC64_ADDR16_HA .TOC.
3148: 38 42 80 00 addi r2,r2,-32768
314a: R_PPC64_ADDR16_LO .TOC.
314c: 7c 08 02 a6 mflr r0
3150: f8 01 00 10 std r0,16(r1)
3154: f8 21 ff e1 stdu r1,-32(r1)
3158: f8 a1 00 50 std r5,80(r1)
va_list args;
int i;
va_start(args, fmt);
i = do_vprintk(msg_level, fmt, args);
315c: 38 a1 00 50 addi r5,r1,80
{
3160: f8 c1 00 58 std r6,88(r1)
3164: f8 e1 00 60 std r7,96(r1)
3168: f9 01 00 68 std r8,104(r1)
316c: f9 21 00 70 std r9,112(r1)
3170: f9 41 00 78 std r10,120(r1)
i = do_vprintk(msg_level, fmt, args);
3174: 4b ff ff 31 bl 30a4 <do_vprintk+0x8>
3174: R_PPC64_REL24 do_vprintk
va_end(args);
return i;
}
3178: 38 21 00 20 addi r1,r1,32
317c: e8 01 00 10 ld r0,16(r1)
3180: 7c 08 03 a6 mtlr r0
3184: 4e 80 00 20 blr
3188: 00 00 00 00 .long 0x0
318c: 00 00 00 01 .long 0x1
3190: 80 00 00 00 lwz r0,0(0)
0000000000003194 <console_time_report>:
{
3194: 3c 40 00 02 lis r2,2
3196: R_PPC64_ADDR16_HA .TOC.
3198: 38 42 80 00 addi r2,r2,-32768
319a: R_PPC64_ADDR16_LO .TOC.
printk(BIOS_DEBUG, "BS: " ENV_STRING " times (exec / console): total (unknown) / %ld ms\n",
319c: 3c a2 ff ff addis r5,r2,-1
319e: R_PPC64_TOC16_HA .bss+0x8
31a0: e8 a5 cd e8 ld r5,-12824(r5)
31a2: R_PPC64_TOC16_LO_DS .bss+0x8
{
31a4: 7c 08 02 a6 mflr r0
printk(BIOS_DEBUG, "BS: " ENV_STRING " times (exec / console): total (unknown) / %ld ms\n",
31a8: 2f a5 00 00 cmpdi cr7,r5,0
{
31ac: f8 01 00 10 std r0,16(r1)
31b0: f8 21 ff a1 stdu r1,-96(r1)
printk(BIOS_DEBUG, "BS: " ENV_STRING " times (exec / console): total (unknown) / %ld ms\n",
31b4: 40 9d 00 30 ble cr7,31e4 <console_time_report+0x50>
31b8: 38 a5 01 f4 addi r5,r5,500
31bc: 39 20 03 e8 li r9,1000
31c0: 3c 82 ff ff addis r4,r2,-1
31c2: R_PPC64_TOC16_HA .text+0x4ada
31c4: 38 60 00 07 li r3,7
31c8: 7c a5 4b d2 divd r5,r5,r9
31cc: 38 84 ca da addi r4,r4,-13606
31ce: R_PPC64_TOC16_LO .text+0x4ada
31d0: 4b ff ff 7d bl 314c <do_printk+0x8>
31d0: R_PPC64_REL24 do_printk
}
31d4: 38 21 00 60 addi r1,r1,96
31d8: e8 01 00 10 ld r0,16(r1)
31dc: 7c 08 03 a6 mtlr r0
31e0: 4e 80 00 20 blr
printk(BIOS_DEBUG, "BS: " ENV_STRING " times (exec / console): total (unknown) / %ld ms\n",
31e4: 38 a5 fe 0c addi r5,r5,-500
31e8: 4b ff ff d4 b 31bc <console_time_report+0x28>
31ec: 00 00 00 00 .long 0x0
31f0: 00 00 00 01 .long 0x1
31f4: 80 00 00 00 lwz r0,0(0)
00000000000031f8 <str_tx_byte>:
};
static void str_tx_byte(unsigned char byte, void *data)
{
struct vsnprintf_context *ctx = data;
if (ctx->buf_limit) {
31f8: e9 24 00 08 ld r9,8(r4)
31fc: 2f a9 00 00 cmpdi cr7,r9,0
3200: 4d 9e 00 20 beqlr cr7
*ctx->str_buf = byte;
3204: e9 24 00 00 ld r9,0(r4)
3208: 98 69 00 00 stb r3,0(r9)
ctx->str_buf++;
320c: e9 24 00 00 ld r9,0(r4)
3210: 39 29 00 01 addi r9,r9,1
3214: f9 24 00 00 std r9,0(r4)
ctx->buf_limit--;
3218: e9 24 00 08 ld r9,8(r4)
321c: 39 29 ff ff addi r9,r9,-1
3220: f9 24 00 08 std r9,8(r4)
}
}
3224: 4e 80 00 20 blr
...
0000000000003234 <vsnprintf>:
int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
{
3234: 3c 40 00 02 lis r2,2
3236: R_PPC64_ADDR16_HA .TOC.
3238: 38 42 80 00 addi r2,r2,-32768
323a: R_PPC64_ADDR16_LO .TOC.
323c: 7c 08 02 a6 mflr r0
3240: 7d 90 80 26 mfocrf r12,8
3244: 7c aa 2b 78 mr r10,r5
struct vsnprintf_context ctx;
DISABLE_TRACE;
ctx.str_buf = buf;
ctx.buf_limit = size ? size - 1 : 0;
3248: 39 24 ff ff addi r9,r4,-1
{
324c: 7c c5 33 78 mr r5,r6
3250: 91 81 00 08 stw r12,8(r1)
ctx.buf_limit = size ? size - 1 : 0;
3254: 2e 24 00 00 cmpdi cr4,r4,0
{
3258: f8 01 00 10 std r0,16(r1)
325c: f8 21 ff d1 stdu r1,-48(r1)
ctx.str_buf = buf;
3260: f8 61 00 20 std r3,32(r1)
ctx.buf_limit = size ? size - 1 : 0;
3264: 40 92 00 08 bne cr4,326c <vsnprintf+0x38>
3268: 39 20 00 00 li r9,0
i = vtxprintf(str_tx_byte, fmt, args, &ctx);
326c: 3c 62 ff ff addis r3,r2,-1
326e: R_PPC64_TOC16_HA .text+0x31f8
3270: 38 c1 00 20 addi r6,r1,32
3274: 7d 44 53 78 mr r4,r10
ctx.buf_limit = size ? size - 1 : 0;
3278: f9 21 00 28 std r9,40(r1)
i = vtxprintf(str_tx_byte, fmt, args, &ctx);
327c: 38 63 b1 f8 addi r3,r3,-19976
327e: R_PPC64_TOC16_LO .text+0x31f8
3280: 48 00 04 19 bl 3698 <vtxprintf+0x8>
3280: R_PPC64_REL24 vtxprintf
3284: 60 00 00 00 nop
if (size)
3288: 41 92 00 10 beq cr4,3298 <vsnprintf+0x64>
*ctx.str_buf = '\0';
328c: e9 21 00 20 ld r9,32(r1)
3290: 39 40 00 00 li r10,0
3294: 99 49 00 00 stb r10,0(r9)
ENABLE_TRACE;
return i;
}
3298: 38 21 00 30 addi r1,r1,48
329c: e8 01 00 10 ld r0,16(r1)
32a0: 81 81 00 08 lwz r12,8(r1)
32a4: 7c 08 03 a6 mtlr r0
32a8: 7d 90 81 20 mtocrf 8,r12
32ac: 4e 80 00 20 blr
32b0: 00 00 00 00 .long 0x0
32b4: 00 00 00 03 .long 0x3
32b8: 80 00 00 00 lwz r0,0(0)
00000000000032bc <snprintf>:
int snprintf(char *buf, size_t size, const char *fmt, ...)
{
32bc: 3c 40 00 02 lis r2,2
32be: R_PPC64_ADDR16_HA .TOC.
32c0: 38 42 80 00 addi r2,r2,-32768
32c2: R_PPC64_ADDR16_LO .TOC.
32c4: 7c 08 02 a6 mflr r0
32c8: f8 01 00 10 std r0,16(r1)
32cc: f8 21 ff e1 stdu r1,-32(r1)
32d0: f8 c1 00 58 std r6,88(r1)
va_list args;
int i;
va_start(args, fmt);
i = vsnprintf(buf, size, fmt, args);
32d4: 38 c1 00 58 addi r6,r1,88
{
32d8: f8 e1 00 60 std r7,96(r1)
32dc: f9 01 00 68 std r8,104(r1)
32e0: f9 21 00 70 std r9,112(r1)
32e4: f9 41 00 78 std r10,120(r1)
i = vsnprintf(buf, size, fmt, args);
32e8: 4b ff ff 55 bl 323c <vsnprintf+0x8>
32e8: R_PPC64_REL24 vsnprintf
va_end(args);
return i;
}
32ec: 38 21 00 20 addi r1,r1,32
32f0: e8 01 00 10 ld r0,16(r1)
32f4: 7c 08 03 a6 mtlr r0
32f8: 4e 80 00 20 blr
32fc: 00 00 00 00 .long 0x0
3300: 00 00 00 01 .long 0x1
3304: 80 00 00 00 lwz r0,0(0)
0000000000003308 <number>:
#define LARGE 64 /* use 'ABCDEF' instead of 'abcdef' */
static int number(void (*tx_byte)(unsigned char byte, void *data),
unsigned long long inum, int base, int size, int precision, int type,
void *data)
{
3308: 3c 40 00 02 lis r2,2
330a: R_PPC64_ADDR16_HA .TOC.
330c: 38 42 80 00 addi r2,r2,-32768
330e: R_PPC64_ADDR16_LO .TOC.
3310: 7c 08 02 a6 mflr r0
char c, sign, tmp[66];
const char *digits = "0123456789abcdef";
3314: 3d 42 ff ff addis r10,r2,-1
3316: R_PPC64_TOC16_HA .text+0x4b1a
{
3318: 7d 80 00 26 mfcr r12
const char *digits = "0123456789abcdef";
331c: 39 4a cb 1a addi r10,r10,-13542
331e: R_PPC64_TOC16_LO .text+0x4b1a
{
3320: 48 00 19 8d bl 4cac <_savegpr0_21>
3320: R_PPC64_REL24 _savegpr0_21
3324: 7d 39 4b 78 mr r25,r9
int i;
int count = 0;
unsigned long long num = inum;
long long snum = num;
if (type & LARGE)
3328: 71 09 00 40 andi. r9,r8,64
{
332c: 7c 7c 1b 78 mr r28,r3
3330: 7c b8 2b 78 mr r24,r5
3334: 91 81 00 08 stw r12,8(r1)
3338: 7d 1d 43 78 mr r29,r8
333c: f8 21 ff 31 stdu r1,-208(r1)
if (type & LARGE)
3340: 41 82 00 0c beq 334c <number+0x44>
digits = "0123456789ABCDEF";
3344: 3d 42 ff ff addis r10,r2,-1
3346: R_PPC64_TOC16_HA .text+0x4b2b
3348: 39 4a cb 2b addi r10,r10,-13525
334a: R_PPC64_TOC16_LO .text+0x4b2b
if (type & LEFT)
334c: 57 a9 06 f6 rlwinm r9,r29,0,27,27
3350: 7d 29 07 b4 extsw r9,r9
3354: 2e 29 00 00 cmpdi cr4,r9,0
3358: 41 92 01 3c beq cr4,3494 <number+0x18c>
type &= ~ZEROPAD;
335c: 57 bd 00 3c rlwinm r29,r29,0,0,30
c = (type & ZEROPAD) ? '0' : ' ';
3360: 3a c0 00 20 li r22,32
type &= ~ZEROPAD;
3364: 7f bd 07 b4 extsw r29,r29
sign = 0;
if (type & SIGN) {
3368: 73 a9 00 02 andi. r9,r29,2
sign = 0;
336c: 3a a0 00 00 li r21,0
if (type & SIGN) {
3370: 41 82 00 1c beq 338c <number+0x84>
if (snum < 0) {
3374: 2f a4 00 00 cmpdi cr7,r4,0
3378: 40 9c 01 30 bge cr7,34a8 <number+0x1a0>
sign = '-';
num = -snum;
size--;
337c: 38 c6 ff ff addi r6,r6,-1
num = -snum;
3380: 7c 84 00 d0 neg r4,r4
sign = '-';
3384: 3a a0 00 2d li r21,45
size--;
3388: 7c c6 07 b4 extsw r6,r6
} else if (type & SPACE) {
sign = ' ';
size--;
}
}
if (type & SPECIAL) {
338c: 57 a9 06 b4 rlwinm r9,r29,0,26,26
3390: 7d 29 07 b4 extsw r9,r9
3394: 2d a9 00 00 cmpdi cr3,r9,0
3398: 41 8e 00 14 beq cr3,33ac <number+0xa4>
if (base == 16)
339c: 2f 98 00 10 cmpwi cr7,r24,16
33a0: 40 9e 01 38 bne cr7,34d8 <number+0x1d0>
size -= 2;
33a4: 38 c6 ff fe addi r6,r6,-2
else if (base == 8)
size--;
33a8: 7c c6 07 b4 extsw r6,r6
}
i = 0;
if (num == 0) {
33ac: 2f a4 00 00 cmpdi cr7,r4,0
33b0: 40 9e 01 38 bne cr7,34e8 <number+0x1e0>
tmp[i++] = '0';
33b4: 39 20 00 30 li r9,48
33b8: 3b 40 00 01 li r26,1
33bc: 99 21 00 20 stb r9,32(r1)
while (num != 0) {
tmp[i++] = digits[num % base];
num /= base;
}
}
if (i > precision) {
33c0: 7f 87 d0 00 cmpw cr7,r7,r26
precision = i;
}
size -= precision;
if (!(type&(ZEROPAD+LEFT))) {
33c4: 73 a9 00 11 andi. r9,r29,17
int count = 0;
33c8: 3b e0 00 00 li r31,0
33cc: 7c e7 d7 5e isel r7,r7,r26,29
size -= precision;
33d0: 7f 67 30 50 subf r27,r7,r6
33d4: 7c f7 07 b4 extsw r23,r7
33d8: 7f 7e 07 b4 extsw r30,r27
if (!(type&(ZEROPAD+LEFT))) {
33dc: 40 82 00 28 bne 3404 <number+0xfc>
33e0: 7b 7f 00 20 clrldi r31,r27,32
while (size-- > 0)
33e4: 2f 9f 00 00 cmpwi cr7,r31,0
33e8: 41 9d 01 34 bgt cr7,351c <number+0x214>
33ec: 2f 9b 00 00 cmpwi cr7,r27,0
33f0: 38 db ff ff addi r6,r27,-1
33f4: 7f c0 df 1e isel r30,0,r27,28
33f8: 7f df 07 b4 extsw r31,r30
33fc: 7f de 30 50 subf r30,r30,r6
3400: 7f de 07 b4 extsw r30,r30
call_tx(' '), count++;
}
if (sign) {
3404: 2f b5 00 00 cmpdi cr7,r21,0
3408: 41 9e 00 28 beq cr7,3430 <number+0x128>
call_tx(sign), count++;
340c: 7f 24 cb 78 mr r4,r25
3410: 7e a3 ab 78 mr r3,r21
3414: f8 41 00 18 std r2,24(r1)
3418: 7f 8c e3 78 mr r12,r28
341c: 7f 89 03 a6 mtctr r28
3420: 3b ff 00 01 addi r31,r31,1
3424: 7f ff 07 b4 extsw r31,r31
3428: 4e 80 04 21 bctrl
342c: e8 41 00 18 ld r2,24(r1)
}
if (type & SPECIAL) {
3430: 41 8e 00 30 beq cr3,3460 <number+0x158>
if (base == 8)
3434: 2f 98 00 08 cmpwi cr7,r24,8
3438: 40 9e 01 0c bne cr7,3544 <number+0x23c>
call_tx('0'), count++;
343c: 7f 24 cb 78 mr r4,r25
3440: 38 60 00 30 li r3,48
3444: f8 41 00 18 std r2,24(r1)
3448: 7f 8c e3 78 mr r12,r28
344c: 7f 89 03 a6 mtctr r28
3450: 3b ff 00 01 addi r31,r31,1
3454: 7f ff 07 b4 extsw r31,r31
3458: 4e 80 04 21 bctrl
345c: e8 41 00 18 ld r2,24(r1)
call_tx('X'), count++;
else
call_tx('x'), count++;
}
}
if (!(type & LEFT)) {
3460: 40 92 00 2c bne cr4,348c <number+0x184>
3464: 7b dd 00 20 clrldi r29,r30,32
while (size-- > 0)
3468: 2f 9d 00 00 cmpwi cr7,r29,0
346c: 41 9d 01 30 bgt cr7,359c <number+0x294>
3470: 2f 9e 00 00 cmpwi cr7,r30,0
3474: 7d 20 f7 1e isel r9,0,r30,28
3478: 3b de ff ff addi r30,r30,-1
347c: 7f ff 4a 14 add r31,r31,r9
3480: 7f c9 f0 50 subf r30,r9,r30
3484: 7f ff 07 b4 extsw r31,r31
3488: 7f de 07 b4 extsw r30,r30
348c: 7e ff ba 14 add r23,r31,r23
3490: 48 00 01 58 b 35e8 <number+0x2e0>
c = (type & ZEROPAD) ? '0' : ' ';
3494: 73 a9 00 01 andi. r9,r29,1
3498: 3a c0 00 20 li r22,32
349c: 39 20 00 30 li r9,48
34a0: 7e d6 48 9e iseleq r22,r22,r9
34a4: 4b ff fe c4 b 3368 <number+0x60>
} else if (type & PLUS) {
34a8: 73 a9 00 04 andi. r9,r29,4
34ac: 41 82 00 14 beq 34c0 <number+0x1b8>
size--;
34b0: 38 c6 ff ff addi r6,r6,-1
sign = '+';
34b4: 3a a0 00 2b li r21,43
size--;
34b8: 7c c6 07 b4 extsw r6,r6
34bc: 4b ff fe d0 b 338c <number+0x84>
} else if (type & SPACE) {
34c0: 73 a9 00 08 andi. r9,r29,8
34c4: 41 82 fe c8 beq 338c <number+0x84>
size--;
34c8: 38 c6 ff ff addi r6,r6,-1
sign = ' ';
34cc: 3a a0 00 20 li r21,32
size--;
34d0: 7c c6 07 b4 extsw r6,r6
34d4: 4b ff fe b8 b 338c <number+0x84>
else if (base == 8)
34d8: 2f 98 00 08 cmpwi cr7,r24,8
34dc: 40 9e fe d0 bne cr7,33ac <number+0xa4>
size--;
34e0: 38 c6 ff ff addi r6,r6,-1
34e4: 4b ff fe c4 b 33a8 <number+0xa0>
34e8: 39 20 00 00 li r9,0
tmp[i++] = digits[num % base];
34ec: 38 a1 00 20 addi r5,r1,32
34f0: 7d 04 c2 12 modud r8,r4,r24
while (num != 0) {
34f4: 7f b8 20 40 cmpld cr7,r24,r4
34f8: 3b 49 00 01 addi r26,r9,1
34fc: 7f 5a 07 b4 extsw r26,r26
tmp[i++] = digits[num % base];
3500: 7d 0a 40 ae lbzx r8,r10,r8
3504: 7d 09 29 ae stbx r8,r9,r5
num /= base;
3508: 7d 04 c3 92 divdu r8,r4,r24
350c: 39 29 00 01 addi r9,r9,1
while (num != 0) {
3510: 41 9d fe b0 bgt cr7,33c0 <number+0xb8>
num /= base;
3514: 7d 04 43 78 mr r4,r8
3518: 4b ff ff d8 b 34f0 <number+0x1e8>
call_tx(' '), count++;
351c: 7f 24 cb 78 mr r4,r25
3520: 38 60 00 20 li r3,32
3524: f8 41 00 18 std r2,24(r1)
3528: 7f 8c e3 78 mr r12,r28
352c: 7f 89 03 a6 mtctr r28
3530: 3b ff ff ff addi r31,r31,-1
3534: 7b ff 00 20 clrldi r31,r31,32
3538: 4e 80 04 21 bctrl
353c: e8 41 00 18 ld r2,24(r1)
3540: 4b ff fe a4 b 33e4 <number+0xdc>
else if (base == 16) {
3544: 2f 98 00 10 cmpwi cr7,r24,16
3548: 40 9e ff 18 bne cr7,3460 <number+0x158>
call_tx('0'), count++;
354c: 7f 24 cb 78 mr r4,r25
3550: 38 60 00 30 li r3,48
3554: f8 41 00 18 std r2,24(r1)
3558: 7f 8c e3 78 mr r12,r28
355c: 7f 89 03 a6 mtctr r28
3560: 3b ff 00 02 addi r31,r31,2
3564: 7f ff 07 b4 extsw r31,r31
3568: 4e 80 04 21 bctrl
356c: e8 41 00 18 ld r2,24(r1)
if (type & LARGE)
3570: 73 a9 00 40 andi. r9,r29,64
call_tx('X'), count++;
3574: 7f 24 cb 78 mr r4,r25
3578: 38 60 00 58 li r3,88
if (type & LARGE)
357c: 40 82 00 08 bne 3584 <number+0x27c>
call_tx('x'), count++;
3580: 38 60 00 78 li r3,120
3584: f8 41 00 18 std r2,24(r1)
3588: 7f 8c e3 78 mr r12,r28
358c: 7f 89 03 a6 mtctr r28
3590: 4e 80 04 21 bctrl
3594: e8 41 00 18 ld r2,24(r1)
3598: 4b ff fe c8 b 3460 <number+0x158>
call_tx(c), count++;
359c: 7f 24 cb 78 mr r4,r25
35a0: 7e c3 b3 78 mr r3,r22
35a4: f8 41 00 18 std r2,24(r1)
35a8: 7f 8c e3 78 mr r12,r28
35ac: 7f 89 03 a6 mtctr r28
35b0: 3b bd ff ff addi r29,r29,-1
35b4: 7b bd 00 20 clrldi r29,r29,32
35b8: 4e 80 04 21 bctrl
35bc: e8 41 00 18 ld r2,24(r1)
35c0: 4b ff fe a8 b 3468 <number+0x160>
}
while (i < precision--)
call_tx('0'), count++;
35c4: 7f 24 cb 78 mr r4,r25
35c8: 38 60 00 30 li r3,48
35cc: f8 41 00 18 std r2,24(r1)
35d0: 7f 8c e3 78 mr r12,r28
35d4: 7f 89 03 a6 mtctr r28
35d8: 3b ff 00 01 addi r31,r31,1
35dc: 7f ff 07 b4 extsw r31,r31
35e0: 4e 80 04 21 bctrl
35e4: e8 41 00 18 ld r2,24(r1)
35e8: 7d 3f b8 50 subf r9,r31,r23
while (i < precision--)
35ec: 7f 89 d0 00 cmpw cr7,r9,r26
35f0: 41 9d ff d4 bgt cr7,35c4 <number+0x2bc>
35f4: 7f 5d d3 78 mr r29,r26
while (i-- > 0)
call_tx(tmp[i]), count++;
35f8: 3b 61 00 20 addi r27,r1,32
35fc: 3b bd ff ff addi r29,r29,-1
while (i-- > 0)
3600: 39 3d 00 01 addi r9,r29,1
3604: 2f 89 00 00 cmpwi cr7,r9,0
3608: 41 9d 00 34 bgt cr7,363c <number+0x334>
360c: 7f fa fa 14 add r31,r26,r31
3610: 7b dd 00 20 clrldi r29,r30,32
while (size-- > 0)
3614: 2f 9d 00 00 cmpwi cr7,r29,0
3618: 41 9d 00 44 bgt cr7,365c <number+0x354>
call_tx(' '), count++;
return count;
361c: 2f 9e 00 00 cmpwi cr7,r30,0
}
3620: 38 21 00 d0 addi r1,r1,208
return count;
3624: 7c 60 f7 1e isel r3,0,r30,28
}
3628: 81 81 00 08 lwz r12,8(r1)
return count;
362c: 7c 63 fa 14 add r3,r3,r31
}
3630: 7d 81 81 20 mtcrf 24,r12
3634: 7c 63 07 b4 extsw r3,r3
3638: 48 00 16 c4 b 4cfc <_restgpr0_21>
3638: R_PPC64_REL24 _restgpr0_21
call_tx(tmp[i]), count++;
363c: 7c 7b e8 ae lbzx r3,r27,r29
3640: 7f 24 cb 78 mr r4,r25
3644: f8 41 00 18 std r2,24(r1)
3648: 7f 8c e3 78 mr r12,r28
364c: 7f 89 03 a6 mtctr r28
3650: 4e 80 04 21 bctrl
3654: e8 41 00 18 ld r2,24(r1)
3658: 4b ff ff a4 b 35fc <number+0x2f4>
call_tx(' '), count++;
365c: 7f 24 cb 78 mr r4,r25
3660: 38 60 00 20 li r3,32
3664: f8 41 00 18 std r2,24(r1)
3668: 7f 8c e3 78 mr r12,r28
366c: 7f 89 03 a6 mtctr r28
3670: 3b bd ff ff addi r29,r29,-1
3674: 7b bd 00 20 clrldi r29,r29,32
3678: 4e 80 04 21 bctrl
367c: e8 41 00 18 ld r2,24(r1)
3680: 4b ff ff 94 b 3614 <number+0x30c>
3684: 00 00 00 00 .long 0x0
3688: 00 00 00 03 .long 0x3
368c: 80 0b 00 00 lwz r0,0(r11)
0000000000003690 <vtxprintf>:
int vtxprintf(void (*tx_byte)(unsigned char byte, void *data),
const char *fmt, va_list args, void *data)
{
3690: 3c 40 00 02 lis r2,2
3692: R_PPC64_ADDR16_HA .TOC.
3694: 38 42 80 00 addi r2,r2,-32768
3696: R_PPC64_ADDR16_LO .TOC.
3698: 7c 08 02 a6 mflr r0
369c: 48 00 16 0d bl 4ca8 <_savegpr0_20>
369c: R_PPC64_REL24 _savegpr0_20
}
}
/* get the conversion qualifier */
qualifier = -1;
if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' || *fmt == 'z' || *fmt == 'j') {
36a0: 3e e0 40 01 lis r23,16385
36a4: 62 f7 50 00 ori r23,r23,20480
{
36a8: f8 21 ff 71 stdu r1,-144(r1)
36ac: 7c 7b 1b 78 mr r27,r3
36b0: 7c bc 2b 78 mr r28,r5
36b4: 7c da 33 78 mr r26,r6
for (count = 0; *fmt ; ++fmt) {
36b8: 3b e0 00 00 li r31,0
call_tx('%'), count++;
continue;
/* integer number formats - set up the flags and "break" */
case 'o':
base = 8;
36bc: 3b 00 00 08 li r24,8
36c0: 3b 20 00 01 li r25,1
{
36c4: f8 81 00 20 std r4,32(r1)
if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' || *fmt == 'z' || *fmt == 'j') {
36c8: 7a f7 83 e4 rldicr r23,r23,16,47
36cc: 62 f7 00 01 ori r23,r23,1
for (count = 0; *fmt ; ++fmt) {
36d0: e9 21 00 20 ld r9,32(r1)
36d4: 88 69 00 00 lbz r3,0(r9)
36d8: 2f a3 00 00 cmpdi cr7,r3,0
36dc: 40 9e 00 10 bne cr7,36ec <vtxprintf+0x5c>
num = va_arg(args, unsigned int);
}
count += number(tx_byte, num, base, field_width, precision, flags, data);
}
return count;
}
36e0: 38 21 00 90 addi r1,r1,144
36e4: 7f e3 fb 78 mr r3,r31
36e8: 48 00 16 10 b 4cf8 <_restgpr0_20>
36e8: R_PPC64_REL24 _restgpr0_20
if (*fmt != '%') {
36ec: 2b 83 00 25 cmplwi cr7,r3,37
call_tx(*fmt), count++;
36f0: 7f 44 d3 78 mr r4,r26
if (*fmt != '%') {
36f4: 40 9e 04 b8 bne cr7,3bac <vtxprintf+0x51c>
flags = 0;
36f8: 3b c0 00 00 li r30,0
++fmt; /* this also skips first '%' */
36fc: e9 41 00 20 ld r10,32(r1)
3700: 39 2a 00 01 addi r9,r10,1
3704: f9 21 00 20 std r9,32(r1)
switch (*fmt) {
3708: 89 2a 00 01 lbz r9,1(r10)
370c: 2b 89 00 2b cmplwi cr7,r9,43
3710: 41 9e 01 84 beq cr7,3894 <vtxprintf+0x204>
3714: 41 9d 01 5c bgt cr7,3870 <vtxprintf+0x1e0>
3718: 2b 89 00 20 cmplwi cr7,r9,32
371c: 41 9e 01 80 beq cr7,389c <vtxprintf+0x20c>
3720: 2b 89 00 23 cmplwi cr7,r9,35
3724: 41 9e 01 80 beq cr7,38a4 <vtxprintf+0x214>
return c >= ' ' && c <= '~';
}
static inline int isdigit(int c)
{
return (c >= '0' && c <= '9');
3728: 39 09 ff d0 addi r8,r9,-48
if (isdigit(*fmt)) {
372c: 2b 88 00 09 cmplwi cr7,r8,9
3730: 41 9d 01 7c bgt cr7,38ac <vtxprintf+0x21c>
field_width = skip_atoi((char **)&fmt);
3734: 38 61 00 20 addi r3,r1,32
3738: 48 00 11 c1 bl 48f8 <skip_atoi>
3738: R_PPC64_REL24 skip_atoi
373c: 60 00 00 00 nop
3740: 7c 7d 07 b4 extsw r29,r3
if (*fmt == '.') {
3744: e9 21 00 20 ld r9,32(r1)
precision = -1;
3748: 38 e0 ff ff li r7,-1
if (*fmt == '.') {
374c: 89 49 00 00 lbz r10,0(r9)
3750: 2f 8a 00 2e cmpwi cr7,r10,46
3754: 40 9e 00 38 bne cr7,378c <vtxprintf+0xfc>
++fmt;
3758: 39 49 00 01 addi r10,r9,1
375c: f9 41 00 20 std r10,32(r1)
if (isdigit(*fmt)) {
3760: 89 49 00 01 lbz r10,1(r9)
3764: 39 0a ff d0 addi r8,r10,-48
3768: 2b 88 00 09 cmplwi cr7,r8,9
376c: 41 9d 01 78 bgt cr7,38e4 <vtxprintf+0x254>
precision = skip_atoi((char **)&fmt);
3770: 38 61 00 20 addi r3,r1,32
3774: 48 00 11 85 bl 48f8 <skip_atoi>
3774: R_PPC64_REL24 skip_atoi
3778: 60 00 00 00 nop
377c: 7c 63 07 b4 extsw r3,r3
if (precision < 0) {
3780: 2f 83 00 00 cmpwi cr7,r3,0
3784: 7c e0 1f 1e isel r7,0,r3,28
3788: 7c e7 07 b4 extsw r7,r7
if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' || *fmt == 'z' || *fmt == 'j') {
378c: e9 01 00 20 ld r8,32(r1)
qualifier = -1;
3790: 39 40 ff ff li r10,-1
if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' || *fmt == 'z' || *fmt == 'j') {
3794: 88 c8 00 00 lbz r6,0(r8)
3798: 39 26 ff b4 addi r9,r6,-76
379c: 55 29 06 3e clrlwi r9,r9,24
37a0: 2b 89 00 2e cmplwi cr7,r9,46
37a4: 41 9d 00 50 bgt cr7,37f4 <vtxprintf+0x164>
37a8: 7e e9 4c 36 srd r9,r23,r9
37ac: 71 29 00 01 andi. r9,r9,1
37b0: 41 82 00 44 beq 37f4 <vtxprintf+0x164>
++fmt;
37b4: 39 28 00 01 addi r9,r8,1
qualifier = *fmt;
37b8: 7c ca 07 b4 extsw r10,r6
++fmt;
37bc: f9 21 00 20 std r9,32(r1)
if (*fmt == 'l') {
37c0: 89 28 00 01 lbz r9,1(r8)
37c4: 2f 89 00 6c cmpwi cr7,r9,108
37c8: 40 9e 00 10 bne cr7,37d8 <vtxprintf+0x148>
++fmt;
37cc: 39 08 00 02 addi r8,r8,2
qualifier = 'L';
37d0: 39 40 00 4c li r10,76
++fmt;
37d4: f9 01 00 20 std r8,32(r1)
if (*fmt == 'h') {
37d8: e9 21 00 20 ld r9,32(r1)
37dc: 89 09 00 00 lbz r8,0(r9)
37e0: 2f 88 00 68 cmpwi cr7,r8,104
37e4: 40 9e 00 10 bne cr7,37f4 <vtxprintf+0x164>
++fmt;
37e8: 39 29 00 01 addi r9,r9,1
qualifier = 'H';
37ec: 39 40 00 48 li r10,72
++fmt;
37f0: f9 21 00 20 std r9,32(r1)
switch (*fmt) {
37f4: e9 21 00 20 ld r9,32(r1)
37f8: 89 29 00 00 lbz r9,0(r9)
37fc: 2b 89 00 6e cmplwi cr7,r9,110
3800: 41 9e 03 70 beq cr7,3b70 <vtxprintf+0x4e0>
3804: 41 9d 01 20 bgt cr7,3924 <vtxprintf+0x294>
3808: 2b 89 00 63 cmplwi cr7,r9,99
380c: 41 9e 01 a0 beq cr7,39ac <vtxprintf+0x31c>
3810: 41 9d 00 f4 bgt cr7,3904 <vtxprintf+0x274>
3814: 2b 89 00 25 cmplwi cr7,r9,37
3818: 41 9e 03 8c beq cr7,3ba4 <vtxprintf+0x514>
381c: 2b 89 00 58 cmplwi cr7,r9,88
3820: 41 9e 03 ac beq cr7,3bcc <vtxprintf+0x53c>
call_tx('%'), count++;
3824: 38 60 00 25 li r3,37
3828: 7f 44 d3 78 mr r4,r26
382c: f8 41 00 18 std r2,24(r1)
3830: 7f 6c db 78 mr r12,r27
3834: 7f 69 03 a6 mtctr r27
3838: 4e 80 04 21 bctrl
383c: e8 41 00 18 ld r2,24(r1)
if (*fmt)
3840: e9 21 00 20 ld r9,32(r1)
3844: 88 69 00 00 lbz r3,0(r9)
3848: 2f a3 00 00 cmpdi cr7,r3,0
384c: 41 9e 03 90 beq cr7,3bdc <vtxprintf+0x54c>
call_tx(*fmt), count++;
3850: 7f 44 d3 78 mr r4,r26
3854: f8 41 00 18 std r2,24(r1)
3858: 7f 6c db 78 mr r12,r27
385c: 7f 69 03 a6 mtctr r27
3860: 3b ff 00 02 addi r31,r31,2
3864: 4e 80 04 21 bctrl
3868: e8 41 00 18 ld r2,24(r1)
386c: 48 00 03 58 b 3bc4 <vtxprintf+0x534>
switch (*fmt) {
3870: 2b 89 00 2d cmplwi cr7,r9,45
3874: 41 9e 00 14 beq cr7,3888 <vtxprintf+0x1f8>
3878: 2b 89 00 30 cmplwi cr7,r9,48
387c: 40 9e fe ac bne cr7,3728 <vtxprintf+0x98>
case '0': flags |= ZEROPAD; goto repeat;
3880: 63 de 00 01 ori r30,r30,1
3884: 48 00 00 08 b 388c <vtxprintf+0x1fc>
case '-': flags |= LEFT; goto repeat;
3888: 63 de 00 10 ori r30,r30,16
case '0': flags |= ZEROPAD; goto repeat;
388c: 7f de 07 b4 extsw r30,r30
3890: 4b ff fe 6c b 36fc <vtxprintf+0x6c>
case '+': flags |= PLUS; goto repeat;
3894: 63 de 00 04 ori r30,r30,4
3898: 4b ff ff f4 b 388c <vtxprintf+0x1fc>
case ' ': flags |= SPACE; goto repeat;
389c: 63 de 00 08 ori r30,r30,8
38a0: 4b ff ff ec b 388c <vtxprintf+0x1fc>
case '#': flags |= SPECIAL; goto repeat;
38a4: 63 de 00 20 ori r30,r30,32
38a8: 4b ff ff e4 b 388c <vtxprintf+0x1fc>
} else if (*fmt == '*') {
38ac: 2b 89 00 2a cmplwi cr7,r9,42
field_width = -1;
38b0: 3b a0 ff ff li r29,-1
} else if (*fmt == '*') {
38b4: 40 9e fe 90 bne cr7,3744 <vtxprintf+0xb4>
field_width = va_arg(args, int);
38b8: eb bc 00 06 lwa r29,4(r28)
++fmt;
38bc: 39 4a 00 02 addi r10,r10,2
field_width = va_arg(args, int);
38c0: 3b 9c 00 08 addi r28,r28,8
++fmt;
38c4: f9 41 00 20 std r10,32(r1)
if (field_width < 0) {
38c8: 2f 9d 00 00 cmpwi cr7,r29,0
38cc: 40 9c fe 78 bge cr7,3744 <vtxprintf+0xb4>
field_width = -field_width;
38d0: 7f bd 00 d0 neg r29,r29
flags |= LEFT;
38d4: 63 de 00 10 ori r30,r30,16
field_width = -field_width;
38d8: 7f bd 07 b4 extsw r29,r29
flags |= LEFT;
38dc: 7f de 07 b4 extsw r30,r30
38e0: 4b ff fe 64 b 3744 <vtxprintf+0xb4>
} else if (*fmt == '*') {
38e4: 2b 8a 00 2a cmplwi cr7,r10,42
precision = 0;
38e8: 38 e0 00 00 li r7,0
} else if (*fmt == '*') {
38ec: 40 9e fe a0 bne cr7,378c <vtxprintf+0xfc>
++fmt;
38f0: 39 29 00 02 addi r9,r9,2
precision = va_arg(args, int);
38f4: e8 7c 00 06 lwa r3,4(r28)
38f8: 3b 9c 00 08 addi r28,r28,8
++fmt;
38fc: f9 21 00 20 std r9,32(r1)
precision = va_arg(args, int);
3900: 4b ff fe 80 b 3780 <vtxprintf+0xf0>
switch (*fmt) {
3904: 2b 89 00 64 cmplwi cr7,r9,100
3908: 41 9e 00 0c beq cr7,3914 <vtxprintf+0x284>
390c: 2b 89 00 69 cmplwi cr7,r9,105
3910: 40 9e ff 14 bne cr7,3824 <vtxprintf+0x194>
flags |= SIGN;
3914: 63 de 00 02 ori r30,r30,2
3918: 7f de 07 b4 extsw r30,r30
base = 10;
391c: 38 a0 00 0a li r5,10
3920: 48 00 00 6c b 398c <vtxprintf+0x2fc>
switch (*fmt) {
3924: 2b 89 00 73 cmplwi cr7,r9,115
3928: 41 9e 01 4c beq cr7,3a74 <vtxprintf+0x3e4>
392c: 41 9d 00 4c bgt cr7,3978 <vtxprintf+0x2e8>
3930: 2b 89 00 6f cmplwi cr7,r9,111
3934: 41 9e 02 bc beq cr7,3bf0 <vtxprintf+0x560>
3938: 2b 89 00 70 cmplwi cr7,r9,112
393c: 40 9e fe e8 bne cr7,3824 <vtxprintf+0x194>
if (field_width == -1 && precision == -1)
3940: 7f a9 38 38 and r9,r29,r7
flags |= SPECIAL;
3944: 63 c8 00 20 ori r8,r30,32
count += number(tx_byte,
3948: e8 9c 00 00 ld r4,0(r28)
(unsigned long) va_arg(args, void *), 16,
394c: 3a dc 00 08 addi r22,r28,8
count += number(tx_byte,
3950: 7f a6 eb 78 mr r6,r29
3954: 38 a0 00 10 li r5,16
precision = 2*sizeof(uint32_t);
3958: 2f 89 ff ff cmpwi cr7,r9,-1
count += number(tx_byte,
395c: 7d 08 07 b4 extsw r8,r8
3960: 7f 49 d3 78 mr r9,r26
3964: 7c f8 3f 9e isel r7,r24,r7,30
count += number(tx_byte, num, base, field_width, precision, flags, data);
3968: 7f 63 db 78 mr r3,r27
396c: 4b ff f9 a5 bl 3310 <number+0x8>
396c: R_PPC64_REL24 number
3970: 7f e3 fa 14 add r31,r3,r31
3974: 48 00 00 d8 b 3a4c <vtxprintf+0x3bc>
switch (*fmt) {
3978: 2b 89 00 75 cmplwi cr7,r9,117
397c: 41 9e ff a0 beq cr7,391c <vtxprintf+0x28c>
3980: 2b 89 00 78 cmplwi cr7,r9,120
base = 16;
3984: 38 a0 00 10 li r5,16
switch (*fmt) {
3988: 40 9e fe 9c bne cr7,3824 <vtxprintf+0x194>
if (qualifier == 'L') {
398c: 2f 8a 00 4c cmpwi cr7,r10,76
3990: 3a dc 00 08 addi r22,r28,8
3994: 40 9e 02 64 bne cr7,3bf8 <vtxprintf+0x568>
num = va_arg(args, uintmax_t);
3998: e8 9c 00 00 ld r4,0(r28)
count += number(tx_byte, num, base, field_width, precision, flags, data);
399c: 7f 49 d3 78 mr r9,r26
39a0: 7f c8 f3 78 mr r8,r30
39a4: 7f a6 eb 78 mr r6,r29
39a8: 4b ff ff c0 b 3968 <vtxprintf+0x2d8>
if (!(flags & LEFT))
39ac: 73 c9 00 10 andi. r9,r30,16
39b0: 40 82 00 54 bne 3a04 <vtxprintf+0x374>
39b4: 7f be eb 78 mr r30,r29
39b8: 48 00 00 20 b 39d8 <vtxprintf+0x348>
call_tx(' '), count++;
39bc: 7f 44 d3 78 mr r4,r26
39c0: 38 60 00 20 li r3,32
39c4: f8 41 00 18 std r2,24(r1)
39c8: 7f 6c db 78 mr r12,r27
39cc: 7f 69 03 a6 mtctr r27
39d0: 4e 80 04 21 bctrl
39d4: e8 41 00 18 ld r2,24(r1)
while (--field_width > 0)
39d8: 39 3e ff ff addi r9,r30,-1
39dc: 2f 89 00 00 cmpwi cr7,r9,0
39e0: 7d 3e 07 b4 extsw r30,r9
39e4: 41 9d ff d8 bgt cr7,39bc <vtxprintf+0x32c>
39e8: 2f 9d 00 00 cmpwi cr7,r29,0
39ec: 7c dd cf 5e isel r6,r29,r25,29
39f0: 38 66 ff ff addi r3,r6,-1
39f4: 7f a6 e8 50 subf r29,r6,r29
39f8: 7f e3 fa 14 add r31,r3,r31
39fc: 7f bd 07 b4 extsw r29,r29
3a00: 7f ff 07 b4 extsw r31,r31
call_tx((unsigned char) va_arg(args, int)), count++;
3a04: 88 7c 00 07 lbz r3,7(r28)
3a08: 7f 44 d3 78 mr r4,r26
3a0c: f8 41 00 18 std r2,24(r1)
3a10: 7f 6c db 78 mr r12,r27
3a14: 7f 69 03 a6 mtctr r27
3a18: 3a dc 00 08 addi r22,r28,8
while (--field_width > 0)
3a1c: 7f be eb 78 mr r30,r29
call_tx((unsigned char) va_arg(args, int)), count++;
3a20: 3b 9f 00 01 addi r28,r31,1
3a24: 4e 80 04 21 bctrl
3a28: e8 41 00 18 ld r2,24(r1)
while (--field_width > 0)
3a2c: 39 3e ff ff addi r9,r30,-1
3a30: 2f 89 00 00 cmpwi cr7,r9,0
3a34: 7d 3e 07 b4 extsw r30,r9
3a38: 41 9d 00 1c bgt cr7,3a54 <vtxprintf+0x3c4>
3a3c: 2f 9d 00 00 cmpwi cr7,r29,0
3a40: 7f fd cf 5e isel r31,r29,r25,29
3a44: 3b ff ff ff addi r31,r31,-1
3a48: 7f ff e2 14 add r31,r31,r28
count += number(tx_byte, num, base, field_width, precision, flags, data);
3a4c: 7f ff 07 b4 extsw r31,r31
3a50: 48 00 00 88 b 3ad8 <vtxprintf+0x448>
call_tx(' '), count++;
3a54: 7f 44 d3 78 mr r4,r26
3a58: 38 60 00 20 li r3,32
3a5c: f8 41 00 18 std r2,24(r1)
3a60: 7f 6c db 78 mr r12,r27
3a64: 7f 69 03 a6 mtctr r27
3a68: 4e 80 04 21 bctrl
3a6c: e8 41 00 18 ld r2,24(r1)
3a70: 4b ff ff bc b 3a2c <vtxprintf+0x39c>
s = va_arg(args, char *);
3a74: ea bc 00 00 ld r21,0(r28)
3a78: 3a dc 00 08 addi r22,r28,8
if (!s)
3a7c: 2f b5 00 00 cmpdi cr7,r21,0
3a80: 40 9e 00 0c bne cr7,3a8c <vtxprintf+0x3fc>
s = "<NULL>";
3a84: 3e a2 ff ff addis r21,r2,-1
3a86: R_PPC64_TOC16_HA .text+0x4b3c
3a88: 3a b5 cb 3c addi r21,r21,-13508
3a8a: R_PPC64_TOC16_LO .text+0x4b3c
len = strnlen(s, (size_t)precision);
3a8c: 7c e4 3b 78 mr r4,r7
3a90: 7e a3 ab 78 mr r3,r21
3a94: 48 00 0d f5 bl 4888 <strnlen>
3a94: R_PPC64_REL24 strnlen
3a98: 60 00 00 00 nop
if (!(flags & LEFT)) {
3a9c: 73 c9 00 10 andi. r9,r30,16
len = strnlen(s, (size_t)precision);
3aa0: 7c 7c 07 b4 extsw r28,r3
if (!(flags & LEFT)) {
3aa4: 41 82 00 78 beq 3b1c <vtxprintf+0x48c>
3aa8: 7f be eb 78 mr r30,r29
for (i = 0; i < len; ++i)
3aac: 3b a0 00 00 li r29,0
3ab0: 7f 9c e8 00 cmpw cr7,r28,r29
3ab4: 41 9d 00 70 bgt cr7,3b24 <vtxprintf+0x494>
3ab8: 2f 9c 00 00 cmpwi cr7,r28,0
3abc: 7c 60 e7 1e isel r3,0,r28,28
3ac0: 7f e3 fa 14 add r31,r3,r31
3ac4: 7f ff 07 b4 extsw r31,r31
3ac8: 7f df f2 14 add r30,r31,r30
3acc: 7d 3f f0 50 subf r9,r31,r30
while (len < field_width--)
3ad0: 7f 89 e0 00 cmpw cr7,r9,r28
3ad4: 41 9d 00 74 bgt cr7,3b48 <vtxprintf+0x4b8>
count += number(tx_byte, num, base, field_width, precision, flags, data);
3ad8: 7e dc b3 78 mr r28,r22
3adc: 48 00 00 a8 b 3b84 <vtxprintf+0x4f4>
call_tx(' '), count++;
3ae0: 7f 44 d3 78 mr r4,r26
3ae4: 38 60 00 20 li r3,32
3ae8: f8 41 00 18 std r2,24(r1)
3aec: 7f 6c db 78 mr r12,r27
3af0: 7f 69 03 a6 mtctr r27
while (len < field_width--)
3af4: 7f dd f3 78 mr r29,r30
call_tx(' '), count++;
3af8: 4e 80 04 21 bctrl
3afc: e8 41 00 18 ld r2,24(r1)
while (len < field_width--)
3b00: 7f 9d e0 00 cmpw cr7,r29,r28
3b04: 7f fd a0 50 subf r31,r29,r20
3b08: 3b dd ff ff addi r30,r29,-1
3b0c: 7f ff 07 b4 extsw r31,r31
3b10: 7f de 07 b4 extsw r30,r30
3b14: 41 9d ff cc bgt cr7,3ae0 <vtxprintf+0x450>
3b18: 4b ff ff 94 b 3aac <vtxprintf+0x41c>
3b1c: 7e 9f ea 14 add r20,r31,r29
3b20: 4b ff ff e0 b 3b00 <vtxprintf+0x470>
call_tx(*s++), count++;
3b24: 7c 75 e8 ae lbzx r3,r21,r29
3b28: 7f 44 d3 78 mr r4,r26
3b2c: f8 41 00 18 std r2,24(r1)
3b30: 7f 6c db 78 mr r12,r27
3b34: 7f 69 03 a6 mtctr r27
3b38: 3b bd 00 01 addi r29,r29,1
3b3c: 4e 80 04 21 bctrl
3b40: e8 41 00 18 ld r2,24(r1)
3b44: 4b ff ff 6c b 3ab0 <vtxprintf+0x420>
call_tx(' '), count++;
3b48: 7f 44 d3 78 mr r4,r26
3b4c: 38 60 00 20 li r3,32
3b50: f8 41 00 18 std r2,24(r1)
3b54: 7f 6c db 78 mr r12,r27
3b58: 7f 69 03 a6 mtctr r27
3b5c: 3b ff 00 01 addi r31,r31,1
3b60: 7f ff 07 b4 extsw r31,r31
3b64: 4e 80 04 21 bctrl
3b68: e8 41 00 18 ld r2,24(r1)
3b6c: 4b ff ff 60 b 3acc <vtxprintf+0x43c>
if (qualifier == 'L') {
3b70: 2f 8a 00 4c cmpwi cr7,r10,76
3b74: e9 3c 00 00 ld r9,0(r28)
3b78: 3b 9c 00 08 addi r28,r28,8
3b7c: 40 9e 00 18 bne cr7,3b94 <vtxprintf+0x504>
*ip = count;
3b80: fb e9 00 00 std r31,0(r9)
for (count = 0; *fmt ; ++fmt) {
3b84: e9 21 00 20 ld r9,32(r1)
3b88: 39 29 00 01 addi r9,r9,1
3b8c: f9 21 00 20 std r9,32(r1)
3b90: 4b ff fb 40 b 36d0 <vtxprintf+0x40>
} else if (qualifier == 'l') {
3b94: 2f 8a 00 6c cmpwi cr7,r10,108
3b98: 41 9e ff e8 beq cr7,3b80 <vtxprintf+0x4f0>
*ip = count;
3b9c: 93 e9 00 00 stw r31,0(r9)
3ba0: 4b ff ff e4 b 3b84 <vtxprintf+0x4f4>
call_tx('%'), count++;
3ba4: 7f 44 d3 78 mr r4,r26
3ba8: 38 60 00 25 li r3,37
3bac: f8 41 00 18 std r2,24(r1)
3bb0: 7f 6c db 78 mr r12,r27
3bb4: 7f 69 03 a6 mtctr r27
3bb8: 3b ff 00 01 addi r31,r31,1
3bbc: 4e 80 04 21 bctrl
3bc0: e8 41 00 18 ld r2,24(r1)
call_tx(*fmt), count++;
3bc4: 7f ff 07 b4 extsw r31,r31
3bc8: 4b ff ff bc b 3b84 <vtxprintf+0x4f4>
flags |= LARGE;
3bcc: 63 de 00 40 ori r30,r30,64
base = 16;
3bd0: 38 a0 00 10 li r5,16
flags |= LARGE;
3bd4: 7f de 07 b4 extsw r30,r30
3bd8: 4b ff fd b4 b 398c <vtxprintf+0x2fc>
call_tx('%'), count++;
3bdc: 3b ff 00 01 addi r31,r31,1
--fmt;
3be0: 39 29 ff ff addi r9,r9,-1
call_tx('%'), count++;
3be4: 7f ff 07 b4 extsw r31,r31
--fmt;
3be8: f9 21 00 20 std r9,32(r1)
3bec: 4b ff ff 98 b 3b84 <vtxprintf+0x4f4>
base = 8;
3bf0: 38 a0 00 08 li r5,8
3bf4: 4b ff fd 98 b 398c <vtxprintf+0x2fc>
} else if (qualifier == 'l') {
3bf8: 2f 8a 00 6c cmpwi cr7,r10,108
3bfc: 41 9e fd 9c beq cr7,3998 <vtxprintf+0x308>
} else if (qualifier == 'z') {
3c00: 2f 8a 00 7a cmpwi cr7,r10,122
3c04: 41 9e fd 94 beq cr7,3998 <vtxprintf+0x308>
} else if (qualifier == 'j') {
3c08: 2f 8a 00 6a cmpwi cr7,r10,106
3c0c: 41 9e fd 8c beq cr7,3998 <vtxprintf+0x308>
} else if (qualifier == 'h') {
3c10: 2f 8a 00 68 cmpwi cr7,r10,104
3c14: 57 c9 07 bc rlwinm r9,r30,0,30,30
3c18: 80 9c 00 04 lwz r4,4(r28)
3c1c: 7d 29 07 b5 extsw. r9,r9
3c20: 40 9e 00 18 bne cr7,3c38 <vtxprintf+0x5a8>
if (flags & SIGN)
3c24: 40 82 00 0c bne 3c30 <vtxprintf+0x5a0>
num = (unsigned short) va_arg(args, int);
3c28: 54 84 04 3e clrlwi r4,r4,16
3c2c: 4b ff fd 70 b 399c <vtxprintf+0x30c>
num = (short) num;
3c30: 7c 84 07 34 extsh r4,r4
3c34: 4b ff fd 68 b 399c <vtxprintf+0x30c>
} else if (qualifier == 'H') {
3c38: 2f 8a 00 48 cmpwi cr7,r10,72
3c3c: 40 9e 00 18 bne cr7,3c54 <vtxprintf+0x5c4>
if (flags & SIGN)
3c40: 40 82 00 0c bne 3c4c <vtxprintf+0x5bc>
num = (unsigned char) va_arg(args, int);
3c44: 54 84 06 3e clrlwi r4,r4,24
3c48: 4b ff fd 54 b 399c <vtxprintf+0x30c>
num = (signed char) num;
3c4c: 7c 84 07 74 extsb r4,r4
3c50: 4b ff fd 4c b 399c <vtxprintf+0x30c>
} else if (flags & SIGN) {
3c54: 41 82 fd 48 beq 399c <vtxprintf+0x30c>
num = va_arg(args, int);
3c58: 7c 84 07 b4 extsw r4,r4
3c5c: 4b ff fd 40 b 399c <vtxprintf+0x30c>
3c60: 00 00 00 00 .long 0x0
3c64: 00 00 00 01 .long 0x1
3c68: 80 0c 00 00 lwz r0,0(r12)
0000000000003c6c <boot_device_init>:
#include <boot_device.h>
void __weak boot_device_init(void)
{
/* Provide weak do-nothing init. */
}
3c6c: 4e 80 00 20 blr
...
0000000000003c7c <boot_device_ro_subregion>:
return rdev_chain(subrd, parent, region_offset(sub), region_sz(sub));
}
int boot_device_ro_subregion(const struct region *sub,
struct region_device *subrd)
{
3c7c: 3c 40 00 02 lis r2,2
3c7e: R_PPC64_ADDR16_HA .TOC.
3c80: 38 42 80 00 addi r2,r2,-32768
3c82: R_PPC64_ADDR16_LO .TOC.
3c84: 7c 08 02 a6 mflr r0
3c88: fb c1 ff f0 std r30,-16(r1)
3c8c: fb e1 ff f8 std r31,-8(r1)
3c90: 7c 9e 23 78 mr r30,r4
3c94: 7c 7f 1b 78 mr r31,r3
3c98: f8 01 00 10 std r0,16(r1)
3c9c: f8 21 ff d1 stdu r1,-48(r1)
/* Ensure boot device has been initialized at least once. */
boot_device_init();
3ca0: 4b ff ff cd bl 3c6c <boot_device_init>
3ca0: R_PPC64_REL24 boot_device_init
3ca4: 60 00 00 00 nop
return boot_device_subregion(sub, subrd, boot_device_ro());
3ca8: 4b ff e5 75 bl 221c <boot_device_ro+0x8>
3ca8: R_PPC64_REL24 boot_device_ro
3cac: 60 00 00 00 nop
if (parent == NULL)
3cb0: 7c 64 1b 79 mr. r4,r3
3cb4: 41 82 00 20 beq 3cd4 <boot_device_ro_subregion+0x58>
return rdev_chain(subrd, parent, region_offset(sub), region_sz(sub));
3cb8: e8 df 00 08 ld r6,8(r31)
3cbc: e8 bf 00 00 ld r5,0(r31)
3cc0: 7f c3 f3 78 mr r3,r30
3cc4: 4b ff f0 01 bl 2cc4 <rdev_chain+0x8>
3cc4: R_PPC64_REL24 rdev_chain
3cc8: 60 00 00 00 nop
}
3ccc: 38 21 00 30 addi r1,r1,48
3cd0: 48 00 10 64 b 4d34 <_restgpr0_30>
3cd0: R_PPC64_REL24 _restgpr0_30
return -1;
3cd4: 38 60 ff ff li r3,-1
3cd8: 4b ff ff f4 b 3ccc <boot_device_ro_subregion+0x50>
3cdc: 00 00 00 00 .long 0x0
3ce0: 00 00 00 01 .long 0x1
3ce4: 80 02 00 00 lwz r0,0(r2)
0000000000003ce8 <bootblock_mainboard_early_init>:
#include <post.h>
#include <program_loading.h>
#include <symbols.h>
#include <timestamp.h>
__weak void bootblock_mainboard_early_init(void) { /* no-op */ }
3ce8: 4e 80 00 20 blr
...
0000000000003cf8 <bootblock_soc_early_init>:
3cf8: 4e 80 00 20 blr
...
0000000000003d08 <bootblock_soc_init>:
3d08: 4e 80 00 20 blr
...
0000000000003d18 <bootblock_mainboard_init>:
3d18: 4e 80 00 20 blr
...
0000000000003d28 <bootblock_main_with_timestamp>:
* entered from C code. This function assumes that the timer has already been
* initialized, so it does not call init_timer().
*/
void bootblock_main_with_timestamp(uint64_t base_timestamp,
struct timestamp_entry *timestamps, size_t num_timestamps)
{
3d28: 3c 40 00 02 lis r2,2
3d2a: R_PPC64_ADDR16_HA .TOC.
3d2c: 38 42 80 00 addi r2,r2,-32768
3d2e: R_PPC64_ADDR16_LO .TOC.
3d30: 7c 08 02 a6 mflr r0
3d34: f8 01 00 10 std r0,16(r1)
3d38: f8 21 ff e1 stdu r1,-32(r1)
timestamps[i].entry_stamp);
}
timestamp_add_now(TS_START_BOOTBLOCK);
bootblock_soc_early_init();
3d3c: 4b ff ff bd bl 3cf8 <bootblock_soc_early_init>
3d3c: R_PPC64_REL24 bootblock_soc_early_init
3d40: 60 00 00 00 nop
bootblock_mainboard_early_init();
3d44: 4b ff ff a5 bl 3ce8 <bootblock_mainboard_early_init>
3d44: R_PPC64_REL24 bootblock_mainboard_early_init
3d48: 60 00 00 00 nop
if (CONFIG(CMOS_POST))
cmos_post_init();
if (CONFIG(BOOTBLOCK_CONSOLE)) {
console_init();
3d4c: 4b ff f1 a5 bl 2ef0 <console_init+0x8>
3d4c: R_PPC64_REL24 console_init
3d50: 60 00 00 00 nop
exception_init();
}
bootblock_soc_init();
3d54: 4b ff ff b5 bl 3d08 <bootblock_soc_init>
3d54: R_PPC64_REL24 bootblock_soc_init
3d58: 60 00 00 00 nop
bootblock_mainboard_init();
3d5c: 4b ff ff bd bl 3d18 <bootblock_mainboard_init>
3d5c: R_PPC64_REL24 bootblock_mainboard_init
3d60: 60 00 00 00 nop
timestamp_add_now(TS_END_BOOTBLOCK);
run_romstage();
3d64: 48 00 09 cd bl 4730 <run_romstage+0x8>
3d64: R_PPC64_REL24 run_romstage
3d68: 60 00 00 00 nop
}
3d6c: 38 21 00 20 addi r1,r1,32
3d70: e8 01 00 10 ld r0,16(r1)
3d74: 7c 08 03 a6 mtlr r0
3d78: 4e 80 00 20 blr
3d7c: 00 00 00 00 .long 0x0
3d80: 00 00 00 01 .long 0x1
3d84: 80 00 00 00 lwz r0,0(0)
0000000000003d88 <main>:
{
bootblock_main_with_timestamp(base_timestamp, NULL, 0);
}
void main(void)
{
3d88: 3c 40 00 02 lis r2,2
3d8a: R_PPC64_ADDR16_HA .TOC.
3d8c: 38 42 80 00 addi r2,r2,-32768
3d8e: R_PPC64_ADDR16_LO .TOC.
3d90: 7c 08 02 a6 mflr r0
3d94: f8 01 00 10 std r0,16(r1)
3d98: f8 21 ff e1 stdu r1,-32(r1)
uint64_t base_timestamp = 0;
init_timer();
3d9c: 48 00 0b a9 bl 4944 <init_timer>
3d9c: R_PPC64_REL24 init_timer
3da0: 60 00 00 00 nop
if (CONFIG(COLLECT_TIMESTAMPS))
base_timestamp = timestamp_get();
bootblock_main_with_timestamp(base_timestamp, NULL, 0);
}
3da4: 38 21 00 20 addi r1,r1,32
bootblock_main_with_timestamp(base_timestamp, NULL, 0);
3da8: 38 a0 00 00 li r5,0
3dac: 38 80 00 00 li r4,0
3db0: 38 60 00 00 li r3,0
}
3db4: e8 01 00 10 ld r0,16(r1)
3db8: 7c 08 03 a6 mtlr r0
bootblock_main_with_timestamp(base_timestamp, NULL, 0);
3dbc: 4b ff ff 74 b 3d30 <bootblock_main_with_timestamp+0x8>
3dbc: R_PPC64_REL24 bootblock_main_with_timestamp
3dc0: 00 00 00 00 .long 0x0
3dc4: 00 00 00 01 .long 0x1
3dc8: 80 00 00 00 lwz r0,0(0)
0000000000003dcc <cbfs_load_and_decompress>:
return true;
}
size_t cbfs_load_and_decompress(const struct region_device *rdev, size_t offset,
size_t in_size, void *buffer, size_t buffer_size, uint32_t compression)
{
3dcc: 3c 40 00 02 lis r2,2
3dce: R_PPC64_ADDR16_HA .TOC.
3dd0: 38 42 80 00 addi r2,r2,-32768
3dd2: R_PPC64_ADDR16_LO .TOC.
3dd4: 7c 08 02 a6 mflr r0
size_t out_size;
void *map;
switch (compression) {
3dd8: 2c 28 00 00 cmpdi r8,0
{
3ddc: 48 00 0e e9 bl 4cc4 <_savegpr0_27>
3ddc: R_PPC64_REL24 _savegpr0_27
3de0: f8 21 ff b1 stdu r1,-80(r1)
3de4: 7c bf 2b 78 mr r31,r5
3de8: 7c dd 33 78 mr r29,r6
3dec: 7c fe 3b 78 mr r30,r7
switch (compression) {
3df0: 41 82 00 14 beq 3e04 <cbfs_load_and_decompress+0x38>
3df4: 2b 88 00 02 cmplwi cr7,r8,2
3df8: 41 9e 00 3c beq cr7,3e34 <cbfs_load_and_decompress+0x68>
case CBFS_COMPRESS_NONE:
if (buffer_size < in_size)
return 0;
if (rdev_readat(rdev, buffer, offset, in_size) != in_size)
return 0;
3dfc: 3b e0 00 00 li r31,0
3e00: 48 00 00 28 b 3e28 <cbfs_load_and_decompress+0x5c>
if (buffer_size < in_size)
3e04: 7f a7 28 40 cmpld cr7,r7,r5
3e08: 41 9c ff f4 blt cr7,3dfc <cbfs_load_and_decompress+0x30>
if (rdev_readat(rdev, buffer, offset, in_size) != in_size)
3e0c: 7c a6 2b 78 mr r6,r5
3e10: 7c 85 23 78 mr r5,r4
3e14: 7f a4 eb 78 mr r4,r29
3e18: 4b ff ee 19 bl 2c30 <rdev_readat+0x8>
3e18: R_PPC64_REL24 rdev_readat
3e1c: 60 00 00 00 nop
3e20: 7f a3 f8 00 cmpd cr7,r3,r31
3e24: 40 9e ff d8 bne cr7,3dfc <cbfs_load_and_decompress+0x30>
return out_size;
default:
return 0;
}
}
3e28: 38 21 00 50 addi r1,r1,80
3e2c: 7f e3 fb 78 mr r3,r31
3e30: 48 00 0e e4 b 4d14 <_restgpr0_27>
3e30: R_PPC64_REL24 _restgpr0_27
3e34: 7c 7c 1b 78 mr r28,r3
map = rdev_mmap(rdev, offset, in_size);
3e38: 4b ff ec f5 bl 2b2c <rdev_mmap+0x8>
3e38: R_PPC64_REL24 rdev_mmap
3e3c: 60 00 00 00 nop
if (map == NULL)
3e40: 7c 7b 1b 79 mr. r27,r3
3e44: 41 82 ff b8 beq 3dfc <cbfs_load_and_decompress+0x30>
out_size = ulz4fn(map, in_size, buffer, buffer_size);
3e48: 7f e4 fb 78 mr r4,r31
3e4c: 7f c6 f3 78 mr r6,r30
3e50: 7f a5 eb 78 mr r5,r29
3e54: 4b ff e8 49 bl 269c <ulz4fn+0x8>
3e54: R_PPC64_REL24 ulz4fn
3e58: 60 00 00 00 nop
rdev_munmap(rdev, map);
3e5c: 7f 64 db 78 mr r4,r27
out_size = ulz4fn(map, in_size, buffer, buffer_size);
3e60: 7c 7f 1b 78 mr r31,r3
rdev_munmap(rdev, map);
3e64: 7f 83 e3 78 mr r3,r28
3e68: 4b ff ed 5d bl 2bc4 <rdev_munmap+0x8>
3e68: R_PPC64_REL24 rdev_munmap
3e6c: 60 00 00 00 nop
return out_size;
3e70: 4b ff ff b8 b 3e28 <cbfs_load_and_decompress+0x5c>
3e74: 00 00 00 00 .long 0x0
3e78: 00 00 00 01 .long 0x1
3e7c: 80 05 00 00 lwz r0,0(r5)
0000000000003e80 <cbfs_prog_stage_load>:
return cbfs_load_and_decompress(&fh.data, 0, region_device_sz(&fh.data),
buf, buf_size, compression_algo);
}
int cbfs_prog_stage_load(struct prog *pstage)
{
3e80: 3c 40 00 02 lis r2,2
3e82: R_PPC64_ADDR16_HA .TOC.
3e84: 38 42 80 00 addi r2,r2,-32768
3e86: R_PPC64_ADDR16_LO .TOC.
3e88: 7c 08 02 a6 mflr r0
void *entry;
size_t fsize;
size_t foffset;
const struct region_device *fh = prog_rdev(pstage);
if (rdev_readat(fh, &stage, 0, sizeof(stage)) != sizeof(stage))
3e8c: 38 c0 00 1c li r6,28
3e90: 38 a0 00 00 li r5,0
{
3e94: 48 00 0e 29 bl 4cbc <_savegpr0_25>
3e94: R_PPC64_REL24 _savegpr0_25
3e98: f8 21 ff 21 stdu r1,-224(r1)
return prog->cbfs_type;
}
static inline struct region_device *prog_rdev(struct prog *prog)
{
return &prog->rdev;
3e9c: 3b 83 00 10 addi r28,r3,16
3ea0: 7c 7d 1b 78 mr r29,r3
if (rdev_readat(fh, &stage, 0, sizeof(stage)) != sizeof(stage))
3ea4: 38 81 00 80 addi r4,r1,128
3ea8: 7f 83 e3 78 mr r3,r28
3eac: 4b ff ed 85 bl 2c30 <rdev_readat+0x8>
3eac: R_PPC64_REL24 rdev_readat
3eb0: 60 00 00 00 nop
3eb4: 2f a3 00 1c cmpdi cr7,r3,28
3eb8: 41 9e 00 10 beq cr7,3ec8 <cbfs_prog_stage_load+0x48>
}
fsize = cbfs_stage_load_and_decompress(fh, foffset, fsize, load,
stage.memlen, stage.compression);
if (!fsize)
return -1;
3ebc: 38 60 ff ff li r3,-1
out:
prog_set_area(pstage, load, stage.memlen);
prog_set_entry(pstage, entry, NULL);
return 0;
}
3ec0: 38 21 00 e0 addi r1,r1,224
3ec4: 48 00 0e 48 b 4d0c <_restgpr0_25>
3ec4: R_PPC64_REL24 _restgpr0_25
fsize -= sizeof(stage);
3ec8: eb fd 00 28 ld r31,40(r29)
assert(fsize == stage.len);
3ecc: 81 21 00 94 lwz r9,148(r1)
fsize -= sizeof(stage);
3ed0: 3b ff ff e4 addi r31,r31,-28
assert(fsize == stage.len);
3ed4: 7f a9 f8 00 cmpd cr7,r9,r31
3ed8: 41 9e 00 24 beq cr7,3efc <cbfs_prog_stage_load+0x7c>
3edc: 3c a2 ff ff addis r5,r2,-1
3ede: R_PPC64_TOC16_HA .text+0x4b4c
3ee0: 3c 82 ff ff addis r4,r2,-1
3ee2: R_PPC64_TOC16_HA .text+0x4b5b
3ee4: 38 c0 01 2b li r6,299
3ee8: 38 60 00 00 li r3,0
3eec: 38 a5 cb 4c addi r5,r5,-13492
3eee: R_PPC64_TOC16_LO .text+0x4b4c
3ef0: 38 84 cb 5b addi r4,r4,-13477
3ef2: R_PPC64_TOC16_LO .text+0x4b5b
3ef4: 4b ff f2 59 bl 314c <do_printk+0x8>
3ef4: R_PPC64_REL24 do_printk
3ef8: 60 00 00 00 nop
fsize = cbfs_stage_load_and_decompress(fh, foffset, fsize, load,
3efc: 81 01 00 80 lwz r8,128(r1)
load = (void *)(uintptr_t)stage.load;
3f00: eb c1 00 8c ld r30,140(r1)
entry = (void *)(uintptr_t)stage.entry;
3f04: eb 21 00 84 ld r25,132(r1)
fsize = cbfs_stage_load_and_decompress(fh, foffset, fsize, load,
3f08: 83 41 00 98 lwz r26,152(r1)
if (compression == CBFS_COMPRESS_LZ4) {
3f0c: 2b 88 00 02 cmplwi cr7,r8,2
3f10: 40 9e 00 c8 bne cr7,3fd8 <cbfs_prog_stage_load+0x158>
void *compr_start = buffer + buffer_size - in_size;
3f14: 7f 7f d0 50 subf r27,r31,r26
if (rdev_readat(rdev, compr_start, offset, in_size) != in_size)
3f18: 7f e6 fb 78 mr r6,r31
3f1c: 38 a0 00 1c li r5,28
3f20: 7f 83 e3 78 mr r3,r28
void *compr_start = buffer + buffer_size - in_size;
3f24: 7f 7e da 14 add r27,r30,r27
if (rdev_readat(rdev, compr_start, offset, in_size) != in_size)
3f28: 7f 64 db 78 mr r4,r27
3f2c: 4b ff ed 05 bl 2c30 <rdev_readat+0x8>
3f2c: R_PPC64_REL24 rdev_readat
3f30: 60 00 00 00 nop
3f34: 7f a3 f8 00 cmpd cr7,r3,r31
3f38: 40 9e ff 84 bne cr7,3ebc <cbfs_prog_stage_load+0x3c>
rdev_chain(&rdev_src, &addrspace_32bit.rdev,
3f3c: 3c 82 ff ff addis r4,r2,-1
3f3e: R_PPC64_TOC16_HA addrspace_32bit+0x8
3f40: 38 84 cd c0 addi r4,r4,-12864
3f42: R_PPC64_TOC16_LO addrspace_32bit+0x8
3f44: 7f e6 fb 78 mr r6,r31
3f48: 7f 65 db 78 mr r5,r27
3f4c: 38 61 00 60 addi r3,r1,96
3f50: 4b ff ed 75 bl 2cc4 <rdev_chain+0x8>
3f50: R_PPC64_REL24 rdev_chain
3f54: 60 00 00 00 nop
return cbfs_load_and_decompress(&rdev_src, 0, in_size, buffer,
3f58: 39 00 00 02 li r8,2
3f5c: 7f 47 d3 78 mr r7,r26
3f60: 7f c6 f3 78 mr r6,r30
3f64: 7f e5 fb 78 mr r5,r31
3f68: 38 80 00 00 li r4,0
3f6c: 38 61 00 60 addi r3,r1,96
return cbfs_load_and_decompress(rdev, offset, in_size, buffer,
3f70: 4b ff fe 65 bl 3dd4 <cbfs_load_and_decompress+0x8>
3f70: R_PPC64_REL24 cbfs_load_and_decompress
if (!fsize)
3f74: 2f a3 00 00 cmpdi cr7,r3,0
3f78: 41 9e ff 44 beq cr7,3ebc <cbfs_prog_stage_load+0x3c>
memset(&load[fsize], 0, stage.memlen - fsize);
3f7c: 80 a1 00 98 lwz r5,152(r1)
3f80: 38 80 00 00 li r4,0
3f84: 7c a3 28 50 subf r5,r3,r5
3f88: 7c 7e 1a 14 add r3,r30,r3
3f8c: 48 00 06 b9 bl 4644 <memset>
3f8c: R_PPC64_REL24 memset
3f90: 60 00 00 00 nop
prog_segment_loaded((uintptr_t)load, stage.memlen, SEG_FINAL);
3f94: 80 81 00 98 lwz r4,152(r1)
3f98: 38 a0 00 01 li r5,1
3f9c: 7f c3 f3 78 mr r3,r30
3fa0: 48 00 08 4d bl 47ec <prog_segment_loaded+0x8>
3fa0: R_PPC64_REL24 prog_segment_loaded
3fa4: 60 00 00 00 nop
extern const struct mem_region_device addrspace_32bit;
static inline void prog_memory_init(struct prog *prog, uintptr_t ptr,
size_t size)
{
rdev_chain(&prog->rdev, &addrspace_32bit.rdev, ptr, size);
3fa8: 80 c1 00 98 lwz r6,152(r1)
3fac: 3c 82 ff ff addis r4,r2,-1
3fae: R_PPC64_TOC16_HA addrspace_32bit+0x8
3fb0: 38 84 cd c0 addi r4,r4,-12864
3fb2: R_PPC64_TOC16_LO addrspace_32bit+0x8
3fb4: 7f c5 f3 78 mr r5,r30
3fb8: 7f 83 e3 78 mr r3,r28
3fbc: 4b ff ed 09 bl 2cc4 <rdev_chain+0x8>
3fbc: R_PPC64_REL24 rdev_chain
3fc0: 60 00 00 00 nop
}
static inline void prog_set_entry(struct prog *prog, void *e, void *arg)
{
prog->entry = e;
prog->arg = arg;
3fc4: 39 20 00 00 li r9,0
prog->entry = e;
3fc8: fb 3d 00 30 std r25,48(r29)
return 0;
3fcc: 38 60 00 00 li r3,0
prog->arg = arg;
3fd0: f9 3d 00 38 std r9,56(r29)
3fd4: 4b ff fe ec b 3ec0 <cbfs_prog_stage_load+0x40>
return cbfs_load_and_decompress(rdev, offset, in_size, buffer,
3fd8: 7f 47 d3 78 mr r7,r26
3fdc: 7f c6 f3 78 mr r6,r30
3fe0: 7f e5 fb 78 mr r5,r31
3fe4: 38 80 00 1c li r4,28
3fe8: 7f 83 e3 78 mr r3,r28
3fec: 4b ff ff 84 b 3f70 <cbfs_prog_stage_load+0xf0>
3ff0: 00 00 00 00 .long 0x0
3ff4: 00 00 00 01 .long 0x1
3ff8: 80 07 00 00 lwz r0,0(r7)
0000000000003ffc <cbfs_boot_region_device>:
int cbfs_boot_region_device(struct region_device *rdev)
{
3ffc: 3c 40 00 02 lis r2,2
3ffe: R_PPC64_ADDR16_HA .TOC.
4000: 38 42 80 00 addi r2,r2,-32768
4002: R_PPC64_ADDR16_LO .TOC.
4004: 7c 08 02 a6 mflr r0
4008: fb e1 ff f8 std r31,-8(r1)
400c: 7c 7f 1b 78 mr r31,r3
4010: f8 01 00 10 std r0,16(r1)
4014: f8 21 ff d1 stdu r1,-48(r1)
boot_device_init();
4018: 4b ff fc 55 bl 3c6c <boot_device_init>
4018: R_PPC64_REL24 boot_device_init
401c: 60 00 00 00 nop
return vboot_locate_cbfs(rdev) &&
fmap_locate_area_as_rdev("COREBOOT", rdev);
4020: 3c 62 ff ff addis r3,r2,-1
4022: R_PPC64_TOC16_HA .text+0x4b43
4024: 7f e4 fb 78 mr r4,r31
4028: 38 63 cb 43 addi r3,r3,-13501
402a: R_PPC64_TOC16_LO .text+0x4b43
402c: 48 00 04 c9 bl 44f4 <fmap_locate_area_as_rdev+0x8>
402c: R_PPC64_REL24 fmap_locate_area_as_rdev
4030: 60 00 00 00 nop
}
4034: 38 21 00 30 addi r1,r1,48
4038: 2f 83 00 00 cmpwi cr7,r3,0
403c: 38 60 00 01 li r3,1
4040: 7c 60 1f 9e isel r3,0,r3,30
4044: 48 00 0c f4 b 4d38 <_restgpr0_31>
4044: R_PPC64_REL24 _restgpr0_31
4048: 00 00 00 00 .long 0x0
404c: 00 00 00 01 .long 0x1
4050: 80 01 00 00 lwz r0,0(r1)
0000000000004054 <cbfs_boot_locate>:
{
4054: 3c 40 00 02 lis r2,2
4056: R_PPC64_ADDR16_HA .TOC.
4058: 38 42 80 00 addi r2,r2,-32768
405a: R_PPC64_ADDR16_LO .TOC.
405c: 7c 08 02 a6 mflr r0
4060: 48 00 0c 6d bl 4ccc <_savegpr0_29>
4060: R_PPC64_REL24 _savegpr0_29
4064: f8 21 ff a1 stdu r1,-96(r1)
4068: 7c 7f 1b 78 mr r31,r3
406c: 7c 9e 23 78 mr r30,r4
4070: 7c bd 2b 78 mr r29,r5
if (cbfs_boot_region_device(&rdev))
4074: 38 61 00 20 addi r3,r1,32
4078: 4b ff ff 8d bl 4004 <cbfs_boot_region_device+0x8>
4078: R_PPC64_REL24 cbfs_boot_region_device
407c: 2f a3 00 00 cmpdi cr7,r3,0
4080: 40 9e 00 24 bne cr7,40a4 <cbfs_boot_locate+0x50>
int ret = cbfs_locate(fh, &rdev, name, type);
4084: 7f a6 eb 78 mr r6,r29
4088: 7f c5 f3 78 mr r5,r30
408c: 38 81 00 20 addi r4,r1,32
4090: 7f e3 fb 78 mr r3,r31
4094: 4b ff e7 c1 bl 2854 <cbfs_locate+0x8>
4094: R_PPC64_REL24 cbfs_locate
4098: 60 00 00 00 nop
}
409c: 38 21 00 60 addi r1,r1,96
40a0: 48 00 0c 7c b 4d1c <_restgpr0_29>
40a0: R_PPC64_REL24 _restgpr0_29
return -1;
40a4: 38 60 ff ff li r3,-1
40a8: 4b ff ff f4 b 409c <cbfs_boot_locate+0x48>
40ac: 00 00 00 00 .long 0x0
40b0: 00 00 00 01 .long 0x1
40b4: 80 03 00 00 lwz r0,0(r3)
00000000000040b8 <cbmemc_init>:
current_console = cbm_cons_p;
}
void cbmemc_init(void)
{
40b8: 3c 40 00 02 lis r2,2
40ba: R_PPC64_ADDR16_HA .TOC.
40bc: 38 42 80 00 addi r2,r2,-32768
40be: R_PPC64_ADDR16_LO .TOC.
if (ENV_ROMSTAGE_OR_BEFORE) {
/* Pre-RAM environments use special buffer placed by linker script. */
init_console_ptr(_preram_cbmem_console, REGION_SIZE(preram_cbmem_console));
40c0: 3d 42 00 07 addis r10,r2,7
40c2: R_PPC64_TOC16_HA _preram_cbmem_console
40c4: 39 4a 80 00 addi r10,r10,-32768
40c6: R_PPC64_TOC16_LO _preram_cbmem_console
40c8: 3d 22 00 07 addis r9,r2,7
40ca: R_PPC64_TOC16_HA _epreram_cbmem_console
40cc: 39 29 a0 00 addi r9,r9,-24576
40ce: R_PPC64_TOC16_LO _epreram_cbmem_console
if (!cbm_cons_p || total_space <= sizeof(struct cbmem_console)) {
40d0: 2f aa 00 00 cmpdi cr7,r10,0
init_console_ptr(_preram_cbmem_console, REGION_SIZE(preram_cbmem_console));
40d4: 7d 2a 48 50 subf r9,r10,r9
40d8: 79 26 00 20 clrldi r6,r9,32
if (!cbm_cons_p || total_space <= sizeof(struct cbmem_console)) {
40dc: 41 9e 00 0c beq cr7,40e8 <cbmemc_init+0x30>
40e0: 2b 86 00 08 cmplwi cr7,r6,8
40e4: 41 9d 00 14 bgt cr7,40f8 <cbmemc_init+0x40>
current_console = NULL;
40e8: 39 20 00 00 li r9,0
40ec: 3d 42 ff ff addis r10,r2,-1
40ee: R_PPC64_TOC16_HA .bss+0x20
40f0: f9 2a ce 00 std r9,-12800(r10)
40f2: R_PPC64_TOC16_LO_DS .bss+0x20
return;
40f4: 4e 80 00 20 blr
return (cbm_cons_p->cursor & CURSOR_MASK) < cbm_cons_p->size &&
40f8: 80 ea 00 04 lwz r7,4(r10)
40fc: 81 0a 00 00 lwz r8,0(r10)
4100: 54 e7 01 3e clrlwi r7,r7,4
cbm_cons_p->size <= MAX_SIZE &&
4104: 7f 87 40 40 cmplw cr7,r7,r8
4108: 40 9c 00 20 bge cr7,4128 <cbmemc_init+0x70>
return (cbm_cons_p->cursor & CURSOR_MASK) < cbm_cons_p->size &&
410c: 3c e0 10 00 lis r7,4096
4110: 7f 88 38 40 cmplw cr7,r8,r7
4114: 41 9d 00 14 bgt cr7,4128 <cbmemc_init+0x70>
cbm_cons_p->size == total_space - sizeof(struct cbmem_console);
4118: 79 29 00 20 clrldi r9,r9,32
411c: 39 29 ff f8 addi r9,r9,-8
cbm_cons_p->size <= MAX_SIZE &&
4120: 7f a8 48 00 cmpd cr7,r8,r9
4124: 41 9e 00 14 beq cr7,4138 <cbmemc_init+0x80>
cbm_cons_p->size = total_space - sizeof(struct cbmem_console);
4128: 38 c6 ff f8 addi r6,r6,-8
cbm_cons_p->cursor = 0;
412c: 39 20 00 00 li r9,0
cbm_cons_p->size = total_space - sizeof(struct cbmem_console);
4130: 90 ca 00 00 stw r6,0(r10)
cbm_cons_p->cursor = 0;
4134: 91 2a 00 04 stw r9,4(r10)
current_console = cbm_cons_p;
4138: 3d 22 ff ff addis r9,r2,-1
413a: R_PPC64_TOC16_HA .bss+0x20
413c: f9 49 ce 00 std r10,-12800(r9)
413e: R_PPC64_TOC16_LO_DS .bss+0x20
} else {
/* Post-RAM uses static (BSS) buffer before CBMEM is reinitialized. */
init_console_ptr(static_console, sizeof(static_console));
}
}
4140: 4e 80 00 20 blr
...
0000000000004150 <cbmemc_tx_byte>:
void cbmemc_tx_byte(unsigned char data)
{
4150: 3c 40 00 02 lis r2,2
4152: R_PPC64_ADDR16_HA .TOC.
4154: 38 42 80 00 addi r2,r2,-32768
4156: R_PPC64_ADDR16_LO .TOC.
if (!current_console || !current_console->size)
4158: 3d 42 ff ff addis r10,r2,-1
415a: R_PPC64_TOC16_HA .bss+0x20
415c: e9 4a ce 00 ld r10,-12800(r10)
415e: R_PPC64_TOC16_LO_DS .bss+0x20
4160: 2f aa 00 00 cmpdi cr7,r10,0
4164: 4d 9e 00 20 beqlr cr7
4168: 80 ca 00 00 lwz r6,0(r10)
416c: 2f a6 00 00 cmpdi cr7,r6,0
4170: 4d 9e 00 20 beqlr cr7
return;
u32 flags = current_console->cursor & ~CURSOR_MASK;
4174: 81 2a 00 04 lwz r9,4(r10)
4178: 55 27 00 06 rlwinm r7,r9,0,0,3
u32 cursor = current_console->cursor & CURSOR_MASK;
417c: 55 29 01 3e clrlwi r9,r9,4
4180: 79 25 00 20 clrldi r5,r9,32
current_console->body[cursor++] = data;
4184: 39 29 00 01 addi r9,r9,1
u32 flags = current_console->cursor & ~CURSOR_MASK;
4188: 78 e8 00 20 clrldi r8,r7,32
if (cursor >= current_console->size) {
418c: 7f 86 48 40 cmplw cr7,r6,r9
current_console->body[cursor++] = data;
4190: 7c aa 2a 14 add r5,r10,r5
4194: 79 24 00 20 clrldi r4,r9,32
4198: 98 65 00 08 stb r3,8(r5)
if (cursor >= current_console->size) {
419c: 41 9d 00 10 bgt cr7,41ac <cbmemc_tx_byte+0x5c>
cursor = 0;
flags |= OVERFLOW;
41a0: 64 e8 80 00 oris r8,r7,32768
cursor = 0;
41a4: 38 80 00 00 li r4,0
flags |= OVERFLOW;
41a8: 79 08 00 20 clrldi r8,r8,32
}
current_console->cursor = flags | cursor;
41ac: 7d 08 23 78 or r8,r8,r4
41b0: 91 0a 00 04 stw r8,4(r10)
}
41b4: 4e 80 00 20 blr
...
00000000000041c4 <report>:
{
return memcmp(fmap->signature, FMAP_SIGNATURE, sizeof(fmap->signature));
}
static void report(const struct fmap *fmap)
{
41c4: 3c 40 00 02 lis r2,2
41c6: R_PPC64_ADDR16_HA .TOC.
41c8: 38 42 80 00 addi r2,r2,-32768
41ca: R_PPC64_ADDR16_LO .TOC.
print_once(BIOS_DEBUG, "FMAP: Found \"%s\" version %d.%d at %#x.\n",
41cc: 3d 22 ff ff addis r9,r2,-1
41ce: R_PPC64_TOC16_HA .bss+0x50
41d0: 81 29 ce 30 lwz r9,-12752(r9)
41d2: R_PPC64_TOC16_LO .bss+0x50
41d4: 2f 89 00 00 cmpwi cr7,r9,0
41d8: 40 9e 00 84 bne cr7,425c <report+0x98>
{
41dc: 7c 08 02 a6 mflr r0
41e0: fb e1 ff f8 std r31,-8(r1)
print_once(BIOS_DEBUG, "FMAP: Found \"%s\" version %d.%d at %#x.\n",
41e4: 3c 82 ff ff addis r4,r2,-1
41e6: R_PPC64_TOC16_HA .text+0x4bcc
41e8: 38 a3 00 16 addi r5,r3,22
41ec: 7c 7f 1b 78 mr r31,r3
41f0: 3d 00 00 02 lis r8,2
41f4: 38 84 cb cc addi r4,r4,-13364
41f6: R_PPC64_TOC16_LO .text+0x4bcc
{
41f8: f8 01 00 10 std r0,16(r1)
41fc: f8 21 ff 91 stdu r1,-112(r1)
print_once(BIOS_DEBUG, "FMAP: Found \"%s\" version %d.%d at %#x.\n",
4200: 88 e3 00 09 lbz r7,9(r3)
4204: 88 c3 00 08 lbz r6,8(r3)
4208: 38 60 00 07 li r3,7
420c: 4b ff ef 41 bl 314c <do_printk+0x8>
420c: R_PPC64_REL24 do_printk
4210: 60 00 00 00 nop
fmap->name, fmap->ver_major, fmap->ver_minor, FMAP_OFFSET);
print_once(BIOS_DEBUG, "FMAP: base = %#llx size = %#x #areas = %d\n",
4214: 3d 22 ff ff addis r9,r2,-1
4216: R_PPC64_TOC16_HA .bss+0x50
4218: 81 29 ce 30 lwz r9,-12752(r9)
421a: R_PPC64_TOC16_LO .bss+0x50
421c: 2f 89 00 00 cmpwi cr7,r9,0
4220: 40 9e 00 28 bne cr7,4248 <report+0x84>
4224: 39 3f 00 0a addi r9,r31,10
4228: 3c 82 ff ff addis r4,r2,-1
422a: R_PPC64_TOC16_HA .text+0x4bf4
422c: a0 ff 00 36 lhz r7,54(r31)
4230: 80 df 00 12 lwz r6,18(r31)
4234: 38 60 00 07 li r3,7
4238: e8 a9 00 00 ld r5,0(r9)
423c: 38 84 cb f4 addi r4,r4,-13324
423e: R_PPC64_TOC16_LO .text+0x4bf4
4240: 4b ff ef 0d bl 314c <do_printk+0x8>
4240: R_PPC64_REL24 do_printk
4244: 60 00 00 00 nop
(long long)fmap->base, fmap->size, fmap->nareas);
fmap_print_once = 1;
4248: 39 20 00 01 li r9,1
424c: 3d 42 ff ff addis r10,r2,-1
424e: R_PPC64_TOC16_HA .bss+0x50
}
4250: 38 21 00 70 addi r1,r1,112
fmap_print_once = 1;
4254: 91 2a ce 30 stw r9,-12752(r10)
4256: R_PPC64_TOC16_LO .bss+0x50
}
4258: 48 00 0a e0 b 4d38 <_restgpr0_31>
4258: R_PPC64_REL24 _restgpr0_31
fmap_print_once = 1;
425c: 39 20 00 01 li r9,1
4260: 3d 42 ff ff addis r10,r2,-1
4262: R_PPC64_TOC16_HA .bss+0x50
4264: 91 2a ce 30 stw r9,-12752(r10)
4266: R_PPC64_TOC16_LO .bss+0x50
4268: 4e 80 00 20 blr
426c: 00 00 00 00 .long 0x0
4270: 00 00 00 01 .long 0x1
4274: 80 01 00 00 lwz r0,0(r1)
0000000000004278 <find_fmap_directory>:
register_cache:
mem_region_device_ro_init(cache_mrdev, fmap, FMAP_SIZE);
}
static int find_fmap_directory(struct region_device *fmrd)
{
4278: 3c 40 00 02 lis r2,2
427a: R_PPC64_ADDR16_HA .TOC.
427c: 38 42 80 00 addi r2,r2,-32768
427e: R_PPC64_ADDR16_LO .TOC.
4280: 7c 08 02 a6 mflr r0
const struct region_device *boot;
struct fmap *fmap;
size_t offset = FMAP_OFFSET;
/* Try FMAP cache first */
if (!region_device_sz(&fmap_cache.rdev))
4284: 3d 22 ff ff addis r9,r2,-1
4286: R_PPC64_TOC16_HA .bss+0x48
4288: e9 29 ce 28 ld r9,-12760(r9)
428a: R_PPC64_TOC16_LO_DS .bss+0x48
428c: 2f a9 00 00 cmpdi cr7,r9,0
{
4290: 48 00 0a 3d bl 4ccc <_savegpr0_29>
4290: R_PPC64_REL24 _savegpr0_29
return &rdev->region;
}
static inline size_t region_device_sz(const struct region_device *rdev)
{
return region_sz(region_device_region(rdev));
4294: 3f c2 ff ff addis r30,r2,-1
4296: R_PPC64_TOC16_HA .bss+0x28
4298: f8 21 ff 81 stdu r1,-128(r1)
429c: 7c 7d 1b 78 mr r29,r3
42a0: 3b de ce 08 addi r30,r30,-12792
42a2: R_PPC64_TOC16_LO .bss+0x28
if (!region_device_sz(&fmap_cache.rdev))
42a4: 40 9e 00 90 bne cr7,4334 <find_fmap_directory+0xbc>
memset(fmap->signature, 0, sizeof(fmap->signature));
42a8: 3f e2 00 07 addis r31,r2,7
42aa: R_PPC64_TOC16_HA _fmap_cache
42ac: 3b ff a0 00 addi r31,r31,-24576
42ae: R_PPC64_TOC16_LO _fmap_cache
42b0: 38 a0 00 08 li r5,8
42b4: 38 80 00 00 li r4,0
42b8: 7f e3 fb 78 mr r3,r31
42bc: 48 00 03 89 bl 4644 <memset>
42bc: R_PPC64_REL24 memset
42c0: 60 00 00 00 nop
boot_device_init();
42c4: 4b ff f9 a9 bl 3c6c <boot_device_init>
42c4: R_PPC64_REL24 boot_device_init
42c8: 60 00 00 00 nop
const struct region_device *boot_rdev = boot_device_ro();
42cc: 4b ff df 51 bl 221c <boot_device_ro+0x8>
42cc: R_PPC64_REL24 boot_device_ro
42d0: 60 00 00 00 nop
if (!boot_rdev)
42d4: 2f a3 00 00 cmpdi cr7,r3,0
42d8: 41 9e 00 5c beq cr7,4334 <find_fmap_directory+0xbc>
if (rdev_readat(boot_rdev, fmap, FMAP_OFFSET, FMAP_SIZE) != FMAP_SIZE)
42dc: 38 c0 00 e0 li r6,224
42e0: 3c a0 00 02 lis r5,2
42e4: 7f e4 fb 78 mr r4,r31
42e8: 4b ff e9 49 bl 2c30 <rdev_readat+0x8>
42e8: R_PPC64_REL24 rdev_readat
42ec: 60 00 00 00 nop
42f0: 2f a3 00 e0 cmpdi cr7,r3,224
42f4: 40 9e 00 40 bne cr7,4334 <find_fmap_directory+0xbc>
return memcmp(fmap->signature, FMAP_SIGNATURE, sizeof(fmap->signature));
42f8: 3c 82 ff ff addis r4,r2,-1
42fa: R_PPC64_TOC16_HA .text+0x4b80
42fc: 38 a0 00 08 li r5,8
4300: 7f e3 fb 78 mr r3,r31
4304: 38 84 cb 80 addi r4,r4,-13440
4306: R_PPC64_TOC16_LO .text+0x4b80
4308: 48 00 02 4d bl 4554 <memcmp>
4308: R_PPC64_REL24 memcmp
430c: 60 00 00 00 nop
if (check_signature(fmap))
4310: 2f a3 00 00 cmpdi cr7,r3,0
4314: 40 9e 00 20 bne cr7,4334 <find_fmap_directory+0xbc>
report(fmap);
4318: 7f e3 fb 78 mr r3,r31
431c: 4b ff fe b1 bl 41cc <report+0x8>
431c: R_PPC64_REL24 report
mem_region_device_ro_init(cache_mrdev, fmap, FMAP_SIZE);
4320: 38 a0 00 e0 li r5,224
4324: 7f e4 fb 78 mr r4,r31
4328: 7f c3 f3 78 mr r3,r30
432c: 4b ff ea 25 bl 2d50 <mem_region_device_ro_init+0x8>
432c: R_PPC64_REL24 mem_region_device_ro_init
4330: 60 00 00 00 nop
4334: 3c c2 ff ff addis r6,r2,-1
4336: R_PPC64_TOC16_HA .bss+0x48
4338: e8 c6 ce 28 ld r6,-12760(r6)
433a: R_PPC64_TOC16_LO_DS .bss+0x48
static inline int rdev_chain_full(struct region_device *child,
const struct region_device *parent)
{
/* Chain full size of parent. */
return rdev_chain(child, parent, 0, region_device_sz(parent));
433c: 38 a0 00 00 li r5,0
4340: 38 9e 00 08 addi r4,r30,8
setup_preram_cache(&fmap_cache);
if (region_device_sz(&fmap_cache.rdev))
4344: 2f a6 00 00 cmpdi cr7,r6,0
4348: 40 9e 00 ac bne cr7,43f4 <find_fmap_directory+0x17c>
return rdev_chain_full(fmrd, &fmap_cache.rdev);
boot_device_init();
434c: 4b ff f9 21 bl 3c6c <boot_device_init>
434c: R_PPC64_REL24 boot_device_init
4350: 60 00 00 00 nop
boot = boot_device_ro();
4354: 4b ff de c9 bl 221c <boot_device_ro+0x8>
4354: R_PPC64_REL24 boot_device_ro
4358: 60 00 00 00 nop
if (boot == NULL)
435c: 7c 7f 1b 79 mr. r31,r3
4360: 40 82 00 10 bne 4370 <find_fmap_directory+0xf8>
return -1;
if (check_signature(fmap)) {
printk(BIOS_DEBUG, "No FMAP found at %zx offset.\n", offset);
rdev_munmap(boot, fmap);
return -1;
4364: 38 60 ff ff li r3,-1
report(fmap);
rdev_munmap(boot, fmap);
return rdev_chain(fmrd, boot, offset, FMAP_SIZE);
}
4368: 38 21 00 80 addi r1,r1,128
436c: 48 00 09 b0 b 4d1c <_restgpr0_29>
436c: R_PPC64_REL24 _restgpr0_29
fmap = rdev_mmap(boot, offset, sizeof(struct fmap));
4370: 38 a0 00 38 li r5,56
4374: 3c 80 00 02 lis r4,2
4378: 4b ff e7 b5 bl 2b2c <rdev_mmap+0x8>
4378: R_PPC64_REL24 rdev_mmap
437c: 60 00 00 00 nop
if (fmap == NULL)
4380: 7c 7e 1b 79 mr. r30,r3
4384: 41 82 ff e0 beq 4364 <find_fmap_directory+0xec>
return memcmp(fmap->signature, FMAP_SIGNATURE, sizeof(fmap->signature));
4388: 3c 82 ff ff addis r4,r2,-1
438a: R_PPC64_TOC16_HA .text+0x4b80
438c: 38 a0 00 08 li r5,8
4390: 38 84 cb 80 addi r4,r4,-13440
4392: R_PPC64_TOC16_LO .text+0x4b80
4394: 48 00 01 c1 bl 4554 <memcmp>
4394: R_PPC64_REL24 memcmp
4398: 60 00 00 00 nop
if (check_signature(fmap)) {
439c: 2f a3 00 00 cmpdi cr7,r3,0
43a0: 41 9e 00 30 beq cr7,43d0 <find_fmap_directory+0x158>
printk(BIOS_DEBUG, "No FMAP found at %zx offset.\n", offset);
43a4: 3c 82 ff ff addis r4,r2,-1
43a6: R_PPC64_TOC16_HA .text+0x4b89
43a8: 3c a0 00 02 lis r5,2
43ac: 38 60 00 07 li r3,7
43b0: 38 84 cb 89 addi r4,r4,-13431
43b2: R_PPC64_TOC16_LO .text+0x4b89
43b4: 4b ff ed 99 bl 314c <do_printk+0x8>
43b4: R_PPC64_REL24 do_printk
43b8: 60 00 00 00 nop
rdev_munmap(boot, fmap);
43bc: 7f c4 f3 78 mr r4,r30
43c0: 7f e3 fb 78 mr r3,r31
43c4: 4b ff e8 01 bl 2bc4 <rdev_munmap+0x8>
43c4: R_PPC64_REL24 rdev_munmap
43c8: 60 00 00 00 nop
43cc: 4b ff ff 98 b 4364 <find_fmap_directory+0xec>
report(fmap);
43d0: 7f c3 f3 78 mr r3,r30
43d4: 4b ff fd f9 bl 41cc <report+0x8>
43d4: R_PPC64_REL24 report
rdev_munmap(boot, fmap);
43d8: 7f c4 f3 78 mr r4,r30
43dc: 7f e3 fb 78 mr r3,r31
43e0: 4b ff e7 e5 bl 2bc4 <rdev_munmap+0x8>
43e0: R_PPC64_REL24 rdev_munmap
43e4: 60 00 00 00 nop
return rdev_chain(fmrd, boot, offset, FMAP_SIZE);
43e8: 38 c0 00 e0 li r6,224
43ec: 3c a0 00 02 lis r5,2
43f0: 7f e4 fb 78 mr r4,r31
43f4: 7f a3 eb 78 mr r3,r29
43f8: 4b ff e8 cd bl 2cc4 <rdev_chain+0x8>
43f8: R_PPC64_REL24 rdev_chain
43fc: 60 00 00 00 nop
4400: 4b ff ff 68 b 4368 <find_fmap_directory+0xf0>
4404: 00 00 00 00 .long 0x0
4408: 00 00 00 01 .long 0x1
440c: 80 03 00 00 lwz r0,0(r3)
0000000000004410 <fmap_locate_area>:
return boot_device_rw_subregion(&ar, area);
}
int fmap_locate_area(const char *name, struct region *ar)
{
4410: 3c 40 00 02 lis r2,2
4412: R_PPC64_ADDR16_HA .TOC.
4414: 38 42 80 00 addi r2,r2,-32768
4416: R_PPC64_ADDR16_LO .TOC.
4418: 7c 08 02 a6 mflr r0
441c: 48 00 08 a9 bl 4cc4 <_savegpr0_27>
441c: R_PPC64_REL24 _savegpr0_27
4420: f8 21 ff 51 stdu r1,-176(r1)
4424: 7c 7b 1b 78 mr r27,r3
4428: 7c 9c 23 78 mr r28,r4
442c: 3b c0 00 38 li r30,56
struct region_device fmrd;
size_t offset;
if (find_fmap_directory(&fmrd))
4430: 38 61 00 60 addi r3,r1,96
4434: 4b ff fe 4d bl 4280 <find_fmap_directory+0x8>
4434: R_PPC64_REL24 find_fmap_directory
4438: 2f a3 00 00 cmpdi cr7,r3,0
443c: 41 9e 00 14 beq cr7,4450 <fmap_locate_area+0x40>
return -1;
4440: 3b a0 ff ff li r29,-1
}
printk(BIOS_DEBUG, "FMAP: area %s not found\n", name);
return -1;
}
4444: 38 21 00 b0 addi r1,r1,176
4448: 7f a3 eb 78 mr r3,r29
444c: 48 00 08 c8 b 4d14 <_restgpr0_27>
444c: R_PPC64_REL24 _restgpr0_27
area = rdev_mmap(&fmrd, offset, sizeof(*area));
4450: 38 a0 00 2a li r5,42
4454: 7f c4 f3 78 mr r4,r30
4458: 38 61 00 60 addi r3,r1,96
445c: 4b ff e6 d1 bl 2b2c <rdev_mmap+0x8>
445c: R_PPC64_REL24 rdev_mmap
4460: 60 00 00 00 nop
if (area == NULL)
4464: 7c 7f 1b 79 mr. r31,r3
4468: 41 82 ff d8 beq 4440 <fmap_locate_area+0x30>
if (strcmp((const char *)area->name, name)) {
446c: 7f 64 db 78 mr r4,r27
4470: 38 7f 00 08 addi r3,r31,8
4474: 48 00 04 4d bl 48c0 <strcmp>
4474: R_PPC64_REL24 strcmp
4478: 60 00 00 00 nop
447c: 7c 7d 1b 79 mr. r29,r3
4480: 41 82 00 1c beq 449c <fmap_locate_area+0x8c>
rdev_munmap(&fmrd, area);
4484: 7f e4 fb 78 mr r4,r31
4488: 38 61 00 60 addi r3,r1,96
offset += sizeof(struct fmap_area);
448c: 3b de 00 2a addi r30,r30,42
rdev_munmap(&fmrd, area);
4490: 4b ff e7 35 bl 2bc4 <rdev_munmap+0x8>
4490: R_PPC64_REL24 rdev_munmap
4494: 60 00 00 00 nop
while (1) {
4498: 4b ff ff b8 b 4450 <fmap_locate_area+0x40>
printk(BIOS_DEBUG, "FMAP: area %s found @ %x (%d bytes)\n",
449c: 80 ff 00 04 lwz r7,4(r31)
44a0: 80 df 00 00 lwz r6,0(r31)
44a4: 3c 82 ff ff addis r4,r2,-1
44a6: R_PPC64_TOC16_HA .text+0x4ba7
44a8: 7f 65 db 78 mr r5,r27
44ac: 38 60 00 07 li r3,7
44b0: 38 84 cb a7 addi r4,r4,-13401
44b2: R_PPC64_TOC16_LO .text+0x4ba7
44b4: 4b ff ec 99 bl 314c <do_printk+0x8>
44b4: R_PPC64_REL24 do_printk
44b8: 60 00 00 00 nop
ar->offset = area->offset;
44bc: 81 3f 00 00 lwz r9,0(r31)
rdev_munmap(&fmrd, area);
44c0: 7f e4 fb 78 mr r4,r31
44c4: 38 61 00 60 addi r3,r1,96
ar->offset = area->offset;
44c8: f9 3c 00 00 std r9,0(r28)
ar->size = area->size;
44cc: 81 3f 00 04 lwz r9,4(r31)
44d0: f9 3c 00 08 std r9,8(r28)
rdev_munmap(&fmrd, area);
44d4: 4b ff e6 f1 bl 2bc4 <rdev_munmap+0x8>
44d4: R_PPC64_REL24 rdev_munmap
44d8: 60 00 00 00 nop
return 0;
44dc: 4b ff ff 68 b 4444 <fmap_locate_area+0x34>
44e0: 00 00 00 00 .long 0x0
44e4: 00 00 00 01 .long 0x1
44e8: 80 05 00 00 lwz r0,0(r5)
00000000000044ec <fmap_locate_area_as_rdev>:
{
44ec: 3c 40 00 02 lis r2,2
44ee: R_PPC64_ADDR16_HA .TOC.
44f0: 38 42 80 00 addi r2,r2,-32768
44f2: R_PPC64_ADDR16_LO .TOC.
44f4: 7c 08 02 a6 mflr r0
44f8: fb e1 ff f8 std r31,-8(r1)
44fc: 7c 9f 23 78 mr r31,r4
4500: f8 01 00 10 std r0,16(r1)
4504: f8 21 ff c1 stdu r1,-64(r1)
if (fmap_locate_area(name, &ar))
4508: 38 81 00 20 addi r4,r1,32
450c: 4b ff ff 0d bl 4418 <fmap_locate_area+0x8>
450c: R_PPC64_REL24 fmap_locate_area
4510: 2f a3 00 00 cmpdi cr7,r3,0
4514: 40 9e 00 1c bne cr7,4530 <fmap_locate_area_as_rdev+0x44>
return boot_device_ro_subregion(&ar, area);
4518: 7f e4 fb 78 mr r4,r31
451c: 38 61 00 20 addi r3,r1,32
4520: 4b ff f7 65 bl 3c84 <boot_device_ro_subregion+0x8>
4520: R_PPC64_REL24 boot_device_ro_subregion
4524: 60 00 00 00 nop
}
4528: 38 21 00 40 addi r1,r1,64
452c: 48 00 08 0c b 4d38 <_restgpr0_31>
452c: R_PPC64_REL24 _restgpr0_31
return -1;
4530: 38 60 ff ff li r3,-1
4534: 4b ff ff f4 b 4528 <fmap_locate_area_as_rdev+0x3c>
4538: 00 00 00 00 .long 0x0
453c: 00 00 00 01 .long 0x1
4540: 80 01 00 00 lwz r0,0(r1)
0000000000004544 <halt>:
/* SPDX-License-Identifier: GPL-2.0-only */
static __always_inline void hlt(void)
{
while (1)
;
4544: 48 00 00 00 b 4544 <halt>
...
0000000000004554 <memcmp>:
{
const unsigned char *s1, *s2;
int result;
s1 = src1;
s2 = src2;
result = 0;
4554: 39 05 00 01 addi r8,r5,1
while ((bytes > 0) && (result == 0)) {
4558: 39 40 00 00 li r10,0
result = 0;
455c: 39 20 00 00 li r9,0
4560: 7d 09 03 a6 mtctr r8
while ((bytes > 0) && (result == 0)) {
4564: 42 40 00 0c bdz 4570 <memcmp+0x1c>
4568: 2f a9 00 00 cmpdi cr7,r9,0
456c: 41 9e 00 0c beq cr7,4578 <memcmp+0x24>
bytes--;
s1++;
s2++;
}
return result;
}
4570: 7d 23 4b 78 mr r3,r9
4574: 4e 80 00 20 blr
result = *s1 - *s2;
4578: 7d 03 50 ae lbzx r8,r3,r10
457c: 7d 24 50 ae lbzx r9,r4,r10
4580: 39 4a 00 01 addi r10,r10,1
4584: 7d 29 40 50 subf r9,r9,r8
4588: 7d 29 07 b4 extsw r9,r9
s2++;
458c: 4b ff ff d8 b 4564 <memcmp+0x10>
...
000000000000459c <memcpy>:
{
const char *src = vsrc;
char *dest = vdest;
int i;
for (i = 0; i < (int)bytes; i++)
459c: 78 a9 00 20 clrldi r9,r5,32
45a0: 2f 85 00 00 cmpwi cr7,r5,0
45a4: 39 00 00 01 li r8,1
45a8: 39 40 00 00 li r10,0
45ac: 39 29 00 01 addi r9,r9,1
45b0: 7d 28 4f 1e isel r9,r8,r9,28
45b4: 2c 29 00 01 cmpdi r9,1
45b8: 39 29 ff ff addi r9,r9,-1
45bc: 4d 82 00 20 beqlr
dest[i] = src[i];
45c0: 7d 04 50 ae lbzx r8,r4,r10
45c4: 7d 03 51 ae stbx r8,r3,r10
45c8: 39 4a 00 01 addi r10,r10,1
45cc: 4b ff ff e8 b 45b4 <memcpy+0x18>
...
00000000000045dc <memmove>:
void *memmove(void *vdest, const void *vsrc, size_t count)
{
const char *src = vsrc;
char *dest = vdest;
if (dest <= src) {
45dc: 7f a4 18 40 cmpld cr7,r4,r3
45e0: 40 9c 00 38 bge cr7,4618 <memmove+0x3c>
while (count--)
*dest++ = *src++;
} else {
src += count - 1;
dest += count - 1;
while (count--)
45e4: 39 05 00 01 addi r8,r5,1
45e8: 39 25 ff ff addi r9,r5,-1
45ec: 39 40 00 00 li r10,0
45f0: 7d 09 03 a6 mtctr r8
src += count - 1;
45f4: 7c 84 4a 14 add r4,r4,r9
dest += count - 1;
45f8: 7d 23 4a 14 add r9,r3,r9
while (count--)
45fc: 42 00 00 2c bdnz 4628 <memmove+0x4c>
*dest-- = *src--;
}
return vdest;
}
4600: 4e 80 00 20 blr
*dest++ = *src++;
4604: 7d 44 48 ae lbzx r10,r4,r9
4608: 7d 43 49 ae stbx r10,r3,r9
460c: 39 29 00 01 addi r9,r9,1
while (count--)
4610: 42 00 ff f4 bdnz 4604 <memmove+0x28>
4614: 4e 80 00 20 blr
4618: 39 45 00 01 addi r10,r5,1
461c: 39 20 00 00 li r9,0
4620: 7d 49 03 a6 mtctr r10
4624: 4b ff ff ec b 4610 <memmove+0x34>
*dest-- = *src--;
4628: 7d 04 50 ae lbzx r8,r4,r10
462c: 7d 09 51 ae stbx r8,r9,r10
4630: 39 4a ff ff addi r10,r10,-1
4634: 4b ff ff c8 b 45fc <memmove+0x20>
...
0000000000004644 <memset>:
void *memset(void *s, int c, size_t n)
{
int i;
char *ss = (char *) s;
for (i = 0; i < (int)n; i++)
4644: 78 a9 00 20 clrldi r9,r5,32
4648: 2f 85 00 00 cmpwi cr7,r5,0
464c: 39 00 00 01 li r8,1
4650: 39 40 00 00 li r10,0
4654: 39 29 00 01 addi r9,r9,1
4658: 7d 28 4f 1e isel r9,r8,r9,28
465c: 2c 29 00 01 cmpdi r9,1
4660: 39 29 ff ff addi r9,r9,-1
4664: 4d 82 00 20 beqlr
ss[i] = c;
4668: 7c 83 51 ae stbx r4,r3,r10
466c: 39 4a 00 01 addi r10,r10,1
4670: 4b ff ff ec b 465c <memset+0x18>
...
0000000000004680 <prog_locate_hook>:
die_with_post_code(POST_INVALID_ROM,
"Couldn't load romstage.\n");
halt();
}
int __weak prog_locate_hook(struct prog *prog) { return 0; }
4680: 38 60 00 00 li r3,0
4684: 4e 80 00 20 blr
...
0000000000004694 <prog_locate>:
{
4694: 3c 40 00 02 lis r2,2
4696: R_PPC64_ADDR16_HA .TOC.
4698: 38 42 80 00 addi r2,r2,-32768
469a: R_PPC64_ADDR16_LO .TOC.
469c: 7c 08 02 a6 mflr r0
46a0: fb e1 ff f8 std r31,-8(r1)
46a4: fb c1 ff f0 std r30,-16(r1)
46a8: 7c 7f 1b 78 mr r31,r3
46ac: f8 01 00 10 std r0,16(r1)
46b0: f8 21 ff 91 stdu r1,-112(r1)
if (prog_locate_hook(prog))
46b4: 4b ff ff cd bl 4680 <prog_locate_hook>
46b4: R_PPC64_REL24 prog_locate_hook
46b8: 60 00 00 00 nop
46bc: 2f a3 00 00 cmpdi cr7,r3,0
46c0: 41 9e 00 14 beq cr7,46d4 <prog_locate+0x40>
return -1;
46c4: 3b c0 ff ff li r30,-1
}
46c8: 38 21 00 70 addi r1,r1,112
46cc: 7f c3 f3 78 mr r3,r30
46d0: 48 00 06 64 b 4d34 <_restgpr0_30>
46d0: R_PPC64_REL24 _restgpr0_30
if (cbfs_boot_locate(&file, prog_name(prog), NULL))
46d4: e8 9f 00 08 ld r4,8(r31)
46d8: 38 a0 00 00 li r5,0
46dc: 38 61 00 20 addi r3,r1,32
46e0: 4b ff f9 7d bl 405c <cbfs_boot_locate+0x8>
46e0: R_PPC64_REL24 cbfs_boot_locate
46e4: 60 00 00 00 nop
46e8: 7c 7e 1b 79 mr. r30,r3
46ec: 40 82 ff d8 bne 46c4 <prog_locate+0x30>
cbfsf_file_type(&file, &prog->cbfs_type);
46f0: 38 9f 00 04 addi r4,r31,4
46f4: 38 61 00 20 addi r3,r1,32
46f8: 4b ff e0 fd bl 27f4 <cbfsf_file_type+0x8>
46f8: R_PPC64_REL24 cbfsf_file_type
46fc: 60 00 00 00 nop
4700: e8 c1 00 58 ld r6,88(r1)
4704: 38 a0 00 00 li r5,0
4708: 38 81 00 40 addi r4,r1,64
470c: 38 7f 00 10 addi r3,r31,16
4710: 4b ff e5 b5 bl 2cc4 <rdev_chain+0x8>
4710: R_PPC64_REL24 rdev_chain
4714: 60 00 00 00 nop
4718: 4b ff ff b0 b 46c8 <prog_locate+0x34>
471c: 00 00 00 00 .long 0x0
4720: 00 00 00 01 .long 0x1
4724: 80 02 00 00 lwz r0,0(r2)
0000000000004728 <run_romstage>:
{
4728: 3c 40 00 02 lis r2,2
472a: R_PPC64_ADDR16_HA .TOC.
472c: 38 42 80 00 addi r2,r2,-32768
472e: R_PPC64_ADDR16_LO .TOC.
4730: 7c 08 02 a6 mflr r0
struct prog romstage =
4734: 38 a0 00 3c li r5,60
4738: 38 80 00 00 li r4,0
{
473c: f8 01 00 10 std r0,16(r1)
4740: f8 21 ff 61 stdu r1,-160(r1)
struct prog romstage =
4744: 38 61 00 64 addi r3,r1,100
4748: 4b ff fe fd bl 4644 <memset>
4748: R_PPC64_REL24 memset
474c: 60 00 00 00 nop
4750: 39 20 00 03 li r9,3
if (prog_locate(&romstage))
4754: 38 61 00 60 addi r3,r1,96
struct prog romstage =
4758: 91 21 00 60 stw r9,96(r1)
475c: 3d 22 ff ff addis r9,r2,-1
475e: R_PPC64_TOC16_HA .text+0x4c1f
4760: 39 29 cc 1f addi r9,r9,-13281
4762: R_PPC64_TOC16_LO .text+0x4c1f
4764: f9 21 00 68 std r9,104(r1)
if (prog_locate(&romstage))
4768: 4b ff ff 35 bl 469c <prog_locate+0x8>
4768: R_PPC64_REL24 prog_locate
476c: 2f a3 00 00 cmpdi cr7,r3,0
4770: 40 9e 00 2c bne cr7,479c <run_romstage+0x74>
if (cbfs_prog_stage_load(&romstage))
4774: 38 61 00 60 addi r3,r1,96
4778: 4b ff f7 11 bl 3e88 <cbfs_prog_stage_load+0x8>
4778: R_PPC64_REL24 cbfs_prog_stage_load
477c: 60 00 00 00 nop
4780: 2f a3 00 00 cmpdi cr7,r3,0
4784: 40 9e 00 18 bne cr7,479c <run_romstage+0x74>
console_time_report();
4788: 4b ff ea 15 bl 319c <console_time_report+0x8>
4788: R_PPC64_REL24 console_time_report
478c: 60 00 00 00 nop
prog_run(&romstage);
4790: 38 61 00 60 addi r3,r1,96
4794: 48 00 00 b9 bl 484c <prog_run+0x8>
4794: R_PPC64_REL24 prog_run
4798: 60 00 00 00 nop
die_with_post_code(POST_INVALID_ROM,
479c: 38 60 00 e0 li r3,224
47a0: 4b ff e7 ed bl 2f8c <post_code+0x8>
47a0: R_PPC64_REL24 post_code
47a4: 60 00 00 00 nop
47a8: 3c 62 ff ff addis r3,r2,-1
47aa: R_PPC64_TOC16_HA .text+0x4c31
47ac: 38 63 cc 31 addi r3,r3,-13263
47ae: R_PPC64_TOC16_LO .text+0x4c31
47b0: 4b ff e6 89 bl 2e38 <die+0x8>
47b0: R_PPC64_REL24 die
47b4: 60 00 00 00 nop
47b8: 00 00 00 00 .long 0x0
47bc: 00 00 00 01 .long 0x1
47c0: 80 00 00 00 lwz r0,0(0)
00000000000047c4 <platform_segment_loaded>:
void __weak platform_segment_loaded(uintptr_t start,
size_t size, int flags)
{
/* do nothing */
}
47c4: 4e 80 00 20 blr
...
00000000000047d4 <arch_segment_loaded>:
47d4: 4e 80 00 20 blr
...
00000000000047e4 <prog_segment_loaded>:
{
47e4: 3c 40 00 02 lis r2,2
47e6: R_PPC64_ADDR16_HA .TOC.
47e8: 38 42 80 00 addi r2,r2,-32768
47ea: R_PPC64_ADDR16_LO .TOC.
47ec: 7c 08 02 a6 mflr r0
47f0: 48 00 04 dd bl 4ccc <_savegpr0_29>
47f0: R_PPC64_REL24 _savegpr0_29
47f4: f8 21 ff c1 stdu r1,-64(r1)
47f8: 7c 7f 1b 78 mr r31,r3
47fc: 7c 9e 23 78 mr r30,r4
4800: 7c bd 2b 78 mr r29,r5
platform_segment_loaded(start, size, flags);
4804: 4b ff ff c1 bl 47c4 <platform_segment_loaded>
4804: R_PPC64_REL24 platform_segment_loaded
4808: 60 00 00 00 nop
arch_segment_loaded(start, size, flags);
480c: 7f a5 eb 78 mr r5,r29
4810: 7f c4 f3 78 mr r4,r30
4814: 7f e3 fb 78 mr r3,r31
4818: 4b ff ff bd bl 47d4 <arch_segment_loaded>
4818: R_PPC64_REL24 arch_segment_loaded
481c: 60 00 00 00 nop
}
4820: 38 21 00 40 addi r1,r1,64
4824: 48 00 04 f8 b 4d1c <_restgpr0_29>
4824: R_PPC64_REL24 _restgpr0_29
4828: 00 00 00 00 .long 0x0
482c: 00 00 00 01 .long 0x1
4830: 80 03 00 00 lwz r0,0(r3)
0000000000004834 <platform_prog_run>:
}
void __weak platform_prog_run(struct prog *prog)
{
/* do nothing */
}
4834: 4e 80 00 20 blr
...
0000000000004844 <prog_run>:
{
4844: 3c 40 00 02 lis r2,2
4846: R_PPC64_ADDR16_HA .TOC.
4848: 38 42 80 00 addi r2,r2,-32768
484a: R_PPC64_ADDR16_LO .TOC.
484c: 7c 08 02 a6 mflr r0
4850: fb e1 ff f8 std r31,-8(r1)
4854: 7c 7f 1b 78 mr r31,r3
4858: f8 01 00 10 std r0,16(r1)
485c: f8 21 ff d1 stdu r1,-48(r1)
platform_prog_run(prog);
4860: 4b ff ff d5 bl 4834 <platform_prog_run>
4860: R_PPC64_REL24 platform_prog_run
4864: 60 00 00 00 nop
arch_prog_run(prog);
4868: 7f e3 fb 78 mr r3,r31
486c: 4b ff d7 e9 bl 2054 <arch_prog_run+0x8>
486c: R_PPC64_REL24 arch_prog_run
4870: 60 00 00 00 nop
}
4874: 38 21 00 30 addi r1,r1,48
4878: 48 00 04 c0 b 4d38 <_restgpr0_31>
4878: R_PPC64_REL24 _restgpr0_31
487c: 00 00 00 00 .long 0x0
4880: 00 00 00 01 .long 0x1
4884: 80 01 00 00 lwz r0,0(r1)
0000000000004888 <strnlen>:
return d;
}
size_t strnlen(const char *src, size_t max)
{
size_t i = 0;
4888: 39 44 00 01 addi r10,r4,1
488c: 39 20 00 00 li r9,0
4890: 7d 49 03 a6 mtctr r10
while ((*src++) && (i < max))
4894: 7d 43 48 ae lbzx r10,r3,r9
4898: 2f 8a 00 00 cmpwi cr7,r10,0
489c: 41 9e 00 08 beq cr7,48a4 <strnlen+0x1c>
48a0: 42 00 00 0c bdnz 48ac <strnlen+0x24>
i++;
return i;
}
48a4: 7d 23 4b 78 mr r3,r9
48a8: 4e 80 00 20 blr
i++;
48ac: 39 29 00 01 addi r9,r9,1
48b0: 4b ff ff e4 b 4894 <strnlen+0xc>
...
00000000000048c0 <strcmp>:
int strcmp(const char *s1, const char *s2)
{
int r;
while ((r = (*s1 - *s2)) == 0 && *s1) {
48c0: 38 e0 00 00 li r7,0
48c4: 7d 03 38 ae lbzx r8,r3,r7
48c8: 7d 24 38 ae lbzx r9,r4,r7
48cc: 7d 29 40 50 subf r9,r9,r8
48d0: 7d 29 07 b5 extsw. r9,r9
48d4: 40 82 00 10 bne 48e4 <strcmp+0x24>
48d8: 2f a8 00 00 cmpdi cr7,r8,0
48dc: 38 e7 00 01 addi r7,r7,1
48e0: 40 9e ff e4 bne cr7,48c4 <strcmp+0x4>
s1++;
s2++;
}
return r;
}
48e4: 7d 23 4b 78 mr r3,r9
48e8: 4e 80 00 20 blr
...
00000000000048f8 <skip_atoi>:
return 0;
}
unsigned int skip_atoi(char **s)
{
unsigned int i = 0;
48f8: 39 20 00 00 li r9,0
while (isdigit(**s))
48fc: e9 03 00 00 ld r8,0(r3)
4900: 89 48 00 00 lbz r10,0(r8)
4904: 39 4a ff d0 addi r10,r10,-48
4908: 2b 8a 00 09 cmplwi cr7,r10,9
490c: 40 9d 00 0c ble cr7,4918 <skip_atoi+0x20>
i = i*10 + *((*s)++) - '0';
return i;
}
4910: 7d 23 4b 78 mr r3,r9
4914: 4e 80 00 20 blr
i = i*10 + *((*s)++) - '0';
4918: 39 48 00 01 addi r10,r8,1
491c: 1d 29 00 0a mulli r9,r9,10
4920: f9 43 00 00 std r10,0(r3)
4924: 89 48 00 00 lbz r10,0(r8)
4928: 39 4a ff d0 addi r10,r10,-48
492c: 7d 2a 4a 14 add r9,r10,r9
4930: 79 29 00 20 clrldi r9,r9,32
4934: 4b ff ff c8 b 48fc <skip_atoi+0x4>
...
0000000000004944 <init_timer>:
#include <timer.h>
#include <delay.h>
#include <thread.h>
__weak void init_timer(void) { /* do nothing */ }
4944: 4e 80 00 20 blr
...
4954: 60 00 00 00 nop
0000000000004958 <_ersbe_init_begin>:
4958: 00 00 00 04 .long 0x4
495c: 00 00 00 01 .long 0x1
4960: 00 00 00 02 .long 0x2
4964: 00 00 00 01 .long 0x1
4968: 00 00 00 04 .long 0x4
496c: 00 00 00 04 .long 0x4
4970: 00 00 00 04 .long 0x4
4974: 00 00 00 04 .long 0x4
...
4984: ff ff ff ff fnmadd. f31,f31,f31,f31
4988: 00 00 00 00 .long 0x0
498c: 00 00 00 01 .long 0x1
4990: 00 00 00 02 .long 0x2
4994: 00 00 00 03 .long 0x3
4998: 2a 2a 2a 2a cmpldi cr4,r10,10794
499c: 2a 2a 2a 2a cmpldi cr4,r10,10794
49a0: 2a 2a 2a 2a cmpldi cr4,r10,10794
49a4: 2a 2a 2a 2a cmpldi cr4,r10,10794
49a8: 2a 2a 2a 2a cmpldi cr4,r10,10794
49ac: 2a 2a 2a 2a cmpldi cr4,r10,10794
49b0: 2a 2a 2a 2a cmpldi cr4,r10,10794
49b4: 2a 2a 2a 2a cmpldi cr4,r10,10794
49b8: 2a 2a 2a 2a cmpldi cr4,r10,10794
49bc: 2a 2a 2a 2a cmpldi cr4,r10,10794
49c0: 2a 2a 2a 2a cmpldi cr4,r10,10794
49c4: 2a 2a 2a 0a cmpldi cr4,r10,10762
49c8: 00 46 61 74 .long 0x466174
49cc: 61 6c 20 53 ori r12,r11,8275
49d0: 79 73 74 65 rldicr. r19,r11,14,49
49d4: 6d 20 52 65 xoris r0,r9,21093
49d8: 73 65 74 20 andi. r5,r27,29728
49dc: 61 74 20 25 ori r20,r11,8229
49e0: 30 31 36 6c addic r1,r17,13932
49e4: 6c 78 20 20 xoris r24,r3,8224
49e8: 20 00 46 61 subfic r0,r0,18017
49ec: 74 61 6c 20 andis. r1,r3,27680
49f0: 45 78 63 65 .long 0x45786365
49f4: 70 74 69 6f andi. r20,r3,26991
49f8: 6e 20 30 78 xoris r0,r17,12408
49fc: 25 6c 6c 78 dozi r11,r12,27768
4a00: 20 61 74 20 subfic r3,r1,29728
4a04: 25 30 31 36 dozi r9,r16,12598
4a08: 6c 6c 78 20 xoris r12,r3,30752
4a0c: 20 00 20 20 subfic r0,r0,8224
4a10: 4d 53 52 25 .long 0x4d535225
4a14: 30 31 36 6c addic r1,r17,13932
4a18: 6c 78 00 4c xoris r24,r3,76
4a1c: 41 52 43 48 bdzt 4*cr4+eq,8d64 <_ebss+0x3f2c>
4a20: 49 56 45 00 b 1568f20 <_eramstage+0x468f20>
4a24: 43 42 46 53 bcla- 26,eq,4650 <memset+0xc>
4a28: 3a 20 4c 6f li r17,19567
4a2c: 63 61 74 69 ori r1,r27,29801
4a30: 6e 67 20 27 xoris r7,r19,8231
4a34: 25 73 27 0a dozi r11,r19,9994
4a38: 00 43 42 46 .long 0x434246
4a3c: 53 3a 20 46 rlwimi r26,r25,4,1,3
4a40: 6f 75 6e 64 xoris r21,r27,28260
4a44: 20 40 20 6f subfic r2,r0,8303
4a48: 66 66 73 65 oris r6,r19,29541
4a4c: 74 20 25 7a andis. r0,r1,9594
4a50: 78 20 73 69 rldic. r0,r1,14,45
4a54: 7a 65 20 25 rldicr. r5,r19,4,32
4a58: 7a 78 0a 00 rldicl r24,r19,1,8
4a5c: 43 42 46 53 bcla- 26,eq,4650 <memset+0xc>
4a60: 3a 20 27 25 li r17,10021
4a64: 73 27 20 6e andi. r7,r25,8302
4a68: 6f 74 20 66 xoris r20,r27,8294
4a6c: 6f 75 6e 64 xoris r21,r27,28260
4a70: 2e 0a 00 00 cmpwi cr4,r10,0
4a74: 00 00 00 00 .long 0x0
0000000000004a78 <mem_rdev_ro_ops>:
4a78: 00 00 00 00 00 00 29 9c 00 00 00 00 00 00 29 b4 ......).......).
4a78: R_PPC64_ADDR64 .text+0x299c
4a80: R_PPC64_ADDR64 .text+0x29b4
4a88: 00 00 00 00 00 00 29 c8 00 00 00 00 00 00 00 00 ......).........
4a88: R_PPC64_ADDR64 .text+0x29c8
...
4aa0: 0a 0a 63 6f 72 65 62 6f 6f 74 2d 25 73 25 73 20 ..coreboot-%s%s
4ab0: 25 73 20 62 6f 6f 74 62 6c 6f 63 6b 20 73 74 61 %s bootblock sta
4ac0: 72 74 69 6e 67 20 28 6c 6f 67 20 6c 65 76 65 6c rting (log level
4ad0: 3a 20 25 69 29 2e 2e 2e 0a 00 42 53 3a 20 62 6f : %i).....BS: bo
4ae0: 6f 74 62 6c 6f 63 6b 20 74 69 6d 65 73 20 28 65 otblock times (e
4af0: 78 65 63 20 2f 20 63 6f 6e 73 6f 6c 65 29 3a 20 xec / console):
4b00: 74 6f 74 61 6c 20 28 75 6e 6b 6e 6f 77 6e 29 20 total (unknown)
4b10: 2f 20 25 6c 64 20 6d 73 0a 00 30 31 32 33 34 35 / %ld ms..012345
4b20: 36 37 38 39 61 62 63 64 65 66 00 30 31 32 33 34 6789abcdef.01234
4b30: 35 36 37 38 39 41 42 43 44 45 46 00 3c 4e 55 4c 56789ABCDEF.<NUL
4b40: 4c 3e 00 43 4f 52 45 42 4f 4f 54 00 73 72 63 2f L>.COREBOOT.src/
4b50: 6c 69 62 2f 63 62 66 73 2e 63 00 41 53 53 45 52 lib/cbfs.c.ASSER
4b60: 54 49 4f 4e 20 45 52 52 4f 52 3a 20 66 69 6c 65 TION ERROR: file
4b70: 20 27 25 73 27 2c 20 6c 69 6e 65 20 25 64 0a 00 '%s', line %d..
4b80: 5f 5f 46 4d 41 50 5f 5f 00 4e 6f 20 46 4d 41 50 __FMAP__.No FMAP
4b90: 20 66 6f 75 6e 64 20 61 74 20 25 7a 78 20 6f 66 found at %zx of
4ba0: 66 73 65 74 2e 0a 00 46 4d 41 50 3a 20 61 72 65 fset...FMAP: are
4bb0: 61 20 25 73 20 66 6f 75 6e 64 20 40 20 25 78 20 a %s found @ %x
4bc0: 28 25 64 20 62 79 74 65 73 29 0a 00 46 4d 41 50 (%d bytes)..FMAP
4bd0: 3a 20 46 6f 75 6e 64 20 22 25 73 22 20 76 65 72 : Found "%s" ver
4be0: 73 69 6f 6e 20 25 64 2e 25 64 20 61 74 20 25 23 sion %d.%d at %#
4bf0: 78 2e 0a 00 46 4d 41 50 3a 20 62 61 73 65 20 3d x...FMAP: base =
4c00: 20 25 23 6c 6c 78 20 73 69 7a 65 20 3d 20 25 23 %#llx size = %#
4c10: 78 20 23 61 72 65 61 73 20 3d 20 25 64 0a 00 66 x #areas = %d..f
4c20: 61 6c 6c 62 61 63 6b 2f 72 6f 6d 73 74 61 67 65 allback/romstage
4c30: 00 43 6f 75 6c 64 6e 27 74 20 6c 6f 61 64 20 72 .Couldn't load r
4c40: 6f 6d 73 74 61 67 65 2e 0a 00 00 00 00 00 00 00 omstage.........
0000000000004c50 <coreboot_build>:
4c50: 54 75 65 20 4f 63 74 20 20 36 20 31 32 3a 32 36 Tue Oct 6 12:26
4c60: 3a 35 31 20 55 54 43 20 32 30 32 30 00 00 00 00 :51 UTC 2020....
0000000000004c70 <coreboot_extra_version>:
...
0000000000004c78 <coreboot_version>:
4c78: 34 2e 31 32 2d 33 31 34 39 2d 67 33 34 38 66 37 4.12-3149-g348f7
4c88: 61 37 66 36 62 00 00 00 a7f6b...
Disassembly of section .sfpr:
0000000000004c90 <_savegpr0_14>:
4c90: f9 c1 ff 70 std r14,-144(r1)
0000000000004c94 <_savegpr0_15>:
4c94: f9 e1 ff 78 std r15,-136(r1)
0000000000004c98 <_savegpr0_16>:
4c98: fa 01 ff 80 std r16,-128(r1)
0000000000004c9c <_savegpr0_17>:
4c9c: fa 21 ff 88 std r17,-120(r1)
0000000000004ca0 <_savegpr0_18>:
4ca0: fa 41 ff 90 std r18,-112(r1)
0000000000004ca4 <_savegpr0_19>:
4ca4: fa 61 ff 98 std r19,-104(r1)
0000000000004ca8 <_savegpr0_20>:
4ca8: fa 81 ff a0 std r20,-96(r1)
0000000000004cac <_savegpr0_21>:
4cac: fa a1 ff a8 std r21,-88(r1)
0000000000004cb0 <_savegpr0_22>:
4cb0: fa c1 ff b0 std r22,-80(r1)
0000000000004cb4 <_savegpr0_23>:
4cb4: fa e1 ff b8 std r23,-72(r1)
0000000000004cb8 <_savegpr0_24>:
4cb8: fb 01 ff c0 std r24,-64(r1)
0000000000004cbc <_savegpr0_25>:
4cbc: fb 21 ff c8 std r25,-56(r1)
0000000000004cc0 <_savegpr0_26>:
4cc0: fb 41 ff d0 std r26,-48(r1)
0000000000004cc4 <_savegpr0_27>:
4cc4: fb 61 ff d8 std r27,-40(r1)
0000000000004cc8 <_savegpr0_28>:
4cc8: fb 81 ff e0 std r28,-32(r1)
0000000000004ccc <_savegpr0_29>:
4ccc: fb a1 ff e8 std r29,-24(r1)
0000000000004cd0 <_savegpr0_30>:
4cd0: fb c1 ff f0 std r30,-16(r1)
0000000000004cd4 <_savegpr0_31>:
4cd4: fb e1 ff f8 std r31,-8(r1)
4cd8: f8 01 00 10 std r0,16(r1)
4cdc: 4e 80 00 20 blr
0000000000004ce0 <_restgpr0_14>:
4ce0: e9 c1 ff 70 ld r14,-144(r1)
0000000000004ce4 <_restgpr0_15>:
4ce4: e9 e1 ff 78 ld r15,-136(r1)
0000000000004ce8 <_restgpr0_16>:
4ce8: ea 01 ff 80 ld r16,-128(r1)
0000000000004cec <_restgpr0_17>:
4cec: ea 21 ff 88 ld r17,-120(r1)
0000000000004cf0 <_restgpr0_18>:
4cf0: ea 41 ff 90 ld r18,-112(r1)
0000000000004cf4 <_restgpr0_19>:
4cf4: ea 61 ff 98 ld r19,-104(r1)
0000000000004cf8 <_restgpr0_20>:
4cf8: ea 81 ff a0 ld r20,-96(r1)
0000000000004cfc <_restgpr0_21>:
4cfc: ea a1 ff a8 ld r21,-88(r1)
0000000000004d00 <_restgpr0_22>:
4d00: ea c1 ff b0 ld r22,-80(r1)
0000000000004d04 <_restgpr0_23>:
4d04: ea e1 ff b8 ld r23,-72(r1)
0000000000004d08 <_restgpr0_24>:
4d08: eb 01 ff c0 ld r24,-64(r1)
0000000000004d0c <_restgpr0_25>:
4d0c: eb 21 ff c8 ld r25,-56(r1)
0000000000004d10 <_restgpr0_26>:
4d10: eb 41 ff d0 ld r26,-48(r1)
0000000000004d14 <_restgpr0_27>:
4d14: eb 61 ff d8 ld r27,-40(r1)
0000000000004d18 <_restgpr0_28>:
4d18: eb 81 ff e0 ld r28,-32(r1)
0000000000004d1c <_restgpr0_29>:
4d1c: e8 01 00 10 ld r0,16(r1)
4d20: eb a1 ff e8 ld r29,-24(r1)
4d24: 7c 08 03 a6 mtlr r0
4d28: eb c1 ff f0 ld r30,-16(r1)
4d2c: eb e1 ff f8 ld r31,-8(r1)
4d30: 4e 80 00 20 blr
0000000000004d34 <_restgpr0_30>:
4d34: eb c1 ff f0 ld r30,-16(r1)
0000000000004d38 <_restgpr0_31>:
4d38: e8 01 00 10 ld r0,16(r1)
4d3c: eb e1 ff f8 ld r31,-8(r1)
4d40: 7c 08 03 a6 mtlr r0
4d44: 4e 80 00 20 blr
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment