opcodes/csky-dis.c

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