opcodes/csky-dis.c

   1 /* C-SKY disassembler.
   2    Copyright (C) 1988-2022 Free Software Foundation, Inc.
   3    Contributed by C-SKY Microsystems and Mentor Graphics.
   4
   5    This file is part of the GNU opcodes library.
   6
   7    This library is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3, or (at your option)
  10    any later version.
  11
  12    It is distributed in the hope that it will be useful, but WITHOUT
  13    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  14    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  15    License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  20    MA 02110-1301, USA.  */
  21
  22 #include "sysdep.h"
  23 #include "config.h"
  24 #include <stdio.h>
  25 #include <stdint.h>
  26 #include <elf/csky.h>
  27 #include "disassemble.h"
  28 #include "elf-bfd.h"
  29 #include "opcode/csky.h"
  30 #include "libiberty.h"
  31 #include "csky-opc.h"
  32 #include "floatformat.h"
  33
  34 #define CSKY_INST_TYPE unsigned long
  35 #define HAS_SUB_OPERAND (unsigned int)0xffffffff
  36 #define CSKY_DEFAULT_ISA 0xffffffff
  37
  38 enum sym_type
  39 {
  40   CUR_TEXT,
  41   CUR_DATA
  42 };
  43
  44 struct csky_dis_info
  45 {
  46   /* Mem to disassemble.  */
  47   bfd_vma mem;
  48   /* Disassemble info.  */
  49   disassemble_info *info;
  50   /* Opcode information.  */
  51   struct csky_opcode_info const *opinfo;
  52   uint64_t isa;
  53   /* The value of operand to show.  */
  54   int value;
  55   /* Whether to look up/print a symbol name.  */
  56   int need_output_symbol;
  57 } dis_info;
  58
  59
  60 enum sym_type last_type;
  61 int last_map_sym = 1;
  62 bfd_vma last_map_addr = 0;
  63 int using_abi = 0;
  64
  65 /* Only for objdump tool.  */
  66 #define INIT_MACH_FLAG  0xffffffff
  67 #define BINARY_MACH_FLAG 0x0
  68
  69 static unsigned int mach_flag = INIT_MACH_FLAG;
  70
  71 static void
  72 print_insn_data (bfd_vma pc ATTRIBUTE_UNUSED,
  73                  struct disassemble_info *info,
  74                  long given)
  75 {
  76   switch (info->bytes_per_chunk)
  77     {
  78     case 1:
  79       info->fprintf_func (info->stream, ".byte\t0x%02lx", given);
  80       break;
  81     case 2:
  82       info->fprintf_func (info->stream, ".short\t0x%04lx", given);
  83       break;
  84     case 4:
  85       info->fprintf_func (info->stream, ".long\t0x%08lx", given);
  86       break;
  87     default:
  88       abort ();
  89     }
  90 }
  91
  92 static int
  93 get_sym_code_type (struct disassemble_info *info,
  94                    int n,
  95                    enum sym_type *sym_type)
  96 {
  97   const char *name;
  98   name = bfd_asymbol_name (info->symtab[n]);
  99   if (name[0] == '$' && (name[1] == 't' || name[1] == 'd')
 100       && (name[2] == 0 || name[2] == '.'))
 101     {
 102       *sym_type = ((name[1] == 't') ? CUR_TEXT : CUR_DATA);
 103       return true;
 104     }
 105   return false;
 106 }
 107
 108 static int
 109 csky_get_operand_mask (struct operand const *oprnd)
 110 {
 111   int mask = 0;
 112   if (oprnd->mask == HAS_SUB_OPERAND)
 113     {
 114       struct soperand *sop = (struct soperand *)oprnd;
 115       mask |= csky_get_operand_mask (&sop->subs[0]);
 116       mask |= csky_get_operand_mask (&sop->subs[1]);
 117       return mask;
 118     }
 119   return oprnd->mask;
 120 }
 121
 122 static int
 123 csky_get_mask (struct csky_opcode_info const *pinfo)
 124 {
 125   int i = 0;
 126   int mask = 0;
 127   /* List type.  */
 128   if (pinfo->operand_num == -1)
 129     mask |= csky_get_operand_mask (&pinfo->oprnd.oprnds[i]);
 130   else
 131     for (; i < pinfo->operand_num; i++)
 132       mask |= csky_get_operand_mask (&pinfo->oprnd.oprnds[i]);
 133
 134   mask = ~mask;
 135   return mask;
 136 }
 137
 138 static unsigned int
 139 csky_chars_to_number (unsigned char * buf, int n)
 140 {
 141   int i;
 142   unsigned int val = 0;
 143
 144   if (dis_info.info->endian == BFD_ENDIAN_BIG)
 145     for (i = 0; i < n; i++)
 146       val = val << 8 | buf[i];
 147   else
 148     for (i = n - 1; i >= 0; i--)
 149       val = val << 8 | buf[i];
 150   return val;
 151 }
 152
 153 static struct csky_opcode const *g_opcodeP;
 154
 155 static struct csky_opcode const *
 156 csky_find_inst_info (struct csky_opcode_info const **pinfo,
 157                      CSKY_INST_TYPE inst, int length)
 158 {
 159   int i;
 160   unsigned int mask;
 161   struct csky_opcode const *p;
 162
 163   p = g_opcodeP;
 164   while (p->mnemonic)
 165     {
 166         if (!(p->isa_flag16 & dis_info.isa)
 167               && !(p->isa_flag32 & dis_info.isa))
 168         {
 169           p++;
 170           continue;
 171         }
 172
 173       /* Get the opcode mask.  */
 174       for (i = 0; i < OP_TABLE_NUM; i++)
 175         if (length == 2)
 176           {
 177             mask =  csky_get_mask (&p->op16[i]);
 178             if (mask != 0 && (inst & mask) == p->op16[i].opcode)
 179               {
 180                 *pinfo = &p->op16[i];
 181                 g_opcodeP = p;
 182                 return p;
 183               }
 184           }
 185         else if (length == 4)
 186           {
 187             mask =  csky_get_mask (&p->op32[i]);
 188             if (mask != 0
 189                 && ((unsigned long)(inst & mask)
 190                     == (unsigned long)p->op32[i].opcode))
 191               {
 192                 *pinfo = &p->op32[i];
 193                 g_opcodeP = p;
 194                 return p;
 195               }
 196           }
 197       p++;
 198     }
 199
 200   return NULL;
 201 }
 202
 203 static bool
 204 is_extern_symbol (struct disassemble_info *info, int addr)
 205 {
 206   unsigned int rel_count = 0;
 207
 208   if (info->section == NULL)
 209     return 0;
 210   if ((info->section->flags & SEC_RELOC) != 0)  /* Fit .o file.  */
 211     {
 212       struct reloc_cache_entry *pt = info->section->relocation;
 213       for (; rel_count < info->section->reloc_count; rel_count++, pt++)
 214         if ((long unsigned int)addr == pt->address)
 215           return true;
 216       return false;
 217     }
 218   return false;
 219 }
 220
 221
 222 /* Suppress printing of mapping symbols emitted by the assembler to mark
 223    the beginning of code and data sequences.  */
 224
 225 bool
 226 csky_symbol_is_valid (asymbol *sym,
 227                       struct disassemble_info *info ATTRIBUTE_UNUSED)
 228 {
 229   const char *name;
 230
 231   if (sym == NULL)
 232     return false;
 233   name = bfd_asymbol_name (sym);
 234   return name && *name != '$';
 235 }
 236
 237 disassembler_ftype
 238 csky_get_disassembler (bfd *abfd)
 239 {
 240   obj_attribute *attr;
 241   const char *sec_name = NULL;
 242   if (!abfd || bfd_get_flavour (abfd) != bfd_target_elf_flavour)
 243     dis_info.isa = CSKY_DEFAULT_ISA;
 244   else
 245     {
 246       mach_flag = elf_elfheader (abfd)->e_flags;
 247
 248       sec_name = get_elf_backend_data (abfd)->obj_attrs_section;
 249       /* Skip any input that hasn't attribute section.
 250          This enables to link object files without attribute section with
 251          any others.  */
 252       if (bfd_get_section_by_name (abfd, sec_name) != NULL)
 253         {
 254           attr = elf_known_obj_attributes_proc (abfd);
 255           dis_info.isa = attr[Tag_CSKY_ISA_EXT_FLAGS].i;
 256           dis_info.isa <<= 32;
 257           dis_info.isa |= attr[Tag_CSKY_ISA_FLAGS].i;
 258         }
 259       else
 260         dis_info.isa = CSKY_DEFAULT_ISA;
 261     }
 262
 263    return print_insn_csky;
 264 }
 265
 266 /* Parse the string of disassembler options.  */
 267 static void
 268 parse_csky_dis_options (const char *opts_in)
 269 {
 270   char *opts = xstrdup (opts_in);
 271   char *opt = opts;
 272   char *opt_end = opts;
 273
 274   for (; opt_end != NULL; opt = opt_end + 1)
 275     {
 276       if ((opt_end = strchr (opt, ',')) != NULL)
 277         *opt_end = 0;
 278       if (strcmp (opt, "abi-names") == 0)
 279         using_abi = 1;
 280       else
 281         fprintf (stderr,
 282                  "unrecognized disassembler option: %s", opt);
 283     }
 284 }
 285
 286 /* Get general register name.  */
 287 static const char *
 288 get_gr_name (int regno)
 289 {
 290   return csky_get_general_reg_name (mach_flag, regno, using_abi);
 291 }
 292
 293 /* Get control register name.  */
 294 static const char *
 295 get_cr_name (unsigned int regno, int bank)
 296 {
 297   return csky_get_control_reg_name (mach_flag, bank, regno, using_abi);
 298 }
 299
 300 static int
 301 csky_output_operand (char *str, struct operand const *oprnd,
 302                      CSKY_INST_TYPE inst, int reloc ATTRIBUTE_UNUSED)
 303 {
 304   int ret = 0;;
 305   int bit = 0;
 306   int result = 0;
 307   bfd_vma value;
 308   int mask = oprnd->mask;
 309   int max = 0;
 310   char buf[128];
 311
 312   /* Get operand value with mask.  */
 313   value = inst & mask;
 314   for (; mask; mask >>= 1, value >>=1)
 315     if (mask & 0x1)
 316       {
 317         result |= ((value & 0x1) << bit);
 318         max |= (1 << bit);
 319         bit++;
 320       }
 321   value = result;
 322
 323   /* Here is general instructions that have no reloc.  */
 324   switch (oprnd->type)
 325     {
 326     case OPRND_TYPE_CTRLREG:
 327         if (IS_CSKY_V1(mach_flag) && ((value & 0x1f) == 0x1f))
 328           return -1;
 329         strcat (str, get_cr_name((value & 0x1f), (value >> 5)));
 330         break;
 331     case OPRND_TYPE_DUMMY_REG:
 332       mask = dis_info.opinfo->oprnd.oprnds[0].mask;
 333       value = inst & mask;
 334       for (; mask; mask >>= 1, value >>=1)
 335         if (mask & 0x1)
 336           {
 337             result |= ((value & 0x1) << bit);
 338             bit++;
 339           }
 340       value = result;
 341       strcat (str, get_gr_name (value));
 342       break;
 343     case OPRND_TYPE_GREG0_7:
 344     case OPRND_TYPE_GREG0_15:
 345     case OPRND_TYPE_GREG16_31:
 346     case OPRND_TYPE_REGnsplr:
 347     case OPRND_TYPE_AREG:
 348       strcat (str, get_gr_name (value));
 349       break;
 350     case OPRND_TYPE_CPREG:
 351       sprintf (buf, "cpr%d", (int)value);
 352       strcat (str, buf);
 353       break;
 354     case OPRND_TYPE_FREG:
 355       sprintf (buf, "fr%d", (int)value);
 356       strcat (str, buf);
 357       break;
 358     case OPRND_TYPE_VREG:
 359       dis_info.value = value;
 360       sprintf (buf, "vr%d", (int)value);
 361       strcat (str, buf);
 362       break;
 363     case OPRND_TYPE_CPCREG:
 364       sprintf (buf, "cpcr%d", (int)value);
 365       strcat (str, buf);
 366       break;
 367     case OPRND_TYPE_CPIDX:
 368       sprintf (buf, "cp%d", (int)value);
 369       strcat (str, buf);
 370       break;
 371     case OPRND_TYPE_IMM2b_JMPIX:
 372       value = (value + 2) << 3;
 373       sprintf (buf, "%d", (int)value);
 374       strcat (str, buf);
 375       break;
 376     case OPRND_TYPE_IMM_LDST:
 377     case OPRND_TYPE_IMM_FLDST:
 378       value <<= oprnd->shift;
 379       sprintf (buf, "0x%x", (unsigned int)value);
 380       strcat (str, buf);
 381       break;
 382     case OPRND_TYPE_IMM7b_LS2:
 383     case OPRND_TYPE_IMM8b_LS2:
 384       sprintf (buf, "%d", (int)(value << 2));
 385       strcat (str, buf);
 386       ret = 0;
 387       break;
 388     case OPRND_TYPE_IMM5b_BMASKI:
 389       if ((value != 0) && (value > 31 || value < 8))
 390         {
 391           ret = -1;
 392           break;
 393         }
 394       sprintf (buf, "%d", (int)value);
 395       strcat (str, buf);
 396       ret = 0;
 397       break;
 398     case OPRND_TYPE_IMM5b_1_31:
 399       if (value > 31 || value < 1)
 400         {
 401           ret = -1;
 402           break;
 403         }
 404       sprintf (buf, "%d", (int)value);
 405       strcat (str, buf);
 406       ret = 0;
 407       break;
 408     case OPRND_TYPE_IMM5b_7_31:
 409       if (value > 31 || value < 7)
 410         {
 411           ret = -1;
 412           break;
 413         }
 414       sprintf (buf, "%d", (int)value);
 415       strcat (str, buf);
 416       ret = 0;
 417       break;
 418     case OPRND_TYPE_IMM5b_VSH:
 419       {
 420         char num[128];
 421         value = ((value & 0x1) << 4) | (value >> 1);
 422         sprintf (num, "%d", (int)value);
 423         strcat (str, num);
 424         ret = 0;
 425         break;
 426       }
 427     case OPRND_TYPE_MSB2SIZE:
 428     case OPRND_TYPE_LSB2SIZE:
 429       {
 430         static int size;
 431         if (oprnd->type == OPRND_TYPE_MSB2SIZE)
 432           size = value;
 433         else
 434           {
 435             str[strlen (str) - 2] = '\0';
 436             sprintf (buf, "%d, %d", (int)(size + value), (int)value);
 437             strcat (str, buf);
 438           }
 439         break;
 440       }
 441     case OPRND_TYPE_IMM1b:
 442     case OPRND_TYPE_IMM2b:
 443     case OPRND_TYPE_IMM4b:
 444     case OPRND_TYPE_IMM5b:
 445     case OPRND_TYPE_IMM5b_LS:
 446     case OPRND_TYPE_IMM7b:
 447     case OPRND_TYPE_IMM8b:
 448     case OPRND_TYPE_IMM12b:
 449     case OPRND_TYPE_IMM15b:
 450     case OPRND_TYPE_IMM16b:
 451     case OPRND_TYPE_IMM16b_MOVIH:
 452     case OPRND_TYPE_IMM16b_ORI:
 453       sprintf (buf, "%d", (int)value);
 454       strcat (str, buf);
 455       ret = 0;
 456       break;
 457     case OPRND_TYPE_OFF8b:
 458     case OPRND_TYPE_OFF16b:
 459       {
 460         unsigned char ibytes[4];
 461         int shift = oprnd->shift;
 462         int status;
 463         unsigned int mem_val;
 464
 465         dis_info.info->stop_vma = 0;
 466
 467         value = ((dis_info.mem + (value << shift)
 468                   + ((IS_CSKY_V1 (mach_flag)) ? 2 : 0))
 469                  & 0xfffffffc);
 470         status = dis_info.info->read_memory_func (value, ibytes, 4,
 471                                                   dis_info.info);
 472         if (status != 0)
 473           {
 474             dis_info.info->memory_error_func (status, dis_info.mem,
 475                                               dis_info.info);
 476             return -1;
 477           }
 478         mem_val = csky_chars_to_number (ibytes, 4);
 479         /* Remove [] around literal value to match ABI syntax.  */
 480         sprintf (buf, "0x%X", mem_val);
 481         strcat (str, buf);
 482         /* For jmpi/jsri, we'll try to get a symbol for the target.  */
 483         if (dis_info.info->print_address_func && mem_val != 0)
 484           {
 485             dis_info.value = mem_val;
 486             dis_info.need_output_symbol = 1;
 487           }
 488         else
 489           {
 490             sprintf (buf, "\t// from address pool at 0x%x",
 491                      (unsigned int)value);
 492             strcat (str, buf);
 493           }
 494         break;
 495       }
 496     case OPRND_TYPE_BLOOP_OFF4b:
 497     case OPRND_TYPE_BLOOP_OFF12b:
 498     case OPRND_TYPE_OFF11b:
 499     case OPRND_TYPE_OFF16b_LSL1:
 500     case OPRND_TYPE_IMM_OFF18b:
 501     case OPRND_TYPE_OFF26b:
 502       {
 503         int shift = oprnd->shift;
 504         if (value & ((max >> 1) + 1))
 505           value |= ~max;
 506         if (is_extern_symbol (dis_info.info, dis_info.mem))
 507           value = 0;
 508         else if (IS_CSKY_V1 (mach_flag))
 509           value = dis_info.mem + 2 + (value << shift);
 510         else
 511           value = dis_info.mem + (value << shift);
 512         dis_info.need_output_symbol = 1;
 513         dis_info.value= value;
 514         sprintf (buf, "0x%x", (unsigned int)value);
 515         strcat (str, buf);
 516         break;
 517       }
 518     case OPRND_TYPE_CONSTANT:
 519     case OPRND_TYPE_FCONSTANT:
 520       {
 521         int shift = oprnd->shift;
 522         char ibytes[8];
 523         int status;
 524         bfd_vma addr;
 525         int nbytes;
 526
 527         dis_info.info->stop_vma = 0;
 528         value <<= shift;
 529
 530         if (IS_CSKY_V1 (mach_flag))
 531           addr = (dis_info.mem + 2 + value) & 0xfffffffc;
 532         else
 533           addr = (dis_info.mem + value) & 0xfffffffc;
 534
 535         if (oprnd->type == OPRND_TYPE_FCONSTANT
 536             && dis_info.opinfo->opcode != CSKYV2_INST_FLRW)
 537           nbytes = 8;
 538         else
 539           nbytes = 4;
 540
 541         status = dis_info.info->read_memory_func (addr, (bfd_byte *)ibytes,
 542                                                   nbytes, dis_info.info);
 543         if (status != 0)
 544           /* Address out of bounds.  -> lrw rx, [pc, 0ffset]. */
 545           sprintf (buf, "[pc, %d]\t// from address pool at %x", (int)value,
 546                    (unsigned int)addr);
 547         else
 548           {
 549             dis_info.value = addr;
 550             value = csky_chars_to_number ((unsigned char *)ibytes, 4);
 551           }
 552
 553         if (oprnd->type == OPRND_TYPE_FCONSTANT)
 554           {
 555             double f;
 556
 557             if (dis_info.opinfo->opcode == CSKYV2_INST_FLRW)
 558               /* flrws.  */
 559               floatformat_to_double ((dis_info.info->endian == BFD_ENDIAN_BIG
 560                                       ? &floatformat_ieee_single_big
 561                                       : &floatformat_ieee_single_little),
 562                                      ibytes, &f);
 563             else
 564               floatformat_to_double ((dis_info.info->endian == BFD_ENDIAN_BIG
 565                                       ? &floatformat_ieee_double_big
 566                                       : &floatformat_ieee_double_little),
 567                                      ibytes, &f);
 568             sprintf (buf, "%.7g", f);
 569           }
 570         else
 571           {
 572             dis_info.need_output_symbol = 1;
 573             sprintf (buf, "0x%x", (unsigned int)value);
 574           }
 575
 576         strcat (str, buf);
 577         break;
 578       }
 579     case OPRND_TYPE_ELRW_CONSTANT:
 580       {
 581         int shift = oprnd->shift;
 582         char ibytes[4];
 583         int status;
 584         bfd_vma addr;
 585         dis_info.info->stop_vma = 0;
 586
 587         value = 0x80 + ((~value) & 0x7f);
 588
 589         value = value << shift;
 590         addr = (dis_info.mem + value) & 0xfffffffc;
 591
 592         status = dis_info.info->read_memory_func (addr, (bfd_byte *)ibytes,
 593                                                   4, dis_info.info);
 594         if (status != 0)
 595           /* Address out of bounds.  -> lrw rx, [pc, 0ffset]. */
 596           sprintf (buf, "[pc, %d]\t// from address pool at %x", (int) value,
 597                    (unsigned int)addr);
 598         else
 599           {
 600             dis_info.value = addr;
 601             value = csky_chars_to_number ((unsigned char *)ibytes, 4);
 602             dis_info.need_output_symbol = 1;
 603             sprintf (buf, "0x%x", (unsigned int)value);
 604           }
 605
 606         strcat (str, buf);
 607         break;
 608       }
 609     case OPRND_TYPE_SFLOAT:
 610     case OPRND_TYPE_DFLOAT:
 611       {
 612         /* This is for fmovis/fmovid, which have an internal 13-bit
 613            encoding that they convert to single/double precision
 614            (respectively).  We'll convert the 13-bit encoding to an IEEE
 615            double and then to host double format to print it.
 616            Sign bit: bit 20.
 617            4-bit exponent: bits 19:16, biased by 11.
 618            8-bit mantissa: split between 24:21 and 7:4.  */
 619         uint64_t imm4;
 620         uint64_t imm8;
 621         uint64_t dbnum;
 622         unsigned char valbytes[8];
 623         double fvalue;
 624
 625         imm4 = ((inst >> 16) & 0xf);
 626         imm4 = (uint64_t)(1023 - (imm4 - 11)) << 52;
 627
 628         imm8 = (uint64_t)((inst >> 4) & 0xf) << 44;
 629         imm8 |= (uint64_t)((inst >> 21) & 0xf) << 48;
 630
 631         dbnum = (uint64_t)((inst >> 20) & 1) << 63;
 632         dbnum |= imm4 | imm8;
 633
 634         /* Do this a byte at a time so we don't have to
 635            worry about the host's endianness.  */
 636         valbytes[0] = dbnum & 0xff;
 637         valbytes[1] = (dbnum >> 8) & 0xff;
 638         valbytes[2] = (dbnum >> 16) & 0xff;
 639         valbytes[3] = (dbnum >> 24) & 0xff;
 640         valbytes[4] = (dbnum >> 32) & 0xff;
 641         valbytes[5] = (dbnum >> 40) & 0xff;
 642         valbytes[6] = (dbnum >> 48) & 0xff;
 643         valbytes[7] = (dbnum >> 56) & 0xff;
 644
 645         floatformat_to_double (&floatformat_ieee_double_little, valbytes,
 646                                &fvalue);
 647
 648         sprintf (buf, "%.7g", fvalue);
 649         strcat (str, buf);
 650         break;
 651       }
 652     case OPRND_TYPE_HFLOAT_FMOVI:
 653     case OPRND_TYPE_SFLOAT_FMOVI:
 654       {
 655         int imm4;
 656         int imm8;
 657         imm4 = ((inst >> 16) & 0xf);
 658         imm4 = (138 - imm4) << 23;
 659
 660         imm8 = ((inst >> 8) & 0x3);
 661         imm8 |= (((inst >> 20) & 0x3f) << 2);
 662         imm8 <<= 15;
 663
 664         value = ((inst >> 5) & 1) << 31;
 665         value |= imm4 | imm8;
 666
 667         imm4 = 138 - (imm4 >> 23);
 668         imm8 >>= 15;
 669         if ((inst >> 5) & 1)
 670           {
 671             imm8 = 0 - imm8;
 672           }
 673
 674         float f = 0;
 675         memcpy (&f, &value, sizeof (float));
 676         sprintf (buf, "%.7g\t// imm9:%4d, imm4:%2d", f, imm8, imm4);
 677         strcat (str, buf);
 678
 679         break;
 680       }
 681
 682     case OPRND_TYPE_DFLOAT_FMOVI:
 683       {
 684         uint64_t imm4;
 685         uint64_t imm8;
 686         uint64_t dvalue;
 687         imm4 = ((inst >> 16) & 0xf);
 688         imm4 = (1034 - imm4) << 52;
 689
 690         imm8 = ((inst >> 8) & 0x3);
 691         imm8 |= (((inst >> 20) & 0x3f) << 2);
 692         imm8 <<= 44;
 693
 694         dvalue = (((uint64_t)inst >> 5) & 1) << 63;
 695         dvalue |= imm4 | imm8;
 696
 697         imm4 = 1034 - (imm4 >> 52);
 698         imm8 >>= 44;
 699         if (inst >> 5)
 700           {
 701             imm8 = 0 - imm8;
 702           }
 703         double d = 0;
 704         memcpy (&d, &dvalue, sizeof (double));
 705         sprintf (buf, "%.7g\t// imm9:%4ld, imm4:%2ld", d, (long) imm8, (long) imm4);
 706         strcat (str, buf);
 707
 708         break;
 709       }
 710     case OPRND_TYPE_LABEL_WITH_BRACKET:
 711       sprintf (buf, "[0x%x]", (unsigned int)value);
 712       strcat (str, buf);
 713       strcat (str, "\t// the offset is based on .data");
 714       break;
 715     case OPRND_TYPE_OIMM3b:
 716     case OPRND_TYPE_OIMM4b:
 717     case OPRND_TYPE_OIMM5b:
 718     case OPRND_TYPE_OIMM5b_IDLY:
 719     case OPRND_TYPE_OIMM8b:
 720     case OPRND_TYPE_OIMM12b:
 721     case OPRND_TYPE_OIMM16b:
 722     case OPRND_TYPE_OIMM18b:
 723       value += 1;
 724       sprintf (buf, "%d", (int)value);
 725       strcat (str, buf);
 726       break;
 727     case OPRND_TYPE_OIMM5b_BMASKI:
 728       if (value > 32 || value < 16)
 729         {
 730           ret = -1;
 731           break;
 732         }
 733       sprintf (buf, "%d", (int)(value + 1));
 734       strcat (str, buf);
 735       ret = 0;
 736       break;
 737     case OPRND_TYPE_FREGLIST_DASH:
 738       if (IS_CSKY_V2 (mach_flag))
 739         {
 740           int vrx = 0;
 741           int vry = 0;
 742           if (dis_info.isa & CSKY_ISA_FLOAT_7E60
 743               && (strstr (str, "fstm") != NULL
 744                   || strstr (str, "fldm") != NULL))
 745             {
 746               vrx = value & 0x1f;
 747               vry = vrx + (value >> 5);
 748             }
 749           else
 750             {
 751               vrx = value & 0xf;
 752               vry = vrx + (value >> 4);
 753             }
 754           sprintf (buf, "fr%d-fr%d", vrx, vry);
 755           strcat (str, buf);
 756         }
 757       break;
 758     case OPRND_TYPE_REGLIST_DASH:
 759       if (IS_CSKY_V1 (mach_flag))
 760         {
 761           sprintf (buf, "%s-r15", get_gr_name (value));
 762           strcat (str, buf);
 763         }
 764       else
 765         {
 766           if ((value & 0x1f) + (value >> 5) > 31)
 767             {
 768               ret = -1;
 769               break;
 770             }
 771           strcat (str, get_gr_name ((value >> 5)));
 772           strcat (str, "-");
 773           strcat (str, get_gr_name ((value & 0x1f) + (value >> 5)));
 774         }
 775       break;
 776     case OPRND_TYPE_PSR_BITS_LIST:
 777       {
 778         struct psrbit const *bits;
 779         int first_oprnd = true;
 780         int i = 0;
 781         if (IS_CSKY_V1 (mach_flag))
 782           {
 783             if (value == 0)
 784               {
 785                 strcat (str, "af");
 786                 break;
 787               }
 788             bits = cskyv1_psr_bits;
 789           }
 790         else
 791           bits = cskyv2_psr_bits;
 792         while (value != 0 && bits[i].name != NULL)
 793             {
 794               if (value & bits[i].value)
 795                 {
 796                   if (!first_oprnd)
 797                     strcat (str, ", ");
 798                   strcat (str, bits[i].name);
 799                   value &= ~bits[i].value;
 800                   first_oprnd = false;
 801                 }
 802               i++;
 803             }
 804         break;
 805       }
 806     case OPRND_TYPE_REGbsp:
 807       if (IS_CSKY_V1 (mach_flag))
 808         sprintf(buf, "(%s)", get_gr_name (0));
 809       else
 810         sprintf(buf, "(%s)", get_gr_name (14));
 811       strcat (str, buf);
 812       break;
 813     case OPRND_TYPE_REGsp:
 814       if (IS_CSKY_V1 (mach_flag))
 815         strcat (str, get_gr_name (0));
 816       else
 817         strcat (str, get_gr_name (14));
 818       break;
 819     case OPRND_TYPE_REGnr4_r7:
 820     case OPRND_TYPE_AREG_WITH_BRACKET:
 821       strcat (str, "(");
 822       strcat (str, get_gr_name (value));
 823       strcat (str, ")");
 824       break;
 825     case OPRND_TYPE_AREG_WITH_LSHIFT:
 826       strcat (str, get_gr_name (value >> 5));
 827       strcat (str, " << ");
 828       if ((value & 0x1f) == 0x1)
 829         strcat (str, "0");
 830       else if ((value & 0x1f) == 0x2)
 831         strcat (str, "1");
 832       else if ((value & 0x1f) == 0x4)
 833         strcat (str, "2");
 834       else if ((value & 0x1f) == 0x8)
 835         strcat (str, "3");
 836       break;
 837     case OPRND_TYPE_AREG_WITH_LSHIFT_FPU:
 838       strcat (str, get_gr_name (value >> 2));
 839       strcat (str, " << ");
 840       if ((value & 0x3) == 0x0)
 841         strcat (str, "0");
 842       else if ((value & 0x3) == 0x1)
 843         strcat (str, "1");
 844       else if ((value & 0x3) == 0x2)
 845         strcat (str, "2");
 846       else if ((value & 0x3) == 0x3)
 847         strcat (str, "3");
 848       break;
 849     case OPRND_TYPE_VREG_WITH_INDEX:
 850       {
 851         unsigned freg_val = value & 0xf;
 852         unsigned index_val = (value >> 4) & 0xf;
 853         sprintf (buf, "vr%d[%d]", freg_val, index_val);
 854         strcat(str, buf);
 855         break;
 856       }
 857     case OPRND_TYPE_FREG_WITH_INDEX:
 858       {
 859         unsigned freg_val = value & 0xf;
 860         unsigned index_val = (value >> 4) & 0xf;
 861         sprintf (buf, "fr%d[%d]", freg_val, index_val);
 862         strcat(str, buf);
 863         break;
 864       }
 865     case OPRND_TYPE_REGr4_r7:
 866       if (IS_CSKY_V1 (mach_flag))
 867         {
 868           sprintf (buf, "%s-%s", get_gr_name (4), get_gr_name (7));
 869           strcat (str, buf);
 870         }
 871       break;
 872     case OPRND_TYPE_CONST1:
 873       strcat (str, "1");
 874       break;
 875     case OPRND_TYPE_REG_r1a:
 876     case OPRND_TYPE_REG_r1b:
 877       strcat (str, get_gr_name (1));
 878       break;
 879     case OPRND_TYPE_REG_r28:
 880       strcat (str, get_gr_name (28));
 881       break;
 882     case OPRND_TYPE_REGLIST_DASH_COMMA:
 883       /* 16-bit reglist.  */
 884       if (value & 0xf)
 885         {
 886           strcat (str, get_gr_name (4));
 887           if ((value & 0xf) > 1)
 888             {
 889               strcat (str, "-");
 890               strcat (str, get_gr_name ((value & 0xf) + 3));
 891             }
 892           if (value & ~0xf)
 893             strcat (str, ", ");
 894         }
 895       if (value & 0x10)
 896         {
 897           /* r15.  */
 898           strcat (str, get_gr_name (15));
 899           if (value & ~0x1f)
 900             strcat (str, ", ");
 901         }
 902       if (dis_info.opinfo->oprnd.oprnds[0].mask != OPRND_MASK_0_4)
 903         {
 904           /* 32bits reglist.  */
 905           value >>= 5;
 906           if (value & 0x3)
 907             {
 908               strcat (str, get_gr_name (16));
 909               if ((value & 0x7) > 1)
 910                 {
 911                   strcat (str, "-");
 912                   strcat (str, get_gr_name ((value & 0x7) + 15));
 913                 }
 914               if (value & ~0x7)
 915                 strcat (str, ", ");
 916               }
 917           if (value & 0x8)
 918             /* r15.  */
 919             strcat (str, get_gr_name (28));
 920         }
 921       break;
 922     case OPRND_TYPE_UNCOND10b:
 923     case OPRND_TYPE_UNCOND16b:
 924     case OPRND_TYPE_COND10b:
 925     case OPRND_TYPE_COND16b:
 926       {
 927         int shift = oprnd->shift;
 928
 929         if (value & ((max >> 1) + 1))
 930           value |= ~max;
 931         if (is_extern_symbol (dis_info.info, dis_info.mem))
 932           value = 0;
 933         else
 934           value = dis_info.mem + (value << shift);
 935         sprintf (buf, "0x%x", (unsigned int)value);
 936         strcat (str, buf);
 937         dis_info.need_output_symbol = 1;
 938         dis_info.value = value;
 939       }
 940       break;
 941
 942     default:
 943       ret = -1;
 944       break;
 945     }
 946   return ret;
 947 }
 948
 949 static int
 950 csky_print_operand (char *str, struct operand const *oprnd,
 951                     CSKY_INST_TYPE inst, int reloc)
 952 {
 953   int ret = -1;
 954   char *lc = "";
 955   char *rc = "";
 956   if (oprnd->mask == HAS_SUB_OPERAND)
 957     {
 958       struct soperand *sop = (struct soperand *)oprnd;
 959       if (oprnd->type == OPRND_TYPE_BRACKET)
 960         {
 961           lc = "(";
 962           rc = ")";
 963         }
 964       else if (oprnd->type == OPRND_TYPE_ABRACKET)
 965         {
 966           lc = "<";
 967           rc = ">";
 968         }
 969       strcat (str, lc);
 970       ret = csky_print_operand (str, &sop->subs[0], inst, reloc);
 971       if (ret)
 972         return ret;
 973       strcat (str, ", ");
 974       ret = csky_print_operand (str, &sop->subs[1], inst, reloc);
 975       strcat (str, rc);
 976       return ret;
 977     }
 978   return csky_output_operand (str, oprnd, inst, reloc);
 979 }
 980
 981 static int
 982 csky_print_operands (char *str, struct csky_opcode_info const *pinfo,
 983                      struct disassemble_info *info, CSKY_INST_TYPE inst,
 984                      int reloc)
 985 {
 986   int i = 0;
 987   int ret = 0;
 988   if (pinfo->operand_num)
 989     strcat (str, "      \t");
 990   if (pinfo->operand_num == -1)
 991     {
 992       ret = csky_print_operand (str, &pinfo->oprnd.oprnds[i], inst, reloc);
 993       if (ret)
 994         return ret;
 995     }
 996   else
 997     for (; i < pinfo->operand_num; i++)
 998       {
 999         if (i != 0)
1000           strcat (str, ", ");
1001         ret = csky_print_operand (str, &pinfo->oprnd.oprnds[i], inst, reloc);
1002         if (ret)
1003           return ret;
1004       }
1005   info->fprintf_func (info->stream, "%s", str);
1006   if (dis_info.need_output_symbol)
1007     {
1008       info->fprintf_func (info->stream, "\t// ");
1009       info->print_address_func (dis_info.value, dis_info.info);
1010     }
1011   return 0;
1012 }
1013
1014 static void
1015 number_to_chars_littleendian (char *buf, CSKY_INST_TYPE val, int n)
1016 {
1017   if (n <= 0)
1018     abort ();
1019   while (n--)
1020     {
1021       *buf++ = val & 0xff;
1022       val >>= 8;
1023     }
1024 }
1025
1026 #define CSKY_READ_DATA()                                        \
1027 {                                                               \
1028   status = info->read_memory_func (memaddr, buf, 2, info);      \
1029   if (status)                                                   \
1030     {                                                           \
1031       info->memory_error_func (status, memaddr, info);          \
1032       return -1;                                                \
1033     }                                                           \
1034   if (info->endian == BFD_ENDIAN_BIG)                           \
1035     inst |= (buf[0] << 8) | buf[1];                             \
1036   else if (info->endian == BFD_ENDIAN_LITTLE)                   \
1037     inst |= (buf[1] << 8) | buf[0];                             \
1038   else                                                          \
1039     abort();                                                    \
1040   info->bytes_per_chunk += 2;                                   \
1041   memaddr += 2;                                                 \
1042 }
1043
1044 int
1045 print_insn_csky (bfd_vma memaddr, struct disassemble_info *info)
1046 {
1047   unsigned char buf[4];
1048   CSKY_INST_TYPE inst = 0;
1049   int status;
1050   char str[256];
1051   unsigned long given;
1052   int is_data = false;
1053   void (*printer) (bfd_vma, struct disassemble_info *, long);
1054   unsigned int  size = 4;
1055
1056   memset (str, 0, sizeof (str));
1057   info->bytes_per_chunk = 0;
1058   info->bytes_per_chunk = 0;
1059   dis_info.mem = memaddr;
1060   dis_info.info = info;
1061   dis_info.need_output_symbol = 0;
1062
1063   if (info->disassembler_options)
1064     {
1065       parse_csky_dis_options (info->disassembler_options);
1066       info->disassembler_options = NULL;
1067     }
1068
1069   if (mach_flag != INIT_MACH_FLAG && mach_flag != BINARY_MACH_FLAG)
1070     info->mach = mach_flag;
1071   else if (mach_flag == INIT_MACH_FLAG)
1072     {
1073       mach_flag = info->mach;
1074       dis_info.isa = CSKY_DEFAULT_ISA;
1075     }
1076
1077   if (mach_flag == BINARY_MACH_FLAG && info->endian == BFD_ENDIAN_UNKNOWN)
1078     {
1079       info->endian = BFD_ENDIAN_LITTLE;
1080       dis_info.isa = CSKY_DEFAULT_ISA;
1081     }
1082
1083   /* First check the full symtab for a mapping symbol, even if there
1084      are no usable non-mapping symbols for this address.  */
1085   if (info->symtab_size != 0
1086       && bfd_asymbol_flavour (*info->symtab) == bfd_target_elf_flavour)
1087     {
1088       bfd_vma addr;
1089       int n;
1090       int last_sym = -1;
1091       enum sym_type type = CUR_TEXT;
1092
1093       if (memaddr <= last_map_addr)
1094         last_map_sym = -1;
1095       /* Start scanning at the start of the function, or wherever
1096          we finished last time.  */
1097       n = 0;
1098       if (n < last_map_sym)
1099         n = last_map_sym;
1100
1101       /* Scan up to the location being disassembled.  */
1102       for (; n < info->symtab_size; n++)
1103         {
1104           addr = bfd_asymbol_value (info->symtab[n]);
1105           if (addr > memaddr)
1106             break;
1107           if ((info->section == NULL
1108                || info->section == info->symtab[n]->section)
1109               && get_sym_code_type (info, n, &type))
1110             last_sym = n;
1111         }
1112       last_map_sym = last_sym;
1113       last_type = type;
1114       is_data = (last_type == CUR_DATA);
1115       if (is_data)
1116         {
1117           size = 4 - ( memaddr & 3);
1118           for (n = last_sym + 1; n < info->symtab_size; n++)
1119             {
1120               addr = bfd_asymbol_value (info->symtab[n]);
1121               if (addr > memaddr)
1122                 {
1123                   if (addr - memaddr < size)
1124                     size = addr - memaddr;
1125                   break;
1126                 }
1127             }
1128           /* If the next symbol is after three bytes, we need to
1129              print only part of the data, so that we can use either
1130              .byte or .short.  */
1131           if (size == 3)
1132             size = (memaddr & 1) ? 1 : 2;
1133         }
1134     }
1135   info->bytes_per_line = 4;
1136
1137   if (is_data)
1138     {
1139       int i;
1140
1141       /* Size was already set above.  */
1142       info->bytes_per_chunk = size;
1143       printer = print_insn_data;
1144
1145       status = info->read_memory_func (memaddr, (bfd_byte *) buf, size, info);
1146       given = 0;
1147       if (info->endian == BFD_ENDIAN_LITTLE)
1148         for (i = size - 1; i >= 0; i--)
1149           given = buf[i] | (given << 8);
1150       else
1151         for (i = 0; i < (int) size; i++)
1152           given = buf[i] | (given << 8);
1153
1154       printer (memaddr, info, given);
1155       return info->bytes_per_chunk;
1156     }
1157
1158   /* Handle instructions.  */
1159   CSKY_READ_DATA();
1160   if ((inst & 0xc000) == 0xc000 && IS_CSKY_V2 (mach_flag))
1161     {
1162       /* It's a 32-bit instruction.  */
1163       inst <<= 16;
1164       CSKY_READ_DATA();
1165       if (info->buffer && (info->endian == BFD_ENDIAN_LITTLE))
1166         {
1167           char* src = (char *)(info->buffer
1168                                + ((memaddr - 4 - info->buffer_vma)
1169                                   * info->octets_per_byte));
1170           if (info->endian == BFD_ENDIAN_LITTLE)
1171             number_to_chars_littleendian (src, inst, 4);
1172         }
1173     }
1174
1175   if (IS_CSKY_V1 (mach_flag))
1176     g_opcodeP = csky_v1_opcodes;
1177   else
1178     g_opcodeP = csky_v2_opcodes;
1179
1180   do
1181     {
1182       struct csky_opcode const *op;
1183       struct csky_opcode_info const *pinfo = NULL;
1184       int reloc;
1185
1186       memset (str, 0, sizeof (str));
1187       op = csky_find_inst_info (&pinfo, inst, info->bytes_per_chunk);
1188       if (!op)
1189         {
1190           if (IS_CSKY_V1 (mach_flag))
1191             info->fprintf_func (info->stream, ".short: 0x%04x",
1192                                 (unsigned short)inst);
1193           else
1194             info->fprintf_func (info->stream, ".long: 0x%08x",
1195                                 (unsigned int)inst);
1196           return info->bytes_per_chunk;
1197         }
1198
1199       if (info->bytes_per_chunk == 2)
1200         reloc = op->reloc16;
1201       else
1202         reloc = op->reloc32;
1203       dis_info.opinfo = pinfo;
1204       strcat (str, op->mnemonic);
1205
1206       if (csky_print_operands (str, pinfo, info, inst, reloc))
1207         g_opcodeP++;
1208       else
1209         break;
1210     } while (1);
1211
1212   return info->bytes_per_chunk;
1213 }