main.c

#include <stdio.h>
#include <stdint.h>
#include <signal.h>
// Linux only 
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/termios.h>
#include <sys/mman.h>






// Hardware defintions

#define MEMORY_MAX (1<<16) // same as 2^16
uint16_t memory[MEMORY_MAX];  /* 65536 locations */

// Registers 
enum
{
    R_R0 = 0,
    R_R1,
    R_R2,
    R_R3,
    R_R4,
    R_R5,
    R_R6,
    R_R7,
    R_PC, /* program counter */
    R_COND,
    R_COUNT
};

// Memory mapped registers
enum
{
    MR_KBSR = 0xFE00, /* keyboard status */
    MR_KBDR = 0xFE02  /* keyboard data */
};



// The registers are stored in an array 
uint16_t reg[R_COUNT]; //r count since its the last element hence will have the last number 
// Should this not need R_COUNT+1 ??


// Instruction set 
enum
{
    OP_BR = 0, /* branch */
    OP_ADD,    /* add  */
    OP_LD,     /* load */
    OP_ST,     /* store */
    OP_JSR,    /* jump register */
    OP_AND,    /* bitwise and */
    OP_LDR,    /* load register */
    OP_STR,    /* store register */
    OP_RTI,    /* unused */
    OP_NOT,    /* bitwise not */
    OP_LDI,    /* load indirect */
    OP_STI,    /* store indirect */
    OP_JMP,    /* jump */
    OP_RES,    /* reserved (unused) */
    OP_LEA,    /* load effective address */
    OP_TRAP    /* execute trap */
};


// Condition flags LC-3 has 3 of them 
enum
{
    FL_POS = 1 << 0, /* P */
    FL_ZRO = 1 << 1, /* Z */
    FL_NEG = 1 << 2, /* N */
};

// End of hardware definitions 


// Extending unsigned integers 
uint16_t sign_extend(uint16_t x, int bit_count)
{
    // Bit count is the number of bits in the number x (msb pos of x)
    if ((x >> (bit_count - 1)) & 1) {
        x |= (0xFFFF << bit_count);
    }
    return x;
}





// The condition codes are set, based on whether the result is negative, zero, or positive. (Pg. 526) (FOR ADD)
// Earlier we defined a condition flags enum, and now it’s time to use them. Any time a value is written to a register, we need to update the flags to indicate its sign. We will write a function so that this can be reused:

void update_flags(uint16_t r)
{
    if (reg[r] == 0)
    {
        reg[R_COND] = FL_ZRO;
    }
    else if (reg[r] >> 15) /* a 1 in the left-most bit indicates negative */
    {
        reg[R_COND] = FL_NEG;
    }
    else
    {
        reg[R_COND] = FL_POS;
    }
}






// Trap routines
enum
{
    TRAP_GETC = 0x20,  /* get character from keyboard, not echoed onto the terminal */
    TRAP_OUT = 0x21,   /* output a character */
    TRAP_PUTS = 0x22,  /* output a word string */
    TRAP_IN = 0x23,    /* get character from keyboard, echoed onto the terminal */
    TRAP_PUTSP = 0x24, /* output a byte string */
    TRAP_HALT = 0x25   /* halt the program */
}; 



uint16_t swap16(uint16_t x)
{
    return (x << 8) | (x >> 8);
}


void read_image_file(FILE* file)
{
    /* the origin tells us where in memory to place the image */
    uint16_t origin;
    fread(&origin, sizeof(origin), 1, file);
    origin = swap16(origin);

    /* we know the maximum file size so we only need one fread */
    uint16_t max_read = MEMORY_MAX - origin;
    uint16_t* p = memory + origin;
    size_t read = fread(p, sizeof(uint16_t), max_read, file);

    /* swap to little endian */
    while (read-- > 0)
    {
        *p = swap16(*p);
        ++p;
    }
}
int read_image(const char* image_path)
{
    FILE* file = fopen(image_path, "rb");
    if (!file) { return 0; };
    read_image_file(file);
    fclose(file);
    return 1;
}





// Input buffering(LINUX ONLY) irrelavant to to the VM
struct termios original_tio;

void disable_input_buffering()
{
    tcgetattr(STDIN_FILENO, &original_tio);
    struct termios new_tio = original_tio;
    new_tio.c_lflag &= ~ICANON & ~ECHO;
    tcsetattr(STDIN_FILENO, TCSANOW, &new_tio);
}

void restore_input_buffering()
{
    tcsetattr(STDIN_FILENO, TCSANOW, &original_tio);
}

uint16_t check_key()
{
    fd_set readfds;
    FD_ZERO(&readfds);
    FD_SET(STDIN_FILENO, &readfds);
    
    struct timeval timeout;
    timeout.tv_sec = 0;
    timeout.tv_usec = 0;
    return select(1, &readfds, NULL, NULL, &timeout) != 0;
}

// Writing to memory mapped registers
void mem_write(uint16_t address, uint16_t val)
{
    memory[address] = val;
}

uint16_t mem_read(uint16_t address)
{
    if (address == MR_KBSR)
    {
        if (check_key())
        {
            memory[MR_KBSR] = (1 << 15);
            memory[MR_KBDR] = getchar();
        }
        else
        {
            memory[MR_KBSR] = 0;
        }
    }
    return memory[address];
}


// Interrupt handler 
void handle_interrupt(int signal)
{
    restore_input_buffering();
    printf("\n");
    exit(-2);
}



int main(int argc,const char* argv[]){
    // setup for buffering
    signal(SIGINT, handle_interrupt);
    disable_input_buffering();


    // Argument parsing
    if (argc < 2)
    {
        /* show usage string */
        printf("lc3 [image-file1] ...\n");
        exit(2);
    }

    for (int j = 1; j < argc; ++j)
    {
        if (!read_image(argv[j]))
        {
            printf("failed to load image: %s\n", argv[j]);
            exit(1);
        }
    }



    /* since exactly one condition flag should be set at any given time, set the Z flag */
    reg[R_COND] = FL_ZRO;

    /* set the PC to starting position */
    /* 0x3000 is the default */
    enum { PC_START = 0x3000 };
    // Hexadecimal of 3000 = 12288 in decimal
    reg[R_PC] = PC_START;

    // main loop
    int running = 1;
    while (running){
        /*
        1.Load the instruction from memmory at the adress of the pc register
        2.Increment the pc register
        */
        uint16_t instr = mem_read(reg[R_PC]++);

        // 3. Look at the opcode to determine which type of instruction it should perform.
        uint16_t op = instr >> 12; /* Since opcode is the bits 15-12 a simple right shift can be performed to get them*/

        switch (op)
        {
        case OP_ADD:
            {
                /* destination register (DR) */
                // selecting the bits 11-9 by first right shifting 9 bits to remove 0-8 and then anding the remaining 15-9 preceeded by zeros with 7 (111) masks the last 3 bits giving us the register number
                uint16_t r0 = (instr >> 9) & 0x7;
                /* first operand (SR1) */
                // similar operation as before to get a 3 bit register number 
                uint16_t r1 = (instr >> 6) & 0x7;
                /* whether we are in immediate mode */
                // Getting the 5th bit to determine mode of operation
                uint16_t imm_flag = (instr >> 5) & 0x1;

                if (imm_flag)
                {
                    // imm=1 imples that the last 5 bits(4-0) is the second number so we get that number and extend the sign
                    uint16_t imm5 = sign_extend(instr & 0x1F, 5);
                    reg[r0] = reg[r1] + imm5;
                }
                else
                {
                    // imm=0 imples the last 3 bits point to the register which contains the second number
                    uint16_t r2 = instr & 0x7;
                    reg[r0] = reg[r1] + reg[r2];
                }


                // Updating flag based on the sign of the destination register 
                update_flags(r0);
            }

            break;
        case OP_AND:
            // AND
            {

                uint16_t dr = (instr>>9) & 0x7;
                uint16_t sr1 = (instr>>6) & 0x7;
                uint16_t imm_flag = (instr>>5) & 0x1;
                if(imm_flag){
                    uint16_t imm5 = sign_extend((instr & 0b11111),5);
                    reg[dr] = reg[sr1] & imm5;
                }
                else
                {
                    uint16_t sr2 = (instr & 0b111);
                    reg[dr] = reg[sr1] & reg[sr2];
                }
                update_flags(dr);

            }
            break;
        case OP_NOT:
            // NOT
            {
                uint16_t dr = (instr>>9) & 0b111;
                uint16_t sr1 = (instr>>6) & 0b111;
                reg[dr] = ~reg[sr1];
                update_flags(dr);
            }
            break;
        case OP_BR:
            // BR
            {
                uint16_t pc_offset = sign_extend(instr & 0b111111111, 9);
                uint16_t cond_flag = (instr >> 9) & 0b111;
                if (cond_flag & reg[R_COND])
                {
                    reg[R_PC] += pc_offset;
                }

            }
            break;
        case OP_JMP:
            // JMP
            {
                uint16_t baseR = (instr>>6 & 0b111);
                reg[R_PC] = reg[baseR];
            }
            break;
        case OP_JSR:
            // JSR
            {
                reg[R_R7] = reg[R_PC];
                uint16_t flag = (instr>>11) & 0b1;
                if (flag)
                {
                    // JSR
                    uint16_t pcOffset11 = instr & 0b11111111111;
                    reg[R_PC] = reg[R_PC]+ sign_extend(pcOffset11,11);

                }
                else
                {
                    // JSRR
                    uint16_t baseR = (instr>>6 & 0b111);
                    reg[R_PC] = reg[baseR];
                }
            }
            break;
        case OP_LD:
            // LD
            {
                uint16_t pcOffset11 = sign_extend(instr & 0b111111111,9);
                uint16_t dr = (instr>>9) & 0b111;
                reg[dr] = mem_read(reg[R_PC]+pcOffset11);
                update_flags(dr);

            }
            break;
        case OP_LDI:
            {
                uint16_t pcOffset11 = sign_extend(instr & 0b111111111,9);
                uint16_t dr = (instr>>9) & 0b111;
                reg[dr] = mem_read(mem_read((reg[R_PC]+pcOffset11)));
                update_flags(dr);
            }
            // LDI
            break;
        case OP_LDR:
            // LDR
            {
                uint16_t offset6 = sign_extend(instr & 0b111111,6);
                uint16_t dr = (instr>>9) & 0b111;
                uint16_t baseR = (instr>>6) & 0b111; 
                reg[dr] = mem_read(reg[baseR]+offset6);
                update_flags(dr);
            }
            break;
        case OP_LEA:
            // LEA
            {
                uint16_t pcOffset9 = sign_extend(instr & 0b111111111,9);
                uint16_t dr = (instr>>9) & 0b111;
                reg[dr] = reg[R_PC]+pcOffset9;
                update_flags(dr);

            }
            break;
        case OP_ST:
            {
                uint16_t sr = (instr>>9) & 0b111;
                uint16_t pcOffset9 = sign_extend(instr & 0b111111111,9);
                mem_write(reg[R_PC]+pcOffset9,reg[sr]);

            }
            break;
        case OP_STI:
            // STI
            {
                uint16_t sr = (instr>>9) & 0b111;
                uint16_t pcOffset9 = sign_extend(instr & 0b111111111,9);
                mem_write(mem_read(reg[R_PC]+pcOffset9),reg[sr]);
                
            }
            break;
        case OP_STR:
            // STR
            {
                uint16_t sr = (instr >> 9) & 0b111;
                uint16_t baseR = (instr >> 6) & 0b111;
                uint16_t offset6 = sign_extend(instr & 0b111111, 6);
                mem_write(reg[baseR] + offset6, reg[sr]);
            }
            break;
        case OP_TRAP:
            // TRAP
            {
                reg[R_R7] = reg[R_PC];
                switch (instr & 0xFF)
                {
                    case TRAP_GETC:
                        {
                            /* read a single ASCII char */
                            reg[R_R0] = (uint16_t)getchar();
                            update_flags(R_R0);
                        }
                        break;
                    case TRAP_OUT:
                        {
                            putc((char)reg[R_R0], stdout);
                            fflush(stdout);
                        }
                        break;
                    case TRAP_PUTS:
                        {
                            /* one char per word */
                            uint16_t* c = memory + reg[R_R0];
                            while (*c)
                            {
                                putc((char)*c, stdout);
                                ++c;
                            }
                            fflush(stdout);
                        }
                        break;
                    case TRAP_IN:
                        {
                            printf("Enter a character: ");
                            char c = getchar();
                            putc(c, stdout);
                            fflush(stdout);
                            reg[R_R0] = (uint16_t)c;
                            update_flags(R_R0);
                        }
            
                        break;
                    case TRAP_PUTSP:
                        {
                            /* one char per byte (two bytes per word)
                            here we need to swap back to
                            big endian format */
                            uint16_t* c = memory + reg[R_R0];
                            while (*c)
                            {
                                char char1 = (*c) & 0xFF;
                                putc(char1, stdout);
                                char char2 = (*c) >> 8;
                                if (char2) putc(char2, stdout);
                                ++c;
                            }
                            fflush(stdout);
                        }

                        
                        break;
                    case TRAP_HALT:
                        {
                            puts("HALT");
                            fflush(stdout);
                            running = 0;
                        }
                        break;
                }
            }
            break;
        case OP_RES:
        case OP_RTI:
        default:
            break;
        }
    }




    // Restoring input buffering(done when program interrupted by user)
    restore_input_buffering();

    
    return 0;
}