Skip to content

Instantly share code, notes, and snippets.

@androm3da

androm3da/disassembly diff

Created October 3, 2016 16:12
Show Gist options
  • Save androm3da/88d0a298ae46eeea887e89cf5b10d28b to your computer and use it in GitHub Desktop.
Save androm3da/88d0a298ae46eeea887e89cf5b10d28b to your computer and use it in GitHub Desktop.
Download ZIP
Raw
disassembly diff
# ABRIDGED EXCERPT
splay: file format elf64-x86-64 | splay_no_landing: file format elf64-x86-64
Disassembly of section .init: Disassembly of section .init:
0000000000007220 <_init>: 0000000000007220 <_init>:
7220: 48 83 ec 08 sub $0x8,%rsp 7220: 48 83 ec 08 sub $0x8,%rsp
7224: e8 13 05 00 00 callq 773c <call_gmon_start> 7224: e8 13 05 00 00 callq 773c <call_gmon_start>
7229: e8 b2 05 00 00 callq 77e0 <frame_dummy> 7229: e8 b2 05 00 00 callq 77e0 <frame_dummy>
722e: e8 cd 00 04 00 callq 47300 <__do_global_ctors_aux> | 722e: e8 cd ff 03 00 callq 47200 <__do_global_ctors_aux>
7233: 48 83 c4 08 add $0x8,%rsp 7233: 48 83 c4 08 add $0x8,%rsp
7237: c3 retq 7237: c3 retq
Disassembly of section .plt: Disassembly of section .plt:
0000000000007240 <pthread_getattr_np@plt-0x10>: 0000000000007240 <pthread_getattr_np@plt-0x10>:
7240: ff 35 aa 2d 25 00 pushq 0x252daa(%rip) # 259ff0 7240: ff 35 aa 2d 25 00 pushq 0x252daa(%rip) # 259ff0
7246: ff 25 ac 2d 25 00 jmpq *0x252dac(%rip) # 259ff 7246: ff 25 ac 2d 25 00 jmpq *0x252dac(%rip) # 259ff
724c: 0f 1f 40 00 nopl 0x0(%rax) 724c: 0f 1f 40 00 nopl 0x0(%rax)
0000000000007250 <pthread_getattr_np@plt>: 0000000000007250 <pthread_getattr_np@plt>:
7250: ff 25 aa 2d 25 00 jmpq *0x252daa(%rip) # 25a00 7250: ff 25 aa 2d 25 00 jmpq *0x252daa(%rip) # 25a00
7256: 68 00 00 00 00 pushq $0x0 7256: 68 00 00 00 00 pushq $0x0
725b: e9 e0 ff ff ff jmpq 7240 <_init+0x20> 725b: e9 e0 ff ff ff jmpq 7240 <_init+0x20>
0000000000007260 <pthread_getspecific@plt>: 0000000000007260 <pthread_getspecific@plt>:
7260: ff 25 a2 2d 25 00 jmpq *0x252da2(%rip) # 25a00 7260: ff 25 a2 2d 25 00 jmpq *0x252da2(%rip) # 25a00
7266: 68 01 00 00 00 pushq $0x1 7266: 68 01 00 00 00 pushq $0x1
726b: e9 d0 ff ff ff jmpq 7240 <_init+0x20> 726b: e9 d0 ff ff ff jmpq 7240 <_init+0x20>
0000000000007270 <pthread_cond_destroy@plt>: 0000000000007270 <pthread_cond_destroy@plt>:
7270: ff 25 9a 2d 25 00 jmpq *0x252d9a(%rip) # 25a01 7270: ff 25 9a 2d 25 00 jmpq *0x252d9a(%rip) # 25a01
7276: 68 02 00 00 00 pushq $0x2 7276: 68 02 00 00 00 pushq $0x2
727b: e9 c0 ff ff ff jmpq 7240 <_init+0x20> 727b: e9 c0 ff ff ff jmpq 7240 <_init+0x20>
0000000000007280 <_Unwind_GetRegionStart@plt>: 0000000000007280 <_Unwind_GetRegionStart@plt>:
7280: ff 25 92 2d 25 00 jmpq *0x252d92(%rip) # 25a01 7280: ff 25 92 2d 25 00 jmpq *0x252d92(%rip) # 25a01
7286: 68 03 00 00 00 pushq $0x3 7286: 68 03 00 00 00 pushq $0x3
728b: e9 b0 ff ff ff jmpq 7240 <_init+0x20> 728b: e9 b0 ff ff ff jmpq 7240 <_init+0x20>
0000000000007290 <memset@plt>: 0000000000007290 <memset@plt>:
7290: ff 25 8a 2d 25 00 jmpq *0x252d8a(%rip) # 25a02 7290: ff 25 8a 2d 25 00 jmpq *0x252d8a(%rip) # 25a02
7296: 68 04 00 00 00 pushq $0x4 7296: 68 04 00 00 00 pushq $0x4
729b: e9 a0 ff ff ff jmpq 7240 <_init+0x20> 729b: e9 a0 ff ff ff jmpq 7240 <_init+0x20>
00000000000072a0 <snprintf@plt>: 00000000000072a0 <snprintf@plt>:
72a0: ff 25 82 2d 25 00 jmpq *0x252d82(%rip) # 25a02 72a0: ff 25 82 2d 25 00 jmpq *0x252d82(%rip) # 25a02
72a6: 68 05 00 00 00 pushq $0x5 72a6: 68 05 00 00 00 pushq $0x5
72ab: e9 90 ff ff ff jmpq 7240 <_init+0x20> 72ab: e9 90 ff ff ff jmpq 7240 <_init+0x20>
00000000000072b0 <_Unwind_SetGR@plt>: 00000000000072b0 <_Unwind_SetGR@plt>:
72b0: ff 25 7a 2d 25 00 jmpq *0x252d7a(%rip) # 25a03 72b0: ff 25 7a 2d 25 00 jmpq *0x252d7a(%rip) # 25a03
72b6: 68 06 00 00 00 pushq $0x6 72b6: 68 06 00 00 00 pushq $0x6
72bb: e9 80 ff ff ff jmpq 7240 <_init+0x20> 72bb: e9 80 ff ff ff jmpq 7240 <_init+0x20>
00000000000072c0 <close@plt>: 00000000000072c0 <close@plt>:
72c0: ff 25 72 2d 25 00 jmpq *0x252d72(%rip) # 25a03 72c0: ff 25 72 2d 25 00 jmpq *0x252d72(%rip) # 25a03
72c6: 68 07 00 00 00 pushq $0x7 72c6: 68 07 00 00 00 pushq $0x7
72cb: e9 70 ff ff ff jmpq 7240 <_init+0x20> 72cb: e9 70 ff ff ff jmpq 7240 <_init+0x20>
00000000000072d0 <_Unwind_GetDataRelBase@plt>: 00000000000072d0 <_Unwind_GetDataRelBase@plt>:
72d0: ff 25 6a 2d 25 00 jmpq *0x252d6a(%rip) # 25a04 72d0: ff 25 6a 2d 25 00 jmpq *0x252d6a(%rip) # 25a04
72d6: 68 08 00 00 00 pushq $0x8 72d6: 68 08 00 00 00 pushq $0x8
72db: e9 60 ff ff ff jmpq 7240 <_init+0x20> 72db: e9 60 ff ff ff jmpq 7240 <_init+0x20>
00000000000072e0 <abort@plt>: 00000000000072e0 <abort@plt>:
72e0: ff 25 62 2d 25 00 jmpq *0x252d62(%rip) # 25a04 72e0: ff 25 62 2d 25 00 jmpq *0x252d62(%rip) # 25a04
72e6: 68 09 00 00 00 pushq $0x9 72e6: 68 09 00 00 00 pushq $0x9
72eb: e9 50 ff ff ff jmpq 7240 <_init+0x20> 72eb: e9 50 ff ff ff jmpq 7240 <_init+0x20>
00000000000072f0 <pthread_setspecific@plt>: 00000000000072f0 <pthread_setspecific@plt>:
72f0: ff 25 5a 2d 25 00 jmpq *0x252d5a(%rip) # 25a05 72f0: ff 25 5a 2d 25 00 jmpq *0x252d5a(%rip) # 25a05
72f6: 68 0a 00 00 00 pushq $0xa 72f6: 68 0a 00 00 00 pushq $0xa
72fb: e9 40 ff ff ff jmpq 7240 <_init+0x20> 72fb: e9 40 ff ff ff jmpq 7240 <_init+0x20>
0000000000007300 <memchr@plt>: 0000000000007300 <memchr@plt>:
7300: ff 25 52 2d 25 00 jmpq *0x252d52(%rip) # 25a05 7300: ff 25 52 2d 25 00 jmpq *0x252d52(%rip) # 25a05
7306: 68 0b 00 00 00 pushq $0xb 7306: 68 0b 00 00 00 pushq $0xb
730b: e9 30 ff ff ff jmpq 7240 <_init+0x20> 730b: e9 30 ff ff ff jmpq 7240 <_init+0x20>
0000000000007310 <pthread_cond_signal@plt>: 0000000000007310 <pthread_cond_signal@plt>:
7310: ff 25 4a 2d 25 00 jmpq *0x252d4a(%rip) # 25a06 7310: ff 25 4a 2d 25 00 jmpq *0x252d4a(%rip) # 25a06
7316: 68 0c 00 00 00 pushq $0xc 7316: 68 0c 00 00 00 pushq $0xc
731b: e9 20 ff ff ff jmpq 7240 <_init+0x20> 731b: e9 20 ff ff ff jmpq 7240 <_init+0x20>
0000000000007320 <pthread_mutexattr_destroy@plt>: 0000000000007320 <pthread_mutexattr_destroy@plt>:
7320: ff 25 42 2d 25 00 jmpq *0x252d42(%rip) # 25a06 7320: ff 25 42 2d 25 00 jmpq *0x252d42(%rip) # 25a06
7326: 68 0d 00 00 00 pushq $0xd 7326: 68 0d 00 00 00 pushq $0xd
732b: e9 10 ff ff ff jmpq 7240 <_init+0x20> 732b: e9 10 ff ff ff jmpq 7240 <_init+0x20>
0000000000007330 <__register_atfork@plt>: 0000000000007330 <__register_atfork@plt>:
7330: ff 25 3a 2d 25 00 jmpq *0x252d3a(%rip) # 25a07 7330: ff 25 3a 2d 25 00 jmpq *0x252d3a(%rip) # 25a07
7336: 68 0e 00 00 00 pushq $0xe 7336: 68 0e 00 00 00 pushq $0xe
733b: e9 00 ff ff ff jmpq 7240 <_init+0x20> 733b: e9 00 ff ff ff jmpq 7240 <_init+0x20>
0000000000007340 <__rawmemchr@plt>: 0000000000007340 <__rawmemchr@plt>:
7340: ff 25 32 2d 25 00 jmpq *0x252d32(%rip) # 25a07 7340: ff 25 32 2d 25 00 jmpq *0x252d32(%rip) # 25a07
7346: 68 0f 00 00 00 pushq $0xf 7346: 68 0f 00 00 00 pushq $0xf
734b: e9 f0 fe ff ff jmpq 7240 <_init+0x20> 734b: e9 f0 fe ff ff jmpq 7240 <_init+0x20>
0000000000007350 <strncmp@plt>: 0000000000007350 <strncmp@plt>:
7350: ff 25 2a 2d 25 00 jmpq *0x252d2a(%rip) # 25a08 7350: ff 25 2a 2d 25 00 jmpq *0x252d2a(%rip) # 25a08
7356: 68 10 00 00 00 pushq $0x10 7356: 68 10 00 00 00 pushq $0x10
735b: e9 e0 fe ff ff jmpq 7240 <_init+0x20> 735b: e9 e0 fe ff ff jmpq 7240 <_init+0x20>
0000000000007360 <__libc_start_main@plt>: 0000000000007360 <__libc_start_main@plt>:
7360: ff 25 22 2d 25 00 jmpq *0x252d22(%rip) # 25a08 7360: ff 25 22 2d 25 00 jmpq *0x252d22(%rip) # 25a08
7366: 68 11 00 00 00 pushq $0x11 7366: 68 11 00 00 00 pushq $0x11
736b: e9 d0 fe ff ff jmpq 7240 <_init+0x20> 736b: e9 d0 fe ff ff jmpq 7240 <_init+0x20>
0000000000007370 <strerror_r@plt>: 0000000000007370 <strerror_r@plt>:
7370: ff 25 1a 2d 25 00 jmpq *0x252d1a(%rip) # 25a09 7370: ff 25 1a 2d 25 00 jmpq *0x252d1a(%rip) # 25a09
7376: 68 12 00 00 00 pushq $0x12 7376: 68 12 00 00 00 pushq $0x12
737b: e9 c0 fe ff ff jmpq 7240 <_init+0x20> 737b: e9 c0 fe ff ff jmpq 7240 <_init+0x20>
0000000000007380 <_Unwind_DeleteException@plt>: 0000000000007380 <_Unwind_DeleteException@plt>:
7380: ff 25 12 2d 25 00 jmpq *0x252d12(%rip) # 25a09 7380: ff 25 12 2d 25 00 jmpq *0x252d12(%rip) # 25a09
7386: 68 13 00 00 00 pushq $0x13 7386: 68 13 00 00 00 pushq $0x13
738b: e9 b0 fe ff ff jmpq 7240 <_init+0x20> 738b: e9 b0 fe ff ff jmpq 7240 <_init+0x20>
0000000000007390 <__cxa_atexit@plt>: 0000000000007390 <__cxa_atexit@plt>:
7390: ff 25 0a 2d 25 00 jmpq *0x252d0a(%rip) # 25a0a 7390: ff 25 0a 2d 25 00 jmpq *0x252d0a(%rip) # 25a0a
7396: 68 14 00 00 00 pushq $0x14 7396: 68 14 00 00 00 pushq $0x14
739b: e9 a0 fe ff ff jmpq 7240 <_init+0x20> 739b: e9 a0 fe ff ff jmpq 7240 <_init+0x20>
00000000000073a0 <sbrk@plt>: 00000000000073a0 <sbrk@plt>:
73a0: ff 25 02 2d 25 00 jmpq *0x252d02(%rip) # 25a0a 73a0: ff 25 02 2d 25 00 jmpq *0x252d02(%rip) # 25a0a
73a6: 68 15 00 00 00 pushq $0x15 73a6: 68 15 00 00 00 pushq $0x15
73ab: e9 90 fe ff ff jmpq 7240 <_init+0x20> 73ab: e9 90 fe ff ff jmpq 7240 <_init+0x20>
00000000000073b0 <sysconf@plt>: 00000000000073b0 <sysconf@plt>:
73b0: ff 25 fa 2c 25 00 jmpq *0x252cfa(%rip) # 25a0b 73b0: ff 25 fa 2c 25 00 jmpq *0x252cfa(%rip) # 25a0b
73b6: 68 16 00 00 00 pushq $0x16 73b6: 68 16 00 00 00 pushq $0x16
73bb: e9 80 fe ff ff jmpq 7240 <_init+0x20> 73bb: e9 80 fe ff ff jmpq 7240 <_init+0x20>
00000000000073c0 <pthread_mutex_init@plt>: 00000000000073c0 <pthread_mutex_init@plt>:
73c0: ff 25 f2 2c 25 00 jmpq *0x252cf2(%rip) # 25a0b 73c0: ff 25 f2 2c 25 00 jmpq *0x252cf2(%rip) # 25a0b
73c6: 68 17 00 00 00 pushq $0x17 73c6: 68 17 00 00 00 pushq $0x17
73cb: e9 70 fe ff ff jmpq 7240 <_init+0x20> 73cb: e9 70 fe ff ff jmpq 7240 <_init+0x20>
00000000000073d0 <__cxa_thread_atexit_impl@plt>: 00000000000073d0 <__cxa_thread_atexit_impl@plt>:
73d0: ff 25 ea 2c 25 00 jmpq *0x252cea(%rip) # 25a0c 73d0: ff 25 ea 2c 25 00 jmpq *0x252cea(%rip) # 25a0c
73d6: 68 18 00 00 00 pushq $0x18 73d6: 68 18 00 00 00 pushq $0x18
73db: e9 60 fe ff ff jmpq 7240 <_init+0x20> 73db: e9 60 fe ff ff jmpq 7240 <_init+0x20>
00000000000073e0 <pthread_attr_destroy@plt>: 00000000000073e0 <pthread_attr_destroy@plt>:
73e0: ff 25 e2 2c 25 00 jmpq *0x252ce2(%rip) # 25a0c 73e0: ff 25 e2 2c 25 00 jmpq *0x252ce2(%rip) # 25a0c
73e6: 68 19 00 00 00 pushq $0x19 73e6: 68 19 00 00 00 pushq $0x19
73eb: e9 50 fe ff ff jmpq 7240 <_init+0x20> 73eb: e9 50 fe ff ff jmpq 7240 <_init+0x20>
00000000000073f0 <strnlen@plt>: 00000000000073f0 <strnlen@plt>:
73f0: ff 25 da 2c 25 00 jmpq *0x252cda(%rip) # 25a0d 73f0: ff 25 da 2c 25 00 jmpq *0x252cda(%rip) # 25a0d
73f6: 68 1a 00 00 00 pushq $0x1a 73f6: 68 1a 00 00 00 pushq $0x1a
73fb: e9 40 fe ff ff jmpq 7240 <_init+0x20> 73fb: e9 40 fe ff ff jmpq 7240 <_init+0x20>
0000000000007400 <_Unwind_GetLanguageSpecificData@plt>: 0000000000007400 <_Unwind_GetLanguageSpecificData@plt>:
7400: ff 25 d2 2c 25 00 jmpq *0x252cd2(%rip) # 25a0d 7400: ff 25 d2 2c 25 00 jmpq *0x252cd2(%rip) # 25a0d
7406: 68 1b 00 00 00 pushq $0x1b 7406: 68 1b 00 00 00 pushq $0x1b
740b: e9 30 fe ff ff jmpq 7240 <_init+0x20> 740b: e9 30 fe ff ff jmpq 7240 <_init+0x20>
0000000000007410 <strlen@plt>: 0000000000007410 <strlen@plt>:
7410: ff 25 ca 2c 25 00 jmpq *0x252cca(%rip) # 25a0e 7410: ff 25 ca 2c 25 00 jmpq *0x252cca(%rip) # 25a0e
7416: 68 1c 00 00 00 pushq $0x1c 7416: 68 1c 00 00 00 pushq $0x1c
741b: e9 20 fe ff ff jmpq 7240 <_init+0x20> 741b: e9 20 fe ff ff jmpq 7240 <_init+0x20>
0000000000007420 <_Unwind_RaiseException@plt>: 0000000000007420 <_Unwind_RaiseException@plt>:
7420: ff 25 c2 2c 25 00 jmpq *0x252cc2(%rip) # 25a0e 7420: ff 25 c2 2c 25 00 jmpq *0x252cc2(%rip) # 25a0e
7426: 68 1d 00 00 00 pushq $0x1d 7426: 68 1d 00 00 00 pushq $0x1d
742b: e9 10 fe ff ff jmpq 7240 <_init+0x20> 742b: e9 10 fe ff ff jmpq 7240 <_init+0x20>
0000000000007430 <__cxa_finalize@plt>: 0000000000007430 <__cxa_finalize@plt>:
7430: ff 25 ba 2c 25 00 jmpq *0x252cba(%rip) # 25a0f 7430: ff 25 ba 2c 25 00 jmpq *0x252cba(%rip) # 25a0f
7436: 68 1e 00 00 00 pushq $0x1e 7436: 68 1e 00 00 00 pushq $0x1e
743b: e9 00 fe ff ff jmpq 7240 <_init+0x20> 743b: e9 00 fe ff ff jmpq 7240 <_init+0x20>
0000000000007440 <pthread_key_delete@plt>: 0000000000007440 <pthread_key_delete@plt>:
7440: ff 25 b2 2c 25 00 jmpq *0x252cb2(%rip) # 25a0f 7440: ff 25 b2 2c 25 00 jmpq *0x252cb2(%rip) # 25a0f
7446: 68 1f 00 00 00 pushq $0x1f 7446: 68 1f 00 00 00 pushq $0x1f
744b: e9 f0 fd ff ff jmpq 7240 <_init+0x20> 744b: e9 f0 fd ff ff jmpq 7240 <_init+0x20>
0000000000007450 <bsearch@plt>: 0000000000007450 <bsearch@plt>:
7450: ff 25 aa 2c 25 00 jmpq *0x252caa(%rip) # 25a10 7450: ff 25 aa 2c 25 00 jmpq *0x252caa(%rip) # 25a10
7456: 68 20 00 00 00 pushq $0x20 7456: 68 20 00 00 00 pushq $0x20
745b: e9 e0 fd ff ff jmpq 7240 <_init+0x20> 745b: e9 e0 fd ff ff jmpq 7240 <_init+0x20>
0000000000007460 <__tls_get_addr@plt>: 0000000000007460 <__tls_get_addr@plt>:
7460: ff 25 a2 2c 25 00 jmpq *0x252ca2(%rip) # 25a10 7460: ff 25 a2 2c 25 00 jmpq *0x252ca2(%rip) # 25a10
7466: 68 21 00 00 00 pushq $0x21 7466: 68 21 00 00 00 pushq $0x21
746b: e9 d0 fd ff ff jmpq 7240 <_init+0x20> 746b: e9 d0 fd ff ff jmpq 7240 <_init+0x20>
0000000000007470 <_Unwind_FindEnclosingFunction@plt>: 0000000000007470 <_Unwind_FindEnclosingFunction@plt>:
7470: ff 25 9a 2c 25 00 jmpq *0x252c9a(%rip) # 25a11 7470: ff 25 9a 2c 25 00 jmpq *0x252c9a(%rip) # 25a11
7476: 68 22 00 00 00 pushq $0x22 7476: 68 22 00 00 00 pushq $0x22
747b: e9 c0 fd ff ff jmpq 7240 <_init+0x20> 747b: e9 c0 fd ff ff jmpq 7240 <_init+0x20>
0000000000007480 <syscall@plt>: 0000000000007480 <syscall@plt>:
7480: ff 25 92 2c 25 00 jmpq *0x252c92(%rip) # 25a11 7480: ff 25 92 2c 25 00 jmpq *0x252c92(%rip) # 25a11
7486: 68 23 00 00 00 pushq $0x23 7486: 68 23 00 00 00 pushq $0x23
748b: e9 b0 fd ff ff jmpq 7240 <_init+0x20> 748b: e9 b0 fd ff ff jmpq 7240 <_init+0x20>
0000000000007490 <getpagesize@plt>: 0000000000007490 <getpagesize@plt>:
7490: ff 25 8a 2c 25 00 jmpq *0x252c8a(%rip) # 25a12 7490: ff 25 8a 2c 25 00 jmpq *0x252c8a(%rip) # 25a12
7496: 68 24 00 00 00 pushq $0x24 7496: 68 24 00 00 00 pushq $0x24
749b: e9 a0 fd ff ff jmpq 7240 <_init+0x20> 749b: e9 a0 fd ff ff jmpq 7240 <_init+0x20>
00000000000074a0 <_Unwind_Backtrace@plt>: 00000000000074a0 <_Unwind_Backtrace@plt>:
74a0: ff 25 82 2c 25 00 jmpq *0x252c82(%rip) # 25a12 74a0: ff 25 82 2c 25 00 jmpq *0x252c82(%rip) # 25a12
74a6: 68 25 00 00 00 pushq $0x25 74a6: 68 25 00 00 00 pushq $0x25
74ab: e9 90 fd ff ff jmpq 7240 <_init+0x20> 74ab: e9 90 fd ff ff jmpq 7240 <_init+0x20>
00000000000074b0 <pthread_attr_getstack@plt>: 00000000000074b0 <pthread_attr_getstack@plt>:
74b0: ff 25 7a 2c 25 00 jmpq *0x252c7a(%rip) # 25a13 74b0: ff 25 7a 2c 25 00 jmpq *0x252c7a(%rip) # 25a13
74b6: 68 26 00 00 00 pushq $0x26 74b6: 68 26 00 00 00 pushq $0x26
74bb: e9 80 fd ff ff jmpq 7240 <_init+0x20> 74bb: e9 80 fd ff ff jmpq 7240 <_init+0x20>
00000000000074c0 <pthread_self@plt>: 00000000000074c0 <pthread_self@plt>:
74c0: ff 25 72 2c 25 00 jmpq *0x252c72(%rip) # 25a13 74c0: ff 25 72 2c 25 00 jmpq *0x252c72(%rip) # 25a13
74c6: 68 27 00 00 00 pushq $0x27 74c6: 68 27 00 00 00 pushq $0x27
74cb: e9 70 fd ff ff jmpq 7240 <_init+0x20> 74cb: e9 70 fd ff ff jmpq 7240 <_init+0x20>
00000000000074d0 <sigaction@plt>: 00000000000074d0 <sigaction@plt>:
74d0: ff 25 6a 2c 25 00 jmpq *0x252c6a(%rip) # 25a14 74d0: ff 25 6a 2c 25 00 jmpq *0x252c6a(%rip) # 25a14
74d6: 68 28 00 00 00 pushq $0x28 74d6: 68 28 00 00 00 pushq $0x28
74db: e9 60 fd ff ff jmpq 7240 <_init+0x20> 74db: e9 60 fd ff ff jmpq 7240 <_init+0x20>
00000000000074e0 <strtol@plt>: 00000000000074e0 <strtol@plt>:
74e0: ff 25 62 2c 25 00 jmpq *0x252c62(%rip) # 25a14 74e0: ff 25 62 2c 25 00 jmpq *0x252c62(%rip) # 25a14
74e6: 68 29 00 00 00 pushq $0x29 74e6: 68 29 00 00 00 pushq $0x29
74eb: e9 50 fd ff ff jmpq 7240 <_init+0x20> 74eb: e9 50 fd ff ff jmpq 7240 <_init+0x20>
00000000000074f0 <readlink@plt>: 00000000000074f0 <readlink@plt>:
74f0: ff 25 5a 2c 25 00 jmpq *0x252c5a(%rip) # 25a15 74f0: ff 25 5a 2c 25 00 jmpq *0x252c5a(%rip) # 25a15
74f6: 68 2a 00 00 00 pushq $0x2a 74f6: 68 2a 00 00 00 pushq $0x2a
74fb: e9 40 fd ff ff jmpq 7240 <_init+0x20> 74fb: e9 40 fd ff ff jmpq 7240 <_init+0x20>
0000000000007500 <signal@plt>: 0000000000007500 <signal@plt>:
7500: ff 25 52 2c 25 00 jmpq *0x252c52(%rip) # 25a15 7500: ff 25 52 2c 25 00 jmpq *0x252c52(%rip) # 25a15
7506: 68 2b 00 00 00 pushq $0x2b 7506: 68 2b 00 00 00 pushq $0x2b
750b: e9 30 fd ff ff jmpq 7240 <_init+0x20> 750b: e9 30 fd ff ff jmpq 7240 <_init+0x20>
0000000000007510 <memmove@plt>: 0000000000007510 <memmove@plt>:
7510: ff 25 4a 2c 25 00 jmpq *0x252c4a(%rip) # 25a16 7510: ff 25 4a 2c 25 00 jmpq *0x252c4a(%rip) # 25a16
7516: 68 2c 00 00 00 pushq $0x2c 7516: 68 2c 00 00 00 pushq $0x2c
751b: e9 20 fd ff ff jmpq 7240 <_init+0x20> 751b: e9 20 fd ff ff jmpq 7240 <_init+0x20>
0000000000007520 <strchr@plt>: 0000000000007520 <strchr@plt>:
7520: ff 25 42 2c 25 00 jmpq *0x252c42(%rip) # 25a16 7520: ff 25 42 2c 25 00 jmpq *0x252c42(%rip) # 25a16
7526: 68 2d 00 00 00 pushq $0x2d 7526: 68 2d 00 00 00 pushq $0x2d
752b: e9 10 fd ff ff jmpq 7240 <_init+0x20> 752b: e9 10 fd ff ff jmpq 7240 <_init+0x20>
0000000000007530 <getenv@plt>: 0000000000007530 <getenv@plt>:
7530: ff 25 3a 2c 25 00 jmpq *0x252c3a(%rip) # 25a17 7530: ff 25 3a 2c 25 00 jmpq *0x252c3a(%rip) # 25a17
7536: 68 2e 00 00 00 pushq $0x2e 7536: 68 2e 00 00 00 pushq $0x2e
753b: e9 00 fd ff ff jmpq 7240 <_init+0x20> 753b: e9 00 fd ff ff jmpq 7240 <_init+0x20>
0000000000007540 <_Unwind_GetIPInfo@plt>: 0000000000007540 <_Unwind_GetIPInfo@plt>:
7540: ff 25 32 2c 25 00 jmpq *0x252c32(%rip) # 25a17 7540: ff 25 32 2c 25 00 jmpq *0x252c32(%rip) # 25a17
7546: 68 2f 00 00 00 pushq $0x2f 7546: 68 2f 00 00 00 pushq $0x2f
754b: e9 f0 fc ff ff jmpq 7240 <_init+0x20> 754b: e9 f0 fc ff ff jmpq 7240 <_init+0x20>
0000000000007550 <dl_iterate_phdr@plt>: 0000000000007550 <dl_iterate_phdr@plt>:
7550: ff 25 2a 2c 25 00 jmpq *0x252c2a(%rip) # 25a18 7550: ff 25 2a 2c 25 00 jmpq *0x252c2a(%rip) # 25a18
7556: 68 30 00 00 00 pushq $0x30 7556: 68 30 00 00 00 pushq $0x30
755b: e9 e0 fc ff ff jmpq 7240 <_init+0x20> 755b: e9 e0 fc ff ff jmpq 7240 <_init+0x20>
0000000000007560 <__errno_location@plt>: 0000000000007560 <__errno_location@plt>:
7560: ff 25 22 2c 25 00 jmpq *0x252c22(%rip) # 25a18 7560: ff 25 22 2c 25 00 jmpq *0x252c22(%rip) # 25a18
7566: 68 31 00 00 00 pushq $0x31 7566: 68 31 00 00 00 pushq $0x31
756b: e9 d0 fc ff ff jmpq 7240 <_init+0x20> 756b: e9 d0 fc ff ff jmpq 7240 <_init+0x20>
0000000000007570 <madvise@plt>: 0000000000007570 <madvise@plt>:
7570: ff 25 1a 2c 25 00 jmpq *0x252c1a(%rip) # 25a19 7570: ff 25 1a 2c 25 00 jmpq *0x252c1a(%rip) # 25a19
7576: 68 32 00 00 00 pushq $0x32 7576: 68 32 00 00 00 pushq $0x32
757b: e9 c0 fc ff ff jmpq 7240 <_init+0x20> 757b: e9 c0 fc ff ff jmpq 7240 <_init+0x20>
0000000000007580 <pthread_mutexattr_settype@plt>: 0000000000007580 <pthread_mutexattr_settype@plt>:
7580: ff 25 12 2c 25 00 jmpq *0x252c12(%rip) # 25a19 7580: ff 25 12 2c 25 00 jmpq *0x252c12(%rip) # 25a19
7586: 68 33 00 00 00 pushq $0x33 7586: 68 33 00 00 00 pushq $0x33
758b: e9 b0 fc ff ff jmpq 7240 <_init+0x20> 758b: e9 b0 fc ff ff jmpq 7240 <_init+0x20>
0000000000007590 <strcmp@plt>: 0000000000007590 <strcmp@plt>:
7590: ff 25 0a 2c 25 00 jmpq *0x252c0a(%rip) # 25a1a 7590: ff 25 0a 2c 25 00 jmpq *0x252c0a(%rip) # 25a1a
7596: 68 34 00 00 00 pushq $0x34 7596: 68 34 00 00 00 pushq $0x34
759b: e9 a0 fc ff ff jmpq 7240 <_init+0x20> 759b: e9 a0 fc ff ff jmpq 7240 <_init+0x20>
00000000000075a0 <pthread_rwlock_rdlock@plt>: 00000000000075a0 <pthread_rwlock_rdlock@plt>:
75a0: ff 25 02 2c 25 00 jmpq *0x252c02(%rip) # 25a1a 75a0: ff 25 02 2c 25 00 jmpq *0x252c02(%rip) # 25a1a
75a6: 68 35 00 00 00 pushq $0x35 75a6: 68 35 00 00 00 pushq $0x35
75ab: e9 90 fc ff ff jmpq 7240 <_init+0x20> 75ab: e9 90 fc ff ff jmpq 7240 <_init+0x20>
00000000000075b0 <pthread_cond_wait@plt>: 00000000000075b0 <pthread_cond_wait@plt>:
75b0: ff 25 fa 2b 25 00 jmpq *0x252bfa(%rip) # 25a1b 75b0: ff 25 fa 2b 25 00 jmpq *0x252bfa(%rip) # 25a1b
75b6: 68 36 00 00 00 pushq $0x36 75b6: 68 36 00 00 00 pushq $0x36
75bb: e9 80 fc ff ff jmpq 7240 <_init+0x20> 75bb: e9 80 fc ff ff jmpq 7240 <_init+0x20>
00000000000075c0 <memcmp@plt>: 00000000000075c0 <memcmp@plt>:
75c0: ff 25 f2 2b 25 00 jmpq *0x252bf2(%rip) # 25a1b 75c0: ff 25 f2 2b 25 00 jmpq *0x252bf2(%rip) # 25a1b
75c6: 68 37 00 00 00 pushq $0x37 75c6: 68 37 00 00 00 pushq $0x37
75cb: e9 70 fc ff ff jmpq 7240 <_init+0x20> 75cb: e9 70 fc ff ff jmpq 7240 <_init+0x20>
00000000000075d0 <munmap@plt>: 00000000000075d0 <munmap@plt>:
75d0: ff 25 ea 2b 25 00 jmpq *0x252bea(%rip) # 25a1c 75d0: ff 25 ea 2b 25 00 jmpq *0x252bea(%rip) # 25a1c
75d6: 68 38 00 00 00 pushq $0x38 75d6: 68 38 00 00 00 pushq $0x38
75db: e9 60 fc ff ff jmpq 7240 <_init+0x20> 75db: e9 60 fc ff ff jmpq 7240 <_init+0x20>
00000000000075e0 <__xpg_strerror_r@plt>: 00000000000075e0 <__xpg_strerror_r@plt>:
75e0: ff 25 e2 2b 25 00 jmpq *0x252be2(%rip) # 25a1c 75e0: ff 25 e2 2b 25 00 jmpq *0x252be2(%rip) # 25a1c
75e6: 68 39 00 00 00 pushq $0x39 75e6: 68 39 00 00 00 pushq $0x39
75eb: e9 50 fc ff ff jmpq 7240 <_init+0x20> 75eb: e9 50 fc ff ff jmpq 7240 <_init+0x20>
00000000000075f0 <strncpy@plt>: 00000000000075f0 <strncpy@plt>:
75f0: ff 25 da 2b 25 00 jmpq *0x252bda(%rip) # 25a1d 75f0: ff 25 da 2b 25 00 jmpq *0x252bda(%rip) # 25a1d
75f6: 68 3a 00 00 00 pushq $0x3a 75f6: 68 3a 00 00 00 pushq $0x3a
75fb: e9 40 fc ff ff jmpq 7240 <_init+0x20> 75fb: e9 40 fc ff ff jmpq 7240 <_init+0x20>
0000000000007600 <pthread_attr_init@plt>: 0000000000007600 <pthread_attr_init@plt>:
7600: ff 25 d2 2b 25 00 jmpq *0x252bd2(%rip) # 25a1d 7600: ff 25 d2 2b 25 00 jmpq *0x252bd2(%rip) # 25a1d
7606: 68 3b 00 00 00 pushq $0x3b 7606: 68 3b 00 00 00 pushq $0x3b
760b: e9 30 fc ff ff jmpq 7240 <_init+0x20> 760b: e9 30 fc ff ff jmpq 7240 <_init+0x20>
0000000000007610 <_Unwind_GetTextRelBase@plt>: 0000000000007610 <_Unwind_GetTextRelBase@plt>:
7610: ff 25 ca 2b 25 00 jmpq *0x252bca(%rip) # 25a1e 7610: ff 25 ca 2b 25 00 jmpq *0x252bca(%rip) # 25a1e
7616: 68 3c 00 00 00 pushq $0x3c 7616: 68 3c 00 00 00 pushq $0x3c
761b: e9 20 fc ff ff jmpq 7240 <_init+0x20> 761b: e9 20 fc ff ff jmpq 7240 <_init+0x20>
0000000000007620 <pthread_rwlock_unlock@plt>: 0000000000007620 <pthread_rwlock_unlock@plt>:
7620: ff 25 c2 2b 25 00 jmpq *0x252bc2(%rip) # 25a1e 7620: ff 25 c2 2b 25 00 jmpq *0x252bc2(%rip) # 25a1e
7626: 68 3d 00 00 00 pushq $0x3d 7626: 68 3d 00 00 00 pushq $0x3d
762b: e9 10 fc ff ff jmpq 7240 <_init+0x20> 762b: e9 10 fc ff ff jmpq 7240 <_init+0x20>
0000000000007630 <pthread_mutex_lock@plt>: 0000000000007630 <pthread_mutex_lock@plt>:
7630: ff 25 ba 2b 25 00 jmpq *0x252bba(%rip) # 25a1f 7630: ff 25 ba 2b 25 00 jmpq *0x252bba(%rip) # 25a1f
7636: 68 3e 00 00 00 pushq $0x3e 7636: 68 3e 00 00 00 pushq $0x3e
763b: e9 00 fc ff ff jmpq 7240 <_init+0x20> 763b: e9 00 fc ff ff jmpq 7240 <_init+0x20>
0000000000007640 <pthread_mutexattr_init@plt>: 0000000000007640 <pthread_mutexattr_init@plt>:
7640: ff 25 b2 2b 25 00 jmpq *0x252bb2(%rip) # 25a1f 7640: ff 25 b2 2b 25 00 jmpq *0x252bb2(%rip) # 25a1f
7646: 68 3f 00 00 00 pushq $0x3f 7646: 68 3f 00 00 00 pushq $0x3f
764b: e9 f0 fb ff ff jmpq 7240 <_init+0x20> 764b: e9 f0 fb ff ff jmpq 7240 <_init+0x20>
0000000000007650 <pthread_key_create@plt>: 0000000000007650 <pthread_key_create@plt>:
7650: ff 25 aa 2b 25 00 jmpq *0x252baa(%rip) # 25a20 7650: ff 25 aa 2b 25 00 jmpq *0x252baa(%rip) # 25a20
7656: 68 40 00 00 00 pushq $0x40 7656: 68 40 00 00 00 pushq $0x40
765b: e9 e0 fb ff ff jmpq 7240 <_init+0x20> 765b: e9 e0 fb ff ff jmpq 7240 <_init+0x20>
0000000000007660 <pthread_mutex_destroy@plt>: 0000000000007660 <pthread_mutex_destroy@plt>:
7660: ff 25 a2 2b 25 00 jmpq *0x252ba2(%rip) # 25a20 7660: ff 25 a2 2b 25 00 jmpq *0x252ba2(%rip) # 25a20
7666: 68 41 00 00 00 pushq $0x41 7666: 68 41 00 00 00 pushq $0x41
766b: e9 d0 fb ff ff jmpq 7240 <_init+0x20> 766b: e9 d0 fb ff ff jmpq 7240 <_init+0x20>
0000000000007670 <write@plt>: 0000000000007670 <write@plt>:
7670: ff 25 9a 2b 25 00 jmpq *0x252b9a(%rip) # 25a21 7670: ff 25 9a 2b 25 00 jmpq *0x252b9a(%rip) # 25a21
7676: 68 42 00 00 00 pushq $0x42 7676: 68 42 00 00 00 pushq $0x42
767b: e9 c0 fb ff ff jmpq 7240 <_init+0x20> 767b: e9 c0 fb ff ff jmpq 7240 <_init+0x20>
0000000000007680 <_Unwind_Resume@plt>: 0000000000007680 <_Unwind_Resume@plt>:
7680: ff 25 92 2b 25 00 jmpq *0x252b92(%rip) # 25a21 7680: ff 25 92 2b 25 00 jmpq *0x252b92(%rip) # 25a21
7686: 68 43 00 00 00 pushq $0x43 7686: 68 43 00 00 00 pushq $0x43
768b: e9 b0 fb ff ff jmpq 7240 <_init+0x20> 768b: e9 b0 fb ff ff jmpq 7240 <_init+0x20>
0000000000007690 <clock_gettime@plt>: 0000000000007690 <clock_gettime@plt>:
7690: ff 25 8a 2b 25 00 jmpq *0x252b8a(%rip) # 25a22 7690: ff 25 8a 2b 25 00 jmpq *0x252b8a(%rip) # 25a22
7696: 68 44 00 00 00 pushq $0x44 7696: 68 44 00 00 00 pushq $0x44
769b: e9 a0 fb ff ff jmpq 7240 <_init+0x20> 769b: e9 a0 fb ff ff jmpq 7240 <_init+0x20>
00000000000076a0 <sigaltstack@plt>: 00000000000076a0 <sigaltstack@plt>:
76a0: ff 25 82 2b 25 00 jmpq *0x252b82(%rip) # 25a22 76a0: ff 25 82 2b 25 00 jmpq *0x252b82(%rip) # 25a22
76a6: 68 45 00 00 00 pushq $0x45 76a6: 68 45 00 00 00 pushq $0x45
76ab: e9 90 fb ff ff jmpq 7240 <_init+0x20> 76ab: e9 90 fb ff ff jmpq 7240 <_init+0x20>
00000000000076b0 <pthread_mutex_unlock@plt>: 00000000000076b0 <pthread_mutex_unlock@plt>:
76b0: ff 25 7a 2b 25 00 jmpq *0x252b7a(%rip) # 25a23 76b0: ff 25 7a 2b 25 00 jmpq *0x252b7a(%rip) # 25a23
76b6: 68 46 00 00 00 pushq $0x46 76b6: 68 46 00 00 00 pushq $0x46
76bb: e9 80 fb ff ff jmpq 7240 <_init+0x20> 76bb: e9 80 fb ff ff jmpq 7240 <_init+0x20>
00000000000076c0 <memcpy@plt>: 00000000000076c0 <memcpy@plt>:
76c0: ff 25 72 2b 25 00 jmpq *0x252b72(%rip) # 25a23 76c0: ff 25 72 2b 25 00 jmpq *0x252b72(%rip) # 25a23
76c6: 68 47 00 00 00 pushq $0x47 76c6: 68 47 00 00 00 pushq $0x47
76cb: e9 70 fb ff ff jmpq 7240 <_init+0x20> 76cb: e9 70 fb ff ff jmpq 7240 <_init+0x20>
00000000000076d0 <fcntl@plt>: 00000000000076d0 <fcntl@plt>:
76d0: ff 25 6a 2b 25 00 jmpq *0x252b6a(%rip) # 25a24 76d0: ff 25 6a 2b 25 00 jmpq *0x252b6a(%rip) # 25a24
76d6: 68 48 00 00 00 pushq $0x48 76d6: 68 48 00 00 00 pushq $0x48
76db: e9 60 fb ff ff jmpq 7240 <_init+0x20> 76db: e9 60 fb ff ff jmpq 7240 <_init+0x20>
00000000000076e0 <open@plt>: 00000000000076e0 <open@plt>:
76e0: ff 25 62 2b 25 00 jmpq *0x252b62(%rip) # 25a24 76e0: ff 25 62 2b 25 00 jmpq *0x252b62(%rip) # 25a24
76e6: 68 49 00 00 00 pushq $0x49 76e6: 68 49 00 00 00 pushq $0x49
76eb: e9 50 fb ff ff jmpq 7240 <_init+0x20> 76eb: e9 50 fb ff ff jmpq 7240 <_init+0x20>
00000000000076f0 <mmap@plt>: 00000000000076f0 <mmap@plt>:
76f0: ff 25 5a 2b 25 00 jmpq *0x252b5a(%rip) # 25a25 76f0: ff 25 5a 2b 25 00 jmpq *0x252b5a(%rip) # 25a25
76f6: 68 4a 00 00 00 pushq $0x4a 76f6: 68 4a 00 00 00 pushq $0x4a
76fb: e9 40 fb ff ff jmpq 7240 <_init+0x20> 76fb: e9 40 fb ff ff jmpq 7240 <_init+0x20>
0000000000007700 <_Unwind_SetIP@plt>: 0000000000007700 <_Unwind_SetIP@plt>:
7700: ff 25 52 2b 25 00 jmpq *0x252b52(%rip) # 25a25 7700: ff 25 52 2b 25 00 jmpq *0x252b52(%rip) # 25a25
7706: 68 4b 00 00 00 pushq $0x4b 7706: 68 4b 00 00 00 pushq $0x4b
770b: e9 30 fb ff ff jmpq 7240 <_init+0x20> 770b: e9 30 fb ff ff jmpq 7240 <_init+0x20>
Disassembly of section .text: Disassembly of section .text:
0000000000007710 <_start>: 0000000000007710 <_start>:
7710: 31 ed xor %ebp,%ebp 7710: 31 ed xor %ebp,%ebp
7712: 49 89 d1 mov %rdx,%r9 7712: 49 89 d1 mov %rdx,%r9
7715: 5e pop %rsi 7715: 5e pop %rsi
7716: 48 89 e2 mov %rsp,%rdx 7716: 48 89 e2 mov %rsp,%rdx
7719: 48 83 e4 f0 and $0xfffffffffffffff0,%rsp 7719: 48 83 e4 f0 and $0xfffffffffffffff0,%rsp
771d: 50 push %rax 771d: 50 push %rax
771e: 54 push %rsp 771e: 54 push %rsp
771f: 4c 8b 05 ba 26 25 00 mov 0x2526ba(%rip),%r8 # 25 771f: 4c 8b 05 ba 26 25 00 mov 0x2526ba(%rip),%r8 # 25
7726: 48 8b 0d 9b 27 25 00 mov 0x25279b(%rip),%rcx # 2 7726: 48 8b 0d 9b 27 25 00 mov 0x25279b(%rip),%rcx # 2
772d: 48 8b 3d 94 28 25 00 mov 0x252894(%rip),%rdi # 2 772d: 48 8b 3d 94 28 25 00 mov 0x252894(%rip),%rdi # 2
7734: e8 27 fc ff ff callq 7360 <__libc_start_main@plt> 7734: e8 27 fc ff ff callq 7360 <__libc_start_main@plt>
7739: f4 hlt 7739: f4 hlt
773a: 90 nop 773a: 90 nop
773b: 90 nop 773b: 90 nop
000000000000773c <call_gmon_start>: 000000000000773c <call_gmon_start>:
773c: 48 83 ec 08 sub $0x8,%rsp 773c: 48 83 ec 08 sub $0x8,%rsp
7740: 48 8b 05 d9 26 25 00 mov 0x2526d9(%rip),%rax # 2 7740: 48 8b 05 d9 26 25 00 mov 0x2526d9(%rip),%rax # 2
7747: 48 85 c0 test %rax,%rax 7747: 48 85 c0 test %rax,%rax
774a: 74 02 je 774e <call_gmon_start+0x12> 774a: 74 02 je 774e <call_gmon_start+0x12>
774c: ff d0 callq *%rax 774c: ff d0 callq *%rax
774e: 48 83 c4 08 add $0x8,%rsp 774e: 48 83 c4 08 add $0x8,%rsp
7752: c3 retq 7752: c3 retq
7753: 90 nop 7753: 90 nop
7754: 90 nop 7754: 90 nop
7755: 90 nop 7755: 90 nop
7756: 90 nop 7756: 90 nop
7757: 90 nop 7757: 90 nop
7758: 90 nop 7758: 90 nop
7759: 90 nop 7759: 90 nop
775a: 90 nop 775a: 90 nop
775b: 90 nop 775b: 90 nop
775c: 90 nop 775c: 90 nop
775d: 90 nop 775d: 90 nop
775e: 90 nop 775e: 90 nop
775f: 90 nop 775f: 90 nop
0000000000007760 <__do_global_dtors_aux>: 0000000000007760 <__do_global_dtors_aux>:
7760: 55 push %rbp 7760: 55 push %rbp
7761: 80 3d 78 2c 25 00 00 cmpb $0x0,0x252c78(%rip) # 2 7761: 80 3d 78 2c 25 00 00 cmpb $0x0,0x252c78(%rip) # 2
7768: 48 89 e5 mov %rsp,%rbp 7768: 48 89 e5 mov %rsp,%rbp
776b: 41 54 push %r12 776b: 41 54 push %r12
776d: 53 push %rbx 776d: 53 push %rbx
776e: 75 62 jne 77d2 <__do_global_dtors_aux+0x 776e: 75 62 jne 77d2 <__do_global_dtors_aux+0x
7770: 48 83 3d 20 27 25 00 cmpq $0x0,0x252720(%rip) # 2 7770: 48 83 3d 20 27 25 00 cmpq $0x0,0x252720(%rip) # 2
7777: 00 7777: 00
7778: 74 0c je 7786 <__do_global_dtors_aux+0x 7778: 74 0c je 7786 <__do_global_dtors_aux+0x
777a: 48 8b 3d df 2a 25 00 mov 0x252adf(%rip),%rdi # 2 777a: 48 8b 3d df 2a 25 00 mov 0x252adf(%rip),%rdi # 2
7781: e8 aa fc ff ff callq 7430 <__cxa_finalize@plt> 7781: e8 aa fc ff ff callq 7430 <__cxa_finalize@plt>
7786: 48 8d 1d b3 f5 24 00 lea 0x24f5b3(%rip),%rbx # 2 7786: 48 8d 1d b3 f5 24 00 lea 0x24f5b3(%rip),%rbx # 2
778d: 4c 8d 25 a4 f5 24 00 lea 0x24f5a4(%rip),%r12 # 2 778d: 4c 8d 25 a4 f5 24 00 lea 0x24f5a4(%rip),%r12 # 2
7794: 48 8b 05 4d 2c 25 00 mov 0x252c4d(%rip),%rax # 2 7794: 48 8b 05 4d 2c 25 00 mov 0x252c4d(%rip),%rax # 2
779b: 4c 29 e3 sub %r12,%rbx 779b: 4c 29 e3 sub %r12,%rbx
779e: 48 c1 fb 03 sar $0x3,%rbx 779e: 48 c1 fb 03 sar $0x3,%rbx
77a2: 48 83 eb 01 sub $0x1,%rbx 77a2: 48 83 eb 01 sub $0x1,%rbx
77a6: 48 39 d8 cmp %rbx,%rax 77a6: 48 39 d8 cmp %rbx,%rax
77a9: 73 20 jae 77cb <__do_global_dtors_aux+0x 77a9: 73 20 jae 77cb <__do_global_dtors_aux+0x
77ab: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) 77ab: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)
77b0: 48 83 c0 01 add $0x1,%rax 77b0: 48 83 c0 01 add $0x1,%rax
77b4: 48 89 05 2d 2c 25 00 mov %rax,0x252c2d(%rip) # 2 77b4: 48 89 05 2d 2c 25 00 mov %rax,0x252c2d(%rip) # 2
77bb: 41 ff 14 c4 callq *(%r12,%rax,8) 77bb: 41 ff 14 c4 callq *(%r12,%rax,8)
77bf: 48 8b 05 22 2c 25 00 mov 0x252c22(%rip),%rax # 2 77bf: 48 8b 05 22 2c 25 00 mov 0x252c22(%rip),%rax # 2
77c6: 48 39 d8 cmp %rbx,%rax 77c6: 48 39 d8 cmp %rbx,%rax
77c9: 72 e5 jb 77b0 <__do_global_dtors_aux+0x 77c9: 72 e5 jb 77b0 <__do_global_dtors_aux+0x
77cb: c6 05 0e 2c 25 00 01 movb $0x1,0x252c0e(%rip) # 2 77cb: c6 05 0e 2c 25 00 01 movb $0x1,0x252c0e(%rip) # 2
77d2: 5b pop %rbx 77d2: 5b pop %rbx
77d3: 41 5c pop %r12 77d3: 41 5c pop %r12
77d5: 5d pop %rbp 77d5: 5d pop %rbp
77d6: c3 retq 77d6: c3 retq
77d7: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) 77d7: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1)
77de: 00 00 77de: 00 00
00000000000077e0 <frame_dummy>: 00000000000077e0 <frame_dummy>:
77e0: 48 83 3d 60 f5 24 00 cmpq $0x0,0x24f560(%rip) # 2 77e0: 48 83 3d 60 f5 24 00 cmpq $0x0,0x24f560(%rip) # 2
77e7: 00 77e7: 00
77e8: 55 push %rbp 77e8: 55 push %rbp
77e9: 48 89 e5 mov %rsp,%rbp 77e9: 48 89 e5 mov %rsp,%rbp
77ec: 74 1a je 7808 <frame_dummy+0x28> 77ec: 74 1a je 7808 <frame_dummy+0x28>
77ee: 48 8b 05 33 26 25 00 mov 0x252633(%rip),%rax # 2 77ee: 48 8b 05 33 26 25 00 mov 0x252633(%rip),%rax # 2
77f5: 48 85 c0 test %rax,%rax 77f5: 48 85 c0 test %rax,%rax
77f8: 74 0e je 7808 <frame_dummy+0x28> 77f8: 74 0e je 7808 <frame_dummy+0x28>
77fa: 5d pop %rbp 77fa: 5d pop %rbp
77fb: 48 8d 3d 46 f5 24 00 lea 0x24f546(%rip),%rdi # 2 77fb: 48 8d 3d 46 f5 24 00 lea 0x24f546(%rip),%rdi # 2
7802: ff e0 jmpq *%rax 7802: ff e0 jmpq *%rax
7804: 0f 1f 40 00 nopl 0x0(%rax) 7804: 0f 1f 40 00 nopl 0x0(%rax)
7808: 5d pop %rbp 7808: 5d pop %rbp
7809: c3 retq 7809: c3 retq
780a: 90 nop 780a: 90 nop
780b: 90 nop 780b: 90 nop
780c: 90 nop 780c: 90 nop
780d: 90 nop 780d: 90 nop
780e: 90 nop 780e: 90 nop
780f: 90 nop 780f: 90 nop
0000000000007810 <_ZN4drop17hddf9fd0101172c6cE>: 0000000000007810 <_ZN4drop17hddf9fd0101172c6cE>:
7810: 55 push %rbp 7810: 55 push %rbp
7811: 48 89 e5 mov %rsp,%rbp 7811: 48 89 e5 mov %rsp,%rbp
7814: 41 56 push %r14 7814: 41 56 push %r14
7816: 53 push %rbx 7816: 53 push %rbx
7817: 48 83 ec 10 sub $0x10,%rsp 7817: 48 83 ec 10 sub $0x10,%rsp
781b: 49 89 fe mov %rdi,%r14 781b: 49 89 fe mov %rdi,%r14
781e: 41 80 7e 08 d4 cmpb $0xd4,0x8(%r14) 781e: 41 80 7e 08 d4 cmpb $0xd4,0x8(%r14)
7823: 75 7f jne 78a4 <_ZN4drop17hddf9fd0101172 7823: 75 7f jne 78a4 <_ZN4drop17hddf9fd0101172
7825: 49 8b 1e mov (%r14),%rbx 7825: 49 8b 1e mov (%r14),%rbx
7828: eb 0c jmp 7836 <_ZN4drop17hddf9fd0101172 7828: eb 0c jmp 7836 <_ZN4drop17hddf9fd0101172
782a: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) 782a: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1)
7830: 48 89 c3 mov %rax,%rbx 7830: 48 89 c3 mov %rax,%rbx
7833: 49 89 1e mov %rbx,(%r14) 7833: 49 89 1e mov %rbx,(%r14)
7836: 48 8b 43 08 mov 0x8(%rbx),%rax 7836: 48 8b 43 08 mov 0x8(%rbx),%rax
783a: 48 85 c0 test %rax,%rax 783a: 48 85 c0 test %rax,%rax
783d: 75 f1 jne 7830 <_ZN4drop17hddf9fd0101172 783d: 75 f1 jne 7830 <_ZN4drop17hddf9fd0101172
783f: 48 8b 43 10 mov 0x10(%rbx),%rax 783f: 48 8b 43 10 mov 0x10(%rbx),%rax
7843: 48 85 c0 test %rax,%rax 7843: 48 85 c0 test %rax,%rax
7846: 74 19 je 7861 <_ZN4drop17hddf9fd0101172 7846: 74 19 je 7861 <_ZN4drop17hddf9fd0101172
7848: 48 c7 40 08 00 00 00 movq $0x0,0x8(%rax) 7848: 48 c7 40 08 00 00 00 movq $0x0,0x8(%rax)
784f: 00 784f: 00
7850: c6 45 e8 d4 movb $0xd4,-0x18(%rbp) 7850: c6 45 e8 d4 movb $0xd4,-0x18(%rbp)
7854: 48 89 45 e0 mov %rax,-0x20(%rbp) 7854: 48 89 45 e0 mov %rax,-0x20(%rbp)
7858: 48 8d 7d e0 lea -0x20(%rbp),%rdi 7858: 48 8d 7d e0 lea -0x20(%rbp),%rdi
785c: e8 af ff ff ff callq 7810 <_ZN4drop17hddf9fd0101172 785c: e8 af ff ff ff callq 7810 <_ZN4drop17hddf9fd0101172
7861: 48 8b 43 18 mov 0x18(%rbx),%rax 7861: 48 8b 43 18 mov 0x18(%rbx),%rax
7865: 48 85 c0 test %rax,%rax 7865: 48 85 c0 test %rax,%rax
7868: 74 19 je 7883 <_ZN4drop17hddf9fd0101172 7868: 74 19 je 7883 <_ZN4drop17hddf9fd0101172
786a: 48 c7 40 08 00 00 00 movq $0x0,0x8(%rax) 786a: 48 c7 40 08 00 00 00 movq $0x0,0x8(%rax)
7871: 00 7871: 00
7872: c6 45 e8 d4 movb $0xd4,-0x18(%rbp) 7872: c6 45 e8 d4 movb $0xd4,-0x18(%rbp)
7876: 48 89 45 e0 mov %rax,-0x20(%rbp) 7876: 48 89 45 e0 mov %rax,-0x20(%rbp)
787a: 48 8d 7d e0 lea -0x20(%rbp),%rdi 787a: 48 8d 7d e0 lea -0x20(%rbp),%rdi
787e: e8 8d ff ff ff callq 7810 <_ZN4drop17hddf9fd0101172 787e: e8 8d ff ff ff callq 7810 <_ZN4drop17hddf9fd0101172
7883: 49 8b 3e mov (%r14),%rdi 7883: 49 8b 3e mov (%r14),%rdi
7886: 48 b8 1d 1d 1d 1d 1d movabs $0x1d1d1d1d1d1d1d1d,%rax 7886: 48 b8 1d 1d 1d 1d 1d movabs $0x1d1d1d1d1d1d1d1d,%rax
788d: 1d 1d 1d 788d: 1d 1d 1d
7890: 48 39 c7 cmp %rax,%rdi 7890: 48 39 c7 cmp %rax,%rdi
7893: 74 0f je 78a4 <_ZN4drop17hddf9fd0101172 7893: 74 0f je 78a4 <_ZN4drop17hddf9fd0101172
7895: be 28 00 00 00 mov $0x28,%esi 7895: be 28 00 00 00 mov $0x28,%esi
789a: ba 08 00 00 00 mov $0x8,%edx 789a: ba 08 00 00 00 mov $0x8,%edx
789f: e8 7c 11 01 00 callq 18a20 <__rust_deallocate> | 789f: e8 7c 10 01 00 callq 18920 <__rust_deallocate>
78a4: 48 83 c4 10 add $0x10,%rsp 78a4: 48 83 c4 10 add $0x10,%rsp
78a8: 5b pop %rbx 78a8: 5b pop %rbx
78a9: 41 5e pop %r14 78a9: 41 5e pop %r14
78ab: 5d pop %rbp 78ab: 5d pop %rbp
78ac: c3 retq 78ac: c3 retq
78ad: 90 nop 78ad: 90 nop
78ae: 90 nop 78ae: 90 nop
78af: 90 nop 78af: 90 nop
00000000000078b0 <_ZN29_$LT$splay..Tree$LT$T$GT$$GT$4link17hee30bf7909124682E 00000000000078b0 <_ZN29_$LT$splay..Tree$LT$T$GT$$GT$4link17hee30bf7909124682E
self.node = child; self.node = child;
true true
} }
} }
fn link(&mut self, index: usize, mut tree: Tree<T>) { fn link(&mut self, index: usize, mut tree: Tree<T>) {
78b0: 55 push %rbp 78b0: 55 push %rbp
78b1: 48 89 e5 mov %rsp,%rbp 78b1: 48 89 e5 mov %rsp,%rbp
78b4: 53 push %rbx | 78b4: 48 83 ec 50 sub $0x50,%rsp
78b5: 48 83 ec 58 sub $0x58,%rsp | 78b8: 48 8b 02 mov (%rdx),%rax
78b9: 48 89 75 f0 mov %rsi,-0x10(%rbp) | 78bb: 48 89 75 f8 mov %rsi,-0x8(%rbp)
78bd: 0f 10 02 movups (%rdx),%xmm0 <
78c0: 0f 29 45 e0 movaps %xmm0,-0x20(%rbp) <
78c4: 48 83 fe 02 cmp $0x2,%rsi <
if unsafe { (*self.node).children[index] } != ptr::null_mut() { <
78c8: 73 5d jae 7927 <_ZN29_$LT$splay..Tree$LT <
78ca: 48 8b 07 mov (%rdi),%rax <
78cd: 48 83 7c f0 10 00 cmpq $0x0,0x10(%rax,%rsi,8) <
78d3: 75 65 jne 793a <_ZN29_$LT$splay..Tree$LT <
fn new(value: T) -> Tree<T> { <
Tree { node: Box::into_raw(Box::new(Node::new(value))) } <
} <
<
fn parent(&mut self) -> Option<usize> { <
let parent = unsafe { (*self.node).parent }; <
78d5: 48 8b 45 e0 mov -0x20(%rbp),%rax <
78d9: 48 8b 48 08 mov 0x8(%rax),%rcx <
<
fn link(&mut self, index: usize, mut tree: Tree<T>) { <
if unsafe { (*self.node).children[index] } != ptr::null_mut() { if unsafe { (*self.node).children[index] } != ptr::null_mut() {
> 78bf: 48 83 fe 01 cmp $0x1,%rsi
> 78c3: 0f 87 95 00 00 00 ja 795e <_ZN29_$LT$splay..Tree$LT
> 78c9: 48 8b 0f mov (%rdi),%rcx
> 78cc: 48 83 7c f1 10 00 cmpq $0x0,0x10(%rcx,%rsi,8)
> 78d2: 74 5f je 7933 <_ZN29_$LT$splay..Tree$LT
> 78d4: 48 8d 45 f8 lea -0x8(%rbp),%rax
panic!("Cannot link a tree because another node is linked at inde panic!("Cannot link a tree because another node is linked at inde
} | 78d8: 48 89 45 e8 mov %rax,-0x18(%rbp)
while tree.parent().is_some() {} | 78dc: 48 8b 05 e5 24 25 00 mov 0x2524e5(%rip),%rax # 2
78dd: 48 85 c9 test %rcx,%rcx | 78e3: 48 89 45 f0 mov %rax,-0x10(%rbp)
78e0: 74 1e je 7900 <_ZN29_$LT$splay..Tree$LT | 78e7: 48 8d 05 ea 10 25 00 lea 0x2510ea(%rip),%rax # 2
78e2: 66 66 66 66 66 2e 0f data32 data32 data32 data32 nopw %cs: | 78ee: 48 89 45 b8 mov %rax,-0x48(%rbp)
78e9: 1f 84 00 00 00 00 00 | 78f2: 48 c7 45 c0 01 00 00 movq $0x1,-0x40(%rbp)
78f0: 48 89 c8 mov %rcx,%rax | 78f9: 00
> 78fa: 48 c7 45 c8 00 00 00 movq $0x0,-0x38(%rbp)
> 7901: 00
> 7902: 48 8d 45 e8 lea -0x18(%rbp),%rax
> 7906: 48 89 45 d8 mov %rax,-0x28(%rbp)
> 790a: 48 c7 45 e0 01 00 00 movq $0x1,-0x20(%rbp)
> 7911: 00
>
> struct Node<T> {
> index: usize,
> parent: *mut Node<T>,
> children: [*mut Node<T>; 2],
> value: T,
> 7912: 48 8d 35 cf 10 25 00 lea 0x2510cf(%rip),%rsi # 2
> 7919: 48 8d 7d b8 lea -0x48(%rbp),%rdi
> 791d: e8 be 71 00 00 callq eae0 <_ZN3std9panicking15begin
> 7922: 66 66 66 66 66 2e 0f data32 data32 data32 data32 nopw %cs:
> 7929: 1f 84 00 00 00 00 00
> 7930: 48 89 c8 mov %rcx,%rax
fn new(value: T) -> Tree<T> { fn new(value: T) -> Tree<T> {
Tree { node: Box::into_raw(Box::new(Node::new(value))) } Tree { node: Box::into_raw(Box::new(Node::new(value))) }
} }
fn parent(&mut self) -> Option<usize> { fn parent(&mut self) -> Option<usize> {
let parent = unsafe { (*self.node).parent }; let parent = unsafe { (*self.node).parent };
78f3: 48 8b 48 08 mov 0x8(%rax),%rcx | 7933: 48 8b 48 08 mov 0x8(%rax),%rcx
if parent == ptr::null_mut() { if parent == ptr::null_mut() {
78f7: 48 85 c9 test %rcx,%rcx | 7937: 48 85 c9 test %rcx,%rcx
78fa: 75 f4 jne 78f0 <_ZN29_$LT$splay..Tree$LT | 793a: 75 f4 jne 7930 <_ZN29_$LT$splay..Tree$LT
None <
} else { <
let index = unsafe { (*self.node).index }; <
self.node = parent; <
78fc: 48 89 45 e0 mov %rax,-0x20(%rbp) <
if unsafe { (*self.node).children[index] } != ptr::null_mut() { if unsafe { (*self.node).children[index] } != ptr::null_mut() {
panic!("Cannot link a tree because another node is linked at inde panic!("Cannot link a tree because another node is linked at inde
} }
while tree.parent().is_some() {} while tree.parent().is_some() {}
unsafe { unsafe {
(*tree.node).index = index; (*tree.node).index = index;
7900: 48 89 30 mov %rsi,(%rax) | 793c: 48 89 30 mov %rsi,(%rax)
(*tree.node).parent = self.node; (*tree.node).parent = self.node;
7903: 48 8b 0f mov (%rdi),%rcx | 793f: 48 8b 0f mov (%rdi),%rcx
7906: 48 89 48 08 mov %rcx,0x8(%rax) | 7942: 48 89 48 08 mov %rcx,0x8(%rax)
(*self.node).children[index] = tree.node; (*self.node).children[index] = tree.node;
790a: 48 8b 75 f0 mov -0x10(%rbp),%rsi | 7946: 48 8b 75 f8 mov -0x8(%rbp),%rsi
790e: 48 83 fe 01 cmp $0x1,%rsi | 794a: 48 83 fe 01 cmp $0x1,%rsi
7912: 77 76 ja 798a <_ZN29_$LT$splay..Tree$LT | 794e: 77 1f ja 796f <_ZN29_$LT$splay..Tree$LT
7914: 48 8b 07 mov (%rdi),%rax | 7950: 48 8b 0f mov (%rdi),%rcx
7917: 48 8b 4d e0 mov -0x20(%rbp),%rcx | 7953: 48 89 44 f1 10 mov %rax,0x10(%rcx,%rsi,8)
791b: 48 89 4c f0 10 mov %rcx,0x10(%rax,%rsi,8) <
self.node = child; self.node = child;
true true
} }
} }
fn link(&mut self, index: usize, mut tree: Tree<T>) { fn link(&mut self, index: usize, mut tree: Tree<T>) {
7920: 48 83 c4 58 add $0x58,%rsp | 7958: 48 83 c4 50 add $0x50,%rsp
7924: 5b pop %rbx | 795c: 5d pop %rbp
7925: 5d pop %rbp | 795d: c3 retq
7926: c3 retq <
if unsafe { (*self.node).children[index] } != ptr::null_mut() { if unsafe { (*self.node).children[index] } != ptr::null_mut() {
7927: 48 8d 3d 7a 10 25 00 lea 0x25107a(%rip),%rdi # 2 | 795e: 48 8d 3d 43 10 25 00 lea 0x251043(%rip),%rdi # 2
792e: ba 02 00 00 00 mov $0x2,%edx | 7965: ba 02 00 00 00 mov $0x2,%edx
7933: e8 08 ce 03 00 callq 44740 <_ZN4core9panicking18pan | 796a: e8 d1 cc 03 00 callq 44640 <_ZN4core9panicking18pan
7938: eb 61 jmp 799b <_ZN29_$LT$splay..Tree$LT <
793a: 48 8d 45 f0 lea -0x10(%rbp),%rax <
panic!("Cannot link a tree because another node is linked at inde <
793e: 48 89 45 d0 mov %rax,-0x30(%rbp) <
7942: 48 8b 05 7f 24 25 00 mov 0x25247f(%rip),%rax # 2 <
7949: 48 89 45 d8 mov %rax,-0x28(%rbp) <
794d: 48 8d 05 84 10 25 00 lea 0x251084(%rip),%rax # 2 <
7954: 48 89 45 a0 mov %rax,-0x60(%rbp) <
7958: 48 c7 45 a8 01 00 00 movq $0x1,-0x58(%rbp) <
795f: 00 <
7960: 48 c7 45 b0 00 00 00 movq $0x0,-0x50(%rbp) <
7967: 00 <
7968: 48 8d 45 d0 lea -0x30(%rbp),%rax <
796c: 48 89 45 c0 mov %rax,-0x40(%rbp) <
7970: 48 c7 45 c8 01 00 00 movq $0x1,-0x38(%rbp) <
7977: 00 <
<
struct Node<T> { <
index: usize, <
parent: *mut Node<T>, <
children: [*mut Node<T>; 2], <
value: T, <
7978: 48 8d 35 69 10 25 00 lea 0x251069(%rip),%rsi # 2 <
797f: 48 8d 7d a0 lea -0x60(%rbp),%rdi <
7983: e8 58 72 00 00 callq ebe0 <_ZN3std9panicking15begin <
7988: eb 11 jmp 799b <_ZN29_$LT$splay..Tree$LT <
} }
while tree.parent().is_some() {} while tree.parent().is_some() {}
unsafe { unsafe {
(*tree.node).index = index; (*tree.node).index = index;
(*tree.node).parent = self.node; (*tree.node).parent = self.node;
(*self.node).children[index] = tree.node; (*self.node).children[index] = tree.node;
798a: 48 8d 3d 2f 10 25 00 lea 0x25102f(%rip),%rdi # 2 | 796f: 48 8d 3d 4a 10 25 00 lea 0x25104a(%rip),%rdi # 2
7991: ba 02 00 00 00 mov $0x2,%edx | 7976: ba 02 00 00 00 mov $0x2,%edx
7996: e8 a5 cd 03 00 callq 44740 <_ZN4core9panicking18pan | 797b: e8 c0 cc 03 00 callq 44640 <_ZN4core9panicking18pan
799b: 48 89 c3 mov %rax,%rbx <
799e: 48 8d 7d e0 lea -0x20(%rbp),%rdi <
self.node = child; <
true <
} <
} <
<
fn link(&mut self, index: usize, mut tree: Tree<T>) { <
79a2: e8 69 fe ff ff callq 7810 <_ZN4drop17hddf9fd0101172 <
79a7: 48 89 df mov %rbx,%rdi <
79aa: e8 d1 fc ff ff callq 7680 <_Unwind_Resume@plt> <
79af: 90 nop <
00000000000079b0 <_ZN30_$LT$splay..Splay$LT$T$GT$$GT$6rotate17ha93a044f2339ca | 0000000000007980 <_ZN30_$LT$splay..Splay$LT$T$GT$$GT$6rotate17ha93a044f2339ca
impl<T> Splay<T> where T: PartialOrd { impl<T> Splay<T> where T: PartialOrd {
fn new() -> Splay<T> { fn new() -> Splay<T> {
Splay { tree: None } Splay { tree: None }
} }
fn rotate(&self, tree: &mut Tree<T>, index: usize) { fn rotate(&self, tree: &mut Tree<T>, index: usize) {
79b0: 55 push %rbp | 7980: 55 push %rbp
79b1: 48 89 e5 mov %rsp,%rbp | 7981: 48 89 e5 mov %rsp,%rbp
79b4: 41 57 push %r15 | 7984: 41 57 push %r15
79b6: 41 56 push %r14 | 7986: 41 56 push %r14
79b8: 41 54 push %r12 | 7988: 41 55 push %r13
79ba: 53 push %rbx | 798a: 41 54 push %r12
79bb: 48 81 ec 90 00 00 00 sub $0x90,%rsp | 798c: 53 push %rbx
79c2: 48 89 fb mov %rdi,%rbx | 798d: 48 83 ec 38 sub $0x38,%rsp
> 7991: 48 89 fb mov %rdi,%rbx
} }
mem::forget(tree); mem::forget(tree);
} }
fn take(&mut self, index: usize) -> Option<Tree<T>> { fn take(&mut self, index: usize) -> Option<Tree<T>> {
let child = unsafe { (*self.node).children[index] }; let child = unsafe { (*self.node).children[index] };
79c5: 48 83 fe 01 cmp $0x1,%rsi | 7994: 48 83 fe 01 cmp $0x1,%rsi
79c9: 0f 87 93 01 00 00 ja 7b62 <_ZN30_$LT$splay..Splay$L | 7998: 0f 87 5c 01 00 00 ja 7afa <_ZN30_$LT$splay..Splay$L
79cf: 48 8b 03 mov (%rbx),%rax | 799e: 48 8b 03 mov (%rbx),%rax
if child == ptr::null_mut() { | 79a1: 4c 8b 64 f0 10 mov 0x10(%rax,%rsi,8),%r12
None <
} else { <
unsafe { <
(*child).parent = ptr::null_mut(); <
(*self.node).children[index] = ptr::null_mut(); <
79d2: 48 8b 44 f0 10 mov 0x10(%rax,%rsi,8),%rax <
fn new() -> Splay<T> { fn new() -> Splay<T> {
Splay { tree: None } Splay { tree: None }
} }
fn rotate(&self, tree: &mut Tree<T>, index: usize) { fn rotate(&self, tree: &mut Tree<T>, index: usize) {
let mut child = tree.take(index).unwrap(); let mut child = tree.take(index).unwrap();
79d7: 48 85 c0 test %rax,%rax | 79a6: 4d 85 e4 test %r12,%r12
79da: 0f 84 96 01 00 00 je 7b76 <_ZN30_$LT$splay..Splay$L | mem::forget(tree);
> }
>
> fn take(&mut self, index: usize) -> Option<Tree<T>> {
let child = unsafe { (*self.node).children[index] }; let child = unsafe { (*self.node).children[index] };
if child == ptr::null_mut() { if child == ptr::null_mut() {
> 79a9: 0f 84 5c 01 00 00 je 7b0b <_ZN30_$LT$splay..Splay$L
None None
} else { } else {
unsafe { unsafe {
(*child).parent = ptr::null_mut(); (*child).parent = ptr::null_mut();
79e0: 48 c7 40 08 00 00 00 movq $0x0,0x8(%rax) | 79af: 49 c7 44 24 08 00 00 movq $0x0,0x8(%r12)
79e7: 00 | 79b6: 00 00
(*self.node).children[index] = ptr::null_mut(); (*self.node).children[index] = ptr::null_mut();
79e8: 48 8b 0b mov (%rbx),%rcx | 79b8: 48 8b 03 mov (%rbx),%rax
79eb: 48 c7 44 f1 10 00 00 movq $0x0,0x10(%rcx,%rsi,8) | 79bb: 48 c7 44 f0 10 00 00 movq $0x0,0x10(%rax,%rsi,8)
79f2: 00 00 | 79c2: 00 00
79f4: 48 89 45 d0 mov %rax,-0x30(%rbp) <
79f8: c6 45 d8 d4 movb $0xd4,-0x28(%rbp) <
79fc: 8a 4d b6 mov -0x4a(%rbp),%cl <
79ff: 88 4d df mov %cl,-0x21(%rbp) <
7a02: 0f b7 4d b4 movzwl -0x4c(%rbp),%ecx <
7a06: 66 89 4d dd mov %cx,-0x23(%rbp) <
7a0a: 8b 4d b0 mov -0x50(%rbp),%ecx <
7a0d: 89 4d d9 mov %ecx,-0x27(%rbp) <
Splay { tree: None } Splay { tree: None }
} }
fn rotate(&self, tree: &mut Tree<T>, index: usize) { fn rotate(&self, tree: &mut Tree<T>, index: usize) {
let mut child = tree.take(index).unwrap(); let mut child = tree.take(index).unwrap();
if let Some(grandchild) = child.take(index ^ 1) { if let Some(grandchild) = child.take(index ^ 1) {
7a10: 49 89 f6 mov %rsi,%r14 | 79c4: 49 89 f6 mov %rsi,%r14
7a13: 49 83 f6 01 xor $0x1,%r14 | 79c7: 49 83 f6 01 xor $0x1,%r14
} }
mem::forget(tree); mem::forget(tree);
} }
fn take(&mut self, index: usize) -> Option<Tree<T>> { fn take(&mut self, index: usize) -> Option<Tree<T>> {
let child = unsafe { (*self.node).children[index] }; let child = unsafe { (*self.node).children[index] };
7a17: 49 83 fe 01 cmp $0x1,%r14 | 79cb: 49 83 fe 01 cmp $0x1,%r14
7a1b: 0f 87 64 01 00 00 ja 7b85 <_ZN30_$LT$splay..Splay$L | 79cf: 0f 87 42 01 00 00 ja 7b17 <_ZN30_$LT$splay..Splay$L
7a21: 4a 8b 4c f0 10 mov 0x10(%rax,%r14,8),%rcx | 79d5: 4b 8b 44 f4 10 mov 0x10(%r12,%r14,8),%rax
Splay { tree: None } Splay { tree: None }
} }
fn rotate(&self, tree: &mut Tree<T>, index: usize) { fn rotate(&self, tree: &mut Tree<T>, index: usize) {
let mut child = tree.take(index).unwrap(); let mut child = tree.take(index).unwrap();
if let Some(grandchild) = child.take(index ^ 1) { if let Some(grandchild) = child.take(index ^ 1) {
7a26: 48 85 c9 test %rcx,%rcx | 79da: 48 85 c0 test %rax,%rax
7a29: 74 48 je 7a73 <_ZN30_$LT$splay..Splay$L | 79dd: 74 3f je 7a1e <_ZN30_$LT$splay..Splay$L
let child = unsafe { (*self.node).children[index] }; let child = unsafe { (*self.node).children[index] };
if child == ptr::null_mut() { if child == ptr::null_mut() {
None None
} else { } else {
unsafe { unsafe {
(*child).parent = ptr::null_mut(); (*child).parent = ptr::null_mut();
7a2b: 48 c7 41 08 00 00 00 movq $0x0,0x8(%rcx) | 79df: 48 c7 40 08 00 00 00 movq $0x0,0x8(%rax)
7a32: 00 | 79e6: 00
(*self.node).children[index] = ptr::null_mut(); (*self.node).children[index] = ptr::null_mut();
7a33: 4a c7 44 f0 10 00 00 movq $0x0,0x10(%rax,%r14,8) | 79e7: 4b c7 44 f4 10 00 00 movq $0x0,0x10(%r12,%r14,8)
7a3a: 00 00 | 79ee: 00 00
} }
Some(Tree { node: child }) Some(Tree { node: child })
7a3c: 48 89 4d b8 mov %rcx,-0x48(%rbp) | 79f0: 48 89 45 c8 mov %rax,-0x38(%rbp)
7a40: c6 45 c0 d4 movb $0xd4,-0x40(%rbp) | 79f4: c6 45 d0 d4 movb $0xd4,-0x30(%rbp)
} }
fn take(&mut self, index: usize) -> Option<Tree<T>> { fn take(&mut self, index: usize) -> Option<Tree<T>> {
let child = unsafe { (*self.node).children[index] }; let child = unsafe { (*self.node).children[index] };
if child == ptr::null_mut() { if child == ptr::null_mut() {
None None
7a44: 48 c7 45 b0 01 00 00 movq $0x1,-0x50(%rbp) | 79f8: 48 c7 45 c0 01 00 00 movq $0x1,-0x40(%rbp)
7a4b: 00 | 79ff: 00
Splay { tree: None } Splay { tree: None }
} }
fn rotate(&self, tree: &mut Tree<T>, index: usize) { fn rotate(&self, tree: &mut Tree<T>, index: usize) {
let mut child = tree.take(index).unwrap(); let mut child = tree.take(index).unwrap();
if let Some(grandchild) = child.take(index ^ 1) { if let Some(grandchild) = child.take(index ^ 1) {
7a4c: 0f 10 45 b8 movups -0x48(%rbp),%xmm0 | 7a00: 0f 10 45 c8 movups -0x38(%rbp),%xmm0
7a50: 0f 29 85 50 ff ff ff movaps %xmm0,-0xb0(%rbp) | 7a04: 0f 29 45 b0 movaps %xmm0,-0x50(%rbp)
tree.link(index, grandchild); tree.link(index, grandchild);
7a57: 0f 10 45 b8 movups -0x48(%rbp),%xmm0 | 7a08: 0f 10 45 c8 movups -0x38(%rbp),%xmm0
7a5b: 0f 29 85 60 ff ff ff movaps %xmm0,-0xa0(%rbp) | 7a0c: 0f 29 45 a0 movaps %xmm0,-0x60(%rbp)
7a62: 48 8d 95 60 ff ff ff lea -0xa0(%rbp),%rdx | 7a10: 48 8d 55 a0 lea -0x60(%rbp),%rdx
7a69: 48 89 df mov %rbx,%rdi | 7a14: 48 89 df mov %rbx,%rdi
7a6c: e8 3f fe ff ff callq 78b0 <_ZN29_$LT$splay..Tree$LT | 7a17: e8 94 fe ff ff callq 78b0 <_ZN29_$LT$splay..Tree$LT
7a71: eb 08 jmp 7a7b <_ZN30_$LT$splay..Splay$L | 7a1c: eb 08 jmp 7a26 <_ZN30_$LT$splay..Splay$L
} }
fn take(&mut self, index: usize) -> Option<Tree<T>> { fn take(&mut self, index: usize) -> Option<Tree<T>> {
let child = unsafe { (*self.node).children[index] }; let child = unsafe { (*self.node).children[index] };
if child == ptr::null_mut() { if child == ptr::null_mut() {
None None
7a73: 48 c7 45 b0 00 00 00 movq $0x0,-0x50(%rbp) | 7a1e: 48 c7 45 c0 00 00 00 movq $0x0,-0x40(%rbp)
7a7a: 00 | 7a25: 00
fn new(value: T) -> Tree<T> { fn new(value: T) -> Tree<T> {
Tree { node: Box::into_raw(Box::new(Node::new(value))) } Tree { node: Box::into_raw(Box::new(Node::new(value))) }
} }
fn parent(&mut self) -> Option<usize> { fn parent(&mut self) -> Option<usize> {
let parent = unsafe { (*self.node).parent }; let parent = unsafe { (*self.node).parent };
7a7b: 48 8b 0b mov (%rbx),%rcx | 7a26: 48 8b 0b mov (%rbx),%rcx
} }
mem::forget(tree); mem::forget(tree);
} }
fn take(&mut self, index: usize) -> Option<Tree<T>> { fn take(&mut self, index: usize) -> Option<Tree<T>> {
let child = unsafe { (*self.node).children[index] }; let child = unsafe { (*self.node).children[index] };
7a7e: 48 8b 41 08 mov 0x8(%rcx),%rax | 7a29: 48 8b 41 08 mov 0x8(%rcx),%rax
let mut child = tree.take(index).unwrap(); <
if let Some(grandchild) = child.take(index ^ 1) { <
tree.link(index, grandchild); <
} <
<
if let Some(i) = tree.parent() { <
7a82: 48 85 c0 test %rax,%rax <
Tree { node: Box::into_raw(Box::new(Node::new(value))) } Tree { node: Box::into_raw(Box::new(Node::new(value))) }
} }
fn parent(&mut self) -> Option<usize> { fn parent(&mut self) -> Option<usize> {
let parent = unsafe { (*self.node).parent }; let parent = unsafe { (*self.node).parent };
if parent == ptr::null_mut() { if parent == ptr::null_mut() {
7a85: 0f 84 97 00 00 00 je 7b22 <_ZN30_$LT$splay..Splay$L | 7a2d: 48 85 c0 test %rax,%rax
> 7a30: 0f 84 8f 00 00 00 je 7ac5 <_ZN30_$LT$splay..Splay$L
None None
} else { } else {
let index = unsafe { (*self.node).index }; let index = unsafe { (*self.node).index };
7a8b: 4c 8b 39 mov (%rcx),%r15 | 7a36: 4c 8b 39 mov (%rcx),%r15
self.node = parent; self.node = parent;
7a8e: 48 89 03 mov %rax,(%rbx) | 7a39: 48 89 03 mov %rax,(%rbx)
} }
mem::forget(tree); mem::forget(tree);
} }
fn take(&mut self, index: usize) -> Option<Tree<T>> { fn take(&mut self, index: usize) -> Option<Tree<T>> {
let child = unsafe { (*self.node).children[index] }; let child = unsafe { (*self.node).children[index] };
7a91: 49 83 ff 01 cmp $0x1,%r15 | 7a3c: 49 83 ff 01 cmp $0x1,%r15
7a95: 0f 87 01 01 00 00 ja 7b9c <_ZN30_$LT$splay..Splay$L | 7a40: 0f 87 e5 00 00 00 ja 7b2b <_ZN30_$LT$splay..Splay$L
7a9b: 4a 8b 44 f8 10 mov 0x10(%rax,%r15,8),%rax | 7a46: 4e 8b 6c f8 10 mov 0x10(%rax,%r15,8),%r13
if let Some(grandchild) = child.take(index ^ 1) { if let Some(grandchild) = child.take(index ^ 1) {
tree.link(index, grandchild); tree.link(index, grandchild);
} }
if let Some(i) = tree.parent() { if let Some(i) = tree.parent() {
let t = tree.take(i).unwrap(); let t = tree.take(i).unwrap();
7aa0: 48 85 c0 test %rax,%rax | 7a4b: 4d 85 ed test %r13,%r13
7aa3: 0f 84 0a 01 00 00 je 7bb3 <_ZN30_$LT$splay..Splay$L | mem::forget(tree);
> }
>
> fn take(&mut self, index: usize) -> Option<Tree<T>> {
let child = unsafe { (*self.node).children[index] }; let child = unsafe { (*self.node).children[index] };
if child == ptr::null_mut() { if child == ptr::null_mut() {
> 7a4e: 0f 84 eb 00 00 00 je 7b3f <_ZN30_$LT$splay..Splay$L
None None
} else { } else {
unsafe { unsafe {
(*child).parent = ptr::null_mut(); (*child).parent = ptr::null_mut();
7aa9: 48 c7 40 08 00 00 00 movq $0x0,0x8(%rax) | 7a54: 49 c7 45 08 00 00 00 movq $0x0,0x8(%r13)
7ab0: 00 | 7a5b: 00
(*self.node).children[index] = ptr::null_mut(); (*self.node).children[index] = ptr::null_mut();
7ab1: 48 8b 0b mov (%rbx),%rcx | 7a5c: 48 8b 03 mov (%rbx),%rax
7ab4: 4a c7 44 f9 10 00 00 movq $0x0,0x10(%rcx,%r15,8) | 7a5f: 4a c7 44 f8 10 00 00 movq $0x0,0x10(%rax,%r15,8)
7abb: 00 00 | 7a66: 00 00
7abd: 48 89 45 a0 mov %rax,-0x60(%rbp) | 7a68: 8a 45 c6 mov -0x3a(%rbp),%al
7ac1: c6 45 a8 d4 movb $0xd4,-0x58(%rbp) | 7a6b: 88 45 b6 mov %al,-0x4a(%rbp)
7ac5: 8a 45 b6 mov -0x4a(%rbp),%al | 7a6e: 0f b7 45 c4 movzwl -0x3c(%rbp),%eax
7ac8: 88 45 af mov %al,-0x51(%rbp) | 7a72: 66 89 45 b4 mov %ax,-0x4c(%rbp)
7acb: 0f b7 45 b4 movzwl -0x4c(%rbp),%eax | 7a76: 8b 45 c0 mov -0x40(%rbp),%eax
7acf: 66 89 45 ad mov %ax,-0x53(%rbp) | 7a79: 89 45 b0 mov %eax,-0x50(%rbp)
7ad3: 8b 45 b0 mov -0x50(%rbp),%eax <
7ad6: 89 45 a9 mov %eax,-0x57(%rbp) <
tree.link(index, grandchild); tree.link(index, grandchild);
} }
if let Some(i) = tree.parent() { if let Some(i) = tree.parent() {
let t = tree.take(i).unwrap(); let t = tree.take(i).unwrap();
tree.link(i, child); tree.link(i, child);
7ad9: 0f 10 45 d0 movups -0x30(%rbp),%xmm0 | 7a7c: 4c 89 65 c0 mov %r12,-0x40(%rbp)
7add: 0f 29 85 70 ff ff ff movaps %xmm0,-0x90(%rbp) | 7a80: 48 c7 45 c8 d4 00 00 movq $0xd4,-0x38(%rbp)
7ae4: 48 8d 95 70 ff ff ff lea -0x90(%rbp),%rdx | 7a87: 00
7aeb: 48 89 df mov %rbx,%rdi | 7a88: 48 8d 55 c0 lea -0x40(%rbp),%rdx
7aee: 4c 89 fe mov %r15,%rsi | 7a8c: 48 89 df mov %rbx,%rdi
7af1: e8 ba fd ff ff callq 78b0 <_ZN29_$LT$splay..Tree$LT | 7a8f: 4c 89 fe mov %r15,%rsi
> 7a92: e8 19 fe ff ff callq 78b0 <_ZN29_$LT$splay..Tree$LT
Some(index) Some(index)
} }
} }
fn child(&mut self, index: usize) -> bool { fn child(&mut self, index: usize) -> bool {
let child = unsafe { (*self.node).children[index] }; let child = unsafe { (*self.node).children[index] };
7af6: 48 8b 03 mov (%rbx),%rax | 7a97: 48 8b 03 mov (%rbx),%rax
7af9: 4a 8b 44 f8 10 mov 0x10(%rax,%r15,8),%rax | 7a9a: 4a 8b 44 f8 10 mov 0x10(%rax,%r15,8),%rax
} }
if let Some(i) = tree.parent() { if let Some(i) = tree.parent() {
let t = tree.take(i).unwrap(); let t = tree.take(i).unwrap();
tree.link(i, child); tree.link(i, child);
tree.child(i); tree.child(i);
7afe: 48 85 c0 test %rax,%rax | 7a9f: 48 85 c0 test %rax,%rax
7b01: 74 03 je 7b06 <_ZN30_$LT$splay..Splay$L | 7aa2: 74 03 je 7aa7 <_ZN30_$LT$splay..Splay$L
fn child(&mut self, index: usize) -> bool { fn child(&mut self, index: usize) -> bool {
let child = unsafe { (*self.node).children[index] }; let child = unsafe { (*self.node).children[index] };
if child == ptr::null_mut() { if child == ptr::null_mut() {
false false
} else { } else {
self.node = child; self.node = child;
7b03: 48 89 03 mov %rax,(%rbx) | 7aa4: 48 89 03 mov %rax,(%rbx)
if let Some(i) = tree.parent() { if let Some(i) = tree.parent() {
let t = tree.take(i).unwrap(); let t = tree.take(i).unwrap();
tree.link(i, child); tree.link(i, child);
tree.child(i); tree.child(i);
tree.link(index ^ 1, t); tree.link(index ^ 1, t);
7b06: 0f 10 45 a0 movups -0x60(%rbp),%xmm0 | 7aa7: 4c 89 6d c0 mov %r13,-0x40(%rbp)
7b0a: 0f 29 45 80 movaps %xmm0,-0x80(%rbp) | 7aab: c6 45 c8 d4 movb $0xd4,-0x38(%rbp)
7b0e: 45 31 e4 xor %r12d,%r12d | 7aaf: 8a 45 b6 mov -0x4a(%rbp),%al
7b11: 48 8d 55 80 lea -0x80(%rbp),%rdx | 7ab2: 88 45 cf mov %al,-0x31(%rbp)
7b15: 48 89 df mov %rbx,%rdi | 7ab5: 0f b7 45 b4 movzwl -0x4c(%rbp),%eax
7b18: 4c 89 f6 mov %r14,%rsi | 7ab9: 66 89 45 cd mov %ax,-0x33(%rbp)
7b1b: e8 90 fd ff ff callq 78b0 <_ZN29_$LT$splay..Tree$LT | 7abd: 8b 45 b0 mov -0x50(%rbp),%eax
7b20: eb 30 jmp 7b52 <_ZN30_$LT$splay..Splay$L | 7ac0: 89 45 c9 mov %eax,-0x37(%rbp)
7b22: 0f 10 03 movups (%rbx),%xmm0 | 7ac3: eb 17 jmp 7adc <_ZN30_$LT$splay..Splay$L
7b25: 0f 29 45 b0 movaps %xmm0,-0x50(%rbp) | 7ac5: 48 8b 43 08 mov 0x8(%rbx),%rax
7b29: 0f 28 45 d0 movaps -0x30(%rbp),%xmm0 | 7ac9: 4c 89 23 mov %r12,(%rbx)
7b2d: 0f 11 03 movups %xmm0,(%rbx) | 7acc: 48 c7 43 08 d4 00 00 movq $0xd4,0x8(%rbx)
7b30: 0f 28 45 b0 movaps -0x50(%rbp),%xmm0 | 7ad3: 00
7b34: 0f 29 45 d0 movaps %xmm0,-0x30(%rbp) <
} else { } else {
mem::swap(tree, &mut child); mem::swap(tree, &mut child);
tree.link(index ^ 1, child); tree.link(index ^ 1, child);
7b38: 0f 28 45 d0 movaps -0x30(%rbp),%xmm0 | 7ad4: 48 89 4d c0 mov %rcx,-0x40(%rbp)
7b3c: 0f 29 45 90 movaps %xmm0,-0x70(%rbp) | 7ad8: 48 89 45 c8 mov %rax,-0x38(%rbp)
7b40: 45 31 e4 xor %r12d,%r12d | 7adc: 48 8d 55 c0 lea -0x40(%rbp),%rdx
7b43: 48 8d 55 90 lea -0x70(%rbp),%rdx |
7b47: 48 89 df mov %rbx,%rdi | if let Some(i) = tree.parent() {
7b4a: 4c 89 f6 mov %r14,%rsi | let t = tree.take(i).unwrap();
7b4d: e8 5e fd ff ff callq 78b0 <_ZN29_$LT$splay..Tree$LT | tree.link(i, child);
> tree.child(i);
> tree.link(index ^ 1, t);
> 7ae0: 48 89 df mov %rbx,%rdi
> 7ae3: 4c 89 f6 mov %r14,%rsi
> 7ae6: e8 c5 fd ff ff callq 78b0 <_ZN29_$LT$splay..Tree$LT
impl<T> Splay<T> where T: PartialOrd { impl<T> Splay<T> where T: PartialOrd {
fn new() -> Splay<T> { fn new() -> Splay<T> {
Splay { tree: None } Splay { tree: None }
} }
fn rotate(&self, tree: &mut Tree<T>, index: usize) { fn rotate(&self, tree: &mut Tree<T>, index: usize) {
7b52: 48 81 c4 90 00 00 00 add $0x90,%rsp | 7aeb: 48 83 c4 38 add $0x38,%rsp
7b59: 5b pop %rbx | 7aef: 5b pop %rbx
7b5a: 41 5c pop %r12 | 7af0: 41 5c pop %r12
7b5c: 41 5e pop %r14 | 7af2: 41 5d pop %r13
7b5e: 41 5f pop %r15 | 7af4: 41 5e pop %r14
7b60: 5d pop %rbp | 7af6: 41 5f pop %r15
7b61: c3 retq | 7af8: 5d pop %rbp
7b62: 45 31 e4 xor %r12d,%r12d | 7af9: c3 retq
} }
mem::forget(tree); mem::forget(tree);
} }
fn take(&mut self, index: usize) -> Option<Tree<T>> { fn take(&mut self, index: usize) -> Option<Tree<T>> {
let child = unsafe { (*self.node).children[index] }; let child = unsafe { (*self.node).children[index] };
7b65: 48 8d 3d 94 0e 25 00 lea 0x250e94(%rip),%rdi # 2 | 7afa: 48 8d 3d ff 0e 25 00 lea 0x250eff(%rip),%rdi # 2
7b6c: ba 02 00 00 00 mov $0x2,%edx | 7b01: ba 02 00 00 00 mov $0x2,%edx
7b71: e8 ca cb 03 00 callq 44740 <_ZN4core9panicking18pan | 7b06: e8 35 cb 03 00 callq 44640 <_ZN4core9panicking18pan
7b76: 45 31 e4 xor %r12d,%r12d | 7b0b: 48 8b 3d a6 22 25 00 mov 0x2522a6(%rip),%rdi # 2
7b79: 48 8b 3d 38 22 25 00 mov 0x252238(%rip),%rdi # 2 | 7b12: e8 b9 ca 03 00 callq 445d0 <_ZN4core9panicking5pani
7b80: e8 4b cb 03 00 callq 446d0 <_ZN4core9panicking5pani | 7b17: 48 8d 3d e2 0e 25 00 lea 0x250ee2(%rip),%rdi # 2
7b85: 41 b4 01 mov $0x1,%r12b | 7b1e: ba 02 00 00 00 mov $0x2,%edx
7b88: 48 8d 3d 71 0e 25 00 lea 0x250e71(%rip),%rdi # 2 | 7b23: 4c 89 f6 mov %r14,%rsi
7b8f: ba 02 00 00 00 mov $0x2,%edx | 7b26: e8 15 cb 03 00 callq 44640 <_ZN4core9panicking18pan
7b94: 4c 89 f6 mov %r14,%rsi | 7b2b: 48 8d 3d ce 0e 25 00 lea 0x250ece(%rip),%rdi # 2
7b97: e8 a4 cb 03 00 callq 44740 <_ZN4core9panicking18pan | 7b32: ba 02 00 00 00 mov $0x2,%edx
7b9c: 41 b4 01 mov $0x1,%r12b | 7b37: 4c 89 fe mov %r15,%rsi
7b9f: 48 8d 3d 5a 0e 25 00 lea 0x250e5a(%rip),%rdi # 2 | 7b3a: e8 01 cb 03 00 callq 44640 <_ZN4core9panicking18pan
7ba6: ba 02 00 00 00 mov $0x2,%edx | 7b3f: 48 8b 3d 72 22 25 00 mov 0x252272(%rip),%rdi # 2
7bab: 4c 89 fe mov %r15,%rsi | 7b46: e8 85 ca 03 00 callq 445d0 <_ZN4core9panicking5pani
7bae: e8 8d cb 03 00 callq 44740 <_ZN4core9panicking18pan | 7b4b: 90 nop
7bb3: 41 b4 01 mov $0x1,%r12b | 7b4c: 90 nop
7bb6: 48 8b 3d fb 21 25 00 mov 0x2521fb(%rip),%rdi # 2 | 7b4d: 90 nop
7bbd: e8 0e cb 03 00 callq 446d0 <_ZN4core9panicking5pani | 7b4e: 90 nop
7bc2: eb 00 jmp 7bc4 <_ZN30_$LT$splay..Splay$L | 7b4f: 90 nop
7bc4: 48 89 c3 mov %rax,%rbx <
fn new() -> Splay<T> { <
Splay { tree: None } <
} <
<
fn rotate(&self, tree: &mut Tree<T>, index: usize) { <
let mut child = tree.take(index).unwrap(); <
7bc7: 45 84 e4 test %r12b,%r12b <
7bca: 75 0e jne 7bda <_ZN30_$LT$splay..Splay$L <
7bcc: eb 15 jmp 7be3 <_ZN30_$LT$splay..Splay$L <
7bce: 48 89 c3 mov %rax,%rbx <
7bd1: 48 8d 7d a0 lea -0x60(%rbp),%rdi <
7bd5: eb 07 jmp 7bde <_ZN30_$LT$splay..Splay$L <
7bd7: 48 89 c3 mov %rax,%rbx <
7bda: 48 8d 7d d0 lea -0x30(%rbp),%rdi <
if let Some(grandchild) = child.take(index ^ 1) { <
tree.link(index, grandchild); <
} <
<
if let Some(i) = tree.parent() { <
let t = tree.take(i).unwrap(); <
7bde: e8 2d fc ff ff callq 7810 <_ZN4drop17hddf9fd0101172 <
7be3: 48 89 df mov %rbx,%rdi <
7be6: e8 95 fa ff ff callq 7680 <_Unwind_Resume@plt> <
7beb: 90 nop <
7bec: 90 nop <
7bed: 90 nop <
7bee: 90 nop <
7bef: 90 nop <
0000000000007bf0 <_ZN5splay4main17h7cf589df5d172d0bE>: | 0000000000007b50 <_ZN5splay4main17h7cf589df5d172d0bE>:
print(tree, depth + 1); print(tree, depth + 1);
tree.parent(); tree.parent();
} }
} }
fn main() { fn main() {
7bf0: 55 push %rbp | 7b50: 55 push %rbp
7bf1: 48 89 e5 mov %rsp,%rbp | 7b51: 48 89 e5 mov %rsp,%rbp
tree: Option<Tree<T>>, tree: Option<Tree<T>>,
} }
impl<T> Splay<T> where T: PartialOrd { impl<T> Splay<T> where T: PartialOrd {
fn new() -> Splay<T> { fn new() -> Splay<T> {
Splay { tree: None } Splay { tree: None }
7bf4: 41 57 push %r15 | 7b54: 41 57 push %r15
7bf6: 41 56 push %r14 | 7b56: 41 56 push %r14
7bf8: 41 55 push %r13 | 7b58: 41 55 push %r13
7bfa: 41 54 push %r12 | 7b5a: 41 54 push %r12
7bfc: 53 push %rbx | 7b5c: 53 push %rbx
7bfd: 48 81 ec 88 00 00 00 sub $0x88,%rsp | 7b5d: 48 83 ec 68 sub $0x68,%rsp
7c04: 48 c7 45 88 00 00 00 movq $0x0,-0x78(%rbp) | 7b61: 48 c7 45 88 00 00 00 movq $0x0,-0x78(%rbp)
7c0b: 00 | 7b68: 00
7c0c: 48 8d 5d 90 lea -0x70(%rbp),%rbx | 7b69: 48 8d 5d 90 lea -0x70(%rbp),%rbx
7c10: 41 bf 01 00 00 00 mov $0x1,%r15d | 7b6d: 41 bf 01 00 00 00 mov $0x1,%r15d
7c16: 31 c0 xor %eax,%eax | 7b73: 31 c0 xor %eax,%eax
7c18: 4c 8d 65 c0 lea -0x40(%rbp),%r12 | 7b75: 4c 8d 65 c0 lea -0x40(%rbp),%r12
7c1c: 41 be 01 00 00 00 mov $0x1,%r14d | 7b79: 41 be 01 00 00 00 mov $0x1,%r14d
7c22: 66 66 66 66 66 2e 0f data32 data32 data32 data32 nopw %cs: | 7b7f: 90 nop
7c29: 1f 84 00 00 00 00 00 | 7b80: 44 89 f1 mov %r14d,%ecx
7c30: 44 89 f1 mov %r14d,%ecx | 7b83: c1 e1 04 shl $0x4,%ecx
7c33: c1 e1 04 shl $0x4,%ecx | 7b86: 45 8d b4 0e ff 00 00 lea 0xff(%r14,%rcx,1),%r14d
7c36: 45 8d b4 0e ff 00 00 lea 0xff(%r14,%rcx,1),%r14d | 7b8d: 00
7c3d: 00 | 7b8e: 0f 10 03 movups (%rbx),%xmm0
7c3e: 0f 10 03 movups (%rbx),%xmm0 | 7b91: 0f 29 85 70 ff ff ff movaps %xmm0,-0x90(%rbp)
7c41: 0f 29 85 50 ff ff ff movaps %xmm0,-0xb0(%rbp) | 7b98: 48 c7 45 88 00 00 00 movq $0x0,-0x78(%rbp)
7c48: 48 c7 45 88 00 00 00 movq $0x0,-0x78(%rbp) | 7b9f: 00
7c4f: 00 <
} }
} }
fn insert(&mut self, value: T) { fn insert(&mut self, value: T) {
match self.tree.take() { match self.tree.take() {
None => self.tree = Some(Tree::new(value)), None => self.tree = Some(Tree::new(value)),
7c50: a8 01 test $0x1,%al | 7ba0: a8 01 test $0x1,%al
7c52: 0f 84 58 01 00 00 je 7db0 <_ZN5splay4main17h7cf589d | 7ba2: 0f 84 48 01 00 00 je 7cf0 <_ZN5splay4main17h7cf589d
Some(mut tree) => { Some(mut tree) => {
7c58: 0f 28 85 50 ff ff ff movaps -0xb0(%rbp),%xmm0 | 7ba8: 0f 28 85 70 ff ff ff movaps -0x90(%rbp),%xmm0
7c5f: 0f 29 45 c0 movaps %xmm0,-0x40(%rbp) | 7baf: 0f 29 45 c0 movaps %xmm0,-0x40(%rbp)
Some(Tree { node: child }) Some(Tree { node: child })
} }
} }
fn value(&mut self) -> &mut T { fn value(&mut self) -> &mut T {
unsafe { &mut (*self.node).value } unsafe { &mut (*self.node).value }
7c63: 4c 8b 6d c0 mov -0x40(%rbp),%r13 | 7bb3: 4c 8b 6d c0 mov -0x40(%rbp),%r13
fn insert(&mut self, value: T) { fn insert(&mut self, value: T) {
match self.tree.take() { match self.tree.take() {
None => self.tree = Some(Tree::new(value)), None => self.tree = Some(Tree::new(value)),
Some(mut tree) => { Some(mut tree) => {
loop { loop {
let index = if value < *tree.value() { 0 } else { 1 }; let index = if value < *tree.value() { 0 } else { 1 };
7c67: 31 db xor %ebx,%ebx | 7bb7: 31 db xor %ebx,%ebx
7c69: 45 39 75 20 cmp %r14d,0x20(%r13) | 7bb9: 45 39 75 20 cmp %r14d,0x20(%r13)
7c6d: 0f 96 c3 setbe %bl | 7bbd: 0f 96 c3 setbe %bl
Some(index) Some(index)
} }
} }
fn child(&mut self, index: usize) -> bool { fn child(&mut self, index: usize) -> bool {
let child = unsafe { (*self.node).children[index] }; let child = unsafe { (*self.node).children[index] };
7c70: 49 8b 44 dd 10 mov 0x10(%r13,%rbx,8),%rax | 7bc0: 49 8b 44 dd 10 mov 0x10(%r13,%rbx,8),%rax
None => self.tree = Some(Tree::new(value)), None => self.tree = Some(Tree::new(value)),
Some(mut tree) => { Some(mut tree) => {
loop { loop {
let index = if value < *tree.value() { 0 } else { 1 }; let index = if value < *tree.value() { 0 } else { 1 };
if !tree.child(index) { if !tree.child(index) {
7c75: 48 85 c0 test %rax,%rax | 7bc5: 48 85 c0 test %rax,%rax
7c78: 74 20 je 7c9a <_ZN5splay4main17h7cf589d | 7bc8: 74 20 je 7bea <_ZN5splay4main17h7cf589d
7c7a: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) | 7bca: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1)
let mut splay = Splay::new(); let mut splay = Splay::new();
let mut num = 1u32; let mut num = 1u32;
for _ in 0..1000000 { for _ in 0..1000000 {
num = num.wrapping_mul(17).wrapping_add(255); num = num.wrapping_mul(17).wrapping_add(255);
splay.insert(num); splay.insert(num);
7c80: 49 89 c5 mov %rax,%r13 | 7bd0: 49 89 c5 mov %rax,%r13
fn insert(&mut self, value: T) { fn insert(&mut self, value: T) {
match self.tree.take() { match self.tree.take() {
None => self.tree = Some(Tree::new(value)), None => self.tree = Some(Tree::new(value)),
Some(mut tree) => { Some(mut tree) => {
loop { loop {
let index = if value < *tree.value() { 0 } else { 1 }; let index = if value < *tree.value() { 0 } else { 1 };
7c83: 31 db xor %ebx,%ebx | 7bd3: 31 db xor %ebx,%ebx
7c85: 45 39 75 20 cmp %r14d,0x20(%r13) | 7bd5: 45 39 75 20 cmp %r14d,0x20(%r13)
7c89: 0f 96 c3 setbe %bl | 7bd9: 0f 96 c3 setbe %bl
Some(index) Some(index)
} }
} }
fn child(&mut self, index: usize) -> bool { fn child(&mut self, index: usize) -> bool {
let child = unsafe { (*self.node).children[index] }; let child = unsafe { (*self.node).children[index] };
7c8c: 49 8b 44 dd 10 mov 0x10(%r13,%rbx,8),%rax | 7bdc: 49 8b 44 dd 10 mov 0x10(%r13,%rbx,8),%rax
if child == ptr::null_mut() { if child == ptr::null_mut() {
7c91: 48 85 c0 test %rax,%rax | 7be1: 48 85 c0 test %rax,%rax
7c94: 75 ea jne 7c80 <_ZN5splay4main17h7cf589d | 7be4: 75 ea jne 7bd0 <_ZN5splay4main17h7cf589d
false false
} else { } else {
self.node = child; self.node = child;
7c96: 4c 89 6d c0 mov %r13,-0x40(%rbp) | 7be6: 4c 89 6d c0 mov %r13,-0x40(%rbp)
7c9a: 0f 57 c0 xorps %xmm0,%xmm0 | 7bea: 0f 57 c0 xorps %xmm0,%xmm0
7c9d: 0f 29 45 a0 movaps %xmm0,-0x60(%rbp) | 7bed: 0f 29 45 a0 movaps %xmm0,-0x60(%rbp)
7ca1: 48 c7 45 b0 00 00 00 movq $0x0,-0x50(%rbp) | 7bf1: 48 c7 45 b0 00 00 00 movq $0x0,-0x50(%rbp)
7ca8: 00 | 7bf8: 00
7ca9: bf 28 00 00 00 mov $0x28,%edi | 7bf9: bf 28 00 00 00 mov $0x28,%edi
7cae: be 08 00 00 00 mov $0x8,%esi | 7bfe: be 08 00 00 00 mov $0x8,%esi
7cb3: e8 28 0d 01 00 callq 189e0 <__rust_allocate> | 7c03: e8 d8 0c 01 00 callq 188e0 <__rust_allocate>
7cb8: 48 85 c0 test %rax,%rax | 7c08: 48 85 c0 test %rax,%rax
7cbb: 0f 84 d8 01 00 00 je 7e99 <_ZN5splay4main17h7cf589d | 7c0b: 0f 84 b9 01 00 00 je 7dca <_ZN5splay4main17h7cf589d
7cc1: 48 c7 00 ff ff ff ff movq $0xffffffffffffffff,(%rax) | 7c11: 48 c7 00 ff ff ff ff movq $0xffffffffffffffff,(%rax)
7cc8: 48 8b 4d b0 mov -0x50(%rbp),%rcx | 7c18: 48 8b 4d b0 mov -0x50(%rbp),%rcx
7ccc: 48 89 48 18 mov %rcx,0x18(%rax) | 7c1c: 48 89 48 18 mov %rcx,0x18(%rax)
7cd0: 0f 28 45 a0 movaps -0x60(%rbp),%xmm0 | 7c20: 0f 28 45 a0 movaps -0x60(%rbp),%xmm0
7cd4: 0f 11 40 08 movups %xmm0,0x8(%rax) | 7c24: 0f 11 40 08 movups %xmm0,0x8(%rax)
7cd8: 44 89 70 20 mov %r14d,0x20(%rax) | 7c28: 44 89 70 20 mov %r14d,0x20(%rax)
node: *mut Node<T>, node: *mut Node<T>,
} }
impl<T> Tree<T> { impl<T> Tree<T> {
fn new(value: T) -> Tree<T> { fn new(value: T) -> Tree<T> {
Tree { node: Box::into_raw(Box::new(Node::new(value))) } Tree { node: Box::into_raw(Box::new(Node::new(value))) }
7cdc: c6 45 80 d4 movb $0xd4,-0x80(%rbp) | 7c2c: c6 45 a8 d4 movb $0xd4,-0x58(%rbp)
7ce0: 48 89 85 78 ff ff ff mov %rax,-0x88(%rbp) | 7c30: 48 89 45 a0 mov %rax,-0x60(%rbp)
Some(mut tree) => { Some(mut tree) => {
loop { loop {
let index = if value < *tree.value() { 0 } else { 1 }; let index = if value < *tree.value() { 0 } else { 1 };
if !tree.child(index) { if !tree.child(index) {
tree.link(index, Tree::new(value)); tree.link(index, Tree::new(value));
7ce7: 4c 89 e7 mov %r12,%rdi | 7c34: 4c 89 e7 mov %r12,%rdi
7cea: 48 89 de mov %rbx,%rsi | 7c37: 48 89 de mov %rbx,%rsi
7ced: 48 8d 95 78 ff ff ff lea -0x88(%rbp),%rdx | 7c3a: 48 8d 55 a0 lea -0x60(%rbp),%rdx
7cf4: e8 b7 fb ff ff callq 78b0 <_ZN29_$LT$splay..Tree$LT | 7c3e: e8 6d fc ff ff callq 78b0 <_ZN29_$LT$splay..Tree$LT
Some(index) Some(index)
} }
} }
fn child(&mut self, index: usize) -> bool { fn child(&mut self, index: usize) -> bool {
let child = unsafe { (*self.node).children[index] }; let child = unsafe { (*self.node).children[index] };
7cf9: 49 8b 44 dd 10 mov 0x10(%r13,%rbx,8),%rax | 7c43: 49 8b 44 dd 10 mov 0x10(%r13,%rbx,8),%rax
loop { loop {
let index = if value < *tree.value() { 0 } else { 1 }; let index = if value < *tree.value() { 0 } else { 1 };
if !tree.child(index) { if !tree.child(index) {
tree.link(index, Tree::new(value)); tree.link(index, Tree::new(value));
tree.child(index); tree.child(index);
7cfe: 48 85 c0 test %rax,%rax | 7c48: 48 85 c0 test %rax,%rax
7d01: 74 11 je 7d14 <_ZN5splay4main17h7cf589d | 7c4b: 74 1c je 7c69 <_ZN5splay4main17h7cf589d
fn child(&mut self, index: usize) -> bool { fn child(&mut self, index: usize) -> bool {
let child = unsafe { (*self.node).children[index] }; let child = unsafe { (*self.node).children[index] };
if child == ptr::null_mut() { if child == ptr::null_mut() {
false false
} else { } else {
self.node = child; self.node = child;
7d03: 48 89 45 c0 mov %rax,-0x40(%rbp) | 7c4d: 48 89 45 c0 mov %rax,-0x40(%rbp)
fn new(value: T) -> Tree<T> { fn new(value: T) -> Tree<T> {
Tree { node: Box::into_raw(Box::new(Node::new(value))) } Tree { node: Box::into_raw(Box::new(Node::new(value))) }
} }
fn parent(&mut self) -> Option<usize> { fn parent(&mut self) -> Option<usize> {
let parent = unsafe { (*self.node).parent }; let parent = unsafe { (*self.node).parent };
7d07: 49 89 c5 mov %rax,%r13 | 7c51: 49 89 c5 mov %rax,%r13
7d0a: eb 08 jmp 7d14 <_ZN5splay4main17h7cf589d | 7c54: eb 13 jmp 7c69 <_ZN5splay4main17h7cf589d
7d0c: 0f 1f 40 00 nopl 0x0(%rax) | 7c56: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
7d10: 4c 8b 6d c0 mov -0x40(%rbp),%r13 | 7c5d: 00 00 00
7d14: 49 8b 45 08 mov 0x8(%r13),%rax | Some(index) => index,
> };
>
> if i1 == i2 {
> self.rotate(tree, i2);
> self.rotate(tree, i1);
> 7c60: e8 1b fd ff ff callq 7980 <_ZN30_$LT$splay..Splay$L
> fn new(value: T) -> Tree<T> {
> Tree { node: Box::into_raw(Box::new(Node::new(value))) }
> }
>
> fn parent(&mut self) -> Option<usize> {
> let parent = unsafe { (*self.node).parent };
> 7c65: 4c 8b 6d c0 mov -0x40(%rbp),%r13
> 7c69: 49 8b 45 08 mov 0x8(%r13),%rax
} }
} }
fn splay(&self, mut tree: &mut Tree<T>) { fn splay(&self, mut tree: &mut Tree<T>) {
loop { loop {
let i1 = match tree.parent() { let i1 = match tree.parent() {
7d18: 48 85 c0 test %rax,%rax | 7c6d: 48 85 c0 test %rax,%rax
7d1b: 0f 84 0e 01 00 00 je 7e2f <_ZN5splay4main17h7cf589d | 7c70: 0f 84 ed 00 00 00 je 7d63 <_ZN5splay4main17h7cf589d
fn parent(&mut self) -> Option<usize> { fn parent(&mut self) -> Option<usize> {
let parent = unsafe { (*self.node).parent }; let parent = unsafe { (*self.node).parent };
if parent == ptr::null_mut() { if parent == ptr::null_mut() {
None None
} else { } else {
let index = unsafe { (*self.node).index }; let index = unsafe { (*self.node).index };
7d21: 49 8b 5d 00 mov 0x0(%r13),%rbx | 7c76: 49 8b 5d 00 mov 0x0(%r13),%rbx
self.node = parent; self.node = parent;
7d25: 48 89 45 c0 mov %rax,-0x40(%rbp) | 7c7a: 48 89 45 c0 mov %rax,-0x40(%rbp)
Some(index) Some(index)
} }
} }
fn child(&mut self, index: usize) -> bool { fn child(&mut self, index: usize) -> bool {
let child = unsafe { (*self.node).children[index] }; let child = unsafe { (*self.node).children[index] };
7d29: 48 8b 48 08 mov 0x8(%rax),%rcx | 7c7e: 48 8b 48 08 mov 0x8(%rax),%rcx
Tree { node: Box::into_raw(Box::new(Node::new(value))) } Tree { node: Box::into_raw(Box::new(Node::new(value))) }
} }
fn parent(&mut self) -> Option<usize> { fn parent(&mut self) -> Option<usize> {
let parent = unsafe { (*self.node).parent }; let parent = unsafe { (*self.node).parent };
if parent == ptr::null_mut() { if parent == ptr::null_mut() {
7d2d: 48 85 c9 test %rcx,%rcx | 7c82: 48 85 c9 test %rcx,%rcx
7d30: 0f 84 ee 00 00 00 je 7e24 <_ZN5splay4main17h7cf589d | 7c85: 0f 84 cd 00 00 00 je 7d58 <_ZN5splay4main17h7cf589d
None None
} else { } else {
let index = unsafe { (*self.node).index }; let index = unsafe { (*self.node).index };
7d36: 4c 8b 28 mov (%rax),%r13 | 7c8b: 4c 8b 28 mov (%rax),%r13
self.node = parent; self.node = parent;
7d39: 48 89 4d c0 mov %rcx,-0x40(%rbp) | 7c8e: 48 89 4d c0 mov %rcx,-0x40(%rbp)
break; break;
}, },
Some(index) => index, Some(index) => index,
}; };
if i1 == i2 { if i1 == i2 {
7d3d: 4c 39 eb cmp %r13,%rbx | 7c92: 4c 39 eb cmp %r13,%rbx
7d40: 75 1e jne 7d60 <_ZN5splay4main17h7cf589d | 7c95: 75 19 jne 7cb0 <_ZN5splay4main17h7cf589d
self.rotate(tree, i2); self.rotate(tree, i2);
7d42: 4c 89 e7 mov %r12,%rdi | 7c97: 4c 89 e7 mov %r12,%rdi
7d45: 48 89 de mov %rbx,%rsi | 7c9a: 48 89 de mov %rbx,%rsi
7d48: e8 63 fc ff ff callq 79b0 <_ZN30_$LT$splay..Splay$L | 7c9d: e8 de fc ff ff callq 7980 <_ZN30_$LT$splay..Splay$L
self.rotate(tree, i1); self.rotate(tree, i1);
7d4d: 4c 89 e7 mov %r12,%rdi | 7ca2: 4c 89 e7 mov %r12,%rdi
7d50: 48 89 de mov %rbx,%rsi | 7ca5: 48 89 de mov %rbx,%rsi
7d53: e8 58 fc ff ff callq 79b0 <_ZN30_$LT$splay..Splay$L | 7ca8: eb b6 jmp 7c60 <_ZN5splay4main17h7cf589d
7d58: eb b6 jmp 7d10 <_ZN5splay4main17h7cf589d | 7caa: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1)
7d5a: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) <
Some(index) Some(index)
} }
} }
fn child(&mut self, index: usize) -> bool { fn child(&mut self, index: usize) -> bool {
let child = unsafe { (*self.node).children[index] }; let child = unsafe { (*self.node).children[index] };
7d60: 49 83 fd 01 cmp $0x1,%r13 | 7cb0: 49 83 fd 01 cmp $0x1,%r13
7d64: 0f 87 1b 01 00 00 ja 7e85 <_ZN5splay4main17h7cf589d | 7cb4: 0f 87 fc 00 00 00 ja 7db6 <_ZN5splay4main17h7cf589d
7d6a: 4a 8b 44 e9 10 mov 0x10(%rcx,%r13,8),%rax | 7cba: 4a 8b 44 e9 10 mov 0x10(%rcx,%r13,8),%rax
if i1 == i2 { if i1 == i2 {
self.rotate(tree, i2); self.rotate(tree, i2);
self.rotate(tree, i1); self.rotate(tree, i1);
} else { } else {
tree.child(i2); tree.child(i2);
7d6f: 48 85 c0 test %rax,%rax | 7cbf: 48 85 c0 test %rax,%rax
7d72: 74 04 je 7d78 <_ZN5splay4main17h7cf589d | 7cc2: 74 04 je 7cc8 <_ZN5splay4main17h7cf589d
fn child(&mut self, index: usize) -> bool { fn child(&mut self, index: usize) -> bool {
let child = unsafe { (*self.node).children[index] }; let child = unsafe { (*self.node).children[index] };
if child == ptr::null_mut() { if child == ptr::null_mut() {
false false
} else { } else {
self.node = child; self.node = child;
7d74: 48 89 45 c0 mov %rax,-0x40(%rbp) | 7cc4: 48 89 45 c0 mov %rax,-0x40(%rbp)
if i1 == i2 { if i1 == i2 {
self.rotate(tree, i2); self.rotate(tree, i2);
self.rotate(tree, i1); self.rotate(tree, i1);
} else { } else {
tree.child(i2); tree.child(i2);
self.rotate(tree, i1); self.rotate(tree, i1);
7d78: 4c 89 e7 mov %r12,%rdi | 7cc8: 4c 89 e7 mov %r12,%rdi
7d7b: 48 89 de mov %rbx,%rsi | 7ccb: 48 89 de mov %rbx,%rsi
7d7e: e8 2d fc ff ff callq 79b0 <_ZN30_$LT$splay..Splay$L | 7cce: e8 ad fc ff ff callq 7980 <_ZN30_$LT$splay..Splay$L
fn new(value: T) -> Tree<T> { fn new(value: T) -> Tree<T> {
Tree { node: Box::into_raw(Box::new(Node::new(value))) } Tree { node: Box::into_raw(Box::new(Node::new(value))) }
} }
fn parent(&mut self) -> Option<usize> { fn parent(&mut self) -> Option<usize> {
let parent = unsafe { (*self.node).parent }; let parent = unsafe { (*self.node).parent };
7d83: 48 8b 45 c0 mov -0x40(%rbp),%rax | 7cd3: 48 8b 45 c0 mov -0x40(%rbp),%rax
7d87: 48 8b 40 08 mov 0x8(%rax),%rax | 7cd7: 48 8b 40 08 mov 0x8(%rax),%rax
self.rotate(tree, i2); self.rotate(tree, i2);
self.rotate(tree, i1); self.rotate(tree, i1);
} else { } else {
tree.child(i2); tree.child(i2);
self.rotate(tree, i1); self.rotate(tree, i1);
tree.parent(); tree.parent();
7d8b: 48 85 c0 test %rax,%rax | 7cdb: 48 85 c0 test %rax,%rax
7d8e: 74 04 je 7d94 <_ZN5splay4main17h7cf589d | 7cde: 74 04 je 7ce4 <_ZN5splay4main17h7cf589d
let parent = unsafe { (*self.node).parent }; let parent = unsafe { (*self.node).parent };
if parent == ptr::null_mut() { if parent == ptr::null_mut() {
None None
} else { } else {
let index = unsafe { (*self.node).index }; let index = unsafe { (*self.node).index };
self.node = parent; self.node = parent;
7d90: 48 89 45 c0 mov %rax,-0x40(%rbp) | 7ce0: 48 89 45 c0 mov %rax,-0x40(%rbp)
self.rotate(tree, i1); self.rotate(tree, i1);
} else { } else {
tree.child(i2); tree.child(i2);
self.rotate(tree, i1); self.rotate(tree, i1);
tree.parent(); tree.parent();
self.rotate(tree, i2); self.rotate(tree, i2);
7d94: 4c 89 e7 mov %r12,%rdi | 7ce4: 4c 89 e7 mov %r12,%rdi
7d97: 4c 89 ee mov %r13,%rsi | 7ce7: 4c 89 ee mov %r13,%rsi
7d9a: e8 11 fc ff ff callq 79b0 <_ZN30_$LT$splay..Splay$L | 7cea: e9 71 ff ff ff jmpq 7c60 <_ZN5splay4main17h7cf589d
7d9f: e9 6c ff ff ff jmpq 7d10 <_ZN5splay4main17h7cf589d | 7cef: 90 nop
7da4: 66 66 66 2e 0f 1f 84 data32 data32 nopw %cs:0x0(%rax,%rax, | 7cf0: 0f 57 c0 xorps %xmm0,%xmm0
7dab: 00 00 00 00 00 | 7cf3: 0f 29 45 a0 movaps %xmm0,-0x60(%rbp)
7db0: 0f 57 c0 xorps %xmm0,%xmm0 | 7cf7: 48 c7 45 b0 00 00 00 movq $0x0,-0x50(%rbp)
7db3: 0f 29 85 60 ff ff ff movaps %xmm0,-0xa0(%rbp) | 7cfe: 00
7dba: 48 c7 85 70 ff ff ff movq $0x0,-0x90(%rbp) | 7cff: bf 28 00 00 00 mov $0x28,%edi
7dc1: 00 00 00 00 | 7d04: be 08 00 00 00 mov $0x8,%esi
7dc5: bf 28 00 00 00 mov $0x28,%edi | 7d09: e8 d2 0b 01 00 callq 188e0 <__rust_allocate>
7dca: be 08 00 00 00 mov $0x8,%esi | 7d0e: 48 85 c0 test %rax,%rax
7dcf: e8 0c 0c 01 00 callq 189e0 <__rust_allocate> | 7d11: 0f 84 b3 00 00 00 je 7dca <_ZN5splay4main17h7cf589d
7dd4: 48 85 c0 test %rax,%rax | 7d17: 48 c7 00 ff ff ff ff movq $0xffffffffffffffff,(%rax)
7dd7: 0f 84 c1 00 00 00 je 7e9e <_ZN5splay4main17h7cf589d | 7d1e: 48 8b 4d b0 mov -0x50(%rbp),%rcx
7ddd: 48 c7 00 ff ff ff ff movq $0xffffffffffffffff,(%rax) | 7d22: 48 89 48 18 mov %rcx,0x18(%rax)
7de4: 48 8b 8d 70 ff ff ff mov -0x90(%rbp),%rcx | 7d26: 0f 28 45 a0 movaps -0x60(%rbp),%xmm0
7deb: 48 89 48 18 mov %rcx,0x18(%rax) | 7d2a: 0f 11 40 08 movups %xmm0,0x8(%rax)
7def: 0f 28 85 60 ff ff ff movaps -0xa0(%rbp),%xmm0 | 7d2e: 44 89 70 20 mov %r14d,0x20(%rax)
7df6: 0f 11 40 08 movups %xmm0,0x8(%rax) <
7dfa: 44 89 70 20 mov %r14d,0x20(%rax) <
} }
} }
fn insert(&mut self, value: T) { fn insert(&mut self, value: T) {
match self.tree.take() { match self.tree.take() {
None => self.tree = Some(Tree::new(value)), None => self.tree = Some(Tree::new(value)),
7dfe: 48 c7 45 88 01 00 00 movq $0x1,-0x78(%rbp) | 7d32: 48 c7 45 88 01 00 00 movq $0x1,-0x78(%rbp)
7e05: 00 | 7d39: 00
7e06: 48 89 45 90 mov %rax,-0x70(%rbp) | 7d3a: 48 89 45 90 mov %rax,-0x70(%rbp)
7e0a: c6 45 98 d4 movb $0xd4,-0x68(%rbp) | 7d3e: c6 45 98 d4 movb $0xd4,-0x68(%rbp)
7e0e: 8a 45 a6 mov -0x5a(%rbp),%al | 7d42: 8a 45 a6 mov -0x5a(%rbp),%al
7e11: 88 43 0f mov %al,0xf(%rbx) | 7d45: 88 43 0f mov %al,0xf(%rbx)
7e14: 0f b7 45 a4 movzwl -0x5c(%rbp),%eax | 7d48: 0f b7 45 a4 movzwl -0x5c(%rbp),%eax
7e18: 66 89 43 0d mov %ax,0xd(%rbx) | 7d4c: 66 89 43 0d mov %ax,0xd(%rbx)
7e1c: 8b 45 a0 mov -0x60(%rbp),%eax | 7d50: 8b 45 a0 mov -0x60(%rbp),%eax
7e1f: 89 43 09 mov %eax,0x9(%rbx) | 7d53: 89 43 09 mov %eax,0x9(%rbx)
7e22: eb 26 jmp 7e4a <_ZN5splay4main17h7cf589d | 7d56: eb 26 jmp 7d7e <_ZN5splay4main17h7cf589d
None => break, None => break,
Some(index) => index, Some(index) => index,
}; };
let i2 = match tree.parent() { let i2 = match tree.parent() {
None => { None => {
self.rotate(tree, i1); self.rotate(tree, i1);
7e24: 4c 89 e7 mov %r12,%rdi | 7d58: 4c 89 e7 mov %r12,%rdi
7e27: 48 89 de mov %rbx,%rsi | 7d5b: 48 89 de mov %rbx,%rsi
7e2a: e8 81 fb ff ff callq 79b0 <_ZN30_$LT$splay..Splay$L | 7d5e: e8 1d fc ff ff callq 7980 <_ZN30_$LT$splay..Splay$L
if !tree.child(index) { if !tree.child(index) {
tree.link(index, Tree::new(value)); tree.link(index, Tree::new(value));
tree.child(index); tree.child(index);
self.splay(&mut tree); self.splay(&mut tree);
self.tree = Some(tree); self.tree = Some(tree);
7e2f: 0f 28 45 c0 movaps -0x40(%rbp),%xmm0 | 7d63: 0f 28 45 c0 movaps -0x40(%rbp),%xmm0
7e33: 0f 29 45 a0 movaps %xmm0,-0x60(%rbp) | 7d67: 0f 29 45 a0 movaps %xmm0,-0x60(%rbp)
7e37: 48 c7 45 88 01 00 00 movq $0x1,-0x78(%rbp) | 7d6b: 48 c7 45 88 01 00 00 movq $0x1,-0x78(%rbp)
7e3e: 00 | 7d72: 00
7e3f: 0f 28 45 a0 movaps -0x60(%rbp),%xmm0 | 7d73: 0f 28 45 a0 movaps -0x60(%rbp),%xmm0
7e43: 48 8d 5d 90 lea -0x70(%rbp),%rbx | 7d77: 48 8d 5d 90 lea -0x70(%rbp),%rbx
7e47: 0f 11 03 movups %xmm0,(%rbx) | 7d7b: 0f 11 03 movups %xmm0,(%rbx)
7e4a: 31 c9 xor %ecx,%ecx | 7d7e: 31 c9 xor %ecx,%ecx
7e4c: 41 81 ff 40 42 0f 00 cmp $0xf4240,%r15d | 7d80: 41 81 ff 40 42 0f 00 cmp $0xf4240,%r15d
7e53: 0f 9c c1 setl %cl | 7d87: 0f 9c c1 setl %cl
7e56: 44 01 f9 add %r15d,%ecx | 7d8a: 44 01 f9 add %r15d,%ecx
7e59: 41 81 ff 40 42 0f 00 cmp $0xf4240,%r15d | 7d8d: 41 81 ff 40 42 0f 00 cmp $0xf4240,%r15d
7e60: b0 01 mov $0x1,%al | 7d94: b0 01 mov $0x1,%al
7e62: 41 89 cf mov %ecx,%r15d | 7d96: 41 89 cf mov %ecx,%r15d
7e65: 0f 8c c5 fd ff ff jl 7c30 <_ZN5splay4main17h7cf589d | 7d99: 0f 8c e1 fd ff ff jl 7b80 <_ZN5splay4main17h7cf589d
tree.parent(); tree.parent();
} }
} }
fn main() { fn main() {
let mut splay = Splay::new(); let mut splay = Splay::new();
7e6b: 48 89 df mov %rbx,%rdi | 7d9f: 48 89 df mov %rbx,%rdi
7e6e: e8 9d f9 ff ff callq 7810 <_ZN4drop17hddf9fd0101172 | 7da2: e8 69 fa ff ff callq 7810 <_ZN4drop17hddf9fd0101172
print(tree, depth + 1); print(tree, depth + 1);
tree.parent(); tree.parent();
} }
} }
fn main() { fn main() {
7e73: 48 81 c4 88 00 00 00 add $0x88,%rsp | 7da7: 48 83 c4 68 add $0x68,%rsp
7e7a: 5b pop %rbx | 7dab: 5b pop %rbx
7e7b: 41 5c pop %r12 | 7dac: 41 5c pop %r12
7e7d: 41 5d pop %r13 | 7dae: 41 5d pop %r13
7e7f: 41 5e pop %r14 | 7db0: 41 5e pop %r14
7e81: 41 5f pop %r15 | 7db2: 41 5f pop %r15
7e83: 5d pop %rbp | 7db4: 5d pop %rbp
7e84: c3 retq | 7db5: c3 retq
Some(index) Some(index)
} }
} }
fn child(&mut self, index: usize) -> bool { fn child(&mut self, index: usize) -> bool {
let child = unsafe { (*self.node).children[index] }; let child = unsafe { (*self.node).children[index] };
7e85: 48 8d 3d 04 0b 25 00 lea 0x250b04(%rip),%rdi # 2 | 7db6: 48 8d 3d d3 0b 25 00 lea 0x250bd3(%rip),%rdi # 2
7e8c: ba 02 00 00 00 mov $0x2,%edx | 7dbd: ba 02 00 00 00 mov $0x2,%edx
7e91: 4c 89 ee mov %r13,%rsi | 7dc2: 4c 89 ee mov %r13,%rsi
7e94: e8 a7 c8 03 00 callq 44740 <_ZN4core9panicking18pan | 7dc5: e8 76 c8 03 00 callq 44640 <_ZN4core9panicking18pan
7e99: e8 22 0b 01 00 callq 189c0 <_ZN5alloc3oom3oom17hf03 | 7dca: e8 f1 0a 01 00 callq 188c0 <_ZN5alloc3oom3oom17hf03
7e9e: e8 1d 0b 01 00 callq 189c0 <_ZN5alloc3oom3oom17hf03 | 7dcf: 90 nop
7ea3: eb 02 jmp 7ea7 <_ZN5splay4main17h7cf589d |
7ea5: eb 07 jmp 7eae <_ZN5splay4main17h7cf589d | 0000000000007dd0 <main>:
7ea7: 48 89 c3 mov %rax,%rbx | 7dd0: 48 89 f0 mov %rsi,%rax
7eaa: eb 0e jmp 7eba <_ZN5splay4main17h7cf589d | 7dd3: 48 89 f9 mov %rdi,%rcx
7eac: eb 00 jmp 7eae <_ZN5splay4main17h7cf589d | 7dd6: 8a 15 76 44 04 00 mov 0x44476(%rip),%dl # 4c2
7eae: 48 89 c3 mov %rax,%rbx | 7ddc: 48 8d 3d 6d fd ff ff lea -0x293(%rip),%rdi # 7b5
} | 7de3: 48 89 ce mov %rcx,%rsi
| 7de6: 48 89 c2 mov %rax,%rdx
fn insert(&mut self, value: T) { | 7de9: e9 82 5b 00 00 jmpq d970 <_ZN3std2rt10lang_start17
match self.tree.take() { | 7dee: 90 nop
None => self.tree = Some(Tree::new(value)), | 7def: 90 nop
Some(mut tree) => { |
7eb1: 48 8d 7d c0 lea -0x40(%rbp),%rdi | 0000000000007df0 <_ZN33_$LT$alloc..arc..Arc$LT$T$GT$$GT$9drop_slow17h7a70bfb0
7eb5: e8 56 f9 ff ff callq 7810 <_ZN4drop17hddf9fd0101172 | 7df0: 41 56 push %r14
7eba: 48 89 df mov %rbx,%rdi | 7df2: 53 push %rbx
7ebd: e8 be f7 ff ff callq 7680 <_Unwind_Resume@plt> | 7df3: 50 push %rax
7ec2: eb e3 jmp 7ea7 <_ZN5splay4main17h7cf589d | 7df4: 48 89 fb mov %rdi,%rbx
7ec4: 90 nop | 7df7: 4c 8b 33 mov (%rbx),%r14
7ec5: 90 nop | 7dfa: 49 8d 7e 10 lea 0x10(%r14),%rdi
7ec6: 90 nop | 7dfe: e8 dd 08 00 00 callq 86e0 <_ZN4drop17h22c4e095070aa
7ec7: 90 nop | 7e03: 48 8b 03 mov (%rbx),%rax
7ec8: 90 nop | 7e06: 48 c7 c1 ff ff ff ff mov $0xffffffffffffffff,%rcx
7ec9: 90 nop | 7e0d: f0 48 0f c1 48 08 lock xadd %rcx,0x8(%rax)
7eca: 90 nop | 7e13: 48 83 f9 01 cmp $0x1,%rcx
7ecb: 90 nop | 7e17: 75 19 jne 7e32 <_ZN33_$LT$alloc..arc..Ar
7ecc: 90 nop | 7e19: be 48 00 00 00 mov $0x48,%esi
7ecd: 90 nop | 7e1e: ba 08 00 00 00 mov $0x8,%edx
7ece: 90 nop | 7e23: 4c 89 f7 mov %r14,%rdi
7ecf: 90 nop | 7e26: 48 83 c4 08 add $0x8,%rsp
| 7e2a: 5b pop %rbx
0000000000007ed0 <main>: | 7e2b: 41 5e pop %r14
7ed0: 48 89 f0 mov %rsi,%rax | 7e2d: e9 ee 0a 01 00 jmpq 18920 <__rust_deallocate>
7ed3: 48 89 f9 mov %rdi,%rcx | 7e32: 48 83 c4 08 add $0x8,%rsp
7ed6: 8a 15 76 44 04 00 mov 0x44476(%rip),%dl # 4c3 | 7e36: 5b pop %rbx
7edc: 48 8d 3d 0d fd ff ff lea -0x2f3(%rip),%rdi # 7bf | 7e37: 41 5e pop %r14
7ee3: 48 89 ce mov %rcx,%rsi | 7e39: c3 retq
7ee6: 48 89 c2 mov %rax,%rdx | 7e3a: 90 nop
7ee9: e9 82 5b 00 00 jmpq da70 <_ZN3std2rt10lang_start17 | 7e3b: 90 nop
7eee: 90 nop | 7e3c: 90 nop
7eef: 90 nop | 7e3d: 90 nop
| 7e3e: 90 nop
0000000000007ef0 <_ZN33_$LT$alloc..arc..Arc$LT$T$GT$$GT$9drop_slow17h7a70bfb0 | 7e3f: 90 nop
7ef0: 41 56 push %r14 |
7ef2: 53 push %rbx | 0000000000007e40 <_ZN36_$LT$T$u20$as$u20$core..any..Any$GT$11get_type_id17h71
7ef3: 50 push %rax | 7e40: 48 b8 f1 af 77 9d 3b movabs $0xca56ac3b9d77aff1,%rax
7ef4: 48 89 fb mov %rdi,%rbx | 7e47: ac 56 ca
7ef7: 4c 8b 33 mov (%rbx),%r14 | 7e4a: c3 retq
7efa: 49 8d 7e 10 lea 0x10(%r14),%rdi | 7e4b: 90 nop
7efe: e8 dd 08 00 00 callq 87e0 <_ZN4drop17h22c4e095070aa | 7e4c: 90 nop
7f03: 48 8b 03 mov (%rbx),%rax | 7e4d: 90 nop
7f06: 48 c7 c1 ff ff ff ff mov $0xffffffffffffffff,%rcx | 7e4e: 90 nop
7f0d: f0 48 0f c1 48 08 lock xadd %rcx,0x8(%rax) | 7e4f: 90 nop
7f13: 48 83 f9 01 cmp $0x1,%rcx |
7f17: 75 19 jne 7f32 <_ZN33_$LT$alloc..arc..Ar | 0000000000007e50 <_ZN36_$LT$T$u20$as$u20$core..any..Any$GT$11get_type_id17h8c
7f19: be 48 00 00 00 mov $0x48,%esi | 7e50: 48 b8 4b 99 a9 5b e8 movabs $0x4435a6e85ba9994b,%rax
7f1e: ba 08 00 00 00 mov $0x8,%edx | 7e57: a6 35 44
7f23: 4c 89 f7 mov %r14,%rdi | 7e5a: c3 retq
7f26: 48 83 c4 08 add $0x8,%rsp | 7e5b: 90 nop
7f2a: 5b pop %rbx | 7e5c: 90 nop
7f2b: 41 5e pop %r14 | 7e5d: 90 nop
7f2d: e9 ee 0a 01 00 jmpq 18a20 <__rust_deallocate> | 7e5e: 90 nop
7f32: 48 83 c4 08 add $0x8,%rsp | 7e5f: 90 nop
7f36: 5b pop %rbx |
7f37: 41 5e pop %r14 | 0000000000007e60 <_ZN39_$LT$collections..vec..Vec$LT$T$GT$$GT$16into_boxed_sl
7f39: c3 retq | 7e60: 41 57 push %r15
7f3a: 90 nop | 7e62: 41 56 push %r14
7f3b: 90 nop | 7e64: 41 54 push %r12
7f3c: 90 nop | 7e66: 53 push %rbx
7f3d: 90 nop | 7e67: 50 push %rax
7f3e: 90 nop | 7e68: 4c 8b 37 mov (%rdi),%r14
7f3f: 90 nop | 7e6b: 4c 8b 7f 08 mov 0x8(%rdi),%r15
| 7e6f: 48 8b 5f 10 mov 0x10(%rdi),%rbx
0000000000007f40 <_ZN36_$LT$T$u20$as$u20$core..any..Any$GT$11get_type_id17h71 | 7e73: 49 39 df cmp %rbx,%r15
7f40: 48 b8 f1 af 77 9d 3b movabs $0xca56ac3b9d77aff1,%rax | 7e76: 72 75 jb 7eed <_ZN39_$LT$collections..v
7f47: ac 56 ca | 7e78: 48 85 db test %rbx,%rbx
7f4a: c3 retq | 7e7b: 74 0d je 7e8a <_ZN39_$LT$collections..v
7f4b: 90 nop | 7e7d: 49 39 df cmp %rbx,%r15
7f4c: 90 nop | 7e80: 75 3e jne 7ec0 <_ZN39_$LT$collections..v
7f4d: 90 nop | 7e82: 4d 89 f4 mov %r14,%r12
7f4e: 90 nop | 7e85: 4c 89 fb mov %r15,%rbx
7f4f: 90 nop | 7e88: eb 51 jmp 7edb <_ZN39_$LT$collections..v
| 7e8a: 31 db xor %ebx,%ebx
0000000000007f50 <_ZN36_$LT$T$u20$as$u20$core..any..Any$GT$11get_type_id17h8c | 7e8c: 41 bc 01 00 00 00 mov $0x1,%r12d
7f50: 48 b8 4b 99 a9 5b e8 movabs $0x4435a6e85ba9994b,%rax | 7e92: 4d 85 ff test %r15,%r15
7f57: a6 35 44 | 7e95: 74 44 je 7edb <_ZN39_$LT$collections..v
7f5a: c3 retq | 7e97: 48 b8 1d 1d 1d 1d 1d movabs $0x1d1d1d1d1d1d1d1d,%rax
7f5b: 90 nop | 7e9e: 1d 1d 1d
7f5c: 90 nop | 7ea1: 49 39 c7 cmp %rax,%r15
7f5d: 90 nop | 7ea4: 74 35 je 7edb <_ZN39_$LT$collections..v
7f5e: 90 nop | 7ea6: 41 bc 01 00 00 00 mov $0x1,%r12d
7f5f: 90 nop | 7eac: ba 01 00 00 00 mov $0x1,%edx
| 7eb1: 4c 89 f7 mov %r14,%rdi
0000000000007f60 <_ZN39_$LT$collections..vec..Vec$LT$T$GT$$GT$16into_boxed_sl | 7eb4: 4c 89 fe mov %r15,%rsi
7f60: 41 57 push %r15 | 7eb7: e8 64 0a 01 00 callq 18920 <__rust_deallocate>
7f62: 41 56 push %r14 | 7ebc: 31 db xor %ebx,%ebx
7f64: 41 54 push %r12 | 7ebe: eb 1b jmp 7edb <_ZN39_$LT$collections..v
7f66: 53 push %rbx | 7ec0: b9 01 00 00 00 mov $0x1,%ecx
7f67: 50 push %rax | 7ec5: 4c 89 f7 mov %r14,%rdi
7f68: 4c 8b 37 mov (%rdi),%r14 | 7ec8: 4c 89 fe mov %r15,%rsi
7f6b: 4c 8b 7f 08 mov 0x8(%rdi),%r15 | 7ecb: 48 89 da mov %rbx,%rdx
7f6f: 48 8b 5f 10 mov 0x10(%rdi),%rbx | 7ece: e8 2d 0a 01 00 callq 18900 <__rust_reallocate>
7f73: 49 39 df cmp %rbx,%r15 | 7ed3: 49 89 c4 mov %rax,%r12
7f76: 72 75 jb 7fed <_ZN39_$LT$collections..v | 7ed6: 4d 85 e4 test %r12,%r12
7f78: 48 85 db test %rbx,%rbx | 7ed9: 74 1e je 7ef9 <_ZN39_$LT$collections..v
7f7b: 74 0d je 7f8a <_ZN39_$LT$collections..v | 7edb: 4c 89 e0 mov %r12,%rax
7f7d: 49 39 df cmp %rbx,%r15 | 7ede: 48 89 da mov %rbx,%rdx
7f80: 75 3e jne 7fc0 <_ZN39_$LT$collections..v | 7ee1: 48 83 c4 08 add $0x8,%rsp
7f82: 4d 89 f4 mov %r14,%r12 | 7ee5: 5b pop %rbx
7f85: 4c 89 fb mov %r15,%rbx | 7ee6: 41 5c pop %r12
7f88: eb 51 jmp 7fdb <_ZN39_$LT$collections..v | 7ee8: 41 5e pop %r14
7f8a: 31 db xor %ebx,%ebx | 7eea: 41 5f pop %r15
7f8c: 41 bc 01 00 00 00 mov $0x1,%r12d | 7eec: c3 retq
7f92: 4d 85 ff test %r15,%r15 | 7eed: 48 8b 3d 14 20 25 00 mov 0x252014(%rip),%rdi # 2
7f95: 74 44 je 7fdb <_ZN39_$LT$collections..v | 7ef4: e8 d7 c6 03 00 callq 445d0 <_ZN4core9panicking5pani
7f97: 48 b8 1d 1d 1d 1d 1d movabs $0x1d1d1d1d1d1d1d1d,%rax | 7ef9: e8 c2 09 01 00 callq 188c0 <_ZN5alloc3oom3oom17hf03
7f9e: 1d 1d 1d | 7efe: 48 89 c3 mov %rax,%rbx
7fa1: 49 39 c7 cmp %rax,%r15 | 7f01: 4d 85 ff test %r15,%r15
7fa4: 74 35 je 7fdb <_ZN39_$LT$collections..v | 7f04: 74 1f je 7f25 <_ZN39_$LT$collections..v
7fa6: 41 bc 01 00 00 00 mov $0x1,%r12d | 7f06: 48 b8 1d 1d 1d 1d 1d movabs $0x1d1d1d1d1d1d1d1d,%rax
7fac: ba 01 00 00 00 mov $0x1,%edx | 7f0d: 1d 1d 1d
7fb1: 4c 89 f7 mov %r14,%rdi | 7f10: 49 39 c7 cmp %rax,%r15
7fb4: 4c 89 fe mov %r15,%rsi | 7f13: 74 10 je 7f25 <_ZN39_$LT$collections..v
7fb7: e8 64 0a 01 00 callq 18a20 <__rust_deallocate> | 7f15: ba 01 00 00 00 mov $0x1,%edx
7fbc: 31 db xor %ebx,%ebx | 7f1a: 4c 89 f7 mov %r14,%rdi
7fbe: eb 1b jmp 7fdb <_ZN39_$LT$collections..v | 7f1d: 4c 89 fe mov %r15,%rsi
7fc0: b9 01 00 00 00 mov $0x1,%ecx | 7f20: e8 fb 09 01 00 callq 18920 <__rust_deallocate>
7fc5: 4c 89 f7 mov %r14,%rdi | 7f25: 48 89 df mov %rbx,%rdi
7fc8: 4c 89 fe mov %r15,%rsi | 7f28: e8 53 f7 ff ff callq 7680 <_Unwind_Resume@plt>
7fcb: 48 89 da mov %rbx,%rdx | 7f2d: 90 nop
7fce: e8 2d 0a 01 00 callq 18a00 <__rust_reallocate> | 7f2e: 90 nop
7fd3: 49 89 c4 mov %rax,%r12 | 7f2f: 90 nop
7fd6: 4d 85 e4 test %r12,%r12 |
7fd9: 74 1e je 7ff9 <_ZN39_$LT$collections..v | 0000000000007f30 <_ZN39_$LT$collections..vec..Vec$LT$T$GT$$GT$7reserve17h67a2
7fdb: 4c 89 e0 mov %r12,%rax | 7f30: 41 56 push %r14
7fde: 48 89 da mov %rbx,%rdx | 7f32: 53 push %rbx
7fe1: 48 83 c4 08 add $0x8,%rsp | 7f33: 50 push %rax
7fe5: 5b pop %rbx | 7f34: 48 89 f0 mov %rsi,%rax
7fe6: 41 5c pop %r12 | 7f37: 48 89 fb mov %rdi,%rbx
7fe8: 41 5e pop %r14 | 7f3a: 48 8b 73 08 mov 0x8(%rbx),%rsi
7fea: 41 5f pop %r15 | 7f3e: 48 8b 4b 10 mov 0x10(%rbx),%rcx
7fec: c3 retq | 7f42: 48 89 f2 mov %rsi,%rdx
7fed: 48 8b 3d 14 1f 25 00 mov 0x251f14(%rip),%rdi # 2 | 7f45: 48 29 ca sub %rcx,%rdx
7ff4: e8 d7 c6 03 00 callq 446d0 <_ZN4core9panicking5pani | 7f48: 48 39 c2 cmp %rax,%rdx
7ff9: e8 c2 09 01 00 callq 189c0 <_ZN5alloc3oom3oom17hf03 | 7f4b: 73 40 jae 7f8d <_ZN39_$LT$collections..v
7ffe: 48 89 c3 mov %rax,%rbx | 7f4d: 48 01 c1 add %rax,%rcx
8001: 4d 85 ff test %r15,%r15 | 7f50: 72 43 jb 7f95 <_ZN39_$LT$collections..v
8004: 74 1f je 8025 <_ZN39_$LT$collections..v | 7f52: 4c 8d 34 36 lea (%rsi,%rsi,1),%r14
8006: 48 b8 1d 1d 1d 1d 1d movabs $0x1d1d1d1d1d1d1d1d,%rax | 7f56: 4c 39 f1 cmp %r14,%rcx
800d: 1d 1d 1d | 7f59: 4c 0f 43 f1 cmovae %rcx,%r14
8010: 49 39 c7 cmp %rax,%r15 | 7f5d: 48 85 f6 test %rsi,%rsi
8013: 74 10 je 8025 <_ZN39_$LT$collections..v | 7f60: 74 12 je 7f74 <_ZN39_$LT$collections..v
8015: ba 01 00 00 00 mov $0x1,%edx | 7f62: 48 8b 3b mov (%rbx),%rdi
801a: 4c 89 f7 mov %r14,%rdi | 7f65: b9 01 00 00 00 mov $0x1,%ecx
801d: 4c 89 fe mov %r15,%rsi | 7f6a: 4c 89 f2 mov %r14,%rdx
8020: e8 fb 09 01 00 callq 18a20 <__rust_deallocate> | 7f6d: e8 8e 09 01 00 callq 18900 <__rust_reallocate>
8025: 48 89 df mov %rbx,%rdi | 7f72: eb 0d jmp 7f81 <_ZN39_$LT$collections..v
8028: e8 53 f6 ff ff callq 7680 <_Unwind_Resume@plt> | 7f74: be 01 00 00 00 mov $0x1,%esi
802d: 90 nop | 7f79: 4c 89 f7 mov %r14,%rdi
802e: 90 nop | 7f7c: e8 5f 09 01 00 callq 188e0 <__rust_allocate>
802f: 90 nop | 7f81: 48 85 c0 test %rax,%rax
| 7f84: 74 20 je 7fa6 <_ZN39_$LT$collections..v
0000000000008030 <_ZN39_$LT$collections..vec..Vec$LT$T$GT$$GT$7reserve17h67a2 | 7f86: 48 89 03 mov %rax,(%rbx)
8030: 41 56 push %r14 | 7f89: 4c 89 73 08 mov %r14,0x8(%rbx)
8032: 53 push %rbx | 7f8d: 48 83 c4 08 add $0x8,%rsp
8033: 50 push %rax | 7f91: 5b pop %rbx
8034: 48 89 f0 mov %rsi,%rax | 7f92: 41 5e pop %r14
8037: 48 89 fb mov %rdi,%rbx | 7f94: c3 retq
803a: 48 8b 73 08 mov 0x8(%rbx),%rsi | 7f95: 48 8d 3d e4 f3 03 00 lea 0x3f3e4(%rip),%rdi # 47
803e: 48 8b 4b 10 mov 0x10(%rbx),%rcx | 7f9c: be 11 00 00 00 mov $0x11,%esi
8042: 48 89 f2 mov %rsi,%rdx | 7fa1: e8 7a c7 03 00 callq 44720 <_ZN4core6option13expect
8045: 48 29 ca sub %rcx,%rdx | 7fa6: e8 15 09 01 00 callq 188c0 <_ZN5alloc3oom3oom17hf03
8048: 48 39 c2 cmp %rax,%rdx | 7fab: 90 nop
804b: 73 40 jae 808d <_ZN39_$LT$collections..v | 7fac: 90 nop
804d: 48 01 c1 add %rax,%rcx | 7fad: 90 nop
8050: 72 43 jb 8095 <_ZN39_$LT$collections..v | 7fae: 90 nop
8052: 4c 8d 34 36 lea (%rsi,%rsi,1),%r14 | 7faf: 90 nop
8056: 4c 39 f1 cmp %r14,%rcx |
8059: 4c 0f 43 f1 cmovae %rcx,%r14 | 0000000000007fb0 <_ZN39_$LT$collections..vec..Vec$LT$T$GT$$GT$7reserve17hf6c7
805d: 48 85 f6 test %rsi,%rsi | 7fb0: 41 56 push %r14
8060: 74 12 je 8074 <_ZN39_$LT$collections..v | 7fb2: 53 push %rbx
8062: 48 8b 3b mov (%rbx),%rdi | 7fb3: 50 push %rax
8065: b9 01 00 00 00 mov $0x1,%ecx | 7fb4: 48 89 fb mov %rdi,%rbx
806a: 4c 89 f2 mov %r14,%rdx | 7fb7: 48 8b 4b 08 mov 0x8(%rbx),%rcx
806d: e8 8e 09 01 00 callq 18a00 <__rust_reallocate> | 7fbb: 48 8b 43 10 mov 0x10(%rbx),%rax
8072: eb 0d jmp 8081 <_ZN39_$LT$collections..v | 7fbf: 48 89 ca mov %rcx,%rdx
8074: be 01 00 00 00 mov $0x1,%esi | 7fc2: 48 29 c2 sub %rax,%rdx
8079: 4c 89 f7 mov %r14,%rdi | 7fc5: 48 39 f2 cmp %rsi,%rdx
807c: e8 5f 09 01 00 callq 189e0 <__rust_allocate> | 7fc8: 73 55 jae 801f <_ZN39_$LT$collections..v
8081: 48 85 c0 test %rax,%rax | 7fca: 48 01 f0 add %rsi,%rax
8084: 74 20 je 80a6 <_ZN39_$LT$collections..v | 7fcd: 72 58 jb 8027 <_ZN39_$LT$collections..v
8086: 48 89 03 mov %rax,(%rbx) | 7fcf: 4c 8d 34 09 lea (%rcx,%rcx,1),%r14
8089: 4c 89 73 08 mov %r14,0x8(%rbx) | 7fd3: 4c 39 f0 cmp %r14,%rax
808d: 48 83 c4 08 add $0x8,%rsp | 7fd6: 4c 0f 43 f0 cmovae %rax,%r14
8091: 5b pop %rbx | 7fda: ba 18 00 00 00 mov $0x18,%edx
8092: 41 5e pop %r14 | 7fdf: 4c 89 f0 mov %r14,%rax
8094: c3 retq | 7fe2: 48 f7 e2 mul %rdx
8095: 48 8d 3d e4 f3 03 00 lea 0x3f3e4(%rip),%rdi # 47 | 7fe5: 70 40 jo 8027 <_ZN39_$LT$collections..v
809c: be 11 00 00 00 mov $0x11,%esi | 7fe7: 48 85 c9 test %rcx,%rcx
80a1: e8 7a c7 03 00 callq 44820 <_ZN4core6option13expect | 7fea: 74 1a je 8006 <_ZN39_$LT$collections..v
80a6: e8 15 09 01 00 callq 189c0 <_ZN5alloc3oom3oom17hf03 | 7fec: 48 8b 3b mov (%rbx),%rdi
80ab: 90 nop | 7fef: 48 c1 e1 03 shl $0x3,%rcx
80ac: 90 nop | 7ff3: 48 8d 34 49 lea (%rcx,%rcx,2),%rsi
80ad: 90 nop | 7ff7: b9 08 00 00 00 mov $0x8,%ecx
80ae: 90 nop | 7ffc: 48 89 c2 mov %rax,%rdx
80af: 90 nop | 7fff: e8 fc 08 01 00 callq 18900 <__rust_reallocate>
| 8004: eb 0d jmp 8013 <_ZN39_$LT$collections..v
00000000000080b0 <_ZN39_$LT$collections..vec..Vec$LT$T$GT$$GT$7reserve17hf6c7 | 8006: be 08 00 00 00 mov $0x8,%esi
80b0: 41 56 push %r14 | 800b: 48 89 c7 mov %rax,%rdi
80b2: 53 push %rbx | 800e: e8 cd 08 01 00 callq 188e0 <__rust_allocate>
80b3: 50 push %rax | 8013: 48 85 c0 test %rax,%rax
80b4: 48 89 fb mov %rdi,%rbx | 8016: 74 20 je 8038 <_ZN39_$LT$collections..v
80b7: 48 8b 4b 08 mov 0x8(%rbx),%rcx | 8018: 48 89 03 mov %rax,(%rbx)
80bb: 48 8b 43 10 mov 0x10(%rbx),%rax | 801b: 4c 89 73 08 mov %r14,0x8(%rbx)
80bf: 48 89 ca mov %rcx,%rdx | 801f: 48 83 c4 08 add $0x8,%rsp
80c2: 48 29 c2 sub %rax,%rdx | 8023: 5b pop %rbx
80c5: 48 39 f2 cmp %rsi,%rdx | 8024: 41 5e pop %r14
80c8: 73 55 jae 811f <_ZN39_$LT$collections..v | 8026: c3 retq
80ca: 48 01 f0 add %rsi,%rax | 8027: 48 8d 3d 52 f3 03 00 lea 0x3f352(%rip),%rdi # 47
80cd: 72 58 jb 8127 <_ZN39_$LT$collections..v | 802e: be 11 00 00 00 mov $0x11,%esi
80cf: 4c 8d 34 09 lea (%rcx,%rcx,1),%r14 | 8033: e8 e8 c6 03 00 callq 44720 <_ZN4core6option13expect
80d3: 4c 39 f0 cmp %r14,%rax | 8038: e8 83 08 01 00 callq 188c0 <_ZN5alloc3oom3oom17hf03
80d6: 4c 0f 43 f0 cmovae %rax,%r14 | 803d: 90 nop
80da: ba 18 00 00 00 mov $0x18,%edx | 803e: 90 nop
80df: 4c 89 f0 mov %r14,%rax | 803f: 90 nop
80e2: 48 f7 e2 mul %rdx |
80e5: 70 40 jo 8127 <_ZN39_$LT$collections..v | 0000000000008040 <_ZN40_$LT$alloc..raw_vec..RawVec$LT$T$GT$$GT$6double17h71bf
80e7: 48 85 c9 test %rcx,%rcx | 8040: 41 56 push %r14
80ea: 74 1a je 8106 <_ZN39_$LT$collections..v | 8042: 53 push %rbx
80ec: 48 8b 3b mov (%rbx),%rdi | 8043: 50 push %rax
80ef: 48 c1 e1 03 shl $0x3,%rcx | 8044: 48 89 fb mov %rdi,%rbx
80f3: 48 8d 34 49 lea (%rcx,%rcx,2),%rsi | 8047: 48 8b 43 08 mov 0x8(%rbx),%rax
80f7: b9 08 00 00 00 mov $0x8,%ecx | 804b: 48 85 c0 test %rax,%rax
80fc: 48 89 c2 mov %rax,%rdx | 804e: 74 21 je 8071 <_ZN40_$LT$alloc..raw_vec
80ff: e8 fc 08 01 00 callq 18a00 <__rust_reallocate> | 8050: 48 89 c2 mov %rax,%rdx
8104: eb 0d jmp 8113 <_ZN39_$LT$collections..v | 8053: 48 c1 e2 05 shl $0x5,%rdx
8106: be 08 00 00 00 mov $0x8,%esi | 8057: 48 8b 3b mov (%rbx),%rdi
810b: 48 89 c7 mov %rax,%rdi | 805a: 48 89 c6 mov %rax,%rsi
810e: e8 cd 08 01 00 callq 189e0 <__rust_allocate> | 805d: 48 c1 e6 04 shl $0x4,%rsi
8113: 48 85 c0 test %rax,%rax | 8061: 4c 8d 34 00 lea (%rax,%rax,1),%r14
8116: 74 20 je 8138 <_ZN39_$LT$collections..v | 8065: b9 08 00 00 00 mov $0x8,%ecx
8118: 48 89 03 mov %rax,(%rbx) | 806a: e8 91 08 01 00 callq 18900 <__rust_reallocate>
811b: 4c 89 73 08 mov %r14,0x8(%rbx) | 806f: eb 15 jmp 8086 <_ZN40_$LT$alloc..raw_vec
811f: 48 83 c4 08 add $0x8,%rsp | 8071: bf 40 00 00 00 mov $0x40,%edi
8123: 5b pop %rbx | 8076: be 08 00 00 00 mov $0x8,%esi
8124: 41 5e pop %r14 | 807b: e8 60 08 01 00 callq 188e0 <__rust_allocate>
8126: c3 retq | 8080: 41 be 04 00 00 00 mov $0x4,%r14d
8127: 48 8d 3d 52 f3 03 00 lea 0x3f352(%rip),%rdi # 47 | 8086: 48 85 c0 test %rax,%rax
812e: be 11 00 00 00 mov $0x11,%esi | 8089: 74 0f je 809a <_ZN40_$LT$alloc..raw_vec
8133: e8 e8 c6 03 00 callq 44820 <_ZN4core6option13expect | 808b: 48 89 03 mov %rax,(%rbx)
8138: e8 83 08 01 00 callq 189c0 <_ZN5alloc3oom3oom17hf03 | 808e: 4c 89 73 08 mov %r14,0x8(%rbx)
813d: 90 nop | 8092: 48 83 c4 08 add $0x8,%rsp
813e: 90 nop | 8096: 5b pop %rbx
813f: 90 nop | 8097: 41 5e pop %r14
| 8099: c3 retq
0000000000008140 <_ZN40_$LT$alloc..raw_vec..RawVec$LT$T$GT$$GT$6double17h71bf | 809a: e8 21 08 01 00 callq 188c0 <_ZN5alloc3oom3oom17hf03
8140: 41 56 push %r14 | 809f: 90 nop
8142: 53 push %rbx |
# ABRIDGED EXCERPT
Raw
perf diff
Percent | Source code & Disassembly of splay | Percent | Source code & Disassembly of splay_no_landing
------------------------------------------------ ------------------------------------------------
: :
: :
: :
: Disassembly of section .text: : Disassembly of section .text:
: :
: 0000000000007bf0 <splay::main::h7cf589df5d172d0b>: | : 0000000000007b50 <splay::main::h7cf589df5d172d0b>:
: print(tree, depth + 1); : print(tree, depth + 1);
: tree.parent(); : tree.parent();
: } : }
: } : }
: :
: fn main() { : fn main() {
0.00 : 7bf0: push %rbp | 0.00 : 7b50: push %rbp
0.00 : 7bf1: mov %rsp,%rbp | 0.00 : 7b51: mov %rsp,%rbp
: tree: Option<Tree<T>>, : tree: Option<Tree<T>>,
: } : }
: :
: impl<T> Splay<T> where T: PartialOrd { : impl<T> Splay<T> where T: PartialOrd {
: fn new() -> Splay<T> { : fn new() -> Splay<T> {
: Splay { tree: None } : Splay { tree: None }
0.00 : 7bf4: push %r15 | 0.00 : 7b54: push %r15
0.00 : 7bf6: push %r14 | 0.00 : 7b56: push %r14
0.00 : 7bf8: push %r13 | 0.00 : 7b58: push %r13
0.00 : 7bfa: push %r12 | 0.00 : 7b5a: push %r12
0.00 : 7bfc: push %rbx | 0.00 : 7b5c: push %rbx
0.00 : 7bfd: sub $0x88,%rsp | 0.00 : 7b5d: sub $0x68,%rsp
0.00 : 7c04: movq $0x0,-0x78(%rbp) | 0.00 : 7b61: movq $0x0,-0x78(%rbp)
0.00 : 7c0c: lea -0x70(%rbp),%rbx | 0.00 : 7b69: lea -0x70(%rbp),%rbx
0.00 : 7c10: mov $0x1,%r15d | 0.00 : 7b6d: mov $0x1,%r15d
0.00 : 7c16: xor %eax,%eax | 0.00 : 7b73: xor %eax,%eax
0.00 : 7c18: lea -0x40(%rbp),%r12 | 0.00 : 7b75: lea -0x40(%rbp),%r12
0.00 : 7c1c: mov $0x1,%r14d | 0.00 : 7b79: mov $0x1,%r14d
0.00 : 7c22: data32 data32 data32 data32 nopw %cs:0x0(%rax | 0.00 : 7b7f: nop
0.00 : 7c30: mov %r14d,%ecx | 0.00 : 7b80: mov %r14d,%ecx
0.00 : 7c33: shl $0x4,%ecx | 0.00 : 7b83: shl $0x4,%ecx
0.00 : 7c36: lea 0xff(%r14,%rcx,1),%r14d | 0.00 : 7b86: lea 0xff(%r14,%rcx,1),%r14d
0.00 : 7c3e: movups (%rbx),%xmm0 | 0.00 : 7b8e: movups (%rbx),%xmm0
0.00 : 7c41: movaps %xmm0,-0xb0(%rbp) | 0.00 : 7b91: movaps %xmm0,-0x90(%rbp)
0.00 : 7c48: movq $0x0,-0x78(%rbp) | 0.00 : 7b98: movq $0x0,-0x78(%rbp)
: } : }
: } : }
: :
: fn insert(&mut self, value: T) { : fn insert(&mut self, value: T) {
: match self.tree.take() { : match self.tree.take() {
: None => self.tree = Some(Tree::new(value)), : None => self.tree = Some(Tree::new(value)),
0.00 : 7c50: test $0x1,%al | 0.00 : 7ba0: test $0x1,%al
0.00 : 7c52: je 7db0 <splay::main::h7cf589df5d172d0b+0 | 0.00 : 7ba2: je 7cf0 <splay::main::h7cf589df5d172d0b+0
: Some(mut tree) => { : Some(mut tree) => {
0.00 : 7c58: movaps -0xb0(%rbp),%xmm0 | 0.00 : 7ba8: movaps -0x90(%rbp),%xmm0
0.00 : 7c5f: movaps %xmm0,-0x40(%rbp) | 0.35 : 7baf: movaps %xmm0,-0x40(%rbp)
: Some(Tree { node: child }) : Some(Tree { node: child })
: } : }
: } : }
: :
: fn value(&mut self) -> &mut T { : fn value(&mut self) -> &mut T {
: unsafe { &mut (*self.node).value } : unsafe { &mut (*self.node).value }
0.00 : 7c63: mov -0x40(%rbp),%r13 | 0.18 : 7bb3: mov -0x40(%rbp),%r13
: fn insert(&mut self, value: T) { : fn insert(&mut self, value: T) {
: match self.tree.take() { : match self.tree.take() {
: None => self.tree = Some(Tree::new(value)), : None => self.tree = Some(Tree::new(value)),
: Some(mut tree) => { : Some(mut tree) => {
: loop { : loop {
: let index = if value < *tree.value() { 0 : let index = if value < *tree.value() { 0
0.00 : 7c67: xor %ebx,%ebx | 0.00 : 7bb7: xor %ebx,%ebx
0.00 : 7c69: cmp %r14d,0x20(%r13) | 0.00 : 7bb9: cmp %r14d,0x20(%r13)
0.18 : 7c6d: setbe %bl | 0.18 : 7bbd: setbe %bl
: Some(index) : Some(index)
: } : }
: } : }
: :
: fn child(&mut self, index: usize) -> bool { : fn child(&mut self, index: usize) -> bool {
: let child = unsafe { (*self.node).children[index] }; : let child = unsafe { (*self.node).children[index] };
0.37 : 7c70: mov 0x10(%r13,%rbx,8),%rax | 0.35 : 7bc0: mov 0x10(%r13,%rbx,8),%rax
: None => self.tree = Some(Tree::new(value)), : None => self.tree = Some(Tree::new(value)),
: Some(mut tree) => { : Some(mut tree) => {
: loop { : loop {
: let index = if value < *tree.value() { 0 : let index = if value < *tree.value() { 0
: :
: if !tree.child(index) { : if !tree.child(index) {
0.37 : 7c75: test %rax,%rax | 0.00 : 7bc5: test %rax,%rax
0.00 : 7c78: je 7c9a <splay::main::h7cf589df5d172d0b+0 | 0.00 : 7bc8: je 7bea <splay::main::h7cf589df5d172d0b+0
0.18 : 7c7a: nopw 0x0(%rax,%rax,1) | 0.00 : 7bca: nopw 0x0(%rax,%rax,1)
: let mut splay = Splay::new(); : let mut splay = Splay::new();
: :
: let mut num = 1u32; : let mut num = 1u32;
: for _ in 0..1000000 { : for _ in 0..1000000 {
: num = num.wrapping_mul(17).wrapping_add(255); : num = num.wrapping_mul(17).wrapping_add(255);
: splay.insert(num); : splay.insert(num);
1.46 : 7c80: mov %rax,%r13 | 1.23 : 7bd0: mov %rax,%r13
: fn insert(&mut self, value: T) { : fn insert(&mut self, value: T) {
: match self.tree.take() { : match self.tree.take() {
: None => self.tree = Some(Tree::new(value)), : None => self.tree = Some(Tree::new(value)),
: Some(mut tree) => { : Some(mut tree) => {
: loop { : loop {
: let index = if value < *tree.value() { 0 : let index = if value < *tree.value() { 0
0.00 : 7c83: xor %ebx,%ebx | 0.00 : 7bd3: xor %ebx,%ebx
0.00 : 7c85: cmp %r14d,0x20(%r13) | 0.00 : 7bd5: cmp %r14d,0x20(%r13)
63.80 : 7c89: setbe %bl | 64.15 : 7bd9: setbe %bl
: Some(index) : Some(index)
: } : }
: } : }
: :
: fn child(&mut self, index: usize) -> bool { : fn child(&mut self, index: usize) -> bool {
: let child = unsafe { (*self.node).children[index] }; : let child = unsafe { (*self.node).children[index] };
3.29 : 7c8c: mov 0x10(%r13,%rbx,8),%rax | 1.41 : 7bdc: mov 0x10(%r13,%rbx,8),%rax
: if child == ptr::null_mut() { : if child == ptr::null_mut() {
16.82 : 7c91: test %rax,%rax | 17.22 : 7be1: test %rax,%rax
0.00 : 7c94: jne 7c80 <splay::main::h7cf589df5d172d0b+0 | 0.00 : 7be4: jne 7bd0 <splay::main::h7cf589df5d172d0b+0
: false : false
: } else { : } else {
: self.node = child; : self.node = child;
0.73 : 7c96: mov %r13,-0x40(%rbp) | 0.35 : 7be6: mov %r13,-0x40(%rbp)
0.18 : 7c9a: xorps %xmm0,%xmm0 | 0.88 : 7bea: xorps %xmm0,%xmm0
0.00 : 7c9d: movaps %xmm0,-0x60(%rbp) | 0.00 : 7bed: movaps %xmm0,-0x60(%rbp)
0.55 : 7ca1: movq $0x0,-0x50(%rbp) | 0.35 : 7bf1: movq $0x0,-0x50(%rbp)
0.00 : 7ca9: mov $0x28,%edi | 0.00 : 7bf9: mov $0x28,%edi
0.00 : 7cae: mov $0x8,%esi | 0.00 : 7bfe: mov $0x8,%esi
0.00 : 7cb3: callq 189e0 <__rust_allocate> | 0.00 : 7c03: callq 188e0 <__rust_allocate>
0.18 : 7cb8: test %rax,%rax | 0.00 : 7c08: test %rax,%rax
0.00 : 7cbb: je 7e99 <splay::main::h7cf589df5d172d0b+0 | 0.00 : 7c0b: je 7dca <splay::main::h7cf589df5d172d0b+0
0.00 : 7cc1: movq $0xffffffffffffffff,(%rax) | 0.00 : 7c11: movq $0xffffffffffffffff,(%rax)
0.00 : 7cc8: mov -0x50(%rbp),%rcx | 0.00 : 7c18: mov -0x50(%rbp),%rcx
0.00 : 7ccc: mov %rcx,0x18(%rax) | 0.00 : 7c1c: mov %rcx,0x18(%rax)
0.18 : 7cd0: movaps -0x60(%rbp),%xmm0 | 0.18 : 7c20: movaps -0x60(%rbp),%xmm0
0.00 : 7cd4: movups %xmm0,0x8(%rax) | 0.00 : 7c24: movups %xmm0,0x8(%rax)
0.00 : 7cd8: mov %r14d,0x20(%rax) | 0.35 : 7c28: mov %r14d,0x20(%rax)
: node: *mut Node<T>, : node: *mut Node<T>,
: } : }
: :
: impl<T> Tree<T> { : impl<T> Tree<T> {
: fn new(value: T) -> Tree<T> { : fn new(value: T) -> Tree<T> {
: Tree { node: Box::into_raw(Box::new(Node::new(value)) : Tree { node: Box::into_raw(Box::new(Node::new(value))
0.00 : 7cdc: movb $0xd4,-0x80(%rbp) | 0.18 : 7c2c: movb $0xd4,-0x58(%rbp)
0.00 : 7ce0: mov %rax,-0x88(%rbp) | 0.00 : 7c30: mov %rax,-0x60(%rbp)
: Some(mut tree) => { : Some(mut tree) => {
: loop { : loop {
: let index = if value < *tree.value() { 0 : let index = if value < *tree.value() { 0
: :
: if !tree.child(index) { : if !tree.child(index) {
: tree.link(index, Tree::new(value)); : tree.link(index, Tree::new(value));
0.00 : 7ce7: mov %r12,%rdi | 0.00 : 7c34: mov %r12,%rdi
0.00 : 7cea: mov %rbx,%rsi | 0.00 : 7c37: mov %rbx,%rsi
0.00 : 7ced: lea -0x88(%rbp),%rdx | 0.00 : 7c3a: lea -0x60(%rbp),%rdx
0.00 : 7cf4: callq 78b0 <_$LT$splay..Tree$LT$T$GT$$GT$::l | 0.00 : 7c3e: callq 78b0 <_$LT$splay..Tree$LT$T$GT$$GT$::l
: Some(index) : Some(index)
: } : }
: } : }
: :
: fn child(&mut self, index: usize) -> bool { : fn child(&mut self, index: usize) -> bool {
: let child = unsafe { (*self.node).children[index] }; : let child = unsafe { (*self.node).children[index] };
0.00 : 7cf9: mov 0x10(%r13,%rbx,8),%rax | 0.00 : 7c43: mov 0x10(%r13,%rbx,8),%rax
: loop { : loop {
: let index = if value < *tree.value() { 0 : let index = if value < *tree.value() { 0
: :
: if !tree.child(index) { : if !tree.child(index) {
: tree.link(index, Tree::new(value)); : tree.link(index, Tree::new(value));
: tree.child(index); : tree.child(index);
0.00 : 7cfe: test %rax,%rax | 0.00 : 7c48: test %rax,%rax
0.00 : 7d01: je 7d14 <splay::main::h7cf589df5d172d0b+0 | 0.00 : 7c4b: je 7c69 <splay::main::h7cf589df5d172d0b+0
: fn child(&mut self, index: usize) -> bool { : fn child(&mut self, index: usize) -> bool {
: let child = unsafe { (*self.node).children[index] }; : let child = unsafe { (*self.node).children[index] };
: if child == ptr::null_mut() { : if child == ptr::null_mut() {
: false : false
: } else { : } else {
: self.node = child; : self.node = child;
0.00 : 7d03: mov %rax,-0x40(%rbp) | 0.00 : 7c4d: mov %rax,-0x40(%rbp)
: fn new(value: T) -> Tree<T> { : fn new(value: T) -> Tree<T> {
: Tree { node: Box::into_raw(Box::new(Node::new(value)) : Tree { node: Box::into_raw(Box::new(Node::new(value))
: } : }
: :
: fn parent(&mut self) -> Option<usize> { : fn parent(&mut self) -> Option<usize> {
: let parent = unsafe { (*self.node).parent }; : let parent = unsafe { (*self.node).parent };
0.00 : 7d07: mov %rax,%r13 | 0.00 : 7c51: mov %rax,%r13
0.00 : 7d0a: jmp 7d14 <splay::main::h7cf589df5d172d0b+0 | 0.00 : 7c54: jmp 7c69 <splay::main::h7cf589df5d172d0b+0
0.00 : 7d0c: nopl 0x0(%rax) | 0.00 : 7c56: nopw %cs:0x0(%rax,%rax,1)
0.00 : 7d10: mov -0x40(%rbp),%r13 | : Some(index) => index,
0.00 : 7d14: mov 0x8(%r13),%rax | : };
> :
> : if i1 == i2 {
> : self.rotate(tree, i2);
> : self.rotate(tree, i1);
> 0.00 : 7c60: callq 7980 <_$LT$splay..Splay$LT$T$GT$$GT$::
> : fn new(value: T) -> Tree<T> {
> : Tree { node: Box::into_raw(Box::new(Node::new(value))
> : }
> :
> : fn parent(&mut self) -> Option<usize> {
> : let parent = unsafe { (*self.node).parent };
> 0.00 : 7c65: mov -0x40(%rbp),%r13
> 0.00 : 7c69: mov 0x8(%r13),%rax
: } : }
: } : }
: :
: fn splay(&self, mut tree: &mut Tree<T>) { : fn splay(&self, mut tree: &mut Tree<T>) {
: loop { : loop {
: let i1 = match tree.parent() { : let i1 = match tree.parent() {
0.00 : 7d18: test %rax,%rax | 0.35 : 7c6d: test %rax,%rax
0.00 : 7d1b: je 7e2f <splay::main::h7cf589df5d172d0b+0 | 0.00 : 7c70: je 7d63 <splay::main::h7cf589df5d172d0b+0
: fn parent(&mut self) -> Option<usize> { : fn parent(&mut self) -> Option<usize> {
: let parent = unsafe { (*self.node).parent }; : let parent = unsafe { (*self.node).parent };
: if parent == ptr::null_mut() { : if parent == ptr::null_mut() {
: None : None
: } else { : } else {
: let index = unsafe { (*self.node).index }; : let index = unsafe { (*self.node).index };
0.00 : 7d21: mov 0x0(%r13),%rbx | 0.18 : 7c76: mov 0x0(%r13),%rbx
: self.node = parent; : self.node = parent;
0.91 : 7d25: mov %rax,-0x40(%rbp) | 0.18 : 7c7a: mov %rax,-0x40(%rbp)
: Some(index) : Some(index)
: } : }
: } : }
: :
: fn child(&mut self, index: usize) -> bool { : fn child(&mut self, index: usize) -> bool {
: let child = unsafe { (*self.node).children[index] }; : let child = unsafe { (*self.node).children[index] };
0.00 : 7d29: mov 0x8(%rax),%rcx | 0.53 : 7c7e: mov 0x8(%rax),%rcx
: Tree { node: Box::into_raw(Box::new(Node::new(value)) : Tree { node: Box::into_raw(Box::new(Node::new(value))
: } : }
: :
: fn parent(&mut self) -> Option<usize> { : fn parent(&mut self) -> Option<usize> {
: let parent = unsafe { (*self.node).parent }; : let parent = unsafe { (*self.node).parent };
: if parent == ptr::null_mut() { : if parent == ptr::null_mut() {
5.67 : 7d2d: test %rcx,%rcx | 5.10 : 7c82: test %rcx,%rcx
0.00 : 7d30: je 7e24 <splay::main::h7cf589df5d172d0b+0 | 0.00 : 7c85: je 7d58 <splay::main::h7cf589df5d172d0b+0
: None : None
: } else { : } else {
: let index = unsafe { (*self.node).index }; : let index = unsafe { (*self.node).index };
0.18 : 7d36: mov (%rax),%r13 | 0.35 : 7c8b: mov (%rax),%r13
: self.node = parent; : self.node = parent;
0.55 : 7d39: mov %rcx,-0x40(%rbp) | 0.18 : 7c8e: mov %rcx,-0x40(%rbp)
: break; : break;
: }, : },
: Some(index) => index, : Some(index) => index,
: }; : };
: :
: if i1 == i2 { : if i1 == i2 {
0.00 : 7d3d: cmp %r13,%rbx | 0.53 : 7c92: cmp %r13,%rbx
0.00 : 7d40: jne 7d60 <splay::main::h7cf589df5d172d0b+0 | 0.00 : 7c95: jne 7cb0 <splay::main::h7cf589df5d172d0b+0
: self.rotate(tree, i2); : self.rotate(tree, i2);
0.73 : 7d42: mov %r12,%rdi | 1.23 : 7c97: mov %r12,%rdi
0.73 : 7d45: mov %rbx,%rsi | 0.18 : 7c9a: mov %rbx,%rsi
0.00 : 7d48: callq 79b0 <_$LT$splay..Splay$LT$T$GT$$GT$:: | 0.00 : 7c9d: callq 7980 <_$LT$splay..Splay$LT$T$GT$$GT$::
: self.rotate(tree, i1); : self.rotate(tree, i1);
0.18 : 7d4d: mov %r12,%rdi | 0.00 : 7ca2: mov %r12,%rdi
0.00 : 7d50: mov %rbx,%rsi | 0.00 : 7ca5: mov %rbx,%rsi
0.00 : 7d53: callq 79b0 <_$LT$splay..Splay$LT$T$GT$$GT$:: | 0.00 : 7ca8: jmp 7c60 <splay::main::h7cf589df5d172d0b+0
0.37 : 7d58: jmp 7d10 <splay::main::h7cf589df5d172d0b+0 | 0.00 : 7caa: nopw 0x0(%rax,%rax,1)
0.00 : 7d5a: nopw 0x0(%rax,%rax,1) <
: Some(index) : Some(index)
: } : }
: } : }
: :
: fn child(&mut self, index: usize) -> bool { : fn child(&mut self, index: usize) -> bool {
: let child = unsafe { (*self.node).children[index] }; : let child = unsafe { (*self.node).children[index] };
0.37 : 7d60: cmp $0x1,%r13 | 0.53 : 7cb0: cmp $0x1,%r13
0.00 : 7d64: ja 7e85 <splay::main::h7cf589df5d172d0b+0 | 0.00 : 7cb4: ja 7db6 <splay::main::h7cf589df5d172d0b+0
0.91 : 7d6a: mov 0x10(%rcx,%r13,8),%rax | 0.35 : 7cba: mov 0x10(%rcx,%r13,8),%rax
: :
: if i1 == i2 { : if i1 == i2 {
: self.rotate(tree, i2); : self.rotate(tree, i2);
: self.rotate(tree, i1); : self.rotate(tree, i1);
: } else { : } else {
: tree.child(i2); : tree.child(i2);
0.37 : 7d6f: test %rax,%rax | 1.23 : 7cbf: test %rax,%rax
0.00 : 7d72: je 7d78 <splay::main::h7cf589df5d172d0b+0 | 0.00 : 7cc2: je 7cc8 <splay::main::h7cf589df5d172d0b+0
: fn child(&mut self, index: usize) -> bool { : fn child(&mut self, index: usize) -> bool {
: let child = unsafe { (*self.node).children[index] }; : let child = unsafe { (*self.node).children[index] };
: if child == ptr::null_mut() { : if child == ptr::null_mut() {
: false : false
: } else { : } else {
: self.node = child; : self.node = child;
0.00 : 7d74: mov %rax,-0x40(%rbp) | 0.18 : 7cc4: mov %rax,-0x40(%rbp)
: if i1 == i2 { : if i1 == i2 {
: self.rotate(tree, i2); : self.rotate(tree, i2);
: self.rotate(tree, i1); : self.rotate(tree, i1);
: } else { : } else {
: tree.child(i2); : tree.child(i2);
: self.rotate(tree, i1); : self.rotate(tree, i1);
0.18 : 7d78: mov %r12,%rdi | 0.53 : 7cc8: mov %r12,%rdi
0.00 : 7d7b: mov %rbx,%rsi | 0.00 : 7ccb: mov %rbx,%rsi
0.00 : 7d7e: callq 79b0 <_$LT$splay..Splay$LT$T$GT$$GT$:: | 0.00 : 7cce: callq 7980 <_$LT$splay..Splay$LT$T$GT$$GT$::
: fn new(value: T) -> Tree<T> { : fn new(value: T) -> Tree<T> {
: Tree { node: Box::into_raw(Box::new(Node::new(value)) : Tree { node: Box::into_raw(Box::new(Node::new(value))
: } : }
: :
: fn parent(&mut self) -> Option<usize> { : fn parent(&mut self) -> Option<usize> {
: let parent = unsafe { (*self.node).parent }; : let parent = unsafe { (*self.node).parent };
0.00 : 7d83: mov -0x40(%rbp),%rax | 0.00 : 7cd3: mov -0x40(%rbp),%rax
0.00 : 7d87: mov 0x8(%rax),%rax | 0.18 : 7cd7: mov 0x8(%rax),%rax
: self.rotate(tree, i2); : self.rotate(tree, i2);
: self.rotate(tree, i1); : self.rotate(tree, i1);
: } else { : } else {
: tree.child(i2); : tree.child(i2);
: self.rotate(tree, i1); : self.rotate(tree, i1);
: tree.parent(); : tree.parent();
0.00 : 7d8b: test %rax,%rax | 0.00 : 7cdb: test %rax,%rax
0.00 : 7d8e: je 7d94 <splay::main::h7cf589df5d172d0b+0 | 0.00 : 7cde: je 7ce4 <splay::main::h7cf589df5d172d0b+0
: let parent = unsafe { (*self.node).parent }; : let parent = unsafe { (*self.node).parent };
: if parent == ptr::null_mut() { : if parent == ptr::null_mut() {
: None : None
: } else { : } else {
: let index = unsafe { (*self.node).index }; : let index = unsafe { (*self.node).index };
: self.node = parent; : self.node = parent;
0.00 : 7d90: mov %rax,-0x40(%rbp) | 0.00 : 7ce0: mov %rax,-0x40(%rbp)
: self.rotate(tree, i1); : self.rotate(tree, i1);
: } else { : } else {
: tree.child(i2); : tree.child(i2);
: self.rotate(tree, i1); : self.rotate(tree, i1);
: tree.parent(); : tree.parent();
: self.rotate(tree, i2); : self.rotate(tree, i2);
0.00 : 7d94: mov %r12,%rdi | 0.18 : 7ce4: mov %r12,%rdi
0.00 : 7d97: mov %r13,%rsi | 0.35 : 7ce7: mov %r13,%rsi
0.00 : 7d9a: callq 79b0 <_$LT$splay..Splay$LT$T$GT$$GT$:: | 0.00 : 7cea: jmpq 7c60 <splay::main::h7cf589df5d172d0b+0
0.18 : 7d9f: jmpq 7d10 <splay::main::h7cf589df5d172d0b+0 | 0.00 : 7cef: nop
0.00 : 7da4: data32 data32 nopw %cs:0x0(%rax,%rax,1) | 0.00 : 7cf0: xorps %xmm0,%xmm0
0.00 : 7db0: xorps %xmm0,%xmm0 | 0.00 : 7cf3: movaps %xmm0,-0x60(%rbp)
0.00 : 7db3: movaps %xmm0,-0xa0(%rbp) | 0.00 : 7cf7: movq $0x0,-0x50(%rbp)
0.00 : 7dba: movq $0x0,-0x90(%rbp) | 0.00 : 7cff: mov $0x28,%edi
0.00 : 7dc5: mov $0x28,%edi | 0.00 : 7d04: mov $0x8,%esi
0.00 : 7dca: mov $0x8,%esi | 0.00 : 7d09: callq 188e0 <__rust_allocate>
0.00 : 7dcf: callq 189e0 <__rust_allocate> | 0.00 : 7d0e: test %rax,%rax
0.00 : 7dd4: test %rax,%rax | 0.00 : 7d11: je 7dca <splay::main::h7cf589df5d172d0b+0
0.00 : 7dd7: je 7e9e <splay::main::h7cf589df5d172d0b+0 | 0.00 : 7d17: movq $0xffffffffffffffff,(%rax)
0.00 : 7ddd: movq $0xffffffffffffffff,(%rax) | 0.00 : 7d1e: mov -0x50(%rbp),%rcx
0.00 : 7de4: mov -0x90(%rbp),%rcx | 0.00 : 7d22: mov %rcx,0x18(%rax)
0.00 : 7deb: mov %rcx,0x18(%rax) | 0.00 : 7d26: movaps -0x60(%rbp),%xmm0
0.00 : 7def: movaps -0xa0(%rbp),%xmm0 | 0.00 : 7d2a: movups %xmm0,0x8(%rax)
0.00 : 7df6: movups %xmm0,0x8(%rax) | 0.00 : 7d2e: mov %r14d,0x20(%rax)
0.00 : 7dfa: mov %r14d,0x20(%rax) <
: } : }
: } : }
: :
: fn insert(&mut self, value: T) { : fn insert(&mut self, value: T) {
: match self.tree.take() { : match self.tree.take() {
: None => self.tree = Some(Tree::new(value)), : None => self.tree = Some(Tree::new(value)),
0.00 : 7dfe: movq $0x1,-0x78(%rbp) | 0.00 : 7d32: movq $0x1,-0x78(%rbp)
0.00 : 7e06: mov %rax,-0x70(%rbp) | 0.00 : 7d3a: mov %rax,-0x70(%rbp)
0.00 : 7e0a: movb $0xd4,-0x68(%rbp) | 0.00 : 7d3e: movb $0xd4,-0x68(%rbp)
0.00 : 7e0e: mov -0x5a(%rbp),%al | 0.00 : 7d42: mov -0x5a(%rbp),%al
0.00 : 7e11: mov %al,0xf(%rbx) | 0.00 : 7d45: mov %al,0xf(%rbx)
0.00 : 7e14: movzwl -0x5c(%rbp),%eax | 0.00 : 7d48: movzwl -0x5c(%rbp),%eax
0.00 : 7e18: mov %ax,0xd(%rbx) | 0.00 : 7d4c: mov %ax,0xd(%rbx)
0.00 : 7e1c: mov -0x60(%rbp),%eax | 0.00 : 7d50: mov -0x60(%rbp),%eax
0.00 : 7e1f: mov %eax,0x9(%rbx) | 0.00 : 7d53: mov %eax,0x9(%rbx)
0.00 : 7e22: jmp 7e4a <splay::main::h7cf589df5d172d0b+0 | 0.00 : 7d56: jmp 7d7e <splay::main::h7cf589df5d172d0b+0
: None => break, : None => break,
: Some(index) => index, : Some(index) => index,
: }; : };
: let i2 = match tree.parent() { : let i2 = match tree.parent() {
: None => { : None => {
: self.rotate(tree, i1); : self.rotate(tree, i1);
0.00 : 7e24: mov %r12,%rdi | 0.18 : 7d58: mov %r12,%rdi
0.00 : 7e27: mov %rbx,%rsi | 0.00 : 7d5b: mov %rbx,%rsi
0.00 : 7e2a: callq 79b0 <_$LT$splay..Splay$LT$T$GT$$GT$:: | 0.00 : 7d5e: callq 7980 <_$LT$splay..Splay$LT$T$GT$$GT$::
: :
: if !tree.child(index) { : if !tree.child(index) {
: tree.link(index, Tree::new(value)); : tree.link(index, Tree::new(value));
: tree.child(index); : tree.child(index);
: self.splay(&mut tree); : self.splay(&mut tree);
: self.tree = Some(tree); : self.tree = Some(tree);
0.18 : 7e2f: movaps -0x40(%rbp),%xmm0 | 0.00 : 7d63: movaps -0x40(%rbp),%xmm0
0.00 : 7e33: movaps %xmm0,-0x60(%rbp) | 0.00 : 7d67: movaps %xmm0,-0x60(%rbp)
0.00 : 7e37: movq $0x1,-0x78(%rbp) | 0.00 : 7d6b: movq $0x1,-0x78(%rbp)
0.00 : 7e3f: movaps -0x60(%rbp),%xmm0 | 0.00 : 7d73: movaps -0x60(%rbp),%xmm0
0.00 : 7e43: lea -0x70(%rbp),%rbx | 0.18 : 7d77: lea -0x70(%rbp),%rbx
0.00 : 7e47: movups %xmm0,(%rbx) | 0.00 : 7d7b: movups %xmm0,(%rbx)
0.00 : 7e4a: xor %ecx,%ecx | 0.00 : 7d7e: xor %ecx,%ecx
0.00 : 7e4c: cmp $0xf4240,%r15d | 0.00 : 7d80: cmp $0xf4240,%r15d
0.18 : 7e53: setl %cl | 0.00 : 7d87: setl %cl
0.00 : 7e56: add %r15d,%ecx | 0.00 : 7d8a: add %r15d,%ecx
0.00 : 7e59: cmp $0xf4240,%r15d | 0.00 : 7d8d: cmp $0xf4240,%r15d
0.00 : 7e60: mov $0x1,%al | 0.00 : 7d94: mov $0x1,%al
0.00 : 7e62: mov %ecx,%r15d | 0.00 : 7d96: mov %ecx,%r15d
0.00 : 7e65: jl 7c30 <splay::main::h7cf589df5d172d0b+0 | 0.00 : 7d99: jl 7b80 <splay::main::h7cf589df5d172d0b+0
: tree.parent(); : tree.parent();
: } : }
: } : }
: :
: fn main() { : fn main() {
: let mut splay = Splay::new(); : let mut splay = Splay::new();
0.00 : 7e6b: mov %rbx,%rdi | 0.00 : 7d9f: mov %rbx,%rdi
0.00 : 7e6e: callq 7810 <drop::hddf9fd0101172c6c> | 0.00 : 7da2: callq 7810 <drop::hddf9fd0101172c6c>
: print(tree, depth + 1); : print(tree, depth + 1);
: tree.parent(); : tree.parent();
: } : }
: } : }
: :
: fn main() { : fn main() {
0.00 : 7e73: add $0x88,%rsp | 0.00 : 7da7: add $0x68,%rsp
0.00 : 7e7a: pop %rbx | 0.00 : 7dab: pop %rbx
0.00 : 7e7b: pop %r12 | 0.00 : 7dac: pop %r12
0.00 : 7e7d: pop %r13 | 0.00 : 7dae: pop %r13
0.00 : 7e7f: pop %r14 | 0.00 : 7db0: pop %r14
0.00 : 7e81: pop %r15 | 0.00 : 7db2: pop %r15
0.00 : 7e83: pop %rbp | 0.00 : 7db4: pop %rbp
0.00 : 7e84: retq | 0.00 : 7db5: retq
: Some(index) : Some(index)
: } : }
: } : }
: :
: fn child(&mut self, index: usize) -> bool { : fn child(&mut self, index: usize) -> bool {
: let child = unsafe { (*self.node).children[index] }; : let child = unsafe { (*self.node).children[index] };
0.00 : 7e85: lea 0x250b04(%rip),%rdi # 258990 <p | 0.00 : 7db6: lea 0x250bd3(%rip),%rdi # 258990 <p
0.00 : 7e8c: mov $0x2,%edx | 0.00 : 7dbd: mov $0x2,%edx
0.00 : 7e91: mov %r13,%rsi | 0.00 : 7dc2: mov %r13,%rsi
0.00 : 7e94: callq 44740 <core::panicking::panic_bounds_c | 0.00 : 7dc5: callq 44640 <core::panicking::panic_bounds_c
0.00 : 7e99: callq 189c0 <alloc::oom::oom::hf03dbd680f815 | 0.00 : 7dca: callq 188c0 <alloc::oom::oom::hf03dbd680f815
0.00 : 7e9e: callq 189c0 <alloc::oom::oom::hf03dbd680f815 <
0.00 : 7ea3: jmp 7ea7 <splay::main::h7cf589df5d172d0b+0 <
0.00 : 7ea5: jmp 7eae <splay::main::h7cf589df5d172d0b+0 <
0.00 : 7ea7: mov %rax,%rbx <
0.00 : 7eaa: jmp 7eba <splay::main::h7cf589df5d172d0b+0 <
0.00 : 7eac: jmp 7eae <splay::main::h7cf589df5d172d0b+0 <
0.00 : 7eae: mov %rax,%rbx <
: } <
: <
: fn insert(&mut self, value: T) { <
: match self.tree.take() { <
: None => self.tree = Some(Tree::new(value)), <
: Some(mut tree) => { <
0.00 : 7eb1: lea -0x40(%rbp),%rdi <
0.00 : 7eb5: callq 7810 <drop::hddf9fd0101172c6c> <
0.00 : 7eba: mov %rbx,%rdi <
0.00 : 7ebd: callq 7680 <_Unwind_Resume@plt> <
0.00 : 7ec2: jmp 7ea7 <splay::main::h7cf589df5d172d0b+0 <
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment