Subversion Repositories scarm

///////////////////////////////////////////////////////////////////////////////
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
//////////////////////////////////////////////////////////////////////
 
///////////////////////////////////////////////////////////////////              
//          
//  Original Author: Allen Tao Zhong,
//  University of Electronic Science and Technology in China
//  email: zhong@opencores.org
//  info   This is a SystemC ARM model,I "stole" some codes from 
//       "swarm" , author Michael Dales (michael@dcs.gla.ac.uk)
// scBooth.cpp: implementation of the scBooth class.
//
//////////////////////////////////////////////////////////////////////
 
#include "scBooth.h"
 
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
 
 
 
scBooth::~scBooth()
{
 
}
///////////////////////////////////////////////////////////////////////////////
// carry_save_adder_32 - 32 bit carry save adder (well, what did you expect?).
//
void scBooth::carry_save_adder_32(uint32_t a, uint32_t b, uint32_t cin, 
			 uint32_t *res, uint32_t *cout)
{
  uint32_t ps, t1, t2;
 
  ps = a ^ b;
  *res = ps ^ cin;
 
  t1 = b & ~ps;
  t2 = cin & ps;
  *cout = t1 | t2;
 
  /*fprintf(stdout, "0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n", 
    a, b, cin, *res, *cout); 
    fflush(stdout);*/
}
 
 
#define SHIFT_LEFT(_x,_y)  ((_y >= 32) ? 0 : _x << _y)
#define SHIFT_RIGHT(_x,_y) ((_y >= 32) ? 0 : _x >> _y)
#define SIGNED_SHIFT_RIGHT(_x,_y) ((_y >= 32) ? ((_x >> 31) * 0xFFFFFFFF) : ((int32_t)_x) >> _y)
 
///////////////////////////////////////////////////////////////////////////////
// booth_stage_one - Does a single round of booths multiply algorithm. Note
//                   this works on 64 bits.
//
void scBooth::booth_one_stage(uint32_t* part_sum_hi, uint32_t* part_sum_lo, 
		     uint32_t* part_carry_hi, uint32_t* part_carry_lo, 
		     uint32_t mult, uint32_t N, bool_t* carry,
		     uint32_t multiplier, bool_t bSign)
{
  uint32_t temp;
  uint32_t srt;
 
  temp = multiplier & 0x3;
  temp |= (*carry == 1) ? 4 : 0;
 
  switch (temp)
    {
    case 0:
      carry_save_adder_32(*part_sum_lo, 0, *part_carry_lo,
			  part_sum_lo, part_carry_lo);
      carry_save_adder_32(*part_sum_hi, 0, *part_carry_hi,
			  part_sum_hi, part_carry_hi);
      break;
    case 1:
      carry_save_adder_32(*part_sum_lo, SHIFT_LEFT(mult,(2 * N)), 
			  *part_carry_lo,
			  part_sum_lo, part_carry_lo);
      srt = bSign == 0 ? SHIFT_RIGHT(mult,(32 - (2 * N))) :
	SIGNED_SHIFT_RIGHT(mult,(32 - (2 * N)));
      carry_save_adder_32(*part_sum_hi, srt, *part_carry_hi,
			  part_sum_hi, part_carry_hi);
      break;
    case 2:
      carry_save_adder_32(*part_sum_lo, ~(SHIFT_LEFT(mult,((2 * N) + 1))), 
			  (*part_carry_lo) | 0x1 , part_sum_lo, part_carry_lo);
      srt = bSign == 0 ? SHIFT_RIGHT(mult,(32 - ((2 * N) + 1))) :
	SIGNED_SHIFT_RIGHT(mult,(32 - ((2 * N) + 1)));
      carry_save_adder_32(*part_sum_hi, ~(srt), 
			  *part_carry_hi, part_sum_hi, part_carry_hi);
      break;
    case 3:
      carry_save_adder_32(*part_sum_lo, ~(SHIFT_LEFT(mult, (2 * N))), 
			  (*part_carry_lo) | 0x1 , part_sum_lo, part_carry_lo);
      srt = bSign == 0 ? SHIFT_RIGHT(mult, (32 - (2 * N))) : 
	SIGNED_SHIFT_RIGHT(mult, (32 - (2 * N)));
      carry_save_adder_32(*part_sum_hi, ~(srt), 
			  *part_carry_hi, part_sum_hi, part_carry_hi);
      break;
    case 4:
      carry_save_adder_32(*part_sum_lo, SHIFT_LEFT(mult, (2 * N)), 
			  *part_carry_lo,
			  part_sum_lo, part_carry_lo);
      srt = bSign == 0 ? SHIFT_RIGHT(mult, (32 - (2 * N))) :
	SIGNED_SHIFT_RIGHT(mult, (32 - (2 * N)));
      carry_save_adder_32(*part_sum_hi, srt, 
			  *part_carry_hi,
			  part_sum_hi, part_carry_hi);
      break;
    case 5:
      carry_save_adder_32(*part_sum_lo, SHIFT_LEFT(mult, ((2 * N) + 1)), 
			  *part_carry_lo,
			  part_sum_lo, part_carry_lo);
      srt = bSign == 0 ? SHIFT_RIGHT(mult, (32 - ((2 * N) + 1))) : 
	SIGNED_SHIFT_RIGHT(mult, (32 - ((2 * N) + 1)));
      carry_save_adder_32(*part_sum_hi, 
			  srt, 
			  *part_carry_hi, part_sum_hi, part_carry_hi);
      break;
    case 6:
      carry_save_adder_32(*part_sum_lo, ~(SHIFT_LEFT(mult,(2 * N))), 
			  (*part_carry_lo) | 0x1 , part_sum_lo, part_carry_lo);
      srt = bSign == 0 ? SHIFT_RIGHT(mult,(32 - (2 * N))) : 
	SIGNED_SHIFT_RIGHT(mult,(32 - (2 * N)));
      carry_save_adder_32(*part_sum_hi, 
			  ~(srt), 
			  *part_carry_hi, part_sum_hi, part_carry_hi);
      break;
    case 7:
      carry_save_adder_32(*part_sum_lo, 0, *part_carry_lo,
			  part_sum_lo, part_carry_lo);
      carry_save_adder_32(*part_sum_hi, 0, *part_carry_hi,
			  part_sum_hi, part_carry_hi);
      break;
    }
 
#if 0
  if (N < 15)
    *carry = (temp >> 1) & 0x1;
  else
    *carry = 0;
#else
    *carry = (temp >> 1) & 0x1;
#endif
}
 
 
///////////////////////////////////////////////////////////////////////////////
// four_stage_booth - Does four rounds of booths alg at once
//
void scBooth::four_stage_booth(uint32_t* part_sum_hi, uint32_t* part_sum_lo, 
		      uint32_t* part_carry_hi, uint32_t* part_carry_lo,
		      uint32_t mult, uint32_t N, bool_t* carry,
		      uint32_t* multiplier, bool_t bSign)
{
  for (int i = 0; i < 4; i++)
    {
      booth_one_stage(part_sum_hi, part_sum_lo, 
		      part_carry_hi, part_carry_lo,
		      mult, (N * 4) + i, 
		      carry, *multiplier, bSign);
 
      *part_carry_hi = (*part_carry_hi << 1) | (*part_carry_lo >> 31);
      *part_carry_lo = *part_carry_lo << 1;
      *multiplier = *multiplier >> 2;
    }
}
 
 
 
void scBooth::entry()
{
  out=a*b;
}