URL https://opencores.org/ocsvn/scarm/scarm/trunk

Subversion Repositories scarm

[/] [scarm/] [trunk/] [src/] [scBarrelShifter.cpp] - Blame information for rev 10

Go to most recent revision | Details | Compare with Previous | View Log


///////////////////////////////////////////////////////////////////////////////
// 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 
//   
//
///////////////////////////////////////////////////////////////////////////////
 
/*****************************************************************************
 
  scBarrelShifter.cpp -- a barrel shifter
 
  Original Author: Allen Tao Zhong, University of Electronic Science and
                   Technology in China
 
 *****************************************************************************/
 
// scBarrelShifter.cpp: implementation of the scBarrelShifter class.
//
//////////////////////////////////////////////////////////////////////
 
#include "scBarrelShifter.h"
 
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
 
#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)
 
///////////////////////////////////////////////////////////////////////////////
//
//
uint32_t scBarrelShifter::Shift(uint32_t nVal,SHIFT type, int nDist)
{
        //out_b_RW=0;
    out_CPSR=R_CPSR;
        uint32_t nCPSR=inout_n_Flag;
  switch (type)
    {
      ////////////////////////////////////////////////////////////////
      case S_LSL: case S_ASL:
      {
                 if (nDist == 0)
                 {
                        m_nShiftCarryBit = (nCPSR & C_FLAG) ? 1 : 0;
                        return nVal;
                 }
                 else if (nDist == 32)
                 {
                        m_nShiftCarryBit = nVal & 0x1;
                        return 0;
                 }
             else if (nDist > 32)
                 {
                        m_nShiftCarryBit = 0;
                        return 0;
                 }
                 else
                 {
                        m_nShiftCarryBit = SHIFT_RIGHT(nVal, (32 - nDist)) & 0x1;
                        return (nVal << nDist); break;
                 }
      }
      break;
      ////////////////////////////////////////////////////////////////
    case S_LSR:
      {
        if (nDist == 0)
          {
            m_nShiftCarryBit = (nCPSR & C_FLAG) ? 1 : 0;
            return nVal;
          }
        else if (nDist == 32)
          {
            m_nShiftCarryBit = (nVal >> 31);
            return 0;
          }
        else if (nDist > 32)
          {
            m_nShiftCarryBit = 0;
            return 0;
          }
        else
          {
            m_nShiftCarryBit = (nVal >> (nDist - 1)) & 0x1;
            return (nVal >> nDist);
          }
      }
      break;
      ////////////////////////////////////////////////////////////////
    case S_ASR:
      {
        if (nDist == 0)
          {
            m_nShiftCarryBit = (nCPSR & C_FLAG) ? 1 : 0;
            return nVal;
          }
        else if (nDist >= 32)
          {
            if (nVal & 0x80000000)
              {
                m_nShiftCarryBit = 1;
                return 0xFFFFFFFF;
              }
            else
              {
                m_nShiftCarryBit = 0;
                return 0;
              }
          }
        else
          {
            uint32_t temp = 0xFFFFFFFF;
            m_nShiftCarryBit = (nVal >> (nDist - 1)) & 0x1;
            if ((nVal & 0x80000000) != 0)
              nVal = (nVal >> nDist) | (~(temp >> (nDist /* - 1 */)));
            else
              nVal = (nVal >> nDist);
 
            return nVal;
          }
      }
      break;
      ////////////////////////////////////////////////////////////////
    case S_ROR:
      {
        if (nDist == 0)
          {
            m_nShiftCarryBit = (nCPSR & C_FLAG) ? 1 : 0;
            return nVal;
          }
        else if ((nDist & 0x1F) == 0)
          {
            m_nShiftCarryBit = nVal >> 31;
            return nVal;
          }
        else
          {
            nDist &= 0x1F;
            m_nShiftCarryBit = SHIFT_RIGHT(nVal, (nDist - 1)) & 0x1;
            return (nVal >> nDist) | (nVal << (32 - nDist));
          }
      }
      break;
      ////////////////////////////////////////////////////////////////
    case S_RRX:
      {
            m_nShiftCarryBit = nVal & 0x1;
 
        uint32_t temp = nVal & 0x1;
        nVal = nVal >> 1;
        if (nCPSR & C_FLAG)
          nVal |= 0x80000000;
 
        return nVal;
      }
      break;
    default :
        {
          cout<<"error in scBarrelShifter.Shift\n";
                  return 0;
 
        }
   }//end of switch(type)
        out_b_RW=1;
    out_CPSR=R_CPSR;
        inout_n_Flag=nCPSR&(m_nShiftCarryBit<<29);
}
 
void scBarrelShifter::entry()
{
 
   uint32_t val,dist,new_val;
   val=in_n_Val;
   dist=in_n_Dist;
   new_val=Shift(val, in_SHIFT_TYPE, dist);
   out_n_NewVal=new_val;
   out_b_Carry=m_nShiftCarryBit?1:0;
 
   //cout<<" Shifter: Value="<<hex<<in_n_Val<<"  ShitfDist="<<in_n_Dist<<" shifted_value="<<hex<<new_val<<endl;
}
 

Browse

Tools

Subversion Repositories scarm

[/] [scarm/] [trunk/] [src/] [scBarrelShifter.cpp] - Blame information for rev 10

Line No.	Rev	Author	Line
1	5	zhong	`///////////////////////////////////////////////////////////////////////////////`
2			`// This program is free software; you can redistribute it and/or`
3			`// modify it under the terms of the GNU General Public License`
4			`// as published by the Free Software Foundation; either version 2`
5			`// of the License, or (at your option) any later version.`
6			`//`
7			`// This program is distributed in the hope that it will be useful,`
8			`// but WITHOUT ANY WARRANTY; without even the implied warranty of`
9			`// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
10			`// GNU General Public License for more details.`
11			`//`
12			`// You should have received a copy of the GNU General Public License`
13			`// along with this program; if not, write to the Free Software`
14			`// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.`
15			`//////////////////////////////////////////////////////////////////////`
16
17			`///////////////////////////////////////////////////////////////////`
18			`//`
19			`// Original Author: Allen Tao Zhong,`
20			`// University of Electronic Science and Technology in China`
21			`// email: zhong@opencores.org`
22			`// info This is a SystemC ARM model`
23			`//`
24			`//`
25			`///////////////////////////////////////////////////////////////////////////////`
26
27			`/*****************************************************************************`
28
29			`scBarrelShifter.cpp -- a barrel shifter`
30
31			`Original Author: Allen Tao Zhong, University of Electronic Science and`
32			`Technology in China`
33
34			`*****************************************************************************/`
35
36			`// scBarrelShifter.cpp: implementation of the scBarrelShifter class.`
37			`//`
38			`//////////////////////////////////////////////////////////////////////`
39
40			`#include "scBarrelShifter.h"`
41
42			`//////////////////////////////////////////////////////////////////////`
43			`// Construction/Destruction`
44			`//////////////////////////////////////////////////////////////////////`
45
46			`#define SHIFT_LEFT(_x,_y) ((_y >= 32) ? 0 : _x << _y)`
47			`#define SHIFT_RIGHT(_x,_y) ((_y >= 32) ? 0 : _x >> _y)`
48			`#define SIGNED_SHIFT_RIGHT(_x,_y) ((_y >= 32) ? ((_x >> 31) * 0xFFFFFFFF) : ((int32_t)_x) >> _y)`
49
50			`///////////////////////////////////////////////////////////////////////////////`
51			`//`
52			`//`
53			`uint32_t scBarrelShifter::Shift(uint32_t nVal,SHIFT type, int nDist)`
54			`{`
55			`//out_b_RW=0;`
56			`out_CPSR=R_CPSR;`
57			`uint32_t nCPSR=inout_n_Flag;`
58			`switch (type)`
59			`{`
60			`////////////////////////////////////////////////////////////////`
61			`case S_LSL: case S_ASL:`
62			`{`
63			`if (nDist == 0)`
64			`{`
65			`m_nShiftCarryBit = (nCPSR & C_FLAG) ? 1 : 0;`
66			`return nVal;`
67			`}`
68			`else if (nDist == 32)`
69			`{`
70			`m_nShiftCarryBit = nVal & 0x1;`
71			`return 0;`
72			`}`
73			`else if (nDist > 32)`
74			`{`
75			`m_nShiftCarryBit = 0;`
76			`return 0;`
77			`}`
78			`else`
79			`{`
80			`m_nShiftCarryBit = SHIFT_RIGHT(nVal, (32 - nDist)) & 0x1;`
81			`return (nVal << nDist); break;`
82			`}`
83			`}`
84			`break;`
85			`////////////////////////////////////////////////////////////////`
86			`case S_LSR:`
87			`{`
88			`if (nDist == 0)`
89			`{`
90			`m_nShiftCarryBit = (nCPSR & C_FLAG) ? 1 : 0;`
91			`return nVal;`
92			`}`
93			`else if (nDist == 32)`
94			`{`
95			`m_nShiftCarryBit = (nVal >> 31);`
96			`return 0;`
97			`}`
98			`else if (nDist > 32)`
99			`{`
100			`m_nShiftCarryBit = 0;`
101			`return 0;`
102			`}`
103			`else`
104			`{`
105			`m_nShiftCarryBit = (nVal >> (nDist - 1)) & 0x1;`
106			`return (nVal >> nDist);`
107			`}`
108			`}`
109			`break;`
110			`////////////////////////////////////////////////////////////////`
111			`case S_ASR:`
112			`{`
113			`if (nDist == 0)`
114			`{`
115			`m_nShiftCarryBit = (nCPSR & C_FLAG) ? 1 : 0;`
116			`return nVal;`
117			`}`
118			`else if (nDist >= 32)`
119			`{`
120			`if (nVal & 0x80000000)`
121			`{`
122			`m_nShiftCarryBit = 1;`
123			`return 0xFFFFFFFF;`
124			`}`
125			`else`
126			`{`
127			`m_nShiftCarryBit = 0;`
128			`return 0;`
129			`}`
130			`}`
131			`else`
132			`{`
133			`uint32_t temp = 0xFFFFFFFF;`
134			`m_nShiftCarryBit = (nVal >> (nDist - 1)) & 0x1;`
135			`if ((nVal & 0x80000000) != 0)`
136			`nVal = (nVal >> nDist) \| (~(temp >> (nDist /* - 1 */)));`
137			`else`
138			`nVal = (nVal >> nDist);`
139
140			`return nVal;`
141			`}`
142			`}`
143			`break;`
144			`////////////////////////////////////////////////////////////////`
145			`case S_ROR:`
146			`{`
147			`if (nDist == 0)`
148			`{`
149			`m_nShiftCarryBit = (nCPSR & C_FLAG) ? 1 : 0;`
150			`return nVal;`
151			`}`
152			`else if ((nDist & 0x1F) == 0)`
153			`{`
154			`m_nShiftCarryBit = nVal >> 31;`
155			`return nVal;`
156			`}`
157			`else`
158			`{`
159			`nDist &= 0x1F;`
160			`m_nShiftCarryBit = SHIFT_RIGHT(nVal, (nDist - 1)) & 0x1;`
161			`return (nVal >> nDist) \| (nVal << (32 - nDist));`
162			`}`
163			`}`
164			`break;`
165			`////////////////////////////////////////////////////////////////`
166			`case S_RRX:`
167			`{`
168			`m_nShiftCarryBit = nVal & 0x1;`
169
170			`uint32_t temp = nVal & 0x1;`
171			`nVal = nVal >> 1;`
172			`if (nCPSR & C_FLAG)`
173			`nVal \|= 0x80000000;`
174
175			`return nVal;`
176			`}`
177			`break;`
178			`default :`
179			`{`
180			`cout<<"error in scBarrelShifter.Shift\n";`
181			`return 0;`
182
183			`}`
184			`}//end of switch(type)`
185			`out_b_RW=1;`
186			`out_CPSR=R_CPSR;`
187			`inout_n_Flag=nCPSR&(m_nShiftCarryBit<<29);`
188			`}`
189
190			`void scBarrelShifter::entry()`
191			`{`
192
193			`uint32_t val,dist,new_val;`
194			`val=in_n_Val;`
195			`dist=in_n_Dist;`
196			`new_val=Shift(val, in_SHIFT_TYPE, dist);`
197			`out_n_NewVal=new_val;`
198			`out_b_Carry=m_nShiftCarryBit?1:0;`
199
200			`//cout<<" Shifter: Value="<<hex<<in_n_Val<<" ShitfDist="<<in_n_Dist<<" shifted_value="<<hex<<new_val<<endl;`
201			`}`
202