Member Avatar for Seapoe

Hello,

I've written a program that mimics a 32-bit MIPS processor. It does a couple of instructions. It works by reading in a Hexadecimal instruction of length 8 and then carrying out the instruction and writing the information to a file. It was working fine earlier but now I get an out of subscript range error when it encounters the third instruction. From my experience I know that that means I'm accessing a location that is not allocated. For some reason memory[ 0 ] is being wiped out. Please help as this is very annoying. I have uploaded the files. I'm using Microsoft Visual Studios

20220005
00221820
ACA3000A
8CA4000A
#include <iostream>
#include <fstream>
#include <string>
#include <iomanip>
#include <cstring>
#include "Org_MIPS.h"

using namespace std;

int main()
{
	string registers[ MAXREG ]; 
	string memory[ MAXMEM ];
	string binInstruction, hexInstruction, opCode, inFileName;
	ifstream inFile;
	ofstream outFile;
	int PC = 0;
	
	for ( int i = 0; i < MAXMEM; i++ )
		memory[ i ] = "00000000";
	
	for ( int i = 0; i < MAXREG; i++ )
		registers[ i ] = "00000000000000000000000000000000";

	cout << "Please enter the name of the file that contains the Hexadecimal Instructions:" << endl;
	cin >> inFileName;
	cout << endl;
	
	inFile.open( inFileName.c_str() );
	outFile.open( "Output.txt" );

	while ( !inFile.eof() )
	{
		cout << "We are executiing!!!" << endl << endl;
		inFile >> hexInstruction;
        cout << "Hex: " << hexInstruction << endl;
		outFile << "PC: " << PC << endl; 
		PC++;
		
		binInstruction = HexToBin( hexInstruction );
		cout << binInstruction << endl << endl;
		opCode = binInstruction.substr( 0,6 );

		if ( opCode == "000000" )
			RtypeInstruct( PC, opCode, binInstruction, registers, memory, outFile );
		else if ( opCode == "000010" )
			JtypeInstruct( PC, opCode, binInstruction, registers, memory, outFile );
		else
			ItypeInstruct( PC, opCode, binInstruction, registers, memory, outFile );
				
		outFile << "MEMORY" << endl;
		for ( int i = 0; i < MAXMEM; i++ )
		{
			if ( i <= 9 )
			{
				outFile << left << i << ".   "  << setfill( ' ' ) << setw( 32 )
				<< memory[ i ] << "  DecVal: " << BinToDec( memory[ i ] ) << endl;
			}
			else if ( i >= 10 && i <= 99 )
			{
				outFile << left << i << ".  "  << setfill( ' ' ) << setw( 32 )
				<< memory[ i ] << "  DecVal: " << BinToDec( memory[ i ] ) << endl;
			}
			else
			{
				outFile << left << i << ". "  << setfill( ' ' ) << setw( 32 )
				<< memory[ i ] << "  DecVal: " << BinToDec( memory[ i ] ) << endl;
			}
		}
		
		outFile << endl << "REGISTERS" << endl;
		for ( int i = 0; i < MAXREG; i++ )
		{
			if ( i <= 9 )
			{
				outFile << left << i << ".  " << setfill( ' ' ) << setw( 32 ) 
				<< registers[ i ] << "  DecVal: " << BinToDec( registers[ i ] ) << endl;
			}
			else
			{
				outFile << left << i << ". " << setfill( ' ' ) << setw( 32 ) 
				<< registers[ i ] << "  DecVal: " << BinToDec( registers[ i ] ) << endl;
			}
		}

		outFile << endl << "*********************************" << endl;
		cout << endl;
		system( "pause" );
		cout << endl << endl;
    }
    
	inFile.close();
	outFile.close();

	return 0;
}
#include <iostream>
#include <fstream>
#include <math.h>
#include <string>
#include <iomanip>

using namespace std;

#define MAXREG 16
#define MAXMEM 128
#define BINFORMAT 32

void RtypeInstruct( int&, string, string, string[], string[], ofstream& );
void ItypeInstruct( int&, string, string, string[], string[], ofstream& );
void JtypeInstruct( int&, string, string, string[], string[], ofstream& );
void ALU( string, string, string, string& );
void And( string[], string[], string& );
void Or( string[], string[], string& );
string Add( string, string );
string Subtract( string, string );
string suband( string, string );
string subor( string, string );
string leftshift( string, int );
string HexToBin( string );
string DecToBin( int );
int BinToDec ( string );
int RaiseToPower( int, int );

void RtypeInstruct( int& PC, string opCode, string binInstruct, string registers[], string memory[], ofstream& outFile )
{
	string rs, rt, rd, shamt, funct, out, inputA, inputB, op;
	string instructionType = "R-Type";
			
	rs = binInstruct.substr( 6, 5 );
	rt = binInstruct.substr( 11, 5 );
	rd = binInstruct.substr( 16, 5 );
	shamt = binInstruct.substr( 21, 5 );
	funct = binInstruct.substr( 26, 6 );

	cout << "opCode: " << opCode << endl << "Instruction Type: " << instructionType << endl <<  "rs: " << rs << endl << "rt: " 
		<< rt << endl << "rd: " << rd << endl << "shamt: " << shamt << endl << "funct: " << funct << endl << endl;

	outFile << "opCode: " << opCode << endl;
	outFile << "Instruction Type: " << instructionType << endl;
	outFile << "RS: " << rs << endl;
	outFile << "RT: " << rt << endl;
	outFile << "RD: " << rd << endl;
	outFile << "SHAMT: " << shamt << endl;
	outFile << "FUNCT: " << funct << endl;

	if ( rt[ 0 ] == '0' )
		rt = "000000000000000000000000000" + rt;
	else
		rt = "111111111111111111111111111" + rt;

	if ( rs[ 0 ] == '0' )							
		rs = "000000000000000000000000000" + rs;
	else
		rs = "111111111111111111111111111" + rs;

	if ( rd[ 0 ] == '0' )							
		rd = "000000000000000000000000000" + rd;
	else
		rd = "111111111111111111111111111" + rd;
	
	inputA = registers[ BinToDec( rs ) ];
	inputB = registers[ BinToDec( rt ) ];
	
	switch ( BinToDec( funct ) )
	{
		case 32: op = "add";
				 break;
        case 34: op = "sub";
                 break;
        case 36: op = "and";
                 break;
        case 37: op = "or";
    }

	cout << "Operation: " << op << endl;
	outFile << "Operation: " << op << endl << endl;

	ALU( op, inputA, inputB, out );
	registers[ BinToDec( rd ) ] = out;
}

void ItypeInstruct( int& PC, string opCode, string binInstruct, string registers[], string memory[], ofstream& outFile )
{
	string rs, rt, immediate, op, out, inputA, inputB, write_data, branch;
	string instructionType = "I-Type";

	rs = binInstruct.substr( 6, 5 );
	rt = binInstruct.substr( 11, 5 );
	immediate = binInstruct.substr( 16, 16 );

	cout << "opCode: " << opCode << endl << "Instruction Type: " << instructionType << endl <<  "rs: " << rs << endl << "rt: " 
		<< rt << endl << "Immediate: " << immediate << endl << endl;

	outFile << "opCode: " << opCode << endl;
	outFile << "Instruction Type: " << instructionType << endl;
	outFile << "RS: " << rs << endl;
	outFile << "RT: " << rt << endl;
	outFile << "Immediate: " << immediate << endl;

	if ( rt[ 0 ] == '0' )
		rt = "000000000000000000000000000" + rt;
	else
		rt = "111111111111111111111111111" + rt;

	if ( rs[ 0 ] == '0' )							
		rs = "000000000000000000000000000" + rs;
	else
		rs = "111111111111111111111111111" + rs;
	if ( immediate[ 0 ] == '0' )						
		immediate = "0000000000000000" + immediate;
	else
		immediate = "1111111111111111" + immediate;

	cout << BinToDec( rs ) << "ball";
	inputA = registers[ BinToDec( rs ) ];
	inputB = registers[ BinToDec( rt ) ];
	
	cout << "Operation: ";
	outFile << "Operation: ";
	
	if ( opCode  == "001000" )
	{
		op = "add";
        cout << "addi" << endl;
		outFile << "addi" << endl << endl;
		ALU( op, inputA, immediate, out );
		registers[ BinToDec( rt ) ] = out;
	}
	else if ( opCode == "000111" )
	{
		op = "sub";
        cout << "subi" << endl;
		outFile << "subi" << endl << endl;
        ALU( op, inputA, immediate, out );
        registers[ BinToDec( rt ) ] = out;
    }
	else if ( opCode  == "100011" )
    {
		op = "lw";
        cout << op << endl;
		outFile << op << endl << endl;
        ALU( op, inputA, immediate, out );
		write_data = memory[ BinToDec( out ) ];
		registers[ BinToDec( rt ) ] = write_data;
	}
	else if ( opCode  == "101011" )
	{
		op = "sw";
        cout << op << endl;
		outFile << op << endl << endl;
		cout << "inputA: " << inputA << endl << endl;
		ALU( op, inputA, immediate, out );
		memory[ BinToDec( out ) ] = inputB;
	}
	else if ( opCode  == "000100" )
	{
		cout << "beq" << endl;
		outFile << "beq" << endl << endl;
		if ( inputA == inputB )
		{
			ALU( "branch", DecToBin( PC ), leftshift( immediate, 2 ), branch );  
			PC = BinToDec( branch );
        }
	}
	else if ( opCode  == "000101" )
	{
		cout << "bne" << endl;
		outFile << "bne" << endl << endl;
		if ( inputA != inputB )
		{
			ALU( "branch", DecToBin( PC ), leftshift( immediate, 2 ), branch );
			PC = BinToDec( branch );
        }
	}
}

void JtypeInstruct( int& PC, string opCode, string binInstruct, string registers[], string memory[], ofstream& outFile )
{
	string branch; 

	string target = binInstruct.substr( 6, 26 );
	string instructionType = "J-Type";

	cout << "opCode: " << opCode << endl << "Instruction Type: " << instructionType << "Target: " << target;
	cout << "Operation: jump" << endl;

	outFile << "opCode: " << opCode << endl;
	outFile << "Instruction Type: " << instructionType << endl;
	outFile << "Target: " << target << endl;
	outFile << "Operation: jump" << endl << endl;
	
	branch = "00" + DecToBin( PC ) + target;
	PC = BinToDec( branch );
}

void And( string a[ 8 ], string b[ 8 ], string& out )
{
	string somearray;

	for ( int c = 0; c < 8; c++ )
	{
		somearray = somearray + suband( a[ c ], b[ c ] );
	}

	out = somearray;
}

string suband( string bin1, string bin2 )
{
	string andarray = "0000";

	for ( int i = 0; i < 4; i++ )
	{
		
		if ( bin1[ i ] == '1' && bin2[ i ] == '1' )	
			andarray[ i ] = '1';						
		else 
			andarray[ i ] = '0';
	}
	
	return andarray;
}


void Or( string a[ 8 ], string b[ 8 ], string& out )
{
	string somearray;

	for ( int c = 0; c < 8; c++ )
	{
		somearray = somearray + subor( a[ c ], b[ c ] );	
	}

	out = somearray;
}


string subor( string bin1, string bin2 )
{
	string orarray = "0000";

	for ( int i = 0; i < 4; i++ )
	{
		
		if ( bin1[ i ] == '1' || bin2[ i ] == '1' )	
			orarray[ i ] = '1';							
		else 
			orarray[ i ] = '0';
	}
	
	return orarray;	
}

string Add( string a, string b )
{

	char carry = '0';
	string aplusb = "00000000000000000000000000000000";
	
	for ( int i = BINFORMAT - 1; i >= 0; i-- )
	{
		if ( a[ i ] == '1' && b[ i ] == '1' )
		{
			if ( carry == '0' )
				aplusb[ i ] = '0';
			else 
				aplusb[ i ] = '1';
			carry = '1';
		}
		else if ( a[ i ] == '0' && b[ i ] == '1' )
		{
			if ( carry == '0' )
				aplusb[ i ] = '1';
			else
			{
				aplusb[ i ] = '0';
			    carry = '1';
			}
		}
		else if ( a[ i ] == '1' && b[ i ] == '0' )
		{
			if ( carry == '0' )
				aplusb[ i ] = '1';
			else
			{
				aplusb[ i ] = '0';
			    carry = '1';
			}
		}
		else if ( a[ i ] == '0' && b[ i ] == '0' )
		{
			if ( carry == '0' )
				aplusb[ i ] = '0';
			else
				aplusb[ i ] = '1';
			carry = '0';
		}

	}

	return aplusb; 
}

string Subtract( string a, string b )
{

	string one = "00000000000000000000000000000001";
	
	for ( int i = BINFORMAT - 1; i >= 0; i-- )
	{
		if ( b[ i ] == '1' )
			b[ i ] = '0';
		else
			b[ i ] = '1';
	}
	
	b = Add( b, one );	
	b = Add( a, b );

	return b;
}

string leftshift( string input, int shift_amt )
{
	for ( int a = 0; a < shift_amt; a++ )
	{
		ALU( "010", input, input, input );
	}
	return input;
}


string HexToBin( string Hex )
{
	string Binary = "";
	int hexLength = Hex.length();

	for ( int i = 0; i < hexLength; i++ )
	{
		switch ( toupper( Hex[ i ] ) )
		{
		case '0' : Binary += "0000";
			break;
		case '1' : Binary += "0001";
			break;
		case '2' : Binary += "0010";
				break;
		case '3' : Binary += "0011";
				break;
		case '4' : Binary += "0100";
				break;
		case '5' : Binary += "0101";
				break;
		case '6' : Binary += "0110";
				break;
		case '7' : Binary += "0111";
				break;
		case '8' : Binary += "1000";
				break;
		case '9' : Binary += "1001";
				break;
		case 'A' : Binary += "1010";
				break;
		case 'B' : Binary += "1011";
				break;
		case 'C' : Binary += "1100";
				break;
		case 'D' : Binary += "1101";
				break;
		case 'E' : Binary += "1110";
				break;
		case 'F' : Binary += "1111";
				break;
		}
	}

	return Binary;
}

int BinToDec( string input )
{
	int currentPos;
	int result = 0;
	int length = input.length();

	for ( int i = length - 1; i >= 0; i-- )
	{
		currentPos = int( input[ 1 ] ); 
		currentPos -=  48;
		int x = ( length - 1 ) - i;
		result +=  currentPos * RaiseToPower( 2 , x );
	}
	return result;
}

string DecToBin( int input )
{
	string result1 = "";
	string result2 = "";
	int remainder = 0;
	int currentPos = 0;
	int length = 0;

	do
	{
		remainder = input % 2;
		
		if ( remainder == 1 )
			result1 += '1';
		else
			result1 += '0';
		
		input = input / 2;
	
	} while ( input != 0 );

	result2 = result1;
	length = result1.length();

	for ( int i = 0; i < length; i++ )
	{
		currentPos = ( length - 1 );
		result2[ i ] = result1[ currentPos - i ];
	}

	for ( int i = 0; i < ( BINFORMAT - length ); i++ )
		result2 += '0'; 
	
	return result2;
}

void ALU( string op, string A, string B, string& out )
{ 
	string bin_A[ 8 ];
	string bin_B[ 8 ];

for ( int z = 0; z < 8; z++ )
{
	int i = z * 4;
	bin_A[ z ] = B.substr( i, 4 );
}
cout << "boo!!!"
  • 2 Contributors
  • 3 Replies
  • 86 Views
  • 5 Days Discussion Span
  • Latest Post Latest Post by Seapoe
Member Avatar for Ancient Dragon

Use your compiler's debugger and step through the program one line at a time.

Member Avatar for Seapoe

Use your compiler's debugger and step through the program one line at a time.

How do you do that? Sorry for the ignorance.

Member Avatar for Seapoe

Figured out the issue. The issue was my BinToDec function. I had a 1 instead of i. Problem solved!!

Be a part of the DaniWeb community

We're a friendly, industry-focused community of developers, IT pros, digital marketers, and technology enthusiasts meeting, networking, learning, and sharing knowledge.