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)
//        
// scALU.cpp: implementation of the scALU class.
//
//////////////////////////////////////////////////////////////////////
 
#include "scALU.h"
#define DEBUG
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
 
#include "scALU.h"
#include"scARMInstruction.h"
#define CARRY_FROM(_a,_b,_r) ((_a >> 31) ? ((_b >> 31) | ((~_r) >> 31)) : ((_b >> 31) * ((~_r) >> 31)))
 
#define BORROWED_FROM(_a,_b,_r) ((_a >> 31) ? ((_b >> 31) & (_r >> 31)) : ((_b >> 31) | (_r >> 31)))
 
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
 
 
 
scALU::~scALU()
{
 
}
/******************************************************************************
 *
 */
uint32_t scALU::adc_op(uint32_t a, uint32_t b, uint32_t* cond)
{
  int64_t temp;
  //int64_t result;
  uint32_t short_res;
  uint32_t c = (*cond);
 
  temp = (int32_t)a;
  temp += (int32_t)b;
  if (c & C_FLAG)
    temp++;
 
  //result = temp & 0x00000000FFFFFFFFL;
  short_res = (uint32_t)((uint64_t)temp);
 
  // Clear flags 
  *cond &= 0x0FFFFFFF;
 
  // N Flags = Rd[31] 
  if (((temp >> 31) & 0x1) == 1)
    (*cond) |= N_FLAG;
 
  // Z Flag = if Rd == 0 then 1 else 0
  if (short_res == 0)
    (*cond) |= Z_FLAG;
 
  // C Flag = CarryFrom(Rn + shifter_operand + C Flag)
  if (CARRY_FROM((uint32_t)a, (uint32_t)b, short_res))
    (*cond) |= C_FLAG;
 
  // V Flag = OverflowFrom(Rn + shifter_operand + C Flag)
  if (((temp >> 32) & 0x1) != ((temp >> 31) & 0x1))
    (*cond) |= V_FLAG;
 
  return (uint32_t)short_res;
}
 
 
 
uint32_t scALU::add_op(uint32_t a, uint32_t b, uint32_t* cond)
{
  int64_t temp;
  //int64_t result;
  uint32_t short_res;
  uint32_t c = (*cond);
 
  temp = (int64_t)((int32_t)a);
  temp += (int64_t)((int32_t)b);
 
  //result = temp & 0x00000000FFFFFFFFL;
  short_res = (uint32_t)((uint64_t)temp);
 
  // Clear flags 
  *cond &= 0x0FFFFFFF;
 
  // N Flags = Rd[31] 
  if (((temp >> 31) & 0x1) == 1)
    (*cond) |= N_FLAG;
 
  // Z Flag = if Rd == 0 then 1 else 0
  if (short_res == 0)
    (*cond) |= Z_FLAG;
 
  // C Flag = CarryFrom(Rn + shifter_operand)
  if (CARRY_FROM((uint32_t)a, (uint32_t)b, short_res))
    (*cond) |= C_FLAG;
 
  // V Flag = OverflowFrom(Rn + shifter_operand)
  if (((temp >> 32) & 0x1) != ((temp >> 31) & 0x1)) {
    (*cond) |= V_FLAG;
  }
 
  return (uint32_t)short_res;
}
 
/******************************************************************************
 *
 */
uint32_t scALU::and_op(uint32_t a, uint32_t b, uint32_t* cond)
{
  uint32_t temp;
 
  temp = a & b;
 
  // Clear flags - V flag uneffected
  *cond &= (0x0FFFFFFF | V_FLAG);
 
  // N Flag = Rd[31]
  if (((temp >> 31) & 0x1) == 1)
    (*cond) |= N_FLAG;
 
  // Z Flag = if Rd == 0 then 1 else 0
  if (temp == 0)
    (*cond) |= Z_FLAG;
 
  // C Flag = shifter_carry_out 
  // Done otherwhere
 
  // V Flag = unaffected
 
  return temp;
}
 
 
/******************************************************************************
 *
 */
uint32_t scALU::bic_op(uint32_t a, uint32_t b, uint32_t* cond)
{
  uint32_t temp;
 
  temp = a & ~b;
 
  // Clear flags
  *cond &= (0x0FFFFFFF | V_FLAG);
 
  // N Flag = Rd[31]
  if (((temp >> 31) & 0x1) == 1)
    (*cond) |= N_FLAG;
 
  // Z Flag = if Rd == 0 then 1 else 0
  if (temp == 0)
    (*cond) |= Z_FLAG;
 
  // C Flag = shifter_carry_out 
  // Done otherwhere
 
  // V Flag = unaffected
 
  return temp;
}
 
 
/******************************************************************************
 *
 */
uint32_t scALU::cmn_op(uint32_t a, uint32_t b, uint32_t* cond)
{
  int64_t temp;
  //int64_t result;
  uint32_t short_res;
  uint32_t c = (*cond);
 
  temp = (int64_t)a;
  temp += (int64_t)b;
 
  //result = temp & 0x00000000FFFFFFFFL;
  short_res = (uint32_t)((uint64_t)temp);
 
  // Clear flags
  *cond &= 0x0FFFFFFF;
 
  // N Flags = Rd[31] 
  if (((temp >> 31) & 0x1) == 1)
    (*cond) |= N_FLAG;
 
  // Z Flag = if Rd == 0 then 1 else 0
  if (short_res == 0)
    (*cond) |= Z_FLAG;
 
  // C Flag = CarryFrom(Rn + shifter_operand)
  if (CARRY_FROM((uint32_t)a, (uint32_t)b, short_res))
    (*cond) |= C_FLAG;
 
  temp = (int64_t)((int32_t)a);
  temp += (int32_t)b;
 
  // V Flag = OverflowFrom(Rn + shifter_operand)
  if (((temp >> 32) & 0x1) != ((temp >> 31) & 0x1))
    (*cond) |= V_FLAG;
 
  return 0;
}
 
 
/******************************************************************************
 *
 */
uint32_t scALU::cmp_op(uint32_t a, uint32_t b, uint32_t* cond)
{
  int64_t temp, result;
  uint32_t short_res;
  uint32_t c = (*cond);
 
  temp = (int32_t)a;
  temp -= (int32_t)b;
 
  result = temp & 0x00000000FFFFFFFFL;
  short_res = (uint32_t)((uint64_t)temp);
 
  uint64_t temp2 = (uint32_t)a;
  temp2 -= (uint32_t)b;
 
  uint64_t result2 = temp2 & 0x00000000FFFFFFFF;
 
  // Clear flags
  *cond &= 0x0FFFFFFF;
 
  // N Flag = Rd[31]
  if (((temp >> 31) & 0x1) == 1)
    (*cond) |= N_FLAG;
 
  // Z Flag = if Rd == 0 then 1 else 0
  if (short_res == 0)
    (*cond) |= Z_FLAG;
 
  // C Flag = NOT BorrowFrom(Rn - shifter_operand)
  //if (result2 == temp2)
  if (BORROWED_FROM((uint32_t)a, (uint32_t)b, short_res) == 0)
    (*cond) |= C_FLAG;
 
  // V Flag = OverFlowFrom (Rn - shifter_operand)
  if (((temp >> 32) & 0x1) != ((temp >> 31) & 0x1))
    (*cond) |= V_FLAG;
 
  return 0;
}
 
 
/******************************************************************************
 *
 */
uint32_t scALU::eor_op(uint32_t a, uint32_t b, uint32_t* cond)
{
  uint32_t temp;
 
  temp = a ^ b;
 
  // Clear flags (overflow unaffected)
  *cond &= (0x0FFFFFFF | V_FLAG);
 
  // N Flag = Rd[31]
  if (((temp >> 31) & 0x1) == 1)
    (*cond) |= N_FLAG;
 
  // Z Flag = if Rd == 0 then 1 else 0
  if (temp == 0)
    (*cond) |= Z_FLAG;
 
  // C Flag = shifter_carry_out 
  // Done otherwhere
 
  // V Flag = unaffected
 
  return temp;
}
 
 
/******************************************************************************
 *
 */
uint32_t scALU::mov_op(uint32_t a, uint32_t b, uint32_t* cond)
{
  // Clear flags (overflow unaffected)
  *cond &= (0x0FFFFFFF | V_FLAG);
 
  // N Flag = Rd[31]
  if (((b >> 31) & 0x1) == 1)
    (*cond) |= N_FLAG;
 
  // Z Flag = if Rd == 0 then 1 else 0
  if (b == 0)
    (*cond) |= Z_FLAG;
 
  //cout<<"move"<<endl;
  // C Flag = shifter_carry_out 
  // Done otherwhere
 
  // V Flag = unaffected
 
  return b;
}
 
 
/******************************************************************************
 *
 */
uint32_t scALU::mvn_op(uint32_t a, uint32_t b, uint32_t* cond)
{
  // Clear flags (overflow unaffected)
  *cond &= (0x0FFFFFFF | V_FLAG);
 
  // N Flag = Rd[31]
  if (((b >> 31) & 0x1) == 1)
    (*cond) |= N_FLAG;
 
  // Z Flag = if Rd == 0 then 1 else 0
  if (~b == 0)
    (*cond) |= Z_FLAG;
 
  // C Flag = shifter_carry_out 
  // Done otherwhere
 
  // V Flag = unaffected
 
  return ~b;
}
 
 
/******************************************************************************
 *
 */
uint32_t scALU::orr_op(uint32_t a, uint32_t b, uint32_t* cond)
{
  uint32_t temp;
 
  temp = a | b;
 
  // Clear flags (overflow unaffected)
  *cond &= (0x0FFFFFFF | V_FLAG);
 
  // N Flag = Rd[31]
  if (((b >> 31) & 0x1) == 1)
    (*cond) |= N_FLAG;
 
  // Z Flag = if Rd == 0 then 1 else 0
  if (temp == 0)
    (*cond) |= Z_FLAG;
 
  // C Flag = shifter_carry_out 
  // Done otherwhere
 
  // V Flag = unaffected
 
  return temp;
}
 
 
/******************************************************************************
 *
 */
uint32_t scALU::rsb_op(uint32_t a, uint32_t b, uint32_t* cond)
{
  int64_t temp, result;
  uint32_t short_res;
  uint32_t c = (*cond);
 
  temp = (int32_t)b;
  temp -= (int32_t)a;
 
  result = temp & 0x00000000FFFFFFFFL;
  short_res = (uint32_t)((uint64_t)temp);
 
  // Clear flags
  *cond &= 0x0FFFFFFF;
 
  // N Flag = Rd[31]
  if (((temp >> 31) & 0x1) == 1)
    (*cond) |= N_FLAG;
 
  // Z Flag = If Rd == 0 then 1 else 0
  if (result == 0)
    (*cond) |= Z_FLAG;
 
  // C Flag = NOT BorrowedFrom(shifter_operand - Rn)
  if (BORROWED_FROM((uint32_t)b, (uint32_t)a, short_res) == 0)
    (*cond) |= C_FLAG;
 
  // V Flag = OverflowFrom(shifter_operand - Rn)
  if (((temp >> 32) & 0x1) != ((temp >> 31) & 0x1))
    (*cond) |= V_FLAG;
 
  return (uint32_t)result;
}
 
 
/******************************************************************************
 *
 */
uint32_t scALU::rsc_op(uint32_t a, uint32_t b, uint32_t* cond)
{
  int64_t temp, result;
  uint32_t short_res;
  uint32_t c = (*cond);
 
  temp = (int32_t)b;
  temp -= (int32_t)a;
  if (!(c & C_FLAG))
    temp--;
 
  result = temp & 0x00000000FFFFFFFFL;
  short_res = (uint32_t)((uint64_t)temp);
 
  // Clear flags
  *cond &= 0x0FFFFFFF;
 
  // N Flag = Rd[31]
  if (((temp >> 31) & 0x1) == 1)
    (*cond) |= N_FLAG;
 
  // Z Flag = If Rd == 0 then 1 else 0
  if (result == 0)
    (*cond) |= Z_FLAG;
 
  // C Flag = NOT BorrowedFrom(shifter_operand - Rn - NOT(C Flag))
  if (BORROWED_FROM((uint32_t)b, (uint32_t)a, short_res) == 0)
    (*cond) |= C_FLAG;
 
  // V Flag = OverflowFrom(shifter_operand - Rn - NOT(C Flag))
  if (((temp >> 32) & 0x1) != ((temp >> 31) & 0x1))
    (*cond) |= V_FLAG;
 
  return (uint32_t)result;
}
 
 
/******************************************************************************
 *
 */
uint32_t scALU::sbc_op(uint32_t a, uint32_t b, uint32_t* cond)
{
  int64_t temp, result;
  uint32_t short_res;
  uint32_t c = (*cond);
 
  temp = (int32_t)a;
  temp -= (int32_t)b;
  if (!(c & C_FLAG))
    temp--;
 
  result = temp & 0x00000000FFFFFFFFL;
  short_res = (uint32_t)((uint64_t)temp);
 
  // Clear flags
  *cond &= 0x0FFFFFFF;
 
  // N Flag = Rd[31]
  if (((temp >> 31) & 0x1) == 1)
    (*cond) |= N_FLAG;
 
  // Z Flag = If Rd == 0 then 1 else 0
  if (result == 0)
    (*cond) |= Z_FLAG;
 
  // C Flag = NOT BorrowedFrom(Rn - shifter_operand - NOT(C Flag))
  if (BORROWED_FROM((uint32_t)a, (uint32_t)b, short_res) == 0)
    (*cond) |= C_FLAG;
 
  // V Flag = OverflowFrom(Rn - shifter_operand - NOT(C Flag))
  if (((temp >> 32) & 0x1) != ((temp >> 31) & 0x1))
    (*cond) |= V_FLAG;
 
  return (uint32_t)result;
}
 
 
/******************************************************************************
 *
 */
uint32_t scALU::sub_op(uint32_t a, uint32_t b, uint32_t* cond)
{
  int64_t temp, result, foo;
  uint32_t c = (*cond);
  //uint32_t res;
 
  temp = (int32_t)a;
  temp -= (int32_t)b;
 
  result = temp & 0x00000000FFFFFFFFL;
 
  // Clear flags
  *cond &= 0x0FFFFFFF;
 
  // N Flag = Rd[31]
  if (((temp >> 31) & 0x1) == 1)
    (*cond) |= N_FLAG;
 
  // Z Flag = If Rd == 0 then 1 else 0
  if (result == 0)
    (*cond) |= Z_FLAG;
 
// C Flag = NOT BorrowedFrom(Rn - shifter_operand - NOT(C Flag))
#if 0
  if (result == temp)
    (*cond) |= C_FLAG;
#else
  foo = (uint32_t)((uint64_t)result);
  //cout.form("foo = 0x%08x\n", foo);
  if (BORROWED_FROM(a, b, foo) == 0)
    (*cond) |= C_FLAG;
 
#endif
 
  // V Flag = OverflowFrom(Rn - shifter_operand - NOT(C Flag))
  if (((temp >> 32) & 0x1) != ((temp >> 31) & 0x1))
    (*cond) |= V_FLAG;
 
  return (uint32_t)result;
}
 
 
/******************************************************************************
 *
 */
uint32_t scALU::teq_op(uint32_t a, uint32_t b, uint32_t* cond)
{
  uint32_t result;
 
  result = a ^ b;
 
  // Clear Flags (overflow unaffected)
  *cond &= (0x0FFFFFFF | V_FLAG);
 
  // N Flag = Rd[31]
  if (((result >> 31) & 0x1) == 1)
    (*cond) |= N_FLAG;
 
  // Z Flag = If Rd == 0 then 1 else 0
  if (result == 0)
    (*cond) |= Z_FLAG;
 
  // C Flag = shifter_carry_out 
  // Done otherwhere
 
  // V Flag = unaffected
 
  return 0;
}
 
 
/******************************************************************************
 *
 */
uint32_t scALU::tst_op(uint32_t a, uint32_t b, uint32_t* cond)
{
  int32_t result;
 
  result = a & b;
 
  // Clear Flags (overflow unaffected)
  *cond &= (0x0FFFFFFF | V_FLAG);
 
  // N Flag = Rd[31]
  if (((result >> 31) & 0x1) == 1)
    (*cond) |= N_FLAG;
 
  // Z Flag = If Rd == 0 then 1 else 0
  if (result == 0)
    (*cond) |= Z_FLAG;
 
  // C Flag = shifter_carry_out 
  // Done otherwhere
 
  // V Flag = unaffected
 
  return 0;
}
void scALU::entry()
{
   OPCODE   op   =in_OP;
   uint32_t condition=inout_n_Flag;
   uint32_t a    =in_n_A;
   uint32_t b    =in_n_B;
 
   //sc_time local_time = sc_time_stamp();
 
   uint32_t result=0;
   switch (op)
   {
    case OP_AND: { 	result=and_op(a,b,&condition);/*cout<<"and_op";*/   break; }
    case OP_EOR: { 	result=eor_op(a,b,&condition);/*cout<<"eor_op";*/	break; }
    case OP_SUB: { 	result=sub_op(a,b,&condition);/*cout<<"sub_op";*/	break; }
    case OP_RSB: { 	result=rsb_op(a,b,&condition);/*cout<<"rsb_op";*/	break; }
    case OP_ADD: { 	result=add_op(a,b,&condition);/*cout<<"add_op";*/	break; }
    case OP_ADC: { 	result=adc_op(a,b,&condition);/*cout<<"adc_op";*/   break; }
    case OP_SBC: { 	result=sbc_op(a,b,&condition);/*cout<<"sbc_op";*/	break; }
    case OP_RSC: { 	result=rsc_op(a,b,&condition);/*cout<<"rsc_op";*/	break; }
    case OP_TST: { 	result=tst_op(a,b,&condition);/*cout<<"tst_op";*/	break; }
    case OP_ORR: { 	result=orr_op(a,b,&condition);/*cout<<"orr_op";*/	break; }
    case OP_TEQ: { 	result=teq_op(a,b,&condition);/*cout<<"teq_op";*/	break; }
    case OP_CMP: { 	result=cmp_op(a,b,&condition);/*cout<<"cmp_op";*/	break; }
    case OP_CMN: { 	result=cmn_op(a,b,&condition);/*cout<<"cmn_op";*/	break; }
    case OP_MOV: { 	result=mov_op(a,b,&condition);/*cout<<"mov_op";*/	break; }
    case OP_BIC: { 	result=bic_op(a,b,&condition);/*cout<<"bic_op";*/	break; }
    case OP_MVN: { 	result=mvn_op(a,b,&condition);/*cout<<"mvn_op";*/	break; }
    default:
		{
          cout<<"ALU: unknown op="<<op<<endl;
 
		}
   }//end of switch op
   inout_n_Flag=condition;
   //cout<<"flag="<<condition<<endl;
   out_n_Out=result;
 
#if defined(DEBUG)
   // cout<<" ALU: output="<<result<<endl;
#endif
}
 
void scALU::display()
{
   cout<<"A="<<in_n_A<<" B="<<in_n_B<<endl;
}