gas/config/tc-h8500.c

   1 /* tc-h8500.c -- Assemble code for the Hitachi H8/500
   2    Copyright (C) 1993 Free Software Foundation.
   3
   4    This file is part of GAS, the GNU Assembler.
   5
   6    GAS is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2, or (at your option)
   9    any later version.
  10
  11    GAS is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with GAS; see the file COPYING.  If not, write to
  18    the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 /*
  21   Written By Steve Chamberlain
  22   sac@cygnus.com
  23   */
  24
  25 #include <stdio.h>
  26 #include "as.h"
  27 #include "bfd.h"
  28 #include "subsegs.h"
  29 #define DEFINE_TABLE
  30 #define ASSEMBLER_TABLE
  31 #include "../opcodes/h8500-opc.h"
  32 #include <ctype.h>
  33
  34 const char comment_chars[] = "!";
  35 const char line_separator_chars[] = ";";
  36 const char line_comment_chars[] = "!";
  37
  38 /* This table describes all the machine specific pseudo-ops the assembler
  39    has to support.  The fields are:
  40    pseudo-op name without dot
  41    function to call to execute this pseudo-op
  42    Integer arg to pass to the function
  43    */
  44
  45 void cons ();
  46
  47 const pseudo_typeS md_pseudo_table[] =
  48 {
  49   {"int", cons, 2},
  50   {"data.b", cons, 1},
  51   {"data.w", cons, 2},
  52   {"data.l", cons, 4},
  53   {"form", listing_psize, 0},
  54   {"heading", listing_title, 0},
  55   {"import", s_ignore, 0},
  56   {"page", listing_eject, 0},
  57   {"program", s_ignore, 0},
  58   {0, 0, 0}
  59 };
  60
  61 const int md_reloc_size;
  62
  63 const char EXP_CHARS[] = "eE";
  64
  65 /* Chars that mean this number is a floating point constant */
  66 /* As in 0f12.456 */
  67 /* or    0d1.2345e12 */
  68 const char FLT_CHARS[] = "rRsSfFdDxXpP";
  69
  70 #define C(a,b) ENCODE_RELAX(a,b)
  71 #define ENCODE_RELAX(what,length) (((what) << 2) + (length))
  72
  73 #define GET_WHAT(x) ((x>>2))
  74
  75 #define BYTE_DISP 1
  76 #define WORD_DISP 2
  77 #define UNDEF_BYTE_DISP 0
  78 #define UNDEF_WORD_DISP 3
  79
  80 #define BRANCH  1
  81 #define SCB_F   2
  82 #define SCB_TST 3
  83 #define END 4
  84
  85 #define BYTE_F 127
  86 #define BYTE_B -126
  87 #define WORD_F 32767
  88 #define WORD_B 32768
  89
  90 const relax_typeS md_relax_table[C (END, 0)];
  91
  92 static struct hash_control *opcode_hash_control;        /* Opcode mnemonics */
  93
  94 /*
  95   This function is called once, at assembler startup time.  This should
  96   set up all the tables, etc that the MD part of the assembler needs
  97   */
  98
  99 void
 100 md_begin ()
 101 {
 102   h8500_opcode_info *opcode;
 103   char prev_buffer[100];
 104   int idx = 0;
 105
 106   opcode_hash_control = hash_new ();
 107   prev_buffer[0] = 0;
 108
 109   /* Insert unique names into hash table */
 110   for (opcode = h8500_table; opcode->name; opcode++)
 111     {
 112       if (idx != opcode->idx)
 113         {
 114           hash_insert (opcode_hash_control, opcode->name, (char *) opcode);
 115           idx++;
 116         }
 117     }
 118
 119   /* Initialize the relax table */
 120   md_relax_table[C (BRANCH, BYTE_DISP)].rlx_forward = BYTE_F;
 121   md_relax_table[C (BRANCH, BYTE_DISP)].rlx_backward = BYTE_B;
 122   md_relax_table[C (BRANCH, BYTE_DISP)].rlx_length = 2;
 123   md_relax_table[C (BRANCH, BYTE_DISP)].rlx_more = C (BRANCH, WORD_DISP);
 124
 125   md_relax_table[C (BRANCH, WORD_DISP)].rlx_forward = WORD_F;
 126   md_relax_table[C (BRANCH, WORD_DISP)].rlx_backward = WORD_B;
 127   md_relax_table[C (BRANCH, WORD_DISP)].rlx_length = 3;
 128   md_relax_table[C (BRANCH, WORD_DISP)].rlx_more = 0;
 129
 130   md_relax_table[C (SCB_F, BYTE_DISP)].rlx_forward = BYTE_F;
 131   md_relax_table[C (SCB_F, BYTE_DISP)].rlx_backward = BYTE_B;
 132   md_relax_table[C (SCB_F, BYTE_DISP)].rlx_length = 3;
 133   md_relax_table[C (SCB_F, BYTE_DISP)].rlx_more = C (SCB_F, WORD_DISP);
 134
 135   md_relax_table[C (SCB_F, WORD_DISP)].rlx_forward = WORD_F;
 136   md_relax_table[C (SCB_F, WORD_DISP)].rlx_backward = WORD_B;
 137   md_relax_table[C (SCB_F, WORD_DISP)].rlx_length = 8;
 138   md_relax_table[C (SCB_F, WORD_DISP)].rlx_more = 0;
 139
 140   md_relax_table[C (SCB_TST, BYTE_DISP)].rlx_forward = BYTE_F;
 141   md_relax_table[C (SCB_TST, BYTE_DISP)].rlx_backward = BYTE_B;
 142   md_relax_table[C (SCB_TST, BYTE_DISP)].rlx_length = 3;
 143   md_relax_table[C (SCB_TST, BYTE_DISP)].rlx_more = C (SCB_TST, WORD_DISP);
 144
 145   md_relax_table[C (SCB_TST, WORD_DISP)].rlx_forward = WORD_F;
 146   md_relax_table[C (SCB_TST, WORD_DISP)].rlx_backward = WORD_B;
 147   md_relax_table[C (SCB_TST, WORD_DISP)].rlx_length = 10;
 148   md_relax_table[C (SCB_TST, WORD_DISP)].rlx_more = 0;
 149
 150 }
 151
 152 static int rn;                  /* register number used by RN */
 153 static int rs;                  /* register number used by RS */
 154 static int rd;                  /* register number used by RD */
 155 static int crb;                 /* byte size cr */
 156 static int crw;                 /* word sized cr */
 157 static int cr;                  /* unknown size cr */
 158
 159 static expressionS displacement;/* displacement expression */
 160 static int displacement_size;   /* and size if given */
 161
 162 static int immediate_inpage;
 163 static expressionS immediate;   /* immediate expression */
 164 static int immediate_size;      /* and size if given */
 165
 166 static expressionS absolute;    /* absolute expression */
 167 static int absolute_size;       /* and size if given */
 168
 169 typedef struct
 170 {
 171   int type;
 172   int reg;
 173   expressionS exp;
 174   int page;
 175 }
 176
 177 h8500_operand_info;
 178
 179 /* try and parse a reg name, returns number of chars consumed */
 180 static int
 181 parse_reg (src, mode, reg)
 182      char *src;
 183      int *mode;
 184      int *reg;
 185 {
 186   if (src[0] == 'r')
 187     {
 188       if (src[1] >= '0' && src[1] <= '7')
 189         {
 190           *mode = RN;
 191           *reg = (src[1] - '0');
 192           return 2;
 193         }
 194     }
 195
 196   if (src[0] == 's' && src[1] == 'p')
 197     {
 198       *mode = RN;
 199       *reg = 7;
 200       return 2;
 201     }
 202   if (src[0] == 'c' && src[1] == 'c' && src[2] == 'r')
 203     {
 204       *mode = CRB;
 205       *reg = 1;
 206       return 3;
 207     }
 208   if (src[0] == 's' && src[1] == 'r')
 209     {
 210       *mode = CRW;
 211       *reg = 0;
 212       return 2;
 213     }
 214
 215   if (src[0] == 'b' && src[1] == 'r')
 216     {
 217       *mode = CRB;
 218       *reg = 3;
 219       return 2;
 220     }
 221
 222   if (src[0] == 'e' && src[1] == 'p')
 223     {
 224       *mode = CRB;
 225       *reg = 4;
 226       return 2;
 227     }
 228
 229   if (src[0] == 'd' && src[1] == 'p')
 230     {
 231       *mode = CRB;
 232       *reg = 5;
 233       return 2;
 234     }
 235
 236   if (src[0] == 't' && src[1] == 'p')
 237     {
 238       *mode = CRB;
 239       *reg = 7;
 240       return 2;
 241     }
 242
 243   if (src[0] == 'f' && src[1] == 'p')
 244     {
 245       *mode = RN;
 246       *reg = 6;
 247       return 2;
 248     }
 249   return 0;
 250 }
 251
 252 static
 253 char *
 254 parse_exp (s, op, page)
 255      char *s;
 256      expressionS *op;
 257      int *page;
 258 {
 259   char *save;
 260   char *new;
 261   segT seg;
 262
 263   save = input_line_pointer;
 264
 265   *page = 0;
 266   if (s[0] == '%')
 267     {
 268       if (s[1] == 'p' && s[2] == 'a' && s[3] == 'g' && s[4] == 'e')
 269         {
 270           s += 5;
 271
 272           *page = 'p';
 273         }
 274       else if (s[1] == 'o' && s[2] == 'f' && s[3] == 'f')
 275         {
 276           s += 4;
 277           *page = 'o';
 278         }
 279     }
 280
 281   input_line_pointer = s;
 282
 283   seg = expr (0, op);
 284   new = input_line_pointer;
 285   input_line_pointer = save;
 286   if (SEG_NORMAL (seg))
 287     return new;
 288   switch (seg)
 289     {
 290     case SEG_ABSOLUTE:
 291     case SEG_UNKNOWN:
 292     case SEG_DIFFERENCE:
 293     case SEG_BIG:
 294     case SEG_REGISTER:
 295       return new;
 296     case SEG_ABSENT:
 297       as_bad ("Missing operand");
 298       return new;
 299     default:
 300       as_bad ("Don't understand operand of type %s", segment_name (seg));
 301       return new;
 302     }
 303 }
 304
 305 typedef enum
 306   {
 307     exp_signed, exp_unsigned, exp_sandu
 308   } sign_type;
 309
 310
 311 static char *
 312 skip_colonthing (sign, ptr, exp, def, size8, size16, size24)
 313      sign_type sign;
 314      char *ptr;
 315      h8500_operand_info *exp;
 316      int def;
 317      int size8;
 318      int size16;
 319      int size24;
 320 {
 321   ptr = parse_exp (ptr, &exp->exp, &exp->page);
 322   if (*ptr == ':')
 323     {
 324       ptr++;
 325       if (*ptr == '8')
 326         {
 327           ptr++;
 328           exp->type = size8;
 329         }
 330       else if (ptr[0] == '1' & ptr[1] == '6')
 331         {
 332           ptr += 2;
 333           exp->type = size16;
 334         }
 335       else if (ptr[0] == '2' & ptr[1] == '4')
 336         {
 337           if (!size24)
 338             {
 339               as_bad (":24 not valid for this opcode");
 340             }
 341           ptr += 2;
 342           exp->type = size24;
 343         }
 344       else
 345         {
 346           as_bad ("expect :8,:16 or :24");
 347           exp->type = size16;
 348         }
 349     }
 350   else
 351     {
 352       if (exp->page == 'p')
 353         {
 354           exp->type = IMM8;
 355         }
 356       else
 357         {
 358           /* Let's work out the size from the context */
 359           int n = exp->exp.X_add_number;
 360           if (size8
 361               && exp->exp.X_seg == SEG_ABSOLUTE
 362               && ((sign == exp_signed && (n >= -128 && n <= 127))
 363                   || (sign == exp_unsigned && (n >= 0 && (n <= 255)))
 364                   || (sign == exp_sandu && (n >= -128 && (n <= 255)))))
 365             {
 366               exp->type = size8;
 367             }
 368           else
 369             {
 370               exp->type = def;
 371             }
 372         }
 373     }
 374   return ptr;
 375 }
 376
 377 static int
 378 parse_reglist (src, op)
 379      char *src;
 380      h8500_operand_info *op;
 381 {
 382   int mode;
 383   int rn;
 384   int mask = 0;
 385   int rm;
 386   int idx = 1;                  /* skip ( */
 387
 388   while (src[idx] && src[idx] != ')')
 389     {
 390       int done = parse_reg (src + idx, &mode, &rn);
 391
 392       if (done)
 393         {
 394           idx += done;
 395           mask |= 1 << rn;
 396         }
 397       else
 398         {
 399           as_bad ("syntax error in reg list");
 400           return 0;
 401         }
 402       if (src[idx] == '-')
 403         {
 404           idx++;
 405           done = parse_reg (src + idx, &mode, &rm);
 406           if (done)
 407             {
 408               idx += done;
 409               while (rn <= rm)
 410                 {
 411                   mask |= 1 << rn;
 412                   rn++;
 413                 }
 414             }
 415           else
 416             {
 417               as_bad ("missing final register in range");
 418             }
 419         }
 420       if (src[idx] == ',')
 421         idx++;
 422     }
 423   idx++;
 424   op->exp.X_add_symbol = 0;
 425   op->exp.X_subtract_symbol = 0;
 426   op->exp.X_add_number = mask;
 427   op->exp.X_seg = SEG_ABSOLUTE;
 428   op->type = IMM8;
 429   return idx;
 430
 431 }
 432
 433 /* The many forms of operand:
 434
 435    Rn                   Register direct
 436    @Rn                  Register indirect
 437    @(disp[:size], Rn)   Register indirect with displacement
 438    @Rn+
 439    @-Rn
 440    @aa[:size]           absolute
 441    #xx[:size]           immediate data
 442
 443    */
 444
 445 static void
 446 get_operand (ptr, op, ispage)
 447      char **ptr;
 448      h8500_operand_info *op;
 449      char ispage;
 450 {
 451   char *src = *ptr;
 452   int mode;
 453   unsigned int num;
 454   unsigned int len;
 455   op->page = 0;
 456   if (src[0] == '(' && src[1] == 'r')
 457     {
 458       /* This is a register list */
 459       *ptr = src + parse_reglist (src, op);
 460       return;
 461     }
 462
 463   len = parse_reg (src, &op->type, &op->reg);
 464
 465   if (len)
 466     {
 467       *ptr = src + len;
 468       return;
 469     }
 470
 471   if (*src == '@')
 472     {
 473       src++;
 474       if (*src == '-')
 475         {
 476           src++;
 477           len = parse_reg (src, &mode, &num);
 478           if (len == 0)
 479             {
 480               /* Oops, not a reg after all, must be ordinary exp */
 481               src--;
 482               /* must be a symbol */
 483               *ptr = skip_colonthing (exp_unsigned, src,
 484                                       op, ABS16, ABS8, ABS16, ABS24);
 485               return;
 486             }
 487
 488           op->type = RNDEC;
 489           op->reg = num;
 490           *ptr = src + len;
 491           return;
 492         }
 493       if (*src == '(')
 494         {
 495           /* Disp */
 496           src++;
 497
 498           src = skip_colonthing (exp_signed, src,
 499                                  op, RNIND_D16, RNIND_D8, RNIND_D16, 0);
 500
 501           if (*src != ',')
 502             {
 503               as_bad ("expected @(exp, Rn)");
 504               return;
 505             }
 506           src++;
 507           len = parse_reg (src, &mode, &op->reg);
 508           if (len == 0 || mode != RN)
 509             {
 510               as_bad ("expected @(exp, Rn)");
 511               return;
 512             }
 513           src += len;
 514           if (*src != ')')
 515             {
 516               as_bad ("expected @(exp, Rn)");
 517               return;
 518             }
 519           *ptr = src + 1;
 520           return;
 521         }
 522       len = parse_reg (src, &mode, &num);
 523
 524       if (len)
 525         {
 526           src += len;
 527           if (*src == '+')
 528             {
 529               src++;
 530               if (mode != RN)
 531                 {
 532                   as_bad ("@Rn+ needs word register");
 533                   return;
 534                 }
 535               op->type = RNINC;
 536               op->reg = num;
 537               *ptr = src;
 538               return;
 539             }
 540           if (mode != RN)
 541             {
 542               as_bad ("@Rn needs word register");
 543               return;
 544             }
 545           op->type = RNIND;
 546           op->reg = num;
 547           *ptr = src;
 548           return;
 549         }
 550       else
 551         {
 552           /* must be a symbol */
 553           *ptr =
 554             skip_colonthing (exp_unsigned, src, op,
 555                              ispage ? ABS24 : ABS16, ABS8, ABS16, ABS24);
 556           return;
 557         }
 558     }
 559
 560   if (*src == '#')
 561     {
 562       src++;
 563       *ptr = skip_colonthing (exp_sandu, src, op, IMM16, IMM8, IMM16, ABS24);
 564       return;
 565     }
 566   else
 567     {
 568       *ptr = skip_colonthing (exp_signed, src, op,
 569                               ispage ? ABS24 : PCREL8, PCREL8, PCREL16, ABS24);
 570     }
 571 }
 572
 573 static
 574 char *
 575 get_operands (info, args, operand)
 576      h8500_opcode_info *info;
 577      char *args;
 578      h8500_operand_info *operand;
 579
 580 {
 581   char *ptr = args;
 582
 583   switch (info->nargs)
 584     {
 585     case 0:
 586       operand[0].type = 0;
 587       operand[1].type = 0;
 588       break;
 589
 590     case 1:
 591       ptr++;
 592       get_operand (&ptr, operand + 0, info->name[0] == 'p');
 593       operand[1].type = 0;
 594       break;
 595
 596     case 2:
 597       ptr++;
 598       get_operand (&ptr, operand + 0, 0);
 599       if (*ptr == ',')
 600         ptr++;
 601       get_operand (&ptr, operand + 1, 0);
 602       break;
 603
 604     default:
 605       abort ();
 606     }
 607
 608   return ptr;
 609 }
 610
 611 /* Passed a pointer to a list of opcodes which use different
 612    addressing modes, return the opcode which matches the opcodes
 613    provided
 614    */
 615
 616 int pcrel8;                     /* Set when we've seen a pcrel operand */
 617
 618 static
 619 h8500_opcode_info *
 620 get_specific (opcode, operands)
 621      h8500_opcode_info *opcode;
 622      h8500_operand_info *operands;
 623 {
 624   h8500_opcode_info *this_try = opcode;
 625   int found = 0;
 626   unsigned int noperands = opcode->nargs;
 627
 628   unsigned int this_index = opcode->idx;
 629
 630   while (this_index == opcode->idx && !found)
 631     {
 632       unsigned int i;
 633
 634       this_try = opcode++;
 635
 636       /* look at both operands needed by the opcodes and provided by
 637        the user*/
 638       for (i = 0; i < noperands; i++)
 639         {
 640           h8500_operand_info *user = operands + i;
 641
 642           switch (this_try->arg_type[i])
 643             {
 644             case FPIND_D8:
 645               /* Opcode needs (disp:8,fp) */
 646               if (user->type == RNIND_D8 && user->reg == 6)
 647                 {
 648                   displacement = user->exp;
 649                   continue;
 650                 }
 651               break;
 652             case RDIND_D16:
 653               if (user->type == RNIND_D16)
 654                 {
 655                   displacement = user->exp;
 656                   rd = user->reg;
 657                   continue;
 658                 }
 659               break;
 660             case RDIND_D8:
 661               if (user->type == RNIND_D8)
 662                 {
 663                   displacement = user->exp;
 664                   rd = user->reg;
 665                   continue;
 666                 }
 667               break;
 668             case RNIND_D16:
 669             case RNIND_D8:
 670               if (user->type == this_try->arg_type[i])
 671                 {
 672                   displacement = user->exp;
 673                   rn = user->reg;
 674                   continue;
 675                 }
 676               break;
 677
 678             case SPDEC:
 679               if (user->type == RNDEC && user->reg == 7)
 680                 {
 681                   continue;
 682                 }
 683               break;
 684             case SPINC:
 685               if (user->type == RNINC && user->reg == 7)
 686                 {
 687                   continue;
 688                 }
 689               break;
 690             case ABS16:
 691               if (user->type == ABS16)
 692                 {
 693                   absolute = user->exp;
 694                   continue;
 695                 }
 696               break;
 697             case ABS8:
 698               if (user->type == ABS8)
 699                 {
 700                   absolute = user->exp;
 701                   continue;
 702                 }
 703               break;
 704             case ABS24:
 705               if (user->type == ABS24)
 706                 {
 707                   absolute = user->exp;
 708                   continue;
 709                 }
 710               break;
 711
 712             case CRB:
 713               if ((user->type == CRB || user->type == CR) && user->reg != 0)
 714                 {
 715                   crb = user->reg;
 716                   continue;
 717                 }
 718               break;
 719             case CRW:
 720               if ((user->type == CRW || user->type == CR) && user->reg == 0)
 721                 {
 722                   crw = user->reg;
 723                   continue;
 724                 }
 725               break;
 726             case DISP16:
 727               if (user->type == DISP16)
 728                 {
 729                   displacement = user->exp;
 730                   continue;
 731                 }
 732               break;
 733             case DISP8:
 734               if (user->type == DISP8)
 735                 {
 736                   displacement = user->exp;
 737                   continue;
 738                 }
 739               break;
 740             case FP:
 741               if (user->type == RN && user->reg == 6)
 742                 {
 743                   continue;
 744                 }
 745               break;
 746             case PCREL16:
 747               if (user->type == PCREL16)
 748                 {
 749                   displacement = user->exp;
 750                   continue;
 751                 }
 752               break;
 753             case PCREL8:
 754               if (user->type == PCREL8)
 755                 {
 756                   displacement = user->exp;
 757                   pcrel8 = 1;
 758                   continue;
 759                 }
 760               break;
 761
 762             case IMM16:
 763               if (user->type == IMM16
 764                   || user->type == IMM8)
 765                 {
 766                   immediate_inpage = user->page;
 767                   immediate = user->exp;
 768                   continue;
 769                 }
 770               break;
 771             case RLIST:
 772             case IMM8:
 773               if (user->type == IMM8)
 774                 {
 775                   immediate_inpage = user->page;
 776                   immediate = user->exp;
 777                   continue;
 778                 }
 779               break;
 780             case IMM4:
 781               if (user->type == IMM8)
 782                 {
 783                   immediate_inpage = user->page;
 784                   immediate = user->exp;
 785                   continue;
 786                 }
 787               break;
 788             case QIM:
 789               if (user->type == IMM8
 790                   && user->exp.X_seg == SEG_ABSOLUTE
 791                   &&
 792                   (user->exp.X_add_number == -2
 793                    || user->exp.X_add_number == -1
 794                    || user->exp.X_add_number == 1
 795                    || user->exp.X_add_number == 2))
 796                 {
 797                   immediate_inpage = user->page;
 798                   immediate = user->exp;
 799                   continue;
 800                 }
 801               break;
 802             case RD:
 803               if (user->type == RN)
 804                 {
 805                   rd = user->reg;
 806                   continue;
 807                 }
 808               break;
 809             case RS:
 810               if (user->type == RN)
 811                 {
 812                   rs = user->reg;
 813                   continue;
 814                 }
 815               break;
 816             case RDIND:
 817               if (user->type == RNIND)
 818                 {
 819                   rd = user->reg;
 820                   continue;
 821
 822                 }
 823               break;
 824             case RNINC:
 825             case RNIND:
 826             case RNDEC:
 827             case RN:
 828
 829               if (user->type == this_try->arg_type[i])
 830                 {
 831                   rn = user->reg;
 832                   continue;
 833                 }
 834               break;
 835             case SP:
 836               if (user->type == RN && user->reg == 7)
 837                 {
 838                   continue;
 839                 }
 840               break;
 841             default:
 842               printf ("unhandled %d\n", this_try->arg_type[i]);
 843               break;
 844             }
 845
 846           /* If we get here this didn't work out */
 847           goto fail;
 848         }
 849       found = 1;
 850     fail:;
 851
 852     }
 853
 854   if (found)
 855     return this_try;
 856   else
 857     return 0;
 858 }
 859
 860 int
 861 check (operand, low, high)
 862      expressionS *operand;
 863      int low;
 864      int high;
 865 {
 866   if (operand->X_seg != SEG_ABSOLUTE
 867       || operand->X_add_number < low
 868       || operand->X_add_number > high)
 869     {
 870       as_bad ("operand must be absolute in range %d..%d", low, high);
 871     }
 872   return operand->X_add_number;
 873 }
 874
 875 static
 876 void
 877 insert (output, index, exp, reloc, pcrel)
 878      char *output;
 879      int index;
 880      expressionS *exp;
 881      int reloc;
 882      int pcrel;
 883 {
 884   fix_new (frag_now,
 885            output - frag_now->fr_literal + index,
 886            4,                   /* always say size is 4, but we know better */
 887            exp->X_add_symbol,
 888            exp->X_subtract_symbol,
 889            exp->X_add_number,
 890            pcrel,
 891            reloc);
 892 }
 893
 894 void
 895 build_relaxable_instruction (opcode, operand)
 896      h8500_opcode_info *opcode;
 897      h8500_operand_info *operand;
 898 {
 899   /* All relaxable instructions start life as two bytes but can become
 900      three bytes long if a lonely branch and up to 9 bytes if long scb
 901      */
 902   char *p;
 903   int len;
 904   int type;
 905
 906   if (opcode->bytes[0].contents == 0x01)
 907     {
 908       type = SCB_F;
 909     }
 910   else if (opcode->bytes[0].contents == 0x06
 911            || opcode->bytes[0].contents == 0x07)
 912     {
 913       type = SCB_TST;
 914     }
 915   else
 916     {
 917       type = BRANCH;
 918     }
 919
 920   p = frag_var (rs_machine_dependent,
 921                 md_relax_table[C (type, WORD_DISP)].rlx_length,
 922                 len = md_relax_table[C (type, BYTE_DISP)].rlx_length,
 923                 C (type, UNDEF_BYTE_DISP),
 924                 displacement.X_add_symbol,
 925                 displacement.X_add_number,
 926                 0);
 927
 928   p[0] = opcode->bytes[0].contents;
 929   if (type != BRANCH)
 930     {
 931       p[1] = opcode->bytes[1].contents | rs;
 932     }
 933 }
 934
 935 /* Now we know what sort of opcodes it is, lets build the bytes -
 936  */
 937 static void
 938 build_bytes (opcode, operand)
 939      h8500_opcode_info *opcode;
 940      h8500_operand_info *operand;
 941
 942 {
 943   int index;
 944
 945   if (pcrel8)
 946     {
 947       pcrel8 = 0;
 948       build_relaxable_instruction (opcode, operand);
 949     }
 950   else
 951     {
 952       char *output = frag_more (opcode->length);
 953
 954       memset (output, 0, opcode->length);
 955       for (index = 0; index < opcode->length; index++)
 956         {
 957           output[index] = opcode->bytes[index].contents;
 958
 959           switch (opcode->bytes[index].insert)
 960             {
 961             default:
 962               printf ("failed for %d\n", opcode->bytes[index].insert);
 963               break;
 964             case 0:
 965               break;
 966             case RN:
 967               output[index] |= rn;
 968               break;
 969             case RD:
 970             case RDIND:
 971
 972               output[index] |= rd;
 973               break;
 974             case RS:
 975               output[index] |= rs;
 976               break;
 977             case DISP16:
 978               insert (output, index, &displacement, R_H8500_IMM16, 0);
 979               index++;
 980               break;
 981             case DISP8:
 982             case FPIND_D8:
 983               insert (output, index, &displacement, R_H8500_IMM8, 0);
 984               break;
 985             case IMM16:
 986               insert (output, index, &immediate, immediate_inpage ?
 987                       R_H8500_LOW16 : R_H8500_IMM16, 0);
 988               index++;
 989               break;
 990             case RLIST:
 991             case IMM8:
 992               if (immediate_inpage)
 993                 {
 994                   insert (output, index, &immediate, R_H8500_HIGH8, 0);
 995                 }
 996               else
 997                 {
 998                   insert (output, index, &immediate, R_H8500_IMM8, 0);
 999                 }
1000               break;
1001             case PCREL16:
1002               insert (output, index, &displacement, R_H8500_PCREL16, 1);
1003               index++;
1004               break;
1005             case PCREL8:
1006               insert (output, index, &displacement, R_H8500_PCREL8, 1);
1007               break;
1008             case IMM4:
1009               output[index] |= check (&immediate, 0, 15);
1010               break;
1011             case CR:
1012
1013               output[index] |= cr;
1014               if (cr == 0)
1015                 {
1016                   output[0] |= 0x8;
1017                 }
1018               else
1019                 {
1020                   output[0] &= ~0x8;
1021                 }
1022
1023               break;
1024
1025             case CRB:
1026               output[index] |= crb;
1027               output[0] &= ~0x8;
1028               break;
1029             case CRW:
1030               output[index] |= crw;
1031               output[0] |= 0x8;
1032               break;
1033             case ABS24:
1034               insert (output, index, &absolute, R_H8500_IMM24, 0);
1035               index += 2;
1036               break;
1037             case ABS16:
1038               insert (output, index, &absolute, R_H8500_IMM16, 0);
1039               index++;
1040               break;
1041             case ABS8:
1042               insert (output, index, &absolute, R_H8500_IMM8, 0);
1043               break;
1044             case QIM:
1045               switch (immediate.X_add_number)
1046                 {
1047                 case -2:
1048                   output[index] |= 0x5;
1049                   break;
1050                 case -1:
1051                   output[index] |= 0x4;
1052                   break;
1053                 case 1:
1054                   output[index] |= 0;
1055                   break;
1056                 case 2:
1057                   output[index] |= 1;
1058                   break;
1059                 }
1060               break;
1061             }
1062         }
1063     }
1064 }
1065
1066 /* This is the guts of the machine-dependent assembler.  STR points to a
1067    machine dependent instruction.  This funciton is supposed to emit
1068    the frags/bytes it assembles to.
1069    */
1070
1071 void
1072 DEFUN (md_assemble, (str),
1073        char *str)
1074 {
1075   char *op_start;
1076   char *op_end;
1077   h8500_operand_info operand[2];
1078   h8500_opcode_info *opcode;
1079   h8500_opcode_info *prev_opcode;
1080   char name[11];
1081
1082   int nlen = 0;
1083
1084   /* Drop leading whitespace */
1085   while (*str == ' ')
1086     str++;
1087
1088   /* find the op code end */
1089   for (op_start = op_end = str;
1090        *op_end &&
1091        !is_end_of_line[*op_end] && *op_end != ' ';
1092        op_end++)
1093     {
1094       if (                      /**op_end != '.'
1095           && *op_end != ':'
1096                                   && */ nlen < 10)
1097         {
1098           name[nlen++] = *op_end;
1099         }
1100     }
1101   name[nlen] = 0;
1102
1103   if (op_end == op_start)
1104     {
1105       as_bad ("can't find opcode ");
1106     }
1107
1108   opcode = (h8500_opcode_info *) hash_find (opcode_hash_control, name);
1109
1110   if (opcode == NULL)
1111     {
1112       as_bad ("unknown opcode");
1113       return;
1114     }
1115
1116   input_line_pointer = get_operands (opcode, op_end, operand);
1117   prev_opcode = opcode;
1118
1119   opcode = get_specific (opcode, operand);
1120
1121   if (opcode == 0)
1122     {
1123       /* Couldn't find an opcode which matched the operands */
1124       char *where = frag_more (2);
1125
1126       where[0] = 0x0;
1127       where[1] = 0x0;
1128       as_bad ("invalid operands for opcode");
1129       return;
1130     }
1131
1132   build_bytes (opcode, operand);
1133
1134 }
1135
1136 void
1137 DEFUN (tc_crawl_symbol_chain, (headers),
1138        object_headers * headers)
1139 {
1140   printf ("call to tc_crawl_symbol_chain \n");
1141 }
1142
1143 symbolS *
1144 DEFUN (md_undefined_symbol, (name),
1145        char *name)
1146 {
1147   return 0;
1148 }
1149
1150 void
1151 DEFUN (tc_headers_hook, (headers),
1152        object_headers * headers)
1153 {
1154   printf ("call to tc_headers_hook \n");
1155 }
1156
1157 void
1158 DEFUN_VOID (md_end)
1159 {
1160 }
1161
1162 /* Various routines to kill one day */
1163 /* Equal to MAX_PRECISION in atof-ieee.c */
1164 #define MAX_LITTLENUMS 6
1165
1166 /* Turn a string in input_line_pointer into a floating point constant of type
1167    type, and store the appropriate bytes in *litP.  The number of LITTLENUMS
1168    emitted is stored in *sizeP .  An error message is returned, or NULL on OK.
1169    */
1170 char *
1171 md_atof (type, litP, sizeP)
1172      char type;
1173      char *litP;
1174      int *sizeP;
1175 {
1176   int prec;
1177   LITTLENUM_TYPE words[MAX_LITTLENUMS];
1178   LITTLENUM_TYPE *wordP;
1179   char *t;
1180   char *atof_ieee ();
1181
1182   switch (type)
1183     {
1184     case 'f':
1185     case 'F':
1186     case 's':
1187     case 'S':
1188       prec = 2;
1189       break;
1190
1191     case 'd':
1192     case 'D':
1193     case 'r':
1194     case 'R':
1195       prec = 4;
1196       break;
1197
1198     case 'x':
1199     case 'X':
1200       prec = 6;
1201       break;
1202
1203     case 'p':
1204     case 'P':
1205       prec = 6;
1206       break;
1207
1208     default:
1209       *sizeP = 0;
1210       return "Bad call to MD_ATOF()";
1211     }
1212   t = atof_ieee (input_line_pointer, type, words);
1213   if (t)
1214     input_line_pointer = t;
1215
1216   *sizeP = prec * sizeof (LITTLENUM_TYPE);
1217   for (wordP = words; prec--;)
1218     {
1219       md_number_to_chars (litP, (long) (*wordP++), sizeof (LITTLENUM_TYPE));
1220       litP += sizeof (LITTLENUM_TYPE);
1221     }
1222   return "";                    /* Someone should teach Dean about null pointers */
1223 }
1224
1225 int
1226 md_parse_option (argP, cntP, vecP)
1227      char **argP;
1228      int *cntP;
1229      char ***vecP;
1230
1231 {
1232   return 0;
1233 }
1234
1235 int md_short_jump_size;
1236
1237 void
1238 tc_aout_fix_to_chars ()
1239 {
1240   printf ("call to tc_aout_fix_to_chars \n");
1241   abort ();
1242 }
1243
1244 void
1245 md_create_short_jump (ptr, from_addr, to_addr, frag, to_symbol)
1246      char *ptr;
1247      long from_addr;
1248      long to_addr;
1249      fragS *frag;
1250      symbolS *to_symbol;
1251 {
1252   as_fatal ("failed sanity check.");
1253 }
1254
1255 void
1256 md_create_long_jump (ptr, from_addr, to_addr, frag, to_symbol)
1257      char *ptr;
1258      long from_addr, to_addr;
1259      fragS *frag;
1260      symbolS *to_symbol;
1261 {
1262   as_fatal ("failed sanity check.");
1263 }
1264
1265 static
1266 void
1267 wordify_scb (buffer, disp_size, inst_size)
1268      char *buffer;
1269      int *disp_size;
1270      int *inst_size;
1271 {
1272   int rn = buffer[1] & 0x7;
1273
1274   switch (buffer[0])
1275     {
1276     case 0x0e:                  /* BSR */
1277     case 0x20:
1278     case 0x21:
1279     case 0x22:
1280     case 0x23:
1281     case 0x24:
1282     case 0x25:
1283     case 0x26:
1284     case 0x27:
1285     case 0x28:
1286     case 0x29:
1287     case 0x2a:
1288     case 0x2b:
1289     case 0x2c:
1290     case 0x2d:
1291     case 0x2e:
1292     case 0x2f:
1293       buffer[0] |= 0x10;
1294       buffer[1] = 0;
1295       buffer[2] = 0;
1296       *disp_size = 2;
1297       *inst_size = 1;
1298       return;
1299     default:
1300       abort ();
1301
1302     case 0x01:
1303       *inst_size = 6;
1304       *disp_size = 2;
1305       break;
1306     case 0x06:
1307       *inst_size = 8;
1308       *disp_size = 2;
1309
1310       *buffer++ = 0x26;         /* bne + 8 */
1311       *buffer++ = 0x08;
1312       break;
1313     case 0x07:
1314       *inst_size = 8;
1315       *disp_size = 2;
1316       *buffer++ = 0x27;         /* bne + 8 */
1317       *buffer++ = 0x08;
1318       break;
1319
1320     }
1321   *buffer++ = 0xa8 | rn;        /* addq -1,rn */
1322   *buffer++ = 0x0c;
1323   *buffer++ = 0x04;             /* cmp #0xff:8, rn */
1324   *buffer++ = 0xff;
1325   *buffer++ = 0x70 | rn;
1326   *buffer++ = 0x36;             /* bne ... */
1327   *buffer++ = 0;
1328   *buffer++ = 0;
1329 }
1330
1331 /*
1332 called after relaxing, change the frags so they know how big they are
1333 */
1334 void
1335 md_convert_frag (headers, fragP)
1336      object_headers *headers;
1337      fragS *fragP;
1338
1339 {
1340   int disp_size = 0;
1341   int inst_size = 0;
1342   char *buffer = fragP->fr_fix + fragP->fr_literal;
1343
1344   switch (fragP->fr_subtype)
1345     {
1346     case C (BRANCH, BYTE_DISP):
1347       disp_size = 1;
1348       inst_size = 1;
1349       break;
1350
1351     case C (SCB_F, BYTE_DISP):
1352     case C (SCB_TST, BYTE_DISP):
1353       disp_size = 1;
1354       inst_size = 2;
1355       break;
1356
1357       /* Branches to a known 16 bit displacement */
1358
1359       /* Turn on the 16bit bit */
1360     case C (BRANCH, WORD_DISP):
1361     case C (SCB_F, WORD_DISP):
1362     case C (SCB_TST, WORD_DISP):
1363       wordify_scb (buffer, &disp_size, &inst_size);
1364       break;
1365
1366     case C (BRANCH, UNDEF_WORD_DISP):
1367     case C (SCB_F, UNDEF_WORD_DISP):
1368     case C (SCB_TST, UNDEF_WORD_DISP):
1369       /* This tried to be relaxed, but didn't manage it, it now needs a
1370        fix */
1371       wordify_scb (buffer, &disp_size, &inst_size);
1372
1373       /* Make a reloc */
1374       fix_new (fragP,
1375                fragP->fr_fix + inst_size,
1376                4,
1377                fragP->fr_symbol,
1378                0,
1379                fragP->fr_offset,
1380                0,
1381                R_H8500_PCREL16);
1382
1383       fragP->fr_fix += disp_size + inst_size;
1384       fragP->fr_var = 0;
1385       return;
1386       break;
1387     default:
1388       abort ();
1389     }
1390   if (inst_size)
1391     {
1392       /* Get the address of the end of the instruction */
1393       int next_inst = fragP->fr_fix + fragP->fr_address + disp_size + inst_size;
1394       int targ_addr = (S_GET_VALUE (fragP->fr_symbol) +
1395                        fragP->fr_offset);
1396       int disp = targ_addr - next_inst;
1397
1398       md_number_to_chars (buffer + inst_size, disp, disp_size);
1399       fragP->fr_fix += disp_size + inst_size;
1400       fragP->fr_var = 0;
1401     }
1402
1403 }
1404
1405 long
1406 DEFUN (md_section_align, (seg, size),
1407        segT seg AND
1408        long size)
1409 {
1410   return ((size + (1 << section_alignment[(int) seg]) - 1)
1411           & (-1 << section_alignment[(int) seg]));
1412
1413 }
1414
1415 void
1416 md_apply_fix (fixP, val)
1417      fixS *fixP;
1418      long val;
1419 {
1420   char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
1421
1422   if (fixP->fx_r_type == 0)
1423     {
1424       fixP->fx_r_type = fixP->fx_size == 4 ? R_H8500_IMM32 : R_H8500_IMM16;
1425     }
1426
1427   switch (fixP->fx_r_type)
1428     {
1429
1430     case R_H8500_IMM8:
1431     case R_H8500_PCREL8:
1432       *buf++ = val;
1433       break;
1434     case R_H8500_IMM16:
1435     case R_H8500_LOW16:
1436     case R_H8500_PCREL16:
1437       *buf++ = (val >> 8);
1438       *buf++ = val;
1439       break;
1440     case R_H8500_HIGH8:
1441       *buf++ = val >> 16;
1442       break;
1443     case R_H8500_IMM24:
1444       *buf++ = (val >> 16);
1445       *buf++ = (val >> 8);
1446       *buf++ = val;
1447       break;
1448     case R_H8500_IMM32:
1449       *buf++ = (val >> 24);
1450       *buf++ = (val >> 16);
1451       *buf++ = (val >> 8);
1452       *buf++ = val;
1453       break;
1454     default:
1455       abort ();
1456
1457     }
1458 }
1459
1460 void
1461 DEFUN (md_operand, (expressionP), expressionS * expressionP)
1462 {
1463 }
1464
1465 int md_long_jump_size;
1466
1467 /*
1468 called just before address relaxation, return the length
1469 by which a fragment must grow to reach it's destination
1470 */
1471 int
1472 md_estimate_size_before_relax (fragP, segment_type)
1473      register fragS *fragP;
1474      register segT segment_type;
1475 {
1476   int what = GET_WHAT (fragP->fr_subtype);
1477
1478   switch (fragP->fr_subtype)
1479     {
1480     default:
1481       abort ();
1482     case C (BRANCH, UNDEF_BYTE_DISP):
1483     case C (SCB_F, UNDEF_BYTE_DISP):
1484     case C (SCB_TST, UNDEF_BYTE_DISP):
1485       /* used to be a branch to somewhere which was unknown */
1486       if (S_GET_SEGMENT (fragP->fr_symbol) == segment_type)
1487         {
1488           /* Got a symbol and it's defined in this segment, become byte
1489          sized - maybe it will fix up */
1490           fragP->fr_subtype = C (what, BYTE_DISP);
1491           fragP->fr_var = md_relax_table[C (what, BYTE_DISP)].rlx_length;
1492         }
1493       else
1494         {
1495           /* Its got a segment, but its not ours, so it will always be long */
1496           fragP->fr_subtype = C (what, UNDEF_WORD_DISP);
1497           fragP->fr_var = md_relax_table[C (what, WORD_DISP)].rlx_length;
1498           return md_relax_table[C (what, WORD_DISP)].rlx_length;
1499         }
1500     }
1501   return fragP->fr_var;
1502 }
1503
1504 /* Put number into target byte order */
1505
1506 void
1507 md_number_to_chars (ptr, use, nbytes)
1508      char *ptr;
1509      long use;
1510      int nbytes;
1511 {
1512   switch (nbytes)
1513     {
1514     case 4:
1515       *ptr++ = (use >> 24) & 0xff;
1516     case 3:
1517       *ptr++ = (use >> 16) & 0xff;
1518     case 2:
1519       *ptr++ = (use >> 8) & 0xff;
1520     case 1:
1521       *ptr++ = (use >> 0) & 0xff;
1522       break;
1523     default:
1524       abort ();
1525     }
1526 }
1527 long
1528 md_pcrel_from (fixP)
1529      fixS *fixP;
1530
1531 {
1532   return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address;
1533 }
1534
1535 void
1536 tc_coff_symbol_emit_hook ()
1537 {
1538 }
1539
1540 short
1541 tc_coff_fix2rtype (fix_ptr)
1542      fixS *fix_ptr;
1543 {
1544   if (fix_ptr->fx_r_type == RELOC_32)
1545     {
1546       /* cons likes to create reloc32's whatever the size of the reloc..
1547      */
1548       switch (fix_ptr->fx_size)
1549         {
1550         case 2:
1551           return R_H8500_IMM16;
1552           break;
1553         case 1:
1554           return R_H8500_IMM8;
1555           break;
1556         default:
1557           abort ();
1558         }
1559     }
1560   return fix_ptr->fx_r_type;
1561 }
1562
1563 void
1564 tc_reloc_mangle (fix_ptr, intr, base)
1565      fixS *fix_ptr;
1566      struct internal_reloc *intr;
1567      bfd_vma base;
1568
1569 {
1570   symbolS *symbol_ptr;
1571
1572   symbol_ptr = fix_ptr->fx_addsy;
1573
1574   /* If this relocation is attached to a symbol then it's ok
1575      to output it */
1576   if (fix_ptr->fx_r_type == RELOC_32)
1577     {
1578       /* cons likes to create reloc32's whatever the size of the reloc..
1579        */
1580       switch (fix_ptr->fx_size)
1581         {
1582         case 2:
1583           intr->r_type = R_IMM16;
1584           break;
1585         case 1:
1586           intr->r_type = R_IMM8;
1587           break;
1588         default:
1589           abort ();
1590         }
1591     }
1592   else
1593     {
1594       intr->r_type = fix_ptr->fx_r_type;
1595     }
1596
1597   intr->r_vaddr = fix_ptr->fx_frag->fr_address + fix_ptr->fx_where + base;
1598   intr->r_offset = fix_ptr->fx_offset;
1599
1600   /* Turn the segment of the symbol into an offset.  */
1601   if (symbol_ptr)
1602     {
1603       symbolS *dot;
1604
1605       dot = segment_info[S_GET_SEGMENT (symbol_ptr)].dot;
1606       if (dot)
1607         {
1608           /*      intr->r_offset -=
1609             segment_info[S_GET_SEGMENT(symbol_ptr)].scnhdr.s_paddr;*/
1610           intr->r_offset += S_GET_VALUE (symbol_ptr);
1611           intr->r_symndx = dot->sy_number;
1612         }
1613       else
1614         {
1615           intr->r_symndx = symbol_ptr->sy_number;
1616         }
1617
1618     }
1619   else
1620     {
1621       intr->r_symndx = -1;
1622     }
1623
1624 }
1625
1626
1627
1628 int
1629 start_label (ptr)
1630      char *ptr;
1631 {
1632   /* Check for :s.w */
1633   if (isalpha (ptr[1]) && ptr[2] == '.')
1634     return 0;
1635   /* Check for :s */
1636   if (isalpha (ptr[1]) && !isalpha (ptr[2]))
1637     return 0;
1638   return 1;
1639 }
1640
1641 /* end of tc-h8500.c */