Loader.cpp

// ============================================================
// LOADER PROCESSING
// ============================================================
// Purpose: LOADING & EXECUTION PHASE
//          Simulates an OS loader + CPU executing the program.
//          – load()    : place instructions into virtual memory
//          – execute() : fetch-decode-execute loop
// ============================================================

#include "Assembler.h"
#include "Linker.h"
#include "Loader.h"
#include <iostream>
#include <iomanip>
#include <stdexcept>
#include <cmath>    // for numeric operations

// CONSTRUCTOR
Loader::Loader() : pc_(0), running_(false) {}

// LOAD – place linked instructions into virtual memory and set PC
void Loader::load(const std::vector<AsmInstruction>& instructions) {
    memory_ = instructions;
    pc_     = 0;
    running_ = true;
    // Skip runtime stubs and find "main:" entry point
    for (int i = 0; i < (int)memory_.size(); i++) {
        if (memory_[i].opcode == "main:") {
            pc_ = i + 1;  // Start executing after the main: label
            break;
        }
    }
    std::cout << "  [LOADER] Loaded " << memory_.size()
              << " instructions into virtual memory.\n";
    std::cout << "  [LOADER] Program counter set to 0x"
              << std::hex << pc_ << std::dec << "\n";
}

// EVAL – evaluate an operand (register, variable, or literal)
double Loader::eval(const std::string& operand) {
    if (operand.empty()) return 0.0;

    // String literal – return 0 (printing handled separately)
    if (!operand.empty() && operand[0] == '"') return 0.0;

    // Check if it is a known variable
    if (variables_.count(operand)) return variables_[operand];

    // Check if it is a known register
    if (registers_.count(operand)) return registers_[operand];

    // Try to parse as a numeric literal
    try {
        return std::stod(operand);
    } catch (...) {
        return 0.0;   // Unknown operand defaults to 0
    }
}

// STORE – store a value into a register or variable
void Loader::store(const std::string& dest, double val) {
    // Registers start with 'E' or 'R' (e.g. EAX, ECX, R8)
    bool isReg = (!dest.empty() &&
                  (dest[0] == 'E' || dest[0] == 'R' || dest == "AL"));
    if (isReg) {
        registers_[dest] = val;
    } else {
        variables_[dest] = val;   // User variable
    }
}

// STEP – execute one instruction at PC
void Loader::step() {
    if (pc_ >= (int)memory_.size()) {
        running_ = false;
        return;
    }

    const AsmInstruction& instr = memory_[pc_];
    std::string op   = instr.opcode;
    std::string dest = instr.dest;
    std::string src  = instr.src;

    // LABELS: skip them (they are just markers, not executable instructions)
    if (!op.empty() && op.back() == ':') {
        pc_++;
        return;
    }

    // DIRECTIVES: skip them (handled at link time, not runtime)
    if (op == ".section" || op == ".global" || op == "main:") {
        pc_++;
        return;
    }

    // MOV / MOVZX: dest = src (MOVZX treated same for simplicity) 
    if (op == "MOV" || op == "MOVZX") {
        store(dest, eval(src));
        pc_++;
        return;
    }

    // ADD: dest += src 
    if (op == "ADD") {
        store(dest, eval(dest) + eval(src));
        pc_++;
        return;
    }

    // SUB: dest -= src
    if (op == "SUB") {
        store(dest, eval(dest) - eval(src));
        pc_++;
        return;
    }

    // IMUL: dest *= src
    if (op == "IMUL") {
        store(dest, eval(dest) * eval(src));
        pc_++;
        return;
    }

    // IDIV: dest = floor(dest / src) with division by zero check
    if (op == "IDIV") {
        double divisor = eval(dest);
        if (divisor == 0) throw std::runtime_error("Division by zero");
        store("EAX", std::floor(eval("EAX") / divisor));
        pc_++;
        return;
    }

    // CMP: set FLAGS = dest - src (for conditional jumps)
    if (op == "CMP") {
        registers_["FLAGS"] = eval(dest) - eval(src);
        pc_++;
        return;
    }

    // SETcc: set AL = 1 if condition met, else 0 (using FLAGS from CMP)
    if (op == "SETE")  { store("AL", registers_["FLAGS"] == 0 ? 1 : 0); pc_++; return; }
    if (op == "SETNE") { store("AL", registers_["FLAGS"] != 0 ? 1 : 0); pc_++; return; }
    if (op == "SETL")  { store("AL", registers_["FLAGS"] <  0 ? 1 : 0); pc_++; return; }
    if (op == "SETG")  { store("AL", registers_["FLAGS"] >  0 ? 1 : 0); pc_++; return; }
    if (op == "SETLE") { store("AL", registers_["FLAGS"] <= 0 ? 1 : 0); pc_++; return; }
    if (op == "SETGE") { store("AL", registers_["FLAGS"] >= 0 ? 1 : 0); pc_++; return; }

    // JMP: unconditional jump to label
    if (op == "JMP") {
        // Search memory for the label
        for (int i = 0; i < (int)memory_.size(); i++) {
            if (memory_[i].opcode == dest + ":") {
                pc_ = i + 1;   // Land on instruction after label
                return;
            }
        }
        pc_++;   // Label not found (shouldn't happen)
        return;
    }

    // JE: jump if equal (FLAGS == 0)
    if (op == "JE") {
        if (registers_["FLAGS"] == 0) {
            for (int i = 0; i < (int)memory_.size(); i++) {
                if (memory_[i].opcode == dest + ":") {
                    pc_ = i + 1;
                    return;
                }
            }
        }
        pc_++;
        return;
    }

    // CALL print_val: special case to handle our print_val runtime stub
    if (op == "CALL" && dest == "print_val") {
        // EAX holds the value to print (set by MOV EAX, <val>)
        // We also look back at the last MOV to find the original name
        double val = eval("EAX");
        std::cout << "  >>> OUTPUT: " << val << "\n";
        pc_++;
        return;
    }

    // PRINT: print the value of dest (can be a variable, register, or string literal)
    if (op == "PRINT") {
        double val = eval(dest);   // dest holds the operand for PRINT
        // If dest is a string literal, print the string
        if (!dest.empty() && dest[0] == '"') {
            std::cout << "  >>> OUTPUT: " << dest.substr(1, dest.size()-2) << "\n";
        } else {
            std::cout << "  >>> OUTPUT: " << val << "\n";
        }
        pc_++;
        return;
    }

    // RETURN: end of main function, stop execution
    if (op == "RET" || op == "RETURN") {
        running_ = false;   // Simplified: return from main = exit
        pc_++;
        return;
    }

    // PUSH/POP/CDQ/INT/CALL: for simplicity, we treat these as no-ops in this simulation
    if (op == "PUSH" || op == "POP" || op == "CDQ" ||
        op == "INT"  || op == "CALL") {
        pc_++;  // Simulate as no-op for our purposes
        return;
    }

    // HALT: stop execution immediately
    if (op == "HALT" || op == "INT") {
        running_ = false;
        return;
    }

    // UNKNOWN OPCODE: print a warning and skip
    std::cout << "  [LOADER] Warning: unknown opcode '" << op << "' at 0x"
              << std::hex << pc_ << std::dec << " - skipping\n";
    pc_++;
}

// EXECUTE – run the fetch-decode-execute loop until program halts or step limit reached
void Loader::execute() {
    std::cout << "  [LOADER] Starting execution...\n\n";

    int steps = 0;
    const int MAX_STEPS = 100000;   // Guard against infinite loops

    while (running_ && steps < MAX_STEPS) {
        step();
        steps++;
    }

    if (steps >= MAX_STEPS) {
        std::cout << "  [LOADER] Execution halted: step limit reached.\n";
    } else {
        std::cout << "\n  [LOADER] Execution complete after "
                  << steps << " steps.\n";
    }
}

// PRINT MEMORY MAP – show the first 20 instructions in virtual memory
void Loader::printMemoryMap() const {
    std::cout << "\n  Virtual Memory Map (first 20 entries):\n";
    std::cout << "  +----------+----------------------------------+\n";
    std::cout << "  | Address  | Instruction                      |\n";
    std::cout << "  +----------+----------------------------------+\n";
    int limit = std::min((int)memory_.size(), 20);
    for (int i = 0; i < limit; i++) {
        std::cout << "  | 0x" << std::hex << std::setw(4) << std::setfill('0') << i
                  << std::dec << std::setfill(' ')
                  << "   | " << std::setw(32) << std::left
                  << memory_[i].toString().substr(0, 32) << " |\n";
    }
    if ((int)memory_.size() > 20)
        std::cout << "  |  ...     | (" << memory_.size()-20 << " more)               |\n";
    std::cout << "  +----------+----------------------------------+\n\n";
}