gas/config/tc-rx.c

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