main.cc

一个mips虚拟机非常好代码,使用C++来编写的,希望大家多学学,

#include <stdlib.h>
#include <string.h>
#include <serial.hh>
#include <sulima.hh>
#include "bus.hh"


// Serialization information.

SerialType<MIPS64SimpleBus> MIPS64SimpleBus::type(
    "MIPS64SimpleBus",
    "A minimal MIPS64 memory and I/O controller."
);


// Runtime constructor.

MIPS64SimpleBus::MIPS64SimpleBus(const SimArgs &args)
    : MIPS64Bus(args), ram(0), file_name(0)
{
    define("fileName", conf.file_name);
    define("memory",   conf.memory, 0);
    define("cpu", conf.cpu, "cpu");
    define("cs0", conf.cs0);
    define("cs1", conf.cs1);
    define("cs2", conf.cs2);
    define("cs3", conf.cs3);
    define("bootcs", conf.bootcs);
    define("cs1a", conf.cs1a);
    define("cs1b", conf.cs1b);
    define("cs1c", conf.cs1c);
    define("cs1d", conf.cs1d);
    define("pciintctrl", conf.pciintctrl);
    for (int i = 0; i < 8; i++) {
	char name[] = "pciX"; name[3] = '0' + i;
	define(name, conf.pci[i]);
    }
    for (int i = 0; i < 4; i++)
	timer[i] = new Timer(this, i);
}


// Serialized constructor.

MIPS64SimpleBus::MIPS64SimpleBus(Checkpoint &cp)
    : MIPS64Bus(cp), ram(0), file_name(0)
{
}


// Checkpointing interface.

void
MIPS64SimpleBus::checkpoint(Checkpoint &cp, bool parent) const
{
}

// Destructor.

MIPS64SimpleBus::~MIPS64SimpleBus()
{
    delete file_name;
    delete ram;
}


// Module interface.

Device *
MIPS64SimpleBus::find_device(char *devname)
{
    Device *device;

    if ((devname == NULL) || (strlen(devname) == 0))
	return NULL;

    device = dynamic_cast<Device*>(find_module(devname));
    if (!device)
	throw Error("%#s: \"%#s\" is not a device module.", name(), devname);

    device->bus = this;
    device->intctrl = clock;
    return device;
}

void
MIPS64SimpleBus::reset(bool warm)
{
    if (!warm) {
	memory_size = conf.memory * MB;
	ram = new UInt64[memory_size / 8];
	bzero(ram, memory_size);
	delete file_name;
	file_name = copy(conf.file_name);

	clock = dynamic_cast<CPU *>(find_module(conf.cpu));
	if (!clock)
	    throw Error("%#s: \"%#s\" is not an CPU module.", name(), conf.cpu);

	decode[0] = decode[1] = find_device(conf.cs0);
	decode[2] = decode[3] = find_device(conf.cs1);
	decode[4] = decode[5] = decode[6] = decode[7] = find_device(conf.cs2);
	decode[8] = decode[9] = decode[10] = decode[11] = NULL;
	decode[12] = decode[13] = decode[14] = find_device(conf.cs3);
	decode[15] = find_device(conf.bootcs);

	cs1_subdecode[0] = find_device(conf.cs1a);
	cs1_subdecode[1] = find_device(conf.cs1b);
	cs1_subdecode[2] = find_device(conf.cs1c);
	cs1_subdecode[3] = find_device(conf.cs1d);

	InterruptSink *pciintctrl;
	if ((conf.pciintctrl != NULL) && (strlen(conf.pciintctrl) > 0)) {
	    pciintctrl = dynamic_cast<InterruptSink*>(find_module(conf.pciintctrl));
	    if (!pciintctrl)
		throw Error("%#s: \"%#s\" is not an interrupt sink module.",
			    name(), conf.pciintctrl);
	} else {
	    pciintctrl = clock;
	}

	for (int i = 0; i < 8; ++i) {
	    if ((conf.pci[i] != NULL) && (strlen(conf.pci[i]) > 0)) {
		pcidev[i] = dynamic_cast<PCIDevice*>(find_module(conf.pci[i]));
		if (!pcidev[i])
		    throw Error("%#s: \"%#s\" is not a PCI device module.",
				name(), conf.pci[i]);
		pcidev[i]->init(this, pciintctrl, 0x10000000 + 0x400000 * (i-1), 0x400000, 4*(i-1));
	    } else {
		pcidev[i] = NULL;
	    }
	}

	intr_pending = intr_mask = timer_control = 0;
    }
}

void
MIPS64SimpleBus::check_interrupts()
{
    if (intr_pending & intr_mask)
	clock->deliver_interrupt(3);
    else
	clock->clear_interrupt(3);
}

void
MIPS64SimpleBus::timer_interrupt(unsigned int timer_id)
{
    msg("Timer %d fires (%lx)", timer_id, clock->now);
    intr_pending |= 1 << (8 + timer_id);
    check_interrupts();
}

void
MIPS64SimpleBus::Timer::invoke(void)
{
    if (!is_timer)
	running = false;
    bus->timer_interrupt(timer_id);
}

UInt32
MIPS64SimpleBus::Timer::read()
{
    if (!running)
	return 0;

    return (when - bus->clock->now) / TIMER_CLOCKS_PER_TICK;
}

void
MIPS64SimpleBus::Timer::write(UInt32 value)
{
    assert(!running);
    start_value = value;
}

void
MIPS64SimpleBus::Timer::control(bool enable, bool timer)
{
    is_timer = timer;
    if (enable && !running)
    {
	when = bus->clock->now + (start_value * TIMER_CLOCKS_PER_TICK);
	interval = is_timer ? (start_value * TIMER_CLOCKS_PER_TICK) : 0;
	bus->clock->insert(this);
	running = true;
    }
    else if (!enable && running)
    {
	bus->clock->remove(this);
	running = false;
    }
}