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