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