10 virtual std::string
to_string(insn_t val
) const = 0;
14 static const char* xpr_to_string
[] = {
15 "zero", "ra", "v0", "v1", "a0", "a1", "a2", "a3",
16 "a4", "a5", "a6", "a7", "t0", "t1", "t2", "t3",
17 "t4", "t5", "t6", "t7", "s0", "s1", "s2", "s3",
18 "s4", "s5", "s6", "s7", "s8", "s9", "sp", "tp"
21 static const char* fpr_to_string
[] = {
22 "ft0", "ft1", "fv0", "fv1", "fa0", "fa1", "fa2", "fa3",
23 "fa4", "fa5", "fa6", "fa7", "ft0", "ft1", "ft2", "ft3",
24 "ft4", "ft5", "ft6", "ft7", "fs0", "fs1", "fs2", "fs3",
25 "fs4", "fs5", "fs6", "fs7", "fs8", "fs9", "ft10", "ft11"
28 class load_address_t
: public arg_t
31 virtual std::string
to_string(insn_t insn
) const
34 s
<< insn
.itype
.imm12
<< '(' << xpr_to_string
[insn
.itype
.rs1
] << ')';
39 class store_address_t
: public arg_t
42 virtual std::string
to_string(insn_t insn
) const
45 int32_t imm
= (int32_t)insn
.btype
.immlo
;
46 imm
|= insn
.btype
.immhi
<< IMMLO_BITS
;
47 s
<< imm
<< '(' << xpr_to_string
[insn
.itype
.rs1
] << ')';
52 class amo_address_t
: public arg_t
55 virtual std::string
to_string(insn_t insn
) const
58 s
<< "0(" << xpr_to_string
[insn
.itype
.rs1
] << ')';
63 class xrd_reg_t
: public arg_t
66 virtual std::string
to_string(insn_t insn
) const
68 return xpr_to_string
[insn
.itype
.rd
];
72 class xrs1_reg_t
: public arg_t
75 virtual std::string
to_string(insn_t insn
) const
77 return xpr_to_string
[insn
.itype
.rs1
];
81 class xrs2_reg_t
: public arg_t
84 virtual std::string
to_string(insn_t insn
) const
86 return xpr_to_string
[insn
.rtype
.rs2
];
90 class frd_reg_t
: public arg_t
93 virtual std::string
to_string(insn_t insn
) const
95 return fpr_to_string
[insn
.ftype
.rd
];
99 class frs1_reg_t
: public arg_t
102 virtual std::string
to_string(insn_t insn
) const
104 return fpr_to_string
[insn
.ftype
.rs1
];
108 class frs2_reg_t
: public arg_t
111 virtual std::string
to_string(insn_t insn
) const
113 return fpr_to_string
[insn
.ftype
.rs2
];
117 class frs3_reg_t
: public arg_t
120 virtual std::string
to_string(insn_t insn
) const
122 return fpr_to_string
[insn
.ftype
.rs3
];
126 class pcr_reg_t
: public arg_t
129 virtual std::string
to_string(insn_t insn
) const
132 s
<< "pcr" << insn
.rtype
.rs2
;
137 class imm_t
: public arg_t
140 virtual std::string
to_string(insn_t insn
) const
143 s
<< insn
.itype
.imm12
;
148 class bigimm_t
: public arg_t
151 virtual std::string
to_string(insn_t insn
) const
154 s
<< std::hex
<< "0x" << insn
.ltype
.bigimm
;
159 class branch_target_t
: public arg_t
162 virtual std::string
to_string(insn_t insn
) const
165 int32_t target
= (int32_t)insn
.btype
.immlo
;
166 target
|= insn
.btype
.immhi
<< IMMLO_BITS
;
167 target
<<= BRANCH_ALIGN_BITS
;
168 char sign
= target
>= 0 ? '+' : '-';
169 s
<< "pc " << sign
<< std::hex
<< " 0x" << abs(target
);
174 class jump_target_t
: public arg_t
177 virtual std::string
to_string(insn_t insn
) const
180 int32_t target
= (int32_t)insn
.jtype
.target
;
181 target
<<= JUMP_ALIGN_BITS
;
182 char sign
= target
>= 0 ? '+' : '-';
183 s
<< "pc " << sign
<< std::hex
<< " 0x" << abs(target
);
188 // workaround for lack of initializer_list in gcc-4.1
192 disasm_insn_t(const char* name
, uint32_t match
, uint32_t mask
)
194 init(name
, match
, mask
, 0);
196 disasm_insn_t(const char* name
, uint32_t match
, uint32_t mask
,
199 init(name
, match
, mask
, 1, a0
);
201 disasm_insn_t(const char* name
, uint32_t match
, uint32_t mask
,
202 const arg_t
* a0
, const arg_t
* a1
)
204 init(name
, match
, mask
, 2, a0
, a1
);
206 disasm_insn_t(const char* name
, uint32_t match
, uint32_t mask
,
207 const arg_t
* a0
, const arg_t
* a1
, const arg_t
* a2
)
209 init(name
, match
, mask
, 3, a0
, a1
, a2
);
211 disasm_insn_t(const char* name
, uint32_t match
, uint32_t mask
,
212 const arg_t
* a0
, const arg_t
* a1
, const arg_t
* a2
,
215 init(name
, match
, mask
, 4, a0
, a1
, a2
, a3
);
217 disasm_insn_t(const char* name
, uint32_t match
, uint32_t mask
,
218 const arg_t
* a0
, const arg_t
* a1
, const arg_t
* a2
,
219 const arg_t
* a3
, const arg_t
* a4
)
221 init(name
, match
, mask
, 5, a0
, a1
, a2
, a3
, a4
);
224 bool operator == (insn_t insn
) const
226 return (insn
.bits
& mask
) == match
;
229 std::string
to_string(insn_t insn
) const
233 for (len
= 0; name
[len
]; len
++)
234 s
<< (name
[len
] == '_' ? '.' : name
[len
]);
238 s
<< std::string(std::max(1, 8 - len
), ' ');
239 for (size_t i
= 0; i
< args
.size()-1; i
++)
240 s
<< args
[i
]->to_string(insn
) << ", ";
241 s
<< args
[args
.size()-1]->to_string(insn
);
246 uint32_t get_match() const { return match
; }
247 uint32_t get_mask() const { return mask
; }
252 std::vector
<const arg_t
*> args
;
255 void init(const char* name
, uint32_t match
, uint32_t mask
, int n
, ...)
259 for (int i
= 0; i
< n
; i
++)
260 args
.push_back(va_arg(vl
, const arg_t
*));
268 std::string
disassembler::disassemble(insn_t insn
)
270 const disasm_insn_t
* disasm_insn
= lookup(insn
);
271 return disasm_insn
? disasm_insn
->to_string(insn
) : "unknown";
274 disassembler::disassembler()
276 static const xrd_reg_t _xrd_reg
, *xrd_reg
= &_xrd_reg
;
277 static const xrs1_reg_t _xrs1_reg
, *xrs1_reg
= &_xrs1_reg
;
278 static const load_address_t _load_address
, *load_address
= &_load_address
;
279 static const store_address_t _store_address
, *store_address
= &_store_address
;
280 static const amo_address_t _amo_address
, *amo_address
= &_amo_address
;
281 static const xrs2_reg_t _xrs2_reg
, *xrs2_reg
= &_xrs2_reg
;
282 static const frd_reg_t _frd_reg
, *frd_reg
= &_frd_reg
;
283 static const frs1_reg_t _frs1_reg
, *frs1_reg
= &_frs1_reg
;
284 static const frs2_reg_t _frs2_reg
, *frs2_reg
= &_frs2_reg
;
285 static const frs3_reg_t _frs3_reg
, *frs3_reg
= &_frs3_reg
;
286 static const pcr_reg_t _pcr_reg
, *pcr_reg
= &_pcr_reg
;
287 static const imm_t _imm
, *imm
= &_imm
;
288 static const bigimm_t _bigimm
, *bigimm
= &_bigimm
;
289 static const branch_target_t _branch_target
, *branch_target
= &_branch_target
;
290 static const jump_target_t _jump_target
, *jump_target
= &_jump_target
;
294 dummy
.rtype
.rs1
= -1;
295 uint32_t mask_rs1
= dummy
.bits
;
297 dummy
.rtype
.rs2
= -1;
298 uint32_t mask_rs2
= dummy
.bits
;
301 uint32_t mask_rd
= dummy
.bits
;
303 dummy
.itype
.imm12
= -1;
304 uint32_t mask_imm
= dummy
.bits
;
307 uint32_t match_rd_ra
= dummy
.bits
;
310 uint32_t match_rs1_ra
= dummy
.bits
;
312 #define DECLARE_INSN(code, match, mask) \
313 const uint32_t __attribute__((unused)) match_##code = match; \
314 const uint32_t __attribute__((unused)) mask_##code = mask;
318 // explicit per-instruction disassembly
319 #define DISASM_INSN(name, code, extra, ...) \
320 add_insn(new disasm_insn_t(name, match_##code, mask_##code | (extra), __VA_ARGS__));
321 #define DEFINE_NOARG(code) \
322 add_insn(new disasm_insn_t(#code, match_##code, mask_##code));
323 #define DEFINE_DTYPE(code) DISASM_INSN(#code, code, 0, xrd_reg)
324 #define DEFINE_RTYPE(code) DISASM_INSN(#code, code, 0, xrd_reg, xrs1_reg, xrs2_reg)
325 #define DEFINE_ITYPE(code) DISASM_INSN(#code, code, 0, xrd_reg, xrs1_reg, imm)
326 #define DEFINE_I0TYPE(name, code) DISASM_INSN(name, code, mask_rs1, xrd_reg, imm)
327 #define DEFINE_I1TYPE(name, code) DISASM_INSN(name, code, mask_imm, xrd_reg, xrs1_reg)
328 #define DEFINE_I2TYPE(name, code) DISASM_INSN(name, code, mask_rd | mask_imm, xrs1_reg)
329 #define DEFINE_LTYPE(code) DISASM_INSN(#code, code, 0, xrd_reg, bigimm)
330 #define DEFINE_BTYPE(code) DISASM_INSN(#code, code, 0, xrs1_reg, xrs2_reg, branch_target)
331 #define DEFINE_B0TYPE(name, code) DISASM_INSN(name, code, mask_rs1 | mask_rs2, branch_target)
332 #define DEFINE_B1TYPE(name, code) DISASM_INSN(name, code, mask_rs2, xrs1_reg, branch_target)
333 #define DEFINE_JTYPE(code) DISASM_INSN(#code, code, 0, jump_target)
334 #define DEFINE_XLOAD(code) DISASM_INSN(#code, code, 0, xrd_reg, load_address)
335 #define DEFINE_XSTORE(code) DISASM_INSN(#code, code, 0, xrs2_reg, store_address)
336 #define DEFINE_XAMO(code) DISASM_INSN(#code, code, 0, xrd_reg, xrs2_reg, amo_address)
337 #define DEFINE_FLOAD(code) DISASM_INSN(#code, code, 0, frd_reg, load_address)
338 #define DEFINE_FSTORE(code) DISASM_INSN(#code, code, 0, frs2_reg, store_address)
339 #define DEFINE_FRTYPE(code) DISASM_INSN(#code, code, 0, frd_reg, frs1_reg, frs2_reg)
340 #define DEFINE_FR1TYPE(code) DISASM_INSN(#code, code, 0, frd_reg, frs1_reg)
341 #define DEFINE_FR3TYPE(code) DISASM_INSN(#code, code, 0, frd_reg, frs1_reg, frs2_reg, frs3_reg)
342 #define DEFINE_FXTYPE(code) DISASM_INSN(#code, code, 0, xrd_reg, frs1_reg)
343 #define DEFINE_XFTYPE(code) DISASM_INSN(#code, code, 0, frd_reg, xrs1_reg)
358 DEFINE_XAMO(amoadd_w
)
359 DEFINE_XAMO(amoswap_w
)
360 DEFINE_XAMO(amoand_w
)
362 DEFINE_XAMO(amomin_w
)
363 DEFINE_XAMO(amomax_w
)
364 DEFINE_XAMO(amominu_w
)
365 DEFINE_XAMO(amomaxu_w
)
366 DEFINE_XAMO(amoadd_d
)
367 DEFINE_XAMO(amoswap_d
)
368 DEFINE_XAMO(amoand_d
)
370 DEFINE_XAMO(amomin_d
)
371 DEFINE_XAMO(amomax_d
)
372 DEFINE_XAMO(amominu_d
)
373 DEFINE_XAMO(amomaxu_d
)
384 DEFINE_B0TYPE("b", beq
);
385 DEFINE_B1TYPE("beqz", beq
);
386 DEFINE_B1TYPE("bnez", bne
);
387 DEFINE_B1TYPE("bltz", blt
);
388 DEFINE_B1TYPE("bgez", bge
);
398 DEFINE_I2TYPE("jr", jalr_j
);
399 add_insn(new disasm_insn_t("jalr", match_jalr_c
| match_rd_ra
, mask_jalr_c
| mask_rd
| mask_imm
, xrs1_reg
));
400 add_insn(new disasm_insn_t("ret", match_jalr_r
| match_rs1_ra
, mask_jalr_r
| mask_rd
| mask_rs1
| mask_imm
));
402 DEFINE_ITYPE(jalr_c
);
403 DEFINE_ITYPE(jalr_r
);
404 DEFINE_ITYPE(jalr_j
);
406 DEFINE_I0TYPE("li", addi
);
407 DEFINE_I1TYPE("move", addi
);
435 DEFINE_RTYPE(mulhsu
);
451 DEFINE_NOARG(syscall
);
454 DEFINE_NOARG(fence_i
);
456 DEFINE_DTYPE(rdcycle
);
457 DEFINE_DTYPE(rdtime
);
458 DEFINE_DTYPE(rdinstret
);
460 add_insn(new disasm_insn_t("mtpcr", match_mtpcr
, mask_mtpcr
, xrs1_reg
, pcr_reg
));
461 add_insn(new disasm_insn_t("mfpcr", match_mfpcr
, mask_mfpcr
, xrd_reg
, pcr_reg
));
467 DEFINE_FRTYPE(fadd_s
);
468 DEFINE_FRTYPE(fsub_s
);
469 DEFINE_FRTYPE(fmul_s
);
470 DEFINE_FRTYPE(fdiv_s
);
471 DEFINE_FR1TYPE(fsqrt_s
);
472 DEFINE_FRTYPE(fmin_s
);
473 DEFINE_FRTYPE(fmax_s
);
474 DEFINE_FR3TYPE(fmadd_s
);
475 DEFINE_FR3TYPE(fmsub_s
);
476 DEFINE_FR3TYPE(fnmadd_s
);
477 DEFINE_FR3TYPE(fnmsub_s
);
478 DEFINE_FRTYPE(fsgnj_s
);
479 DEFINE_FRTYPE(fsgnjn_s
);
480 DEFINE_FRTYPE(fsgnjx_s
);
481 DEFINE_FR1TYPE(fcvt_s_d
);
482 DEFINE_XFTYPE(fcvt_s_l
);
483 DEFINE_XFTYPE(fcvt_s_lu
);
484 DEFINE_XFTYPE(fcvt_s_w
);
485 DEFINE_XFTYPE(fcvt_s_wu
);
486 DEFINE_XFTYPE(fcvt_s_wu
);
487 DEFINE_XFTYPE(mxtf_s
);
488 DEFINE_FXTYPE(fcvt_l_s
);
489 DEFINE_FXTYPE(fcvt_lu_s
);
490 DEFINE_FXTYPE(fcvt_w_s
);
491 DEFINE_FXTYPE(fcvt_wu_s
);
492 DEFINE_FXTYPE(mftx_s
);
493 DEFINE_FXTYPE(feq_s
);
494 DEFINE_FXTYPE(flt_s
);
495 DEFINE_FXTYPE(fle_s
);
497 DEFINE_FRTYPE(fadd_d
);
498 DEFINE_FRTYPE(fsub_d
);
499 DEFINE_FRTYPE(fmul_d
);
500 DEFINE_FRTYPE(fdiv_d
);
501 DEFINE_FR1TYPE(fsqrt_d
);
502 DEFINE_FRTYPE(fmin_d
);
503 DEFINE_FRTYPE(fmax_d
);
504 DEFINE_FR3TYPE(fmadd_d
);
505 DEFINE_FR3TYPE(fmsub_d
);
506 DEFINE_FR3TYPE(fnmadd_d
);
507 DEFINE_FR3TYPE(fnmsub_d
);
508 DEFINE_FRTYPE(fsgnj_d
);
509 DEFINE_FRTYPE(fsgnjn_d
);
510 DEFINE_FRTYPE(fsgnjx_d
);
511 DEFINE_FR1TYPE(fcvt_d_s
);
512 DEFINE_XFTYPE(fcvt_d_l
);
513 DEFINE_XFTYPE(fcvt_d_lu
);
514 DEFINE_XFTYPE(fcvt_d_w
);
515 DEFINE_XFTYPE(fcvt_d_wu
);
516 DEFINE_XFTYPE(fcvt_d_wu
);
517 DEFINE_XFTYPE(mxtf_d
);
518 DEFINE_FXTYPE(fcvt_l_d
);
519 DEFINE_FXTYPE(fcvt_lu_d
);
520 DEFINE_FXTYPE(fcvt_w_d
);
521 DEFINE_FXTYPE(fcvt_wu_d
);
522 DEFINE_FXTYPE(mftx_d
);
523 DEFINE_FXTYPE(feq_d
);
524 DEFINE_FXTYPE(flt_d
);
525 DEFINE_FXTYPE(fle_d
);
527 add_insn(new disasm_insn_t("mtfsr", match_mtfsr
, mask_mtfsr
| mask_rd
, xrs1_reg
));
528 add_insn(new disasm_insn_t("mtfsr", match_mtfsr
, mask_mtfsr
, xrd_reg
, xrs1_reg
));
531 // provide a default disassembly for all instructions as a fallback
532 #define DECLARE_INSN(code, match, mask) \
533 add_insn(new disasm_insn_t(#code " (args unknown)", match, mask));
538 const disasm_insn_t
* disassembler::lookup(insn_t insn
)
540 size_t idx
= insn
.bits
% HASH_SIZE
;
541 for (size_t j
= 0; j
< chain
[idx
].size(); j
++)
542 if(*chain
[idx
][j
] == insn
)
543 return chain
[idx
][j
];
546 for (size_t j
= 0; j
< chain
[idx
].size(); j
++)
547 if(*chain
[idx
][j
] == insn
)
548 return chain
[idx
][j
];
553 void disassembler::add_insn(disasm_insn_t
* insn
)
555 size_t idx
= HASH_SIZE
;
556 if (insn
->get_mask() % HASH_SIZE
== HASH_SIZE
- 1)
557 idx
= insn
->get_match() % HASH_SIZE
;
558 chain
[idx
].push_back(insn
);
561 disassembler::~disassembler()
563 for (size_t i
= 0; i
< HASH_SIZE
+1; i
++)
564 for (size_t j
= 0; j
< chain
[i
].size(); j
++)