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 36934107 : Word64 W_add_nosat( Word64 L64_var1, Word64 L64_var2 )
75 : {
76 : Word64 L64_var_out;
77 :
78 36934107 : L64_var_out = L64_var1 + L64_var2;
79 :
80 : #ifdef WMOPS
81 : multiCounter[currCounter].W_add_nosat++;
82 : #endif
83 :
84 36934107 : 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 11571838 : Word64 W_sub_nosat( Word64 L64_var1, Word64 L64_var2 )
118 : {
119 : Word64 L64_var_out;
120 :
121 11571838 : L64_var_out = L64_var1 - L64_var2;
122 :
123 : #ifdef WMOPS
124 : multiCounter[currCounter].W_sub_nosat++;
125 : #endif
126 :
127 11571838 : 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 >29685*10^7 : Word64 W_shl_o( Word64 L64_var1, Word16 var2, Flag *Overflow )
165 : {
166 :
167 >29685*10^7 : Word64 L64_var_out = 0LL;
168 :
169 >29685*10^7 : if ( var2 <= 0 )
170 : {
171 4509731857 : if ( var2 < -64 )
172 0 : var2 = -64;
173 4509731857 : var2 = -var2;
174 4509731857 : L64_var_out = L64_var1 >> var2;
175 : }
176 : else
177 : {
178 >13390*10^8 : for ( ; var2 > 0; var2-- )
179 : {
180 >10466*10^8 : if ( L64_var1 > (Word64) 0X3fffffffffffffffLL )
181 : {
182 5133578 : set_overflow( Overflow );
183 5133578 : L64_var_out = (Word64) 0X7fffffffffffffffLL;
184 5133578 : break;
185 : }
186 : else
187 : {
188 >10466*10^8 : if ( L64_var1 < (Word64) 0xc000000000000000LL )
189 : {
190 3 : set_overflow( Overflow );
191 3 : L64_var_out = (Word64) 0x8000000000000000LL;
192 3 : break;
193 : }
194 : }
195 >10466*10^8 : L64_var1 *= 2;
196 >10466*10^8 : L64_var_out = L64_var1;
197 : }
198 : }
199 : #ifdef WMOPS
200 : multiCounter[currCounter].W_shl++;
201 : #endif
202 :
203 : /* BASOP_CHECK();*/
204 :
205 >29685*10^7 : return ( L64_var_out );
206 : }
207 :
208 59094412719 : Word64 W_shl( Word64 L64_var1, Word16 var2 )
209 : {
210 59094412719 : 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 30762071211 : Word64 W_shr( Word64 L64_var1, Word16 var2 )
248 : {
249 : Word64 L64_var_out;
250 :
251 30762071211 : if ( var2 < 0 )
252 : {
253 604076296 : var2 = -var2;
254 604076296 : 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 30157994915 : L64_var_out = L64_var1 >> var2;
263 : }
264 :
265 : #ifdef WMOPS
266 : multiCounter[currCounter].W_shr++;
267 : #endif /* if WMOPS */
268 :
269 30762071211 : 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 1939765086 : Word64 W_shl_nosat( Word64 L64_var1, Word16 var2 )
308 : {
309 :
310 1939765086 : Word64 L64_var_out = 0LL;
311 :
312 1939765086 : if ( var2 <= 0 )
313 : {
314 1933409253 : var2 = -var2;
315 1933409253 : L64_var_out = L64_var1 >> var2;
316 : }
317 : else
318 : {
319 6355833 : L64_var_out = L64_var1 << var2;
320 : }
321 : #ifdef WMOPS
322 : multiCounter[currCounter].W_shl_nosat++;
323 : #endif
324 :
325 : /* BASOP_CHECK();*/
326 :
327 1939765086 : 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 2183045628 : Word64 W_mac_32_16( Word64 L64_var1, Word32 L_var2, Word16 var3 )
424 : {
425 2183045628 : Word64 L64_var_out = ( (Word64) L_var2 * var3 ) << 1;
426 2183045628 : L64_var_out += L64_var1;
427 : #ifdef WMOPS
428 : multiCounter[currCounter].W_mac_32_16++;
429 : #endif /* if WMOPS */
430 2183045628 : 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 984672320 : Word64 W_msu_32_16( Word64 L64_var1, Word32 L_var2, Word16 var3 )
471 : {
472 984672320 : Word64 L64_var_out = ( (Word64) L_var2 * var3 ) << 1;
473 984672320 : L64_var_out = L64_var1 - L64_var_out;
474 : #ifdef WMOPS
475 : multiCounter[currCounter].W_msu_32_16++;
476 : #endif /* if WMOPS */
477 984672320 : 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 >13203*10^7 : Word64 W_mult_32_16( Word32 L_var1, Word16 var2 )
513 : {
514 >13203*10^7 : Word64 L64_var_out = ( (Word64) L_var1 * var2 ) << 1;
515 : #ifdef WMOPS
516 : multiCounter[currCounter].W_mult_32_16++;
517 : #endif /* if WMOPS */
518 >13203*10^7 : 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 338277303 : Word64 W_mult0_16_16( Word16 var1, Word16 var2 )
553 : {
554 338277303 : Word64 L64_var_out = (Word64) var1 * var2;
555 : #ifdef WMOPS
556 : multiCounter[currCounter].W_mult0_16_16++;
557 : #endif /* if WMOPS */
558 338277303 : 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 88764449366 : Word64 W_mac0_16_16( Word64 L64_var1, Word16 var2, Word16 var3 )
597 : {
598 88764449366 : Word64 L64_var_out = (Word64) var2 * var3;
599 88764449366 : L64_var_out += L64_var1;
600 : #ifdef WMOPS
601 : multiCounter[currCounter].W_mac0_16_16++;
602 : #endif /* if WMOPS */
603 88764449366 : 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 820159200 : Word64 W_msu0_16_16( Word64 L64_var1, Word16 var2, Word16 var3 )
643 : {
644 820159200 : Word64 L64_var_out = (Word64) var2 * var3;
645 820159200 : L64_var_out = L64_var1 - L64_var_out;
646 : #ifdef WMOPS
647 : multiCounter[currCounter].W_msu0_16_16++;
648 : #endif /* if WMOPS */
649 820159200 : 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 >11020*10^7 : Word32 W_sat_l( Word64 L64_var )
681 : {
682 : Word32 L_var_out;
683 :
684 >11020*10^7 : if ( L64_var > 0x7FFFFFFF )
685 : {
686 3551386 : L_var_out = 0x7FFFFFFF;
687 : }
688 >11020*10^7 : else if ( L64_var < (int) 0x80000000 )
689 : {
690 134324 : L_var_out = (Word32) 0x80000000;
691 : }
692 : else
693 : {
694 >11020*10^7 : L_var_out = (Word32) L64_var;
695 : }
696 :
697 : #ifdef WMOPS
698 : multiCounter[currCounter].W_sat_l++;
699 : #endif /* if WMOPS */
700 :
701 >11020*10^7 : 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 94856603085 : Word32 W_sat_m( Word64 L64_var )
734 : {
735 : Word32 L_var_out;
736 :
737 94856603085 : L64_var = L64_var >> 16;
738 94856603085 : 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 94856603085 : 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 6806681677 : Word64 W_deposit32_l( Word32 L_var1 )
777 : {
778 : Word64 L64_var_out;
779 :
780 6806681677 : L64_var_out = (Word64) L_var1;
781 :
782 : #ifdef WMOPS
783 : multiCounter[currCounter].W_deposit32_l++;
784 : #endif
785 :
786 6806681677 : 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 1250 : Word64 W_deposit32_h( Word32 L_var1 )
818 : {
819 : Word64 L64_var_out;
820 :
821 1250 : L64_var_out = (Word64) L_var1 << 32;
822 :
823 : #ifdef WMOPS
824 : multiCounter[currCounter].W_deposit32_h++;
825 : #endif
826 :
827 1250 : 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 9544489236 : Word32 W_extract_l( Word64 L64_var1 )
859 : {
860 : Word32 L_var_out;
861 :
862 9544489236 : L_var_out = (Word32) L64_var1;
863 :
864 : #ifdef WMOPS
865 : multiCounter[currCounter].W_extract_l++;
866 : #endif /* if WMOPS */
867 :
868 9544489236 : 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 >28063*10^7 : Word32 W_extract_h( Word64 L64_var1 )
900 : {
901 : Word32 L_var_out;
902 :
903 >28063*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 >28063*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 12241044 : Word64 W_mult_16_16( Word16 var1, Word16 var2 )
945 : {
946 12241044 : Word64 L64_var_out = ( (Word64) var1 * var2 ) << 1;
947 : #ifdef WMOPS
948 : multiCounter[currCounter].W_mult_16_16++;
949 : #endif /* if WMOPS */
950 12241044 : 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 18343075746 : Word64 W_mac_16_16( Word64 L64_acc, Word16 var1, Word16 var2 )
989 : {
990 18343075746 : Word64 L64_var_out = ( (Word64) var1 * var2 ) << 1;
991 18343075746 : L64_acc = L64_acc + L64_var_out;
992 :
993 : #ifdef WMOPS
994 : multiCounter[currCounter].W_mac_16_16++;
995 : #endif /* if WMOPS */
996 18343075746 : 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 596686688 : Word64 W_msu_16_16( Word64 L64_var1, Word16 var2, Word16 var3 )
1037 : {
1038 596686688 : Word64 L64_var_out = ( (Word64) var2 * var3 ) << 1;
1039 596686688 : L64_var_out = L64_var1 - L64_var_out;
1040 : #ifdef WMOPS
1041 : multiCounter[currCounter].W_msu_16_16++;
1042 : #endif /* if WMOPS */
1043 596686688 : 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 >13635*10^7 : Word64 W_mac_32_32( Word64 L64_var1, Word32 L_var2, Word32 L_var3 )
1084 : {
1085 >13635*10^7 : Word64 L64_var_out = W_mult_32_32( L_var2, L_var3 );
1086 >13635*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 >13635*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 13291078489 : Word32 W_shl_sat_l( Word64 L64_var, Word16 n )
1130 : {
1131 : Word32 L_result;
1132 : Word64 d_var_64;
1133 :
1134 13291078489 : d_var_64 = W_shl( L64_var, n );
1135 13291078489 : 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 13291078489 : 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 36780596228 : Word32 W_round48_L_o( Word64 L64_var1, Flag *Overflow )
1175 : {
1176 : Word64 L64_var_out;
1177 : Word32 L_result;
1178 :
1179 36780596228 : Word64 L64_var2 = 0x80000000;
1180 36780596228 : Word64 L64_MIN = (Word64) 0x8000000000000000LL;
1181 36780596228 : Word64 L64_MAX = 0x7FFFFFFFFFFFFFFFLL;
1182 :
1183 36780596228 : L64_var1 = W_shl( L64_var1, 16 );
1184 :
1185 36780596228 : L64_var_out = L64_var1 + L64_var2;
1186 :
1187 36780596228 : if ( ( ( L64_var1 ^ L64_var2 ) & L64_MIN ) == 0 )
1188 : {
1189 21058586975 : if ( ( L64_var_out ^ L64_var1 ) & L64_MIN )
1190 : {
1191 367 : L64_var_out = ( L64_var1 < 0 ) ? L64_MIN : L64_MAX;
1192 367 : set_overflow( Overflow );
1193 : }
1194 : }
1195 36780596228 : 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 36780596228 : return ( L_result );
1203 : }
1204 :
1205 36780596228 : Word32 W_round48_L( Word64 L64_var1 )
1206 : {
1207 36780596228 : 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 18444125907 : Word16 W_norm( Word64 L64_var1 )
1305 : {
1306 : Word16 var_out;
1307 18444125907 : if ( L64_var1 == 0 )
1308 : {
1309 773747631 : var_out = 0;
1310 : }
1311 : else
1312 : {
1313 17670378276 : if ( L64_var1 == (Word64) 0xffffffffffffffffLL )
1314 : {
1315 39639 : var_out = 63;
1316 : }
1317 : else
1318 : {
1319 17670338637 : if ( L64_var1 < 0 )
1320 : {
1321 7423688673 : L64_var1 = ~L64_var1;
1322 : }
1323 >61060*10^7 : for ( var_out = 0; L64_var1 < (Word64) 0x4000000000000000LL; var_out++ )
1324 : {
1325 >59293*10^7 : L64_var1 <<= 1;
1326 : }
1327 : }
1328 : }
1329 : #ifdef WMOPS
1330 : multiCounter[currCounter].W_norm++;
1331 : #endif /* if WMOPS */
1332 18444125907 : 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 >16549*10^7 : Word64 W_add_o( Word64 L64_var1, Word64 L64_var2, Flag *Overflow )
1368 : {
1369 : Word64 L64_var_out;
1370 :
1371 >16549*10^7 : L64_var_out = L64_var1 + L64_var2;
1372 :
1373 >16549*10^7 : if ( ( ( L64_var1 ^ L64_var2 ) & MIN_64 ) == 0 )
1374 : {
1375 92483331263 : if ( ( L64_var_out ^ L64_var1 ) & MIN_64 )
1376 : {
1377 237111 : L64_var_out = ( L64_var1 < 0 ) ? MIN_64 : MAX_64;
1378 237111 : set_overflow( Overflow );
1379 : }
1380 : }
1381 :
1382 : #ifdef WMOPS
1383 : multiCounter[currCounter].W_add++;
1384 : #endif
1385 >16549*10^7 : return L64_var_out;
1386 : }
1387 :
1388 >16549*10^7 : Word64 W_add( Word64 L64_var1, Word64 L64_var2 )
1389 : {
1390 >16549*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 236387655 : Word64 W_sub_o( Word64 L64_var1, Word64 L64_var2, Flag *Overflow )
1425 : {
1426 : Word64 L64_var_out;
1427 :
1428 236387655 : L64_var_out = L64_var1 - L64_var2;
1429 :
1430 236387655 : if ( ( ( L64_var1 ^ L64_var2 ) & MIN_64 ) != 0 )
1431 : {
1432 45783093 : 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 236387655 : return L64_var_out;
1443 : }
1444 :
1445 236387655 : Word64 W_sub( Word64 L64_var1, Word64 L64_var2 )
1446 : {
1447 236387655 : 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 399159513 : Word64 W_abs_o( Word64 L64_var1, Flag *Overflow )
1533 : {
1534 : Word64 L64_var_out;
1535 :
1536 399159513 : if ( L64_var1 == MIN_64 )
1537 : {
1538 0 : L64_var_out = MAX_64;
1539 0 : set_overflow( Overflow );
1540 : }
1541 : else
1542 : {
1543 399159513 : if ( L64_var1 < 0 )
1544 : {
1545 163792819 : L64_var_out = -L64_var1;
1546 : }
1547 : else
1548 : {
1549 235366694 : L64_var_out = L64_var1;
1550 : }
1551 : }
1552 :
1553 : #ifdef WMOPS
1554 : multiCounter[currCounter].W_abs++;
1555 : #endif
1556 :
1557 399159513 : return ( L64_var_out );
1558 : }
1559 :
1560 399159513 : Word64 W_abs( Word64 L64_var1 )
1561 : {
1562 399159513 : 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 >14482*10^7 : Word64 W_mult_32_32_o( Word32 L_var1, Word32 L_var2, Flag *Overflow )
1598 : {
1599 : Word64 L64_var_out;
1600 :
1601 >14482*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 >14482*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 >14482*10^7 : return L64_var_out;
1615 : }
1616 :
1617 >14482*10^7 : Word64 W_mult_32_32( Word32 L_var1, Word32 L_var2 )
1618 : {
1619 >14482*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 25213820371 : Word64 W_mult0_32_32( Word32 L_var1, Word32 L_var2 )
1654 : {
1655 : Word64 L64_var_out;
1656 :
1657 25213820371 : 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 25213820371 : 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 372352 : UWord64 W_lshl( UWord64 L64_var1, Word16 var2 )
1700 : {
1701 :
1702 372352 : UWord64 L64_var_out = 0LL;
1703 :
1704 372352 : if ( var2 < 0 )
1705 : {
1706 0 : L64_var_out = L64_var1 >> ( -var2 );
1707 : }
1708 : else
1709 : {
1710 372352 : L64_var_out = L64_var1 << var2;
1711 : }
1712 : #ifdef WMOPS
1713 : multiCounter[currCounter].W_lshl++;
1714 : #endif
1715 :
1716 372352 : 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 5170901 : Word32 W_round64_L( Word64 L64_var1 )
1800 : {
1801 : Word64 L64_var_out;
1802 : Word32 L_result;
1803 :
1804 :
1805 5170901 : Word64 L64_tmp = 0x80000000;
1806 5170901 : L64_var_out = W_add( L64_var1, L64_tmp );
1807 5170901 : 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 5170901 : return ( L_result );
1816 : }
1817 :
1818 : #endif /* #ifdef ENH_64_BIT_OPERATOR */
1819 : #undef WMC_TOOL_SKIP
1820 :
1821 : /* end of file */
|
