本文是 IS 2016课程的homework笔记，详情请参考课程主页和本人github主页
-
cpu_exec是一个循环执行exec(eip)函数，exec由make_helper宏定义
// nemu/src/cpu/exec/exec.c
make_helper(exec) {
ops_decoded.opcode = instr_fetch(eip, 1);
return opcode_table[ ops_decoded.opcode ](eip);
}
// nemu/include/cpu/helper.h
/* All function defined with 'make_helper' return the length of the operation. */
#define make_helper(name) int name(swaddr_t eip)
-
exec调用的是opcode_table对当前eip指向的指令进行dispatch，table和ops_decoded的定义为
// nemu/include/cpu/decode/operand.h
typedef struct {
uint32_t type;
size_t size;
union {
uint32_t reg;
swaddr_t addr;
uint32_t imm;
int32_t simm;
};
uint32_t val;
char str[OP_STR_SIZE];
} Operand;
typedef struct {
uint32_t opcode;
bool is_operand_size_16;
Operand src, dest, src2;
} Operands;
// decode.c
Operands ops_decoded;
-
66这个prefix决定了mov指令立即数的长度，在opcode_table里边将其分发到函数operand_size，该函数将全局变量的域is_operand_size_16置位，然后再按照正常的逻辑执行exec函数，不过返回值加１字节。
make_helper(operand_size) {
ops_decoded.is_operand_size_16 = true;
int instr_len = exec(eip + 1);
ops_decoded.is_operand_size_16 = false;
return instr_len + 1;
}
- 比如找到的是
mov_i2r_v，那么它用make_helper声明，用make_helper_v定义，v表示是变长的操作数，可能是16/32位操作数。译码是通过operand的size来决定不同的实现的，没有66的话就是32bit的。
// nemu/src/cpu/exec/data-mov/mov.c
/* for instruction encoding overloading */
make_helper_v(mov_i2r)
make_helper_v(mov_i2rm)
make_helper_v(mov_r2rm)
make_helper_v(mov_rm2r)
make_helper_v(mov_a2moffs)
make_helper_v(mov_moffs2a)
#define make_helper_v(name) \\
make_helper(concat(name, _v)) { \\
return (ops_decoded.is_operand_size_16 ? concat(name, _w) : concat(name, _l)) (eip); \\
}
- 后面的
mov_i2r_w和mov_i2r_l是模板，定义在mov.c里边，用用模板引擎多次调用make_instr_helper实现。这里有四层的模板：
- 最顶层的模板是
template-start.h和template-end.h，作用是提供操作数的类型和后缀名，用DATA_BYTE的大小决定。 - 中间层是
mov-template.h，提供move指令的指令名等信息，这里将instr定义为mov - 组合层在exec/helper.h中，用
make_instr_helper实现，这里用到了上层提供的类型，后缀名和指令名。组合层需要两个函数指针“decode_type_suffix"和"do_type_suffix"。 - 最后是实现层实现具体的解码和执行函数。
例如，mov_i2r_v的实现在mov.c中，在mov.c里边就有３次"调用mov-template.h，三次调用传递了不同的数据类型和后缀名，mov-template中将instr宏定义为mov。然后一次实现mov_i2r_w和mov_i2r_l，这里边mov是instr，w/l是后缀，i2r是type。他们使使用了idex，该函数需要参数decode_i2r_w和do_i2r_w。
// nemu/src/cpu/exec/data-move/move.c
#define DATA_BYTE 1
#include "mov-template.h"
#undef DATA_BYTE
#define DATA_BYTE 2
#include "mov-template.h" // mov_xxx_w
#undef DATA_BYTE
#define DATA_BYTE 4
#include "mov-template.h"
#undef DATA_BYTE
// nemu/include/cpu/exec/template-start.h
#if DATA_BYTE == 1
#define SUFFIX b
#define DATA_TYPE uint8_t
#define DATA_TYPE_S int8_t
#elif DATA_BYTE == 2
#define SUFFIX w
#define DATA_TYPE uint16_t
#define DATA_TYPE_S int16_t
#elif DATA_BYTE == 4
#define SUFFIX l
#define DATA_TYPE uint32_t
#define DATA_TYPE_S int32_t
#else
#error unknown DATA_BYTE
#endif
// nemu/src/cpu/exec/data-move/move-template.h
#define instr mov
make_instr_helper(i2r)
make_instr_helper(i2rm)
make_instr_helper(r2rm)
make_instr_helper(rm2r)
// nemu/include/cpu/exec/helper.h
#define make_instr_helper(type) \\
make_helper(concat5(instr, _, type, _, SUFFIX)) { \\
return idex(eip, concat4(decode_, type, _, SUFFIX), do_execute); \\
}
// nemu/include/cpu/helper.h
/* Instruction Decode and EXecute */
static inline int idex(swaddr_t eip, int (*decode)(swaddr_t), void (*execute) (void)) {
/* eip is pointing to the opcode */
int len = decode(eip + 1);
execute();
return len + 1; // "1" for opcode
}
传递给
idex的函数有两个，一个是decode，一个是execute.这里的execute部分特别隐晦，在mov.c里边定义了一个
do_execute的函数，在之前的头文件里边又定义了一个do_execute的宏，编译时，do_execute进行了文本替换，比如替换成了do_mov_b等等，这样才有了实际的执行体。
// exec/helper.h
#define do_execute concat4(do_, instr, _, SUFFIX)
// mov-template.h
static void do_execute() {
OPERAND_W(op_dest, op_src->val);
print_asm_template2();
}
// template-start.h
#define OPERAND_W(op, src) concat(write_operand_, SUFFIX) (op, src)
// exec/helper.h
#define print_asm_template2() \
print_asm(str(instr) str(SUFFIX) " %s,%s", op_src->str, op_dest->str)
- write_operand_xx的实现在decode里边，如果操作类型是寄存器就写到目的寄存器，否则就写到内存里边。
void concat(write_operand_, SUFFIX) (Operand *op, DATA_TYPE src) {
if(op->type == OP_TYPE_REG) { REG(op->reg) = src; }
else if(op->type == OP_TYPE_MEM) { swaddr_write(op->addr, op->size, src); }
else { assert(0); }
}
print_asm_template2()。
如果nemu是用面向对象的方法写可能会清晰很多，这里的各种奇奇怪怪的宏替代if/switch，出错调试起来各种乱七八糟的提示，感觉设计过度了。
关于
decode_type_suffix这个在decode模块无疑，看一下mov的实现decode_i2r_w，
// decode-template.h
/* XX <- Ib
* eXX <- Iv
*/
make_helper(concat(decode_i2r_, SUFFIX)) {
decode_r_internal(eip, op_dest);
return decode_i(eip);
}
#define decode_r_internal concat3(decode_r_, SUFFIX, _internal)
/* eXX: eAX, eCX, eDX, eBX, eSP, eBP, eSI, eDI */
static int concat3(decode_r_, SUFFIX, _internal) (swaddr_t eip, Operand *op) {
op->type = OP_TYPE_REG;
op->reg = ops_decoded.opcode & 0x7;
op->val = REG(op->reg);
#ifdef DEBUG
snprintf(op->str, OP_STR_SIZE, "%%%s", REG_NAME(op->reg));
#endif
return 0;
}
- 这里写反了，先写decode再写execute比较好
实现一条call指令
查找
call rel32对应的opcode为e8，在exec.c里边的opcode_table里边增加一个条目，记为call_i_v。声明１中的函数，在cpu/exec目录里边创建call目录，该目录下依次创建三个文件：call.h/call.c/call-template.h；在all-instrs.h目录里边增加"call/call.h"头文件。
// call.h
#include "cpu/helper.h"
make_helper(call_i_v);
// call.c
#include "cpu/exec/helper.h"
#define DATA_BYTE 2
#include "calll-template.h"
#endif
#define DATA_BYTE 4
#include "call-template.h"
#endif
make_helpr_v(call_i)
// call-template.h
#include "cpu/exec/template-start.h"
#define instr call
static void do_execute() {
// push(ip)
// read operand address
// eip += relative address
}
make_instr_helper(i)
#include "cpu/exec/template-end.h"
- 创建decode函数，在decode/decode.h，这里应该能够直接使用
decode_i_w和decode_i_l，这里src->type为立即数，数据在imm里边
make_helper(concat(decode_i_, SUFFIX)) {
/* eip here is pointing to the immediate */
op_src->type = OP_TYPE_IMM;
op_src->imm = instr_fetch(eip, DATA_BYTE);
op_src->val = op_src->imm;
#ifdef DEBUG
snprintf(op_src->str, OP_STR_SIZE, "$0x%x", op_src->imm);
#endif
return DATA_BYTE;
}
替换exec table中的inv为call_i_v即可
使用
decode_i_w各种不适，因为call的操作数不是立即数？注意到call opcode的后面跟的是cw/cd，试着将i改为c，增加新的decode_c看看。
// decode.h
make_helper(decode_c_w);
make_helper(decode_c_l);
// operand.h
enum { OP_TYPE_REG, OP_TYPE_MEM, OP_TYPE_IMM, OP_TYPE_CALL };
// decode-template.h
/* cw/cd */
make_helper(concat(decode_c_, SUFFIX)) {
op_src->type = OP_TYPE_CALL;
op_src->val = instr_fetch(eip, DATA_BYTE);
#ifdef DEBUG
sprintf(op_src->str, OP_STR_SIZE, "", op_src->val);
#endif
return DATA_BYTE;
}
实现push指令
- done, nothing special
实现test指令
- done
实现je指令
- done
int32_t tmp = op_dest->val - op_src->val;
cpu.AF = 0;
cpu.OF = 0;
cpu.CF = 0;
cpu.SF = tmp & 0x7fffffff;
cpu.ZF = tmp == 0 ? 1 : 0;
cpu.PF = parity(tmp & 0xff);
push/pop/ret
问题出在了sub指令，他的描述是
83 /5 ib SUB r/m16,imm8 2/7 Subtract sign-extended immediate byte from r/m word
83 /5 ib SUB r/m32,imm8 2/7 Subtract sign-extended immediate byte from r/m dword
它的目的操作数和源操作数长度不一致，计算的时候把源操作数要sign extended，但是问题是，框架中要保持目的和源操作数的类型一致。
