sc_nbfriends.inc

来自「基于4个mips核的noc设计」· INC 代码 · 共 719 行 · 第 1/2 页

    ys = us;
    xs = vs;
  }

  const unsigned long *xend = (x + xnd);
  const unsigned long *yend = (y + ynd);

  // x is longer than y.

  small_type s = mul_signs(xs, ys);

  if (s > 0) {

    if (xs > 0) { // case 2

      while (y < yend)
        (*d++) = (*x++) & (*y++);

      while (x++ < xend) 
        (*d++) = 0;

    }
    else {  // case 3

      register unsigned long xcarry = 1;
      register unsigned long ycarry = 1;

      while (y < yend) {
        xcarry += (~(*x++) & DIGIT_MASK);
        ycarry += (~(*y++) & DIGIT_MASK);
        (*d++) = (xcarry & ycarry) & DIGIT_MASK;
        xcarry >>= BITS_PER_DIGIT;
        ycarry >>= BITS_PER_DIGIT;
      }

      while (x < xend) {
        xcarry += (~(*x++) & DIGIT_MASK);
        ycarry += DIGIT_MASK;
        (*d++) = (xcarry & ycarry) & DIGIT_MASK;
        xcarry >>= BITS_PER_DIGIT;
        ycarry >>= BITS_PER_DIGIT;
      }

    }
  }
  else {

    if (xs > 0) { // case 4

      register unsigned long ycarry = 1;

      while (y < yend) {
        ycarry += (~(*y++) & DIGIT_MASK);
        (*d++) = ((*x++) & ycarry) & DIGIT_MASK;
        ycarry >>= BITS_PER_DIGIT;
      }

      while (x < xend) {
        ycarry += DIGIT_MASK;
        (*d++) = ((*x++) & ycarry) & DIGIT_MASK;
        ycarry >>= BITS_PER_DIGIT;
      }

    }
    else {  // case 5

      register unsigned long xcarry = 1;

      while (y < yend) {
        xcarry += (~(*x++) & DIGIT_MASK);
        (*d++) = (xcarry & (*y++)) & DIGIT_MASK;
        xcarry >>= BITS_PER_DIGIT;
      }

      while (x++ < xend)
        (*d++) = 0;

    }
  }

  s = convert_signed_2C_to_SM(nb, nd, dbegin);

  return CLASS_TYPE(s, nb, nd, dbegin);  

}


// ----------------------------------------------------------------------------
//  SECTION: Friend functions for OR operators.
// ----------------------------------------------------------------------------

// Handles the cases 3-5 and returns the result.
CLASS_TYPE 
OR_HELPER(small_type us, 
          int unb, int und, 
          const unsigned long *ud, 
          small_type vs,
          int vnb, int vnd,
          const unsigned long *vd)
{
  
  int nb = sc_max(unb, vnb);
  int nd = sc_max(und, vnd);

#ifdef SC_MAX_NBITS
  unsigned long dbegin[MAX_NDIGITS];
#else
  unsigned long *dbegin = new unsigned long[nd];
#endif

  unsigned long *d = dbegin;

  register const unsigned long *x;
  register const unsigned long *y;
  int xnd;
  int ynd;
  small_type xs;
  small_type ys;

  if (und >= vnd) {
    x = ud;
    y = vd;
    xnd = und;
    ynd = vnd;
    xs = us;
    ys = vs;
  }
  else {
    y = ud;
    x = vd;
    ynd = und;
    xnd = vnd;
    ys = us;
    xs = vs;
  }

  const unsigned long *xend = (x + xnd);
  const unsigned long *yend = (y + ynd);

  // x is longer than y.

  small_type s = mul_signs(xs, ys);

  if (s > 0) {

    if (xs > 0) { // case 3

      while (y < yend)
        (*d++) = (*x++) | (*y++);

      while (x < xend)
        (*d++) = (*x++);

    }
    else {  // case 4

      register unsigned long xcarry = 1;
      register unsigned long ycarry = 1;

      while (y < yend) {
        xcarry += (~(*x++) & DIGIT_MASK);
        ycarry += (~(*y++) & DIGIT_MASK);
        (*d++) = (xcarry | ycarry) & DIGIT_MASK;
        xcarry >>= BITS_PER_DIGIT;
        ycarry >>= BITS_PER_DIGIT;
      }

      while (x < xend) {
        xcarry += (~(*x++) & DIGIT_MASK);
        ycarry += DIGIT_MASK;
        (*d++) = (xcarry | ycarry) & DIGIT_MASK;
        xcarry >>= BITS_PER_DIGIT;
        ycarry >>= BITS_PER_DIGIT;
      }

    }

  }
  else {

    if (xs > 0) { // case 5

      register unsigned long ycarry = 1;

      while (y < yend) {
        ycarry += (~(*y++) & DIGIT_MASK);
        (*d++) = ((*x++) | ycarry) & DIGIT_MASK;
        ycarry >>= BITS_PER_DIGIT;
      }

      while (x < xend) {
        ycarry += DIGIT_MASK;
        (*d++) = ((*x++) | ycarry) & DIGIT_MASK;
        ycarry >>= BITS_PER_DIGIT;
      }

    }
    else {  // case 6

      register unsigned long xcarry = 1;

      while (y < yend) {
        xcarry += (~(*x++) & DIGIT_MASK);
        (*d++) = (xcarry | (*y++)) & DIGIT_MASK;
        xcarry >>= BITS_PER_DIGIT;
      }

      while (x < xend) {
        xcarry += (~(*x++) & DIGIT_MASK);
        (*d++) = xcarry & DIGIT_MASK;
        xcarry >>= BITS_PER_DIGIT;
      }
    }

  }

  s = convert_signed_2C_to_SM(nb, nd, dbegin);

  return CLASS_TYPE(s, nb, nd, dbegin);

}


// ----------------------------------------------------------------------------
//  SECTION: Friend functions for XOR operators.
// ----------------------------------------------------------------------------

// Handles the cases 3-5 and returns the result.
CLASS_TYPE 
XOR_HELPER(small_type us, 
           int unb, int und, 
           const unsigned long *ud, 
           small_type vs,
           int vnb, int vnd,
           const unsigned long *vd)
{
  
  int nb = sc_max(unb, vnb);
  int nd = sc_max(und, vnd);

#ifdef SC_MAX_NBITS
  unsigned long dbegin[MAX_NDIGITS];
#else
  unsigned long *dbegin = new unsigned long[nd];
#endif

  unsigned long *d = dbegin;

  register const unsigned long *x;
  register const unsigned long *y;
  int xnd;
  int ynd;
  small_type xs;
  small_type ys;

  if (und >= vnd) {
    x = ud;
    y = vd;
    xnd = und;
    ynd = vnd;
    xs = us;
    ys = vs;
  }
  else {
    y = ud;
    x = vd;
    ynd = und;
    xnd = vnd;
    ys = us;
    xs = vs;
  }

  const unsigned long *xend = (x + xnd);
  const unsigned long *yend = (y + ynd);

  // x is longer than y.

  small_type s = mul_signs(xs, ys);

  if (s > 0) {

    if (xs > 0) { // case 3

      while (y < yend)
        (*d++) = ((*x++) ^ (*y++)) & DIGIT_MASK;

      while (x < xend)
        (*d++) = (*x++);

    }
    else {  // case 4

      register unsigned long xcarry = 1;
      register unsigned long ycarry = 1;

      while (y < yend) {
        xcarry += (~(*x++) & DIGIT_MASK);
        ycarry += (~(*y++) & DIGIT_MASK);
        (*d++) = (xcarry ^ ycarry) & DIGIT_MASK;
        xcarry >>= BITS_PER_DIGIT;
        ycarry >>= BITS_PER_DIGIT;
      }

      while (x < xend) {
        xcarry += (~(*x++) & DIGIT_MASK);
        ycarry += DIGIT_MASK;
        (*d++) = (xcarry ^ ycarry) & DIGIT_MASK;
        xcarry >>= BITS_PER_DIGIT;
        ycarry >>= BITS_PER_DIGIT;
      }

    }
  }
  else {

    if (xs > 0) { // case 5

      register unsigned long ycarry = 1;

      while (y < yend) {
        ycarry += (~(*y++) & DIGIT_MASK);
        (*d++) = ((*x++) ^ ycarry) & DIGIT_MASK;
        ycarry >>= BITS_PER_DIGIT;
      }

      while (x < xend) {
        ycarry += DIGIT_MASK;
        (*d++) = ((*x++) ^ ycarry) & DIGIT_MASK;
        ycarry >>= BITS_PER_DIGIT;
      }

    }
    else {  // case 6

      register unsigned long xcarry = 1;

      while (y < yend) {
        xcarry += (~(*x++) & DIGIT_MASK);
        (*d++) = (xcarry ^ (*y++)) & DIGIT_MASK;
        xcarry >>= BITS_PER_DIGIT;
      }

      while (x < xend) {
        xcarry += (~(*x++) & DIGIT_MASK);
        (*d++) = xcarry & DIGIT_MASK;
        xcarry >>= BITS_PER_DIGIT;
      }
    }
  }

  s = convert_signed_2C_to_SM(nb, nd, dbegin);

  return CLASS_TYPE(s, nb, nd, dbegin);

}

// End of file.