EVP_PKEY_METHOD accessor functions.
[openssl.git] / crypto / ppccap.c
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <string.h>
4 #include <setjmp.h>
5 #include <signal.h>
6 #include <unistd.h>
7 #if defined(__linux) || defined(_AIX)
8 # include <sys/utsname.h>
9 #endif
10 #if defined(__APPLE__) && defined(__MACH__)
11 # include <sys/types.h>
12 # include <sys/sysctl.h>
13 #endif
14 #include <openssl/crypto.h>
15 #include <openssl/bn.h>
16
17 #include "ppc_arch.h"
18
19 unsigned int OPENSSL_ppccap_P = 0;
20
21 static sigset_t all_masked;
22
23 #ifdef OPENSSL_BN_ASM_MONT
24 int bn_mul_mont(BN_ULONG *rp, const BN_ULONG *ap, const BN_ULONG *bp,
25                 const BN_ULONG *np, const BN_ULONG *n0, int num)
26 {
27     int bn_mul_mont_fpu64(BN_ULONG *rp, const BN_ULONG *ap,
28                           const BN_ULONG *bp, const BN_ULONG *np,
29                           const BN_ULONG *n0, int num);
30     int bn_mul_mont_int(BN_ULONG *rp, const BN_ULONG *ap, const BN_ULONG *bp,
31                         const BN_ULONG *np, const BN_ULONG *n0, int num);
32
33     if (sizeof(size_t) == 4) {
34 # if 1 || (defined(__APPLE__) && defined(__MACH__))
35         if (num >= 8 && (num & 3) == 0 && (OPENSSL_ppccap_P & PPC_FPU64))
36             return bn_mul_mont_fpu64(rp, ap, bp, np, n0, num);
37 # else
38         /*
39          * boundary of 32 was experimentally determined on Linux 2.6.22,
40          * might have to be adjusted on AIX...
41          */
42         if (num >= 32 && (num & 3) == 0 && (OPENSSL_ppccap_P & PPC_FPU64)) {
43             sigset_t oset;
44             int ret;
45
46             sigprocmask(SIG_SETMASK, &all_masked, &oset);
47             ret = bn_mul_mont_fpu64(rp, ap, bp, np, n0, num);
48             sigprocmask(SIG_SETMASK, &oset, NULL);
49
50             return ret;
51         }
52 # endif
53     } else if ((OPENSSL_ppccap_P & PPC_FPU64))
54         /*
55          * this is a "must" on POWER6, but run-time detection is not
56          * implemented yet...
57          */
58         return bn_mul_mont_fpu64(rp, ap, bp, np, n0, num);
59
60     return bn_mul_mont_int(rp, ap, bp, np, n0, num);
61 }
62 #endif
63
64 void sha256_block_p8(void *ctx, const void *inp, size_t len);
65 void sha256_block_ppc(void *ctx, const void *inp, size_t len);
66 void sha256_block_data_order(void *ctx, const void *inp, size_t len)
67 {
68     OPENSSL_ppccap_P & PPC_CRYPTO207 ? sha256_block_p8(ctx, inp, len) :
69         sha256_block_ppc(ctx, inp, len);
70 }
71
72 void sha512_block_p8(void *ctx, const void *inp, size_t len);
73 void sha512_block_ppc(void *ctx, const void *inp, size_t len);
74 void sha512_block_data_order(void *ctx, const void *inp, size_t len)
75 {
76     OPENSSL_ppccap_P & PPC_CRYPTO207 ? sha512_block_p8(ctx, inp, len) :
77         sha512_block_ppc(ctx, inp, len);
78 }
79
80 static sigjmp_buf ill_jmp;
81 static void ill_handler(int sig)
82 {
83     siglongjmp(ill_jmp, sig);
84 }
85
86 void OPENSSL_ppc64_probe(void);
87 void OPENSSL_altivec_probe(void);
88 void OPENSSL_crypto207_probe(void);
89
90 void OPENSSL_cpuid_setup(void)
91 {
92     char *e;
93     struct sigaction ill_oact, ill_act;
94     sigset_t oset;
95     static int trigger = 0;
96
97     if (trigger)
98         return;
99     trigger = 1;
100
101     sigfillset(&all_masked);
102     sigdelset(&all_masked, SIGILL);
103     sigdelset(&all_masked, SIGTRAP);
104 #ifdef SIGEMT
105     sigdelset(&all_masked, SIGEMT);
106 #endif
107     sigdelset(&all_masked, SIGFPE);
108     sigdelset(&all_masked, SIGBUS);
109     sigdelset(&all_masked, SIGSEGV);
110
111     if ((e = getenv("OPENSSL_ppccap"))) {
112         OPENSSL_ppccap_P = strtoul(e, NULL, 0);
113         return;
114     }
115
116     OPENSSL_ppccap_P = 0;
117
118 #if defined(_AIX)
119     if (sizeof(size_t) == 4) {
120         struct utsname uts;
121 # if defined(_SC_AIX_KERNEL_BITMODE)
122         if (sysconf(_SC_AIX_KERNEL_BITMODE) != 64)
123             return;
124 # endif
125         if (uname(&uts) != 0 || atoi(uts.version) < 6)
126             return;
127     }
128 #endif
129
130 #if defined(__APPLE__) && defined(__MACH__)
131     {
132         int val;
133         size_t len = sizeof(val);
134
135         if (sysctlbyname("hw.optional.64bitops", &val, &len, NULL, 0) == 0) {
136             if (val)
137                 OPENSSL_ppccap_P |= PPC_FPU64;
138         }
139
140         len = sizeof(val);
141         if (sysctlbyname("hw.optional.altivec", &val, &len, NULL, 0) == 0) {
142             if (val)
143                 OPENSSL_ppccap_P |= PPC_ALTIVEC;
144         }
145
146         return;
147     }
148 #endif
149
150     memset(&ill_act, 0, sizeof(ill_act));
151     ill_act.sa_handler = ill_handler;
152     ill_act.sa_mask = all_masked;
153
154     sigprocmask(SIG_SETMASK, &ill_act.sa_mask, &oset);
155     sigaction(SIGILL, &ill_act, &ill_oact);
156
157     if (sizeof(size_t) == 4) {
158 #ifdef __linux
159         struct utsname uts;
160         if (uname(&uts) == 0 && strcmp(uts.machine, "ppc64") == 0)
161 #endif
162             if (sigsetjmp(ill_jmp, 1) == 0) {
163                 OPENSSL_ppc64_probe();
164                 OPENSSL_ppccap_P |= PPC_FPU64;
165             }
166     } else {
167         /*
168          * Wanted code detecting POWER6 CPU and setting PPC_FPU64
169          */
170     }
171
172     if (sigsetjmp(ill_jmp, 1) == 0) {
173         OPENSSL_altivec_probe();
174         OPENSSL_ppccap_P |= PPC_ALTIVEC;
175         if (sigsetjmp(ill_jmp, 1) == 0) {
176             OPENSSL_crypto207_probe();
177             OPENSSL_ppccap_P |= PPC_CRYPTO207;
178         }
179     }
180
181     sigaction(SIGILL, &ill_oact, NULL);
182     sigprocmask(SIG_SETMASK, &oset, NULL);
183 }