projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Update function declarations to ISO C90 formatting
[deliverable/binutils-gdb.git] / opcodes / sparc-dis.c
1 /* Print SPARC instructions.
2 Copyright 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
4
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
18 MA 02110-1301, USA. */
19
20 #include <stdio.h>
21
22 #include "sysdep.h"
23 #include "opcode/sparc.h"
24 #include "dis-asm.h"
25 #include "libiberty.h"
26 #include "opintl.h"
27
28 /* Bitmask of v9 architectures. */
29 #define MASK_V9 ((1 << SPARC_OPCODE_ARCH_V9) \
30 | (1 << SPARC_OPCODE_ARCH_V9A) \
31 | (1 << SPARC_OPCODE_ARCH_V9B))
32 /* 1 if INSN is for v9 only. */
33 #define V9_ONLY_P(insn) (! ((insn)->architecture & ~MASK_V9))
34 /* 1 if INSN is for v9. */
35 #define V9_P(insn) (((insn)->architecture & MASK_V9) != 0)
36
37 /* The sorted opcode table. */
38 static const sparc_opcode **sorted_opcodes;
39
40 /* For faster lookup, after insns are sorted they are hashed. */
41 /* ??? I think there is room for even more improvement. */
42
43 #define HASH_SIZE 256
44 /* It is important that we only look at insn code bits as that is how the
45 opcode table is hashed. OPCODE_BITS is a table of valid bits for each
46 of the main types (0,1,2,3). */
47 static int opcode_bits[4] = { 0x01c00000, 0x0, 0x01f80000, 0x01f80000 };
48 #define HASH_INSN(INSN) \
49 ((((INSN) >> 24) & 0xc0) | (((INSN) & opcode_bits[((INSN) >> 30) & 3]) >> 19))
50 typedef struct sparc_opcode_hash
51 {
52 struct sparc_opcode_hash *next;
53 const sparc_opcode *opcode;
54 } sparc_opcode_hash;
55
56 static sparc_opcode_hash *opcode_hash_table[HASH_SIZE];
57
58 /* Sign-extend a value which is N bits long. */
59 #define SEX(value, bits) \
60 ((((int)(value)) << ((8 * sizeof (int)) - bits)) \
61 >> ((8 * sizeof (int)) - bits) )
62
63 static char *reg_names[] =
64 { "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",
65 "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",
66 "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
67 "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",
68 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
69 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
70 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
71 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
72 "f32", "f33", "f34", "f35", "f36", "f37", "f38", "f39",
73 "f40", "f41", "f42", "f43", "f44", "f45", "f46", "f47",
74 "f48", "f49", "f50", "f51", "f52", "f53", "f54", "f55",
75 "f56", "f57", "f58", "f59", "f60", "f61", "f62", "f63",
76 /* psr, wim, tbr, fpsr, cpsr are v8 only. */
77 "y", "psr", "wim", "tbr", "pc", "npc", "fpsr", "cpsr"
78 };
79
80 #define freg_names (&reg_names[4 * 8])
81
82 /* These are ordered according to there register number in
83 rdpr and wrpr insns. */
84 static char *v9_priv_reg_names[] =
85 {
86 "tpc", "tnpc", "tstate", "tt", "tick", "tba", "pstate", "tl",
87 "pil", "cwp", "cansave", "canrestore", "cleanwin", "otherwin",
88 "wstate", "fq"
89 /* "ver" - special cased */
90 };
91
92 /* These are ordered according to there register number in
93 rd and wr insns (-16). */
94 static char *v9a_asr_reg_names[] =
95 {
96 "pcr", "pic", "dcr", "gsr", "set_softint", "clear_softint",
97 "softint", "tick_cmpr", "sys_tick", "sys_tick_cmpr"
98 };
99
100 /* Macros used to extract instruction fields. Not all fields have
101 macros defined here, only those which are actually used. */
102
103 #define X_RD(i) (((i) >> 25) & 0x1f)
104 #define X_RS1(i) (((i) >> 14) & 0x1f)
105 #define X_LDST_I(i) (((i) >> 13) & 1)
106 #define X_ASI(i) (((i) >> 5) & 0xff)
107 #define X_RS2(i) (((i) >> 0) & 0x1f)
108 #define X_IMM(i,n) (((i) >> 0) & ((1 << (n)) - 1))
109 #define X_SIMM(i,n) SEX (X_IMM ((i), (n)), (n))
110 #define X_DISP22(i) (((i) >> 0) & 0x3fffff)
111 #define X_IMM22(i) X_DISP22 (i)
112 #define X_DISP30(i) (((i) >> 0) & 0x3fffffff)
113
114 /* These are for v9. */
115 #define X_DISP16(i) (((((i) >> 20) & 3) << 14) | (((i) >> 0) & 0x3fff))
116 #define X_DISP19(i) (((i) >> 0) & 0x7ffff)
117 #define X_MEMBAR(i) ((i) & 0x7f)
118
119 /* Here is the union which was used to extract instruction fields
120 before the shift and mask macros were written.
121
122 union sparc_insn
123 {
124 unsigned long int code;
125 struct
126 {
127 unsigned int anop:2;
128 #define op ldst.anop
129 unsigned int anrd:5;
130 #define rd ldst.anrd
131 unsigned int op3:6;
132 unsigned int anrs1:5;
133 #define rs1 ldst.anrs1
134 unsigned int i:1;
135 unsigned int anasi:8;
136 #define asi ldst.anasi
137 unsigned int anrs2:5;
138 #define rs2 ldst.anrs2
139 #define shcnt rs2
140 } ldst;
141 struct
142 {
143 unsigned int anop:2, anrd:5, op3:6, anrs1:5, i:1;
144 unsigned int IMM13:13;
145 #define imm13 IMM13.IMM13
146 } IMM13;
147 struct
148 {
149 unsigned int anop:2;
150 unsigned int a:1;
151 unsigned int cond:4;
152 unsigned int op2:3;
153 unsigned int DISP22:22;
154 #define disp22 branch.DISP22
155 #define imm22 disp22
156 } branch;
157 struct
158 {
159 unsigned int anop:2;
160 unsigned int a:1;
161 unsigned int z:1;
162 unsigned int rcond:3;
163 unsigned int op2:3;
164 unsigned int DISP16HI:2;
165 unsigned int p:1;
166 unsigned int _rs1:5;
167 unsigned int DISP16LO:14;
168 } branch16;
169 struct
170 {
171 unsigned int anop:2;
172 unsigned int adisp30:30;
173 #define disp30 call.adisp30
174 } call;
175 }; */
176
177 /* Nonzero if INSN is the opcode for a delayed branch. */
178
179 static int
180 is_delayed_branch (unsigned long insn)
181 {
182 sparc_opcode_hash *op;
183
184 for (op = opcode_hash_table[HASH_INSN (insn)]; op; op = op->next)
185 {
186 const sparc_opcode *opcode = op->opcode;
187
188 if ((opcode->match & insn) == opcode->match
189 && (opcode->lose & insn) == 0)
190 return opcode->flags & F_DELAYED;
191 }
192 return 0;
193 }
194
195 /* extern void qsort (); */
196
197 /* Records current mask of SPARC_OPCODE_ARCH_FOO values, used to pass value
198 to compare_opcodes. */
199 static unsigned int current_arch_mask;
200
201 /* Given BFD mach number, return a mask of SPARC_OPCODE_ARCH_FOO values. */
202
203 static int
204 compute_arch_mask (unsigned long mach)
205 {
206 switch (mach)
207 {
208 case 0 :
209 case bfd_mach_sparc :
210 return SPARC_OPCODE_ARCH_MASK (SPARC_OPCODE_ARCH_V8);
211 case bfd_mach_sparc_sparclet :
212 return SPARC_OPCODE_ARCH_MASK (SPARC_OPCODE_ARCH_SPARCLET);
213 case bfd_mach_sparc_sparclite :
214 case bfd_mach_sparc_sparclite_le :
215 /* sparclites insns are recognized by default (because that's how
216 they've always been treated, for better or worse). Kludge this by
217 indicating generic v8 is also selected. */
218 return (SPARC_OPCODE_ARCH_MASK (SPARC_OPCODE_ARCH_SPARCLITE)
219 | SPARC_OPCODE_ARCH_MASK (SPARC_OPCODE_ARCH_V8));
220 case bfd_mach_sparc_v8plus :
221 case bfd_mach_sparc_v9 :
222 return SPARC_OPCODE_ARCH_MASK (SPARC_OPCODE_ARCH_V9);
223 case bfd_mach_sparc_v8plusa :
224 case bfd_mach_sparc_v9a :
225 return SPARC_OPCODE_ARCH_MASK (SPARC_OPCODE_ARCH_V9A);
226 case bfd_mach_sparc_v8plusb :
227 case bfd_mach_sparc_v9b :
228 return SPARC_OPCODE_ARCH_MASK (SPARC_OPCODE_ARCH_V9B);
229 }
230 abort ();
231 }
232
233 /* Compare opcodes A and B. */
234
235 static int
236 compare_opcodes (const void * a, const void * b)
237 {
238 sparc_opcode *op0 = * (sparc_opcode **) a;
239 sparc_opcode *op1 = * (sparc_opcode **) b;
240 unsigned long int match0 = op0->match, match1 = op1->match;
241 unsigned long int lose0 = op0->lose, lose1 = op1->lose;
242 register unsigned int i;
243
244 /* If one (and only one) insn isn't supported by the current architecture,
245 prefer the one that is. If neither are supported, but they're both for
246 the same architecture, continue processing. Otherwise (both unsupported
247 and for different architectures), prefer lower numbered arch's (fudged
248 by comparing the bitmasks). */
249 if (op0->architecture & current_arch_mask)
250 {
251 if (! (op1->architecture & current_arch_mask))
252 return -1;
253 }
254 else
255 {
256 if (op1->architecture & current_arch_mask)
257 return 1;
258 else if (op0->architecture != op1->architecture)
259 return op0->architecture - op1->architecture;
260 }
261
262 /* If a bit is set in both match and lose, there is something
263 wrong with the opcode table. */
264 if (match0 & lose0)
265 {
266 fprintf
267 (stderr,
268 /* xgettext:c-format */
269 _("Internal error: bad sparc-opcode.h: \"%s\", %#.8lx, %#.8lx\n"),
270 op0->name, match0, lose0);
271 op0->lose &= ~op0->match;
272 lose0 = op0->lose;
273 }
274
275 if (match1 & lose1)
276 {
277 fprintf
278 (stderr,
279 /* xgettext:c-format */
280 _("Internal error: bad sparc-opcode.h: \"%s\", %#.8lx, %#.8lx\n"),
281 op1->name, match1, lose1);
282 op1->lose &= ~op1->match;
283 lose1 = op1->lose;
284 }
285
286 /* Because the bits that are variable in one opcode are constant in
287 another, it is important to order the opcodes in the right order. */
288 for (i = 0; i < 32; ++i)
289 {
290 unsigned long int x = 1 << i;
291 int x0 = (match0 & x) != 0;
292 int x1 = (match1 & x) != 0;
293
294 if (x0 != x1)
295 return x1 - x0;
296 }
297
298 for (i = 0; i < 32; ++i)
299 {
300 unsigned long int x = 1 << i;
301 int x0 = (lose0 & x) != 0;
302 int x1 = (lose1 & x) != 0;
303
304 if (x0 != x1)
305 return x1 - x0;
306 }
307
308 /* They are functionally equal. So as long as the opcode table is
309 valid, we can put whichever one first we want, on aesthetic grounds. */
310
311 /* Our first aesthetic ground is that aliases defer to real insns. */
312 {
313 int alias_diff = (op0->flags & F_ALIAS) - (op1->flags & F_ALIAS);
314
315 if (alias_diff != 0)
316 /* Put the one that isn't an alias first. */
317 return alias_diff;
318 }
319
320 /* Except for aliases, two "identical" instructions had
321 better have the same opcode. This is a sanity check on the table. */
322 i = strcmp (op0->name, op1->name);
323 if (i)
324 {
325 if (op0->flags & F_ALIAS) /* If they're both aliases, be arbitrary. */
326 return i;
327 else
328 fprintf (stderr,
329 /* xgettext:c-format */
330 _("Internal error: bad sparc-opcode.h: \"%s\" == \"%s\"\n"),
331 op0->name, op1->name);
332 }
333
334 /* Fewer arguments are preferred. */
335 {
336 int length_diff = strlen (op0->args) - strlen (op1->args);
337
338 if (length_diff != 0)
339 /* Put the one with fewer arguments first. */
340 return length_diff;
341 }
342
343 /* Put 1+i before i+1. */
344 {
345 char *p0 = (char *) strchr (op0->args, '+');
346 char *p1 = (char *) strchr (op1->args, '+');
347
348 if (p0 && p1)
349 {
350 /* There is a plus in both operands. Note that a plus
351 sign cannot be the first character in args,
352 so the following [-1]'s are valid. */
353 if (p0[-1] == 'i' && p1[1] == 'i')
354 /* op0 is i+1 and op1 is 1+i, so op1 goes first. */
355 return 1;
356 if (p0[1] == 'i' && p1[-1] == 'i')
357 /* op0 is 1+i and op1 is i+1, so op0 goes first. */
358 return -1;
359 }
360 }
361
362 /* Put 1,i before i,1. */
363 {
364 int i0 = strncmp (op0->args, "i,1", 3) == 0;
365 int i1 = strncmp (op1->args, "i,1", 3) == 0;
366
367 if (i0 ^ i1)
368 return i0 - i1;
369 }
370
371 /* They are, as far as we can tell, identical.
372 Since qsort may have rearranged the table partially, there is
373 no way to tell which one was first in the opcode table as
374 written, so just say there are equal. */
375 /* ??? This is no longer true now that we sort a vector of pointers,
376 not the table itself. */
377 return 0;
378 }
379
380 /* Build a hash table from the opcode table.
381 OPCODE_TABLE is a sorted list of pointers into the opcode table. */
382
383 static void
384 build_hash_table (const sparc_opcode **opcode_table,
385 sparc_opcode_hash **hash_table,
386 int num_opcodes)
387 {
388 int i;
389 int hash_count[HASH_SIZE];
390 static sparc_opcode_hash *hash_buf = NULL;
391
392 /* Start at the end of the table and work backwards so that each
393 chain is sorted. */
394
395 memset (hash_table, 0, HASH_SIZE * sizeof (hash_table[0]));
396 memset (hash_count, 0, HASH_SIZE * sizeof (hash_count[0]));
397 if (hash_buf != NULL)
398 free (hash_buf);
399 hash_buf = xmalloc (sizeof (* hash_buf) * num_opcodes);
400 for (i = num_opcodes - 1; i >= 0; --i)
401 {
402 int hash = HASH_INSN (opcode_table[i]->match);
403 sparc_opcode_hash *h = &hash_buf[i];
404
405 h->next = hash_table[hash];
406 h->opcode = opcode_table[i];
407 hash_table[hash] = h;
408 ++hash_count[hash];
409 }
410
411 #if 0 /* for debugging */
412 {
413 int min_count = num_opcodes, max_count = 0;
414 int total;
415
416 for (i = 0; i < HASH_SIZE; ++i)
417 {
418 if (hash_count[i] < min_count)
419 min_count = hash_count[i];
420 if (hash_count[i] > max_count)
421 max_count = hash_count[i];
422 total += hash_count[i];
423 }
424
425 printf ("Opcode hash table stats: min %d, max %d, ave %f\n",
426 min_count, max_count, (double) total / HASH_SIZE);
427 }
428 #endif
429 }
430
431 /* Print one instruction from MEMADDR on INFO->STREAM.
432
433 We suffix the instruction with a comment that gives the absolute
434 address involved, as well as its symbolic form, if the instruction
435 is preceded by a findable `sethi' and it either adds an immediate
436 displacement to that register, or it is an `add' or `or' instruction
437 on that register. */
438
439 int
440 print_insn_sparc (bfd_vma memaddr, disassemble_info *info)
441 {
442 FILE *stream = info->stream;
443 bfd_byte buffer[4];
444 unsigned long insn;
445 sparc_opcode_hash *op;
446 /* Nonzero of opcode table has been initialized. */
447 static int opcodes_initialized = 0;
448 /* bfd mach number of last call. */
449 static unsigned long current_mach = 0;
450 bfd_vma (*getword) (const void *);
451
452 if (!opcodes_initialized
453 || info->mach != current_mach)
454 {
455 int i;
456
457 current_arch_mask = compute_arch_mask (info->mach);
458
459 if (!opcodes_initialized)
460 sorted_opcodes =
461 xmalloc (sparc_num_opcodes * sizeof (sparc_opcode *));
462 /* Reset the sorted table so we can resort it. */
463 for (i = 0; i < sparc_num_opcodes; ++i)
464 sorted_opcodes[i] = &sparc_opcodes[i];
465 qsort ((char *) sorted_opcodes, sparc_num_opcodes,
466 sizeof (sorted_opcodes[0]), compare_opcodes);
467
468 build_hash_table (sorted_opcodes, opcode_hash_table, sparc_num_opcodes);
469 current_mach = info->mach;
470 opcodes_initialized = 1;
471 }
472
473 {
474 int status =
475 (*info->read_memory_func) (memaddr, buffer, sizeof (buffer), info);
476
477 if (status != 0)
478 {
479 (*info->memory_error_func) (status, memaddr, info);
480 return -1;
481 }
482 }
483
484 /* On SPARClite variants such as DANlite (sparc86x), instructions
485 are always big-endian even when the machine is in little-endian mode. */
486 if (info->endian == BFD_ENDIAN_BIG || info->mach == bfd_mach_sparc_sparclite)
487 getword = bfd_getb32;
488 else
489 getword = bfd_getl32;
490
491 insn = getword (buffer);
492
493 info->insn_info_valid = 1; /* We do return this info. */
494 info->insn_type = dis_nonbranch; /* Assume non branch insn. */
495 info->branch_delay_insns = 0; /* Assume no delay. */
496 info->target = 0; /* Assume no target known. */
497
498 for (op = opcode_hash_table[HASH_INSN (insn)]; op; op = op->next)
499 {
500 const sparc_opcode *opcode = op->opcode;
501
502 /* If the insn isn't supported by the current architecture, skip it. */
503 if (! (opcode->architecture & current_arch_mask))
504 continue;
505
506 if ((opcode->match & insn) == opcode->match
507 && (opcode->lose & insn) == 0)
508 {
509 /* Nonzero means that we have found an instruction which has
510 the effect of adding or or'ing the imm13 field to rs1. */
511 int imm_added_to_rs1 = 0;
512 int imm_ored_to_rs1 = 0;
513
514 /* Nonzero means that we have found a plus sign in the args
515 field of the opcode table. */
516 int found_plus = 0;
517
518 /* Nonzero means we have an annulled branch. */
519 int is_annulled = 0;
520
521 /* Do we have an `add' or `or' instruction combining an
522 immediate with rs1? */
523 if (opcode->match == 0x80102000) /* or */
524 imm_ored_to_rs1 = 1;
525 if (opcode->match == 0x80002000) /* add */
526 imm_added_to_rs1 = 1;
527
528 if (X_RS1 (insn) != X_RD (insn)
529 && strchr (opcode->args, 'r') != 0)
530 /* Can't do simple format if source and dest are different. */
531 continue;
532 if (X_RS2 (insn) != X_RD (insn)
533 && strchr (opcode->args, 'O') != 0)
534 /* Can't do simple format if source and dest are different. */
535 continue;
536
537 (*info->fprintf_func) (stream, opcode->name);
538
539 {
540 const char *s;
541
542 if (opcode->args[0] != ',')
543 (*info->fprintf_func) (stream, " ");
544
545 for (s = opcode->args; *s != '\0'; ++s)
546 {
547 while (*s == ',')
548 {
549 (*info->fprintf_func) (stream, ",");
550 ++s;
551 switch (*s)
552 {
553 case 'a':
554 (*info->fprintf_func) (stream, "a");
555 is_annulled = 1;
556 ++s;
557 continue;
558 case 'N':
559 (*info->fprintf_func) (stream, "pn");
560 ++s;
561 continue;
562
563 case 'T':
564 (*info->fprintf_func) (stream, "pt");
565 ++s;
566 continue;
567
568 default:
569 break;
570 }
571 }
572
573 (*info->fprintf_func) (stream, " ");
574
575 switch (*s)
576 {
577 case '+':
578 found_plus = 1;
579 /* Fall through. */
580
581 default:
582 (*info->fprintf_func) (stream, "%c", *s);
583 break;
584
585 case '#':
586 (*info->fprintf_func) (stream, "0");
587 break;
588
589 #define reg(n) (*info->fprintf_func) (stream, "%%%s", reg_names[n])
590 case '1':
591 case 'r':
592 reg (X_RS1 (insn));
593 break;
594
595 case '2':
596 case 'O':
597 reg (X_RS2 (insn));
598 break;
599
600 case 'd':
601 reg (X_RD (insn));
602 break;
603 #undef reg
604
605 #define freg(n) (*info->fprintf_func) (stream, "%%%s", freg_names[n])
606 #define fregx(n) (*info->fprintf_func) (stream, "%%%s", freg_names[((n) & ~1) | (((n) & 1) << 5)])
607 case 'e':
608 freg (X_RS1 (insn));
609 break;
610 case 'v': /* Double/even. */
611 case 'V': /* Quad/multiple of 4. */
612 fregx (X_RS1 (insn));
613 break;
614
615 case 'f':
616 freg (X_RS2 (insn));
617 break;
618 case 'B': /* Double/even. */
619 case 'R': /* Quad/multiple of 4. */
620 fregx (X_RS2 (insn));
621 break;
622
623 case 'g':
624 freg (X_RD (insn));
625 break;
626 case 'H': /* Double/even. */
627 case 'J': /* Quad/multiple of 4. */
628 fregx (X_RD (insn));
629 break;
630 #undef freg
631 #undef fregx
632
633 #define creg(n) (*info->fprintf_func) (stream, "%%c%u", (unsigned int) (n))
634 case 'b':
635 creg (X_RS1 (insn));
636 break;
637
638 case 'c':
639 creg (X_RS2 (insn));
640 break;
641
642 case 'D':
643 creg (X_RD (insn));
644 break;
645 #undef creg
646
647 case 'h':
648 (*info->fprintf_func) (stream, "%%hi(%#x)",
649 ((unsigned) 0xFFFFFFFF
650 & ((int) X_IMM22 (insn) << 10)));
651 break;
652
653 case 'i': /* 13 bit immediate. */
654 case 'I': /* 11 bit immediate. */
655 case 'j': /* 10 bit immediate. */
656 {
657 int imm;
658
659 if (*s == 'i')
660 imm = X_SIMM (insn, 13);
661 else if (*s == 'I')
662 imm = X_SIMM (insn, 11);
663 else
664 imm = X_SIMM (insn, 10);
665
666 /* Check to see whether we have a 1+i, and take
667 note of that fact.
668
669 Note: because of the way we sort the table,
670 we will be matching 1+i rather than i+1,
671 so it is OK to assume that i is after +,
672 not before it. */
673 if (found_plus)
674 imm_added_to_rs1 = 1;
675
676 if (imm <= 9)
677 (*info->fprintf_func) (stream, "%d", imm);
678 else
679 (*info->fprintf_func) (stream, "%#x", imm);
680 }
681 break;
682
683 case 'X': /* 5 bit unsigned immediate. */
684 case 'Y': /* 6 bit unsigned immediate. */
685 {
686 int imm = X_IMM (insn, *s == 'X' ? 5 : 6);
687
688 if (imm <= 9)
689 (info->fprintf_func) (stream, "%d", imm);
690 else
691 (info->fprintf_func) (stream, "%#x", (unsigned) imm);
692 }
693 break;
694
695 case '3':
696 (info->fprintf_func) (stream, "%d", X_IMM (insn, 3));
697 break;
698
699 case 'K':
700 {
701 int mask = X_MEMBAR (insn);
702 int bit = 0x40, printed_one = 0;
703 const char *name;
704
705 if (mask == 0)
706 (info->fprintf_func) (stream, "0");
707 else
708 while (bit)
709 {
710 if (mask & bit)
711 {
712 if (printed_one)
713 (info->fprintf_func) (stream, "|");
714 name = sparc_decode_membar (bit);
715 (info->fprintf_func) (stream, "%s", name);
716 printed_one = 1;
717 }
718 bit >>= 1;
719 }
720 break;
721 }
722
723 case 'k':
724 info->target = memaddr + SEX (X_DISP16 (insn), 16) * 4;
725 (*info->print_address_func) (info->target, info);
726 break;
727
728 case 'G':
729 info->target = memaddr + SEX (X_DISP19 (insn), 19) * 4;
730 (*info->print_address_func) (info->target, info);
731 break;
732
733 case '6':
734 case '7':
735 case '8':
736 case '9':
737 (*info->fprintf_func) (stream, "%%fcc%c", *s - '6' + '0');
738 break;
739
740 case 'z':
741 (*info->fprintf_func) (stream, "%%icc");
742 break;
743
744 case 'Z':
745 (*info->fprintf_func) (stream, "%%xcc");
746 break;
747
748 case 'E':
749 (*info->fprintf_func) (stream, "%%ccr");
750 break;
751
752 case 's':
753 (*info->fprintf_func) (stream, "%%fprs");
754 break;
755
756 case 'o':
757 (*info->fprintf_func) (stream, "%%asi");
758 break;
759
760 case 'W':
761 (*info->fprintf_func) (stream, "%%tick");
762 break;
763
764 case 'P':
765 (*info->fprintf_func) (stream, "%%pc");
766 break;
767
768 case '?':
769 if (X_RS1 (insn) == 31)
770 (*info->fprintf_func) (stream, "%%ver");
771 else if ((unsigned) X_RS1 (insn) < 16)
772 (*info->fprintf_func) (stream, "%%%s",
773 v9_priv_reg_names[X_RS1 (insn)]);
774 else
775 (*info->fprintf_func) (stream, "%%reserved");
776 break;
777
778 case '!':
779 if ((unsigned) X_RD (insn) < 15)
780 (*info->fprintf_func) (stream, "%%%s",
781 v9_priv_reg_names[X_RD (insn)]);
782 else
783 (*info->fprintf_func) (stream, "%%reserved");
784 break;
785
786 case '/':
787 if (X_RS1 (insn) < 16 || X_RS1 (insn) > 25)
788 (*info->fprintf_func) (stream, "%%reserved");
789 else
790 (*info->fprintf_func) (stream, "%%%s",
791 v9a_asr_reg_names[X_RS1 (insn)-16]);
792 break;
793
794 case '_':
795 if (X_RD (insn) < 16 || X_RD (insn) > 25)
796 (*info->fprintf_func) (stream, "%%reserved");
797 else
798 (*info->fprintf_func) (stream, "%%%s",
799 v9a_asr_reg_names[X_RD (insn)-16]);
800 break;
801
802 case '*':
803 {
804 const char *name = sparc_decode_prefetch (X_RD (insn));
805
806 if (name)
807 (*info->fprintf_func) (stream, "%s", name);
808 else
809 (*info->fprintf_func) (stream, "%d", X_RD (insn));
810 break;
811 }
812
813 case 'M':
814 (*info->fprintf_func) (stream, "%%asr%d", X_RS1 (insn));
815 break;
816
817 case 'm':
818 (*info->fprintf_func) (stream, "%%asr%d", X_RD (insn));
819 break;
820
821 case 'L':
822 info->target = memaddr + SEX (X_DISP30 (insn), 30) * 4;
823 (*info->print_address_func) (info->target, info);
824 break;
825
826 case 'n':
827 (*info->fprintf_func)
828 (stream, "%#x", SEX (X_DISP22 (insn), 22));
829 break;
830
831 case 'l':
832 info->target = memaddr + SEX (X_DISP22 (insn), 22) * 4;
833 (*info->print_address_func) (info->target, info);
834 break;
835
836 case 'A':
837 {
838 const char *name = sparc_decode_asi (X_ASI (insn));
839
840 if (name)
841 (*info->fprintf_func) (stream, "%s", name);
842 else
843 (*info->fprintf_func) (stream, "(%d)", X_ASI (insn));
844 break;
845 }
846
847 case 'C':
848 (*info->fprintf_func) (stream, "%%csr");
849 break;
850
851 case 'F':
852 (*info->fprintf_func) (stream, "%%fsr");
853 break;
854
855 case 'p':
856 (*info->fprintf_func) (stream, "%%psr");
857 break;
858
859 case 'q':
860 (*info->fprintf_func) (stream, "%%fq");
861 break;
862
863 case 'Q':
864 (*info->fprintf_func) (stream, "%%cq");
865 break;
866
867 case 't':
868 (*info->fprintf_func) (stream, "%%tbr");
869 break;
870
871 case 'w':
872 (*info->fprintf_func) (stream, "%%wim");
873 break;
874
875 case 'x':
876 (*info->fprintf_func) (stream, "%d",
877 ((X_LDST_I (insn) << 8)
878 + X_ASI (insn)));
879 break;
880
881 case 'y':
882 (*info->fprintf_func) (stream, "%%y");
883 break;
884
885 case 'u':
886 case 'U':
887 {
888 int val = *s == 'U' ? X_RS1 (insn) : X_RD (insn);
889 const char *name = sparc_decode_sparclet_cpreg (val);
890
891 if (name)
892 (*info->fprintf_func) (stream, "%s", name);
893 else
894 (*info->fprintf_func) (stream, "%%cpreg(%d)", val);
895 break;
896 }
897 }
898 }
899 }
900
901 /* If we are adding or or'ing something to rs1, then
902 check to see whether the previous instruction was
903 a sethi to the same register as in the sethi.
904 If so, attempt to print the result of the add or
905 or (in this context add and or do the same thing)
906 and its symbolic value. */
907 if (imm_ored_to_rs1 || imm_added_to_rs1)
908 {
909 unsigned long prev_insn;
910 int errcode;
911
912 if (memaddr >= 4)
913 errcode =
914 (*info->read_memory_func)
915 (memaddr - 4, buffer, sizeof (buffer), info);
916 else
917 errcode = 1;
918
919 prev_insn = getword (buffer);
920
921 if (errcode == 0)
922 {
923 /* If it is a delayed branch, we need to look at the
924 instruction before the delayed branch. This handles
925 sequences such as:
926
927 sethi %o1, %hi(_foo), %o1
928 call _printf
929 or %o1, %lo(_foo), %o1 */
930
931 if (is_delayed_branch (prev_insn))
932 {
933 if (memaddr >= 8)
934 errcode = (*info->read_memory_func)
935 (memaddr - 8, buffer, sizeof (buffer), info);
936 else
937 errcode = 1;
938
939 prev_insn = getword (buffer);
940 }
941 }
942
943 /* If there was a problem reading memory, then assume
944 the previous instruction was not sethi. */
945 if (errcode == 0)
946 {
947 /* Is it sethi to the same register? */
948 if ((prev_insn & 0xc1c00000) == 0x01000000
949 && X_RD (prev_insn) == X_RS1 (insn))
950 {
951 (*info->fprintf_func) (stream, "\t! ");
952 info->target =
953 ((unsigned) 0xFFFFFFFF
954 & ((int) X_IMM22 (prev_insn) << 10));
955 if (imm_added_to_rs1)
956 info->target += X_SIMM (insn, 13);
957 else
958 info->target |= X_SIMM (insn, 13);
959 (*info->print_address_func) (info->target, info);
960 info->insn_type = dis_dref;
961 info->data_size = 4; /* FIXME!!! */
962 }
963 }
964 }
965
966 if (opcode->flags & (F_UNBR|F_CONDBR|F_JSR))
967 {
968 /* FIXME -- check is_annulled flag. */
969 if (opcode->flags & F_UNBR)
970 info->insn_type = dis_branch;
971 if (opcode->flags & F_CONDBR)
972 info->insn_type = dis_condbranch;
973 if (opcode->flags & F_JSR)
974 info->insn_type = dis_jsr;
975 if (opcode->flags & F_DELAYED)
976 info->branch_delay_insns = 1;
977 }
978
979 return sizeof (buffer);
980 }
981 }
982
983 info->insn_type = dis_noninsn; /* Mark as non-valid instruction. */
984 (*info->fprintf_func) (stream, _("unknown"));
985 return sizeof (buffer);
986 }
GDB Binutils - Deliverables
This page took 0.080265 seconds and 5 git commands to generate.