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