gas/config/tc-arc.c

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