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. */
1216 if (!bfd_set_arch_mach (stdoutput, bfd_arch_mn10300, MN103))
1217 as_warn (_("could not set architecture and machine"));
1219 current_machine = MN103;
1222 static symbolS *GOT_symbol;
1224 static inline int mn10300_check_fixup PARAMS ((struct mn10300_fixup *));
1225 static inline int mn10300_PIC_related_p PARAMS ((symbolS *));
1228 mn10300_PIC_related_p (sym)
1236 if (sym == GOT_symbol)
1239 exp = symbol_get_value_expression (sym);
1241 return (exp->X_op == O_PIC_reloc
1242 || mn10300_PIC_related_p (exp->X_add_symbol)
1243 || mn10300_PIC_related_p (exp->X_op_symbol));
1247 mn10300_check_fixup (fixup)
1248 struct mn10300_fixup *fixup;
1250 expressionS *exp = &fixup->exp;
1256 case O_subtract: /* If we're sufficiently unlucky that the label
1257 and the expression that references it happen
1258 to end up in different frags, the subtract
1259 won't be simplified within expression(). */
1260 /* The PIC-related operand must be the first operand of a sum. */
1261 if (exp != &fixup->exp || mn10300_PIC_related_p (exp->X_op_symbol))
1264 if (exp->X_add_symbol && exp->X_add_symbol == GOT_symbol)
1265 fixup->reloc = BFD_RELOC_32_GOT_PCREL;
1267 exp = symbol_get_value_expression (exp->X_add_symbol);
1271 if (exp->X_add_symbol && exp->X_add_symbol == GOT_symbol)
1272 fixup->reloc = BFD_RELOC_32_GOT_PCREL;
1276 fixup->reloc = exp->X_md;
1277 exp->X_op = O_symbol;
1278 if (fixup->reloc == BFD_RELOC_32_PLT_PCREL
1279 && fixup->opindex >= 0
1280 && (mn10300_operands[fixup->opindex].flags
1281 & MN10300_OPERAND_RELAX))
1286 return (mn10300_PIC_related_p (exp->X_add_symbol)
1287 || mn10300_PIC_related_p (exp->X_op_symbol));
1294 mn10300_cons_fix_new (frag, off, size, exp)
1299 struct mn10300_fixup fixup;
1303 fixup.reloc = BFD_RELOC_UNUSED;
1305 mn10300_check_fixup (&fixup);
1307 if (fixup.reloc == BFD_RELOC_MN10300_GOT32)
1311 fixup.reloc = BFD_RELOC_MN10300_GOT16;
1315 fixup.reloc = BFD_RELOC_MN10300_GOT24;
1324 else if (fixup.reloc == BFD_RELOC_UNUSED)
1328 fixup.reloc = BFD_RELOC_8;
1332 fixup.reloc = BFD_RELOC_16;
1336 fixup.reloc = BFD_RELOC_24;
1340 fixup.reloc = BFD_RELOC_32;
1349 as_bad (_("unsupported BFD relocation size %u"), size);
1350 fixup.reloc = BFD_RELOC_UNUSED;
1353 fix_new_exp (frag, off, size, &fixup.exp, 0, fixup.reloc);
1361 struct mn10300_opcode *opcode;
1362 struct mn10300_opcode *next_opcode;
1363 const unsigned char *opindex_ptr;
1364 int next_opindex, relaxable;
1365 unsigned long insn, extension, size = 0;
1370 /* Get the opcode. */
1371 for (s = str; *s != '\0' && !ISSPACE (*s); s++)
1376 /* Find the first opcode with the proper name. */
1377 opcode = (struct mn10300_opcode *) hash_find (mn10300_hash, str);
1380 as_bad (_("Unrecognized opcode: `%s'"), str);
1385 while (ISSPACE (*str))
1388 input_line_pointer = str;
1395 int extra_shift = 0;
1397 errmsg = _("Invalid opcode/operands");
1399 /* Reset the array of register operands. */
1400 memset (mn10300_reg_operands, -1, sizeof (mn10300_reg_operands));
1406 insn = opcode->opcode;
1409 /* If the instruction is not available on the current machine
1410 then it can not possibly match. */
1412 && !(opcode->machine == AM33_2 && HAVE_AM33_2)
1413 && !(opcode->machine == AM33 && HAVE_AM33)
1414 && !(opcode->machine == AM30 && HAVE_AM30))
1417 for (op_idx = 1, opindex_ptr = opcode->operands;
1419 opindex_ptr++, op_idx++)
1421 const struct mn10300_operand *operand;
1424 if (next_opindex == 0)
1426 operand = &mn10300_operands[*opindex_ptr];
1430 operand = &mn10300_operands[next_opindex];
1434 while (*str == ' ' || *str == ',')
1437 if (operand->flags & MN10300_OPERAND_RELAX)
1440 /* Gather the operand. */
1441 hold = input_line_pointer;
1442 input_line_pointer = str;
1444 if (operand->flags & MN10300_OPERAND_PAREN)
1446 if (*input_line_pointer != ')' && *input_line_pointer != '(')
1448 input_line_pointer = hold;
1452 input_line_pointer++;
1455 /* See if we can match the operands. */
1456 else if (operand->flags & MN10300_OPERAND_DREG)
1458 if (!data_register_name (&ex))
1460 input_line_pointer = hold;
1465 else if (operand->flags & MN10300_OPERAND_AREG)
1467 if (!address_register_name (&ex))
1469 input_line_pointer = hold;
1474 else if (operand->flags & MN10300_OPERAND_SP)
1476 char *start = input_line_pointer;
1477 char c = get_symbol_end ();
1479 if (strcasecmp (start, "sp") != 0)
1481 *input_line_pointer = c;
1482 input_line_pointer = hold;
1486 *input_line_pointer = c;
1489 else if (operand->flags & MN10300_OPERAND_RREG)
1491 if (!r_register_name (&ex))
1493 input_line_pointer = hold;
1498 else if (operand->flags & MN10300_OPERAND_XRREG)
1500 if (!xr_register_name (&ex))
1502 input_line_pointer = hold;
1507 else if (operand->flags & MN10300_OPERAND_FSREG)
1509 if (!float_register_name (&ex))
1511 input_line_pointer = hold;
1516 else if (operand->flags & MN10300_OPERAND_FDREG)
1518 if (!double_register_name (&ex))
1520 input_line_pointer = hold;
1525 else if (operand->flags & MN10300_OPERAND_FPCR)
1527 char *start = input_line_pointer;
1528 char c = get_symbol_end ();
1530 if (strcasecmp (start, "fpcr") != 0)
1532 *input_line_pointer = c;
1533 input_line_pointer = hold;
1537 *input_line_pointer = c;
1540 else if (operand->flags & MN10300_OPERAND_USP)
1542 char *start = input_line_pointer;
1543 char c = get_symbol_end ();
1545 if (strcasecmp (start, "usp") != 0)
1547 *input_line_pointer = c;
1548 input_line_pointer = hold;
1552 *input_line_pointer = c;
1555 else if (operand->flags & MN10300_OPERAND_SSP)
1557 char *start = input_line_pointer;
1558 char c = get_symbol_end ();
1560 if (strcasecmp (start, "ssp") != 0)
1562 *input_line_pointer = c;
1563 input_line_pointer = hold;
1567 *input_line_pointer = c;
1570 else if (operand->flags & MN10300_OPERAND_MSP)
1572 char *start = input_line_pointer;
1573 char c = get_symbol_end ();
1575 if (strcasecmp (start, "msp") != 0)
1577 *input_line_pointer = c;
1578 input_line_pointer = hold;
1582 *input_line_pointer = c;
1585 else if (operand->flags & MN10300_OPERAND_PC)
1587 char *start = input_line_pointer;
1588 char c = get_symbol_end ();
1590 if (strcasecmp (start, "pc") != 0)
1592 *input_line_pointer = c;
1593 input_line_pointer = hold;
1597 *input_line_pointer = c;
1600 else if (operand->flags & MN10300_OPERAND_EPSW)
1602 char *start = input_line_pointer;
1603 char c = get_symbol_end ();
1605 if (strcasecmp (start, "epsw") != 0)
1607 *input_line_pointer = c;
1608 input_line_pointer = hold;
1612 *input_line_pointer = c;
1615 else if (operand->flags & MN10300_OPERAND_PLUS)
1617 if (*input_line_pointer != '+')
1619 input_line_pointer = hold;
1623 input_line_pointer++;
1626 else if (operand->flags & MN10300_OPERAND_PSW)
1628 char *start = input_line_pointer;
1629 char c = get_symbol_end ();
1631 if (strcasecmp (start, "psw") != 0)
1633 *input_line_pointer = c;
1634 input_line_pointer = hold;
1638 *input_line_pointer = c;
1641 else if (operand->flags & MN10300_OPERAND_MDR)
1643 char *start = input_line_pointer;
1644 char c = get_symbol_end ();
1646 if (strcasecmp (start, "mdr") != 0)
1648 *input_line_pointer = c;
1649 input_line_pointer = hold;
1653 *input_line_pointer = c;
1656 else if (operand->flags & MN10300_OPERAND_REG_LIST)
1658 unsigned int value = 0;
1659 if (*input_line_pointer != '[')
1661 input_line_pointer = hold;
1667 input_line_pointer++;
1669 /* We used to reject a null register list here; however,
1670 we accept it now so the compiler can emit "call"
1671 instructions for all calls to named functions.
1673 The linker can then fill in the appropriate bits for the
1674 register list and stack size or change the instruction
1675 into a "calls" if using "call" is not profitable. */
1676 while (*input_line_pointer != ']')
1681 if (*input_line_pointer == ',')
1682 input_line_pointer++;
1684 start = input_line_pointer;
1685 c = get_symbol_end ();
1687 if (strcasecmp (start, "d2") == 0)
1690 *input_line_pointer = c;
1692 else if (strcasecmp (start, "d3") == 0)
1695 *input_line_pointer = c;
1697 else if (strcasecmp (start, "a2") == 0)
1700 *input_line_pointer = c;
1702 else if (strcasecmp (start, "a3") == 0)
1705 *input_line_pointer = c;
1707 else if (strcasecmp (start, "other") == 0)
1710 *input_line_pointer = c;
1713 && strcasecmp (start, "exreg0") == 0)
1716 *input_line_pointer = c;
1719 && strcasecmp (start, "exreg1") == 0)
1722 *input_line_pointer = c;
1725 && strcasecmp (start, "exother") == 0)
1728 *input_line_pointer = c;
1731 && strcasecmp (start, "all") == 0)
1734 *input_line_pointer = c;
1738 input_line_pointer = hold;
1743 input_line_pointer++;
1744 mn10300_insert_operand (&insn, &extension, operand,
1745 value, (char *) NULL, 0, 0);
1749 else if (data_register_name (&ex))
1751 input_line_pointer = hold;
1755 else if (address_register_name (&ex))
1757 input_line_pointer = hold;
1761 else if (other_register_name (&ex))
1763 input_line_pointer = hold;
1767 else if (HAVE_AM33 && r_register_name (&ex))
1769 input_line_pointer = hold;
1773 else if (HAVE_AM33 && xr_register_name (&ex))
1775 input_line_pointer = hold;
1779 else if (HAVE_AM33_2 && float_register_name (&ex))
1781 input_line_pointer = hold;
1785 else if (HAVE_AM33_2 && double_register_name (&ex))
1787 input_line_pointer = hold;
1791 else if (*str == ')' || *str == '(')
1793 input_line_pointer = hold;
1805 errmsg = _("illegal operand");
1808 errmsg = _("missing operand");
1814 mask = MN10300_OPERAND_DREG | MN10300_OPERAND_AREG;
1816 mask |= MN10300_OPERAND_RREG | MN10300_OPERAND_XRREG;
1818 mask |= MN10300_OPERAND_FSREG | MN10300_OPERAND_FDREG;
1819 if ((operand->flags & mask) == 0)
1821 input_line_pointer = hold;
1826 if (opcode->format == FMT_D1 || opcode->format == FMT_S1)
1828 else if (opcode->format == FMT_D2
1829 || opcode->format == FMT_D4
1830 || opcode->format == FMT_S2
1831 || opcode->format == FMT_S4
1832 || opcode->format == FMT_S6
1833 || opcode->format == FMT_D5)
1835 else if (opcode->format == FMT_D7)
1837 else if (opcode->format == FMT_D8 || opcode->format == FMT_D9)
1842 mn10300_insert_operand (&insn, &extension, operand,
1843 ex.X_add_number, (char *) NULL,
1846 /* And note the register number in the register array. */
1847 mn10300_reg_operands[op_idx - 1] = ex.X_add_number;
1852 /* If this operand can be promoted, and it doesn't
1853 fit into the allocated bitfield for this insn,
1854 then promote it (ie this opcode does not match). */
1856 & (MN10300_OPERAND_PROMOTE | MN10300_OPERAND_RELAX)
1857 && !check_operand (insn, operand, ex.X_add_number))
1859 input_line_pointer = hold;
1864 mn10300_insert_operand (&insn, &extension, operand,
1865 ex.X_add_number, (char *) NULL,
1870 /* If this operand can be promoted, then this opcode didn't
1871 match since we can't know if it needed promotion! */
1872 if (operand->flags & MN10300_OPERAND_PROMOTE)
1874 input_line_pointer = hold;
1879 /* We need to generate a fixup for this expression. */
1880 if (fc >= MAX_INSN_FIXUPS)
1881 as_fatal (_("too many fixups"));
1882 fixups[fc].exp = ex;
1883 fixups[fc].opindex = *opindex_ptr;
1884 fixups[fc].reloc = BFD_RELOC_UNUSED;
1885 if (mn10300_check_fixup (& fixups[fc]))
1892 str = input_line_pointer;
1893 input_line_pointer = hold;
1895 while (*str == ' ' || *str == ',')
1900 /* Make sure we used all the operands! */
1904 /* If this instruction has registers that must not match, verify
1905 that they do indeed not match. */
1906 if (opcode->no_match_operands)
1910 /* Look at each operand to see if it's marked. */
1911 for (i = 0; i < MN10300_MAX_OPERANDS; i++)
1913 if ((1 << i) & opcode->no_match_operands)
1917 /* operand I is marked. Check that it does not match any
1918 operands > I which are marked. */
1919 for (j = i + 1; j < MN10300_MAX_OPERANDS; j++)
1921 if (((1 << j) & opcode->no_match_operands)
1922 && mn10300_reg_operands[i] == mn10300_reg_operands[j])
1924 errmsg = _("Invalid register specification.");
1936 next_opcode = opcode + 1;
1937 if (!strcmp (next_opcode->name, opcode->name))
1939 opcode = next_opcode;
1943 as_bad ("%s", errmsg);
1949 while (ISSPACE (*str))
1953 as_bad (_("junk at end of line: `%s'"), str);
1955 input_line_pointer = str;
1957 /* Determine the size of the instruction. */
1958 if (opcode->format == FMT_S0)
1961 if (opcode->format == FMT_S1 || opcode->format == FMT_D0)
1964 if (opcode->format == FMT_S2 || opcode->format == FMT_D1)
1967 if (opcode->format == FMT_D6)
1970 if (opcode->format == FMT_D7 || opcode->format == FMT_D10)
1973 if (opcode->format == FMT_D8)
1976 if (opcode->format == FMT_D9)
1979 if (opcode->format == FMT_S4)
1982 if (opcode->format == FMT_S6 || opcode->format == FMT_D5)
1985 if (opcode->format == FMT_D2)
1988 if (opcode->format == FMT_D3)
1991 if (opcode->format == FMT_D4)
1994 if (relaxable && fc > 0)
1998 /* We want to anchor the line info to the previous frag (if
1999 there isn't one, create it), so that, when the insn is
2000 resized, we still get the right address for the beginning of
2003 dwarf2_emit_insn (0);
2008 /* Handle bra specially. Basically treat it like jmp so
2009 that we automatically handle 8, 16 and 32 bit offsets
2010 correctly as well as jumps to an undefined address.
2012 It is also important to not treat it like other bCC
2013 instructions since the long forms of bra is different
2014 from other bCC instructions. */
2015 if (opcode->opcode == 0xca00)
2027 else if (size == 3 && opcode->opcode == 0xcc0000)
2029 else if (size == 3 && (opcode->opcode & 0xfff000) == 0xf8d000)
2031 /* bCC (uncommon cases) */
2035 f = frag_var (rs_machine_dependent, 8, 8 - size, type,
2036 fixups[0].exp.X_add_symbol,
2037 fixups[0].exp.X_add_number,
2038 (char *)fixups[0].opindex);
2040 /* This is pretty hokey. We basically just care about the
2041 opcode, so we have to write out the first word big endian.
2043 The exception is "call", which has two operands that we
2046 The first operand (the register list) happens to be in the
2047 first instruction word, and will be in the right place if
2048 we output the first word in big endian mode.
2050 The second operand (stack size) is in the extension word,
2051 and we want it to appear as the first character in the extension
2052 word (as it appears in memory). Luckily, writing the extension
2053 word in big endian format will do what we want. */
2054 number_to_chars_bigendian (f, insn, size > 4 ? 4 : size);
2057 number_to_chars_bigendian (f + 4, extension, 4);
2058 number_to_chars_bigendian (f + 8, 0, size - 8);
2061 number_to_chars_bigendian (f + 4, extension, size - 4);
2065 /* Allocate space for the instruction. */
2066 f = frag_more (size);
2068 /* Fill in bytes for the instruction. Note that opcode fields
2069 are written big-endian, 16 & 32bit immediates are written
2070 little endian. Egad. */
2071 if (opcode->format == FMT_S0
2072 || opcode->format == FMT_S1
2073 || opcode->format == FMT_D0
2074 || opcode->format == FMT_D6
2075 || opcode->format == FMT_D7
2076 || opcode->format == FMT_D10
2077 || opcode->format == FMT_D1)
2079 number_to_chars_bigendian (f, insn, size);
2081 else if (opcode->format == FMT_S2
2082 && opcode->opcode != 0xdf0000
2083 && opcode->opcode != 0xde0000)
2085 /* A format S2 instruction that is _not_ "ret" and "retf". */
2086 number_to_chars_bigendian (f, (insn >> 16) & 0xff, 1);
2087 number_to_chars_littleendian (f + 1, insn & 0xffff, 2);
2089 else if (opcode->format == FMT_S2)
2091 /* This must be a ret or retf, which is written entirely in
2092 big-endian format. */
2093 number_to_chars_bigendian (f, insn, 3);
2095 else if (opcode->format == FMT_S4
2096 && opcode->opcode != 0xdc000000)
2098 /* This must be a format S4 "call" instruction. What a pain. */
2099 unsigned long temp = (insn >> 8) & 0xffff;
2100 number_to_chars_bigendian (f, (insn >> 24) & 0xff, 1);
2101 number_to_chars_littleendian (f + 1, temp, 2);
2102 number_to_chars_bigendian (f + 3, insn & 0xff, 1);
2103 number_to_chars_bigendian (f + 4, extension & 0xff, 1);
2105 else if (opcode->format == FMT_S4)
2107 /* This must be a format S4 "jmp" instruction. */
2108 unsigned long temp = ((insn & 0xffffff) << 8) | (extension & 0xff);
2109 number_to_chars_bigendian (f, (insn >> 24) & 0xff, 1);
2110 number_to_chars_littleendian (f + 1, temp, 4);
2112 else if (opcode->format == FMT_S6)
2114 unsigned long temp = ((insn & 0xffffff) << 8)
2115 | ((extension >> 16) & 0xff);
2116 number_to_chars_bigendian (f, (insn >> 24) & 0xff, 1);
2117 number_to_chars_littleendian (f + 1, temp, 4);
2118 number_to_chars_bigendian (f + 5, (extension >> 8) & 0xff, 1);
2119 number_to_chars_bigendian (f + 6, extension & 0xff, 1);
2121 else if (opcode->format == FMT_D2
2122 && opcode->opcode != 0xfaf80000
2123 && opcode->opcode != 0xfaf00000
2124 && opcode->opcode != 0xfaf40000)
2126 /* A format D2 instruction where the 16bit immediate is
2127 really a single 16bit value, not two 8bit values. */
2128 number_to_chars_bigendian (f, (insn >> 16) & 0xffff, 2);
2129 number_to_chars_littleendian (f + 2, insn & 0xffff, 2);
2131 else if (opcode->format == FMT_D2)
2133 /* A format D2 instruction where the 16bit immediate
2134 is really two 8bit immediates. */
2135 number_to_chars_bigendian (f, insn, 4);
2137 else if (opcode->format == FMT_D3)
2139 number_to_chars_bigendian (f, (insn >> 16) & 0xffff, 2);
2140 number_to_chars_littleendian (f + 2, insn & 0xffff, 2);
2141 number_to_chars_bigendian (f + 4, extension & 0xff, 1);
2143 else if (opcode->format == FMT_D4)
2145 unsigned long temp = ((insn & 0xffff) << 16) | (extension & 0xffff);
2147 number_to_chars_bigendian (f, (insn >> 16) & 0xffff, 2);
2148 number_to_chars_littleendian (f + 2, temp, 4);
2150 else if (opcode->format == FMT_D5)
2152 unsigned long temp = (((insn & 0xffff) << 16)
2153 | ((extension >> 8) & 0xffff));
2155 number_to_chars_bigendian (f, (insn >> 16) & 0xffff, 2);
2156 number_to_chars_littleendian (f + 2, temp, 4);
2157 number_to_chars_bigendian (f + 6, extension & 0xff, 1);
2159 else if (opcode->format == FMT_D8)
2161 unsigned long temp = ((insn & 0xff) << 16) | (extension & 0xffff);
2163 number_to_chars_bigendian (f, (insn >> 8) & 0xffffff, 3);
2164 number_to_chars_bigendian (f + 3, (temp & 0xff), 1);
2165 number_to_chars_littleendian (f + 4, temp >> 8, 2);
2167 else if (opcode->format == FMT_D9)
2169 unsigned long temp = ((insn & 0xff) << 24) | (extension & 0xffffff);
2171 number_to_chars_bigendian (f, (insn >> 8) & 0xffffff, 3);
2172 number_to_chars_littleendian (f + 3, temp, 4);
2175 /* Create any fixups. */
2176 for (i = 0; i < fc; i++)
2178 const struct mn10300_operand *operand;
2180 operand = &mn10300_operands[fixups[i].opindex];
2181 if (fixups[i].reloc != BFD_RELOC_UNUSED
2182 && fixups[i].reloc != BFD_RELOC_32_GOT_PCREL
2183 && fixups[i].reloc != BFD_RELOC_32_GOTOFF
2184 && fixups[i].reloc != BFD_RELOC_32_PLT_PCREL
2185 && fixups[i].reloc != BFD_RELOC_MN10300_GOT32)
2187 reloc_howto_type *reloc_howto;
2192 reloc_howto = bfd_reloc_type_lookup (stdoutput,
2198 size = bfd_get_reloc_size (reloc_howto);
2200 if (size < 1 || size > 4)
2204 fixP = fix_new_exp (frag_now, f - frag_now->fr_literal + offset,
2205 size, &fixups[i].exp,
2206 reloc_howto->pc_relative,
2211 int reloc, pcrel, reloc_size, offset;
2214 reloc = BFD_RELOC_NONE;
2215 if (fixups[i].reloc != BFD_RELOC_UNUSED)
2216 reloc = fixups[i].reloc;
2217 /* How big is the reloc? Remember SPLIT relocs are
2218 implicitly 32bits. */
2219 if ((operand->flags & MN10300_OPERAND_SPLIT) != 0)
2221 else if ((operand->flags & MN10300_OPERAND_24BIT) != 0)
2224 reloc_size = operand->bits;
2226 /* Is the reloc pc-relative? */
2227 pcrel = (operand->flags & MN10300_OPERAND_PCREL) != 0;
2228 if (reloc != BFD_RELOC_NONE)
2229 pcrel = bfd_reloc_type_lookup (stdoutput, reloc)->pc_relative;
2231 offset = size - (reloc_size + operand->shift) / 8;
2233 /* Choose a proper BFD relocation type. */
2234 if (reloc != BFD_RELOC_NONE)
2238 if (reloc_size == 32)
2239 reloc = BFD_RELOC_32_PCREL;
2240 else if (reloc_size == 16)
2241 reloc = BFD_RELOC_16_PCREL;
2242 else if (reloc_size == 8)
2243 reloc = BFD_RELOC_8_PCREL;
2249 if (reloc_size == 32)
2250 reloc = BFD_RELOC_32;
2251 else if (reloc_size == 16)
2252 reloc = BFD_RELOC_16;
2253 else if (reloc_size == 8)
2254 reloc = BFD_RELOC_8;
2259 /* Convert the size of the reloc into what fix_new_exp wants. */
2260 reloc_size = reloc_size / 8;
2261 if (reloc_size == 8)
2263 else if (reloc_size == 16)
2265 else if (reloc_size == 32)
2268 fixP = fix_new_exp (frag_now, f - frag_now->fr_literal + offset,
2269 reloc_size, &fixups[i].exp, pcrel,
2270 ((bfd_reloc_code_real_type) reloc));
2273 fixP->fx_offset += offset;
2277 dwarf2_emit_insn (size);
2281 /* If while processing a fixup, a reloc really needs to be created
2282 then it is done here. */
2285 tc_gen_reloc (seg, fixp)
2286 asection *seg ATTRIBUTE_UNUSED;
2290 reloc = (arelent *) xmalloc (sizeof (arelent));
2292 reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
2293 if (reloc->howto == (reloc_howto_type *) NULL)
2295 as_bad_where (fixp->fx_file, fixp->fx_line,
2296 _("reloc %d not supported by object file format"),
2297 (int) fixp->fx_r_type);
2300 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
2303 && S_GET_SEGMENT (fixp->fx_subsy) == absolute_section)
2305 fixp->fx_offset -= S_GET_VALUE (fixp->fx_subsy);
2309 if (fixp->fx_addsy && fixp->fx_subsy)
2311 reloc->sym_ptr_ptr = NULL;
2313 /* If we got a difference between two symbols, and the
2314 subtracted symbol is in the current section, use a
2315 PC-relative relocation. If both symbols are in the same
2316 section, the difference would have already been simplified
2318 if (S_GET_SEGMENT (fixp->fx_subsy) == seg)
2320 reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
2321 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
2322 reloc->addend = (reloc->address - S_GET_VALUE (fixp->fx_subsy)
2325 switch (fixp->fx_r_type)
2328 reloc->howto = bfd_reloc_type_lookup (stdoutput,
2333 reloc->howto = bfd_reloc_type_lookup (stdoutput,
2334 BFD_RELOC_16_PCREL);
2338 reloc->howto = bfd_reloc_type_lookup (stdoutput,
2339 BFD_RELOC_24_PCREL);
2343 reloc->howto = bfd_reloc_type_lookup (stdoutput,
2344 BFD_RELOC_32_PCREL);
2348 /* Try to compute the absolute value below. */
2353 if ((S_GET_SEGMENT (fixp->fx_addsy) != S_GET_SEGMENT (fixp->fx_subsy))
2354 || S_GET_SEGMENT (fixp->fx_addsy) == undefined_section)
2356 as_bad_where (fixp->fx_file, fixp->fx_line,
2357 "Difference of symbols in different sections is not supported");
2361 char *fixpos = fixp->fx_where + fixp->fx_frag->fr_literal;
2363 reloc->addend = (S_GET_VALUE (fixp->fx_addsy)
2364 - S_GET_VALUE (fixp->fx_subsy) + fixp->fx_offset);
2366 switch (fixp->fx_r_type)
2369 md_number_to_chars (fixpos, reloc->addend, 1);
2373 md_number_to_chars (fixpos, reloc->addend, 2);
2377 md_number_to_chars (fixpos, reloc->addend, 3);
2381 md_number_to_chars (fixpos, reloc->addend, 4);
2385 reloc->sym_ptr_ptr = (asymbol **) &bfd_abs_symbol;
2390 if (reloc->sym_ptr_ptr)
2391 free (reloc->sym_ptr_ptr);
2397 reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
2398 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
2399 reloc->addend = fixp->fx_offset;
2405 md_estimate_size_before_relax (fragp, seg)
2409 if (fragp->fr_subtype == 6
2410 && (!S_IS_DEFINED (fragp->fr_symbol)
2411 || seg != S_GET_SEGMENT (fragp->fr_symbol)))
2412 fragp->fr_subtype = 7;
2413 else if (fragp->fr_subtype == 8
2414 && (!S_IS_DEFINED (fragp->fr_symbol)
2415 || seg != S_GET_SEGMENT (fragp->fr_symbol)))
2416 fragp->fr_subtype = 9;
2417 else if (fragp->fr_subtype == 10
2418 && (!S_IS_DEFINED (fragp->fr_symbol)
2419 || seg != S_GET_SEGMENT (fragp->fr_symbol)))
2420 fragp->fr_subtype = 12;
2422 if (fragp->fr_subtype == 13)
2424 if (fragp->fr_subtype >= sizeof (md_relax_table) / sizeof (md_relax_table[0]))
2427 return md_relax_table[fragp->fr_subtype].rlx_length;
2431 md_pcrel_from (fixp)
2434 if (fixp->fx_addsy != (symbolS *) NULL && !S_IS_DEFINED (fixp->fx_addsy))
2436 /* The symbol is undefined. Let the linker figure it out. */
2439 return fixp->fx_frag->fr_address + fixp->fx_where;
2443 md_apply_fix3 (fixP, valP, seg)
2448 char * fixpos = fixP->fx_where + fixP->fx_frag->fr_literal;
2450 int value = (int) * valP;
2452 assert (fixP->fx_r_type < BFD_RELOC_UNUSED);
2454 /* This should never happen. */
2455 if (seg->flags & SEC_ALLOC)
2458 /* The value we are passed in *valuep includes the symbol values.
2459 Since we are using BFD_ASSEMBLER, if we are doing this relocation
2460 the code in write.c is going to call bfd_install_relocation, which
2461 is also going to use the symbol value. That means that if the
2462 reloc is fully resolved we want to use *valuep since
2463 bfd_install_relocation is not being used.
2465 However, if the reloc is not fully resolved we do not want to use
2466 *valuep, and must use fx_offset instead. However, if the reloc
2467 is PC relative, we do want to use *valuep since it includes the
2468 result of md_pcrel_from. */
2469 if (fixP->fx_addsy != (symbolS *) NULL && ! fixP->fx_pcrel)
2470 value = fixP->fx_offset;
2472 /* If the fix is relative to a symbol which is not defined, or not
2473 in the same segment as the fix, we cannot resolve it here. */
2474 if (fixP->fx_addsy != NULL
2475 && (! S_IS_DEFINED (fixP->fx_addsy)
2476 || (S_GET_SEGMENT (fixP->fx_addsy) != seg)))
2482 switch (fixP->fx_r_type)
2485 case BFD_RELOC_8_PCREL:
2490 case BFD_RELOC_16_PCREL:
2495 case BFD_RELOC_32_PCREL:
2499 case BFD_RELOC_VTABLE_INHERIT:
2500 case BFD_RELOC_VTABLE_ENTRY:
2504 case BFD_RELOC_NONE:
2506 as_bad_where (fixP->fx_file, fixP->fx_line,
2507 _("Bad relocation fixup type (%d)"), fixP->fx_r_type);
2510 md_number_to_chars (fixpos, value, size);
2512 /* If a symbol remains, pass the fixup, as a reloc, onto the linker. */
2513 if (fixP->fx_addsy == NULL)
2517 /* Return zero if the fixup in fixp should be left alone and not
2521 mn10300_fix_adjustable (fixp)
2524 if (! TC_RELOC_RTSYM_LOC_FIXUP (fixp))
2527 if (fixp->fx_r_type == BFD_RELOC_VTABLE_INHERIT
2528 || fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
2531 /* Do not adjust relocations involving symbols in code sections,
2532 because it breaks linker relaxations. This could be fixed in the
2533 linker, but this fix is simpler, and it pretty much only affects
2534 object size a little bit. */
2535 if (S_GET_SEGMENT (fixp->fx_addsy)->flags & SEC_CODE)
2541 /* Insert an operand value into an instruction. */
2544 mn10300_insert_operand (insnp, extensionp, operand, val, file, line, shift)
2545 unsigned long *insnp;
2546 unsigned long *extensionp;
2547 const struct mn10300_operand *operand;
2553 /* No need to check 32bit operands for a bit. Note that
2554 MN10300_OPERAND_SPLIT is an implicit 32bit operand. */
2555 if (operand->bits != 32
2556 && (operand->flags & MN10300_OPERAND_SPLIT) == 0)
2562 bits = operand->bits;
2563 if (operand->flags & MN10300_OPERAND_24BIT)
2566 if ((operand->flags & MN10300_OPERAND_SIGNED) != 0)
2568 max = (1 << (bits - 1)) - 1;
2569 min = - (1 << (bits - 1));
2573 max = (1 << bits) - 1;
2579 if (test < (offsetT) min || test > (offsetT) max)
2582 _("operand out of range (%s not between %ld and %ld)");
2585 sprint_value (buf, test);
2586 if (file == (char *) NULL)
2587 as_warn (err, buf, min, max);
2589 as_warn_where (file, line, err, buf, min, max);
2593 if ((operand->flags & MN10300_OPERAND_SPLIT) != 0)
2595 *insnp |= (val >> (32 - operand->bits)) & ((1 << operand->bits) - 1);
2596 *extensionp |= ((val & ((1 << (32 - operand->bits)) - 1))
2599 else if ((operand->flags & MN10300_OPERAND_24BIT) != 0)
2601 *insnp |= (val >> (24 - operand->bits)) & ((1 << operand->bits) - 1);
2602 *extensionp |= ((val & ((1 << (24 - operand->bits)) - 1))
2605 else if ((operand->flags & (MN10300_OPERAND_FSREG | MN10300_OPERAND_FDREG)))
2607 /* See devo/opcodes/m10300-opc.c just before #define FSM0 for an
2608 explanation of these variables. Note that FMT-implied shifts
2609 are not taken into account for FP registers. */
2610 unsigned long mask_low, mask_high;
2611 int shl_low, shr_high, shl_high;
2613 switch (operand->bits)
2616 /* Handle regular FP registers. */
2617 if (operand->shift >= 0)
2619 /* This is an `m' register. */
2620 shl_low = operand->shift;
2621 shl_high = 8 + (8 & shl_low) + (shl_low & 4) / 4;
2625 /* This is an `n' register. */
2626 shl_low = -operand->shift;
2627 shl_high = shl_low / 4;
2636 /* Handle accumulators. */
2637 shl_low = -operand->shift;
2647 *insnp |= ((((val & mask_high) >> shr_high) << shl_high)
2648 | ((val & mask_low) << shl_low));
2650 else if ((operand->flags & MN10300_OPERAND_EXTENDED) == 0)
2652 *insnp |= (((long) val & ((1 << operand->bits) - 1))
2653 << (operand->shift + shift));
2655 if ((operand->flags & MN10300_OPERAND_REPEATED) != 0)
2656 *insnp |= (((long) val & ((1 << operand->bits) - 1))
2657 << (operand->shift + shift + operand->bits));
2661 *extensionp |= (((long) val & ((1 << operand->bits) - 1))
2662 << (operand->shift + shift));
2664 if ((operand->flags & MN10300_OPERAND_REPEATED) != 0)
2665 *extensionp |= (((long) val & ((1 << operand->bits) - 1))
2666 << (operand->shift + shift + operand->bits));
2670 static unsigned long
2671 check_operand (insn, operand, val)
2672 unsigned long insn ATTRIBUTE_UNUSED;
2673 const struct mn10300_operand *operand;
2676 /* No need to check 32bit operands for a bit. Note that
2677 MN10300_OPERAND_SPLIT is an implicit 32bit operand. */
2678 if (operand->bits != 32
2679 && (operand->flags & MN10300_OPERAND_SPLIT) == 0)
2685 bits = operand->bits;
2686 if (operand->flags & MN10300_OPERAND_24BIT)
2689 if ((operand->flags & MN10300_OPERAND_SIGNED) != 0)
2691 max = (1 << (bits - 1)) - 1;
2692 min = - (1 << (bits - 1));
2696 max = (1 << bits) - 1;
2702 if (test < (offsetT) min || test > (offsetT) max)
2711 set_arch_mach (mach)
2714 if (!bfd_set_arch_mach (stdoutput, bfd_arch_mn10300, mach))
2715 as_warn (_("could not set architecture and machine"));
2717 current_machine = mach;
2720 static inline char * mn10300_end_of_match PARAMS ((char *, char *));
2722 static inline char *
2723 mn10300_end_of_match (cont, what)
2726 int len = strlen (what);
2728 if (strncmp (cont, what, strlen (what)) == 0
2729 && ! is_part_of_name (cont[len]))
2736 mn10300_parse_name (name, exprP, nextcharP)
2741 char *next = input_line_pointer;
2746 exprP->X_op_symbol = NULL;
2748 if (strcmp (name, GLOBAL_OFFSET_TABLE_NAME) == 0)
2751 GOT_symbol = symbol_find_or_make (name);
2753 exprP->X_add_symbol = GOT_symbol;
2755 /* If we have an absolute symbol or a reg,
2756 then we know its value now. */
2757 segment = S_GET_SEGMENT (exprP->X_add_symbol);
2758 if (segment == absolute_section)
2760 exprP->X_op = O_constant;
2761 exprP->X_add_number = S_GET_VALUE (exprP->X_add_symbol);
2762 exprP->X_add_symbol = NULL;
2764 else if (segment == reg_section)
2766 exprP->X_op = O_register;
2767 exprP->X_add_number = S_GET_VALUE (exprP->X_add_symbol);
2768 exprP->X_add_symbol = NULL;
2772 exprP->X_op = O_symbol;
2773 exprP->X_add_number = 0;
2779 exprP->X_add_symbol = symbol_find_or_make (name);
2781 if (*nextcharP != '@')
2783 else if ((next_end = mn10300_end_of_match (next + 1, "GOTOFF")))
2784 reloc_type = BFD_RELOC_32_GOTOFF;
2785 else if ((next_end = mn10300_end_of_match (next + 1, "GOT")))
2786 reloc_type = BFD_RELOC_MN10300_GOT32;
2787 else if ((next_end = mn10300_end_of_match (next + 1, "PLT")))
2788 reloc_type = BFD_RELOC_32_PLT_PCREL;
2792 *input_line_pointer = *nextcharP;
2793 input_line_pointer = next_end;
2794 *nextcharP = *input_line_pointer;
2795 *input_line_pointer = '\0';
2797 exprP->X_op = O_PIC_reloc;
2798 exprP->X_add_number = 0;
2799 exprP->X_md = reloc_type;