gas/config/tc-h8300.c

   1 /* tc-h8300.c -- Assemble code for the Hitachi H8/300
   2    Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000, 2001
   3    Free Software Foundation, Inc.
   4
   5    This file is part of GAS, the GNU Assembler.
   6
   7    GAS is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2, or (at your option)
  10    any later version.
  11
  12    GAS is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with GAS; see the file COPYING.  If not, write to the Free
  19    Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20    02111-1307, USA.  */
  21
  22 /* Written By Steve Chamberlain <sac@cygnus.com>.  */
  23
  24 #include <stdio.h>
  25 #include "as.h"
  26 #include "subsegs.h"
  27 #include "bfd.h"
  28 #define DEFINE_TABLE
  29 #define h8_opcodes ops
  30 #include "opcode/h8300.h"
  31 #include <ctype.h>
  32
  33 #ifdef OBJ_ELF
  34 #include "elf/h8.h"
  35 #endif
  36
  37 const char comment_chars[] = ";";
  38 const char line_comment_chars[] = "#";
  39 const char line_separator_chars[] = "";
  40
  41 /* This table describes all the machine specific pseudo-ops the assembler
  42    has to support.  The fields are:
  43    pseudo-op name without dot
  44    function to call to execute this pseudo-op
  45    Integer arg to pass to the function
  46    */
  47
  48 void cons ();
  49
  50 int Hmode;
  51 int Smode;
  52 #define PSIZE (Hmode ? L_32 : L_16)
  53 #define DMODE (L_16)
  54 #define DSYMMODE (Hmode ? L_24 : L_16)
  55 int bsize = L_8;                /* default branch displacement */
  56
  57 void
  58 h8300hmode ()
  59 {
  60   Hmode = 1;
  61   Smode = 0;
  62 #ifdef BFD_ASSEMBLER
  63   if (!bfd_set_arch_mach (stdoutput, bfd_arch_h8300, bfd_mach_h8300h))
  64     as_warn (_("could not set architecture and machine"));
  65 #endif
  66 }
  67
  68 void
  69 h8300smode ()
  70 {
  71   Smode = 1;
  72   Hmode = 1;
  73 #ifdef BFD_ASSEMBLER
  74   if (!bfd_set_arch_mach (stdoutput, bfd_arch_h8300, bfd_mach_h8300s))
  75     as_warn (_("could not set architecture and machine"));
  76 #endif
  77 }
  78
  79 void
  80 sbranch (size)
  81      int size;
  82 {
  83   bsize = size;
  84 }
  85
  86 static void
  87 pint ()
  88 {
  89   cons (Hmode ? 4 : 2);
  90 }
  91
  92 const pseudo_typeS md_pseudo_table[] =
  93 {
  94   {"h8300h", h8300hmode, 0},
  95   {"h8300s", h8300smode, 0},
  96   {"sbranch", sbranch, L_8},
  97   {"lbranch", sbranch, L_16},
  98
  99   {"int", pint, 0},
 100   {"data.b", cons, 1},
 101   {"data.w", cons, 2},
 102   {"data.l", cons, 4},
 103   {"form", listing_psize, 0},
 104   {"heading", listing_title, 0},
 105   {"import", s_ignore, 0},
 106   {"page", listing_eject, 0},
 107   {"program", s_ignore, 0},
 108   {0, 0, 0}
 109 };
 110
 111 const int md_reloc_size;
 112
 113 const char EXP_CHARS[] = "eE";
 114
 115 /* Chars that mean this number is a floating point constant */
 116 /* As in 0f12.456 */
 117 /* or    0d1.2345e12 */
 118 const char FLT_CHARS[] = "rRsSfFdDxXpP";
 119
 120 static struct hash_control *opcode_hash_control;        /* Opcode mnemonics */
 121
 122 /* This function is called once, at assembler startup time.  This
 123    should set up all the tables, etc. that the MD part of the assembler
 124    needs.  */
 125 void
 126 md_begin ()
 127 {
 128   struct h8_opcode *opcode;
 129   char prev_buffer[100];
 130   int idx = 0;
 131
 132 #ifdef BFD_ASSEMBLER
 133   if (!bfd_set_arch_mach (stdoutput, bfd_arch_h8300, bfd_mach_h8300))
 134     as_warn (_("could not set architecture and machine"));
 135 #endif
 136
 137   opcode_hash_control = hash_new ();
 138   prev_buffer[0] = 0;
 139
 140   for (opcode = h8_opcodes; opcode->name; opcode++)
 141     {
 142       /* Strip off any . part when inserting the opcode and only enter
 143          unique codes into the hash table.  */
 144       char *src = opcode->name;
 145       unsigned int len = strlen (src);
 146       char *dst = malloc (len + 1);
 147       char *buffer = dst;
 148
 149       opcode->size = 0;
 150       while (*src)
 151         {
 152           if (*src == '.')
 153             {
 154               src++;
 155               opcode->size = *src;
 156               break;
 157             }
 158           *dst++ = *src++;
 159         }
 160       *dst++ = 0;
 161       if (strcmp (buffer, prev_buffer))
 162         {
 163           hash_insert (opcode_hash_control, buffer, (char *) opcode);
 164           strcpy (prev_buffer, buffer);
 165           idx++;
 166         }
 167       opcode->idx = idx;
 168
 169       /* Find the number of operands.  */
 170       opcode->noperands = 0;
 171       while (opcode->args.nib[opcode->noperands] != E)
 172         opcode->noperands++;
 173
 174       /* Find the length of the opcode in bytes.  */
 175       opcode->length = 0;
 176       while (opcode->data.nib[opcode->length * 2] != E)
 177         opcode->length++;
 178     }
 179
 180   linkrelax = 1;
 181 }
 182
 183 struct h8_exp
 184 {
 185   char *e_beg;
 186   char *e_end;
 187   expressionS e_exp;
 188 };
 189
 190 int dispreg;
 191 int opsize;                     /* Set when a register size is seen */
 192
 193 struct h8_op
 194 {
 195   op_type mode;
 196   unsigned reg;
 197   expressionS exp;
 198 };
 199
 200 /*
 201   parse operands
 202   WREG r0,r1,r2,r3,r4,r5,r6,r7,fp,sp
 203   r0l,r0h,..r7l,r7h
 204   @WREG
 205   @WREG+
 206   @-WREG
 207   #const
 208   ccr
 209 */
 210
 211 /* Try to parse a reg name.  Return the number of chars consumed.  */
 212
 213 static int
 214 parse_reg (src, mode, reg, direction)
 215      char *src;
 216      op_type *mode;
 217      unsigned int *reg;
 218      int direction;
 219
 220 {
 221   char *end;
 222   int len;
 223
 224   /* Cribbed from get_symbol_end.  */
 225   if (!is_name_beginner (*src) || *src == '\001')
 226     return 0;
 227   end = src + 1;
 228   while (is_part_of_name (*end) || *end == '\001')
 229     end++;
 230   len = end - src;
 231
 232   if (len == 2 && src[0] == 's' && src[1] == 'p')
 233     {
 234       *mode = PSIZE | REG | direction;
 235       *reg = 7;
 236       return len;
 237     }
 238   if (len == 3 && src[0] == 'c' && src[1] == 'c' && src[2] == 'r')
 239     {
 240       *mode = CCR;
 241       *reg = 0;
 242       return len;
 243     }
 244   if (len == 3 && src[0] == 'e' && src[1] == 'x' && src[2] == 'r')
 245     {
 246       *mode = EXR;
 247       *reg = 0;
 248       return len;
 249     }
 250   if (len == 2 && src[0] == 'f' && src[1] == 'p')
 251     {
 252       *mode = PSIZE | REG | direction;
 253       *reg = 6;
 254       return len;
 255     }
 256   if (len == 3 && src[0] == 'e' && src[1] == 'r'
 257       && src[2] >= '0' && src[2] <= '7')
 258     {
 259       *mode = L_32 | REG | direction;
 260       *reg = src[2] - '0';
 261       if (!Hmode)
 262         as_warn (_("Reg not valid for H8/300"));
 263       return len;
 264     }
 265   if (len == 2 && src[0] == 'e' && src[1] >= '0' && src[1] <= '7')
 266     {
 267       *mode = L_16 | REG | direction;
 268       *reg = src[1] - '0' + 8;
 269       if (!Hmode)
 270         as_warn (_("Reg not valid for H8/300"));
 271       return len;
 272     }
 273
 274   if (src[0] == 'r')
 275     {
 276       if (src[1] >= '0' && src[1] <= '7')
 277         {
 278           if (len == 3 && src[2] == 'l')
 279             {
 280               *mode = L_8 | REG | direction;
 281               *reg = (src[1] - '0') + 8;
 282               return len;
 283             }
 284           if (len == 3 && src[2] == 'h')
 285             {
 286               *mode = L_8 | REG | direction;
 287               *reg = (src[1] - '0');
 288               return len;
 289             }
 290           if (len == 2)
 291             {
 292               *mode = L_16 | REG | direction;
 293               *reg = (src[1] - '0');
 294               return len;
 295             }
 296         }
 297     }
 298
 299   return 0;
 300 }
 301
 302 static char *
 303 parse_exp (s, op)
 304      char *s;
 305      expressionS *op;
 306 {
 307   char *save = input_line_pointer;
 308   char *new;
 309
 310   input_line_pointer = s;
 311   expression (op);
 312   if (op->X_op == O_absent)
 313     as_bad (_("missing operand"));
 314   new = input_line_pointer;
 315   input_line_pointer = save;
 316   return new;
 317 }
 318
 319 static char *
 320 skip_colonthing (ptr, exp, mode)
 321      char *ptr;
 322      expressionS *exp ATTRIBUTE_UNUSED;
 323      int *mode;
 324 {
 325   if (*ptr == ':')
 326     {
 327       ptr++;
 328       *mode &= ~SIZE;
 329       if (*ptr == '8')
 330         {
 331           ptr++;
 332           /* ff fill any 8 bit quantity */
 333           /* exp->X_add_number -= 0x100; */
 334           *mode |= L_8;
 335         }
 336       else
 337         {
 338           if (*ptr == '2')
 339             {
 340               *mode |= L_24;
 341             }
 342           else if (*ptr == '3')
 343             {
 344               *mode |= L_32;
 345             }
 346           else if (*ptr == '1')
 347             {
 348               *mode |= L_16;
 349             }
 350           while (isdigit (*ptr))
 351             ptr++;
 352         }
 353     }
 354   return ptr;
 355 }
 356
 357 /* The many forms of operand:
 358
 359    Rn                   Register direct
 360    @Rn                  Register indirect
 361    @(exp[:16], Rn)      Register indirect with displacement
 362    @Rn+
 363    @-Rn
 364    @aa:8                absolute 8 bit
 365    @aa:16               absolute 16 bit
 366    @aa                  absolute 16 bit
 367
 368    #xx[:size]           immediate data
 369    @(exp:[8], pc)       pc rel
 370    @@aa[:8]             memory indirect
 371
 372    */
 373
 374 char *
 375 colonmod24 (op, src)
 376      struct h8_op *op;
 377      char *src;
 378
 379 {
 380   int mode = 0;
 381   src = skip_colonthing (src, &op->exp, &mode);
 382
 383   if (!mode)
 384     {
 385       /* Choose a default mode.  */
 386       if (op->exp.X_add_number < -32768
 387           || op->exp.X_add_number > 32767)
 388         {
 389           if (Hmode)
 390             mode = L_24;
 391           else
 392             mode = L_16;
 393         }
 394       else if (op->exp.X_add_symbol
 395                || op->exp.X_op_symbol)
 396         mode = DSYMMODE;
 397       else
 398         mode = DMODE;
 399     }
 400   op->mode |= mode;
 401   return src;
 402
 403 }
 404
 405 static void
 406 get_operand (ptr, op, dst, direction)
 407      char **ptr;
 408      struct h8_op *op;
 409      unsigned int dst ATTRIBUTE_UNUSED;
 410      int direction;
 411 {
 412   char *src = *ptr;
 413   op_type mode;
 414   unsigned int num;
 415   unsigned int len;
 416
 417   op->mode = E;
 418
 419   /* Gross.  Gross.  ldm and stm have a format not easily handled
 420      by get_operand.  We deal with it explicitly here.  */
 421   if (src[0] == 'e' && src[1] == 'r' && isdigit (src[2])
 422       && src[3] == '-' && src[4] == 'e' && src[5] == 'r' && isdigit (src[6]))
 423     {
 424       int low, high;
 425
 426       low = src[2] - '0';
 427       high = src[6] - '0';
 428
 429       if (high < low)
 430         as_bad (_("Invalid register list for ldm/stm\n"));
 431
 432       if (low % 2)
 433         as_bad (_("Invalid register list for ldm/stm\n"));
 434
 435       if (high - low > 3)
 436         as_bad (_("Invalid register list for ldm/stm\n"));
 437
 438       if (high - low != 1
 439           && low % 4)
 440         as_bad (_("Invalid register list for ldm/stm\n"));
 441
 442       /* Even sicker.  We encode two registers into op->reg.  One
 443          for the low register to save, the other for the high
 444          register to save;  we also set the high bit in op->reg
 445          so we know this is "very special".  */
 446       op->reg = 0x80000000 | (high << 8) | low;
 447       op->mode = REG;
 448       *ptr = src + 7;
 449       return;
 450     }
 451
 452   len = parse_reg (src, &op->mode, &op->reg, direction);
 453   if (len)
 454     {
 455       *ptr = src + len;
 456       return;
 457     }
 458
 459   if (*src == '@')
 460     {
 461       src++;
 462       if (*src == '@')
 463         {
 464           src++;
 465           src = parse_exp (src, &op->exp);
 466
 467           src = skip_colonthing (src, &op->exp, &op->mode);
 468
 469           *ptr = src;
 470
 471           op->mode = MEMIND;
 472           return;
 473         }
 474
 475       if (*src == '-')
 476         {
 477           src++;
 478           len = parse_reg (src, &mode, &num, direction);
 479           if (len == 0)
 480             {
 481               /* Oops, not a reg after all, must be ordinary exp.  */
 482               src--;
 483               /* Must be a symbol.  */
 484               op->mode = ABS | PSIZE | direction;
 485               *ptr = skip_colonthing (parse_exp (src, &op->exp),
 486                                       &op->exp, &op->mode);
 487
 488               return;
 489             }
 490
 491           if ((mode & SIZE) != PSIZE)
 492             as_bad (_("Wrong size pointer register for architecture."));
 493           op->mode = RDDEC;
 494           op->reg = num;
 495           *ptr = src + len;
 496           return;
 497         }
 498       if (*src == '(')
 499         {
 500           /* Disp.  */
 501           src++;
 502
 503           /* Start off assuming a 16 bit offset.  */
 504
 505           src = parse_exp (src, &op->exp);
 506
 507           src = colonmod24 (op, src);
 508
 509           if (*src == ')')
 510             {
 511               src++;
 512               op->mode |= ABS | direction;
 513               *ptr = src;
 514               return;
 515             }
 516
 517           if (*src != ',')
 518             {
 519               as_bad (_("expected @(exp, reg16)"));
 520               return;
 521
 522             }
 523           src++;
 524
 525           len = parse_reg (src, &mode, &op->reg, direction);
 526           if (len == 0 || !(mode & REG))
 527             {
 528               as_bad (_("expected @(exp, reg16)"));
 529               return;
 530             }
 531           op->mode |= DISP | direction;
 532           dispreg = op->reg;
 533           src += len;
 534           src = skip_colonthing (src, &op->exp, &op->mode);
 535
 536           if (*src != ')' && '(')
 537             {
 538               as_bad (_("expected @(exp, reg16)"));
 539               return;
 540             }
 541           *ptr = src + 1;
 542
 543           return;
 544         }
 545       len = parse_reg (src, &mode, &num, direction);
 546
 547       if (len)
 548         {
 549           src += len;
 550           if (*src == '+')
 551             {
 552               src++;
 553               if ((mode & SIZE) != PSIZE)
 554                 as_bad (_("Wrong size pointer register for architecture."));
 555               op->mode = RSINC;
 556               op->reg = num;
 557               *ptr = src;
 558               return;
 559             }
 560           if ((mode & SIZE) != PSIZE)
 561             as_bad (_("Wrong size pointer register for architecture."));
 562
 563           op->mode = direction | IND | PSIZE;
 564           op->reg = num;
 565           *ptr = src;
 566
 567           return;
 568         }
 569       else
 570         {
 571           /* must be a symbol */
 572
 573           op->mode = ABS | direction;
 574           src = parse_exp (src, &op->exp);
 575
 576           *ptr = colonmod24 (op, src);
 577
 578           return;
 579         }
 580     }
 581
 582   if (*src == '#')
 583     {
 584       src++;
 585       op->mode = IMM;
 586       src = parse_exp (src, &op->exp);
 587       *ptr = skip_colonthing (src, &op->exp, &op->mode);
 588
 589       return;
 590     }
 591   else if (strncmp (src, "mach", 4) == 0
 592            || strncmp (src, "macl", 4) == 0)
 593     {
 594       op->reg = src[3] == 'l';
 595       op->mode = MACREG;
 596       *ptr = src + 4;
 597       return;
 598     }
 599   else
 600     {
 601       src = parse_exp (src, &op->exp);
 602       /* Trailing ':' size ? */
 603       if (*src == ':')
 604         {
 605           if (src[1] == '1' && src[2] == '6')
 606             {
 607               op->mode = PCREL | L_16;
 608               src += 3;
 609             }
 610           else if (src[1] == '8')
 611             {
 612               op->mode = PCREL | L_8;
 613               src += 2;
 614             }
 615           else
 616             {
 617               as_bad (_("expect :8 or :16 here"));
 618             }
 619         }
 620       else
 621         {
 622           op->mode = PCREL | bsize;
 623         }
 624       *ptr = src;
 625     }
 626 }
 627
 628 static char *
 629 get_operands (noperands, op_end, operand)
 630      unsigned int noperands;
 631      char *op_end;
 632      struct h8_op *operand;
 633 {
 634   char *ptr = op_end;
 635
 636   switch (noperands)
 637     {
 638     case 0:
 639       operand[0].mode = 0;
 640       operand[1].mode = 0;
 641       break;
 642
 643     case 1:
 644       ptr++;
 645       get_operand (&ptr, operand + 0, 0, SRC);
 646       if (*ptr == ',')
 647         {
 648           ptr++;
 649           get_operand (&ptr, operand + 1, 1, DST);
 650         }
 651       else
 652         {
 653           operand[1].mode = 0;
 654         }
 655       break;
 656
 657     case 2:
 658       ptr++;
 659       get_operand (&ptr, operand + 0, 0, SRC);
 660       if (*ptr == ',')
 661         ptr++;
 662       get_operand (&ptr, operand + 1, 1, DST);
 663       break;
 664
 665     default:
 666       abort ();
 667     }
 668
 669   return ptr;
 670 }
 671
 672 /* Passed a pointer to a list of opcodes which use different
 673    addressing modes, return the opcode which matches the opcodes
 674    provided.  */
 675 static struct h8_opcode *
 676 get_specific (opcode, operands, size)
 677      struct h8_opcode *opcode;
 678      struct h8_op *operands;
 679      int size;
 680 {
 681   struct h8_opcode *this_try = opcode;
 682   int found = 0;
 683
 684   unsigned int this_index = opcode->idx;
 685
 686   /* There's only one ldm/stm and it's easier to just
 687      get out quick for them.  */
 688   if (strcmp (opcode->name, "stm.l") == 0
 689       || strcmp (opcode->name, "ldm.l") == 0)
 690     return this_try;
 691
 692   while (this_index == opcode->idx && !found)
 693     {
 694       found = 1;
 695
 696       this_try = opcode++;
 697       if (this_try->noperands == 0)
 698         {
 699           int this_size;
 700
 701           this_size = this_try->how & SN;
 702           if (this_size != size && (this_size != SB || size != SN))
 703             found = 0;
 704         }
 705       else
 706         {
 707           unsigned int i;
 708
 709           for (i = 0; i < this_try->noperands && found; i++)
 710             {
 711               op_type op = this_try->args.nib[i];
 712               int x = operands[i].mode;
 713
 714               if ((op & (DISP | REG)) == (DISP | REG)
 715                   && ((x & (DISP | REG)) == (DISP | REG)))
 716                 {
 717                   dispreg = operands[i].reg;
 718                 }
 719               else if (op & REG)
 720                 {
 721                   if (!(x & REG))
 722                     found = 0;
 723
 724                   if (x & L_P)
 725                     x = (x & ~L_P) | (Hmode ? L_32 : L_16);
 726                   if (op & L_P)
 727                     op = (op & ~L_P) | (Hmode ? L_32 : L_16);
 728
 729                   opsize = op & SIZE;
 730
 731                   /* The size of the reg is v important.  */
 732                   if ((op & SIZE) != (x & SIZE))
 733                     found = 0;
 734                 }
 735               else if ((op & ABSJMP) && (x & ABS))
 736                 {
 737                   operands[i].mode &= ~ABS;
 738                   operands[i].mode |= ABSJMP;
 739                   /* But it may not be 24 bits long.  */
 740                   if (!Hmode)
 741                     {
 742                       operands[i].mode &= ~SIZE;
 743                       operands[i].mode |= L_16;
 744                     }
 745                 }
 746               else if ((op & (KBIT | DBIT)) && (x & IMM))
 747                 {
 748                   /* This is ok if the immediate value is sensible.  */
 749                 }
 750               else if (op & PCREL)
 751                 {
 752                   /* The size of the displacement is important.  */
 753                   if ((op & SIZE) != (x & SIZE))
 754                     found = 0;
 755                 }
 756               else if ((op & (DISP | IMM | ABS))
 757                        && (op & (DISP | IMM | ABS)) == (x & (DISP | IMM | ABS)))
 758                 {
 759                   /* Promote a L_24 to L_32 if it makes us match.  */
 760                   if ((x & L_24) && (op & L_32))
 761                     {
 762                       x &= ~L_24;
 763                       x |= L_32;
 764                     }
 765                   /* Promote an L8 to L_16 if it makes us match.  */
 766                   if (op & ABS && op & L_8 && op & DISP)
 767                     {
 768                       if (x & L_16)
 769                         found = 1;
 770                     }
 771                   else if ((x & SIZE) != 0
 772                            && ((op & SIZE) != (x & SIZE)))
 773                     found = 0;
 774                 }
 775               else if ((op & MACREG) != (x & MACREG))
 776                 {
 777                   found = 0;
 778                 }
 779               else if ((op & MODE) != (x & MODE))
 780                 {
 781                   found = 0;
 782                 }
 783             }
 784         }
 785     }
 786   if (found)
 787     return this_try;
 788   else
 789     return 0;
 790 }
 791
 792 static void
 793 check_operand (operand, width, string)
 794      struct h8_op *operand;
 795      unsigned int width;
 796      char *string;
 797 {
 798   if (operand->exp.X_add_symbol == 0
 799       && operand->exp.X_op_symbol == 0)
 800     {
 801       /* No symbol involved, let's look at offset, it's dangerous if
 802          any of the high bits are not 0 or ff's, find out by oring or
 803          anding with the width and seeing if the answer is 0 or all
 804          fs.  */
 805
 806       if ((operand->exp.X_add_number & ~width) != 0 &&
 807           (operand->exp.X_add_number | width) != (~0))
 808         {
 809           if (width == 255
 810               && (operand->exp.X_add_number & 0xff00) == 0xff00)
 811             {
 812               /* Just ignore this one - which happens when trying to
 813                  fit a 16 bit address truncated into an 8 bit address
 814                  of something like bset.  */
 815             }
 816           else
 817             {
 818               as_warn (_("operand %s0x%lx out of range."), string,
 819                        (unsigned long) operand->exp.X_add_number);
 820             }
 821         }
 822     }
 823 }
 824
 825 /* RELAXMODE has one of 3 values:
 826
 827    0 Output a "normal" reloc, no relaxing possible for this insn/reloc
 828
 829    1 Output a relaxable 24bit absolute mov.w address relocation
 830      (may relax into a 16bit absolute address).
 831
 832    2 Output a relaxable 16/24 absolute mov.b address relocation
 833      (may relax into an 8bit absolute address).  */
 834
 835 static void
 836 do_a_fix_imm (offset, operand, relaxmode)
 837      int offset;
 838      struct h8_op *operand;
 839      int relaxmode;
 840 {
 841   int idx;
 842   int size;
 843   int where;
 844
 845   char *t = operand->mode & IMM ? "#" : "@";
 846
 847   if (operand->exp.X_add_symbol == 0)
 848     {
 849       char *bytes = frag_now->fr_literal + offset;
 850       switch (operand->mode & SIZE)
 851         {
 852         case L_2:
 853           check_operand (operand, 0x3, t);
 854           bytes[0] |= (operand->exp.X_add_number) << 4;
 855           break;
 856         case L_3:
 857           check_operand (operand, 0x7, t);
 858           bytes[0] |= (operand->exp.X_add_number) << 4;
 859           break;
 860         case L_8:
 861           check_operand (operand, 0xff, t);
 862           bytes[0] = operand->exp.X_add_number;
 863           break;
 864         case L_16:
 865           check_operand (operand, 0xffff, t);
 866           bytes[0] = operand->exp.X_add_number >> 8;
 867           bytes[1] = operand->exp.X_add_number >> 0;
 868           break;
 869         case L_24:
 870           check_operand (operand, 0xffffff, t);
 871           bytes[0] = operand->exp.X_add_number >> 16;
 872           bytes[1] = operand->exp.X_add_number >> 8;
 873           bytes[2] = operand->exp.X_add_number >> 0;
 874           break;
 875
 876         case L_32:
 877           /* This should be done with bfd.  */
 878           bytes[0] = operand->exp.X_add_number >> 24;
 879           bytes[1] = operand->exp.X_add_number >> 16;
 880           bytes[2] = operand->exp.X_add_number >> 8;
 881           bytes[3] = operand->exp.X_add_number >> 0;
 882           if (relaxmode != 0)
 883             {
 884               idx = (relaxmode == 2) ? R_MOV24B1 : R_MOVL1;
 885               fix_new_exp (frag_now, offset, 4, &operand->exp, 0, idx);
 886             }
 887           break;
 888         }
 889     }
 890   else
 891     {
 892       switch (operand->mode & SIZE)
 893         {
 894         case L_24:
 895         case L_32:
 896           size = 4;
 897           where = (operand->mode & SIZE) == L_24 ? -1 : 0;
 898           if (relaxmode == 2)
 899             idx = R_MOV24B1;
 900           else if (relaxmode == 1)
 901             idx = R_MOVL1;
 902           else
 903             idx = R_RELLONG;
 904           break;
 905         default:
 906           as_bad (_("Can't work out size of operand.\n"));
 907         case L_16:
 908           size = 2;
 909           where = 0;
 910           if (relaxmode == 2)
 911             idx = R_MOV16B1;
 912           else
 913             idx = R_RELWORD;
 914           operand->exp.X_add_number =
 915             ((operand->exp.X_add_number & 0xffff) ^ 0x8000) - 0x8000;
 916           break;
 917         case L_8:
 918           size = 1;
 919           where = 0;
 920           idx = R_RELBYTE;
 921           operand->exp.X_add_number =
 922             ((operand->exp.X_add_number & 0xff) ^ 0x80) - 0x80;
 923         }
 924
 925       fix_new_exp (frag_now,
 926                    offset + where,
 927                    size,
 928                    &operand->exp,
 929                    0,
 930                    idx);
 931     }
 932 }
 933
 934 /* Now we know what sort of opcodes it is, let's build the bytes.  */
 935 static void
 936 build_bytes (this_try, operand)
 937      struct h8_opcode *this_try;
 938      struct h8_op *operand;
 939 {
 940   unsigned int i;
 941
 942   char *output = frag_more (this_try->length);
 943   op_type *nibble_ptr = this_try->data.nib;
 944   op_type c;
 945   unsigned int nibble_count = 0;
 946   int absat;
 947   int immat;
 948   int nib;
 949   int movb = 0;
 950   char asnibbles[30];
 951   char *p = asnibbles;
 952
 953   if (!(this_try->inbase || Hmode))
 954     as_warn (_("Opcode `%s' with these operand types not available in H8/300 mode"),
 955              this_try->name);
 956
 957   while (*nibble_ptr != E)
 958     {
 959       int d;
 960       c = *nibble_ptr++;
 961
 962       d = (c & (DST | SRC_IN_DST)) != 0;
 963
 964       if (c < 16)
 965         {
 966           nib = c;
 967         }
 968       else
 969         {
 970           if (c & (REG | IND | INC | DEC))
 971             {
 972               nib = operand[d].reg;
 973             }
 974           else if ((c & DISPREG) == (DISPREG))
 975             {
 976               nib = dispreg;
 977             }
 978           else if (c & ABS)
 979             {
 980               operand[d].mode = c;
 981               absat = nibble_count / 2;
 982               nib = 0;
 983             }
 984           else if (c & (IMM | PCREL | ABS | ABSJMP | DISP))
 985             {
 986               operand[d].mode = c;
 987               immat = nibble_count / 2;
 988               nib = 0;
 989             }
 990           else if (c & IGNORE)
 991             {
 992               nib = 0;
 993             }
 994           else if (c & DBIT)
 995             {
 996               switch (operand[0].exp.X_add_number)
 997                 {
 998                 case 1:
 999                   nib = c;
1000                   break;
1001                 case 2:
1002                   nib = 0x8 | c;
1003                   break;
1004                 default:
1005                   as_bad (_("Need #1 or #2 here"));
1006                 }
1007             }
1008           else if (c & KBIT)
1009             {
1010               switch (operand[0].exp.X_add_number)
1011                 {
1012                 case 1:
1013                   nib = 0;
1014                   break;
1015                 case 2:
1016                   nib = 8;
1017                   break;
1018                 case 4:
1019                   if (!Hmode)
1020                     as_warn (_("#4 not valid on H8/300."));
1021                   nib = 9;
1022                   break;
1023
1024                 default:
1025                   as_bad (_("Need #1 or #2 here"));
1026                   break;
1027                 }
1028               /* Stop it making a fix.  */
1029               operand[0].mode = 0;
1030             }
1031
1032           if (c & MEMRELAX)
1033             {
1034               operand[d].mode |= MEMRELAX;
1035             }
1036
1037           if (c & B31)
1038             {
1039               nib |= 0x8;
1040             }
1041
1042           if (c & MACREG)
1043             {
1044               if (operand[0].mode == MACREG)
1045                 /* stmac has mac[hl] as the first operand.  */
1046                 nib = 2 + operand[0].reg;
1047               else
1048                 /* ldmac has mac[hl] as the second operand.  */
1049                 nib = 2 + operand[1].reg;
1050             }
1051         }
1052       nibble_count++;
1053
1054       *p++ = nib;
1055     }
1056
1057   /* Disgusting.  Why, oh why didn't someone ask us for advice
1058      on the assembler format.  */
1059   if (strcmp (this_try->name, "stm.l") == 0
1060       || strcmp (this_try->name, "ldm.l") == 0)
1061     {
1062       int high, low;
1063       high = (operand[this_try->name[0] == 'l' ? 1 : 0].reg >> 8) & 0xf;
1064       low = operand[this_try->name[0] == 'l' ? 1 : 0].reg & 0xf;
1065
1066       asnibbles[2] = high - low;
1067       asnibbles[7] = (this_try->name[0] == 'l') ? high : low;
1068     }
1069
1070   for (i = 0; i < this_try->length; i++)
1071     {
1072       output[i] = (asnibbles[i * 2] << 4) | asnibbles[i * 2 + 1];
1073     }
1074
1075   /* Note if this is a movb instruction -- there's a special relaxation
1076      which only applies to them.  */
1077   if (strcmp (this_try->name, "mov.b") == 0)
1078     movb = 1;
1079
1080   /* Output any fixes.  */
1081   for (i = 0; i < 2; i++)
1082     {
1083       int x = operand[i].mode;
1084
1085       if (x & (IMM | DISP))
1086         {
1087           do_a_fix_imm (output - frag_now->fr_literal + immat,
1088                         operand + i, x & MEMRELAX != 0);
1089         }
1090       else if (x & ABS)
1091         {
1092           do_a_fix_imm (output - frag_now->fr_literal + absat,
1093                         operand + i, x & MEMRELAX ? movb + 1 : 0);
1094         }
1095       else if (x & PCREL)
1096         {
1097           int size16 = x & L_16;
1098           int where = size16 ? 2 : 1;
1099           int size = size16 ? 2 : 1;
1100           int type = size16 ? R_PCRWORD : R_PCRBYTE;
1101           fixS *fixP;
1102
1103           check_operand (operand + i, size16 ? 0x7fff : 0x7f, "@");
1104
1105           if (operand[i].exp.X_add_number & 1)
1106             {
1107               as_warn (_("branch operand has odd offset (%lx)\n"),
1108                        (unsigned long) operand->exp.X_add_number);
1109             }
1110
1111 #ifndef OBJ_ELF
1112           /* The COFF port has always been off by one, changing it
1113              now would be an incompatible change, so we leave it as-is.
1114
1115              We don't want to do this for ELF as we want to be
1116              compatible with the proposed ELF format from Hitachi.  */
1117           operand[i].exp.X_add_number -= 1;
1118 #endif
1119
1120           operand[i].exp.X_add_number =
1121             ((operand[i].exp.X_add_number & 0xff) ^ 0x80) - 0x80;
1122
1123           fixP = fix_new_exp (frag_now,
1124                               output - frag_now->fr_literal + where,
1125                               size,
1126                               &operand[i].exp,
1127                               1,
1128                               type);
1129           fixP->fx_signed = 1;
1130         }
1131       else if (x & MEMIND)
1132         {
1133           check_operand (operand + i, 0xff, "@@");
1134           fix_new_exp (frag_now,
1135                        output - frag_now->fr_literal + 1,
1136                        1,
1137                        &operand[i].exp,
1138                        0,
1139                        R_MEM_INDIRECT);
1140         }
1141       else if (x & ABSJMP)
1142         {
1143           int where = 0;
1144
1145 #ifdef OBJ_ELF
1146           /* To be compatible with the proposed H8 ELF format, we
1147              want the relocation's offset to point to the first byte
1148              that will be modified, not to the start of the instruction.  */
1149           where += 1;
1150
1151
1152 #endif
1153           /* This jmp may be a jump or a branch.  */
1154
1155           check_operand (operand + i, Hmode ? 0xffffff : 0xffff, "@");
1156           if (operand[i].exp.X_add_number & 1)
1157             {
1158               as_warn (_("branch operand has odd offset (%lx)\n"),
1159                        (unsigned long) operand->exp.X_add_number);
1160             }
1161           if (!Hmode)
1162             operand[i].exp.X_add_number =
1163               ((operand[i].exp.X_add_number & 0xffff) ^ 0x8000) - 0x8000;
1164           fix_new_exp (frag_now,
1165                        output - frag_now->fr_literal + where,
1166                        4,
1167                        &operand[i].exp,
1168                        0,
1169                        R_JMPL1);
1170         }
1171     }
1172 }
1173
1174 /* Try to give an intelligent error message for common and simple to
1175    detect errors.  */
1176 static void
1177 clever_message (opcode, operand)
1178      struct h8_opcode *opcode;
1179      struct h8_op *operand;
1180 {
1181   /* Find out if there was more than one possible opcode.  */
1182
1183   if ((opcode + 1)->idx != opcode->idx)
1184     {
1185       unsigned int argn;
1186
1187       /* Only one opcode of this flavour, try to guess which operand
1188          didn't match.  */
1189       for (argn = 0; argn < opcode->noperands; argn++)
1190         {
1191           switch (opcode->args.nib[argn])
1192             {
1193             case RD16:
1194               if (operand[argn].mode != RD16)
1195                 {
1196                   as_bad (_("destination operand must be 16 bit register"));
1197                   return;
1198
1199                 }
1200               break;
1201
1202             case RS8:
1203               if (operand[argn].mode != RS8)
1204                 {
1205                   as_bad (_("source operand must be 8 bit register"));
1206                   return;
1207                 }
1208               break;
1209
1210             case ABS16DST:
1211               if (operand[argn].mode != ABS16DST)
1212                 {
1213                   as_bad (_("destination operand must be 16bit absolute address"));
1214                   return;
1215                 }
1216               break;
1217             case RD8:
1218               if (operand[argn].mode != RD8)
1219                 {
1220                   as_bad (_("destination operand must be 8 bit register"));
1221                   return;
1222                 }
1223               break;
1224
1225             case ABS16SRC:
1226               if (operand[argn].mode != ABS16SRC)
1227                 {
1228                   as_bad (_("source operand must be 16bit absolute address"));
1229                   return;
1230                 }
1231               break;
1232
1233             }
1234         }
1235     }
1236   as_bad (_("invalid operands"));
1237 }
1238
1239 /* This is the guts of the machine-dependent assembler.  STR points to
1240    a machine dependent instruction.  This function is supposed to emit
1241    the frags/bytes it assembles.  */
1242 void
1243 md_assemble (str)
1244      char *str;
1245 {
1246   char *op_start;
1247   char *op_end;
1248   struct h8_op operand[2];
1249   struct h8_opcode *opcode;
1250   struct h8_opcode *prev_opcode;
1251
1252   char *dot = 0;
1253   char c;
1254   int size;
1255
1256   /* Drop leading whitespace.  */
1257   while (*str == ' ')
1258     str++;
1259
1260   /* Find the op code end.  */
1261   for (op_start = op_end = str;
1262        *op_end != 0 && *op_end != ' ';
1263        op_end++)
1264     {
1265       if (*op_end == '.')
1266         {
1267           dot = op_end + 1;
1268           *op_end = 0;
1269           op_end += 2;
1270           break;
1271         }
1272     }
1273
1274   if (op_end == op_start)
1275     {
1276       as_bad (_("can't find opcode "));
1277     }
1278   c = *op_end;
1279
1280   *op_end = 0;
1281
1282   opcode = (struct h8_opcode *) hash_find (opcode_hash_control,
1283                                            op_start);
1284
1285   if (opcode == NULL)
1286     {
1287       as_bad (_("unknown opcode"));
1288       return;
1289     }
1290
1291   /* We used to set input_line_pointer to the result of get_operands,
1292      but that is wrong.  Our caller assumes we don't change it.  */
1293
1294   (void) get_operands (opcode->noperands, op_end, operand);
1295   *op_end = c;
1296   prev_opcode = opcode;
1297
1298   size = SN;
1299   if (dot)
1300     {
1301       switch (*dot)
1302         {
1303         case 'b':
1304           size = SB;
1305           break;
1306
1307         case 'w':
1308           size = SW;
1309           break;
1310
1311         case 'l':
1312           size = SL;
1313           break;
1314         }
1315     }
1316   opcode = get_specific (opcode, operand, size);
1317
1318   if (opcode == 0)
1319     {
1320       /* Couldn't find an opcode which matched the operands.  */
1321       char *where = frag_more (2);
1322
1323       where[0] = 0x0;
1324       where[1] = 0x0;
1325       clever_message (prev_opcode, operand);
1326
1327       return;
1328     }
1329   if (opcode->size && dot)
1330     {
1331       if (opcode->size != *dot)
1332         {
1333           as_warn (_("mismatch between opcode size and operand size"));
1334         }
1335     }
1336
1337   build_bytes (opcode, operand);
1338 }
1339
1340 #ifndef BFD_ASSEMBLER
1341 void
1342 tc_crawl_symbol_chain (headers)
1343      object_headers *headers ATTRIBUTE_UNUSED;
1344 {
1345   printf (_("call to tc_crawl_symbol_chain \n"));
1346 }
1347 #endif
1348
1349 symbolS *
1350 md_undefined_symbol (name)
1351      char *name ATTRIBUTE_UNUSED;
1352 {
1353   return 0;
1354 }
1355
1356 #ifndef BFD_ASSEMBLER
1357 void
1358 tc_headers_hook (headers)
1359      object_headers *headers ATTRIBUTE_UNUSED;
1360 {
1361   printf (_("call to tc_headers_hook \n"));
1362 }
1363 #endif
1364
1365 /* Various routines to kill one day */
1366 /* Equal to MAX_PRECISION in atof-ieee.c */
1367 #define MAX_LITTLENUMS 6
1368
1369 /* Turn a string in input_line_pointer into a floating point constant
1370    of type TYPE, and store the appropriate bytes in *LITP.  The number
1371    of LITTLENUMS emitted is stored in *SIZEP.  An error message is
1372    returned, or NULL on OK.  */
1373
1374 char *
1375 md_atof (type, litP, sizeP)
1376      char type;
1377      char *litP;
1378      int *sizeP;
1379 {
1380   int prec;
1381   LITTLENUM_TYPE words[MAX_LITTLENUMS];
1382   LITTLENUM_TYPE *wordP;
1383   char *t;
1384   char *atof_ieee ();
1385
1386   switch (type)
1387     {
1388     case 'f':
1389     case 'F':
1390     case 's':
1391     case 'S':
1392       prec = 2;
1393       break;
1394
1395     case 'd':
1396     case 'D':
1397     case 'r':
1398     case 'R':
1399       prec = 4;
1400       break;
1401
1402     case 'x':
1403     case 'X':
1404       prec = 6;
1405       break;
1406
1407     case 'p':
1408     case 'P':
1409       prec = 6;
1410       break;
1411
1412     default:
1413       *sizeP = 0;
1414       return _("Bad call to MD_ATOF()");
1415     }
1416   t = atof_ieee (input_line_pointer, type, words);
1417   if (t)
1418     input_line_pointer = t;
1419
1420   *sizeP = prec * sizeof (LITTLENUM_TYPE);
1421   for (wordP = words; prec--;)
1422     {
1423       md_number_to_chars (litP, (long) (*wordP++), sizeof (LITTLENUM_TYPE));
1424       litP += sizeof (LITTLENUM_TYPE);
1425     }
1426   return 0;
1427 }
1428 \f
1429 CONST char *md_shortopts = "";
1430 struct option md_longopts[] = {
1431   {NULL, no_argument, NULL, 0}
1432 };
1433
1434 size_t md_longopts_size = sizeof (md_longopts);
1435
1436 int
1437 md_parse_option (c, arg)
1438      int c ATTRIBUTE_UNUSED;
1439      char *arg ATTRIBUTE_UNUSED;
1440 {
1441   return 0;
1442 }
1443
1444 void
1445 md_show_usage (stream)
1446      FILE *stream ATTRIBUTE_UNUSED;
1447 {
1448 }
1449 \f
1450 void
1451 tc_aout_fix_to_chars ()
1452 {
1453   printf (_("call to tc_aout_fix_to_chars \n"));
1454   abort ();
1455 }
1456
1457 void
1458 md_convert_frag (headers, seg, fragP)
1459 #ifdef BFD_ASSEMBLER
1460      bfd *headers ATTRIBUTE_UNUSED;
1461 #else
1462      object_headers *headers ATTRIBUTE_UNUSED;
1463 #endif
1464      segT seg ATTRIBUTE_UNUSED;
1465      fragS *fragP ATTRIBUTE_UNUSED;
1466 {
1467   printf (_("call to md_convert_frag \n"));
1468   abort ();
1469 }
1470
1471 #ifdef BFD_ASSEMBLER
1472 valueT
1473 md_section_align (segment, size)
1474      segT segment;
1475      valueT size;
1476 {
1477   int align = bfd_get_section_alignment (stdoutput, segment);
1478   return ((size + (1 << align) - 1) & (-1 << align));
1479 }
1480 #else
1481 valueT
1482 md_section_align (seg, size)
1483      segT seg;
1484      valueT size;
1485 {
1486   return ((size + (1 << section_alignment[(int) seg]) - 1)
1487           & (-1 << section_alignment[(int) seg]));
1488 }
1489 #endif
1490
1491
1492 #ifdef BFD_ASSEMBLER
1493 int
1494 md_apply_fix (fixP, valp)
1495      fixS *fixP;
1496      valueT *valp;
1497 #else
1498 void
1499 md_apply_fix (fixP, val)
1500      fixS *fixP;
1501      long val;
1502 #endif
1503 {
1504   char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
1505 #ifdef BFD_ASSEMBLER
1506   long val = *valp;
1507 #endif
1508
1509   switch (fixP->fx_size)
1510     {
1511     case 1:
1512       *buf++ = val;
1513       break;
1514     case 2:
1515       *buf++ = (val >> 8);
1516       *buf++ = val;
1517       break;
1518     case 4:
1519       *buf++ = (val >> 24);
1520       *buf++ = (val >> 16);
1521       *buf++ = (val >> 8);
1522       *buf++ = val;
1523       break;
1524     default:
1525       abort ();
1526     }
1527 }
1528
1529 int
1530 md_estimate_size_before_relax (fragP, segment_type)
1531      register fragS *fragP ATTRIBUTE_UNUSED;
1532      register segT segment_type ATTRIBUTE_UNUSED;
1533 {
1534   printf (_("call tomd_estimate_size_before_relax \n"));
1535   abort ();
1536 }
1537
1538 /* Put number into target byte order.  */
1539 void
1540 md_number_to_chars (ptr, use, nbytes)
1541      char *ptr;
1542      valueT use;
1543      int nbytes;
1544 {
1545   number_to_chars_bigendian (ptr, use, nbytes);
1546 }
1547
1548 long
1549 md_pcrel_from (fixP)
1550      fixS *fixP ATTRIBUTE_UNUSED;
1551 {
1552   abort ();
1553 }
1554
1555 #ifndef BFD_ASSEMBLER
1556 void
1557 tc_reloc_mangle (fix_ptr, intr, base)
1558      fixS *fix_ptr;
1559      struct internal_reloc *intr;
1560      bfd_vma base;
1561
1562 {
1563   symbolS *symbol_ptr;
1564
1565   symbol_ptr = fix_ptr->fx_addsy;
1566
1567   /* If this relocation is attached to a symbol then it's ok
1568      to output it.  */
1569   if (fix_ptr->fx_r_type == TC_CONS_RELOC)
1570     {
1571       /* cons likes to create reloc32's whatever the size of the reloc..
1572        */
1573       switch (fix_ptr->fx_size)
1574         {
1575         case 4:
1576           intr->r_type = R_RELLONG;
1577           break;
1578         case 2:
1579           intr->r_type = R_RELWORD;
1580           break;
1581         case 1:
1582           intr->r_type = R_RELBYTE;
1583           break;
1584         default:
1585           abort ();
1586         }
1587     }
1588   else
1589     {
1590       intr->r_type = fix_ptr->fx_r_type;
1591     }
1592
1593   intr->r_vaddr = fix_ptr->fx_frag->fr_address + fix_ptr->fx_where + base;
1594   intr->r_offset = fix_ptr->fx_offset;
1595
1596   if (symbol_ptr)
1597     {
1598       if (symbol_ptr->sy_number != -1)
1599         intr->r_symndx = symbol_ptr->sy_number;
1600       else
1601         {
1602           symbolS *segsym;
1603
1604           /* This case arises when a reference is made to `.'.  */
1605           segsym = seg_info (S_GET_SEGMENT (symbol_ptr))->dot;
1606           if (segsym == NULL)
1607             intr->r_symndx = -1;
1608           else
1609             {
1610               intr->r_symndx = segsym->sy_number;
1611               intr->r_offset += S_GET_VALUE (symbol_ptr);
1612             }
1613         }
1614     }
1615   else
1616     intr->r_symndx = -1;
1617 }
1618 #else /* BFD_ASSEMBLER */
1619 arelent *
1620 tc_gen_reloc (section, fixp)
1621      asection *section ATTRIBUTE_UNUSED;
1622      fixS *fixp;
1623 {
1624   arelent *rel;
1625   bfd_reloc_code_real_type r_type;
1626
1627   rel = (arelent *) xmalloc (sizeof (arelent));
1628   rel->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
1629   *rel->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
1630   rel->address = fixp->fx_frag->fr_address + fixp->fx_where;
1631   rel->addend = fixp->fx_offset;
1632
1633   r_type = fixp->fx_r_type;
1634
1635 #define DEBUG 0
1636 #if DEBUG
1637   fprintf (stderr, "%s\n", bfd_get_reloc_code_name (r_type));
1638   fflush(stderr);
1639 #endif
1640   rel->howto = bfd_reloc_type_lookup (stdoutput, r_type);
1641   if (rel->howto == NULL)
1642     {
1643       as_bad_where (fixp->fx_file, fixp->fx_line,
1644                     _("Cannot represent relocation type %s"),
1645                     bfd_get_reloc_code_name (r_type));
1646       return NULL;
1647     }
1648
1649   return rel;
1650 }
1651 #endif