高速浮点除法子程序，比标准库要快得多

banana

高速浮点除法子程序，比标准库要快得多 [复制链接]

1. //==============================================================================================
2. // ----Function: float Float_DIV(float Data_A,float Data_B);
3. // -Description: 浮点除法运算子程序
4. // 最大执行时间53.3us -- 1280 Cycle (24MHz):这个时间包括参数传递和现场保护,参数返回
5. // --Parameters: 被除数/除数
6. // -----Returns: 结果,浮点数
7. // -------Notes: 和标准库相比，节约3000个Cycle左右。在运算溢出时，返回的指数为0xff,但数符为运算结果的数符
8. //==============================================================================================
9. .PUBLIC _Float_DIV
10. _Float_DIV:
11. push bp,bp to [sp]
12. bp = sp + 1
13. r2 = [bp + 5]
14. r2 |= [bp + 6]
15. jz ?ACC_over //第二个参数为零则转
16. r2 = [bp + 3] //判断是不是有参数为零,为零结果肯定是零
17. r2 |= [bp + 4]
18. jnz ?ACC_zero //第一个参数为零则转
19. ?DIV_zer //运算结果太小，直接置为零
20. r2 = 0 //高字
21. r1 = 0 //低字
22. pop bp,bp from [sp]
23. retf
24. ?ACC_over: //运算溢出
25. r2 = r1 ^ 0x7fff //返回的指数为0xff
26. r1 = 0xffff //所有尾数的位为1
27. pop bp,bp from [sp]
28. retf
29. ?ACC_zer //结果不为零，向下执行
30. r4 = [bp + 4] //第一个参数的高字
31. r3 = [bp + 6] //第二个参数的高字
32. //计算阶码
33. r2 = r4 & 0x7f80 //第一个参数的阶码
34. r1 = r3 & 0x7f80 //第二个参数的阶码
35. r2 -= r1
36. r2 += 0x3f00 //获得结果的阶码
37. cmp r2,0x7f80
38. jae ?ACC_over //如果运算溢出则转到?sum_over
39. cmp r2,0x0080
40. jb ?DIV_zero //阶码小于等于0，结果为零
41. r1 = r3 //计算符号
42. r1 ^= r4
43. r1 &= 0x8000 //计算结果的符号
44. r4 &= 0x7f
45. r4 |= 0x80 //尾数恢复
46. [bp + 4] = r4 //保存尾数高字
47. r3 &= 0x7f
48. r3 |= 0x80 //尾数恢复
49. [bp + 6] = r3 //保存尾数高字
50. cmp r4,r3 //先比较高位
51. jne ?DIV_Adj
52. r3 = [bp + 3] //比较低位
53. cmp r3,[bp + 5]
54. jne ?DIV_Adj
55. //尾数相等,商为1,数据规格化,调整商阶
56. r2 += 0x80 //指数调整
57. cmp r2,0x7f80
58. jae ?ACC_over //如果运算溢出则转到?sum_over
59. r2 |= r1 //获得符号位
60. r1 = 0 //尾数为零
61. pop bp,bp from [sp]
62. retf
63. ?DIV_Adj: //被除数和指数调整
64. jb ?DIV_next //小的话就直接执行除法
65. r3 = [bp + 3] //调整数据后再除,被除数减去除数
66. r3 -= [bp + 5]
67. [bp + 3] = r3
68. r3 = [bp + 4]
69. r3 -= [bp + 6],carry
70. [bp + 4] = r3
71. r2 += 0x80 //商阶加1
72. cmp r2,0x7f80
73. jae ?ACC_over //如果运算溢出则转到?sum_over
74. r2 |= r1
75. [sp --] = r2 //分配一个临时空间，并用来存结果的阶码和符号位
76. call _Uint24_F_DIV //除法获得的结果直接作为尾数
77. //结果在[bp + 4],[bp + 3]中
78. r2 = [bp + 4] //四舍五入
79. r1 = [bp + 3]
80. r1 += 1
81. r2 += 0,carry
82. r2 = r2 lsr 1
83. r3 = r2 lsr 3
84. r1 = r1 ror 1
85. r2 |= [++ sp]
86. pop bp,bp from [sp]
87. retf
88. ?DIV_next:
89. r2 |= r1
90. [sp --] = r2 //分配一个临时空间，并用来存结果的阶码和符号位
91. call _Uint24_F_DIV //不用调整时,除法获得的结果左移一位规格化
92. r2 = [bp + 4] //结果在[bp + 4],[bp + 3]中
93. r2 &= 0x7f
94. r2 |= [++ sp]
95. r1 = [bp + 3]
96. pop bp,bp from [sp]
97. retf
98. _Uint24_F_DIV: //结果存到[bp + 4],[bp + 3]中
99. r2 = [bp + 4]
100. r1 = [bp + 3]
101. r4 = 0 //清结果寄存器
102. r3 = 8 //算高8位结果
103. ?Uint24_Loop:
104. r4 += r4 //商和被除数整体左移一位
105. r1 += r1,carry
106. r2 += r2,carry //前8位时绝对不会有高位移出为1的情况
107. r1 -= [bp + 5] //相减判溢出
108. r2 -= [bp + 6],Carry
109. jcs ?Uint24_ADD1 //够减则转
110. r1 += [bp + 5] //不够减,被除数恢复
111. r2 += [bp + 6],Carry
112. r3 -= 1
113. jnz ?Uint24_Loop
114. jmp ?Uint24_Loop1
115. ?Uint24_ADD1:
116. r4 += 1
117. r3 -= 1
118. jnz ?Uint24_Loop
119. ?Uint24_Loop1:
120. [bp + 4] = r4 //存结果的高8位
121. r4 = 0
122. r3 = 16 //算后16位结果
123. ?Uint24_Loop2:
124. r4 += r4
125. r1 += r1,carry
126. r2 += r2,carry
127. jcs ?Uint24_SUB_ADD2
128. r1 -= [bp + 5]
129. r2 -= [bp + 6],Carry
130. jcs ?Uint24_ADD2
131. r1 += [bp + 5] //被除数恢复
132. r2 += [bp + 6],Carry
133. r3 -= 1
134. jnz ?Uint24_Loop2
135. ?Uint24_5_Adj: //尾数的四舍五入
136. r1 += r1 //试商25位结果,并做四舍五入处理
137. r2 += r2,carry
138. cmp r2,[bp + 6]
139. jne ?Uint24_5ON_Adj
140. cmp r1,[bp + 5]
141. ?Uint24_5ON_Adj:
142. jb ?Uint24_exit
143. r4 += 1
144. r3 = [bp + 4]
145. r3 += 0,carry
146. [bp + 4] = r3
147. ?Uint24_exit:
148. [bp + 3] = r4
149. retf
150. ?Uint24_SUB_ADD2:
151. r1 -= [bp + 5]
152. r2 -= [bp + 6],Carry
153. ?Uint24_ADD2:
154. r4 += 1
155. r3 -= 1
156. jnz ?Uint24_Loop2
157. jmp ?Uint24_5_Adj

复制代码