1 /* tc-h8300.c -- Assemble code for the Renesas H8/300
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000,
3 2001, 2002, 2003 Free Software Foundation, Inc.
5 This file is part of GAS, the GNU Assembler.
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)
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.
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
22 /* Written By Steve Chamberlain <sac@cygnus.com>. */
30 #include "dwarf2dbg.h"
34 #define h8_opcodes ops
35 #include "opcode/h8300.h"
36 #include "safe-ctype.h"
42 const char comment_chars
[] = ";";
43 const char line_comment_chars
[] = "#";
44 const char line_separator_chars
[] = "";
46 void cons
PARAMS ((int));
47 void sbranch
PARAMS ((int));
48 void h8300hmode
PARAMS ((int));
49 void h8300smode
PARAMS ((int));
50 void h8300hnmode
PARAMS ((int));
51 void h8300snmode
PARAMS ((int));
52 void h8300sxmode
PARAMS ((int));
53 static void pint
PARAMS ((int));
60 #define PSIZE (Hmode ? L_32 : L_16)
61 #define DSYMMODE (Hmode ? L_24 : L_16)
63 int bsize
= L_8
; /* Default branch displacement. */
71 const struct h8_opcode
*opcode
;
74 struct h8_instruction
*h8_instructions
;
78 int arg ATTRIBUTE_UNUSED
;
83 if (!bfd_set_arch_mach (stdoutput
, bfd_arch_h8300
, bfd_mach_h8300h
))
84 as_warn (_("could not set architecture and machine"));
90 int arg ATTRIBUTE_UNUSED
;
95 if (!bfd_set_arch_mach (stdoutput
, bfd_arch_h8300
, bfd_mach_h8300s
))
96 as_warn (_("could not set architecture and machine"));
102 int arg ATTRIBUTE_UNUSED
;
108 if (!bfd_set_arch_mach (stdoutput
, bfd_arch_h8300
, bfd_mach_h8300hn
))
109 as_warn (_("could not set architecture and machine"));
115 int arg ATTRIBUTE_UNUSED
;
121 if (!bfd_set_arch_mach (stdoutput
, bfd_arch_h8300
, bfd_mach_h8300sn
))
122 as_warn (_("could not set architecture and machine"));
128 int arg ATTRIBUTE_UNUSED
;
134 if (!bfd_set_arch_mach (stdoutput
, bfd_arch_h8300
, bfd_mach_h8300sx
))
135 as_warn (_("could not set architecture and machine"));
141 int arg ATTRIBUTE_UNUSED
;
148 if (!bfd_set_arch_mach (stdoutput
, bfd_arch_h8300
, bfd_mach_h8300sxn
))
149 as_warn (_("could not set architecture and machine"));
162 int arg ATTRIBUTE_UNUSED
;
164 cons (Hmode
? 4 : 2);
167 /* This table describes all the machine specific pseudo-ops the assembler
168 has to support. The fields are:
169 pseudo-op name without dot
170 function to call to execute this pseudo-op
171 Integer arg to pass to the function. */
173 const pseudo_typeS md_pseudo_table
[] =
175 {"h8300h", h8300hmode
, 0},
176 {"h8300hn", h8300hnmode
, 0},
177 {"h8300s", h8300smode
, 0},
178 {"h8300sn", h8300snmode
, 0},
179 {"h8300sx", h8300sxmode
, 0},
180 {"h8300sxn", h8300sxnmode
, 0},
181 {"sbranch", sbranch
, L_8
},
182 {"lbranch", sbranch
, L_16
},
188 {"form", listing_psize
, 0},
189 {"heading", listing_title
, 0},
190 {"import", s_ignore
, 0},
191 {"page", listing_eject
, 0},
192 {"program", s_ignore
, 0},
196 const int md_reloc_size
;
198 const char EXP_CHARS
[] = "eE";
200 /* Chars that mean this number is a floating point constant
203 const char FLT_CHARS
[] = "rRsSfFdDxXpP";
205 static struct hash_control
*opcode_hash_control
; /* Opcode mnemonics. */
207 /* This function is called once, at assembler startup time. This
208 should set up all the tables, etc. that the MD part of the assembler
214 unsigned int nopcodes
;
215 struct h8_opcode
*p
, *p1
;
216 struct h8_instruction
*pi
;
217 char prev_buffer
[100];
221 if (!bfd_set_arch_mach (stdoutput
, bfd_arch_h8300
, bfd_mach_h8300
))
222 as_warn (_("could not set architecture and machine"));
225 opcode_hash_control
= hash_new ();
228 nopcodes
= sizeof (h8_opcodes
) / sizeof (struct h8_opcode
);
230 h8_instructions
= (struct h8_instruction
*)
231 xmalloc (nopcodes
* sizeof (struct h8_instruction
));
233 pi
= h8_instructions
;
235 /* We do a minimum amount of sorting on the opcode table; this is to
236 make it easy to describe the mova instructions without unnecessary
238 Sorting only takes place inside blocks of instructions of the form
239 X/Y, so for example mova/b, mova/w and mova/l can be intermixed. */
242 struct h8_opcode
*first_skipped
= 0;
244 char *src
= p1
->name
;
249 /* Strip off any . part when inserting the opcode and only enter
250 unique codes into the hash table. */
251 dst
= buffer
= malloc (strlen (src
) + 1);
260 cmplen
= src
- p1
->name
+ 1;
267 hash_insert (opcode_hash_control
, buffer
, (char *) pi
);
268 strcpy (prev_buffer
, buffer
);
271 for (p
= p1
; p
->name
; p
++)
273 /* A negative TIME is used to indicate that we've added this opcode
277 if (strncmp (p
->name
, buffer
, cmplen
) != 0
278 || (p
->name
[cmplen
] != '\0' && p
->name
[cmplen
] != '.'
279 && p
->name
[cmplen
- 1] != '/'))
281 if (first_skipped
== 0)
285 if (strncmp (p
->name
, buffer
, len
) != 0)
287 if (first_skipped
== 0)
293 pi
->size
= p
->name
[len
] == '.' ? p
->name
[len
+ 1] : 0;
296 /* Find the number of operands. */
298 while (pi
->noperands
< 3 && p
->args
.nib
[pi
->noperands
] != (op_type
) E
)
301 /* Find the length of the opcode in bytes. */
303 while (p
->data
.nib
[pi
->length
* 2] != (op_type
) E
)
312 /* Add entry for the NULL vector terminator. */
336 static void clever_message
PARAMS ((const struct h8_instruction
*, struct h8_op
*));
337 static void fix_operand_size
PARAMS ((struct h8_op
*, int));
338 static void build_bytes
PARAMS ((const struct h8_instruction
*, struct h8_op
*));
339 static void do_a_fix_imm
PARAMS ((int, int, struct h8_op
*, int));
340 static void check_operand
PARAMS ((struct h8_op
*, unsigned int, char *));
341 static const struct h8_instruction
* get_specific
PARAMS ((const struct h8_instruction
*, struct h8_op
*, int));
342 static char * get_operands
PARAMS ((unsigned, char *, struct h8_op
*));
343 static void get_operand
PARAMS ((char **, struct h8_op
*, int));
344 static char * skip_colonthing
PARAMS ((char *, expressionS
*, int *));
345 static char * parse_exp
PARAMS ((char *, expressionS
*));
346 static int parse_reg
PARAMS ((char *, op_type
*, unsigned *, int));
347 char * colonmod24
PARAMS ((struct h8_op
*, char *));
349 static int constant_fits_width_p
PARAMS ((struct h8_op
*, unsigned int));
350 static int constant_fits_size_p
PARAMS ((struct h8_op
*, int, int));
354 WREG r0,r1,r2,r3,r4,r5,r6,r7,fp,sp
363 /* Try to parse a reg name. Return the number of chars consumed. */
366 parse_reg (src
, mode
, reg
, direction
)
375 /* Cribbed from get_symbol_end. */
376 if (!is_name_beginner (*src
) || *src
== '\001')
379 while ((is_part_of_name (*end
) && *end
!= '.') || *end
== '\001')
383 if (len
== 2 && TOLOWER (src
[0]) == 's' && TOLOWER (src
[1]) == 'p')
385 *mode
= PSIZE
| REG
| direction
;
390 TOLOWER (src
[0]) == 'c' &&
391 TOLOWER (src
[1]) == 'c' &&
392 TOLOWER (src
[2]) == 'r')
399 TOLOWER (src
[0]) == 'e' &&
400 TOLOWER (src
[1]) == 'x' &&
401 TOLOWER (src
[2]) == 'r')
408 TOLOWER (src
[0]) == 'v' &&
409 TOLOWER (src
[1]) == 'b' &&
410 TOLOWER (src
[2]) == 'r')
417 TOLOWER (src
[0]) == 's' &&
418 TOLOWER (src
[1]) == 'b' &&
419 TOLOWER (src
[2]) == 'r')
425 if (len
== 2 && TOLOWER (src
[0]) == 'f' && TOLOWER (src
[1]) == 'p')
427 *mode
= PSIZE
| REG
| direction
;
431 if (len
== 3 && TOLOWER (src
[0]) == 'e' && TOLOWER (src
[1]) == 'r' &&
432 src
[2] >= '0' && src
[2] <= '7')
434 *mode
= L_32
| REG
| direction
;
437 as_warn (_("Reg not valid for H8/300"));
440 if (len
== 2 && TOLOWER (src
[0]) == 'e' && src
[1] >= '0' && src
[1] <= '7')
442 *mode
= L_16
| REG
| direction
;
443 *reg
= src
[1] - '0' + 8;
445 as_warn (_("Reg not valid for H8/300"));
449 if (TOLOWER (src
[0]) == 'r')
451 if (src
[1] >= '0' && src
[1] <= '7')
453 if (len
== 3 && TOLOWER (src
[2]) == 'l')
455 *mode
= L_8
| REG
| direction
;
456 *reg
= (src
[1] - '0') + 8;
459 if (len
== 3 && TOLOWER (src
[2]) == 'h')
461 *mode
= L_8
| REG
| direction
;
462 *reg
= (src
[1] - '0');
467 *mode
= L_16
| REG
| direction
;
468 *reg
= (src
[1] - '0');
482 char *save
= input_line_pointer
;
485 input_line_pointer
= s
;
487 if (op
->X_op
== O_absent
)
488 as_bad (_("missing operand"));
489 new = input_line_pointer
;
490 input_line_pointer
= save
;
495 skip_colonthing (ptr
, exp
, mode
)
497 expressionS
*exp ATTRIBUTE_UNUSED
;
504 if (ptr
[0] == '8' && ! ISDIGIT (ptr
[1]))
506 else if (ptr
[0] == '2' && ! ISDIGIT (ptr
[1]))
508 else if (ptr
[0] == '3' && ! ISDIGIT (ptr
[1]))
510 else if (ptr
[0] == '4' && ! ISDIGIT (ptr
[1]))
512 else if (ptr
[0] == '5' && ! ISDIGIT (ptr
[1]))
514 else if (ptr
[0] == '2' && ptr
[1] == '4')
516 else if (ptr
[0] == '3' && ptr
[1] == '2')
518 else if (ptr
[0] == '1' && ptr
[1] == '6')
521 as_bad (_("invalid operand size requested"));
523 while (ISDIGIT (*ptr
))
529 /* The many forms of operand:
532 @Rn Register indirect
533 @(exp[:16], Rn) Register indirect with displacement
537 @aa:16 absolute 16 bit
540 #xx[:size] immediate data
541 @(exp:[8], pc) pc rel
542 @@aa[:8] memory indirect. */
550 src
= skip_colonthing (src
, &op
->exp
, &mode
);
554 /* If the operand is a 16-bit constant integer, leave fix_operand_size
555 to calculate its size. Otherwise choose a default here. */
556 if (op
->exp
.X_add_number
< -32768
557 || op
->exp
.X_add_number
> 32767)
564 else if (op
->exp
.X_add_symbol
565 || op
->exp
.X_op_symbol
)
574 constant_fits_width_p (operand
, width
)
575 struct h8_op
*operand
;
578 return ((operand
->exp
.X_add_number
& ~width
) == 0
579 || (operand
->exp
.X_add_number
| width
) == (unsigned)(~0));
583 constant_fits_size_p (operand
, size
, no_symbols
)
584 struct h8_op
*operand
;
585 int size
, no_symbols
;
587 offsetT num
= operand
->exp
.X_add_number
;
589 && (operand
->exp
.X_add_symbol
!= 0 || operand
->exp
.X_op_symbol
!= 0))
594 return (num
& ~3) == 0;
596 return (num
& ~7) == 0;
598 return num
>= 1 && num
< 8;
600 return (num
& ~15) == 0;
602 return num
>= 1 && num
< 32;
604 return (num
& ~0xFF) == 0 || ((unsigned)num
| 0x7F) == ~0u;
606 return (num
& ~0xFF) == 0;
608 return (num
& ~0xFFFF) == 0 || ((unsigned)num
| 0x7FFF) == ~0u;
610 return (num
& ~0xFFFF) == 0;
619 get_operand (ptr
, op
, direction
)
631 /* Check for '(' and ')' for instructions ldm and stm. */
632 if (src
[0] == '(' && src
[8] == ')')
635 /* Gross. Gross. ldm and stm have a format not easily handled
636 by get_operand. We deal with it explicitly here. */
637 if (TOLOWER (src
[0]) == 'e' && TOLOWER (src
[1]) == 'r' &&
638 ISDIGIT (src
[2]) && src
[3] == '-' &&
639 TOLOWER (src
[4]) == 'e' && TOLOWER (src
[5]) == 'r' && ISDIGIT (src
[6]))
647 as_bad (_("Invalid register list for ldm/stm\n"));
650 as_bad (_("Invalid register list for ldm/stm\n"));
653 as_bad (_("Invalid register list for ldm/stm)\n"));
655 /* Even sicker. We encode two registers into op->reg. One
656 for the low register to save, the other for the high
657 register to save; we also set the high bit in op->reg
658 so we know this is "very special". */
659 op
->reg
= 0x80000000 | (high
<< 8) | low
;
668 len
= parse_reg (src
, &op
->mode
, &op
->reg
, direction
);
674 int size
= op
->mode
& SIZE
;
679 as_warn (_("mismatch between register and suffix"));
680 op
->mode
= (op
->mode
& ~MODE
) | LOWREG
;
683 if (size
!= L_32
&& size
!= L_16
)
684 as_warn (_("mismatch between register and suffix"));
685 op
->mode
= (op
->mode
& ~MODE
) | LOWREG
;
686 op
->mode
= (op
->mode
& ~SIZE
) | L_16
;
689 op
->mode
= (op
->mode
& ~MODE
) | LOWREG
;
690 if (size
!= L_32
&& size
!= L_8
)
691 as_warn (_("mismatch between register and suffix"));
692 op
->mode
= (op
->mode
& ~MODE
) | LOWREG
;
693 op
->mode
= (op
->mode
& ~SIZE
) | L_8
;
696 as_warn ("invalid suffix after register.");
711 src
= parse_exp (src
, &op
->exp
);
713 src
= skip_colonthing (src
, &op
->exp
, &op
->mode
);
717 if (op
->exp
.X_add_number
>= 0x100)
722 /* FIXME : 2? or 4? */
723 if (op
->exp
.X_add_number
>= 0x400)
724 as_bad (_("address too high for vector table jmp/jsr"));
725 else if (op
->exp
.X_add_number
>= 0x200)
730 op
->exp
.X_add_number
= op
->exp
.X_add_number
/ divisor
- 0x80;
738 if (*src
== '-' || *src
== '+')
742 len
= parse_reg (src
, &mode
, &num
, direction
);
745 /* Oops, not a reg after all, must be ordinary exp. */
747 /* Must be a symbol. */
748 op
->mode
= ABS
| PSIZE
| direction
;
749 *ptr
= skip_colonthing (parse_exp (src
, &op
->exp
),
750 &op
->exp
, &op
->mode
);
755 if ((mode
& SIZE
) != PSIZE
)
756 as_bad (_("Wrong size pointer register for architecture."));
757 op
->mode
= c
== '-' ? RDPREDEC
: RDPREINC
;
766 /* See if this is @(ERn.x, PC). */
767 len
= parse_reg (src
, &mode
, &op
->reg
, direction
);
768 if (len
!= 0 && (mode
& MODE
) == REG
&& src
[len
] == '.')
770 switch (TOLOWER (src
[len
+ 1]))
773 mode
= PCIDXB
| direction
;
776 mode
= PCIDXW
| direction
;
779 mode
= PCIDXL
| direction
;
786 && src
[len
+ 2] == ','
787 && TOLOWER (src
[len
+ 3]) != 'p'
788 && TOLOWER (src
[len
+ 4]) != 'c'
789 && src
[len
+ 5] != ')')
791 *ptr
= src
+ len
+ 6;
795 /* Fall through into disp case - the grammar is somewhat
796 ambiguous, so we should try whether it's a DISP operand
797 after all ("ER3.L" might be a poorly named label...). */
802 /* Start off assuming a 16 bit offset. */
804 src
= parse_exp (src
, &op
->exp
);
806 src
= colonmod24 (op
, src
);
811 op
->mode
|= ABS
| direction
;
818 as_bad (_("expected @(exp, reg16)"));
824 len
= parse_reg (src
, &mode
, &op
->reg
, direction
);
825 if (len
== 0 || (mode
& MODE
) != REG
)
827 as_bad (_("expected @(exp, reg16)"));
833 switch (TOLOWER (src
[1]))
836 op
->mode
|= INDEXB
| direction
;
839 op
->mode
|= INDEXW
| direction
;
842 op
->mode
|= INDEXL
| direction
;
845 as_bad (_("expected .L, .W or .B for register in indexed addressing mode"));
851 op
->mode
|= DISP
| direction
;
852 src
= skip_colonthing (src
, &op
->exp
, &op
->mode
);
854 if (*src
!= ')' && '(')
856 as_bad (_("expected @(exp, reg16)"));
863 len
= parse_reg (src
, &mode
, &num
, direction
);
868 if (*src
== '+' || *src
== '-')
870 if ((mode
& SIZE
) != PSIZE
)
871 as_bad (_("Wrong size pointer register for architecture."));
872 op
->mode
= *src
== '+' ? RSPOSTINC
: RSPOSTDEC
;
878 if ((mode
& SIZE
) != PSIZE
)
879 as_bad (_("Wrong size pointer register for architecture."));
881 op
->mode
= direction
| IND
| PSIZE
;
889 /* must be a symbol */
891 op
->mode
= ABS
| direction
;
892 src
= parse_exp (src
, &op
->exp
);
894 *ptr
= colonmod24 (op
, src
);
904 src
= parse_exp (src
, &op
->exp
);
905 *ptr
= skip_colonthing (src
, &op
->exp
, &op
->mode
);
909 else if (strncmp (src
, "mach", 4) == 0 ||
910 strncmp (src
, "macl", 4) == 0 ||
911 strncmp (src
, "MACH", 4) == 0 ||
912 strncmp (src
, "MACL", 4) == 0)
914 op
->reg
= TOLOWER (src
[3]) == 'l';
921 src
= parse_exp (src
, &op
->exp
);
922 /* Trailing ':' size ? */
925 if (src
[1] == '1' && src
[2] == '6')
927 op
->mode
= PCREL
| L_16
;
930 else if (src
[1] == '8')
932 op
->mode
= PCREL
| L_8
;
936 as_bad (_("expect :8 or :16 here"));
940 int val
= op
->exp
.X_add_number
;
943 if (-128 < val
&& val
< 127)
954 get_operands (noperands
, op_end
, operand
)
955 unsigned int noperands
;
957 struct h8_op
*operand
;
968 get_operand (&ptr
, operand
+ 0, SRC
);
972 get_operand (&ptr
, operand
+ 1, DST
);
978 get_operand (&ptr
, operand
+ 0, SRC
);
981 get_operand (&ptr
, operand
+ 1, DST
);
986 get_operand (&ptr
, operand
+ 0, SRC
);
989 get_operand (&ptr
, operand
+ 1, DST
);
992 get_operand (&ptr
, operand
+ 2, OP3
);
1002 /* MOVA has special requirements. Rather than adding twice the amount of
1003 addressing modes, we simply special case it a bit. */
1005 get_mova_operands (char *op_end
, struct h8_op
*operand
)
1009 if (ptr
[1] != '@' || ptr
[2] != '(')
1012 operand
[0].mode
= 0;
1013 ptr
= parse_exp (ptr
, &operand
[0].exp
);
1014 ptr
= colonmod24 (operand
+ 0, ptr
);
1019 get_operand (&ptr
, operand
+ 1, DST
);
1027 operand
[0].mode
= (operand
[0].mode
& ~MODE
) | INDEXB
;
1030 operand
[0].mode
= (operand
[0].mode
& ~MODE
) | INDEXW
;
1033 operand
[0].mode
= (operand
[0].mode
& ~MODE
) | INDEXL
;
1039 else if ((operand
[1].mode
& MODE
) == LOWREG
)
1041 switch (operand
[1].mode
& SIZE
)
1044 operand
[0].mode
= (operand
[0].mode
& ~MODE
) | INDEXB
;
1047 operand
[0].mode
= (operand
[0].mode
& ~MODE
) | INDEXW
;
1050 operand
[0].mode
= (operand
[0].mode
& ~MODE
) | INDEXL
;
1059 if (*ptr
++ != ')' || *ptr
++ != ',')
1061 get_operand (&ptr
, operand
+ 2, OP3
);
1062 /* See if we can use the short form of MOVA. */
1063 if (((operand
[1].mode
& MODE
) == REG
|| (operand
[1].mode
& MODE
) == LOWREG
)
1064 && (operand
[2].mode
& MODE
) == REG
1065 && (operand
[1].reg
& 7) == (operand
[2].reg
& 7))
1067 operand
[1].mode
= operand
[2].mode
= 0;
1068 operand
[0].reg
= operand
[2].reg
& 7;
1073 as_bad (_("expected valid addressing mode for mova: \"@(disp, ea.sz),ERn\""));
1078 get_rtsl_operands (char *ptr
, struct h8_op
*operand
)
1080 int mode
, num
, num2
, len
, type
= 0;
1088 len
= parse_reg (ptr
, &mode
, &num
, SRC
);
1089 if (len
== 0 || (mode
& MODE
) != REG
)
1091 as_bad (_("expected register"));
1099 as_bad (_("expected register list"));
1102 len
= parse_reg (ptr
, &mode
, &num2
, SRC
);
1103 if (len
== 0 || (mode
& MODE
) != REG
)
1105 as_bad (_("expected register"));
1111 as_bad (_("expected closing paren"));
1114 /* CONST_xxx are used as placeholders in the opcode table. */
1116 if (num
< 1 || num
> 3)
1118 as_bad (_("invalid register list"));
1123 num2
= num
, num
= 0;
1124 operand
[0].mode
= RS32
;
1125 operand
[1].mode
= RD32
;
1126 operand
[0].reg
= num
;
1127 operand
[1].reg
= num2
;
1130 /* Passed a pointer to a list of opcodes which use different
1131 addressing modes, return the opcode which matches the opcodes
1134 static const struct h8_instruction
*
1135 get_specific (instruction
, operands
, size
)
1136 const struct h8_instruction
*instruction
;
1137 struct h8_op
*operands
;
1140 const struct h8_instruction
*this_try
= instruction
;
1141 const struct h8_instruction
*found_other
= 0, *found_mismatched
= 0;
1143 int this_index
= instruction
->idx
;
1146 /* There's only one ldm/stm and it's easier to just
1147 get out quick for them. */
1148 if (OP_KIND (instruction
->opcode
->how
) == O_LDM
1149 || OP_KIND (instruction
->opcode
->how
) == O_STM
)
1152 while (noperands
< 3 && operands
[noperands
].mode
!= 0)
1155 while (this_index
== instruction
->idx
&& !found
)
1160 this_try
= instruction
++;
1161 this_size
= this_try
->opcode
->how
& SN
;
1163 if (this_try
->noperands
!= noperands
)
1165 else if (this_try
->noperands
> 0)
1169 for (i
= 0; i
< this_try
->noperands
&& found
; i
++)
1171 op_type op
= this_try
->opcode
->args
.nib
[i
];
1172 int op_mode
= op
& MODE
;
1173 int op_size
= op
& SIZE
;
1174 int x
= operands
[i
].mode
;
1175 int x_mode
= x
& MODE
;
1176 int x_size
= x
& SIZE
;
1178 if (op_mode
== LOWREG
&& (x_mode
== REG
|| x_mode
== LOWREG
))
1180 if ((x_size
== L_8
&& (operands
[i
].reg
& 8) == 0)
1181 || (x_size
== L_16
&& (operands
[i
].reg
& 8) == 8))
1182 as_warn (_("can't use high part of register in operand %d"), i
);
1184 if (x_size
!= op_size
)
1187 else if (op_mode
== REG
)
1189 if (x_mode
== LOWREG
)
1195 x_size
= (Hmode
? L_32
: L_16
);
1197 op_size
= (Hmode
? L_32
: L_16
);
1199 /* The size of the reg is v important. */
1200 if (op_size
!= x_size
)
1203 else if (op_mode
& CTRL
) /* control register */
1205 if (!(x_mode
& CTRL
))
1211 if (op_mode
!= CCR
&&
1212 op_mode
!= CCR_EXR
&&
1213 op_mode
!= CC_EX_VB_SB
)
1217 if (op_mode
!= EXR
&&
1218 op_mode
!= CCR_EXR
&&
1219 op_mode
!= CC_EX_VB_SB
)
1223 if (op_mode
!= MACH
&&
1228 if (op_mode
!= MACL
&&
1233 if (op_mode
!= VBR
&&
1234 op_mode
!= VBR_SBR
&&
1235 op_mode
!= CC_EX_VB_SB
)
1239 if (op_mode
!= SBR
&&
1240 op_mode
!= VBR_SBR
&&
1241 op_mode
!= CC_EX_VB_SB
)
1246 else if ((op
& ABSJMP
) && (x_mode
== ABS
|| x_mode
== PCREL
))
1248 operands
[i
].mode
&= ~MODE
;
1249 operands
[i
].mode
|= ABSJMP
;
1250 /* But it may not be 24 bits long. */
1251 if (x_mode
== ABS
&& !Hmode
)
1253 operands
[i
].mode
&= ~SIZE
;
1254 operands
[i
].mode
|= L_16
;
1256 if ((operands
[i
].mode
& SIZE
) == L_32
1257 && (op_mode
& SIZE
) != L_32
)
1260 else if (x_mode
== IMM
&& op_mode
!= IMM
)
1262 offsetT num
= operands
[i
].exp
.X_add_number
;
1263 if (op_mode
== KBIT
|| op_mode
== DBIT
)
1264 /* This is ok if the immediate value is sensible. */;
1265 else if (op_mode
== CONST_2
)
1267 else if (op_mode
== CONST_4
)
1269 else if (op_mode
== CONST_8
)
1271 else if (op_mode
== CONST_16
)
1276 else if (op_mode
== PCREL
&& op_mode
== x_mode
)
1278 /* movsd only comes in PCREL16 flavour:
1279 If x_size is L_8, promote it. */
1280 if (OP_KIND (this_try
->opcode
->how
) == O_MOVSD
)
1284 /* The size of the displacement is important. */
1285 if (op_size
!= x_size
)
1288 else if ((op_mode
== DISP
|| op_mode
== IMM
|| op_mode
== ABS
1289 || op_mode
== INDEXB
|| op_mode
== INDEXW
1290 || op_mode
== INDEXL
)
1291 && op_mode
== x_mode
)
1293 /* Promote a L_24 to L_32 if it makes us match. */
1294 if (x_size
== L_24
&& op_size
== L_32
)
1301 /* Promote an L8 to L_16 if it makes us match. */
1302 if ((op_mode
== ABS
|| op_mode
== DISP
) && x_size
== L_8
)
1304 if (op_size
== L_16
)
1309 if (((x_size
== L_16
&& op_size
== L_16U
)
1310 || (x_size
== L_3
&& op_size
== L_3NZ
))
1311 /* We're deliberately more permissive for ABS modes. */
1313 || constant_fits_size_p (operands
+ i
, op_size
,
1317 if (x_size
!= 0 && op_size
!= x_size
)
1319 else if (x_size
== 0
1320 && ! constant_fits_size_p (operands
+ i
, op_size
,
1324 else if (op_mode
!= x_mode
)
1332 if ((this_try
->opcode
->available
== AV_H8SX
&& ! SXmode
)
1333 || (this_try
->opcode
->available
== AV_H8S
&& ! Smode
)
1334 || (this_try
->opcode
->available
== AV_H8H
&& ! Hmode
))
1335 found
= 0, found_other
= this_try
;
1336 else if (this_size
!= size
&& (this_size
!= SN
&& size
!= SN
))
1337 found_mismatched
= this_try
, found
= 0;
1345 as_warn (_("Opcode `%s' with these operand types not available in %s mode"),
1346 found_other
->opcode
->name
,
1347 (! Hmode
&& ! Smode
? "H8/300"
1352 else if (found_mismatched
)
1354 as_warn (_("mismatch between opcode size and operand size"));
1355 return found_mismatched
;
1361 check_operand (operand
, width
, string
)
1362 struct h8_op
*operand
;
1366 if (operand
->exp
.X_add_symbol
== 0
1367 && operand
->exp
.X_op_symbol
== 0)
1369 /* No symbol involved, let's look at offset, it's dangerous if
1370 any of the high bits are not 0 or ff's, find out by oring or
1371 anding with the width and seeing if the answer is 0 or all
1374 if (! constant_fits_width_p (operand
, width
))
1377 && (operand
->exp
.X_add_number
& 0xff00) == 0xff00)
1379 /* Just ignore this one - which happens when trying to
1380 fit a 16 bit address truncated into an 8 bit address
1381 of something like bset. */
1383 else if (strcmp (string
, "@") == 0
1385 && (operand
->exp
.X_add_number
& 0xff8000) == 0xff8000)
1387 /* Just ignore this one - which happens when trying to
1388 fit a 24 bit address truncated into a 16 bit address
1389 of something like mov.w. */
1393 as_warn (_("operand %s0x%lx out of range."), string
,
1394 (unsigned long) operand
->exp
.X_add_number
);
1400 /* RELAXMODE has one of 3 values:
1402 0 Output a "normal" reloc, no relaxing possible for this insn/reloc
1404 1 Output a relaxable 24bit absolute mov.w address relocation
1405 (may relax into a 16bit absolute address).
1407 2 Output a relaxable 16/24 absolute mov.b address relocation
1408 (may relax into an 8bit absolute address). */
1411 do_a_fix_imm (offset
, nibble
, operand
, relaxmode
)
1413 struct h8_op
*operand
;
1419 char *bytes
= frag_now
->fr_literal
+ offset
;
1421 char *t
= ((operand
->mode
& MODE
) == IMM
) ? "#" : "@";
1423 if (operand
->exp
.X_add_symbol
== 0)
1425 switch (operand
->mode
& SIZE
)
1428 check_operand (operand
, 0x3, t
);
1429 bytes
[0] |= (operand
->exp
.X_add_number
& 3) << (nibble
? 0 : 4);
1433 check_operand (operand
, 0x7, t
);
1434 bytes
[0] |= (operand
->exp
.X_add_number
& 7) << (nibble
? 0 : 4);
1437 check_operand (operand
, 0xF, t
);
1438 bytes
[0] |= (operand
->exp
.X_add_number
& 15) << (nibble
? 0 : 4);
1441 check_operand (operand
, 0x1F, t
);
1442 bytes
[0] |= operand
->exp
.X_add_number
& 31;
1446 check_operand (operand
, 0xff, t
);
1447 bytes
[0] |= operand
->exp
.X_add_number
;
1451 check_operand (operand
, 0xffff, t
);
1452 bytes
[0] |= operand
->exp
.X_add_number
>> 8;
1453 bytes
[1] |= operand
->exp
.X_add_number
>> 0;
1456 check_operand (operand
, 0xffffff, t
);
1457 bytes
[0] |= operand
->exp
.X_add_number
>> 16;
1458 bytes
[1] |= operand
->exp
.X_add_number
>> 8;
1459 bytes
[2] |= operand
->exp
.X_add_number
>> 0;
1463 /* This should be done with bfd. */
1464 bytes
[0] |= operand
->exp
.X_add_number
>> 24;
1465 bytes
[1] |= operand
->exp
.X_add_number
>> 16;
1466 bytes
[2] |= operand
->exp
.X_add_number
>> 8;
1467 bytes
[3] |= operand
->exp
.X_add_number
>> 0;
1470 idx
= (relaxmode
== 2) ? R_MOV24B1
: R_MOVL1
;
1471 fix_new_exp (frag_now
, offset
, 4, &operand
->exp
, 0, idx
);
1478 switch (operand
->mode
& SIZE
)
1483 where
= (operand
->mode
& SIZE
) == L_24
? -1 : 0;
1486 else if (relaxmode
== 1)
1492 as_bad (_("Can't work out size of operand.\n"));
1501 operand
->exp
.X_add_number
=
1502 ((operand
->exp
.X_add_number
& 0xffff) ^ 0x8000) - 0x8000;
1503 operand
->exp
.X_add_number
|= (bytes
[0] << 8) | bytes
[1];
1509 operand
->exp
.X_add_number
=
1510 ((operand
->exp
.X_add_number
& 0xff) ^ 0x80) - 0x80;
1511 operand
->exp
.X_add_number
|= bytes
[0];
1514 fix_new_exp (frag_now
,
1523 /* Now we know what sort of opcodes it is, let's build the bytes. */
1526 build_bytes (this_try
, operand
)
1527 const struct h8_instruction
*this_try
;
1528 struct h8_op
*operand
;
1531 char *output
= frag_more (this_try
->length
);
1532 op_type
*nibble_ptr
= this_try
->opcode
->data
.nib
;
1534 unsigned int nibble_count
= 0;
1538 char asnibbles
[100];
1539 char *p
= asnibbles
;
1542 if (!Hmode
&& this_try
->opcode
->available
!= AV_H8
)
1543 as_warn (_("Opcode `%s' with these operand types not available in H8/300 mode"),
1544 this_try
->opcode
->name
);
1546 && this_try
->opcode
->available
!= AV_H8
1547 && this_try
->opcode
->available
!= AV_H8H
)
1548 as_warn (_("Opcode `%s' with these operand types not available in H8/300H mode"),
1549 this_try
->opcode
->name
);
1551 && this_try
->opcode
->available
!= AV_H8
1552 && this_try
->opcode
->available
!= AV_H8H
1553 && this_try
->opcode
->available
!= AV_H8S
)
1554 as_warn (_("Opcode `%s' with these operand types not available in H8/300S mode"),
1555 this_try
->opcode
->name
);
1557 while (*nibble_ptr
!= (op_type
) E
)
1564 d
= (c
& OP3
) == OP3
? 2 : (c
& DST
) == DST
? 1 : 0;
1572 if (c2
== REG
|| c2
== LOWREG
1573 || c2
== IND
|| c2
== PREINC
|| c2
== PREDEC
1574 || c2
== POSTINC
|| c2
== POSTDEC
)
1576 nib
= operand
[d
].reg
;
1581 else if (c
& CTRL
) /* Control reg operand. */
1582 nib
= operand
[d
].reg
;
1584 else if ((c
& DISPREG
) == (DISPREG
))
1586 nib
= operand
[d
].reg
;
1590 operand
[d
].mode
= c
;
1591 op_at
[d
] = nibble_count
;
1594 else if (c2
== IMM
|| c2
== PCREL
|| c2
== ABS
1595 || (c
& ABSJMP
) || c2
== DISP
)
1597 operand
[d
].mode
= c
;
1598 op_at
[d
] = nibble_count
;
1601 else if ((c
& IGNORE
) || (c
& DATA
))
1604 else if (c2
== DBIT
)
1606 switch (operand
[0].exp
.X_add_number
)
1615 as_bad (_("Need #1 or #2 here"));
1618 else if (c2
== KBIT
)
1620 switch (operand
[0].exp
.X_add_number
)
1630 as_warn (_("#4 not valid on H8/300."));
1635 as_bad (_("Need #1 or #2 here"));
1638 /* Stop it making a fix. */
1639 operand
[0].mode
= 0;
1643 operand
[d
].mode
|= MEMRELAX
;
1659 if (operand
[0].mode
== MACREG
)
1660 /* stmac has mac[hl] as the first operand. */
1661 nib
= 2 + operand
[0].reg
;
1663 /* ldmac has mac[hl] as the second operand. */
1664 nib
= 2 + operand
[1].reg
;
1672 /* Disgusting. Why, oh why didn't someone ask us for advice
1673 on the assembler format. */
1674 if (OP_KIND (this_try
->opcode
->how
) == O_LDM
)
1676 high
= (operand
[1].reg
>> 8) & 0xf;
1677 low
= (operand
[1].reg
) & 0xf;
1678 asnibbles
[2] = high
- low
;
1679 asnibbles
[7] = high
;
1681 else if (OP_KIND (this_try
->opcode
->how
) == O_STM
)
1683 high
= (operand
[0].reg
>> 8) & 0xf;
1684 low
= (operand
[0].reg
) & 0xf;
1685 asnibbles
[2] = high
- low
;
1689 for (i
= 0; i
< this_try
->length
; i
++)
1690 output
[i
] = (asnibbles
[i
* 2] << 4) | asnibbles
[i
* 2 + 1];
1692 /* Note if this is a movb instruction -- there's a special relaxation
1693 which only applies to them. */
1694 if (this_try
->opcode
->how
== O (O_MOV
, SB
))
1697 /* Output any fixes. */
1698 for (i
= 0; i
< this_try
->noperands
; i
++)
1700 int x
= operand
[i
].mode
;
1701 int x_mode
= x
& MODE
;
1703 if (x_mode
== IMM
|| x_mode
== DISP
)
1704 do_a_fix_imm (output
- frag_now
->fr_literal
+ op_at
[i
] / 2,
1705 op_at
[i
] & 1, operand
+ i
, (x
& MEMRELAX
) != 0);
1707 else if (x_mode
== ABS
)
1708 do_a_fix_imm (output
- frag_now
->fr_literal
+ op_at
[i
] / 2,
1709 op_at
[i
] & 1, operand
+ i
,
1710 (x
& MEMRELAX
) ? movb
+ 1 : 0);
1712 else if (x_mode
== PCREL
)
1714 int size16
= (x
& SIZE
) == L_16
;
1715 int size
= size16
? 2 : 1;
1716 int type
= size16
? R_PCRWORD
: R_PCRBYTE
;
1719 check_operand (operand
+ i
, size16
? 0x7fff : 0x7f, "@");
1721 if (operand
[i
].exp
.X_add_number
& 1)
1722 as_warn (_("branch operand has odd offset (%lx)\n"),
1723 (unsigned long) operand
->exp
.X_add_number
);
1725 /* The COFF port has always been off by one, changing it
1726 now would be an incompatible change, so we leave it as-is.
1728 We don't want to do this for ELF as we want to be
1729 compatible with the proposed ELF format from Hitachi. */
1730 operand
[i
].exp
.X_add_number
-= 1;
1734 operand
[i
].exp
.X_add_number
=
1735 ((operand
[i
].exp
.X_add_number
& 0xffff) ^ 0x8000) - 0x8000;
1739 operand
[i
].exp
.X_add_number
=
1740 ((operand
[i
].exp
.X_add_number
& 0xff) ^ 0x80) - 0x80;
1745 operand
[i
].exp
.X_add_number
|= output
[op_at
[i
] / 2];
1747 fixP
= fix_new_exp (frag_now
,
1748 output
- frag_now
->fr_literal
+ op_at
[i
] / 2,
1753 fixP
->fx_signed
= 1;
1755 else if (x_mode
== MEMIND
)
1757 check_operand (operand
+ i
, 0xff, "@@");
1758 fix_new_exp (frag_now
,
1759 output
- frag_now
->fr_literal
+ 1,
1765 else if (x_mode
== VECIND
)
1767 check_operand (operand
+ i
, 0x7f, "@@");
1768 /* FIXME: approximating the effect of "B31" here...
1769 This is very hackish, and ought to be done a better way. */
1770 operand
[i
].exp
.X_add_number
|= 0x80;
1771 fix_new_exp (frag_now
,
1772 output
- frag_now
->fr_literal
+ 1,
1778 else if (x
& ABSJMP
)
1781 bfd_reloc_code_real_type reloc_type
= R_JMPL1
;
1784 /* To be compatible with the proposed H8 ELF format, we
1785 want the relocation's offset to point to the first byte
1786 that will be modified, not to the start of the instruction. */
1788 if ((operand
->mode
& SIZE
) == L_32
)
1791 reloc_type
= R_RELLONG
;
1797 /* This jmp may be a jump or a branch. */
1799 check_operand (operand
+ i
,
1800 SXmode
? 0xffffffff : Hmode
? 0xffffff : 0xffff,
1803 if (operand
[i
].exp
.X_add_number
& 1)
1804 as_warn (_("branch operand has odd offset (%lx)\n"),
1805 (unsigned long) operand
->exp
.X_add_number
);
1808 operand
[i
].exp
.X_add_number
=
1809 ((operand
[i
].exp
.X_add_number
& 0xffff) ^ 0x8000) - 0x8000;
1810 fix_new_exp (frag_now
,
1811 output
- frag_now
->fr_literal
+ where
,
1820 /* Try to give an intelligent error message for common and simple to
1824 clever_message (instruction
, operand
)
1825 const struct h8_instruction
*instruction
;
1826 struct h8_op
*operand
;
1828 /* Find out if there was more than one possible opcode. */
1830 if ((instruction
+ 1)->idx
!= instruction
->idx
)
1834 /* Only one opcode of this flavour, try to guess which operand
1836 for (argn
= 0; argn
< instruction
->noperands
; argn
++)
1838 switch (instruction
->opcode
->args
.nib
[argn
])
1841 if (operand
[argn
].mode
!= RD16
)
1843 as_bad (_("destination operand must be 16 bit register"));
1850 if (operand
[argn
].mode
!= RS8
)
1852 as_bad (_("source operand must be 8 bit register"));
1858 if (operand
[argn
].mode
!= ABS16DST
)
1860 as_bad (_("destination operand must be 16bit absolute address"));
1865 if (operand
[argn
].mode
!= RD8
)
1867 as_bad (_("destination operand must be 8 bit register"));
1873 if (operand
[argn
].mode
!= ABS16SRC
)
1875 as_bad (_("source operand must be 16bit absolute address"));
1883 as_bad (_("invalid operands"));
1887 /* Adjust OPERAND's value and size given that it is accessing a field
1890 This function handles the choice between @(d:2,ERn) and @(d:16,ERn)
1891 when no size is explicitly given. It also scales down the assembly-level
1892 displacement in an @(d:2,ERn) operand. */
1895 fix_operand_size (operand
, size
)
1896 struct h8_op
*operand
;
1899 if ((operand
->mode
& MODE
) == DISP
)
1901 /* If the user didn't specify an operand width, see if we
1902 can use @(d:2,ERn). */
1904 && (operand
->mode
& SIZE
) == 0
1905 && (operand
->exp
.X_add_number
== size
1906 || operand
->exp
.X_add_number
== size
* 2
1907 || operand
->exp
.X_add_number
== size
* 3))
1908 operand
->mode
|= L_2
;
1910 /* Scale down the displacement in an @(d:2,ERn) operand.
1911 X_add_number then contains the desired field value. */
1912 if ((operand
->mode
& SIZE
) == L_2
)
1914 if (operand
->exp
.X_add_number
% size
!= 0)
1915 as_warn (_("operand/size mis-match"));
1916 operand
->exp
.X_add_number
/= size
;
1920 /* If the operand needs a size but doesn't have one yet, it must be
1921 a 16-bit integer (see colonmod24). */
1922 if ((operand
->mode
& SIZE
) == 0)
1923 switch (operand
->mode
& MODE
)
1930 operand
->mode
|= L_16
;
1936 /* This is the guts of the machine-dependent assembler. STR points to
1937 a machine dependent instruction. This function is supposed to emit
1938 the frags/bytes it assembles. */
1946 struct h8_op operand
[3];
1947 const struct h8_instruction
*instruction
;
1948 const struct h8_instruction
*prev_instruction
;
1954 /* Drop leading whitespace. */
1958 /* Find the op code end. */
1959 for (op_start
= op_end
= str
;
1960 *op_end
!= 0 && *op_end
!= ' ';
1972 if (op_end
== op_start
)
1974 as_bad (_("can't find opcode "));
1980 instruction
= (const struct h8_instruction
*)
1981 hash_find (opcode_hash_control
, op_start
);
1983 if (instruction
== NULL
)
1985 as_bad (_("unknown opcode"));
1989 /* We used to set input_line_pointer to the result of get_operands,
1990 but that is wrong. Our caller assumes we don't change it. */
1992 operand
[0].mode
= 0;
1993 operand
[1].mode
= 0;
1994 operand
[2].mode
= 0;
1996 if (OP_KIND (instruction
->opcode
->how
) == O_MOVAB
1997 || OP_KIND (instruction
->opcode
->how
) == O_MOVAW
1998 || OP_KIND (instruction
->opcode
->how
) == O_MOVAL
)
1999 get_mova_operands (op_end
, operand
);
2000 else if (OP_KIND (instruction
->opcode
->how
) == O_RTEL
2001 || OP_KIND (instruction
->opcode
->how
) == O_RTSL
)
2002 get_rtsl_operands (op_end
, operand
);
2004 get_operands (instruction
->noperands
, op_end
, operand
);
2007 prev_instruction
= instruction
;
2027 if (OP_KIND (instruction
->opcode
->how
) == O_MOVAB
||
2028 OP_KIND (instruction
->opcode
->how
) == O_MOVAW
||
2029 OP_KIND (instruction
->opcode
->how
) == O_MOVAL
)
2031 switch (operand
[0].mode
& MODE
)
2035 fix_operand_size (&operand
[1], 1);
2038 fix_operand_size (&operand
[1], 2);
2041 fix_operand_size (&operand
[1], 4);
2047 for (i
= 0; i
< 3 && operand
[i
].mode
!= 0; i
++)
2053 fix_operand_size (&operand
[i
], 1);
2056 fix_operand_size (&operand
[i
], 2);
2059 fix_operand_size (&operand
[i
], 4);
2064 instruction
= get_specific (instruction
, operand
, size
);
2066 if (instruction
== 0)
2068 /* Couldn't find an opcode which matched the operands. */
2069 char *where
= frag_more (2);
2073 clever_message (prev_instruction
, operand
);
2078 build_bytes (instruction
, operand
);
2080 #ifdef BFD_ASSEMBLER
2081 dwarf2_emit_insn (instruction
->length
);
2085 #ifndef BFD_ASSEMBLER
2087 tc_crawl_symbol_chain (headers
)
2088 object_headers
*headers ATTRIBUTE_UNUSED
;
2090 printf (_("call to tc_crawl_symbol_chain \n"));
2095 md_undefined_symbol (name
)
2096 char *name ATTRIBUTE_UNUSED
;
2101 #ifndef BFD_ASSEMBLER
2103 tc_headers_hook (headers
)
2104 object_headers
*headers ATTRIBUTE_UNUSED
;
2106 printf (_("call to tc_headers_hook \n"));
2110 /* Various routines to kill one day */
2111 /* Equal to MAX_PRECISION in atof-ieee.c */
2112 #define MAX_LITTLENUMS 6
2114 /* Turn a string in input_line_pointer into a floating point constant
2115 of type TYPE, and store the appropriate bytes in *LITP. The number
2116 of LITTLENUMS emitted is stored in *SIZEP. An error message is
2117 returned, or NULL on OK. */
2120 md_atof (type
, litP
, sizeP
)
2126 LITTLENUM_TYPE words
[MAX_LITTLENUMS
];
2127 LITTLENUM_TYPE
*wordP
;
2158 return _("Bad call to MD_ATOF()");
2160 t
= atof_ieee (input_line_pointer
, type
, words
);
2162 input_line_pointer
= t
;
2164 *sizeP
= prec
* sizeof (LITTLENUM_TYPE
);
2165 for (wordP
= words
; prec
--;)
2167 md_number_to_chars (litP
, (long) (*wordP
++), sizeof (LITTLENUM_TYPE
));
2168 litP
+= sizeof (LITTLENUM_TYPE
);
2173 const char *md_shortopts
= "";
2174 struct option md_longopts
[] = {
2175 {NULL
, no_argument
, NULL
, 0}
2178 size_t md_longopts_size
= sizeof (md_longopts
);
2181 md_parse_option (c
, arg
)
2182 int c ATTRIBUTE_UNUSED
;
2183 char *arg ATTRIBUTE_UNUSED
;
2189 md_show_usage (stream
)
2190 FILE *stream ATTRIBUTE_UNUSED
;
2194 void tc_aout_fix_to_chars
PARAMS ((void));
2197 tc_aout_fix_to_chars ()
2199 printf (_("call to tc_aout_fix_to_chars \n"));
2204 md_convert_frag (headers
, seg
, fragP
)
2205 #ifdef BFD_ASSEMBLER
2206 bfd
*headers ATTRIBUTE_UNUSED
;
2208 object_headers
*headers ATTRIBUTE_UNUSED
;
2210 segT seg ATTRIBUTE_UNUSED
;
2211 fragS
*fragP ATTRIBUTE_UNUSED
;
2213 printf (_("call to md_convert_frag \n"));
2217 #ifdef BFD_ASSEMBLER
2219 md_section_align (segment
, size
)
2223 int align
= bfd_get_section_alignment (stdoutput
, segment
);
2224 return ((size
+ (1 << align
) - 1) & (-1 << align
));
2228 md_section_align (seg
, size
)
2232 return ((size
+ (1 << section_alignment
[(int) seg
]) - 1)
2233 & (-1 << section_alignment
[(int) seg
]));
2239 md_apply_fix3 (fixP
, valP
, seg
)
2242 segT seg ATTRIBUTE_UNUSED
;
2244 char *buf
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
2247 switch (fixP
->fx_size
)
2253 *buf
++ = (val
>> 8);
2257 *buf
++ = (val
>> 24);
2258 *buf
++ = (val
>> 16);
2259 *buf
++ = (val
>> 8);
2266 if (fixP
->fx_addsy
== NULL
&& fixP
->fx_pcrel
== 0)
2271 md_estimate_size_before_relax (fragP
, segment_type
)
2272 register fragS
*fragP ATTRIBUTE_UNUSED
;
2273 register segT segment_type ATTRIBUTE_UNUSED
;
2275 printf (_("call tomd_estimate_size_before_relax \n"));
2279 /* Put number into target byte order. */
2281 md_number_to_chars (ptr
, use
, nbytes
)
2286 number_to_chars_bigendian (ptr
, use
, nbytes
);
2290 md_pcrel_from (fixP
)
2291 fixS
*fixP ATTRIBUTE_UNUSED
;
2296 #ifndef BFD_ASSEMBLER
2298 tc_reloc_mangle (fix_ptr
, intr
, base
)
2300 struct internal_reloc
*intr
;
2304 symbolS
*symbol_ptr
;
2306 symbol_ptr
= fix_ptr
->fx_addsy
;
2308 /* If this relocation is attached to a symbol then it's ok
2310 if (fix_ptr
->fx_r_type
== TC_CONS_RELOC
)
2312 /* cons likes to create reloc32's whatever the size of the reloc..
2314 switch (fix_ptr
->fx_size
)
2317 intr
->r_type
= R_RELLONG
;
2320 intr
->r_type
= R_RELWORD
;
2323 intr
->r_type
= R_RELBYTE
;
2331 intr
->r_type
= fix_ptr
->fx_r_type
;
2334 intr
->r_vaddr
= fix_ptr
->fx_frag
->fr_address
+ fix_ptr
->fx_where
+ base
;
2335 intr
->r_offset
= fix_ptr
->fx_offset
;
2339 if (symbol_ptr
->sy_number
!= -1)
2340 intr
->r_symndx
= symbol_ptr
->sy_number
;
2345 /* This case arises when a reference is made to `.'. */
2346 segsym
= seg_info (S_GET_SEGMENT (symbol_ptr
))->dot
;
2348 intr
->r_symndx
= -1;
2351 intr
->r_symndx
= segsym
->sy_number
;
2352 intr
->r_offset
+= S_GET_VALUE (symbol_ptr
);
2357 intr
->r_symndx
= -1;
2359 #else /* BFD_ASSEMBLER */
2361 tc_gen_reloc (section
, fixp
)
2362 asection
*section ATTRIBUTE_UNUSED
;
2366 bfd_reloc_code_real_type r_type
;
2368 if (fixp
->fx_addsy
&& fixp
->fx_subsy
)
2370 if ((S_GET_SEGMENT (fixp
->fx_addsy
) != S_GET_SEGMENT (fixp
->fx_subsy
))
2371 || S_GET_SEGMENT (fixp
->fx_addsy
) == undefined_section
)
2373 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2374 "Difference of symbols in different sections is not supported");
2379 rel
= (arelent
*) xmalloc (sizeof (arelent
));
2380 rel
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
2381 *rel
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
2382 rel
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
2383 rel
->addend
= fixp
->fx_offset
;
2385 r_type
= fixp
->fx_r_type
;
2389 fprintf (stderr
, "%s\n", bfd_get_reloc_code_name (r_type
));
2392 rel
->howto
= bfd_reloc_type_lookup (stdoutput
, r_type
);
2393 if (rel
->howto
== NULL
)
2395 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2396 _("Cannot represent relocation type %s"),
2397 bfd_get_reloc_code_name (r_type
));