Subversion Repositories theia_gpu

/**********************************************************************************

Theia, Ray Cast Programable graphic Processing Unit.

Copyright (C) 2012  Diego Valverde (diego.valverde.g@gmail.com)

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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

***********************************************************************************/

#include "Instruction.h"

#include <sstream>

#include <iostream>

#include <iomanip>

//--------------------------------------------------------------

template <std::size_t N >

inline void SetbitRange( std::bitset<N> & aBitset , unsigned int aEnd, unsigned int aStart, unsigned int aValue)

{

        unsigned long mask = 1;

        unsigned long result = 0;

        for (int i = aStart; i <= aEnd; ++i)

        {

                aBitset[i] =  ( mask & aValue );

                mask <<= 1;

        }

}

//--------------------------------------------------------------

template <std::size_t N >

inline unsigned int GetbitRange( std::bitset<N> & aBitset , unsigned int aEnd, unsigned int aStart)

{

        unsigned long Result = 0;

        int j = 0;

        for (int i = aStart; i <= aEnd; ++i)

        {

                Result |=  ( aBitset[i] << j++);

        }

        return Result;

}

//--------------------------------------------------------------

const char lookuparrbin2hex[] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};

char convert_bin2hex(std::string bits)

{

        unsigned int result = 0;

        unsigned int shifter0 = 0;

        unsigned int shifter1 = 1;

        for(int n=0; n < bits.length(); n++)

        {

                result <<= 1; //shift result to the left by 1

                if(bits[n] == '1') result = (result | shifter1);

                else result = (result | shifter0);

        }

        return lookuparrbin2hex[result];

}

//--------------------------------------------------------------

std::string BinStringToHexString(std::string aBinString )

{

        std::string endresult = "";

        for(int i = 0; i < aBinString.length(); i = i+4)

        {

                endresult += convert_bin2hex(aBinString.substr(i,4));

        }

        return endresult;

}

//--------------------------------------------------------------

CControlInstruction::CControlInstruction()

{

mSourceLine = -1;

}

//--------------------------------------------------------------

CControlInstruction::~CControlInstruction()

{

}

//--------------------------------------------------------------

void CControlInstruction::Clear()

{

        mOperation = 0;

        mDestination = 0;

        mSource1 = 0;

        mSource0 = 0;

        mComment.clear();

        mCopyDestinationAddress = 0;

        mCopySourceAddress = 0;

        mCopyDestinationId = 0;

        mCopySize = 0;

        mSourceLine = -1;

}

//--------------------------------------------------------------

void CControlInstruction::SetDestinationAddress( unsigned int aAddress )

{

        mDestination = aAddress;

}

//--------------------------------------------------------------

void CControlInstruction::SetSrc1Address(unsigned int aAddress )

{

        mSource1 = aAddress;

}

//--------------------------------------------------------------

void CControlInstruction::SetSrc0Address(unsigned int aAddress )

{

        mSource0 = aAddress;

}

//--------------------------------------------------------------

void CControlInstruction::SetOperation( EOPERATION aCode )

{

        mOperation = aCode;

}

//--------------------------------------------------------------

void CControlInstruction::SetCopyDestinationAddress( unsigned int aAddress )

{

        mCopyDestinationAddress = aAddress;

}

//--------------------------------------------------------------

void CControlInstruction::SetCopySourceAddress( unsigned int aAddress )

{

        mCopySourceAddress = aAddress;

}

//--------------------------------------------------------------

void CControlInstruction::SetCopyDestinationId( unsigned int aId )

{

        mCopyDestinationId = aId;

}

//--------------------------------------------------------------

void CControlInstruction::SetCopySize( unsigned int aSize )

{

        mCopyDestinationAddress = mCopyDestinationAddress;

}

//--------------------------------------------------------------

void CControlInstruction::SetLiteral(  unsigned int aLiteral )

{

        mLiteral = aLiteral;

}

//--------------------------------------------------------------

std::string OperationStrings[] =

{

        "NOP",

        "DELIVERCOMMAND",

        "ADD",

        "SUB",

        "AND",

        "OR",

        "BRANCH",

        "BEQ",

        "BNE",

        "BG",

        "BL",

        "BGE",

        "BLE",

        "ASSIGN",

        "COPYBLOCK",

        "EXIT",

        "NOT",

        "SHL",

        "SHR"

};

//--------------------------------------------------------------

std::string CControlInstruction::PrintAssembly( void )

{

        std::ostringstream oss;

        std::bitset<INSTRUCTION_SIZE> Bitset;

        SetbitRange<INSTRUCTION_SIZE>( Bitset ,OP_RNG , mOperation);

        switch (mOperation)

        {

                case EOPERATION_COPYBLOCK:

                {

                SetbitRange<INSTRUCTION_SIZE>( Bitset ,COPY_DST_RNG,  mCopyDestinationAddress);

                SetbitRange<INSTRUCTION_SIZE>( Bitset ,COPY_SRC_RNG,  mCopySourceAddress);

                SetbitRange<INSTRUCTION_SIZE>( Bitset ,COPY_DSTID_RNG,  mCopyDestinationId);

                //SetbitRange<INSTRUCTION_SIZE>( Bitset ,COPY_SIZE_RNG,  mCopyDestinationAddress);

                /*std::bitset<32> BitsetWord32_0( GetbitRange<INSTRUCTION_SIZE>(Bitset,31,0) );

                std::bitset<32> BitsetWord32_1( GetbitRange<INSTRUCTION_SIZE>(Bitset,63,32) );

                std::bitset<32> BitsetWord32_2( GetbitRange<INSTRUCTION_SIZE>(Bitset,84,64) );*/

                //oss << std::hex << BitsetWord32_2 << " " << BitsetWord32_1 << " "<< BitsetWord32_0;

                oss << std::hex << Bitset.to_ulong();

                oss << "\t\t//" << OperationStrings[mOperation];

                oss << std::dec  << " DstId: R"  << mCopyDestinationId << " SrcOffset: R" << mCopySourceAddress << " DstOffsetAndLen: R" << mCopyDestinationAddress;

                }

                break;

                case EOPERATION_ASSIGN:

                {

                SetbitRange<INSTRUCTION_SIZE>( Bitset ,DST_RNG , mDestination);

                SetbitRange<INSTRUCTION_SIZE>( Bitset ,LITERAL_RNG , mLiteral);

                //SetbitRange<INSTRUCTION_SIZE>( Bitset ,63,32 , 0);

                /*std::bitset<32> BitsetWord32_0( GetbitRange<INSTRUCTION_SIZE>(Bitset,31,0) );

                std::bitset<32> BitsetWord32_1( GetbitRange<INSTRUCTION_SIZE>(Bitset,63,32) );

                std::bitset<32> BitsetWord32_2( GetbitRange<INSTRUCTION_SIZE>(Bitset,84,64) );

                oss << std::hex << BitsetWord32_2 << " " << BitsetWord32_1 << " "<< BitsetWord32_0;*/

                oss << std::hex << Bitset.to_ulong();

                oss << "\t\t//" << OperationStrings[mOperation];

                oss << std::dec << " R"  << mDestination << " I(" << mLiteral << " )";

                }

                break;

                default:

                {

                SetbitRange<INSTRUCTION_SIZE>( Bitset ,SRC0_RNG, mSource0);

                SetbitRange<INSTRUCTION_SIZE>( Bitset ,SRC1_RNG, mSource1);

                SetbitRange<INSTRUCTION_SIZE>( Bitset ,DST_RNG , mDestination);

                /*

                std::bitset<32> BitsetWord32_0( GetbitRange<INSTRUCTION_SIZE>(Bitset,31,0) );

                std::bitset<32> BitsetWord32_1( GetbitRange<INSTRUCTION_SIZE>(Bitset,63,32) );

                std::bitset<32> BitsetWord32_2( GetbitRange<INSTRUCTION_SIZE>(Bitset,84,64) );

                oss << std::hex << BitsetWord32_2 << " " << BitsetWord32_1 << " "<< BitsetWord32_0;*/

                oss << std::hex << Bitset.to_ulong();

                oss << "\t\t//" << OperationStrings[mOperation];

                oss << std::dec << " R"  << mDestination << " R" << mSource1 << " R" << mSource0;

                }

        }

        return oss.str();

}

//--------------------------------------------------------------