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