* mmo.c (File Layout): Correct place of misplaced blurb about
[binutils.git] / gas / config / tc-mn10300.c
blobea5b533dec10d0271fcee9b33a58cd2daf492718
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)
10 any later version.
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. */
22 #include <stdio.h>
23 #include "as.h"
24 #include "safe-ctype.h"
25 #include "subsegs.h"
26 #include "opcode/mn10300.h"
27 #include "dwarf2dbg.h"
29 /* Structure to hold information about predefined registers. */
30 struct reg_name
32 const char *name;
33 int value;
36 /* Generic assembler global variables which must be defined by all
37 targets. */
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
46 single line. */
47 const char line_separator_chars[] = ";";
49 /* Characters which are used to indicate an exponent in a floating
50 point number. */
51 const char EXP_CHARS[] = "eE";
53 /* Characters which mean that a number is a floating point constant,
54 as in 0d1.0. */
55 const char FLT_CHARS[] = "dD";
57 const relax_typeS md_relax_table[] = {
58 /* bCC relaxing */
59 {0x7f, -0x80, 2, 1},
60 {0x7fff, -0x8000, 5, 2},
61 {0x7fffffff, -0x80000000, 7, 0},
63 /* bCC relaxing (uncommon cases) */
64 {0x7f, -0x80, 3, 4},
65 {0x7fff, -0x8000, 6, 5},
66 {0x7fffffff, -0x80000000, 8, 0},
68 /* call relaxing */
69 {0x7fff, -0x8000, 5, 7},
70 {0x7fffffff, -0x80000000, 7, 0},
72 /* calls relaxing */
73 {0x7fff, -0x8000, 4, 9},
74 {0x7fffffff, -0x80000000, 6, 0},
76 /* jmp relaxing */
77 {0x7f, -0x80, 2, 11},
78 {0x7fff, -0x8000, 3, 12},
79 {0x7fffffff, -0x80000000, 5, 0},
81 /* fbCC relaxing */
82 {0x7f, -0x80, 3, 14},
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,
92 unsigned));
93 static unsigned long check_operand PARAMS ((unsigned long,
94 const struct mn10300_operand *,
95 offsetT));
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. */
105 int linkrelax = 1;
107 static int current_machine;
109 /* Fixups. */
110 #define MAX_INSN_FIXUPS (5)
111 struct mn10300_fixup
113 expressionS exp;
114 int opindex;
115 bfd_reloc_code_real_type reloc;
117 struct mn10300_fixup fixups[MAX_INSN_FIXUPS];
118 static int fc;
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 },
137 {NULL, 0, 0}
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[] =
150 { "d0", 0 },
151 { "d1", 1 },
152 { "d2", 2 },
153 { "d3", 3 },
155 #define DATA_REG_NAME_CNT \
156 (sizeof (data_registers) / sizeof (struct reg_name))
158 static const struct reg_name address_registers[] =
160 { "a0", 0 },
161 { "a1", 1 },
162 { "a2", 2 },
163 { "a3", 3 },
166 #define ADDRESS_REG_NAME_CNT \
167 (sizeof (address_registers) / sizeof (struct reg_name))
169 static const struct reg_name r_registers[] =
171 { "a0", 8 },
172 { "a1", 9 },
173 { "a2", 10 },
174 { "a3", 11 },
175 { "d0", 12 },
176 { "d1", 13 },
177 { "d2", 14 },
178 { "d3", 15 },
179 { "e0", 0 },
180 { "e1", 1 },
181 { "e10", 10 },
182 { "e11", 11 },
183 { "e12", 12 },
184 { "e13", 13 },
185 { "e14", 14 },
186 { "e15", 15 },
187 { "e2", 2 },
188 { "e3", 3 },
189 { "e4", 4 },
190 { "e5", 5 },
191 { "e6", 6 },
192 { "e7", 7 },
193 { "e8", 8 },
194 { "e9", 9 },
195 { "r0", 0 },
196 { "r1", 1 },
197 { "r10", 10 },
198 { "r11", 11 },
199 { "r12", 12 },
200 { "r13", 13 },
201 { "r14", 14 },
202 { "r15", 15 },
203 { "r2", 2 },
204 { "r3", 3 },
205 { "r4", 4 },
206 { "r5", 5 },
207 { "r6", 6 },
208 { "r7", 7 },
209 { "r8", 8 },
210 { "r9", 9 },
213 #define R_REG_NAME_CNT \
214 (sizeof (r_registers) / sizeof (struct reg_name))
216 static const struct reg_name xr_registers[] =
218 { "mcrh", 2 },
219 { "mcrl", 3 },
220 { "mcvf", 4 },
221 { "mdrq", 1 },
222 { "sp", 0 },
223 { "xr0", 0 },
224 { "xr1", 1 },
225 { "xr10", 10 },
226 { "xr11", 11 },
227 { "xr12", 12 },
228 { "xr13", 13 },
229 { "xr14", 14 },
230 { "xr15", 15 },
231 { "xr2", 2 },
232 { "xr3", 3 },
233 { "xr4", 4 },
234 { "xr5", 5 },
235 { "xr6", 6 },
236 { "xr7", 7 },
237 { "xr8", 8 },
238 { "xr9", 9 },
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[] =
251 { "epsw", AM33 },
252 { "mdr", 0 },
253 { "pc", AM33 },
254 { "psw", 0 },
255 { "sp", 0 },
258 #define OTHER_REG_NAME_CNT \
259 (sizeof (other_registers) / sizeof (struct reg_name))
261 static const struct reg_name float_registers[] =
263 { "fs0", 0 },
264 { "fs1", 1 },
265 { "fs10", 10 },
266 { "fs11", 11 },
267 { "fs12", 12 },
268 { "fs13", 13 },
269 { "fs14", 14 },
270 { "fs15", 15 },
271 { "fs16", 16 },
272 { "fs17", 17 },
273 { "fs18", 18 },
274 { "fs19", 19 },
275 { "fs2", 2 },
276 { "fs20", 20 },
277 { "fs21", 21 },
278 { "fs22", 22 },
279 { "fs23", 23 },
280 { "fs24", 24 },
281 { "fs25", 25 },
282 { "fs26", 26 },
283 { "fs27", 27 },
284 { "fs28", 28 },
285 { "fs29", 29 },
286 { "fs3", 3 },
287 { "fs30", 30 },
288 { "fs31", 31 },
289 { "fs4", 4 },
290 { "fs5", 5 },
291 { "fs6", 6 },
292 { "fs7", 7 },
293 { "fs8", 8 },
294 { "fs9", 9 },
297 #define FLOAT_REG_NAME_CNT \
298 (sizeof (float_registers) / sizeof (struct reg_name))
300 static const struct reg_name double_registers[] =
302 { "fd0", 0 },
303 { "fd10", 10 },
304 { "fd12", 12 },
305 { "fd14", 14 },
306 { "fd16", 16 },
307 { "fd18", 18 },
308 { "fd2", 2 },
309 { "fd20", 20 },
310 { "fd22", 22 },
311 { "fd24", 24 },
312 { "fd26", 26 },
313 { "fd28", 28 },
314 { "fd30", 30 },
315 { "fd4", 4 },
316 { "fd6", 6 },
317 { "fd8", 8 },
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. */
328 static int
329 reg_name_search (regs, regcount, name)
330 const struct reg_name *regs;
331 int regcount;
332 const char *name;
334 int middle, low, high;
335 int cmp;
337 low = 0;
338 high = regcount - 1;
342 middle = (low + high) / 2;
343 cmp = strcasecmp (name, regs[middle].name);
344 if (cmp < 0)
345 high = middle - 1;
346 else if (cmp > 0)
347 low = middle + 1;
348 else
349 return regs[middle].value;
351 while (low <= high);
352 return -1;
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.
366 static bfd_boolean
367 r_register_name (expressionP)
368 expressionS *expressionP;
370 int reg_number;
371 char *name;
372 char *start;
373 char c;
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. */
385 if (reg_number >= 0)
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;
394 return TRUE;
397 /* Reset the line as if we had not done anything. */
398 input_line_pointer = start;
399 return FALSE;
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.
413 static bfd_boolean
414 xr_register_name (expressionP)
415 expressionS *expressionP;
417 int reg_number;
418 char *name;
419 char *start;
420 char c;
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. */
432 if (reg_number >= 0)
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;
441 return TRUE;
444 /* Reset the line as if we had not done anything. */
445 input_line_pointer = start;
446 return FALSE;
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.
460 static bfd_boolean
461 data_register_name (expressionP)
462 expressionS *expressionP;
464 int reg_number;
465 char *name;
466 char *start;
467 char c;
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. */
479 if (reg_number >= 0)
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;
488 return TRUE;
491 /* Reset the line as if we had not done anything. */
492 input_line_pointer = start;
493 return FALSE;
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.
507 static bfd_boolean
508 address_register_name (expressionP)
509 expressionS *expressionP;
511 int reg_number;
512 char *name;
513 char *start;
514 char c;
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. */
526 if (reg_number >= 0)
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;
535 return TRUE;
538 /* Reset the line as if we had not done anything. */
539 input_line_pointer = start;
540 return FALSE;
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.
554 static bfd_boolean
555 other_register_name (expressionP)
556 expressionS *expressionP;
558 int reg_number;
559 char *name;
560 char *start;
561 char c;
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. */
573 if (reg_number == 0
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;
583 return TRUE;
586 /* Reset the line as if we had not done anything. */
587 input_line_pointer = start;
588 return FALSE;
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.
598 out: A expressionS.
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. */
604 static bfd_boolean
605 float_register_name (expressionP)
606 expressionS *expressionP;
608 int reg_number;
609 char *name;
610 char *start;
611 char c;
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. */
623 if (reg_number >= 0)
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;
632 return TRUE;
635 /* Reset the line as if we had not done anything. */
636 input_line_pointer = start;
637 return FALSE;
640 /* Summary of double_register_name:
642 in: Input_line_pointer points to 1st char of operand.
644 out: A expressionS.
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. */
650 static bfd_boolean
651 double_register_name (expressionP)
652 expressionS *expressionP;
654 int reg_number;
655 char *name;
656 char *start;
657 char c;
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. */
669 if (reg_number >= 0)
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;
678 return TRUE;
681 /* Reset the line as if we had not done anything. */
682 input_line_pointer = start;
683 return FALSE;
686 void
687 md_show_usage (stream)
688 FILE *stream;
690 fprintf (stream, _("MN10300 options:\n\
691 none yet\n"));
695 md_parse_option (c, arg)
696 int c ATTRIBUTE_UNUSED;
697 char *arg ATTRIBUTE_UNUSED;
699 return 0;
702 symbolS *
703 md_undefined_symbol (name)
704 char *name ATTRIBUTE_UNUSED;
706 return 0;
709 char *
710 md_atof (type, litp, sizep)
711 int type;
712 char *litp;
713 int *sizep;
715 int prec;
716 LITTLENUM_TYPE words[4];
717 char *t;
718 int i;
720 switch (type)
722 case 'f':
723 prec = 2;
724 break;
726 case 'd':
727 prec = 4;
728 break;
730 default:
731 *sizep = 0;
732 return "bad call to md_atof";
735 t = atof_ieee (input_line_pointer, type, words);
736 if (t)
737 input_line_pointer = t;
739 *sizep = prec * 2;
741 for (i = prec - 1; i >= 0; i--)
743 md_number_to_chars (litp, (valueT) words[i], 2);
744 litp += 2;
747 return NULL;
750 void
751 md_convert_frag (abfd, sec, fragP)
752 bfd *abfd ATTRIBUTE_UNUSED;
753 asection *sec;
754 fragS *fragP;
756 static unsigned long label_count = 0;
757 char buf[40];
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);
764 fragP->fr_var = 0;
765 fragP->fr_fix += 2;
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;
773 switch (opcode)
775 case 0xc8:
776 opcode = 0xc9;
777 break;
778 case 0xc9:
779 opcode = 0xc8;
780 break;
781 case 0xc0:
782 opcode = 0xc2;
783 break;
784 case 0xc2:
785 opcode = 0xc0;
786 break;
787 case 0xc3:
788 opcode = 0xc1;
789 break;
790 case 0xc1:
791 opcode = 0xc3;
792 break;
793 case 0xc4:
794 opcode = 0xc6;
795 break;
796 case 0xc6:
797 opcode = 0xc4;
798 break;
799 case 0xc7:
800 opcode = 0xc5;
801 break;
802 case 0xc5:
803 opcode = 0xc7;
804 break;
805 default:
806 abort ();
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
817 final target. */
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);
821 fragP->fr_var = 0;
822 fragP->fr_fix += 5;
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;
830 switch (opcode)
832 case 0xc8:
833 opcode = 0xc9;
834 break;
835 case 0xc9:
836 opcode = 0xc8;
837 break;
838 case 0xc0:
839 opcode = 0xc2;
840 break;
841 case 0xc2:
842 opcode = 0xc0;
843 break;
844 case 0xc3:
845 opcode = 0xc1;
846 break;
847 case 0xc1:
848 opcode = 0xc3;
849 break;
850 case 0xc4:
851 opcode = 0xc6;
852 break;
853 case 0xc6:
854 opcode = 0xc4;
855 break;
856 case 0xc7:
857 opcode = 0xc5;
858 break;
859 case 0xc5:
860 opcode = 0xc7;
861 break;
862 default:
863 abort ();
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
874 final target. */
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);
878 fragP->fr_var = 0;
879 fragP->fr_fix += 7;
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);
885 fragP->fr_var = 0;
886 fragP->fr_fix += 3;
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;
894 switch (opcode)
896 case 0xe8:
897 opcode = 0xe9;
898 break;
899 case 0xe9:
900 opcode = 0xe8;
901 break;
902 case 0xea:
903 opcode = 0xeb;
904 break;
905 case 0xeb:
906 opcode = 0xea;
907 break;
908 default:
909 abort ();
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
920 final target. */
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);
924 fragP->fr_var = 0;
925 fragP->fr_fix += 6;
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;
933 switch (opcode)
935 case 0xe8:
936 opcode = 0xe9;
937 break;
938 case 0xea:
939 opcode = 0xeb;
940 break;
941 case 0xeb:
942 opcode = 0xea;
943 break;
944 default:
945 abort ();
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
956 final target. */
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);
960 fragP->fr_var = 0;
961 fragP->fr_fix += 8;
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);
969 fragP->fr_var = 0;
970 fragP->fr_fix += 5;
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);
981 fragP->fr_var = 0;
982 fragP->fr_fix += 7;
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);
991 fragP->fr_var = 0;
992 fragP->fr_fix += 4;
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);
1002 fragP->fr_var = 0;
1003 fragP->fr_fix += 6;
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);
1010 fragP->fr_var = 0;
1011 fragP->fr_fix += 2;
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);
1020 fragP->fr_var = 0;
1021 fragP->fr_fix += 3;
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);
1030 fragP->fr_var = 0;
1031 fragP->fr_fix += 5;
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);
1037 fragP->fr_var = 0;
1038 fragP->fr_fix += 3;
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;
1046 switch (opcode)
1048 case 0xd0:
1049 opcode = 0xd1;
1050 break;
1051 case 0xd1:
1052 opcode = 0xd0;
1053 break;
1054 case 0xd2:
1055 opcode = 0xdc;
1056 break;
1057 case 0xd3:
1058 opcode = 0xdb;
1059 break;
1060 case 0xd4:
1061 opcode = 0xda;
1062 break;
1063 case 0xd5:
1064 opcode = 0xd9;
1065 break;
1066 case 0xd6:
1067 opcode = 0xd8;
1068 break;
1069 case 0xd7:
1070 opcode = 0xdd;
1071 break;
1072 case 0xd8:
1073 opcode = 0xd6;
1074 break;
1075 case 0xd9:
1076 opcode = 0xd5;
1077 break;
1078 case 0xda:
1079 opcode = 0xd4;
1080 break;
1081 case 0xdb:
1082 opcode = 0xd3;
1083 break;
1084 case 0xdc:
1085 opcode = 0xd2;
1086 break;
1087 case 0xdd:
1088 opcode = 0xd7;
1089 break;
1090 default:
1091 abort ();
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
1102 final target. */
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);
1106 fragP->fr_var = 0;
1107 fragP->fr_fix += 6;
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;
1115 switch (opcode)
1117 case 0xd0:
1118 opcode = 0xd1;
1119 break;
1120 case 0xd1:
1121 opcode = 0xd0;
1122 break;
1123 case 0xd2:
1124 opcode = 0xdc;
1125 break;
1126 case 0xd3:
1127 opcode = 0xdb;
1128 break;
1129 case 0xd4:
1130 opcode = 0xda;
1131 break;
1132 case 0xd5:
1133 opcode = 0xd9;
1134 break;
1135 case 0xd6:
1136 opcode = 0xd8;
1137 break;
1138 case 0xd7:
1139 opcode = 0xdd;
1140 break;
1141 case 0xd8:
1142 opcode = 0xd6;
1143 break;
1144 case 0xd9:
1145 opcode = 0xd5;
1146 break;
1147 case 0xda:
1148 opcode = 0xd4;
1149 break;
1150 case 0xdb:
1151 opcode = 0xd3;
1152 break;
1153 case 0xdc:
1154 opcode = 0xd2;
1155 break;
1156 case 0xdd:
1157 opcode = 0xd7;
1158 break;
1159 default:
1160 abort ();
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
1171 final target. */
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);
1175 fragP->fr_var = 0;
1176 fragP->fr_fix += 8;
1178 else
1179 abort ();
1182 valueT
1183 md_section_align (seg, addr)
1184 asection *seg;
1185 valueT addr;
1187 int align = bfd_get_section_alignment (stdoutput, seg);
1188 return ((addr + (1 << align) - 1) & (-1 << align));
1191 void
1192 md_begin ()
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;
1205 while (op->name)
1207 if (strcmp (prev_name, op->name))
1209 prev_name = (char *) op->name;
1210 hash_insert (mn10300_hash, op->name, (char *) op);
1212 op++;
1215 /* Set the default machine type. */
1216 #ifdef TE_LINUX
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;
1221 #else
1222 if (!bfd_set_arch_mach (stdoutput, bfd_arch_mn10300, MN103))
1223 as_warn (_("could not set architecture and machine"));
1225 current_machine = MN103;
1226 #endif
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 *));
1234 static inline int
1235 mn10300_PIC_related_p (sym)
1236 symbolS *sym;
1238 expressionS *exp;
1240 if (! sym)
1241 return 0;
1243 if (sym == GOT_symbol)
1244 return 1;
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));
1253 static inline int
1254 mn10300_check_fixup (fixup)
1255 struct mn10300_fixup *fixup;
1257 expressionS *exp = &fixup->exp;
1259 repeat:
1260 switch (exp->X_op)
1262 case O_add:
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))
1269 return 1;
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);
1275 goto repeat;
1277 case O_symbol:
1278 if (exp->X_add_symbol && exp->X_add_symbol == GOT_symbol)
1279 fixup->reloc = BFD_RELOC_32_GOT_PCREL;
1280 break;
1282 case O_PIC_reloc:
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))
1289 return 1;
1290 break;
1292 default:
1293 return (mn10300_PIC_related_p (exp->X_add_symbol)
1294 || mn10300_PIC_related_p (exp->X_op_symbol));
1297 return 0;
1300 void
1301 mn10300_cons_fix_new (frag, off, size, exp)
1302 fragS *frag;
1303 int off, size;
1304 expressionS *exp;
1306 struct mn10300_fixup fixup;
1308 fixup.opindex = -1;
1309 fixup.exp = *exp;
1310 fixup.reloc = BFD_RELOC_UNUSED;
1312 mn10300_check_fixup (&fixup);
1314 if (fixup.reloc == BFD_RELOC_MN10300_GOT32)
1315 switch (size)
1317 case 2:
1318 fixup.reloc = BFD_RELOC_MN10300_GOT16;
1319 break;
1321 case 3:
1322 fixup.reloc = BFD_RELOC_MN10300_GOT24;
1323 break;
1325 case 4:
1326 break;
1328 default:
1329 goto error;
1331 else if (fixup.reloc == BFD_RELOC_UNUSED)
1332 switch (size)
1334 case 1:
1335 fixup.reloc = BFD_RELOC_8;
1336 break;
1338 case 2:
1339 fixup.reloc = BFD_RELOC_16;
1340 break;
1342 case 3:
1343 fixup.reloc = BFD_RELOC_24;
1344 break;
1346 case 4:
1347 fixup.reloc = BFD_RELOC_32;
1348 break;
1350 default:
1351 goto error;
1353 else if (size != 4)
1355 error:
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);
1363 void
1364 md_assemble (str)
1365 char *str;
1367 char *s;
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;
1373 char *f;
1374 int i;
1375 int match;
1377 /* Get the opcode. */
1378 for (s = str; *s != '\0' && !ISSPACE (*s); s++)
1380 if (*s != '\0')
1381 *s++ = '\0';
1383 /* Find the first opcode with the proper name. */
1384 opcode = (struct mn10300_opcode *) hash_find (mn10300_hash, str);
1385 if (opcode == NULL)
1387 as_bad (_("Unrecognized opcode: `%s'"), str);
1388 return;
1391 str = s;
1392 while (ISSPACE (*str))
1393 ++str;
1395 input_line_pointer = str;
1397 for (;;)
1399 const char *errmsg;
1400 int op_idx;
1401 char *hold;
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));
1409 relaxable = 0;
1410 fc = 0;
1411 match = 0;
1412 next_opindex = 0;
1413 insn = opcode->opcode;
1414 extension = 0;
1416 /* If the instruction is not available on the current machine
1417 then it can not possibly match. */
1418 if (opcode->machine
1419 && !(opcode->machine == AM33_2 && HAVE_AM33_2)
1420 && !(opcode->machine == AM33 && HAVE_AM33)
1421 && !(opcode->machine == AM30 && HAVE_AM30))
1422 goto error;
1424 for (op_idx = 1, opindex_ptr = opcode->operands;
1425 *opindex_ptr != 0;
1426 opindex_ptr++, op_idx++)
1428 const struct mn10300_operand *operand;
1429 expressionS ex;
1431 if (next_opindex == 0)
1433 operand = &mn10300_operands[*opindex_ptr];
1435 else
1437 operand = &mn10300_operands[next_opindex];
1438 next_opindex = 0;
1441 while (*str == ' ' || *str == ',')
1442 ++str;
1444 if (operand->flags & MN10300_OPERAND_RELAX)
1445 relaxable = 1;
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;
1456 str = hold;
1457 goto error;
1459 input_line_pointer++;
1460 goto keep_going;
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;
1468 str = hold;
1469 goto error;
1472 else if (operand->flags & MN10300_OPERAND_AREG)
1474 if (!address_register_name (&ex))
1476 input_line_pointer = hold;
1477 str = hold;
1478 goto error;
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;
1490 str = hold;
1491 goto error;
1493 *input_line_pointer = c;
1494 goto keep_going;
1496 else if (operand->flags & MN10300_OPERAND_RREG)
1498 if (!r_register_name (&ex))
1500 input_line_pointer = hold;
1501 str = hold;
1502 goto error;
1505 else if (operand->flags & MN10300_OPERAND_XRREG)
1507 if (!xr_register_name (&ex))
1509 input_line_pointer = hold;
1510 str = hold;
1511 goto error;
1514 else if (operand->flags & MN10300_OPERAND_FSREG)
1516 if (!float_register_name (&ex))
1518 input_line_pointer = hold;
1519 str = hold;
1520 goto error;
1523 else if (operand->flags & MN10300_OPERAND_FDREG)
1525 if (!double_register_name (&ex))
1527 input_line_pointer = hold;
1528 str = hold;
1529 goto error;
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;
1541 str = hold;
1542 goto error;
1544 *input_line_pointer = c;
1545 goto keep_going;
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;
1556 str = hold;
1557 goto error;
1559 *input_line_pointer = c;
1560 goto keep_going;
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;
1571 str = hold;
1572 goto error;
1574 *input_line_pointer = c;
1575 goto keep_going;
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;
1586 str = hold;
1587 goto error;
1589 *input_line_pointer = c;
1590 goto keep_going;
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;
1601 str = hold;
1602 goto error;
1604 *input_line_pointer = c;
1605 goto keep_going;
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;
1616 str = hold;
1617 goto error;
1619 *input_line_pointer = c;
1620 goto keep_going;
1622 else if (operand->flags & MN10300_OPERAND_PLUS)
1624 if (*input_line_pointer != '+')
1626 input_line_pointer = hold;
1627 str = hold;
1628 goto error;
1630 input_line_pointer++;
1631 goto keep_going;
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;
1642 str = hold;
1643 goto error;
1645 *input_line_pointer = c;
1646 goto keep_going;
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;
1657 str = hold;
1658 goto error;
1660 *input_line_pointer = c;
1661 goto keep_going;
1663 else if (operand->flags & MN10300_OPERAND_REG_LIST)
1665 unsigned int value = 0;
1666 if (*input_line_pointer != '[')
1668 input_line_pointer = hold;
1669 str = hold;
1670 goto error;
1673 /* Eat the '['. */
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 != ']')
1685 char *start;
1686 char c;
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)
1696 value |= 0x80;
1697 *input_line_pointer = c;
1699 else if (strcasecmp (start, "d3") == 0)
1701 value |= 0x40;
1702 *input_line_pointer = c;
1704 else if (strcasecmp (start, "a2") == 0)
1706 value |= 0x20;
1707 *input_line_pointer = c;
1709 else if (strcasecmp (start, "a3") == 0)
1711 value |= 0x10;
1712 *input_line_pointer = c;
1714 else if (strcasecmp (start, "other") == 0)
1716 value |= 0x08;
1717 *input_line_pointer = c;
1719 else if (HAVE_AM33
1720 && strcasecmp (start, "exreg0") == 0)
1722 value |= 0x04;
1723 *input_line_pointer = c;
1725 else if (HAVE_AM33
1726 && strcasecmp (start, "exreg1") == 0)
1728 value |= 0x02;
1729 *input_line_pointer = c;
1731 else if (HAVE_AM33
1732 && strcasecmp (start, "exother") == 0)
1734 value |= 0x01;
1735 *input_line_pointer = c;
1737 else if (HAVE_AM33
1738 && strcasecmp (start, "all") == 0)
1740 value |= 0xff;
1741 *input_line_pointer = c;
1743 else
1745 input_line_pointer = hold;
1746 str = hold;
1747 goto error;
1750 input_line_pointer++;
1751 mn10300_insert_operand (&insn, &extension, operand,
1752 value, (char *) NULL, 0, 0);
1753 goto keep_going;
1756 else if (data_register_name (&ex))
1758 input_line_pointer = hold;
1759 str = hold;
1760 goto error;
1762 else if (address_register_name (&ex))
1764 input_line_pointer = hold;
1765 str = hold;
1766 goto error;
1768 else if (other_register_name (&ex))
1770 input_line_pointer = hold;
1771 str = hold;
1772 goto error;
1774 else if (HAVE_AM33 && r_register_name (&ex))
1776 input_line_pointer = hold;
1777 str = hold;
1778 goto error;
1780 else if (HAVE_AM33 && xr_register_name (&ex))
1782 input_line_pointer = hold;
1783 str = hold;
1784 goto error;
1786 else if (HAVE_AM33_2 && float_register_name (&ex))
1788 input_line_pointer = hold;
1789 str = hold;
1790 goto error;
1792 else if (HAVE_AM33_2 && double_register_name (&ex))
1794 input_line_pointer = hold;
1795 str = hold;
1796 goto error;
1798 else if (*str == ')' || *str == '(')
1800 input_line_pointer = hold;
1801 str = hold;
1802 goto error;
1804 else
1806 expression (&ex);
1809 switch (ex.X_op)
1811 case O_illegal:
1812 errmsg = _("illegal operand");
1813 goto error;
1814 case O_absent:
1815 errmsg = _("missing operand");
1816 goto error;
1817 case O_register:
1819 int mask;
1821 mask = MN10300_OPERAND_DREG | MN10300_OPERAND_AREG;
1822 if (HAVE_AM33)
1823 mask |= MN10300_OPERAND_RREG | MN10300_OPERAND_XRREG;
1824 if (HAVE_AM33_2)
1825 mask |= MN10300_OPERAND_FSREG | MN10300_OPERAND_FDREG;
1826 if ((operand->flags & mask) == 0)
1828 input_line_pointer = hold;
1829 str = hold;
1830 goto error;
1833 if (opcode->format == FMT_D1 || opcode->format == FMT_S1)
1834 extra_shift = 8;
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)
1841 extra_shift = 16;
1842 else if (opcode->format == FMT_D7)
1843 extra_shift = 8;
1844 else if (opcode->format == FMT_D8 || opcode->format == FMT_D9)
1845 extra_shift = 8;
1846 else
1847 extra_shift = 0;
1849 mn10300_insert_operand (&insn, &extension, operand,
1850 ex.X_add_number, (char *) NULL,
1851 0, extra_shift);
1853 /* And note the register number in the register array. */
1854 mn10300_reg_operands[op_idx - 1] = ex.X_add_number;
1855 break;
1858 case O_constant:
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). */
1862 if (operand->flags
1863 & (MN10300_OPERAND_PROMOTE | MN10300_OPERAND_RELAX)
1864 && !check_operand (insn, operand, ex.X_add_number))
1866 input_line_pointer = hold;
1867 str = hold;
1868 goto error;
1871 mn10300_insert_operand (&insn, &extension, operand,
1872 ex.X_add_number, (char *) NULL,
1873 0, 0);
1874 break;
1876 default:
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;
1882 str = hold;
1883 goto error;
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]))
1893 goto error;
1894 ++fc;
1895 break;
1898 keep_going:
1899 str = input_line_pointer;
1900 input_line_pointer = hold;
1902 while (*str == ' ' || *str == ',')
1903 ++str;
1907 /* Make sure we used all the operands! */
1908 if (*str != ',')
1909 match = 1;
1911 /* If this instruction has registers that must not match, verify
1912 that they do indeed not match. */
1913 if (opcode->no_match_operands)
1915 int i;
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)
1922 int j;
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.");
1932 match = 0;
1933 goto error;
1940 error:
1941 if (match == 0)
1943 next_opcode = opcode + 1;
1944 if (!strcmp (next_opcode->name, opcode->name))
1946 opcode = next_opcode;
1947 continue;
1950 as_bad ("%s", errmsg);
1951 return;
1953 break;
1956 while (ISSPACE (*str))
1957 ++str;
1959 if (*str != '\0')
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)
1966 size = 1;
1968 if (opcode->format == FMT_S1 || opcode->format == FMT_D0)
1969 size = 2;
1971 if (opcode->format == FMT_S2 || opcode->format == FMT_D1)
1972 size = 3;
1974 if (opcode->format == FMT_D6)
1975 size = 3;
1977 if (opcode->format == FMT_D7 || opcode->format == FMT_D10)
1978 size = 4;
1980 if (opcode->format == FMT_D8)
1981 size = 6;
1983 if (opcode->format == FMT_D9)
1984 size = 7;
1986 if (opcode->format == FMT_S4)
1987 size = 5;
1989 if (opcode->format == FMT_S6 || opcode->format == FMT_D5)
1990 size = 7;
1992 if (opcode->format == FMT_D2)
1993 size = 4;
1995 if (opcode->format == FMT_D3)
1996 size = 5;
1998 if (opcode->format == FMT_D4)
1999 size = 6;
2001 if (relaxable && fc > 0)
2003 int type;
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
2008 the region. */
2009 f = frag_more (0);
2010 dwarf2_emit_insn (0);
2012 /* bCC */
2013 if (size == 2)
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)
2023 type = 10;
2024 else
2025 type = 0;
2027 /* call */
2028 else if (size == 5)
2029 type = 6;
2030 /* calls */
2031 else if (size == 4)
2032 type = 8;
2033 /* jmp */
2034 else if (size == 3 && opcode->opcode == 0xcc0000)
2035 type = 10;
2036 else if (size == 3 && (opcode->opcode & 0xfff000) == 0xf8d000)
2037 type = 13;
2038 /* bCC (uncommon cases) */
2039 else
2040 type = 3;
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
2051 care about.
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);
2062 if (size > 8)
2064 number_to_chars_bigendian (f + 4, extension, 4);
2065 number_to_chars_bigendian (f + 8, 0, size - 8);
2067 else if (size > 4)
2068 number_to_chars_bigendian (f + 4, extension, size - 4);
2070 else
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;
2195 int size;
2196 int offset;
2197 fixS *fixP;
2199 reloc_howto = bfd_reloc_type_lookup (stdoutput,
2200 fixups[i].reloc);
2202 if (!reloc_howto)
2203 abort ();
2205 size = bfd_get_reloc_size (reloc_howto);
2207 if (size < 1 || size > 4)
2208 abort ();
2210 offset = 4 - size;
2211 fixP = fix_new_exp (frag_now, f - frag_now->fr_literal + offset,
2212 size, &fixups[i].exp,
2213 reloc_howto->pc_relative,
2214 fixups[i].reloc);
2216 else
2218 int reloc, pcrel, reloc_size, offset;
2219 fixS *fixP;
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)
2227 reloc_size = 32;
2228 else if ((operand->flags & MN10300_OPERAND_24BIT) != 0)
2229 reloc_size = 24;
2230 else
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)
2243 else if (pcrel)
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;
2251 else
2252 abort ();
2254 else
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;
2262 else
2263 abort ();
2266 /* Convert the size of the reloc into what fix_new_exp wants. */
2267 reloc_size = reloc_size / 8;
2268 if (reloc_size == 8)
2269 reloc_size = 0;
2270 else if (reloc_size == 16)
2271 reloc_size = 1;
2272 else if (reloc_size == 32)
2273 reloc_size = 2;
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));
2279 if (pcrel)
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. */
2291 arelent *
2292 tc_gen_reloc (seg, fixp)
2293 asection *seg ATTRIBUTE_UNUSED;
2294 fixS *fixp;
2296 arelent *reloc;
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);
2305 return NULL;
2307 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
2309 if (fixp->fx_subsy
2310 && S_GET_SEGMENT (fixp->fx_subsy) == absolute_section)
2312 fixp->fx_offset -= S_GET_VALUE (fixp->fx_subsy);
2313 fixp->fx_subsy = 0;
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
2324 to a constant. */
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)
2330 + fixp->fx_offset);
2332 switch (fixp->fx_r_type)
2334 case BFD_RELOC_8:
2335 reloc->howto = bfd_reloc_type_lookup (stdoutput,
2336 BFD_RELOC_8_PCREL);
2337 return reloc;
2339 case BFD_RELOC_16:
2340 reloc->howto = bfd_reloc_type_lookup (stdoutput,
2341 BFD_RELOC_16_PCREL);
2342 return reloc;
2344 case BFD_RELOC_24:
2345 reloc->howto = bfd_reloc_type_lookup (stdoutput,
2346 BFD_RELOC_24_PCREL);
2347 return reloc;
2349 case BFD_RELOC_32:
2350 reloc->howto = bfd_reloc_type_lookup (stdoutput,
2351 BFD_RELOC_32_PCREL);
2352 return reloc;
2354 default:
2355 /* Try to compute the absolute value below. */
2356 break;
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");
2366 else
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)
2375 case BFD_RELOC_8:
2376 md_number_to_chars (fixpos, reloc->addend, 1);
2377 break;
2379 case BFD_RELOC_16:
2380 md_number_to_chars (fixpos, reloc->addend, 2);
2381 break;
2383 case BFD_RELOC_24:
2384 md_number_to_chars (fixpos, reloc->addend, 3);
2385 break;
2387 case BFD_RELOC_32:
2388 md_number_to_chars (fixpos, reloc->addend, 4);
2389 break;
2391 default:
2392 reloc->sym_ptr_ptr = (asymbol **) &bfd_abs_symbol;
2393 return reloc;
2397 if (reloc->sym_ptr_ptr)
2398 free (reloc->sym_ptr_ptr);
2399 free (reloc);
2400 return NULL;
2402 else
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;
2408 return reloc;
2412 md_estimate_size_before_relax (fragp, seg)
2413 fragS *fragp;
2414 asection *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)
2430 return 3;
2431 if (fragp->fr_subtype >= sizeof (md_relax_table) / sizeof (md_relax_table[0]))
2432 abort ();
2434 return md_relax_table[fragp->fr_subtype].rlx_length;
2437 long
2438 md_pcrel_from (fixp)
2439 fixS *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. */
2444 return 0;
2446 return fixp->fx_frag->fr_address + fixp->fx_where;
2449 void
2450 md_apply_fix3 (fixP, valP, seg)
2451 fixS * fixP;
2452 valueT * valP;
2453 segT seg;
2455 char * fixpos = fixP->fx_where + fixP->fx_frag->fr_literal;
2456 int size = 0;
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)
2463 abort ();
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)))
2485 fixP->fx_done = 0;
2486 return;
2489 switch (fixP->fx_r_type)
2491 case BFD_RELOC_8:
2492 case BFD_RELOC_8_PCREL:
2493 size = 1;
2494 break;
2496 case BFD_RELOC_16:
2497 case BFD_RELOC_16_PCREL:
2498 size = 2;
2499 break;
2501 case BFD_RELOC_32:
2502 case BFD_RELOC_32_PCREL:
2503 size = 4;
2504 break;
2506 case BFD_RELOC_VTABLE_INHERIT:
2507 case BFD_RELOC_VTABLE_ENTRY:
2508 fixP->fx_done = 0;
2509 return;
2511 case BFD_RELOC_NONE:
2512 default:
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)
2521 fixP->fx_done = 1;
2524 /* Return zero if the fixup in fixp should be left alone and not
2525 adjusted. */
2527 bfd_boolean
2528 mn10300_fix_adjustable (fixp)
2529 struct fix *fixp;
2531 if (! TC_RELOC_RTSYM_LOC_FIXUP (fixp))
2532 return 0;
2534 if (fixp->fx_r_type == BFD_RELOC_VTABLE_INHERIT
2535 || fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
2536 return 0;
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)
2543 return 0;
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))
2550 return 0;
2551 if (strncmp (S_GET_SEGMENT (fixp->fx_addsy)->name, ".debug", 6) == 0)
2552 return 0;
2554 return 1;
2557 /* Insert an operand value into an instruction. */
2559 static void
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;
2564 offsetT val;
2565 char *file;
2566 unsigned int line;
2567 unsigned int shift;
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)
2574 long min, max;
2575 offsetT test;
2576 int bits;
2578 bits = operand->bits;
2579 if (operand->flags & MN10300_OPERAND_24BIT)
2580 bits = 24;
2582 if ((operand->flags & MN10300_OPERAND_SIGNED) != 0)
2584 max = (1 << (bits - 1)) - 1;
2585 min = - (1 << (bits - 1));
2587 else
2589 max = (1 << bits) - 1;
2590 min = 0;
2593 test = val;
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))
2603 << operand->shift);
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))
2609 << operand->shift);
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)
2621 case 5:
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;
2629 else
2631 /* This is an `n' register. */
2632 shl_low = -operand->shift;
2633 shl_high = shl_low / 4;
2636 mask_low = 0x0f;
2637 mask_high = 0x10;
2638 shr_high = 4;
2639 break;
2641 case 3:
2642 /* Handle accumulators. */
2643 shl_low = -operand->shift;
2644 shl_high = 0;
2645 mask_low = 0x03;
2646 mask_high = 0x04;
2647 shr_high = 2;
2648 break;
2650 default:
2651 abort ();
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));
2665 else
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;
2680 offsetT val;
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)
2687 long min, max;
2688 offsetT test;
2689 int bits;
2691 bits = operand->bits;
2692 if (operand->flags & MN10300_OPERAND_24BIT)
2693 bits = 24;
2695 if ((operand->flags & MN10300_OPERAND_SIGNED) != 0)
2697 max = (1 << (bits - 1)) - 1;
2698 min = - (1 << (bits - 1));
2700 else
2702 max = (1 << bits) - 1;
2703 min = 0;
2706 test = val;
2708 if (test < (offsetT) min || test > (offsetT) max)
2709 return 0;
2710 else
2711 return 1;
2713 return 1;
2716 static void
2717 set_arch_mach (mach)
2718 int 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)
2730 char *cont, *what;
2732 int len = strlen (what);
2734 if (strncmp (cont, what, strlen (what)) == 0
2735 && ! is_part_of_name (cont[len]))
2736 return cont + len;
2738 return NULL;
2742 mn10300_parse_name (name, exprP, nextcharP)
2743 char const *name;
2744 expressionS *exprP;
2745 char *nextcharP;
2747 char *next = input_line_pointer;
2748 char *next_end;
2749 int reloc_type;
2750 segT segment;
2752 exprP->X_op_symbol = NULL;
2754 if (strcmp (name, GLOBAL_OFFSET_TABLE_NAME) == 0)
2756 if (! GOT_symbol)
2757 GOT_symbol = symbol_find_or_make (name);
2759 exprP->X_add_symbol = GOT_symbol;
2760 no_suffix:
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;
2776 else
2778 exprP->X_op = O_symbol;
2779 exprP->X_add_number = 0;
2782 return 1;
2785 exprP->X_add_symbol = symbol_find_or_make (name);
2787 if (*nextcharP != '@')
2788 goto no_suffix;
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;
2795 else
2796 goto no_suffix;
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;
2807 return 1;