sparc64db.c 21 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078
  1. #include <u.h>
  2. #include <libc.h>
  3. #include <bio.h>
  4. #include <mach.h>
  5. /*
  6. * Sparc64-specific debugger interface
  7. */
  8. static char *sparc64excep(Map*, Rgetter);
  9. static int sparc64foll(Map*, uvlong, Rgetter, uvlong*);
  10. static int sparc64inst(Map*, uvlong, char, char*, int);
  11. static int sparc64das(Map*, uvlong, char*, int);
  12. static int sparc64instlen(Map*, uvlong);
  13. Machdata sparc64mach =
  14. {
  15. {0x91, 0xd0, 0x20, 0x01}, /* breakpoint: TA $1 */
  16. 4, /* break point size */
  17. beswab, /* convert short to local byte order */
  18. beswal, /* convert long to local byte order */
  19. beswav, /* convert vlong to local byte order */
  20. risctrace, /* C traceback */
  21. riscframe, /* frame finder */
  22. sparc64excep, /* print exception */
  23. 0, /* breakpoint fixup */
  24. beieeesftos, /* single precision float printer */
  25. beieeedftos, /* double precision float printer */
  26. sparc64foll, /* following addresses */
  27. sparc64inst, /* print instruction */
  28. sparc64das, /* dissembler */
  29. sparc64instlen, /* instruction size */
  30. };
  31. static char *trapname[] =
  32. {
  33. 0,
  34. "power on reset",
  35. "watchdog reset",
  36. "external reset",
  37. "software reset",
  38. "RED",
  39. 0, 0,
  40. "instruction access exception",
  41. "instruction access MMU miss",
  42. "instruction access error",
  43. 0, 0, 0, 0, 0,
  44. "illegal instruction",
  45. "privileged opcode",
  46. "unimplemented LDD",
  47. "unimplemented STD",
  48. 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  49. "fp disabled",
  50. "fp exception ieee 754",
  51. "fp exception other",
  52. 0, 0, 0, 0,
  53. "division by zero",
  54. "internal processor error",
  55. 0, 0, 0, 0, 0, 0,
  56. "data access exception",
  57. "data access MMU miss",
  58. "data access error",
  59. "data access protection",
  60. "mem address not aligned",
  61. "LDDF mem address not aligned",
  62. "STDF mem address not aligned",
  63. "privileged action",
  64. "LDQF mem address nto aligned",
  65. "STQF mem address not aligned",
  66. };
  67. static char*
  68. excname(ulong tt)
  69. {
  70. static char buf[32];
  71. if(tt < sizeof trapname/sizeof(char*) && trapname[tt])
  72. return trapname[tt];
  73. if(tt >= 258)
  74. sprint(buf, "trap instruction %ld", tt-128);
  75. else if(65<=tt && tt<=79)
  76. sprint(buf, "interrupt level %ld", tt-64);
  77. else switch(tt){
  78. case 64:
  79. return "async data error";
  80. case 96:
  81. return "mondo interrupt";
  82. case 100:
  83. return "instruction access MMU miss";
  84. case 104:
  85. return "data access MMU miss";
  86. case 108:
  87. return "data access protection";
  88. case 256:
  89. return "syscall";
  90. case 257:
  91. return "breakpoint";
  92. default:
  93. sprint(buf, "unknown trap %ld", tt);
  94. }
  95. return buf;
  96. }
  97. static char*
  98. sparc64excep(Map *map, Rgetter rget)
  99. {
  100. long tt;
  101. tt = (*rget)(map, "TT");
  102. return excname(tt);
  103. }
  104. /* Sparc disassembler and related functions */
  105. struct opcode {
  106. char *mnemonic;
  107. void (*f)(struct instr*, char*);
  108. int flag;
  109. };
  110. static char FRAMENAME[] = ".frame";
  111. typedef struct instr Instr;
  112. struct instr {
  113. uchar op; /* bits 31-30 */
  114. uchar rd; /* bits 29-25 */
  115. uchar op2; /* bits 24-22 */
  116. uchar a; /* bit 29 */
  117. uchar cond; /* bits 28-25 */
  118. uchar op3; /* bits 24-19 */
  119. uchar rs1; /* bits 18-14 */
  120. uchar i; /* bit 13 */
  121. uchar asi; /* bits 12-05 */
  122. uchar rs2; /* bits 04-00 */
  123. short simm13; /* bits 12-00, signed */
  124. ushort opf; /* bits 13-05 */
  125. ulong immdisp22; /* bits 21-00 */
  126. ulong simmdisp22; /* bits 21-00, signed */
  127. ulong disp30; /* bits 30-00 */
  128. ulong imm32; /* SETHI+ADD constant */
  129. int target; /* SETHI+ADD dest reg */
  130. long w0;
  131. long w1;
  132. uvlong addr; /* pc of instruction */
  133. char *curr; /* current fill level in output buffer */
  134. char *end; /* end of buffer */
  135. int size; /* number of longs in instr */
  136. char *err; /* errmsg */
  137. };
  138. static Map *mymap; /* disassembler context */
  139. static int dascase;
  140. static int mkinstr(uvlong, Instr*);
  141. static void bra1(Instr*, char*, char*[]);
  142. static void bra(Instr*, char*);
  143. static void fbra(Instr*, char*);
  144. static void cbra(Instr*, char*);
  145. static void unimp(Instr*, char*);
  146. static void fpop(Instr*, char*);
  147. static void shift(Instr*, char*);
  148. static void sethi(Instr*, char*);
  149. static void load(Instr*, char*);
  150. static void loada(Instr*, char*);
  151. static void store(Instr*, char*);
  152. static void storea(Instr*, char*);
  153. static void add(Instr*, char*);
  154. static void cmp(Instr*, char*);
  155. static void wr(Instr*, char*);
  156. static void jmpl(Instr*, char*);
  157. static void rd(Instr*, char*);
  158. static void loadf(Instr*, char*);
  159. static void storef(Instr*, char*);
  160. static void loadc(Instr*, char*);
  161. static void loadcsr(Instr*, char*);
  162. static void trap(Instr*, char*);
  163. static struct opcode sparc64op0[8] = {
  164. [0] "UNIMP", unimp, 0, /* page 137 */
  165. [2] "B", bra, 0, /* page 119 */
  166. [4] "SETHI", sethi, 0, /* page 104 */
  167. [6] "FB", fbra, 0, /* page 121 */
  168. [7] "CB", cbra, 0, /* page 123 */
  169. };
  170. static struct opcode sparc64op2[64] = {
  171. [0x00] "ADD", add, 0, /* page 108 */
  172. [0x10] "ADDCC", add, 0,
  173. [0x08] "ADDX", add, 0,
  174. [0x18] "ADDXCC", add, 0,
  175. [0x20] "TADD", add, 0, /* page 109 */
  176. [0x22] "TADDCCTV", add, 0,
  177. [0x04] "SUB", add, 0, /* page 110 */
  178. [0x14] "SUBCC", cmp, 0,
  179. [0x0C] "SUBX", add, 0,
  180. [0x1C] "SUBXCC", add, 0,
  181. [0x21] "TSUB", add, 0, /* page 111 */
  182. [0x23] "TSUBCCTV", add, 0,
  183. [0x24] "MULSCC", add, 0, /* page 112 */
  184. [0x0A] "UMUL", add, 0, /* page 113 */
  185. [0x0B] "SMUL", add, 0,
  186. [0x1A] "UMULCC", add, 0,
  187. [0x1B] "SMULCC", add, 0,
  188. [0x0E] "UDIV", add, 0, /* page 115 */
  189. [0x0F] "SDIV", add, 0,
  190. [0x1E] "UDIVCC", add, 0,
  191. [0x1F] "SDIVCC", add, 0,
  192. [0x01] "AND", add, 0, /* page 106 */
  193. [0x11] "ANDCC", add, 0,
  194. [0x05] "ANDN", add, 0,
  195. [0x15] "ANDNCC", add, 0,
  196. [0x02] "OR", add, 0,
  197. [0x12] "ORCC", add, 0,
  198. [0x06] "ORN", add, 0,
  199. [0x16] "ORNCC", add, 0,
  200. [0x03] "XOR", add, 0,
  201. [0x13] "XORCC", add, 0,
  202. [0x07] "XORN", add, 0,
  203. [0x17] "XORNCC", add, 0,
  204. [0x25] "SLL", shift, 0, /* page 107 */
  205. [0x26] "SRL", shift, 0,
  206. [0x27] "SRA", shift, 0,
  207. [0x3C] "SAVE", add, 0, /* page 117 */
  208. [0x3D] "RESTORE", add, 0,
  209. [0x38] "JMPL", jmpl, 0, /* page 126 */
  210. [0x39] "RETT", add, 0, /* page 127 */
  211. [0x3A] "T", trap, 0, /* page 129 */
  212. [0x28] "rdy", rd, 0, /* page 131 */
  213. [0x29] "rdpsr", rd, 0,
  214. [0x2A] "rdwim", rd, 0,
  215. [0x2B] "rdtbr", rd, 0,
  216. [0x30] "wry", wr, 0, /* page 133 */
  217. [0x31] "wrpsr", wr, 0,
  218. [0x32] "wrwim", wr, 0,
  219. [0x33] "wrtbr", wr, 0,
  220. [0x3B] "flush", add, 0, /* page 138 */
  221. [0x34] "FPOP", fpop, 0, /* page 140 */
  222. [0x35] "FPOP", fpop, 0,
  223. };
  224. static struct opcode sparc64op3[64]={
  225. [0x09] "ldsb", load, 0, /* page 90 */
  226. [0x19] "ldsba", loada, 0,
  227. [0x0A] "ldsh", load, 0,
  228. [0x1A] "ldsha", loada, 0,
  229. [0x01] "ldub", load, 0,
  230. [0x11] "lduba", loada, 0,
  231. [0x02] "lduh", load, 0,
  232. [0x12] "lduha", loada, 0,
  233. [0x00] "ld", load, 0,
  234. [0x10] "lda", loada, 0,
  235. [0x03] "ldd", load, 0,
  236. [0x13] "ldda", loada, 0,
  237. [0x20] "ldf", loadf, 0, /* page 92 */
  238. [0x23] "lddf", loadf, 0,
  239. [0x21] "ldfsr", loadf,0,
  240. [0x30] "ldc", loadc, 0, /* page 94 */
  241. [0x33] "lddc", loadc, 0,
  242. [0x31] "ldcsr", loadcsr,0,
  243. [0x05] "stb", store, 0, /* page 95 */
  244. [0x15] "stba", storea, 0,
  245. [0x06] "sth", store, 0,
  246. [0x16] "stha", storea, 0,
  247. [0x04] "st", store, 0,
  248. [0x14] "sta", storea, 0,
  249. [0x07] "std", store, 0,
  250. [0x17] "stda", storea, 0,
  251. [0x24] "stf", storef, 0, /* page 97 */
  252. [0x27] "stdf", storef, 0,
  253. [0x25] "stfsr", storef,0,
  254. [0x26] "stdfq", storef,0,
  255. [0x34] "stc", loadc, 0, /* page 99 */
  256. [0x37] "stdc", loadc, 0,
  257. [0x35] "stcsr", loadcsr,0,
  258. [0x36] "stdcq", loadcsr,0,
  259. [0x0D] "ldstub", store, 0, /* page 101 */
  260. [0x1D] "ldstuba", storea, 0,
  261. [0x0F] "swap", load, 0, /* page 102 */
  262. [0x1F] "swapa", loada, 0,
  263. };
  264. #pragma varargck argpos bprint 2
  265. #pragma varargck type "T" char*
  266. /* convert to lower case from upper, according to dascase */
  267. static int
  268. Tfmt(Fmt *f)
  269. {
  270. char buf[128];
  271. char *s, *t, *oa;
  272. oa = va_arg(f->args, char*);
  273. if(dascase){
  274. for(s=oa,t=buf; *t = *s; s++,t++)
  275. if('A'<=*t && *t<='Z')
  276. *t += 'a'-'A';
  277. return fmtstrcpy(f, buf);
  278. }
  279. return fmtstrcpy(f, oa);
  280. }
  281. static void
  282. bprint(Instr *i, char *fmt, ...)
  283. {
  284. va_list arg;
  285. va_start(arg, fmt);
  286. i->curr = vseprint(i->curr, i->end, fmt, arg);
  287. va_end(arg);
  288. }
  289. static int
  290. decode(ulong pc, Instr *i)
  291. {
  292. ulong w;
  293. if (get4(mymap, pc, &w) < 0) {
  294. werrstr("can't read instruction: %r");
  295. return -1;
  296. }
  297. i->op = (w >> 30) & 0x03;
  298. i->rd = (w >> 25) & 0x1F;
  299. i->op2 = (w >> 22) & 0x07;
  300. i->a = (w >> 29) & 0x01;
  301. i->cond = (w >> 25) & 0x0F;
  302. i->op3 = (w >> 19) & 0x3F;
  303. i->rs1 = (w >> 14) & 0x1F;
  304. i->i = (w >> 13) & 0x01;
  305. i->asi = (w >> 5) & 0xFF;
  306. i->rs2 = (w >> 0) & 0x1F;
  307. i->simm13 = (w >> 0) & 0x1FFF;
  308. if(i->simm13 & (1<<12))
  309. i->simm13 |= ~((1<<13)-1);
  310. i->opf = (w >> 5) & 0x1FF;
  311. i->immdisp22 = (w >> 0) & 0x3FFFFF;
  312. i->simmdisp22 = i->immdisp22;
  313. if(i->simmdisp22 & (1<<21))
  314. i->simmdisp22 |= ~((1<<22)-1);
  315. i->disp30 = (w >> 0) & 0x3FFFFFFF;
  316. i->w0 = w;
  317. i->target = -1;
  318. i->addr = pc;
  319. i->size = 1;
  320. return 1;
  321. }
  322. static int
  323. mkinstr(uvlong pc, Instr *i)
  324. {
  325. Instr xi;
  326. if (decode(pc, i) < 0)
  327. return -1;
  328. if(i->op==0 && i->op2==4 && !dascase){ /* SETHI */
  329. if (decode(pc+4, &xi) < 0)
  330. return -1;
  331. if(xi.op==2 && xi.op3==0) /* ADD */
  332. if(xi.i == 1 && xi.rs1 == i->rd){ /* immediate to same reg */
  333. i->imm32 = xi.simm13 + (i->immdisp22<<10);
  334. i->target = xi.rd;
  335. i->w1 = xi.w0;
  336. i->size++;
  337. return 1;
  338. }
  339. }
  340. if(i->op==2 && i->opf==1 && !dascase){ /* FMOVS */
  341. if (decode(pc+4, &xi) < 0)
  342. return -1;
  343. if(i->op==2 && i->opf==1) /* FMOVS */
  344. if(xi.rd==i->rd+1 && xi.rs2==i->rs2+1){ /* next pair */
  345. i->w1 = xi.w0;
  346. i->size++;
  347. }
  348. }
  349. return 1;
  350. }
  351. static int
  352. printins(Map *map, uvlong pc, char *buf, int n)
  353. {
  354. Instr instr;
  355. void (*f)(Instr*, char*);
  356. mymap = map;
  357. memset(&instr, 0, sizeof(instr));
  358. instr.curr = buf;
  359. instr.end = buf+n-1;
  360. if (mkinstr(pc, &instr) < 0)
  361. return -1;
  362. switch(instr.op){
  363. case 0:
  364. f = sparc64op0[instr.op2].f;
  365. if(f)
  366. (*f)(&instr, sparc64op0[instr.op2].mnemonic);
  367. else
  368. bprint(&instr, "unknown %lux", instr.w0);
  369. break;
  370. case 1:
  371. bprint(&instr, "CALL\t");
  372. instr.curr += symoff(instr.curr, instr.end-instr.curr,
  373. pc+instr.disp30*4, CTEXT);
  374. if (!dascase)
  375. bprint(&instr, "(SB)");
  376. break;
  377. case 2:
  378. f = sparc64op2[instr.op3].f;
  379. if(f)
  380. (*f)(&instr, sparc64op2[instr.op3].mnemonic);
  381. else
  382. bprint(&instr, "unknown %lux", instr.w0);
  383. break;
  384. case 3:
  385. f = sparc64op3[instr.op3].f;
  386. if(f)
  387. (*f)(&instr, sparc64op3[instr.op3].mnemonic);
  388. else
  389. bprint(&instr, "unknown %lux", instr.w0);
  390. break;
  391. }
  392. if (instr.err) {
  393. if (instr.curr != buf)
  394. bprint(&instr, "\t\t;");
  395. bprint(&instr, instr.err);
  396. }
  397. return instr.size*4;
  398. }
  399. static int
  400. sparc64inst(Map *map, uvlong pc, char modifier, char *buf, int n)
  401. {
  402. static int fmtinstalled = 0;
  403. /* a modifier of 'I' toggles the dissassembler type */
  404. if (!fmtinstalled) {
  405. fmtinstalled = 1;
  406. fmtinstall('T', Tfmt);
  407. }
  408. if ((asstype == ASUNSPARC && modifier == 'i')
  409. || (asstype == ASPARC && modifier == 'I'))
  410. dascase = 'a'-'A';
  411. else
  412. dascase = 0;
  413. return printins(map, pc, buf, n);
  414. }
  415. static int
  416. sparc64das(Map *map, uvlong pc, char *buf, int n)
  417. {
  418. Instr instr;
  419. mymap = map;
  420. memset(&instr, 0, sizeof(instr));
  421. instr.curr = buf;
  422. instr.end = buf+n-1;
  423. if (mkinstr(pc, &instr) < 0)
  424. return -1;
  425. if (instr.end-instr.curr > 8)
  426. instr.curr = _hexify(instr.curr, instr.w0, 7);
  427. if (instr.end-instr.curr > 9 && instr.size == 2) {
  428. *instr.curr++ = ' ';
  429. instr.curr = _hexify(instr.curr, instr.w1, 7);
  430. }
  431. *instr.curr = 0;
  432. return instr.size*4;
  433. }
  434. static int
  435. sparc64instlen(Map *map, uvlong pc)
  436. {
  437. Instr i;
  438. mymap = map;
  439. if (mkinstr(pc, &i) < 0)
  440. return -1;
  441. return i.size*4;
  442. }
  443. static int
  444. plocal(Instr *i)
  445. {
  446. long offset;
  447. Symbol s;
  448. if (!findsym(i->addr, CTEXT, &s) || !findlocal(&s, FRAMENAME, &s))
  449. return -1;
  450. if (s.value > i->simm13) {
  451. if(getauto(&s, s.value-i->simm13, CAUTO, &s)) {
  452. bprint(i, "%s+%lld(SP)", s.name, s.value);
  453. return 1;
  454. }
  455. } else {
  456. offset = i->simm13-s.value;
  457. if (getauto(&s, offset-4, CPARAM, &s)) {
  458. bprint(i, "%s+%ld(FP)", s.name, offset);
  459. return 1;
  460. }
  461. }
  462. return -1;
  463. }
  464. static void
  465. address(Instr *i)
  466. {
  467. Symbol s, s2;
  468. uvlong off, off1;
  469. if (i->rs1 == 1 && plocal(i) >= 0)
  470. return;
  471. off = mach->sb+i->simm13;
  472. if(i->rs1 == 2 && findsym(off, CANY, &s)
  473. && s.value-off < 4096
  474. && (s.class == CDATA || s.class == CTEXT)) {
  475. if(off==s.value && s.name[0]=='$'){
  476. off1 = 0;
  477. geta(mymap, s.value, &off1);
  478. if(off1 && findsym(off1, CANY, &s2) && s2.value == off1){
  479. bprint(i, "$%s(SB)", s2.name);
  480. return;
  481. }
  482. }
  483. bprint(i, "%s", s.name);
  484. if (s.value != off)
  485. bprint(i, "+%llux", s.value-off);
  486. bprint(i, "(SB)");
  487. return;
  488. }
  489. bprint(i, "%ux(R%d)", i->simm13, i->rs1);
  490. }
  491. static void
  492. unimp(Instr *i, char *m)
  493. {
  494. bprint(i, "%T", m);
  495. }
  496. static char *bratab[16] = { /* page 91 */
  497. [0X8] "A",
  498. [0X0] "N",
  499. [0X9] "NE",
  500. [0X1] "E",
  501. [0XA] "G",
  502. [0X2] "LE",
  503. [0XB] "GE",
  504. [0X3] "L",
  505. [0XC] "GU",
  506. [0X4] "LEU",
  507. [0XD] "CC",
  508. [0X5] "CS",
  509. [0XE] "POS",
  510. [0X6] "NEG",
  511. [0XF] "VC",
  512. [0X7] "VS",
  513. };
  514. static char *fbratab[16] = { /* page 91 */
  515. [0X8] "A",
  516. [0X0] "N",
  517. [0X7] "U",
  518. [0X6] "G",
  519. [0X5] "UG",
  520. [0X4] "L",
  521. [0X3] "UL",
  522. [0X2] "LG",
  523. [0X1] "NE",
  524. [0X9] "E",
  525. [0XA] "UE",
  526. [0XB] "GE",
  527. [0XC] "UGE",
  528. [0XD] "LE",
  529. [0XE] "ULE",
  530. [0XF] "O",
  531. };
  532. static char *cbratab[16] = { /* page 91 */
  533. [0X8] "A",
  534. [0X0] "N",
  535. [0X7] "3",
  536. [0X6] "2",
  537. [0X5] "23",
  538. [0X4] "1",
  539. [0X3] "13",
  540. [0X2] "12",
  541. [0X1] "123",
  542. [0X9] "0",
  543. [0XA] "03",
  544. [0XB] "02",
  545. [0XC] "023",
  546. [0XD] "01",
  547. [0XE] "013",
  548. [0XF] "012",
  549. };
  550. static void
  551. bra1(Instr *i, char *m, char *tab[])
  552. {
  553. long imm;
  554. imm = i->simmdisp22;
  555. if(i->a)
  556. bprint(i, "%T%T.%c\t", m, tab[i->cond], 'A'+dascase);
  557. else
  558. bprint(i, "%T%T\t", m, tab[i->cond]);
  559. i->curr += symoff(i->curr, i->end-i->curr, i->addr+4*imm, CTEXT);
  560. if (!dascase)
  561. bprint(i, "(SB)");
  562. }
  563. static void
  564. bra(Instr *i, char *m) /* page 91 */
  565. {
  566. bra1(i, m, bratab);
  567. }
  568. static void
  569. fbra(Instr *i, char *m) /* page 93 */
  570. {
  571. bra1(i, m, fbratab);
  572. }
  573. static void
  574. cbra(Instr *i, char *m) /* page 95 */
  575. {
  576. bra1(i, m, cbratab);
  577. }
  578. static void
  579. trap(Instr *i, char *m) /* page 101 */
  580. {
  581. if(i->i == 0)
  582. bprint(i, "%T%T\tR%d+R%d", m, bratab[i->cond], i->rs2, i->rs1);
  583. else
  584. bprint(i, "%T%T\t$%ux+R%d", m, bratab[i->cond], i->simm13, i->rs1);
  585. }
  586. static void
  587. sethi(Instr *i, char *m) /* page 89 */
  588. {
  589. ulong imm;
  590. imm = i->immdisp22<<10;
  591. if(dascase){
  592. bprint(i, "%T\t%lux, R%d", m, imm, i->rd);
  593. return;
  594. }
  595. if(imm==0 && i->rd==0){
  596. bprint(i, "NOP");
  597. return;
  598. }
  599. if(i->target < 0){
  600. bprint(i, "MOVW\t$%lux, R%d", imm, i->rd);
  601. return;
  602. }
  603. bprint(i, "MOVW\t$%lux, R%d", i->imm32, i->target);
  604. }
  605. static char ldtab[] = {
  606. 'W',
  607. 'B',
  608. 'H',
  609. 'D',
  610. };
  611. static char*
  612. moveinstr(int op3, char *m)
  613. {
  614. char *s;
  615. int c;
  616. static char buf[8];
  617. if(!dascase){
  618. /* batshit cases */
  619. if(op3 == 0xF || op3 == 0x1F)
  620. return "SWAP";
  621. if(op3 == 0xD || op3 == 0x1D)
  622. return "TAS"; /* really LDSTUB */
  623. c = ldtab[op3&3];
  624. s = "";
  625. if((op3&11)==1 || (op3&11)==2)
  626. s="U";
  627. sprint(buf, "MOV%c%s", c, s);
  628. return buf;
  629. }
  630. return m;
  631. }
  632. static void
  633. load(Instr *i, char *m) /* page 68 */
  634. {
  635. m = moveinstr(i->op3, m);
  636. if(i->i == 0)
  637. bprint(i, "%s\t(R%d+R%d), R%d", m, i->rs1, i->rs2, i->rd);
  638. else{
  639. bprint(i, "%s\t", m);
  640. address(i);
  641. bprint(i, ", R%d", i->rd);
  642. }
  643. }
  644. static void
  645. loada(Instr *i, char *m) /* page 68 */
  646. {
  647. m = moveinstr(i->op3, m);
  648. if(i->i == 0)
  649. bprint(i, "%s\t(R%d+R%d, %d), R%d", m, i->rs1, i->rs2, i->asi, i->rd);
  650. else
  651. bprint(i, "unknown ld asi %lux", i->w0);
  652. }
  653. static void
  654. store(Instr *i, char *m) /* page 74 */
  655. {
  656. m = moveinstr(i->op3, m);
  657. if(i->i == 0)
  658. bprint(i, "%s\tR%d, (R%d+R%d)",
  659. m, i->rd, i->rs1, i->rs2);
  660. else{
  661. bprint(i, "%s\tR%d, ", m, i->rd);
  662. address(i);
  663. }
  664. }
  665. static void
  666. storea(Instr *i, char *m) /* page 74 */
  667. {
  668. m = moveinstr(i->op3, m);
  669. if(i->i == 0)
  670. bprint(i, "%s\tR%d, (R%d+R%d, %d)", m, i->rd, i->rs1, i->rs2, i->asi);
  671. else
  672. bprint(i, "%s\tR%d, %d(R%d, %d), ???", m, i->rd, i->simm13, i->rs1, i->asi);
  673. }
  674. static void
  675. shift(Instr *i, char *m) /* page 88 */
  676. {
  677. if(i->i == 0){
  678. if(i->rs1 == i->rd)
  679. if(dascase)
  680. bprint(i, "%T\tR%d, R%d", m, i->rs1, i->rs2);
  681. else
  682. bprint(i, "%T\tR%d, R%d", m, i->rs2, i->rs1);
  683. else
  684. if(dascase)
  685. bprint(i, "%T\tR%d, R%d, R%d", m, i->rs1, i->rs2, i->rd);
  686. else
  687. bprint(i, "%T\tR%d, R%d, R%d", m, i->rs2, i->rs1, i->rd);
  688. }else{
  689. if(i->rs1 == i->rd)
  690. if(dascase)
  691. bprint(i, "%T\t$%d,R%d", m, i->simm13&0x1F, i->rs1);
  692. else
  693. bprint(i, "%T\tR%d, $%d", m, i->rs1, i->simm13&0x1F);
  694. else
  695. if(dascase)
  696. bprint(i, "%T\tR%d, $%d, R%d",m,i->rs1,i->simm13&0x1F,i->rd);
  697. else
  698. bprint(i, "%T\t$%d, R%d, R%d",m,i->simm13&0x1F,i->rs1,i->rd);
  699. }
  700. }
  701. static void
  702. add(Instr *i, char *m) /* page 82 */
  703. {
  704. if(i->i == 0){
  705. if(dascase)
  706. bprint(i, "%T\tR%d, R%d", m, i->rs1, i->rs2);
  707. else
  708. if(i->op3==2 && i->rs1==0 && i->rd) /* OR R2, R0, R1 */
  709. bprint(i, "MOVW\tR%d", i->rs2);
  710. else
  711. bprint(i, "%T\tR%d, R%d", m, i->rs2, i->rs1);
  712. }else{
  713. if(dascase)
  714. bprint(i, "%T\tR%d, $%ux", m, i->rs1, i->simm13);
  715. else
  716. if(i->op3==0 && i->rd && i->rs1==0) /* ADD $x, R0, R1 */
  717. bprint(i, "MOVW\t$%ux", i->simm13);
  718. else if(i->op3==0 && i->rd && i->rs1==2){
  719. /* ADD $x, R2, R1 -> MOVW $x(SB), R1 */
  720. bprint(i, "MOVW\t$");
  721. address(i);
  722. } else
  723. bprint(i, "%T\t$%ux, R%d", m, i->simm13, i->rs1);
  724. }
  725. if(i->rs1 != i->rd)
  726. bprint(i, ", R%d", i->rd);
  727. }
  728. static void
  729. cmp(Instr *i, char *m)
  730. {
  731. if(dascase || i->rd){
  732. add(i, m);
  733. return;
  734. }
  735. if(i->i == 0)
  736. bprint(i, "CMP\tR%d, R%d", i->rs1, i->rs2);
  737. else
  738. bprint(i, "CMP\tR%d, $%ux", i->rs1, i->simm13);
  739. }
  740. static char *regtab[4] = {
  741. "Y",
  742. "PSTATE",
  743. "WIM", /* XXX not any more */
  744. "TT",
  745. };
  746. static void
  747. wr(Instr *i, char *m) /* page 82 */
  748. {
  749. if(dascase){
  750. if(i->i == 0)
  751. bprint(i, "%s\tR%d, R%d", m, i->rs1, i->rs2);
  752. else
  753. bprint(i, "%s\tR%d, $%ux", m, i->rs1, i->simm13);
  754. }else{
  755. if(i->i && i->simm13==0)
  756. bprint(i, "MOVW\tR%d", i->rs1);
  757. else if(i->i == 0)
  758. bprint(i, "wr\tR%d, R%d", i->rs2, i->rs1);
  759. else
  760. bprint(i, "wr\t$%ux, R%d", i->simm13, i->rs1);
  761. }
  762. bprint(i, ", %s", regtab[i->op3&3]);
  763. }
  764. static void
  765. rd(Instr *i, char *m) /* page 103 */
  766. {
  767. if(i->rs1==15 && i->rd==0){
  768. m = "stbar";
  769. if(!dascase)
  770. m = "STBAR";
  771. bprint(i, "%s", m);
  772. }else{
  773. if(!dascase)
  774. m = "MOVW";
  775. bprint(i, "%s\t%s, R%d", m, regtab[i->op3&3], i->rd);
  776. }
  777. }
  778. static void
  779. jmpl(Instr *i, char *m) /* page 82 */
  780. {
  781. if(i->i == 0){
  782. if(i->rd == 15)
  783. bprint(i, "%T\t(R%d+R%d)", "CALL", i->rs2, i->rs1);
  784. else
  785. bprint(i, "%T\t(R%d+R%d), R%d", m, i->rs2, i->rs1, i->rd);
  786. }else{
  787. if(!dascase && i->simm13==8 && i->rs1==15 && i->rd==0)
  788. bprint(i, "RETURN");
  789. else{
  790. bprint(i, "%T\t", m);
  791. address(i);
  792. bprint(i, ", R%d", i->rd);
  793. }
  794. }
  795. }
  796. static void
  797. loadf(Instr *i, char *m) /* page 70 */
  798. {
  799. if(!dascase){
  800. m = "FMOVD";
  801. if(i->op3 == 0x20)
  802. m = "FMOVF";
  803. else if(i->op3 == 0x21)
  804. m = "MOVW";
  805. }
  806. if(i->i == 0)
  807. bprint(i, "%s\t(R%d+R%d)", m, i->rs1, i->rs2);
  808. else{
  809. bprint(i, "%s\t", m);
  810. address(i);
  811. }
  812. if(i->op3 == 0x21)
  813. bprint(i, ", FSR");
  814. else
  815. bprint(i, ", R%d", i->rd);
  816. }
  817. static
  818. void storef(Instr *i, char *m) /* page 70 */
  819. {
  820. if(!dascase){
  821. m = "FMOVD";
  822. if(i->op3 == 0x25 || i->op3 == 0x26)
  823. m = "MOVW";
  824. else if(i->op3 == 0x20)
  825. m = "FMOVF";
  826. }
  827. bprint(i, "%s\t", m);
  828. if(i->op3 == 0x25)
  829. bprint(i, "FSR, ");
  830. else if(i->op3 == 0x26)
  831. bprint(i, "FQ, ");
  832. else
  833. bprint(i, "R%d, ", i->rd);
  834. if(i->i == 0)
  835. bprint(i, "(R%d+R%d)", i->rs1, i->rs2);
  836. else
  837. address(i);
  838. }
  839. static
  840. void loadc(Instr *i, char *m) /* page 72 */
  841. {
  842. if(i->i == 0)
  843. bprint(i, "%s\t(R%d+R%d), C%d", m, i->rs1, i->rs2, i->rd);
  844. else{
  845. bprint(i, "%s\t", m);
  846. address(i);
  847. bprint(i, ", C%d", i->rd);
  848. }
  849. }
  850. static
  851. void loadcsr(Instr *i, char *m) /* page 72 */
  852. {
  853. if(i->i == 0)
  854. bprint(i, "%s\t(R%d+R%d), CSR", m, i->rs1, i->rs2);
  855. else{
  856. bprint(i, "%s\t", m);
  857. address(i);
  858. bprint(i, ", CSR");
  859. }
  860. }
  861. static struct{
  862. int opf;
  863. char *name;
  864. } fptab1[] = { /* ignores rs1 */
  865. 0xC4, "FITOS", /* page 109 */
  866. 0xC8, "FITOD",
  867. 0xCC, "FITOX",
  868. 0xD1, "FSTOI", /* page 110 */
  869. 0xD2, "FDTOI",
  870. 0xD3, "FXTOI",
  871. 0xC9, "FSTOD", /* page 111 */
  872. 0xCD, "FSTOX",
  873. 0xC6, "FDTOS",
  874. 0xCE, "FDTOX",
  875. 0xC7, "FXTOS",
  876. 0xCB, "FXTOD",
  877. 0x01, "FMOVS", /* page 112 */
  878. 0x05, "FNEGS",
  879. 0x09, "FABSS",
  880. 0x29, "FSQRTS", /* page 113 */
  881. 0x2A, "FSQRTD",
  882. 0x2B, "FSQRTX",
  883. 0, 0,
  884. };
  885. static struct{
  886. int opf;
  887. char *name;
  888. } fptab2[] = { /* uses rs1 */
  889. 0x41, "FADDS", /* page 114 */
  890. 0x42, "FADDD",
  891. 0x43, "FADDX",
  892. 0x45, "FSUBS",
  893. 0x46, "FSUBD",
  894. 0x47, "FSUBX",
  895. 0x49, "FMULS", /* page 115 */
  896. 0x4A, "FMULD",
  897. 0x4B, "FMULX",
  898. 0x4D, "FDIVS",
  899. 0x4E, "FDIVD",
  900. 0x4F, "FDIVX",
  901. 0x51, "FCMPS", /* page 116 */
  902. 0x52, "FCMPD",
  903. 0x53, "FCMPX",
  904. 0x55, "FCMPES",
  905. 0x56, "FCMPED",
  906. 0x57, "FCMPEX",
  907. 0, 0
  908. };
  909. static void
  910. fpop(Instr *i, char *m) /* page 108-116 */
  911. {
  912. int j;
  913. if(dascase==0 && i->size==2){
  914. bprint(i, "FMOVD\tF%d, F%d", i->rs2, i->rd);
  915. return;
  916. }
  917. for(j=0; fptab1[j].name; j++)
  918. if(fptab1[j].opf == i->opf){
  919. bprint(i, "%T\tF%d, F%d", fptab1[j].name, i->rs2, i->rd);
  920. return;
  921. }
  922. for(j=0; fptab2[j].name; j++)
  923. if(fptab2[j].opf == i->opf){
  924. bprint(i, "%T\tF%d, F%d, F%d", fptab2[j].name, i->rs1, i->rs2, i->rd);
  925. return;
  926. }
  927. bprint(i, "%T%ux\tF%d, F%d, F%d", m, i->opf, i->rs1, i->rs2, i->rd);
  928. }
  929. static int
  930. sparc64foll(Map *map, uvlong pc, Rgetter rget, uvlong *foll)
  931. {
  932. ulong w, r1, r2;
  933. char buf[8];
  934. Instr i;
  935. mymap = map;
  936. if (mkinstr(pc, &i) < 0)
  937. return -1;
  938. w = i.w0;
  939. switch(w & 0xC1C00000){
  940. case 0x00800000: /* branch on int cond */
  941. case 0x01800000: /* branch on fp cond */
  942. case 0x01C00000: /* branch on copr cond */
  943. foll[0] = pc+8;
  944. foll[1] = pc + (i.simmdisp22<<2);
  945. return 2;
  946. }
  947. if((w&0xC0000000) == 0x40000000){ /* CALL */
  948. foll[0] = pc + (i.disp30<<2);
  949. return 1;
  950. }
  951. if((w&0xC1F80000) == 0x81C00000){ /* JMPL */
  952. sprint(buf, "R%ld", (w>>14)&0xF);
  953. r1 = (*rget)(map, buf);
  954. if(w & 0x2000) /* JMPL R1+simm13 */
  955. r2 = i.simm13;
  956. else{ /* JMPL R1+R2 */
  957. sprint(buf, "R%ld", w&0xF);
  958. r2 = (*rget)(map, buf);
  959. }
  960. foll[0] = r1 + r2;
  961. return 1;
  962. }
  963. foll[0] = pc+i.size*4;
  964. return 1;
  965. }