1 /* tc-mn10300.c -- Assembler code for the Matsushita 10300
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
3 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
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
24 #include "safe-ctype.h"
26 #include "opcode/mn10300.h"
27 #include "dwarf2dbg.h"
29 /* Structure to hold information about predefined registers. */
36 /* Generic assembler global variables which must be defined by all
39 /* Characters which always start a comment. */
40 const char comment_chars
[] = "#";
42 /* Characters which start a comment at the beginning of a line. */
43 const char line_comment_chars
[] = ";#";
45 /* Characters which may be used to separate multiple commands on a
47 const char line_separator_chars
[] = ";";
49 /* Characters which are used to indicate an exponent in a floating
51 const char EXP_CHARS
[] = "eE";
53 /* Characters which mean that a number is a floating point constant,
55 const char FLT_CHARS
[] = "dD";
57 const relax_typeS md_relax_table
[] = {
60 {0x7fff, -0x8000, 5, 2},
61 {0x7fffffff, -0x80000000, 7, 0},
63 /* bCC relaxing (uncommon cases) */
65 {0x7fff, -0x8000, 6, 5},
66 {0x7fffffff, -0x80000000, 8, 0},
69 {0x7fff, -0x8000, 5, 7},
70 {0x7fffffff, -0x80000000, 7, 0},
73 {0x7fff, -0x8000, 4, 9},
74 {0x7fffffff, -0x80000000, 6, 0},
78 {0x7fff, -0x8000, 3, 12},
79 {0x7fffffff, -0x80000000, 5, 0},
83 {0x7fff, -0x8000, 6, 15},
84 {0x7fffffff, -0x80000000, 8, 0},
88 /* Local functions. */
89 static void mn10300_insert_operand
PARAMS ((unsigned long *, unsigned long *,
90 const struct mn10300_operand
*,
91 offsetT
, char *, unsigned,
93 static unsigned long check_operand
PARAMS ((unsigned long,
94 const struct mn10300_operand
*,
96 static int reg_name_search
PARAMS ((const struct reg_name
*, int, const char *));
97 static bfd_boolean data_register_name
PARAMS ((expressionS
*expressionP
));
98 static bfd_boolean address_register_name
PARAMS ((expressionS
*expressionP
));
99 static bfd_boolean other_register_name
PARAMS ((expressionS
*expressionP
));
100 static bfd_boolean r_register_name
PARAMS ((expressionS
*expressionP
));
101 static bfd_boolean xr_register_name
PARAMS ((expressionS
*expressionP
));
102 static void set_arch_mach
PARAMS ((int));
104 /* Set linkrelax here to avoid fixups in most sections. */
107 static int current_machine
;
110 #define MAX_INSN_FIXUPS (5)
115 bfd_reloc_code_real_type reloc
;
117 struct mn10300_fixup fixups
[MAX_INSN_FIXUPS
];
120 /* We must store the value of each register operand so that we can
121 verify that certain registers do not match. */
122 int mn10300_reg_operands
[MN10300_MAX_OPERANDS
];
124 const char *md_shortopts
= "";
125 struct option md_longopts
[] = {
126 {NULL
, no_argument
, NULL
, 0}
128 size_t md_longopts_size
= sizeof (md_longopts
);
130 /* The target specific pseudo-ops which we support. */
131 const pseudo_typeS md_pseudo_table
[] =
133 { "am30", set_arch_mach
, AM30
},
134 { "am33", set_arch_mach
, AM33
},
135 { "am33_2", (void (*) PARAMS ((int))) set_arch_mach
, AM33_2
},
136 { "mn10300", set_arch_mach
, MN103
},
140 #define HAVE_AM33_2 (current_machine == AM33_2)
141 #define HAVE_AM33 (current_machine == AM33 || HAVE_AM33_2)
142 #define HAVE_AM30 (current_machine == AM30)
144 /* Opcode hash table. */
145 static struct hash_control
*mn10300_hash
;
147 /* This table is sorted. Suitable for searching by a binary search. */
148 static const struct reg_name data_registers
[] =
155 #define DATA_REG_NAME_CNT \
156 (sizeof (data_registers) / sizeof (struct reg_name))
158 static const struct reg_name address_registers
[] =
166 #define ADDRESS_REG_NAME_CNT \
167 (sizeof (address_registers) / sizeof (struct reg_name))
169 static const struct reg_name r_registers
[] =
213 #define R_REG_NAME_CNT \
214 (sizeof (r_registers) / sizeof (struct reg_name))
216 static const struct reg_name xr_registers
[] =
241 #define XR_REG_NAME_CNT \
242 (sizeof (xr_registers) / sizeof (struct reg_name))
244 /* We abuse the `value' field, that would be otherwise unused, to
245 encode the architecture on which (access to) the register was
246 introduced. FIXME: we should probably warn when we encounter a
247 register name when assembling for an architecture that doesn't
248 support it, before parsing it as a symbol name. */
249 static const struct reg_name other_registers
[] =
258 #define OTHER_REG_NAME_CNT \
259 (sizeof (other_registers) / sizeof (struct reg_name))
261 static const struct reg_name float_registers
[] =
297 #define FLOAT_REG_NAME_CNT \
298 (sizeof (float_registers) / sizeof (struct reg_name))
300 static const struct reg_name double_registers
[] =
320 #define DOUBLE_REG_NAME_CNT \
321 (sizeof (double_registers) / sizeof (struct reg_name))
324 /* reg_name_search does a binary search of the given register table
325 to see if "name" is a valid regiter name. Returns the register
326 number from the array on success, or -1 on failure. */
329 reg_name_search (regs
, regcount
, name
)
330 const struct reg_name
*regs
;
334 int middle
, low
, high
;
342 middle
= (low
+ high
) / 2;
343 cmp
= strcasecmp (name
, regs
[middle
].name
);
349 return regs
[middle
].value
;
355 /* Summary of register_name().
357 * in: Input_line_pointer points to 1st char of operand.
359 * out: An expressionS.
360 * The operand may have been a register: in this case, X_op == O_register,
361 * X_add_number is set to the register number, and truth is returned.
362 * Input_line_pointer->(next non-blank) char after operand, or is in
363 * its original state.
367 r_register_name (expressionP
)
368 expressionS
*expressionP
;
375 /* Find the spelling of the operand. */
376 start
= name
= input_line_pointer
;
378 c
= get_symbol_end ();
379 reg_number
= reg_name_search (r_registers
, R_REG_NAME_CNT
, name
);
381 /* Put back the delimiting char. */
382 *input_line_pointer
= c
;
384 /* Look to see if it's in the register table. */
387 expressionP
->X_op
= O_register
;
388 expressionP
->X_add_number
= reg_number
;
390 /* Make the rest nice. */
391 expressionP
->X_add_symbol
= NULL
;
392 expressionP
->X_op_symbol
= NULL
;
397 /* Reset the line as if we had not done anything. */
398 input_line_pointer
= start
;
402 /* Summary of register_name().
404 * in: Input_line_pointer points to 1st char of operand.
406 * out: An expressionS.
407 * The operand may have been a register: in this case, X_op == O_register,
408 * X_add_number is set to the register number, and truth is returned.
409 * Input_line_pointer->(next non-blank) char after operand, or is in
410 * its original state.
414 xr_register_name (expressionP
)
415 expressionS
*expressionP
;
422 /* Find the spelling of the operand. */
423 start
= name
= input_line_pointer
;
425 c
= get_symbol_end ();
426 reg_number
= reg_name_search (xr_registers
, XR_REG_NAME_CNT
, name
);
428 /* Put back the delimiting char. */
429 *input_line_pointer
= c
;
431 /* Look to see if it's in the register table. */
434 expressionP
->X_op
= O_register
;
435 expressionP
->X_add_number
= reg_number
;
437 /* Make the rest nice. */
438 expressionP
->X_add_symbol
= NULL
;
439 expressionP
->X_op_symbol
= NULL
;
444 /* Reset the line as if we had not done anything. */
445 input_line_pointer
= start
;
449 /* Summary of register_name().
451 * in: Input_line_pointer points to 1st char of operand.
453 * out: An expressionS.
454 * The operand may have been a register: in this case, X_op == O_register,
455 * X_add_number is set to the register number, and truth is returned.
456 * Input_line_pointer->(next non-blank) char after operand, or is in
457 * its original state.
461 data_register_name (expressionP
)
462 expressionS
*expressionP
;
469 /* Find the spelling of the operand. */
470 start
= name
= input_line_pointer
;
472 c
= get_symbol_end ();
473 reg_number
= reg_name_search (data_registers
, DATA_REG_NAME_CNT
, name
);
475 /* Put back the delimiting char. */
476 *input_line_pointer
= c
;
478 /* Look to see if it's in the register table. */
481 expressionP
->X_op
= O_register
;
482 expressionP
->X_add_number
= reg_number
;
484 /* Make the rest nice. */
485 expressionP
->X_add_symbol
= NULL
;
486 expressionP
->X_op_symbol
= NULL
;
491 /* Reset the line as if we had not done anything. */
492 input_line_pointer
= start
;
496 /* Summary of register_name().
498 * in: Input_line_pointer points to 1st char of operand.
500 * out: An expressionS.
501 * The operand may have been a register: in this case, X_op == O_register,
502 * X_add_number is set to the register number, and truth is returned.
503 * Input_line_pointer->(next non-blank) char after operand, or is in
504 * its original state.
508 address_register_name (expressionP
)
509 expressionS
*expressionP
;
516 /* Find the spelling of the operand. */
517 start
= name
= input_line_pointer
;
519 c
= get_symbol_end ();
520 reg_number
= reg_name_search (address_registers
, ADDRESS_REG_NAME_CNT
, name
);
522 /* Put back the delimiting char. */
523 *input_line_pointer
= c
;
525 /* Look to see if it's in the register table. */
528 expressionP
->X_op
= O_register
;
529 expressionP
->X_add_number
= reg_number
;
531 /* Make the rest nice. */
532 expressionP
->X_add_symbol
= NULL
;
533 expressionP
->X_op_symbol
= NULL
;
538 /* Reset the line as if we had not done anything. */
539 input_line_pointer
= start
;
543 /* Summary of register_name().
545 * in: Input_line_pointer points to 1st char of operand.
547 * out: An expressionS.
548 * The operand may have been a register: in this case, X_op == O_register,
549 * X_add_number is set to the register number, and truth is returned.
550 * Input_line_pointer->(next non-blank) char after operand, or is in
551 * its original state.
555 other_register_name (expressionP
)
556 expressionS
*expressionP
;
563 /* Find the spelling of the operand. */
564 start
= name
= input_line_pointer
;
566 c
= get_symbol_end ();
567 reg_number
= reg_name_search (other_registers
, OTHER_REG_NAME_CNT
, name
);
569 /* Put back the delimiting char. */
570 *input_line_pointer
= c
;
572 /* Look to see if it's in the register table. */
574 || (reg_number
== AM33
&& HAVE_AM33
))
576 expressionP
->X_op
= O_register
;
577 expressionP
->X_add_number
= 0;
579 /* Make the rest nice. */
580 expressionP
->X_add_symbol
= NULL
;
581 expressionP
->X_op_symbol
= NULL
;
586 /* Reset the line as if we had not done anything. */
587 input_line_pointer
= start
;
591 static bfd_boolean double_register_name
PARAMS ((expressionS
*));
592 static bfd_boolean float_register_name
PARAMS ((expressionS
*));
594 /* Summary of float_register_name:
596 in: Input_line_pointer points to 1st char of operand.
599 The operand may have been a register: in this case, X_op == O_register,
600 X_add_number is set to the register number, and truth is returned.
601 Input_line_pointer->(next non-blank) char after operand, or is in
602 its original state. */
605 float_register_name (expressionP
)
606 expressionS
*expressionP
;
613 /* Find the spelling of the operand. */
614 start
= name
= input_line_pointer
;
616 c
= get_symbol_end ();
617 reg_number
= reg_name_search (float_registers
, FLOAT_REG_NAME_CNT
, name
);
619 /* Put back the delimiting char. */
620 * input_line_pointer
= c
;
622 /* Look to see if it's in the register table. */
625 expressionP
->X_op
= O_register
;
626 expressionP
->X_add_number
= reg_number
;
628 /* Make the rest nice. */
629 expressionP
->X_add_symbol
= NULL
;
630 expressionP
->X_op_symbol
= NULL
;
635 /* Reset the line as if we had not done anything. */
636 input_line_pointer
= start
;
640 /* Summary of double_register_name:
642 in: Input_line_pointer points to 1st char of operand.
645 The operand may have been a register: in this case, X_op == O_register,
646 X_add_number is set to the register number, and truth is returned.
647 Input_line_pointer->(next non-blank) char after operand, or is in
648 its original state. */
651 double_register_name (expressionP
)
652 expressionS
*expressionP
;
659 /* Find the spelling of the operand. */
660 start
= name
= input_line_pointer
;
662 c
= get_symbol_end ();
663 reg_number
= reg_name_search (double_registers
, DOUBLE_REG_NAME_CNT
, name
);
665 /* Put back the delimiting char. */
666 * input_line_pointer
= c
;
668 /* Look to see if it's in the register table. */
671 expressionP
->X_op
= O_register
;
672 expressionP
->X_add_number
= reg_number
;
674 /* Make the rest nice. */
675 expressionP
->X_add_symbol
= NULL
;
676 expressionP
->X_op_symbol
= NULL
;
681 /* Reset the line as if we had not done anything. */
682 input_line_pointer
= start
;
687 md_show_usage (stream
)
690 fprintf (stream
, _("MN10300 options:\n\
695 md_parse_option (c
, arg
)
696 int c ATTRIBUTE_UNUSED
;
697 char *arg ATTRIBUTE_UNUSED
;
703 md_undefined_symbol (name
)
704 char *name ATTRIBUTE_UNUSED
;
710 md_atof (type
, litp
, sizep
)
716 LITTLENUM_TYPE words
[4];
732 return "bad call to md_atof";
735 t
= atof_ieee (input_line_pointer
, type
, words
);
737 input_line_pointer
= t
;
741 for (i
= prec
- 1; i
>= 0; i
--)
743 md_number_to_chars (litp
, (valueT
) words
[i
], 2);
751 md_convert_frag (abfd
, sec
, fragP
)
752 bfd
*abfd ATTRIBUTE_UNUSED
;
756 static unsigned long label_count
= 0;
759 subseg_change (sec
, 0);
760 if (fragP
->fr_subtype
== 0)
762 fix_new (fragP
, fragP
->fr_fix
+ 1, 1, fragP
->fr_symbol
,
763 fragP
->fr_offset
+ 1, 1, BFD_RELOC_8_PCREL
);
767 else if (fragP
->fr_subtype
== 1)
769 /* Reverse the condition of the first branch. */
770 int offset
= fragP
->fr_fix
;
771 int opcode
= fragP
->fr_literal
[offset
] & 0xff;
808 fragP
->fr_literal
[offset
] = opcode
;
810 /* Create a fixup for the reversed conditional branch. */
811 sprintf (buf
, ".%s_%ld", FAKE_LABEL_NAME
, label_count
++);
812 fix_new (fragP
, fragP
->fr_fix
+ 1, 1,
813 symbol_new (buf
, sec
, 0, fragP
->fr_next
),
814 fragP
->fr_offset
+ 1, 1, BFD_RELOC_8_PCREL
);
816 /* Now create the unconditional branch + fixup to the
818 fragP
->fr_literal
[offset
+ 2] = 0xcc;
819 fix_new (fragP
, fragP
->fr_fix
+ 3, 2, fragP
->fr_symbol
,
820 fragP
->fr_offset
+ 1, 1, BFD_RELOC_16_PCREL
);
824 else if (fragP
->fr_subtype
== 2)
826 /* Reverse the condition of the first branch. */
827 int offset
= fragP
->fr_fix
;
828 int opcode
= fragP
->fr_literal
[offset
] & 0xff;
865 fragP
->fr_literal
[offset
] = opcode
;
867 /* Create a fixup for the reversed conditional branch. */
868 sprintf (buf
, ".%s_%ld", FAKE_LABEL_NAME
, label_count
++);
869 fix_new (fragP
, fragP
->fr_fix
+ 1, 1,
870 symbol_new (buf
, sec
, 0, fragP
->fr_next
),
871 fragP
->fr_offset
+ 1, 1, BFD_RELOC_8_PCREL
);
873 /* Now create the unconditional branch + fixup to the
875 fragP
->fr_literal
[offset
+ 2] = 0xdc;
876 fix_new (fragP
, fragP
->fr_fix
+ 3, 4, fragP
->fr_symbol
,
877 fragP
->fr_offset
+ 1, 1, BFD_RELOC_32_PCREL
);
881 else if (fragP
->fr_subtype
== 3)
883 fix_new (fragP
, fragP
->fr_fix
+ 2, 1, fragP
->fr_symbol
,
884 fragP
->fr_offset
+ 2, 1, BFD_RELOC_8_PCREL
);
888 else if (fragP
->fr_subtype
== 4)
890 /* Reverse the condition of the first branch. */
891 int offset
= fragP
->fr_fix
;
892 int opcode
= fragP
->fr_literal
[offset
+ 1] & 0xff;
911 fragP
->fr_literal
[offset
+ 1] = opcode
;
913 /* Create a fixup for the reversed conditional branch. */
914 sprintf (buf
, ".%s_%ld", FAKE_LABEL_NAME
, label_count
++);
915 fix_new (fragP
, fragP
->fr_fix
+ 2, 1,
916 symbol_new (buf
, sec
, 0, fragP
->fr_next
),
917 fragP
->fr_offset
+ 2, 1, BFD_RELOC_8_PCREL
);
919 /* Now create the unconditional branch + fixup to the
921 fragP
->fr_literal
[offset
+ 3] = 0xcc;
922 fix_new (fragP
, fragP
->fr_fix
+ 4, 2, fragP
->fr_symbol
,
923 fragP
->fr_offset
+ 1, 1, BFD_RELOC_16_PCREL
);
927 else if (fragP
->fr_subtype
== 5)
929 /* Reverse the condition of the first branch. */
930 int offset
= fragP
->fr_fix
;
931 int opcode
= fragP
->fr_literal
[offset
+ 1] & 0xff;
947 fragP
->fr_literal
[offset
+ 1] = opcode
;
949 /* Create a fixup for the reversed conditional branch. */
950 sprintf (buf
, ".%s_%ld", FAKE_LABEL_NAME
, label_count
++);
951 fix_new (fragP
, fragP
->fr_fix
+ 2, 1,
952 symbol_new (buf
, sec
, 0, fragP
->fr_next
),
953 fragP
->fr_offset
+ 2, 1, BFD_RELOC_8_PCREL
);
955 /* Now create the unconditional branch + fixup to the
957 fragP
->fr_literal
[offset
+ 3] = 0xdc;
958 fix_new (fragP
, fragP
->fr_fix
+ 4, 4, fragP
->fr_symbol
,
959 fragP
->fr_offset
+ 1, 1, BFD_RELOC_32_PCREL
);
963 else if (fragP
->fr_subtype
== 6)
965 int offset
= fragP
->fr_fix
;
966 fragP
->fr_literal
[offset
] = 0xcd;
967 fix_new (fragP
, fragP
->fr_fix
+ 1, 2, fragP
->fr_symbol
,
968 fragP
->fr_offset
+ 1, 1, BFD_RELOC_16_PCREL
);
972 else if (fragP
->fr_subtype
== 7)
974 int offset
= fragP
->fr_fix
;
975 fragP
->fr_literal
[offset
] = 0xdd;
976 fragP
->fr_literal
[offset
+ 5] = fragP
->fr_literal
[offset
+ 3];
977 fragP
->fr_literal
[offset
+ 6] = fragP
->fr_literal
[offset
+ 4];
979 fix_new (fragP
, fragP
->fr_fix
+ 1, 4, fragP
->fr_symbol
,
980 fragP
->fr_offset
+ 1, 1, BFD_RELOC_32_PCREL
);
984 else if (fragP
->fr_subtype
== 8)
986 int offset
= fragP
->fr_fix
;
987 fragP
->fr_literal
[offset
] = 0xfa;
988 fragP
->fr_literal
[offset
+ 1] = 0xff;
989 fix_new (fragP
, fragP
->fr_fix
+ 2, 2, fragP
->fr_symbol
,
990 fragP
->fr_offset
+ 2, 1, BFD_RELOC_16_PCREL
);
994 else if (fragP
->fr_subtype
== 9)
996 int offset
= fragP
->fr_fix
;
997 fragP
->fr_literal
[offset
] = 0xfc;
998 fragP
->fr_literal
[offset
+ 1] = 0xff;
1000 fix_new (fragP
, fragP
->fr_fix
+ 2, 4, fragP
->fr_symbol
,
1001 fragP
->fr_offset
+ 2, 1, BFD_RELOC_32_PCREL
);
1005 else if (fragP
->fr_subtype
== 10)
1007 fragP
->fr_literal
[fragP
->fr_fix
] = 0xca;
1008 fix_new (fragP
, fragP
->fr_fix
+ 1, 1, fragP
->fr_symbol
,
1009 fragP
->fr_offset
+ 1, 1, BFD_RELOC_8_PCREL
);
1013 else if (fragP
->fr_subtype
== 11)
1015 int offset
= fragP
->fr_fix
;
1016 fragP
->fr_literal
[offset
] = 0xcc;
1018 fix_new (fragP
, fragP
->fr_fix
+ 1, 4, fragP
->fr_symbol
,
1019 fragP
->fr_offset
+ 1, 1, BFD_RELOC_16_PCREL
);
1023 else if (fragP
->fr_subtype
== 12)
1025 int offset
= fragP
->fr_fix
;
1026 fragP
->fr_literal
[offset
] = 0xdc;
1028 fix_new (fragP
, fragP
->fr_fix
+ 1, 4, fragP
->fr_symbol
,
1029 fragP
->fr_offset
+ 1, 1, BFD_RELOC_32_PCREL
);
1033 else if (fragP
->fr_subtype
== 13)
1035 fix_new (fragP
, fragP
->fr_fix
+ 2, 1, fragP
->fr_symbol
,
1036 fragP
->fr_offset
+ 2, 1, BFD_RELOC_8_PCREL
);
1040 else if (fragP
->fr_subtype
== 14)
1042 /* Reverse the condition of the first branch. */
1043 int offset
= fragP
->fr_fix
;
1044 int opcode
= fragP
->fr_literal
[offset
+ 1] & 0xff;
1093 fragP
->fr_literal
[offset
+ 1] = opcode
;
1095 /* Create a fixup for the reversed conditional branch. */
1096 sprintf (buf
, ".%s_%ld", FAKE_LABEL_NAME
, label_count
++);
1097 fix_new (fragP
, fragP
->fr_fix
+ 2, 1,
1098 symbol_new (buf
, sec
, 0, fragP
->fr_next
),
1099 fragP
->fr_offset
+ 2, 1, BFD_RELOC_8_PCREL
);
1101 /* Now create the unconditional branch + fixup to the
1103 fragP
->fr_literal
[offset
+ 3] = 0xcc;
1104 fix_new (fragP
, fragP
->fr_fix
+ 4, 2, fragP
->fr_symbol
,
1105 fragP
->fr_offset
+ 1, 1, BFD_RELOC_16_PCREL
);
1109 else if (fragP
->fr_subtype
== 15)
1111 /* Reverse the condition of the first branch. */
1112 int offset
= fragP
->fr_fix
;
1113 int opcode
= fragP
->fr_literal
[offset
+ 1] & 0xff;
1162 fragP
->fr_literal
[offset
+ 1] = opcode
;
1164 /* Create a fixup for the reversed conditional branch. */
1165 sprintf (buf
, ".%s_%ld", FAKE_LABEL_NAME
, label_count
++);
1166 fix_new (fragP
, fragP
->fr_fix
+ 2, 1,
1167 symbol_new (buf
, sec
, 0, fragP
->fr_next
),
1168 fragP
->fr_offset
+ 2, 1, BFD_RELOC_8_PCREL
);
1170 /* Now create the unconditional branch + fixup to the
1172 fragP
->fr_literal
[offset
+ 3] = 0xdc;
1173 fix_new (fragP
, fragP
->fr_fix
+ 4, 4, fragP
->fr_symbol
,
1174 fragP
->fr_offset
+ 1, 1, BFD_RELOC_32_PCREL
);
1183 md_section_align (seg
, addr
)
1187 int align
= bfd_get_section_alignment (stdoutput
, seg
);
1188 return ((addr
+ (1 << align
) - 1) & (-1 << align
));
1194 char *prev_name
= "";
1195 register const struct mn10300_opcode
*op
;
1197 mn10300_hash
= hash_new ();
1199 /* Insert unique names into hash table. The MN10300 instruction set
1200 has many identical opcode names that have different opcodes based
1201 on the operands. This hash table then provides a quick index to
1202 the first opcode with a particular name in the opcode table. */
1204 op
= mn10300_opcodes
;
1207 if (strcmp (prev_name
, op
->name
))
1209 prev_name
= (char *) op
->name
;
1210 hash_insert (mn10300_hash
, op
->name
, (char *) op
);
1215 /* Set the default machine type. */
1217 if (!bfd_set_arch_mach (stdoutput
, bfd_arch_mn10300
, AM33_2
))
1218 as_warn (_("could not set architecture and machine"));
1220 current_machine
= AM33_2
;
1222 if (!bfd_set_arch_mach (stdoutput
, bfd_arch_mn10300
, MN103
))
1223 as_warn (_("could not set architecture and machine"));
1225 current_machine
= MN103
;
1229 static symbolS
*GOT_symbol
;
1231 static inline int mn10300_check_fixup
PARAMS ((struct mn10300_fixup
*));
1232 static inline int mn10300_PIC_related_p
PARAMS ((symbolS
*));
1235 mn10300_PIC_related_p (sym
)
1243 if (sym
== GOT_symbol
)
1246 exp
= symbol_get_value_expression (sym
);
1248 return (exp
->X_op
== O_PIC_reloc
1249 || mn10300_PIC_related_p (exp
->X_add_symbol
)
1250 || mn10300_PIC_related_p (exp
->X_op_symbol
));
1254 mn10300_check_fixup (fixup
)
1255 struct mn10300_fixup
*fixup
;
1257 expressionS
*exp
= &fixup
->exp
;
1263 case O_subtract
: /* If we're sufficiently unlucky that the label
1264 and the expression that references it happen
1265 to end up in different frags, the subtract
1266 won't be simplified within expression(). */
1267 /* The PIC-related operand must be the first operand of a sum. */
1268 if (exp
!= &fixup
->exp
|| mn10300_PIC_related_p (exp
->X_op_symbol
))
1271 if (exp
->X_add_symbol
&& exp
->X_add_symbol
== GOT_symbol
)
1272 fixup
->reloc
= BFD_RELOC_32_GOT_PCREL
;
1274 exp
= symbol_get_value_expression (exp
->X_add_symbol
);
1278 if (exp
->X_add_symbol
&& exp
->X_add_symbol
== GOT_symbol
)
1279 fixup
->reloc
= BFD_RELOC_32_GOT_PCREL
;
1283 fixup
->reloc
= exp
->X_md
;
1284 exp
->X_op
= O_symbol
;
1285 if (fixup
->reloc
== BFD_RELOC_32_PLT_PCREL
1286 && fixup
->opindex
>= 0
1287 && (mn10300_operands
[fixup
->opindex
].flags
1288 & MN10300_OPERAND_RELAX
))
1293 return (mn10300_PIC_related_p (exp
->X_add_symbol
)
1294 || mn10300_PIC_related_p (exp
->X_op_symbol
));
1301 mn10300_cons_fix_new (frag
, off
, size
, exp
)
1306 struct mn10300_fixup fixup
;
1310 fixup
.reloc
= BFD_RELOC_UNUSED
;
1312 mn10300_check_fixup (&fixup
);
1314 if (fixup
.reloc
== BFD_RELOC_MN10300_GOT32
)
1318 fixup
.reloc
= BFD_RELOC_MN10300_GOT16
;
1322 fixup
.reloc
= BFD_RELOC_MN10300_GOT24
;
1331 else if (fixup
.reloc
== BFD_RELOC_UNUSED
)
1335 fixup
.reloc
= BFD_RELOC_8
;
1339 fixup
.reloc
= BFD_RELOC_16
;
1343 fixup
.reloc
= BFD_RELOC_24
;
1347 fixup
.reloc
= BFD_RELOC_32
;
1356 as_bad (_("unsupported BFD relocation size %u"), size
);
1357 fixup
.reloc
= BFD_RELOC_UNUSED
;
1360 fix_new_exp (frag
, off
, size
, &fixup
.exp
, 0, fixup
.reloc
);
1368 struct mn10300_opcode
*opcode
;
1369 struct mn10300_opcode
*next_opcode
;
1370 const unsigned char *opindex_ptr
;
1371 int next_opindex
, relaxable
;
1372 unsigned long insn
, extension
, size
= 0;
1377 /* Get the opcode. */
1378 for (s
= str
; *s
!= '\0' && !ISSPACE (*s
); s
++)
1383 /* Find the first opcode with the proper name. */
1384 opcode
= (struct mn10300_opcode
*) hash_find (mn10300_hash
, str
);
1387 as_bad (_("Unrecognized opcode: `%s'"), str
);
1392 while (ISSPACE (*str
))
1395 input_line_pointer
= str
;
1402 int extra_shift
= 0;
1404 errmsg
= _("Invalid opcode/operands");
1406 /* Reset the array of register operands. */
1407 memset (mn10300_reg_operands
, -1, sizeof (mn10300_reg_operands
));
1413 insn
= opcode
->opcode
;
1416 /* If the instruction is not available on the current machine
1417 then it can not possibly match. */
1419 && !(opcode
->machine
== AM33_2
&& HAVE_AM33_2
)
1420 && !(opcode
->machine
== AM33
&& HAVE_AM33
)
1421 && !(opcode
->machine
== AM30
&& HAVE_AM30
))
1424 for (op_idx
= 1, opindex_ptr
= opcode
->operands
;
1426 opindex_ptr
++, op_idx
++)
1428 const struct mn10300_operand
*operand
;
1431 if (next_opindex
== 0)
1433 operand
= &mn10300_operands
[*opindex_ptr
];
1437 operand
= &mn10300_operands
[next_opindex
];
1441 while (*str
== ' ' || *str
== ',')
1444 if (operand
->flags
& MN10300_OPERAND_RELAX
)
1447 /* Gather the operand. */
1448 hold
= input_line_pointer
;
1449 input_line_pointer
= str
;
1451 if (operand
->flags
& MN10300_OPERAND_PAREN
)
1453 if (*input_line_pointer
!= ')' && *input_line_pointer
!= '(')
1455 input_line_pointer
= hold
;
1459 input_line_pointer
++;
1462 /* See if we can match the operands. */
1463 else if (operand
->flags
& MN10300_OPERAND_DREG
)
1465 if (!data_register_name (&ex
))
1467 input_line_pointer
= hold
;
1472 else if (operand
->flags
& MN10300_OPERAND_AREG
)
1474 if (!address_register_name (&ex
))
1476 input_line_pointer
= hold
;
1481 else if (operand
->flags
& MN10300_OPERAND_SP
)
1483 char *start
= input_line_pointer
;
1484 char c
= get_symbol_end ();
1486 if (strcasecmp (start
, "sp") != 0)
1488 *input_line_pointer
= c
;
1489 input_line_pointer
= hold
;
1493 *input_line_pointer
= c
;
1496 else if (operand
->flags
& MN10300_OPERAND_RREG
)
1498 if (!r_register_name (&ex
))
1500 input_line_pointer
= hold
;
1505 else if (operand
->flags
& MN10300_OPERAND_XRREG
)
1507 if (!xr_register_name (&ex
))
1509 input_line_pointer
= hold
;
1514 else if (operand
->flags
& MN10300_OPERAND_FSREG
)
1516 if (!float_register_name (&ex
))
1518 input_line_pointer
= hold
;
1523 else if (operand
->flags
& MN10300_OPERAND_FDREG
)
1525 if (!double_register_name (&ex
))
1527 input_line_pointer
= hold
;
1532 else if (operand
->flags
& MN10300_OPERAND_FPCR
)
1534 char *start
= input_line_pointer
;
1535 char c
= get_symbol_end ();
1537 if (strcasecmp (start
, "fpcr") != 0)
1539 *input_line_pointer
= c
;
1540 input_line_pointer
= hold
;
1544 *input_line_pointer
= c
;
1547 else if (operand
->flags
& MN10300_OPERAND_USP
)
1549 char *start
= input_line_pointer
;
1550 char c
= get_symbol_end ();
1552 if (strcasecmp (start
, "usp") != 0)
1554 *input_line_pointer
= c
;
1555 input_line_pointer
= hold
;
1559 *input_line_pointer
= c
;
1562 else if (operand
->flags
& MN10300_OPERAND_SSP
)
1564 char *start
= input_line_pointer
;
1565 char c
= get_symbol_end ();
1567 if (strcasecmp (start
, "ssp") != 0)
1569 *input_line_pointer
= c
;
1570 input_line_pointer
= hold
;
1574 *input_line_pointer
= c
;
1577 else if (operand
->flags
& MN10300_OPERAND_MSP
)
1579 char *start
= input_line_pointer
;
1580 char c
= get_symbol_end ();
1582 if (strcasecmp (start
, "msp") != 0)
1584 *input_line_pointer
= c
;
1585 input_line_pointer
= hold
;
1589 *input_line_pointer
= c
;
1592 else if (operand
->flags
& MN10300_OPERAND_PC
)
1594 char *start
= input_line_pointer
;
1595 char c
= get_symbol_end ();
1597 if (strcasecmp (start
, "pc") != 0)
1599 *input_line_pointer
= c
;
1600 input_line_pointer
= hold
;
1604 *input_line_pointer
= c
;
1607 else if (operand
->flags
& MN10300_OPERAND_EPSW
)
1609 char *start
= input_line_pointer
;
1610 char c
= get_symbol_end ();
1612 if (strcasecmp (start
, "epsw") != 0)
1614 *input_line_pointer
= c
;
1615 input_line_pointer
= hold
;
1619 *input_line_pointer
= c
;
1622 else if (operand
->flags
& MN10300_OPERAND_PLUS
)
1624 if (*input_line_pointer
!= '+')
1626 input_line_pointer
= hold
;
1630 input_line_pointer
++;
1633 else if (operand
->flags
& MN10300_OPERAND_PSW
)
1635 char *start
= input_line_pointer
;
1636 char c
= get_symbol_end ();
1638 if (strcasecmp (start
, "psw") != 0)
1640 *input_line_pointer
= c
;
1641 input_line_pointer
= hold
;
1645 *input_line_pointer
= c
;
1648 else if (operand
->flags
& MN10300_OPERAND_MDR
)
1650 char *start
= input_line_pointer
;
1651 char c
= get_symbol_end ();
1653 if (strcasecmp (start
, "mdr") != 0)
1655 *input_line_pointer
= c
;
1656 input_line_pointer
= hold
;
1660 *input_line_pointer
= c
;
1663 else if (operand
->flags
& MN10300_OPERAND_REG_LIST
)
1665 unsigned int value
= 0;
1666 if (*input_line_pointer
!= '[')
1668 input_line_pointer
= hold
;
1674 input_line_pointer
++;
1676 /* We used to reject a null register list here; however,
1677 we accept it now so the compiler can emit "call"
1678 instructions for all calls to named functions.
1680 The linker can then fill in the appropriate bits for the
1681 register list and stack size or change the instruction
1682 into a "calls" if using "call" is not profitable. */
1683 while (*input_line_pointer
!= ']')
1688 if (*input_line_pointer
== ',')
1689 input_line_pointer
++;
1691 start
= input_line_pointer
;
1692 c
= get_symbol_end ();
1694 if (strcasecmp (start
, "d2") == 0)
1697 *input_line_pointer
= c
;
1699 else if (strcasecmp (start
, "d3") == 0)
1702 *input_line_pointer
= c
;
1704 else if (strcasecmp (start
, "a2") == 0)
1707 *input_line_pointer
= c
;
1709 else if (strcasecmp (start
, "a3") == 0)
1712 *input_line_pointer
= c
;
1714 else if (strcasecmp (start
, "other") == 0)
1717 *input_line_pointer
= c
;
1720 && strcasecmp (start
, "exreg0") == 0)
1723 *input_line_pointer
= c
;
1726 && strcasecmp (start
, "exreg1") == 0)
1729 *input_line_pointer
= c
;
1732 && strcasecmp (start
, "exother") == 0)
1735 *input_line_pointer
= c
;
1738 && strcasecmp (start
, "all") == 0)
1741 *input_line_pointer
= c
;
1745 input_line_pointer
= hold
;
1750 input_line_pointer
++;
1751 mn10300_insert_operand (&insn
, &extension
, operand
,
1752 value
, (char *) NULL
, 0, 0);
1756 else if (data_register_name (&ex
))
1758 input_line_pointer
= hold
;
1762 else if (address_register_name (&ex
))
1764 input_line_pointer
= hold
;
1768 else if (other_register_name (&ex
))
1770 input_line_pointer
= hold
;
1774 else if (HAVE_AM33
&& r_register_name (&ex
))
1776 input_line_pointer
= hold
;
1780 else if (HAVE_AM33
&& xr_register_name (&ex
))
1782 input_line_pointer
= hold
;
1786 else if (HAVE_AM33_2
&& float_register_name (&ex
))
1788 input_line_pointer
= hold
;
1792 else if (HAVE_AM33_2
&& double_register_name (&ex
))
1794 input_line_pointer
= hold
;
1798 else if (*str
== ')' || *str
== '(')
1800 input_line_pointer
= hold
;
1812 errmsg
= _("illegal operand");
1815 errmsg
= _("missing operand");
1821 mask
= MN10300_OPERAND_DREG
| MN10300_OPERAND_AREG
;
1823 mask
|= MN10300_OPERAND_RREG
| MN10300_OPERAND_XRREG
;
1825 mask
|= MN10300_OPERAND_FSREG
| MN10300_OPERAND_FDREG
;
1826 if ((operand
->flags
& mask
) == 0)
1828 input_line_pointer
= hold
;
1833 if (opcode
->format
== FMT_D1
|| opcode
->format
== FMT_S1
)
1835 else if (opcode
->format
== FMT_D2
1836 || opcode
->format
== FMT_D4
1837 || opcode
->format
== FMT_S2
1838 || opcode
->format
== FMT_S4
1839 || opcode
->format
== FMT_S6
1840 || opcode
->format
== FMT_D5
)
1842 else if (opcode
->format
== FMT_D7
)
1844 else if (opcode
->format
== FMT_D8
|| opcode
->format
== FMT_D9
)
1849 mn10300_insert_operand (&insn
, &extension
, operand
,
1850 ex
.X_add_number
, (char *) NULL
,
1853 /* And note the register number in the register array. */
1854 mn10300_reg_operands
[op_idx
- 1] = ex
.X_add_number
;
1859 /* If this operand can be promoted, and it doesn't
1860 fit into the allocated bitfield for this insn,
1861 then promote it (ie this opcode does not match). */
1863 & (MN10300_OPERAND_PROMOTE
| MN10300_OPERAND_RELAX
)
1864 && !check_operand (insn
, operand
, ex
.X_add_number
))
1866 input_line_pointer
= hold
;
1871 mn10300_insert_operand (&insn
, &extension
, operand
,
1872 ex
.X_add_number
, (char *) NULL
,
1877 /* If this operand can be promoted, then this opcode didn't
1878 match since we can't know if it needed promotion! */
1879 if (operand
->flags
& MN10300_OPERAND_PROMOTE
)
1881 input_line_pointer
= hold
;
1886 /* We need to generate a fixup for this expression. */
1887 if (fc
>= MAX_INSN_FIXUPS
)
1888 as_fatal (_("too many fixups"));
1889 fixups
[fc
].exp
= ex
;
1890 fixups
[fc
].opindex
= *opindex_ptr
;
1891 fixups
[fc
].reloc
= BFD_RELOC_UNUSED
;
1892 if (mn10300_check_fixup (& fixups
[fc
]))
1899 str
= input_line_pointer
;
1900 input_line_pointer
= hold
;
1902 while (*str
== ' ' || *str
== ',')
1907 /* Make sure we used all the operands! */
1911 /* If this instruction has registers that must not match, verify
1912 that they do indeed not match. */
1913 if (opcode
->no_match_operands
)
1917 /* Look at each operand to see if it's marked. */
1918 for (i
= 0; i
< MN10300_MAX_OPERANDS
; i
++)
1920 if ((1 << i
) & opcode
->no_match_operands
)
1924 /* operand I is marked. Check that it does not match any
1925 operands > I which are marked. */
1926 for (j
= i
+ 1; j
< MN10300_MAX_OPERANDS
; j
++)
1928 if (((1 << j
) & opcode
->no_match_operands
)
1929 && mn10300_reg_operands
[i
] == mn10300_reg_operands
[j
])
1931 errmsg
= _("Invalid register specification.");
1943 next_opcode
= opcode
+ 1;
1944 if (!strcmp (next_opcode
->name
, opcode
->name
))
1946 opcode
= next_opcode
;
1950 as_bad ("%s", errmsg
);
1956 while (ISSPACE (*str
))
1960 as_bad (_("junk at end of line: `%s'"), str
);
1962 input_line_pointer
= str
;
1964 /* Determine the size of the instruction. */
1965 if (opcode
->format
== FMT_S0
)
1968 if (opcode
->format
== FMT_S1
|| opcode
->format
== FMT_D0
)
1971 if (opcode
->format
== FMT_S2
|| opcode
->format
== FMT_D1
)
1974 if (opcode
->format
== FMT_D6
)
1977 if (opcode
->format
== FMT_D7
|| opcode
->format
== FMT_D10
)
1980 if (opcode
->format
== FMT_D8
)
1983 if (opcode
->format
== FMT_D9
)
1986 if (opcode
->format
== FMT_S4
)
1989 if (opcode
->format
== FMT_S6
|| opcode
->format
== FMT_D5
)
1992 if (opcode
->format
== FMT_D2
)
1995 if (opcode
->format
== FMT_D3
)
1998 if (opcode
->format
== FMT_D4
)
2001 if (relaxable
&& fc
> 0)
2005 /* We want to anchor the line info to the previous frag (if
2006 there isn't one, create it), so that, when the insn is
2007 resized, we still get the right address for the beginning of
2010 dwarf2_emit_insn (0);
2015 /* Handle bra specially. Basically treat it like jmp so
2016 that we automatically handle 8, 16 and 32 bit offsets
2017 correctly as well as jumps to an undefined address.
2019 It is also important to not treat it like other bCC
2020 instructions since the long forms of bra is different
2021 from other bCC instructions. */
2022 if (opcode
->opcode
== 0xca00)
2034 else if (size
== 3 && opcode
->opcode
== 0xcc0000)
2036 else if (size
== 3 && (opcode
->opcode
& 0xfff000) == 0xf8d000)
2038 /* bCC (uncommon cases) */
2042 f
= frag_var (rs_machine_dependent
, 8, 8 - size
, type
,
2043 fixups
[0].exp
.X_add_symbol
,
2044 fixups
[0].exp
.X_add_number
,
2045 (char *)fixups
[0].opindex
);
2047 /* This is pretty hokey. We basically just care about the
2048 opcode, so we have to write out the first word big endian.
2050 The exception is "call", which has two operands that we
2053 The first operand (the register list) happens to be in the
2054 first instruction word, and will be in the right place if
2055 we output the first word in big endian mode.
2057 The second operand (stack size) is in the extension word,
2058 and we want it to appear as the first character in the extension
2059 word (as it appears in memory). Luckily, writing the extension
2060 word in big endian format will do what we want. */
2061 number_to_chars_bigendian (f
, insn
, size
> 4 ? 4 : size
);
2064 number_to_chars_bigendian (f
+ 4, extension
, 4);
2065 number_to_chars_bigendian (f
+ 8, 0, size
- 8);
2068 number_to_chars_bigendian (f
+ 4, extension
, size
- 4);
2072 /* Allocate space for the instruction. */
2073 f
= frag_more (size
);
2075 /* Fill in bytes for the instruction. Note that opcode fields
2076 are written big-endian, 16 & 32bit immediates are written
2077 little endian. Egad. */
2078 if (opcode
->format
== FMT_S0
2079 || opcode
->format
== FMT_S1
2080 || opcode
->format
== FMT_D0
2081 || opcode
->format
== FMT_D6
2082 || opcode
->format
== FMT_D7
2083 || opcode
->format
== FMT_D10
2084 || opcode
->format
== FMT_D1
)
2086 number_to_chars_bigendian (f
, insn
, size
);
2088 else if (opcode
->format
== FMT_S2
2089 && opcode
->opcode
!= 0xdf0000
2090 && opcode
->opcode
!= 0xde0000)
2092 /* A format S2 instruction that is _not_ "ret" and "retf". */
2093 number_to_chars_bigendian (f
, (insn
>> 16) & 0xff, 1);
2094 number_to_chars_littleendian (f
+ 1, insn
& 0xffff, 2);
2096 else if (opcode
->format
== FMT_S2
)
2098 /* This must be a ret or retf, which is written entirely in
2099 big-endian format. */
2100 number_to_chars_bigendian (f
, insn
, 3);
2102 else if (opcode
->format
== FMT_S4
2103 && opcode
->opcode
!= 0xdc000000)
2105 /* This must be a format S4 "call" instruction. What a pain. */
2106 unsigned long temp
= (insn
>> 8) & 0xffff;
2107 number_to_chars_bigendian (f
, (insn
>> 24) & 0xff, 1);
2108 number_to_chars_littleendian (f
+ 1, temp
, 2);
2109 number_to_chars_bigendian (f
+ 3, insn
& 0xff, 1);
2110 number_to_chars_bigendian (f
+ 4, extension
& 0xff, 1);
2112 else if (opcode
->format
== FMT_S4
)
2114 /* This must be a format S4 "jmp" instruction. */
2115 unsigned long temp
= ((insn
& 0xffffff) << 8) | (extension
& 0xff);
2116 number_to_chars_bigendian (f
, (insn
>> 24) & 0xff, 1);
2117 number_to_chars_littleendian (f
+ 1, temp
, 4);
2119 else if (opcode
->format
== FMT_S6
)
2121 unsigned long temp
= ((insn
& 0xffffff) << 8)
2122 | ((extension
>> 16) & 0xff);
2123 number_to_chars_bigendian (f
, (insn
>> 24) & 0xff, 1);
2124 number_to_chars_littleendian (f
+ 1, temp
, 4);
2125 number_to_chars_bigendian (f
+ 5, (extension
>> 8) & 0xff, 1);
2126 number_to_chars_bigendian (f
+ 6, extension
& 0xff, 1);
2128 else if (opcode
->format
== FMT_D2
2129 && opcode
->opcode
!= 0xfaf80000
2130 && opcode
->opcode
!= 0xfaf00000
2131 && opcode
->opcode
!= 0xfaf40000)
2133 /* A format D2 instruction where the 16bit immediate is
2134 really a single 16bit value, not two 8bit values. */
2135 number_to_chars_bigendian (f
, (insn
>> 16) & 0xffff, 2);
2136 number_to_chars_littleendian (f
+ 2, insn
& 0xffff, 2);
2138 else if (opcode
->format
== FMT_D2
)
2140 /* A format D2 instruction where the 16bit immediate
2141 is really two 8bit immediates. */
2142 number_to_chars_bigendian (f
, insn
, 4);
2144 else if (opcode
->format
== FMT_D3
)
2146 number_to_chars_bigendian (f
, (insn
>> 16) & 0xffff, 2);
2147 number_to_chars_littleendian (f
+ 2, insn
& 0xffff, 2);
2148 number_to_chars_bigendian (f
+ 4, extension
& 0xff, 1);
2150 else if (opcode
->format
== FMT_D4
)
2152 unsigned long temp
= ((insn
& 0xffff) << 16) | (extension
& 0xffff);
2154 number_to_chars_bigendian (f
, (insn
>> 16) & 0xffff, 2);
2155 number_to_chars_littleendian (f
+ 2, temp
, 4);
2157 else if (opcode
->format
== FMT_D5
)
2159 unsigned long temp
= (((insn
& 0xffff) << 16)
2160 | ((extension
>> 8) & 0xffff));
2162 number_to_chars_bigendian (f
, (insn
>> 16) & 0xffff, 2);
2163 number_to_chars_littleendian (f
+ 2, temp
, 4);
2164 number_to_chars_bigendian (f
+ 6, extension
& 0xff, 1);
2166 else if (opcode
->format
== FMT_D8
)
2168 unsigned long temp
= ((insn
& 0xff) << 16) | (extension
& 0xffff);
2170 number_to_chars_bigendian (f
, (insn
>> 8) & 0xffffff, 3);
2171 number_to_chars_bigendian (f
+ 3, (temp
& 0xff), 1);
2172 number_to_chars_littleendian (f
+ 4, temp
>> 8, 2);
2174 else if (opcode
->format
== FMT_D9
)
2176 unsigned long temp
= ((insn
& 0xff) << 24) | (extension
& 0xffffff);
2178 number_to_chars_bigendian (f
, (insn
>> 8) & 0xffffff, 3);
2179 number_to_chars_littleendian (f
+ 3, temp
, 4);
2182 /* Create any fixups. */
2183 for (i
= 0; i
< fc
; i
++)
2185 const struct mn10300_operand
*operand
;
2187 operand
= &mn10300_operands
[fixups
[i
].opindex
];
2188 if (fixups
[i
].reloc
!= BFD_RELOC_UNUSED
2189 && fixups
[i
].reloc
!= BFD_RELOC_32_GOT_PCREL
2190 && fixups
[i
].reloc
!= BFD_RELOC_32_GOTOFF
2191 && fixups
[i
].reloc
!= BFD_RELOC_32_PLT_PCREL
2192 && fixups
[i
].reloc
!= BFD_RELOC_MN10300_GOT32
)
2194 reloc_howto_type
*reloc_howto
;
2199 reloc_howto
= bfd_reloc_type_lookup (stdoutput
,
2205 size
= bfd_get_reloc_size (reloc_howto
);
2207 if (size
< 1 || size
> 4)
2211 fixP
= fix_new_exp (frag_now
, f
- frag_now
->fr_literal
+ offset
,
2212 size
, &fixups
[i
].exp
,
2213 reloc_howto
->pc_relative
,
2218 int reloc
, pcrel
, reloc_size
, offset
;
2221 reloc
= BFD_RELOC_NONE
;
2222 if (fixups
[i
].reloc
!= BFD_RELOC_UNUSED
)
2223 reloc
= fixups
[i
].reloc
;
2224 /* How big is the reloc? Remember SPLIT relocs are
2225 implicitly 32bits. */
2226 if ((operand
->flags
& MN10300_OPERAND_SPLIT
) != 0)
2228 else if ((operand
->flags
& MN10300_OPERAND_24BIT
) != 0)
2231 reloc_size
= operand
->bits
;
2233 /* Is the reloc pc-relative? */
2234 pcrel
= (operand
->flags
& MN10300_OPERAND_PCREL
) != 0;
2235 if (reloc
!= BFD_RELOC_NONE
)
2236 pcrel
= bfd_reloc_type_lookup (stdoutput
, reloc
)->pc_relative
;
2238 offset
= size
- (reloc_size
+ operand
->shift
) / 8;
2240 /* Choose a proper BFD relocation type. */
2241 if (reloc
!= BFD_RELOC_NONE
)
2245 if (reloc_size
== 32)
2246 reloc
= BFD_RELOC_32_PCREL
;
2247 else if (reloc_size
== 16)
2248 reloc
= BFD_RELOC_16_PCREL
;
2249 else if (reloc_size
== 8)
2250 reloc
= BFD_RELOC_8_PCREL
;
2256 if (reloc_size
== 32)
2257 reloc
= BFD_RELOC_32
;
2258 else if (reloc_size
== 16)
2259 reloc
= BFD_RELOC_16
;
2260 else if (reloc_size
== 8)
2261 reloc
= BFD_RELOC_8
;
2266 /* Convert the size of the reloc into what fix_new_exp wants. */
2267 reloc_size
= reloc_size
/ 8;
2268 if (reloc_size
== 8)
2270 else if (reloc_size
== 16)
2272 else if (reloc_size
== 32)
2275 fixP
= fix_new_exp (frag_now
, f
- frag_now
->fr_literal
+ offset
,
2276 reloc_size
, &fixups
[i
].exp
, pcrel
,
2277 ((bfd_reloc_code_real_type
) reloc
));
2280 fixP
->fx_offset
+= offset
;
2284 dwarf2_emit_insn (size
);
2288 /* If while processing a fixup, a reloc really needs to be created
2289 then it is done here. */
2292 tc_gen_reloc (seg
, fixp
)
2293 asection
*seg ATTRIBUTE_UNUSED
;
2297 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
2299 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
2300 if (reloc
->howto
== (reloc_howto_type
*) NULL
)
2302 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2303 _("reloc %d not supported by object file format"),
2304 (int) fixp
->fx_r_type
);
2307 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
2310 && S_GET_SEGMENT (fixp
->fx_subsy
) == absolute_section
)
2312 fixp
->fx_offset
-= S_GET_VALUE (fixp
->fx_subsy
);
2316 if (fixp
->fx_addsy
&& fixp
->fx_subsy
)
2318 reloc
->sym_ptr_ptr
= NULL
;
2320 /* If we got a difference between two symbols, and the
2321 subtracted symbol is in the current section, use a
2322 PC-relative relocation. If both symbols are in the same
2323 section, the difference would have already been simplified
2325 if (S_GET_SEGMENT (fixp
->fx_subsy
) == seg
)
2327 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
2328 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
2329 reloc
->addend
= (reloc
->address
- S_GET_VALUE (fixp
->fx_subsy
)
2332 switch (fixp
->fx_r_type
)
2335 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
,
2340 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
,
2341 BFD_RELOC_16_PCREL
);
2345 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
,
2346 BFD_RELOC_24_PCREL
);
2350 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
,
2351 BFD_RELOC_32_PCREL
);
2355 /* Try to compute the absolute value below. */
2360 if ((S_GET_SEGMENT (fixp
->fx_addsy
) != S_GET_SEGMENT (fixp
->fx_subsy
))
2361 || S_GET_SEGMENT (fixp
->fx_addsy
) == undefined_section
)
2363 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2364 "Difference of symbols in different sections is not supported");
2368 char *fixpos
= fixp
->fx_where
+ fixp
->fx_frag
->fr_literal
;
2370 reloc
->addend
= (S_GET_VALUE (fixp
->fx_addsy
)
2371 - S_GET_VALUE (fixp
->fx_subsy
) + fixp
->fx_offset
);
2373 switch (fixp
->fx_r_type
)
2376 md_number_to_chars (fixpos
, reloc
->addend
, 1);
2380 md_number_to_chars (fixpos
, reloc
->addend
, 2);
2384 md_number_to_chars (fixpos
, reloc
->addend
, 3);
2388 md_number_to_chars (fixpos
, reloc
->addend
, 4);
2392 reloc
->sym_ptr_ptr
= (asymbol
**) &bfd_abs_symbol
;
2397 if (reloc
->sym_ptr_ptr
)
2398 free (reloc
->sym_ptr_ptr
);
2404 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
2405 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
2406 reloc
->addend
= fixp
->fx_offset
;
2412 md_estimate_size_before_relax (fragp
, seg
)
2416 if (fragp
->fr_subtype
== 6
2417 && (!S_IS_DEFINED (fragp
->fr_symbol
)
2418 || seg
!= S_GET_SEGMENT (fragp
->fr_symbol
)))
2419 fragp
->fr_subtype
= 7;
2420 else if (fragp
->fr_subtype
== 8
2421 && (!S_IS_DEFINED (fragp
->fr_symbol
)
2422 || seg
!= S_GET_SEGMENT (fragp
->fr_symbol
)))
2423 fragp
->fr_subtype
= 9;
2424 else if (fragp
->fr_subtype
== 10
2425 && (!S_IS_DEFINED (fragp
->fr_symbol
)
2426 || seg
!= S_GET_SEGMENT (fragp
->fr_symbol
)))
2427 fragp
->fr_subtype
= 12;
2429 if (fragp
->fr_subtype
== 13)
2431 if (fragp
->fr_subtype
>= sizeof (md_relax_table
) / sizeof (md_relax_table
[0]))
2434 return md_relax_table
[fragp
->fr_subtype
].rlx_length
;
2438 md_pcrel_from (fixp
)
2441 if (fixp
->fx_addsy
!= (symbolS
*) NULL
&& !S_IS_DEFINED (fixp
->fx_addsy
))
2443 /* The symbol is undefined. Let the linker figure it out. */
2446 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
2450 md_apply_fix3 (fixP
, valP
, seg
)
2455 char * fixpos
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
2457 int value
= (int) * valP
;
2459 assert (fixP
->fx_r_type
< BFD_RELOC_UNUSED
);
2461 /* This should never happen. */
2462 if (seg
->flags
& SEC_ALLOC
)
2465 /* The value we are passed in *valuep includes the symbol values.
2466 Since we are using BFD_ASSEMBLER, if we are doing this relocation
2467 the code in write.c is going to call bfd_install_relocation, which
2468 is also going to use the symbol value. That means that if the
2469 reloc is fully resolved we want to use *valuep since
2470 bfd_install_relocation is not being used.
2472 However, if the reloc is not fully resolved we do not want to use
2473 *valuep, and must use fx_offset instead. However, if the reloc
2474 is PC relative, we do want to use *valuep since it includes the
2475 result of md_pcrel_from. */
2476 if (fixP
->fx_addsy
!= (symbolS
*) NULL
&& ! fixP
->fx_pcrel
)
2477 value
= fixP
->fx_offset
;
2479 /* If the fix is relative to a symbol which is not defined, or not
2480 in the same segment as the fix, we cannot resolve it here. */
2481 if (fixP
->fx_addsy
!= NULL
2482 && (! S_IS_DEFINED (fixP
->fx_addsy
)
2483 || (S_GET_SEGMENT (fixP
->fx_addsy
) != seg
)))
2489 switch (fixP
->fx_r_type
)
2492 case BFD_RELOC_8_PCREL
:
2497 case BFD_RELOC_16_PCREL
:
2502 case BFD_RELOC_32_PCREL
:
2506 case BFD_RELOC_VTABLE_INHERIT
:
2507 case BFD_RELOC_VTABLE_ENTRY
:
2511 case BFD_RELOC_NONE
:
2513 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2514 _("Bad relocation fixup type (%d)"), fixP
->fx_r_type
);
2517 md_number_to_chars (fixpos
, value
, size
);
2519 /* If a symbol remains, pass the fixup, as a reloc, onto the linker. */
2520 if (fixP
->fx_addsy
== NULL
)
2524 /* Return zero if the fixup in fixp should be left alone and not
2528 mn10300_fix_adjustable (fixp
)
2531 if (! TC_RELOC_RTSYM_LOC_FIXUP (fixp
))
2534 if (fixp
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
2535 || fixp
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
2538 /* Do not adjust relocations involving symbols in code sections,
2539 because it breaks linker relaxations. This could be fixed in the
2540 linker, but this fix is simpler, and it pretty much only affects
2541 object size a little bit. */
2542 if (S_GET_SEGMENT (fixp
->fx_addsy
)->flags
& SEC_CODE
)
2545 /* Likewise, do not adjust symbols that won't be merged, or debug
2546 symbols, because they too break relaxation. We do want to adjust
2547 other mergable symbols, like .rodata, because code relaxations
2548 need section-relative symbols to properly relax them. */
2549 if (! (S_GET_SEGMENT(fixp
->fx_addsy
)->flags
& SEC_MERGE
))
2551 if (strncmp (S_GET_SEGMENT (fixp
->fx_addsy
)->name
, ".debug", 6) == 0)
2557 /* Insert an operand value into an instruction. */
2560 mn10300_insert_operand (insnp
, extensionp
, operand
, val
, file
, line
, shift
)
2561 unsigned long *insnp
;
2562 unsigned long *extensionp
;
2563 const struct mn10300_operand
*operand
;
2569 /* No need to check 32bit operands for a bit. Note that
2570 MN10300_OPERAND_SPLIT is an implicit 32bit operand. */
2571 if (operand
->bits
!= 32
2572 && (operand
->flags
& MN10300_OPERAND_SPLIT
) == 0)
2578 bits
= operand
->bits
;
2579 if (operand
->flags
& MN10300_OPERAND_24BIT
)
2582 if ((operand
->flags
& MN10300_OPERAND_SIGNED
) != 0)
2584 max
= (1 << (bits
- 1)) - 1;
2585 min
= - (1 << (bits
- 1));
2589 max
= (1 << bits
) - 1;
2595 if (test
< (offsetT
) min
|| test
> (offsetT
) max
)
2596 as_warn_value_out_of_range (_("operand"), test
, (offsetT
) min
, (offsetT
) max
, file
, line
);
2599 if ((operand
->flags
& MN10300_OPERAND_SPLIT
) != 0)
2601 *insnp
|= (val
>> (32 - operand
->bits
)) & ((1 << operand
->bits
) - 1);
2602 *extensionp
|= ((val
& ((1 << (32 - operand
->bits
)) - 1))
2605 else if ((operand
->flags
& MN10300_OPERAND_24BIT
) != 0)
2607 *insnp
|= (val
>> (24 - operand
->bits
)) & ((1 << operand
->bits
) - 1);
2608 *extensionp
|= ((val
& ((1 << (24 - operand
->bits
)) - 1))
2611 else if ((operand
->flags
& (MN10300_OPERAND_FSREG
| MN10300_OPERAND_FDREG
)))
2613 /* See devo/opcodes/m10300-opc.c just before #define FSM0 for an
2614 explanation of these variables. Note that FMT-implied shifts
2615 are not taken into account for FP registers. */
2616 unsigned long mask_low
, mask_high
;
2617 int shl_low
, shr_high
, shl_high
;
2619 switch (operand
->bits
)
2622 /* Handle regular FP registers. */
2623 if (operand
->shift
>= 0)
2625 /* This is an `m' register. */
2626 shl_low
= operand
->shift
;
2627 shl_high
= 8 + (8 & shl_low
) + (shl_low
& 4) / 4;
2631 /* This is an `n' register. */
2632 shl_low
= -operand
->shift
;
2633 shl_high
= shl_low
/ 4;
2642 /* Handle accumulators. */
2643 shl_low
= -operand
->shift
;
2653 *insnp
|= ((((val
& mask_high
) >> shr_high
) << shl_high
)
2654 | ((val
& mask_low
) << shl_low
));
2656 else if ((operand
->flags
& MN10300_OPERAND_EXTENDED
) == 0)
2658 *insnp
|= (((long) val
& ((1 << operand
->bits
) - 1))
2659 << (operand
->shift
+ shift
));
2661 if ((operand
->flags
& MN10300_OPERAND_REPEATED
) != 0)
2662 *insnp
|= (((long) val
& ((1 << operand
->bits
) - 1))
2663 << (operand
->shift
+ shift
+ operand
->bits
));
2667 *extensionp
|= (((long) val
& ((1 << operand
->bits
) - 1))
2668 << (operand
->shift
+ shift
));
2670 if ((operand
->flags
& MN10300_OPERAND_REPEATED
) != 0)
2671 *extensionp
|= (((long) val
& ((1 << operand
->bits
) - 1))
2672 << (operand
->shift
+ shift
+ operand
->bits
));
2676 static unsigned long
2677 check_operand (insn
, operand
, val
)
2678 unsigned long insn ATTRIBUTE_UNUSED
;
2679 const struct mn10300_operand
*operand
;
2682 /* No need to check 32bit operands for a bit. Note that
2683 MN10300_OPERAND_SPLIT is an implicit 32bit operand. */
2684 if (operand
->bits
!= 32
2685 && (operand
->flags
& MN10300_OPERAND_SPLIT
) == 0)
2691 bits
= operand
->bits
;
2692 if (operand
->flags
& MN10300_OPERAND_24BIT
)
2695 if ((operand
->flags
& MN10300_OPERAND_SIGNED
) != 0)
2697 max
= (1 << (bits
- 1)) - 1;
2698 min
= - (1 << (bits
- 1));
2702 max
= (1 << bits
) - 1;
2708 if (test
< (offsetT
) min
|| test
> (offsetT
) max
)
2717 set_arch_mach (mach
)
2720 if (!bfd_set_arch_mach (stdoutput
, bfd_arch_mn10300
, mach
))
2721 as_warn (_("could not set architecture and machine"));
2723 current_machine
= mach
;
2726 static inline char * mn10300_end_of_match
PARAMS ((char *, char *));
2728 static inline char *
2729 mn10300_end_of_match (cont
, what
)
2732 int len
= strlen (what
);
2734 if (strncmp (cont
, what
, strlen (what
)) == 0
2735 && ! is_part_of_name (cont
[len
]))
2742 mn10300_parse_name (name
, exprP
, nextcharP
)
2747 char *next
= input_line_pointer
;
2752 exprP
->X_op_symbol
= NULL
;
2754 if (strcmp (name
, GLOBAL_OFFSET_TABLE_NAME
) == 0)
2757 GOT_symbol
= symbol_find_or_make (name
);
2759 exprP
->X_add_symbol
= GOT_symbol
;
2761 /* If we have an absolute symbol or a reg,
2762 then we know its value now. */
2763 segment
= S_GET_SEGMENT (exprP
->X_add_symbol
);
2764 if (segment
== absolute_section
)
2766 exprP
->X_op
= O_constant
;
2767 exprP
->X_add_number
= S_GET_VALUE (exprP
->X_add_symbol
);
2768 exprP
->X_add_symbol
= NULL
;
2770 else if (segment
== reg_section
)
2772 exprP
->X_op
= O_register
;
2773 exprP
->X_add_number
= S_GET_VALUE (exprP
->X_add_symbol
);
2774 exprP
->X_add_symbol
= NULL
;
2778 exprP
->X_op
= O_symbol
;
2779 exprP
->X_add_number
= 0;
2785 exprP
->X_add_symbol
= symbol_find_or_make (name
);
2787 if (*nextcharP
!= '@')
2789 else if ((next_end
= mn10300_end_of_match (next
+ 1, "GOTOFF")))
2790 reloc_type
= BFD_RELOC_32_GOTOFF
;
2791 else if ((next_end
= mn10300_end_of_match (next
+ 1, "GOT")))
2792 reloc_type
= BFD_RELOC_MN10300_GOT32
;
2793 else if ((next_end
= mn10300_end_of_match (next
+ 1, "PLT")))
2794 reloc_type
= BFD_RELOC_32_PLT_PCREL
;
2798 *input_line_pointer
= *nextcharP
;
2799 input_line_pointer
= next_end
;
2800 *nextcharP
= *input_line_pointer
;
2801 *input_line_pointer
= '\0';
2803 exprP
->X_op
= O_PIC_reloc
;
2804 exprP
->X_add_number
= 0;
2805 exprP
->X_md
= reloc_type
;