ret ($26)
.end OPENSSL_cpuid_setup
-.globl OPENSSL_wipe_cpu
-.ent OPENSSL_wipe_cpu
-OPENSSL_wipe_cpu:
- .frame $30,0,$26
- .prologue 0
- clr $1
- clr $2
- clr $3
- clr $4
- clr $5
- clr $6
- clr $7
- clr $8
- clr $16
- clr $17
- clr $18
- clr $19
- clr $20
- clr $21
- clr $22
- clr $23
- clr $24
- clr $25
- clr $27
- clr $at
- clr $29
- fclr $f0
- fclr $f1
- fclr $f10
- fclr $f11
- fclr $f12
- fclr $f13
- fclr $f14
- fclr $f15
- fclr $f16
- fclr $f17
- fclr $f18
- fclr $f19
- fclr $f20
- fclr $f21
- fclr $f22
- fclr $f23
- fclr $f24
- fclr $f25
- fclr $f26
- fclr $f27
- fclr $f28
- fclr $f29
- fclr $f30
- mov $sp,$0
- ret ($26)
-.end OPENSSL_wipe_cpu
-
.globl OPENSSL_atomic_add
.ent OPENSSL_atomic_add
OPENSSL_atomic_add:
.size _armv8_pmull_probe,.-_armv8_pmull_probe
#endif
-.global OPENSSL_wipe_cpu
-.type OPENSSL_wipe_cpu,%function
-OPENSSL_wipe_cpu:
-#if __ARM_MAX_ARCH__>=7
- ldr r0,.LOPENSSL_armcap
- adr r1,.LOPENSSL_armcap
- ldr r0,[r1,r0]
-#ifdef __APPLE__
- ldr r0,[r0]
-#endif
-#endif
- eor r2,r2,r2
- eor r3,r3,r3
- eor ip,ip,ip
-#if __ARM_MAX_ARCH__>=7
- tst r0,#1
- beq .Lwipe_done
- veor q0, q0, q0
- veor q1, q1, q1
- veor q2, q2, q2
- veor q3, q3, q3
- veor q8, q8, q8
- veor q9, q9, q9
- veor q10, q10, q10
- veor q11, q11, q11
- veor q12, q12, q12
- veor q13, q13, q13
- veor q14, q14, q14
- veor q15, q15, q15
-.Lwipe_done:
-#endif
- mov r0,sp
-#if __ARM_ARCH__>=5
- bx lr
-#else
- tst lr,#1
- moveq pc,lr
- .word 0xe12fff1e @ bx lr
-#endif
-.size OPENSSL_wipe_cpu,.-OPENSSL_wipe_cpu
-
.global OPENSSL_instrument_bus
.type OPENSSL_instrument_bus,%function
OPENSSL_instrument_bus:
.asg OPENSSL_cleanse,_OPENSSL_cleanse
.asg CRYPTO_memcmp,_CRYPTO_memcmp
.asg OPENSSL_atomic_add,_OPENSSL_atomic_add
- .asg OPENSSL_wipe_cpu,_OPENSSL_wipe_cpu
.asg OPENSSL_instrument_bus,_OPENSSL_instrument_bus
.asg OPENSSL_instrument_bus2,_OPENSSL_instrument_bus2
.endif
br.ret.sptk.many b0 };;
.endp OPENSSL_atomic_add#
-// Returns a structure comprising pointer to the top of stack of
-// the caller and pointer beyond backing storage for the current
-// register frame. The latter is required, because it might be
-// insufficient to wipe backing storage for the current frame
-// (as this procedure does), one might have to go further, toward
-// higher addresses to reach for whole "retroactively" saved
-// context...
-.global OPENSSL_wipe_cpu#
-.proc OPENSSL_wipe_cpu#
-.align 32
-OPENSSL_wipe_cpu:
- .prologue
- .fframe 0
- .save ar.pfs,r2
- .save ar.lc,r3
-{ .mib; alloc r2=ar.pfs,0,96,0,96
- mov r3=ar.lc
- brp.loop.imp .L_wipe_top,.L_wipe_end-16
- };;
-{ .mii; mov r9=ar.bsp
- mov r8=pr
- mov ar.lc=96 };;
- .body
-{ .mii; add r9=96*8-8,r9
- mov ar.ec=1 };;
-
-// One can sweep double as fast, but then we can't guarantee
-// that backing storage is wiped...
-.L_wipe_top:
-{ .mfi; st8 [r9]=r0,-8
- mov f127=f0
- mov r127=r0 }
-{ .mfb; nop.m 0
- nop.f 0
- br.ctop.sptk .L_wipe_top };;
-.L_wipe_end:
-
-{ .mfi; mov r11=r0
- mov f6=f0
- mov r14=r0 }
-{ .mfi; mov r15=r0
- mov f7=f0
- mov r16=r0 }
-{ .mfi; mov r17=r0
- mov f8=f0
- mov r18=r0 }
-{ .mfi; mov r19=r0
- mov f9=f0
- mov r20=r0 }
-{ .mfi; mov r21=r0
- mov f10=f0
- mov r22=r0 }
-{ .mfi; mov r23=r0
- mov f11=f0
- mov r24=r0 }
-{ .mfi; mov r25=r0
- mov f12=f0
- mov r26=r0 }
-{ .mfi; mov r27=r0
- mov f13=f0
- mov r28=r0 }
-{ .mfi; mov r29=r0
- mov f14=f0
- mov r30=r0 }
-{ .mfi; mov r31=r0
- mov f15=f0
- nop.i 0 }
-{ .mfi; mov f16=f0 }
-{ .mfi; mov f17=f0 }
-{ .mfi; mov f18=f0 }
-{ .mfi; mov f19=f0 }
-{ .mfi; mov f20=f0 }
-{ .mfi; mov f21=f0 }
-{ .mfi; mov f22=f0 }
-{ .mfi; mov f23=f0 }
-{ .mfi; mov f24=f0 }
-{ .mfi; mov f25=f0 }
-{ .mfi; mov f26=f0 }
-{ .mfi; mov f27=f0 }
-{ .mfi; mov f28=f0 }
-{ .mfi; mov f29=f0 }
-{ .mfi; mov f30=f0 }
-{ .mfi; add r9=96*8+8,r9
- mov f31=f0
- mov pr=r8,0x1ffff }
-{ .mib; mov r8=sp
- mov ar.lc=r3
- br.ret.sptk b0 };;
-.endp OPENSSL_wipe_cpu#
-
.global OPENSSL_cleanse#
.proc OPENSSL_cleanse#
OPENSSL_cleanse:
.EXIT
nop
.PROCEND
-
- .EXPORT OPENSSL_wipe_cpu,ENTRY
- .ALIGN 8
-OPENSSL_wipe_cpu
- .PROC
- .CALLINFO NO_CALLS
- .ENTRY
- xor %r0,%r0,%r1
- fcpy,dbl %fr0,%fr4
- xor %r0,%r0,%r19
- fcpy,dbl %fr0,%fr5
- xor %r0,%r0,%r20
- fcpy,dbl %fr0,%fr6
- xor %r0,%r0,%r21
- fcpy,dbl %fr0,%fr7
- xor %r0,%r0,%r22
- fcpy,dbl %fr0,%fr8
- xor %r0,%r0,%r23
- fcpy,dbl %fr0,%fr9
- xor %r0,%r0,%r24
- fcpy,dbl %fr0,%fr10
- xor %r0,%r0,%r25
- fcpy,dbl %fr0,%fr11
- xor %r0,%r0,%r26
- fcpy,dbl %fr0,%fr22
- xor %r0,%r0,%r29
- fcpy,dbl %fr0,%fr23
- xor %r0,%r0,%r31
- fcpy,dbl %fr0,%fr24
- fcpy,dbl %fr0,%fr25
- fcpy,dbl %fr0,%fr26
- fcpy,dbl %fr0,%fr27
- fcpy,dbl %fr0,%fr28
- fcpy,dbl %fr0,%fr29
- fcpy,dbl %fr0,%fr30
- fcpy,dbl %fr0,%fr31
- bv ($rp)
- .EXIT
- ldo 0($sp),$rv
- .PROCEND
___
{
my $inp="%r26";
.byte 0,12,0x14,0,0,0,0,0
.size .OPENSSL_brd31_probe,.-.OPENSSL_brd31_probe
-
-.globl .OPENSSL_wipe_cpu
-.align 4
-.OPENSSL_wipe_cpu:
- xor r0,r0,r0
- fmr f0,f31
- fmr f1,f31
- fmr f2,f31
- mr r3,r1
- fmr f3,f31
- xor r4,r4,r4
- fmr f4,f31
- xor r5,r5,r5
- fmr f5,f31
- xor r6,r6,r6
- fmr f6,f31
- xor r7,r7,r7
- fmr f7,f31
- xor r8,r8,r8
- fmr f8,f31
- xor r9,r9,r9
- fmr f9,f31
- xor r10,r10,r10
- fmr f10,f31
- xor r11,r11,r11
- fmr f11,f31
- xor r12,r12,r12
- fmr f12,f31
- fmr f13,f31
- blr
- .long 0
- .byte 0,12,0x14,0,0,0,0,0
-.size .OPENSSL_wipe_cpu,.-.OPENSSL_wipe_cpu
-
.globl .OPENSSL_atomic_add
.align 4
.OPENSSL_atomic_add:
br $ra
.size OPENSSL_atomic_add,.-OPENSSL_atomic_add
-.globl OPENSSL_wipe_cpu
-.type OPENSSL_wipe_cpu,\@function
-.align 16
-OPENSSL_wipe_cpu:
- xgr %r0,%r0
- xgr %r1,%r1
- lgr %r2,$sp
- xgr %r3,%r3
- xgr %r4,%r4
- lzdr %f0
- lzdr %f1
- lzdr %f2
- lzdr %f3
- lzdr %f4
- lzdr %f5
- lzdr %f6
- lzdr %f7
- br $ra
-.size OPENSSL_wipe_cpu,.-OPENSSL_wipe_cpu
-
.globl OPENSSL_cleanse
.type OPENSSL_cleanse,\@function
.align 16
#endif
.text
-.align 32
-.global OPENSSL_wipe_cpu
-.type OPENSSL_wipe_cpu,#function
-! Keep in mind that this does not excuse us from wiping the stack!
-! This routine wipes registers, but not the backing store [which
-! resides on the stack, toward lower addresses]. To facilitate for
-! stack wiping I return pointer to the top of stack of the *caller*.
-OPENSSL_wipe_cpu:
- save %sp,FRAME,%sp
- nop
-#ifdef __sun
-#include <sys/trap.h>
- ta ST_CLEAN_WINDOWS
-#else
- call .walk.reg.wins
-#endif
- nop
- call .PIC.zero.up
- mov .zero-(.-4),%o0
- ld [%o0],%f0
- ld [%o0],%f1
-
- subcc %g0,1,%o0
- ! Following is V9 "rd %ccr,%o0" instruction. However! V8
- ! specification says that it ("rd %asr2,%o0" in V8 terms) does
- ! not cause illegal_instruction trap. It therefore can be used
- ! to determine if the CPU the code is executing on is V8- or
- ! V9-compliant, as V9 returns a distinct value of 0x99,
- ! "negative" and "borrow" bits set in both %icc and %xcc.
- .word 0x91408000 !rd %ccr,%o0
- cmp %o0,0x99
- bne .v8
- nop
- ! Even though we do not use %fp register bank,
- ! we wipe it as memcpy might have used it...
- .word 0xbfa00040 !fmovd %f0,%f62
- .word 0xbba00040 !...
- .word 0xb7a00040
- .word 0xb3a00040
- .word 0xafa00040
- .word 0xaba00040
- .word 0xa7a00040
- .word 0xa3a00040
- .word 0x9fa00040
- .word 0x9ba00040
- .word 0x97a00040
- .word 0x93a00040
- .word 0x8fa00040
- .word 0x8ba00040
- .word 0x87a00040
- .word 0x83a00040 !fmovd %f0,%f32
-.v8: fmovs %f1,%f31
- clr %o0
- fmovs %f0,%f30
- clr %o1
- fmovs %f1,%f29
- clr %o2
- fmovs %f0,%f28
- clr %o3
- fmovs %f1,%f27
- clr %o4
- fmovs %f0,%f26
- clr %o5
- fmovs %f1,%f25
- clr %o7
- fmovs %f0,%f24
- clr %l0
- fmovs %f1,%f23
- clr %l1
- fmovs %f0,%f22
- clr %l2
- fmovs %f1,%f21
- clr %l3
- fmovs %f0,%f20
- clr %l4
- fmovs %f1,%f19
- clr %l5
- fmovs %f0,%f18
- clr %l6
- fmovs %f1,%f17
- clr %l7
- fmovs %f0,%f16
- clr %i0
- fmovs %f1,%f15
- clr %i1
- fmovs %f0,%f14
- clr %i2
- fmovs %f1,%f13
- clr %i3
- fmovs %f0,%f12
- clr %i4
- fmovs %f1,%f11
- clr %i5
- fmovs %f0,%f10
- clr %g1
- fmovs %f1,%f9
- clr %g2
- fmovs %f0,%f8
- clr %g3
- fmovs %f1,%f7
- clr %g4
- fmovs %f0,%f6
- clr %g5
- fmovs %f1,%f5
- fmovs %f0,%f4
- fmovs %f1,%f3
- fmovs %f0,%f2
-
- add %fp,BIAS,%i0 ! return pointer to caller´s top of stack
-
- ret
- restore
-
-.zero: .long 0x0,0x0
-.PIC.zero.up:
- retl
- add %o0,%o7,%o0
-#ifdef DEBUG
-.global walk_reg_wins
-.type walk_reg_wins,#function
-walk_reg_wins:
-#endif
-.walk.reg.wins:
- save %sp,FRAME,%sp
- cmp %i7,%o7
- be 2f
- clr %o0
- cmp %o7,0 ! compiler never cleans %o7...
- be 1f ! could have been a leaf function...
- clr %o1
- call .walk.reg.wins
- nop
-1: clr %o2
- clr %o3
- clr %o4
- clr %o5
- clr %o7
- clr %l0
- clr %l1
- clr %l2
- clr %l3
- clr %l4
- clr %l5
- clr %l6
- clr %l7
- add %o0,1,%i0 ! used for debugging
-2: ret
- restore
-.size OPENSSL_wipe_cpu,.-OPENSSL_wipe_cpu
-
.global OPENSSL_atomic_add
.type OPENSSL_atomic_add,#function
.align 32
.size CRYPTO_memcmp,.-CRYPTO_memcmp
___
-print<<___ if (!$win64);
-.globl OPENSSL_wipe_cpu
-.type OPENSSL_wipe_cpu,\@abi-omnipotent
-.align 16
-OPENSSL_wipe_cpu:
-.cfi_startproc
- endbranch
- pxor %xmm0,%xmm0
- pxor %xmm1,%xmm1
- pxor %xmm2,%xmm2
- pxor %xmm3,%xmm3
- pxor %xmm4,%xmm4
- pxor %xmm5,%xmm5
- pxor %xmm6,%xmm6
- pxor %xmm7,%xmm7
- pxor %xmm8,%xmm8
- pxor %xmm9,%xmm9
- pxor %xmm10,%xmm10
- pxor %xmm11,%xmm11
- pxor %xmm12,%xmm12
- pxor %xmm13,%xmm13
- pxor %xmm14,%xmm14
- pxor %xmm15,%xmm15
- xorq %rcx,%rcx
- xorq %rdx,%rdx
- xorq %rsi,%rsi
- xorq %rdi,%rdi
- xorq %r8,%r8
- xorq %r9,%r9
- xorq %r10,%r10
- xorq %r11,%r11
- leaq 8(%rsp),%rax
- ret
-.cfi_endproc
-.size OPENSSL_wipe_cpu,.-OPENSSL_wipe_cpu
-___
-print<<___ if ($win64);
-.globl OPENSSL_wipe_cpu
-.type OPENSSL_wipe_cpu,\@abi-omnipotent
-.align 16
-OPENSSL_wipe_cpu:
- pxor %xmm0,%xmm0
- pxor %xmm1,%xmm1
- pxor %xmm2,%xmm2
- pxor %xmm3,%xmm3
- pxor %xmm4,%xmm4
- pxor %xmm5,%xmm5
- xorq %rcx,%rcx
- xorq %rdx,%rdx
- xorq %r8,%r8
- xorq %r9,%r9
- xorq %r10,%r10
- xorq %r11,%r11
- leaq 8(%rsp),%rax
- ret
-.size OPENSSL_wipe_cpu,.-OPENSSL_wipe_cpu
-___
{
my $out="%r10";
my $cnt="%rcx";
&ret ();
&function_end_B("OPENSSL_far_spin");
-&function_begin_B("OPENSSL_wipe_cpu","EXTRN\t_OPENSSL_ia32cap_P:DWORD");
- &xor ("eax","eax");
- &xor ("edx","edx");
- &picmeup("ecx","OPENSSL_ia32cap_P");
- &mov ("ecx",&DWP(0,"ecx"));
- &bt (&DWP(0,"ecx"),1);
- &jnc (&label("no_x87"));
- if ($sse2) {
- &and ("ecx",1<<26|1<<24); # check SSE2 and FXSR bits
- &cmp ("ecx",1<<26|1<<24);
- &jne (&label("no_sse2"));
- &pxor ("xmm0","xmm0");
- &pxor ("xmm1","xmm1");
- &pxor ("xmm2","xmm2");
- &pxor ("xmm3","xmm3");
- &pxor ("xmm4","xmm4");
- &pxor ("xmm5","xmm5");
- &pxor ("xmm6","xmm6");
- &pxor ("xmm7","xmm7");
- &set_label("no_sse2");
- }
- # just a bunch of fldz to zap the fp/mm bank followed by finit...
- &data_word(0xeed9eed9,0xeed9eed9,0xeed9eed9,0xeed9eed9,0x90e3db9b);
-&set_label("no_x87");
- &lea ("eax",&DWP(4,"esp"));
- &ret ();
-&function_end_B("OPENSSL_wipe_cpu");
-
&function_begin_B("OPENSSL_atomic_add");
&mov ("edx",&DWP(4,"esp")); # fetch the pointer, 1st arg
&mov ("ecx",&DWP(8,"esp")); # fetch the increment, 2nd arg
projects / thirdparty / openssl.git / commitdiff
