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     }
 483 }
 484
 485 static void v850_longcode PARAMS ((int));
 486
 487 static void
 488 v850_longcode (type)
 489      int type;
 490 {
 491   expressionS ex;
 492
 493   if (! v850_relax)
 494     {
 495       if (type == 1)
 496         as_warn (".longcall pseudo-op seen when not relaxing");
 497       else
 498         as_warn (".longjump pseudo-op seen when not relaxing");
 499     }
 500
 501   expression (&ex);
 502
 503   if (ex.X_op != O_symbol || ex.X_add_number != 0)
 504     {
 505       as_bad ("bad .longcall format");
 506       ignore_rest_of_line ();
 507
 508       return;
 509     }
 510
 511   if (type == 1)
 512     fix_new_exp (frag_now, frag_now_fix (), 4, & ex, 1,
 513                  BFD_RELOC_V850_LONGCALL);
 514   else
 515     fix_new_exp (frag_now, frag_now_fix (), 4, & ex, 1,
 516                  BFD_RELOC_V850_LONGJUMP);
 517
 518   demand_empty_rest_of_line ();
 519 }
 520
 521 /* The target specific pseudo-ops which we support.  */
 522 const pseudo_typeS md_pseudo_table[] =
 523 {
 524   { "sdata",            v850_seg,               SDATA_SECTION           },
 525   { "tdata",            v850_seg,               TDATA_SECTION           },
 526   { "zdata",            v850_seg,               ZDATA_SECTION           },
 527   { "sbss",             v850_seg,               SBSS_SECTION            },
 528   { "tbss",             v850_seg,               TBSS_SECTION            },
 529   { "zbss",             v850_seg,               ZBSS_SECTION            },
 530   { "rosdata",          v850_seg,               ROSDATA_SECTION         },
 531   { "rozdata",          v850_seg,               ROZDATA_SECTION         },
 532   { "bss",              v850_seg,               BSS_SECTION             },
 533   { "offset",           v850_offset,            0                       },
 534   { "word",             cons,                   4                       },
 535   { "zcomm",            v850_comm,              ZCOMMON_SECTION         },
 536   { "scomm",            v850_comm,              SCOMMON_SECTION         },
 537   { "tcomm",            v850_comm,              TCOMMON_SECTION         },
 538   { "v850",             set_machine,            0                       },
 539   { "call_table_data",  v850_seg,               CALL_TABLE_DATA_SECTION },
 540   { "call_table_text",  v850_seg,               CALL_TABLE_TEXT_SECTION },
 541   { "v850e",            set_machine,            bfd_mach_v850e          },
 542   { "file", (void (*) PARAMS ((int))) dwarf2_directive_file, 0 },
 543   { "loc",              dwarf2_directive_loc,   0                       },
 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 epxressions whoes bits indicate the
 941    registers in the lists.  The LSB in the expression refers to
 942    the lowest numbered permissable 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, _("  -mv850any                 The code is generic, despite any processor specific instructions\n"));
1162   fprintf (stream, _("  -mrelax                   Enable relaxation\n"));
1163
1164 }
1165
1166 int
1167 md_parse_option (c, arg)
1168      int c;
1169      char *arg;
1170 {
1171   if (c != 'm')
1172     {
1173       if (c != 'a')
1174         /* xgettext:c-format  */
1175         fprintf (stderr, _("unknown command line option: -%c%s\n"), c, arg);
1176       return 0;
1177     }
1178
1179   if (strcmp (arg, "warn-signed-overflow") == 0)
1180     {
1181       warn_signed_overflows = TRUE;
1182     }
1183   else if (strcmp (arg, "warn-unsigned-overflow") == 0)
1184     {
1185       warn_unsigned_overflows = TRUE;
1186     }
1187   else if (strcmp (arg, "v850") == 0)
1188     {
1189       machine = 0;
1190       processor_mask = PROCESSOR_V850;
1191     }
1192   else if (strcmp (arg, "v850e") == 0)
1193     {
1194       machine = bfd_mach_v850e;
1195       processor_mask = PROCESSOR_V850E;
1196     }
1197   else if (strcmp (arg, "v850any") == 0)
1198     {
1199       /* Tell the world that this is for any v850 chip.  */
1200       machine = 0;
1201
1202       /* But support instructions for the extended versions.  */
1203       processor_mask = PROCESSOR_V850E;
1204     }
1205   else if (strcmp (arg, "relax") == 0)
1206     v850_relax = 1;
1207   else
1208     {
1209       /* xgettext:c-format  */
1210       fprintf (stderr, _("unknown command line option: -%c%s\n"), c, arg);
1211       return 0;
1212     }
1213
1214   return 1;
1215 }
1216
1217 symbolS *
1218 md_undefined_symbol (name)
1219      char *name ATTRIBUTE_UNUSED;
1220 {
1221   return 0;
1222 }
1223
1224 char *
1225 md_atof (type, litp, sizep)
1226      int type;
1227      char *litp;
1228      int *sizep;
1229 {
1230   int prec;
1231   LITTLENUM_TYPE words[4];
1232   char *t;
1233   int i;
1234
1235   switch (type)
1236     {
1237     case 'f':
1238       prec = 2;
1239       break;
1240
1241     case 'd':
1242       prec = 4;
1243       break;
1244
1245     default:
1246       *sizep = 0;
1247       return _("bad call to md_atof");
1248     }
1249
1250   t = atof_ieee (input_line_pointer, type, words);
1251   if (t)
1252     input_line_pointer = t;
1253
1254   *sizep = prec * 2;
1255
1256   for (i = prec - 1; i >= 0; i--)
1257     {
1258       md_number_to_chars (litp, (valueT) words[i], 2);
1259       litp += 2;
1260     }
1261
1262   return NULL;
1263 }
1264
1265 /* Very gross.  */
1266
1267 void
1268 md_convert_frag (abfd, sec, fragP)
1269      bfd *abfd ATTRIBUTE_UNUSED;
1270      asection *sec;
1271      fragS *fragP;
1272 {
1273   subseg_change (sec, 0);
1274
1275   /* In range conditional or unconditional branch.  */
1276   if (fragP->fr_subtype == 0 || fragP->fr_subtype == 2)
1277     {
1278       fix_new (fragP, fragP->fr_fix, 2, fragP->fr_symbol,
1279                fragP->fr_offset, 1, BFD_RELOC_UNUSED + (int)fragP->fr_opcode);
1280       fragP->fr_fix += 2;
1281     }
1282   /* Out of range conditional branch.  Emit a branch around a jump.  */
1283   else if (fragP->fr_subtype == 1)
1284     {
1285       unsigned char *buffer =
1286         (unsigned char *) (fragP->fr_fix + fragP->fr_literal);
1287
1288       /* Reverse the condition of the first branch.  */
1289       buffer[0] ^= 0x08;
1290       /* Mask off all the displacement bits.  */
1291       buffer[0] &= 0x8f;
1292       buffer[1] &= 0x07;
1293       /* Now set the displacement bits so that we branch
1294          around the unconditional branch.  */
1295       buffer[0] |= 0x30;
1296
1297       /* Now create the unconditional branch + fixup to the final
1298          target.  */
1299       md_number_to_chars (buffer + 2, 0x00000780, 4);
1300       fix_new (fragP, fragP->fr_fix + 2, 4, fragP->fr_symbol,
1301                fragP->fr_offset, 1, BFD_RELOC_UNUSED +
1302                (int) fragP->fr_opcode + 1);
1303       fragP->fr_fix += 6;
1304     }
1305   /* Out of range unconditional branch.  Emit a jump.  */
1306   else if (fragP->fr_subtype == 3)
1307     {
1308       md_number_to_chars (fragP->fr_fix + fragP->fr_literal, 0x00000780, 4);
1309       fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol,
1310                fragP->fr_offset, 1, BFD_RELOC_UNUSED +
1311                (int) fragP->fr_opcode + 1);
1312       fragP->fr_fix += 4;
1313     }
1314   else
1315     abort ();
1316 }
1317
1318 valueT
1319 md_section_align (seg, addr)
1320      asection *seg;
1321      valueT addr;
1322 {
1323   int align = bfd_get_section_alignment (stdoutput, seg);
1324   return ((addr + (1 << align) - 1) & (-1 << align));
1325 }
1326
1327 void
1328 md_begin ()
1329 {
1330   char *prev_name = "";
1331   const struct v850_opcode *op;
1332
1333   if (strncmp (TARGET_CPU, "v850e", 5) == 0)
1334     {
1335       if (machine == -1)
1336         machine = bfd_mach_v850e;
1337
1338       if (processor_mask == -1)
1339         processor_mask = PROCESSOR_V850E;
1340     }
1341   else if (strncmp (TARGET_CPU, "v850", 4) == 0)
1342     {
1343       if (machine == -1)
1344         machine = 0;
1345
1346       if (processor_mask == -1)
1347         processor_mask = PROCESSOR_V850;
1348     }
1349   else
1350     /* xgettext:c-format  */
1351     as_bad (_("Unable to determine default target processor from string: %s"),
1352             TARGET_CPU);
1353
1354   v850_hash = hash_new ();
1355
1356   /* Insert unique names into hash table.  The V850 instruction set
1357      has many identical opcode names that have different opcodes based
1358      on the operands.  This hash table then provides a quick index to
1359      the first opcode with a particular name in the opcode table.  */
1360   op = v850_opcodes;
1361   while (op->name)
1362     {
1363       if (strcmp (prev_name, op->name))
1364         {
1365           prev_name = (char *) op->name;
1366           hash_insert (v850_hash, op->name, (char *) op);
1367         }
1368       op++;
1369     }
1370
1371   v850_seg_table[BSS_SECTION].s = bss_section;
1372   bfd_set_arch_mach (stdoutput, TARGET_ARCH, machine);
1373 }
1374
1375 static bfd_reloc_code_real_type handle_ctoff
1376   PARAMS ((const struct v850_operand *));
1377
1378 static bfd_reloc_code_real_type
1379 handle_ctoff (operand)
1380      const struct v850_operand *operand;
1381 {
1382   if (operand == NULL)
1383     return BFD_RELOC_V850_CALLT_16_16_OFFSET;
1384
1385   if (operand->bits != 6
1386       || operand->shift != 0)
1387     {
1388       as_bad (_("ctoff() relocation used on an instruction which does not support it"));
1389       return BFD_RELOC_64;  /* Used to indicate an error condition.  */
1390     }
1391
1392   return BFD_RELOC_V850_CALLT_6_7_OFFSET;
1393 }
1394
1395 static bfd_reloc_code_real_type handle_sdaoff
1396   PARAMS ((const struct v850_operand *));
1397
1398 static bfd_reloc_code_real_type
1399 handle_sdaoff (operand)
1400      const struct v850_operand *operand;
1401 {
1402   if (operand == NULL)
1403     return BFD_RELOC_V850_SDA_16_16_OFFSET;
1404
1405   if (operand->bits == 15 && operand->shift == 17)
1406     return BFD_RELOC_V850_SDA_15_16_OFFSET;
1407
1408   if (operand->bits == -1)
1409     return BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET;
1410
1411   if (operand->bits != 16
1412       || operand->shift != 16)
1413     {
1414       as_bad (_("sdaoff() relocation used on an instruction which does not support it"));
1415       return BFD_RELOC_64;  /* Used to indicate an error condition.  */
1416     }
1417
1418   return BFD_RELOC_V850_SDA_16_16_OFFSET;
1419 }
1420
1421 static bfd_reloc_code_real_type handle_zdaoff
1422   PARAMS ((const struct v850_operand *));
1423
1424 static bfd_reloc_code_real_type
1425 handle_zdaoff (operand)
1426      const struct v850_operand *operand;
1427 {
1428   if (operand == NULL)
1429     return BFD_RELOC_V850_ZDA_16_16_OFFSET;
1430
1431   if (operand->bits == 15 && operand->shift == 17)
1432     return BFD_RELOC_V850_ZDA_15_16_OFFSET;
1433
1434   if (operand->bits == -1)
1435     return BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET;
1436
1437   if (operand->bits != 16
1438       || operand->shift != 16)
1439     {
1440       as_bad (_("zdaoff() relocation used on an instruction which does not support it"));
1441       /* Used to indicate an error condition.  */
1442       return BFD_RELOC_64;
1443     }
1444
1445   return BFD_RELOC_V850_ZDA_16_16_OFFSET;
1446 }
1447
1448 static bfd_reloc_code_real_type handle_tdaoff
1449   PARAMS ((const struct v850_operand *));
1450
1451 static bfd_reloc_code_real_type
1452 handle_tdaoff (operand)
1453      const struct v850_operand *operand;
1454 {
1455   if (operand == NULL)
1456     /* Data item, not an instruction.  */
1457     return BFD_RELOC_V850_TDA_7_7_OFFSET;
1458
1459   if (operand->bits == 6 && operand->shift == 1)
1460     /* sld.w/sst.w, operand: D8_6  */
1461     return BFD_RELOC_V850_TDA_6_8_OFFSET;
1462
1463   if (operand->bits == 4 && operand->insert != NULL)
1464     /* sld.hu, operand: D5-4  */
1465     return BFD_RELOC_V850_TDA_4_5_OFFSET;
1466
1467   if (operand->bits == 4 && operand->insert == NULL)
1468     /* sld.bu, operand: D4   */
1469     return BFD_RELOC_V850_TDA_4_4_OFFSET;
1470
1471   if (operand->bits == 16 && operand->shift == 16)
1472     /* set1 & chums, operands: D16  */
1473     return BFD_RELOC_V850_TDA_16_16_OFFSET;
1474
1475   if (operand->bits != 7)
1476     {
1477       as_bad (_("tdaoff() relocation used on an instruction which does not support it"));
1478       /* Used to indicate an error condition.  */
1479       return BFD_RELOC_64;
1480     }
1481
1482   return  operand->insert != NULL
1483     ? BFD_RELOC_V850_TDA_7_8_OFFSET     /* sld.h/sst.h, operand: D8_7  */
1484     : BFD_RELOC_V850_TDA_7_7_OFFSET;    /* sld.b/sst.b, opreand: D7    */
1485 }
1486
1487 /* Warning: The code in this function relies upon the definitions
1488    in the v850_operands[] array (defined in opcodes/v850-opc.c)
1489    matching the hard coded values contained herein.  */
1490
1491 static bfd_reloc_code_real_type v850_reloc_prefix
1492   PARAMS ((const struct v850_operand *));
1493
1494 static bfd_reloc_code_real_type
1495 v850_reloc_prefix (operand)
1496      const struct v850_operand *operand;
1497 {
1498   bfd_boolean paren_skipped = FALSE;
1499
1500   /* Skip leading opening parenthesis.  */
1501   if (*input_line_pointer == '(')
1502     {
1503       ++input_line_pointer;
1504       paren_skipped = TRUE;
1505     }
1506
1507 #define CHECK_(name, reloc)                                             \
1508   if (strncmp (input_line_pointer, name "(", strlen (name) + 1) == 0)   \
1509     {                                                                   \
1510       input_line_pointer += strlen (name);                              \
1511       return reloc;                                                     \
1512     }
1513
1514   CHECK_ ("hi0",    BFD_RELOC_HI16         );
1515   CHECK_ ("hi",     BFD_RELOC_HI16_S       );
1516   CHECK_ ("lo",     BFD_RELOC_LO16         );
1517   CHECK_ ("sdaoff", handle_sdaoff (operand));
1518   CHECK_ ("zdaoff", handle_zdaoff (operand));
1519   CHECK_ ("tdaoff", handle_tdaoff (operand));
1520   CHECK_ ("hilo",   BFD_RELOC_32           );
1521   CHECK_ ("ctoff",  handle_ctoff (operand) );
1522
1523   /* Restore skipped parenthesis.  */
1524   if (paren_skipped)
1525     --input_line_pointer;
1526
1527   return BFD_RELOC_UNUSED;
1528 }
1529
1530 /* Insert an operand value into an instruction.  */
1531
1532 static unsigned long v850_insert_operand
1533   PARAMS ((unsigned long, const struct v850_operand *, offsetT, char *,
1534            unsigned int, char *));
1535
1536 static unsigned long
1537 v850_insert_operand (insn, operand, val, file, line, str)
1538      unsigned long insn;
1539      const struct v850_operand *operand;
1540      offsetT val;
1541      char *file;
1542      unsigned int line;
1543      char *str;
1544 {
1545   if (operand->insert)
1546     {
1547       const char *message = NULL;
1548
1549       insn = operand->insert (insn, val, &message);
1550       if (message != NULL)
1551         {
1552           if ((operand->flags & V850_OPERAND_SIGNED)
1553               && ! warn_signed_overflows
1554               && strstr (message, "out of range") != NULL)
1555             {
1556               /* Skip warning...  */
1557             }
1558           else if ((operand->flags & V850_OPERAND_SIGNED) == 0
1559                    && ! warn_unsigned_overflows
1560                    && strstr (message, "out of range") != NULL)
1561             {
1562               /* Skip warning...  */
1563             }
1564           else if (str)
1565             {
1566               if (file == (char *) NULL)
1567                 as_warn ("%s: %s", str, message);
1568               else
1569                 as_warn_where (file, line, "%s: %s", str, message);
1570             }
1571           else
1572             {
1573               if (file == (char *) NULL)
1574                 as_warn (message);
1575               else
1576                 as_warn_where (file, line, message);
1577             }
1578         }
1579     }
1580   else
1581     {
1582       if (operand->bits != 32)
1583         {
1584           long min, max;
1585
1586           if ((operand->flags & V850_OPERAND_SIGNED) != 0)
1587             {
1588               if (! warn_signed_overflows)
1589                 max = (1 << operand->bits) - 1;
1590               else
1591                 max = (1 << (operand->bits - 1)) - 1;
1592
1593               min = -(1 << (operand->bits - 1));
1594             }
1595           else
1596             {
1597               max = (1 << operand->bits) - 1;
1598
1599               if (! warn_unsigned_overflows)
1600                 min = -(1 << (operand->bits - 1));
1601               else
1602                 min = 0;
1603             }
1604
1605           if (val < (offsetT) min || val > (offsetT) max)
1606             {
1607               /* xgettext:c-format  */
1608               const char *err =
1609                 _("operand out of range (%s not between %ld and %ld)");
1610               char buf[100];
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                 {
1623                   sprintf (buf, "%s: ", str);
1624
1625                   sprint_value (buf + strlen (buf), val);
1626                 }
1627               else
1628                 sprint_value (buf, val);
1629
1630               if (file == (char *) NULL)
1631                 as_warn (err, buf, min, max);
1632               else
1633                 as_warn_where (file, line, err, buf, min, max);
1634             }
1635         }
1636
1637       insn |= (((long) val & ((1 << operand->bits) - 1)) << operand->shift);
1638     }
1639
1640   return insn;
1641 }
1642 \f
1643 static char copy_of_instruction[128];
1644
1645 void
1646 md_assemble (str)
1647      char *str;
1648 {
1649   char *s;
1650   char *start_of_operands;
1651   struct v850_opcode *opcode;
1652   struct v850_opcode *next_opcode;
1653   const unsigned char *opindex_ptr;
1654   int next_opindex;
1655   int relaxable = 0;
1656   unsigned long insn;
1657   unsigned long insn_size;
1658   char *f;
1659   int i;
1660   int match;
1661   bfd_boolean extra_data_after_insn = FALSE;
1662   unsigned extra_data_len = 0;
1663   unsigned long extra_data = 0;
1664   char *saved_input_line_pointer;
1665
1666   strncpy (copy_of_instruction, str, sizeof (copy_of_instruction) - 1);
1667
1668   /* Get the opcode.  */
1669   for (s = str; *s != '\0' && ! ISSPACE (*s); s++)
1670     continue;
1671
1672   if (*s != '\0')
1673     *s++ = '\0';
1674
1675   /* Find the first opcode with the proper name.  */
1676   opcode = (struct v850_opcode *) hash_find (v850_hash, str);
1677   if (opcode == NULL)
1678     {
1679       /* xgettext:c-format  */
1680       as_bad (_("Unrecognized opcode: `%s'"), str);
1681       ignore_rest_of_line ();
1682       return;
1683     }
1684
1685   str = s;
1686   while (ISSPACE (*str))
1687     ++str;
1688
1689   start_of_operands = str;
1690
1691   saved_input_line_pointer = input_line_pointer;
1692
1693   for (;;)
1694     {
1695       const char *errmsg = NULL;
1696
1697       match = 0;
1698
1699       if ((opcode->processors & processor_mask) == 0)
1700         {
1701           errmsg = _("Target processor does not support this instruction.");
1702           goto error;
1703         }
1704
1705       relaxable = 0;
1706       fc = 0;
1707       next_opindex = 0;
1708       insn = opcode->opcode;
1709       extra_data_after_insn = FALSE;
1710
1711       input_line_pointer = str = start_of_operands;
1712
1713       for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++)
1714         {
1715           const struct v850_operand *operand;
1716           char *hold;
1717           expressionS ex;
1718           bfd_reloc_code_real_type reloc;
1719
1720           if (next_opindex == 0)
1721             {
1722               operand = &v850_operands[*opindex_ptr];
1723             }
1724           else
1725             {
1726               operand = &v850_operands[next_opindex];
1727               next_opindex = 0;
1728             }
1729
1730           errmsg = NULL;
1731
1732           while (*str == ' ' || *str == ',' || *str == '[' || *str == ']')
1733             ++str;
1734
1735           if (operand->flags & V850_OPERAND_RELAX)
1736             relaxable = 1;
1737
1738           /* Gather the operand.  */
1739           hold = input_line_pointer;
1740           input_line_pointer = str;
1741
1742           /* lo(), hi(), hi0(), etc...  */
1743           if ((reloc = v850_reloc_prefix (operand)) != BFD_RELOC_UNUSED)
1744             {
1745               /* This is a fake reloc, used to indicate an error condition.  */
1746               if (reloc == BFD_RELOC_64)
1747                 {
1748                   match = 1;
1749                   goto error;
1750                 }
1751
1752               expression (&ex);
1753
1754               if (ex.X_op == O_constant)
1755                 {
1756                   switch (reloc)
1757                     {
1758                     case BFD_RELOC_V850_ZDA_16_16_OFFSET:
1759                       /* To cope with "not1 7, zdaoff(0xfffff006)[r0]"
1760                          and the like.  */
1761                       /* Fall through.  */
1762
1763                     case BFD_RELOC_LO16:
1764                       {
1765                         /* Truncate, then sign extend the value.  */
1766                         ex.X_add_number = SEXT16 (ex.X_add_number);
1767                         break;
1768                       }
1769
1770                     case BFD_RELOC_HI16:
1771                       {
1772                         /* Truncate, then sign extend the value.  */
1773                         ex.X_add_number = SEXT16 (ex.X_add_number >> 16);
1774                         break;
1775                       }
1776
1777                     case BFD_RELOC_HI16_S:
1778                       {
1779                         /* Truncate, then sign extend the value.  */
1780                         int temp = (ex.X_add_number >> 16) & 0xffff;
1781
1782                         temp += (ex.X_add_number >> 15) & 1;
1783
1784                         ex.X_add_number = SEXT16 (temp);
1785                         break;
1786                       }
1787
1788                     case BFD_RELOC_32:
1789                       if ((operand->flags & V850E_IMMEDIATE32) == 0)
1790                         {
1791                           errmsg = _("immediate operand is too large");
1792                           goto error;
1793                         }
1794
1795                       extra_data_after_insn = TRUE;
1796                       extra_data_len        = 4;
1797                       extra_data            = 0;
1798                       break;
1799
1800                     default:
1801                       fprintf (stderr, "reloc: %d\n", reloc);
1802                       as_bad (_("AAARG -> unhandled constant reloc"));
1803                       break;
1804                     }
1805
1806                   if (fc > MAX_INSN_FIXUPS)
1807                     as_fatal (_("too many fixups"));
1808
1809                   fixups[fc].exp     = ex;
1810                   fixups[fc].opindex = *opindex_ptr;
1811                   fixups[fc].reloc   = reloc;
1812                   fc++;
1813                 }
1814               else
1815                 {
1816                   if (reloc == BFD_RELOC_32)
1817                     {
1818                       if ((operand->flags & V850E_IMMEDIATE32) == 0)
1819                         {
1820                           errmsg = _("immediate operand is too large");
1821                           goto error;
1822                         }
1823
1824                       extra_data_after_insn = TRUE;
1825                       extra_data_len        = 4;
1826                       extra_data            = ex.X_add_number;
1827                     }
1828
1829                   if (fc > MAX_INSN_FIXUPS)
1830                     as_fatal (_("too many fixups"));
1831
1832                   fixups[fc].exp     = ex;
1833                   fixups[fc].opindex = *opindex_ptr;
1834                   fixups[fc].reloc   = reloc;
1835                   fc++;
1836                 }
1837             }
1838           else
1839             {
1840               errmsg = NULL;
1841
1842               if ((operand->flags & V850_OPERAND_REG) != 0)
1843                 {
1844                   if (!register_name (&ex))
1845                     {
1846                       errmsg = _("invalid register name");
1847                     }
1848                   else if ((operand->flags & V850_NOT_R0)
1849                            && ex.X_add_number == 0)
1850                     {
1851                       errmsg = _("register r0 cannot be used here");
1852
1853                       /* Force an error message to be generated by
1854                          skipping over any following potential matches
1855                          for this opcode.  */
1856                       opcode += 3;
1857                     }
1858                 }
1859               else if ((operand->flags & V850_OPERAND_SRG) != 0)
1860                 {
1861                   if (!system_register_name (&ex, TRUE, FALSE))
1862                     {
1863                       errmsg = _("invalid system register name");
1864                     }
1865                 }
1866               else if ((operand->flags & V850_OPERAND_EP) != 0)
1867                 {
1868                   char *start = input_line_pointer;
1869                   char c = get_symbol_end ();
1870
1871                   if (strcmp (start, "ep") != 0 && strcmp (start, "r30") != 0)
1872                     {
1873                       /* Put things back the way we found them.  */
1874                       *input_line_pointer = c;
1875                       input_line_pointer = start;
1876                       errmsg = _("expected EP register");
1877                       goto error;
1878                     }
1879
1880                   *input_line_pointer = c;
1881                   str = input_line_pointer;
1882                   input_line_pointer = hold;
1883
1884                   while (*str == ' ' || *str == ','
1885                          || *str == '[' || *str == ']')
1886                     ++str;
1887                   continue;
1888                 }
1889               else if ((operand->flags & V850_OPERAND_CC) != 0)
1890                 {
1891                   if (!cc_name (&ex))
1892                     {
1893                       errmsg = _("invalid condition code name");
1894                     }
1895                 }
1896               else if (operand->flags & V850E_PUSH_POP)
1897                 {
1898                   errmsg = parse_register_list (&insn, operand);
1899
1900                   /* The parse_register_list() function has already done
1901                      everything, so fake a dummy expression.  */
1902                   ex.X_op         = O_constant;
1903                   ex.X_add_number = 0;
1904                 }
1905               else if (operand->flags & V850E_IMMEDIATE16)
1906                 {
1907                   expression (&ex);
1908
1909                   if (ex.X_op != O_constant)
1910                     errmsg = _("constant expression expected");
1911                   else if (ex.X_add_number & 0xffff0000)
1912                     {
1913                       if (ex.X_add_number & 0xffff)
1914                         errmsg = _("constant too big to fit into instruction");
1915                       else if ((insn & 0x001fffc0) == 0x00130780)
1916                         ex.X_add_number >>= 16;
1917                       else
1918                         errmsg = _("constant too big to fit into instruction");
1919                     }
1920
1921                   extra_data_after_insn = TRUE;
1922                   extra_data_len        = 2;
1923                   extra_data            = ex.X_add_number;
1924                   ex.X_add_number       = 0;
1925                 }
1926               else if (operand->flags & V850E_IMMEDIATE32)
1927                 {
1928                   expression (&ex);
1929
1930                   if (ex.X_op != O_constant)
1931                     errmsg = _("constant expression expected");
1932
1933                   extra_data_after_insn = TRUE;
1934                   extra_data_len        = 4;
1935                   extra_data            = ex.X_add_number;
1936                   ex.X_add_number       = 0;
1937                 }
1938               else if (register_name (&ex)
1939                        && (operand->flags & V850_OPERAND_REG) == 0)
1940                 {
1941                   char c;
1942                   int exists = 0;
1943
1944                   /* It is possible that an alias has been defined that
1945                      matches a register name.  For example the code may
1946                      include a ".set ZERO, 0" directive, which matches
1947                      the register name "zero".  Attempt to reparse the
1948                      field as an expression, and only complain if we
1949                      cannot generate a constant.  */
1950
1951                   input_line_pointer = str;
1952
1953                   c = get_symbol_end ();
1954
1955                   if (symbol_find (str) != NULL)
1956                     exists = 1;
1957
1958                   *input_line_pointer = c;
1959                   input_line_pointer = str;
1960
1961                   expression (&ex);
1962
1963                   if (ex.X_op != O_constant)
1964                     {
1965                       /* If this register is actually occuring too early on
1966                          the parsing of the instruction, (because another
1967                          field is missing) then report this.  */
1968                       if (opindex_ptr[1] != 0
1969                           && (v850_operands[opindex_ptr[1]].flags
1970                               & V850_OPERAND_REG))
1971                         errmsg = _("syntax error: value is missing before the register name");
1972                       else
1973                         errmsg = _("syntax error: register not expected");
1974
1975                       /* If we created a symbol in the process of this
1976                          test then delete it now, so that it will not
1977                          be output with the real symbols...  */
1978                       if (exists == 0
1979                           && ex.X_op == O_symbol)
1980                         symbol_remove (ex.X_add_symbol,
1981                                        &symbol_rootP, &symbol_lastP);
1982                     }
1983                 }
1984               else if (system_register_name (&ex, FALSE, FALSE)
1985                        && (operand->flags & V850_OPERAND_SRG) == 0)
1986                 {
1987                   errmsg = _("syntax error: system register not expected");
1988                 }
1989               else if (cc_name (&ex)
1990                        && (operand->flags & V850_OPERAND_CC) == 0)
1991                 {
1992                   errmsg = _("syntax error: condition code not expected");
1993                 }
1994               else
1995                 {
1996                   expression (&ex);
1997                   /* Special case:
1998                      If we are assembling a MOV instruction and the immediate
1999                      value does not fit into the bits available then create a
2000                      fake error so that the next MOV instruction will be
2001                      selected.  This one has a 32 bit immediate field.  */
2002
2003                   if (((insn & 0x07e0) == 0x0200)
2004                       && operand->bits == 5 /* Do not match the CALLT instruction.  */
2005                       && ex.X_op == O_constant
2006                       && (ex.X_add_number < (-(1 << (operand->bits - 1)))
2007                           || ex.X_add_number > ((1 << (operand->bits - 1)) - 1)))
2008                     errmsg = _("immediate operand is too large");
2009                 }
2010
2011               if (errmsg)
2012                 goto error;
2013
2014 #if 0
2015               fprintf (stderr,
2016                        " insn: %x, operand %d, op: %d, add_number: %d\n",
2017                        insn, opindex_ptr - opcode->operands,
2018                        ex.X_op, ex.X_add_number);
2019 #endif
2020
2021               switch (ex.X_op)
2022                 {
2023                 case O_illegal:
2024                   errmsg = _("illegal operand");
2025                   goto error;
2026                 case O_absent:
2027                   errmsg = _("missing operand");
2028                   goto error;
2029                 case O_register:
2030                   if ((operand->flags
2031                        & (V850_OPERAND_REG | V850_OPERAND_SRG)) == 0)
2032                     {
2033                       errmsg = _("invalid operand");
2034                       goto error;
2035                     }
2036                   insn = v850_insert_operand (insn, operand, ex.X_add_number,
2037                                               (char *) NULL, 0,
2038                                               copy_of_instruction);
2039                   break;
2040
2041                 case O_constant:
2042                   insn = v850_insert_operand (insn, operand, ex.X_add_number,
2043                                               (char *) NULL, 0,
2044                                               copy_of_instruction);
2045                   break;
2046
2047                 default:
2048                   /* We need to generate a fixup for this expression.  */
2049                   if (fc >= MAX_INSN_FIXUPS)
2050                     as_fatal (_("too many fixups"));
2051
2052                   fixups[fc].exp     = ex;
2053                   fixups[fc].opindex = *opindex_ptr;
2054                   fixups[fc].reloc   = BFD_RELOC_UNUSED;
2055                   ++fc;
2056                   break;
2057                 }
2058             }
2059
2060           str = input_line_pointer;
2061           input_line_pointer = hold;
2062
2063           while (*str == ' ' || *str == ',' || *str == '[' || *str == ']'
2064                  || *str == ')')
2065             ++str;
2066         }
2067       match = 1;
2068
2069     error:
2070       if (match == 0)
2071         {
2072           next_opcode = opcode + 1;
2073           if (next_opcode->name != NULL
2074               && strcmp (next_opcode->name, opcode->name) == 0)
2075             {
2076               opcode = next_opcode;
2077
2078               /* Skip versions that are not supported by the target
2079                  processor.  */
2080               if ((opcode->processors & processor_mask) == 0)
2081                 goto error;
2082
2083               continue;
2084             }
2085
2086           as_bad ("%s: %s", copy_of_instruction, errmsg);
2087
2088           if (*input_line_pointer == ']')
2089             ++input_line_pointer;
2090
2091           ignore_rest_of_line ();
2092           input_line_pointer = saved_input_line_pointer;
2093           return;
2094         }
2095       break;
2096     }
2097
2098   while (ISSPACE (*str))
2099     ++str;
2100
2101   if (*str != '\0')
2102     /* xgettext:c-format  */
2103     as_bad (_("junk at end of line: `%s'"), str);
2104
2105   input_line_pointer = str;
2106
2107   /* Tie dwarf2 debug info to the address at the start of the insn.
2108      We can't do this after the insn has been output as the current
2109      frag may have been closed off.  eg. by frag_var.  */
2110   dwarf2_emit_insn (0);
2111
2112   /* Write out the instruction.  */
2113
2114   if (relaxable && fc > 0)
2115     {
2116       insn_size = 2;
2117       fc = 0;
2118
2119       if (!strcmp (opcode->name, "br"))
2120         {
2121           f = frag_var (rs_machine_dependent, 4, 2, 2,
2122                         fixups[0].exp.X_add_symbol,
2123                         fixups[0].exp.X_add_number,
2124                         (char *) fixups[0].opindex);
2125           md_number_to_chars (f, insn, insn_size);
2126           md_number_to_chars (f + 2, 0, 2);
2127         }
2128       else
2129         {
2130           f = frag_var (rs_machine_dependent, 6, 4, 0,
2131                         fixups[0].exp.X_add_symbol,
2132                         fixups[0].exp.X_add_number,
2133                         (char *) fixups[0].opindex);
2134           md_number_to_chars (f, insn, insn_size);
2135           md_number_to_chars (f + 2, 0, 4);
2136         }
2137     }
2138   else
2139     {
2140       /* Four byte insns have an opcode with the two high bits on.  */
2141       if ((insn & 0x0600) == 0x0600)
2142         insn_size = 4;
2143       else
2144         insn_size = 2;
2145
2146       /* Special case: 32 bit MOV.  */
2147       if ((insn & 0xffe0) == 0x0620)
2148         insn_size = 2;
2149
2150       f = frag_more (insn_size);
2151       md_number_to_chars (f, insn, insn_size);
2152
2153       if (extra_data_after_insn)
2154         {
2155           f = frag_more (extra_data_len);
2156           md_number_to_chars (f, extra_data, extra_data_len);
2157
2158           extra_data_after_insn = FALSE;
2159         }
2160     }
2161
2162   /* Create any fixups.  At this point we do not use a
2163      bfd_reloc_code_real_type, but instead just use the
2164      BFD_RELOC_UNUSED plus the operand index.  This lets us easily
2165      handle fixups for any operand type, although that is admittedly
2166      not a very exciting feature.  We pick a BFD reloc type in
2167      md_apply_fix3.  */
2168   for (i = 0; i < fc; i++)
2169     {
2170       const struct v850_operand *operand;
2171       bfd_reloc_code_real_type reloc;
2172
2173       operand = &v850_operands[fixups[i].opindex];
2174
2175       reloc = fixups[i].reloc;
2176
2177       if (reloc != BFD_RELOC_UNUSED)
2178         {
2179           reloc_howto_type *reloc_howto =
2180             bfd_reloc_type_lookup (stdoutput, reloc);
2181           int size;
2182           int address;
2183           fixS *fixP;
2184
2185           if (!reloc_howto)
2186             abort ();
2187
2188           size = bfd_get_reloc_size (reloc_howto);
2189
2190           /* XXX This will abort on an R_V850_8 reloc -
2191              is this reloc actually used?  */
2192           if (size != 2 && size != 4)
2193             abort ();
2194
2195           address = (f - frag_now->fr_literal) + insn_size - size;
2196
2197           if (reloc == BFD_RELOC_32)
2198             address += 2;
2199
2200           fixP = fix_new_exp (frag_now, address, size,
2201                               &fixups[i].exp,
2202                               reloc_howto->pc_relative,
2203                               reloc);
2204
2205           switch (reloc)
2206             {
2207             case BFD_RELOC_LO16:
2208             case BFD_RELOC_HI16:
2209             case BFD_RELOC_HI16_S:
2210               fixP->fx_no_overflow = 1;
2211               break;
2212             default:
2213               break;
2214             }
2215         }
2216       else
2217         {
2218           fix_new_exp (frag_now,
2219                        f - frag_now->fr_literal, 4,
2220                        & fixups[i].exp,
2221                        1 /* FIXME: V850_OPERAND_RELATIVE ???  */,
2222                        (bfd_reloc_code_real_type) (fixups[i].opindex
2223                                                    + (int) BFD_RELOC_UNUSED));
2224         }
2225     }
2226
2227   input_line_pointer = saved_input_line_pointer;
2228 }
2229
2230 /* If while processing a fixup, a reloc really needs to be created
2231    then it is done here.  */
2232
2233 arelent *
2234 tc_gen_reloc (seg, fixp)
2235      asection *seg ATTRIBUTE_UNUSED;
2236      fixS *fixp;
2237 {
2238   arelent *reloc;
2239
2240   reloc               = (arelent *) xmalloc (sizeof (arelent));
2241   reloc->sym_ptr_ptr  = (asymbol **) xmalloc (sizeof (asymbol *));
2242   *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
2243   reloc->address      = fixp->fx_frag->fr_address + fixp->fx_where;
2244   reloc->howto        = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
2245
2246   if (reloc->howto == (reloc_howto_type *) NULL)
2247     {
2248       as_bad_where (fixp->fx_file, fixp->fx_line,
2249                     /* xgettext:c-format  */
2250                     _("reloc %d not supported by object file format"),
2251                     (int) fixp->fx_r_type);
2252
2253       xfree (reloc);
2254
2255       return NULL;
2256     }
2257
2258   if (fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY
2259       || fixp->fx_r_type == BFD_RELOC_VTABLE_INHERIT)
2260     reloc->addend = fixp->fx_offset;
2261   else if (   fixp->fx_r_type == BFD_RELOC_V850_LONGCALL
2262            || fixp->fx_r_type == BFD_RELOC_V850_LONGJUMP
2263            || fixp->fx_r_type == BFD_RELOC_V850_ALIGN)
2264     reloc->addend = fixp->fx_offset;
2265   else
2266     reloc->addend = fixp->fx_addnumber;
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 }