gas/config/tc-moxie.c

   1 /* tc-moxie.c -- Assemble code for moxie
   2    Copyright (C) 2009-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
  18    the Free Software Foundation, 51 Franklin Street - Fifth Floor,
  19    Boston, MA 02110-1301, USA.  */
  20
  21 /* Contributed by Anthony Green <green@moxielogic.com>.  */
  22
  23 #include "as.h"
  24 #include "safe-ctype.h"
  25 #include "opcode/moxie.h"
  26 #include "elf/moxie.h"
  27
  28 extern const moxie_opc_info_t moxie_opc_info[128];
  29
  30 const char comment_chars[]        = "#";
  31 const char line_separator_chars[] = ";";
  32 const char line_comment_chars[]   = "#";
  33
  34 static int pending_reloc;
  35 static struct hash_control *opcode_hash_control;
  36
  37 const pseudo_typeS md_pseudo_table[] =
  38 {
  39   {0, 0, 0}
  40 };
  41
  42 const char FLT_CHARS[] = "rRsSfFdDxXpP";
  43 const char EXP_CHARS[] = "eE";
  44
  45 static valueT md_chars_to_number (char * buf, int n);
  46
  47 /* Byte order.  */
  48 extern int target_big_endian;
  49
  50 void
  51 md_operand (expressionS *op __attribute__((unused)))
  52 {
  53   /* Empty for now. */
  54 }
  55
  56 /* This function is called once, at assembler startup time.  It sets
  57    up the hash table with all the opcodes in it, and also initializes
  58    some aliases for compatibility with other assemblers.  */
  59
  60 void
  61 md_begin (void)
  62 {
  63   int count;
  64   const moxie_opc_info_t *opcode;
  65   opcode_hash_control = hash_new ();
  66
  67   /* Insert names into hash table.  */
  68   for (count = 0, opcode = moxie_form1_opc_info; count++ < 64; opcode++)
  69     hash_insert (opcode_hash_control, opcode->name, (char *) opcode);
  70
  71   for (count = 0, opcode = moxie_form2_opc_info; count++ < 4; opcode++)
  72     hash_insert (opcode_hash_control, opcode->name, (char *) opcode);
  73
  74   for (count = 0, opcode = moxie_form3_opc_info; count++ < 10; opcode++)
  75     hash_insert (opcode_hash_control, opcode->name, (char *) opcode);
  76
  77   target_big_endian = TARGET_BYTES_BIG_ENDIAN;
  78
  79   bfd_set_arch_mach (stdoutput, TARGET_ARCH, 0);
  80 }
  81
  82 /* Parse an expression and then restore the input line pointer.  */
  83
  84 static char *
  85 parse_exp_save_ilp (char *s, expressionS *op)
  86 {
  87   char *save = input_line_pointer;
  88
  89   input_line_pointer = s;
  90   expression (op);
  91   s = input_line_pointer;
  92   input_line_pointer = save;
  93   return s;
  94 }
  95
  96 static int
  97 parse_register_operand (char **ptr)
  98 {
  99   int reg;
 100   char *s = *ptr;
 101
 102   if (*s != '$')
 103     {
 104       as_bad (_("expecting register"));
 105       ignore_rest_of_line ();
 106       return -1;
 107     }
 108   if (s[1] == 'f' && s[2] == 'p')
 109     {
 110       *ptr += 3;
 111       return 0;
 112     }
 113   if (s[1] == 's' && s[2] == 'p')
 114     {
 115       *ptr += 3;
 116       return 1;
 117     }
 118   if (s[1] == 'r')
 119     {
 120       reg = s[2] - '0';
 121       if ((reg < 0) || (reg > 9))
 122         {
 123           as_bad (_("illegal register number"));
 124           ignore_rest_of_line ();
 125           return -1;
 126         }
 127       if (reg == 1)
 128         {
 129           int r2 = s[3] - '0';
 130           if ((r2 >= 0) && (r2 <= 3))
 131             {
 132               reg = 10 + r2;
 133               *ptr += 1;
 134             }
 135         }
 136     }
 137   else
 138     {
 139       as_bad (_("illegal register number"));
 140       ignore_rest_of_line ();
 141       return -1;
 142     }
 143
 144   *ptr += 3;
 145
 146   return reg + 2;
 147 }
 148
 149 /* This is the guts of the machine-dependent assembler.  STR points to
 150    a machine dependent instruction.  This function is supposed to emit
 151    the frags/bytes it assembles to.  */
 152
 153 void
 154 md_assemble (char *str)
 155 {
 156   char *op_start;
 157   char *op_end;
 158
 159   moxie_opc_info_t *opcode;
 160   char *p;
 161   char pend;
 162
 163   unsigned short iword = 0;
 164
 165   int nlen = 0;
 166
 167   /* Drop leading whitespace.  */
 168   while (*str == ' ')
 169     str++;
 170
 171   /* Find the op code end.  */
 172   op_start = str;
 173   for (op_end = str;
 174        *op_end && !is_end_of_line[*op_end & 0xff] && *op_end != ' ';
 175        op_end++)
 176     nlen++;
 177
 178   pend = *op_end;
 179   *op_end = 0;
 180
 181   if (nlen == 0)
 182     as_bad (_("can't find opcode "));
 183   opcode = (moxie_opc_info_t *) hash_find (opcode_hash_control, op_start);
 184   *op_end = pend;
 185
 186   if (opcode == NULL)
 187     {
 188       as_bad (_("unknown opcode %s"), op_start);
 189       return;
 190     }
 191
 192   p = frag_more (2);
 193
 194   switch (opcode->itype)
 195     {
 196     case MOXIE_F2_A8V:
 197       iword = (1<<15) | (opcode->opcode << 12);
 198       while (ISSPACE (*op_end))
 199         op_end++;
 200       {
 201         expressionS arg;
 202         int reg;
 203         reg = parse_register_operand (&op_end);
 204         iword += (reg << 8);
 205         if (*op_end != ',')
 206           as_warn (_("expecting comma delimited register operands"));
 207         op_end++;
 208         op_end = parse_exp_save_ilp (op_end, &arg);
 209         fix_new_exp (frag_now,
 210                      ((p + (target_big_endian ? 1 : 0)) - frag_now->fr_literal),
 211                      1,
 212                      &arg,
 213                      0,
 214                      BFD_RELOC_8);
 215       }
 216       break;
 217     case MOXIE_F1_AB:
 218       iword = opcode->opcode << 8;
 219       while (ISSPACE (*op_end))
 220         op_end++;
 221       {
 222         int dest, src;
 223         dest = parse_register_operand (&op_end);
 224         if (*op_end != ',')
 225           as_warn (_("expecting comma delimited register operands"));
 226         op_end++;
 227         src  = parse_register_operand (&op_end);
 228         iword += (dest << 4) + src;
 229         while (ISSPACE (*op_end))
 230           op_end++;
 231         if (*op_end != 0)
 232           as_warn (_("extra stuff on line ignored"));
 233       }
 234       break;
 235     case MOXIE_F1_A4:
 236       iword = opcode->opcode << 8;
 237       while (ISSPACE (*op_end))
 238         op_end++;
 239       {
 240         expressionS arg;
 241         char *where;
 242         int regnum;
 243
 244         regnum = parse_register_operand (&op_end);
 245         while (ISSPACE (*op_end))
 246           op_end++;
 247
 248         iword += (regnum << 4);
 249
 250         if (*op_end != ',')
 251           {
 252             as_bad (_("expecting comma delimited operands"));
 253             ignore_rest_of_line ();
 254             return;
 255           }
 256         op_end++;
 257
 258         op_end = parse_exp_save_ilp (op_end, &arg);
 259         where = frag_more (4);
 260         fix_new_exp (frag_now,
 261                      (where - frag_now->fr_literal),
 262                      4,
 263                      &arg,
 264                      0,
 265                      BFD_RELOC_32);
 266       }
 267       break;
 268     case MOXIE_F1_M:
 269     case MOXIE_F1_4:
 270       iword = opcode->opcode << 8;
 271       while (ISSPACE (*op_end))
 272         op_end++;
 273       {
 274         expressionS arg;
 275         char *where;
 276
 277         op_end = parse_exp_save_ilp (op_end, &arg);
 278         where = frag_more (4);
 279         fix_new_exp (frag_now,
 280                      (where - frag_now->fr_literal),
 281                      4,
 282                      &arg,
 283                      0,
 284                      BFD_RELOC_32);
 285       }
 286       break;
 287     case MOXIE_F1_NARG:
 288       iword = opcode->opcode << 8;
 289       while (ISSPACE (*op_end))
 290         op_end++;
 291       if (*op_end != 0)
 292         as_warn (_("extra stuff on line ignored"));
 293       break;
 294     case MOXIE_F1_A:
 295       iword = opcode->opcode << 8;
 296       while (ISSPACE (*op_end))
 297         op_end++;
 298       {
 299         int reg;
 300         reg = parse_register_operand (&op_end);
 301         while (ISSPACE (*op_end))
 302           op_end++;
 303         if (*op_end != 0)
 304           as_warn (_("extra stuff on line ignored"));
 305         iword += (reg << 4);
 306       }
 307       break;
 308     case MOXIE_F1_ABi:
 309       iword = opcode->opcode << 8;
 310       while (ISSPACE (*op_end))
 311         op_end++;
 312       {
 313         int a, b;
 314         a = parse_register_operand (&op_end);
 315         if (*op_end != ',')
 316           as_warn (_("expecting comma delimited register operands"));
 317         op_end++;
 318         if (*op_end != '(')
 319           {
 320             as_bad (_("expecting indirect register `($rA)'"));
 321             ignore_rest_of_line ();
 322             return;
 323           }
 324         op_end++;
 325         b = parse_register_operand (&op_end);
 326         if (*op_end != ')')
 327           {
 328             as_bad (_("missing closing parenthesis"));
 329             ignore_rest_of_line ();
 330             return;
 331           }
 332         op_end++;
 333         iword += (a << 4) + b;
 334         while (ISSPACE (*op_end))
 335           op_end++;
 336         if (*op_end != 0)
 337           as_warn (_("extra stuff on line ignored"));
 338       }
 339       break;
 340     case MOXIE_F1_AiB:
 341       iword = opcode->opcode << 8;
 342       while (ISSPACE (*op_end))
 343         op_end++;
 344       {
 345         int a, b;
 346         if (*op_end != '(')
 347           {
 348             as_bad (_("expecting indirect register `($rA)'"));
 349             ignore_rest_of_line ();
 350             return;
 351           }
 352         op_end++;
 353         a = parse_register_operand (&op_end);
 354         if (*op_end != ')')
 355           {
 356             as_bad (_("missing closing parenthesis"));
 357             ignore_rest_of_line ();
 358             return;
 359           }
 360         op_end++;
 361         if (*op_end != ',')
 362           as_warn (_("expecting comma delimited register operands"));
 363         op_end++;
 364         b = parse_register_operand (&op_end);
 365         iword += (a << 4) + b;
 366         while (ISSPACE (*op_end))
 367           op_end++;
 368         if (*op_end != 0)
 369           as_warn (_("extra stuff on line ignored"));
 370       }
 371       break;
 372     case MOXIE_F1_4A:
 373       iword = opcode->opcode << 8;
 374       while (ISSPACE (*op_end))
 375         op_end++;
 376       {
 377         expressionS arg;
 378         char *where;
 379         int a;
 380
 381         op_end = parse_exp_save_ilp (op_end, &arg);
 382         where = frag_more (4);
 383         fix_new_exp (frag_now,
 384                      (where - frag_now->fr_literal),
 385                      4,
 386                      &arg,
 387                      0,
 388                      BFD_RELOC_32);
 389
 390         if (*op_end != ',')
 391           {
 392             as_bad (_("expecting comma delimited operands"));
 393             ignore_rest_of_line ();
 394             return;
 395           }
 396         op_end++;
 397
 398         a = parse_register_operand (&op_end);
 399         while (ISSPACE (*op_end))
 400           op_end++;
 401         if (*op_end != 0)
 402           as_warn (_("extra stuff on line ignored"));
 403
 404         iword += (a << 4);
 405       }
 406       break;
 407     case MOXIE_F1_ABi2:
 408       iword = opcode->opcode << 8;
 409       while (ISSPACE (*op_end))
 410         op_end++;
 411       {
 412         expressionS arg;
 413         char *offset;
 414         int a, b;
 415
 416         a = parse_register_operand (&op_end);
 417         while (ISSPACE (*op_end))
 418           op_end++;
 419
 420         if (*op_end != ',')
 421           {
 422             as_bad (_("expecting comma delimited operands"));
 423             ignore_rest_of_line ();
 424             return;
 425           }
 426         op_end++;
 427
 428         op_end = parse_exp_save_ilp (op_end, &arg);
 429         offset = frag_more (2);
 430         fix_new_exp (frag_now,
 431                      (offset - frag_now->fr_literal),
 432                      2,
 433                      &arg,
 434                      0,
 435                      BFD_RELOC_16);
 436
 437         if (*op_end != '(')
 438           {
 439             as_bad (_("expecting indirect register `($rX)'"));
 440             ignore_rest_of_line ();
 441             return;
 442           }
 443         op_end++;
 444         b = parse_register_operand (&op_end);
 445         if (*op_end != ')')
 446           {
 447             as_bad (_("missing closing parenthesis"));
 448             ignore_rest_of_line ();
 449             return;
 450           }
 451         op_end++;
 452
 453         while (ISSPACE (*op_end))
 454           op_end++;
 455         if (*op_end != 0)
 456           as_warn (_("extra stuff on line ignored"));
 457
 458         iword += (a << 4) + b;
 459       }
 460       break;
 461     case MOXIE_F1_AiB2:
 462       iword = opcode->opcode << 8;
 463       while (ISSPACE (*op_end))
 464         op_end++;
 465       {
 466         expressionS arg;
 467         char *offset;
 468         int a, b;
 469
 470         op_end = parse_exp_save_ilp (op_end, &arg);
 471         offset = frag_more (2);
 472         fix_new_exp (frag_now,
 473                      (offset - frag_now->fr_literal),
 474                      2,
 475                      &arg,
 476                      0,
 477                      BFD_RELOC_16);
 478
 479         if (*op_end != '(')
 480           {
 481             as_bad (_("expecting indirect register `($rX)'"));
 482             ignore_rest_of_line ();
 483             return;
 484           }
 485         op_end++;
 486         a = parse_register_operand (&op_end);
 487         if (*op_end != ')')
 488           {
 489             as_bad (_("missing closing parenthesis"));
 490             ignore_rest_of_line ();
 491             return;
 492           }
 493         op_end++;
 494
 495         if (*op_end != ',')
 496           {
 497             as_bad (_("expecting comma delimited operands"));
 498             ignore_rest_of_line ();
 499             return;
 500           }
 501         op_end++;
 502
 503         b = parse_register_operand (&op_end);
 504         while (ISSPACE (*op_end))
 505           op_end++;
 506
 507         while (ISSPACE (*op_end))
 508           op_end++;
 509         if (*op_end != 0)
 510           as_warn (_("extra stuff on line ignored"));
 511
 512         iword += (a << 4) + b;
 513       }
 514       break;
 515     case MOXIE_F2_NARG:
 516       iword = opcode->opcode << 12;
 517       while (ISSPACE (*op_end))
 518         op_end++;
 519       if (*op_end != 0)
 520         as_warn (_("extra stuff on line ignored"));
 521       break;
 522     case MOXIE_F3_PCREL:
 523       iword = (3<<14) | (opcode->opcode << 10);
 524       while (ISSPACE (*op_end))
 525         op_end++;
 526       {
 527         expressionS arg;
 528
 529         op_end = parse_exp_save_ilp (op_end, &arg);
 530         fix_new_exp (frag_now,
 531                      (p - frag_now->fr_literal),
 532                      2,
 533                      &arg,
 534                      TRUE,
 535                      BFD_RELOC_MOXIE_10_PCREL);
 536       }
 537       break;
 538     default:
 539       abort ();
 540     }
 541
 542   md_number_to_chars (p, iword, 2);
 543
 544   while (ISSPACE (*op_end))
 545     op_end++;
 546
 547   if (*op_end != 0)
 548     as_warn (_("extra stuff on line ignored"));
 549
 550   if (pending_reloc)
 551     as_bad (_("Something forgot to clean up\n"));
 552 }
 553
 554 /* Turn a string in input_line_pointer into a floating point constant
 555    of type type, and store the appropriate bytes in *LITP.  The number
 556    of LITTLENUMS emitted is stored in *SIZEP .  An error message is
 557    returned, or NULL on OK.  */
 558
 559 char *
 560 md_atof (int type, char *litP, int *sizeP)
 561 {
 562   int prec;
 563   LITTLENUM_TYPE words[4];
 564   char *t;
 565   int i;
 566
 567   switch (type)
 568     {
 569     case 'f':
 570       prec = 2;
 571       break;
 572
 573     case 'd':
 574       prec = 4;
 575       break;
 576
 577     default:
 578       *sizeP = 0;
 579       return _("bad call to md_atof");
 580     }
 581
 582   t = atof_ieee (input_line_pointer, type, words);
 583   if (t)
 584     input_line_pointer = t;
 585
 586   *sizeP = prec * 2;
 587
 588   for (i = prec - 1; i >= 0; i--)
 589     {
 590       md_number_to_chars (litP, (valueT) words[i], 2);
 591       litP += 2;
 592     }
 593
 594   return NULL;
 595 }
 596
 597 enum options
 598 {
 599   OPTION_EB = OPTION_MD_BASE,
 600   OPTION_EL,
 601 };
 602
 603 struct option md_longopts[] =
 604 {
 605   { "EB",          no_argument, NULL, OPTION_EB},
 606   { "EL",          no_argument, NULL, OPTION_EL},
 607   { NULL,          no_argument, NULL, 0}
 608 };
 609
 610 size_t md_longopts_size = sizeof (md_longopts);
 611 \f
 612 const char *md_shortopts = "";
 613
 614 int
 615 md_parse_option (int c ATTRIBUTE_UNUSED, char *arg ATTRIBUTE_UNUSED)
 616 {
 617   switch (c)
 618     {
 619     case OPTION_EB:
 620       target_big_endian = 1;
 621       break;
 622     case OPTION_EL:
 623       target_big_endian = 0;
 624       break;
 625     default:
 626       return 0;
 627     }
 628
 629   return 1;
 630 }
 631
 632 void
 633 md_show_usage (FILE *stream ATTRIBUTE_UNUSED)
 634 {
 635   fprintf (stream, _("\
 636   -EB                     assemble for a big endian system (default)\n\
 637   -EL                     assemble for a little endian system\n"));
 638 }
 639
 640 /* Apply a fixup to the object file.  */
 641
 642 void
 643 md_apply_fix (fixS *fixP ATTRIBUTE_UNUSED,
 644               valueT * valP ATTRIBUTE_UNUSED, segT seg ATTRIBUTE_UNUSED)
 645 {
 646   char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
 647   long val = *valP;
 648   long newval;
 649   long max, min;
 650
 651   max = min = 0;
 652   switch (fixP->fx_r_type)
 653     {
 654     case BFD_RELOC_32:
 655       if (target_big_endian)
 656         {
 657           buf[0] = val >> 24;
 658           buf[1] = val >> 16;
 659           buf[2] = val >> 8;
 660           buf[3] = val >> 0;
 661         }
 662       else
 663         {
 664           buf[3] = val >> 24;
 665           buf[2] = val >> 16;
 666           buf[1] = val >> 8;
 667           buf[0] = val >> 0;
 668         }
 669       buf += 4;
 670       break;
 671
 672     case BFD_RELOC_16:
 673       if (target_big_endian)
 674         {
 675           buf[0] = val >> 8;
 676           buf[1] = val >> 0;
 677         }
 678       else
 679         {
 680           buf[1] = val >> 8;
 681           buf[0] = val >> 0;
 682         }
 683       buf += 2;
 684       break;
 685
 686     case BFD_RELOC_8:
 687       *buf++ = val;
 688       break;
 689
 690     case BFD_RELOC_MOXIE_10_PCREL:
 691       if (!val)
 692         break;
 693       if (val < -1024 || val > 1022)
 694         as_bad_where (fixP->fx_file, fixP->fx_line,
 695                       _("pcrel too far BFD_RELOC_MOXIE_10"));
 696       /* 11 bit offset even numbered, so we remove right bit.  */
 697       val >>= 1;
 698       newval = md_chars_to_number (buf, 2);
 699       newval |= val & 0x03ff;
 700       md_number_to_chars (buf, newval, 2);
 701       break;
 702
 703     default:
 704       abort ();
 705     }
 706
 707   if (max != 0 && (val < min || val > max))
 708     as_bad_where (fixP->fx_file, fixP->fx_line, _("offset out of range"));
 709
 710   if (fixP->fx_addsy == NULL && fixP->fx_pcrel == 0)
 711     fixP->fx_done = 1;
 712 }
 713
 714 /* Put number into target byte order.  */
 715
 716 void
 717 md_number_to_chars (char * ptr, valueT use, int nbytes)
 718 {
 719   if (target_big_endian)
 720     number_to_chars_bigendian (ptr, use, nbytes);
 721   else
 722     number_to_chars_littleendian (ptr, use, nbytes);
 723 }
 724
 725 /* Convert from target byte order to host byte order.  */
 726
 727 static valueT
 728 md_chars_to_number (char * buf, int n)
 729 {
 730   valueT result = 0;
 731   unsigned char * where = (unsigned char *) buf;
 732
 733   if (target_big_endian)
 734     {
 735       while (n--)
 736         {
 737           result <<= 8;
 738           result |= (*where++ & 255);
 739         }
 740     }
 741   else
 742     {
 743       while (n--)
 744         {
 745           result <<= 8;
 746           result |= (where[n] & 255);
 747         }
 748     }
 749
 750   return result;
 751 }
 752
 753 /* Generate a machine-dependent relocation.  */
 754 arelent *
 755 tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixP)
 756 {
 757   arelent *relP;
 758   bfd_reloc_code_real_type code;
 759
 760   switch (fixP->fx_r_type)
 761     {
 762     case BFD_RELOC_32:
 763       code = fixP->fx_r_type;
 764       break;
 765     case BFD_RELOC_MOXIE_10_PCREL:
 766       code = fixP->fx_r_type;
 767       break;
 768     default:
 769       as_bad_where (fixP->fx_file, fixP->fx_line,
 770                     _("Semantics error.  This type of operand can not be relocated, it must be an assembly-time constant"));
 771       return 0;
 772     }
 773
 774   relP = xmalloc (sizeof (arelent));
 775   gas_assert (relP != 0);
 776   relP->sym_ptr_ptr = xmalloc (sizeof (asymbol *));
 777   *relP->sym_ptr_ptr = symbol_get_bfdsym (fixP->fx_addsy);
 778   relP->address = fixP->fx_frag->fr_address + fixP->fx_where;
 779
 780   relP->addend = fixP->fx_offset;
 781
 782   /* This is the standard place for KLUDGEs to work around bugs in
 783      bfd_install_relocation (first such note in the documentation
 784      appears with binutils-2.8).
 785
 786      That function bfd_install_relocation does the wrong thing with
 787      putting stuff into the addend of a reloc (it should stay out) for a
 788      weak symbol.  The really bad thing is that it adds the
 789      "segment-relative offset" of the symbol into the reloc.  In this
 790      case, the reloc should instead be relative to the symbol with no
 791      other offset than the assembly code shows; and since the symbol is
 792      weak, any local definition should be ignored until link time (or
 793      thereafter).
 794      To wit:  weaksym+42  should be weaksym+42 in the reloc,
 795      not weaksym+(offset_from_segment_of_local_weaksym_definition)
 796
 797      To "work around" this, we subtract the segment-relative offset of
 798      "known" weak symbols.  This evens out the extra offset.
 799
 800      That happens for a.out but not for ELF, since for ELF,
 801      bfd_install_relocation uses the "special function" field of the
 802      howto, and does not execute the code that needs to be undone.  */
 803
 804   if (OUTPUT_FLAVOR == bfd_target_aout_flavour
 805       && fixP->fx_addsy && S_IS_WEAK (fixP->fx_addsy)
 806       && ! bfd_is_und_section (S_GET_SEGMENT (fixP->fx_addsy)))
 807     {
 808       relP->addend -= S_GET_VALUE (fixP->fx_addsy);
 809     }
 810
 811   relP->howto = bfd_reloc_type_lookup (stdoutput, code);
 812   if (! relP->howto)
 813     {
 814       const char *name;
 815
 816       name = S_GET_NAME (fixP->fx_addsy);
 817       if (name == NULL)
 818         name = _("<unknown>");
 819       as_fatal (_("Cannot generate relocation type for symbol %s, code %s"),
 820                 name, bfd_get_reloc_code_name (code));
 821     }
 822
 823   return relP;
 824 }
 825
 826 /* Decide from what point a pc-relative relocation is relative to,
 827    relative to the pc-relative fixup.  Er, relatively speaking.  */
 828 long
 829 md_pcrel_from (fixS *fixP)
 830 {
 831   valueT addr = fixP->fx_where + fixP->fx_frag->fr_address;
 832
 833   switch (fixP->fx_r_type)
 834     {
 835     case BFD_RELOC_32:
 836       return addr + 4;
 837     case BFD_RELOC_MOXIE_10_PCREL:
 838       /* Offset is from the end of the instruction.  */
 839       return addr + 2;
 840     default:
 841       abort ();
 842       return addr;
 843     }
 844 }