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