gas/config/tc-arc.c

   1 /* tc-arc.c -- Assembler for the ARC
   2    Copyright (C) 1994-2019 Free Software Foundation, Inc.
   3
   4    Contributor: Claudiu Zissulescu <claziss@synopsys.com>
   5
   6    This file is part of GAS, the GNU Assembler.
   7
   8    GAS is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3, or (at your option)
  11    any later version.
  12
  13    GAS is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with GAS; see the file COPYING.  If not, write to the Free
  20    Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
  21    02110-1301, USA.  */
  22
  23 #include "as.h"
  24 #include "subsegs.h"
  25 #include "dwarf2dbg.h"
  26 #include "dw2gencfi.h"
  27 #include "safe-ctype.h"
  28
  29 #include "opcode/arc.h"
  30 #include "opcode/arc-attrs.h"
  31 #include "elf/arc.h"
  32 #include "../opcodes/arc-ext.h"
  33
  34 /* Defines section.  */
  35
  36 #define MAX_INSN_FIXUPS      2
  37 #define MAX_CONSTR_STR       20
  38 #define FRAG_MAX_GROWTH      8
  39
  40 #ifdef DEBUG
  41 # define pr_debug(fmt, args...) fprintf (stderr, fmt, ##args)
  42 #else
  43 # define pr_debug(fmt, args...)
  44 #endif
  45
  46 #define MAJOR_OPCODE(x)  (((x) & 0xF8000000) >> 27)
  47 #define SUB_OPCODE(x)    (((x) & 0x003F0000) >> 16)
  48 #define LP_INSN(x)       ((MAJOR_OPCODE (x) == 0x4) \
  49                           && (SUB_OPCODE (x) == 0x28))
  50
  51 #ifndef TARGET_WITH_CPU
  52 #define TARGET_WITH_CPU "arc700"
  53 #endif /* TARGET_WITH_CPU */
  54
  55 #define ARC_GET_FLAG(s)         (*symbol_get_tc (s))
  56 #define ARC_SET_FLAG(s,v)       (*symbol_get_tc (s) |= (v))
  57 #define streq(a, b)           (strcmp (a, b) == 0)
  58
  59 /* Enum used to enumerate the relaxable ins operands.  */
  60 enum rlx_operand_type
  61 {
  62   EMPTY = 0,
  63   REGISTER,
  64   REGISTER_S,     /* Register for short instruction(s).  */
  65   REGISTER_NO_GP, /* Is a register but not gp register specifically.  */
  66   REGISTER_DUP,   /* Duplication of previous operand of type register.  */
  67   IMMEDIATE,
  68   BRACKET
  69 };
  70
  71 enum arc_rlx_types
  72 {
  73   ARC_RLX_NONE = 0,
  74   ARC_RLX_BL_S,
  75   ARC_RLX_BL,
  76   ARC_RLX_B_S,
  77   ARC_RLX_B,
  78   ARC_RLX_ADD_U3,
  79   ARC_RLX_ADD_U6,
  80   ARC_RLX_ADD_LIMM,
  81   ARC_RLX_LD_U7,
  82   ARC_RLX_LD_S9,
  83   ARC_RLX_LD_LIMM,
  84   ARC_RLX_MOV_U8,
  85   ARC_RLX_MOV_S12,
  86   ARC_RLX_MOV_LIMM,
  87   ARC_RLX_SUB_U3,
  88   ARC_RLX_SUB_U6,
  89   ARC_RLX_SUB_LIMM,
  90   ARC_RLX_MPY_U6,
  91   ARC_RLX_MPY_LIMM,
  92   ARC_RLX_MOV_RU6,
  93   ARC_RLX_MOV_RLIMM,
  94   ARC_RLX_ADD_RRU6,
  95   ARC_RLX_ADD_RRLIMM,
  96 };
  97
  98 /* Macros section.  */
  99
 100 #define regno(x)                ((x) & 0x3F)
 101 #define is_ir_num(x)            (((x) & ~0x3F) == 0)
 102 #define is_code_density_p(sc)   (((sc) == CD1 || (sc) == CD2))
 103 #define is_spfp_p(op)           (((sc) == SPX))
 104 #define is_dpfp_p(op)           (((sc) == DPX))
 105 #define is_fpuda_p(op)          (((sc) == DPA))
 106 #define is_br_jmp_insn_p(op)    (((op)->insn_class == BRANCH            \
 107                                   || (op)->insn_class == JUMP           \
 108                                   || (op)->insn_class == BRCC           \
 109                                   || (op)->insn_class == BBIT0          \
 110                                   || (op)->insn_class == BBIT1          \
 111                                   || (op)->insn_class == BI             \
 112                                   || (op)->insn_class == EI             \
 113                                   || (op)->insn_class == ENTER          \
 114                                   || (op)->insn_class == JLI            \
 115                                   || (op)->insn_class == LOOP           \
 116                                   || (op)->insn_class == LEAVE          \
 117                                   ))
 118 #define is_kernel_insn_p(op)    (((op)->insn_class == KERNEL))
 119 #define is_nps400_p(op)         (((sc) == NPS400))
 120
 121 /* Generic assembler global variables which must be defined by all
 122    targets.  */
 123
 124 /* Characters which always start a comment.  */
 125 const char comment_chars[] = "#;";
 126
 127 /* Characters which start a comment at the beginning of a line.  */
 128 const char line_comment_chars[] = "#";
 129
 130 /* Characters which may be used to separate multiple commands on a
 131    single line.  */
 132 const char line_separator_chars[] = "`";
 133
 134 /* Characters which are used to indicate an exponent in a floating
 135    point number.  */
 136 const char EXP_CHARS[] = "eE";
 137
 138 /* Chars that mean this number is a floating point constant
 139    As in 0f12.456 or 0d1.2345e12.  */
 140 const char FLT_CHARS[] = "rRsSfFdD";
 141
 142 /* Byte order.  */
 143 extern int target_big_endian;
 144 const char *arc_target_format = DEFAULT_TARGET_FORMAT;
 145 static int byte_order = DEFAULT_BYTE_ORDER;
 146
 147 /* Arc extension section.  */
 148 static segT arcext_section;
 149
 150 /* By default relaxation is disabled.  */
 151 static int relaxation_state = 0;
 152
 153 extern int arc_get_mach (char *);
 154
 155 /* Forward declarations.  */
 156 static void arc_lcomm (int);
 157 static void arc_option (int);
 158 static void arc_extra_reloc (int);
 159 static void arc_extinsn (int);
 160 static void arc_extcorereg (int);
 161 static void arc_attribute (int);
 162
 163 const pseudo_typeS md_pseudo_table[] =
 164 {
 165   /* Make sure that .word is 32 bits.  */
 166   { "word", cons, 4 },
 167
 168   { "align",   s_align_bytes, 0 }, /* Defaulting is invalid (0).  */
 169   { "lcomm",   arc_lcomm, 0 },
 170   { "lcommon", arc_lcomm, 0 },
 171   { "cpu",     arc_option, 0 },
 172
 173   { "arc_attribute",   arc_attribute, 0 },
 174   { "extinstruction",  arc_extinsn, 0 },
 175   { "extcoreregister", arc_extcorereg, EXT_CORE_REGISTER },
 176   { "extauxregister",  arc_extcorereg, EXT_AUX_REGISTER },
 177   { "extcondcode",     arc_extcorereg, EXT_COND_CODE },
 178
 179   { "tls_gd_ld",   arc_extra_reloc, BFD_RELOC_ARC_TLS_GD_LD },
 180   { "tls_gd_call", arc_extra_reloc, BFD_RELOC_ARC_TLS_GD_CALL },
 181
 182   { NULL, NULL, 0 }
 183 };
 184
 185 const char *md_shortopts = "";
 186
 187 enum options
 188 {
 189   OPTION_EB = OPTION_MD_BASE,
 190   OPTION_EL,
 191
 192   OPTION_ARC600,
 193   OPTION_ARC601,
 194   OPTION_ARC700,
 195   OPTION_ARCEM,
 196   OPTION_ARCHS,
 197
 198   OPTION_MCPU,
 199   OPTION_CD,
 200   OPTION_RELAX,
 201   OPTION_NPS400,
 202
 203   OPTION_SPFP,
 204   OPTION_DPFP,
 205   OPTION_FPUDA,
 206
 207   /* The following options are deprecated and provided here only for
 208      compatibility reasons.  */
 209   OPTION_USER_MODE,
 210   OPTION_LD_EXT_MASK,
 211   OPTION_SWAP,
 212   OPTION_NORM,
 213   OPTION_BARREL_SHIFT,
 214   OPTION_MIN_MAX,
 215   OPTION_NO_MPY,
 216   OPTION_EA,
 217   OPTION_MUL64,
 218   OPTION_SIMD,
 219   OPTION_XMAC_D16,
 220   OPTION_XMAC_24,
 221   OPTION_DSP_PACKA,
 222   OPTION_CRC,
 223   OPTION_DVBF,
 224   OPTION_TELEPHONY,
 225   OPTION_XYMEMORY,
 226   OPTION_LOCK,
 227   OPTION_SWAPE,
 228   OPTION_RTSC
 229 };
 230
 231 struct option md_longopts[] =
 232 {
 233   { "EB",               no_argument,       NULL, OPTION_EB },
 234   { "EL",               no_argument,       NULL, OPTION_EL },
 235   { "mcpu",             required_argument, NULL, OPTION_MCPU },
 236   { "mA6",              no_argument,       NULL, OPTION_ARC600 },
 237   { "mARC600",          no_argument,       NULL, OPTION_ARC600 },
 238   { "mARC601",          no_argument,       NULL, OPTION_ARC601 },
 239   { "mARC700",          no_argument,       NULL, OPTION_ARC700 },
 240   { "mA7",              no_argument,       NULL, OPTION_ARC700 },
 241   { "mEM",              no_argument,       NULL, OPTION_ARCEM },
 242   { "mHS",              no_argument,       NULL, OPTION_ARCHS },
 243   { "mcode-density",    no_argument,       NULL, OPTION_CD },
 244   { "mrelax",           no_argument,       NULL, OPTION_RELAX },
 245   { "mnps400",          no_argument,       NULL, OPTION_NPS400 },
 246
 247   /* Floating point options */
 248   { "mspfp", no_argument, NULL, OPTION_SPFP},
 249   { "mspfp-compact", no_argument, NULL, OPTION_SPFP},
 250   { "mspfp_compact", no_argument, NULL, OPTION_SPFP},
 251   { "mspfp-fast", no_argument, NULL, OPTION_SPFP},
 252   { "mspfp_fast", no_argument, NULL, OPTION_SPFP},
 253   { "mdpfp", no_argument, NULL, OPTION_DPFP},
 254   { "mdpfp-compact", no_argument, NULL, OPTION_DPFP},
 255   { "mdpfp_compact", no_argument, NULL, OPTION_DPFP},
 256   { "mdpfp-fast", no_argument, NULL, OPTION_DPFP},
 257   { "mdpfp_fast", no_argument, NULL, OPTION_DPFP},
 258   { "mfpuda", no_argument, NULL, OPTION_FPUDA},
 259
 260   /* The following options are deprecated and provided here only for
 261      compatibility reasons.  */
 262   { "mav2em", no_argument, NULL, OPTION_ARCEM },
 263   { "mav2hs", no_argument, NULL, OPTION_ARCHS },
 264   { "muser-mode-only", no_argument, NULL, OPTION_USER_MODE },
 265   { "mld-extension-reg-mask", required_argument, NULL, OPTION_LD_EXT_MASK },
 266   { "mswap", no_argument, NULL, OPTION_SWAP },
 267   { "mnorm", no_argument, NULL, OPTION_NORM },
 268   { "mbarrel-shifter", no_argument, NULL, OPTION_BARREL_SHIFT },
 269   { "mbarrel_shifter", no_argument, NULL, OPTION_BARREL_SHIFT },
 270   { "mmin-max", no_argument, NULL, OPTION_MIN_MAX },
 271   { "mmin_max", no_argument, NULL, OPTION_MIN_MAX },
 272   { "mno-mpy", no_argument, NULL, OPTION_NO_MPY },
 273   { "mea", no_argument, NULL, OPTION_EA },
 274   { "mEA", no_argument, NULL, OPTION_EA },
 275   { "mmul64", no_argument, NULL, OPTION_MUL64 },
 276   { "msimd", no_argument, NULL, OPTION_SIMD},
 277   { "mmac-d16", no_argument, NULL, OPTION_XMAC_D16},
 278   { "mmac_d16", no_argument, NULL, OPTION_XMAC_D16},
 279   { "mmac-24", no_argument, NULL, OPTION_XMAC_24},
 280   { "mmac_24", no_argument, NULL, OPTION_XMAC_24},
 281   { "mdsp-packa", no_argument, NULL, OPTION_DSP_PACKA},
 282   { "mdsp_packa", no_argument, NULL, OPTION_DSP_PACKA},
 283   { "mcrc", no_argument, NULL, OPTION_CRC},
 284   { "mdvbf", no_argument, NULL, OPTION_DVBF},
 285   { "mtelephony", no_argument, NULL, OPTION_TELEPHONY},
 286   { "mxy", no_argument, NULL, OPTION_XYMEMORY},
 287   { "mlock", no_argument, NULL, OPTION_LOCK},
 288   { "mswape", no_argument, NULL, OPTION_SWAPE},
 289   { "mrtsc", no_argument, NULL, OPTION_RTSC},
 290
 291   { NULL,               no_argument, NULL, 0 }
 292 };
 293
 294 size_t md_longopts_size = sizeof (md_longopts);
 295
 296 /* Local data and data types.  */
 297
 298 /* Used since new relocation types are introduced in this
 299    file (DUMMY_RELOC_LITUSE_*).  */
 300 typedef int extended_bfd_reloc_code_real_type;
 301
 302 struct arc_fixup
 303 {
 304   expressionS exp;
 305
 306   extended_bfd_reloc_code_real_type reloc;
 307
 308   /* index into arc_operands.  */
 309   unsigned int opindex;
 310
 311   /* PC-relative, used by internals fixups.  */
 312   unsigned char pcrel;
 313
 314   /* TRUE if this fixup is for LIMM operand.  */
 315   bfd_boolean islong;
 316 };
 317
 318 struct arc_insn
 319 {
 320   unsigned long long int insn;
 321   int nfixups;
 322   struct arc_fixup fixups[MAX_INSN_FIXUPS];
 323   long limm;
 324   unsigned int len;       /* Length of instruction in bytes.  */
 325   bfd_boolean has_limm;   /* Boolean value: TRUE if limm field is
 326                              valid.  */
 327   bfd_boolean relax;      /* Boolean value: TRUE if needs
 328                              relaxation.  */
 329 };
 330
 331 /* Structure to hold any last two instructions.  */
 332 static struct arc_last_insn
 333 {
 334   /* Saved instruction opcode.  */
 335   const struct arc_opcode *opcode;
 336
 337   /* Boolean value: TRUE if current insn is short.  */
 338   bfd_boolean has_limm;
 339
 340   /* Boolean value: TRUE if current insn has delay slot.  */
 341   bfd_boolean has_delay_slot;
 342 } arc_last_insns[2];
 343
 344 /* Extension instruction suffix classes.  */
 345 typedef struct
 346 {
 347   const char *name;
 348   int  len;
 349   int  attr_class;
 350 } attributes_t;
 351
 352 static const attributes_t suffixclass[] =
 353 {
 354   { "SUFFIX_FLAG", 11, ARC_SUFFIX_FLAG },
 355   { "SUFFIX_COND", 11, ARC_SUFFIX_COND },
 356   { "SUFFIX_NONE", 11, ARC_SUFFIX_NONE }
 357 };
 358
 359 /* Extension instruction syntax classes.  */
 360 static const attributes_t syntaxclass[] =
 361 {
 362   { "SYNTAX_3OP", 10, ARC_SYNTAX_3OP },
 363   { "SYNTAX_2OP", 10, ARC_SYNTAX_2OP },
 364   { "SYNTAX_1OP", 10, ARC_SYNTAX_1OP },
 365   { "SYNTAX_NOP", 10, ARC_SYNTAX_NOP }
 366 };
 367
 368 /* Extension instruction syntax classes modifiers.  */
 369 static const attributes_t syntaxclassmod[] =
 370 {
 371   { "OP1_IMM_IMPLIED" , 15, ARC_OP1_IMM_IMPLIED },
 372   { "OP1_MUST_BE_IMM" , 15, ARC_OP1_MUST_BE_IMM }
 373 };
 374
 375 /* Extension register type.  */
 376 typedef struct
 377 {
 378   char *name;
 379   int  number;
 380   int  imode;
 381 } extRegister_t;
 382
 383 /* A structure to hold the additional conditional codes.  */
 384 static struct
 385 {
 386   struct arc_flag_operand *arc_ext_condcode;
 387   int size;
 388 } ext_condcode = { NULL, 0 };
 389
 390 /* Structure to hold an entry in ARC_OPCODE_HASH.  */
 391 struct arc_opcode_hash_entry
 392 {
 393   /* The number of pointers in the OPCODE list.  */
 394   size_t count;
 395
 396   /* Points to a list of opcode pointers.  */
 397   const struct arc_opcode **opcode;
 398 };
 399
 400 /* Structure used for iterating through an arc_opcode_hash_entry.  */
 401 struct arc_opcode_hash_entry_iterator
 402 {
 403   /* Index into the OPCODE element of the arc_opcode_hash_entry.  */
 404   size_t index;
 405
 406   /* The specific ARC_OPCODE from the ARC_OPCODES table that was last
 407      returned by this iterator.  */
 408   const struct arc_opcode *opcode;
 409 };
 410
 411 /* Forward declaration.  */
 412 static void assemble_insn
 413   (const struct arc_opcode *, const expressionS *, int,
 414    const struct arc_flags *, int, struct arc_insn *);
 415
 416 /* The selection of the machine type can come from different sources.  This
 417    enum is used to track how the selection was made in order to perform
 418    error checks.  */
 419 enum mach_selection_type
 420   {
 421     MACH_SELECTION_NONE,
 422     MACH_SELECTION_FROM_DEFAULT,
 423     MACH_SELECTION_FROM_CPU_DIRECTIVE,
 424     MACH_SELECTION_FROM_COMMAND_LINE
 425   };
 426
 427 /* How the current machine type was selected.  */
 428 static enum mach_selection_type mach_selection_mode = MACH_SELECTION_NONE;
 429
 430 /* The hash table of instruction opcodes.  */
 431 static struct hash_control *arc_opcode_hash;
 432
 433 /* The hash table of register symbols.  */
 434 static struct hash_control *arc_reg_hash;
 435
 436 /* The hash table of aux register symbols.  */
 437 static struct hash_control *arc_aux_hash;
 438
 439 /* The hash table of address types.  */
 440 static struct hash_control *arc_addrtype_hash;
 441
 442 #define ARC_CPU_TYPE_A6xx(NAME,EXTRA)                   \
 443   { #NAME, ARC_OPCODE_ARC600, bfd_mach_arc_arc600,      \
 444       E_ARC_MACH_ARC600, EXTRA}
 445 #define ARC_CPU_TYPE_A7xx(NAME,EXTRA)                   \
 446   { #NAME, ARC_OPCODE_ARC700,  bfd_mach_arc_arc700,     \
 447       E_ARC_MACH_ARC700, EXTRA}
 448 #define ARC_CPU_TYPE_AV2EM(NAME,EXTRA)                  \
 449   { #NAME,  ARC_OPCODE_ARCv2EM, bfd_mach_arc_arcv2,     \
 450       EF_ARC_CPU_ARCV2EM, EXTRA}
 451 #define ARC_CPU_TYPE_AV2HS(NAME,EXTRA)                  \
 452   { #NAME,  ARC_OPCODE_ARCv2HS, bfd_mach_arc_arcv2,     \
 453       EF_ARC_CPU_ARCV2HS, EXTRA}
 454 #define ARC_CPU_TYPE_NONE                               \
 455   { 0, 0, 0, 0, 0 }
 456
 457 /* A table of CPU names and opcode sets.  */
 458 static const struct cpu_type
 459 {
 460   const char *name;
 461   unsigned flags;
 462   int mach;
 463   unsigned eflags;
 464   unsigned features;
 465 }
 466   cpu_types[] =
 467 {
 468   #include "elf/arc-cpu.def"
 469 };
 470
 471 /* Information about the cpu/variant we're assembling for.  */
 472 static struct cpu_type selected_cpu = { 0, 0, 0, E_ARC_OSABI_CURRENT, 0 };
 473
 474 /* TRUE if current assembly code uses RF16 only registers.  */
 475 static bfd_boolean rf16_only = TRUE;
 476
 477 /* MPY option.  */
 478 static unsigned mpy_option = 0;
 479
 480 /* Use PIC. */
 481 static unsigned pic_option = 0;
 482
 483 /* Use small data.  */
 484 static unsigned sda_option = 0;
 485
 486 /* Use TLS.  */
 487 static unsigned tls_option = 0;
 488
 489 /* Command line given features.  */
 490 static unsigned cl_features = 0;
 491
 492 /* Used by the arc_reloc_op table.  Order is important.  */
 493 #define O_gotoff  O_md1     /* @gotoff relocation.  */
 494 #define O_gotpc   O_md2     /* @gotpc relocation.  */
 495 #define O_plt     O_md3     /* @plt relocation.  */
 496 #define O_sda     O_md4     /* @sda relocation.  */
 497 #define O_pcl     O_md5     /* @pcl relocation.  */
 498 #define O_tlsgd   O_md6     /* @tlsgd relocation.  */
 499 #define O_tlsie   O_md7     /* @tlsie relocation.  */
 500 #define O_tpoff9  O_md8     /* @tpoff9 relocation.  */
 501 #define O_tpoff   O_md9     /* @tpoff relocation.  */
 502 #define O_dtpoff9 O_md10    /* @dtpoff9 relocation.  */
 503 #define O_dtpoff  O_md11    /* @dtpoff relocation.  */
 504 #define O_last    O_dtpoff
 505
 506 /* Used to define a bracket as operand in tokens.  */
 507 #define O_bracket O_md32
 508
 509 /* Used to define a colon as an operand in tokens.  */
 510 #define O_colon O_md31
 511
 512 /* Used to define address types in nps400.  */
 513 #define O_addrtype O_md30
 514
 515 /* Dummy relocation, to be sorted out.  */
 516 #define DUMMY_RELOC_ARC_ENTRY     (BFD_RELOC_UNUSED + 1)
 517
 518 #define USER_RELOC_P(R) ((R) >= O_gotoff && (R) <= O_last)
 519
 520 /* A table to map the spelling of a relocation operand into an appropriate
 521    bfd_reloc_code_real_type type.  The table is assumed to be ordered such
 522    that op-O_literal indexes into it.  */
 523 #define ARC_RELOC_TABLE(op)                             \
 524   (&arc_reloc_op[ ((!USER_RELOC_P (op))                 \
 525                    ? (abort (), 0)                      \
 526                    : (int) (op) - (int) O_gotoff) ])
 527
 528 #define DEF(NAME, RELOC, REQ)                           \
 529   { #NAME, sizeof (#NAME)-1, O_##NAME, RELOC, REQ}
 530
 531 static const struct arc_reloc_op_tag
 532 {
 533   /* String to lookup.  */
 534   const char *name;
 535   /* Size of the string.  */
 536   size_t length;
 537   /* Which operator to use.  */
 538   operatorT op;
 539   extended_bfd_reloc_code_real_type reloc;
 540   /* Allows complex relocation expression like identifier@reloc +
 541      const.  */
 542   unsigned int complex_expr : 1;
 543 }
 544   arc_reloc_op[] =
 545 {
 546   DEF (gotoff,  BFD_RELOC_ARC_GOTOFF,           1),
 547   DEF (gotpc,   BFD_RELOC_ARC_GOTPC32,          0),
 548   DEF (plt,     BFD_RELOC_ARC_PLT32,            0),
 549   DEF (sda,     DUMMY_RELOC_ARC_ENTRY,          1),
 550   DEF (pcl,     BFD_RELOC_ARC_PC32,             1),
 551   DEF (tlsgd,   BFD_RELOC_ARC_TLS_GD_GOT,       0),
 552   DEF (tlsie,   BFD_RELOC_ARC_TLS_IE_GOT,       0),
 553   DEF (tpoff9,  BFD_RELOC_ARC_TLS_LE_S9,        0),
 554   DEF (tpoff,   BFD_RELOC_ARC_TLS_LE_32,        1),
 555   DEF (dtpoff9, BFD_RELOC_ARC_TLS_DTPOFF_S9,    0),
 556   DEF (dtpoff,  BFD_RELOC_ARC_TLS_DTPOFF,       1),
 557 };
 558
 559 static const int arc_num_reloc_op
 560 = sizeof (arc_reloc_op) / sizeof (*arc_reloc_op);
 561
 562 /* Structure for relaxable instruction that have to be swapped with a
 563    smaller alternative instruction.  */
 564 struct arc_relaxable_ins
 565 {
 566   /* Mnemonic that should be checked.  */
 567   const char *mnemonic_r;
 568
 569   /* Operands that should be checked.
 570      Indexes of operands from operand array.  */
 571   enum rlx_operand_type operands[6];
 572
 573   /* Flags that should be checked.  */
 574   unsigned flag_classes[5];
 575
 576   /* Mnemonic (smaller) alternative to be used later for relaxation.  */
 577   const char *mnemonic_alt;
 578
 579   /* Index of operand that generic relaxation has to check.  */
 580   unsigned opcheckidx;
 581
 582   /* Base subtype index used.  */
 583   enum arc_rlx_types subtype;
 584 };
 585
 586 #define RELAX_TABLE_ENTRY(BITS, ISSIGNED, SIZE, NEXT)                   \
 587   { (ISSIGNED) ? ((1 << ((BITS) - 1)) - 1) : ((1 << (BITS)) - 1),       \
 588       (ISSIGNED) ? -(1 << ((BITS) - 1)) : 0,                            \
 589       (SIZE),                                                           \
 590       (NEXT) }                                                          \
 591
 592 #define RELAX_TABLE_ENTRY_MAX(ISSIGNED, SIZE, NEXT)     \
 593   { (ISSIGNED) ? 0x7FFFFFFF : 0xFFFFFFFF,               \
 594       (ISSIGNED) ? -(0x7FFFFFFF) : 0,                   \
 595       (SIZE),                                           \
 596       (NEXT) }                                          \
 597
 598
 599 /* ARC relaxation table.  */
 600 const relax_typeS md_relax_table[] =
 601 {
 602   /* Fake entry.  */
 603   {0, 0, 0, 0},
 604
 605   /* BL_S s13 ->
 606      BL s25.  */
 607   RELAX_TABLE_ENTRY (13, 1, 2, ARC_RLX_BL),
 608   RELAX_TABLE_ENTRY (25, 1, 4, ARC_RLX_NONE),
 609
 610   /* B_S s10 ->
 611      B s25.  */
 612   RELAX_TABLE_ENTRY (10, 1, 2, ARC_RLX_B),
 613   RELAX_TABLE_ENTRY (25, 1, 4, ARC_RLX_NONE),
 614
 615   /* ADD_S c,b, u3 ->
 616      ADD<.f> a,b,u6 ->
 617      ADD<.f> a,b,limm.  */
 618   RELAX_TABLE_ENTRY (3, 0, 2, ARC_RLX_ADD_U6),
 619   RELAX_TABLE_ENTRY (6, 0, 4, ARC_RLX_ADD_LIMM),
 620   RELAX_TABLE_ENTRY_MAX (0, 8, ARC_RLX_NONE),
 621
 622   /* LD_S a, [b, u7] ->
 623      LD<zz><.x><.aa><.di> a, [b, s9] ->
 624      LD<zz><.x><.aa><.di> a, [b, limm] */
 625   RELAX_TABLE_ENTRY (7, 0, 2, ARC_RLX_LD_S9),
 626   RELAX_TABLE_ENTRY (9, 1, 4, ARC_RLX_LD_LIMM),
 627   RELAX_TABLE_ENTRY_MAX (1, 8, ARC_RLX_NONE),
 628
 629   /* MOV_S b, u8 ->
 630      MOV<.f> b, s12 ->
 631      MOV<.f> b, limm.  */
 632   RELAX_TABLE_ENTRY (8, 0, 2, ARC_RLX_MOV_S12),
 633   RELAX_TABLE_ENTRY (8, 0, 4, ARC_RLX_MOV_LIMM),
 634   RELAX_TABLE_ENTRY_MAX (0, 8, ARC_RLX_NONE),
 635
 636   /* SUB_S c, b, u3 ->
 637      SUB<.f> a, b, u6 ->
 638      SUB<.f> a, b, limm.  */
 639   RELAX_TABLE_ENTRY (3, 0, 2, ARC_RLX_SUB_U6),
 640   RELAX_TABLE_ENTRY (6, 0, 4, ARC_RLX_SUB_LIMM),
 641   RELAX_TABLE_ENTRY_MAX (0, 8, ARC_RLX_NONE),
 642
 643   /* MPY<.f> a, b, u6 ->
 644      MPY<.f> a, b, limm.  */
 645   RELAX_TABLE_ENTRY (6, 0, 4, ARC_RLX_MPY_LIMM),
 646   RELAX_TABLE_ENTRY_MAX (0, 8, ARC_RLX_NONE),
 647
 648   /* MOV<.f><.cc> b, u6 ->
 649      MOV<.f><.cc> b, limm.  */
 650   RELAX_TABLE_ENTRY (6, 0, 4, ARC_RLX_MOV_RLIMM),
 651   RELAX_TABLE_ENTRY_MAX (0, 8, ARC_RLX_NONE),
 652
 653   /* ADD<.f><.cc> b, b, u6 ->
 654      ADD<.f><.cc> b, b, limm.  */
 655   RELAX_TABLE_ENTRY (6, 0, 4, ARC_RLX_ADD_RRLIMM),
 656   RELAX_TABLE_ENTRY_MAX (0, 8, ARC_RLX_NONE),
 657 };
 658
 659 /* Order of this table's entries matters!  */
 660 const struct arc_relaxable_ins arc_relaxable_insns[] =
 661 {
 662   { "bl", { IMMEDIATE }, { 0 }, "bl_s", 0, ARC_RLX_BL_S },
 663   { "b", { IMMEDIATE }, { 0 }, "b_s", 0, ARC_RLX_B_S },
 664   { "add", { REGISTER, REGISTER_DUP, IMMEDIATE }, { 5, 1, 0 }, "add",
 665     2, ARC_RLX_ADD_RRU6},
 666   { "add", { REGISTER_S, REGISTER_S, IMMEDIATE }, { 0 }, "add_s", 2,
 667     ARC_RLX_ADD_U3 },
 668   { "add", { REGISTER, REGISTER, IMMEDIATE }, { 5, 0 }, "add", 2,
 669     ARC_RLX_ADD_U6 },
 670   { "ld", { REGISTER_S, BRACKET, REGISTER_S, IMMEDIATE, BRACKET },
 671     { 0 }, "ld_s", 3, ARC_RLX_LD_U7 },
 672   { "ld", { REGISTER, BRACKET, REGISTER_NO_GP, IMMEDIATE, BRACKET },
 673     { 11, 4, 14, 17, 0 }, "ld", 3, ARC_RLX_LD_S9 },
 674   { "mov", { REGISTER_S, IMMEDIATE }, { 0 }, "mov_s", 1, ARC_RLX_MOV_U8 },
 675   { "mov", { REGISTER, IMMEDIATE }, { 5, 0 }, "mov", 1, ARC_RLX_MOV_S12 },
 676   { "mov", { REGISTER, IMMEDIATE }, { 5, 1, 0 },"mov", 1, ARC_RLX_MOV_RU6 },
 677   { "sub", { REGISTER_S, REGISTER_S, IMMEDIATE }, { 0 }, "sub_s", 2,
 678     ARC_RLX_SUB_U3 },
 679   { "sub", { REGISTER, REGISTER, IMMEDIATE }, { 5, 0 }, "sub", 2,
 680     ARC_RLX_SUB_U6 },
 681   { "mpy", { REGISTER, REGISTER, IMMEDIATE }, { 5, 0 }, "mpy", 2,
 682     ARC_RLX_MPY_U6 },
 683 };
 684
 685 const unsigned arc_num_relaxable_ins = ARRAY_SIZE (arc_relaxable_insns);
 686
 687 /* Pre-defined "_GLOBAL_OFFSET_TABLE_".  */
 688 symbolS * GOT_symbol = 0;
 689
 690 /* Set to TRUE when we assemble instructions.  */
 691 static bfd_boolean assembling_insn = FALSE;
 692
 693 /* List with attributes set explicitly.  */
 694 static bfd_boolean attributes_set_explicitly[NUM_KNOWN_OBJ_ATTRIBUTES];
 695
 696 /* Functions implementation.  */
 697
 698 /* Return a pointer to ARC_OPCODE_HASH_ENTRY that identifies all
 699    ARC_OPCODE entries in ARC_OPCODE_HASH that match NAME, or NULL if there
 700    are no matching entries in ARC_OPCODE_HASH.  */
 701
 702 static const struct arc_opcode_hash_entry *
 703 arc_find_opcode (const char *name)
 704 {
 705   const struct arc_opcode_hash_entry *entry;
 706
 707   entry = hash_find (arc_opcode_hash, name);
 708   return entry;
 709 }
 710
 711 /* Initialise the iterator ITER.  */
 712
 713 static void
 714 arc_opcode_hash_entry_iterator_init (struct arc_opcode_hash_entry_iterator *iter)
 715 {
 716   iter->index = 0;
 717   iter->opcode = NULL;
 718 }
 719
 720 /* Return the next ARC_OPCODE from ENTRY, using ITER to hold state between
 721    calls to this function.  Return NULL when all ARC_OPCODE entries have
 722    been returned.  */
 723
 724 static const struct arc_opcode *
 725 arc_opcode_hash_entry_iterator_next (const struct arc_opcode_hash_entry *entry,
 726                                      struct arc_opcode_hash_entry_iterator *iter)
 727 {
 728   if (iter->opcode == NULL && iter->index == 0)
 729     {
 730       gas_assert (entry->count > 0);
 731       iter->opcode = entry->opcode[iter->index];
 732     }
 733   else if (iter->opcode != NULL)
 734     {
 735       const char *old_name = iter->opcode->name;
 736
 737       iter->opcode++;
 738       if (iter->opcode->name == NULL
 739           || strcmp (old_name, iter->opcode->name) != 0)
 740         {
 741           iter->index++;
 742           if (iter->index == entry->count)
 743             iter->opcode = NULL;
 744           else
 745             iter->opcode = entry->opcode[iter->index];
 746         }
 747     }
 748
 749   return iter->opcode;
 750 }
 751
 752 /* Insert an opcode into opcode hash structure.  */
 753
 754 static void
 755 arc_insert_opcode (const struct arc_opcode *opcode)
 756 {
 757   const char *name, *retval;
 758   struct arc_opcode_hash_entry *entry;
 759   name = opcode->name;
 760
 761   entry = hash_find (arc_opcode_hash, name);
 762   if (entry == NULL)
 763     {
 764       entry = XNEW (struct arc_opcode_hash_entry);
 765       entry->count = 0;
 766       entry->opcode = NULL;
 767
 768       retval = hash_insert (arc_opcode_hash, name, (void *) entry);
 769       if (retval)
 770         as_fatal (_("internal error: can't hash opcode '%s': %s"),
 771                   name, retval);
 772     }
 773
 774   entry->opcode = XRESIZEVEC (const struct arc_opcode *, entry->opcode,
 775                               entry->count + 1);
 776
 777   if (entry->opcode == NULL)
 778     as_fatal (_("Virtual memory exhausted"));
 779
 780   entry->opcode[entry->count] = opcode;
 781   entry->count++;
 782 }
 783
 784
 785 /* Like md_number_to_chars but for middle-endian values.  The 4-byte limm
 786    value, is encoded as 'middle-endian' for a little-endian target.  This
 787    function is used for regular 4, 6, and 8 byte instructions as well.  */
 788
 789 static void
 790 md_number_to_chars_midend (char *buf, unsigned long long val, int n)
 791 {
 792   switch (n)
 793     {
 794     case 2:
 795       md_number_to_chars (buf, val, n);
 796       break;
 797     case 6:
 798       md_number_to_chars (buf, (val & 0xffff00000000ull) >> 32, 2);
 799       md_number_to_chars_midend (buf + 2, (val & 0xffffffff), 4);
 800       break;
 801     case 4:
 802       md_number_to_chars (buf,     (val & 0xffff0000) >> 16, 2);
 803       md_number_to_chars (buf + 2, (val & 0xffff), 2);
 804       break;
 805     case 8:
 806       md_number_to_chars_midend (buf, (val & 0xffffffff00000000ull) >> 32, 4);
 807       md_number_to_chars_midend (buf + 4, (val & 0xffffffff), 4);
 808       break;
 809     default:
 810       abort ();
 811     }
 812 }
 813
 814 /* Check if a feature is allowed for a specific CPU.  */
 815
 816 static void
 817 arc_check_feature (void)
 818 {
 819   unsigned i;
 820
 821   if (!selected_cpu.features
 822       || !selected_cpu.name)
 823     return;
 824
 825   for (i = 0; i < ARRAY_SIZE (feature_list); i++)
 826     if ((selected_cpu.features & feature_list[i].feature)
 827         && !(selected_cpu.flags & feature_list[i].cpus))
 828       as_bad (_("invalid %s option for %s cpu"), feature_list[i].name,
 829               selected_cpu.name);
 830
 831   for (i = 0; i < ARRAY_SIZE (conflict_list); i++)
 832     if ((selected_cpu.features & conflict_list[i]) == conflict_list[i])
 833       as_bad(_("conflicting ISA extension attributes."));
 834 }
 835
 836 /* Select an appropriate entry from CPU_TYPES based on ARG and initialise
 837    the relevant static global variables.  Parameter SEL describes where
 838    this selection originated from.  */
 839
 840 static void
 841 arc_select_cpu (const char *arg, enum mach_selection_type sel)
 842 {
 843   int i;
 844
 845   /* We should only set a default if we've not made a selection from some
 846      other source.  */
 847   gas_assert (sel != MACH_SELECTION_FROM_DEFAULT
 848               || mach_selection_mode == MACH_SELECTION_NONE);
 849
 850   if ((mach_selection_mode == MACH_SELECTION_FROM_CPU_DIRECTIVE)
 851       && (sel == MACH_SELECTION_FROM_CPU_DIRECTIVE))
 852     as_bad (_("Multiple .cpu directives found"));
 853
 854   /* Look for a matching entry in CPU_TYPES array.  */
 855   for (i = 0; cpu_types[i].name; ++i)
 856     {
 857       if (!strcasecmp (cpu_types[i].name, arg))
 858         {
 859           /* If a previous selection was made on the command line, then we
 860              allow later selections on the command line to override earlier
 861              ones.  However, a selection from a '.cpu NAME' directive must
 862              match the command line selection, or we give a warning.  */
 863           if (mach_selection_mode == MACH_SELECTION_FROM_COMMAND_LINE)
 864             {
 865               gas_assert (sel == MACH_SELECTION_FROM_COMMAND_LINE
 866                           || sel == MACH_SELECTION_FROM_CPU_DIRECTIVE);
 867               if (sel == MACH_SELECTION_FROM_CPU_DIRECTIVE
 868                   && selected_cpu.mach != cpu_types[i].mach)
 869                 {
 870                   as_warn (_("Command-line value overrides \".cpu\" directive"));
 871                 }
 872               return;
 873             }
 874
 875           /* Initialise static global data about selected machine type.  */
 876           selected_cpu.flags = cpu_types[i].flags;
 877           selected_cpu.name = cpu_types[i].name;
 878           selected_cpu.features = cpu_types[i].features | cl_features;
 879           selected_cpu.mach = cpu_types[i].mach;
 880           selected_cpu.eflags = ((selected_cpu.eflags & ~EF_ARC_MACH_MSK)
 881                                  | cpu_types[i].eflags);
 882           break;
 883         }
 884     }
 885
 886   if (!cpu_types[i].name)
 887     as_fatal (_("unknown architecture: %s\n"), arg);
 888
 889   /* Check if set features are compatible with the chosen CPU.  */
 890   arc_check_feature ();
 891
 892   mach_selection_mode = sel;
 893 }
 894
 895 /* Here ends all the ARCompact extension instruction assembling
 896    stuff.  */
 897
 898 static void
 899 arc_extra_reloc (int r_type)
 900 {
 901   char *sym_name, c;
 902   symbolS *sym, *lab = NULL;
 903
 904   if (*input_line_pointer == '@')
 905     input_line_pointer++;
 906   c = get_symbol_name (&sym_name);
 907   sym = symbol_find_or_make (sym_name);
 908   restore_line_pointer (c);
 909   if (c == ',' && r_type == BFD_RELOC_ARC_TLS_GD_LD)
 910     {
 911       ++input_line_pointer;
 912       char *lab_name;
 913       c = get_symbol_name (&lab_name);
 914       lab = symbol_find_or_make (lab_name);
 915       restore_line_pointer (c);
 916     }
 917
 918   /* These relocations exist as a mechanism for the compiler to tell the
 919      linker how to patch the code if the tls model is optimised.  However,
 920      the relocation itself does not require any space within the assembler
 921      fragment, and so we pass a size of 0.
 922
 923      The lines that generate these relocations look like this:
 924
 925          .tls_gd_ld @.tdata`bl __tls_get_addr@plt
 926
 927      The '.tls_gd_ld @.tdata' is processed first and generates the
 928      additional relocation, while the 'bl __tls_get_addr@plt' is processed
 929      second and generates the additional branch.
 930
 931      It is possible that the additional relocation generated by the
 932      '.tls_gd_ld @.tdata' will be attached at the very end of one fragment,
 933      while the 'bl __tls_get_addr@plt' will be generated as the first thing
 934      in the next fragment.  This will be fine; both relocations will still
 935      appear to be at the same address in the generated object file.
 936      However, this only works as the additional relocation is generated
 937      with size of 0 bytes.  */
 938   fixS *fixP
 939     = fix_new (frag_now,        /* Which frag?  */
 940                frag_now_fix (), /* Where in that frag?  */
 941                0,               /* size: 1, 2, or 4 usually.  */
 942                sym,             /* X_add_symbol.  */
 943                0,               /* X_add_number.  */
 944                FALSE,           /* TRUE if PC-relative relocation.  */
 945                r_type           /* Relocation type.  */);
 946   fixP->fx_subsy = lab;
 947 }
 948
 949 static symbolS *
 950 arc_lcomm_internal (int ignore ATTRIBUTE_UNUSED,
 951                     symbolS *symbolP, addressT size)
 952 {
 953   addressT align = 0;
 954   SKIP_WHITESPACE ();
 955
 956   if (*input_line_pointer == ',')
 957     {
 958       align = parse_align (1);
 959
 960       if (align == (addressT) -1)
 961         return NULL;
 962     }
 963   else
 964     {
 965       if (size >= 8)
 966         align = 3;
 967       else if (size >= 4)
 968         align = 2;
 969       else if (size >= 2)
 970         align = 1;
 971       else
 972         align = 0;
 973     }
 974
 975   bss_alloc (symbolP, size, align);
 976   S_CLEAR_EXTERNAL (symbolP);
 977
 978   return symbolP;
 979 }
 980
 981 static void
 982 arc_lcomm (int ignore)
 983 {
 984   symbolS *symbolP = s_comm_internal (ignore, arc_lcomm_internal);
 985
 986   if (symbolP)
 987     symbol_get_bfdsym (symbolP)->flags |= BSF_OBJECT;
 988 }
 989
 990 /* Select the cpu we're assembling for.  */
 991
 992 static void
 993 arc_option (int ignore ATTRIBUTE_UNUSED)
 994 {
 995   char c;
 996   char *cpu;
 997   const char *cpu_name;
 998
 999   c = get_symbol_name (&cpu);
1000
1001   cpu_name = cpu;
1002   if ((!strcmp ("ARC600", cpu))
1003       || (!strcmp ("ARC601", cpu))
1004       || (!strcmp ("A6", cpu)))
1005     cpu_name = "arc600";
1006   else if ((!strcmp ("ARC700", cpu))
1007            || (!strcmp ("A7", cpu)))
1008     cpu_name = "arc700";
1009   else if (!strcmp ("EM", cpu))
1010     cpu_name = "arcem";
1011   else if (!strcmp ("HS", cpu))
1012     cpu_name = "archs";
1013   else if (!strcmp ("NPS400", cpu))
1014     cpu_name = "nps400";
1015
1016   arc_select_cpu (cpu_name, MACH_SELECTION_FROM_CPU_DIRECTIVE);
1017
1018   restore_line_pointer (c);
1019   demand_empty_rest_of_line ();
1020 }
1021
1022 /* Smartly print an expression.  */
1023
1024 static void
1025 debug_exp (expressionS *t)
1026 {
1027   const char *name ATTRIBUTE_UNUSED;
1028   const char *namemd ATTRIBUTE_UNUSED;
1029
1030   pr_debug ("debug_exp: ");
1031
1032   switch (t->X_op)
1033     {
1034     default:                    name = "unknown";               break;
1035     case O_illegal:             name = "O_illegal";             break;
1036     case O_absent:              name = "O_absent";              break;
1037     case O_constant:            name = "O_constant";            break;
1038     case O_symbol:              name = "O_symbol";              break;
1039     case O_symbol_rva:          name = "O_symbol_rva";          break;
1040     case O_register:            name = "O_register";            break;
1041     case O_big:                 name = "O_big";                 break;
1042     case O_uminus:              name = "O_uminus";              break;
1043     case O_bit_not:             name = "O_bit_not";             break;
1044     case O_logical_not:         name = "O_logical_not";         break;
1045     case O_multiply:            name = "O_multiply";            break;
1046     case O_divide:              name = "O_divide";              break;
1047     case O_modulus:             name = "O_modulus";             break;
1048     case O_left_shift:          name = "O_left_shift";          break;
1049     case O_right_shift:         name = "O_right_shift";         break;
1050     case O_bit_inclusive_or:    name = "O_bit_inclusive_or";    break;
1051     case O_bit_or_not:          name = "O_bit_or_not";          break;
1052     case O_bit_exclusive_or:    name = "O_bit_exclusive_or";    break;
1053     case O_bit_and:             name = "O_bit_and";             break;
1054     case O_add:                 name = "O_add";                 break;
1055     case O_subtract:            name = "O_subtract";            break;
1056     case O_eq:                  name = "O_eq";                  break;
1057     case O_ne:                  name = "O_ne";                  break;
1058     case O_lt:                  name = "O_lt";                  break;
1059     case O_le:                  name = "O_le";                  break;
1060     case O_ge:                  name = "O_ge";                  break;
1061     case O_gt:                  name = "O_gt";                  break;
1062     case O_logical_and:         name = "O_logical_and";         break;
1063     case O_logical_or:          name = "O_logical_or";          break;
1064     case O_index:               name = "O_index";               break;
1065     case O_bracket:             name = "O_bracket";             break;
1066     case O_colon:               name = "O_colon";               break;
1067     case O_addrtype:            name = "O_addrtype";            break;
1068     }
1069
1070   switch (t->X_md)
1071     {
1072     default:                    namemd = "unknown";             break;
1073     case O_gotoff:              namemd = "O_gotoff";            break;
1074     case O_gotpc:               namemd = "O_gotpc";             break;
1075     case O_plt:                 namemd = "O_plt";               break;
1076     case O_sda:                 namemd = "O_sda";               break;
1077     case O_pcl:                 namemd = "O_pcl";               break;
1078     case O_tlsgd:               namemd = "O_tlsgd";             break;
1079     case O_tlsie:               namemd = "O_tlsie";             break;
1080     case O_tpoff9:              namemd = "O_tpoff9";            break;
1081     case O_tpoff:               namemd = "O_tpoff";             break;
1082     case O_dtpoff9:             namemd = "O_dtpoff9";           break;
1083     case O_dtpoff:              namemd = "O_dtpoff";            break;
1084     }
1085
1086   pr_debug ("%s (%s, %s, %d, %s)", name,
1087             (t->X_add_symbol) ? S_GET_NAME (t->X_add_symbol) : "--",
1088             (t->X_op_symbol) ? S_GET_NAME (t->X_op_symbol) : "--",
1089             (int) t->X_add_number,
1090             (t->X_md) ? namemd : "--");
1091   pr_debug ("\n");
1092   fflush (stderr);
1093 }
1094
1095 /* Parse the arguments to an opcode.  */
1096
1097 static int
1098 tokenize_arguments (char *str,
1099                     expressionS *tok,
1100                     int ntok)
1101 {
1102   char *old_input_line_pointer;
1103   bfd_boolean saw_comma = FALSE;
1104   bfd_boolean saw_arg = FALSE;
1105   int brk_lvl = 0;
1106   int num_args = 0;
1107   int i;
1108   size_t len;
1109   const struct arc_reloc_op_tag *r;
1110   expressionS tmpE;
1111   char *reloc_name, c;
1112
1113   memset (tok, 0, sizeof (*tok) * ntok);
1114
1115   /* Save and restore input_line_pointer around this function.  */
1116   old_input_line_pointer = input_line_pointer;
1117   input_line_pointer = str;
1118
1119   while (*input_line_pointer)
1120     {
1121       SKIP_WHITESPACE ();
1122       switch (*input_line_pointer)
1123         {
1124         case '\0':
1125           goto fini;
1126
1127         case ',':
1128           input_line_pointer++;
1129           if (saw_comma || !saw_arg)
1130             goto err;
1131           saw_comma = TRUE;
1132           break;
1133
1134         case '}':
1135         case ']':
1136           ++input_line_pointer;
1137           --brk_lvl;
1138           if (!saw_arg || num_args == ntok)
1139             goto err;
1140           tok->X_op = O_bracket;
1141           ++tok;
1142           ++num_args;
1143           break;
1144
1145         case '{':
1146         case '[':
1147           input_line_pointer++;
1148           if (brk_lvl || num_args == ntok)
1149             goto err;
1150           ++brk_lvl;
1151           tok->X_op = O_bracket;
1152           ++tok;
1153           ++num_args;
1154           break;
1155
1156         case ':':
1157           input_line_pointer++;
1158           if (!saw_arg || num_args == ntok)
1159             goto err;
1160           tok->X_op = O_colon;
1161           saw_arg = FALSE;
1162           ++tok;
1163           ++num_args;
1164           break;
1165
1166         case '@':
1167           /* We have labels, function names and relocations, all
1168              starting with @ symbol.  Sort them out.  */
1169           if ((saw_arg && !saw_comma) || num_args == ntok)
1170             goto err;
1171
1172           /* Parse @label.  */
1173           tok->X_op = O_symbol;
1174           tok->X_md = O_absent;
1175           expression (tok);
1176           if (*input_line_pointer != '@')
1177             goto normalsymbol; /* This is not a relocation.  */
1178
1179         relocationsym:
1180
1181           /* A relocation operand has the following form
1182              @identifier@relocation_type.  The identifier is already
1183              in tok!  */
1184           if (tok->X_op != O_symbol)
1185             {
1186               as_bad (_("No valid label relocation operand"));
1187               goto err;
1188             }
1189
1190           /* Parse @relocation_type.  */
1191           input_line_pointer++;
1192           c = get_symbol_name (&reloc_name);
1193           len = input_line_pointer - reloc_name;
1194           if (len == 0)
1195             {
1196               as_bad (_("No relocation operand"));
1197               goto err;
1198             }
1199
1200           /* Go through known relocation and try to find a match.  */
1201           r = &arc_reloc_op[0];
1202           for (i = arc_num_reloc_op - 1; i >= 0; i--, r++)
1203             if (len == r->length
1204                 && memcmp (reloc_name, r->name, len) == 0)
1205               break;
1206           if (i < 0)
1207             {
1208               as_bad (_("Unknown relocation operand: @%s"), reloc_name);
1209               goto err;
1210             }
1211
1212           *input_line_pointer = c;
1213           SKIP_WHITESPACE_AFTER_NAME ();
1214           /* Extra check for TLS: base.  */
1215           if (*input_line_pointer == '@')
1216             {
1217               symbolS *base;
1218               if (tok->X_op_symbol != NULL
1219                   || tok->X_op != O_symbol)
1220                 {
1221                   as_bad (_("Unable to parse TLS base: %s"),
1222                           input_line_pointer);
1223                   goto err;
1224                 }
1225               input_line_pointer++;
1226               char *sym_name;
1227               c = get_symbol_name (&sym_name);
1228               base = symbol_find_or_make (sym_name);
1229               tok->X_op = O_subtract;
1230               tok->X_op_symbol = base;
1231               restore_line_pointer (c);
1232               tmpE.X_add_number = 0;
1233             }
1234           if ((*input_line_pointer != '+')
1235                    && (*input_line_pointer != '-'))
1236             {
1237               tmpE.X_add_number = 0;
1238             }
1239           else
1240             {
1241               /* Parse the constant of a complex relocation expression
1242                  like @identifier@reloc +/- const.  */
1243               if (! r->complex_expr)
1244                 {
1245                   as_bad (_("@%s is not a complex relocation."), r->name);
1246                   goto err;
1247                 }
1248               expression (&tmpE);
1249               if (tmpE.X_op != O_constant)
1250                 {
1251                   as_bad (_("Bad expression: @%s + %s."),
1252                           r->name, input_line_pointer);
1253                   goto err;
1254                 }
1255             }
1256
1257           tok->X_md = r->op;
1258           tok->X_add_number = tmpE.X_add_number;
1259
1260           debug_exp (tok);
1261
1262           saw_comma = FALSE;
1263           saw_arg = TRUE;
1264           tok++;
1265           num_args++;
1266           break;
1267
1268         case '%':
1269           /* Can be a register.  */
1270           ++input_line_pointer;
1271           /* Fall through.  */
1272         default:
1273
1274           if ((saw_arg && !saw_comma) || num_args == ntok)
1275             goto err;
1276
1277           tok->X_op = O_absent;
1278           tok->X_md = O_absent;
1279           expression (tok);
1280
1281           /* Legacy: There are cases when we have
1282              identifier@relocation_type, if it is the case parse the
1283              relocation type as well.  */
1284           if (*input_line_pointer == '@')
1285             goto relocationsym;
1286
1287         normalsymbol:
1288           debug_exp (tok);
1289
1290           if (tok->X_op == O_illegal
1291               || tok->X_op == O_absent
1292               || num_args == ntok)
1293             goto err;
1294
1295           saw_comma = FALSE;
1296           saw_arg = TRUE;
1297           tok++;
1298           num_args++;
1299           break;
1300         }
1301     }
1302
1303  fini:
1304   if (saw_comma || brk_lvl)
1305     goto err;
1306   input_line_pointer = old_input_line_pointer;
1307
1308   return num_args;
1309
1310  err:
1311   if (brk_lvl)
1312     as_bad (_("Brackets in operand field incorrect"));
1313   else if (saw_comma)
1314     as_bad (_("extra comma"));
1315   else if (!saw_arg)
1316     as_bad (_("missing argument"));
1317   else
1318     as_bad (_("missing comma or colon"));
1319   input_line_pointer = old_input_line_pointer;
1320   return -1;
1321 }
1322
1323 /* Parse the flags to a structure.  */
1324
1325 static int
1326 tokenize_flags (const char *str,
1327                 struct arc_flags flags[],
1328                 int nflg)
1329 {
1330   char *old_input_line_pointer;
1331   bfd_boolean saw_flg = FALSE;
1332   bfd_boolean saw_dot = FALSE;
1333   int num_flags  = 0;
1334   size_t flgnamelen;
1335
1336   memset (flags, 0, sizeof (*flags) * nflg);
1337
1338   /* Save and restore input_line_pointer around this function.  */
1339   old_input_line_pointer = input_line_pointer;
1340   input_line_pointer = (char *) str;
1341
1342   while (*input_line_pointer)
1343     {
1344       switch (*input_line_pointer)
1345         {
1346         case ' ':
1347         case '\0':
1348           goto fini;
1349
1350         case '.':
1351           input_line_pointer++;
1352           if (saw_dot)
1353             goto err;
1354           saw_dot = TRUE;
1355           saw_flg = FALSE;
1356           break;
1357
1358         default:
1359           if (saw_flg && !saw_dot)
1360             goto err;
1361
1362           if (num_flags >= nflg)
1363             goto err;
1364
1365           flgnamelen = strspn (input_line_pointer,
1366                                "abcdefghijklmnopqrstuvwxyz0123456789");
1367           if (flgnamelen > MAX_FLAG_NAME_LENGTH)
1368             goto err;
1369
1370           memcpy (flags->name, input_line_pointer, flgnamelen);
1371
1372           input_line_pointer += flgnamelen;
1373           flags++;
1374           saw_dot = FALSE;
1375           saw_flg = TRUE;
1376           num_flags++;
1377           break;
1378         }
1379     }
1380
1381  fini:
1382   input_line_pointer = old_input_line_pointer;
1383   return num_flags;
1384
1385  err:
1386   if (saw_dot)
1387     as_bad (_("extra dot"));
1388   else if (!saw_flg)
1389     as_bad (_("unrecognized flag"));
1390   else
1391     as_bad (_("failed to parse flags"));
1392   input_line_pointer = old_input_line_pointer;
1393   return -1;
1394 }
1395
1396 /* Apply the fixups in order.  */
1397
1398 static void
1399 apply_fixups (struct arc_insn *insn, fragS *fragP, int fix)
1400 {
1401   int i;
1402
1403   for (i = 0; i < insn->nfixups; i++)
1404     {
1405       struct arc_fixup *fixup = &insn->fixups[i];
1406       int size, pcrel, offset = 0;
1407
1408       /* FIXME! the reloc size is wrong in the BFD file.
1409          When it is fixed please delete me.  */
1410       size = ((insn->len == 2) && !fixup->islong) ? 2 : 4;
1411
1412       if (fixup->islong)
1413         offset = insn->len;
1414
1415       /* Some fixups are only used internally, thus no howto.  */
1416       if ((int) fixup->reloc == 0)
1417         as_fatal (_("Unhandled reloc type"));
1418
1419       if ((int) fixup->reloc < 0)
1420         {
1421           /* FIXME! the reloc size is wrong in the BFD file.
1422              When it is fixed please enable me.
1423              size = ((insn->len == 2 && !fixup->islong) ? 2 : 4; */
1424           pcrel = fixup->pcrel;
1425         }
1426       else
1427         {
1428           reloc_howto_type *reloc_howto =
1429             bfd_reloc_type_lookup (stdoutput,
1430                                    (bfd_reloc_code_real_type) fixup->reloc);
1431           gas_assert (reloc_howto);
1432
1433           /* FIXME! the reloc size is wrong in the BFD file.
1434              When it is fixed please enable me.
1435              size = bfd_get_reloc_size (reloc_howto); */
1436           pcrel = reloc_howto->pc_relative;
1437         }
1438
1439       pr_debug ("%s:%d: apply_fixups: new %s fixup (PCrel:%s) of size %d @ \
1440 offset %d + %d\n",
1441                 fragP->fr_file, fragP->fr_line,
1442                 (fixup->reloc < 0) ? "Internal" :
1443                 bfd_get_reloc_code_name (fixup->reloc),
1444                 pcrel ? "Y" : "N",
1445                 size, fix, offset);
1446       fix_new_exp (fragP, fix + offset,
1447                    size, &fixup->exp, pcrel, fixup->reloc);
1448
1449       /* Check for ZOLs, and update symbol info if any.  */
1450       if (LP_INSN (insn->insn))
1451         {
1452           gas_assert (fixup->exp.X_add_symbol);
1453           ARC_SET_FLAG (fixup->exp.X_add_symbol, ARC_FLAG_ZOL);
1454         }
1455     }
1456 }
1457
1458 /* Actually output an instruction with its fixup.  */
1459
1460 static void
1461 emit_insn0 (struct arc_insn *insn, char *where, bfd_boolean relax)
1462 {
1463   char *f = where;
1464   size_t total_len;
1465
1466   pr_debug ("Emit insn : 0x%llx\n", insn->insn);
1467   pr_debug ("\tLength  : 0x%d\n", insn->len);
1468   pr_debug ("\tLong imm: 0x%lx\n", insn->limm);
1469
1470   /* Write out the instruction.  */
1471   total_len = insn->len + (insn->has_limm ? 4 : 0);
1472   if (!relax)
1473     f = frag_more (total_len);
1474
1475   md_number_to_chars_midend(f, insn->insn, insn->len);
1476
1477   if (insn->has_limm)
1478     md_number_to_chars_midend (f + insn->len, insn->limm, 4);
1479   dwarf2_emit_insn (total_len);
1480
1481   if (!relax)
1482     apply_fixups (insn, frag_now, (f - frag_now->fr_literal));
1483 }
1484
1485 static void
1486 emit_insn1 (struct arc_insn *insn)
1487 {
1488   /* How frag_var's args are currently configured:
1489      - rs_machine_dependent, to dictate it's a relaxation frag.
1490      - FRAG_MAX_GROWTH, maximum size of instruction
1491      - 0, variable size that might grow...unused by generic relaxation.
1492      - frag_now->fr_subtype, fr_subtype starting value, set previously.
1493      - s, opand expression.
1494      - 0, offset but it's unused.
1495      - 0, opcode but it's unused.  */
1496   symbolS *s = make_expr_symbol (&insn->fixups[0].exp);
1497   frag_now->tc_frag_data.pcrel = insn->fixups[0].pcrel;
1498
1499   if (frag_room () < FRAG_MAX_GROWTH)
1500     {
1501       /* Handle differently when frag literal memory is exhausted.
1502          This is used because when there's not enough memory left in
1503          the current frag, a new frag is created and the information
1504          we put into frag_now->tc_frag_data is disregarded.  */
1505
1506       struct arc_relax_type relax_info_copy;
1507       relax_substateT subtype = frag_now->fr_subtype;
1508
1509       memcpy (&relax_info_copy, &frag_now->tc_frag_data,
1510               sizeof (struct arc_relax_type));
1511
1512       frag_wane (frag_now);
1513       frag_grow (FRAG_MAX_GROWTH);
1514
1515       memcpy (&frag_now->tc_frag_data, &relax_info_copy,
1516               sizeof (struct arc_relax_type));
1517
1518       frag_var (rs_machine_dependent, FRAG_MAX_GROWTH, 0,
1519                 subtype, s, 0, 0);
1520     }
1521   else
1522     frag_var (rs_machine_dependent, FRAG_MAX_GROWTH, 0,
1523               frag_now->fr_subtype, s, 0, 0);
1524 }
1525
1526 static void
1527 emit_insn (struct arc_insn *insn)
1528 {
1529   if (insn->relax)
1530     emit_insn1 (insn);
1531   else
1532     emit_insn0 (insn, NULL, FALSE);
1533 }
1534
1535 /* Check whether a symbol involves a register.  */
1536
1537 static bfd_boolean
1538 contains_register (symbolS *sym)
1539 {
1540   if (sym)
1541     {
1542       expressionS *ex = symbol_get_value_expression (sym);
1543
1544       return ((O_register == ex->X_op)
1545               && !contains_register (ex->X_add_symbol)
1546               && !contains_register (ex->X_op_symbol));
1547     }
1548
1549   return FALSE;
1550 }
1551
1552 /* Returns the register number within a symbol.  */
1553
1554 static int
1555 get_register (symbolS *sym)
1556 {
1557   if (!contains_register (sym))
1558     return -1;
1559
1560   expressionS *ex = symbol_get_value_expression (sym);
1561   return regno (ex->X_add_number);
1562 }
1563
1564 /* Return true if a RELOC is generic.  A generic reloc is PC-rel of a
1565    simple ME relocation (e.g. RELOC_ARC_32_ME, BFD_RELOC_ARC_PC32.  */
1566
1567 static bfd_boolean
1568 generic_reloc_p (extended_bfd_reloc_code_real_type reloc)
1569 {
1570   if (!reloc)
1571     return FALSE;
1572
1573   switch (reloc)
1574     {
1575     case BFD_RELOC_ARC_SDA_LDST:
1576     case BFD_RELOC_ARC_SDA_LDST1:
1577     case BFD_RELOC_ARC_SDA_LDST2:
1578     case BFD_RELOC_ARC_SDA16_LD:
1579     case BFD_RELOC_ARC_SDA16_LD1:
1580     case BFD_RELOC_ARC_SDA16_LD2:
1581     case BFD_RELOC_ARC_SDA16_ST2:
1582     case BFD_RELOC_ARC_SDA32_ME:
1583       return FALSE;
1584     default:
1585       return TRUE;
1586     }
1587 }
1588
1589 /* Allocates a tok entry.  */
1590
1591 static int
1592 allocate_tok (expressionS *tok, int ntok, int cidx)
1593 {
1594   if (ntok > MAX_INSN_ARGS - 2)
1595     return 0; /* No space left.  */
1596
1597   if (cidx > ntok)
1598     return 0; /* Incorrect args.  */
1599
1600   memcpy (&tok[ntok+1], &tok[ntok], sizeof (*tok));
1601
1602   if (cidx == ntok)
1603     return 1; /* Success.  */
1604   return allocate_tok (tok, ntok - 1, cidx);
1605 }
1606
1607 /* Check if an particular ARC feature is enabled.  */
1608
1609 static bfd_boolean
1610 check_cpu_feature (insn_subclass_t sc)
1611 {
1612   if (is_code_density_p (sc) && !(selected_cpu.features & CD))
1613     return FALSE;
1614
1615   if (is_spfp_p (sc) && !(selected_cpu.features & SPX))
1616     return FALSE;
1617
1618   if (is_dpfp_p (sc) && !(selected_cpu.features & DPX))
1619     return FALSE;
1620
1621   if (is_fpuda_p (sc) && !(selected_cpu.features & DPA))
1622     return FALSE;
1623
1624   if (is_nps400_p (sc) && !(selected_cpu.features & NPS400))
1625     return FALSE;
1626
1627   return TRUE;
1628 }
1629
1630 /* Parse the flags described by FIRST_PFLAG and NFLGS against the flag
1631    operands in OPCODE.  Stores the matching OPCODES into the FIRST_PFLAG
1632    array and returns TRUE if the flag operands all match, otherwise,
1633    returns FALSE, in which case the FIRST_PFLAG array may have been
1634    modified.  */
1635
1636 static bfd_boolean
1637 parse_opcode_flags (const struct arc_opcode *opcode,
1638                     int nflgs,
1639                     struct arc_flags *first_pflag)
1640 {
1641   int lnflg, i;
1642   const unsigned char *flgidx;
1643
1644   lnflg = nflgs;
1645   for (i = 0; i < nflgs; i++)
1646     first_pflag[i].flgp = NULL;
1647
1648   /* Check the flags.  Iterate over the valid flag classes.  */
1649   for (flgidx = opcode->flags; *flgidx; ++flgidx)
1650     {
1651       /* Get a valid flag class.  */
1652       const struct arc_flag_class *cl_flags = &arc_flag_classes[*flgidx];
1653       const unsigned *flgopridx;
1654       int cl_matches = 0;
1655       struct arc_flags *pflag = NULL;
1656
1657       /* Check if opcode has implicit flag classes.  */
1658       if (cl_flags->flag_class & F_CLASS_IMPLICIT)
1659         continue;
1660
1661       /* Check for extension conditional codes.  */
1662       if (ext_condcode.arc_ext_condcode
1663           && cl_flags->flag_class & F_CLASS_EXTEND)
1664         {
1665           struct arc_flag_operand *pf = ext_condcode.arc_ext_condcode;
1666           while (pf->name)
1667             {
1668               pflag = first_pflag;
1669               for (i = 0; i < nflgs; i++, pflag++)
1670                 {
1671                   if (!strcmp (pf->name, pflag->name))
1672                     {
1673                       if (pflag->flgp != NULL)
1674                         return FALSE;
1675                       /* Found it.  */
1676                       cl_matches++;
1677                       pflag->flgp = pf;
1678                       lnflg--;
1679                       break;
1680                     }
1681                 }
1682               pf++;
1683             }
1684         }
1685
1686       for (flgopridx = cl_flags->flags; *flgopridx; ++flgopridx)
1687         {
1688           const struct arc_flag_operand *flg_operand;
1689
1690           pflag = first_pflag;
1691           flg_operand = &arc_flag_operands[*flgopridx];
1692           for (i = 0; i < nflgs; i++, pflag++)
1693             {
1694               /* Match against the parsed flags.  */
1695               if (!strcmp (flg_operand->name, pflag->name))
1696                 {
1697                   if (pflag->flgp != NULL)
1698                     return FALSE;
1699                   cl_matches++;
1700                   pflag->flgp = flg_operand;
1701                   lnflg--;
1702                   break; /* goto next flag class and parsed flag.  */
1703                 }
1704             }
1705         }
1706
1707       if ((cl_flags->flag_class & F_CLASS_REQUIRED) && cl_matches == 0)
1708         return FALSE;
1709       if ((cl_flags->flag_class & F_CLASS_OPTIONAL) && cl_matches > 1)
1710         return FALSE;
1711     }
1712
1713   /* Did I check all the parsed flags?  */
1714   return lnflg ? FALSE : TRUE;
1715 }
1716
1717
1718 /* Search forward through all variants of an opcode looking for a
1719    syntax match.  */
1720
1721 static const struct arc_opcode *
1722 find_opcode_match (const struct arc_opcode_hash_entry *entry,
1723                    expressionS *tok,
1724                    int *pntok,
1725                    struct arc_flags *first_pflag,
1726                    int nflgs,
1727                    int *pcpumatch,
1728                    const char **errmsg)
1729 {
1730   const struct arc_opcode *opcode;
1731   struct arc_opcode_hash_entry_iterator iter;
1732   int ntok = *pntok;
1733   int got_cpu_match = 0;
1734   expressionS bktok[MAX_INSN_ARGS];
1735   int bkntok;
1736   expressionS emptyE;
1737
1738   arc_opcode_hash_entry_iterator_init (&iter);
1739   memset (&emptyE, 0, sizeof (emptyE));
1740   memcpy (bktok, tok, MAX_INSN_ARGS * sizeof (*tok));
1741   bkntok = ntok;
1742
1743   for (opcode = arc_opcode_hash_entry_iterator_next (entry, &iter);
1744        opcode != NULL;
1745        opcode = arc_opcode_hash_entry_iterator_next (entry, &iter))
1746     {
1747       const unsigned char *opidx;
1748       int tokidx = 0;
1749       const expressionS *t = &emptyE;
1750
1751       pr_debug ("%s:%d: find_opcode_match: trying opcode 0x%08llX ",
1752                 frag_now->fr_file, frag_now->fr_line, opcode->opcode);
1753
1754       /* Don't match opcodes that don't exist on this
1755          architecture.  */
1756       if (!(opcode->cpu & selected_cpu.flags))
1757         goto match_failed;
1758
1759       if (!check_cpu_feature (opcode->subclass))
1760         goto match_failed;
1761
1762       got_cpu_match = 1;
1763       pr_debug ("cpu ");
1764
1765       /* Check the operands.  */
1766       for (opidx = opcode->operands; *opidx; ++opidx)
1767         {
1768           const struct arc_operand *operand = &arc_operands[*opidx];
1769
1770           /* Only take input from real operands.  */
1771           if (ARC_OPERAND_IS_FAKE (operand))
1772             continue;
1773
1774           /* When we expect input, make sure we have it.  */
1775           if (tokidx >= ntok)
1776             goto match_failed;
1777
1778           /* Match operand type with expression type.  */
1779           switch (operand->flags & ARC_OPERAND_TYPECHECK_MASK)
1780             {
1781             case ARC_OPERAND_ADDRTYPE:
1782               {
1783                 *errmsg = NULL;
1784
1785                 /* Check to be an address type.  */
1786                 if (tok[tokidx].X_op != O_addrtype)
1787                   goto match_failed;
1788
1789                 /* All address type operands need to have an insert
1790                    method in order to check that we have the correct
1791                    address type.  */
1792                 gas_assert (operand->insert != NULL);
1793                 (*operand->insert) (0, tok[tokidx].X_add_number,
1794                                     errmsg);
1795                 if (*errmsg != NULL)
1796                   goto match_failed;
1797               }
1798               break;
1799
1800             case ARC_OPERAND_IR:
1801               /* Check to be a register.  */
1802               if ((tok[tokidx].X_op != O_register
1803                    || !is_ir_num (tok[tokidx].X_add_number))
1804                   && !(operand->flags & ARC_OPERAND_IGNORE))
1805                 goto match_failed;
1806
1807               /* If expect duplicate, make sure it is duplicate.  */
1808               if (operand->flags & ARC_OPERAND_DUPLICATE)
1809                 {
1810                   /* Check for duplicate.  */
1811                   if (t->X_op != O_register
1812                       || !is_ir_num (t->X_add_number)
1813                       || (regno (t->X_add_number) !=
1814                           regno (tok[tokidx].X_add_number)))
1815                     goto match_failed;
1816                 }
1817
1818               /* Special handling?  */
1819               if (operand->insert)
1820                 {
1821                   *errmsg = NULL;
1822                   (*operand->insert)(0,
1823                                      regno (tok[tokidx].X_add_number),
1824                                      errmsg);
1825                   if (*errmsg)
1826                     {
1827                       if (operand->flags & ARC_OPERAND_IGNORE)
1828                         {
1829                           /* Missing argument, create one.  */
1830                           if (!allocate_tok (tok, ntok - 1, tokidx))
1831                             goto match_failed;
1832
1833                           tok[tokidx].X_op = O_absent;
1834                           ++ntok;
1835                         }
1836                       else
1837                         goto match_failed;
1838                     }
1839                 }
1840
1841               t = &tok[tokidx];
1842               break;
1843
1844             case ARC_OPERAND_BRAKET:
1845               /* Check if bracket is also in opcode table as
1846                  operand.  */
1847               if (tok[tokidx].X_op != O_bracket)
1848                 goto match_failed;
1849               break;
1850
1851             case ARC_OPERAND_COLON:
1852               /* Check if colon is also in opcode table as operand.  */
1853               if (tok[tokidx].X_op != O_colon)
1854                 goto match_failed;
1855               break;
1856
1857             case ARC_OPERAND_LIMM:
1858             case ARC_OPERAND_SIGNED:
1859             case ARC_OPERAND_UNSIGNED:
1860               switch (tok[tokidx].X_op)
1861                 {
1862                 case O_illegal:
1863                 case O_absent:
1864                 case O_register:
1865                   goto match_failed;
1866
1867                 case O_bracket:
1868                   /* Got an (too) early bracket, check if it is an
1869                      ignored operand.  N.B. This procedure works only
1870                      when bracket is the last operand!  */
1871                   if (!(operand->flags & ARC_OPERAND_IGNORE))
1872                     goto match_failed;
1873                   /* Insert the missing operand.  */
1874                   if (!allocate_tok (tok, ntok - 1, tokidx))
1875                     goto match_failed;
1876
1877                   tok[tokidx].X_op = O_absent;
1878                   ++ntok;
1879                   break;
1880
1881                 case O_symbol:
1882                   {
1883                     const char *p;
1884                     char *tmpp, *pp;
1885                     const struct arc_aux_reg *auxr;
1886
1887                     if (opcode->insn_class != AUXREG)
1888                       goto de_fault;
1889                     p = S_GET_NAME (tok[tokidx].X_add_symbol);
1890
1891                     /* For compatibility reasons, an aux register can
1892                        be spelled with upper or lower case
1893                        letters.  */
1894                     tmpp = strdup (p);
1895                     for (pp = tmpp; *pp; ++pp) *pp = TOLOWER (*pp);
1896
1897                     auxr = hash_find (arc_aux_hash, tmpp);
1898                     if (auxr)
1899                       {
1900                         /* We modify the token array here, safe in the
1901                            knowledge, that if this was the wrong
1902                            choice then the original contents will be
1903                            restored from BKTOK.  */
1904                         tok[tokidx].X_op = O_constant;
1905                         tok[tokidx].X_add_number = auxr->address;
1906                         ARC_SET_FLAG (tok[tokidx].X_add_symbol, ARC_FLAG_AUX);
1907                       }
1908                     free (tmpp);
1909
1910                     if (tok[tokidx].X_op != O_constant)
1911                       goto de_fault;
1912                   }
1913                   /* Fall through.  */
1914                 case O_constant:
1915                   /* Check the range.  */
1916                   if (operand->bits != 32
1917                       && !(operand->flags & ARC_OPERAND_NCHK))
1918                     {
1919                       offsetT min, max, val;
1920                       val = tok[tokidx].X_add_number;
1921
1922                       if (operand->flags & ARC_OPERAND_SIGNED)
1923                         {
1924                           max = (1 << (operand->bits - 1)) - 1;
1925                           min = -(1 << (operand->bits - 1));
1926                         }
1927                       else
1928                         {
1929                           max = (1 << operand->bits) - 1;
1930                           min = 0;
1931                         }
1932
1933                       if (val < min || val > max)
1934                         goto match_failed;
1935
1936                       /* Check alignments.  */
1937                       if ((operand->flags & ARC_OPERAND_ALIGNED32)
1938                           && (val & 0x03))
1939                         goto match_failed;
1940
1941                       if ((operand->flags & ARC_OPERAND_ALIGNED16)
1942                           && (val & 0x01))
1943                         goto match_failed;
1944                     }
1945                   else if (operand->flags & ARC_OPERAND_NCHK)
1946                     {
1947                       if (operand->insert)
1948                         {
1949                           *errmsg = NULL;
1950                           (*operand->insert)(0,
1951                                              tok[tokidx].X_add_number,
1952                                              errmsg);
1953                           if (*errmsg)
1954                             goto match_failed;
1955                         }
1956                       else if (!(operand->flags & ARC_OPERAND_IGNORE))
1957                         goto match_failed;
1958                     }
1959                   break;
1960
1961                 case O_subtract:
1962                   /* Check if it is register range.  */
1963                   if ((tok[tokidx].X_add_number == 0)
1964                       && contains_register (tok[tokidx].X_add_symbol)
1965                       && contains_register (tok[tokidx].X_op_symbol))
1966                     {
1967                       int regs;
1968
1969                       regs = get_register (tok[tokidx].X_add_symbol);
1970                       regs <<= 16;
1971                       regs |= get_register (tok[tokidx].X_op_symbol);
1972                       if (operand->insert)
1973                         {
1974                           *errmsg = NULL;
1975                           (*operand->insert)(0,
1976                                              regs,
1977                                              errmsg);
1978                           if (*errmsg)
1979                             goto match_failed;
1980                         }
1981                       else
1982                         goto match_failed;
1983                       break;
1984                     }
1985                   /* Fall through.  */
1986                 default:
1987                 de_fault:
1988                   if (operand->default_reloc == 0)
1989                     goto match_failed; /* The operand needs relocation.  */
1990
1991                   /* Relocs requiring long immediate.  FIXME! make it
1992                      generic and move it to a function.  */
1993                   switch (tok[tokidx].X_md)
1994                     {
1995                     case O_gotoff:
1996                     case O_gotpc:
1997                     case O_pcl:
1998                     case O_tpoff:
1999                     case O_dtpoff:
2000                     case O_tlsgd:
2001                     case O_tlsie:
2002                       if (!(operand->flags & ARC_OPERAND_LIMM))
2003                         goto match_failed;
2004                       /* Fall through.  */
2005                     case O_absent:
2006                       if (!generic_reloc_p (operand->default_reloc))
2007                         goto match_failed;
2008                       break;
2009                     default:
2010                       break;
2011                     }
2012                   break;
2013                 }
2014               /* If expect duplicate, make sure it is duplicate.  */
2015               if (operand->flags & ARC_OPERAND_DUPLICATE)
2016                 {
2017                   if (t->X_op == O_illegal
2018                       || t->X_op == O_absent
2019                       || t->X_op == O_register
2020                       || (t->X_add_number != tok[tokidx].X_add_number))
2021                     goto match_failed;
2022                 }
2023               t = &tok[tokidx];
2024               break;
2025
2026             default:
2027               /* Everything else should have been fake.  */
2028               abort ();
2029             }
2030
2031           ++tokidx;
2032         }
2033       pr_debug ("opr ");
2034
2035       /* Setup ready for flag parsing.  */
2036       if (!parse_opcode_flags (opcode, nflgs, first_pflag))
2037         goto match_failed;
2038
2039       pr_debug ("flg");
2040       /* Possible match -- did we use all of our input?  */
2041       if (tokidx == ntok)
2042         {
2043           *pntok = ntok;
2044           pr_debug ("\n");
2045           return opcode;
2046         }
2047
2048     match_failed:;
2049       pr_debug ("\n");
2050       /* Restore the original parameters.  */
2051       memcpy (tok, bktok, MAX_INSN_ARGS * sizeof (*tok));
2052       ntok = bkntok;
2053     }
2054
2055   if (*pcpumatch)
2056     *pcpumatch = got_cpu_match;
2057
2058   return NULL;
2059 }
2060
2061 /* Swap operand tokens.  */
2062
2063 static void
2064 swap_operand (expressionS *operand_array,
2065               unsigned source,
2066               unsigned destination)
2067 {
2068   expressionS cpy_operand;
2069   expressionS *src_operand;
2070   expressionS *dst_operand;
2071   size_t size;
2072
2073   if (source == destination)
2074     return;
2075
2076   src_operand = &operand_array[source];
2077   dst_operand = &operand_array[destination];
2078   size = sizeof (expressionS);
2079
2080   /* Make copy of operand to swap with and swap.  */
2081   memcpy (&cpy_operand, dst_operand, size);
2082   memcpy (dst_operand, src_operand, size);
2083   memcpy (src_operand, &cpy_operand, size);
2084 }
2085
2086 /* Check if *op matches *tok type.
2087    Returns FALSE if they don't match, TRUE if they match.  */
2088
2089 static bfd_boolean
2090 pseudo_operand_match (const expressionS *tok,
2091                       const struct arc_operand_operation *op)
2092 {
2093   offsetT min, max, val;
2094   bfd_boolean ret;
2095   const struct arc_operand *operand_real = &arc_operands[op->operand_idx];
2096
2097   ret = FALSE;
2098   switch (tok->X_op)
2099     {
2100     case O_constant:
2101       if (operand_real->bits == 32 && (operand_real->flags & ARC_OPERAND_LIMM))
2102         ret = 1;
2103       else if (!(operand_real->flags & ARC_OPERAND_IR))
2104         {
2105           val = tok->X_add_number + op->count;
2106           if (operand_real->flags & ARC_OPERAND_SIGNED)
2107             {
2108               max = (1 << (operand_real->bits - 1)) - 1;
2109               min = -(1 << (operand_real->bits - 1));
2110             }
2111           else
2112             {
2113               max = (1 << operand_real->bits) - 1;
2114               min = 0;
2115             }
2116           if (min <= val && val <= max)
2117             ret = TRUE;
2118         }
2119       break;
2120
2121     case O_symbol:
2122       /* Handle all symbols as long immediates or signed 9.  */
2123       if (operand_real->flags & ARC_OPERAND_LIMM
2124           || ((operand_real->flags & ARC_OPERAND_SIGNED)
2125               && operand_real->bits == 9))
2126         ret = TRUE;
2127       break;
2128
2129     case O_register:
2130       if (operand_real->flags & ARC_OPERAND_IR)
2131         ret = TRUE;
2132       break;
2133
2134     case O_bracket:
2135       if (operand_real->flags & ARC_OPERAND_BRAKET)
2136         ret = TRUE;
2137       break;
2138
2139     default:
2140       /* Unknown.  */
2141       break;
2142     }
2143   return ret;
2144 }
2145
2146 /* Find pseudo instruction in array.  */
2147
2148 static const struct arc_pseudo_insn *
2149 find_pseudo_insn (const char *opname,
2150                   int ntok,
2151                   const expressionS *tok)
2152 {
2153   const struct arc_pseudo_insn *pseudo_insn = NULL;
2154   const struct arc_operand_operation *op;
2155   unsigned int i;
2156   int j;
2157
2158   for (i = 0; i < arc_num_pseudo_insn; ++i)
2159     {
2160       pseudo_insn = &arc_pseudo_insns[i];
2161       if (strcmp (pseudo_insn->mnemonic_p, opname) == 0)
2162         {
2163           op = pseudo_insn->operand;
2164           for (j = 0; j < ntok; ++j)
2165             if (!pseudo_operand_match (&tok[j], &op[j]))
2166               break;
2167
2168           /* Found the right instruction.  */
2169           if (j == ntok)
2170             return pseudo_insn;
2171         }
2172     }
2173   return NULL;
2174 }
2175
2176 /* Assumes the expressionS *tok is of sufficient size.  */
2177
2178 static const struct arc_opcode_hash_entry *
2179 find_special_case_pseudo (const char *opname,
2180                           int *ntok,
2181                           expressionS *tok,
2182                           int *nflgs,
2183                           struct arc_flags *pflags)
2184 {
2185   const struct arc_pseudo_insn *pseudo_insn = NULL;
2186   const struct arc_operand_operation *operand_pseudo;
2187   const struct arc_operand *operand_real;
2188   unsigned i;
2189   char construct_operand[MAX_CONSTR_STR];
2190
2191   /* Find whether opname is in pseudo instruction array.  */
2192   pseudo_insn = find_pseudo_insn (opname, *ntok, tok);
2193
2194   if (pseudo_insn == NULL)
2195     return NULL;
2196
2197   /* Handle flag, Limited to one flag at the moment.  */
2198   if (pseudo_insn->flag_r != NULL)
2199     *nflgs += tokenize_flags (pseudo_insn->flag_r, &pflags[*nflgs],
2200                               MAX_INSN_FLGS - *nflgs);
2201
2202   /* Handle operand operations.  */
2203   for (i = 0; i < pseudo_insn->operand_cnt; ++i)
2204     {
2205       operand_pseudo = &pseudo_insn->operand[i];
2206       operand_real = &arc_operands[operand_pseudo->operand_idx];
2207
2208       if (operand_real->flags & ARC_OPERAND_BRAKET
2209           && !operand_pseudo->needs_insert)
2210         continue;
2211
2212       /* Has to be inserted (i.e. this token does not exist yet).  */
2213       if (operand_pseudo->needs_insert)
2214         {
2215           if (operand_real->flags & ARC_OPERAND_BRAKET)
2216             {
2217               tok[i].X_op = O_bracket;
2218               ++(*ntok);
2219               continue;
2220             }
2221
2222           /* Check if operand is a register or constant and handle it
2223              by type.  */
2224           if (operand_real->flags & ARC_OPERAND_IR)
2225             snprintf (construct_operand, MAX_CONSTR_STR, "r%d",
2226                       operand_pseudo->count);
2227           else
2228             snprintf (construct_operand, MAX_CONSTR_STR, "%d",
2229                       operand_pseudo->count);
2230
2231           tokenize_arguments (construct_operand, &tok[i], 1);
2232           ++(*ntok);
2233         }
2234
2235       else if (operand_pseudo->count)
2236         {
2237           /* Operand number has to be adjusted accordingly (by operand
2238              type).  */
2239           switch (tok[i].X_op)
2240             {
2241             case O_constant:
2242               tok[i].X_add_number += operand_pseudo->count;
2243               break;
2244
2245             case O_symbol:
2246               break;
2247
2248             default:
2249               /* Ignored.  */
2250               break;
2251             }
2252         }
2253     }
2254
2255   /* Swap operands if necessary.  Only supports one swap at the
2256      moment.  */
2257   for (i = 0; i < pseudo_insn->operand_cnt; ++i)
2258     {
2259       operand_pseudo = &pseudo_insn->operand[i];
2260
2261       if (operand_pseudo->swap_operand_idx == i)
2262         continue;
2263
2264       swap_operand (tok, i, operand_pseudo->swap_operand_idx);
2265
2266       /* Prevent a swap back later by breaking out.  */
2267       break;
2268     }
2269
2270   return arc_find_opcode (pseudo_insn->mnemonic_r);
2271 }
2272
2273 static const struct arc_opcode_hash_entry *
2274 find_special_case_flag (const char *opname,
2275                         int *nflgs,
2276                         struct arc_flags *pflags)
2277 {
2278   unsigned int i;
2279   const char *flagnm;
2280   unsigned flag_idx, flag_arr_idx;
2281   size_t flaglen, oplen;
2282   const struct arc_flag_special *arc_flag_special_opcode;
2283   const struct arc_opcode_hash_entry *entry;
2284
2285   /* Search for special case instruction.  */
2286   for (i = 0; i < arc_num_flag_special; i++)
2287     {
2288       arc_flag_special_opcode = &arc_flag_special_cases[i];
2289       oplen = strlen (arc_flag_special_opcode->name);
2290
2291       if (strncmp (opname, arc_flag_special_opcode->name, oplen) != 0)
2292         continue;
2293
2294       /* Found a potential special case instruction, now test for
2295          flags.  */
2296       for (flag_arr_idx = 0;; ++flag_arr_idx)
2297         {
2298           flag_idx = arc_flag_special_opcode->flags[flag_arr_idx];
2299           if (flag_idx == 0)
2300             break;  /* End of array, nothing found.  */
2301
2302           flagnm = arc_flag_operands[flag_idx].name;
2303           flaglen = strlen (flagnm);
2304           if (strcmp (opname + oplen, flagnm) == 0)
2305             {
2306               entry = arc_find_opcode (arc_flag_special_opcode->name);
2307
2308               if (*nflgs + 1 > MAX_INSN_FLGS)
2309                 break;
2310               memcpy (pflags[*nflgs].name, flagnm, flaglen);
2311               pflags[*nflgs].name[flaglen] = '\0';
2312               (*nflgs)++;
2313               return entry;
2314             }
2315         }
2316     }
2317   return NULL;
2318 }
2319
2320 /* Used to find special case opcode.  */
2321
2322 static const struct arc_opcode_hash_entry *
2323 find_special_case (const char *opname,
2324                    int *nflgs,
2325                    struct arc_flags *pflags,
2326                    expressionS *tok,
2327                    int *ntok)
2328 {
2329   const struct arc_opcode_hash_entry *entry;
2330
2331   entry = find_special_case_pseudo (opname, ntok, tok, nflgs, pflags);
2332
2333   if (entry == NULL)
2334     entry = find_special_case_flag (opname, nflgs, pflags);
2335
2336   return entry;
2337 }
2338
2339 /* Autodetect cpu attribute list.  */
2340
2341 static void
2342 autodetect_attributes (const struct arc_opcode *opcode,
2343                          const expressionS *tok,
2344                          int ntok)
2345 {
2346   unsigned i;
2347   struct mpy_type
2348   {
2349     unsigned feature;
2350     unsigned encoding;
2351   } mpy_list[] = {{ MPY1E, 1 }, { MPY6E, 6 }, { MPY7E, 7 }, { MPY8E, 8 },
2352                  { MPY9E, 9 }};
2353
2354   for (i = 0; i < ARRAY_SIZE (feature_list); i++)
2355     if (opcode->subclass == feature_list[i].feature)
2356       selected_cpu.features |= feature_list[i].feature;
2357
2358   for (i = 0; i < ARRAY_SIZE (mpy_list); i++)
2359     if (opcode->subclass == mpy_list[i].feature)
2360       mpy_option = mpy_list[i].encoding;
2361
2362   for (i = 0; i < (unsigned) ntok; i++)
2363     {
2364       switch (tok[i].X_md)
2365         {
2366         case O_gotoff:
2367         case O_gotpc:
2368         case O_plt:
2369           pic_option = 2;
2370           break;
2371         case O_sda:
2372           sda_option = 2;
2373           break;
2374         case O_tlsgd:
2375         case O_tlsie:
2376         case O_tpoff9:
2377         case O_tpoff:
2378         case O_dtpoff9:
2379         case O_dtpoff:
2380           tls_option = 1;
2381           break;
2382         default:
2383           break;
2384         }
2385
2386       switch (tok[i].X_op)
2387         {
2388         case O_register:
2389           if ((tok[i].X_add_number >= 4 && tok[i].X_add_number <= 9)
2390               || (tok[i].X_add_number >= 16 && tok[i].X_add_number <= 25))
2391             rf16_only = FALSE;
2392           break;
2393         default:
2394           break;
2395         }
2396     }
2397 }
2398
2399 /* Given an opcode name, pre-tockenized set of argumenst and the
2400    opcode flags, take it all the way through emission.  */
2401
2402 static void
2403 assemble_tokens (const char *opname,
2404                  expressionS *tok,
2405                  int ntok,
2406                  struct arc_flags *pflags,
2407                  int nflgs)
2408 {
2409   bfd_boolean found_something = FALSE;
2410   const struct arc_opcode_hash_entry *entry;
2411   int cpumatch = 1;
2412   const char *errmsg = NULL;
2413
2414   /* Search opcodes.  */
2415   entry = arc_find_opcode (opname);
2416
2417   /* Couldn't find opcode conventional way, try special cases.  */
2418   if (entry == NULL)
2419     entry = find_special_case (opname, &nflgs, pflags, tok, &ntok);
2420
2421   if (entry != NULL)
2422     {
2423       const struct arc_opcode *opcode;
2424
2425       pr_debug ("%s:%d: assemble_tokens: %s\n",
2426                 frag_now->fr_file, frag_now->fr_line, opname);
2427       found_something = TRUE;
2428       opcode = find_opcode_match (entry, tok, &ntok, pflags,
2429                                   nflgs, &cpumatch, &errmsg);
2430       if (opcode != NULL)
2431         {
2432           struct arc_insn insn;
2433
2434           autodetect_attributes (opcode,  tok, ntok);
2435           assemble_insn (opcode, tok, ntok, pflags, nflgs, &insn);
2436           emit_insn (&insn);
2437           return;
2438         }
2439     }
2440
2441   if (found_something)
2442     {
2443       if (cpumatch)
2444         if (errmsg)
2445           as_bad (_("%s for instruction '%s'"), errmsg, opname);
2446         else
2447           as_bad (_("inappropriate arguments for opcode '%s'"), opname);
2448       else
2449         as_bad (_("opcode '%s' not supported for target %s"), opname,
2450                 selected_cpu.name);
2451     }
2452   else
2453     as_bad (_("unknown opcode '%s'"), opname);
2454 }
2455
2456 /* The public interface to the instruction assembler.  */
2457
2458 void
2459 md_assemble (char *str)
2460 {
2461   char *opname;
2462   expressionS tok[MAX_INSN_ARGS];
2463   int ntok, nflg;
2464   size_t opnamelen;
2465   struct arc_flags flags[MAX_INSN_FLGS];
2466
2467   /* Split off the opcode.  */
2468   opnamelen = strspn (str, "abcdefghijklmnopqrstuvwxyz_0123468");
2469   opname = xmemdup0 (str, opnamelen);
2470
2471   /* Signalize we are assembling the instructions.  */
2472   assembling_insn = TRUE;
2473
2474   /* Tokenize the flags.  */
2475   if ((nflg = tokenize_flags (str + opnamelen, flags, MAX_INSN_FLGS)) == -1)
2476     {
2477       as_bad (_("syntax error"));
2478       return;
2479     }
2480
2481   /* Scan up to the end of the mnemonic which must end in space or end
2482      of string.  */
2483   str += opnamelen;
2484   for (; *str != '\0'; str++)
2485     if (*str == ' ')
2486       break;
2487
2488   /* Tokenize the rest of the line.  */
2489   if ((ntok = tokenize_arguments (str, tok, MAX_INSN_ARGS)) < 0)
2490     {
2491       as_bad (_("syntax error"));
2492       return;
2493     }
2494
2495   /* Finish it off.  */
2496   assemble_tokens (opname, tok, ntok, flags, nflg);
2497   assembling_insn = FALSE;
2498 }
2499
2500 /* Callback to insert a register into the hash table.  */
2501
2502 static void
2503 declare_register (const char *name, int number)
2504 {
2505   const char *err;
2506   symbolS *regS = symbol_create (name, reg_section,
2507                                  number, &zero_address_frag);
2508
2509   err = hash_insert (arc_reg_hash, S_GET_NAME (regS), (void *) regS);
2510   if (err)
2511     as_fatal (_("Inserting \"%s\" into register table failed: %s"),
2512               name, err);
2513 }
2514
2515 /* Construct symbols for each of the general registers.  */
2516
2517 static void
2518 declare_register_set (void)
2519 {
2520   int i;
2521   for (i = 0; i < 64; ++i)
2522     {
2523       char name[7];
2524
2525       sprintf (name, "r%d", i);
2526       declare_register (name, i);
2527       if ((i & 0x01) == 0)
2528         {
2529           sprintf (name, "r%dr%d", i, i+1);
2530           declare_register (name, i);
2531         }
2532     }
2533 }
2534
2535 /* Construct a symbol for an address type.  */
2536
2537 static void
2538 declare_addrtype (const char *name, int number)
2539 {
2540   const char *err;
2541   symbolS *addrtypeS = symbol_create (name, undefined_section,
2542                                       number, &zero_address_frag);
2543
2544   err = hash_insert (arc_addrtype_hash, S_GET_NAME (addrtypeS),
2545                      (void *) addrtypeS);
2546   if (err)
2547     as_fatal (_("Inserting \"%s\" into address type table failed: %s"),
2548               name, err);
2549 }
2550
2551 /* Port-specific assembler initialization.  This function is called
2552    once, at assembler startup time.  */
2553
2554 void
2555 md_begin (void)
2556 {
2557   const struct arc_opcode *opcode = arc_opcodes;
2558
2559   if (mach_selection_mode == MACH_SELECTION_NONE)
2560     arc_select_cpu (TARGET_WITH_CPU, MACH_SELECTION_FROM_DEFAULT);
2561
2562   /* The endianness can be chosen "at the factory".  */
2563   target_big_endian = byte_order == BIG_ENDIAN;
2564
2565   if (!bfd_set_arch_mach (stdoutput, bfd_arch_arc, selected_cpu.mach))
2566     as_warn (_("could not set architecture and machine"));
2567
2568   /* Set elf header flags.  */
2569   bfd_set_private_flags (stdoutput, selected_cpu.eflags);
2570
2571   /* Set up a hash table for the instructions.  */
2572   arc_opcode_hash = hash_new ();
2573   if (arc_opcode_hash == NULL)
2574     as_fatal (_("Virtual memory exhausted"));
2575
2576   /* Initialize the hash table with the insns.  */
2577   do
2578     {
2579       const char *name = opcode->name;
2580
2581       arc_insert_opcode (opcode);
2582
2583       while (++opcode && opcode->name
2584              && (opcode->name == name
2585                  || !strcmp (opcode->name, name)))
2586         continue;
2587     }while (opcode->name);
2588
2589   /* Register declaration.  */
2590   arc_reg_hash = hash_new ();
2591   if (arc_reg_hash == NULL)
2592     as_fatal (_("Virtual memory exhausted"));
2593
2594   declare_register_set ();
2595   declare_register ("gp", 26);
2596   declare_register ("fp", 27);
2597   declare_register ("sp", 28);
2598   declare_register ("ilink", 29);
2599   declare_register ("ilink1", 29);
2600   declare_register ("ilink2", 30);
2601   declare_register ("blink", 31);
2602
2603   /* XY memory registers.  */
2604   declare_register ("x0_u0", 32);
2605   declare_register ("x0_u1", 33);
2606   declare_register ("x1_u0", 34);
2607   declare_register ("x1_u1", 35);
2608   declare_register ("x2_u0", 36);
2609   declare_register ("x2_u1", 37);
2610   declare_register ("x3_u0", 38);
2611   declare_register ("x3_u1", 39);
2612   declare_register ("y0_u0", 40);
2613   declare_register ("y0_u1", 41);
2614   declare_register ("y1_u0", 42);
2615   declare_register ("y1_u1", 43);
2616   declare_register ("y2_u0", 44);
2617   declare_register ("y2_u1", 45);
2618   declare_register ("y3_u0", 46);
2619   declare_register ("y3_u1", 47);
2620   declare_register ("x0_nu", 48);
2621   declare_register ("x1_nu", 49);
2622   declare_register ("x2_nu", 50);
2623   declare_register ("x3_nu", 51);
2624   declare_register ("y0_nu", 52);
2625   declare_register ("y1_nu", 53);
2626   declare_register ("y2_nu", 54);
2627   declare_register ("y3_nu", 55);
2628
2629   declare_register ("mlo", 57);
2630   declare_register ("mmid", 58);
2631   declare_register ("mhi", 59);
2632
2633   declare_register ("acc1", 56);
2634   declare_register ("acc2", 57);
2635
2636   declare_register ("lp_count", 60);
2637   declare_register ("pcl", 63);
2638
2639   /* Initialize the last instructions.  */
2640   memset (&arc_last_insns[0], 0, sizeof (arc_last_insns));
2641
2642   /* Aux register declaration.  */
2643   arc_aux_hash = hash_new ();
2644   if (arc_aux_hash == NULL)
2645     as_fatal (_("Virtual memory exhausted"));
2646
2647   const struct arc_aux_reg *auxr = &arc_aux_regs[0];
2648   unsigned int i;
2649   for (i = 0; i < arc_num_aux_regs; i++, auxr++)
2650     {
2651       const char *retval;
2652
2653       if (!(auxr->cpu & selected_cpu.flags))
2654         continue;
2655
2656       if ((auxr->subclass != NONE)
2657           && !check_cpu_feature (auxr->subclass))
2658         continue;
2659
2660       retval = hash_insert (arc_aux_hash, auxr->name, (void *) auxr);
2661       if (retval)
2662         as_fatal (_("internal error: can't hash aux register '%s': %s"),
2663                   auxr->name, retval);
2664     }
2665
2666   /* Address type declaration.  */
2667   arc_addrtype_hash = hash_new ();
2668   if (arc_addrtype_hash == NULL)
2669     as_fatal (_("Virtual memory exhausted"));
2670
2671   declare_addrtype ("bd", ARC_NPS400_ADDRTYPE_BD);
2672   declare_addrtype ("jid", ARC_NPS400_ADDRTYPE_JID);
2673   declare_addrtype ("lbd", ARC_NPS400_ADDRTYPE_LBD);
2674   declare_addrtype ("mbd", ARC_NPS400_ADDRTYPE_MBD);
2675   declare_addrtype ("sd", ARC_NPS400_ADDRTYPE_SD);
2676   declare_addrtype ("sm", ARC_NPS400_ADDRTYPE_SM);
2677   declare_addrtype ("xa", ARC_NPS400_ADDRTYPE_XA);
2678   declare_addrtype ("xd", ARC_NPS400_ADDRTYPE_XD);
2679   declare_addrtype ("cd", ARC_NPS400_ADDRTYPE_CD);
2680   declare_addrtype ("cbd", ARC_NPS400_ADDRTYPE_CBD);
2681   declare_addrtype ("cjid", ARC_NPS400_ADDRTYPE_CJID);
2682   declare_addrtype ("clbd", ARC_NPS400_ADDRTYPE_CLBD);
2683   declare_addrtype ("cm", ARC_NPS400_ADDRTYPE_CM);
2684   declare_addrtype ("csd", ARC_NPS400_ADDRTYPE_CSD);
2685   declare_addrtype ("cxa", ARC_NPS400_ADDRTYPE_CXA);
2686   declare_addrtype ("cxd", ARC_NPS400_ADDRTYPE_CXD);
2687 }
2688
2689 /* Write a value out to the object file, using the appropriate
2690    endianness.  */
2691
2692 void
2693 md_number_to_chars (char *buf,
2694                     valueT val,
2695                     int n)
2696 {
2697   if (target_big_endian)
2698     number_to_chars_bigendian (buf, val, n);
2699   else
2700     number_to_chars_littleendian (buf, val, n);
2701 }
2702
2703 /* Round up a section size to the appropriate boundary.  */
2704
2705 valueT
2706 md_section_align (segT segment,
2707                   valueT size)
2708 {
2709   int align = bfd_get_section_alignment (stdoutput, segment);
2710
2711   return ((size + (1 << align) - 1) & (-((valueT) 1 << align)));
2712 }
2713
2714 /* The location from which a PC relative jump should be calculated,
2715    given a PC relative reloc.  */
2716
2717 long
2718 md_pcrel_from_section (fixS *fixP,
2719                        segT sec)
2720 {
2721   offsetT base = fixP->fx_where + fixP->fx_frag->fr_address;
2722
2723   pr_debug ("pcrel_from_section, fx_offset = %d\n", (int) fixP->fx_offset);
2724
2725   if (fixP->fx_addsy != (symbolS *) NULL
2726       && (!S_IS_DEFINED (fixP->fx_addsy)
2727           || S_GET_SEGMENT (fixP->fx_addsy) != sec))
2728     {
2729       pr_debug ("Unknown pcrel symbol: %s\n", S_GET_NAME (fixP->fx_addsy));
2730
2731       /* The symbol is undefined (or is defined but not in this section).
2732          Let the linker figure it out.  */
2733       return 0;
2734     }
2735
2736   if ((int) fixP->fx_r_type < 0)
2737     {
2738       /* These are the "internal" relocations.  Align them to
2739          32 bit boundary (PCL), for the moment.  */
2740       base &= ~3;
2741     }
2742   else
2743     {
2744       switch (fixP->fx_r_type)
2745         {
2746         case BFD_RELOC_ARC_PC32:
2747           /* The hardware calculates relative to the start of the
2748              insn, but this relocation is relative to location of the
2749              LIMM, compensate.  The base always needs to be
2750              subtracted by 4 as we do not support this type of PCrel
2751              relocation for short instructions.  */
2752           base -= 4;
2753           /* Fall through.  */
2754         case BFD_RELOC_ARC_PLT32:
2755         case BFD_RELOC_ARC_S25H_PCREL_PLT:
2756         case BFD_RELOC_ARC_S21H_PCREL_PLT:
2757         case BFD_RELOC_ARC_S25W_PCREL_PLT:
2758         case BFD_RELOC_ARC_S21W_PCREL_PLT:
2759
2760         case BFD_RELOC_ARC_S21H_PCREL:
2761         case BFD_RELOC_ARC_S25H_PCREL:
2762         case BFD_RELOC_ARC_S13_PCREL:
2763         case BFD_RELOC_ARC_S21W_PCREL:
2764         case BFD_RELOC_ARC_S25W_PCREL:
2765           base &= ~3;
2766           break;
2767         default:
2768           as_bad_where (fixP->fx_file, fixP->fx_line,
2769                         _("unhandled reloc %s in md_pcrel_from_section"),
2770                   bfd_get_reloc_code_name (fixP->fx_r_type));
2771           break;
2772         }
2773     }
2774
2775   pr_debug ("pcrel from %"BFD_VMA_FMT"x + %lx = %"BFD_VMA_FMT"x, "
2776             "symbol: %s (%"BFD_VMA_FMT"x)\n",
2777             fixP->fx_frag->fr_address, fixP->fx_where, base,
2778             fixP->fx_addsy ? S_GET_NAME (fixP->fx_addsy) : "(null)",
2779             fixP->fx_addsy ? S_GET_VALUE (fixP->fx_addsy) : 0);
2780
2781   return base;
2782 }
2783
2784 /* Given a BFD relocation find the corresponding operand.  */
2785
2786 static const struct arc_operand *
2787 find_operand_for_reloc (extended_bfd_reloc_code_real_type reloc)
2788 {
2789   unsigned i;
2790
2791   for (i = 0; i < arc_num_operands; i++)
2792     if (arc_operands[i].default_reloc == reloc)
2793       return  &arc_operands[i];
2794   return NULL;
2795 }
2796
2797 /* Insert an operand value into an instruction.  */
2798
2799 static unsigned long long
2800 insert_operand (unsigned long long insn,
2801                 const struct arc_operand *operand,
2802                 long long val,
2803                 const char *file,
2804                 unsigned line)
2805 {
2806   offsetT min = 0, max = 0;
2807
2808   if (operand->bits != 32
2809       && !(operand->flags & ARC_OPERAND_NCHK)
2810       && !(operand->flags & ARC_OPERAND_FAKE))
2811     {
2812       if (operand->flags & ARC_OPERAND_SIGNED)
2813         {
2814           max = (1 << (operand->bits - 1)) - 1;
2815           min = -(1 << (operand->bits - 1));
2816         }
2817       else
2818         {
2819           max = (1 << operand->bits) - 1;
2820           min = 0;
2821         }
2822
2823       if (val < min || val > max)
2824         as_bad_value_out_of_range (_("operand"),
2825                                    val, min, max, file, line);
2826     }
2827
2828   pr_debug ("insert field: %ld <= %lld <= %ld in 0x%08llx\n",
2829             min, val, max, insn);
2830
2831   if ((operand->flags & ARC_OPERAND_ALIGNED32)
2832       && (val & 0x03))
2833     as_bad_where (file, line,
2834                   _("Unaligned operand. Needs to be 32bit aligned"));
2835
2836   if ((operand->flags & ARC_OPERAND_ALIGNED16)
2837       && (val & 0x01))
2838     as_bad_where (file, line,
2839                   _("Unaligned operand. Needs to be 16bit aligned"));
2840
2841   if (operand->insert)
2842     {
2843       const char *errmsg = NULL;
2844
2845       insn = (*operand->insert) (insn, val, &errmsg);
2846       if (errmsg)
2847         as_warn_where (file, line, "%s", errmsg);
2848     }
2849   else
2850     {
2851       if (operand->flags & ARC_OPERAND_TRUNCATE)
2852         {
2853           if (operand->flags & ARC_OPERAND_ALIGNED32)
2854             val >>= 2;
2855           if (operand->flags & ARC_OPERAND_ALIGNED16)
2856             val >>= 1;
2857         }
2858       insn |= ((val & ((1 << operand->bits) - 1)) << operand->shift);
2859     }
2860   return insn;
2861 }
2862
2863 /* Apply a fixup to the object code.  At this point all symbol values
2864    should be fully resolved, and we attempt to completely resolve the
2865    reloc.  If we can not do that, we determine the correct reloc code
2866    and put it back in the fixup.  To indicate that a fixup has been
2867    eliminated, set fixP->fx_done.  */
2868
2869 void
2870 md_apply_fix (fixS *fixP,
2871               valueT *valP,
2872               segT seg)
2873 {
2874   char * const fixpos = fixP->fx_frag->fr_literal + fixP->fx_where;
2875   valueT value = *valP;
2876   unsigned insn = 0;
2877   symbolS *fx_addsy, *fx_subsy;
2878   offsetT fx_offset;
2879   segT add_symbol_segment = absolute_section;
2880   segT sub_symbol_segment = absolute_section;
2881   const struct arc_operand *operand = NULL;
2882   extended_bfd_reloc_code_real_type reloc;
2883
2884   pr_debug ("%s:%u: apply_fix: r_type=%d (%s) value=0x%lX offset=0x%lX\n",
2885             fixP->fx_file, fixP->fx_line, fixP->fx_r_type,
2886             ((int) fixP->fx_r_type < 0) ? "Internal":
2887             bfd_get_reloc_code_name (fixP->fx_r_type), value,
2888             fixP->fx_offset);
2889
2890   fx_addsy = fixP->fx_addsy;
2891   fx_subsy = fixP->fx_subsy;
2892   fx_offset = 0;
2893
2894   if (fx_addsy)
2895     {
2896       add_symbol_segment = S_GET_SEGMENT (fx_addsy);
2897     }
2898
2899   if (fx_subsy
2900       && fixP->fx_r_type != BFD_RELOC_ARC_TLS_DTPOFF
2901       && fixP->fx_r_type != BFD_RELOC_ARC_TLS_DTPOFF_S9
2902       && fixP->fx_r_type != BFD_RELOC_ARC_TLS_GD_LD)
2903     {
2904       resolve_symbol_value (fx_subsy);
2905       sub_symbol_segment = S_GET_SEGMENT (fx_subsy);
2906
2907       if (sub_symbol_segment == absolute_section)
2908         {
2909           /* The symbol is really a constant.  */
2910           fx_offset -= S_GET_VALUE (fx_subsy);
2911           fx_subsy = NULL;
2912         }
2913       else
2914         {
2915           as_bad_where (fixP->fx_file, fixP->fx_line,
2916                         _("can't resolve `%s' {%s section} - `%s' {%s section}"),
2917                         fx_addsy ? S_GET_NAME (fx_addsy) : "0",
2918                         segment_name (add_symbol_segment),
2919                         S_GET_NAME (fx_subsy),
2920                         segment_name (sub_symbol_segment));
2921           return;
2922         }
2923     }
2924
2925   if (fx_addsy
2926       && !S_IS_WEAK (fx_addsy))
2927     {
2928       if (add_symbol_segment == seg
2929           && fixP->fx_pcrel)
2930         {
2931           value += S_GET_VALUE (fx_addsy);
2932           value -= md_pcrel_from_section (fixP, seg);
2933           fx_addsy = NULL;
2934           fixP->fx_pcrel = FALSE;
2935         }
2936       else if (add_symbol_segment == absolute_section)
2937         {
2938           value = fixP->fx_offset;
2939           fx_offset += S_GET_VALUE (fixP->fx_addsy);
2940           fx_addsy = NULL;
2941           fixP->fx_pcrel = FALSE;
2942         }
2943     }
2944
2945   if (!fx_addsy)
2946     fixP->fx_done = TRUE;
2947
2948   if (fixP->fx_pcrel)
2949     {
2950       if (fx_addsy
2951           && ((S_IS_DEFINED (fx_addsy)
2952                && S_GET_SEGMENT (fx_addsy) != seg)
2953               || S_IS_WEAK (fx_addsy)))
2954         value += md_pcrel_from_section (fixP, seg);
2955
2956       switch (fixP->fx_r_type)
2957         {
2958         case BFD_RELOC_ARC_32_ME:
2959           /* This is a pc-relative value in a LIMM.  Adjust it to the
2960              address of the instruction not to the address of the
2961              LIMM.  Note: it is not any longer valid this affirmation as
2962              the linker consider ARC_PC32 a fixup to entire 64 bit
2963              insn.  */
2964           fixP->fx_offset += fixP->fx_frag->fr_address;
2965           /* Fall through.  */
2966         case BFD_RELOC_32:
2967           fixP->fx_r_type = BFD_RELOC_ARC_PC32;
2968           /* Fall through.  */
2969         case BFD_RELOC_ARC_PC32:
2970           /* fixP->fx_offset += fixP->fx_where - fixP->fx_dot_value; */
2971           break;
2972         default:
2973           if ((int) fixP->fx_r_type < 0)
2974             as_bad_where (fixP->fx_file, fixP->fx_line,
2975                           _("PC relative relocation not allowed for (internal)"
2976                             " type %d"),
2977                           fixP->fx_r_type);
2978           break;
2979         }
2980     }
2981
2982   pr_debug ("%s:%u: apply_fix: r_type=%d (%s) value=0x%lX offset=0x%lX\n",
2983             fixP->fx_file, fixP->fx_line, fixP->fx_r_type,
2984             ((int) fixP->fx_r_type < 0) ? "Internal":
2985             bfd_get_reloc_code_name (fixP->fx_r_type), value,
2986             fixP->fx_offset);
2987
2988
2989   /* Now check for TLS relocations.  */
2990   reloc = fixP->fx_r_type;
2991   switch (reloc)
2992     {
2993     case BFD_RELOC_ARC_TLS_DTPOFF:
2994     case BFD_RELOC_ARC_TLS_LE_32:
2995       if (fixP->fx_done)
2996         break;
2997       /* Fall through.  */
2998     case BFD_RELOC_ARC_TLS_GD_GOT:
2999     case BFD_RELOC_ARC_TLS_IE_GOT:
3000       S_SET_THREAD_LOCAL (fixP->fx_addsy);
3001       break;
3002
3003     case BFD_RELOC_ARC_TLS_GD_LD:
3004       gas_assert (!fixP->fx_offset);
3005       if (fixP->fx_subsy)
3006         fixP->fx_offset
3007           = (S_GET_VALUE (fixP->fx_subsy)
3008              - fixP->fx_frag->fr_address- fixP->fx_where);
3009       fixP->fx_subsy = NULL;
3010       /* Fall through.  */
3011     case BFD_RELOC_ARC_TLS_GD_CALL:
3012       /* These two relocs are there just to allow ld to change the tls
3013          model for this symbol, by patching the code.  The offset -
3014          and scale, if any - will be installed by the linker.  */
3015       S_SET_THREAD_LOCAL (fixP->fx_addsy);
3016       break;
3017
3018     case BFD_RELOC_ARC_TLS_LE_S9:
3019     case BFD_RELOC_ARC_TLS_DTPOFF_S9:
3020       as_bad (_("TLS_*_S9 relocs are not supported yet"));
3021       break;
3022
3023     default:
3024       break;
3025     }
3026
3027   if (!fixP->fx_done)
3028     {
3029       return;
3030     }
3031
3032   /* Adjust the value if we have a constant.  */
3033   value += fx_offset;
3034
3035   /* For hosts with longs bigger than 32-bits make sure that the top
3036      bits of a 32-bit negative value read in by the parser are set,
3037      so that the correct comparisons are made.  */
3038   if (value & 0x80000000)
3039     value |= (-1UL << 31);
3040
3041   reloc = fixP->fx_r_type;
3042   switch (reloc)
3043     {
3044     case BFD_RELOC_8:
3045     case BFD_RELOC_16:
3046     case BFD_RELOC_24:
3047     case BFD_RELOC_32:
3048     case BFD_RELOC_64:
3049     case BFD_RELOC_ARC_32_PCREL:
3050       md_number_to_chars (fixpos, value, fixP->fx_size);
3051       return;
3052
3053     case BFD_RELOC_ARC_GOTPC32:
3054       /* I cannot fix an GOTPC relocation because I need to relax it
3055          from ld rx,[pcl,@sym@gotpc] to add rx,pcl,@sym@gotpc.  */
3056       as_bad (_("Unsupported operation on reloc"));
3057       return;
3058
3059     case BFD_RELOC_ARC_TLS_DTPOFF:
3060     case BFD_RELOC_ARC_TLS_LE_32:
3061       gas_assert (!fixP->fx_addsy);
3062       gas_assert (!fixP->fx_subsy);
3063       /* Fall through.  */
3064
3065     case BFD_RELOC_ARC_GOTOFF:
3066     case BFD_RELOC_ARC_32_ME:
3067     case BFD_RELOC_ARC_PC32:
3068       md_number_to_chars_midend (fixpos, value, fixP->fx_size);
3069       return;
3070
3071     case BFD_RELOC_ARC_PLT32:
3072       md_number_to_chars_midend (fixpos, value, fixP->fx_size);
3073       return;
3074
3075     case BFD_RELOC_ARC_S25H_PCREL_PLT:
3076       reloc = BFD_RELOC_ARC_S25W_PCREL;
3077       goto solve_plt;
3078
3079     case BFD_RELOC_ARC_S21H_PCREL_PLT:
3080       reloc = BFD_RELOC_ARC_S21H_PCREL;
3081       goto solve_plt;
3082
3083     case BFD_RELOC_ARC_S25W_PCREL_PLT:
3084       reloc = BFD_RELOC_ARC_S25W_PCREL;
3085       goto solve_plt;
3086
3087     case BFD_RELOC_ARC_S21W_PCREL_PLT:
3088       reloc = BFD_RELOC_ARC_S21W_PCREL;
3089       /* Fall through.  */
3090
3091     case BFD_RELOC_ARC_S25W_PCREL:
3092     case BFD_RELOC_ARC_S21W_PCREL:
3093     case BFD_RELOC_ARC_S21H_PCREL:
3094     case BFD_RELOC_ARC_S25H_PCREL:
3095     case BFD_RELOC_ARC_S13_PCREL:
3096     solve_plt:
3097       operand = find_operand_for_reloc (reloc);
3098       gas_assert (operand);
3099       break;
3100
3101     default:
3102       {
3103         if ((int) fixP->fx_r_type >= 0)
3104           as_fatal (_("unhandled relocation type %s"),
3105                     bfd_get_reloc_code_name (fixP->fx_r_type));
3106
3107         /* The rest of these fixups needs to be completely resolved as
3108            constants.  */
3109         if (fixP->fx_addsy != 0
3110             && S_GET_SEGMENT (fixP->fx_addsy) != absolute_section)
3111           as_bad_where (fixP->fx_file, fixP->fx_line,
3112                         _("non-absolute expression in constant field"));
3113
3114         gas_assert (-(int) fixP->fx_r_type < (int) arc_num_operands);
3115         operand = &arc_operands[-(int) fixP->fx_r_type];
3116         break;
3117       }
3118     }
3119
3120   if (target_big_endian)
3121     {
3122       switch (fixP->fx_size)
3123         {
3124         case 4:
3125           insn = bfd_getb32 (fixpos);
3126           break;
3127         case 2:
3128           insn = bfd_getb16 (fixpos);
3129           break;
3130         default:
3131           as_bad_where (fixP->fx_file, fixP->fx_line,
3132                         _("unknown fixup size"));
3133         }
3134     }
3135   else
3136     {
3137       insn = 0;
3138       switch (fixP->fx_size)
3139         {
3140         case 4:
3141           insn = bfd_getl16 (fixpos) << 16 | bfd_getl16 (fixpos + 2);
3142           break;
3143         case 2:
3144           insn = bfd_getl16 (fixpos);
3145           break;
3146         default:
3147           as_bad_where (fixP->fx_file, fixP->fx_line,
3148                         _("unknown fixup size"));
3149         }
3150     }
3151
3152   insn = insert_operand (insn, operand, (offsetT) value,
3153                          fixP->fx_file, fixP->fx_line);
3154
3155   md_number_to_chars_midend (fixpos, insn, fixP->fx_size);
3156 }
3157
3158 /* Prepare machine-dependent frags for relaxation.
3159
3160    Called just before relaxation starts.  Any symbol that is now undefined
3161    will not become defined.
3162
3163    Return the correct fr_subtype in the frag.
3164
3165    Return the initial "guess for fr_var" to caller.  The guess for fr_var
3166    is *actually* the growth beyond fr_fix.  Whatever we do to grow fr_fix
3167    or fr_var contributes to our returned value.
3168
3169    Although it may not be explicit in the frag, pretend
3170    fr_var starts with a value.  */
3171
3172 int
3173 md_estimate_size_before_relax (fragS *fragP,
3174                                segT segment)
3175 {
3176   int growth;
3177
3178   /* If the symbol is not located within the same section AND it's not
3179      an absolute section, use the maximum.  OR if the symbol is a
3180      constant AND the insn is by nature not pc-rel, use the maximum.
3181      OR if the symbol is being equated against another symbol, use the
3182      maximum.  OR if the symbol is weak use the maximum.  */
3183   if ((S_GET_SEGMENT (fragP->fr_symbol) != segment
3184        && S_GET_SEGMENT (fragP->fr_symbol) != absolute_section)
3185       || (symbol_constant_p (fragP->fr_symbol)
3186           && !fragP->tc_frag_data.pcrel)
3187       || symbol_equated_p (fragP->fr_symbol)
3188       || S_IS_WEAK (fragP->fr_symbol))
3189     {
3190       while (md_relax_table[fragP->fr_subtype].rlx_more != ARC_RLX_NONE)
3191         ++fragP->fr_subtype;
3192     }
3193
3194   growth = md_relax_table[fragP->fr_subtype].rlx_length;
3195   fragP->fr_var = growth;
3196
3197   pr_debug ("%s:%d: md_estimate_size_before_relax: %d\n",
3198            fragP->fr_file, fragP->fr_line, growth);
3199
3200   return growth;
3201 }
3202
3203 /* Translate internal representation of relocation info to BFD target
3204    format.  */
3205
3206 arelent *
3207 tc_gen_reloc (asection *section ATTRIBUTE_UNUSED,
3208               fixS *fixP)
3209 {
3210   arelent *reloc;
3211   bfd_reloc_code_real_type code;
3212
3213   reloc = XNEW (arelent);
3214   reloc->sym_ptr_ptr = XNEW (asymbol *);
3215   *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixP->fx_addsy);
3216   reloc->address = fixP->fx_frag->fr_address + fixP->fx_where;
3217
3218   /* Make sure none of our internal relocations make it this far.
3219      They'd better have been fully resolved by this point.  */
3220   gas_assert ((int) fixP->fx_r_type > 0);
3221
3222   code = fixP->fx_r_type;
3223
3224   /* if we have something like add gp, pcl,
3225      _GLOBAL_OFFSET_TABLE_@gotpc.  */
3226   if (code == BFD_RELOC_ARC_GOTPC32
3227       && GOT_symbol
3228       && fixP->fx_addsy == GOT_symbol)
3229     code = BFD_RELOC_ARC_GOTPC;
3230
3231   reloc->howto = bfd_reloc_type_lookup (stdoutput, code);
3232   if (reloc->howto == NULL)
3233     {
3234       as_bad_where (fixP->fx_file, fixP->fx_line,
3235                     _("cannot represent `%s' relocation in object file"),
3236                     bfd_get_reloc_code_name (code));
3237       return NULL;
3238     }
3239
3240   if (!fixP->fx_pcrel != !reloc->howto->pc_relative)
3241     as_fatal (_("internal error? cannot generate `%s' relocation"),
3242               bfd_get_reloc_code_name (code));
3243
3244   gas_assert (!fixP->fx_pcrel == !reloc->howto->pc_relative);
3245
3246   reloc->addend = fixP->fx_offset;
3247
3248   return reloc;
3249 }
3250
3251 /* Perform post-processing of machine-dependent frags after relaxation.
3252    Called after relaxation is finished.
3253    In:  Address of frag.
3254    fr_type == rs_machine_dependent.
3255    fr_subtype is what the address relaxed to.
3256
3257    Out: Any fixS:s and constants are set up.  */
3258
3259 void
3260 md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED,
3261                  segT segment ATTRIBUTE_UNUSED,
3262                  fragS *fragP)
3263 {
3264   const relax_typeS *table_entry;
3265   char *dest;
3266   const struct arc_opcode *opcode;
3267   struct arc_insn insn;
3268   int size, fix;
3269   struct arc_relax_type *relax_arg = &fragP->tc_frag_data;
3270
3271   fix = fragP->fr_fix;
3272   dest = fragP->fr_literal + fix;
3273   table_entry = TC_GENERIC_RELAX_TABLE + fragP->fr_subtype;
3274
3275   pr_debug ("%s:%d: md_convert_frag, subtype: %d, fix: %d, "
3276             "var: %"BFD_VMA_FMT"d\n",
3277             fragP->fr_file, fragP->fr_line,
3278             fragP->fr_subtype, fix, fragP->fr_var);
3279
3280   if (fragP->fr_subtype <= 0
3281       && fragP->fr_subtype >= arc_num_relax_opcodes)
3282     as_fatal (_("no relaxation found for this instruction."));
3283
3284   opcode = &arc_relax_opcodes[fragP->fr_subtype];
3285
3286   assemble_insn (opcode, relax_arg->tok, relax_arg->ntok, relax_arg->pflags,
3287         relax_arg->nflg, &insn);
3288
3289   apply_fixups (&insn, fragP, fix);
3290
3291   size = insn.len + (insn.has_limm ? 4 : 0);
3292   gas_assert (table_entry->rlx_length == size);
3293   emit_insn0 (&insn, dest, TRUE);
3294
3295   fragP->fr_fix += table_entry->rlx_length;
3296   fragP->fr_var = 0;
3297 }
3298
3299 /* We have no need to default values of symbols.  We could catch
3300    register names here, but that is handled by inserting them all in
3301    the symbol table to begin with.  */
3302
3303 symbolS *
3304 md_undefined_symbol (char *name)
3305 {
3306   /* The arc abi demands that a GOT[0] should be referencible as
3307      [pc+_DYNAMIC@gotpc].  Hence we convert a _DYNAMIC@gotpc to a
3308      GOTPC reference to _GLOBAL_OFFSET_TABLE_.  */
3309   if (((*name == '_')
3310        && (*(name+1) == 'G')
3311        && (strcmp (name, GLOBAL_OFFSET_TABLE_NAME) == 0)))
3312     {
3313       if (!GOT_symbol)
3314         {
3315           if (symbol_find (name))
3316             as_bad ("GOT already in symbol table");
3317
3318           GOT_symbol = symbol_new (GLOBAL_OFFSET_TABLE_NAME, undefined_section,
3319                                    (valueT) 0, &zero_address_frag);
3320         };
3321       return GOT_symbol;
3322     }
3323   return NULL;
3324 }
3325
3326 /* Turn a string in input_line_pointer into a floating point constant
3327    of type type, and store the appropriate bytes in *litP.  The number
3328    of LITTLENUMS emitted is stored in *sizeP.  An error message is
3329    returned, or NULL on OK.  */
3330
3331 const char *
3332 md_atof (int type, char *litP, int *sizeP)
3333 {
3334   return ieee_md_atof (type, litP, sizeP, target_big_endian);
3335 }
3336
3337 /* Called for any expression that can not be recognized.  When the
3338    function is called, `input_line_pointer' will point to the start of
3339    the expression.  */
3340
3341 void
3342 md_operand (expressionS *expressionP ATTRIBUTE_UNUSED)
3343 {
3344   char *p = input_line_pointer;
3345   if (*p == '@')
3346     {
3347       input_line_pointer++;
3348       expressionP->X_op = O_symbol;
3349       expression (expressionP);
3350     }
3351 }
3352
3353 /* This function is called from the function 'expression', it attempts
3354    to parse special names (in our case register names).  It fills in
3355    the expression with the identified register.  It returns TRUE if
3356    it is a register and FALSE otherwise.  */
3357
3358 bfd_boolean
3359 arc_parse_name (const char *name,
3360                 struct expressionS *e)
3361 {
3362   struct symbol *sym;
3363
3364   if (!assembling_insn)
3365     return FALSE;
3366
3367   if (e->X_op == O_symbol)
3368     return FALSE;
3369
3370   sym = hash_find (arc_reg_hash, name);
3371   if (sym)
3372     {
3373       e->X_op = O_register;
3374       e->X_add_number = S_GET_VALUE (sym);
3375       return TRUE;
3376     }
3377
3378   sym = hash_find (arc_addrtype_hash, name);
3379   if (sym)
3380     {
3381       e->X_op = O_addrtype;
3382       e->X_add_number = S_GET_VALUE (sym);
3383       return TRUE;
3384     }
3385
3386   return FALSE;
3387 }
3388
3389 /* md_parse_option
3390    Invocation line includes a switch not recognized by the base assembler.
3391    See if it's a processor-specific option.
3392
3393    New options (supported) are:
3394
3395    -mcpu=<cpu name>              Assemble for selected processor
3396    -EB/-mbig-endian              Big-endian
3397    -EL/-mlittle-endian           Little-endian
3398    -mrelax                       Enable relaxation
3399
3400    The following CPU names are recognized:
3401    arc600, arc700, arcem, archs, nps400.  */
3402
3403 int
3404 md_parse_option (int c, const char *arg ATTRIBUTE_UNUSED)
3405 {
3406   switch (c)
3407     {
3408     case OPTION_ARC600:
3409     case OPTION_ARC601:
3410       return md_parse_option (OPTION_MCPU, "arc600");
3411
3412     case OPTION_ARC700:
3413       return md_parse_option (OPTION_MCPU, "arc700");
3414
3415     case OPTION_ARCEM:
3416       return md_parse_option (OPTION_MCPU, "arcem");
3417
3418     case OPTION_ARCHS:
3419       return md_parse_option (OPTION_MCPU, "archs");
3420
3421     case OPTION_MCPU:
3422       {
3423         arc_select_cpu (arg, MACH_SELECTION_FROM_COMMAND_LINE);
3424         break;
3425       }
3426
3427     case OPTION_EB:
3428       arc_target_format = "elf32-bigarc";
3429       byte_order = BIG_ENDIAN;
3430       break;
3431
3432     case OPTION_EL:
3433       arc_target_format = "elf32-littlearc";
3434       byte_order = LITTLE_ENDIAN;
3435       break;
3436
3437     case OPTION_CD:
3438       selected_cpu.features |= CD;
3439       cl_features |= CD;
3440       arc_check_feature ();
3441       break;
3442
3443     case OPTION_RELAX:
3444       relaxation_state = 1;
3445       break;
3446
3447     case OPTION_NPS400:
3448       selected_cpu.features |= NPS400;
3449       cl_features |= NPS400;
3450       arc_check_feature ();
3451       break;
3452
3453     case OPTION_SPFP:
3454       selected_cpu.features |= SPX;
3455       cl_features |= SPX;
3456       arc_check_feature ();
3457       break;
3458
3459     case OPTION_DPFP:
3460       selected_cpu.features |= DPX;
3461       cl_features |= DPX;
3462       arc_check_feature ();
3463       break;
3464
3465     case OPTION_FPUDA:
3466       selected_cpu.features |= DPA;
3467       cl_features |= DPA;
3468       arc_check_feature ();
3469       break;
3470
3471     /* Dummy options are accepted but have no effect.  */
3472     case OPTION_USER_MODE:
3473     case OPTION_LD_EXT_MASK:
3474     case OPTION_SWAP:
3475     case OPTION_NORM:
3476     case OPTION_BARREL_SHIFT:
3477     case OPTION_MIN_MAX:
3478     case OPTION_NO_MPY:
3479     case OPTION_EA:
3480     case OPTION_MUL64:
3481     case OPTION_SIMD:
3482     case OPTION_XMAC_D16:
3483     case OPTION_XMAC_24:
3484     case OPTION_DSP_PACKA:
3485     case OPTION_CRC:
3486     case OPTION_DVBF:
3487     case OPTION_TELEPHONY:
3488     case OPTION_XYMEMORY:
3489     case OPTION_LOCK:
3490     case OPTION_SWAPE:
3491     case OPTION_RTSC:
3492       break;
3493
3494     default:
3495       return 0;
3496     }
3497
3498   return 1;
3499 }
3500
3501 /* Display the list of cpu names for use in the help text.  */
3502
3503 static void
3504 arc_show_cpu_list (FILE *stream)
3505 {
3506   int i, offset;
3507   static const char *space_buf = "                          ";
3508
3509   fprintf (stream, "%s", space_buf);
3510   offset = strlen (space_buf);
3511   for (i = 0; cpu_types[i].name != NULL; ++i)
3512     {
3513       bfd_boolean last = (cpu_types[i + 1].name == NULL);
3514
3515       /* If displaying the new cpu name string, and the ', ' (for all
3516          but the last one) will take us past a target width of 80
3517          characters, then it's time for a new line.  */
3518       if (offset + strlen (cpu_types[i].name) + (last ? 0 : 2) > 80)
3519         {
3520           fprintf (stream, "\n%s", space_buf);
3521           offset = strlen (space_buf);
3522         }
3523
3524       fprintf (stream, "%s%s", cpu_types[i].name, (last ? "\n" : ", "));
3525       offset += strlen (cpu_types [i].name) + (last ? 0 : 2);
3526     }
3527 }
3528
3529 void
3530 md_show_usage (FILE *stream)
3531 {
3532   fprintf (stream, _("ARC-specific assembler options:\n"));
3533
3534   fprintf (stream, "  -mcpu=<cpu name>\t  (default: %s), assemble for"
3535            " CPU <cpu name>, one of:\n", TARGET_WITH_CPU);
3536   arc_show_cpu_list (stream);
3537   fprintf (stream, "\n");
3538   fprintf (stream, "  -mA6/-mARC600/-mARC601  same as -mcpu=arc600\n");
3539   fprintf (stream, "  -mA7/-mARC700\t\t  same as -mcpu=arc700\n");
3540   fprintf (stream, "  -mEM\t\t\t  same as -mcpu=arcem\n");
3541   fprintf (stream, "  -mHS\t\t\t  same as -mcpu=archs\n");
3542
3543   fprintf (stream, "  -mnps400\t\t  enable NPS-400 extended instructions\n");
3544   fprintf (stream, "  -mspfp\t\t  enable single-precision floating point"
3545            " instructions\n");
3546   fprintf (stream, "  -mdpfp\t\t  enable double-precision floating point"
3547            " instructions\n");
3548   fprintf (stream, "  -mfpuda\t\t  enable double-precision assist floating "
3549                    "point\n\t\t\t  instructions for ARC EM\n");
3550
3551   fprintf (stream,
3552            "  -mcode-density\t  enable code density option for ARC EM\n");
3553
3554   fprintf (stream, _("\
3555   -EB                     assemble code for a big-endian cpu\n"));
3556   fprintf (stream, _("\
3557   -EL                     assemble code for a little-endian cpu\n"));
3558   fprintf (stream, _("\
3559   -mrelax                 enable relaxation\n"));
3560
3561   fprintf (stream, _("The following ARC-specific assembler options are "
3562                      "deprecated and are accepted\nfor compatibility only:\n"));
3563
3564   fprintf (stream, _("  -mEA\n"
3565                      "  -mbarrel-shifter\n"
3566                      "  -mbarrel_shifter\n"
3567                      "  -mcrc\n"
3568                      "  -mdsp-packa\n"
3569                      "  -mdsp_packa\n"
3570                      "  -mdvbf\n"
3571                      "  -mld-extension-reg-mask\n"
3572                      "  -mlock\n"
3573                      "  -mmac-24\n"
3574                      "  -mmac-d16\n"
3575                      "  -mmac_24\n"
3576                      "  -mmac_d16\n"
3577                      "  -mmin-max\n"
3578                      "  -mmin_max\n"
3579                      "  -mmul64\n"
3580                      "  -mno-mpy\n"
3581                      "  -mnorm\n"
3582                      "  -mrtsc\n"
3583                      "  -msimd\n"
3584                      "  -mswap\n"
3585                      "  -mswape\n"
3586                      "  -mtelephony\n"
3587                      "  -muser-mode-only\n"
3588                      "  -mxy\n"));
3589 }
3590
3591 /* Find the proper relocation for the given opcode.  */
3592
3593 static extended_bfd_reloc_code_real_type
3594 find_reloc (const char *name,
3595             const char *opcodename,
3596             const struct arc_flags *pflags,
3597             int nflg,
3598             extended_bfd_reloc_code_real_type reloc)
3599 {
3600   unsigned int i;
3601   int j;
3602   bfd_boolean found_flag, tmp;
3603   extended_bfd_reloc_code_real_type ret = BFD_RELOC_UNUSED;
3604
3605   for (i = 0; i < arc_num_equiv_tab; i++)
3606     {
3607       const struct arc_reloc_equiv_tab *r = &arc_reloc_equiv[i];
3608
3609       /* Find the entry.  */
3610       if (strcmp (name, r->name))
3611         continue;
3612       if (r->mnemonic && (strcmp (r->mnemonic, opcodename)))
3613         continue;
3614       if (r->flags[0])
3615         {
3616           if (!nflg)
3617             continue;
3618           found_flag = FALSE;
3619           unsigned * psflg = (unsigned *)r->flags;
3620           do
3621             {
3622               tmp = FALSE;
3623               for (j = 0; j < nflg; j++)
3624                 if (!strcmp (pflags[j].name,
3625                              arc_flag_operands[*psflg].name))
3626                   {
3627                     tmp = TRUE;
3628                     break;
3629                   }
3630               if (!tmp)
3631                 {
3632                   found_flag = FALSE;
3633                   break;
3634                 }
3635               else
3636                 {
3637                   found_flag = TRUE;
3638                 }
3639               ++ psflg;
3640             } while (*psflg);
3641
3642           if (!found_flag)
3643             continue;
3644         }
3645
3646       if (reloc != r->oldreloc)
3647         continue;
3648       /* Found it.  */
3649       ret = r->newreloc;
3650       break;
3651     }
3652
3653   if (ret == BFD_RELOC_UNUSED)
3654     as_bad (_("Unable to find %s relocation for instruction %s"),
3655             name, opcodename);
3656   return ret;
3657 }
3658
3659 /* All the symbol types that are allowed to be used for
3660    relaxation.  */
3661
3662 static bfd_boolean
3663 may_relax_expr (expressionS tok)
3664 {
3665   /* Check if we have unrelaxable relocs.  */
3666   switch (tok.X_md)
3667     {
3668     default:
3669       break;
3670     case O_plt:
3671       return FALSE;
3672     }
3673
3674   switch (tok.X_op)
3675     {
3676     case O_symbol:
3677     case O_multiply:
3678     case O_divide:
3679     case O_modulus:
3680     case O_add:
3681     case O_subtract:
3682       break;
3683
3684     default:
3685       return FALSE;
3686     }
3687   return TRUE;
3688 }
3689
3690 /* Checks if flags are in line with relaxable insn.  */
3691
3692 static bfd_boolean
3693 relaxable_flag (const struct arc_relaxable_ins *ins,
3694                 const struct arc_flags *pflags,
3695                 int nflgs)
3696 {
3697   unsigned flag_class,
3698     flag,
3699     flag_class_idx = 0,
3700     flag_idx = 0;
3701
3702   const struct arc_flag_operand *flag_opand;
3703   int i, counttrue = 0;
3704
3705   /* Iterate through flags classes.  */
3706   while ((flag_class = ins->flag_classes[flag_class_idx]) != 0)
3707     {
3708       /* Iterate through flags in flag class.  */
3709       while ((flag = arc_flag_classes[flag_class].flags[flag_idx])
3710              != 0)
3711         {
3712           flag_opand = &arc_flag_operands[flag];
3713           /* Iterate through flags in ins to compare.  */
3714           for (i = 0; i < nflgs; ++i)
3715             {
3716               if (strcmp (flag_opand->name, pflags[i].name) == 0)
3717                 ++counttrue;
3718             }
3719
3720           ++flag_idx;
3721         }
3722
3723       ++flag_class_idx;
3724       flag_idx = 0;
3725     }
3726
3727   /* If counttrue == nflgs, then all flags have been found.  */
3728   return (counttrue == nflgs ? TRUE : FALSE);
3729 }
3730
3731 /* Checks if operands are in line with relaxable insn.  */
3732
3733 static bfd_boolean
3734 relaxable_operand (const struct arc_relaxable_ins *ins,
3735                    const expressionS *tok,
3736                    int ntok)
3737 {
3738   const enum rlx_operand_type *operand = &ins->operands[0];
3739   int i = 0;
3740
3741   while (*operand != EMPTY)
3742     {
3743       const expressionS *epr = &tok[i];
3744
3745       if (i != 0 && i >= ntok)
3746         return FALSE;
3747
3748       switch (*operand)
3749         {
3750         case IMMEDIATE:
3751           if (!(epr->X_op == O_multiply
3752                 || epr->X_op == O_divide
3753                 || epr->X_op == O_modulus
3754                 || epr->X_op == O_add
3755                 || epr->X_op == O_subtract
3756                 || epr->X_op == O_symbol))
3757             return FALSE;
3758           break;
3759
3760         case REGISTER_DUP:
3761           if ((i <= 0)
3762               || (epr->X_add_number != tok[i - 1].X_add_number))
3763             return FALSE;
3764           /* Fall through.  */
3765         case REGISTER:
3766           if (epr->X_op != O_register)
3767             return FALSE;
3768           break;
3769
3770         case REGISTER_S:
3771           if (epr->X_op != O_register)
3772             return FALSE;
3773
3774           switch (epr->X_add_number)
3775             {
3776             case 0: case 1: case 2: case 3:
3777             case 12: case 13: case 14: case 15:
3778               break;
3779             default:
3780               return FALSE;
3781             }
3782           break;
3783
3784         case REGISTER_NO_GP:
3785           if ((epr->X_op != O_register)
3786               || (epr->X_add_number == 26)) /* 26 is the gp register.  */
3787             return FALSE;
3788           break;
3789
3790         case BRACKET:
3791           if (epr->X_op != O_bracket)
3792             return FALSE;
3793           break;
3794
3795         default:
3796           /* Don't understand, bail out.  */
3797           return FALSE;
3798           break;
3799         }
3800
3801       ++i;
3802       operand = &ins->operands[i];
3803     }
3804
3805   return (i == ntok ? TRUE : FALSE);
3806 }
3807
3808 /* Return TRUE if this OPDCODE is a candidate for relaxation.  */
3809
3810 static bfd_boolean
3811 relax_insn_p (const struct arc_opcode *opcode,
3812               const expressionS *tok,
3813               int ntok,
3814               const struct arc_flags *pflags,
3815               int nflg)
3816 {
3817   unsigned i;
3818   bfd_boolean rv = FALSE;
3819
3820   /* Check the relaxation table.  */
3821   for (i = 0; i < arc_num_relaxable_ins && relaxation_state; ++i)
3822     {
3823       const struct arc_relaxable_ins *arc_rlx_ins = &arc_relaxable_insns[i];
3824
3825       if ((strcmp (opcode->name, arc_rlx_ins->mnemonic_r) == 0)
3826           && may_relax_expr (tok[arc_rlx_ins->opcheckidx])
3827           && relaxable_operand (arc_rlx_ins, tok, ntok)
3828           && relaxable_flag (arc_rlx_ins, pflags, nflg))
3829         {
3830           rv = TRUE;
3831           frag_now->fr_subtype = arc_relaxable_insns[i].subtype;
3832           memcpy (&frag_now->tc_frag_data.tok, tok,
3833                 sizeof (expressionS) * ntok);
3834           memcpy (&frag_now->tc_frag_data.pflags, pflags,
3835                 sizeof (struct arc_flags) * nflg);
3836           frag_now->tc_frag_data.nflg = nflg;
3837           frag_now->tc_frag_data.ntok = ntok;
3838           break;
3839         }
3840     }
3841
3842   return rv;
3843 }
3844
3845 /* Turn an opcode description and a set of arguments into
3846    an instruction and a fixup.  */
3847
3848 static void
3849 assemble_insn (const struct arc_opcode *opcode,
3850                const expressionS *tok,
3851                int ntok,
3852                const struct arc_flags *pflags,
3853                int nflg,
3854                struct arc_insn *insn)
3855 {
3856   const expressionS *reloc_exp = NULL;
3857   unsigned long long image;
3858   const unsigned char *argidx;
3859   int i;
3860   int tokidx = 0;
3861   unsigned char pcrel = 0;
3862   bfd_boolean needGOTSymbol;
3863   bfd_boolean has_delay_slot = FALSE;
3864   extended_bfd_reloc_code_real_type reloc = BFD_RELOC_UNUSED;
3865
3866   memset (insn, 0, sizeof (*insn));
3867   image = opcode->opcode;
3868
3869   pr_debug ("%s:%d: assemble_insn: %s using opcode %llx\n",
3870             frag_now->fr_file, frag_now->fr_line, opcode->name,
3871             opcode->opcode);
3872
3873   /* Handle operands.  */
3874   for (argidx = opcode->operands; *argidx; ++argidx)
3875     {
3876       const struct arc_operand *operand = &arc_operands[*argidx];
3877       const expressionS *t = (const expressionS *) 0;
3878
3879       if (ARC_OPERAND_IS_FAKE (operand))
3880         continue;
3881
3882       if (operand->flags & ARC_OPERAND_DUPLICATE)
3883         {
3884           /* Duplicate operand, already inserted.  */
3885           tokidx ++;
3886           continue;
3887         }
3888
3889       if (tokidx >= ntok)
3890         {
3891           abort ();
3892         }
3893       else
3894         t = &tok[tokidx++];
3895
3896       /* Regardless if we have a reloc or not mark the instruction
3897          limm if it is the case.  */
3898       if (operand->flags & ARC_OPERAND_LIMM)
3899         insn->has_limm = TRUE;
3900
3901       switch (t->X_op)
3902         {
3903         case O_register:
3904           image = insert_operand (image, operand, regno (t->X_add_number),
3905                                   NULL, 0);
3906           break;
3907
3908         case O_constant:
3909           image = insert_operand (image, operand, t->X_add_number, NULL, 0);
3910           reloc_exp = t;
3911           if (operand->flags & ARC_OPERAND_LIMM)
3912             insn->limm = t->X_add_number;
3913           break;
3914
3915         case O_bracket:
3916         case O_colon:
3917         case O_addrtype:
3918           /* Ignore brackets, colons, and address types.  */
3919           break;
3920
3921         case O_absent:
3922           gas_assert (operand->flags & ARC_OPERAND_IGNORE);
3923           break;
3924
3925         case O_subtract:
3926           /* Maybe register range.  */
3927           if ((t->X_add_number == 0)
3928               && contains_register (t->X_add_symbol)
3929               && contains_register (t->X_op_symbol))
3930             {
3931               int regs;
3932
3933               regs = get_register (t->X_add_symbol);
3934               regs <<= 16;
3935               regs |= get_register (t->X_op_symbol);
3936               image = insert_operand (image, operand, regs, NULL, 0);
3937               break;
3938             }
3939           /* Fall through.  */
3940
3941         default:
3942           /* This operand needs a relocation.  */
3943           needGOTSymbol = FALSE;
3944
3945           switch (t->X_md)
3946             {
3947             case O_plt:
3948               if (opcode->insn_class == JUMP)
3949                 as_bad (_("Unable to use @plt relocation for insn %s"),
3950                         opcode->name);
3951               needGOTSymbol = TRUE;
3952               reloc = find_reloc ("plt", opcode->name,
3953                                   pflags, nflg,
3954                                   operand->default_reloc);
3955               break;
3956
3957             case O_gotoff:
3958             case O_gotpc:
3959               needGOTSymbol = TRUE;
3960               reloc = ARC_RELOC_TABLE (t->X_md)->reloc;
3961               break;
3962             case O_pcl:
3963               if (operand->flags & ARC_OPERAND_LIMM)
3964                 {
3965                   reloc = ARC_RELOC_TABLE (t->X_md)->reloc;
3966                   if (arc_opcode_len (opcode) == 2
3967                       || opcode->insn_class == JUMP)
3968                     as_bad (_("Unable to use @pcl relocation for insn %s"),
3969                             opcode->name);
3970                 }
3971               else
3972                 {
3973                   /* This is a relaxed operand which initially was
3974                      limm, choose whatever we have defined in the
3975                      opcode as reloc.  */
3976                   reloc = operand->default_reloc;
3977                 }
3978               break;
3979             case O_sda:
3980               reloc = find_reloc ("sda", opcode->name,
3981                                   pflags, nflg,
3982                                   operand->default_reloc);
3983               break;
3984             case O_tlsgd:
3985             case O_tlsie:
3986               needGOTSymbol = TRUE;
3987               /* Fall-through.  */
3988
3989             case O_tpoff:
3990             case O_dtpoff:
3991               reloc = ARC_RELOC_TABLE (t->X_md)->reloc;
3992               break;
3993
3994             case O_tpoff9: /*FIXME! Check for the conditionality of
3995                              the insn.  */
3996             case O_dtpoff9: /*FIXME! Check for the conditionality of
3997                               the insn.  */
3998               as_bad (_("TLS_*_S9 relocs are not supported yet"));
3999               break;
4000
4001             default:
4002               /* Just consider the default relocation.  */
4003               reloc = operand->default_reloc;
4004               break;
4005             }
4006
4007           if (needGOTSymbol && (GOT_symbol == NULL))
4008             GOT_symbol = symbol_find_or_make (GLOBAL_OFFSET_TABLE_NAME);
4009
4010           reloc_exp = t;
4011
4012 #if 0
4013           if (reloc > 0)
4014             {
4015               /* sanity checks.  */
4016               reloc_howto_type *reloc_howto
4017                 = bfd_reloc_type_lookup (stdoutput,
4018                                          (bfd_reloc_code_real_type) reloc);
4019               unsigned reloc_bitsize = reloc_howto->bitsize;
4020               if (reloc_howto->rightshift)
4021                 reloc_bitsize -= reloc_howto->rightshift;
4022               if (reloc_bitsize != operand->bits)
4023                 {
4024                   as_bad (_("invalid relocation %s for field"),
4025                           bfd_get_reloc_code_name (reloc));
4026                   return;
4027                 }
4028             }
4029 #endif
4030           if (insn->nfixups >= MAX_INSN_FIXUPS)
4031             as_fatal (_("too many fixups"));
4032
4033           struct arc_fixup *fixup;
4034           fixup = &insn->fixups[insn->nfixups++];
4035           fixup->exp = *t;
4036           fixup->reloc = reloc;
4037           if ((int) reloc < 0)
4038             pcrel = (operand->flags & ARC_OPERAND_PCREL) ? 1 : 0;
4039           else
4040             {
4041               reloc_howto_type *reloc_howto =
4042                 bfd_reloc_type_lookup (stdoutput,
4043                                        (bfd_reloc_code_real_type) fixup->reloc);
4044               pcrel = reloc_howto->pc_relative;
4045             }
4046           fixup->pcrel = pcrel;
4047           fixup->islong = (operand->flags & ARC_OPERAND_LIMM) ?
4048             TRUE : FALSE;
4049           break;
4050         }
4051     }
4052
4053   /* Handle flags.  */
4054   for (i = 0; i < nflg; i++)
4055     {
4056       const struct arc_flag_operand *flg_operand = pflags[i].flgp;
4057
4058       /* Check if the instruction has a delay slot.  */
4059       if (!strcmp (flg_operand->name, "d"))
4060         has_delay_slot = TRUE;
4061
4062       /* There is an exceptional case when we cannot insert a flag just as
4063          it is.  On ARCv2 the '.t' and '.nt' flags must be handled in
4064          relation with the relative address.  Unfortunately, some of the
4065          ARC700 extensions (NPS400) also have a '.nt' flag that should be
4066          handled in the normal way.
4067
4068          Flag operands don't have an architecture field, so we can't
4069          directly validate that FLAG_OPERAND is valid for the current
4070          architecture, what we do instead is just validate that we're
4071          assembling for an ARCv2 architecture.  */
4072       if ((selected_cpu.flags & ARC_OPCODE_ARCV2)
4073           && (!strcmp (flg_operand->name, "t")
4074               || !strcmp (flg_operand->name, "nt")))
4075         {
4076           unsigned bitYoperand = 0;
4077           /* FIXME! move selection bbit/brcc in arc-opc.c.  */
4078           if (!strcmp (flg_operand->name, "t"))
4079             if (!strcmp (opcode->name, "bbit0")
4080                 || !strcmp (opcode->name, "bbit1"))
4081               bitYoperand = arc_NToperand;
4082             else
4083               bitYoperand = arc_Toperand;
4084           else
4085             if (!strcmp (opcode->name, "bbit0")
4086                 || !strcmp (opcode->name, "bbit1"))
4087               bitYoperand = arc_Toperand;
4088             else
4089               bitYoperand = arc_NToperand;
4090
4091           gas_assert (reloc_exp != NULL);
4092           if (reloc_exp->X_op == O_constant)
4093             {
4094               /* Check if we have a constant and solved it
4095                  immediately.  */
4096               offsetT val = reloc_exp->X_add_number;
4097               image |= insert_operand (image, &arc_operands[bitYoperand],
4098                                        val, NULL, 0);
4099             }
4100           else
4101             {
4102               struct arc_fixup *fixup;
4103
4104               if (insn->nfixups >= MAX_INSN_FIXUPS)
4105                 as_fatal (_("too many fixups"));
4106
4107               fixup = &insn->fixups[insn->nfixups++];
4108               fixup->exp = *reloc_exp;
4109               fixup->reloc = -bitYoperand;
4110               fixup->pcrel = pcrel;
4111               fixup->islong = FALSE;
4112             }
4113         }
4114       else
4115         image |= (flg_operand->code & ((1 << flg_operand->bits) - 1))
4116           << flg_operand->shift;
4117     }
4118
4119   insn->relax = relax_insn_p (opcode, tok, ntok, pflags, nflg);
4120
4121   /* Instruction length.  */
4122   insn->len = arc_opcode_len (opcode);
4123
4124   insn->insn = image;
4125
4126   /* Update last insn status.  */
4127   arc_last_insns[1]                = arc_last_insns[0];
4128   arc_last_insns[0].opcode         = opcode;
4129   arc_last_insns[0].has_limm       = insn->has_limm;
4130   arc_last_insns[0].has_delay_slot = has_delay_slot;
4131
4132   /* Check if the current instruction is legally used.  */
4133   if (arc_last_insns[1].has_delay_slot
4134       && is_br_jmp_insn_p (arc_last_insns[0].opcode))
4135     as_bad (_("Insn %s has a jump/branch instruction %s in its delay slot."),
4136             arc_last_insns[1].opcode->name,
4137             arc_last_insns[0].opcode->name);
4138   if (arc_last_insns[1].has_delay_slot
4139       && arc_last_insns[0].has_limm)
4140     as_bad (_("Insn %s has an instruction %s with limm in its delay slot."),
4141             arc_last_insns[1].opcode->name,
4142             arc_last_insns[0].opcode->name);
4143 }
4144
4145 void
4146 arc_handle_align (fragS* fragP)
4147 {
4148   if ((fragP)->fr_type == rs_align_code)
4149     {
4150       char *dest = (fragP)->fr_literal + (fragP)->fr_fix;
4151       valueT count = ((fragP)->fr_next->fr_address
4152                       - (fragP)->fr_address - (fragP)->fr_fix);
4153
4154       (fragP)->fr_var = 2;
4155
4156       if (count & 1)/* Padding in the gap till the next 2-byte
4157                        boundary with 0s.  */
4158         {
4159           (fragP)->fr_fix++;
4160           *dest++ = 0;
4161         }
4162       /* Writing nop_s.  */
4163       md_number_to_chars (dest, NOP_OPCODE_S, 2);
4164     }
4165 }
4166
4167 /* Here we decide which fixups can be adjusted to make them relative
4168    to the beginning of the section instead of the symbol.  Basically
4169    we need to make sure that the dynamic relocations are done
4170    correctly, so in some cases we force the original symbol to be
4171    used.  */
4172
4173 int
4174 tc_arc_fix_adjustable (fixS *fixP)
4175 {
4176
4177   /* Prevent all adjustments to global symbols.  */
4178   if (S_IS_EXTERNAL (fixP->fx_addsy))
4179     return 0;
4180   if (S_IS_WEAK (fixP->fx_addsy))
4181     return 0;
4182
4183   /* Adjust_reloc_syms doesn't know about the GOT.  */
4184   switch (fixP->fx_r_type)
4185     {
4186     case BFD_RELOC_ARC_GOTPC32:
4187     case BFD_RELOC_ARC_PLT32:
4188     case BFD_RELOC_ARC_S25H_PCREL_PLT:
4189     case BFD_RELOC_ARC_S21H_PCREL_PLT:
4190     case BFD_RELOC_ARC_S25W_PCREL_PLT:
4191     case BFD_RELOC_ARC_S21W_PCREL_PLT:
4192       return 0;
4193
4194     default:
4195       break;
4196     }
4197
4198   return 1;
4199 }
4200
4201 /* Compute the reloc type of an expression EXP.  */
4202
4203 static void
4204 arc_check_reloc (expressionS *exp,
4205                  bfd_reloc_code_real_type *r_type_p)
4206 {
4207   if (*r_type_p == BFD_RELOC_32
4208       && exp->X_op == O_subtract
4209       && exp->X_op_symbol != NULL
4210       && S_GET_SEGMENT (exp->X_op_symbol) == now_seg)
4211     *r_type_p = BFD_RELOC_ARC_32_PCREL;
4212 }
4213
4214
4215 /* Add expression EXP of SIZE bytes to offset OFF of fragment FRAG.  */
4216
4217 void
4218 arc_cons_fix_new (fragS *frag,
4219                   int off,
4220                   int size,
4221                   expressionS *exp,
4222                   bfd_reloc_code_real_type r_type)
4223 {
4224   r_type = BFD_RELOC_UNUSED;
4225
4226   switch (size)
4227     {
4228     case 1:
4229       r_type = BFD_RELOC_8;
4230       break;
4231
4232     case 2:
4233       r_type = BFD_RELOC_16;
4234       break;
4235
4236     case 3:
4237       r_type = BFD_RELOC_24;
4238       break;
4239
4240     case 4:
4241       r_type = BFD_RELOC_32;
4242       arc_check_reloc (exp, &r_type);
4243       break;
4244
4245     case 8:
4246       r_type = BFD_RELOC_64;
4247       break;
4248
4249     default:
4250       as_bad (_("unsupported BFD relocation size %u"), size);
4251       r_type = BFD_RELOC_UNUSED;
4252     }
4253
4254   fix_new_exp (frag, off, size, exp, 0, r_type);
4255 }
4256
4257 /* The actual routine that checks the ZOL conditions.  */
4258
4259 static void
4260 check_zol (symbolS *s)
4261 {
4262   switch (selected_cpu.mach)
4263     {
4264     case bfd_mach_arc_arcv2:
4265       if (selected_cpu.flags & ARC_OPCODE_ARCv2EM)
4266         return;
4267
4268       if (is_br_jmp_insn_p (arc_last_insns[0].opcode)
4269           || arc_last_insns[1].has_delay_slot)
4270         as_bad (_("Jump/Branch instruction detected at the end of the ZOL label @%s"),
4271                 S_GET_NAME (s));
4272
4273       break;
4274     case bfd_mach_arc_arc600:
4275
4276       if (is_kernel_insn_p (arc_last_insns[0].opcode))
4277         as_bad (_("Kernel instruction detected at the end of the ZOL label @%s"),
4278                 S_GET_NAME (s));
4279
4280       if (arc_last_insns[0].has_limm
4281           && is_br_jmp_insn_p (arc_last_insns[0].opcode))
4282         as_bad (_("A jump instruction with long immediate detected at the \
4283 end of the ZOL label @%s"), S_GET_NAME (s));
4284
4285       /* Fall through.  */
4286     case bfd_mach_arc_arc700:
4287       if (arc_last_insns[0].has_delay_slot)
4288         as_bad (_("An illegal use of delay slot detected at the end of the ZOL label @%s"),
4289                 S_GET_NAME (s));
4290
4291       break;
4292     default:
4293       break;
4294     }
4295 }
4296
4297 /* If ZOL end check the last two instruction for illegals.  */
4298 void
4299 arc_frob_label (symbolS * sym)
4300 {
4301   if (ARC_GET_FLAG (sym) & ARC_FLAG_ZOL)
4302     check_zol (sym);
4303
4304   dwarf2_emit_label (sym);
4305 }
4306
4307 /* Used because generic relaxation assumes a pc-rel value whilst we
4308    also relax instructions that use an absolute value resolved out of
4309    relative values (if that makes any sense).  An example: 'add r1,
4310    r2, @.L2 - .'  The symbols . and @.L2 are relative to the section
4311    but if they're in the same section we can subtract the section
4312    offset relocation which ends up in a resolved value.  So if @.L2 is
4313    .text + 0x50 and . is .text + 0x10, we can say that .text + 0x50 -
4314    .text + 0x40 = 0x10.  */
4315 int
4316 arc_pcrel_adjust (fragS *fragP)
4317 {
4318   pr_debug ("arc_pcrel_adjust: address=%ld, fix=%ld, PCrel %s\n",
4319             fragP->fr_address, fragP->fr_fix,
4320             fragP->tc_frag_data.pcrel ? "Y" : "N");
4321
4322   if (!fragP->tc_frag_data.pcrel)
4323     return fragP->fr_address + fragP->fr_fix;
4324
4325   /* Take into account the PCL rounding.  */
4326   return (fragP->fr_address + fragP->fr_fix) & 0x03;
4327 }
4328
4329 /* Initialize the DWARF-2 unwind information for this procedure.  */
4330
4331 void
4332 tc_arc_frame_initial_instructions (void)
4333 {
4334   /* Stack pointer is register 28.  */
4335   cfi_add_CFA_def_cfa (28, 0);
4336 }
4337
4338 int
4339 tc_arc_regname_to_dw2regnum (char *regname)
4340 {
4341   struct symbol *sym;
4342
4343   sym = hash_find (arc_reg_hash, regname);
4344   if (sym)
4345     return S_GET_VALUE (sym);
4346
4347   return -1;
4348 }
4349
4350 /* Adjust the symbol table.  Delete found AUX register symbols.  */
4351
4352 void
4353 arc_adjust_symtab (void)
4354 {
4355   symbolS * sym;
4356
4357   for (sym = symbol_rootP; sym != NULL; sym = symbol_next (sym))
4358     {
4359       /* I've created a symbol during parsing process.  Now, remove
4360          the symbol as it is found to be an AUX register.  */
4361       if (ARC_GET_FLAG (sym) & ARC_FLAG_AUX)
4362         symbol_remove (sym, &symbol_rootP, &symbol_lastP);
4363     }
4364
4365   /* Now do generic ELF adjustments.  */
4366   elf_adjust_symtab ();
4367 }
4368
4369 static void
4370 tokenize_extinsn (extInstruction_t *einsn)
4371 {
4372   char *p, c;
4373   char *insn_name;
4374   unsigned char major_opcode;
4375   unsigned char sub_opcode;
4376   unsigned char syntax_class = 0;
4377   unsigned char syntax_class_modifiers = 0;
4378   unsigned char suffix_class = 0;
4379   unsigned int i;
4380
4381   SKIP_WHITESPACE ();
4382
4383   /* 1st: get instruction name.  */
4384   p = input_line_pointer;
4385   c = get_symbol_name (&p);
4386
4387   insn_name = xstrdup (p);
4388   restore_line_pointer (c);
4389
4390   /* Convert to lower case.  */
4391   for (p = insn_name; *p; ++p)
4392     *p = TOLOWER (*p);
4393
4394   /* 2nd: get major opcode.  */
4395   if (*input_line_pointer != ',')
4396     {
4397       as_bad (_("expected comma after instruction name"));
4398       ignore_rest_of_line ();
4399       return;
4400     }
4401   input_line_pointer++;
4402   major_opcode = get_absolute_expression ();
4403
4404   /* 3rd: get sub-opcode.  */
4405   SKIP_WHITESPACE ();
4406
4407   if (*input_line_pointer != ',')
4408     {
4409       as_bad (_("expected comma after major opcode"));
4410       ignore_rest_of_line ();
4411       return;
4412     }
4413   input_line_pointer++;
4414   sub_opcode = get_absolute_expression ();
4415
4416   /* 4th: get suffix class.  */
4417   SKIP_WHITESPACE ();
4418
4419   if (*input_line_pointer != ',')
4420     {
4421       as_bad ("expected comma after sub opcode");
4422       ignore_rest_of_line ();
4423       return;
4424     }
4425   input_line_pointer++;
4426
4427   while (1)
4428     {
4429       SKIP_WHITESPACE ();
4430
4431       for (i = 0; i < ARRAY_SIZE (suffixclass); i++)
4432         {
4433           if (!strncmp (suffixclass[i].name, input_line_pointer,
4434                         suffixclass[i].len))
4435             {
4436               suffix_class |= suffixclass[i].attr_class;
4437               input_line_pointer += suffixclass[i].len;
4438               break;
4439             }
4440         }
4441
4442       if (i == ARRAY_SIZE (suffixclass))
4443         {
4444           as_bad ("invalid suffix class");
4445           ignore_rest_of_line ();
4446           return;
4447         }
4448
4449       SKIP_WHITESPACE ();
4450
4451       if (*input_line_pointer == '|')
4452         input_line_pointer++;
4453       else
4454         break;
4455     }
4456
4457   /* 5th: get syntax class and syntax class modifiers.  */
4458   if (*input_line_pointer != ',')
4459     {
4460       as_bad ("expected comma after suffix class");
4461       ignore_rest_of_line ();
4462       return;
4463     }
4464   input_line_pointer++;
4465
4466   while (1)
4467     {
4468       SKIP_WHITESPACE ();
4469
4470       for (i = 0; i < ARRAY_SIZE (syntaxclassmod); i++)
4471         {
4472           if (!strncmp (syntaxclassmod[i].name,
4473                         input_line_pointer,
4474                         syntaxclassmod[i].len))
4475             {
4476               syntax_class_modifiers |= syntaxclassmod[i].attr_class;
4477               input_line_pointer += syntaxclassmod[i].len;
4478               break;
4479             }
4480         }
4481
4482       if (i == ARRAY_SIZE (syntaxclassmod))
4483         {
4484           for (i = 0; i < ARRAY_SIZE (syntaxclass); i++)
4485             {
4486               if (!strncmp (syntaxclass[i].name,
4487                             input_line_pointer,
4488                             syntaxclass[i].len))
4489                 {
4490                   syntax_class |= syntaxclass[i].attr_class;
4491                   input_line_pointer += syntaxclass[i].len;
4492                   break;
4493                 }
4494             }
4495
4496           if (i == ARRAY_SIZE (syntaxclass))
4497             {
4498               as_bad ("missing syntax class");
4499               ignore_rest_of_line ();
4500               return;
4501             }
4502         }
4503
4504       SKIP_WHITESPACE ();
4505
4506       if (*input_line_pointer == '|')
4507         input_line_pointer++;
4508       else
4509         break;
4510     }
4511
4512   demand_empty_rest_of_line ();
4513
4514   einsn->name   = insn_name;
4515   einsn->major  = major_opcode;
4516   einsn->minor  = sub_opcode;
4517   einsn->syntax = syntax_class;
4518   einsn->modsyn = syntax_class_modifiers;
4519   einsn->suffix = suffix_class;
4520   einsn->flags  = syntax_class
4521     | (syntax_class_modifiers & ARC_OP1_IMM_IMPLIED ? 0x10 : 0);
4522 }
4523
4524 /* Generate an extension section.  */
4525
4526 static int
4527 arc_set_ext_seg (void)
4528 {
4529   if (!arcext_section)
4530     {
4531       arcext_section = subseg_new (".arcextmap", 0);
4532       bfd_set_section_flags (stdoutput, arcext_section,
4533                              SEC_READONLY | SEC_HAS_CONTENTS);
4534     }
4535   else
4536     subseg_set (arcext_section, 0);
4537   return 1;
4538 }
4539
4540 /* Create an extension instruction description in the arc extension
4541    section of the output file.
4542    The structure for an instruction is like this:
4543    [0]: Length of the record.
4544    [1]: Type of the record.
4545
4546    [2]: Major opcode.
4547    [3]: Sub-opcode.
4548    [4]: Syntax (flags).
4549    [5]+ Name instruction.
4550
4551    The sequence is terminated by an empty entry.  */
4552
4553 static void
4554 create_extinst_section (extInstruction_t *einsn)
4555 {
4556
4557   segT old_sec    = now_seg;
4558   int old_subsec  = now_subseg;
4559   char *p;
4560   int name_len    = strlen (einsn->name);
4561
4562   arc_set_ext_seg ();
4563
4564   p = frag_more (1);
4565   *p = 5 + name_len + 1;
4566   p = frag_more (1);
4567   *p = EXT_INSTRUCTION;
4568   p = frag_more (1);
4569   *p = einsn->major;
4570   p = frag_more (1);
4571   *p = einsn->minor;
4572   p = frag_more (1);
4573   *p = einsn->flags;
4574   p = frag_more (name_len + 1);
4575   strcpy (p, einsn->name);
4576
4577   subseg_set (old_sec, old_subsec);
4578 }
4579
4580 /* Handler .extinstruction pseudo-op.  */
4581
4582 static void
4583 arc_extinsn (int ignore ATTRIBUTE_UNUSED)
4584 {
4585   extInstruction_t einsn;
4586   struct arc_opcode *arc_ext_opcodes;
4587   const char *errmsg = NULL;
4588   unsigned char moplow, mophigh;
4589
4590   memset (&einsn, 0, sizeof (einsn));
4591   tokenize_extinsn (&einsn);
4592
4593   /* Check if the name is already used.  */
4594   if (arc_find_opcode (einsn.name))
4595     as_warn (_("Pseudocode already used %s"), einsn.name);
4596
4597   /* Check the opcode ranges.  */
4598   moplow = 0x05;
4599   mophigh = (selected_cpu.flags & (ARC_OPCODE_ARCv2EM
4600                                    | ARC_OPCODE_ARCv2HS)) ? 0x07 : 0x0a;
4601
4602   if ((einsn.major > mophigh) || (einsn.major < moplow))
4603     as_fatal (_("major opcode not in range [0x%02x - 0x%02x]"), moplow, mophigh);
4604
4605   if ((einsn.minor > 0x3f) && (einsn.major != 0x0a)
4606       && (einsn.major != 5) && (einsn.major != 9))
4607     as_fatal (_("minor opcode not in range [0x00 - 0x3f]"));
4608
4609   switch (einsn.syntax & ARC_SYNTAX_MASK)
4610     {
4611     case ARC_SYNTAX_3OP:
4612       if (einsn.modsyn & ARC_OP1_IMM_IMPLIED)
4613         as_fatal (_("Improper use of OP1_IMM_IMPLIED"));
4614       break;
4615     case ARC_SYNTAX_2OP:
4616     case ARC_SYNTAX_1OP:
4617     case ARC_SYNTAX_NOP:
4618       if (einsn.modsyn & ARC_OP1_MUST_BE_IMM)
4619         as_fatal (_("Improper use of OP1_MUST_BE_IMM"));
4620       break;
4621     default:
4622       break;
4623     }
4624
4625   arc_ext_opcodes = arcExtMap_genOpcode (&einsn, selected_cpu.flags, &errmsg);
4626   if (arc_ext_opcodes == NULL)
4627     {
4628       if (errmsg)
4629         as_fatal ("%s", errmsg);
4630       else
4631         as_fatal (_("Couldn't generate extension instruction opcodes"));
4632     }
4633   else if (errmsg)
4634     as_warn ("%s", errmsg);
4635
4636   /* Insert the extension instruction.  */
4637   arc_insert_opcode ((const struct arc_opcode *) arc_ext_opcodes);
4638
4639   create_extinst_section (&einsn);
4640 }
4641
4642 static bfd_boolean
4643 tokenize_extregister (extRegister_t *ereg, int opertype)
4644 {
4645   char *name;
4646   char *mode;
4647   char c;
4648   char *p;
4649   int number, imode = 0;
4650   bfd_boolean isCore_p = (opertype == EXT_CORE_REGISTER) ? TRUE : FALSE;
4651   bfd_boolean isReg_p  = (opertype == EXT_CORE_REGISTER
4652                           || opertype == EXT_AUX_REGISTER) ? TRUE : FALSE;
4653
4654   /* 1st: get register name.  */
4655   SKIP_WHITESPACE ();
4656   p = input_line_pointer;
4657   c = get_symbol_name (&p);
4658
4659   name = xstrdup (p);
4660   restore_line_pointer (c);
4661
4662   /* 2nd: get register number.  */
4663   SKIP_WHITESPACE ();
4664
4665   if (*input_line_pointer != ',')
4666     {
4667       as_bad (_("expected comma after name"));
4668       ignore_rest_of_line ();
4669       free (name);
4670       return FALSE;
4671     }
4672   input_line_pointer++;
4673   number = get_absolute_expression ();
4674
4675   if ((number < 0)
4676       && (opertype != EXT_AUX_REGISTER))
4677     {
4678       as_bad (_("%s second argument cannot be a negative number %d"),
4679               isCore_p ? "extCoreRegister's" : "extCondCode's",
4680               number);
4681       ignore_rest_of_line ();
4682       free (name);
4683       return FALSE;
4684     }
4685
4686   if (isReg_p)
4687     {
4688       /* 3rd: get register mode.  */
4689       SKIP_WHITESPACE ();
4690
4691       if (*input_line_pointer != ',')
4692         {
4693           as_bad (_("expected comma after register number"));
4694           ignore_rest_of_line ();
4695           free (name);
4696           return FALSE;
4697         }
4698
4699       input_line_pointer++;
4700       mode = input_line_pointer;
4701
4702       if (!strncmp (mode, "r|w", 3))
4703         {
4704           imode = 0;
4705           input_line_pointer += 3;
4706         }
4707       else if (!strncmp (mode, "r", 1))
4708         {
4709           imode = ARC_REGISTER_READONLY;
4710           input_line_pointer += 1;
4711         }
4712       else if (strncmp (mode, "w", 1))
4713         {
4714           as_bad (_("invalid mode"));
4715           ignore_rest_of_line ();
4716           free (name);
4717           return FALSE;
4718         }
4719       else
4720         {
4721           imode = ARC_REGISTER_WRITEONLY;
4722           input_line_pointer += 1;
4723         }
4724     }
4725
4726   if (isCore_p)
4727     {
4728       /* 4th: get core register shortcut.  */
4729       SKIP_WHITESPACE ();
4730       if (*input_line_pointer != ',')
4731         {
4732           as_bad (_("expected comma after register mode"));
4733           ignore_rest_of_line ();
4734           free (name);
4735           return FALSE;
4736         }
4737
4738       input_line_pointer++;
4739
4740       if (!strncmp (input_line_pointer, "cannot_shortcut", 15))
4741         {
4742           imode |= ARC_REGISTER_NOSHORT_CUT;
4743           input_line_pointer += 15;
4744         }
4745       else if (strncmp (input_line_pointer, "can_shortcut", 12))
4746         {
4747           as_bad (_("shortcut designator invalid"));
4748           ignore_rest_of_line ();
4749           free (name);
4750           return FALSE;
4751         }
4752       else
4753         {
4754           input_line_pointer += 12;
4755         }
4756     }
4757   demand_empty_rest_of_line ();
4758
4759   ereg->name = name;
4760   ereg->number = number;
4761   ereg->imode  = imode;
4762   return TRUE;
4763 }
4764
4765 /* Create an extension register/condition description in the arc
4766    extension section of the output file.
4767
4768    The structure for an instruction is like this:
4769    [0]: Length of the record.
4770    [1]: Type of the record.
4771
4772    For core regs and condition codes:
4773    [2]: Value.
4774    [3]+ Name.
4775
4776    For auxiliary registers:
4777    [2..5]: Value.
4778    [6]+ Name
4779
4780    The sequence is terminated by an empty entry.  */
4781
4782 static void
4783 create_extcore_section (extRegister_t *ereg, int opertype)
4784 {
4785   segT old_sec   = now_seg;
4786   int old_subsec = now_subseg;
4787   char *p;
4788   int name_len   = strlen (ereg->name);
4789
4790   arc_set_ext_seg ();
4791
4792   switch (opertype)
4793     {
4794     case EXT_COND_CODE:
4795     case EXT_CORE_REGISTER:
4796       p = frag_more (1);
4797       *p = 3 + name_len + 1;
4798       p = frag_more (1);
4799       *p = opertype;
4800       p = frag_more (1);
4801       *p = ereg->number;
4802       break;
4803     case EXT_AUX_REGISTER:
4804       p = frag_more (1);
4805       *p = 6 + name_len + 1;
4806       p = frag_more (1);
4807       *p = EXT_AUX_REGISTER;
4808       p = frag_more (1);
4809       *p = (ereg->number >> 24) & 0xff;
4810       p = frag_more (1);
4811       *p = (ereg->number >> 16) & 0xff;
4812       p = frag_more (1);
4813       *p = (ereg->number >>  8) & 0xff;
4814       p = frag_more (1);
4815       *p = (ereg->number)       & 0xff;
4816       break;
4817     default:
4818       break;
4819     }
4820
4821   p = frag_more (name_len + 1);
4822   strcpy (p, ereg->name);
4823
4824   subseg_set (old_sec, old_subsec);
4825 }
4826
4827 /* Handler .extCoreRegister pseudo-op.  */
4828
4829 static void
4830 arc_extcorereg (int opertype)
4831 {
4832   extRegister_t ereg;
4833   struct arc_aux_reg *auxr;
4834   const char *retval;
4835   struct arc_flag_operand *ccode;
4836
4837   memset (&ereg, 0, sizeof (ereg));
4838   if (!tokenize_extregister (&ereg, opertype))
4839     return;
4840
4841   switch (opertype)
4842     {
4843     case EXT_CORE_REGISTER:
4844       /* Core register.  */
4845       if (ereg.number > 60)
4846         as_bad (_("core register %s value (%d) too large"), ereg.name,
4847                 ereg.number);
4848       declare_register (ereg.name, ereg.number);
4849       break;
4850     case EXT_AUX_REGISTER:
4851       /* Auxiliary register.  */
4852       auxr = XNEW (struct arc_aux_reg);
4853       auxr->name = ereg.name;
4854       auxr->cpu = selected_cpu.flags;
4855       auxr->subclass = NONE;
4856       auxr->address = ereg.number;
4857       retval = hash_insert (arc_aux_hash, auxr->name, (void *) auxr);
4858       if (retval)
4859         as_fatal (_("internal error: can't hash aux register '%s': %s"),
4860                   auxr->name, retval);
4861       break;
4862     case EXT_COND_CODE:
4863       /* Condition code.  */
4864       if (ereg.number > 31)
4865         as_bad (_("condition code %s value (%d) too large"), ereg.name,
4866                 ereg.number);
4867       ext_condcode.size ++;
4868       ext_condcode.arc_ext_condcode =
4869         XRESIZEVEC (struct arc_flag_operand, ext_condcode.arc_ext_condcode,
4870                     ext_condcode.size + 1);
4871       if (ext_condcode.arc_ext_condcode == NULL)
4872         as_fatal (_("Virtual memory exhausted"));
4873
4874       ccode = ext_condcode.arc_ext_condcode + ext_condcode.size - 1;
4875       ccode->name   = ereg.name;
4876       ccode->code   = ereg.number;
4877       ccode->bits   = 5;
4878       ccode->shift  = 0;
4879       ccode->favail = 0; /* not used.  */
4880       ccode++;
4881       memset (ccode, 0, sizeof (struct arc_flag_operand));
4882       break;
4883     default:
4884       as_bad (_("Unknown extension"));
4885       break;
4886     }
4887   create_extcore_section (&ereg, opertype);
4888 }
4889
4890 /* Parse a .arc_attribute directive.  */
4891
4892 static void
4893 arc_attribute (int ignored ATTRIBUTE_UNUSED)
4894 {
4895   int tag = obj_elf_vendor_attribute (OBJ_ATTR_PROC);
4896
4897   if (tag < NUM_KNOWN_OBJ_ATTRIBUTES)
4898     attributes_set_explicitly[tag] = TRUE;
4899 }
4900
4901 /* Set an attribute if it has not already been set by the user.  */
4902
4903 static void
4904 arc_set_attribute_int (int tag, int value)
4905 {
4906   if (tag < 1
4907       || tag >= NUM_KNOWN_OBJ_ATTRIBUTES
4908       || !attributes_set_explicitly[tag])
4909     bfd_elf_add_proc_attr_int (stdoutput, tag, value);
4910 }
4911
4912 static void
4913 arc_set_attribute_string (int tag, const char *value)
4914 {
4915   if (tag < 1
4916       || tag >= NUM_KNOWN_OBJ_ATTRIBUTES
4917       || !attributes_set_explicitly[tag])
4918     bfd_elf_add_proc_attr_string (stdoutput, tag, value);
4919 }
4920
4921 /* Allocate and concatenate two strings.  s1 can be NULL but not
4922    s2.  s1 pointer is freed at end of this procedure.  */
4923
4924 static char *
4925 arc_stralloc (char * s1, const char * s2)
4926 {
4927   char * p;
4928   int len = 0;
4929
4930   if (s1)
4931     len = strlen (s1) + 1;
4932
4933   /* Only s1 can be null.  */
4934   gas_assert (s2);
4935   len += strlen (s2) + 1;
4936
4937   p = (char *) xmalloc (len);
4938   if (p == NULL)
4939     as_fatal (_("Virtual memory exhausted"));
4940
4941   if (s1)
4942     {
4943       strcpy (p, s1);
4944       strcat (p, ",");
4945       strcat (p, s2);
4946       free (s1);
4947     }
4948   else
4949     strcpy (p, s2);
4950
4951   return p;
4952 }
4953
4954 /* Set the public ARC object attributes.  */
4955
4956 static void
4957 arc_set_public_attributes (void)
4958 {
4959   int base = 0;
4960   char *s = NULL;
4961   unsigned int i;
4962
4963   /* Tag_ARC_CPU_name.  */
4964   arc_set_attribute_string (Tag_ARC_CPU_name, selected_cpu.name);
4965
4966   /* Tag_ARC_CPU_base.  */
4967   switch (selected_cpu.eflags & EF_ARC_MACH_MSK)
4968     {
4969     case E_ARC_MACH_ARC600:
4970     case E_ARC_MACH_ARC601:
4971       base = TAG_CPU_ARC6xx;
4972       break;
4973     case E_ARC_MACH_ARC700:
4974       base = TAG_CPU_ARC7xx;
4975       break;
4976     case EF_ARC_CPU_ARCV2EM:
4977       base = TAG_CPU_ARCEM;
4978       break;
4979     case EF_ARC_CPU_ARCV2HS:
4980       base = TAG_CPU_ARCHS;
4981       break;
4982     default:
4983       base = 0;
4984       break;
4985     }
4986   if (attributes_set_explicitly[Tag_ARC_CPU_base]
4987       && (base != bfd_elf_get_obj_attr_int (stdoutput, OBJ_ATTR_PROC,
4988                                             Tag_ARC_CPU_base)))
4989     as_warn (_("Overwrite explicitly set Tag_ARC_CPU_base"));
4990   bfd_elf_add_proc_attr_int (stdoutput, Tag_ARC_CPU_base, base);
4991
4992   /* Tag_ARC_ABI_osver.  */
4993   if (attributes_set_explicitly[Tag_ARC_ABI_osver])
4994     {
4995       int val = bfd_elf_get_obj_attr_int (stdoutput, OBJ_ATTR_PROC,
4996                                           Tag_ARC_ABI_osver);
4997
4998       selected_cpu.eflags = ((selected_cpu.eflags & ~EF_ARC_OSABI_MSK)
4999                              | (val & 0x0f << 8));
5000     }
5001   else
5002     {
5003       arc_set_attribute_int (Tag_ARC_ABI_osver, E_ARC_OSABI_CURRENT >> 8);
5004     }
5005
5006   /* Tag_ARC_ISA_config.  */
5007   arc_check_feature();
5008
5009   for (i = 0; i < ARRAY_SIZE (feature_list); i++)
5010     if (selected_cpu.features & feature_list[i].feature)
5011       s = arc_stralloc (s, feature_list[i].attr);
5012
5013   if (s)
5014     arc_set_attribute_string (Tag_ARC_ISA_config, s);
5015
5016   /* Tag_ARC_ISA_mpy_option.  */
5017   arc_set_attribute_int (Tag_ARC_ISA_mpy_option, mpy_option);
5018
5019   /* Tag_ARC_ABI_pic.  */
5020   arc_set_attribute_int (Tag_ARC_ABI_pic, pic_option);
5021
5022   /* Tag_ARC_ABI_sda.  */
5023   arc_set_attribute_int (Tag_ARC_ABI_sda, sda_option);
5024
5025   /* Tag_ARC_ABI_tls.  */
5026   arc_set_attribute_int (Tag_ARC_ABI_tls, tls_option);
5027
5028   /* Tag_ARC_ATR_version.  */
5029   arc_set_attribute_int (Tag_ARC_ATR_version, 1);
5030
5031   /* Tag_ARC_ABI_rf16.  */
5032   if (attributes_set_explicitly[Tag_ARC_ABI_rf16]
5033       && bfd_elf_get_obj_attr_int (stdoutput, OBJ_ATTR_PROC,
5034                                    Tag_ARC_ABI_rf16)
5035       && !rf16_only)
5036     {
5037       as_warn (_("Overwrite explicitly set Tag_ARC_ABI_rf16 to full "
5038                  "register file"));
5039       bfd_elf_add_proc_attr_int (stdoutput, Tag_ARC_ABI_rf16, 0);
5040     }
5041 }
5042
5043 /* Add the default contents for the .ARC.attributes section.  */
5044
5045 void
5046 arc_md_end (void)
5047 {
5048   arc_set_public_attributes ();
5049
5050   if (!bfd_set_arch_mach (stdoutput, bfd_arch_arc, selected_cpu.mach))
5051     as_fatal (_("could not set architecture and machine"));
5052
5053   bfd_set_private_flags (stdoutput, selected_cpu.eflags);
5054 }
5055
5056 void arc_copy_symbol_attributes (symbolS *dest, symbolS *src)
5057 {
5058   ARC_GET_FLAG (dest) = ARC_GET_FLAG (src);
5059 }
5060
5061 int arc_convert_symbolic_attribute (const char *name)
5062 {
5063   static const struct
5064   {
5065     const char * name;
5066     const int    tag;
5067   }
5068   attribute_table[] =
5069     {
5070 #define T(tag) {#tag, tag}
5071   T (Tag_ARC_PCS_config),
5072   T (Tag_ARC_CPU_base),
5073   T (Tag_ARC_CPU_variation),
5074   T (Tag_ARC_CPU_name),
5075   T (Tag_ARC_ABI_rf16),
5076   T (Tag_ARC_ABI_osver),
5077   T (Tag_ARC_ABI_sda),
5078   T (Tag_ARC_ABI_pic),
5079   T (Tag_ARC_ABI_tls),
5080   T (Tag_ARC_ABI_enumsize),
5081   T (Tag_ARC_ABI_exceptions),
5082   T (Tag_ARC_ABI_double_size),
5083   T (Tag_ARC_ISA_config),
5084   T (Tag_ARC_ISA_apex),
5085   T (Tag_ARC_ISA_mpy_option),
5086   T (Tag_ARC_ATR_version)
5087 #undef T
5088     };
5089   unsigned int i;
5090
5091   if (name == NULL)
5092     return -1;
5093
5094   for (i = 0; i < ARRAY_SIZE (attribute_table); i++)
5095     if (streq (name, attribute_table[i].name))
5096       return attribute_table[i].tag;
5097
5098   return -1;
5099 }
5100
5101 /* Local variables:
5102    eval: (c-set-style "gnu")
5103    indent-tabs-mode: t
5104    End:  */