gas/config/tc-score.c

   1 /* tc-score.c -- Assembler for Score
   2    Copyright 2006, 2007 Free Software Foundation, Inc.
   3    Contributed by:
   4    Mei Ligang (ligang@sunnorth.com.cn)
   5    Pei-Lin Tsai (pltsai@sunplus.com)
   6
   7    This file is part of GAS, the GNU Assembler.
   8
   9    GAS is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3, or (at your option)
  12    any later version.
  13
  14    GAS is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with GAS; see the file COPYING.  If not, write to the Free
  21    Software Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  22    02110-1301, USA.  */
  23
  24 #include "as.h"
  25 #include "config.h"
  26 #include "subsegs.h"
  27 #include "safe-ctype.h"
  28 #include "opcode/score-inst.h"
  29 #include "opcode/score-datadep.h"
  30 #include "struc-symbol.h"
  31
  32 #ifdef OBJ_ELF
  33 #include "elf/score.h"
  34 #include "dwarf2dbg.h"
  35 #endif
  36
  37 #define GP                     28
  38 #define PIC_CALL_REG           29
  39 #define MAX_LITERAL_POOL_SIZE  1024
  40 #define FAIL                   0x80000000
  41 #define SUCCESS         0
  42 #define INSN_SIZE       4
  43 #define INSN16_SIZE     2
  44 #define RELAX_INST_NUM  3
  45
  46 /* For score5u : div/mul will pop warning message, mmu/alw/asw will pop error message.  */
  47 #define BAD_ARGS                  _("bad arguments to instruction")
  48 #define BAD_PC                    _("r15 not allowed here")
  49 #define BAD_COND                  _("instruction is not conditional")
  50 #define ERR_NO_ACCUM              _("acc0 expected")
  51 #define ERR_FOR_SCORE5U_MUL_DIV   _("div / mul are reserved instructions")
  52 #define ERR_FOR_SCORE5U_MMU       _("This architecture doesn't support mmu")
  53 #define ERR_FOR_SCORE5U_ATOMIC    _("This architecture doesn't support atomic instruction")
  54 #define LONG_LABEL_LEN            _("the label length is longer than 1024");
  55 #define BAD_SKIP_COMMA            BAD_ARGS
  56 #define BAD_GARBAGE               _("garbage following instruction");
  57
  58 #define skip_whitespace(str)  while (*(str) == ' ') ++(str)
  59
  60 /* The name of the readonly data section.  */
  61 #define RDATA_SECTION_NAME (OUTPUT_FLAVOR == bfd_target_aout_flavour \
  62                             ? ".data" \
  63                             : OUTPUT_FLAVOR == bfd_target_ecoff_flavour \
  64                             ? ".rdata" \
  65                             : OUTPUT_FLAVOR == bfd_target_coff_flavour \
  66                             ? ".rdata" \
  67                             : OUTPUT_FLAVOR == bfd_target_elf_flavour \
  68                             ? ".rodata" \
  69                             : (abort (), ""))
  70
  71 #define RELAX_ENCODE(old, new, type, reloc1, reloc2, opt) \
  72   ((relax_substateT) \
  73    (((old) << 23) \
  74     | ((new) << 16) \
  75     | ((type) << 9) \
  76     | ((reloc1) << 5) \
  77     | ((reloc2) << 1) \
  78     | ((opt) ? 1 : 0)))
  79
  80 #define RELAX_OLD(i)       (((i) >> 23) & 0x7f)
  81 #define RELAX_NEW(i)       (((i) >> 16) & 0x7f)
  82 #define RELAX_TYPE(i)      (((i) >> 9) & 0x7f)
  83 #define RELAX_RELOC1(i)    ((valueT) ((i) >> 5) & 0xf)
  84 #define RELAX_RELOC2(i)    ((valueT) ((i) >> 1) & 0xf)
  85 #define RELAX_OPT(i)       ((i) & 1)
  86 #define RELAX_OPT_CLEAR(i) ((i) & ~1)
  87
  88 #define SET_INSN_ERROR(s) (inst.error = (s))
  89 #define INSN_IS_PCE_P(s)  (strstr (str, "||") != NULL)
  90
  91 #define GET_INSN_CLASS(type) (get_insn_class_from_type (type))
  92
  93 #define GET_INSN_SIZE(type) ((GET_INSN_CLASS (type) == INSN_CLASS_16) \
  94                              ? INSN16_SIZE : INSN_SIZE)
  95
  96 /* This array holds the chars that always start a comment.  If the
  97    pre-processor is disabled, these aren't very useful.  */
  98 const char comment_chars[] = "#";
  99 const char line_comment_chars[] = "#";
 100 const char line_separator_chars[] = ";";
 101
 102 /* Chars that can be used to separate mant from exp in floating point numbers.  */
 103 const char EXP_CHARS[] = "eE";
 104 const char FLT_CHARS[] = "rRsSfFdDxXeEpP";
 105
 106 /* Used to contain constructed error messages.  */
 107 static char err_msg[255];
 108
 109 fragS *score_fragp = 0;
 110 static int fix_data_dependency = 0;
 111 static int warn_fix_data_dependency = 1;
 112 static int score7 = 1;
 113 static int university_version = 0;
 114
 115 static int in_my_get_expression = 0;
 116
 117 #define USE_GLOBAL_POINTER_OPT 1
 118 #define SCORE_BI_ENDIAN
 119
 120 /* Default, pop warning message when using r1.  */
 121 static int nor1 = 1;
 122
 123 /* Default will do instruction relax, -O0 will set g_opt = 0.  */
 124 static unsigned int g_opt = 1;
 125
 126 /* The size of the small data section.  */
 127 static unsigned int g_switch_value = 8;
 128
 129 #ifdef OBJ_ELF
 130 /* Pre-defined "_GLOBAL_OFFSET_TABLE_"  */
 131 symbolS *GOT_symbol;
 132 #endif
 133 static segT pdr_seg;
 134
 135 enum score_pic_level score_pic = NO_PIC;
 136
 137 #define INSN_NAME_LEN 16
 138 struct score_it
 139 {
 140   char name[INSN_NAME_LEN];
 141   unsigned long instruction;
 142   unsigned long relax_inst;
 143   int size;
 144   int relax_size;
 145   enum score_insn_type type;
 146   char str[MAX_LITERAL_POOL_SIZE];
 147   const char *error;
 148   int bwarn;
 149   char reg[INSN_NAME_LEN];
 150   struct
 151   {
 152     bfd_reloc_code_real_type type;
 153     expressionS exp;
 154     int pc_rel;
 155   }reloc;
 156 };
 157 struct score_it inst;
 158
 159 typedef struct proc
 160 {
 161   symbolS *isym;
 162   unsigned long reg_mask;
 163   unsigned long reg_offset;
 164   unsigned long fpreg_mask;
 165   unsigned long leaf;
 166   unsigned long frame_offset;
 167   unsigned long frame_reg;
 168   unsigned long pc_reg;
 169 }
 170 procS;
 171
 172 static procS cur_proc;
 173 static procS *cur_proc_ptr;
 174 static int numprocs;
 175
 176 #define SCORE7_PIPELINE 7
 177 #define SCORE5_PIPELINE 5
 178 static int vector_size = SCORE7_PIPELINE;
 179 struct score_it dependency_vector[SCORE7_PIPELINE];
 180
 181 /* Relax will need some padding for alignment.  */
 182 #define RELAX_PAD_BYTE 3
 183
 184 /* Structure for a hash table entry for a register.  */
 185 struct reg_entry
 186 {
 187   const char *name;
 188   int number;
 189 };
 190
 191 static const struct reg_entry score_rn_table[] =
 192 {
 193   {"r0", 0}, {"r1", 1}, {"r2", 2}, {"r3", 3},
 194   {"r4", 4}, {"r5", 5}, {"r6", 6}, {"r7", 7},
 195   {"r8", 8}, {"r9", 9}, {"r10", 10}, {"r11", 11},
 196   {"r12", 12}, {"r13", 13}, {"r14", 14}, {"r15", 15},
 197   {"r16", 16}, {"r17", 17}, {"r18", 18}, {"r19", 19},
 198   {"r20", 20}, {"r21", 21}, {"r22", 22}, {"r23", 23},
 199   {"r24", 24}, {"r25", 25}, {"r26", 26}, {"r27", 27},
 200   {"r28", 28}, {"r29", 29}, {"r30", 30}, {"r31", 31},
 201   {NULL, 0}
 202 };
 203
 204 static const struct reg_entry score_srn_table[] =
 205 {
 206   {"sr0", 0}, {"sr1", 1}, {"sr2", 2},
 207   {NULL, 0}
 208 };
 209
 210 static const struct reg_entry score_crn_table[] =
 211 {
 212   {"cr0", 0}, {"cr1", 1}, {"cr2", 2}, {"cr3", 3},
 213   {"cr4", 4}, {"cr5", 5}, {"cr6", 6}, {"cr7", 7},
 214   {"cr8", 8}, {"cr9", 9}, {"cr10", 10}, {"cr11", 11},
 215   {"cr12", 12}, {"cr13", 13}, {"cr14", 14}, {"cr15", 15},
 216   {"cr16", 16}, {"cr17", 17}, {"cr18", 18}, {"cr19", 19},
 217   {"cr20", 20}, {"cr21", 21}, {"cr22", 22}, {"cr23", 23},
 218   {"cr24", 24}, {"cr25", 25}, {"cr26", 26}, {"cr27", 27},
 219   {"cr28", 28}, {"cr29", 29}, {"cr30", 30}, {"cr31", 31},
 220   {NULL, 0}
 221 };
 222
 223 struct reg_map
 224 {
 225   const struct reg_entry *names;
 226   int max_regno;
 227   struct hash_control *htab;
 228   const char *expected;
 229 };
 230
 231 struct reg_map all_reg_maps[] =
 232 {
 233   {score_rn_table, 31, NULL, N_("S+core register expected")},
 234   {score_srn_table, 2, NULL, N_("S+core special-register expected")},
 235   {score_crn_table, 31, NULL, N_("S+core co-processor register expected")},
 236 };
 237
 238 static struct hash_control *score_ops_hsh = NULL;
 239
 240 static struct hash_control *dependency_insn_hsh = NULL;
 241
 242 /* Enumeration matching entries in table above.  */
 243 enum score_reg_type
 244 {
 245   REG_TYPE_SCORE = 0,
 246 #define REG_TYPE_FIRST REG_TYPE_SCORE
 247   REG_TYPE_SCORE_SR = 1,
 248   REG_TYPE_SCORE_CR = 2,
 249   REG_TYPE_MAX = 3
 250 };
 251
 252 typedef struct literalS
 253 {
 254   struct expressionS exp;
 255   struct score_it *inst;
 256 }
 257 literalT;
 258
 259 literalT literals[MAX_LITERAL_POOL_SIZE];
 260
 261 static void do_ldst_insn (char *);
 262 static void do_crdcrscrsimm5 (char *);
 263 static void do_ldst_unalign (char *);
 264 static void do_ldst_atomic (char *);
 265 static void do_ldst_cop (char *);
 266 static void do_macro_li_rdi32 (char *);
 267 static void do_macro_la_rdi32 (char *);
 268 static void do_macro_rdi32hi (char *);
 269 static void do_macro_rdi32lo (char *);
 270 static void do_macro_mul_rdrsrs (char *);
 271 static void do_macro_ldst_label (char *);
 272 static void do_branch (char *);
 273 static void do_jump (char *);
 274 static void do_empty (char *);
 275 static void do_rdrsrs (char *);
 276 static void do_rdsi16 (char *);
 277 static void do_rdrssi14 (char *);
 278 static void do_sub_rdsi16 (char *);
 279 static void do_sub_rdrssi14 (char *);
 280 static void do_rdrsi5 (char *);
 281 static void do_rdrsi14 (char *);
 282 static void do_rdi16 (char *);
 283 static void do_xrsi5 (char *);
 284 static void do_rdrs (char *);
 285 static void do_rdxrs (char *);
 286 static void do_rsrs (char *);
 287 static void do_rdcrs (char *);
 288 static void do_rdsrs (char *);
 289 static void do_rd (char *);
 290 static void do_rs (char *);
 291 static void do_i15 (char *);
 292 static void do_xi5x (char *);
 293 static void do_ceinst (char *);
 294 static void do_cache (char *);
 295 static void do16_rdrs (char *);
 296 static void do16_rs (char *);
 297 static void do16_xrs (char *);
 298 static void do16_mv_rdrs (char *);
 299 static void do16_hrdrs (char *);
 300 static void do16_rdhrs (char *);
 301 static void do16_rdi4 (char *);
 302 static void do16_rdi5 (char *);
 303 static void do16_xi5 (char *);
 304 static void do16_ldst_insn (char *);
 305 static void do16_ldst_imm_insn (char *);
 306 static void do16_push_pop (char *);
 307 static void do16_branch (char *);
 308 static void do16_jump (char *);
 309 static void do_rdi16_pic (char *);
 310 static void do_addi_s_pic (char *);
 311 static void do_addi_u_pic (char *);
 312 static void do_lw_pic (char *);
 313
 314 static const struct asm_opcode score_ldst_insns[] =
 315 {
 316   {"lw",        0x20000000, 0x3e000000, 0x2008,     Rd_rvalueRs_SI15,     do_ldst_insn},
 317   {"lw",        0x06000000, 0x3e000007, 0x8000,     Rd_rvalueRs_preSI12,  do_ldst_insn},
 318   {"lw",        0x0e000000, 0x3e000007, 0x200a,     Rd_rvalueRs_postSI12, do_ldst_insn},
 319   {"lh",        0x22000000, 0x3e000000, 0x2009,     Rd_rvalueRs_SI15,     do_ldst_insn},
 320   {"lh",        0x06000001, 0x3e000007, 0x8000,     Rd_rvalueRs_preSI12,  do_ldst_insn},
 321   {"lh",        0x0e000001, 0x3e000007, 0x8000,     Rd_rvalueRs_postSI12, do_ldst_insn},
 322   {"lhu",       0x24000000, 0x3e000000, 0x8000,     Rd_rvalueRs_SI15,     do_ldst_insn},
 323   {"lhu",       0x06000002, 0x3e000007, 0x8000,     Rd_rvalueRs_preSI12,  do_ldst_insn},
 324   {"lhu",       0x0e000002, 0x3e000007, 0x8000,     Rd_rvalueRs_postSI12, do_ldst_insn},
 325   {"lb",        0x26000000, 0x3e000000, 0x8000,     Rd_rvalueRs_SI15,     do_ldst_insn},
 326   {"lb",        0x06000003, 0x3e000007, 0x8000,     Rd_rvalueRs_preSI12,  do_ldst_insn},
 327   {"lb",        0x0e000003, 0x3e000007, 0x8000,     Rd_rvalueRs_postSI12, do_ldst_insn},
 328   {"sw",        0x28000000, 0x3e000000, 0x200c,     Rd_lvalueRs_SI15,     do_ldst_insn},
 329   {"sw",        0x06000004, 0x3e000007, 0x200e,     Rd_lvalueRs_preSI12,  do_ldst_insn},
 330   {"sw",        0x0e000004, 0x3e000007, 0x8000,     Rd_lvalueRs_postSI12, do_ldst_insn},
 331   {"sh",        0x2a000000, 0x3e000000, 0x200d,     Rd_lvalueRs_SI15,     do_ldst_insn},
 332   {"sh",        0x06000005, 0x3e000007, 0x8000,     Rd_lvalueRs_preSI12,  do_ldst_insn},
 333   {"sh",        0x0e000005, 0x3e000007, 0x8000,     Rd_lvalueRs_postSI12, do_ldst_insn},
 334   {"lbu",       0x2c000000, 0x3e000000, 0x200b,     Rd_rvalueRs_SI15,     do_ldst_insn},
 335   {"lbu",       0x06000006, 0x3e000007, 0x8000,     Rd_rvalueRs_preSI12,  do_ldst_insn},
 336   {"lbu",       0x0e000006, 0x3e000007, 0x8000,     Rd_rvalueRs_postSI12, do_ldst_insn},
 337   {"sb",        0x2e000000, 0x3e000000, 0x200f,     Rd_lvalueRs_SI15,     do_ldst_insn},
 338   {"sb",        0x06000007, 0x3e000007, 0x8000,     Rd_lvalueRs_preSI12,  do_ldst_insn},
 339   {"sb",        0x0e000007, 0x3e000007, 0x8000,     Rd_lvalueRs_postSI12, do_ldst_insn},
 340 };
 341
 342 static const struct asm_opcode score_insns[] =
 343 {
 344   {"abs",       0x3800000a, 0x3e007fff, 0x8000,     Rd_Rs_x,              do_rdrs},
 345   {"abs.s",     0x3800004b, 0x3e007fff, 0x8000,     Rd_Rs_x,              do_rdrs},
 346   {"add",       0x00000010, 0x3e0003ff, 0x8000,     Rd_Rs_Rs,             do_rdrsrs},
 347   {"add.c",     0x00000011, 0x3e0003ff, 0x2000,     Rd_Rs_Rs,             do_rdrsrs},
 348   {"add.s",     0x38000048, 0x3e0003ff, 0x8000,     Rd_Rs_Rs,             do_rdrsrs},
 349   {"addc",      0x00000012, 0x3e0003ff, 0x8000,     Rd_Rs_Rs,             do_rdrsrs},
 350   {"addc.c",    0x00000013, 0x3e0003ff, 0x0009,     Rd_Rs_Rs,             do_rdrsrs},
 351   {"addi",      0x02000000, 0x3e0e0001, 0x8000,     Rd_SI16,              do_rdsi16},
 352   {"addi.c",    0x02000001, 0x3e0e0001, 0x8000,     Rd_SI16,              do_rdsi16},
 353   {"addis",     0x0a000000, 0x3e0e0001, 0x8000,     Rd_SI16,              do_rdi16},
 354   {"addis.c",   0x0a000001, 0x3e0e0001, 0x8000,     Rd_SI16,              do_rdi16},
 355   {"addri",     0x10000000, 0x3e000001, 0x8000,     Rd_Rs_SI14,           do_rdrssi14},
 356   {"addri.c",   0x10000001, 0x3e000001, 0x8000,     Rd_Rs_SI14,           do_rdrssi14},
 357   {"addc!",     0x0009,     0x700f,     0x00000013, Rd_Rs,                do16_rdrs},
 358   {"add!",      0x2000,     0x700f,     0x00000011, Rd_Rs,                do16_rdrs},
 359   {"addei!",    0x6000    , 0x7087,     0x02000001, Rd_I4,                do16_rdi4},
 360   {"subi",      0x02000000, 0x3e0e0001, 0x8000,     Rd_SI16,              do_sub_rdsi16},
 361   {"subi.c",    0x02000001, 0x3e0e0001, 0x8000,     Rd_SI16,              do_sub_rdsi16},
 362   {"subri",     0x10000000, 0x3e000001, 0x8000,     Rd_Rs_SI14,           do_sub_rdrssi14},
 363   {"subri.c",   0x10000001, 0x3e000001, 0x8000,     Rd_Rs_SI14,           do_sub_rdrssi14},
 364   {"and",       0x00000020, 0x3e0003ff, 0x8000,     Rd_Rs_Rs,             do_rdrsrs},
 365   {"and.c",     0x00000021, 0x3e0003ff, 0x2004,     Rd_Rs_Rs,             do_rdrsrs},
 366   {"andi",      0x02080000, 0x3e0e0001, 0x8000,     Rd_I16,               do_rdi16},
 367   {"andi.c",    0x02080001, 0x3e0e0001, 0x8000,     Rd_I16,               do_rdi16},
 368   {"andis",     0x0a080000, 0x3e0e0001, 0x8000,     Rd_I16,               do_rdi16},
 369   {"andis.c",   0x0a080001, 0x3e0e0001, 0x8000,     Rd_I16,               do_rdi16},
 370   {"andri",     0x18000000, 0x3e000001, 0x8000,     Rd_Rs_I14,            do_rdrsi14},
 371   {"andri.c",   0x18000001, 0x3e000001, 0x8000,     Rd_Rs_I14,            do_rdrsi14},
 372   {"and!",      0x2004,     0x700f,     0x00000021, Rd_Rs,                do16_rdrs},
 373   {"bcs",       0x08000000, 0x3e007c01, 0x4000,     PC_DISP19div2,        do_branch},
 374   {"bcc",       0x08000400, 0x3e007c01, 0x4000,     PC_DISP19div2,        do_branch},
 375   {"bcnz",      0x08003800, 0x3e007c01, 0x4000,     PC_DISP19div2,        do_branch},
 376   {"bcsl",      0x08000001, 0x3e007c01, 0x8000,     PC_DISP19div2,        do_branch},
 377   {"bccl",      0x08000401, 0x3e007c01, 0x8000,     PC_DISP19div2,        do_branch},
 378   {"bcnzl",     0x08003801, 0x3e007c01, 0x8000,     PC_DISP19div2,        do_branch},
 379   {"bcs!",      0x4000,     0x7f00,     0x08000000, PC_DISP8div2,         do16_branch},
 380   {"bcc!",      0x4100,     0x7f00,     0x08000400, PC_DISP8div2,         do16_branch},
 381   {"bcnz!",     0x4e00,     0x7f00,     0x08003800, PC_DISP8div2,         do16_branch},
 382   {"beq",       0x08001000, 0x3e007c01, 0x4000,     PC_DISP19div2,        do_branch},
 383   {"beql",      0x08001001, 0x3e007c01, 0x8000,     PC_DISP19div2,        do_branch},
 384   {"beq!",      0x4400,     0x7f00,     0x08001000, PC_DISP8div2,         do16_branch},
 385   {"bgtu",      0x08000800, 0x3e007c01, 0x4000,     PC_DISP19div2,        do_branch},
 386   {"bgt",       0x08001800, 0x3e007c01, 0x4000,     PC_DISP19div2,        do_branch},
 387   {"bge",       0x08002000, 0x3e007c01, 0x4000,     PC_DISP19div2,        do_branch},
 388   {"bgtul",     0x08000801, 0x3e007c01, 0x8000,     PC_DISP19div2,        do_branch},
 389   {"bgtl",      0x08001801, 0x3e007c01, 0x8000,     PC_DISP19div2,        do_branch},
 390   {"bgel",      0x08002001, 0x3e007c01, 0x8000,     PC_DISP19div2,        do_branch},
 391   {"bgtu!",     0x4200,     0x7f00,     0x08000800, PC_DISP8div2,         do16_branch},
 392   {"bgt!",      0x4600,     0x7f00,     0x08001800, PC_DISP8div2,         do16_branch},
 393   {"bge!",      0x4800,     0x7f00,     0x08002000, PC_DISP8div2,         do16_branch},
 394   {"bitclr.c",  0x00000029, 0x3e0003ff, 0x6004,     Rd_Rs_I5,             do_rdrsi5},
 395   {"bitrev",    0x3800000c, 0x3e0003ff, 0x8000,     Rd_Rs_Rs,             do_rdrsrs},
 396   {"bitset.c",  0x0000002b, 0x3e0003ff, 0x6005,     Rd_Rs_I5,             do_rdrsi5},
 397   {"bittst.c",  0x0000002d, 0x3e0003ff, 0x6006,     x_Rs_I5,              do_xrsi5},
 398   {"bittgl.c",  0x0000002f, 0x3e0003ff, 0x6007,     Rd_Rs_I5,             do_rdrsi5},
 399   {"bitclr!",   0x6004,     0x7007,     0x00000029, Rd_I5,                do16_rdi5},
 400   {"bitset!",   0x6005,     0x7007,     0x0000002b, Rd_I5,                do16_rdi5},
 401   {"bittst!",   0x6006,     0x7007,     0x0000002d, Rd_I5,                do16_rdi5},
 402   {"bittgl!",   0x6007,     0x7007,     0x0000002f, Rd_I5,                do16_rdi5},
 403   {"bleu",      0x08000c00, 0x3e007c01, 0x4000,     PC_DISP19div2,        do_branch},
 404   {"ble",       0x08001c00, 0x3e007c01, 0x4000,     PC_DISP19div2,        do_branch},
 405   {"blt",       0x08002400, 0x3e007c01, 0x4000,     PC_DISP19div2,        do_branch},
 406   {"bleul",     0x08000c01, 0x3e007c01, 0x8000,     PC_DISP19div2,        do_branch},
 407   {"blel",      0x08001c01, 0x3e007c01, 0x8000,     PC_DISP19div2,        do_branch},
 408   {"bltl",      0x08002401, 0x3e007c01, 0x8000,     PC_DISP19div2,        do_branch},
 409   {"bl",        0x08003c01, 0x3e007c01, 0x8000,     PC_DISP19div2,        do_branch},
 410   {"bleu!",     0x4300,     0x7f00,     0x08000c00, PC_DISP8div2,         do16_branch},
 411   {"ble!",      0x4700,     0x7f00,     0x08001c00, PC_DISP8div2,         do16_branch},
 412   {"blt!",      0x4900,     0x7f00,     0x08002400, PC_DISP8div2,         do16_branch},
 413   {"bmi",       0x08002800, 0x3e007c01, 0x4000,     PC_DISP19div2,        do_branch},
 414   {"bmil",      0x08002801, 0x3e007c01, 0x8000,     PC_DISP19div2,        do_branch},
 415   {"bmi!",      0x00004a00, 0x00007f00, 0x08002800, PC_DISP8div2,         do16_branch},
 416   {"bne",       0x08001400, 0x3e007c01, 0x4000,     PC_DISP19div2,        do_branch},
 417   {"bnel",      0x08001401, 0x3e007c01, 0x8000,     PC_DISP19div2,        do_branch},
 418   {"bne!",      0x4500,     0x7f00,     0x08001400, PC_DISP8div2,         do16_branch},
 419   {"bpl",       0x08002c00, 0x3e007c01, 0x4000,     PC_DISP19div2,        do_branch},
 420   {"bpll",      0x08002c01, 0x3e007c01, 0x8000,     PC_DISP19div2,        do_branch},
 421   {"bpl!",      0x4b00,     0x7f00,     0x08002c00, PC_DISP8div2,         do16_branch},
 422   {"brcs",      0x00000008, 0x3e007fff, 0x0004,     x_Rs_x,               do_rs},
 423   {"brcc",      0x00000408, 0x3e007fff, 0x0104,     x_Rs_x,               do_rs},
 424   {"brgtu",     0x00000808, 0x3e007fff, 0x0204,     x_Rs_x,               do_rs},
 425   {"brleu",     0x00000c08, 0x3e007fff, 0x0304,     x_Rs_x,               do_rs},
 426   {"breq",      0x00001008, 0x3e007fff, 0x0404,     x_Rs_x,               do_rs},
 427   {"brne",      0x00001408, 0x3e007fff, 0x0504,     x_Rs_x,               do_rs},
 428   {"brgt",      0x00001808, 0x3e007fff, 0x0604,     x_Rs_x,               do_rs},
 429   {"brle",      0x00001c08, 0x3e007fff, 0x0704,     x_Rs_x,               do_rs},
 430   {"brge",      0x00002008, 0x3e007fff, 0x0804,     x_Rs_x,               do_rs},
 431   {"brlt",      0x00002408, 0x3e007fff, 0x0904,     x_Rs_x,               do_rs},
 432   {"brmi",      0x00002808, 0x3e007fff, 0x0a04,     x_Rs_x,               do_rs},
 433   {"brpl",      0x00002c08, 0x3e007fff, 0x0b04,     x_Rs_x,               do_rs},
 434   {"brvs",      0x00003008, 0x3e007fff, 0x0c04,     x_Rs_x,               do_rs},
 435   {"brvc",      0x00003408, 0x3e007fff, 0x0d04,     x_Rs_x,               do_rs},
 436   {"brcnz",     0x00003808, 0x3e007fff, 0x0e04,     x_Rs_x,               do_rs},
 437   {"br",        0x00003c08, 0x3e007fff, 0x0f04,     x_Rs_x,               do_rs},
 438   {"brcsl",     0x00000009, 0x3e007fff, 0x000c,     x_Rs_x,               do_rs},
 439   {"brccl",     0x00000409, 0x3e007fff, 0x010c,     x_Rs_x,               do_rs},
 440   {"brgtul",    0x00000809, 0x3e007fff, 0x020c,     x_Rs_x,               do_rs},
 441   {"brleul",    0x00000c09, 0x3e007fff, 0x030c,     x_Rs_x,               do_rs},
 442   {"breql",     0x00001009, 0x3e007fff, 0x040c,     x_Rs_x,               do_rs},
 443   {"brnel",     0x00001409, 0x3e007fff, 0x050c,     x_Rs_x,               do_rs},
 444   {"brgtl",     0x00001809, 0x3e007fff, 0x060c,     x_Rs_x,               do_rs},
 445   {"brlel",     0x00001c09, 0x3e007fff, 0x070c,     x_Rs_x,               do_rs},
 446   {"brgel",     0x00002009, 0x3e007fff, 0x080c,     x_Rs_x,               do_rs},
 447   {"brltl",     0x00002409, 0x3e007fff, 0x090c,     x_Rs_x,               do_rs},
 448   {"brmil",     0x00002809, 0x3e007fff, 0x0a0c,     x_Rs_x,               do_rs},
 449   {"brpll",     0x00002c09, 0x3e007fff, 0x0b0c,     x_Rs_x,               do_rs},
 450   {"brvsl",     0x00003009, 0x3e007fff, 0x0c0c,     x_Rs_x,               do_rs},
 451   {"brvcl",     0x00003409, 0x3e007fff, 0x0d0c,     x_Rs_x,               do_rs},
 452   {"brcnzl",    0x00003809, 0x3e007fff, 0x0e0c,     x_Rs_x,               do_rs},
 453   {"brl",       0x00003c09, 0x3e007fff, 0x0f0c,     x_Rs_x,               do_rs},
 454   {"brcs!",     0x0004,     0x7f0f,     0x00000008, x_Rs,                 do16_xrs},
 455   {"brcc!",     0x0104,     0x7f0f,     0x00000408, x_Rs,                 do16_xrs},
 456   {"brgtu!",    0x0204,     0x7f0f,     0x00000808, x_Rs,                 do16_xrs},
 457   {"brleu!",    0x0304,     0x7f0f,     0x00000c08, x_Rs,                 do16_xrs},
 458   {"breq!",     0x0404,     0x7f0f,     0x00001008, x_Rs,                 do16_xrs},
 459   {"brne!",     0x0504,     0x7f0f,     0x00001408, x_Rs,                 do16_xrs},
 460   {"brgt!",     0x0604,     0x7f0f,     0x00001808, x_Rs,                 do16_xrs},
 461   {"brle!",     0x0704,     0x7f0f,     0x00001c08, x_Rs,                 do16_xrs},
 462   {"brge!",     0x0804,     0x7f0f,     0x00002008, x_Rs,                 do16_xrs},
 463   {"brlt!",     0x0904,     0x7f0f,     0x00002408, x_Rs,                 do16_xrs},
 464   {"brmi!",     0x0a04,     0x7f0f,     0x00002808, x_Rs,                 do16_xrs},
 465   {"brpl!",     0x0b04,     0x7f0f,     0x00002c08, x_Rs,                 do16_xrs},
 466   {"brvs!",     0x0c04,     0x7f0f,     0x00003008, x_Rs,                 do16_xrs},
 467   {"brvc!",     0x0d04,     0x7f0f,     0x00003408, x_Rs,                 do16_xrs},
 468   {"brcnz!",    0x0e04,     0x7f0f,     0x00003808, x_Rs,                 do16_xrs},
 469   {"br!",       0x0f04,     0x7f0f,     0x00003c08, x_Rs,                 do16_xrs},
 470   {"brcsl!",    0x000c,     0x7f0f,     0x00000009, x_Rs,                 do16_xrs},
 471   {"brccl!",    0x010c,     0x7f0f,     0x00000409, x_Rs,                 do16_xrs},
 472   {"brgtul!",   0x020c,     0x7f0f,     0x00000809, x_Rs,                 do16_xrs},
 473   {"brleul!",   0x030c,     0x7f0f,     0x00000c09, x_Rs,                 do16_xrs},
 474   {"breql!",    0x040c,     0x7f0f,     0x00001009, x_Rs,                 do16_xrs},
 475   {"brnel!",    0x050c,     0x7f0f,     0x00001409, x_Rs,                 do16_xrs},
 476   {"brgtl!",    0x060c,     0x7f0f,     0x00001809, x_Rs,                 do16_xrs},
 477   {"brlel!",    0x070c,     0x7f0f,     0x00001c09, x_Rs,                 do16_xrs},
 478   {"brgel!",    0x080c,     0x7f0f,     0x00002009, x_Rs,                 do16_xrs},
 479   {"brltl!",    0x090c,     0x7f0f,     0x00002409, x_Rs,                 do16_xrs},
 480   {"brmil!",    0x0a0c,     0x7f0f,     0x00002809, x_Rs,                 do16_xrs},
 481   {"brpll!",    0x0b0c,     0x7f0f,     0x00002c09, x_Rs,                 do16_xrs},
 482   {"brvsl!",    0x0c0c,     0x7f0f,     0x00003009, x_Rs,                 do16_xrs},
 483   {"brvcl!",    0x0d0c,     0x7f0f,     0x00003409, x_Rs,                 do16_xrs},
 484   {"brcnzl!",   0x0e0c,     0x7f0f,     0x00003809, x_Rs,                 do16_xrs},
 485   {"brl!",      0x0f0c,     0x7f0f,     0x00003c09, x_Rs,                 do16_xrs},
 486   {"bvs",       0x08003000, 0x3e007c01, 0x4000,     PC_DISP19div2,        do_branch},
 487   {"bvc",       0x08003400, 0x3e007c01, 0x4000,     PC_DISP19div2,        do_branch},
 488   {"bvsl",      0x08003001, 0x3e007c01, 0x8000,     PC_DISP19div2,        do_branch},
 489   {"bvcl",      0x08003401, 0x3e007c01, 0x8000,     PC_DISP19div2,        do_branch},
 490   {"bvs!",      0x4c00,     0x7f00,     0x08003000, PC_DISP8div2,         do16_branch},
 491   {"bvc!",      0x4d00,     0x7f00,     0x08003400, PC_DISP8div2,         do16_branch},
 492   {"b!",        0x4f00,     0x7f00,     0x08003c00, PC_DISP8div2,         do16_branch},
 493   {"b",         0x08003c00, 0x3e007c01, 0x4000,     PC_DISP19div2,        do_branch},
 494   {"cache",     0x30000000, 0x3ff00000, 0x8000,     OP5_rvalueRs_SI15,    do_cache},
 495   {"ceinst",    0x38000000, 0x3e000000, 0x8000,     I5_Rs_Rs_I5_OP5,      do_ceinst},
 496   {"clz",       0x3800000d, 0x3e007fff, 0x8000,     Rd_Rs_x,              do_rdrs},
 497   {"cmpteq.c",  0x00000019, 0x3ff003ff, 0x8000,     x_Rs_Rs,              do_rsrs},
 498   {"cmptmi.c",  0x00100019, 0x3ff003ff, 0x8000,     x_Rs_Rs,              do_rsrs},
 499   {"cmp.c",     0x00300019, 0x3ff003ff, 0x2003,     x_Rs_Rs,              do_rsrs},
 500   {"cmpzteq.c", 0x0000001b, 0x3ff07fff, 0x8000,     x_Rs_x,               do_rs},
 501   {"cmpztmi.c", 0x0010001b, 0x3ff07fff, 0x8000,     x_Rs_x,               do_rs},
 502   {"cmpz.c",    0x0030001b, 0x3ff07fff, 0x8000,     x_Rs_x,               do_rs},
 503   {"cmpi.c",    0x02040001, 0x3e0e0001, 0x8000,     Rd_SI16,              do_rdsi16},
 504   {"cmp!",      0x2003,     0x700f,     0x00300019, Rd_Rs,                do16_rdrs},
 505   {"cop1",      0x0c00000c, 0x3e00001f, 0x8000,     Rd_Rs_Rs_imm,         do_crdcrscrsimm5},
 506   {"cop2",      0x0c000014, 0x3e00001f, 0x8000,     Rd_Rs_Rs_imm,         do_crdcrscrsimm5},
 507   {"cop3",      0x0c00001c, 0x3e00001f, 0x8000,     Rd_Rs_Rs_imm,         do_crdcrscrsimm5},
 508   {"drte",      0x0c0000a4, 0x3e0003ff, 0x8000,     NO_OPD,               do_empty},
 509   {"extsb",     0x00000058, 0x3e0003ff, 0x8000,     Rd_Rs_x,              do_rdrs},
 510   {"extsb.c",   0x00000059, 0x3e0003ff, 0x8000,     Rd_Rs_x,              do_rdrs},
 511   {"extsh",     0x0000005a, 0x3e0003ff, 0x8000,     Rd_Rs_x,              do_rdrs},
 512   {"extsh.c",   0x0000005b, 0x3e0003ff, 0x8000,     Rd_Rs_x,              do_rdrs},
 513   {"extzb",     0x0000005c, 0x3e0003ff, 0x8000,     Rd_Rs_x,              do_rdrs},
 514   {"extzb.c",   0x0000005d, 0x3e0003ff, 0x8000,     Rd_Rs_x,              do_rdrs},
 515   {"extzh",     0x0000005e, 0x3e0003ff, 0x8000,     Rd_Rs_x,              do_rdrs},
 516   {"extzh.c",   0x0000005f, 0x3e0003ff, 0x8000,     Rd_Rs_x,              do_rdrs},
 517   {"jl",        0x04000001, 0x3e000001, 0x8000,     PC_DISP24div2,        do_jump},
 518   {"jl!",       0x3001,     0x7001,     0x04000001, PC_DISP11div2,        do16_jump},
 519   {"j!",        0x3000,     0x7001,     0x04000000, PC_DISP11div2,        do16_jump},
 520   {"j",         0x04000000, 0x3e000001, 0x8000,     PC_DISP24div2,        do_jump},
 521   {"lbu!",      0x200b,     0x0000700f, 0x2c000000, Rd_rvalueRs,          do16_ldst_insn},
 522   {"lbup!",     0x7003,     0x7007,     0x2c000000, Rd_rvalueBP_I5,       do16_ldst_imm_insn},
 523   {"alw",       0x0000000c, 0x3e0003ff, 0x8000,     Rd_rvalue32Rs,        do_ldst_atomic},
 524   {"lcb",       0x00000060, 0x3e0003ff, 0x8000,     x_rvalueRs_post4,     do_ldst_unalign},
 525   {"lcw",       0x00000062, 0x3e0003ff, 0x8000,     Rd_rvalueRs_post4,    do_ldst_unalign},
 526   {"lce",       0x00000066, 0x3e0003ff, 0x8000,     Rd_rvalueRs_post4,    do_ldst_unalign},
 527   {"ldc1",      0x0c00000a, 0x3e00001f, 0x8000,     Rd_rvalueRs_SI10,     do_ldst_cop},
 528   {"ldc2",      0x0c000012, 0x3e00001f, 0x8000,     Rd_rvalueRs_SI10,     do_ldst_cop},
 529   {"ldc3",      0x0c00001a, 0x3e00001f, 0x8000,     Rd_rvalueRs_SI10,     do_ldst_cop},
 530   {"lh!",       0x2009,     0x700f,     0x22000000, Rd_rvalueRs,          do16_ldst_insn},
 531   {"lhp!",      0x7001,     0x7007,     0x22000000, Rd_rvalueBP_I5,       do16_ldst_imm_insn},
 532   {"ldi",       0x020c0000, 0x3e0e0000, 0x5000,     Rd_SI16,              do_rdsi16},
 533   {"ldis",      0x0a0c0000, 0x3e0e0000, 0x8000,     Rd_I16,               do_rdi16},
 534   {"ldiu!",     0x5000,     0x7000,     0x020c0000, Rd_I8,                do16_ldst_imm_insn},
 535   {"lw!",       0x2008,     0x700f,     0x20000000, Rd_rvalueRs,          do16_ldst_insn},
 536   {"lwp!",      0x7000,     0x7007,     0x20000000, Rd_rvalueBP_I5,       do16_ldst_imm_insn},
 537   {"mfcel",     0x00000448, 0x3e007fff, 0x8000,     Rd_x_x,               do_rd},
 538   {"mfcel!",    0x1001,     0x7f0f,     0x00000448, x_Rs,                 do16_rs},
 539   {"mad",       0x38000000, 0x3ff003ff, 0x8000,     x_Rs_Rs,              do_rsrs},
 540   {"mad.f!",    0x1004,     0x700f,     0x38000080, Rd_Rs,                do16_rdrs},
 541   {"madh",      0x38000203, 0x3ff003ff, 0x8000,     x_Rs_Rs,              do_rsrs},
 542   {"madh.fs",   0x380002c3, 0x3ff003ff, 0x8000,     x_Rs_Rs,              do_rsrs},
 543   {"madh.fs!",  0x100b,     0x700f,     0x380002c3, Rd_Rs,                do16_rdrs},
 544   {"madl",      0x38000002, 0x3ff003ff, 0x8000,     x_Rs_Rs,              do_rsrs},
 545   {"madl.fs",   0x380000c2, 0x3ff003ff, 0x8000,     x_Rs_Rs,              do_rsrs},
 546   {"madl.fs!",  0x100a,     0x700f,     0x380000c2, Rd_Rs,                do16_rdrs},
 547   {"madu",      0x38000020, 0x3ff003ff, 0x8000,     x_Rs_Rs,              do_rsrs},
 548   {"madu!",     0x1005,     0x700f,     0x38000020, Rd_Rs,                do16_rdrs},
 549   {"mad.f",     0x38000080, 0x3ff003ff, 0x8000,     x_Rs_Rs,              do_rsrs},
 550   {"max",       0x38000007, 0x3e0003ff, 0x8000,     Rd_Rs_Rs,             do_rdrsrs},
 551   {"mazh",      0x38000303, 0x3ff003ff, 0x8000,     x_Rs_Rs,              do_rsrs},
 552   {"mazh.f",    0x38000383, 0x3ff003ff, 0x8000,     x_Rs_Rs,              do_rsrs},
 553   {"mazh.f!",   0x1009,     0x700f,     0x3800038c, Rd_Rs,                do16_rdrs},
 554   {"mazl",      0x38000102, 0x3ff003ff, 0x8000,     x_Rs_Rs,              do_rsrs},
 555   {"mazl.f",    0x38000182, 0x3ff003ff, 0x8000,     x_Rs_Rs,              do_rsrs},
 556   {"mazl.f!",   0x1008,     0x700f,     0x38000182, Rd_Rs,                do16_rdrs},
 557   {"mfceh",     0x00000848, 0x3e007fff, 0x8000,     Rd_x_x,               do_rd},
 558   {"mfceh!",    0x1101,     0x7f0f,     0x00000848, x_Rs,                 do16_rs},
 559   {"mfcehl",    0x00000c48, 0x3e007fff, 0x8000,     Rd_Rs_x,              do_rdrs},
 560   {"mfsr",      0x00000050, 0x3e0003ff, 0x8000,     Rd_x_I5,              do_rdsrs},
 561   {"mfcr",      0x0c000001, 0x3e00001f, 0x8000,     Rd_Rs_x,              do_rdcrs},
 562   {"mfc1",      0x0c000009, 0x3e00001f, 0x8000,     Rd_Rs_x,              do_rdcrs},
 563   {"mfc2",      0x0c000011, 0x3e00001f, 0x8000,     Rd_Rs_x,              do_rdcrs},
 564   {"mfc3",      0x0c000019, 0x3e00001f, 0x8000,     Rd_Rs_x,              do_rdcrs},
 565   {"mfcc1",     0x0c00000f, 0x3e00001f, 0x8000,     Rd_Rs_x,              do_rdcrs},
 566   {"mfcc2",     0x0c000017, 0x3e00001f, 0x8000,     Rd_Rs_x,              do_rdcrs},
 567   {"mfcc3",     0x0c00001f, 0x3e00001f, 0x8000,     Rd_Rs_x,              do_rdcrs},
 568   {"mhfl!",     0x0002,     0x700f,     0x00003c56, Rd_LowRs,             do16_hrdrs},
 569   {"min",       0x38000006, 0x3e0003ff, 0x8000,     Rd_Rs_Rs,             do_rdrsrs},
 570   {"mlfh!",     0x0001,     0x700f,     0x00003c56, Rd_HighRs,            do16_rdhrs},
 571   {"msb",       0x38000001, 0x3ff003ff, 0x8000,     x_Rs_Rs,              do_rsrs},
 572   {"msb.f!",    0x1006,     0x700f,     0x38000081, Rd_Rs,                do16_rdrs},
 573   {"msbh",      0x38000205, 0x3ff003ff, 0x8000,     x_Rs_Rs,              do_rsrs},
 574   {"msbh.fs",   0x380002c5, 0x3ff003ff, 0x8000,     x_Rs_Rs,              do_rsrs},
 575   {"msbh.fs!",  0x100f,     0x700f,     0x380002c5, Rd_Rs,                do16_rdrs},
 576   {"msbl",      0x38000004, 0x3ff003ff, 0x8000,     x_Rs_Rs,              do_rsrs},
 577   {"msbl.fs",   0x380000c4, 0x3ff003ff, 0x8000,     x_Rs_Rs,              do_rsrs},
 578   {"msbl.fs!",  0x100e,     0x700f,     0x380000c4, Rd_Rs,                do16_rdrs},
 579   {"msbu",      0x38000021, 0x3ff003ff, 0x8000,     x_Rs_Rs,              do_rsrs},
 580   {"msbu!",     0x1007,     0x700f,     0x38000021, Rd_Rs,                do16_rdrs},
 581   {"msb.f",     0x38000081, 0x3ff003ff, 0x8000,     x_Rs_Rs,              do_rsrs},
 582   {"mszh",      0x38000305, 0x3ff003ff, 0x8000,     x_Rs_Rs,              do_rsrs},
 583   {"mszh.f",    0x38000385, 0x3ff003ff, 0x8000,     x_Rs_Rs,              do_rsrs},
 584   {"mszh.f!",   0x100d,     0x700f,     0x38000385, Rd_Rs,                do16_rdrs},
 585   {"mszl",      0x38000104, 0x3ff003ff, 0x8000,     x_Rs_Rs,              do_rsrs},
 586   {"mszl.f",    0x38000184, 0x3ff003ff, 0x8000,     x_Rs_Rs,              do_rsrs},
 587   {"mszl.f!",   0x100c,     0x700f,     0x38000184, Rd_Rs,                do16_rdrs},
 588   {"mtcel!",    0x1000,     0x7f0f,     0x0000044a, x_Rs,                 do16_rs},
 589   {"mtcel",     0x0000044a, 0x3e007fff, 0x8000,     Rd_x_x,               do_rd},
 590   {"mtceh",     0x0000084a, 0x3e007fff, 0x8000,     Rd_x_x,               do_rd},
 591   {"mtceh!",    0x1100,     0x7f0f,     0x0000084a, x_Rs,                 do16_rs},
 592   {"mtcehl",    0x00000c4a, 0x3e007fff, 0x8000,     Rd_Rs_x,              do_rdrs},
 593   {"mtsr",      0x00000052, 0x3e0003ff, 0x8000,     x_Rs_I5,              do_rdsrs},
 594   {"mtcr",      0x0c000000, 0x3e00001f, 0x8000,     Rd_Rs_x,              do_rdcrs},
 595   {"mtc1",      0x0c000008, 0x3e00001f, 0x8000,     Rd_Rs_x,              do_rdcrs},
 596   {"mtc2",      0x0c000010, 0x3e00001f, 0x8000,     Rd_Rs_x,              do_rdcrs},
 597   {"mtc3",      0x0c000018, 0x3e00001f, 0x8000,     Rd_Rs_x,              do_rdcrs},
 598   {"mtcc1",     0x0c00000e, 0x3e00001f, 0x8000,     Rd_Rs_x,              do_rdcrs},
 599   {"mtcc2",     0x0c000016, 0x3e00001f, 0x8000,     Rd_Rs_x,              do_rdcrs},
 600   {"mtcc3",     0x0c00001e, 0x3e00001f, 0x8000,     Rd_Rs_x,              do_rdcrs},
 601   {"mul.f!",    0x1002,     0x700f,     0x00000041, Rd_Rs,                do16_rdrs},
 602   {"mulu!",     0x1003,     0x700f,     0x00000042, Rd_Rs,                do16_rdrs},
 603   {"mvcs",      0x00000056, 0x3e007fff, 0x8000,     Rd_Rs_x,              do_rdrs},
 604   {"mvcc",      0x00000456, 0x3e007fff, 0x8000,     Rd_Rs_x,              do_rdrs},
 605   {"mvgtu",     0x00000856, 0x3e007fff, 0x8000,     Rd_Rs_x,              do_rdrs},
 606   {"mvleu",     0x00000c56, 0x3e007fff, 0x8000,     Rd_Rs_x,              do_rdrs},
 607   {"mveq",      0x00001056, 0x3e007fff, 0x8000,     Rd_Rs_x,              do_rdrs},
 608   {"mvne",      0x00001456, 0x3e007fff, 0x8000,     Rd_Rs_x,              do_rdrs},
 609   {"mvgt",      0x00001856, 0x3e007fff, 0x8000,     Rd_Rs_x,              do_rdrs},
 610   {"mvle",      0x00001c56, 0x3e007fff, 0x8000,     Rd_Rs_x,              do_rdrs},
 611   {"mvge",      0x00002056, 0x3e007fff, 0x8000,     Rd_Rs_x,              do_rdrs},
 612   {"mvlt",      0x00002456, 0x3e007fff, 0x8000,     Rd_Rs_x,              do_rdrs},
 613   {"mvmi",      0x00002856, 0x3e007fff, 0x8000,     Rd_Rs_x,              do_rdrs},
 614   {"mvpl",      0x00002c56, 0x3e007fff, 0x8000,     Rd_Rs_x,              do_rdrs},
 615   {"mvvs",      0x00003056, 0x3e007fff, 0x8000,     Rd_Rs_x,              do_rdrs},
 616   {"mvvc",      0x00003456, 0x3e007fff, 0x8000,     Rd_Rs_x,              do_rdrs},
 617   {"mv",        0x00003c56, 0x3e007fff, 0x0003,     Rd_Rs_x,              do_rdrs},
 618   {"mv!",       0x0003,     0x700f,     0x00003c56, Rd_Rs,                do16_mv_rdrs},
 619   {"neg",       0x0000001e, 0x3e0003ff, 0x8000,     Rd_x_Rs,              do_rdxrs},
 620   {"neg.c",     0x0000001f, 0x3e0003ff, 0x2002,     Rd_x_Rs,              do_rdxrs},
 621   {"neg!",      0x2002,     0x700f,     0x0000001f, Rd_Rs,                do16_rdrs},
 622   {"nop",       0x00000000, 0x3e0003ff, 0x0000,     NO_OPD,               do_empty},
 623   {"not",       0x00000024, 0x3e0003ff, 0x8000,     Rd_Rs_x,              do_rdrs},
 624   {"not.c",     0x00000025, 0x3e0003ff, 0x2006,     Rd_Rs_x,              do_rdrs},
 625   {"nop!",      0x0000,     0x700f,     0x00000000, NO16_OPD,               do_empty},
 626   {"not!",      0x2006,     0x700f,     0x00000025, Rd_Rs,                do16_rdrs},
 627   {"or",        0x00000022, 0x3e0003ff, 0x8000,     Rd_Rs_Rs,             do_rdrsrs},
 628   {"or.c",      0x00000023, 0x3e0003ff, 0x2005,     Rd_Rs_Rs,             do_rdrsrs},
 629   {"ori",       0x020a0000, 0x3e0e0001, 0x8000,     Rd_I16,               do_rdi16},
 630   {"ori.c",     0x020a0001, 0x3e0e0001, 0x8000,     Rd_I16,               do_rdi16},
 631   {"oris",      0x0a0a0000, 0x3e0e0001, 0x8000,     Rd_I16,               do_rdi16},
 632   {"oris.c",    0x0a0a0001, 0x3e0e0001, 0x8000,     Rd_I16,               do_rdi16},
 633   {"orri",      0x1a000000, 0x3e000001, 0x8000,     Rd_Rs_I14,            do_rdrsi14},
 634   {"orri.c",    0x1a000001, 0x3e000001, 0x8000,     Rd_Rs_I14,            do_rdrsi14},
 635   {"or!",       0x2005,     0x700f,     0x00000023, Rd_Rs,                do16_rdrs},
 636   {"pflush",    0x0000000a, 0x3e0003ff, 0x8000,     NO_OPD,               do_empty},
 637   {"pop!",      0x200a,     0x700f,     0x0e000000, Rd_rvalueRs,          do16_push_pop},
 638   {"push!",     0x200e,     0x700f,     0x06000004, Rd_lvalueRs,          do16_push_pop},
 639   {"ror",       0x00000038, 0x3e0003ff, 0x8000,     Rd_Rs_Rs,             do_rdrsrs},
 640   {"ror.c",     0x00000039, 0x3e0003ff, 0x8000,     Rd_Rs_Rs,             do_rdrsrs},
 641   {"rorc.c",    0x0000003b, 0x3e0003ff, 0x8000,     Rd_Rs_Rs,             do_rdrsrs},
 642   {"rol",       0x0000003c, 0x3e0003ff, 0x8000,     Rd_Rs_Rs,             do_rdrsrs},
 643   {"rol.c",     0x0000003d, 0x3e0003ff, 0x8000,     Rd_Rs_Rs,             do_rdrsrs},
 644   {"rolc.c",    0x0000003f, 0x3e0003ff, 0x8000,     Rd_Rs_Rs,             do_rdrsrs},
 645   {"rori",      0x00000078, 0x3e0003ff, 0x8000,     Rd_Rs_I5,             do_rdrsi5},
 646   {"rori.c",    0x00000079, 0x3e0003ff, 0x8000,     Rd_Rs_I5,             do_rdrsi5},
 647   {"roric.c",   0x0000007b, 0x3e0003ff, 0x8000,     Rd_Rs_I5,             do_rdrsi5},
 648   {"roli",      0x0000007c, 0x3e0003ff, 0x8000,     Rd_Rs_I5,             do_rdrsi5},
 649   {"roli.c",    0x0000007d, 0x3e0003ff, 0x8000,     Rd_Rs_I5,             do_rdrsi5},
 650   {"rolic.c",   0x0000007f, 0x3e0003ff, 0x8000,     Rd_Rs_I5,             do_rdrsi5},
 651   {"rte",       0x0c000084, 0x3e0003ff, 0x8000,     NO_OPD,               do_empty},
 652   {"sb!",       0x200f,     0x700f,     0x2e000000, Rd_lvalueRs,          do16_ldst_insn},
 653   {"sbp!",      0x7007,     0x7007,     0x2e000000, Rd_lvalueBP_I5,       do16_ldst_imm_insn},
 654   {"asw",       0x0000000e, 0x3e0003ff, 0x8000,     Rd_lvalue32Rs,        do_ldst_atomic},
 655   {"scb",       0x00000068, 0x3e0003ff, 0x8000,     Rd_lvalueRs_post4,    do_ldst_unalign},
 656   {"scw",       0x0000006a, 0x3e0003ff, 0x8000,     Rd_lvalueRs_post4,    do_ldst_unalign},
 657   {"sce",       0x0000006e, 0x3e0003ff, 0x8000,     x_lvalueRs_post4,     do_ldst_unalign},
 658   {"sdbbp",     0x00000006, 0x3e0003ff, 0x6002,     x_I5_x,               do_xi5x},
 659   {"sdbbp!",    0x6002,     0x7007,     0x00000006, Rd_I5,                do16_xi5},
 660   {"sh!",       0x200d,     0x700f,     0x2a000000, Rd_lvalueRs,          do16_ldst_insn},
 661   {"shp!",      0x7005,     0x7007,     0x2a000000, Rd_lvalueBP_I5,       do16_ldst_imm_insn},
 662   {"sleep",     0x0c0000c4, 0x3e0003ff, 0x8000,     NO_OPD,               do_empty},
 663   {"sll",       0x00000030, 0x3e0003ff, 0x8000,     Rd_Rs_Rs,             do_rdrsrs},
 664   {"sll.c",     0x00000031, 0x3e0003ff, 0x0008,     Rd_Rs_Rs,             do_rdrsrs},
 665   {"sll.s",     0x3800004e, 0x3e0003ff, 0x8000,     Rd_Rs_Rs,             do_rdrsrs},
 666   {"slli",      0x00000070, 0x3e0003ff, 0x8000,     Rd_Rs_I5,             do_rdrsi5},
 667   {"slli.c",    0x00000071, 0x3e0003ff, 0x6001,     Rd_Rs_I5,             do_rdrsi5},
 668   {"sll!",      0x0008,     0x700f,     0x00000031, Rd_Rs,                do16_rdrs},
 669   {"slli!",     0x6001,     0x7007,     0x00000071, Rd_I5,                do16_rdi5},
 670   {"srl",       0x00000034, 0x3e0003ff, 0x8000,     Rd_Rs_Rs,             do_rdrsrs},
 671   {"srl.c",     0x00000035, 0x3e0003ff, 0x000a,     Rd_Rs_Rs,             do_rdrsrs},
 672   {"sra",       0x00000036, 0x3e0003ff, 0x8000,     Rd_Rs_Rs,             do_rdrsrs},
 673   {"sra.c",     0x00000037, 0x3e0003ff, 0x000b,     Rd_Rs_Rs,             do_rdrsrs},
 674   {"srli",      0x00000074, 0x3e0003ff, 0x8000,     Rd_Rs_I5,             do_rdrsi5},
 675   {"srli.c",    0x00000075, 0x3e0003ff, 0x6003,     Rd_Rs_I5,             do_rdrsi5},
 676   {"srai",      0x00000076, 0x3e0003ff, 0x8000,     Rd_Rs_I5,             do_rdrsi5},
 677   {"srai.c",    0x00000077, 0x3e0003ff, 0x8000,     Rd_Rs_I5,             do_rdrsi5},
 678   {"srl!",      0x000a,     0x700f,     0x00000035, Rd_Rs,                do16_rdrs},
 679   {"sra!",      0x000b,     0x700f,     0x00000037, Rd_Rs,                do16_rdrs},
 680   {"srli!",     0x6003,     0x7007,     0x00000075, Rd_Rs,                do16_rdi5},
 681   {"stc1",      0x0c00000b, 0x3e00001f, 0x8000,     Rd_lvalueRs_SI10,     do_ldst_cop},
 682   {"stc2",      0x0c000013, 0x3e00001f, 0x8000,     Rd_lvalueRs_SI10,     do_ldst_cop},
 683   {"stc3",      0x0c00001b, 0x3e00001f, 0x8000,     Rd_lvalueRs_SI10,     do_ldst_cop},
 684   {"sub",       0x00000014, 0x3e0003ff, 0x8000,     Rd_Rs_Rs,             do_rdrsrs},
 685   {"sub.c",     0x00000015, 0x3e0003ff, 0x2001,     Rd_Rs_Rs,             do_rdrsrs},
 686   {"sub.s",     0x38000049, 0x3e0003ff, 0x8000,     Rd_Rs_Rs,             do_rdrsrs},
 687   {"subc",      0x00000016, 0x3e0003ff, 0x8000,     Rd_Rs_Rs,             do_rdrsrs},
 688   {"subc.c",    0x00000017, 0x3e0003ff, 0x8000,     Rd_Rs_Rs,             do_rdrsrs},
 689   {"sub!",      0x2001,     0x700f,     0x00000015, Rd_Rs,                do16_rdrs},
 690   {"subei!",    0x6080,     0x7087,     0x02000001, Rd_I4,                do16_rdi4},
 691   {"sw!",       0x200c,     0x700f,     0x28000000, Rd_lvalueRs,          do16_ldst_insn},
 692   {"swp!",      0x7004,     0x7007,     0x28000000, Rd_lvalueBP_I5,       do16_ldst_imm_insn},
 693   {"syscall",   0x00000002, 0x3e0003ff, 0x8000,     I15,                  do_i15},
 694   {"tcs",       0x00000054, 0x3e007fff, 0x0005,     NO_OPD,               do_empty},
 695   {"tcc",       0x00000454, 0x3e007fff, 0x0105,     NO_OPD,               do_empty},
 696   {"tcnz",      0x00003854, 0x3e007fff, 0x0e05,     NO_OPD,               do_empty},
 697   {"tcs!",      0x0005,     0x7f0f,     0x00000054, NO16_OPD,             do_empty},
 698   {"tcc!",      0x0105,     0x7f0f,     0x00000454, NO16_OPD,             do_empty},
 699   {"tcnz!",     0x0e05,     0x7f0f,     0x00003854, NO16_OPD,             do_empty},
 700   {"teq",       0x00001054, 0x3e007fff, 0x0405,     NO_OPD,               do_empty},
 701   {"teq!",      0x0405,     0x7f0f,     0x00001054, NO16_OPD,             do_empty},
 702   {"tgtu",      0x00000854, 0x3e007fff, 0x0205,     NO_OPD,               do_empty},
 703   {"tgt",       0x00001854, 0x3e007fff, 0x0605,     NO_OPD,               do_empty},
 704   {"tge",       0x00002054, 0x3e007fff, 0x0805,     NO_OPD,               do_empty},
 705   {"tgtu!",     0x0205,     0x7f0f,     0x00000854, NO16_OPD,             do_empty},
 706   {"tgt!",      0x0605,     0x7f0f,     0x00001854, NO16_OPD,             do_empty},
 707   {"tge!",      0x0805,     0x7f0f,     0x00002054, NO16_OPD,             do_empty},
 708   {"tleu",      0x00000c54, 0x3e007fff, 0x0305,     NO_OPD,               do_empty},
 709   {"tle",       0x00001c54, 0x3e007fff, 0x0705,     NO_OPD,               do_empty},
 710   {"tlt",       0x00002454, 0x3e007fff, 0x0905,     NO_OPD,               do_empty},
 711   {"stlb",      0x0c000004, 0x3e0003ff, 0x8000,     NO_OPD,               do_empty},
 712   {"mftlb",     0x0c000024, 0x3e0003ff, 0x8000,     NO_OPD,               do_empty},
 713   {"mtptlb",    0x0c000044, 0x3e0003ff, 0x8000,     NO_OPD,               do_empty},
 714   {"mtrtlb",    0x0c000064, 0x3e0003ff, 0x8000,     NO_OPD,               do_empty},
 715   {"tleu!",     0x0305,     0x7f0f,     0x00000c54, NO16_OPD,             do_empty},
 716   {"tle!",      0x0705,     0x7f0f,     0x00001c54, NO16_OPD,             do_empty},
 717   {"tlt!",      0x0905,     0x7f0f,     0x00002454, NO16_OPD,             do_empty},
 718   {"tmi",       0x00002854, 0x3e007fff, 0x0a05,     NO_OPD,               do_empty},
 719   {"tmi!",      0x0a05,     0x7f0f,     0x00002854, NO16_OPD,             do_empty},
 720   {"tne",       0x00001454, 0x3e007fff, 0x0505,     NO_OPD,               do_empty},
 721   {"tne!",      0x0505,     0x7f0f,     0x00001454, NO16_OPD,             do_empty},
 722   {"tpl",       0x00002c54, 0x3e007fff, 0x0b05,     NO_OPD,               do_empty},
 723   {"tpl!",      0x0b05,     0x7f0f,     0x00002c54, NO16_OPD,             do_empty},
 724   {"trapcs",    0x00000004, 0x3e007fff, 0x8000,     x_I5_x,               do_xi5x},
 725   {"trapcc",    0x00000404, 0x3e007fff, 0x8000,     x_I5_x,               do_xi5x},
 726   {"trapgtu",   0x00000804, 0x3e007fff, 0x8000,     x_I5_x,               do_xi5x},
 727   {"trapleu",   0x00000c04, 0x3e007fff, 0x8000,     x_I5_x,               do_xi5x},
 728   {"trapeq",    0x00001004, 0x3e007fff, 0x8000,     x_I5_x,               do_xi5x},
 729   {"trapne",    0x00001404, 0x3e007fff, 0x8000,     x_I5_x,               do_xi5x},
 730   {"trapgt",    0x00001804, 0x3e007fff, 0x8000,     x_I5_x,               do_xi5x},
 731   {"traple",    0x00001c04, 0x3e007fff, 0x8000,     x_I5_x,               do_xi5x},
 732   {"trapge",    0x00002004, 0x3e007fff, 0x8000,     x_I5_x,               do_xi5x},
 733   {"traplt",    0x00002404, 0x3e007fff, 0x8000,     x_I5_x,               do_xi5x},
 734   {"trapmi",    0x00002804, 0x3e007fff, 0x8000,     x_I5_x,               do_xi5x},
 735   {"trappl",    0x00002c04, 0x3e007fff, 0x8000,     x_I5_x,               do_xi5x},
 736   {"trapvs",    0x00003004, 0x3e007fff, 0x8000,     x_I5_x,               do_xi5x},
 737   {"trapvc",    0x00003404, 0x3e007fff, 0x8000,     x_I5_x,               do_xi5x},
 738   {"trap",      0x00003c04, 0x3e007fff, 0x8000,     x_I5_x,               do_xi5x},
 739   {"tset",      0x00003c54, 0x3e007fff, 0x0f05,     NO_OPD,               do_empty},
 740   {"tset!",     0x0f05,     0x00007f0f, 0x00003c54, NO16_OPD,             do_empty},
 741   {"tvs",       0x00003054, 0x3e007fff, 0x0c05,     NO_OPD,               do_empty},
 742   {"tvc",       0x00003454, 0x3e007fff, 0x0d05,     NO_OPD,               do_empty},
 743   {"tvs!",      0x0c05,     0x7f0f,     0x00003054, NO16_OPD,             do_empty},
 744   {"tvc!",      0x0d05,     0x7f0f,     0x00003454, NO16_OPD,             do_empty},
 745   {"xor",       0x00000026, 0x3e0003ff, 0x8000,     Rd_Rs_Rs,             do_rdrsrs},
 746   {"xor.c",     0x00000027, 0x3e0003ff, 0x2007,     Rd_Rs_Rs,             do_rdrsrs},
 747   {"xor!",      0x2007,     0x700f,     0x00000027, Rd_Rs,                do16_rdrs},
 748   /* Macro instruction.  */
 749   {"li",        0x020c0000, 0x3e0e0000, 0x8000,     Insn_Type_SYN,        do_macro_li_rdi32},
 750   /* la reg, imm32        -->(1)  ldi  reg, simm16
 751                              (2)  ldis reg, %HI(imm32)
 752                                   ori  reg, %LO(imm32)
 753
 754      la reg, symbol       -->(1)  lis  reg, %HI(imm32)
 755                                   ori  reg, %LO(imm32)  */
 756   {"la",        0x020c0000, 0x3e0e0000, 0x8000,     Insn_Type_SYN,        do_macro_la_rdi32},
 757   {"div",       0x00000044, 0x3e0003ff, 0x8000,     Insn_Type_SYN,        do_macro_mul_rdrsrs},
 758   {"divu",      0x00000046, 0x3e0003ff, 0x8000,     Insn_Type_SYN,        do_macro_mul_rdrsrs},
 759   {"rem",       0x00000044, 0x3e0003ff, 0x8000,     Insn_Type_SYN,        do_macro_mul_rdrsrs},
 760   {"remu",      0x00000046, 0x3e0003ff, 0x8000,     Insn_Type_SYN,        do_macro_mul_rdrsrs},
 761   {"mul",       0x00000040, 0x3e0003ff, 0x8000,     Insn_Type_SYN,        do_macro_mul_rdrsrs},
 762   {"mulu",      0x00000042, 0x3e0003ff, 0x8000,     Insn_Type_SYN,        do_macro_mul_rdrsrs},
 763   {"maz",       0x00000040, 0x3e0003ff, 0x8000,     Insn_Type_SYN,        do_macro_mul_rdrsrs},
 764   {"mazu",      0x00000042, 0x3e0003ff, 0x8000,     Insn_Type_SYN,        do_macro_mul_rdrsrs},
 765   {"mul.f",     0x00000041, 0x3e0003ff, 0x8000,     Insn_Type_SYN,        do_macro_mul_rdrsrs},
 766   {"maz.f",     0x00000041, 0x3e0003ff, 0x8000,     Insn_Type_SYN,        do_macro_mul_rdrsrs},
 767   {"lb",        INSN_LB,    0x00000000, 0x8000,     Insn_Type_SYN,        do_macro_ldst_label},
 768   {"lbu",       INSN_LBU,   0x00000000, 0x200b,     Insn_Type_SYN,        do_macro_ldst_label},
 769   {"lh",        INSN_LH,    0x00000000, 0x2009,     Insn_Type_SYN,        do_macro_ldst_label},
 770   {"lhu",       INSN_LHU,   0x00000000, 0x8000,     Insn_Type_SYN,        do_macro_ldst_label},
 771   {"lw",        INSN_LW,    0x00000000, 0x2008,     Insn_Type_SYN,        do_macro_ldst_label},
 772   {"sb",        INSN_SB,    0x00000000, 0x200f,     Insn_Type_SYN,        do_macro_ldst_label},
 773   {"sh",        INSN_SH,    0x00000000, 0x200d,     Insn_Type_SYN,        do_macro_ldst_label},
 774   {"sw",        INSN_SW,    0x00000000, 0x200c,     Insn_Type_SYN,        do_macro_ldst_label},
 775   /* Assembler use internal.  */
 776   {"ld_i32hi",  0x0a0c0000, 0x3e0e0000, 0x8000,     Insn_internal, do_macro_rdi32hi},
 777   {"ld_i32lo",  0x020a0000, 0x3e0e0001, 0x8000,     Insn_internal, do_macro_rdi32lo},
 778   {"ldis_pic",  0x0a0c0000, 0x3e0e0000, 0x5000,     Insn_internal, do_rdi16_pic},
 779   {"addi_s_pic",0x02000000, 0x3e0e0001, 0x8000,     Insn_internal, do_addi_s_pic},
 780   {"addi_u_pic",0x02000000, 0x3e0e0001, 0x8000,     Insn_internal, do_addi_u_pic},
 781   {"lw_pic",    0x20000000, 0x3e000000, 0x8000,     Insn_internal, do_lw_pic},
 782 };
 783
 784 /* Next free entry in the pool.  */
 785 int next_literal_pool_place = 0;
 786
 787 /* Next literal pool number.  */
 788 int lit_pool_num = 1;
 789 symbolS *current_poolP = NULL;
 790
 791
 792 static int
 793 end_of_line (char *str)
 794 {
 795   int retval = SUCCESS;
 796
 797   skip_whitespace (str);
 798   if (*str != '\0')
 799     {
 800       retval = (int) FAIL;
 801
 802       if (!inst.error)
 803         inst.error = BAD_GARBAGE;
 804     }
 805
 806   return retval;
 807 }
 808
 809 static int
 810 score_reg_parse (char **ccp, struct hash_control *htab)
 811 {
 812   char *start = *ccp;
 813   char c;
 814   char *p;
 815   struct reg_entry *reg;
 816
 817   p = start;
 818   if (!ISALPHA (*p) || !is_name_beginner (*p))
 819     return (int) FAIL;
 820
 821   c = *p++;
 822
 823   while (ISALPHA (c) || ISDIGIT (c) || c == '_')
 824     c = *p++;
 825
 826   *--p = 0;
 827   reg = (struct reg_entry *) hash_find (htab, start);
 828   *p = c;
 829
 830   if (reg)
 831     {
 832       *ccp = p;
 833       return reg->number;
 834     }
 835   return (int) FAIL;
 836 }
 837
 838 /* If shift <= 0, only return reg.  */
 839
 840 static int
 841 reg_required_here (char **str, int shift, enum score_reg_type reg_type)
 842 {
 843   static char buff[MAX_LITERAL_POOL_SIZE];
 844   int reg = (int) FAIL;
 845   char *start = *str;
 846
 847   if ((reg = score_reg_parse (str, all_reg_maps[reg_type].htab)) != (int) FAIL)
 848     {
 849       if (reg_type == REG_TYPE_SCORE)
 850         {
 851           if ((reg == 1) && (nor1 == 1) && (inst.bwarn == 0))
 852             {
 853               as_warn (_("Using temp register(r1)"));
 854               inst.bwarn = 1;
 855             }
 856         }
 857       if (shift >= 0)
 858         {
 859           if (reg_type == REG_TYPE_SCORE_CR)
 860             strcpy (inst.reg, score_crn_table[reg].name);
 861           else if (reg_type == REG_TYPE_SCORE_SR)
 862             strcpy (inst.reg, score_srn_table[reg].name);
 863           else
 864             strcpy (inst.reg, "");
 865
 866           inst.instruction |= reg << shift;
 867         }
 868     }
 869   else
 870     {
 871       *str = start;
 872       sprintf (buff, _("register expected, not '%.100s'"), start);
 873       inst.error = buff;
 874     }
 875
 876   return reg;
 877 }
 878
 879 static int
 880 skip_past_comma (char **str)
 881 {
 882   char *p = *str;
 883   char c;
 884   int comma = 0;
 885
 886   while ((c = *p) == ' ' || c == ',')
 887     {
 888       p++;
 889       if (c == ',' && comma++)
 890         {
 891           inst.error = BAD_SKIP_COMMA;
 892           return (int) FAIL;
 893         }
 894     }
 895
 896   if ((c == '\0') || (comma == 0))
 897     {
 898       inst.error = BAD_SKIP_COMMA;
 899       return (int) FAIL;
 900     }
 901
 902   *str = p;
 903   return comma ? SUCCESS : (int) FAIL;
 904 }
 905
 906 static void
 907 do_rdrsrs (char *str)
 908 {
 909   skip_whitespace (str);
 910
 911   if (reg_required_here (&str, 20, REG_TYPE_SCORE) == (int) FAIL
 912       || skip_past_comma (&str) == (int) FAIL
 913       || reg_required_here (&str, 15, REG_TYPE_SCORE) == (int) FAIL
 914       || skip_past_comma (&str) == (int) FAIL
 915       || reg_required_here (&str, 10, REG_TYPE_SCORE) == (int) FAIL
 916       || end_of_line (str) == (int) FAIL)
 917     {
 918       return;
 919     }
 920   else
 921     {
 922       if ((((inst.instruction >> 15) & 0x10) == 0)
 923           && (((inst.instruction >> 10) & 0x10) == 0)
 924           && (((inst.instruction >> 20) & 0x10) == 0)
 925           && (inst.relax_inst != 0x8000)
 926           && (((inst.instruction >> 20) & 0xf) == ((inst.instruction >> 15) & 0xf)))
 927         {
 928           inst.relax_inst |= (((inst.instruction >> 10) & 0xf) << 4)
 929             | (((inst.instruction >> 15) & 0xf) << 8);
 930           inst.relax_size = 2;
 931         }
 932       else
 933         {
 934           inst.relax_inst = 0x8000;
 935         }
 936     }
 937 }
 938
 939 static int
 940 walk_no_bignums (symbolS * sp)
 941 {
 942   if (symbol_get_value_expression (sp)->X_op == O_big)
 943     return 1;
 944
 945   if (symbol_get_value_expression (sp)->X_add_symbol)
 946     return (walk_no_bignums (symbol_get_value_expression (sp)->X_add_symbol)
 947             || (symbol_get_value_expression (sp)->X_op_symbol
 948                 && walk_no_bignums (symbol_get_value_expression (sp)->X_op_symbol)));
 949
 950   return 0;
 951 }
 952
 953 static int
 954 my_get_expression (expressionS * ep, char **str)
 955 {
 956   char *save_in;
 957   segT seg;
 958
 959   save_in = input_line_pointer;
 960   input_line_pointer = *str;
 961   in_my_get_expression = 1;
 962   seg = expression (ep);
 963   in_my_get_expression = 0;
 964
 965   if (ep->X_op == O_illegal)
 966     {
 967       *str = input_line_pointer;
 968       input_line_pointer = save_in;
 969       inst.error = _("illegal expression");
 970       return (int) FAIL;
 971     }
 972   /* Get rid of any bignums now, so that we don't generate an error for which
 973      we can't establish a line number later on.  Big numbers are never valid
 974      in instructions, which is where this routine is always called.  */
 975   if (ep->X_op == O_big
 976       || (ep->X_add_symbol
 977           && (walk_no_bignums (ep->X_add_symbol)
 978               || (ep->X_op_symbol && walk_no_bignums (ep->X_op_symbol)))))
 979     {
 980       inst.error = _("invalid constant");
 981       *str = input_line_pointer;
 982       input_line_pointer = save_in;
 983       return (int) FAIL;
 984     }
 985
 986   if ((ep->X_add_symbol != NULL)
 987       && (inst.type != PC_DISP19div2)
 988       && (inst.type != PC_DISP8div2)
 989       && (inst.type != PC_DISP24div2)
 990       && (inst.type != PC_DISP11div2)
 991       && (inst.type != Insn_Type_SYN)
 992       && (inst.type != Rd_rvalueRs_SI15)
 993       && (inst.type != Rd_lvalueRs_SI15)
 994       && (inst.type != Insn_internal))
 995     {
 996       inst.error = BAD_ARGS;
 997       *str = input_line_pointer;
 998       input_line_pointer = save_in;
 999       return (int) FAIL;
1000     }
1001
1002   *str = input_line_pointer;
1003   input_line_pointer = save_in;
1004   return SUCCESS;
1005 }
1006
1007 /* Check if an immediate is valid.  If so, convert it to the right format.  */
1008
1009 static int
1010 validate_immediate (int val, unsigned int data_type, int hex_p)
1011 {
1012   switch (data_type)
1013     {
1014     case _VALUE_HI16:
1015       {
1016         int val_hi = ((val & 0xffff0000) >> 16);
1017
1018         if (score_df_range[data_type].range[0] <= val_hi
1019             && val_hi <= score_df_range[data_type].range[1])
1020           return val_hi;
1021       }
1022       break;
1023
1024     case _VALUE_LO16:
1025       {
1026         int val_lo = (val & 0xffff);
1027
1028         if (score_df_range[data_type].range[0] <= val_lo
1029             && val_lo <= score_df_range[data_type].range[1])
1030           return val_lo;
1031       }
1032       break;
1033
1034     case _VALUE:
1035       return val;
1036       break;
1037
1038     case _SIMM14:
1039       if (hex_p == 1)
1040         {
1041           if (!(val >= -0x2000 && val <= 0x3fff))
1042             {
1043               return (int) FAIL;
1044             }
1045         }
1046       else
1047         {
1048           if (!(val >= -8192 && val <= 8191))
1049             {
1050               return (int) FAIL;
1051             }
1052         }
1053
1054       return val;
1055       break;
1056
1057     case _SIMM16_NEG:
1058       if (hex_p == 1)
1059         {
1060           if (!(val >= -0x7fff && val <= 0xffff && val != 0x8000))
1061             {
1062               return (int) FAIL;
1063             }
1064         }
1065       else
1066         {
1067           if (!(val >= -32767 && val <= 32768))
1068             {
1069               return (int) FAIL;
1070             }
1071         }
1072
1073       val = -val;
1074       return val;
1075       break;
1076
1077     default:
1078       if (data_type == _SIMM14_NEG || data_type == _IMM16_NEG)
1079         val = -val;
1080
1081       if (score_df_range[data_type].range[0] <= val
1082           && val <= score_df_range[data_type].range[1])
1083         return val;
1084
1085       break;
1086     }
1087
1088   return (int) FAIL;
1089 }
1090
1091 static int
1092 data_op2 (char **str, int shift, enum score_data_type data_type)
1093 {
1094   int value;
1095   char data_exp[MAX_LITERAL_POOL_SIZE];
1096   char *dataptr;
1097   int cnt = 0;
1098   char *pp = NULL;
1099
1100   skip_whitespace (*str);
1101   inst.error = NULL;
1102   dataptr = * str;
1103
1104   /* Set hex_p to zero.  */
1105   int hex_p = 0;
1106
1107   while ((*dataptr != '\0') && (*dataptr != '|') && (cnt <= MAX_LITERAL_POOL_SIZE))     /* 0x7c = ='|' */
1108     {
1109       data_exp[cnt] = *dataptr;
1110       dataptr++;
1111       cnt++;
1112     }
1113
1114   data_exp[cnt] = '\0';
1115   pp = (char *)&data_exp;
1116
1117   if (*dataptr == '|')          /* process PCE */
1118     {
1119       if (my_get_expression (&inst.reloc.exp, &pp) == (int) FAIL)
1120         return (int) FAIL;
1121       end_of_line (pp);
1122       if (inst.error != 0)
1123         return (int) FAIL;       /* to ouptut_inst to printf out the error */
1124       *str = dataptr;
1125     }
1126   else                          /* process  16 bit */
1127     {
1128       if (my_get_expression (&inst.reloc.exp, str) == (int) FAIL)
1129         {
1130           return (int) FAIL;
1131         }
1132
1133       dataptr = (char *)data_exp;
1134       for (; *dataptr != '\0'; dataptr++)
1135         {
1136           *dataptr = TOLOWER (*dataptr);
1137           if (*dataptr == '!' || *dataptr == ' ')
1138             break;
1139         }
1140       dataptr = (char *)data_exp;
1141
1142       if ((dataptr != NULL)
1143           && (((strstr (dataptr, "0x")) != NULL)
1144               || ((strstr (dataptr, "0X")) != NULL)))
1145         {
1146           hex_p = 1;
1147           if ((data_type != _SIMM16_LA)
1148               && (data_type != _VALUE_HI16)
1149               && (data_type != _VALUE_LO16)
1150               && (data_type != _IMM16)
1151               && (data_type != _IMM15)
1152               && (data_type != _IMM14)
1153               && (data_type != _IMM4)
1154               && (data_type != _IMM5)
1155               && (data_type != _IMM8)
1156               && (data_type != _IMM5_RSHIFT_1)
1157               && (data_type != _IMM5_RSHIFT_2)
1158               && (data_type != _SIMM14)
1159               && (data_type != _SIMM14_NEG)
1160               && (data_type != _SIMM16_NEG)
1161               && (data_type != _IMM10_RSHIFT_2)
1162               && (data_type != _GP_IMM15))
1163             {
1164               data_type += 24;
1165             }
1166         }
1167
1168       if ((inst.reloc.exp.X_add_number == 0)
1169           && (inst.type != Insn_Type_SYN)
1170           && (inst.type != Rd_rvalueRs_SI15)
1171           && (inst.type != Rd_lvalueRs_SI15)
1172           && (inst.type != Insn_internal)
1173           && (((*dataptr >= 'a') && (*dataptr <= 'z'))
1174              || ((*dataptr == '0') && (*(dataptr + 1) == 'x') && (*(dataptr + 2) != '0'))
1175              || ((*dataptr == '+') && (*(dataptr + 1) != '0'))
1176              || ((*dataptr == '-') && (*(dataptr + 1) != '0'))))
1177         {
1178           inst.error = BAD_ARGS;
1179           return (int) FAIL;
1180         }
1181     }
1182
1183   if ((inst.reloc.exp.X_add_symbol)
1184       && ((data_type == _SIMM16)
1185           || (data_type == _SIMM16_NEG)
1186           || (data_type == _IMM16_NEG)
1187           || (data_type == _SIMM14)
1188           || (data_type == _SIMM14_NEG)
1189           || (data_type == _IMM5)
1190           || (data_type == _IMM14)
1191           || (data_type == _IMM20)
1192           || (data_type == _IMM16)
1193           || (data_type == _IMM15)
1194           || (data_type == _IMM4)))
1195     {
1196       inst.error = BAD_ARGS;
1197       return (int) FAIL;
1198     }
1199
1200   if (inst.reloc.exp.X_add_symbol)
1201     {
1202       switch (data_type)
1203         {
1204         case _SIMM16_LA:
1205           return (int) FAIL;
1206         case _VALUE_HI16:
1207           inst.reloc.type = BFD_RELOC_HI16_S;
1208           inst.reloc.pc_rel = 0;
1209           break;
1210         case _VALUE_LO16:
1211           inst.reloc.type = BFD_RELOC_LO16;
1212           inst.reloc.pc_rel = 0;
1213           break;
1214         case _GP_IMM15:
1215           inst.reloc.type = BFD_RELOC_SCORE_GPREL15;
1216           inst.reloc.pc_rel = 0;
1217           break;
1218         case _SIMM16_pic:
1219         case _IMM16_LO16_pic:
1220           inst.reloc.type = BFD_RELOC_SCORE_GOT_LO16;
1221           inst.reloc.pc_rel = 0;
1222           break;
1223         default:
1224           inst.reloc.type = BFD_RELOC_32;
1225           inst.reloc.pc_rel = 0;
1226           break;
1227         }
1228     }
1229   else
1230     {
1231       if (data_type == _IMM16_pic)
1232         {
1233           inst.reloc.type = BFD_RELOC_SCORE_DUMMY_HI16;
1234           inst.reloc.pc_rel = 0;
1235         }
1236
1237       if (data_type == _SIMM16_LA && inst.reloc.exp.X_unsigned == 1)
1238         {
1239           value = validate_immediate (inst.reloc.exp.X_add_number, _SIMM16_LA_POS, hex_p);
1240           if (value == (int) FAIL)       /* for advance to check if this is ldis */
1241             if ((inst.reloc.exp.X_add_number & 0xffff) == 0)
1242               {
1243                 inst.instruction |= 0x8000000;
1244                 inst.instruction |= ((inst.reloc.exp.X_add_number >> 16) << 1) & 0x1fffe;
1245                 return SUCCESS;
1246               }
1247         }
1248       else
1249         {
1250           value = validate_immediate (inst.reloc.exp.X_add_number, data_type, hex_p);
1251         }
1252
1253       if (value == (int) FAIL)
1254         {
1255           if ((data_type != _SIMM14_NEG) && (data_type != _SIMM16_NEG) && (data_type != _IMM16_NEG))
1256             {
1257               sprintf (err_msg,
1258                        _("invalid constant: %d bit expression not in range %d..%d"),
1259                        score_df_range[data_type].bits,
1260                        score_df_range[data_type].range[0], score_df_range[data_type].range[1]);
1261             }
1262           else
1263             {
1264               sprintf (err_msg,
1265                        _("invalid constant: %d bit expression not in range %d..%d"),
1266                        score_df_range[data_type].bits,
1267                        -score_df_range[data_type].range[1], -score_df_range[data_type].range[0]);
1268             }
1269
1270           inst.error = err_msg;
1271           return (int) FAIL;
1272         }
1273
1274       if ((score_df_range[data_type].range[0] != 0) || (data_type == _IMM5_RANGE_8_31))
1275         {
1276           value &= (1 << score_df_range[data_type].bits) - 1;
1277         }
1278
1279       inst.instruction |= value << shift;
1280     }
1281
1282   if ((inst.instruction & 0xf0000000) == 0x30000000)
1283     {
1284       if ((((inst.instruction >> 20) & 0x1F) != 0)
1285           && (((inst.instruction >> 20) & 0x1F) != 1)
1286           && (((inst.instruction >> 20) & 0x1F) != 2)
1287           && (((inst.instruction >> 20) & 0x1F) != 3)
1288           && (((inst.instruction >> 20) & 0x1F) != 4)
1289           && (((inst.instruction >> 20) & 0x1F) != 8)
1290           && (((inst.instruction >> 20) & 0x1F) != 9)
1291           && (((inst.instruction >> 20) & 0x1F) != 0xa)
1292           && (((inst.instruction >> 20) & 0x1F) != 0xb)
1293           && (((inst.instruction >> 20) & 0x1F) != 0xc)
1294           && (((inst.instruction >> 20) & 0x1F) != 0xd)
1295           && (((inst.instruction >> 20) & 0x1F) != 0xe)
1296           && (((inst.instruction >> 20) & 0x1F) != 0x10)
1297           && (((inst.instruction >> 20) & 0x1F) != 0x11)
1298           && (((inst.instruction >> 20) & 0x1F) != 0x18)
1299           && (((inst.instruction >> 20) & 0x1F) != 0x1A)
1300           && (((inst.instruction >> 20) & 0x1F) != 0x1B)
1301           && (((inst.instruction >> 20) & 0x1F) != 0x1d)
1302           && (((inst.instruction >> 20) & 0x1F) != 0x1e)
1303           && (((inst.instruction >> 20) & 0x1F) != 0x1f))
1304         {
1305           inst.error = _("invalid constant: bit expression not defined");
1306           return (int) FAIL;
1307         }
1308     }
1309
1310   return SUCCESS;
1311 }
1312
1313 /* Handle addi/addi.c/addis.c/cmpi.c/addis.c/ldi.  */
1314
1315 static void
1316 do_rdsi16 (char *str)
1317 {
1318   skip_whitespace (str);
1319
1320   if (reg_required_here (&str, 20, REG_TYPE_SCORE) == (int) FAIL
1321       || skip_past_comma (&str) == (int) FAIL
1322       || data_op2 (&str, 1, _SIMM16) == (int) FAIL
1323       || end_of_line (str) == (int) FAIL)
1324     return;
1325
1326   /* ldi.  */
1327   if ((inst.instruction & 0x20c0000) == 0x20c0000)
1328     {
1329       if ((((inst.instruction >> 20) & 0x10) == 0x10) || ((inst.instruction & 0x1fe00) != 0))
1330         {
1331           inst.relax_inst = 0x8000;
1332         }
1333       else
1334         {
1335           inst.relax_inst |= (inst.instruction >> 1) & 0xff;
1336           inst.relax_inst |= (((inst.instruction >> 20) & 0xf) << 8);
1337           inst.relax_size = 2;
1338         }
1339     }
1340   else if (((inst.instruction >> 20) & 0x10) == 0x10)
1341     {
1342       inst.relax_inst = 0x8000;
1343     }
1344 }
1345
1346 /* Handle subi/subi.c.  */
1347
1348 static void
1349 do_sub_rdsi16 (char *str)
1350 {
1351   skip_whitespace (str);
1352
1353   if (reg_required_here (&str, 20, REG_TYPE_SCORE) != (int) FAIL
1354       && skip_past_comma (&str) != (int) FAIL
1355       && data_op2 (&str, 1, _SIMM16_NEG) != (int) FAIL)
1356     end_of_line (str);
1357 }
1358
1359 /* Handle addri/addri.c.  */
1360
1361 static void
1362 do_rdrssi14 (char *str)         /* -(2^13)~((2^13)-1) */
1363 {
1364   skip_whitespace (str);
1365
1366   if (reg_required_here (&str, 20, REG_TYPE_SCORE) != (int) FAIL
1367       && skip_past_comma (&str) != (int) FAIL
1368       && reg_required_here (&str, 15, REG_TYPE_SCORE) != (int) FAIL
1369       && skip_past_comma (&str) != (int) FAIL)
1370     data_op2 (&str, 1, _SIMM14);
1371 }
1372
1373 /* Handle subri.c/subri.  */
1374 static void
1375 do_sub_rdrssi14 (char *str)     /* -(2^13)~((2^13)-1) */
1376 {
1377   skip_whitespace (str);
1378
1379   if (reg_required_here (&str, 20, REG_TYPE_SCORE) != (int) FAIL
1380       && skip_past_comma (&str) != (int) FAIL
1381       && reg_required_here (&str, 15, REG_TYPE_SCORE) != (int) FAIL
1382       && skip_past_comma (&str) != (int) FAIL
1383       && data_op2 (&str, 1, _SIMM14_NEG) != (int) FAIL)
1384     end_of_line (str);
1385 }
1386
1387 /* Handle bitclr.c/bitset.c/bittgl.c/slli.c/srai.c/srli.c/roli.c/rori.c/rolic.c.  */
1388 static void
1389 do_rdrsi5 (char *str)           /* 0~((2^14)-1) */
1390 {
1391   skip_whitespace (str);
1392
1393   if (reg_required_here (&str, 20, REG_TYPE_SCORE) == (int) FAIL
1394       || skip_past_comma (&str) == (int) FAIL
1395       || reg_required_here (&str, 15, REG_TYPE_SCORE) == (int) FAIL
1396       || skip_past_comma (&str) == (int) FAIL
1397       || data_op2 (&str, 10, _IMM5) == (int) FAIL
1398       || end_of_line (str) == (int) FAIL)
1399     return;
1400
1401   if ((((inst.instruction >> 20) & 0x1f) == ((inst.instruction >> 15) & 0x1f))
1402       && (inst.relax_inst != 0x8000) && (((inst.instruction >> 15) & 0x10) == 0))
1403     {
1404       inst.relax_inst |= (((inst.instruction >> 10) & 0x1f) << 3) | (((inst.instruction >> 15) & 0xf) << 8);
1405       inst.relax_size = 2;
1406     }
1407   else
1408     inst.relax_inst = 0x8000;
1409 }
1410
1411 /* Handle andri/orri/andri.c/orri.c.  */
1412
1413 static void
1414 do_rdrsi14 (char *str)          /* 0 ~ ((2^14)-1)  */
1415 {
1416   skip_whitespace (str);
1417
1418   if (reg_required_here (&str, 20, REG_TYPE_SCORE) != (int) FAIL
1419       && skip_past_comma (&str) != (int) FAIL
1420       && reg_required_here (&str, 15, REG_TYPE_SCORE) != (int) FAIL
1421       && skip_past_comma (&str) != (int) FAIL
1422       && data_op2 (&str, 1, _IMM14) != (int) FAIL)
1423     end_of_line (str);
1424 }
1425
1426 /* Handle bittst.c.  */
1427 static void
1428 do_xrsi5 (char *str)
1429 {
1430   skip_whitespace (str);
1431
1432   if (reg_required_here (&str, 15, REG_TYPE_SCORE) == (int) FAIL
1433       || skip_past_comma (&str) == (int) FAIL
1434       || data_op2 (&str, 10, _IMM5) == (int) FAIL
1435       || end_of_line (str) == (int) FAIL)
1436     return;
1437
1438   if ((inst.relax_inst != 0x8000) && (((inst.instruction >> 15) & 0x10) == 0))
1439     {
1440       inst.relax_inst |= (((inst.instruction >> 10) & 0x1f) << 3) | (((inst.instruction >> 15) & 0xf) << 8);
1441       inst.relax_size = 2;
1442     }
1443   else
1444     inst.relax_inst = 0x8000;
1445 }
1446
1447 /* Handle addis/andi/ori/andis/oris/ldis.  */
1448 static void
1449 do_rdi16 (char *str)
1450 {
1451   skip_whitespace (str);
1452
1453   if (reg_required_here (&str, 20, REG_TYPE_SCORE) == (int) FAIL
1454       || skip_past_comma (&str) == (int) FAIL
1455       || data_op2 (&str, 1, _IMM16) == (int) FAIL
1456       || end_of_line (str) == (int) FAIL)
1457     return;
1458   /*
1459   if (((inst.instruction & 0xa0dfffe) != 0xa0c0000) || ((((inst.instruction >> 20) & 0x1f) & 0x10) == 0x10))
1460     inst.relax_inst = 0x8000;
1461   else
1462     inst.relax_size = 2;
1463   */
1464 }
1465
1466 static void
1467 do_macro_rdi32hi (char *str)
1468 {
1469   skip_whitespace (str);
1470
1471   /* Do not handle end_of_line().  */
1472   if (reg_required_here (&str, 20, REG_TYPE_SCORE) != (int) FAIL
1473       && skip_past_comma (&str) != (int) FAIL)
1474     data_op2 (&str, 1, _VALUE_HI16);
1475 }
1476
1477 static void
1478 do_macro_rdi32lo (char *str)
1479 {
1480   skip_whitespace (str);
1481
1482   /* Do not handle end_of_line().  */
1483   if (reg_required_here (&str, 20, REG_TYPE_SCORE) != (int) FAIL
1484       && skip_past_comma (&str) != (int) FAIL)
1485     data_op2 (&str, 1, _VALUE_LO16);
1486 }
1487
1488 /* Handle ldis_pic.  */
1489
1490 static void
1491 do_rdi16_pic (char *str)
1492 {
1493   skip_whitespace (str);
1494
1495   if (reg_required_here (&str, 20, REG_TYPE_SCORE) != (int) FAIL
1496       && skip_past_comma (&str) != (int) FAIL
1497       && data_op2 (&str, 1, _IMM16_pic) != (int) FAIL)
1498     end_of_line (str);
1499 }
1500
1501 /* Handle addi_s_pic to generate R_SCORE_GOT_LO16 .  */
1502
1503 static void
1504 do_addi_s_pic (char *str)
1505 {
1506   skip_whitespace (str);
1507
1508   if (reg_required_here (&str, 20, REG_TYPE_SCORE) != (int) FAIL
1509       && skip_past_comma (&str) != (int) FAIL
1510       && data_op2 (&str, 1, _SIMM16_pic) != (int) FAIL)
1511     end_of_line (str);
1512 }
1513
1514 /* Handle addi_u_pic to generate R_SCORE_GOT_LO16 .  */
1515
1516 static void
1517 do_addi_u_pic (char *str)
1518 {
1519   skip_whitespace (str);
1520
1521   if (reg_required_here (&str, 20, REG_TYPE_SCORE) != (int) FAIL
1522       && skip_past_comma (&str) != (int) FAIL
1523       && data_op2 (&str, 1, _IMM16_LO16_pic) != (int) FAIL)
1524     end_of_line (str);
1525 }
1526
1527 /* Handle mfceh/mfcel/mtceh/mtchl.  */
1528
1529 static void
1530 do_rd (char *str)
1531 {
1532   skip_whitespace (str);
1533
1534   if (reg_required_here (&str, 20, REG_TYPE_SCORE) != (int) FAIL)
1535     end_of_line (str);
1536 }
1537
1538 static void
1539 do_rs (char *str)
1540 {
1541   skip_whitespace (str);
1542
1543   if (reg_required_here (&str, 15, REG_TYPE_SCORE) == (int) FAIL
1544       || end_of_line (str) == (int) FAIL)
1545     return;
1546
1547   if ((inst.relax_inst != 0x8000) && (((inst.instruction >> 15) & 0x10) == 0))
1548     {
1549       inst.relax_inst |= (((inst.instruction >> 10) & 0xf) << 8) | (((inst.instruction >> 15) & 0xf) << 4);
1550       inst.relax_size = 2;
1551     }
1552   else
1553     inst.relax_inst = 0x8000;
1554 }
1555
1556 static void
1557 do_i15 (char *str)
1558 {
1559   skip_whitespace (str);
1560
1561   if (data_op2 (&str, 10, _IMM15) != (int) FAIL)
1562     end_of_line (str);
1563 }
1564
1565 static void
1566 do_xi5x (char *str)
1567 {
1568   skip_whitespace (str);
1569
1570   if (data_op2 (&str, 15, _IMM5) == (int) FAIL || end_of_line (str) == (int) FAIL)
1571     return;
1572
1573   if (inst.relax_inst != 0x8000)
1574     {
1575       inst.relax_inst |= (((inst.instruction >> 15) & 0x1f) << 3);
1576       inst.relax_size = 2;
1577     }
1578 }
1579
1580 static void
1581 do_rdrs (char *str)
1582 {
1583   skip_whitespace (str);
1584
1585   if (reg_required_here (&str, 20, REG_TYPE_SCORE) == (int) FAIL
1586       || skip_past_comma (&str) == (int) FAIL
1587       || reg_required_here (&str, 15, REG_TYPE_SCORE) == (int) FAIL
1588       || end_of_line (str) == (int) FAIL)
1589     return;
1590
1591   if (inst.relax_inst != 0x8000)
1592     {
1593       if (((inst.instruction & 0x7f) == 0x56))  /* adjust mv -> mv! / mlfh! / mhfl! */
1594         {
1595           /* mlfh */
1596           if ((((inst.instruction >> 15) & 0x10) != 0x0) && (((inst.instruction >> 20) & 0x10) == 0))
1597             {
1598               inst.relax_inst = 0x00000001 | (((inst.instruction >> 15) & 0xf) << 4)
1599                 | (((inst.instruction >> 20) & 0xf) << 8);
1600               inst.relax_size = 2;
1601             }
1602           /* mhfl */
1603           else if ((((inst.instruction >> 15) & 0x10) == 0x0) && ((inst.instruction >> 20) & 0x10) != 0)
1604             {
1605               inst.relax_inst = 0x00000002 | (((inst.instruction >> 15) & 0xf) << 4)
1606                 | (((inst.instruction >> 20) & 0xf) << 8);
1607               inst.relax_size = 2;
1608             }
1609           else if ((((inst.instruction >> 15) & 0x10) == 0x0) && (((inst.instruction >> 20) & 0x10) == 0))
1610             {
1611               inst.relax_inst |= (((inst.instruction >> 15) & 0xf) << 4)
1612                 | (((inst.instruction >> 20) & 0xf) << 8);
1613               inst.relax_size = 2;
1614             }
1615           else
1616             {
1617               inst.relax_inst = 0x8000;
1618             }
1619         }
1620       else if ((((inst.instruction >> 15) & 0x10) == 0x0) && (((inst.instruction >> 20) & 0x10) == 0))
1621         {
1622           inst.relax_inst |= (((inst.instruction >> 15) & 0xf) << 4)
1623             | (((inst.instruction >> 20) & 0xf) << 8);
1624           inst.relax_size = 2;
1625         }
1626       else
1627         {
1628           inst.relax_inst = 0x8000;
1629         }
1630     }
1631 }
1632
1633 /* Handle mfcr/mtcr.  */
1634 static void
1635 do_rdcrs (char *str)
1636 {
1637   skip_whitespace (str);
1638
1639   if (reg_required_here (&str, 20, REG_TYPE_SCORE) != (int) FAIL
1640       && skip_past_comma (&str) != (int) FAIL
1641       && reg_required_here (&str, 15, REG_TYPE_SCORE_CR) != (int) FAIL)
1642     end_of_line (str);
1643 }
1644
1645 /* Handle mfsr/mtsr.  */
1646
1647 static void
1648 do_rdsrs (char *str)
1649 {
1650   skip_whitespace (str);
1651
1652   /* mfsr */
1653   if ((inst.instruction & 0xff) == 0x50)
1654     {
1655       if (reg_required_here (&str, 20, REG_TYPE_SCORE) != (int) FAIL
1656           && skip_past_comma (&str) != (int) FAIL
1657           && reg_required_here (&str, 10, REG_TYPE_SCORE_SR) != (int) FAIL)
1658         end_of_line (str);
1659     }
1660   else
1661     {
1662       if (reg_required_here (&str, 15, REG_TYPE_SCORE) != (int) FAIL
1663           && skip_past_comma (&str) != (int) FAIL)
1664         reg_required_here (&str, 10, REG_TYPE_SCORE_SR);
1665     }
1666 }
1667
1668 /* Handle neg.  */
1669
1670 static void
1671 do_rdxrs (char *str)
1672 {
1673   skip_whitespace (str);
1674
1675   if (reg_required_here (&str, 20, REG_TYPE_SCORE) == (int) FAIL
1676       || skip_past_comma (&str) == (int) FAIL
1677       || reg_required_here (&str, 10, REG_TYPE_SCORE) == (int) FAIL
1678       || end_of_line (str) == (int) FAIL)
1679     return;
1680
1681   if ((inst.relax_inst != 0x8000) && (((inst.instruction >> 10) & 0x10) == 0)
1682       && (((inst.instruction >> 20) & 0x10) == 0))
1683     {
1684       inst.relax_inst |= (((inst.instruction >> 10) & 0xf) << 4) | (((inst.instruction >> 20) & 0xf) << 8);
1685       inst.relax_size = 2;
1686     }
1687   else
1688     inst.relax_inst = 0x8000;
1689 }
1690
1691 /* Handle cmp.c/cmp<cond>.  */
1692 static void
1693 do_rsrs (char *str)
1694 {
1695   skip_whitespace (str);
1696
1697   if (reg_required_here (&str, 15, REG_TYPE_SCORE) == (int) FAIL
1698       || skip_past_comma (&str) == (int) FAIL
1699       || reg_required_here (&str, 10, REG_TYPE_SCORE) == (int) FAIL
1700       || end_of_line (str) == (int) FAIL)
1701     return;
1702
1703   if ((inst.relax_inst != 0x8000) && (((inst.instruction >> 20) & 0x1f) == 3)
1704       && (((inst.instruction >> 10) & 0x10) == 0) && (((inst.instruction >> 15) & 0x10) == 0))
1705     {
1706       inst.relax_inst |= (((inst.instruction >> 10) & 0xf) << 4) | (((inst.instruction >> 15) & 0xf) << 8);
1707       inst.relax_size = 2;
1708     }
1709   else
1710     inst.relax_inst = 0x8000;
1711 }
1712
1713 static void
1714 do_ceinst (char *str)
1715 {
1716   char *strbak;
1717
1718   strbak = str;
1719   skip_whitespace (str);
1720
1721   if (data_op2 (&str, 20, _IMM5) == (int) FAIL
1722       || skip_past_comma (&str) == (int) FAIL
1723       || reg_required_here (&str, 15, REG_TYPE_SCORE) == (int) FAIL
1724       || skip_past_comma (&str) == (int) FAIL
1725       || reg_required_here (&str, 10, REG_TYPE_SCORE) == (int) FAIL
1726       || skip_past_comma (&str) == (int) FAIL
1727       || data_op2 (&str, 5, _IMM5) == (int) FAIL
1728       || skip_past_comma (&str) == (int) FAIL
1729       || data_op2 (&str, 0, _IMM5) == (int) FAIL
1730       || end_of_line (str) == (int) FAIL)
1731     {
1732       return;
1733     }
1734   else
1735     {
1736       str = strbak;
1737       if (data_op2 (&str, 0, _IMM25) == (int) FAIL)
1738         return;
1739     }
1740 }
1741
1742 static int
1743 reglow_required_here (char **str, int shift)
1744 {
1745   static char buff[MAX_LITERAL_POOL_SIZE];
1746   int reg;
1747   char *start = *str;
1748
1749   if ((reg = score_reg_parse (str, all_reg_maps[REG_TYPE_SCORE].htab)) != (int) FAIL)
1750     {
1751       if ((reg == 1) && (nor1 == 1) && (inst.bwarn == 0))
1752         {
1753           as_warn (_("Using temp register(r1)"));
1754           inst.bwarn = 1;
1755         }
1756       if (reg < 16)
1757         {
1758           if (shift >= 0)
1759             inst.instruction |= reg << shift;
1760
1761           return reg;
1762         }
1763     }
1764
1765   /* Restore the start point, we may have got a reg of the wrong class.  */
1766   *str = start;
1767   sprintf (buff, _("low register(r0-r15)expected, not '%.100s'"), start);
1768   inst.error = buff;
1769   return (int) FAIL;
1770 }
1771
1772 /* Handle addc!/add!/and!/cmp!/neg!/not!/or!/sll!/srl!/sra!/xor!/sub!.  */
1773 static void
1774 do16_rdrs (char *str)
1775 {
1776   skip_whitespace (str);
1777
1778   if (reglow_required_here (&str, 8) == (int) FAIL
1779       || skip_past_comma (&str) == (int) FAIL
1780       || reglow_required_here (&str, 4) == (int) FAIL
1781       || end_of_line (str) == (int) FAIL)
1782     {
1783       return;
1784     }
1785   else
1786     {
1787       if ((inst.instruction & 0x700f) == 0x2003)        /* cmp!  */
1788         {
1789           inst.relax_inst |= (((inst.instruction >> 8) & 0xf) << 15)
1790             | (((inst.instruction >> 4) & 0xf) << 10);
1791         }
1792       else if ((inst.instruction & 0x700f) == 0x2006)   /* not!  */
1793         {
1794           inst.relax_inst |= (((inst.instruction >> 8) & 0xf) << 20)
1795             | (((inst.instruction >> 4) & 0xf) << 15);
1796         }
1797       else
1798         {
1799           inst.relax_inst |= (((inst.instruction >> 8) & 0xf) << 20)
1800             | (((inst.instruction >> 8) & 0xf) << 15) | (((inst.instruction >> 4) & 0xf) << 10);
1801         }
1802       inst.relax_size = 4;
1803     }
1804 }
1805
1806 static void
1807 do16_rs (char *str)
1808 {
1809   int rd = 0;
1810
1811   skip_whitespace (str);
1812
1813   if ((rd = reglow_required_here (&str, 4)) == (int) FAIL
1814       || end_of_line (str) == (int) FAIL)
1815     {
1816       return;
1817     }
1818   else
1819     {
1820       inst.relax_inst |= rd << 20;
1821       inst.relax_size = 4;
1822     }
1823 }
1824
1825 /* Handle br!/brl!.  */
1826 static void
1827 do16_xrs (char *str)
1828 {
1829   skip_whitespace (str);
1830
1831   if (reglow_required_here (&str, 4) == (int) FAIL || end_of_line (str) == (int) FAIL)
1832     {
1833       return;
1834     }
1835   else
1836     {
1837       inst.relax_inst |= (((inst.instruction >> 8) & 0xf) << 10)
1838                       | (((inst.instruction >> 4) & 0xf) << 15);
1839       inst.relax_size = 4;
1840     }
1841 }
1842
1843 static int
1844 reghigh_required_here (char **str, int shift)
1845 {
1846   static char buff[MAX_LITERAL_POOL_SIZE];
1847   int reg;
1848   char *start = *str;
1849
1850   if ((reg = score_reg_parse (str, all_reg_maps[REG_TYPE_SCORE].htab)) != (int) FAIL)
1851     {
1852       if (15 < reg && reg < 32)
1853         {
1854           if (shift >= 0)
1855             inst.instruction |= (reg & 0xf) << shift;
1856
1857           return reg;
1858         }
1859     }
1860
1861   *str = start;
1862   sprintf (buff, _("high register(r16-r31)expected, not '%.100s'"), start);
1863   inst.error = buff;
1864   return (int) FAIL;
1865 }
1866
1867 /* Handle mhfl!.  */
1868 static void
1869 do16_hrdrs (char *str)
1870 {
1871   skip_whitespace (str);
1872
1873   if (reghigh_required_here (&str, 8) != (int) FAIL
1874       && skip_past_comma (&str) != (int) FAIL
1875       && reglow_required_here (&str, 4) != (int) FAIL
1876       && end_of_line (str) != (int) FAIL)
1877     {
1878       inst.relax_inst |= ((((inst.instruction >> 8) & 0xf) | 0x10) << 20)
1879         | (((inst.instruction >> 4) & 0xf) << 15) | (0xf << 10);
1880       inst.relax_size = 4;
1881     }
1882 }
1883
1884 /* Handle mlfh!.  */
1885 static void
1886 do16_rdhrs (char *str)
1887 {
1888   skip_whitespace (str);
1889
1890   if (reglow_required_here (&str, 8) != (int) FAIL
1891       && skip_past_comma (&str) != (int) FAIL
1892       && reghigh_required_here (&str, 4) != (int) FAIL
1893       && end_of_line (str) != (int) FAIL)
1894     {
1895       inst.relax_inst |= (((inst.instruction >> 8) & 0xf) << 20)
1896         | ((((inst.instruction >> 4) & 0xf) | 0x10) << 15) | (0xf << 10);
1897       inst.relax_size = 4;
1898     }
1899 }
1900
1901 /* We need to be able to fix up arbitrary expressions in some statements.
1902    This is so that we can handle symbols that are an arbitrary distance from
1903    the pc.  The most common cases are of the form ((+/-sym -/+ . - 8) & mask),
1904    which returns part of an address in a form which will be valid for
1905    a data instruction.  We do this by pushing the expression into a symbol
1906    in the expr_section, and creating a fix for that.  */
1907 static fixS *
1908 fix_new_score (fragS * frag, int where, short int size, expressionS * exp, int pc_rel, int reloc)
1909 {
1910   fixS *new_fix;
1911
1912   switch (exp->X_op)
1913     {
1914     case O_constant:
1915     case O_symbol:
1916     case O_add:
1917     case O_subtract:
1918       new_fix = fix_new_exp (frag, where, size, exp, pc_rel, reloc);
1919       break;
1920     default:
1921       new_fix = fix_new (frag, where, size, make_expr_symbol (exp), 0, pc_rel, reloc);
1922       break;
1923     }
1924   return new_fix;
1925 }
1926
1927 static void
1928 init_dependency_vector (void)
1929 {
1930   int i;
1931
1932   for (i = 0; i < vector_size; i++)
1933     memset (&dependency_vector[i], '\0', sizeof (dependency_vector[i]));
1934
1935   return;
1936 }
1937
1938 static enum insn_type_for_dependency
1939 dependency_type_from_insn (char *insn_name)
1940 {
1941   char name[INSN_NAME_LEN];
1942   const struct insn_to_dependency *tmp;
1943
1944   strcpy (name, insn_name);
1945   tmp = (const struct insn_to_dependency *) hash_find (dependency_insn_hsh, name);
1946
1947   if (tmp)
1948     return tmp->type;
1949
1950   return D_all_insn;
1951 }
1952
1953 static int
1954 check_dependency (char *pre_insn, char *pre_reg,
1955                   char *cur_insn, char *cur_reg, int *warn_or_error)
1956 {
1957   int bubbles = 0;
1958   unsigned int i;
1959   enum insn_type_for_dependency pre_insn_type;
1960   enum insn_type_for_dependency cur_insn_type;
1961
1962   pre_insn_type = dependency_type_from_insn (pre_insn);
1963   cur_insn_type = dependency_type_from_insn (cur_insn);
1964
1965   for (i = 0; i < sizeof (data_dependency_table) / sizeof (data_dependency_table[0]); i++)
1966     {
1967       if ((pre_insn_type == data_dependency_table[i].pre_insn_type)
1968           && (D_all_insn == data_dependency_table[i].cur_insn_type
1969               || cur_insn_type == data_dependency_table[i].cur_insn_type)
1970           && (strcmp (data_dependency_table[i].pre_reg, "") == 0
1971               || strcmp (data_dependency_table[i].pre_reg, pre_reg) == 0)
1972           && (strcmp (data_dependency_table[i].cur_reg, "") == 0
1973               || strcmp (data_dependency_table[i].cur_reg, cur_reg) == 0))
1974         {
1975           bubbles = (score7) ? data_dependency_table[i].bubblenum_7 : data_dependency_table[i].bubblenum_5;
1976           *warn_or_error = data_dependency_table[i].warn_or_error;
1977           break;
1978         }
1979     }
1980
1981   return bubbles;
1982 }
1983
1984 static void
1985 build_one_frag (struct score_it one_inst)
1986 {
1987   char *p;
1988   int relaxable_p = g_opt;
1989   int relax_size = 0;
1990
1991   /* Start a new frag if frag_now is not empty.  */
1992   if (frag_now_fix () != 0)
1993     {
1994       if (!frag_now->tc_frag_data.is_insn)
1995         frag_wane (frag_now);
1996
1997       frag_new (0);
1998     }
1999   frag_grow (20);
2000
2001   p = frag_more (one_inst.size);
2002   md_number_to_chars (p, one_inst.instruction, one_inst.size);
2003
2004 #ifdef OBJ_ELF
2005   dwarf2_emit_insn (one_inst.size);
2006 #endif
2007
2008   relaxable_p &= (one_inst.relax_size != 0);
2009   relax_size = relaxable_p ? one_inst.relax_size : 0;
2010
2011   p = frag_var (rs_machine_dependent, relax_size + RELAX_PAD_BYTE, 0,
2012                 RELAX_ENCODE (one_inst.size, one_inst.relax_size,
2013                               one_inst.type, 0, 0, relaxable_p),
2014                 NULL, 0, NULL);
2015
2016   if (relaxable_p)
2017     md_number_to_chars (p, one_inst.relax_inst, relax_size);
2018 }
2019
2020 static void
2021 handle_dependency (struct score_it *theinst)
2022 {
2023   int i;
2024   int warn_or_error = 0;   /* warn - 0; error - 1  */
2025   int bubbles = 0;
2026   int remainder_bubbles = 0;
2027   char cur_insn[INSN_NAME_LEN];
2028   char pre_insn[INSN_NAME_LEN];
2029   struct score_it nop_inst;
2030   struct score_it pflush_inst;
2031
2032   nop_inst.instruction = 0x0000;
2033   nop_inst.size = 2;
2034   nop_inst.relax_inst = 0x80008000;
2035   nop_inst.relax_size = 4;
2036   nop_inst.type = NO16_OPD;
2037
2038   pflush_inst.instruction = 0x8000800a;
2039   pflush_inst.size = 4;
2040   pflush_inst.relax_inst = 0x8000;
2041   pflush_inst.relax_size = 0;
2042   pflush_inst.type = NO_OPD;
2043
2044   /* pflush will clear all data dependency.  */
2045   if (strcmp (theinst->name, "pflush") == 0)
2046     {
2047       init_dependency_vector ();
2048       return;
2049     }
2050
2051   /* Push current instruction to dependency_vector[0].  */
2052   for (i = vector_size - 1; i > 0; i--)
2053     memcpy (&dependency_vector[i], &dependency_vector[i - 1], sizeof (dependency_vector[i]));
2054
2055   memcpy (&dependency_vector[0], theinst, sizeof (dependency_vector[i]));
2056
2057   /* There is no dependency between nop and any instruction.  */
2058   if (strcmp (dependency_vector[0].name, "nop") == 0
2059       || strcmp (dependency_vector[0].name, "nop!") == 0)
2060     return;
2061
2062   /* "pce" is defined in insn_to_dependency_table.  */
2063 #define PCE_NAME "pce"
2064
2065   if (dependency_vector[0].type == Insn_Type_PCE)
2066     strcpy (cur_insn, PCE_NAME);
2067   else
2068     strcpy (cur_insn, dependency_vector[0].name);
2069
2070   for (i = 1; i < vector_size; i++)
2071     {
2072       /* The element of dependency_vector is NULL.  */
2073       if (dependency_vector[i].name[0] == '\0')
2074         continue;
2075
2076       if (dependency_vector[i].type == Insn_Type_PCE)
2077         strcpy (pre_insn, PCE_NAME);
2078       else
2079         strcpy (pre_insn, dependency_vector[i].name);
2080
2081       bubbles = check_dependency (pre_insn, dependency_vector[i].reg,
2082                                   cur_insn, dependency_vector[0].reg, &warn_or_error);
2083       remainder_bubbles = bubbles - i + 1;
2084
2085       if (remainder_bubbles > 0)
2086         {
2087           int j;
2088
2089           if (fix_data_dependency == 1)
2090             {
2091               if (remainder_bubbles <= 2)
2092                 {
2093                   if (warn_fix_data_dependency)
2094                     as_warn (_("Fix data dependency: %s %s -- %s %s  (insert %d nop!/%d)"),
2095                              dependency_vector[i].name, dependency_vector[i].reg,
2096                              dependency_vector[0].name, dependency_vector[0].reg,
2097                              remainder_bubbles, bubbles);
2098
2099                   for (j = (vector_size - 1); (j - remainder_bubbles) > 0; j--)
2100                     memcpy (&dependency_vector[j], &dependency_vector[j - remainder_bubbles],
2101                             sizeof (dependency_vector[j]));
2102
2103                   for (j = 1; j <= remainder_bubbles; j++)
2104                     {
2105                       memset (&dependency_vector[j], '\0', sizeof (dependency_vector[j]));
2106                       /* Insert nop!.  */
2107                       build_one_frag (nop_inst);
2108                     }
2109                 }
2110               else
2111                 {
2112                   if (warn_fix_data_dependency)
2113                     as_warn (_("Fix data dependency: %s %s -- %s %s  (insert 1 pflush/%d)"),
2114                              dependency_vector[i].name, dependency_vector[i].reg,
2115                              dependency_vector[0].name, dependency_vector[0].reg,
2116                              bubbles);
2117
2118                   for (j = 1; j < vector_size; j++)
2119                     memset (&dependency_vector[j], '\0', sizeof (dependency_vector[j]));
2120
2121                   /* Insert pflush.  */
2122                   build_one_frag (pflush_inst);
2123                 }
2124             }
2125           else
2126             {
2127               if (warn_or_error)
2128                 {
2129                   as_bad (_("data dependency: %s %s -- %s %s  (%d/%d bubble)"),
2130                            dependency_vector[i].name, dependency_vector[i].reg,
2131                            dependency_vector[0].name, dependency_vector[0].reg,
2132                            remainder_bubbles, bubbles);
2133                 }
2134               else
2135                 {
2136                   as_warn (_("data dependency: %s %s -- %s %s  (%d/%d bubble)"),
2137                            dependency_vector[i].name, dependency_vector[i].reg,
2138                            dependency_vector[0].name, dependency_vector[0].reg,
2139                            remainder_bubbles, bubbles);
2140                 }
2141             }
2142         }
2143     }
2144 }
2145
2146 static enum insn_class
2147 get_insn_class_from_type (enum score_insn_type type)
2148 {
2149   enum insn_class retval = (int) FAIL;
2150
2151   switch (type)
2152     {
2153     case Rd_I4:
2154     case Rd_I5:
2155     case Rd_rvalueBP_I5:
2156     case Rd_lvalueBP_I5:
2157     case Rd_I8:
2158     case PC_DISP8div2:
2159     case PC_DISP11div2:
2160     case Rd_Rs:
2161     case Rd_HighRs:
2162     case Rd_lvalueRs:
2163     case Rd_rvalueRs:
2164     case x_Rs:
2165     case Rd_LowRs:
2166     case NO16_OPD:
2167       retval = INSN_CLASS_16;
2168       break;
2169     case Rd_Rs_I5:
2170     case x_Rs_I5:
2171     case x_I5_x:
2172     case Rd_Rs_I14:
2173     case I15:
2174     case Rd_I16:
2175     case Rd_SI16:
2176     case Rd_rvalueRs_SI10:
2177     case Rd_lvalueRs_SI10:
2178     case Rd_rvalueRs_preSI12:
2179     case Rd_rvalueRs_postSI12:
2180     case Rd_lvalueRs_preSI12:
2181     case Rd_lvalueRs_postSI12:
2182     case Rd_Rs_SI14:
2183     case Rd_rvalueRs_SI15:
2184     case Rd_lvalueRs_SI15:
2185     case PC_DISP19div2:
2186     case PC_DISP24div2:
2187     case Rd_Rs_Rs:
2188     case x_Rs_x:
2189     case x_Rs_Rs:
2190     case Rd_Rs_x:
2191     case Rd_x_Rs:
2192     case Rd_x_x:
2193     case OP5_rvalueRs_SI15:
2194     case I5_Rs_Rs_I5_OP5:
2195     case x_rvalueRs_post4:
2196     case Rd_rvalueRs_post4:
2197     case Rd_x_I5:
2198     case Rd_lvalueRs_post4:
2199     case x_lvalueRs_post4:
2200     case Rd_Rs_Rs_imm:
2201     case NO_OPD:
2202     case Rd_lvalue32Rs:
2203     case Rd_rvalue32Rs:
2204     case Insn_GP:
2205     case Insn_PIC:
2206     case Insn_internal:
2207       retval = INSN_CLASS_32;
2208       break;
2209     case Insn_Type_PCE:
2210       retval = INSN_CLASS_PCE;
2211       break;
2212     case Insn_Type_SYN:
2213       retval = INSN_CLASS_SYN;
2214       break;
2215     default:
2216       abort ();
2217       break;
2218     }
2219   return retval;
2220 }
2221
2222 static unsigned long
2223 adjust_paritybit (unsigned long m_code, enum insn_class class)
2224 {
2225   unsigned long result = 0;
2226   unsigned long m_code_high = 0;
2227   unsigned long m_code_low = 0;
2228   unsigned long pb_high = 0;
2229   unsigned long pb_low = 0;
2230
2231   if (class == INSN_CLASS_32)
2232     {
2233       pb_high = 0x80000000;
2234       pb_low = 0x00008000;
2235     }
2236   else if (class == INSN_CLASS_16)
2237     {
2238       pb_high = 0;
2239       pb_low = 0;
2240     }
2241   else if (class == INSN_CLASS_PCE)
2242     {
2243       pb_high = 0;
2244       pb_low = 0x00008000;
2245     }
2246   else if (class == INSN_CLASS_SYN)
2247     {
2248       /* FIXME.  at this time, INSN_CLASS_SYN must be 32 bit, but, instruction type should
2249          be changed if macro instruction has been expanded.  */
2250       pb_high = 0x80000000;
2251       pb_low = 0x00008000;
2252     }
2253   else
2254     {
2255       abort ();
2256     }
2257
2258   m_code_high = m_code & 0x3fff8000;
2259   m_code_low = m_code & 0x00007fff;
2260   result = pb_high | (m_code_high << 1) | pb_low | m_code_low;
2261   return result;
2262
2263 }
2264
2265 static void
2266 gen_insn_frag (struct score_it *part_1, struct score_it *part_2)
2267 {
2268   char *p;
2269   bfd_boolean pce_p = FALSE;
2270   int relaxable_p = g_opt;
2271   int relax_size = 0;
2272   struct score_it *inst1 = part_1;
2273   struct score_it *inst2 = part_2;
2274   struct score_it backup_inst1;
2275
2276   pce_p = (inst2) ? TRUE : FALSE;
2277   memcpy (&backup_inst1, inst1, sizeof (struct score_it));
2278
2279   /* Adjust instruction opcode and to be relaxed instruction opcode.  */
2280   if (pce_p)
2281     {
2282       backup_inst1.instruction = ((backup_inst1.instruction & 0x7FFF) << 15)
2283                                   | (inst2->instruction & 0x7FFF);
2284       backup_inst1.instruction = adjust_paritybit (backup_inst1.instruction, INSN_CLASS_PCE);
2285       backup_inst1.relax_inst = 0x8000;
2286       backup_inst1.size = INSN_SIZE;
2287       backup_inst1.relax_size = 0;
2288       backup_inst1.type = Insn_Type_PCE;
2289     }
2290   else
2291     {
2292       backup_inst1.instruction = adjust_paritybit (backup_inst1.instruction,
2293                                                    GET_INSN_CLASS (backup_inst1.type));
2294     }
2295
2296   if (backup_inst1.relax_size != 0)
2297     {
2298       enum insn_class tmp;
2299
2300       tmp = (backup_inst1.size == INSN_SIZE) ? INSN_CLASS_16 : INSN_CLASS_32;
2301       backup_inst1.relax_inst = adjust_paritybit (backup_inst1.relax_inst, tmp);
2302     }
2303
2304   /* Check data dependency.  */
2305   handle_dependency (&backup_inst1);
2306
2307   /* Start a new frag if frag_now is not empty and is not instruction frag, maybe it contains
2308      data produced by .ascii etc.  Doing this is to make one instruction per frag.  */
2309   if (frag_now_fix () != 0)
2310     {
2311       if (!frag_now->tc_frag_data.is_insn)
2312         frag_wane (frag_now);
2313
2314       frag_new (0);
2315     }
2316
2317   /* Here, we must call frag_grow in order to keep the instruction frag type is
2318      rs_machine_dependent.
2319      For, frag_var may change frag_now->fr_type to rs_fill by calling frag_grow which
2320      acturally will call frag_wane.
2321      Calling frag_grow first will create a new frag_now which free size is 20 that is enough
2322      for frag_var.  */
2323   frag_grow (20);
2324
2325   p = frag_more (backup_inst1.size);
2326   md_number_to_chars (p, backup_inst1.instruction, backup_inst1.size);
2327
2328 #ifdef OBJ_ELF
2329   dwarf2_emit_insn (backup_inst1.size);
2330 #endif
2331
2332   /* Generate fixup structure.  */
2333   if (pce_p)
2334     {
2335       if (inst1->reloc.type != BFD_RELOC_NONE)
2336         fix_new_score (frag_now, p - frag_now->fr_literal,
2337                        inst1->size, &inst1->reloc.exp,
2338                        inst1->reloc.pc_rel, inst1->reloc.type);
2339
2340       if (inst2->reloc.type != BFD_RELOC_NONE)
2341         fix_new_score (frag_now, p - frag_now->fr_literal + 2,
2342                        inst2->size, &inst2->reloc.exp, inst2->reloc.pc_rel, inst2->reloc.type);
2343     }
2344   else
2345     {
2346       if (backup_inst1.reloc.type != BFD_RELOC_NONE)
2347         fix_new_score (frag_now, p - frag_now->fr_literal,
2348                        backup_inst1.size, &backup_inst1.reloc.exp,
2349                        backup_inst1.reloc.pc_rel, backup_inst1.reloc.type);
2350     }
2351
2352   /* relax_size may be 2, 4, 12 or 0, 0 indicates no relaxation.  */
2353   relaxable_p &= (backup_inst1.relax_size != 0);
2354   relax_size = relaxable_p ? backup_inst1.relax_size : 0;
2355
2356   p = frag_var (rs_machine_dependent, relax_size + RELAX_PAD_BYTE, 0,
2357                 RELAX_ENCODE (backup_inst1.size, backup_inst1.relax_size,
2358                               backup_inst1.type, 0, 0, relaxable_p),
2359                 backup_inst1.reloc.exp.X_add_symbol, 0, NULL);
2360
2361   if (relaxable_p)
2362     md_number_to_chars (p, backup_inst1.relax_inst, relax_size);
2363
2364   memcpy (inst1, &backup_inst1, sizeof (struct score_it));
2365 }
2366
2367 static void
2368 parse_16_32_inst (char *insnstr, bfd_boolean gen_frag_p)
2369 {
2370   char c;
2371   char *p;
2372   char *operator = insnstr;
2373   const struct asm_opcode *opcode;
2374
2375   /* Parse operator and operands.  */
2376   skip_whitespace (operator);
2377
2378   for (p = operator; *p != '\0'; p++)
2379     if ((*p == ' ') || (*p == '!'))
2380       break;
2381
2382   if (*p == '!')
2383     p++;
2384
2385   c = *p;
2386   *p = '\0';
2387
2388   opcode = (const struct asm_opcode *) hash_find (score_ops_hsh, operator);
2389   *p = c;
2390
2391   memset (&inst, '\0', sizeof (inst));
2392   sprintf (inst.str, "%s", insnstr);
2393   if (opcode)
2394     {
2395       inst.instruction = opcode->value;
2396       inst.relax_inst = opcode->relax_value;
2397       inst.type = opcode->type;
2398       inst.size = GET_INSN_SIZE (inst.type);
2399       inst.relax_size = 0;
2400       inst.bwarn = 0;
2401       sprintf (inst.name, "%s", opcode->template);
2402       strcpy (inst.reg, "");
2403       inst.error = NULL;
2404       inst.reloc.type = BFD_RELOC_NONE;
2405
2406       (*opcode->parms) (p);
2407
2408       /* It indicates current instruction is a macro instruction if inst.bwarn equals -1.  */
2409       if ((inst.bwarn != -1) && (!inst.error) && (gen_frag_p))
2410         gen_insn_frag (&inst, NULL);
2411     }
2412   else
2413     inst.error = _("unrecognized opcode");
2414 }
2415
2416 static int
2417 append_insn (char *str, bfd_boolean gen_frag_p)
2418 {
2419   int retval = SUCCESS;
2420
2421   parse_16_32_inst (str, gen_frag_p);
2422
2423   if (inst.error)
2424     {
2425       retval = (int) FAIL;
2426       as_bad (_("%s -- `%s'"), inst.error, inst.str);
2427       inst.error = NULL;
2428     }
2429
2430   return retval;
2431 }
2432
2433 /* Handle mv! reg_high, reg_low;
2434           mv! reg_low, reg_high;
2435           mv! reg_low, reg_low;  */
2436 static void
2437 do16_mv_rdrs (char *str)
2438 {
2439   int reg_rd;
2440   int reg_rs;
2441   char *backupstr = NULL;
2442
2443   backupstr = str;
2444   skip_whitespace (str);
2445
2446   if ((reg_rd = reg_required_here (&str, 8, REG_TYPE_SCORE)) == (int) FAIL
2447       || skip_past_comma (&str) == (int) FAIL
2448       || (reg_rs = reg_required_here (&str, 4, REG_TYPE_SCORE)) == (int) FAIL
2449       || end_of_line (str) == (int) FAIL)
2450     {
2451       return;
2452     }
2453   else
2454     {
2455       /* Case 1 : mv! or mlfh!.  */
2456       if (reg_rd < 16)
2457         {
2458           if (reg_rs < 16)
2459             {
2460               inst.relax_inst |= (((inst.instruction >> 8) & 0xf) << 20)
2461                 | (((inst.instruction >> 4) & 0xf) << 15) | (0xf << 10);
2462               inst.relax_size = 4;
2463             }
2464           else
2465             {
2466               char append_str[MAX_LITERAL_POOL_SIZE];
2467
2468               sprintf (append_str, "mlfh! %s", backupstr);
2469               if (append_insn (append_str, TRUE) == (int) FAIL)
2470                 return;
2471               /* Set bwarn as -1, so macro instruction itself will not be generated frag.  */
2472               inst.bwarn = -1;
2473             }
2474         }
2475       /* Case 2 : mhfl!.  */
2476       else
2477         {
2478           if (reg_rs > 16)
2479             {
2480               SET_INSN_ERROR (BAD_ARGS);
2481               return;
2482             }
2483           else
2484             {
2485               char append_str[MAX_LITERAL_POOL_SIZE];
2486
2487               sprintf (append_str, "mhfl! %s", backupstr);
2488               if (append_insn (append_str, TRUE) == (int) FAIL)
2489                 return;
2490
2491               /* Set bwarn as -1, so macro instruction itself will not be generated frag.  */
2492               inst.bwarn = -1;
2493             }
2494         }
2495     }
2496 }
2497
2498 static void
2499 do16_rdi4 (char *str)
2500 {
2501   skip_whitespace (str);
2502
2503   if (reglow_required_here (&str, 8) == (int) FAIL
2504       || skip_past_comma (&str) == (int) FAIL
2505       || data_op2 (&str, 3, _IMM4) == (int) FAIL
2506       || end_of_line (str) == (int) FAIL)
2507     {
2508       return;
2509     }
2510   else
2511     {
2512       if (((inst.instruction >> 3) & 0x10) == 0)        /* for judge is addei or subei : bit 5 =0 : addei */
2513         {
2514           if (((inst.instruction >> 3) & 0xf) != 0xf)
2515             {
2516               inst.relax_inst |= (((inst.instruction >> 8) & 0xf) << 20)
2517                 | ((1 << ((inst.instruction >> 3) & 0xf)) << 1);
2518               inst.relax_size = 4;
2519             }
2520           else
2521             {
2522               inst.relax_inst = 0x8000;
2523             }
2524         }
2525       else
2526         {
2527           if (((inst.instruction >> 3) & 0xf) != 0xf)
2528             {
2529               inst.relax_inst |= (((inst.instruction >> 8) & 0xf) << 20)
2530                 | (((-(1 << ((inst.instruction >> 3) & 0xf))) & 0xffff) << 1);
2531               inst.relax_size = 4;
2532             }
2533           else
2534             {
2535               inst.relax_inst = 0x8000;
2536             }
2537         }
2538     }
2539 }
2540
2541 static void
2542 do16_rdi5 (char *str)
2543 {
2544   skip_whitespace (str);
2545
2546   if (reglow_required_here (&str, 8) == (int) FAIL
2547       || skip_past_comma (&str) == (int) FAIL
2548       || data_op2 (&str, 3, _IMM5) == (int) FAIL
2549       || end_of_line (str) == (int) FAIL)
2550     return;
2551   else
2552     {
2553       inst.relax_inst |= (((inst.instruction >> 8) & 0xf) << 20)
2554         | (((inst.instruction >> 8) & 0xf) << 15) | (((inst.instruction >> 3) & 0x1f) << 10);
2555       inst.relax_size = 4;
2556     }
2557 }
2558
2559 /* Handle sdbbp.  */
2560 static void
2561 do16_xi5 (char *str)
2562 {
2563   skip_whitespace (str);
2564
2565   if (data_op2 (&str, 3, _IMM5) == (int) FAIL || end_of_line (str) == (int) FAIL)
2566     return;
2567   else
2568     {
2569       inst.relax_inst |= (((inst.instruction >> 3) & 0x1f) << 15);
2570       inst.relax_size = 4;
2571     }
2572 }
2573
2574 /* Check that an immediate is word alignment or half word alignment.
2575    If so, convert it to the right format.  */
2576 static int
2577 validate_immediate_align (int val, unsigned int data_type)
2578 {
2579   if (data_type == _IMM5_RSHIFT_1)
2580     {
2581       if (val % 2)
2582         {
2583           inst.error = _("address offset must be half word alignment");
2584           return (int) FAIL;
2585         }
2586     }
2587   else if ((data_type == _IMM5_RSHIFT_2) || (data_type == _IMM10_RSHIFT_2))
2588     {
2589       if (val % 4)
2590         {
2591           inst.error = _("address offset must be word alignment");
2592           return (int) FAIL;
2593         }
2594     }
2595
2596   return SUCCESS;
2597 }
2598
2599 static int
2600 exp_ldst_offset (char **str, int shift, unsigned int data_type)
2601 {
2602   char *dataptr;
2603
2604   dataptr = * str;
2605
2606   if ((*dataptr == '0') && (*(dataptr + 1) == 'x')
2607       && (data_type != _SIMM16_LA)
2608       && (data_type != _VALUE_HI16)
2609       && (data_type != _VALUE_LO16)
2610       && (data_type != _IMM16)
2611       && (data_type != _IMM15)
2612       && (data_type != _IMM14)
2613       && (data_type != _IMM4)
2614       && (data_type != _IMM5)
2615       && (data_type != _IMM8)
2616       && (data_type != _IMM5_RSHIFT_1)
2617       && (data_type != _IMM5_RSHIFT_2)
2618       && (data_type != _SIMM14_NEG)
2619       && (data_type != _IMM10_RSHIFT_2))
2620     {
2621       data_type += 24;
2622     }
2623
2624   if (my_get_expression (&inst.reloc.exp, str) == (int) FAIL)
2625     return (int) FAIL;
2626
2627   if (inst.reloc.exp.X_op == O_constant)
2628     {
2629       /* Need to check the immediate align.  */
2630       int value = validate_immediate_align (inst.reloc.exp.X_add_number, data_type);
2631
2632       if (value == (int) FAIL)
2633         return (int) FAIL;
2634
2635       value = validate_immediate (inst.reloc.exp.X_add_number, data_type, 0);
2636       if (value == (int) FAIL)
2637         {
2638           if (data_type < 30)
2639             sprintf (err_msg,
2640                      _("invalid constant: %d bit expression not in range %d..%d"),
2641                      score_df_range[data_type].bits,
2642                      score_df_range[data_type].range[0], score_df_range[data_type].range[1]);
2643           else
2644             sprintf (err_msg,
2645                      _("invalid constant: %d bit expression not in range %d..%d"),
2646                      score_df_range[data_type - 24].bits,
2647                      score_df_range[data_type - 24].range[0], score_df_range[data_type - 24].range[1]);
2648           inst.error = err_msg;
2649           return (int) FAIL;
2650         }
2651
2652       if (data_type == _IMM5_RSHIFT_1)
2653         {
2654           value >>= 1;
2655         }
2656       else if ((data_type == _IMM5_RSHIFT_2) || (data_type == _IMM10_RSHIFT_2))
2657         {
2658           value >>= 2;
2659         }
2660
2661       if (score_df_range[data_type].range[0] != 0)
2662         {
2663           value &= (1 << score_df_range[data_type].bits) - 1;
2664         }
2665
2666       inst.instruction |= value << shift;
2667     }
2668   else
2669     {
2670       inst.reloc.pc_rel = 0;
2671     }
2672
2673   return SUCCESS;
2674 }
2675
2676 static void
2677 do_ldst_insn (char *str)
2678 {
2679   int pre_inc = 0;
2680   int conflict_reg;
2681   int value;
2682   char * temp;
2683   char *strbak;
2684   char *dataptr;
2685   int reg;
2686   int ldst_idx = 0;
2687
2688   strbak = str;
2689   skip_whitespace (str);
2690
2691   if (((conflict_reg = reg_required_here (&str, 20, REG_TYPE_SCORE)) == (int) FAIL)
2692       || (skip_past_comma (&str) == (int) FAIL))
2693     return;
2694
2695   /* ld/sw rD, [rA, simm15]    ld/sw rD, [rA]+, simm12     ld/sw rD, [rA, simm12]+.  */
2696   if (*str == '[')
2697     {
2698       str++;
2699       skip_whitespace (str);
2700
2701       if ((reg = reg_required_here (&str, 15, REG_TYPE_SCORE)) == (int) FAIL)
2702         return;
2703
2704       /* Conflicts can occur on stores as well as loads.  */
2705       conflict_reg = (conflict_reg == reg);
2706       skip_whitespace (str);
2707       temp = str + 1;    /* The latter will process decimal/hex expression.  */
2708
2709       /* ld/sw rD, [rA]+, simm12    ld/sw rD, [rA]+.  */
2710       if (*str == ']')
2711         {
2712           str++;
2713           if (*str == '+')
2714             {
2715               str++;
2716               /* ld/sw rD, [rA]+, simm12.  */
2717               if (skip_past_comma (&str) == SUCCESS)
2718                 {
2719                   if ((exp_ldst_offset (&str, 3, _SIMM12) == (int) FAIL)
2720                       || (end_of_line (str) == (int) FAIL))
2721                     return;
2722
2723                   if (conflict_reg)
2724                     {
2725                       unsigned int ldst_func = inst.instruction & OPC_PSEUDOLDST_MASK;
2726
2727                       if ((ldst_func == INSN_LH)
2728                           || (ldst_func == INSN_LHU)
2729                           || (ldst_func == INSN_LW)
2730                           || (ldst_func == INSN_LB)
2731                           || (ldst_func == INSN_LBU))
2732                         {
2733                           inst.error = _("register same as write-back base");
2734                           return;
2735                         }
2736                     }
2737
2738                   ldst_idx = inst.instruction & OPC_PSEUDOLDST_MASK;
2739                   inst.instruction &= ~OPC_PSEUDOLDST_MASK;
2740                   inst.instruction |= score_ldst_insns[ldst_idx * 3 + LDST_POST].value;
2741
2742                   /* lw rD, [rA]+, 4 convert to pop rD, [rA].  */
2743                   if ((inst.instruction & 0x3e000007) == 0x0e000000)
2744                     {
2745                       /* rs =  r0-r7, offset = 4 */
2746                       if ((((inst.instruction >> 15) & 0x18) == 0)
2747                           && (((inst.instruction >> 3) & 0xfff) == 4))
2748                         {
2749                           /* Relax to pophi.  */
2750                           if ((((inst.instruction >> 20) & 0x10) == 0x10))
2751                             {
2752                               inst.relax_inst = 0x0000200a | (((inst.instruction >> 20) & 0xf)
2753                                                               << 8) | 1 << 7 |
2754                                 (((inst.instruction >> 15) & 0x7) << 4);
2755                             }
2756                           /* Relax to pop.  */
2757                           else
2758                             {
2759                               inst.relax_inst = 0x0000200a | (((inst.instruction >> 20) & 0xf)
2760                                                               << 8) | 0 << 7 |
2761                                 (((inst.instruction >> 15) & 0x7) << 4);
2762                             }
2763                           inst.relax_size = 2;
2764                         }
2765                     }
2766                   return;
2767                 }
2768               /* ld/sw rD, [rA]+ convert to ld/sw rD, [rA, 0]+.  */
2769               else
2770                 {
2771                   SET_INSN_ERROR (NULL);
2772                   if (end_of_line (str) == (int) FAIL)
2773                     {
2774                       return;
2775                     }
2776
2777                   pre_inc = 1;
2778                   value = validate_immediate (inst.reloc.exp.X_add_number, _SIMM12, 0);
2779                   value &= (1 << score_df_range[_SIMM12].bits) - 1;
2780                   ldst_idx = inst.instruction & OPC_PSEUDOLDST_MASK;
2781                   inst.instruction &= ~OPC_PSEUDOLDST_MASK;
2782                   inst.instruction |= score_ldst_insns[ldst_idx * 3 + pre_inc].value;
2783                   inst.instruction |= value << 3;
2784                   inst.relax_inst = 0x8000;
2785                   return;
2786                 }
2787             }
2788           /* ld/sw rD, [rA] convert to ld/sw rD, [rA, simm15].  */
2789           else
2790             {
2791               if (end_of_line (str) == (int) FAIL)
2792                 return;
2793
2794               ldst_idx = inst.instruction & OPC_PSEUDOLDST_MASK;
2795               inst.instruction &= ~OPC_PSEUDOLDST_MASK;
2796               inst.instruction |= score_ldst_insns[ldst_idx * 3 + LDST_NOUPDATE].value;
2797
2798               /* lbu rd, [rs] -> lbu! rd, [rs]  */
2799               if (ldst_idx == INSN_LBU)
2800                 {
2801                   inst.relax_inst = INSN16_LBU;
2802                 }
2803               else if (ldst_idx == INSN_LH)
2804                 {
2805                   inst.relax_inst = INSN16_LH;
2806                 }
2807               else if (ldst_idx == INSN_LW)
2808                 {
2809                   inst.relax_inst = INSN16_LW;
2810                 }
2811               else if (ldst_idx == INSN_SB)
2812                 {
2813                   inst.relax_inst = INSN16_SB;
2814                 }
2815               else if (ldst_idx == INSN_SH)
2816                 {
2817                   inst.relax_inst = INSN16_SH;
2818                 }
2819               else if (ldst_idx == INSN_SW)
2820                 {
2821                   inst.relax_inst = INSN16_SW;
2822                 }
2823               else
2824                 {
2825                   inst.relax_inst = 0x8000;
2826                 }
2827
2828               /* lw/lh/lbu/sw/sh/sb, offset = 0, relax to 16 bit instruction.  */
2829               if ((ldst_idx == INSN_LBU)
2830                   || (ldst_idx == INSN_LH)
2831                   || (ldst_idx == INSN_LW)
2832                   || (ldst_idx == INSN_SB) || (ldst_idx == INSN_SH) || (ldst_idx == INSN_SW))
2833                 {
2834                   if ((((inst.instruction >> 15) & 0x10) == 0) && (((inst.instruction >> 20) & 0x10) == 0))
2835                     {
2836                       inst.relax_inst |= (2 << 12) | (((inst.instruction >> 20) & 0xf) << 8) |
2837                         (((inst.instruction >> 15) & 0xf) << 4);
2838                       inst.relax_size = 2;
2839                     }
2840                 }
2841
2842               return;
2843             }
2844         }
2845       /* ld/sw rD, [rA, simm15]    ld/sw rD, [rA, simm12]+.  */
2846       else
2847         {
2848           if (skip_past_comma (&str) == (int) FAIL)
2849             {
2850               inst.error = _("pre-indexed expression expected");
2851               return;
2852             }
2853
2854           if (my_get_expression (&inst.reloc.exp, &str) == (int) FAIL)
2855             return;
2856
2857           skip_whitespace (str);
2858           if (*str++ != ']')
2859             {
2860               inst.error = _("missing ]");
2861               return;
2862             }
2863
2864           skip_whitespace (str);
2865           /* ld/sw rD, [rA, simm12]+.  */
2866           if (*str == '+')
2867             {
2868               str++;
2869               pre_inc = 1;
2870               if (conflict_reg)
2871                 {
2872                   unsigned int ldst_func = inst.instruction & OPC_PSEUDOLDST_MASK;
2873
2874                   if ((ldst_func == INSN_LH)
2875                       || (ldst_func == INSN_LHU)
2876                       || (ldst_func == INSN_LW)
2877                       || (ldst_func == INSN_LB)
2878                       || (ldst_func == INSN_LBU))
2879                     {
2880                       inst.error = _("register same as write-back base");
2881                       return;
2882                     }
2883                 }
2884             }
2885
2886           if (end_of_line (str) == (int) FAIL)
2887             return;
2888
2889           if (inst.reloc.exp.X_op == O_constant)
2890             {
2891               int value;
2892               unsigned int data_type;
2893
2894               if (pre_inc == 1)
2895                 data_type = _SIMM12;
2896               else
2897                 data_type = _SIMM15;
2898               dataptr = temp;
2899
2900               if ((*dataptr == '0') && (*(dataptr + 1) == 'x')
2901                   && (data_type != _SIMM16_LA)
2902                   && (data_type != _VALUE_HI16)
2903                   && (data_type != _VALUE_LO16)
2904                   && (data_type != _IMM16)
2905                   && (data_type != _IMM15)
2906                   && (data_type != _IMM14)
2907                   && (data_type != _IMM4)
2908                   && (data_type != _IMM5)
2909                   && (data_type != _IMM8)
2910                   && (data_type != _IMM5_RSHIFT_1)
2911                   && (data_type != _IMM5_RSHIFT_2)
2912                   && (data_type != _SIMM14_NEG)
2913                   && (data_type != _IMM10_RSHIFT_2))
2914                 {
2915                   data_type += 24;
2916                 }
2917
2918               value = validate_immediate (inst.reloc.exp.X_add_number, data_type, 0);
2919               if (value == (int) FAIL)
2920                 {
2921                   if (data_type < 30)
2922                     sprintf (err_msg,
2923                              _("invalid constant: %d bit expression not in range %d..%d"),
2924                              score_df_range[data_type].bits,
2925                              score_df_range[data_type].range[0], score_df_range[data_type].range[1]);
2926                   else
2927                     sprintf (err_msg,
2928                              _("invalid constant: %d bit expression not in range %d..%d"),
2929                              score_df_range[data_type - 24].bits,
2930                              score_df_range[data_type - 24].range[0],
2931                              score_df_range[data_type - 24].range[1]);
2932                   inst.error = err_msg;
2933                   return;
2934                 }
2935
2936               value &= (1 << score_df_range[data_type].bits) - 1;
2937               ldst_idx = inst.instruction & OPC_PSEUDOLDST_MASK;
2938               inst.instruction &= ~OPC_PSEUDOLDST_MASK;
2939               inst.instruction |= score_ldst_insns[ldst_idx * 3 + pre_inc].value;
2940               if (pre_inc == 1)
2941                 inst.instruction |= value << 3;
2942               else
2943                 inst.instruction |= value;
2944
2945               /* lw rD, [rA, simm15]  */
2946               if ((inst.instruction & 0x3e000000) == 0x20000000)
2947                 {
2948                   /* Both rD and rA are in [r0 - r15].  */
2949                   if ((((inst.instruction >> 15) & 0x10) == 0)
2950                       && (((inst.instruction >> 20) & 0x10) == 0))
2951                     {
2952                       /* simm15 = 0, lw -> lw!.  */
2953                       if ((inst.instruction & 0x7fff) == 0)
2954                         {
2955                           inst.relax_inst |= (((inst.instruction >> 15) & 0xf) << 4)
2956                             | (((inst.instruction >> 20) & 0xf) << 8);
2957                           inst.relax_size = 2;
2958                         }
2959                       /* rA = r2, lw -> lwp!.  */
2960                       else if ((((inst.instruction >> 15) & 0xf) == 2)
2961                                && ((inst.instruction & 0x3) == 0)
2962                                && ((inst.instruction & 0x7fff) < 128))
2963                         {
2964                           inst.relax_inst = 0x7000 | (((inst.instruction >> 20) & 0xf) << 8)
2965                             | (((inst.instruction & 0x7fff) >> 2) << 3);
2966                           inst.relax_size = 2;
2967                         }
2968                       else
2969                         {
2970                           inst.relax_inst = 0x8000;
2971                         }
2972                     }
2973                   else
2974                     {
2975                       inst.relax_inst = 0x8000;
2976                     }
2977                 }
2978               /* sw rD, [rA, simm15]  */
2979               else if ((inst.instruction & 0x3e000000) == 0x28000000)
2980                 {
2981                   /* Both rD and rA are in [r0 - r15].  */
2982                   if ((((inst.instruction >> 15) & 0x10) == 0) && (((inst.instruction >> 20) & 0x10) == 0))
2983                     {
2984                       /* simm15 = 0, sw -> sw!.  */
2985                       if ((inst.instruction & 0x7fff) == 0)
2986                         {
2987                           inst.relax_inst |= (((inst.instruction >> 15) & 0xf) << 4)
2988                             | (((inst.instruction >> 20) & 0xf) << 8);
2989                           inst.relax_size = 2;
2990                         }
2991                       /* rA = r2, sw -> swp!.  */
2992                       else if ((((inst.instruction >> 15) & 0xf) == 2)
2993                                && ((inst.instruction & 0x3) == 0)
2994                                && ((inst.instruction & 0x7fff) < 128))
2995                         {
2996                           inst.relax_inst = 0x7004 | (((inst.instruction >> 20) & 0xf) << 8)
2997                             | (((inst.instruction & 0x7fff) >> 2) << 3);
2998                           inst.relax_size = 2;
2999                         }
3000                       else
3001                         {
3002                           inst.relax_inst = 0x8000;
3003                         }
3004                     }
3005                   else
3006                     {
3007                       inst.relax_inst = 0x8000;
3008                     }
3009                 }
3010               /* sw rD, [rA, simm15]+    sw pre.  */
3011               else if ((inst.instruction & 0x3e000007) == 0x06000004)
3012                 {
3013                   /* rA is in [r0 - r7], and simm15 = -4.  */
3014                   if ((((inst.instruction >> 15) & 0x18) == 0)
3015                       && (((inst.instruction >> 3) & 0xfff) == 0xffc))
3016                     {
3017                       /* sw -> pushhi!.  */
3018                       if ((((inst.instruction >> 20) & 0x10) == 0x10))
3019                         {
3020                           inst.relax_inst = 0x0000200e | (((inst.instruction >> 20) & 0xf) << 8)
3021                             | 1 << 7 | (((inst.instruction >> 15) & 0x7) << 4);
3022                           inst.relax_size = 2;
3023                         }
3024                       /* sw -> push!.  */
3025                       else
3026                         {
3027                           inst.relax_inst = 0x0000200e | (((inst.instruction >> 20) & 0xf) << 8)
3028                             | 0 << 7 | (((inst.instruction >> 15) & 0x7) << 4);
3029                           inst.relax_size = 2;
3030                         }
3031                     }
3032                   else
3033                     {
3034                       inst.relax_inst = 0x8000;
3035                     }
3036                 }
3037               /* lh rD, [rA, simm15]  */
3038               else if ((inst.instruction & 0x3e000000) == 0x22000000)
3039                 {
3040                   /* Both rD and rA are in [r0 - r15].  */
3041                   if ((((inst.instruction >> 15) & 0x10) == 0) && (((inst.instruction >> 20) & 0x10) == 0))
3042                     {
3043                       /* simm15 = 0, lh -> lh!.  */
3044                       if ((inst.instruction & 0x7fff) == 0)
3045                         {
3046                           inst.relax_inst |= (((inst.instruction >> 15) & 0xf) << 4)
3047                             | (((inst.instruction >> 20) & 0xf) << 8);
3048                           inst.relax_size = 2;
3049                         }
3050                       /* rA = r2, lh -> lhp!.  */
3051                       else if ((((inst.instruction >> 15) & 0xf) == 2)
3052                                && ((inst.instruction & 0x1) == 0)
3053                                && ((inst.instruction & 0x7fff) < 64))
3054                         {
3055                           inst.relax_inst = 0x7001 | (((inst.instruction >> 20) & 0xf) << 8)
3056                             | (((inst.instruction & 0x7fff) >> 1) << 3);
3057                           inst.relax_size = 2;
3058                         }
3059                       else
3060                         {
3061                           inst.relax_inst = 0x8000;
3062                         }
3063                     }
3064                   else
3065                     {
3066                       inst.relax_inst = 0x8000;
3067                     }
3068                 }
3069               /* sh rD, [rA, simm15]  */
3070               else if ((inst.instruction & 0x3e000000) == 0x2a000000)
3071                 {
3072                   /* Both rD and rA are in [r0 - r15].  */
3073                   if ((((inst.instruction >> 15) & 0x10) == 0) && (((inst.instruction >> 20) & 0x10) == 0))
3074                     {
3075                       /* simm15 = 0, sh -> sh!.  */
3076                       if ((inst.instruction & 0x7fff) == 0)
3077                         {
3078                           inst.relax_inst |= (((inst.instruction >> 15) & 0xf) << 4)
3079                             | (((inst.instruction >> 20) & 0xf) << 8);
3080                           inst.relax_size = 2;
3081                         }
3082                       /* rA = r2, sh -> shp!.  */
3083                       else if ((((inst.instruction >> 15) & 0xf) == 2)
3084                                && ((inst.instruction & 0x1) == 0)
3085                                && ((inst.instruction & 0x7fff) < 64))
3086                         {
3087                           inst.relax_inst = 0x7005 | (((inst.instruction >> 20) & 0xf) << 8)
3088                             | (((inst.instruction & 0x7fff) >> 1) << 3);
3089                           inst.relax_size = 2;
3090                         }
3091                       else
3092                         {
3093                           inst.relax_inst = 0x8000;
3094                         }
3095                     }
3096                   else
3097                     {
3098                       inst.relax_inst = 0x8000;
3099                     }
3100                 }
3101               /* lbu rD, [rA, simm15]  */
3102               else if ((inst.instruction & 0x3e000000) == 0x2c000000)
3103                 {
3104                   /* Both rD and rA are in [r0 - r15].  */
3105                   if ((((inst.instruction >> 15) & 0x10) == 0) && (((inst.instruction >> 20) & 0x10) == 0))
3106                     {
3107                       /* simm15 = 0, lbu -> lbu!.  */
3108                       if ((inst.instruction & 0x7fff) == 0)
3109                         {
3110                           inst.relax_inst |= (((inst.instruction >> 15) & 0xf) << 4)
3111                             | (((inst.instruction >> 20) & 0xf) << 8);
3112                           inst.relax_size = 2;
3113                         }
3114                       /* rA = r2, lbu -> lbup!.  */
3115                       else if ((((inst.instruction >> 15) & 0xf) == 2)
3116                                && ((inst.instruction & 0x7fff) < 32))
3117                         {
3118                           inst.relax_inst = 0x7003 | (((inst.instruction >> 20) & 0xf) << 8)
3119                             | ((inst.instruction & 0x7fff) << 3);
3120                           inst.relax_size = 2;
3121                         }
3122                       else
3123                         {
3124                           inst.relax_inst = 0x8000;
3125                         }
3126                     }
3127                   else
3128                     {
3129                       inst.relax_inst = 0x8000;
3130                     }
3131                 }
3132               /* sb rD, [rA, simm15]  */
3133               else if ((inst.instruction & 0x3e000000) == 0x2e000000)
3134                 {
3135                   /* Both rD and rA are in [r0 - r15].  */
3136                   if ((((inst.instruction >> 15) & 0x10) == 0) && (((inst.instruction >> 20) & 0x10) == 0))
3137                     {
3138                       /* simm15 = 0, sb -> sb!.  */
3139                       if ((inst.instruction & 0x7fff) == 0)
3140                         {
3141                           inst.relax_inst |= (((inst.instruction >> 15) & 0xf) << 4)
3142                             | (((inst.instruction >> 20) & 0xf) << 8);
3143                           inst.relax_size = 2;
3144                         }
3145                       /* rA = r2, sb -> sb!.  */
3146                       else if ((((inst.instruction >> 15) & 0xf) == 2)
3147                                && ((inst.instruction & 0x7fff) < 32))
3148                         {
3149                           inst.relax_inst = 0x7007 | (((inst.instruction >> 20) & 0xf) << 8)
3150                             | ((inst.instruction & 0x7fff) << 3);
3151                           inst.relax_size = 2;
3152                         }
3153                       else
3154                         {
3155                           inst.relax_inst = 0x8000;
3156                         }
3157                     }
3158                   else
3159                     {
3160                       inst.relax_inst = 0x8000;
3161                     }
3162                 }
3163               else
3164                 {
3165                   inst.relax_inst = 0x8000;
3166                 }
3167
3168               return;
3169             }
3170           else
3171             {
3172               /* FIXME: may set error, for there is no ld/sw rD, [rA, label] */
3173               inst.reloc.pc_rel = 0;
3174             }
3175         }
3176     }
3177   else
3178     {
3179       inst.error = BAD_ARGS;
3180     }
3181 }
3182
3183 /* Handle cache.  */
3184
3185 static void
3186 do_cache (char *str)
3187 {
3188   skip_whitespace (str);
3189
3190   if ((data_op2 (&str, 20, _IMM5) == (int) FAIL) || (skip_past_comma (&str) == (int) FAIL))
3191     {
3192       return;
3193     }
3194   else
3195     {
3196       int cache_op;
3197
3198       cache_op = (inst.instruction >> 20) & 0x1F;
3199       sprintf (inst.name, "cache %d", cache_op);
3200     }
3201
3202   if (*str == '[')
3203     {
3204       str++;
3205       skip_whitespace (str);
3206
3207       if (reg_required_here (&str, 15, REG_TYPE_SCORE) == (int) FAIL)
3208         return;
3209
3210       skip_whitespace (str);
3211
3212       /* cache op, [rA]  */
3213       if (skip_past_comma (&str) == (int) FAIL)
3214         {
3215           SET_INSN_ERROR (NULL);
3216           if (*str != ']')
3217             {
3218               inst.error = _("missing ]");
3219               return;
3220             }
3221           str++;
3222         }
3223       /* cache op, [rA, simm15]  */
3224       else
3225         {
3226           if (exp_ldst_offset (&str, 0, _SIMM15) == (int) FAIL)
3227             {
3228               return;
3229             }
3230
3231           skip_whitespace (str);
3232           if (*str++ != ']')
3233             {
3234               inst.error = _("missing ]");
3235               return;
3236             }
3237         }
3238
3239       if (end_of_line (str) == (int) FAIL)
3240         return;
3241     }
3242   else
3243     {
3244       inst.error = BAD_ARGS;
3245     }
3246 }
3247
3248 static void
3249 do_crdcrscrsimm5 (char *str)
3250 {
3251   char *strbak;
3252
3253   strbak = str;
3254   skip_whitespace (str);
3255
3256   if (reg_required_here (&str, 20, REG_TYPE_SCORE_CR) == (int) FAIL
3257       || skip_past_comma (&str) == (int) FAIL
3258       || reg_required_here (&str, 15, REG_TYPE_SCORE_CR) == (int) FAIL
3259       || skip_past_comma (&str) == (int) FAIL
3260       || reg_required_here (&str, 10, REG_TYPE_SCORE_CR) == (int) FAIL
3261       || skip_past_comma (&str) == (int) FAIL)
3262     {
3263       str = strbak;
3264       /* cop1 cop_code20.  */
3265       if (data_op2 (&str, 5, _IMM20) == (int) FAIL)
3266         return;
3267     }
3268   else
3269     {
3270       if (data_op2 (&str, 5, _IMM5) == (int) FAIL)
3271         return;
3272     }
3273
3274   end_of_line (str);
3275 }
3276
3277 /* Handle ldc/stc.  */
3278 static void
3279 do_ldst_cop (char *str)
3280 {
3281   skip_whitespace (str);
3282
3283   if ((reg_required_here (&str, 15, REG_TYPE_SCORE_CR) == (int) FAIL)
3284       || (skip_past_comma (&str) == (int) FAIL))
3285     return;
3286
3287   if (*str == '[')
3288     {
3289       str++;
3290       skip_whitespace (str);
3291
3292       if (reg_required_here (&str, 20, REG_TYPE_SCORE) == (int) FAIL)
3293         return;
3294
3295       skip_whitespace (str);
3296
3297       if (*str++ != ']')
3298         {
3299           if (exp_ldst_offset (&str, 5, _IMM10_RSHIFT_2) == (int) FAIL)
3300             return;
3301
3302           skip_whitespace (str);
3303           if (*str++ != ']')
3304             {
3305               inst.error = _("missing ]");
3306               return;
3307             }
3308         }
3309
3310       end_of_line (str);
3311     }
3312   else
3313     inst.error = BAD_ARGS;
3314 }
3315
3316 static void
3317 do16_ldst_insn (char *str)
3318 {
3319   skip_whitespace (str);
3320
3321   if ((reglow_required_here (&str, 8) == (int) FAIL) || (skip_past_comma (&str) == (int) FAIL))
3322     return;
3323
3324   if (*str == '[')
3325     {
3326       int reg;
3327
3328       str++;
3329       skip_whitespace (str);
3330
3331       if ((reg = reglow_required_here (&str, 4)) == (int) FAIL)
3332         return;
3333
3334       skip_whitespace (str);
3335       if (*str++ == ']')
3336         {
3337           if (end_of_line (str) == (int) FAIL)
3338             return;
3339           else
3340             {
3341               inst.relax_inst |= (((inst.instruction >> 8) & 0xf) << 20)
3342                               | (((inst.instruction >> 4) & 0xf) << 15);
3343               inst.relax_size = 4;
3344             }
3345         }
3346       else
3347         {
3348           inst.error = _("missing ]");
3349         }
3350     }
3351   else
3352     {
3353       inst.error = BAD_ARGS;
3354     }
3355 }
3356
3357 /* Handle lbup!/lhp!/ldiu!/lwp!/sbp!/shp!/swp!.  */
3358 static void
3359 do16_ldst_imm_insn (char *str)
3360 {
3361   char data_exp[MAX_LITERAL_POOL_SIZE];
3362   int reg_rd;
3363   char *dataptr = NULL, *pp = NULL;
3364   int cnt = 0;
3365   int assign_data = (int) FAIL;
3366   unsigned int ldst_func;
3367
3368   skip_whitespace (str);
3369
3370   if (((reg_rd = reglow_required_here (&str, 8)) == (int) FAIL)
3371       || (skip_past_comma (&str) == (int) FAIL))
3372     return;
3373
3374   skip_whitespace (str);
3375   dataptr = str;
3376
3377   while ((*dataptr != '\0') && (*dataptr != '|') && (cnt <= MAX_LITERAL_POOL_SIZE))
3378     {
3379       data_exp[cnt] = *dataptr;
3380       dataptr++;
3381       cnt++;
3382     }
3383
3384   data_exp[cnt] = '\0';
3385   pp = &data_exp[0];
3386
3387   str = dataptr;
3388
3389   ldst_func = inst.instruction & LDST16_RI_MASK;
3390   if (ldst_func == N16_LIU)
3391     assign_data = exp_ldst_offset (&pp, 0, _IMM8);
3392   else if (ldst_func == N16_LHP || ldst_func == N16_SHP)
3393     assign_data = exp_ldst_offset (&pp, 3, _IMM5_RSHIFT_1);
3394   else if (ldst_func == N16_LWP || ldst_func == N16_SWP)
3395     assign_data = exp_ldst_offset (&pp, 3, _IMM5_RSHIFT_2);
3396   else
3397     assign_data = exp_ldst_offset (&pp, 3, _IMM5);
3398
3399   if ((assign_data == (int) FAIL) || (end_of_line (pp) == (int) FAIL))
3400     return;
3401   else
3402     {
3403       if ((inst.instruction & 0x7000) == N16_LIU)
3404         {
3405           inst.relax_inst |= ((inst.instruction >> 8) & 0xf) << 20
3406                           | ((inst.instruction & 0xff) << 1);
3407         }
3408       else if (((inst.instruction & 0x7007) == N16_LHP)
3409                || ((inst.instruction & 0x7007) == N16_SHP))
3410         {
3411           inst.relax_inst |= ((inst.instruction >> 8) & 0xf) << 20 | 2 << 15
3412                           | (((inst.instruction >> 3) & 0x1f) << 1);
3413         }
3414       else if (((inst.instruction & 0x7007) == N16_LWP)
3415                || ((inst.instruction & 0x7007) == N16_SWP))
3416         {
3417           inst.relax_inst |= ((inst.instruction >> 8) & 0xf) << 20 | 2 << 15
3418                           | (((inst.instruction >> 3) & 0x1f) << 2);
3419         }
3420       else if (((inst.instruction & 0x7007) == N16_LBUP)
3421                || ((inst.instruction & 0x7007) == N16_SBP))
3422         {
3423           inst.relax_inst |= ((inst.instruction >> 8) & 0xf) << 20 | 2 << 15
3424                           | (((inst.instruction >> 3) & 0x1f));
3425         }
3426
3427       inst.relax_size = 4;
3428     }
3429 }
3430
3431 static void
3432 do16_push_pop (char *str)
3433 {
3434   int reg_rd;
3435   int H_bit_mask = 0;
3436
3437   skip_whitespace (str);
3438   if (((reg_rd = reg_required_here (&str, 8, REG_TYPE_SCORE)) == (int) FAIL)
3439       || (skip_past_comma (&str) == (int) FAIL))
3440     return;
3441
3442   if (reg_rd >= 16)
3443     H_bit_mask = 1;
3444
3445   /* reg_required_here will change bit 12 of opcode, so we must restore bit 12.  */
3446   inst.instruction &= ~(1 << 12);
3447
3448   inst.instruction |= H_bit_mask << 7;
3449
3450   if (*str == '[')
3451     {
3452       int reg;
3453
3454       str++;
3455       skip_whitespace (str);
3456       if ((reg = reg_required_here (&str, 4, REG_TYPE_SCORE)) == (int) FAIL)
3457         return;
3458       else if (reg > 7)
3459         {
3460           if (!inst.error)
3461             inst.error = _("base register nums are over 3 bit");
3462
3463           return;
3464         }
3465
3466       skip_whitespace (str);
3467       if ((*str++ != ']') || (end_of_line (str) == (int) FAIL))
3468         {
3469           if (!inst.error)
3470             inst.error = _("missing ]");
3471
3472           return;
3473         }
3474
3475       /* pop! */
3476       if ((inst.instruction & 0xf) == 0xa)
3477         {
3478           if (H_bit_mask)
3479             {
3480               inst.relax_inst |= ((((inst.instruction >> 8) & 0xf) | 0x10) << 20)
3481                                   | (((inst.instruction >> 4) & 0x7) << 15) | (4 << 3);
3482             }
3483           else
3484             {
3485               inst.relax_inst |= (((inst.instruction >> 8) & 0xf) << 20)
3486                                   | (((inst.instruction >> 4) & 0x7) << 15) | (4 << 3);
3487             }
3488         }
3489       /* push! */
3490       else
3491         {
3492           if (H_bit_mask)
3493             {
3494               inst.relax_inst |= ((((inst.instruction >> 8) & 0xf) | 0x10) << 20)
3495                                   | (((inst.instruction >> 4) & 0x7) << 15) | (((-4) & 0xfff) << 3);
3496             }
3497           else
3498             {
3499               inst.relax_inst |= (((inst.instruction >> 8) & 0xf) << 20)
3500                                   | (((inst.instruction >> 4) & 0x7) << 15) | (((-4) & 0xfff) << 3);
3501             }
3502         }
3503       inst.relax_size = 4;
3504     }
3505   else
3506     {
3507       inst.error = BAD_ARGS;
3508     }
3509 }
3510
3511 /* Handle lcb/lcw/lce/scb/scw/sce.  */
3512 static void
3513 do_ldst_unalign (char *str)
3514 {
3515   int conflict_reg;
3516
3517   if (university_version == 1)
3518     {
3519       inst.error = ERR_FOR_SCORE5U_ATOMIC;
3520       return;
3521     }
3522
3523   skip_whitespace (str);
3524
3525   /* lcb/scb [rA]+.  */
3526   if (*str == '[')
3527     {
3528       str++;
3529       skip_whitespace (str);
3530
3531       if (reg_required_here (&str, 15, REG_TYPE_SCORE) == (int) FAIL)
3532         return;
3533
3534       if (*str++ == ']')
3535         {
3536           if (*str++ != '+')
3537             {
3538               inst.error = _("missing +");
3539               return;
3540             }
3541         }
3542       else
3543         {
3544           inst.error = _("missing ]");
3545           return;
3546         }
3547
3548       if (end_of_line (str) == (int) FAIL)
3549         return;
3550     }
3551   /* lcw/lce/scb/sce rD, [rA]+.  */
3552   else
3553     {
3554       if (((conflict_reg = reg_required_here (&str, 20, REG_TYPE_SCORE)) == (int) FAIL)
3555           || (skip_past_comma (&str) == (int) FAIL))
3556         {
3557           return;
3558         }
3559
3560       skip_whitespace (str);
3561       if (*str++ == '[')
3562         {
3563           int reg;
3564
3565           skip_whitespace (str);
3566           if ((reg = reg_required_here (&str, 15, REG_TYPE_SCORE)) == (int) FAIL)
3567             {
3568               return;
3569             }
3570
3571           /* Conflicts can occur on stores as well as loads.  */
3572           conflict_reg = (conflict_reg == reg);
3573           skip_whitespace (str);
3574           if (*str++ == ']')
3575             {
3576               unsigned int ldst_func = inst.instruction & LDST_UNALIGN_MASK;
3577
3578               if (*str++ == '+')
3579                 {
3580                   if (conflict_reg)
3581                     {
3582                       as_warn (_("%s register same as write-back base"),
3583                                ((ldst_func & UA_LCE) || (ldst_func & UA_LCW)
3584                                 ? _("destination") : _("source")));
3585                     }
3586                 }
3587               else
3588                 {
3589                   inst.error = _("missing +");
3590                   return;
3591                 }
3592
3593               if (end_of_line (str) == (int) FAIL)
3594                 return;
3595             }
3596           else
3597             {
3598               inst.error = _("missing ]");
3599               return;
3600             }
3601         }
3602       else
3603         {
3604           inst.error = BAD_ARGS;
3605           return;
3606         }
3607     }
3608 }
3609
3610 /* Handle alw/asw.  */
3611 static void
3612 do_ldst_atomic (char *str)
3613 {
3614   if (university_version == 1)
3615     {
3616       inst.error = ERR_FOR_SCORE5U_ATOMIC;
3617       return;
3618     }
3619
3620   skip_whitespace (str);
3621
3622   if ((reg_required_here (&str, 20, REG_TYPE_SCORE) == (int) FAIL)
3623       || (skip_past_comma (&str) == (int) FAIL))
3624     {
3625       return;
3626     }
3627   else
3628     {
3629
3630       skip_whitespace (str);
3631       if (*str++ == '[')
3632         {
3633           int reg;
3634
3635           skip_whitespace (str);
3636           if ((reg = reg_required_here (&str, 15, REG_TYPE_SCORE)) == (int) FAIL)
3637             {
3638               return;
3639             }
3640
3641           skip_whitespace (str);
3642           if (*str++ != ']')
3643             {
3644               inst.error = _("missing ]");
3645               return;
3646             }
3647
3648           end_of_line (str);
3649         }
3650       else
3651         inst.error = BAD_ARGS;
3652     }
3653 }
3654
3655 static void
3656 build_relax_frag (struct score_it fix_insts[RELAX_INST_NUM], int fix_num ATTRIBUTE_UNUSED,
3657                   struct score_it var_insts[RELAX_INST_NUM], int var_num,
3658                   symbolS *add_symbol)
3659 {
3660   int i;
3661   char *p;
3662   fixS *fixp = NULL;
3663   fixS *cur_fixp = NULL;
3664   long where;
3665   struct score_it inst_main;
3666
3667   memcpy (&inst_main, &fix_insts[0], sizeof (struct score_it));
3668
3669   /* Adjust instruction opcode and to be relaxed instruction opcode.  */
3670   inst_main.instruction = adjust_paritybit (inst_main.instruction, GET_INSN_CLASS (inst_main.type));
3671   inst_main.type = Insn_PIC;
3672
3673   for (i = 0; i < var_num; i++)
3674     {
3675       inst_main.relax_size += var_insts[i].size;
3676       var_insts[i].instruction = adjust_paritybit (var_insts[i].instruction,
3677                                                    GET_INSN_CLASS (var_insts[i].type));
3678     }
3679
3680   /* Check data dependency.  */
3681   handle_dependency (&inst_main);
3682
3683   /* Start a new frag if frag_now is not empty.  */
3684   if (frag_now_fix () != 0)
3685     {
3686       if (!frag_now->tc_frag_data.is_insn)
3687         {
3688           frag_wane (frag_now);
3689         }
3690       frag_new (0);
3691     }
3692   frag_grow (20);
3693
3694   /* Write fr_fix part.  */
3695   p = frag_more (inst_main.size);
3696   md_number_to_chars (p, inst_main.instruction, inst_main.size);
3697
3698   if (inst_main.reloc.type != BFD_RELOC_NONE)
3699     fixp = fix_new_score (frag_now, p - frag_now->fr_literal, inst_main.size,
3700                           &inst_main.reloc.exp, inst_main.reloc.pc_rel, inst_main.reloc.type);
3701
3702   frag_now->tc_frag_data.fixp = fixp;
3703   cur_fixp = frag_now->tc_frag_data.fixp;
3704
3705 #ifdef OBJ_ELF
3706   dwarf2_emit_insn (inst_main.size);
3707 #endif
3708
3709   where = p - frag_now->fr_literal + inst_main.size;
3710   for (i = 0; i < var_num; i++)
3711     {
3712       if (i > 0)
3713         where += var_insts[i - 1].size;
3714
3715       if (var_insts[i].reloc.type != BFD_RELOC_NONE)
3716         {
3717           fixp = fix_new_score (frag_now, where, var_insts[i].size,
3718                                 &var_insts[i].reloc.exp, var_insts[i].reloc.pc_rel,
3719                                 var_insts[i].reloc.type);
3720           if (fixp)
3721             {
3722               if (cur_fixp)
3723                 {
3724                   cur_fixp->fx_next = fixp;
3725                   cur_fixp = cur_fixp->fx_next;
3726                 }
3727               else
3728                 {
3729                   frag_now->tc_frag_data.fixp = fixp;
3730                   cur_fixp = frag_now->tc_frag_data.fixp;
3731                 }
3732             }
3733         }
3734     }
3735
3736   p = frag_var (rs_machine_dependent, inst_main.relax_size + RELAX_PAD_BYTE, 0,
3737                 RELAX_ENCODE (inst_main.size, inst_main.relax_size, inst_main.type,
3738                 0, inst_main.size, 0), add_symbol, 0, NULL);
3739
3740   /* Write fr_var part.
3741      no calling gen_insn_frag, no fixS will be generated.  */
3742   for (i = 0; i < var_num; i++)
3743     {
3744       md_number_to_chars (p, var_insts[i].instruction, var_insts[i].size);
3745       p += var_insts[i].size;
3746     }
3747   /* Set bwarn as -1, so macro instruction itself will not be generated frag.  */
3748   inst.bwarn = -1;
3749 }
3750
3751 /* Build a relax frag for la instruction when generating PIC,
3752    external symbol first and local symbol second.  */
3753
3754 static void
3755 build_la_pic (int reg_rd, expressionS exp)
3756 {
3757   symbolS *add_symbol = exp.X_add_symbol;
3758   offsetT add_number = exp.X_add_number;
3759   struct score_it fix_insts[RELAX_INST_NUM];
3760   struct score_it var_insts[RELAX_INST_NUM];
3761   int fix_num = 0;
3762   int var_num = 0;
3763   char tmp[MAX_LITERAL_POOL_SIZE];
3764   int r1_bak;
3765
3766   r1_bak = nor1;
3767   nor1 = 0;
3768
3769   if (add_number == 0)
3770     {
3771       fix_num = 1;
3772       var_num = 2;
3773
3774       /* For an external symbol, only one insn is generated;
3775          For a local symbol, two insns are generated.  */
3776       /* Fix part
3777          For an external symbol: lw rD, <sym>($gp)
3778                                  (BFD_RELOC_SCORE_GOT15 or BFD_RELOC_SCORE_CALL15)  */
3779       sprintf (tmp, "lw_pic r%d, %s", reg_rd, add_symbol->bsym->name);
3780       if (append_insn (tmp, FALSE) == (int) FAIL)
3781         return;
3782
3783       if (reg_rd == PIC_CALL_REG)
3784         inst.reloc.type = BFD_RELOC_SCORE_CALL15;
3785       memcpy (&fix_insts[0], &inst, sizeof (struct score_it));
3786
3787       /* Var part
3788          For a local symbol :
3789          lw rD, <sym>($gp)    (BFD_RELOC_SCORE_GOT15)
3790          addi rD, <sym>       (BFD_RELOC_GOT_LO16) */
3791       inst.reloc.type = BFD_RELOC_SCORE_GOT15;
3792       memcpy (&var_insts[0], &inst, sizeof (struct score_it));
3793       sprintf (tmp, "addi_s_pic r%d, %s", reg_rd, add_symbol->bsym->name);
3794       if (append_insn (tmp, FALSE) == (int) FAIL)
3795         return;
3796
3797       memcpy (&var_insts[1], &inst, sizeof (struct score_it));
3798       build_relax_frag (fix_insts, fix_num, var_insts, var_num, add_symbol);
3799     }
3800   else if (add_number >= -0x8000 && add_number <= 0x7fff)
3801     {
3802       /* Insn 1: lw rD, <sym>($gp)    (BFD_RELOC_SCORE_GOT15)  */
3803       sprintf (tmp, "lw_pic r%d, %s", reg_rd, add_symbol->bsym->name);
3804       if (append_insn (tmp, TRUE) == (int) FAIL)
3805         return;
3806
3807       /* Insn 2  */
3808       fix_num = 1;
3809       var_num = 1;
3810       /* Fix part
3811          For an external symbol: addi rD, <constant> */
3812       sprintf (tmp, "addi r%d, %d", reg_rd, (int)add_number);
3813       if (append_insn (tmp, FALSE) == (int) FAIL)
3814         return;
3815
3816       memcpy (&fix_insts[0], &inst, sizeof (struct score_it));
3817
3818       /* Var part
3819          For a local symbol: addi rD, <sym>+<constant>    (BFD_RELOC_GOT_LO16)  */
3820       sprintf (tmp, "addi_s_pic r%d, %s + %d", reg_rd, add_symbol->bsym->name, (int)add_number);
3821       if (append_insn (tmp, FALSE) == (int) FAIL)
3822         return;
3823
3824       memcpy (&var_insts[0], &inst, sizeof (struct score_it));
3825       build_relax_frag (fix_insts, fix_num, var_insts, var_num, add_symbol);
3826     }
3827   else
3828     {
3829       int hi = (add_number >> 16) & 0x0000FFFF;
3830       int lo = add_number & 0x0000FFFF;
3831
3832       /* Insn 1: lw rD, <sym>($gp)    (BFD_RELOC_SCORE_GOT15)  */
3833       sprintf (tmp, "lw_pic r%d, %s", reg_rd, add_symbol->bsym->name);
3834       if (append_insn (tmp, TRUE) == (int) FAIL)
3835         return;
3836
3837       /* Insn 2  */
3838       fix_num = 1;
3839       var_num = 1;
3840       /* Fix part
3841          For an external symbol: ldis r1, HI%<constant>  */
3842       sprintf (tmp, "ldis r1, %d", hi);
3843       if (append_insn (tmp, FALSE) == (int) FAIL)
3844         return;
3845
3846       memcpy (&fix_insts[0], &inst, sizeof (struct score_it));
3847
3848       /* Var part
3849          For a local symbol: ldis r1, HI%<constant>
3850          but, if lo is outof 16 bit, make hi plus 1  */
3851       if ((lo < -0x8000) || (lo > 0x7fff))
3852         {
3853           hi += 1;
3854         }
3855       sprintf (tmp, "ldis_pic r1, %d", hi);
3856       if (append_insn (tmp, FALSE) == (int) FAIL)
3857         return;
3858
3859       memcpy (&var_insts[0], &inst, sizeof (struct score_it));
3860       build_relax_frag (fix_insts, fix_num, var_insts, var_num, add_symbol);
3861
3862       /* Insn 3  */
3863       fix_num = 1;
3864       var_num = 1;
3865       /* Fix part
3866          For an external symbol: ori r1, LO%<constant>  */
3867       sprintf (tmp, "ori r1, %d", lo);
3868       if (append_insn (tmp, FALSE) == (int) FAIL)
3869         return;
3870
3871       memcpy (&fix_insts[0], &inst, sizeof (struct score_it));
3872
3873       /* Var part
3874          For a local symbol: addi r1, <sym>+LO%<constant>    (BFD_RELOC_GOT_LO16)  */
3875       sprintf (tmp, "addi_u_pic r1, %s + %d", add_symbol->bsym->name, lo);
3876       if (append_insn (tmp, FALSE) == (int) FAIL)
3877         return;
3878
3879       memcpy (&var_insts[0], &inst, sizeof (struct score_it));
3880       build_relax_frag (fix_insts, fix_num, var_insts, var_num, add_symbol);
3881
3882       /* Insn 4: add rD, rD, r1  */
3883       sprintf (tmp, "add r%d, r%d, r1", reg_rd, reg_rd);
3884       if (append_insn (tmp, TRUE) == (int) FAIL)
3885         return;
3886
3887      /* Set bwarn as -1, so macro instruction itself will not be generated frag.  */
3888      inst.bwarn = -1;
3889     }
3890
3891   nor1 = r1_bak;
3892 }
3893
3894 /* Handle la.  */
3895 static void
3896 do_macro_la_rdi32 (char *str)
3897 {
3898   int reg_rd;
3899
3900   skip_whitespace (str);
3901   if ((reg_rd = reg_required_here (&str, 20, REG_TYPE_SCORE)) == (int) FAIL
3902       || skip_past_comma (&str) == (int) FAIL)
3903     {
3904       return;
3905     }
3906   else
3907     {
3908       char append_str[MAX_LITERAL_POOL_SIZE];
3909       char *keep_data = str;
3910
3911       /* la rd, simm16.  */
3912       if (data_op2 (&str, 1, _SIMM16_LA) != (int) FAIL)
3913         {
3914           end_of_line (str);
3915           return;
3916         }
3917       /* la rd, imm32 or la rd, label.  */
3918       else
3919         {
3920           SET_INSN_ERROR (NULL);
3921           str = keep_data;
3922           if ((data_op2 (&str, 1, _VALUE_HI16) == (int) FAIL)
3923               || (end_of_line (str) == (int) FAIL))
3924             {
3925               return;
3926             }
3927           else
3928             {
3929               if ((score_pic == NO_PIC) || (!inst.reloc.exp.X_add_symbol))
3930                 {
3931                   sprintf (append_str, "ld_i32hi r%d, %s", reg_rd, keep_data);
3932                   if (append_insn (append_str, TRUE) == (int) FAIL)
3933                     return;
3934
3935                   sprintf (append_str, "ld_i32lo r%d, %s", reg_rd, keep_data);
3936                   if (append_insn (append_str, TRUE) == (int) FAIL)
3937                     return;
3938                 }
3939               else
3940                 {
3941                   assert (inst.reloc.exp.X_add_symbol);
3942                   build_la_pic (reg_rd, inst.reloc.exp);
3943                 }
3944
3945               /* Set bwarn as -1, so macro instruction itself will not be generated frag.  */
3946               inst.bwarn = -1;
3947             }
3948         }
3949     }
3950 }
3951
3952 /* Handle li.  */
3953 static void
3954 do_macro_li_rdi32 (char *str){
3955
3956   int reg_rd;
3957
3958   skip_whitespace (str);
3959   if ((reg_rd = reg_required_here (&str, 20, REG_TYPE_SCORE)) == (int) FAIL
3960       || skip_past_comma (&str) == (int) FAIL)
3961     {
3962       return;
3963     }
3964   else
3965     {
3966       char *keep_data = str;
3967
3968       /* li rd, simm16.  */
3969       if (data_op2 (&str, 1, _SIMM16_LA) != (int) FAIL)
3970         {
3971           end_of_line (str);
3972           return;
3973         }
3974       /* li rd, imm32.  */
3975       else
3976         {
3977           char append_str[MAX_LITERAL_POOL_SIZE];
3978
3979           str = keep_data;
3980
3981           if ((data_op2 (&str, 1, _VALUE_HI16) == (int) FAIL)
3982               || (end_of_line (str) == (int) FAIL))
3983             {
3984               return;
3985             }
3986           else if (inst.reloc.exp.X_add_symbol)
3987             {
3988               inst.error = _("li rd label isn't correct instruction form");
3989               return;
3990             }
3991           else
3992             {
3993               sprintf (append_str, "ld_i32hi r%d, %s", reg_rd, keep_data);
3994
3995               if (append_insn (append_str, TRUE) == (int) FAIL)
3996                 return;
3997               else
3998                 {
3999                   sprintf (append_str, "ld_i32lo r%d, %s", reg_rd, keep_data);
4000                   if (append_insn (append_str, TRUE) == (int) FAIL)
4001                     return;
4002
4003                   /* Set bwarn as -1, so macro instruction itself will not be generated frag.  */
4004                   inst.bwarn = -1;
4005                 }
4006             }
4007         }
4008     }
4009 }
4010
4011 /* Handle mul/mulu/div/divu/rem/remu.  */
4012 static void
4013 do_macro_mul_rdrsrs (char *str)
4014 {
4015   int reg_rd;
4016   int reg_rs1;
4017   int reg_rs2;
4018   char *backupstr;
4019   char append_str[MAX_LITERAL_POOL_SIZE];
4020
4021   if (university_version == 1)
4022     as_warn ("%s", ERR_FOR_SCORE5U_MUL_DIV);
4023
4024   strcpy (append_str, str);
4025   backupstr = append_str;
4026   skip_whitespace (backupstr);
4027   if (((reg_rd = reg_required_here (&backupstr, -1, REG_TYPE_SCORE)) == (int) FAIL)
4028       || (skip_past_comma (&backupstr) == (int) FAIL)
4029       || ((reg_rs1 = reg_required_here (&backupstr, -1, REG_TYPE_SCORE)) == (int) FAIL))
4030     {
4031       inst.error = BAD_ARGS;
4032       return;
4033     }
4034
4035   if (skip_past_comma (&backupstr) == (int) FAIL)
4036     {
4037       /* rem/remu rA, rB is error format.  */
4038       if (strcmp (inst.name, "rem") == 0 || strcmp (inst.name, "remu") == 0)
4039         {
4040           SET_INSN_ERROR (BAD_ARGS);
4041         }
4042       else
4043         {
4044           SET_INSN_ERROR (NULL);
4045           do_rsrs (str);
4046         }
4047       return;
4048     }
4049   else
4050     {
4051       SET_INSN_ERROR (NULL);
4052       if (((reg_rs2 = reg_required_here (&backupstr, -1, REG_TYPE_SCORE)) == (int) FAIL)
4053           || (end_of_line (backupstr) == (int) FAIL))
4054         {
4055           return;
4056         }
4057       else
4058         {
4059           char append_str1[MAX_LITERAL_POOL_SIZE];
4060
4061           if (strcmp (inst.name, "rem") == 0)
4062             {
4063               sprintf (append_str, "mul r%d, r%d", reg_rs1, reg_rs2);
4064               sprintf (append_str1, "mfceh  r%d", reg_rd);
4065             }
4066           else if (strcmp (inst.name, "remu") == 0)
4067             {
4068               sprintf (append_str, "mulu r%d, r%d", reg_rs1, reg_rs2);
4069               sprintf (append_str1, "mfceh  r%d", reg_rd);
4070             }
4071           else
4072             {
4073               sprintf (append_str, "%s r%d, r%d", inst.name, reg_rs1, reg_rs2);
4074               sprintf (append_str1, "mfcel  r%d", reg_rd);
4075             }
4076
4077           /* Output mul/mulu or div/divu or rem/remu.  */
4078           if (append_insn (append_str, TRUE) == (int) FAIL)
4079             return;
4080
4081           /* Output mfcel or mfceh.  */
4082           if (append_insn (append_str1, TRUE) == (int) FAIL)
4083             return;
4084
4085           /* Set bwarn as -1, so macro instruction itself will not be generated frag.  */
4086           inst.bwarn = -1;
4087         }
4088     }
4089 }
4090
4091 static void
4092 exp_macro_ldst_abs (char *str)
4093 {
4094   int reg_rd;
4095   char *backupstr, *tmp;
4096   char append_str[MAX_LITERAL_POOL_SIZE];
4097   char verifystr[MAX_LITERAL_POOL_SIZE];
4098   struct score_it inst_backup;
4099   int r1_bak = 0;
4100
4101   r1_bak = nor1;
4102   nor1 = 0;
4103   memcpy (&inst_backup, &inst, sizeof (struct score_it));
4104
4105   strcpy (verifystr, str);
4106   backupstr = verifystr;
4107   skip_whitespace (backupstr);
4108   if ((reg_rd = reg_required_here (&backupstr, -1, REG_TYPE_SCORE)) == (int) FAIL)
4109     return;
4110
4111   tmp = backupstr;
4112   if (skip_past_comma (&backupstr) == (int) FAIL)
4113     return;
4114
4115   backupstr = tmp;
4116   sprintf (append_str, "li r1  %s", backupstr);
4117   append_insn (append_str, TRUE);
4118
4119   memcpy (&inst, &inst_backup, sizeof (struct score_it));
4120   sprintf (append_str, " r%d, [r1,0]", reg_rd);
4121   do_ldst_insn (append_str);
4122
4123   nor1 = r1_bak;
4124 }
4125
4126 static int
4127 nopic_need_relax (symbolS * sym, int before_relaxing)
4128 {
4129   if (sym == NULL)
4130     return 0;
4131   else if (USE_GLOBAL_POINTER_OPT && g_switch_value > 0)
4132     {
4133       const char *symname;
4134       const char *segname;
4135
4136       /* Find out whether this symbol can be referenced off the $gp
4137          register.  It can be if it is smaller than the -G size or if
4138          it is in the .sdata or .sbss section.  Certain symbols can
4139          not be referenced off the $gp, although it appears as though
4140          they can.  */
4141       symname = S_GET_NAME (sym);
4142       if (symname != (const char *)NULL
4143           && (strcmp (symname, "eprol") == 0
4144               || strcmp (symname, "etext") == 0
4145               || strcmp (symname, "_gp") == 0
4146               || strcmp (symname, "edata") == 0
4147               || strcmp (symname, "_fbss") == 0
4148               || strcmp (symname, "_fdata") == 0
4149               || strcmp (symname, "_ftext") == 0
4150               || strcmp (symname, "end") == 0
4151               || strcmp (symname, GP_DISP_LABEL) == 0))
4152         {
4153           return 1;
4154         }
4155       else if ((!S_IS_DEFINED (sym) || S_IS_COMMON (sym)) && (0
4156       /* We must defer this decision until after the whole file has been read,
4157          since there might be a .extern after the first use of this symbol.  */
4158                || (before_relaxing
4159                    && S_GET_VALUE (sym) == 0)
4160                || (S_GET_VALUE (sym) != 0
4161                    && S_GET_VALUE (sym) <= g_switch_value)))
4162         {
4163           return 0;
4164         }
4165
4166       segname = segment_name (S_GET_SEGMENT (sym));
4167       return (strcmp (segname, ".sdata") != 0
4168               && strcmp (segname, ".sbss") != 0
4169               && strncmp (segname, ".sdata.", 7) != 0
4170               && strncmp (segname, ".gnu.linkonce.s.", 16) != 0);
4171     }
4172   /* We are not optimizing for the $gp register.  */
4173   else
4174     return 1;
4175 }
4176
4177 /* Build a relax frag for lw/st instruction when generating PIC,
4178    external symbol first and local symbol second.  */
4179
4180 static void
4181 build_lwst_pic (int reg_rd, expressionS exp, const char *insn_name)
4182 {
4183   symbolS *add_symbol = exp.X_add_symbol;
4184   int add_number = exp.X_add_number;
4185   struct score_it fix_insts[RELAX_INST_NUM];
4186   struct score_it var_insts[RELAX_INST_NUM];
4187   int fix_num = 0;
4188   int var_num = 0;
4189   char tmp[MAX_LITERAL_POOL_SIZE];
4190   int r1_bak;
4191
4192   r1_bak = nor1;
4193   nor1 = 0;
4194
4195   if ((add_number == 0) || (add_number >= -0x8000 && add_number <= 0x7fff))
4196     {
4197       fix_num = 1;
4198       var_num = 2;
4199
4200       /* For an external symbol, two insns are generated;
4201          For a local symbol, three insns are generated.  */
4202       /* Fix part
4203          For an external symbol: lw rD, <sym>($gp)
4204                                  (BFD_RELOC_SCORE_GOT15)  */
4205       sprintf (tmp, "lw_pic r1, %s", add_symbol->bsym->name);
4206       if (append_insn (tmp, FALSE) == (int) FAIL)
4207         return;
4208
4209       memcpy (&fix_insts[0], &inst, sizeof (struct score_it));
4210
4211       /* Var part
4212          For a local symbol :
4213          lw rD, <sym>($gp)    (BFD_RELOC_SCORE_GOT15)
4214          addi rD, <sym>       (BFD_RELOC_GOT_LO16) */
4215       inst.reloc.type = BFD_RELOC_SCORE_GOT15;
4216       memcpy (&var_insts[0], &inst, sizeof (struct score_it));
4217       sprintf (tmp, "addi_s_pic r1, %s", add_symbol->bsym->name);
4218       if (append_insn (tmp, FALSE) == (int) FAIL)
4219         return;
4220
4221       memcpy (&var_insts[1], &inst, sizeof (struct score_it));
4222       build_relax_frag (fix_insts, fix_num, var_insts, var_num, add_symbol);
4223
4224       /* Insn 2 or Insn 3: lw/st rD, [r1, constant]  */
4225       sprintf (tmp, "%s r%d, [r1, %d]", insn_name, reg_rd, add_number);
4226       if (append_insn (tmp, TRUE) == (int) FAIL)
4227         return;
4228
4229       /* Set bwarn as -1, so macro instruction itself will not be generated frag.  */
4230       inst.bwarn = -1;
4231     }
4232   else
4233     {
4234       inst.error = _("PIC code offset overflow (max 16 signed bits)");
4235       return;
4236     }
4237
4238   nor1 = r1_bak;
4239 }
4240
4241 static void
4242 do_macro_ldst_label (char *str)
4243 {
4244   int i;
4245   int ldst_gp_p = 0;
4246   int reg_rd;
4247   int r1_bak;
4248   char *backup_str;
4249   char *label_str;
4250   char *absolute_value;
4251   char append_str[3][MAX_LITERAL_POOL_SIZE];
4252   char verifystr[MAX_LITERAL_POOL_SIZE];
4253   struct score_it inst_backup;
4254   struct score_it inst_expand[3];
4255   struct score_it inst_main;
4256
4257   memcpy (&inst_backup, &inst, sizeof (struct score_it));
4258   strcpy (verifystr, str);
4259   backup_str = verifystr;
4260
4261   skip_whitespace (backup_str);
4262   if ((reg_rd = reg_required_here (&backup_str, -1, REG_TYPE_SCORE)) == (int) FAIL)
4263     return;
4264
4265   if (skip_past_comma (&backup_str) == (int) FAIL)
4266     return;
4267
4268   label_str = backup_str;
4269
4270   /* Ld/st rD, [rA, imm]      ld/st rD, [rA]+, imm      ld/st rD, [rA, imm]+.  */
4271   if (*backup_str == '[')
4272     {
4273       inst.type = Rd_rvalueRs_preSI12;
4274       do_ldst_insn (str);
4275       return;
4276     }
4277
4278   /* Ld/st rD, imm.  */
4279   absolute_value = backup_str;
4280   inst.type = Rd_rvalueRs_SI15;
4281   if ((my_get_expression (&inst.reloc.exp, &backup_str) == (int) FAIL)
4282       || (validate_immediate (inst.reloc.exp.X_add_number, _VALUE, 0) == (int) FAIL)
4283       || (end_of_line (backup_str) == (int) FAIL))
4284     {
4285       return;
4286     }
4287   else
4288     {
4289       if (inst.reloc.exp.X_add_symbol == 0)
4290         {
4291           memcpy (&inst, &inst_backup, sizeof (struct score_it));
4292           exp_macro_ldst_abs (str);
4293           return;
4294         }
4295     }
4296
4297   /* Ld/st rD, label.  */
4298   inst.type = Rd_rvalueRs_SI15;
4299   backup_str = absolute_value;
4300   if ((data_op2 (&backup_str, 1, _GP_IMM15) == (int) FAIL)
4301       || (end_of_line (backup_str) == (int) FAIL))
4302     {
4303       return;
4304     }
4305   else
4306     {
4307       if (inst.reloc.exp.X_add_symbol == 0)
4308         {
4309           if (!inst.error)
4310             inst.error = BAD_ARGS;
4311
4312           return;
4313         }
4314
4315       if (score_pic == PIC)
4316         {
4317           int ldst_idx = 0;
4318           ldst_idx = inst.instruction & OPC_PSEUDOLDST_MASK;
4319           build_lwst_pic (reg_rd, inst.reloc.exp, score_ldst_insns[ldst_idx * 3 + 0].template);
4320           return;
4321         }
4322       else
4323         {
4324           if ((inst.reloc.exp.X_add_number <= 0x3fff)
4325                && (inst.reloc.exp.X_add_number >= -0x4000)
4326                && (!nopic_need_relax (inst.reloc.exp.X_add_symbol, 1)))
4327             {
4328               int ldst_idx = 0;
4329
4330               /* Assign the real opcode.  */
4331               ldst_idx = inst.instruction & OPC_PSEUDOLDST_MASK;
4332               inst.instruction &= ~OPC_PSEUDOLDST_MASK;
4333               inst.instruction |= score_ldst_insns[ldst_idx * 3 + 0].value;
4334               inst.instruction |= reg_rd << 20;
4335               inst.instruction |= GP << 15;
4336               inst.relax_inst = 0x8000;
4337               inst.relax_size = 0;
4338               ldst_gp_p = 1;
4339             }
4340         }
4341     }
4342
4343   /* Backup inst.  */
4344   memcpy (&inst_main, &inst, sizeof (struct score_it));
4345   r1_bak = nor1;
4346   nor1 = 0;
4347
4348   /* Determine which instructions should be output.  */
4349   sprintf (append_str[0], "ld_i32hi r1, %s", label_str);
4350   sprintf (append_str[1], "ld_i32lo r1, %s", label_str);
4351   sprintf (append_str[2], "%s r%d, [r1, 0]", inst_backup.name, reg_rd);
4352
4353   /* Generate three instructions.
4354      la r1, label
4355      ld/st rd, [r1, 0]  */
4356   for (i = 0; i < 3; i++)
4357     {
4358       if (append_insn (append_str[i], FALSE) == (int) FAIL)
4359         return;
4360
4361       memcpy (&inst_expand[i], &inst, sizeof (struct score_it));
4362     }
4363
4364   if (ldst_gp_p)
4365     {
4366       char *p;
4367
4368       /* Adjust instruction opcode and to be relaxed instruction opcode.  */
4369       inst_main.instruction = adjust_paritybit (inst_main.instruction, GET_INSN_CLASS (inst_main.type));
4370       inst_main.relax_size = inst_expand[0].size + inst_expand[1].size + inst_expand[2].size;
4371       inst_main.type = Insn_GP;
4372
4373       for (i = 0; i < 3; i++)
4374         inst_expand[i].instruction = adjust_paritybit (inst_expand[i].instruction
4375                                                        , GET_INSN_CLASS (inst_expand[i].type));
4376
4377       /* Check data dependency.  */
4378       handle_dependency (&inst_main);
4379
4380       /* Start a new frag if frag_now is not empty.  */
4381       if (frag_now_fix () != 0)
4382         {
4383           if (!frag_now->tc_frag_data.is_insn)
4384             frag_wane (frag_now);
4385
4386           frag_new (0);
4387         }
4388       frag_grow (20);
4389
4390       /* Write fr_fix part.  */
4391       p = frag_more (inst_main.size);
4392       md_number_to_chars (p, inst_main.instruction, inst_main.size);
4393
4394       if (inst_main.reloc.type != BFD_RELOC_NONE)
4395         {
4396           fix_new_score (frag_now, p - frag_now->fr_literal, inst_main.size,
4397                          &inst_main.reloc.exp, inst_main.reloc.pc_rel, inst_main.reloc.type);
4398         }
4399
4400 #ifdef OBJ_ELF
4401       dwarf2_emit_insn (inst_main.size);
4402 #endif
4403
4404       /* GP instruction can not do optimization, only can do relax between
4405          1 instruction and 3 instructions.  */
4406       p = frag_var (rs_machine_dependent, inst_main.relax_size + RELAX_PAD_BYTE, 0,
4407                     RELAX_ENCODE (inst_main.size, inst_main.relax_size, inst_main.type, 0, 4, 0),
4408                     inst_main.reloc.exp.X_add_symbol, 0, NULL);
4409
4410       /* Write fr_var part.
4411          no calling gen_insn_frag, no fixS will be generated.  */
4412       md_number_to_chars (p, inst_expand[0].instruction, inst_expand[0].size);
4413       p += inst_expand[0].size;
4414       md_number_to_chars (p, inst_expand[1].instruction, inst_expand[1].size);
4415       p += inst_expand[1].size;
4416       md_number_to_chars (p, inst_expand[2].instruction, inst_expand[2].size);
4417     }
4418   else
4419     {
4420       gen_insn_frag (&inst_expand[0], NULL);
4421       gen_insn_frag (&inst_expand[1], NULL);
4422       gen_insn_frag (&inst_expand[2], NULL);
4423     }
4424   nor1 = r1_bak;
4425
4426   /* Set bwarn as -1, so macro instruction itself will not be generated frag.  */
4427   inst.bwarn = -1;
4428 }
4429
4430 static void
4431 do_lw_pic (char *str)
4432 {
4433   int reg_rd;
4434
4435   skip_whitespace (str);
4436   if (((reg_rd = reg_required_here (&str, 20, REG_TYPE_SCORE)) == (int) FAIL)
4437       || (skip_past_comma (&str) == (int) FAIL)
4438       || (my_get_expression (&inst.reloc.exp, &str) == (int) FAIL)
4439       || (end_of_line (str) == (int) FAIL))
4440     {
4441       return;
4442     }
4443   else
4444     {
4445       if (inst.reloc.exp.X_add_symbol == 0)
4446         {
4447           if (!inst.error)
4448             inst.error = BAD_ARGS;
4449
4450           return;
4451         }
4452
4453       inst.instruction |= GP << 15;
4454       inst.reloc.type = BFD_RELOC_SCORE_GOT15;
4455     }
4456 }
4457
4458 static void
4459 do_empty (char *str)
4460 {
4461   str = str;
4462   if (university_version == 1)
4463     {
4464       if (((inst.instruction & 0x3e0003ff) == 0x0c000004)
4465           || ((inst.instruction & 0x3e0003ff) == 0x0c000024)
4466           || ((inst.instruction & 0x3e0003ff) == 0x0c000044)
4467           || ((inst.instruction & 0x3e0003ff) == 0x0c000064))
4468         {
4469           inst.error = ERR_FOR_SCORE5U_MMU;
4470           return;
4471         }
4472     }
4473   if (end_of_line (str) == (int) FAIL)
4474     return;
4475
4476   if (inst.relax_inst != 0x8000)
4477     {
4478       if (inst.type == NO_OPD)
4479         {
4480           inst.relax_size = 2;
4481         }
4482       else
4483         {
4484           inst.relax_size = 4;
4485         }
4486     }
4487 }
4488
4489 static void
4490 do_jump (char *str)
4491 {
4492   char *save_in;
4493
4494   skip_whitespace (str);
4495   if (my_get_expression (&inst.reloc.exp, &str) == (int) FAIL
4496       || end_of_line (str) == (int) FAIL)
4497     return;
4498
4499   if (inst.reloc.exp.X_add_symbol == 0)
4500     {
4501       inst.error = _("lacking label  ");
4502       return;
4503     }
4504
4505   if (((inst.reloc.exp.X_add_number & 0xff000000) != 0)
4506       && ((inst.reloc.exp.X_add_number & 0xff000000) != 0xff000000))
4507     {
4508       inst.error = _("invalid constant: 25 bit expression not in range -2^24..2^24");
4509       return;
4510     }
4511
4512   save_in = input_line_pointer;
4513   input_line_pointer = str;
4514   inst.reloc.type = BFD_RELOC_SCORE_JMP;
4515   inst.reloc.pc_rel = 1;
4516   input_line_pointer = save_in;
4517 }
4518
4519 static void
4520 do16_jump (char *str)
4521 {
4522   skip_whitespace (str);
4523   if (my_get_expression (&inst.reloc.exp, &str) == (int) FAIL
4524       || end_of_line (str) == (int) FAIL)
4525     {
4526       return;
4527     }
4528   else if (inst.reloc.exp.X_add_symbol == 0)
4529     {
4530       inst.error = _("lacking label  ");
4531       return;
4532     }
4533   else if (((inst.reloc.exp.X_add_number & 0xfffff800) != 0)
4534            && ((inst.reloc.exp.X_add_number & 0xfffff800) != 0xfffff800))
4535     {
4536       inst.error = _("invalid constant: 12 bit expression not in range -2^11..2^11");
4537       return;
4538     }
4539
4540   inst.reloc.type = BFD_RELOC_SCORE16_JMP;
4541   inst.reloc.pc_rel = 1;
4542 }
4543
4544 static void
4545 do_branch (char *str)
4546 {
4547   unsigned long abs_value = 0;
4548
4549   if (my_get_expression (&inst.reloc.exp, &str) == (int) FAIL
4550       || end_of_line (str) == (int) FAIL)
4551     {
4552       return;
4553     }
4554   else if (inst.reloc.exp.X_add_symbol == 0)
4555     {
4556       inst.error = _("lacking label  ");
4557       return;
4558     }
4559   else if (((inst.reloc.exp.X_add_number & 0xff000000) != 0)
4560            && ((inst.reloc.exp.X_add_number & 0xff000000) != 0xff000000))
4561     {
4562       inst.error = _("invalid constant: 20 bit expression not in range -2^19..2^19");
4563       return;
4564     }
4565
4566   inst.reloc.type = BFD_RELOC_SCORE_BRANCH;
4567   inst.reloc.pc_rel = 1;
4568
4569   /* Branch 32  offset field : 20 bit, 16 bit branch offset field : 8 bit.  */
4570   inst.instruction |= (inst.reloc.exp.X_add_number & 0x3fe) | ((inst.reloc.exp.X_add_number & 0xffc00) << 5);
4571
4572   /* Compute 16 bit branch instruction.  */
4573   if ((inst.relax_inst != 0x8000) && (abs_value & 0xfffffe00) == 0)
4574     {
4575       inst.relax_inst |= (((inst.instruction >> 10) & 0xf) << 8);
4576       inst.relax_inst |= ((inst.reloc.exp.X_add_number >> 1) & 0xff);
4577       inst.relax_size = 2;
4578     }
4579   else
4580     {
4581       inst.relax_inst = 0x8000;
4582     }
4583 }
4584
4585 static void
4586 do16_branch (char *str)
4587 {
4588   if ((my_get_expression (&inst.reloc.exp, &str) == (int) FAIL
4589       || end_of_line (str) == (int) FAIL))
4590     {
4591       ;
4592     }
4593   else if (inst.reloc.exp.X_add_symbol == 0)
4594     {
4595       inst.error = _("lacking label");
4596     }
4597   else if (((inst.reloc.exp.X_add_number & 0xffffff00) != 0)
4598            && ((inst.reloc.exp.X_add_number & 0xffffff00) != 0xffffff00))
4599     {
4600       inst.error = _("invalid constant: 9 bit expression not in range -2^8..2^8");
4601     }
4602   else
4603     {
4604       inst.reloc.type = BFD_RELOC_SCORE16_BRANCH;
4605       inst.reloc.pc_rel = 1;
4606       inst.instruction |= ((inst.reloc.exp.X_add_number >> 1) & 0xff);
4607     }
4608 }
4609
4610 /* Iterate over the base tables to create the instruction patterns.  */
4611 static void
4612 build_score_ops_hsh (void)
4613 {
4614   unsigned int i;
4615   static struct obstack insn_obstack;
4616
4617   obstack_begin (&insn_obstack, 4000);
4618   for (i = 0; i < sizeof (score_insns) / sizeof (struct asm_opcode); i++)
4619     {
4620       const struct asm_opcode *insn = score_insns + i;
4621       unsigned len = strlen (insn->template);
4622       struct asm_opcode *new;
4623       char *template;
4624       new = obstack_alloc (&insn_obstack, sizeof (struct asm_opcode));
4625       template = obstack_alloc (&insn_obstack, len + 1);
4626
4627       strcpy (template, insn->template);
4628       new->template = template;
4629       new->parms = insn->parms;
4630       new->value = insn->value;
4631       new->relax_value = insn->relax_value;
4632       new->type = insn->type;
4633       new->bitmask = insn->bitmask;
4634       hash_insert (score_ops_hsh, new->template, (void *) new);
4635     }
4636 }
4637
4638 static void
4639 build_dependency_insn_hsh (void)
4640 {
4641   unsigned int i;
4642   static struct obstack dependency_obstack;
4643
4644   obstack_begin (&dependency_obstack, 4000);
4645   for (i = 0; i < sizeof (insn_to_dependency_table) / sizeof (insn_to_dependency_table[0]); i++)
4646     {
4647       const struct insn_to_dependency *tmp = insn_to_dependency_table + i;
4648       unsigned len = strlen (tmp->insn_name);
4649       struct insn_to_dependency *new;
4650
4651       new = obstack_alloc (&dependency_obstack, sizeof (struct insn_to_dependency));
4652       new->insn_name = obstack_alloc (&dependency_obstack, len + 1);
4653
4654       strcpy (new->insn_name, tmp->insn_name);
4655       new->type = tmp->type;
4656       hash_insert (dependency_insn_hsh, new->insn_name, (void *) new);
4657     }
4658 }
4659
4660 /* Turn an integer of n bytes (in val) into a stream of bytes appropriate
4661    for use in the a.out file, and stores them in the array pointed to by buf.
4662    This knows about the endian-ness of the target machine and does
4663    THE RIGHT THING, whatever it is.  Possible values for n are 1 (byte)
4664    2 (short) and 4 (long)  Floating numbers are put out as a series of
4665    LITTLENUMS (shorts, here at least).  */
4666
4667 void
4668 md_number_to_chars (char *buf, valueT val, int n)
4669 {
4670   if (target_big_endian)
4671     number_to_chars_bigendian (buf, val, n);
4672   else
4673     number_to_chars_littleendian (buf, val, n);
4674 }
4675
4676 static valueT
4677 md_chars_to_number (char *buf, int n)
4678 {
4679   valueT result = 0;
4680   unsigned char *where = (unsigned char *)buf;
4681
4682   if (target_big_endian)
4683     {
4684       while (n--)
4685         {
4686           result <<= 8;
4687           result |= (*where++ & 255);
4688         }
4689     }
4690   else
4691     {
4692       while (n--)
4693         {
4694           result <<= 8;
4695           result |= (where[n] & 255);
4696         }
4697     }
4698
4699   return result;
4700 }
4701
4702 char *
4703 md_atof (int type, char *litP, int *sizeP)
4704 {
4705   return ieee_md_atof (type, litP, sizeP, target_big_endian);
4706 }
4707
4708 /* Return true if the given symbol should be considered local for PIC.  */
4709
4710 static bfd_boolean
4711 pic_need_relax (symbolS *sym, asection *segtype)
4712 {
4713   asection *symsec;
4714   bfd_boolean linkonce;
4715
4716   /* Handle the case of a symbol equated to another symbol.  */
4717   while (symbol_equated_reloc_p (sym))
4718     {
4719       symbolS *n;
4720
4721       /* It's possible to get a loop here in a badly written
4722          program.  */
4723       n = symbol_get_value_expression (sym)->X_add_symbol;
4724       if (n == sym)
4725         break;
4726       sym = n;
4727     }
4728
4729   symsec = S_GET_SEGMENT (sym);
4730
4731   /* duplicate the test for LINK_ONCE sections as in adjust_reloc_syms */
4732   linkonce = FALSE;
4733   if (symsec != segtype && ! S_IS_LOCAL (sym))
4734     {
4735       if ((bfd_get_section_flags (stdoutput, symsec) & SEC_LINK_ONCE) != 0)
4736         linkonce = TRUE;
4737
4738       /* The GNU toolchain uses an extension for ELF: a section
4739           beginning with the magic string .gnu.linkonce is a linkonce
4740           section.  */
4741       if (strncmp (segment_name (symsec), ".gnu.linkonce",
4742                    sizeof ".gnu.linkonce" - 1) == 0)
4743         linkonce = TRUE;
4744     }
4745
4746   /* This must duplicate the test in adjust_reloc_syms.  */
4747   return (symsec != &bfd_und_section
4748             && symsec != &bfd_abs_section
4749           && ! bfd_is_com_section (symsec)
4750             && !linkonce
4751 #ifdef OBJ_ELF
4752           /* A global or weak symbol is treated as external.  */
4753           && (OUTPUT_FLAVOR != bfd_target_elf_flavour
4754               || (! S_IS_WEAK (sym) && ! S_IS_EXTERNAL (sym)))
4755 #endif
4756           );
4757 }
4758
4759 static int
4760 judge_size_before_relax (fragS * fragp, asection *sec)
4761 {
4762   int change = 0;
4763
4764   if (score_pic == NO_PIC)
4765     change = nopic_need_relax (fragp->fr_symbol, 0);
4766   else
4767     change = pic_need_relax (fragp->fr_symbol, sec);
4768
4769   if (change == 1)
4770     {
4771       /* Only at the first time determining whether GP instruction relax should be done,
4772          return the difference between insntruction size and instruction relax size.  */
4773       if (fragp->fr_opcode == NULL)
4774         {
4775           fragp->fr_fix = RELAX_NEW (fragp->fr_subtype);
4776           fragp->fr_opcode = fragp->fr_literal + RELAX_RELOC1 (fragp->fr_subtype);
4777           return RELAX_NEW (fragp->fr_subtype) - RELAX_OLD (fragp->fr_subtype);
4778         }
4779     }
4780
4781   return 0;
4782 }
4783
4784 /* In this function, we determine whether GP instruction should do relaxation,
4785    for the label being against was known now.
4786    Doing this here but not in md_relax_frag() can induce iteration times
4787    in stage of doing relax.  */
4788 int
4789 md_estimate_size_before_relax (fragS * fragp, asection * sec ATTRIBUTE_UNUSED)
4790 {
4791   if ((RELAX_TYPE (fragp->fr_subtype) == Insn_GP)
4792       || (RELAX_TYPE (fragp->fr_subtype) == Insn_PIC))
4793     return judge_size_before_relax (fragp, sec);
4794
4795   return 0;
4796 }
4797
4798 static int
4799 b32_relax_to_b16 (fragS * fragp)
4800 {
4801   int grows = 0;
4802   int relaxable_p = 0;
4803   int old;
4804   int new;
4805   int frag_addr = fragp->fr_address + fragp->insn_addr;
4806
4807   addressT symbol_address = 0;
4808   symbolS *s;
4809   offsetT offset;
4810   unsigned long value;
4811   unsigned long abs_value;
4812
4813   /* FIXME : here may be able to modify better .
4814      I don't know how to get the fragp's section ,
4815      so in relax stage , it may be wrong to calculate the symbol's offset when the frag's section
4816      is different from the symbol's.  */
4817
4818   old = RELAX_OLD (fragp->fr_subtype);
4819   new = RELAX_NEW (fragp->fr_subtype);
4820   relaxable_p = RELAX_OPT (fragp->fr_subtype);
4821
4822   s = fragp->fr_symbol;
4823   /* b/bl immediate  */
4824   if (s == NULL)
4825     frag_addr = 0;
4826   else
4827     {
4828       if (s->bsym != 0)
4829         symbol_address = (addressT) s->sy_frag->fr_address;
4830     }
4831
4832   value = md_chars_to_number (fragp->fr_literal, INSN_SIZE);
4833
4834   /* b 32's offset : 20 bit, b 16's tolerate field : 0xff.  */
4835   offset = ((value & 0x3ff0000) >> 6) | (value & 0x3fe);
4836   if ((offset & 0x80000) == 0x80000)
4837     offset |= 0xfff00000;
4838
4839   abs_value = offset + symbol_address - frag_addr;
4840   if ((abs_value & 0x80000000) == 0x80000000)
4841     abs_value = 0xffffffff - abs_value + 1;
4842
4843   /* Relax branch 32 to branch 16.  */
4844   if (relaxable_p && (s->bsym != NULL) && ((abs_value & 0xffffff00) == 0)
4845       && (S_IS_DEFINED (s) && !S_IS_COMMON (s) && !S_IS_EXTERNAL (s)))
4846     {
4847       /* do nothing.  */
4848     }
4849   else
4850     {
4851       /* Branch 32 can not be relaxed to b 16, so clear OPT bit.  */
4852       fragp->fr_opcode = NULL;
4853       fragp->fr_subtype = RELAX_OPT_CLEAR (fragp->fr_subtype);
4854     }
4855
4856   return grows;
4857 }
4858
4859 /* Main purpose is to determine whether one frag should do relax.
4860    frag->fr_opcode indicates this point.  */
4861
4862 int
4863 score_relax_frag (asection * sec ATTRIBUTE_UNUSED, fragS * fragp, long stretch ATTRIBUTE_UNUSED)
4864 {
4865   int grows = 0;
4866   int insn_size;
4867   int insn_relax_size;
4868   int do_relax_p = 0;           /* Indicate doing relaxation for this frag.  */
4869   int relaxable_p = 0;
4870   bfd_boolean word_align_p = FALSE;
4871   fragS *next_fragp;
4872
4873   /* If the instruction address is odd, make it half word align first.  */
4874   if ((fragp->fr_address) % 2 != 0)
4875     {
4876       if ((fragp->fr_address + fragp->insn_addr) % 2 != 0)
4877         {
4878           fragp->insn_addr = 1;
4879           grows += 1;
4880         }
4881     }
4882
4883   word_align_p = ((fragp->fr_address + fragp->insn_addr) % 4 == 0) ? TRUE : FALSE;
4884
4885   /* Get instruction size and relax size after the last relaxation.  */
4886   if (fragp->fr_opcode)
4887     {
4888       insn_size = RELAX_NEW (fragp->fr_subtype);
4889       insn_relax_size = RELAX_OLD (fragp->fr_subtype);
4890     }
4891   else
4892     {
4893       insn_size = RELAX_OLD (fragp->fr_subtype);
4894       insn_relax_size = RELAX_NEW (fragp->fr_subtype);
4895     }
4896
4897   /* Handle specially for GP instruction.  for, judge_size_before_relax() has already determine
4898      whether the GP instruction should do relax.  */
4899   if ((RELAX_TYPE (fragp->fr_subtype) == Insn_GP)
4900       || (RELAX_TYPE (fragp->fr_subtype) == Insn_PIC))
4901     {
4902       if (!word_align_p)
4903         {
4904           if (fragp->insn_addr < 2)
4905             {
4906               fragp->insn_addr += 2;
4907               grows += 2;
4908             }
4909           else
4910             {
4911               fragp->insn_addr -= 2;
4912               grows -= 2;
4913             }
4914         }
4915
4916       if (fragp->fr_opcode)
4917         fragp->fr_fix = RELAX_NEW (fragp->fr_subtype) + fragp->insn_addr;
4918       else
4919         fragp->fr_fix = RELAX_OLD (fragp->fr_subtype) + fragp->insn_addr;
4920     }
4921   else
4922     {
4923       if (RELAX_TYPE (fragp->fr_subtype) == PC_DISP19div2)
4924         b32_relax_to_b16 (fragp);
4925
4926       relaxable_p = RELAX_OPT (fragp->fr_subtype);
4927       next_fragp = fragp->fr_next;
4928       while ((next_fragp) && (next_fragp->fr_type != rs_machine_dependent))
4929         {
4930           next_fragp = next_fragp->fr_next;
4931         }
4932
4933       if (next_fragp)
4934         {
4935           int n_insn_size;
4936           int n_relaxable_p = 0;
4937
4938           if (next_fragp->fr_opcode)
4939             {
4940               n_insn_size = RELAX_NEW (next_fragp->fr_subtype);
4941             }
4942           else
4943             {
4944               n_insn_size = RELAX_OLD (next_fragp->fr_subtype);
4945             }
4946
4947           if (RELAX_TYPE (next_fragp->fr_subtype) == PC_DISP19div2)
4948             b32_relax_to_b16 (next_fragp);
4949           n_relaxable_p = RELAX_OPT (next_fragp->fr_subtype);
4950
4951           if (word_align_p)
4952             {
4953               if (insn_size == 4)
4954                 {
4955                   /* 32 -> 16.  */
4956                   if (relaxable_p && ((n_insn_size == 2) || n_relaxable_p))
4957                     {
4958                       grows -= 2;
4959                       do_relax_p = 1;
4960                     }
4961                 }
4962               else if (insn_size == 2)
4963                 {
4964                   /* 16 -> 32.  */
4965                   if (relaxable_p && (((n_insn_size == 4) && !n_relaxable_p) || (n_insn_size > 4)))
4966                     {
4967                       grows += 2;
4968                       do_relax_p = 1;
4969                     }
4970                 }
4971               else
4972                 {
4973                   abort ();
4974                 }
4975             }
4976           else
4977             {
4978               if (insn_size == 4)
4979                 {
4980                   /* 32 -> 16.  */
4981                   if (relaxable_p)
4982                     {
4983                       grows -= 2;
4984                       do_relax_p = 1;
4985                     }
4986                   /* Make the 32 bit insturction word align.  */
4987                   else
4988                     {
4989                       fragp->insn_addr += 2;
4990                       grows += 2;
4991                     }
4992                 }
4993               else if (insn_size == 2)
4994                 {
4995                   /* Do nothing.  */
4996                 }
4997               else
4998                 {
4999                   abort ();
5000                 }
5001             }
5002         }
5003       else
5004         {
5005           /* Here, try best to do relax regardless fragp->fr_next->fr_type.  */
5006           if (word_align_p == FALSE)
5007             {
5008               if (insn_size % 4 == 0)
5009                 {
5010                   /* 32 -> 16.  */
5011                   if (relaxable_p)
5012                     {
5013                       grows -= 2;
5014                       do_relax_p = 1;
5015                     }
5016                   else
5017                     {
5018                       fragp->insn_addr += 2;
5019                       grows += 2;
5020                     }
5021                 }
5022             }
5023           else
5024             {
5025               /* Do nothing.  */
5026             }
5027         }
5028
5029       /* fragp->fr_opcode indicates whether this frag should be relaxed.  */
5030       if (do_relax_p)
5031         {
5032           if (fragp->fr_opcode)
5033             {
5034               fragp->fr_opcode = NULL;
5035               /* Guarantee estimate stage is correct.  */
5036               fragp->fr_fix = RELAX_OLD (fragp->fr_subtype);
5037               fragp->fr_fix += fragp->insn_addr;
5038             }
5039           else
5040             {
5041               fragp->fr_opcode = fragp->fr_literal + RELAX_RELOC1 (fragp->fr_subtype);
5042               /* Guarantee estimate stage is correct.  */
5043               fragp->fr_fix = RELAX_NEW (fragp->fr_subtype);
5044               fragp->fr_fix += fragp->insn_addr;
5045             }
5046         }
5047       else
5048         {
5049           if (fragp->fr_opcode)
5050             {
5051               /* Guarantee estimate stage is correct.  */
5052               fragp->fr_fix = RELAX_NEW (fragp->fr_subtype);
5053               fragp->fr_fix += fragp->insn_addr;
5054             }
5055           else
5056             {
5057               /* Guarantee estimate stage is correct.  */
5058               fragp->fr_fix = RELAX_OLD (fragp->fr_subtype);
5059               fragp->fr_fix += fragp->insn_addr;
5060             }
5061         }
5062     }
5063
5064   return grows;
5065 }
5066
5067 void
5068 md_convert_frag (bfd * abfd ATTRIBUTE_UNUSED, segT sec ATTRIBUTE_UNUSED, fragS * fragp)
5069 {
5070   int old;
5071   int new;
5072   char backup[20];
5073   fixS *fixp;
5074
5075   old = RELAX_OLD (fragp->fr_subtype);
5076   new = RELAX_NEW (fragp->fr_subtype);
5077
5078   /* fragp->fr_opcode indicates whether this frag should be relaxed.  */
5079   if (fragp->fr_opcode == NULL)
5080     {
5081       memcpy (backup, fragp->fr_literal, old);
5082       fragp->fr_fix = old;
5083     }
5084   else
5085     {
5086       memcpy (backup, fragp->fr_literal + old, new);
5087       fragp->fr_fix = new;
5088     }
5089
5090   fixp = fragp->tc_frag_data.fixp;
5091   while (fixp && fixp->fx_frag == fragp && fixp->fx_where < old)
5092     {
5093       if (fragp->fr_opcode)
5094         fixp->fx_done = 1;
5095       fixp = fixp->fx_next;
5096     }
5097   while (fixp && fixp->fx_frag == fragp)
5098     {
5099       if (fragp->fr_opcode)
5100         fixp->fx_where -= old + fragp->insn_addr;
5101       else
5102         fixp->fx_done = 1;
5103       fixp = fixp->fx_next;
5104     }
5105
5106   if (fragp->insn_addr)
5107     {
5108       md_number_to_chars (fragp->fr_literal, 0x0, fragp->insn_addr);
5109     }
5110   memcpy (fragp->fr_literal + fragp->insn_addr, backup, fragp->fr_fix);
5111   fragp->fr_fix += fragp->insn_addr;
5112 }
5113
5114 /* Implementation of md_frag_check.
5115    Called after md_convert_frag().  */
5116
5117 void
5118 score_frag_check (fragS * fragp ATTRIBUTE_UNUSED)
5119 {
5120   know (fragp->insn_addr <= RELAX_PAD_BYTE);
5121 }
5122
5123 bfd_boolean
5124 score_fix_adjustable (fixS * fixP)
5125 {
5126   if (fixP->fx_addsy == NULL)
5127     {
5128       return 1;
5129     }
5130   else if (OUTPUT_FLAVOR == bfd_target_elf_flavour
5131       && (S_IS_EXTERNAL (fixP->fx_addsy) || S_IS_WEAK (fixP->fx_addsy)))
5132     {
5133       return 0;
5134     }
5135   else if (fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
5136       || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
5137     {
5138       return 0;
5139     }
5140
5141   return 1;
5142 }
5143
5144 /* Implementation of TC_VALIDATE_FIX.
5145    Called before md_apply_fix() and after md_convert_frag().  */
5146 void
5147 score_validate_fix (fixS *fixP)
5148 {
5149   fixP->fx_where += fixP->fx_frag->insn_addr;
5150 }
5151
5152 long
5153 md_pcrel_from (fixS * fixP)
5154 {
5155   long retval = 0;
5156
5157   if (fixP->fx_addsy
5158       && (S_GET_SEGMENT (fixP->fx_addsy) == undefined_section)
5159       && (fixP->fx_subsy == NULL))
5160     {
5161       retval = 0;
5162     }
5163   else
5164     {
5165       retval = fixP->fx_where + fixP->fx_frag->fr_address;
5166     }
5167
5168   return retval;
5169 }
5170
5171 int
5172 score_force_relocation (struct fix *fixp)
5173 {
5174   int retval = 0;
5175
5176   if (fixp->fx_r_type == BFD_RELOC_VTABLE_INHERIT
5177       || fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY
5178       || fixp->fx_r_type == BFD_RELOC_SCORE_JMP
5179       || fixp->fx_r_type == BFD_RELOC_SCORE_BRANCH
5180       || fixp->fx_r_type == BFD_RELOC_SCORE16_JMP
5181       || fixp->fx_r_type == BFD_RELOC_SCORE16_BRANCH)
5182     {
5183       retval = 1;
5184     }
5185
5186   return retval;
5187 }
5188
5189 /* Round up a section size to the appropriate boundary.  */
5190 valueT
5191 md_section_align (segT segment ATTRIBUTE_UNUSED, valueT size)
5192 {
5193   int align = bfd_get_section_alignment (stdoutput, segment);
5194
5195   return ((size + (1 << align) - 1) & (-1 << align));
5196 }
5197
5198 void
5199 md_apply_fix (fixS *fixP, valueT *valP, segT seg)
5200 {
5201   offsetT value = *valP;
5202   offsetT abs_value = 0;
5203   offsetT newval;
5204   offsetT content;
5205   unsigned short HI, LO;
5206
5207   char *buf = fixP->fx_frag->fr_literal + fixP->fx_where;
5208
5209   assert (fixP->fx_r_type < BFD_RELOC_UNUSED);
5210   if (fixP->fx_addsy == 0 && !fixP->fx_pcrel)
5211     {
5212       if (fixP->fx_r_type != BFD_RELOC_SCORE_DUMMY_HI16)
5213         fixP->fx_done = 1;
5214     }
5215
5216   /* If this symbol is in a different section then we need to leave it for
5217      the linker to deal with.  Unfortunately, md_pcrel_from can't tell,
5218      so we have to undo it's effects here.  */
5219   if (fixP->fx_pcrel)
5220     {
5221       if (fixP->fx_addsy != NULL
5222           && S_IS_DEFINED (fixP->fx_addsy)
5223           && S_GET_SEGMENT (fixP->fx_addsy) != seg)
5224         value += md_pcrel_from (fixP);
5225     }
5226
5227   /* Remember value for emit_reloc.  */
5228   fixP->fx_addnumber = value;
5229
5230   switch (fixP->fx_r_type)
5231     {
5232     case BFD_RELOC_HI16_S:
5233       if (fixP->fx_done)
5234         {                       /* For la rd, imm32.  */
5235           newval = md_chars_to_number (buf, INSN_SIZE);
5236           HI = (value) >> 16;   /* mul to 2, then take the hi 16 bit.  */
5237           newval |= (HI & 0x3fff) << 1;
5238           newval |= ((HI >> 14) & 0x3) << 16;
5239           md_number_to_chars (buf, newval, INSN_SIZE);
5240         }
5241       break;
5242     case BFD_RELOC_LO16:
5243       if (fixP->fx_done)        /* For la rd, imm32.  */
5244         {
5245           newval = md_chars_to_number (buf, INSN_SIZE);
5246           LO = (value) & 0xffff;
5247           newval |= (LO & 0x3fff) << 1; /* 16 bit: imm -> 14 bit in lo, 2 bit in hi.  */
5248           newval |= ((LO >> 14) & 0x3) << 16;
5249           md_number_to_chars (buf, newval, INSN_SIZE);
5250         }
5251       break;
5252     case BFD_RELOC_SCORE_JMP:
5253       {
5254         content = md_chars_to_number (buf, INSN_SIZE);
5255         value = fixP->fx_offset;
5256         content = (content & ~0x3ff7ffe) | ((value << 1) & 0x3ff0000) | (value & 0x7fff);
5257         md_number_to_chars (buf, content, INSN_SIZE);
5258       }
5259       break;
5260     case BFD_RELOC_SCORE_BRANCH:
5261       if ((S_GET_SEGMENT (fixP->fx_addsy) != seg) || (fixP->fx_addsy != NULL && S_IS_EXTERNAL (fixP->fx_addsy)))
5262         value = fixP->fx_offset;
5263       else
5264         fixP->fx_done = 1;
5265
5266       content = md_chars_to_number (buf, INSN_SIZE);
5267       if ((fixP->fx_frag->fr_opcode != 0) && ((content & 0x80008000) != 0x80008000))
5268         {
5269           if ((value & 0x80000000) == 0x80000000)
5270             abs_value = 0xffffffff - value + 1;
5271           if ((abs_value & 0xffffff00) != 0)
5272             {
5273               as_bad_where (fixP->fx_file, fixP->fx_line,
5274                             _(" branch relocation truncate (0x%x) [-2^8 ~ 2^8]"), (unsigned int)value);
5275               return;
5276             }
5277           content = md_chars_to_number (buf, INSN16_SIZE);
5278           content &= 0xff00;
5279           content = (content & 0xff00) | ((value >> 1) & 0xff);
5280           md_number_to_chars (buf, content, INSN16_SIZE);
5281           fixP->fx_r_type = BFD_RELOC_SCORE16_BRANCH;
5282           fixP->fx_size = 2;
5283         }
5284       else
5285         {
5286           if ((value & 0x80000000) == 0x80000000)
5287             abs_value = 0xffffffff - value + 1;
5288           if ((abs_value & 0xfff80000) != 0)
5289             {
5290               as_bad_where (fixP->fx_file, fixP->fx_line,
5291                             _(" branch relocation truncate (0x%x) [-2^19 ~ 2^19]"), (unsigned int)value);
5292               return;
5293             }
5294           content = md_chars_to_number (buf, INSN_SIZE);
5295           content &= 0xfc00fc01;
5296           content = (content & 0xfc00fc01) | (value & 0x3fe) | ((value << 6) & 0x3ff0000);
5297           md_number_to_chars (buf, content, INSN_SIZE);
5298         }
5299       break;
5300     case BFD_RELOC_SCORE16_JMP:
5301       content = md_chars_to_number (buf, INSN16_SIZE);
5302       content &= 0xf001;
5303       value = fixP->fx_offset & 0xfff;
5304       content = (content & 0xfc01) | (value & 0xffe);
5305       md_number_to_chars (buf, content, INSN16_SIZE);
5306       break;
5307     case BFD_RELOC_SCORE16_BRANCH:
5308       content = md_chars_to_number (buf, INSN_SIZE);
5309       if ((fixP->fx_frag->fr_opcode != 0) && ((content & 0x80008000) == 0x80008000))
5310         {
5311           if ((S_GET_SEGMENT (fixP->fx_addsy) != seg) ||
5312               (fixP->fx_addsy != NULL && S_IS_EXTERNAL (fixP->fx_addsy)))
5313             value = fixP->fx_offset;
5314           else
5315             fixP->fx_done = 1;
5316           if ((value & 0x80000000) == 0x80000000)
5317             abs_value = 0xffffffff - value + 1;
5318           if ((abs_value & 0xfff80000) != 0)
5319             {
5320               as_bad_where (fixP->fx_file, fixP->fx_line,
5321                             _(" branch relocation truncate (0x%x) [-2^19 ~ 2^19]"), (unsigned int)value);
5322               return;
5323             }
5324           content = md_chars_to_number (buf, INSN_SIZE);
5325           content = (content & 0xfc00fc01) | (value & 0x3fe) | ((value << 6) & 0x3ff0000);
5326           md_number_to_chars (buf, content, INSN_SIZE);
5327           fixP->fx_r_type = BFD_RELOC_SCORE_BRANCH;
5328           fixP->fx_size = 4;
5329           break;
5330         }
5331       else
5332         {
5333           /* In differnt section.  */
5334           if ((S_GET_SEGMENT (fixP->fx_addsy) != seg) ||
5335               (fixP->fx_addsy != NULL && S_IS_EXTERNAL (fixP->fx_addsy)))
5336             value = fixP->fx_offset;
5337           else
5338             fixP->fx_done = 1;
5339
5340           if ((value & 0x80000000) == 0x80000000)
5341             abs_value = 0xffffffff - value + 1;
5342           if ((abs_value & 0xffffff00) != 0)
5343             {
5344               as_bad_where (fixP->fx_file, fixP->fx_line,
5345                             _(" branch relocation truncate (0x%x)  [-2^8 ~ 2^8]"), (unsigned int)value);
5346               return;
5347             }
5348           content = md_chars_to_number (buf, INSN16_SIZE);
5349           content = (content & 0xff00) | ((value >> 1) & 0xff);
5350           md_number_to_chars (buf, content, INSN16_SIZE);
5351           break;
5352         }
5353     case BFD_RELOC_8:
5354       if (fixP->fx_done || fixP->fx_pcrel)
5355         md_number_to_chars (buf, value, 1);
5356 #ifdef OBJ_ELF
5357       else
5358         {
5359           value = fixP->fx_offset;
5360           md_number_to_chars (buf, value, 1);
5361         }
5362 #endif
5363       break;
5364
5365     case BFD_RELOC_16:
5366       if (fixP->fx_done || fixP->fx_pcrel)
5367         md_number_to_chars (buf, value, 2);
5368 #ifdef OBJ_ELF
5369       else
5370         {
5371           value = fixP->fx_offset;
5372           md_number_to_chars (buf, value, 2);
5373         }
5374 #endif
5375       break;
5376     case BFD_RELOC_RVA:
5377     case BFD_RELOC_32:
5378       if (fixP->fx_done || fixP->fx_pcrel)
5379         md_number_to_chars (buf, value, 4);
5380 #ifdef OBJ_ELF
5381       else
5382         {
5383           value = fixP->fx_offset;
5384           md_number_to_chars (buf, value, 4);
5385         }
5386 #endif
5387       break;
5388     case BFD_RELOC_VTABLE_INHERIT:
5389       fixP->fx_done = 0;
5390       if (fixP->fx_addsy && !S_IS_DEFINED (fixP->fx_addsy) && !S_IS_WEAK (fixP->fx_addsy))
5391         S_SET_WEAK (fixP->fx_addsy);
5392       break;
5393     case BFD_RELOC_VTABLE_ENTRY:
5394       fixP->fx_done = 0;
5395       break;
5396     case BFD_RELOC_SCORE_GPREL15:
5397       content = md_chars_to_number (buf, INSN_SIZE);
5398       if ((fixP->fx_frag->fr_opcode != 0) && ((content & 0xfc1c8000) != 0x94188000))
5399         fixP->fx_r_type = BFD_RELOC_NONE;
5400       fixP->fx_done = 0;
5401       break;
5402     case BFD_RELOC_SCORE_GOT15:
5403     case BFD_RELOC_SCORE_DUMMY_HI16:
5404     case BFD_RELOC_SCORE_GOT_LO16:
5405     case BFD_RELOC_SCORE_CALL15:
5406     case BFD_RELOC_GPREL32:
5407       break;
5408     case BFD_RELOC_NONE:
5409     default:
5410       as_bad_where (fixP->fx_file, fixP->fx_line, _("bad relocation fixup type (%d)"), fixP->fx_r_type);
5411     }
5412 }
5413
5414 /* Translate internal representation of relocation info to BFD target format.  */
5415 arelent **
5416 tc_gen_reloc (asection * section ATTRIBUTE_UNUSED, fixS * fixp)
5417 {
5418   static arelent *retval[MAX_RELOC_EXPANSION + 1];  /* MAX_RELOC_EXPANSION equals 2.  */
5419   arelent *reloc;
5420   bfd_reloc_code_real_type code;
5421   char *type;
5422   fragS *f;
5423   symbolS *s;
5424   expressionS e;
5425
5426   reloc = retval[0] = xmalloc (sizeof (arelent));
5427   retval[1] = NULL;
5428
5429   reloc->sym_ptr_ptr = xmalloc (sizeof (asymbol *));
5430   *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
5431   reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
5432   reloc->addend = fixp->fx_offset;
5433
5434   /* If this is a variant frag, we may need to adjust the existing
5435      reloc and generate a new one.  */
5436   if (fixp->fx_frag->fr_opcode != NULL && (fixp->fx_r_type == BFD_RELOC_SCORE_GPREL15))
5437     {
5438       /* Update instruction imm bit.  */
5439       offsetT newval;
5440       unsigned short off;
5441       char *buf;
5442
5443       buf = fixp->fx_frag->fr_literal + fixp->fx_frag->insn_addr;
5444       newval = md_chars_to_number (buf, INSN_SIZE);
5445       off = fixp->fx_offset >> 16;
5446       newval |= (off & 0x3fff) << 1;
5447       newval |= ((off >> 14) & 0x3) << 16;
5448       md_number_to_chars (buf, newval, INSN_SIZE);
5449
5450       buf += INSN_SIZE;
5451       newval = md_chars_to_number (buf, INSN_SIZE);
5452       off = fixp->fx_offset & 0xffff;
5453       newval |= ((off & 0x3fff) << 1);
5454       newval |= (((off >> 14) & 0x3) << 16);
5455       md_number_to_chars (buf, newval, INSN_SIZE);
5456
5457       retval[1] = xmalloc (sizeof (arelent));
5458       retval[2] = NULL;
5459       retval[1]->sym_ptr_ptr = xmalloc (sizeof (asymbol *));
5460       *retval[1]->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
5461       retval[1]->address = (reloc->address + RELAX_RELOC2 (fixp->fx_frag->fr_subtype));
5462
5463       f = fixp->fx_frag;
5464       s = f->fr_symbol;
5465       e = s->sy_value;
5466
5467       retval[1]->addend = 0;
5468       retval[1]->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_LO16);
5469       assert (retval[1]->howto != NULL);
5470
5471       fixp->fx_r_type = BFD_RELOC_HI16_S;
5472     }
5473
5474   code = fixp->fx_r_type;
5475   switch (fixp->fx_r_type)
5476     {
5477     case BFD_RELOC_32:
5478       if (fixp->fx_pcrel)
5479         {
5480           code = BFD_RELOC_32_PCREL;
5481           break;
5482         }
5483     case BFD_RELOC_HI16_S:
5484     case BFD_RELOC_LO16:
5485     case BFD_RELOC_SCORE_JMP:
5486     case BFD_RELOC_SCORE_BRANCH:
5487     case BFD_RELOC_SCORE16_JMP:
5488     case BFD_RELOC_SCORE16_BRANCH:
5489     case BFD_RELOC_VTABLE_ENTRY:
5490     case BFD_RELOC_VTABLE_INHERIT:
5491     case BFD_RELOC_SCORE_GPREL15:
5492     case BFD_RELOC_SCORE_GOT15:
5493     case BFD_RELOC_SCORE_DUMMY_HI16:
5494     case BFD_RELOC_SCORE_GOT_LO16:
5495     case BFD_RELOC_SCORE_CALL15:
5496     case BFD_RELOC_GPREL32:
5497     case BFD_RELOC_NONE:
5498       code = fixp->fx_r_type;
5499       break;
5500     default:
5501       type = _("<unknown>");
5502       as_bad_where (fixp->fx_file, fixp->fx_line,
5503                     _("cannot represent %s relocation in this object file format"), type);
5504       return NULL;
5505     }
5506
5507   reloc->howto = bfd_reloc_type_lookup (stdoutput, code);
5508   if (reloc->howto == NULL)
5509     {
5510       as_bad_where (fixp->fx_file, fixp->fx_line,
5511                     _("cannot represent %s relocation in this object file format1"),
5512                     bfd_get_reloc_code_name (code));
5513       return NULL;
5514     }
5515   /* HACK: Since arm ELF uses Rel instead of Rela, encode the
5516      vtable entry to be used in the relocation's section offset.  */
5517   if (fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
5518     reloc->address = fixp->fx_offset;
5519
5520   return retval;
5521 }
5522
5523 void
5524 score_elf_final_processing (void)
5525 {
5526   if (fix_data_dependency == 1)
5527     {
5528       elf_elfheader (stdoutput)->e_flags |= EF_SCORE_FIXDEP;
5529     }
5530   if (score_pic == PIC)
5531     {
5532       elf_elfheader (stdoutput)->e_flags |= EF_SCORE_PIC;
5533     }
5534 }
5535
5536 static void
5537 parse_pce_inst (char *insnstr)
5538 {
5539   char c;
5540   char *p;
5541   char first[MAX_LITERAL_POOL_SIZE];
5542   char second[MAX_LITERAL_POOL_SIZE];
5543   struct score_it pec_part_1;
5544
5545   /* Get first part string of PCE.  */
5546   p = strstr (insnstr, "||");
5547   c = *p;
5548   *p = '\0';
5549   sprintf (first, "%s", insnstr);
5550
5551   /* Get second part string of PCE.  */
5552   *p = c;
5553   p += 2;
5554   sprintf (second, "%s", p);
5555
5556   parse_16_32_inst (first, FALSE);
5557   if (inst.error)
5558     return;
5559
5560   memcpy (&pec_part_1, &inst, sizeof (inst));
5561
5562   parse_16_32_inst (second, FALSE);
5563   if (inst.error)
5564     return;
5565
5566   if (   ((pec_part_1.size == INSN_SIZE) && (inst.size == INSN_SIZE))
5567       || ((pec_part_1.size == INSN_SIZE) && (inst.size == INSN16_SIZE))
5568       || ((pec_part_1.size == INSN16_SIZE) && (inst.size == INSN_SIZE)))
5569     {
5570       inst.error = _("pce instruction error (16 bit || 16 bit)'");
5571       sprintf (inst.str, insnstr);
5572       return;
5573     }
5574
5575   if (!inst.error)
5576     gen_insn_frag (&pec_part_1, &inst);
5577 }
5578
5579 void
5580 md_assemble (char *str)
5581 {
5582   know (str);
5583   know (strlen (str) < MAX_LITERAL_POOL_SIZE);
5584
5585   memset (&inst, '\0', sizeof (inst));
5586   if (INSN_IS_PCE_P (str))
5587     parse_pce_inst (str);
5588   else
5589     parse_16_32_inst (str, TRUE);
5590
5591   if (inst.error)
5592     as_bad (_("%s -- `%s'"), inst.error, inst.str);
5593 }
5594
5595 /* We handle all bad expressions here, so that we can report the faulty
5596    instruction in the error message.  */
5597 void
5598 md_operand (expressionS * expr)
5599 {
5600   if (in_my_get_expression)
5601     {
5602       expr->X_op = O_illegal;
5603       if (inst.error == NULL)
5604         {
5605           inst.error = _("bad expression");
5606         }
5607     }
5608 }
5609
5610 const char *md_shortopts = "nO::g::G:";
5611
5612 #ifdef SCORE_BI_ENDIAN
5613 #define OPTION_EB             (OPTION_MD_BASE + 0)
5614 #define OPTION_EL             (OPTION_MD_BASE + 1)
5615 #else
5616 #if TARGET_BYTES_BIG_ENDIAN
5617 #define OPTION_EB             (OPTION_MD_BASE + 0)
5618 #else
5619 #define OPTION_EL             (OPTION_MD_BASE + 1)
5620 #endif
5621 #endif
5622 #define OPTION_FIXDD          (OPTION_MD_BASE + 2)
5623 #define OPTION_NWARN          (OPTION_MD_BASE + 3)
5624 #define OPTION_SCORE5         (OPTION_MD_BASE + 4)
5625 #define OPTION_SCORE5U        (OPTION_MD_BASE + 5)
5626 #define OPTION_SCORE7         (OPTION_MD_BASE + 6)
5627 #define OPTION_R1             (OPTION_MD_BASE + 7)
5628 #define OPTION_O0             (OPTION_MD_BASE + 8)
5629 #define OPTION_SCORE_VERSION  (OPTION_MD_BASE + 9)
5630 #define OPTION_PIC            (OPTION_MD_BASE + 10)
5631
5632 struct option md_longopts[] =
5633 {
5634 #ifdef OPTION_EB
5635   {"EB"     , no_argument, NULL, OPTION_EB},
5636 #endif
5637 #ifdef OPTION_EL
5638   {"EL"     , no_argument, NULL, OPTION_EL},
5639 #endif
5640   {"FIXDD"  , no_argument, NULL, OPTION_FIXDD},
5641   {"NWARN"  , no_argument, NULL, OPTION_NWARN},
5642   {"SCORE5" , no_argument, NULL, OPTION_SCORE5},
5643   {"SCORE5U", no_argument, NULL, OPTION_SCORE5U},
5644   {"SCORE7" , no_argument, NULL, OPTION_SCORE7},
5645   {"USE_R1" , no_argument, NULL, OPTION_R1},
5646   {"O0"     , no_argument, NULL, OPTION_O0},
5647   {"V"      , no_argument, NULL, OPTION_SCORE_VERSION},
5648   {"KPIC"   , no_argument, NULL, OPTION_PIC},
5649   {NULL     , no_argument, NULL, 0}
5650 };
5651
5652 size_t md_longopts_size = sizeof (md_longopts);
5653
5654 int
5655 md_parse_option (int c, char *arg)
5656 {
5657   switch (c)
5658     {
5659 #ifdef OPTION_EB
5660     case OPTION_EB:
5661       target_big_endian = 1;
5662       break;
5663 #endif
5664 #ifdef OPTION_EL
5665     case OPTION_EL:
5666       target_big_endian = 0;
5667       break;
5668 #endif
5669     case OPTION_FIXDD:
5670       fix_data_dependency = 1;
5671       break;
5672     case OPTION_NWARN:
5673       warn_fix_data_dependency = 0;
5674       break;
5675     case OPTION_SCORE5:
5676       score7 = 0;
5677       university_version = 0;
5678       vector_size = SCORE5_PIPELINE;
5679       break;
5680     case OPTION_SCORE5U:
5681       score7 = 0;
5682       university_version = 1;
5683       vector_size = SCORE5_PIPELINE;
5684       break;
5685     case OPTION_SCORE7:
5686       score7 = 1;
5687       university_version = 0;
5688       vector_size = SCORE7_PIPELINE;
5689       break;
5690     case OPTION_R1:
5691       nor1 = 0;
5692       break;
5693     case 'G':
5694       g_switch_value = atoi (arg);
5695       break;
5696     case OPTION_O0:
5697       g_opt = 0;
5698       break;
5699     case OPTION_SCORE_VERSION:
5700       printf (_("Sunplus-v2-0-0-20060510\n"));
5701       break;
5702     case OPTION_PIC:
5703       score_pic = PIC;
5704       g_switch_value = 0;    /* Must set -G num as 0 to generate PIC code.  */
5705       break;
5706     default:
5707       /* as_bad (_("unrecognized option `-%c%s'"), c, arg ? arg : "");  */
5708       return 0;
5709     }
5710   return 1;
5711 }
5712
5713 void
5714 md_show_usage (FILE * fp)
5715 {
5716   fprintf (fp, _(" Score-specific assembler options:\n"));
5717 #ifdef OPTION_EB
5718   fprintf (fp, _("\
5719         -EB\t\tassemble code for a big-endian cpu\n"));
5720 #endif
5721
5722 #ifdef OPTION_EL
5723   fprintf (fp, _("\
5724         -EL\t\tassemble code for a little-endian cpu\n"));
5725 #endif
5726
5727   fprintf (fp, _("\
5728         -FIXDD\t\tassemble code for fix data dependency\n"));
5729   fprintf (fp, _("\
5730         -NWARN\t\tassemble code for no warning message for fix data dependency\n"));
5731   fprintf (fp, _("\
5732         -SCORE5\t\tassemble code for target is SCORE5\n"));
5733   fprintf (fp, _("\
5734         -SCORE5U\tassemble code for target is SCORE5U\n"));
5735   fprintf (fp, _("\
5736         -SCORE7\t\tassemble code for target is SCORE7, this is default setting\n"));
5737   fprintf (fp, _("\
5738         -USE_R1\t\tassemble code for no warning message when using temp register r1\n"));
5739   fprintf (fp, _("\
5740         -KPIC\t\tassemble code for PIC\n"));
5741   fprintf (fp, _("\
5742         -O0\t\tassembler will not perform any optimizations\n"));
5743   fprintf (fp, _("\
5744         -G gpnum\tassemble code for setting gpsize and default is 8 byte\n"));
5745   fprintf (fp, _("\
5746         -V \t\tSunplus release version \n"));
5747 }
5748
5749
5750 /* Pesudo handling functions.  */
5751
5752 /* If we change section we must dump the literal pool first.  */
5753 static void
5754 s_score_bss (int ignore ATTRIBUTE_UNUSED)
5755 {
5756   subseg_set (bss_section, (subsegT) get_absolute_expression ());
5757   demand_empty_rest_of_line ();
5758 }
5759
5760 static void
5761 s_score_text (int ignore)
5762 {
5763   obj_elf_text (ignore);
5764   record_alignment (now_seg, 2);
5765 }
5766
5767 static void
5768 score_s_section (int ignore)
5769 {
5770   obj_elf_section (ignore);
5771   if ((bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE) != 0)
5772     record_alignment (now_seg, 2);
5773
5774 }
5775
5776 static void
5777 s_change_sec (int sec)
5778 {
5779   segT seg;
5780
5781 #ifdef OBJ_ELF
5782   /* The ELF backend needs to know that we are changing sections, so
5783      that .previous works correctly.  We could do something like check
5784      for an obj_section_change_hook macro, but that might be confusing
5785      as it would not be appropriate to use it in the section changing
5786      functions in read.c, since obj-elf.c intercepts those.  FIXME:
5787      This should be cleaner, somehow.  */
5788   obj_elf_section_change_hook ();
5789 #endif
5790   switch (sec)
5791     {
5792     case 'r':
5793       seg = subseg_new (RDATA_SECTION_NAME, (subsegT) get_absolute_expression ());
5794       bfd_set_section_flags (stdoutput, seg, (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_RELOC | SEC_DATA));
5795       if (strcmp (TARGET_OS, "elf") != 0)
5796         record_alignment (seg, 4);
5797       demand_empty_rest_of_line ();
5798       break;
5799     case 's':
5800       seg = subseg_new (".sdata", (subsegT) get_absolute_expression ());
5801       bfd_set_section_flags (stdoutput, seg, SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_DATA);
5802       if (strcmp (TARGET_OS, "elf") != 0)
5803         record_alignment (seg, 4);
5804       demand_empty_rest_of_line ();
5805       break;
5806     }
5807 }
5808
5809 static void
5810 s_score_mask (int reg_type ATTRIBUTE_UNUSED)
5811 {
5812   long mask, off;
5813
5814   if (cur_proc_ptr == (procS *) NULL)
5815     {
5816       as_warn (_(".mask outside of .ent"));
5817       demand_empty_rest_of_line ();
5818       return;
5819     }
5820   if (get_absolute_expression_and_terminator (&mask) != ',')
5821     {
5822       as_warn (_("Bad .mask directive"));
5823       --input_line_pointer;
5824       demand_empty_rest_of_line ();
5825       return;
5826     }
5827   off = get_absolute_expression ();
5828   cur_proc_ptr->reg_mask = mask;
5829   cur_proc_ptr->reg_offset = off;
5830   demand_empty_rest_of_line ();
5831 }
5832
5833 static symbolS *
5834 get_symbol (void)
5835 {
5836   int c;
5837   char *name;
5838   symbolS *p;
5839
5840   name = input_line_pointer;
5841   c = get_symbol_end ();
5842   p = (symbolS *) symbol_find_or_make (name);
5843   *input_line_pointer = c;
5844   return p;
5845 }
5846
5847 static long
5848 get_number (void)
5849 {
5850   int negative = 0;
5851   long val = 0;
5852
5853   if (*input_line_pointer == '-')
5854     {
5855       ++input_line_pointer;
5856       negative = 1;
5857     }
5858   if (!ISDIGIT (*input_line_pointer))
5859     as_bad (_("expected simple number"));
5860   if (input_line_pointer[0] == '0')
5861     {
5862       if (input_line_pointer[1] == 'x')
5863         {
5864           input_line_pointer += 2;
5865           while (ISXDIGIT (*input_line_pointer))
5866             {
5867               val <<= 4;
5868               val |= hex_value (*input_line_pointer++);
5869             }
5870           return negative ? -val : val;
5871         }
5872       else
5873         {
5874           ++input_line_pointer;
5875           while (ISDIGIT (*input_line_pointer))
5876             {
5877               val <<= 3;
5878               val |= *input_line_pointer++ - '0';
5879             }
5880           return negative ? -val : val;
5881         }
5882     }
5883   if (!ISDIGIT (*input_line_pointer))
5884     {
5885       printf (_(" *input_line_pointer == '%c' 0x%02x\n"), *input_line_pointer, *input_line_pointer);
5886       as_warn (_("invalid number"));
5887       return -1;
5888     }
5889   while (ISDIGIT (*input_line_pointer))
5890     {
5891       val *= 10;
5892       val += *input_line_pointer++ - '0';
5893     }
5894   return negative ? -val : val;
5895 }
5896
5897 /* The .aent and .ent directives.  */
5898
5899 static void
5900 s_score_ent (int aent)
5901 {
5902   symbolS *symbolP;
5903   int maybe_text;
5904
5905   symbolP = get_symbol ();
5906   if (*input_line_pointer == ',')
5907     ++input_line_pointer;
5908   SKIP_WHITESPACE ();
5909   if (ISDIGIT (*input_line_pointer) || *input_line_pointer == '-')
5910     get_number ();
5911
5912 #ifdef BFD_ASSEMBLER
5913   if ((bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE) != 0)
5914     maybe_text = 1;
5915   else
5916     maybe_text = 0;
5917 #else
5918   if (now_seg != data_section && now_seg != bss_section)
5919     maybe_text = 1;
5920   else
5921     maybe_text = 0;
5922 #endif
5923   if (!maybe_text)
5924     as_warn (_(".ent or .aent not in text section."));
5925   if (!aent && cur_proc_ptr)
5926     as_warn (_("missing .end"));
5927   if (!aent)
5928     {
5929       cur_proc_ptr = &cur_proc;
5930       cur_proc_ptr->reg_mask = 0xdeadbeaf;
5931       cur_proc_ptr->reg_offset = 0xdeadbeaf;
5932       cur_proc_ptr->fpreg_mask = 0xdeafbeaf;
5933       cur_proc_ptr->leaf = 0xdeafbeaf;
5934       cur_proc_ptr->frame_offset = 0xdeafbeaf;
5935       cur_proc_ptr->frame_reg = 0xdeafbeaf;
5936       cur_proc_ptr->pc_reg = 0xdeafbeaf;
5937       cur_proc_ptr->isym = symbolP;
5938       symbol_get_bfdsym (symbolP)->flags |= BSF_FUNCTION;
5939       ++numprocs;
5940       if (debug_type == DEBUG_STABS)
5941         stabs_generate_asm_func (S_GET_NAME (symbolP), S_GET_NAME (symbolP));
5942     }
5943   demand_empty_rest_of_line ();
5944 }
5945
5946 static void
5947 s_score_frame (int ignore ATTRIBUTE_UNUSED)
5948 {
5949   char *backupstr;
5950   char str[30];
5951   long val;
5952   int i = 0;
5953
5954   backupstr = input_line_pointer;
5955
5956 #ifdef OBJ_ELF
5957   if (cur_proc_ptr == (procS *) NULL)
5958     {
5959       as_warn (_(".frame outside of .ent"));
5960       demand_empty_rest_of_line ();
5961       return;
5962     }
5963   cur_proc_ptr->frame_reg = reg_required_here ((&backupstr), 0, REG_TYPE_SCORE);
5964   SKIP_WHITESPACE ();
5965   skip_past_comma (&backupstr);
5966   while (*backupstr != ',')
5967     {
5968       str[i] = *backupstr;
5969       i++;
5970       backupstr++;
5971     }
5972   str[i] = '\0';
5973   val = atoi (str);
5974
5975   SKIP_WHITESPACE ();
5976   skip_past_comma (&backupstr);
5977   cur_proc_ptr->frame_offset = val;
5978   cur_proc_ptr->pc_reg = reg_required_here ((&backupstr), 0, REG_TYPE_SCORE);
5979
5980   SKIP_WHITESPACE ();
5981   skip_past_comma (&backupstr);
5982   i = 0;
5983   while (*backupstr != '\n')
5984     {
5985       str[i] = *backupstr;
5986       i++;
5987       backupstr++;
5988     }
5989   str[i] = '\0';
5990   val = atoi (str);
5991   cur_proc_ptr->leaf = val;
5992   SKIP_WHITESPACE ();
5993   skip_past_comma (&backupstr);
5994
5995 #endif /* OBJ_ELF */
5996   while (input_line_pointer != backupstr)
5997     input_line_pointer++;
5998 }
5999
6000 /* The .end directive.  */
6001 static void
6002 s_score_end (int x ATTRIBUTE_UNUSED)
6003 {
6004   symbolS *p;
6005   int maybe_text;
6006
6007   /* Generate a .pdr section.  */
6008   segT saved_seg = now_seg;
6009   subsegT saved_subseg = now_subseg;
6010   valueT dot;
6011   expressionS exp;
6012   char *fragp;
6013
6014   if (!is_end_of_line[(unsigned char)*input_line_pointer])
6015     {
6016       p = get_symbol ();
6017       demand_empty_rest_of_line ();
6018     }
6019   else
6020     p = NULL;
6021
6022 #ifdef BFD_ASSEMBLER
6023   if ((bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE) != 0)
6024     maybe_text = 1;
6025   else
6026     maybe_text = 0;
6027 #else
6028   if (now_seg != data_section && now_seg != bss_section)
6029     maybe_text = 1;
6030   else
6031     maybe_text = 0;
6032 #endif
6033
6034   if (!maybe_text)
6035     as_warn (_(".end not in text section"));
6036   if (!cur_proc_ptr)
6037     {
6038       as_warn (_(".end directive without a preceding .ent directive."));
6039       demand_empty_rest_of_line ();
6040       return;
6041     }
6042   if (p != NULL)
6043     {
6044       assert (S_GET_NAME (p));
6045       if (strcmp (S_GET_NAME (p), S_GET_NAME (cur_proc_ptr->isym)))
6046         as_warn (_(".end symbol does not match .ent symbol."));
6047       if (debug_type == DEBUG_STABS)
6048         stabs_generate_asm_endfunc (S_GET_NAME (p), S_GET_NAME (p));
6049     }
6050   else
6051     as_warn (_(".end directive missing or unknown symbol"));
6052
6053   if ((cur_proc_ptr->reg_mask == 0xdeadbeaf) ||
6054       (cur_proc_ptr->reg_offset == 0xdeadbeaf) ||
6055       (cur_proc_ptr->leaf == 0xdeafbeaf) ||
6056       (cur_proc_ptr->frame_offset == 0xdeafbeaf) ||
6057       (cur_proc_ptr->frame_reg == 0xdeafbeaf) || (cur_proc_ptr->pc_reg == 0xdeafbeaf));
6058
6059   else
6060     {
6061       dot = frag_now_fix ();
6062       assert (pdr_seg);
6063       subseg_set (pdr_seg, 0);
6064       /* Write the symbol.  */
6065       exp.X_op = O_symbol;
6066       exp.X_add_symbol = p;
6067       exp.X_add_number = 0;
6068       emit_expr (&exp, 4);
6069       fragp = frag_more (7 * 4);
6070       md_number_to_chars (fragp, (valueT) cur_proc_ptr->reg_mask, 4);
6071       md_number_to_chars (fragp + 4, (valueT) cur_proc_ptr->reg_offset, 4);
6072       md_number_to_chars (fragp + 8, (valueT) cur_proc_ptr->fpreg_mask, 4);
6073       md_number_to_chars (fragp + 12, (valueT) cur_proc_ptr->leaf, 4);
6074       md_number_to_chars (fragp + 16, (valueT) cur_proc_ptr->frame_offset, 4);
6075       md_number_to_chars (fragp + 20, (valueT) cur_proc_ptr->frame_reg, 4);
6076       md_number_to_chars (fragp + 24, (valueT) cur_proc_ptr->pc_reg, 4);
6077       subseg_set (saved_seg, saved_subseg);
6078
6079     }
6080   cur_proc_ptr = NULL;
6081 }
6082
6083 /* Handle the .set pseudo-op.  */
6084 static void
6085 s_score_set (int x ATTRIBUTE_UNUSED)
6086 {
6087   int i = 0;
6088   char name[MAX_LITERAL_POOL_SIZE];
6089   char * orig_ilp = input_line_pointer;
6090
6091   while (!is_end_of_line[(unsigned char)*input_line_pointer])
6092     {
6093       name[i] = (char) * input_line_pointer;
6094       i++;
6095       ++input_line_pointer;
6096     }
6097
6098   name[i] = '\0';
6099
6100   if (strcmp (name, "nwarn") == 0)
6101     {
6102       warn_fix_data_dependency = 0;
6103     }
6104   else if (strcmp (name, "fixdd") == 0)
6105     {
6106       fix_data_dependency = 1;
6107     }
6108   else if (strcmp (name, "nofixdd") == 0)
6109     {
6110       fix_data_dependency = 0;
6111     }
6112   else if (strcmp (name, "r1") == 0)
6113     {
6114       nor1 = 0;
6115     }
6116   else if (strcmp (name, "nor1") == 0)
6117     {
6118       nor1 = 1;
6119     }
6120   else if (strcmp (name, "optimize") == 0)
6121     {
6122       g_opt = 1;
6123     }
6124   else if (strcmp (name, "volatile") == 0)
6125     {
6126       g_opt = 0;
6127     }
6128   else if (strcmp (name, "pic") == 0)
6129     {
6130       score_pic = PIC;
6131     }
6132   else
6133     {
6134       input_line_pointer = orig_ilp;
6135       s_set (0);
6136     }
6137 }
6138
6139 /* Handle the .cpload pseudo-op.  This is used when generating PIC code.  It sets the
6140    $gp register for the function based on the function address, which is in the register
6141    named in the argument. This uses a relocation against GP_DISP_LABEL, which is handled
6142    specially by the linker.  The result is:
6143    ldis gp, %hi(GP_DISP_LABEL)
6144    ori  gp, %low(GP_DISP_LABEL)
6145    add  gp, gp, .cpload argument
6146    The .cpload argument is normally r29.  */
6147
6148 static void
6149 s_score_cpload (int ignore ATTRIBUTE_UNUSED)
6150 {
6151   int reg;
6152   char insn_str[MAX_LITERAL_POOL_SIZE];
6153
6154   /* If we are not generating PIC code, .cpload is ignored.  */
6155   if (score_pic == NO_PIC)
6156     {
6157       s_ignore (0);
6158       return;
6159     }
6160
6161   if ((reg = reg_required_here (&input_line_pointer, -1, REG_TYPE_SCORE)) == (int) FAIL)
6162     return;
6163
6164   demand_empty_rest_of_line ();
6165
6166   sprintf (insn_str, "ld_i32hi r%d, %s", GP, GP_DISP_LABEL);
6167   if (append_insn (insn_str, TRUE) == (int) FAIL)
6168     return;
6169
6170   sprintf (insn_str, "ld_i32lo r%d, %s", GP, GP_DISP_LABEL);
6171   if (append_insn (insn_str, TRUE) == (int) FAIL)
6172     return;
6173
6174   sprintf (insn_str, "add r%d, r%d, r%d", GP, GP, reg);
6175   if (append_insn (insn_str, TRUE) == (int) FAIL)
6176     return;
6177 }
6178
6179 /* Handle the .cprestore pseudo-op.  This stores $gp into a given
6180    offset from $sp.  The offset is remembered, and after making a PIC
6181    call $gp is restored from that location.  */
6182
6183 static void
6184 s_score_cprestore (int ignore ATTRIBUTE_UNUSED)
6185 {
6186   int reg;
6187   int cprestore_offset;
6188   char insn_str[MAX_LITERAL_POOL_SIZE];
6189
6190   /* If we are not generating PIC code, .cprestore is ignored.  */
6191   if (score_pic == NO_PIC)
6192     {
6193       s_ignore (0);
6194       return;
6195     }
6196
6197   if ((reg = reg_required_here (&input_line_pointer, -1, REG_TYPE_SCORE)) == (int) FAIL
6198       || skip_past_comma (&input_line_pointer) == (int) FAIL)
6199     {
6200       return;
6201     }
6202
6203   cprestore_offset = get_absolute_expression ();
6204
6205   if (cprestore_offset <= 0x3fff)
6206     {
6207       sprintf (insn_str, "sw r%d, [r%d, %d]", GP, reg, cprestore_offset);
6208       if (append_insn (insn_str, TRUE) == (int) FAIL)
6209         return;
6210     }
6211   else
6212     {
6213       int r1_bak;
6214
6215       r1_bak = nor1;
6216       nor1 = 0;
6217
6218       sprintf (insn_str, "li r1, %d", cprestore_offset);
6219       if (append_insn (insn_str, TRUE) == (int) FAIL)
6220         return;
6221
6222       sprintf (insn_str, "add r1, r1, r%d", reg);
6223       if (append_insn (insn_str, TRUE) == (int) FAIL)
6224         return;
6225
6226       sprintf (insn_str, "sw r%d, [r1]", GP);
6227       if (append_insn (insn_str, TRUE) == (int) FAIL)
6228         return;
6229
6230       nor1 = r1_bak;
6231     }
6232
6233   demand_empty_rest_of_line ();
6234 }
6235
6236 /* Handle the .gpword pseudo-op.  This is used when generating PIC
6237    code.  It generates a 32 bit GP relative reloc.  */
6238 static void
6239 s_score_gpword (int ignore ATTRIBUTE_UNUSED)
6240 {
6241   expressionS ex;
6242   char *p;
6243
6244   /* When not generating PIC code, this is treated as .word.  */
6245   if (score_pic == NO_PIC)
6246     {
6247       cons (4);
6248       return;
6249     }
6250   expression (&ex);
6251   if (ex.X_op != O_symbol || ex.X_add_number != 0)
6252     {
6253       as_bad (_("Unsupported use of .gpword"));
6254       ignore_rest_of_line ();
6255     }
6256   p = frag_more (4);
6257   md_number_to_chars (p, (valueT) 0, 4);
6258   fix_new_exp (frag_now, p - frag_now->fr_literal, 4, &ex, FALSE, BFD_RELOC_GPREL32);
6259   demand_empty_rest_of_line ();
6260 }
6261
6262 /* Handle the .cpadd pseudo-op.  This is used when dealing with switch
6263    tables in PIC code.  */
6264
6265 static void
6266 s_score_cpadd (int ignore ATTRIBUTE_UNUSED)
6267 {
6268   int reg;
6269   char insn_str[MAX_LITERAL_POOL_SIZE];
6270
6271   /* If we are not generating PIC code, .cpload is ignored.  */
6272   if (score_pic == NO_PIC)
6273     {
6274       s_ignore (0);
6275       return;
6276     }
6277
6278   if ((reg = reg_required_here (&input_line_pointer, -1, REG_TYPE_SCORE)) == (int) FAIL)
6279     {
6280       return;
6281     }
6282   demand_empty_rest_of_line ();
6283
6284   /* Add $gp to the register named as an argument.  */
6285   sprintf (insn_str, "add r%d, r%d, r%d", reg, reg, GP);
6286   if (append_insn (insn_str, TRUE) == (int) FAIL)
6287     return;
6288 }
6289
6290 #ifndef TC_IMPLICIT_LCOMM_ALIGNMENT
6291 #define TC_IMPLICIT_LCOMM_ALIGNMENT(SIZE, P2VAR)                \
6292     do                                                          \
6293     {                                                           \
6294     if ((SIZE) >= 8)                                            \
6295     (P2VAR) = 3;                                                \
6296     else if ((SIZE) >= 4)                                       \
6297     (P2VAR) = 2;                                                \
6298     else if ((SIZE) >= 2)                                       \
6299     (P2VAR) = 1;                                                \
6300     else                                                        \
6301     (P2VAR) = 0;                                                \
6302     }                                                           \
6303   while (0)
6304 #endif
6305
6306 static void
6307 s_score_lcomm (int bytes_p)
6308 {
6309   char *name;
6310   char c;
6311   char *p;
6312   int temp;
6313   symbolS *symbolP;
6314   segT current_seg = now_seg;
6315   subsegT current_subseg = now_subseg;
6316   const int max_alignment = 15;
6317   int align = 0;
6318   segT bss_seg = bss_section;
6319   int needs_align = 0;
6320
6321   name = input_line_pointer;
6322   c = get_symbol_end ();
6323   p = input_line_pointer;
6324   *p = c;
6325
6326   if (name == p)
6327     {
6328       as_bad (_("expected symbol name"));
6329       discard_rest_of_line ();
6330       return;
6331     }
6332
6333   SKIP_WHITESPACE ();
6334
6335   /* Accept an optional comma after the name.  The comma used to be
6336      required, but Irix 5 cc does not generate it.  */
6337   if (*input_line_pointer == ',')
6338     {
6339       ++input_line_pointer;
6340       SKIP_WHITESPACE ();
6341     }
6342
6343   if (is_end_of_line[(unsigned char)*input_line_pointer])
6344     {
6345       as_bad (_("missing size expression"));
6346       return;
6347     }
6348
6349   if ((temp = get_absolute_expression ()) < 0)
6350     {
6351       as_warn (_("BSS length (%d) < 0 ignored"), temp);
6352       ignore_rest_of_line ();
6353       return;
6354     }
6355
6356 #if defined (TC_SCORE)
6357   if (OUTPUT_FLAVOR == bfd_target_ecoff_flavour || OUTPUT_FLAVOR == bfd_target_elf_flavour)
6358     {
6359       /* For Score and Alpha ECOFF or ELF, small objects are put in .sbss.  */
6360       if ((unsigned)temp <= bfd_get_gp_size (stdoutput))
6361         {
6362           bss_seg = subseg_new (".sbss", 1);
6363           seg_info (bss_seg)->bss = 1;
6364 #ifdef BFD_ASSEMBLER
6365           if (!bfd_set_section_flags (stdoutput, bss_seg, SEC_ALLOC))
6366             as_warn (_("error setting flags for \".sbss\": %s"), bfd_errmsg (bfd_get_error ()));
6367 #endif
6368         }
6369     }
6370 #endif
6371
6372   SKIP_WHITESPACE ();
6373   if (*input_line_pointer == ',')
6374     {
6375       ++input_line_pointer;
6376       SKIP_WHITESPACE ();
6377
6378       if (is_end_of_line[(unsigned char)*input_line_pointer])
6379         {
6380           as_bad (_("missing alignment"));
6381           return;
6382         }
6383       else
6384         {
6385           align = get_absolute_expression ();
6386           needs_align = 1;
6387         }
6388     }
6389
6390   if (!needs_align)
6391     {
6392       TC_IMPLICIT_LCOMM_ALIGNMENT (temp, align);
6393
6394       /* Still zero unless TC_IMPLICIT_LCOMM_ALIGNMENT set it.  */
6395       if (align)
6396         record_alignment (bss_seg, align);
6397     }
6398
6399   if (needs_align)
6400     {
6401       if (bytes_p)
6402         {
6403           /* Convert to a power of 2.  */
6404           if (align != 0)
6405             {
6406               unsigned int i;
6407
6408               for (i = 0; align != 0; align >>= 1, ++i)
6409                 ;
6410               align = i - 1;
6411             }
6412         }
6413
6414       if (align > max_alignment)
6415         {
6416           align = max_alignment;
6417           as_warn (_("alignment too large; %d assumed"), align);
6418         }
6419       else if (align < 0)
6420         {
6421           align = 0;
6422           as_warn (_("alignment negative; 0 assumed"));
6423         }
6424
6425       record_alignment (bss_seg, align);
6426     }
6427   else
6428     {
6429       /* Assume some objects may require alignment on some systems.  */
6430 #if defined (TC_ALPHA) && ! defined (VMS)
6431       if (temp > 1)
6432         {
6433           align = ffs (temp) - 1;
6434           if (temp % (1 << align))
6435             abort ();
6436         }
6437 #endif
6438     }
6439
6440   *p = 0;
6441   symbolP = symbol_find_or_make (name);
6442   *p = c;
6443
6444   if (
6445 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT) \
6446      || defined (OBJ_BOUT) || defined (OBJ_MAYBE_BOUT))
6447 #ifdef BFD_ASSEMBLER
6448        (OUTPUT_FLAVOR != bfd_target_aout_flavour
6449         || (S_GET_OTHER (symbolP) == 0 && S_GET_DESC (symbolP) == 0)) &&
6450 #else
6451        (S_GET_OTHER (symbolP) == 0 && S_GET_DESC (symbolP) == 0) &&
6452 #endif
6453 #endif
6454        (S_GET_SEGMENT (symbolP) == bss_seg || (!S_IS_DEFINED (symbolP) && S_GET_VALUE (symbolP) == 0)))
6455     {
6456       char *pfrag;
6457
6458       subseg_set (bss_seg, 1);
6459
6460       if (align)
6461         frag_align (align, 0, 0);
6462
6463       /* Detach from old frag.  */
6464       if (S_GET_SEGMENT (symbolP) == bss_seg)
6465         symbol_get_frag (symbolP)->fr_symbol = NULL;
6466
6467       symbol_set_frag (symbolP, frag_now);
6468       pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP, (offsetT) temp, NULL);
6469       *pfrag = 0;
6470
6471
6472       S_SET_SEGMENT (symbolP, bss_seg);
6473
6474 #ifdef OBJ_COFF
6475       /* The symbol may already have been created with a preceding
6476          ".globl" directive -- be careful not to step on storage class
6477          in that case.  Otherwise, set it to static.  */
6478       if (S_GET_STORAGE_CLASS (symbolP) != C_EXT)
6479         {
6480           S_SET_STORAGE_CLASS (symbolP, C_STAT);
6481         }
6482 #endif /* OBJ_COFF */
6483
6484 #ifdef S_SET_SIZE
6485       S_SET_SIZE (symbolP, temp);
6486 #endif
6487     }
6488   else
6489     as_bad (_("symbol `%s' is already defined"), S_GET_NAME (symbolP));
6490
6491   subseg_set (current_seg, current_subseg);
6492
6493   demand_empty_rest_of_line ();
6494 }
6495
6496 static void
6497 insert_reg (const struct reg_entry *r, struct hash_control *htab)
6498 {
6499   int i = 0;
6500   int len = strlen (r->name) + 2;
6501   char *buf = xmalloc (len);
6502   char *buf2 = xmalloc (len);
6503
6504   strcpy (buf + i, r->name);
6505   for (i = 0; buf[i]; i++)
6506     {
6507       buf2[i] = TOUPPER (buf[i]);
6508     }
6509   buf2[i] = '\0';
6510
6511   hash_insert (htab, buf, (void *) r);
6512   hash_insert (htab, buf2, (void *) r);
6513 }
6514
6515 static void
6516 build_reg_hsh (struct reg_map *map)
6517 {
6518   const struct reg_entry *r;
6519
6520   if ((map->htab = hash_new ()) == NULL)
6521     {
6522       as_fatal (_("virtual memory exhausted"));
6523     }
6524   for (r = map->names; r->name != NULL; r++)
6525     {
6526       insert_reg (r, map->htab);
6527     }
6528 }
6529
6530 void
6531 md_begin (void)
6532 {
6533   unsigned int i;
6534   segT seg;
6535   subsegT subseg;
6536
6537   if ((score_ops_hsh = hash_new ()) == NULL)
6538     as_fatal (_("virtual memory exhausted"));
6539
6540   build_score_ops_hsh ();
6541
6542   if ((dependency_insn_hsh = hash_new ()) == NULL)
6543     as_fatal (_("virtual memory exhausted"));
6544
6545   build_dependency_insn_hsh ();
6546
6547   for (i = (int)REG_TYPE_FIRST; i < (int)REG_TYPE_MAX; i++)
6548     build_reg_hsh (all_reg_maps + i);
6549
6550   /* Initialize dependency vector.  */
6551   init_dependency_vector ();
6552
6553   bfd_set_arch_mach (stdoutput, TARGET_ARCH, 0);
6554   seg = now_seg;
6555   subseg = now_subseg;
6556   pdr_seg = subseg_new (".pdr", (subsegT) 0);
6557   (void)bfd_set_section_flags (stdoutput, pdr_seg, SEC_READONLY | SEC_RELOC | SEC_DEBUGGING);
6558   (void)bfd_set_section_alignment (stdoutput, pdr_seg, 2);
6559   subseg_set (seg, subseg);
6560
6561   if (USE_GLOBAL_POINTER_OPT)
6562     bfd_set_gp_size (stdoutput, g_switch_value);
6563 }
6564
6565
6566 const pseudo_typeS md_pseudo_table[] =
6567 {
6568   {"bss", s_score_bss, 0},
6569   {"text", s_score_text, 0},
6570   {"word", cons, 4},
6571   {"long", cons, 4},
6572   {"extend", float_cons, 'x'},
6573   {"ldouble", float_cons, 'x'},
6574   {"packed", float_cons, 'p'},
6575   {"end", s_score_end, 0},
6576   {"ent", s_score_ent, 0},
6577   {"frame", s_score_frame, 0},
6578   {"rdata", s_change_sec, 'r'},
6579   {"sdata", s_change_sec, 's'},
6580   {"set", s_score_set, 0},
6581   {"mask", s_score_mask, 'R'},
6582   {"dword", cons, 8},
6583   {"lcomm", s_score_lcomm, 1},
6584   {"section", score_s_section, 0},
6585   {"cpload", s_score_cpload, 0},
6586   {"cprestore", s_score_cprestore, 0},
6587   {"gpword", s_score_gpword, 0},
6588   {"cpadd", s_score_cpadd, 0},
6589   {0, 0, 0}
6590 };
6591