gas/config/tc-d10v.c

   1 /* tc-d10v.c -- Assembler code for the Mitsubishi D10V
   2
   3    Copyright (C) 1996, 1997 Free Software Foundation.
   4
   5    This file is part of GAS, the GNU Assembler.
   6
   7    GAS is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2, or (at your option)
  10    any later version.
  11
  12    GAS is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with GAS; see the file COPYING.  If not, write to
  19    the Free Software Foundation, 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #include <stdio.h>
  23 #include <ctype.h>
  24 #include "as.h"
  25 #include "subsegs.h"
  26 #include "opcode/d10v.h"
  27 #include "elf/ppc.h"
  28
  29 const char comment_chars[] = ";";
  30 const char line_comment_chars[] = "#";
  31 const char line_separator_chars[] = "";
  32 const char *md_shortopts = "O";
  33 const char EXP_CHARS[] = "eE";
  34 const char FLT_CHARS[] = "dD";
  35
  36 int Optimizing = 0;
  37
  38 #define AT_WORD (-1)
  39
  40 /* fixups */
  41 #define MAX_INSN_FIXUPS (5)
  42 struct d10v_fixup
  43 {
  44   expressionS exp;
  45   int operand;
  46   int pcrel;
  47   int size;
  48   bfd_reloc_code_real_type reloc;
  49 };
  50
  51 typedef struct _fixups
  52 {
  53   int fc;
  54   struct d10v_fixup fix[MAX_INSN_FIXUPS];
  55   struct _fixups *next;
  56 } Fixups;
  57
  58 static Fixups FixUps[2];
  59 static Fixups *fixups;
  60
  61 /* local functions */
  62 static int reg_name_search PARAMS ((char *name));
  63 static int register_name PARAMS ((expressionS *expressionP));
  64 static int check_range PARAMS ((unsigned long num, int bits, int flags));
  65 static int postfix PARAMS ((char *p));
  66 static bfd_reloc_code_real_type get_reloc PARAMS ((struct d10v_operand *op));
  67 static int get_operands PARAMS ((expressionS exp[]));
  68 static struct d10v_opcode *find_opcode PARAMS ((struct d10v_opcode *opcode, expressionS ops[]));
  69 static unsigned long build_insn PARAMS ((struct d10v_opcode *opcode, expressionS *opers, unsigned long insn));
  70 static void write_long PARAMS ((struct d10v_opcode *opcode, unsigned long insn, Fixups *fx));
  71 static void write_1_short PARAMS ((struct d10v_opcode *opcode, unsigned long insn, Fixups *fx));
  72 static int write_2_short PARAMS ((struct d10v_opcode *opcode1, unsigned long insn1,
  73                                   struct d10v_opcode *opcode2, unsigned long insn2, int exec_type, Fixups *fx));
  74 static unsigned long do_assemble PARAMS ((char *str, struct d10v_opcode **opcode));
  75 static unsigned long d10v_insert_operand PARAMS (( unsigned long insn, int op_type,
  76                                                    offsetT value, int left, fixS *fix));
  77 static int parallel_ok PARAMS ((struct d10v_opcode *opcode1, unsigned long insn1,
  78                                 struct d10v_opcode *opcode2, unsigned long insn2,
  79                                 int exec_type));
  80
  81 struct option md_longopts[] = {
  82   {NULL, no_argument, NULL, 0}
  83 };
  84 size_t md_longopts_size = sizeof(md_longopts);
  85
  86 static void d10v_dot_word PARAMS ((int));
  87
  88 /* The target specific pseudo-ops which we support.  */
  89 const pseudo_typeS md_pseudo_table[] =
  90 {
  91   { "word",     d10v_dot_word,  2 },
  92   { NULL,       NULL,           0 }
  93 };
  94
  95 /* Opcode hash table.  */
  96 static struct hash_control *d10v_hash;
  97
  98 /* reg_name_search does a binary search of the d10v_predefined_registers
  99    array to see if "name" is a valid regiter name.  Returns the register
 100    number from the array on success, or -1 on failure. */
 101
 102 static int
 103 reg_name_search (name)
 104      char *name;
 105 {
 106   int middle, low, high;
 107   int cmp;
 108
 109   low = 0;
 110   high = d10v_reg_name_cnt() - 1;
 111
 112   do
 113     {
 114       middle = (low + high) / 2;
 115       cmp = strcasecmp (name, d10v_predefined_registers[middle].name);
 116       if (cmp < 0)
 117         high = middle - 1;
 118       else if (cmp > 0)
 119         low = middle + 1;
 120       else
 121           return d10v_predefined_registers[middle].value;
 122     }
 123   while (low <= high);
 124   return -1;
 125 }
 126
 127 /* register_name() checks the string at input_line_pointer
 128    to see if it is a valid register name */
 129
 130 static int
 131 register_name (expressionP)
 132      expressionS *expressionP;
 133 {
 134   int reg_number;
 135   char c, *p = input_line_pointer;
 136
 137   while (*p && *p!='\n' && *p!='\r' && *p !=',' && *p!=' ' && *p!=')')
 138     p++;
 139
 140   c = *p;
 141   if (c)
 142     *p++ = 0;
 143
 144   /* look to see if it's in the register table */
 145   reg_number = reg_name_search (input_line_pointer);
 146   if (reg_number >= 0)
 147     {
 148       expressionP->X_op = O_register;
 149       /* temporarily store a pointer to the string here */
 150       expressionP->X_op_symbol = (struct symbol *)input_line_pointer;
 151       expressionP->X_add_number = reg_number;
 152       input_line_pointer = p;
 153       return 1;
 154     }
 155   if (c)
 156     *(p-1) = c;
 157   return 0;
 158 }
 159
 160
 161 static int
 162 check_range (num, bits, flags)
 163      unsigned long num;
 164      int bits;
 165      int flags;
 166 {
 167   long min, max, bit1;
 168   int retval=0;
 169
 170   /* don't bother checking 16-bit values */
 171   if (bits == 16)
 172     return 0;
 173
 174   if (flags & OPERAND_SHIFT)
 175     {
 176       /* all special shift operands are unsigned */
 177       /* and <= 16.  We allow 0 for now. */
 178       if (num>16)
 179         return 1;
 180       else
 181         return 0;
 182     }
 183
 184   if (flags & OPERAND_SIGNED)
 185     {
 186       max = (1 << (bits - 1))-1;
 187       min = - (1 << (bits - 1));
 188       if (((long)num > max) || ((long)num < min))
 189         retval = 1;
 190     }
 191   else
 192     {
 193       max = (1 << bits) - 1;
 194       min = 0;
 195       if ((num > max) || (num < min))
 196         retval = 1;
 197     }
 198   return retval;
 199 }
 200
 201
 202 void
 203 md_show_usage (stream)
 204   FILE *stream;
 205 {
 206   fprintf(stream, "D10V options:\n\
 207 -O                      optimize.  Will do some operations in parallel.\n");
 208 }
 209
 210 int
 211 md_parse_option (c, arg)
 212      int c;
 213      char *arg;
 214 {
 215   switch (c)
 216     {
 217     case 'O':
 218       /* Optimize. Will attempt to parallelize operations */
 219       Optimizing = 1;
 220       break;
 221     default:
 222       return 0;
 223     }
 224   return 1;
 225 }
 226
 227 symbolS *
 228 md_undefined_symbol (name)
 229   char *name;
 230 {
 231   return 0;
 232 }
 233
 234 /* Turn a string in input_line_pointer into a floating point constant of type
 235    type, and store the appropriate bytes in *litP.  The number of LITTLENUMS
 236    emitted is stored in *sizeP .  An error message is returned, or NULL on OK.
 237  */
 238 char *
 239 md_atof (type, litP, sizeP)
 240      int type;
 241      char *litP;
 242      int *sizeP;
 243 {
 244   int prec;
 245   LITTLENUM_TYPE words[4];
 246   char *t;
 247   int i;
 248
 249   switch (type)
 250     {
 251     case 'f':
 252       prec = 2;
 253       break;
 254     case 'd':
 255       prec = 4;
 256       break;
 257     default:
 258       *sizeP = 0;
 259       return "bad call to md_atof";
 260     }
 261
 262   t = atof_ieee (input_line_pointer, type, words);
 263   if (t)
 264     input_line_pointer = t;
 265
 266   *sizeP = prec * 2;
 267
 268   for (i = 0; i < prec; i++)
 269     {
 270       md_number_to_chars (litP, (valueT) words[i], 2);
 271           litP += 2;
 272     }
 273   return NULL;
 274 }
 275
 276 void
 277 md_convert_frag (abfd, sec, fragP)
 278   bfd *abfd;
 279   asection *sec;
 280   fragS *fragP;
 281 {
 282   abort ();
 283 }
 284
 285 valueT
 286 md_section_align (seg, addr)
 287      asection *seg;
 288      valueT addr;
 289 {
 290   int align = bfd_get_section_alignment (stdoutput, seg);
 291   return ((addr + (1 << align) - 1) & (-1 << align));
 292 }
 293
 294
 295 void
 296 md_begin ()
 297 {
 298   char *prev_name = "";
 299   struct d10v_opcode *opcode;
 300   d10v_hash = hash_new();
 301
 302   /* Insert unique names into hash table.  The D10v instruction set
 303      has many identical opcode names that have different opcodes based
 304      on the operands.  This hash table then provides a quick index to
 305      the first opcode with a particular name in the opcode table.  */
 306
 307   for (opcode = (struct d10v_opcode *)d10v_opcodes; opcode->name; opcode++)
 308     {
 309       if (strcmp (prev_name, opcode->name))
 310         {
 311           prev_name = (char *)opcode->name;
 312           hash_insert (d10v_hash, opcode->name, (char *) opcode);
 313         }
 314     }
 315
 316   fixups = &FixUps[0];
 317   FixUps[0].next = &FixUps[1];
 318   FixUps[1].next = &FixUps[0];
 319 }
 320
 321
 322 /* this function removes the postincrement or postdecrement
 323    operator ( '+' or '-' ) from an expression */
 324
 325 static int postfix (p)
 326      char *p;
 327 {
 328   while (*p != '-' && *p != '+')
 329     {
 330       if (*p==0 || *p=='\n' || *p=='\r')
 331         break;
 332       p++;
 333     }
 334
 335   if (*p == '-')
 336     {
 337       *p = ' ';
 338       return (-1);
 339     }
 340   if (*p == '+')
 341     {
 342       *p = ' ';
 343       return (1);
 344     }
 345
 346   return (0);
 347 }
 348
 349
 350 static bfd_reloc_code_real_type
 351 get_reloc (op)
 352      struct d10v_operand *op;
 353 {
 354   int bits = op->bits;
 355
 356   if (bits <= 4)
 357     return (0);
 358
 359   if (op->flags & OPERAND_ADDR)
 360     {
 361       if (bits == 8)
 362         return (BFD_RELOC_D10V_10_PCREL_R);
 363       else
 364         return (BFD_RELOC_D10V_18_PCREL);
 365     }
 366
 367   return (BFD_RELOC_16);
 368 }
 369
 370
 371 /* get_operands parses a string of operands and returns
 372    an array of expressions */
 373
 374 static int
 375 get_operands (exp)
 376      expressionS exp[];
 377 {
 378   char *p = input_line_pointer;
 379   int numops = 0;
 380   int post = 0;
 381
 382   while (*p)
 383     {
 384       while (*p == ' ' || *p == '\t' || *p == ',')
 385         p++;
 386       if (*p==0 || *p=='\n' || *p=='\r')
 387         break;
 388
 389       if (*p == '@')
 390         {
 391           p++;
 392           exp[numops].X_op = O_absent;
 393           if (*p == '(')
 394             {
 395               p++;
 396               exp[numops].X_add_number = OPERAND_ATPAR;
 397             }
 398           else if (*p == '-')
 399             {
 400               p++;
 401               exp[numops].X_add_number = OPERAND_ATMINUS;
 402             }
 403           else
 404             {
 405               exp[numops].X_add_number = OPERAND_ATSIGN;
 406               post = postfix (p);
 407             }
 408           numops++;
 409           continue;
 410         }
 411
 412       if (*p == ')')
 413         {
 414           /* just skip the trailing paren */
 415           p++;
 416           continue;
 417         }
 418
 419       input_line_pointer = p;
 420
 421       /* check to see if it might be a register name */
 422       if (!register_name (&exp[numops]))
 423         {
 424           /* parse as an expression */
 425           expression (&exp[numops]);
 426         }
 427
 428       if (!strncasecmp (input_line_pointer, "@word", 5))
 429         {
 430           if (exp[numops].X_op == O_register)
 431             {
 432               /* if it looked like a register name but was followed by "@word" */
 433               /* then it was really a symbol, so change it to one */
 434               exp[numops].X_op = O_symbol;
 435               exp[numops].X_add_symbol = symbol_find_or_make ((char *)exp[numops].X_op_symbol);
 436               exp[numops].X_op_symbol = NULL;
 437             }
 438           exp[numops].X_add_number = AT_WORD;
 439           input_line_pointer += 5;
 440         }
 441
 442       if (exp[numops].X_op == O_illegal)
 443         as_bad ("illegal operand");
 444       else if (exp[numops].X_op == O_absent)
 445         as_bad ("missing operand");
 446
 447       numops++;
 448       p = input_line_pointer;
 449     }
 450
 451   switch (post)
 452     {
 453     case -1:    /* postdecrement mode */
 454       exp[numops].X_op = O_absent;
 455       exp[numops++].X_add_number = OPERAND_MINUS;
 456       break;
 457     case 1:     /* postincrement mode */
 458       exp[numops].X_op = O_absent;
 459       exp[numops++].X_add_number = OPERAND_PLUS;
 460       break;
 461     }
 462
 463   exp[numops].X_op = 0;
 464   return (numops);
 465 }
 466
 467 static unsigned long
 468 d10v_insert_operand (insn, op_type, value, left, fix)
 469      unsigned long insn;
 470      int op_type;
 471      offsetT value;
 472      int left;
 473      fixS *fix;
 474 {
 475   int shift, bits;
 476
 477   shift = d10v_operands[op_type].shift;
 478   if (left)
 479     shift += 15;
 480
 481   bits = d10v_operands[op_type].bits;
 482
 483   /* truncate to the proper number of bits */
 484   if (check_range (value, bits, d10v_operands[op_type].flags))
 485     as_bad_where (fix->fx_file, fix->fx_line, "operand out of range: %d", value);
 486
 487   value &= 0x7FFFFFFF >> (31 - bits);
 488   insn |= (value << shift);
 489
 490   return insn;
 491 }
 492
 493
 494 /* build_insn takes a pointer to the opcode entry in the opcode table
 495    and the array of operand expressions and returns the instruction */
 496
 497 static unsigned long
 498 build_insn (opcode, opers, insn)
 499      struct d10v_opcode *opcode;
 500      expressionS *opers;
 501      unsigned long insn;
 502 {
 503   int i, bits, shift, flags, format;
 504   unsigned int number;
 505
 506   /* the insn argument is only used for the DIVS kludge */
 507   if (insn)
 508     format = LONG_R;
 509   else
 510     {
 511       insn = opcode->opcode;
 512       format = opcode->format;
 513     }
 514
 515   for (i=0;opcode->operands[i];i++)
 516     {
 517       flags = d10v_operands[opcode->operands[i]].flags;
 518       bits = d10v_operands[opcode->operands[i]].bits;
 519       shift = d10v_operands[opcode->operands[i]].shift;
 520       number = opers[i].X_add_number;
 521
 522       if (flags & OPERAND_REG)
 523         {
 524           number &= REGISTER_MASK;
 525           if (format == LONG_L)
 526             shift += 15;
 527         }
 528
 529       if (opers[i].X_op != O_register && opers[i].X_op != O_constant)
 530         {
 531           /* now create a fixup */
 532
 533           if (fixups->fc >= MAX_INSN_FIXUPS)
 534             as_fatal ("too many fixups");
 535
 536           if (opers[i].X_op == O_symbol && number == AT_WORD)
 537             {
 538               number = opers[i].X_add_number = 0;
 539               fixups->fix[fixups->fc].reloc = BFD_RELOC_D10V_18;
 540             } else
 541               fixups->fix[fixups->fc].reloc =
 542                 get_reloc((struct d10v_operand *)&d10v_operands[opcode->operands[i]]);
 543
 544           if (fixups->fix[fixups->fc].reloc == BFD_RELOC_16 ||
 545               fixups->fix[fixups->fc].reloc == BFD_RELOC_D10V_18)
 546             fixups->fix[fixups->fc].size = 2;
 547           else
 548             fixups->fix[fixups->fc].size = 4;
 549
 550           fixups->fix[fixups->fc].exp = opers[i];
 551           fixups->fix[fixups->fc].operand = opcode->operands[i];
 552           fixups->fix[fixups->fc].pcrel = (flags & OPERAND_ADDR) ? true : false;
 553           (fixups->fc)++;
 554         }
 555
 556       /* truncate to the proper number of bits */
 557       if ((opers[i].X_op == O_constant) && check_range (number, bits, flags))
 558         as_bad("operand out of range: %d",number);
 559       number &= 0x7FFFFFFF >> (31 - bits);
 560       insn = insn | (number << shift);
 561     }
 562
 563   /* kludge: for DIVS, we need to put the operands in twice */
 564   /* on the second pass, format is changed to LONG_R to force */
 565   /* the second set of operands to not be shifted over 15 */
 566   if ((opcode->opcode == OPCODE_DIVS) && (format==LONG_L))
 567     insn = build_insn (opcode, opers, insn);
 568
 569   return insn;
 570 }
 571
 572 /* write out a long form instruction */
 573 static void
 574 write_long (opcode, insn, fx)
 575      struct d10v_opcode *opcode;
 576      unsigned long insn;
 577      Fixups *fx;
 578 {
 579   int i, where;
 580   char *f = frag_more(4);
 581
 582   insn |= FM11;
 583   number_to_chars_bigendian (f, insn, 4);
 584
 585   for (i=0; i < fx->fc; i++)
 586     {
 587       if (fx->fix[i].reloc)
 588         {
 589           where = f - frag_now->fr_literal;
 590           if (fx->fix[i].size == 2)
 591             where += 2;
 592
 593           if (fx->fix[i].reloc == BFD_RELOC_D10V_18)
 594             fx->fix[i].operand |= 4096;
 595
 596           fix_new_exp (frag_now,
 597                        where,
 598                        fx->fix[i].size,
 599                        &(fx->fix[i].exp),
 600                        fx->fix[i].pcrel,
 601                        fx->fix[i].operand|2048);
 602         }
 603     }
 604   fx->fc = 0;
 605 }
 606
 607
 608 /* write out a short form instruction by itself */
 609 static void
 610 write_1_short (opcode, insn, fx)
 611      struct d10v_opcode *opcode;
 612      unsigned long insn;
 613      Fixups *fx;
 614 {
 615   char *f = frag_more(4);
 616   int i, where;
 617
 618   if (opcode->exec_type & PARONLY)
 619     as_fatal ("Instruction must be executed in parallel with another instruction.");
 620
 621   /* the other container needs to be NOP */
 622   /* according to 4.3.1: for FM=00, sub-instructions performed only
 623      by IU cannot be encoded in L-container. */
 624   if (opcode->unit == IU)
 625     insn |= FM00 | (NOP << 15);         /* right container */
 626   else
 627     insn = FM00 | (insn << 15) | NOP;   /* left container */
 628
 629   number_to_chars_bigendian (f, insn, 4);
 630   for (i=0; i < fx->fc; i++)
 631     {
 632       if (fx->fix[i].reloc)
 633         {
 634           where = f - frag_now->fr_literal;
 635           if (fx->fix[i].size == 2)
 636             where += 2;
 637
 638           if (fx->fix[i].reloc == BFD_RELOC_D10V_18)
 639             fx->fix[i].operand |= 4096;
 640
 641           /* if it's an R reloc, we may have to switch it to L */
 642           if ( (fx->fix[i].reloc == BFD_RELOC_D10V_10_PCREL_R) && (opcode->unit != IU) )
 643             fx->fix[i].operand |= 1024;
 644
 645           fix_new_exp (frag_now,
 646                        where,
 647                        fx->fix[i].size,
 648                        &(fx->fix[i].exp),
 649                        fx->fix[i].pcrel,
 650                        fx->fix[i].operand|2048);
 651         }
 652     }
 653   fx->fc = 0;
 654 }
 655
 656 /* write out a short form instruction if possible */
 657 /* return number of instructions not written out */
 658 static int
 659 write_2_short (opcode1, insn1, opcode2, insn2, exec_type, fx)
 660      struct d10v_opcode *opcode1, *opcode2;
 661      unsigned long insn1, insn2;
 662      int exec_type;
 663      Fixups *fx;
 664 {
 665   unsigned long insn;
 666   char *f;
 667   int i,j, where;
 668
 669   if ( (exec_type != 1) && ((opcode1->exec_type & PARONLY)
 670                         || (opcode2->exec_type & PARONLY)))
 671     as_fatal("Instruction must be executed in parallel");
 672
 673   if ( (opcode1->format & LONG_OPCODE) || (opcode2->format & LONG_OPCODE))
 674     as_fatal ("Long instructions may not be combined.");
 675
 676   if(opcode1->exec_type & BRANCH_LINK && exec_type == 0)
 677     {
 678       /* Instructions paired with a subroutine call are executed before the
 679          subroutine, so don't do these pairings unless explicitly requested.  */
 680       write_1_short (opcode1, insn1, fx->next);
 681       return (1);
 682     }
 683
 684   switch (exec_type)
 685     {
 686     case 0:     /* order not specified */
 687       if ( Optimizing && parallel_ok (opcode1, insn1, opcode2, insn2, exec_type))
 688         {
 689           /* parallel */
 690           if (opcode1->unit == IU)
 691             insn = FM00 | (insn2 << 15) | insn1;
 692           else if (opcode2->unit == MU)
 693             insn = FM00 | (insn2 << 15) | insn1;
 694           else
 695             {
 696               insn = FM00 | (insn1 << 15) | insn2;
 697               fx = fx->next;
 698             }
 699         }
 700       else if (opcode1->unit == IU)
 701         {
 702           /* reverse sequential */
 703           insn = FM10 | (insn2 << 15) | insn1;
 704         }
 705       else
 706         {
 707           /* sequential */
 708           insn = FM01 | (insn1 << 15) | insn2;
 709           fx = fx->next;
 710         }
 711       break;
 712     case 1:     /* parallel */
 713       if (opcode1->exec_type & SEQ || opcode2->exec_type & SEQ)
 714         as_fatal ("One of these instructions may not be executed in parallel.");
 715
 716       if (opcode1->unit == IU)
 717         {
 718           if (opcode2->unit == IU)
 719             as_fatal ("Two IU instructions may not be executed in parallel");
 720           as_warn ("Swapping instruction order");
 721           insn = FM00 | (insn2 << 15) | insn1;
 722         }
 723       else if (opcode2->unit == MU)
 724         {
 725           if (opcode1->unit == MU)
 726             as_fatal ("Two MU instructions may not be executed in parallel");
 727           as_warn ("Swapping instruction order");
 728           insn = FM00 | (insn2 << 15) | insn1;
 729         }
 730       else
 731         {
 732           insn = FM00 | (insn1 << 15) | insn2;
 733           fx = fx->next;
 734         }
 735       break;
 736     case 2:     /* sequential */
 737       if (opcode1->unit == IU)
 738         as_fatal ("IU instruction may not be in the left container");
 739       insn = FM01 | (insn1 << 15) | insn2;
 740       fx = fx->next;
 741       break;
 742     case 3:     /* reverse sequential */
 743       if (opcode2->unit == MU)
 744         as_fatal ("MU instruction may not be in the right container");
 745       insn = FM10 | (insn1 << 15) | insn2;
 746       fx = fx->next;
 747       break;
 748     default:
 749       as_fatal("unknown execution type passed to write_2_short()");
 750     }
 751
 752   f = frag_more(4);
 753   number_to_chars_bigendian (f, insn, 4);
 754
 755   for (j=0; j<2; j++)
 756     {
 757       for (i=0; i < fx->fc; i++)
 758         {
 759           if (fx->fix[i].reloc)
 760             {
 761               where = f - frag_now->fr_literal;
 762               if (fx->fix[i].size == 2)
 763                 where += 2;
 764
 765               if ( (fx->fix[i].reloc == BFD_RELOC_D10V_10_PCREL_R) && (j == 0) )
 766                 fx->fix[i].operand |= 1024;
 767
 768               if (fx->fix[i].reloc == BFD_RELOC_D10V_18)
 769                 fx->fix[i].operand |= 4096;
 770
 771               fix_new_exp (frag_now,
 772                            where,
 773                            fx->fix[i].size,
 774                            &(fx->fix[i].exp),
 775                            fx->fix[i].pcrel,
 776                            fx->fix[i].operand|2048);
 777             }
 778         }
 779       fx->fc = 0;
 780       fx = fx->next;
 781     }
 782   return (0);
 783 }
 784
 785
 786 /* Check 2 instructions and determine if they can be safely */
 787 /* executed in parallel.  Returns 1 if they can be.         */
 788 static int
 789 parallel_ok (op1, insn1, op2, insn2, exec_type)
 790      struct d10v_opcode *op1, *op2;
 791      unsigned long insn1, insn2;
 792      int exec_type;
 793 {
 794   int i, j, flags, mask, shift, regno;
 795   unsigned long ins, mod[2], used[2];
 796   struct d10v_opcode *op;
 797
 798   if ((op1->exec_type & SEQ) != 0 || (op2->exec_type & SEQ) != 0
 799       || (op1->exec_type & PAR) == 0 || (op2->exec_type & PAR) == 0
 800       || (op1->unit == BOTH) || (op2->unit == BOTH)
 801       || (op1->unit == IU && op2->unit == IU)
 802       || (op1->unit == MU && op2->unit == MU))
 803     return 0;
 804
 805   /* If the first instruction is a branch and this is auto parallazation,
 806      don't combine with any second instruction.  */
 807   if (exec_type == 0 && (op1->exec_type & BRANCH) != 0)
 808     return 0;
 809
 810   /* The idea here is to create two sets of bitmasks (mod and used) */
 811   /* which indicate which registers are modified or used by each instruction. */
 812   /* The operation can only be done in parallel if instruction 1 and instruction 2 */
 813   /* modify different registers, and neither instruction modifies any registers */
 814   /* the other is using.  Accesses to control registers, PSW, and memory are treated */
 815   /* as accesses to a single register.  So if both instructions write memory or one */
 816   /* instruction writes memory and the other reads, then they cannot be done in parallel. */
 817   /* Likewise, if one instruction mucks with the psw and the other reads the PSW */
 818   /* (which includes C, F0, and F1), then they cannot operate safely in parallel. */
 819
 820   /* the bitmasks (mod and used) look like this (bit 31 = MSB) */
 821   /* r0-r15       0-15  */
 822   /* a0-a1        16-17 */
 823   /* cr (not psw) 18    */
 824   /* psw          19    */
 825   /* mem          20    */
 826
 827   for (j=0;j<2;j++)
 828     {
 829       if (j == 0)
 830         {
 831           op = op1;
 832           ins = insn1;
 833         }
 834       else
 835         {
 836           op = op2;
 837           ins = insn2;
 838         }
 839       mod[j] = used[j] = 0;
 840       if (op->exec_type & BRANCH_LINK)
 841         mod[j] |= 1 << 13;
 842
 843       for (i = 0; op->operands[i]; i++)
 844         {
 845           flags = d10v_operands[op->operands[i]].flags;
 846           shift = d10v_operands[op->operands[i]].shift;
 847           mask = 0x7FFFFFFF >> (31 - d10v_operands[op->operands[i]].bits);
 848           if (flags & OPERAND_REG)
 849             {
 850               regno = (ins >> shift) & mask;
 851               if (flags & OPERAND_ACC)
 852                 regno += 16;
 853               else if (flags & OPERAND_CONTROL) /* mvtc or mvfc */
 854                 {
 855                   if (regno == 0)
 856                     regno = 19;
 857                   else
 858                     regno = 18;
 859                 }
 860               else if (flags & OPERAND_FLAG)
 861                 regno = 19;
 862
 863               if ( flags & OPERAND_DEST )
 864                 {
 865                   mod[j] |= 1 << regno;
 866                   if (flags & OPERAND_EVEN)
 867                     mod[j] |= 1 << (regno + 1);
 868                 }
 869               else
 870                 {
 871                   used[j] |= 1 << regno ;
 872                   if (flags & OPERAND_EVEN)
 873                     used[j] |= 1 << (regno + 1);
 874
 875                   /* Auto inc/dec also modifies the register.  */
 876                   if (op->operands[i+1] != 0
 877                       && (d10v_operands[op->operands[i+1]].flags
 878                           & (OPERAND_PLUS | OPERAND_MINUS)) != 0)
 879                     mod[j] |= 1 << regno;
 880                 }
 881             }
 882           else if (flags & OPERAND_ATMINUS)
 883             {
 884               /* SP implicitly used/modified */
 885               mod[j] |= 1 << 15;
 886               used[j] |= 1 << 15;
 887             }
 888         }
 889       if (op->exec_type & RMEM)
 890         used[j] |= 1 << 20;
 891       else if (op->exec_type & WMEM)
 892         mod[j] |= 1 << 20;
 893       else if (op->exec_type & RF0)
 894         used[j] |= 1 << 19;
 895       else if (op->exec_type & WF0)
 896         mod[j] |= 1 << 19;
 897       else if (op->exec_type & WCAR)
 898         mod[j] |= 1 << 19;
 899     }
 900   if ((mod[0] & mod[1]) == 0 && (mod[0] & used[1]) == 0 && (mod[1] & used[0]) == 0)
 901     return 1;
 902   return 0;
 903 }
 904
 905
 906 /* This is the main entry point for the machine-dependent assembler.  str points to a
 907    machine-dependent instruction.  This function is supposed to emit the frags/bytes
 908    it assembles to.  For the D10V, it mostly handles the special VLIW parsing and packing
 909    and leaves the difficult stuff to do_assemble().
 910  */
 911
 912 static unsigned long prev_insn;
 913 static struct d10v_opcode *prev_opcode = 0;
 914 static subsegT prev_subseg;
 915 static segT prev_seg = 0;;
 916
 917 void
 918 md_assemble (str)
 919      char *str;
 920 {
 921   struct d10v_opcode *opcode;
 922   unsigned long insn;
 923   int extype=0;                 /* execution type; parallel, etc */
 924   static int etype=0;           /* saved extype.  used for multiline instructions */
 925   char *str2;
 926
 927   if (etype == 0)
 928     {
 929       /* look for the special multiple instruction separators */
 930       str2 = strstr (str, "||");
 931       if (str2)
 932         extype = 1;
 933       else
 934         {
 935           str2 = strstr (str, "->");
 936           if (str2)
 937             extype = 2;
 938           else
 939             {
 940               str2 = strstr (str, "<-");
 941               if (str2)
 942                 extype = 3;
 943             }
 944         }
 945       /* str2 points to the separator, if one */
 946       if (str2)
 947         {
 948           *str2 = 0;
 949
 950           /* if two instructions are present and we already have one saved
 951              then first write it out */
 952           d10v_cleanup();
 953
 954           /* assemble first instruction and save it */
 955           prev_insn = do_assemble (str, &prev_opcode);
 956           if (prev_insn == -1)
 957             as_fatal ("can't find opcode ");
 958           fixups = fixups->next;
 959           str = str2 + 2;
 960         }
 961     }
 962
 963   insn = do_assemble (str, &opcode);
 964   if (insn == -1)
 965     {
 966       if (extype)
 967         {
 968           etype = extype;
 969           return;
 970         }
 971       as_fatal ("can't find opcode ");
 972     }
 973
 974   if (etype)
 975     {
 976       extype = etype;
 977       etype = 0;
 978     }
 979
 980   /* if this is a long instruction, write it and any previous short instruction */
 981   if (opcode->format & LONG_OPCODE)
 982     {
 983       if (extype)
 984         as_fatal("Unable to mix instructions as specified");
 985       d10v_cleanup();
 986       write_long (opcode, insn, fixups);
 987       prev_opcode = NULL;
 988       return;
 989     }
 990
 991   if (prev_opcode && prev_seg && ((prev_seg != now_seg) || (prev_subseg != now_subseg)))
 992     d10v_cleanup();
 993
 994   if (prev_opcode && (write_2_short (prev_opcode, prev_insn, opcode, insn, extype, fixups) == 0))
 995     {
 996       /* no instructions saved */
 997       prev_opcode = NULL;
 998     }
 999   else
1000     {
1001       if (extype)
1002         as_fatal("Unable to mix instructions as specified");
1003       /* save off last instruction so it may be packed on next pass */
1004       prev_opcode = opcode;
1005       prev_insn = insn;
1006       prev_seg = now_seg;
1007       prev_subseg = now_subseg;
1008       fixups = fixups->next;
1009     }
1010 }
1011
1012
1013 /* do_assemble assembles a single instruction and returns an opcode */
1014 /* it returns -1 (an invalid opcode) on error */
1015
1016 static unsigned long
1017 do_assemble (str, opcode)
1018      char *str;
1019      struct d10v_opcode **opcode;
1020 {
1021   unsigned char *op_start, *save;
1022   unsigned char *op_end;
1023   char name[20];
1024   int nlen = 0;
1025   expressionS myops[6];
1026   unsigned long insn;
1027
1028   /* Drop leading whitespace */
1029   while (*str == ' ')
1030     str++;
1031
1032   /* find the opcode end */
1033   for (op_start = op_end = (unsigned char *) (str);
1034        *op_end
1035        && nlen < 20
1036        && !is_end_of_line[*op_end] && *op_end != ' ';
1037        op_end++)
1038     {
1039       name[nlen] = tolower(op_start[nlen]);
1040       nlen++;
1041     }
1042   name[nlen] = 0;
1043
1044   if (nlen == 0)
1045     return (-1);
1046
1047   /* find the first opcode with the proper name */
1048   *opcode = (struct d10v_opcode *)hash_find (d10v_hash, name);
1049   if (*opcode == NULL)
1050       as_fatal ("unknown opcode: %s",name);
1051
1052   save = input_line_pointer;
1053   input_line_pointer = op_end;
1054   *opcode = find_opcode (*opcode, myops);
1055   if (*opcode == 0)
1056     return -1;
1057   input_line_pointer = save;
1058
1059   insn = build_insn ((*opcode), myops, 0);
1060   return (insn);
1061 }
1062
1063 /* find_opcode() gets a pointer to an entry in the opcode table.       */
1064 /* It must look at all opcodes with the same name and use the operands */
1065 /* to choose the correct opcode. */
1066
1067 static struct d10v_opcode *
1068 find_opcode (opcode, myops)
1069      struct d10v_opcode *opcode;
1070      expressionS myops[];
1071 {
1072   int i, match, done;
1073   struct d10v_opcode *next_opcode;
1074
1075   /* get all the operands and save them as expressions */
1076   get_operands (myops);
1077
1078   /* now see if the operand is a fake.  If so, find the correct size */
1079   /* instruction, if possible */
1080   if (opcode->format == OPCODE_FAKE)
1081     {
1082       int opnum = opcode->operands[0];
1083
1084       if (myops[opnum].X_op == O_register)
1085         {
1086           myops[opnum].X_op = O_symbol;
1087           myops[opnum].X_add_symbol = symbol_find_or_make ((char *)myops[opnum].X_op_symbol);
1088           myops[opnum].X_add_number = 0;
1089           myops[opnum].X_op_symbol = NULL;
1090         }
1091
1092       if (myops[opnum].X_op == O_constant || (myops[opnum].X_op == O_symbol &&
1093           S_IS_DEFINED(myops[opnum].X_add_symbol) &&
1094           (S_GET_SEGMENT(myops[opnum].X_add_symbol) == now_seg)))
1095         {
1096           next_opcode=opcode+1;
1097           for (i=0; opcode->operands[i+1]; i++)
1098             {
1099               int bits = d10v_operands[next_opcode->operands[opnum]].bits;
1100               int flags = d10v_operands[next_opcode->operands[opnum]].flags;
1101               if (flags & OPERAND_ADDR)
1102                 bits += 2;
1103               if (myops[opnum].X_op == O_constant)
1104                 {
1105                   if (!check_range (myops[opnum].X_add_number, bits, flags))
1106                     return next_opcode;
1107                 }
1108               else
1109                 {
1110                   fragS *f;
1111                   long value;
1112                   /* calculate the current address by running through the previous frags */
1113                   /* and adding our current offset */
1114                   for (value = 0, f = frchain_now->frch_root; f; f = f->fr_next)
1115                     value += f->fr_fix + f->fr_offset;
1116
1117                   if (flags & OPERAND_ADDR)
1118                     value = S_GET_VALUE(myops[opnum].X_add_symbol) - value -
1119                       (obstack_next_free(&frchain_now->frch_obstack) - frag_now->fr_literal);
1120                   else
1121                     value = S_GET_VALUE(myops[opnum].X_add_symbol);
1122
1123                   if (myops[opnum].X_add_number == AT_WORD)
1124                     {
1125                       if (bits > 4)
1126                         {
1127                           bits += 2;
1128                           if (!check_range (value, bits, flags))
1129                             return next_opcode;
1130                         }
1131                     }
1132                   else if (!check_range (value, bits, flags))
1133                     return next_opcode;
1134                 }
1135               next_opcode++;
1136             }
1137           as_fatal ("value out of range");
1138         }
1139       else
1140         {
1141           /* not a constant, so use a long instruction */
1142           return opcode+2;
1143         }
1144     }
1145   else
1146     {
1147       match = 0;
1148       /* now search the opcode table table for one with operands */
1149       /* that matches what we've got */
1150       while (!match)
1151         {
1152           match = 1;
1153           for (i = 0; opcode->operands[i]; i++)
1154             {
1155               int flags = d10v_operands[opcode->operands[i]].flags;
1156               int X_op = myops[i].X_op;
1157               int num = myops[i].X_add_number;
1158
1159               if (X_op==0)
1160                 {
1161                   match=0;
1162                   break;
1163                 }
1164
1165               if (flags & OPERAND_REG)
1166                 {
1167                   if ((X_op != O_register) ||
1168                       ((flags & OPERAND_ACC) != (num & OPERAND_ACC)) ||
1169                       ((flags & OPERAND_FLAG) != (num & OPERAND_FLAG)) ||
1170                       ((flags & OPERAND_CONTROL) != (num & OPERAND_CONTROL)))
1171                     {
1172                       match=0;
1173                       break;
1174                     }
1175                 }
1176
1177               if (((flags & OPERAND_MINUS) && ((X_op != O_absent) || (num != OPERAND_MINUS))) ||
1178                   ((flags & OPERAND_PLUS) && ((X_op != O_absent) || (num != OPERAND_PLUS))) ||
1179                   ((flags & OPERAND_ATMINUS) && ((X_op != O_absent) || (num != OPERAND_ATMINUS))) ||
1180                   ((flags & OPERAND_ATPAR) && ((X_op != O_absent) || (num != OPERAND_ATPAR))) ||
1181                   ((flags & OPERAND_ATSIGN) && ((X_op != O_absent) || (num != OPERAND_ATSIGN))))
1182                 {
1183                   match=0;
1184                   break;
1185                 }
1186             }
1187           /* we're only done if the operands matched so far AND there
1188              are no more to check */
1189           if (match && myops[i].X_op==0)
1190             break;
1191           else
1192             match = 0;
1193
1194           next_opcode = opcode+1;
1195           if (next_opcode->opcode == 0)
1196             break;
1197           if (strcmp(next_opcode->name, opcode->name))
1198             break;
1199           opcode = next_opcode;
1200         }
1201     }
1202
1203   if (!match)
1204     {
1205       as_bad ("bad opcode or operands");
1206       return (0);
1207     }
1208
1209   /* Check that all registers that are required to be even are. */
1210   /* Also, if any operands were marked as registers, but were really symbols */
1211   /* fix that here. */
1212   for (i=0; opcode->operands[i]; i++)
1213     {
1214       if ((d10v_operands[opcode->operands[i]].flags & OPERAND_EVEN) &&
1215           (myops[i].X_add_number & 1))
1216         as_fatal("Register number must be EVEN");
1217       if (myops[i].X_op == O_register)
1218         {
1219           if (!(d10v_operands[opcode->operands[i]].flags & OPERAND_REG))
1220             {
1221               myops[i].X_op = O_symbol;
1222               myops[i].X_add_symbol = symbol_find_or_make ((char *)myops[i].X_op_symbol);
1223               myops[i].X_add_number = 0;
1224               myops[i].X_op_symbol = NULL;
1225             }
1226         }
1227     }
1228   return opcode;
1229 }
1230
1231 /* if while processing a fixup, a reloc really needs to be created */
1232 /* then it is done here */
1233
1234 arelent *
1235 tc_gen_reloc (seg, fixp)
1236      asection *seg;
1237      fixS *fixp;
1238 {
1239   arelent *reloc;
1240   reloc = (arelent *) xmalloc (sizeof (arelent));
1241   reloc->sym_ptr_ptr = &fixp->fx_addsy->bsym;
1242   reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
1243   reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
1244   if (reloc->howto == (reloc_howto_type *) NULL)
1245     {
1246       as_bad_where (fixp->fx_file, fixp->fx_line,
1247                     "reloc %d not supported by object file format", (int)fixp->fx_r_type);
1248       return NULL;
1249     }
1250   reloc->addend = fixp->fx_addnumber;
1251   return reloc;
1252 }
1253
1254 int
1255 md_estimate_size_before_relax (fragp, seg)
1256      fragS *fragp;
1257      asection *seg;
1258 {
1259   abort ();
1260   return 0;
1261 }
1262
1263 long
1264 md_pcrel_from_section (fixp, sec)
1265      fixS *fixp;
1266      segT sec;
1267 {
1268   if (fixp->fx_addsy != (symbolS *)NULL && (!S_IS_DEFINED (fixp->fx_addsy) ||
1269       (S_GET_SEGMENT (fixp->fx_addsy) != sec)))
1270     return 0;
1271   return fixp->fx_frag->fr_address + fixp->fx_where;
1272 }
1273
1274 int
1275 md_apply_fix3 (fixp, valuep, seg)
1276      fixS *fixp;
1277      valueT *valuep;
1278      segT seg;
1279 {
1280   char *where;
1281   unsigned long insn;
1282   long value;
1283   int op_type;
1284   int left=0;
1285
1286   if (fixp->fx_addsy == (symbolS *) NULL)
1287     {
1288       value = *valuep;
1289       fixp->fx_done = 1;
1290     }
1291   else if (fixp->fx_pcrel)
1292     value = *valuep;
1293   else
1294     {
1295       value = fixp->fx_offset;
1296       if (fixp->fx_subsy != (symbolS *) NULL)
1297         {
1298           if (S_GET_SEGMENT (fixp->fx_subsy) == absolute_section)
1299             value -= S_GET_VALUE (fixp->fx_subsy);
1300           else
1301             {
1302               /* We don't actually support subtracting a symbol.  */
1303               as_bad_where (fixp->fx_file, fixp->fx_line,
1304                             "expression too complex");
1305             }
1306         }
1307     }
1308
1309   op_type = fixp->fx_r_type;
1310   if (op_type & 2048)
1311     {
1312       op_type -= 2048;
1313       if (op_type & 1024)
1314         {
1315           op_type -= 1024;
1316           fixp->fx_r_type = BFD_RELOC_D10V_10_PCREL_L;
1317           left = 1;
1318         }
1319       else if (op_type & 4096)
1320         {
1321           op_type -= 4096;
1322           fixp->fx_r_type = BFD_RELOC_D10V_18;
1323         }
1324       else
1325         fixp->fx_r_type = get_reloc((struct d10v_operand *)&d10v_operands[op_type]);
1326     }
1327
1328   /* Fetch the instruction, insert the fully resolved operand
1329      value, and stuff the instruction back again.  */
1330   where = fixp->fx_frag->fr_literal + fixp->fx_where;
1331   insn = bfd_getb32 ((unsigned char *) where);
1332
1333   switch (fixp->fx_r_type)
1334     {
1335     case BFD_RELOC_D10V_10_PCREL_L:
1336     case BFD_RELOC_D10V_10_PCREL_R:
1337     case BFD_RELOC_D10V_18_PCREL:
1338     case BFD_RELOC_D10V_18:
1339       /* instruction addresses are always right-shifted by 2 */
1340       value >>= 2;
1341       if (fixp->fx_size == 2)
1342         bfd_putb16 ((bfd_vma) value, (unsigned char *) where);
1343       else
1344         {
1345           insn = d10v_insert_operand (insn, op_type, (offsetT)value, left, fixp);
1346           bfd_putb32 ((bfd_vma) insn, (unsigned char *) where);
1347         }
1348       break;
1349     case BFD_RELOC_32:
1350       bfd_putb32 ((bfd_vma) value, (unsigned char *) where);
1351       break;
1352     case BFD_RELOC_16:
1353       bfd_putb16 ((bfd_vma) value, (unsigned char *) where);
1354       break;
1355     default:
1356       as_fatal ("line %d: unknown relocation type: 0x%x",fixp->fx_line,fixp->fx_r_type);
1357     }
1358   return 0;
1359 }
1360
1361 /* d10v_cleanup() is called after the assembler has finished parsing the input
1362    file or after a label is defined.  Because the D10V assembler sometimes saves short
1363    instructions to see if it can package them with the next instruction, there may
1364    be a short instruction that still needs written.  */
1365 int
1366 d10v_cleanup ()
1367 {
1368   segT seg;
1369   subsegT subseg;
1370
1371   if (prev_opcode)
1372     {
1373       seg = now_seg;
1374       subseg = now_subseg;
1375       subseg_set (prev_seg, prev_subseg);
1376       write_1_short (prev_opcode, prev_insn, fixups->next);
1377       subseg_set (seg, subseg);
1378       prev_opcode = NULL;
1379     }
1380   return 1;
1381 }
1382
1383 /* Like normal .word, except support @word */
1384 /* clobbers input_line_pointer, checks end-of-line. */
1385 static void
1386 d10v_dot_word (nbytes)
1387      register int nbytes;       /* 1=.byte, 2=.word, 4=.long */
1388 {
1389   expressionS exp;
1390   bfd_reloc_code_real_type reloc;
1391   char *p;
1392   int offset;
1393
1394   if (is_it_end_of_statement ())
1395     {
1396       demand_empty_rest_of_line ();
1397       return;
1398     }
1399
1400   do
1401     {
1402       expression (&exp);
1403       if (!strncasecmp (input_line_pointer, "@word", 5))
1404         {
1405           exp.X_add_number = 0;
1406           input_line_pointer += 5;
1407
1408           p = frag_more (2);
1409           fix_new_exp (frag_now, p - frag_now->fr_literal, 2,
1410                        &exp, 0, BFD_RELOC_D10V_18);
1411         }
1412       else
1413         emit_expr (&exp, 2);
1414     }
1415   while (*input_line_pointer++ == ',');
1416
1417   input_line_pointer--;         /* Put terminator back into stream. */
1418   demand_empty_rest_of_line ();
1419 }
1420
1421
1422 /* Mitsubishi asked that we support some old syntax that apparently */
1423 /* had immediate operands starting with '#'.  This is in some of their */
1424 /* sample code but is not documented (although it appears in some  */
1425 /* examples in their assembler manual). For now, we'll solve this */
1426 /* compatibility problem by simply ignoring any '#' at the beginning */
1427 /* of an operand. */
1428
1429 /* operands that begin with '#' should fall through to here */
1430 /* from expr.c */
1431
1432 void
1433 md_operand (expressionP)
1434      expressionS *expressionP;
1435 {
1436   if (*input_line_pointer == '#')
1437     {
1438       input_line_pointer++;
1439       expression (expressionP);
1440     }
1441 }
1442