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

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

CA认证

开发平台：

WINDOWS

mpi_mips.s：源码内容
  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_mips.s,v 1.2 2000/08/31 02:40:32 nelsonb%netscape.com Exp $
  33.  */
  34. #include <regdef.h>
  35.         .set    noreorder
  36.         .set    noat
  38.         .section        .text, 1, 0x00000006, 4, 4
  39. .text:
  40.         .section        .text
  42.         .ent    s_mpv_mul_d_add
  43.         .globl  s_mpv_mul_d_add
  45. s_mpv_mul_d_add: 
  46.  #/* c += a * b */
  47.  #void s_mpv_mul_d_add(const mp_digit *a, mp_size a_len, mp_digit b, 
  48.  #       mp_digit *c)
  49.  #{
  50.  #  mp_digit   a0, a1; regs a4, a5
  51.  #  mp_digit   c0, c1;  regs a6, a7
  52.  #  mp_digit   cy = 0;  reg t2
  53.  #  mp_word    w0, w1;  regs t0, t1
  54.  #
  55.  #  if (a_len) {
  56. beq a1,zero,.L.1
  57. move t2,zero # cy = 0
  58. dsll32 a2,a2,0 # "b" is sometimes negative (?!?!)
  59. dsrl32 a2,a2,0 # This clears the upper 32 bits.
  60.  #    a0 = a[0];
  61. lwu a4,0(a0)
  62.  #    w0 = ((mp_word)b * a0);
  63. dmultu a2,a4
  64.  #    if (--a_len) {
  65. addiu a1,a1,-1
  66. beq a1,zero,.L.2
  67.  #      while (a_len >= 2) {
  68. sltiu t3,a1,2
  69. bne t3,zero,.L.3
  70.  #   a1     = a[1];
  71. lwu a5,4(a0)
  72. .L.4:
  73.  #   a_len -= 2;
  74.         addiu a1,a1,-2
  75.  #   c0     = c[0];
  76. lwu a6,0(a3)
  77.  #   w0    += cy;
  78. mflo t0
  79. daddu t0,t0,t2
  80.  #   w0    += c0;
  81. daddu t0,t0,a6
  82.  #   w1     = (mp_word)b * a1; 
  83. dmultu a2,a5 #
  84.  #   cy     = CARRYOUT(w0);
  85. dsrl32 t2,t0,0
  86.  #   c[0]   = ACCUM(w0);
  87. sw t0,0(a3)
  88.  #   a0     = a[2];
  89. lwu a4,8(a0)
  90.  #   a     += 2;
  91. addiu a0,a0,8
  92.  #   c1     = c[1];
  93. lwu a7,4(a3)
  94.  #   w1    += cy;
  95. mflo t1
  96. daddu t1,t1,t2
  97.  #   w1    += c1;
  98. daddu t1,t1,a7
  99.  #   w0     = (mp_word)b * a0;
  100. dmultu a2,a4 #
  101.  #   cy     = CARRYOUT(w1);
  102. dsrl32 t2,t1,0
  103.  #   c[1]   = ACCUM(w1);
  104. sw t1,4(a3)
  105.  #   c     += 2;
  106. addiu a3,a3,8
  107. sltiu t3,a1,2
  108. beq t3,zero,.L.4
  109.  #   a1     = a[1];
  110. lwu a5,4(a0)
  111.  #      }
  112. .L.3:
  113.  #      c0       = c[0];
  114. lwu a6,0(a3)
  115.  #      w0      += cy;
  116.  #      if (a_len) {
  117. mflo t0
  118. beq a1,zero,.L.5
  119. daddu t0,t0,t2
  120.  #   w1     = (mp_word)b * a1; 
  121. dmultu a2,a5
  122.  #   w0    += c0;
  123. daddu t0,t0,a6 #
  124.  #   cy     = CARRYOUT(w0);
  125. dsrl32 t2,t0,0
  126.  #   c[0]   = ACCUM(w0);
  127. sw t0,0(a3)
  128.  #   c1     = c[1];
  129. lwu a7,4(a3)
  130.  #   w1    += cy;
  131. mflo t1
  132. daddu t1,t1,t2
  133.  #   w1    += c1;
  134. daddu t1,t1,a7
  135.  #   c[1]   = ACCUM(w1);
  136. sw t1,4(a3)
  137.  #   cy     = CARRYOUT(w1);
  138. dsrl32 t2,t1,0
  139.  #   c     += 1;
  140. b .L.6
  141. addiu a3,a3,4
  142.  #      } else {
  143. .L.5:
  144.  #   w0    += c0;
  145. daddu t0,t0,a6
  146.  #   c[0]   = ACCUM(w0);
  147. sw t0,0(a3)
  148.  #   cy     = CARRYOUT(w0);
  149. b .L.6
  150. dsrl32 t2,t0,0
  151.  #      }
  152.  #    } else {
  153. .L.2:
  154.  #      c0     = c[0];
  155. lwu a6,0(a3)
  156.  #      w0    += c0;
  157. mflo t0
  158. daddu t0,t0,a6
  159.  #      c[0]   = ACCUM(w0);
  160. sw t0,0(a3)
  161.  #      cy     = CARRYOUT(w0);
  162. dsrl32 t2,t0,0
  163.  #    }
  164. .L.6:
  165.  #    c[1] = cy;
  166. jr ra
  167. sw t2,4(a3)
  168.  #  }
  169. .L.1:
  170. jr ra
  171. nop
  172.  #}
  173.  #
  174.         .end    s_mpv_mul_d_add
  176.         .ent    s_mpv_mul_d_add_prop
  177.         .globl  s_mpv_mul_d_add_prop
  179. s_mpv_mul_d_add_prop: 
  180.  #/* c += a * b */
  181.  #void s_mpv_mul_d_add_prop(const mp_digit *a, mp_size a_len, mp_digit b, 
  182.  #       mp_digit *c)
  183.  #{
  184.  #  mp_digit   a0, a1; regs a4, a5
  185.  #  mp_digit   c0, c1;  regs a6, a7
  186.  #  mp_digit   cy = 0;  reg t2
  187.  #  mp_word    w0, w1;  regs t0, t1
  188.  #
  189.  #  if (a_len) {
  190. beq a1,zero,.M.1
  191. move t2,zero # cy = 0
  192. dsll32 a2,a2,0 # "b" is sometimes negative (?!?!)
  193. dsrl32 a2,a2,0 # This clears the upper 32 bits.
  194.  #    a0 = a[0];
  195. lwu a4,0(a0)
  196.  #    w0 = ((mp_word)b * a0);
  197. dmultu a2,a4
  198.  #    if (--a_len) {
  199. addiu a1,a1,-1
  200. beq a1,zero,.M.2
  201.  #      while (a_len >= 2) {
  202. sltiu t3,a1,2
  203. bne t3,zero,.M.3
  204.  #   a1     = a[1];
  205. lwu a5,4(a0)
  206. .M.4:
  207.  #   a_len -= 2;
  208.         addiu a1,a1,-2
  209.  #   c0     = c[0];
  210. lwu a6,0(a3)
  211.  #   w0    += cy;
  212. mflo t0
  213. daddu t0,t0,t2
  214.  #   w0    += c0;
  215. daddu t0,t0,a6
  216.  #   w1     = (mp_word)b * a1; 
  217. dmultu a2,a5 #
  218.  #   cy     = CARRYOUT(w0);
  219. dsrl32 t2,t0,0
  220.  #   c[0]   = ACCUM(w0);
  221. sw t0,0(a3)
  222.  #   a0     = a[2];
  223. lwu a4,8(a0)
  224.  #   a     += 2;
  225. addiu a0,a0,8
  226.  #   c1     = c[1];
  227. lwu a7,4(a3)
  228.  #   w1    += cy;
  229. mflo t1
  230. daddu t1,t1,t2
  231.  #   w1    += c1;
  232. daddu t1,t1,a7
  233.  #   w0     = (mp_word)b * a0;
  234. dmultu a2,a4 #
  235.  #   cy     = CARRYOUT(w1);
  236. dsrl32 t2,t1,0
  237.  #   c[1]   = ACCUM(w1);
  238. sw t1,4(a3)
  239.  #   c     += 2;
  240. addiu a3,a3,8
  241. sltiu t3,a1,2
  242. beq t3,zero,.M.4
  243.  #   a1     = a[1];
  244. lwu a5,4(a0)
  245.  #      }
  246. .M.3:
  247.  #      c0       = c[0];
  248. lwu a6,0(a3)
  249.  #      w0      += cy;
  250.  #      if (a_len) {
  251. mflo t0
  252. beq a1,zero,.M.5
  253. daddu t0,t0,t2
  254.  #   w1     = (mp_word)b * a1; 
  255. dmultu a2,a5
  256.  #   w0    += c0;
  257. daddu t0,t0,a6 #
  258.  #   cy     = CARRYOUT(w0);
  259. dsrl32 t2,t0,0
  260.  #   c[0]   = ACCUM(w0);
  261. sw t0,0(a3)
  262.  #   c1     = c[1];
  263. lwu a7,4(a3)
  264.  #   w1    += cy;
  265. mflo t1
  266. daddu t1,t1,t2
  267.  #   w1    += c1;
  268. daddu t1,t1,a7
  269.  #   c[1]   = ACCUM(w1);
  270. sw t1,4(a3)
  271.  #   cy     = CARRYOUT(w1);
  272. dsrl32 t2,t1,0
  273.  #   c     += 1;
  274. b .M.6
  275. addiu a3,a3,8
  276.  #      } else {
  277. .M.5:
  278.  #   w0    += c0;
  279. daddu t0,t0,a6
  280.  #   c[0]   = ACCUM(w0);
  281. sw t0,0(a3)
  282.  #   cy     = CARRYOUT(w0);
  283. dsrl32 t2,t0,0
  284. b .M.6
  285. addiu a3,a3,4
  286.  #      }
  287.  #    } else {
  288. .M.2:
  289.  #      c0     = c[0];
  290. lwu a6,0(a3)
  291.  #      w0    += c0;
  292. mflo t0
  293. daddu t0,t0,a6
  294.  #      c[0]   = ACCUM(w0);
  295. sw t0,0(a3)
  296.  #      cy     = CARRYOUT(w0);
  297. dsrl32 t2,t0,0
  298. addiu a3,a3,4
  299.  #    }
  300. .M.6:
  302.  #    while (cy) {
  303. beq t2,zero,.M.1
  304. nop
  305. .M.7:
  306.  #      mp_word w = (mp_word)*c + cy;
  307. lwu a6,0(a3)
  308. daddu t2,t2,a6
  309.  #      *c++ = ACCUM(w);
  310. sw t2,0(a3)
  311.  #      cy = CARRYOUT(w);
  312. dsrl32 t2,t2,0
  313. bne t2,zero,.M.7
  314. addiu a3,a3,4
  316.  #  }
  317. .M.1:
  318. jr ra
  319. nop
  320.  #}
  321.  #
  322.         .end    s_mpv_mul_d_add_prop
  324.         .ent    s_mpv_mul_d
  325.         .globl  s_mpv_mul_d
  327. s_mpv_mul_d: 
  328.  #/* c = a * b */
  329.  #void s_mpv_mul_d(const mp_digit *a, mp_size a_len, mp_digit b, 
  330.  #       mp_digit *c)
  331.  #{
  332.  #  mp_digit   a0, a1; regs a4, a5
  333.  #  mp_digit   cy = 0;  reg t2
  334.  #  mp_word    w0, w1;  regs t0, t1
  335.  #
  336.  #  if (a_len) {
  337. beq a1,zero,.N.1
  338. move t2,zero # cy = 0
  339. dsll32 a2,a2,0 # "b" is sometimes negative (?!?!)
  340. dsrl32 a2,a2,0 # This clears the upper 32 bits.
  341.  #    a0 = a[0];
  342. lwu a4,0(a0)
  343.  #    w0 = ((mp_word)b * a0);
  344. dmultu a2,a4
  345.  #    if (--a_len) {
  346. addiu a1,a1,-1
  347. beq a1,zero,.N.2
  348.  #      while (a_len >= 2) {
  349. sltiu t3,a1,2
  350. bne t3,zero,.N.3
  351.  #   a1     = a[1];
  352. lwu a5,4(a0)
  353. .N.4:
  354.  #   a_len -= 2;
  355.         addiu a1,a1,-2
  356.  #   w0    += cy;
  357. mflo t0
  358. daddu t0,t0,t2
  359.  #   cy     = CARRYOUT(w0);
  360. dsrl32 t2,t0,0
  361.  #   w1     = (mp_word)b * a1; 
  362. dmultu a2,a5
  363.  #   c[0]   = ACCUM(w0);
  364. sw t0,0(a3)
  365.  #   a0     = a[2];
  366. lwu a4,8(a0)
  367.  #   a     += 2;
  368. addiu a0,a0,8
  369.  #   w1    += cy;
  370. mflo t1
  371. daddu t1,t1,t2
  372.  #   cy     = CARRYOUT(w1);
  373. dsrl32 t2,t1,0
  374.  #   w0     = (mp_word)b * a0;
  375. dmultu a2,a4
  376.  #   c[1]   = ACCUM(w1);
  377. sw t1,4(a3)
  378.  #   c     += 2;
  379. addiu a3,a3,8
  380. sltiu t3,a1,2
  381. beq t3,zero,.N.4
  382.  #   a1     = a[1];
  383. lwu a5,4(a0)
  384.  #      }
  385. .N.3:
  386.  #      w0      += cy;
  387.  #      if (a_len) {
  388. mflo t0
  389. beq a1,zero,.N.5
  390. daddu t0,t0,t2
  391.  #   w1     = (mp_word)b * a1; 
  392. dmultu a2,a5 #
  393.  #   cy     = CARRYOUT(w0);
  394. dsrl32 t2,t0,0
  395.  #   c[0]   = ACCUM(w0);
  396. sw t0,0(a3)
  397.  #   w1    += cy;
  398. mflo t1
  399. daddu t1,t1,t2
  400.  #   c[1]   = ACCUM(w1);
  401. sw t1,4(a3)
  402.  #   cy     = CARRYOUT(w1);
  403. dsrl32 t2,t1,0
  404.  #   c     += 1;
  405. b .N.6
  406. addiu a3,a3,4
  407.  #      } else {
  408. .N.5:
  409.  #   c[0]   = ACCUM(w0);
  410. sw t0,0(a3)
  411.  #   cy     = CARRYOUT(w0);
  412. b .N.6
  413. dsrl32 t2,t0,0
  414.  #      }
  415.  #    } else {
  416. .N.2:
  417. mflo t0
  418.  #      c[0]   = ACCUM(w0);
  419. sw t0,0(a3)
  420.  #      cy     = CARRYOUT(w0);
  421. dsrl32 t2,t0,0
  422.  #    }
  423. .N.6:
  424.  #    c[1] = cy;
  425. jr ra
  426. sw t2,4(a3)
  427.  #  }
  428. .N.1:
  429. jr ra
  430. nop
  431.  #}
  432.  #
  433.         .end    s_mpv_mul_d
  436.         .ent    s_mpv_sqr_add_prop
  437.         .globl  s_mpv_sqr_add_prop
  438.  #void   s_mpv_sqr_add_prop(const mp_digit *a, mp_size a_len, mp_digit *sqrs);
  439.  # registers
  440.  # a0 *a
  441.  # a1 a_len
  442.  # a2 *sqr
  443.  # a3 digit from *a, a_i
  444.  # a4 square of digit from a
  445.  # a5,a6 next 2 digits in sqr
  446.  # a7,t0 carry 
  447. s_mpv_sqr_add_prop:
  448. move a7,zero
  449. move t0,zero
  450. lwu a3,0(a0)
  451. addiu a1,a1,-1 # --a_len
  452. dmultu a3,a3
  453. beq a1,zero,.P.3 # jump if we've already done the only sqr
  454. addiu a0,a0,4 # ++a
  455. .P.2:
  456.         lwu a5,0(a2)
  457.         lwu a6,4(a2)
  458. addiu a2,a2,8 # sqrs += 2;
  459. dsll32 a6,a6,0
  460. daddu a5,a5,a6
  461. lwu a3,0(a0)
  462. addiu a0,a0,4 # ++a
  463. mflo a4
  464. daddu a6,a5,a4
  465. sltu a7,a6,a5 # a7 = a6 < a5 detect overflow
  466. dmultu a3,a3
  467. daddu a4,a6,t0
  468. sltu t0,a4,a6
  469. add t0,t0,a7
  470. sw a4,-8(a2)
  471. addiu a1,a1,-1 # --a_len
  472. dsrl32 a4,a4,0
  473. bne a1,zero,.P.2 # loop if a_len > 0
  474. sw a4,-4(a2)
  475. .P.3:
  476.         lwu a5,0(a2)
  477.         lwu a6,4(a2)
  478. addiu a2,a2,8 # sqrs += 2;
  479. dsll32 a6,a6,0
  480. daddu a5,a5,a6
  481. mflo a4
  482. daddu a6,a5,a4
  483. sltu a7,a6,a5 # a7 = a6 < a5 detect overflow
  484. daddu a4,a6,t0
  485. sltu t0,a4,a6
  486. add t0,t0,a7
  487. sw a4,-8(a2)
  488. beq t0,zero,.P.9 # jump if no carry
  489. dsrl32 a4,a4,0
  490. .P.8:
  491. sw a4,-4(a2)
  492. /* propagate final carry */
  493. lwu a5,0(a2)
  494. daddu a6,a5,t0
  495. sltu t0,a6,a5
  496. bne t0,zero,.P.8 # loop if carry persists
  497. addiu a2,a2,4 # sqrs++
  498. .P.9:
  499. jr ra
  500. sw a4,-4(a2)
  502.         .end    s_mpv_sqr_add_prop