crypt/md5-crypt.v.s

   1         .file   "md5-crypt.c"
   2 # GNU C11 (GCC) version 7.3.0 (x86_64-nyan-linux-gnu)
   3 #       compiled by GNU C version 7.3.0, GMP version 6.1.2, MPFR version 4.0.1, MPC version 1.1.0, isl version none
   4 # GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072
   5 # options passed:  -I ../include
   6 # -I /root/wip/nyanglibc/builds/0/nyanglibc/build/crypt
   7 # -I /root/wip/nyanglibc/builds/0/nyanglibc/build
   8 # -I ../sysdeps/unix/sysv/linux/x86_64/64
   9 # -I ../sysdeps/unix/sysv/linux/x86_64
  10 # -I ../sysdeps/unix/sysv/linux/x86/include
  11 # -I ../sysdeps/unix/sysv/linux/x86 -I ../sysdeps/x86/nptl
  12 # -I ../sysdeps/unix/sysv/linux/wordsize-64 -I ../sysdeps/x86_64/nptl
  13 # -I ../sysdeps/unix/sysv/linux/include -I ../sysdeps/unix/sysv/linux
  14 # -I ../sysdeps/nptl -I ../sysdeps/pthread -I ../sysdeps/gnu
  15 # -I ../sysdeps/unix/inet -I ../sysdeps/unix/sysv -I ../sysdeps/unix/x86_64
  16 # -I ../sysdeps/unix -I ../sysdeps/posix -I ../sysdeps/x86_64/64
  17 # -I ../sysdeps/x86_64/fpu -I ../sysdeps/x86/fpu -I ../sysdeps/x86_64
  18 # -I ../sysdeps/x86/include -I ../sysdeps/x86
  19 # -I ../sysdeps/ieee754/float128 -I ../sysdeps/ieee754/ldbl-96/include
  20 # -I ../sysdeps/ieee754/ldbl-96 -I ../sysdeps/ieee754/dbl-64
  21 # -I ../sysdeps/ieee754/flt-32 -I ../sysdeps/wordsize-64
  22 # -I ../sysdeps/ieee754 -I ../sysdeps/generic -I .. -I ../libio -I .
  23 # -MD /run/asm/crypt/md5-crypt.v.d -MF /run/asm/crypt/md5-crypt.o.dt -MP
  24 # -MT /run/asm/crypt/.o -D _LIBC_REENTRANT -D MODULE_NAME=libcrypt -D PIC
  25 # -D TOP_NAMESPACE=glibc
  26 # -include /root/wip/nyanglibc/builds/0/nyanglibc/build/libc-modules.h
  27 # -include ../include/libc-symbols.h md5-crypt.c -mtune=generic
  28 # -march=x86-64 -auxbase-strip /run/asm/crypt/md5-crypt.v.s -O2 -Wall
  29 # -Wwrite-strings -Wundef -Werror -Wstrict-prototypes
  30 # -Wold-style-definition -std=gnu11 -fverbose-asm -fgnu89-inline
  31 # -fmerge-all-constants -frounding-math -fno-stack-protector -fmath-errno
  32 # -fpie -ftls-model=initial-exec
  33 # options enabled:  -faggressive-loop-optimizations -falign-labels
  34 # -fasynchronous-unwind-tables -fauto-inc-dec -fbranch-count-reg
  35 # -fcaller-saves -fchkp-check-incomplete-type -fchkp-check-read
  36 # -fchkp-check-write -fchkp-instrument-calls -fchkp-narrow-bounds
  37 # -fchkp-optimize -fchkp-store-bounds -fchkp-use-static-bounds
  38 # -fchkp-use-static-const-bounds -fchkp-use-wrappers -fcode-hoisting
  39 # -fcombine-stack-adjustments -fcommon -fcompare-elim -fcprop-registers
  40 # -fcrossjumping -fcse-follow-jumps -fdefer-pop
  41 # -fdelete-null-pointer-checks -fdevirtualize -fdevirtualize-speculatively
  42 # -fdwarf2-cfi-asm -fearly-inlining -feliminate-unused-debug-types
  43 # -fexpensive-optimizations -fforward-propagate -ffp-int-builtin-inexact
  44 # -ffunction-cse -fgcse -fgcse-lm -fgnu-runtime -fgnu-unique
  45 # -fguess-branch-probability -fhoist-adjacent-loads -fident -fif-conversion
  46 # -fif-conversion2 -findirect-inlining -finline -finline-atomics
  47 # -finline-functions-called-once -finline-small-functions -fipa-bit-cp
  48 # -fipa-cp -fipa-icf -fipa-icf-functions -fipa-icf-variables -fipa-profile
  49 # -fipa-pure-const -fipa-ra -fipa-reference -fipa-sra -fipa-vrp
  50 # -fira-hoist-pressure -fira-share-save-slots -fira-share-spill-slots
  51 # -fisolate-erroneous-paths-dereference -fivopts -fkeep-static-consts
  52 # -fleading-underscore -flifetime-dse -flra-remat -flto-odr-type-merging
  53 # -fmath-errno -fmerge-all-constants -fmerge-debug-strings
  54 # -fmove-loop-invariants -fomit-frame-pointer -foptimize-sibling-calls
  55 # -foptimize-strlen -fpartial-inlining -fpeephole -fpeephole2 -fpic -fpie
  56 # -fplt -fprefetch-loop-arrays -free -freg-struct-return -freorder-blocks
  57 # -freorder-functions -frerun-cse-after-loop -frounding-math
  58 # -fsched-critical-path-heuristic -fsched-dep-count-heuristic
  59 # -fsched-group-heuristic -fsched-interblock -fsched-last-insn-heuristic
  60 # -fsched-rank-heuristic -fsched-spec -fsched-spec-insn-heuristic
  61 # -fsched-stalled-insns-dep -fschedule-fusion -fschedule-insns2
  62 # -fsemantic-interposition -fshow-column -fshrink-wrap
  63 # -fshrink-wrap-separate -fsigned-zeros -fsplit-ivs-in-unroller
  64 # -fsplit-wide-types -fssa-backprop -fssa-phiopt -fstdarg-opt
  65 # -fstore-merging -fstrict-aliasing -fstrict-overflow
  66 # -fstrict-volatile-bitfields -fsync-libcalls -fthread-jumps
  67 # -ftoplevel-reorder -ftrapping-math -ftree-bit-ccp -ftree-builtin-call-dce
  68 # -ftree-ccp -ftree-ch -ftree-coalesce-vars -ftree-copy-prop -ftree-cselim
  69 # -ftree-dce -ftree-dominator-opts -ftree-dse -ftree-forwprop -ftree-fre
  70 # -ftree-loop-if-convert -ftree-loop-im -ftree-loop-ivcanon
  71 # -ftree-loop-optimize -ftree-parallelize-loops= -ftree-phiprop -ftree-pre
  72 # -ftree-pta -ftree-reassoc -ftree-scev-cprop -ftree-sink -ftree-slsr
  73 # -ftree-sra -ftree-switch-conversion -ftree-tail-merge -ftree-ter
  74 # -ftree-vrp -funit-at-a-time -funwind-tables -fverbose-asm
  75 # -fzero-initialized-in-bss -m128bit-long-double -m64 -m80387
  76 # -malign-stringops -mavx256-split-unaligned-load
  77 # -mavx256-split-unaligned-store -mfancy-math-387 -mfp-ret-in-387 -mfxsr
  78 # -mglibc -mieee-fp -mlong-double-80 -mmmx -mno-sse4 -mpush-args -mred-zone
  79 # -msse -msse2 -mstv -mtls-direct-seg-refs -mvzeroupper
  80
  81         .text
  82 #APP
  83         .section __libc_freeres_ptrs, "aw", %nobits
  84         .previous
  85         .section        .rodata.str1.1,"aMS",@progbits,1
  86 .LC0:
  87         .string "$"
  88 #NO_APP
  89         .text
  90         .p2align 4,,15
  91         .globl  __md5_crypt_r
  92         .type   __md5_crypt_r, @function
  93 __md5_crypt_r:
  94 .LFB41:
  95         .cfi_startproc
  96         pushq   %rbp    #
  97         .cfi_def_cfa_offset 16
  98         .cfi_offset 6, -16
  99         movq    %rsp, %rbp      #,
 100         .cfi_def_cfa_register 6
 101         pushq   %r15    #
 102         pushq   %r14    #
 103         pushq   %r13    #
 104         pushq   %r12    #
 105         .cfi_offset 15, -24
 106         .cfi_offset 14, -32
 107         .cfi_offset 13, -40
 108         .cfi_offset 12, -48
 109         movq    %rdi, %r15      # key, key
 110         pushq   %rbx    #
 111 # md5-crypt.c:107:   if (strncmp (md5_salt_prefix, salt, sizeof (md5_salt_prefix) - 1) == 0)
 112         leaq    md5_salt_prefix(%rip), %rdi     #,
 113         .cfi_offset 3, -56
 114 # md5-crypt.c:93: {
 115         movq    %rsi, %rbx      # salt, salt
 116         subq    $456, %rsp      #,
 117 # md5-crypt.c:93: {
 118         movq    %rdx, -440(%rbp)        # buffer, %sfp
 119 # md5-crypt.c:107:   if (strncmp (md5_salt_prefix, salt, sizeof (md5_salt_prefix) - 1) == 0)
 120         movl    $3, %edx        #,
 121 # md5-crypt.c:93: {
 122         movl    %ecx, -404(%rbp)        # buflen, buflen
 123 # md5-crypt.c:107:   if (strncmp (md5_salt_prefix, salt, sizeof (md5_salt_prefix) - 1) == 0)
 124         call    strncmp@PLT     #
 125 # md5-crypt.c:109:     salt += sizeof (md5_salt_prefix) - 1;
 126         leaq    3(%rbx), %rdx   #, tmp384
 127         testl   %eax, %eax      # _1
 128 # md5-crypt.c:111:   salt_len = MIN (strcspn (salt, "$"), 8);
 129         leaq    .LC0(%rip), %rsi        #,
 130 # md5-crypt.c:109:     salt += sizeof (md5_salt_prefix) - 1;
 131         cmovne  %rbx, %rdx      # tmp384,, salt, tmp384
 132         movq    %rdx, %rdi      # tmp384, salt
 133         movq    %rdx, -432(%rbp)        # salt, %sfp
 134 # md5-crypt.c:111:   salt_len = MIN (strcspn (salt, "$"), 8);
 135         call    strcspn@PLT     #
 136         cmpq    $8, %rax        #, _2
 137         movq    %rax, %rcx      #, _2
 138         movl    $8, %eax        #, tmp386
 139         cmovb   %rcx, %rax      # _2,, tmp386
 140 # md5-crypt.c:112:   key_len = strlen (key);
 141         movq    %r15, %rdi      # key,
 142 # md5-crypt.c:111:   salt_len = MIN (strcspn (salt, "$"), 8);
 143         movq    %rax, -424(%rbp)        # tmp386, %sfp
 144 # md5-crypt.c:112:   key_len = strlen (key);
 145         call    strlen@PLT      #
 146 # md5-crypt.c:114:   if ((key - (char *) 0) % __alignof__ (md5_uint32) != 0)
 147         testb   $3, %r15b       #, key
 148 # md5-crypt.c:112:   key_len = strlen (key);
 149         movq    %rax, -416(%rbp)        # tmp184, %sfp
 150 # md5-crypt.c:114:   if ((key - (char *) 0) % __alignof__ (md5_uint32) != 0)
 151         je      .L34    #,
 152 # md5-crypt.c:118:       if (__libc_use_alloca (alloca_used + key_len + __alignof__ (md5_uint32)))
 153         leaq    4(%rax), %rbx   #, _5
 154 # ../sysdeps/pthread/allocalim.h:27:   return (__glibc_likely (__libc_alloca_cutoff (size))
 155         movq    %rbx, %rdi      # _5,
 156         call    __libc_alloca_cutoff@PLT        #
 157 # ../sysdeps/pthread/allocalim.h:29:           || __glibc_likely (size <= PTHREAD_STACK_MIN / 4)
 158         testl   %eax, %eax      # _174
 159         jne     .L5     #,
 160         cmpq    $4096, %rbx     #, _5
 161         ja      .L68    #,
 162 .L5:
 163 # md5-crypt.c:119:      tmp = (char *) alloca (key_len + __alignof__ (md5_uint32));
 164         addq    $30, %rbx       #, tmp194
 165 # md5-crypt.c:102:   char *free_key = NULL;
 166         movq    $0, -456(%rbp)  #, %sfp
 167 # md5-crypt.c:119:      tmp = (char *) alloca (key_len + __alignof__ (md5_uint32));
 168         andq    $-16, %rbx      #, tmp198
 169         subq    %rbx, %rsp      # tmp198,
 170         leaq    15(%rsp), %rbx  #, tmp200
 171         andq    $-16, %rbx      #, <retval>
 172 .L7:
 173 # md5-crypt.c:127:       key = copied_key =
 174         movq    -416(%rbp), %rdx        # %sfp,
 175 # md5-crypt.c:129:              - (tmp - (char *) 0) % __alignof__ (md5_uint32),
 176         leaq    4(%rbx), %rdi   #, tmp203
 177 # md5-crypt.c:127:       key = copied_key =
 178         movq    %r15, %rsi      # key,
 179         call    memcpy@PLT      #
 180         movq    %rax, %r15      #, key
 181         movq    %rax, -464(%rbp)        # key, %sfp
 182 .L4:
 183 # md5-crypt.c:134:   if ((salt - (char *) 0) % __alignof__ (md5_uint32) != 0)
 184         testb   $3, -432(%rbp)  #, %sfp
 185 # md5-crypt.c:101:   char *copied_salt = NULL;
 186         movq    $0, -448(%rbp)  #, %sfp
 187 # md5-crypt.c:134:   if ((salt - (char *) 0) % __alignof__ (md5_uint32) != 0)
 188         jne     .L69    #,
 189 .L8:
 190 # md5-crypt.c:160:   md5_init_ctx (&ctx, nss_ctx);
 191         leaq    -368(%rbp), %r12        #, tmp382
 192 # md5-crypt.c:178:   md5_init_ctx (&alt_ctx, nss_alt_ctx);
 193         leaq    -208(%rbp), %rbx        #, tmp383
 194 # md5-crypt.c:160:   md5_init_ctx (&ctx, nss_ctx);
 195         movq    %r12, %rdi      # tmp382,
 196         call    __md5_init_ctx@PLT      #
 197 # md5-crypt.c:163:   md5_process_bytes (key, key_len, &ctx, nss_ctx);
 198         movq    -416(%rbp), %r14        # %sfp, tmp184
 199         movq    %r12, %rdx      # tmp382,
 200         movq    %r15, %rdi      # key,
 201         movq    %r14, %rsi      # tmp184,
 202         call    __md5_process_bytes@PLT #
 203 # md5-crypt.c:167:   md5_process_bytes (md5_salt_prefix, sizeof (md5_salt_prefix) - 1,
 204         leaq    md5_salt_prefix(%rip), %rdi     #,
 205         movq    %r12, %rdx      # tmp382,
 206         movl    $3, %esi        #,
 207         call    __md5_process_bytes@PLT #
 208 # md5-crypt.c:173:   md5_process_bytes (salt, salt_len, &ctx, nss_ctx);
 209         movq    -432(%rbp), %r13        # %sfp, salt
 210         movq    -424(%rbp), %rsi        # %sfp,
 211         movq    %r12, %rdx      # tmp382,
 212         movq    %r13, %rdi      # salt,
 213         call    __md5_process_bytes@PLT #
 214 # md5-crypt.c:178:   md5_init_ctx (&alt_ctx, nss_alt_ctx);
 215         movq    %rbx, %rdi      # tmp383,
 216         movq    %rbx, -472(%rbp)        # tmp383, %sfp
 217         call    __md5_init_ctx@PLT      #
 218 # md5-crypt.c:181:   md5_process_bytes (key, key_len, &alt_ctx, nss_alt_ctx);
 219         movq    %rbx, %rdx      # tmp383,
 220         movq    %r14, %rsi      # tmp184,
 221         movq    %r15, %rdi      # key,
 222         call    __md5_process_bytes@PLT #
 223 # md5-crypt.c:184:   md5_process_bytes (salt, salt_len, &alt_ctx, nss_alt_ctx);
 224         movq    -424(%rbp), %rsi        # %sfp,
 225         movq    %r13, %rdi      # salt,
 226         movq    %rbx, %rdx      # tmp383,
 227 # md5-crypt.c:191:   md5_finish_ctx (&alt_ctx, nss_alt_ctx, alt_result);
 228         leaq    -384(%rbp), %r13        #, tmp381
 229 # md5-crypt.c:184:   md5_process_bytes (salt, salt_len, &alt_ctx, nss_alt_ctx);
 230         call    __md5_process_bytes@PLT #
 231 # md5-crypt.c:187:   md5_process_bytes (key, key_len, &alt_ctx, nss_alt_ctx);
 232         movq    %rbx, %rdx      # tmp383,
 233         movq    %r14, %rsi      # tmp184,
 234         movq    %r15, %rdi      # key,
 235         call    __md5_process_bytes@PLT #
 236 # md5-crypt.c:191:   md5_finish_ctx (&alt_ctx, nss_alt_ctx, alt_result);
 237         movq    %r13, %rsi      # tmp381,
 238         movq    %rbx, %rdi      # tmp383,
 239         call    __md5_finish_ctx@PLT    #
 240 # md5-crypt.c:194:   for (cnt = key_len; cnt > 16; cnt -= 16)
 241         cmpq    $16, %r14       #, tmp184
 242         jbe     .L15    #,
 243         leaq    -17(%r14), %rax #, _194
 244         leaq    -16(%r14), %rcx #, _192
 245         movq    %rax, -488(%rbp)        # _194, %sfp
 246         andq    $-16, %rax      #, tmp268
 247         movq    %rcx, -480(%rbp)        # _192, %sfp
 248         subq    %rax, %rcx      # tmp268, _175
 249         movq    %rcx, %rbx      # _175, _175
 250         .p2align 4,,10
 251         .p2align 3
 252 .L16:
 253 # md5-crypt.c:195:     md5_process_bytes (alt_result, 16, &ctx, nss_ctx);
 254         movq    %r12, %rdx      # tmp382,
 255         movl    $16, %esi       #,
 256         movq    %r13, %rdi      # tmp381,
 257 # md5-crypt.c:194:   for (cnt = key_len; cnt > 16; cnt -= 16)
 258         subq    $16, %r14       #, cnt
 259 # md5-crypt.c:195:     md5_process_bytes (alt_result, 16, &ctx, nss_ctx);
 260         call    __md5_process_bytes@PLT #
 261 # md5-crypt.c:194:   for (cnt = key_len; cnt > 16; cnt -= 16)
 262         cmpq    %rbx, %r14      # _175, cnt
 263         jne     .L16    #,
 264 # md5-crypt.c:196:   md5_process_bytes (alt_result, cnt, &ctx, nss_ctx);
 265         movq    -488(%rbp), %r14        # %sfp, _194
 266         movq    -480(%rbp), %rsi        # %sfp, _192
 267         movq    %r12, %rdx      # tmp382,
 268         movq    %r13, %rdi      # tmp381,
 269         andq    $-16, %r14      #, _194
 270         subq    %r14, %rsi      # tmp274, _192
 271         call    __md5_process_bytes@PLT #
 272 # md5-crypt.c:199:   *alt_result = '\0';
 273         movb    $0, -384(%rbp)  #, alt_result
 274 .L17:
 275 # md5-crypt.c:194:   for (cnt = key_len; cnt > 16; cnt -= 16)
 276         movq    -416(%rbp), %rbx        # %sfp, cnt
 277         .p2align 4,,10
 278         .p2align 3
 279 .L20:
 280 # md5-crypt.c:206:     md5_process_bytes ((cnt & 1) != 0
 281         testb   $1, %bl #, cnt
 282         movq    %r15, %rdi      # key, iftmp.7_88
 283         movq    %r12, %rdx      # tmp382,
 284         cmovne  %r13, %rdi      # tmp381,, iftmp.7_88
 285         movl    $1, %esi        #,
 286         call    __md5_process_bytes@PLT #
 287 # md5-crypt.c:205:   for (cnt = key_len; cnt > 0; cnt >>= 1)
 288         shrq    %rbx    # cnt
 289         jne     .L20    #,
 290 .L18:
 291 # md5-crypt.c:211:   md5_finish_ctx (&ctx, nss_ctx, alt_result);
 292         movq    %r13, %rsi      # tmp381,
 293         movq    %r12, %rdi      # tmp382,
 294 # md5-crypt.c:216:   for (cnt = 0; cnt < 1000; ++cnt)
 295         xorl    %ebx, %ebx      # cnt
 296 # md5-crypt.c:211:   md5_finish_ctx (&ctx, nss_ctx, alt_result);
 297         call    __md5_finish_ctx@PLT    #
 298         jmp     .L27    #
 299         .p2align 4,,10
 300         .p2align 3
 301 .L73:
 302 # md5-crypt.c:223:      md5_process_bytes (key, key_len, &ctx, nss_ctx);
 303         movq    -416(%rbp), %rsi        # %sfp,
 304         movq    %r15, %rdi      # key,
 305         call    __md5_process_bytes@PLT #
 306 .L22:
 307 # md5-crypt.c:228:       if (cnt % 3 != 0)
 308         movabsq $-6148914691236517205, %rax     #, tmp406
 309         mulq    %rbx    # cnt
 310         shrq    %rdx    # tmp288
 311         leaq    (%rdx,%rdx,2), %rax     #, tmp293
 312         cmpq    %rax, %rbx      # tmp293, cnt
 313         jne     .L70    #,
 314 .L23:
 315 # md5-crypt.c:232:       if (cnt % 7 != 0)
 316         movabsq $5270498306774157605, %rax      #, tmp407
 317         imulq   %rbx    # cnt
 318         movq    %rbx, %rax      # cnt, tmp318
 319         sarq    $63, %rax       #, tmp318
 320         sarq    %rdx    # tmp317
 321         subq    %rax, %rdx      # tmp318, tmp314
 322         leaq    0(,%rdx,8), %rax        #, tmp320
 323         subq    %rdx, %rax      # tmp314, tmp321
 324         cmpq    %rax, %rbx      # tmp321, cnt
 325         jne     .L71    #,
 326 .L24:
 327 # md5-crypt.c:236:       if ((cnt & 1) != 0)
 328         testq   %r14, %r14      # _12
 329 # md5-crypt.c:237:      md5_process_bytes (alt_result, 16, &ctx, nss_ctx);
 330         movq    %r12, %rdx      # tmp382,
 331 # md5-crypt.c:236:       if ((cnt & 1) != 0)
 332         je      .L25    #,
 333 # md5-crypt.c:237:      md5_process_bytes (alt_result, 16, &ctx, nss_ctx);
 334         movl    $16, %esi       #,
 335         movq    %r13, %rdi      # tmp381,
 336         call    __md5_process_bytes@PLT #
 337 .L26:
 338 # md5-crypt.c:242:       md5_finish_ctx (&ctx, nss_ctx, alt_result);
 339         movq    %r13, %rsi      # tmp381,
 340         movq    %r12, %rdi      # tmp382,
 341 # md5-crypt.c:216:   for (cnt = 0; cnt < 1000; ++cnt)
 342         addq    $1, %rbx        #, cnt
 343 # md5-crypt.c:242:       md5_finish_ctx (&ctx, nss_ctx, alt_result);
 344         call    __md5_finish_ctx@PLT    #
 345 # md5-crypt.c:216:   for (cnt = 0; cnt < 1000; ++cnt)
 346         cmpq    $1000, %rbx     #, cnt
 347         je      .L72    #,
 348 .L27:
 349 # md5-crypt.c:219:       md5_init_ctx (&ctx, nss_ctx);
 350         movq    %r12, %rdi      # tmp382,
 351 # md5-crypt.c:222:       if ((cnt & 1) != 0)
 352         movq    %rbx, %r14      # cnt, _12
 353 # md5-crypt.c:219:       md5_init_ctx (&ctx, nss_ctx);
 354         call    __md5_init_ctx@PLT      #
 355 # md5-crypt.c:222:       if ((cnt & 1) != 0)
 356         andl    $1, %r14d       #, _12
 357 # md5-crypt.c:223:      md5_process_bytes (key, key_len, &ctx, nss_ctx);
 358         movq    %r12, %rdx      # tmp382,
 359 # md5-crypt.c:222:       if ((cnt & 1) != 0)
 360         jne     .L73    #,
 361 # md5-crypt.c:225:      md5_process_bytes (alt_result, 16, &ctx, nss_ctx);
 362         movl    $16, %esi       #,
 363         movq    %r13, %rdi      # tmp381,
 364         call    __md5_process_bytes@PLT #
 365         jmp     .L22    #
 366         .p2align 4,,10
 367         .p2align 3
 368 .L25:
 369 # md5-crypt.c:239:      md5_process_bytes (key, key_len, &ctx, nss_ctx);
 370         movq    -416(%rbp), %rsi        # %sfp,
 371         movq    %r15, %rdi      # key,
 372         call    __md5_process_bytes@PLT #
 373         jmp     .L26    #
 374         .p2align 4,,10
 375         .p2align 3
 376 .L71:
 377 # md5-crypt.c:233:      md5_process_bytes (key, key_len, &ctx, nss_ctx);
 378         movq    -416(%rbp), %rsi        # %sfp,
 379         movq    %r12, %rdx      # tmp382,
 380         movq    %r15, %rdi      # key,
 381         call    __md5_process_bytes@PLT #
 382         jmp     .L24    #
 383         .p2align 4,,10
 384         .p2align 3
 385 .L70:
 386 # md5-crypt.c:229:      md5_process_bytes (salt, salt_len, &ctx, nss_ctx);
 387         movq    -424(%rbp), %rsi        # %sfp,
 388         movq    -432(%rbp), %rdi        # %sfp,
 389         movq    %r12, %rdx      # tmp382,
 390         call    __md5_process_bytes@PLT #
 391         jmp     .L23    #
 392         .p2align 4,,10
 393         .p2align 3
 394 .L72:
 395 # md5-crypt.c:252:   cp = __stpncpy (buffer, md5_salt_prefix, MAX (0, buflen));
 396         movl    -404(%rbp), %edx        # buflen,
 397         xorl    %ebx, %ebx      # tmp330
 398         movq    -440(%rbp), %rdi        # %sfp,
 399         leaq    md5_salt_prefix(%rip), %rsi     #,
 400         testl   %edx, %edx      #
 401         movl    %ebx, %edx      # tmp330, tmp329
 402         cmovns  -404(%rbp), %edx        # buflen,, tmp329
 403         movslq  %edx, %rdx      # tmp329, tmp331
 404         call    __stpncpy@PLT   #
 405 # md5-crypt.c:253:   buflen -= sizeof (md5_salt_prefix) - 1;
 406         movl    -404(%rbp), %ecx        # buflen, tmp444
 407 # md5-crypt.c:255:   cp = __stpncpy (cp, salt, MIN ((size_t) MAX (0, buflen), salt_len));
 408         movq    -424(%rbp), %r15        # %sfp, _2
 409         movq    %rax, %rdi      # _18,
 410         movq    -432(%rbp), %rsi        # %sfp,
 411 # md5-crypt.c:252:   cp = __stpncpy (buffer, md5_salt_prefix, MAX (0, buflen));
 412         movq    %rax, -392(%rbp)        # _18, cp
 413 # md5-crypt.c:253:   buflen -= sizeof (md5_salt_prefix) - 1;
 414         leal    -3(%rcx), %edx  #, _22
 415 # md5-crypt.c:255:   cp = __stpncpy (cp, salt, MIN ((size_t) MAX (0, buflen), salt_len));
 416         testl   %edx, %edx      # _22
 417 # md5-crypt.c:253:   buflen -= sizeof (md5_salt_prefix) - 1;
 418         movl    %edx, -404(%rbp)        # _22, buflen
 419 # md5-crypt.c:255:   cp = __stpncpy (cp, salt, MIN ((size_t) MAX (0, buflen), salt_len));
 420         cmovs   %ebx, %edx      # _22,, tmp330, tmp334
 421         movslq  %edx, %rdx      # tmp334, tmp336
 422         cmpq    %r15, %rdx      # _2, tmp336
 423         cmova   %r15, %rdx      # tmp336,, _2, tmp333
 424         call    __stpncpy@PLT   #
 425 # md5-crypt.c:256:   buflen -= MIN ((size_t) MAX (0, buflen), salt_len);
 426         movl    -404(%rbp), %ecx        # buflen, buflen.13_27
 427 # md5-crypt.c:255:   cp = __stpncpy (cp, salt, MIN ((size_t) MAX (0, buflen), salt_len));
 428         movq    %rax, -392(%rbp)        # _26, cp
 429 # md5-crypt.c:256:   buflen -= MIN ((size_t) MAX (0, buflen), salt_len);
 430         testl   %ecx, %ecx      # buflen.13_27
 431         cmovns  %ecx, %ebx      # buflen.13_27,, tmp330
 432         movslq  %ebx, %rdx      # tmp330,
 433         cmpq    %r15, %rdx      # _2, tmp340
 434         cmova   %r15, %rdx      # tmp340,, _2, tmp337
 435         subl    %edx, %ecx      # tmp337, _34
 436 # md5-crypt.c:258:   if (buflen > 0)
 437         testl   %ecx, %ecx      # _34
 438 # md5-crypt.c:256:   buflen -= MIN ((size_t) MAX (0, buflen), salt_len);
 439         movl    %ecx, -404(%rbp)        # _34, buflen
 440 # md5-crypt.c:258:   if (buflen > 0)
 441         jle     .L28    #,
 442 # md5-crypt.c:260:       *cp++ = '$';
 443         leaq    1(%rax), %rdx   #, tmp341
 444         movq    %rdx, -392(%rbp)        # tmp341, cp
 445         movb    $36, (%rax)     #, *_26
 446 # md5-crypt.c:261:       --buflen;
 447         subl    $1, -404(%rbp)  #, buflen
 448 .L28:
 449 # md5-crypt.c:264:   __b64_from_24bit (&cp, &buflen,
 450         movzbl  -378(%rbp), %ecx        # alt_result, alt_result
 451         movzbl  -384(%rbp), %edx        # alt_result, alt_result
 452         leaq    -404(%rbp), %rbx        #, tmp345
 453         movzbl  -372(%rbp), %r8d        # alt_result,
 454         leaq    -392(%rbp), %r14        #, tmp346
 455         movl    $4, %r9d        #,
 456         movq    %rbx, %rsi      # tmp345,
 457         movq    %r14, %rdi      # tmp346,
 458         call    __b64_from_24bit@PLT    #
 459 # md5-crypt.c:266:   __b64_from_24bit (&cp, &buflen,
 460         movzbl  -377(%rbp), %ecx        # alt_result, alt_result
 461         movzbl  -383(%rbp), %edx        # alt_result, alt_result
 462         movl    $4, %r9d        #,
 463         movzbl  -371(%rbp), %r8d        # alt_result,
 464         movq    %rbx, %rsi      # tmp345,
 465         movq    %r14, %rdi      # tmp346,
 466         call    __b64_from_24bit@PLT    #
 467 # md5-crypt.c:268:   __b64_from_24bit (&cp, &buflen,
 468         movzbl  -376(%rbp), %ecx        # alt_result, alt_result
 469         movzbl  -382(%rbp), %edx        # alt_result, alt_result
 470         movl    $4, %r9d        #,
 471         movzbl  -370(%rbp), %r8d        # alt_result,
 472         movq    %rbx, %rsi      # tmp345,
 473         movq    %r14, %rdi      # tmp346,
 474         call    __b64_from_24bit@PLT    #
 475 # md5-crypt.c:270:   __b64_from_24bit (&cp, &buflen,
 476         movzbl  -375(%rbp), %ecx        # alt_result, alt_result
 477         movzbl  -381(%rbp), %edx        # alt_result, alt_result
 478         movl    $4, %r9d        #,
 479         movzbl  -369(%rbp), %r8d        # alt_result,
 480         movq    %rbx, %rsi      # tmp345,
 481         movq    %r14, %rdi      # tmp346,
 482         call    __b64_from_24bit@PLT    #
 483 # md5-crypt.c:272:   __b64_from_24bit (&cp, &buflen,
 484         movzbl  -374(%rbp), %ecx        # alt_result, alt_result
 485         movzbl  -380(%rbp), %edx        # alt_result, alt_result
 486         movl    $4, %r9d        #,
 487         movzbl  -379(%rbp), %r8d        # alt_result,
 488         movq    %rbx, %rsi      # tmp345,
 489         movq    %r14, %rdi      # tmp346,
 490         call    __b64_from_24bit@PLT    #
 491 # md5-crypt.c:274:   __b64_from_24bit (&cp, &buflen,
 492         movzbl  -373(%rbp), %r8d        # alt_result,
 493         xorl    %ecx, %ecx      #
 494         xorl    %edx, %edx      #
 495         movl    $2, %r9d        #,
 496         movq    %rbx, %rsi      # tmp345,
 497         movq    %r14, %rdi      # tmp346,
 498         call    __b64_from_24bit@PLT    #
 499 # md5-crypt.c:276:   if (buflen <= 0)
 500         movl    -404(%rbp), %eax        # buflen,
 501         testl   %eax, %eax      #
 502         jle     .L74    #,
 503 # md5-crypt.c:282:     *cp = '\0';              /* Terminate the string.  */
 504         movq    -392(%rbp), %rax        # cp, cp.21_71
 505         movq    -440(%rbp), %rbx        # %sfp, <retval>
 506         movb    $0, (%rax)      #, *cp.21_71
 507 .L30:
 508 # md5-crypt.c:289:   __md5_init_ctx (&ctx);
 509         movq    %r12, %rdi      # tmp382,
 510         call    __md5_init_ctx@PLT      #
 511 # md5-crypt.c:290:   __md5_finish_ctx (&ctx, alt_result);
 512         movq    %r13, %rsi      # tmp381,
 513         movq    %r12, %rdi      # tmp382,
 514         call    __md5_finish_ctx@PLT    #
 515 # md5-crypt.c:291:   explicit_bzero (&ctx, sizeof (ctx));
 516         movl    $156, %edx      #,
 517         movl    $156, %esi      #,
 518         movq    %r12, %rdi      # tmp382,
 519         call    __explicit_bzero_chk@PLT        #
 520 # md5-crypt.c:292:   explicit_bzero (&alt_ctx, sizeof (alt_ctx));
 521         movq    -472(%rbp), %rdi        # %sfp,
 522         movl    $156, %edx      #,
 523         movl    $156, %esi      #,
 524         call    __explicit_bzero_chk@PLT        #
 525 # md5-crypt.c:294:   if (copied_key != NULL)
 526         movq    -464(%rbp), %rax        # %sfp, copied_key
 527         testq   %rax, %rax      # copied_key
 528         je      .L31    #,
 529 # md5-crypt.c:295:     explicit_bzero (copied_key, key_len);
 530         movq    -416(%rbp), %rsi        # %sfp,
 531         movq    $-1, %rdx       #,
 532         movq    %rax, %rdi      # copied_key,
 533         call    __explicit_bzero_chk@PLT        #
 534 .L31:
 535 # md5-crypt.c:296:   if (copied_salt != NULL)
 536         movq    -448(%rbp), %rax        # %sfp, copied_salt
 537         testq   %rax, %rax      # copied_salt
 538         je      .L32    #,
 539 # md5-crypt.c:297:     explicit_bzero (copied_salt, salt_len);
 540         movq    -424(%rbp), %rsi        # %sfp,
 541         movq    $-1, %rdx       #,
 542         movq    %rax, %rdi      # copied_salt,
 543         call    __explicit_bzero_chk@PLT        #
 544 .L32:
 545 # md5-crypt.c:299:   free (free_key);
 546         movq    -456(%rbp), %rdi        # %sfp,
 547         call    free@PLT        #
 548 .L1:
 549 # md5-crypt.c:301: }
 550         leaq    -40(%rbp), %rsp #,
 551         movq    %rbx, %rax      # <retval>,
 552         popq    %rbx    #
 553         popq    %r12    #
 554         popq    %r13    #
 555         popq    %r14    #
 556         popq    %r15    #
 557         popq    %rbp    #
 558         .cfi_remember_state
 559         .cfi_def_cfa 7, 8
 560         ret
 561 .L34:
 562         .cfi_restore_state
 563 # md5-crypt.c:102:   char *free_key = NULL;
 564         movq    $0, -456(%rbp)  #, %sfp
 565 # md5-crypt.c:100:   char *copied_key = NULL;
 566         movq    $0, -464(%rbp)  #, %sfp
 567         jmp     .L4     #
 568 .L74:
 569 # md5-crypt.c:278:       __set_errno (ERANGE);
 570         movq    errno@gottpoff(%rip), %rax      #, tmp370
 571 # md5-crypt.c:279:       buffer = NULL;
 572         xorl    %ebx, %ebx      # <retval>
 573 # md5-crypt.c:278:       __set_errno (ERANGE);
 574         movl    $34, %fs:(%rax) #, errno
 575         jmp     .L30    #
 576 .L69:
 577 # md5-crypt.c:136:       char *tmp = (char *) alloca (salt_len + __alignof__ (md5_uint32));
 578         movq    -424(%rbp), %rsi        # %sfp, _2
 579         leaq    34(%rsi), %rax  #, tmp213
 580         andq    $-16, %rax      #, tmp217
 581         subq    %rax, %rsp      # tmp217,
 582 # md5-crypt.c:137:       salt = copied_salt =
 583         movl    %esi, %eax      # _2,
 584 # md5-crypt.c:136:       char *tmp = (char *) alloca (salt_len + __alignof__ (md5_uint32));
 585         leaq    15(%rsp), %rdx  #, tmp219
 586         andq    $-16, %rdx      #, tmp221
 587 # md5-crypt.c:137:       salt = copied_salt =
 588         cmpl    $8, %esi        #, _2
 589 # md5-crypt.c:139:              - (tmp - (char *) 0) % __alignof__ (md5_uint32),
 590         leaq    4(%rdx), %rcx   #, tmp222
 591 # md5-crypt.c:137:       salt = copied_salt =
 592         jnb     .L9     #,
 593         andl    $4, %esi        #, _2
 594         jne     .L75    #,
 595         testl   %eax, %eax      # _2
 596         je      .L10    #,
 597         movq    -432(%rbp), %rsi        # %sfp, salt
 598         testb   $2, %al #, _2
 599         movzbl  (%rsi), %esi    #* salt, tmp235
 600         movb    %sil, 4(%rdx)   # tmp235,
 601         jne     .L76    #,
 602 .L10:
 603         movq    %rcx, -432(%rbp)        # salt, %sfp
 604         movq    %rcx, -448(%rbp)        # salt, %sfp
 605         jmp     .L8     #
 606 .L9:
 607         movq    -432(%rbp), %rdi        # %sfp, salt
 608         addq    $8, %rdx        #, tmp252
 609         movq    (%rdi), %rax    #* salt, tmp244
 610         movq    %rax, -4(%rdx)  # tmp244,
 611         movq    -424(%rbp), %rbx        # %sfp, _2
 612         movl    %ebx, %eax      # _2, _2
 613         movq    -8(%rdi,%rax), %rsi     #, tmp251
 614         movq    %rsi, -8(%rcx,%rax)     # tmp251,
 615         movq    %rcx, %rax      # tmp222, tmp224
 616         subq    %rdx, %rax      # tmp252, tmp224
 617         subq    %rax, %rdi      # tmp224, salt
 618         addl    %ebx, %eax      # _2, _2
 619         andl    $-8, %eax       #, _2
 620         movq    %rdi, %r8       # salt, salt
 621         cmpl    $8, %eax        #, _2
 622         jb      .L10    #,
 623         andl    $-8, %eax       #, tmp254
 624         xorl    %esi, %esi      # tmp253
 625 .L13:
 626         movl    %esi, %edi      # tmp253, tmp255
 627         addl    $8, %esi        #, tmp253
 628         movq    (%r8,%rdi), %r9 #, tmp256
 629         cmpl    %eax, %esi      # tmp254, tmp253
 630         movq    %r9, (%rdx,%rdi)        # tmp256,
 631         jb      .L13    #,
 632         jmp     .L10    #
 633 .L15:
 634 # md5-crypt.c:196:   md5_process_bytes (alt_result, cnt, &ctx, nss_ctx);
 635         movq    -416(%rbp), %rbx        # %sfp, tmp184
 636         movq    %r12, %rdx      # tmp382,
 637         movq    %r13, %rdi      # tmp381,
 638         movq    %rbx, %rsi      # tmp184,
 639         call    __md5_process_bytes@PLT #
 640 # md5-crypt.c:205:   for (cnt = key_len; cnt > 0; cnt >>= 1)
 641         testq   %rbx, %rbx      # tmp184
 642 # md5-crypt.c:199:   *alt_result = '\0';
 643         movb    $0, -384(%rbp)  #, alt_result
 644 # md5-crypt.c:205:   for (cnt = key_len; cnt > 0; cnt >>= 1)
 645         je      .L18    #,
 646         jmp     .L17    #
 647         .p2align 4,,10
 648         .p2align 3
 649 .L75:
 650 # md5-crypt.c:137:       salt = copied_salt =
 651         movq    -432(%rbp), %rdi        # %sfp, salt
 652         movl    (%rdi), %esi    #* salt, tmp227
 653         movl    %esi, 4(%rdx)   # tmp227,
 654         movl    -4(%rdi,%rax), %edx     #, tmp234
 655         movl    %edx, -4(%rcx,%rax)     # tmp234,
 656         jmp     .L10    #
 657 .L68:
 658 # md5-crypt.c:122:        free_key = tmp = (char *) malloc (key_len + __alignof__ (md5_uint32));
 659         movq    %rbx, %rdi      # _5,
 660         call    malloc@PLT      #
 661 # md5-crypt.c:123:        if (tmp == NULL)
 662         testq   %rax, %rax      # <retval>
 663 # md5-crypt.c:122:        free_key = tmp = (char *) malloc (key_len + __alignof__ (md5_uint32));
 664         movq    %rax, %rbx      #, <retval>
 665 # md5-crypt.c:123:        if (tmp == NULL)
 666         je      .L1     #,
 667         movq    %rax, -456(%rbp)        # <retval>, %sfp
 668         jmp     .L7     #
 669 .L76:
 670 # md5-crypt.c:137:       salt = copied_salt =
 671         movq    -432(%rbp), %rsi        # %sfp, salt
 672         movzwl  -2(%rsi,%rax), %edx     #, tmp243
 673         movw    %dx, -2(%rcx,%rax)      # tmp243,
 674         jmp     .L10    #
 675         .cfi_endproc
 676 .LFE41:
 677         .size   __md5_crypt_r, .-__md5_crypt_r
 678         .p2align 4,,15
 679         .globl  __md5_crypt
 680         .type   __md5_crypt, @function
 681 __md5_crypt:
 682 .LFB42:
 683         .cfi_startproc
 684         pushq   %r12    #
 685         .cfi_def_cfa_offset 16
 686         .cfi_offset 12, -16
 687         pushq   %rbp    #
 688         .cfi_def_cfa_offset 24
 689         .cfi_offset 6, -24
 690         movq    %rdi, %r12      # key, key
 691         pushq   %rbx    #
 692         .cfi_def_cfa_offset 32
 693         .cfi_offset 3, -32
 694 # md5-crypt.c:315:   int needed = 3 + strlen (salt) + 1 + 26 + 1;
 695         movq    %rsi, %rdi      # salt,
 696 # md5-crypt.c:310: {
 697         movq    %rsi, %rbp      # salt, salt
 698 # md5-crypt.c:315:   int needed = 3 + strlen (salt) + 1 + 26 + 1;
 699         call    strlen@PLT      #
 700 # md5-crypt.c:317:   if (buflen < needed)
 701         movl    buflen.5407(%rip), %ecx # buflen, buflen.23_4
 702 # md5-crypt.c:315:   int needed = 3 + strlen (salt) + 1 + 26 + 1;
 703         leal    31(%rax), %ebx  #, needed
 704         movq    buffer(%rip), %rdx      # buffer, <retval>
 705 # md5-crypt.c:317:   if (buflen < needed)
 706         cmpl    %ebx, %ecx      # needed, buflen.23_4
 707         jge     .L78    #,
 708 # md5-crypt.c:319:       char *new_buffer = (char *) realloc (buffer, needed);
 709         movq    %rdx, %rdi      # <retval>,
 710         movslq  %ebx, %rsi      # needed, needed
 711         call    realloc@PLT     #
 712 # md5-crypt.c:320:       if (new_buffer == NULL)
 713         testq   %rax, %rax      # <retval>
 714 # md5-crypt.c:319:       char *new_buffer = (char *) realloc (buffer, needed);
 715         movq    %rax, %rdx      #, <retval>
 716 # md5-crypt.c:320:       if (new_buffer == NULL)
 717         je      .L77    #,
 718 # md5-crypt.c:323:       buffer = new_buffer;
 719         movq    %rax, buffer(%rip)      # <retval>, buffer
 720 # md5-crypt.c:324:       buflen = needed;
 721         movl    %ebx, buflen.5407(%rip) # needed, buflen
 722         movl    %ebx, %ecx      # needed, buflen.23_4
 723 .L78:
 724 # md5-crypt.c:328: }
 725         popq    %rbx    #
 726         .cfi_remember_state
 727         .cfi_def_cfa_offset 24
 728 # md5-crypt.c:327:   return __md5_crypt_r (key, salt, buffer, buflen);
 729         movq    %rbp, %rsi      # salt,
 730         movq    %r12, %rdi      # key,
 731 # md5-crypt.c:328: }
 732         popq    %rbp    #
 733         .cfi_def_cfa_offset 16
 734         popq    %r12    #
 735         .cfi_def_cfa_offset 8
 736 # md5-crypt.c:327:   return __md5_crypt_r (key, salt, buffer, buflen);
 737         jmp     __md5_crypt_r   #
 738         .p2align 4,,10
 739         .p2align 3
 740 .L77:
 741         .cfi_restore_state
 742 # md5-crypt.c:328: }
 743         popq    %rbx    #
 744         .cfi_def_cfa_offset 24
 745         xorl    %eax, %eax      #
 746         popq    %rbp    #
 747         .cfi_def_cfa_offset 16
 748         popq    %r12    #
 749         .cfi_def_cfa_offset 8
 750         ret
 751         .cfi_endproc
 752 .LFE42:
 753         .size   __md5_crypt, .-__md5_crypt
 754         .local  buflen.5407
 755         .comm   buflen.5407,4,4
 756         .section        __libc_freeres_ptrs
 757         #,"aw",@progbits
 758         .align 8
 759         .type   buffer, @object
 760         .size   buffer, 8
 761 buffer:
 762         .zero   8
 763         .section        .rodata.str1.1
 764         .type   md5_salt_prefix, @object
 765         .size   md5_salt_prefix, 4
 766 md5_salt_prefix:
 767         .string "$1$"
 768         .ident  "GCC: (GNU) 7.3.0"
 769         .section        .note.GNU-stack,"",@progbits