gas/config/tc-msp430.c

   1 /* tc-msp430.c -- Assembler code for the Texas Instruments MSP430
   2
   3   Copyright (C) 2002, 2003 Free Software Foundation, Inc.
   4   Contributed by Dmitry Diky <diwil@mail.ru>
   5
   6   This file is part of GAS, the GNU Assembler.
   7
   8   GAS is free software; you can redistribute it and/or modify
   9   it under the terms of the GNU General Public License as published by
  10   the Free Software Foundation; either version 2, or (at your option)
  11   any later version.
  12
  13   GAS is distributed in the hope that it will be useful,
  14   but WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16   GNU General Public License for more details.
  17
  18   You should have received a copy of the GNU General Public License
  19   along with GAS; see the file COPYING.  If not, write to
  20   the Free Software Foundation, 59 Temple Place - Suite 330,
  21   Boston, MA 02111-1307, USA.  */
  22
  23 #include <stdio.h>
  24 #include <string.h>
  25 #include <stdlib.h>
  26 #include <limits.h>
  27
  28 #define PUSH_1X_WORKAROUND
  29 #include "as.h"
  30 #include "subsegs.h"
  31 #include "opcode/msp430.h"
  32 #include "safe-ctype.h"
  33
  34 const char comment_chars[] = ";";
  35 const char line_comment_chars[] = "#";
  36 const char line_separator_chars[] = "";
  37 const char EXP_CHARS[] = "eE";
  38 const char FLT_CHARS[] = "dD";
  39
  40 /* Handle  long expressions.  */
  41 extern LITTLENUM_TYPE generic_bignum[];
  42
  43 static struct hash_control *msp430_hash;
  44
  45 static unsigned int msp430_operands
  46   PARAMS ((struct msp430_opcode_s *, char *));
  47 static int msp430_srcoperand
  48   PARAMS ((struct msp430_operand_s *, char *, int, int *));
  49 static int msp430_dstoperand
  50   PARAMS ((struct msp430_operand_s *, char *, int));
  51 static char *parse_exp
  52   PARAMS ((char *, expressionS *));
  53 static inline char *skip_space
  54   PARAMS ((char *));
  55 static int check_reg
  56   PARAMS ((char *));
  57 static void msp430_set_arch
  58   PARAMS ((int));
  59 static void show_mcu_list
  60   PARAMS ((FILE *));
  61 static void del_spaces
  62   PARAMS ((char *));
  63
  64 #define MAX_OP_LEN      64
  65
  66 struct mcu_type_s
  67 {
  68   char *name;
  69   int isa;
  70   int mach;
  71 };
  72
  73 #define MSP430_ISA_11   11
  74 #define MSP430_ISA_12   12
  75 #define MSP430_ISA_13   13
  76 #define MSP430_ISA_14   14
  77 #define MSP430_ISA_41   41
  78 #define MSP430_ISA_31   31
  79 #define MSP430_ISA_32   32
  80 #define MSP430_ISA_33   33
  81 #define MSP430_ISA_110  110
  82 #define MSP430_ISA_43   43
  83 #define MSP430_ISA_44   44
  84 #define MSP430_ISA_15   15
  85 #define MSP430_ISA_16   16
  86
  87 #define CHECK_RELOC_MSP430              ((imm_op || byte_op)?BFD_RELOC_MSP430_16_BYTE:BFD_RELOC_MSP430_16)
  88 #define CHECK_RELOC_MSP430_PCREL        ((imm_op || byte_op)?BFD_RELOC_MSP430_16_PCREL_BYTE:BFD_RELOC_MSP430_16_PCREL)
  89
  90 static struct mcu_type_s mcu_types[] =
  91 {
  92   {"msp1",       MSP430_ISA_11, bfd_mach_msp11},
  93   {"msp2",       MSP430_ISA_14, bfd_mach_msp14},
  94   {"msp430x110", MSP430_ISA_11, bfd_mach_msp11},
  95   {"msp430x112", MSP430_ISA_11, bfd_mach_msp11},
  96   {"msp430x122", MSP430_ISA_12, bfd_mach_msp12},
  97   {"msp430x122", MSP430_ISA_12, bfd_mach_msp12},
  98   {"msp430x1222",MSP430_ISA_12, bfd_mach_msp12},
  99   {"msp430x1122",MSP430_ISA_11, bfd_mach_msp110},
 100   {"msp430x1132",MSP430_ISA_11, bfd_mach_msp110},
 101   {"msp430x123", MSP430_ISA_12, bfd_mach_msp12},
 102   {"msp430x1232",MSP430_ISA_12, bfd_mach_msp12},
 103   {"msp430x133", MSP430_ISA_13, bfd_mach_msp13},
 104   {"msp430x135", MSP430_ISA_13, bfd_mach_msp13},
 105   {"msp430x147", MSP430_ISA_14, bfd_mach_msp14},
 106   {"msp430x148", MSP430_ISA_14, bfd_mach_msp14},
 107   {"msp430x149", MSP430_ISA_14, bfd_mach_msp14},
 108   {"msp430x412", MSP430_ISA_41, bfd_mach_msp41},
 109   {"msp430x413", MSP430_ISA_41, bfd_mach_msp41},
 110   {"msp430x311", MSP430_ISA_31, bfd_mach_msp31},
 111   {"msp430x312", MSP430_ISA_31, bfd_mach_msp31},
 112   {"msp430x313", MSP430_ISA_31, bfd_mach_msp31},
 113   {"msp430x314", MSP430_ISA_31, bfd_mach_msp31},
 114   {"msp430x315", MSP430_ISA_31, bfd_mach_msp31},
 115   {"msp430x323", MSP430_ISA_32, bfd_mach_msp32},
 116   {"msp430x325", MSP430_ISA_32, bfd_mach_msp32},
 117   {"msp430x336", MSP430_ISA_33, bfd_mach_msp33},
 118   {"msp430x337", MSP430_ISA_33, bfd_mach_msp33},
 119   {"msp430x1101",MSP430_ISA_110, bfd_mach_msp110},
 120   {"msp430x1111",MSP430_ISA_110, bfd_mach_msp110},
 121   {"msp430x1121",MSP430_ISA_110, bfd_mach_msp110},
 122   {"msp430x1331",MSP430_ISA_13, bfd_mach_msp13},
 123   {"msp430x1351",MSP430_ISA_13, bfd_mach_msp13},
 124   {"msp430x435", MSP430_ISA_43, bfd_mach_msp43},
 125   {"msp430x436", MSP430_ISA_43, bfd_mach_msp43},
 126   {"msp430x437", MSP430_ISA_43, bfd_mach_msp43},
 127   {"msp430x447", MSP430_ISA_44, bfd_mach_msp44},
 128   {"msp430x448", MSP430_ISA_44, bfd_mach_msp44},
 129   {"msp430x449", MSP430_ISA_44, bfd_mach_msp44},
 130   {"msp430x167", MSP430_ISA_16, bfd_mach_msp16},
 131   {"msp430x168", MSP430_ISA_16, bfd_mach_msp16},
 132   {"msp430x169", MSP430_ISA_16, bfd_mach_msp16},
 133   {"msp430x155", MSP430_ISA_15, bfd_mach_msp15},
 134   {"msp430x156", MSP430_ISA_15, bfd_mach_msp15},
 135   {"msp430x157", MSP430_ISA_15, bfd_mach_msp15},
 136
 137   {NULL, 0, 0}
 138 };
 139
 140
 141 static struct mcu_type_s default_mcu =
 142     { "msp430x11", MSP430_ISA_11, bfd_mach_msp11 };
 143
 144 static struct mcu_type_s *msp430_mcu = &default_mcu;
 145
 146 const pseudo_typeS md_pseudo_table[] =
 147 {
 148   {"arch", msp430_set_arch, 0},
 149   {NULL, NULL, 0}
 150 };
 151
 152 #define OPTION_MMCU 'm'
 153
 154 const char *md_shortopts = "m:";
 155
 156 struct option md_longopts[] =
 157 {
 158   {"mmcu", required_argument, NULL, OPTION_MMCU},
 159   {NULL, no_argument, NULL, 0}
 160 };
 161
 162 size_t md_longopts_size = sizeof (md_longopts);
 163
 164 static void
 165 show_mcu_list (stream)
 166      FILE *stream;
 167 {
 168   int i;
 169
 170   fprintf (stream, _("Known MCU names:\n"));
 171
 172   for (i = 0; mcu_types[i].name; i++)
 173     fprintf (stream, _("\t %s\n"), mcu_types[i].name);
 174
 175   fprintf (stream, "\n");
 176 }
 177
 178 void
 179 md_show_usage (stream)
 180      FILE *stream;
 181 {
 182   fprintf (stream,
 183            _("MSP430 options:\n"
 184              "  -mmcu=[msp430-name] select microcontroller type\n"
 185              "                  msp430x110  msp430x112\n"
 186              "                  msp430x1101 msp430x1111\n"
 187              "                  msp430x1121 msp430x1122 msp430x1132\n"
 188              "                  msp430x122  msp430x123\n"
 189              "                  msp430x1222 msp430x1232\n"
 190              "                  msp430x133  msp430x135\n"
 191              "                  msp430x1331 msp430x1351\n"
 192              "                  msp430x147  msp430x148  msp430x149\n"
 193              "                  msp430x155  msp430x156  msp430x157\n"
 194              "                  msp430x167  msp430x168  msp430x169\n"
 195              "                  msp430x311  msp430x312  msp430x313  msp430x314  msp430x315\n"
 196              "                  msp430x323  msp430x325\n"
 197              "                  msp430x336  msp430x337\n"
 198              "                  msp430x412  msp430x413\n"
 199              "                  msp430x435  msp430x436  msp430x437\n"
 200              "                  msp430x447  msp430x448  msp430x449\n"));
 201
 202   show_mcu_list (stream);
 203 }
 204
 205 static char *
 206 extract_word (char *from, char *to, int limit)
 207 {
 208   char *op_start;
 209   char *op_end;
 210   int size = 0;
 211
 212   /* Drop leading whitespace.  */
 213   from = skip_space (from);
 214   *to = 0;
 215
 216   /* Find the op code end.  */
 217   for (op_start = op_end = from; *op_end != 0 && is_part_of_name (*op_end);)
 218     {
 219       to[size++] = *op_end++;
 220       if (size + 1 >= limit)
 221         break;
 222     }
 223
 224   to[size] = 0;
 225   return op_end;
 226 }
 227
 228 static void
 229 msp430_set_arch (dummy)
 230      int dummy ATTRIBUTE_UNUSED;
 231 {
 232   char *str = (char *) alloca (32);     /* 32 for good measure.  */
 233
 234   input_line_pointer = extract_word (input_line_pointer, str, 32);
 235
 236   md_parse_option (OPTION_MMCU, str);
 237   bfd_set_arch_mach (stdoutput, TARGET_ARCH, msp430_mcu->mach);
 238 }
 239
 240 int
 241 md_parse_option (c, arg)
 242      int c;
 243      char *arg;
 244 {
 245   int i;
 246
 247   switch (c)
 248     {
 249     case OPTION_MMCU:
 250       for (i = 0; mcu_types[i].name; ++i)
 251         if (strcmp (mcu_types[i].name, arg) == 0)
 252           break;
 253
 254       if (!mcu_types[i].name)
 255         {
 256           show_mcu_list (stderr);
 257           as_fatal (_("unknown MCU: %s\n"), arg);
 258         }
 259
 260       if (msp430_mcu == &default_mcu || msp430_mcu->mach == mcu_types[i].mach)
 261         msp430_mcu = &mcu_types[i];
 262       else
 263         as_fatal (_("redefinition of mcu type %s' to %s'"),
 264                   msp430_mcu->name, mcu_types[i].name);
 265       return 1;
 266     }
 267
 268   return 0;
 269 }
 270
 271 symbolS *
 272 md_undefined_symbol (name)
 273      char *name ATTRIBUTE_UNUSED;
 274 {
 275   return 0;
 276 }
 277
 278 static inline char *
 279 skip_space (s)
 280      char *s;
 281 {
 282   while (ISSPACE (*s))
 283     ++s;
 284   return s;
 285 }
 286
 287 /* Delete spaces from s: X ( r 1  2)  => X(r12).  */
 288
 289 static void
 290 del_spaces (s)
 291      char *s;
 292 {
 293   while (*s)
 294     {
 295       if (ISSPACE (*s))
 296         {
 297           char *m = s + 1;
 298
 299           while (ISSPACE (*m) && *m)
 300             m++;
 301           memmove (s, m, strlen (m) + 1);
 302         }
 303       else
 304         s++;
 305     }
 306 }
 307
 308 /* Extract one word from FROM and copy it to TO. Delimeters are ",;\n"  */
 309
 310 static char *
 311 extract_operand (char *from, char *to, int limit)
 312 {
 313   int size = 0;
 314
 315   /* Drop leading whitespace.  */
 316   from = skip_space (from);
 317
 318   while (size < limit && *from)
 319     {
 320       *(to + size) = *from;
 321       if (*from == ',' || *from == ';' || *from == '\n')
 322         break;
 323       from++;
 324       size++;
 325     }
 326
 327   *(to + size) = 0;
 328   del_spaces (to);
 329
 330   from++;
 331
 332   return from;
 333 }
 334
 335 static char *
 336 extract_cmd (char *from, char *to, int limit)
 337 {
 338   int size = 0;
 339
 340   while (*from && ! ISSPACE (*from) && *from != '.' && limit > size)
 341     {
 342       *(to + size) = *from;
 343       from++;
 344       size++;
 345     }
 346
 347   *(to + size) = 0;
 348
 349   return from;
 350 }
 351
 352 /* Turn a string in input_line_pointer into a floating point constant
 353    of type TYPE, and store the appropriate bytes in *LITP.  The number
 354    of LITTLENUMS emitted is stored in *SIZEP.  An error message is
 355    returned, or NULL on OK.  */
 356
 357 char *
 358 md_atof (type, litP, sizeP)
 359      int type;
 360      char *litP;
 361      int *sizeP;
 362 {
 363   int prec;
 364   LITTLENUM_TYPE words[4];
 365   LITTLENUM_TYPE *wordP;
 366   char *t;
 367
 368   switch (type)
 369     {
 370     case 'f':
 371       prec = 2;
 372       break;
 373     case 'd':
 374       prec = 4;
 375       break;
 376     default:
 377       *sizeP = 0;
 378       return _("bad call to md_atof");
 379     }
 380
 381   t = atof_ieee (input_line_pointer, type, words);
 382   if (t)
 383     input_line_pointer = t;
 384
 385   *sizeP = prec * sizeof (LITTLENUM_TYPE);
 386
 387   /* This loop outputs the LITTLENUMs in REVERSE order.  */
 388   for (wordP = words + prec - 1; prec--;)
 389     {
 390       md_number_to_chars (litP, (valueT) (*wordP--), sizeof (LITTLENUM_TYPE));
 391       litP += sizeof (LITTLENUM_TYPE);
 392     }
 393
 394   return NULL;
 395 }
 396
 397 void
 398 md_convert_frag (abfd, sec, fragP)
 399      bfd *abfd ATTRIBUTE_UNUSED;
 400      asection *sec ATTRIBUTE_UNUSED;
 401      fragS *fragP ATTRIBUTE_UNUSED;
 402 {
 403   abort ();
 404 }
 405
 406 void
 407 md_begin ()
 408 {
 409   struct msp430_opcode_s *opcode;
 410   msp430_hash = hash_new ();
 411
 412   for (opcode = msp430_opcodes; opcode->name; opcode++)
 413     hash_insert (msp430_hash, opcode->name, (char *) opcode);
 414
 415   bfd_set_arch_mach (stdoutput, TARGET_ARCH, msp430_mcu->mach);
 416 }
 417
 418 void
 419 md_assemble (str)
 420      char *str;
 421 {
 422   struct msp430_opcode_s *opcode;
 423   char cmd[32];
 424   unsigned int i = 0;
 425
 426   str = skip_space (str);       /* Skip leading spaces.  */
 427   str = extract_cmd (str, cmd, sizeof (cmd));
 428
 429   while (cmd[i] && i < sizeof (cmd))
 430     {
 431       char a = TOLOWER (cmd[i]);
 432       cmd[i] = a;
 433       i++;
 434     }
 435
 436   if (!cmd[0])
 437     {
 438       as_bad (_("can't find opcode "));
 439       return;
 440     }
 441
 442   opcode = (struct msp430_opcode_s *) hash_find (msp430_hash, cmd);
 443
 444   if (opcode == NULL)
 445     {
 446       as_bad (_("unknown opcode `%s'"), cmd);
 447       return;
 448     }
 449
 450   {
 451     char *__t = input_line_pointer;
 452     msp430_operands (opcode, str);
 453     input_line_pointer = __t;
 454   }
 455 }
 456
 457 /* Parse instruction operands.
 458    Return binary opcode.  */
 459
 460 static unsigned int
 461 msp430_operands (opcode, line)
 462      struct msp430_opcode_s *opcode;
 463      char *line;
 464 {
 465   int bin = opcode->bin_opcode; /* opcode mask.  */
 466   int __is;
 467   char l1[MAX_OP_LEN], l2[MAX_OP_LEN];
 468   char *frag;
 469   int where;
 470   struct msp430_operand_s op1, op2;
 471   int res = 0;
 472   static short ZEROS = 0;
 473   int byte_op, imm_op;
 474
 475   /* opcode is the one from opcodes table
 476      line contains something like
 477      [.w] @r2+, 5(R1)
 478      or
 479      .b @r2+, 5(R1).  */
 480
 481   /* Check if byte or word operation.  */
 482   if (*line == '.' && TOLOWER (*(line + 1)) == 'b')
 483     {
 484       bin |= BYTE_OPERATION;
 485       byte_op = 1;
 486     }
 487   else
 488     byte_op = 0;
 489
 490   /* skip .[bwBW].  */
 491   while (! ISSPACE (*line) && *line)
 492     line++;
 493
 494   if (opcode->insn_opnumb && (!*line || *line == '\n'))
 495     {
 496       as_bad (_("instruction %s requires %d operand(s)"),
 497               opcode->name, opcode->insn_opnumb);
 498       return 0;
 499     }
 500
 501   memset (l1, 0, sizeof (l1));
 502   memset (l2, 0, sizeof (l2));
 503   memset (&op1, 0, sizeof (op1));
 504   memset (&op2, 0, sizeof (op2));
 505
 506   imm_op = 0;
 507
 508   switch (opcode->fmt)
 509     {
 510     case 0:                     /* Emulated.  */
 511       switch (opcode->insn_opnumb)
 512         {
 513         case 0:
 514           /* Set/clear bits instructions.  */
 515           __is = 2;
 516           frag = frag_more (__is);
 517           bfd_putl16 ((bfd_vma) bin, frag);
 518           break;
 519         case 1:
 520           /* Something which works with destination operand.  */
 521           line = extract_operand (line, l1, sizeof (l1));
 522           res = msp430_dstoperand (&op1, l1, opcode->bin_opcode);
 523           if (res)
 524             break;
 525
 526           bin |= (op1.reg | (op1.am << 7));
 527           __is = 1 + op1.ol;
 528           frag = frag_more (2 * __is);
 529           where = frag - frag_now->fr_literal;
 530           bfd_putl16 ((bfd_vma) bin, frag);
 531
 532           if (op1.mode == OP_EXP)
 533             {
 534               where += 2;
 535               bfd_putl16 ((bfd_vma) ZEROS, frag + 2);
 536
 537               if (op1.reg)
 538                 fix_new_exp (frag_now, where, 2,
 539                              &(op1.exp), FALSE, CHECK_RELOC_MSP430);
 540               else
 541                 fix_new_exp (frag_now, where, 2,
 542                              &(op1.exp), TRUE, CHECK_RELOC_MSP430_PCREL);
 543             }
 544           break;
 545
 546         case 2:
 547           {
 548             char l2[16];
 549
 550             /* Shift instruction.  */
 551             line = extract_operand (line, l1, sizeof (l1));
 552             strncpy (l2, l1, 16);
 553             res = msp430_srcoperand (&op1, l1, opcode->bin_opcode, &imm_op);
 554             res += msp430_dstoperand (&op2, l2, opcode->bin_opcode);
 555
 556             if (res)
 557               break;    /* An error occured.  All warnings were done before.  */
 558
 559             bin |= (op2.reg | (op1.reg << 8) | (op1.am << 4) | (op2.am << 7));
 560
 561             __is = 1 + op1.ol + op2.ol; /* insn size in words.  */
 562             frag = frag_more (2 * __is);
 563             where = frag - frag_now->fr_literal;
 564             bfd_putl16 ((bfd_vma) bin, frag);
 565
 566             if (op1.mode == OP_EXP)
 567               {
 568                 where += 2;     /* Advance 'where' as we do not know _where_.  */
 569                 bfd_putl16 ((bfd_vma) ZEROS, frag + 2);
 570
 571                 if (op1.reg || (op1.reg == 0 && op1.am == 3))   /* Not PC relative.  */
 572                   fix_new_exp (frag_now, where, 2,
 573                                &(op1.exp), FALSE, CHECK_RELOC_MSP430);
 574                 else
 575                   fix_new_exp (frag_now, where, 2,
 576                                &(op1.exp), TRUE, CHECK_RELOC_MSP430_PCREL);
 577               }
 578
 579             if (op2.mode == OP_EXP)
 580               {
 581                 imm_op = 0;
 582                 bfd_putl16 ((bfd_vma) ZEROS, frag + 2 + ((__is == 3) ? 2 : 0));
 583
 584                 if (op2.reg)    /* Not PC relative.  */
 585                   fix_new_exp (frag_now, where + 2, 2,
 586                                &(op2.exp), FALSE, CHECK_RELOC_MSP430);
 587                 else
 588                   fix_new_exp (frag_now, where + 2, 2,
 589                                &(op2.exp), TRUE, CHECK_RELOC_MSP430_PCREL);
 590               }
 591             break;
 592           }
 593         case 3:
 594           /* Branch instruction => mov dst, r0.  */
 595           line = extract_operand (line, l1, sizeof (l1));
 596
 597           res = msp430_srcoperand (&op1, l1, opcode->bin_opcode, &imm_op);
 598           if (res)
 599             break;
 600
 601           byte_op = 0;
 602           imm_op = 0;
 603
 604           bin |= ((op1.reg << 8) | (op1.am << 4));
 605           __is = 1 + op1.ol;
 606           frag = frag_more (2 * __is);
 607           where = frag - frag_now->fr_literal;
 608           bfd_putl16 ((bfd_vma) bin, frag);
 609
 610           if (op1.mode == OP_EXP)
 611             {
 612               where += 2;
 613               bfd_putl16 ((bfd_vma) ZEROS, frag + 2);
 614
 615               if (op1.reg || (op1.reg == 0 && op1.am == 3))
 616                 fix_new_exp (frag_now, where, 2,
 617                              &(op1.exp), FALSE, CHECK_RELOC_MSP430);
 618               else
 619                 fix_new_exp (frag_now, where, 2,
 620                              &(op1.exp), TRUE, CHECK_RELOC_MSP430_PCREL);
 621             }
 622           break;
 623         }
 624       break;
 625
 626     case 1:                     /* Format 1, double operand.  */
 627       line = extract_operand (line, l1, sizeof (l1));
 628       line = extract_operand (line, l2, sizeof (l2));
 629       res = msp430_srcoperand (&op1, l1, opcode->bin_opcode, &imm_op);
 630       res += msp430_dstoperand (&op2, l2, opcode->bin_opcode);
 631
 632       if (res)
 633         break;                  /* Error occured.  All warnings were done before.  */
 634
 635       bin |= (op2.reg | (op1.reg << 8) | (op1.am << 4) | (op2.am << 7));
 636
 637       __is = 1 + op1.ol + op2.ol;       /* insn size in words.  */
 638       frag = frag_more (2 * __is);
 639       where = frag - frag_now->fr_literal;
 640       bfd_putl16 ((bfd_vma) bin, frag);
 641
 642       if (op1.mode == OP_EXP)
 643         {
 644           where += 2;           /* Advance where as we do not know _where_.  */
 645           bfd_putl16 ((bfd_vma) ZEROS, frag + 2);
 646
 647           if (op1.reg || (op1.reg == 0 && op1.am == 3)) /* Not PC relative.  */
 648             fix_new_exp (frag_now, where, 2,
 649                          &(op1.exp), FALSE, CHECK_RELOC_MSP430);
 650           else
 651             fix_new_exp (frag_now, where, 2,
 652                          &(op1.exp), TRUE, CHECK_RELOC_MSP430_PCREL);
 653         }
 654
 655       if (op2.mode == OP_EXP)
 656         {
 657           imm_op = 0;
 658           bfd_putl16 ((bfd_vma) ZEROS, frag + 2 + ((__is == 3) ? 2 : 0));
 659
 660           if (op2.reg)          /* Not PC relative.  */
 661             fix_new_exp (frag_now, where + 2, 2,
 662                          &(op2.exp), FALSE, CHECK_RELOC_MSP430);
 663           else
 664             fix_new_exp (frag_now, where + 2, 2,
 665                          &(op2.exp), TRUE, CHECK_RELOC_MSP430_PCREL);
 666         }
 667       break;
 668
 669     case 2:                     /* Single-operand mostly instr.  */
 670       if (opcode->insn_opnumb == 0)
 671         {
 672           /* reti instruction.  */
 673           frag = frag_more (2);
 674           bfd_putl16 ((bfd_vma) bin, frag);
 675           break;
 676         }
 677
 678       line = extract_operand (line, l1, sizeof (l1));
 679       res = msp430_srcoperand (&op1, l1, opcode->bin_opcode, &imm_op);
 680       if (res)
 681         break;          /* Error in operand.  */
 682
 683       bin |= op1.reg | (op1.am << 4);
 684       __is = 1 + op1.ol;
 685       frag = frag_more (2 * __is);
 686       where = frag - frag_now->fr_literal;
 687       bfd_putl16 ((bfd_vma) bin, frag);
 688
 689       if (op1.mode == OP_EXP)
 690         {
 691           bfd_putl16 ((bfd_vma) ZEROS, frag + 2);
 692
 693           if (op1.reg || (op1.reg == 0 && op1.am == 3)) /* Not PC relative.  */
 694             fix_new_exp (frag_now, where + 2, 2,
 695                          &(op1.exp), FALSE, CHECK_RELOC_MSP430);
 696           else
 697             fix_new_exp (frag_now, where + 2, 2,
 698                          &(op1.exp), TRUE, CHECK_RELOC_MSP430_PCREL);
 699         }
 700       break;
 701
 702     case 3:                     /* Conditional jumps instructions.  */
 703       line = extract_operand (line, l1, sizeof (l1));
 704       /* l1 is a label.  */
 705       if (l1[0])
 706         {
 707           char *m = l1;
 708           expressionS exp;
 709
 710           if (*m == '$')
 711             m++;
 712
 713           parse_exp (m, &exp);
 714           frag = frag_more (2); /* Instr size is 1 word.  */
 715
 716           /* In order to handle something like:
 717
 718              and #0x8000, r5
 719              tst r5
 720              jz   4     ;       skip next 4 bytes
 721              inv r5
 722              inc r5
 723              nop        ;       will jump here if r5 positive or zero
 724
 725              jCOND      -n      ;assumes jump n bytes backward:
 726
 727              mov r5,r6
 728              jmp -2
 729
 730              is equial to:
 731              lab:
 732              mov r5,r6
 733              jmp lab
 734
 735              jCOND      $n      ; jump from PC in either direction.  */
 736
 737           if (exp.X_op == O_constant)
 738             {
 739               int x = exp.X_add_number;
 740
 741               if (x & 1)
 742                 {
 743                   as_warn (_("Even number required. Rounded to %d"), x + 1);
 744                   x++;
 745                 }
 746
 747               if ((*l1 == '$' && x > 0) || x < 0)
 748                 x -= 2;
 749
 750               x >>= 1;
 751
 752               if (x > 512 || x < -511)
 753                 {
 754                   as_bad (_("Wrong displacement  %d"), x << 1);
 755                   break;
 756                 }
 757
 758               bin |= x & 0x3ff;
 759               bfd_putl16 ((bfd_vma) bin, frag);
 760             }
 761           else if (exp.X_op == O_symbol && *l1 != '$')
 762             {
 763               where = frag - frag_now->fr_literal;
 764               fix_new_exp (frag_now, where, 2,
 765                            &exp, TRUE, BFD_RELOC_MSP430_10_PCREL);
 766
 767               bfd_putl16 ((bfd_vma) bin, frag);
 768             }
 769           else if (*l1 == '$')
 770             {
 771               as_bad (_("instruction requires label sans '$'"));
 772               break;
 773             }
 774           else
 775             {
 776               as_bad (_
 777                       ("instruction requires label or value in range -511:512"));
 778               break;
 779             }
 780         }
 781       else
 782         {
 783           as_bad (_("instruction requires label"));
 784           break;
 785         }
 786       break;
 787
 788     default:
 789       as_bad (_("Ilegal instruction or not implmented opcode."));
 790     }
 791
 792   input_line_pointer = line;
 793   return 0;
 794 }
 795
 796 static int
 797 msp430_dstoperand (op, l, bin)
 798      struct msp430_operand_s *op;
 799      char *l;
 800      int bin;
 801 {
 802   int dummy;
 803   int ret = msp430_srcoperand (op, l, bin, &dummy);
 804   if (ret)
 805     return ret;
 806
 807   if (op->am == 2)
 808     {
 809       char *__tl = "0";
 810
 811       op->mode = OP_EXP;
 812       op->am = 1;
 813       op->ol = 1;
 814       parse_exp (__tl, &(op->exp));
 815       if (op->exp.X_op != O_constant || op->exp.X_add_number != 0)
 816         {
 817           as_bad (_("Internal bug. Try to use 0(r%d) instead of @r%d"),
 818                   op->reg, op->reg);
 819           return 1;
 820         }
 821       return 0;
 822     }
 823
 824   if (op->am > 1)
 825     {
 826       as_bad (_
 827               ("this addressing mode is not applicable for destination operand"));
 828       return 1;
 829     }
 830   return 0;
 831 }
 832
 833
 834 static int
 835 check_reg (t)
 836      char *t;
 837 {
 838   /* If this is a reg numb, str 't' must be a number from 0 - 15.  */
 839
 840   if (strlen (t) > 2 && *(t + 2) != '+')
 841     return 1;
 842
 843   while (*t)
 844     {
 845       if ((*t < '0' || *t > '9') && *t != '+')
 846         break;
 847       t++;
 848     }
 849
 850   if (*t)
 851     return 1;
 852
 853   return 0;
 854 }
 855
 856
 857 static int
 858 msp430_srcoperand (op, l, bin, imm_op)
 859      struct msp430_operand_s *op;
 860      char *l;
 861      int bin;
 862      int *imm_op;
 863 {
 864   char *__tl = l;
 865
 866   /* Check if an immediate #VALUE.  The hash sign should be only at the beginning!  */
 867   if (*l == '#')
 868     {
 869       char *h = l;
 870       int vshift = -1;
 871       int rval = 0;
 872
 873       /* Check if there is:
 874          llo(x) - least significant 16 bits, x &= 0xffff
 875          lhi(x) - x = (x >> 16) & 0xffff,
 876          hlo(x) - x = (x >> 32) & 0xffff,
 877          hhi(x) - x = (x >> 48) & 0xffff
 878          The value _MUST_ be constant expression: #hlo(1231231231).  */
 879
 880       *imm_op = 1;
 881
 882       if (strncasecmp (h, "#llo(", 5) == 0)
 883         {
 884           vshift = 0;
 885           rval = 3;
 886         }
 887       else if (strncasecmp (h, "#lhi(", 5) == 0)
 888         {
 889           vshift = 1;
 890           rval = 3;
 891         }
 892       else if (strncasecmp (h, "#hlo(", 5) == 0)
 893         {
 894           vshift = 2;
 895           rval = 3;
 896         }
 897       else if (strncasecmp (h, "#hhi(", 5) == 0)
 898         {
 899           vshift = 3;
 900           rval = 3;
 901         }
 902       else if (strncasecmp (h, "#lo(", 4) == 0)
 903         {
 904           vshift = 0;
 905           rval = 2;
 906         }
 907       else if (strncasecmp (h, "#hi(", 4) == 0)
 908         {
 909           vshift = 1;
 910           rval = 2;
 911         }
 912
 913       op->reg = 0;              /* Reg PC.  */
 914       op->am = 3;
 915       op->ol = 1;               /* Immediate  will follow an instruction.  */
 916       __tl = h + 1 + rval;
 917       op->mode = OP_EXP;
 918       parse_exp (__tl, &(op->exp));
 919       if (op->exp.X_op == O_constant)
 920         {
 921           int x = op->exp.X_add_number;
 922
 923           if (vshift == 0)
 924             {
 925               x = x & 0xffff;
 926               op->exp.X_add_number = x;
 927             }
 928           else if (vshift == 1)
 929             {
 930               x = (x >> 16) & 0xffff;
 931               op->exp.X_add_number = x;
 932             }
 933           else if (vshift > 1)
 934             {
 935               if (x < 0)
 936                 op->exp.X_add_number = -1;
 937               else
 938                 op->exp.X_add_number = 0;       /* Nothing left.  */
 939               x = op->exp.X_add_number;
 940             }
 941
 942           if (op->exp.X_add_number > 65535 || op->exp.X_add_number < -32768)
 943             {
 944               as_bad (_("value %ld out of range. Use #lo() or #hi()"), x);
 945               return 1;
 946             }
 947
 948           /* Now check constants.  */
 949           /* Substitude register mode with a constant generator if applicable.  */
 950
 951           x = (short) x;        /* Extend sign.  */
 952
 953           if (x == 0)
 954             {
 955               op->reg = 3;
 956               op->am = 0;
 957               op->ol = 0;
 958               op->mode = OP_REG;
 959             }
 960           else if (x == 1)
 961             {
 962               op->reg = 3;
 963               op->am = 1;
 964               op->ol = 0;
 965               op->mode = OP_REG;
 966             }
 967           else if (x == 2)
 968             {
 969               op->reg = 3;
 970               op->am = 2;
 971               op->ol = 0;
 972               op->mode = OP_REG;
 973             }
 974           else if (x == -1)
 975             {
 976               op->reg = 3;
 977               op->am = 3;
 978               op->ol = 0;
 979               op->mode = OP_REG;
 980             }
 981           else if (x == 4)
 982             {
 983 #ifdef PUSH_1X_WORKAROUND
 984               if (bin == 0x1200)
 985                 {
 986                   /* Remove warning as confusing.
 987                      as_warn(_("Hardware push bug workaround")); */
 988                 }
 989               else
 990 #endif
 991                 {
 992                   op->reg = 2;
 993                   op->am = 2;
 994                   op->ol = 0;
 995                   op->mode = OP_REG;
 996                 }
 997             }
 998           else if (x == 8)
 999             {
1000 #ifdef PUSH_1X_WORKAROUND
1001               if (bin == 0x1200)
1002                 {
1003                   /* Remove warning as confusing.
1004                      as_warn(_("Hardware push bug workaround")); */
1005                 }
1006               else
1007 #endif
1008                 {
1009                   op->reg = 2;
1010                   op->am = 3;
1011                   op->ol = 0;
1012                   op->mode = OP_REG;
1013                 }
1014             }
1015         }
1016       else if (op->exp.X_op == O_symbol)
1017         {
1018           op->mode = OP_EXP;
1019         }
1020       else if (op->exp.X_op == O_big)
1021         {
1022           short x;
1023           if (vshift != -1)
1024             {
1025               op->exp.X_op = O_constant;
1026               op->exp.X_add_number = 0xffff & generic_bignum[vshift];
1027               x = op->exp.X_add_number;
1028             }
1029           else
1030             {
1031               as_bad (_
1032                       ("unknown expression in operand %s. use #llo() #lhi() #hlo() #hhi() "),
1033                       l);
1034               return 1;
1035             }
1036
1037           if (x == 0)
1038             {
1039               op->reg = 3;
1040               op->am = 0;
1041               op->ol = 0;
1042               op->mode = OP_REG;
1043             }
1044           else if (x == 1)
1045             {
1046               op->reg = 3;
1047               op->am = 1;
1048               op->ol = 0;
1049               op->mode = OP_REG;
1050             }
1051           else if (x == 2)
1052             {
1053               op->reg = 3;
1054               op->am = 2;
1055               op->ol = 0;
1056               op->mode = OP_REG;
1057             }
1058           else if (x == -1)
1059             {
1060               op->reg = 3;
1061               op->am = 3;
1062               op->ol = 0;
1063               op->mode = OP_REG;
1064             }
1065           else if (x == 4)
1066             {
1067               op->reg = 2;
1068               op->am = 2;
1069               op->ol = 0;
1070               op->mode = OP_REG;
1071             }
1072           else if (x == 8)
1073             {
1074               op->reg = 2;
1075               op->am = 3;
1076               op->ol = 0;
1077               op->mode = OP_REG;
1078             }
1079         }
1080       else
1081         {
1082           as_bad (_("unknown operand %s"), l);
1083         }
1084       return 0;
1085     }
1086
1087   /* Check if absolute &VALUE (assume that we can construct something like ((a&b)<<7 + 25).  */
1088   if (*l == '&')
1089     {
1090       char *h = l;
1091
1092       op->reg = 2;              /* reg 2 in absolute addr mode.  */
1093       op->am = 1;               /* mode As == 01 bin.  */
1094       op->ol = 1;               /* Immediate value followed by instruction.  */
1095       __tl = h + 1;
1096       parse_exp (__tl, &(op->exp));
1097       op->mode = OP_EXP;
1098       if (op->exp.X_op == O_constant)
1099         {
1100           int x = op->exp.X_add_number;
1101           if (x > 65535 || x < -32768)
1102             {
1103               as_bad (_("value out of range: %d"), x);
1104               return 1;
1105             }
1106         }
1107       else if (op->exp.X_op == O_symbol)
1108         {
1109         }
1110       else
1111         {
1112           as_bad (_("unknown expression in operand %s"), l);
1113           return 1;
1114         }
1115       return 0;
1116     }
1117
1118   /* Check if inderect register mode @Rn / postincrement @Rn+.  */
1119   if (*l == '@')
1120     {
1121       char *t = l;
1122       char *m = strchr (l, '+');
1123
1124       if (t != l)
1125         {
1126           as_bad (_("unknown addressing mode %s"), l);
1127           return 1;
1128         }
1129
1130       t++;
1131       if (*t != 'r' && *t != 'R')
1132         {
1133           as_bad (_("unknown addressing mode %s"), l);
1134           return 1;
1135         }
1136
1137       t++;      /* Points to the reg value.  */
1138
1139       if (check_reg (t))
1140         {
1141           as_bad (_("Bad register name r%s"), t);
1142           return 1;
1143         }
1144
1145       op->mode = OP_REG;
1146       op->am = m ? 3 : 2;
1147       op->ol = 0;
1148       if (m)
1149         *m = 0;                 /* strip '+' */
1150       op->reg = atoi (t);
1151       if (op->reg < 0 || op->reg > 15)
1152         {
1153           as_bad (_("MSP430 does not have %d registers"), op->reg);
1154           return 1;
1155         }
1156
1157       return 0;
1158     }
1159
1160   /* Check if register indexed X(Rn).  */
1161   do
1162     {
1163       char *h = strrchr (l, '(');
1164       char *m = strrchr (l, ')');
1165       char *t;
1166
1167       *imm_op = 1;
1168
1169       if (!h)
1170         break;
1171       if (!m)
1172         {
1173           as_bad (_("')' required"));
1174           return 1;
1175         }
1176
1177       t = h;
1178       op->am = 1;
1179       op->ol = 1;
1180       /* Extract a register.  */
1181       t++;      /* Advance pointer.  */
1182
1183       if (*t != 'r' && *t != 'R')
1184         {
1185           as_bad (_
1186                   ("unknown operator %s. Did you mean X(Rn) or #[hl][hl][oi](CONST) ?"),
1187                   l);
1188           return 1;
1189         }
1190       t++;
1191
1192       op->reg = *t - '0';
1193       if (op->reg > 9 || op->reg < 0)
1194         {
1195           as_bad (_("unknown operator (r%s substituded as a register name"),
1196                   t);
1197           return 1;
1198         }
1199       t++;
1200       if (*t != ')')
1201         {
1202           op->reg = op->reg * 10;
1203           op->reg += *t - '0';
1204
1205           if (op->reg > 15)
1206             {
1207               as_bad (_("unknown operator %s"), l);
1208               return 1;
1209             }
1210           if (op->reg == 2)
1211             {
1212               as_bad (_("r2 should not be used in indexed addressing mode"));
1213               return 1;
1214             }
1215
1216           if (*(t + 1) != ')')
1217             {
1218               as_bad (_("unknown operator %s"), l);
1219               return 1;
1220             }
1221         }
1222
1223       /* Extract constant.  */
1224       __tl = l;
1225       *h = 0;
1226       op->mode = OP_EXP;
1227       parse_exp (__tl, &(op->exp));
1228       if (op->exp.X_op == O_constant)
1229         {
1230           int x = op->exp.X_add_number;
1231
1232           if (x > 65535 || x < -32768)
1233             {
1234               as_bad (_("value out of range: %d"), x);
1235               return 1;
1236             }
1237
1238           if (x == 0)
1239             {
1240               op->mode = OP_REG;
1241               op->am = 2;
1242               op->ol = 0;
1243               return 0;
1244             }
1245         }
1246       else if (op->exp.X_op == O_symbol)
1247         {
1248         }
1249       else
1250         {
1251           as_bad (_("unknown expression in operand %s"), l);
1252           return 1;
1253         }
1254
1255       return 0;
1256     }
1257   while (0);
1258
1259   /* Register mode 'mov r1,r2'.  */
1260   do
1261     {
1262       char *t = l;
1263
1264       /* Operand should be a register.  */
1265       if (*t == 'r' || *t == 'R')
1266         {
1267           int x = atoi (t + 1);
1268
1269           if (check_reg (t + 1))
1270             break;
1271
1272           if (x < 0 || x > 15)
1273             break;              /* Symbolic mode.  */
1274
1275           op->mode = OP_REG;
1276           op->am = 0;
1277           op->ol = 0;
1278           op->reg = x;
1279           return 0;
1280         }
1281     }
1282   while (0);
1283
1284   /* Symbolic mode 'mov a, b' == 'mov x(pc), y(pc)'.  */
1285   do
1286     {
1287       char *t = l;
1288
1289       __tl = l;
1290
1291       while (*t)
1292         {
1293           /* alpha/number    underline     dot for labels.  */
1294           if (! ISALNUM (*t) && *t != '_' && *t != '.')
1295             {
1296               as_bad (_("unknown operand %s"), l);
1297               return 1;
1298             }
1299           t++;
1300         }
1301
1302       op->mode = OP_EXP;
1303       op->reg = 0;              /* PC relative... be careful.  */
1304       op->am = 1;
1305       op->ol = 1;
1306       __tl = l;
1307       parse_exp (__tl, &(op->exp));
1308       return 0;
1309     }
1310   while (0);
1311
1312   /* Unreachable.  */
1313   as_bad (_("unknown addressing mode for operand %s"), l);
1314   return 1;
1315 }
1316
1317
1318 /* GAS will call this function for each section at the end of the assembly,
1319    to permit the CPU backend to adjust the alignment of a section.  */
1320
1321 valueT
1322 md_section_align (seg, addr)
1323      asection *seg;
1324      valueT addr;
1325 {
1326   int align = bfd_get_section_alignment (stdoutput, seg);
1327
1328   return ((addr + (1 << align) - 1) & (-1 << align));
1329 }
1330
1331 /* If you define this macro, it should return the offset between the
1332    address of a PC relative fixup and the position from which the PC
1333    relative adjustment should be made.  On many processors, the base
1334    of a PC relative instruction is the next instruction, so this
1335    macro would return the length of an instruction.  */
1336
1337 long
1338 md_pcrel_from_section (fixp, sec)
1339      fixS *fixp;
1340      segT sec;
1341 {
1342   if (fixp->fx_addsy != (symbolS *) NULL
1343       && (!S_IS_DEFINED (fixp->fx_addsy)
1344           || (S_GET_SEGMENT (fixp->fx_addsy) != sec)))
1345     return 0;
1346
1347   return fixp->fx_frag->fr_address + fixp->fx_where;
1348 }
1349
1350 /* GAS will call this for each fixup.  It should store the correct
1351    value in the object file.  */
1352
1353 void
1354 md_apply_fix3 (fixp, valuep, seg)
1355      fixS *fixp;
1356      valueT *valuep;
1357      segT seg;
1358 {
1359   unsigned char *where;
1360   unsigned long insn;
1361   long value;
1362
1363   if (fixp->fx_addsy == (symbolS *) NULL)
1364     {
1365       value = *valuep;
1366       fixp->fx_done = 1;
1367     }
1368   else if (fixp->fx_pcrel)
1369     {
1370       segT s = S_GET_SEGMENT (fixp->fx_addsy);
1371
1372       if (fixp->fx_addsy && (s == seg || s == absolute_section))
1373         {
1374           value = S_GET_VALUE (fixp->fx_addsy) + *valuep;
1375           fixp->fx_done = 1;
1376         }
1377       else
1378         value = *valuep;
1379     }
1380   else
1381     {
1382       value = fixp->fx_offset;
1383
1384       if (fixp->fx_subsy != (symbolS *) NULL)
1385         {
1386           if (S_GET_SEGMENT (fixp->fx_subsy) == absolute_section)
1387             {
1388               value -= S_GET_VALUE (fixp->fx_subsy);
1389               fixp->fx_done = 1;
1390             }
1391           else
1392             {
1393               /* We don't actually support subtracting a symbol.  */
1394               as_bad_where (fixp->fx_file, fixp->fx_line,
1395                             _("expression too complex"));
1396             }
1397         }
1398     }
1399
1400   switch (fixp->fx_r_type)
1401     {
1402     default:
1403       fixp->fx_no_overflow = 1;
1404       break;
1405     case BFD_RELOC_MSP430_10_PCREL:
1406       break;
1407     }
1408
1409   if (fixp->fx_done)
1410     {
1411       /* Fetch the instruction, insert the fully resolved operand
1412          value, and stuff the instruction back again.  */
1413
1414       where = fixp->fx_frag->fr_literal + fixp->fx_where;
1415
1416       insn = bfd_getl16 (where);
1417
1418       switch (fixp->fx_r_type)
1419         {
1420         case BFD_RELOC_MSP430_10_PCREL:
1421           if (value & 1)
1422             as_bad_where (fixp->fx_file, fixp->fx_line,
1423                           _("odd address operand: %ld"), value);
1424
1425           /* Jumps are in words.  */
1426           value >>= 1;
1427           --value;              /* Correct PC.  */
1428
1429           if (value < -512 || value > 511)
1430             as_bad_where (fixp->fx_file, fixp->fx_line,
1431                           _("operand out of range: %ld"), value);
1432
1433           value &= 0x3ff;       /* get rid of extended sign */
1434           bfd_putl16 ((bfd_vma) (value | insn), where);
1435           break;
1436
1437         case BFD_RELOC_MSP430_16_PCREL:
1438           if (value & 1)
1439             as_bad_where (fixp->fx_file, fixp->fx_line,
1440                           _("odd address operand: %ld"), value);
1441
1442           /* Nothing to be corrected here.  */
1443           if (value < -32768 || value > 65536)
1444             as_bad_where (fixp->fx_file, fixp->fx_line,
1445                           _("operand out of range: %ld"), value);
1446
1447           value &= 0xffff;      /* Get rid of extended sign.  */
1448           bfd_putl16 ((bfd_vma) value, where);
1449           break;
1450
1451         case BFD_RELOC_MSP430_16_PCREL_BYTE:
1452           /* Nothing to be corrected here.  */
1453           if (value < -32768 || value > 65536)
1454             as_bad_where (fixp->fx_file, fixp->fx_line,
1455                           _("operand out of range: %ld"), value);
1456
1457           value &= 0xffff;      /* Get rid of extended sign.  */
1458           bfd_putl16 ((bfd_vma) value, where);
1459           break;
1460
1461         case BFD_RELOC_32:
1462           bfd_putl16 ((bfd_vma) value, where);
1463           break;
1464
1465         case BFD_RELOC_MSP430_16:
1466         case BFD_RELOC_16:
1467         case BFD_RELOC_MSP430_16_BYTE:
1468           value &= 0xffff;
1469           bfd_putl16 ((bfd_vma) value, where);
1470           break;
1471
1472         default:
1473           as_fatal (_("line %d: unknown relocation type: 0x%x"),
1474                     fixp->fx_line, fixp->fx_r_type);
1475           break;
1476         }
1477     }
1478   else
1479     {
1480       fixp->fx_addnumber = value;
1481     }
1482   return;
1483 }
1484
1485 /* A `BFD_ASSEMBLER' GAS will call this to generate a reloc.  GAS
1486    will pass the resulting reloc to `bfd_install_relocation'.  This
1487    currently works poorly, as `bfd_install_relocation' often does the
1488    wrong thing, and instances of `tc_gen_reloc' have been written to
1489    work around the problems, which in turns makes it difficult to fix
1490    `bfd_install_relocation'.  */
1491
1492 /* If while processing a fixup, a reloc really needs to be created
1493    then it is done here.  */
1494
1495 arelent *
1496 tc_gen_reloc (seg, fixp)
1497      asection *seg ATTRIBUTE_UNUSED;
1498      fixS *fixp;
1499 {
1500   arelent *reloc;
1501
1502   reloc = (arelent *) xmalloc (sizeof (arelent));
1503
1504   reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
1505   *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
1506
1507   reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
1508   reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
1509   if (reloc->howto == (reloc_howto_type *) NULL)
1510     {
1511       as_bad_where (fixp->fx_file, fixp->fx_line,
1512                     _("reloc %d not supported by object file format"),
1513                     (int) fixp->fx_r_type);
1514       return NULL;
1515     }
1516
1517   if (fixp->fx_r_type == BFD_RELOC_VTABLE_INHERIT
1518       || fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
1519     reloc->address = fixp->fx_offset;
1520
1521   reloc->addend = fixp->fx_offset;
1522
1523   return reloc;
1524 }
1525
1526 /* Parse ordinary expression.  */
1527
1528 static char *
1529 parse_exp (s, op)
1530      char *s;
1531      expressionS *op;
1532 {
1533   input_line_pointer = s;
1534   expression (op);
1535   if (op->X_op == O_absent)
1536     as_bad (_("missing operand"));
1537   return input_line_pointer;
1538 }
1539
1540
1541 int
1542 md_estimate_size_before_relax (fragp, seg)
1543      fragS *fragp ATTRIBUTE_UNUSED;
1544      asection *seg ATTRIBUTE_UNUSED;
1545 {
1546   abort ();
1547   return 0;
1548 }