gas/config/tc-rl78.c

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