开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 加密解密 > CA认证 > 查看源码
mpi_sparc.c
资源名称：nss-3.1.1.tar.gz　[点击查看]
上传用户：lyxiangda
上传日期：2007-01-12
资源大小：3042k
文件大小：8k
源码类别：

CA认证

开发平台：

WINDOWS

mpi_sparc.c：源码内容
  1. /*
  2.  * The contents of this file are subject to the Mozilla Public
  3.  * License Version 1.1 (the "License"); you may not use this file
  4.  * except in compliance with the License. You may obtain a copy of
  5.  * the License at http://www.mozilla.org/MPL/
  6.  * 
  7.  * Software distributed under the License is distributed on an "AS
  8.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  9.  * implied. See the License for the specific language governing
  10.  * rights and limitations under the License.
  11.  * 
  12.  * The Original Code is the Netscape security libraries.
  13.  * 
  14.  * The Initial Developer of the Original Code is Netscape
  15.  * Communications Corporation. Portions created by Netscape are 
  16.  * Copyright (C) 2000 Netscape Communications Corporation.  All
  17.  * Rights Reserved.
  18.  * 
  19.  * Contributor(s):
  20.  * 
  21.  * Alternatively, the contents of this file may be used under the
  22.  * terms of the GNU General Public License Version 2 or later (the
  23.  * "GPL"), in which case the provisions of the GPL are applicable 
  24.  * instead of those above. If you wish to allow use of your 
  25.  * version of this file only under the terms of the GPL and not to
  26.  * allow others to use your version of this file under the MPL,
  27.  * indicate your decision by deleting the provisions above and
  28.  * replace them with the notice and other provisions required by
  29.  * the GPL.  If you do not delete the provisions above, a recipient
  30.  * may use your version of this file under either the MPL or the
  31.  * GPL.
  32.  *  $Id: mpi_sparc.c,v 1.2.2.1 2000/11/29 01:45:46 nelsonb%netscape.com Exp $
  33.  */
  35. /* Multiplication performance enhancements for sparc v8+vis CPUs. */
  37. #include "mpi-priv.h"
  38. #include <stddef.h>
  39. #include <sys/systeminfo.h>
  40. #include <strings.h>
  42. /* In the functions below, */
  43. /* vector y must be 8-byte aligned, and n must be even */
  44. /* returns carry out of high order word of result */
  45. /* maximum n is 256 */
  47. /* vector x += vector y * scaler a; where y is of length n words. */
  48. extern mp_digit mul_add_inp(mp_digit *x, const mp_digit *y, int n, mp_digit a);
  50. /* vector z = vector x + vector y * scaler a; where y is of length n words. */
  51. extern mp_digit mul_add(mp_digit *z, const mp_digit *x, const mp_digit *y, 
  52. int n, mp_digit a);
  54. /* v8 versions of these functions run on any Sparc v8 CPU. */
  56. /* This trick works on Sparc V8 CPUs with the Workshop compilers. */
  57. #define MP_MUL_DxD(a, b, Phi, Plo) 
  58.   { unsigned long long product = (unsigned long long)a * b; 
  59.     Plo = (mp_digit)product; 
  60.     Phi = (mp_digit)(product >> MP_DIGIT_BIT); }
  62. /* c = a * b */
  63. static void 
  64. v8_mpv_mul_d(const mp_digit *a, mp_size a_len, mp_digit b, mp_digit *c)
  65. {
  66. #if !defined(MP_NO_MP_WORD)
  67.   mp_digit   d = 0;
  69.   /* Inner product:  Digits of a */
  70.   while (a_len--) {
  71.     mp_word w = ((mp_word)b * *a++) + d;
  72.     *c++ = ACCUM(w);
  73.     d = CARRYOUT(w);
  74.   }
  75.   *c = d;
  76. #else
  77.   mp_digit carry = 0;
  78.   while (a_len--) {
  79.     mp_digit a_i = *a++;
  80.     mp_digit a0b0, a1b1;
  82.     MP_MUL_DxD(a_i, b, a1b1, a0b0);
  84.     a0b0 += carry;
  85.     if (a0b0 < carry)
  86.       ++a1b1;
  87.     *c++ = a0b0;
  88.     carry = a1b1;
  89.   }
  90.   *c = carry;
  91. #endif
  92. }
  94. /* c += a * b */
  95. static void 
  96. v8_mpv_mul_d_add(const mp_digit *a, mp_size a_len, mp_digit b, mp_digit *c)
  97. {
  98. #if !defined(MP_NO_MP_WORD)
  99.   mp_digit   d = 0;
  101.   /* Inner product:  Digits of a */
  102.   while (a_len--) {
  103.     mp_word w = ((mp_word)b * *a++) + *c + d;
  104.     *c++ = ACCUM(w);
  105.     d = CARRYOUT(w);
  106.   }
  107.   *c = d;
  108. #else
  109.   mp_digit carry = 0;
  110.   while (a_len--) {
  111.     mp_digit a_i = *a++;
  112.     mp_digit a0b0, a1b1;
  114.     MP_MUL_DxD(a_i, b, a1b1, a0b0);
  116.     a0b0 += carry;
  117.     if (a0b0 < carry)
  118.       ++a1b1;
  119.     a0b0 += a_i = *c;
  120.     if (a0b0 < a_i)
  121.       ++a1b1;
  122.     *c++ = a0b0;
  123.     carry = a1b1;
  124.   }
  125.   *c = carry;
  126. #endif
  127. }
  129. /* Presently, this is only used by the Montgomery arithmetic code. */
  130. /* c += a * b */
  131. static void 
  132. v8_mpv_mul_d_add_prop(const mp_digit *a, mp_size a_len, mp_digit b, mp_digit *c)
  133. {
  134. #if !defined(MP_NO_MP_WORD)
  135.   mp_digit   d = 0;
  137.   /* Inner product:  Digits of a */
  138.   while (a_len--) {
  139.     mp_word w = ((mp_word)b * *a++) + *c + d;
  140.     *c++ = ACCUM(w);
  141.     d = CARRYOUT(w);
  142.   }
  144.   while (d) {
  145.     mp_word w = (mp_word)*c + d;
  146.     *c++ = ACCUM(w);
  147.     d = CARRYOUT(w);
  148.   }
  149. #else
  150.   mp_digit carry = 0;
  151.   while (a_len--) {
  152.     mp_digit a_i = *a++;
  153.     mp_digit a0b0, a1b1;
  155.     MP_MUL_DxD(a_i, b, a1b1, a0b0);
  157.     a0b0 += carry;
  158.     if (a0b0 < carry)
  159.       ++a1b1;
  161.     a0b0 += a_i = *c;
  162.     if (a0b0 < a_i)
  163.       ++a1b1;
  165.     *c++ = a0b0;
  166.     carry = a1b1;
  167.   }
  168.   while (carry) {
  169.     mp_digit c_i = *c;
  170.     carry += c_i;
  171.     *c++ = carry;
  172.     carry = carry < c_i;
  173.   }
  174. #endif
  175. }
  177. /* vis versions of these functions run only on v8+vis or v9+vis CPUs. */
  179. /* c = a * b */
  180. static void 
  181. vis_mpv_mul_d(const mp_digit *a, mp_size a_len, mp_digit b, mp_digit *c)
  182. {
  183.     mp_digit d;
  184.     mp_digit x[258];
  185.     if (a_len <= 256) {
  186. if (a == c || ((ptrdiff_t)a & 0x7) != 0 || (a_len & 1) != 0) {
  187.     mp_digit * px;
  188.     px = (((ptrdiff_t)x & 0x7) != 0) ? x + 1 : x;
  189.     memcpy(px, a, a_len * sizeof(*a));
  190.     a = px;
  191.     if (a_len & 1) {
  192. px[a_len] = 0;
  193.     }
  194. }
  195. s_mp_setz(c, a_len + 1);
  196. d = mul_add_inp(c, a, a_len, b);
  197. c[a_len] = d;
  198.     } else {
  199. v8_mpv_mul_d(a, a_len, b, c);
  200.     }
  201. }
  203. /* c += a * b, where a is a_len words long. */
  204. static void     
  205. vis_mpv_mul_d_add(const mp_digit *a, mp_size a_len, mp_digit b, mp_digit *c)
  206. {
  207.     mp_digit d;
  208.     mp_digit x[258];
  209.     if (a_len <= 256) {
  210. if (((ptrdiff_t)a & 0x7) != 0 || (a_len & 1) != 0) {
  211.     mp_digit * px;
  212.     px = (((ptrdiff_t)x & 0x7) != 0) ? x + 1 : x;
  213.     memcpy(px, a, a_len * sizeof(*a));
  214.     a = px;
  215.     if (a_len & 1) {
  216. px[a_len] = 0;
  217.     }
  218. }
  219. d = mul_add_inp(c, a, a_len, b);
  220. c[a_len] = d;
  221.     } else {
  222. v8_mpv_mul_d_add(a, a_len, b, c);
  223.     }
  224. }
  226. /* c += a * b, where a is y words long. */
  227. static void     
  228. vis_mpv_mul_d_add_prop(const mp_digit *a, mp_size a_len, mp_digit b, 
  229.  mp_digit *c)
  230. {
  231.     mp_digit d;
  232.     mp_digit x[258];
  233.     if (a_len <= 256) {
  234. if (((ptrdiff_t)a & 0x7) != 0 || (a_len & 1) != 0) {
  235.     mp_digit * px;
  236.     px = (((ptrdiff_t)x & 0x7) != 0) ? x + 1 : x;
  237.     memcpy(px, a, a_len * sizeof(*a));
  238.     a = px;
  239.     if (a_len & 1) {
  240. px[a_len] = 0;
  241.     }
  242. }
  243. d = mul_add_inp(c, a, a_len, b);
  244. if (d) {
  245.     c += a_len;
  246.     do {
  247. mp_digit sum = d + *c;
  248. *c++ = sum;
  249. d = sum < d;
  250.     } while (d);
  251. }
  252.     } else {
  253. v8_mpv_mul_d_add_prop(a, a_len, b, c);
  254.     }
  255. }
  257. #if defined(SOLARIS2_5)
  258. static int
  259. isSparcV8PlusVis(void)
  260. {
  261.     long buflen;
  262.     int  rv             = 0;    /* false */
  263.     char buf[256];
  264.     buflen = sysinfo(SI_MACHINE, buf, sizeof buf);
  265.     if (buflen > 0) {
  266.         rv = (!strcmp(buf, "sun4u") || !strcmp(buf, "sun4u1"));
  267.     }
  268.     return rv;
  269. }
  270. #else   /* SunOS2.6or higher has SI_ISALIST */
  272. static int
  273. isSparcV8PlusVis(void)
  274. {
  275.     long buflen;
  276.     int  rv             = 0;    /* false */
  277.     char buf[256];
  278.     buflen = sysinfo(SI_ISALIST, buf, sizeof buf);
  279.     if (buflen > 0) {
  280. #if defined(NSS_USE_64)
  281.         char * found = strstr(buf, "sparcv9+vis");
  282. #else
  283.         char * found = strstr(buf, "sparcv8plus+vis");
  284. #endif
  285.         rv = (found != 0);
  286.     }
  287.     return rv;
  288. }
  289. #endif
  291. typedef void MPVmpy(const mp_digit *a, mp_size a_len, mp_digit b, mp_digit *c);
  293. /* forward static function declarations */
  294. static MPVmpy sp_mpv_mul_d;
  295. static MPVmpy sp_mpv_mul_d_add;
  296. static MPVmpy sp_mpv_mul_d_add_prop;
  298. static MPVmpy *p_mpv_mul_d = &sp_mpv_mul_d;
  299. static MPVmpy *p_mpv_mul_d_add = &sp_mpv_mul_d_add;
  300. static MPVmpy *p_mpv_mul_d_add_prop = &sp_mpv_mul_d_add_prop;
  302. static void
  303. initPtrs(void)
  304. {
  305.     if (isSparcV8PlusVis()) {
  306. p_mpv_mul_d =  &vis_mpv_mul_d;
  307. p_mpv_mul_d_add =  &vis_mpv_mul_d_add;
  308. p_mpv_mul_d_add_prop =  &vis_mpv_mul_d_add_prop;
  309.     } else {
  310. p_mpv_mul_d =  &v8_mpv_mul_d;
  311. p_mpv_mul_d_add =  &v8_mpv_mul_d_add;
  312. p_mpv_mul_d_add_prop =  &v8_mpv_mul_d_add_prop;
  313.     }
  314. }
  316. static void 
  317. sp_mpv_mul_d(const mp_digit *a, mp_size a_len, mp_digit b, mp_digit *c)
  318. {
  319.     initPtrs();
  320.     (* p_mpv_mul_d)(a, a_len, b, c);
  321. }
  323. static void 
  324. sp_mpv_mul_d_add(const mp_digit *a, mp_size a_len, mp_digit b, mp_digit *c)
  325. {
  326.     initPtrs();
  327.     (* p_mpv_mul_d_add)(a, a_len, b, c);
  328. }
  330. static void 
  331. sp_mpv_mul_d_add_prop(const mp_digit *a, mp_size a_len, mp_digit b, mp_digit *c)
  332. {
  333.     initPtrs();
  334.     (* p_mpv_mul_d_add_prop)(a, a_len, b, c);
  335. }
  338. /* This is the external interface */
  340. void 
  341. s_mpv_mul_d(const mp_digit *a, mp_size a_len, mp_digit b, mp_digit *c)
  342. {
  343.     (* p_mpv_mul_d)(a, a_len, b, c);
  344. }
  346. void 
  347. s_mpv_mul_d_add(const mp_digit *a, mp_size a_len, mp_digit b, mp_digit *c)
  348. {
  349.     (* p_mpv_mul_d_add)(a, a_len, b, c);
  350. }
  352. void 
  353. s_mpv_mul_d_add_prop(const mp_digit *a, mp_size a_len, mp_digit b, mp_digit *c)
  354. {
  355.     (* p_mpv_mul_d_add_prop)(a, a_len, b, c);
  356. }