gas/config/tc-arc.c

   1 /* tc-arc.c -- Assembler for the ARC
   2    Copyright 1994, 1995, 1997, 1999, 2000, 2001, 2002, 2003, 2004, 2005
   3    Free Software Foundation, Inc.
   4    Contributed by Doug Evans ([email protected]).
   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 2, 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, 59 Temple Place - Suite 330, Boston, MA
  21    02111-1307, USA.  */
  22
  23 #include <stdio.h>
  24 #include "libiberty.h"
  25 #include "as.h"
  26 #include "struc-symbol.h"
  27 #include "safe-ctype.h"
  28 #include "subsegs.h"
  29 #include "opcode/arc.h"
  30 #include "../opcodes/arc-ext.h"
  31 #include "elf/arc.h"
  32 #include "dwarf2dbg.h"
  33
  34 extern int arc_get_mach PARAMS ((char *));
  35 extern int arc_operand_type PARAMS ((int));
  36 extern int arc_insn_not_jl PARAMS ((arc_insn));
  37 extern int arc_limm_fixup_adjust PARAMS ((arc_insn));
  38 extern int arc_get_noshortcut_flag PARAMS ((void));
  39 extern int arc_set_ext_seg PARAMS ((void));
  40 extern void arc_code_symbol PARAMS ((expressionS *));
  41
  42 static arc_insn arc_insert_operand PARAMS ((arc_insn,
  43                                             const struct arc_operand *, int,
  44                                             const struct arc_operand_value *,
  45                                             offsetT, char *, unsigned int));
  46 static void arc_common PARAMS ((int));
  47 static void arc_extinst PARAMS ((int));
  48 static void arc_extoper PARAMS ((int));
  49 static void arc_option PARAMS ((int));
  50 static int  get_arc_exp_reloc_type PARAMS ((int, int, expressionS *,
  51                                            expressionS *));
  52
  53 static void init_opcode_tables PARAMS ((int));
  54
  55 const struct suffix_classes {
  56   char *name;
  57   int  len;
  58 } suffixclass[] = {
  59   { "SUFFIX_COND|SUFFIX_FLAG",23 },
  60   { "SUFFIX_FLAG", 11 },
  61   { "SUFFIX_COND", 11 },
  62   { "SUFFIX_NONE", 11 }
  63 };
  64
  65 #define MAXSUFFIXCLASS (sizeof (suffixclass) / sizeof (struct suffix_classes))
  66
  67 const struct syntax_classes {
  68   char *name;
  69   int  len;
  70   int  class;
  71 } syntaxclass[] = {
  72   { "SYNTAX_3OP|OP1_MUST_BE_IMM", 26, SYNTAX_3OP|OP1_MUST_BE_IMM|SYNTAX_VALID },
  73   { "OP1_MUST_BE_IMM|SYNTAX_3OP", 26, OP1_MUST_BE_IMM|SYNTAX_3OP|SYNTAX_VALID },
  74   { "SYNTAX_2OP|OP1_IMM_IMPLIED", 26, SYNTAX_2OP|OP1_IMM_IMPLIED|SYNTAX_VALID },
  75   { "OP1_IMM_IMPLIED|SYNTAX_2OP", 26, OP1_IMM_IMPLIED|SYNTAX_2OP|SYNTAX_VALID },
  76   { "SYNTAX_3OP",                 10, SYNTAX_3OP|SYNTAX_VALID },
  77   { "SYNTAX_2OP",                 10, SYNTAX_2OP|SYNTAX_VALID }
  78 };
  79
  80 #define MAXSYNTAXCLASS (sizeof (syntaxclass) / sizeof (struct syntax_classes))
  81
  82 const pseudo_typeS md_pseudo_table[] = {
  83   { "align", s_align_bytes, 0 }, /* Defaulting is invalid (0).  */
  84   { "comm", arc_common, 0 },
  85   { "common", arc_common, 0 },
  86   { "lcomm", arc_common, 1 },
  87   { "lcommon", arc_common, 1 },
  88   { "2byte", cons, 2 },
  89   { "half", cons, 2 },
  90   { "short", cons, 2 },
  91   { "3byte", cons, 3 },
  92   { "4byte", cons, 4 },
  93   { "word", cons, 4 },
  94   { "option", arc_option, 0 },
  95   { "cpu", arc_option, 0 },
  96   { "block", s_space, 0 },
  97   { "extcondcode", arc_extoper, 0 },
  98   { "extcoreregister", arc_extoper, 1 },
  99   { "extauxregister", arc_extoper, 2 },
 100   { "extinstruction", arc_extinst, 0 },
 101   { NULL, 0, 0 },
 102 };
 103
 104 /* This array holds the chars that always start a comment.  If the
 105    pre-processor is disabled, these aren't very useful.  */
 106 const char comment_chars[] = "#;";
 107
 108 /* This array holds the chars that only start a comment at the beginning of
 109    a line.  If the line seems to have the form '# 123 filename'
 110    .line and .file directives will appear in the pre-processed output */
 111 /* Note that input_file.c hand checks for '#' at the beginning of the
 112    first line of the input file.  This is because the compiler outputs
 113    #NO_APP at the beginning of its output.  */
 114 /* Also note that comments started like this one will always
 115    work if '/' isn't otherwise defined.  */
 116 const char line_comment_chars[] = "#";
 117
 118 const char line_separator_chars[] = "";
 119
 120 /* Chars that can be used to separate mant from exp in floating point nums.  */
 121 const char EXP_CHARS[] = "eE";
 122
 123 /* Chars that mean this number is a floating point constant
 124    As in 0f12.456 or 0d1.2345e12.  */
 125 const char FLT_CHARS[] = "rRsSfFdD";
 126
 127 /* Byte order.  */
 128 extern int target_big_endian;
 129 const char *arc_target_format = DEFAULT_TARGET_FORMAT;
 130 static int byte_order = DEFAULT_BYTE_ORDER;
 131
 132 static segT arcext_section;
 133
 134 /* One of bfd_mach_arc_n.  */
 135 static int arc_mach_type = bfd_mach_arc_6;
 136
 137 /* Non-zero if the cpu type has been explicitly specified.  */
 138 static int mach_type_specified_p = 0;
 139
 140 /* Non-zero if opcode tables have been initialized.
 141    A .option command must appear before any instructions.  */
 142 static int cpu_tables_init_p = 0;
 143
 144 static struct hash_control *arc_suffix_hash = NULL;
 145 \f
 146 const char *md_shortopts = "";
 147 struct option md_longopts[] = {
 148 #define OPTION_EB (OPTION_MD_BASE + 0)
 149   { "EB", no_argument, NULL, OPTION_EB },
 150 #define OPTION_EL (OPTION_MD_BASE + 1)
 151   { "EL", no_argument, NULL, OPTION_EL },
 152 #define OPTION_ARC5 (OPTION_MD_BASE + 2)
 153   { "marc5", no_argument, NULL, OPTION_ARC5 },
 154   { "pre-v6", no_argument, NULL, OPTION_ARC5 },
 155 #define OPTION_ARC6 (OPTION_MD_BASE + 3)
 156   { "marc6", no_argument, NULL, OPTION_ARC6 },
 157 #define OPTION_ARC7 (OPTION_MD_BASE + 4)
 158   { "marc7", no_argument, NULL, OPTION_ARC7 },
 159 #define OPTION_ARC8 (OPTION_MD_BASE + 5)
 160   { "marc8", no_argument, NULL, OPTION_ARC8 },
 161 #define OPTION_ARC (OPTION_MD_BASE + 6)
 162   { "marc", no_argument, NULL, OPTION_ARC },
 163   { NULL, no_argument, NULL, 0 }
 164 };
 165 size_t md_longopts_size = sizeof (md_longopts);
 166
 167 #define IS_SYMBOL_OPERAND(o) \
 168  ((o) == 'b' || (o) == 'c' || (o) == 's' || (o) == 'o' || (o) == 'O')
 169
 170 struct arc_operand_value *get_ext_suffix (char *s);
 171
 172 /* Invocation line includes a switch not recognized by the base assembler.
 173    See if it's a processor-specific option.  */
 174
 175 int
 176 md_parse_option (c, arg)
 177      int c;
 178      char *arg ATTRIBUTE_UNUSED;
 179 {
 180   switch (c)
 181     {
 182     case OPTION_ARC5:
 183       arc_mach_type = bfd_mach_arc_5;
 184       break;
 185     case OPTION_ARC:
 186     case OPTION_ARC6:
 187       arc_mach_type = bfd_mach_arc_6;
 188       break;
 189     case OPTION_ARC7:
 190       arc_mach_type = bfd_mach_arc_7;
 191       break;
 192     case OPTION_ARC8:
 193       arc_mach_type = bfd_mach_arc_8;
 194       break;
 195     case OPTION_EB:
 196       byte_order = BIG_ENDIAN;
 197       arc_target_format = "elf32-bigarc";
 198       break;
 199     case OPTION_EL:
 200       byte_order = LITTLE_ENDIAN;
 201       arc_target_format = "elf32-littlearc";
 202       break;
 203     default:
 204       return 0;
 205     }
 206   return 1;
 207 }
 208
 209 void
 210 md_show_usage (stream)
 211      FILE *stream;
 212 {
 213   fprintf (stream, "\
 214 ARC Options:\n\
 215   -marc[5|6|7|8]          select processor variant (default arc%d)\n\
 216   -EB                     assemble code for a big endian cpu\n\
 217   -EL                     assemble code for a little endian cpu\n", arc_mach_type + 5);
 218 }
 219
 220 /* This function is called once, at assembler startup time.  It should
 221    set up all the tables, etc. that the MD part of the assembler will need.
 222    Opcode selection is deferred until later because we might see a .option
 223    command.  */
 224
 225 void
 226 md_begin ()
 227 {
 228   /* The endianness can be chosen "at the factory".  */
 229   target_big_endian = byte_order == BIG_ENDIAN;
 230
 231   if (!bfd_set_arch_mach (stdoutput, bfd_arch_arc, arc_mach_type))
 232     as_warn ("could not set architecture and machine");
 233
 234   /* This call is necessary because we need to initialize `arc_operand_map'
 235      which may be needed before we see the first insn.  */
 236   arc_opcode_init_tables (arc_get_opcode_mach (arc_mach_type,
 237                                                target_big_endian));
 238 }
 239
 240 /* Initialize the various opcode and operand tables.
 241    MACH is one of bfd_mach_arc_xxx.  */
 242 static void
 243 init_opcode_tables (mach)
 244      int mach;
 245 {
 246   int i;
 247   char *last;
 248
 249   if ((arc_suffix_hash = hash_new ()) == NULL)
 250     as_fatal ("virtual memory exhausted");
 251
 252   if (!bfd_set_arch_mach (stdoutput, bfd_arch_arc, mach))
 253     as_warn ("could not set architecture and machine");
 254
 255   /* This initializes a few things in arc-opc.c that we need.
 256      This must be called before the various arc_xxx_supported fns.  */
 257   arc_opcode_init_tables (arc_get_opcode_mach (mach, target_big_endian));
 258
 259   /* Only put the first entry of each equivalently named suffix in the
 260      table.  */
 261   last = "";
 262   for (i = 0; i < arc_suffixes_count; i++)
 263     {
 264       if (strcmp (arc_suffixes[i].name, last) != 0)
 265         hash_insert (arc_suffix_hash, arc_suffixes[i].name, (PTR) (arc_suffixes + i));
 266       last = arc_suffixes[i].name;
 267     }
 268
 269   /* Since registers don't have a prefix, we put them in the symbol table so
 270      they can't be used as symbols.  This also simplifies argument parsing as
 271      we can let gas parse registers for us.  The recorded register number is
 272      the address of the register's entry in arc_reg_names.
 273
 274      If the register name is already in the table, then the existing
 275      definition is assumed to be from an .ExtCoreRegister pseudo-op.  */
 276
 277   for (i = 0; i < arc_reg_names_count; i++)
 278     {
 279       if (symbol_find (arc_reg_names[i].name))
 280         continue;
 281       /* Use symbol_create here instead of symbol_new so we don't try to
 282          output registers into the object file's symbol table.  */
 283       symbol_table_insert (symbol_create (arc_reg_names[i].name,
 284                                           reg_section,
 285                                           (int) &arc_reg_names[i],
 286                                           &zero_address_frag));
 287     }
 288
 289   /* Tell `.option' it's too late.  */
 290   cpu_tables_init_p = 1;
 291 }
 292 \f
 293 /* Insert an operand value into an instruction.
 294    If REG is non-NULL, it is a register number and ignore VAL.  */
 295
 296 static arc_insn
 297 arc_insert_operand (insn, operand, mods, reg, val, file, line)
 298      arc_insn insn;
 299      const struct arc_operand *operand;
 300      int mods;
 301      const struct arc_operand_value *reg;
 302      offsetT val;
 303      char *file;
 304      unsigned int line;
 305 {
 306   if (operand->bits != 32)
 307     {
 308       long min, max;
 309       offsetT test;
 310
 311       if ((operand->flags & ARC_OPERAND_SIGNED) != 0)
 312         {
 313           if ((operand->flags & ARC_OPERAND_SIGNOPT) != 0)
 314             max = (1 << operand->bits) - 1;
 315           else
 316             max = (1 << (operand->bits - 1)) - 1;
 317           min = - (1 << (operand->bits - 1));
 318         }
 319       else
 320         {
 321           max = (1 << operand->bits) - 1;
 322           min = 0;
 323         }
 324
 325       if ((operand->flags & ARC_OPERAND_NEGATIVE) != 0)
 326         test = - val;
 327       else
 328         test = val;
 329
 330       if (test < (offsetT) min || test > (offsetT) max)
 331         as_warn_value_out_of_range (_("operand"), test, (offsetT) min, (offsetT) max, file, line);
 332     }
 333
 334   if (operand->insert)
 335     {
 336       const char *errmsg;
 337
 338       errmsg = NULL;
 339       insn = (*operand->insert) (insn, operand, mods, reg, (long) val, &errmsg);
 340       if (errmsg != (const char *) NULL)
 341         as_warn (errmsg);
 342     }
 343   else
 344     insn |= (((long) val & ((1 << operand->bits) - 1))
 345              << operand->shift);
 346
 347   return insn;
 348 }
 349
 350 /* We need to keep a list of fixups.  We can't simply generate them as
 351    we go, because that would require us to first create the frag, and
 352    that would screw up references to ``.''.  */
 353
 354 struct arc_fixup {
 355   /* index into `arc_operands'  */
 356   int opindex;
 357   expressionS exp;
 358 };
 359
 360 #define MAX_FIXUPS 5
 361
 362 #define MAX_SUFFIXES 5
 363
 364 /* This routine is called for each instruction to be assembled.  */
 365
 366 void
 367 md_assemble (str)
 368      char *str;
 369 {
 370   const struct arc_opcode *opcode;
 371   const struct arc_opcode *std_opcode;
 372   struct arc_opcode *ext_opcode;
 373   char *start;
 374   const char *last_errmsg = 0;
 375   arc_insn insn;
 376   static int init_tables_p = 0;
 377
 378   /* Opcode table initialization is deferred until here because we have to
 379      wait for a possible .option command.  */
 380   if (!init_tables_p)
 381     {
 382       init_opcode_tables (arc_mach_type);
 383       init_tables_p = 1;
 384     }
 385
 386   /* Skip leading white space.  */
 387   while (ISSPACE (*str))
 388     str++;
 389
 390   /* The instructions are stored in lists hashed by the first letter (though
 391      we needn't care how they're hashed).  Get the first in the list.  */
 392
 393   ext_opcode = arc_ext_opcodes;
 394   std_opcode = arc_opcode_lookup_asm (str);
 395
 396   /* Keep looking until we find a match.  */
 397
 398   start = str;
 399   for (opcode = (ext_opcode ? ext_opcode : std_opcode);
 400        opcode != NULL;
 401        opcode = (ARC_OPCODE_NEXT_ASM (opcode)
 402                  ? ARC_OPCODE_NEXT_ASM (opcode)
 403                  : (ext_opcode ? ext_opcode = NULL, std_opcode : NULL)))
 404     {
 405       int past_opcode_p, fc, num_suffixes;
 406       int fix_up_at = 0;
 407       char *syn;
 408       struct arc_fixup fixups[MAX_FIXUPS];
 409       /* Used as a sanity check.  If we need a limm reloc, make sure we ask
 410          for an extra 4 bytes from frag_more.  */
 411       int limm_reloc_p;
 412       int ext_suffix_p;
 413       const struct arc_operand_value *insn_suffixes[MAX_SUFFIXES];
 414
 415       /* Is this opcode supported by the selected cpu?  */
 416       if (! arc_opcode_supported (opcode))
 417         continue;
 418
 419       /* Scan the syntax string.  If it doesn't match, try the next one.  */
 420
 421       arc_opcode_init_insert ();
 422       insn = opcode->value;
 423       fc = 0;
 424       past_opcode_p = 0;
 425       num_suffixes = 0;
 426       limm_reloc_p = 0;
 427       ext_suffix_p = 0;
 428
 429       /* We don't check for (*str != '\0') here because we want to parse
 430          any trailing fake arguments in the syntax string.  */
 431       for (str = start, syn = opcode->syntax; *syn != '\0';)
 432         {
 433           int mods;
 434           const struct arc_operand *operand;
 435
 436           /* Non operand chars must match exactly.  */
 437           if (*syn != '%' || *++syn == '%')
 438             {
 439               /* Handle '+' specially as we want to allow "ld r0,[sp-4]".  */
 440               /* ??? The syntax has changed to [sp,-4].  */
 441               if (0 && *syn == '+' && *str == '-')
 442                 {
 443                   /* Skip over syn's +, but leave str's - alone.
 444                      That makes the case identical to "ld r0,[sp+-4]".  */
 445                   ++syn;
 446                 }
 447               else if (*str == *syn)
 448                 {
 449                   if (*syn == ' ')
 450                     past_opcode_p = 1;
 451                   ++syn;
 452                   ++str;
 453                 }
 454               else
 455                 break;
 456               continue;
 457             }
 458
 459           /* We have an operand.  Pick out any modifiers.  */
 460           mods = 0;
 461           while (ARC_MOD_P (arc_operands[arc_operand_map[(int) *syn]].flags))
 462             {
 463               mods |= arc_operands[arc_operand_map[(int) *syn]].flags & ARC_MOD_BITS;
 464               ++syn;
 465             }
 466           operand = arc_operands + arc_operand_map[(int) *syn];
 467           if (operand->fmt == 0)
 468             as_fatal ("unknown syntax format character `%c'", *syn);
 469
 470           if (operand->flags & ARC_OPERAND_FAKE)
 471             {
 472               const char *errmsg = NULL;
 473               if (operand->insert)
 474                 {
 475                   insn = (*operand->insert) (insn, operand, mods, NULL, 0, &errmsg);
 476                   if (errmsg != (const char *) NULL)
 477                     {
 478                       last_errmsg = errmsg;
 479                       if (operand->flags & ARC_OPERAND_ERROR)
 480                         {
 481                           as_bad (errmsg);
 482                           return;
 483                         }
 484                       else if (operand->flags & ARC_OPERAND_WARN)
 485                         as_warn (errmsg);
 486                       break;
 487                     }
 488                   if (limm_reloc_p
 489                       && (operand->flags && operand->flags & ARC_OPERAND_LIMM)
 490                       && (operand->flags &
 491                           (ARC_OPERAND_ABSOLUTE_BRANCH | ARC_OPERAND_ADDRESS)))
 492                     {
 493                       fixups[fix_up_at].opindex = arc_operand_map[operand->fmt];
 494                     }
 495                 }
 496               ++syn;
 497             }
 498           /* Are we finished with suffixes?  */
 499           else if (!past_opcode_p)
 500             {
 501               int found;
 502               char c;
 503               char *s, *t;
 504               const struct arc_operand_value *suf, *suffix_end;
 505               const struct arc_operand_value *suffix = NULL;
 506
 507               if (!(operand->flags & ARC_OPERAND_SUFFIX))
 508                 abort ();
 509
 510               /* If we're at a space in the input string, we want to skip the
 511                  remaining suffixes.  There may be some fake ones though, so
 512                  just go on to try the next one.  */
 513               if (*str == ' ')
 514                 {
 515                   ++syn;
 516                   continue;
 517                 }
 518
 519               s = str;
 520               if (mods & ARC_MOD_DOT)
 521                 {
 522                   if (*s != '.')
 523                     break;
 524                   ++s;
 525                 }
 526               else
 527                 {
 528                   /* This can happen in "b.nd foo" and we're currently looking
 529                      for "%q" (ie: a condition code suffix).  */
 530                   if (*s == '.')
 531                     {
 532                       ++syn;
 533                       continue;
 534                     }
 535                 }
 536
 537               /* Pick the suffix out and look it up via the hash table.  */
 538               for (t = s; *t && ISALNUM (*t); ++t)
 539                 continue;
 540               c = *t;
 541               *t = '\0';
 542               if ((suf = get_ext_suffix (s)))
 543                 ext_suffix_p = 1;
 544               else
 545                 suf = hash_find (arc_suffix_hash, s);
 546               if (!suf)
 547                 {
 548                   /* This can happen in "blle foo" and we're currently using
 549                      the template "b%q%.n %j".  The "bl" insn occurs later in
 550                      the table so "lle" isn't an illegal suffix.  */
 551                   *t = c;
 552                   break;
 553                 }
 554
 555               /* Is it the right type?  Note that the same character is used
 556                  several times, so we have to examine all of them.  This is
 557                  relatively efficient as equivalent entries are kept
 558                  together.  If it's not the right type, don't increment `str'
 559                  so we try the next one in the series.  */
 560               found = 0;
 561               if (ext_suffix_p && arc_operands[suf->type].fmt == *syn)
 562                 {
 563                   /* Insert the suffix's value into the insn.  */
 564                   *t = c;
 565                   if (operand->insert)
 566                     insn = (*operand->insert) (insn, operand,
 567                                                mods, NULL, suf->value,
 568                                                NULL);
 569                   else
 570                     insn |= suf->value << operand->shift;
 571
 572                   str = t;
 573                   found = 1;
 574                 }
 575               else
 576                 {
 577                   *t = c;
 578                   suffix_end = arc_suffixes + arc_suffixes_count;
 579                   for (suffix = suf;
 580                        suffix < suffix_end && strcmp (suffix->name, suf->name) == 0;
 581                        ++suffix)
 582                     {
 583                       if (arc_operands[suffix->type].fmt == *syn)
 584                         {
 585                           /* Insert the suffix's value into the insn.  */
 586                           if (operand->insert)
 587                             insn = (*operand->insert) (insn, operand,
 588                                                        mods, NULL, suffix->value,
 589                                                        NULL);
 590                           else
 591                             insn |= suffix->value << operand->shift;
 592
 593                           str = t;
 594                           found = 1;
 595                           break;
 596                         }
 597                     }
 598                 }
 599               ++syn;
 600               if (!found)
 601                 /* Wrong type.  Just go on to try next insn entry.  */
 602                 ;
 603               else
 604                 {
 605                   if (num_suffixes == MAX_SUFFIXES)
 606                     as_bad ("too many suffixes");
 607                   else
 608                     insn_suffixes[num_suffixes++] = suffix;
 609                 }
 610             }
 611           else
 612             /* This is either a register or an expression of some kind.  */
 613             {
 614               char *hold;
 615               const struct arc_operand_value *reg = NULL;
 616               long value = 0;
 617               expressionS exp;
 618
 619               if (operand->flags & ARC_OPERAND_SUFFIX)
 620                 abort ();
 621
 622               /* Is there anything left to parse?
 623                  We don't check for this at the top because we want to parse
 624                  any trailing fake arguments in the syntax string.  */
 625               if (is_end_of_line[(unsigned char) *str])
 626                 break;
 627
 628               /* Parse the operand.  */
 629               hold = input_line_pointer;
 630               input_line_pointer = str;
 631               expression (&exp);
 632               str = input_line_pointer;
 633               input_line_pointer = hold;
 634
 635               if (exp.X_op == O_illegal)
 636                 as_bad ("illegal operand");
 637               else if (exp.X_op == O_absent)
 638                 as_bad ("missing operand");
 639               else if (exp.X_op == O_constant)
 640                 {
 641                   value = exp.X_add_number;
 642                 }
 643               else if (exp.X_op == O_register)
 644                 {
 645                   reg = (struct arc_operand_value *) exp.X_add_number;
 646                 }
 647 #define IS_REG_DEST_OPERAND(o) ((o) == 'a')
 648               else if (IS_REG_DEST_OPERAND (*syn))
 649                 as_bad ("symbol as destination register");
 650               else
 651                 {
 652                   if (!strncmp (str, "@h30", 4))
 653                     {
 654                       arc_code_symbol (&exp);
 655                       str += 4;
 656                     }
 657                   /* We need to generate a fixup for this expression.  */
 658                   if (fc >= MAX_FIXUPS)
 659                     as_fatal ("too many fixups");
 660                   fixups[fc].exp = exp;
 661                   /* We don't support shimm relocs. break here to force
 662                      the assembler to output a limm.  */
 663 #define IS_REG_SHIMM_OFFSET(o) ((o) == 'd')
 664                   if (IS_REG_SHIMM_OFFSET (*syn))
 665                     break;
 666                   /* If this is a register constant (IE: one whose
 667                      register value gets stored as 61-63) then this
 668                      must be a limm.  */
 669                   /* ??? This bit could use some cleaning up.
 670                      Referencing the format chars like this goes
 671                      against style.  */
 672                   if (IS_SYMBOL_OPERAND (*syn))
 673                     {
 674                       const char *junk;
 675                       limm_reloc_p = 1;
 676                       /* Save this, we don't yet know what reloc to use.  */
 677                       fix_up_at = fc;
 678                       /* Tell insert_reg we need a limm.  This is
 679                          needed because the value at this point is
 680                          zero, a shimm.  */
 681                       /* ??? We need a cleaner interface than this.  */
 682                       (*arc_operands[arc_operand_map['Q']].insert)
 683                         (insn, operand, mods, reg, 0L, &junk);
 684                     }
 685                   else
 686                     fixups[fc].opindex = arc_operand_map[(int) *syn];
 687                   ++fc;
 688                   value = 0;
 689                 }
 690
 691               /* Insert the register or expression into the instruction.  */
 692               if (operand->insert)
 693                 {
 694                   const char *errmsg = NULL;
 695                   insn = (*operand->insert) (insn, operand, mods,
 696                                              reg, (long) value, &errmsg);
 697                   if (errmsg != (const char *) NULL)
 698                     {
 699                       last_errmsg = errmsg;
 700                       if (operand->flags & ARC_OPERAND_ERROR)
 701                         {
 702                           as_bad (errmsg);
 703                           return;
 704                         }
 705                       else if (operand->flags & ARC_OPERAND_WARN)
 706                         as_warn (errmsg);
 707                       break;
 708                     }
 709                 }
 710               else
 711                 insn |= (value & ((1 << operand->bits) - 1)) << operand->shift;
 712
 713               ++syn;
 714             }
 715         }
 716
 717       /* If we're at the end of the syntax string, we're done.  */
 718       /* FIXME: try to move this to a separate function.  */
 719       if (*syn == '\0')
 720         {
 721           int i;
 722           char *f;
 723           long limm, limm_p;
 724
 725           /* For the moment we assume a valid `str' can only contain blanks
 726              now.  IE: We needn't try again with a longer version of the
 727              insn and it is assumed that longer versions of insns appear
 728              before shorter ones (eg: lsr r2,r3,1 vs lsr r2,r3).  */
 729
 730           while (ISSPACE (*str))
 731             ++str;
 732
 733           if (!is_end_of_line[(unsigned char) *str])
 734             as_bad ("junk at end of line: `%s'", str);
 735
 736           /* Is there a limm value?  */
 737           limm_p = arc_opcode_limm_p (&limm);
 738
 739           /* Perform various error and warning tests.  */
 740
 741           {
 742             static int in_delay_slot_p = 0;
 743             static int prev_insn_needs_cc_nop_p = 0;
 744             /* delay slot type seen */
 745             int delay_slot_type = ARC_DELAY_NONE;
 746             /* conditional execution flag seen */
 747             int conditional = 0;
 748             /* 1 if condition codes are being set */
 749             int cc_set_p = 0;
 750             /* 1 if conditional branch, including `b' "branch always" */
 751             int cond_branch_p = opcode->flags & ARC_OPCODE_COND_BRANCH;
 752
 753             for (i = 0; i < num_suffixes; ++i)
 754               {
 755                 switch (arc_operands[insn_suffixes[i]->type].fmt)
 756                   {
 757                   case 'n':
 758                     delay_slot_type = insn_suffixes[i]->value;
 759                     break;
 760                   case 'q':
 761                     conditional = insn_suffixes[i]->value;
 762                     break;
 763                   case 'f':
 764                     cc_set_p = 1;
 765                     break;
 766                   }
 767               }
 768
 769             /* Putting an insn with a limm value in a delay slot is supposed to
 770                be legal, but let's warn the user anyway.  Ditto for 8 byte
 771                jumps with delay slots.  */
 772             if (in_delay_slot_p && limm_p)
 773               as_warn ("8 byte instruction in delay slot");
 774             if (delay_slot_type != ARC_DELAY_NONE
 775                 && limm_p && arc_insn_not_jl (insn)) /* except for jl  addr */
 776               as_warn ("8 byte jump instruction with delay slot");
 777             in_delay_slot_p = (delay_slot_type != ARC_DELAY_NONE) && !limm_p;
 778
 779             /* Warn when a conditional branch immediately follows a set of
 780                the condition codes.  Note that this needn't be done if the
 781                insn that sets the condition codes uses a limm.  */
 782             if (cond_branch_p && conditional != 0 /* 0 = "always" */
 783                 && prev_insn_needs_cc_nop_p && arc_mach_type == bfd_mach_arc_5)
 784               as_warn ("conditional branch follows set of flags");
 785             prev_insn_needs_cc_nop_p =
 786               /* FIXME: ??? not required:
 787                  (delay_slot_type != ARC_DELAY_NONE) &&  */
 788               cc_set_p && !limm_p;
 789           }
 790
 791           /* Write out the instruction.
 792              It is important to fetch enough space in one call to `frag_more'.
 793              We use (f - frag_now->fr_literal) to compute where we are and we
 794              don't want frag_now to change between calls.  */
 795           if (limm_p)
 796             {
 797               f = frag_more (8);
 798               md_number_to_chars (f, insn, 4);
 799               md_number_to_chars (f + 4, limm, 4);
 800               dwarf2_emit_insn (8);
 801             }
 802           else if (limm_reloc_p)
 803             {
 804               /* We need a limm reloc, but the tables think we don't.  */
 805               abort ();
 806             }
 807           else
 808             {
 809               f = frag_more (4);
 810               md_number_to_chars (f, insn, 4);
 811               dwarf2_emit_insn (4);
 812             }
 813
 814           /* Create any fixups.  */
 815           for (i = 0; i < fc; ++i)
 816             {
 817               int op_type, reloc_type;
 818               expressionS exptmp;
 819               const struct arc_operand *operand;
 820
 821               /* Create a fixup for this operand.
 822                  At this point we do not use a bfd_reloc_code_real_type for
 823                  operands residing in the insn, but instead just use the
 824                  operand index.  This lets us easily handle fixups for any
 825                  operand type, although that is admittedly not a very exciting
 826                  feature.  We pick a BFD reloc type in md_apply_fix3.
 827
 828                  Limm values (4 byte immediate "constants") must be treated
 829                  normally because they're not part of the actual insn word
 830                  and thus the insertion routines don't handle them.  */
 831
 832               if (arc_operands[fixups[i].opindex].flags & ARC_OPERAND_LIMM)
 833                 {
 834                   /* Modify the fixup addend as required by the cpu.  */
 835                   fixups[i].exp.X_add_number += arc_limm_fixup_adjust (insn);
 836                   op_type = fixups[i].opindex;
 837                   /* FIXME: can we add this data to the operand table?  */
 838                   if (op_type == arc_operand_map['L']
 839                       || op_type == arc_operand_map['s']
 840                       || op_type == arc_operand_map['o']
 841                       || op_type == arc_operand_map['O'])
 842                     reloc_type = BFD_RELOC_32;
 843                   else if (op_type == arc_operand_map['J'])
 844                     reloc_type = BFD_RELOC_ARC_B26;
 845                   else
 846                     abort ();
 847                   reloc_type = get_arc_exp_reloc_type (1, reloc_type,
 848                                                        &fixups[i].exp,
 849                                                        &exptmp);
 850                 }
 851               else
 852                 {
 853                   op_type = get_arc_exp_reloc_type (0, fixups[i].opindex,
 854                                                     &fixups[i].exp, &exptmp);
 855                   reloc_type = op_type + (int) BFD_RELOC_UNUSED;
 856                 }
 857               operand = &arc_operands[op_type];
 858               fix_new_exp (frag_now,
 859                            ((f - frag_now->fr_literal)
 860                             + (operand->flags & ARC_OPERAND_LIMM ? 4 : 0)), 4,
 861                            &exptmp,
 862                            (operand->flags & ARC_OPERAND_RELATIVE_BRANCH) != 0,
 863                            (bfd_reloc_code_real_type) reloc_type);
 864             }
 865
 866           /* All done.  */
 867           return;
 868         }
 869
 870       /* Try the next entry.  */
 871     }
 872
 873   if (NULL == last_errmsg)
 874     as_bad ("bad instruction `%s'", start);
 875   else
 876     as_bad (last_errmsg);
 877 }
 878 \f
 879 static void
 880 arc_extoper (opertype)
 881      int opertype;
 882 {
 883   char *name;
 884   char *mode;
 885   char c;
 886   char *p;
 887   int imode = 0;
 888   int number;
 889   struct arc_ext_operand_value *ext_oper;
 890   symbolS *symbolP;
 891
 892   segT old_sec;
 893   int old_subsec;
 894
 895   name = input_line_pointer;
 896   c = get_symbol_end ();
 897   name = xstrdup (name);
 898
 899   p = name;
 900   while (*p)
 901     {
 902       *p = TOLOWER (*p);
 903       p++;
 904     }
 905
 906   /* just after name is now '\0'  */
 907   p = input_line_pointer;
 908   *p = c;
 909   SKIP_WHITESPACE ();
 910
 911   if (*input_line_pointer != ',')
 912     {
 913       as_bad ("expected comma after operand name");
 914       ignore_rest_of_line ();
 915       free (name);
 916       return;
 917     }
 918
 919   input_line_pointer++;         /* skip ','  */
 920   number = get_absolute_expression ();
 921
 922   if (number < 0)
 923     {
 924       as_bad ("negative operand number %d", number);
 925       ignore_rest_of_line ();
 926       free (name);
 927       return;
 928     }
 929
 930   if (opertype)
 931     {
 932       SKIP_WHITESPACE ();
 933
 934       if (*input_line_pointer != ',')
 935         {
 936           as_bad ("expected comma after register-number");
 937           ignore_rest_of_line ();
 938           free (name);
 939           return;
 940         }
 941
 942       input_line_pointer++;             /* skip ','  */
 943       mode = input_line_pointer;
 944
 945       if (!strncmp (mode, "r|w", 3))
 946         {
 947           imode = 0;
 948           input_line_pointer += 3;
 949         }
 950       else
 951         {
 952           if (!strncmp (mode, "r", 1))
 953             {
 954               imode = ARC_REGISTER_READONLY;
 955               input_line_pointer += 1;
 956             }
 957           else
 958             {
 959               if (strncmp (mode, "w", 1))
 960                 {
 961                   as_bad ("invalid mode");
 962                   ignore_rest_of_line ();
 963                   free (name);
 964                   return;
 965                 }
 966               else
 967                 {
 968                   imode = ARC_REGISTER_WRITEONLY;
 969                   input_line_pointer += 1;
 970                 }
 971             }
 972         }
 973       SKIP_WHITESPACE ();
 974       if (1 == opertype)
 975         {
 976           if (*input_line_pointer != ',')
 977             {
 978               as_bad ("expected comma after register-mode");
 979               ignore_rest_of_line ();
 980               free (name);
 981               return;
 982             }
 983
 984           input_line_pointer++;         /* skip ','  */
 985
 986           if (!strncmp (input_line_pointer, "cannot_shortcut", 15))
 987             {
 988               imode |= arc_get_noshortcut_flag ();
 989               input_line_pointer += 15;
 990             }
 991           else
 992             {
 993               if (strncmp (input_line_pointer, "can_shortcut", 12))
 994                 {
 995                   as_bad ("shortcut designator invalid");
 996                   ignore_rest_of_line ();
 997                   free (name);
 998                   return;
 999                 }
1000               else
1001                 {
1002                   input_line_pointer += 12;
1003                 }
1004             }
1005         }
1006     }
1007
1008   if ((opertype == 1) && number > 60)
1009     {
1010       as_bad ("core register value (%d) too large", number);
1011       ignore_rest_of_line ();
1012       free (name);
1013       return;
1014     }
1015
1016   if ((opertype == 0) && number > 31)
1017     {
1018       as_bad ("condition code value (%d) too large", number);
1019       ignore_rest_of_line ();
1020       free (name);
1021       return;
1022     }
1023
1024   ext_oper = (struct arc_ext_operand_value *) \
1025     xmalloc (sizeof (struct arc_ext_operand_value));
1026
1027   if (opertype)
1028     {
1029       /* If the symbol already exists, point it at the new definition.  */
1030       if ((symbolP = symbol_find (name)))
1031         {
1032           if (S_GET_SEGMENT (symbolP) == reg_section)
1033             S_SET_VALUE (symbolP, (int) &ext_oper->operand);
1034           else
1035             {
1036               as_bad ("attempt to override symbol: %s", name);
1037               ignore_rest_of_line ();
1038               free (name);
1039               free (ext_oper);
1040               return;
1041             }
1042         }
1043       else
1044         {
1045           /* If its not there, add it.  */
1046           symbol_table_insert (symbol_create (name, reg_section,
1047                                               (int) &ext_oper->operand, &zero_address_frag));
1048         }
1049     }
1050
1051   ext_oper->operand.name  = name;
1052   ext_oper->operand.value = number;
1053   ext_oper->operand.type  = arc_operand_type (opertype);
1054   ext_oper->operand.flags = imode;
1055
1056   ext_oper->next = arc_ext_operands;
1057   arc_ext_operands = ext_oper;
1058
1059   /* OK, now that we know what this operand is, put a description in
1060      the arc extension section of the output file.  */
1061
1062   old_sec    = now_seg;
1063   old_subsec = now_subseg;
1064
1065   arc_set_ext_seg ();
1066
1067   switch (opertype)
1068     {
1069     case 0:
1070       p = frag_more (1);
1071       *p = 3 + strlen (name) + 1;
1072       p = frag_more (1);
1073       *p = EXT_COND_CODE;
1074       p = frag_more (1);
1075       *p = number;
1076       p = frag_more (strlen (name) + 1);
1077       strcpy (p, name);
1078       break;
1079     case 1:
1080       p = frag_more (1);
1081       *p = 3 + strlen (name) + 1;
1082       p = frag_more (1);
1083       *p = EXT_CORE_REGISTER;
1084       p = frag_more (1);
1085       *p = number;
1086       p = frag_more (strlen (name) + 1);
1087       strcpy (p, name);
1088       break;
1089     case 2:
1090       p = frag_more (1);
1091       *p = 6 + strlen (name) + 1;
1092       p = frag_more (1);
1093       *p = EXT_AUX_REGISTER;
1094       p = frag_more (1);
1095       *p = number >> 24 & 0xff;
1096       p = frag_more (1);
1097       *p = number >> 16 & 0xff;
1098       p = frag_more (1);
1099       *p = number >>  8 & 0xff;
1100       p = frag_more (1);
1101       *p = number       & 0xff;
1102       p = frag_more (strlen (name) + 1);
1103       strcpy (p, name);
1104       break;
1105     default:
1106       as_bad ("invalid opertype");
1107       ignore_rest_of_line ();
1108       free (name);
1109       return;
1110       break;
1111     }
1112
1113   subseg_set (old_sec, old_subsec);
1114
1115   /* Enter all registers into the symbol table.  */
1116
1117   demand_empty_rest_of_line ();
1118 }
1119
1120 static void
1121 arc_extinst (ignore)
1122      int ignore ATTRIBUTE_UNUSED;
1123 {
1124   char syntax[129];
1125   char *name;
1126   char *p;
1127   char c;
1128   int suffixcode = -1;
1129   int opcode, subopcode;
1130   int i;
1131   int class = 0;
1132   int name_len;
1133   struct arc_opcode *ext_op;
1134
1135   segT old_sec;
1136   int old_subsec;
1137
1138   name = input_line_pointer;
1139   c = get_symbol_end ();
1140   name = xstrdup (name);
1141   strcpy (syntax, name);
1142   name_len = strlen (name);
1143
1144   /* just after name is now '\0'  */
1145   p = input_line_pointer;
1146   *p = c;
1147
1148   SKIP_WHITESPACE ();
1149
1150   if (*input_line_pointer != ',')
1151     {
1152       as_bad ("expected comma after operand name");
1153       ignore_rest_of_line ();
1154       return;
1155     }
1156
1157   input_line_pointer++;         /* skip ','  */
1158   opcode = get_absolute_expression ();
1159
1160   SKIP_WHITESPACE ();
1161
1162   if (*input_line_pointer != ',')
1163     {
1164       as_bad ("expected comma after opcode");
1165       ignore_rest_of_line ();
1166       return;
1167     }
1168
1169   input_line_pointer++;         /* skip ','  */
1170   subopcode = get_absolute_expression ();
1171
1172   if (subopcode < 0)
1173     {
1174       as_bad ("negative subopcode %d", subopcode);
1175       ignore_rest_of_line ();
1176       return;
1177     }
1178
1179   if (subopcode)
1180     {
1181       if (3 != opcode)
1182         {
1183           as_bad ("subcode value found when opcode not equal 0x03");
1184           ignore_rest_of_line ();
1185           return;
1186         }
1187       else
1188         {
1189           if (subopcode < 0x09 || subopcode == 0x3f)
1190             {
1191               as_bad ("invalid subopcode %d", subopcode);
1192               ignore_rest_of_line ();
1193               return;
1194             }
1195         }
1196     }
1197
1198   SKIP_WHITESPACE ();
1199
1200   if (*input_line_pointer != ',')
1201     {
1202       as_bad ("expected comma after subopcode");
1203       ignore_rest_of_line ();
1204       return;
1205     }
1206
1207   input_line_pointer++;         /* skip ','  */
1208
1209   for (i = 0; i < (int) MAXSUFFIXCLASS; i++)
1210     {
1211       if (!strncmp (suffixclass[i].name,input_line_pointer, suffixclass[i].len))
1212         {
1213           suffixcode = i;
1214           input_line_pointer += suffixclass[i].len;
1215           break;
1216         }
1217     }
1218
1219   if (-1 == suffixcode)
1220     {
1221       as_bad ("invalid suffix class");
1222       ignore_rest_of_line ();
1223       return;
1224     }
1225
1226   SKIP_WHITESPACE ();
1227
1228   if (*input_line_pointer != ',')
1229     {
1230       as_bad ("expected comma after suffix class");
1231       ignore_rest_of_line ();
1232       return;
1233     }
1234
1235   input_line_pointer++;         /* skip ','  */
1236
1237   for (i = 0; i < (int) MAXSYNTAXCLASS; i++)
1238     {
1239       if (!strncmp (syntaxclass[i].name,input_line_pointer, syntaxclass[i].len))
1240         {
1241           class = syntaxclass[i].class;
1242           input_line_pointer += syntaxclass[i].len;
1243           break;
1244         }
1245     }
1246
1247   if (0 == (SYNTAX_VALID & class))
1248     {
1249       as_bad ("invalid syntax class");
1250       ignore_rest_of_line ();
1251       return;
1252     }
1253
1254   if ((0x3 == opcode) & (class & SYNTAX_3OP))
1255     {
1256       as_bad ("opcode 0x3 and SYNTAX_3OP invalid");
1257       ignore_rest_of_line ();
1258       return;
1259     }
1260
1261   switch (suffixcode)
1262     {
1263     case 0:
1264       strcat (syntax, "%.q%.f ");
1265       break;
1266     case 1:
1267       strcat (syntax, "%.f ");
1268       break;
1269     case 2:
1270       strcat (syntax, "%.q ");
1271       break;
1272     case 3:
1273       strcat (syntax, " ");
1274       break;
1275     default:
1276       as_bad ("unknown suffix class");
1277       ignore_rest_of_line ();
1278       return;
1279       break;
1280     };
1281
1282   strcat (syntax, ((opcode == 0x3) ? "%a,%b" : ((class & SYNTAX_3OP) ? "%a,%b,%c" : "%b,%c")));
1283   if (suffixcode < 2)
1284     strcat (syntax, "%F");
1285   strcat (syntax, "%S%L");
1286
1287   ext_op = (struct arc_opcode *) xmalloc (sizeof (struct arc_opcode));
1288   ext_op->syntax = xstrdup (syntax);
1289
1290   ext_op->mask  = I (-1) | ((0x3 == opcode) ? C (-1) : 0);
1291   ext_op->value = I (opcode) | ((0x3 == opcode) ? C (subopcode) : 0);
1292   ext_op->flags = class;
1293   ext_op->next_asm = arc_ext_opcodes;
1294   ext_op->next_dis = arc_ext_opcodes;
1295   arc_ext_opcodes = ext_op;
1296
1297   /* OK, now that we know what this inst is, put a description in the
1298      arc extension section of the output file.  */
1299
1300   old_sec    = now_seg;
1301   old_subsec = now_subseg;
1302
1303   arc_set_ext_seg ();
1304
1305   p = frag_more (1);
1306   *p = 5 + name_len + 1;
1307   p = frag_more (1);
1308   *p = EXT_INSTRUCTION;
1309   p = frag_more (1);
1310   *p = opcode;
1311   p = frag_more (1);
1312   *p = subopcode;
1313   p = frag_more (1);
1314   *p = (class & (OP1_MUST_BE_IMM | OP1_IMM_IMPLIED) ? IGNORE_FIRST_OPD : 0);
1315   p = frag_more (name_len);
1316   strncpy (p, syntax, name_len);
1317   p = frag_more (1);
1318   *p = '\0';
1319
1320   subseg_set (old_sec, old_subsec);
1321
1322   demand_empty_rest_of_line ();
1323 }
1324
1325 int
1326 arc_set_ext_seg ()
1327 {
1328   if (!arcext_section)
1329     {
1330       arcext_section = subseg_new (".arcextmap", 0);
1331       bfd_set_section_flags (stdoutput, arcext_section,
1332                              SEC_READONLY | SEC_HAS_CONTENTS);
1333     }
1334   else
1335     subseg_set (arcext_section, 0);
1336   return 1;
1337 }
1338
1339 static void
1340 arc_common (localScope)
1341      int localScope;
1342 {
1343   char *name;
1344   char c;
1345   char *p;
1346   int align, size;
1347   symbolS *symbolP;
1348
1349   name = input_line_pointer;
1350   c = get_symbol_end ();
1351   /* just after name is now '\0'  */
1352   p = input_line_pointer;
1353   *p = c;
1354   SKIP_WHITESPACE ();
1355
1356   if (*input_line_pointer != ',')
1357     {
1358       as_bad ("expected comma after symbol name");
1359       ignore_rest_of_line ();
1360       return;
1361     }
1362
1363   input_line_pointer++;         /* skip ','  */
1364   size = get_absolute_expression ();
1365
1366   if (size < 0)
1367     {
1368       as_bad ("negative symbol length");
1369       ignore_rest_of_line ();
1370       return;
1371     }
1372
1373   *p = 0;
1374   symbolP = symbol_find_or_make (name);
1375   *p = c;
1376
1377   if (S_IS_DEFINED (symbolP) && ! S_IS_COMMON (symbolP))
1378     {
1379       as_bad ("ignoring attempt to re-define symbol");
1380       ignore_rest_of_line ();
1381       return;
1382     }
1383   if (((int) S_GET_VALUE (symbolP) != 0) \
1384       && ((int) S_GET_VALUE (symbolP) != size))
1385     {
1386       as_warn ("length of symbol \"%s\" already %ld, ignoring %d",
1387                S_GET_NAME (symbolP), (long) S_GET_VALUE (symbolP), size);
1388     }
1389   assert (symbolP->sy_frag == &zero_address_frag);
1390
1391   /* Now parse the alignment field.  This field is optional for
1392      local and global symbols. Default alignment is zero.  */
1393   if (*input_line_pointer == ',')
1394     {
1395       input_line_pointer++;
1396       align = get_absolute_expression ();
1397       if (align < 0)
1398         {
1399           align = 0;
1400           as_warn ("assuming symbol alignment of zero");
1401         }
1402     }
1403   else
1404     align = 0;
1405
1406   if (localScope != 0)
1407     {
1408       segT old_sec;
1409       int old_subsec;
1410       char *pfrag;
1411
1412       old_sec    = now_seg;
1413       old_subsec = now_subseg;
1414       record_alignment (bss_section, align);
1415       subseg_set (bss_section, 0);  /* ??? subseg_set (bss_section, 1); ???  */
1416
1417       if (align)
1418         /* Do alignment.  */
1419         frag_align (align, 0, 0);
1420
1421       /* Detach from old frag.  */
1422       if (S_GET_SEGMENT (symbolP) == bss_section)
1423         symbolP->sy_frag->fr_symbol = NULL;
1424
1425       symbolP->sy_frag = frag_now;
1426       pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP,
1427                         (offsetT) size, (char *) 0);
1428       *pfrag = 0;
1429
1430       S_SET_SIZE       (symbolP, size);
1431       S_SET_SEGMENT    (symbolP, bss_section);
1432       S_CLEAR_EXTERNAL (symbolP);
1433       symbolP->local = 1;
1434       subseg_set (old_sec, old_subsec);
1435     }
1436   else
1437     {
1438       S_SET_VALUE    (symbolP, (valueT) size);
1439       S_SET_ALIGN    (symbolP, align);
1440       S_SET_EXTERNAL (symbolP);
1441       S_SET_SEGMENT  (symbolP, bfd_com_section_ptr);
1442     }
1443
1444   symbolP->bsym->flags |= BSF_OBJECT;
1445
1446   demand_empty_rest_of_line ();
1447 }
1448 \f
1449 /* Select the cpu we're assembling for.  */
1450
1451 static void
1452 arc_option (ignore)
1453      int ignore ATTRIBUTE_UNUSED;
1454 {
1455   int mach;
1456   char c;
1457   char *cpu;
1458
1459   cpu = input_line_pointer;
1460   c = get_symbol_end ();
1461   mach = arc_get_mach (cpu);
1462   *input_line_pointer = c;
1463
1464   /* If an instruction has already been seen, it's too late.  */
1465   if (cpu_tables_init_p)
1466     {
1467       as_bad ("\".option\" directive must appear before any instructions");
1468       ignore_rest_of_line ();
1469       return;
1470     }
1471
1472   if (mach == -1)
1473     goto bad_cpu;
1474
1475   if (mach_type_specified_p && mach != arc_mach_type)
1476     {
1477       as_bad ("\".option\" directive conflicts with initial definition");
1478       ignore_rest_of_line ();
1479       return;
1480     }
1481   else
1482     {
1483       /* The cpu may have been selected on the command line.  */
1484       if (mach != arc_mach_type)
1485         as_warn ("\".option\" directive overrides command-line (default) value");
1486       arc_mach_type = mach;
1487       if (!bfd_set_arch_mach (stdoutput, bfd_arch_arc, mach))
1488         as_fatal ("could not set architecture and machine");
1489       mach_type_specified_p = 1;
1490     }
1491   demand_empty_rest_of_line ();
1492   return;
1493
1494  bad_cpu:
1495   as_bad ("invalid identifier for \".option\"");
1496   ignore_rest_of_line ();
1497 }
1498 \f
1499 /* Turn a string in input_line_pointer into a floating point constant
1500    of type TYPE, and store the appropriate bytes in *LITP.  The number
1501    of LITTLENUMS emitted is stored in *SIZEP.  An error message is
1502    returned, or NULL on OK.  */
1503
1504 /* Equal to MAX_PRECISION in atof-ieee.c  */
1505 #define MAX_LITTLENUMS 6
1506
1507 char *
1508 md_atof (type, litP, sizeP)
1509      int type;
1510      char *litP;
1511      int *sizeP;
1512 {
1513   int prec;
1514   LITTLENUM_TYPE words[MAX_LITTLENUMS];
1515   LITTLENUM_TYPE *wordP;
1516   char *t;
1517
1518   switch (type)
1519     {
1520     case 'f':
1521     case 'F':
1522       prec = 2;
1523       break;
1524
1525     case 'd':
1526     case 'D':
1527       prec = 4;
1528       break;
1529
1530     default:
1531       *sizeP = 0;
1532       return "bad call to md_atof";
1533     }
1534
1535   t = atof_ieee (input_line_pointer, type, words);
1536   if (t)
1537     input_line_pointer = t;
1538   *sizeP = prec * sizeof (LITTLENUM_TYPE);
1539   for (wordP = words; prec--;)
1540     {
1541       md_number_to_chars (litP, (valueT) (*wordP++), sizeof (LITTLENUM_TYPE));
1542       litP += sizeof (LITTLENUM_TYPE);
1543     }
1544
1545   return NULL;
1546 }
1547
1548 /* Write a value out to the object file, using the appropriate
1549    endianness.  */
1550
1551 void
1552 md_number_to_chars (buf, val, n)
1553      char *buf;
1554      valueT val;
1555      int n;
1556 {
1557   if (target_big_endian)
1558     number_to_chars_bigendian (buf, val, n);
1559   else
1560     number_to_chars_littleendian (buf, val, n);
1561 }
1562
1563 /* Round up a section size to the appropriate boundary.  */
1564
1565 valueT
1566 md_section_align (segment, size)
1567      segT segment;
1568      valueT size;
1569 {
1570   int align = bfd_get_section_alignment (stdoutput, segment);
1571
1572   return ((size + (1 << align) - 1) & (-1 << align));
1573 }
1574
1575 /* We don't have any form of relaxing.  */
1576
1577 int
1578 md_estimate_size_before_relax (fragp, seg)
1579      fragS *fragp ATTRIBUTE_UNUSED;
1580      asection *seg ATTRIBUTE_UNUSED;
1581 {
1582   as_fatal (_("md_estimate_size_before_relax\n"));
1583   return 1;
1584 }
1585
1586 /* Convert a machine dependent frag.  We never generate these.  */
1587
1588 void
1589 md_convert_frag (abfd, sec, fragp)
1590      bfd *abfd ATTRIBUTE_UNUSED;
1591      asection *sec ATTRIBUTE_UNUSED;
1592      fragS *fragp ATTRIBUTE_UNUSED;
1593 {
1594   as_fatal (_("md_convert_frag\n"));
1595 }
1596
1597 void
1598 arc_code_symbol (expressionP)
1599      expressionS *expressionP;
1600 {
1601   if (expressionP->X_op == O_symbol && expressionP->X_add_number == 0)
1602     {
1603       expressionS two;
1604       expressionP->X_op = O_right_shift;
1605       expressionP->X_add_symbol->sy_value.X_op = O_constant;
1606       two.X_op = O_constant;
1607       two.X_add_symbol = two.X_op_symbol = NULL;
1608       two.X_add_number = 2;
1609       expressionP->X_op_symbol = make_expr_symbol (&two);
1610     }
1611   /* Allow %st(sym1-sym2)  */
1612   else if (expressionP->X_op == O_subtract
1613            && expressionP->X_add_symbol != NULL
1614            && expressionP->X_op_symbol != NULL
1615            && expressionP->X_add_number == 0)
1616     {
1617       expressionS two;
1618       expressionP->X_add_symbol = make_expr_symbol (expressionP);
1619       expressionP->X_op = O_right_shift;
1620       two.X_op = O_constant;
1621       two.X_add_symbol = two.X_op_symbol = NULL;
1622       two.X_add_number = 2;
1623       expressionP->X_op_symbol = make_expr_symbol (&two);
1624     }
1625   else
1626     {
1627       as_bad ("expression too complex code symbol");
1628       return;
1629     }
1630 }
1631
1632 /* Parse an operand that is machine-specific.
1633
1634    The ARC has a special %-op to adjust addresses so they're usable in
1635    branches.  The "st" is short for the STatus register.
1636    ??? Later expand this to take a flags value too.
1637
1638    ??? We can't create new expression types so we map the %-op's onto the
1639    existing syntax.  This means that the user could use the chosen syntax
1640    to achieve the same effect.  */
1641
1642 void
1643 md_operand (expressionP)
1644      expressionS *expressionP;
1645 {
1646   char *p = input_line_pointer;
1647
1648   if (*p != '%')
1649     return;
1650
1651   if (strncmp (p, "%st(", 4) == 0)
1652     {
1653       input_line_pointer += 4;
1654       expression (expressionP);
1655       if (*input_line_pointer != ')')
1656         {
1657           as_bad ("missing ')' in %%-op");
1658           return;
1659         }
1660       ++input_line_pointer;
1661       arc_code_symbol (expressionP);
1662     }
1663   else
1664     {
1665       /* It could be a register.  */
1666       int i, l;
1667       struct arc_ext_operand_value *ext_oper = arc_ext_operands;
1668       p++;
1669
1670       while (ext_oper)
1671         {
1672           l = strlen (ext_oper->operand.name);
1673           if (!strncmp (p, ext_oper->operand.name, l) && !ISALNUM (*(p + l)))
1674             {
1675               input_line_pointer += l + 1;
1676               expressionP->X_op = O_register;
1677               expressionP->X_add_number = (int) &ext_oper->operand;
1678               return;
1679             }
1680           ext_oper = ext_oper->next;
1681         }
1682       for (i = 0; i < arc_reg_names_count; i++)
1683         {
1684           l = strlen (arc_reg_names[i].name);
1685           if (!strncmp (p, arc_reg_names[i].name, l) && !ISALNUM (*(p + l)))
1686             {
1687               input_line_pointer += l + 1;
1688               expressionP->X_op = O_register;
1689               expressionP->X_add_number = (int) &arc_reg_names[i];
1690               break;
1691             }
1692         }
1693     }
1694 }
1695
1696 /* We have no need to default values of symbols.
1697    We could catch register names here, but that is handled by inserting
1698    them all in the symbol table to begin with.  */
1699
1700 symbolS *
1701 md_undefined_symbol (name)
1702      char *name ATTRIBUTE_UNUSED;
1703 {
1704   return 0;
1705 }
1706 \f
1707 /* Functions concerning expressions.  */
1708
1709 /* Parse a .byte, .word, etc. expression.
1710
1711    Values for the status register are specified with %st(label).
1712    `label' will be right shifted by 2.  */
1713
1714 void
1715 arc_parse_cons_expression (exp, nbytes)
1716      expressionS *exp;
1717      unsigned int nbytes ATTRIBUTE_UNUSED;
1718 {
1719   char *p = input_line_pointer;
1720   int code_symbol_fix = 0;
1721
1722   for (; ! is_end_of_line[(unsigned char) *p]; p++)
1723     if (*p == '@' && !strncmp (p, "@h30", 4))
1724       {
1725         code_symbol_fix = 1;
1726         strcpy (p, ";   ");
1727       }
1728   expr (0, exp);
1729   if (code_symbol_fix)
1730     {
1731       arc_code_symbol (exp);
1732       input_line_pointer = p;
1733     }
1734 }
1735
1736 /* Record a fixup for a cons expression.  */
1737
1738 void
1739 arc_cons_fix_new (frag, where, nbytes, exp)
1740      fragS *frag;
1741      int where;
1742      int nbytes;
1743      expressionS *exp;
1744 {
1745   if (nbytes == 4)
1746     {
1747       int reloc_type;
1748       expressionS exptmp;
1749
1750       /* This may be a special ARC reloc (eg: %st()).  */
1751       reloc_type = get_arc_exp_reloc_type (1, BFD_RELOC_32, exp, &exptmp);
1752       fix_new_exp (frag, where, nbytes, &exptmp, 0, reloc_type);
1753     }
1754   else
1755     {
1756       fix_new_exp (frag, where, nbytes, exp, 0,
1757                    nbytes == 2 ? BFD_RELOC_16
1758                    : nbytes == 8 ? BFD_RELOC_64
1759                    : BFD_RELOC_32);
1760     }
1761 }
1762 \f
1763 /* Functions concerning relocs.  */
1764
1765 /* The location from which a PC relative jump should be calculated,
1766    given a PC relative reloc.  */
1767
1768 long
1769 md_pcrel_from (fixP)
1770      fixS *fixP;
1771 {
1772   /* Return the address of the delay slot.  */
1773   return fixP->fx_frag->fr_address + fixP->fx_where + fixP->fx_size;
1774 }
1775
1776 /* Compute the reloc type of an expression.
1777    The possibly modified expression is stored in EXPNEW.
1778
1779    This is used to convert the expressions generated by the %-op's into
1780    the appropriate operand type.  It is called for both data in instructions
1781    (operands) and data outside instructions (variables, debugging info, etc.).
1782
1783    Currently supported %-ops:
1784
1785    %st(symbol): represented as "symbol >> 2"
1786                 "st" is short for STatus as in the status register (pc)
1787
1788    DEFAULT_TYPE is the type to use if no special processing is required.
1789
1790    DATA_P is non-zero for data or limm values, zero for insn operands.
1791    Remember that the opcode "insertion fns" cannot be used on data, they're
1792    only for inserting operands into insns.  They also can't be used for limm
1793    values as the insertion routines don't handle limm values.  When called for
1794    insns we return fudged reloc types (real_value - BFD_RELOC_UNUSED).  When
1795    called for data or limm values we use real reloc types.  */
1796
1797 static int
1798 get_arc_exp_reloc_type (data_p, default_type, exp, expnew)
1799      int data_p;
1800      int default_type;
1801      expressionS *exp;
1802      expressionS *expnew;
1803 {
1804   /* If the expression is "symbol >> 2" we must change it to just "symbol",
1805      as fix_new_exp can't handle it.  Similarly for (symbol - symbol) >> 2.
1806      That's ok though.  What's really going on here is that we're using
1807      ">> 2" as a special syntax for specifying BFD_RELOC_ARC_B26.  */
1808
1809   if (exp->X_op == O_right_shift
1810       && exp->X_op_symbol != NULL
1811       && exp->X_op_symbol->sy_value.X_op == O_constant
1812       && exp->X_op_symbol->sy_value.X_add_number == 2
1813       && exp->X_add_number == 0)
1814     {
1815       if (exp->X_add_symbol != NULL
1816           && (exp->X_add_symbol->sy_value.X_op == O_constant
1817               || exp->X_add_symbol->sy_value.X_op == O_symbol))
1818         {
1819           *expnew = *exp;
1820           expnew->X_op = O_symbol;
1821           expnew->X_op_symbol = NULL;
1822           return data_p ? BFD_RELOC_ARC_B26 : arc_operand_map['J'];
1823         }
1824       else if (exp->X_add_symbol != NULL
1825                && exp->X_add_symbol->sy_value.X_op == O_subtract)
1826         {
1827           *expnew = exp->X_add_symbol->sy_value;
1828           return data_p ? BFD_RELOC_ARC_B26 : arc_operand_map['J'];
1829         }
1830     }
1831
1832   *expnew = *exp;
1833   return default_type;
1834 }
1835
1836 /* Apply a fixup to the object code.  This is called for all the
1837    fixups we generated by the call to fix_new_exp, above.  In the call
1838    above we used a reloc code which was the largest legal reloc code
1839    plus the operand index.  Here we undo that to recover the operand
1840    index.  At this point all symbol values should be fully resolved,
1841    and we attempt to completely resolve the reloc.  If we can not do
1842    that, we determine the correct reloc code and put it back in the fixup.  */
1843
1844 void
1845 md_apply_fix3 (fixP, valP, seg)
1846      fixS *fixP;
1847      valueT * valP;
1848      segT seg;
1849 {
1850   valueT value = * valP;
1851
1852   if (fixP->fx_addsy == (symbolS *) NULL)
1853     fixP->fx_done = 1;
1854
1855   else if (fixP->fx_pcrel)
1856     {
1857       /* Hack around bfd_install_relocation brain damage.  */
1858       if (S_GET_SEGMENT (fixP->fx_addsy) != seg)
1859         value += md_pcrel_from (fixP);
1860     }
1861
1862   /* We can't actually support subtracting a symbol.  */
1863   if (fixP->fx_subsy != NULL)
1864     as_bad_where (fixP->fx_file, fixP->fx_line, _("expression too complex"));
1865
1866   if ((int) fixP->fx_r_type >= (int) BFD_RELOC_UNUSED)
1867     {
1868       int opindex;
1869       const struct arc_operand *operand;
1870       char *where;
1871       arc_insn insn;
1872
1873       opindex = (int) fixP->fx_r_type - (int) BFD_RELOC_UNUSED;
1874
1875       operand = &arc_operands[opindex];
1876
1877       /* Fetch the instruction, insert the fully resolved operand
1878          value, and stuff the instruction back again.  */
1879       where = fixP->fx_frag->fr_literal + fixP->fx_where;
1880       if (target_big_endian)
1881         insn = bfd_getb32 ((unsigned char *) where);
1882       else
1883         insn = bfd_getl32 ((unsigned char *) where);
1884       insn = arc_insert_operand (insn, operand, -1, NULL, (offsetT) value,
1885                                  fixP->fx_file, fixP->fx_line);
1886       if (target_big_endian)
1887         bfd_putb32 ((bfd_vma) insn, (unsigned char *) where);
1888       else
1889         bfd_putl32 ((bfd_vma) insn, (unsigned char *) where);
1890
1891       if (fixP->fx_done)
1892         {
1893           /* Nothing else to do here.  */
1894           return;
1895         }
1896
1897       /* Determine a BFD reloc value based on the operand information.
1898          We are only prepared to turn a few of the operands into relocs.
1899          !!! Note that we can't handle limm values here.  Since we're using
1900          implicit addends the addend must be inserted into the instruction,
1901          however, the opcode insertion routines currently do nothing with
1902          limm values.  */
1903       if (operand->fmt == 'B')
1904         {
1905           assert ((operand->flags & ARC_OPERAND_RELATIVE_BRANCH) != 0
1906                   && operand->bits == 20
1907                   && operand->shift == 7);
1908           fixP->fx_r_type = BFD_RELOC_ARC_B22_PCREL;
1909         }
1910       else if (operand->fmt == 'J')
1911         {
1912           assert ((operand->flags & ARC_OPERAND_ABSOLUTE_BRANCH) != 0
1913                   && operand->bits == 24
1914                   && operand->shift == 32);
1915           fixP->fx_r_type = BFD_RELOC_ARC_B26;
1916         }
1917       else if (operand->fmt == 'L')
1918         {
1919           assert ((operand->flags & ARC_OPERAND_LIMM) != 0
1920                   && operand->bits == 32
1921                   && operand->shift == 32);
1922           fixP->fx_r_type = BFD_RELOC_32;
1923         }
1924       else
1925         {
1926           as_bad_where (fixP->fx_file, fixP->fx_line,
1927                         "unresolved expression that must be resolved");
1928           fixP->fx_done = 1;
1929           return;
1930         }
1931     }
1932   else
1933     {
1934       switch (fixP->fx_r_type)
1935         {
1936         case BFD_RELOC_8:
1937           md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
1938                               value, 1);
1939           break;
1940         case BFD_RELOC_16:
1941           md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
1942                               value, 2);
1943           break;
1944         case BFD_RELOC_32:
1945           md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
1946                               value, 4);
1947           break;
1948         case BFD_RELOC_ARC_B26:
1949           /* If !fixP->fx_done then `value' is an implicit addend.
1950              We must shift it right by 2 in this case as well because the
1951              linker performs the relocation and then adds this in (as opposed
1952              to adding this in and then shifting right by 2).  */
1953           value >>= 2;
1954           md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
1955                               value, 4);
1956           break;
1957         default:
1958           abort ();
1959         }
1960     }
1961 }
1962
1963 /* Translate internal representation of relocation info to BFD target
1964    format.  */
1965
1966 arelent *
1967 tc_gen_reloc (section, fixP)
1968      asection *section ATTRIBUTE_UNUSED;
1969      fixS *fixP;
1970 {
1971   arelent *reloc;
1972
1973   reloc = (arelent *) xmalloc (sizeof (arelent));
1974   reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
1975
1976   *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixP->fx_addsy);
1977   reloc->address = fixP->fx_frag->fr_address + fixP->fx_where;
1978   reloc->howto = bfd_reloc_type_lookup (stdoutput, fixP->fx_r_type);
1979   if (reloc->howto == (reloc_howto_type *) NULL)
1980     {
1981       as_bad_where (fixP->fx_file, fixP->fx_line,
1982                     "internal error: can't export reloc type %d (`%s')",
1983                     fixP->fx_r_type,
1984                     bfd_get_reloc_code_name (fixP->fx_r_type));
1985       return NULL;
1986     }
1987
1988   assert (!fixP->fx_pcrel == !reloc->howto->pc_relative);
1989
1990   /* Set addend to account for PC being advanced one insn before the
1991      target address is computed.  */
1992
1993   reloc->addend = (fixP->fx_pcrel ? -4 : 0);
1994
1995   return reloc;
1996 }