Google Git Google Git
Sign in
gem5/public/gem5/b8ecd2784c24879712b598fe940d8a73ec6842b1/./src/systemc/dt/int/sc_nbutils.cc
blob: a78013d772db182bb87f5315f79b4a181f3ab911 [file]
/*****************************************************************************
Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
more contributor license agreements. See the NOTICE file distributed
with this work for additional information regarding copyright ownership.
Accellera licenses this file to you under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with the
License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied. See the License for the specific language governing
permissions and limitations under the License.
*****************************************************************************/
/*****************************************************************************
sc_nbutils.cpp -- External and friend functions for both sc_signed and
sc_unsigned classes.
Original Author: Ali Dasdan, Synopsys, Inc.
*****************************************************************************/
/*****************************************************************************
MODIFICATION LOG - modifiers, enter your name, affiliation, date and
changes you are making here.
Name, Affiliation, Date:
Description of Modification:
*****************************************************************************/
// $Log: sc_nbutils.cpp,v $
// Revision 1.4 2011/08/24 22:05:46 acg
// Torsten Maehne: initialization changes to remove warnings.
//
// Revision 1.3 2011/02/18 20:19:15 acg
// Andy Goodrich: updating Copyright notice.
//
// Revision 1.2 2007/11/04 21:26:40 acg
// Andy Goodrich: added a buffer to the allocation of the q array to address
// an issue with references outside the array by 1 byte detected by valgrind.
//
// Revision 1.1.1.1 2006/12/15 20:20:05 acg
// SystemC 2.3
//
// Revision 1.3 2006/01/13 18:49:32 acg
// Added $Log command so that CVS check in comments are reproduced in the
// source.
//
#include <cctype>
#include <cstdio>
#include <cstring>
#include <sstream>
#include "systemc/ext/dt/bit/messages.hh"
#include "systemc/ext/dt/int/messages.hh"
#include "systemc/ext/dt/int/sc_nbutils.hh"
#include "systemc/ext/utils/functions.hh"
namespace sc_dt
{
// only used within vec_from_str (non-standard, deprecated)
static inline void
is_valid_base(sc_numrep base)
{
switch (base) {
case SC_NOBASE: case SC_BIN:
case SC_OCT: case SC_DEC:
case SC_HEX:
break;
case SC_BIN_US: case SC_BIN_SM:
case SC_OCT_US: case SC_OCT_SM:
case SC_HEX_US: case SC_HEX_SM:
case SC_CSD:
SC_REPORT_ERROR("not implemented",
"is_valid_base( sc_numrep base ) : "
"bases SC_CSD, or ending in _US and _SM are "
"not supported");
break;
default:
std::stringstream msg;
msg << "is_valid_base( sc_numrep base ) : base = " << base <<
" is not valid";
SC_REPORT_ERROR(sc_core::SC_ID_VALUE_NOT_VALID_, msg.str().c_str());
}
}
// ----------------------------------------------------------------------------
// ENUM : sc_numrep
//
// Enumeration of number representations for character string conversion.
// ----------------------------------------------------------------------------
const std::string
to_string(sc_numrep numrep)
{
switch (numrep) {
#define CASE_ENUM2STR(Value) case Value: return #Value
CASE_ENUM2STR(SC_DEC);
CASE_ENUM2STR(SC_BIN);
CASE_ENUM2STR(SC_BIN_US);
CASE_ENUM2STR(SC_BIN_SM);
CASE_ENUM2STR(SC_OCT);
CASE_ENUM2STR(SC_OCT_US);
CASE_ENUM2STR(SC_OCT_SM);
CASE_ENUM2STR(SC_HEX);
CASE_ENUM2STR(SC_HEX_US);
CASE_ENUM2STR(SC_HEX_SM);
CASE_ENUM2STR(SC_CSD);
#undef CASE_ENUM2STR
default:
return "unknown";
}
}
// ----------------------------------------------------------------------------
// SECTION: General utility functions.
// ----------------------------------------------------------------------------
// Return the number of characters to advance the source of c. This
// function implements one move of the FSM to parse the following
// regular expressions. Error checking is done in the caller.
small_type
fsm_move(char c, small_type &b, small_type &s, small_type &state)
{
// Possible regular expressions (REs):
// Let N = any digit depending on the base.
// 1. [0|1|..|9]N*
// 2. [+|-][0|1|..|9]N*
// 3. 0[b|B|d|D|o|O|x|X][0|1|..|F]N*
// 4. [+|-]?0[b|B|d|D|o|O|x|X][0|1|..|F]N*
//
// The finite state machine (FMS) to parse these regular expressions
// has 4 states, 0 to 3. 0 is the initial state and 3 is the final
// state.
//
// Default sign = SC_POS, default base = NB_DEFAULT_BASE.
switch (state) {
case 0: // The initial state.
switch (c) {
case '0': s = SC_POS; state = 1; return 0; // RE 1 or 3
case '+': s = SC_POS; state = 2; return 1; // RE 2
case '-': s = SC_NEG; state = 2; return 1; // RE 2
default:
s = SC_POS; b = NB_DEFAULT_BASE; state = 3; return 0; // RE 1
}
// break; //unreachable code
case 1: // 0...
switch (c) {
case 'x': case 'X': b = SC_HEX; state = 3; return 2; // RE 3 or 4
case 'd': case 'D': b = SC_DEC; state = 3; return 2; // RE 3 or 4
case 'o': case 'O': b = SC_OCT; state = 3; return 2; // RE 3 or 4
case 'b': case 'B': b = SC_BIN; state = 3; return 2; // RE 3 or 4
default: b = NB_DEFAULT_BASE; state = 3; return 0; // RE 1
}
// break; //unreachable code
case 2: // +... or -...
switch (c) {
case '0': state = 1; return 0; // RE 2 or 4
default: b = NB_DEFAULT_BASE; state = 3; return 0; // RE 2
}
// break; //unreachable code
case 3: // The final state.
break;
default:
// Any other state is not possible.
sc_assert((0 <= state) && (state <= 3));
} // switch
return 0;
}
// Get base b and sign s of the number in the char string v. Return a
// pointer to the first char after the point where b and s are
// determined or where the end of v is reached. The input string v has
// to be null terminated.
const char *
get_base_and_sign(const char *v, small_type &b, small_type &s)
{
#ifdef DEBUG_SYSTEMC
sc_assert(v != NULL);
#endif
const small_type STATE_START = 0;
const small_type STATE_FINISH = 3;
// Default sign = SC_POS, default base = 10.
s = SC_POS;
b = NB_DEFAULT_BASE;
small_type state = STATE_START;
small_type nskip = 0; // Skip that many chars.
const char *u = v;
while (*u) {
if (isspace(*u)) { // Skip white space.
++u;
} else {
nskip += fsm_move(*u, b, s, state);
if (state == STATE_FINISH)
break;
else
++u;
}
}
// Test to see if the above loop executed more than it should
// have. The max number of skipped chars is equal to the length of
// the longest format specifier, e.g., "-0x".
sc_assert(nskip <= 3);
v += nskip;
// Handles empty strings or strings without any digits after the
// base or base and sign specifier.
if (*v == '\0') {
static const char msg[] =
"get_base_and_sign( const char* v, small_type&, small_type& ) : "
"v = \"\" is not valid";
SC_REPORT_ERROR(sc_core::SC_ID_CONVERSION_FAILED_, msg);
}
return v;
}
//-----------------------------------------------------------------------------
//"parse_binary_bits"
//
// This function parses the supplied string into the supplied vector as a
// right justified bit value.
// src_p -> character string representing the bits to be parsed.
// dst_n = number of words in data_p and ctrl_p.
// data_p -> words w/BITS_PER_DIGIT bits to receive the value's data bits.
// ctrl_p -> words w/BITS_PER_DIGIT bits to receive the value's control
// bits, or zero.
// Result is true if value was non-zero.
//-----------------------------------------------------------------------------
void
parse_binary_bits(const char *src_p, int dst_n,
sc_digit *data_p, sc_digit *ctrl_p)
{
int bit_i; // Number of bit now processing.
sc_digit ctrl; // Control word now assembling.
sc_digit data; // Data word now assembling.
int delta_n; // src_n - dst_n*BITS_PER_DIGIT.
int src_i; // Index in src_p now accessing (left to right).
int src_n; // Length of source that is left in bits.
int word_i; // Bit within word now accessing (left to right).
// MAKE SURE WE HAVE A STRING TO PARSE:
if (src_p == 0) {
SC_REPORT_ERROR(sc_core::SC_ID_CONVERSION_FAILED_,
"character string is zero");
return;
}
if (*src_p == 0) {
SC_REPORT_ERROR(sc_core::SC_ID_CONVERSION_FAILED_,
"character string is empty");
return;
}
// INDEX INTO THE SOURCE TO A DEPTH THAT WILL ACCOMODATE OUR SIZE:
//
// If the source is smaller than our value initialize our value to zero.
src_n = strlen(src_p);
delta_n = src_n - (dst_n*BITS_PER_DIGIT);
if (delta_n > 0) {
src_p = &src_p[delta_n];
src_n -= delta_n;
} else {
for (word_i = 0; word_i < dst_n; word_i++)
data_p[word_i] = 0;
if (ctrl_p)
for (word_i = 0; word_i < dst_n; word_i++)
ctrl_p[word_i] = 0;
}
// LOOP OVER THE SOURCE ASSEMBLING WORDS AND PLACING THEM IN OUR VALUE:
//
// We stride right to left through the source in BITS_PER_DIGIT chunks.
// Each of those chunks is processed from left to right a bit at a time.
// We process the high order word specially, since there are less bits.
src_n = src_n - BITS_PER_DIGIT;
for (word_i=0; word_i < dst_n; word_i++) {
src_i = src_n;
// PARTIAL LAST WORD TO ASSEMBLE:
if (src_i < 0) {
src_n += BITS_PER_DIGIT;
data = 0;
ctrl = 0;
for (src_i = 0; src_i < src_n; src_i++) {
ctrl = ctrl << 1;
data = data << 1;
switch (src_p[src_i]) {
case 'X':
case 'x': ctrl = ctrl | 1; data = data | 1; break;
case '1': data = data | 1; break;
case 'Z':
case 'z': ctrl = ctrl | 1; break;
case '0': break;
default:
{
std::stringstream msg;
msg << "character string '" << src_p <<
"' is not valid";
SC_REPORT_ERROR(sc_core::SC_ID_CONVERSION_FAILED_,
msg.str().c_str());
return;
}
break;
}
}
if (ctrl_p)
ctrl_p[word_i] = ctrl;
data_p[word_i] = data;
break;
}
// FULL WORD TO BE ASSEMBLED:
ctrl = 0;
data = 0;
for (bit_i = 0; bit_i < BITS_PER_DIGIT; bit_i++) {
ctrl = ctrl << 1;
data = data << 1;
switch (src_p[src_i++]) {
case 'X':
case 'x': ctrl = ctrl | 1; data = data | 1; break;
case '1': data = data | 1; break;
case 'Z':
case 'z': ctrl = ctrl | 1; break;
case '0': break;
default:
{
std::stringstream msg;
msg << "character string '" << src_p <<
"' is not valid";
SC_REPORT_ERROR(sc_core::SC_ID_CONVERSION_FAILED_,
msg.str().c_str());
return;
}
break;
}
}
if (ctrl_p)
ctrl_p[word_i] = ctrl;
data_p[word_i] = data;
src_n = src_n - BITS_PER_DIGIT;
}
}
//-----------------------------------------------------------------------------
//"parse_hex_bits"
//
// This function parses the supplied string into the supplied vector as a
// right justified bit value.
// src_p -> character string representing the bits to be parsed.
// dst_n = number of words in data_p and ctrl_p.
// data_p -> words w/32 bits to receive the value's data bits.
// ctrl_p -> words w/32 bits to receive the value's control bits,
// or zero.
// Result is true if value was non-zero.
//-----------------------------------------------------------------------------
void
parse_hex_bits(const char *src_p, int dst_n,
sc_digit *data_p, sc_digit *ctrl_p)
{
sc_digit ctrl; // Control word now assembling.
sc_digit data; // Data word now assembling.
int delta_n; // src_n - dst_n*BITS_PER_DIGIT.
int digit_i; // Number of digit now processing.
int src_i; // Index in src_p now accessing (left to right).
int src_n; // Length of source that is left in bits.
int word_i; // Bit within word now accessing (left to right).
// MAKE SURE WE HAVE A STRING TO PARSE:
if (src_p == 0) {
SC_REPORT_ERROR(sc_core::SC_ID_CONVERSION_FAILED_,
"character string is zero");
return;
}
if (*src_p == 0) {
SC_REPORT_ERROR(sc_core::SC_ID_CONVERSION_FAILED_,
"character string is empty");
return;
}
// INDEX INTO THE SOURCE TO A DEPTH THAT WILL ACCOMODATE OUR SIZE:
//
// If the source is smaller than our value initialize our value to zero.
src_n = strlen(src_p);
delta_n = src_n - (dst_n*8);
if (delta_n > 0) {
src_p = &src_p[delta_n];
src_n -= delta_n;
} else {
for (word_i = 0; word_i < dst_n; word_i++)
data_p[word_i] = 0;
if (ctrl_p)
for (word_i = 0; word_i < dst_n; word_i++)
ctrl_p[word_i] = 0;
}
// LOOP OVER THE SOURCE ASSEMBLING WORDS AND PLACING THEM IN OUR VALUE:
//
// We stride right to left through the source in BITS_PER_DIGIT chunks.
// Each of those chunks is processed from left to right a bit at a time.
// We process the high order word specially, since there are less bits.
src_n = src_n - 8;
for (word_i = 0; word_i < dst_n; word_i++) {
src_i = src_n;
// PARTIAL LAST WORD TO ASSEMBLE:
if (src_i < 0) {
src_n += 8;
data = 0;
ctrl = 0;
for (src_i = 0; src_i < src_n; src_i++) {
ctrl = ctrl << 4;
data = data << 4;
switch (src_p[src_i]) {
case 'X':
case 'x': ctrl = ctrl | 15; data = data | 15; break;
case 'F':
case 'f': data = data | 15; break;
case 'E':
case 'e': data = data | 14; break;
case 'D':
case 'd': data = data | 13; break;
case 'C':
case 'c': data = data | 12; break;
case 'B':
case 'b': data = data | 11; break;
case 'A':
case 'a': data = data | 10; break;
case '9': data = data | 9; break;
case '8': data = data | 8; break;
case '7': data = data | 7; break;
case '6': data = data | 6; break;
case '5': data = data | 5; break;
case '4': data = data | 4; break;
case '3': data = data | 3; break;
case '2': data = data | 2; break;
case '1': data = data | 1; break;
case '0': break;
case 'Z':
case 'z': ctrl = ctrl | 15; break;
default:
{
std::stringstream msg;
msg << "character string '" << src_p <<
"' is not valid";
SC_REPORT_ERROR(sc_core::SC_ID_CONVERSION_FAILED_,
msg.str().c_str());
return;
}
break;
}
}
if (ctrl_p)
ctrl_p[word_i] = ctrl;
data_p[word_i] = data;
break;
}
// FULL WORD TO BE ASSEMBLED:
ctrl = 0;
data = 0;
for (digit_i = 0; digit_i < 8; digit_i++) {
ctrl = ctrl << 4;
data = data << 4;
switch (src_p[src_i++]) {
case 'X':
case 'x': ctrl = ctrl | 15; data = data | 15; break;
case 'F':
case 'f': data = data | 15; break;
case 'E':
case 'e': data = data | 14; break;
case 'D':
case 'd': data = data | 13; break;
case 'C':
case 'c': data = data | 12; break;
case 'B':
case 'b': data = data | 11; break;
case 'A':
case 'a': data = data | 10; break;
case '9': data = data | 9; break;
case '8': data = data | 8; break;
case '7': data = data | 7; break;
case '6': data = data | 6; break;
case '5': data = data | 5; break;
case '4': data = data | 4; break;
case '3': data = data | 3; break;
case '2': data = data | 2; break;
case '1': data = data | 1; break;
case '0': break;
case 'Z':
case 'z': ctrl = ctrl | 15; break;
default:
{
std::stringstream msg;
msg << "character string '" << src_p << "' is not valid";
SC_REPORT_ERROR(sc_core::SC_ID_CONVERSION_FAILED_,
msg.str().c_str() );
return;
}
break;
}
}
if (ctrl_p)
ctrl_p[word_i] = ctrl;
data_p[word_i] = data;
src_n = src_n - BITS_PER_DIGIT;
}
}
// ----------------------------------------------------------------------------
// SECTION: Utility functions involving unsigned vectors.
// ----------------------------------------------------------------------------
// Read u from a null terminated char string v. Note that operator>>
// in sc_nbcommon.cpp is similar to this function.
small_type
vec_from_str(int unb, int und, sc_digit *u, const char *v, sc_numrep base)
{
#ifdef DEBUG_SYSTEMC
sc_assert((unb > 0) && (und > 0) && (u != NULL));
sc_assert(v != NULL);
#endif
is_valid_base(base);
small_type b, s; // base and sign.
v = get_base_and_sign(v, b, s);
if (base != SC_NOBASE) {
if (b == NB_DEFAULT_BASE) {
b = base;
} else {
std::stringstream msg;
msg << "vec_from_str( int, int, sc_digit*, const char*, " <<
"sc_numrep base ) : base = " << base <<
" does not match the default base";
SC_REPORT_ERROR(sc_core::SC_ID_CONVERSION_FAILED_,
msg.str().c_str());
return 0;
}
}
vec_zero(und, u);
char c;
for (; (c = *v); ++v) {
if (isalnum(c)) {
small_type val; // Numeric value of a char.
if (isalpha(c)) // Hex digit.
val = toupper(c) - 'A' + 10;
else
val = c - '0';
if (val >= b) {
std::stringstream msg;
msg << "vec_from_str( int, int, sc_digit*, const char*, " <<
"sc_numrep base ) : '" << *v << "' is not a valid " <<
"digit in base " << b;
SC_REPORT_ERROR(sc_core::SC_ID_CONVERSION_FAILED_,
msg.str().c_str());
return 0;
}
// digit = digit * b + val;
vec_mul_small_on(und, u, b);
if (val)
vec_add_small_on(und, u, val);
} else {
std::stringstream msg;
msg << "vec_from_str( int, int, sc_digit*, const char*, " <<
"sc_numrep base ) : '" << *v << "' is not a valid " <<
"digit in base " << b;
SC_REPORT_ERROR(sc_core::SC_ID_CONVERSION_FAILED_,
msg.str().c_str());
return 0;
}
}
return convert_signed_SM_to_2C_to_SM(s, unb, und, u);
}
// All vec_ functions assume that the vector to hold the result,
// called w, has sufficient length to hold the result. For efficiency
// reasons, we do not test whether or not we are out of bounds.
// Compute w = u + v, where w, u, and v are vectors.
// - ulen >= vlen
// - wlen >= sc_max(ulen, vlen) + 1
void
vec_add(int ulen, const sc_digit *u, int vlen, const sc_digit *v, sc_digit *w)
{
#ifdef DEBUG_SYSTEMC
sc_assert((ulen > 0) && (u != NULL));
sc_assert((vlen > 0) && (v != NULL));
sc_assert(w != NULL);
sc_assert(ulen >= vlen);
#endif
const sc_digit *uend = (u + ulen);
const sc_digit *vend = (v + vlen);
sc_digit carry = 0; // Also used as sum to save space.
// Add along the shorter v.
while (v < vend) {
carry += (*u++) + (*v++);
(*w++) = carry & DIGIT_MASK;
carry >>= BITS_PER_DIGIT;
}
// Propagate the carry.
while (carry && (u < uend)) {
carry = (*u++) + 1;
(*w++) = carry & DIGIT_MASK;
carry >>= BITS_PER_DIGIT;
}
// Copy the rest of u to the result.
while (u < uend)
(*w++) = (*u++);
// Propagate the carry if it is still 1.
if (carry)
(*w) = 1;
}
// Compute u += v, where u and v are vectors.
// - ulen >= vlen
void
vec_add_on(int ulen, sc_digit *ubegin, int vlen, const sc_digit *v)
{
#ifdef DEBUG_SYSTEMC
sc_assert((ulen > 0) && (ubegin != NULL));
sc_assert((vlen > 0) && (v != NULL));
sc_assert(ulen >= vlen);
#endif
sc_digit *u = ubegin;
const sc_digit *uend = (u + ulen);
const sc_digit *vend = (v + vlen);
sc_digit carry = 0; // Also used as sum to save space.
// Add along the shorter v.
while (v < vend) {
carry += (*u) + (*v++);
(*u++) = carry & DIGIT_MASK;
carry >>= BITS_PER_DIGIT;
}
// Propagate the carry.
while (carry && (u < uend)) {
carry = (*u) + 1;
(*u++) = carry & DIGIT_MASK;
carry >>= BITS_PER_DIGIT;
}
#ifdef DEBUG_SYSTEMC
if (carry != 0) {
SC_REPORT_WARNING(sc_core::SC_ID_WITHOUT_MESSAGE_,
"vec_add_on( int, sc_digit*, int, const "
"sc_digit* ) : "
"result of addition is wrapped around");
}
#endif
}
// Compute u += v, where u and v are vectors.
// - ulen < vlen
void
vec_add_on2(int ulen, sc_digit *ubegin, int,
#ifdef DEBUG_SYSTEMC
vlen,
#endif
const sc_digit *v)
{
#ifdef DEBUG_SYSTEMC
sc_assert((ulen > 0) && (ubegin != NULL));
sc_assert((vlen > 0) && (v != NULL));
sc_assert(ulen < vlen);
#endif
sc_digit *u = ubegin;
const sc_digit *uend = (u + ulen);
sc_digit carry = 0; // Also used as sum to save space.
// Add along the shorter u.
while (u < uend) {
carry += (*u) + (*v++);
(*u++) = carry & DIGIT_MASK;
carry >>= BITS_PER_DIGIT;
}
#ifdef DEBUG_SYSTEMC
if (carry != 0) {
SC_REPORT_WARNING(sc_core::SC_ID_WITHOUT_MESSAGE_,
"vec_add_on2( int, sc_digit*, int, const "
"sc_digit* ) : "
"result of addition is wrapped around");
}
#endif
}
// Compute w = u + v, where w and u are vectors, and v is a scalar.
void
vec_add_small(int ulen, const sc_digit *u, sc_digit v, sc_digit *w)
{
#ifdef DEBUG_SYSTEMC
sc_assert((ulen > 0) && (u != NULL));
sc_assert(w != NULL);
#endif
const sc_digit *uend = (u + ulen);
// Add along the shorter v.
sc_digit carry = (*u++) + v;
(*w++) = carry & DIGIT_MASK;
carry >>= BITS_PER_DIGIT;
// Propagate the carry.
while (carry && (u < uend)) {
carry = (*u++) + 1;
(*w++) = carry & DIGIT_MASK;
carry >>= BITS_PER_DIGIT;
}
// Copy the rest of u to the result.
while (u < uend)
(*w++) = (*u++);
// Propagate the carry if it is still 1.
if (carry)
(*w) = 1;
}
// Compute u += v, where u is vectors, and v is a scalar.
void
vec_add_small_on(int ulen, sc_digit *u, sc_digit v)
{
#ifdef DEBUG_SYSTEMC
sc_assert((ulen > 0) && (u != NULL));
#endif
int i = 0;
while (v && (i < ulen)) {
v += u[i];
u[i++] = v & DIGIT_MASK;
v >>= BITS_PER_DIGIT;
}
#ifdef DEBUG_SYSTEMC
if (v != 0) {
SC_REPORT_WARNING(sc_core::SC_ID_WITHOUT_MESSAGE_,
"vec_add_small_on( int, sc_digit*, unsigned "
"long ) : "
"result of addition is wrapped around");
}
#endif
}
// Compute w = u - v, where w, u, and v are vectors.
// - ulen >= vlen
// - wlen >= sc_max(ulen, vlen)
void
vec_sub(int ulen, const sc_digit *u, int vlen, const sc_digit *v, sc_digit *w)
{
#ifdef DEBUG_SYSTEMC
sc_assert((ulen > 0) && (u != NULL));
sc_assert((vlen > 0) && (v != NULL));
sc_assert(w != NULL);
sc_assert(ulen >= vlen);
#endif
const sc_digit *uend = (u + ulen);
const sc_digit *vend = (v + vlen);
sc_digit borrow = 0; // Also used as diff to save space.
// Subtract along the shorter v.
while (v < vend) {
borrow = ((*u++) + DIGIT_RADIX) - (*v++) - borrow;
(*w++) = borrow & DIGIT_MASK;
borrow = 1 - (borrow >> BITS_PER_DIGIT);
}
// Propagate the borrow.
while (borrow && (u < uend)) {
borrow = ((*u++) + DIGIT_RADIX) - 1;
(*w++) = borrow & DIGIT_MASK;
borrow = 1 - (borrow >> BITS_PER_DIGIT);
}
#ifdef DEBUG_SYSTEMC
sc_assert(borrow == 0);
#endif
// Copy the rest of u to the result.
while (u < uend)
(*w++) = (*u++);
}
// Compute u = u - v, where u and v are vectors.
// - u > v
// - ulen >= vlen
void
vec_sub_on(int ulen, sc_digit *ubegin, int vlen, const sc_digit *v)
{
#ifdef DEBUG_SYSTEMC
sc_assert((ulen > 0) && (ubegin != NULL));
sc_assert((vlen > 0) && (v != NULL));
sc_assert(ulen >= vlen);
#endif
sc_digit *u = ubegin;
const sc_digit *uend = (u + ulen);
const sc_digit *vend = (v + vlen);
sc_digit borrow = 0; // Also used as diff to save space.
// Subtract along the shorter v.
while (v < vend) {
borrow = ((*u) + DIGIT_RADIX) - (*v++) - borrow;
(*u++) = borrow & DIGIT_MASK;
borrow = 1 - (borrow >> BITS_PER_DIGIT);
}
// Propagate the borrow.
while (borrow && (u < uend)) {
borrow = ((*u) + DIGIT_RADIX) - 1;
(*u++) = borrow & DIGIT_MASK;
borrow = 1 - (borrow >> BITS_PER_DIGIT);
}
#ifdef DEBUG_SYSTEMC
sc_assert(borrow == 0);
#endif
}
// Compute u = v - u, where u and v are vectors.
// - v > u
// - ulen <= vlen or ulen > ulen
void
vec_sub_on2(int ulen, sc_digit *ubegin, int vlen, const sc_digit *v)
{
#ifdef DEBUG_SYSTEMC
sc_assert((ulen > 0) && (ubegin != NULL));
sc_assert((vlen > 0) && (v != NULL));
#endif
sc_digit *u = ubegin;
const sc_digit *uend = (u + sc_min(ulen, vlen));
sc_digit borrow = 0; // Also used as diff to save space.
// Subtract along the shorter u.
while (u < uend) {
borrow = ((*v++) + DIGIT_RADIX) - (*u) - borrow;
(*u++) = borrow & DIGIT_MASK;
borrow = 1 - (borrow >> BITS_PER_DIGIT);
}
#ifdef DEBUG_SYSTEMC
if (borrow != 0) {
SC_REPORT_WARNING(sc_core::SC_ID_WITHOUT_MESSAGE_,
"vec_sub_on2( int, sc_digit*, int, const "
"sc_digit* ) : "
"result of subtraction is wrapped around");
}
#endif
}
// Compute w = u - v, where w and u are vectors, and v is a scalar.
void
vec_sub_small(int ulen, const sc_digit *u, sc_digit v, sc_digit *w)
{
#ifdef DEBUG_SYSTEMC
sc_assert(ulen > 0);
sc_assert(u != NULL);
#endif
const sc_digit *uend = (u + ulen);
// Add along the shorter v.
sc_digit borrow = ((*u++) + DIGIT_RADIX) - v;
(*w++) = borrow & DIGIT_MASK;
borrow = 1 - (borrow >> BITS_PER_DIGIT);
// Propagate the borrow.
while (borrow && (u < uend)) {
borrow = ((*u++) + DIGIT_RADIX) - 1;
(*w++) = borrow & DIGIT_MASK;
borrow = 1 - (borrow >> BITS_PER_DIGIT);
}
#ifdef DEBUG_SYSTEMC
sc_assert(borrow == 0);
#endif
// Copy the rest of u to the result.
while (u < uend)
(*w++) = (*u++);
}
// Compute u -= v, where u is vectors, and v is a scalar.
void
vec_sub_small_on(int ulen, sc_digit *u, sc_digit v)
{
#ifdef DEBUG_SYSTEMC
sc_assert((ulen > 0) && (u != NULL));
#endif
for (int i = 0; i < ulen; ++i) {
v = (u[i] + DIGIT_RADIX) - v;
u[i] = v & DIGIT_MASK;
v = 1 - (v >> BITS_PER_DIGIT);
}
#ifdef DEBUG_SYSTEMC
sc_assert(v == 0);
#endif
}
// Compute w = u * v, where w, u, and v are vectors.
void
vec_mul(int ulen, const sc_digit *u, int vlen, const sc_digit *vbegin,
sc_digit *wbegin)
{
/* Consider u = Ax + B and v = Cx + D where x is equal to
HALF_DIGIT_RADIX. In other words, A is the higher half of u and
B is the lower half of u. The interpretation for v is
similar. Then, we have the following picture:
u_h u_l
u: -------- --------
A B
v_h v_l
v: -------- --------
C D
result (d):
carry_before: -------- --------
carry_h carry_l
result_before: -------- -------- -------- --------
R1_h R1_l R0_h R0_l
-------- --------
BD_h BD_l
-------- --------
AD_h AD_l
-------- --------
BC_h BC_l
-------- --------
AC_h AC_l
result_after: -------- -------- -------- --------
R1_h' R1_l' R0_h' R0_l'
prod_l = R0_h|R0_l + B * D + 0|carry_l
= R0_h|R0_l + BD_h|BD_l + 0|carry_l
prod_h = A * D + B * C + high_half(prod_l) + carry_h
= AD_h|AD_l + BC_h|BC_l + high_half(prod_l) + 0|carry_h
carry = A * C + high_half(prod_h)
= AC_h|AC_l + high_half(prod_h)
R0_l' = low_half(prod_l)
R0_h' = low_half(prod_h)
R0 = high_half(prod_h)|low_half(prod_l)
where '|' is the concatenation operation and the suffixes 0 and 1
show the iteration number, i.e., 0 is the current iteration and 1
is the next iteration.
NOTE: sc_max(prod_l, prod_h, carry) <= 2 * x^2 - 1, so any
of these numbers can be stored in a digit.
NOTE: low_half(u) returns the lower BITS_PER_HALF_DIGIT of u,
whereas high_half(u) returns the rest of the bits, which may
contain more bits than BITS_PER_HALF_DIGIT.
*/
#ifdef DEBUG_SYSTEMC
sc_assert((ulen > 0) && (u != NULL));
sc_assert((vlen > 0) && (vbegin != NULL));
sc_assert(wbegin != NULL);
#endif
#define prod_h carry
const sc_digit *uend = (u + ulen);
const sc_digit *vend = (vbegin + vlen);
while (u < uend) {
sc_digit u_h = (*u++); // A|B
sc_digit u_l = low_half(u_h); // B
u_h = high_half(u_h); // A
#ifdef DEBUG_SYSTEMC
// The overflow bits must be zero.
sc_assert(u_h == (u_h & HALF_DIGIT_MASK));
#endif
sc_digit carry = 0;
sc_digit *w = (wbegin++);
const sc_digit *v = vbegin;
while (v < vend) {
sc_digit v_h = (*v++); // C|D
sc_digit v_l = low_half(v_h); // D
v_h = high_half(v_h); // C
#ifdef DEBUG_SYSTEMC
// The overflow bits must be zero.
sc_assert(v_h == (v_h & HALF_DIGIT_MASK));
#endif
sc_digit prod_l = (*w) + u_l * v_l + low_half(carry);
prod_h = u_h * v_l + u_l * v_h +
high_half(prod_l) + high_half(carry);
(*w++) = concat(low_half(prod_h), low_half(prod_l));
carry = u_h * v_h + high_half(prod_h);
}
(*w) = carry;
}
#undef prod_h
}
// Compute w = u * v, where w and u are vectors, and v is a scalar.
// - 0 < v < HALF_DIGIT_RADIX.
void
vec_mul_small(int ulen, const sc_digit *u, sc_digit v, sc_digit *w)
{
#ifdef DEBUG_SYSTEMC
sc_assert((ulen > 0) && (u != NULL));
sc_assert(w != NULL);
sc_assert((0 < v) && (v < HALF_DIGIT_RADIX));
#endif
#define prod_h carry
const sc_digit *uend = (u + ulen);
sc_digit carry = 0;
while (u < uend) {
sc_digit u_AB = (*u++);
#ifdef DEBUG_SYSTEMC
// The overflow bits must be zero.
sc_assert(high_half(u_AB) == high_half_masked(u_AB));
#endif
sc_digit prod_l = v * low_half(u_AB) + low_half(carry);
prod_h = v * high_half(u_AB) + high_half(prod_l) + high_half(carry);
(*w++) = concat(low_half(prod_h), low_half(prod_l));
carry = high_half(prod_h);
}
(*w) = carry;
#undef prod_h
}
// Compute u = u * v, where u is a vector, and v is a scalar.
// - 0 < v < HALF_DIGIT_RADIX.
void
vec_mul_small_on(int ulen, sc_digit *u, sc_digit v)
{
#ifdef DEBUG_SYSTEMC
sc_assert((ulen > 0) && (u != NULL));
sc_assert((0 < v) && (v < HALF_DIGIT_RADIX));
#endif
#define prod_h carry
sc_digit carry = 0;
for (int i = 0; i < ulen; ++i) {
#ifdef DEBUG_SYSTEMC
// The overflow bits must be zero.
sc_assert(high_half(u[i]) == high_half_masked(u[i]));
#endif
sc_digit prod_l = v * low_half(u[i]) + low_half(carry);
prod_h = v * high_half(u[i]) + high_half(prod_l) + high_half(carry);
u[i] = concat(low_half(prod_h), low_half(prod_l));
carry = high_half(prod_h);
}
#undef prod_h
#ifdef DEBUG_SYSTEMC
if (carry != 0) {
SC_REPORT_WARNING(sc_core::SC_ID_WITHOUT_MESSAGE_,
"vec_mul_small_on( int, sc_digit*, unsigned "
"long ) : "
"result of multiplication is wrapped around");
}
#endif
}
// Compute w = u / v, where w, u, and v are vectors.
// - u and v are assumed to have at least two digits as uchars.
void
vec_div_large(int ulen, const sc_digit *u, int vlen, const sc_digit *v,
sc_digit *w)
{
#ifdef DEBUG_SYSTEMC
sc_assert((ulen > 0) && (u != NULL));
sc_assert((vlen > 0) && (v != NULL));
sc_assert(w != NULL);
sc_assert(BITS_PER_DIGIT >= 3 * BITS_PER_BYTE);
#endif
// We will compute q = x / y where x = u and y = v. The reason for
// using x and y is that x and y are BYTE_RADIX copies of u and v,
// respectively. The use of BYTE_RADIX radix greatly simplifies the
// complexity of the division operation. These copies are also
// needed even when we use DIGIT_RADIX representation.
int xlen = BYTES_PER_DIGIT * ulen + 1;
int ylen = BYTES_PER_DIGIT * vlen;
#ifdef SC_MAX_NBITS
uchar x[DIV_CEIL2(SC_MAX_NBITS, BITS_PER_BYTE)];
uchar y[DIV_CEIL2(SC_MAX_NBITS, BITS_PER_BYTE)];
uchar q[DIV_CEIL2(SC_MAX_NBITS, BITS_PER_BYTE)];
#else
uchar *x = new uchar[xlen];
uchar *y = new uchar[ylen];
// valgrind complains about us accessing too far to so leave a buffer.
uchar *q = new uchar[(xlen - ylen) + 10];
#endif
// q corresponds to w.
// Set (uchar) x = (sc_digit) u.
xlen = vec_to_char(ulen, u, xlen, x);
// Skip all the leading zeros in x.
while ((--xlen >= 0) && (! x[xlen]))
continue;
xlen++;
// Set (uchar) y = (sc_digit) v.
ylen = vec_to_char(vlen, v, ylen, y);
// Skip all the leading zeros in y.
while ((--ylen >= 0) && (! y[ylen]))
continue;
ylen++;
#ifdef DEBUG_SYSTEMC
sc_assert(xlen > 1);
sc_assert(ylen > 1);
#endif
// At this point, all the leading zeros are eliminated from x and y.
// Zero the last digit of x.
x[xlen] = 0;
// The first two digits of y.
sc_digit y2 = (y[ylen - 1] << BITS_PER_BYTE) + y[ylen - 2];
const sc_digit DOUBLE_BITS_PER_BYTE = 2 * BITS_PER_BYTE;
// Find each q[k].
for (int k = (xlen - ylen); k >= 0; --k) {
// qk is a guess for q[k] such that q[k] = qk or qk - 1.
sc_digit qk;
// Find qk by just using 2 digits of y and 3 digits of x. The
// following code assumes that sizeof(sc_digit) >= 3 BYTEs.
int k2 = k + ylen;
qk = ((x[k2] << DOUBLE_BITS_PER_BYTE) +
(x[k2 - 1] << BITS_PER_BYTE) + x[k2 - 2]) / y2;
if (qk >= BYTE_RADIX) // qk cannot be larger than the largest
qk = BYTE_RADIX - 1; // digit in BYTE_RADIX.
// q[k] = qk or qk - 1. The following if-statement determines which:
if (qk) {
uchar *xk = (x + k); // A shortcut for x[k].
// x = x - y * qk :
sc_digit carry = 0;
for (int i = 0; i < ylen; ++i) {
carry += y[i] * qk;
sc_digit diff = (xk[i] + BYTE_RADIX) - (carry & BYTE_MASK);
xk[i] = (uchar)(diff & BYTE_MASK);
carry = (carry >> BITS_PER_BYTE) +
(1 - (diff >> BITS_PER_BYTE));
}
// If carry, qk may be one too large.
if (carry) {
// 2's complement the last digit.
carry = (xk[ylen] + BYTE_RADIX) - carry;
xk[ylen] = (uchar)(carry & BYTE_MASK);
carry = 1 - (carry >> BITS_PER_BYTE);
if (carry) {
// qk was one too large, so decrement it.
--qk;
// Since qk was decreased by one, y must be added to x:
// x = x - y * (qk - 1) = x - y * qk + y = x_above + y.
carry = 0;
for (int i = 0; i < ylen; ++i) {
carry += xk[i] + y[i];
xk[i] = (uchar)(carry & BYTE_MASK);
carry >>= BITS_PER_BYTE;
}
if (carry)
xk[ylen] = (uchar)((xk[ylen] + 1) & BYTE_MASK);
} // second if carry
} // first if carry
} // if qk
q[k] = (uchar)qk;
} // for k
// Set (sc_digit) w = (uchar) q.
vec_from_char(xlen - ylen + 1, q, ulen, w);
#ifndef SC_MAX_NBITS
delete [] x;
delete [] y;
delete [] q;
#endif
}
// Compute w = u / v, where u and w are vectors, and v is a scalar.
// - 0 < v < HALF_DIGIT_RADIX. Below, we rename w to q.
void
vec_div_small(int ulen, const sc_digit *u, sc_digit v, sc_digit *q)
{
// Given (u = u_1u_2...u_n)_b = (q = q_1q_2...q_n) * v + r, where b
// is the base, and 0 <= r < v. Then, the algorithm is as follows:
//
// r = 0;
// for (j = 1; j <= n; j++) {
// q_j = (r * b + u_j) / v;
// r = (r * b + u_j) % v;
// }
//
// In our case, b = DIGIT_RADIX, and u = Ax + B and q = Cx + D where
// x = HALF_DIGIT_RADIX. Note that r < v < x and b = x^2. Then, a
// typical situation is as follows:
//
// ---- ----
// 0 r
// ---- ----
// A B
// ---- ---- ----
// r A B = r * b + u
//
// Hence, C = (r|A) / v.
// D = (((r|A) % v)|B) / v
// r = (((r|A) % v)|B) % v
#ifdef DEBUG_SYSTEMC
sc_assert((ulen > 0) && (u != NULL));
sc_assert(q != NULL);
sc_assert((0 < v) && (v < HALF_DIGIT_RADIX));
#endif
#define q_h r
sc_digit r = 0;
const sc_digit *ubegin = u;
u += ulen;
q += ulen;
while (ubegin < u) {
sc_digit u_AB = (*--u); // A|B
#ifdef DEBUG_SYSTEMC
// The overflow bits must be zero.
sc_assert(high_half(u_AB) == high_half_masked(u_AB));
#endif
sc_digit num = concat(r, high_half(u_AB)); // num = r|A
q_h = num / v; // C
num = concat((num % v), low_half(u_AB)); // num = (((r|A) % v)|B)
(*--q) = concat(q_h, num / v); // q = C|D
r = num % v;
}
#undef q_h
}
// Compute w = u % v, where w, u, and v are vectors.
// - u and v are assumed to have at least two digits as uchars.
void
vec_rem_large(int ulen, const sc_digit *u, int vlen, const sc_digit *v,
sc_digit *w)
{
#ifdef DEBUG_SYSTEMC
sc_assert((ulen > 0) && (u != NULL));
sc_assert((vlen > 0) && (v != NULL));
sc_assert(w != NULL);
sc_assert(BITS_PER_DIGIT >= 3 * BITS_PER_BYTE);
#endif
// This function is adapted from vec_div_large.
int xlen = BYTES_PER_DIGIT * ulen + 1;
int ylen = BYTES_PER_DIGIT * vlen;
#ifdef SC_MAX_NBITS
uchar x[DIV_CEIL2(SC_MAX_NBITS, BITS_PER_BYTE)];
uchar y[DIV_CEIL2(SC_MAX_NBITS, BITS_PER_BYTE)];
#else
uchar *x = new uchar[xlen];
uchar *y = new uchar[ylen];
#endif
// r corresponds to w.
// Set (uchar) x = (sc_digit) u.
xlen = vec_to_char(ulen, u, xlen, x);
// Skip all the leading zeros in x.
while ((--xlen >= 0) && (!x[xlen]))
continue;
xlen++;
// Set (uchar) y = (sc_digit) v.
ylen = vec_to_char(vlen, v, ylen, y);
// Skip all the leading zeros in y.
while ((--ylen >= 0) && (!y[ylen]))
continue;
ylen++;
#ifdef DEBUG_SYSTEMC
sc_assert(xlen > 1);
sc_assert(ylen > 1);
#endif
// At this point, all the leading zeros are eliminated from x and y.
// Zero the last digit of x.
x[xlen] = 0;
// The first two digits of y.
sc_digit y2 = (y[ylen - 1] << BITS_PER_BYTE) + y[ylen - 2];
const sc_digit DOUBLE_BITS_PER_BYTE = 2 * BITS_PER_BYTE;
// Find each q[k].
for (int k = xlen - ylen; k >= 0; --k) {
// qk is a guess for q[k] such that q[k] = qk or qk - 1.
sc_digit qk;
// Find qk by just using 2 digits of y and 3 digits of x. The
// following code assumes that sizeof(sc_digit) >= 3 BYTEs.
int k2 = k + ylen;
qk = ((x[k2] << DOUBLE_BITS_PER_BYTE) +
(x[k2 - 1] << BITS_PER_BYTE) + x[k2 - 2]) / y2;
if (qk >= BYTE_RADIX) // qk cannot be larger than the largest
qk = BYTE_RADIX - 1; // digit in BYTE_RADIX.
// q[k] = qk or qk - 1. The following if-statement determines which.
if (qk) {
uchar *xk = (x + k); // A shortcut for x[k].
// x = x - y * qk;
sc_digit carry = 0;
for (int i = 0; i < ylen; ++i) {
carry += y[i] * qk;
sc_digit diff = (xk[i] + BYTE_RADIX) - (carry & BYTE_MASK);
xk[i] = (uchar)(diff & BYTE_MASK);
carry = (carry >> BITS_PER_BYTE) +
(1 - (diff >> BITS_PER_BYTE));
}
if (carry) {
// 2's complement the last digit.
carry = (xk[ylen] + BYTE_RADIX) - carry;
xk[ylen] = (uchar)(carry & BYTE_MASK);
carry = 1 - (carry >> BITS_PER_BYTE);
if (carry) {
// qk was one too large, so decrement it.
// --qk;
// x = x - y * (qk - 1) = x - y * qk + y = x_above + y.
carry = 0;
for (int i = 0; i < ylen; ++i) {
carry += xk[i] + y[i];
xk[i] = (uchar)(carry & BYTE_MASK);
carry >>= BITS_PER_BYTE;
}
if (carry)
xk[ylen] = (uchar)((xk[ylen] + 1) & BYTE_MASK);
} // second if carry
} // first if carry
} // if qk
} // for k
// Set (sc_digit) w = (uchar) x for the remainder.
vec_from_char(ylen, x, ulen, w);
#ifndef SC_MAX_NBITS
delete [] x;
delete [] y;
#endif
}
// Compute r = u % v, where u is a vector, and r and v are scalars.
// - 0 < v < HALF_DIGIT_RADIX.
// - The remainder r is returned.
sc_digit
vec_rem_small(int ulen, const sc_digit *u, sc_digit v)
{
#ifdef DEBUG_SYSTEMC
sc_assert((ulen > 0) && (u != NULL));
sc_assert((0 < v) && (v < HALF_DIGIT_RADIX));
#endif
// This function is adapted from vec_div_small().
sc_digit r = 0;
const sc_digit *ubegin = u;
u += ulen;
while (ubegin < u) {
sc_digit u_AB = (*--u); // A|B
#ifdef DEBUG_SYSTEMC
// The overflow bits must be zero.
sc_assert(high_half(u_AB) == high_half_masked(u_AB));
#endif
// r = (((r|A) % v)|B) % v
r = (concat(((concat(r, high_half(u_AB))) % v), low_half(u_AB))) % v;
}
return r;
}
// u = u / v, r = u % v.
sc_digit
vec_rem_on_small(int ulen, sc_digit *u, sc_digit v)
{
#ifdef DEBUG_SYSTEMC
sc_assert((ulen > 0) && (u != NULL));
sc_assert(v > 0);
#endif
#define q_h r
sc_digit r = 0;
const sc_digit *ubegin = u;
u += ulen;
while (ubegin < u) {
sc_digit u_AB = (*--u); // A|B
#ifdef DEBUG_SYSTEMC
// The overflow bits must be zero.
sc_assert(high_half(u_AB) == high_half_masked(u_AB));
#endif
sc_digit num = concat(r, high_half(u_AB)); // num = r|A
q_h = num / v; // C
num = concat((num % v), low_half(u_AB)); // num = (((r|A) % v)|B)
(*u) = concat(q_h, num / v); // q = C|D
r = num % v;
}
#undef q_h
return r;
}
// Set (uchar) v = (sc_digit) u. Return the new vlen.
int
vec_to_char(int ulen, const sc_digit *u, int vlen, uchar *v)
{
#ifdef DEBUG_SYSTEMC
sc_assert((ulen > 0) && (u != NULL));
sc_assert((vlen > 0) && (v != NULL));
#endif
int nbits = ulen * BITS_PER_DIGIT;
int right = 0;
int left = right + BITS_PER_BYTE - 1;
vlen = 0;
while (nbits > 0) {
int left_digit = left / BITS_PER_DIGIT;
int right_digit = right / BITS_PER_DIGIT;
int nsr = ((vlen << LOG2_BITS_PER_BYTE) % BITS_PER_DIGIT);
int d = u[right_digit] >> nsr;
if (left_digit != right_digit) {
if (left_digit < ulen)
d |= u[left_digit] << (BITS_PER_DIGIT - nsr);
}
v[vlen++] = (uchar)(d & BYTE_MASK);
left += BITS_PER_BYTE;
right += BITS_PER_BYTE;
nbits -= BITS_PER_BYTE;
}
return vlen;
}
// Set (sc_digit) v = (uchar) u.
// - sizeof(uchar) <= sizeof(sc_digit),
void
vec_from_char(int ulen, const uchar *u, int vlen, sc_digit *v)
{
#ifdef DEBUG_SYSTEMC
sc_assert((ulen > 0) && (u != NULL));
sc_assert((vlen > 0) && (v != NULL));
sc_assert(sizeof(uchar) <= sizeof(sc_digit));
#endif
sc_digit *vend = (v + vlen);
const int nsr = BITS_PER_DIGIT - BITS_PER_BYTE;
const sc_digit mask = one_and_ones(nsr);
(*v) = (sc_digit) u[ulen - 1];
for (int i = ulen - 2; i >= 0; --i) {
// Manual inlining of vec_shift_left().
sc_digit *viter = v;
sc_digit carry = 0;
while (viter < vend) {
sc_digit vval = (*viter);
(*viter++) = (((vval & mask) << BITS_PER_BYTE) | carry);
carry = vval >> nsr;
}
if (viter < vend)
(*viter) = carry;
(*v) |= (sc_digit)u[i];
}
}
// Set u <<= nsl.
// If nsl is negative, it is ignored.
void
vec_shift_left(int ulen, sc_digit *u, int nsl)
{
#ifdef DEBUG_SYSTEMC
sc_assert((ulen > 0) && (u != NULL));
#endif
if (nsl <= 0)
return;
// Shift left whole digits if nsl is large enough.
if (nsl >= (int) BITS_PER_DIGIT) {
int nd;
if (nsl % BITS_PER_DIGIT == 0) {
nd = nsl / BITS_PER_DIGIT; // No need to use DIV_CEIL(nsl).
nsl = 0;
} else {
nd = DIV_CEIL(nsl) - 1;
nsl -= nd * BITS_PER_DIGIT;
}
if (nd) {
// Shift left for nd digits.
for (int j = ulen - 1; j >= nd; --j)
u[j] = u[j - nd];
vec_zero(sc_min(nd, ulen), u);
}
if (nsl == 0)
return;
}
// Shift left if nsl < BITS_PER_DIGIT.
sc_digit *uiter = u;
sc_digit *uend = uiter + ulen;
int nsr = BITS_PER_DIGIT - nsl;
sc_digit mask = one_and_ones(nsr);
sc_digit carry = 0;
while (uiter < uend) {
sc_digit uval = (*uiter);
(*uiter++) = (((uval & mask) << nsl) | carry);
carry = uval >> nsr;
}
if (uiter < uend)
(*uiter) = carry;
}
// Set u >>= nsr.
// If nsr is negative, it is ignored.
void
vec_shift_right(int ulen, sc_digit *u, int nsr, sc_digit fill)
{
#ifdef DEBUG_SYSTEMC
sc_assert((ulen > 0) && (u != NULL));
#endif
// fill is usually either 0 or DIGIT_MASK; it can be any value.
if (nsr <= 0)
return;
// Shift right whole digits if nsr is large enough.
if (nsr >= (int) BITS_PER_DIGIT) {
int nd;
if (nsr % BITS_PER_DIGIT == 0) {
nd = nsr / BITS_PER_DIGIT;
nsr = 0;
} else {
nd = DIV_CEIL(nsr) - 1;
nsr -= nd * BITS_PER_DIGIT;
}
if (nd) {
// Shift right for nd digits.
for (int j = 0; j < (ulen - nd); ++j)
u[j] = u[j + nd];
if (fill) {
for (int j = ulen - sc_min( nd, ulen ); j < ulen; ++j)
u[j] = fill;
} else {
vec_zero(ulen - sc_min( nd, ulen ), ulen, u);
}
}
if (nsr == 0)
return;
}
// Shift right if nsr < BITS_PER_DIGIT.
sc_digit *ubegin = u;
sc_digit *uiter = (ubegin + ulen);
int nsl = BITS_PER_DIGIT - nsr;
sc_digit mask = one_and_ones(nsr);
sc_digit carry = (fill & mask) << nsl;
while (ubegin < uiter) {
sc_digit uval = (*--uiter);
(*uiter) = (uval >> nsr) | carry;
carry = (uval & mask) << nsl;
}
}
// Let u[l..r], where l and r are left and right bit positions
// respectively, be equal to its mirror image.
void
vec_reverse(int unb, int und, sc_digit *ud, int l, int r)
{
#ifdef DEBUG_SYSTEMC
sc_assert((unb > 0) && (und > 0) && (ud != NULL));
sc_assert((0 <= r) && (r <= l) && (l < unb));
#endif
if (l < r) {
std::stringstream msg;
msg << "vec_reverse( int, int, sc_digit*, int l, int r ) : " <<
"l = " << l << " < r = " << r << " is not valid",
SC_REPORT_ERROR(sc_core::SC_ID_CONVERSION_FAILED_, msg.str().c_str());
return;
}
// Make sure that l and r are within bounds.
r = sc_max(r, 0);
l = sc_min(l, unb - 1);
// Allocate memory for processing.
#ifdef SC_MAX_NBITS
sc_digit d[MAX_NDIGITS];
#else
sc_digit *d = new sc_digit[und];
#endif
// d is a copy of ud.
vec_copy(und, d, ud);
// Based on the value of the ith in d, find the value of the jth bit
// in ud.
for (int i = l, j = r; i >= r; --i, ++j) {
if ((d[digit_ord(i)] & one_and_zeros(bit_ord(i))) != 0) // Test.
ud[digit_ord(j)] |= one_and_zeros(bit_ord(j)); // Set.
else
ud[digit_ord(j)] &= ~(one_and_zeros(bit_ord(j))); // Clear.
}
#ifndef SC_MAX_NBITS
delete [] d;
#endif
}
#ifdef SC_MAX_NBITS
void test_bound_failed(int nb)
{
std::stringstream msg;
msg << "test_bound( int nb ) : "
"nb = " << nb << " > SC_MAX_NBITS = " << SC_MAX_NBITS <<
" is not valid";
SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, msg.str().c_str());
}
#endif // SC_MAX_NBITS
} // namespace sc_dt