/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

/*
 * File:   main_v2.c
 * Author: AslakV
 *
 * Created on 16. november 2017, 13:50
 */

#include <stdio.h>
#include <stdlib.h>

#define MAX_PROGRAM_SIZE 1000000

static int reg[32];
/*
static int progr[] = {
    // As minimal RISC-V assembler example
    0x00200093, // addi x1 x0 2
    0x00300113, // addi x2 x0 3
    0x002081b3, // add x3 x1 x2
};
*/

// int progrLenght = sizeof (progr) / sizeof (progr[0]);

int main(int argc, char *argv[]) {

    static int PC = 0;

    FILE *fp;
    int program_done = 0;
    unsigned int progr[MAX_PROGRAM_SIZE];
//    unsigned int rd, rs1, rs2;
    unsigned int progrLenght = 0;

    if(argc == 2){
        fp = fopen(argv[1], "r");   // Set pointer to file referenced by argv

        // Load content of the input file into an array
        while(!program_done){
            fread(&progr[progrLenght], 4, 1, fp);   // (ptr to dist, wordsize, # of words, file ptr)
            if(progr[progrLenght] == 0x00000073 || progrLenght > 50){     // DEBUG: (instruction_count < 20)
                program_done = 1;
            }
            progrLenght++;
        }
        program_done = 0;
        fclose(fp);     // Close file pointer

        // DEBUG: Read content of array
        printf("instruction count: %u \n", progrLenght);
        for(unsigned int i = 0 ; i < progrLenght ; i++){
            printf("%#.8x\n", progr[i]);
        }
    }else{
        printf("Too few or too many args \n");
    }


    while (PC < progrLenght) {
        int instr = progr[PC];
        int opcode = instr & 0b01111111;
        int rd = (instr >> 7) & 0x01f;
        int func3 = (instr >> 12) & 0b111; // >>10
        int rs1 = (instr >> 15) & 0x01f;
        int rs2 = (instr >> 20) & 0x01f;
        int rs1_l = reg[rs1];
        int rs2_l = reg[rs2]; // local register values
        int i_imm = (instr >> 20); // immidiate is bit 0 to
        int u_imm = (instr >> 12); // *add bitmask*

        int func6 = (i_imm >> 5); // i_imm >>6
        int func7 = (i_imm >> 6); // i_imm >>7

        printf("\nPC: %u \t opcode: %u \t func3: %u \t func6: %u \t func7: %u \n", PC, opcode, func3, func6, func7);

        switch (opcode) {
            case 0b0110011: // R-type
//            printf("\n\nR TYPE\n\n");
                switch (func3) {
                    case 0b000: // add, sub
                        switch (func7) {
                            case 0b0000000: // add
                                reg[rd] = reg[rs1] + reg[rs2];
                                break;
                            case 0b0100000: // sub
                                reg[rd] = reg[rs1] - reg[rs2];
                                break;
                            default:
                                printf("\n ERROR, R-type func7 can't be %d \n", func7);
                                break;
                        }
                        break;
                    case 0b001: // sll
                        reg[rd] = (reg[rs1] << reg[rs2]); // arit og logisk bør være ens
                        break;
                    case 0b100: // xor
                        reg[rd] = reg[rs1] ^ reg[rs2];
                        break;
                    case 0b101: // srl, sra
                        switch (func7) {
                            case 0b0000000: // srl
                                while (rs2_l--) {
                                    rs1_l = (rs1_l >> 1) & 0x7FFFFFFF;
                                }
                                reg[rd] = rs1_l;
                                break;
                            case 0b0100000: // sra

                                if (rs1_l & 0x80000000 == 0x80000000) { // if MSB = 1
                                    while (rs2_l--) {
                                        rs1_l = (rs1_l >> 1) & 0x7FFFFFFF;
                                    }
                                } else { // if MSB = 0
                                    while (rs2_l--) {
                                        rs1_l = (rs1_l >> 1) | 0x80000000;
                                    }
                                }
                                reg[rd] = rs1_l;
                                break;
                            default:
                                printf("\n ERROR, R-type func7 can't be %d \n", func7);
                                break;
                        }
                    case 0b110: // or
                        reg[rd] = reg[rs1] | reg[rs2];
                        break;
                    case 0b111: // and
                        reg[rd] = reg[rs1] & reg[rs2];
                        break;
                    default:
                        printf("\n ERROR, opcode can't be %d \n", opcode);
                        break;
                }
                break;




            case 0b0000011: // i-type
                switch (func3) {
                    case 000: //lb

                        break;
                    case 001: //lh

                        break;
                    case 0b010: //lw

                        break;
                    case 0b011: //ld

                        break;
                    case 0b100: //lbu

                        break;
                    case 0b101: //lhu

                        break;
                    case 0b110: //lwu

                        break;
                    default:
                        printf("\n ERROR, I-type (1) func3 can't be %d \n", func3);
                        break;
                }

            case 0b0010011: // i-type
                switch (func3) {
                    case 0b000: // addi
                        reg[rd] = reg[rs1] + i_imm;
                        break;
                    case 0b001: //slli
                        reg[rd] = (reg[rs1] << i_imm);
                        break;
                    case 0b100: //xori
                        reg[rd] = reg[rs1] ^ i_imm;
                        break;
                    case 0b101: //srli, srai
                        i_imm = (i_imm & 0b000000111111); // remove func6 from imm
                        if (func6 == 0) {   // srli
                            while (i_imm--) {
                                rs1_l = (rs1_l >> 1) & 0x7FFFFFFF;
                            }
                            reg[rd] = rs1_l;
                        } else if (func6 == 0b100000) { // srai

                           if (rs1_l & 0x80000000 == 0x80000000) { // if MSB = 1
                                while (i_imm--) {
                                    rs1_l = (rs1_l >> 1) & 0x7FFFFFFF;
                                }
                            } else { // if MSB = 0
                                while (i_imm--) {
                                    rs1_l = (rs1_l >> 1) | 0x80000000;
                                }
                            }
                            reg[rd] = rs1_l;
                        } else {
                            printf("\n ERROR, I-type func6 can't be %d \n", func6);
                        }
                        break;
                    case 0b110: //ori
                        reg[rd] = reg[rs1] | i_imm;
                        break;
                    case 0b111: // andi
                        reg[rd] = reg[rs1] & i_imm;
                        break;
                    default:
                        printf("\n ERROR, I-type (2) func3 can't be %d \n", func3);
                        break;
                }
                break;


            case 0b0110111: // U type, lui
                reg[rd] = (u_imm << 12);
                break;


            case 0x73:
                printf("ecall \n");
                break;
            default:
                printf("\n ERROR, opcode can't be %d \n", opcode);
                break;
        }

        PC++; // We count in 4 byte words

        for (int i = 0; i < 32; ++i) {
            if(i==8 || i==16 || i==24) printf("\n");
            printf("x%2d = %8x | ", i, reg[i]);
        }
        printf("\n");
    }
    printf("\nProgram exit \n\n");
    return 0;
}