IA86/ia86.h

446 lines
12 KiB
C
Raw Normal View History

using namespace std;
using std::cout; using std::endl;
using std::vector; using std::string;
using FKey = finalcut::FKey;
using finalcut::FColor;
using finalcut::FPoint;
using finalcut::FRect;
using finalcut::FSize;
//----------------------------------------------------------------------
// Types & classes mineures
//----------------------------------------------------------------------
typedef union {
struct {
union {
uint8_t l;
uint8_t byte;
};
uint8_t h;
} __attribute__ (( packed ));
uint16_t word;
} __attribute__ (( packed )) reg16_t;
typedef union {
struct {
union {
uint8_t l;
uint8_t byte;
};
uint8_t h;
} __attribute__ (( packed ));
uint16_t word;
uint32_t dword;
} __attribute__ (( packed )) reg32_t;
struct i386_regs {
union {
uint16_t ip;
uint32_t eip;
};
union {
uint16_t di;
uint32_t edi;
};
union {
uint16_t si;
uint32_t esi;
};
union {
uint16_t bp;
uint32_t ebp;
};
union {
uint16_t sp;
uint32_t esp;
};
union {
struct {
uint8_t bl;
uint8_t bh;
} __attribute__ (( packed ));
uint16_t bx;
uint32_t ebx;
};
union {
struct {
uint8_t dl;
uint8_t dh;
} __attribute__ (( packed ));
uint16_t dx;
uint32_t edx;
};
union {
struct {
uint8_t cl;
uint8_t ch;
} __attribute__ (( packed ));
uint16_t cx;
uint32_t ecx;
};
union {
struct {
uint8_t al;
uint8_t ah;
} __attribute__ (( packed ));
uint16_t ax;
uint32_t eax;
};
} __attribute__ (( packed ));
struct i386_segs
{
uint16_t cs;
uint16_t ss;
uint16_t ds;
uint16_t es;
uint16_t fs;
uint16_t gs;
} __attribute__ (( packed ));
struct i386_all_regs
{
struct i386_segs segs;
struct i386_regs regs;
uint32_t flags;
} __attribute__ (( packed ));
struct State {
i386_all_regs dump;
std::string code;
};
struct Level {
std::string title;
std::string description;
std::string tutorial;
std::string code;
int rights;
State init;
State goal;
};
struct Scenario {
std::string title;
std::vector<Level> levels;
bool loaded;
};
struct Code
{
uint32_t address;
size_t size;
2021-07-16 13:14:48 +02:00
std::string name;
uint8_t *content;
bool assembled;
2021-07-09 00:51:05 +02:00
bool loaded;
std::string src;
};
struct Unasm
{
std::vector<std::array<std::string, 4>> src;
std::vector<uint32_t> pos;
};
class Error: public exception
{
public:
Error(string const& phrase="") throw()
:m_phrase(phrase)
{}
virtual const char* what() const throw()
{
return m_phrase.c_str();
}
virtual ~Error() throw()
{}
private:
string m_phrase;
};
class ScenarioWindow final : public finalcut::FDialog
{
public:
// Constructor
explicit ScenarioWindow (finalcut::FWidget* = nullptr);
// Disable copy constructor
ScenarioWindow (const ScenarioWindow&) = delete;
// Destructor
~ScenarioWindow() override = default;
// Disable copy assignment operator (=)
ScenarioWindow& operator = (const ScenarioWindow&) = delete;
// Method
void Load(std::vector<Level> items);
private:
// Method
void click();
void initLayout() override;
void adjustSize() override;
// Data members
finalcut::FListView listview{this};
};
class InstructionWindow final : public finalcut::FDialog
{
public:
// Constructor
explicit InstructionWindow (finalcut::FWidget* = nullptr);
// Disable copy constructor
InstructionWindow (const InstructionWindow&) = delete;
// Destructor
~InstructionWindow() override = default;
// Disable copy assignment operator (=)
InstructionWindow& operator = (const InstructionWindow&) = delete;
// Method
std::vector<std::array<std::string, 4>> get();
void set(std::vector<std::array<std::string, 4>> src);
void clear();
int getindex();
void setmultimark(std::vector<int> mark);
void setmark(int index);
int getsize();
std::string getaddress();
private:
// Method
std::vector<std::array<std::string, 4>> content;
void initLayout() override;
void adjustSize() override;
// Data members
2021-07-07 09:02:33 +02:00
finalcut::FListView listview{this};
};
class TextEditWindow final : public finalcut::FDialog
{
public:
// Constructor
explicit TextEditWindow (finalcut::FWidget* = nullptr);
// Disable copy constructor
TextEditWindow (const TextEditWindow&) = delete;
// Destructor
~TextEditWindow() override = default;
// Disable copy assignment operator (=)
TextEditWindow& operator = (const TextEditWindow&) = delete;
// Method
void append(const finalcut::FString&);
void clear();
std::string get();
void set(const finalcut::FString&);
private:
// Method
void onClose(finalcut::FCloseEvent*) override;
void initLayout() override;
void adjustSize() override;
// Data members
finalcut::FTextView scrolltext{this};
};
class TextWindow final : public finalcut::FDialog
{
public:
// Constructor
explicit TextWindow (finalcut::FWidget* = nullptr);
// Disable copy constructor
TextWindow (const TextWindow&) = delete;
// Destructor
~TextWindow() override = default;
// Disable copy assignment operator (=)
TextWindow& operator = (const TextWindow&) = delete;
// Method
void append(const finalcut::FString&);
void clear();
std::string get();
void set(const finalcut::FString&);
private:
// Method
void onClose(finalcut::FCloseEvent*) override;
void initLayout() override;
void adjustSize() override;
// Data members
finalcut::FTextView scrolltext{this};
};
class Menu;
class Desassembler
{
public:
Desassembler(Menu *widget);
void setSyntax(int syntax);
void Desassemble(uint8_t *content, uint32_t address,uint32_t size, Unasm *unasm);
private:
csh handle;
cs_insn *insn;
int err;
Menu *widget;
TextEditWindow *edit;
size_t srcsize;
size_t codesize;
std::vector<std::array<std::string, 4>> src;
unsigned char *src_char = new unsigned char[64*1024];
};
class Assembler
{
public:
Assembler(Menu *widget);
void setSyntax(int syntax);
void Assemble(Code *code);
2021-07-09 00:51:05 +02:00
std::vector<Code> MultiAssemble(std::string source,uint32_t address);
private:
ks_engine *ks;
ks_err err;
int err2;
Menu *widget;
TextEditWindow *edit;
};
class VMEngine
{
public:
VMEngine(Menu *widget);
void Configure(State *init, std::string code);
2021-07-09 00:51:05 +02:00
void Halt();
void Unconfigure();
uint32_t getCurrent();
void setSyntax(int asmsyntax,int unasmsyntax);
void Run(bool astep, bool acall, uint64_t timeout);
std::string getFlags();
std::string getRegs();
std::string getStack();
std::vector<std::array<std::string, 4>> getInstr(int segment, int address,int size);
2021-07-16 13:14:48 +02:00
std::vector<std::array<std::string, 7>> getCode();
2021-07-09 00:51:05 +02:00
void SetMem(Code *code);
void SetRegs(State *init);
2021-07-11 18:20:28 +02:00
std::string getRam(int segment, int address,int lines, int linesize);
2021-07-09 00:51:05 +02:00
int verify();
bool isExecuted();
bool isInitialized();
void setRights(int rights);
void clearbreakpoints();
void addbreakpoint(uint16_t segment, uint32_t address);
void removebreakpoint(uint16_t segment, uint32_t address);
std::vector<int> getBreapoints();
int getLine();
uint32_t getEIP();
uint32_t getESI();
uint32_t getEDI();
uint32_t getESP();
uint32_t getEBP();
uint16_t getCS();
uint16_t getDS();
uint16_t getES();
uint16_t getSS();
private:
int rights;
void Init();
void Close();
uc_engine *uc;
uc_err err;
int bufferaddress;
int address_old;
uint8_t *code;
uLong crc,crc_old;
std::vector<Code> mcode;
Menu *widget;
Assembler asmer{widget};
Desassembler unasmer{widget};
};
class Menu final : public finalcut::FDialog
{
public:
// Constructor
explicit Menu (finalcut::FWidget* = nullptr);
// Disable copy constructor
Menu (const Menu&) = delete;
// Destructor
~Menu() override = default;
// Disable copy assignment operator (=)
Menu& operator = (const Menu&) = delete;
// Methods
void loadLevel(int alevel);
void closeLevel();
void tolog(std::string str);
std::vector<std::array<std::string, 4>> getsrc();
void SetScreen(uint16_t x, uint16_t y, char value);
private:
void onTimer (finalcut::FTimerEvent*) override;
void refresh();
void configureFileMenuItems();
void initMenusCallBack ();
void initMenus();
void initMisc();
void compile();
void end();
void loadScenario(std::string file);
void showInstr();
void addbp();
void exec();
void trace();
void step();
void about();
void changesyntax();
void ClearScreen();
void AdjustWindows();
void initWindows();
void initLayout() override;
// Event handler
void onClose (finalcut::FCloseEvent*) override;
// Callback method
void cb_message (const finalcut::FMenuItem*);
// Data members
//finalcut::FString line{13, finalcut::UniChar::BoxDrawingsHorizontal};
finalcut::FMenuBar Menubar{this};
finalcut::FMenu Game{"&Partie", &Menubar};
finalcut::FMenuItem New{"&Nouvelle partie", &Game};
finalcut::FMenuItem Line2{&Game};
finalcut::FMenuItem Quit{"&Quitter", &Game};
finalcut::FMenu Options{"&Options", &Menubar};
finalcut::FMenu Memory{"&Visualisateur Mémoire", &Options};
finalcut::FRadioMenuItem Ds_000{"DS:0000", &Memory};
finalcut::FRadioMenuItem Ds_esi{"DS:ESI", &Memory};
finalcut::FRadioMenuItem Es_edi{"ES:EDI", &Memory};
finalcut::FRadioMenuItem Cs_eip{"CS:EIP", &Memory};
finalcut::FRadioMenuItem Ss_esp{"SS:ESP", &Memory};
finalcut::FRadioMenuItem Ss_FFF{"SS:FFFF", &Memory};
finalcut::FRadioMenuItem Value{"Valeur...", &Memory};
finalcut::FMenu Code{"&Syntaxe", &Options};
finalcut::FCheckMenuItem AsmAtt{"Assembleur AT&T", &Code};
finalcut::FCheckMenuItem UnasmAtt{"Désassembleur AT&T", &Code};
finalcut::FMenu Tools{"&Outils", &Menubar};
finalcut::FMenuItem Assemble{"&Assembler", &Tools};
finalcut::FMenuItem Rearange{"&Ordonne les fenêtres", &Tools};
finalcut::FMenu Debug{"&Déboguage", &Menubar};
finalcut::FMenuItem Run{"&Exécuter", &Debug};
finalcut::FMenuItem End{"&Terminer", &Debug};
finalcut::FMenuItem TraceInto{"Pas à pas &détaillé", &Debug};
finalcut::FMenuItem StepOver{"&Pas à pas", &Debug};
finalcut::FMenu Breakpoint{"&Point d'arrêt", &Menubar};
finalcut::FMenuItem AddBp{"&Ajouter", &Breakpoint};
finalcut::FMenuItem ClearBp{"&Tout supprimer", &Breakpoint};
finalcut::FDialogListMenu Window{"&Fenêtres", &Menubar};
finalcut::FMenu Help{"&Aide", &Menubar};
finalcut::FMenuItem About{"&A propos", &Help};
finalcut::FTextView Log{this};
finalcut::FStatusBar Statusbar{this};
TextWindow info{this};
TextWindow view{this};
InstructionWindow debug{this};
TextWindow regs{this};
TextWindow flags{this};
TextWindow stack{this};
TextWindow mem{this};
TextWindow tuto{this};
TextWindow screen{this};
TextEditWindow edit{this};
ScenarioWindow scenar{this};
VMEngine vm{this};
};