/*
Copyright (C) 1998-2003 T. Scott Dattalo
This file is part of gpsim.
gpsim is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
gpsim is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with gpsim; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#ifndef __PROCESSOR_H__
#define __PROCESSOR_H__
#include <glib.h>
#include <vector>
#include <list>
#include <map>
#include "gpsim_classes.h"
#include "modules.h"
#include "trace.h"
#include "registers.h"
#include "gpsim_time.h"
#include "gpsim_interface.h"
class Processor;
class ProcessorConstructor;
class ProgramFileType;
class FileContext;
class FileContextList;
class ProgramMemoryCollection;
//---------------------------------------------------------
/// MemoryAccess - A base class designed to support
/// access to memory. For the PIC, this class is extended by
/// the ProgramMemoryAccess and RegisterMemoryAccess classes.
class MemoryAccess : public TriggerObject, public gpsimObject
{
public:
MemoryAccess(Processor *new_cpu);
virtual Processor *get_cpu(void);
virtual void set_cpu(Processor *p);
list<Register *> SpecialRegisters;
protected:
Processor *cpu; /// The processor to which this object belongs
};
//---------------------------------------------------------
/// The ProgramMemoryAccess class is the interface used
/// by objects other than the simulator to manipulate the
/// pic's program memory. For example, the breakpoint class
/// modifies program memory when break points are set or
/// cleared. The modification goes through here.
class ProgramMemoryAccess : public MemoryAccess
{
public:
/// Symbolic debugging
enum HLL_MODES {
ASM_MODE, // Source came from plain old .asm files
HLL_MODE // Source came from a high level language like C or JAL.
};
ProgramMemoryAccess(Processor *new_cpu=0);
virtual void putToAddress(unsigned int addr, instruction *new_instruction);
virtual void putToIndex(unsigned int uIndex, instruction *new_instruction);
instruction *getFromAddress(unsigned int addr);
instruction *getFromIndex(unsigned int uIndex);
instruction *get_base_instruction(unsigned int addr);
unsigned int get_opcode(unsigned int addr);
unsigned int get_rom(unsigned int addr);
void put_rom(unsigned int addr,unsigned int value);
char *get_opcode_name(unsigned int addr, char *buffer, unsigned int size);
virtual unsigned int get_PC(void);
virtual void set_PC(unsigned int);
virtual Program_Counter *GetProgramCounter(void);
void remove(unsigned int address, instruction *bp_instruction);
void put_opcode(unsigned int addr, unsigned int new_opcode);
// When a pic is replacing one of it's own instructions, this routine
// is called.
void put_opcode_start(unsigned int addr, unsigned int new_opcode);
// Assign a cross reference object to an instruction
void assign_xref(unsigned int address, gpointer cross_reference);
virtual void callback(void);
void init(Processor *);
// Helper functions for querying the program memory
// hasValid_opcode -- returns true if the opcode at the address is valid
bool hasValid_opcode_at_address(unsigned int address);
bool hasValid_opcode_at_index(unsigned int uIndex);
// step - step one of more instructions
virtual void step(unsigned int steps, bool refresh=true);
virtual void step_over(bool refresh=true);
virtual void run(bool refresh=true);
virtual void stop(void);
virtual void finish(void);
// isModified -- returns true if the program at the address has been modified
// (this is only valid for those processor capable of writing to their own
// program memory)
bool isModified(unsigned int address);
// Given a file and a line in that file, find the instrucion in the
// processor's memory that's closest to it.
virtual int find_closest_address_to_line(int file_id, int src_line);
virtual int find_address_from_line(FileContext *fc, int src_line);
//virtual int find_closest_address_to_hll_line(int file_id, int src_line);
// Given an address to an instruction, find the source line that
// created it:
unsigned int get_src_line(unsigned int address);
// Return the file ID of the source program responsible for the opcode at address.
unsigned int get_file_id(unsigned int address);
// A couple of functions for manipulating breakpoints
virtual unsigned int set_break_at_address(unsigned int address);
virtual unsigned int set_notify_at_address(unsigned int address,
TriggerObject *cb);
virtual unsigned int set_profile_start_at_address(unsigned int address,
TriggerObject *cb);
virtual unsigned int set_profile_stop_at_address(unsigned int address,
TriggerObject *cb);
virtual int clear_break_at_address(unsigned int address,
enum instruction::INSTRUCTION_TYPES type);
virtual int clear_break_at_address(unsigned int address,
instruction * pInstruction);
virtual int clear_notify_at_address(unsigned int address);
virtual int clear_profile_start_at_address(unsigned int address);
virtual int clear_profile_stop_at_address(unsigned int address);
virtual int address_has_break(unsigned int address,
enum instruction::INSTRUCTION_TYPES type=instruction::BREAKPOINT_INSTRUCTION);
virtual int address_has_notify(unsigned int address);
virtual int address_has_profile_start(unsigned int address);
virtual int address_has_profile_stop(unsigned int address);
virtual instruction *find_instruction(unsigned int address,
enum instruction::INSTRUCTION_TYPES type);
virtual void toggle_break_at_address(unsigned int address);
virtual void set_break_at_line(unsigned int file_id, unsigned int src_line);
virtual void clear_break_at_line(unsigned int file_id,
unsigned int src_line);
virtual void toggle_break_at_line(unsigned int file_id,
unsigned int src_line);
void set_hll_mode(unsigned int);
enum HLL_MODES get_hll_mode(void) { return hll_mode;}
bool isHLLmode(void) {return get_hll_mode() == HLL_MODE;}
private:
ProgramMemoryCollection *m_pRomCollection;
unsigned int
_address,
_opcode,
_state;
enum HLL_MODES hll_mode;
// breakpoint instruction pointer. This is used by get_base_instruction().
// If an instruction has a breakpoint set on it, then get_base_instruction
// will return a pointer to the instruction and will initialize bpi to
// the breakpoint instruction that has replaced the one in the processor's
// program memory.
Breakpoint_Instruction *bpi;
};
//---------------------------------------------------------
/// The RegisterMemoryAccess class is the interface used
/// by objects other than the simulator to manipulate the
/// cpu's register memory.
class RegisterMemoryAccess : public MemoryAccess
{
public:
RegisterMemoryAccess(Processor *new_cpu=0);
virtual ~RegisterMemoryAccess();
virtual Register *get_register(unsigned int address);
unsigned int get_size(void) { return nRegisters; }
void set_Registers(Register **_registers, int _nRegisters);
// The insertRegister and removeRegister methods are used primarily
// to set and clear breakpoints.
bool insertRegister(int address, Register *);
bool removeRegister(int address, Register *);
bool hasBreak(unsigned int address);
Register &operator [] (unsigned int address);
private:
unsigned int nRegisters;
bool initialized;
Register **registers; // Pointer to the array of registers.
//
};
//------------------------------------------------------------------------
//
/// FileContext - Maintain state information about files.
/// The state of each source file for a processor is recorded in the
/// FileContext class. Clients can query information like the name
/// of the source file or the line number responsible for generating
/// a specific instruction.
class FileContext
{
private:
string name_str; // File name
FILE *fptr; // File ptr when the file is opened
vector<int> *line_seek; // A vector of file offsets to the start of lines
vector<int> *pm_address; // A vector of program memory addresses for lines
unsigned int m_uiMaxLine; // number of lines in the file
friend class FileContextList;
protected:
bool m_bIsList; // True if this is a list file.
void setListId(bool b)
{
m_bIsList = b;
}
public:
// cache -- deprecated - this was used with the old gui source browser
typedef vector<gpsimObject*> Cache;
Cache m_cache;
FileContext(string &new_name);
FileContext(const char *new_name);
~FileContext();
void ReadSource();
char *ReadLine(unsigned int line_number, char *buf, unsigned int nBytes);
char *gets(char *buf, unsigned int nBytes);
void rewind(void);
void open(const char *mode);
void close();
bool IsOpen() { return fptr != NULL; }
bool IsList() { return m_bIsList; }
/// get_address - given a line number, return the program memory address
int get_address(unsigned int line);
/// put_address - associate a line number with a program memory address.
void put_address(unsigned int line, unsigned int address);
string &name(void)
{
return name_str;
}
unsigned int max_line();
};
//------------------------------------------------------------------------
//
// FileContextList - a vector of FileContext objects.
//
//
class FileContextList : private vector<FileContext>
{
public:
#ifndef _MSC_VER
typedef vector<FileContext> _Myt;
#endif
FileContextList();
~FileContextList();
int Add(string& new_name);
int Add(const char *new_name);
int Find(string &fname);
FileContext *operator [] (int file_number);
void list_id(int new_list_id);
int list_id()
{
return list_file_id;
}
int nsrc_files(void)
{
return (int) size();
}
char *ReadLine(int file_id, int line_number, char *buf, int nBytes);
char *gets(int file_id, char *buf, int nBytes);
void rewind(int file_id);
void SetSourcePath(const char *pPath);
private:
string sSourcePath;
int lastFile;
int list_file_id;
};
//------------------------------------------------------------------------
//
/// Processor - a generic base class for processors supported by gpsim
class Processor : public Module
{
public:
typedef bool (*LPFNISPROGRAMFILE)(const char *, FILE *);
/// Load the source code for this processor. The pProcessorName
/// is an optional name that a user can assign to the processor.
virtual bool LoadProgramFile(const char *hex_file,
FILE *pFile,
const char *pProcessorName) = 0;
/// The source files for this processor.
FileContextList files;
/// Oscillator cycles for 1 instruction
unsigned int clocks_per_inst;
/// Supply voltage
double Vdd;
/// Processor capabilities
unsigned long m_Capabilities;
enum {
eSTACK = 0x00000001,
eWATCHDOGTIMER = 0x00000002,
eBREAKONSTACKOVER = 0x00000004,
eBREAKONSTACKUNDER = 0x00000009,
eBREAKONWATCHDOGTIMER = 0x00000010,
};
unsigned long GetCapabilities();
/// Processor RAM
Register **registers;
RegisterCollection *m_UiAccessOfRegisters; // should this be in rma class?
/// Currently selected RAM bank
Register **register_bank;
/// Program memory - where instructions are stored.
instruction **program_memory;
/// Program memory interface
ProgramMemoryAccess *pma;
virtual ProgramMemoryAccess * createProgramMemoryAccess(Processor *processor);
virtual void destroyProgramMemoryAccess(ProgramMemoryAccess *pma);
virtual instruction * ConstructInvalidInstruction(Processor *processor,
unsigned int address, unsigned int new_opcode) {
return new invalid_instruction(processor,address,new_opcode); }
/// register memory interface
RegisterMemoryAccess rma;
/// eeprom memory interface (if present).
RegisterMemoryAccess ema;
unsigned int m_uPageMask;
unsigned int m_uAddrMask;
/// Program Counter
Program_Counter *pc;
/// Context debugging is a way of debugging the processor while it is
/// in different states. For example, when the interrupt flag is set
/// (for those processors that support interrupts), the processor is
/// in a different 'state' then when the interrupt flag is cleared.
list<ProgramMemoryAccess *> pma_context;
/// Tracing
/// The readTT and writeTT are TraceType objects for tracing
/// register reads and writes.
/// The mTrace map is a collection of special trace types that
/// share the same trace function code. For example, interrupts
/// and resets are special trace events that don't warrant thier
/// own trace function code.
TraceType *readTT, *writeTT;
map <unsigned int, TraceType *> mTrace;
virtual void set(const char *cP,int len=0);
virtual void get(char *, int len);
//
// Creation and manipulation of registers
//
void create_invalid_registers (void);
void add_file_registers(unsigned int start_address,
unsigned int end_address,
unsigned int alias_offset);
void delete_file_registers(unsigned int start_address,
unsigned int end_address);
void alias_file_registers(unsigned int start_address,
unsigned int end_address,
unsigned int alias_offset);
virtual int map_rm_address2index(int address) {return address;};
virtual int map_rm_index2address(int index) {return index;};
virtual void init_register_memory(unsigned int memory_size);
virtual unsigned int register_memory_size () const = 0;
virtual unsigned int CalcJumpAbsoluteAddress(unsigned int uInstAddr,
unsigned int uDestAddr) { return uDestAddr; }
virtual unsigned int CalcCallAbsoluteAddress(unsigned int uInstAddr,
unsigned int uDestAddr) { return uDestAddr; }
//
// Creation and manipulation of Program Memory
//
virtual void init_program_memory(unsigned int memory_size);
virtual void init_program_memory(unsigned int address, unsigned int value);
virtual void init_program_memory_at_index(unsigned int address,
unsigned int value);
virtual void init_program_memory_at_index(unsigned int address,
const unsigned char *, int nBytes);
virtual unsigned int program_memory_size(void) const {return 0;};
virtual unsigned int get_program_memory_at_address(unsigned int address);
void build_program_memory(unsigned int *memory,
unsigned int minaddr,
unsigned int maxaddr);
virtual int map_pm_address2index(int address) {return address;};
virtual int map_pm_index2address(int index) {return index;};
virtual void set_out_of_range_pm(unsigned int address, unsigned int value);
guint64 cycles_used(unsigned int address);
virtual bool IsAddressInRange(unsigned int address) {
return address < program_memory_size();
}
// opcode_size - number of bytes for an opcode.
virtual int opcode_size() { return 2;}
//
// Symbolic debugging
//
// First the source files:
void attach_src_line(unsigned int address,
unsigned int file_id,
unsigned int sline,
unsigned int lst_line);
void read_src_files(void);
virtual void dump_registers(void);
virtual instruction * disasm ( unsigned int address,unsigned int inst)=0;
virtual void initializeAttributes();
//
// Processor State
//
// copy the entire processor state to a file
virtual void save_state(FILE *);
// take an internal snap shot of the current state.
virtual void save_state();
// restore the processor state
virtual void load_state(FILE *);
//
// Execution control
//
virtual void run(bool refresh=true);
virtual void run_to_address(unsigned int destination);
virtual void finish(void);
virtual void sleep(void) {};
virtual void step(unsigned int steps,bool refresh=true);
virtual void step_over(bool refresh=true);
virtual void step_one(bool refresh=true) = 0;
virtual void interrupt(void) = 0 ;
// Simulation modes
/// setWarnMode - when true, gpsim will issue warnings whenever
/// suspicious is occuring.
virtual void setWarnMode(bool);
virtual bool getWarnMode() { return bWarnMode; }
/// setSafeMode - when true, model will model the 'official'
/// behavior of the chip. When false, the simulator behaves the same
/// as the hardware.
virtual void setSafeMode(bool);
virtual bool getSafeMode() { return bSafeMode; }
/// setUnknownMode - when true, gpsim will implement three-state logic
/// for data. When false, unkown data are treated as zeros.
virtual void setUnknownMode(bool);
virtual bool getUnknownMode() { return bUnknownMode; }
/// setBreakOnReset - when true, gpsim will implement three-state logic
/// for data. When false, unkown data are treated as zeros.
virtual void setBreakOnReset(bool);
virtual bool getBreakOnReset() { return bBreakOnReset; }
bool getBreakOnInvalidRegisterRead() { return *m_pbBreakOnInvalidRegisterRead; }
bool getBreakOnInvalidRegisterWrite() { return *m_pbBreakOnInvalidRegisterWrite; }
///
/// Notification of breakpoint set
virtual void NotifyBreakpointSet(Breakpoints::BreakStatus &bs, TriggerObject *bpo) { }
virtual void NotifyBreakpointCleared(Breakpoints::BreakStatus &bs, TriggerObject *bpo) { }
// Tracing control
virtual void trace_dump(int type, int amount);
virtual int trace_dump1(int type, char *buffer, int bufsize);
virtual RegisterValue getWriteTT(unsigned int addr);
virtual RegisterValue getReadTT(unsigned int addr);
//
// Processor Clock control
//
void set_frequency(double f);
virtual double get_frequency();
void set_ClockCycles_per_Instruction(unsigned int cpi)
{ clocks_per_inst = cpi; }
unsigned int get_ClockCycles_per_Instruction(void)
{
return clocks_per_inst;
}
virtual double get_OSCperiod();
virtual double get_InstPeriod()
{
return get_OSCperiod() * get_ClockCycles_per_Instruction();
}
virtual void disassemble (signed int start_address,
signed int end_address);
virtual void list(unsigned int file_id,
unsigned int pcval,
int start_line,
int end_line);
// Configuration control
virtual bool set_config_word(unsigned int address, unsigned int cfg_word)
{return false;} // fixme - make this a pure virtual function...
virtual unsigned int get_config_word(unsigned int address) = 0;
virtual unsigned int config_word_address(void) {return 0;}
//
// Processor reset
//
virtual void reset(RESET_TYPE r) {};
virtual void por(void) = 0; // por = Power On Reset
virtual double get_Vdd() { return Vdd; }
virtual void set_Vdd(double v) { Vdd = v; }
//
// Debugging - used to view the state of the processor (or whatever).
//
virtual void Debug();
//
// FIXME -- create -- a way of constructing a processor (why not use constructors?)
//
virtual void create(void);
static Processor *construct(void);
ProcessorConstructor *m_pConstructorObject;
Processor(const char *_name=0, const char *desc=0);
virtual ~Processor();
private:
Float *mFrequency;
// Simulation modes
bool bSafeMode;
bool bWarnMode;
bool bUnknownMode;
bool bBreakOnReset;
Boolean *m_pbBreakOnInvalidRegisterRead;
Boolean *m_pbBreakOnInvalidRegisterWrite;
};
//-------------------------------------------------------------------
//
// ProcessorConstructor -- a class to handle all of gpsim's supported
// processors
//
// gpsim supports dozens of processors. All of these processors are
// grouped together in the ProcessConstructor class. Within the class
// is a static STL list<> object that holds an instance of a
// ProcessorConstructor for each gpsim supported processor. Whenever
// the user selects a processor to simulate, the find() member
// function will search through the list and find the one that matches
// the user supplied ASCII string.
//
// Why have this class?
// The idea behind this class is that a ProcessorConstructor object
// can be instantiated for each processor and that instantiation will
// place the object into list of processors. Prior to gpsim-0.21, a
// giant array held the list of all available processors. However,
// there were two problems with this: it was painful to look at and
// it precluded processors that were defined outside of the gpsim
// core library.
class ProcessorConstructorList;
class ProcessorConstructor
{
public:
typedef Processor * (*tCpuContructor) (const char *_name);
protected:
// A pointer to a function that when called will construct a processor
tCpuContructor cpu_constructor;
public:
virtual Processor * ConstructProcessor(const char *opt_name=0);
// The processor name (plus upto three aliases).
#define nProcessorNames 4
const char *names[nProcessorNames];
//------------------------------------------------------------
// contructor --
//
ProcessorConstructor(
tCpuContructor _cpu_constructor,
const char *name1,
const char *name2,
const char *name3=0,
const char *name4=0);
static ProcessorConstructorList * processor_list;
static ProcessorConstructorList * GetList();
};
// THE list of all of gpsim's processors:
class ProcessorConstructorList : public list <ProcessorConstructor *> {
public:
ProcessorConstructorList() {}
static ProcessorConstructor * findByType(const char *type);
static string DisplayString(void);
static ProcessorConstructorList *GetList();
private:
static ProcessorConstructorList *processor_list;
};
//----------------------------------------------------------
// Global definitions:
#if defined(IN_MODULE) && defined(_WIN32)
// we are in a module: don't access active_cpu object directly!
LIBGPSIM_EXPORT Processor * get_active_cpu(void);
#else
// we are in gpsim: use of get_active_cpu() and set_active_cpu() is recommended,
// even if active_cpu object can be accessed directly.
extern Processor *active_cpu;
inline Processor *get_active_cpu(void)
{
return active_cpu;
}
inline void set_active_cpu(Processor *act_cpu)
{
active_cpu = act_cpu;
}
#endif
#endif
