sh2dasm.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657
  1. #include <stdio.h>
  2. #include "sh2dasm.h"
  3. typedef int INT32;
  4. typedef unsigned int UINT32;
  5. typedef unsigned short UINT16;
  6. typedef unsigned char UINT8;
  7. #define DASMFLAG_STEP_OUT 0
  8. #define DASMFLAG_STEP_OVER 0
  9. #define DASMFLAG_STEP_OVER_EXTRA(x) 0
  10. #define SIGNX8(x) (((INT32)(x) << 24) >> 24)
  11. #define SIGNX12(x) (((INT32)(x) << 20) >> 20)
  12. #define Rn ((opcode >> 8) & 15)
  13. #define Rm ((opcode >> 4) & 15)
  14. static const char *const regname[16] = {
  15. "R0", "R1", "R2", "R3", "R4", "R5", "R6", "R7",
  16. "R8", "R9", "R10","R11","R12","R13","R14","SP"
  17. };
  18. static UINT32 op0000(char *buffer, UINT32 pc, UINT16 opcode)
  19. {
  20. UINT32 flags = 0;
  21. switch(opcode & 0x3f)
  22. {
  23. case 0x02:
  24. sprintf(buffer,"STC SR,%s", regname[Rn]);
  25. break;
  26. case 0x03:
  27. sprintf(buffer,"BSRF %s", regname[Rn]);
  28. break;
  29. case 0x08:
  30. sprintf(buffer,"CLRT");
  31. break;
  32. case 0x09:
  33. sprintf(buffer,"NOP");
  34. break;
  35. case 0x0A:
  36. sprintf(buffer,"STS MACH,%s", regname[Rn]);
  37. break;
  38. case 0x0B:
  39. sprintf(buffer,"RTS");
  40. flags = DASMFLAG_STEP_OUT;
  41. break;
  42. case 0x12:
  43. sprintf(buffer,"STS GBR,%s", regname[Rn]);
  44. break;
  45. case 0x18:
  46. sprintf(buffer,"SETT");
  47. break;
  48. case 0x19:
  49. sprintf(buffer,"DIV0U");
  50. break;
  51. case 0x1A:
  52. sprintf(buffer,"STS MACL,%s", regname[Rn]);
  53. break;
  54. case 0x1B:
  55. sprintf(buffer,"SLEEP");
  56. break;
  57. case 0x22:
  58. sprintf(buffer,"STC VBR,%s", regname[Rn]);
  59. break;
  60. case 0x23:
  61. sprintf(buffer,"BRAF %s", regname[Rn]);
  62. break;
  63. case 0x28:
  64. sprintf(buffer,"CLRMAC");
  65. break;
  66. case 0x29:
  67. sprintf(buffer,"MOVT %s", regname[Rn]);
  68. break;
  69. case 0x2A:
  70. sprintf(buffer,"STS PR,%s", regname[Rn]);
  71. break;
  72. case 0x2B:
  73. sprintf(buffer,"RTE");
  74. flags = DASMFLAG_STEP_OUT;
  75. break;
  76. default:
  77. switch(opcode & 15)
  78. {
  79. case 0:
  80. sprintf(buffer, "?????? $%04X", opcode);
  81. break;
  82. case 1:
  83. sprintf(buffer, "?????? $%04X", opcode);
  84. break;
  85. case 2:
  86. sprintf(buffer, "?????? $%04X", opcode);
  87. break;
  88. case 3:
  89. sprintf(buffer, "?????? $%04X", opcode);
  90. break;
  91. case 4:
  92. sprintf(buffer, "MOV.B %s,@(R0,%s)", regname[Rm], regname[Rn]);
  93. break;
  94. case 5:
  95. sprintf(buffer, "MOV.W %s,@(R0,%s)", regname[Rm], regname[Rn]);
  96. break;
  97. case 6:
  98. sprintf(buffer, "MOV.L %s,@(R0,%s)", regname[Rm], regname[Rn]);
  99. break;
  100. case 7:
  101. sprintf(buffer, "MUL.L %s,%s", regname[Rm], regname[Rn]);
  102. break;
  103. case 8:
  104. sprintf(buffer, "?????? $%04X", opcode);
  105. break;
  106. case 9:
  107. sprintf(buffer, "?????? $%04X", opcode);
  108. break;
  109. case 10:
  110. sprintf(buffer, "?????? $%04X", opcode);
  111. break;
  112. case 11:
  113. sprintf(buffer, "?????? $%04X", opcode);
  114. break;
  115. case 12:
  116. sprintf(buffer, "MOV.B @(R0,%s),%s", regname[Rm], regname[Rn]);
  117. break;
  118. case 13:
  119. sprintf(buffer, "MOV.W @(R0,%s),%s", regname[Rm], regname[Rn]);
  120. break;
  121. case 14:
  122. sprintf(buffer, "MOV.L @(R0,%s),%s", regname[Rm], regname[Rn]);
  123. break;
  124. case 15:
  125. sprintf(buffer, "MAC.L @%s+,@%s+", regname[Rn], regname[Rm]);
  126. break;
  127. }
  128. }
  129. return flags;
  130. }
  131. static UINT32 op0001(char *buffer, UINT32 pc, UINT16 opcode)
  132. {
  133. sprintf(buffer, "MOV.L %s,@($%02X,%s)", regname[Rm], (opcode & 15) * 4, regname[Rn]);
  134. return 0;
  135. }
  136. static UINT32 op0010(char *buffer, UINT32 pc, UINT16 opcode)
  137. {
  138. switch (opcode & 15)
  139. {
  140. case 0:
  141. sprintf(buffer, "MOV.B %s,@%s", regname[Rm], regname[Rn]);
  142. break;
  143. case 1:
  144. sprintf(buffer, "MOV.W %s,@%s", regname[Rm], regname[Rn]);
  145. break;
  146. case 2:
  147. sprintf(buffer, "MOV.L %s,@%s", regname[Rm], regname[Rn]);
  148. break;
  149. case 3:
  150. sprintf(buffer, "?????? $%04X", opcode);
  151. break;
  152. case 4:
  153. sprintf(buffer, "MOV.B %s,@-%s", regname[Rm], regname[Rn]);
  154. break;
  155. case 5:
  156. sprintf(buffer, "MOV.W %s,@-%s", regname[Rm], regname[Rn]);
  157. break;
  158. case 6:
  159. sprintf(buffer, "MOV.L %s,@-%s", regname[Rm], regname[Rn]);
  160. break;
  161. case 7:
  162. sprintf(buffer, "DIV0S %s,%s", regname[Rm], regname[Rn]);
  163. break;
  164. case 8:
  165. sprintf(buffer, "TST %s,%s", regname[Rm], regname[Rn]);
  166. break;
  167. case 9:
  168. sprintf(buffer, "AND %s,%s", regname[Rm], regname[Rn]);
  169. break;
  170. case 10:
  171. sprintf(buffer, "XOR %s,%s", regname[Rm], regname[Rn]);
  172. break;
  173. case 11:
  174. sprintf(buffer, "OR %s,%s", regname[Rm], regname[Rn]);
  175. break;
  176. case 12:
  177. sprintf(buffer, "CMP/STR %s,%s", regname[Rm], regname[Rn]);
  178. break;
  179. case 13:
  180. sprintf(buffer, "XTRCT %s,%s", regname[Rm], regname[Rn]);
  181. break;
  182. case 14:
  183. sprintf(buffer, "MULU.W %s,%s", regname[Rm], regname[Rn]);
  184. break;
  185. case 15:
  186. sprintf(buffer, "MULS.W %s,%s", regname[Rm], regname[Rn]);
  187. break;
  188. }
  189. return 0;
  190. }
  191. static UINT32 op0011(char *buffer, UINT32 pc, UINT16 opcode)
  192. {
  193. switch (opcode & 15)
  194. {
  195. case 0:
  196. sprintf(buffer, "CMP/EQ %s,%s", regname[Rm], regname[Rn]);
  197. break;
  198. case 1:
  199. sprintf(buffer, "?????? %s,%s", regname[Rm], regname[Rn]);
  200. break;
  201. case 2:
  202. sprintf(buffer, "CMP/HS %s,%s", regname[Rm], regname[Rn]);
  203. break;
  204. case 3:
  205. sprintf(buffer, "CMP/GE %s,%s", regname[Rm], regname[Rn]);
  206. break;
  207. case 4:
  208. sprintf(buffer, "DIV1 %s,%s", regname[Rm], regname[Rn]);
  209. break;
  210. case 5:
  211. sprintf(buffer, "DMULU.L %s,%s", regname[Rm], regname[Rn]);
  212. break;
  213. case 6:
  214. sprintf(buffer, "CMP/HI %s,%s", regname[Rm], regname[Rn]);
  215. break;
  216. case 7:
  217. sprintf(buffer, "CMP/GT %s,%s", regname[Rm], regname[Rn]);
  218. break;
  219. case 8:
  220. sprintf(buffer, "SUB %s,%s", regname[Rm], regname[Rn]);
  221. break;
  222. case 9:
  223. sprintf(buffer, "?????? %s,%s", regname[Rm], regname[Rn]);
  224. break;
  225. case 10:
  226. sprintf(buffer, "SUBC %s,%s", regname[Rm], regname[Rn]);
  227. break;
  228. case 11:
  229. sprintf(buffer, "SUBV %s,%s", regname[Rm], regname[Rn]);
  230. break;
  231. case 12:
  232. sprintf(buffer, "ADD %s,%s", regname[Rm], regname[Rn]);
  233. break;
  234. case 13:
  235. sprintf(buffer, "DMULS.L %s,%s", regname[Rm], regname[Rn]);
  236. break;
  237. case 14:
  238. sprintf(buffer, "ADDC %s,%s", regname[Rm], regname[Rn]);
  239. break;
  240. case 15:
  241. sprintf(buffer, "ADDV %s,%s", regname[Rm], regname[Rn]);
  242. break;
  243. }
  244. return 0;
  245. }
  246. static UINT32 op0100(char *buffer, UINT32 pc, UINT16 opcode)
  247. {
  248. UINT32 flags = 0;
  249. switch(opcode & 0x3F)
  250. {
  251. case 0x00:
  252. sprintf(buffer, "SHLL %s", regname[Rn]);
  253. break;
  254. case 0x01:
  255. sprintf(buffer, "SHLR %s", regname[Rn]);
  256. break;
  257. case 0x02:
  258. sprintf(buffer, "STS.L MACH,@-%s", regname[Rn]);
  259. break;
  260. case 0x03:
  261. sprintf(buffer, "STC.L SR,@-%s", regname[Rn]);
  262. break;
  263. case 0x04:
  264. sprintf(buffer, "ROTL %s", regname[Rn]);
  265. break;
  266. case 0x05:
  267. sprintf(buffer, "ROTR %s", regname[Rn]);
  268. break;
  269. case 0x06:
  270. sprintf(buffer, "LDS.L @%s+,MACH", regname[Rn]);
  271. break;
  272. case 0x07:
  273. sprintf(buffer, "LDC.L @%s+,SR", regname[Rn]);
  274. break;
  275. case 0x08:
  276. sprintf(buffer, "SHLL2 %s", regname[Rn]);
  277. break;
  278. case 0x09:
  279. sprintf(buffer, "SHLR2 %s", regname[Rn]);
  280. break;
  281. case 0x0a:
  282. sprintf(buffer, "LDS %s,MACH", regname[Rn]);
  283. break;
  284. case 0x0b:
  285. sprintf(buffer, "JSR %s", regname[Rn]);
  286. flags = DASMFLAG_STEP_OVER | DASMFLAG_STEP_OVER_EXTRA(1);
  287. break;
  288. case 0x0e:
  289. sprintf(buffer, "LDC %s,SR", regname[Rn]);
  290. break;
  291. case 0x10:
  292. sprintf(buffer, "DT %s", regname[Rn]);
  293. break;
  294. case 0x11:
  295. sprintf(buffer, "CMP/PZ %s", regname[Rn]);
  296. break;
  297. case 0x12:
  298. sprintf(buffer, "STS.L MACL,@-%s", regname[Rn]);
  299. break;
  300. case 0x13:
  301. sprintf(buffer, "STC.L GBR,@-%s", regname[Rn]);
  302. break;
  303. case 0x15:
  304. sprintf(buffer, "CMP/PL %s", regname[Rn]);
  305. break;
  306. case 0x16:
  307. sprintf(buffer, "LDS.L @%s+,MACL", regname[Rn]);
  308. break;
  309. case 0x17:
  310. sprintf(buffer, "LDC.L @%s+,GBR", regname[Rn]);
  311. break;
  312. case 0x18:
  313. sprintf(buffer, "SHLL8 %s", regname[Rn]);
  314. break;
  315. case 0x19:
  316. sprintf(buffer, "SHLR8 %s", regname[Rn]);
  317. break;
  318. case 0x1a:
  319. sprintf(buffer, "LDS %s,MACL", regname[Rn]);
  320. break;
  321. case 0x1b:
  322. sprintf(buffer, "TAS %s", regname[Rn]);
  323. break;
  324. case 0x1e:
  325. sprintf(buffer, "LDC %s,GBR", regname[Rn]);
  326. break;
  327. case 0x20:
  328. sprintf(buffer, "SHAL %s", regname[Rn]);
  329. break;
  330. case 0x21:
  331. sprintf(buffer, "SHAR %s", regname[Rn]);
  332. break;
  333. case 0x22:
  334. sprintf(buffer, "STS.L PR,@-%s", regname[Rn]);
  335. break;
  336. case 0x23:
  337. sprintf(buffer, "STC.L VBR,@-%s", regname[Rn]);
  338. break;
  339. case 0x24:
  340. sprintf(buffer, "ROTCL %s", regname[Rn]);
  341. break;
  342. case 0x25:
  343. sprintf(buffer, "ROTCR %s", regname[Rn]);
  344. break;
  345. case 0x26:
  346. sprintf(buffer, "LDS.L @%s+,PR", regname[Rn]);
  347. break;
  348. case 0x27:
  349. sprintf(buffer, "LDC.L @%s+,VBR", regname[Rn]);
  350. break;
  351. case 0x28:
  352. sprintf(buffer, "SHLL16 %s", regname[Rn]);
  353. break;
  354. case 0x29:
  355. sprintf(buffer, "SHLR16 %s", regname[Rn]);
  356. break;
  357. case 0x2a:
  358. sprintf(buffer, "LDS %s,PR", regname[Rn]);
  359. break;
  360. case 0x2b:
  361. sprintf(buffer, "JMP %s", regname[Rn]);
  362. break;
  363. case 0x2e:
  364. sprintf(buffer, "LDC %s,VBR", regname[Rn]);
  365. break;
  366. default:
  367. if ((opcode & 15) == 15)
  368. sprintf(buffer, "MAC.W @%s+,@%s+", regname[Rm], regname[Rn]);
  369. else
  370. sprintf(buffer, "?????? $%04X", opcode);
  371. }
  372. return flags;
  373. }
  374. static UINT32 op0101(char *buffer, UINT32 pc, UINT16 opcode)
  375. {
  376. sprintf(buffer, "MOV.L @($%02X,%s),%s", (opcode & 15) * 4, regname[Rm], regname[Rn]);
  377. return 0;
  378. }
  379. static UINT32 op0110(char *buffer, UINT32 pc, UINT16 opcode)
  380. {
  381. switch(opcode & 0xF)
  382. {
  383. case 0x00:
  384. sprintf(buffer, "MOV.B @%s,%s", regname[Rm], regname[Rn]);
  385. break;
  386. case 0x01:
  387. sprintf(buffer, "MOV.W @%s,%s", regname[Rm], regname[Rn]);
  388. break;
  389. case 0x02:
  390. sprintf(buffer, "MOV.L @%s,%s", regname[Rm], regname[Rn]);
  391. break;
  392. case 0x03:
  393. sprintf(buffer, "MOV %s,%s", regname[Rm], regname[Rn]);
  394. break;
  395. case 0x04:
  396. sprintf(buffer, "MOV.B @%s+,%s", regname[Rm], regname[Rn]);
  397. break;
  398. case 0x05:
  399. sprintf(buffer, "MOV.W @%s+,%s", regname[Rm], regname[Rn]);
  400. break;
  401. case 0x06:
  402. sprintf(buffer, "MOV.L @%s+,%s", regname[Rm], regname[Rn]);
  403. break;
  404. case 0x07:
  405. sprintf(buffer, "NOT %s,%s", regname[Rm], regname[Rn]);
  406. break;
  407. case 0x08:
  408. sprintf(buffer, "SWAP.B %s,%s", regname[Rm], regname[Rn]);
  409. break;
  410. case 0x09:
  411. sprintf(buffer, "SWAP.W %s,%s", regname[Rm], regname[Rn]);
  412. break;
  413. case 0x0a:
  414. sprintf(buffer, "NEGC %s,%s", regname[Rm], regname[Rn]);
  415. break;
  416. case 0x0b:
  417. sprintf(buffer, "NEG %s,%s", regname[Rm], regname[Rn]);
  418. break;
  419. case 0x0c:
  420. sprintf(buffer, "EXTU.B %s,%s", regname[Rm], regname[Rn]);
  421. break;
  422. case 0x0d:
  423. sprintf(buffer, "EXTU.W %s,%s", regname[Rm], regname[Rn]);
  424. break;
  425. case 0x0e:
  426. sprintf(buffer, "EXTS.B %s,%s", regname[Rm], regname[Rn]);
  427. break;
  428. case 0x0f:
  429. sprintf(buffer, "EXTS.W %s,%s", regname[Rm], regname[Rn]);
  430. break;
  431. }
  432. return 0;
  433. }
  434. static UINT32 op0111(char *buffer, UINT32 pc, UINT16 opcode)
  435. {
  436. sprintf(buffer, "ADD #$%02X,%s", opcode & 0xff, regname[Rn]);
  437. return 0;
  438. }
  439. static UINT32 op1000(char *buffer, UINT32 pc, UINT16 opcode)
  440. {
  441. switch((opcode >> 8) & 15)
  442. {
  443. case 0:
  444. sprintf(buffer, "MOV.B R0,@($%02X,%s)", (opcode & 15), regname[Rm]);
  445. break;
  446. case 1:
  447. sprintf(buffer, "MOV.W R0,@($%02X,%s)", (opcode & 15) * 2, regname[Rm]);
  448. break;
  449. case 4:
  450. sprintf(buffer, "MOV.B @($%02X,%s),R0", (opcode & 15), regname[Rm]);
  451. break;
  452. case 5:
  453. sprintf(buffer, "MOV.W @($%02X,%s),R0", (opcode & 15) * 2, regname[Rm]);
  454. break;
  455. case 8:
  456. sprintf(buffer, "CMP/EQ #$%02X,R0", (opcode & 0xff));
  457. break;
  458. case 9:
  459. sprintf(buffer, "BT $%08x", pc + SIGNX8(opcode & 0xff) * 2 + 2);
  460. break;
  461. case 11:
  462. sprintf(buffer, "BF $%08x", pc + SIGNX8(opcode & 0xff) * 2 + 2);
  463. break;
  464. case 13:
  465. sprintf(buffer, "BTS $%08x", pc + SIGNX8(opcode & 0xff) * 2 + 2);
  466. break;
  467. case 15:
  468. sprintf(buffer, "BFS $%08x", pc + SIGNX8(opcode & 0xff) * 2 + 2);
  469. break;
  470. default :
  471. sprintf(buffer, "invalid $%04X", opcode);
  472. }
  473. return 0;
  474. }
  475. static UINT32 op1001(char *buffer, UINT32 pc, UINT16 opcode)
  476. {
  477. sprintf(buffer, "MOV.W @($%02X,PC),%s ; @$%08x", (opcode & 0xff) * 2, regname[Rn],
  478. pc + (opcode & 0xff) * 2 + 2);
  479. return 0;
  480. }
  481. static UINT32 op1010(char *buffer, UINT32 pc, UINT16 opcode)
  482. {
  483. sprintf(buffer, "BRA $%08x", SIGNX12(opcode & 0xfff) * 2 + pc + 2);
  484. return 0;
  485. }
  486. static UINT32 op1011(char *buffer, UINT32 pc, UINT16 opcode)
  487. {
  488. sprintf(buffer, "BSR $%08x", SIGNX12(opcode & 0xfff) * 2 + pc + 2);
  489. return DASMFLAG_STEP_OVER | DASMFLAG_STEP_OVER_EXTRA(1);
  490. }
  491. static UINT32 op1100(char *buffer, UINT32 pc, UINT16 opcode)
  492. {
  493. UINT32 flags = 0;
  494. switch((opcode >> 8) & 15)
  495. {
  496. case 0:
  497. sprintf(buffer, "MOV.B R0,@($%02X,GBR)", opcode & 0xff);
  498. break;
  499. case 1:
  500. sprintf(buffer, "MOV.W R0,@($%04X,GBR)", (opcode & 0xff) * 2);
  501. break;
  502. case 2:
  503. sprintf(buffer, "MOV.L R0,@($%04X,GBR)", (opcode & 0xff) * 4);
  504. break;
  505. case 3:
  506. sprintf(buffer, "TRAPA #$%02X", opcode & 0xff);
  507. flags = DASMFLAG_STEP_OVER;
  508. break;
  509. case 4:
  510. sprintf(buffer, "MOV.B @($%02X,GBR),R0", opcode & 0xff);
  511. break;
  512. case 5:
  513. sprintf(buffer, "MOV.W @($%04X,GBR),R0", (opcode & 0xff) * 2);
  514. break;
  515. case 6:
  516. sprintf(buffer, "MOV.L @($%04X,GBR),R0", (opcode & 0xff) * 4);
  517. break;
  518. case 7:
  519. sprintf(buffer, "MOVA @($%04X,PC),R0 ; @$%08x", (opcode & 0xff) * 4,
  520. ((pc + 2) & ~3) + (opcode & 0xff) * 4);
  521. break;
  522. case 8:
  523. sprintf(buffer, "TST #$%02X,R0", opcode & 0xff);
  524. break;
  525. case 9:
  526. sprintf(buffer, "AND #$%02X,R0", opcode & 0xff);
  527. break;
  528. case 10:
  529. sprintf(buffer, "XOR #$%02X,R0", opcode & 0xff);
  530. break;
  531. case 11:
  532. sprintf(buffer, "OR #$%02X,R0", opcode & 0xff);
  533. break;
  534. case 12:
  535. sprintf(buffer, "TST.B #$%02X,@(R0,GBR)", opcode & 0xff);
  536. break;
  537. case 13:
  538. sprintf(buffer, "AND.B #$%02X,@(R0,GBR)", opcode & 0xff);
  539. break;
  540. case 14:
  541. sprintf(buffer, "XOR.B #$%02X,@(R0,GBR)", opcode & 0xff);
  542. break;
  543. case 15:
  544. sprintf(buffer, "OR.B #$%02X,@(R0,GBR)", opcode & 0xff);
  545. break;
  546. }
  547. return flags;
  548. }
  549. static UINT32 op1101(char *buffer, UINT32 pc, UINT16 opcode)
  550. {
  551. sprintf(buffer, "MOV.L @($%02X,PC),%s ; @$%08x", (opcode & 0xff) * 4, regname[Rn],
  552. (pc + (opcode & 0xff) * 4 + 2) & ~3);
  553. return 0;
  554. }
  555. static UINT32 op1110(char *buffer, UINT32 pc, UINT16 opcode)
  556. {
  557. sprintf(buffer, "MOV #$%02X,%s", (opcode & 0xff), regname[Rn]);
  558. return 0;
  559. }
  560. static UINT32 op1111(char *buffer, UINT32 pc, UINT16 opcode)
  561. {
  562. sprintf(buffer, "unknown $%04X", opcode);
  563. return 0;
  564. }
  565. unsigned DasmSH2(char *buffer, unsigned pc, UINT16 opcode)
  566. {
  567. UINT32 flags;
  568. pc += 2;
  569. switch((opcode >> 12) & 15)
  570. {
  571. case 0: flags = op0000(buffer,pc,opcode); break;
  572. case 1: flags = op0001(buffer,pc,opcode); break;
  573. case 2: flags = op0010(buffer,pc,opcode); break;
  574. case 3: flags = op0011(buffer,pc,opcode); break;
  575. case 4: flags = op0100(buffer,pc,opcode); break;
  576. case 5: flags = op0101(buffer,pc,opcode); break;
  577. case 6: flags = op0110(buffer,pc,opcode); break;
  578. case 7: flags = op0111(buffer,pc,opcode); break;
  579. case 8: flags = op1000(buffer,pc,opcode); break;
  580. case 9: flags = op1001(buffer,pc,opcode); break;
  581. case 10: flags = op1010(buffer,pc,opcode); break;
  582. case 11: flags = op1011(buffer,pc,opcode); break;
  583. case 12: flags = op1100(buffer,pc,opcode); break;
  584. case 13: flags = op1101(buffer,pc,opcode); break;
  585. case 14: flags = op1110(buffer,pc,opcode); break;
  586. default: flags = op1111(buffer,pc,opcode); break;
  587. }
  588. (void)flags;
  589. return 0;//2 | flags | DASMFLAG_SUPPORTED;
  590. }
  591. #if 0
  592. #define swab32(x) (((x) << 24) | (((x) << 8) & 0xff0000) | (((x) >> 8) & 0xff00) | ((x) >> 24))
  593. #define swab16(x) ((((x) << 8) & 0xff00) | (((x) >> 8) & 0x00ff))
  594. int main(int argc, char *argv[])
  595. {
  596. unsigned short op;
  597. char buff[256];
  598. unsigned pc;
  599. FILE *f;
  600. int ret;
  601. if (argv[1] == NULL) {
  602. printf("usage\n%s <file>\n", argv[0]);
  603. return 1;
  604. }
  605. f = fopen(argv[1], "rb");
  606. if (f == NULL) {
  607. fprintf(stderr, "can't open %s\n", argv[1]);
  608. return 1;
  609. }
  610. for (pc = 0x140;; pc += 2)
  611. {
  612. fseek(f, pc, SEEK_SET);
  613. ret = fread(&op, 1, sizeof(op), f);
  614. if (ret != sizeof(op))
  615. break;
  616. DasmSH2(buff, pc, swab16(op));
  617. printf("%06x %04x %s\n", pc, swab16(op), buff);
  618. }
  619. fclose(f);
  620. return 0;
  621. }
  622. #endif