Mariquitas os lo tienen que dar todo hecho :D. Yo lo comento todo en ingles paletillo asi que no me insultes xD.
Con el español y el catalán no vas a salir de tu barrio xD.
Yo prohibiría los doblajes de pelis al español y al catalán, euskera, etc... y así nos quitabamos un gasto de encima. [wei2]
No te enfades, ehh que no posteaba por esto.
Bueno a lo que vamos. He estado mirando un poco por la
recompilación dinámica "dynarec" y voy a poner un mini tutorial
para codificar dinamicamente los operandos "opcodes" de los x86.
Los emuladores "interpretes" decodifican el opcode, mediante una
tabla de punteros a función o varias de estas.
Una vez decodificado "fetch" se ejecuta, en la función apuntada.
Los procesadores RISC son mas faciles de decodificar pues solo
tienen opcodes+operandos de igual tamaño:
(PSX-RISC300A) opcodes de 32 bits, donde va el tipo de operacion + operandos.
Los operadores CISC con mas pesados pues tienen operandos de diferente tamaño, 1 byte, ejmplo RET en x86, 3 bytes, LD A,$0005
en Z80, 1 byte de opcode + 2 de #Inm, etc...
Bueno y despues de la ejecución hay que emular las
interrupciones. Si son snidadas con prioridad, si no, etc...
Lo de los ciclos de reloj no se como va eso.
Bueno a lo que ibamos, el dynarec se realiza a partir de aquí.
El dynarec no es mas que codigo de la maquina que hospeda el
emulador que es traduccion directa de los opcodes de la maquina emulada. Posee una cahce, "información de la situación del codigo" en la memoria emulada... hay que poder saber donde esta el PC real de 64KB de un Z80 por ejemplo, porque los opcodes no tienen el mismo tamaño xD.
La cache sirve "lo mas importante para tener un acceso rapido"
al codigo compilado por si se repite muchas veces y no tener que recompilarlo algo asi como una cache de RAM real.
Bueno la caché son esttructuras con todo lo que necesitamos saber de los bloques de código con codio de la maquina hospedadora? que mal suena xD. Por tanto tiene puntero al bloque de codigo , su tamaño, etc...
typedef struct codeblock{
unsigned char* buffer;
unsigned short size;
unsigned short indxemitter;
}
Para ejecutar el codigo, que supongo que os procupara, esto es portable:
codeblock CB;
CB.buffer = (unsigned char*)malloc(128);
CB.size = 128;
CB.indxbuffer = 0;
void (*ejecutaBloque)() = (void(*)())CB.buffer;
ejecutaBloque(); // Ya esta xD
// Se traduce a: CALL CB.buffer
Pero claro esto casca xD. porque no vuelve de la llamada.
En un x86 esta es el byte 0xC3 RET.
CB.buffer[CB.indxbuffer++] = 0xC3;
ejecutaBloque();
// Ahora si xD.
Lo que ha equivalido a un:
CALL bloque
NOP
......
;Una función un poco corta... xD
bloque: RET
Para hacer algo mas "papichulo":
#include "./../global/types.h"
#ifndef __DYNAREC_H__
#define __DYNAREC_H__
typedef struct codeblock
{
BYTE* buffer;
DWORD indxemitter;
DWORD size;
}
codeblock;
/**
* initCodeBlock
* Init a code block
*/
void initCodeBlock(codeblock* CB, WORD size);
/**
* freeCodeBlock
* Free a code block
*/
void freeCodeBlock(codeblock* CB);
/**
* executeBlock
* Exectute a block of code
*/
void executeBlock(codeblock* CB);
/**
* emitteByte
* Emitte a byte in codeblock
*/
void emitteByte(register codeblock* CB, BYTE value);
/**
* emitetWord
* Emitte a word in codeblock
*/
void emitteWord(register codeblock* CB, WORD value);
/**
* emitteDWord
* Emitte a dword in codeblock
*/
void emitteDWord(register codeblock* CB, DWORD value);
#endif //__DYNAREC_H__
#include "dynarec.h"
#include <assert.h>
void executeBlock(codeblock* CB)
{
/* Transform the block in a function */
void (*CBFunction)() = (void(*)())CB->buffer;
/* Call the block */
CBFunction();
}
void initCodeBlock(codeblock* CB, WORD size)
{
CB->buffer = (BYTE*)malloc(size);
assert(CB->buffer);
CB->indxemitter = 0;
CB->size = size;
}
void freeCodeBlock(codeblock* CB)
{
free(CB->buffer);
CB->indxemitter = 0;
CB->size=0;
}
void emitteByte(register codeblock* CB, BYTE value)
{
CB->buffer[CB->indxemitter++] = value;
}
void emitteWord(register codeblock* CB, WORD value)
{
*((WORD*)(CB->buffer+CB->indxemitter)) = value;
CB->indxemitter+=2;
}
void emitteDWord(register codeblock* CB, DWORD value)
{
*((DWORD*)(CB->buffer+CB->indxemitter)) = value;
CB->indxemitter+=4;
}
#include "../../global/types.h"
#include "../dynarec.h"
#include "x86emitter_macros.h"
#ifndef __X86EMITTER_H__
#define __X86EMITTER_H__
typedef enum
{
EAX = 0, EBX = 3, ECX = 1, EDX = 2,
ESI = 6, EDI = 7, EBP = 5, ESP = 4
}
X86RegType;
/**
* emitteH_x86_ModRM
* The ModRM and SIB bytes follow the opcode byte(s) in many of the processor
* instructions. They contain the following information:
• Indexing type or register number to be used in the instruction
• Register to be used, or more information to select the instruction
• Base, index, and scale information
*/
void emitteH_x86_ModRM(codeblock* CB,BYTE mod,BYTE rm,X86RegType reg);
/**
* emitteH_x86_SibSB
* The ModRM and SIB bytes follow the opcode byte(s) in many of the processor
* instructions. They contain the following information:
• Indexing type or register number to be used in the instruction
• Register to be used, or more information to select the instruction
• Base, index, and scale information
*/
void emitteH_x86_SibSB(codeblock* CB,BYTE sib,BYTE rm,BYTE index);
/**
* emit_x86_ret
* The ret opcode for return
* of a called function
*/
void x86_x86_ret(codeblock* CB);
/**
* emit_x86_mov16RtoM
*/
void emit_x86_mov16RtoM(codeblock* CB,X86RegType from,DWORD to);
/**
* emit_x86_mov16RtoM
*/
void emit_x86_mov16MtoR(codeblock* CB,DWORD from, X86RegType to);
/**
* emit_x86_mov16ItoR
*/
void emit_x86_mov16ItoR(codeblock* CB,X86RegType to,WORD value);
#endif //__X86EMITTER__
< - >
Segunada parte:
#include "x86emitter.h"
void emitteH_x86_ModRM(codeblock* CB,BYTE mod,BYTE rm,X86RegType reg)
{
emitteByte(CB,(mod<<6)|(rm<<4)|(reg));
}
void emitteH_x86_SibSB(codeblock* CB,BYTE sib,BYTE rm,BYTE index)
{
emitteByte(CB,(sib<<6)|(rm<<4)|(index));
}
void emit_x86_ret(register codeblock* CB)
{
/* Opcode RET */
emitteByte(CB, 0xC3);
}
void emit_x86_mov16RtoM(codeblock* CB,X86RegType from,DWORD to)
{
/* Operand size prefix */
emitteByte(CB, 0x66);
emitteByte(CB, 0x89);
/* Addressing form */
emitteH_x86_ModRM(CB,0,from,DISP32);
/* Inm Dir */
emitteDWord(CB, to);
}
void emit_x86_mov16MtoR(codeblock* CB,DWORD from, X86RegType to)
{
/* Operand size prefix */
emitteByte(CB, 0x66);
emitteByte(CB, 0x8B);
/* Addressing form */
emitteH_x86_ModRM(CB,0,to,DISP32);
/* Inm Dir */
emitteDWord(CB, from);
}
void emit_x86_mov16ItoR(codeblock* CB,X86RegType to,WORD value)
{
/* Operand size prefix */
emitteByte(CB, 0x66);
emitteByte(CB, 0xB8|to);
/* Inm Num */
emitteWord(CB, value);
}
#include "../../global/types.h"
#ifndef __X86EMITTER_MACROS_H__
#define __X86EMITTER_MACROS_H__
#define DISP32 5
#endif //__X86EMITTER_MACROS__
emitteH_x86_ModRM & emitteH_x86_SibSB son funciones de ayuda
para codificar bytes extraños que utilizan algunos opcodes.
Y donde esta la codificacion binaria?? [Ahhh]
Ja para eso esoty yo aquí xD.
http://img352.imageshack.us/img352/4927/intelvc1.png (http://imageshack.us)
Bueno esto no es dificil de encontrar pues esta en la
web oficial.
Bueno la razon de estas dos funciones:
http://img63.imageshack.us/img63/1450/intel2to7.png (http://imageshack.us)
Mas ayuda de codificación:
http://img130.imageshack.us/img130/2829/intel3xk1.png (http://imageshack.us)
Opcodes imprescindibles:
http://img246.imageshack.us/img246/610/intel4tk5.png (http://imageshack.us)
Bueno al grano:
unsigned int value = 0;
printf("value: %u", value);
codeblock CB;
initCodeBlock(&CB, 64);
emit_x86_mov16ItoR(&CB,EAX,13);
emit_x86_mov16RtoM(&CB,EAX,(DWORD)&value);
emit_x86_ret(&CB); // No sus olvide xD
executeBlock(&CB);
freeCodeBlock(&CB);
printf("value: %u", value);
CodeBlock:
Mueve 13 ---> EAX
Mueve EAX ---> [&value]
Return
SALIDA: "value: 13"
Explicación de la función "RtoM":
/* Este es un prefijo de tamaño raro */
emitteByte(CB, 0x66);
emitteByte(CB, 0x89); // 1000 100w Donde w=1.
emitteH_x86_ModRM(CB,0,from,DISP32); // Mod=0, Reg=EAX, R/M=DISP32
emitteDWord(CB, to); // 4 Bytes de dirección
Venga [Ahhh]. Si os interesa mas me lo contais.
Tengo una para sumar registros, y mas, si os fijais son
muy faciles de codificar, las de mover de registro a memoria
no son mias pero la de Inm a REG si, y no son dificiles de codificar.
Y ya si hablamos de ARM será aun mas faciles al ser
un procesador RISC.
Estoy haciendo un emu del Z80 con dynarec en el PC, me
llevará unos meses que soy un tio ocupado, por ahora no
tengo nada de dynarec xD, tengo que rellenar todas las
funciones de los opcodes que es muy aburrido xD
e investigar mas.