sc_unsigned.cc revision 13322
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 2261