projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
force all files to end in "/* end of filename"
[deliverable/binutils-gdb.git] / gas / config / tc-h8300.c
1 /* tc-h8300.c -- Assemble code for the Hitachi H8/300
2 Copyright (C) 1991 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 /*
22 Written By Steve Chamberlain
23 sac@cygnus.com
24 */
25
26 #include <stdio.h>
27 #include "as.h"
28 #include "bfd.h"
29 #include "opcode/h8300.h"
30 #include <ctype.h>
31 #include "listing.h"
32
33 char comment_chars[] = { ';',0 };
34 char line_separator_chars[] = { '$' ,0};
35
36 /* This table describes all the machine specific pseudo-ops the assembler
37 has to support. The fields are:
38 pseudo-op name without dot
39 function to call to execute this pseudo-op
40 Integer arg to pass to the function
41 */
42
43 void cons();
44
45 const pseudo_typeS md_pseudo_table[] = {
46 { "int", cons, 2 },
47 { 0,0,0 }
48 };
49
50 int md_reloc_size ;
51
52 const char EXP_CHARS[] = "eE";
53
54 /* Chars that mean this number is a floating point constant */
55 /* As in 0f12.456 */
56 /* or 0d1.2345e12 */
57 char FLT_CHARS[] = "rRsSfFdDxXpP";
58
59
60 const relax_typeS md_relax_table[1];
61
62
63 static struct hash_control *opcode_hash_control; /* Opcode mnemonics */
64
65
66 /*
67 This function is called once, at assembler startup time. This should
68 set up all the tables, etc that the MD part of the assembler needs
69 */
70 #if 0
71 /* encode the size and number into the number field
72 xxnnnn
73 00 8 bit
74 01 16 bit
75 10 ccr
76 nnnnreg number
77 */
78 #define WORD_REG 0x10
79 #define BYTE_REG 0x00
80 #define CCR_REG 0x20
81 struct reg_entry
82 {
83 char *name;
84 char number;
85 };
86
87 struct reg_entry reg_list[] = {
88 "r0",WORD_REG +0,
89 "r1",WORD_REG +1,
90 "r2",WORD_REG +2,
91 "r3",WORD_REG +3,
92 "r4",WORD_REG +4,
93 "r5",WORD_REG +5,
94 "r6",WORD_REG +6,
95 "r7",WORD_REG +7,
96 "fp",WORD_REG +6,
97 "sp",WORD_REG +7,
98 "r0h",BYTE_REG + 0,
99 "r0l",BYTE_REG + 1,
100 "r1h",BYTE_REG + 2,
101 "r1l",BYTE_REG + 3,
102 "r2h",BYTE_REG + 4,
103 "r2l",BYTE_REG + 5,
104 "r3h",BYTE_REG + 6,
105 "r3l",BYTE_REG + 7,
106 "r4h",BYTE_REG + 8,
107 "r4l",BYTE_REG + 9,
108 "r5h",BYTE_REG + 10,
109 "r5l",BYTE_REG + 11,
110 "r6h",BYTE_REG + 12,
111 "r6l",BYTE_REG + 13,
112 "r7h",BYTE_REG + 14,
113 "r7l",BYTE_REG + 15,
114 "ccr",CCR_REG,
115 0,0
116 }
117 ;
118
119
120 #endif
121
122
123 void md_begin ()
124 {
125 struct h8_opcode *opcode;
126 const struct reg_entry *reg;
127 char prev_buffer[100];
128 int idx = 0;
129
130 opcode_hash_control = hash_new();
131 prev_buffer[0] = 0;
132
133 for (opcode = h8_opcodes; opcode->name; opcode++)
134 {
135 /* Strip off any . part when inserting the opcode and only enter
136 unique codes into the hash table
137 */
138 char *src= opcode->name;
139 unsigned int len = strlen(src);
140 char *dst = malloc(len+1);
141 char *buffer = dst;
142 opcode->size = 0;
143 while (*src) {
144 if (*src == '.') {
145 *dst++ = 0;
146 src++;
147 opcode->size = *src;
148 break;
149 }
150 *dst++ = *src++;
151 }
152 if (strcmp(buffer, prev_buffer))
153 {
154 hash_insert(opcode_hash_control, buffer, (char *)opcode);
155 strcpy(prev_buffer, buffer);
156 idx++;
157 }
158 opcode->idx = idx;
159
160
161 /* Find the number of operands */
162 opcode->noperands = 0;
163 while (opcode->args.nib[opcode->noperands] != E)
164 opcode->noperands ++;
165 /* Find the length of the opcode in bytes */
166 opcode->length =0;
167 while (opcode->data.nib[opcode->length*2] != E)
168 opcode->length++;
169 }
170
171 }
172
173
174 struct h8_exp {
175 char *e_beg;
176 char *e_end;
177 expressionS e_exp;
178 };
179 struct h8_op
180 {
181 unsigned int dispreg;
182 op_type mode;
183 unsigned reg;
184 expressionS exp;
185 };
186
187
188
189 /*
190 parse operands
191 WREG r0,r1,r2,r3,r4,r5,r6,r7,fp,sp
192 r0l,r0h,..r7l,r7h
193 @WREG
194 @WREG+
195 @-WREG
196 #const
197
198 */
199
200 op_type r8_sord[] = {RS8, RD8};
201 op_type r16_sord[] = {RS16, RD16};
202 op_type rind_sord[] = {RSIND, RDIND};
203 op_type abs_sord[2] = {ABS16SRC, ABS16DST};
204 op_type disp_sord[] = {DISPSRC, DISPDST};
205
206 /* try and parse a reg name, returns number of chars consumed */
207 int
208 DEFUN(parse_reg,(src, mode, reg, dst),
209 char *src AND
210 op_type *mode AND
211 unsigned int *reg AND
212 int dst)
213 {
214 if (src[0] == 's' && src[1] == 'p')
215 {
216 *mode = r16_sord[dst];
217 *reg = 7;
218 return 2;
219 }
220 if (src[0] == 'c' && src[1] == 'c' && src[2] == 'r')
221 {
222 *mode = CCR;
223 *reg = 0;
224 return 3;
225 }
226 if (src[0] == 'f' && src[1] == 'p')
227 {
228 *mode = r16_sord[dst];
229 *reg = 6;
230 return 2;
231 }
232 if (src[0] == 'r')
233 {
234 if (src[1] >= '0' && src[1] <= '7')
235 {
236 if(src[2] == 'l')
237 {
238 *mode = r8_sord[dst];
239 *reg = (src[1] - '0') + 8;
240 return 3;
241 }
242 if(src[2] == 'h')
243 {
244 *mode = r8_sord[dst];
245 *reg = (src[1] - '0') ;
246 return 3;
247 }
248 *mode = r16_sord[dst];
249 *reg = (src[1] - '0');
250 return 2;
251 }
252 }
253 return 0;
254 }
255
256 char *
257 DEFUN(parse_exp,(s, op),
258 char *s AND
259 expressionS *op)
260 {
261 char *save = input_line_pointer;
262 char *new;
263 segT seg;
264 input_line_pointer = s;
265 seg = expr(0,op);
266 new = input_line_pointer;
267 input_line_pointer = save;
268 if (SEG_NORMAL(seg))
269 return new;
270 switch (seg) {
271 case SEG_ABSOLUTE:
272 case SEG_UNKNOWN:
273 case SEG_DIFFERENCE:
274 case SEG_BIG:
275 case SEG_REGISTER:
276 return new;
277 case SEG_ABSENT:
278 as_bad("Missing operand");
279 return new;
280 default:
281 as_bad("Don't understand operand of type %s", segment_name (seg));
282 return new;
283 }
284 }
285
286 static char *
287 DEFUN(skip_colonthing,(ptr),
288 char *ptr)
289 {
290 if (*ptr == ':') {
291 ptr++;
292 while (isdigit(*ptr))
293 ptr++;
294
295 }
296 return ptr;
297 }
298
299 /* The many forms of operand:
300
301 Rn Register direct
302 @Rn Register indirect
303 @(exp[:16], Rn) Register indirect with displacement
304 @Rn+
305 @-Rn
306 @aa:8 absolute 8 bit
307 @aa:16 absolute 16 bit
308 @aa absolute 16 bit
309
310 #xx[:size] immediate data
311 @(exp:[8], pc) pc rel
312 @@aa[:8] memory indirect
313
314 */
315
316 static void
317 DEFUN(get_operand,(ptr, op, dst),
318 char **ptr AND
319 struct h8_op *op AND
320 unsigned int dst)
321 {
322 char *src = *ptr;
323 op_type mode;
324 unsigned int num;
325 unsigned int len;
326 unsigned int size;
327 op->mode = E;
328
329 len = parse_reg(src, &op->mode, &op->reg, dst);
330 if (len) {
331 *ptr = src + len;
332 return ;
333 }
334
335 if (*src == '@')
336 {
337 src++;
338 if (*src == '@')
339 {
340 src++;
341 src = parse_exp(src,&op->exp);
342 src = skip_colonthing(src);
343
344 *ptr = src;
345
346 op->mode = MEMIND;
347 return;
348
349 }
350
351
352 if (*src == '-')
353 {
354 src++;
355 len = parse_reg(src, &mode, &num, dst);
356 if (len == 0)
357 {
358 /* Oops, not a reg after all, must be ordinary exp */
359 src--;
360 /* must be a symbol */
361 op->mode = abs_sord[dst];
362 *ptr = skip_colonthing(parse_exp(src, &op->exp));
363
364 return;
365
366
367 }
368
369 if (mode != r16_sord[dst])
370 {
371 as_bad("@- needs word register");
372 }
373 op->mode = RDDEC;
374 op->reg = num;
375 *ptr = src + len;
376 return;
377 }
378 if (*src == '(' && ')')
379 {
380 /* Disp */
381 src++;
382 src = parse_exp(src, &op->exp);
383
384 if (*src == ')')
385 {
386 src++;
387 op->mode = abs_sord[dst];
388 *ptr = src;
389 return;
390 }
391 src = skip_colonthing(src);
392
393 if (*src != ',')
394 {
395 as_bad("expected @(exp, reg16)");
396 }
397 src++;
398 len = parse_reg(src, &mode, &op->reg, dst);
399 if (len == 0 || mode != r16_sord[dst])
400 {
401 as_bad("expected @(exp, reg16)");
402 }
403 op->mode = disp_sord[dst];
404 src += len;
405 src = skip_colonthing(src);
406
407 if (*src != ')' && '(')
408 {
409 as_bad("expected @(exp, reg16)");
410
411 }
412 *ptr = src +1;
413
414 return;
415 }
416 len = parse_reg(src, &mode, &num, dst);
417
418 if(len) {
419 src += len;
420 if (*src == '+')
421 {
422 src++;
423 if (mode != RS16)
424 {
425 as_bad("@Rn+ needs src word register");
426 }
427 op->mode = RSINC;
428 op->reg = num;
429 *ptr = src;
430 return;
431 }
432 if (mode != r16_sord[dst])
433 {
434 as_bad("@Rn needs word register");
435 }
436 op->mode =rind_sord[dst];
437 op->reg = num;
438 *ptr = src;
439 return;
440 }
441 else
442 {
443 /* must be a symbol */
444 op->mode = abs_sord[dst];
445 *ptr = skip_colonthing(parse_exp(src, &op->exp));
446
447 return;
448 }
449 }
450
451
452 if (*src == '#') {
453 src++;
454 op->mode = IMM16;
455 src = parse_exp(src, &op->exp);
456 *ptr= skip_colonthing(src);
457
458 return;
459 }
460 else {
461 *ptr = parse_exp(src, &op->exp);
462 op->mode = DISP8;
463 }
464 }
465
466
467 static
468 char *
469 DEFUN(get_operands,(noperands,op_end, operand),
470 unsigned int noperands AND
471 char *op_end AND
472 struct h8_op *operand)
473 {
474 char *ptr = op_end;
475 switch (noperands)
476 {
477 case 0:
478 operand[0].mode = 0;
479 operand[1].mode = 0;
480 break;
481
482 case 1:
483 ptr++;
484 get_operand(& ptr, operand +0,0);
485 operand[1].mode =0;
486 break;
487
488 case 2:
489 ptr++;
490 get_operand(& ptr, operand +0,0);
491 if (*ptr == ',') ptr++;
492 get_operand(& ptr, operand +1, 1);
493 break;
494
495 default:
496 abort();
497 }
498
499
500 return ptr;
501 }
502
503 /* Passed a pointer to a list of opcodes which use different
504 addressing modes, return the opcode which matches the opcodes
505 provided
506 */
507 static
508 struct h8_opcode *
509 DEFUN(get_specific,(opcode, operands),
510 struct h8_opcode *opcode AND
511 struct h8_op *operands)
512
513 {
514 struct h8_opcode *this_try = opcode ;
515 int found = 0;
516 unsigned int noperands = opcode->noperands;
517
518 unsigned int dispreg;
519 unsigned int this_index = opcode->idx;
520 while (this_index == opcode->idx && !found)
521 {
522 unsigned int i;
523
524 this_try = opcode ++;
525 for (i = 0; i < noperands; i++)
526 {
527 op_type op = (this_try->args.nib[i]) & ~(B30|B31);
528 switch (op)
529 {
530 case Hex0:
531 case Hex1:
532 case Hex2:
533 case Hex3:
534 case Hex4:
535 case Hex5:
536 case Hex6:
537 case Hex7:
538 case Hex8:
539 case Hex9:
540 case HexA:
541 case HexB:
542 case HexC:
543 case HexD:
544 case HexE:
545 case HexF:
546 break;
547 case DISPSRC:
548 case DISPDST:
549 operands[0].dispreg = operands[i].reg;
550 case RD8:
551 case RS8:
552 case RDIND:
553 case RSIND:
554 case RD16:
555 case RS16:
556 case CCR:
557 case RSINC:
558 case RDDEC:
559 if (operands[i].mode != op) goto fail;
560 break;
561 case KBIT:
562 case IMM16:
563 case IMM3:
564 case IMM8:
565 if (operands[i].mode != IMM16) goto fail;
566 break;
567 case MEMIND:
568 if (operands[i].mode != MEMIND) goto fail;
569 break;
570 case ABS16SRC:
571 case ABS8SRC:
572 case ABS16OR8SRC:
573 case ABS16ORREL8SRC:
574
575 if (operands[i].mode != ABS16SRC) goto fail;
576 break;
577 case ABS16OR8DST:
578 case ABS16DST:
579 case ABS8DST:
580 if (operands[i].mode != ABS16DST) goto fail;
581 break;
582 }
583 }
584 found =1;
585 fail: ;
586 }
587 if (found)
588 return this_try;
589 else
590 return 0;
591 }
592
593 static void
594 DEFUN(check_operand,(operand, width, string),
595 struct h8_op *operand AND
596 unsigned int width AND
597 char *string)
598 {
599 if (operand->exp.X_add_symbol == 0
600 && operand->exp.X_subtract_symbol == 0)
601 {
602
603 /* No symbol involved, let's look at offset, it's dangerous if any of
604 the high bits are not 0 or ff's, find out by oring or anding with
605 the width and seeing if the answer is 0 or all fs*/
606 if ((operand->exp.X_add_number | width) != ~0 &&
607 (operand->exp.X_add_number & ~width)!= 0)
608 {
609 as_warn("operand %s0x%x out of range.", string, operand->exp.X_add_number);
610 }
611 }
612
613 }
614
615 /* Now we know what sort of opcodes it is, lets build the bytes -
616 */
617 static void
618 DEFUN (build_bytes,(this_try, operand),
619 struct h8_opcode *this_try AND
620 struct h8_op *operand)
621
622 {
623 unsigned int i;
624
625 char *output = frag_more(this_try->length);
626 char *output_ptr = output;
627 op_type *nibble_ptr = this_try->data.nib;
628 char part;
629 op_type c;
630 char high;
631 int nib;
632 top: ;
633 while (*nibble_ptr != E)
634 {
635 int nibble;
636 for (nibble = 0; nibble <2; nibble++)
637 {
638 c = *nibble_ptr & ~(B30|B31);
639 switch (c)
640 {
641 default:
642 abort();
643 case KBIT:
644 switch (operand[0].exp.X_add_number)
645 {
646 case 1:
647 nib = 0;
648 break;
649 case 2:
650 nib = 8;
651 break;
652 default:
653 as_bad("Need #1 or #2 here");
654 break;
655 }
656 /* stop it making a fix */
657 operand[0].mode = 0;
658 break;
659 case 0:
660 case 1:
661 case 2: case 3: case 4: case 5: case 6:
662 case 7: case 8: case 9: case 10: case 11:
663 case 12: case 13: case 14: case 15:
664 nib = c;
665 break;
666 case DISPREG:
667 nib = operand[0].dispreg;
668 break;
669 case IMM8:
670 operand[0].mode = IMM8;
671 nib = 0;
672 break;
673
674 case DISPDST:
675 nib = 0;
676 break;
677 case IMM3:
678 if (operand[0].exp.X_add_symbol == 0) {
679 operand[0].mode = 0; /* stop it making a fix */
680 nib = (operand[0].exp.X_add_number);
681 }
682 else as_bad("can't have symbol for bit number");
683 if (nib < 0 || nib > 7)
684 {
685 as_bad("Bit number out of range %d", nib);
686 }
687
688 break;
689
690 case ABS16DST:
691 nib = 0;
692 break;
693 case ABS8DST:
694 operand[1].mode = ABS8DST;
695 nib = 0;
696 break;
697 case ABS8SRC:
698 operand[0].mode = ABS8SRC;
699 nib = 0;
700 break;
701 case ABS16OR8DST:
702 operand[1].mode = c;
703
704 nib = 0;
705
706 break;
707
708 case ABS16ORREL8SRC:
709 operand[0].mode = c;
710 nib=0;
711 break;
712
713 case ABS16OR8SRC:
714 operand[0].mode = ABS16OR8SRC;
715 nib = 0;
716 break;
717 case DISPSRC:
718 operand[0].mode = ABS16SRC;
719 nib = 0;
720 break;
721
722 case DISP8:
723 operand[0].mode = DISP8;
724 nib = 0;
725 break;
726
727 case ABS16SRC:
728 case IMM16:
729 case IGNORE:
730 case MEMIND:
731
732 nib=0;
733 break;
734 case RS8:
735 case RS16:
736 case RSIND:
737 case RSINC:
738 nib = operand[0].reg;
739 break;
740
741 case RD8:
742 case RD16:
743 case RDDEC:
744 case RDIND:
745 nib = operand[1].reg;
746 break;
747
748 case E:
749 abort();
750 break;
751 }
752 if (*nibble_ptr & B31) {
753 nib |=0x8;
754 }
755
756 if (nibble == 0) {
757 *output_ptr = nib << 4;
758 }
759 else {
760 *output_ptr |= nib;
761 output_ptr++;
762 }
763 nibble_ptr++;
764 }
765
766 }
767
768 /* output any fixes */
769 for (i = 0; i < 2; i++)
770 {
771 switch (operand[i].mode) {
772 case 0:
773 break;
774
775 case DISP8:
776 check_operand(operand+i, 0x7f,"@");
777
778 fix_new(frag_now,
779 output - frag_now->fr_literal + 1,
780 1,
781 operand[i].exp.X_add_symbol,
782 operand[i].exp.X_subtract_symbol,
783 operand[i].exp.X_add_number -1,
784 1,
785 R_PCRBYTE);
786 break;
787 case IMM8:
788 check_operand(operand+i, 0xff,"#");
789 /* If there is nothing else going on we can safely
790 reloc in place */
791 if (operand[i].exp.X_add_symbol == 0)
792 {
793 output[1] = operand[i].exp.X_add_number;
794 }
795 else
796 {
797 fix_new(frag_now,
798 output - frag_now->fr_literal + 1,
799 1,
800 operand[i].exp.X_add_symbol,
801 operand[i].exp.X_subtract_symbol,
802 operand[i].exp.X_add_number,
803 0,
804 R_RELBYTE);
805 }
806
807 break;
808 case MEMIND:
809 check_operand(operand+i, 0xff,"@@");
810 fix_new(frag_now,
811 output - frag_now->fr_literal + 1,
812 1,
813 operand[i].exp.X_add_symbol,
814 operand[i].exp.X_subtract_symbol,
815 operand[i].exp.X_add_number,
816 0,
817 R_RELBYTE);
818 break;
819 case ABS8DST:
820 case ABS8SRC:
821 check_operand(operand+i, 0xff,"@");
822 fix_new(frag_now,
823 output - frag_now->fr_literal + 1,
824 1,
825 operand[i].exp.X_add_symbol,
826 operand[i].exp.X_subtract_symbol,
827 operand[i].exp.X_add_number,
828 0,
829 R_RELBYTE);
830 break;
831
832 case ABS16OR8SRC:
833 case ABS16OR8DST:
834 check_operand(operand+i, 0xffff,"@");
835
836 fix_new(frag_now,
837 output - frag_now->fr_literal + 2,
838 2,
839 operand[i].exp.X_add_symbol,
840 operand[i].exp.X_subtract_symbol,
841 operand[i].exp.X_add_number,
842 0,
843 R_MOVB1);
844 break;
845
846 case ABS16ORREL8SRC:
847 check_operand(operand+i, 0xffff,"@");
848
849 fix_new(frag_now,
850 output - frag_now->fr_literal + 2,
851 2,
852 operand[i].exp.X_add_symbol,
853 operand[i].exp.X_subtract_symbol,
854 operand[i].exp.X_add_number,
855 0,
856 R_JMP1);
857 break;
858
859
860 case ABS16SRC:
861 case ABS16DST:
862 case IMM16:
863 case DISPSRC:
864 case DISPDST:
865 check_operand(operand+i, 0xffff,"@");
866 if (operand[i].exp.X_add_symbol == 0)
867 {
868 /* This should be done with bfd */
869 output[3] = operand[i].exp.X_add_number & 0xff;
870 output[2] = operand[i].exp.X_add_number >> 8;
871
872 }
873 else
874 {
875
876 fix_new(frag_now,
877 output - frag_now->fr_literal + 2,
878 2,
879 operand[i].exp.X_add_symbol,
880 operand[i].exp.X_subtract_symbol,
881 operand[i].exp.X_add_number,
882 0,
883 R_RELWORD);
884 }
885
886 break;
887 case RS8:
888 case RD8:
889 case RS16:
890 case RD16:
891 case RDDEC:
892 case KBIT:
893 case RSINC:
894 case RDIND:
895 case RSIND:
896 case CCR:
897
898 break;
899 default:
900 abort();
901 }
902 }
903
904 }
905 /*
906 try and give an intelligent error message for common and simple to
907 detect errors
908 */
909
910 static void
911 DEFUN(clever_message, (opcode, operand),
912 struct h8_opcode *opcode AND
913 struct h8_op *operand)
914 {
915 struct h8_opcode *scan = opcode;
916
917 /* Find out if there was more than one possible opccode */
918
919 if ((opcode+1)->idx != opcode->idx)
920 {
921 unsigned int argn;
922
923 /* Only one opcode of this flavour, try and guess which operand
924 didn't match */
925 for (argn = 0; argn < opcode->noperands; argn++)
926 {
927 switch (opcode->args.nib[argn])
928 {
929 case RD16:
930 if (operand[argn].mode != RD16)
931 {
932 as_bad("destination operand must be 16 bit register");
933 }
934 return;
935 case RS8:
936
937 if (operand[argn].mode != RS8)
938 {
939 as_bad("source operand must be 8 bit register");
940 }
941 return;
942 case ABS16DST:
943 if (operand[argn].mode != ABS16DST)
944 {
945 as_bad("destination operand must be 16bit absolute address");
946 return;
947 }
948
949 case RD8:
950 if (operand[argn].mode != RD8)
951 {
952 as_bad("destination operand must be 8 bit register");
953 }
954 return;
955
956 case ABS16SRC:
957 if (operand[argn].mode != ABS16SRC)
958 {
959 as_bad("source operand must be 16bit absolute address");
960 return;
961 }
962 }
963 }
964 }
965 as_bad("invalid operands");
966 }
967
968 /* This is the guts of the machine-dependent assembler. STR points to a
969 machine dependent instruction. This funciton is supposed to emit
970 the frags/bytes it assembles to.
971 */
972
973
974
975 void
976 DEFUN(md_assemble,(str),
977 char *str)
978 {
979 char *op_start;
980 char *op_end;
981 unsigned int i;
982 struct h8_op operand[2];
983 struct h8_opcode * opcode;
984 struct h8_opcode * prev_opcode;
985
986 char *dot = 0;
987 char c;
988 /* Drop leading whitespace */
989 while (*str == ' ')
990 str++;
991
992 /* find the op code end */
993 for (op_start = op_end = str;
994 *op_end != 0 && *op_end != ' ';
995 op_end ++)
996 {
997 if (*op_end == '.') {
998 dot = op_end+1;
999 *op_end = 0;
1000 op_end+=2;
1001 break;
1002 }
1003 }
1004
1005 ;
1006
1007 if (op_end == op_start)
1008 {
1009 as_bad("can't find opcode ");
1010 }
1011 c = *op_end;
1012
1013 *op_end = 0;
1014
1015 opcode = (struct h8_opcode *) hash_find(opcode_hash_control,
1016 op_start);
1017
1018 if (opcode == NULL)
1019 {
1020 as_bad("unknown opcode");
1021 return;
1022 }
1023
1024
1025 input_line_pointer = get_operands(opcode->noperands, op_end,
1026 operand);
1027 *op_end = c;
1028 prev_opcode = opcode;
1029
1030 opcode = get_specific(opcode, operand);
1031
1032 if (opcode == 0)
1033 {
1034 /* Couldn't find an opcode which matched the operands */
1035 char *where =frag_more(2);
1036 where[0] = 0x0;
1037 where[1] = 0x0;
1038 clever_message(prev_opcode, operand);
1039
1040 return;
1041 }
1042 if (opcode->size && dot)
1043 {
1044 if (opcode->size != *dot)
1045 {
1046 as_warn("mismatch between opcode size and operand size");
1047 }
1048 }
1049
1050 build_bytes(opcode, operand);
1051
1052 }
1053
1054 void
1055 DEFUN(tc_crawl_symbol_chain, (headers),
1056 object_headers *headers)
1057 {
1058 printf("call to tc_crawl_symbol_chain \n");
1059 }
1060
1061 symbolS *DEFUN(md_undefined_symbol,(name),
1062 char *name)
1063 {
1064 return 0;
1065 }
1066
1067 void
1068 DEFUN(tc_headers_hook,(headers),
1069 object_headers *headers)
1070 {
1071 printf("call to tc_headers_hook \n");
1072 }
1073 void
1074 DEFUN_VOID(md_end)
1075 {
1076 }
1077
1078 /* Various routines to kill one day */
1079 /* Equal to MAX_PRECISION in atof-ieee.c */
1080 #define MAX_LITTLENUMS 6
1081
1082 /* Turn a string in input_line_pointer into a floating point constant of type
1083 type, and store the appropriate bytes in *litP. The number of LITTLENUMS
1084 emitted is stored in *sizeP . An error message is returned, or NULL on OK.
1085 */
1086 char *
1087 md_atof(type,litP,sizeP)
1088 char type;
1089 char *litP;
1090 int *sizeP;
1091 {
1092 int prec;
1093 LITTLENUM_TYPE words[MAX_LITTLENUMS];
1094 LITTLENUM_TYPE *wordP;
1095 char *t;
1096 char *atof_ieee();
1097
1098 switch(type) {
1099 case 'f':
1100 case 'F':
1101 case 's':
1102 case 'S':
1103 prec = 2;
1104 break;
1105
1106 case 'd':
1107 case 'D':
1108 case 'r':
1109 case 'R':
1110 prec = 4;
1111 break;
1112
1113 case 'x':
1114 case 'X':
1115 prec = 6;
1116 break;
1117
1118 case 'p':
1119 case 'P':
1120 prec = 6;
1121 break;
1122
1123 default:
1124 *sizeP=0;
1125 return "Bad call to MD_ATOF()";
1126 }
1127 t=atof_ieee(input_line_pointer,type,words);
1128 if(t)
1129 input_line_pointer=t;
1130
1131 *sizeP=prec * sizeof(LITTLENUM_TYPE);
1132 for(wordP=words;prec--;) {
1133 md_number_to_chars(litP,(long)(*wordP++),sizeof(LITTLENUM_TYPE));
1134 litP+=sizeof(LITTLENUM_TYPE);
1135 }
1136 return ""; /* Someone should teach Dean about null pointers */
1137 }
1138
1139 int
1140 md_parse_option(argP, cntP, vecP)
1141 char **argP;
1142 int *cntP;
1143 char ***vecP;
1144
1145 {
1146 return 0;
1147
1148 }
1149
1150 int md_short_jump_size;
1151
1152 void tc_aout_fix_to_chars () { printf("call to tc_aout_fix_to_chars \n");
1153 abort(); }
1154 void md_create_short_jump(ptr, from_addr, to_addr, frag, to_symbol)
1155 char *ptr;
1156 long from_addr;
1157 long to_addr;
1158 fragS *frag;
1159 symbolS *to_symbol;
1160 {
1161 as_fatal("failed sanity check.");
1162 }
1163
1164 void
1165 md_create_long_jump(ptr,from_addr,to_addr,frag,to_symbol)
1166 char *ptr;
1167 long from_addr, to_addr;
1168 fragS *frag;
1169 symbolS *to_symbol;
1170 {
1171 as_fatal("failed sanity check.");
1172 }
1173
1174 void
1175 md_convert_frag(headers, fragP)
1176 object_headers *headers;
1177 fragS * fragP;
1178
1179 { printf("call to md_convert_frag \n"); abort(); }
1180
1181 long
1182 DEFUN(md_section_align,(seg, size),
1183 segT seg AND
1184 long size)
1185 {
1186 return((size + (1 << section_alignment[(int) seg]) - 1) & (-1 << section_alignment[(int) seg]));
1187
1188 }
1189
1190 void
1191 md_apply_fix(fixP, val)
1192 fixS *fixP;
1193 long val;
1194 {
1195 char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
1196
1197 switch(fixP->fx_size) {
1198 case 1:
1199 *buf++=val;
1200 break;
1201 case 2:
1202 *buf++=(val>>8);
1203 *buf++=val;
1204 break;
1205 case 4:
1206 *buf++=(val>>24);
1207 *buf++=(val>>16);
1208 *buf++=(val>>8);
1209 *buf++=val;
1210 break;
1211 default:
1212 abort();
1213
1214 }
1215 }
1216
1217 void DEFUN(md_operand, (expressionP),expressionS *expressionP)
1218 { }
1219
1220 int md_long_jump_size;
1221 int
1222 md_estimate_size_before_relax(fragP, segment_type)
1223 register fragS *fragP;
1224 register segT segment_type;
1225 {
1226 printf("call tomd_estimate_size_before_relax \n"); abort(); }
1227 /* Put number into target byte order */
1228
1229 void DEFUN(md_number_to_chars,(ptr, use, nbytes),
1230 char *ptr AND
1231 long use AND
1232 int nbytes)
1233 {
1234 switch (nbytes) {
1235 case 4: *ptr++ = (use >> 24) & 0xff;
1236 case 3: *ptr++ = (use >> 16) & 0xff;
1237 case 2: *ptr++ = (use >> 8) & 0xff;
1238 case 1: *ptr++ = (use >> 0) & 0xff;
1239 break;
1240 default:
1241 abort();
1242 }
1243 }
1244 long md_pcrel_from(fixP)
1245 fixS *fixP; { abort(); }
1246
1247 void tc_coff_symbol_emit_hook() { }
1248
1249
1250 void tc_reloc_mangle(fix_ptr, intr, base)
1251 fixS *fix_ptr;
1252 struct internal_reloc *intr;
1253 bfd_vma base;
1254
1255 {
1256 symbolS *symbol_ptr;
1257
1258 symbol_ptr = fix_ptr->fx_addsy;
1259
1260 /* If this relocation is attached to a symbol then it's ok
1261 to output it */
1262 if (fix_ptr->fx_r_type == RELOC_32) {
1263 /* cons likes to create reloc32's whatever the size of the reloc..
1264 */
1265 switch (fix_ptr->fx_size)
1266 {
1267
1268 case 2:
1269 intr->r_type = R_RELWORD;
1270 break;
1271 case 1:
1272 intr->r_type = R_RELBYTE;
1273 break;
1274 default:
1275 abort();
1276
1277 }
1278
1279 }
1280 else {
1281 intr->r_type = fix_ptr->fx_r_type;
1282 }
1283
1284 intr->r_vaddr = fix_ptr->fx_frag->fr_address + fix_ptr->fx_where +base;
1285 intr->r_offset = fix_ptr->fx_offset;
1286
1287 if (symbol_ptr)
1288 intr->r_symndx = symbol_ptr->sy_number;
1289 else
1290 intr->r_symndx = -1;
1291
1292
1293 }
1294
1295 /* end of tc-h8300.c */
GDB Binutils - Deliverables
This page took 0.0697680000000001 seconds and 5 git commands to generate.