OSchip
/
OpenBLAS
Not watched
1
0
Fork 0
Code
Releases 66 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branch: develop
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'develop'
${ noResults }
OpenBLAS/kernel/arm/nrm2_vfpv3.S

520 lines
13 kB
Raw Permalink Blame History 

  1. /***************************************************************************

  2. Copyright (c) 2013, The OpenBLAS Project

  3. All rights reserved.

  4. Redistribution and use in source and binary forms, with or without

  5. modification, are permitted provided that the following conditions are

  6. met:

  7. 1. Redistributions of source code must retain the above copyright

  8. notice, this list of conditions and the following disclaimer.

  9. 2. Redistributions in binary form must reproduce the above copyright

  10. notice, this list of conditions and the following disclaimer in

  11. the documentation and/or other materials provided with the

  12. distribution.

  13. 3. Neither the name of the OpenBLAS project nor the names of

  14. its contributors may be used to endorse or promote products

  15. derived from this software without specific prior written permission.

  16. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

  17. AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

  18. IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

  19. ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT OR CONTRIBUTORS BE

  20. LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

  21. DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

  22. SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

  23. CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

  24. OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE

  25. USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

  26. *****************************************************************************/

  27. 

  28. /**************************************************************************************

  29. * 2013/11/16 Saar

  30. * 	 BLASTEST 		: OK

  31. * 	 CTEST			: OK

  32. * 	 TEST			: OK

  33. *

  34. **************************************************************************************/

  35. 

  36. #define ASSEMBLER

  37. #include "common.h"

  38. 

  39. #define STACKSIZE 256

  40. 

  41. #define	N	r0

  42. #define	X	r1

  43. #define	INC_X	r2

  44. 

  45. #define I	r12

  46. 

  47. #define X_PRE	512

  48. 

  49. /**************************************************************************************

  50. * Macro definitions

  51. **************************************************************************************/

  52. 

  53. 

  54. #if	!defined(COMPLEX)

  55. 

  56. #if	defined(DOUBLE)

  57. 

  58. 

  59. .macro KERNEL_F1

  60. 

  61. 	vldmia.f64	X!, 	{ d4 }

  62. 	vcmpe.f64	d4, d6				// compare with 0.0

  63. 	vmrs		APSR_nzcv, fpscr

  64. 	beq		1f     /* KERNEL_F1_NEXT_\@ */

  65. 	vabs.f64   	d4,  d4

  66. 	vcmpe.f64  	d0,  d4				// compare with scale

  67. 	vmrs		APSR_nzcv, fpscr

  68. 	vdivge.f64	d2 , d4, d0			// scale >= x ?	x / scale

  69. 	vmlage.f64	d1 , d2 , d2			// ssq += ( x/scale ) * ( x/scale )

  70. 	bge		1f     /* KERNEL_F1_NEXT_\@ */

  71. 	vdiv.f64	d2 , d0, d4			// scale / x

  72. 	vmul.f64	d2 , d2, d2			// ( scale / x ) * ( scale / x )

  73. 	vmul.f64	d3 , d1, d2			// ssq * ( scale / x ) * ( scale / x )

  74. 	vadd.f64	d1 , d3, d7			// ssq = 1 + ssq * ( scale / x ) * ( scale / x )

  75. 	vmov.f64	d0 , d4				// scale = x

  76. 

  77. 1:                             /* KERNEL_F1_NEXT_\@: */

  78. 

  79. .endm

  80. 

  81. .macro KERNEL_F8

  82. 

  83. 	pld	[ X, #X_PRE ]

  84. 	KERNEL_F1

  85. 	KERNEL_F1

  86. 	KERNEL_F1

  87. 	KERNEL_F1

  88. 	pld	[ X, #X_PRE ]

  89. 	KERNEL_F1

  90. 	KERNEL_F1

  91. 	KERNEL_F1

  92. 	KERNEL_F1

  93. 

  94. .endm

  95. 

  96. .macro KERNEL_S1

  97. 

  98. 	vldmia.f64	X, 	{ d4 }

  99. 	vcmpe.f64	d4, d6				// compare with 0.0

  100. 	vmrs		APSR_nzcv, fpscr

  101. 	beq		KERNEL_S1_NEXT

  102. 	vabs.f64   	d4,  d4

  103. 	vcmpe.f64  	d0,  d4				// compare with scale

  104. 	vmrs		APSR_nzcv, fpscr

  105. 	vdivge.f64	d2 , d4, d0			// scale >= x ?	x / scale

  106. 	vmlage.f64	d1 , d2 , d2			// ssq += ( x/scale ) * ( x/scale )

  107. 	bge		KERNEL_S1_NEXT

  108. 	vdiv.f64	d2 , d0, d4			// scale / x

  109. 	vmul.f64	d2 , d2, d2			// ( scale / x ) * ( scale / x )

  110. 	vmul.f64	d3 , d1, d2			// ssq * ( scale / x ) * ( scale / x )

  111. 	vadd.f64	d1 , d3, d7			// ssq = 1 + ssq * ( scale / x ) * ( scale / x )

  112. 	vmov.f64	d0 , d4				// scale = x

  113. 

  114. KERNEL_S1_NEXT:

  115. 

  116. 	add	X, X, INC_X

  117. 

  118. .endm

  119. 

  120. #else

  121. 

  122. .macro KERNEL_F1

  123. 

  124. 	vldmia.f32	X!, 	{ s4 }

  125. 	vcmpe.f32	s4, s6				// compare with 0.0

  126. 	vmrs		APSR_nzcv, fpscr

  127. 	beq		1f        /* KERNEL_F1_NEXT_\@ */

  128. 	vabs.f32   	s4,  s4

  129. 	vcmpe.f32  	s0,  s4				// compare with scale

  130. 	vmrs		APSR_nzcv, fpscr

  131. 	vdivge.f32	s2 , s4, s0			// scale >= x ?	x / scale

  132. 	vmlage.f32	s1 , s2 , s2			// ssq += ( x/scale ) * ( x/scale )

  133. 	bge		1f        /* KERNEL_F1_NEXT_\@ */

  134. 	vdiv.f32	s2 , s0, s4			// scale / x

  135. 	vmul.f32	s2 , s2, s2			// ( scale / x ) * ( scale / x )

  136. 	vmul.f32	s3 , s1, s2			// ssq * ( scale / x ) * ( scale / x )

  137. 	vadd.f32	s1 , s3, s7			// ssq = 1 + ssq * ( scale / x ) * ( scale / x )

  138. 	vmov.f32	s0 , s4				// scale = x

  139. 

  140. 1:                                /* KERNEL_F1_NEXT_\@: */

  141. 

  142. .endm

  143. 

  144. .macro KERNEL_F8

  145. 

  146. 	pld	[ X, #X_PRE ]

  147. 	KERNEL_F1

  148. 	KERNEL_F1

  149. 	KERNEL_F1

  150. 	KERNEL_F1

  151. 

  152. 	KERNEL_F1

  153. 	KERNEL_F1

  154. 	KERNEL_F1

  155. 	KERNEL_F1

  156. 

  157. .endm

  158. 

  159. .macro KERNEL_S1

  160. 

  161. 	vldmia.f32	X, 	{ s4 }

  162. 	vcmpe.f32	s4, s6				// compare with 0.0

  163. 	vmrs		APSR_nzcv, fpscr

  164. 	beq		KERNEL_S1_NEXT

  165. 	vabs.f32   	s4,  s4

  166. 	vcmpe.f32  	s0,  s4				// compare with scale

  167. 	vmrs		APSR_nzcv, fpscr

  168. 	vdivge.f32	s2 , s4, s0			// scale >= x ?	x / scale

  169. 	vmlage.f32	s1 , s2 , s2			// ssq += ( x/scale ) * ( x/scale )

  170. 	bge		KERNEL_S1_NEXT

  171. 	vdiv.f32	s2 , s0, s4			// scale / x

  172. 	vmul.f32	s2 , s2, s2			// ( scale / x ) * ( scale / x )

  173. 	vmul.f32	s3 , s1, s2			// ssq * ( scale / x ) * ( scale / x )

  174. 	vadd.f32	s1 , s3, s7			// ssq = 1 + ssq * ( scale / x ) * ( scale / x )

  175. 	vmov.f32	s0 , s4				// scale = x

  176. 

  177. KERNEL_S1_NEXT:

  178. 

  179. 	add	X, X, INC_X

  180. 

  181. .endm

  182. 

  183. 

  184. 

  185. 

  186. #endif

  187. 

  188. #else

  189. 

  190. #if	defined(DOUBLE)

  191. 

  192. .macro KERNEL_F1

  193. 

  194. 	vldmia.f64	X!, 	{ d4 - d5 }

  195. 

  196. 	vcmpe.f64	d4, d6				// compare with 0.0

  197. 	vmrs		APSR_nzcv, fpscr

  198. 	beq		1f           /* KERNEL_F1_NEXT_\@ */

  199. 	vabs.f64   	d4,  d4

  200. 	vcmpe.f64  	d0,  d4				// compare with scale

  201. 	vmrs		APSR_nzcv, fpscr

  202. 	vdivge.f64	d2 , d4, d0			// scale >= x ?	x / scale

  203. 	vmlage.f64	d1 , d2 , d2			// ssq += ( x/scale ) * ( x/scale )

  204. 	bge		1f           /* KERNEL_F1_NEXT_\@ */

  205. 	vdiv.f64	d2 , d0, d4			// scale / x

  206. 	vmul.f64	d2 , d2, d2			// ( scale / x ) * ( scale / x )

  207. 	vmul.f64	d3 , d1, d2			// ssq * ( scale / x ) * ( scale / x )

  208. 	vadd.f64	d1 , d3, d7			// ssq = 1 + ssq * ( scale / x ) * ( scale / x )

  209. 	vmov.f64	d0 , d4				// scale = x

  210. 

  211. 1:                                   /* KERNEL_F1_NEXT_\@: */

  212. 

  213. 	vcmpe.f64	d5, d6				// compare with 0.0

  214. 	vmrs		APSR_nzcv, fpscr

  215. 	beq		2f           /* KERNEL_F1_END_\@ */

  216. 	vabs.f64   	d5,  d5

  217. 	vcmpe.f64  	d0,  d5				// compare with scale

  218. 	vmrs		APSR_nzcv, fpscr

  219. 	vdivge.f64	d2 , d5, d0			// scale >= x ?	x / scale

  220. 	vmlage.f64	d1 , d2 , d2			// ssq += ( x/scale ) * ( x/scale )

  221. 	bge		2f           /* KERNEL_F1_END_\@ */

  222. 	vdiv.f64	d2 , d0, d5			// scale / x

  223. 	vmul.f64	d2 , d2, d2			// ( scale / x ) * ( scale / x )

  224. 	vmul.f64	d3 , d1, d2			// ssq * ( scale / x ) * ( scale / x )

  225. 	vadd.f64	d1 , d3, d7			// ssq = 1 + ssq * ( scale / x ) * ( scale / x )

  226. 	vmov.f64	d0 , d5				// scale = x

  227. 

  228. 2:                                   /* KERNEL_F1_END_\@: */

  229. 

  230. 

  231. .endm

  232. 

  233. .macro KERNEL_F8

  234. 

  235. 	pld	[ X, #X_PRE ]

  236. 	KERNEL_F1

  237. 	KERNEL_F1

  238. 	pld	[ X, #X_PRE ]

  239. 	KERNEL_F1

  240. 	KERNEL_F1

  241. 	pld	[ X, #X_PRE ]

  242. 	KERNEL_F1

  243. 	KERNEL_F1

  244. 	pld	[ X, #X_PRE ]

  245. 	KERNEL_F1

  246. 	KERNEL_F1

  247. 

  248. .endm

  249. 

  250. .macro KERNEL_S1

  251. 

  252. 	vldmia.f64	X, 	{ d4 - d5 }

  253. 

  254. 	vcmpe.f64	d4, d6				// compare with 0.0

  255. 	vmrs		APSR_nzcv, fpscr

  256. 	beq		1f          /* KERNEL_S1_NEXT_\@ */

  257. 	vabs.f64   	d4,  d4

  258. 	vcmpe.f64  	d0,  d4				// compare with scale

  259. 	vmrs		APSR_nzcv, fpscr

  260. 	vdivge.f64	d2 , d4, d0			// scale >= x ?	x / scale

  261. 	vmlage.f64	d1 , d2 , d2			// ssq += ( x/scale ) * ( x/scale )

  262. 	bge		1f          /* KERNEL_S1_NEXT_\@ */

  263. 	vdiv.f64	d2 , d0, d4			// scale / x

  264. 	vmul.f64	d2 , d2, d2			// ( scale / x ) * ( scale / x )

  265. 	vmul.f64	d3 , d1, d2			// ssq * ( scale / x ) * ( scale / x )

  266. 	vadd.f64	d1 , d3, d7			// ssq = 1 + ssq * ( scale / x ) * ( scale / x )

  267. 	vmov.f64	d0 , d4				// scale = x

  268. 

  269. 1:                                  /* KERNEL_S1_NEXT_\@: */

  270. 

  271. 	vcmpe.f64	d5, d6				// compare with 0.0

  272. 	vmrs		APSR_nzcv, fpscr

  273. 	beq		2f          /* KERNEL_S1_END_\@ */

  274. 	vabs.f64   	d5,  d5

  275. 	vcmpe.f64  	d0,  d5				// compare with scale

  276. 	vmrs		APSR_nzcv, fpscr

  277. 	vdivge.f64	d2 , d5, d0			// scale >= x ?	x / scale

  278. 	vmlage.f64	d1 , d2 , d2			// ssq += ( x/scale ) * ( x/scale )

  279. 	bge		2f          /* KERNEL_S1_END_\@ */

  280. 	vdiv.f64	d2 , d0, d5			// scale / x

  281. 	vmul.f64	d2 , d2, d2			// ( scale / x ) * ( scale / x )

  282. 	vmul.f64	d3 , d1, d2			// ssq * ( scale / x ) * ( scale / x )

  283. 	vadd.f64	d1 , d3, d7			// ssq = 1 + ssq * ( scale / x ) * ( scale / x )

  284. 	vmov.f64	d0 , d5				// scale = x

  285. 

  286. 2:                                  /* KERNEL_S1_END_\@: */

  287. 

  288. 	add	X, X, INC_X

  289. 

  290. .endm

  291. 

  292. 

  293. #else

  294. 

  295. .macro KERNEL_F1

  296. 

  297. 	vldmia.f32	X!, 	{ s4 - s5 }

  298. 

  299. 	vcmpe.f32	s4, s6				// compare with 0.0

  300. 	vmrs		APSR_nzcv, fpscr

  301. 	beq		1f         /* KERNEL_F1_NEXT_\@ */

  302. 	vabs.f32   	s4,  s4

  303. 	vcmpe.f32  	s0,  s4				// compare with scale

  304. 	vmrs		APSR_nzcv, fpscr

  305. 	vdivge.f32	s2 , s4, s0			// scale >= x ?	x / scale

  306. 	vmlage.f32	s1 , s2 , s2			// ssq += ( x/scale ) * ( x/scale )

  307. 	bge		1f         /* KERNEL_F1_NEXT_\@ */

  308. 	vdiv.f32	s2 , s0, s4			// scale / x

  309. 	vmul.f32	s2 , s2, s2			// ( scale / x ) * ( scale / x )

  310. 	vmul.f32	s3 , s1, s2			// ssq * ( scale / x ) * ( scale / x )

  311. 	vadd.f32	s1 , s3, s7			// ssq = 1 + ssq * ( scale / x ) * ( scale / x )

  312. 	vmov.f32	s0 , s4				// scale = x

  313. 

  314. 1:                                 /* KERNEL_F1_NEXT_\@: */

  315. 

  316. 	vcmpe.f32	s5, s6				// compare with 0.0

  317. 	vmrs		APSR_nzcv, fpscr

  318. 	beq		2f         /* KERNEL_F1_END_\@ */

  319. 	vabs.f32   	s5,  s5

  320. 	vcmpe.f32  	s0,  s5				// compare with scale

  321. 	vmrs		APSR_nzcv, fpscr

  322. 	vdivge.f32	s2 , s5, s0			// scale >= x ?	x / scale

  323. 	vmlage.f32	s1 , s2 , s2			// ssq += ( x/scale ) * ( x/scale )

  324. 	bge		2f         /* KERNEL_F1_END_\@ */

  325. 	vdiv.f32	s2 , s0, s5			// scale / x

  326. 	vmul.f32	s2 , s2, s2			// ( scale / x ) * ( scale / x )

  327. 	vmul.f32	s3 , s1, s2			// ssq * ( scale / x ) * ( scale / x )

  328. 	vadd.f32	s1 , s3, s7			// ssq = 1 + ssq * ( scale / x ) * ( scale / x )

  329. 	vmov.f32	s0 , s5				// scale = x

  330. 

  331. 2:                                 /* KERNEL_F1_END_\@: */

  332. 

  333. 

  334. .endm

  335. 

  336. .macro KERNEL_F8

  337. 

  338. 	pld	[ X, #X_PRE ]

  339. 	KERNEL_F1

  340. 	KERNEL_F1

  341. 	KERNEL_F1

  342. 	KERNEL_F1

  343. 	pld	[ X, #X_PRE ]

  344. 	KERNEL_F1

  345. 	KERNEL_F1

  346. 	KERNEL_F1

  347. 	KERNEL_F1

  348. 

  349. .endm

  350. 

  351. .macro KERNEL_S1

  352. 

  353. 	vldmia.f32	X, 	{ s4 - s5 }

  354. 

  355. 	vcmpe.f32	s4, s6				// compare with 0.0

  356. 	vmrs		APSR_nzcv, fpscr

  357. 	beq		1f          /* KERNEL_S1_NEXT_\@ */

  358. 	vabs.f32   	s4,  s4

  359. 	vcmpe.f32  	s0,  s4				// compare with scale

  360. 	vmrs		APSR_nzcv, fpscr

  361. 	vdivge.f32	s2 , s4, s0			// scale >= x ?	x / scale

  362. 	vmlage.f32	s1 , s2 , s2			// ssq += ( x/scale ) * ( x/scale )

  363. 	bge		1f          /* KERNEL_S1_NEXT_\@ */

  364. 	vdiv.f32	s2 , s0, s4			// scale / x

  365. 	vmul.f32	s2 , s2, s2			// ( scale / x ) * ( scale / x )

  366. 	vmul.f32	s3 , s1, s2			// ssq * ( scale / x ) * ( scale / x )

  367. 	vadd.f32	s1 , s3, s7			// ssq = 1 + ssq * ( scale / x ) * ( scale / x )

  368. 	vmov.f32	s0 , s4				// scale = x

  369. 

  370. 1:                                  /* KERNEL_S1_NEXT_\@: */

  371. 

  372. 	vcmpe.f32	s5, s6				// compare with 0.0

  373. 	vmrs		APSR_nzcv, fpscr

  374. 	beq		2f          /* KERNEL_S1_END_\@ */

  375. 	vabs.f32   	s5,  s5

  376. 	vcmpe.f32  	s0,  s5				// compare with scale

  377. 	vmrs		APSR_nzcv, fpscr

  378. 	vdivge.f32	s2 , s5, s0			// scale >= x ?	x / scale

  379. 	vmlage.f32	s1 , s2 , s2			// ssq += ( x/scale ) * ( x/scale )

  380. 	bge		2f          /* KERNEL_S1_END_\@ */

  381. 	vdiv.f32	s2 , s0, s5			// scale / x

  382. 	vmul.f32	s2 , s2, s2			// ( scale / x ) * ( scale / x )

  383. 	vmul.f32	s3 , s1, s2			// ssq * ( scale / x ) * ( scale / x )

  384. 	vadd.f32	s1 , s3, s7			// ssq = 1 + ssq * ( scale / x ) * ( scale / x )

  385. 	vmov.f32	s0 , s5				// scale = x

  386. 

  387. 2:                                  /* KERNEL_S1_END_\@: */

  388. 

  389. 	add	X, X, INC_X

  390. 

  391. .endm

  392. 

  393. 

  394. 

  395. #endif

  396. 

  397. #endif

  398. 

  399. /**************************************************************************************

  400. * End of macro definitions

  401. **************************************************************************************/

  402. 

  403. 	PROLOGUE

  404. 

  405. 	.align 5

  406. 

  407. #if defined(DOUBLE)

  408. 	movs			r12 , #0

  409. 	vmov.f32		s0 , r12		// scale=0.0

  410. 	vcvt.f64.f32    d0, s0

  411. 	vmov.f64		d1 , #1.0		// ssq=1.0

  412. 	vmov.f64		d7 , d1			// value 1.0

  413. 	vmov.f64		d6 , d0			// value 0.0

  414. #else

  415. 	movs			r12 , #0

  416. 	vmov.f32		s0 , r12		// scale=0.0

  417. 	vmov.f32		s1 , #1.0		// ssq=1.0

  418. 	vmov.f32		s7 , s1			// value 1.0

  419. 	vmov.f32		s6 , s0			// value 0.0

  420. #endif

  421. 

  422. 

  423. 

  424. 	cmp	N, #0

  425. 	ble	nrm2_kernel_L999

  426. 

  427. 	cmp	INC_X, #0

  428. 	beq	nrm2_kernel_L999

  429. 

  430. 

  431. 	cmp	INC_X, #1

  432. 	bne	nrm2_kernel_S_BEGIN

  433. 

  434. 

  435. nrm2_kernel_F_BEGIN:

  436. 

  437. 	asrs	I, N, #3				// I = N / 8

  438. 	ble	nrm2_kernel_F1

  439. 

  440. nrm2_kernel_F8:

  441. 

  442. 	KERNEL_F8

  443. 

  444. 	subs    I, I, #1

  445.         bne     nrm2_kernel_F8

  446. 

  447. nrm2_kernel_F1:

  448. 

  449. 	ands    I, N, #7

  450.         ble     nrm2_kernel_L999

  451. 

  452. 

  453. nrm2_kernel_F10:

  454. 

  455. 	KERNEL_F1

  456. 

  457. 	subs    I, I, #1

  458.         bne     nrm2_kernel_F10

  459. 

  460. 	b	nrm2_kernel_L999

  461. 

  462. nrm2_kernel_S_BEGIN:

  463. 

  464. #if defined(COMPLEX)

  465. 

  466. #if defined(DOUBLE)

  467. 	lsl	INC_X, INC_X, #4				// INC_X * SIZE * 2

  468. #else

  469. 	lsl	INC_X, INC_X, #3				// INC_X * SIZE * 2

  470. #endif

  471. 

  472. #else

  473. 

  474. #if defined(DOUBLE)

  475. 	lsl	INC_X, INC_X, #3				// INC_X * SIZE

  476. #else

  477. 	lsl	INC_X, INC_X, #2				// INC_X * SIZE

  478. #endif

  479. 

  480. #endif

  481. 

  482. 

  483. 

  484. nrm2_kernel_S1:

  485. 

  486. 	mov	I, N

  487. 

  488. 	.align 5

  489. 

  490. nrm2_kernel_S10:

  491. 

  492. 	KERNEL_S1

  493. 

  494. 	subs    I, I, #1

  495.         bne     nrm2_kernel_S10

  496. 

  497. 

  498. nrm2_kernel_L999:

  499. 

  500. #if defined(DOUBLE)

  501. 	vsqrt.f64	d1, d1

  502. 	vmul.f64	d0, d0, d1

  503. #else

  504. 	vsqrt.f32	s1, s1

  505. 	vmul.f32	s0, s0, s1

  506. #endif

  507. 

  508. #if !defined(__ARM_PCS_VFP)

  509. #if defined(DOUBLE)

  510. 	vmov	r0, r1, d0

  511. #else

  512. 	vmov	r0, s0

  513. #endif

  514. #endif

  515. 

  516. 	bx	lr

  517. 

  518. 	EPILOGUE