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, 2004, 2005,
   3    2006, 2007, 2009, 2010  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 3, 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, 51 Franklin Street - Fifth Floor,
  20    Boston, MA 02110-1301, USA.  */
  21
  22 #include "as.h"
  23 #include "safe-ctype.h"
  24 #include "subsegs.h"
  25 #include "opcode/v850.h"
  26 #include "dwarf2dbg.h"
  27
  28 /* Sign-extend a 16-bit number.  */
  29 #define SEXT16(x)       ((((x) & 0xffff) ^ (~0x7fff)) + 0x8000)
  30
  31 /* Temporarily holds the reloc in a cons expression.  */
  32 static bfd_reloc_code_real_type hold_cons_reloc = BFD_RELOC_UNUSED;
  33
  34 /* Set to TRUE if we want to be pedantic about signed overflows.  */
  35 static bfd_boolean warn_signed_overflows   = FALSE;
  36 static bfd_boolean warn_unsigned_overflows = FALSE;
  37
  38 /* Indicates the target BFD machine number.  */
  39 static int machine = -1;
  40
  41 /* Indicates the target processor(s) for the assemble.  */
  42 static int processor_mask = 0;
  43 \f
  44 /* Structure to hold information about predefined registers.  */
  45 struct reg_name
  46 {
  47   const char *name;
  48   int value;
  49   unsigned int processors;
  50 };
  51
  52 /* Generic assembler global variables which must be defined by all
  53    targets.  */
  54
  55 /* Characters which always start a comment.  */
  56 const char comment_chars[] = "#";
  57
  58 /* Characters which start a comment at the beginning of a line.  */
  59 const char line_comment_chars[] = ";#";
  60
  61 /* Characters which may be used to separate multiple commands on a
  62    single line.  */
  63 const char line_separator_chars[] = ";";
  64
  65 /* Characters which are used to indicate an exponent in a floating
  66    point number.  */
  67 const char EXP_CHARS[] = "eE";
  68
  69 /* Characters which mean that a number is a floating point constant,
  70    as in 0d1.0.  */
  71 const char FLT_CHARS[] = "dD";
  72 \f
  73 const relax_typeS md_relax_table[] =
  74 {
  75   /* Conditional branches.(V850/V850E, max 22bit)  */
  76 #define SUBYPTE_COND_9_22       0
  77   {0xfe,         -0x100,        2, SUBYPTE_COND_9_22 + 1},
  78   {0x1ffffe + 2, -0x200000 + 2, 6, 0},
  79   /* Conditional branches.(V850/V850E, max 22bit)  */
  80 #define SUBYPTE_SA_9_22 2
  81   {0xfe,         -0x100,      2, SUBYPTE_SA_9_22 + 1},
  82   {0x1ffffe + 4, -0x200000 + 4, 8, 0},
  83   /* Unconditional branches.(V850/V850E, max 22bit)  */
  84 #define SUBYPTE_UNCOND_9_22     4
  85   {0xfe,     -0x100,    2, SUBYPTE_UNCOND_9_22 + 1},
  86   {0x1ffffe, -0x200000, 4, 0},
  87   /* Conditional branches.(V850E2, max 32bit)  */
  88 #define SUBYPTE_COND_9_22_32    6
  89   {0xfe,     -0x100,    2, SUBYPTE_COND_9_22_32 + 1},
  90   {0x1fffff + 2, -0x200000 + 2, 6, SUBYPTE_COND_9_22_32 + 2},
  91   {0x7ffffffe, -0x80000000, 8, 0},
  92   /* Conditional branches.(V850E2, max 32bit)  */
  93 #define SUBYPTE_SA_9_22_32      9
  94   {0xfe,     -0x100,    2, SUBYPTE_SA_9_22_32 + 1},
  95   {0x1ffffe + 4, -0x200000 + 4, 8, SUBYPTE_SA_9_22_32 + 2},
  96   {0x7ffffffe, -0x80000000, 10, 0},
  97   /* Unconditional branches.(V850E2, max 32bit)  */
  98 #define SUBYPTE_UNCOND_9_22_32  12
  99   {0xfe,     -0x100,    2, SUBYPTE_UNCOND_9_22_32 + 1},
 100   {0x1ffffe, -0x200000, 4, SUBYPTE_UNCOND_9_22_32 + 2},
 101   {0x7ffffffe, -0x80000000, 6, 0},
 102   /* Conditional branches.(V850E2R max 22bit)  */
 103 #define SUBYPTE_COND_9_17_22    15
 104   {0xfe,     -0x100,    2, SUBYPTE_COND_9_17_22 + 1},
 105   {0xfffe, -0x10000,    4, SUBYPTE_COND_9_17_22 + 2},
 106   {0x1ffffe + 2, -0x200000 + 2, 6, 0},
 107   /* Conditional branches.(V850E2R max 22bit)  */
 108 #define SUBYPTE_SA_9_17_22      18
 109   {0xfe,     -0x100,    2, SUBYPTE_SA_9_17_22 + 1},
 110   {0xfffe, -0x10000,    4, SUBYPTE_SA_9_17_22 + 2},
 111   {0x1ffffe + 4, -0x200000 + 4, 8, 0},
 112   /* Conditional branches.(V850E2R max 32bit)  */
 113 #define SUBYPTE_COND_9_17_22_32 21
 114   {0xfe,     -0x100,    2, SUBYPTE_COND_9_17_22_32 + 1},
 115   {0xfffe, -0x10000,    4, SUBYPTE_COND_9_17_22_32 + 2},
 116   {0x1ffffe + 2, -0x200000 + 2, 6, SUBYPTE_COND_9_17_22_32 + 3},
 117   {0x7ffffffe, -0x80000000, 8, 0},
 118   /* Conditional branches.(V850E2R max 32bit)  */
 119 #define SUBYPTE_SA_9_17_22_32   25
 120   {0xfe,     -0x100,    2, SUBYPTE_SA_9_17_22_32 + 1},
 121   {0xfffe, -0x10000,    4, SUBYPTE_SA_9_17_22_32 + 2},
 122   {0x1ffffe + 4, -0x200000 + 4, 8, SUBYPTE_SA_9_17_22_32 + 3},
 123   {0x7ffffffe, -0x80000000, 10, 0},
 124 };
 125
 126 static int v850_relax = 0;
 127
 128 /* Default branch disp size 22 or 32.  */
 129 static int default_disp_size = 22;
 130
 131 /* Default no using bcond17.  */
 132 static int no_bcond17 = 0;
 133
 134 /* Default no using ld/st 23bit offset.  */
 135 static int no_stld23 = 0;
 136
 137 /* Fixups.  */
 138 #define MAX_INSN_FIXUPS   5
 139
 140 struct v850_fixup
 141 {
 142   expressionS exp;
 143   int opindex;
 144   bfd_reloc_code_real_type reloc;
 145 };
 146
 147 struct v850_fixup fixups[MAX_INSN_FIXUPS];
 148 static int fc;
 149
 150 struct v850_seg_entry
 151 {
 152   segT s;
 153   const char *name;
 154   flagword flags;
 155 };
 156
 157 struct v850_seg_entry v850_seg_table[] =
 158 {
 159   { NULL, ".sdata",
 160     SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_DATA | SEC_HAS_CONTENTS
 161     | SEC_SMALL_DATA },
 162   { NULL, ".tdata",
 163     SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_DATA | SEC_HAS_CONTENTS },
 164   { NULL, ".zdata",
 165     SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_DATA | SEC_HAS_CONTENTS },
 166   { NULL, ".sbss",
 167     SEC_ALLOC | SEC_SMALL_DATA },
 168   { NULL, ".tbss",
 169     SEC_ALLOC },
 170   { NULL, ".zbss",
 171     SEC_ALLOC},
 172   { NULL, ".rosdata",
 173     SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_READONLY | SEC_DATA
 174     | SEC_HAS_CONTENTS | SEC_SMALL_DATA },
 175   { NULL, ".rozdata",
 176     SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_READONLY | SEC_DATA
 177     | SEC_HAS_CONTENTS },
 178   { NULL, ".scommon",
 179     SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_DATA | SEC_HAS_CONTENTS
 180     | SEC_SMALL_DATA | SEC_IS_COMMON },
 181   { NULL, ".tcommon",
 182     SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_DATA | SEC_HAS_CONTENTS
 183     | SEC_IS_COMMON },
 184   { NULL, ".zcommon",
 185     SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_DATA | SEC_HAS_CONTENTS
 186     | SEC_IS_COMMON },
 187   { NULL, ".call_table_data",
 188     SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_DATA | SEC_HAS_CONTENTS },
 189   { NULL, ".call_table_text",
 190     SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_READONLY | SEC_CODE
 191     | SEC_HAS_CONTENTS},
 192   { NULL, ".bss",
 193     SEC_ALLOC }
 194 };
 195
 196 #define SDATA_SECTION           0
 197 #define TDATA_SECTION           1
 198 #define ZDATA_SECTION           2
 199 #define SBSS_SECTION            3
 200 #define TBSS_SECTION            4
 201 #define ZBSS_SECTION            5
 202 #define ROSDATA_SECTION         6
 203 #define ROZDATA_SECTION         7
 204 #define SCOMMON_SECTION         8
 205 #define TCOMMON_SECTION         9
 206 #define ZCOMMON_SECTION         10
 207 #define CALL_TABLE_DATA_SECTION 11
 208 #define CALL_TABLE_TEXT_SECTION 12
 209 #define BSS_SECTION             13
 210
 211 static void
 212 do_v850_seg (int i, subsegT sub)
 213 {
 214   struct v850_seg_entry *seg = v850_seg_table + i;
 215
 216   obj_elf_section_change_hook ();
 217
 218   if (seg->s != NULL)
 219     subseg_set (seg->s, sub);
 220   else
 221     {
 222       seg->s = subseg_new (seg->name, sub);
 223       bfd_set_section_flags (stdoutput, seg->s, seg->flags);
 224       if ((seg->flags & SEC_LOAD) == 0)
 225         seg_info (seg->s)->bss = 1;
 226     }
 227 }
 228
 229 static void
 230 v850_seg (int i)
 231 {
 232   subsegT sub = get_absolute_expression ();
 233
 234   do_v850_seg (i, sub);
 235   demand_empty_rest_of_line ();
 236 }
 237
 238 static void
 239 v850_offset (int ignore ATTRIBUTE_UNUSED)
 240 {
 241   char *pfrag;
 242   int temp = get_absolute_expression ();
 243
 244   pfrag = frag_var (rs_org, 1, 1, (relax_substateT)0, (symbolS *)0,
 245                     (offsetT) temp, (char *) 0);
 246   *pfrag = 0;
 247
 248   demand_empty_rest_of_line ();
 249 }
 250
 251 /* Copied from obj_elf_common() in gas/config/obj-elf.c.  */
 252
 253 static void
 254 v850_comm (int area)
 255 {
 256   char *name;
 257   char c;
 258   char *p;
 259   int temp;
 260   unsigned int size;
 261   symbolS *symbolP;
 262   int have_align;
 263
 264   name = input_line_pointer;
 265   c = get_symbol_end ();
 266
 267   /* Just after name is now '\0'.  */
 268   p = input_line_pointer;
 269   *p = c;
 270
 271   SKIP_WHITESPACE ();
 272
 273   if (*input_line_pointer != ',')
 274     {
 275       as_bad (_("Expected comma after symbol-name"));
 276       ignore_rest_of_line ();
 277       return;
 278     }
 279
 280   /* Skip ','.  */
 281   input_line_pointer++;
 282
 283   if ((temp = get_absolute_expression ()) < 0)
 284     {
 285       /* xgettext:c-format  */
 286       as_bad (_(".COMMon length (%d.) < 0! Ignored."), temp);
 287       ignore_rest_of_line ();
 288       return;
 289     }
 290
 291   size = temp;
 292   *p = 0;
 293   symbolP = symbol_find_or_make (name);
 294   *p = c;
 295
 296   if (S_IS_DEFINED (symbolP) && ! S_IS_COMMON (symbolP))
 297     {
 298       as_bad (_("Ignoring attempt to re-define symbol"));
 299       ignore_rest_of_line ();
 300       return;
 301     }
 302
 303   if (S_GET_VALUE (symbolP) != 0)
 304     {
 305       if (S_GET_VALUE (symbolP) != size)
 306         /* xgettext:c-format  */
 307         as_warn (_("Length of .comm \"%s\" is already %ld. Not changed to %d."),
 308                  S_GET_NAME (symbolP), (long) S_GET_VALUE (symbolP), size);
 309     }
 310
 311   know (symbol_get_frag (symbolP) == &zero_address_frag);
 312
 313   if (*input_line_pointer != ',')
 314     have_align = 0;
 315   else
 316     {
 317       have_align = 1;
 318       input_line_pointer++;
 319       SKIP_WHITESPACE ();
 320     }
 321
 322   if (! have_align || *input_line_pointer != '"')
 323     {
 324       if (! have_align)
 325         temp = 0;
 326       else
 327         {
 328           temp = get_absolute_expression ();
 329
 330           if (temp < 0)
 331             {
 332               temp = 0;
 333               as_warn (_("Common alignment negative; 0 assumed"));
 334             }
 335         }
 336
 337       if (symbol_get_obj (symbolP)->local)
 338         {
 339           segT old_sec;
 340           int old_subsec;
 341           char *pfrag;
 342           int align;
 343           flagword applicable;
 344
 345           old_sec = now_seg;
 346           old_subsec = now_subseg;
 347
 348           applicable = bfd_applicable_section_flags (stdoutput);
 349
 350           applicable &= SEC_ALLOC;
 351
 352           switch (area)
 353             {
 354             case SCOMMON_SECTION:
 355               do_v850_seg (SBSS_SECTION, 0);
 356               break;
 357
 358             case ZCOMMON_SECTION:
 359               do_v850_seg (ZBSS_SECTION, 0);
 360               break;
 361
 362             case TCOMMON_SECTION:
 363               do_v850_seg (TBSS_SECTION, 0);
 364               break;
 365             }
 366
 367           if (temp)
 368             {
 369               /* Convert to a power of 2 alignment.  */
 370               for (align = 0; (temp & 1) == 0; temp >>= 1, ++align)
 371                 ;
 372
 373               if (temp != 1)
 374                 {
 375                   as_bad (_("Common alignment not a power of 2"));
 376                   ignore_rest_of_line ();
 377                   return;
 378                 }
 379             }
 380           else
 381             align = 0;
 382
 383           record_alignment (now_seg, align);
 384
 385           if (align)
 386             frag_align (align, 0, 0);
 387
 388           switch (area)
 389             {
 390             case SCOMMON_SECTION:
 391               if (S_GET_SEGMENT (symbolP) == v850_seg_table[SBSS_SECTION].s)
 392                 symbol_get_frag (symbolP)->fr_symbol = 0;
 393               break;
 394
 395             case ZCOMMON_SECTION:
 396               if (S_GET_SEGMENT (symbolP) == v850_seg_table[ZBSS_SECTION].s)
 397                 symbol_get_frag (symbolP)->fr_symbol = 0;
 398               break;
 399
 400             case TCOMMON_SECTION:
 401               if (S_GET_SEGMENT (symbolP) == v850_seg_table[TBSS_SECTION].s)
 402                 symbol_get_frag (symbolP)->fr_symbol = 0;
 403               break;
 404
 405             default:
 406               abort ();
 407             }
 408
 409           symbol_set_frag (symbolP, frag_now);
 410           pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP,
 411                             (offsetT) size, (char *) 0);
 412           *pfrag = 0;
 413           S_SET_SIZE (symbolP, size);
 414
 415           switch (area)
 416             {
 417             case SCOMMON_SECTION:
 418               S_SET_SEGMENT (symbolP, v850_seg_table[SBSS_SECTION].s);
 419               break;
 420
 421             case ZCOMMON_SECTION:
 422               S_SET_SEGMENT (symbolP, v850_seg_table[ZBSS_SECTION].s);
 423               break;
 424
 425             case TCOMMON_SECTION:
 426               S_SET_SEGMENT (symbolP, v850_seg_table[TBSS_SECTION].s);
 427               break;
 428
 429             default:
 430               abort ();
 431             }
 432
 433           S_CLEAR_EXTERNAL (symbolP);
 434           obj_elf_section_change_hook ();
 435           subseg_set (old_sec, old_subsec);
 436         }
 437       else
 438         {
 439           segT   old_sec;
 440           int    old_subsec;
 441
 442         allocate_common:
 443           old_sec = now_seg;
 444           old_subsec = now_subseg;
 445
 446           S_SET_VALUE (symbolP, (valueT) size);
 447           S_SET_ALIGN (symbolP, temp);
 448           S_SET_EXTERNAL (symbolP);
 449
 450           switch (area)
 451             {
 452             case SCOMMON_SECTION:
 453             case ZCOMMON_SECTION:
 454             case TCOMMON_SECTION:
 455               do_v850_seg (area, 0);
 456               S_SET_SEGMENT (symbolP, v850_seg_table[area].s);
 457               break;
 458
 459             default:
 460               abort ();
 461             }
 462
 463           obj_elf_section_change_hook ();
 464           subseg_set (old_sec, old_subsec);
 465         }
 466     }
 467   else
 468     {
 469       input_line_pointer++;
 470
 471       /* @@ Some use the dot, some don't.  Can we get some consistency??  */
 472       if (*input_line_pointer == '.')
 473         input_line_pointer++;
 474
 475       /* @@ Some say data, some say bss.  */
 476       if (strncmp (input_line_pointer, "bss\"", 4)
 477           && strncmp (input_line_pointer, "data\"", 5))
 478         {
 479           while (*--input_line_pointer != '"')
 480             ;
 481           input_line_pointer--;
 482           goto bad_common_segment;
 483         }
 484
 485       while (*input_line_pointer++ != '"')
 486         ;
 487
 488       goto allocate_common;
 489     }
 490
 491   symbol_get_bfdsym (symbolP)->flags |= BSF_OBJECT;
 492
 493   demand_empty_rest_of_line ();
 494   return;
 495
 496   {
 497   bad_common_segment:
 498     p = input_line_pointer;
 499     while (*p && *p != '\n')
 500       p++;
 501     c = *p;
 502     *p = '\0';
 503     as_bad (_("bad .common segment %s"), input_line_pointer + 1);
 504     *p = c;
 505     input_line_pointer = p;
 506     ignore_rest_of_line ();
 507     return;
 508   }
 509 }
 510
 511 static void
 512 set_machine (int number)
 513 {
 514   machine = number;
 515   bfd_set_arch_mach (stdoutput, TARGET_ARCH, machine);
 516
 517   switch (machine)
 518     {
 519     case 0:                SET_PROCESSOR_MASK (processor_mask, PROCESSOR_V850);    break;
 520     case bfd_mach_v850:    SET_PROCESSOR_MASK (processor_mask, PROCESSOR_V850);    break;
 521     case bfd_mach_v850e:   SET_PROCESSOR_MASK (processor_mask, PROCESSOR_V850E);   break;
 522     case bfd_mach_v850e1:  SET_PROCESSOR_MASK (processor_mask, PROCESSOR_V850E);   break;
 523     case bfd_mach_v850e2:  SET_PROCESSOR_MASK (processor_mask, PROCESSOR_V850E2);  break;
 524     case bfd_mach_v850e2v3:SET_PROCESSOR_MASK (processor_mask, PROCESSOR_V850E2V3); break;
 525     }
 526 }
 527
 528 static void
 529 v850_longcode (int type)
 530 {
 531   expressionS ex;
 532
 533   if (! v850_relax)
 534     {
 535       if (type == 1)
 536         as_warn (_(".longcall pseudo-op seen when not relaxing"));
 537       else
 538         as_warn (_(".longjump pseudo-op seen when not relaxing"));
 539     }
 540
 541   expression (&ex);
 542
 543   if (ex.X_op != O_symbol || ex.X_add_number != 0)
 544     {
 545       as_bad (_("bad .longcall format"));
 546       ignore_rest_of_line ();
 547
 548       return;
 549     }
 550
 551   if (type == 1)
 552     fix_new_exp (frag_now, frag_now_fix (), 4, & ex, 1,
 553                  BFD_RELOC_V850_LONGCALL);
 554   else
 555     fix_new_exp (frag_now, frag_now_fix (), 4, & ex, 1,
 556                  BFD_RELOC_V850_LONGJUMP);
 557
 558   demand_empty_rest_of_line ();
 559 }
 560
 561 /* The target specific pseudo-ops which we support.  */
 562 const pseudo_typeS md_pseudo_table[] =
 563 {
 564   { "sdata",            v850_seg,               SDATA_SECTION           },
 565   { "tdata",            v850_seg,               TDATA_SECTION           },
 566   { "zdata",            v850_seg,               ZDATA_SECTION           },
 567   { "sbss",             v850_seg,               SBSS_SECTION            },
 568   { "tbss",             v850_seg,               TBSS_SECTION            },
 569   { "zbss",             v850_seg,               ZBSS_SECTION            },
 570   { "rosdata",          v850_seg,               ROSDATA_SECTION         },
 571   { "rozdata",          v850_seg,               ROZDATA_SECTION         },
 572   { "bss",              v850_seg,               BSS_SECTION             },
 573   { "offset",           v850_offset,            0                       },
 574   { "word",             cons,                   4                       },
 575   { "zcomm",            v850_comm,              ZCOMMON_SECTION         },
 576   { "scomm",            v850_comm,              SCOMMON_SECTION         },
 577   { "tcomm",            v850_comm,              TCOMMON_SECTION         },
 578   { "v850",             set_machine,            0                       },
 579   { "call_table_data",  v850_seg,               CALL_TABLE_DATA_SECTION },
 580   { "call_table_text",  v850_seg,               CALL_TABLE_TEXT_SECTION },
 581   { "v850e",            set_machine,            bfd_mach_v850e          },
 582   { "v850e1",           set_machine,            bfd_mach_v850e1         },
 583   { "v850e2",           set_machine,            bfd_mach_v850e2         },
 584   { "v850e2v3",         set_machine,            bfd_mach_v850e2v3       },
 585   { "longcall",         v850_longcode,          1                       },
 586   { "longjump",         v850_longcode,          2                       },
 587   { NULL,               NULL,                   0                       }
 588 };
 589
 590 /* Opcode hash table.  */
 591 static struct hash_control *v850_hash;
 592
 593 /* This table is sorted.  Suitable for searching by a binary search.  */
 594 static const struct reg_name pre_defined_registers[] =
 595 {
 596   { "ep",  30, PROCESSOR_ALL },         /* ep - element ptr.  */
 597   { "gp",   4, PROCESSOR_ALL },         /* gp - global ptr.  */
 598   { "hp",   2, PROCESSOR_ALL },         /* hp - handler stack ptr.  */
 599   { "lp",  31, PROCESSOR_ALL },         /* lp - link ptr.  */
 600   { "r0",   0, PROCESSOR_ALL },
 601   { "r1",   1, PROCESSOR_ALL },
 602   { "r10", 10, PROCESSOR_ALL },
 603   { "r11", 11, PROCESSOR_ALL },
 604   { "r12", 12, PROCESSOR_ALL },
 605   { "r13", 13, PROCESSOR_ALL },
 606   { "r14", 14, PROCESSOR_ALL },
 607   { "r15", 15, PROCESSOR_ALL },
 608   { "r16", 16, PROCESSOR_ALL },
 609   { "r17", 17, PROCESSOR_ALL },
 610   { "r18", 18, PROCESSOR_ALL },
 611   { "r19", 19, PROCESSOR_ALL },
 612   { "r2",   2, PROCESSOR_ALL },
 613   { "r20", 20, PROCESSOR_ALL },
 614   { "r21", 21, PROCESSOR_ALL },
 615   { "r22", 22, PROCESSOR_ALL },
 616   { "r23", 23, PROCESSOR_ALL },
 617   { "r24", 24, PROCESSOR_ALL },
 618   { "r25", 25, PROCESSOR_ALL },
 619   { "r26", 26, PROCESSOR_ALL },
 620   { "r27", 27, PROCESSOR_ALL },
 621   { "r28", 28, PROCESSOR_ALL },
 622   { "r29", 29, PROCESSOR_ALL },
 623   { "r3",   3, PROCESSOR_ALL },
 624   { "r30", 30, PROCESSOR_ALL },
 625   { "r31", 31, PROCESSOR_ALL },
 626   { "r4",   4, PROCESSOR_ALL },
 627   { "r5",   5, PROCESSOR_ALL },
 628   { "r6",   6, PROCESSOR_ALL },
 629   { "r7",   7, PROCESSOR_ALL },
 630   { "r8",   8, PROCESSOR_ALL },
 631   { "r9",   9, PROCESSOR_ALL },
 632   { "sp",   3, PROCESSOR_ALL },         /* sp - stack ptr.  */
 633   { "tp",   5, PROCESSOR_ALL },         /* tp - text ptr.  */
 634   { "zero", 0, PROCESSOR_ALL },
 635 };
 636
 637 #define REG_NAME_CNT                                            \
 638   (sizeof (pre_defined_registers) / sizeof (struct reg_name))
 639
 640 static const struct reg_name system_registers[] =
 641 {
 642   { "asid",        23, PROCESSOR_NOT_V850 },
 643   { "bpam",        25, PROCESSOR_NOT_V850 },
 644   { "bpav",        24, PROCESSOR_NOT_V850 },
 645   { "bpc",         22, PROCESSOR_NOT_V850 },
 646   { "bpdm",        27, PROCESSOR_NOT_V850 },
 647   { "bpdv",        26, PROCESSOR_NOT_V850 },
 648   { "bsel",        31, PROCESSOR_V850E2_ALL },
 649   { "cfg",          7, PROCESSOR_V850E2V3 },
 650   { "ctbp",        20, PROCESSOR_NOT_V850 },
 651   { "ctpc",        16, PROCESSOR_NOT_V850 },
 652   { "ctpsw",       17, PROCESSOR_NOT_V850 },
 653   { "dbic",        15, PROCESSOR_V850E2_ALL },
 654   { "dbpc",        18, PROCESSOR_NOT_V850 },
 655   { "dbpsw",       19, PROCESSOR_NOT_V850 },
 656   { "dbwr",        30, PROCESSOR_V850E2_ALL },
 657   { "dir",         21, PROCESSOR_NOT_V850 },
 658   { "dpa0l",       16, PROCESSOR_V850E2V3 },
 659   { "dpa0u",       17, PROCESSOR_V850E2V3 },
 660   { "dpa1l",       18, PROCESSOR_V850E2V3 },
 661   { "dpa1u",       19, PROCESSOR_V850E2V3 },
 662   { "dpa2l",       20, PROCESSOR_V850E2V3 },
 663   { "dpa2u",       21, PROCESSOR_V850E2V3 },
 664   { "dpa3l",       22, PROCESSOR_V850E2V3 },
 665   { "dpa3u",       23, PROCESSOR_V850E2V3 },
 666   { "dpa4l",       24, PROCESSOR_V850E2V3 },
 667   { "dpa4u",       25, PROCESSOR_V850E2V3 },
 668   { "dpa5l",       26, PROCESSOR_V850E2V3 },
 669   { "dpa5u",       27, PROCESSOR_V850E2V3 },
 670   { "ecr",          4, PROCESSOR_ALL },
 671   { "eh_base",      3, PROCESSOR_V850E2V3 },
 672   { "eh_cfg",       1, PROCESSOR_V850E2V3 },
 673   { "eh_reset",     2, PROCESSOR_V850E2V3 },
 674   { "eiic",        13, PROCESSOR_V850E2_ALL },
 675   { "eipc",         0, PROCESSOR_ALL },
 676   { "eipsw",        1, PROCESSOR_ALL },
 677   { "eiwr",        28, PROCESSOR_V850E2_ALL },
 678   { "feic",        14, PROCESSOR_V850E2_ALL },
 679   { "fepc",         2, PROCESSOR_ALL },
 680   { "fepsw",        3, PROCESSOR_ALL },
 681   { "fewr",        29, PROCESSOR_V850E2_ALL },
 682   { "fpcc",         9, PROCESSOR_V850E2V3 },
 683   { "fpcfg",       10, PROCESSOR_V850E2V3 },
 684   { "fpec",        11, PROCESSOR_V850E2V3 },
 685   { "fpepc",        7, PROCESSOR_V850E2V3 },
 686   { "fpspc",       27, PROCESSOR_V850E2V3 },
 687   { "fpsr",         6, PROCESSOR_V850E2V3 },
 688   { "fpst",         8, PROCESSOR_V850E2V3 },
 689   { "ipa0l",        6, PROCESSOR_V850E2V3 },
 690   { "ipa0u",        7, PROCESSOR_V850E2V3 },
 691   { "ipa1l",        8, PROCESSOR_V850E2V3 },
 692   { "ipa1u",        9, PROCESSOR_V850E2V3 },
 693   { "ipa2l",       10, PROCESSOR_V850E2V3 },
 694   { "ipa2u",       11, PROCESSOR_V850E2V3 },
 695   { "ipa3l",       12, PROCESSOR_V850E2V3 },
 696   { "ipa3u",       13, PROCESSOR_V850E2V3 },
 697   { "ipa4l",       14, PROCESSOR_V850E2V3 },
 698   { "ipa4u",       15, PROCESSOR_V850E2V3 },
 699   { "mca",         24, PROCESSOR_V850E2V3 },
 700   { "mcc",         26, PROCESSOR_V850E2V3 },
 701   { "mcr",         27, PROCESSOR_V850E2V3 },
 702   { "mcs",         25, PROCESSOR_V850E2V3 },
 703   { "mpc",          1, PROCESSOR_V850E2V3 },
 704   { "mpm",          0, PROCESSOR_V850E2V3 },
 705   { "mpu10_dpa0l", 16, PROCESSOR_V850E2V3 },
 706   { "mpu10_dpa0u", 17, PROCESSOR_V850E2V3 },
 707   { "mpu10_dpa1l", 18, PROCESSOR_V850E2V3 },
 708   { "mpu10_dpa1u", 19, PROCESSOR_V850E2V3 },
 709   { "mpu10_dpa2l", 20, PROCESSOR_V850E2V3 },
 710   { "mpu10_dpa2u", 21, PROCESSOR_V850E2V3 },
 711   { "mpu10_dpa3l", 22, PROCESSOR_V850E2V3 },
 712   { "mpu10_dpa3u", 23, PROCESSOR_V850E2V3 },
 713   { "mpu10_dpa4l", 24, PROCESSOR_V850E2V3 },
 714   { "mpu10_dpa4u", 25, PROCESSOR_V850E2V3 },
 715   { "mpu10_dpa5l", 26, PROCESSOR_V850E2V3 },
 716   { "mpu10_dpa5u", 27, PROCESSOR_V850E2V3 },
 717   { "mpu10_ipa0l",  6, PROCESSOR_V850E2V3 },
 718   { "mpu10_ipa0u",  7, PROCESSOR_V850E2V3 },
 719   { "mpu10_ipa1l",  8, PROCESSOR_V850E2V3 },
 720   { "mpu10_ipa1u",  9, PROCESSOR_V850E2V3 },
 721   { "mpu10_ipa2l", 10, PROCESSOR_V850E2V3 },
 722   { "mpu10_ipa2u", 11, PROCESSOR_V850E2V3 },
 723   { "mpu10_ipa3l", 12, PROCESSOR_V850E2V3 },
 724   { "mpu10_ipa3u", 13, PROCESSOR_V850E2V3 },
 725   { "mpu10_ipa4l", 14, PROCESSOR_V850E2V3 },
 726   { "mpu10_ipa4u", 15, PROCESSOR_V850E2V3 },
 727   { "mpu10_mpc",    1, PROCESSOR_V850E2V3 },
 728   { "mpu10_mpm",    0, PROCESSOR_V850E2V3 },
 729   { "mpu10_tid",    2, PROCESSOR_V850E2V3 },
 730   { "mpu10_vmadr",  5, PROCESSOR_V850E2V3 },
 731   { "mpu10_vmecr",  3, PROCESSOR_V850E2V3 },
 732   { "mpu10_vmtid",  4, PROCESSOR_V850E2V3 },
 733   { "pid",          6, PROCESSOR_V850E2V3 },
 734   { "pmcr0",        4, PROCESSOR_V850E2V3 },
 735   { "pmis2",       14, PROCESSOR_V850E2V3 },
 736   { "psw",          5, PROCESSOR_ALL },
 737   { "scbp",        12, PROCESSOR_V850E2V3 },
 738   { "sccfg",       11, PROCESSOR_V850E2V3 },
 739   { "sr0",          0, PROCESSOR_ALL },
 740   { "sr1",          1, PROCESSOR_ALL },
 741   { "sr10",        10, PROCESSOR_ALL },
 742   { "sr11",        11, PROCESSOR_ALL },
 743   { "sr12",        12, PROCESSOR_ALL },
 744   { "sr13",        13, PROCESSOR_ALL },
 745   { "sr14",        14, PROCESSOR_ALL },
 746   { "sr15",        15, PROCESSOR_ALL },
 747   { "sr16",        16, PROCESSOR_ALL },
 748   { "sr17",        17, PROCESSOR_ALL },
 749   { "sr18",        18, PROCESSOR_ALL },
 750   { "sr19",        19, PROCESSOR_ALL },
 751   { "sr2",          2, PROCESSOR_ALL },
 752   { "sr20",        20, PROCESSOR_ALL },
 753   { "sr21",        21, PROCESSOR_ALL },
 754   { "sr22",        22, PROCESSOR_ALL },
 755   { "sr23",        23, PROCESSOR_ALL },
 756   { "sr24",        24, PROCESSOR_ALL },
 757   { "sr25",        25, PROCESSOR_ALL },
 758   { "sr26",        26, PROCESSOR_ALL },
 759   { "sr27",        27, PROCESSOR_ALL },
 760   { "sr28",        28, PROCESSOR_ALL },
 761   { "sr29",        29, PROCESSOR_ALL },
 762   { "sr3",          3, PROCESSOR_ALL },
 763   { "sr30",        30, PROCESSOR_ALL },
 764   { "sr31",        31, PROCESSOR_ALL },
 765   { "sr4",          4, PROCESSOR_ALL },
 766   { "sr5",          5, PROCESSOR_ALL },
 767   { "sr6",          6, PROCESSOR_ALL },
 768   { "sr7",          7, PROCESSOR_ALL },
 769   { "sr8",          8, PROCESSOR_ALL },
 770   { "sr9",          9, PROCESSOR_ALL },
 771   { "sw_base",      3, PROCESSOR_V850E2V3 },
 772   { "sw_cfg",       1, PROCESSOR_V850E2V3 },
 773   { "sw_ctl",       0, PROCESSOR_V850E2V3 },
 774   { "tid",          2, PROCESSOR_V850E2V3 },
 775   { "vmadr",        6, PROCESSOR_V850E2V3 },
 776   { "vmecr",        4, PROCESSOR_V850E2V3 },
 777   { "vmtid",        5, PROCESSOR_V850E2V3 },
 778   { "vsadr",        2, PROCESSOR_V850E2V3 },
 779   { "vsecr",        0, PROCESSOR_V850E2V3 },
 780   { "vstid",        1, PROCESSOR_V850E2V3 },
 781 };
 782
 783 #define SYSREG_NAME_CNT                                         \
 784   (sizeof (system_registers) / sizeof (struct reg_name))
 785
 786
 787 static const struct reg_name cc_names[] =
 788 {
 789   { "c",  0x1, PROCESSOR_ALL },
 790   { "e",  0x2, PROCESSOR_ALL },
 791   { "ge", 0xe, PROCESSOR_ALL },
 792   { "gt", 0xf, PROCESSOR_ALL },
 793   { "h",  0xb, PROCESSOR_ALL },
 794   { "l",  0x1, PROCESSOR_ALL },
 795   { "le", 0x7, PROCESSOR_ALL },
 796   { "lt", 0x6, PROCESSOR_ALL },
 797   { "n",  0x4, PROCESSOR_ALL },
 798   { "nc", 0x9, PROCESSOR_ALL },
 799   { "ne", 0xa, PROCESSOR_ALL },
 800   { "nh", 0x3, PROCESSOR_ALL },
 801   { "nl", 0x9, PROCESSOR_ALL },
 802   { "ns", 0xc, PROCESSOR_ALL },
 803   { "nv", 0x8, PROCESSOR_ALL },
 804   { "nz", 0xa, PROCESSOR_ALL },
 805   { "p",  0xc, PROCESSOR_ALL },
 806   { "s",  0x4, PROCESSOR_ALL },
 807 #define COND_SA_NUM 0xd
 808   { "sa", COND_SA_NUM, PROCESSOR_ALL },
 809   { "t",  0x5, PROCESSOR_ALL },
 810   { "v",  0x0, PROCESSOR_ALL },
 811   { "z",  0x2, PROCESSOR_ALL },
 812 };
 813
 814 #define CC_NAME_CNT                                     \
 815   (sizeof (cc_names) / sizeof (struct reg_name))
 816
 817 static const struct reg_name float_cc_names[] =
 818 {
 819   { "eq",  0x2, PROCESSOR_V850E2V3 },   /* true.  */
 820   { "f",   0x0, PROCESSOR_V850E2V3 },   /* true.  */
 821   { "ge",  0xd, PROCESSOR_V850E2V3 },   /* false.  */
 822   { "gl",  0xb, PROCESSOR_V850E2V3 },   /* false.  */
 823   { "gle", 0x9, PROCESSOR_V850E2V3 },   /* false.  */
 824   { "gt",  0xf, PROCESSOR_V850E2V3 },   /* false.  */
 825   { "le",  0xe, PROCESSOR_V850E2V3 },   /* true.  */
 826   { "lt",  0xc, PROCESSOR_V850E2V3 },   /* true.  */
 827   { "neq", 0x2, PROCESSOR_V850E2V3 },   /* false.  */
 828   { "nge", 0xd, PROCESSOR_V850E2V3 },   /* true.  */
 829   { "ngl", 0xb, PROCESSOR_V850E2V3 },   /* true.  */
 830   { "ngle",0x9, PROCESSOR_V850E2V3 },   /* true.  */
 831   { "ngt", 0xf, PROCESSOR_V850E2V3 },   /* true.  */
 832   { "nle", 0xe, PROCESSOR_V850E2V3 },   /* false.  */
 833   { "nlt", 0xc, PROCESSOR_V850E2V3 },   /* false.  */
 834   { "oge", 0x5, PROCESSOR_V850E2V3 },   /* false.  */
 835   { "ogl", 0x3, PROCESSOR_V850E2V3 },   /* false.  */
 836   { "ogt", 0x7, PROCESSOR_V850E2V3 },   /* false.  */
 837   { "ole", 0x6, PROCESSOR_V850E2V3 },   /* true.  */
 838   { "olt", 0x4, PROCESSOR_V850E2V3 },   /* true.  */
 839   { "or",  0x1, PROCESSOR_V850E2V3 },   /* false.  */
 840   { "seq", 0xa, PROCESSOR_V850E2V3 },   /* true.  */
 841   { "sf",  0x8, PROCESSOR_V850E2V3 },   /* true.  */
 842   { "sne", 0xa, PROCESSOR_V850E2V3 },   /* false.  */
 843   { "st",  0x8, PROCESSOR_V850E2V3 },   /* false.  */
 844   { "t",   0x0, PROCESSOR_V850E2V3 },   /* false.  */
 845   { "ueq", 0x3, PROCESSOR_V850E2V3 },   /* true.  */
 846   { "uge", 0x4, PROCESSOR_V850E2V3 },   /* false.  */
 847   { "ugt", 0x6, PROCESSOR_V850E2V3 },   /* false.  */
 848   { "ule", 0x7, PROCESSOR_V850E2V3 },   /* true.  */
 849   { "ult", 0x5, PROCESSOR_V850E2V3 },   /* true.  */
 850   { "un",  0x1, PROCESSOR_V850E2V3 },   /* true.  */
 851 };
 852
 853 #define FLOAT_CC_NAME_CNT                                       \
 854   (sizeof (float_cc_names) / sizeof (struct reg_name))
 855
 856 /* Do a binary search of the given register table to see if NAME is a
 857    valid regiter name.  Return the register number from the array on
 858    success, or -1 on failure.  */
 859
 860 static int
 861 reg_name_search (const struct reg_name *regs,
 862                  int regcount,
 863                  const char *name,
 864                  bfd_boolean accept_numbers)
 865 {
 866   int middle, low, high;
 867   int cmp;
 868   symbolS *symbolP;
 869
 870   /* If the register name is a symbol, then evaluate it.  */
 871   if ((symbolP = symbol_find (name)) != NULL)
 872     {
 873       /* If the symbol is an alias for another name then use that.
 874          If the symbol is an alias for a number, then return the number.  */
 875       if (symbol_equated_p (symbolP))
 876         name
 877           = S_GET_NAME (symbol_get_value_expression (symbolP)->X_add_symbol);
 878       else if (accept_numbers)
 879         {
 880           int reg = S_GET_VALUE (symbolP);
 881           return reg;
 882         }
 883
 884       /* Otherwise drop through and try parsing name normally.  */
 885     }
 886
 887   low = 0;
 888   high = regcount - 1;
 889
 890   do
 891     {
 892       middle = (low + high) / 2;
 893       cmp = strcasecmp (name, regs[middle].name);
 894       if (cmp < 0)
 895         high = middle - 1;
 896       else if (cmp > 0)
 897         low = middle + 1;
 898       else
 899         return ((regs[middle].processors & processor_mask)
 900                 ? regs[middle].value
 901                 : -1);
 902     }
 903   while (low <= high);
 904   return -1;
 905 }
 906
 907 /* Summary of register_name().
 908
 909    in: Input_line_pointer points to 1st char of operand.
 910
 911    out: An expressionS.
 912         The operand may have been a register: in this case, X_op == O_register,
 913         X_add_number is set to the register number, and truth is returned.
 914         Input_line_pointer->(next non-blank) char after operand, or is in
 915         its original state.  */
 916
 917 static bfd_boolean
 918 register_name (expressionS *expressionP)
 919 {
 920   int reg_number;
 921   char *name;
 922   char *start;
 923   char c;
 924
 925   /* Find the spelling of the operand.  */
 926   start = name = input_line_pointer;
 927
 928   c = get_symbol_end ();
 929
 930   reg_number = reg_name_search (pre_defined_registers, REG_NAME_CNT,
 931                                 name, FALSE);
 932
 933   /* Put back the delimiting char.  */
 934   *input_line_pointer = c;
 935
 936   expressionP->X_add_symbol = NULL;
 937   expressionP->X_op_symbol  = NULL;
 938
 939   /* Look to see if it's in the register table.  */
 940   if (reg_number >= 0)
 941     {
 942       expressionP->X_op         = O_register;
 943       expressionP->X_add_number = reg_number;
 944
 945       return TRUE;
 946     }
 947
 948   /* Reset the line as if we had not done anything.  */
 949   input_line_pointer = start;
 950
 951   expressionP->X_op = O_illegal;
 952
 953   return FALSE;
 954 }
 955
 956 /* Summary of system_register_name().
 957
 958    in:  INPUT_LINE_POINTER points to 1st char of operand.
 959         EXPRESSIONP points to an expression structure to be filled in.
 960         ACCEPT_NUMBERS is true iff numerical register names may be used.
 961
 962    out: An expressionS structure in expressionP.
 963         The operand may have been a register: in this case, X_op == O_register,
 964         X_add_number is set to the register number, and truth is returned.
 965         Input_line_pointer->(next non-blank) char after operand, or is in
 966         its original state.  */
 967
 968 static bfd_boolean
 969 system_register_name (expressionS *expressionP,
 970                       bfd_boolean accept_numbers)
 971 {
 972   int reg_number;
 973   char *name;
 974   char *start;
 975   char c;
 976
 977   /* Find the spelling of the operand.  */
 978   start = name = input_line_pointer;
 979
 980   c = get_symbol_end ();
 981   reg_number = reg_name_search (system_registers, SYSREG_NAME_CNT, name,
 982                                 accept_numbers);
 983
 984   /* Put back the delimiting char.  */
 985   *input_line_pointer = c;
 986
 987   if (reg_number < 0
 988       && accept_numbers)
 989     {
 990       /* Reset input_line pointer.  */
 991       input_line_pointer = start;
 992
 993       if (ISDIGIT (*input_line_pointer))
 994         {
 995           reg_number = strtol (input_line_pointer, &input_line_pointer, 0);
 996         }
 997     }
 998
 999   expressionP->X_add_symbol = NULL;
1000   expressionP->X_op_symbol  = NULL;
1001
1002   /* Look to see if it's in the register table.  */
1003   if (reg_number >= 0)
1004     {
1005       expressionP->X_op         = O_register;
1006       expressionP->X_add_number = reg_number;
1007
1008       return TRUE;
1009     }
1010
1011   /* Reset the line as if we had not done anything.  */
1012   input_line_pointer = start;
1013
1014   expressionP->X_op = O_illegal;
1015
1016   return FALSE;
1017 }
1018
1019 /* Summary of cc_name().
1020
1021    in: INPUT_LINE_POINTER points to 1st char of operand.
1022
1023    out: An expressionS.
1024         The operand may have been a register: in this case, X_op == O_register,
1025         X_add_number is set to the register number, and truth is returned.
1026         Input_line_pointer->(next non-blank) char after operand, or is in
1027         its original state.  */
1028
1029 static bfd_boolean
1030 cc_name (expressionS *expressionP,
1031          bfd_boolean accept_numbers)
1032 {
1033   int reg_number;
1034   char *name;
1035   char *start;
1036   char c;
1037
1038   /* Find the spelling of the operand.  */
1039   start = name = input_line_pointer;
1040
1041   c = get_symbol_end ();
1042   reg_number = reg_name_search (cc_names, CC_NAME_CNT, name, accept_numbers);
1043
1044   /* Put back the delimiting char.  */
1045   *input_line_pointer = c;
1046
1047   if (reg_number < 0
1048       && accept_numbers)
1049     {
1050       /* Reset input_line pointer.  */
1051       input_line_pointer = start;
1052
1053       if (ISDIGIT (*input_line_pointer))
1054         {
1055           reg_number = strtol (input_line_pointer, &input_line_pointer, 0);
1056         }
1057     }
1058
1059   expressionP->X_add_symbol = NULL;
1060   expressionP->X_op_symbol  = NULL;
1061
1062   /* Look to see if it's in the register table.  */
1063   if (reg_number >= 0)
1064     {
1065       expressionP->X_op         = O_constant;
1066       expressionP->X_add_number = reg_number;
1067
1068       return TRUE;
1069     }
1070
1071   /* Reset the line as if we had not done anything.  */
1072   input_line_pointer = start;
1073
1074   expressionP->X_op = O_illegal;
1075   expressionP->X_add_number = 0;
1076
1077   return FALSE;
1078 }
1079
1080 static bfd_boolean
1081 float_cc_name (expressionS *expressionP,
1082                bfd_boolean accept_numbers)
1083 {
1084   int reg_number;
1085   char *name;
1086   char *start;
1087   char c;
1088
1089   /* Find the spelling of the operand.  */
1090   start = name = input_line_pointer;
1091
1092   c = get_symbol_end ();
1093   reg_number = reg_name_search (float_cc_names, FLOAT_CC_NAME_CNT, name, accept_numbers);
1094
1095   /* Put back the delimiting char.  */
1096   *input_line_pointer = c;
1097
1098   if (reg_number < 0
1099       && accept_numbers)
1100     {
1101       /* Reset input_line pointer.  */
1102       input_line_pointer = start;
1103
1104       if (ISDIGIT (*input_line_pointer))
1105         {
1106           reg_number = strtol (input_line_pointer, &input_line_pointer, 0);
1107         }
1108     }
1109
1110   expressionP->X_add_symbol = NULL;
1111   expressionP->X_op_symbol  = NULL;
1112
1113   /* Look to see if it's in the register table.  */
1114   if (reg_number >= 0)
1115     {
1116       expressionP->X_op         = O_constant;
1117       expressionP->X_add_number = reg_number;
1118
1119       return TRUE;
1120     }
1121
1122   /* Reset the line as if we had not done anything.  */
1123   input_line_pointer = start;
1124
1125   expressionP->X_op = O_illegal;
1126   expressionP->X_add_number = 0;
1127
1128   return FALSE;
1129 }
1130
1131 static void
1132 skip_white_space (void)
1133 {
1134   while (*input_line_pointer == ' '
1135          || *input_line_pointer == '\t')
1136     ++input_line_pointer;
1137 }
1138
1139 /* Summary of parse_register_list ().
1140
1141    in: INPUT_LINE_POINTER  points to 1st char of a list of registers.
1142        INSN                is the partially constructed instruction.
1143        OPERAND             is the operand being inserted.
1144
1145    out: NULL if the parse completed successfully, otherwise a
1146         pointer to an error message is returned.  If the parse
1147         completes the correct bit fields in the instruction
1148         will be filled in.
1149
1150    Parses register lists with the syntax:
1151
1152      { rX }
1153      { rX, rY }
1154      { rX - rY }
1155      { rX - rY, rZ }
1156      etc
1157
1158    and also parses constant expressions whoes bits indicate the
1159    registers in the lists.  The LSB in the expression refers to
1160    the lowest numbered permissible register in the register list,
1161    and so on upwards.  System registers are considered to be very
1162    high numbers.  */
1163
1164 static char *
1165 parse_register_list (unsigned long *insn,
1166                      const struct v850_operand *operand)
1167 {
1168   static int type1_regs[32] =
1169   {
1170     30,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
1171      0,  0,  0,  0,  0, 31, 29, 28, 23, 22, 21, 20, 27, 26, 25, 24
1172   };
1173
1174   int *regs;
1175   expressionS exp;
1176
1177   /* Select a register array to parse.  */
1178   switch (operand->shift)
1179     {
1180     case 0xffe00001: regs = type1_regs; break;
1181     default:
1182       as_bad (_("unknown operand shift: %x\n"), operand->shift);
1183       return _("internal failure in parse_register_list");
1184     }
1185
1186   skip_white_space ();
1187
1188   /* If the expression starts with a curly brace it is a register list.
1189      Otherwise it is a constant expression, whoes bits indicate which
1190      registers are to be included in the list.  */
1191   if (*input_line_pointer != '{')
1192     {
1193       int reg;
1194       int i;
1195
1196       expression (&exp);
1197
1198       if (exp.X_op != O_constant)
1199         return _("constant expression or register list expected");
1200
1201       if (regs == type1_regs)
1202         {
1203           if (exp.X_add_number & 0xFFFFF000)
1204             return _("high bits set in register list expression");
1205
1206           for (reg = 20; reg < 32; reg++)
1207             if (exp.X_add_number & (1 << (reg - 20)))
1208               {
1209                 for (i = 0; i < 32; i++)
1210                   if (regs[i] == reg)
1211                     *insn |= (1 << i);
1212               }
1213         }
1214
1215       return NULL;
1216     }
1217
1218   input_line_pointer++;
1219
1220   /* Parse the register list until a terminator (closing curly brace or
1221      new-line) is found.  */
1222   for (;;)
1223     {
1224       skip_white_space ();
1225
1226       if (register_name (&exp))
1227         {
1228           int i;
1229
1230           /* Locate the given register in the list, and if it is there,
1231              insert the corresponding bit into the instruction.  */
1232           for (i = 0; i < 32; i++)
1233             {
1234               if (regs[i] == exp.X_add_number)
1235                 {
1236                   *insn |= (1 << i);
1237                   break;
1238                 }
1239             }
1240
1241           if (i == 32)
1242             return _("illegal register included in list");
1243         }
1244       else if (system_register_name (&exp, TRUE))
1245         {
1246           if (regs == type1_regs)
1247             {
1248               return _("system registers cannot be included in list");
1249             }
1250         }
1251
1252       if (*input_line_pointer == '}')
1253         {
1254           input_line_pointer++;
1255           break;
1256         }
1257       else if (*input_line_pointer == ',')
1258         {
1259           input_line_pointer++;
1260           continue;
1261         }
1262       else if (*input_line_pointer == '-')
1263         {
1264           /* We have encountered a range of registers: rX - rY.  */
1265           int j;
1266           expressionS exp2;
1267
1268           /* Skip the dash.  */
1269           ++input_line_pointer;
1270
1271           /* Get the second register in the range.  */
1272           if (! register_name (&exp2))
1273             {
1274               return _("second register should follow dash in register list");
1275             }
1276
1277           if (exp.X_add_number > exp2.X_add_number)
1278             {
1279               return _("second register should greater tahn first register");
1280             }
1281
1282           /* Add the rest of the registers in the range.  */
1283           for (j = exp.X_add_number + 1; j <= exp2.X_add_number; j++)
1284             {
1285               int i;
1286
1287               /* Locate the given register in the list, and if it is there,
1288                  insert the corresponding bit into the instruction.  */
1289               for (i = 0; i < 32; i++)
1290                 {
1291                   if (regs[i] == j)
1292                     {
1293                       *insn |= (1 << i);
1294                       break;
1295                     }
1296                 }
1297
1298               if (i == 32)
1299                 return _("illegal register included in list");
1300             }
1301
1302           exp = exp2;
1303         }
1304       else
1305         break;
1306     }
1307
1308   return NULL;
1309 }
1310
1311 const char *md_shortopts = "m:";
1312
1313 struct option md_longopts[] =
1314 {
1315 #define OPTION_DISP_SIZE_DEFAULT_22 (OPTION_MD_BASE)
1316   {"disp-size-default-22", no_argument, NULL, OPTION_DISP_SIZE_DEFAULT_22},
1317 #define OPTION_DISP_SIZE_DEFAULT_32 (OPTION_MD_BASE + 1)
1318   {"disp-size-default-32", no_argument, NULL, OPTION_DISP_SIZE_DEFAULT_32},
1319   {NULL, no_argument, NULL, 0}
1320 };
1321
1322 size_t md_longopts_size = sizeof (md_longopts);
1323
1324 void
1325 md_show_usage (FILE *stream)
1326 {
1327   fprintf (stream, _(" V850 options:\n"));
1328   fprintf (stream, _("  -mwarn-signed-overflow    Warn if signed immediate values overflow\n"));
1329   fprintf (stream, _("  -mwarn-unsigned-overflow  Warn if unsigned immediate values overflow\n"));
1330   fprintf (stream, _("  -mv850                    The code is targeted at the v850\n"));
1331   fprintf (stream, _("  -mv850e                   The code is targeted at the v850e\n"));
1332   fprintf (stream, _("  -mv850e1                  The code is targeted at the v850e1\n"));
1333   fprintf (stream, _("  -mv850e2                  The code is targeted at the v850e2\n"));
1334   fprintf (stream, _("  -mv850e2v3                The code is targeted at the v850e2v3\n"));
1335   fprintf (stream, _("  -mrelax                   Enable relaxation\n"));
1336   fprintf (stream, _("  --disp-size-default-22    branch displacement with unknown size is 22 bits (default)\n"));
1337   fprintf (stream, _("  --disp-size-default-32    branch displacement with unknown size is 32 bits\n"));
1338   fprintf (stream, _("  -mextension               enable extension opcode support\n"));
1339   fprintf (stream, _("  -mno-bcond17              disable b<cond> disp17 instruction\n"));
1340   fprintf (stream, _("  -mno-stld23               disable st/ld offset23 instruction\n"));
1341 }
1342
1343 int
1344 md_parse_option (int c, char *arg)
1345 {
1346   if (c != 'm')
1347     {
1348       switch (c)
1349         {
1350         case OPTION_DISP_SIZE_DEFAULT_22:
1351           default_disp_size = 22;
1352           return 1;
1353
1354         case OPTION_DISP_SIZE_DEFAULT_32:
1355           default_disp_size = 32;
1356           return 1;
1357         }
1358       return 0;
1359     }
1360
1361   if (strcmp (arg, "warn-signed-overflow") == 0)
1362     warn_signed_overflows = TRUE;
1363
1364   else if (strcmp (arg, "warn-unsigned-overflow") == 0)
1365     warn_unsigned_overflows = TRUE;
1366
1367   else if (strcmp (arg, "v850") == 0)
1368     {
1369       machine = 0;
1370       SET_PROCESSOR_MASK (processor_mask, PROCESSOR_V850);
1371     }
1372   else if (strcmp (arg, "v850e") == 0)
1373     {
1374       machine = bfd_mach_v850e;
1375       SET_PROCESSOR_MASK (processor_mask, PROCESSOR_V850E);
1376     }
1377   else if (strcmp (arg, "v850e1") == 0)
1378     {
1379       machine = bfd_mach_v850e1;
1380       SET_PROCESSOR_MASK (processor_mask, PROCESSOR_V850E1);
1381     }
1382   else if (strcmp (arg, "v850e2") == 0)
1383     {
1384       machine = bfd_mach_v850e2;
1385       SET_PROCESSOR_MASK (processor_mask, PROCESSOR_V850E2);
1386     }
1387   else if (strcmp (arg, "v850e2v3") == 0)
1388     {
1389       machine = bfd_mach_v850e2v3;
1390       SET_PROCESSOR_MASK (processor_mask, PROCESSOR_V850E2V3);
1391     }
1392   else if (strcmp (arg, "extension") == 0)
1393     {
1394       processor_mask |= PROCESSOR_OPTION_EXTENSION | PROCESSOR_OPTION_ALIAS;;
1395     }
1396   else if (strcmp (arg, "no-bcond17") == 0)
1397     {
1398       no_bcond17 = 1;
1399     }
1400   else if (strcmp (arg, "no-stld23") == 0)
1401     {
1402       no_stld23 = 1;
1403     }
1404   else if (strcmp (arg, "relax") == 0)
1405     v850_relax = 1;
1406   else
1407     return 0;
1408
1409   return 1;
1410 }
1411
1412 symbolS *
1413 md_undefined_symbol (char *name ATTRIBUTE_UNUSED)
1414 {
1415   return 0;
1416 }
1417
1418 char *
1419 md_atof (int type, char *litp, int *sizep)
1420 {
1421   return ieee_md_atof (type, litp, sizep, FALSE);
1422 }
1423
1424 /* Very gross.  */
1425
1426 void
1427 md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED,
1428                  asection *sec,
1429                  fragS *fragP)
1430 {
1431   union u
1432   {
1433     bfd_reloc_code_real_type fx_r_type;
1434     char * fr_opcode;
1435   }
1436   opcode_converter;
1437   subseg_change (sec, 0);
1438
1439   opcode_converter.fr_opcode = fragP->fr_opcode;
1440
1441   subseg_change (sec, 0);
1442
1443   /* In range conditional or unconditional branch.  */
1444   if (fragP->fr_subtype == SUBYPTE_COND_9_22
1445       || fragP->fr_subtype == SUBYPTE_UNCOND_9_22
1446       || fragP->fr_subtype == SUBYPTE_COND_9_22_32
1447       || fragP->fr_subtype == SUBYPTE_UNCOND_9_22_32
1448       || fragP->fr_subtype == SUBYPTE_COND_9_17_22
1449       || fragP->fr_subtype == SUBYPTE_COND_9_17_22_32
1450       || fragP->fr_subtype == SUBYPTE_SA_9_22
1451       || fragP->fr_subtype == SUBYPTE_SA_9_22_32
1452       || fragP->fr_subtype == SUBYPTE_SA_9_17_22
1453       || fragP->fr_subtype == SUBYPTE_SA_9_17_22_32)
1454
1455     {
1456       fix_new (fragP, fragP->fr_fix, 2, fragP->fr_symbol,
1457                fragP->fr_offset, 1,
1458                BFD_RELOC_UNUSED + opcode_converter.fx_r_type);
1459       fragP->fr_fix += 2;
1460     }
1461   /* V850e2r-v3 17bit conditional branch.  */
1462   else if (fragP->fr_subtype == SUBYPTE_COND_9_17_22 + 1
1463            || fragP->fr_subtype == SUBYPTE_COND_9_17_22_32 + 1
1464            || fragP->fr_subtype == SUBYPTE_SA_9_17_22 + 1
1465            || fragP->fr_subtype == SUBYPTE_SA_9_17_22_32 + 1)
1466     {
1467       unsigned char *buffer =
1468         (unsigned char *) (fragP->fr_fix + fragP->fr_literal);
1469
1470       buffer[0] &= 0x0f;        /* Use condition.  */
1471       buffer[0] |= 0xe0;
1472       buffer[1] = 0x07;
1473
1474       /* Now create the unconditional branch + fixup to the final
1475          target.  */
1476       md_number_to_chars ((char *) buffer + 2, 0x0001, 2);
1477       fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol,
1478                fragP->fr_offset, 1, BFD_RELOC_V850_17_PCREL);
1479       fragP->fr_fix += 4;
1480     }
1481   /* Out of range conditional branch.  Emit a branch around a 22bit jump.  */
1482   else if (fragP->fr_subtype == SUBYPTE_COND_9_22 + 1
1483            || fragP->fr_subtype == SUBYPTE_COND_9_22_32 + 1
1484            || fragP->fr_subtype == SUBYPTE_COND_9_17_22 + 2
1485            || fragP->fr_subtype == SUBYPTE_COND_9_17_22_32 + 2)
1486     {
1487       unsigned char *buffer =
1488         (unsigned char *) (fragP->fr_fix + fragP->fr_literal);
1489
1490       /* Reverse the condition of the first branch.  */
1491       buffer[0] ^= 0x08;
1492       /* Mask off all the displacement bits.  */
1493       buffer[0] &= 0x8f;
1494       buffer[1] &= 0x07;
1495       /* Now set the displacement bits so that we branch
1496          around the unconditional branch.  */
1497       buffer[0] |= 0x30;
1498
1499       /* Now create the unconditional branch + fixup to the final
1500          target.  */
1501       md_number_to_chars ((char *) buffer + 2, 0x00000780, 4);
1502       fix_new (fragP, fragP->fr_fix + 2, 4, fragP->fr_symbol,
1503                fragP->fr_offset, 1, BFD_RELOC_V850_22_PCREL);
1504       fragP->fr_fix += 6;
1505     }
1506   /* Out of range conditional branch.  Emit a branch around a 32bit jump.  */
1507   else if (fragP->fr_subtype == SUBYPTE_COND_9_22_32 + 2
1508            || fragP->fr_subtype == SUBYPTE_COND_9_17_22_32 + 3)
1509     {
1510       unsigned char *buffer =
1511         (unsigned char *) (fragP->fr_fix + fragP->fr_literal);
1512
1513       /* Reverse the condition of the first branch.  */
1514       buffer[0] ^= 0x08;
1515       /* Mask off all the displacement bits.  */
1516       buffer[0] &= 0x8f;
1517       buffer[1] &= 0x07;
1518       /* Now set the displacement bits so that we branch
1519          around the unconditional branch.  */
1520       buffer[0] |= 0x40;
1521
1522       /* Now create the unconditional branch + fixup to the final
1523          target.  */
1524       md_number_to_chars ((char *) buffer + 2, 0x02e0, 2);
1525       fix_new (fragP, fragP->fr_fix + 4, 4, fragP->fr_symbol,
1526                fragP->fr_offset + 2, 1, BFD_RELOC_V850_32_PCREL);
1527       fragP->fr_fix += 8;
1528     }
1529   /* Out of range unconditional branch.  Emit a 22bit jump.  */
1530   else if (fragP->fr_subtype == SUBYPTE_UNCOND_9_22 + 1
1531            || fragP->fr_subtype == SUBYPTE_UNCOND_9_22_32 + 1)
1532     {
1533       md_number_to_chars (fragP->fr_fix + fragP->fr_literal, 0x00000780, 4);
1534       fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol,
1535                fragP->fr_offset, 1, BFD_RELOC_V850_22_PCREL);
1536       fragP->fr_fix += 4;
1537     }
1538   /* Out of range unconditional branch.  Emit a 32bit jump.  */
1539   else if (fragP->fr_subtype == SUBYPTE_UNCOND_9_22_32 + 2)
1540     {
1541       md_number_to_chars (fragP->fr_fix + fragP->fr_literal, 0x02e0, 2);
1542       fix_new (fragP, fragP->fr_fix + 4, 4, fragP->fr_symbol,
1543                fragP->fr_offset + 2, 1, BFD_RELOC_V850_32_PCREL);
1544       fragP->fr_fix += 6;
1545     }
1546   /* Out of range SA conditional branch.  Emit a branch to a 22bit jump.  */
1547   else if (fragP->fr_subtype == SUBYPTE_SA_9_22 + 1
1548            || fragP->fr_subtype == SUBYPTE_SA_9_22_32 + 1
1549            || fragP->fr_subtype == SUBYPTE_SA_9_17_22 + 2
1550            || fragP->fr_subtype == SUBYPTE_SA_9_17_22_32 + 2)
1551     {
1552       unsigned char *buffer =
1553         (unsigned char *) (fragP->fr_fix + fragP->fr_literal);
1554
1555       /* bsa .+4 */
1556       buffer[0] &= 0x8f;
1557       buffer[0] |= 0x20;
1558       buffer[1] &= 0x07;
1559
1560       /* br .+6 */
1561       md_number_to_chars ((char *) buffer + 2, 0x05b5, 2);
1562
1563       /* Now create the unconditional branch + fixup to the final
1564          target.  */
1565       /* jr SYM */
1566       md_number_to_chars ((char *) buffer + 4, 0x00000780, 4);
1567       fix_new (fragP, fragP->fr_fix + 4, 4, fragP->fr_symbol,
1568                fragP->fr_offset, 1,
1569                BFD_RELOC_V850_22_PCREL);
1570       fragP->fr_fix += 8;
1571     }
1572   /* Out of range SA conditional branch.  Emit a branch around a 32bit jump.  */
1573   else if (fragP->fr_subtype == SUBYPTE_SA_9_22_32 + 2
1574            || fragP->fr_subtype == SUBYPTE_SA_9_17_22_32 + 3)
1575     {
1576       unsigned char *buffer =
1577         (unsigned char *) (fragP->fr_fix + fragP->fr_literal);
1578
1579       /* bsa .+2 */
1580       buffer[0] &= 0x8f;
1581       buffer[0] |= 0x20;
1582       buffer[1] &= 0x07;
1583
1584       /* br .+8 */
1585       md_number_to_chars ((char *) buffer + 2, 0x05c5, 2);
1586
1587       /* Now create the unconditional branch + fixup to the final
1588          target.  */
1589       /* jr SYM */
1590       md_number_to_chars ((char *) buffer + 4, 0x02e0, 2);
1591       fix_new (fragP, fragP->fr_fix + 6, 4, fragP->fr_symbol,
1592                fragP->fr_offset + 2, 1, BFD_RELOC_V850_32_PCREL);
1593
1594       fragP->fr_fix += 10;
1595     }
1596   else
1597     abort ();
1598 }
1599
1600 valueT
1601 md_section_align (asection *seg, valueT addr)
1602 {
1603   int align = bfd_get_section_alignment (stdoutput, seg);
1604   return ((addr + (1 << align) - 1) & (-1 << align));
1605 }
1606
1607 void
1608 md_begin (void)
1609 {
1610   char *prev_name = "";
1611   const struct v850_opcode *op;
1612
1613   if (strncmp (TARGET_CPU, "v850e2v3", 8) == 0)
1614     {
1615       if (machine == -1)
1616         machine = bfd_mach_v850e2v3;
1617
1618       if (!processor_mask)
1619         SET_PROCESSOR_MASK (processor_mask, PROCESSOR_V850E2V3);
1620     }
1621   else if (strncmp (TARGET_CPU, "v850e2", 6) == 0)
1622     {
1623       if (machine == -1)
1624         machine = bfd_mach_v850e2;
1625
1626       if (!processor_mask)
1627         SET_PROCESSOR_MASK (processor_mask, PROCESSOR_V850E2);
1628     }
1629   else if (strncmp (TARGET_CPU, "v850e1", 6) == 0)
1630     {
1631       if (machine == -1)
1632         machine = bfd_mach_v850e1;
1633
1634       if (!processor_mask)
1635         SET_PROCESSOR_MASK (processor_mask, PROCESSOR_V850E1);
1636     }
1637   else if (strncmp (TARGET_CPU, "v850e", 5) == 0)
1638     {
1639       if (machine == -1)
1640         machine = bfd_mach_v850e;
1641
1642       if (!processor_mask)
1643         SET_PROCESSOR_MASK (processor_mask, PROCESSOR_V850E);
1644     }
1645   else if (strncmp (TARGET_CPU, "v850", 4) == 0)
1646     {
1647       if (machine == -1)
1648         machine = 0;
1649
1650       if (!processor_mask)
1651         SET_PROCESSOR_MASK (processor_mask, PROCESSOR_V850);
1652     }
1653   else
1654     /* xgettext:c-format  */
1655     as_bad (_("Unable to determine default target processor from string: %s"),
1656             TARGET_CPU);
1657
1658   v850_hash = hash_new ();
1659
1660   /* Insert unique names into hash table.  The V850 instruction set
1661      has many identical opcode names that have different opcodes based
1662      on the operands.  This hash table then provides a quick index to
1663      the first opcode with a particular name in the opcode table.  */
1664   op = v850_opcodes;
1665   while (op->name)
1666     {
1667       if (strcmp (prev_name, op->name))
1668         {
1669           prev_name = (char *) op->name;
1670           hash_insert (v850_hash, op->name, (char *) op);
1671         }
1672       op++;
1673     }
1674
1675   v850_seg_table[BSS_SECTION].s = bss_section;
1676   bfd_set_arch_mach (stdoutput, TARGET_ARCH, machine);
1677 }
1678
1679
1680 static bfd_reloc_code_real_type
1681 handle_hi016 (const struct v850_operand *operand, const char **errmsg)
1682 {
1683   if (operand == NULL)
1684     return BFD_RELOC_HI16;
1685
1686   if (operand->default_reloc == BFD_RELOC_HI16)
1687     return BFD_RELOC_HI16;
1688
1689   if (operand->default_reloc == BFD_RELOC_HI16_S)
1690     return BFD_RELOC_HI16;
1691
1692   if (operand->default_reloc == BFD_RELOC_16)
1693     return BFD_RELOC_HI16;
1694
1695   *errmsg = _("hi0() relocation used on an instruction which does "
1696               "not support it");
1697   return BFD_RELOC_64;  /* Used to indicate an error condition.  */
1698 }
1699
1700 static bfd_reloc_code_real_type
1701 handle_hi16 (const struct v850_operand *operand, const char **errmsg)
1702 {
1703   if (operand == NULL)
1704     return BFD_RELOC_HI16_S;
1705
1706   if (operand->default_reloc == BFD_RELOC_HI16_S)
1707     return BFD_RELOC_HI16_S;
1708
1709   if (operand->default_reloc == BFD_RELOC_HI16)
1710     return BFD_RELOC_HI16_S;
1711
1712   if (operand->default_reloc == BFD_RELOC_16)
1713     return BFD_RELOC_HI16_S;
1714
1715   *errmsg = _("hi() relocation used on an instruction which does "
1716               "not support it");
1717   return BFD_RELOC_64;  /* Used to indicate an error condition.  */
1718 }
1719
1720 static bfd_reloc_code_real_type
1721 handle_lo16 (const struct v850_operand *operand, const char **errmsg)
1722 {
1723   if (operand == NULL)
1724     return BFD_RELOC_LO16;
1725
1726   if (operand->default_reloc == BFD_RELOC_LO16)
1727     return BFD_RELOC_LO16;
1728
1729   if (operand->default_reloc == BFD_RELOC_V850_16_SPLIT_OFFSET)
1730     return BFD_RELOC_V850_LO16_SPLIT_OFFSET;
1731
1732   if (operand->default_reloc == BFD_RELOC_V850_16_S1)
1733     return BFD_RELOC_V850_LO16_S1;
1734
1735   if (operand->default_reloc == BFD_RELOC_16)
1736     return BFD_RELOC_LO16;
1737
1738   *errmsg = _("lo() relocation used on an instruction which does "
1739               "not support it");
1740   return BFD_RELOC_64;  /* Used to indicate an error condition.  */
1741 }
1742
1743 static bfd_reloc_code_real_type
1744 handle_ctoff (const struct v850_operand *operand, const char **errmsg)
1745 {
1746   if (operand == NULL)
1747     return BFD_RELOC_V850_CALLT_16_16_OFFSET;
1748
1749   if (operand->default_reloc == BFD_RELOC_V850_CALLT_6_7_OFFSET)
1750     return operand->default_reloc;
1751
1752   if (operand->default_reloc == BFD_RELOC_V850_16_S1)
1753     return BFD_RELOC_V850_CALLT_15_16_OFFSET;
1754
1755   if (operand->default_reloc == BFD_RELOC_16)
1756     return BFD_RELOC_V850_CALLT_16_16_OFFSET;
1757
1758   *errmsg = _("ctoff() relocation used on an instruction which does not support it");
1759   return BFD_RELOC_64;  /* Used to indicate an error condition.  */
1760 }
1761
1762 static bfd_reloc_code_real_type
1763 handle_sdaoff (const struct v850_operand *operand, const char **errmsg)
1764 {
1765   if (operand == NULL)
1766     return BFD_RELOC_V850_SDA_16_16_OFFSET;
1767
1768   if (operand->default_reloc == BFD_RELOC_V850_16_SPLIT_OFFSET)
1769     return BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET;
1770
1771   if (operand->default_reloc == BFD_RELOC_16)
1772     return BFD_RELOC_V850_SDA_16_16_OFFSET;
1773
1774   if (operand->default_reloc == BFD_RELOC_V850_16_S1)
1775     return BFD_RELOC_V850_SDA_15_16_OFFSET;
1776
1777   *errmsg = _("sdaoff() relocation used on an instruction which does not support it");
1778   return BFD_RELOC_64;  /* Used to indicate an error condition.  */
1779 }
1780
1781 static bfd_reloc_code_real_type
1782 handle_zdaoff (const struct v850_operand *operand, const char **errmsg)
1783 {
1784   if (operand == NULL)
1785     return BFD_RELOC_V850_ZDA_16_16_OFFSET;
1786
1787   if (operand->default_reloc == BFD_RELOC_V850_16_SPLIT_OFFSET)
1788     return BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET;
1789
1790   if (operand->default_reloc == BFD_RELOC_16)
1791     return BFD_RELOC_V850_ZDA_16_16_OFFSET;
1792
1793   if (operand->default_reloc == BFD_RELOC_V850_16_S1)
1794     return BFD_RELOC_V850_ZDA_15_16_OFFSET;
1795
1796   *errmsg = _("zdaoff() relocation used on an instruction which does not support it");
1797   return BFD_RELOC_64;  /* Used to indicate an error condition.  */
1798 }
1799
1800 static bfd_reloc_code_real_type
1801 handle_tdaoff (const struct v850_operand *operand, const char **errmsg)
1802 {
1803   if (operand == NULL)
1804     /* Data item, not an instruction.  */
1805     return BFD_RELOC_V850_TDA_16_16_OFFSET;
1806
1807   switch (operand->default_reloc)
1808     {
1809       /* sld.hu, operand: D5-4.  */
1810     case BFD_RELOC_V850_TDA_4_5_OFFSET:
1811       /* sld.bu, operand: D4.  */
1812     case BFD_RELOC_V850_TDA_4_4_OFFSET:
1813     /* sld.w/sst.w, operand: D8_6.  */
1814     case BFD_RELOC_V850_TDA_6_8_OFFSET:
1815     /* sld.h/sst.h, operand: D8_7.  */
1816     case BFD_RELOC_V850_TDA_7_8_OFFSET:
1817       /* sld.b/sst.b, operand: D7.  */
1818     case BFD_RELOC_V850_TDA_7_7_OFFSET:
1819       return operand->default_reloc;
1820     default:
1821       break;
1822     }
1823
1824   if (operand->default_reloc == BFD_RELOC_16 && operand->shift == 16)
1825     /* set1 & chums, operands: D16.  */
1826     return BFD_RELOC_V850_TDA_16_16_OFFSET;
1827
1828   *errmsg = _("tdaoff() relocation used on an instruction which does not support it");
1829   /* Used to indicate an error condition.  */
1830   return BFD_RELOC_64;
1831 }
1832
1833 /* Warning: The code in this function relies upon the definitions
1834    in the v850_operands[] array (defined in opcodes/v850-opc.c)
1835    matching the hard coded values contained herein.  */
1836
1837 static bfd_reloc_code_real_type
1838 v850_reloc_prefix (const struct v850_operand *operand, const char **errmsg)
1839 {
1840   bfd_boolean paren_skipped = FALSE;
1841
1842   /* Skip leading opening parenthesis.  */
1843   if (*input_line_pointer == '(')
1844     {
1845       ++input_line_pointer;
1846       paren_skipped = TRUE;
1847     }
1848
1849 #define CHECK_(name, reloc)                                             \
1850   if (strncmp (input_line_pointer, name "(", strlen (name) + 1) == 0)   \
1851     {                                                                   \
1852       input_line_pointer += strlen (name);                              \
1853       return reloc;                                                     \
1854     }
1855
1856   CHECK_ ("hi0",    handle_hi016(operand, errmsg)  );
1857   CHECK_ ("hi",     handle_hi16(operand, errmsg)   );
1858   CHECK_ ("lo",     handle_lo16 (operand, errmsg)  );
1859   CHECK_ ("sdaoff", handle_sdaoff (operand, errmsg));
1860   CHECK_ ("zdaoff", handle_zdaoff (operand, errmsg));
1861   CHECK_ ("tdaoff", handle_tdaoff (operand, errmsg));
1862   CHECK_ ("hilo",   BFD_RELOC_32);
1863   CHECK_ ("lo23",   BFD_RELOC_V850_23);
1864   CHECK_ ("ctoff",  handle_ctoff (operand, errmsg) );
1865
1866   /* Restore skipped parenthesis.  */
1867   if (paren_skipped)
1868     --input_line_pointer;
1869
1870   return BFD_RELOC_UNUSED;
1871 }
1872
1873 /* Insert an operand value into an instruction.  */
1874
1875 static unsigned long
1876 v850_insert_operand (unsigned long insn,
1877                      const struct v850_operand *operand,
1878                      offsetT val,
1879                      const char **errmsg)
1880 {
1881   if (operand->insert)
1882     {
1883       const char *message = NULL;
1884
1885       insn = operand->insert (insn, val, &message);
1886       if (message != NULL)
1887         {
1888           if ((operand->flags & V850_OPERAND_SIGNED)
1889               && ! warn_signed_overflows
1890               && v850_msg_is_out_of_range (message))
1891             {
1892               /* Skip warning...  */
1893             }
1894           else if ((operand->flags & V850_OPERAND_SIGNED) == 0
1895                    && ! warn_unsigned_overflows
1896                   && v850_msg_is_out_of_range (message))
1897             {
1898               /* Skip warning...  */
1899             }
1900           else
1901             {
1902              if (errmsg != NULL)
1903                *errmsg = message;
1904             }
1905         }
1906     }
1907   else if (operand->bits == -1
1908           || operand->flags & V850E_IMMEDIATE16
1909           || operand->flags & V850E_IMMEDIATE23
1910           || operand->flags & V850E_IMMEDIATE32)
1911     {
1912       abort ();
1913     }
1914   else
1915     {
1916       if (operand->bits < 32)
1917         {
1918           long min, max;
1919
1920           if ((operand->flags & V850_OPERAND_SIGNED) != 0)
1921             {
1922               if (! warn_signed_overflows)
1923                 max = (1 << operand->bits) - 1;
1924               else
1925                 max = (1 << (operand->bits - 1)) - 1;
1926
1927               min = -(1 << (operand->bits - 1));
1928             }
1929           else
1930             {
1931               max = (1 << operand->bits) - 1;
1932
1933               if (! warn_unsigned_overflows)
1934                 min = -(1 << (operand->bits - 1));
1935               else
1936                 min = 0;
1937             }
1938
1939           /* Some people write constants with the sign extension done by
1940              hand but only up to 32 bits.  This shouldn't really be valid,
1941              but, to permit this code to assemble on a 64-bit host, we
1942              sign extend the 32-bit value to 64 bits if so doing makes the
1943              value valid.  */
1944           if (val > max
1945               && (offsetT) (val - 0x80000000 - 0x80000000) >= min
1946               && (offsetT) (val - 0x80000000 - 0x80000000) <= max)
1947             val = val - 0x80000000 - 0x80000000;
1948
1949           /* Similarly, people write expressions like ~(1<<15), and expect
1950              this to be OK for a 32-bit unsigned value.  */
1951           else if (val < min
1952                    && (offsetT) (val + 0x80000000 + 0x80000000) >= min
1953                    && (offsetT) (val + 0x80000000 + 0x80000000) <= max)
1954             val = val + 0x80000000 + 0x80000000;
1955
1956           else if (val < (offsetT) min || val > (offsetT) max)
1957             {
1958               char buf [128];
1959
1960               /* Restore min and mix to expected values for decimal ranges.  */
1961               if ((operand->flags & V850_OPERAND_SIGNED)
1962                   && ! warn_signed_overflows)
1963                 max = (1 << (operand->bits - 1)) - 1;
1964
1965               if (! (operand->flags & V850_OPERAND_SIGNED)
1966                   && ! warn_unsigned_overflows)
1967                 min = 0;
1968
1969               sprintf (buf, _("operand out of range (%d is not between %d and %d)"),
1970                        (int) val, (int) min, (int) max);
1971               *errmsg = buf;
1972             }
1973
1974           insn |= (((long) val & ((1 << operand->bits) - 1)) << operand->shift);
1975         }
1976       else
1977         {
1978           insn |= (((long) val) << operand->shift);
1979         }
1980     }
1981
1982   return insn;
1983 }
1984 \f
1985 static char copy_of_instruction[128];
1986
1987 void
1988 md_assemble (char *str)
1989 {
1990   char *s;
1991   char *start_of_operands;
1992   struct v850_opcode *opcode;
1993   struct v850_opcode *next_opcode;
1994   const unsigned char *opindex_ptr;
1995   int next_opindex;
1996   int relaxable = 0;
1997   unsigned long insn;
1998   unsigned long insn_size;
1999   char *f;
2000   int i;
2001   int match;
2002   bfd_boolean extra_data_after_insn = FALSE;
2003   unsigned extra_data_len = 0;
2004   unsigned long extra_data = 0;
2005   char *saved_input_line_pointer;
2006   char most_match_errmsg[1024];
2007   int most_match_count = -1;
2008
2009   strncpy (copy_of_instruction, str, sizeof (copy_of_instruction) - 1);
2010   most_match_errmsg[0] = 0;
2011
2012   /* Get the opcode.  */
2013   for (s = str; *s != '\0' && ! ISSPACE (*s); s++)
2014     continue;
2015
2016   if (*s != '\0')
2017     *s++ = '\0';
2018
2019   /* Find the first opcode with the proper name.  */
2020   opcode = (struct v850_opcode *) hash_find (v850_hash, str);
2021   if (opcode == NULL)
2022     {
2023       /* xgettext:c-format  */
2024       as_bad (_("Unrecognized opcode: `%s'"), str);
2025       ignore_rest_of_line ();
2026       return;
2027     }
2028
2029   str = s;
2030   while (ISSPACE (*str))
2031     ++str;
2032
2033   start_of_operands = str;
2034
2035   saved_input_line_pointer = input_line_pointer;
2036
2037   for (;;)
2038     {
2039       const char *errmsg = NULL;
2040       const char *warningmsg = NULL;
2041
2042       match = 0;
2043       opindex_ptr = opcode->operands;
2044
2045       if (no_stld23)
2046         {
2047           if ((strncmp (opcode->name, "st.", 3) == 0
2048                && v850_operands[opcode->operands[1]].bits == 23)
2049               || (strncmp (opcode->name, "ld.", 3) == 0
2050                   && v850_operands[opcode->operands[0]].bits == 23))
2051             {
2052               errmsg = _("st/ld offset 23 instruction was disabled .");
2053               goto error;
2054             }
2055         }
2056
2057       if ((opcode->processors & processor_mask & PROCESSOR_MASK) == 0
2058           || (((opcode->processors & ~PROCESSOR_MASK) != 0)
2059               && ((opcode->processors & processor_mask & ~PROCESSOR_MASK) == 0)))
2060         {
2061           errmsg = _("Target processor does not support this instruction.");
2062           goto error;
2063         }
2064
2065       relaxable = 0;
2066       fc = 0;
2067       next_opindex = 0;
2068       insn = opcode->opcode;
2069       extra_data_len = 0;
2070       extra_data_after_insn = FALSE;
2071
2072       input_line_pointer = str = start_of_operands;
2073
2074       for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++)
2075         {
2076           const struct v850_operand *operand;
2077           char *hold;
2078           expressionS ex;
2079           bfd_reloc_code_real_type reloc;
2080
2081           if (next_opindex == 0)
2082             operand = &v850_operands[*opindex_ptr];
2083           else
2084             {
2085               operand = &v850_operands[next_opindex];
2086               next_opindex = 0;
2087             }
2088
2089           errmsg = NULL;
2090
2091           while (*str == ' ')
2092             ++str;
2093
2094           if (operand->flags & V850_OPERAND_BANG
2095               && *str == '!')
2096             ++str;
2097           else if (operand->flags & V850_OPERAND_PERCENT
2098                    && *str == '%')
2099             ++str;
2100
2101           if (*str == ',' || *str == '[' || *str == ']')
2102             ++str;
2103
2104           while (*str == ' ')
2105             ++str;
2106
2107           if (operand->flags & V850_OPERAND_RELAX)
2108             relaxable = 1;
2109
2110           /* Gather the operand.  */
2111           hold = input_line_pointer;
2112           input_line_pointer = str;
2113
2114           /* lo(), hi(), hi0(), etc...  */
2115           if ((reloc = v850_reloc_prefix (operand, &errmsg)) != BFD_RELOC_UNUSED)
2116             {
2117               /* This is a fake reloc, used to indicate an error condition.  */
2118               if (reloc == BFD_RELOC_64)
2119                 {
2120                   /* match = 1;  */
2121                   goto error;
2122                 }
2123
2124               expression (&ex);
2125
2126               if (ex.X_op == O_constant)
2127                 {
2128                   switch (reloc)
2129                     {
2130                     case BFD_RELOC_V850_ZDA_16_16_OFFSET:
2131                     case BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET:
2132                     case BFD_RELOC_V850_ZDA_15_16_OFFSET:
2133                       /* To cope with "not1 7, zdaoff(0xfffff006)[r0]"
2134                          and the like.  */
2135                       /* Fall through.  */
2136
2137                     case BFD_RELOC_LO16:
2138                     case BFD_RELOC_V850_LO16_S1:
2139                     case BFD_RELOC_V850_LO16_SPLIT_OFFSET:
2140                       {
2141                         /* Truncate, then sign extend the value.  */
2142                         ex.X_add_number = SEXT16 (ex.X_add_number);
2143                         break;
2144                       }
2145
2146                     case BFD_RELOC_HI16:
2147                       {
2148                         /* Truncate, then sign extend the value.  */
2149                         ex.X_add_number = SEXT16 (ex.X_add_number >> 16);
2150                         break;
2151                       }
2152
2153                     case BFD_RELOC_HI16_S:
2154                       {
2155                         /* Truncate, then sign extend the value.  */
2156                         int temp = (ex.X_add_number >> 16) & 0xffff;
2157
2158                         temp += (ex.X_add_number >> 15) & 1;
2159
2160                         ex.X_add_number = SEXT16 (temp);
2161                         break;
2162                       }
2163
2164                     case BFD_RELOC_V850_23:
2165                       if ((operand->flags & V850E_IMMEDIATE23) == 0)
2166                         {
2167                           errmsg = _("immediate operand is too large");
2168                           goto error;
2169                         }
2170                       break;
2171
2172                     case BFD_RELOC_32:
2173                     case BFD_RELOC_V850_32_ABS:
2174                     case BFD_RELOC_V850_32_PCREL:
2175                       if ((operand->flags & V850E_IMMEDIATE32) == 0)
2176                         {
2177                           errmsg = _("immediate operand is too large");
2178                           goto error;
2179                         }
2180
2181                       break;
2182
2183                     default:
2184                       fprintf (stderr, "reloc: %d\n", reloc);
2185                       as_bad (_("AAARG -> unhandled constant reloc"));
2186                       break;
2187                     }
2188
2189                   if (operand->flags & V850E_IMMEDIATE32)
2190                     {
2191                       extra_data_after_insn = TRUE;
2192                       extra_data_len        = 4;
2193                       extra_data            = 0;
2194                     }
2195                   else if (operand->flags & V850E_IMMEDIATE23)
2196                     {
2197                       if (reloc != BFD_RELOC_V850_23)
2198                         {
2199                           errmsg = _("immediate operand is too large");
2200                           goto error;
2201                         }
2202                       extra_data_after_insn = TRUE;
2203                       extra_data_len        = 2;
2204                       extra_data            = 0;
2205                     }
2206                   else if ((operand->flags & V850E_IMMEDIATE16)
2207                            || (operand->flags & V850E_IMMEDIATE16HI))
2208                     {
2209                       if (operand->flags & V850E_IMMEDIATE16HI
2210                           && reloc != BFD_RELOC_HI16
2211                           && reloc != BFD_RELOC_HI16_S)
2212                         {
2213                           errmsg = _("immediate operand is too large");
2214                           goto error;
2215                         }
2216                       else if (operand->flags & V850E_IMMEDIATE16
2217                                && reloc != BFD_RELOC_LO16)
2218                         {
2219                           errmsg = _("immediate operand is too large");
2220                           goto error;
2221                         }
2222
2223                       extra_data_after_insn = TRUE;
2224                       extra_data_len        = 2;
2225                       extra_data            = 0;
2226                     }
2227
2228                   if (fc > MAX_INSN_FIXUPS)
2229                     as_fatal (_("too many fixups"));
2230
2231                   fixups[fc].exp     = ex;
2232                   fixups[fc].opindex = *opindex_ptr;
2233                   fixups[fc].reloc   = reloc;
2234                   fc++;
2235                 }
2236               else      /* ex.X_op != O_constant.  */
2237                 {
2238                   if ((reloc == BFD_RELOC_32
2239                        || reloc == BFD_RELOC_V850_32_ABS
2240                        || reloc == BFD_RELOC_V850_32_PCREL)
2241                       && operand->bits < 32)
2242                     {
2243                       errmsg = _("immediate operand is too large");
2244                       goto error;
2245                     }
2246                   else if (reloc == BFD_RELOC_V850_23
2247                            && (operand->flags & V850E_IMMEDIATE23) == 0)
2248                     {
2249                       errmsg = _("immediate operand is too large");
2250                       goto error;
2251                     }
2252                   else if ((reloc == BFD_RELOC_HI16
2253                             || reloc == BFD_RELOC_HI16_S)
2254                            && operand->bits < 16)
2255                     {
2256                       errmsg = _("immediate operand is too large");
2257                       goto error;
2258                     }
2259
2260                   if (operand->flags & V850E_IMMEDIATE32)
2261                     {
2262                       extra_data_after_insn = TRUE;
2263                       extra_data_len        = 4;
2264                       extra_data            = 0;
2265                     }
2266                   else if (operand->flags & V850E_IMMEDIATE23)
2267                     {
2268                       if (reloc != BFD_RELOC_V850_23)
2269                         {
2270                           errmsg = _("immediate operand is too large");
2271                           goto error;
2272                         }
2273                       extra_data_after_insn = TRUE;
2274                       extra_data_len        = 2;
2275                       extra_data            = 0;
2276                     }
2277                   else if ((operand->flags & V850E_IMMEDIATE16)
2278                            || (operand->flags & V850E_IMMEDIATE16HI))
2279                     {
2280                       if (operand->flags & V850E_IMMEDIATE16HI
2281                           && reloc != BFD_RELOC_HI16
2282                           && reloc != BFD_RELOC_HI16_S)
2283                         {
2284                           errmsg = _("immediate operand is too large");
2285                           goto error;
2286                         }
2287                       else if (operand->flags & V850E_IMMEDIATE16
2288                                && reloc != BFD_RELOC_LO16)
2289                         {
2290                           errmsg = _("immediate operand is too large");
2291                           goto error;
2292                         }
2293
2294                       extra_data_after_insn = TRUE;
2295                       extra_data_len        = 2;
2296                       extra_data            = 0;
2297                     }
2298
2299                   if (fc > MAX_INSN_FIXUPS)
2300                     as_fatal (_("too many fixups"));
2301
2302                   fixups[fc].exp     = ex;
2303                   fixups[fc].opindex = *opindex_ptr;
2304                   fixups[fc].reloc   = reloc;
2305                   fc++;
2306                 }
2307             }
2308           else if (operand->flags & V850E_IMMEDIATE16
2309                    || operand->flags & V850E_IMMEDIATE16HI)
2310             {
2311               expression (&ex);
2312
2313               switch (ex.X_op)
2314                 {
2315                 case O_constant:
2316                   if (operand->flags & V850E_IMMEDIATE16HI)
2317                     {
2318                       if (ex.X_add_number & 0xffff)
2319                         {
2320                           errmsg = _("constant too big to fit into instruction");
2321                           goto error;
2322                         }
2323
2324                       ex.X_add_number >>= 16;
2325                     }
2326                   if (operand->flags & V850E_IMMEDIATE16)
2327                     {
2328                       if (ex.X_add_number & 0xffff0000)
2329                         {
2330                           errmsg = _("constant too big to fit into instruction");
2331                           goto error;
2332                         }
2333                     }
2334                   break;
2335
2336                 case O_illegal:
2337                   errmsg = _("illegal operand");
2338                   goto error;
2339
2340                 case O_absent:
2341                   errmsg = _("missing operand");
2342                   goto error;
2343
2344                 default:
2345                   if (fc >= MAX_INSN_FIXUPS)
2346                     as_fatal (_("too many fixups"));
2347
2348                   fixups[fc].exp     = ex;
2349                   fixups[fc].opindex = *opindex_ptr;
2350                   fixups[fc].reloc   = operand->default_reloc;
2351                   ++fc;
2352
2353                   ex.X_add_number = 0;
2354                   break;
2355                 }
2356
2357               extra_data_after_insn = TRUE;
2358               extra_data_len        = 2;
2359               extra_data            = ex.X_add_number;
2360             }
2361           else if (operand->flags & V850E_IMMEDIATE23)
2362             {
2363               expression (&ex);
2364
2365               switch (ex.X_op)
2366                 {
2367                 case O_constant:
2368                   break;
2369
2370                 case O_illegal:
2371                   errmsg = _("illegal operand");
2372                   goto error;
2373
2374                 case O_absent:
2375                   errmsg = _("missing operand");
2376                   goto error;
2377
2378                 default:
2379                   break;
2380                 }
2381
2382               if (fc >= MAX_INSN_FIXUPS)
2383                 as_fatal (_("too many fixups"));
2384
2385               fixups[fc].exp     = ex;
2386               fixups[fc].opindex = *opindex_ptr;
2387               fixups[fc].reloc   = operand->default_reloc;
2388               ++fc;
2389
2390               extra_data_after_insn = TRUE;
2391               extra_data_len        = 2;
2392               extra_data            = 0;
2393             }
2394           else if (operand->flags & V850E_IMMEDIATE32)
2395             {
2396               expression (&ex);
2397
2398               switch (ex.X_op)
2399                 {
2400                 case O_constant:
2401                   if ((operand->default_reloc == BFD_RELOC_V850_32_ABS
2402                        || operand->default_reloc == BFD_RELOC_V850_32_PCREL)
2403                       && (ex.X_add_number & 1))
2404                     {
2405                       errmsg = _("odd number cannot be used here");
2406                       goto error;
2407                     }
2408                   break;
2409
2410                 case O_illegal:
2411                   errmsg = _("illegal operand");
2412                   goto error;
2413
2414                 case O_absent:
2415                   errmsg = _("missing operand");
2416                   goto error;
2417
2418                 default:
2419                   if (fc >= MAX_INSN_FIXUPS)
2420                     as_fatal (_("too many fixups"));
2421
2422                   fixups[fc].exp     = ex;
2423                   fixups[fc].opindex = *opindex_ptr;
2424                   fixups[fc].reloc   = operand->default_reloc;
2425                   ++fc;
2426
2427                   ex.X_add_number = 0;
2428                   break;
2429                 }
2430
2431               extra_data_after_insn = TRUE;
2432               extra_data_len        = 4;
2433               extra_data            = ex.X_add_number;
2434             }
2435           else if (operand->flags & V850E_OPERAND_REG_LIST)
2436             {
2437               errmsg = parse_register_list (&insn, operand);
2438
2439               if (errmsg)
2440                 goto error;
2441             }
2442           else
2443             {
2444               errmsg = NULL;
2445
2446               if ((operand->flags & V850_OPERAND_REG) != 0)
2447                 {
2448                   if (!register_name (&ex))
2449                     {
2450                       errmsg = _("invalid register name");
2451                     }
2452
2453                   if ((operand->flags & V850_NOT_R0)
2454                            && ex.X_add_number == 0)
2455                     {
2456                       errmsg = _("register r0 cannot be used here");
2457                     }
2458
2459                   if (operand->flags & V850_REG_EVEN)
2460                     {
2461                       if (ex.X_add_number % 2)
2462                         errmsg = _("odd register cannot be used here");
2463                       ex.X_add_number = ex.X_add_number / 2;
2464                     }
2465
2466                 }
2467               else if ((operand->flags & V850_OPERAND_SRG) != 0)
2468                 {
2469                   if (!system_register_name (&ex, TRUE))
2470                     {
2471                       errmsg = _("invalid system register name");
2472                     }
2473                 }
2474               else if ((operand->flags & V850_OPERAND_EP) != 0)
2475                 {
2476                   char *start = input_line_pointer;
2477                   char c = get_symbol_end ();
2478
2479                   if (strcmp (start, "ep") != 0 && strcmp (start, "r30") != 0)
2480                     {
2481                       /* Put things back the way we found them.  */
2482                       *input_line_pointer = c;
2483                       input_line_pointer = start;
2484                       errmsg = _("expected EP register");
2485                       goto error;
2486                     }
2487
2488                   *input_line_pointer = c;
2489                   str = input_line_pointer;
2490                   input_line_pointer = hold;
2491
2492                   while (*str == ' ' || *str == ','
2493                          || *str == '[' || *str == ']')
2494                     ++str;
2495                   continue;
2496                 }
2497               else if ((operand->flags & V850_OPERAND_CC) != 0)
2498                 {
2499                   if (!cc_name (&ex, TRUE))
2500                     {
2501                       errmsg = _("invalid condition code name");
2502                     }
2503
2504                   if ((operand->flags & V850_NOT_SA)
2505                       && ex.X_add_number == COND_SA_NUM)
2506                     {
2507                       errmsg = _("condition sa cannot be used here");
2508                     }
2509                 }
2510               else if ((operand->flags & V850_OPERAND_FLOAT_CC) != 0)
2511                 {
2512                   if (!float_cc_name (&ex, TRUE))
2513                     {
2514                       errmsg = _("invalid condition code name");
2515                     }
2516                 }
2517               else if ((register_name (&ex)
2518                         && (operand->flags & V850_OPERAND_REG) == 0))
2519                 {
2520                   char c;
2521                   int exists = 0;
2522
2523                   /* It is possible that an alias has been defined that
2524                      matches a register name.  For example the code may
2525                      include a ".set ZERO, 0" directive, which matches
2526                      the register name "zero".  Attempt to reparse the
2527                      field as an expression, and only complain if we
2528                      cannot generate a constant.  */
2529
2530                   input_line_pointer = str;
2531
2532                   c = get_symbol_end ();
2533
2534                   if (symbol_find (str) != NULL)
2535                     exists = 1;
2536
2537                   *input_line_pointer = c;
2538                   input_line_pointer = str;
2539
2540                   expression (&ex);
2541
2542                   if (ex.X_op != O_constant)
2543                     {
2544                       /* If this register is actually occurring too early on
2545                          the parsing of the instruction, (because another
2546                          field is missing) then report this.  */
2547                       if (opindex_ptr[1] != 0
2548                           && ((v850_operands[opindex_ptr[1]].flags
2549                                & V850_OPERAND_REG)
2550                               ||(v850_operands[opindex_ptr[1]].flags
2551                                  & V850_OPERAND_VREG)))
2552                         errmsg = _("syntax error: value is missing before the register name");
2553                       else
2554                         errmsg = _("syntax error: register not expected");
2555
2556                       /* If we created a symbol in the process of this
2557                          test then delete it now, so that it will not
2558                          be output with the real symbols...  */
2559                       if (exists == 0
2560                           && ex.X_op == O_symbol)
2561                         symbol_remove (ex.X_add_symbol,
2562                                        &symbol_rootP, &symbol_lastP);
2563                     }
2564                 }
2565               else if (system_register_name (&ex, FALSE)
2566                        && (operand->flags & V850_OPERAND_SRG) == 0)
2567                 {
2568                   errmsg = _("syntax error: system register not expected");
2569                 }
2570               else if (cc_name (&ex, FALSE)
2571                        && (operand->flags & V850_OPERAND_CC) == 0)
2572                 {
2573                   errmsg = _("syntax error: condition code not expected");
2574                 }
2575               else if (float_cc_name (&ex, FALSE)
2576                        && (operand->flags & V850_OPERAND_FLOAT_CC) == 0)
2577                 {
2578                   errmsg = _("syntax error: condition code not expected");
2579                 }
2580               else
2581                 {
2582                   expression (&ex);
2583
2584                   if ((operand->flags & V850_NOT_IMM0)
2585                       && ex.X_op == O_constant
2586                       && ex.X_add_number == 0)
2587                     {
2588                       errmsg = _("immediate 0 cannot be used here");
2589                     }
2590
2591                   /* Special case:
2592                      If we are assembling a MOV/JARL/JR instruction and the immediate
2593                      value does not fit into the bits available then create a
2594                      fake error so that the next MOV/JARL/JR instruction will be
2595                      selected.  This one has a 32 bit immediate field.  */
2596
2597                   if ((strcmp (opcode->name, "mov") == 0
2598                        || strcmp (opcode->name, "jarl") == 0
2599                        || strcmp (opcode->name, "jr") == 0)
2600                       && ex.X_op == O_constant
2601                       && (ex.X_add_number < (-(1 << (operand->bits - 1)))
2602                           || ex.X_add_number > ((1 << (operand->bits - 1)) - 1)))
2603                     {
2604                       errmsg = _("immediate operand is too large");
2605                     }
2606
2607                   if ((strcmp (opcode->name, "jarl") == 0
2608                        || strcmp (opcode->name, "jr") == 0)
2609                       && ex.X_op != O_constant
2610                       && operand->bits != default_disp_size)
2611                     {
2612                       errmsg = _("immediate operand is not match");
2613                     }
2614                 }
2615
2616               if (errmsg)
2617                 goto error;
2618
2619               switch (ex.X_op)
2620                 {
2621                 case O_illegal:
2622                   errmsg = _("illegal operand");
2623                   goto error;
2624                 case O_absent:
2625                   errmsg = _("missing operand");
2626                   goto error;
2627                 case O_register:
2628                   if ((operand->flags
2629                        & (V850_OPERAND_REG | V850_OPERAND_SRG | V850_OPERAND_VREG)) == 0)
2630                     {
2631                       errmsg = _("invalid operand");
2632                       goto error;
2633                     }
2634
2635                   insn = v850_insert_operand (insn, operand,
2636                                               ex.X_add_number,
2637                                               &warningmsg);
2638
2639                   break;
2640
2641                 case O_constant:
2642                   insn = v850_insert_operand (insn, operand, ex.X_add_number,
2643                                               &warningmsg);
2644                   break;
2645
2646                 default:
2647                   /* We need to generate a fixup for this expression.  */
2648                   if (fc >= MAX_INSN_FIXUPS)
2649                     as_fatal (_("too many fixups"));
2650
2651                   fixups[fc].exp     = ex;
2652                   fixups[fc].opindex = *opindex_ptr;
2653                   fixups[fc].reloc   = BFD_RELOC_UNUSED;
2654                   ++fc;
2655                   break;
2656                 }
2657             }
2658
2659           str = input_line_pointer;
2660           input_line_pointer = hold;
2661
2662           while (*str == ' ' || *str == ',' || *str == '[' || *str == ']'
2663                  || *str == ')')
2664             ++str;
2665         }
2666
2667       while (ISSPACE (*str))
2668         ++str;
2669
2670       if (*str == '\0')
2671         match = 1;
2672
2673     error:
2674       if (match == 0)
2675         {
2676           if ((opindex_ptr - opcode->operands) >= most_match_count)
2677             {
2678               most_match_count = opindex_ptr - opcode->operands;
2679               if (errmsg != NULL)
2680                 strncpy (most_match_errmsg, errmsg, sizeof (most_match_errmsg)-1);
2681             }
2682
2683           next_opcode = opcode + 1;
2684           if (next_opcode->name != NULL
2685               && strcmp (next_opcode->name, opcode->name) == 0)
2686             {
2687               opcode = next_opcode;
2688
2689               /* Skip versions that are not supported by the target
2690                  processor.  */
2691               if ((opcode->processors & processor_mask) == 0)
2692                 goto error;
2693
2694               continue;
2695             }
2696
2697           if (most_match_errmsg[0] == 0)
2698             /* xgettext:c-format.  */
2699             as_bad (_("junk at end of line: `%s'"), str);
2700           else
2701             as_bad ("%s: %s", copy_of_instruction, most_match_errmsg);
2702
2703           if (*input_line_pointer == ']')
2704             ++input_line_pointer;
2705
2706           ignore_rest_of_line ();
2707           input_line_pointer = saved_input_line_pointer;
2708           return;
2709         }
2710
2711       if (warningmsg != NULL)
2712         as_warn ("%s", warningmsg);
2713       break;
2714     }
2715
2716   input_line_pointer = str;
2717
2718   /* Tie dwarf2 debug info to the address at the start of the insn.
2719      We can't do this after the insn has been output as the current
2720      frag may have been closed off.  eg. by frag_var.  */
2721   dwarf2_emit_insn (0);
2722
2723   /* Write out the instruction.  */
2724
2725   if (relaxable && fc > 0)
2726     {
2727       insn_size = 2;
2728       fc = 0;
2729
2730       if (strcmp (opcode->name, "br") == 0
2731           || strcmp (opcode->name, "jbr") == 0)
2732         {
2733           if ((processor_mask & PROCESSOR_V850E2_ALL) == 0 || default_disp_size == 22)
2734             {
2735               f = frag_var (rs_machine_dependent, 4, 2, SUBYPTE_UNCOND_9_22,
2736                             fixups[0].exp.X_add_symbol,
2737                             fixups[0].exp.X_add_number,
2738                             (char *)(size_t) fixups[0].opindex);
2739               md_number_to_chars (f, insn, insn_size);
2740               md_number_to_chars (f + 2, 0, 2);
2741             }
2742           else
2743             {
2744               f = frag_var (rs_machine_dependent, 6, 4, SUBYPTE_UNCOND_9_22_32,
2745                             fixups[0].exp.X_add_symbol,
2746                             fixups[0].exp.X_add_number,
2747                             (char *)(size_t) fixups[0].opindex);
2748               md_number_to_chars (f, insn, insn_size);
2749               md_number_to_chars (f + 2, 0, 4);
2750             }
2751         }
2752       else /* b<cond>, j<cond>.  */
2753         {
2754           if (default_disp_size == 22
2755               || (processor_mask & PROCESSOR_V850E2_ALL) == 0)
2756             {
2757               if (processor_mask & PROCESSOR_V850E2V3 && !no_bcond17)
2758                 {
2759                   if (strcmp (opcode->name, "bsa") == 0)
2760                     {
2761                       f = frag_var (rs_machine_dependent, 8, 6, SUBYPTE_SA_9_17_22,
2762                                     fixups[0].exp.X_add_symbol,
2763                                     fixups[0].exp.X_add_number,
2764                                     (char *)(size_t) fixups[0].opindex);
2765                       md_number_to_chars (f, insn, insn_size);
2766                       md_number_to_chars (f + 2, 0, 6);
2767                     }
2768                   else
2769                     {
2770                       f = frag_var (rs_machine_dependent, 6, 4, SUBYPTE_COND_9_17_22,
2771                                     fixups[0].exp.X_add_symbol,
2772                                     fixups[0].exp.X_add_number,
2773                                     (char *)(size_t) fixups[0].opindex);
2774                       md_number_to_chars (f, insn, insn_size);
2775                       md_number_to_chars (f + 2, 0, 4);
2776                     }
2777                 }
2778               else
2779                 {
2780                   if (strcmp (opcode->name, "bsa") == 0)
2781                     {
2782                       f = frag_var (rs_machine_dependent, 8, 6, SUBYPTE_SA_9_22,
2783                                     fixups[0].exp.X_add_symbol,
2784                                     fixups[0].exp.X_add_number,
2785                                     (char *)(size_t) fixups[0].opindex);
2786                       md_number_to_chars (f, insn, insn_size);
2787                       md_number_to_chars (f + 2, 0, 6);
2788                     }
2789                   else
2790                     {
2791                       f = frag_var (rs_machine_dependent, 6, 4, SUBYPTE_COND_9_22,
2792                                     fixups[0].exp.X_add_symbol,
2793                                     fixups[0].exp.X_add_number,
2794                                     (char *)(size_t) fixups[0].opindex);
2795                       md_number_to_chars (f, insn, insn_size);
2796                       md_number_to_chars (f + 2, 0, 4);
2797                     }
2798                 }
2799             }
2800           else
2801             {
2802               if (processor_mask & PROCESSOR_V850E2V3 && !no_bcond17)
2803                 {
2804                   if (strcmp (opcode->name, "bsa") == 0)
2805                     {
2806                       f = frag_var (rs_machine_dependent, 10, 8, SUBYPTE_SA_9_17_22_32,
2807                                     fixups[0].exp.X_add_symbol,
2808                                     fixups[0].exp.X_add_number,
2809                                     (char *)(size_t) fixups[0].opindex);
2810                       md_number_to_chars (f, insn, insn_size);
2811                       md_number_to_chars (f + 2, 0, 8);
2812                     }
2813                   else
2814                     {
2815                       f = frag_var (rs_machine_dependent, 8, 6, SUBYPTE_COND_9_17_22_32,
2816                                     fixups[0].exp.X_add_symbol,
2817                                     fixups[0].exp.X_add_number,
2818                                     (char *)(size_t) fixups[0].opindex);
2819                       md_number_to_chars (f, insn, insn_size);
2820                       md_number_to_chars (f + 2, 0, 6);
2821                     }
2822                 }
2823               else
2824                 {
2825                   if (strcmp (opcode->name, "bsa") == 0)
2826                     {
2827                       f = frag_var (rs_machine_dependent, 10, 8, SUBYPTE_SA_9_22_32,
2828                                     fixups[0].exp.X_add_symbol,
2829                                     fixups[0].exp.X_add_number,
2830                                     (char *)(size_t) fixups[0].opindex);
2831                       md_number_to_chars (f, insn, insn_size);
2832                       md_number_to_chars (f + 2, 0, 8);
2833                     }
2834                   else
2835                     {
2836                       f = frag_var (rs_machine_dependent, 8, 6, SUBYPTE_COND_9_22_32,
2837                                     fixups[0].exp.X_add_symbol,
2838                                     fixups[0].exp.X_add_number,
2839                                     (char *)(size_t) fixups[0].opindex);
2840                       md_number_to_chars (f, insn, insn_size);
2841                       md_number_to_chars (f + 2, 0, 6);
2842                     }
2843                 }
2844             }
2845         }
2846     }
2847   else
2848     {
2849       /* Four byte insns have an opcode with the two high bits on.  */
2850       if ((insn & 0x0600) == 0x0600)
2851         insn_size = 4;
2852       else
2853         insn_size = 2;
2854
2855       /* Special case: 32 bit MOV.  */
2856       if ((insn & 0xffe0) == 0x0620)
2857         insn_size = 2;
2858
2859       /* Special case: 32 bit JARL,JMP,JR.  */
2860       if ((insn & 0x1ffe0) == 0x2e0     /* JARL.  */
2861           || (insn & 0x1ffe0) == 0x6e0  /* JMP.  */
2862           || (insn & 0x1ffff) == 0x2e0) /* JR.  */
2863         insn_size = 2;
2864
2865       f = frag_more (insn_size);
2866       md_number_to_chars (f, insn, insn_size);
2867
2868       if (extra_data_after_insn)
2869         {
2870           f = frag_more (extra_data_len);
2871           md_number_to_chars (f, extra_data, extra_data_len);
2872
2873           extra_data_after_insn = FALSE;
2874         }
2875     }
2876
2877   /* Create any fixups.  At this point we do not use a
2878      bfd_reloc_code_real_type, but instead just use the
2879      BFD_RELOC_UNUSED plus the operand index.  This lets us easily
2880      handle fixups for any operand type, although that is admittedly
2881      not a very exciting feature.  We pick a BFD reloc type in
2882      md_apply_fix.  */
2883   for (i = 0; i < fc; i++)
2884     {
2885       const struct v850_operand *operand;
2886       bfd_reloc_code_real_type reloc;
2887
2888       operand = &v850_operands[fixups[i].opindex];
2889
2890       reloc = fixups[i].reloc;
2891
2892       if (reloc != BFD_RELOC_UNUSED)
2893         {
2894           reloc_howto_type *reloc_howto =
2895             bfd_reloc_type_lookup (stdoutput, reloc);
2896           int size;
2897           int address;
2898           fixS *fixP;
2899
2900           if (!reloc_howto)
2901             abort ();
2902
2903           size = bfd_get_reloc_size (reloc_howto);
2904
2905           /* XXX This will abort on an R_V850_8 reloc -
2906              is this reloc actually used?  */
2907           if (size != 2 && size != 4)
2908             abort ();
2909
2910           if (extra_data_len == 0)
2911             {
2912               address = (f - frag_now->fr_literal) + insn_size - size;
2913             }
2914           else
2915             {
2916               address = (f - frag_now->fr_literal) + extra_data_len - size;
2917             }
2918
2919           if ((operand->flags & V850E_IMMEDIATE32) && (operand->flags & V850_PCREL))
2920             {
2921               fixups[i].exp.X_add_number += 2;
2922             }
2923           else if (operand->default_reloc ==  BFD_RELOC_V850_16_PCREL)
2924             {
2925               fixups[i].exp.X_add_number += 2;
2926               address += 2;
2927             }
2928
2929           /* fprintf (stderr, "0x%x %d %ld\n", address, size, fixups[i].exp.X_add_number);  */
2930           fixP = fix_new_exp (frag_now, address, size,
2931                               &fixups[i].exp,
2932                               reloc_howto->pc_relative,
2933                               reloc);
2934
2935           fixP->tc_fix_data = (void *) operand;
2936
2937           switch (reloc)
2938             {
2939             case BFD_RELOC_LO16:
2940             case BFD_RELOC_V850_LO16_S1:
2941             case BFD_RELOC_V850_LO16_SPLIT_OFFSET:
2942             case BFD_RELOC_HI16:
2943             case BFD_RELOC_HI16_S:
2944               fixP->fx_no_overflow = 1;
2945               break;
2946             default:
2947               break;
2948             }
2949         }
2950       else
2951         {
2952           fix_new_exp (frag_now,
2953                        f - frag_now->fr_literal, 4,
2954                        & fixups[i].exp,
2955                        (operand->flags & V850_PCREL) != 0,
2956                        (bfd_reloc_code_real_type) (fixups[i].opindex
2957                                                    + (int) BFD_RELOC_UNUSED));
2958         }
2959     }
2960
2961   input_line_pointer = saved_input_line_pointer;
2962 }
2963
2964 /* If while processing a fixup, a reloc really needs to be created
2965    then it is done here.  */
2966
2967 arelent *
2968 tc_gen_reloc (asection *seg ATTRIBUTE_UNUSED, fixS *fixp)
2969 {
2970   arelent *reloc;
2971
2972   reloc               = xmalloc (sizeof (arelent));
2973   reloc->sym_ptr_ptr  = xmalloc (sizeof (asymbol *));
2974   *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
2975   reloc->address      = fixp->fx_frag->fr_address + fixp->fx_where;
2976
2977   if (   fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY
2978       || fixp->fx_r_type == BFD_RELOC_VTABLE_INHERIT
2979       || fixp->fx_r_type == BFD_RELOC_V850_LONGCALL
2980       || fixp->fx_r_type == BFD_RELOC_V850_LONGJUMP
2981       || fixp->fx_r_type == BFD_RELOC_V850_ALIGN)
2982     reloc->addend = fixp->fx_offset;
2983   else
2984     {
2985 #if 0
2986       if (fixp->fx_r_type == BFD_RELOC_32
2987           && fixp->fx_pcrel)
2988         fixp->fx_r_type = BFD_RELOC_32_PCREL;
2989 #endif
2990
2991       reloc->addend = fixp->fx_addnumber;
2992     }
2993
2994   reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
2995
2996   if (reloc->howto == NULL)
2997     {
2998       as_bad_where (fixp->fx_file, fixp->fx_line,
2999                     /* xgettext:c-format  */
3000                     _("reloc %d not supported by object file format"),
3001                     (int) fixp->fx_r_type);
3002
3003       xfree (reloc);
3004
3005       return NULL;
3006     }
3007
3008   return reloc;
3009 }
3010
3011 void
3012 v850_handle_align (fragS * frag)
3013 {
3014   if (v850_relax
3015       && frag->fr_type == rs_align
3016       && frag->fr_address + frag->fr_fix > 0
3017       && frag->fr_offset > 1
3018       && now_seg != bss_section
3019       && now_seg != v850_seg_table[SBSS_SECTION].s
3020       && now_seg != v850_seg_table[TBSS_SECTION].s
3021       && now_seg != v850_seg_table[ZBSS_SECTION].s)
3022     fix_new (frag, frag->fr_fix, 2, & abs_symbol, frag->fr_offset, 0,
3023              BFD_RELOC_V850_ALIGN);
3024 }
3025
3026 /* Return current size of variable part of frag.  */
3027
3028 int
3029 md_estimate_size_before_relax (fragS *fragp, asection *seg ATTRIBUTE_UNUSED)
3030 {
3031   if (fragp->fr_subtype >= sizeof (md_relax_table) / sizeof (md_relax_table[0]))
3032     abort ();
3033
3034   return md_relax_table[fragp->fr_subtype].rlx_length;
3035 }
3036
3037 long
3038 v850_pcrel_from_section (fixS *fixp, segT section)
3039 {
3040   /* If the symbol is undefined, or in a section other than our own,
3041      or it is weak (in which case it may well be in another section,
3042      then let the linker figure it out.  */
3043   if (fixp->fx_addsy != (symbolS *) NULL
3044       && (! S_IS_DEFINED (fixp->fx_addsy)
3045           || S_IS_WEAK (fixp->fx_addsy)
3046           || (S_GET_SEGMENT (fixp->fx_addsy) != section)))
3047     return 0;
3048
3049   return fixp->fx_frag->fr_address + fixp->fx_where;
3050 }
3051
3052 void
3053 md_apply_fix (fixS *fixP, valueT *valueP, segT seg ATTRIBUTE_UNUSED)
3054 {
3055   valueT value = * valueP;
3056   char *where;
3057
3058   if (fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
3059       || fixP->fx_r_type == BFD_RELOC_V850_LONGCALL
3060       || fixP->fx_r_type == BFD_RELOC_V850_LONGJUMP
3061       || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
3062     {
3063       fixP->fx_done = 0;
3064       return;
3065     }
3066
3067   if (fixP->fx_addsy == (symbolS *) NULL)
3068     fixP->fx_addnumber = value,
3069     fixP->fx_done = 1;
3070
3071   else if (fixP->fx_pcrel)
3072     fixP->fx_addnumber = fixP->fx_offset;
3073
3074   else
3075     {
3076       value = fixP->fx_offset;
3077       if (fixP->fx_subsy != (symbolS *) NULL)
3078         {
3079           if (S_GET_SEGMENT (fixP->fx_subsy) == absolute_section)
3080             value -= S_GET_VALUE (fixP->fx_subsy);
3081           else
3082             /* We don't actually support subtracting a symbol.  */
3083             as_bad_where (fixP->fx_file, fixP->fx_line,
3084                           _("expression too complex"));
3085         }
3086       fixP->fx_addnumber = value;
3087     }
3088
3089   if ((int) fixP->fx_r_type >= (int) BFD_RELOC_UNUSED)
3090     {
3091       int opindex;
3092       const struct v850_operand *operand;
3093       unsigned long insn;
3094       const char *errmsg = NULL;
3095
3096       opindex = (int) fixP->fx_r_type - (int) BFD_RELOC_UNUSED;
3097       operand = &v850_operands[opindex];
3098
3099       /* Fetch the instruction, insert the fully resolved operand
3100          value, and stuff the instruction back again.
3101
3102          Note the instruction has been stored in little endian
3103          format!  */
3104       where = fixP->fx_frag->fr_literal + fixP->fx_where;
3105
3106       if (fixP->fx_size > 2)
3107         insn = bfd_getl32 ((unsigned char *) where);
3108       else
3109         insn = bfd_getl16 ((unsigned char *) where);
3110
3111       insn = v850_insert_operand (insn, operand, (offsetT) value,
3112                                   &errmsg);
3113       if (errmsg)
3114         as_warn_where (fixP->fx_file, fixP->fx_line, "%s", errmsg);
3115
3116       if (fixP->fx_size > 2)
3117         bfd_putl32 ((bfd_vma) insn, (unsigned char *) where);
3118       else
3119         bfd_putl16 ((bfd_vma) insn, (unsigned char *) where);
3120
3121       if (fixP->fx_done)
3122         /* Nothing else to do here.  */
3123         return;
3124
3125       /* Determine a BFD reloc value based on the operand information.
3126          We are only prepared to turn a few of the operands into relocs.  */
3127
3128       if (operand->default_reloc == BFD_RELOC_NONE)
3129         {
3130           as_bad_where (fixP->fx_file, fixP->fx_line,
3131                         _("unresolved expression that must be resolved"));
3132           fixP->fx_done = 1;
3133           return;
3134         }
3135
3136       {
3137         fixP->fx_r_type = operand->default_reloc;
3138         if (operand->default_reloc ==  BFD_RELOC_V850_16_PCREL)
3139           {
3140             fixP->fx_where += 2;
3141             fixP->fx_size = 2;
3142             fixP->fx_addnumber += 2;
3143           }
3144       }
3145     }
3146   else if (fixP->fx_done)
3147     {
3148       /* We still have to insert the value into memory!  */
3149       where = fixP->fx_frag->fr_literal + fixP->fx_where;
3150
3151       if (fixP->tc_fix_data != NULL
3152           && ((struct v850_operand *) fixP->tc_fix_data)->insert != NULL)
3153         {
3154           const char * message = NULL;
3155           struct v850_operand * operand = (struct v850_operand *) fixP->tc_fix_data;
3156           unsigned long insn;
3157
3158           /* The variable "where" currently points at the exact point inside
3159              the insn where we need to insert the value.  But we need to
3160              extract the entire insn so we probably need to move "where"
3161              back a few bytes.  */
3162
3163           if (fixP->fx_size == 2)
3164             where -= 2;
3165           else if (fixP->fx_size == 1)
3166             where -= 3;
3167
3168           insn = bfd_getl32 ((unsigned char *) where);
3169
3170           /* Use the operand's insertion procedure, if present, in order to
3171              make sure that the value is correctly stored in the insn.  */
3172           insn = operand->insert (insn, (offsetT) value, & message);
3173           /* Ignore message even if it is set.  */
3174
3175           bfd_putl32 ((bfd_vma) insn, (unsigned char *) where);
3176         }
3177       else
3178         {
3179           switch (fixP->fx_r_type)
3180             {
3181             case BFD_RELOC_V850_32_ABS:
3182             case BFD_RELOC_V850_32_PCREL:
3183               bfd_putl32 (value & 0xfffffffe, (unsigned char *) where);
3184               break;
3185
3186             case BFD_RELOC_32:
3187               bfd_putl32 (value, (unsigned char *) where);
3188               break;
3189
3190             case BFD_RELOC_V850_23:
3191               bfd_putl32 (((value & 0x7f) << 4) | ((value & 0x7fff80) << (16-7))
3192                           | (bfd_getl32 (where) & ~((0x7f << 4) | (0xffff << 16))),
3193                           (unsigned char *) where);
3194             break;
3195
3196             case BFD_RELOC_16:
3197             case BFD_RELOC_HI16:
3198             case BFD_RELOC_HI16_S:
3199             case BFD_RELOC_LO16:
3200             case BFD_RELOC_V850_ZDA_16_16_OFFSET:
3201             case BFD_RELOC_V850_SDA_16_16_OFFSET:
3202             case BFD_RELOC_V850_TDA_16_16_OFFSET:
3203             case BFD_RELOC_V850_CALLT_16_16_OFFSET:
3204               bfd_putl16 (value & 0xffff, (unsigned char *) where);
3205               break;
3206
3207             case BFD_RELOC_8:
3208               *where = value & 0xff;
3209               break;
3210
3211             case BFD_RELOC_V850_9_PCREL:
3212               bfd_putl16 (((value & 0x1f0) << 7) | ((value & 0x0e) << 3)
3213                           | (bfd_getl16 (where) & ~((0x1f0 << 7) | (0x0e << 3))), where);
3214               break;
3215
3216             case BFD_RELOC_V850_17_PCREL:
3217               bfd_putl32 (((value & 0x10000) >> (16 - 4)) | ((value & 0xfffe) << 16)
3218                           | (bfd_getl32 (where) & ~((0x10000 >> (16 - 4)) | (0xfffe << 16))), where);
3219               break;
3220
3221             case BFD_RELOC_V850_16_PCREL:
3222               bfd_putl16 (-value & 0xfffe, (unsigned char *) where);
3223               break;
3224
3225             case BFD_RELOC_V850_22_PCREL:
3226               bfd_putl32 (((value & 0xfffe) << 16) | ((value & 0x3f0000) >> 16)
3227                           | (bfd_getl32 (where) & ~((0xfffe << 16) | (0x3f0000 >> 16))), where);
3228               break;
3229
3230             case BFD_RELOC_V850_16_S1:
3231             case BFD_RELOC_V850_LO16_S1:
3232             case BFD_RELOC_V850_ZDA_15_16_OFFSET:
3233             case BFD_RELOC_V850_SDA_15_16_OFFSET:
3234               bfd_putl16 (value & 0xfffe, (unsigned char *) where);
3235               break;
3236
3237             case BFD_RELOC_V850_16_SPLIT_OFFSET:
3238             case BFD_RELOC_V850_LO16_SPLIT_OFFSET:
3239             case BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET:
3240             case BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET:
3241               bfd_putl32 (((value << 16) & 0xfffe0000)
3242                           | ((value << 5) & 0x20)
3243                           | (bfd_getl32 (where) & ~0xfffe0020), where);
3244               break;
3245
3246             case BFD_RELOC_V850_TDA_6_8_OFFSET:
3247               *where = (*where & ~0x7e) | ((value >> 1) & 0x7e);
3248               break;
3249
3250             case BFD_RELOC_V850_TDA_7_8_OFFSET:
3251               *where = (*where & ~0x7f) | ((value >> 1) & 0x7f);
3252               break;
3253
3254             case BFD_RELOC_V850_TDA_7_7_OFFSET:
3255               *where = (*where & ~0x7f) | (value & 0x7f);
3256               break;
3257
3258             case BFD_RELOC_V850_TDA_4_5_OFFSET:
3259               *where = (*where & ~0xf) | ((value >> 1) & 0xf);
3260               break;
3261
3262             case BFD_RELOC_V850_TDA_4_4_OFFSET:
3263               *where = (*where & ~0xf) | (value & 0xf);
3264               break;
3265
3266             case BFD_RELOC_V850_CALLT_6_7_OFFSET:
3267               *where = (*where & ~0x3f) | (value & 0x3f);
3268               break;
3269
3270             default:
3271               abort ();
3272             }
3273         }
3274     }
3275 }
3276
3277 /* Parse a cons expression.  We have to handle hi(), lo(), etc
3278    on the v850.  */
3279
3280 void
3281 parse_cons_expression_v850 (expressionS *exp)
3282 {
3283   const char *errmsg;
3284   /* See if there's a reloc prefix like hi() we have to handle.  */
3285   hold_cons_reloc = v850_reloc_prefix (NULL, &errmsg);
3286
3287   /* Do normal expression parsing.  */
3288   expression (exp);
3289 }
3290
3291 /* Create a fixup for a cons expression.  If parse_cons_expression_v850
3292    found a reloc prefix, then we use that reloc, else we choose an
3293    appropriate one based on the size of the expression.  */
3294
3295 void
3296 cons_fix_new_v850 (fragS *frag,
3297                    int where,
3298                    int size,
3299                    expressionS *exp)
3300 {
3301   if (hold_cons_reloc == BFD_RELOC_UNUSED)
3302     {
3303       if (size == 4)
3304         hold_cons_reloc = BFD_RELOC_32;
3305       if (size == 2)
3306         hold_cons_reloc = BFD_RELOC_16;
3307       if (size == 1)
3308         hold_cons_reloc = BFD_RELOC_8;
3309     }
3310
3311   if (exp != NULL)
3312     fix_new_exp (frag, where, size, exp, 0, hold_cons_reloc);
3313   else
3314     fix_new (frag, where, size, NULL, 0, 0, hold_cons_reloc);
3315
3316   hold_cons_reloc = BFD_RELOC_UNUSED;
3317 }
3318
3319 bfd_boolean
3320 v850_fix_adjustable (fixS *fixP)
3321 {
3322   if (fixP->fx_addsy == NULL)
3323     return 1;
3324
3325   /* Don't adjust function names.  */
3326   if (S_IS_FUNCTION (fixP->fx_addsy))
3327     return 0;
3328
3329   /* We need the symbol name for the VTABLE entries.  */
3330   if (fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
3331       || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
3332     return 0;
3333
3334   return 1;
3335 }
3336
3337 int
3338 v850_force_relocation (struct fix *fixP)
3339 {
3340   if (fixP->fx_r_type == BFD_RELOC_V850_LONGCALL
3341       || fixP->fx_r_type == BFD_RELOC_V850_LONGJUMP)
3342     return 1;
3343
3344   if (v850_relax
3345       && (fixP->fx_pcrel
3346           || fixP->fx_r_type == BFD_RELOC_V850_ALIGN
3347           || fixP->fx_r_type == BFD_RELOC_V850_9_PCREL
3348           || fixP->fx_r_type == BFD_RELOC_V850_16_PCREL
3349           || fixP->fx_r_type == BFD_RELOC_V850_17_PCREL
3350           || fixP->fx_r_type == BFD_RELOC_V850_22_PCREL
3351           || fixP->fx_r_type == BFD_RELOC_V850_32_PCREL
3352           || fixP->fx_r_type >= BFD_RELOC_UNUSED))
3353     return 1;
3354
3355   return generic_force_reloc (fixP);
3356 }