gas/config/tc-v850.c

   1 /* tc-v850.c -- Assembler code for the NEC V850
   2    Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
   3    Free Software Foundation, Inc.
   4
   5    This file is part of GAS, the GNU Assembler.
   6
   7    GAS is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2, or (at your option)
  10    any later version.
  11
  12    GAS is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with GAS; see the file COPYING.  If not, write to
  19    the Free Software Foundation, 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #include <stdio.h>
  23 #include "as.h"
  24 #include "safe-ctype.h"
  25 #include "subsegs.h"
  26 #include "opcode/v850.h"
  27 #include "dwarf2dbg.h"
  28
  29 /* Sign-extend a 16-bit number.  */
  30 #define SEXT16(x)       ((((x) & 0xffff) ^ (~0x7fff)) + 0x8000)
  31
  32 /* Temporarily holds the reloc in a cons expression.  */
  33 static bfd_reloc_code_real_type hold_cons_reloc = BFD_RELOC_UNUSED;
  34
  35 /* Set to TRUE if we want to be pedantic about signed overflows.  */
  36 static bfd_boolean warn_signed_overflows   = FALSE;
  37 static bfd_boolean warn_unsigned_overflows = FALSE;
  38
  39 /* Indicates the target BFD machine number.  */
  40 static int machine = -1;
  41
  42 /* Indicates the target processor(s) for the assemble.  */
  43 static int processor_mask = -1;
  44 \f
  45 /* Structure to hold information about predefined registers.  */
  46 struct reg_name {
  47   const char *name;
  48   int value;
  49 };
  50
  51 /* Generic assembler global variables which must be defined by all
  52    targets.  */
  53
  54 /* Characters which always start a comment.  */
  55 const char comment_chars[] = "#";
  56
  57 /* Characters which start a comment at the beginning of a line.  */
  58 const char line_comment_chars[] = ";#";
  59
  60 /* Characters which may be used to separate multiple commands on a
  61    single line.  */
  62 const char line_separator_chars[] = ";";
  63
  64 /* Characters which are used to indicate an exponent in a floating
  65    point number.  */
  66 const char EXP_CHARS[] = "eE";
  67
  68 /* Characters which mean that a number is a floating point constant,
  69    as in 0d1.0.  */
  70 const char FLT_CHARS[] = "dD";
  71 \f
  72 const relax_typeS md_relax_table[] = {
  73   /* Conditional branches.  */
  74   {0xff,     -0x100,    2, 1},
  75   {0x1fffff, -0x200000, 6, 0},
  76   /* Unconditional branches.  */
  77   {0xff,     -0x100,    2, 3},
  78   {0x1fffff, -0x200000, 4, 0},
  79 };
  80
  81 static int  v850_relax = 0;
  82
  83 /* Fixups.  */
  84 #define MAX_INSN_FIXUPS (5)
  85 struct v850_fixup {
  86   expressionS exp;
  87   int opindex;
  88   bfd_reloc_code_real_type reloc;
  89 };
  90
  91 struct v850_fixup fixups[MAX_INSN_FIXUPS];
  92 static int fc;
  93
  94 struct v850_seg_entry
  95 {
  96   segT s;
  97   const char *name;
  98   flagword flags;
  99 };
 100
 101 struct v850_seg_entry v850_seg_table[] =
 102 {
 103   { NULL, ".sdata",
 104     SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_DATA | SEC_HAS_CONTENTS
 105     | SEC_SMALL_DATA },
 106   { NULL, ".tdata",
 107     SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_DATA | SEC_HAS_CONTENTS },
 108   { NULL, ".zdata",
 109     SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_DATA | SEC_HAS_CONTENTS },
 110   { NULL, ".sbss",
 111     SEC_ALLOC | SEC_SMALL_DATA },
 112   { NULL, ".tbss",
 113     SEC_ALLOC },
 114   { NULL, ".zbss",
 115     SEC_ALLOC},
 116   { NULL, ".rosdata",
 117     SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_READONLY | SEC_DATA
 118     | SEC_HAS_CONTENTS | SEC_SMALL_DATA },
 119   { NULL, ".rozdata",
 120     SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_READONLY | SEC_DATA
 121     | SEC_HAS_CONTENTS },
 122   { NULL, ".scommon",
 123     SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_DATA | SEC_HAS_CONTENTS
 124     | SEC_SMALL_DATA | SEC_IS_COMMON },
 125   { NULL, ".tcommon",
 126     SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_DATA | SEC_HAS_CONTENTS
 127     | SEC_IS_COMMON },
 128   { NULL, ".zcommon",
 129     SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_DATA | SEC_HAS_CONTENTS
 130     | SEC_IS_COMMON },
 131   { NULL, ".call_table_data",
 132     SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_DATA | SEC_HAS_CONTENTS },
 133   { NULL, ".call_table_text",
 134     SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_READONLY | SEC_CODE
 135     | SEC_HAS_CONTENTS},
 136   { NULL, ".bss",
 137     SEC_ALLOC }
 138 };
 139
 140 #define SDATA_SECTION           0
 141 #define TDATA_SECTION           1
 142 #define ZDATA_SECTION           2
 143 #define SBSS_SECTION            3
 144 #define TBSS_SECTION            4
 145 #define ZBSS_SECTION            5
 146 #define ROSDATA_SECTION         6
 147 #define ROZDATA_SECTION         7
 148 #define SCOMMON_SECTION         8
 149 #define TCOMMON_SECTION         9
 150 #define ZCOMMON_SECTION         10
 151 #define CALL_TABLE_DATA_SECTION 11
 152 #define CALL_TABLE_TEXT_SECTION 12
 153 #define BSS_SECTION             13
 154
 155 static void do_v850_seg PARAMS ((int, subsegT));
 156
 157 static void
 158 do_v850_seg (i, sub)
 159      int i;
 160      subsegT sub;
 161 {
 162   struct v850_seg_entry *seg = v850_seg_table + i;
 163
 164   obj_elf_section_change_hook ();
 165   if (seg->s != NULL)
 166     {
 167       subseg_set (seg->s, sub);
 168     }
 169   else
 170     {
 171       seg->s = subseg_new (seg->name, sub);
 172       bfd_set_section_flags (stdoutput, seg->s, seg->flags);
 173       if ((seg->flags & SEC_LOAD) == 0)
 174         seg_info (seg->s)->bss = 1;
 175     }
 176 }
 177
 178 static void v850_seg PARAMS ((int i));
 179
 180 static void
 181 v850_seg (i)
 182      int i;
 183 {
 184   subsegT sub = get_absolute_expression ();
 185
 186   do_v850_seg (i, sub);
 187   demand_empty_rest_of_line ();
 188 }
 189
 190 static void v850_offset PARAMS ((int));
 191
 192 static void
 193 v850_offset (ignore)
 194      int ignore ATTRIBUTE_UNUSED;
 195 {
 196   char *pfrag;
 197   int temp = get_absolute_expression ();
 198
 199   pfrag = frag_var (rs_org, 1, 1, (relax_substateT)0, (symbolS *)0,
 200                     (offsetT) temp, (char *) 0);
 201   *pfrag = 0;
 202
 203   demand_empty_rest_of_line ();
 204 }
 205
 206 /* Copied from obj_elf_common() in gas/config/obj-elf.c.  */
 207
 208 static void v850_comm PARAMS ((int));
 209
 210 static void
 211 v850_comm (area)
 212      int area;
 213 {
 214   char *name;
 215   char c;
 216   char *p;
 217   int temp;
 218   unsigned int size;
 219   symbolS *symbolP;
 220   int have_align;
 221
 222   name = input_line_pointer;
 223   c = get_symbol_end ();
 224
 225   /* Just after name is now '\0'.  */
 226   p = input_line_pointer;
 227   *p = c;
 228
 229   SKIP_WHITESPACE ();
 230
 231   if (*input_line_pointer != ',')
 232     {
 233       as_bad (_("Expected comma after symbol-name"));
 234       ignore_rest_of_line ();
 235       return;
 236     }
 237
 238   /* Skip ','.  */
 239   input_line_pointer++;
 240
 241   if ((temp = get_absolute_expression ()) < 0)
 242     {
 243       /* xgettext:c-format  */
 244       as_bad (_(".COMMon length (%d.) < 0! Ignored."), temp);
 245       ignore_rest_of_line ();
 246       return;
 247     }
 248
 249   size = temp;
 250   *p = 0;
 251   symbolP = symbol_find_or_make (name);
 252   *p = c;
 253
 254   if (S_IS_DEFINED (symbolP) && ! S_IS_COMMON (symbolP))
 255     {
 256       as_bad (_("Ignoring attempt to re-define symbol"));
 257       ignore_rest_of_line ();
 258       return;
 259     }
 260
 261   if (S_GET_VALUE (symbolP) != 0)
 262     {
 263       if (S_GET_VALUE (symbolP) != size)
 264         {
 265           /* xgettext:c-format  */
 266           as_warn (_("Length of .comm \"%s\" is already %ld. Not changed to %d."),
 267                    S_GET_NAME (symbolP), (long) S_GET_VALUE (symbolP), size);
 268         }
 269     }
 270
 271   know (symbol_get_frag (symbolP) == &zero_address_frag);
 272
 273   if (*input_line_pointer != ',')
 274     have_align = 0;
 275   else
 276     {
 277       have_align = 1;
 278       input_line_pointer++;
 279       SKIP_WHITESPACE ();
 280     }
 281
 282   if (! have_align || *input_line_pointer != '"')
 283     {
 284       if (! have_align)
 285         temp = 0;
 286       else
 287         {
 288           temp = get_absolute_expression ();
 289
 290           if (temp < 0)
 291             {
 292               temp = 0;
 293               as_warn (_("Common alignment negative; 0 assumed"));
 294             }
 295         }
 296
 297       if (symbol_get_obj (symbolP)->local)
 298         {
 299           segT old_sec;
 300           int old_subsec;
 301           char *pfrag;
 302           int align;
 303           flagword applicable;
 304
 305           old_sec = now_seg;
 306           old_subsec = now_subseg;
 307
 308           applicable = bfd_applicable_section_flags (stdoutput);
 309
 310           applicable &= SEC_ALLOC;
 311
 312           switch (area)
 313             {
 314             case SCOMMON_SECTION:
 315               do_v850_seg (SBSS_SECTION, 0);
 316               break;
 317
 318             case ZCOMMON_SECTION:
 319               do_v850_seg (ZBSS_SECTION, 0);
 320               break;
 321
 322             case TCOMMON_SECTION:
 323               do_v850_seg (TBSS_SECTION, 0);
 324               break;
 325             }
 326
 327           if (temp)
 328             {
 329               /* Convert to a power of 2 alignment.  */
 330               for (align = 0; (temp & 1) == 0; temp >>= 1, ++align)
 331                 ;
 332
 333               if (temp != 1)
 334                 {
 335                   as_bad (_("Common alignment not a power of 2"));
 336                   ignore_rest_of_line ();
 337                   return;
 338                 }
 339             }
 340           else
 341             align = 0;
 342
 343           record_alignment (now_seg, align);
 344
 345           if (align)
 346             frag_align (align, 0, 0);
 347
 348           switch (area)
 349             {
 350             case SCOMMON_SECTION:
 351               if (S_GET_SEGMENT (symbolP) == v850_seg_table[SBSS_SECTION].s)
 352                 symbol_get_frag (symbolP)->fr_symbol = 0;
 353               break;
 354
 355             case ZCOMMON_SECTION:
 356               if (S_GET_SEGMENT (symbolP) == v850_seg_table[ZBSS_SECTION].s)
 357                 symbol_get_frag (symbolP)->fr_symbol = 0;
 358               break;
 359
 360             case TCOMMON_SECTION:
 361               if (S_GET_SEGMENT (symbolP) == v850_seg_table[TBSS_SECTION].s)
 362                 symbol_get_frag (symbolP)->fr_symbol = 0;
 363               break;
 364
 365             default:
 366               abort ();
 367             }
 368
 369           symbol_set_frag (symbolP, frag_now);
 370           pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP,
 371                             (offsetT) size, (char *) 0);
 372           *pfrag = 0;
 373           S_SET_SIZE (symbolP, size);
 374
 375           switch (area)
 376             {
 377             case SCOMMON_SECTION:
 378               S_SET_SEGMENT (symbolP, v850_seg_table[SBSS_SECTION].s);
 379               break;
 380
 381             case ZCOMMON_SECTION:
 382               S_SET_SEGMENT (symbolP, v850_seg_table[ZBSS_SECTION].s);
 383               break;
 384
 385             case TCOMMON_SECTION:
 386               S_SET_SEGMENT (symbolP, v850_seg_table[TBSS_SECTION].s);
 387               break;
 388
 389             default:
 390               abort ();
 391             }
 392
 393           S_CLEAR_EXTERNAL (symbolP);
 394           obj_elf_section_change_hook ();
 395           subseg_set (old_sec, old_subsec);
 396         }
 397       else
 398         {
 399           segT   old_sec;
 400           int    old_subsec;
 401
 402         allocate_common:
 403           old_sec = now_seg;
 404           old_subsec = now_subseg;
 405
 406           S_SET_VALUE (symbolP, (valueT) size);
 407           S_SET_ALIGN (symbolP, temp);
 408           S_SET_EXTERNAL (symbolP);
 409
 410           switch (area)
 411             {
 412             case SCOMMON_SECTION:
 413             case ZCOMMON_SECTION:
 414             case TCOMMON_SECTION:
 415               do_v850_seg (area, 0);
 416               S_SET_SEGMENT (symbolP, v850_seg_table[area].s);
 417               break;
 418
 419             default:
 420               abort ();
 421             }
 422
 423           obj_elf_section_change_hook ();
 424           subseg_set (old_sec, old_subsec);
 425         }
 426     }
 427   else
 428     {
 429       input_line_pointer++;
 430
 431       /* @@ Some use the dot, some don't.  Can we get some consistency??  */
 432       if (*input_line_pointer == '.')
 433         input_line_pointer++;
 434
 435       /* @@ Some say data, some say bss.  */
 436       if (strncmp (input_line_pointer, "bss\"", 4)
 437           && strncmp (input_line_pointer, "data\"", 5))
 438         {
 439           while (*--input_line_pointer != '"')
 440             ;
 441           input_line_pointer--;
 442           goto bad_common_segment;
 443         }
 444       while (*input_line_pointer++ != '"')
 445         ;
 446       goto allocate_common;
 447     }
 448
 449   symbol_get_bfdsym (symbolP)->flags |= BSF_OBJECT;
 450
 451   demand_empty_rest_of_line ();
 452   return;
 453
 454   {
 455   bad_common_segment:
 456     p = input_line_pointer;
 457     while (*p && *p != '\n')
 458       p++;
 459     c = *p;
 460     *p = '\0';
 461     as_bad (_("bad .common segment %s"), input_line_pointer + 1);
 462     *p = c;
 463     input_line_pointer = p;
 464     ignore_rest_of_line ();
 465     return;
 466   }
 467 }
 468
 469 static void set_machine PARAMS ((int));
 470
 471 static void
 472 set_machine (number)
 473      int number;
 474 {
 475   machine = number;
 476   bfd_set_arch_mach (stdoutput, TARGET_ARCH, machine);
 477
 478   switch (machine)
 479     {
 480     case 0:               processor_mask = PROCESSOR_V850;   break;
 481     case bfd_mach_v850e:  processor_mask = PROCESSOR_V850E;  break;
 482     case bfd_mach_v850e1: processor_mask = PROCESSOR_V850E;  break;
 483     }
 484 }
 485
 486 static void v850_longcode PARAMS ((int));
 487
 488 static void
 489 v850_longcode (type)
 490      int type;
 491 {
 492   expressionS ex;
 493
 494   if (! v850_relax)
 495     {
 496       if (type == 1)
 497         as_warn (".longcall pseudo-op seen when not relaxing");
 498       else
 499         as_warn (".longjump pseudo-op seen when not relaxing");
 500     }
 501
 502   expression (&ex);
 503
 504   if (ex.X_op != O_symbol || ex.X_add_number != 0)
 505     {
 506       as_bad ("bad .longcall format");
 507       ignore_rest_of_line ();
 508
 509       return;
 510     }
 511
 512   if (type == 1)
 513     fix_new_exp (frag_now, frag_now_fix (), 4, & ex, 1,
 514                  BFD_RELOC_V850_LONGCALL);
 515   else
 516     fix_new_exp (frag_now, frag_now_fix (), 4, & ex, 1,
 517                  BFD_RELOC_V850_LONGJUMP);
 518
 519   demand_empty_rest_of_line ();
 520 }
 521
 522 /* The target specific pseudo-ops which we support.  */
 523 const pseudo_typeS md_pseudo_table[] =
 524 {
 525   { "sdata",            v850_seg,               SDATA_SECTION           },
 526   { "tdata",            v850_seg,               TDATA_SECTION           },
 527   { "zdata",            v850_seg,               ZDATA_SECTION           },
 528   { "sbss",             v850_seg,               SBSS_SECTION            },
 529   { "tbss",             v850_seg,               TBSS_SECTION            },
 530   { "zbss",             v850_seg,               ZBSS_SECTION            },
 531   { "rosdata",          v850_seg,               ROSDATA_SECTION         },
 532   { "rozdata",          v850_seg,               ROZDATA_SECTION         },
 533   { "bss",              v850_seg,               BSS_SECTION             },
 534   { "offset",           v850_offset,            0                       },
 535   { "word",             cons,                   4                       },
 536   { "zcomm",            v850_comm,              ZCOMMON_SECTION         },
 537   { "scomm",            v850_comm,              SCOMMON_SECTION         },
 538   { "tcomm",            v850_comm,              TCOMMON_SECTION         },
 539   { "v850",             set_machine,            0                       },
 540   { "call_table_data",  v850_seg,               CALL_TABLE_DATA_SECTION },
 541   { "call_table_text",  v850_seg,               CALL_TABLE_TEXT_SECTION },
 542   { "v850e",            set_machine,            bfd_mach_v850e          },
 543   { "v850e1",           set_machine,            bfd_mach_v850e1         },
 544   { "longcall",         v850_longcode,          1                       },
 545   { "longjump",         v850_longcode,          2                       },
 546   { NULL,               NULL,                   0                       }
 547 };
 548
 549 /* Opcode hash table.  */
 550 static struct hash_control *v850_hash;
 551
 552 /* This table is sorted.  Suitable for searching by a binary search.  */
 553 static const struct reg_name pre_defined_registers[] =
 554 {
 555   { "ep",  30 },                /* ep - element ptr */
 556   { "gp",   4 },                /* gp - global ptr  */
 557   { "hp",   2 },                /* hp - handler stack ptr  */
 558   { "lp",  31 },                /* lp - link ptr  */
 559   { "r0",   0 },
 560   { "r1",   1 },
 561   { "r10", 10 },
 562   { "r11", 11 },
 563   { "r12", 12 },
 564   { "r13", 13 },
 565   { "r14", 14 },
 566   { "r15", 15 },
 567   { "r16", 16 },
 568   { "r17", 17 },
 569   { "r18", 18 },
 570   { "r19", 19 },
 571   { "r2",   2 },
 572   { "r20", 20 },
 573   { "r21", 21 },
 574   { "r22", 22 },
 575   { "r23", 23 },
 576   { "r24", 24 },
 577   { "r25", 25 },
 578   { "r26", 26 },
 579   { "r27", 27 },
 580   { "r28", 28 },
 581   { "r29", 29 },
 582   { "r3",   3 },
 583   { "r30", 30 },
 584   { "r31", 31 },
 585   { "r4",   4 },
 586   { "r5",   5 },
 587   { "r6",   6 },
 588   { "r7",   7 },
 589   { "r8",   8 },
 590   { "r9",   9 },
 591   { "sp",   3 },                /* sp - stack ptr  */
 592   { "tp",   5 },                /* tp - text ptr  */
 593   { "zero", 0 },
 594 };
 595
 596 #define REG_NAME_CNT                                            \
 597   (sizeof (pre_defined_registers) / sizeof (struct reg_name))
 598
 599 static const struct reg_name system_registers[] =
 600 {
 601   { "asid",  23 },
 602   { "bpc",   22 },
 603   { "bpav",  24 },
 604   { "bpam",  25 },
 605   { "bpdv",  26 },
 606   { "bpdm",  27 },
 607   { "ctbp",  20 },
 608   { "ctpc",  16 },
 609   { "ctpsw", 17 },
 610   { "dbpc",  18 },
 611   { "dbpsw", 19 },
 612   { "dir",   21 },
 613   { "ecr",    4 },
 614   { "eipc",   0 },
 615   { "eipsw",  1 },
 616   { "fepc",   2 },
 617   { "fepsw",  3 },
 618   { "psw",    5 },
 619 };
 620
 621 #define SYSREG_NAME_CNT                                         \
 622   (sizeof (system_registers) / sizeof (struct reg_name))
 623
 624 static const struct reg_name system_list_registers[] =
 625 {
 626   {"PS",      5 },
 627   {"SR",      0 + 1}
 628 };
 629
 630 #define SYSREGLIST_NAME_CNT                                     \
 631   (sizeof (system_list_registers) / sizeof (struct reg_name))
 632
 633 static const struct reg_name cc_names[] =
 634 {
 635   { "c",  0x1 },
 636   { "e",  0x2 },
 637   { "ge", 0xe },
 638   { "gt", 0xf },
 639   { "h",  0xb },
 640   { "l",  0x1 },
 641   { "le", 0x7 },
 642   { "lt", 0x6 },
 643   { "n",  0x4 },
 644   { "nc", 0x9 },
 645   { "ne", 0xa },
 646   { "nh", 0x3 },
 647   { "nl", 0x9 },
 648   { "ns", 0xc },
 649   { "nv", 0x8 },
 650   { "nz", 0xa },
 651   { "p",  0xc },
 652   { "s",  0x4 },
 653   { "sa", 0xd },
 654   { "t",  0x5 },
 655   { "v",  0x0 },
 656   { "z",  0x2 },
 657 };
 658
 659 #define CC_NAME_CNT                                     \
 660   (sizeof (cc_names) / sizeof (struct reg_name))
 661
 662 /* Do a binary search of the given register table to see if NAME is a
 663    valid regiter name.  Return the register number from the array on
 664    success, or -1 on failure.  */
 665
 666 static int reg_name_search
 667   PARAMS ((const struct reg_name *, int, const char *, bfd_boolean));
 668
 669 static int
 670 reg_name_search (regs, regcount, name, accept_numbers)
 671      const struct reg_name *regs;
 672      int regcount;
 673      const char *name;
 674      bfd_boolean accept_numbers;
 675 {
 676   int middle, low, high;
 677   int cmp;
 678   symbolS *symbolP;
 679
 680   /* If the register name is a symbol, then evaluate it.  */
 681   if ((symbolP = symbol_find (name)) != NULL)
 682     {
 683       /* If the symbol is an alias for another name then use that.
 684          If the symbol is an alias for a number, then return the number.  */
 685       if (symbol_equated_p (symbolP))
 686         {
 687           name
 688             = S_GET_NAME (symbol_get_value_expression (symbolP)->X_add_symbol);
 689         }
 690       else if (accept_numbers)
 691         {
 692           int reg = S_GET_VALUE (symbolP);
 693
 694           if (reg >= 0 && reg <= 31)
 695             return reg;
 696         }
 697
 698       /* Otherwise drop through and try parsing name normally.  */
 699     }
 700
 701   low = 0;
 702   high = regcount - 1;
 703
 704   do
 705     {
 706       middle = (low + high) / 2;
 707       cmp = strcasecmp (name, regs[middle].name);
 708       if (cmp < 0)
 709         high = middle - 1;
 710       else if (cmp > 0)
 711         low = middle + 1;
 712       else
 713         return regs[middle].value;
 714     }
 715   while (low <= high);
 716   return -1;
 717 }
 718
 719 /* Summary of register_name().
 720
 721    in: Input_line_pointer points to 1st char of operand.
 722
 723    out: An expressionS.
 724         The operand may have been a register: in this case, X_op == O_register,
 725         X_add_number is set to the register number, and truth is returned.
 726         Input_line_pointer->(next non-blank) char after operand, or is in
 727         its original state.  */
 728
 729 static bfd_boolean register_name PARAMS ((expressionS *));
 730
 731 static bfd_boolean
 732 register_name (expressionP)
 733      expressionS *expressionP;
 734 {
 735   int reg_number;
 736   char *name;
 737   char *start;
 738   char c;
 739
 740   /* Find the spelling of the operand.  */
 741   start = name = input_line_pointer;
 742
 743   c = get_symbol_end ();
 744
 745   reg_number = reg_name_search (pre_defined_registers, REG_NAME_CNT,
 746                                 name, FALSE);
 747
 748   /* Put back the delimiting char.  */
 749   *input_line_pointer = c;
 750
 751   /* Look to see if it's in the register table.  */
 752   if (reg_number >= 0)
 753     {
 754       expressionP->X_op         = O_register;
 755       expressionP->X_add_number = reg_number;
 756
 757       /* Make the rest nice.  */
 758       expressionP->X_add_symbol = NULL;
 759       expressionP->X_op_symbol  = NULL;
 760
 761       return TRUE;
 762     }
 763   else
 764     {
 765       /* Reset the line as if we had not done anything.  */
 766       input_line_pointer = start;
 767
 768       return FALSE;
 769     }
 770 }
 771
 772 /* Summary of system_register_name().
 773
 774    in:  INPUT_LINE_POINTER points to 1st char of operand.
 775         EXPRESSIONP points to an expression structure to be filled in.
 776         ACCEPT_NUMBERS is true iff numerical register names may be used.
 777         ACCEPT_LIST_NAMES is true iff the special names PS and SR may be
 778         accepted.
 779
 780    out: An expressionS structure in expressionP.
 781         The operand may have been a register: in this case, X_op == O_register,
 782         X_add_number is set to the register number, and truth is returned.
 783         Input_line_pointer->(next non-blank) char after operand, or is in
 784         its original state.  */
 785
 786 static bfd_boolean system_register_name
 787   PARAMS ((expressionS *, bfd_boolean, bfd_boolean));
 788
 789 static bfd_boolean
 790 system_register_name (expressionP, accept_numbers, accept_list_names)
 791      expressionS *expressionP;
 792      bfd_boolean accept_numbers;
 793      bfd_boolean accept_list_names;
 794 {
 795   int reg_number;
 796   char *name;
 797   char *start;
 798   char c;
 799
 800   /* Find the spelling of the operand.  */
 801   start = name = input_line_pointer;
 802
 803   c = get_symbol_end ();
 804   reg_number = reg_name_search (system_registers, SYSREG_NAME_CNT, name,
 805                                 accept_numbers);
 806
 807   /* Put back the delimiting char.  */
 808   *input_line_pointer = c;
 809
 810   if (reg_number < 0
 811       && accept_numbers)
 812     {
 813       /* Reset input_line pointer.  */
 814       input_line_pointer = start;
 815
 816       if (ISDIGIT (*input_line_pointer))
 817         {
 818           reg_number = strtol (input_line_pointer, &input_line_pointer, 10);
 819
 820           /* Make sure that the register number is allowable.  */
 821           if (reg_number < 0
 822               || (reg_number > 5 && reg_number < 16)
 823               || reg_number > 27)
 824             {
 825               reg_number = -1;
 826             }
 827         }
 828       else if (accept_list_names)
 829         {
 830           c = get_symbol_end ();
 831           reg_number = reg_name_search (system_list_registers,
 832                                         SYSREGLIST_NAME_CNT, name, FALSE);
 833
 834           /* Put back the delimiting char.  */
 835           *input_line_pointer = c;
 836         }
 837     }
 838
 839   /* Look to see if it's in the register table.  */
 840   if (reg_number >= 0)
 841     {
 842       expressionP->X_op         = O_register;
 843       expressionP->X_add_number = reg_number;
 844
 845       /* Make the rest nice.  */
 846       expressionP->X_add_symbol = NULL;
 847       expressionP->X_op_symbol  = NULL;
 848
 849       return TRUE;
 850     }
 851   else
 852     {
 853       /* Reset the line as if we had not done anything.  */
 854       input_line_pointer = start;
 855
 856       return FALSE;
 857     }
 858 }
 859
 860 /* Summary of cc_name().
 861
 862    in: INPUT_LINE_POINTER points to 1st char of operand.
 863
 864    out: An expressionS.
 865         The operand may have been a register: in this case, X_op == O_register,
 866         X_add_number is set to the register number, and truth is returned.
 867         Input_line_pointer->(next non-blank) char after operand, or is in
 868         its original state.  */
 869
 870 static bfd_boolean cc_name PARAMS ((expressionS *));
 871
 872 static bfd_boolean
 873 cc_name (expressionP)
 874      expressionS *expressionP;
 875 {
 876   int reg_number;
 877   char *name;
 878   char *start;
 879   char c;
 880
 881   /* Find the spelling of the operand.  */
 882   start = name = input_line_pointer;
 883
 884   c = get_symbol_end ();
 885   reg_number = reg_name_search (cc_names, CC_NAME_CNT, name, FALSE);
 886
 887   /* Put back the delimiting char.  */
 888   *input_line_pointer = c;
 889
 890   /* Look to see if it's in the register table.  */
 891   if (reg_number >= 0)
 892     {
 893       expressionP->X_op         = O_constant;
 894       expressionP->X_add_number = reg_number;
 895
 896       /* Make the rest nice.  */
 897       expressionP->X_add_symbol = NULL;
 898       expressionP->X_op_symbol  = NULL;
 899
 900       return TRUE;
 901     }
 902   else
 903     {
 904       /* Reset the line as if we had not done anything.  */
 905       input_line_pointer = start;
 906
 907       return FALSE;
 908     }
 909 }
 910
 911 static void skip_white_space PARAMS ((void));
 912
 913 static void
 914 skip_white_space ()
 915 {
 916   while (*input_line_pointer == ' '
 917          || *input_line_pointer == '\t')
 918     ++input_line_pointer;
 919 }
 920
 921 /* Summary of parse_register_list ().
 922
 923    in: INPUT_LINE_POINTER  points to 1st char of a list of registers.
 924        INSN                is the partially constructed instruction.
 925        OPERAND             is the operand being inserted.
 926
 927    out: NULL if the parse completed successfully, otherwise a
 928         pointer to an error message is returned.  If the parse
 929         completes the correct bit fields in the instruction
 930         will be filled in.
 931
 932    Parses register lists with the syntax:
 933
 934      { rX }
 935      { rX, rY }
 936      { rX - rY }
 937      { rX - rY, rZ }
 938      etc
 939
 940    and also parses constant expressions whoes bits indicate the
 941    registers in the lists.  The LSB in the expression refers to
 942    the lowest numbered permissible register in the register list,
 943    and so on upwards.  System registers are considered to be very
 944    high numbers.  */
 945
 946 static char *parse_register_list
 947   PARAMS ((unsigned long *, const struct v850_operand *));
 948
 949 static char *
 950 parse_register_list (insn, operand)
 951      unsigned long *insn;
 952      const struct v850_operand *operand;
 953 {
 954   static int type1_regs[32] = {
 955     30,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 956      0,  0,  0,  0,  0, 31, 29, 28, 23, 22, 21, 20, 27, 26, 25, 24
 957   };
 958   static int type2_regs[32] = {
 959     19, 18, 17, 16,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 960      0,  0,  0,  0, 30, 31, 29, 28, 23, 22, 21, 20, 27, 26, 25, 24
 961   };
 962   static int type3_regs[32] = {
 963      3,  2,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 964      0,  0,  0,  0, 14, 15, 13, 12,  7,  6,  5,  4, 11, 10,  9,  8
 965   };
 966   int *regs;
 967   expressionS exp;
 968
 969   /* Select a register array to parse.  */
 970   switch (operand->shift)
 971     {
 972     case 0xffe00001: regs = type1_regs; break;
 973     case 0xfff8000f: regs = type2_regs; break;
 974     case 0xfff8001f: regs = type3_regs; break;
 975     default:
 976       as_bad (_("unknown operand shift: %x\n"), operand->shift);
 977       return _("internal failure in parse_register_list");
 978     }
 979
 980   skip_white_space ();
 981
 982   /* If the expression starts with a curly brace it is a register list.
 983      Otherwise it is a constant expression, whoes bits indicate which
 984      registers are to be included in the list.  */
 985   if (*input_line_pointer != '{')
 986     {
 987       int reg;
 988       int i;
 989
 990       expression (&exp);
 991
 992       if (exp.X_op != O_constant)
 993         return _("constant expression or register list expected");
 994
 995       if (regs == type1_regs)
 996         {
 997           if (exp.X_add_number & 0xFFFFF000)
 998             return _("high bits set in register list expression");
 999
1000           for (reg = 20; reg < 32; reg++)
1001             if (exp.X_add_number & (1 << (reg - 20)))
1002               {
1003                 for (i = 0; i < 32; i++)
1004                   if (regs[i] == reg)
1005                     *insn |= (1 << i);
1006               }
1007         }
1008       else if (regs == type2_regs)
1009         {
1010           if (exp.X_add_number & 0xFFFE0000)
1011             return _("high bits set in register list expression");
1012
1013           for (reg = 1; reg < 16; reg++)
1014             if (exp.X_add_number & (1 << (reg - 1)))
1015               {
1016                 for (i = 0; i < 32; i++)
1017                   if (regs[i] == reg)
1018                     *insn |= (1 << i);
1019               }
1020
1021           if (exp.X_add_number & (1 << 15))
1022             *insn |= (1 << 3);
1023
1024           if (exp.X_add_number & (1 << 16))
1025             *insn |= (1 << 19);
1026         }
1027       else /* regs == type3_regs  */
1028         {
1029           if (exp.X_add_number & 0xFFFE0000)
1030             return _("high bits set in register list expression");
1031
1032           for (reg = 16; reg < 32; reg++)
1033             if (exp.X_add_number & (1 << (reg - 16)))
1034               {
1035                 for (i = 0; i < 32; i++)
1036                   if (regs[i] == reg)
1037                     *insn |= (1 << i);
1038               }
1039
1040           if (exp.X_add_number & (1 << 16))
1041             *insn |= (1 << 19);
1042         }
1043
1044       return NULL;
1045     }
1046
1047   input_line_pointer++;
1048
1049   /* Parse the register list until a terminator (closing curly brace or
1050      new-line) is found.  */
1051   for (;;)
1052     {
1053       if (register_name (&exp))
1054         {
1055           int i;
1056
1057           /* Locate the given register in the list, and if it is there,
1058              insert the corresponding bit into the instruction.  */
1059           for (i = 0; i < 32; i++)
1060             {
1061               if (regs[i] == exp.X_add_number)
1062                 {
1063                   *insn |= (1 << i);
1064                   break;
1065                 }
1066             }
1067
1068           if (i == 32)
1069             return _("illegal register included in list");
1070         }
1071       else if (system_register_name (&exp, TRUE, TRUE))
1072         {
1073           if (regs == type1_regs)
1074             {
1075               return _("system registers cannot be included in list");
1076             }
1077           else if (exp.X_add_number == 5)
1078             {
1079               if (regs == type2_regs)
1080                 return _("PSW cannot be included in list");
1081               else
1082                 *insn |= 0x8;
1083             }
1084           else if (exp.X_add_number < 4)
1085             *insn |= 0x80000;
1086           else
1087             return _("High value system registers cannot be included in list");
1088         }
1089       else if (*input_line_pointer == '}')
1090         {
1091           input_line_pointer++;
1092           break;
1093         }
1094       else if (*input_line_pointer == ',')
1095         {
1096           input_line_pointer++;
1097           continue;
1098         }
1099       else if (*input_line_pointer == '-')
1100         {
1101           /* We have encountered a range of registers: rX - rY.  */
1102           int j;
1103           expressionS exp2;
1104
1105           /* Skip the dash.  */
1106           ++input_line_pointer;
1107
1108           /* Get the second register in the range.  */
1109           if (! register_name (&exp2))
1110             {
1111               return _("second register should follow dash in register list");
1112               exp2.X_add_number = exp.X_add_number;
1113             }
1114
1115           /* Add the rest of the registers in the range.  */
1116           for (j = exp.X_add_number + 1; j <= exp2.X_add_number; j++)
1117             {
1118               int i;
1119
1120               /* Locate the given register in the list, and if it is there,
1121                  insert the corresponding bit into the instruction.  */
1122               for (i = 0; i < 32; i++)
1123                 {
1124                   if (regs[i] == j)
1125                     {
1126                       *insn |= (1 << i);
1127                       break;
1128                     }
1129                 }
1130
1131               if (i == 32)
1132                 return _("illegal register included in list");
1133             }
1134         }
1135       else
1136         break;
1137
1138       skip_white_space ();
1139     }
1140
1141   return NULL;
1142 }
1143
1144 const char *md_shortopts = "m:";
1145
1146 struct option md_longopts[] = {
1147   {NULL, no_argument, NULL, 0}
1148 };
1149
1150 size_t md_longopts_size = sizeof (md_longopts);
1151
1152 void
1153 md_show_usage (stream)
1154      FILE *stream;
1155 {
1156   fprintf (stream, _(" V850 options:\n"));
1157   fprintf (stream, _("  -mwarn-signed-overflow    Warn if signed immediate values overflow\n"));
1158   fprintf (stream, _("  -mwarn-unsigned-overflow  Warn if unsigned immediate values overflow\n"));
1159   fprintf (stream, _("  -mv850                    The code is targeted at the v850\n"));
1160   fprintf (stream, _("  -mv850e                   The code is targeted at the v850e\n"));
1161   fprintf (stream, _("  -mv850e1                  The code is targeted at the v850e1\n"));
1162   fprintf (stream, _("  -mv850any                 The code is generic, despite any processor specific instructions\n"));
1163   fprintf (stream, _("  -mrelax                   Enable relaxation\n"));
1164 }
1165
1166 int
1167 md_parse_option (c, arg)
1168      int c;
1169      char *arg;
1170 {
1171   if (c != 'm')
1172     return 0;
1173
1174   if (strcmp (arg, "warn-signed-overflow") == 0)
1175     warn_signed_overflows = TRUE;
1176
1177   else if (strcmp (arg, "warn-unsigned-overflow") == 0)
1178     warn_unsigned_overflows = TRUE;
1179
1180   else if (strcmp (arg, "v850") == 0)
1181     {
1182       machine = 0;
1183       processor_mask = PROCESSOR_V850;
1184     }
1185   else if (strcmp (arg, "v850e") == 0)
1186     {
1187       machine = bfd_mach_v850e;
1188       processor_mask = PROCESSOR_V850E;
1189     }
1190   else if (strcmp (arg, "v850e1") == 0)
1191     {
1192       machine = bfd_mach_v850e1;
1193       processor_mask = PROCESSOR_V850E1;
1194     }
1195   else if (strcmp (arg, "v850any") == 0)
1196     {
1197       /* Tell the world that this is for any v850 chip.  */
1198       machine = 0;
1199
1200       /* But support instructions for the extended versions.  */
1201       processor_mask = PROCESSOR_V850E;
1202       processor_mask |= PROCESSOR_V850E1;
1203     }
1204   else if (strcmp (arg, "relax") == 0)
1205     v850_relax = 1;
1206   else
1207     return 0;
1208
1209   return 1;
1210 }
1211
1212 symbolS *
1213 md_undefined_symbol (name)
1214      char *name ATTRIBUTE_UNUSED;
1215 {
1216   return 0;
1217 }
1218
1219 char *
1220 md_atof (type, litp, sizep)
1221      int type;
1222      char *litp;
1223      int *sizep;
1224 {
1225   int prec;
1226   LITTLENUM_TYPE words[4];
1227   char *t;
1228   int i;
1229
1230   switch (type)
1231     {
1232     case 'f':
1233       prec = 2;
1234       break;
1235
1236     case 'd':
1237       prec = 4;
1238       break;
1239
1240     default:
1241       *sizep = 0;
1242       return _("bad call to md_atof");
1243     }
1244
1245   t = atof_ieee (input_line_pointer, type, words);
1246   if (t)
1247     input_line_pointer = t;
1248
1249   *sizep = prec * 2;
1250
1251   for (i = prec - 1; i >= 0; i--)
1252     {
1253       md_number_to_chars (litp, (valueT) words[i], 2);
1254       litp += 2;
1255     }
1256
1257   return NULL;
1258 }
1259
1260 /* Very gross.  */
1261
1262 void
1263 md_convert_frag (abfd, sec, fragP)
1264      bfd *abfd ATTRIBUTE_UNUSED;
1265      asection *sec;
1266      fragS *fragP;
1267 {
1268   subseg_change (sec, 0);
1269
1270   /* In range conditional or unconditional branch.  */
1271   if (fragP->fr_subtype == 0 || fragP->fr_subtype == 2)
1272     {
1273       fix_new (fragP, fragP->fr_fix, 2, fragP->fr_symbol,
1274                fragP->fr_offset, 1, BFD_RELOC_UNUSED + (int)fragP->fr_opcode);
1275       fragP->fr_fix += 2;
1276     }
1277   /* Out of range conditional branch.  Emit a branch around a jump.  */
1278   else if (fragP->fr_subtype == 1)
1279     {
1280       unsigned char *buffer =
1281         (unsigned char *) (fragP->fr_fix + fragP->fr_literal);
1282
1283       /* Reverse the condition of the first branch.  */
1284       buffer[0] ^= 0x08;
1285       /* Mask off all the displacement bits.  */
1286       buffer[0] &= 0x8f;
1287       buffer[1] &= 0x07;
1288       /* Now set the displacement bits so that we branch
1289          around the unconditional branch.  */
1290       buffer[0] |= 0x30;
1291
1292       /* Now create the unconditional branch + fixup to the final
1293          target.  */
1294       md_number_to_chars (buffer + 2, 0x00000780, 4);
1295       fix_new (fragP, fragP->fr_fix + 2, 4, fragP->fr_symbol,
1296                fragP->fr_offset, 1, BFD_RELOC_UNUSED +
1297                (int) fragP->fr_opcode + 1);
1298       fragP->fr_fix += 6;
1299     }
1300   /* Out of range unconditional branch.  Emit a jump.  */
1301   else if (fragP->fr_subtype == 3)
1302     {
1303       md_number_to_chars (fragP->fr_fix + fragP->fr_literal, 0x00000780, 4);
1304       fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol,
1305                fragP->fr_offset, 1, BFD_RELOC_UNUSED +
1306                (int) fragP->fr_opcode + 1);
1307       fragP->fr_fix += 4;
1308     }
1309   else
1310     abort ();
1311 }
1312
1313 valueT
1314 md_section_align (seg, addr)
1315      asection *seg;
1316      valueT addr;
1317 {
1318   int align = bfd_get_section_alignment (stdoutput, seg);
1319   return ((addr + (1 << align) - 1) & (-1 << align));
1320 }
1321
1322 void
1323 md_begin ()
1324 {
1325   char *prev_name = "";
1326   const struct v850_opcode *op;
1327
1328   if (strncmp (TARGET_CPU, "v850e1", 6) == 0)
1329     {
1330       if (machine == -1)
1331         machine = bfd_mach_v850e1;
1332
1333       if (processor_mask == -1)
1334         processor_mask = PROCESSOR_V850E1;
1335     }
1336   else if (strncmp (TARGET_CPU, "v850e", 5) == 0)
1337     {
1338       if (machine == -1)
1339         machine = bfd_mach_v850e;
1340
1341       if (processor_mask == -1)
1342         processor_mask = PROCESSOR_V850E;
1343     }
1344   else if (strncmp (TARGET_CPU, "v850", 4) == 0)
1345     {
1346       if (machine == -1)
1347         machine = 0;
1348
1349       if (processor_mask == -1)
1350         processor_mask = PROCESSOR_V850;
1351     }
1352   else
1353     /* xgettext:c-format  */
1354     as_bad (_("Unable to determine default target processor from string: %s"),
1355             TARGET_CPU);
1356
1357   v850_hash = hash_new ();
1358
1359   /* Insert unique names into hash table.  The V850 instruction set
1360      has many identical opcode names that have different opcodes based
1361      on the operands.  This hash table then provides a quick index to
1362      the first opcode with a particular name in the opcode table.  */
1363   op = v850_opcodes;
1364   while (op->name)
1365     {
1366       if (strcmp (prev_name, op->name))
1367         {
1368           prev_name = (char *) op->name;
1369           hash_insert (v850_hash, op->name, (char *) op);
1370         }
1371       op++;
1372     }
1373
1374   v850_seg_table[BSS_SECTION].s = bss_section;
1375   bfd_set_arch_mach (stdoutput, TARGET_ARCH, machine);
1376 }
1377
1378 static bfd_reloc_code_real_type handle_ctoff
1379   PARAMS ((const struct v850_operand *));
1380
1381 static bfd_reloc_code_real_type
1382 handle_ctoff (operand)
1383      const struct v850_operand *operand;
1384 {
1385   if (operand == NULL)
1386     return BFD_RELOC_V850_CALLT_16_16_OFFSET;
1387
1388   if (operand->bits != 6
1389       || operand->shift != 0)
1390     {
1391       as_bad (_("ctoff() relocation used on an instruction which does not support it"));
1392       return BFD_RELOC_64;  /* Used to indicate an error condition.  */
1393     }
1394
1395   return BFD_RELOC_V850_CALLT_6_7_OFFSET;
1396 }
1397
1398 static bfd_reloc_code_real_type handle_sdaoff
1399   PARAMS ((const struct v850_operand *));
1400
1401 static bfd_reloc_code_real_type
1402 handle_sdaoff (operand)
1403      const struct v850_operand *operand;
1404 {
1405   if (operand == NULL)
1406     return BFD_RELOC_V850_SDA_16_16_OFFSET;
1407
1408   if (operand->bits == 15 && operand->shift == 17)
1409     return BFD_RELOC_V850_SDA_15_16_OFFSET;
1410
1411   if (operand->bits == -1)
1412     return BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET;
1413
1414   if (operand->bits != 16
1415       || operand->shift != 16)
1416     {
1417       as_bad (_("sdaoff() relocation used on an instruction which does not support it"));
1418       return BFD_RELOC_64;  /* Used to indicate an error condition.  */
1419     }
1420
1421   return BFD_RELOC_V850_SDA_16_16_OFFSET;
1422 }
1423
1424 static bfd_reloc_code_real_type handle_zdaoff
1425   PARAMS ((const struct v850_operand *));
1426
1427 static bfd_reloc_code_real_type
1428 handle_zdaoff (operand)
1429      const struct v850_operand *operand;
1430 {
1431   if (operand == NULL)
1432     return BFD_RELOC_V850_ZDA_16_16_OFFSET;
1433
1434   if (operand->bits == 15 && operand->shift == 17)
1435     return BFD_RELOC_V850_ZDA_15_16_OFFSET;
1436
1437   if (operand->bits == -1)
1438     return BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET;
1439
1440   if (operand->bits != 16
1441       || operand->shift != 16)
1442     {
1443       as_bad (_("zdaoff() relocation used on an instruction which does not support it"));
1444       /* Used to indicate an error condition.  */
1445       return BFD_RELOC_64;
1446     }
1447
1448   return BFD_RELOC_V850_ZDA_16_16_OFFSET;
1449 }
1450
1451 static bfd_reloc_code_real_type handle_tdaoff
1452   PARAMS ((const struct v850_operand *));
1453
1454 static bfd_reloc_code_real_type
1455 handle_tdaoff (operand)
1456      const struct v850_operand *operand;
1457 {
1458   if (operand == NULL)
1459     /* Data item, not an instruction.  */
1460     return BFD_RELOC_V850_TDA_7_7_OFFSET;
1461
1462   if (operand->bits == 6 && operand->shift == 1)
1463     /* sld.w/sst.w, operand: D8_6  */
1464     return BFD_RELOC_V850_TDA_6_8_OFFSET;
1465
1466   if (operand->bits == 4 && operand->insert != NULL)
1467     /* sld.hu, operand: D5-4  */
1468     return BFD_RELOC_V850_TDA_4_5_OFFSET;
1469
1470   if (operand->bits == 4 && operand->insert == NULL)
1471     /* sld.bu, operand: D4   */
1472     return BFD_RELOC_V850_TDA_4_4_OFFSET;
1473
1474   if (operand->bits == 16 && operand->shift == 16)
1475     /* set1 & chums, operands: D16  */
1476     return BFD_RELOC_V850_TDA_16_16_OFFSET;
1477
1478   if (operand->bits != 7)
1479     {
1480       as_bad (_("tdaoff() relocation used on an instruction which does not support it"));
1481       /* Used to indicate an error condition.  */
1482       return BFD_RELOC_64;
1483     }
1484
1485   return  operand->insert != NULL
1486     ? BFD_RELOC_V850_TDA_7_8_OFFSET     /* sld.h/sst.h, operand: D8_7  */
1487     : BFD_RELOC_V850_TDA_7_7_OFFSET;    /* sld.b/sst.b, operand: D7    */
1488 }
1489
1490 /* Warning: The code in this function relies upon the definitions
1491    in the v850_operands[] array (defined in opcodes/v850-opc.c)
1492    matching the hard coded values contained herein.  */
1493
1494 static bfd_reloc_code_real_type v850_reloc_prefix
1495   PARAMS ((const struct v850_operand *));
1496
1497 static bfd_reloc_code_real_type
1498 v850_reloc_prefix (operand)
1499      const struct v850_operand *operand;
1500 {
1501   bfd_boolean paren_skipped = FALSE;
1502
1503   /* Skip leading opening parenthesis.  */
1504   if (*input_line_pointer == '(')
1505     {
1506       ++input_line_pointer;
1507       paren_skipped = TRUE;
1508     }
1509
1510 #define CHECK_(name, reloc)                                             \
1511   if (strncmp (input_line_pointer, name "(", strlen (name) + 1) == 0)   \
1512     {                                                                   \
1513       input_line_pointer += strlen (name);                              \
1514       return reloc;                                                     \
1515     }
1516
1517   CHECK_ ("hi0",    BFD_RELOC_HI16         );
1518   CHECK_ ("hi",     BFD_RELOC_HI16_S       );
1519   CHECK_ ("lo",     BFD_RELOC_LO16         );
1520   CHECK_ ("sdaoff", handle_sdaoff (operand));
1521   CHECK_ ("zdaoff", handle_zdaoff (operand));
1522   CHECK_ ("tdaoff", handle_tdaoff (operand));
1523   CHECK_ ("hilo",   BFD_RELOC_32           );
1524   CHECK_ ("ctoff",  handle_ctoff (operand) );
1525
1526   /* Restore skipped parenthesis.  */
1527   if (paren_skipped)
1528     --input_line_pointer;
1529
1530   return BFD_RELOC_UNUSED;
1531 }
1532
1533 /* Insert an operand value into an instruction.  */
1534
1535 static unsigned long v850_insert_operand
1536   PARAMS ((unsigned long, const struct v850_operand *, offsetT, char *,
1537            unsigned int, char *));
1538
1539 static unsigned long
1540 v850_insert_operand (insn, operand, val, file, line, str)
1541      unsigned long insn;
1542      const struct v850_operand *operand;
1543      offsetT val;
1544      char *file;
1545      unsigned int line;
1546      char *str;
1547 {
1548   if (operand->insert)
1549     {
1550       const char *message = NULL;
1551
1552       insn = operand->insert (insn, val, &message);
1553       if (message != NULL)
1554         {
1555           if ((operand->flags & V850_OPERAND_SIGNED)
1556               && ! warn_signed_overflows
1557               && strstr (message, "out of range") != NULL)
1558             {
1559               /* Skip warning...  */
1560             }
1561           else if ((operand->flags & V850_OPERAND_SIGNED) == 0
1562                    && ! warn_unsigned_overflows
1563                    && strstr (message, "out of range") != NULL)
1564             {
1565               /* Skip warning...  */
1566             }
1567           else if (str)
1568             {
1569               if (file == (char *) NULL)
1570                 as_warn ("%s: %s", str, message);
1571               else
1572                 as_warn_where (file, line, "%s: %s", str, message);
1573             }
1574           else
1575             {
1576               if (file == (char *) NULL)
1577                 as_warn (message);
1578               else
1579                 as_warn_where (file, line, message);
1580             }
1581         }
1582     }
1583   else
1584     {
1585       if (operand->bits != 32)
1586         {
1587           long min, max;
1588
1589           if ((operand->flags & V850_OPERAND_SIGNED) != 0)
1590             {
1591               if (! warn_signed_overflows)
1592                 max = (1 << operand->bits) - 1;
1593               else
1594                 max = (1 << (operand->bits - 1)) - 1;
1595
1596               min = -(1 << (operand->bits - 1));
1597             }
1598           else
1599             {
1600               max = (1 << operand->bits) - 1;
1601
1602               if (! warn_unsigned_overflows)
1603                 min = -(1 << (operand->bits - 1));
1604               else
1605                 min = 0;
1606             }
1607
1608           if (val < (offsetT) min || val > (offsetT) max)
1609             {
1610               char buf [128];
1611
1612               /* Restore min and mix to expected values for decimal ranges.  */
1613               if ((operand->flags & V850_OPERAND_SIGNED)
1614                   && ! warn_signed_overflows)
1615                 max = (1 << (operand->bits - 1)) - 1;
1616
1617               if (! (operand->flags & V850_OPERAND_SIGNED)
1618                   && ! warn_unsigned_overflows)
1619                 min = 0;
1620
1621               if (str)
1622                 sprintf (buf, "%s: ", str);
1623               else
1624                 buf[0] = 0;
1625               strcat (buf, _("operand"));
1626
1627               as_bad_value_out_of_range (buf, val, (offsetT) min, (offsetT) max, file, line);
1628             }
1629         }
1630
1631       insn |= (((long) val & ((1 << operand->bits) - 1)) << operand->shift);
1632     }
1633
1634   return insn;
1635 }
1636 \f
1637 static char copy_of_instruction[128];
1638
1639 void
1640 md_assemble (str)
1641      char *str;
1642 {
1643   char *s;
1644   char *start_of_operands;
1645   struct v850_opcode *opcode;
1646   struct v850_opcode *next_opcode;
1647   const unsigned char *opindex_ptr;
1648   int next_opindex;
1649   int relaxable = 0;
1650   unsigned long insn;
1651   unsigned long insn_size;
1652   char *f;
1653   int i;
1654   int match;
1655   bfd_boolean extra_data_after_insn = FALSE;
1656   unsigned extra_data_len = 0;
1657   unsigned long extra_data = 0;
1658   char *saved_input_line_pointer;
1659
1660   strncpy (copy_of_instruction, str, sizeof (copy_of_instruction) - 1);
1661
1662   /* Get the opcode.  */
1663   for (s = str; *s != '\0' && ! ISSPACE (*s); s++)
1664     continue;
1665
1666   if (*s != '\0')
1667     *s++ = '\0';
1668
1669   /* Find the first opcode with the proper name.  */
1670   opcode = (struct v850_opcode *) hash_find (v850_hash, str);
1671   if (opcode == NULL)
1672     {
1673       /* xgettext:c-format  */
1674       as_bad (_("Unrecognized opcode: `%s'"), str);
1675       ignore_rest_of_line ();
1676       return;
1677     }
1678
1679   str = s;
1680   while (ISSPACE (*str))
1681     ++str;
1682
1683   start_of_operands = str;
1684
1685   saved_input_line_pointer = input_line_pointer;
1686
1687   for (;;)
1688     {
1689       const char *errmsg = NULL;
1690
1691       match = 0;
1692
1693       if ((opcode->processors & processor_mask) == 0)
1694         {
1695           errmsg = _("Target processor does not support this instruction.");
1696           goto error;
1697         }
1698
1699       relaxable = 0;
1700       fc = 0;
1701       next_opindex = 0;
1702       insn = opcode->opcode;
1703       extra_data_after_insn = FALSE;
1704
1705       input_line_pointer = str = start_of_operands;
1706
1707       for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++)
1708         {
1709           const struct v850_operand *operand;
1710           char *hold;
1711           expressionS ex;
1712           bfd_reloc_code_real_type reloc;
1713
1714           if (next_opindex == 0)
1715             {
1716               operand = &v850_operands[*opindex_ptr];
1717             }
1718           else
1719             {
1720               operand = &v850_operands[next_opindex];
1721               next_opindex = 0;
1722             }
1723
1724           errmsg = NULL;
1725
1726           while (*str == ' ' || *str == ',' || *str == '[' || *str == ']')
1727             ++str;
1728
1729           if (operand->flags & V850_OPERAND_RELAX)
1730             relaxable = 1;
1731
1732           /* Gather the operand.  */
1733           hold = input_line_pointer;
1734           input_line_pointer = str;
1735
1736           /* lo(), hi(), hi0(), etc...  */
1737           if ((reloc = v850_reloc_prefix (operand)) != BFD_RELOC_UNUSED)
1738             {
1739               /* This is a fake reloc, used to indicate an error condition.  */
1740               if (reloc == BFD_RELOC_64)
1741                 {
1742                   match = 1;
1743                   goto error;
1744                 }
1745
1746               expression (&ex);
1747
1748               if (ex.X_op == O_constant)
1749                 {
1750                   switch (reloc)
1751                     {
1752                     case BFD_RELOC_V850_ZDA_16_16_OFFSET:
1753                       /* To cope with "not1 7, zdaoff(0xfffff006)[r0]"
1754                          and the like.  */
1755                       /* Fall through.  */
1756
1757                     case BFD_RELOC_LO16:
1758                       {
1759                         /* Truncate, then sign extend the value.  */
1760                         ex.X_add_number = SEXT16 (ex.X_add_number);
1761                         break;
1762                       }
1763
1764                     case BFD_RELOC_HI16:
1765                       {
1766                         /* Truncate, then sign extend the value.  */
1767                         ex.X_add_number = SEXT16 (ex.X_add_number >> 16);
1768                         break;
1769                       }
1770
1771                     case BFD_RELOC_HI16_S:
1772                       {
1773                         /* Truncate, then sign extend the value.  */
1774                         int temp = (ex.X_add_number >> 16) & 0xffff;
1775
1776                         temp += (ex.X_add_number >> 15) & 1;
1777
1778                         ex.X_add_number = SEXT16 (temp);
1779                         break;
1780                       }
1781
1782                     case BFD_RELOC_32:
1783                       if ((operand->flags & V850E_IMMEDIATE32) == 0)
1784                         {
1785                           errmsg = _("immediate operand is too large");
1786                           goto error;
1787                         }
1788
1789                       extra_data_after_insn = TRUE;
1790                       extra_data_len        = 4;
1791                       extra_data            = 0;
1792                       break;
1793
1794                     default:
1795                       fprintf (stderr, "reloc: %d\n", reloc);
1796                       as_bad (_("AAARG -> unhandled constant reloc"));
1797                       break;
1798                     }
1799
1800                   if (fc > MAX_INSN_FIXUPS)
1801                     as_fatal (_("too many fixups"));
1802
1803                   fixups[fc].exp     = ex;
1804                   fixups[fc].opindex = *opindex_ptr;
1805                   fixups[fc].reloc   = reloc;
1806                   fc++;
1807                 }
1808               else
1809                 {
1810                   if (reloc == BFD_RELOC_32)
1811                     {
1812                       if ((operand->flags & V850E_IMMEDIATE32) == 0)
1813                         {
1814                           errmsg = _("immediate operand is too large");
1815                           goto error;
1816                         }
1817
1818                       extra_data_after_insn = TRUE;
1819                       extra_data_len        = 4;
1820                       extra_data            = ex.X_add_number;
1821                     }
1822
1823                   if (fc > MAX_INSN_FIXUPS)
1824                     as_fatal (_("too many fixups"));
1825
1826                   fixups[fc].exp     = ex;
1827                   fixups[fc].opindex = *opindex_ptr;
1828                   fixups[fc].reloc   = reloc;
1829                   fc++;
1830                 }
1831             }
1832           else
1833             {
1834               errmsg = NULL;
1835
1836               if ((operand->flags & V850_OPERAND_REG) != 0)
1837                 {
1838                   if (!register_name (&ex))
1839                     {
1840                       errmsg = _("invalid register name");
1841                     }
1842                   else if ((operand->flags & V850_NOT_R0)
1843                            && ex.X_add_number == 0)
1844                     {
1845                       errmsg = _("register r0 cannot be used here");
1846
1847                       /* Force an error message to be generated by
1848                          skipping over any following potential matches
1849                          for this opcode.  */
1850                       opcode += 3;
1851                     }
1852                 }
1853               else if ((operand->flags & V850_OPERAND_SRG) != 0)
1854                 {
1855                   if (!system_register_name (&ex, TRUE, FALSE))
1856                     {
1857                       errmsg = _("invalid system register name");
1858                     }
1859                 }
1860               else if ((operand->flags & V850_OPERAND_EP) != 0)
1861                 {
1862                   char *start = input_line_pointer;
1863                   char c = get_symbol_end ();
1864
1865                   if (strcmp (start, "ep") != 0 && strcmp (start, "r30") != 0)
1866                     {
1867                       /* Put things back the way we found them.  */
1868                       *input_line_pointer = c;
1869                       input_line_pointer = start;
1870                       errmsg = _("expected EP register");
1871                       goto error;
1872                     }
1873
1874                   *input_line_pointer = c;
1875                   str = input_line_pointer;
1876                   input_line_pointer = hold;
1877
1878                   while (*str == ' ' || *str == ','
1879                          || *str == '[' || *str == ']')
1880                     ++str;
1881                   continue;
1882                 }
1883               else if ((operand->flags & V850_OPERAND_CC) != 0)
1884                 {
1885                   if (!cc_name (&ex))
1886                     {
1887                       errmsg = _("invalid condition code name");
1888                     }
1889                 }
1890               else if (operand->flags & V850E_PUSH_POP)
1891                 {
1892                   errmsg = parse_register_list (&insn, operand);
1893
1894                   /* The parse_register_list() function has already done
1895                      everything, so fake a dummy expression.  */
1896                   ex.X_op         = O_constant;
1897                   ex.X_add_number = 0;
1898                 }
1899               else if (operand->flags & V850E_IMMEDIATE16)
1900                 {
1901                   expression (&ex);
1902
1903                   if (ex.X_op != O_constant)
1904                     errmsg = _("constant expression expected");
1905                   else if (ex.X_add_number & 0xffff0000)
1906                     {
1907                       if (ex.X_add_number & 0xffff)
1908                         errmsg = _("constant too big to fit into instruction");
1909                       else if ((insn & 0x001fffc0) == 0x00130780)
1910                         ex.X_add_number >>= 16;
1911                       else
1912                         errmsg = _("constant too big to fit into instruction");
1913                     }
1914
1915                   extra_data_after_insn = TRUE;
1916                   extra_data_len        = 2;
1917                   extra_data            = ex.X_add_number;
1918                   ex.X_add_number       = 0;
1919                 }
1920               else if (operand->flags & V850E_IMMEDIATE32)
1921                 {
1922                   expression (&ex);
1923
1924                   if (ex.X_op != O_constant)
1925                     errmsg = _("constant expression expected");
1926
1927                   extra_data_after_insn = TRUE;
1928                   extra_data_len        = 4;
1929                   extra_data            = ex.X_add_number;
1930                   ex.X_add_number       = 0;
1931                 }
1932               else if (register_name (&ex)
1933                        && (operand->flags & V850_OPERAND_REG) == 0)
1934                 {
1935                   char c;
1936                   int exists = 0;
1937
1938                   /* It is possible that an alias has been defined that
1939                      matches a register name.  For example the code may
1940                      include a ".set ZERO, 0" directive, which matches
1941                      the register name "zero".  Attempt to reparse the
1942                      field as an expression, and only complain if we
1943                      cannot generate a constant.  */
1944
1945                   input_line_pointer = str;
1946
1947                   c = get_symbol_end ();
1948
1949                   if (symbol_find (str) != NULL)
1950                     exists = 1;
1951
1952                   *input_line_pointer = c;
1953                   input_line_pointer = str;
1954
1955                   expression (&ex);
1956
1957                   if (ex.X_op != O_constant)
1958                     {
1959                       /* If this register is actually occurring too early on
1960                          the parsing of the instruction, (because another
1961                          field is missing) then report this.  */
1962                       if (opindex_ptr[1] != 0
1963                           && (v850_operands[opindex_ptr[1]].flags
1964                               & V850_OPERAND_REG))
1965                         errmsg = _("syntax error: value is missing before the register name");
1966                       else
1967                         errmsg = _("syntax error: register not expected");
1968
1969                       /* If we created a symbol in the process of this
1970                          test then delete it now, so that it will not
1971                          be output with the real symbols...  */
1972                       if (exists == 0
1973                           && ex.X_op == O_symbol)
1974                         symbol_remove (ex.X_add_symbol,
1975                                        &symbol_rootP, &symbol_lastP);
1976                     }
1977                 }
1978               else if (system_register_name (&ex, FALSE, FALSE)
1979                        && (operand->flags & V850_OPERAND_SRG) == 0)
1980                 {
1981                   errmsg = _("syntax error: system register not expected");
1982                 }
1983               else if (cc_name (&ex)
1984                        && (operand->flags & V850_OPERAND_CC) == 0)
1985                 {
1986                   errmsg = _("syntax error: condition code not expected");
1987                 }
1988               else
1989                 {
1990                   expression (&ex);
1991                   /* Special case:
1992                      If we are assembling a MOV instruction and the immediate
1993                      value does not fit into the bits available then create a
1994                      fake error so that the next MOV instruction will be
1995                      selected.  This one has a 32 bit immediate field.  */
1996
1997                   if (((insn & 0x07e0) == 0x0200)
1998                       && operand->bits == 5 /* Do not match the CALLT instruction.  */
1999                       && ex.X_op == O_constant
2000                       && (ex.X_add_number < (-(1 << (operand->bits - 1)))
2001                           || ex.X_add_number > ((1 << (operand->bits - 1)) - 1)))
2002                     errmsg = _("immediate operand is too large");
2003                 }
2004
2005               if (errmsg)
2006                 goto error;
2007
2008 #if 0
2009               fprintf (stderr,
2010                        " insn: %x, operand %d, op: %d, add_number: %d\n",
2011                        insn, opindex_ptr - opcode->operands,
2012                        ex.X_op, ex.X_add_number);
2013 #endif
2014
2015               switch (ex.X_op)
2016                 {
2017                 case O_illegal:
2018                   errmsg = _("illegal operand");
2019                   goto error;
2020                 case O_absent:
2021                   errmsg = _("missing operand");
2022                   goto error;
2023                 case O_register:
2024                   if ((operand->flags
2025                        & (V850_OPERAND_REG | V850_OPERAND_SRG)) == 0)
2026                     {
2027                       errmsg = _("invalid operand");
2028                       goto error;
2029                     }
2030                   insn = v850_insert_operand (insn, operand, ex.X_add_number,
2031                                               (char *) NULL, 0,
2032                                               copy_of_instruction);
2033                   break;
2034
2035                 case O_constant:
2036                   insn = v850_insert_operand (insn, operand, ex.X_add_number,
2037                                               (char *) NULL, 0,
2038                                               copy_of_instruction);
2039                   break;
2040
2041                 default:
2042                   /* We need to generate a fixup for this expression.  */
2043                   if (fc >= MAX_INSN_FIXUPS)
2044                     as_fatal (_("too many fixups"));
2045
2046                   fixups[fc].exp     = ex;
2047                   fixups[fc].opindex = *opindex_ptr;
2048                   fixups[fc].reloc   = BFD_RELOC_UNUSED;
2049                   ++fc;
2050                   break;
2051                 }
2052             }
2053
2054           str = input_line_pointer;
2055           input_line_pointer = hold;
2056
2057           while (*str == ' ' || *str == ',' || *str == '[' || *str == ']'
2058                  || *str == ')')
2059             ++str;
2060         }
2061       match = 1;
2062
2063     error:
2064       if (match == 0)
2065         {
2066           next_opcode = opcode + 1;
2067           if (next_opcode->name != NULL
2068               && strcmp (next_opcode->name, opcode->name) == 0)
2069             {
2070               opcode = next_opcode;
2071
2072               /* Skip versions that are not supported by the target
2073                  processor.  */
2074               if ((opcode->processors & processor_mask) == 0)
2075                 goto error;
2076
2077               continue;
2078             }
2079
2080           as_bad ("%s: %s", copy_of_instruction, errmsg);
2081
2082           if (*input_line_pointer == ']')
2083             ++input_line_pointer;
2084
2085           ignore_rest_of_line ();
2086           input_line_pointer = saved_input_line_pointer;
2087           return;
2088         }
2089       break;
2090     }
2091
2092   while (ISSPACE (*str))
2093     ++str;
2094
2095   if (*str != '\0')
2096     /* xgettext:c-format  */
2097     as_bad (_("junk at end of line: `%s'"), str);
2098
2099   input_line_pointer = str;
2100
2101   /* Tie dwarf2 debug info to the address at the start of the insn.
2102      We can't do this after the insn has been output as the current
2103      frag may have been closed off.  eg. by frag_var.  */
2104   dwarf2_emit_insn (0);
2105
2106   /* Write out the instruction.  */
2107
2108   if (relaxable && fc > 0)
2109     {
2110       insn_size = 2;
2111       fc = 0;
2112
2113       if (!strcmp (opcode->name, "br"))
2114         {
2115           f = frag_var (rs_machine_dependent, 4, 2, 2,
2116                         fixups[0].exp.X_add_symbol,
2117                         fixups[0].exp.X_add_number,
2118                         (char *) fixups[0].opindex);
2119           md_number_to_chars (f, insn, insn_size);
2120           md_number_to_chars (f + 2, 0, 2);
2121         }
2122       else
2123         {
2124           f = frag_var (rs_machine_dependent, 6, 4, 0,
2125                         fixups[0].exp.X_add_symbol,
2126                         fixups[0].exp.X_add_number,
2127                         (char *) fixups[0].opindex);
2128           md_number_to_chars (f, insn, insn_size);
2129           md_number_to_chars (f + 2, 0, 4);
2130         }
2131     }
2132   else
2133     {
2134       /* Four byte insns have an opcode with the two high bits on.  */
2135       if ((insn & 0x0600) == 0x0600)
2136         insn_size = 4;
2137       else
2138         insn_size = 2;
2139
2140       /* Special case: 32 bit MOV.  */
2141       if ((insn & 0xffe0) == 0x0620)
2142         insn_size = 2;
2143
2144       f = frag_more (insn_size);
2145       md_number_to_chars (f, insn, insn_size);
2146
2147       if (extra_data_after_insn)
2148         {
2149           f = frag_more (extra_data_len);
2150           md_number_to_chars (f, extra_data, extra_data_len);
2151
2152           extra_data_after_insn = FALSE;
2153         }
2154     }
2155
2156   /* Create any fixups.  At this point we do not use a
2157      bfd_reloc_code_real_type, but instead just use the
2158      BFD_RELOC_UNUSED plus the operand index.  This lets us easily
2159      handle fixups for any operand type, although that is admittedly
2160      not a very exciting feature.  We pick a BFD reloc type in
2161      md_apply_fix3.  */
2162   for (i = 0; i < fc; i++)
2163     {
2164       const struct v850_operand *operand;
2165       bfd_reloc_code_real_type reloc;
2166
2167       operand = &v850_operands[fixups[i].opindex];
2168
2169       reloc = fixups[i].reloc;
2170
2171       if (reloc != BFD_RELOC_UNUSED)
2172         {
2173           reloc_howto_type *reloc_howto =
2174             bfd_reloc_type_lookup (stdoutput, reloc);
2175           int size;
2176           int address;
2177           fixS *fixP;
2178
2179           if (!reloc_howto)
2180             abort ();
2181
2182           size = bfd_get_reloc_size (reloc_howto);
2183
2184           /* XXX This will abort on an R_V850_8 reloc -
2185              is this reloc actually used?  */
2186           if (size != 2 && size != 4)
2187             abort ();
2188
2189           address = (f - frag_now->fr_literal) + insn_size - size;
2190
2191           if (reloc == BFD_RELOC_32)
2192             address += 2;
2193
2194           fixP = fix_new_exp (frag_now, address, size,
2195                               &fixups[i].exp,
2196                               reloc_howto->pc_relative,
2197                               reloc);
2198
2199           switch (reloc)
2200             {
2201             case BFD_RELOC_LO16:
2202             case BFD_RELOC_HI16:
2203             case BFD_RELOC_HI16_S:
2204               fixP->fx_no_overflow = 1;
2205               break;
2206             default:
2207               break;
2208             }
2209         }
2210       else
2211         {
2212           fix_new_exp (frag_now,
2213                        f - frag_now->fr_literal, 4,
2214                        & fixups[i].exp,
2215                        (operand->flags & V850_OPERAND_DISP) != 0,
2216                        (bfd_reloc_code_real_type) (fixups[i].opindex
2217                                                    + (int) BFD_RELOC_UNUSED));
2218         }
2219     }
2220
2221   input_line_pointer = saved_input_line_pointer;
2222 }
2223
2224 /* If while processing a fixup, a reloc really needs to be created
2225    then it is done here.  */
2226
2227 arelent *
2228 tc_gen_reloc (seg, fixp)
2229      asection *seg ATTRIBUTE_UNUSED;
2230      fixS *fixp;
2231 {
2232   arelent *reloc;
2233
2234   reloc               = (arelent *) xmalloc (sizeof (arelent));
2235   reloc->sym_ptr_ptr  = (asymbol **) xmalloc (sizeof (asymbol *));
2236   *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
2237   reloc->address      = fixp->fx_frag->fr_address + fixp->fx_where;
2238
2239   if (   fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY
2240       || fixp->fx_r_type == BFD_RELOC_VTABLE_INHERIT
2241       || fixp->fx_r_type == BFD_RELOC_V850_LONGCALL
2242       || fixp->fx_r_type == BFD_RELOC_V850_LONGJUMP
2243       || fixp->fx_r_type == BFD_RELOC_V850_ALIGN)
2244     reloc->addend = fixp->fx_offset;
2245   else
2246     {
2247       if (fixp->fx_r_type == BFD_RELOC_32
2248           && fixp->fx_pcrel)
2249         fixp->fx_r_type = BFD_RELOC_32_PCREL;
2250
2251       reloc->addend = fixp->fx_addnumber;
2252     }
2253
2254   reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
2255
2256   if (reloc->howto == (reloc_howto_type *) NULL)
2257     {
2258       as_bad_where (fixp->fx_file, fixp->fx_line,
2259                     /* xgettext:c-format  */
2260                     _("reloc %d not supported by object file format"),
2261                     (int) fixp->fx_r_type);
2262
2263       xfree (reloc);
2264
2265       return NULL;
2266     }
2267
2268   return reloc;
2269 }
2270
2271 void
2272 v850_handle_align (frag)
2273      fragS * frag;
2274 {
2275   if (v850_relax
2276       && frag->fr_type == rs_align
2277       && frag->fr_address + frag->fr_fix > 0
2278       && frag->fr_offset > 1
2279       && now_seg != bss_section
2280       && now_seg != v850_seg_table[SBSS_SECTION].s
2281       && now_seg != v850_seg_table[TBSS_SECTION].s
2282       && now_seg != v850_seg_table[ZBSS_SECTION].s)
2283     fix_new (frag, frag->fr_fix, 2, & abs_symbol, frag->fr_offset, 0,
2284              BFD_RELOC_V850_ALIGN);
2285 }
2286
2287 /* Return current size of variable part of frag.  */
2288
2289 int
2290 md_estimate_size_before_relax (fragp, seg)
2291      fragS *fragp;
2292      asection *seg ATTRIBUTE_UNUSED;
2293 {
2294   if (fragp->fr_subtype >= sizeof (md_relax_table) / sizeof (md_relax_table[0]))
2295     abort ();
2296
2297   return md_relax_table[fragp->fr_subtype].rlx_length;
2298 }
2299
2300 long
2301 v850_pcrel_from_section (fixp, section)
2302      fixS *fixp;
2303      segT section;
2304 {
2305   /* If the symbol is undefined, or in a section other than our own,
2306      or it is weak (in which case it may well be in another section,
2307      then let the linker figure it out.  */
2308   if (fixp->fx_addsy != (symbolS *) NULL
2309       && (! S_IS_DEFINED (fixp->fx_addsy)
2310           || S_IS_WEAK (fixp->fx_addsy)
2311           || (S_GET_SEGMENT (fixp->fx_addsy) != section)))
2312     return 0;
2313
2314   return fixp->fx_frag->fr_address + fixp->fx_where;
2315 }
2316
2317 void
2318 md_apply_fix3 (fixP, valueP, seg)
2319      fixS *fixP;
2320      valueT *valueP;
2321      segT seg ATTRIBUTE_UNUSED;
2322 {
2323   valueT value = * valueP;
2324   char *where;
2325
2326   if (fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
2327       || fixP->fx_r_type == BFD_RELOC_V850_LONGCALL
2328       || fixP->fx_r_type == BFD_RELOC_V850_LONGJUMP
2329       || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
2330     {
2331       fixP->fx_done = 0;
2332       return;
2333     }
2334
2335   if (fixP->fx_addsy == (symbolS *) NULL)
2336     fixP->fx_addnumber = value,
2337     fixP->fx_done = 1;
2338
2339   else if (fixP->fx_pcrel)
2340     fixP->fx_addnumber = fixP->fx_offset;
2341
2342   else
2343     {
2344       value = fixP->fx_offset;
2345       if (fixP->fx_subsy != (symbolS *) NULL)
2346         {
2347           if (S_GET_SEGMENT (fixP->fx_subsy) == absolute_section)
2348             value -= S_GET_VALUE (fixP->fx_subsy);
2349           else
2350             {
2351               /* We don't actually support subtracting a symbol.  */
2352               as_bad_where (fixP->fx_file, fixP->fx_line,
2353                             _("expression too complex"));
2354             }
2355         }
2356       fixP->fx_addnumber = value;
2357     }
2358
2359   if ((int) fixP->fx_r_type >= (int) BFD_RELOC_UNUSED)
2360     {
2361       int opindex;
2362       const struct v850_operand *operand;
2363       unsigned long insn;
2364
2365       opindex = (int) fixP->fx_r_type - (int) BFD_RELOC_UNUSED;
2366       operand = &v850_operands[opindex];
2367
2368       /* Fetch the instruction, insert the fully resolved operand
2369          value, and stuff the instruction back again.
2370
2371          Note the instruction has been stored in little endian
2372          format!  */
2373       where = fixP->fx_frag->fr_literal + fixP->fx_where;
2374
2375       insn = bfd_getl32 ((unsigned char *) where);
2376       insn = v850_insert_operand (insn, operand, (offsetT) value,
2377                                   fixP->fx_file, fixP->fx_line, NULL);
2378       bfd_putl32 ((bfd_vma) insn, (unsigned char *) where);
2379
2380       if (fixP->fx_done)
2381         /* Nothing else to do here.  */
2382         return;
2383
2384       /* Determine a BFD reloc value based on the operand information.
2385          We are only prepared to turn a few of the operands into relocs.  */
2386
2387       if (operand->bits == 22)
2388         fixP->fx_r_type = BFD_RELOC_V850_22_PCREL;
2389       else if (operand->bits == 9)
2390         fixP->fx_r_type = BFD_RELOC_V850_9_PCREL;
2391       else
2392         {
2393 #if 0
2394           fprintf (stderr, "bits: %d, insn: %x\n", operand->bits, insn);
2395 #endif
2396
2397           as_bad_where (fixP->fx_file, fixP->fx_line,
2398                         _("unresolved expression that must be resolved"));
2399           fixP->fx_done = 1;
2400           return;
2401         }
2402     }
2403   else if (fixP->fx_done)
2404     {
2405       /* We still have to insert the value into memory!  */
2406       where = fixP->fx_frag->fr_literal + fixP->fx_where;
2407
2408       if (fixP->fx_size == 1)
2409         *where = value & 0xff;
2410       else if (fixP->fx_size == 2)
2411         bfd_putl16 (value & 0xffff, (unsigned char *) where);
2412       else if (fixP->fx_size == 4)
2413         bfd_putl32 (value, (unsigned char *) where);
2414     }
2415 }
2416 \f
2417 /* Parse a cons expression.  We have to handle hi(), lo(), etc
2418    on the v850.  */
2419
2420 void
2421 parse_cons_expression_v850 (exp)
2422      expressionS *exp;
2423 {
2424   /* See if there's a reloc prefix like hi() we have to handle.  */
2425   hold_cons_reloc = v850_reloc_prefix (NULL);
2426
2427   /* Do normal expression parsing.  */
2428   expression (exp);
2429 }
2430
2431 /* Create a fixup for a cons expression.  If parse_cons_expression_v850
2432    found a reloc prefix, then we use that reloc, else we choose an
2433    appropriate one based on the size of the expression.  */
2434
2435 void
2436 cons_fix_new_v850 (frag, where, size, exp)
2437      fragS *frag;
2438      int where;
2439      int size;
2440      expressionS *exp;
2441 {
2442   if (hold_cons_reloc == BFD_RELOC_UNUSED)
2443     {
2444       if (size == 4)
2445         hold_cons_reloc = BFD_RELOC_32;
2446       if (size == 2)
2447         hold_cons_reloc = BFD_RELOC_16;
2448       if (size == 1)
2449         hold_cons_reloc = BFD_RELOC_8;
2450     }
2451
2452   if (exp != NULL)
2453     fix_new_exp (frag, where, size, exp, 0, hold_cons_reloc);
2454   else
2455     fix_new (frag, where, size, NULL, 0, 0, hold_cons_reloc);
2456
2457   hold_cons_reloc = BFD_RELOC_UNUSED;
2458 }
2459
2460 bfd_boolean
2461 v850_fix_adjustable (fixP)
2462      fixS *fixP;
2463 {
2464   if (fixP->fx_addsy == NULL)
2465     return 1;
2466
2467   /* Don't adjust function names.  */
2468   if (S_IS_FUNCTION (fixP->fx_addsy))
2469     return 0;
2470
2471   /* We need the symbol name for the VTABLE entries.  */
2472   if (fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
2473       || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
2474     return 0;
2475
2476   return 1;
2477 }
2478
2479 int
2480 v850_force_relocation (fixP)
2481      struct fix *fixP;
2482 {
2483   if (fixP->fx_r_type == BFD_RELOC_V850_LONGCALL
2484       || fixP->fx_r_type == BFD_RELOC_V850_LONGJUMP)
2485     return 1;
2486
2487   if (v850_relax
2488       && (fixP->fx_pcrel
2489           || fixP->fx_r_type == BFD_RELOC_V850_ALIGN
2490           || fixP->fx_r_type == BFD_RELOC_V850_22_PCREL
2491           || fixP->fx_r_type == BFD_RELOC_V850_9_PCREL
2492           || fixP->fx_r_type >= BFD_RELOC_UNUSED))
2493     return 1;
2494
2495   return generic_force_reloc (fixP);
2496 }