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