gas/config/tc-rl78.c

   1 /* tc-rl78.c -- Assembler for the Renesas RL78
   2    Copyright (C) 2011-2016 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 "struc-symbol.h"
  23 #include "safe-ctype.h"
  24 #include "dwarf2dbg.h"
  25 #include "libbfd.h"
  26 #include "elf/common.h"
  27 #include "elf/rl78.h"
  28 #include "rl78-defs.h"
  29 #include "filenames.h"
  30 #include "listing.h"
  31 #include "sb.h"
  32 #include "macro.h"
  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 /* Use something that isn't going to be needed by any expressions or
  40    other syntax.  */
  41 const char line_separator_chars[] = "@";
  42
  43 const char EXP_CHARS[]            = "eE";
  44 const char FLT_CHARS[]            = "dD";
  45
  46 /* ELF flags to set in the output file header.  */
  47 static int elf_flags = 0;
  48
  49 /*------------------------------------------------------------------*/
  50
  51 char * rl78_lex_start;
  52 char * rl78_lex_end;
  53
  54 typedef struct rl78_bytesT
  55 {
  56   char prefix[1];
  57   int n_prefix;
  58   char base[4];
  59   int n_base;
  60   char ops[8];
  61   int n_ops;
  62   struct
  63   {
  64     expressionS  exp;
  65     char         offset;
  66     char         nbits;
  67     char         type; /* RL78REL_*.  */
  68     int          reloc;
  69     fixS *       fixP;
  70   } fixups[2];
  71   int n_fixups;
  72   struct
  73   {
  74     char type;
  75     char field_pos;
  76     char val_ofs;
  77   } relax[2];
  78   int n_relax;
  79   int link_relax;
  80   fixS *link_relax_fixP;
  81   char times_grown;
  82   char times_shrank;
  83 } rl78_bytesT;
  84
  85 static rl78_bytesT rl78_bytes;
  86
  87 void
  88 rl78_relax (int type, int pos)
  89 {
  90   rl78_bytes.relax[rl78_bytes.n_relax].type = type;
  91   rl78_bytes.relax[rl78_bytes.n_relax].field_pos = pos;
  92   rl78_bytes.relax[rl78_bytes.n_relax].val_ofs = rl78_bytes.n_base + rl78_bytes.n_ops;
  93   rl78_bytes.n_relax ++;
  94 }
  95
  96 void
  97 rl78_linkrelax_addr16 (void)
  98 {
  99   rl78_bytes.link_relax |= RL78_RELAXA_ADDR16;
 100 }
 101
 102 void
 103 rl78_linkrelax_branch (void)
 104 {
 105   rl78_relax (RL78_RELAX_BRANCH, 0);
 106   rl78_bytes.link_relax |= RL78_RELAXA_BRA;
 107 }
 108
 109 static void
 110 rl78_fixup (expressionS exp, int offsetbits, int nbits, int type)
 111 {
 112   rl78_bytes.fixups[rl78_bytes.n_fixups].exp = exp;
 113   rl78_bytes.fixups[rl78_bytes.n_fixups].offset = offsetbits;
 114   rl78_bytes.fixups[rl78_bytes.n_fixups].nbits = nbits;
 115   rl78_bytes.fixups[rl78_bytes.n_fixups].type = type;
 116   rl78_bytes.fixups[rl78_bytes.n_fixups].reloc = exp.X_md;
 117   rl78_bytes.n_fixups ++;
 118 }
 119
 120 #define rl78_field_fixup(exp, offset, nbits, type)      \
 121   rl78_fixup (exp, offset + 8 * rl78_bytes.n_prefix), nbits, type)
 122
 123 #define rl78_op_fixup(exp, offset, nbits, type)         \
 124   rl78_fixup (exp, offset + 8 * (rl78_bytes.n_prefix + rl78_bytes.n_base), nbits, type)
 125
 126 void
 127 rl78_prefix (int p)
 128 {
 129   rl78_bytes.prefix[0] = p;
 130   rl78_bytes.n_prefix = 1;
 131 }
 132
 133 int
 134 rl78_has_prefix (void)
 135 {
 136   return rl78_bytes.n_prefix;
 137 }
 138
 139 void
 140 rl78_base1 (int b1)
 141 {
 142   rl78_bytes.base[0] = b1;
 143   rl78_bytes.n_base = 1;
 144 }
 145
 146 void
 147 rl78_base2 (int b1, int b2)
 148 {
 149   rl78_bytes.base[0] = b1;
 150   rl78_bytes.base[1] = b2;
 151   rl78_bytes.n_base = 2;
 152 }
 153
 154 void
 155 rl78_base3 (int b1, int b2, int b3)
 156 {
 157   rl78_bytes.base[0] = b1;
 158   rl78_bytes.base[1] = b2;
 159   rl78_bytes.base[2] = b3;
 160   rl78_bytes.n_base = 3;
 161 }
 162
 163 void
 164 rl78_base4 (int b1, int b2, int b3, int b4)
 165 {
 166   rl78_bytes.base[0] = b1;
 167   rl78_bytes.base[1] = b2;
 168   rl78_bytes.base[2] = b3;
 169   rl78_bytes.base[3] = b4;
 170   rl78_bytes.n_base = 4;
 171 }
 172
 173 #define F_PRECISION 2
 174
 175 void
 176 rl78_op (expressionS exp, int nbytes, int type)
 177 {
 178   int v = 0;
 179
 180   if ((exp.X_op == O_constant || exp.X_op == O_big)
 181       && type != RL78REL_PCREL)
 182     {
 183       if (exp.X_op == O_big && exp.X_add_number <= 0)
 184         {
 185           LITTLENUM_TYPE w[2];
 186           char * ip = rl78_bytes.ops + rl78_bytes.n_ops;
 187
 188           gen_to_words (w, F_PRECISION, 8);
 189           ip[3] = w[0] >> 8;
 190           ip[2] = w[0];
 191           ip[1] = w[1] >> 8;
 192           ip[0] = w[1];
 193           rl78_bytes.n_ops += 4;
 194         }
 195       else
 196         {
 197           v = exp.X_add_number;
 198           while (nbytes)
 199             {
 200               rl78_bytes.ops[rl78_bytes.n_ops++] =v & 0xff;
 201               v >>= 8;
 202               nbytes --;
 203             }
 204         }
 205     }
 206   else
 207     {
 208       if (nbytes > 2
 209           && exp.X_md == BFD_RELOC_RL78_CODE)
 210         exp.X_md = 0;
 211
 212       if (nbytes == 1
 213           && (exp.X_md == BFD_RELOC_RL78_LO16
 214               || exp.X_md == BFD_RELOC_RL78_HI16))
 215         as_bad (_("16-bit relocation used in 8-bit operand"));
 216
 217       if (nbytes == 2
 218           && exp.X_md == BFD_RELOC_RL78_HI8)
 219         as_bad (_("8-bit relocation used in 16-bit operand"));
 220
 221       rl78_op_fixup (exp, rl78_bytes.n_ops * 8, nbytes * 8, type);
 222       memset (rl78_bytes.ops + rl78_bytes.n_ops, 0, nbytes);
 223       rl78_bytes.n_ops += nbytes;
 224     }
 225 }
 226
 227 /* This gets complicated when the field spans bytes, because fields
 228    are numbered from the MSB of the first byte as zero, and bits are
 229    stored LSB towards the LSB of the byte.  Thus, a simple four-bit
 230    insertion of 12 at position 4 of 0x00 yields: 0x0b.  A three-bit
 231    insertion of b'MXL at position 7 is like this:
 232
 233      - - - -  - - - -   - - - -  - - - -
 234                     M   X L               */
 235
 236 void
 237 rl78_field (int val, int pos, int sz)
 238 {
 239   int valm;
 240   int bytep, bitp;
 241
 242   if (sz > 0)
 243     {
 244       if (val < 0 || val >= (1 << sz))
 245         as_bad (_("Value %d doesn't fit in unsigned %d-bit field"), val, sz);
 246     }
 247   else
 248     {
 249       sz = - sz;
 250       if (val < -(1 << (sz - 1)) || val >= (1 << (sz - 1)))
 251         as_bad (_("Value %d doesn't fit in signed %d-bit field"), val, sz);
 252     }
 253
 254   /* This code points at 'M' in the above example.  */
 255   bytep = pos / 8;
 256   bitp = pos % 8;
 257
 258   while (bitp + sz > 8)
 259     {
 260       int ssz = 8 - bitp;
 261       int svalm;
 262
 263       svalm = val >> (sz - ssz);
 264       svalm = svalm & ((1 << ssz) - 1);
 265       svalm = svalm << (8 - bitp - ssz);
 266       gas_assert (bytep < rl78_bytes.n_base);
 267       rl78_bytes.base[bytep] |= svalm;
 268
 269       bitp = 0;
 270       sz -= ssz;
 271       bytep ++;
 272     }
 273   valm = val & ((1 << sz) - 1);
 274   valm = valm << (8 - bitp - sz);
 275   gas_assert (bytep < rl78_bytes.n_base);
 276   rl78_bytes.base[bytep] |= valm;
 277 }
 278
 279 /*------------------------------------------------------------------*/
 280
 281 enum options
 282 {
 283   OPTION_RELAX = OPTION_MD_BASE,
 284   OPTION_NORELAX,
 285   OPTION_G10,
 286   OPTION_G13,
 287   OPTION_G14,
 288   OPTION_32BIT_DOUBLES,
 289   OPTION_64BIT_DOUBLES,
 290 };
 291
 292 #define RL78_SHORTOPTS ""
 293 const char * md_shortopts = RL78_SHORTOPTS;
 294
 295 /* Assembler options.  */
 296 struct option md_longopts[] =
 297 {
 298   {"relax", no_argument, NULL, OPTION_RELAX},
 299   {"norelax", no_argument, NULL, OPTION_NORELAX},
 300   {"mg10", no_argument, NULL, OPTION_G10},
 301   {"mg13", no_argument, NULL, OPTION_G13},
 302   {"mg14", no_argument, NULL, OPTION_G14},
 303   {"mrl78", no_argument, NULL, OPTION_G14},
 304   {"m32bit-doubles", no_argument, NULL, OPTION_32BIT_DOUBLES},
 305   {"m64bit-doubles", no_argument, NULL, OPTION_64BIT_DOUBLES},
 306   {NULL, no_argument, NULL, 0}
 307 };
 308 size_t md_longopts_size = sizeof (md_longopts);
 309
 310 int
 311 md_parse_option (int c, const char * arg ATTRIBUTE_UNUSED)
 312 {
 313   switch (c)
 314     {
 315     case OPTION_RELAX:
 316       linkrelax = 1;
 317       return 1;
 318     case OPTION_NORELAX:
 319       linkrelax = 0;
 320       return 1;
 321
 322     case OPTION_G10:
 323       elf_flags &= ~ E_FLAG_RL78_CPU_MASK;
 324       elf_flags |= E_FLAG_RL78_G10;
 325       return 1;
 326
 327     case OPTION_G13:
 328       elf_flags &= ~ E_FLAG_RL78_CPU_MASK;
 329       elf_flags |= E_FLAG_RL78_G13;
 330       return 1;
 331
 332     case OPTION_G14:
 333       elf_flags &= ~ E_FLAG_RL78_CPU_MASK;
 334       elf_flags |= E_FLAG_RL78_G14;
 335       return 1;
 336
 337     case OPTION_32BIT_DOUBLES:
 338       elf_flags &= ~ E_FLAG_RL78_64BIT_DOUBLES;
 339       return 1;
 340
 341     case OPTION_64BIT_DOUBLES:
 342       elf_flags |= E_FLAG_RL78_64BIT_DOUBLES;
 343       return 1;
 344     }
 345   return 0;
 346 }
 347
 348 int
 349 rl78_isa_g10 (void)
 350 {
 351   return (elf_flags & E_FLAG_RL78_CPU_MASK) == E_FLAG_RL78_G10;
 352 }
 353
 354 int
 355 rl78_isa_g13 (void)
 356 {
 357   return (elf_flags & E_FLAG_RL78_CPU_MASK) == E_FLAG_RL78_G13;
 358 }
 359
 360 int
 361 rl78_isa_g14 (void)
 362 {
 363   return (elf_flags & E_FLAG_RL78_CPU_MASK) == E_FLAG_RL78_G14;
 364 }
 365
 366 void
 367 md_show_usage (FILE * stream)
 368 {
 369   fprintf (stream, _(" RL78 specific command line options:\n"));
 370   fprintf (stream, _("  --mrelax          Enable link time relaxation\n"));
 371   fprintf (stream, _("  --mg10            Enable support for G10 variant\n"));
 372   fprintf (stream, _("  --mg13            Selects the G13 core.\n"));
 373   fprintf (stream, _("  --mg14            Selects the G14 core [default]\n"));
 374   fprintf (stream, _("  --mrl78           Alias for --mg14\n"));
 375   fprintf (stream, _("  --m32bit-doubles  [default]\n"));
 376   fprintf (stream, _("  --m64bit-doubles  Source code uses 64-bit doubles\n"));
 377 }
 378
 379 static void
 380 s_bss (int ignore ATTRIBUTE_UNUSED)
 381 {
 382   int temp;
 383
 384   temp = get_absolute_expression ();
 385   subseg_set (bss_section, (subsegT) temp);
 386   demand_empty_rest_of_line ();
 387 }
 388
 389 static void
 390 rl78_float_cons (int ignore ATTRIBUTE_UNUSED)
 391 {
 392   if (elf_flags & E_FLAG_RL78_64BIT_DOUBLES)
 393     return float_cons ('d');
 394   return float_cons ('f');
 395 }
 396
 397 /* The target specific pseudo-ops which we support.  */
 398 const pseudo_typeS md_pseudo_table[] =
 399 {
 400   /* Our "standard" pseudos.  */
 401   { "double", rl78_float_cons,  'd' },
 402   { "bss",    s_bss,            0 },
 403   { "3byte",  cons,             3 },
 404   { "int",    cons,             4 },
 405   { "word",   cons,             4 },
 406
 407   /* End of list marker.  */
 408   { NULL,       NULL,           0 }
 409 };
 410
 411 static symbolS * rl78_abs_sym = NULL;
 412
 413 void
 414 md_begin (void)
 415 {
 416   rl78_abs_sym = symbol_make ("__rl78_abs__");
 417 }
 418
 419 void
 420 rl78_md_end (void)
 421 {
 422 }
 423
 424 /* Set the ELF specific flags.  */
 425 void
 426 rl78_elf_final_processing (void)
 427 {
 428   elf_elfheader (stdoutput)->e_flags |= elf_flags;
 429 }
 430
 431 /* Write a value out to the object file, using the appropriate endianness.  */
 432 void
 433 md_number_to_chars (char * buf, valueT val, int n)
 434 {
 435   number_to_chars_littleendian (buf, val, n);
 436 }
 437
 438 static void
 439 require_end_of_expr (const char *fname)
 440 {
 441   while (* input_line_pointer == ' '
 442          || * input_line_pointer == '\t')
 443     input_line_pointer ++;
 444
 445   if (! * input_line_pointer
 446       || strchr ("\n\r,", * input_line_pointer)
 447       || strchr (comment_chars, * input_line_pointer)
 448       || strchr (line_comment_chars, * input_line_pointer)
 449       || strchr (line_separator_chars, * input_line_pointer))
 450     return;
 451
 452   as_bad (_("%%%s() must be outermost term in expression"), fname);
 453 }
 454
 455 static struct
 456 {
 457   const char * fname;
 458   int    reloc;
 459 }
 460 reloc_functions[] =
 461 {
 462   { "code", BFD_RELOC_RL78_CODE },
 463   { "lo16", BFD_RELOC_RL78_LO16 },
 464   { "hi16", BFD_RELOC_RL78_HI16 },
 465   { "hi8",  BFD_RELOC_RL78_HI8 },
 466   { 0, 0 }
 467 };
 468
 469 void
 470 md_operand (expressionS * exp ATTRIBUTE_UNUSED)
 471 {
 472   int reloc = 0;
 473   int i;
 474
 475   for (i = 0; reloc_functions[i].fname; i++)
 476     {
 477       int flen = strlen (reloc_functions[i].fname);
 478
 479       if (input_line_pointer[0] == '%'
 480           && strncasecmp (input_line_pointer + 1, reloc_functions[i].fname, flen) == 0
 481           && input_line_pointer[flen + 1] == '(')
 482         {
 483           reloc = reloc_functions[i].reloc;
 484           input_line_pointer += flen + 2;
 485           break;
 486         }
 487     }
 488   if (reloc == 0)
 489     return;
 490
 491   expression (exp);
 492   if (* input_line_pointer == ')')
 493     input_line_pointer ++;
 494
 495   exp->X_md = reloc;
 496
 497   require_end_of_expr (reloc_functions[i].fname);
 498 }
 499
 500 void
 501 rl78_frag_init (fragS * fragP)
 502 {
 503   if (rl78_bytes.n_relax || rl78_bytes.link_relax)
 504     {
 505       fragP->tc_frag_data = XNEW (rl78_bytesT);
 506       memcpy (fragP->tc_frag_data, & rl78_bytes, sizeof (rl78_bytesT));
 507     }
 508   else
 509     fragP->tc_frag_data = 0;
 510 }
 511
 512 /* When relaxing, we need to output a reloc for any .align directive
 513    so that we can retain this alignment as we adjust opcode sizes.  */
 514 void
 515 rl78_handle_align (fragS * frag)
 516 {
 517   if (linkrelax
 518       && (frag->fr_type == rs_align
 519           || frag->fr_type == rs_align_code)
 520       && frag->fr_address + frag->fr_fix > 0
 521       && frag->fr_offset > 0
 522       && now_seg != bss_section)
 523     {
 524       fix_new (frag, frag->fr_fix, 0,
 525                &abs_symbol, RL78_RELAXA_ALIGN + frag->fr_offset,
 526                0, BFD_RELOC_RL78_RELAX);
 527       /* For the purposes of relaxation, this relocation is attached
 528          to the byte *after* the alignment - i.e. the byte that must
 529          remain aligned.  */
 530       fix_new (frag->fr_next, 0, 0,
 531                &abs_symbol, RL78_RELAXA_ELIGN + frag->fr_offset,
 532                0, BFD_RELOC_RL78_RELAX);
 533     }
 534 }
 535
 536 const char *
 537 md_atof (int type, char * litP, int * sizeP)
 538 {
 539   return ieee_md_atof (type, litP, sizeP, target_big_endian);
 540 }
 541
 542 symbolS *
 543 md_undefined_symbol (char * name ATTRIBUTE_UNUSED)
 544 {
 545   return NULL;
 546 }
 547
 548 #define APPEND(B, N_B)                                 \
 549   if (rl78_bytes.N_B)                                  \
 550     {                                                  \
 551       memcpy (bytes + idx, rl78_bytes.B, rl78_bytes.N_B);  \
 552       idx += rl78_bytes.N_B;                           \
 553     }
 554
 555
 556 void
 557 md_assemble (char * str)
 558 {
 559   char * bytes;
 560   fragS * frag_then = frag_now;
 561   int idx = 0;
 562   int i;
 563   int rel;
 564   expressionS  *exp;
 565
 566   /*printf("\033[32mASM: %s\033[0m\n", str);*/
 567
 568   dwarf2_emit_insn (0);
 569
 570   memset (& rl78_bytes, 0, sizeof (rl78_bytes));
 571
 572   rl78_lex_init (str, str + strlen (str));
 573
 574   rl78_parse ();
 575
 576   /* This simplifies the relaxation code.  */
 577   if (rl78_bytes.n_relax || rl78_bytes.link_relax)
 578     {
 579       int olen = rl78_bytes.n_prefix + rl78_bytes.n_base + rl78_bytes.n_ops;
 580       /* We do it this way because we want the frag to have the
 581          rl78_bytes in it, which we initialize above.  The extra bytes
 582          are for relaxing.  */
 583       bytes = frag_more (olen + 3);
 584       frag_then = frag_now;
 585       frag_variant (rs_machine_dependent,
 586                     olen /* max_chars */,
 587                     0 /* var */,
 588                     olen /* subtype */,
 589                     0 /* symbol */,
 590                     0 /* offset */,
 591                     0 /* opcode */);
 592       frag_then->fr_opcode = bytes;
 593       frag_then->fr_fix = olen + (bytes - frag_then->fr_literal);
 594       frag_then->fr_subtype = olen;
 595       frag_then->fr_var = 0;
 596     }
 597   else
 598     {
 599       bytes = frag_more (rl78_bytes.n_prefix + rl78_bytes.n_base + rl78_bytes.n_ops);
 600       frag_then = frag_now;
 601     }
 602
 603   APPEND (prefix, n_prefix);
 604   APPEND (base, n_base);
 605   APPEND (ops, n_ops);
 606
 607   if (rl78_bytes.link_relax)
 608     {
 609       fixS * f;
 610
 611       f = fix_new (frag_then,
 612                    (char *) bytes - frag_then->fr_literal,
 613                    0,
 614                    abs_section_sym,
 615                    rl78_bytes.link_relax | rl78_bytes.n_fixups,
 616                    0,
 617                    BFD_RELOC_RL78_RELAX);
 618       frag_then->tc_frag_data->link_relax_fixP = f;
 619     }
 620
 621   for (i = 0; i < rl78_bytes.n_fixups; i ++)
 622     {
 623       /* index: [nbytes][type] */
 624       static int reloc_map[5][4] =
 625         {
 626           { 0,            0 },
 627           { BFD_RELOC_8,  BFD_RELOC_8_PCREL },
 628           { BFD_RELOC_16, BFD_RELOC_16_PCREL },
 629           { BFD_RELOC_24, BFD_RELOC_24_PCREL },
 630           { BFD_RELOC_32, BFD_RELOC_32_PCREL },
 631         };
 632       fixS * f;
 633
 634       idx = rl78_bytes.fixups[i].offset / 8;
 635       rel = reloc_map [rl78_bytes.fixups[i].nbits / 8][(int) rl78_bytes.fixups[i].type];
 636
 637       if (rl78_bytes.fixups[i].reloc)
 638         rel = rl78_bytes.fixups[i].reloc;
 639
 640       if (frag_then->tc_frag_data)
 641         exp = & frag_then->tc_frag_data->fixups[i].exp;
 642       else
 643         exp = & rl78_bytes.fixups[i].exp;
 644
 645       f = fix_new_exp (frag_then,
 646                        (char *) bytes + idx - frag_then->fr_literal,
 647                        rl78_bytes.fixups[i].nbits / 8,
 648                        exp,
 649                        rl78_bytes.fixups[i].type == RL78REL_PCREL ? 1 : 0,
 650                        rel);
 651       if (frag_then->tc_frag_data)
 652         frag_then->tc_frag_data->fixups[i].fixP = f;
 653     }
 654 }
 655
 656 void
 657 rl78_cons_fix_new (fragS *      frag,
 658                  int            where,
 659                  int            size,
 660                  expressionS *  exp)
 661 {
 662   bfd_reloc_code_real_type type;
 663   fixS *fixP;
 664
 665   switch (size)
 666     {
 667     case 1:
 668       type = BFD_RELOC_8;
 669       break;
 670     case 2:
 671       type = BFD_RELOC_16;
 672       break;
 673     case 3:
 674       type = BFD_RELOC_24;
 675       break;
 676     case 4:
 677       type = BFD_RELOC_32;
 678       break;
 679     default:
 680       as_bad (_("unsupported constant size %d\n"), size);
 681       return;
 682     }
 683
 684   switch (exp->X_md)
 685     {
 686     case BFD_RELOC_RL78_CODE:
 687       if (size == 2)
 688         type = exp->X_md;
 689       break;
 690     case BFD_RELOC_RL78_LO16:
 691     case BFD_RELOC_RL78_HI16:
 692       if (size != 2)
 693         {
 694           /* Fixups to assembler generated expressions do not use %hi or %lo.  */
 695           if (frag->fr_file)
 696             as_bad (_("%%hi16/%%lo16 only applies to .short or .hword"));
 697         }
 698       else
 699         type = exp->X_md;
 700       break;
 701     case BFD_RELOC_RL78_HI8:
 702       if (size != 1)
 703         {
 704           /* Fixups to assembler generated expressions do not use %hi or %lo.  */
 705           if (frag->fr_file)
 706             as_bad (_("%%hi8 only applies to .byte"));
 707         }
 708       else
 709         type = exp->X_md;
 710       break;
 711     default:
 712       break;
 713     }
 714
 715   if (exp->X_op == O_subtract && exp->X_op_symbol)
 716     {
 717       if (size != 4 && size != 2 && size != 1)
 718         as_bad (_("difference of two symbols only supported with .long, .short, or .byte"));
 719       else
 720         type = BFD_RELOC_RL78_DIFF;
 721     }
 722
 723   fixP = fix_new_exp (frag, where, (int) size, exp, 0, type);
 724   switch (exp->X_md)
 725     {
 726       /* These are intended to have values larger than the container,
 727          since the backend puts only the portion we need in it.
 728          However, we don't have a backend-specific reloc for them as
 729          they're handled with complex relocations.  */
 730     case BFD_RELOC_RL78_LO16:
 731     case BFD_RELOC_RL78_HI16:
 732     case BFD_RELOC_RL78_HI8:
 733       fixP->fx_no_overflow = 1;
 734       break;
 735     default:
 736       break;
 737     }
 738 }
 739
 740 \f
 741 /*----------------------------------------------------------------------*/
 742 /* To recap: we estimate everything based on md_estimate_size, then
 743    adjust based on rl78_relax_frag.  When it all settles, we call
 744    md_convert frag to update the bytes.  The relaxation types and
 745    relocations are in fragP->tc_frag_data, which is a copy of that
 746    rl78_bytes.
 747
 748    Our scheme is as follows: fr_fix has the size of the smallest
 749    opcode (like BRA.S).  We store the number of total bytes we need in
 750    fr_subtype.  When we're done relaxing, we use fr_subtype and the
 751    existing opcode bytes to figure out what actual opcode we need to
 752    put in there.  If the fixup isn't resolvable now, we use the
 753    maximal size.  */
 754
 755 #define TRACE_RELAX 0
 756 #define tprintf if (TRACE_RELAX) printf
 757
 758
 759 typedef enum
 760 {
 761   OT_other,
 762   OT_bt,
 763   OT_bt_sfr,
 764   OT_bt_es,
 765   OT_bc,
 766   OT_bh,
 767   OT_sk,
 768   OT_call,
 769   OT_br,
 770 } op_type_T;
 771
 772 /* We're looking for these types of relaxations:
 773
 774    BT           00110001 sbit0cc1 addr----      (cc is 10 (BF) or 01 (BT))
 775    B~T          00110001 sbit0cc1 00000011 11101110 pcrel16- -------- (BR $!pcrel20)
 776
 777    BT sfr       00110001 sbit0cc0 sfr----- addr----
 778    BT ES:       00010001 00101110 sbit0cc1 addr----
 779
 780    BC           110111cc addr----
 781    B~C          110111cc 00000011 11101110 pcrel16- -------- (BR $!pcrel20)
 782
 783    BH           01100001 110c0011 00000011 11101110 pcrel16- -------- (BR $!pcrel20)
 784    B~H          01100001 110c0011 00000011 11101110 pcrel16- -------- (BR $!pcrel20)
 785 */
 786
 787 /* Given the opcode bytes at OP, figure out which opcode it is and
 788    return the type of opcode.  We use this to re-encode the opcode as
 789    a different size later.  */
 790
 791 static op_type_T
 792 rl78_opcode_type (char * ops)
 793 {
 794   unsigned char *op = (unsigned char *)ops;
 795
 796   if (op[0] == 0x31
 797       && ((op[1] & 0x0f) == 0x05
 798           || (op[1] & 0x0f) == 0x03))
 799     return OT_bt;
 800
 801   if (op[0] == 0x31
 802       && ((op[1] & 0x0f) == 0x04
 803           || (op[1] & 0x0f) == 0x02))
 804     return OT_bt_sfr;
 805
 806   if (op[0] == 0x11
 807       && op[1] == 0x31
 808       && ((op[2] & 0x0f) == 0x05
 809           || (op[2] & 0x0f) == 0x03))
 810     return OT_bt_es;
 811
 812   if ((op[0] & 0xfc) == 0xdc)
 813     return OT_bc;
 814
 815   if (op[0] == 0x61
 816       && (op[1] & 0xef) == 0xc3)
 817     return OT_bh;
 818
 819   if (op[0] == 0x61
 820       && (op[1] & 0xcf) == 0xc8)
 821     return OT_sk;
 822
 823   if (op[0] == 0x61
 824       && (op[1] & 0xef) == 0xe3)
 825     return OT_sk;
 826
 827   if (op[0] == 0xfc)
 828     return OT_call;
 829
 830   if ((op[0] & 0xec) == 0xec)
 831     return OT_br;
 832
 833   return OT_other;
 834 }
 835
 836 /* Returns zero if *addrP has the target address.  Else returns nonzero
 837    if we cannot compute the target address yet.  */
 838
 839 static int
 840 rl78_frag_fix_value (fragS *    fragP,
 841                      segT       segment,
 842                      int        which,
 843                      addressT * addrP,
 844                      int        need_diff,
 845                      addressT * sym_addr)
 846 {
 847   addressT addr = 0;
 848   rl78_bytesT * b = fragP->tc_frag_data;
 849   expressionS * exp = & b->fixups[which].exp;
 850
 851   if (need_diff && exp->X_op != O_subtract)
 852     return 1;
 853
 854   if (exp->X_add_symbol)
 855     {
 856       if (S_FORCE_RELOC (exp->X_add_symbol, 1))
 857         return 1;
 858       if (S_GET_SEGMENT (exp->X_add_symbol) != segment)
 859         return 1;
 860       addr += S_GET_VALUE (exp->X_add_symbol);
 861     }
 862
 863   if (exp->X_op_symbol)
 864     {
 865       if (exp->X_op != O_subtract)
 866         return 1;
 867       if (S_FORCE_RELOC (exp->X_op_symbol, 1))
 868         return 1;
 869       if (S_GET_SEGMENT (exp->X_op_symbol) != segment)
 870         return 1;
 871       addr -= S_GET_VALUE (exp->X_op_symbol);
 872     }
 873   if (sym_addr)
 874     * sym_addr = addr;
 875   addr += exp->X_add_number;
 876   * addrP = addr;
 877   return 0;
 878 }
 879
 880 /* Estimate how big the opcode is after this relax pass.  The return
 881    value is the difference between fr_fix and the actual size.  We
 882    compute the total size in rl78_relax_frag and store it in fr_subtype,
 883    so we only need to subtract fx_fix and return it.  */
 884
 885 int
 886 md_estimate_size_before_relax (fragS * fragP ATTRIBUTE_UNUSED, segT segment ATTRIBUTE_UNUSED)
 887 {
 888   int opfixsize;
 889   int delta;
 890
 891   /* This is the size of the opcode that's accounted for in fr_fix.  */
 892   opfixsize = fragP->fr_fix - (fragP->fr_opcode - fragP->fr_literal);
 893   /* This is the size of the opcode that isn't.  */
 894   delta = (fragP->fr_subtype - opfixsize);
 895
 896   tprintf (" -> opfixsize %d delta %d\n", opfixsize, delta);
 897   return delta;
 898 }
 899
 900 /* Given the new addresses for this relax pass, figure out how big
 901    each opcode must be.  We store the total number of bytes needed in
 902    fr_subtype.  The return value is the difference between the size
 903    after the last pass and the size after this pass, so we use the old
 904    fr_subtype to calculate the difference.  */
 905
 906 int
 907 rl78_relax_frag (segT segment ATTRIBUTE_UNUSED, fragS * fragP, long stretch)
 908 {
 909   addressT addr0, sym_addr;
 910   addressT mypc;
 911   int disp;
 912   int oldsize = fragP->fr_subtype;
 913   int newsize = oldsize;
 914   op_type_T optype;
 915   int ri;
 916
 917   mypc = fragP->fr_address + (fragP->fr_opcode - fragP->fr_literal);
 918
 919   /* If we ever get more than one reloc per opcode, this is the one
 920      we're relaxing.  */
 921   ri = 0;
 922
 923   optype = rl78_opcode_type (fragP->fr_opcode);
 924   /* Try to get the target address.  */
 925   if (rl78_frag_fix_value (fragP, segment, ri, & addr0,
 926                            fragP->tc_frag_data->relax[ri].type != RL78_RELAX_BRANCH,
 927                            & sym_addr))
 928     {
 929       /* If we don't expect the linker to do relaxing, don't emit
 930          expanded opcodes that only the linker will relax.  */
 931       if (!linkrelax)
 932         return newsize - oldsize;
 933
 934       /* If we don't, we must use the maximum size for the linker.  */
 935       switch (fragP->tc_frag_data->relax[ri].type)
 936         {
 937         case RL78_RELAX_BRANCH:
 938           switch (optype)
 939             {
 940             case OT_bt:
 941               newsize = 6;
 942               break;
 943             case OT_bt_sfr:
 944             case OT_bt_es:
 945               newsize = 7;
 946               break;
 947             case OT_bc:
 948               newsize = 5;
 949               break;
 950             case OT_bh:
 951               newsize = 6;
 952               break;
 953             case OT_sk:
 954               newsize = 2;
 955               break;
 956             default:
 957               newsize = oldsize;
 958               break;
 959             }
 960           break;
 961
 962         }
 963       fragP->fr_subtype = newsize;
 964       tprintf (" -> new %d old %d delta %d (external)\n", newsize, oldsize, newsize-oldsize);
 965       return newsize - oldsize;
 966     }
 967
 968   if (sym_addr > mypc)
 969     addr0 += stretch;
 970
 971   switch (fragP->tc_frag_data->relax[ri].type)
 972     {
 973     case  RL78_RELAX_BRANCH:
 974       disp = (int) addr0 - (int) mypc;
 975
 976       switch (optype)
 977         {
 978         case OT_bt:
 979           if (disp >= -128 && (disp - (oldsize-2)) <= 127)
 980             newsize = 3;
 981           else
 982             newsize = 6;
 983           break;
 984         case OT_bt_sfr:
 985         case OT_bt_es:
 986           if (disp >= -128 && (disp - (oldsize-3)) <= 127)
 987             newsize = 4;
 988           else
 989             newsize = 7;
 990           break;
 991         case OT_bc:
 992           if (disp >= -128 && (disp - (oldsize-1)) <= 127)
 993             newsize = 2;
 994           else
 995             newsize = 5;
 996           break;
 997         case OT_bh:
 998           if (disp >= -128 && (disp - (oldsize-2)) <= 127)
 999             newsize = 3;
1000           else
1001             newsize = 6;
1002           break;
1003         case OT_sk:
1004           newsize = 2;
1005           break;
1006         default:
1007           newsize = oldsize;
1008           break;
1009         }
1010       break;
1011     }
1012
1013   /* This prevents infinite loops in align-heavy sources.  */
1014   if (newsize < oldsize)
1015     {
1016       if (fragP->tc_frag_data->times_shrank > 10
1017          && fragP->tc_frag_data->times_grown > 10)
1018        newsize = oldsize;
1019       if (fragP->tc_frag_data->times_shrank < 20)
1020        fragP->tc_frag_data->times_shrank ++;
1021     }
1022   else if (newsize > oldsize)
1023     {
1024       if (fragP->tc_frag_data->times_grown < 20)
1025        fragP->tc_frag_data->times_grown ++;
1026     }
1027
1028   fragP->fr_subtype = newsize;
1029   tprintf (" -> new %d old %d delta %d\n", newsize, oldsize, newsize-oldsize);
1030   return newsize - oldsize;
1031 }
1032
1033 /* This lets us test for the opcode type and the desired size in a
1034    switch statement.  */
1035 #define OPCODE(type,size) ((type) * 16 + (size))
1036
1037 /* Given the opcode stored in fr_opcode and the number of bytes we
1038    think we need, encode a new opcode.  We stored a pointer to the
1039    fixup for this opcode in the tc_frag_data structure.  If we can do
1040    the fixup here, we change the relocation type to "none" (we test
1041    for that in tc_gen_reloc) else we change it to the right type for
1042    the new (biggest) opcode.  */
1043
1044 void
1045 md_convert_frag (bfd *   abfd ATTRIBUTE_UNUSED,
1046                  segT    segment ATTRIBUTE_UNUSED,
1047                  fragS * fragP ATTRIBUTE_UNUSED)
1048 {
1049   rl78_bytesT * rl78b = fragP->tc_frag_data;
1050   addressT addr0, mypc;
1051   int disp;
1052   int reloc_type, reloc_adjust;
1053   char * op = fragP->fr_opcode;
1054   int keep_reloc = 0;
1055   int ri;
1056   int fi = (rl78b->n_fixups > 1) ? 1 : 0;
1057   fixS * fix = rl78b->fixups[fi].fixP;
1058
1059   /* If we ever get more than one reloc per opcode, this is the one
1060      we're relaxing.  */
1061   ri = 0;
1062
1063   /* We used a new frag for this opcode, so the opcode address should
1064      be the frag address.  */
1065   mypc = fragP->fr_address + (fragP->fr_opcode - fragP->fr_literal);
1066   tprintf ("\033[32mmypc: 0x%x\033[0m\n", (int)mypc);
1067
1068   /* Try to get the target address.  If we fail here, we just use the
1069      largest format.  */
1070   if (rl78_frag_fix_value (fragP, segment, 0, & addr0,
1071                            fragP->tc_frag_data->relax[ri].type != RL78_RELAX_BRANCH, 0))
1072     {
1073       /* We don't know the target address.  */
1074       keep_reloc = 1;
1075       addr0 = 0;
1076       disp = 0;
1077       tprintf ("unknown addr ? - %x = ?\n", (int)mypc);
1078     }
1079   else
1080     {
1081       /* We know the target address, and it's in addr0.  */
1082       disp = (int) addr0 - (int) mypc;
1083       tprintf ("known addr %x - %x = %d\n", (int)addr0, (int)mypc, disp);
1084     }
1085
1086   if (linkrelax)
1087     keep_reloc = 1;
1088
1089   reloc_type = BFD_RELOC_NONE;
1090   reloc_adjust = 0;
1091
1092   switch (fragP->tc_frag_data->relax[ri].type)
1093     {
1094     case RL78_RELAX_BRANCH:
1095       switch (OPCODE (rl78_opcode_type (fragP->fr_opcode), fragP->fr_subtype))
1096         {
1097
1098         case OPCODE (OT_bt, 3): /* BT A,$ - no change.  */
1099           disp -= 3;
1100           op[2] = disp;
1101           reloc_type = keep_reloc ? BFD_RELOC_8_PCREL : BFD_RELOC_NONE;
1102           break;
1103
1104         case OPCODE (OT_bt, 6): /* BT A,$ - long version.  */
1105           disp -= 3;
1106           op[1] ^= 0x06; /* toggle conditional.  */
1107           op[2] = 3; /* displacement over long branch.  */
1108           disp -= 3;
1109           op[3] = 0xEE; /* BR $!addr20 */
1110           op[4] = disp & 0xff;
1111           op[5] = disp >> 8;
1112           reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE;
1113           reloc_adjust = 2;
1114           break;
1115
1116         case OPCODE (OT_bt_sfr, 4): /* BT PSW,$ - no change.  */
1117           disp -= 4;
1118           op[3] = disp;
1119           reloc_type = keep_reloc ? BFD_RELOC_8_PCREL : BFD_RELOC_NONE;
1120           break;
1121
1122         case OPCODE (OT_bt_sfr, 7): /* BT PSW,$ - long version.  */
1123           disp -= 4;
1124           op[1] ^= 0x06; /* toggle conditional.  */
1125           op[3] = 3; /* displacement over long branch.  */
1126           disp -= 3;
1127           op[4] = 0xEE; /* BR $!addr20 */
1128           op[5] = disp & 0xff;
1129           op[6] = disp >> 8;
1130           reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE;
1131           reloc_adjust = 2;
1132           break;
1133
1134         case OPCODE (OT_bt_es, 4): /* BT ES:[HL],$ - no change.  */
1135           disp -= 4;
1136           op[3] = disp;
1137           reloc_type = keep_reloc ? BFD_RELOC_8_PCREL : BFD_RELOC_NONE;
1138           break;
1139
1140         case OPCODE (OT_bt_es, 7): /* BT PSW,$ - long version.  */
1141           disp -= 4;
1142           op[2] ^= 0x06; /* toggle conditional.  */
1143           op[3] = 3; /* displacement over long branch.  */
1144           disp -= 3;
1145           op[4] = 0xEE; /* BR $!addr20 */
1146           op[5] = disp & 0xff;
1147           op[6] = disp >> 8;
1148           reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE;
1149           reloc_adjust = 2;
1150           break;
1151
1152         case OPCODE (OT_bc, 2): /* BC $ - no change.  */
1153           disp -= 2;
1154           op[1] = disp;
1155           reloc_type = keep_reloc ? BFD_RELOC_8_PCREL : BFD_RELOC_NONE;
1156           break;
1157
1158         case OPCODE (OT_bc, 5): /* BC $ - long version.  */
1159           disp -= 2;
1160           op[0] ^= 0x02; /* toggle conditional.  */
1161           op[1] = 3;
1162           disp -= 3;
1163           op[2] = 0xEE; /* BR $!addr20 */
1164           op[3] = disp & 0xff;
1165           op[4] = disp >> 8;
1166           reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE;
1167           reloc_adjust = 2;
1168           break;
1169
1170         case OPCODE (OT_bh, 3): /* BH $ - no change.  */
1171           disp -= 3;
1172           op[2] = disp;
1173           reloc_type = keep_reloc ? BFD_RELOC_8_PCREL : BFD_RELOC_NONE;
1174           break;
1175
1176         case OPCODE (OT_bh, 6): /* BC $ - long version.  */
1177           disp -= 3;
1178           op[1] ^= 0x10; /* toggle conditional.  */
1179           op[2] = 3;
1180           disp -= 3;
1181           op[3] = 0xEE; /* BR $!addr20 */
1182           op[4] = disp & 0xff;
1183           op[5] = disp >> 8;
1184           reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE;
1185           reloc_adjust = 2;
1186           break;
1187
1188         case OPCODE (OT_sk, 2): /* SK<cond> - no change */
1189           reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE;
1190           break;
1191
1192         default:
1193           reloc_type = fix ? fix->fx_r_type : BFD_RELOC_NONE;
1194           break;
1195         }
1196       break;
1197
1198     default:
1199       if (rl78b->n_fixups)
1200         {
1201           reloc_type = fix->fx_r_type;
1202           reloc_adjust = 0;
1203         }
1204       break;
1205     }
1206
1207   if (rl78b->n_fixups)
1208     {
1209
1210       fix->fx_r_type = reloc_type;
1211       fix->fx_where += reloc_adjust;
1212       switch (reloc_type)
1213         {
1214         case BFD_RELOC_NONE:
1215           fix->fx_size = 0;
1216           break;
1217         case BFD_RELOC_8:
1218           fix->fx_size = 1;
1219           break;
1220         case BFD_RELOC_16_PCREL:
1221           fix->fx_size = 2;
1222           break;
1223         }
1224     }
1225
1226   fragP->fr_fix = fragP->fr_subtype + (fragP->fr_opcode - fragP->fr_literal);
1227   tprintf ("fragP->fr_fix now %ld (%d + (%p - %p)\n", (long) fragP->fr_fix,
1228           fragP->fr_subtype, fragP->fr_opcode, fragP->fr_literal);
1229   fragP->fr_var = 0;
1230
1231   tprintf ("compare 0x%lx vs 0x%lx - 0x%lx = 0x%lx (%p)\n",
1232            (long)fragP->fr_fix,
1233            (long)fragP->fr_next->fr_address, (long)fragP->fr_address,
1234            (long)(fragP->fr_next->fr_address - fragP->fr_address),
1235            fragP->fr_next);
1236
1237   if (fragP->fr_next != NULL
1238           && ((offsetT) (fragP->fr_next->fr_address - fragP->fr_address)
1239               != fragP->fr_fix))
1240     as_bad (_("bad frag at %p : fix %ld addr %ld %ld \n"), fragP,
1241             (long) fragP->fr_fix,
1242             (long) fragP->fr_address, (long) fragP->fr_next->fr_address);
1243 }
1244
1245 /* End of relaxation code.
1246   ----------------------------------------------------------------------*/
1247 \f
1248
1249 arelent **
1250 tc_gen_reloc (asection * seg ATTRIBUTE_UNUSED, fixS * fixp)
1251 {
1252   static arelent * reloc[8];
1253   int rp;
1254
1255   if (fixp->fx_r_type == BFD_RELOC_NONE)
1256     {
1257       reloc[0] = NULL;
1258       return reloc;
1259     }
1260
1261   if (fixp->fx_r_type == BFD_RELOC_RL78_RELAX && !linkrelax)
1262     {
1263       reloc[0] = NULL;
1264       return reloc;
1265     }
1266
1267   if (fixp->fx_subsy
1268       && S_GET_SEGMENT (fixp->fx_subsy) == absolute_section)
1269     {
1270       fixp->fx_offset -= S_GET_VALUE (fixp->fx_subsy);
1271       fixp->fx_subsy = NULL;
1272     }
1273
1274   reloc[0]                = (arelent *) xmalloc (sizeof (arelent));
1275   reloc[0]->sym_ptr_ptr   = (asymbol **) xmalloc (sizeof (asymbol *));
1276   * reloc[0]->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
1277   reloc[0]->address       = fixp->fx_frag->fr_address + fixp->fx_where;
1278   reloc[0]->addend        = fixp->fx_offset;
1279
1280   if (fixp->fx_r_type == BFD_RELOC_RL78_32_OP
1281       && fixp->fx_subsy)
1282     {
1283       fixp->fx_r_type = BFD_RELOC_RL78_DIFF;
1284     }
1285
1286 #define OPX(REL,SYM,ADD)                                                        \
1287   reloc[rp]                = (arelent *) xmalloc (sizeof (arelent));            \
1288   reloc[rp]->sym_ptr_ptr   = (asymbol **) xmalloc (sizeof (asymbol *));         \
1289   reloc[rp]->howto         = bfd_reloc_type_lookup (stdoutput, REL);            \
1290   reloc[rp]->addend        = ADD;                                               \
1291   * reloc[rp]->sym_ptr_ptr = SYM;                                               \
1292   reloc[rp]->address       = fixp->fx_frag->fr_address + fixp->fx_where;        \
1293   reloc[++rp] = NULL
1294 #define OPSYM(SYM) OPX(BFD_RELOC_RL78_SYM, SYM, 0)
1295
1296   /* FIXME: We cannot do the normal thing for an immediate value reloc,
1297      ie creating a RL78_SYM reloc in the *ABS* section with an offset
1298      equal to the immediate value we want to store.  This fails because
1299      the reloc processing in bfd_perform_relocation and bfd_install_relocation
1300      will short circuit such relocs and never pass them on to the special
1301      reloc processing code.  So instead we create a RL78_SYM reloc against
1302      the __rl78_abs__ symbol and arrange for the linker scripts to place
1303      this symbol at address 0.  */
1304 #define OPIMM(IMM) OPX (BFD_RELOC_RL78_SYM, symbol_get_bfdsym (rl78_abs_sym), IMM)
1305
1306 #define OP(OP) OPX(BFD_RELOC_RL78_##OP, *reloc[0]->sym_ptr_ptr, 0)
1307 #define SYM0() reloc[0]->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RL78_SYM)
1308
1309   rp = 1;
1310
1311   /* Certain BFD relocations cannot be translated directly into
1312      a single (non-Red Hat) RL78 relocation, but instead need
1313      multiple RL78 relocations - handle them here.  */
1314   switch (fixp->fx_r_type)
1315     {
1316     case BFD_RELOC_RL78_DIFF:
1317       SYM0 ();
1318       OPSYM (symbol_get_bfdsym (fixp->fx_subsy));
1319       OP(OP_SUBTRACT);
1320
1321       switch (fixp->fx_size)
1322         {
1323         case 1:
1324           OP(ABS8);
1325           break;
1326         case 2:
1327           OP (ABS16);
1328           break;
1329         case 4:
1330           OP (ABS32);
1331           break;
1332         }
1333       break;
1334
1335     case BFD_RELOC_RL78_NEG32:
1336       SYM0 ();
1337       OP (OP_NEG);
1338       OP (ABS32);
1339       break;
1340
1341     case BFD_RELOC_RL78_CODE:
1342       reloc[0]->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RL78_16U);
1343       reloc[1] = NULL;
1344       break;
1345
1346     case BFD_RELOC_RL78_LO16:
1347       SYM0 ();
1348       OPIMM (0xffff);
1349       OP (OP_AND);
1350       OP (ABS16);
1351       break;
1352
1353     case BFD_RELOC_RL78_HI16:
1354       SYM0 ();
1355       OPIMM (16);
1356       OP (OP_SHRA);
1357       OP (ABS16);
1358       break;
1359
1360     case BFD_RELOC_RL78_HI8:
1361       SYM0 ();
1362       OPIMM (16);
1363       OP (OP_SHRA);
1364       OPIMM (0xff);
1365       OP (OP_AND);
1366       OP (ABS8);
1367       break;
1368
1369     default:
1370       reloc[0]->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
1371       reloc[1] = NULL;
1372       break;
1373     }
1374
1375   return reloc;
1376 }
1377
1378 int
1379 rl78_validate_fix_sub (struct fix * f)
1380 {
1381   /* We permit the subtraction of two symbols in a few cases.  */
1382   /* mov #sym1-sym2, R3 */
1383   if (f->fx_r_type == BFD_RELOC_RL78_32_OP)
1384     return 1;
1385   /* .long sym1-sym2 */
1386   if (f->fx_r_type == BFD_RELOC_RL78_DIFF
1387       && ! f->fx_pcrel
1388       && (f->fx_size == 4 || f->fx_size == 2 || f->fx_size == 1))
1389     return 1;
1390   return 0;
1391 }
1392
1393 long
1394 md_pcrel_from_section (fixS * fixP, segT sec)
1395 {
1396   long rv;
1397
1398   if (fixP->fx_addsy != NULL
1399       && (! S_IS_DEFINED (fixP->fx_addsy)
1400           || S_GET_SEGMENT (fixP->fx_addsy) != sec))
1401     /* The symbol is undefined (or is defined but not in this section).
1402        Let the linker figure it out.  */
1403     return 0;
1404
1405   rv = fixP->fx_frag->fr_address + fixP->fx_where;
1406   switch (fixP->fx_r_type)
1407     {
1408     case BFD_RELOC_8_PCREL:
1409       rv += 1;
1410       break;
1411     case BFD_RELOC_16_PCREL:
1412       rv += 2;
1413       break;
1414     default:
1415       break;
1416     }
1417   return rv;
1418 }
1419
1420 void
1421 md_apply_fix (struct fix * f ATTRIBUTE_UNUSED,
1422               valueT *     t ATTRIBUTE_UNUSED,
1423               segT         s ATTRIBUTE_UNUSED)
1424 {
1425   char * op;
1426   unsigned long val;
1427
1428   /* We always defer overflow checks for these to the linker, as it
1429      needs to do PLT stuff.  */
1430   if (f->fx_r_type == BFD_RELOC_RL78_CODE)
1431     f->fx_no_overflow = 1;
1432
1433   if (f->fx_addsy && S_FORCE_RELOC (f->fx_addsy, 1))
1434     return;
1435   if (f->fx_subsy && S_FORCE_RELOC (f->fx_subsy, 1))
1436     return;
1437
1438   op = f->fx_frag->fr_literal + f->fx_where;
1439   val = (unsigned long) * t;
1440
1441   if (f->fx_addsy == NULL)
1442     f->fx_done = 1;
1443
1444   switch (f->fx_r_type)
1445     {
1446     case BFD_RELOC_NONE:
1447       break;
1448
1449     case BFD_RELOC_RL78_RELAX:
1450       f->fx_done = 0;
1451       break;
1452
1453     case BFD_RELOC_8_PCREL:
1454       if ((long)val < -128 || (long)val > 127)
1455         as_bad_where (f->fx_file, f->fx_line,
1456                       _("value of %ld too large for 8-bit branch"),
1457                       val);
1458       /* Fall through.  */
1459     case BFD_RELOC_8:
1460     case BFD_RELOC_RL78_SADDR: /* We need to store the 8 LSB, but this works.  */
1461       op[0] = val;
1462       break;
1463
1464     case BFD_RELOC_16_PCREL:
1465       if ((long)val < -32768 || (long)val > 32767)
1466         as_bad_where (f->fx_file, f->fx_line,
1467                       _("value of %ld too large for 16-bit branch"),
1468                       val);
1469       /* Fall through.  */
1470     case BFD_RELOC_16:
1471     case BFD_RELOC_RL78_CODE:
1472       op[0] = val;
1473       op[1] = val >> 8;
1474       break;
1475
1476     case BFD_RELOC_24:
1477       op[0] = val;
1478       op[1] = val >> 8;
1479       op[2] = val >> 16;
1480       break;
1481
1482     case BFD_RELOC_32:
1483       op[0] = val;
1484       op[1] = val >> 8;
1485       op[2] = val >> 16;
1486       op[3] = val >> 24;
1487       break;
1488
1489     case BFD_RELOC_RL78_DIFF:
1490       op[0] = val;
1491       if (f->fx_size > 1)
1492         op[1] = val >> 8;
1493       if (f->fx_size > 2)
1494         op[2] = val >> 16;
1495       if (f->fx_size > 3)
1496         op[3] = val >> 24;
1497       break;
1498
1499     case BFD_RELOC_RL78_HI8:
1500       val = val >> 16;
1501       op[0] = val;
1502       break;
1503
1504     case BFD_RELOC_RL78_HI16:
1505       val = val >> 16;
1506       op[0] = val;
1507       op[1] = val >> 8;
1508       break;
1509
1510     case BFD_RELOC_RL78_LO16:
1511       op[0] = val;
1512       op[1] = val >> 8;
1513       break;
1514
1515     default:
1516       as_bad (_("Unknown reloc in md_apply_fix: %s"),
1517               bfd_get_reloc_code_name (f->fx_r_type));
1518       break;
1519     }
1520
1521 }
1522
1523 valueT
1524 md_section_align (segT segment, valueT size)
1525 {
1526   int align = bfd_get_section_alignment (stdoutput, segment);
1527   return ((size + (1 << align) - 1) & -(1 << align));
1528 }