1/*****************************************************************************
2
3 Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
4 more contributor license agreements. See the NOTICE file distributed
5 with this work for additional information regarding copyright ownership.
6 Accellera licenses this file to you under the Apache License, Version 2.0
7 (the "License"); you may not use this file except in compliance with the
8 License. You may obtain a copy of the License at
9
10 http://www.apache.org/licenses/LICENSE-2.0
11
12 Unless required by applicable law or agreed to in writing, software
13 distributed under the License is distributed on an "AS IS" BASIS,
14 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
15 implied. See the License for the specific language governing
16 permissions and limitations under the License.
17
18 *****************************************************************************/
19
20/*****************************************************************************
21
22 sc_unsigned.cpp -- Arbitrary precision signed arithmetic.
23
24 This file includes the definitions of sc_unsigned_bitref,
25 sc_unsigned_subref, and sc_unsigned classes. The first two classes
26 are proxy classes to reference one bit and a range of bits of a
27 sc_unsigned number, respectively. This file also includes
28 sc_nbcommon.cpp and sc_nbfriends.cpp, which contain the
29 definitions shared by sc_unsigned.
30
31 Original Author: Ali Dasdan, Synopsys, Inc.
32
33 *****************************************************************************/
34
35/*****************************************************************************
36
37 MODIFICATION LOG - modifiers, enter your name, affiliation, date and
38 changes you are making here.
39
40 Name, Affiliation, Date:
41 Description of Modification:
42
43 *****************************************************************************/
44
45
46// $Log: sc_unsigned.cpp,v $
47// Revision 1.7 2011/02/18 20:19:15 acg
48// Andy Goodrich: updating Copyright notice.
49//
50// Revision 1.6 2008/12/10 20:38:45 acg
51// Andy Goodrich: fixed conversion of double values to the digits vector.
52// The bits above the radix were not being masked off.
53//
54// Revision 1.5 2008/06/19 17:47:57 acg
55// Andy Goodrich: fixes for bugs. See 2.2.1 RELEASENOTES.
56//
57// Revision 1.4 2008/06/19 16:57:57 acg
58// Andy Goodrich: added case for negative unsigned values to the support in
59// concate_get_data().
60//
61// Revision 1.3 2007/11/04 21:27:00 acg
62// Andy Goodrich: changes to make sure the proper value is returned from
63// concat_get_data().
64//
65// Revision 1.2 2007/02/22 21:35:05 acg
66// Andy Goodrich: cleaned up comments in concat_get_ctrl and concat_get_data.
67//
68// Revision 1.1.1.1 2006/12/15 20:20:05 acg
69// SystemC 2.3
70//
71// Revision 1.4 2006/08/29 23:36:54 acg
72// Andy Goodrich: fixed and_reduce and optimized or_reduce.
73//
74// Revision 1.3 2006/01/13 18:49:32 acg
75// Added $Log command so that CVS check in comments are reproduced in the
76// source.
77//
78
79#include <cctype>
80#include <cmath>
81#include <sstream>
82
83#include "systemc/ext/dt/bit/sc_bv_base.hh"
84#include "systemc/ext/dt/bit/sc_lv_base.hh"
85#include "systemc/ext/dt/fx/sc_ufix.hh"
86#include "systemc/ext/dt/fx/scfx_other_defs.hh"
87#include "systemc/ext/dt/int/sc_int_base.hh"
88#include "systemc/ext/dt/int/sc_signed.hh"
89#include "systemc/ext/dt/int/sc_uint_base.hh"
90#include "systemc/ext/dt/int/sc_unsigned.hh"
91#include "systemc/ext/dt/misc/sc_concatref.hh"
92#include "systemc/ext/utils/messages.hh"
93
94// explicit template instantiations
95namespace sc_core
96{
97
98template class sc_vpool<sc_dt::sc_unsigned_bitref>;
99template class sc_vpool<sc_dt::sc_unsigned_subref>;
100template class sc_vpool<sc_dt::sc_unsigned>;
101
102} // namespace sc_core
103
104namespace sc_dt
105{
106
107// Pool of temporary instances:
108// The sc_unsigned pool is used by the concatenation support.
109// The bit and part reference pools allow references to be returned.
110
111sc_core::sc_vpool<sc_unsigned> sc_unsigned::m_pool(8);
112sc_core::sc_vpool<sc_unsigned_bitref> sc_unsigned_bitref::m_pool(9);
113sc_core::sc_vpool<sc_unsigned_subref> sc_unsigned_subref::m_pool(9);
114
115
116void
117sc_unsigned::invalid_init(const char *type_name, int nb) const
118{
119 std::stringstream msg;
120 msg << "sc_unsigned("<< type_name << ") : nb = " << nb << " is not valid";
121 SC_REPORT_ERROR("initialization failed", msg.str().c_str());
122}
123
124
125// ----------------------------------------------------------------------------
126// SECTION: Public members - Invalid selections.
127// ----------------------------------------------------------------------------
128
129void
130sc_unsigned::invalid_index(int i) const
131{
132 std::stringstream msg;
133 msg << "sc_biguint bit selection: index = " << i << " violates "
134 "0 <= index <= " << (nbits-2);
135 SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, msg.str().c_str());
136 sc_core::sc_abort(); // can't recover from here
137}
138
139void
140sc_unsigned::invalid_range(int l, int r) const
141{
142 std::stringstream msg;
143 msg << "sc_biguint part selection: left = " <<
144 l << ", right = " << r << " \n"
145 " violates either (" << (nbits - 2) << " >= left >= 0) or "
146 "(" << (nbits-2) << " >= right >= 0)";
147 SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, msg.str().c_str());
148 sc_core::sc_abort(); // can't recover from here
149}
150
151// ----------------------------------------------------------------------------
152// SECTION: Public members - Concatenation support.
153// ----------------------------------------------------------------------------
154
155// Most public members are included from sc_nbcommon.inc. However, some
156// concatenation support appears here to optimize between the signed and
157// unsigned cases.
158
159
160
161// Insert this object's value at the specified place in a vector of big style
162// values.
163
164bool
165sc_unsigned::concat_get_ctrl(sc_digit *dst_p, int low_i) const
166{
167 int dst_i; // Index to next word to set in dst_p.
168 int end_i; // Index of high order word to set.
169 int left_shift; // Amount to shift value left.
170 sc_digit mask; // Mask for partial word sets.
171
172
173 // CALCULATE METRICS FOR DATA MOVEMENT:
174 dst_i = low_i / BITS_PER_DIGIT;
175 end_i = (low_i + nbits - 2) / BITS_PER_DIGIT;
176 left_shift = low_i % BITS_PER_DIGIT;
177
178 // MOVE FIRST WORD (IT MAY BE PARTIAL) AND THEN ANY OTHERS:
179 //
180 // We may "clobber" upper bits, but they will be written at some point
181 // anyway.
182
183 mask = ~(~0U << left_shift);
184 dst_p[dst_i] = (dst_p[dst_i] & ~mask);
185 dst_i++;
186
187 for (; dst_i <= end_i; dst_i++)
188 dst_p[dst_i] = 0;
189
190 return false;
191}
192
193bool
194sc_unsigned::concat_get_data(sc_digit *dst_p, int low_i) const
195{
196 sc_digit carry; // Carry for negating value.
197 int dst_i; // Index to next word to set in dst_p.
198 int end_i; // Index of high order word to set.
199 int high_i; // Index w/in word of high order bit.
200 int left_shift; // Amount to shift value left.
201 sc_digit left_word; // High word component for set.
202 sc_digit mask; // Mask for partial word sets.
203 bool result; // True if inserting non-zero data.
204 int right_shift; // Amount to shift value right.
205 sc_digit right_word; // Low word component for set.
206 int real_bits; // nbits - 1.
207 int src_i; // Index to next word to get from digit.
208
209 // CALCULATE METRICS FOR DATA MOVEMENT:
210 real_bits = nbits - 1; // Remove that extra sign bit.
211 dst_i = low_i / BITS_PER_DIGIT;
212 high_i = low_i + real_bits - 1;
213 end_i = high_i / BITS_PER_DIGIT;
214 left_shift = low_i % BITS_PER_DIGIT;
215
216 switch (sgn) {
217 // POSITIVE SOURCE VALUE:
218 case SC_POS:
219 result = true;
220
221 // ALL DATA TO BE MOVED IS IN A SINGLE WORD:
222 if (dst_i == end_i) {
223 mask = ~(~0U << left_shift);
224 dst_p[dst_i] = ((dst_p[dst_i] & mask) |
225 (digit[0] << left_shift)) & DIGIT_MASK;
226
227 // DATA IS IN MORE THAN ONE WORD, BUT IS WORD ALIGNED:
228 } else if (left_shift == 0) {
229 for (src_i = 0; dst_i < end_i; dst_i++, src_i++) {
230 dst_p[dst_i] = digit[src_i];
231 }
232 high_i = high_i % BITS_PER_DIGIT;
233 mask = ~(~1U << high_i) & DIGIT_MASK;
234 dst_p[dst_i] = digit[src_i] & mask;
235
236 // DATA IS IN MORE THAN ONE WORD, AND NOT WORD ALIGNED:
237 } else {
238 high_i = high_i % BITS_PER_DIGIT;
239 right_shift = BITS_PER_DIGIT - left_shift;
240 mask = ~(~0U << left_shift);
241 right_word = digit[0];
242 dst_p[dst_i] = (dst_p[dst_i] & mask) |
243 ((right_word << left_shift) & DIGIT_MASK);
244 for (src_i = 1, dst_i++; dst_i < end_i; dst_i++, src_i++) {
245 left_word = digit[src_i];
246 dst_p[dst_i] = ((left_word << left_shift) & DIGIT_MASK) |
247 (right_word >> right_shift);
248 right_word = left_word;
249 }
250 left_word = (src_i < ndigits) ? digit[src_i] : 0;
251 mask = ~(~1U << high_i) & DIGIT_MASK;
252 dst_p[dst_i] = ((left_word << left_shift) |
253 (right_word >> right_shift)) & mask;
254 }
255 break;
256
257 // SOURCE VALUE IS NEGATIVE:
258 case SC_NEG:
259 // ALL DATA TO BE MOVED IS IN A SINGLE WORD:
260 result = true;
261 if (dst_i == end_i) {
262 mask = ~(~0U << nbits);
263 right_word = ((digit[0] ^ DIGIT_MASK) + 1) & mask;
264 mask = ~(~0U << left_shift);
265 dst_p[dst_i] = ((dst_p[dst_i] & mask) |
266 (right_word << left_shift)) & DIGIT_MASK;
267
268 // DATA IS IN MORE THAN ONE WORD, BUT IS WORD ALIGNED:
269
270 } else if (left_shift == 0) {
271 carry = 1;
272 for (src_i = 0; dst_i < end_i; dst_i++, src_i++) {
273 right_word = (digit[src_i] ^ DIGIT_MASK) + carry;
274 dst_p[dst_i] = right_word & DIGIT_MASK;
275 carry = right_word >> BITS_PER_DIGIT;
276 }
277 high_i = high_i % BITS_PER_DIGIT;
278 mask = (~(~1U << high_i)) & DIGIT_MASK;
279 right_word = (src_i < ndigits) ?
280 (digit[src_i] ^ DIGIT_MASK) + carry : DIGIT_MASK + carry;
281 dst_p[dst_i] = right_word & mask;
282
283 // DATA IS IN MORE THAN ONE WORD, AND NOT WORD ALIGNED:
284 } else {
285 high_i = high_i % BITS_PER_DIGIT;
286 right_shift = BITS_PER_DIGIT - left_shift;
287 mask = ~(~0U << left_shift);
288 carry = 1;
289 right_word = (digit[0] ^ DIGIT_MASK) + carry;
290 dst_p[dst_i] = (dst_p[dst_i] & mask) |
291 ((right_word << left_shift) & DIGIT_MASK);
292 carry = right_word >> BITS_PER_DIGIT;
293 right_word &= DIGIT_MASK;
294 for (src_i = 1, dst_i++; dst_i < end_i; dst_i++, src_i++) {
295 left_word = (digit[src_i] ^ DIGIT_MASK) + carry;
296 dst_p[dst_i] = ((left_word << left_shift)&DIGIT_MASK) |
297 (right_word >> right_shift);
298 carry = left_word >> BITS_PER_DIGIT;
299 right_word = left_word & DIGIT_MASK;
300 }
301 left_word = (src_i < ndigits) ?
302 (digit[src_i] ^ DIGIT_MASK) + carry : carry;
303 mask = ~(~1U << high_i) & DIGIT_MASK;
304 dst_p[dst_i] = ((left_word << left_shift) |
305 (right_word >> right_shift)) & mask;
306 }
307 break;
308 // VALUE IS ZERO:
309 default:
310 result = false;
311 // ALL DATA TO BE MOVED IS IN A SINGLE WORD:
312 if (dst_i == end_i) {
313 mask = ~(~0U << real_bits) << left_shift;
314 dst_p[dst_i] = dst_p[dst_i] & ~mask;
315
316 // DATA IS IN MORE THAN ONE WORD, BUT IS WORD ALIGNED:
317
318 } else if (left_shift == 0) {
319 for (src_i = 0; dst_i < end_i; dst_i++, src_i++) {
320 dst_p[dst_i] = 0;
321 }
322 dst_p[dst_i] = 0;
323
324 // DATA IS IN MORE THAN ONE WORD, AND NOT WORD ALIGNED:
325 } else {
326 mask = ~(~0U << left_shift);
327 dst_p[dst_i] = (dst_p[dst_i] & mask);
328 for (dst_i++; dst_i <= end_i; dst_i++) {
329 dst_p[dst_i] = 0;
330 }
331 }
332 break;
333 }
334 return result;
335}
336
337// Return this object instance's bits as a uint64 without sign extension.
338uint64
339sc_unsigned::concat_get_uint64() const
340{
341 uint64 result;
342
343 switch (sgn) {
344 case SC_POS:
345 result = 0;
346 if (ndigits > 2)
347 result = digit[2];
348 if (ndigits > 1)
349 result = (result << BITS_PER_DIGIT) | digit[1];
350 result = (result << BITS_PER_DIGIT) | digit[0];
351 break;
352 default:
353 result = 0;
354 break;
355 }
356 return result;
357}
358
359// #### OPTIMIZE
360void
361sc_unsigned::concat_set(int64 src, int low_i)
362{
363 *this = (low_i < 64) ? src >> low_i : src >> 63;
364}
365
366void
367sc_unsigned::concat_set(const sc_signed &src, int low_i)
368{
369 if (low_i < src.length())
370 *this = src >> low_i;
371 else
372 *this = (src < 0) ? (int_type)-1 : 0;
373}
374
375void
376sc_unsigned::concat_set(const sc_unsigned &src, int low_i)
377{
378 if (low_i < src.length())
379 *this = src >> low_i;
380 else
381 *this = 0;
382}
383
384void
385sc_unsigned::concat_set(uint64 src, int low_i)
386{
387 *this = (low_i < 64) ? src >> low_i : 0;
388}
389
390
391// ----------------------------------------------------------------------------
392// SECTION: Public members - Reduction methods.
393// ----------------------------------------------------------------------------
394
395bool
396sc_unsigned::and_reduce() const
397{
398 int i; // Digit examining.
399
400 if (sgn == SC_ZERO)
401 return false;
402 for (i = 0; i < ndigits - 1; i++)
403 if ((digit[i] & DIGIT_MASK) != DIGIT_MASK)
404 return false;
405 if ((digit[i] & ~(~0U << ((nbits - 1) % BITS_PER_DIGIT))) ==
406 static_cast<sc_digit>(~(~0U << ((nbits - 1) % BITS_PER_DIGIT)))) {
407 return true;
408 }
409 return false;
410}
411
412bool
413sc_unsigned::or_reduce() const
414{
415 return (sgn == SC_ZERO) ? false : true;
416}
417
418bool
419sc_unsigned::xor_reduce() const
420{
421 int i; // Digit examining.
422 int odd; // Flag for odd number of digits.
423
424 odd = 0;
425 for (i = 0; i < nbits - 1; i++)
426 if (test(i))
427 odd = ~odd;
428 return odd ? true : false;
429}
430
431
432// ----------------------------------------------------------------------------
433// SECTION: Public members - Assignment operators.
434// ----------------------------------------------------------------------------
435
436// assignment operators
437const sc_unsigned &
438sc_unsigned::operator = (const char *a)
439{
440 if (a == 0) {
441 SC_REPORT_ERROR("conversion failed",
442 "character string is zero");
443 } else if (*a == 0) {
444 SC_REPORT_ERROR("conversion failed",
445 "character string is empty");
446 } else try {
447 int len = length();
448 sc_ufix aa(a, len, len, SC_TRN, SC_WRAP, 0, SC_ON);
449 return this->operator = (aa);
450 } catch(const sc_core::sc_report &) {
451 std::stringstream msg;
452 msg << "character string '" << a << "' is not valid";
453 SC_REPORT_ERROR("conversion failed", msg.str().c_str());
454 }
455 return *this;
456}
457
458const sc_unsigned &
459sc_unsigned::operator = (int64 v)
460{
461 sgn = get_sign(v);
462 if (sgn == SC_ZERO) {
463 vec_zero(ndigits, digit);
464 } else {
465 from_uint(ndigits, digit, (uint64) v);
466 convert_SM_to_2C_to_SM();
467 }
468 return *this;
469}
470
471const sc_unsigned &
472sc_unsigned::operator = (uint64 v)
473{
474 if (v == 0) {
475 sgn = SC_ZERO;
476 vec_zero(ndigits, digit);
477 } else {
478 sgn = SC_POS;
479 from_uint(ndigits, digit, v);
480 convert_SM_to_2C_to_SM();
481 }
482 return *this;
483}
484
485const sc_unsigned &
486sc_unsigned::operator = (long v)
487{
488 sgn = get_sign(v);
489 if (sgn == SC_ZERO) {
490 vec_zero(ndigits, digit);
491 } else {
492 from_uint(ndigits, digit, (unsigned long)v);
493 convert_SM_to_2C_to_SM();
494 }
495 return *this;
496}
497
498const sc_unsigned &
499sc_unsigned::operator = (unsigned long v)
500{
501 if (v == 0) {
502 sgn = SC_ZERO;
503 vec_zero(ndigits, digit);
504 } else {
505 sgn = SC_POS;
506 from_uint(ndigits, digit, v);
507 convert_SM_to_2C_to_SM();
508 }
509 return *this;
510}
511
512const sc_unsigned &
513sc_unsigned::operator = (double v)
514{
515 is_bad_double(v);
516 sgn = SC_POS;
517 int i = 0;
518 while (std::floor(v) && (i < ndigits)) {
519 digit[i++] = ((sc_digit)std::floor(remainder(v, DIGIT_RADIX))) &
520 DIGIT_MASK;
521 v /= DIGIT_RADIX;
522 }
523 vec_zero(i, ndigits, digit);
524 convert_SM_to_2C_to_SM();
525 return *this;
526}
527
528
529// ----------------------------------------------------------------------------
530
531const sc_unsigned &
532sc_unsigned::operator = (const sc_bv_base &v)
533{
534 int minlen = sc_min(nbits, v.length());
535 int i = 0;
536 for (; i < minlen; ++i) {
537 safe_set(i, v.get_bit(i), digit);
538 }
539 for (; i < nbits; ++i) {
540 safe_set(i, 0, digit); // zero-extend
541 }
542 convert_2C_to_SM();
543 return *this;
544}
545
546const sc_unsigned &
547sc_unsigned::operator = (const sc_lv_base &v)
548{
549 int minlen = sc_min(nbits, v.length());
550 int i = 0;
551 for (; i < minlen; ++i) {
552 safe_set(i, sc_logic(v.get_bit(i)).to_bool(), digit);
553 }
554 for (; i < nbits; ++i) {
555 safe_set(i, 0, digit); // zero-extend
556 }
557 convert_2C_to_SM();
558 return *this;
559}
560
561
562// explicit conversion to character string
563const std::string
564sc_unsigned::to_string(sc_numrep numrep) const
565{
566 int len = length();
567 sc_ufix aa(*this, len, len, SC_TRN, SC_WRAP, 0, SC_ON);
568 return aa.to_string(numrep);
569}
570
571const std::string
572sc_unsigned::to_string(sc_numrep numrep, bool w_prefix) const
573{
574 int len = length();
575 sc_ufix aa(*this, len, len, SC_TRN, SC_WRAP, 0, SC_ON);
576 return aa.to_string(numrep, w_prefix);
577}
578
579
580// ----------------------------------------------------------------------------
581// SECTION: Interfacing with sc_int_base
582// ----------------------------------------------------------------------------
583
584const sc_unsigned &
585sc_unsigned::operator = (const sc_int_base &v)
586{
587 return operator = ((int64)v);
588}
589
590const sc_unsigned &
591sc_unsigned::operator += (const sc_int_base &v)
592{
593 return operator += ((int64)v);
594}
595
596const sc_unsigned &
597sc_unsigned::operator -= (const sc_int_base &v)
598{
599 return operator -= ((int64)v);
600}
601
602const sc_unsigned &
603sc_unsigned::operator *= (const sc_int_base &v)
604{
605 return operator *= ((int64)v);
606}
607
608const sc_unsigned &
609sc_unsigned::operator /= (const sc_int_base &v)
610{
611 return operator /= ((int64)v);
612}
613
614const sc_unsigned &
615sc_unsigned::operator %= (const sc_int_base &v)
616{
617 return operator %= ((int64)v);
618}
619
620const sc_unsigned &
621sc_unsigned::operator &= (const sc_int_base &v)
622{
623 return operator &= ((int64)v);
624}
625
626const sc_unsigned &
627sc_unsigned::operator |= (const sc_int_base &v)
628{
629 return operator |= ((int64)v);
630}
631
632const sc_unsigned &
633sc_unsigned::operator ^= (const sc_int_base &v)
634{
635 return operator ^= ((int64)v);
636}
637
638sc_unsigned
639operator << (const sc_unsigned &u, const sc_int_base &v)
640{
641 return operator << (u, (int64)v);
642}
643const sc_unsigned &
644sc_unsigned::operator <<= (const sc_int_base &v)
645{
646 return operator <<= ((int64)v);
647}
648
649sc_unsigned
650operator >> (const sc_unsigned& u, const sc_int_base& v)
651{
652 return operator >> (u, (int64)v);
653}
654const sc_unsigned &
655sc_unsigned::operator >>= (const sc_int_base& v)
656{
657 return operator >>= ((int64)v);
658}
659
660bool
661operator == (const sc_unsigned &u, const sc_int_base &v)
662{
663 return operator == (u, (int64)v);
664}
665bool
666operator == (const sc_int_base &u, const sc_unsigned &v)
667{
668 return operator == ((int64)u, v);
669}
670
671bool
672operator != (const sc_unsigned &u, const sc_int_base &v)
673{
674 return operator != (u, (int64)v);
675}
676bool
677operator != (const sc_int_base &u, const sc_unsigned &v)
678{
679 return operator != ((int64)u, v);
680}
681
682bool
683operator < (const sc_unsigned &u, const sc_int_base &v)
684{
685 return operator < (u, (int64)v);
686}
687bool
688operator < (const sc_int_base &u, const sc_unsigned &v)
689{
690 return operator < ((int64)u, v);
691}
692
693bool
694operator <= (const sc_unsigned &u, const sc_int_base &v)
695{
696 return operator <= (u, (int64)v);
697}
698bool
699operator <= (const sc_int_base &u, const sc_unsigned &v)
700{
701 return operator <= ((int64)u, v);
702}
703
704bool
705operator > (const sc_unsigned &u, const sc_int_base &v)
706{
707 return operator > (u, (int64)v);
708}
709bool
710operator > (const sc_int_base &u, const sc_unsigned &v)
711{
712 return operator > ((int64)u, v);
713}
714
715bool
716operator >= (const sc_unsigned &u, const sc_int_base &v)
717{
718 return operator >= (u, (int64)v);
719}
720bool
721operator >= (const sc_int_base &u, const sc_unsigned &v)
722{
723 return operator >= ((int64)u, v);
724}
725
726
727// ----------------------------------------------------------------------------
728// SECTION: Interfacing with sc_uint_base
729// ----------------------------------------------------------------------------
730
731const sc_unsigned &
732sc_unsigned::operator = (const sc_uint_base &v)
733{
734 return operator = ((uint64)v);
735}
736
737sc_unsigned
738operator + (const sc_unsigned &u, const sc_uint_base &v)
739{
740 return operator + (u, (uint64)v);
741}
742sc_unsigned
743operator + (const sc_uint_base &u, const sc_unsigned &v)
744{
745 return operator + ((uint64)u, v);
746}
747const sc_unsigned &
748sc_unsigned::operator += (const sc_uint_base &v)
749{
750 return operator += ((uint64)v);
751}
752
753const sc_unsigned &
754sc_unsigned::operator -= (const sc_uint_base &v)
755{
756 return operator -= ((uint64)v);
757}
758
759sc_unsigned
760operator * (const sc_unsigned &u, const sc_uint_base &v)
761{
762 return operator * (u, (uint64)v);
763}
764sc_unsigned
765operator * (const sc_uint_base &u, const sc_unsigned &v)
766{
767 return operator * ((uint64)u, v);
768}
769const sc_unsigned &
770sc_unsigned::operator *= (const sc_uint_base &v)
771{
772 return operator *= ((uint64)v);
773}
774
775sc_unsigned
776operator / (const sc_unsigned &u, const sc_uint_base &v)
777{
778 return operator / (u, (uint64)v);
779}
780sc_unsigned
781operator / (const sc_uint_base &u, const sc_unsigned &v)
782{
783 return operator / ((uint64)u, v);
784}
785const sc_unsigned &
786sc_unsigned::operator /= (const sc_uint_base &v)
787{
788 return operator /= ((uint64)v);
789}
790
791sc_unsigned
792operator % (const sc_unsigned &u, const sc_uint_base &v)
793{
794 return operator % (u, (uint64)v);
795}
796sc_unsigned
797operator % (const sc_uint_base &u, const sc_unsigned &v)
798{
799 return operator % ((uint64)u, v);
800}
801const sc_unsigned &
802sc_unsigned::operator %= (const sc_uint_base &v)
803{
804 return operator %= ((uint64)v);
805}
806
807sc_unsigned
808operator & (const sc_unsigned &u, const sc_uint_base &v)
809{
810 return operator & (u, (uint64)v);
811}
812sc_unsigned
813operator & (const sc_uint_base &u, const sc_unsigned &v)
814{
815 return operator & ((uint64)u, v);
816}
817const sc_unsigned &
818sc_unsigned::operator &= (const sc_uint_base &v)
819{
820 return operator &= ((uint64)v);
821}
822
823sc_unsigned
824operator | (const sc_unsigned &u, const sc_uint_base &v)
825{
826 return operator | (u, (uint64)v);
827}
828sc_unsigned
829operator | (const sc_uint_base &u, const sc_unsigned &v)
830{
831 return operator | ((uint64)u, v);
832}
833const sc_unsigned &
834sc_unsigned::operator |= (const sc_uint_base &v)
835{
836 return operator |= ((uint64)v);
837}
838
839sc_unsigned
840operator ^ (const sc_unsigned &u, const sc_uint_base &v)
841{
842 return operator ^ (u, (uint64)v);
843}
844sc_unsigned
845operator ^ (const sc_uint_base &u, const sc_unsigned &v)
846{
847 return operator ^ ((uint64)u, v);
848}
849const sc_unsigned &
850sc_unsigned::operator ^= (const sc_uint_base &v)
851{
852 return operator ^= ((uint64)v);
853}
854
855sc_unsigned
856operator << (const sc_unsigned &u, const sc_uint_base &v)
857{
858 return operator << (u, (uint64)v);
859}
860const sc_unsigned &
861sc_unsigned::operator <<= (const sc_uint_base &v)
862{
863 return operator <<= ((uint64)v);
864}
865
866sc_unsigned
867operator >> (const sc_unsigned &u, const sc_uint_base &v)
868{
869 return operator >> (u, (uint64)v);
870}
871const sc_unsigned &
872sc_unsigned::operator >>= (const sc_uint_base &v)
873{
874 return operator >>= ((uint64)v);
875}
876
877bool
878operator == (const sc_unsigned &u, const sc_uint_base &v)
879{
880 return operator == (u, (uint64)v);
881}
882bool
883operator == (const sc_uint_base &u, const sc_unsigned &v)
884{
885 return operator == ((uint64)u, v);
886}
887
888bool
889operator != (const sc_unsigned &u, const sc_uint_base &v)
890{
891 return operator != (u, (uint64)v);
892}
893bool
894operator != (const sc_uint_base &u, const sc_unsigned &v)
895{
896 return operator != ((uint64)u, v);
897}
898
899bool
900operator < (const sc_unsigned &u, const sc_uint_base &v)
901{
902 return operator < (u, (uint64)v);
903}
904bool
905operator < (const sc_uint_base &u, const sc_unsigned &v)
906{
907 return operator < ((uint64)u, v);
908}
909
910bool
911operator <= (const sc_unsigned &u, const sc_uint_base &v)
912{
913 return operator <= (u, (uint64)v);
914}
915bool
916operator <= (const sc_uint_base &u, const sc_unsigned &v)
917{
918 return operator <= ((uint64)u, v);
919}
920
921bool
922operator > (const sc_unsigned &u, const sc_uint_base &v)
923{
924 return operator > (u, (uint64)v);
925}
926bool
927operator > (const sc_uint_base &u, const sc_unsigned &v)
928{
929 return operator > ((uint64)u, v);
930}
931
932bool
933operator >= (const sc_unsigned &u, const sc_uint_base &v)
934{
935 return operator >= (u, (uint64)v);
936}
937bool
938operator >= (const sc_uint_base &u, const sc_unsigned &v)
939{
940 return operator >= ((uint64)u, v);
941}
942
943
944// ----------------------------------------------------------------------------
945// SECTION: Input and output operators
946// ----------------------------------------------------------------------------
947
948// The operators in this section are included from sc_nbcommon.cpp.
949
950
951// ----------------------------------------------------------------------------
952// SECTION: Operator macros.
953// ----------------------------------------------------------------------------
954
955#define CONVERT_LONG(u) \
956small_type u ## s = get_sign(u); \
957sc_digit u ## d[DIGITS_PER_ULONG]; \
958from_uint(DIGITS_PER_ULONG, u ## d, (unsigned long) u);
959
960#define CONVERT_LONG_2(u) \
961sc_digit u ## d[DIGITS_PER_ULONG]; \
962from_uint(DIGITS_PER_ULONG, u ## d, (unsigned long) u);
963
964#define CONVERT_INT(u) \
965small_type u ## s = get_sign(u); \
966sc_digit u ## d[DIGITS_PER_UINT]; \
967from_uint(DIGITS_PER_UINT, u ## d, (unsigned int) u);
968
969#define CONVERT_INT_2(u) \
970sc_digit u ## d[DIGITS_PER_UINT]; \
971from_uint(DIGITS_PER_UINT, u ## d, (unsigned int) u);
972
973#define CONVERT_INT64(u) \
974small_type u ## s = get_sign(u); \
975sc_digit u ## d[DIGITS_PER_UINT64]; \
976from_uint(DIGITS_PER_UINT64, u ## d, (uint64) u);
977
978#define CONVERT_INT64_2(u) \
979sc_digit u ## d[DIGITS_PER_UINT64]; \
980from_uint(DIGITS_PER_UINT64, u ## d, (uint64) u);
981
982
983// ----------------------------------------------------------------------------
984// SECTION: PLUS operators: +, +=, ++
985// ----------------------------------------------------------------------------
986
987// Cases to consider when computing u + v:
988// 1. 0 + v = v
989// 2. u + 0 = u
990// 3. if sgn(u) == sgn(v)
991// 3.1 u + v = +(u + v) = sgn(u) * (u + v)
992// 3.2 (-u) + (-v) = -(u + v) = sgn(u) * (u + v)
993// 4. if sgn(u) != sgn(v)
994// 4.1 u + (-v) = u - v = sgn(u) * (u - v)
995// 4.2 (-u) + v = -(u - v) ==> sgn(u) * (u - v)
996//
997// Specialization of above cases for computing ++u or u++:
998// 1. 0 + 1 = 1
999// 3. u + 1 = u + 1 = sgn(u) * (u + 1)
1000// 4. (-u) + 1 = -(u - 1) = sgn(u) * (u - 1)
1001
1002sc_unsigned
1003operator + (const sc_unsigned &u, const sc_unsigned &v)
1004{
1005 if (u.sgn == SC_ZERO) // case 1
1006 return sc_unsigned(v);
1007
1008 if (v.sgn == SC_ZERO) // case 2
1009 return sc_unsigned(u);
1010
1011 // cases 3 and 4
1012 return add_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1013 v.sgn, v.nbits, v.ndigits, v.digit);
1014}
1015
1016
1017sc_unsigned
1018operator + (const sc_unsigned &u, uint64 v)
1019{
1020 if (v == 0) // case 2
1021 return sc_unsigned(u);
1022
1023 CONVERT_INT64(v);
1024
1025 if (u.sgn == SC_ZERO) // case 1
1026 return sc_unsigned(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
1027
1028 // cases 3 and 4
1029 return add_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1030 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1031}
1032
1033
1034sc_unsigned
1035operator + (uint64 u, const sc_unsigned &v)
1036{
1037 if (u == 0) // case 1
1038 return sc_unsigned(v);
1039
1040 CONVERT_INT64(u);
1041
1042 if (v.sgn == SC_ZERO) // case 2
1043 return sc_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
1044
1045 // cases 3 and 4
1046 return add_unsigned_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
1047 v.sgn, v.nbits, v.ndigits, v.digit);
1048}
1049
1050
1051sc_unsigned
1052operator + (const sc_unsigned &u, unsigned long v)
1053{
1054 if (v == 0) // case 2
1055 return sc_unsigned(u);
1056
1057 CONVERT_LONG(v);
1058
1059 if (u.sgn == SC_ZERO) // case 1
1060 return sc_unsigned(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
1061
1062 // cases 3 and 4
1063 return add_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1064 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1065}
1066
1067
1068sc_unsigned
1069operator + (unsigned long u, const sc_unsigned &v)
1070{
1071 if (u == 0) // case 1
1072 return sc_unsigned(v);
1073
1074 CONVERT_LONG(u);
1075
1076 if (v.sgn == SC_ZERO) // case 2
1077 return sc_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
1078
1079 // cases 3 and 4
1080 return add_unsigned_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
1081 v.sgn, v.nbits, v.ndigits, v.digit);
1082}
1083
1084// The rest of the operators in this section are included from
1085// sc_nbcommon.cpp.
1086
1087
1088// ----------------------------------------------------------------------------
1089// SECTION: MINUS operators: -, -=, --
1090// ----------------------------------------------------------------------------
1091
1092// Cases to consider when computing u + v:
1093// 1. u - 0 = u
1094// 2. 0 - v = -v
1095// 3. if sgn(u) != sgn(v)
1096// 3.1 u - (-v) = u + v = sgn(u) * (u + v)
1097// 3.2 (-u) - v = -(u + v) ==> sgn(u) * (u + v)
1098// 4. if sgn(u) == sgn(v)
1099// 4.1 u - v = +(u - v) = sgn(u) * (u - v)
1100// 4.2 (-u) - (-v) = -(u - v) = sgn(u) * (u - v)
1101//
1102// Specialization of above cases for computing --u or u--:
1103// 1. 0 - 1 = -1
1104// 3. (-u) - 1 = -(u + 1) = sgn(u) * (u + 1)
1105// 4. u - 1 = u - 1 = sgn(u) * (u - 1)
1106
1107// The operators in this section are included from sc_nbcommon.cpp.
1108
1109
1110// ----------------------------------------------------------------------------
1111// SECTION: MULTIPLICATION operators: *, *=
1112// ----------------------------------------------------------------------------
1113
1114// Cases to consider when computing u * v:
1115// 1. u * 0 = 0 * v = 0
1116// 2. 1 * v = v and -1 * v = -v
1117// 3. u * 1 = u and u * -1 = -u
1118// 4. u * v = u * v
1119
1120sc_unsigned
1121operator * (const sc_unsigned &u, const sc_unsigned &v)
1122{
1123 small_type s = mul_signs(u.sgn, v.sgn);
1124
1125 if (s == SC_ZERO) // case 1
1126 return sc_unsigned();
1127
1128 // cases 2-4
1129 return mul_unsigned_friend(s, u.nbits, u.ndigits, u.digit,
1130 v.nbits, v.ndigits, v.digit);
1131}
1132
1133
1134sc_unsigned
1135operator * (const sc_unsigned &u, uint64 v)
1136{
1137 small_type s = mul_signs(u.sgn, get_sign(v));
1138
1139 if (s == SC_ZERO) // case 1
1140 return sc_unsigned();
1141
1142 CONVERT_INT64_2(v);
1143
1144 // cases 2-4
1145 return mul_unsigned_friend(s, u.nbits, u.ndigits, u.digit,
1146 BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1147}
1148
1149
1150sc_unsigned
1151operator * (uint64 u, const sc_unsigned &v)
1152{
1153 small_type s = mul_signs(v.sgn, get_sign(u));
1154
1155 if (s == SC_ZERO) // case 1
1156 return sc_unsigned();
1157
1158 CONVERT_INT64_2(u);
1159
1160 // cases 2-4
1161 return mul_unsigned_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
1162 v.nbits, v.ndigits, v.digit);
1163}
1164
1165
1166sc_unsigned
1167operator * (const sc_unsigned &u, unsigned long v)
1168{
1169 small_type s = mul_signs(u.sgn, get_sign(v));
1170
1171 if (s == SC_ZERO) // case 1
1172 return sc_unsigned();
1173
1174 CONVERT_LONG_2(v);
1175
1176 // else cases 2-4
1177 return mul_unsigned_friend(s, u.nbits, u.ndigits, u.digit,
1178 BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1179}
1180
1181sc_unsigned
1182operator * (unsigned long u, const sc_unsigned &v)
1183{
1184 small_type s = mul_signs(v.sgn, get_sign(u));
1185
1186 if (s == SC_ZERO) // case 1
1187 return sc_unsigned();
1188
1189 CONVERT_LONG_2(u);
1190
1191 // cases 2-4
1192 return mul_unsigned_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
1193 v.nbits, v.ndigits, v.digit);
1194}
1195
1196// The rest of the operators in this section are included from
1197// sc_nbcommon.cpp.
1198
1199
1200// ----------------------------------------------------------------------------
1201// SECTION: DIVISION operators: /, /=
1202// ----------------------------------------------------------------------------
1203
1204// Cases to consider when finding the quotient q = floor(u/v):
1205// Note that u = q * v + r for r < q.
1206// 1. 0 / 0 or u / 0 => error
1207// 2. 0 / v => 0 = 0 * v + 0
1208// 3. u / v & &u = v => u = 1 * u + 0 - u or v can be 1 or -1
1209// 4. u / v & &u < v => u = 0 * v + u - u can be 1 or -1
1210// 5. u / v & &u > v => u = q * v + r - v can be 1 or -1
1211
1212sc_unsigned
1213operator / (const sc_unsigned &u, const sc_unsigned &v)
1214{
1215 small_type s = mul_signs(u.sgn, v.sgn);
1216
1217 if (s == SC_ZERO) {
1218 div_by_zero(v.sgn); // case 1
1219 return sc_unsigned(); // case 2
1220 }
1221
1222 // other cases
1223 return div_unsigned_friend(s, u.nbits, u.ndigits, u.digit,
1224 v.nbits, v.ndigits, v.digit);
1225}
1226
1227
1228sc_unsigned
1229operator / (const sc_unsigned &u, uint64 v)
1230{
1231 small_type s = mul_signs(u.sgn, get_sign(v));
1232
1233 if (s == SC_ZERO) {
1234 div_by_zero(v); // case 1
1235 return sc_unsigned(); // case 2
1236 }
1237
1238 CONVERT_INT64_2(v);
1239
1240 // other cases
1241 return div_unsigned_friend(s, u.nbits, u.ndigits, u.digit,
1242 BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1243}
1244
1245
1246sc_unsigned
1247operator / (uint64 u, const sc_unsigned &v)
1248{
1249 small_type s = mul_signs(v.sgn, get_sign(u));
1250
1251 if (s == SC_ZERO) {
1252 div_by_zero(v.sgn); // case 1
1253 return sc_unsigned(); // case 2
1254
1255 }
1256
1257 CONVERT_INT64_2(u);
1258
1259 // other cases
1260 return div_unsigned_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
1261 v.nbits, v.ndigits, v.digit);
1262}
1263
1264
1265sc_unsigned
1266operator / (const sc_unsigned &u, unsigned long v)
1267{
1268 small_type s = mul_signs(u.sgn, get_sign(v));
1269
1270 if (s == SC_ZERO) {
1271 div_by_zero(v); // case 1
1272 return sc_unsigned(); // case 2
1273 }
1274
1275 CONVERT_LONG_2(v);
1276
1277 // other cases
1278 return div_unsigned_friend(s, u.nbits, u.ndigits, u.digit,
1279 BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1280}
1281
1282
1283sc_unsigned
1284operator / (unsigned long u, const sc_unsigned &v)
1285{
1286 small_type s = mul_signs(v.sgn, get_sign(u));
1287
1288 if (s == SC_ZERO) {
1289 div_by_zero(v.sgn); // case 1
1290 return sc_unsigned(); // case 2
1291
1292 }
1293
1294 CONVERT_LONG_2(u);
1295
1296 // other cases
1297 return div_unsigned_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
1298 v.nbits, v.ndigits, v.digit);
1299}
1300
1301// The rest of the operators in this section are included from
1302// sc_nbcommon.cpp.
1303
1304
1305// ----------------------------------------------------------------------------
1306// SECTION: MOD operators: %, %=.
1307// ----------------------------------------------------------------------------
1308
1309// Cases to consider when finding the remainder r = u % v:
1310// Note that u = q * v + r for r < q.
1311// 1. 0 % 0 or u % 0 => error
1312// 2. 0 % v => 0 = 0 * v + 0
1313// 3. u % v & &u = v => u = 1 * u + 0 - u or v can be 1 or -1
1314// 4. u % v & &u < v => u = 0 * v + u - u can be 1 or -1
1315// 5. u % v & &u > v => u = q * v + r - v can be 1 or -1
1316
1317sc_unsigned
1318operator % (const sc_unsigned &u, const sc_unsigned &v)
1319{
1320 if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) {
1321 div_by_zero(v.sgn); // case 1
1322 return sc_unsigned(); // case 2
1323 }
1324
1325 // other cases
1326 return mod_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1327 v.nbits, v.ndigits, v.digit);
1328}
1329
1330
1331sc_unsigned
1332operator % (const sc_unsigned &u, uint64 v)
1333{
1334 if ((u.sgn == SC_ZERO) || (v == 0)) {
1335 div_by_zero(v); // case 1
1336 return sc_unsigned(); // case 2
1337 }
1338
1339 CONVERT_INT64_2(v);
1340
1341 // other cases
1342 return mod_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1343 BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1344
1345}
1346
1347
1348sc_unsigned
1349operator % (uint64 u, const sc_unsigned &v)
1350{
1351 if ((u == 0) || (v.sgn == SC_ZERO)) {
1352 div_by_zero(v.sgn); // case 1
1353 return sc_unsigned(); // case 2
1354 }
1355
1356 CONVERT_INT64(u);
1357
1358 // other cases
1359 return mod_unsigned_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
1360 v.nbits, v.ndigits, v.digit);
1361}
1362
1363
1364sc_unsigned
1365operator % (const sc_unsigned &u, unsigned long v)
1366{
1367 if ((u.sgn == SC_ZERO) || (v == 0)) {
1368 div_by_zero(v); // case 1
1369 return sc_unsigned(); // case 2
1370 }
1371
1372 CONVERT_LONG_2(v);
1373
1374 // other cases
1375 return mod_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1376 BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1377}
1378
1379
1380sc_unsigned
1381operator % (unsigned long u, const sc_unsigned &v)
1382{
1383 if ((u == 0) || (v.sgn == SC_ZERO)) {
1384 div_by_zero(v.sgn); // case 1
1385 return sc_unsigned(); // case 2
1386 }
1387
1388 CONVERT_LONG(u);
1389
1390 // other cases
1391 return mod_unsigned_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
1392 v.nbits, v.ndigits, v.digit);
1393}
1394
1395// The rest of the operators in this section are included from
1396// sc_nbcommon.cpp.
1397
1398
1399// ----------------------------------------------------------------------------
1400// SECTION: Bitwise AND operators: &, &=
1401// ----------------------------------------------------------------------------
1402
1403// Cases to consider when computing u &v:
1404// 1. u & 0 = 0 &v = 0
1405// 2. u &v => sgn = +
1406// 3. (-u) & (-v) => sgn = -
1407// 4. u & (-v) => sgn = +
1408// 5. (-u) &v => sgn = +
1409
1410sc_unsigned
1411operator & (const sc_unsigned &u, const sc_unsigned &v)
1412{
1413 if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) // case 1
1414 return sc_unsigned();
1415
1416 // other cases
1417 return and_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1418 v.sgn, v.nbits, v.ndigits, v.digit);
1419}
1420
1421
1422sc_unsigned
1423operator & (const sc_unsigned &u, uint64 v)
1424{
1425 if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
1426 return sc_unsigned();
1427
1428 CONVERT_INT64(v);
1429
1430 // other cases
1431 return and_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1432 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1433}
1434
1435
1436sc_unsigned
1437operator & (uint64 u, const sc_unsigned &v)
1438{
1439 if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
1440 return sc_unsigned();
1441
1442 CONVERT_INT64(u);
1443
1444 // other cases
1445 return and_unsigned_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
1446 v.sgn, v.nbits, v.ndigits, v.digit);
1447}
1448
1449
1450sc_unsigned
1451operator & (const sc_unsigned &u, unsigned long v)
1452{
1453 if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
1454 return sc_unsigned();
1455
1456 CONVERT_LONG(v);
1457
1458 // other cases
1459 return and_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1460 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1461}
1462
1463
1464sc_unsigned
1465operator & (unsigned long u, const sc_unsigned &v)
1466{
1467 if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
1468 return sc_unsigned();
1469
1470 CONVERT_LONG(u);
1471
1472 // other cases
1473 return and_unsigned_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
1474 v.sgn, v.nbits, v.ndigits, v.digit);
1475}
1476
1477// The rest of the operators in this section are included from
1478// sc_nbcommon.cpp.
1479
1480
1481// ----------------------------------------------------------------------------
1482// SECTION: Bitwise OR operators: |, |=
1483// ----------------------------------------------------------------------------
1484
1485// Cases to consider when computing u | v:
1486// 1. u | 0 = u
1487// 2. 0 | v = v
1488// 3. u | v => sgn = +
1489// 4. (-u) | (-v) => sgn = -
1490// 5. u | (-v) => sgn = -
1491// 6. (-u) | v => sgn = -
1492
1493sc_unsigned
1494operator | (const sc_unsigned &u, const sc_unsigned &v)
1495{
1496 if (v.sgn == SC_ZERO) // case 1
1497 return sc_unsigned(u);
1498
1499 if (u.sgn == SC_ZERO) // case 2
1500 return sc_unsigned(v);
1501
1502 // other cases
1503 return or_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1504 v.sgn, v.nbits, v.ndigits, v.digit);
1505}
1506
1507
1508sc_unsigned
1509operator | (const sc_unsigned &u, uint64 v)
1510{
1511 if (v == 0) // case 1
1512 return sc_unsigned(u);
1513
1514 CONVERT_INT64(v);
1515
1516 if (u.sgn == SC_ZERO) // case 2
1517 return sc_unsigned(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
1518
1519 // other cases
1520 return or_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1521 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1522}
1523
1524
1525sc_unsigned
1526operator | (uint64 u, const sc_unsigned &v)
1527{
1528 if (u == 0)
1529 return sc_unsigned(v);
1530
1531 CONVERT_INT64(u);
1532
1533 if (v.sgn == SC_ZERO)
1534 return sc_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
1535
1536 // other cases
1537 return or_unsigned_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
1538 v.sgn, v.nbits, v.ndigits, v.digit);
1539}
1540
1541
1542sc_unsigned
1543operator | (const sc_unsigned &u, unsigned long v)
1544{
1545 if (v == 0) // case 1
1546 return sc_unsigned(u);
1547
1548 CONVERT_LONG(v);
1549
1550 if (u.sgn == SC_ZERO) // case 2
1551 return sc_unsigned(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
1552
1553 // other cases
1554 return or_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1555 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1556}
1557
1558
1559sc_unsigned
1560operator | (unsigned long u, const sc_unsigned &v)
1561{
1562 if (u == 0)
1563 return sc_unsigned(v);
1564
1565 CONVERT_LONG(u);
1566
1567 if (v.sgn == SC_ZERO)
1568 return sc_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
1569
1570 // other cases
1571 return or_unsigned_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
1572 v.sgn, v.nbits, v.ndigits, v.digit);
1573}
1574
1575// The rest of the operators in this section are included from
1576// sc_nbcommon.cpp.
1577
1578
1579// ----------------------------------------------------------------------------
1580// SECTION: Bitwise XOR operators: ^, ^=
1581// ----------------------------------------------------------------------------
1582
1583// Cases to consider when computing u ^ v:
1584// Note that u ^ v = (~u &v) | (u & ~v).
1585// 1. u ^ 0 = u
1586// 2. 0 ^ v = v
1587// 3. u ^ v => sgn = +
1588// 4. (-u) ^ (-v) => sgn = -
1589// 5. u ^ (-v) => sgn = -
1590// 6. (-u) ^ v => sgn = +
1591
1592sc_unsigned
1593operator ^ (const sc_unsigned &u, const sc_unsigned &v)
1594{
1595 if (v.sgn == SC_ZERO) // case 1
1596 return sc_unsigned(u);
1597
1598 if (u.sgn == SC_ZERO) // case 2
1599 return sc_unsigned(v);
1600
1601 // other cases
1602 return xor_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1603 v.sgn, v.nbits, v.ndigits, v.digit);
1604}
1605
1606
1607sc_unsigned
1608operator ^ (const sc_unsigned &u, uint64 v)
1609{
1610 if (v == 0) // case 1
1611 return sc_unsigned(u);
1612
1613 CONVERT_INT64(v);
1614
1615 if (u.sgn == SC_ZERO) // case 2
1616 return sc_unsigned(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
1617
1618 // other cases
1619 return xor_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1620 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1621}
1622
1623sc_unsigned
1624operator ^ (uint64 u, const sc_unsigned &v)
1625{
1626 if (u == 0)
1627 return sc_unsigned(v);
1628
1629 CONVERT_INT64(u);
1630
1631 if (v.sgn == SC_ZERO)
1632 return sc_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
1633
1634 // other cases
1635 return xor_unsigned_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
1636 v.sgn, v.nbits, v.ndigits, v.digit);
1637}
1638
1639
1640sc_unsigned
1641operator ^ (const sc_unsigned &u, unsigned long v)
1642{
1643 if (v == 0) // case 1
1644 return sc_unsigned(u);
1645
1646 CONVERT_LONG(v);
1647
1648 if (u.sgn == SC_ZERO) // case 2
1649 return sc_unsigned(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
1650
1651 // other cases
1652 return xor_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1653 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1654}
1655
1656sc_unsigned
1657operator ^ (unsigned long u, const sc_unsigned &v)
1658{
1659 if (u == 0)
1660 return sc_unsigned(v);
1661
1662 CONVERT_LONG(u);
1663
1664 if (v.sgn == SC_ZERO)
1665 return sc_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
1666
1667 // other cases
1668 return xor_unsigned_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
1669 v.sgn, v.nbits, v.ndigits, v.digit);
1670}
1671
1672// The rest of the operators in this section are included from
1673// sc_nbcommon.cpp.
1674
1675
1676// ----------------------------------------------------------------------------
1677// SECTION: Bitwise NOT operator: ~
1678// ----------------------------------------------------------------------------
1679
1680// Operators in this section are included from sc_nbcommon.cpp.
1681
1682
1683// ----------------------------------------------------------------------------
1684// SECTION: LEFT SHIFT operators: <<, <<=
1685// ----------------------------------------------------------------------------
1686
1687sc_unsigned
1688operator << (const sc_unsigned &u, const sc_signed &v)
1689{
1690 if ((v.sgn == SC_ZERO) || (v.sgn == SC_NEG))
1691 return sc_unsigned(u);
1692
1693 return operator << (u, v.to_ulong());
1694}
1695
1696// The rest of the operators in this section are included from
1697// sc_nbcommon.cpp.
1698
1699
1700// ----------------------------------------------------------------------------
1701// SECTION: RIGHT SHIFT operators: >>, >>=
1702// ----------------------------------------------------------------------------
1703
1704sc_unsigned
1705operator >> (const sc_unsigned &u, const sc_signed &v)
1706{
1707
1708 if ((v.sgn == SC_ZERO) || (v.sgn == SC_NEG))
1709 return sc_unsigned(u);
1710
1711 return operator >> (u, v.to_long());
1712
1713}
1714
1715// The rest of the operators in this section are included from
1716// sc_nbcommon.cpp.
1717
1718
1719// ----------------------------------------------------------------------------
1720// SECTION: Unary arithmetic operators.
1721// ----------------------------------------------------------------------------
1722
1723sc_unsigned
1724operator + (const sc_unsigned &u)
1725{
1726 return sc_unsigned(u);
1727}
1728
1729
1730// ----------------------------------------------------------------------------
1731// SECTION: EQUAL operator: ==
1732// ----------------------------------------------------------------------------
1733
1734bool
1735operator == (const sc_unsigned &u, const sc_unsigned &v)
1736{
1737 if (&u == &v)
1738 return true;
1739 if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
1740 v.sgn, v.nbits, v.ndigits, v.digit) != 0) {
1741 return false;
1742 }
1743 return true;
1744}
1745
1746
1747bool
1748operator == (const sc_unsigned &u, const sc_signed &v)
1749{
1750 if (v.sgn == SC_NEG)
1751 return false;
1752 if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
1753 v.sgn, v.nbits, v.ndigits, v.digit, 0, 1) != 0) {
1754 return false;
1755 }
1756 return true;
1757}
1758
1759
1760bool
1761operator == (const sc_signed &u, const sc_unsigned &v)
1762{
1763 if (u.sgn == SC_NEG)
1764 return false;
1765 if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
1766 v.sgn, v.nbits, v.ndigits, v.digit, 1, 0) != 0) {
1767 return false;
1768 }
1769 return true;
1770}
1771
1772
1773bool
1774operator == (const sc_unsigned &u, int64 v)
1775{
1776 if (v < 0)
1777 return false;
1778 CONVERT_INT64(v);
1779 if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
1780 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd) != 0) {
1781 return false;
1782 }
1783 return true;
1784}
1785
1786
1787bool
1788operator == (int64 u, const sc_unsigned &v)
1789{
1790 if (u < 0)
1791 return false;
1792 CONVERT_INT64(u);
1793 if (compare_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
1794 v.sgn, v.nbits, v.ndigits, v.digit) != 0) {
1795 return false;
1796 }
1797 return true;
1798}
1799
1800
1801bool
1802operator == (const sc_unsigned &u, uint64 v)
1803{
1804 CONVERT_INT64(v);
1805 if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
1806 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd) != 0)
1807 return false;
1808 return true;
1809}
1810
1811
1812bool
1813operator == (uint64 u, const sc_unsigned &v)
1814{
1815 CONVERT_INT64(u);
1816 if (compare_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
1817 v.sgn, v.nbits, v.ndigits, v.digit) != 0)
1818 return false;
1819 return true;
1820}
1821
1822
1823bool
1824operator == (const sc_unsigned &u, long v)
1825{
1826 if (v < 0)
1827 return false;
1828 CONVERT_LONG(v);
1829 if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
1830 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd) != 0)
1831 return false;
1832 return true;
1833}
1834
1835
1836bool
1837operator == (long u, const sc_unsigned &v)
1838{
1839 if (u < 0)
1840 return false;
1841 CONVERT_LONG(u);
1842 if (compare_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
1843 v.sgn, v.nbits, v.ndigits, v.digit) != 0)
1844 return false;
1845 return true;
1846}
1847
1848
1849bool
1850operator == (const sc_unsigned &u, unsigned long v)
1851{
1852 CONVERT_LONG(v);
1853 if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
1854 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd) != 0)
1855 return false;
1856 return true;
1857}
1858
1859
1860bool
1861operator == (unsigned long u, const sc_unsigned &v)
1862{
1863 CONVERT_LONG(u);
1864 if (compare_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
1865 v.sgn, v.nbits, v.ndigits, v.digit) != 0)
1866 return false;
1867 return true;
1868}
1869
1870
1871// ----------------------------------------------------------------------------
1872// SECTION: NOT_EQUAL operator: !=
1873// ----------------------------------------------------------------------------
1874
1875bool
1876operator != (const sc_unsigned &u, const sc_signed &v)
1877{
1878 return (!operator == (u, v));
1879}
1880
1881
1882bool
1883operator != (const sc_signed &u, const sc_unsigned &v)
1884{
1885 return (!operator == (u, v));
1886}
1887
1888// The rest of the operators in this section are included from sc_nbcommon.cpp.
1889
1890
1891// ----------------------------------------------------------------------------
1892// SECTION: LESS THAN operator: <
1893// ----------------------------------------------------------------------------
1894
1895bool
1896operator < (const sc_unsigned &u, const sc_unsigned &v)
1897{
1898 if (&u == &v)
1899 return false;
1900 if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
1901 v.sgn, v.nbits, v.ndigits, v.digit) < 0) {
1902 return true;
1903 }
1904 return false;
1905}
1906
1907
1908bool
1909operator < (const sc_unsigned &u, const sc_signed &v)
1910{
1911 if (v.sgn == SC_NEG)
1912 return false;
1913 if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
1914 v.sgn, v.nbits, v.ndigits, v.digit, 0, 1) < 0) {
1915 return true;
1916 }
1917 return false;
1918}
1919
1920
1921bool
1922operator < (const sc_signed &u, const sc_unsigned &v)
1923{
1924 if (u.sgn == SC_NEG)
1925 return true;
1926 if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
1927 v.sgn, v.nbits, v.ndigits, v.digit, 1, 0) < 0) {
1928 return true;
1929 }
1930 return false;
1931}
1932
1933
1934bool
1935operator < (const sc_unsigned &u, int64 v)
1936{
1937 if (v < 0)
1938 return false;
1939 CONVERT_INT64(v);
1940 if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
1941 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd) < 0) {
1942 return true;
1943 }
1944 return false;
1945}
1946
1947
1948bool
1949operator < (int64 u, const sc_unsigned &v)
1950{
1951 if (u < 0)
1952 return true;
1953 CONVERT_INT64(u);
1954 if (compare_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
1955 v.sgn, v.nbits, v.ndigits, v.digit) < 0) {
1956 return true;
1957 }
1958 return false;
1959}
1960
1961
1962bool
1963operator < (const sc_unsigned &u, uint64 v)
1964{
1965 CONVERT_INT64(v);
1966 if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
1967 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd) < 0) {
1968 return true;
1969 }
1970 return false;
1971}
1972
1973
1974bool
1975operator < (uint64 u, const sc_unsigned &v)
1976{
1977 CONVERT_INT64(u);
1978 if (compare_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
1979 v.sgn, v.nbits, v.ndigits, v.digit) < 0){
1980 return true;
1981 }
1982 return false;
1983}
1984
1985
1986bool
1987operator < (const sc_unsigned &u, long v)
1988{
1989 if (v < 0)
1990 return false;
1991 CONVERT_LONG(v);
1992 if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
1993 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd) < 0) {
1994 return true;
1995 }
1996 return false;
1997}
1998
1999
2000bool
2001operator < (long u, const sc_unsigned &v)
2002{
2003 if (u < 0)
2004 return true;
2005 CONVERT_LONG(u);
2006 if (compare_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
2007 v.sgn, v.nbits, v.ndigits, v.digit) < 0) {
2008 return true;
2009 }
2010 return false;
2011}
2012
2013
2014bool
2015operator < (const sc_unsigned &u, unsigned long v)
2016{
2017 CONVERT_LONG(v);
2018 if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
2019 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd) < 0) {
2020 return true;
2021 }
2022 return false;
2023}
2024
2025
2026bool
2027operator < (unsigned long u, const sc_unsigned &v)
2028{
2029 CONVERT_LONG(u);
2030 if (compare_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
2031 v.sgn, v.nbits, v.ndigits, v.digit) < 0) {
2032 return true;
2033 }
2034 return false;
2035}
2036
2037
2038// ----------------------------------------------------------------------------
2039// SECTION: LESS THAN or EQUAL operator: <=
2040// ----------------------------------------------------------------------------
2041
2042bool
2043operator <= (const sc_unsigned &u, const sc_signed &v)
2044{
2045 return (operator < (u, v) || operator == (u, v));
2046}
2047
2048
2049bool
2050operator <= (const sc_signed &u, const sc_unsigned &v)
2051{
2052 return (operator < (u, v) || operator == (u, v));
2053}
2054
2055// The rest of the operators in this section are included from sc_nbcommon.cpp.
2056
2057
2058// ----------------------------------------------------------------------------
2059// SECTION: GREATER THAN operator: >
2060// ----------------------------------------------------------------------------
2061
2062bool
2063operator > (const sc_unsigned &u, const sc_signed &v)
2064{
2065 return (!(operator <= (u, v)));
2066}
2067
2068
2069bool
2070operator > (const sc_signed &u, const sc_unsigned &v)
2071{
2072 return (!(operator <= (u, v)));
2073}
2074
2075// The rest of the operators in this section are included from sc_nbcommon.cpp.
2076
2077
2078// ----------------------------------------------------------------------------
2079// SECTION: GREATER THAN or EQUAL operator: >=
2080// ----------------------------------------------------------------------------
2081
2082bool
2083operator >= (const sc_unsigned &u, const sc_signed &v)
2084{
2085 return (!(operator < (u, v)));
2086}
2087
2088
2089bool
2090operator >= (const sc_signed &u, const sc_unsigned &v)
2091{
2092 return (!(operator < (u, v)));
2093}
2094
2095// The rest of the operators in this section are included from sc_nbcommon.cpp.
2096
2097
2098// ----------------------------------------------------------------------------
2099// SECTION: Friends
2100// ----------------------------------------------------------------------------
2101
2102// Compare u and v as unsigned and return r
2103// r = 0 if u == v
2104// r < 0 if u < v
2105// r > 0 if u > v
2106
2107int
2108compare_unsigned(small_type us, int unb, int und, const sc_digit *ud,
2109 small_type vs, int vnb, int vnd, const sc_digit *vd,
2110 small_type if_u_signed, small_type if_v_signed)
2111{
2112 if (us == vs) {
2113 if (us == SC_ZERO) {
2114 return 0;
2115 } else {
2116 int cmp_res = vec_skip_and_cmp(und, ud, vnd, vd);
2117 if (us == SC_POS)
2118 return cmp_res;
2119 else
2120 return -cmp_res;
2121 }
2122 } else {
2123 if (us == SC_ZERO)
2124 return -vs;
2125 if (vs == SC_ZERO)
2126 return us;
2127
2128 int cmp_res;
2129 int nd = (us == SC_NEG ? und : vnd);
2130
2131#ifdef SC_MAX_NBITS
2132 sc_digit d[MAX_NDIGITS];
2133#else
2134 sc_digit *d = new sc_digit[nd];
2135#endif
2136
2137 if (us == SC_NEG) {
2138 vec_copy(nd, d, ud);
2139 vec_complement(nd, d);
2140 trim(if_u_signed, unb, nd, d);
2141 cmp_res = vec_skip_and_cmp(nd, d, vnd, vd);
2142 } else {
2143 vec_copy(nd, d, vd);
2144 vec_complement(nd, d);
2145 trim(if_v_signed, vnb, nd, d);
2146 cmp_res = vec_skip_and_cmp(und, ud, nd, d);
2147 }
2148
2149#ifndef SC_MAX_NBITS
2150 delete [] d;
2151#endif
2152
2153 return cmp_res;
2154 }
2155}
2156
2157
2158// ----------------------------------------------------------------------------
2159// SECTION: Public members - Other utils.
2160// ----------------------------------------------------------------------------
2161
2162bool
2163sc_unsigned::iszero() const
2164{
2165 if (sgn == SC_ZERO) {
2166 return true;
2167 } else if (sgn == SC_NEG) {
2168 // A negative unsigned number can be zero, e.g., -16 in 4 bits, so
2169 // check that.
2170
2171#ifdef SC_MAX_NBITS
2172 sc_digit d[MAX_NDIGITS];
2173#else
2174 sc_digit *d = new sc_digit[ndigits];
2175#endif
2176
2177 vec_copy(ndigits, d, digit);
2178 vec_complement(ndigits, d);
2179 trim_unsigned(nbits, ndigits, d);
2180
2181 bool res = check_for_zero(ndigits, d);
2182
2183#ifndef SC_MAX_NBITS
2184 delete [] d;
2185#endif
2186
2187 return res;
2188 } else {
2189 return false;
2190 }
2191}
2192
2193// The rest of the utils in this section are included from sc_nbcommon.cpp.
2194
2195
2196// ----------------------------------------------------------------------------
2197// SECTION: Private members.
2198// ----------------------------------------------------------------------------
2199
2200// The private members in this section are included from
2201// sc_nbcommon.cpp.
2202
2203#define CLASS_TYPE sc_unsigned
2204#define CLASS_TYPE_STR "sc_unsigned"
2205
2206#define ADD_HELPER add_unsigned_friend
2207#define SUB_HELPER sub_unsigned_friend
2208#define MUL_HELPER mul_unsigned_friend
2209#define DIV_HELPER div_unsigned_friend
2210#define MOD_HELPER mod_unsigned_friend
2211#define AND_HELPER and_unsigned_friend
2212#define OR_HELPER or_unsigned_friend
2213#define XOR_HELPER xor_unsigned_friend
2214
2215#include "sc_nbfriends.inc"
2216
2217#undef SC_SIGNED
2218#define SC_UNSIGNED
2219#define IF_SC_SIGNED 0 // 0 = sc_unsigned
2220#define CLASS_TYPE_SUBREF sc_unsigned_subref_r
2221#define OTHER_CLASS_TYPE sc_signed
2222#define OTHER_CLASS_TYPE_SUBREF sc_signed_subref_r
2223
2224#define MUL_ON_HELPER mul_on_help_unsigned
2225#define DIV_ON_HELPER div_on_help_unsigned
2226#define MOD_ON_HELPER mod_on_help_unsigned
2227
2228#include "sc_nbcommon.inc"
2229
2230#undef MOD_ON_HELPER
2231#undef DIV_ON_HELPER
2232#undef MUL_ON_HELPER
2233
2234#undef OTHER_CLASS_TYPE_SUBREF
2235#undef OTHER_CLASS_TYPE
2236#undef CLASS_TYPE_SUBREF
2237#undef IF_SC_SIGNED
2238#undef SC_UNSIGNED
2239
2240#undef XOR_HELPER
2241#undef OR_HELPER
2242#undef AND_HELPER
2243#undef MOD_HELPER
2244#undef DIV_HELPER
2245#undef MUL_HELPER
2246#undef SUB_HELPER
2247#undef ADD_HELPER
2248
2249#undef CLASS_TYPE
2250#undef CLASS_TYPE_STR
2251
2252#include "sc_unsigned_bitref.inc"
2253#include "sc_unsigned_subref.inc"
2254
2255#undef CONVERT_LONG
2256#undef CONVERT_LONG_2
2257#undef CONVERT_INT64
2258#undef CONVERT_INT64_2
2259
2260} // namespace sc_dt
2
3 Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
4 more contributor license agreements. See the NOTICE file distributed
5 with this work for additional information regarding copyright ownership.
6 Accellera licenses this file to you under the Apache License, Version 2.0
7 (the "License"); you may not use this file except in compliance with the
8 License. You may obtain a copy of the License at
9
10 http://www.apache.org/licenses/LICENSE-2.0
11
12 Unless required by applicable law or agreed to in writing, software
13 distributed under the License is distributed on an "AS IS" BASIS,
14 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
15 implied. See the License for the specific language governing
16 permissions and limitations under the License.
17
18 *****************************************************************************/
19
20/*****************************************************************************
21
22 sc_unsigned.cpp -- Arbitrary precision signed arithmetic.
23
24 This file includes the definitions of sc_unsigned_bitref,
25 sc_unsigned_subref, and sc_unsigned classes. The first two classes
26 are proxy classes to reference one bit and a range of bits of a
27 sc_unsigned number, respectively. This file also includes
28 sc_nbcommon.cpp and sc_nbfriends.cpp, which contain the
29 definitions shared by sc_unsigned.
30
31 Original Author: Ali Dasdan, Synopsys, Inc.
32
33 *****************************************************************************/
34
35/*****************************************************************************
36
37 MODIFICATION LOG - modifiers, enter your name, affiliation, date and
38 changes you are making here.
39
40 Name, Affiliation, Date:
41 Description of Modification:
42
43 *****************************************************************************/
44
45
46// $Log: sc_unsigned.cpp,v $
47// Revision 1.7 2011/02/18 20:19:15 acg
48// Andy Goodrich: updating Copyright notice.
49//
50// Revision 1.6 2008/12/10 20:38:45 acg
51// Andy Goodrich: fixed conversion of double values to the digits vector.
52// The bits above the radix were not being masked off.
53//
54// Revision 1.5 2008/06/19 17:47:57 acg
55// Andy Goodrich: fixes for bugs. See 2.2.1 RELEASENOTES.
56//
57// Revision 1.4 2008/06/19 16:57:57 acg
58// Andy Goodrich: added case for negative unsigned values to the support in
59// concate_get_data().
60//
61// Revision 1.3 2007/11/04 21:27:00 acg
62// Andy Goodrich: changes to make sure the proper value is returned from
63// concat_get_data().
64//
65// Revision 1.2 2007/02/22 21:35:05 acg
66// Andy Goodrich: cleaned up comments in concat_get_ctrl and concat_get_data.
67//
68// Revision 1.1.1.1 2006/12/15 20:20:05 acg
69// SystemC 2.3
70//
71// Revision 1.4 2006/08/29 23:36:54 acg
72// Andy Goodrich: fixed and_reduce and optimized or_reduce.
73//
74// Revision 1.3 2006/01/13 18:49:32 acg
75// Added $Log command so that CVS check in comments are reproduced in the
76// source.
77//
78
79#include <cctype>
80#include <cmath>
81#include <sstream>
82
83#include "systemc/ext/dt/bit/sc_bv_base.hh"
84#include "systemc/ext/dt/bit/sc_lv_base.hh"
85#include "systemc/ext/dt/fx/sc_ufix.hh"
86#include "systemc/ext/dt/fx/scfx_other_defs.hh"
87#include "systemc/ext/dt/int/sc_int_base.hh"
88#include "systemc/ext/dt/int/sc_signed.hh"
89#include "systemc/ext/dt/int/sc_uint_base.hh"
90#include "systemc/ext/dt/int/sc_unsigned.hh"
91#include "systemc/ext/dt/misc/sc_concatref.hh"
92#include "systemc/ext/utils/messages.hh"
93
94// explicit template instantiations
95namespace sc_core
96{
97
98template class sc_vpool<sc_dt::sc_unsigned_bitref>;
99template class sc_vpool<sc_dt::sc_unsigned_subref>;
100template class sc_vpool<sc_dt::sc_unsigned>;
101
102} // namespace sc_core
103
104namespace sc_dt
105{
106
107// Pool of temporary instances:
108// The sc_unsigned pool is used by the concatenation support.
109// The bit and part reference pools allow references to be returned.
110
111sc_core::sc_vpool<sc_unsigned> sc_unsigned::m_pool(8);
112sc_core::sc_vpool<sc_unsigned_bitref> sc_unsigned_bitref::m_pool(9);
113sc_core::sc_vpool<sc_unsigned_subref> sc_unsigned_subref::m_pool(9);
114
115
116void
117sc_unsigned::invalid_init(const char *type_name, int nb) const
118{
119 std::stringstream msg;
120 msg << "sc_unsigned("<< type_name << ") : nb = " << nb << " is not valid";
121 SC_REPORT_ERROR("initialization failed", msg.str().c_str());
122}
123
124
125// ----------------------------------------------------------------------------
126// SECTION: Public members - Invalid selections.
127// ----------------------------------------------------------------------------
128
129void
130sc_unsigned::invalid_index(int i) const
131{
132 std::stringstream msg;
133 msg << "sc_biguint bit selection: index = " << i << " violates "
134 "0 <= index <= " << (nbits-2);
135 SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, msg.str().c_str());
136 sc_core::sc_abort(); // can't recover from here
137}
138
139void
140sc_unsigned::invalid_range(int l, int r) const
141{
142 std::stringstream msg;
143 msg << "sc_biguint part selection: left = " <<
144 l << ", right = " << r << " \n"
145 " violates either (" << (nbits - 2) << " >= left >= 0) or "
146 "(" << (nbits-2) << " >= right >= 0)";
147 SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, msg.str().c_str());
148 sc_core::sc_abort(); // can't recover from here
149}
150
151// ----------------------------------------------------------------------------
152// SECTION: Public members - Concatenation support.
153// ----------------------------------------------------------------------------
154
155// Most public members are included from sc_nbcommon.inc. However, some
156// concatenation support appears here to optimize between the signed and
157// unsigned cases.
158
159
160
161// Insert this object's value at the specified place in a vector of big style
162// values.
163
164bool
165sc_unsigned::concat_get_ctrl(sc_digit *dst_p, int low_i) const
166{
167 int dst_i; // Index to next word to set in dst_p.
168 int end_i; // Index of high order word to set.
169 int left_shift; // Amount to shift value left.
170 sc_digit mask; // Mask for partial word sets.
171
172
173 // CALCULATE METRICS FOR DATA MOVEMENT:
174 dst_i = low_i / BITS_PER_DIGIT;
175 end_i = (low_i + nbits - 2) / BITS_PER_DIGIT;
176 left_shift = low_i % BITS_PER_DIGIT;
177
178 // MOVE FIRST WORD (IT MAY BE PARTIAL) AND THEN ANY OTHERS:
179 //
180 // We may "clobber" upper bits, but they will be written at some point
181 // anyway.
182
183 mask = ~(~0U << left_shift);
184 dst_p[dst_i] = (dst_p[dst_i] & ~mask);
185 dst_i++;
186
187 for (; dst_i <= end_i; dst_i++)
188 dst_p[dst_i] = 0;
189
190 return false;
191}
192
193bool
194sc_unsigned::concat_get_data(sc_digit *dst_p, int low_i) const
195{
196 sc_digit carry; // Carry for negating value.
197 int dst_i; // Index to next word to set in dst_p.
198 int end_i; // Index of high order word to set.
199 int high_i; // Index w/in word of high order bit.
200 int left_shift; // Amount to shift value left.
201 sc_digit left_word; // High word component for set.
202 sc_digit mask; // Mask for partial word sets.
203 bool result; // True if inserting non-zero data.
204 int right_shift; // Amount to shift value right.
205 sc_digit right_word; // Low word component for set.
206 int real_bits; // nbits - 1.
207 int src_i; // Index to next word to get from digit.
208
209 // CALCULATE METRICS FOR DATA MOVEMENT:
210 real_bits = nbits - 1; // Remove that extra sign bit.
211 dst_i = low_i / BITS_PER_DIGIT;
212 high_i = low_i + real_bits - 1;
213 end_i = high_i / BITS_PER_DIGIT;
214 left_shift = low_i % BITS_PER_DIGIT;
215
216 switch (sgn) {
217 // POSITIVE SOURCE VALUE:
218 case SC_POS:
219 result = true;
220
221 // ALL DATA TO BE MOVED IS IN A SINGLE WORD:
222 if (dst_i == end_i) {
223 mask = ~(~0U << left_shift);
224 dst_p[dst_i] = ((dst_p[dst_i] & mask) |
225 (digit[0] << left_shift)) & DIGIT_MASK;
226
227 // DATA IS IN MORE THAN ONE WORD, BUT IS WORD ALIGNED:
228 } else if (left_shift == 0) {
229 for (src_i = 0; dst_i < end_i; dst_i++, src_i++) {
230 dst_p[dst_i] = digit[src_i];
231 }
232 high_i = high_i % BITS_PER_DIGIT;
233 mask = ~(~1U << high_i) & DIGIT_MASK;
234 dst_p[dst_i] = digit[src_i] & mask;
235
236 // DATA IS IN MORE THAN ONE WORD, AND NOT WORD ALIGNED:
237 } else {
238 high_i = high_i % BITS_PER_DIGIT;
239 right_shift = BITS_PER_DIGIT - left_shift;
240 mask = ~(~0U << left_shift);
241 right_word = digit[0];
242 dst_p[dst_i] = (dst_p[dst_i] & mask) |
243 ((right_word << left_shift) & DIGIT_MASK);
244 for (src_i = 1, dst_i++; dst_i < end_i; dst_i++, src_i++) {
245 left_word = digit[src_i];
246 dst_p[dst_i] = ((left_word << left_shift) & DIGIT_MASK) |
247 (right_word >> right_shift);
248 right_word = left_word;
249 }
250 left_word = (src_i < ndigits) ? digit[src_i] : 0;
251 mask = ~(~1U << high_i) & DIGIT_MASK;
252 dst_p[dst_i] = ((left_word << left_shift) |
253 (right_word >> right_shift)) & mask;
254 }
255 break;
256
257 // SOURCE VALUE IS NEGATIVE:
258 case SC_NEG:
259 // ALL DATA TO BE MOVED IS IN A SINGLE WORD:
260 result = true;
261 if (dst_i == end_i) {
262 mask = ~(~0U << nbits);
263 right_word = ((digit[0] ^ DIGIT_MASK) + 1) & mask;
264 mask = ~(~0U << left_shift);
265 dst_p[dst_i] = ((dst_p[dst_i] & mask) |
266 (right_word << left_shift)) & DIGIT_MASK;
267
268 // DATA IS IN MORE THAN ONE WORD, BUT IS WORD ALIGNED:
269
270 } else if (left_shift == 0) {
271 carry = 1;
272 for (src_i = 0; dst_i < end_i; dst_i++, src_i++) {
273 right_word = (digit[src_i] ^ DIGIT_MASK) + carry;
274 dst_p[dst_i] = right_word & DIGIT_MASK;
275 carry = right_word >> BITS_PER_DIGIT;
276 }
277 high_i = high_i % BITS_PER_DIGIT;
278 mask = (~(~1U << high_i)) & DIGIT_MASK;
279 right_word = (src_i < ndigits) ?
280 (digit[src_i] ^ DIGIT_MASK) + carry : DIGIT_MASK + carry;
281 dst_p[dst_i] = right_word & mask;
282
283 // DATA IS IN MORE THAN ONE WORD, AND NOT WORD ALIGNED:
284 } else {
285 high_i = high_i % BITS_PER_DIGIT;
286 right_shift = BITS_PER_DIGIT - left_shift;
287 mask = ~(~0U << left_shift);
288 carry = 1;
289 right_word = (digit[0] ^ DIGIT_MASK) + carry;
290 dst_p[dst_i] = (dst_p[dst_i] & mask) |
291 ((right_word << left_shift) & DIGIT_MASK);
292 carry = right_word >> BITS_PER_DIGIT;
293 right_word &= DIGIT_MASK;
294 for (src_i = 1, dst_i++; dst_i < end_i; dst_i++, src_i++) {
295 left_word = (digit[src_i] ^ DIGIT_MASK) + carry;
296 dst_p[dst_i] = ((left_word << left_shift)&DIGIT_MASK) |
297 (right_word >> right_shift);
298 carry = left_word >> BITS_PER_DIGIT;
299 right_word = left_word & DIGIT_MASK;
300 }
301 left_word = (src_i < ndigits) ?
302 (digit[src_i] ^ DIGIT_MASK) + carry : carry;
303 mask = ~(~1U << high_i) & DIGIT_MASK;
304 dst_p[dst_i] = ((left_word << left_shift) |
305 (right_word >> right_shift)) & mask;
306 }
307 break;
308 // VALUE IS ZERO:
309 default:
310 result = false;
311 // ALL DATA TO BE MOVED IS IN A SINGLE WORD:
312 if (dst_i == end_i) {
313 mask = ~(~0U << real_bits) << left_shift;
314 dst_p[dst_i] = dst_p[dst_i] & ~mask;
315
316 // DATA IS IN MORE THAN ONE WORD, BUT IS WORD ALIGNED:
317
318 } else if (left_shift == 0) {
319 for (src_i = 0; dst_i < end_i; dst_i++, src_i++) {
320 dst_p[dst_i] = 0;
321 }
322 dst_p[dst_i] = 0;
323
324 // DATA IS IN MORE THAN ONE WORD, AND NOT WORD ALIGNED:
325 } else {
326 mask = ~(~0U << left_shift);
327 dst_p[dst_i] = (dst_p[dst_i] & mask);
328 for (dst_i++; dst_i <= end_i; dst_i++) {
329 dst_p[dst_i] = 0;
330 }
331 }
332 break;
333 }
334 return result;
335}
336
337// Return this object instance's bits as a uint64 without sign extension.
338uint64
339sc_unsigned::concat_get_uint64() const
340{
341 uint64 result;
342
343 switch (sgn) {
344 case SC_POS:
345 result = 0;
346 if (ndigits > 2)
347 result = digit[2];
348 if (ndigits > 1)
349 result = (result << BITS_PER_DIGIT) | digit[1];
350 result = (result << BITS_PER_DIGIT) | digit[0];
351 break;
352 default:
353 result = 0;
354 break;
355 }
356 return result;
357}
358
359// #### OPTIMIZE
360void
361sc_unsigned::concat_set(int64 src, int low_i)
362{
363 *this = (low_i < 64) ? src >> low_i : src >> 63;
364}
365
366void
367sc_unsigned::concat_set(const sc_signed &src, int low_i)
368{
369 if (low_i < src.length())
370 *this = src >> low_i;
371 else
372 *this = (src < 0) ? (int_type)-1 : 0;
373}
374
375void
376sc_unsigned::concat_set(const sc_unsigned &src, int low_i)
377{
378 if (low_i < src.length())
379 *this = src >> low_i;
380 else
381 *this = 0;
382}
383
384void
385sc_unsigned::concat_set(uint64 src, int low_i)
386{
387 *this = (low_i < 64) ? src >> low_i : 0;
388}
389
390
391// ----------------------------------------------------------------------------
392// SECTION: Public members - Reduction methods.
393// ----------------------------------------------------------------------------
394
395bool
396sc_unsigned::and_reduce() const
397{
398 int i; // Digit examining.
399
400 if (sgn == SC_ZERO)
401 return false;
402 for (i = 0; i < ndigits - 1; i++)
403 if ((digit[i] & DIGIT_MASK) != DIGIT_MASK)
404 return false;
405 if ((digit[i] & ~(~0U << ((nbits - 1) % BITS_PER_DIGIT))) ==
406 static_cast<sc_digit>(~(~0U << ((nbits - 1) % BITS_PER_DIGIT)))) {
407 return true;
408 }
409 return false;
410}
411
412bool
413sc_unsigned::or_reduce() const
414{
415 return (sgn == SC_ZERO) ? false : true;
416}
417
418bool
419sc_unsigned::xor_reduce() const
420{
421 int i; // Digit examining.
422 int odd; // Flag for odd number of digits.
423
424 odd = 0;
425 for (i = 0; i < nbits - 1; i++)
426 if (test(i))
427 odd = ~odd;
428 return odd ? true : false;
429}
430
431
432// ----------------------------------------------------------------------------
433// SECTION: Public members - Assignment operators.
434// ----------------------------------------------------------------------------
435
436// assignment operators
437const sc_unsigned &
438sc_unsigned::operator = (const char *a)
439{
440 if (a == 0) {
441 SC_REPORT_ERROR("conversion failed",
442 "character string is zero");
443 } else if (*a == 0) {
444 SC_REPORT_ERROR("conversion failed",
445 "character string is empty");
446 } else try {
447 int len = length();
448 sc_ufix aa(a, len, len, SC_TRN, SC_WRAP, 0, SC_ON);
449 return this->operator = (aa);
450 } catch(const sc_core::sc_report &) {
451 std::stringstream msg;
452 msg << "character string '" << a << "' is not valid";
453 SC_REPORT_ERROR("conversion failed", msg.str().c_str());
454 }
455 return *this;
456}
457
458const sc_unsigned &
459sc_unsigned::operator = (int64 v)
460{
461 sgn = get_sign(v);
462 if (sgn == SC_ZERO) {
463 vec_zero(ndigits, digit);
464 } else {
465 from_uint(ndigits, digit, (uint64) v);
466 convert_SM_to_2C_to_SM();
467 }
468 return *this;
469}
470
471const sc_unsigned &
472sc_unsigned::operator = (uint64 v)
473{
474 if (v == 0) {
475 sgn = SC_ZERO;
476 vec_zero(ndigits, digit);
477 } else {
478 sgn = SC_POS;
479 from_uint(ndigits, digit, v);
480 convert_SM_to_2C_to_SM();
481 }
482 return *this;
483}
484
485const sc_unsigned &
486sc_unsigned::operator = (long v)
487{
488 sgn = get_sign(v);
489 if (sgn == SC_ZERO) {
490 vec_zero(ndigits, digit);
491 } else {
492 from_uint(ndigits, digit, (unsigned long)v);
493 convert_SM_to_2C_to_SM();
494 }
495 return *this;
496}
497
498const sc_unsigned &
499sc_unsigned::operator = (unsigned long v)
500{
501 if (v == 0) {
502 sgn = SC_ZERO;
503 vec_zero(ndigits, digit);
504 } else {
505 sgn = SC_POS;
506 from_uint(ndigits, digit, v);
507 convert_SM_to_2C_to_SM();
508 }
509 return *this;
510}
511
512const sc_unsigned &
513sc_unsigned::operator = (double v)
514{
515 is_bad_double(v);
516 sgn = SC_POS;
517 int i = 0;
518 while (std::floor(v) && (i < ndigits)) {
519 digit[i++] = ((sc_digit)std::floor(remainder(v, DIGIT_RADIX))) &
520 DIGIT_MASK;
521 v /= DIGIT_RADIX;
522 }
523 vec_zero(i, ndigits, digit);
524 convert_SM_to_2C_to_SM();
525 return *this;
526}
527
528
529// ----------------------------------------------------------------------------
530
531const sc_unsigned &
532sc_unsigned::operator = (const sc_bv_base &v)
533{
534 int minlen = sc_min(nbits, v.length());
535 int i = 0;
536 for (; i < minlen; ++i) {
537 safe_set(i, v.get_bit(i), digit);
538 }
539 for (; i < nbits; ++i) {
540 safe_set(i, 0, digit); // zero-extend
541 }
542 convert_2C_to_SM();
543 return *this;
544}
545
546const sc_unsigned &
547sc_unsigned::operator = (const sc_lv_base &v)
548{
549 int minlen = sc_min(nbits, v.length());
550 int i = 0;
551 for (; i < minlen; ++i) {
552 safe_set(i, sc_logic(v.get_bit(i)).to_bool(), digit);
553 }
554 for (; i < nbits; ++i) {
555 safe_set(i, 0, digit); // zero-extend
556 }
557 convert_2C_to_SM();
558 return *this;
559}
560
561
562// explicit conversion to character string
563const std::string
564sc_unsigned::to_string(sc_numrep numrep) const
565{
566 int len = length();
567 sc_ufix aa(*this, len, len, SC_TRN, SC_WRAP, 0, SC_ON);
568 return aa.to_string(numrep);
569}
570
571const std::string
572sc_unsigned::to_string(sc_numrep numrep, bool w_prefix) const
573{
574 int len = length();
575 sc_ufix aa(*this, len, len, SC_TRN, SC_WRAP, 0, SC_ON);
576 return aa.to_string(numrep, w_prefix);
577}
578
579
580// ----------------------------------------------------------------------------
581// SECTION: Interfacing with sc_int_base
582// ----------------------------------------------------------------------------
583
584const sc_unsigned &
585sc_unsigned::operator = (const sc_int_base &v)
586{
587 return operator = ((int64)v);
588}
589
590const sc_unsigned &
591sc_unsigned::operator += (const sc_int_base &v)
592{
593 return operator += ((int64)v);
594}
595
596const sc_unsigned &
597sc_unsigned::operator -= (const sc_int_base &v)
598{
599 return operator -= ((int64)v);
600}
601
602const sc_unsigned &
603sc_unsigned::operator *= (const sc_int_base &v)
604{
605 return operator *= ((int64)v);
606}
607
608const sc_unsigned &
609sc_unsigned::operator /= (const sc_int_base &v)
610{
611 return operator /= ((int64)v);
612}
613
614const sc_unsigned &
615sc_unsigned::operator %= (const sc_int_base &v)
616{
617 return operator %= ((int64)v);
618}
619
620const sc_unsigned &
621sc_unsigned::operator &= (const sc_int_base &v)
622{
623 return operator &= ((int64)v);
624}
625
626const sc_unsigned &
627sc_unsigned::operator |= (const sc_int_base &v)
628{
629 return operator |= ((int64)v);
630}
631
632const sc_unsigned &
633sc_unsigned::operator ^= (const sc_int_base &v)
634{
635 return operator ^= ((int64)v);
636}
637
638sc_unsigned
639operator << (const sc_unsigned &u, const sc_int_base &v)
640{
641 return operator << (u, (int64)v);
642}
643const sc_unsigned &
644sc_unsigned::operator <<= (const sc_int_base &v)
645{
646 return operator <<= ((int64)v);
647}
648
649sc_unsigned
650operator >> (const sc_unsigned& u, const sc_int_base& v)
651{
652 return operator >> (u, (int64)v);
653}
654const sc_unsigned &
655sc_unsigned::operator >>= (const sc_int_base& v)
656{
657 return operator >>= ((int64)v);
658}
659
660bool
661operator == (const sc_unsigned &u, const sc_int_base &v)
662{
663 return operator == (u, (int64)v);
664}
665bool
666operator == (const sc_int_base &u, const sc_unsigned &v)
667{
668 return operator == ((int64)u, v);
669}
670
671bool
672operator != (const sc_unsigned &u, const sc_int_base &v)
673{
674 return operator != (u, (int64)v);
675}
676bool
677operator != (const sc_int_base &u, const sc_unsigned &v)
678{
679 return operator != ((int64)u, v);
680}
681
682bool
683operator < (const sc_unsigned &u, const sc_int_base &v)
684{
685 return operator < (u, (int64)v);
686}
687bool
688operator < (const sc_int_base &u, const sc_unsigned &v)
689{
690 return operator < ((int64)u, v);
691}
692
693bool
694operator <= (const sc_unsigned &u, const sc_int_base &v)
695{
696 return operator <= (u, (int64)v);
697}
698bool
699operator <= (const sc_int_base &u, const sc_unsigned &v)
700{
701 return operator <= ((int64)u, v);
702}
703
704bool
705operator > (const sc_unsigned &u, const sc_int_base &v)
706{
707 return operator > (u, (int64)v);
708}
709bool
710operator > (const sc_int_base &u, const sc_unsigned &v)
711{
712 return operator > ((int64)u, v);
713}
714
715bool
716operator >= (const sc_unsigned &u, const sc_int_base &v)
717{
718 return operator >= (u, (int64)v);
719}
720bool
721operator >= (const sc_int_base &u, const sc_unsigned &v)
722{
723 return operator >= ((int64)u, v);
724}
725
726
727// ----------------------------------------------------------------------------
728// SECTION: Interfacing with sc_uint_base
729// ----------------------------------------------------------------------------
730
731const sc_unsigned &
732sc_unsigned::operator = (const sc_uint_base &v)
733{
734 return operator = ((uint64)v);
735}
736
737sc_unsigned
738operator + (const sc_unsigned &u, const sc_uint_base &v)
739{
740 return operator + (u, (uint64)v);
741}
742sc_unsigned
743operator + (const sc_uint_base &u, const sc_unsigned &v)
744{
745 return operator + ((uint64)u, v);
746}
747const sc_unsigned &
748sc_unsigned::operator += (const sc_uint_base &v)
749{
750 return operator += ((uint64)v);
751}
752
753const sc_unsigned &
754sc_unsigned::operator -= (const sc_uint_base &v)
755{
756 return operator -= ((uint64)v);
757}
758
759sc_unsigned
760operator * (const sc_unsigned &u, const sc_uint_base &v)
761{
762 return operator * (u, (uint64)v);
763}
764sc_unsigned
765operator * (const sc_uint_base &u, const sc_unsigned &v)
766{
767 return operator * ((uint64)u, v);
768}
769const sc_unsigned &
770sc_unsigned::operator *= (const sc_uint_base &v)
771{
772 return operator *= ((uint64)v);
773}
774
775sc_unsigned
776operator / (const sc_unsigned &u, const sc_uint_base &v)
777{
778 return operator / (u, (uint64)v);
779}
780sc_unsigned
781operator / (const sc_uint_base &u, const sc_unsigned &v)
782{
783 return operator / ((uint64)u, v);
784}
785const sc_unsigned &
786sc_unsigned::operator /= (const sc_uint_base &v)
787{
788 return operator /= ((uint64)v);
789}
790
791sc_unsigned
792operator % (const sc_unsigned &u, const sc_uint_base &v)
793{
794 return operator % (u, (uint64)v);
795}
796sc_unsigned
797operator % (const sc_uint_base &u, const sc_unsigned &v)
798{
799 return operator % ((uint64)u, v);
800}
801const sc_unsigned &
802sc_unsigned::operator %= (const sc_uint_base &v)
803{
804 return operator %= ((uint64)v);
805}
806
807sc_unsigned
808operator & (const sc_unsigned &u, const sc_uint_base &v)
809{
810 return operator & (u, (uint64)v);
811}
812sc_unsigned
813operator & (const sc_uint_base &u, const sc_unsigned &v)
814{
815 return operator & ((uint64)u, v);
816}
817const sc_unsigned &
818sc_unsigned::operator &= (const sc_uint_base &v)
819{
820 return operator &= ((uint64)v);
821}
822
823sc_unsigned
824operator | (const sc_unsigned &u, const sc_uint_base &v)
825{
826 return operator | (u, (uint64)v);
827}
828sc_unsigned
829operator | (const sc_uint_base &u, const sc_unsigned &v)
830{
831 return operator | ((uint64)u, v);
832}
833const sc_unsigned &
834sc_unsigned::operator |= (const sc_uint_base &v)
835{
836 return operator |= ((uint64)v);
837}
838
839sc_unsigned
840operator ^ (const sc_unsigned &u, const sc_uint_base &v)
841{
842 return operator ^ (u, (uint64)v);
843}
844sc_unsigned
845operator ^ (const sc_uint_base &u, const sc_unsigned &v)
846{
847 return operator ^ ((uint64)u, v);
848}
849const sc_unsigned &
850sc_unsigned::operator ^= (const sc_uint_base &v)
851{
852 return operator ^= ((uint64)v);
853}
854
855sc_unsigned
856operator << (const sc_unsigned &u, const sc_uint_base &v)
857{
858 return operator << (u, (uint64)v);
859}
860const sc_unsigned &
861sc_unsigned::operator <<= (const sc_uint_base &v)
862{
863 return operator <<= ((uint64)v);
864}
865
866sc_unsigned
867operator >> (const sc_unsigned &u, const sc_uint_base &v)
868{
869 return operator >> (u, (uint64)v);
870}
871const sc_unsigned &
872sc_unsigned::operator >>= (const sc_uint_base &v)
873{
874 return operator >>= ((uint64)v);
875}
876
877bool
878operator == (const sc_unsigned &u, const sc_uint_base &v)
879{
880 return operator == (u, (uint64)v);
881}
882bool
883operator == (const sc_uint_base &u, const sc_unsigned &v)
884{
885 return operator == ((uint64)u, v);
886}
887
888bool
889operator != (const sc_unsigned &u, const sc_uint_base &v)
890{
891 return operator != (u, (uint64)v);
892}
893bool
894operator != (const sc_uint_base &u, const sc_unsigned &v)
895{
896 return operator != ((uint64)u, v);
897}
898
899bool
900operator < (const sc_unsigned &u, const sc_uint_base &v)
901{
902 return operator < (u, (uint64)v);
903}
904bool
905operator < (const sc_uint_base &u, const sc_unsigned &v)
906{
907 return operator < ((uint64)u, v);
908}
909
910bool
911operator <= (const sc_unsigned &u, const sc_uint_base &v)
912{
913 return operator <= (u, (uint64)v);
914}
915bool
916operator <= (const sc_uint_base &u, const sc_unsigned &v)
917{
918 return operator <= ((uint64)u, v);
919}
920
921bool
922operator > (const sc_unsigned &u, const sc_uint_base &v)
923{
924 return operator > (u, (uint64)v);
925}
926bool
927operator > (const sc_uint_base &u, const sc_unsigned &v)
928{
929 return operator > ((uint64)u, v);
930}
931
932bool
933operator >= (const sc_unsigned &u, const sc_uint_base &v)
934{
935 return operator >= (u, (uint64)v);
936}
937bool
938operator >= (const sc_uint_base &u, const sc_unsigned &v)
939{
940 return operator >= ((uint64)u, v);
941}
942
943
944// ----------------------------------------------------------------------------
945// SECTION: Input and output operators
946// ----------------------------------------------------------------------------
947
948// The operators in this section are included from sc_nbcommon.cpp.
949
950
951// ----------------------------------------------------------------------------
952// SECTION: Operator macros.
953// ----------------------------------------------------------------------------
954
955#define CONVERT_LONG(u) \
956small_type u ## s = get_sign(u); \
957sc_digit u ## d[DIGITS_PER_ULONG]; \
958from_uint(DIGITS_PER_ULONG, u ## d, (unsigned long) u);
959
960#define CONVERT_LONG_2(u) \
961sc_digit u ## d[DIGITS_PER_ULONG]; \
962from_uint(DIGITS_PER_ULONG, u ## d, (unsigned long) u);
963
964#define CONVERT_INT(u) \
965small_type u ## s = get_sign(u); \
966sc_digit u ## d[DIGITS_PER_UINT]; \
967from_uint(DIGITS_PER_UINT, u ## d, (unsigned int) u);
968
969#define CONVERT_INT_2(u) \
970sc_digit u ## d[DIGITS_PER_UINT]; \
971from_uint(DIGITS_PER_UINT, u ## d, (unsigned int) u);
972
973#define CONVERT_INT64(u) \
974small_type u ## s = get_sign(u); \
975sc_digit u ## d[DIGITS_PER_UINT64]; \
976from_uint(DIGITS_PER_UINT64, u ## d, (uint64) u);
977
978#define CONVERT_INT64_2(u) \
979sc_digit u ## d[DIGITS_PER_UINT64]; \
980from_uint(DIGITS_PER_UINT64, u ## d, (uint64) u);
981
982
983// ----------------------------------------------------------------------------
984// SECTION: PLUS operators: +, +=, ++
985// ----------------------------------------------------------------------------
986
987// Cases to consider when computing u + v:
988// 1. 0 + v = v
989// 2. u + 0 = u
990// 3. if sgn(u) == sgn(v)
991// 3.1 u + v = +(u + v) = sgn(u) * (u + v)
992// 3.2 (-u) + (-v) = -(u + v) = sgn(u) * (u + v)
993// 4. if sgn(u) != sgn(v)
994// 4.1 u + (-v) = u - v = sgn(u) * (u - v)
995// 4.2 (-u) + v = -(u - v) ==> sgn(u) * (u - v)
996//
997// Specialization of above cases for computing ++u or u++:
998// 1. 0 + 1 = 1
999// 3. u + 1 = u + 1 = sgn(u) * (u + 1)
1000// 4. (-u) + 1 = -(u - 1) = sgn(u) * (u - 1)
1001
1002sc_unsigned
1003operator + (const sc_unsigned &u, const sc_unsigned &v)
1004{
1005 if (u.sgn == SC_ZERO) // case 1
1006 return sc_unsigned(v);
1007
1008 if (v.sgn == SC_ZERO) // case 2
1009 return sc_unsigned(u);
1010
1011 // cases 3 and 4
1012 return add_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1013 v.sgn, v.nbits, v.ndigits, v.digit);
1014}
1015
1016
1017sc_unsigned
1018operator + (const sc_unsigned &u, uint64 v)
1019{
1020 if (v == 0) // case 2
1021 return sc_unsigned(u);
1022
1023 CONVERT_INT64(v);
1024
1025 if (u.sgn == SC_ZERO) // case 1
1026 return sc_unsigned(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
1027
1028 // cases 3 and 4
1029 return add_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1030 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1031}
1032
1033
1034sc_unsigned
1035operator + (uint64 u, const sc_unsigned &v)
1036{
1037 if (u == 0) // case 1
1038 return sc_unsigned(v);
1039
1040 CONVERT_INT64(u);
1041
1042 if (v.sgn == SC_ZERO) // case 2
1043 return sc_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
1044
1045 // cases 3 and 4
1046 return add_unsigned_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
1047 v.sgn, v.nbits, v.ndigits, v.digit);
1048}
1049
1050
1051sc_unsigned
1052operator + (const sc_unsigned &u, unsigned long v)
1053{
1054 if (v == 0) // case 2
1055 return sc_unsigned(u);
1056
1057 CONVERT_LONG(v);
1058
1059 if (u.sgn == SC_ZERO) // case 1
1060 return sc_unsigned(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
1061
1062 // cases 3 and 4
1063 return add_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1064 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1065}
1066
1067
1068sc_unsigned
1069operator + (unsigned long u, const sc_unsigned &v)
1070{
1071 if (u == 0) // case 1
1072 return sc_unsigned(v);
1073
1074 CONVERT_LONG(u);
1075
1076 if (v.sgn == SC_ZERO) // case 2
1077 return sc_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
1078
1079 // cases 3 and 4
1080 return add_unsigned_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
1081 v.sgn, v.nbits, v.ndigits, v.digit);
1082}
1083
1084// The rest of the operators in this section are included from
1085// sc_nbcommon.cpp.
1086
1087
1088// ----------------------------------------------------------------------------
1089// SECTION: MINUS operators: -, -=, --
1090// ----------------------------------------------------------------------------
1091
1092// Cases to consider when computing u + v:
1093// 1. u - 0 = u
1094// 2. 0 - v = -v
1095// 3. if sgn(u) != sgn(v)
1096// 3.1 u - (-v) = u + v = sgn(u) * (u + v)
1097// 3.2 (-u) - v = -(u + v) ==> sgn(u) * (u + v)
1098// 4. if sgn(u) == sgn(v)
1099// 4.1 u - v = +(u - v) = sgn(u) * (u - v)
1100// 4.2 (-u) - (-v) = -(u - v) = sgn(u) * (u - v)
1101//
1102// Specialization of above cases for computing --u or u--:
1103// 1. 0 - 1 = -1
1104// 3. (-u) - 1 = -(u + 1) = sgn(u) * (u + 1)
1105// 4. u - 1 = u - 1 = sgn(u) * (u - 1)
1106
1107// The operators in this section are included from sc_nbcommon.cpp.
1108
1109
1110// ----------------------------------------------------------------------------
1111// SECTION: MULTIPLICATION operators: *, *=
1112// ----------------------------------------------------------------------------
1113
1114// Cases to consider when computing u * v:
1115// 1. u * 0 = 0 * v = 0
1116// 2. 1 * v = v and -1 * v = -v
1117// 3. u * 1 = u and u * -1 = -u
1118// 4. u * v = u * v
1119
1120sc_unsigned
1121operator * (const sc_unsigned &u, const sc_unsigned &v)
1122{
1123 small_type s = mul_signs(u.sgn, v.sgn);
1124
1125 if (s == SC_ZERO) // case 1
1126 return sc_unsigned();
1127
1128 // cases 2-4
1129 return mul_unsigned_friend(s, u.nbits, u.ndigits, u.digit,
1130 v.nbits, v.ndigits, v.digit);
1131}
1132
1133
1134sc_unsigned
1135operator * (const sc_unsigned &u, uint64 v)
1136{
1137 small_type s = mul_signs(u.sgn, get_sign(v));
1138
1139 if (s == SC_ZERO) // case 1
1140 return sc_unsigned();
1141
1142 CONVERT_INT64_2(v);
1143
1144 // cases 2-4
1145 return mul_unsigned_friend(s, u.nbits, u.ndigits, u.digit,
1146 BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1147}
1148
1149
1150sc_unsigned
1151operator * (uint64 u, const sc_unsigned &v)
1152{
1153 small_type s = mul_signs(v.sgn, get_sign(u));
1154
1155 if (s == SC_ZERO) // case 1
1156 return sc_unsigned();
1157
1158 CONVERT_INT64_2(u);
1159
1160 // cases 2-4
1161 return mul_unsigned_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
1162 v.nbits, v.ndigits, v.digit);
1163}
1164
1165
1166sc_unsigned
1167operator * (const sc_unsigned &u, unsigned long v)
1168{
1169 small_type s = mul_signs(u.sgn, get_sign(v));
1170
1171 if (s == SC_ZERO) // case 1
1172 return sc_unsigned();
1173
1174 CONVERT_LONG_2(v);
1175
1176 // else cases 2-4
1177 return mul_unsigned_friend(s, u.nbits, u.ndigits, u.digit,
1178 BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1179}
1180
1181sc_unsigned
1182operator * (unsigned long u, const sc_unsigned &v)
1183{
1184 small_type s = mul_signs(v.sgn, get_sign(u));
1185
1186 if (s == SC_ZERO) // case 1
1187 return sc_unsigned();
1188
1189 CONVERT_LONG_2(u);
1190
1191 // cases 2-4
1192 return mul_unsigned_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
1193 v.nbits, v.ndigits, v.digit);
1194}
1195
1196// The rest of the operators in this section are included from
1197// sc_nbcommon.cpp.
1198
1199
1200// ----------------------------------------------------------------------------
1201// SECTION: DIVISION operators: /, /=
1202// ----------------------------------------------------------------------------
1203
1204// Cases to consider when finding the quotient q = floor(u/v):
1205// Note that u = q * v + r for r < q.
1206// 1. 0 / 0 or u / 0 => error
1207// 2. 0 / v => 0 = 0 * v + 0
1208// 3. u / v & &u = v => u = 1 * u + 0 - u or v can be 1 or -1
1209// 4. u / v & &u < v => u = 0 * v + u - u can be 1 or -1
1210// 5. u / v & &u > v => u = q * v + r - v can be 1 or -1
1211
1212sc_unsigned
1213operator / (const sc_unsigned &u, const sc_unsigned &v)
1214{
1215 small_type s = mul_signs(u.sgn, v.sgn);
1216
1217 if (s == SC_ZERO) {
1218 div_by_zero(v.sgn); // case 1
1219 return sc_unsigned(); // case 2
1220 }
1221
1222 // other cases
1223 return div_unsigned_friend(s, u.nbits, u.ndigits, u.digit,
1224 v.nbits, v.ndigits, v.digit);
1225}
1226
1227
1228sc_unsigned
1229operator / (const sc_unsigned &u, uint64 v)
1230{
1231 small_type s = mul_signs(u.sgn, get_sign(v));
1232
1233 if (s == SC_ZERO) {
1234 div_by_zero(v); // case 1
1235 return sc_unsigned(); // case 2
1236 }
1237
1238 CONVERT_INT64_2(v);
1239
1240 // other cases
1241 return div_unsigned_friend(s, u.nbits, u.ndigits, u.digit,
1242 BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1243}
1244
1245
1246sc_unsigned
1247operator / (uint64 u, const sc_unsigned &v)
1248{
1249 small_type s = mul_signs(v.sgn, get_sign(u));
1250
1251 if (s == SC_ZERO) {
1252 div_by_zero(v.sgn); // case 1
1253 return sc_unsigned(); // case 2
1254
1255 }
1256
1257 CONVERT_INT64_2(u);
1258
1259 // other cases
1260 return div_unsigned_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
1261 v.nbits, v.ndigits, v.digit);
1262}
1263
1264
1265sc_unsigned
1266operator / (const sc_unsigned &u, unsigned long v)
1267{
1268 small_type s = mul_signs(u.sgn, get_sign(v));
1269
1270 if (s == SC_ZERO) {
1271 div_by_zero(v); // case 1
1272 return sc_unsigned(); // case 2
1273 }
1274
1275 CONVERT_LONG_2(v);
1276
1277 // other cases
1278 return div_unsigned_friend(s, u.nbits, u.ndigits, u.digit,
1279 BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1280}
1281
1282
1283sc_unsigned
1284operator / (unsigned long u, const sc_unsigned &v)
1285{
1286 small_type s = mul_signs(v.sgn, get_sign(u));
1287
1288 if (s == SC_ZERO) {
1289 div_by_zero(v.sgn); // case 1
1290 return sc_unsigned(); // case 2
1291
1292 }
1293
1294 CONVERT_LONG_2(u);
1295
1296 // other cases
1297 return div_unsigned_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
1298 v.nbits, v.ndigits, v.digit);
1299}
1300
1301// The rest of the operators in this section are included from
1302// sc_nbcommon.cpp.
1303
1304
1305// ----------------------------------------------------------------------------
1306// SECTION: MOD operators: %, %=.
1307// ----------------------------------------------------------------------------
1308
1309// Cases to consider when finding the remainder r = u % v:
1310// Note that u = q * v + r for r < q.
1311// 1. 0 % 0 or u % 0 => error
1312// 2. 0 % v => 0 = 0 * v + 0
1313// 3. u % v & &u = v => u = 1 * u + 0 - u or v can be 1 or -1
1314// 4. u % v & &u < v => u = 0 * v + u - u can be 1 or -1
1315// 5. u % v & &u > v => u = q * v + r - v can be 1 or -1
1316
1317sc_unsigned
1318operator % (const sc_unsigned &u, const sc_unsigned &v)
1319{
1320 if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) {
1321 div_by_zero(v.sgn); // case 1
1322 return sc_unsigned(); // case 2
1323 }
1324
1325 // other cases
1326 return mod_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1327 v.nbits, v.ndigits, v.digit);
1328}
1329
1330
1331sc_unsigned
1332operator % (const sc_unsigned &u, uint64 v)
1333{
1334 if ((u.sgn == SC_ZERO) || (v == 0)) {
1335 div_by_zero(v); // case 1
1336 return sc_unsigned(); // case 2
1337 }
1338
1339 CONVERT_INT64_2(v);
1340
1341 // other cases
1342 return mod_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1343 BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1344
1345}
1346
1347
1348sc_unsigned
1349operator % (uint64 u, const sc_unsigned &v)
1350{
1351 if ((u == 0) || (v.sgn == SC_ZERO)) {
1352 div_by_zero(v.sgn); // case 1
1353 return sc_unsigned(); // case 2
1354 }
1355
1356 CONVERT_INT64(u);
1357
1358 // other cases
1359 return mod_unsigned_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
1360 v.nbits, v.ndigits, v.digit);
1361}
1362
1363
1364sc_unsigned
1365operator % (const sc_unsigned &u, unsigned long v)
1366{
1367 if ((u.sgn == SC_ZERO) || (v == 0)) {
1368 div_by_zero(v); // case 1
1369 return sc_unsigned(); // case 2
1370 }
1371
1372 CONVERT_LONG_2(v);
1373
1374 // other cases
1375 return mod_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1376 BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1377}
1378
1379
1380sc_unsigned
1381operator % (unsigned long u, const sc_unsigned &v)
1382{
1383 if ((u == 0) || (v.sgn == SC_ZERO)) {
1384 div_by_zero(v.sgn); // case 1
1385 return sc_unsigned(); // case 2
1386 }
1387
1388 CONVERT_LONG(u);
1389
1390 // other cases
1391 return mod_unsigned_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
1392 v.nbits, v.ndigits, v.digit);
1393}
1394
1395// The rest of the operators in this section are included from
1396// sc_nbcommon.cpp.
1397
1398
1399// ----------------------------------------------------------------------------
1400// SECTION: Bitwise AND operators: &, &=
1401// ----------------------------------------------------------------------------
1402
1403// Cases to consider when computing u &v:
1404// 1. u & 0 = 0 &v = 0
1405// 2. u &v => sgn = +
1406// 3. (-u) & (-v) => sgn = -
1407// 4. u & (-v) => sgn = +
1408// 5. (-u) &v => sgn = +
1409
1410sc_unsigned
1411operator & (const sc_unsigned &u, const sc_unsigned &v)
1412{
1413 if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) // case 1
1414 return sc_unsigned();
1415
1416 // other cases
1417 return and_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1418 v.sgn, v.nbits, v.ndigits, v.digit);
1419}
1420
1421
1422sc_unsigned
1423operator & (const sc_unsigned &u, uint64 v)
1424{
1425 if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
1426 return sc_unsigned();
1427
1428 CONVERT_INT64(v);
1429
1430 // other cases
1431 return and_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1432 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1433}
1434
1435
1436sc_unsigned
1437operator & (uint64 u, const sc_unsigned &v)
1438{
1439 if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
1440 return sc_unsigned();
1441
1442 CONVERT_INT64(u);
1443
1444 // other cases
1445 return and_unsigned_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
1446 v.sgn, v.nbits, v.ndigits, v.digit);
1447}
1448
1449
1450sc_unsigned
1451operator & (const sc_unsigned &u, unsigned long v)
1452{
1453 if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
1454 return sc_unsigned();
1455
1456 CONVERT_LONG(v);
1457
1458 // other cases
1459 return and_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1460 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1461}
1462
1463
1464sc_unsigned
1465operator & (unsigned long u, const sc_unsigned &v)
1466{
1467 if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
1468 return sc_unsigned();
1469
1470 CONVERT_LONG(u);
1471
1472 // other cases
1473 return and_unsigned_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
1474 v.sgn, v.nbits, v.ndigits, v.digit);
1475}
1476
1477// The rest of the operators in this section are included from
1478// sc_nbcommon.cpp.
1479
1480
1481// ----------------------------------------------------------------------------
1482// SECTION: Bitwise OR operators: |, |=
1483// ----------------------------------------------------------------------------
1484
1485// Cases to consider when computing u | v:
1486// 1. u | 0 = u
1487// 2. 0 | v = v
1488// 3. u | v => sgn = +
1489// 4. (-u) | (-v) => sgn = -
1490// 5. u | (-v) => sgn = -
1491// 6. (-u) | v => sgn = -
1492
1493sc_unsigned
1494operator | (const sc_unsigned &u, const sc_unsigned &v)
1495{
1496 if (v.sgn == SC_ZERO) // case 1
1497 return sc_unsigned(u);
1498
1499 if (u.sgn == SC_ZERO) // case 2
1500 return sc_unsigned(v);
1501
1502 // other cases
1503 return or_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1504 v.sgn, v.nbits, v.ndigits, v.digit);
1505}
1506
1507
1508sc_unsigned
1509operator | (const sc_unsigned &u, uint64 v)
1510{
1511 if (v == 0) // case 1
1512 return sc_unsigned(u);
1513
1514 CONVERT_INT64(v);
1515
1516 if (u.sgn == SC_ZERO) // case 2
1517 return sc_unsigned(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
1518
1519 // other cases
1520 return or_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1521 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1522}
1523
1524
1525sc_unsigned
1526operator | (uint64 u, const sc_unsigned &v)
1527{
1528 if (u == 0)
1529 return sc_unsigned(v);
1530
1531 CONVERT_INT64(u);
1532
1533 if (v.sgn == SC_ZERO)
1534 return sc_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
1535
1536 // other cases
1537 return or_unsigned_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
1538 v.sgn, v.nbits, v.ndigits, v.digit);
1539}
1540
1541
1542sc_unsigned
1543operator | (const sc_unsigned &u, unsigned long v)
1544{
1545 if (v == 0) // case 1
1546 return sc_unsigned(u);
1547
1548 CONVERT_LONG(v);
1549
1550 if (u.sgn == SC_ZERO) // case 2
1551 return sc_unsigned(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
1552
1553 // other cases
1554 return or_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1555 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1556}
1557
1558
1559sc_unsigned
1560operator | (unsigned long u, const sc_unsigned &v)
1561{
1562 if (u == 0)
1563 return sc_unsigned(v);
1564
1565 CONVERT_LONG(u);
1566
1567 if (v.sgn == SC_ZERO)
1568 return sc_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
1569
1570 // other cases
1571 return or_unsigned_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
1572 v.sgn, v.nbits, v.ndigits, v.digit);
1573}
1574
1575// The rest of the operators in this section are included from
1576// sc_nbcommon.cpp.
1577
1578
1579// ----------------------------------------------------------------------------
1580// SECTION: Bitwise XOR operators: ^, ^=
1581// ----------------------------------------------------------------------------
1582
1583// Cases to consider when computing u ^ v:
1584// Note that u ^ v = (~u &v) | (u & ~v).
1585// 1. u ^ 0 = u
1586// 2. 0 ^ v = v
1587// 3. u ^ v => sgn = +
1588// 4. (-u) ^ (-v) => sgn = -
1589// 5. u ^ (-v) => sgn = -
1590// 6. (-u) ^ v => sgn = +
1591
1592sc_unsigned
1593operator ^ (const sc_unsigned &u, const sc_unsigned &v)
1594{
1595 if (v.sgn == SC_ZERO) // case 1
1596 return sc_unsigned(u);
1597
1598 if (u.sgn == SC_ZERO) // case 2
1599 return sc_unsigned(v);
1600
1601 // other cases
1602 return xor_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1603 v.sgn, v.nbits, v.ndigits, v.digit);
1604}
1605
1606
1607sc_unsigned
1608operator ^ (const sc_unsigned &u, uint64 v)
1609{
1610 if (v == 0) // case 1
1611 return sc_unsigned(u);
1612
1613 CONVERT_INT64(v);
1614
1615 if (u.sgn == SC_ZERO) // case 2
1616 return sc_unsigned(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
1617
1618 // other cases
1619 return xor_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1620 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1621}
1622
1623sc_unsigned
1624operator ^ (uint64 u, const sc_unsigned &v)
1625{
1626 if (u == 0)
1627 return sc_unsigned(v);
1628
1629 CONVERT_INT64(u);
1630
1631 if (v.sgn == SC_ZERO)
1632 return sc_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
1633
1634 // other cases
1635 return xor_unsigned_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
1636 v.sgn, v.nbits, v.ndigits, v.digit);
1637}
1638
1639
1640sc_unsigned
1641operator ^ (const sc_unsigned &u, unsigned long v)
1642{
1643 if (v == 0) // case 1
1644 return sc_unsigned(u);
1645
1646 CONVERT_LONG(v);
1647
1648 if (u.sgn == SC_ZERO) // case 2
1649 return sc_unsigned(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
1650
1651 // other cases
1652 return xor_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1653 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1654}
1655
1656sc_unsigned
1657operator ^ (unsigned long u, const sc_unsigned &v)
1658{
1659 if (u == 0)
1660 return sc_unsigned(v);
1661
1662 CONVERT_LONG(u);
1663
1664 if (v.sgn == SC_ZERO)
1665 return sc_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
1666
1667 // other cases
1668 return xor_unsigned_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
1669 v.sgn, v.nbits, v.ndigits, v.digit);
1670}
1671
1672// The rest of the operators in this section are included from
1673// sc_nbcommon.cpp.
1674
1675
1676// ----------------------------------------------------------------------------
1677// SECTION: Bitwise NOT operator: ~
1678// ----------------------------------------------------------------------------
1679
1680// Operators in this section are included from sc_nbcommon.cpp.
1681
1682
1683// ----------------------------------------------------------------------------
1684// SECTION: LEFT SHIFT operators: <<, <<=
1685// ----------------------------------------------------------------------------
1686
1687sc_unsigned
1688operator << (const sc_unsigned &u, const sc_signed &v)
1689{
1690 if ((v.sgn == SC_ZERO) || (v.sgn == SC_NEG))
1691 return sc_unsigned(u);
1692
1693 return operator << (u, v.to_ulong());
1694}
1695
1696// The rest of the operators in this section are included from
1697// sc_nbcommon.cpp.
1698
1699
1700// ----------------------------------------------------------------------------
1701// SECTION: RIGHT SHIFT operators: >>, >>=
1702// ----------------------------------------------------------------------------
1703
1704sc_unsigned
1705operator >> (const sc_unsigned &u, const sc_signed &v)
1706{
1707
1708 if ((v.sgn == SC_ZERO) || (v.sgn == SC_NEG))
1709 return sc_unsigned(u);
1710
1711 return operator >> (u, v.to_long());
1712
1713}
1714
1715// The rest of the operators in this section are included from
1716// sc_nbcommon.cpp.
1717
1718
1719// ----------------------------------------------------------------------------
1720// SECTION: Unary arithmetic operators.
1721// ----------------------------------------------------------------------------
1722
1723sc_unsigned
1724operator + (const sc_unsigned &u)
1725{
1726 return sc_unsigned(u);
1727}
1728
1729
1730// ----------------------------------------------------------------------------
1731// SECTION: EQUAL operator: ==
1732// ----------------------------------------------------------------------------
1733
1734bool
1735operator == (const sc_unsigned &u, const sc_unsigned &v)
1736{
1737 if (&u == &v)
1738 return true;
1739 if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
1740 v.sgn, v.nbits, v.ndigits, v.digit) != 0) {
1741 return false;
1742 }
1743 return true;
1744}
1745
1746
1747bool
1748operator == (const sc_unsigned &u, const sc_signed &v)
1749{
1750 if (v.sgn == SC_NEG)
1751 return false;
1752 if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
1753 v.sgn, v.nbits, v.ndigits, v.digit, 0, 1) != 0) {
1754 return false;
1755 }
1756 return true;
1757}
1758
1759
1760bool
1761operator == (const sc_signed &u, const sc_unsigned &v)
1762{
1763 if (u.sgn == SC_NEG)
1764 return false;
1765 if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
1766 v.sgn, v.nbits, v.ndigits, v.digit, 1, 0) != 0) {
1767 return false;
1768 }
1769 return true;
1770}
1771
1772
1773bool
1774operator == (const sc_unsigned &u, int64 v)
1775{
1776 if (v < 0)
1777 return false;
1778 CONVERT_INT64(v);
1779 if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
1780 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd) != 0) {
1781 return false;
1782 }
1783 return true;
1784}
1785
1786
1787bool
1788operator == (int64 u, const sc_unsigned &v)
1789{
1790 if (u < 0)
1791 return false;
1792 CONVERT_INT64(u);
1793 if (compare_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
1794 v.sgn, v.nbits, v.ndigits, v.digit) != 0) {
1795 return false;
1796 }
1797 return true;
1798}
1799
1800
1801bool
1802operator == (const sc_unsigned &u, uint64 v)
1803{
1804 CONVERT_INT64(v);
1805 if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
1806 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd) != 0)
1807 return false;
1808 return true;
1809}
1810
1811
1812bool
1813operator == (uint64 u, const sc_unsigned &v)
1814{
1815 CONVERT_INT64(u);
1816 if (compare_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
1817 v.sgn, v.nbits, v.ndigits, v.digit) != 0)
1818 return false;
1819 return true;
1820}
1821
1822
1823bool
1824operator == (const sc_unsigned &u, long v)
1825{
1826 if (v < 0)
1827 return false;
1828 CONVERT_LONG(v);
1829 if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
1830 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd) != 0)
1831 return false;
1832 return true;
1833}
1834
1835
1836bool
1837operator == (long u, const sc_unsigned &v)
1838{
1839 if (u < 0)
1840 return false;
1841 CONVERT_LONG(u);
1842 if (compare_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
1843 v.sgn, v.nbits, v.ndigits, v.digit) != 0)
1844 return false;
1845 return true;
1846}
1847
1848
1849bool
1850operator == (const sc_unsigned &u, unsigned long v)
1851{
1852 CONVERT_LONG(v);
1853 if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
1854 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd) != 0)
1855 return false;
1856 return true;
1857}
1858
1859
1860bool
1861operator == (unsigned long u, const sc_unsigned &v)
1862{
1863 CONVERT_LONG(u);
1864 if (compare_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
1865 v.sgn, v.nbits, v.ndigits, v.digit) != 0)
1866 return false;
1867 return true;
1868}
1869
1870
1871// ----------------------------------------------------------------------------
1872// SECTION: NOT_EQUAL operator: !=
1873// ----------------------------------------------------------------------------
1874
1875bool
1876operator != (const sc_unsigned &u, const sc_signed &v)
1877{
1878 return (!operator == (u, v));
1879}
1880
1881
1882bool
1883operator != (const sc_signed &u, const sc_unsigned &v)
1884{
1885 return (!operator == (u, v));
1886}
1887
1888// The rest of the operators in this section are included from sc_nbcommon.cpp.
1889
1890
1891// ----------------------------------------------------------------------------
1892// SECTION: LESS THAN operator: <
1893// ----------------------------------------------------------------------------
1894
1895bool
1896operator < (const sc_unsigned &u, const sc_unsigned &v)
1897{
1898 if (&u == &v)
1899 return false;
1900 if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
1901 v.sgn, v.nbits, v.ndigits, v.digit) < 0) {
1902 return true;
1903 }
1904 return false;
1905}
1906
1907
1908bool
1909operator < (const sc_unsigned &u, const sc_signed &v)
1910{
1911 if (v.sgn == SC_NEG)
1912 return false;
1913 if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
1914 v.sgn, v.nbits, v.ndigits, v.digit, 0, 1) < 0) {
1915 return true;
1916 }
1917 return false;
1918}
1919
1920
1921bool
1922operator < (const sc_signed &u, const sc_unsigned &v)
1923{
1924 if (u.sgn == SC_NEG)
1925 return true;
1926 if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
1927 v.sgn, v.nbits, v.ndigits, v.digit, 1, 0) < 0) {
1928 return true;
1929 }
1930 return false;
1931}
1932
1933
1934bool
1935operator < (const sc_unsigned &u, int64 v)
1936{
1937 if (v < 0)
1938 return false;
1939 CONVERT_INT64(v);
1940 if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
1941 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd) < 0) {
1942 return true;
1943 }
1944 return false;
1945}
1946
1947
1948bool
1949operator < (int64 u, const sc_unsigned &v)
1950{
1951 if (u < 0)
1952 return true;
1953 CONVERT_INT64(u);
1954 if (compare_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
1955 v.sgn, v.nbits, v.ndigits, v.digit) < 0) {
1956 return true;
1957 }
1958 return false;
1959}
1960
1961
1962bool
1963operator < (const sc_unsigned &u, uint64 v)
1964{
1965 CONVERT_INT64(v);
1966 if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
1967 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd) < 0) {
1968 return true;
1969 }
1970 return false;
1971}
1972
1973
1974bool
1975operator < (uint64 u, const sc_unsigned &v)
1976{
1977 CONVERT_INT64(u);
1978 if (compare_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
1979 v.sgn, v.nbits, v.ndigits, v.digit) < 0){
1980 return true;
1981 }
1982 return false;
1983}
1984
1985
1986bool
1987operator < (const sc_unsigned &u, long v)
1988{
1989 if (v < 0)
1990 return false;
1991 CONVERT_LONG(v);
1992 if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
1993 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd) < 0) {
1994 return true;
1995 }
1996 return false;
1997}
1998
1999
2000bool
2001operator < (long u, const sc_unsigned &v)
2002{
2003 if (u < 0)
2004 return true;
2005 CONVERT_LONG(u);
2006 if (compare_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
2007 v.sgn, v.nbits, v.ndigits, v.digit) < 0) {
2008 return true;
2009 }
2010 return false;
2011}
2012
2013
2014bool
2015operator < (const sc_unsigned &u, unsigned long v)
2016{
2017 CONVERT_LONG(v);
2018 if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
2019 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd) < 0) {
2020 return true;
2021 }
2022 return false;
2023}
2024
2025
2026bool
2027operator < (unsigned long u, const sc_unsigned &v)
2028{
2029 CONVERT_LONG(u);
2030 if (compare_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
2031 v.sgn, v.nbits, v.ndigits, v.digit) < 0) {
2032 return true;
2033 }
2034 return false;
2035}
2036
2037
2038// ----------------------------------------------------------------------------
2039// SECTION: LESS THAN or EQUAL operator: <=
2040// ----------------------------------------------------------------------------
2041
2042bool
2043operator <= (const sc_unsigned &u, const sc_signed &v)
2044{
2045 return (operator < (u, v) || operator == (u, v));
2046}
2047
2048
2049bool
2050operator <= (const sc_signed &u, const sc_unsigned &v)
2051{
2052 return (operator < (u, v) || operator == (u, v));
2053}
2054
2055// The rest of the operators in this section are included from sc_nbcommon.cpp.
2056
2057
2058// ----------------------------------------------------------------------------
2059// SECTION: GREATER THAN operator: >
2060// ----------------------------------------------------------------------------
2061
2062bool
2063operator > (const sc_unsigned &u, const sc_signed &v)
2064{
2065 return (!(operator <= (u, v)));
2066}
2067
2068
2069bool
2070operator > (const sc_signed &u, const sc_unsigned &v)
2071{
2072 return (!(operator <= (u, v)));
2073}
2074
2075// The rest of the operators in this section are included from sc_nbcommon.cpp.
2076
2077
2078// ----------------------------------------------------------------------------
2079// SECTION: GREATER THAN or EQUAL operator: >=
2080// ----------------------------------------------------------------------------
2081
2082bool
2083operator >= (const sc_unsigned &u, const sc_signed &v)
2084{
2085 return (!(operator < (u, v)));
2086}
2087
2088
2089bool
2090operator >= (const sc_signed &u, const sc_unsigned &v)
2091{
2092 return (!(operator < (u, v)));
2093}
2094
2095// The rest of the operators in this section are included from sc_nbcommon.cpp.
2096
2097
2098// ----------------------------------------------------------------------------
2099// SECTION: Friends
2100// ----------------------------------------------------------------------------
2101
2102// Compare u and v as unsigned and return r
2103// r = 0 if u == v
2104// r < 0 if u < v
2105// r > 0 if u > v
2106
2107int
2108compare_unsigned(small_type us, int unb, int und, const sc_digit *ud,
2109 small_type vs, int vnb, int vnd, const sc_digit *vd,
2110 small_type if_u_signed, small_type if_v_signed)
2111{
2112 if (us == vs) {
2113 if (us == SC_ZERO) {
2114 return 0;
2115 } else {
2116 int cmp_res = vec_skip_and_cmp(und, ud, vnd, vd);
2117 if (us == SC_POS)
2118 return cmp_res;
2119 else
2120 return -cmp_res;
2121 }
2122 } else {
2123 if (us == SC_ZERO)
2124 return -vs;
2125 if (vs == SC_ZERO)
2126 return us;
2127
2128 int cmp_res;
2129 int nd = (us == SC_NEG ? und : vnd);
2130
2131#ifdef SC_MAX_NBITS
2132 sc_digit d[MAX_NDIGITS];
2133#else
2134 sc_digit *d = new sc_digit[nd];
2135#endif
2136
2137 if (us == SC_NEG) {
2138 vec_copy(nd, d, ud);
2139 vec_complement(nd, d);
2140 trim(if_u_signed, unb, nd, d);
2141 cmp_res = vec_skip_and_cmp(nd, d, vnd, vd);
2142 } else {
2143 vec_copy(nd, d, vd);
2144 vec_complement(nd, d);
2145 trim(if_v_signed, vnb, nd, d);
2146 cmp_res = vec_skip_and_cmp(und, ud, nd, d);
2147 }
2148
2149#ifndef SC_MAX_NBITS
2150 delete [] d;
2151#endif
2152
2153 return cmp_res;
2154 }
2155}
2156
2157
2158// ----------------------------------------------------------------------------
2159// SECTION: Public members - Other utils.
2160// ----------------------------------------------------------------------------
2161
2162bool
2163sc_unsigned::iszero() const
2164{
2165 if (sgn == SC_ZERO) {
2166 return true;
2167 } else if (sgn == SC_NEG) {
2168 // A negative unsigned number can be zero, e.g., -16 in 4 bits, so
2169 // check that.
2170
2171#ifdef SC_MAX_NBITS
2172 sc_digit d[MAX_NDIGITS];
2173#else
2174 sc_digit *d = new sc_digit[ndigits];
2175#endif
2176
2177 vec_copy(ndigits, d, digit);
2178 vec_complement(ndigits, d);
2179 trim_unsigned(nbits, ndigits, d);
2180
2181 bool res = check_for_zero(ndigits, d);
2182
2183#ifndef SC_MAX_NBITS
2184 delete [] d;
2185#endif
2186
2187 return res;
2188 } else {
2189 return false;
2190 }
2191}
2192
2193// The rest of the utils in this section are included from sc_nbcommon.cpp.
2194
2195
2196// ----------------------------------------------------------------------------
2197// SECTION: Private members.
2198// ----------------------------------------------------------------------------
2199
2200// The private members in this section are included from
2201// sc_nbcommon.cpp.
2202
2203#define CLASS_TYPE sc_unsigned
2204#define CLASS_TYPE_STR "sc_unsigned"
2205
2206#define ADD_HELPER add_unsigned_friend
2207#define SUB_HELPER sub_unsigned_friend
2208#define MUL_HELPER mul_unsigned_friend
2209#define DIV_HELPER div_unsigned_friend
2210#define MOD_HELPER mod_unsigned_friend
2211#define AND_HELPER and_unsigned_friend
2212#define OR_HELPER or_unsigned_friend
2213#define XOR_HELPER xor_unsigned_friend
2214
2215#include "sc_nbfriends.inc"
2216
2217#undef SC_SIGNED
2218#define SC_UNSIGNED
2219#define IF_SC_SIGNED 0 // 0 = sc_unsigned
2220#define CLASS_TYPE_SUBREF sc_unsigned_subref_r
2221#define OTHER_CLASS_TYPE sc_signed
2222#define OTHER_CLASS_TYPE_SUBREF sc_signed_subref_r
2223
2224#define MUL_ON_HELPER mul_on_help_unsigned
2225#define DIV_ON_HELPER div_on_help_unsigned
2226#define MOD_ON_HELPER mod_on_help_unsigned
2227
2228#include "sc_nbcommon.inc"
2229
2230#undef MOD_ON_HELPER
2231#undef DIV_ON_HELPER
2232#undef MUL_ON_HELPER
2233
2234#undef OTHER_CLASS_TYPE_SUBREF
2235#undef OTHER_CLASS_TYPE
2236#undef CLASS_TYPE_SUBREF
2237#undef IF_SC_SIGNED
2238#undef SC_UNSIGNED
2239
2240#undef XOR_HELPER
2241#undef OR_HELPER
2242#undef AND_HELPER
2243#undef MOD_HELPER
2244#undef DIV_HELPER
2245#undef MUL_HELPER
2246#undef SUB_HELPER
2247#undef ADD_HELPER
2248
2249#undef CLASS_TYPE
2250#undef CLASS_TYPE_STR
2251
2252#include "sc_unsigned_bitref.inc"
2253#include "sc_unsigned_subref.inc"
2254
2255#undef CONVERT_LONG
2256#undef CONVERT_LONG_2
2257#undef CONVERT_INT64
2258#undef CONVERT_INT64_2
2259
2260} // namespace sc_dt