crypt/crypt-entry.v.s

   1         .file   "crypt-entry.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/crypt-entry.v.d -MF /run/asm/crypt/crypt-entry.o.dt
  24 # -MP -MT /run/asm/crypt/.o -D _LIBC_REENTRANT -D MODULE_NAME=libcrypt
  25 # -D PIC -D TOP_NAMESPACE=glibc
  26 # -include /root/wip/nyanglibc/builds/0/nyanglibc/build/libc-modules.h
  27 # -include ../include/libc-symbols.h crypt-entry.c -mtune=generic
  28 # -march=x86-64 -auxbase-strip /run/asm/crypt/crypt-entry.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         .section        .rodata.str1.1,"aMS",@progbits,1
  83 .LC0:
  84         .string "/proc/sys/crypto/fips_enabled"
  85         .text
  86         .p2align 4,,15
  87         .type   fips_enabled_p, @function
  88 fips_enabled_p:
  89 .LFB48:
  90         .cfi_startproc
  91 # ../sysdeps/unix/sysv/linux/fips-private.h:43:   if (checked == FIPS_UNTESTED)
  92         movl    checked.8336(%rip), %eax        # checked, checked.0_1
  93         testl   %eax, %eax      # checked.0_1
  94         je      .L2     #,
  95         cmpl    $1, %eax        #, checked.0_1
  96         sete    %al     #, <retval>
  97 # ../sysdeps/unix/sysv/linux/fips-private.h:72: }
  98         ret
  99         .p2align 4,,10
 100         .p2align 3
 101 .L2:
 102 # ../sysdeps/unix/sysv/linux/fips-private.h:34: {
 103         pushq   %r12    #
 104         .cfi_def_cfa_offset 16
 105         .cfi_offset 12, -16
 106         pushq   %rbp    #
 107         .cfi_def_cfa_offset 24
 108         .cfi_offset 6, -24
 109 # ../sysdeps/unix/sysv/linux/fips-private.h:45:       int fd = __open_nocancel ("/proc/sys/crypto/fips_enabled", O_RDONLY);
 110         leaq    .LC0(%rip), %rdi        #,
 111 # ../sysdeps/unix/sysv/linux/fips-private.h:34: {
 112         pushq   %rbx    #
 113         .cfi_def_cfa_offset 32
 114         .cfi_offset 3, -32
 115 # ../sysdeps/unix/sysv/linux/fips-private.h:45:       int fd = __open_nocancel ("/proc/sys/crypto/fips_enabled", O_RDONLY);
 116         xorl    %esi, %esi      #
 117         xorl    %eax, %eax      #
 118 # ../sysdeps/unix/sysv/linux/fips-private.h:34: {
 119         subq    $48, %rsp       #,
 120         .cfi_def_cfa_offset 80
 121 # ../sysdeps/unix/sysv/linux/fips-private.h:45:       int fd = __open_nocancel ("/proc/sys/crypto/fips_enabled", O_RDONLY);
 122         call    __open_nocancel@PLT     #
 123 # ../sysdeps/unix/sysv/linux/fips-private.h:47:       if (fd != -1)
 124         cmpl    $-1, %eax       #, fd
 125 # ../sysdeps/unix/sysv/linux/fips-private.h:45:       int fd = __open_nocancel ("/proc/sys/crypto/fips_enabled", O_RDONLY);
 126         movl    %eax, %ebp      #, fd
 127         leaq    16(%rsp), %r12  #, tmp111
 128 # ../sysdeps/unix/sysv/linux/fips-private.h:47:       if (fd != -1)
 129         jne     .L4     #,
 130         jmp     .L27    #
 131         .p2align 4,,10
 132         .p2align 3
 133 .L30:
 134 # ../sysdeps/unix/sysv/linux/fips-private.h:52:           n = TEMP_FAILURE_RETRY (__read_nocancel (fd, buf, sizeof (buf) - 1));
 135         movq    errno@gottpoff(%rip), %rax      #, tmp101
 136         cmpl    $4, %fs:(%rax)  #, errno
 137         jne     .L29    #,
 138 .L4:
 139 # ../sysdeps/unix/sysv/linux/fips-private.h:52:           n = TEMP_FAILURE_RETRY (__read_nocancel (fd, buf, sizeof (buf) - 1));
 140         movl    $31, %edx       #,
 141         movq    %r12, %rsi      # tmp111,
 142         movl    %ebp, %edi      # fd,
 143         call    __read_nocancel@PLT     #
 144         cmpq    $-1, %rax       #, __result
 145         movq    %rax, %rbx      #, __result
 146         je      .L30    #,
 147 # ../sysdeps/unix/sysv/linux/not-cancel.h:60:   __close_nocancel (fd);
 148         movl    %ebp, %edi      # fd,
 149         call    __close_nocancel@PLT    #
 150 # ../sysdeps/unix/sysv/linux/fips-private.h:55:           if (n > 0)
 151         testq   %rbx, %rbx      # __result
 152         jle     .L27    #,
 153 # ../sysdeps/unix/sysv/linux/fips-private.h:61:               long int res = strtol (buf, &endp, 10);
 154         leaq    8(%rsp), %rsi   #, tmp102
 155         movl    $10, %edx       #,
 156         movq    %r12, %rdi      # tmp111,
 157 # ../sysdeps/unix/sysv/linux/fips-private.h:58:               buf[n] = '\0';
 158         movb    $0, 16(%rsp,%rbx)       #, buf
 159 # ../sysdeps/unix/sysv/linux/fips-private.h:61:               long int res = strtol (buf, &endp, 10);
 160         call    strtol@PLT      #
 161 # ../sysdeps/unix/sysv/linux/fips-private.h:62:               if (endp != buf && (*endp == '\0' || *endp == '\n'))
 162         movq    8(%rsp), %rdx   # endp, endp.2_3
 163         cmpq    %r12, %rdx      # tmp111, endp.2_3
 164         je      .L27    #,
 165 # ../sysdeps/unix/sysv/linux/fips-private.h:62:               if (endp != buf && (*endp == '\0' || *endp == '\n'))
 166         movzbl  (%rdx), %edx    # *endp.2_3, _24
 167         testb   %dl, %dl        # _24
 168         je      .L16    #,
 169         cmpb    $10, %dl        #, _24
 170         je      .L16    #,
 171         .p2align 4,,10
 172         .p2align 3
 173 .L27:
 174         movl    checked.8336(%rip), %eax        # checked, prephitmp_42
 175 # ../sysdeps/unix/sysv/linux/fips-private.h:67:       if (checked == FIPS_UNTESTED)
 176         testl   %eax, %eax      # prephitmp_42
 177         jne     .L14    #,
 178 .L15:
 179 # ../sysdeps/unix/sysv/linux/fips-private.h:68:         checked = FIPS_TEST_FAILED;
 180         movl    $-2, checked.8336(%rip) #, checked
 181 # ../sysdeps/unix/sysv/linux/fips-private.h:72: }
 182         addq    $48, %rsp       #,
 183         .cfi_remember_state
 184         .cfi_def_cfa_offset 32
 185 # ../sysdeps/unix/sysv/linux/fips-private.h:68:         checked = FIPS_TEST_FAILED;
 186         xorl    %eax, %eax      # <retval>
 187 # ../sysdeps/unix/sysv/linux/fips-private.h:72: }
 188         popq    %rbx    #
 189         .cfi_def_cfa_offset 24
 190         popq    %rbp    #
 191         .cfi_def_cfa_offset 16
 192         popq    %r12    #
 193         .cfi_def_cfa_offset 8
 194         ret
 195         .p2align 4,,10
 196         .p2align 3
 197 .L16:
 198         .cfi_restore_state
 199 # ../sysdeps/unix/sysv/linux/fips-private.h:63:                 checked = (res > 0) ? FIPS_ENABLED : FIPS_DISABLED;
 200         testq   %rax, %rax      # res
 201         jle     .L13    #,
 202         movl    $1, checked.8336(%rip)  #, checked
 203         movl    $1, %eax        #, prephitmp_42
 204 .L14:
 205         cmpl    $1, %eax        #, prephitmp_42
 206         sete    %al     #, <retval>
 207 # ../sysdeps/unix/sysv/linux/fips-private.h:72: }
 208         addq    $48, %rsp       #,
 209         .cfi_remember_state
 210         .cfi_def_cfa_offset 32
 211         popq    %rbx    #
 212         .cfi_def_cfa_offset 24
 213         popq    %rbp    #
 214         .cfi_def_cfa_offset 16
 215         popq    %r12    #
 216         .cfi_def_cfa_offset 8
 217         ret
 218         .p2align 4,,10
 219         .p2align 3
 220 .L29:
 221         .cfi_restore_state
 222 # ../sysdeps/unix/sysv/linux/not-cancel.h:60:   __close_nocancel (fd);
 223         movl    %ebp, %edi      # fd,
 224         call    __close_nocancel@PLT    #
 225         movl    checked.8336(%rip), %eax        # checked, prephitmp_42
 226 # ../sysdeps/unix/sysv/linux/fips-private.h:67:       if (checked == FIPS_UNTESTED)
 227         testl   %eax, %eax      # prephitmp_42
 228         je      .L15    #,
 229         jmp     .L14    #
 230 .L13:
 231 # ../sysdeps/unix/sysv/linux/fips-private.h:63:                 checked = (res > 0) ? FIPS_ENABLED : FIPS_DISABLED;
 232         movl    $-1, checked.8336(%rip) #, checked
 233         movl    $-1, %eax       #, prephitmp_42
 234         jmp     .L14    #
 235         .cfi_endproc
 236 .LFE48:
 237         .size   fips_enabled_p, .-fips_enabled_p
 238         .p2align 4,,15
 239         .globl  __crypt_r
 240         .type   __crypt_r, @function
 241 __crypt_r:
 242 .LFB49:
 243         .cfi_startproc
 244         pushq   %r13    #
 245         .cfi_def_cfa_offset 16
 246         .cfi_offset 13, -16
 247         pushq   %r12    #
 248         .cfi_def_cfa_offset 24
 249         .cfi_offset 12, -24
 250         movq    %rdi, %r12      # key, key
 251         pushq   %rbp    #
 252         .cfi_def_cfa_offset 32
 253         .cfi_offset 6, -32
 254         pushq   %rbx    #
 255         .cfi_def_cfa_offset 40
 256         .cfi_offset 3, -40
 257 # crypt-entry.c:84:   if (strncmp (md5_salt_prefix, salt, sizeof (md5_salt_prefix) - 1) == 0)
 258         leaq    md5_salt_prefix(%rip), %rdi     #,
 259 # crypt-entry.c:77: {
 260         movq    %rdx, %rbx      # data, data
 261 # crypt-entry.c:84:   if (strncmp (md5_salt_prefix, salt, sizeof (md5_salt_prefix) - 1) == 0)
 262         movl    $3, %edx        #,
 263 # crypt-entry.c:77: {
 264         movq    %rsi, %rbp      # salt, salt
 265         subq    $56, %rsp       #,
 266         .cfi_def_cfa_offset 96
 267 # crypt-entry.c:84:   if (strncmp (md5_salt_prefix, salt, sizeof (md5_salt_prefix) - 1) == 0)
 268         call    strncmp@PLT     #
 269         testl   %eax, %eax      # _1
 270         je      .L42    #,
 271 # crypt-entry.c:97:   if (strncmp (sha256_salt_prefix, salt, sizeof (sha256_salt_prefix) - 1) == 0)
 272         leaq    sha256_salt_prefix(%rip), %rdi  #,
 273         movl    $3, %edx        #,
 274         movq    %rbp, %rsi      # salt,
 275         call    strncmp@PLT     #
 276         testl   %eax, %eax      # _3
 277         je      .L43    #,
 278 # crypt-entry.c:102:   if (strncmp (sha512_salt_prefix, salt, sizeof (sha512_salt_prefix) - 1) == 0)
 279         leaq    sha512_salt_prefix(%rip), %rdi  #,
 280         movl    $3, %edx        #,
 281         movq    %rbp, %rsi      # salt,
 282         call    strncmp@PLT     #
 283         testl   %eax, %eax      # _18
 284         je      .L44    #,
 285 # crypt-entry.c:110:   if (!_ufc_setup_salt_r (salt, data))
 286         movq    %rbx, %rsi      # data,
 287         movq    %rbp, %rdi      # salt,
 288         call    _ufc_setup_salt_r@PLT   #
 289         testb   %al, %al        # _20
 290         je      .L45    #,
 291 # crypt-entry.c:117:   if (fips_enabled_p ())
 292         call    fips_enabled_p  #
 293         testb   %al, %al        # _21
 294         jne     .L41    #,
 295 # crypt-entry.c:126:   _ufc_clearmem (ktab, (int) sizeof (ktab));
 296         leaq    7(%rsp), %r13   #, tmp106
 297 # crypt-entry.c:127:   (void) strncpy (ktab, key, 8);
 298         movl    $8, %edx        #,
 299         movq    %r12, %rsi      # key,
 300 # crypt-entry.c:126:   _ufc_clearmem (ktab, (int) sizeof (ktab));
 301         movq    $0, 7(%rsp)     #, MEM[(void *)&ktab]
 302         movb    $0, 15(%rsp)    #, MEM[(void *)&ktab]
 303 # crypt-entry.c:133:   _ufc_clearmem ((char*) res, (int) sizeof (res));
 304         leaq    16(%rsp), %r12  #, tmp109
 305 # crypt-entry.c:127:   (void) strncpy (ktab, key, 8);
 306         movq    %r13, %rdi      # tmp106,
 307         call    strncpy@PLT     #
 308 # crypt-entry.c:128:   _ufc_mk_keytab_r (ktab, data);
 309         movq    %rbx, %rsi      # data,
 310         movq    %r13, %rdi      # tmp106,
 311         call    _ufc_mk_keytab_r@PLT    #
 312 # crypt-entry.c:133:   _ufc_clearmem ((char*) res, (int) sizeof (res));
 313         pxor    %xmm0, %xmm0    # tmp117
 314 # crypt-entry.c:134:   _ufc_doit_r (xx,  data, &res[0]);
 315         movq    %r12, %rdx      # tmp109,
 316         movq    %rbx, %rsi      # data,
 317         movl    $25, %edi       #,
 318 # crypt-entry.c:133:   _ufc_clearmem ((char*) res, (int) sizeof (res));
 319         movaps  %xmm0, 16(%rsp) # tmp117, MEM[(void *)&res]
 320         movaps  %xmm0, 32(%rsp) # tmp117, MEM[(void *)&res]
 321 # crypt-entry.c:134:   _ufc_doit_r (xx,  data, &res[0]);
 322         call    _ufc_doit_r@PLT #
 323 # crypt-entry.c:139:   _ufc_dofinalperm_r (res, data);
 324         movq    %rbx, %rsi      # data,
 325         movq    %r12, %rdi      # tmp109,
 326         call    _ufc_dofinalperm_r@PLT  #
 327 # crypt-entry.c:144:   _ufc_output_conversion_r (res[0], res[1], salt, data);
 328         movq    24(%rsp), %rsi  # res,
 329         movq    16(%rsp), %rdi  # res,
 330         movq    %rbx, %rcx      # data,
 331         movq    %rbp, %rdx      # salt,
 332         call    _ufc_output_conversion_r@PLT    #
 333 # crypt-entry.c:150:   explicit_bzero (ktab, sizeof (ktab));
 334         movq    %r13, %rdi      # tmp106,
 335         movl    $9, %edx        #,
 336         movl    $9, %esi        #,
 337         call    __explicit_bzero_chk@PLT        #
 338 # crypt-entry.c:151:   explicit_bzero (data->keysched, sizeof (data->keysched));
 339         movq    %rbx, %rdi      # data,
 340         movq    $-1, %rdx       #,
 341         movl    $128, %esi      #,
 342         call    __explicit_bzero_chk@PLT        #
 343 # crypt-entry.c:152:   explicit_bzero (res, sizeof (res));
 344         movq    %r12, %rdi      # tmp109,
 345         movl    $32, %edx       #,
 346         movl    $32, %esi       #,
 347         call    __explicit_bzero_chk@PLT        #
 348 # crypt-entry.c:155: }
 349         addq    $56, %rsp       #,
 350         .cfi_remember_state
 351         .cfi_def_cfa_offset 40
 352 # crypt-entry.c:154:   return data->crypt_3_buf;
 353         leaq    131200(%rbx), %rax      #, <retval>
 354 # crypt-entry.c:155: }
 355         popq    %rbx    #
 356         .cfi_def_cfa_offset 32
 357         popq    %rbp    #
 358         .cfi_def_cfa_offset 24
 359         popq    %r12    #
 360         .cfi_def_cfa_offset 16
 361         popq    %r13    #
 362         .cfi_def_cfa_offset 8
 363         ret
 364         .p2align 4,,10
 365         .p2align 3
 366 .L42:
 367         .cfi_restore_state
 368 # crypt-entry.c:87:       if (fips_enabled_p ())
 369         call    fips_enabled_p  #
 370         testb   %al, %al        # _2
 371         jne     .L41    #,
 372 # crypt-entry.c:92:       return __md5_crypt_r (key, salt, (char *) data,
 373         movl    $131232, %ecx   #,
 374         movq    %rbx, %rdx      # data,
 375         movq    %rbp, %rsi      # salt,
 376         movq    %r12, %rdi      # key,
 377         call    __md5_crypt_r@PLT       #
 378 .L31:
 379 # crypt-entry.c:155: }
 380         addq    $56, %rsp       #,
 381         .cfi_remember_state
 382         .cfi_def_cfa_offset 40
 383         popq    %rbx    #
 384         .cfi_def_cfa_offset 32
 385         popq    %rbp    #
 386         .cfi_def_cfa_offset 24
 387         popq    %r12    #
 388         .cfi_def_cfa_offset 16
 389         popq    %r13    #
 390         .cfi_def_cfa_offset 8
 391         ret
 392         .p2align 4,,10
 393         .p2align 3
 394 .L44:
 395         .cfi_restore_state
 396 # crypt-entry.c:103:     return __sha512_crypt_r (key, salt, (char *) data,
 397         movq    %rbx, %rdx      # data,
 398         movq    %rbp, %rsi      # salt,
 399         movq    %r12, %rdi      # key,
 400         movl    $131232, %ecx   #,
 401         call    __sha512_crypt_r@PLT    #
 402 # crypt-entry.c:155: }
 403         addq    $56, %rsp       #,
 404         .cfi_remember_state
 405         .cfi_def_cfa_offset 40
 406         popq    %rbx    #
 407         .cfi_def_cfa_offset 32
 408         popq    %rbp    #
 409         .cfi_def_cfa_offset 24
 410         popq    %r12    #
 411         .cfi_def_cfa_offset 16
 412         popq    %r13    #
 413         .cfi_def_cfa_offset 8
 414         ret
 415         .p2align 4,,10
 416         .p2align 3
 417 .L43:
 418         .cfi_restore_state
 419 # crypt-entry.c:98:     return __sha256_crypt_r (key, salt, (char *) data,
 420         movq    %rbx, %rdx      # data,
 421         movq    %rbp, %rsi      # salt,
 422         movq    %r12, %rdi      # key,
 423         movl    $131232, %ecx   #,
 424         call    __sha256_crypt_r@PLT    #
 425 # crypt-entry.c:155: }
 426         addq    $56, %rsp       #,
 427         .cfi_remember_state
 428         .cfi_def_cfa_offset 40
 429         popq    %rbx    #
 430         .cfi_def_cfa_offset 32
 431         popq    %rbp    #
 432         .cfi_def_cfa_offset 24
 433         popq    %r12    #
 434         .cfi_def_cfa_offset 16
 435         popq    %r13    #
 436         .cfi_def_cfa_offset 8
 437         ret
 438         .p2align 4,,10
 439         .p2align 3
 440 .L41:
 441         .cfi_restore_state
 442 # crypt-entry.c:119:       __set_errno (EPERM);
 443         movq    errno@gottpoff(%rip), %rax      #, tmp105
 444         movl    $1, %fs:(%rax)  #, errno
 445 # crypt-entry.c:120:       return NULL;
 446         xorl    %eax, %eax      # <retval>
 447         jmp     .L31    #
 448         .p2align 4,,10
 449         .p2align 3
 450 .L45:
 451 # crypt-entry.c:112:       __set_errno (EINVAL);
 452         movq    errno@gottpoff(%rip), %rax      #, tmp104
 453         movl    $22, %fs:(%rax) #, errno
 454 # crypt-entry.c:113:       return NULL;
 455         xorl    %eax, %eax      # <retval>
 456         jmp     .L31    #
 457         .cfi_endproc
 458 .LFE49:
 459         .size   __crypt_r, .-__crypt_r
 460         .weak   crypt_r
 461         .set    crypt_r,__crypt_r
 462         .p2align 4,,15
 463         .globl  crypt
 464         .type   crypt, @function
 465 crypt:
 466 .LFB50:
 467         .cfi_startproc
 468         pushq   %rbp    #
 469         .cfi_def_cfa_offset 16
 470         .cfi_offset 6, -16
 471         pushq   %rbx    #
 472         .cfi_def_cfa_offset 24
 473         .cfi_offset 3, -24
 474         movq    %rdi, %rbp      # key, key
 475 # crypt-entry.c:163:   if (strncmp (md5_salt_prefix, salt, sizeof (md5_salt_prefix) - 1) == 0
 476         leaq    md5_salt_prefix(%rip), %rdi     #,
 477         movl    $3, %edx        #,
 478 # crypt-entry.c:160: {
 479         movq    %rsi, %rbx      # salt, salt
 480         subq    $8, %rsp        #,
 481         .cfi_def_cfa_offset 32
 482 # crypt-entry.c:163:   if (strncmp (md5_salt_prefix, salt, sizeof (md5_salt_prefix) - 1) == 0
 483         call    strncmp@PLT     #
 484         testl   %eax, %eax      # _1
 485         je      .L51    #,
 486 .L47:
 487 # crypt-entry.c:169:   if (strncmp (sha256_salt_prefix, salt, sizeof (sha256_salt_prefix) - 1) == 0)
 488         leaq    sha256_salt_prefix(%rip), %rdi  #,
 489         movl    $3, %edx        #,
 490         movq    %rbx, %rsi      # salt,
 491         call    strncmp@PLT     #
 492         testl   %eax, %eax      # _3
 493         je      .L52    #,
 494 # crypt-entry.c:173:   if (strncmp (sha512_salt_prefix, salt, sizeof (sha512_salt_prefix) - 1) == 0)
 495         leaq    sha512_salt_prefix(%rip), %rdi  #,
 496         movl    $3, %edx        #,
 497         movq    %rbx, %rsi      # salt,
 498         call    strncmp@PLT     #
 499         testl   %eax, %eax      # _4
 500         je      .L53    #,
 501 # crypt-entry.c:178: }
 502         addq    $8, %rsp        #,
 503         .cfi_remember_state
 504         .cfi_def_cfa_offset 24
 505 # crypt-entry.c:177:   return __crypt_r (key, salt, &_ufc_foobar);
 506         movq    %rbx, %rsi      # salt,
 507         movq    %rbp, %rdi      # key,
 508 # crypt-entry.c:178: }
 509         popq    %rbx    #
 510         .cfi_def_cfa_offset 16
 511         popq    %rbp    #
 512         .cfi_def_cfa_offset 8
 513 # crypt-entry.c:177:   return __crypt_r (key, salt, &_ufc_foobar);
 514         leaq    _ufc_foobar(%rip), %rdx #,
 515         jmp     __crypt_r       #
 516         .p2align 4,,10
 517         .p2align 3
 518 .L53:
 519         .cfi_restore_state
 520 # crypt-entry.c:178: }
 521         addq    $8, %rsp        #,
 522         .cfi_remember_state
 523         .cfi_def_cfa_offset 24
 524 # crypt-entry.c:174:     return __sha512_crypt (key, salt);
 525         movq    %rbx, %rsi      # salt,
 526         movq    %rbp, %rdi      # key,
 527 # crypt-entry.c:178: }
 528         popq    %rbx    #
 529         .cfi_def_cfa_offset 16
 530         popq    %rbp    #
 531         .cfi_def_cfa_offset 8
 532 # crypt-entry.c:174:     return __sha512_crypt (key, salt);
 533         jmp     __sha512_crypt@PLT      #
 534         .p2align 4,,10
 535         .p2align 3
 536 .L51:
 537         .cfi_restore_state
 538 # crypt-entry.c:165:       && !fips_enabled_p ())
 539         call    fips_enabled_p  #
 540         testb   %al, %al        # _2
 541         jne     .L47    #,
 542 # crypt-entry.c:178: }
 543         addq    $8, %rsp        #,
 544         .cfi_remember_state
 545         .cfi_def_cfa_offset 24
 546 # crypt-entry.c:166:     return __md5_crypt (key, salt);
 547         movq    %rbx, %rsi      # salt,
 548         movq    %rbp, %rdi      # key,
 549 # crypt-entry.c:178: }
 550         popq    %rbx    #
 551         .cfi_def_cfa_offset 16
 552         popq    %rbp    #
 553         .cfi_def_cfa_offset 8
 554 # crypt-entry.c:166:     return __md5_crypt (key, salt);
 555         jmp     __md5_crypt@PLT #
 556         .p2align 4,,10
 557         .p2align 3
 558 .L52:
 559         .cfi_restore_state
 560 # crypt-entry.c:178: }
 561         addq    $8, %rsp        #,
 562         .cfi_def_cfa_offset 24
 563 # crypt-entry.c:170:     return __sha256_crypt (key, salt);
 564         movq    %rbx, %rsi      # salt,
 565         movq    %rbp, %rdi      # key,
 566 # crypt-entry.c:178: }
 567         popq    %rbx    #
 568         .cfi_def_cfa_offset 16
 569         popq    %rbp    #
 570         .cfi_def_cfa_offset 8
 571 # crypt-entry.c:170:     return __sha256_crypt (key, salt);
 572         jmp     __sha256_crypt@PLT      #
 573         .cfi_endproc
 574 .LFE50:
 575         .size   crypt, .-crypt
 576         .local  checked.8336
 577         .comm   checked.8336,4,4
 578         .section        .rodata.str1.1
 579         .type   sha512_salt_prefix, @object
 580         .size   sha512_salt_prefix, 4
 581 sha512_salt_prefix:
 582         .string "$6$"
 583         .type   sha256_salt_prefix, @object
 584         .size   sha256_salt_prefix, 4
 585 sha256_salt_prefix:
 586         .string "$5$"
 587         .type   md5_salt_prefix, @object
 588         .size   md5_salt_prefix, 4
 589 md5_salt_prefix:
 590         .string "$1$"
 591         .ident  "GCC: (GNU) 7.3.0"
 592         .section        .note.GNU-stack,"",@progbits