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

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

CA认证

开发平台：

WINDOWS

mpv_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 a SPARC/VIS optimized multiply and add function
  13.  *
  14.  * The Initial Developer of the Original Code is Sun Microsystems Inc.
  15.  * Portions created by Sun Microsystems Inc. are 
  16.  * Copyright (C) 1999-2000 Sun Microsystems Inc.  All Rights Reserved.
  17.  * 
  18.  * Contributor(s):
  19.  * 
  20.  * Alternatively, the contents of this file may be used under the
  21.  * terms of the GNU General Public License Version 2 or later (the
  22.  * "GPL"), in which case the provisions of the GPL are applicable 
  23.  * instead of those above. If you wish to allow use of your 
  24.  * version of this file only under the terms of the GPL and not to
  25.  * allow others to use your version of this file under the MPL,
  26.  * indicate your decision by deleting the provisions above and
  27.  * replace them with the notice and other provisions required by
  28.  * the GPL.  If you do not delete the provisions above, a recipient
  29.  * may use your version of this file under either the MPL or the
  30.  * GPL.
  31.  *  $Id: mpv_sparc.c,v 1.1 2000/09/29 23:38:01 nelsonb%netscape.com Exp $
  32.  */
  34. #include "vis_proto.h"
  36. /***************************************************************/
  38. typedef  int                t_s32;
  39. typedef  unsigned int       t_u32;
  40. #if defined(__sparcv9)
  41. typedef  long               t_s64;
  42. typedef  unsigned long      t_u64;
  43. #else
  44. typedef  long long          t_s64;
  45. typedef  unsigned long long t_u64;
  46. #endif
  47. typedef  double             t_d64;
  49. /***************************************************************/
  51. typedef union {
  52.   t_d64 d64;
  53.   struct {
  54.     t_s32 i0;
  55.     t_s32 i1;
  56.   } i32s;
  57. } d64_2_i32;
  59. /***************************************************************/
  61. #define BUFF_SIZE  256
  63. #define A_BITS  21
  64. #define A_MASK  ((1 << A_BITS) - 1)
  66. /***************************************************************/
  68. static t_u64 mask_cnst[] = {
  69.   0x8000000080000000ull
  70. };
  72. /***************************************************************/
  74. #define DEF_VARS(N)                     
  75.   t_d64 *py = (t_d64*)y;                
  76.   t_d64 mask = *((t_d64*)mask_cnst);    
  77.   t_d64 ca = (1u << 31) - 1;            
  78.   t_d64 da = (t_d64)a;                  
  79.   t_s64 buff[N], s;                     
  80.   d64_2_i32 dy
  82. /***************************************************************/
  84. #define MUL_U32_S64_1(i)                                        
  85.   dy.f32s.i0 = vis_fxnors(vis_read_hi(mask), ((t_f32*)y)[0]);   
  86.   buff[0] = (ca - (t_d64)dy.i32s.i0) * da
  88. #define MUL_U32_S64_1_D()                                       
  89.   dy.f32s.i0 = vis_fxnors(vis_read_hi(mask), ((t_f32*)y)[0]);   
  90.   d0 = ca - (t_d64)dy.i32s.i0;                                  
  91.   buff[0] = (t_s64)(d0 * da);                                   
  92.   buff[1] = (t_s64)(d0 * db);                                   
  94. #define MUL_U32_S64_1_E(i)                                      
  95.   dy.f32s.i0 = vis_fxnors(vis_read_hi(mask), ((t_f32*)y)[0]);   
  96.   d0 = ca - (t_d64)dy.i32s.i0;                                  
  97.   buff[0] = (t_s64)(d0 * da);                                   
  98.   buff[1] = (t_s64)(d0 * db - (1ULL << 63))
  100. /************ ***************************************************/
  102. #define MUL_U32_S64_2(i)                                
  103.   dy.d64 = vis_fxnor(mask, py[i]);                      
  104.   buff[2*(i)  ] = (ca - (t_d64)dy.i32s.i0) * da;        
  105.   buff[2*(i)+1] = (ca - (t_d64)dy.i32s.i1) * da
  107. #define MUL_U32_S64_2_D(i)              
  108.   dy.d64 = vis_fxnor(mask, py[i]);      
  109.   d0 = ca - (t_d64)dy.i32s.i0;          
  110.   d1 = ca - (t_d64)dy.i32s.i1;          
  111.   buff[4*(i)  ] = (t_s64)(d0 * da);     
  112.   buff[4*(i)+1] = (t_s64)(d0 * db);     
  113.   buff[4*(i)+2] = (t_s64)(d1 * da);     
  114.   buff[4*(i)+3] = (t_s64)(d1 * db)
  116. #define MUL_U32_S64_2_E(i)                              
  117.   dy.d64 = vis_fxnor(mask, py[i]);                      
  118.   d0 = ca - (t_d64)dy.i32s.i0;                          
  119.   d1 = ca - (t_d64)dy.i32s.i1;                          
  120.   buff[4*(i)  ] = (t_s64)(d0 * da);                     
  121.   buff[4*(i)+1] = (t_s64)(d0 * db - (1ULL << 63));      
  122.   buff[4*(i)+2] = (t_s64)(d1 * da);                     
  123.   buff[4*(i)+3] = (t_s64)(d1 * db - (1ULL << 63))
  125. /***************************************************************/
  127. #define ADD_S64_U32(i)          
  128.   s = buff[i] + x[i] + c;       
  129.   z[i] = s;                     
  130.   c = (s >> 32)
  132. #define ADD_S64_U32_D(i)                        
  133.   s = buff[2*(i)] + buff[2*(i)+1] + x[i] + c;   
  134.   z[i] = s;                                     
  135.   c = (s >> 32)
  137. #define ADD_S64_U32_E(i)                                        
  138.   s =  buff[2*(i)] + buff[2*(i)+1] + x[i] + uc + (1ULL << 63);  
  139.   z[i] = s;                                                     
  140.   uc = ((t_u64)s >> 32)
  142. /***************************************************************/
  144. #define MUL_U32_S64_8(i)        
  145.   MUL_U32_S64_2(i);             
  146.   MUL_U32_S64_2(i+1);           
  147.   MUL_U32_S64_2(i+2);           
  148.   MUL_U32_S64_2(i+3)
  150. #define MUL_U32_S64_D_8(i)      
  151.   MUL_U32_S64_2_D(i);           
  152.   MUL_U32_S64_2_D(i+1);         
  153.   MUL_U32_S64_2_D(i+2);         
  154.   MUL_U32_S64_2_D(i+3)
  156. #define MUL_U32_S64_E_8(i)      
  157.   MUL_U32_S64_2_E(i);           
  158.   MUL_U32_S64_2_E(i+1);         
  159.   MUL_U32_S64_2_E(i+2);         
  160.   MUL_U32_S64_2_E(i+3)
  162. /***************************************************************/
  164. #define ADD_S64_U32_8(i)        
  165.   ADD_S64_U32(i);               
  166.   ADD_S64_U32(i+1);             
  167.   ADD_S64_U32(i+2);             
  168.   ADD_S64_U32(i+3);             
  169.   ADD_S64_U32(i+4);             
  170.   ADD_S64_U32(i+5);             
  171.   ADD_S64_U32(i+6);             
  172.   ADD_S64_U32(i+7)
  174. #define ADD_S64_U32_D_8(i)      
  175.   ADD_S64_U32_D(i);             
  176.   ADD_S64_U32_D(i+1);           
  177.   ADD_S64_U32_D(i+2);           
  178.   ADD_S64_U32_D(i+3);           
  179.   ADD_S64_U32_D(i+4);           
  180.   ADD_S64_U32_D(i+5);           
  181.   ADD_S64_U32_D(i+6);           
  182.   ADD_S64_U32_D(i+7)
  184. #define ADD_S64_U32_E_8(i)      
  185.   ADD_S64_U32_E(i);             
  186.   ADD_S64_U32_E(i+1);           
  187.   ADD_S64_U32_E(i+2);           
  188.   ADD_S64_U32_E(i+3);           
  189.   ADD_S64_U32_E(i+4);           
  190.   ADD_S64_U32_E(i+5);           
  191.   ADD_S64_U32_E(i+6);           
  192.   ADD_S64_U32_E(i+7)
  194. /***************************************************************/
  196. t_u32 mul_add(t_u32 *z, t_u32 *x, t_u32 *y, int n, t_u32 a)
  197. {
  198.   if (a < (1 << A_BITS)) {
  200.     if (n == 8) {
  201.       DEF_VARS(8);
  202.       t_s32 c = 0;
  204.       MUL_U32_S64_8(0);
  205.       ADD_S64_U32_8(0);
  207.       return c;
  209.     } else if (n == 16) {
  210.       DEF_VARS(16);
  211.       t_s32 c = 0;
  213.       MUL_U32_S64_8(0);
  214.       MUL_U32_S64_8(4);
  215.       ADD_S64_U32_8(0);
  216.       ADD_S64_U32_8(8);
  218.       return c;
  220.     } else {
  221.       DEF_VARS(BUFF_SIZE);
  222.       t_s32 i, c = 0;
  224. #pragma pipeloop(0)
  225.       for (i = 0; i < (n+1)/2; i ++) {
  226.         MUL_U32_S64_2(i);
  227.       }
  229. #pragma pipeloop(0)
  230.       for (i = 0; i < n; i ++) {
  231.         ADD_S64_U32(i);
  232.       }
  234.       return c;
  236.     }
  237.   } else if (a < (1u << 31)) {
  239.     if (n == 8) {
  240.       DEF_VARS(2*8);
  241.       t_d64 d0, d1, db;
  242.       t_s32 c = 0;
  244.       da = (t_d64)(a &  A_MASK);
  245.       db = (t_d64)(a &~ A_MASK);
  247.       MUL_U32_S64_D_8(0);
  248.       ADD_S64_U32_D_8(0);
  250.       return c;
  252.     } else if (n == 16) {
  253.       DEF_VARS(2*16);
  254.       t_d64 d0, d1, db;
  255.       t_s32 c = 0;
  257.       da = (t_d64)(a &  A_MASK);
  258.       db = (t_d64)(a &~ A_MASK);
  260.       MUL_U32_S64_D_8(0);
  261.       MUL_U32_S64_D_8(4);
  262.       ADD_S64_U32_D_8(0);
  263.       ADD_S64_U32_D_8(8);
  265.       return c;
  267.     } else {
  268.       DEF_VARS(2*BUFF_SIZE);
  269.       t_d64 d0, d1, db;
  270.       t_s32 i, c = 0;
  272.       da = (t_d64)(a &  A_MASK);
  273.       db = (t_d64)(a &~ A_MASK);
  275. #pragma pipeloop(0)
  276.       for (i = 0; i < (n+1)/2; i ++) {
  277.         MUL_U32_S64_2_D(i);
  278.       }
  280. #pragma pipeloop(0)
  281.       for (i = 0; i < n; i ++) {
  282.         ADD_S64_U32_D(i);
  283.       }
  285.       return c;
  286.     }
  288.   } else {
  290.     if (n == 8) {
  291.       DEF_VARS(2*8);
  292.       t_d64 d0, d1, db;
  293.       t_u32 uc = 0;
  295.       da = (t_d64)(a &  A_MASK);
  296.       db = (t_d64)(a &~ A_MASK);
  298.       MUL_U32_S64_E_8(0);
  299.       ADD_S64_U32_E_8(0);
  301.       return uc;
  303.     } else if (n == 16) {
  304.       DEF_VARS(2*16);
  305.       t_d64 d0, d1, db;
  306.       t_u32 uc = 0;
  308.       da = (t_d64)(a &  A_MASK);
  309.       db = (t_d64)(a &~ A_MASK);
  311.       MUL_U32_S64_E_8(0);
  312.       MUL_U32_S64_E_8(4);
  313.       ADD_S64_U32_E_8(0);
  314.       ADD_S64_U32_E_8(8);
  316.       return uc;
  318.     } else {
  319.       DEF_VARS(2*BUFF_SIZE);
  320.       t_d64 d0, d1, db;
  321.       t_u32 uc = 0;
  322.       t_s32 i;
  324.       da = (t_d64)(a &  A_MASK);
  325.       db = (t_d64)(a &~ A_MASK);
  327. #pragma pipeloop(0)
  328.       for (i = 0; i < (n+1)/2; i ++) {
  329.         MUL_U32_S64_2_E(i);
  330.       }
  332. #pragma pipeloop(0)
  333.       for (i = 0; i < n; i ++) {
  334.         ADD_S64_U32_E(i);
  335.       }
  337.       return uc;
  338.     }
  339.   }
  340. }
  342. /***************************************************************/
  344. t_u32 mul_add_inp(t_u32 *x, t_u32 *y, int n, t_u32 a)
  345. {
  346.   return mul_add(x, x, y, n, a);
  347. }
  349. /***************************************************************/