tmachpower.c - plan9port - [fork] Plan 9 from user space
HTML git clone git://src.adamsgaard.dk/plan9port
DIR Log
DIR Files
DIR Refs
DIR README
DIR LICENSE
---
tmachpower.c (31762B)
---
1 /*
2 * PowerPC definition
3 * forsyth@plan9.cs.york.ac.uk
4 */
5 #include <u.h>
6 #include <libc.h>
7 #include <bio.h>
8 #include "uregpower.h"
9 #include <mach.h>
10
11 /*
12 * PowerPC-specific debugger interface
13 * forsyth@plan9.cs.york.ac.uk
14 */
15
16 static char *powerexcep(Map*, Regs*);
17 static int powerfoll(Map*, Regs*, u64int, u64int*);
18 static int powerdas(Map*, u64int, char, char*, int);
19 static int powerinstlen(Map*, u64int);
20 static int powerhexinst(Map*, u64int, char*, int);
21
22 static char *excname[] =
23 {
24 "reserved 0",
25 "system reset",
26 "machine check",
27 "data access",
28 "instruction access",
29 "external interrupt",
30 "alignment",
31 "program exception",
32 "floating-point unavailable",
33 "decrementer",
34 "i/o controller interface error",
35 "reserved B",
36 "system call",
37 "trace trap",
38 "floating point assist",
39 "reserved",
40 "ITLB miss",
41 "DTLB load miss",
42 "DTLB store miss",
43 "instruction address breakpoint"
44 "SMI interrupt"
45 "reserved 15",
46 "reserved 16",
47 "reserved 17",
48 "reserved 18",
49 "reserved 19",
50 "reserved 1A",
51 /* the following are made up on a program exception */
52 "floating point exception", /* FPEXC */
53 "illegal instruction",
54 "privileged instruction",
55 "trap",
56 "illegal operation",
57 };
58
59 static char*
60 powerexcep(Map *map, Regs *regs)
61 {
62 u64int c;
63 static char buf[32];
64
65 if(rget(regs, "CAUSE", &c) < 0)
66 return "no cause register";
67 c >>= 8;
68 if(c < nelem(excname))
69 return excname[c];
70 sprint(buf, "unknown trap #%lux", c);
71 return buf;
72 }
73
74 /*
75 * disassemble PowerPC opcodes
76 */
77
78 #define REGSP 1 /* should come from q.out.h, but there's a clash */
79 #define REGSB 2
80
81 /*static char FRAMENAME[] = ".frame"; */
82
83 static Map *mymap;
84
85 /*
86 * ibm conventions for these: bit 0 is top bit
87 * from table 10-1
88 */
89 typedef struct {
90 uchar aa; /* bit 30 */
91 uchar crba; /* bits 11-15 */
92 uchar crbb; /* bits 16-20 */
93 long bd; /* bits 16-29 */
94 uchar crfd; /* bits 6-8 */
95 uchar crfs; /* bits 11-13 */
96 uchar bi; /* bits 11-15 */
97 uchar bo; /* bits 6-10 */
98 uchar crbd; /* bits 6-10 */
99 /*union {*/
100 short d; /* bits 16-31 */
101 short simm;
102 ushort uimm;
103 /*};*/
104 uchar fm; /* bits 7-14 */
105 uchar fra; /* bits 11-15 */
106 uchar frb; /* bits 16-20 */
107 uchar frc; /* bits 21-25 */
108 uchar frs; /* bits 6-10 */
109 uchar frd; /* bits 6-10 */
110 uchar crm; /* bits 12-19 */
111 long li; /* bits 6-29 || b'00' */
112 uchar lk; /* bit 31 */
113 uchar mb; /* bits 21-25 */
114 uchar me; /* bits 26-30 */
115 uchar nb; /* bits 16-20 */
116 uchar op; /* bits 0-5 */
117 uchar oe; /* bit 21 */
118 uchar ra; /* bits 11-15 */
119 uchar rb; /* bits 16-20 */
120 uchar rc; /* bit 31 */
121 /*union {*/
122 uchar rs; /* bits 6-10 */
123 uchar rd;
124 /*};*/
125 uchar sh; /* bits 16-20 */
126 ushort spr; /* bits 11-20 */
127 uchar to; /* bits 6-10 */
128 uchar imm; /* bits 16-19 */
129 ushort xo; /* bits 21-30, 22-30, 26-30, or 30 (beware) */
130 long immediate;
131 long w0;
132 long w1;
133 u64int addr; /* pc of instruction */
134 short target;
135 char *curr; /* current fill level in output buffer */
136 char *end; /* end of buffer */
137 int size; /* number of longs in instr */
138 char *err; /* errmsg */
139 } Instr;
140
141 #define IBF(v,a,b) (((ulong)(v)>>(32-(b)-1)) & ~(~0UL<<(((b)-(a)+1))))
142 #define IB(v,b) IBF((v),(b),(b))
143
144 static void
145 bprint(Instr *i, char *fmt, ...)
146 {
147 va_list arg;
148
149 va_start(arg, fmt);
150 i->curr = vseprint(i->curr, i->end, fmt, arg);
151 va_end(arg);
152 }
153
154 static int
155 decode(ulong pc, Instr *i)
156 {
157 u32int w;
158
159 if (get4(mymap, pc, &w) < 0) {
160 werrstr("can't read instruction: %r");
161 return -1;
162 }
163 i->aa = IB(w, 30);
164 i->crba = IBF(w, 11, 15);
165 i->crbb = IBF(w, 16, 20);
166 i->bd = IBF(w, 16, 29)<<2;
167 if(i->bd & 0x8000)
168 i->bd |= ~0UL<<16;
169 i->crfd = IBF(w, 6, 8);
170 i->crfs = IBF(w, 11, 13);
171 i->bi = IBF(w, 11, 15);
172 i->bo = IBF(w, 6, 10);
173 i->crbd = IBF(w, 6, 10);
174 i->uimm = IBF(w, 16, 31); /* also d, simm */
175 i->fm = IBF(w, 7, 14);
176 i->fra = IBF(w, 11, 15);
177 i->frb = IBF(w, 16, 20);
178 i->frc = IBF(w, 21, 25);
179 i->frs = IBF(w, 6, 10);
180 i->frd = IBF(w, 6, 10);
181 i->crm = IBF(w, 12, 19);
182 i->li = IBF(w, 6, 29)<<2;
183 if(IB(w, 6))
184 i->li |= ~0UL<<25;
185 i->lk = IB(w, 31);
186 i->mb = IBF(w, 21, 25);
187 i->me = IBF(w, 26, 30);
188 i->nb = IBF(w, 16, 20);
189 i->op = IBF(w, 0, 5);
190 i->oe = IB(w, 21);
191 i->ra = IBF(w, 11, 15);
192 i->rb = IBF(w, 16, 20);
193 i->rc = IB(w, 31);
194 i->rs = IBF(w, 6, 10); /* also rd */
195 i->sh = IBF(w, 16, 20);
196 i->spr = IBF(w, 11, 20);
197 i->to = IBF(w, 6, 10);
198 i->imm = IBF(w, 16, 19);
199 i->xo = IBF(w, 21, 30); /* bits 21-30, 22-30, 26-30, or 30 (beware) */
200 i->immediate = i->simm;
201 if(i->op == 15)
202 i->immediate <<= 16;
203 i->w0 = w;
204 i->target = -1;
205 i->addr = pc;
206 i->size = 1;
207 return 1;
208 }
209
210 static int
211 mkinstr(ulong pc, Instr *i)
212 {
213 Instr x;
214
215 if(decode(pc, i) < 0)
216 return -1;
217 /*
218 * combine ADDIS/ORI (CAU/ORIL) into MOVW
219 */
220 if (i->op == 15 && i->ra==0) {
221 if(decode(pc+4, &x) < 0)
222 return -1;
223 if (x.op == 24 && x.rs == x.ra && x.ra == i->rd) {
224 i->immediate |= (x.immediate & 0xFFFF);
225 i->w1 = x.w0;
226 i->target = x.rd;
227 i->size++;
228 return 1;
229 }
230 }
231 return 1;
232 }
233
234 static int
235 plocal(Instr *i)
236 {
237 Symbol s;
238 Loc l, li;
239
240 l.type = LOFFSET;
241 l.offset = i->immediate;
242 l.reg = "SP";
243
244 li.type = LADDR;
245 li.addr = i->addr;
246 if (findsym(li, CTEXT, &s)<0 || findlsym(&s, l, &s)<0)
247 return -1;
248 bprint(i, "%s%+ld(SP)", s.name, (long)i->immediate);
249 return 0;
250 }
251
252 static int
253 pglobal(Instr *i, long off, int anyoff, char *reg)
254 {
255 Symbol s, s2;
256 u32int off1;
257 Loc l;
258
259 l.type = LADDR;
260 l.addr = off;
261 if(findsym(l, CANY, &s)>=0 && s.loc.type==LADDR &&
262 s.loc.addr-off < 4096 &&
263 (s.class == CDATA || s.class == CTEXT)) {
264 if(off==s.loc.addr && s.name[0]=='$'){
265 off1 = 0;
266 get4(mymap, s.loc.addr, &off1);
267 l.addr = off1;
268 if(off1 && findsym(l, CANY, &s2)>=0 && s2.loc.type==LADDR && s2.loc.addr == off1){
269 bprint(i, "$%s%s", s2.name, reg);
270 return 1;
271 }
272 }
273 bprint(i, "%s", s.name);
274 if (s.loc.addr != off)
275 bprint(i, "+%lux", off-s.loc.addr);
276 bprint(i, reg);
277 return 1;
278 }
279 if(!anyoff)
280 return 0;
281 bprint(i, "%lux%s", off, reg);
282 return 1;
283 }
284
285 static void
286 address(Instr *i)
287 {
288 if (i->ra == REGSP && plocal(i) >= 0)
289 return;
290 if (i->ra == REGSB && mach->sb && pglobal(i, mach->sb+i->immediate, 0, "(SB)") >= 0)
291 return;
292 if(i->simm < 0)
293 bprint(i, "-%lx(R%d)", -i->simm, i->ra);
294 else
295 bprint(i, "%lux(R%d)", i->immediate, i->ra);
296 }
297
298 static char *tcrbits[] = {"LT", "GT", "EQ", "VS"};
299 static char *fcrbits[] = {"GE", "LE", "NE", "VC"};
300
301 typedef struct Opcode Opcode;
302
303 struct Opcode {
304 uchar op;
305 ushort xo;
306 ushort xomask;
307 char *mnemonic;
308 void (*f)(Opcode *, Instr *);
309 char *ken;
310 int flags;
311 };
312
313 static void format(char *, Instr *, char *);
314
315 static void
316 branch(Opcode *o, Instr *i)
317 {
318 char buf[8];
319 int bo, bi;
320
321 bo = i->bo & ~1; /* ignore prediction bit */
322 if(bo==4 || bo==12 || bo==20) { /* simple forms */
323 if(bo != 20) {
324 bi = i->bi&3;
325 sprint(buf, "B%s%%L", bo==12? tcrbits[bi]: fcrbits[bi]);
326 format(buf, i, 0);
327 bprint(i, "\t");
328 if(i->bi > 4)
329 bprint(i, "CR(%d),", i->bi/4);
330 } else
331 format("BR%L\t", i, 0);
332 if(i->op == 16)
333 format(0, i, "%J");
334 else if(i->op == 19 && i->xo == 528)
335 format(0, i, "(CTR)");
336 else if(i->op == 19 && i->xo == 16)
337 format(0, i, "(LR)");
338 } else
339 format(o->mnemonic, i, o->ken);
340 }
341
342 static void
343 addi(Opcode *o, Instr *i)
344 {
345 if (i->op==14 && i->ra == 0)
346 format("MOVW", i, "%i,R%d");
347 else if (i->ra == REGSB) {
348 bprint(i, "MOVW\t$");
349 address(i);
350 bprint(i, ",R%d", i->rd);
351 } else if(i->op==14 && i->simm < 0) {
352 bprint(i, "SUB\t$%d,R%d", -i->simm, i->ra);
353 if(i->rd != i->ra)
354 bprint(i, ",R%d", i->rd);
355 } else if(i->ra == i->rd) {
356 format(o->mnemonic, i, "%i");
357 bprint(i, ",R%d", i->rd);
358 } else
359 format(o->mnemonic, i, o->ken);
360 }
361
362 static void
363 addis(Opcode *o, Instr *i)
364 {
365 long v;
366
367 v = i->immediate;
368 if (i->op==15 && i->ra == 0)
369 bprint(i, "MOVW\t$%lux,R%d", v, i->rd);
370 else if (i->op==15 && i->ra == REGSB) {
371 bprint(i, "MOVW\t$");
372 address(i);
373 bprint(i, ",R%d", i->rd);
374 } else if(i->op==15 && v < 0) {
375 bprint(i, "SUB\t$%d,R%d", -v, i->ra);
376 if(i->rd != i->ra)
377 bprint(i, ",R%d", i->rd);
378 } else {
379 format(o->mnemonic, i, 0);
380 bprint(i, "\t$%ld,R%d", v, i->ra);
381 if(i->rd != i->ra)
382 bprint(i, ",R%d", i->rd);
383 }
384 }
385
386 static void
387 andi(Opcode *o, Instr *i)
388 {
389 if (i->ra == i->rs)
390 format(o->mnemonic, i, "%I,R%d");
391 else
392 format(o->mnemonic, i, o->ken);
393 }
394
395 static void
396 gencc(Opcode *o, Instr *i)
397 {
398 format(o->mnemonic, i, o->ken);
399 }
400
401 static void
402 gen(Opcode *o, Instr *i)
403 {
404 format(o->mnemonic, i, o->ken);
405 if (i->rc)
406 bprint(i, " [illegal Rc]");
407 }
408
409 static void
410 ldx(Opcode *o, Instr *i)
411 {
412 if(i->ra == 0)
413 format(o->mnemonic, i, "(R%b),R%d");
414 else
415 format(o->mnemonic, i, "(R%b+R%a),R%d");
416 if(i->rc)
417 bprint(i, " [illegal Rc]");
418 }
419
420 static void
421 stx(Opcode *o, Instr *i)
422 {
423 if(i->ra == 0)
424 format(o->mnemonic, i, "R%d,(R%b)");
425 else
426 format(o->mnemonic, i, "R%d,(R%b+R%a)");
427 if(i->rc && i->xo != 150)
428 bprint(i, " [illegal Rc]");
429 }
430
431 static void
432 fldx(Opcode *o, Instr *i)
433 {
434 if(i->ra == 0)
435 format(o->mnemonic, i, "(R%b),F%d");
436 else
437 format(o->mnemonic, i, "(R%b+R%a),F%d");
438 if(i->rc)
439 bprint(i, " [illegal Rc]");
440 }
441
442 static void
443 fstx(Opcode *o, Instr *i)
444 {
445 if(i->ra == 0)
446 format(o->mnemonic, i, "F%d,(R%b)");
447 else
448 format(o->mnemonic, i, "F%d,(R%b+R%a)");
449 if(i->rc)
450 bprint(i, " [illegal Rc]");
451 }
452
453 static void
454 dcb(Opcode *o, Instr *i)
455 {
456 if(i->ra == 0)
457 format(o->mnemonic, i, "(R%b)");
458 else
459 format(o->mnemonic, i, "(R%b+R%a)");
460 if(i->rd)
461 bprint(i, " [illegal Rd]");
462 if(i->rc)
463 bprint(i, " [illegal Rc]");
464 }
465
466 static void
467 lw(Opcode *o, Instr *i, char r)
468 {
469 bprint(i, "%s\t", o->mnemonic);
470 address(i);
471 bprint(i, ",%c%d", r, i->rd);
472 }
473
474 static void
475 load(Opcode *o, Instr *i)
476 {
477 lw(o, i, 'R');
478 }
479
480 static void
481 fload(Opcode *o, Instr *i)
482 {
483 lw(o, i, 'F');
484 }
485
486 static void
487 sw(Opcode *o, Instr *i, char r)
488 {
489 char *m;
490 Symbol s;
491 Loc l;
492
493 m = o->mnemonic;
494 if (i->rs == REGSP) {
495 l.type = LADDR;
496 l.addr = i->addr;
497 if (findsym(l, CTEXT, &s)>=0) {
498 l.type = LOFFSET;
499 l.reg = "SP";
500 l.offset = i->immediate;
501 if (findlsym(&s, l, &s) >= 0) {
502 bprint(i, "%s\t%c%d,%s-%d(SP)", m, r, i->rd,
503 s.name, i->immediate);
504 return;
505 }
506 }
507 }
508 if (i->rs == REGSB && mach->sb) {
509 bprint(i, "%s\t%c%d,", m, r, i->rd);
510 address(i);
511 return;
512 }
513 if (r == 'F')
514 format(m, i, "F%d,%l");
515 else
516 format(m, i, o->ken);
517 }
518
519 static void
520 store(Opcode *o, Instr *i)
521 {
522 sw(o, i, 'R');
523 }
524
525 static void
526 fstore(Opcode *o, Instr *i)
527 {
528 sw(o, i, 'F');
529 }
530
531 static void
532 shifti(Opcode *o, Instr *i)
533 {
534 if (i->ra == i->rs)
535 format(o->mnemonic, i, "$%k,R%a");
536 else
537 format(o->mnemonic, i, o->ken);
538 }
539
540 static void
541 shift(Opcode *o, Instr *i)
542 {
543 if (i->ra == i->rs)
544 format(o->mnemonic, i, "R%b,R%a");
545 else
546 format(o->mnemonic, i, o->ken);
547 }
548
549 static void
550 add(Opcode *o, Instr *i)
551 {
552 if (i->rd == i->ra)
553 format(o->mnemonic, i, "R%b,R%d");
554 else if (i->rd == i->rb)
555 format(o->mnemonic, i, "R%a,R%d");
556 else
557 format(o->mnemonic, i, o->ken);
558 }
559
560 static void
561 sub(Opcode *o, Instr *i)
562 {
563 format(o->mnemonic, i, 0);
564 bprint(i, "\t");
565 if(i->op == 31) {
566 bprint(i, "\tR%d,R%d", i->ra, i->rb); /* subtract Ra from Rb */
567 if(i->rd != i->rb)
568 bprint(i, ",R%d", i->rd);
569 } else
570 bprint(i, "\tR%d,$%d,R%d", i->ra, i->simm, i->rd);
571 }
572
573 #define div power_div
574
575 static void
576 div(Opcode *o, Instr *i)
577 {
578 format(o->mnemonic, i, 0);
579 if(i->op == 31)
580 bprint(i, "\tR%d,R%d", i->rb, i->ra);
581 else
582 bprint(i, "\t$%d,R%d", i->simm, i->ra);
583 if(i->ra != i->rd)
584 bprint(i, ",R%d", i->rd);
585 }
586
587 static void
588 and(Opcode *o, Instr *i)
589 {
590 if (i->op == 31) {
591 /* Rb,Rs,Ra */
592 if (i->ra == i->rs)
593 format(o->mnemonic, i, "R%b,R%a");
594 else if (i->ra == i->rb)
595 format(o->mnemonic, i, "R%s,R%a");
596 else
597 format(o->mnemonic, i, o->ken);
598 } else {
599 /* imm,Rs,Ra */
600 if (i->ra == i->rs)
601 format(o->mnemonic, i, "%I,R%a");
602 else
603 format(o->mnemonic, i, o->ken);
604 }
605 }
606
607 static void
608 or(Opcode *o, Instr *i)
609 {
610 if (i->op == 31) {
611 /* Rb,Rs,Ra */
612 if (i->rs == 0 && i->ra == 0 && i->rb == 0)
613 format("NOP", i, 0);
614 else if (i->rs == i->rb)
615 format("MOVW", i, "R%b,R%a");
616 else
617 and(o, i);
618 } else
619 and(o, i);
620 }
621
622 static void
623 shifted(Opcode *o, Instr *i)
624 {
625 format(o->mnemonic, i, 0);
626 bprint(i, "\t$%lux,", (ulong)i->uimm<<16);
627 if (i->rs == i->ra)
628 bprint(i, "R%d", i->ra);
629 else
630 bprint(i, "R%d,R%d", i->rs, i->ra);
631 }
632
633 static void
634 neg(Opcode *o, Instr *i)
635 {
636 if (i->rd == i->ra)
637 format(o->mnemonic, i, "R%d");
638 else
639 format(o->mnemonic, i, o->ken);
640 }
641
642 static char ir2[] = "R%a,R%d"; /* reverse of IBM order */
643 static char ir3[] = "R%b,R%a,R%d";
644 static char ir3r[] = "R%a,R%b,R%d";
645 static char il3[] = "R%b,R%s,R%a";
646 static char il2u[] = "%I,R%a,R%d";
647 static char il3s[] = "$%k,R%s,R%a";
648 static char il2[] = "R%s,R%a";
649 static char icmp3[] = "R%a,R%b,%D";
650 static char cr3op[] = "%b,%a,%d";
651 static char ir2i[] = "%i,R%a,R%d";
652 static char fp2[] = "F%b,F%d";
653 static char fp3[] = "F%b,F%a,F%d";
654 static char fp3c[] = "F%c,F%a,F%d";
655 static char fp4[] = "F%a,F%c,F%b,F%d";
656 static char fpcmp[] = "F%a,F%b,%D";
657 static char ldop[] = "%l,R%d";
658 static char stop[] = "R%d,%l";
659 static char fldop[] = "%l,F%d";
660 static char fstop[] = "F%d,%l";
661 static char rlim[] = "R%b,R%s,$%z,R%a";
662 static char rlimi[] = "$%k,R%s,$%z,R%a";
663
664 #define OEM IBF(~0,22,30)
665 #define FP4 IBF(~0,26,30)
666 #define ALL ((ushort)~0)
667 /*
668 notes:
669 10-26: crfD = rD>>2; rD&3 mbz
670 also, L bit (bit 10) mbz or selects 64-bit operands
671 */
672
673 static Opcode opcodes[] = {
674 {31, 360, OEM, "ABS%V%C", 0, ir2}, /* POWER */
675
676 {31, 266, OEM, "ADD%V%C", add, ir3},
677 {31, 10, OEM, "ADDC%V%C", add, ir3},
678 {31, 138, OEM, "ADDE%V%C", add, ir3},
679 {14, 0, 0, "ADD", addi, ir2i},
680 {12, 0, 0, "ADDC", addi, ir2i},
681 {13, 0, 0, "ADDCCC", addi, ir2i},
682 {15, 0, 0, "ADD", addis, 0},
683 {31, 234, OEM, "ADDME%V%C", gencc, ir2},
684 {31, 202, OEM, "ADDZE%V%C", gencc, ir2},
685
686 {31, 28, ALL, "AND%C", and, il3},
687 {31, 60, ALL, "ANDN%C", and, il3},
688 {28, 0, 0, "ANDCC", andi, il2u},
689 {29, 0, 0, "ANDCC", shifted, 0},
690
691 {18, 0, 0, "B%L", gencc, "%j"},
692 {16, 0, 0, "BC%L", branch, "%d,%a,%J"},
693 {19, 528, ALL, "BC%L", branch, "%d,%a,(CTR)"},
694 {19, 16, ALL, "BC%L", branch, "%d,%a,(LR)"},
695
696 {31, 531, ALL, "CLCS", gen, ir2}, /* POWER */
697
698 {31, 0, ALL, "CMP", 0, icmp3},
699 {11, 0, 0, "CMP", 0, "R%a,%i,%D"},
700 {31, 32, ALL, "CMPU", 0, icmp3},
701 {10, 0, 0, "CMPU", 0, "R%a,%I,%D"},
702
703 {31, 26, ALL, "CNTLZ%C", gencc, ir2},
704
705 {19, 257, ALL, "CRAND", gen, cr3op},
706 {19, 129, ALL, "CRANDN", gen, cr3op},
707 {19, 289, ALL, "CREQV", gen, cr3op},
708 {19, 225, ALL, "CRNAND", gen, cr3op},
709 {19, 33, ALL, "CRNOR", gen, cr3op},
710 {19, 449, ALL, "CROR", gen, cr3op},
711 {19, 417, ALL, "CRORN", gen, cr3op},
712 {19, 193, ALL, "CRXOR", gen, cr3op},
713
714 {31, 86, ALL, "DCBF", dcb, 0},
715 {31, 470, ALL, "DCBI", dcb, 0},
716 {31, 54, ALL, "DCBST", dcb, 0},
717 {31, 278, ALL, "DCBT", dcb, 0},
718 {31, 246, ALL, "DCBTST", dcb, 0},
719 {31, 1014, ALL, "DCBZ", dcb, 0},
720
721 {31, 331, OEM, "DIV%V%C", div, ir3}, /* POWER */
722 {31, 363, OEM, "DIVS%V%C", div, ir3}, /* POWER */
723 {31, 491, OEM, "DIVW%V%C", div, ir3},
724 {31, 459, OEM, "DIVWU%V%C", div, ir3},
725
726 {31, 264, OEM, "DOZ%V%C", gencc, ir3r}, /* POWER */
727 {9, 0, 0, "DOZ", gen, ir2i}, /* POWER */
728
729 {31, 310, ALL, "ECIWX", ldx, 0},
730 {31, 438, ALL, "ECOWX", stx, 0},
731 {31, 854, ALL, "EIEIO", gen, 0},
732
733 {31, 284, ALL, "EQV%C", gencc, il3},
734
735 {31, 954, ALL, "EXTSB%C", gencc, il2},
736 {31, 922, ALL, "EXTSH%C", gencc, il2},
737
738 {63, 264, ALL, "FABS%C", gencc, fp2},
739 {63, 21, ALL, "FADD%C", gencc, fp3},
740 {59, 21, ALL, "FADDS%C", gencc, fp3},
741 {63, 32, ALL, "FCMPO", gen, fpcmp},
742 {63, 0, ALL, "FCMPU", gen, fpcmp},
743 {63, 14, ALL, "FCTIW%C", gencc, fp2},
744 {63, 15, ALL, "FCTIWZ%C", gencc, fp2},
745 {63, 18, ALL, "FDIV%C", gencc, fp3},
746 {59, 18, ALL, "FDIVS%C", gencc, fp3},
747 {63, 29, FP4, "FMADD%C", gencc, fp4},
748 {59, 29, FP4, "FMADDS%C", gencc, fp4},
749 {63, 72, ALL, "FMOVD%C", gencc, fp2},
750 {63, 28, FP4, "FMSUB%C", gencc, fp4},
751 {59, 28, FP4, "FMSUBS%C", gencc, fp4},
752 {63, 25, FP4, "FMUL%C", gencc, fp3c},
753 {59, 25, FP4, "FMULS%C", gencc, fp3c},
754 {63, 136, ALL, "FNABS%C", gencc, fp2},
755 {63, 40, ALL, "FNEG%C", gencc, fp2},
756 {63, 31, FP4, "FNMADD%C", gencc, fp4},
757 {59, 31, FP4, "FNMADDS%C", gencc, fp4},
758 {63, 30, FP4, "FNMSUB%C", gencc, fp4},
759 {59, 30, FP4, "FNMSUBS%C", gencc, fp4},
760 {63, 12, ALL, "FRSP%C", gencc, fp2},
761 {63, 20, FP4, "FSUB%C", gencc, fp3},
762 {59, 20, FP4, "FSUBS%C", gencc, fp3},
763
764 {31, 982, ALL, "ICBI", dcb, 0},
765 {19, 150, ALL, "ISYNC", gen, 0},
766
767 {34, 0, 0, "MOVBZ", load, ldop},
768 {35, 0, 0, "MOVBZU", load, ldop},
769 {31, 119, ALL, "MOVBZU", ldx, 0},
770 {31, 87, ALL, "MOVBZ", ldx, 0},
771 {50, 0, 0, "FMOVD", fload, fldop},
772 {51, 0, 0, "FMOVDU", fload, fldop},
773 {31, 631, ALL, "FMOVDU", fldx, 0},
774 {31, 599, ALL, "FMOVD", fldx, 0},
775 {48, 0, 0, "FMOVS", load, fldop},
776 {49, 0, 0, "FMOVSU", load, fldop},
777 {31, 567, ALL, "FMOVSU", fldx, 0},
778 {31, 535, ALL, "FMOVS", fldx, 0},
779 {42, 0, 0, "MOVH", load, ldop},
780 {43, 0, 0, "MOVHU", load, ldop},
781 {31, 375, ALL, "MOVHU", ldx, 0},
782 {31, 343, ALL, "MOVH", ldx, 0},
783 {31, 790, ALL, "MOVHBR", ldx, 0},
784 {40, 0, 0, "MOVHZ", load, ldop},
785 {41, 0, 0, "MOVHZU", load, ldop},
786 {31, 311, ALL, "MOVHZU", ldx, 0},
787 {31, 279, ALL, "MOVHZ", ldx, 0},
788 {46, 0, 0, "MOVMW", load, ldop},
789 {31, 277, ALL, "LSCBX%C", ldx, 0}, /* POWER */
790 {31, 597, ALL, "LSW", gen, "(R%a),$%n,R%d"},
791 {31, 533, ALL, "LSW", ldx, 0},
792 {31, 20, ALL, "LWAR", ldx, 0},
793 {31, 534, ALL, "MOVWBR", ldx, 0},
794 {32, 0, 0, "MOVW", load, ldop},
795 {33, 0, 0, "MOVWU", load, ldop},
796 {31, 55, ALL, "MOVWU", ldx, 0},
797 {31, 23, ALL, "MOVW", ldx, 0},
798
799 {31, 29, ALL, "MASKG%C", gencc, "R%s:R%b,R%d"}, /* POWER */
800 {31, 541, ALL, "MASKIR%C", gencc, "R%s,R%b,R%a"}, /* POWER */
801
802 {19, 0, ALL, "MOVFL", gen, "%S,%D"},
803 {63, 64, ALL, "MOVCRFS", gen, "%S,%D"},
804 {31, 512, ALL, "MOVW", gen, "XER,%D"},
805 {31, 19, ALL, "MOVW", gen, "CR,R%d"},
806
807 {63, 583, ALL, "MOVW%C", gen, "FPSCR, F%d"}, /* mffs */
808 {31, 83, ALL, "MOVW", gen, "MSR,R%d"},
809 {31, 339, ALL, "MOVW", gen, "%P,R%d"},
810 {31, 595, ALL, "MOVW", gen, "SEG(%a),R%d"},
811 {31, 659, ALL, "MOVW", gen, "SEG(R%b),R%d"},
812 {31, 144, ALL, "MOVFL", gen, "R%s,%m,CR"},
813 {63, 70, ALL, "MTFSB0%C", gencc, "%D"},
814 {63, 38, ALL, "MTFSB1%C", gencc, "%D"},
815 {63, 711, ALL, "MOVFL%C", gencc, "F%b,%M,FPSCR"}, /* mtfsf */
816 {63, 134, ALL, "MOVFL%C", gencc, "%K,%D"},
817 {31, 146, ALL, "MOVW", gen, "R%s,MSR"},
818 {31, 467, ALL, "MOVW", gen, "R%s,%P"},
819 {31, 210, ALL, "MOVW", gen, "R%s,SEG(%a)"},
820 {31, 242, ALL, "MOVW", gen, "R%s,SEG(R%b)"},
821
822 {31, 107, OEM, "MUL%V%C", gencc, ir3}, /* POWER */
823 {31, 75, ALL, "MULHW%C", gencc, ir3}, /* POWER */
824 {31, 11, ALL, "MULHWU%C", gencc, ir3}, /* POWER */
825
826 {31, 235, OEM, "MULLW%V%C", gencc, ir3},
827 {7, 0, 0, "MULLW", div, "%i,R%a,R%d"},
828
829 {31, 488, OEM, "NABS%V%C", neg, ir2}, /* POWER */
830
831 {31, 476, ALL, "NAND%C", gencc, il3},
832 {31, 104, OEM, "NEG%V%C", neg, ir2},
833 {31, 124, ALL, "NOR%C", gencc, il3},
834 {31, 444, ALL, "OR%C", or, il3},
835 {31, 412, ALL, "ORN%C", or, il3},
836 {24, 0, 0, "OR", and, "%I,R%d,R%a"},
837 {25, 0, 0, "OR", shifted, 0},
838
839 {19, 50, ALL, "RFI", gen, 0},
840
841 {22, 0, 0, "RLMI%C", gencc, rlim}, /* POWER */
842 {20, 0, 0, "RLWMI%C", gencc, rlimi},
843 {21, 0, 0, "RLWNM%C", gencc, rlimi},
844 {23, 0, 0, "RLWNM%C", gencc, rlim},
845
846 {31, 537, ALL, "RRIB%C", gencc, il3}, /* POWER */
847
848 {17, 1, ALL, "SYSCALL", gen, 0},
849
850 {31, 153, ALL, "SLE%C", shift, il3}, /* POWER */
851 {31, 217, ALL, "SLEQ%C", shift, il3}, /* POWER */
852 {31, 184, ALL, "SLQ%C", shifti, il3s}, /* POWER */
853 {31, 248, ALL, "SLLQ%C", shifti, il3s}, /* POWER */
854 {31, 216, ALL, "SLLQ%C", shift, il3}, /* POWER */
855 {31, 152, ALL, "SLQ%C", shift, il3}, /* POWER */
856
857 {31, 24, ALL, "SLW%C", shift, il3},
858
859 {31, 920, ALL, "SRAQ%C", shift, il3}, /* POWER */
860 {31, 952, ALL, "SRAQ%C", shifti, il3s}, /* POWER */
861
862 {31, 792, ALL, "SRAW%C", shift, il3},
863 {31, 824, ALL, "SRAW%C", shifti, il3s},
864
865 {31, 665, ALL, "SRE%C", shift, il3}, /* POWER */
866 {31, 921, ALL, "SREA%C", shift, il3}, /* POWER */
867 {31, 729, ALL, "SREQ%C", shift, il3}, /* POWER */
868 {31, 696, ALL, "SRQ%C", shifti, il3s}, /* POWER */
869 {31, 760, ALL, "SRLQ%C", shifti, il3s}, /* POWER */
870 {31, 728, ALL, "SRLQ%C", shift, il3}, /* POWER */
871 {31, 664, ALL, "SRQ%C", shift, il3}, /* POWER */
872
873 {31, 536, ALL, "SRW%C", shift, il3},
874
875 {38, 0, 0, "MOVB", store, stop},
876 {39, 0, 0, "MOVBU", store, stop},
877 {31, 247, ALL, "MOVBU", stx, 0},
878 {31, 215, ALL, "MOVB", stx, 0},
879 {54, 0, 0, "FMOVD", fstore, fstop},
880 {55, 0, 0, "FMOVDU", fstore, fstop},
881 {31, 759, ALL, "FMOVDU", fstx, 0},
882 {31, 727, ALL, "FMOVD", fstx, 0},
883 {52, 0, 0, "FMOVS", fstore, fstop},
884 {53, 0, 0, "FMOVSU", fstore, fstop},
885 {31, 695, ALL, "FMOVSU", fstx, 0},
886 {31, 663, ALL, "FMOVS", fstx, 0},
887 {44, 0, 0, "MOVH", store, stop},
888 {31, 918, ALL, "MOVHBR", stx, 0},
889 {45, 0, 0, "MOVHU", store, stop},
890 {31, 439, ALL, "MOVHU", stx, 0},
891 {31, 407, ALL, "MOVH", stx, 0},
892 {47, 0, 0, "MOVMW", store, stop},
893 {31, 725, ALL, "STSW", gen, "R%d,$%n,(R%a)"},
894 {31, 661, ALL, "STSW", stx, 0},
895 {36, 0, 0, "MOVW", store, stop},
896 {31, 662, ALL, "MOVWBR", stx, 0},
897 {31, 150, ALL, "STWCCC", stx, 0},
898 {37, 0, 0, "MOVWU", store, stop},
899 {31, 183, ALL, "MOVWU", stx, 0},
900 {31, 151, ALL, "MOVW", stx, 0},
901
902 {31, 40, OEM, "SUB%V%C", sub, ir3},
903 {31, 8, OEM, "SUBC%V%C", sub, ir3},
904 {31, 136, OEM, "SUBE%V%C", sub, ir3},
905 {8, 0, 0, "SUBC", gen, "R%a,%i,R%d"},
906 {31, 232, OEM, "SUBME%V%C", sub, ir2},
907 {31, 200, OEM, "SUBZE%V%C", sub, ir2},
908
909 {31, 598, ALL, "SYNC", gen, 0},
910 {31, 370, ALL, "TLBIA", gen, 0},
911 {31, 306, ALL, "TLBIE", gen, "R%b"},
912 {31, 1010, ALL, "TLBLI", gen, "R%b"},
913 {31, 978, ALL, "TLBLD", gen, "R%b"},
914 {31, 4, ALL, "TW", gen, "%d,R%a,R%b"},
915 {3, 0, 0, "TW", gen, "%d,R%a,%i"},
916
917 {31, 316, ALL, "XOR", and, il3},
918 {26, 0, 0, "XOR", and, il2u},
919 {27, 0, 0, "XOR", shifted, 0},
920
921 {0},
922 };
923
924 typedef struct Spr Spr;
925 struct Spr {
926 int n;
927 char *name;
928 };
929
930 static Spr sprname[] = {
931 {0, "MQ"},
932 {1, "XER"},
933 {268, "TBL"},
934 {269, "TBU"},
935 {8, "LR"},
936 {9, "CTR"},
937 {528, "IBAT0U"},
938 {529, "IBAT0L"},
939 {530, "IBAT1U"},
940 {531, "IBAT1L"},
941 {532, "IBAT2U"},
942 {533, "IBAT2L"},
943 {534, "IBAT3U"},
944 {535, "IBAT3L"},
945 {536, "DBAT0U"},
946 {537, "DBAT0L"},
947 {538, "DBAT1U"},
948 {539, "DBAT1L"},
949 {540, "DBAT2U"},
950 {541, "DBAT2L"},
951 {542, "DBAT3U"},
952 {543, "DBAT3L"},
953 {25, "SDR1"},
954 {19, "DAR"},
955 {272, "SPRG0"},
956 {273, "SPRG1"},
957 {274, "SPRG2"},
958 {275, "SPRG3"},
959 {18, "DSISR"},
960 {26, "SRR0"},
961 {27, "SRR1"},
962 {284, "TBLW"},
963 {285, "TBUW"},
964 {22, "DEC"},
965 {282, "EAR"},
966 {1008, "HID0"},
967 {1009, "HID1"},
968 {976, "DMISS"},
969 {977, "DCMP"},
970 {978, "HASH1"},
971 {979, "HASH2"},
972 {980, "IMISS"},
973 {981, "ICMP"},
974 {982, "RPA"},
975 {1010, "IABR"},
976 {0,0},
977 };
978
979 static void
980 format(char *mnemonic, Instr *i, char *f)
981 {
982 int n, s;
983 ulong mask;
984
985 if (mnemonic)
986 format(0, i, mnemonic);
987 if (f == 0)
988 return;
989 if (mnemonic)
990 bprint(i, "\t");
991 for ( ; *f; f++) {
992 if (*f != '%') {
993 bprint(i, "%c", *f);
994 continue;
995 }
996 switch (*++f) {
997 case 'V':
998 if(i->oe)
999 bprint(i, "V");
1000 break;
1001
1002 case 'C':
1003 if(i->rc)
1004 bprint(i, "CC");
1005 break;
1006
1007 case 'a':
1008 bprint(i, "%d", i->ra);
1009 break;
1010
1011 case 'b':
1012 bprint(i, "%d", i->rb);
1013 break;
1014
1015 case 'c':
1016 bprint(i, "%d", i->frc);
1017 break;
1018
1019 case 'd':
1020 case 's':
1021 bprint(i, "%d", i->rd);
1022 break;
1023
1024 case 'S':
1025 if(i->ra & 3)
1026 bprint(i, "CR(INVAL:%d)", i->ra);
1027 else if(i->op == 63)
1028 bprint(i, "FPSCR(%d)", i->crfs);
1029 else
1030 bprint(i, "CR(%d)", i->crfs);
1031 break;
1032
1033 case 'D':
1034 if(i->rd & 3)
1035 bprint(i, "CR(INVAL:%d)", i->rd);
1036 else if(i->op == 63)
1037 bprint(i, "FPSCR(%d)", i->crfd);
1038 else
1039 bprint(i, "CR(%d)", i->crfd);
1040 break;
1041
1042 case 'l':
1043 if(i->simm < 0)
1044 bprint(i, "-%lx(R%d)", -i->simm, i->ra);
1045 else
1046 bprint(i, "%lx(R%d)", i->simm, i->ra);
1047 break;
1048
1049 case 'i':
1050 bprint(i, "$%ld", i->simm);
1051 break;
1052
1053 case 'I':
1054 bprint(i, "$%lx", i->uimm);
1055 break;
1056
1057 case 'w':
1058 bprint(i, "[%lux]", i->w0);
1059 break;
1060
1061 case 'P':
1062 n = ((i->spr&0x1f)<<5)|((i->spr>>5)&0x1f);
1063 for(s=0; sprname[s].name; s++)
1064 if(sprname[s].n == n)
1065 break;
1066 if(sprname[s].name) {
1067 if(s < 10)
1068 bprint(i, sprname[s].name);
1069 else
1070 bprint(i, "SPR(%s)", sprname[s].name);
1071 } else
1072 bprint(i, "SPR(%d)", n);
1073 break;
1074
1075 case 'n':
1076 bprint(i, "%d", i->nb==0? 32: i->nb); /* eg, pg 10-103 */
1077 break;
1078
1079 case 'm':
1080 bprint(i, "%lx", i->crm);
1081 break;
1082
1083 case 'M':
1084 bprint(i, "%lx", i->fm);
1085 break;
1086
1087 case 'z':
1088 if(i->mb <= i->me)
1089 mask = ((ulong)~0L>>i->mb) & (~0L<<(31-i->me));
1090 else
1091 mask = ~(((ulong)~0L>>(i->me+1)) & (~0L<<(31-(i->mb-1))));
1092 bprint(i, "%lux", mask);
1093 break;
1094
1095 case 'k':
1096 bprint(i, "%d", i->sh);
1097 break;
1098
1099 case 'K':
1100 bprint(i, "$%x", i->imm);
1101 break;
1102
1103 case 'L':
1104 if(i->lk)
1105 bprint(i, "L");
1106 break;
1107
1108 case 'j':
1109 if(i->aa)
1110 pglobal(i, i->li, 1, "(SB)");
1111 else
1112 pglobal(i, i->addr+i->li, 1, "");
1113 break;
1114
1115 case 'J':
1116 if(i->aa)
1117 pglobal(i, i->bd, 1, "(SB)");
1118 else
1119 pglobal(i, i->addr+i->bd, 1, "");
1120 break;
1121
1122 case '\0':
1123 bprint(i, "%%");
1124 return;
1125
1126 default:
1127 bprint(i, "%%%c", *f);
1128 break;
1129 }
1130 }
1131 }
1132
1133 static int
1134 printins(Map *map, ulong pc, char *buf, int n)
1135 {
1136 Instr i;
1137 Opcode *o;
1138
1139 mymap = map;
1140 memset(&i, 0, sizeof(i));
1141 i.curr = buf;
1142 i.end = buf+n-1;
1143 if(mkinstr(pc, &i) < 0)
1144 return -1;
1145 for(o = opcodes; o->mnemonic != 0; o++)
1146 if(i.op == o->op && (i.xo & o->xomask) == o->xo) {
1147 if (o->f)
1148 (*o->f)(o, &i);
1149 else
1150 format(o->mnemonic, &i, o->ken);
1151 return i.size*4;
1152 }
1153 bprint(&i, "unknown %lux", i.w0);
1154 return i.size*4;
1155 }
1156
1157 static int
1158 powerdas(Map *map, u64int pc, char modifier, char *buf, int n)
1159 {
1160 USED(modifier);
1161 return printins(map, pc, buf, n);
1162 }
1163
1164 static int
1165 powerhexinst(Map *map, u64int pc, char *buf, int n)
1166 {
1167 Instr instr;
1168
1169 mymap = map;
1170 memset(&instr, 0, sizeof(instr));
1171 instr.curr = buf;
1172 instr.end = buf+n-1;
1173 if (mkinstr(pc, &instr) < 0)
1174 return -1;
1175 if (instr.end-instr.curr > 8)
1176 instr.curr = _hexify(instr.curr, instr.w0, 7);
1177 if (instr.end-instr.curr > 9 && instr.size == 2) {
1178 *instr.curr++ = ' ';
1179 instr.curr = _hexify(instr.curr, instr.w1, 7);
1180 }
1181 *instr.curr = 0;
1182 return instr.size*4;
1183 }
1184
1185 static int
1186 powerinstlen(Map *map, u64int pc)
1187 {
1188 Instr i;
1189
1190 mymap = map;
1191 if (mkinstr(pc, &i) < 0)
1192 return -1;
1193 return i.size*4;
1194 }
1195
1196 static int
1197 powerfoll(Map *map, Regs *regs, u64int pc, u64int *foll)
1198 {
1199 char *reg;
1200 Instr i;
1201
1202 mymap = map;
1203 if (mkinstr(pc, &i) < 0)
1204 return -1;
1205 foll[0] = pc+4;
1206 foll[1] = pc+4;
1207 switch(i.op) {
1208 default:
1209 return 1;
1210
1211 case 18: /* branch */
1212 foll[0] = i.li;
1213 if(!i.aa)
1214 foll[0] += pc;
1215 break;
1216
1217 case 16: /* conditional branch */
1218 foll[0] = i.bd;
1219 if(!i.aa)
1220 foll[0] += pc;
1221 break;
1222
1223 case 19: /* conditional branch to register */
1224 if(i.xo == 528)
1225 reg = "CTR";
1226 else if(i.xo == 16)
1227 reg = "LR";
1228 else
1229 return 1; /* not a branch */
1230 if(rget(regs, reg, &foll[0]) < 0)
1231 return -1;
1232 break;
1233 }
1234 if(i.lk)
1235 return 2;
1236 return 1;
1237 }
1238
1239 #define REGOFF(x) (ulong) (&((struct Ureg *) 0)->x)
1240
1241 #define SP REGOFF(r1)
1242 #define PC REGOFF(pc)
1243 #define R3 REGOFF(r3) /* return reg */
1244 #define LR REGOFF(lr)
1245 #define R31 REGOFF(r31)
1246 #define FP_REG(x) (R31+4+8*(x))
1247
1248 #define REGSIZE sizeof(struct Ureg)
1249 #define FPREGSIZE (8*33)
1250
1251 Regdesc powerreglist[] =
1252 {
1253 {"CAUSE", REGOFF(cause), RINT|RRDONLY, 'X'},
1254 {"SRR1", REGOFF(srr1), RINT|RRDONLY, 'X'},
1255 {"PC", REGOFF(pc), RINT, 'X'},
1256 {"LR", REGOFF(lr), RINT, 'X'},
1257 {"CR", REGOFF(cr), RINT, 'X'},
1258 {"XER", REGOFF(xer), RINT, 'X'},
1259 {"CTR", REGOFF(ctr), RINT, 'X'},
1260 {"PC", PC, RINT, 'X'},
1261 {"SP", SP, RINT, 'X'},
1262 {"R0", REGOFF(r0), RINT, 'X'},
1263 /* R1 is SP */
1264 {"R2", REGOFF(r2), RINT, 'X'},
1265 {"R3", REGOFF(r3), RINT, 'X'},
1266 {"R4", REGOFF(r4), RINT, 'X'},
1267 {"R5", REGOFF(r5), RINT, 'X'},
1268 {"R6", REGOFF(r6), RINT, 'X'},
1269 {"R7", REGOFF(r7), RINT, 'X'},
1270 {"R8", REGOFF(r8), RINT, 'X'},
1271 {"R9", REGOFF(r9), RINT, 'X'},
1272 {"R10", REGOFF(r10), RINT, 'X'},
1273 {"R11", REGOFF(r11), RINT, 'X'},
1274 {"R12", REGOFF(r12), RINT, 'X'},
1275 {"R13", REGOFF(r13), RINT, 'X'},
1276 {"R14", REGOFF(r14), RINT, 'X'},
1277 {"R15", REGOFF(r15), RINT, 'X'},
1278 {"R16", REGOFF(r16), RINT, 'X'},
1279 {"R17", REGOFF(r17), RINT, 'X'},
1280 {"R18", REGOFF(r18), RINT, 'X'},
1281 {"R19", REGOFF(r19), RINT, 'X'},
1282 {"R20", REGOFF(r20), RINT, 'X'},
1283 {"R21", REGOFF(r21), RINT, 'X'},
1284 {"R22", REGOFF(r22), RINT, 'X'},
1285 {"R23", REGOFF(r23), RINT, 'X'},
1286 {"R24", REGOFF(r24), RINT, 'X'},
1287 {"R25", REGOFF(r25), RINT, 'X'},
1288 {"R26", REGOFF(r26), RINT, 'X'},
1289 {"R27", REGOFF(r27), RINT, 'X'},
1290 {"R28", REGOFF(r28), RINT, 'X'},
1291 {"R29", REGOFF(r29), RINT, 'X'},
1292 {"R30", REGOFF(r30), RINT, 'X'},
1293 {"R31", REGOFF(r31), RINT, 'X'},
1294 {"VRSAVE", REGOFF(vrsave), RINT, 'X'},
1295 {"F0", FP_REG(0), RFLT, 'F'},
1296 {"F1", FP_REG(1), RFLT, 'F'},
1297 {"F2", FP_REG(2), RFLT, 'F'},
1298 {"F3", FP_REG(3), RFLT, 'F'},
1299 {"F4", FP_REG(4), RFLT, 'F'},
1300 {"F5", FP_REG(5), RFLT, 'F'},
1301 {"F6", FP_REG(6), RFLT, 'F'},
1302 {"F7", FP_REG(7), RFLT, 'F'},
1303 {"F8", FP_REG(8), RFLT, 'F'},
1304 {"F9", FP_REG(9), RFLT, 'F'},
1305 {"F10", FP_REG(10), RFLT, 'F'},
1306 {"F11", FP_REG(11), RFLT, 'F'},
1307 {"F12", FP_REG(12), RFLT, 'F'},
1308 {"F13", FP_REG(13), RFLT, 'F'},
1309 {"F14", FP_REG(14), RFLT, 'F'},
1310 {"F15", FP_REG(15), RFLT, 'F'},
1311 {"F16", FP_REG(16), RFLT, 'F'},
1312 {"F17", FP_REG(17), RFLT, 'F'},
1313 {"F18", FP_REG(18), RFLT, 'F'},
1314 {"F19", FP_REG(19), RFLT, 'F'},
1315 {"F20", FP_REG(20), RFLT, 'F'},
1316 {"F21", FP_REG(21), RFLT, 'F'},
1317 {"F22", FP_REG(22), RFLT, 'F'},
1318 {"F23", FP_REG(23), RFLT, 'F'},
1319 {"F24", FP_REG(24), RFLT, 'F'},
1320 {"F25", FP_REG(25), RFLT, 'F'},
1321 {"F26", FP_REG(26), RFLT, 'F'},
1322 {"F27", FP_REG(27), RFLT, 'F'},
1323 {"F28", FP_REG(28), RFLT, 'F'},
1324 {"F29", FP_REG(29), RFLT, 'F'},
1325 {"F30", FP_REG(30), RFLT, 'F'},
1326 {"F31", FP_REG(31), RFLT, 'F'},
1327 {"FPSCR", FP_REG(32)+4, RFLT, 'X'},
1328 { 0 }
1329 };
1330
1331 static char *powerwindregs[] =
1332 {
1333 "PC",
1334 "SP",
1335 "LR",
1336 0,
1337 };
1338
1339 static int
1340 powerunwind(Map *map, Regs *regs, u64int *next, Symbol *sym)
1341 {
1342 /*
1343 * This is tremendously hard. The best we're going to
1344 * do without better debugger support is trace through
1345 * the stack frame links and pull the link registers out of 8(R1).
1346 * Anything more requires knowing which registers got saved,
1347 * and the compiler appears not to record that. Gdb appears
1348 * to disassemble the function prologues in order to figure
1349 * this out.
1350 */
1351 /* evaluate lr */
1352 /* if in this function, no good - go to saved one. */
1353 /* set next[sp] to *cur[sp] */
1354 /* set next[pc] to lr */
1355 /* set next[lr] to lr */
1356 /* */
1357 werrstr("powerunwind not implemented");
1358 return -1;
1359 }
1360
1361 /* the machine description */
1362 Mach machpower =
1363 {
1364 "power",
1365 MPOWER, /* machine type */
1366 powerreglist, /* register set */
1367 REGSIZE, /* number of bytes in register set */
1368 FPREGSIZE, /* number of bytes in FP register set */
1369 "PC", /* name of PC */
1370 "SP", /* name of SP */
1371 0, /* name of FP */
1372 "LR", /* name of link register */
1373 "setSB", /* static base register name */
1374 0, /* value */
1375 0x1000, /* page size */
1376 0x80000000, /* kernel base */
1377 0, /* kernel text mask */
1378 4, /* quantization of pc */
1379 4, /* szaddr */
1380 4, /* szreg */
1381 4, /* szfloat */
1382 8, /* szdouble */
1383
1384 powerwindregs, /* locations unwound in stack trace */
1385 3,
1386
1387 {0x02, 0x8F, 0xFF, 0xFF}, /* break point */ /* BUG */
1388 4,
1389
1390 powerfoll, /* following addresses */
1391 powerexcep, /* print exception */
1392 powerunwind, /* stack unwind */
1393
1394 beswap2, /* convert short to local byte order */
1395 beswap4, /* convert long to local byte order */
1396 beswap8, /* convert vlong to local byte order */
1397 beieeeftoa32, /* single precision float pointer */
1398 beieeeftoa64, /* double precision float pointer */
1399 beieeeftoa80, /* long double precision floating point */
1400
1401 powerdas, /* dissembler */
1402 powerdas, /* plan9-format disassembler */
1403 0, /* commercial disassembler */
1404 powerhexinst, /* print instruction */
1405 powerinstlen, /* instruction size calculation */
1406 };