gas/config/tc-csky.c

   1 /* tc-csky.c -- Assembler for C-SKY
   2    Copyright (C) 1989-2019 Free Software Foundation, Inc.
   3    Created by Lifang Xia (lifang_xia@c-sky.com)
   4    Contributed by C-SKY Microsystems and Mentor Graphics.
   5
   6    This file is part of GAS, the GNU Assembler.
   7
   8    GAS 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    GAS is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with GAS; see the file COPYING.  If not, write to the Free
  20    Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
  21    02110-1301, USA.  */
  22
  23 #include "as.h"
  24 #include <limits.h>
  25 #include <stdint.h>
  26 #include <stdarg.h>
  27 #include <ctype.h>
  28 #include "safe-ctype.h"
  29 #include "subsegs.h"
  30 #include "obstack.h"
  31 #include "libiberty.h"
  32
  33 #ifdef OBJ_ELF
  34 #include "elf/csky.h"
  35 #include "dw2gencfi.h"
  36 #endif
  37 #include "tc-csky.h"
  38 #include "dwarf2dbg.h"
  39
  40 #define BUILD_AS          1
  41
  42 #define OPCODE_MAX_LEN    20
  43 #define HAS_SUB_OPERAND   0xfffffffful
  44
  45 /* This value is just for lrw to distinguish "[]" label.  */
  46 #define NEED_OUTPUT_LITERAL           1
  47
  48 #define IS_EXTERNAL_SYM(sym, sec)     (S_GET_SEGMENT (sym) != sec)
  49 #define IS_SUPPORT_OPCODE16(opcode)   (opcode->isa_flag16 | isa_flag)
  50 #define IS_SUPPORT_OPCODE32(opcode)   (opcode->isa_flag32 | isa_flag)
  51
  52
  53 #define KB                * 1024
  54 #define MB                KB * 1024
  55 #define GB                MB * 1024
  56
  57 /* Define DSP version flags. For different CPU, the version of DSP
  58    instructions may be different.  */
  59 #define CSKY_DSP_FLAG_V1          (1 << 0) /* Normal DSP instructions.  */
  60 #define CSKY_DSP_FLAG_V2          (1 << 1) /* CK803S enhanced DSP.  */
  61
  62 /* Literal pool related macros.  */
  63 /* 1024 - 1 entry - 2 byte rounding.  */
  64 #define v1_SPANPANIC      (998)
  65 #define v1_SPANCLOSE      (900)
  66 #define v1_SPANEXIT       (600)
  67 #define v2_SPANPANIC      (1024 - 4)
  68
  69 /* 1024 is flrw offset.
  70    24 is the biggest size for single instruction.
  71    for lrw16 (3+7, 512 bytes).  */
  72 #define v2_SPANCLOSE      (512 - 24)
  73
  74 /* For lrw16, 112 average size for a function.  */
  75 #define v2_SPANEXIT       (512 - 112)
  76
  77 /* For lrw16 (3+7, 512 bytes).  */
  78 #define v2_SPANCLOSE_ELRW (1016 - 24)
  79
  80 /* For lrw16, 112 average size for a function.  */
  81 #define v2_SPANEXIT_ELRW  (1016 - 112)
  82 #define MAX_POOL_SIZE     (1024 / 4)
  83 #define POOL_END_LABEL    ".LE"
  84 #define POOL_START_LABEL  ".LS"
  85
  86 /* Used in v1_relax_table.  */
  87 /* These are the two types of relaxable instruction.  */
  88 #define COND_JUMP         1
  89 #define UNCD_JUMP         2
  90 #define COND_JUMP_PIC     3
  91 #define UNCD_JUMP_PIC     4
  92
  93 #define UNDEF_DISP        0
  94 #define DISP12            1
  95 #define DISP32            2
  96 #define UNDEF_WORD_DISP   3
  97
  98 #define C12_LEN           2
  99 /* Allow for align: bt/jmpi/.long + align.  */
 100 #define C32_LEN           10
 101 /* Allow for align: bt/subi/stw/bsr/lrw/add/ld/addi/jmp/.long + align.  */
 102 #define C32_LEN_PIC       24
 103 #define U12_LEN           2
 104 /* Allow for align: jmpi/.long + align.  */
 105 #define U32_LEN           8
 106 /* Allow for align: subi/stw/bsr/lrw/add/ld/addi/jmp/.long + align.  */
 107 #define U32_LEN_PIC       22
 108
 109 #define C(what,length)    (((what) << 2) + (length))
 110 #define UNCD_JUMP_S       (do_pic ? UNCD_JUMP_PIC : UNCD_JUMP)
 111 #define COND_JUMP_S       (do_pic ? COND_JUMP_PIC : COND_JUMP)
 112 #define U32_LEN_S         (do_pic ? U32_LEN_PIC  : U32_LEN)
 113 #define C32_LEN_S         (do_pic ? C32_LEN_PIC  : C32_LEN)
 114
 115 /* Used in v2_relax_table.  */
 116 #define COND_DISP10_LEN   2   /* bt/bf_16.  */
 117 #define COND_DISP16_LEN   4   /* bt/bf_32.  */
 118
 119 #define SCOND_DISP10_LEN   2   /* bt/bf_16, for CK801 only.  */
 120 #define SCOND_DISP16_LEN   6   /* !(bt/bf_16) + br_32.  */
 121
 122 #define UNCD_DISP10_LEN   2   /* br_16.  */
 123 #define UNCD_DISP16_LEN   4   /* br_32.  */
 124 #define UNCD_DISP26_LEN   4   /* br32_old.  */
 125
 126 #define JCOND_DISP10_LEN  2   /* bt/bf_16.  */
 127 #define JCOND_DISP16_LEN  4   /* bt/bf_32.  */
 128 #define JCOND_DISP32_LEN  12  /* !(bt/bf_16)/jmpi 32/.align 2/literal 4.  */
 129 #define JCOND_DISP26_LEN  8   /* bt/bf_32/br_32 old.  */
 130
 131 #define JUNCD_DISP26_LEN  4   /* bt/bf_32 old.  */
 132 #define JUNCD_DISP10_LEN  2   /* br_16.  */
 133 #define JUNCD_DISP16_LEN  4   /* bt/bf_32.  */
 134 #define JUNCD_DISP32_LEN  10  /* jmpi_32/.align 2/literal 4/  CHANGED!.  */
 135 #define JCOMP_DISP26_LEN  8   /* bne_32/br_32 old.  */
 136
 137 #define JCOMP_DISP16_LEN  4   /* bne_32 old.  */
 138 #define JCOMPZ_DISP16_LEN 4   /* bhlz_32.  */
 139 #define JCOMPZ_DISP32_LEN 14  /* bsz_32/jmpi 32/.align 2/literal 4.  */
 140 #define JCOMPZ_DISP26_LEN 8   /* bsz_32/br_32  old.  */
 141 #define JCOMP_DISP32_LEN  14  /* be_32/jmpi_32/.align 2/literal old.  */
 142
 143 #define BSR_DISP10_LEN    2   /* bsr_16.  */
 144 #define BSR_DISP26_LEN    4   /* bsr_32.  */
 145 #define LRW_DISP7_LEN     2   /* lrw16.  */
 146 #define LRW_DISP16_LEN    4   /* lrw32.  */
 147
 148 /* Declare worker functions.  */
 149 bfd_boolean v1_work_lrw (void);
 150 bfd_boolean v1_work_jbsr (void);
 151 bfd_boolean v1_work_fpu_fo (void);
 152 bfd_boolean v1_work_fpu_fo_fc (void);
 153 bfd_boolean v1_work_fpu_write (void);
 154 bfd_boolean v1_work_fpu_read (void);
 155 bfd_boolean v1_work_fpu_writed (void);
 156 bfd_boolean v1_work_fpu_readd (void);
 157 bfd_boolean v2_work_istack (void);
 158 bfd_boolean v2_work_btsti (void);
 159 bfd_boolean v2_work_addi (void);
 160 bfd_boolean v2_work_subi (void);
 161 bfd_boolean v2_work_add_sub (void);
 162 bfd_boolean v2_work_rotlc (void);
 163 bfd_boolean v2_work_bgeni (void);
 164 bfd_boolean v2_work_not (void);
 165 bfd_boolean v2_work_jbtf (void);
 166 bfd_boolean v2_work_jbr (void);
 167 bfd_boolean v2_work_lrw (void);
 168 bfd_boolean v2_work_lrsrsw (void);
 169 bfd_boolean v2_work_jbsr (void);
 170 bfd_boolean v2_work_jsri (void);
 171 bfd_boolean v2_work_movih (void);
 172 bfd_boolean v2_work_ori (void);
 173 bfd_boolean float_work_fmovi (void);
 174 bfd_boolean dsp_work_bloop (void);
 175
 176 /* csky-opc.h must be included after workers are declared.  */
 177 #include "opcodes/csky-opc.h"
 178 #include "opcode/csky.h"
 179
 180 enum
 181 {
 182   RELAX_NONE = 0,
 183   RELAX_OVERFLOW,
 184
 185   COND_DISP10 = 20,    /* bt/bf_16.  */
 186   COND_DISP16,    /* bt/bf_32.  */
 187
 188   SCOND_DISP10,    /* br_16 */
 189   SCOND_DISP16,    /* !(bt/bf_32) + br_32.  */
 190
 191   UNCD_DISP10,    /* br_16.  */
 192   UNCD_DISP16,    /* br_32.  */
 193
 194   JCOND_DISP10,   /* bt/bf_16.  */
 195   JCOND_DISP16,   /* bt/bf_32.  */
 196   JCOND_DISP32,   /* !(bt/bf_32)/jmpi + literal.  */
 197
 198   JUNCD_DISP10,   /* br_16.  */
 199   JUNCD_DISP16,   /* br_32.  */
 200   JUNCD_DISP32,   /* jmpi + literal.  */
 201
 202   JCOMPZ_DISP16,  /* bez/bnez/bhz/blsz/blz/bhsz.  */
 203   JCOMPZ_DISP32,  /* !(jbez/jbnez/jblsz/jblz/jbhsz) + jmpi + literal.  */
 204
 205   BSR_DISP26,     /* bsr_32.  */
 206
 207   LRW_DISP7,      /* lrw16.  */
 208   LRW2_DISP8,     /* lrw16, -mno-bsr16,8 bit offset.  */
 209   LRW_DISP16,     /* lrw32.  */
 210 };
 211
 212 unsigned int mach_flag = 0;
 213 unsigned int arch_flag = 0;
 214 unsigned int other_flag = 0;
 215 unsigned int isa_flag = 0;
 216 unsigned int dsp_flag = 0;
 217
 218 typedef struct stack_size_entry
 219 {
 220   struct stack_size_entry *next;
 221   symbolS *function;
 222   unsigned int stack_size;
 223 } stack_size_entry;
 224
 225 struct csky_arch_info
 226 {
 227   const char *name;
 228   unsigned int arch_flag;
 229   unsigned int bfd_mach_flag;
 230 };
 231
 232 struct csky_cpu_info
 233 {
 234   const char *name;
 235   unsigned int mach_flag;
 236   unsigned int isa_flag;
 237 };
 238
 239 typedef enum
 240 {
 241   INSN_OPCODE,
 242   INSN_OPCODE16F,
 243   INSN_OPCODE32F,
 244 } inst_flag;
 245
 246 /* Macro information.  */
 247 struct csky_macro_info
 248 {
 249   const char *name;
 250   /* How many operands : if operands == 5, all of 1,2,3,4 are ok.  */
 251   long oprnd_num;
 252   int isa_flag;
 253   /* Do the work.  */
 254   void (*handle_func)(void);
 255 };
 256
 257 struct csky_insn_info
 258 {
 259   /* Name of the opcode.  */
 260   char *name;
 261   /* Output instruction.  */
 262   unsigned int inst;
 263   /* Pointer for frag.  */
 264   char *output;
 265   /* End of instruction.  */
 266   char *opcode_end;
 267   /* Flag for INSN_OPCODE16F, INSN_OPCODE32F, INSN_OPCODE, INSN_MACRO.  */
 268   inst_flag flag_force;
 269   /* Operand number.  */
 270   int number;
 271   struct csky_opcode *opcode;
 272   struct csky_macro_info *macro;
 273   /* Insn size for check_literal.  */
 274   unsigned int isize;
 275   /* Max size of insn for relax frag_var.  */
 276   unsigned int max;
 277   /* Indicates which element is in csky_opcode_info op[] array.  */
 278   int opcode_idx;
 279   /* The value of each operand in instruction when layout.  */
 280   int idx;
 281   int val[MAX_OPRND_NUM];
 282   struct relax_info
 283     {
 284       int max;
 285       int var;
 286       int subtype;
 287     } relax;
 288   /* The following are used for constant expressions.  */
 289   expressionS e1;
 290   expressionS e2;
 291 };
 292
 293 /* Literal pool data structures.  */
 294 struct literal
 295 {
 296   unsigned short  refcnt;
 297   unsigned char   ispcrel;
 298   unsigned char   unused;
 299   bfd_reloc_code_real_type r_type;
 300   expressionS     e;
 301   struct tls_addend tls_addend;
 302   unsigned char   isdouble;
 303   uint64_t dbnum;
 304 };
 305
 306 static void csky_idly (void);
 307 static void csky_rolc (void);
 308 static void csky_sxtrb (void);
 309 static void csky_movtf (void);
 310 static void csky_addc64 (void);
 311 static void csky_subc64 (void);
 312 static void csky_or64 (void);
 313 static void csky_xor64 (void);
 314 static void csky_neg (void);
 315 static void csky_rsubi (void);
 316 static void csky_arith (void);
 317 static void csky_decne (void);
 318 static void csky_lrw (void);
 319
 320 static enum bfd_reloc_code_real insn_reloc;
 321
 322 /* Assembler operand parse errors use these identifiers.  */
 323
 324 enum error_number
 325 {
 326   /* The following are errors.  */
 327   ERROR_CREG_ILLEGAL = 0,
 328   ERROR_REG_OVER_RANGE,
 329   ERROR_GREG_ILLEGAL,
 330   ERROR_802J_REG_OVER_RANGE,
 331   ERROR_REG_FORMAT,
 332   ERROR_REG_LIST,
 333   ERROR_IMM_ILLEGAL,
 334   ERROR_IMM_OVERFLOW,             /* 5  */
 335   ERROR_IMM_POWER,
 336   ERROR_JMPIX_OVER_RANGE,
 337   ERROR_EXP_CREG,
 338   ERROR_EXP_GREG,
 339   ERROR_EXP_CONSTANT,
 340   ERROR_EXP_EVEN_FREG,
 341   ERROR_RELOC_ILLEGAL,
 342   ERROR_MISSING_OPERAND,          /* 10  */
 343   ERROR_MISSING_COMMA,
 344   ERROR_MISSING_LBRACKET,
 345   ERROR_MISSING_RBRACKET,
 346   ERROR_MISSING_LSQUARE_BRACKETS,
 347   ERROR_MISSING_RSQUARE_BRACKETS, /* 15  */
 348   ERROR_MISSING_LANGLE_BRACKETS,
 349   ERROR_MISSING_RANGLE_BRACKETS,
 350   ERROR_OFFSET_UNALIGNED,
 351   ERROR_BAD_END,
 352   ERROR_UNDEFINE,
 353   ERROR_CPREG_ILLEGAL,           /* 20  */
 354   ERROR_OPCODE_PSRBIT,
 355   ERROR_OPERANDS_ILLEGAL,
 356   ERROR_OPERANDS_NUMBER,
 357   ERROR_OPCODE_ILLEGAL,
 358
 359   /* The following are warnings.  */
 360   WARNING_OPTIONS,
 361   WARNING_IDLY,
 362
 363   /* Error and warning end.  */
 364   ERROR_NONE,
 365 };
 366
 367 /* Global error state.  ARG1 and ARG2 are opaque data interpreted
 368    as appropriate for the error code.  */
 369
 370 struct csky_error_state
 371 {
 372   enum error_number err_num;
 373   int opnum;
 374   const void *arg1;
 375   const void *arg2;
 376 } error_state;
 377
 378 /* This macro is used to set error number and arg1 in the global state.  */
 379
 380 #define SET_ERROR_NUMBER(err, msg)                      \
 381   do {                                                  \
 382     if (error_state.err_num > err)                      \
 383       {                                                 \
 384         error_state.err_num = err;                      \
 385         error_state.arg1 = (void *)msg;                 \
 386       }                                                 \
 387   } while (0)
 388
 389
 390 /* Map error identifiers onto a format string, which will use
 391    arg1 and arg2 from the global error state.  */
 392 struct csky_error_format_map
 393 {
 394   enum error_number num;
 395   const char *fmt;
 396 };
 397
 398 static const struct csky_error_format_map err_formats[] =
 399 {
 400   {ERROR_CREG_ILLEGAL, "Operand %d error: control register is illegal."},
 401   {ERROR_REG_OVER_RANGE, "Operand %d error: r%d register is over range."},
 402   {ERROR_GREG_ILLEGAL, "Operand %d error: general register is illegal."},
 403   {ERROR_802J_REG_OVER_RANGE, "Operand %d register %s out of range (802j only has registers:0-15,23,24,25,30)"},
 404   {ERROR_REG_FORMAT, "Operand %d error: %s."},
 405   {ERROR_REG_LIST, "Register list format is illegal."},
 406   {ERROR_IMM_ILLEGAL, "Operand %d is not an immediate."},
 407   {ERROR_IMM_OVERFLOW, "Operand %d immediate is overflow."},
 408   {ERROR_IMM_POWER, "immediate %d is not a power of two"},
 409   {ERROR_JMPIX_OVER_RANGE, "The second operand must be 16/24/32/40"},
 410   {ERROR_EXP_CREG, "Operand %d error: control register is expected."},
 411   {ERROR_EXP_GREG, "Operand %d error: general register is expected."},
 412   {ERROR_EXP_CONSTANT, "Operand %d error: constant is expected."},
 413   {ERROR_EXP_EVEN_FREG, "Operand %d error: even float register is expected."},
 414   {ERROR_RELOC_ILLEGAL, "@%s reloc is not supported"},
 415   {ERROR_MISSING_OPERAND, "Operand %d is missing."},
 416   {ERROR_MISSING_COMMA, "Missing ','"},
 417   {ERROR_MISSING_LBRACKET, "Missing '('"},
 418   {ERROR_MISSING_RBRACKET, "Missing ')'"},
 419   {ERROR_MISSING_LSQUARE_BRACKETS, "Missing '['"},
 420   {ERROR_MISSING_RSQUARE_BRACKETS, "Missing ']'"},
 421   {ERROR_MISSING_LANGLE_BRACKETS, "Missing '<'"},
 422   {ERROR_MISSING_RANGLE_BRACKETS, "Missing '>'"},
 423   {ERROR_OFFSET_UNALIGNED, "Operand %d is unaligned. It must be %d aligned!"},
 424   {ERROR_BAD_END, "Operands mismatch, it has a bad end: %s"},
 425   {ERROR_UNDEFINE, NULL},
 426   {ERROR_CPREG_ILLEGAL, "Operand %d illegal, expect a cpreg(cpr0-cpr63)."},
 427   {ERROR_OPCODE_PSRBIT, "The operands must be 'ie'/'ee'/'fe'."},
 428   {ERROR_OPERANDS_ILLEGAL, "Operands mismatch: %s."},
 429   {ERROR_OPERANDS_NUMBER, "Operands number mismatch, %d operands expected."},
 430   {ERROR_OPCODE_ILLEGAL, "The instruction is not recognized."},
 431   {WARNING_OPTIONS, "Option %s is not support in %s."},
 432   {WARNING_IDLY, "idly %d is encoded to: idly 4 "},
 433   {ERROR_NONE, "There is no error."},
 434 };
 435
 436 static int do_pic = 0;            /* for jbr/jbf/jbt relax jmpi reloc.  */
 437 static int do_pff = -1;           /* for insert two br ahead of literals.  */
 438 static int do_force2bsr = -1;     /* for jbsr->bsr.  */
 439 static int do_jsri2bsr = 1;       /* for jsri->bsr.  */
 440 static int do_nolrw = 0;          /* lrw to movih & ori, only for V2.  */
 441 static int do_long_jump = -1;      /* control if jbf,jbt,jbr relax to jmpi.  */
 442 static int do_extend_lrw = -1;    /* delete bsr16 in both two options,
 443                                      add btesti16, lrw offset +1 in -melrw.  */
 444 static int do_func_dump = 0;      /* dump literals after every function.  */
 445 static int do_br_dump = 1;        /* work for -mabr/-mno-abr, control the literals dump.  */
 446 static int do_intr_stack = -1;    /* control interrupt stack module, 801&802&803
 447                                      default on, 807&810, default off.  */
 448
 449 #ifdef INCLUDE_BRANCH_STUB
 450 static int do_use_branchstub = -1;
 451 #else
 452 static int do_use_branchstub = 0;
 453 #endif
 454
 455 /* These are only used for options parsing.  Values are bitmasks and are
 456    OR'ed into the processor flag bits in md_begin.  */
 457 static int do_opt_mmp = 0;
 458 static int do_opt_mcp = 0;
 459 static int do_opt_mcache = 0;
 460 static int do_opt_msecurity = 0;
 461 static int do_opt_mhard_float = 0;
 462 static int do_opt_mtrust = 0;
 463 static int do_opt_mdsp = 0;
 464 static int do_opt_medsp = 0;
 465 static int do_opt_mvdsp = 0;
 466
 467 const relax_typeS *md_relax_table = NULL;
 468 struct literal *literal_insn_offset;
 469 static struct literal litpool[MAX_POOL_SIZE];
 470 static unsigned poolsize = 0;
 471 static unsigned poolnumber = 0;
 472 static unsigned long poolspan = 0;
 473 static unsigned int SPANPANIC;
 474 static unsigned int SPANCLOSE;
 475 static unsigned int SPANEXIT;
 476
 477 static stack_size_entry *all_stack_size_data = NULL;
 478 static stack_size_entry **last_stack_size_data = &all_stack_size_data;
 479
 480 /* Control by ".no_literal_dump N"
 481  * 1 : don't dump literal pool between insn1 and insnN+1
 482  * 0 : do nothing.  */
 483 static int do_noliteraldump = 0;
 484
 485 /* Label for current pool.  */
 486 static symbolS * poolsym;
 487 static char poolname[8];
 488
 489 static bfd_boolean mov_r1_before;
 490 static bfd_boolean mov_r1_after;
 491
 492 const relax_typeS csky_relax_table [] =
 493 {
 494   /* C-SKY V1 relax table.  */
 495   {0, 0, 0, 0},                                   /* RELAX_NONE      */
 496   {0, 0, 0, 0},                                   /* RELAX_OVERFLOW  */
 497   {0, 0, 0, 0},
 498   {0, 0, 0, 0},
 499
 500   /* COND_JUMP */
 501   {    0,     0, 0,       0 },                     /* UNDEF_DISP */
 502   { 2048, -2046, C12_LEN, C (COND_JUMP, DISP32) }, /* DISP12 */
 503   {    0,     0, C32_LEN, 0 },                     /* DISP32 */
 504   {    0,     0, C32_LEN, 0 },                     /* UNDEF_WORD_DISP */
 505
 506   /* UNCD_JUMP */
 507   {    0,     0, 0,       0 },                     /* UNDEF_DISP */
 508   { 2048, -2046, U12_LEN, C (UNCD_JUMP, DISP32) }, /* DISP12 */
 509   {    0,     0, U32_LEN, 0 },                     /* DISP32 */
 510   {    0,     0, U32_LEN, 0 },                     /* UNDEF_WORD_DISP */
 511
 512   /* COND_JUMP_PIC */
 513   {    0,     0, 0,           0 },                     /* UNDEF_DISP */
 514   { 2048, -2046, C12_LEN, C (COND_JUMP_PIC, DISP32) }, /* DISP12 */
 515   {    0,     0, C32_LEN_PIC, 0 },                     /* DISP32 */
 516   {    0,     0, C32_LEN_PIC, 0 },                     /* UNDEF_WORD_DISP */
 517
 518   /* UNCD_JUMP_PIC */
 519   {    0,     0, 0,           0 },                     /* UNDEF_DISP */
 520   { 2048, -2046, U12_LEN, C (UNCD_JUMP_PIC, DISP32) }, /* DISP12 */
 521   {    0,     0, U32_LEN_PIC, 0 },                     /* DISP32 */
 522   {    0,     0, U32_LEN_PIC, 0 },                     /* UNDEF_WORD_DISP */
 523
 524   /* C-SKY V2 relax table.  */
 525   /* forward  backward      length          more     */
 526   {  1 KB - 2,  -1 KB, COND_DISP10_LEN,   COND_DISP16    }, /* COND_DISP10 */
 527   { 64 KB - 2, -64 KB, COND_DISP16_LEN,   RELAX_OVERFLOW }, /* COND_DISP16 */
 528
 529   {  1 KB - 2,  -1 KB, SCOND_DISP10_LEN,  SCOND_DISP16   }, /* SCOND_DISP10 */
 530   { 64 KB - 2, -64 KB, SCOND_DISP16_LEN,  RELAX_OVERFLOW }, /* SCOND_DISP16 */
 531
 532   {  1 KB - 2,  -1 KB, UNCD_DISP10_LEN,   UNCD_DISP16    }, /* UNCD_DISP10 */
 533   { 64 KB - 2, -64 KB, UNCD_DISP16_LEN,   RELAX_OVERFLOW }, /* UNCD_DISP16 */
 534
 535   {  1 KB - 2,  -1 KB, JCOND_DISP10_LEN,  JCOND_DISP16   }, /* JCOND_DISP10 */
 536   { 64 KB - 2, -64 KB, JCOND_DISP16_LEN,  JCOND_DISP32   }, /* JCOND_DISP16 */
 537   {         0,      0, JCOND_DISP32_LEN,  RELAX_NONE     }, /* JCOND_DISP32 */
 538
 539   {  1 KB - 2,  -1 KB, JUNCD_DISP10_LEN,  JUNCD_DISP16   }, /* JUNCD_DISP10 */
 540   { 64 KB - 2, -64 KB, JUNCD_DISP16_LEN,  JUNCD_DISP32   }, /* JUNCD_DISP16 */
 541   {         0,      0, JUNCD_DISP32_LEN,  RELAX_NONE     }, /* JUNCD_DISP32 */
 542
 543   { 64 KB - 2, -64 KB, JCOMPZ_DISP16_LEN, JCOMPZ_DISP32  }, /* JCOMPZ_DISP16 */
 544   {         0,      0, JCOMPZ_DISP32_LEN, RELAX_NONE     }, /* JCOMPZ_DISP32 */
 545
 546   { 64 MB - 2, -64 MB, BSR_DISP26_LEN,    RELAX_OVERFLOW }, /* BSR_DISP26 */
 547
 548   {       508,      0, LRW_DISP7_LEN,     LRW_DISP16     }, /* LRW_DISP7 */
 549   {      1016,      0, LRW_DISP7_LEN,     LRW_DISP16     }, /* LRW2_DISP8 */
 550   {     64 KB,      0, LRW_DISP16_LEN,    RELAX_OVERFLOW }, /* LRW_DISP16 */
 551
 552 };
 553
 554 static void csky_write_insn (char *ptr, valueT use, int nbytes);
 555 void md_number_to_chars (char * buf, valueT val, int n);
 556 long md_pcrel_from_section (fixS * fixP, segT seg);
 557
 558 /* C-SKY architecture table.  */
 559 const struct csky_arch_info csky_archs[] =
 560 {
 561   {"ck510",  CSKY_ARCH_510,  bfd_mach_ck510},
 562   {"ck610",  CSKY_ARCH_610,  bfd_mach_ck610},
 563   {"ck801",  CSKY_ARCH_801,  bfd_mach_ck801},
 564   {"ck802",  CSKY_ARCH_802,  bfd_mach_ck802},
 565   {"ck803",  CSKY_ARCH_803,  bfd_mach_ck803},
 566 #define CSKY_ARCH_807_BASE    CSKY_ARCH_807 | CSKY_ARCH_DSP
 567 #define CSKY_ARCH_810_BASE    CSKY_ARCH_810 | CSKY_ARCH_DSP
 568   {"ck807",  CSKY_ARCH_807_BASE,  bfd_mach_ck807},
 569   {"ck810",  CSKY_ARCH_810_BASE,  bfd_mach_ck810},
 570   {NULL, 0, 0}
 571 };
 572
 573 /* C-SKY cpus table.  */
 574 const struct csky_cpu_info csky_cpus[] =
 575 {
 576   /* CK510 series.  */
 577 #define CSKYV1_ISA_DSP   CSKY_ISA_DSP | CSKY_ISA_MAC_DSP
 578   {"ck510",  CSKY_ARCH_510, CSKYV1_ISA_E1},
 579   {"ck510e", CSKY_ARCH_510 | CSKY_ARCH_DSP, CSKYV1_ISA_E1 | CSKYV1_ISA_DSP},
 580   {"ck520",  CSKY_ARCH_510 | CSKY_ARCH_MAC, CSKYV1_ISA_E1 | CSKY_ISA_MAC | CSKY_ISA_MAC_DSP},
 581
 582 #define CSKY_ISA_610          CSKYV1_ISA_E1 | CSKY_ISA_CP
 583   /* CK610 series.  */
 584   {"ck610",  CSKY_ARCH_610, CSKY_ISA_610},
 585   {"ck610e", CSKY_ARCH_610 | CSKY_ARCH_DSP, CSKY_ISA_610 | CSKYV1_ISA_DSP},
 586   {"ck610f", CSKY_ARCH_610 | CSKY_ARCH_FLOAT, CSKY_ISA_610 | CSKY_ISA_FLOAT_E1},
 587   {"ck610ef", CSKY_ARCH_610 | CSKY_ARCH_FLOAT | CSKY_ARCH_DSP, CSKY_ISA_610 | CSKY_ISA_FLOAT_E1 | CSKYV1_ISA_DSP},
 588   {"ck610fe", CSKY_ARCH_610 | CSKY_ARCH_FLOAT | CSKY_ARCH_DSP, CSKY_ISA_610 | CSKY_ISA_FLOAT_E1 | CSKYV1_ISA_DSP},
 589   {"ck620",  CSKY_ARCH_610 | CSKY_ARCH_MAC, CSKY_ISA_610 | CSKY_ISA_MAC | CSKY_ISA_MAC_DSP},
 590
 591   /* CK801 series.  */
 592 #define CSKY_ISA_801    CSKYV2_ISA_E1
 593 #define CSKYV2_ISA_DSP  (CSKY_ISA_DSP | CSKY_ISA_DSP_1E2)
 594   {"ck801", CSKY_ARCH_801, CSKY_ISA_801},
 595   {"ck801t", CSKY_ARCH_801, CSKY_ISA_801 | CSKY_ISA_TRUST},
 596
 597   /* CK802 series.  */
 598 #define CSKY_ISA_802    (CSKY_ISA_801 | CSKYV2_ISA_1E2 | CSKY_ISA_NVIC)
 599   {"ck802", CSKY_ARCH_802, CSKY_ISA_802},
 600   {"ck802j", CSKY_ARCH_802 | CSKY_ARCH_JAVA, CSKY_ISA_802 | CSKY_ISA_JAVA},
 601   {"ck802t", CSKY_ARCH_802, CSKY_ISA_802 | CSKY_ISA_TRUST},
 602
 603   /* CK803 series.  */
 604 #define CSKY_ISA_803    (CSKY_ISA_802 | CSKYV2_ISA_2E3 | CSKY_ISA_MP)
 605 #define CSKY_ISA_803R1  (CSKY_ISA_803 | CSKYV2_ISA_3E3R1)
 606 #define CSKY_ISA_FLOAT_803 (CSKY_ISA_FLOAT_E1 | CSKY_ISA_FLOAT_1E3)
 607   {"ck803", CSKY_ARCH_803, CSKY_ISA_803 },
 608   {"ck803h", CSKY_ARCH_803, CSKY_ISA_803 },
 609   {"ck803t", CSKY_ARCH_803, CSKY_ISA_803 | CSKY_ISA_TRUST},
 610   {"ck803ht", CSKY_ARCH_803, CSKY_ISA_803 | CSKY_ISA_TRUST},
 611   {"ck803f", CSKY_ARCH_803 | CSKY_ARCH_FLOAT, CSKY_ISA_803 | CSKY_ISA_FLOAT_803},
 612   {"ck803fh", CSKY_ARCH_803 | CSKY_ARCH_FLOAT, CSKY_ISA_803 | CSKY_ISA_FLOAT_803},
 613   {"ck803e", CSKY_ARCH_803 | CSKY_ARCH_DSP, CSKY_ISA_803 | CSKYV2_ISA_DSP},
 614   {"ck803eh", CSKY_ARCH_803 | CSKY_ARCH_DSP, CSKY_ISA_803 | CSKYV2_ISA_DSP},
 615   {"ck803et", CSKY_ARCH_803 | CSKY_ARCH_DSP, CSKY_ISA_803 | CSKYV2_ISA_DSP | CSKY_ISA_TRUST},
 616   {"ck803eht", CSKY_ARCH_803 | CSKY_ARCH_DSP, CSKY_ISA_803 | CSKYV2_ISA_DSP | CSKY_ISA_TRUST},
 617   {"ck803ef", CSKY_ARCH_803 | CSKY_ARCH_DSP | CSKY_ARCH_FLOAT, CSKY_ISA_803 | CSKYV2_ISA_DSP | CSKY_ISA_FLOAT_803},
 618   {"ck803efh", CSKY_ARCH_803 | CSKY_ARCH_DSP | CSKY_ARCH_FLOAT, CSKY_ISA_803 | CSKYV2_ISA_DSP | CSKY_ISA_FLOAT_803},
 619   {"ck803ft", CSKY_ARCH_803 | CSKY_ARCH_FLOAT, CSKY_ISA_803 | CSKY_ISA_FLOAT_803 | CSKY_ISA_TRUST},
 620   {"ck803eft", CSKY_ARCH_803 | CSKY_ARCH_DSP | CSKY_ARCH_FLOAT, CSKY_ISA_803 | CSKYV2_ISA_DSP | CSKY_ISA_FLOAT_803 | CSKY_ISA_TRUST},
 621   {"ck803efht", CSKY_ARCH_803 | CSKY_ARCH_DSP | CSKY_ARCH_FLOAT, CSKY_ISA_803 | CSKYV2_ISA_DSP | CSKY_ISA_FLOAT_803 | CSKY_ISA_TRUST},
 622   {"ck803r1", CSKY_ARCH_803, CSKY_ISA_803R1 },
 623   {"ck803hr1", CSKY_ARCH_803, CSKY_ISA_803R1 },
 624   {"ck803tr1", CSKY_ARCH_803, CSKY_ISA_803R1 | CSKY_ISA_TRUST},
 625   {"ck803htr1", CSKY_ARCH_803, CSKY_ISA_803R1 | CSKY_ISA_TRUST},
 626   {"ck803fr1", CSKY_ARCH_803 | CSKY_ARCH_FLOAT, CSKY_ISA_803R1 | CSKY_ISA_FLOAT_803},
 627   {"ck803fhr1", CSKY_ARCH_803 | CSKY_ARCH_FLOAT, CSKY_ISA_803R1 | CSKY_ISA_FLOAT_803},
 628   {"ck803er1", CSKY_ARCH_803 | CSKY_ARCH_DSP, CSKY_ISA_803R1 | CSKY_ISA_DSP_ENHANCE},
 629   {"ck803ehr1", CSKY_ARCH_803 | CSKY_ARCH_DSP, CSKY_ISA_803R1 | CSKY_ISA_DSP_ENHANCE},
 630   {"ck803etr1", CSKY_ARCH_803 | CSKY_ARCH_DSP, CSKY_ISA_803R1 | CSKY_ISA_DSP_ENHANCE | CSKY_ISA_TRUST},
 631   {"ck803ehtr1", CSKY_ARCH_803 | CSKY_ARCH_DSP, CSKY_ISA_803R1 | CSKY_ISA_DSP_ENHANCE | CSKY_ISA_TRUST},
 632   {"ck803efr1", CSKY_ARCH_803 | CSKY_ARCH_DSP | CSKY_ARCH_FLOAT, CSKY_ISA_803R1 | CSKY_ISA_DSP_ENHANCE | CSKY_ISA_FLOAT_803},
 633   {"ck803efhr1", CSKY_ARCH_803 | CSKY_ARCH_DSP | CSKY_ARCH_FLOAT, CSKY_ISA_803R1 | CSKY_ISA_DSP_ENHANCE | CSKY_ISA_FLOAT_803},
 634   {"ck803ftr1", CSKY_ARCH_803 | CSKY_ARCH_FLOAT, CSKY_ISA_803R1 | CSKY_ISA_FLOAT_803 | CSKY_ISA_TRUST},
 635   {"ck803eftr1", CSKY_ARCH_803 | CSKY_ARCH_DSP | CSKY_ARCH_FLOAT, CSKY_ISA_803R1 | CSKY_ISA_DSP_ENHANCE | CSKY_ISA_FLOAT_803 | CSKY_ISA_TRUST},
 636   {"ck803ehftr1", CSKY_ARCH_803 | CSKY_ARCH_DSP | CSKY_ARCH_FLOAT, CSKY_ISA_803R1 | CSKY_ISA_DSP_ENHANCE | CSKY_ISA_FLOAT_803 | CSKY_ISA_TRUST},
 637
 638   {"ck803s", CSKY_ARCH_803, CSKY_ISA_803R1 },
 639   {"ck803se", CSKY_ARCH_803 | CSKY_ARCH_DSP, CSKY_ISA_803R1 | CSKYV2_ISA_DSP},
 640   {"ck803sj", CSKY_ARCH_803 | CSKY_ARCH_JAVA, CSKY_ISA_803R1 | CSKY_ISA_JAVA},
 641   {"ck803sf", CSKY_ARCH_803 | CSKY_ARCH_FLOAT, CSKY_ISA_803R1 | CSKY_ISA_FLOAT_803},
 642   {"ck803sef", CSKY_ARCH_803 | CSKY_ARCH_DSP | CSKY_ARCH_FLOAT, CSKY_ISA_803R1 | CSKYV2_ISA_DSP | CSKY_ISA_FLOAT_803},
 643   {"ck803st", CSKY_ARCH_803, CSKY_ISA_803R1 | CSKY_ISA_TRUST},
 644
 645   /* CK807 series.  */
 646 #define CSKY_ISA_807    (CSKY_ISA_803 | CSKYV2_ISA_3E7 | CSKY_ISA_DSP | CSKY_ISA_MP_1E2 | CSKY_ISA_CACHE)
 647 #define CSKY_ISA_FLOAT_807 (CSKY_ISA_FLOAT_803 | CSKY_ISA_FLOAT_3E4 | CSKY_ISA_FLOAT_1E2)
 648   {"ck807e", CSKY_ARCH_807_BASE, CSKY_ISA_807 | CSKYV2_ISA_DSP},
 649   {"ck807ef", CSKY_ARCH_807_BASE | CSKY_ARCH_FLOAT, CSKY_ISA_807 | CSKYV2_ISA_DSP | CSKY_ISA_FLOAT_807},
 650   {"ck807", CSKY_ARCH_807_BASE, CSKY_ISA_807 | CSKYV2_ISA_DSP},
 651   {"ck807f", CSKY_ARCH_807_BASE | CSKY_ARCH_FLOAT,  CSKY_ISA_807 | CSKYV2_ISA_DSP | CSKY_ISA_FLOAT_807},
 652
 653   /* CK810 series.  */
 654 #define CSKY_ISA_810    (CSKY_ISA_807 | CSKYV2_ISA_7E10)
 655 #define CSKY_ISA_FLOAT_810 (CSKY_ISA_FLOAT_E1 | CSKY_ISA_FLOAT_1E2)
 656   {"ck810e", CSKY_ARCH_810_BASE, CSKY_ISA_810 | CSKYV2_ISA_DSP},
 657   {"ck810et", CSKY_ARCH_810_BASE, CSKY_ISA_810 | CSKYV2_ISA_DSP | CSKY_ISA_TRUST},
 658   {"ck810ef", CSKY_ARCH_810_BASE | CSKY_ARCH_FLOAT, CSKY_ISA_810 | CSKYV2_ISA_DSP | CSKY_ISA_FLOAT_810},
 659   {"ck810eft", CSKY_ARCH_810_BASE | CSKY_ARCH_FLOAT, CSKY_ISA_810 | CSKYV2_ISA_DSP | CSKY_ISA_FLOAT_810 | CSKY_ISA_TRUST},
 660   {"ck810", CSKY_ARCH_810_BASE, CSKY_ISA_810 | CSKYV2_ISA_DSP},
 661   {"ck810v", CSKY_ARCH_810_BASE, CSKY_ISA_810 | CSKYV2_ISA_DSP | CSKY_ISA_VDSP},
 662   {"ck810f", CSKY_ARCH_810_BASE | CSKY_ARCH_FLOAT, CSKY_ISA_810 | CSKYV2_ISA_DSP | CSKY_ISA_FLOAT_810},
 663   {"ck810t", CSKY_ARCH_810_BASE, CSKY_ISA_810 | CSKYV2_ISA_DSP | CSKY_ISA_TRUST},
 664   {"ck810tv", CSKY_ARCH_810_BASE, CSKY_ISA_810 | CSKYV2_ISA_DSP | CSKY_ISA_TRUST},
 665   {"ck810ft", CSKY_ARCH_810_BASE | CSKY_ARCH_FLOAT, CSKY_ISA_810 | CSKYV2_ISA_DSP | CSKY_ISA_VDSP | CSKY_ISA_FLOAT_810 | CSKY_ISA_TRUST},
 666   {"ck810ftv", CSKY_ARCH_810_BASE | CSKY_ARCH_FLOAT, CSKY_ISA_810 | CSKYV2_ISA_DSP | CSKY_ISA_VDSP | CSKY_ISA_FLOAT_810 | CSKY_ISA_TRUST},
 667
 668   {NULL, 0, 0}
 669 };
 670
 671 int md_short_jump_size = 2;
 672 int md_long_jump_size = 4;
 673
 674 /* This array holds the chars that always start a comment.  If the
 675    pre-processor is disabled, these aren't very useful.  */
 676 const char comment_chars[] = "#";
 677
 678 /* This array holds the chars that only start a comment at the beginning of
 679    a line.  If the line seems to have the form '# 123 filename'
 680    .line and .file directives will appear in the pre-processed output.  */
 681 /* Note that input_file.c hand checks for '#' at the beginning of the
 682    first line of the input file.  This is because the compiler outputs
 683    #NO_APP at the beginning of its output.  */
 684 /* Also note that comments like this one will always work.  */
 685 const char line_comment_chars[] = "#";
 686
 687 const char line_separator_chars[] = ";";
 688
 689 /* Chars that can be used to separate mant
 690    from exp in floating point numbers.  */
 691 const char EXP_CHARS[] = "eE";
 692
 693 /* Chars that mean this number is a floating point constant.
 694    As in 0f12.456
 695    or   0d1.2345e12  */
 696
 697 const char FLT_CHARS[] = "rRsSfFdDxXeEpP";
 698
 699 const char *md_shortopts = "";
 700
 701 struct option md_longopts[] = {
 702 #define OPTION_MARCH (OPTION_MD_BASE + 0)
 703   {"march", required_argument, NULL, OPTION_MARCH},
 704 #define OPTION_MCPU (OPTION_MD_BASE + 1)
 705   {"mcpu", required_argument, NULL, OPTION_MCPU},
 706
 707   /* Remaining options just set boolean flags.  */
 708   {"EL", no_argument, &target_big_endian, 0},
 709   {"mlittle-endian", no_argument, &target_big_endian, 0},
 710   {"EB", no_argument, &target_big_endian, 1},
 711   {"mbig-endian", no_argument, &target_big_endian, 1},
 712   {"fpic", no_argument, &do_pic, 1},
 713   {"pic", no_argument, &do_pic, 1},
 714   {"mljump", no_argument, &do_long_jump, 1},
 715   {"mno-ljump", no_argument, &do_long_jump, 0},
 716   {"force2bsr", no_argument, &do_force2bsr, 1},
 717   {"mforce2bsr", no_argument, &do_force2bsr, 1},
 718   {"no-force2bsr", no_argument, &do_force2bsr, 0},
 719   {"mno-force2bsr", no_argument, &do_force2bsr, 0},
 720   {"jsri2bsr", no_argument, &do_jsri2bsr, 1},
 721   {"mjsri2bsr", no_argument, &do_jsri2bsr, 1},
 722   {"no-jsri2bsr", no_argument, &do_jsri2bsr, 0},
 723   {"mno-jsri2bsr", no_argument, &do_jsri2bsr, 0},
 724   {"mnolrw", no_argument, &do_nolrw, 1},
 725   {"mno-lrw", no_argument, &do_nolrw, 1},
 726   {"melrw", no_argument, &do_extend_lrw, 1},
 727   {"mno-elrw", no_argument, &do_extend_lrw, 0},
 728   {"mlaf", no_argument, &do_func_dump, 1},
 729   {"mliterals-after-func", no_argument, &do_func_dump, 1},
 730   {"mno-laf", no_argument, &do_func_dump, 0},
 731   {"mno-literals-after-func", no_argument, &do_func_dump, 0},
 732   {"mlabr", no_argument, &do_br_dump, 1},
 733   {"mliterals-after-br", no_argument, &do_br_dump, 1},
 734   {"mno-labr", no_argument, &do_br_dump, 0},
 735   {"mnoliterals-after-br", no_argument, &do_br_dump, 0},
 736   {"mistack", no_argument, &do_intr_stack, 1},
 737   {"mno-istack", no_argument, &do_intr_stack, 0},
 738 #ifdef INCLUDE_BRANCH_STUB
 739   {"mbranch-stub", no_argument, &do_use_branchstub, 1},
 740   {"mno-branch-stub", no_argument, &do_use_branchstub, 0},
 741 #endif
 742   {"mhard-float", no_argument, &do_opt_mhard_float, CSKY_ARCH_FLOAT},
 743   {"mmp", no_argument, &do_opt_mmp, CSKY_ARCH_MP},
 744   {"mcp", no_argument, &do_opt_mcp, CSKY_ARCH_CP},
 745   {"mcache", no_argument, &do_opt_mcache, CSKY_ARCH_CACHE},
 746   {"msecurity", no_argument, &do_opt_msecurity, CSKY_ARCH_MAC},
 747   {"mtrust", no_argument, &do_opt_mtrust, CSKY_ISA_TRUST},
 748   {"mdsp", no_argument, &do_opt_mdsp, CSKY_DSP_FLAG_V1},
 749   {"medsp", no_argument, &do_opt_medsp, CSKY_DSP_FLAG_V2},
 750   {"mvdsp", no_argument, &do_opt_mvdsp, CSKY_ISA_VDSP},
 751 };
 752
 753 size_t md_longopts_size = sizeof (md_longopts);
 754
 755 static struct csky_insn_info csky_insn;
 756
 757 static struct hash_control *csky_opcodes_hash;
 758 static struct hash_control *csky_macros_hash;
 759
 760 static struct csky_macro_info v1_macros_table[] =
 761 {
 762   {"idly",   1, CSKYV1_ISA_E1, csky_idly},
 763   {"rolc",   2, CSKYV1_ISA_E1, csky_rolc},
 764   {"rotlc",  2, CSKYV1_ISA_E1, csky_rolc},
 765   {"sxtrb0", 2, CSKYV1_ISA_E1, csky_sxtrb},
 766   {"sxtrb1", 2, CSKYV1_ISA_E1, csky_sxtrb},
 767   {"sxtrb2", 2, CSKYV1_ISA_E1, csky_sxtrb},
 768   {"movtf",  3, CSKYV1_ISA_E1, csky_movtf},
 769   {"addc64", 3, CSKYV1_ISA_E1, csky_addc64},
 770   {"subc64", 3, CSKYV1_ISA_E1, csky_subc64},
 771   {"or64",   3, CSKYV1_ISA_E1, csky_or64},
 772   {"xor64",  3, CSKYV1_ISA_E1, csky_xor64},
 773   {NULL,0,0,0}
 774 };
 775
 776 static struct csky_macro_info v2_macros_table[] =
 777 {
 778   {"neg",   1, CSKYV2_ISA_E1,  csky_neg},
 779   {"rsubi", 2, CSKYV2_ISA_1E2, csky_rsubi},
 780   {"incf",  1, CSKYV2_ISA_1E2, csky_arith},
 781   {"inct",  1, CSKYV2_ISA_1E2, csky_arith},
 782   {"decf",  1, CSKYV2_ISA_2E3, csky_arith},
 783   {"decgt", 1, CSKYV2_ISA_2E3, csky_arith},
 784   {"declt", 1, CSKYV2_ISA_2E3, csky_arith},
 785   {"decne", 1, CSKYV2_ISA_1E2, csky_decne},
 786   {"dect",  1, CSKYV2_ISA_1E2, csky_arith},
 787   {"lslc",  1, CSKYV2_ISA_1E2, csky_arith},
 788   {"lsrc",  1, CSKYV2_ISA_1E2, csky_arith},
 789   {"xsr",   1, CSKYV2_ISA_1E2, csky_arith},
 790   {NULL,0,0,0}
 791 };
 792
 793 /* For option -mnolrw, replace lrw by movih & ori.  */
 794 static struct csky_macro_info v2_lrw_macro_opcode =
 795   {"lrw", 2, CSKYV2_ISA_1E2, csky_lrw};
 796
 797 /* This function is used to show errors or warnings.  */
 798
 799 static void
 800 csky_show_error (enum error_number err, int idx, void *arg1, void *arg2)
 801 {
 802   if (err == ERROR_NONE)
 803     return;
 804
 805   switch (err)
 806     {
 807     case ERROR_REG_LIST:
 808     case ERROR_OPCODE_PSRBIT:
 809     case ERROR_OPCODE_ILLEGAL:
 810     case ERROR_JMPIX_OVER_RANGE:
 811     case ERROR_MISSING_COMMA:
 812     case ERROR_MISSING_LBRACKET:
 813     case ERROR_MISSING_RBRACKET:
 814     case ERROR_MISSING_LSQUARE_BRACKETS:
 815     case ERROR_MISSING_RSQUARE_BRACKETS:
 816     case ERROR_MISSING_LANGLE_BRACKETS:
 817     case ERROR_MISSING_RANGLE_BRACKETS:
 818       /* Add NULL to fix warnings.  */
 819       as_bad (_(err_formats[err].fmt), NULL);
 820       break;
 821     case ERROR_CREG_ILLEGAL:
 822     case ERROR_GREG_ILLEGAL:
 823     case ERROR_IMM_ILLEGAL:
 824     case ERROR_IMM_OVERFLOW:
 825     case ERROR_EXP_CREG:
 826     case ERROR_EXP_GREG:
 827     case ERROR_EXP_CONSTANT:
 828     case ERROR_EXP_EVEN_FREG:
 829     case ERROR_MISSING_OPERAND:
 830     case ERROR_CPREG_ILLEGAL:
 831       as_bad (_(err_formats[err].fmt), idx);
 832       break;
 833     case ERROR_OPERANDS_NUMBER:
 834     case ERROR_IMM_POWER:
 835       as_bad (_(err_formats[err].fmt), (long)arg1);
 836       break;
 837
 838     case ERROR_OFFSET_UNALIGNED:
 839       as_bad (_(err_formats[err].fmt), idx, (long)arg1);
 840       break;
 841     case ERROR_RELOC_ILLEGAL:
 842     case ERROR_BAD_END:
 843     case ERROR_OPERANDS_ILLEGAL:
 844       as_bad (_(err_formats[err].fmt), (char *)arg1);
 845       break;
 846     case ERROR_REG_OVER_RANGE:
 847       as_bad (_(err_formats[err].fmt), idx, (long) arg1);
 848       break;
 849     case ERROR_802J_REG_OVER_RANGE:
 850     case ERROR_REG_FORMAT:
 851       as_bad (_(err_formats[err].fmt), idx, (char *)arg1);
 852       break;
 853     case ERROR_UNDEFINE:
 854       /* Add NULL to fix warnings.  */
 855       as_bad ((char *)arg1, NULL);
 856       break;
 857     case WARNING_IDLY:
 858       as_warn (_(err_formats[err].fmt), (long)arg1);
 859       break;
 860     case WARNING_OPTIONS:
 861       as_warn (_(err_formats[err].fmt), (char *)arg1, (char *)arg2);
 862       break;
 863     default:
 864       break;
 865     }
 866 }
 867
 868 /* Handle errors in branch relaxation.  */
 869
 870 static void
 871 csky_branch_report_error (const char* file, unsigned int line,
 872                           symbolS* sym, offsetT val)
 873 {
 874   as_bad_where (file ? file : _("unknown"),
 875                 line,
 876                 _("pcrel offset for branch to %s too far (0x%lx)"),
 877                 sym ? S_GET_NAME (sym) : _("<unknown>"),
 878                 (long) val);
 879 }
 880
 881 /* Set appropriate flags for the cpu matching STR.  */
 882
 883 static void
 884 parse_cpu (const char *str)
 885 {
 886   int i = 0;
 887
 888   for (; csky_cpus[i].name != NULL; i++)
 889     if (strcasecmp (str, csky_cpus[i].name) == 0)
 890       {
 891         mach_flag |= csky_cpus[i].mach_flag;
 892         isa_flag = csky_cpus[i].isa_flag;
 893         other_flag |= (csky_cpus[i].mach_flag & ~CSKY_ARCH_MASK);
 894         return;
 895       }
 896   as_bad (_("unknown cpu `%s'"), str);
 897 }
 898
 899 /* Set appropriate flags for the arch matching STR.  */
 900
 901 static void
 902 parse_arch (const char *str)
 903 {
 904   int i = 0;
 905   for (; csky_archs[i].name != NULL; i++)
 906     if (strcasecmp (str, csky_archs[i].name) == 0)
 907       {
 908         arch_flag |= csky_archs[i].arch_flag;
 909         return;
 910       }
 911   as_bad (_("unknown architecture `%s'"), str);
 912 }
 913
 914
 915 #ifdef OBJ_ELF
 916 /* Implement the TARGET_FORMAT macro.  */
 917
 918 const char *
 919 elf32_csky_target_format (void)
 920 {
 921   return (target_big_endian
 922           ? "elf32-csky-big"
 923           : "elf32-csky-little");
 924 }
 925 #endif
 926
 927 /* Turn an integer of n bytes (in val) into a stream of bytes appropriate
 928    for use in the a.out file, and stores them in the array pointed to by buf.
 929    This knows about the endian-ness of the target machine and does
 930    THE RIGHT THING, whatever it is.  Possible values for n are 1 (byte)
 931    2 (short) and 4 (long)  Floating numbers are put out as a series of
 932    LITTLENUMS (shorts, here at least).  */
 933
 934 void
 935 md_number_to_chars (char * buf, valueT val, int n)
 936 {
 937   if (target_big_endian)
 938     number_to_chars_bigendian (buf, val, n);
 939   else
 940     number_to_chars_littleendian (buf, val, n);
 941 }
 942
 943 /* Get a log2(val).  */
 944
 945 static int
 946 csky_log_2 (unsigned int val)
 947 {
 948     int log = -1;
 949     if ((val & (val - 1)) == 0)
 950       for (; val; val >>= 1)
 951         log ++;
 952     else
 953       csky_show_error (ERROR_IMM_POWER, 0, (void *)(long)val, NULL);
 954     return log;
 955 }
 956
 957 /* Output one instruction to the buffer at PTR.  */
 958
 959 static void
 960 csky_write_insn (char *ptr, valueT use, int nbytes)
 961 {
 962   if (nbytes == 2)
 963     md_number_to_chars (ptr, use, nbytes);
 964   else  /* 32-bit instruction.  */
 965     {
 966       /* Significant figures are in low bits.  */
 967       md_number_to_chars (ptr, use >> 16, 2);
 968       md_number_to_chars (ptr + 2, use & 0xFFFF, 2);
 969     }
 970 }
 971
 972 /* Read an NBYTES instruction from the buffer at PTR.  NBYTES should
 973    be either 2 or 4.  This function is used in branch relaxation.  */
 974
 975 static valueT
 976 csky_read_insn (char *ptr, int nbytes)
 977 {
 978   unsigned char *uptr = (unsigned char *)ptr;
 979   valueT v = 0;
 980   int lo, hi;   /* hi/lo byte index in binary stream.  */
 981
 982   if (target_big_endian)
 983     {
 984       hi = 0;
 985       lo = 1;
 986     }
 987   else
 988     {
 989       hi = 1;
 990       lo = 0;
 991     }
 992   v = uptr[lo] | (uptr[hi] << 8);
 993   if (nbytes == 4)
 994     {
 995       v <<= 16;
 996       v |=  uptr[lo + 2] | (uptr[hi + 2] << 8);
 997     }
 998   return v;
 999 }
1000
1001 /* Construct a label name into S from the 3-character prefix P and
1002    number N formatted as a 4-digit hex number.  */
1003
1004 static void
1005 make_internal_label (char *s, const char *p, int n)
1006 {
1007   static const char hex[] = "0123456789ABCDEF";
1008
1009   s[0] = p[0];
1010   s[1] = p[1];
1011   s[2] = p[2];
1012   s[3] = hex[(n >> 12) & 0xF];
1013   s[4] = hex[(n >>  8) & 0xF];
1014   s[5] = hex[(n >>  4) & 0xF];
1015   s[6] = hex[(n)       & 0xF];
1016   s[7] = 0;
1017 }
1018
1019 /* md_operand is a no-op on C-SKY; we do everything elsewhere.  */
1020
1021 void
1022 md_operand (expressionS *expressionP ATTRIBUTE_UNUSED)
1023 {
1024   return;
1025 }
1026
1027 /* Under ELF we need to default _GLOBAL_OFFSET_TABLE.
1028    Otherwise we have no need to default values of symbols.  */
1029
1030 symbolS *
1031 md_undefined_symbol (char *name ATTRIBUTE_UNUSED)
1032 {
1033 #ifdef OBJ_ELF
1034   /* TODO:  */
1035 #endif
1036   return NULL;
1037 }
1038
1039 /* Use IEEE format for floating-point constants.  */
1040
1041 const char *
1042 md_atof (int type, char *litP, int *sizeP)
1043 {
1044   return ieee_md_atof (type, litP, sizeP, target_big_endian);
1045 }
1046
1047 /* Print option help to FP.  */
1048
1049 void
1050 md_show_usage (FILE *fp)
1051 {
1052   int i, n;
1053   const int margin = 48;
1054
1055   fprintf (fp, _("C-SKY assembler options:\n"));
1056
1057   fprintf (fp, _("\
1058   -march=ARCH                   select architecture ARCH:"));
1059   for (i = 0, n = margin; csky_archs[i].name != NULL; i++)
1060     {
1061       int l = strlen (csky_archs[i].name);
1062       if (n + l >= margin)
1063         {
1064           fprintf (fp, "\n\t\t\t\t");
1065           n = l;
1066         }
1067       else
1068         {
1069           fprintf (fp, " ");
1070           n += l + 1;
1071         }
1072       fprintf (fp, "%s", csky_archs[i].name);
1073     }
1074   fprintf (fp, "\n");
1075
1076   fprintf (fp, _("\
1077   -mcpu=CPU                     select processor CPU:"));
1078   for (i = 0, n = margin; csky_cpus[i].name != NULL; i++)
1079     {
1080       int l = strlen (csky_cpus[i].name);
1081       if (n + l >= margin)
1082         {
1083           fprintf (fp, "\n\t\t\t\t");
1084           n = l;
1085         }
1086       else
1087         {
1088           fprintf (fp, " ");
1089           n += l + 1;
1090         }
1091       fprintf (fp, "%s", csky_cpus[i].name);
1092     }
1093   fprintf (fp, "\n");
1094
1095   fprintf (fp, _("\
1096   -EL  -mlittle-endian          generate little-endian output\n"));
1097   fprintf (fp, _("\
1098   -EB  -mbig-endian             generate big-endian output\n"));
1099   fprintf (fp, _("\
1100   -fpic  -pic                   generate position-independent code\n"));
1101
1102   fprintf (fp, _("\
1103   -mljump                       transform jbf, jbt, jbr to jmpi (CK800 only)\n"));
1104   fprintf (fp, _("\
1105   -mno-ljump\n"));
1106
1107 #ifdef INCLUDE_BRANCH_STUB
1108   fprintf (fp, _("\
1109   -mbranch-stub                 enable branch stubs for PC-relative calls\n"));
1110   fprintf (fp, _("\
1111   -mno-branch-stub\n"));
1112 #endif
1113
1114   fprintf (fp, _("\
1115   -force2bsr  -mforce2bsr       transform jbsr to bsr\n"));
1116   fprintf (fp, _("\
1117   -no-force2bsr  -mno-force2bsr\n"));
1118   fprintf (fp, _("\
1119   -jsri2bsr  -mjsri2bsr         transform jsri to bsr\n"));
1120   fprintf (fp, _("\
1121   -no-jsri2bsr  -mno-jsri2bsr\n"));
1122
1123   fprintf (fp, _("\
1124   -mnolrw  -mno-lrw             implement lrw as movih + ori\n"));
1125   fprintf (fp, _("\
1126   -melrw                        enable extended lrw (CK800 only)\n"));
1127   fprintf (fp, _("\
1128   -mno-elrw\n"));
1129
1130   fprintf (fp, _("\
1131   -mlaf  -mliterals-after-func  emit literals after each function\n"));
1132   fprintf (fp, _("\
1133   -mno-laf  -mno-literals-after-func\n"));
1134   fprintf (fp, _("\
1135   -mlabr  -mliterals-after-br   emit literals after branch instructions\n"));
1136   fprintf (fp, _("\
1137   -mno-labr  -mnoliterals-after-br\n"));
1138
1139   fprintf (fp, _("\
1140   -mistack                      enable interrupt stack instructions\n"));
1141   fprintf (fp, _("\
1142   -mno-istack\n"));
1143
1144   fprintf (fp, _("\
1145   -mhard-float                  enable hard float instructions\n"));
1146   fprintf (fp, _("\
1147   -mmp                          enable multiprocessor instructions\n"));
1148   fprintf (fp, _("\
1149   -mcp                          enable coprocessor instructions\n"));
1150   fprintf (fp, _("\
1151   -mcache                       enable cache prefetch instruction\n"));
1152   fprintf (fp, _("\
1153   -msecurity                    enable security instructions\n"));
1154   fprintf (fp, _("\
1155   -mtrust                       enable trust instructions\n"));
1156   fprintf (fp, _("\
1157   -mdsp                         enable DSP instructions\n"));
1158   fprintf (fp, _("\
1159   -medsp                        enable enhanced DSP instructions\n"));
1160   fprintf (fp, _("\
1161   -mvdsp                        enable vector DSP instructions\n"));
1162 }
1163
1164 /* Target-specific initialization and option handling.  */
1165
1166 void
1167 md_begin (void)
1168 {
1169   unsigned int bfd_mach_flag = 0;
1170   struct csky_opcode const *opcode;
1171   struct csky_macro_info const *macro;
1172   struct csky_arch_info const *p_arch;
1173   struct csky_cpu_info const *p_cpu;
1174   unsigned int flags = (other_flag | do_opt_mmp | do_opt_mcp | do_opt_mcache
1175                         | do_opt_msecurity | do_opt_mhard_float);
1176   dsp_flag |= do_opt_mdsp | do_opt_medsp;
1177   isa_flag |= do_opt_mtrust | do_opt_mvdsp;
1178
1179   if (dsp_flag)
1180     flags |= CSKY_ARCH_DSP;
1181
1182   if (mach_flag != 0)
1183     {
1184       if ((mach_flag & CSKY_ARCH_MASK) != arch_flag && arch_flag != 0)
1185         as_warn (_("-mcpu conflict with -march option, using -mcpu"));
1186       if ((mach_flag & ~CSKY_ARCH_MASK) != flags && flags != 0)
1187         as_warn (_("-mcpu conflict with other model parameters, using -mcpu"));
1188     }
1189   else if (arch_flag != 0)
1190     mach_flag |= arch_flag | flags;
1191   else
1192     {
1193 #ifdef TARGET_WITH_CPU
1194       int i = 0;
1195       for (; csky_cpus[i].name != NULL; i++)
1196         {
1197           if (strcmp (TARGET_WITH_CPU, csky_cpus[i].name) == 0)
1198             {
1199               mach_flag |= csky_cpus[i].mach_flag;
1200               isa_flag = csky_cpus[i].isa_flag;
1201               break;
1202             }
1203         }
1204 #else
1205 #if _CSKY_ABI==1
1206       mach_flag |= CSKY_ARCH_610 | flags;
1207 #else
1208       mach_flag |= CSKY_ARCH_810_BASE | flags;
1209 #endif
1210 #endif
1211     }
1212
1213   if (IS_CSKY_ARCH_610 (mach_flag) || IS_CSKY_ARCH_510 (mach_flag))
1214     {
1215       if ((mach_flag & CSKY_ARCH_MP) && (mach_flag & CSKY_ARCH_MAC))
1216         as_fatal ("520/620 conflicts with -mmp option");
1217       else if ((mach_flag & CSKY_ARCH_MP) && (mach_flag & CSKY_ARCH_DSP))
1218         as_fatal ("510e/610e conflicts with -mmp option");
1219       else if ((mach_flag & CSKY_ARCH_DSP) && (mach_flag & CSKY_ARCH_MAC))
1220         as_fatal ("520/620 conflicts with 510e/610e or -mdsp option");
1221     }
1222   if (IS_CSKY_ARCH_510 (mach_flag) && (mach_flag & CSKY_ARCH_FLOAT))
1223     {
1224       mach_flag = (mach_flag & (~CSKY_ARCH_MASK));
1225       mach_flag |= CSKY_ARCH_610;
1226     }
1227
1228   /* Find bfd_mach_flag, it will set to bfd backend data.  */
1229   for (p_arch = csky_archs; p_arch->arch_flag != 0; p_arch++)
1230     if ((mach_flag & CSKY_ARCH_MASK) == (p_arch->arch_flag & CSKY_ARCH_MASK))
1231       {
1232         bfd_mach_flag =  p_arch->bfd_mach_flag;
1233         break;
1234       }
1235
1236   /* Find isa_flag.  */
1237   for (p_cpu = csky_cpus; p_cpu->mach_flag != 0; p_cpu++)
1238     if ((mach_flag & CPU_ARCH_MASK) == p_cpu->mach_flag)
1239       {
1240         isa_flag |= p_cpu->isa_flag;
1241         break;
1242       }
1243
1244   /* Check if -mdsp and -medsp conflict. If cpu is ck803, we will
1245      use enhanced dsp instruction. Otherwise, we will use normal dsp.  */
1246   if (dsp_flag)
1247     {
1248       if (IS_CSKY_ARCH_803 (mach_flag))
1249         {
1250           /* In 803, dspv1 is conflict with dspv2. We keep dspv2.  */
1251           if ((dsp_flag & CSKY_DSP_FLAG_V1) && (dsp_flag & CSKY_DSP_FLAG_V2))
1252             as_warn (_("option -mdsp conflicts with -medsp, only enabling -medsp"));
1253           isa_flag &= ~(CSKY_ISA_MAC_DSP | CSKY_ISA_DSP);
1254           isa_flag |= CSKY_ISA_DSP_ENHANCE;
1255         }
1256       else
1257         {
1258           isa_flag &= ~CSKY_ISA_DSP_ENHANCE;
1259           as_warn (_("-medsp option is only supported by ck803s, ignoring -medsp"));
1260         }
1261       ;
1262     }
1263
1264   if (do_use_branchstub == -1)
1265     do_use_branchstub = !IS_CSKY_ARCH_V1 (mach_flag);
1266   else if (do_use_branchstub == 1)
1267     {
1268       if (IS_CSKY_ARCH_V1 (mach_flag))
1269         {
1270           as_warn (_("C-SKY ABI v1 (ck510/ck610) does not support -mbranch-stub"));
1271           do_use_branchstub = 0;
1272         }
1273       else if (do_force2bsr == 0)
1274         {
1275           as_warn (_("-mno-force2bsr is ignored with -mbranch-stub"));
1276           do_force2bsr = 1;
1277         }
1278     }
1279
1280   if (IS_CSKY_ARCH_801 (mach_flag) || IS_CSKY_ARCH_802 (mach_flag))
1281     {
1282       if (!do_force2bsr)
1283         as_warn (_("-mno-force2bsr is ignored for ck801/ck802"));
1284       do_force2bsr = 1;
1285     }
1286   else if (do_force2bsr == -1)
1287     do_force2bsr = do_use_branchstub;
1288
1289   if (do_pff == -1)
1290     {
1291       if (IS_CSKY_ARCH_V1 (mach_flag))
1292         do_pff = 1;
1293       else
1294         do_pff = 0;
1295     }
1296
1297   if (do_extend_lrw == -1)
1298     {
1299       if (IS_CSKY_ARCH_801 (mach_flag))
1300         do_extend_lrw = 1;
1301       else
1302         do_extend_lrw = 0;
1303     }
1304   if (IS_CSKY_ARCH_801 (mach_flag) || IS_CSKY_ARCH_802 (mach_flag))
1305     {
1306       if (do_long_jump > 0)
1307         as_warn (_("-mljump is ignored for ck801/ck802"));
1308       do_long_jump = 0;
1309     }
1310   else if (do_long_jump == -1)
1311     do_long_jump = 1;
1312   if (do_intr_stack == -1)
1313     {
1314       /* control interrupt stack module, 801&802&803 default on
1315          807&810, default off.  */
1316       if (IS_CSKY_ARCH_807 (mach_flag) || IS_CSKY_ARCH_810 (mach_flag))
1317         do_intr_stack = 0;
1318       else
1319         do_intr_stack = 1;
1320     }
1321   /* TODO: add isa_flag(SIMP/CACHE/APS).  */
1322   isa_flag |= (mach_flag & CSKY_ARCH_MAC) ? CSKY_ISA_MAC : 0;
1323   isa_flag |= (mach_flag & CSKY_ARCH_MP) ? CSKY_ISA_MP : 0;
1324   isa_flag |= (mach_flag & CSKY_ARCH_CP) ? CSKY_ISA_CP : 0;
1325
1326   /* Set abi flag and get table address.  */
1327   if (IS_CSKY_ARCH_V1 (mach_flag))
1328     {
1329       mach_flag = mach_flag | CSKY_ABI_V1;
1330       opcode = csky_v1_opcodes;
1331       macro = v1_macros_table;
1332       SPANPANIC = v1_SPANPANIC;
1333       SPANCLOSE = v1_SPANCLOSE;
1334       SPANEXIT  = v1_SPANEXIT;
1335       md_relax_table = csky_relax_table;
1336     }
1337   else
1338     {
1339       mach_flag = mach_flag | CSKY_ABI_V2;
1340       opcode = csky_v2_opcodes;
1341       macro = v2_macros_table;
1342       SPANPANIC = v2_SPANPANIC;
1343       if (do_extend_lrw)
1344         {
1345           SPANCLOSE = v2_SPANCLOSE_ELRW;
1346           SPANEXIT  = v2_SPANEXIT_ELRW;
1347         }
1348       else
1349         {
1350           SPANCLOSE = v2_SPANCLOSE;
1351           SPANEXIT  = v2_SPANEXIT;
1352         }
1353       md_relax_table = csky_relax_table;
1354     }
1355
1356   /* Establish hash table for opcodes and macros.  */
1357   csky_macros_hash = hash_new ();
1358   csky_opcodes_hash = hash_new ();
1359   for ( ; opcode->mnemonic != NULL; opcode++)
1360     if ((isa_flag & (opcode->isa_flag16 | opcode->isa_flag32)) != 0)
1361       hash_insert (csky_opcodes_hash, opcode->mnemonic, (char *)opcode);
1362   for ( ; macro->name != NULL; macro++)
1363     if ((isa_flag & macro->isa_flag) != 0)
1364       hash_insert (csky_macros_hash, macro->name, (char *)macro);
1365   if (do_nolrw && (isa_flag & CSKYV2_ISA_1E2) != 0)
1366     hash_insert (csky_macros_hash,
1367                  v2_lrw_macro_opcode.name,
1368                  (char *)&v2_lrw_macro_opcode);
1369   /* Set e_flag to ELF Head.  */
1370   bfd_set_private_flags (stdoutput, mach_flag);
1371   /* Set bfd_mach to bfd backend data.  */
1372   bfd_set_arch_mach (stdoutput, bfd_arch_csky, bfd_mach_flag);
1373 }
1374
1375 /* The C-SKY assembler emits mapping symbols $t and $d to mark the
1376    beginning of a sequence of instructions and data (such as a constant pool),
1377    respectively.  This is similar to what ARM does.  */
1378
1379 static void
1380 make_mapping_symbol (map_state state, valueT value, fragS *frag)
1381 {
1382   symbolS * symbolP;
1383   const char * symname;
1384   int type;
1385   switch (state)
1386     {
1387     case MAP_DATA:
1388       symname = "$d";
1389       type = BSF_NO_FLAGS;
1390       break;
1391     case MAP_TEXT:
1392       symname = "$t";
1393       type = BSF_NO_FLAGS;
1394       break;
1395     default:
1396       abort ();
1397     }
1398
1399   symbolP = symbol_new (symname, now_seg, value, frag);
1400   symbol_get_bfdsym (symbolP)->flags |= type | BSF_LOCAL;
1401 }
1402
1403 /* We need to keep track of whether we are emitting code or data; this
1404    function switches state and emits a mapping symbol if necessary.  */
1405
1406 static void
1407 mapping_state (map_state state)
1408 {
1409   map_state current_state
1410     = seg_info (now_seg)->tc_segment_info_data.current_state;
1411
1412   if (current_state == state)
1413     return;
1414   else if (current_state == MAP_UNDEFINED && state == MAP_DATA)
1415     return;
1416   else if (current_state == MAP_UNDEFINED && state == MAP_TEXT)
1417    {
1418      struct frag * const frag_first = seg_info (now_seg)->frchainP->frch_root;
1419      if (frag_now != frag_first || frag_now_fix () > 0)
1420        make_mapping_symbol (MAP_DATA, (valueT) 0, frag_first);
1421    }
1422
1423   seg_info (now_seg)->tc_segment_info_data.current_state = state;
1424   make_mapping_symbol (state, (valueT) frag_now_fix (), frag_now);
1425 }
1426
1427 /* Dump the literal pool.  */
1428
1429 static void
1430 dump_literals (int isforce)
1431 {
1432 #define CSKYV1_BR_INSN  0xF000
1433 #define CSKYV2_BR_INSN  0x0400
1434   unsigned int i;
1435   struct literal * p;
1436   symbolS * brarsym = NULL;
1437
1438   /* V1 nop encoding:  0x1200 : mov r0, r0.  */
1439   static char v1_nop_insn_big[2] = {0x12, 0x00};
1440   static char v1_nop_insn_little[2] = {0x00, 0x12};
1441
1442   if (poolsize == 0)
1443     return;
1444
1445   /* Must we branch around the literal table?  */
1446   if (isforce)
1447     {
1448       char brarname[8];
1449       make_internal_label (brarname, POOL_END_LABEL, poolnumber);
1450       brarsym = symbol_make (brarname);
1451       symbol_table_insert (brarsym);
1452       mapping_state (MAP_TEXT);
1453       if (IS_CSKY_ARCH_V1 (mach_flag))
1454         {
1455           csky_insn.output
1456             = frag_var (rs_machine_dependent,
1457                         csky_relax_table[C (UNCD_JUMP_S, DISP32)].rlx_length,
1458                         csky_relax_table[C (UNCD_JUMP_S, DISP12)].rlx_length,
1459                         C (UNCD_JUMP_S, 0), brarsym, 0, 0);
1460           md_number_to_chars (csky_insn.output, CSKYV1_BR_INSN, 2);
1461         }
1462       else
1463         {
1464           csky_insn.output
1465             = frag_var (rs_machine_dependent,
1466                         UNCD_DISP16_LEN,
1467                         UNCD_DISP10_LEN,
1468                         UNCD_DISP10,
1469                         brarsym, 0, 0);
1470           md_number_to_chars (csky_insn.output, CSKYV2_BR_INSN, 2);
1471         }
1472     }
1473   /* Make sure that the section is sufficiently aligned and that
1474      the literal table is aligned within it.  */
1475   if (do_pff)
1476     {
1477       valueT br_self;
1478       csky_insn.output = frag_more (2);
1479       /* .Lxx: br .Lxx  */
1480       if (IS_CSKY_V1 (mach_flag))
1481         br_self = CSKYV1_BR_INSN | 0x7ff;
1482       else
1483         br_self = CSKYV2_BR_INSN;
1484       md_number_to_chars (csky_insn.output, br_self, 2);
1485       if (!isforce)
1486         {
1487           csky_insn.output = frag_more (2);
1488           /* .Lxx: br .Lxx  */
1489           md_number_to_chars (csky_insn.output, br_self, 2);
1490         }
1491     }
1492   mapping_state (MAP_DATA);
1493
1494   record_alignment (now_seg, 2);
1495   if (IS_CSKY_ARCH_V1 (mach_flag))
1496     frag_align_pattern (2,
1497                         (target_big_endian
1498                          ? v1_nop_insn_big : v1_nop_insn_little),
1499                         2, 0);
1500   else
1501     frag_align (2, 0, 3);
1502
1503   colon (S_GET_NAME (poolsym));
1504
1505   for (i = 0, p = litpool; i < poolsize; i += (p->isdouble ? 2 : 1), p++)
1506     {
1507       insn_reloc = p->r_type;
1508       if (insn_reloc == BFD_RELOC_CKCORE_TLS_IE32
1509           || insn_reloc == BFD_RELOC_CKCORE_TLS_LDM32
1510           || insn_reloc == BFD_RELOC_CKCORE_TLS_GD32)
1511         literal_insn_offset = p;
1512       if (p->isdouble)
1513         {
1514           if (target_big_endian)
1515             {
1516               p->e.X_add_number = p->dbnum >> 32;
1517               emit_expr (& p->e, 4);
1518               p->e.X_add_number = p->dbnum & 0xffffffff;
1519               emit_expr (& p->e, 4);
1520             }
1521           else
1522             {
1523               p->e.X_add_number = p->dbnum & 0xffffffff;
1524               emit_expr (& p->e, 4);
1525               p->e.X_add_number = p->dbnum >> 32;
1526               emit_expr (& p->e, 4);
1527             }
1528         }
1529       else
1530         emit_expr (& p->e, 4);
1531     }
1532
1533   if (isforce && IS_CSKY_ARCH_V2 (mach_flag))
1534     {
1535       /* Add one nop insn at end of literal for disassembler.  */
1536       mapping_state (MAP_TEXT);
1537       csky_insn.output = frag_more (2);
1538       md_number_to_chars (csky_insn.output, CSKYV2_INST_NOP, 2);
1539     }
1540
1541   insn_reloc = BFD_RELOC_NONE;
1542
1543   if (brarsym != NULL)
1544     colon (S_GET_NAME (brarsym));
1545   poolsize = 0;
1546 }
1547
1548 static int
1549 enter_literal (expressionS *e,
1550                int ispcrel,
1551                unsigned char isdouble,
1552                uint64_t dbnum)
1553 {
1554   unsigned int i;
1555   struct literal * p;
1556   if (poolsize >= MAX_POOL_SIZE - 2)
1557     {
1558       /* The literal pool is as full as we can handle. We have
1559          to be 2 entries shy of the 1024/4=256 entries because we
1560          have to allow for the branch (2 bytes) and the alignment
1561          (2 bytes before the first insn referencing the pool and
1562          2 bytes before the pool itself) == 6 bytes, rounds up
1563          to 2 entries.  */
1564
1565       /* Save the parsed symbol's reloc.  */
1566       enum bfd_reloc_code_real last_reloc_before_dump = insn_reloc;
1567       dump_literals (1);
1568       insn_reloc = last_reloc_before_dump;
1569     }
1570
1571   if (poolsize == 0)
1572     {
1573       /* Create new literal pool.  */
1574       if (++ poolnumber > 0xFFFF)
1575         as_fatal (_("more than 65K literal pools"));
1576
1577       make_internal_label (poolname, POOL_START_LABEL, poolnumber);
1578       poolsym = symbol_make (poolname);
1579       symbol_table_insert (poolsym);
1580       poolspan = 0;
1581     }
1582
1583   /* Search pool for value so we don't have duplicates.  */
1584   for (p = litpool, i = 0; i < poolsize; i += (p->isdouble ? 2 : 1), p++)
1585     {
1586       if (e->X_op == p->e.X_op
1587           && e->X_add_symbol == p->e.X_add_symbol
1588           && e->X_add_number == p->e.X_add_number
1589           && ispcrel == p->ispcrel
1590           && insn_reloc == p->r_type
1591           && isdouble == p->isdouble
1592           && insn_reloc != BFD_RELOC_CKCORE_TLS_GD32
1593           && insn_reloc != BFD_RELOC_CKCORE_TLS_LDM32
1594           && insn_reloc != BFD_RELOC_CKCORE_TLS_LDO32
1595           && insn_reloc != BFD_RELOC_CKCORE_TLS_IE32
1596           && insn_reloc != BFD_RELOC_CKCORE_TLS_LE32)
1597         {
1598           p->refcnt ++;
1599           return i;
1600         }
1601     }
1602   p->refcnt = 1;
1603   p->ispcrel = ispcrel;
1604   p->e = *e;
1605   p->r_type = insn_reloc;
1606   p->isdouble = isdouble;
1607   if (isdouble)
1608     p->dbnum = dbnum;
1609
1610   if (insn_reloc == BFD_RELOC_CKCORE_TLS_GD32
1611       || insn_reloc == BFD_RELOC_CKCORE_TLS_LDM32
1612       || insn_reloc == BFD_RELOC_CKCORE_TLS_IE32)
1613     {
1614       p->tls_addend.frag  = frag_now;
1615       p->tls_addend.offset = csky_insn.output - frag_now->fr_literal;
1616       literal_insn_offset = p;
1617     }
1618   poolsize += (p->isdouble ? 2 : 1);
1619   return i;
1620 }
1621
1622 /* Check whether we must dump the literal pool here.
1623    kind == 0 is any old instruction.
1624    kind  > 0 means we just had a control transfer instruction.
1625    kind == 1 means within a function.
1626    kind == 2 means we just left a function.
1627
1628    OFFSET is the length of the insn being processed.
1629
1630    SPANCLOSE and SPANEXIT are smaller numbers than SPANPANIC.
1631    SPANPANIC means that we must dump now.
1632    The dump_literals (1) call inserts a branch around the table, so
1633    we first look to see if its a situation where we won't have to
1634    insert a branch (e.g., the previous instruction was an unconditional
1635    branch).
1636
1637    SPANPANIC is the point where we must dump a single-entry pool.
1638    it accounts for alignments and an inserted branch.
1639    the 'poolsize*2' accounts for the scenario where we do:
1640    lrw r1,lit1; lrw r2,lit2; lrw r3,lit3
1641    Note that the 'lit2' reference is 2 bytes further along
1642    but the literal it references will be 4 bytes further along,
1643    so we must consider the poolsize into this equation.
1644    This is slightly over-cautious, but guarantees that we won't
1645    panic because a relocation is too distant.  */
1646
1647 static void
1648 check_literals (int kind, int offset)
1649 {
1650   poolspan += offset;
1651
1652   if ((poolspan > SPANEXIT || do_func_dump)
1653       && kind > 1
1654       && (do_br_dump || do_func_dump))
1655     dump_literals (0);
1656   else if (poolspan > SPANCLOSE && (kind > 0) && do_br_dump)
1657     dump_literals (0);
1658   else if (poolspan
1659            >= (SPANPANIC - (IS_CSKY_ARCH_V1 (mach_flag) ?  poolsize * 2 : 0)))
1660     dump_literals (1);
1661   /* We have not dumped literal pool before insn1,
1662      and will not dump literal pool between insn1 and insnN+1,
1663      so reset poolspan to original length.  */
1664   else if (do_noliteraldump == 1)
1665     poolspan -= offset;
1666
1667   if (do_noliteraldump == 1)
1668     do_noliteraldump = 0;
1669 }
1670
1671 /* The next group of functions are helpers for parsing various kinds
1672    of instruction operand syntax.  */
1673
1674 /* Parse operands of the form
1675    <symbol>@GOTOFF+<nnn>
1676    and similar .plt or .got references.
1677
1678    If we find one, set up the correct relocation in RELOC and copy the
1679    input string, minus the `@GOTOFF' into a malloc'd buffer for
1680    parsing by the calling routine.  Return this buffer, and if ADJUST
1681    is non-null set it to the length of the string we removed from the
1682    input line.  Otherwise return NULL.  */
1683
1684 static char *
1685 lex_got (enum bfd_reloc_code_real *reloc,
1686          int *adjust)
1687 {
1688   struct _gotrel
1689   {
1690     const char *str;
1691     const enum bfd_reloc_code_real rel;
1692   };
1693   static const struct _gotrel gotrel[] =
1694     {
1695       { "GOTOFF",     BFD_RELOC_CKCORE_GOTOFF      },
1696       { "GOTPC",      BFD_RELOC_CKCORE_GOTPC       },
1697       { "GOTTPOFF",   BFD_RELOC_CKCORE_TLS_IE32    },
1698       { "GOT",        BFD_RELOC_CKCORE_GOT32       },
1699       { "PLT",        BFD_RELOC_CKCORE_PLT32       },
1700       { "BTEXT",      BFD_RELOC_CKCORE_TOFFSET_LO16},
1701       { "BDATA",      BFD_RELOC_CKCORE_DOFFSET_LO16},
1702       { "TLSGD32",    BFD_RELOC_CKCORE_TLS_GD32    },
1703       { "TLSLDM32",   BFD_RELOC_CKCORE_TLS_LDM32   },
1704       { "TLSLDO32",   BFD_RELOC_CKCORE_TLS_LDO32   },
1705       { "TPOFF",      BFD_RELOC_CKCORE_TLS_LE32    }
1706     };
1707
1708   char *cp;
1709   unsigned int j;
1710
1711   for (cp = input_line_pointer; *cp != '@'; cp++)
1712     if (is_end_of_line[(unsigned char) *cp])
1713       return NULL;
1714
1715   for (j = 0; j < sizeof (gotrel) / sizeof (gotrel[0]); j++)
1716     {
1717       int len = strlen (gotrel[j].str);
1718
1719       if (strncasecmp (cp + 1, gotrel[j].str, len) == 0)
1720         {
1721           if (gotrel[j].rel != 0)
1722             {
1723               *reloc = gotrel[j].rel;
1724               if (adjust)
1725                 *adjust = len;
1726
1727               /* input_line_pointer is the str pointer after relocation
1728                  token like @GOTOFF.  */
1729               input_line_pointer += len + 1;
1730               return input_line_pointer;
1731             }
1732
1733           csky_show_error (ERROR_RELOC_ILLEGAL, 0,
1734                            (void *)gotrel[j].str, NULL);
1735           return NULL;
1736         }
1737     }
1738
1739   /* Might be a symbol version string.  Don't as_bad here.  */
1740   return NULL;
1741 }
1742
1743 /* Parse an expression, returning it in E.  */
1744
1745 static char *
1746 parse_exp (char *s, expressionS *e)
1747 {
1748   char *save;
1749   char *new;
1750
1751   /* Skip whitespace.  */
1752   while (ISSPACE (*s))
1753     ++s;
1754
1755   save = input_line_pointer;
1756   input_line_pointer = s;
1757
1758   insn_reloc = BFD_RELOC_NONE;
1759   expression (e);
1760   lex_got (&insn_reloc, NULL);
1761
1762   if (e->X_op == O_absent)
1763     SET_ERROR_NUMBER (ERROR_MISSING_OPERAND, NULL);
1764
1765   new = input_line_pointer;
1766   input_line_pointer = save;
1767
1768   return new;
1769 }
1770
1771 /* Parse a floating-point number from S into its target representation.
1772    If ISDOUBLE is true, return the result in *DBNUM; otherwise
1773    it's returned in E->X_add_number.  Returns the result of advancing
1774    S past the constant.  */
1775
1776 static char *
1777 parse_fexp (char *s, expressionS *e, unsigned char isdouble, uint64_t *dbnum)
1778 {
1779   int length;                       /* Number of chars in an object.  */
1780   register char const *err = NULL;  /* Error from scanning float literal.  */
1781   char temp[8];
1782
1783   /* input_line_pointer->1st char of a flonum (we hope!).  */
1784   input_line_pointer = s;
1785
1786   if (input_line_pointer[0] == '0'
1787       && ISALPHA (input_line_pointer[1]))
1788     input_line_pointer += 2;
1789
1790   if (isdouble)
1791     err = md_atof ('d', temp, &length);
1792   else
1793     err = md_atof ('f', temp, &length);
1794   know (length <= 8);
1795   know (err != NULL || length > 0);
1796
1797   if (!is_end_of_line[(unsigned char) *input_line_pointer])
1798     as_bad (_("immediate operand required"));
1799   while (!is_end_of_line[(unsigned char) *input_line_pointer])
1800     input_line_pointer++;
1801
1802   if (err)
1803     {
1804       as_bad (_("bad floating literal: %s"), err);
1805       while (!is_end_of_line[(unsigned char) *input_line_pointer])
1806         input_line_pointer++;
1807       know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
1808       return input_line_pointer;
1809     }
1810
1811   e->X_add_symbol = 0x0;
1812   e->X_op_symbol = 0x0;
1813   e->X_op = O_constant;
1814   e->X_unsigned = 1;
1815   e->X_md = 0x0;
1816
1817   if (!isdouble)
1818     {
1819       uint32_t fnum;
1820       if (target_big_endian)
1821         fnum = (((temp[0] << 24) & 0xffffffff)
1822                 | ((temp[1] << 16) & 0xffffff)
1823                 | ((temp[2] << 8) & 0xffff)
1824                 | (temp[3] & 0xff));
1825       else
1826         fnum = (((temp[3] << 24) & 0xffffffff)
1827                            | ((temp[2] << 16) & 0xffffff)
1828                            | ((temp[1] << 8) & 0xffff)
1829                            | (temp[0] & 0xff));
1830       e->X_add_number = fnum;    }
1831   else
1832     {
1833       if (target_big_endian)
1834         {
1835           *dbnum = (((temp[0] << 24) & 0xffffffff)
1836                     | ((temp[1] << 16) & 0xffffff)
1837                     | ((temp[2] << 8) & 0xffff)
1838                     | (temp[3] & 0xff));
1839           *dbnum <<= 32;
1840           *dbnum |= (((temp[4] << 24) & 0xffffffff)
1841                      | ((temp[5] << 16) & 0xffffff)
1842                      | ((temp[6] << 8) & 0xffff)
1843                      | (temp[7] & 0xff));
1844         }
1845       else
1846         {
1847           *dbnum = (((temp[7] << 24) & 0xffffffff)
1848                     | ((temp[6] << 16) & 0xffffff)
1849                     | ((temp[5] << 8) & 0xffff)
1850                     | (temp[4] & 0xff));
1851           *dbnum <<= 32;
1852           *dbnum |= (((temp[3] << 24) & 0xffffffff)
1853                      | ((temp[2] << 16) & 0xffffff)
1854                      | ((temp[1] << 8) & 0xffff)
1855                      | (temp[0] & 0xff));
1856       }
1857     }
1858   return input_line_pointer;
1859 }
1860
1861 static char *
1862 parse_rt (char *s,
1863           int ispcrel,
1864           expressionS *ep,
1865           long reg ATTRIBUTE_UNUSED)
1866 {
1867   expressionS e;
1868   int n;
1869
1870   if (ep)
1871     /* Indicate nothing there.  */
1872     ep->X_op = O_absent;
1873
1874   if (*s == '[')
1875     {
1876       s = parse_exp (s + 1, &e);
1877
1878       if (*s == ']')
1879         s++;
1880       else
1881         SET_ERROR_NUMBER (ERROR_MISSING_RSQUARE_BRACKETS, NULL);
1882
1883       if (ep)
1884        *ep = e;
1885     }
1886   else
1887     {
1888       s = parse_exp (s, &e);
1889       if (BFD_RELOC_CKCORE_DOFFSET_LO16 == insn_reloc
1890            || BFD_RELOC_CKCORE_TOFFSET_LO16 == insn_reloc)
1891         {
1892           if (ep)
1893             *ep = e;
1894           return s;
1895         }
1896       if (ep)
1897         *ep = e;
1898       /* If the instruction has work, literal handling is in the work.  */
1899       if (!csky_insn.opcode->work)
1900         {
1901           n = enter_literal (&e, ispcrel, 0, 0);
1902           if (ep)
1903            *ep = e;
1904
1905           /* Create a reference to pool entry.  */
1906           ep->X_op = O_symbol;
1907           ep->X_add_symbol = poolsym;
1908           ep->X_add_number = n << 2;
1909         }
1910     }
1911   return s;
1912 }
1913
1914 static char *
1915 parse_rtf (char *s, int ispcrel, expressionS *ep)
1916 {
1917   expressionS e;
1918   int n = 0;
1919
1920   if (ep)
1921     /* Indicate nothing there.  */
1922     ep->X_op = O_absent;
1923
1924   if (*s == '[')
1925     {
1926       s = parse_exp (s + 1, & e);
1927
1928       if (*s == ']')
1929         s++;
1930       else
1931         as_bad (_("missing ']'"));
1932
1933       if (ep)
1934         *ep = e;
1935     }
1936   else
1937     {
1938       uint64_t dbnum;
1939       if (strstr (csky_insn.opcode->mnemonic, "flrws"))
1940         {
1941           s = parse_fexp (s, &e, 0, &dbnum);
1942           n = enter_literal (&e, ispcrel, 0, dbnum);
1943         }
1944       else if (strstr (csky_insn.opcode->mnemonic, "flrwd"))
1945         {
1946           s = parse_fexp (s, &e, 1, &dbnum);
1947           n = enter_literal (&e, ispcrel, 1, dbnum);
1948         }
1949       else
1950         as_bad (_("unrecognized opcode"));
1951
1952       if (ep)
1953         *ep = e;
1954
1955       /* Create a reference to pool entry.  */
1956       ep->X_op         = O_symbol;
1957       ep->X_add_symbol = poolsym;
1958       ep->X_add_number = n << 2;
1959     }
1960   return s;
1961 }
1962
1963 static bfd_boolean
1964 parse_type_ctrlreg (char** oper)
1965 {
1966   int i = -1;
1967   int len = 0;
1968
1969   if (TOLOWER (*(*oper + 0)) == 'c'
1970       && TOLOWER (*(*oper + 1)) == 'r'
1971       && ISDIGIT (*(*oper + 2)))
1972     {
1973       /* The control registers are named crxx.  */
1974       i = *(*oper + 2) - 0x30;
1975       i = ISDIGIT (*(*oper + 3)) ? (*(*oper + 3) - 0x30) + 10 * i : i;
1976       len = ISDIGIT (*(*oper + 3)) ? 4 : 3;
1977       *oper += len;
1978     }
1979   else if (!(TOLOWER (*(*oper + 0)) == 'c'
1980              && TOLOWER (*(*oper + 1)) == 'r'))
1981     {
1982       /* The control registers are aliased.  */
1983       struct csky_reg *reg = &csky_ctrl_regs[0];
1984       while (reg->name)
1985         {
1986           if (memcmp (*oper, reg->name, strlen (reg->name)) == 0
1987               && (!reg->flag || (isa_flag & reg->flag)))
1988             {
1989               i = reg->index;
1990               len = strlen (reg->name);
1991               *oper += len;
1992               break;
1993             }
1994           reg++;
1995         }
1996     }
1997
1998   if (IS_CSKY_V2 (mach_flag))
1999     {
2000       char *s = *oper;
2001       int crx;
2002       int sel;
2003       if (i != -1)
2004         {
2005           crx = i;
2006           sel = 0;
2007         }
2008       else
2009         {
2010           if (s[0] == 'c' && s[1] == 'r')
2011             {
2012               s += 2;
2013               if (*s == '<')
2014                 {
2015                   s++;
2016                   if (s[0] == '3' && s[1] >= '0' && s[1] <= '1')
2017                     {
2018                       crx = 30 + s[1] - '0';
2019                       s += 2;
2020                     }
2021                   else if (s[0] == '2' && s[1] >= '0' && s[1] <= '9')
2022                     {
2023                       crx = 20 + s[1] - '0';
2024                       s += 2;
2025                     }
2026                   else if (s[0] == '1' && s[1] >= '0' && s[1] <= '9')
2027                     {
2028                       crx = 10 + s[1] - '0';
2029                       s += 2;
2030                     }
2031                   else if (s[0] >= '0' && s[0] <= '9')
2032                     {
2033                       crx = s[0] - '0';
2034                       s += 1;
2035                     }
2036                   else
2037                     {
2038                       SET_ERROR_NUMBER (ERROR_REG_OVER_RANGE, "control");
2039                       return FALSE;
2040                     }
2041                   if (*s == ',')
2042                     s++;
2043                   else
2044                     {
2045                       SET_ERROR_NUMBER (ERROR_CREG_ILLEGAL, NULL);
2046                       return FALSE;
2047                     }
2048                   char *pS = s;
2049                   while (*pS != '>' && !is_end_of_line[(unsigned char) *pS])
2050                     pS++;
2051                   if (*pS == '>')
2052                       *pS = '\0';
2053                   else
2054                     {
2055                       /* Error. Missing '>'.  */
2056                       SET_ERROR_NUMBER (ERROR_MISSING_RANGLE_BRACKETS, NULL);
2057                       return FALSE;
2058                     }
2059                   expressionS e;
2060                   s = parse_exp (s, &e);
2061                   if (e.X_op == O_constant
2062                       && e.X_add_number >= 0
2063                       && e.X_add_number <= 31)
2064                     {
2065                       *oper = s;
2066                       sel = e.X_add_number;
2067                     }
2068                   else
2069                     return FALSE;
2070                 }
2071               else
2072                 {
2073                   /* Error. Missing '<'.  */
2074                   SET_ERROR_NUMBER (ERROR_MISSING_LANGLE_BRACKETS, NULL);
2075                   return FALSE;
2076                 }
2077             }
2078           else
2079             {
2080               SET_ERROR_NUMBER (ERROR_CREG_ILLEGAL, NULL);
2081               return FALSE;
2082             }
2083         }
2084         i = (sel << 5) | crx;
2085     }
2086   csky_insn.val[csky_insn.idx++] = i;
2087   return TRUE;
2088 }
2089
2090 static bfd_boolean
2091 is_reg_sp_with_bracket (char **oper)
2092 {
2093   const char **regs;
2094   int sp_idx;
2095   int len;
2096
2097   if (IS_CSKY_V1 (mach_flag))
2098     sp_idx = 0;
2099   else
2100     sp_idx = 14;
2101
2102   if (**oper != '(')
2103       return FALSE;
2104   *oper += 1;
2105   regs = csky_general_reg;
2106   len = strlen (regs[sp_idx]);
2107   if (memcmp (*oper, regs[sp_idx], len) == 0)
2108     {
2109       *oper += len;
2110       if (**oper != ')')
2111         return FALSE;
2112       *oper += 1;
2113       csky_insn.val[csky_insn.idx++] = sp_idx;
2114       return TRUE;
2115     }
2116   else
2117     {
2118       if (IS_CSKY_V1 (mach_flag))
2119         regs = cskyv1_general_alias_reg;
2120       else
2121         regs = cskyv2_general_alias_reg;
2122       len = strlen (regs[sp_idx]);
2123       if (memcmp (*oper, regs[sp_idx], len) == 0)
2124         {
2125           *oper += len;
2126           if (**oper != ')')
2127             return FALSE;
2128           *oper += 1;
2129           return TRUE;
2130         }
2131     }
2132   return FALSE;
2133 }
2134
2135 static bfd_boolean
2136 is_reg_sp (char **oper)
2137 {
2138   const char **regs;
2139   int sp_idx;
2140   int len;
2141   if (IS_CSKY_V1 (mach_flag))
2142     sp_idx = 0;
2143   else
2144     sp_idx = 14;
2145
2146   regs = csky_general_reg;
2147   len = strlen (regs[sp_idx]);
2148   if (memcmp (*oper, regs[sp_idx], len) == 0)
2149     {
2150       *oper += len;
2151       csky_insn.val[csky_insn.idx++] = sp_idx;
2152       return TRUE;
2153     }
2154   else
2155     {
2156       if (IS_CSKY_V1 (mach_flag))
2157         regs = cskyv1_general_alias_reg;
2158       else
2159         regs = cskyv2_general_alias_reg;
2160       len = strlen (regs[sp_idx]);
2161       if (memcmp (*oper, regs[sp_idx], len) == 0)
2162         {
2163           *oper += len;
2164           csky_insn.val[csky_insn.idx++] = sp_idx;
2165           return TRUE;
2166         }
2167     }
2168   return FALSE;
2169 }
2170
2171 static int
2172 csky_get_reg_val (char *str, int *len)
2173 {
2174   long reg = 0;
2175   if (TOLOWER (str[0]) == 'r' && ISDIGIT (str[1]))
2176     {
2177       if (ISDIGIT (str[1]) && ISDIGIT (str[2]))
2178         {
2179           reg = (str[1] - '0') * 10 + str[2] - '0';
2180           *len = 3;
2181         }
2182       else if (ISDIGIT (str[1]))
2183         {
2184           reg = str[1] - '0';
2185           *len = 2;
2186         }
2187       else
2188         return -1;
2189     }
2190   else if (TOLOWER (str[0]) == 's' && TOLOWER (str[1]) == 'p'
2191            && !ISDIGIT (str[2]))
2192     {
2193       /* sp.  */
2194       if (IS_CSKY_V1 (mach_flag))
2195         reg = 0;
2196       else
2197         reg = 14;
2198       *len = 2;
2199     }
2200   else if (TOLOWER (str[0]) == 'g' && TOLOWER (str[1]) == 'b'
2201            && !ISDIGIT (str[2]))
2202     {
2203       /* gb.  */
2204       if (IS_CSKY_V1 (mach_flag))
2205         reg = 14;
2206       else
2207         reg = 28;
2208       *len = 2;
2209     }
2210   else if (TOLOWER (str[0]) == 'l' && TOLOWER (str[1]) == 'r'
2211            && !ISDIGIT (str[2]))
2212     {
2213       /* lr.  */
2214       reg = 15;
2215       *len = 2;
2216     }
2217   else if (TOLOWER (str[0]) == 't' && TOLOWER (str[1]) == 'l'
2218            && TOLOWER (str[2]) == 's' && !ISDIGIT (str[3]))
2219     {
2220       /* tls.  */
2221       if (IS_CSKY_V2 (mach_flag))
2222         reg = 31;
2223       else
2224         return -1;
2225       *len = 3;
2226     }
2227   else if (TOLOWER (str[0]) == 's' && TOLOWER (str[1]) == 'v'
2228            && TOLOWER (str[2]) == 'b' && TOLOWER (str[3]) == 'r')
2229     {
2230       if (IS_CSKY_V2 (mach_flag))
2231         reg = 30;
2232       else
2233         return -1;
2234       *len = 4;
2235     }
2236   else if (TOLOWER (str[0]) == 'a')
2237     {
2238       if (ISDIGIT (str[1]) && !ISDIGIT (str[2]))
2239         {
2240           if (IS_CSKY_V1 (mach_flag) && (str[1] - '0') <= 5)
2241             /* a0 - a5.  */
2242             reg = 2 + str[1] - '0';
2243           else if (IS_CSKY_V2 (mach_flag) && (str[1] - '0') <= 3)
2244             /* a0 - a3.  */
2245             reg = str[1] - '0';
2246           else
2247             return -1;
2248           *len = 2;
2249         }
2250     }
2251   else if (TOLOWER (str[0]) == 't')
2252     {
2253       if (IS_CSKY_V2 (mach_flag))
2254         {
2255           reg = atoi (str + 1);
2256           if (reg > 9)
2257             return -1;
2258
2259           if (reg > 1)
2260             /* t2 - t9.  */
2261             reg = reg + 16;
2262           else
2263             /* t0 - t1.  */
2264             reg = reg + 12;
2265           *len = 2;
2266         }
2267     }
2268   else if (TOLOWER (str[0]) == 'l')
2269     {
2270       if (str[1] < '0' || str[1] > '9')
2271         return -1;
2272       if (IS_CSKY_V2 (mach_flag))
2273         {
2274           reg = atoi (str + 1);
2275           if (reg > 9)
2276             return -1;
2277           if (reg > 7)
2278             /* l8 - l9.  */
2279             reg = reg + 8;
2280           else
2281             /* l0 - l7.  */
2282             reg = reg + 4;
2283         }
2284       else
2285         {
2286           reg = atoi (str + 1);
2287           if (reg > 5)
2288             return -1;
2289           /* l0 - l6 -> r8 - r13.  */
2290           reg = reg + 8;
2291         }
2292       *len = 2;
2293     }
2294   else
2295     return -1;
2296
2297   /* Is register available?  */
2298   if (IS_CSKY_ARCH_801 (mach_flag))
2299     {
2300       /* CK801 register range is r0-r8 & r13-r15.  */
2301       if ((reg > 8 && reg < 13) || reg > 15)
2302         {
2303           SET_ERROR_NUMBER (ERROR_REG_OVER_RANGE, reg);
2304           return -1;
2305         }
2306     }
2307   else if (IS_CSKY_ARCH_802 (mach_flag))
2308     {
2309       /* CK802 register range is r0-r15 & r23-r25 & r30.  */
2310       if ((reg > 15 && reg < 23) || (reg > 25 && reg != 30))
2311         {
2312           SET_ERROR_NUMBER (ERROR_REG_OVER_RANGE, reg);
2313           return -1;
2314         }
2315     }
2316   else if (reg > 31 || reg < 0)
2317     {
2318       SET_ERROR_NUMBER (ERROR_REG_OVER_RANGE, reg);
2319       return -1;
2320     }
2321
2322   return reg;
2323 }
2324
2325 static int
2326 csky_get_freg_val (char *str, int *len)
2327 {
2328   int reg = 0;
2329   char *s = NULL;
2330   if ((str[0] == 'v' || str[0] == 'f') && (str[1] == 'r'))
2331     {
2332       /* It is fpu register.  */
2333       s = &str[2];
2334       while (ISDIGIT (*s))
2335         {
2336           reg = reg * 10 + (*s) - '0';
2337           s++;
2338         }
2339       if (reg > 31)
2340         return -1;
2341     }
2342   else
2343     return -1;
2344   *len = s - str;
2345   return reg;
2346 }
2347
2348 static bfd_boolean
2349 is_reglist_legal (char **oper)
2350 {
2351   int reg1 = -1;
2352   int reg2 = -1;
2353   int len = 0;
2354   reg1 = csky_get_reg_val  (*oper, &len);
2355   *oper += len;
2356
2357   if (reg1 == -1 || (IS_CSKY_V1 (mach_flag) && (reg1 == 0 || reg1 == 15)))
2358     {
2359       SET_ERROR_NUMBER (ERROR_REG_FORMAT,
2360                         "The first reg must not be r0/r15");
2361       return FALSE;
2362     }
2363
2364   if (**oper != '-')
2365     {
2366       SET_ERROR_NUMBER (ERROR_REG_FORMAT,
2367                         "The operand format must be rx-ry");
2368       return FALSE;
2369     }
2370   *oper += 1;
2371
2372   reg2 = csky_get_reg_val  (*oper, &len);
2373   *oper += len;
2374
2375   if (reg2 == -1 || (IS_CSKY_V1 (mach_flag) && reg1 == 15))
2376     {
2377       SET_ERROR_NUMBER (ERROR_REG_FORMAT,
2378                         "The operand format must be r15 in C-SKY V1");
2379       return FALSE;
2380     }
2381   if (IS_CSKY_V2 (mach_flag))
2382     {
2383       if (reg2 < reg1)
2384         {
2385           SET_ERROR_NUMBER (ERROR_REG_FORMAT,
2386                             "The operand format must be rx-ry (rx < ry)");
2387           return FALSE;
2388         }
2389       reg2 = reg2 - reg1;
2390       reg1 <<= 5;
2391       reg1 |= reg2;
2392     }
2393   csky_insn.val[csky_insn.idx++] = reg1;
2394   return TRUE;
2395 }
2396
2397 static bfd_boolean
2398 is_freglist_legal (char **oper)
2399 {
2400   int reg1 = -1;
2401   int reg2 = -1;
2402   int len = 0;
2403   reg1 = csky_get_freg_val  (*oper, &len);
2404   *oper += len;
2405
2406   if (reg1 == -1)
2407     {
2408       SET_ERROR_NUMBER (ERROR_REG_FORMAT,
2409                         "The fpu register format is not recognized.");
2410       return FALSE;
2411     }
2412
2413   if (**oper != '-')
2414     {
2415       SET_ERROR_NUMBER (ERROR_REG_FORMAT,
2416                         "The operand format must be vrx-vry/frx-fry.");
2417       return FALSE;
2418     }
2419   *oper += 1;
2420
2421   reg2 = csky_get_freg_val  (*oper, &len);
2422   *oper += len;
2423
2424   if (reg2 == -1)
2425     {
2426       SET_ERROR_NUMBER (ERROR_REG_FORMAT,
2427                         "The fpu register format is not recognized.");
2428       return FALSE;
2429     }
2430   if (reg2 < reg1)
2431     {
2432       SET_ERROR_NUMBER (ERROR_REG_FORMAT,
2433                         "The operand format must be rx-ry(rx < ry)");
2434       return FALSE;
2435     }
2436   reg2 = reg2 - reg1;
2437   reg2 <<= 4;
2438   reg1 |= reg2;
2439   csky_insn.val[csky_insn.idx++] = reg1;
2440   return TRUE;
2441 }
2442
2443 static bfd_boolean
2444 is_reglist_dash_comma_legal (char **oper, struct operand *oprnd)
2445 {
2446   int reg1 = -1;
2447   int reg2 = -1;
2448   int len = 0;
2449   int list = 0;
2450   int flag = 0;
2451   int temp = 0;
2452   while (**oper != '\n' && **oper != '\0')
2453     {
2454       reg1 = csky_get_reg_val  (*oper, &len);
2455       if (reg1 == -1)
2456         {
2457           SET_ERROR_NUMBER (ERROR_REG_LIST, NULL);
2458           return FALSE;
2459         }
2460       flag |= (1 << reg1);
2461       *oper += len;
2462       if (**oper == '-')
2463         {
2464           *oper += 1;
2465           reg2 = csky_get_reg_val  (*oper, &len);
2466           if (reg2 == -1)
2467             {
2468               SET_ERROR_NUMBER (ERROR_REG_LIST, NULL);
2469               return FALSE;
2470             }
2471           *oper += len;
2472           if (reg1 > reg2)
2473             {
2474               SET_ERROR_NUMBER (ERROR_REG_LIST, NULL);
2475               return FALSE;
2476             }
2477           while (reg2 >= reg1)
2478             {
2479               flag |= (1 << reg2);
2480               reg2--;
2481             }
2482         }
2483       if (**oper == ',')
2484         *oper += 1;
2485     }
2486   /* The reglist: r4-r11, r15, r16-r17, r28.  */
2487 #define REGLIST_BITS         0x10038ff0
2488   if (flag & ~(REGLIST_BITS))
2489     {
2490       SET_ERROR_NUMBER (ERROR_REG_LIST, NULL);
2491       return FALSE;
2492     }
2493   /* Check r4-r11.  */
2494   int i = 4;
2495   while (i <= 11)
2496     {
2497       if (flag & (1 << i))
2498         temp = i - 4 + 1;
2499       i++;
2500     }
2501   list |= temp;
2502
2503   /* Check r15.  */
2504   if (flag & (1 << 15))
2505     list |= (1 << 4);
2506
2507   /* Check r16-r17.  */
2508   i = 16;
2509   temp = 0;
2510   while (i <= 17)
2511     {
2512       if (flag & (1 << i))
2513         temp = i - 16 + 1;
2514       i++;
2515     }
2516   list |= (temp << 5);
2517
2518   /* Check r28.  */
2519   if (flag & (1 << 28))
2520     list |= (1 << 8);
2521   if (oprnd->mask == OPRND_MASK_0_4 && (list & ~OPRND_MASK_0_4))
2522     {
2523       SET_ERROR_NUMBER (ERROR_REG_LIST, NULL);
2524       return FALSE;
2525     }
2526   csky_insn.val[csky_insn.idx++] = list;
2527   return TRUE;
2528 }
2529
2530 static bfd_boolean
2531 is_reg_lshift_illegal (char **oper, int is_float)
2532 {
2533   int value;
2534   int len;
2535   int reg;
2536   reg = csky_get_reg_val  (*oper, &len);
2537   if (reg == -1)
2538     {
2539       SET_ERROR_NUMBER (ERROR_REG_FORMAT, "The register must be r0-r31.");
2540       return FALSE;
2541     }
2542
2543   *oper += len;
2544   if ((*oper)[0] != '<' || (*oper)[1] != '<')
2545     {
2546       SET_ERROR_NUMBER (ERROR_UNDEFINE,
2547                         "Operand format error; should be (rx, ry << n)");
2548       return FALSE;
2549     }
2550   *oper += 2;
2551
2552   expressionS e;
2553   char *new_oper = parse_exp (*oper, &e);
2554   if (e.X_op == O_constant)
2555     {
2556       *oper = new_oper;
2557       /* The immediate must be in [0, 3].  */
2558       if (e.X_add_number < 0 || e.X_add_number > 3)
2559         {
2560           SET_ERROR_NUMBER (ERROR_IMM_OVERFLOW, NULL);
2561           return FALSE;
2562         }
2563     }
2564   else
2565     {
2566       SET_ERROR_NUMBER (ERROR_EXP_CONSTANT, NULL);
2567       return FALSE;
2568     }
2569   if (is_float)
2570     value = (reg << 2) | e.X_add_number;
2571   else
2572     value = (reg << 5) | (1 << e.X_add_number);
2573   csky_insn.val[csky_insn.idx++] = value;
2574
2575   return TRUE;
2576 }
2577
2578 static bfd_boolean
2579 is_imm_over_range (char **oper, int min, int max, int ext)
2580 {
2581   expressionS e;
2582   bfd_boolean ret = FALSE;
2583   char *new_oper = parse_exp (*oper, &e);
2584   if (e.X_op == O_constant)
2585     {
2586       ret = TRUE;
2587       *oper = new_oper;
2588       if ((int)e.X_add_number != ext
2589           && (e.X_add_number < min || e.X_add_number > max))
2590         {
2591           ret = FALSE;
2592           SET_ERROR_NUMBER (ERROR_IMM_OVERFLOW, NULL);
2593         }
2594       csky_insn.val[csky_insn.idx++] = e.X_add_number;
2595     }
2596
2597   return ret;
2598 }
2599
2600 static bfd_boolean
2601 is_oimm_over_range (char **oper, int min, int max)
2602 {
2603   expressionS e;
2604   bfd_boolean ret = FALSE;
2605   char *new_oper = parse_exp (*oper, &e);
2606   if (e.X_op == O_constant)
2607     {
2608       ret = TRUE;
2609       *oper = new_oper;
2610       if (e.X_add_number < min || e.X_add_number > max)
2611         {
2612           ret = FALSE;
2613           SET_ERROR_NUMBER (ERROR_IMM_OVERFLOW, NULL);
2614         }
2615       csky_insn.val[csky_insn.idx++] = e.X_add_number - 1;
2616     }
2617
2618   return ret;
2619 }
2620
2621 static bfd_boolean
2622 is_psr_bit (char **oper)
2623 {
2624   const struct psrbit *bits;
2625   int i = 0;
2626
2627   if (IS_CSKY_V1 (mach_flag))
2628     bits = cskyv1_psr_bits;
2629   else
2630     bits = cskyv2_psr_bits;
2631
2632   while (bits[i].name != NULL)
2633     {
2634       if (bits[i].isa && !(bits[i].isa & isa_flag))
2635         {
2636           i++;
2637           continue;
2638         }
2639       if (strncasecmp (*oper, bits[i].name, strlen (bits[i].name)) == 0)
2640         {
2641           *oper += strlen (bits[i].name);
2642           csky_insn.val[csky_insn.idx] |= bits[i].value;
2643           return TRUE;
2644         }
2645       i++;
2646     }
2647   SET_ERROR_NUMBER (ERROR_OPCODE_PSRBIT, NULL);
2648   return FALSE;
2649 }
2650
2651 static bfd_boolean
2652 parse_type_cpidx (char** oper)
2653 {
2654   char *s = *oper;
2655   int idx;
2656   if (s[0] == 'c' && s[1] == 'p')
2657     {
2658       if (ISDIGIT (s[2]) && ISDIGIT (s[3]) && ! ISDIGIT (s[4]))
2659         {
2660           idx = (s[2] - '0') * 10 + s[3] - '0';
2661           *oper += 4;
2662         }
2663       else if (ISDIGIT (s[2]) && !ISDIGIT (s[3]))
2664         {
2665           idx = s[2] - '0';
2666           *oper += 3;
2667         }
2668       else
2669         return FALSE;
2670     }
2671   else
2672     {
2673       expressionS e;
2674       *oper = parse_exp (*oper, &e);
2675       if (e.X_op != O_constant)
2676         {
2677           /* Can not recognize the operand.  */
2678           return FALSE;
2679         }
2680       idx = e.X_add_number;
2681     }
2682
2683   csky_insn.val[csky_insn.idx++] = idx;
2684
2685   return TRUE;
2686 }
2687
2688 static bfd_boolean
2689 parse_type_cpreg (char** oper)
2690 {
2691   const char **regs = csky_cp_reg;
2692   int i;
2693   int len;
2694
2695   for (i = 0; i < (int)(sizeof (csky_cp_reg) / sizeof (char *)); i++)
2696     {
2697       len = strlen (regs[i]);
2698       if (memcmp (*oper, regs[i], len) == 0 && !ISDIGIT (*(*oper + len)))
2699         {
2700           *oper += len;
2701           csky_insn.val[csky_insn.idx++] = i;
2702           return TRUE;
2703         }
2704     }
2705   SET_ERROR_NUMBER (ERROR_CPREG_ILLEGAL, *oper);
2706   return FALSE;
2707 }
2708
2709 static bfd_boolean
2710 parse_type_cpcreg (char** oper)
2711 {
2712   const char **regs;
2713   int i;
2714   int len;
2715   regs = csky_cp_creg;
2716   for (i = 0; i < (int)(sizeof (csky_cp_creg) / sizeof (char *)); i++)
2717     {
2718       len = strlen (regs[i]);
2719       if (memcmp (*oper, regs[i], len) == 0 && !ISDIGIT (*(*oper + len)))
2720         {
2721           *oper += len;
2722           csky_insn.val[csky_insn.idx++] = i;
2723           return TRUE;
2724         }
2725     }
2726   SET_ERROR_NUMBER (ERROR_CPREG_ILLEGAL, *oper);
2727   return FALSE;
2728 }
2729
2730 static bfd_boolean
2731 parse_type_areg (char** oper)
2732 {
2733   int i = 0;
2734   int len = 0;
2735   i = csky_get_reg_val (*oper, &len);
2736   if (i == -1)
2737     {
2738       SET_ERROR_NUMBER (ERROR_GREG_ILLEGAL, NULL);
2739       return FALSE;
2740     }
2741   *oper += len;
2742   csky_insn.val[csky_insn.idx++] = i;
2743
2744   return TRUE;
2745 }
2746
2747 static bfd_boolean
2748 parse_type_freg (char** oper, int even)
2749 {
2750   int reg;
2751   int len;
2752   reg = csky_get_freg_val (*oper, &len);
2753   if (reg == -1)
2754     {
2755       SET_ERROR_NUMBER (ERROR_REG_FORMAT,
2756                         "The fpu register format is not recognized.");
2757       return FALSE;
2758     }
2759   *oper += len;
2760   csky_insn.opcode_end = *oper;
2761   if (even && reg & 0x1)
2762     {
2763       SET_ERROR_NUMBER (ERROR_EXP_EVEN_FREG, NULL);
2764       return FALSE;
2765     }
2766   csky_insn.val[csky_insn.idx++] = reg;
2767   return TRUE;
2768 }
2769
2770 static bfd_boolean
2771 parse_ldst_imm (char **oper, struct csky_opcode_info *op ATTRIBUTE_UNUSED,
2772                 struct operand *oprnd)
2773 {
2774   unsigned int mask = oprnd->mask;
2775   int max = 1;
2776   int shift = 0;
2777
2778   shift = oprnd->shift;
2779
2780   while (mask)
2781     {
2782       if (mask & 1)
2783         max <<= 1;
2784       mask >>= 1;
2785     }
2786   max = max << shift;
2787
2788   if (**oper == '\0' || **oper == ')')
2789     {
2790       csky_insn.val[csky_insn.idx++] = 0;
2791       return TRUE;
2792     }
2793
2794   expressionS e;
2795   *oper = parse_exp (*oper, &e);
2796   if (e.X_op != O_constant)
2797     /* Not a constant.  */
2798     return FALSE;
2799   else if (e.X_add_number < 0 || e.X_add_number >= max)
2800     {
2801       /* Out of range.  */
2802       SET_ERROR_NUMBER (ERROR_IMM_OVERFLOW, NULL);
2803       return FALSE;
2804     }
2805   if ((e.X_add_number % (1 << shift)) != 0)
2806     {
2807       /* Not aligned.  */
2808       SET_ERROR_NUMBER (ERROR_OFFSET_UNALIGNED, ((unsigned long)1 << shift));
2809       return FALSE;
2810     }
2811
2812   csky_insn.val[csky_insn.idx++] = e.X_add_number >> shift;
2813
2814   return TRUE;
2815
2816 }
2817
2818 static unsigned int
2819 csky_count_operands (char *str)
2820 {
2821   char *oper_end = str;
2822   unsigned int oprnd_num;
2823   int bracket_cnt = 0;
2824
2825   if (is_end_of_line[(unsigned char) *oper_end])
2826     oprnd_num = 0;
2827   else
2828     oprnd_num = 1;
2829
2830   /* Count how many operands.  */
2831   if (oprnd_num)
2832     while (!is_end_of_line[(unsigned char) *oper_end])
2833       {
2834         if (*oper_end == '(' || *oper_end == '<')
2835           {
2836             bracket_cnt++;
2837             oper_end++;
2838             continue;
2839           }
2840         if (*oper_end == ')' || *oper_end == '>')
2841           {
2842             bracket_cnt--;
2843             oper_end++;
2844             continue;
2845           }
2846         if (!bracket_cnt && *oper_end == ',')
2847           oprnd_num++;
2848         oper_end++;
2849       }
2850   return oprnd_num;
2851 }
2852
2853 /* End of the operand parsing helper functions.  */
2854
2855 /* Parse the opcode part of an instruction.  Fill in the csky_insn
2856    state and return true on success, false otherwise.  */
2857
2858 static bfd_boolean
2859 parse_opcode (char *str)
2860 {
2861 #define IS_OPCODE32F(a) (*(a - 2) == '3' && *(a - 1) == '2')
2862 #define IS_OPCODE16F(a) (*(a - 2) == '1' && *(a - 1) == '6')
2863
2864   /* TRUE if this opcode has a suffix, like 'lrw.h'.  */
2865   unsigned int has_suffix = FALSE;
2866   unsigned int nlen = 0;
2867   char *opcode_end;
2868   char name[OPCODE_MAX_LEN + 1];
2869   char macro_name[OPCODE_MAX_LEN + 1];
2870
2871   /* Remove space ahead of string.  */
2872   while (ISSPACE (*str))
2873     str++;
2874   opcode_end = str;
2875
2876   /* Find the opcode end.  */
2877   while (nlen < OPCODE_MAX_LEN
2878          && !is_end_of_line [(unsigned char) *opcode_end]
2879          && *opcode_end != ' ')
2880     {
2881       /* Is csky force 32 or 16 instruction?  */
2882       if (IS_CSKY_V2 (mach_flag)
2883           && *opcode_end == '.' && has_suffix == FALSE)
2884         {
2885           has_suffix = TRUE;
2886           if (IS_OPCODE32F (opcode_end))
2887             {
2888               csky_insn.flag_force = INSN_OPCODE32F;
2889               nlen -= 2;
2890             }
2891           else if (IS_OPCODE16F (opcode_end))
2892             {
2893               csky_insn.flag_force = INSN_OPCODE16F;
2894               nlen -= 2;
2895             }
2896         }
2897       name[nlen] = *opcode_end;
2898       nlen++;
2899       opcode_end++;
2900     }
2901
2902   /* Is csky force 32 or 16 instruction?  */
2903   if (has_suffix == FALSE)
2904     {
2905       if (IS_CSKY_V2 (mach_flag) && IS_OPCODE32F (opcode_end))
2906         {
2907           csky_insn.flag_force = INSN_OPCODE32F;
2908           nlen -= 2;
2909         }
2910       else if (IS_OPCODE16F (opcode_end))
2911         {
2912           csky_insn.flag_force = INSN_OPCODE16F;
2913           nlen -= 2;
2914         }
2915     }
2916   name[nlen] = '\0';
2917
2918   /* Generate macro_name for finding hash in macro hash_table.  */
2919   if (has_suffix == TRUE)
2920     nlen += 2;
2921   strncpy (macro_name, str, nlen);
2922   macro_name[nlen] = '\0';
2923
2924   /* Get csky_insn.opcode_end.  */
2925   while (ISSPACE (*opcode_end))
2926     opcode_end++;
2927   csky_insn.opcode_end = opcode_end;
2928
2929   /* Count the operands.  */
2930   csky_insn.number = csky_count_operands (opcode_end);
2931
2932   /* Find hash by name in csky_macros_hash and csky_opcodes_hash.  */
2933   csky_insn.macro = (struct csky_macro_info *) hash_find (csky_macros_hash,
2934                                                           macro_name);
2935   csky_insn.opcode = (struct csky_opcode *) hash_find (csky_opcodes_hash,
2936                                                         name);
2937
2938   if (csky_insn.macro == NULL && csky_insn.opcode == NULL)
2939     return FALSE;
2940   return TRUE;
2941 }
2942
2943 /* Main dispatch routine to parse operand OPRND for opcode OP from string
2944    *OPER.  */
2945
2946 static bfd_boolean
2947 get_operand_value (struct csky_opcode_info *op,
2948                    char **oper, struct operand *oprnd)
2949 {
2950   struct soperand *soprnd = NULL;
2951   if (oprnd->mask == HAS_SUB_OPERAND)
2952     {
2953       /* It has sub operand, it must be like:
2954          (oprnd1, oprnd2)
2955          or
2956          <oprnd1, oprnd2>
2957          We will check the format here.  */
2958       soprnd = (struct soperand *) oprnd;
2959       char lc = 0;
2960       char rc = 0;
2961       char *s = *oper;
2962       int  bracket_cnt = 0;
2963       if (oprnd->type == OPRND_TYPE_BRACKET)
2964         {
2965           lc = '(';
2966           rc = ')';
2967         }
2968       else if (oprnd->type == OPRND_TYPE_ABRACKET)
2969         {
2970           lc = '<';
2971           rc = '>';
2972         }
2973
2974       if (**oper == lc)
2975         {
2976           *oper += 1;
2977           s += 1;
2978         }
2979       else
2980         {
2981           SET_ERROR_NUMBER ((oprnd->type == OPRND_TYPE_BRACKET
2982                              ? ERROR_MISSING_LBRACKET
2983                              : ERROR_MISSING_LANGLE_BRACKETS), NULL);
2984           return FALSE;
2985         }
2986
2987       /* If the oprnd2 is an immediate, it can not be parsed
2988          that end with ')'/'>'.  Modify ')'/'>' to '\0'.  */
2989       while ((*s != rc || bracket_cnt != 0) && (*s != '\n' && *s != '\0'))
2990         {
2991           if (*s == lc)
2992             bracket_cnt++;
2993           else if (*s == rc)
2994             bracket_cnt--;
2995           s++;
2996         }
2997
2998       if (*s == rc)
2999         *s = '\0';
3000       else
3001         {
3002           SET_ERROR_NUMBER ((oprnd->type == OPRND_TYPE_BRACKET
3003                              ? ERROR_MISSING_RBRACKET
3004                              : ERROR_MISSING_RANGLE_BRACKETS), NULL);
3005           return FALSE;
3006         }
3007
3008       if (get_operand_value (op, oper, &soprnd->subs[0]) == FALSE)
3009         {
3010           *s = rc;
3011           return FALSE;
3012         }
3013       if (**oper == ',')
3014         *oper += 1;
3015       if (get_operand_value (op, oper, &soprnd->subs[1]) == FALSE)
3016         {
3017           *s = rc;
3018           return FALSE;
3019         }
3020
3021       *s = rc;
3022       *oper += 1;
3023       return TRUE;
3024     }
3025
3026   switch (oprnd->type)
3027     {
3028       /* TODO: add opcode type here, log errors in the function.
3029          If REGLIST, then j = csky_insn.number - 1.
3030          If there is needed to parse expressions, it will be
3031          handled here.  */
3032     case OPRND_TYPE_CTRLREG:
3033       /* some parse.  */
3034       return parse_type_ctrlreg (oper);
3035     case OPRND_TYPE_AREG:
3036       return parse_type_areg (oper);
3037     case OPRND_TYPE_FREG:
3038     case OPRND_TYPE_VREG:
3039       return parse_type_freg (oper, 0);
3040     case OPRND_TYPE_FEREG:
3041       return parse_type_freg (oper, 1);
3042     case OPRND_TYPE_CPCREG:
3043       return parse_type_cpcreg (oper);
3044     case OPRND_TYPE_CPREG:
3045       return parse_type_cpreg (oper);
3046     case OPRND_TYPE_CPIDX:
3047       return parse_type_cpidx (oper);
3048     case OPRND_TYPE_GREG0_7:
3049     case OPRND_TYPE_GREG0_15:
3050       {
3051         int len;
3052         long reg;
3053         reg = csky_get_reg_val (*oper, &len);
3054
3055         if (reg == -1)
3056           {
3057             SET_ERROR_NUMBER (ERROR_GREG_ILLEGAL, NULL);
3058             return FALSE;
3059           }
3060         else if ((oprnd->type == OPRND_TYPE_GREG0_7 && reg > 7)
3061                  || (oprnd->type == OPRND_TYPE_GREG0_15 && reg > 15))
3062           {
3063             SET_ERROR_NUMBER (ERROR_REG_OVER_RANGE, reg);
3064             return FALSE;
3065           }
3066         *oper += len;
3067         csky_insn.val[csky_insn.idx++] = reg;
3068         return TRUE;
3069       }
3070     case OPRND_TYPE_REGnsplr:
3071       {
3072         int len;
3073         long reg;
3074         reg = csky_get_reg_val (*oper, &len);
3075
3076         if (reg == -1
3077             || (IS_CSKY_V1 (mach_flag)
3078                 && (reg == V1_REG_SP || reg == V1_REG_LR)))
3079           {
3080             SET_ERROR_NUMBER (ERROR_REG_OVER_RANGE, reg);
3081             return FALSE;
3082           }
3083         csky_insn.val[csky_insn.idx++] = reg;
3084         *oper += len;
3085         return TRUE;;
3086       }
3087     case OPRND_TYPE_REGnr4_r7:
3088       {
3089         int len;
3090         int reg;
3091         if (**oper == '(')
3092           *oper += 1;
3093         reg = csky_get_reg_val (*oper, &len);
3094         if (reg == -1 || (reg <= 7 && reg >= 4))
3095           return FALSE;
3096
3097         csky_insn.val[csky_insn.idx++] = reg;
3098         *oper += len;
3099
3100         if (**oper == ')')
3101           *oper += 1;
3102         return TRUE;;
3103       }
3104     case OPRND_TYPE_REGr4_r7:
3105       if (memcmp (*oper, "r4-r7", sizeof ("r4-r7") - 1) == 0)
3106         {
3107           *oper += sizeof ("r4-r7") - 1;
3108           csky_insn.val[csky_insn.idx++] = 0;
3109           return TRUE;
3110         }
3111       SET_ERROR_NUMBER (ERROR_OPCODE_ILLEGAL, NULL);
3112       return FALSE;
3113     case OPRND_TYPE_IMM_LDST:
3114       return parse_ldst_imm (oper, op, oprnd);
3115     case OPRND_TYPE_IMM_FLDST:
3116       return parse_ldst_imm (oper, op, oprnd);
3117     case OPRND_TYPE_IMM1b:
3118       return is_imm_over_range (oper, 0, 1, -1);
3119     case OPRND_TYPE_IMM2b:
3120       return is_imm_over_range (oper, 0, 3, -1);
3121     case OPRND_TYPE_IMM2b_JMPIX:
3122       /* ck802j support jmpix16, but not support jmpix32.  */
3123       if (IS_CSKY_ARCH_802 (mach_flag)
3124           && (op->opcode & 0xffff0000) != 0)
3125         {
3126           SET_ERROR_NUMBER (ERROR_OPCODE_ILLEGAL, NULL);
3127           return FALSE;
3128         }
3129       *oper = parse_exp (*oper, &csky_insn.e1);
3130       if (csky_insn.e1.X_op == O_constant)
3131         {
3132           csky_insn.opcode_end = *oper;
3133           if (csky_insn.e1.X_add_number & 0x7)
3134             {
3135               SET_ERROR_NUMBER (ERROR_JMPIX_OVER_RANGE, NULL);
3136               return FALSE;
3137             }
3138           csky_insn.val[csky_insn.idx++]
3139             = (csky_insn.e1.X_add_number >> 3) - 2;
3140         }
3141       return TRUE;
3142     case OPRND_TYPE_IMM4b:
3143       return is_imm_over_range (oper, 0, 15, -1);
3144       break;
3145     case OPRND_TYPE_IMM5b:
3146       return is_imm_over_range (oper, 0, 31, -1);
3147       /* This type for "bgeni" in csky v1 ISA.  */
3148     case OPRND_TYPE_IMM5b_7_31:
3149       if (is_imm_over_range (oper, 0, 31, -1))
3150         {
3151           int val = csky_insn.val[csky_insn.idx - 1];
3152           /* immediate values of 0 -> 6 translate to movi.  */
3153           if (val <= 6)
3154             {
3155               const char *name = "movi";
3156               csky_insn.opcode = (struct csky_opcode *)
3157                 hash_find (csky_opcodes_hash, name);
3158               csky_insn.val[csky_insn.idx - 1] = 1 << val;
3159             }
3160           return TRUE;
3161         }
3162       else
3163         return FALSE;
3164
3165     case OPRND_TYPE_IMM5b_1_31:
3166       return is_imm_over_range (oper, 1, 31, -1);
3167     case OPRND_TYPE_IMM5b_POWER:
3168       if (is_imm_over_range (oper, 1, ~(1 << 31), 1 << 31))
3169         {
3170           int log;
3171           int val = csky_insn.val[csky_insn.idx - 1];
3172           log = csky_log_2 (val);
3173           csky_insn.val[csky_insn.idx - 1] = log;
3174           return (log == -1 ? FALSE : TRUE);
3175         }
3176       else
3177         return FALSE;
3178
3179       /* This type for "mgeni" in csky v1 ISA.  */
3180       case OPRND_TYPE_IMM5b_7_31_POWER:
3181         if (is_imm_over_range (oper, 1, ~(1 << 31), 1 << 31))
3182           {
3183             int log;
3184             int val = csky_insn.val[csky_insn.idx - 1];
3185             log = csky_log_2 (val);
3186             /* Immediate values of 0 -> 6 translate to movi.  */
3187             if (log <= 6)
3188               {
3189                 const char *name = "movi";
3190                 csky_insn.opcode = (struct csky_opcode *)
3191                   hash_find (csky_opcodes_hash, name);
3192                 as_warn (_("translating mgeni to movi"));
3193               }
3194             else
3195               csky_insn.val[csky_insn.idx - 1] = log;
3196             return (log == -1 ? FALSE : TRUE);
3197           }
3198         else
3199           return FALSE;
3200
3201     case OPRND_TYPE_IMM5b_RORI:
3202       {
3203         unsigned max_shift = IS_CSKY_V1 (mach_flag) ? 31 : 32;
3204
3205         if (is_imm_over_range (oper, 1, max_shift, -1))
3206           {
3207             int i = csky_insn.idx - 1;
3208             csky_insn.val[i] = 32 - csky_insn.val[i];
3209             return TRUE;
3210           }
3211         else
3212           return FALSE;
3213       }
3214
3215     case OPRND_TYPE_IMM5b_BMASKI:
3216       /* For csky v1 bmask inst.  */
3217
3218       if (!is_imm_over_range (oper, 8, 31, 0))
3219         {
3220           unsigned int mask_val = csky_insn.val[csky_insn.idx - 1];
3221           if (mask_val > 0 && mask_val < 8)
3222             {
3223               const char *op_movi = "movi";
3224               csky_insn.opcode = (struct csky_opcode *)
3225                 hash_find (csky_opcodes_hash, op_movi);
3226               if (csky_insn.opcode == NULL)
3227                 return FALSE;
3228               csky_insn.val[csky_insn.idx - 1] = (1 << mask_val) - 1;
3229               return TRUE;
3230             }
3231         }
3232       return TRUE;
3233
3234       case OPRND_TYPE_IMM8b_BMASKI:
3235       /* For csky v2 bmask, which will transfer to 16bits movi.  */
3236         if (is_imm_over_range (oper, 1, 8, -1))
3237           {
3238             unsigned int mask_val = csky_insn.val[csky_insn.idx - 1];
3239             csky_insn.val[csky_insn.idx - 1] = (1 << mask_val) - 1;
3240             return TRUE;
3241           }
3242         return FALSE;
3243     case OPRND_TYPE_OIMM4b:
3244       return is_oimm_over_range (oper, 1, 16);
3245     case OPRND_TYPE_OIMM5b:
3246       return is_oimm_over_range (oper, 1, 32);
3247     case OPRND_TYPE_OIMM5b_IDLY:
3248       if (is_imm_over_range (oper, 0, 32, -1))
3249         {
3250           /* imm5b for idly n: 0<=n<4, imm5b=3; 4<=n<=32, imm5b=n-1.  */
3251           unsigned long imm = csky_insn.val[csky_insn.idx - 1];
3252           if (imm < 4)
3253             {
3254               csky_show_error (WARNING_IDLY, 0, (void *)imm, NULL);
3255               imm = 3;
3256             }
3257           else imm--;
3258           csky_insn.val[csky_insn.idx - 1] = imm;
3259           return TRUE;
3260         }
3261       else
3262         return FALSE;
3263
3264       /* For csky v2 bmask inst.  */
3265     case OPRND_TYPE_OIMM5b_BMASKI:
3266       if (!is_oimm_over_range (oper, 17, 32))
3267         {
3268           int mask_val = csky_insn.val[csky_insn.idx - 1];
3269           if (mask_val + 1 == 0)
3270             return TRUE;
3271           if (mask_val > 0 && mask_val < 16)
3272             {
3273               const char *op_movi = "movi";
3274               csky_insn.opcode = (struct csky_opcode *)
3275                 hash_find (csky_opcodes_hash, op_movi);
3276               if (csky_insn.opcode == NULL)
3277                 return FALSE;
3278               csky_insn.val[csky_insn.idx - 1] = (1 << (mask_val + 1)) - 1;
3279               return TRUE;
3280             }
3281         }
3282       return TRUE;
3283     case OPRND_TYPE_IMM7b:
3284       return is_imm_over_range (oper, 0, 127, -1);
3285     case OPRND_TYPE_IMM8b:
3286       return is_imm_over_range (oper, 0, 255, -1);
3287     case OPRND_TYPE_IMM12b:
3288       return is_imm_over_range (oper, 0, 4095, -1);
3289     case OPRND_TYPE_IMM15b:
3290       return is_imm_over_range (oper, 0, 0xfffff, -1);
3291     case OPRND_TYPE_IMM16b:
3292       return is_imm_over_range (oper, 0, 65535, -1);
3293     case OPRND_TYPE_OIMM16b:
3294       return is_oimm_over_range (oper, 1, 65536);
3295     case OPRND_TYPE_IMM32b:
3296       {
3297         expressionS e;
3298         char *new_oper = parse_exp (*oper, &e);
3299         if (e.X_op == O_constant)
3300           {
3301             *oper = new_oper;
3302             csky_insn.val[csky_insn.idx++] = e.X_add_number;
3303             return TRUE;
3304           }
3305         return FALSE;
3306       }
3307     case OPRND_TYPE_IMM16b_MOVIH:
3308     case OPRND_TYPE_IMM16b_ORI:
3309       {
3310         bfd_reloc_code_real_type r = BFD_RELOC_NONE;
3311         int len;
3312         char *curr = *oper;
3313         char * save = input_line_pointer;
3314         /* get the reloc type, and set "@GOTxxx" as ' '  */
3315         while (**oper != '@' && **oper != '\0')
3316           *oper += 1;
3317         if (**oper != '\0')
3318           {
3319             input_line_pointer = *oper;
3320             lex_got (&r, &len);
3321             while (*(*oper + len + 1) != '\0')
3322               {
3323                 **oper = *(*oper + len + 1);
3324                 *(*oper + len + 1) = '\0';
3325                 *oper += 1;
3326               }
3327             **oper = '\0';
3328           }
3329         input_line_pointer = save;
3330         *oper = parse_exp (curr, &csky_insn.e1);
3331         return TRUE;
3332       }
3333     case OPRND_TYPE_PSR_BITS_LIST:
3334       {
3335         int ret = TRUE;
3336         if (csky_insn.number == 0)
3337           ret = FALSE;
3338         else
3339           {
3340             csky_insn.val[csky_insn.idx] = 0;
3341             if (is_psr_bit (oper) != FALSE)
3342               while (**oper == ',')
3343                 {
3344                   *oper += 1;
3345                   if (is_psr_bit (oper) == FALSE)
3346                     {
3347                       ret = FALSE;
3348                       break;
3349                     }
3350                 }
3351             else
3352               ret = FALSE;
3353             if (ret == TRUE && IS_CSKY_V1 (mach_flag)
3354                 && csky_insn.val[csky_insn.idx] > 8)
3355               ret = FALSE;
3356           }
3357         if (!ret)
3358           SET_ERROR_NUMBER (ERROR_OPERANDS_ILLEGAL, csky_insn.opcode_end);
3359         return ret;
3360       }
3361     case OPRND_TYPE_RM:
3362       {
3363         /* FPU round mode.  */
3364         static const char *round_mode[] =
3365           {
3366             "rm_nearest",
3367             "rm_zero",
3368             "rm_posinf",
3369             "rm_neginf",
3370             NULL
3371           };
3372         int i;
3373         for (i = 0; round_mode[i]; i++)
3374           if (strncasecmp (*oper, round_mode[i], strlen (round_mode[i])) == 0)
3375             {
3376               *oper += strlen (round_mode[i]);
3377               csky_insn.val[csky_insn.idx++] = i;
3378               return TRUE;
3379             }
3380         return FALSE;
3381       }
3382
3383     case OPRND_TYPE_REGLIST_COMMA:
3384     case OPRND_TYPE_BRACKET:
3385       /* TODO: using sub operand union.  */
3386     case OPRND_TYPE_ABRACKET:
3387       /* TODO: using sub operand union.  */
3388     case OPRND_TYPE_REGLIST_DASH:
3389       return is_reglist_legal (oper);
3390     case OPRND_TYPE_FREGLIST_DASH:
3391       return is_freglist_legal (oper);
3392     case OPRND_TYPE_AREG_WITH_BRACKET:
3393       {
3394         int len;
3395         int reg;
3396         if (**oper != '(')
3397           {
3398             SET_ERROR_NUMBER (ERROR_MISSING_LBRACKET, NULL);
3399             return FALSE;
3400           }
3401         *oper += 1;
3402         reg = csky_get_reg_val (*oper, &len);
3403         if (reg == -1)
3404           {
3405             SET_ERROR_NUMBER (ERROR_EXP_GREG, NULL);
3406             return FALSE;
3407           }
3408         *oper += len;
3409         if (**oper != ')')
3410           {
3411             SET_ERROR_NUMBER (ERROR_MISSING_RBRACKET, NULL);
3412             return FALSE;
3413           }
3414         *oper += 1;
3415         csky_insn.val[csky_insn.idx++] = reg;
3416         return TRUE;
3417       }
3418     case OPRND_TYPE_REGsp:
3419       return is_reg_sp (oper);
3420     case OPRND_TYPE_REGbsp:
3421       return is_reg_sp_with_bracket (oper);
3422       /* For jmpi.  */
3423     case OPRND_TYPE_OFF8b:
3424     case OPRND_TYPE_OFF16b:
3425       *oper = parse_rt (*oper, 1, &csky_insn.e1, -1);
3426       csky_insn.val[csky_insn.idx++] = 0;
3427       return TRUE;
3428     case OPRND_TYPE_LABEL_WITH_BRACKET:
3429     case OPRND_TYPE_CONSTANT:
3430     case OPRND_TYPE_ELRW_CONSTANT:
3431       if (**oper == '[')
3432         csky_insn.val[csky_insn.idx++] = 0;
3433       else
3434         csky_insn.val[csky_insn.idx++] = NEED_OUTPUT_LITERAL;
3435       *oper = parse_rt (*oper, 0, &csky_insn.e1, -1);
3436       return TRUE;
3437     case OPRND_TYPE_FCONSTANT:
3438       *oper = parse_rtf (*oper, 0, &csky_insn.e1);
3439       return TRUE;
3440
3441     case OPRND_TYPE_SFLOAT:
3442     case OPRND_TYPE_DFLOAT:
3443       /* For fmovis and fmovid, which accept a constant float with
3444          a limited range.  */
3445       {
3446         uint64_t dbnum;
3447         int imm4, imm8;
3448
3449         *oper = parse_fexp (*oper, &csky_insn.e1, 1, &dbnum);
3450         if (csky_insn.e1.X_op == O_absent)
3451           return FALSE;
3452
3453         /* Convert the representation from IEEE double to the 13-bit
3454            encoding used internally for fmovis and fmovid.  */
3455         imm4 = 11 - (((dbnum & 0x7ff0000000000000ULL) >> 52) - 1023);
3456         /* Check float range.  */
3457         if ((dbnum & 0x00000fffffffffffULL) || imm4 < 0 || imm4 > 15)
3458           {
3459             csky_show_error (ERROR_IMM_OVERFLOW, 2, NULL, NULL);
3460             return FALSE;
3461           }
3462         imm8 = (dbnum & 0x000ff00000000000ULL) >> 44;
3463         csky_insn.e1.X_add_number
3464           = (((imm8 & 0xf) << 4)
3465              | ((imm8 & 0xf0) << 17)
3466              | ((imm4 & 0xf) << 16)
3467              | ((dbnum & 0x8000000000000000ULL) >> 43));
3468         return TRUE;
3469       }
3470
3471       /* For grs v2.  */
3472     case OPRND_TYPE_IMM_OFF18b:
3473       *oper = parse_exp (*oper, &csky_insn.e1);
3474       return TRUE;
3475
3476     case OPRND_TYPE_BLOOP_OFF4b:
3477       *oper = parse_exp (*oper, &csky_insn.e2);
3478       if (csky_insn.e2.X_op == O_symbol)
3479         {
3480           csky_insn.opcode_end = *oper;
3481           return TRUE;
3482         }
3483       else
3484         return FALSE;
3485
3486     case OPRND_TYPE_BLOOP_OFF12b:
3487     case OPRND_TYPE_OFF10b:
3488     case OPRND_TYPE_OFF11b:
3489     case OPRND_TYPE_OFF16b_LSL1:
3490     case OPRND_TYPE_OFF26b:
3491       *oper = parse_exp (*oper, &csky_insn.e1);
3492       if (csky_insn.e1.X_op == O_symbol)
3493         {
3494           csky_insn.opcode_end = *oper;
3495           return TRUE;
3496         }
3497       else
3498         return FALSE;
3499       /* For xtrb0(1)(2)(3) and div in csky v1 ISA.  */
3500     case OPRND_TYPE_REG_r1a:
3501       {
3502         int reg = 0;
3503         int len = 0;
3504         reg = csky_get_reg_val (*oper, &len);
3505         if (reg == -1)
3506           {
3507             SET_ERROR_NUMBER (ERROR_REG_FORMAT,
3508                               "The first operand must be register r1.");
3509             return FALSE;
3510           }
3511         if (reg != 1)
3512           mov_r1_after = TRUE;
3513         *oper += len;
3514         csky_insn.opcode_end = *oper;
3515         csky_insn.val[csky_insn.idx++] = reg;
3516         return TRUE;
3517       }
3518     case OPRND_TYPE_REG_r1b:
3519       {
3520         int reg = 0;
3521         int len = 0;
3522         reg = csky_get_reg_val (*oper, &len);
3523         if (reg == -1)
3524           {
3525             SET_ERROR_NUMBER (ERROR_REG_FORMAT,
3526                               "The second operand must be register r1.");
3527             return FALSE;
3528           }
3529         if (reg != 1)
3530           {
3531             unsigned int mov_insn = CSKYV1_INST_MOV_R1_RX;
3532             mov_insn |= reg << 4;
3533             mov_r1_before = TRUE;
3534             csky_insn.output = frag_more (2);
3535             dwarf2_emit_insn (0);
3536             md_number_to_chars (csky_insn.output, mov_insn, 2);
3537           }
3538         *oper += len;
3539         csky_insn.opcode_end = *oper;
3540         csky_insn.val[csky_insn.idx++] = reg;
3541         return TRUE;
3542       }
3543     case OPRND_TYPE_DUMMY_REG:
3544       {
3545         int reg = 0;
3546         int len = 0;
3547         reg = csky_get_reg_val (*oper, &len);
3548         if (reg == -1)
3549           {
3550             SET_ERROR_NUMBER (ERROR_GREG_ILLEGAL, NULL);
3551             return FALSE;
3552           }
3553         if (reg != csky_insn.val[0])
3554           {
3555             SET_ERROR_NUMBER (ERROR_REG_FORMAT,
3556                               "The second register must be the same as the first.");
3557             return FALSE;
3558           }
3559         *oper += len;
3560         csky_insn.opcode_end = *oper;
3561         csky_insn.val[csky_insn.idx++] = reg;
3562         return TRUE;
3563       }
3564     case OPRND_TYPE_2IN1_DUMMY:
3565       {
3566         int reg = 0;
3567         int len = 0;
3568         int max = 0;
3569         int min = 0;
3570         reg = csky_get_reg_val (*oper, &len);
3571         if (reg == -1)
3572           {
3573             SET_ERROR_NUMBER (ERROR_GREG_ILLEGAL, NULL);
3574             return FALSE;
3575           }
3576         /* dummy reg's real type should be same with first operand.  */
3577         if (op->oprnd.oprnds[0].type == OPRND_TYPE_GREG0_15)
3578           max = 15;
3579         else if (op->oprnd.oprnds[0].type == OPRND_TYPE_GREG0_7)
3580           max = 7;
3581         else
3582           return FALSE;
3583         if (reg < min || reg > max)
3584           return FALSE;
3585         csky_insn.val[csky_insn.idx++] = reg;
3586         /* if it is the last operands.  */
3587         if (csky_insn.idx > 2)
3588           {
3589             /* For "insn rz, rx, ry", if rx or ry is equal to rz,
3590                we can output the insn like "insn rz, rx".  */
3591             if (csky_insn.val[0] ==  csky_insn.val[1])
3592               csky_insn.val[1] = 0;
3593             else if (csky_insn.val[0] ==  csky_insn.val[2])
3594               csky_insn.val[2] = 0;
3595             else
3596               return FALSE;
3597           }
3598         *oper += len;
3599         csky_insn.opcode_end = *oper;
3600         return TRUE;
3601       }
3602     case OPRND_TYPE_DUP_GREG0_7:
3603     case OPRND_TYPE_DUP_GREG0_15:
3604     case OPRND_TYPE_DUP_AREG:
3605       {
3606         long reg = 0;
3607         int len = 0;
3608         long max_reg;
3609         unsigned int shift_num;
3610         if (oprnd->type == OPRND_TYPE_DUP_GREG0_7)
3611           {
3612             max_reg = 7;
3613             shift_num = 3;
3614           }
3615         else if (oprnd->type == OPRND_TYPE_DUP_GREG0_15)
3616           {
3617             max_reg = 15;
3618             shift_num = 4;
3619           }
3620         else
3621           {
3622             max_reg = 31;
3623             shift_num = 5;
3624           }
3625         reg = csky_get_reg_val (*oper, &len);
3626         if (reg == -1)
3627           {
3628             if (max_reg == 31)
3629               SET_ERROR_NUMBER (ERROR_REG_FORMAT,
3630                                 "The register must be r0-r31");
3631             else
3632               SET_ERROR_NUMBER (ERROR_REG_FORMAT,
3633                                 "The register must be r0-r15");
3634             return FALSE;
3635           }
3636         if (reg > max_reg)
3637           {
3638             SET_ERROR_NUMBER (ERROR_REG_OVER_RANGE, reg);
3639             return FALSE;
3640           }
3641         reg |= reg << shift_num;
3642         *oper += len;
3643         csky_insn.opcode_end = *oper;
3644         csky_insn.val[csky_insn.idx++] = reg;
3645         return TRUE;
3646       }
3647     case OPRND_TYPE_CONST1:
3648       *oper = parse_exp (*oper, &csky_insn.e1);
3649       if (csky_insn.e1.X_op == O_constant)
3650         {
3651           csky_insn.opcode_end = *oper;
3652           if (csky_insn.e1.X_add_number != 1)
3653             return FALSE;
3654           csky_insn.val[csky_insn.idx++] = 1;
3655           return TRUE;
3656         }
3657       return FALSE;
3658     case OPRND_TYPE_UNCOND10b:
3659     case OPRND_TYPE_UNCOND16b:
3660       *oper = parse_exp (*oper, &csky_insn.e1);
3661       if (csky_insn.e1.X_op == O_constant)
3662         return FALSE;
3663       input_line_pointer = *oper;
3664       csky_insn.opcode_end = *oper;
3665       csky_insn.relax.max = UNCD_DISP16_LEN;
3666       csky_insn.relax.var = UNCD_DISP10_LEN;
3667       csky_insn.relax.subtype = UNCD_DISP10;
3668       csky_insn.val[csky_insn.idx++] = 0;
3669       return TRUE;
3670     case OPRND_TYPE_COND10b:
3671     case OPRND_TYPE_COND16b:
3672       *oper = parse_exp (*oper, &csky_insn.e1);
3673       if (csky_insn.e1.X_op == O_constant)
3674         return FALSE;
3675       input_line_pointer = *oper;
3676       csky_insn.opcode_end = *oper;
3677       /* CK801 doesn't have 32-bit bt/bf insns; relax to a short
3678          jump around a 32-bit unconditional branch instead.  */
3679       if (IS_CSKY_ARCH_801 (mach_flag))
3680         {
3681           csky_insn.relax.max = SCOND_DISP16_LEN;
3682           csky_insn.relax.var = SCOND_DISP10_LEN;
3683           csky_insn.relax.subtype = SCOND_DISP10;
3684         }
3685       else
3686         {
3687           csky_insn.relax.max = COND_DISP16_LEN;
3688           csky_insn.relax.var = COND_DISP10_LEN;
3689           csky_insn.relax.subtype = COND_DISP10;
3690         }
3691       csky_insn.val[csky_insn.idx++] = 0;
3692       return TRUE;
3693     case OPRND_TYPE_JCOMPZ:
3694       *oper = parse_exp (*oper, &csky_insn.e1);
3695       if (csky_insn.e1.X_op == O_constant)
3696         return FALSE;
3697       input_line_pointer = *oper;
3698       csky_insn.opcode_end = *oper;
3699       csky_insn.relax.max = JCOMPZ_DISP32_LEN;
3700       csky_insn.relax.var = JCOMPZ_DISP16_LEN;
3701       csky_insn.relax.subtype = JCOMPZ_DISP16;
3702       csky_insn.max = JCOMPZ_DISP32_LEN;
3703       csky_insn.val[csky_insn.idx++] = 0;
3704       return TRUE;
3705     case OPRND_TYPE_JBTF:
3706       *oper = parse_exp (*oper, &csky_insn.e1);
3707       input_line_pointer = *oper;
3708       csky_insn.opcode_end = *oper;
3709       csky_insn.relax.max = csky_relax_table[C (COND_JUMP_S, DISP32)].rlx_length;
3710       csky_insn.relax.var = csky_relax_table[C (COND_JUMP_S, DISP12)].rlx_length;
3711       csky_insn.relax.subtype = C (COND_JUMP_S, 0);
3712       csky_insn.val[csky_insn.idx++] = 0;
3713       csky_insn.max = C32_LEN_S + 2;
3714       return TRUE;
3715     case OPRND_TYPE_JBR:
3716       *oper = parse_exp (*oper, &csky_insn.e1);
3717       input_line_pointer = *oper;
3718       csky_insn.opcode_end = *oper;
3719       csky_insn.relax.max = csky_relax_table[C (UNCD_JUMP_S, DISP32)].rlx_length;
3720       csky_insn.relax.var = csky_relax_table[C (UNCD_JUMP_S, DISP12)].rlx_length;
3721       csky_insn.relax.subtype = C (UNCD_JUMP_S, 0);
3722       csky_insn.val[csky_insn.idx++] = 0;
3723       csky_insn.max = U32_LEN_S + 2;
3724       return TRUE;
3725     case OPRND_TYPE_JBSR:
3726       if (do_force2bsr)
3727         *oper = parse_exp (*oper, &csky_insn.e1);
3728       else
3729         *oper = parse_rt (*oper, 1, &csky_insn.e1, -1);
3730       input_line_pointer = *oper;
3731       csky_insn.opcode_end = *oper;
3732       csky_insn.val[csky_insn.idx++] = 0;
3733       return TRUE;
3734     case OPRND_TYPE_REGLIST_DASH_COMMA:
3735       return is_reglist_dash_comma_legal (oper, oprnd);
3736
3737     case OPRND_TYPE_MSB2SIZE:
3738     case OPRND_TYPE_LSB2SIZE:
3739       {
3740         expressionS e;
3741         char *new_oper = parse_exp (*oper, &e);
3742         if (e.X_op == O_constant)
3743           {
3744             *oper = new_oper;
3745             if (e.X_add_number > 31)
3746               {
3747                 SET_ERROR_NUMBER (ERROR_IMM_OVERFLOW, NULL);
3748                 return FALSE;
3749               }
3750             csky_insn.val[csky_insn.idx++] = e.X_add_number;
3751             if (oprnd->type == OPRND_TYPE_LSB2SIZE)
3752               {
3753                 if (csky_insn.val[csky_insn.idx - 1] > csky_insn.val[csky_insn.idx - 2])
3754                   {
3755                     SET_ERROR_NUMBER (ERROR_IMM_OVERFLOW, NULL);
3756                     return FALSE;
3757                   }
3758                 csky_insn.val[csky_insn.idx - 2] -= e.X_add_number;
3759               }
3760             return TRUE;
3761           }
3762         return FALSE;
3763       }
3764     case OPRND_TYPE_AREG_WITH_LSHIFT:
3765       return is_reg_lshift_illegal (oper, 0);
3766     case OPRND_TYPE_AREG_WITH_LSHIFT_FPU:
3767       return is_reg_lshift_illegal (oper, 1);
3768     case OPRND_TYPE_FREG_WITH_INDEX:
3769       if (parse_type_freg (oper, 0))
3770         {
3771           if (**oper == '[')
3772             {
3773               (*oper)++;
3774               if (is_imm_over_range (oper, 0, 0xf, -1))
3775                 {
3776                   if (**oper == ']')
3777                     {
3778                       unsigned int idx = --csky_insn.idx;
3779                       unsigned int val = csky_insn.val[idx];
3780                       (*oper)++;
3781                       csky_insn.val[idx - 1] |= val << 4;
3782                       return TRUE;
3783                     }
3784                   else
3785                     SET_ERROR_NUMBER (ERROR_MISSING_RSQUARE_BRACKETS, NULL);
3786                 }
3787             }
3788           else
3789             SET_ERROR_NUMBER (ERROR_MISSING_LSQUARE_BRACKETS, NULL);
3790         }
3791       return FALSE;
3792
3793     default:
3794       break;
3795       /* error code.  */
3796     }
3797   return FALSE;
3798 }
3799
3800 /* Subroutine of parse_operands.  */
3801
3802 static bfd_boolean
3803 parse_operands_op (char *str, struct csky_opcode_info *op)
3804 {
3805   int i;
3806   int j;
3807   char *oper = str;
3808   int flag_pass;
3809
3810   for (i = 0; i < OP_TABLE_NUM && op[i].operand_num != -2; i++)
3811     {
3812       flag_pass = TRUE;
3813       csky_insn.idx = 0;
3814       oper = str;
3815       /* if operand_num = -1, it is a insn with a REGLIST type operand.i.  */
3816       if (!(op[i].operand_num == csky_insn.number
3817             || (op[i].operand_num == -1 && csky_insn.number != 0)))
3818         {
3819           /* The smaller err_num is more serious.  */
3820           SET_ERROR_NUMBER (ERROR_OPERANDS_NUMBER, op[i].operand_num);
3821           flag_pass = FALSE;
3822           continue;
3823         }
3824
3825       for (j = 0; j < csky_insn.number; j++)
3826         {
3827           while (ISSPACE (*oper))
3828             oper++;
3829           flag_pass = get_operand_value (&op[i], &oper,
3830                                          &op[i].oprnd.oprnds[j]);
3831           if (flag_pass == FALSE)
3832             break;
3833           while (ISSPACE (*oper))
3834             oper++;
3835           /* Skip the ','.  */
3836           if (j < csky_insn.number - 1 && op[i].operand_num != -1)
3837             {
3838               if (*oper == ',')
3839                 oper++;
3840               else
3841                 {
3842                   SET_ERROR_NUMBER (ERROR_MISSING_COMMA, NULL);
3843                   flag_pass = FALSE;
3844                   break;
3845                 }
3846             }
3847           else if (!is_end_of_line[(unsigned char) *oper])
3848             {
3849               SET_ERROR_NUMBER (ERROR_BAD_END, NULL);
3850               flag_pass = FALSE;
3851               break;
3852             }
3853           else
3854             break;
3855         }
3856       /* Parse operands in one table end.  */
3857
3858       if (flag_pass == TRUE)
3859         {
3860           /* Parse operands success, set opcode_idx.  */
3861           csky_insn.opcode_idx = i;
3862           return TRUE;
3863         }
3864       else
3865         error_state.opnum = j + 1;
3866     }
3867   /* Parse operands in ALL tables end.  */
3868   return FALSE;
3869 }
3870
3871 /* Parse the operands according to operand type.  */
3872
3873 static bfd_boolean
3874 parse_operands (char *str)
3875 {
3876   char *oper = str;
3877
3878   /* Parse operands according to flag_force.  */
3879   if (csky_insn.flag_force == INSN_OPCODE16F
3880       && (csky_insn.opcode->isa_flag16 & isa_flag) != 0)
3881     {
3882       if (parse_operands_op (oper, csky_insn.opcode->op16) == TRUE)
3883         {
3884           csky_insn.isize = 2;
3885           return TRUE;
3886         }
3887       return FALSE;
3888     }
3889   else if (csky_insn.flag_force == INSN_OPCODE32F
3890            && (csky_insn.opcode->isa_flag32 & isa_flag) != 0)
3891     {
3892       if (parse_operands_op (oper, csky_insn.opcode->op32) == TRUE)
3893         {
3894           csky_insn.isize = 4;
3895           return TRUE;
3896         }
3897       return FALSE;
3898     }
3899   else
3900     {
3901       if ((csky_insn.opcode->isa_flag16 & isa_flag) != 0
3902           && parse_operands_op (oper, csky_insn.opcode->op16) == TRUE)
3903         {
3904           csky_insn.isize = 2;
3905           return TRUE;
3906         }
3907       if ((csky_insn.opcode->isa_flag32 & isa_flag) != 0
3908           && parse_operands_op (oper, csky_insn.opcode->op32) == TRUE)
3909         {
3910           csky_insn.isize = 4;
3911           return TRUE;
3912         }
3913       return FALSE;
3914     }
3915 }
3916
3917 static bfd_boolean
3918 csky_generate_frags (void)
3919 {
3920   /* frag more relax reloc.  */
3921   if (csky_insn.flag_force == INSN_OPCODE16F
3922       || !IS_SUPPORT_OPCODE32 (csky_insn.opcode))
3923     {
3924       csky_insn.output = frag_more (csky_insn.isize);
3925       if (csky_insn.opcode->reloc16)
3926         {
3927           /* 16 bits opcode force, should generate fixup.  */
3928           reloc_howto_type *howto;
3929           howto = bfd_reloc_type_lookup (stdoutput,
3930                                          csky_insn.opcode->reloc16);
3931           fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
3932                        2, &csky_insn.e1, howto->pc_relative,
3933                        csky_insn.opcode->reloc16);
3934         }
3935     }
3936   else if (csky_insn.flag_force == INSN_OPCODE32F)
3937     {
3938       csky_insn.output = frag_more (csky_insn.isize);
3939       if (csky_insn.opcode->reloc32)
3940         {
3941           reloc_howto_type *howto;
3942           howto = bfd_reloc_type_lookup (stdoutput,
3943                                          csky_insn.opcode->reloc32);
3944           fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
3945                        4, &csky_insn.e1, howto->pc_relative,
3946                        csky_insn.opcode->reloc32);
3947         }
3948     }
3949   else if (csky_insn.opcode->relax)
3950     /* Generate the relax information.  */
3951     csky_insn.output = frag_var (rs_machine_dependent,
3952                                  csky_insn.relax.max,
3953                                  csky_insn.relax.var,
3954                                  csky_insn.relax.subtype,
3955                                  csky_insn.e1.X_add_symbol,
3956                                  csky_insn.e1.X_add_number, 0);
3957   else
3958     {
3959       csky_insn.output = frag_more (csky_insn.isize);
3960       if (csky_insn.opcode->reloc16 && csky_insn.isize == 2)
3961         {
3962           reloc_howto_type *howto;
3963           howto = bfd_reloc_type_lookup (stdoutput,
3964                                          csky_insn.opcode->reloc16);
3965           fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
3966                        2, &csky_insn.e1, howto->pc_relative,
3967                        csky_insn.opcode->reloc16);
3968         }
3969       else if (csky_insn.opcode->reloc32 && csky_insn.isize == 4)
3970         {
3971           reloc_howto_type *howto;
3972           howto = bfd_reloc_type_lookup (stdoutput,
3973                                          csky_insn.opcode->reloc32);
3974           fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
3975                        4, &csky_insn.e1, howto->pc_relative,
3976                        csky_insn.opcode->reloc32);
3977         }
3978     }
3979   return TRUE;
3980 }
3981
3982 /* Return the bits of VAL shifted according to MASK.  The bits of MASK
3983    need not be contiguous.  */
3984
3985 static int
3986 generate_masked_value (int mask, int val)
3987 {
3988   int ret = 0;
3989   int bit;
3990
3991   for (bit = 1; mask; bit = bit << 1)
3992     if (mask & bit)
3993       {
3994         if (val & 0x1)
3995           ret |= bit;
3996         val = val >> 1;
3997         mask &= ~bit;
3998       }
3999   return ret;
4000 }
4001
4002 /* Return the result of masking operand number OPRND_IDX into the
4003    instruction word according to the information in OPRND.  */
4004
4005 static int
4006 generate_masked_operand (struct operand *oprnd, int *oprnd_idx)
4007 {
4008   struct soperand *soprnd = NULL;
4009   int mask;
4010   int val;
4011   if ((unsigned int)oprnd->mask == HAS_SUB_OPERAND)
4012     {
4013       soprnd = (struct soperand *) oprnd;
4014       generate_masked_operand (&soprnd->subs[0], oprnd_idx);
4015       generate_masked_operand (&soprnd->subs[1], oprnd_idx);
4016       return 0;
4017     }
4018   mask = oprnd->mask;
4019   val = csky_insn.val[*oprnd_idx];
4020   (*oprnd_idx)++;
4021   val = generate_masked_value (mask, val);
4022   csky_insn.inst |= val;
4023
4024   return 0;
4025 }
4026
4027 static bfd_boolean
4028 csky_generate_insn (void)
4029 {
4030   int i = 0;
4031   struct csky_opcode_info *opinfo = NULL;
4032
4033   if (csky_insn.isize == 4)
4034     opinfo = &csky_insn.opcode->op32[csky_insn.opcode_idx];
4035   else if (csky_insn.isize == 2)
4036     opinfo = &csky_insn.opcode->op16[csky_insn.opcode_idx];
4037
4038   int sidx = 0;
4039   csky_insn.inst = opinfo->opcode;
4040   if (opinfo->operand_num == -1)
4041     {
4042       generate_masked_operand (&opinfo->oprnd.oprnds[i], &sidx);
4043       return 0;
4044     }
4045   else
4046     for (i = 0; i < opinfo->operand_num; i++)
4047       generate_masked_operand (&opinfo->oprnd.oprnds[i], &sidx);
4048   return 0;
4049 }
4050
4051 /* Main entry point for assembling a single instruction.  */
4052
4053 void
4054 md_assemble (char *str)
4055 {
4056   bfd_boolean must_check_literals = TRUE;
4057   csky_insn.isize = 0;
4058   csky_insn.idx = 0;
4059   csky_insn.max = 0;
4060   csky_insn.flag_force = INSN_OPCODE;
4061   csky_insn.macro = NULL;
4062   csky_insn.opcode = NULL;
4063   memset (csky_insn.val, 0, sizeof (int) * MAX_OPRND_NUM);
4064   /* Initialize err_num.  */
4065   error_state.err_num = ERROR_NONE;
4066   mov_r1_before = FALSE;
4067   mov_r1_after = FALSE;
4068
4069   mapping_state (MAP_TEXT);
4070   /* Tie dwarf2 debug info to every insn if set option --gdwarf2.  */
4071   dwarf2_emit_insn (0);
4072   while (ISSPACE (* str))
4073     str++;
4074   /* Get opcode from str.  */
4075   if (parse_opcode (str) == FALSE)
4076     {
4077       csky_show_error (ERROR_OPCODE_ILLEGAL, 0, NULL, NULL);
4078       return;
4079     }
4080
4081   /* If it is a macro instruction, handle it.  */
4082   if (csky_insn.macro != NULL)
4083     {
4084       if (csky_insn.number == csky_insn.macro->oprnd_num)
4085         {
4086           csky_insn.macro->handle_func ();
4087           return;
4088         }
4089       else if (error_state.err_num > ERROR_OPERANDS_NUMBER)
4090         SET_ERROR_NUMBER (ERROR_OPERANDS_NUMBER, csky_insn.macro->oprnd_num);
4091     }
4092
4093   if (csky_insn.opcode == NULL)
4094     {
4095       SET_ERROR_NUMBER (ERROR_OPCODE_ILLEGAL, NULL);
4096       csky_show_error (error_state.err_num, error_state.opnum,
4097                        (void *)error_state.arg1, (void *)error_state.arg1);
4098       return;
4099     }
4100
4101   /* Parse the operands according to operand type.  */
4102   if (parse_operands (csky_insn.opcode_end) == FALSE)
4103     {
4104       csky_show_error (error_state.err_num, error_state.opnum,
4105                        (void *)error_state.arg1, (void *)error_state.arg1);
4106       return;
4107     }
4108
4109   /* if this insn has work in opcode table, then do it.  */
4110   if (csky_insn.opcode->work != NULL)
4111       must_check_literals = csky_insn.opcode->work ();
4112   else
4113     {
4114       /* Generate relax or reloc if necessary.  */
4115       csky_generate_frags ();
4116       /* Generate the insn by mask.  */
4117       csky_generate_insn ();
4118       /* Write inst to frag.  */
4119       csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
4120     }
4121
4122   /* Adjust for xtrb0/xtrb1/xtrb2/xtrb3/divs/divu in csky v1 ISA.  */
4123   if (mov_r1_after == TRUE)
4124     {
4125       unsigned int mov_insn = CSKYV1_INST_MOV_RX_R1;
4126       mov_insn |= csky_insn.val[0];
4127       mov_r1_before = TRUE;
4128       csky_insn.output = frag_more (2);
4129       dwarf2_emit_insn (0);
4130       md_number_to_chars (csky_insn.output, mov_insn, 2);
4131       csky_insn.isize += 2;
4132     }
4133   if (mov_r1_before == TRUE)
4134     csky_insn.isize += 2;
4135
4136   /* Check literal.  */
4137   if (must_check_literals)
4138     {
4139       if (csky_insn.max == 0)
4140         check_literals (csky_insn.opcode->transfer, csky_insn.isize);
4141       else
4142         check_literals (csky_insn.opcode->transfer, csky_insn.max);
4143     }
4144
4145   insn_reloc = BFD_RELOC_NONE;
4146 }
4147
4148 /* Attempt to handle option with value C, returning non-zero on success.  */
4149
4150 int
4151 md_parse_option (int c, const char *arg)
4152 {
4153   switch (c)
4154     {
4155     case 0:
4156       break;
4157     case OPTION_MARCH:
4158       parse_arch (arg);
4159       break;
4160     case OPTION_MCPU:
4161       parse_cpu (arg);
4162       break;
4163     default:
4164       return 0;
4165     }
4166   return 1;
4167 }
4168
4169 /* Convert a machine dependent frag.  */
4170 #define PAD_LITERAL_LENGTH                        6
4171 #define opposite_of_stored_comp(insn)             (insn ^ 0x04000000)
4172 #define opposite_of_stored_compz(insn)            (insn ^ 0x00200000)
4173 #define make_insn(total_length, opcode, operand, operand_length)        \
4174   do {                                                                  \
4175     if (total_length > 0)                                               \
4176       {                                                                 \
4177         csky_write_insn (buf,                                           \
4178                          opcode | (operand & ((1 << operand_length) - 1)), \
4179                          total_length);                                 \
4180         buf += total_length;                                            \
4181         fragp->fr_fix += total_length;                                  \
4182       }                                                                 \
4183   } while (0)
4184
4185 #define make_literal(fragp, literal_offset)                             \
4186   do {                                                                  \
4187     make_insn (literal_offset, PAD_FILL_CONTENT, 0, 0);                 \
4188     fix_new (fragp, fragp->fr_fix, 4, fragp->fr_symbol,                 \
4189              fragp->fr_offset, 0, BFD_RELOC_CKCORE_ADDR32);             \
4190     make_insn (4, 0, 0, 0);                                             \
4191     make_insn (2 - literal_offset, PAD_FILL_CONTENT, 0, 0);             \
4192   } while (0)
4193
4194 void
4195 md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED, segT asec,  fragS *fragp)
4196 {
4197   offsetT disp;
4198   char *buf = fragp->fr_fix + fragp->fr_literal;
4199
4200   gas_assert (fragp->fr_symbol);
4201   if (IS_EXTERNAL_SYM (fragp->fr_symbol, asec))
4202     disp = 0;
4203   else
4204     disp = (S_GET_VALUE (fragp->fr_symbol)
4205             + fragp->fr_offset
4206             - fragp->fr_address
4207             - fragp->fr_fix);
4208
4209   switch (fragp->fr_subtype)
4210     {
4211       /* generate new insn.  */
4212     case C (COND_JUMP, DISP12):
4213     case C (UNCD_JUMP, DISP12):
4214     case C (COND_JUMP_PIC, DISP12):
4215     case C (UNCD_JUMP_PIC, DISP12):
4216       {
4217 #define CSKY_V1_B_MASK   0xf8
4218         unsigned char t0;
4219         disp -= 2;
4220         if (disp & 1)
4221           {
4222             /* Error. odd displacement at %x, next_inst-2.  */
4223             ;
4224           }
4225         disp >>= 1;
4226
4227         if (!target_big_endian)
4228           {
4229             t0 = buf[1] & CSKY_V1_B_MASK;
4230             md_number_to_chars (buf, disp, 2);
4231             buf[1] = (buf[1] & ~CSKY_V1_B_MASK) | t0;
4232           }
4233         else
4234           {
4235             t0 = buf[0] & CSKY_V1_B_MASK;
4236             md_number_to_chars (buf, disp, 2);
4237             buf[0] = (buf[0] & ~CSKY_V1_B_MASK) | t0;
4238           }
4239         fragp->fr_fix += 2;
4240         break;
4241       }
4242     case C (COND_JUMP, DISP32):
4243     case C (COND_JUMP, UNDEF_WORD_DISP):
4244       {
4245         /* A conditional branch wont fit into 12 bits:
4246            b!cond 1f
4247            jmpi 0f
4248            .align 2
4249            0: .long disp
4250            1:
4251         */
4252         int first_inst = fragp->fr_fix + fragp->fr_address;
4253         int is_unaligned = (first_inst & 3);
4254
4255         if (!target_big_endian)
4256           {
4257             /* b!cond instruction.  */
4258             buf[1] ^= 0x08;
4259             /* jmpi instruction.  */
4260             buf[2] = CSKYV1_INST_JMPI & 0xff;
4261             buf[3] = CSKYV1_INST_JMPI >> 8;
4262           }
4263         else
4264           {
4265             /* b!cond instruction.  */
4266             buf[0] ^= 0x08;
4267             /* jmpi instruction.  */
4268             buf[2] = CSKYV1_INST_JMPI >> 8;
4269             buf[3] = CSKYV1_INST_JMPI & 0xff;
4270           }
4271
4272         if (is_unaligned)
4273           {
4274             if (!target_big_endian)
4275               {
4276                 /* bt/bf: jump to pc + 2 + (4 << 1).  */
4277                 buf[0] = 4;
4278                 /* jmpi: jump to MEM (pc + 2 + (1 << 2)).  */
4279                 buf[2] = 1;
4280               }
4281             else
4282               {
4283                 /* bt/bf: jump to pc + 2 + (4 << 1).  */
4284                 buf[1] = 4;
4285                 /* jmpi: jump to MEM (pc + 2 + (1 << 2)).  */
4286                 buf[3] = 1;
4287               }
4288             /* Aligned 4 bytes.  */
4289             buf[4] = 0;
4290             buf[5] = 0;
4291             /* .long  */
4292             buf[6] = 0;
4293             buf[7] = 0;
4294             buf[8] = 0;
4295             buf[9] = 0;
4296
4297             /* Make reloc for the long disp.  */
4298             fix_new (fragp, fragp->fr_fix + 6, 4,
4299                      fragp->fr_symbol, fragp->fr_offset, 0, BFD_RELOC_32);
4300             fragp->fr_fix += C32_LEN;
4301           }
4302         else
4303           {
4304             if (!target_big_endian)
4305               {
4306                 /* bt/bf: jump to pc + 2 + (3 << 1).  */
4307                 buf[0] = 3;
4308                 /* jmpi: jump to MEM (pc + 2 + (0 << 2)).  */
4309                 buf[2] = 0;
4310               }
4311             else
4312               {
4313                 /* bt/bf: jump to pc + 2 + (3 << 1).  */
4314                 buf[1] = 3;
4315                 /* jmpi: jump to MEM (pc + 2 + (0 << 2)).  */
4316                 buf[3] = 0;
4317               }
4318             /* .long  */
4319             buf[4] = 0;
4320             buf[5] = 0;
4321             buf[6] = 0;
4322             buf[7] = 0;
4323
4324             /* Make reloc for the long disp.  */
4325             fix_new (fragp, fragp->fr_fix + 4, 4,
4326                      fragp->fr_symbol, fragp->fr_offset, 0, BFD_RELOC_32);
4327             fragp->fr_fix += C32_LEN;
4328
4329             /* Frag is actually shorter (see the other side of this ifdef)
4330                but gas isn't prepared for that.  We have to re-adjust
4331                the branch displacement so that it goes beyond the
4332                full length of the fragment, not just what we actually
4333                filled in.  */
4334             if (!target_big_endian)
4335               buf[0] = 4;
4336             else
4337               buf[1] = 4;
4338           }
4339       }
4340       break;
4341
4342     case C (COND_JUMP_PIC, DISP32):
4343     case C (COND_JUMP_PIC, UNDEF_WORD_DISP):
4344       {
4345 #define BYTE_1(a) (target_big_endian ? ((a) & 0xff) : ((a) >> 8))
4346 #define BYTE_0(a) (target_big_endian ? ((a) >> 8) : ((a) & 0xff))
4347         /* b!cond 1f
4348            subi sp, 8
4349            stw  r15, (sp, 0)
4350            bsr  .L0
4351            .L0:
4352            lrw r1, 0f
4353            add r1, r15
4354            addi sp, 8
4355            jmp r1
4356            .align 2
4357            0: .long (tar_addr - pc)
4358            1:
4359         */
4360         int first_inst = fragp->fr_fix + fragp->fr_address;
4361         int is_unaligned = (first_inst & 3);
4362         disp -= 8;
4363         /* Toggle T/F bit.  */
4364         if (! target_big_endian)
4365           buf[1] ^= 0x08;
4366         else
4367           buf[0] ^= 0x08;
4368         buf[2] = BYTE_0 (CSKYV1_INST_SUBI | (7 << 4));     /* subi r0, 8.  */
4369         buf[3] = BYTE_1 (CSKYV1_INST_SUBI | (7 << 4));
4370         buf[4] = BYTE_0 (CSKYV1_INST_STW  | (15 << 8));    /* stw r15, r0.  */
4371         buf[5] = BYTE_1 (CSKYV1_INST_STW  | (15 << 8));
4372         buf[6] = BYTE_0 (CSKYV1_INST_BSR);                 /* bsr pc + 2.  */
4373         buf[7] = BYTE_1 (CSKYV1_INST_BSR);
4374         buf[8] = BYTE_0 (CSKYV1_INST_LRW | (1 << 8));      /* lrw r1, (tar_addr - pc).  */
4375         buf[9] = BYTE_1 (CSKYV1_INST_LRW | (1 << 8));
4376         buf[10] = BYTE_0 (CSKYV1_INST_ADDU | (15 << 4) | 1);  /* add r1, r15.  */
4377         buf[11] = BYTE_1 (CSKYV1_INST_ADDU | (15 << 4) | 1);
4378         buf[12] = BYTE_0 (CSKYV1_INST_LDW | (15 << 8));     /* ldw r15, r0.  */
4379         buf[13] = BYTE_1 (CSKYV1_INST_LDW | (15 << 8));
4380         buf[14] = BYTE_0 (CSKYV1_INST_ADDI | (7 << 4));     /* addi r0, 8.  */
4381         buf[15] = BYTE_1 (CSKYV1_INST_ADDI | (7 << 4));
4382         buf[16] = BYTE_0 (CSKYV1_INST_JMP | 1);             /* jmp r1.  */
4383         buf[17] = BYTE_1 (CSKYV1_INST_JMP | 1);
4384
4385         if (!is_unaligned)
4386           {
4387             if (!target_big_endian)
4388               {
4389                 buf[0] = 11;
4390                 buf[8] = 3;
4391                 buf[20] = disp & 0xff;
4392                 buf[21] = (disp >> 8) & 0xff;
4393                 buf[22] = (disp >> 16) & 0xff;
4394                 buf[23] = (disp >> 24) & 0xff;
4395               }
4396             else /* if !target_big_endian.  */
4397               {
4398                 buf[1] = 11;
4399                 buf[9] = 3;
4400                 buf[20] = (disp >> 24) & 0xff;
4401                 buf[21] = (disp >> 16) & 0xff;
4402                 buf[22] = (disp >> 8) & 0xff;
4403                 buf[23] = disp & 0xff;
4404               }
4405             buf[18] = 0;  /* alignment.  */
4406             buf[19] = 0;
4407             fragp->fr_fix += C32_LEN_PIC;
4408           }
4409         else  /* if !is_unaligned.  */
4410           {
4411             if (!target_big_endian)
4412               {
4413                 buf[0] = 11;
4414                 buf[8] = 2;
4415                 buf[18] = disp & 0xff;
4416                 buf[19] = (disp >> 8) & 0xff;
4417                 buf[20] = (disp >> 16) & 0xff;
4418                 buf[21] = (disp >> 24) & 0xff;
4419               }
4420             else /* if !target_big_endian.  */
4421               {
4422                 buf[1] = 11;
4423                 buf[9] = 2;
4424                 buf[18] = (disp >> 24) & 0xff;
4425                 buf[19] = (disp >> 16) & 0xff;
4426                 buf[20] = (disp >> 8) & 0xff;
4427                 buf[21] = disp & 0xff;
4428               }
4429             buf[22] = 0;  /* initialise.  */
4430             buf[23] = 0;
4431             fragp->fr_fix += C32_LEN_PIC;
4432
4433           } /* end if is_unaligned.  */
4434       } /* end case C (COND_JUMP_PIC, DISP32)/C (COND_JUMP_PIC, UNDEF_WORD_DISP).  */
4435       break;
4436     case C (UNCD_JUMP, DISP32):
4437     case C (UNCD_JUMP, UNDEF_WORD_DISP):
4438       {
4439         /* jmpi 0f
4440            .align 2
4441            0: .long disp.  */
4442         int first_inst = fragp->fr_fix + fragp->fr_address;
4443         int is_unaligned = (first_inst & 3);
4444         /* Build jmpi.  */
4445         buf[0] = BYTE_0 (CSKYV1_INST_JMPI);
4446         buf[1] = BYTE_1 (CSKYV1_INST_JMPI);
4447         if (!is_unaligned)
4448           {
4449             if (!target_big_endian)
4450               buf[0] = 1;
4451             else
4452               buf[1] = 1;
4453             /* Alignment.  */
4454             buf[2] = 0;
4455             buf[3] = 0;
4456             /* .long  */
4457             buf[4] = 0;
4458             buf[5] = 0;
4459             buf[6] = 0;
4460             buf[7] = 0;
4461             fix_new (fragp, fragp->fr_fix + 4, 4,
4462                      fragp->fr_symbol, fragp->fr_offset, 0, BFD_RELOC_32);
4463             fragp->fr_fix += U32_LEN;
4464           }
4465         else /* if is_unaligned.  */
4466           {
4467             if (!target_big_endian)
4468               buf[0] = 0;
4469             else
4470               buf[1] = 0;
4471             /* .long  */
4472             buf[2] = 0;
4473             buf[3] = 0;
4474             buf[4] = 0;
4475             buf[5] = 0;
4476             fix_new (fragp, fragp->fr_fix + 2, 4,
4477                      fragp->fr_symbol, fragp->fr_offset, 0, BFD_RELOC_32);
4478             fragp->fr_fix += U32_LEN;
4479
4480           }
4481       }
4482       break;
4483     case C (UNCD_JUMP_PIC, DISP32):
4484     case C (UNCD_JUMP_PIC, UNDEF_WORD_DISP):
4485       {
4486         /*    subi sp, 8
4487               stw  r15, (sp)
4488               bsr  .L0
4489               .L0:
4490               lrw  r1, 0f
4491               add  r1, r15
4492               ldw  r15, (sp)
4493               addi sp, 8
4494               jmp r1
4495               .align 2
4496               0: .long (tar_add - pc)
4497               1:
4498         */
4499         /* If the b!cond is 4 byte aligned, the literal which would
4500            go at x+4 will also be aligned.  */
4501         int first_inst = fragp->fr_fix + fragp->fr_address;
4502         int is_unaligned = (first_inst & 3);
4503         disp -= 6;
4504
4505         buf[0] = BYTE_0 (CSKYV1_INST_SUBI | (7 << 4));     /* subi r0, 8.  */
4506         buf[1] = BYTE_1 (CSKYV1_INST_SUBI | (7 << 4));
4507         buf[2] = BYTE_0 (CSKYV1_INST_STW  | (15 << 8));    /* stw r15, r0.  */
4508         buf[3] = BYTE_1 (CSKYV1_INST_STW  | (15 << 8));
4509         buf[4] = BYTE_0 (CSKYV1_INST_BSR);                 /* bsr pc + 2.  */
4510         buf[5] = BYTE_1 (CSKYV1_INST_BSR);
4511         buf[6] = BYTE_0 (CSKYV1_INST_LRW | (1 << 8));      /* lrw r1, (tar_addr - pc).  */
4512         buf[7] = BYTE_1 (CSKYV1_INST_LRW | (1 << 8));
4513         buf[8] = BYTE_0 (CSKYV1_INST_ADDU | (15 << 4) | 1);  /* add r1, r15.  */
4514         buf[9] = BYTE_1 (CSKYV1_INST_ADDU | (15 << 4) | 1);
4515         buf[10] = BYTE_0 (CSKYV1_INST_LDW | (15 << 8));     /* ldw r15, r0.  */
4516         buf[11] = BYTE_1 (CSKYV1_INST_LDW | (15 << 8));
4517         buf[12] = BYTE_0 (CSKYV1_INST_ADDI | (7 << 4));     /* addi r0, 8.  */
4518         buf[13] = BYTE_1 (CSKYV1_INST_ADDI | (7 << 4));
4519         buf[14] = BYTE_0 (CSKYV1_INST_JMP | 1);             /* jmp r1.  */
4520         buf[15] = BYTE_1 (CSKYV1_INST_JMP | 1);
4521
4522         if (is_unaligned)
4523           {
4524             if (!target_big_endian)
4525               {
4526                 buf[6] = 3;
4527                 buf[18] = disp & 0xff;
4528                 buf[19] = (disp >> 8) & 0xff;
4529                 buf[20] = (disp >> 16) & 0xff;
4530                 buf[21] = (disp >> 24) & 0xff;
4531               }
4532             else
4533               {
4534                 buf[7] = 3;
4535                 buf[18] = (disp >> 24) & 0xff;
4536                 buf[19] = (disp >> 16) & 0xff;
4537                 buf[20] = (disp >> 8) & 0xff;
4538                 buf[21] = disp & 0xff;
4539               }
4540             buf[16] = 0;
4541             buf[17] = 0;
4542             fragp->fr_fix += U32_LEN_PIC;
4543           }
4544         else
4545           {
4546             if (!target_big_endian)
4547               {
4548                 buf[6] = 2;
4549                 buf[16] = disp & 0xff;
4550                 buf[17] = (disp >> 8) & 0xff;
4551                 buf[18] = (disp >> 16) & 0xff;
4552                 buf[19] = (disp >> 24) & 0xff;
4553               }
4554             else
4555               {
4556                 buf[7] = 2;
4557                 buf[16] = (disp >> 24) & 0xff;
4558                 buf[17] = (disp >> 16) & 0xff;
4559                 buf[18] = (disp >> 8) & 0xff;
4560                 buf[19] = disp & 0xff;
4561               }
4562             fragp->fr_fix += U32_LEN_PIC;
4563           }
4564       }
4565       break;
4566     case COND_DISP10:
4567     case SCOND_DISP10:
4568     case UNCD_DISP10:
4569     case JCOND_DISP10:
4570     case JUNCD_DISP10:
4571       {
4572         unsigned int inst = csky_read_insn (buf, 2);
4573         inst |= (disp >> 1) & ((1 << 10) - 1);
4574         csky_write_insn (buf, inst, 2);
4575         fragp->fr_fix += 2;
4576         break;
4577       }
4578     case SCOND_DISP16:
4579       {
4580         unsigned int inst = csky_read_insn (buf, 2);
4581
4582         if (inst == CSKYV2_INST_BT16)
4583           inst = CSKYV2_INST_BF16;
4584         else
4585           inst = CSKYV2_INST_BT16;
4586         make_insn (2, inst, (2 + 4) >> 1, 10);
4587         if (IS_EXTERNAL_SYM (fragp->fr_symbol, asec))
4588           fix_new (fragp, fragp->fr_fix, 4,
4589                    fragp->fr_symbol, fragp->fr_offset, 1,
4590                    BFD_RELOC_CKCORE_PCREL_IMM16BY2);
4591         disp -= 2;
4592         inst = CSKYV2_INST_BR32 | ((disp >> 1) & ((1 << 16) - 1));
4593         csky_write_insn (buf, inst, 4);
4594         fragp->fr_fix += 4;
4595         break;
4596       }
4597     case COND_DISP16:
4598     case JCOND_DISP16:
4599       {
4600         unsigned int inst = csky_read_insn (buf, 2);
4601
4602         if (inst == CSKYV2_INST_BT16)
4603           inst = CSKYV2_INST_BT32;
4604         else
4605           inst = CSKYV2_INST_BF32;
4606         if (IS_EXTERNAL_SYM (fragp->fr_symbol, asec))
4607           fix_new (fragp, fragp->fr_fix, 4,
4608                    fragp->fr_symbol, fragp->fr_offset, 1,
4609                    BFD_RELOC_CKCORE_PCREL_IMM16BY2);
4610         inst |= (disp >> 1) & ((1 << 16) - 1);
4611         csky_write_insn (buf, inst, 4);
4612         fragp->fr_fix += 4;
4613         break;
4614       }
4615     case LRW_DISP7:
4616       {
4617         unsigned int inst = csky_read_insn (buf, 2);
4618         int imm;
4619         imm = (disp + 2) >> 2;
4620         inst |= (imm >> 5) << 8;
4621         make_insn (2, inst, (imm & 0x1f), 5);
4622         break;
4623       }
4624     case LRW2_DISP8:
4625       {
4626         unsigned int inst = csky_read_insn (buf, 2);
4627         int imm = (disp + 2) >> 2;
4628         if (imm >= 0x80)
4629           {
4630             inst &= 0xe0;
4631             inst |= (~((imm >> 5) << 8)) & 0x300;
4632             make_insn (2, inst, (~imm & 0x1f), 5);
4633           }
4634         else
4635           {
4636             inst |= (imm >> 5) << 8;
4637             make_insn (2, inst, (imm & 0x1f), 5);
4638           }
4639         break;
4640       }
4641     case LRW_DISP16:
4642       {
4643         unsigned int inst = csky_read_insn (buf, 2);
4644         inst = CSKYV2_INST_LRW32 | (((inst & 0xe0) >> 5) << 16);
4645         if (IS_EXTERNAL_SYM (fragp->fr_symbol, asec))
4646           fix_new (fragp, fragp->fr_fix, 4,
4647                    fragp->fr_symbol, fragp->fr_offset, 1,
4648                    BFD_RELOC_CKCORE_PCREL_IMM16BY4);
4649         make_insn (4, inst, ((disp + 2) >> 2), 16);
4650         break;
4651       }
4652     case JCOMPZ_DISP16:
4653       {
4654         unsigned int inst = csky_read_insn (buf, 4);
4655         make_insn (4, inst, disp >> 1, 16);
4656       }
4657       break;
4658     case JCOMPZ_DISP32:
4659       {
4660         unsigned int inst = csky_read_insn (buf, 4);
4661         int literal_offset;
4662         make_insn (4, opposite_of_stored_compz (inst),
4663                    (4 + 4 + PAD_LITERAL_LENGTH) >> 1, 16);
4664         literal_offset = ((fragp->fr_address + fragp->fr_fix) % 4 == 0
4665                           ? 0 : 2);
4666         make_insn (4, CSKYV2_INST_JMPI32, (4 + literal_offset + 2) >> 2, 10);
4667         make_literal (fragp, literal_offset);
4668       }
4669       break;
4670     case JUNCD_DISP16:
4671     case UNCD_DISP16:
4672       {
4673         if (IS_EXTERNAL_SYM (fragp->fr_symbol, asec))
4674           fix_new (fragp, fragp->fr_fix, 4,
4675                    fragp->fr_symbol, fragp->fr_offset, 1,
4676                    BFD_RELOC_CKCORE_PCREL_IMM16BY2);
4677         make_insn (4, CSKYV2_INST_BR32, disp >> 1, 16);
4678       }
4679       break;
4680     case JCOND_DISP32:
4681       {
4682         /* 'jbt'/'jbf'-> <bf16/bt16>; jmpi32; [pad16]+literal32  */
4683         unsigned int inst = csky_read_insn (buf, 2);
4684         int literal_offset;
4685
4686         if (inst == CSKYV2_INST_BT16)
4687           inst = CSKYV2_INST_BF16;
4688         else
4689           inst = CSKYV2_INST_BT16;
4690         make_insn (2, inst, (2 + 4 + PAD_LITERAL_LENGTH) >> 1, 10);
4691         literal_offset = ((fragp->fr_address + fragp->fr_fix) % 4 == 0
4692                           ? 0 : 2);
4693         make_insn (4, CSKYV2_INST_JMPI32, (4 + literal_offset + 2) >> 2, 10);
4694         make_literal (fragp, literal_offset);
4695         break;
4696       }
4697     case JUNCD_DISP32:
4698       {
4699         int literal_offset;
4700         literal_offset = ((fragp->fr_address + fragp->fr_fix) % 4 == 0
4701                           ? 0 : 2);
4702         make_insn (4, CSKYV2_INST_JMPI32, (4 + literal_offset + 2) >> 2, 10);
4703         make_literal (fragp, literal_offset);
4704       }
4705       break;
4706     case RELAX_OVERFLOW:
4707       csky_branch_report_error (fragp->fr_file, fragp->fr_line,
4708                                 fragp->fr_symbol, disp);
4709       break;
4710     default:
4711       abort ();
4712       break;
4713     }
4714 }
4715
4716 /* Round up a section size to the appropriate boundary.  */
4717
4718 valueT
4719 md_section_align (segT segment ATTRIBUTE_UNUSED,
4720                   valueT size)
4721 {
4722   return size;
4723 }
4724
4725 /* MD interface: Symbol and relocation handling.  */
4726
4727 void md_csky_end (void)
4728 {
4729   dump_literals (0);
4730 }
4731
4732 /* Return the address within the segment that a PC-relative fixup is
4733    relative to.  */
4734
4735 long
4736 md_pcrel_from_section (fixS * fixP, segT seg)
4737 {
4738   /* If the symbol is undefined or defined in another section
4739      we leave the add number alone for the linker to fix it later.  */
4740   if (fixP->fx_addsy != (symbolS *) NULL
4741       && (! S_IS_DEFINED (fixP->fx_addsy)
4742           || S_GET_SEGMENT (fixP->fx_addsy) != seg))
4743     return fixP->fx_size;
4744
4745   /* The case where we are going to resolve things.  */
4746   return  fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address;
4747 }
4748
4749 /* csky_cons_fix_new is called via the expression parsing code when a
4750    reloc is needed.  We use this hook to get the correct .got reloc.  */
4751
4752 void
4753 csky_cons_fix_new (fragS *frag,
4754                    unsigned int off,
4755                    unsigned int len,
4756                    expressionS *exp,
4757                    bfd_reloc_code_real_type reloc)
4758 {
4759   fixS *fixP;
4760
4761   if (BFD_RELOC_CKCORE_GOTOFF == insn_reloc
4762       || BFD_RELOC_CKCORE_GOTPC == insn_reloc
4763       || BFD_RELOC_CKCORE_GOT32 == insn_reloc
4764       || BFD_RELOC_CKCORE_PLT32 == insn_reloc
4765       || BFD_RELOC_CKCORE_TLS_LE32 == insn_reloc
4766       || BFD_RELOC_CKCORE_TLS_GD32 == insn_reloc
4767       || BFD_RELOC_CKCORE_TLS_LDM32 == insn_reloc
4768       || BFD_RELOC_CKCORE_TLS_LDO32 == insn_reloc
4769       || BFD_RELOC_CKCORE_TLS_IE32 == insn_reloc)
4770     reloc = insn_reloc;
4771   else
4772     switch (len)
4773       {
4774       case 1:
4775         reloc = BFD_RELOC_8;
4776         break;
4777       case 2:
4778         reloc = BFD_RELOC_16;
4779         break;
4780       case 4:
4781         reloc = BFD_RELOC_32;
4782         break;
4783       case 8:
4784         reloc = BFD_RELOC_64;
4785         break;
4786       default:
4787         as_bad (_("unsupported BFD relocation size %d"), len);
4788         reloc = BFD_RELOC_32;
4789         break;
4790       }
4791   fixP = fix_new_exp (frag, off, (int) len, exp, 0, reloc);
4792   if (BFD_RELOC_CKCORE_TLS_IE32 == insn_reloc
4793       || BFD_RELOC_CKCORE_TLS_GD32 == insn_reloc
4794       || BFD_RELOC_CKCORE_TLS_LDM32 == insn_reloc)
4795     {
4796       fixP->tc_fix_data.frag = literal_insn_offset->tls_addend.frag;
4797       fixP->tc_fix_data.offset = literal_insn_offset->tls_addend.offset;
4798     }
4799 }
4800
4801 /* See whether we need to force a relocation into the output file.
4802    This is used to force out switch and PC relative relocations when
4803    relaxing.  */
4804
4805 int
4806 csky_force_relocation (fixS * fix)
4807 {
4808   if (fix->fx_r_type == BFD_RELOC_VTABLE_INHERIT
4809       || fix->fx_r_type == BFD_RELOC_VTABLE_ENTRY
4810       || fix->fx_r_type == BFD_RELOC_RVA
4811       || fix->fx_r_type == BFD_RELOC_CKCORE_ADDR_HI16
4812       || fix->fx_r_type == BFD_RELOC_CKCORE_ADDR_LO16
4813       || fix->fx_r_type == BFD_RELOC_CKCORE_TOFFSET_LO16
4814       || fix->fx_r_type == BFD_RELOC_CKCORE_DOFFSET_LO16)
4815     return 1;
4816
4817   if (fix->fx_addsy == NULL)
4818     return 0;
4819
4820   if (do_use_branchstub
4821       && fix->fx_r_type == BFD_RELOC_CKCORE_PCREL_IMM26BY2
4822       && (symbol_get_bfdsym (fix->fx_addsy)->flags & BSF_FUNCTION))
4823     return 1;
4824   return S_FORCE_RELOC (fix->fx_addsy, fix->fx_subsy == NULL);
4825 }
4826
4827 /* Return true if the fix can be handled by GAS, false if it must
4828    be passed through to the linker.  */
4829
4830 bfd_boolean
4831 csky_fix_adjustable (fixS * fixP)
4832 {
4833   if (fixP->fx_addsy == NULL)
4834     return 1;
4835
4836   /* We need the symbol name for the VTABLE entries.  */
4837   if (fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
4838       || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY
4839       || fixP->fx_r_type == BFD_RELOC_CKCORE_PLT32
4840       || fixP->fx_r_type == BFD_RELOC_CKCORE_GOT32
4841       || fixP->fx_r_type == BFD_RELOC_CKCORE_PLT12
4842       || fixP->fx_r_type == BFD_RELOC_CKCORE_GOT12
4843       || fixP->fx_r_type == BFD_RELOC_CKCORE_GOT_HI16
4844       || fixP->fx_r_type == BFD_RELOC_CKCORE_GOT_LO16
4845       || fixP->fx_r_type == BFD_RELOC_CKCORE_PLT_HI16
4846       || fixP->fx_r_type == BFD_RELOC_CKCORE_PLT_LO16
4847       || fixP->fx_r_type == BFD_RELOC_CKCORE_GOTOFF
4848       || fixP->fx_r_type == BFD_RELOC_CKCORE_GOTOFF_HI16
4849       || fixP->fx_r_type == BFD_RELOC_CKCORE_GOTOFF_LO16
4850       || fixP->fx_r_type == BFD_RELOC_CKCORE_ADDR_HI16
4851       || fixP->fx_r_type == BFD_RELOC_CKCORE_ADDR_LO16
4852       || fixP->fx_r_type == BFD_RELOC_CKCORE_GOT_IMM18BY4
4853       || fixP->fx_r_type == BFD_RELOC_CKCORE_PLT_IMM18BY4
4854       || fixP->fx_r_type == BFD_RELOC_CKCORE_GOTOFF_IMM18
4855       || fixP->fx_r_type == BFD_RELOC_CKCORE_TLS_LE32
4856       || fixP->fx_r_type == BFD_RELOC_CKCORE_TLS_IE32
4857       || fixP->fx_r_type == BFD_RELOC_CKCORE_TLS_GD32
4858       || fixP->fx_r_type == BFD_RELOC_CKCORE_TLS_LDM32
4859       || fixP->fx_r_type == BFD_RELOC_CKCORE_TLS_LDO32)
4860     return 0;
4861
4862   if (do_use_branchstub
4863       && fixP->fx_r_type == BFD_RELOC_CKCORE_PCREL_IMM26BY2
4864       && (symbol_get_bfdsym (fixP->fx_addsy)->flags & BSF_FUNCTION))
4865     return 0;
4866
4867   return 1;
4868 }
4869
4870 void
4871 md_apply_fix (fixS   *fixP,
4872               valueT *valP,
4873               segT   seg)
4874 {
4875   reloc_howto_type *howto;
4876   /* Note: use offsetT because it is signed, valueT is unsigned.  */
4877   offsetT val = *valP;
4878   char *buf = fixP->fx_frag->fr_literal + fixP->fx_where;
4879
4880   /* if fx_done = 0, fixup will also be processed in
4881    * tc_gen_reloc() after md_apply_fix().  */
4882   fixP->fx_done = 0;
4883
4884   /* If the fix is relative to a symbol which is not defined, or not
4885      in the same segment as the fix, we cannot resolve it here.  */
4886   if (IS_CSKY_V1 (mach_flag) && fixP->fx_addsy != NULL
4887       && (! S_IS_DEFINED (fixP->fx_addsy)
4888           || S_GET_SEGMENT (fixP->fx_addsy) != seg))
4889     {
4890       switch (fixP->fx_r_type)
4891        {
4892          /* Data fx_addnumber is greater than 16 bits,
4893             so fx_addnumber is assigned zero.  */
4894        case BFD_RELOC_CKCORE_PCREL_JSR_IMM11BY2:
4895          *valP = 0;
4896          break;
4897        case BFD_RELOC_CKCORE_TLS_IE32:
4898        case BFD_RELOC_CKCORE_TLS_LDM32:
4899        case BFD_RELOC_CKCORE_TLS_GD32:
4900          {
4901            struct tls_addend *ta = &(fixP->tc_fix_data);
4902            fixP->fx_offset = (fixP->fx_frag->fr_address + fixP->fx_where
4903                               - (ta->frag->fr_address + ta->offset));
4904          }
4905          /* Fall through.  */
4906        case BFD_RELOC_CKCORE_TLS_LE32:
4907        case BFD_RELOC_CKCORE_TLS_LDO32:
4908          S_SET_THREAD_LOCAL (fixP->fx_addsy);
4909          break;
4910        default:
4911          break;
4912        }
4913 #ifdef OBJ_ELF
4914       /* For ELF we can just return and let the reloc that will be generated
4915          take care of everything.  For COFF we still have to insert 'val'
4916          into the insn since the addend field will be ignored.  */
4917       return;
4918 #endif
4919     }
4920
4921   /* We can handle these relocs.  */
4922   switch (fixP->fx_r_type)
4923     {
4924     case BFD_RELOC_32_PCREL:
4925     case BFD_RELOC_CKCORE_PCREL32:
4926       fixP->fx_r_type = BFD_RELOC_CKCORE_PCREL32;
4927       break;
4928     case BFD_RELOC_VTABLE_INHERIT:
4929       fixP->fx_r_type = BFD_RELOC_CKCORE_GNU_VTINHERIT;
4930       if (fixP->fx_addsy && !S_IS_DEFINED (fixP->fx_addsy)
4931           && !S_IS_WEAK (fixP->fx_addsy))
4932         S_SET_WEAK (fixP->fx_addsy);
4933       break;
4934     case BFD_RELOC_VTABLE_ENTRY:
4935       fixP->fx_r_type = BFD_RELOC_CKCORE_GNU_VTENTRY;
4936       break;
4937     case BFD_RELOC_CKCORE_GOT12:
4938     case BFD_RELOC_CKCORE_PLT12:
4939     case BFD_RELOC_CKCORE_ADDR_HI16:
4940     case BFD_RELOC_CKCORE_ADDR_LO16:
4941     case BFD_RELOC_CKCORE_TOFFSET_LO16:
4942     case BFD_RELOC_CKCORE_DOFFSET_LO16:
4943     case BFD_RELOC_CKCORE_GOT_HI16:
4944     case BFD_RELOC_CKCORE_GOT_LO16:
4945     case BFD_RELOC_CKCORE_PLT_HI16:
4946     case BFD_RELOC_CKCORE_PLT_LO16:
4947     case BFD_RELOC_CKCORE_GOTPC_HI16:
4948     case BFD_RELOC_CKCORE_GOTPC_LO16:
4949     case BFD_RELOC_CKCORE_GOTOFF_HI16:
4950     case BFD_RELOC_CKCORE_GOTOFF_LO16:
4951     case BFD_RELOC_CKCORE_DOFFSET_IMM18:
4952     case BFD_RELOC_CKCORE_DOFFSET_IMM18BY2:
4953     case BFD_RELOC_CKCORE_DOFFSET_IMM18BY4:
4954     case BFD_RELOC_CKCORE_GOTOFF_IMM18:
4955     case BFD_RELOC_CKCORE_GOT_IMM18BY4:
4956     case BFD_RELOC_CKCORE_PLT_IMM18BY4:
4957       break;
4958     case BFD_RELOC_CKCORE_TLS_IE32:
4959     case BFD_RELOC_CKCORE_TLS_LDM32:
4960     case BFD_RELOC_CKCORE_TLS_GD32:
4961       {
4962         struct tls_addend *ta = &(fixP->tc_fix_data);
4963         fixP->fx_offset = (fixP->fx_frag->fr_address + fixP->fx_where
4964                            - (ta->frag->fr_address + ta->offset));
4965       }
4966       /* Fall through.  */
4967     case BFD_RELOC_CKCORE_TLS_LE32:
4968     case BFD_RELOC_CKCORE_TLS_LDO32:
4969       S_SET_THREAD_LOCAL (fixP->fx_addsy);
4970       break;
4971     case BFD_RELOC_32:
4972       fixP->fx_r_type = BFD_RELOC_CKCORE_ADDR32;
4973       /* Fall through.  */
4974     case BFD_RELOC_16:
4975     case BFD_RELOC_8:
4976       if (fixP->fx_addsy == NULL)
4977         {
4978           if (fixP->fx_size == 4)
4979             ;
4980           else if (fixP->fx_size == 2 && val >= -32768 && val <= 32767)
4981             ;
4982           else if (fixP->fx_size == 1 && val >= -256 && val <= 255)
4983             ;
4984           else
4985             abort ();
4986           md_number_to_chars (buf, val, fixP->fx_size);
4987           fixP->fx_done = 1;
4988         }
4989       break;
4990     case BFD_RELOC_CKCORE_PCREL_JSR_IMM11BY2:
4991       if (fixP->fx_addsy == 0 && val > -2 KB && val < 2 KB)
4992         {
4993           long nval = (val >> 1) & 0x7ff;
4994           nval |= CSKYV1_INST_BSR;
4995           csky_write_insn (buf, nval, 2);
4996           fixP->fx_done = 1;
4997         }
4998       else
4999         *valP = 0;
5000       break;
5001     case BFD_RELOC_CKCORE_PCREL_JSR_IMM26BY2:
5002       if (fixP->fx_addsy == 0)
5003         {
5004           if (val >= -(1 << 26) && val < (1 << 26))
5005             {
5006               unsigned int nval = ((val + fixP->fx_size) >> 1) & 0x3ffffff;
5007               nval |= CSKYV2_INST_BSR32;
5008
5009               csky_write_insn (buf, nval, 4);
5010             }
5011           /* If bsr32 cannot reach,
5012              generate 'lrw r25,label;jsr r25' instead of 'jsri label'.  */
5013           else if (IS_CSKY_ARCH_810 (mach_flag))
5014             {
5015               howto = bfd_reloc_type_lookup (stdoutput, fixP->fx_r_type);
5016               valueT opcode = csky_read_insn (buf, 4);
5017               opcode = (opcode & howto->dst_mask) | CSKYV2_INST_JSRI_TO_LRW;
5018               csky_write_insn (buf, opcode, 4);
5019               opcode = CSKYV2_INST_JSR_R26;
5020               csky_write_insn (buf + 4, opcode, 4);
5021             }
5022           fixP->fx_done = 1;
5023         }
5024       break;
5025
5026     default:
5027       {
5028         valueT opcode;
5029         offsetT min, max;
5030         unsigned int issigned = 0;
5031
5032         if (fixP->fx_addsy)
5033           break;
5034
5035         howto = bfd_reloc_type_lookup (stdoutput, fixP->fx_r_type);
5036         if (howto == NULL)
5037           {
5038             if (fixP->fx_size == 4
5039                 || (fixP->fx_size == 2 && val >= -32768 && val <= 32767)
5040                 || (fixP->fx_size == 1 && val >= -256 && val <= 255))
5041               {
5042                 md_number_to_chars (buf, val, fixP->fx_size);
5043                 fixP->fx_done = 1;
5044                 break;
5045               }
5046             else
5047               abort ();
5048           }
5049
5050         if (IS_CSKY_V2 (mach_flag))
5051           val += fixP->fx_size;
5052
5053         if (howto->rightshift == 2)
5054           val += 2;
5055
5056         val >>= howto->rightshift;
5057
5058         switch (fixP->fx_r_type)
5059           {
5060             /* Offset is unsigned.  */
5061           case BFD_RELOC_CKCORE_PCREL_IMM8BY4:
5062           case BFD_RELOC_CKCORE_PCREL_IMM10BY4:
5063           case BFD_RELOC_CKCORE_PCREL_IMM16BY4:
5064             max = (offsetT) howto->dst_mask;
5065             min = 0;
5066             break;
5067             /* lrw16.  */
5068           case BFD_RELOC_CKCORE_PCREL_IMM7BY4:
5069             if (do_extend_lrw)
5070               max = (offsetT)((1 << (howto->bitsize + 1)) - 2);
5071             else
5072               max = (offsetT)((1 << howto->bitsize) - 1);
5073             min = 0;
5074             break;
5075             /* flrws, flrwd: the offset bits are divided in two parts.  */
5076           case BFD_RELOC_CKCORE_PCREL_FLRW_IMM8BY4:
5077             max = (offsetT)((1 << howto->bitsize) - 1);
5078             min = 0;
5079             break;
5080             /* Offset is signed.  */
5081           default:
5082             max = (offsetT)(howto->dst_mask >> 1);
5083             min = - max - 1;
5084             issigned = 1;
5085           }
5086         if (val < min || val > max)
5087           {
5088             csky_branch_report_error (fixP->fx_file, fixP->fx_line,
5089                                       fixP->fx_addsy, val);
5090             return;
5091           }
5092         opcode = csky_read_insn (buf, fixP->fx_size);
5093         /* Clear redundant bits brought from the last
5094            operation if there is any.  */
5095         if (do_extend_lrw && (opcode & 0xfc00) == CSKYV2_INST_LRW16)
5096           val &= 0xff;
5097         else
5098           val &= issigned ? (offsetT)(howto->dst_mask) : max;
5099
5100         if (fixP->fx_r_type == BFD_RELOC_CKCORE_PCREL_BLOOP_IMM4BY4)
5101           val = (val & 0xf) << 12;
5102
5103         if (fixP->fx_size == 2  && (opcode & 0xfc00) == CSKYV2_INST_LRW16)
5104           {
5105             /* 8 bit offset lrw16.  */
5106             if (val >= 0x80)
5107               csky_write_insn (buf,
5108                                ((~val & 0x1f)
5109                                 | ((~val & 0x60) << 3) | (opcode & 0xe0)),
5110                                fixP->fx_size);
5111             /* 7 bit offset lrw16.  */
5112             else
5113               csky_write_insn (buf,
5114                                (val & 0x1f) | ((val & 0x60) << 3) | opcode,
5115                                fixP->fx_size);
5116           }
5117         else if (fixP->fx_size == 4
5118                  && (opcode & 0xfe1ffe00) == CSKYV2_INST_FLRW)
5119           csky_write_insn (buf,
5120                            ((val & 0xf) << 4) | ((val & 0xf0) << 17) | opcode,
5121                            fixP->fx_size);
5122         else
5123           csky_write_insn (buf, val | opcode, fixP->fx_size);
5124         fixP->fx_done = 1;
5125         break;
5126       }
5127     }
5128   fixP->fx_addnumber = val;
5129 }
5130
5131 /* Translate internal representation of relocation info to BFD target
5132    format.  */
5133
5134 arelent *
5135 tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixP)
5136 {
5137   arelent *rel;
5138
5139   if (fixP->fx_pcrel
5140       && fixP->fx_r_type == BFD_RELOC_CKCORE_ADDR32)
5141       fixP->fx_r_type = BFD_RELOC_CKCORE_PCREL32;
5142
5143   rel = xmalloc (sizeof (arelent));
5144   rel->sym_ptr_ptr = xmalloc (sizeof (asymbol *));
5145   *rel->sym_ptr_ptr = symbol_get_bfdsym (fixP->fx_addsy);
5146   rel->howto = bfd_reloc_type_lookup (stdoutput, fixP->fx_r_type);
5147   rel->addend = fixP->fx_offset;
5148   if (rel->howto == NULL)
5149     {
5150       as_bad_where (fixP->fx_file, fixP->fx_line,
5151                     _("cannot represent `%s' relocation in object file"),
5152                     bfd_get_reloc_code_name (fixP->fx_r_type));
5153
5154       /* Set howto to a garbage value so that we can keep going.  */
5155       rel->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_32);
5156     }
5157   gas_assert (rel->howto != NULL);
5158   rel->address = fixP->fx_frag->fr_address + fixP->fx_where;
5159   return rel;
5160 }
5161
5162 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE.  */
5163
5164 long
5165 csky_relax_frag (segT segment, fragS *fragP, long stretch)
5166 {
5167   const relax_typeS *this_type;
5168   const relax_typeS *start_type;
5169   relax_substateT next_state;
5170   relax_substateT this_state;
5171   offsetT growth;
5172   offsetT aim;
5173   addressT target;
5174   addressT address;
5175   symbolS *symbolP;
5176   const relax_typeS *table;
5177
5178   target = fragP->fr_offset;
5179   address = fragP->fr_address;
5180   table = TC_GENERIC_RELAX_TABLE;
5181   this_state = fragP->fr_subtype;
5182   start_type = this_type = table + this_state;
5183   symbolP = fragP->fr_symbol;
5184
5185   if (symbolP)
5186     {
5187       fragS *sym_frag;
5188
5189       sym_frag = symbol_get_frag (symbolP);
5190
5191 #ifndef DIFF_EXPR_OK
5192       know (sym_frag != NULL);
5193 #endif
5194       know (S_GET_SEGMENT (symbolP) != absolute_section
5195             || sym_frag == &zero_address_frag);
5196       target += S_GET_VALUE (symbolP);
5197
5198       /* If SYM_FRAG has yet to be reached on this pass, assume it
5199          will move by STRETCH just as we did, unless there is an
5200          alignment frag between here and SYM_FRAG.  An alignment may
5201          well absorb any STRETCH, and we don't want to choose a larger
5202          branch insn by overestimating the needed reach of this
5203          branch.  It isn't critical to calculate TARGET exactly;  We
5204          know we'll be doing another pass if STRETCH is non-zero.  */
5205
5206       if (stretch != 0
5207           && sym_frag->relax_marker != fragP->relax_marker
5208           && S_GET_SEGMENT (symbolP) == segment)
5209         {
5210           fragS *f;
5211
5212           /* Adjust stretch for any alignment frag.  Note that if have
5213              been expanding the earlier code, the symbol may be
5214              defined in what appears to be an earlier frag.  FIXME:
5215              This doesn't handle the fr_subtype field, which specifies
5216              a maximum number of bytes to skip when doing an
5217              alignment.  */
5218           for (f = fragP; f != NULL && f != sym_frag; f = f->fr_next)
5219             {
5220               if (f->fr_type == rs_align || f->fr_type == rs_align_code)
5221                 {
5222                   if (stretch < 0)
5223                     stretch = -((-stretch)
5224                                 & ~((1 << (int) f->fr_offset) - 1));
5225                   else
5226                     stretch &= ~((1 << (int) f->fr_offset) - 1);
5227                 }
5228               if (stretch == 0)
5229                 break;
5230             }
5231           if (f != 0)
5232             target += stretch;
5233         }
5234     }
5235
5236   aim = target - address - fragP->fr_fix;
5237
5238   /* If the fragP->fr_symbol is extern symbol, aim should be 0.  */
5239   if (fragP->fr_symbol && S_GET_SEGMENT (symbolP) != segment)
5240     aim = 0;
5241
5242   if (aim < 0)
5243     {
5244       /* Look backwards.  */
5245       for (next_state = this_type->rlx_more; next_state;)
5246         if (aim >= this_type->rlx_backward)
5247           next_state = 0;
5248         else
5249           {
5250             /* Grow to next state.  */
5251             this_state = next_state;
5252             this_type = table + this_state;
5253             next_state = this_type->rlx_more;
5254           }
5255     }
5256   else
5257     {
5258       /* Look forwards.  */
5259       for (next_state = this_type->rlx_more; next_state;)
5260         if (aim <= this_type->rlx_forward)
5261           next_state = 0;
5262         else
5263           {
5264             /* Grow to next state.  */
5265             this_state = next_state;
5266             this_type = table + this_state;
5267             next_state = this_type->rlx_more;
5268           }
5269     }
5270
5271   growth = this_type->rlx_length - start_type->rlx_length;
5272   if (growth != 0)
5273     fragP->fr_subtype = this_state;
5274   return growth;
5275 }
5276
5277 int
5278 md_estimate_size_before_relax (fragS * fragp,
5279                                segT  segtype)
5280 {
5281   switch (fragp->fr_subtype)
5282     {
5283     case COND_DISP10:
5284     case COND_DISP16:
5285     case SCOND_DISP10:
5286     case SCOND_DISP16:
5287     case UNCD_DISP10:
5288     case UNCD_DISP16:
5289     case JCOND_DISP10:
5290     case JCOND_DISP16:
5291     case JCOND_DISP32:
5292     case JUNCD_DISP10:
5293     case JUNCD_DISP16:
5294     case JUNCD_DISP32:
5295     case JCOMPZ_DISP16:
5296     case JCOMPZ_DISP32:
5297     case BSR_DISP26:
5298     case LRW_DISP7:
5299     case LRW2_DISP8:
5300     case LRW_DISP16:
5301       gas_assert (fragp->fr_symbol);
5302       if (IS_EXTERNAL_SYM (fragp->fr_symbol, segtype))
5303         while (csky_relax_table[fragp->fr_subtype].rlx_more > RELAX_OVERFLOW)
5304           fragp->fr_subtype = csky_relax_table[fragp->fr_subtype].rlx_more;
5305       return csky_relax_table[fragp->fr_subtype].rlx_length;
5306
5307       /* C-SKY V1 relaxes.  */
5308     case C (UNCD_JUMP, UNDEF_DISP):
5309     case C (UNCD_JUMP_PIC, UNDEF_DISP):
5310       if (!fragp->fr_symbol)
5311         fragp->fr_subtype = C (UNCD_JUMP_S, DISP12);
5312       else if (S_GET_SEGMENT (fragp->fr_symbol) == segtype)
5313         fragp->fr_subtype = C (UNCD_JUMP_S, DISP12);
5314       else
5315         fragp->fr_subtype = C (UNCD_JUMP_S, UNDEF_WORD_DISP);
5316       break;
5317
5318     case C (COND_JUMP, UNDEF_DISP):
5319     case C (COND_JUMP_PIC, UNDEF_DISP):
5320       if (fragp->fr_symbol
5321           && S_GET_SEGMENT (fragp->fr_symbol) == segtype)
5322         /* Got a symbol and it's defined in this segment, become byte
5323            sized. Maybe it will fix up.  */
5324         fragp->fr_subtype = C (COND_JUMP_S, DISP12);
5325       else if (fragp->fr_symbol)
5326         /* It's got a segment, but it's not ours, so it will always be
5327            long.  */
5328         fragp->fr_subtype = C (COND_JUMP_S, UNDEF_WORD_DISP);
5329       else
5330         /* We know the abs value.  */
5331         fragp->fr_subtype = C (COND_JUMP_S, DISP12);
5332       break;
5333
5334     case C (UNCD_JUMP, DISP12):
5335     case C (UNCD_JUMP, DISP32):
5336     case C (UNCD_JUMP, UNDEF_WORD_DISP):
5337     case C (COND_JUMP, DISP12):
5338     case C (COND_JUMP, DISP32):
5339     case C (COND_JUMP, UNDEF_WORD_DISP):
5340     case C (UNCD_JUMP_PIC, DISP12):
5341     case C (UNCD_JUMP_PIC, DISP32):
5342     case C (UNCD_JUMP_PIC, UNDEF_WORD_DISP):
5343     case C (COND_JUMP_PIC, DISP12):
5344     case C (COND_JUMP_PIC, DISP32):
5345     case C (COND_JUMP_PIC, UNDEF_WORD_DISP):
5346     case RELAX_OVERFLOW:
5347       break;
5348
5349     default:
5350       abort ();
5351     }
5352   return csky_relax_table[fragp->fr_subtype].rlx_length;
5353 }
5354
5355 /* Parse opcode like: "op oprnd1, oprnd2, oprnd3".  */
5356
5357 static void
5358 csky_macro_md_assemble (const char *op,
5359                         const char *oprnd1,
5360                         const char *oprnd2,
5361                         const char *oprnd3)
5362 {
5363   char str[80];
5364   str[0] = '\0';
5365   strcat (str, op);
5366   if (oprnd1 != NULL)
5367     {
5368       strcat (str, " ");
5369       strcat (str, oprnd1);
5370       if (oprnd2 != NULL)
5371         {
5372           strcat (str, ",");
5373           strcat (str, oprnd2);
5374           if (oprnd3 != NULL)
5375             {
5376               strcat (str, ",");
5377               strcat (str, oprnd3);
5378             }
5379         }
5380     }
5381   md_assemble (str);
5382   return;
5383 }
5384
5385 /* Get the string of operand.  */
5386
5387 static int
5388 csky_get_macro_operand (char *src_s, char *dst_s, char end_sym)
5389 {
5390   int nlen = 0;
5391   while (ISSPACE (*src_s))
5392     ++src_s;
5393   while (*src_s != end_sym)
5394     dst_s[nlen++] = *(src_s++);
5395   dst_s[nlen] = '\0';
5396   return nlen;
5397 }
5398
5399 /* idly 4 -> idly4.  */
5400
5401 static void
5402 csky_idly (void)
5403 {
5404   char *s = csky_insn.opcode_end;
5405   if (!is_imm_over_range (&s, 4, 4, -1))
5406     {
5407       as_bad (_("second operand must be 4"));
5408       return;
5409     }
5410   csky_macro_md_assemble ("idly4", NULL, NULL, NULL);
5411   return;
5412 }
5413
5414 /* rolc rd, 1 or roltc rd, 1 -> addc rd, rd.  */
5415
5416 static void
5417 csky_rolc (void)
5418 {
5419   char reg[10];
5420   char *s = csky_insn.opcode_end;
5421
5422   s += csky_get_macro_operand (s, reg, ',');
5423   ++s;
5424
5425   if (is_imm_over_range (&s, 1, 1, -1))
5426     {
5427       csky_macro_md_assemble ("addc", reg, reg, NULL);
5428       return;
5429     }
5430   else
5431     as_bad (_("second operand must be 1"));
5432 }
5433
5434 /* sxtrb0(1)(2) r1, rx -> xtbr0(1)(2) r1,rx; sextb r1.  */
5435
5436 static void
5437 csky_sxtrb (void)
5438 {
5439   char reg1[10];
5440   char reg2[10];
5441
5442   char *s = csky_insn.opcode_end;
5443   s += csky_get_macro_operand (s, reg1, ',');
5444   ++s;
5445   csky_get_macro_operand (s, reg2, '\0');
5446
5447   csky_macro_md_assemble (csky_insn.macro->name + 1, reg1, reg2, NULL);
5448   csky_macro_md_assemble ("sextb", reg1, NULL, NULL);
5449   return;
5450 }
5451
5452 static void
5453 csky_movtf (void)
5454 {
5455   char reg1[10];
5456   char reg2[10];
5457   char reg3[10];
5458
5459   char *s = csky_insn.opcode_end;
5460   s += csky_get_macro_operand (s, reg1, ',');
5461   ++s;
5462
5463   s += csky_get_macro_operand (s, reg2, ',');
5464   ++s;
5465
5466   s += csky_get_macro_operand (s, reg3, '\0');
5467   ++s;
5468   csky_macro_md_assemble ("movt", reg1, reg2, NULL);
5469   csky_macro_md_assemble ("movf", reg1, reg3, NULL);
5470   return;
5471 }
5472
5473 static bfd_boolean
5474 get_macro_reg_vals (int *reg1, int *reg2, int *reg3)
5475 {
5476   int nlen;
5477   char *s = csky_insn.opcode_end;
5478
5479   *reg1 = csky_get_reg_val (s, &nlen);
5480   s += nlen;
5481   if (*s != ',')
5482     {
5483       csky_show_error (ERROR_MISSING_COMMA, 0, NULL, NULL);
5484       return FALSE;
5485     }
5486   s++;
5487   *reg2 = csky_get_reg_val (s, &nlen);
5488   s += nlen;
5489   if (*s != ',')
5490     {
5491       csky_show_error (ERROR_MISSING_COMMA, 0, NULL, NULL);
5492       return FALSE;
5493     }
5494   s++;
5495   *reg3 = csky_get_reg_val (s, &nlen);
5496   s += nlen;
5497   if (*s != '\0')
5498     {
5499       csky_show_error (ERROR_BAD_END, 0, s, NULL);
5500       return FALSE;
5501     }
5502   if (*reg1 == -1 || *reg2 == -1 || *reg3 == -1)
5503     {
5504       as_bad (_("register number out of range"));
5505       return FALSE;
5506     }
5507   if (*reg1 != *reg2)
5508     {
5509       as_bad (_("dest and source1 must be the same register"));
5510       return FALSE;
5511     }
5512   if (*reg1 >= 15 || *reg3 >= 15)
5513     {
5514       as_bad (_("64-bit operator src/dst register must be less than 15"));
5515       return FALSE;
5516     }
5517   return TRUE;
5518 }
5519
5520 /* addc64 rx, rx, ry -> cmplt rx, rx, addc  rx, ry, addc  rx+1, ry+1.  */
5521
5522 static void
5523 csky_addc64 (void)
5524 {
5525   int reg1;
5526   int reg2;
5527   int reg3;
5528
5529   if (!get_macro_reg_vals (&reg1, &reg2, &reg3))
5530     return;
5531   csky_macro_md_assemble ("cmplt",
5532                           csky_general_reg[reg1],
5533                           csky_general_reg[reg1],
5534                           NULL);
5535   csky_macro_md_assemble ("addc",
5536                           csky_general_reg[reg1 + (target_big_endian ? 1 : 0)],
5537                           csky_general_reg[reg3 + (target_big_endian ? 1 : 0)],
5538                           NULL);
5539   csky_macro_md_assemble ("addc",
5540                           csky_general_reg[reg1 + (target_big_endian ? 0 : 1)],
5541                           csky_general_reg[reg3 + (target_big_endian ? 0 : 1)],
5542                           NULL);
5543   return;
5544 }
5545
5546 /* subc64 rx, rx, ry -> cmphs rx, rx, subc  rx, ry, subc  rx+1, ry+1.  */
5547
5548 static void
5549 csky_subc64 (void)
5550 {
5551   int reg1;
5552   int reg2;
5553   int reg3;
5554
5555   if (!get_macro_reg_vals (&reg1, &reg2, &reg3))
5556     return;
5557   csky_macro_md_assemble ("cmphs",
5558                           csky_general_reg[reg1],
5559                           csky_general_reg[reg1],
5560                           NULL);
5561   csky_macro_md_assemble ("subc",
5562                           csky_general_reg[reg1 + (target_big_endian ? 1 : 0)],
5563                           csky_general_reg[reg3 + (target_big_endian ? 1 : 0)],
5564                           NULL);
5565   csky_macro_md_assemble ("subc",
5566                           csky_general_reg[reg1 + (target_big_endian ? 0 : 1)],
5567                           csky_general_reg[reg3 + (target_big_endian ? 0 : 1)],
5568                           NULL);
5569   return;
5570 }
5571
5572 /* or64 rx, rx, ry -> or rx, ry, or rx+1, ry+1.  */
5573
5574 static void
5575 csky_or64 (void)
5576 {
5577   int reg1;
5578   int reg2;
5579   int reg3;
5580
5581   if (!get_macro_reg_vals (&reg1, &reg2, &reg3))
5582     return;
5583   csky_macro_md_assemble ("or",
5584                           csky_general_reg[reg1 + (target_big_endian ? 1 : 0)],
5585                           csky_general_reg[reg3 + (target_big_endian ? 1 : 0)],
5586                           NULL);
5587   csky_macro_md_assemble ("or",
5588                           csky_general_reg[reg1 + (target_big_endian ? 0 : 1)],
5589                           csky_general_reg[reg3 + (target_big_endian ? 0 : 1)],
5590                           NULL);
5591   return;
5592 }
5593
5594 /* xor64 rx, rx, ry -> xor rx, ry, xor rx+1, ry+1.  */
5595
5596 static void
5597 csky_xor64 (void)
5598 {
5599   int reg1;
5600   int reg2;
5601   int reg3;
5602
5603   if (!get_macro_reg_vals (&reg1, &reg2, &reg3))
5604     return;
5605   csky_macro_md_assemble ("xor",
5606                           csky_general_reg[reg1 + (target_big_endian ? 1 : 0)],
5607                           csky_general_reg[reg3 + (target_big_endian ? 1 : 0)],
5608                           NULL);
5609   csky_macro_md_assemble ("xor",
5610                           csky_general_reg[reg1 + (target_big_endian ? 0 : 1)],
5611                           csky_general_reg[reg3 + (target_big_endian ? 0 : 1)],
5612                           NULL);
5613   return;
5614 }
5615
5616 /* The following are V2 macro instructions.  */
5617
5618 /* neg rd -> not rd, rd; addi rd, 1.  */
5619
5620 static void
5621 csky_neg (void)
5622 {
5623   char reg1[10];
5624
5625   char *s = csky_insn.opcode_end;
5626   s += csky_get_macro_operand (s, reg1, '\0');
5627   ++s;
5628
5629   csky_macro_md_assemble ("not", reg1, reg1, NULL);
5630   csky_macro_md_assemble ("addi", reg1, "1", NULL);
5631   return;
5632 }
5633
5634 /* rsubi rd, imm16 -> not rd; addi rd, imm16 + 1  */
5635
5636 static void
5637 csky_rsubi (void)
5638 {
5639   char reg1[10];
5640   char str_imm16[20];
5641   unsigned int imm16 = 0;
5642   expressionS e;
5643   char *s = csky_insn.opcode_end;
5644   s += csky_get_macro_operand (s, reg1, ',');
5645   ++s;
5646
5647   s = parse_exp (s, &e);
5648   if (e.X_op == O_constant)
5649     imm16 = e.X_add_number;
5650   else
5651     csky_show_error (ERROR_IMM_ILLEGAL, 2, NULL, NULL);
5652
5653   sprintf (str_imm16, "%d", imm16 + 1);
5654
5655   csky_macro_md_assemble ("not", reg1, reg1, NULL);
5656   csky_macro_md_assemble ("addi", reg1, str_imm16, NULL);
5657   return;
5658 }
5659
5660 /* Such as: asrc rd -> asrc rd, rd, 1.  */
5661
5662 static void
5663 csky_arith (void)
5664 {
5665   char reg1[10];
5666   char *s = csky_insn.opcode_end;
5667   s += csky_get_macro_operand (s, reg1, '\0');
5668   ++s;
5669   csky_macro_md_assemble (csky_insn.macro->name, reg1, reg1, "1");
5670   return;
5671 }
5672
5673 /* decne rd ->  if ck802: subi rd, 1; cmpnei rd, 0.
5674    else: decne rd, rd, 1  */
5675
5676 static void
5677 csky_decne (void)
5678 {
5679   char reg1[10];
5680   char *s = csky_insn.opcode_end;
5681   s += csky_get_macro_operand (s, reg1, '\0');
5682   ++s;
5683   if (IS_CSKY_ARCH_802 (mach_flag))
5684     {
5685       csky_macro_md_assemble ("subi", reg1, "1", NULL);
5686       csky_macro_md_assemble ("cmpnei", reg1, "0", NULL);
5687     }
5688   else
5689     csky_macro_md_assemble ("decne", reg1, reg1, "1");
5690   return;
5691 }
5692
5693 /* If -mnolrw, lrw rd, imm -> movih rd, imm_hi16; ori rd, imm_lo16.  */
5694
5695 static void
5696 csky_lrw (void)
5697 {
5698   char reg1[10];
5699   char imm[40];
5700   char imm_hi16[40];
5701   char imm_lo16[40];
5702
5703   char *s = csky_insn.opcode_end;
5704   s += csky_get_macro_operand (s, reg1, ',');
5705   ++s;
5706   s += csky_get_macro_operand (s, imm, '\0');
5707   ++s;
5708
5709   imm_hi16[0] = '\0';
5710   strcat (imm_hi16, "(");
5711   strcat (imm_hi16, imm);
5712   strcat (imm_hi16, ") >> 16");
5713   imm_lo16[0] = '\0';
5714   strcat (imm_lo16, "(");
5715   strcat (imm_lo16, imm);
5716   strcat (imm_lo16, ") & 0xffff");
5717
5718   csky_macro_md_assemble ("movih", reg1, imm_hi16,  NULL);
5719   csky_macro_md_assemble ("ori", reg1, reg1, imm_lo16);
5720
5721   return;
5722 }
5723
5724 /* The following are worker functions for C-SKY v1.  */
5725
5726 bfd_boolean
5727 v1_work_lrw (void)
5728 {
5729   int reg;
5730   int output_literal = csky_insn.val[1];
5731
5732   reg = csky_insn.val[0];
5733   csky_insn.isize = 2;
5734   csky_insn.output = frag_more (2);
5735   if (csky_insn.e1.X_op == O_constant
5736       && csky_insn.e1.X_add_number <= 0x7f
5737       && csky_insn.e1.X_add_number >= 0)
5738     /* lrw to movi.  */
5739     csky_insn.inst = 0x6000 | reg | (csky_insn.e1.X_add_number << 4);
5740   else
5741     {
5742       csky_insn.inst = csky_insn.opcode->op16[0].opcode;
5743       csky_insn.inst |= reg << 8;
5744       if (output_literal)
5745         {
5746           int n = enter_literal (&csky_insn.e1, 0, 0, 0);
5747
5748           /* Create a reference to pool entry.  */
5749           csky_insn.e1.X_op = O_symbol;
5750           csky_insn.e1.X_add_symbol = poolsym;
5751           csky_insn.e1.X_add_number = n << 2;
5752         }
5753
5754       if (insn_reloc == BFD_RELOC_CKCORE_TLS_GD32
5755           || insn_reloc == BFD_RELOC_CKCORE_TLS_LDM32
5756           || insn_reloc == BFD_RELOC_CKCORE_TLS_IE32)
5757         {
5758           literal_insn_offset->tls_addend.frag  = frag_now;
5759           literal_insn_offset->tls_addend.offset
5760             = (csky_insn.output
5761                - literal_insn_offset->tls_addend.frag->fr_literal);
5762         }
5763       fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal, 2,
5764                    &csky_insn.e1, 1, BFD_RELOC_CKCORE_PCREL_IMM8BY4);
5765     }
5766   csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
5767
5768   return TRUE;
5769 }
5770
5771 bfd_boolean
5772 v1_work_fpu_fo (void)
5773 {
5774   int i = 0;
5775   int inst;
5776   int greg = -1;
5777   char buff[50];
5778   struct csky_opcode_info *opinfo = NULL;
5779
5780   if (csky_insn.isize == 4)
5781     opinfo = &csky_insn.opcode->op32[csky_insn.opcode_idx];
5782   else if (csky_insn.isize == 2)
5783     opinfo = &csky_insn.opcode->op16[csky_insn.opcode_idx];
5784
5785   /* Firstly, get general reg.  */
5786   for (i = 0;i < opinfo->operand_num; i++)
5787     if (opinfo->oprnd.oprnds[i].type == OPRND_TYPE_GREG0_15)
5788       greg = csky_insn.val[i];
5789   gas_assert (greg != -1);
5790
5791   /* Secondly, get float inst.  */
5792   csky_generate_insn ();
5793   inst = csky_insn.inst;
5794
5795   /* Now get greg and inst, we can write instruction to floating unit.  */
5796   sprintf (buff, "lrw %s,0x%x", csky_general_reg[greg], inst);
5797   md_assemble (buff);
5798   sprintf (buff, "cpwir %s", csky_general_reg[greg]);
5799   md_assemble (buff);
5800
5801   return FALSE;
5802 }
5803
5804 bfd_boolean
5805 v1_work_fpu_fo_fc (void)
5806 {
5807   int i = 0;
5808   int inst;
5809   int greg = -1;
5810   char buff[50];
5811   struct csky_opcode_info *opinfo = NULL;
5812
5813   if (csky_insn.isize == 4)
5814     opinfo = &csky_insn.opcode->op32[csky_insn.opcode_idx];
5815   else if (csky_insn.isize == 2)
5816     opinfo = &csky_insn.opcode->op16[csky_insn.opcode_idx];
5817
5818   /* Firstly, get general reg.  */
5819   for (i = 0;i < opinfo->operand_num; i++)
5820     if (opinfo->oprnd.oprnds[i].type == OPRND_TYPE_GREG0_15)
5821       greg = csky_insn.val[i];
5822   gas_assert (greg != -1);
5823
5824   /* Secondly, get float inst.  */
5825   csky_generate_insn ();
5826   inst = csky_insn.inst;
5827
5828   /* Now get greg and inst, we can write instruction to floating unit.  */
5829   sprintf (buff, "lrw %s,0x%x", csky_general_reg[greg], inst);
5830   md_assemble (buff);
5831   sprintf (buff, "cpwir %s", csky_general_reg[greg]);
5832   md_assemble (buff);
5833   sprintf (buff, "cprc");
5834   md_assemble (buff);
5835
5836   return FALSE;
5837 }
5838
5839 bfd_boolean
5840 v1_work_fpu_write (void)
5841 {
5842   int greg;
5843   int freg;
5844   char buff[50];
5845
5846   greg = csky_insn.val[0];
5847   freg = csky_insn.val[1];
5848
5849   /* Now get greg and freg, we can write instruction to floating unit.  */
5850   sprintf (buff, "cpwgr %s,%s", csky_general_reg[greg], csky_cp_reg[freg]);
5851   md_assemble (buff);
5852
5853   return FALSE;
5854 }
5855
5856 bfd_boolean
5857 v1_work_fpu_read (void)
5858 {
5859   int greg;
5860   int freg;
5861   char buff[50];
5862
5863   greg = csky_insn.val[0];
5864   freg = csky_insn.val[1];
5865   /* Now get greg and freg, we can write instruction to floating unit.  */
5866   sprintf (buff, "cprgr %s,%s", csky_general_reg[greg], csky_cp_reg[freg]);
5867   md_assemble (buff);
5868
5869   return FALSE;
5870 }
5871
5872 bfd_boolean
5873 v1_work_fpu_writed (void)
5874 {
5875   int greg;
5876   int freg;
5877   char buff[50];
5878
5879   greg = csky_insn.val[0];
5880   freg = csky_insn.val[1];
5881
5882   if (greg & 0x1)
5883     {
5884       as_bad (_("even register number required"));
5885       return FALSE;
5886     }
5887   /* Now get greg and freg, we can write instruction to floating unit.  */
5888   if (target_big_endian)
5889     sprintf (buff, "cpwgr %s,%s",
5890              csky_general_reg[greg + 1], csky_cp_reg[freg]);
5891   else
5892     sprintf (buff, "cpwgr %s,%s",
5893              csky_general_reg[greg], csky_cp_reg[freg]);
5894   md_assemble (buff);
5895   if (target_big_endian)
5896     sprintf (buff, "cpwgr %s,%s",
5897              csky_general_reg[greg], csky_cp_reg[freg + 1]);
5898   else
5899     sprintf (buff, "cpwgr %s,%s",
5900              csky_general_reg[greg + 1], csky_cp_reg[freg + 1]);
5901   md_assemble (buff);
5902
5903   return FALSE;
5904 }
5905
5906 bfd_boolean
5907 v1_work_fpu_readd (void)
5908 {
5909   int greg;
5910   int freg;
5911   char buff[50];
5912
5913   greg = csky_insn.val[0];
5914   freg = csky_insn.val[1];
5915
5916   if (greg & 0x1)
5917     {
5918       as_bad (_("even register number required"));
5919       return FALSE;
5920     }
5921   /* Now get greg and freg, we can write instruction to floating unit.  */
5922   if (target_big_endian)
5923     sprintf (buff, "cprgr %s,%s",
5924              csky_general_reg[greg + 1], csky_cp_reg[freg]);
5925   else
5926     sprintf (buff, "cprgr %s,%s",
5927              csky_general_reg[greg], csky_cp_reg[freg]);
5928   md_assemble (buff);
5929   if (target_big_endian)
5930     sprintf (buff, "cprgr %s,%s",
5931              csky_general_reg[greg], csky_cp_reg[freg + 1]);
5932   else
5933     sprintf (buff, "cprgr %s,%s",
5934              csky_general_reg[greg + 1], csky_cp_reg[freg + 1]);
5935   md_assemble (buff);
5936
5937   return FALSE;
5938 }
5939
5940 /* The following are for csky pseudo handling.  */
5941
5942 bfd_boolean
5943 v1_work_jbsr (void)
5944 {
5945   csky_insn.output = frag_more (2);
5946   if (do_force2bsr)
5947     /* Generate fixup BFD_RELOC_CKCORE_PCREL_IMM11BY2.  */
5948     fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
5949                  2, & csky_insn.e1, 1, BFD_RELOC_CKCORE_PCREL_IMM11BY2);
5950   else
5951     {
5952       /* Using jsri instruction.  */
5953       const char *name = "jsri";
5954       csky_insn.opcode = (struct csky_opcode *)
5955         hash_find (csky_opcodes_hash, name);
5956       csky_insn.opcode_idx = 0;
5957       csky_insn.isize = 2;
5958
5959       int n = enter_literal (&csky_insn.e1, 1, 0, 0);
5960
5961       /* Create a reference to pool entry.  */
5962       csky_insn.e1.X_op = O_symbol;
5963       csky_insn.e1.X_add_symbol = poolsym;
5964       csky_insn.e1.X_add_number = n << 2;
5965
5966       /* Generate fixup BFD_RELOC_CKCORE_PCREL_IMM8BY4.  */
5967       fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
5968                    2, & csky_insn.e1, 1, BFD_RELOC_CKCORE_PCREL_IMM8BY4);
5969
5970       if (csky_insn.e1.X_op != O_absent && do_jsri2bsr)
5971         /* Generate fixup BFD_RELOC_CKCORE_PCREL_JSR_IMM11BY2.  */
5972         fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
5973                      2, & (litpool + (csky_insn.e1.X_add_number >> 2))->e,
5974                      1, BFD_RELOC_CKCORE_PCREL_JSR_IMM11BY2);
5975     }
5976   csky_generate_insn ();
5977
5978   csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
5979
5980   return TRUE;
5981 }
5982
5983 /* The following are worker functions for csky v2 instruction handling.  */
5984
5985 /* For nie/nir/ipush/ipop.  */
5986
5987 bfd_boolean
5988 v2_work_istack (void)
5989 {
5990   if (!do_intr_stack)
5991     {
5992       csky_show_error (ERROR_OPCODE_ILLEGAL, 0, NULL, NULL);
5993       return FALSE;
5994     }
5995   csky_insn.output = frag_more (csky_insn.isize);
5996   csky_insn.inst = csky_insn.opcode->op16[0].opcode;
5997   csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
5998   return TRUE;
5999 }
6000
6001 bfd_boolean
6002 v2_work_btsti (void)
6003 {
6004   if (!do_extend_lrw
6005       && (csky_insn.flag_force == INSN_OPCODE16F
6006           || IS_CSKY_ARCH_801 (mach_flag)))
6007     {
6008       csky_show_error (ERROR_OPCODE_ILLEGAL, 0, NULL, NULL);
6009       return FALSE;
6010     }
6011   if (!do_extend_lrw && csky_insn.isize == 2)
6012     csky_insn.isize = 4;
6013   /* Generate relax or reloc if necessary.  */
6014   csky_generate_frags ();
6015   /* Generate the insn by mask.  */
6016   csky_generate_insn ();
6017   /* Write inst to frag.  */
6018   csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
6019   return TRUE;
6020 }
6021
6022 bfd_boolean
6023 v2_work_addi (void)
6024 {
6025   csky_insn.isize = 2;
6026   if (csky_insn.number == 2)
6027     {
6028       if (csky_insn.val[0] == 14
6029           && csky_insn.val[1] >= 0 && csky_insn.val[1] <= 0x1fc
6030           && (csky_insn.val[1] & 0x3) == 0
6031           && csky_insn.flag_force != INSN_OPCODE32F)
6032         {
6033           /* addi sp, sp, imm.  */
6034           csky_insn.inst = 0x1400 | ((csky_insn.val[1] >> 2) & 0x1f);
6035           csky_insn.inst |= (csky_insn.val[1] << 1) & 0x300;
6036           csky_insn.output = frag_more (2);
6037         }
6038       else if (csky_insn.val[0] < 8
6039                && csky_insn.val[1] >= 1 && csky_insn.val[1] <= 0x100
6040                && csky_insn.flag_force != INSN_OPCODE32F)
6041         {
6042           csky_insn.inst = 0x2000 | (csky_insn.val[0] << 8);
6043           csky_insn.inst |=  (csky_insn.val[1] - 1);
6044           csky_insn.output = frag_more (2);
6045         }
6046       else if (csky_insn.val[1] >= 1 && csky_insn.val[1] <= 0x10000
6047                && csky_insn.flag_force != INSN_OPCODE16F
6048                && !IS_CSKY_ARCH_801 (mach_flag))
6049         {
6050           csky_insn.inst = 0xe4000000 | (csky_insn.val[0] << 21);
6051           csky_insn.inst |= csky_insn.val[0] << 16;
6052           csky_insn.inst |= (csky_insn.val[1] - 1);
6053           csky_insn.isize = 4;
6054           csky_insn.output = frag_more (4);
6055         }
6056       else
6057         {
6058           csky_show_error (ERROR_OPERANDS_ILLEGAL, 0,
6059                            csky_insn.opcode_end, NULL);
6060           return FALSE;
6061         }
6062     }
6063   else if (csky_insn.number == 3)
6064     {
6065       if (csky_insn.val[0] == 14
6066           && csky_insn.val[1] == 14
6067           && csky_insn.val[2] >= 0 && csky_insn.val[2] <= 0x1fc
6068           && (csky_insn.val[2] & 0x3) == 0
6069           && csky_insn.flag_force != INSN_OPCODE32F)
6070         {
6071           csky_insn.inst = 0x1400 | ((csky_insn.val[2] >> 2) & 0x1f);
6072           csky_insn.inst |= (csky_insn.val[2] << 1) & 0x300;
6073           csky_insn.output = frag_more (2);
6074         }
6075       else if (csky_insn.val[0] < 8
6076                && csky_insn.val[1] == 14
6077                && csky_insn.val[2] >= 0 && csky_insn.val[2] <= 0x3fc
6078                && (csky_insn.val[2] & 0x3) == 0
6079                && csky_insn.flag_force != INSN_OPCODE32F)
6080         {
6081           csky_insn.inst = 0x1800 | (csky_insn.val[0] << 8);
6082           csky_insn.inst |= csky_insn.val[2] >> 2;
6083           csky_insn.output = frag_more (2);
6084         }
6085       else if (csky_insn.val[0] < 8
6086                && csky_insn.val[0] == csky_insn.val[1]
6087                && csky_insn.val[2] >= 1 && csky_insn.val[2] <= 0x100
6088                && csky_insn.flag_force != INSN_OPCODE32F)
6089         {
6090           csky_insn.inst = 0x2000 | (csky_insn.val[0] << 8);
6091           csky_insn.inst |=  (csky_insn.val[2] - 1);
6092           csky_insn.output = frag_more (2);
6093         }
6094       else if (csky_insn.val[0] < 8
6095                && csky_insn.val[1] < 8
6096                && csky_insn.val[2] >= 1 && csky_insn.val[2] <= 0x8
6097                && csky_insn.flag_force != INSN_OPCODE32F)
6098         {
6099           csky_insn.inst = 0x5802 | (csky_insn.val[0] << 5);
6100           csky_insn.inst |= csky_insn.val[1] << 8;
6101           csky_insn.inst |= (csky_insn.val[2] - 1) << 2;
6102           csky_insn.output = frag_more (2);
6103         }
6104       else if (csky_insn.val[1] == 28
6105                && csky_insn.val[2] >= 1 && csky_insn.val[2] <= 0x40000
6106                && csky_insn.flag_force != INSN_OPCODE16F
6107                && !IS_CSKY_ARCH_801 (mach_flag))
6108         {
6109           csky_insn.inst = 0xcc1c0000 | (csky_insn.val[0] << 21);
6110           csky_insn.isize = 4;
6111           csky_insn.output = frag_more (4);
6112           if (insn_reloc == BFD_RELOC_CKCORE_GOTOFF)
6113             {
6114               fix_new_exp (frag_now, csky_insn.output-frag_now->fr_literal,
6115                            4, &csky_insn.e1, 0, BFD_RELOC_CKCORE_GOTOFF_IMM18);
6116             }
6117           else
6118             csky_insn.inst |= (csky_insn.val[2] - 1);
6119         }
6120       else if (csky_insn.val[2] >= 1 && csky_insn.val[2] <= 0x1000
6121                && csky_insn.flag_force != INSN_OPCODE16F
6122                && !IS_CSKY_ARCH_801 (mach_flag))
6123         {
6124           csky_insn.inst = 0xe4000000 | (csky_insn.val[0] << 21);
6125           csky_insn.inst |= csky_insn.val[1] << 16;
6126           csky_insn.inst |= (csky_insn.val[2] - 1);
6127           csky_insn.isize = 4;
6128           csky_insn.output = frag_more (4);
6129         }
6130       else
6131         {
6132           csky_show_error (ERROR_OPERANDS_ILLEGAL, 0,
6133                            (char *)csky_insn.opcode_end, NULL);
6134           return FALSE;
6135         }
6136     }
6137   csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
6138
6139   return TRUE;
6140 }
6141
6142 bfd_boolean
6143 v2_work_subi (void)
6144 {
6145   csky_insn.isize = 2;
6146   if (csky_insn.number == 2)
6147     {
6148       if (csky_insn.val[0] == 14
6149           && csky_insn.val[1] >= 0 && csky_insn.val[2] <= 0x1fc
6150           && (csky_insn.val[1] & 0x3) == 0
6151           && csky_insn.flag_force != INSN_OPCODE32F)
6152         {
6153           csky_insn.inst = 0x1420 | ((csky_insn.val[1] >> 2) & 0x1f);
6154           csky_insn.inst |= (csky_insn.val[1] << 1) & 0x300;
6155         }
6156       else if (csky_insn.val[0] < 8
6157                && csky_insn.val[1] >= 1 && csky_insn.val[1] <= 0x100
6158                && csky_insn.flag_force != INSN_OPCODE32F)
6159         {
6160           csky_insn.inst = 0x2800 | (csky_insn.val[0] << 8);
6161           csky_insn.inst |=  (csky_insn.val[1] - 1);
6162         }
6163       else if (csky_insn.val[1] >= 1 && csky_insn.val[1] <= 0x10000
6164                && csky_insn.flag_force != INSN_OPCODE16F
6165                && !IS_CSKY_ARCH_801 (mach_flag))
6166         {
6167           csky_insn.inst = 0xe4001000 | (csky_insn.val[0] << 21);
6168           csky_insn.inst |= csky_insn.val[0] << 16;
6169           csky_insn.inst |= (csky_insn.val[1] - 1);
6170           csky_insn.isize = 4;
6171         }
6172       else
6173         {
6174           csky_show_error (ERROR_OPERANDS_ILLEGAL, 0,
6175                            (char *)csky_insn.opcode_end, NULL);
6176           return FALSE;
6177         }
6178     }
6179   else if (csky_insn.number == 3)
6180     {
6181       if (csky_insn.val[0] == 14
6182           && csky_insn.val[1] == 14
6183           && csky_insn.val[2] >= 0 && csky_insn.val[2] <= 0x1fc
6184           && (csky_insn.val[2] & 0x3) == 0
6185           && csky_insn.flag_force != INSN_OPCODE32F)
6186         {
6187           csky_insn.inst = 0x1420 | ((csky_insn.val[2] >> 2) & 0x1f);
6188           csky_insn.inst |= (csky_insn.val[2] << 1) & 0x300;
6189         }
6190
6191       else if (csky_insn.val[0] < 8
6192                && csky_insn.val[0] == csky_insn.val[1]
6193                && csky_insn.val[2] >= 1 && csky_insn.val[2] <= 0x100
6194                && csky_insn.flag_force != INSN_OPCODE32F)
6195         {
6196           csky_insn.inst = 0x2800 | (csky_insn.val[0] << 8);
6197           csky_insn.inst |=  (csky_insn.val[2] - 1);
6198         }
6199       else if (csky_insn.val[0] < 8
6200                && csky_insn.val[1] < 8
6201                && csky_insn.val[2] >= 1 && csky_insn.val[2] <= 0x8
6202                && csky_insn.flag_force != INSN_OPCODE32F)
6203         {
6204           csky_insn.inst = 0x5803 | (csky_insn.val[0] << 5);
6205           csky_insn.inst |= csky_insn.val[1] << 8;
6206           csky_insn.inst |= (csky_insn.val[2] - 1) << 2;
6207         }
6208       else if (csky_insn.val[2] >= 1 && csky_insn.val[2] <= 0x1000
6209                && csky_insn.flag_force != INSN_OPCODE16F
6210                && !IS_CSKY_ARCH_801 (mach_flag))
6211         {
6212           csky_insn.inst = 0xe4001000 | (csky_insn.val[0] << 21);
6213           csky_insn.inst |= csky_insn.val[1] << 16;
6214           csky_insn.inst |= (csky_insn.val[2] - 1);
6215           csky_insn.isize = 4;
6216         }
6217       else
6218         {
6219           csky_show_error (ERROR_OPERANDS_ILLEGAL, 0,
6220                            (char *)csky_insn.opcode_end, NULL);
6221           return FALSE;
6222         }
6223     }
6224   csky_insn.output = frag_more (csky_insn.isize);
6225   csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
6226
6227   return TRUE;
6228 }
6229
6230 bfd_boolean
6231 v2_work_add_sub (void)
6232 {
6233   if (csky_insn.number == 3
6234            && (csky_insn.val[0] == csky_insn.val[1]
6235               || csky_insn.val[0] == csky_insn.val[2])
6236            && csky_insn.val[0] <= 15
6237            && csky_insn.val[1] <= 15
6238            && csky_insn.val[2] <= 15)
6239     {
6240       if (!strstr (csky_insn.opcode->mnemonic, "sub")
6241           || csky_insn.val[0] == csky_insn.val[1])
6242         {
6243           csky_insn.opcode_idx = 0;
6244           csky_insn.isize = 2;
6245           if (csky_insn.val[0] == csky_insn.val[1])
6246             csky_insn.val[1] = csky_insn.val[2];
6247
6248           csky_insn.number = 2;
6249
6250         }
6251     }
6252   if (csky_insn.isize == 4
6253       && IS_CSKY_ARCH_801 (mach_flag))
6254     {
6255       if (csky_insn.number == 3)
6256         {
6257           if (csky_insn.val[0] > 7)
6258             csky_show_error (ERROR_REG_OVER_RANGE, 1,
6259                              (void *)(long)csky_insn.val[0], NULL);
6260           if (csky_insn.val[1] > 7)
6261             csky_show_error (ERROR_REG_OVER_RANGE, 2,
6262                              (void *)(long)csky_insn.val[1], NULL);
6263           if (csky_insn.val[2] > 7)
6264             csky_show_error (ERROR_REG_OVER_RANGE, 3,
6265                              (void *)(long)csky_insn.val[2], NULL);
6266         }
6267       else
6268         {
6269           if (csky_insn.val[0] > 15)
6270             csky_show_error (ERROR_REG_OVER_RANGE, 1,
6271                              (void *)(long)csky_insn.val[0], NULL);
6272           if (csky_insn.val[1] > 15)
6273             csky_show_error (ERROR_REG_OVER_RANGE, 2,
6274                              (void *)(long)csky_insn.val[1], NULL);
6275         }
6276       return FALSE;
6277     }
6278   /* sub rz, rx.  */
6279   /* Generate relax or reloc if necessary.  */
6280   csky_generate_frags ();
6281   /* Generate the insn by mask.  */
6282   csky_generate_insn ();
6283   /* Write inst to frag.  */
6284   csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
6285   return TRUE;
6286 }
6287
6288 bfd_boolean
6289 v2_work_rotlc (void)
6290 {
6291   const char *name = "addc";
6292   csky_insn.opcode
6293     = (struct csky_opcode *) hash_find (csky_opcodes_hash, name);
6294   csky_insn.opcode_idx = 0;
6295   if (csky_insn.isize == 2)
6296     {
6297       /* addc rz, rx.  */
6298       csky_insn.number = 2;
6299       csky_insn.val[1] = csky_insn.val[0];
6300     }
6301   else
6302     {
6303       csky_insn.number = 3;
6304       /* addc rz, rx, ry.  */
6305       csky_insn.val[1] = csky_insn.val[0];
6306       csky_insn.val[2] = csky_insn.val[0];
6307     }
6308   /* Generate relax or reloc if necessary.  */
6309   csky_generate_frags ();
6310   /* Generate the insn by mask.  */
6311   csky_generate_insn ();
6312   /* Write inst to frag.  */
6313   csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
6314   return TRUE;
6315 }
6316
6317 bfd_boolean
6318 v2_work_bgeni (void)
6319 {
6320   const char *name = NULL;
6321   int imm = csky_insn.val[1];
6322   int val = 1 << imm;
6323   if (imm < 16)
6324       name = "movi";
6325   else
6326     {
6327       name = "movih";
6328       val >>= 16;
6329     }
6330   csky_insn.opcode
6331     = (struct csky_opcode *) hash_find (csky_opcodes_hash, name);
6332   csky_insn.opcode_idx = 0;
6333   csky_insn.val[1] = val;
6334
6335   /* Generate relax or reloc if necessary.  */
6336   csky_generate_frags ();
6337   /* Generate the insn by mask.  */
6338   csky_generate_insn ();
6339   /* Write inst to frag.  */
6340   csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
6341   return TRUE;
6342 }
6343
6344 bfd_boolean
6345 v2_work_not (void)
6346 {
6347   const char *name = "nor";
6348   csky_insn.opcode
6349     = (struct csky_opcode *) hash_find (csky_opcodes_hash, name);
6350   csky_insn.opcode_idx = 0;
6351   if (csky_insn.number == 1)
6352     {
6353       csky_insn.val[1] = csky_insn.val[0];
6354       if (csky_insn.val[0] < 16)
6355         {
6356           /* 16 bits nor rz, rz.  */
6357           csky_insn.number = 2;
6358           csky_insn.isize = 2;
6359         }
6360       else
6361         {
6362           csky_insn.val[2] = csky_insn.val[0];
6363           csky_insn.number = 3;
6364           csky_insn.isize = 4;
6365         }
6366     }
6367   if (csky_insn.number == 2)
6368     {
6369       if (csky_insn.val[0] == csky_insn.val[1]
6370           && csky_insn.val[0] < 16)
6371         {
6372           /* 16 bits nor rz, rz.  */
6373           csky_insn.number = 2;
6374           csky_insn.isize = 2;
6375         }
6376       else
6377         {
6378           csky_insn.val[2] = csky_insn.val[1];
6379           csky_insn.number = 3;
6380           csky_insn.isize = 4;
6381         }
6382     }
6383
6384   /* Generate relax or reloc if necessary.  */
6385   csky_generate_frags ();
6386   /* Generate the insn by mask.  */
6387   csky_generate_insn ();
6388   /* Write inst to frag.  */
6389   csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
6390   return TRUE;
6391 }
6392
6393 bfd_boolean
6394 v2_work_jbtf (void)
6395 {
6396   if (csky_insn.e1.X_add_symbol == NULL || csky_insn.e1.X_op == O_constant)
6397     {
6398       csky_show_error (ERROR_UNDEFINE, 0, (void *)"operand is invalid", NULL);
6399       return FALSE;
6400     }
6401
6402   if (IS_CSKY_ARCH_801 (mach_flag))
6403     {
6404       /* CK801 doesn't have 32-bit bt/bf insns or a jump insn with a
6405          range larger than SCOND_DISP16.  Relax to a short jump around
6406          an unconditional branch, and give up if that overflows too.  */
6407       csky_insn.output = frag_var (rs_machine_dependent,
6408                                    SCOND_DISP16_LEN,
6409                                    SCOND_DISP10_LEN,
6410                                    SCOND_DISP10,
6411                                    csky_insn.e1.X_add_symbol,
6412                                    csky_insn.e1.X_add_number,
6413                                    0);
6414       csky_insn.isize = 2;
6415       csky_insn.max = SCOND_DISP16_LEN;
6416       csky_insn.inst = csky_insn.opcode->op16[0].opcode;
6417     }
6418   else if (do_long_jump && !IS_CSKY_ARCH_802 (mach_flag))
6419     {
6420       /* Generate relax with jcondition.
6421          Note that CK802 doesn't support the JMPI instruction so
6422          we cannot relax to a jump with a 32-bit offset.  */
6423       csky_insn.output = frag_var (rs_machine_dependent,
6424                                    JCOND_DISP32_LEN,
6425                                    JCOND_DISP10_LEN,
6426                                    JCOND_DISP10,
6427                                    csky_insn.e1.X_add_symbol,
6428                                    csky_insn.e1.X_add_number,
6429                                    0);
6430       csky_insn.isize = 2;
6431       csky_insn.max = JCOND_DISP32_LEN;
6432       csky_insn.inst = csky_insn.opcode->op16[0].opcode;
6433     }
6434   else
6435     {
6436       /* Generate relax with condition.  */
6437       csky_insn.output = frag_var (rs_machine_dependent,
6438                                    COND_DISP16_LEN,
6439                                    COND_DISP10_LEN,
6440                                    COND_DISP10,
6441                                    csky_insn.e1.X_add_symbol,
6442                                    csky_insn.e1.X_add_number,
6443                                    0);
6444       csky_insn.isize = 2;
6445       csky_insn.max = COND_DISP16_LEN;
6446       csky_insn.inst = csky_insn.opcode->op16[0].opcode;
6447     }
6448   csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
6449
6450   return TRUE;
6451 }
6452
6453 bfd_boolean
6454 v2_work_jbr (void)
6455 {
6456   if (csky_insn.e1.X_add_symbol == NULL || csky_insn.e1.X_op == O_constant)
6457     {
6458       csky_show_error (ERROR_UNDEFINE, 0, (void *)"operand is invalid", NULL);
6459       return FALSE;
6460     }
6461
6462   if (do_long_jump
6463       && !IS_CSKY_ARCH_801 (mach_flag)
6464       && !IS_CSKY_ARCH_802 (mach_flag))
6465     {
6466       csky_insn.output = frag_var (rs_machine_dependent,
6467                                    JUNCD_DISP32_LEN,
6468                                    JUNCD_DISP10_LEN,
6469                                    JUNCD_DISP10,
6470                                    csky_insn.e1.X_add_symbol,
6471                                    csky_insn.e1.X_add_number,
6472                                    0);
6473
6474       csky_insn.inst = csky_insn.opcode->op16[0].opcode;
6475       csky_insn.max = JUNCD_DISP32_LEN;
6476       csky_insn.isize = 2;
6477     }
6478   else
6479     {
6480       /* Generate relax with condition.  */
6481       csky_insn.output = frag_var (rs_machine_dependent,
6482                                    UNCD_DISP16_LEN,
6483                                    UNCD_DISP10_LEN,
6484                                    UNCD_DISP10,
6485                                    csky_insn.e1.X_add_symbol,
6486                                    csky_insn.e1.X_add_number,
6487                                    0);
6488       csky_insn.isize = 2;
6489       csky_insn.max = UNCD_DISP16_LEN;
6490       csky_insn.inst = csky_insn.opcode->op16[0].opcode;
6491
6492     }
6493   csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
6494   return TRUE;
6495 }
6496
6497 #define SIZE_V2_MOVI16(x)         ((addressT)x <= 0xff)
6498 #define SIZE_V2_MOVI32(x)         ((addressT)x <= 0xffff)
6499 #define SIZE_V2_MOVIH(x)          ((addressT)x <= 0xffffffff && (((addressT)x & 0xffff) == 0))
6500
6501 bfd_boolean
6502 v2_work_lrw (void)
6503 {
6504   int reg = csky_insn.val[0];
6505   int output_literal = csky_insn.val[1];
6506   int is_done = 0;
6507
6508   /* If the second operand is O_constant, We can use movi/movih
6509      instead of lrw.  */
6510   if (csky_insn.e1.X_op == O_constant)
6511     {
6512       /* 801 only has movi16.  */
6513       if (SIZE_V2_MOVI16 (csky_insn.e1.X_add_number) && reg < 8)
6514         {
6515           /* movi16 instead.  */
6516           csky_insn.output = frag_more (2);
6517           csky_insn.inst = (CSKYV2_INST_MOVI16 | (reg << 8)
6518                             | (csky_insn.e1.X_add_number));
6519           csky_insn.isize = 2;
6520           is_done = 1;
6521         }
6522       else if (SIZE_V2_MOVI32 (csky_insn.e1.X_add_number)
6523                && !IS_CSKY_ARCH_801 (mach_flag))
6524         {
6525           /* movi32 instead.  */
6526           csky_insn.output = frag_more (4);
6527           csky_insn.inst = (CSKYV2_INST_MOVI32 | (reg << 16)
6528                             | (csky_insn.e1.X_add_number));
6529           csky_insn.isize = 4;
6530           is_done = 1;
6531         }
6532       else if (SIZE_V2_MOVIH (csky_insn.e1.X_add_number)
6533                && !IS_CSKY_ARCH_801 (mach_flag))
6534         {
6535           /* movih instead.  */
6536           csky_insn.output = frag_more (4);
6537           csky_insn.inst = (CSKYV2_INST_MOVIH | (reg << 16)
6538                             | ((csky_insn.e1.X_add_number >> 16) & 0xffff));
6539           csky_insn.isize = 4;
6540           is_done = 1;
6541         }
6542     }
6543
6544   if (is_done)
6545     {
6546       csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
6547       return TRUE;
6548     }
6549
6550   if (output_literal)
6551     {
6552       int n = enter_literal (&csky_insn.e1, 0, 0, 0);
6553       /* Create a reference to pool entry.  */
6554       csky_insn.e1.X_op = O_symbol;
6555       csky_insn.e1.X_add_symbol = poolsym;
6556       csky_insn.e1.X_add_number = n << 2;
6557     }
6558   /* If 16bit force.  */
6559   if (csky_insn.flag_force == INSN_OPCODE16F)
6560     {
6561       /* Generate fixup.  */
6562       if (reg > 7)
6563         {
6564           csky_show_error (ERROR_UNDEFINE, 0,
6565                            (void *)"The register is out of range.", NULL);
6566           return FALSE;
6567         }
6568       csky_insn.isize = 2;
6569       csky_insn.output = frag_more (2);
6570
6571       if (insn_reloc == BFD_RELOC_CKCORE_TLS_GD32
6572           || insn_reloc == BFD_RELOC_CKCORE_TLS_LDM32
6573           || insn_reloc == BFD_RELOC_CKCORE_TLS_IE32)
6574         {
6575           literal_insn_offset->tls_addend.frag = frag_now;
6576           literal_insn_offset->tls_addend.offset
6577             = csky_insn.output - frag_now->fr_literal;
6578         }
6579       csky_insn.inst = csky_insn.opcode->op16[0].opcode | (reg << 5);
6580       csky_insn.max = 4;
6581       fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
6582                    2, &csky_insn.e1, 1, BFD_RELOC_CKCORE_PCREL_IMM7BY4);
6583     }
6584   else if (csky_insn.flag_force == INSN_OPCODE32F)
6585     {
6586       csky_insn.isize = 4;
6587       csky_insn.output = frag_more (4);
6588       if (insn_reloc == BFD_RELOC_CKCORE_TLS_GD32
6589           || insn_reloc == BFD_RELOC_CKCORE_TLS_LDM32
6590           || insn_reloc == BFD_RELOC_CKCORE_TLS_IE32)
6591        {
6592           literal_insn_offset->tls_addend.frag = frag_now;
6593           literal_insn_offset->tls_addend.offset
6594             = csky_insn.output - frag_now->fr_literal;
6595        }
6596       csky_insn.inst = csky_insn.opcode->op32[0].opcode | (reg << 16);
6597       fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
6598                    4, &csky_insn.e1, 1, BFD_RELOC_CKCORE_PCREL_IMM16BY4);
6599     }
6600   else if (!is_done)
6601     {
6602       if (reg < 8)
6603         {
6604           csky_insn.isize = 2;
6605
6606           if (insn_reloc == BFD_RELOC_CKCORE_TLS_GD32
6607               || insn_reloc == BFD_RELOC_CKCORE_TLS_LDM32
6608               || insn_reloc == BFD_RELOC_CKCORE_TLS_IE32)
6609             literal_insn_offset->tls_addend.frag = frag_now;
6610
6611           csky_insn.output = frag_var (rs_machine_dependent,
6612                                        LRW_DISP16_LEN,
6613                                        LRW_DISP7_LEN,
6614                                        (do_extend_lrw
6615                                         ? LRW2_DISP8 : LRW_DISP7),
6616                                        csky_insn.e1.X_add_symbol,
6617                                        csky_insn.e1.X_add_number, 0);
6618           if (insn_reloc == BFD_RELOC_CKCORE_TLS_GD32
6619               || insn_reloc == BFD_RELOC_CKCORE_TLS_LDM32
6620               || insn_reloc == BFD_RELOC_CKCORE_TLS_IE32)
6621             {
6622               if (literal_insn_offset->tls_addend.frag->fr_next != frag_now)
6623                 literal_insn_offset->tls_addend.frag
6624                   = literal_insn_offset->tls_addend.frag->fr_next;
6625               literal_insn_offset->tls_addend.offset
6626                 = (csky_insn.output
6627                    - literal_insn_offset->tls_addend.frag->fr_literal);
6628             }
6629           csky_insn.inst = csky_insn.opcode->op16[0].opcode | (reg << 5);
6630           csky_insn.max = LRW_DISP16_LEN;
6631           csky_insn.isize = 2;
6632         }
6633       else
6634         {
6635           csky_insn.isize = 4;
6636           csky_insn.output = frag_more (4);
6637           if (insn_reloc == BFD_RELOC_CKCORE_TLS_GD32
6638               || insn_reloc == BFD_RELOC_CKCORE_TLS_LDM32
6639               || insn_reloc == BFD_RELOC_CKCORE_TLS_IE32)
6640            {
6641               literal_insn_offset->tls_addend.frag = frag_now;
6642               literal_insn_offset->tls_addend.offset
6643                 = csky_insn.output - frag_now->fr_literal;
6644            }
6645           csky_insn.inst = csky_insn.opcode->op32[0].opcode | (reg << 16);
6646           fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
6647                        4, &csky_insn.e1, 1, BFD_RELOC_CKCORE_PCREL_IMM16BY4);
6648        }
6649     }
6650
6651   csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
6652   return TRUE;
6653 }
6654
6655 bfd_boolean
6656 v2_work_lrsrsw (void)
6657 {
6658   int reg = csky_insn.val[0];
6659   csky_insn.output = frag_more (4);
6660   csky_insn.inst = csky_insn.opcode->op32[0].opcode | (reg << 21);
6661   csky_insn.isize = 4;
6662
6663   switch (insn_reloc)
6664     {
6665       case BFD_RELOC_CKCORE_GOT32:
6666         fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
6667                      4, &csky_insn.e1, 0, BFD_RELOC_CKCORE_GOT_IMM18BY4);
6668         break;
6669       case BFD_RELOC_CKCORE_PLT32:
6670         fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
6671                      4, &csky_insn.e1, 0, BFD_RELOC_CKCORE_PLT_IMM18BY4);
6672         break;
6673       default:
6674         fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
6675                      4, &csky_insn.e1, 1, BFD_RELOC_CKCORE_DOFFSET_IMM18BY4);
6676         break;
6677     }
6678   csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
6679   return TRUE;
6680 }
6681
6682 bfd_boolean
6683 v2_work_jbsr (void)
6684 {
6685   if (do_force2bsr
6686       || IS_CSKY_ARCH_801 (mach_flag)
6687       || IS_CSKY_ARCH_802 (mach_flag))
6688     {
6689       csky_insn.output = frag_more (4);
6690       fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
6691                    4, &csky_insn.e1, 1, BFD_RELOC_CKCORE_PCREL_IMM26BY2);
6692       csky_insn.isize = 4;
6693       csky_insn.inst = CSKYV2_INST_BSR32;
6694     }
6695   else
6696     {
6697       int n = enter_literal (&csky_insn.e1, 0, 0, 0);
6698       csky_insn.output = frag_more (4);
6699       csky_insn.e1.X_op = O_symbol;
6700       csky_insn.e1.X_add_symbol = poolsym;
6701       csky_insn.e1.X_add_number = n << 2;
6702       fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
6703                  4, &csky_insn.e1, 1, BFD_RELOC_CKCORE_PCREL_IMM16BY4);
6704       if (do_jsri2bsr || IS_CSKY_ARCH_810 (mach_flag))
6705         fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
6706                      4,
6707                      &(litpool + (csky_insn.e1.X_add_number >> 2))->e,
6708                      1,
6709                      BFD_RELOC_CKCORE_PCREL_JSR_IMM26BY2);
6710       csky_insn.inst = CSKYV2_INST_JSRI32;
6711       csky_insn.isize = 4;
6712       if (IS_CSKY_ARCH_810 (mach_flag))
6713         {
6714           csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
6715           csky_insn.output = frag_more (4);
6716           dwarf2_emit_insn (0);
6717           /* Insert "mov r0, r0".  */
6718           csky_insn.inst = CSKYV2_INST_MOV_R0_R0;
6719           csky_insn.max = 8;
6720         }
6721     }
6722   csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
6723
6724   return TRUE;
6725 }
6726
6727 bfd_boolean
6728 v2_work_jsri (void)
6729 {
6730   /* dump literal.  */
6731   int n = enter_literal (&csky_insn.e1, 1, 0, 0);
6732   csky_insn.e1.X_op = O_symbol;
6733   csky_insn.e1.X_add_symbol = poolsym;
6734   csky_insn.e1.X_add_number = n << 2;
6735
6736   /* Generate relax or reloc if necessary.  */
6737   csky_generate_frags ();
6738   /* Generate the insn by mask.  */
6739   csky_generate_insn ();
6740   /* Write inst to frag.  */
6741   csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
6742   /* Control 810 not to generate jsri.  */
6743   if (IS_CSKY_ARCH_810 (mach_flag))
6744     {
6745       /* Look at adding the R_PCREL_JSRIMM26BY2.
6746          For 'jbsr .L1', this reloc type's symbol
6747          is bound to '.L1', isn't bound to literal pool.  */
6748       fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
6749                    4, &(litpool + (csky_insn.e1.X_add_number >> 2))->e, 1,
6750                    BFD_RELOC_CKCORE_PCREL_JSR_IMM26BY2);
6751       csky_insn.output = frag_more (4);
6752       dwarf2_emit_insn (0);
6753       /* The opcode of "mov32 r0,r0".  */
6754       csky_insn.inst = CSKYV2_INST_MOV_R0_R0;
6755       /* The effect of this value is to check literal.  */
6756       csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
6757       csky_insn.max = 8;
6758     }
6759   return TRUE;
6760 }
6761
6762 bfd_boolean
6763 v2_work_movih (void)
6764 {
6765   int rz = csky_insn.val[0];
6766   csky_insn.output = frag_more (4);
6767   csky_insn.inst = csky_insn.opcode->op32[0].opcode | (rz << 16);
6768   if (csky_insn.e1.X_op == O_constant)
6769     {
6770       if (csky_insn.e1.X_unsigned == 1 && csky_insn.e1.X_add_number > 0xffff)
6771         {
6772           csky_show_error (ERROR_IMM_OVERFLOW, 2, NULL, NULL);
6773           return FALSE;
6774         }
6775       else if (csky_insn.e1.X_unsigned == 0 && csky_insn.e1.X_add_number < 0)
6776         {
6777           csky_show_error (ERROR_IMM_OVERFLOW, 2, NULL, NULL);
6778           return FALSE;
6779         }
6780       else
6781         csky_insn.inst |= (csky_insn.e1.X_add_number & 0xffff);
6782     }
6783   else if (csky_insn.e1.X_op == O_right_shift
6784            || (csky_insn.e1.X_op == O_symbol && insn_reloc != BFD_RELOC_NONE))
6785     {
6786       if (csky_insn.e1.X_op_symbol != 0
6787           && symbol_constant_p (csky_insn.e1.X_op_symbol)
6788           && S_GET_SEGMENT (csky_insn.e1.X_op_symbol) == absolute_section
6789           && 16 == S_GET_VALUE (csky_insn.e1.X_op_symbol))
6790         {
6791           csky_insn.e1.X_op = O_symbol;
6792           if (insn_reloc == BFD_RELOC_CKCORE_GOT32)
6793             insn_reloc = BFD_RELOC_CKCORE_GOT_HI16;
6794           else if (insn_reloc == BFD_RELOC_CKCORE_PLT32)
6795             insn_reloc = BFD_RELOC_CKCORE_PLT_HI16;
6796           else if (insn_reloc == BFD_RELOC_CKCORE_GOTPC)
6797             insn_reloc = BFD_RELOC_CKCORE_GOTPC_HI16;
6798           else if (insn_reloc == BFD_RELOC_CKCORE_GOTOFF)
6799             insn_reloc = BFD_RELOC_CKCORE_GOTOFF_HI16;
6800           else
6801             insn_reloc = BFD_RELOC_CKCORE_ADDR_HI16;
6802           fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
6803                        4, &csky_insn.e1, 0, insn_reloc);
6804         }
6805       else
6806         {
6807           void *arg = (void *)"the second operand must be \"SYMBOL >> 16\"";
6808           csky_show_error (ERROR_UNDEFINE, 0, arg, NULL);
6809           return FALSE;
6810         }
6811     }
6812   csky_insn.isize = 4;
6813   csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
6814
6815   return TRUE;
6816 }
6817
6818 bfd_boolean
6819 v2_work_ori (void)
6820 {
6821   int rz = csky_insn.val[0];
6822   int rx = csky_insn.val[1];
6823   csky_insn.output = frag_more (4);
6824   csky_insn.inst = csky_insn.opcode->op32[0].opcode | (rz << 21) | (rx << 16);
6825   if (csky_insn.e1.X_op == O_constant)
6826     {
6827       if (csky_insn.e1.X_add_number <= 0xffff
6828           && csky_insn.e1.X_add_number >= 0)
6829         csky_insn.inst |= csky_insn.e1.X_add_number;
6830       else
6831         {
6832           csky_show_error (ERROR_IMM_OVERFLOW, 3, NULL, NULL);
6833           return FALSE;
6834         }
6835     }
6836   else if (csky_insn.e1.X_op == O_bit_and)
6837     {
6838       if (symbol_constant_p (csky_insn.e1.X_op_symbol)
6839           && S_GET_SEGMENT (csky_insn.e1.X_op_symbol) == absolute_section
6840           && 0xffff == S_GET_VALUE (csky_insn.e1.X_op_symbol))
6841         {
6842           csky_insn.e1.X_op = O_symbol;
6843           if (insn_reloc == BFD_RELOC_CKCORE_GOT32)
6844             insn_reloc = BFD_RELOC_CKCORE_GOT_LO16;
6845           else if (insn_reloc == BFD_RELOC_CKCORE_PLT32)
6846             insn_reloc = BFD_RELOC_CKCORE_PLT_LO16;
6847           else if (insn_reloc == BFD_RELOC_CKCORE_GOTPC)
6848             insn_reloc = BFD_RELOC_CKCORE_GOTPC_LO16;
6849           else if (insn_reloc == BFD_RELOC_CKCORE_GOTOFF)
6850             insn_reloc = BFD_RELOC_CKCORE_GOTOFF_LO16;
6851           else
6852             insn_reloc = BFD_RELOC_CKCORE_ADDR_LO16;
6853           fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
6854                        4, &csky_insn.e1, 0, insn_reloc);
6855         }
6856       else
6857         {
6858           void *arg = (void *)"the third operand must be \"SYMBOL & 0xffff\"";
6859           csky_show_error (ERROR_UNDEFINE, 0, arg, NULL);
6860           return FALSE;
6861         }
6862     }
6863   csky_insn.isize = 4;
6864   csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
6865   return TRUE;
6866 }
6867
6868 /* Helper function to encode a single/double floating point constant
6869    into the instruction word for fmovis and fmovid instructions.
6870    The constant is in its IEEE single/double precision representation
6871    and is repacked into the internal 13-bit representation for these
6872    instructions with a diagnostic for overflow.  Note that there is no
6873    rounding when converting to the smaller format, just an error if there
6874    is excess precision or the number is too small/large to be represented.  */
6875
6876 bfd_boolean
6877 float_work_fmovi (void)
6878 {
6879   int rx = csky_insn.val[0];
6880
6881   /* We already converted the float constant to the internal 13-bit
6882      representation so we just need to OR it in here.  */
6883   csky_insn.inst = csky_insn.opcode->op32[0].opcode | rx;
6884   csky_insn.inst |= (uint32_t) csky_insn.e1.X_add_number;
6885
6886   csky_insn.output = frag_more (4);
6887   csky_insn.isize = 4;
6888   csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
6889   return TRUE;
6890 }
6891
6892 bfd_boolean
6893 dsp_work_bloop (void)
6894 {
6895   int reg = csky_insn.val[0];
6896   csky_insn.output = frag_more (4);
6897   csky_insn.inst = csky_insn.opcode->op32[0].opcode | (reg << 16);
6898   csky_insn.isize = 4;
6899
6900   if (csky_insn.e1.X_op == O_symbol
6901       && csky_insn.e2.X_op == O_symbol)
6902     {
6903         fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
6904                      4, &csky_insn.e1, 1,
6905                      BFD_RELOC_CKCORE_PCREL_BLOOP_IMM12BY4);
6906         fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
6907                      4, &csky_insn.e2, 1,
6908                      BFD_RELOC_CKCORE_PCREL_BLOOP_IMM4BY4);
6909     }
6910
6911   csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
6912   return TRUE;
6913 }
6914
6915
6916 /* The following are for assembler directive handling.  */
6917
6918 /* Helper function to adjust constant pool counts when we emit a
6919    data directive in the text section.  FUNC is one of the standard
6920    gas functions to handle these directives, like "stringer" for the
6921    .string directive, and ARG is the argument to FUNC.  csky_pool_count
6922    essentially wraps the call with the constant pool magic.  */
6923
6924 static void
6925 csky_pool_count (void (*func) (int), int arg)
6926 {
6927   const fragS *curr_frag = frag_now;
6928   offsetT added = -frag_now_fix_octets ();
6929
6930   (*func) (arg);
6931
6932   while (curr_frag != frag_now)
6933     {
6934       added += curr_frag->fr_fix;
6935       curr_frag = curr_frag->fr_next;
6936     }
6937
6938   added += frag_now_fix_octets ();
6939   poolspan += added;
6940 }
6941
6942 /* Support the .literals directive.  */
6943 static void
6944 csky_s_literals (int ignore ATTRIBUTE_UNUSED)
6945 {
6946   dump_literals (0);
6947   demand_empty_rest_of_line ();
6948 }
6949
6950 /* Support the .string, etc directives.  */
6951 static void
6952 csky_stringer (int append_zero)
6953 {
6954   if (now_seg == text_section)
6955     csky_pool_count (stringer, append_zero);
6956   else
6957     stringer (append_zero);
6958
6959   /* We call check_literals here in case a large number of strings are
6960      being placed into the text section with a sequence of stringer
6961      directives.  In theory we could be upsetting something if these
6962      strings are actually in an indexed table instead of referenced by
6963      individual labels.  Let us hope that that never happens.  */
6964   check_literals (2, 0);
6965 }
6966
6967 /* Support integer-mode constructors like .word, .byte, etc.  */
6968
6969 static void
6970 csky_cons (int nbytes)
6971 {
6972   mapping_state (MAP_DATA);
6973   if (nbytes == 4)  /* @GOT.  */
6974     {
6975       do
6976         {
6977           bfd_reloc_code_real_type reloc;
6978           expressionS exp;
6979
6980           reloc = BFD_RELOC_NONE;
6981           expression (&exp);
6982           lex_got (&reloc, NULL);
6983
6984           if (exp.X_op == O_symbol && reloc != BFD_RELOC_NONE)
6985             {
6986               reloc_howto_type *howto
6987                 = bfd_reloc_type_lookup (stdoutput, reloc);
6988               int size = bfd_get_reloc_size (howto);
6989
6990               if (size > nbytes)
6991                 as_bad (ngettext ("%s relocations do not fit in %d byte",
6992                                   "%s relocations do not fit in %d bytes",
6993                                   nbytes),
6994                         howto->name, nbytes);
6995               else
6996                 {
6997                   register char *p = frag_more ((int) nbytes);
6998                   int offset = nbytes - size;
6999
7000                   fix_new_exp (frag_now,
7001                                p - frag_now->fr_literal + offset,
7002                                size, &exp, 0, reloc);
7003                 }
7004             }
7005           else
7006             emit_expr (&exp, (unsigned int) nbytes);
7007           if (now_seg == text_section)
7008             poolspan += nbytes;
7009         }
7010       while (*input_line_pointer++ == ',');
7011
7012       /* Put terminator back into stream.  */
7013       input_line_pointer --;
7014       demand_empty_rest_of_line ();
7015
7016       return;
7017     }
7018
7019   if (now_seg == text_section)
7020     csky_pool_count (cons, nbytes);
7021   else
7022     cons (nbytes);
7023
7024   /* In theory we ought to call check_literals (2,0) here in case
7025      we need to dump the literal table.  We cannot do this however,
7026      as the directives that we are intercepting may be being used
7027      to build a switch table, and we must not interfere with its
7028      contents.  Instead we cross our fingers and pray...  */
7029 }
7030
7031 /* Support floating-mode constant directives like .float and .double.  */
7032
7033 static void
7034 csky_float_cons (int float_type)
7035 {
7036   mapping_state (MAP_DATA);
7037   if (now_seg == text_section)
7038     csky_pool_count (float_cons, float_type);
7039   else
7040     float_cons (float_type);
7041
7042   /* See the comment in csky_cons () about calling check_literals.
7043      It is unlikely that a switch table will be constructed using
7044      floating point values, but it is still likely that an indexed
7045      table of floating point constants is being created by these
7046      directives, so again we must not interfere with their placement.  */
7047 }
7048
7049 /* Support the .fill directive.  */
7050
7051 static void
7052 csky_fill (int ignore)
7053 {
7054   if (now_seg == text_section)
7055     csky_pool_count (s_fill, ignore);
7056   else
7057     s_fill (ignore);
7058
7059   check_literals (2, 0);
7060 }
7061
7062 /* Handle the section changing pseudo-ops.  These call through to the
7063    normal implementations, but they dump the literal pool first.  */
7064
7065 static void
7066 csky_s_text (int ignore)
7067 {
7068   dump_literals (0);
7069
7070 #ifdef OBJ_ELF
7071   obj_elf_text (ignore);
7072 #else
7073   s_text (ignore);
7074 #endif
7075 }
7076
7077 static void
7078 csky_s_data (int ignore)
7079 {
7080   dump_literals (0);
7081
7082 #ifdef OBJ_ELF
7083   obj_elf_data (ignore);
7084 #else
7085   s_data (ignore);
7086 #endif
7087 }
7088
7089 static void
7090 csky_s_section (int ignore)
7091 {
7092   /* Scan forwards to find the name of the section.  If the section
7093      being switched to is ".line" then this is a DWARF1 debug section
7094      which is arbitrarily placed inside generated code.  In this case
7095      do not dump the literal pool because it is a) inefficient and
7096      b) would require the generation of extra code to jump around the
7097      pool.  */
7098   char * ilp = input_line_pointer;
7099
7100   while (*ilp != 0 && ISSPACE (*ilp))
7101     ++ ilp;
7102
7103   if (strncmp (ilp, ".line", 5) == 0
7104       && (ISSPACE (ilp[5]) || *ilp == '\n' || *ilp == '\r'))
7105     ;
7106   else
7107     dump_literals (0);
7108
7109 #ifdef OBJ_ELF
7110   obj_elf_section (ignore);
7111 #endif
7112 #ifdef OBJ_COFF
7113   obj_coff_section (ignore);
7114 #endif
7115 }
7116
7117 static void
7118 csky_s_bss (int needs_align)
7119 {
7120   dump_literals (0);
7121   s_lcomm_bytes (needs_align);
7122 }
7123
7124 #ifdef OBJ_ELF
7125 static void
7126 csky_s_comm (int needs_align)
7127 {
7128   dump_literals (0);
7129   obj_elf_common (needs_align);
7130 }
7131 #endif
7132
7133 /* Handle the .no_literal_dump directive.  */
7134
7135 static void
7136 csky_noliteraldump (int ignore ATTRIBUTE_UNUSED)
7137 {
7138   do_noliteraldump = 1;
7139   int insn_num = get_absolute_expression ();
7140   /* The insn after '.no_literal_dump insn_num' is insn1,
7141      Don't dump literal pool between insn1 and insn(insn_num+1)
7142      The insn cannot be the insn generate literal, like lrw & jsri.  */
7143   check_literals (0, insn_num * 2);
7144 }
7145
7146 /* Handle the .align directive.
7147    We must check literals before doing alignment.  For example, if
7148    '.align n', add (2^n-1) to poolspan and check literals.  */
7149
7150 static void
7151 csky_s_align_ptwo (int arg)
7152 {
7153   /* Get the .align's first absolute number.  */
7154   char * temp_pointer = input_line_pointer;
7155   int align = get_absolute_expression ();
7156   check_literals (0, (1 << align) - 1);
7157   input_line_pointer = temp_pointer;
7158
7159   /* Do alignment.  */
7160   s_align_ptwo (arg);
7161 }
7162
7163 /* Handle the .stack_size directive.  */
7164
7165 static void
7166 csky_stack_size (int arg ATTRIBUTE_UNUSED)
7167 {
7168   expressionS exp;
7169   stack_size_entry *sse
7170     = (stack_size_entry *) xcalloc (1, sizeof (stack_size_entry));
7171
7172   expression (&exp);
7173   if (exp.X_op == O_symbol)
7174     sse->function = exp.X_add_symbol;
7175   else
7176     {
7177       as_bad (_("the first operand must be a symbol"));
7178       ignore_rest_of_line ();
7179       free (sse);
7180       return;
7181     }
7182
7183   SKIP_WHITESPACE ();
7184   if (*input_line_pointer != ',')
7185     {
7186       as_bad (_("missing stack size"));
7187       ignore_rest_of_line ();
7188       free (sse);
7189       return;
7190     }
7191
7192   ++input_line_pointer;
7193   expression (&exp);
7194   if (exp.X_op == O_constant)
7195     {
7196       if (exp.X_add_number < 0 || exp.X_add_number > (offsetT)0xffffffff)
7197         {
7198
7199           as_bad (_("value not in range [0, 0xffffffff]"));
7200           ignore_rest_of_line ();
7201           free (sse);
7202           return;
7203         }
7204       else
7205         sse->stack_size = exp.X_add_number;
7206     }
7207   else
7208     {
7209       as_bad (_("operand must be a constant"));
7210       ignore_rest_of_line ();
7211       free (sse);
7212       return;
7213     }
7214
7215   if (*last_stack_size_data != NULL)
7216     last_stack_size_data = &((*last_stack_size_data)->next);
7217
7218   *last_stack_size_data = sse;
7219 }
7220
7221 /* This table describes all the machine specific pseudo-ops the assembler
7222    has to support.  The fields are:
7223      pseudo-op name without dot
7224      function to call to execute this pseudo-op
7225      Integer arg to pass to the function.  */
7226
7227 const pseudo_typeS md_pseudo_table[] =
7228 {
7229   { "export",   s_globl,          0 },
7230   { "import",   s_ignore,         0 },
7231   { "literals", csky_s_literals, 0 },
7232   { "page",     listing_eject,    0 },
7233
7234   /* The following are to intercept the placement of data into the text
7235      section (eg addresses for a switch table), so that the space they
7236      occupy can be taken into account when deciding whether or not to
7237      dump the current literal pool.
7238      XXX - currently we do not cope with the .space and .dcb.d directives.  */
7239   { "ascii",    csky_stringer,       8 + 0 },
7240   { "asciz",    csky_stringer,       8 + 1 },
7241   { "byte",     csky_cons,           1 },
7242   { "dc",       csky_cons,           2 },
7243   { "dc.b",     csky_cons,           1 },
7244   { "dc.d",     csky_float_cons,    'd'},
7245   { "dc.l",     csky_cons,           4 },
7246   { "dc.s",     csky_float_cons,    'f'},
7247   { "dc.w",     csky_cons,           2 },
7248   { "dc.x",     csky_float_cons,    'x'},
7249   { "double",   csky_float_cons,    'd'},
7250   { "float",    csky_float_cons,    'f'},
7251   { "hword",    csky_cons,           2 },
7252   { "int",      csky_cons,           4 },
7253   { "long",     csky_cons,           4 },
7254   { "octa",     csky_cons,          16 },
7255   { "quad",     csky_cons,           8 },
7256   { "short",    csky_cons,           2 },
7257   { "single",   csky_float_cons,    'f'},
7258   { "string",   csky_stringer,       8 + 1 },
7259   { "word",     csky_cons,           4 },
7260   { "fill",     csky_fill,           0 },
7261
7262   /* Allow for the effect of section changes.  */
7263   { "text",      csky_s_text,    0 },
7264   { "data",      csky_s_data,    0 },
7265   { "bss",       csky_s_bss,     1 },
7266 #ifdef OBJ_ELF
7267   { "comm",      csky_s_comm,    0 },
7268 #endif
7269   { "section",   csky_s_section, 0 },
7270   { "section.s", csky_s_section, 0 },
7271   { "sect",      csky_s_section, 0 },
7272   { "sect.s",    csky_s_section, 0 },
7273   /* When ".no_literal_dump N" is in front of insn1,
7274      and instruction sequence is:
7275        insn1
7276        insn2
7277        ......
7278        insnN+1
7279      it means literals will not dump between insn1 and insnN+1
7280      The insn cannot itself generate literal, like lrw & jsri.  */
7281   { "no_literal_dump",  csky_noliteraldump,     0 },
7282   { "align",            csky_s_align_ptwo,       0 },
7283   { "stack_size",       csky_stack_size,         0 },
7284   {0,       0,            0}
7285 };
7286
7287 /* Implement tc_cfi_frame_initial_instructions.  */
7288
7289 void
7290 csky_cfi_frame_initial_instructions (void)
7291 {
7292   int sp_reg = IS_CSKY_V1 (mach_flag) ? 0 : 14;
7293   cfi_add_CFA_def_cfa_register (sp_reg);
7294 }
7295
7296 /* Implement tc_regname_to_dw2regnum.  */
7297
7298 int
7299 tc_csky_regname_to_dw2regnum (char *regname)
7300 {
7301   int reg_num = -1;
7302   int len;
7303
7304   /* FIXME the reg should be parsed according to
7305      the abi version.  */
7306   reg_num = csky_get_reg_val (regname, &len);
7307   return reg_num;
7308 }