gas/config/tc-rx.c

   1 /* tc-rx.c -- Assembler for the Renesas RX
   2    Copyright (C) 2008-2019 Free Software Foundation, Inc.
   3
   4    This file is part of GAS, the GNU Assembler.
   5
   6    GAS is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3, or (at your option)
   9    any later version.
  10
  11    GAS is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with GAS; see the file COPYING.  If not, write to the Free
  18    Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
  19    02110-1301, USA.  */
  20
  21 #include "as.h"
  22 #include "safe-ctype.h"
  23 #include "dwarf2dbg.h"
  24 #include "elf/common.h"
  25 #include "elf/rx.h"
  26 #include "rx-defs.h"
  27 #include "filenames.h"
  28 #include "listing.h"
  29 #include "sb.h"
  30 #include "macro.h"
  31
  32 #define RX_OPCODE_BIG_ENDIAN 0
  33
  34 const char comment_chars[]        = ";";
  35 /* Note that input_file.c hand checks for '#' at the beginning of the
  36    first line of the input file.  This is because the compiler outputs
  37    #NO_APP at the beginning of its output.  */
  38 const char line_comment_chars[]   = "#";
  39 const char line_separator_chars[] = "!";
  40
  41 const char EXP_CHARS[]            = "eE";
  42 const char FLT_CHARS[]            = "dD";
  43 \f
  44 /* ELF flags to set in the output file header.  */
  45 static int elf_flags = E_FLAG_RX_ABI;
  46
  47 #ifndef TE_LINUX
  48 bfd_boolean rx_use_conventional_section_names = FALSE;
  49 #else
  50 bfd_boolean rx_use_conventional_section_names = TRUE;
  51 #endif
  52 static bfd_boolean rx_use_small_data_limit = FALSE;
  53
  54 static bfd_boolean rx_pid_mode = FALSE;
  55 static int rx_num_int_regs = 0;
  56 int rx_pid_register;
  57 int rx_gp_register;
  58
  59 enum rx_cpu_types rx_cpu = RX600;
  60
  61 static void rx_fetchalign (int ignore ATTRIBUTE_UNUSED);
  62
  63 enum options
  64 {
  65   OPTION_BIG = OPTION_MD_BASE,
  66   OPTION_LITTLE,
  67   OPTION_32BIT_DOUBLES,
  68   OPTION_64BIT_DOUBLES,
  69   OPTION_CONVENTIONAL_SECTION_NAMES,
  70   OPTION_RENESAS_SECTION_NAMES,
  71   OPTION_SMALL_DATA_LIMIT,
  72   OPTION_RELAX,
  73   OPTION_PID,
  74   OPTION_INT_REGS,
  75   OPTION_USES_GCC_ABI,
  76   OPTION_USES_RX_ABI,
  77   OPTION_CPU,
  78   OPTION_DISALLOW_STRING_INSNS,
  79 };
  80
  81 #define RX_SHORTOPTS ""
  82 const char * md_shortopts = RX_SHORTOPTS;
  83
  84 /* Assembler options.  */
  85 struct option md_longopts[] =
  86 {
  87   {"mbig-endian-data", no_argument, NULL, OPTION_BIG},
  88   {"mlittle-endian-data", no_argument, NULL, OPTION_LITTLE},
  89   /* The next two switches are here because the
  90      generic parts of the linker testsuite uses them.  */
  91   {"EB", no_argument, NULL, OPTION_BIG},
  92   {"EL", no_argument, NULL, OPTION_LITTLE},
  93   {"m32bit-doubles", no_argument, NULL, OPTION_32BIT_DOUBLES},
  94   {"m64bit-doubles", no_argument, NULL, OPTION_64BIT_DOUBLES},
  95   /* This option is here mainly for the binutils testsuites,
  96      as many of their tests assume conventional section naming.  */
  97   {"muse-conventional-section-names", no_argument, NULL, OPTION_CONVENTIONAL_SECTION_NAMES},
  98   {"muse-renesas-section-names", no_argument, NULL, OPTION_RENESAS_SECTION_NAMES},
  99   {"msmall-data-limit", no_argument, NULL, OPTION_SMALL_DATA_LIMIT},
 100   {"relax", no_argument, NULL, OPTION_RELAX},
 101   {"mpid", no_argument, NULL, OPTION_PID},
 102   {"mint-register", required_argument, NULL, OPTION_INT_REGS},
 103   {"mgcc-abi", no_argument, NULL, OPTION_USES_GCC_ABI},
 104   {"mrx-abi", no_argument, NULL, OPTION_USES_RX_ABI},
 105   {"mcpu", required_argument, NULL, OPTION_CPU},
 106   {"mno-allow-string-insns", no_argument, NULL, OPTION_DISALLOW_STRING_INSNS},
 107   {NULL, no_argument, NULL, 0}
 108 };
 109 size_t md_longopts_size = sizeof (md_longopts);
 110
 111 struct cpu_type
 112 {
 113   const char *cpu_name;
 114   enum rx_cpu_types type;
 115   int flag;
 116 };
 117
 118 struct cpu_type  cpu_type_list[] =
 119 {
 120   {"rx100", RX100, 0},
 121   {"rx200", RX200, 0},
 122   {"rx600", RX600, 0},
 123   {"rx610", RX610, 0},
 124   {"rxv2",  RXV2,  E_FLAG_RX_V2},
 125   {"rxv3",  RXV3,  E_FLAG_RX_V3},
 126   {"rxv3-dfpu",  RXV3FPU,  E_FLAG_RX_V3},
 127 };
 128
 129 int
 130 md_parse_option (int c ATTRIBUTE_UNUSED, const char * arg ATTRIBUTE_UNUSED)
 131 {
 132   switch (c)
 133     {
 134     case OPTION_BIG:
 135       target_big_endian = 1;
 136       return 1;
 137
 138     case OPTION_LITTLE:
 139       target_big_endian = 0;
 140       return 1;
 141
 142     case OPTION_32BIT_DOUBLES:
 143       elf_flags &= ~ E_FLAG_RX_64BIT_DOUBLES;
 144       return 1;
 145
 146     case OPTION_64BIT_DOUBLES:
 147       elf_flags |= E_FLAG_RX_64BIT_DOUBLES;
 148       return 1;
 149
 150     case OPTION_CONVENTIONAL_SECTION_NAMES:
 151       rx_use_conventional_section_names = TRUE;
 152       return 1;
 153
 154     case OPTION_RENESAS_SECTION_NAMES:
 155       rx_use_conventional_section_names = FALSE;
 156       return 1;
 157
 158     case OPTION_SMALL_DATA_LIMIT:
 159       rx_use_small_data_limit = TRUE;
 160       return 1;
 161
 162     case OPTION_RELAX:
 163       linkrelax = 1;
 164       return 1;
 165
 166     case OPTION_PID:
 167       rx_pid_mode = TRUE;
 168       elf_flags |= E_FLAG_RX_PID;
 169       return 1;
 170
 171     case OPTION_INT_REGS:
 172       rx_num_int_regs = atoi (optarg);
 173       return 1;
 174
 175     case OPTION_USES_GCC_ABI:
 176       elf_flags &= ~ E_FLAG_RX_ABI;
 177       return 1;
 178
 179     case OPTION_USES_RX_ABI:
 180       elf_flags |= E_FLAG_RX_ABI;
 181       return 1;
 182
 183     case OPTION_CPU:
 184       {
 185         unsigned int i;
 186         for (i = 0; i < ARRAY_SIZE (cpu_type_list); i++)
 187           {
 188             if (strcasecmp (arg, cpu_type_list[i].cpu_name) == 0)
 189               {
 190                 rx_cpu = cpu_type_list[i].type;
 191                 elf_flags |= cpu_type_list[i].flag;
 192                 return 1;
 193               }
 194           }
 195         as_warn (_("unrecognised RX CPU type %s"), arg);
 196         break;
 197       }
 198
 199     case OPTION_DISALLOW_STRING_INSNS:
 200       elf_flags |= E_FLAG_RX_SINSNS_SET | E_FLAG_RX_SINSNS_NO;
 201       return 1;
 202     }
 203
 204   return 0;
 205 }
 206
 207 void
 208 md_show_usage (FILE * stream)
 209 {
 210   fprintf (stream, _(" RX specific command line options:\n"));
 211   fprintf (stream, _("  --mbig-endian-data\n"));
 212   fprintf (stream, _("  --mlittle-endian-data [default]\n"));
 213   fprintf (stream, _("  --m32bit-doubles [default]\n"));
 214   fprintf (stream, _("  --m64bit-doubles\n"));
 215   fprintf (stream, _("  --muse-conventional-section-names\n"));
 216   fprintf (stream, _("  --muse-renesas-section-names [default]\n"));
 217   fprintf (stream, _("  --msmall-data-limit\n"));
 218   fprintf (stream, _("  --mrelax\n"));
 219   fprintf (stream, _("  --mpid\n"));
 220   fprintf (stream, _("  --mint-register=<value>\n"));
 221   fprintf (stream, _("  --mcpu=<rx100|rx200|rx600|rx610|rxv2|rxv3|rxv3-dfpu>\n"));
 222   fprintf (stream, _("  --mno-allow-string-insns"));
 223 }
 224
 225 static void
 226 s_bss (int ignore ATTRIBUTE_UNUSED)
 227 {
 228   int temp;
 229
 230   temp = get_absolute_expression ();
 231   subseg_set (bss_section, (subsegT) temp);
 232   demand_empty_rest_of_line ();
 233 }
 234
 235 static void
 236 rx_float_cons (int ignore ATTRIBUTE_UNUSED)
 237 {
 238   if (elf_flags & E_FLAG_RX_64BIT_DOUBLES)
 239     return float_cons ('d');
 240   return float_cons ('f');
 241 }
 242
 243 static char *
 244 rx_strcasestr (const char *string, const char *sub)
 245 {
 246   int subl;
 247   int strl;
 248
 249   if (!sub || !sub[0])
 250     return (char *)string;
 251
 252   subl = strlen (sub);
 253   strl = strlen (string);
 254
 255   while (strl >= subl)
 256     {
 257       /* strncasecmp is in libiberty.  */
 258       if (strncasecmp (string, sub, subl) == 0)
 259         return (char *)string;
 260
 261       string ++;
 262       strl --;
 263     }
 264   return NULL;
 265 }
 266
 267 static void
 268 rx_include (int ignore)
 269 {
 270   FILE * try;
 271   char * path;
 272   char * filename;
 273   const char * current_filename;
 274   char * last_char;
 275   const char * p;
 276   const char * d;
 277   char * f;
 278   char   end_char;
 279   size_t len;
 280
 281   /* The RX version of the .INCLUDE pseudo-op does not
 282      have to have the filename inside double quotes.  */
 283   SKIP_WHITESPACE ();
 284   if (*input_line_pointer == '"')
 285     {
 286       /* Treat as the normal GAS .include pseudo-op.  */
 287       s_include (ignore);
 288       return;
 289     }
 290
 291   /* Get the filename.  Spaces are allowed, NUL characters are not.  */
 292   filename = input_line_pointer;
 293   last_char = find_end_of_line (filename, FALSE);
 294   input_line_pointer = last_char;
 295
 296   while (last_char >= filename && (* last_char == ' ' || * last_char == '\n'))
 297     -- last_char;
 298   end_char = *(++ last_char);
 299   * last_char = 0;
 300   if (last_char == filename)
 301     {
 302       as_bad (_("no filename following .INCLUDE pseudo-op"));
 303       * last_char = end_char;
 304       return;
 305     }
 306
 307    current_filename = as_where (NULL);
 308   f = XNEWVEC (char, strlen (current_filename) + strlen (filename) + 1);
 309
 310   /* Check the filename.  If [@]..FILE[@] is found then replace
 311      this with the current assembler source filename, stripped
 312      of any directory prefixes or extensions.  */
 313   if ((p = rx_strcasestr (filename, "..file")) != NULL)
 314     {
 315       const char * c;
 316
 317       len = 6; /* strlen ("..file"); */
 318
 319       if (p > filename && p[-1] == '@')
 320         -- p, ++len;
 321
 322       if (p[len] == '@')
 323         len ++;
 324
 325       for (d = c = current_filename; *c; c++)
 326         if (IS_DIR_SEPARATOR (* c))
 327           d = c + 1;
 328       for (c = d; *c; c++)
 329         if (*c == '.')
 330           break;
 331
 332       sprintf (f, "%.*s%.*s%.*s", (int) (p - filename), filename,
 333                (int) (c - d), d,
 334                (int) (strlen (filename) - ((p + len) - filename)),
 335                p + len);
 336     }
 337   else
 338     strcpy (f, filename);
 339
 340   /* RX .INCLUDE semantics say that 'filename' is located by:
 341
 342      1. If filename is absolute, just try that.  Otherwise...
 343
 344      2. If the current source file includes a directory component
 345         then prepend that to the filename and try.  Otherwise...
 346
 347      3. Try any directories specified by the -I command line
 348         option(s).
 349
 350      4 .Try a directory specified by the INC100 environment variable.  */
 351
 352   if (IS_ABSOLUTE_PATH (f))
 353     try = fopen (path = f, FOPEN_RT);
 354   else
 355     {
 356       char * env = getenv ("INC100");
 357
 358       try = NULL;
 359
 360       len = strlen (current_filename);
 361       if ((size_t) include_dir_maxlen > len)
 362         len = include_dir_maxlen;
 363       if (env && strlen (env) > len)
 364         len = strlen (env);
 365
 366       path = XNEWVEC (char, strlen (f) + len + 5);
 367
 368       if (current_filename != NULL)
 369         {
 370           for (d = NULL, p = current_filename; *p; p++)
 371             if (IS_DIR_SEPARATOR (* p))
 372               d = p;
 373
 374           if (d != NULL)
 375             {
 376               sprintf (path, "%.*s/%s", (int) (d - current_filename), current_filename,
 377                        f);
 378               try = fopen (path, FOPEN_RT);
 379             }
 380         }
 381
 382       if (try == NULL)
 383         {
 384           int i;
 385
 386           for (i = 0; i < include_dir_count; i++)
 387             {
 388               sprintf (path, "%s/%s", include_dirs[i], f);
 389               if ((try = fopen (path, FOPEN_RT)) != NULL)
 390                 break;
 391             }
 392         }
 393
 394       if (try == NULL && env != NULL)
 395         {
 396           sprintf (path, "%s/%s", env, f);
 397           try = fopen (path, FOPEN_RT);
 398         }
 399
 400       free (f);
 401     }
 402
 403   if (try == NULL)
 404     {
 405       as_bad (_("unable to locate include file: %s"), filename);
 406       free (path);
 407     }
 408   else
 409     {
 410       fclose (try);
 411       register_dependency (path);
 412       input_scrub_insert_file (path);
 413     }
 414
 415   * last_char = end_char;
 416 }
 417
 418 static void
 419 parse_rx_section (char * name)
 420 {
 421   asection * sec;
 422   int   type;
 423   int   attr = SHF_ALLOC | SHF_EXECINSTR;
 424   int   align = 1;
 425   char  end_char;
 426
 427   do
 428     {
 429       char * p;
 430
 431       SKIP_WHITESPACE ();
 432       for (p = input_line_pointer; *p && strchr ("\n\t, =", *p) == NULL; p++)
 433         ;
 434       end_char = *p;
 435       *p = 0;
 436
 437       if (strcasecmp (input_line_pointer, "ALIGN") == 0)
 438         {
 439           *p = end_char;
 440
 441           if (end_char == ' ')
 442             while (ISSPACE (*p))
 443               p++;
 444
 445           if (*p == '=')
 446             {
 447               ++ p;
 448               while (ISSPACE (*p))
 449                 p++;
 450               switch (*p)
 451                 {
 452                 case '2': align = 1; break;
 453                 case '4': align = 2; break;
 454                 case '8': align = 3; break;
 455                 default:
 456                   as_bad (_("unrecognised alignment value in .SECTION directive: %s"), p);
 457                   ignore_rest_of_line ();
 458                   return;
 459                 }
 460               ++ p;
 461             }
 462
 463           end_char = *p;
 464         }
 465       else if (strcasecmp (input_line_pointer, "CODE") == 0)
 466         attr = SHF_ALLOC | SHF_EXECINSTR;
 467       else if (strcasecmp (input_line_pointer, "DATA") == 0)
 468         attr = SHF_ALLOC | SHF_WRITE;
 469       else if (strcasecmp (input_line_pointer, "ROMDATA") == 0)
 470         attr = SHF_ALLOC;
 471       else
 472         {
 473           as_bad (_("unknown parameter following .SECTION directive: %s"),
 474                   input_line_pointer);
 475
 476           *p = end_char;
 477           input_line_pointer = p + 1;
 478           ignore_rest_of_line ();
 479           return;
 480         }
 481
 482       *p = end_char;
 483       input_line_pointer = p + 1;
 484     }
 485   while (end_char != '\n' && end_char != 0);
 486
 487   if ((sec = bfd_get_section_by_name (stdoutput, name)) == NULL)
 488     {
 489       if (strcmp (name, "B") && strcmp (name, "B_1") && strcmp (name, "B_2"))
 490         type = SHT_NULL;
 491       else
 492         type = SHT_NOBITS;
 493
 494       obj_elf_change_section (name, type, 0, attr, 0, NULL, FALSE, FALSE);
 495     }
 496   else /* Try not to redefine a section, especially B_1.  */
 497     {
 498       int flags = sec->flags;
 499
 500       type = elf_section_type (sec);
 501
 502       attr = ((flags & SEC_READONLY) ? 0 : SHF_WRITE)
 503         | ((flags & SEC_ALLOC) ? SHF_ALLOC : 0)
 504         | ((flags & SEC_CODE) ? SHF_EXECINSTR : 0)
 505         | ((flags & SEC_MERGE) ? SHF_MERGE : 0)
 506         | ((flags & SEC_STRINGS) ? SHF_STRINGS : 0)
 507         | ((flags & SEC_THREAD_LOCAL) ? SHF_TLS : 0);
 508
 509       obj_elf_change_section (name, type, 0, attr, 0, NULL, FALSE, FALSE);
 510     }
 511
 512   bfd_set_section_alignment (stdoutput, now_seg, align);
 513 }
 514
 515 static void
 516 rx_section (int ignore)
 517 {
 518   char * p;
 519
 520   /* The as100 assembler supports a different syntax for the .section
 521      pseudo-op.  So check for it and handle it here if necessary. */
 522   SKIP_WHITESPACE ();
 523
 524   /* Peek past the section name to see if arguments follow.  */
 525   for (p = input_line_pointer; *p; p++)
 526     if (*p == ',' || *p == '\n')
 527       break;
 528
 529   if (*p == ',')
 530     {
 531       int len = p - input_line_pointer;
 532
 533       while (ISSPACE (*++p))
 534         ;
 535
 536       if (*p != '"' && *p != '#')
 537         {
 538           char *name = xmemdup0 (input_line_pointer, len);
 539
 540           input_line_pointer = p;
 541           parse_rx_section (name);
 542           return;
 543         }
 544     }
 545
 546   obj_elf_section (ignore);
 547 }
 548
 549 static void
 550 rx_list (int ignore ATTRIBUTE_UNUSED)
 551 {
 552   SKIP_WHITESPACE ();
 553
 554   if (strncasecmp (input_line_pointer, "OFF", 3))
 555     listing_list (0);
 556   else if (strncasecmp (input_line_pointer, "ON", 2))
 557     listing_list (1);
 558   else
 559     as_warn (_("expecting either ON or OFF after .list"));
 560 }
 561
 562 /* Like the .rept pseudo op, but supports the
 563    use of ..MACREP inside the repeated region.  */
 564
 565 static void
 566 rx_rept (int ignore ATTRIBUTE_UNUSED)
 567 {
 568   size_t count = get_absolute_expression ();
 569
 570   do_repeat_with_expander (count, "MREPEAT", "ENDR", "..MACREP");
 571 }
 572
 573 /* Like cons() accept that strings are allowed.  */
 574
 575 static void
 576 rx_cons (int size)
 577 {
 578   SKIP_WHITESPACE ();
 579
 580   if (* input_line_pointer == '"')
 581     stringer (8+0);
 582   else
 583     cons (size);
 584 }
 585
 586 static void
 587 rx_nop (int ignore ATTRIBUTE_UNUSED)
 588 {
 589   ignore_rest_of_line ();
 590 }
 591
 592 static void
 593 rx_unimp (int idx)
 594 {
 595   as_warn (_("The \".%s\" pseudo-op is not implemented\n"),
 596            md_pseudo_table[idx].poc_name);
 597   ignore_rest_of_line ();
 598 }
 599
 600 /* The target specific pseudo-ops which we support.  */
 601 const pseudo_typeS md_pseudo_table[] =
 602 {
 603   /* These are unimplemented.  They're listed first so that we can use
 604      the poc_value as the index into this array, to get the name of
 605      the pseudo.  So, keep these (1) first, and (2) in order, with (3)
 606      the poc_value's in sequence.  */
 607   { "btglb",    rx_unimp,       0 },
 608   { "call",     rx_unimp,       1 },
 609   { "einsf",    rx_unimp,       2 },
 610   { "fb",       rx_unimp,       3 },
 611   { "fbsym",    rx_unimp,       4 },
 612   { "id",       rx_unimp,       5 },
 613   { "initsct",  rx_unimp,       6 },
 614   { "insf",     rx_unimp,       7 },
 615   { "instr",    rx_unimp,       8 },
 616   { "lbba",     rx_unimp,       9 },
 617   { "len",      rx_unimp,       10 },
 618   { "optj",     rx_unimp,       11 },
 619   { "rvector",  rx_unimp,       12 },
 620   { "sb",       rx_unimp,       13 },
 621   { "sbbit",    rx_unimp,       14 },
 622   { "sbsym",    rx_unimp,       15 },
 623   { "sbsym16",  rx_unimp,       16 },
 624
 625   /* These are the do-nothing pseudos.  */
 626   { "stk",      rx_nop,         0 },
 627   /* The manual documents ".stk" but the compiler emits ".stack".  */
 628   { "stack",    rx_nop,         0 },
 629
 630   /* These are Renesas as100 assembler pseudo-ops that we do support.  */
 631   { "addr",     rx_cons,        3 },
 632   { "align",    s_align_bytes,  2 },
 633   { "byte",     rx_cons,        1 },
 634   { "fixed",    float_cons,    'f' },
 635   { "form",     listing_psize,  0 },
 636   { "glb",      s_globl,        0 },
 637   { "include",  rx_include,     0 },
 638   { "list",     rx_list,        0 },
 639   { "lword",    rx_cons,        4 },
 640   { "mrepeat",  rx_rept,        0 },
 641   { "section",  rx_section,     0 },
 642
 643   /* FIXME: The following pseudo-ops place their values (and associated
 644      label if present) in the data section, regardless of whatever
 645      section we are currently in.  At the moment this code does not
 646      implement that part of the semantics.  */
 647   { "blka",     s_space,        3 },
 648   { "blkb",     s_space,        1 },
 649   { "blkd",     s_space,        8 },
 650   { "blkf",     s_space,        4 },
 651   { "blkl",     s_space,        4 },
 652   { "blkw",     s_space,        2 },
 653
 654   /* Our "standard" pseudos. */
 655   { "double",   rx_float_cons,  0 },
 656   { "bss",      s_bss,          0 },
 657   { "3byte",    cons,           3 },
 658   { "int",      cons,           4 },
 659   { "word",     cons,           4 },
 660
 661   { "fetchalign", rx_fetchalign, 0 },
 662
 663   /* End of list marker.  */
 664   { NULL,       NULL,           0 }
 665 };
 666
 667 static asymbol * gp_symbol;
 668 static asymbol * rx_pid_symbol;
 669
 670 static symbolS * rx_pidreg_symbol;
 671 static symbolS * rx_gpreg_symbol;
 672
 673 void
 674 md_begin (void)
 675 {
 676   /* Make the __gp and __pid_base symbols now rather
 677      than after the symbol table is frozen.  We only do this
 678      when supporting small data limits because otherwise we
 679      pollute the symbol table.  */
 680
 681   /* The meta-registers %pidreg and %gpreg depend on what other
 682      options are specified.  The __rx_*_defined symbols exist so we
 683      can .ifdef asm code based on what options were passed to gas,
 684      without needing a preprocessor  */
 685
 686   if (rx_pid_mode)
 687     {
 688       rx_pid_register = 13 - rx_num_int_regs;
 689       rx_pid_symbol = symbol_get_bfdsym (symbol_find_or_make ("__pid_base"));
 690       rx_pidreg_symbol = symbol_find_or_make ("__rx_pidreg_defined");
 691       S_SET_VALUE (rx_pidreg_symbol, rx_pid_register);
 692       S_SET_SEGMENT (rx_pidreg_symbol, absolute_section);
 693     }
 694
 695   if (rx_use_small_data_limit)
 696     {
 697       if (rx_pid_mode)
 698         rx_gp_register = rx_pid_register - 1;
 699       else
 700         rx_gp_register = 13 - rx_num_int_regs;
 701       gp_symbol = symbol_get_bfdsym (symbol_find_or_make ("__gp"));
 702       rx_gpreg_symbol = symbol_find_or_make ("__rx_gpreg_defined");
 703       S_SET_VALUE (rx_gpreg_symbol, rx_gp_register);
 704       S_SET_SEGMENT (rx_gpreg_symbol, absolute_section);
 705     }
 706 }
 707
 708 char * rx_lex_start;
 709 char * rx_lex_end;
 710
 711 /* These negative numbers are found in rx_bytesT.n_base for non-opcode
 712    md_frags */
 713 #define RX_NBASE_FETCHALIGN     -1
 714
 715 typedef struct rx_bytesT
 716 {
 717   char base[4];
 718   /* If this is negative, it's a special-purpose frag as per the defines above. */
 719   int n_base;
 720   char ops[8];
 721   int n_ops;
 722   struct
 723   {
 724     expressionS  exp;
 725     char         offset;
 726     char         nbits;
 727     char         type; /* RXREL_*.  */
 728     int          reloc;
 729     fixS *       fixP;
 730   } fixups[2];
 731   int n_fixups;
 732   char post[1];
 733   int n_post;
 734   struct
 735   {
 736     char type;
 737     char field_pos;
 738     char val_ofs;
 739   } relax[2];
 740   int n_relax;
 741   int link_relax;
 742   fixS *link_relax_fixP;
 743   unsigned long times_grown;
 744   unsigned long times_shrank;
 745 } rx_bytesT;
 746
 747 static rx_bytesT rx_bytes;
 748 /* We set n_ops to be "size of next opcode" if the next opcode doesn't relax.  */
 749 static rx_bytesT *fetchalign_bytes = NULL;
 750
 751 static void
 752 rx_fetchalign (int ignore ATTRIBUTE_UNUSED)
 753 {
 754   char * bytes;
 755   fragS * frag_then;
 756
 757   memset (& rx_bytes, 0, sizeof (rx_bytes));
 758   rx_bytes.n_base = RX_NBASE_FETCHALIGN;
 759
 760   bytes = frag_more (8);
 761   frag_then = frag_now;
 762   frag_variant (rs_machine_dependent,
 763                 0 /* max_chars */,
 764                 0 /* var */,
 765                 0 /* subtype */,
 766                 0 /* symbol */,
 767                 0 /* offset */,
 768                 0 /* opcode */);
 769   frag_then->fr_opcode = bytes;
 770   frag_then->fr_subtype = 0;
 771   fetchalign_bytes = frag_then->tc_frag_data;
 772 }
 773
 774 void
 775 rx_relax (int type, int pos)
 776 {
 777   rx_bytes.relax[rx_bytes.n_relax].type = type;
 778   rx_bytes.relax[rx_bytes.n_relax].field_pos = pos;
 779   rx_bytes.relax[rx_bytes.n_relax].val_ofs = rx_bytes.n_base + rx_bytes.n_ops;
 780   rx_bytes.n_relax ++;
 781 }
 782
 783 void
 784 rx_linkrelax_dsp (int pos)
 785 {
 786   switch (pos)
 787     {
 788     case 4:
 789       rx_bytes.link_relax |= RX_RELAXA_DSP4;
 790       break;
 791     case 6:
 792       rx_bytes.link_relax |= RX_RELAXA_DSP6;
 793       break;
 794     case 14:
 795       rx_bytes.link_relax |= RX_RELAXA_DSP14;
 796       break;
 797     }
 798 }
 799
 800 void
 801 rx_linkrelax_imm (int pos)
 802 {
 803   switch (pos)
 804     {
 805     case 6:
 806       rx_bytes.link_relax |= RX_RELAXA_IMM6;
 807       break;
 808     case 12:
 809       rx_bytes.link_relax |= RX_RELAXA_IMM12;
 810       break;
 811     }
 812 }
 813
 814 void
 815 rx_linkrelax_branch (void)
 816 {
 817   rx_bytes.link_relax |= RX_RELAXA_BRA;
 818 }
 819
 820 static void
 821 rx_fixup (expressionS exp, int offsetbits, int nbits, int type)
 822 {
 823   rx_bytes.fixups[rx_bytes.n_fixups].exp = exp;
 824   rx_bytes.fixups[rx_bytes.n_fixups].offset = offsetbits;
 825   rx_bytes.fixups[rx_bytes.n_fixups].nbits = nbits;
 826   rx_bytes.fixups[rx_bytes.n_fixups].type = type;
 827   rx_bytes.fixups[rx_bytes.n_fixups].reloc = exp.X_md;
 828   rx_bytes.n_fixups ++;
 829 }
 830
 831 #define rx_field_fixup(exp, offset, nbits, type)        \
 832   rx_fixup (exp, offset, nbits, type)
 833
 834 #define rx_op_fixup(exp, offset, nbits, type)           \
 835   rx_fixup (exp, offset + 8 * rx_bytes.n_base, nbits, type)
 836
 837 void
 838 rx_base1 (int b1)
 839 {
 840   rx_bytes.base[0] = b1;
 841   rx_bytes.n_base = 1;
 842 }
 843
 844 void
 845 rx_base2 (int b1, int b2)
 846 {
 847   rx_bytes.base[0] = b1;
 848   rx_bytes.base[1] = b2;
 849   rx_bytes.n_base = 2;
 850 }
 851
 852 void
 853 rx_base3 (int b1, int b2, int b3)
 854 {
 855   rx_bytes.base[0] = b1;
 856   rx_bytes.base[1] = b2;
 857   rx_bytes.base[2] = b3;
 858   rx_bytes.n_base = 3;
 859 }
 860
 861 void
 862 rx_base4 (int b1, int b2, int b3, int b4)
 863 {
 864   rx_bytes.base[0] = b1;
 865   rx_bytes.base[1] = b2;
 866   rx_bytes.base[2] = b3;
 867   rx_bytes.base[3] = b4;
 868   rx_bytes.n_base = 4;
 869 }
 870
 871 /* This gets complicated when the field spans bytes, because fields
 872    are numbered from the MSB of the first byte as zero, and bits are
 873    stored LSB towards the LSB of the byte.  Thus, a simple four-bit
 874    insertion of 12 at position 4 of 0x00 yields: 0x0b.  A three-bit
 875    insertion of b'MXL at position 7 is like this:
 876
 877      - - - -  - - - -   - - - -  - - - -
 878                     M   X L               */
 879
 880 void
 881 rx_field (int val, int pos, int sz)
 882 {
 883   int valm;
 884   int bytep, bitp;
 885
 886   if (sz > 0)
 887     {
 888       if (val < 0 || val >= (1 << sz))
 889         as_bad (_("Value %d doesn't fit in unsigned %d-bit field"), val, sz);
 890     }
 891   else
 892     {
 893       sz = - sz;
 894       if (val < -(1 << (sz - 1)) || val >= (1 << (sz - 1)))
 895         as_bad (_("Value %d doesn't fit in signed %d-bit field"), val, sz);
 896     }
 897
 898   /* This code points at 'M' in the above example.  */
 899   bytep = pos / 8;
 900   bitp = pos % 8;
 901
 902   while (bitp + sz > 8)
 903     {
 904       int ssz = 8 - bitp;
 905       int svalm;
 906
 907       svalm = val >> (sz - ssz);
 908       svalm = svalm & ((1 << ssz) - 1);
 909       svalm = svalm << (8 - bitp - ssz);
 910       gas_assert (bytep < rx_bytes.n_base);
 911       rx_bytes.base[bytep] |= svalm;
 912
 913       bitp = 0;
 914       sz -= ssz;
 915       bytep ++;
 916     }
 917   valm = val & ((1 << sz) - 1);
 918   valm = valm << (8 - bitp - sz);
 919   gas_assert (bytep < rx_bytes.n_base);
 920   rx_bytes.base[bytep] |= valm;
 921 }
 922
 923 /* Special case of the above, for 3-bit displacements of 2..9.  */
 924
 925 void
 926 rx_disp3 (expressionS exp, int pos)
 927 {
 928   rx_field_fixup (exp, pos, 3, RXREL_PCREL);
 929 }
 930
 931 /* Special case of the above, for split 5-bit displacements.  Assumes
 932    the displacement has been checked with rx_disp5op.  */
 933 /* ---- -432 1--- 0--- */
 934
 935 void
 936 rx_field5s (expressionS exp)
 937 {
 938   int val;
 939
 940   val = exp.X_add_number;
 941   rx_bytes.base[0] |= val >> 2;
 942   rx_bytes.base[1] |= (val << 6) & 0x80;
 943   rx_bytes.base[1] |= (val << 3) & 0x08;
 944 }
 945
 946 /* ---- ---- 4--- 3210 */
 947
 948 void
 949 rx_field5s2 (expressionS exp)
 950 {
 951   int val;
 952
 953   val = exp.X_add_number;
 954   rx_bytes.base[1] |= (val << 3) & 0x80;
 955   rx_bytes.base[1] |= (val     ) & 0x0f;
 956 }
 957
 958 void
 959 rx_bfield(expressionS s, expressionS d, expressionS w)
 960 {
 961   int slsb = s.X_add_number;
 962   int dlsb = d.X_add_number;
 963   int width = w.X_add_number;
 964   unsigned int imm =
 965     (((dlsb + width) & 0x1f) << 10 | (dlsb << 5) |
 966      ((dlsb - slsb) & 0x1f));
 967   if ((slsb + width) > 32)
 968         as_warn (_("Value %d and %d out of range"), slsb, width);
 969   if ((dlsb + width) > 32)
 970         as_warn (_("Value %d and %d out of range"), dlsb, width);
 971   rx_bytes.ops[0] = imm & 0xff;
 972   rx_bytes.ops[1] = (imm >> 8);
 973   rx_bytes.n_ops = 2;
 974 }
 975
 976 #define OP(x) rx_bytes.ops[rx_bytes.n_ops++] = (x)
 977
 978 #define F_PRECISION 2
 979
 980 void
 981 rx_op (expressionS exp, int nbytes, int type)
 982 {
 983   offsetT v = 0;
 984
 985   if ((exp.X_op == O_constant || exp.X_op == O_big)
 986       && type != RXREL_PCREL)
 987     {
 988       if (exp.X_op == O_big)
 989         {
 990           if (exp.X_add_number == -1)
 991             {
 992               LITTLENUM_TYPE w[2];
 993               char * ip = rx_bytes.ops + rx_bytes.n_ops;
 994
 995               gen_to_words (w, F_PRECISION, 8);
 996 #if RX_OPCODE_BIG_ENDIAN
 997               ip[0] = w[0] >> 8;
 998               ip[1] = w[0];
 999               ip[2] = w[1] >> 8;
1000               ip[3] = w[1];
1001 #else
1002               ip[3] = w[0] >> 8;
1003               ip[2] = w[0];
1004               ip[1] = w[1] >> 8;
1005               ip[0] = w[1];
1006 #endif
1007               rx_bytes.n_ops += 4;
1008               return;
1009             }
1010
1011           v = ((generic_bignum[1] & LITTLENUM_MASK) << LITTLENUM_NUMBER_OF_BITS)
1012             |  (generic_bignum[0] & LITTLENUM_MASK);
1013
1014         }
1015       else
1016         v = exp.X_add_number;
1017
1018       while (nbytes)
1019         {
1020 #if RX_OPCODE_BIG_ENDIAN
1021           OP ((v >> (8 * (nbytes - 1))) & 0xff);
1022 #else
1023           OP (v & 0xff);
1024           v >>= 8;
1025 #endif
1026           nbytes --;
1027         }
1028     }
1029   else
1030     {
1031       rx_op_fixup (exp, rx_bytes.n_ops * 8, nbytes * 8, type);
1032       memset (rx_bytes.ops + rx_bytes.n_ops, 0, nbytes);
1033       rx_bytes.n_ops += nbytes;
1034     }
1035 }
1036
1037 void rx_post(char byte)
1038 {
1039   rx_bytes.post[rx_bytes.n_post++] = byte;
1040 }
1041
1042 int
1043 rx_wrap (void)
1044 {
1045   return 0;
1046 }
1047
1048 #define APPEND(B, N_B)                                 \
1049   if (rx_bytes.N_B)                                    \
1050     {                                                  \
1051       memcpy (bytes + idx, rx_bytes.B, rx_bytes.N_B);  \
1052       idx += rx_bytes.N_B;                             \
1053     }
1054
1055 void
1056 rx_frag_init (fragS * fragP)
1057 {
1058   if (rx_bytes.n_relax || rx_bytes.link_relax || rx_bytes.n_base < 0)
1059     {
1060       fragP->tc_frag_data = XNEW (rx_bytesT);
1061       memcpy (fragP->tc_frag_data, & rx_bytes, sizeof (rx_bytesT));
1062     }
1063   else
1064     fragP->tc_frag_data = 0;
1065 }
1066
1067 /* Handle the as100's version of the .equ pseudo-op.  It has the syntax:
1068    <symbol_name> .equ <expression>   */
1069
1070 static void
1071 rx_equ (char * name, char * expression)
1072 {
1073   char   saved_name_end_char;
1074   char * name_end;
1075   char * saved_ilp;
1076
1077   while (ISSPACE (* name))
1078     name ++;
1079
1080   for (name_end = name + 1; *name_end; name_end ++)
1081     if (! ISALNUM (* name_end))
1082       break;
1083
1084   saved_name_end_char = * name_end;
1085   * name_end = 0;
1086
1087   saved_ilp = input_line_pointer;
1088   input_line_pointer = expression;
1089
1090   equals (name, 1);
1091
1092   input_line_pointer = saved_ilp;
1093   * name_end = saved_name_end_char;
1094 }
1095
1096 /* Look for Renesas as100 pseudo-ops that occur after a symbol name
1097    rather than at the start of a line.  (eg .EQU or .DEFINE).  If one
1098    is found, process it and return TRUE otherwise return FALSE.  */
1099
1100 static bfd_boolean
1101 scan_for_infix_rx_pseudo_ops (char * str)
1102 {
1103   char * p;
1104   char * pseudo_op;
1105   char * dot = strchr (str, '.');
1106
1107   if (dot == NULL || dot == str)
1108     return FALSE;
1109
1110   /* A real pseudo-op must be preceded by whitespace.  */
1111   if (dot[-1] != ' ' && dot[-1] != '\t')
1112     return FALSE;
1113
1114   pseudo_op = dot + 1;
1115
1116   if (!ISALNUM (* pseudo_op))
1117     return FALSE;
1118
1119   for (p = pseudo_op + 1; ISALNUM (* p); p++)
1120     ;
1121
1122   if (strncasecmp ("EQU", pseudo_op, p - pseudo_op) == 0)
1123     rx_equ (str, p);
1124   else if (strncasecmp ("DEFINE", pseudo_op, p - pseudo_op) == 0)
1125     as_warn (_("The .DEFINE pseudo-op is not implemented"));
1126   else if (strncasecmp ("MACRO", pseudo_op, p - pseudo_op) == 0)
1127     as_warn (_("The .MACRO pseudo-op is not implemented"));
1128   else if (strncasecmp ("BTEQU", pseudo_op, p - pseudo_op) == 0)
1129     as_warn (_("The .BTEQU pseudo-op is not implemented."));
1130   else
1131     return FALSE;
1132
1133   return TRUE;
1134 }
1135
1136 void
1137 md_assemble (char * str)
1138 {
1139   char * bytes;
1140   int idx = 0;
1141   int i, rel;
1142   fragS * frag_then = frag_now;
1143   expressionS  *exp;
1144
1145   memset (& rx_bytes, 0, sizeof (rx_bytes));
1146
1147   rx_lex_init (str, str + strlen (str));
1148   if (scan_for_infix_rx_pseudo_ops (str))
1149     return;
1150   rx_parse ();
1151
1152   /* This simplifies the relaxation code.  */
1153   if (rx_bytes.n_relax || rx_bytes.link_relax)
1154     {
1155       /* We do it this way because we want the frag to have the
1156          rx_bytes in it, which we initialize above.  */
1157       bytes = frag_more (12);
1158       frag_then = frag_now;
1159       frag_variant (rs_machine_dependent,
1160                     0 /* max_chars */,
1161                     0 /* var */,
1162                     0 /* subtype */,
1163                     0 /* symbol */,
1164                     0 /* offset */,
1165                     0 /* opcode */);
1166       frag_then->fr_opcode = bytes;
1167       frag_then->fr_fix += rx_bytes.n_base + rx_bytes.n_ops + rx_bytes.n_post;
1168       frag_then->fr_subtype = rx_bytes.n_base + rx_bytes.n_ops + rx_bytes.n_post;
1169     }
1170   else
1171     {
1172       bytes = frag_more (rx_bytes.n_base + rx_bytes.n_ops + rx_bytes.n_post);
1173       frag_then = frag_now;
1174       if (fetchalign_bytes)
1175         fetchalign_bytes->n_ops = rx_bytes.n_base + rx_bytes.n_ops + rx_bytes.n_post;
1176     }
1177
1178   fetchalign_bytes = NULL;
1179
1180   APPEND (base, n_base);
1181   APPEND (ops, n_ops);
1182   APPEND (post, n_post);
1183
1184   if (rx_bytes.link_relax && rx_bytes.n_fixups)
1185     {
1186       fixS * f;
1187
1188       f = fix_new (frag_then,
1189                    (char *) bytes - frag_then->fr_literal,
1190                    0,
1191                    abs_section_sym,
1192                    rx_bytes.link_relax | rx_bytes.n_fixups,
1193                    0,
1194                    BFD_RELOC_RX_RELAX);
1195       frag_then->tc_frag_data->link_relax_fixP = f;
1196     }
1197
1198   for (i = 0; i < rx_bytes.n_fixups; i ++)
1199     {
1200       /* index: [nbytes][type] */
1201       static int reloc_map[5][4] =
1202         {
1203           { 0,                  0,                0,                  BFD_RELOC_RX_DIR3U_PCREL },
1204           { BFD_RELOC_8,        BFD_RELOC_RX_8U,  BFD_RELOC_RX_NEG8,  BFD_RELOC_8_PCREL },
1205           { BFD_RELOC_RX_16_OP, BFD_RELOC_RX_16U, BFD_RELOC_RX_NEG16, BFD_RELOC_16_PCREL },
1206           { BFD_RELOC_RX_24_OP, BFD_RELOC_RX_24U, BFD_RELOC_RX_NEG24, BFD_RELOC_24_PCREL },
1207           { BFD_RELOC_RX_32_OP, BFD_RELOC_32,     BFD_RELOC_RX_NEG32, BFD_RELOC_32_PCREL },
1208         };
1209       fixS * f;
1210
1211       idx = rx_bytes.fixups[i].offset / 8;
1212       rel = reloc_map [rx_bytes.fixups[i].nbits / 8][(int) rx_bytes.fixups[i].type];
1213
1214       if (rx_bytes.fixups[i].reloc)
1215         rel = rx_bytes.fixups[i].reloc;
1216
1217       if (frag_then->tc_frag_data)
1218         exp = & frag_then->tc_frag_data->fixups[i].exp;
1219       else
1220         exp = & rx_bytes.fixups[i].exp;
1221
1222       f = fix_new_exp (frag_then,
1223                        (char *) bytes + idx - frag_then->fr_literal,
1224                        rx_bytes.fixups[i].nbits / 8,
1225                        exp,
1226                        rx_bytes.fixups[i].type == RXREL_PCREL ? 1 : 0,
1227                        rel);
1228       if (frag_then->tc_frag_data)
1229         frag_then->tc_frag_data->fixups[i].fixP = f;
1230     }
1231   dwarf2_emit_insn (idx);
1232 }
1233
1234 void
1235 rx_md_end (void)
1236 {
1237 }
1238
1239 /* Write a value out to the object file, using the appropriate endianness.  */
1240
1241 void
1242 md_number_to_chars (char * buf, valueT val, int n)
1243 {
1244   if (target_big_endian)
1245     number_to_chars_bigendian (buf, val, n);
1246   else
1247     number_to_chars_littleendian (buf, val, n);
1248 }
1249
1250 static struct
1251 {
1252   const char * fname;
1253   int    reloc;
1254 }
1255 reloc_functions[] =
1256 {
1257   { "gp", BFD_RELOC_GPREL16 },
1258   { 0, 0 }
1259 };
1260
1261 void
1262 md_operand (expressionS * exp ATTRIBUTE_UNUSED)
1263 {
1264   int reloc = 0;
1265   int i;
1266
1267   for (i = 0; reloc_functions[i].fname; i++)
1268     {
1269       int flen = strlen (reloc_functions[i].fname);
1270
1271       if (input_line_pointer[0] == '%'
1272           && strncasecmp (input_line_pointer + 1, reloc_functions[i].fname, flen) == 0
1273           && input_line_pointer[flen + 1] == '(')
1274         {
1275           reloc = reloc_functions[i].reloc;
1276           input_line_pointer += flen + 2;
1277           break;
1278         }
1279     }
1280   if (reloc == 0)
1281     return;
1282
1283   expression (exp);
1284   if (* input_line_pointer == ')')
1285     input_line_pointer ++;
1286
1287   exp->X_md = reloc;
1288 }
1289
1290 valueT
1291 md_section_align (segT segment, valueT size)
1292 {
1293   int align = bfd_get_section_alignment (stdoutput, segment);
1294   return ((size + (1 << align) - 1) & -(1 << align));
1295 }
1296
1297                                 /* NOP - 1 cycle */
1298 static unsigned char nop_1[] = { 0x03};
1299                                 /* MOV.L R0,R0 - 1 cycle */
1300 static unsigned char nop_2[] = { 0xef, 0x00};
1301                                 /* MAX R0,R0 - 1 cycle */
1302 static unsigned char nop_3[] = { 0xfc, 0x13, 0x00 };
1303                                 /* MUL #1,R0 - 1 cycle */
1304 static unsigned char nop_4[] = { 0x76, 0x10, 0x01, 0x00 };
1305                                 /* MUL #1,R0 - 1 cycle */
1306 static unsigned char nop_5[] = { 0x77, 0x10, 0x01, 0x00, 0x00 };
1307                                 /* MUL #1,R0 - 1 cycle */
1308 static unsigned char nop_6[] = { 0x74, 0x10, 0x01, 0x00, 0x00, 0x00 };
1309                                 /* MAX 0x80000000,R0 - 1 cycle */
1310 static unsigned char nop_7[] = { 0xFD, 0x70, 0x40, 0x00, 0x00, 0x00, 0x80 };
1311
1312 static unsigned char *nops[] = { NULL, nop_1, nop_2, nop_3, nop_4, nop_5, nop_6, nop_7 };
1313 #define BIGGEST_NOP 7
1314
1315 /* When relaxing, we need to output a reloc for any .align directive
1316    so that we can retain this alignment as we adjust opcode sizes.  */
1317 void
1318 rx_handle_align (fragS * frag)
1319 {
1320   /* If handling an alignment frag, use an optimal NOP pattern.
1321      Only do this if a fill value has not already been provided.
1322      FIXME: This test fails if the provided fill value is zero.  */
1323   if ((frag->fr_type == rs_align
1324        || frag->fr_type == rs_align_code)
1325       && subseg_text_p (now_seg))
1326     {
1327       int count = (frag->fr_next->fr_address
1328                    - frag->fr_address
1329                    - frag->fr_fix);
1330       unsigned char *base = (unsigned char *)frag->fr_literal + frag->fr_fix;
1331
1332       if (* base == 0)
1333         {
1334           if (count > BIGGEST_NOP)
1335             {
1336               base[0] = 0x2e;
1337               base[1] = count;
1338               frag->fr_var = 2;
1339             }
1340           else if (count > 0)
1341             {
1342               memcpy (base, nops[count], count);
1343               frag->fr_var = count;
1344             }
1345         }
1346     }
1347
1348   if (linkrelax
1349       && (frag->fr_type == rs_align
1350           || frag->fr_type == rs_align_code)
1351       && frag->fr_address + frag->fr_fix > 0
1352       && frag->fr_offset > 0
1353       && now_seg != bss_section)
1354     {
1355       fix_new (frag, frag->fr_fix, 0,
1356                &abs_symbol, RX_RELAXA_ALIGN + frag->fr_offset,
1357                0, BFD_RELOC_RX_RELAX);
1358       /* For the purposes of relaxation, this relocation is attached
1359          to the byte *after* the alignment - i.e. the byte that must
1360          remain aligned.  */
1361       fix_new (frag->fr_next, 0, 0,
1362                &abs_symbol, RX_RELAXA_ELIGN + frag->fr_offset,
1363                0, BFD_RELOC_RX_RELAX);
1364     }
1365 }
1366
1367 const char *
1368 md_atof (int type, char * litP, int * sizeP)
1369 {
1370   return ieee_md_atof (type, litP, sizeP, target_big_endian);
1371 }
1372
1373 symbolS *
1374 md_undefined_symbol (char * name ATTRIBUTE_UNUSED)
1375 {
1376   return NULL;
1377 }
1378
1379 /*----------------------------------------------------------------------*/
1380 /* To recap: we estimate everything based on md_estimate_size, then
1381    adjust based on rx_relax_frag.  When it all settles, we call
1382    md_convert frag to update the bytes.  The relaxation types and
1383    relocations are in fragP->tc_frag_data, which is a copy of that
1384    rx_bytes.
1385
1386    Our scheme is as follows: fr_fix has the size of the smallest
1387    opcode (like BRA.S).  We store the number of total bytes we need in
1388    fr_subtype.  When we're done relaxing, we use fr_subtype and the
1389    existing opcode bytes to figure out what actual opcode we need to
1390    put in there.  If the fixup isn't resolvable now, we use the
1391    maximal size.  */
1392
1393 #define TRACE_RELAX 0
1394 #define tprintf if (TRACE_RELAX) printf
1395
1396 typedef enum
1397 {
1398   OT_other,
1399   OT_bra,
1400   OT_beq,
1401   OT_bne,
1402   OT_bsr,
1403   OT_bcc
1404 } op_type_T;
1405
1406 /* We're looking for these types of relaxations:
1407
1408    BRA.S        00001dsp
1409    BRA.B        00101110 dspppppp
1410    BRA.W        00111000 dspppppp pppppppp
1411    BRA.A        00000100 dspppppp pppppppp pppppppp
1412
1413    BEQ.S        00010dsp
1414    BEQ.B        00100000 dspppppp
1415    BEQ.W        00111010 dspppppp pppppppp
1416
1417    BNE.S        00011dsp
1418    BNE.B        00100001 dspppppp
1419    BNE.W        00111011 dspppppp pppppppp
1420
1421    BSR.W        00111001 dspppppp pppppppp
1422    BSR.A        00000101 dspppppp pppppppp pppppppp
1423
1424    Bcc.B        0010cond dspppppp
1425
1426    Additionally, we can synthesize longer conditional branches using
1427    pairs of opcodes, one with an inverted conditional (flip LSB):
1428
1429    Bcc.W        0010ncnd 00000110 00111000 dspppppp pppppppp
1430    Bcc.A        0010ncnd 00000111 00000100 dspppppp pppppppp pppppppp
1431    BEQ.A        00011100 00000100 dspppppp pppppppp pppppppp
1432    BNE.A        00010100 00000100 dspppppp pppppppp pppppppp  */
1433
1434 /* Given the opcode bytes at OP, figure out which opcode it is and
1435    return the type of opcode.  We use this to re-encode the opcode as
1436    a different size later.  */
1437
1438 static op_type_T
1439 rx_opcode_type (char * op)
1440 {
1441   unsigned char b = (unsigned char) op[0];
1442
1443   switch (b & 0xf8)
1444     {
1445     case 0x08: return OT_bra;
1446     case 0x10: return OT_beq;
1447     case 0x18: return OT_bne;
1448     }
1449
1450   switch (b)
1451     {
1452     case 0x2e: return OT_bra;
1453     case 0x38: return OT_bra;
1454     case 0x04: return OT_bra;
1455
1456     case 0x20: return OT_beq;
1457     case 0x3a: return OT_beq;
1458
1459     case 0x21: return OT_bne;
1460     case 0x3b: return OT_bne;
1461
1462     case 0x39: return OT_bsr;
1463     case 0x05: return OT_bsr;
1464     }
1465
1466   if ((b & 0xf0) == 0x20)
1467     return OT_bcc;
1468
1469   return OT_other;
1470 }
1471
1472 /* Returns zero if *addrP has the target address.  Else returns nonzero
1473    if we cannot compute the target address yet.  */
1474
1475 static int
1476 rx_frag_fix_value (fragS *    fragP,
1477                    segT       segment,
1478                    int        which,
1479                    addressT * addrP,
1480                    int        need_diff,
1481                    addressT * sym_addr)
1482 {
1483   addressT addr = 0;
1484   rx_bytesT * b = fragP->tc_frag_data;
1485   expressionS * exp = & b->fixups[which].exp;
1486
1487   if (need_diff && exp->X_op != O_subtract)
1488     return 1;
1489
1490   if (exp->X_add_symbol)
1491     {
1492       if (S_FORCE_RELOC (exp->X_add_symbol, 1))
1493         return 1;
1494       if (S_GET_SEGMENT (exp->X_add_symbol) != segment)
1495         return 1;
1496       addr += S_GET_VALUE (exp->X_add_symbol);
1497     }
1498
1499   if (exp->X_op_symbol)
1500     {
1501       if (exp->X_op != O_subtract)
1502         return 1;
1503       if (S_FORCE_RELOC (exp->X_op_symbol, 1))
1504         return 1;
1505       if (S_GET_SEGMENT (exp->X_op_symbol) != segment)
1506         return 1;
1507       addr -= S_GET_VALUE (exp->X_op_symbol);
1508     }
1509   if (sym_addr)
1510     * sym_addr = addr;
1511   addr += exp->X_add_number;
1512   * addrP = addr;
1513   return 0;
1514 }
1515
1516 /* Estimate how big the opcode is after this relax pass.  The return
1517    value is the difference between fr_fix and the actual size.  We
1518    compute the total size in rx_relax_frag and store it in fr_subtype,
1519    so we only need to subtract fx_fix and return it.  */
1520
1521 int
1522 md_estimate_size_before_relax (fragS * fragP ATTRIBUTE_UNUSED, segT segment ATTRIBUTE_UNUSED)
1523 {
1524   int opfixsize;
1525   int delta;
1526
1527   tprintf ("\033[32m  est frag: addr %08lx fix %ld var %ld ofs %ld lit %p opc %p type %d sub %d\033[0m\n",
1528            (unsigned long) (fragP->fr_address
1529                             + (fragP->fr_opcode - fragP->fr_literal)),
1530            (long) fragP->fr_fix, (long) fragP->fr_var, (long) fragP->fr_offset,
1531            fragP->fr_literal, fragP->fr_opcode, fragP->fr_type, fragP->fr_subtype);
1532
1533   /* This is the size of the opcode that's accounted for in fr_fix.  */
1534   opfixsize = fragP->fr_fix - (fragP->fr_opcode - fragP->fr_literal);
1535   /* This is the size of the opcode that isn't.  */
1536   delta = (fragP->fr_subtype - opfixsize);
1537
1538   tprintf (" -> opfixsize %d delta %d\n", opfixsize, delta);
1539   return delta;
1540 }
1541
1542 /* Given a frag FRAGP, return the "next" frag that contains an
1543    opcode.  Assumes the next opcode is relaxable, and thus rs_machine_dependent.  */
1544
1545 static fragS *
1546 rx_next_opcode (fragS *fragP)
1547 {
1548   do {
1549     fragP = fragP->fr_next;
1550   } while (fragP && fragP->fr_type != rs_machine_dependent);
1551   return fragP;
1552 }
1553
1554 /* Given the new addresses for this relax pass, figure out how big
1555    each opcode must be.  We store the total number of bytes needed in
1556    fr_subtype.  The return value is the difference between the size
1557    after the last pass and the size after this pass, so we use the old
1558    fr_subtype to calculate the difference.  */
1559
1560 int
1561 rx_relax_frag (segT segment ATTRIBUTE_UNUSED, fragS * fragP, long stretch, unsigned long max_iterations)
1562 {
1563   addressT addr0, sym_addr;
1564   addressT mypc;
1565   int disp;
1566   int oldsize = fragP->fr_subtype;
1567   int newsize = oldsize;
1568   op_type_T optype;
1569    /* Index of relaxation we care about.  */
1570   int ri;
1571
1572   tprintf ("\033[36mrelax frag: addr %08lx fix %ld var %ld ofs %ld lit %p opc %p type %d sub %d str %ld\033[0m\n",
1573            (unsigned long) (fragP->fr_address
1574                             + (fragP->fr_opcode - fragP->fr_literal)),
1575            (long) fragP->fr_fix, (long) fragP->fr_var, (long) fragP->fr_offset,
1576            fragP->fr_literal, fragP->fr_opcode, fragP->fr_type, fragP->fr_subtype, stretch);
1577
1578   mypc = fragP->fr_address + (fragP->fr_opcode - fragP->fr_literal);
1579
1580   if (fragP->tc_frag_data->n_base == RX_NBASE_FETCHALIGN)
1581     {
1582       unsigned int next_size;
1583       if (fragP->fr_next == NULL)
1584         return 0;
1585
1586       next_size = fragP->tc_frag_data->n_ops;
1587       if (next_size == 0)
1588         {
1589           fragS *n = rx_next_opcode (fragP);
1590           next_size = n->fr_subtype;
1591         }
1592
1593       fragP->fr_subtype = (8-(mypc & 7)) & 7;
1594       tprintf("subtype %u\n", fragP->fr_subtype);
1595       if (fragP->fr_subtype >= next_size)
1596         fragP->fr_subtype = 0;
1597       tprintf ("\033[34m -> mypc %lu next_size %u new %d old %d delta %d (fetchalign)\033[0m\n",
1598                (unsigned long) (mypc & 7),
1599                next_size, fragP->fr_subtype, oldsize, fragP->fr_subtype-oldsize);
1600
1601       newsize = fragP->fr_subtype;
1602
1603       return newsize - oldsize;
1604     }
1605
1606   optype = rx_opcode_type (fragP->fr_opcode);
1607
1608   /* In the one case where we have both a disp and imm relaxation, we want
1609      the imm relaxation here.  */
1610   ri = 0;
1611   if (fragP->tc_frag_data->n_relax > 1
1612       && fragP->tc_frag_data->relax[0].type == RX_RELAX_DISP)
1613     ri = 1;
1614
1615   /* Try to get the target address.  */
1616   if (rx_frag_fix_value (fragP, segment, ri, & addr0,
1617                          fragP->tc_frag_data->relax[ri].type != RX_RELAX_BRANCH,
1618                          & sym_addr))
1619     {
1620       /* If we don't, we must use the maximum size for the linker.
1621          Note that we don't use synthetically expanded conditionals
1622          for this.  */
1623       switch (fragP->tc_frag_data->relax[ri].type)
1624         {
1625         case RX_RELAX_BRANCH:
1626           switch (optype)
1627             {
1628             case OT_bra:
1629             case OT_bsr:
1630               newsize = 4;
1631               break;
1632             case OT_beq:
1633             case OT_bne:
1634               newsize = 3;
1635               break;
1636             case OT_bcc:
1637               newsize = 2;
1638               break;
1639             case OT_other:
1640               newsize = oldsize;
1641               break;
1642             }
1643           break;
1644
1645         case RX_RELAX_IMM:
1646           newsize = fragP->tc_frag_data->relax[ri].val_ofs + 4;
1647           break;
1648         }
1649       fragP->fr_subtype = newsize;
1650       tprintf (" -> new %d old %d delta %d (external)\n", newsize, oldsize, newsize-oldsize);
1651       return newsize - oldsize;
1652     }
1653
1654   if (sym_addr > mypc)
1655     addr0 += stretch;
1656
1657   switch (fragP->tc_frag_data->relax[ri].type)
1658     {
1659     case  RX_RELAX_BRANCH:
1660       tprintf ("branch, addr %08lx pc %08lx disp %ld\n",
1661                (unsigned long) addr0, (unsigned long) mypc,
1662                (long) (addr0 - mypc));
1663       disp = (int) addr0 - (int) mypc;
1664
1665       switch (optype)
1666         {
1667         case OT_bcc:
1668           if (disp >= -128 && (disp - (oldsize-2)) <= 127)
1669             /* bcc.b */
1670             newsize = 2;
1671           else if (disp >= -32768 && (disp - (oldsize-5)) <= 32767)
1672             /* bncc.b/bra.w */
1673             newsize = 5;
1674           else
1675             /* bncc.b/bra.a */
1676             newsize = 6;
1677           break;
1678
1679         case OT_beq:
1680         case OT_bne:
1681           if ((disp - (oldsize-1)) >= 3 && (disp - (oldsize-1)) <= 10 && !linkrelax)
1682             /* beq.s */
1683             newsize = 1;
1684           else if (disp >= -128 && (disp - (oldsize-2)) <= 127)
1685             /* beq.b */
1686             newsize = 2;
1687           else if (disp >= -32768 && (disp - (oldsize-3)) <= 32767)
1688             /* beq.w */
1689             newsize = 3;
1690           else
1691             /* bne.s/bra.a */
1692             newsize = 5;
1693           break;
1694
1695         case OT_bra:
1696         case OT_bsr:
1697           if ((disp - (oldsize-1)) >= 3 && (disp - (oldsize-1)) <= 10 && !linkrelax)
1698             /* bra.s */
1699             newsize = 1;
1700           else if (disp >= -128 && (disp - (oldsize-2)) <= 127)
1701             /* bra.b */
1702             newsize = 2;
1703           else if (disp >= -32768 && (disp - (oldsize-3)) <= 32767)
1704             /* bra.w */
1705             newsize = 3;
1706           else
1707             /* bra.a */
1708             newsize = 4;
1709           break;
1710
1711         case OT_other:
1712           break;
1713         }
1714       tprintf (" - newsize %d\n", newsize);
1715       break;
1716
1717     case RX_RELAX_IMM:
1718       tprintf ("other, addr %08lx pc %08lx LI %d OF %d\n",
1719                (unsigned long) addr0, (unsigned long) mypc,
1720                fragP->tc_frag_data->relax[ri].field_pos,
1721                fragP->tc_frag_data->relax[ri].val_ofs);
1722
1723       newsize = fragP->tc_frag_data->relax[ri].val_ofs;
1724
1725       if ((long) addr0 >= -128 && (long) addr0 <= 127)
1726         newsize += 1;
1727       else if ((long) addr0 >= -32768 && (long) addr0 <= 32767)
1728         newsize += 2;
1729       else if ((long) addr0 >= -8388608 && (long) addr0 <= 8388607)
1730         newsize += 3;
1731       else
1732         newsize += 4;
1733       break;
1734
1735     default:
1736       break;
1737     }
1738
1739   if (fragP->tc_frag_data->relax[ri].type == RX_RELAX_BRANCH)
1740     switch (optype)
1741       {
1742       case OT_bra:
1743       case OT_bcc:
1744       case OT_beq:
1745       case OT_bne:
1746         break;
1747       case OT_bsr:
1748         if (newsize < 3)
1749           newsize = 3;
1750         break;
1751       case OT_other:
1752         break;
1753       }
1754
1755   /* This prevents infinite loops in align-heavy sources.  */
1756   if (newsize < oldsize)
1757     {
1758       /* Make sure that our iteration limit is no bigger than the one being
1759          used inside write.c:relax_segment().  Otherwise we can end up
1760          iterating for too long, and triggering a fatal error there.  See
1761          PR 24464 for more details.  */
1762       unsigned long limit = max_iterations > 10 ? 10 : max_iterations;
1763
1764       if (fragP->tc_frag_data->times_shrank > limit
1765           && fragP->tc_frag_data->times_grown > limit)
1766         newsize = oldsize;
1767
1768       if (fragP->tc_frag_data->times_shrank < 20)
1769        fragP->tc_frag_data->times_shrank ++;
1770     }
1771   else if (newsize > oldsize)
1772     {
1773       if (fragP->tc_frag_data->times_grown < 20)
1774        fragP->tc_frag_data->times_grown ++;
1775     }
1776
1777   fragP->fr_subtype = newsize;
1778   tprintf (" -> new %d old %d delta %d\n", newsize, oldsize, newsize-oldsize);
1779   return newsize - oldsize;
1780 }
1781
1782 /* This lets us test for the opcode type and the desired size in a
1783    switch statement.  */
1784 #define OPCODE(type,size) ((type) * 16 + (size))
1785
1786 /* Given the opcode stored in fr_opcode and the number of bytes we
1787    think we need, encode a new opcode.  We stored a pointer to the
1788    fixup for this opcode in the tc_frag_data structure.  If we can do
1789    the fixup here, we change the relocation type to "none" (we test
1790    for that in tc_gen_reloc) else we change it to the right type for
1791    the new (biggest) opcode.  */
1792
1793 void
1794 md_convert_frag (bfd *   abfd ATTRIBUTE_UNUSED,
1795                  segT    segment ATTRIBUTE_UNUSED,
1796                  fragS * fragP ATTRIBUTE_UNUSED)
1797 {
1798   rx_bytesT * rxb = fragP->tc_frag_data;
1799   addressT addr0, mypc;
1800   int disp;
1801   int reloc_adjust;
1802   bfd_reloc_code_real_type reloc_type;
1803   char * op = fragP->fr_opcode;
1804   int keep_reloc = 0;
1805   int ri;
1806   int fi = (rxb->n_fixups > 1) ? 1 : 0;
1807   fixS * fix = rxb->fixups[fi].fixP;
1808
1809   tprintf ("\033[31mconvrt frag: addr %08lx fix %ld var %ld ofs %ld lit %p opc %p type %d sub %d\033[0m\n",
1810            (unsigned long) (fragP->fr_address
1811                             + (fragP->fr_opcode - fragP->fr_literal)),
1812            (long) fragP->fr_fix, (long) fragP->fr_var, (long) fragP->fr_offset,
1813            fragP->fr_literal, fragP->fr_opcode, fragP->fr_type,
1814            fragP->fr_subtype);
1815
1816 #if TRACE_RELAX
1817   {
1818     int i;
1819
1820     printf ("lit 0x%p opc 0x%p", fragP->fr_literal, fragP->fr_opcode);
1821     for (i = 0; i < 10; i++)
1822       printf (" %02x", (unsigned char) (fragP->fr_opcode[i]));
1823     printf ("\n");
1824   }
1825 #endif
1826
1827   if (fragP->tc_frag_data->n_base == RX_NBASE_FETCHALIGN)
1828     {
1829       int count = fragP->fr_subtype;
1830       if (count == 0)
1831         ;
1832       else if (count > BIGGEST_NOP)
1833         {
1834           op[0] = 0x2e;
1835           op[1] = count;
1836         }
1837       else if (count > 0)
1838         {
1839           memcpy (op, nops[count], count);
1840         }
1841     }
1842
1843   /* In the one case where we have both a disp and imm relaxation, we want
1844      the imm relaxation here.  */
1845   ri = 0;
1846   if (fragP->tc_frag_data->n_relax > 1
1847       && fragP->tc_frag_data->relax[0].type == RX_RELAX_DISP)
1848     ri = 1;
1849
1850   /* We used a new frag for this opcode, so the opcode address should
1851      be the frag address.  */
1852   mypc = fragP->fr_address + (fragP->fr_opcode - fragP->fr_literal);
1853
1854   /* Try to get the target address.  If we fail here, we just use the
1855      largest format.  */
1856   if (rx_frag_fix_value (fragP, segment, 0, & addr0,
1857                          fragP->tc_frag_data->relax[ri].type != RX_RELAX_BRANCH, 0))
1858     {
1859       /* We don't know the target address.  */
1860       keep_reloc = 1;
1861       addr0 = 0;
1862       disp = 0;
1863     }
1864   else
1865     {
1866       /* We know the target address, and it's in addr0.  */
1867       disp = (int) addr0 - (int) mypc;
1868     }
1869
1870   if (linkrelax)
1871     keep_reloc = 1;
1872
1873   reloc_type = BFD_RELOC_NONE;
1874   reloc_adjust = 0;
1875
1876   tprintf ("convert, op is %d, disp %d (%lx-%lx)\n",
1877            rx_opcode_type (fragP->fr_opcode), disp,
1878            (unsigned long) addr0, (unsigned long) mypc);
1879   switch (fragP->tc_frag_data->relax[ri].type)
1880     {
1881     case RX_RELAX_BRANCH:
1882       switch (OPCODE (rx_opcode_type (fragP->fr_opcode), fragP->fr_subtype))
1883         {
1884         case OPCODE (OT_bra, 1): /* BRA.S - no change.  */
1885           op[0] = 0x08 + (disp & 7);
1886           break;
1887         case OPCODE (OT_bra, 2): /* BRA.B - 8 bit.  */
1888           op[0] = 0x2e;
1889           op[1] = disp;
1890           reloc_type = keep_reloc ? BFD_RELOC_8_PCREL : BFD_RELOC_NONE;
1891           reloc_adjust = 1;
1892           break;
1893         case OPCODE (OT_bra, 3): /* BRA.W - 16 bit.  */
1894           op[0] = 0x38;
1895 #if RX_OPCODE_BIG_ENDIAN
1896           op[1] = (disp >> 8) & 0xff;
1897           op[2] = disp;
1898 #else
1899           op[2] = (disp >> 8) & 0xff;
1900           op[1] = disp;
1901 #endif
1902           reloc_adjust = 1;
1903           reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE;
1904           break;
1905         case OPCODE (OT_bra, 4): /* BRA.A - 24 bit.  */
1906           op[0] = 0x04;
1907 #if RX_OPCODE_BIG_ENDIAN
1908           op[1] = (disp >> 16) & 0xff;
1909           op[2] = (disp >> 8) & 0xff;
1910           op[3] = disp;
1911 #else
1912           op[3] = (disp >> 16) & 0xff;
1913           op[2] = (disp >> 8) & 0xff;
1914           op[1] = disp;
1915 #endif
1916           reloc_type = keep_reloc ? BFD_RELOC_24_PCREL : BFD_RELOC_NONE;
1917           reloc_adjust = 1;
1918           break;
1919
1920         case OPCODE (OT_beq, 1): /* BEQ.S - no change.  */
1921           op[0] = 0x10 + (disp & 7);
1922           break;
1923         case OPCODE (OT_beq, 2): /* BEQ.B - 8 bit.  */
1924           op[0] = 0x20;
1925           op[1] = disp;
1926           reloc_adjust = 1;
1927           reloc_type = keep_reloc ? BFD_RELOC_8_PCREL : BFD_RELOC_NONE;
1928           break;
1929         case OPCODE (OT_beq, 3): /* BEQ.W - 16 bit.  */
1930           op[0] = 0x3a;
1931 #if RX_OPCODE_BIG_ENDIAN
1932           op[1] = (disp >> 8) & 0xff;
1933           op[2] = disp;
1934 #else
1935           op[2] = (disp >> 8) & 0xff;
1936           op[1] = disp;
1937 #endif
1938           reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE;
1939           reloc_adjust = 1;
1940           break;
1941         case OPCODE (OT_beq, 5): /* BEQ.A - synthetic.  */
1942           op[0] = 0x1d; /* bne.s .+5.  */
1943           op[1] = 0x04; /* bra.a dsp:24.  */
1944           disp -= 1;
1945 #if RX_OPCODE_BIG_ENDIAN
1946           op[2] = (disp >> 16) & 0xff;
1947           op[3] = (disp >> 8) & 0xff;
1948           op[4] = disp;
1949 #else
1950           op[4] = (disp >> 16) & 0xff;
1951           op[3] = (disp >> 8) & 0xff;
1952           op[2] = disp;
1953 #endif
1954           reloc_type = keep_reloc ? BFD_RELOC_24_PCREL : BFD_RELOC_NONE;
1955           reloc_adjust = 2;
1956           break;
1957
1958         case OPCODE (OT_bne, 1): /* BNE.S - no change.  */
1959           op[0] = 0x18 + (disp & 7);
1960           break;
1961         case OPCODE (OT_bne, 2): /* BNE.B - 8 bit.  */
1962           op[0] = 0x21;
1963           op[1] = disp;
1964           reloc_adjust = 1;
1965           reloc_type = keep_reloc ? BFD_RELOC_8_PCREL : BFD_RELOC_NONE;
1966           break;
1967         case OPCODE (OT_bne, 3): /* BNE.W - 16 bit.  */
1968           op[0] = 0x3b;
1969 #if RX_OPCODE_BIG_ENDIAN
1970           op[1] = (disp >> 8) & 0xff;
1971           op[2] = disp;
1972 #else
1973           op[2] = (disp >> 8) & 0xff;
1974           op[1] = disp;
1975 #endif
1976           reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE;
1977           reloc_adjust = 1;
1978           break;
1979         case OPCODE (OT_bne, 5): /* BNE.A - synthetic.  */
1980           op[0] = 0x15; /* beq.s .+5.  */
1981           op[1] = 0x04; /* bra.a dsp:24.  */
1982           disp -= 1;
1983 #if RX_OPCODE_BIG_ENDIAN
1984           op[2] = (disp >> 16) & 0xff;
1985           op[3] = (disp >> 8) & 0xff;
1986           op[4] = disp;
1987 #else
1988           op[4] = (disp >> 16) & 0xff;
1989           op[3] = (disp >> 8) & 0xff;
1990           op[2] = disp;
1991 #endif
1992           reloc_type = keep_reloc ? BFD_RELOC_24_PCREL : BFD_RELOC_NONE;
1993           reloc_adjust = 2;
1994           break;
1995
1996         case OPCODE (OT_bsr, 3): /* BSR.W - 16 bit.  */
1997           op[0] = 0x39;
1998 #if RX_OPCODE_BIG_ENDIAN
1999           op[1] = (disp >> 8) & 0xff;
2000           op[2] = disp;
2001 #else
2002           op[2] = (disp >> 8) & 0xff;
2003           op[1] = disp;
2004 #endif
2005           reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE;
2006           reloc_adjust = 0;
2007           break;
2008         case OPCODE (OT_bsr, 4): /* BSR.A - 24 bit.  */
2009           op[0] = 0x05;
2010 #if RX_OPCODE_BIG_ENDIAN
2011           op[1] = (disp >> 16) & 0xff;
2012           op[2] = (disp >> 8) & 0xff;
2013           op[3] = disp;
2014 #else
2015           op[3] = (disp >> 16) & 0xff;
2016           op[2] = (disp >> 8) & 0xff;
2017           op[1] = disp;
2018 #endif
2019           reloc_type = keep_reloc ? BFD_RELOC_24_PCREL : BFD_RELOC_NONE;
2020           reloc_adjust = 0;
2021           break;
2022
2023         case OPCODE (OT_bcc, 2): /* Bcond.B - 8 bit.  */
2024           op[1] = disp;
2025           reloc_type = keep_reloc ? BFD_RELOC_8_PCREL : BFD_RELOC_NONE;
2026           break;
2027         case OPCODE (OT_bcc, 5): /* Bcond.W - synthetic.  */
2028           op[0] ^= 1; /* Invert condition.  */
2029           op[1] = 5;  /* Displacement.  */
2030           op[2] = 0x38;
2031           disp -= 2;
2032 #if RX_OPCODE_BIG_ENDIAN
2033           op[3] = (disp >> 8) & 0xff;
2034           op[4] = disp;
2035 #else
2036           op[4] = (disp >> 8) & 0xff;
2037           op[3] = disp;
2038 #endif
2039           reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE;
2040           reloc_adjust = 2;
2041           break;
2042         case OPCODE (OT_bcc, 6): /* Bcond.S - synthetic.  */
2043           op[0] ^= 1; /* Invert condition.  */
2044           op[1] = 6;  /* Displacement.  */
2045           op[2] = 0x04;
2046           disp -= 2;
2047 #if RX_OPCODE_BIG_ENDIAN
2048           op[3] = (disp >> 16) & 0xff;
2049           op[4] = (disp >> 8) & 0xff;
2050           op[5] = disp;
2051 #else
2052           op[5] = (disp >> 16) & 0xff;
2053           op[4] = (disp >> 8) & 0xff;
2054           op[3] = disp;
2055 #endif
2056           reloc_type = keep_reloc ? BFD_RELOC_24_PCREL : BFD_RELOC_NONE;
2057           reloc_adjust = 2;
2058           break;
2059
2060         default:
2061           /* These are opcodes we'll relax in th linker, later.  */
2062           if (rxb->n_fixups)
2063             reloc_type = rxb->fixups[ri].fixP->fx_r_type;
2064           break;
2065         }
2066       break;
2067
2068     case RX_RELAX_IMM:
2069       {
2070         int nbytes = fragP->fr_subtype - fragP->tc_frag_data->relax[ri].val_ofs;
2071         int li;
2072         char * imm = op + fragP->tc_frag_data->relax[ri].val_ofs;
2073
2074         switch (nbytes)
2075           {
2076           case 1:
2077             li = 1;
2078             imm[0] = addr0;
2079             reloc_type = BFD_RELOC_8;
2080             break;
2081           case 2:
2082             li = 2;
2083 #if RX_OPCODE_BIG_ENDIAN
2084             imm[1] = addr0;
2085             imm[0] = addr0 >> 8;
2086 #else
2087             imm[0] = addr0;
2088             imm[1] = addr0 >> 8;
2089 #endif
2090             reloc_type = BFD_RELOC_RX_16_OP;
2091             break;
2092           case 3:
2093             li = 3;
2094 #if RX_OPCODE_BIG_ENDIAN
2095             imm[2] = addr0;
2096             imm[1] = addr0 >> 8;
2097             imm[0] = addr0 >> 16;
2098 #else
2099             imm[0] = addr0;
2100             imm[1] = addr0 >> 8;
2101             imm[2] = addr0 >> 16;
2102 #endif
2103             reloc_type = BFD_RELOC_RX_24_OP;
2104             break;
2105           case 4:
2106             li = 0;
2107 #if RX_OPCODE_BIG_ENDIAN
2108             imm[3] = addr0;
2109             imm[2] = addr0 >> 8;
2110             imm[1] = addr0 >> 16;
2111             imm[0] = addr0 >> 24;
2112 #else
2113             imm[0] = addr0;
2114             imm[1] = addr0 >> 8;
2115             imm[2] = addr0 >> 16;
2116             imm[3] = addr0 >> 24;
2117 #endif
2118             reloc_type = BFD_RELOC_RX_32_OP;
2119             break;
2120           default:
2121             as_bad (_("invalid immediate size"));
2122             li = -1;
2123           }
2124
2125         switch (fragP->tc_frag_data->relax[ri].field_pos)
2126           {
2127           case 6:
2128             op[0] &= 0xfc;
2129             op[0] |= li;
2130             break;
2131           case 12:
2132             op[1] &= 0xf3;
2133             op[1] |= li << 2;
2134             break;
2135           case 20:
2136             op[2] &= 0xf3;
2137             op[2] |= li << 2;
2138             break;
2139           default:
2140             as_bad (_("invalid immediate field position"));
2141           }
2142       }
2143       break;
2144
2145     default:
2146       if (rxb->n_fixups)
2147         {
2148           reloc_type = fix->fx_r_type;
2149           reloc_adjust = 0;
2150         }
2151       break;
2152     }
2153
2154   if (rxb->n_fixups)
2155     {
2156
2157       fix->fx_r_type = reloc_type;
2158       fix->fx_where += reloc_adjust;
2159       switch (reloc_type)
2160         {
2161         case BFD_RELOC_NONE:
2162           fix->fx_size = 0;
2163           break;
2164         case BFD_RELOC_8:
2165           fix->fx_size = 1;
2166           break;
2167         case BFD_RELOC_16_PCREL:
2168         case BFD_RELOC_RX_16_OP:
2169           fix->fx_size = 2;
2170           break;
2171         case BFD_RELOC_24_PCREL:
2172         case BFD_RELOC_RX_24_OP:
2173           fix->fx_size = 3;
2174           break;
2175         case BFD_RELOC_RX_32_OP:
2176           fix->fx_size = 4;
2177           break;
2178         default:
2179           break;
2180         }
2181     }
2182
2183   fragP->fr_fix = fragP->fr_subtype + (fragP->fr_opcode - fragP->fr_literal);
2184   tprintf ("fragP->fr_fix now %ld (%d + (%p - %p)\n", (long) fragP->fr_fix,
2185           fragP->fr_subtype, fragP->fr_opcode, fragP->fr_literal);
2186   fragP->fr_var = 0;
2187
2188   if (fragP->fr_next != NULL
2189       && fragP->fr_next->fr_address - fragP->fr_address != fragP->fr_fix)
2190     as_bad (_("bad frag at %p : fix %ld addr %ld %ld \n"), fragP,
2191             (long) fragP->fr_fix,
2192             (long) fragP->fr_address, (long) fragP->fr_next->fr_address);
2193 }
2194
2195 #undef OPCODE
2196 \f
2197 int
2198 rx_validate_fix_sub (struct fix * f)
2199 {
2200   /* We permit the subtraction of two symbols in a few cases.  */
2201   /* mov #sym1-sym2, R3 */
2202   if (f->fx_r_type == BFD_RELOC_RX_32_OP)
2203     return 1;
2204   /* .long sym1-sym2 */
2205   if (f->fx_r_type == BFD_RELOC_RX_DIFF
2206       && ! f->fx_pcrel
2207       && (f->fx_size == 4 || f->fx_size == 2 || f->fx_size == 1))
2208     return 1;
2209   return 0;
2210 }
2211
2212 long
2213 md_pcrel_from_section (fixS * fixP, segT sec)
2214 {
2215   long rv;
2216
2217   if (fixP->fx_addsy != NULL
2218       && (! S_IS_DEFINED (fixP->fx_addsy)
2219           || S_GET_SEGMENT (fixP->fx_addsy) != sec))
2220     /* The symbol is undefined (or is defined but not in this section).
2221        Let the linker figure it out.  */
2222     return 0;
2223
2224   rv = fixP->fx_frag->fr_address + fixP->fx_where;
2225   switch (fixP->fx_r_type)
2226     {
2227     case BFD_RELOC_RX_DIR3U_PCREL:
2228       return rv;
2229     default:
2230       return rv - 1;
2231     }
2232 }
2233
2234 void
2235 rx_cons_fix_new (fragS *        frag,
2236                  int            where,
2237                  int            size,
2238                  expressionS *  exp,
2239                  bfd_reloc_code_real_type type)
2240 {
2241   switch (size)
2242     {
2243     case 1:
2244       type = BFD_RELOC_8;
2245       break;
2246     case 2:
2247       type = BFD_RELOC_16;
2248       break;
2249     case 3:
2250       type = BFD_RELOC_24;
2251       break;
2252     case 4:
2253       type = BFD_RELOC_32;
2254       break;
2255     default:
2256       as_bad (_("unsupported constant size %d\n"), size);
2257       return;
2258     }
2259
2260   if (exp->X_op == O_subtract && exp->X_op_symbol)
2261     {
2262       if (size != 4 && size != 2 && size != 1)
2263         as_bad (_("difference of two symbols only supported with .long, .short, or .byte"));
2264       else
2265         type = BFD_RELOC_RX_DIFF;
2266     }
2267
2268   fix_new_exp (frag, where, (int) size, exp, 0, type);
2269 }
2270
2271 void
2272 md_apply_fix (struct fix * f ATTRIBUTE_UNUSED,
2273               valueT *     t ATTRIBUTE_UNUSED,
2274               segT         s ATTRIBUTE_UNUSED)
2275 {
2276   /* Instruction bytes are always little endian.  */
2277   char * op;
2278   unsigned long val;
2279
2280   if (f->fx_addsy && S_FORCE_RELOC (f->fx_addsy, 1))
2281     return;
2282   if (f->fx_subsy && S_FORCE_RELOC (f->fx_subsy, 1))
2283     return;
2284
2285 #define OP2(x) op[target_big_endian ? 1-x : x]
2286 #define OP3(x) op[target_big_endian ? 2-x : x]
2287 #define OP4(x) op[target_big_endian ? 3-x : x]
2288
2289   op = f->fx_frag->fr_literal + f->fx_where;
2290   val = (unsigned long) * t;
2291
2292   /* Opcode words are always the same endian.  Data words are either
2293      big or little endian.  */
2294
2295   switch (f->fx_r_type)
2296     {
2297     case BFD_RELOC_NONE:
2298       break;
2299
2300     case BFD_RELOC_RX_RELAX:
2301       f->fx_done = 1;
2302       break;
2303
2304     case BFD_RELOC_RX_DIR3U_PCREL:
2305       if (val < 3 || val > 10)
2306         as_bad_where (f->fx_file, f->fx_line,
2307                       _("jump not 3..10 bytes away (is %d)"), (int) val);
2308       op[0] &= 0xf8;
2309       op[0] |= val & 0x07;
2310       break;
2311
2312     case BFD_RELOC_8:
2313     case BFD_RELOC_8_PCREL:
2314     case BFD_RELOC_RX_8U:
2315       op[0] = val;
2316       break;
2317
2318     case BFD_RELOC_16:
2319       OP2(1) = val & 0xff;
2320       OP2(0) = (val >> 8) & 0xff;
2321       break;
2322
2323     case BFD_RELOC_16_PCREL:
2324     case BFD_RELOC_RX_16_OP:
2325     case BFD_RELOC_RX_16U:
2326 #if RX_OPCODE_BIG_ENDIAN
2327       op[1] = val & 0xff;
2328       op[0] = (val >> 8) & 0xff;
2329 #else
2330       op[0] = val & 0xff;
2331       op[1] = (val >> 8) & 0xff;
2332 #endif
2333       break;
2334
2335     case BFD_RELOC_24:
2336       OP3(0) = val & 0xff;
2337       OP3(1) = (val >> 8) & 0xff;
2338       OP3(2) = (val >> 16) & 0xff;
2339       break;
2340
2341     case BFD_RELOC_24_PCREL:
2342     case BFD_RELOC_RX_24_OP:
2343     case BFD_RELOC_RX_24U:
2344 #if RX_OPCODE_BIG_ENDIAN
2345       op[2] = val & 0xff;
2346       op[1] = (val >> 8) & 0xff;
2347       op[0] = (val >> 16) & 0xff;
2348 #else
2349       op[0] = val & 0xff;
2350       op[1] = (val >> 8) & 0xff;
2351       op[2] = (val >> 16) & 0xff;
2352 #endif
2353       break;
2354
2355     case BFD_RELOC_RX_DIFF:
2356       switch (f->fx_size)
2357         {
2358         case 1:
2359           op[0] = val & 0xff;
2360           break;
2361         case 2:
2362           OP2(0) = val & 0xff;
2363           OP2(1) = (val >> 8) & 0xff;
2364           break;
2365         case 4:
2366           OP4(0) = val & 0xff;
2367           OP4(1) = (val >> 8) & 0xff;
2368           OP4(2) = (val >> 16) & 0xff;
2369           OP4(3) = (val >> 24) & 0xff;
2370           break;
2371         }
2372       break;
2373
2374     case BFD_RELOC_32:
2375       OP4(0) = val & 0xff;
2376       OP4(1) = (val >> 8) & 0xff;
2377       OP4(2) = (val >> 16) & 0xff;
2378       OP4(3) = (val >> 24) & 0xff;
2379       break;
2380
2381     case BFD_RELOC_RX_32_OP:
2382 #if RX_OPCODE_BIG_ENDIAN
2383       op[3] = val & 0xff;
2384       op[2] = (val >> 8) & 0xff;
2385       op[1] = (val >> 16) & 0xff;
2386       op[0] = (val >> 24) & 0xff;
2387 #else
2388       op[0] = val & 0xff;
2389       op[1] = (val >> 8) & 0xff;
2390       op[2] = (val >> 16) & 0xff;
2391       op[3] = (val >> 24) & 0xff;
2392 #endif
2393       break;
2394
2395     case BFD_RELOC_RX_NEG8:
2396       op[0] = - val;
2397       break;
2398
2399     case BFD_RELOC_RX_NEG16:
2400       val = -val;
2401 #if RX_OPCODE_BIG_ENDIAN
2402       op[1] = val & 0xff;
2403       op[0] = (val >> 8) & 0xff;
2404 #else
2405       op[0] = val & 0xff;
2406       op[1] = (val >> 8) & 0xff;
2407 #endif
2408       break;
2409
2410     case BFD_RELOC_RX_NEG24:
2411       val = -val;
2412 #if RX_OPCODE_BIG_ENDIAN
2413       op[2] = val & 0xff;
2414       op[1] = (val >> 8) & 0xff;
2415       op[0] = (val >> 16) & 0xff;
2416 #else
2417       op[0] = val & 0xff;
2418       op[1] = (val >> 8) & 0xff;
2419       op[2] = (val >> 16) & 0xff;
2420 #endif
2421       break;
2422
2423     case BFD_RELOC_RX_NEG32:
2424       val = -val;
2425 #if RX_OPCODE_BIG_ENDIAN
2426       op[3] = val & 0xff;
2427       op[2] = (val >> 8) & 0xff;
2428       op[1] = (val >> 16) & 0xff;
2429       op[0] = (val >> 24) & 0xff;
2430 #else
2431       op[0] = val & 0xff;
2432       op[1] = (val >> 8) & 0xff;
2433       op[2] = (val >> 16) & 0xff;
2434       op[3] = (val >> 24) & 0xff;
2435 #endif
2436       break;
2437
2438     case BFD_RELOC_RX_GPRELL:
2439       val >>= 1;
2440       /* Fall through.  */
2441     case BFD_RELOC_RX_GPRELW:
2442       val >>= 1;
2443       /* Fall through.  */
2444     case BFD_RELOC_RX_GPRELB:
2445 #if RX_OPCODE_BIG_ENDIAN
2446       op[1] = val & 0xff;
2447       op[0] = (val >> 8) & 0xff;
2448 #else
2449       op[0] = val & 0xff;
2450       op[1] = (val >> 8) & 0xff;
2451 #endif
2452       break;
2453
2454     default:
2455       as_bad (_("Unknown reloc in md_apply_fix: %s"),
2456               bfd_get_reloc_code_name (f->fx_r_type));
2457       break;
2458     }
2459
2460   if (f->fx_addsy == NULL)
2461     f->fx_done = 1;
2462 }
2463
2464 arelent **
2465 tc_gen_reloc (asection * sec ATTRIBUTE_UNUSED, fixS * fixp)
2466 {
2467   static arelent * reloc[5];
2468   bfd_boolean is_opcode = FALSE;
2469
2470   if (fixp->fx_r_type == BFD_RELOC_NONE)
2471     {
2472       reloc[0] = NULL;
2473       return reloc;
2474     }
2475
2476   if (fixp->fx_subsy
2477       && S_GET_SEGMENT (fixp->fx_subsy) == absolute_section)
2478     {
2479       fixp->fx_offset -= S_GET_VALUE (fixp->fx_subsy);
2480       fixp->fx_subsy = NULL;
2481     }
2482
2483   reloc[0]                = XNEW (arelent);
2484   reloc[0]->sym_ptr_ptr   = XNEW (asymbol *);
2485   * reloc[0]->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
2486   reloc[0]->address       = fixp->fx_frag->fr_address + fixp->fx_where;
2487   reloc[0]->addend        = fixp->fx_offset;
2488
2489   if (fixp->fx_r_type == BFD_RELOC_RX_32_OP
2490       && fixp->fx_subsy)
2491     {
2492       fixp->fx_r_type = BFD_RELOC_RX_DIFF;
2493       is_opcode = TRUE;
2494     }
2495   else if (sec)
2496     is_opcode = sec->flags & SEC_CODE;
2497
2498   /* Certain BFD relocations cannot be translated directly into
2499      a single (non-Red Hat) RX relocation, but instead need
2500      multiple RX relocations - handle them here.  */
2501   switch (fixp->fx_r_type)
2502     {
2503     case BFD_RELOC_RX_DIFF:
2504       reloc[0]->howto         = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_SYM);
2505
2506       reloc[1]                = XNEW (arelent);
2507       reloc[1]->sym_ptr_ptr   = XNEW (asymbol *);
2508       * reloc[1]->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_subsy);
2509       reloc[1]->address       = fixp->fx_frag->fr_address + fixp->fx_where;
2510       reloc[1]->addend        = 0;
2511       reloc[1]->howto         = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_SYM);
2512
2513       reloc[2]                = XNEW (arelent);
2514       reloc[2]->howto         = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_OP_SUBTRACT);
2515       reloc[2]->addend        = 0;
2516       reloc[2]->sym_ptr_ptr   = reloc[1]->sym_ptr_ptr;
2517       reloc[2]->address       = fixp->fx_frag->fr_address + fixp->fx_where;
2518
2519       reloc[3]                = XNEW (arelent);
2520       switch (fixp->fx_size)
2521         {
2522         case 1:
2523           reloc[3]->howto   = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_ABS8);
2524           break;
2525         case 2:
2526           if (!is_opcode && target_big_endian)
2527             reloc[3]->howto   = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_ABS16_REV);
2528           else if (is_opcode)
2529             reloc[3]->howto   = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_ABS16UL);
2530           else
2531             reloc[3]->howto   = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_ABS16);
2532           break;
2533         case 4:
2534           if (!is_opcode && target_big_endian)
2535             reloc[3]->howto   = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_ABS32_REV);
2536           else
2537             reloc[3]->howto   = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_ABS32);
2538           break;
2539         }
2540       reloc[3]->addend      = 0;
2541       reloc[3]->sym_ptr_ptr = reloc[1]->sym_ptr_ptr;
2542       reloc[3]->address     = fixp->fx_frag->fr_address + fixp->fx_where;
2543
2544       reloc[4] = NULL;
2545       break;
2546
2547     case BFD_RELOC_RX_GPRELL:
2548       reloc[0]->howto         = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_SYM);
2549
2550       reloc[1]                = XNEW (arelent);
2551       reloc[1]->sym_ptr_ptr   = XNEW (asymbol *);
2552       if (gp_symbol == NULL)
2553         {
2554           if (symbol_table_frozen)
2555             {
2556               symbolS * gp;
2557
2558               gp = symbol_find ("__gp");
2559               if (gp == NULL)
2560                 as_bad (("unable to create __gp symbol: please re-assemble with the -msmall-data-limit option specified"));
2561               else
2562                 gp_symbol = symbol_get_bfdsym (gp);
2563             }
2564           else
2565             gp_symbol = symbol_get_bfdsym (symbol_find_or_make ("__gp"));
2566         }
2567       * reloc[1]->sym_ptr_ptr = gp_symbol;
2568       reloc[1]->address       = fixp->fx_frag->fr_address + fixp->fx_where;
2569       reloc[1]->addend        = 0;
2570       reloc[1]->howto         = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_SYM);
2571
2572       reloc[2]              = XNEW (arelent);
2573       reloc[2]->howto       = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_OP_SUBTRACT);
2574       reloc[2]->addend      = 0;
2575       reloc[2]->sym_ptr_ptr = reloc[1]->sym_ptr_ptr;
2576       reloc[2]->address     = fixp->fx_frag->fr_address + fixp->fx_where;
2577
2578       reloc[3]              = XNEW (arelent);
2579       reloc[3]->howto       = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_ABS16UL);
2580       reloc[3]->addend      = 0;
2581       reloc[3]->sym_ptr_ptr = reloc[1]->sym_ptr_ptr;
2582       reloc[3]->address     = fixp->fx_frag->fr_address + fixp->fx_where;
2583
2584       reloc[4] = NULL;
2585       break;
2586
2587     case BFD_RELOC_RX_GPRELW:
2588       reloc[0]->howto         = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_SYM);
2589
2590       reloc[1]                = XNEW (arelent);
2591       reloc[1]->sym_ptr_ptr   = XNEW (asymbol *);
2592       if (gp_symbol == NULL)
2593         {
2594           if (symbol_table_frozen)
2595             {
2596               symbolS * gp;
2597
2598               gp = symbol_find ("__gp");
2599               if (gp == NULL)
2600                 as_bad (("unable to create __gp symbol: please re-assemble with the -msmall-data-limit option specified"));
2601               else
2602                 gp_symbol = symbol_get_bfdsym (gp);
2603             }
2604           else
2605             gp_symbol = symbol_get_bfdsym (symbol_find_or_make ("__gp"));
2606         }
2607       * reloc[1]->sym_ptr_ptr = gp_symbol;
2608       reloc[1]->address       = fixp->fx_frag->fr_address + fixp->fx_where;
2609       reloc[1]->addend        = 0;
2610       reloc[1]->howto         = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_SYM);
2611
2612       reloc[2]              = XNEW (arelent);
2613       reloc[2]->howto       = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_OP_SUBTRACT);
2614       reloc[2]->addend      = 0;
2615       reloc[2]->sym_ptr_ptr = reloc[1]->sym_ptr_ptr;
2616       reloc[2]->address     = fixp->fx_frag->fr_address + fixp->fx_where;
2617
2618       reloc[3]              = XNEW (arelent);
2619       reloc[3]->howto       = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_ABS16UW);
2620       reloc[3]->addend      = 0;
2621       reloc[3]->sym_ptr_ptr = reloc[1]->sym_ptr_ptr;
2622       reloc[3]->address     = fixp->fx_frag->fr_address + fixp->fx_where;
2623
2624       reloc[4] = NULL;
2625       break;
2626
2627     case BFD_RELOC_RX_GPRELB:
2628       reloc[0]->howto         = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_SYM);
2629
2630       reloc[1]                = XNEW (arelent);
2631       reloc[1]->sym_ptr_ptr   = XNEW (asymbol *);
2632       if (gp_symbol == NULL)
2633         {
2634           if (symbol_table_frozen)
2635             {
2636               symbolS * gp;
2637
2638               gp = symbol_find ("__gp");
2639               if (gp == NULL)
2640                 as_bad (("unable to create __gp symbol: please re-assemble with the -msmall-data-limit option specified"));
2641               else
2642                 gp_symbol = symbol_get_bfdsym (gp);
2643             }
2644           else
2645             gp_symbol = symbol_get_bfdsym (symbol_find_or_make ("__gp"));
2646         }
2647       * reloc[1]->sym_ptr_ptr = gp_symbol;
2648       reloc[1]->address       = fixp->fx_frag->fr_address + fixp->fx_where;
2649       reloc[1]->addend        = 0;
2650       reloc[1]->howto         = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_SYM);
2651
2652       reloc[2]              = XNEW (arelent);
2653       reloc[2]->howto       = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_OP_SUBTRACT);
2654       reloc[2]->addend      = 0;
2655       reloc[2]->sym_ptr_ptr = reloc[1]->sym_ptr_ptr;
2656       reloc[2]->address     = fixp->fx_frag->fr_address + fixp->fx_where;
2657
2658       reloc[3]              = XNEW (arelent);
2659       reloc[3]->howto       = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_ABS16U);
2660       reloc[3]->addend      = 0;
2661       reloc[3]->sym_ptr_ptr = reloc[1]->sym_ptr_ptr;
2662       reloc[3]->address     = fixp->fx_frag->fr_address + fixp->fx_where;
2663
2664       reloc[4] = NULL;
2665       break;
2666
2667     case BFD_RELOC_RX_NEG32:
2668       reloc[0]->howto         = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_SYM);
2669
2670       reloc[1]              = XNEW (arelent);
2671       reloc[1]->howto       = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_OP_NEG);
2672       reloc[1]->addend      = 0;
2673       reloc[1]->sym_ptr_ptr = reloc[0]->sym_ptr_ptr;
2674       reloc[1]->address     = fixp->fx_frag->fr_address + fixp->fx_where;
2675
2676       reloc[2]              = XNEW (arelent);
2677       reloc[2]->howto       = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_ABS32);
2678       reloc[2]->addend      = 0;
2679       reloc[2]->sym_ptr_ptr = reloc[0]->sym_ptr_ptr;
2680       reloc[2]->address     = fixp->fx_frag->fr_address + fixp->fx_where;
2681
2682       reloc[3] = NULL;
2683       break;
2684
2685     default:
2686       reloc[0]->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
2687       reloc[1] = NULL;
2688       break;
2689     }
2690
2691   return reloc;
2692 }
2693
2694 void
2695 rx_note_string_insn_use (void)
2696 {
2697   if ((elf_flags & E_FLAG_RX_SINSNS_MASK) == (E_FLAG_RX_SINSNS_SET | E_FLAG_RX_SINSNS_NO))
2698     as_bad (_("Use of an RX string instruction detected in a file being assembled without string instruction support"));
2699   elf_flags |= E_FLAG_RX_SINSNS_SET | E_FLAG_RX_SINSNS_YES;
2700 }
2701
2702 /* Set the ELF specific flags.  */
2703
2704 void
2705 rx_elf_final_processing (void)
2706 {
2707   elf_elfheader (stdoutput)->e_flags |= elf_flags;
2708 }
2709
2710 /* Scan the current input line for occurrences of Renesas
2711    local labels and replace them with the GAS version.  */
2712
2713 void
2714 rx_start_line (void)
2715 {
2716   int in_double_quote = 0;
2717   int in_single_quote = 0;
2718   int done = 0;
2719   char * p = input_line_pointer;
2720   char prev_char = 0;
2721
2722   /* Scan the line looking for question marks.  Skip past quote enclosed regions.  */
2723   do
2724     {
2725       switch (*p)
2726         {
2727         case '\n':
2728         case 0:
2729           done = 1;
2730           break;
2731
2732         case '"':
2733           /* Handle escaped double quote \" inside a string.  */
2734           if (prev_char != '\\')
2735             in_double_quote = ! in_double_quote;
2736           break;
2737
2738         case '\'':
2739           in_single_quote = ! in_single_quote;
2740           break;
2741
2742         case '?':
2743           if (in_double_quote || in_single_quote)
2744             break;
2745
2746           if (p[1] == ':')
2747             *p = '1';
2748           else if (p[1] == '+')
2749             {
2750               p[0] = '1';
2751               p[1] = 'f';
2752             }
2753           else if (p[1] == '-')
2754             {
2755               p[0] = '1';
2756               p[1] = 'b';
2757             }
2758           break;
2759
2760         default:
2761           break;
2762         }
2763
2764       prev_char = *p++;
2765     }
2766   while (! done);
2767 }