Line data Source code
1 : /*****************************************************************************
2 : *
3 : * Enhanced 64 bit operators :
4 : *
5 : * W_mac_32_16()
6 : * W_mac0_16_16()
7 : * W_msu0_16_16()
8 : *
9 : *****************************************************************************/
10 :
11 :
12 : /*****************************************************************************
13 : *
14 : * Include-Files
15 : *
16 : *****************************************************************************/
17 : #include <stdio.h>
18 : #include <stdlib.h>
19 : #include "stl.h"
20 :
21 : #define WMC_TOOL_SKIP
22 :
23 : /*****************************************************************************
24 : *
25 : * Local Functions
26 : *
27 : *****************************************************************************/
28 :
29 : /*****************************************************************************
30 : *
31 : * Constants and Globals
32 : *
33 : *****************************************************************************/
34 :
35 :
36 : /*****************************************************************************
37 : *
38 : * Functions
39 : *
40 : *****************************************************************************/
41 :
42 : #ifdef ENH_64_BIT_OPERATOR
43 :
44 :
45 : /*___________________________________________________________________________
46 : | |
47 : | Function Name : W_add_nosat |
48 : | |
49 : | Purpose : |
50 : | |
51 : | 64 bits addition of the two 64 bits variables (L64_var1+L64_var2) |
52 : | |
53 : | Complexity weight : 1 |
54 : | |
55 : | Inputs : |
56 : | |
57 : | L64_var1 64 bit long signed integer (Word64) whose value falls in the |
58 : | range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
59 : | |
60 : | L64_var2 64 bit long signed integer (Word64) whose value falls in the |
61 : | range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
62 : | |
63 : | Outputs : |
64 : | |
65 : | none |
66 : | |
67 : | Return Value : |
68 : | |
69 : | L64_var_out |
70 : | 64 bit long signed integer (Word64) whose value falls in the |
71 : | range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
72 : |___________________________________________________________________________|
73 : */
74 5308758 : Word64 W_add_nosat( Word64 L64_var1, Word64 L64_var2 )
75 : {
76 : Word64 L64_var_out;
77 :
78 5308758 : L64_var_out = L64_var1 + L64_var2;
79 :
80 : #ifdef WMOPS
81 : multiCounter[currCounter].W_add_nosat++;
82 : #endif
83 :
84 5308758 : return L64_var_out;
85 : }
86 :
87 :
88 : /*___________________________________________________________________________
89 : | |
90 : | Function Name : W_sub_nosat |
91 : | |
92 : | Purpose : |
93 : | |
94 : | 64 bits subtraction of the two 64 bits variables (L64_var1-L64_var2) |
95 : | |
96 : | Complexity weight : 1 |
97 : | |
98 : | Inputs : |
99 : | |
100 : | L64_var1 64 bit long signed integer (Word64) whose value falls in the |
101 : | range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
102 : | |
103 : | L64_var2 64 bit long signed integer (Word64) whose value falls in the |
104 : | range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
105 : | |
106 : | Outputs : |
107 : | |
108 : | none |
109 : | |
110 : | Return Value : |
111 : | |
112 : | L64_var_out |
113 : | 64 bit long signed integer (Word64) whose value falls in the |
114 : | range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
115 : |___________________________________________________________________________|
116 : */
117 1045670 : Word64 W_sub_nosat( Word64 L64_var1, Word64 L64_var2 )
118 : {
119 : Word64 L64_var_out;
120 :
121 1045670 : L64_var_out = L64_var1 - L64_var2;
122 :
123 : #ifdef WMOPS
124 : multiCounter[currCounter].W_sub_nosat++;
125 : #endif
126 :
127 1045670 : return L64_var_out;
128 : }
129 :
130 :
131 : /*___________________________________________________________________________
132 : | |
133 : | Function Name : W_shl |
134 : | |
135 : | Purpose : |
136 : | |
137 : | Arithmetically shift the 64 bit input L64_var1 left var2 positions. Zero|
138 : | fill the var2 LSB of the result. If var2 is negative, arithmetically |
139 : | shift L64_var1 right by -var2 with sign extension. Saturate the result |
140 : | in case of underflows or overflows. |
141 : | |
142 : | Complexity weight : 1 |
143 : | |
144 : | Inputs : |
145 : | |
146 : | L64_var1 64 bit long signed integer (Word64) whose value falls in the|
147 : | range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
148 : | |
149 : | var2 |
150 : | 16 bit short signed integer (Word16) whose value falls in the |
151 : | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
152 : | |
153 : | Outputs : |
154 : | |
155 : | none |
156 : | |
157 : | Return Value : |
158 : | |
159 : | L64_var_out |
160 : | 64 bit long signed integer (Word64) whose value falls in the |
161 : | range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
162 : |___________________________________________________________________________|
163 : */
164 >22796*10^7 : Word64 W_shl_o( Word64 L64_var1, Word16 var2, Flag *Overflow )
165 : {
166 :
167 >22796*10^7 : Word64 L64_var_out = 0LL;
168 :
169 >22796*10^7 : if ( var2 <= 0 )
170 : {
171 2356387450 : if ( var2 < -64 )
172 2276 : var2 = -64;
173 2356387450 : var2 = -var2;
174 2356387450 : L64_var_out = L64_var1 >> var2;
175 : }
176 : else
177 : {
178 >79202*10^7 : for ( ; var2 > 0; var2-- )
179 : {
180 >56641*10^7 : if ( L64_var1 > (Word64) 0X3fffffffffffffffLL )
181 : {
182 547855 : set_overflow( Overflow );
183 547855 : L64_var_out = (Word64) 0X7fffffffffffffffLL;
184 547855 : break;
185 : }
186 : else
187 : {
188 >56641*10^7 : if ( L64_var1 < (Word64) 0xc000000000000000LL )
189 : {
190 3 : set_overflow( Overflow );
191 3 : L64_var_out = (Word64) 0x8000000000000000LL;
192 3 : break;
193 : }
194 : }
195 >56641*10^7 : L64_var1 *= 2;
196 >56641*10^7 : L64_var_out = L64_var1;
197 : }
198 : }
199 : #ifdef WMOPS
200 : multiCounter[currCounter].W_shl++;
201 : #endif
202 :
203 : /* BASOP_CHECK();*/
204 :
205 >22796*10^7 : return ( L64_var_out );
206 : }
207 :
208 27511294087 : Word64 W_shl( Word64 L64_var1, Word16 var2 )
209 : {
210 27511294087 : return W_shl_o( L64_var1, var2, NULL );
211 : }
212 :
213 :
214 : /*___________________________________________________________________________
215 : | |
216 : | Function Name : W_shr |
217 : | |
218 : | Purpose : |
219 : | |
220 : | Arithmetically shift the 64 bit input L64_var1 right var2 positions. |
221 : | Zero fill the var2 LSB of the result. If var2 is negative, |
222 : | arithmetically shift L64_var1 left by -var2 with sign extension. |
223 : | Saturate the result in case of underflows or overflows. |
224 : | |
225 : | Complexity weight : 1 |
226 : | |
227 : | Inputs : |
228 : | |
229 : | L64_var1 64 bit long signed integer (Word64) whose value falls in the|
230 : | range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
231 : | |
232 : | var2 |
233 : | 16 bit short signed integer (Word16) whose value falls in the |
234 : | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
235 : | |
236 : | Outputs : |
237 : | |
238 : | none |
239 : | |
240 : | Return Value : |
241 : | |
242 : | L64_var_out |
243 : | 64 bit long signed integer (Word64) whose value falls in the |
244 : | range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
245 : |___________________________________________________________________________|
246 : */
247 11223935199 : Word64 W_shr( Word64 L64_var1, Word16 var2 )
248 : {
249 : Word64 L64_var_out;
250 :
251 11223935199 : if ( var2 < 0 )
252 : {
253 47703364 : var2 = -var2;
254 47703364 : L64_var_out = W_shl( L64_var1, var2 );
255 :
256 : #ifdef WMOPS
257 : multiCounter[currCounter].W_shl--;
258 : #endif /* if WMOPS */
259 : }
260 : else
261 : {
262 11176231835 : L64_var_out = L64_var1 >> var2;
263 : }
264 :
265 : #ifdef WMOPS
266 : multiCounter[currCounter].W_shr++;
267 : #endif /* if WMOPS */
268 :
269 11223935199 : return ( L64_var_out );
270 : }
271 :
272 :
273 : /*___________________________________________________________________________
274 : | |
275 : | Function Name : W_shl_nosat |
276 : | |
277 : | Purpose : |
278 : | |
279 : | Arithmetically shifts left the 64-bit variable W_var1 by var2 positions. |
280 : | if var2 is negative, W_var1 is shifted to the least significant bits by |
281 : | (�var2) positions with extension of the sign bit . |
282 : | if var2 is positive, W_var1 is shifted to the most significant bits by |
283 : | (var2) positions without saturation control on 64 bits. |
284 : | |
285 : | Complexity weight : 1 |
286 : | |
287 : | Inputs : |
288 : | |
289 : | L64_var1 64 bit long signed integer (Word64) whose value falls in the|
290 : | range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
291 : | |
292 : | var2 |
293 : | 16 bit short signed integer (Word16) whose value falls in the |
294 : | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
295 : | |
296 : | Outputs : |
297 : | |
298 : | none |
299 : | |
300 : | Return Value : |
301 : | |
302 : | L64_var_out |
303 : | 64 bit long signed integer (Word64) whose value falls in the |
304 : | range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
305 : |___________________________________________________________________________|
306 : */
307 0 : Word64 W_shl_nosat( Word64 L64_var1, Word16 var2 )
308 : {
309 :
310 0 : Word64 L64_var_out = 0LL;
311 :
312 0 : if ( var2 <= 0 )
313 : {
314 0 : var2 = -var2;
315 0 : L64_var_out = L64_var1 >> var2;
316 : }
317 : else
318 : {
319 0 : L64_var_out = L64_var1 << var2;
320 : }
321 : #ifdef WMOPS
322 : multiCounter[currCounter].W_shl_nosat++;
323 : #endif
324 :
325 : /* BASOP_CHECK();*/
326 :
327 0 : return ( L64_var_out );
328 : }
329 :
330 :
331 : /*___________________________________________________________________________
332 : | |
333 : | Function Name : W_shr_nosat |
334 : | |
335 : | Purpose : |
336 : | |
337 : | Arithmetically shifts right the 64-bit variable W_var1 by var2 positions. |
338 : | if var2 is negative, W_var1 is shifted to the most significant bits by |
339 : | (�var2) positions without saturation control on 64 bits. |
340 : | if var2 is positive, W_var1 is shifted to the least significant bits by |
341 : | (var2) positions with extension of the sign bit . |
342 : | |
343 : | Complexity weight : 1 |
344 : | |
345 : | Inputs : |
346 : | |
347 : | L64_var1 64 bit long signed integer (Word64) whose value falls in the|
348 : | range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
349 : | |
350 : | var2 |
351 : | 16 bit short signed integer (Word16) whose value falls in the |
352 : | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
353 : | |
354 : | Outputs : |
355 : | |
356 : | none |
357 : | |
358 : | Return Value : |
359 : | |
360 : | L64_var_out |
361 : | 64 bit long signed integer (Word64) whose value falls in the |
362 : | range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
363 : |___________________________________________________________________________|
364 : */
365 0 : Word64 W_shr_nosat( Word64 L64_var1, Word16 var2 )
366 : {
367 : Word64 L64_var_out;
368 :
369 0 : if ( var2 < 0 )
370 : {
371 0 : var2 = -var2;
372 0 : L64_var_out = L64_var1 << var2;
373 : }
374 : else
375 : {
376 0 : L64_var_out = L64_var1 >> var2;
377 : }
378 :
379 : #ifdef WMOPS
380 : multiCounter[currCounter].W_shr_nosat++;
381 : #endif /* if WMOPS */
382 :
383 0 : return ( L64_var_out );
384 : }
385 :
386 :
387 : /*_________________________________________________________________________________________________
388 : | |
389 : | Function Name : W_mac_32_16 |
390 : | |
391 : | Purpose : |
392 : | |
393 : | Multiply L_var2 by var3 and shift the result left by 1. Add the 64 bit |
394 : | result to L64_var1, return a 64 bit result. |
395 : | |
396 : | Complexity weight : 1 |
397 : | |
398 : | Inputs : |
399 : | |
400 : | L64_var1 |
401 : | 64 bit long long signed integer (Word64) whose value falls in the |
402 : | range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
403 : | |
404 : | L_var2 |
405 : | 32 bit signed integer (Word32) whose value falls in the |
406 : | range : 0x8000 0000 <= L_var2 <= 0x7fff ffff |
407 : | |
408 : | var3 |
409 : | 16 bit short signed integer (Word16) whose value falls in the |
410 : | range : 0xffff 8000 <= var3 <= 0x0000 7fff. |
411 : | |
412 : | Outputs : |
413 : | |
414 : | none |
415 : | |
416 : | Return Value : |
417 : | |
418 : | L64_var_out |
419 : | 64 bit long long signed integer (Word64) whose value falls in the |
420 : | range : 0x80000000 00000000LL <= L64_var_out <= 0x7fffffff ffffffffLL. |
421 : |_________________________________________________________________________________________________|
422 : */
423 702405347 : Word64 W_mac_32_16( Word64 L64_var1, Word32 L_var2, Word16 var3 )
424 : {
425 702405347 : Word64 L64_var_out = ( (Word64) L_var2 * var3 ) << 1;
426 702405347 : L64_var_out += L64_var1;
427 : #ifdef WMOPS
428 : multiCounter[currCounter].W_mac_32_16++;
429 : #endif /* if WMOPS */
430 702405347 : return L64_var_out;
431 : }
432 :
433 :
434 : /*_________________________________________________________________________________________________
435 : | |
436 : | Function Name : W_msu_32_16 |
437 : | |
438 : | Purpose : |
439 : | |
440 : | Multiply L_var2 by var3 and shift the result left by 1. Subtract the 64 bit |
441 : | result from L64_var1, return a 64 bit result. |
442 : | |
443 : | Complexity weight : 1 |
444 : | |
445 : | Inputs : |
446 : | |
447 : | L64_var1 |
448 : | 64 bit long long signed integer (Word64) whose value falls in the |
449 : | range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
450 : | |
451 : | L_var2 |
452 : | 32 bit signed integer (Word32) whose value falls in the |
453 : | range : 0x8000 0000 <= L_var2 <= 0x7fff ffff |
454 : | |
455 : | var3 |
456 : | 16 bit short signed integer (Word16) whose value falls in the |
457 : | range : 0xffff 8000 <= var3 <= 0x0000 7fff. |
458 : | |
459 : | Outputs : |
460 : | |
461 : | none |
462 : | |
463 : | Return Value : |
464 : | |
465 : | L64_var_out |
466 : | 64 bit long long signed integer (Word64) whose value falls in the |
467 : | range : 0x80000000 00000000LL <= L64_var_out <= 0x7fffffff ffffffffLL. |
468 : |_________________________________________________________________________________________________|
469 : */
470 480600910 : Word64 W_msu_32_16( Word64 L64_var1, Word32 L_var2, Word16 var3 )
471 : {
472 480600910 : Word64 L64_var_out = ( (Word64) L_var2 * var3 ) << 1;
473 480600910 : L64_var_out = L64_var1 - L64_var_out;
474 : #ifdef WMOPS
475 : multiCounter[currCounter].W_msu_32_16++;
476 : #endif /* if WMOPS */
477 480600910 : return L64_var_out;
478 : }
479 :
480 :
481 : /*_________________________________________________________________________________________________
482 : | |
483 : | Function Name : W_mult_32_16 |
484 : | |
485 : | Purpose : |
486 : | |
487 : | Multiply L_var1 by var2 and shift the result left by 1. Return a 64 bit result. |
488 : | |
489 : | Complexity weight : 1 |
490 : | |
491 : | Inputs : |
492 : | |
493 : | L_var1 |
494 : | 32 bit signed integer (Word32) whose value falls in the |
495 : | range : 0x8000 0000 <= L_var1 <= 0x7fff ffff |
496 : | |
497 : | var2 |
498 : | 16 bit short signed integer (Word16) whose value falls in the |
499 : | range : 0xffff 8000 <= var2 <= 0x0000 7fff. |
500 : | |
501 : | Outputs : |
502 : | |
503 : | none |
504 : | |
505 : | Return Value : |
506 : | |
507 : | L64_var_out |
508 : | 64 bit long long signed integer (Word64) whose value falls in the |
509 : | range : 0x80000000 00000000LL <= L64_var_out <= 0x7fffffff ffffffffLL. |
510 : |_________________________________________________________________________________________________|
511 : */
512 77662279516 : Word64 W_mult_32_16( Word32 L_var1, Word16 var2 )
513 : {
514 77662279516 : Word64 L64_var_out = ( (Word64) L_var1 * var2 ) << 1;
515 : #ifdef WMOPS
516 : multiCounter[currCounter].W_mult_32_16++;
517 : #endif /* if WMOPS */
518 77662279516 : return L64_var_out;
519 : }
520 :
521 : /*________________________________________________________________________________________________
522 : | |
523 : | Function Name : W_mult0_16_16 |
524 : | |
525 : | Purpose : |
526 : | |
527 : | Multiply var1 by var2 and return a 64 bit result. |
528 : | |
529 : | Complexity weight : 1 |
530 : | |
531 : | Inputs : |
532 : | |
533 : | var1 |
534 : | 16 bit short signed integer (Word16) whose value falls in the |
535 : | range : 0x8000 0000 <= L_var1 <= 0x7fff ffff |
536 : | |
537 : | var2 |
538 : | 16 bit short signed integer (Word16) whose value falls in the |
539 : | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
540 : | |
541 : | Outputs : |
542 : | |
543 : | none |
544 : | |
545 : | Return Value : |
546 : | |
547 : | L64_var_out |
548 : | 64 bit long long signed integer (Word64) whose value falls in the |
549 : | range : 0x80000000 00000000LL <= L64_acc <= 0x7fffffff ffffffffLL. |
550 : |_________________________________________________________________________________________________|
551 : */
552 3050 : Word64 W_mult0_16_16( Word16 var1, Word16 var2 )
553 : {
554 3050 : Word64 L64_var_out = (Word64) var1 * var2;
555 : #ifdef WMOPS
556 : multiCounter[currCounter].W_mult0_16_16++;
557 : #endif /* if WMOPS */
558 3050 : return L64_var_out;
559 : }
560 :
561 : /*________________________________________________________________________________________________
562 : | |
563 : | Function Name : W_mac0_16_16 |
564 : | |
565 : | Purpose : |
566 : | |
567 : | Multiply var2 by var3 and add the 64 bit result to L64_var1, return a 64 bit result. |
568 : | |
569 : | Complexity weight : 1 |
570 : | |
571 : | Inputs : |
572 : | |
573 : | L64_var1 |
574 : | 64 bit long long signed integer (Word64) whose value falls in the |
575 : | range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
576 : | |
577 : | var2 |
578 : | 16 bit short signed integer (Word16) whose value falls in the |
579 : | range : 0xffff 8000 <= var2 <= 0x0000 7fff. |
580 : | |
581 : | var3 |
582 : | 16 bit short signed integer (Word16) whose value falls in the |
583 : | range : 0xffff 8000 <= var3 <= 0x0000 7fff. |
584 : | |
585 : | Outputs : |
586 : | |
587 : | none |
588 : | |
589 : | Return Value : |
590 : | |
591 : | L64_var_out |
592 : | 64 bit long long signed integer (Word64) whose value falls in the |
593 : | range : 0x80000000 00000000LL <= L64_var_out <= 0x7fffffff ffffffffLL. |
594 : |_________________________________________________________________________________________________|
595 : */
596 2345189841 : Word64 W_mac0_16_16( Word64 L64_var1, Word16 var2, Word16 var3 )
597 : {
598 2345189841 : Word64 L64_var_out = (Word64) var2 * var3;
599 2345189841 : L64_var_out += L64_var1;
600 : #ifdef WMOPS
601 : multiCounter[currCounter].W_mac0_16_16++;
602 : #endif /* if WMOPS */
603 2345189841 : return L64_var_out;
604 : }
605 :
606 :
607 : /*________________________________________________________________________________________________
608 : | |
609 : | Function Name : W_msu0_16_16 |
610 : | |
611 : | Purpose : |
612 : | |
613 : | Multiply var2 by var3 and subtract the 64 bit result from L64_var1, return a 64 bit result. |
614 : | |
615 : | Complexity weight : 1 |
616 : | |
617 : | Inputs : |
618 : | |
619 : | L64_var1 |
620 : | 64 bit long long signed integer (Word64) whose value falls in the |
621 : | range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
622 : | |
623 : | var2 |
624 : | 16 bit short signed integer (Word16) whose value falls in the |
625 : | range : 0xffff 8000 <= var2 <= 0x0000 7fff. |
626 : | |
627 : | var3 |
628 : | 16 bit short signed integer (Word16) whose value falls in the |
629 : | range : 0xffff 8000 <= var3 <= 0x0000 7fff. |
630 : | |
631 : | Outputs : |
632 : | |
633 : | none |
634 : | |
635 : | Return Value : |
636 : | |
637 : | L64_var_out |
638 : | 64 bit long long signed integer (Word64) whose value falls in the |
639 : | range : 0x80000000 00000000LL <= L64_var_out <= 0x7fffffff ffffffffLL. |
640 : |_________________________________________________________________________________________________|
641 : */
642 0 : Word64 W_msu0_16_16( Word64 L64_var1, Word16 var2, Word16 var3 )
643 : {
644 0 : Word64 L64_var_out = (Word64) var2 * var3;
645 0 : L64_var_out = L64_var1 - L64_var_out;
646 : #ifdef WMOPS
647 : multiCounter[currCounter].W_msu0_16_16++;
648 : #endif /* if WMOPS */
649 0 : return L64_var_out;
650 : }
651 :
652 :
653 : /*_____________________________________________________________________________________
654 : | |
655 : | Function Name : W_sat_l |
656 : | |
657 : | Purpose : |
658 : | |
659 : | Saturate the lower 32 bits of the 64 bit input number L64_var into 32 bits. |
660 : | |
661 : | Complexity weight : 1 |
662 : | |
663 : | Inputs : |
664 : | |
665 : | L64_var |
666 : | 64 bit long long signed integer (Word64) whose value falls in the |
667 : | range : 0x80000000 00000000LL <= L64_var <= 0x7fffffff ffffffffLL. |
668 : | |
669 : | Outputs : |
670 : | |
671 : | none |
672 : | |
673 : | Return Value : |
674 : | |
675 : | L_var_out |
676 : | 32 bit signed integer (Word32) whose value falls in the |
677 : | range : 0x8000 0000 <= L_var_out <= 0x7fff 0000. |
678 : |_____________________________________________________________________________________|
679 : */
680 64287605222 : Word32 W_sat_l( Word64 L64_var )
681 : {
682 : Word32 L_var_out;
683 :
684 64287605222 : if ( L64_var > 0x7FFFFFFF )
685 : {
686 3514864 : L_var_out = 0x7FFFFFFF;
687 : }
688 64284090358 : else if ( L64_var < (int) 0x80000000 )
689 : {
690 88979 : L_var_out = (Word32) 0x80000000;
691 : }
692 : else
693 : {
694 64284001379 : L_var_out = (Word32) L64_var;
695 : }
696 :
697 : #ifdef WMOPS
698 : multiCounter[currCounter].W_sat_l++;
699 : #endif /* if WMOPS */
700 :
701 64287605222 : return L_var_out;
702 : }
703 :
704 :
705 : /*___________________________________________________________________________________
706 : | |
707 : | Function Name : W_sat_m |
708 : | |
709 : | Purpose : |
710 : | |
711 : | Truncates the lower 16 bits of the 64 bit input L64_var |
712 : | and saturates the number into 32 bits. |
713 : | |
714 : | Complexity weight : 1 |
715 : | |
716 : | Inputs : |
717 : | |
718 : | L64_var |
719 : | 64 bit long long signed integer (Word64) whose value falls in the |
720 : | range : 0x80000000 00000000LL <= L64_var <= 0x7fffffff ffffffffLL. |
721 : | |
722 : | Outputs : |
723 : | |
724 : | none |
725 : | |
726 : | Return Value : |
727 : | |
728 : | L_var_out |
729 : | 32 bit signed integer (Word32) whose value falls in the |
730 : | range : 0x8000 0000 <= L_var_out <= 0x7fff 0000. |
731 : |_____________________________________________________________________________________|
732 : */
733 58586343021 : Word32 W_sat_m( Word64 L64_var )
734 : {
735 : Word32 L_var_out;
736 :
737 58586343021 : L64_var = L64_var >> 16;
738 58586343021 : L_var_out = W_sat_l( L64_var );
739 :
740 : #ifdef WMOPS
741 : multiCounter[currCounter].W_sat_l--;
742 : multiCounter[currCounter].W_sat_m++;
743 : #endif /* if WMOPS */
744 :
745 58586343021 : return L_var_out;
746 : }
747 :
748 :
749 : /*__________________________________________________________________________________
750 : | |
751 : | Function Name : W_deposit32_l |
752 : | |
753 : | Purpose : |
754 : | |
755 : | Deposit the 32 bit L_var1 into the 32 LS bits of the 64 bit output. The |
756 : | 32 MS bits of the output are sign extended. |
757 : | |
758 : | Complexity weight : 1 |
759 : | |
760 : | Inputs : |
761 : | |
762 : | L_var1 |
763 : | 32 bit long signed integer (Word32) whose value falls in the |
764 : | range : 0x8000 0000 <= var_out <= 0x7fff 0000. | |
765 : | Outputs : |
766 : | |
767 : | none |
768 : | |
769 : | Return Value : |
770 : | |
771 : | L64_var_out |
772 : | 64 bit long long signed integer (Word64) whose value falls in |
773 : | range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
774 : |__________________________________________________________________________________|
775 : */
776 837379781 : Word64 W_deposit32_l( Word32 L_var1 )
777 : {
778 : Word64 L64_var_out;
779 :
780 837379781 : L64_var_out = (Word64) L_var1;
781 :
782 : #ifdef WMOPS
783 : multiCounter[currCounter].W_deposit32_l++;
784 : #endif
785 :
786 837379781 : return ( L64_var_out );
787 : }
788 :
789 :
790 : /*__________________________________________________________________________________
791 : | |
792 : | Function Name : W_deposit32_h |
793 : | |
794 : | Purpose : |
795 : | |
796 : | Deposit the 32 bit L_var1 into the 32 MS bits of the 64 bit output. The |
797 : | 32 LS bits of the output are zeroed. |
798 : | |
799 : | Complexity weight : 1 |
800 : | |
801 : | Inputs : |
802 : | |
803 : | L_var1 |
804 : | 32 bit long signed integer (Word32) whose value falls in the |
805 : | range : 0x8000 0000 <= var_out <= 0x7fff 0000. | |
806 : | Outputs : |
807 : | |
808 : | none |
809 : | |
810 : | Return Value : |
811 : | |
812 : | L64_var_out |
813 : | 64 bit long long signed integer (Word64) whose value falls in |
814 : | range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
815 : |__________________________________________________________________________________|
816 : */
817 0 : Word64 W_deposit32_h( Word32 L_var1 )
818 : {
819 : Word64 L64_var_out;
820 :
821 0 : L64_var_out = (Word64) L_var1 << 32;
822 :
823 : #ifdef WMOPS
824 : multiCounter[currCounter].W_deposit32_h++;
825 : #endif
826 :
827 0 : return ( L64_var_out );
828 : }
829 :
830 :
831 : /*__________________________________________________________________________________
832 : | |
833 : | Function Name : W_extract_l |
834 : | |
835 : | Purpose : |
836 : | |
837 : | Return the 32 LSB of L64_var1. |
838 : | |
839 : | Complexity weight : 1 |
840 : | |
841 : | Inputs : |
842 : | |
843 : | L64_var1 |
844 : | 64 bit long long signed integer (Word64) whose value falls in |
845 : | range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
846 : | |
847 : | Outputs : |
848 : | |
849 : | none |
850 : | |
851 : | Return Value : |
852 : | |
853 : | L_var_out |
854 : | 32 bit long signed integer (Word32) whose value falls in the |
855 : | range : 0x8000 0000 <= L_var_out <= 0x7fff 0000. |
856 : |__________________________________________________________________________________|
857 : */
858 2221073998 : Word32 W_extract_l( Word64 L64_var1 )
859 : {
860 : Word32 L_var_out;
861 :
862 2221073998 : L_var_out = (Word32) L64_var1;
863 :
864 : #ifdef WMOPS
865 : multiCounter[currCounter].W_extract_l++;
866 : #endif /* if WMOPS */
867 :
868 2221073998 : return ( L_var_out );
869 : }
870 :
871 :
872 : /*__________________________________________________________________________________
873 : | |
874 : | Function Name : W_extract_h |
875 : | |
876 : | Purpose : |
877 : | |
878 : | Return the 32 MSB of L64_var1. |
879 : | |
880 : | Complexity weight : 1 |
881 : | |
882 : | Inputs : |
883 : | |
884 : | L64_var1 |
885 : | 64 bit long long signed integer (Word64) whose value falls in |
886 : | range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
887 : | |
888 : | Outputs : |
889 : | |
890 : | none |
891 : | |
892 : | Return Value : |
893 : | |
894 : | L_var_out |
895 : | 32 bit long signed integer (Word32) whose value falls in the |
896 : | range : 0x8000 0000 <= L_var_out <= 0x7fff 0000. |
897 : |__________________________________________________________________________________|
898 : */
899 >22277*10^7 : Word32 W_extract_h( Word64 L64_var1 )
900 : {
901 : Word32 L_var_out;
902 :
903 >22277*10^7 : L_var_out = (Word32) ( L64_var1 >> 32 );
904 :
905 : #ifdef WMOPS
906 : multiCounter[currCounter].W_extract_h++;
907 : #endif /* if WMOPS */
908 :
909 >22277*10^7 : return ( L_var_out );
910 : }
911 :
912 :
913 : /*________________________________________________________________________________________________
914 : | |
915 : | Function Name : W_mult_16_16 |
916 : | |
917 : | Purpose : |
918 : | |
919 : | Multiply var1 by var2 and shift the result left by 1. Return a 64 bit result. |
920 : | |
921 : | Complexity weight : 1 |
922 : | |
923 : | Inputs : |
924 : | |
925 : | var1 |
926 : | 16 bit short signed integer (Word16) whose value falls in the |
927 : | range : 0x8000 0000 <= L_var1 <= 0x7fff ffff |
928 : | |
929 : | var2 |
930 : | 16 bit short signed integer (Word16) whose value falls in the |
931 : | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
932 : | |
933 : | Outputs : |
934 : | |
935 : | none |
936 : | |
937 : | Return Value : |
938 : | |
939 : | L64_var_out |
940 : | 64 bit long long signed integer (Word64) whose value falls in the |
941 : | range : 0x80000000 00000000LL <= L64_acc <= 0x7fffffff ffffffffLL. |
942 : |_________________________________________________________________________________________________|
943 : */
944 0 : Word64 W_mult_16_16( Word16 var1, Word16 var2 )
945 : {
946 0 : Word64 L64_var_out = ( (Word64) var1 * var2 ) << 1;
947 : #ifdef WMOPS
948 : multiCounter[currCounter].W_mult_16_16++;
949 : #endif /* if WMOPS */
950 0 : return L64_var_out;
951 : }
952 : /*________________________________________________________________________________________________
953 : | |
954 : | Function Name : W_mac_16_16 |
955 : | |
956 : | Purpose : |
957 : | |
958 : | Multiply var1 by var2 and shift the result left by 1 and add the 64 bit result to L64_acc, |
959 : | return a 64 bit result. |
960 : | |
961 : | Complexity weight : 1 |
962 : | |
963 : | Inputs : |
964 : | |
965 : | L64_acc |
966 : | 64 bit long long signed integer (Word64) whose value falls in the |
967 : | range : 0x80000000 00000000LL <= L64_acc <= 0x7fffffff ffffffffLL. |
968 : | |
969 : | var1 |
970 : | 16 bit short signed integer (Word16) whose value falls in the |
971 : | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
972 : | |
973 : | var2 |
974 : | 16 bit short signed integer (Word16) whose value falls in the |
975 : | range : 0xffff 8000 <= var2 <= 0x0000 7fff. |
976 : | |
977 : | Outputs : |
978 : | |
979 : | none |
980 : | |
981 : | Return Value : |
982 : | |
983 : | L64_var_out |
984 : | 64 bit long long signed integer (Word64) whose value falls in the |
985 : | range : 0x80000000 00000000LL <= L64_var_out <= 0x7fffffff ffffffffLL. |
986 : |_________________________________________________________________________________________________|
987 : */
988 1896819777 : Word64 W_mac_16_16( Word64 L64_acc, Word16 var1, Word16 var2 )
989 : {
990 1896819777 : Word64 L64_var_out = ( (Word64) var1 * var2 ) << 1;
991 1896819777 : L64_acc = L64_acc + L64_var_out;
992 :
993 : #ifdef WMOPS
994 : multiCounter[currCounter].W_mac_16_16++;
995 : #endif /* if WMOPS */
996 1896819777 : return L64_acc;
997 : }
998 :
999 :
1000 : /*________________________________________________________________________________________________
1001 : | |
1002 : | Function Name : W_msu_16_16 |
1003 : | |
1004 : | Purpose : |
1005 : | |
1006 : | Multiply var2 by var3 and shift the result left by1 and subtract the 64 bit result |
1007 : | from L64_var1, return a 64 bit result. |
1008 : | |
1009 : | Complexity weight : 1 |
1010 : | |
1011 : | Inputs : |
1012 : | |
1013 : | L64_var1 |
1014 : | 64 bit long long signed integer (Word64) whose value falls in the |
1015 : | range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
1016 : | |
1017 : | var2 |
1018 : | 16 bit short signed integer (Word16) whose value falls in the |
1019 : | range : 0xffff 8000 <= var2 <= 0x0000 7fff. |
1020 : | |
1021 : | var3 |
1022 : | 16 bit short signed integer (Word16) whose value falls in the |
1023 : | range : 0xffff 8000 <= var3 <= 0x0000 7fff. |
1024 : | |
1025 : | Outputs : |
1026 : | |
1027 : | none |
1028 : | |
1029 : | Return Value : |
1030 : | |
1031 : | L64_var_out |
1032 : | 64 bit long long signed integer (Word64) whose value falls in the |
1033 : | range : 0x80000000 00000000LL <= L64_var_out <= 0x7fffffff ffffffffLL. |
1034 : |_________________________________________________________________________________________________|
1035 : */
1036 0 : Word64 W_msu_16_16( Word64 L64_var1, Word16 var2, Word16 var3 )
1037 : {
1038 0 : Word64 L64_var_out = ( (Word64) var2 * var3 ) << 1;
1039 0 : L64_var_out = L64_var1 - L64_var_out;
1040 : #ifdef WMOPS
1041 : multiCounter[currCounter].W_msu_16_16++;
1042 : #endif /* if WMOPS */
1043 0 : return L64_var_out;
1044 : }
1045 :
1046 : /* Below BASOP is not part of STL 2023 library, might be proposed in next update */
1047 : /*________________________________________________________________________________________________
1048 : | |
1049 : | Function Name : W_mac_32_32 |
1050 : | |
1051 : | Purpose : |
1052 : | |
1053 : | Multiply var1 by var2 and shift the result left by 1 and add the 64 bit result to L64_acc, |
1054 : | return a 64 bit result. |
1055 : | |
1056 : | Complexity weight : 1 |
1057 : | |
1058 : | Inputs : |
1059 : | |
1060 : | L64_acc |
1061 : | 64 bit long long signed integer (Word64) whose value falls in the |
1062 : | range : 0x80000000 00000000LL <= L64_acc <= 0x7fffffff ffffffffLL. |
1063 : | |
1064 : | var1 |
1065 : | 32 bit signed integer (Word32) whose value falls in the |
1066 : | range : 0x8000 0000 <= var1 <= 0x7fff 0000. |
1067 : | |
1068 : | var2 |
1069 : | 32 bit signed integer (Word32) whose value falls in the |
1070 : | range : 0x8000 0000 <= var2 <= 0x7fff 0000. |
1071 : | |
1072 : | Outputs : |
1073 : | |
1074 : | none |
1075 : | |
1076 : | Return Value : |
1077 : | |
1078 : | L64_var_out |
1079 : | 64 bit long long signed integer (Word64) whose value falls in the |
1080 : | range : 0x80000000 00000000LL <= L64_var_out <= 0x7fffffff ffffffffLL. |
1081 : |_________________________________________________________________________________________________|
1082 : */
1083 >12531*10^7 : Word64 W_mac_32_32( Word64 L64_var1, Word32 L_var2, Word32 L_var3 )
1084 : {
1085 >12531*10^7 : Word64 L64_var_out = W_mult_32_32( L_var2, L_var3 );
1086 >12531*10^7 : L64_var_out = W_add( L64_var1, L64_var_out );
1087 :
1088 : #ifdef WMOPS
1089 : multiCounter[currCounter].W_mult_32_32--;
1090 : /* multiCounter[currCounter].W_add--; */
1091 : #endif
1092 :
1093 >12531*10^7 : return L64_var_out;
1094 : }
1095 :
1096 :
1097 : /*___________________________________________________________________________
1098 : | |
1099 : | Function Name : W_shl_sat_l |
1100 : | |
1101 : | Purpose : |
1102 : | |
1103 : | Arithmetically shift the 64 bit input L64_var left by n positions with |
1104 : | lower 32 bit saturation and return the 32 LSB of 64 bit result |
1105 : | |
1106 : | Complexity weight : 1 |
1107 : | |
1108 : | Inputs : |
1109 : | |
1110 : | L64_var |
1111 : | 64 bit long signed integer (Word64) whose value falls in the |
1112 : | range : 0x80000000 00000000LL <= L64_var <= 0x7fffffff ffffffffLL. |
1113 : | |
1114 : | n |
1115 : | 32 bit signed integer (Word32) whose value falls in the |
1116 : | range : 0x8000 0000 <= n <= 0x7fff 0000. |
1117 : | |
1118 : | Outputs : |
1119 : | |
1120 : | none |
1121 : | |
1122 : | Return Value : |
1123 : | |
1124 : | L_result |
1125 : | 32 bit long signed integer (Word32) whose value falls in the |
1126 : | range : 0x8000 0000 <= L_result <= 0x7fff 0000. |
1127 : |___________________________________________________________________________|
1128 : */
1129 5160186647 : Word32 W_shl_sat_l( Word64 L64_var, Word16 n )
1130 : {
1131 : Word32 L_result;
1132 : Word64 d_var_64;
1133 :
1134 5160186647 : d_var_64 = W_shl( L64_var, n );
1135 5160186647 : L_result = W_sat_l( d_var_64 );
1136 :
1137 : #ifdef WMOPS
1138 : multiCounter[currCounter].W_shl_sat_l++;
1139 : multiCounter[currCounter].W_shl--;
1140 : multiCounter[currCounter].W_sat_l--;
1141 : #endif /* if WMOPS */
1142 :
1143 5160186647 : return L_result;
1144 : }
1145 :
1146 :
1147 : /*__________________________________________________________________________________
1148 : | |
1149 : | Function Name : W_round48_L |
1150 : | |
1151 : | Purpose : |
1152 : | |
1153 : | Round asymmetrically lower 16 bits, and |
1154 : | saturate the 17.47-bit values to 1.31-bit values |
1155 : | Complexity weight : 1 |
1156 : | |
1157 : | Inputs : |
1158 : | |
1159 : | L64_var1 |
1160 : | 64 bit long long signed integer (Word64) whose value falls in |
1161 : | range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
1162 : | |
1163 : | Outputs : |
1164 : | |
1165 : | none |
1166 : | |
1167 : | Return Value : |
1168 : | |
1169 : | L_var_out |
1170 : | 32 bit long signed integer (Word32) whose value falls in the |
1171 : | range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. |
1172 : |__________________________________________________________________________________|
1173 : */
1174 20067898781 : Word32 W_round48_L_o( Word64 L64_var1, Flag *Overflow )
1175 : {
1176 : Word64 L64_var_out;
1177 : Word32 L_result;
1178 :
1179 20067898781 : Word64 L64_var2 = 0x80000000;
1180 20067898781 : Word64 L64_MIN = (Word64) 0x8000000000000000LL;
1181 20067898781 : Word64 L64_MAX = 0x7FFFFFFFFFFFFFFFLL;
1182 :
1183 20067898781 : L64_var1 = W_shl( L64_var1, 16 );
1184 :
1185 20067898781 : L64_var_out = L64_var1 + L64_var2;
1186 :
1187 20067898781 : if ( ( ( L64_var1 ^ L64_var2 ) & L64_MIN ) == 0 )
1188 : {
1189 12456706369 : if ( ( L64_var_out ^ L64_var1 ) & L64_MIN )
1190 : {
1191 0 : L64_var_out = ( L64_var1 < 0 ) ? L64_MIN : L64_MAX;
1192 0 : set_overflow( Overflow );
1193 : }
1194 : }
1195 20067898781 : L_result = W_extract_h( L64_var_out );
1196 : #ifdef WMOPS
1197 : multiCounter[currCounter].W_round48_L++;
1198 : multiCounter[currCounter].W_extract_h--;
1199 : multiCounter[currCounter].W_shl--;
1200 : #endif /* if WMOPS */
1201 :
1202 20067898781 : return ( L_result );
1203 : }
1204 :
1205 20067898781 : Word32 W_round48_L( Word64 L64_var1 )
1206 : {
1207 20067898781 : return W_round48_L_o( L64_var1, NULL );
1208 : }
1209 :
1210 : /*__________________________________________________________________________________
1211 : | |
1212 : | Function Name : W_round32_s |
1213 : | |
1214 : | Purpose : |
1215 : | |
1216 : | Round asymmetrically lower 32 bits, and |
1217 : | saturate the 17.47-bit values to 1.15-bit values |
1218 : | Complexity weight : 1 |
1219 : | |
1220 : | Inputs : |
1221 : | |
1222 : | L64_var1 |
1223 : | 64 bit long long signed integer (Word64) whose value falls in |
1224 : | range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
1225 : | |
1226 : | Outputs : |
1227 : | |
1228 : | none |
1229 : | |
1230 : | Return Value : |
1231 : | |
1232 : | var_out |
1233 : | 16 bit short signed integer (Word16) whose value falls in the |
1234 : | range : 0xffff 8000 <= var_out <= 0x0000 7fff. |
1235 : |__________________________________________________________________________________|
1236 : */
1237 27938368 : Word16 W_round32_s_o( Word64 L64_var1, Flag *Overflow )
1238 : {
1239 : Word64 L64_var_out;
1240 : Word32 L_var;
1241 : Word16 var_out;
1242 :
1243 :
1244 27938368 : Word64 L64_var2 = 0x800000000000LL;
1245 27938368 : Word64 L64_MIN = 0x8000000000000000LL;
1246 27938368 : Word64 L64_MAX = 0x7FFFFFFFFFFFFFFFLL;
1247 :
1248 27938368 : L64_var1 = W_shl( L64_var1, 16 );
1249 27938368 : L64_var_out = L64_var1 + L64_var2;
1250 :
1251 27938368 : if ( ( ( L64_var1 ^ L64_var2 ) & L64_MIN ) == 0 )
1252 : {
1253 13900697 : if ( ( L64_var_out ^ L64_var1 ) & L64_MIN )
1254 : {
1255 0 : L64_var_out = ( L64_var1 < 0 ) ? L64_MIN : L64_MAX;
1256 0 : set_overflow( Overflow );
1257 : }
1258 : }
1259 27938368 : L_var = W_extract_h( L64_var_out );
1260 27938368 : var_out = extract_h( L_var );
1261 : #ifdef WMOPS
1262 : multiCounter[currCounter].W_round32_s++;
1263 : multiCounter[currCounter].W_extract_h--;
1264 : multiCounter[currCounter].extract_h--;
1265 : multiCounter[currCounter].W_shl--;
1266 : #endif /* if WMOPS */
1267 :
1268 27938368 : return ( var_out );
1269 : }
1270 :
1271 27938368 : Word16 W_round32_s( Word64 L64_var1 )
1272 : {
1273 27938368 : return W_round32_s_o( L64_var1, NULL );
1274 : }
1275 :
1276 : /*___________________________________________________________________________
1277 : | |
1278 : | Function Name : W_norm |
1279 : | |
1280 : | Purpose : |
1281 : | |
1282 : | Produces the number of left shifts needed to normalize the 64 bit varia-|
1283 : | ble L64_var1.
1284 : | |
1285 : | Complexity weight : 1 |
1286 : | |
1287 : | Inputs : |
1288 : | |
1289 : | L64_var1 |
1290 : | 64 bit long long signed integer (Word64) whose value falls in |
1291 : | range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
1292 : | |
1293 : | Outputs : |
1294 : | |
1295 : | none |
1296 : | |
1297 : | Return Value : |
1298 : | |
1299 : | var_out |
1300 : | 16 bit short signed integer (Word16) whose value falls in the |
1301 : | range : 0x0000 0000 <= var_out <= 0x0000 003f. |
1302 : |___________________________________________________________________________|
1303 : */
1304 5065260187 : Word16 W_norm( Word64 L64_var1 )
1305 : {
1306 : Word16 var_out;
1307 5065260187 : if ( L64_var1 == 0 )
1308 : {
1309 254253098 : var_out = 0;
1310 : }
1311 : else
1312 : {
1313 4811007089 : if ( L64_var1 == (Word64) 0xffffffffffffffffLL )
1314 : {
1315 37217 : var_out = 63;
1316 : }
1317 : else
1318 : {
1319 4810969872 : if ( L64_var1 < 0 )
1320 : {
1321 2281406401 : L64_var1 = ~L64_var1;
1322 : }
1323 >17904*10^7 : for ( var_out = 0; L64_var1 < (Word64) 0x4000000000000000LL; var_out++ )
1324 : {
1325 >17423*10^7 : L64_var1 <<= 1;
1326 : }
1327 : }
1328 : }
1329 : #ifdef WMOPS
1330 : multiCounter[currCounter].W_norm++;
1331 : #endif /* if WMOPS */
1332 5065260187 : return ( var_out );
1333 : }
1334 :
1335 :
1336 : /*______________________________________________________________________________
1337 : | |
1338 : | Function Name : W_add |
1339 : | |
1340 : | Purpose : |
1341 : | |
1342 : | 64 bits addition of the two 64 bits variables (L64_var1+L64_var2) with |
1343 : | overflow control and saturation; the result is set at 0x7fffffffffffffffLL |
1344 : | when overflow occurs or at 0x8000000000000000LL when underflow occurs. |
1345 : | |
1346 : | Complexity weight : 1 |
1347 : | |
1348 : | Inputs : |
1349 : | |
1350 : | L64_var1 64 bit long signed integer (Word64) whose value falls in the |
1351 : | range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
1352 : | |
1353 : | L64_var2 64 bit long signed integer (Word64) whose value falls in the |
1354 : | range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
1355 : | |
1356 : | Outputs : |
1357 : | |
1358 : | none |
1359 : | |
1360 : | Return Value : |
1361 : | |
1362 : | L64_var_out |
1363 : | 64 bit long signed integer (Word64) whose value falls in the |
1364 : | range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
1365 : |_______________________________________________________________________________|
1366 : */
1367 >13381*10^7 : Word64 W_add_o( Word64 L64_var1, Word64 L64_var2, Flag *Overflow )
1368 : {
1369 : Word64 L64_var_out;
1370 :
1371 >13381*10^7 : L64_var_out = L64_var1 + L64_var2;
1372 :
1373 >13381*10^7 : if ( ( ( L64_var1 ^ L64_var2 ) & MIN_64 ) == 0 )
1374 : {
1375 71988741582 : if ( ( L64_var_out ^ L64_var1 ) & MIN_64 )
1376 : {
1377 15169 : L64_var_out = ( L64_var1 < 0 ) ? MIN_64 : MAX_64;
1378 15169 : set_overflow( Overflow );
1379 : }
1380 : }
1381 :
1382 : #ifdef WMOPS
1383 : multiCounter[currCounter].W_add++;
1384 : #endif
1385 >13381*10^7 : return L64_var_out;
1386 : }
1387 :
1388 >13381*10^7 : Word64 W_add( Word64 L64_var1, Word64 L64_var2 )
1389 : {
1390 >13381*10^7 : return W_add_o( L64_var1, L64_var2, NULL );
1391 : }
1392 :
1393 : /*______________________________________________________________________________
1394 : | |
1395 : | Function Name : W_sub |
1396 : | |
1397 : | Purpose : |
1398 : | |
1399 : | 64 bits subtraction of the two 64 bits variables (L64_var1-L64_var2) with |
1400 : | overflow control and saturation; the result is set at 0x7fffffffffffffffLL |
1401 : | when overflow occurs or at 0x8000000000000000LL when underflow occurs. |
1402 : | |
1403 : | Complexity weight : 1 |
1404 : | |
1405 : | Inputs : |
1406 : | |
1407 : | L64_var1 64 bit long signed integer (Word64) whose value falls in the |
1408 : | range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
1409 : | |
1410 : | L64_var2 64 bit long signed integer (Word64) whose value falls in the |
1411 : | range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
1412 : | |
1413 : | Outputs : |
1414 : | |
1415 : | none |
1416 : | |
1417 : | Return Value : |
1418 : | |
1419 : | L64_var_out |
1420 : | 64 bit long signed integer (Word64) whose value falls in the |
1421 : | range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
1422 : |_______________________________________________________________________________|
1423 : */
1424 163545111 : Word64 W_sub_o( Word64 L64_var1, Word64 L64_var2, Flag *Overflow )
1425 : {
1426 : Word64 L64_var_out;
1427 :
1428 163545111 : L64_var_out = L64_var1 - L64_var2;
1429 :
1430 163545111 : if ( ( ( L64_var1 ^ L64_var2 ) & MIN_64 ) != 0 )
1431 : {
1432 23585152 : if ( ( L64_var_out ^ L64_var1 ) & MIN_64 )
1433 : {
1434 0 : L64_var_out = ( L64_var1 < 0 ) ? MIN_64 : MAX_64;
1435 0 : set_overflow( Overflow );
1436 : }
1437 : }
1438 :
1439 : #ifdef WMOPS
1440 : multiCounter[currCounter].W_add++;
1441 : #endif
1442 163545111 : return L64_var_out;
1443 : }
1444 :
1445 163545111 : Word64 W_sub( Word64 L64_var1, Word64 L64_var2 )
1446 : {
1447 163545111 : return W_sub_o( L64_var1, L64_var2, NULL );
1448 : }
1449 :
1450 :
1451 : /*______________________________________________________________________________
1452 : | |
1453 : | Function Name : W_neg |
1454 : | |
1455 : | Purpose : |
1456 : | |
1457 : | Negate the 64 bit variable L64_var1 with overflow control and saturation; |
1458 : | Saturate and set overflow in the case where input is 0x8000000000000000LL. |
1459 : | |
1460 : | Complexity weight : 1 |
1461 : | |
1462 : | Inputs : |
1463 : | |
1464 : | L64_var1 64 bit long signed integer (Word64) whose value falls in the |
1465 : | range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
1466 : | |
1467 : | Outputs : |
1468 : | |
1469 : | none |
1470 : | |
1471 : | Return Value : |
1472 : | |
1473 : | L64_var_out |
1474 : | 64 bit long signed integer (Word64) whose value falls in the |
1475 : | range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
1476 : |_______________________________________________________________________________|
1477 : */
1478 3318532 : Word64 W_neg_o( Word64 L64_var1, Flag *Overflow )
1479 : {
1480 : Word64 L64_var_out;
1481 :
1482 3318532 : if ( L64_var1 == MIN_64 )
1483 : {
1484 0 : L64_var_out = MAX_64;
1485 0 : set_overflow( Overflow );
1486 : }
1487 : else
1488 : {
1489 3318532 : L64_var_out = -L64_var1;
1490 : }
1491 :
1492 : #ifdef WMOPS
1493 : multiCounter[currCounter].W_neg++;
1494 : #endif
1495 :
1496 3318532 : return ( L64_var_out );
1497 : }
1498 :
1499 3318532 : Word64 W_neg( Word64 L64_var1 )
1500 : {
1501 3318532 : return W_neg_o( L64_var1, NULL );
1502 : }
1503 :
1504 :
1505 : /*___________________________________________________________________________
1506 : | |
1507 : | Function Name : W_abs |
1508 : | |
1509 : | Purpose : |
1510 : | |
1511 : | Absolute value of L64_var1; Saturate in case where the input is |
1512 : | 0x8000000000000000LL |
1513 : | |
1514 : | Complexity weight : 1 |
1515 : | |
1516 : | Inputs : |
1517 : | |
1518 : | L64_var1 64 bit long signed integer (Word64) whose value falls in the |
1519 : | range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
1520 : | |
1521 : | Outputs : |
1522 : | |
1523 : | none |
1524 : | |
1525 : | Return Value : |
1526 : | |
1527 : | L64_var_out |
1528 : | 64 bit long signed integer (Word64) whose value falls in the |
1529 : | range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
1530 : |___________________________________________________________________________|
1531 : */
1532 379143988 : Word64 W_abs_o( Word64 L64_var1, Flag *Overflow )
1533 : {
1534 : Word64 L64_var_out;
1535 :
1536 379143988 : if ( L64_var1 == MIN_64 )
1537 : {
1538 0 : L64_var_out = MAX_64;
1539 0 : set_overflow( Overflow );
1540 : }
1541 : else
1542 : {
1543 379143988 : if ( L64_var1 < 0 )
1544 : {
1545 155497633 : L64_var_out = -L64_var1;
1546 : }
1547 : else
1548 : {
1549 223646355 : L64_var_out = L64_var1;
1550 : }
1551 : }
1552 :
1553 : #ifdef WMOPS
1554 : multiCounter[currCounter].W_abs++;
1555 : #endif
1556 :
1557 379143988 : return ( L64_var_out );
1558 : }
1559 :
1560 379143988 : Word64 W_abs( Word64 L64_var1 )
1561 : {
1562 379143988 : return W_abs_o( L64_var1, NULL );
1563 : }
1564 :
1565 : /*_________________________________________________________________________________________________
1566 : | |
1567 : | Function Name : W_mult_32_32 |
1568 : | |
1569 : | Purpose : |
1570 : | |
1571 : | Multiply L_var1 by L_var2 and shift the result left by 1.Saturate and set overflow in case |
1572 : | where both inputs are 0x80000000 . Return a 64 bit result. |
1573 : | |
1574 : | Complexity weight : 1 |
1575 : | |
1576 : | Inputs : |
1577 : | |
1578 : | L_var1 |
1579 : | 32 bit signed integer (Word32) whose value falls in the |
1580 : | range : 0x8000 0000 <= L_var1 <= 0x7fff ffff |
1581 : | |
1582 : | L_var2 |
1583 : | 32 bit signed integer (Word32) whose value falls in the |
1584 : | range : 0x8000 0000 <= L_var1 <= 0x7fff ffff |
1585 : | |
1586 : | Outputs : |
1587 : | |
1588 : | none |
1589 : | |
1590 : | Return Value : |
1591 : | |
1592 : | L64_var_out |
1593 : | 64 bit long long signed integer (Word64) whose value falls in the |
1594 : | range : 0x80000000 00000000LL <= L64_var_out <= 0x7fffffff ffffffffLL. |
1595 : |_________________________________________________________________________________________________|
1596 : */
1597 >12880*10^7 : Word64 W_mult_32_32_o( Word32 L_var1, Word32 L_var2, Flag *Overflow )
1598 : {
1599 : Word64 L64_var_out;
1600 :
1601 >12880*10^7 : if ( ( L_var1 == MIN_32 ) && ( L_var2 == MIN_32 ) )
1602 : {
1603 8227 : L64_var_out = MAX_64;
1604 8227 : set_overflow( Overflow );
1605 : }
1606 : else
1607 : {
1608 >12880*10^7 : L64_var_out = ( (Word64) L_var1 * L_var2 ) << 1;
1609 : }
1610 :
1611 : #ifdef WMOPS
1612 : multiCounter[currCounter].W_mult_32_32++;
1613 : #endif /* if WMOPS */
1614 >12880*10^7 : return L64_var_out;
1615 : }
1616 :
1617 >12880*10^7 : Word64 W_mult_32_32( Word32 L_var1, Word32 L_var2 )
1618 : {
1619 >12880*10^7 : return W_mult_32_32_o( L_var1, L_var2, NULL );
1620 : }
1621 :
1622 : /*_________________________________________________________________________________________________
1623 : | |
1624 : | Function Name : W_mult0_32_32 |
1625 : | |
1626 : | Purpose : |
1627 : | |
1628 : | Multiply L_var1 by L_var2. Return a 64 bit result. |
1629 : | |
1630 : | Complexity weight : 1 |
1631 : | |
1632 : | Inputs : |
1633 : | |
1634 : | L_var1 |
1635 : | 32 bit signed integer (Word32) whose value falls in the |
1636 : | range : 0x8000 0000 <= L_var1 <= 0x7fff ffff |
1637 : | |
1638 : | L_var2 |
1639 : | 32 bit signed integer (Word32) whose value falls in the |
1640 : | range : 0x8000 0000 <= L_var1 <= 0x7fff ffff |
1641 : | |
1642 : | Outputs : |
1643 : | |
1644 : | none |
1645 : | |
1646 : | Return Value : |
1647 : | |
1648 : | L64_var_out |
1649 : | 64 bit long long signed integer (Word64) whose value falls in the |
1650 : | range : 0x80000000 00000000LL <= L64_var_out <= 0x7fffffff ffffffffLL. |
1651 : |_________________________________________________________________________________________________|
1652 : */
1653 7809238674 : Word64 W_mult0_32_32( Word32 L_var1, Word32 L_var2 )
1654 : {
1655 : Word64 L64_var_out;
1656 :
1657 7809238674 : L64_var_out = (Word64) L_var1 * L_var2;
1658 :
1659 :
1660 : #ifdef WMOPS
1661 : multiCounter[currCounter].W_mult0_32_32++;
1662 : #endif /* if WMOPS */
1663 7809238674 : return L64_var_out;
1664 : }
1665 :
1666 :
1667 : /*_____________________________________________________________________________
1668 : | |
1669 : | Function Name : W_lshl |
1670 : | |
1671 : | Purpose : |
1672 : | |
1673 : | Logically shift the 64 bit unsigned input L64_var1 left by var2 positions. |
1674 : | Zero fill the var2 LSB of the result. If var2 is negative, logically shift |
1675 : | L64_var1 right by -var2 with zero fill in the MSB. |
1676 : | |
1677 : | Complexity weight : 1 |
1678 : | |
1679 : | Inputs : |
1680 : | |
1681 : | L64_var1 64 bit long unsigned signed integer (UWord64) whose value falls |
1682 : | in the range : 0LL <= L64_var1 <= 0xffffffff ffffffffLL. |
1683 : | |
1684 : | var2 |
1685 : | 16 bit short signed integer (Word16) whose value falls in the |
1686 : | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
1687 : | |
1688 : | Outputs : |
1689 : | |
1690 : | none |
1691 : | |
1692 : | Return Value : |
1693 : | |
1694 : | L64_var_out |
1695 : | 64 bit long unsigned signed integer (UWord64) whose value falls |
1696 : | in the range : 0LL <= L64_var1 <= 0xffffffff ffffffffLL. |
1697 : |______________________________________________________________________________|
1698 : */
1699 0 : UWord64 W_lshl( UWord64 L64_var1, Word16 var2 )
1700 : {
1701 :
1702 0 : UWord64 L64_var_out = 0LL;
1703 :
1704 0 : if ( var2 < 0 )
1705 : {
1706 0 : L64_var_out = L64_var1 >> ( -var2 );
1707 : }
1708 : else
1709 : {
1710 0 : L64_var_out = L64_var1 << var2;
1711 : }
1712 : #ifdef WMOPS
1713 : multiCounter[currCounter].W_lshl++;
1714 : #endif
1715 :
1716 0 : return ( L64_var_out );
1717 : }
1718 :
1719 : /*_____________________________________________________________________________
1720 : | |
1721 : | Function Name : W_lshr |
1722 : | |
1723 : | Purpose : |
1724 : | |
1725 : | Logically shift the 64 bit unsigned input L64_var1 right by var2 positions.|
1726 : | Zero fill the var2 MSB of the result. If var2 is negative, logically shift |
1727 : | L64_var1 left by -var2 with zero fill in the LSB. |
1728 : | |
1729 : | Complexity weight : 1 |
1730 : | |
1731 : | Inputs : |
1732 : | |
1733 : | L64_var1 64 bit long unsigned signed integer (UWord64) whose value falls |
1734 : | in the range : 0LL <= L64_var1 <= 0xffffffff ffffffffLL. |
1735 : | |
1736 : | var2 |
1737 : | 16 bit short signed integer (Word16) whose value falls in the |
1738 : | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
1739 : | |
1740 : | Outputs : |
1741 : | |
1742 : | none |
1743 : | |
1744 : | Return Value : |
1745 : | |
1746 : | L64_var_out |
1747 : | 64 bit long unsigned signed integer (UWord64) whose value falls |
1748 : | in the range : 0LL <= L64_var1 <= 0xffffffff ffffffffLL. |
1749 : |______________________________________________________________________________|
1750 : */
1751 0 : UWord64 W_lshr( UWord64 L64_var1, Word16 var2 )
1752 : {
1753 :
1754 0 : UWord64 L64_var_out = 0LL;
1755 :
1756 0 : if ( var2 < 0 )
1757 : {
1758 0 : L64_var_out = L64_var1 << ( -var2 );
1759 : }
1760 : else
1761 : {
1762 0 : L64_var_out = L64_var1 >> var2;
1763 : }
1764 : #ifdef WMOPS
1765 : multiCounter[currCounter].W_lshr++;
1766 : #endif
1767 :
1768 0 : return ( L64_var_out );
1769 : }
1770 :
1771 :
1772 : /*__________________________________________________________________________________
1773 : | |
1774 : | Function Name : W_round64_L |
1775 : | |
1776 : | Purpose : |
1777 : | |
1778 : | Round asymmetrically lower 32 bits, and |
1779 : | saturate the 1.63-bit values to 1.31-bit values |
1780 : | Complexity weight : 1 |
1781 : | |
1782 : | Inputs : |
1783 : | |
1784 : | L64_var1 |
1785 : | 64 bit long long signed integer (Word64) whose value falls in |
1786 : | range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
1787 : | |
1788 : | Outputs : |
1789 : | |
1790 : | none |
1791 : | |
1792 : | Return Value : |
1793 : | |
1794 : | L_var_out |
1795 : | 32 bit long signed integer (Word32) whose value falls in the |
1796 : | range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. |
1797 : |__________________________________________________________________________________|
1798 : */
1799 1714922 : Word32 W_round64_L( Word64 L64_var1 )
1800 : {
1801 : Word64 L64_var_out;
1802 : Word32 L_result;
1803 :
1804 :
1805 1714922 : Word64 L64_tmp = 0x80000000;
1806 1714922 : L64_var_out = W_add( L64_var1, L64_tmp );
1807 1714922 : L_result = W_extract_h( L64_var_out );
1808 :
1809 : #ifdef WMOPS
1810 : multiCounter[currCounter].W_round64_L++;
1811 : multiCounter[currCounter].W_extract_h--;
1812 : multiCounter[currCounter].W_add--;
1813 : #endif /* if WMOPS */
1814 :
1815 1714922 : return ( L_result );
1816 : }
1817 :
1818 : #endif /* #ifdef ENH_64_BIT_OPERATOR */
1819 : #undef WMC_TOOL_SKIP
1820 :
1821 : /* end of file */
|
