projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Update all uses of md_apply_fix to use md_apply_fix3. Make it a void function.
[deliverable/binutils-gdb.git] / gas / config / tc-v850.c
1 /* tc-v850.c -- Assembler code for the NEC V850
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001
3 Free Software Foundation, Inc.
4
5 This file is part of GAS, the GNU Assembler.
6
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.
11
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.
16
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. */
21
22 #include <stdio.h>
23 #include "as.h"
24 #include "safe-ctype.h"
25 #include "subsegs.h"
26 #include "opcode/v850.h"
27 #include "dwarf2dbg.h"
28
29 #define AREA_ZDA 0
30 #define AREA_SDA 1
31 #define AREA_TDA 2
32
33 /* Sign-extend a 16-bit number. */
34 #define SEXT16(x) ((((x) & 0xffff) ^ (~0x7fff)) + 0x8000)
35
36 /* Temporarily holds the reloc in a cons expression. */
37 static bfd_reloc_code_real_type hold_cons_reloc = BFD_RELOC_UNUSED;
38
39 /* Set to TRUE if we want to be pedantic about signed overflows. */
40 static boolean warn_signed_overflows = FALSE;
41 static boolean warn_unsigned_overflows = FALSE;
42
43 /* Indicates the target BFD machine number. */
44 static int machine = -1;
45
46 /* Indicates the target processor(s) for the assemble. */
47 static int processor_mask = -1;
48 \f
49 /* Structure to hold information about predefined registers. */
50 struct reg_name {
51 const char *name;
52 int value;
53 };
54
55 /* Generic assembler global variables which must be defined by all
56 targets. */
57
58 /* Characters which always start a comment. */
59 const char comment_chars[] = "#";
60
61 /* Characters which start a comment at the beginning of a line. */
62 const char line_comment_chars[] = ";#";
63
64 /* Characters which may be used to separate multiple commands on a
65 single line. */
66 const char line_separator_chars[] = ";";
67
68 /* Characters which are used to indicate an exponent in a floating
69 point number. */
70 const char EXP_CHARS[] = "eE";
71
72 /* Characters which mean that a number is a floating point constant,
73 as in 0d1.0. */
74 const char FLT_CHARS[] = "dD";
75 \f
76 const relax_typeS md_relax_table[] = {
77 /* Conditional branches. */
78 {0xff, -0x100, 2, 1},
79 {0x1fffff, -0x200000, 6, 0},
80 /* Unconditional branches. */
81 {0xff, -0x100, 2, 3},
82 {0x1fffff, -0x200000, 4, 0},
83 };
84
85 static segT sdata_section = NULL;
86 static segT tdata_section = NULL;
87 static segT zdata_section = NULL;
88 static segT sbss_section = NULL;
89 static segT tbss_section = NULL;
90 static segT zbss_section = NULL;
91 static segT rosdata_section = NULL;
92 static segT rozdata_section = NULL;
93 static segT scommon_section = NULL;
94 static segT tcommon_section = NULL;
95 static segT zcommon_section = NULL;
96 static segT call_table_data_section = NULL;
97 static segT call_table_text_section = NULL;
98
99 /* Fixups. */
100 #define MAX_INSN_FIXUPS (5)
101 struct v850_fixup {
102 expressionS exp;
103 int opindex;
104 bfd_reloc_code_real_type reloc;
105 };
106
107 struct v850_fixup fixups[MAX_INSN_FIXUPS];
108 static int fc;
109 \f
110 void
111 v850_sdata (int ignore ATTRIBUTE_UNUSED)
112 {
113 obj_elf_section_change_hook ();
114
115 subseg_set (sdata_section, (subsegT) get_absolute_expression ());
116
117 demand_empty_rest_of_line ();
118 }
119
120 void
121 v850_tdata (int ignore ATTRIBUTE_UNUSED)
122 {
123 obj_elf_section_change_hook ();
124
125 subseg_set (tdata_section, (subsegT) get_absolute_expression ());
126
127 demand_empty_rest_of_line ();
128 }
129
130 void
131 v850_zdata (int ignore ATTRIBUTE_UNUSED)
132 {
133 obj_elf_section_change_hook ();
134
135 subseg_set (zdata_section, (subsegT) get_absolute_expression ());
136
137 demand_empty_rest_of_line ();
138 }
139
140 void
141 v850_sbss (int ignore ATTRIBUTE_UNUSED)
142 {
143 obj_elf_section_change_hook ();
144
145 subseg_set (sbss_section, (subsegT) get_absolute_expression ());
146
147 demand_empty_rest_of_line ();
148 }
149
150 void
151 v850_tbss (int ignore ATTRIBUTE_UNUSED)
152 {
153 obj_elf_section_change_hook ();
154
155 subseg_set (tbss_section, (subsegT) get_absolute_expression ());
156
157 demand_empty_rest_of_line ();
158 }
159
160 void
161 v850_zbss (int ignore ATTRIBUTE_UNUSED)
162 {
163 obj_elf_section_change_hook ();
164
165 subseg_set (zbss_section, (subsegT) get_absolute_expression ());
166
167 demand_empty_rest_of_line ();
168 }
169
170 void
171 v850_rosdata (int ignore ATTRIBUTE_UNUSED)
172 {
173 obj_elf_section_change_hook ();
174
175 subseg_set (rosdata_section, (subsegT) get_absolute_expression ());
176
177 demand_empty_rest_of_line ();
178 }
179
180 void
181 v850_rozdata (int ignore ATTRIBUTE_UNUSED)
182 {
183 obj_elf_section_change_hook ();
184
185 subseg_set (rozdata_section, (subsegT) get_absolute_expression ());
186
187 demand_empty_rest_of_line ();
188 }
189
190 void
191 v850_call_table_data (int ignore ATTRIBUTE_UNUSED)
192 {
193 obj_elf_section_change_hook ();
194
195 subseg_set (call_table_data_section, (subsegT) get_absolute_expression ());
196
197 demand_empty_rest_of_line ();
198 }
199
200 void
201 v850_call_table_text (int ignore ATTRIBUTE_UNUSED)
202 {
203 obj_elf_section_change_hook ();
204
205 subseg_set (call_table_text_section, (subsegT) get_absolute_expression ());
206
207 demand_empty_rest_of_line ();
208 }
209
210 void
211 v850_bss (int ignore ATTRIBUTE_UNUSED)
212 {
213 register int temp = get_absolute_expression ();
214
215 obj_elf_section_change_hook ();
216
217 subseg_set (bss_section, (subsegT) temp);
218
219 demand_empty_rest_of_line ();
220 }
221
222 void
223 v850_offset (int ignore ATTRIBUTE_UNUSED)
224 {
225 int temp = get_absolute_expression ();
226
227 temp -= frag_now_fix ();
228
229 if (temp > 0)
230 (void) frag_more (temp);
231
232 demand_empty_rest_of_line ();
233 }
234
235 /* Copied from obj_elf_common() in gas/config/obj-elf.c. */
236
237 static void
238 v850_comm (area)
239 int area;
240 {
241 char *name;
242 char c;
243 char *p;
244 int temp;
245 unsigned int size;
246 symbolS *symbolP;
247 int have_align;
248
249 name = input_line_pointer;
250 c = get_symbol_end ();
251
252 /* Just after name is now '\0'. */
253 p = input_line_pointer;
254 *p = c;
255
256 SKIP_WHITESPACE ();
257
258 if (*input_line_pointer != ',')
259 {
260 as_bad (_("Expected comma after symbol-name"));
261 ignore_rest_of_line ();
262 return;
263 }
264
265 /* Skip ','. */
266 input_line_pointer++;
267
268 if ((temp = get_absolute_expression ()) < 0)
269 {
270 /* xgettext:c-format */
271 as_bad (_(".COMMon length (%d.) < 0! Ignored."), temp);
272 ignore_rest_of_line ();
273 return;
274 }
275
276 size = temp;
277 *p = 0;
278 symbolP = symbol_find_or_make (name);
279 *p = c;
280
281 if (S_IS_DEFINED (symbolP) && ! S_IS_COMMON (symbolP))
282 {
283 as_bad (_("Ignoring attempt to re-define symbol"));
284 ignore_rest_of_line ();
285 return;
286 }
287
288 if (S_GET_VALUE (symbolP) != 0)
289 {
290 if (S_GET_VALUE (symbolP) != size)
291 {
292 /* xgettext:c-format */
293 as_warn (_("Length of .comm \"%s\" is already %ld. Not changed to %d."),
294 S_GET_NAME (symbolP), (long) S_GET_VALUE (symbolP), size);
295 }
296 }
297
298 know (symbol_get_frag (symbolP) == &zero_address_frag);
299
300 if (*input_line_pointer != ',')
301 have_align = 0;
302 else
303 {
304 have_align = 1;
305 input_line_pointer++;
306 SKIP_WHITESPACE ();
307 }
308
309 if (! have_align || *input_line_pointer != '"')
310 {
311 if (! have_align)
312 temp = 0;
313 else
314 {
315 temp = get_absolute_expression ();
316
317 if (temp < 0)
318 {
319 temp = 0;
320 as_warn (_("Common alignment negative; 0 assumed"));
321 }
322 }
323
324 if (symbol_get_obj (symbolP)->local)
325 {
326 segT old_sec;
327 int old_subsec;
328 char *pfrag;
329 int align;
330 flagword applicable;
331
332 old_sec = now_seg;
333 old_subsec = now_subseg;
334
335 applicable = bfd_applicable_section_flags (stdoutput);
336
337 applicable &= SEC_ALLOC;
338
339 switch (area)
340 {
341 case AREA_SDA:
342 if (sbss_section == NULL)
343 {
344 sbss_section = subseg_new (".sbss", 0);
345
346 bfd_set_section_flags (stdoutput, sbss_section, applicable);
347
348 seg_info (sbss_section)->bss = 1;
349 }
350 break;
351
352 case AREA_ZDA:
353 if (zbss_section == NULL)
354 {
355 zbss_section = subseg_new (".zbss", 0);
356
357 bfd_set_section_flags (stdoutput, sbss_section, applicable);
358
359 seg_info (zbss_section)->bss = 1;
360 }
361 break;
362
363 case AREA_TDA:
364 if (tbss_section == NULL)
365 {
366 tbss_section = subseg_new (".tbss", 0);
367
368 bfd_set_section_flags (stdoutput, tbss_section, applicable);
369
370 seg_info (tbss_section)->bss = 1;
371 }
372 break;
373 }
374
375 if (temp)
376 {
377 /* Convert to a power of 2 alignment. */
378 for (align = 0; (temp & 1) == 0; temp >>= 1, ++align)
379 ;
380
381 if (temp != 1)
382 {
383 as_bad (_("Common alignment not a power of 2"));
384 ignore_rest_of_line ();
385 return;
386 }
387 }
388 else
389 align = 0;
390
391 switch (area)
392 {
393 case AREA_SDA:
394 record_alignment (sbss_section, align);
395 obj_elf_section_change_hook ();
396 subseg_set (sbss_section, 0);
397 break;
398
399 case AREA_ZDA:
400 record_alignment (zbss_section, align);
401 obj_elf_section_change_hook ();
402 subseg_set (zbss_section, 0);
403 break;
404
405 case AREA_TDA:
406 record_alignment (tbss_section, align);
407 obj_elf_section_change_hook ();
408 subseg_set (tbss_section, 0);
409 break;
410
411 default:
412 abort ();
413 }
414
415 if (align)
416 frag_align (align, 0, 0);
417
418 switch (area)
419 {
420 case AREA_SDA:
421 if (S_GET_SEGMENT (symbolP) == sbss_section)
422 symbol_get_frag (symbolP)->fr_symbol = 0;
423 break;
424
425 case AREA_ZDA:
426 if (S_GET_SEGMENT (symbolP) == zbss_section)
427 symbol_get_frag (symbolP)->fr_symbol = 0;
428 break;
429
430 case AREA_TDA:
431 if (S_GET_SEGMENT (symbolP) == tbss_section)
432 symbol_get_frag (symbolP)->fr_symbol = 0;
433 break;
434
435 default:
436 abort ();
437 }
438
439 symbol_set_frag (symbolP, frag_now);
440 pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP,
441 (offsetT) size, (char *) 0);
442 *pfrag = 0;
443 S_SET_SIZE (symbolP, size);
444
445 switch (area)
446 {
447 case AREA_SDA:
448 S_SET_SEGMENT (symbolP, sbss_section);
449 break;
450
451 case AREA_ZDA:
452 S_SET_SEGMENT (symbolP, zbss_section);
453 break;
454
455 case AREA_TDA:
456 S_SET_SEGMENT (symbolP, tbss_section);
457 break;
458
459 default:
460 abort ();
461 }
462
463 S_CLEAR_EXTERNAL (symbolP);
464 obj_elf_section_change_hook ();
465 subseg_set (old_sec, old_subsec);
466 }
467 else
468 {
469 allocate_common:
470 S_SET_VALUE (symbolP, (valueT) size);
471 S_SET_ALIGN (symbolP, temp);
472 S_SET_EXTERNAL (symbolP);
473
474 switch (area)
475 {
476 case AREA_SDA:
477 if (scommon_section == NULL)
478 {
479 flagword applicable =
480 bfd_applicable_section_flags (stdoutput);
481
482 scommon_section = subseg_new (".scommon", 0);
483
484 bfd_set_section_flags (stdoutput, scommon_section,
485 (applicable
486 & (SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_DATA
487 | SEC_HAS_CONTENTS)) | SEC_IS_COMMON);
488 }
489 S_SET_SEGMENT (symbolP, scommon_section);
490 break;
491
492 case AREA_ZDA:
493 if (zcommon_section == NULL)
494 {
495 flagword applicable =
496 bfd_applicable_section_flags (stdoutput);
497
498 zcommon_section = subseg_new (".zcommon", 0);
499
500 bfd_set_section_flags (stdoutput, zcommon_section,
501 (applicable
502 & (SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_DATA
503 | SEC_HAS_CONTENTS)) | SEC_IS_COMMON);
504 }
505 S_SET_SEGMENT (symbolP, zcommon_section);
506 break;
507
508 case AREA_TDA:
509 if (tcommon_section == NULL)
510 {
511 flagword applicable =
512 bfd_applicable_section_flags (stdoutput);
513
514 tcommon_section = subseg_new (".tcommon", 0);
515
516 bfd_set_section_flags (stdoutput, tcommon_section,
517 ((applicable
518 & (SEC_ALLOC | SEC_LOAD
519 | SEC_RELOC | SEC_DATA
520 | SEC_HAS_CONTENTS))
521 | SEC_IS_COMMON));
522 }
523 S_SET_SEGMENT (symbolP, tcommon_section);
524 break;
525
526 default:
527 abort ();
528 }
529 }
530 }
531 else
532 {
533 input_line_pointer++;
534
535 /* @@ Some use the dot, some don't. Can we get some consistency?? */
536 if (*input_line_pointer == '.')
537 input_line_pointer++;
538
539 /* @@ Some say data, some say bss. */
540 if (strncmp (input_line_pointer, "bss\"", 4)
541 && strncmp (input_line_pointer, "data\"", 5))
542 {
543 while (*--input_line_pointer != '"')
544 ;
545 input_line_pointer--;
546 goto bad_common_segment;
547 }
548 while (*input_line_pointer++ != '"')
549 ;
550 goto allocate_common;
551 }
552
553 symbol_get_bfdsym (symbolP)->flags |= BSF_OBJECT;
554
555 demand_empty_rest_of_line ();
556 return;
557
558 {
559 bad_common_segment:
560 p = input_line_pointer;
561 while (*p && *p != '\n')
562 p++;
563 c = *p;
564 *p = '\0';
565 as_bad (_("bad .common segment %s"), input_line_pointer + 1);
566 *p = c;
567 input_line_pointer = p;
568 ignore_rest_of_line ();
569 return;
570 }
571 }
572
573 void
574 set_machine (int number)
575 {
576 machine = number;
577 bfd_set_arch_mach (stdoutput, TARGET_ARCH, machine);
578
579 switch (machine)
580 {
581 case 0: processor_mask = PROCESSOR_V850; break;
582 case bfd_mach_v850e: processor_mask = PROCESSOR_V850E; break;
583 case bfd_mach_v850ea: processor_mask = PROCESSOR_V850EA; break;
584 }
585 }
586
587 /* The target specific pseudo-ops which we support. */
588 const pseudo_typeS md_pseudo_table[] = {
589 {"sdata", v850_sdata, 0},
590 {"tdata", v850_tdata, 0},
591 {"zdata", v850_zdata, 0},
592 {"sbss", v850_sbss, 0},
593 {"tbss", v850_tbss, 0},
594 {"zbss", v850_zbss, 0},
595 {"rosdata", v850_rosdata, 0},
596 {"rozdata", v850_rozdata, 0},
597 {"bss", v850_bss, 0},
598 {"offset", v850_offset, 0},
599 {"word", cons, 4},
600 {"zcomm", v850_comm, AREA_ZDA},
601 {"scomm", v850_comm, AREA_SDA},
602 {"tcomm", v850_comm, AREA_TDA},
603 {"v850", set_machine, 0},
604 {"call_table_data", v850_call_table_data, 0},
605 {"call_table_text", v850_call_table_text, 0},
606 {"v850e", set_machine, bfd_mach_v850e},
607 {"v850ea", set_machine, bfd_mach_v850ea},
608 {"file", dwarf2_directive_file, 0},
609 {"loc", dwarf2_directive_loc, 0},
610 { NULL, NULL, 0}
611 };
612
613 /* Opcode hash table. */
614 static struct hash_control *v850_hash;
615
616 /* This table is sorted. Suitable for searching by a binary search. */
617 static const struct reg_name pre_defined_registers[] = {
618 { "ep", 30 }, /* ep - element ptr */
619 { "gp", 4 }, /* gp - global ptr */
620 { "hp", 2 }, /* hp - handler stack ptr */
621 { "lp", 31 }, /* lp - link ptr */
622 { "r0", 0 },
623 { "r1", 1 },
624 { "r10", 10 },
625 { "r11", 11 },
626 { "r12", 12 },
627 { "r13", 13 },
628 { "r14", 14 },
629 { "r15", 15 },
630 { "r16", 16 },
631 { "r17", 17 },
632 { "r18", 18 },
633 { "r19", 19 },
634 { "r2", 2 },
635 { "r20", 20 },
636 { "r21", 21 },
637 { "r22", 22 },
638 { "r23", 23 },
639 { "r24", 24 },
640 { "r25", 25 },
641 { "r26", 26 },
642 { "r27", 27 },
643 { "r28", 28 },
644 { "r29", 29 },
645 { "r3", 3 },
646 { "r30", 30 },
647 { "r31", 31 },
648 { "r4", 4 },
649 { "r5", 5 },
650 { "r6", 6 },
651 { "r7", 7 },
652 { "r8", 8 },
653 { "r9", 9 },
654 { "sp", 3 }, /* sp - stack ptr */
655 { "tp", 5 }, /* tp - text ptr */
656 { "zero", 0 },
657 };
658
659 #define REG_NAME_CNT \
660 (sizeof (pre_defined_registers) / sizeof (struct reg_name))
661
662 static const struct reg_name system_registers[] = {
663 { "ctbp", 20 },
664 { "ctpc", 16 },
665 { "ctpsw", 17 },
666 { "dbpc", 18 },
667 { "dbpsw", 19 },
668 { "ecr", 4 },
669 { "eipc", 0 },
670 { "eipsw", 1 },
671 { "fepc", 2 },
672 { "fepsw", 3 },
673 { "psw", 5 },
674 };
675
676 #define SYSREG_NAME_CNT \
677 (sizeof (system_registers) / sizeof (struct reg_name))
678
679 static const struct reg_name system_list_registers[] = {
680 {"PS", 5 },
681 {"SR", 0 + 1}
682 };
683
684 #define SYSREGLIST_NAME_CNT \
685 (sizeof (system_list_registers) / sizeof (struct reg_name))
686
687 static const struct reg_name cc_names[] = {
688 { "c", 0x1 },
689 { "e", 0x2 },
690 { "ge", 0xe },
691 { "gt", 0xf },
692 { "h", 0xb },
693 { "l", 0x1 },
694 { "le", 0x7 },
695 { "lt", 0x6 },
696 { "n", 0x4 },
697 { "nc", 0x9 },
698 { "ne", 0xa },
699 { "nh", 0x3 },
700 { "nl", 0x9 },
701 { "ns", 0xc },
702 { "nv", 0x8 },
703 { "nz", 0xa },
704 { "p", 0xc },
705 { "s", 0x4 },
706 { "sa", 0xd },
707 { "t", 0x5 },
708 { "v", 0x0 },
709 { "z", 0x2 },
710 };
711
712 #define CC_NAME_CNT \
713 (sizeof (cc_names) / sizeof (struct reg_name))
714
715 /* Do a binary search of the given register table to see if NAME is a
716 valid regiter name. Return the register number from the array on
717 success, or -1 on failure. */
718
719 static int
720 reg_name_search (regs, regcount, name, accept_numbers)
721 const struct reg_name *regs;
722 int regcount;
723 const char *name;
724 boolean accept_numbers;
725 {
726 int middle, low, high;
727 int cmp;
728 symbolS *symbolP;
729
730 /* If the register name is a symbol, then evaluate it. */
731 if ((symbolP = symbol_find (name)) != NULL)
732 {
733 /* If the symbol is an alias for another name then use that.
734 If the symbol is an alias for a number, then return the number. */
735 if (symbol_equated_p (symbolP))
736 {
737 name
738 = S_GET_NAME (symbol_get_value_expression (symbolP)->X_add_symbol);
739 }
740 else if (accept_numbers)
741 {
742 int reg = S_GET_VALUE (symbolP);
743
744 if (reg >= 0 && reg <= 31)
745 return reg;
746 }
747
748 /* Otherwise drop through and try parsing name normally. */
749 }
750
751 low = 0;
752 high = regcount - 1;
753
754 do
755 {
756 middle = (low + high) / 2;
757 cmp = strcasecmp (name, regs[middle].name);
758 if (cmp < 0)
759 high = middle - 1;
760 else if (cmp > 0)
761 low = middle + 1;
762 else
763 return regs[middle].value;
764 }
765 while (low <= high);
766 return -1;
767 }
768
769 /* Summary of register_name().
770 *
771 * in: Input_line_pointer points to 1st char of operand.
772 *
773 * out: An expressionS.
774 * The operand may have been a register: in this case, X_op == O_register,
775 * X_add_number is set to the register number, and truth is returned.
776 * Input_line_pointer->(next non-blank) char after operand, or is in
777 * its original state. */
778
779 static boolean
780 register_name (expressionP)
781 expressionS *expressionP;
782 {
783 int reg_number;
784 char *name;
785 char *start;
786 char c;
787
788 /* Find the spelling of the operand. */
789 start = name = input_line_pointer;
790
791 c = get_symbol_end ();
792
793 reg_number = reg_name_search (pre_defined_registers, REG_NAME_CNT,
794 name, FALSE);
795
796 /* Put back the delimiting char. */
797 *input_line_pointer = c;
798
799 /* Look to see if it's in the register table. */
800 if (reg_number >= 0)
801 {
802 expressionP->X_op = O_register;
803 expressionP->X_add_number = reg_number;
804
805 /* Make the rest nice. */
806 expressionP->X_add_symbol = NULL;
807 expressionP->X_op_symbol = NULL;
808
809 return true;
810 }
811 else
812 {
813 /* Reset the line as if we had not done anything. */
814 input_line_pointer = start;
815
816 return false;
817 }
818 }
819
820 /* Summary of system_register_name().
821 *
822 * in: INPUT_LINE_POINTER points to 1st char of operand.
823 * EXPRESSIONP points to an expression structure to be filled in.
824 * ACCEPT_NUMBERS is true iff numerical register names may be used.
825 * ACCEPT_LIST_NAMES is true iff the special names PS and SR may be
826 * accepted.
827 *
828 * out: An expressionS structure in expressionP.
829 * The operand may have been a register: in this case, X_op == O_register,
830 * X_add_number is set to the register number, and truth is returned.
831 * Input_line_pointer->(next non-blank) char after operand, or is in
832 * its original state. */
833
834 static boolean
835 system_register_name (expressionP, accept_numbers, accept_list_names)
836 expressionS *expressionP;
837 boolean accept_numbers;
838 boolean accept_list_names;
839 {
840 int reg_number;
841 char *name;
842 char *start;
843 char c;
844
845 /* Find the spelling of the operand. */
846 start = name = input_line_pointer;
847
848 c = get_symbol_end ();
849 reg_number = reg_name_search (system_registers, SYSREG_NAME_CNT, name,
850 accept_numbers);
851
852 /* Put back the delimiting char. */
853 *input_line_pointer = c;
854
855 if (reg_number < 0
856 && accept_numbers)
857 {
858 /* Reset input_line pointer. */
859 input_line_pointer = start;
860
861 if (ISDIGIT (*input_line_pointer))
862 {
863 reg_number = strtol (input_line_pointer, &input_line_pointer, 10);
864
865 /* Make sure that the register number is allowable. */
866 if (reg_number < 0
867 || (reg_number > 5 && reg_number < 16)
868 || reg_number > 20)
869 {
870 reg_number = -1;
871 }
872 }
873 else if (accept_list_names)
874 {
875 c = get_symbol_end ();
876 reg_number = reg_name_search (system_list_registers,
877 SYSREGLIST_NAME_CNT, name, FALSE);
878
879 /* Put back the delimiting char. */
880 *input_line_pointer = c;
881 }
882 }
883
884 /* Look to see if it's in the register table. */
885 if (reg_number >= 0)
886 {
887 expressionP->X_op = O_register;
888 expressionP->X_add_number = reg_number;
889
890 /* Make the rest nice. */
891 expressionP->X_add_symbol = NULL;
892 expressionP->X_op_symbol = NULL;
893
894 return true;
895 }
896 else
897 {
898 /* Reset the line as if we had not done anything. */
899 input_line_pointer = start;
900
901 return false;
902 }
903 }
904
905 /* Summary of cc_name().
906 *
907 * in: INPUT_LINE_POINTER points to 1st char of operand.
908 *
909 * out: An expressionS.
910 * The operand may have been a register: in this case, X_op == O_register,
911 * X_add_number is set to the register number, and truth is returned.
912 * Input_line_pointer->(next non-blank) char after operand, or is in
913 * its original state. */
914
915 static boolean
916 cc_name (expressionP)
917 expressionS *expressionP;
918 {
919 int reg_number;
920 char *name;
921 char *start;
922 char c;
923
924 /* Find the spelling of the operand. */
925 start = name = input_line_pointer;
926
927 c = get_symbol_end ();
928 reg_number = reg_name_search (cc_names, CC_NAME_CNT, name, FALSE);
929
930 /* Put back the delimiting char. */
931 *input_line_pointer = c;
932
933 /* Look to see if it's in the register table. */
934 if (reg_number >= 0)
935 {
936 expressionP->X_op = O_constant;
937 expressionP->X_add_number = reg_number;
938
939 /* Make the rest nice. */
940 expressionP->X_add_symbol = NULL;
941 expressionP->X_op_symbol = NULL;
942
943 return true;
944 }
945 else
946 {
947 /* Reset the line as if we had not done anything. */
948 input_line_pointer = start;
949
950 return false;
951 }
952 }
953
954 static void
955 skip_white_space (void)
956 {
957 while (*input_line_pointer == ' '
958 || *input_line_pointer == '\t')
959 ++input_line_pointer;
960 }
961
962 /* Summary of parse_register_list ().
963 *
964 * in: INPUT_LINE_POINTER points to 1st char of a list of registers.
965 * INSN is the partially constructed instruction.
966 * OPERAND is the operand being inserted.
967 *
968 * out: NULL if the parse completed successfully, otherwise a
969 * pointer to an error message is returned. If the parse
970 * completes the correct bit fields in the instruction
971 * will be filled in.
972 *
973 * Parses register lists with the syntax:
974 *
975 * { rX }
976 * { rX, rY }
977 * { rX - rY }
978 * { rX - rY, rZ }
979 * etc
980 *
981 * and also parses constant epxressions whoes bits indicate the
982 * registers in the lists. The LSB in the expression refers to
983 * the lowest numbered permissable register in the register list,
984 * and so on upwards. System registers are considered to be very
985 * high numbers. */
986
987 static char *
988 parse_register_list (insn, operand)
989 unsigned long *insn;
990 const struct v850_operand *operand;
991 {
992 static int type1_regs[32] = {
993 30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
994 0, 0, 0, 0, 0, 31, 29, 28, 23, 22, 21, 20, 27, 26, 25, 24
995 };
996 static int type2_regs[32] = {
997 19, 18, 17, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
998 0, 0, 0, 0, 30, 31, 29, 28, 23, 22, 21, 20, 27, 26, 25, 24
999 };
1000 static int type3_regs[32] = {
1001 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1002 0, 0, 0, 0, 14, 15, 13, 12, 7, 6, 5, 4, 11, 10, 9, 8
1003 };
1004 int *regs;
1005 expressionS exp;
1006
1007 /* Select a register array to parse. */
1008 switch (operand->shift)
1009 {
1010 case 0xffe00001: regs = type1_regs; break;
1011 case 0xfff8000f: regs = type2_regs; break;
1012 case 0xfff8001f: regs = type3_regs; break;
1013 default:
1014 as_bad (_("unknown operand shift: %x\n"), operand->shift);
1015 return _("internal failure in parse_register_list");
1016 }
1017
1018 skip_white_space ();
1019
1020 /* If the expression starts with a curly brace it is a register list.
1021 Otherwise it is a constant expression, whoes bits indicate which
1022 registers are to be included in the list. */
1023
1024 if (*input_line_pointer != '{')
1025 {
1026 int reg;
1027 int i;
1028
1029 expression (&exp);
1030
1031 if (exp.X_op != O_constant)
1032 return _("constant expression or register list expected");
1033
1034 if (regs == type1_regs)
1035 {
1036 if (exp.X_add_number & 0xFFFFF000)
1037 return _("high bits set in register list expression");
1038
1039 for (reg = 20; reg < 32; reg++)
1040 if (exp.X_add_number & (1 << (reg - 20)))
1041 {
1042 for (i = 0; i < 32; i++)
1043 if (regs[i] == reg)
1044 *insn |= (1 << i);
1045 }
1046 }
1047 else if (regs == type2_regs)
1048 {
1049 if (exp.X_add_number & 0xFFFE0000)
1050 return _("high bits set in register list expression");
1051
1052 for (reg = 1; reg < 16; reg++)
1053 if (exp.X_add_number & (1 << (reg - 1)))
1054 {
1055 for (i = 0; i < 32; i++)
1056 if (regs[i] == reg)
1057 *insn |= (1 << i);
1058 }
1059
1060 if (exp.X_add_number & (1 << 15))
1061 *insn |= (1 << 3);
1062
1063 if (exp.X_add_number & (1 << 16))
1064 *insn |= (1 << 19);
1065 }
1066 else /* regs == type3_regs */
1067 {
1068 if (exp.X_add_number & 0xFFFE0000)
1069 return _("high bits set in register list expression");
1070
1071 for (reg = 16; reg < 32; reg++)
1072 if (exp.X_add_number & (1 << (reg - 16)))
1073 {
1074 for (i = 0; i < 32; i++)
1075 if (regs[i] == reg)
1076 *insn |= (1 << i);
1077 }
1078
1079 if (exp.X_add_number & (1 << 16))
1080 *insn |= (1 << 19);
1081 }
1082
1083 return NULL;
1084 }
1085
1086 input_line_pointer++;
1087
1088 /* Parse the register list until a terminator (closing curly brace or
1089 new-line) is found. */
1090 for (;;)
1091 {
1092 if (register_name (&exp))
1093 {
1094 int i;
1095
1096 /* Locate the given register in the list, and if it is there,
1097 insert the corresponding bit into the instruction. */
1098 for (i = 0; i < 32; i++)
1099 {
1100 if (regs[i] == exp.X_add_number)
1101 {
1102 *insn |= (1 << i);
1103 break;
1104 }
1105 }
1106
1107 if (i == 32)
1108 {
1109 return _("illegal register included in list");
1110 }
1111 }
1112 else if (system_register_name (&exp, true, true))
1113 {
1114 if (regs == type1_regs)
1115 {
1116 return _("system registers cannot be included in list");
1117 }
1118 else if (exp.X_add_number == 5)
1119 {
1120 if (regs == type2_regs)
1121 return _("PSW cannot be included in list");
1122 else
1123 *insn |= 0x8;
1124 }
1125 else if (exp.X_add_number < 4)
1126 *insn |= 0x80000;
1127 else
1128 return _("High value system registers cannot be included in list");
1129 }
1130 else if (*input_line_pointer == '}')
1131 {
1132 input_line_pointer++;
1133 break;
1134 }
1135 else if (*input_line_pointer == ',')
1136 {
1137 input_line_pointer++;
1138 continue;
1139 }
1140 else if (*input_line_pointer == '-')
1141 {
1142 /* We have encountered a range of registers: rX - rY. */
1143 int j;
1144 expressionS exp2;
1145
1146 /* Skip the dash. */
1147 ++input_line_pointer;
1148
1149 /* Get the second register in the range. */
1150 if (! register_name (&exp2))
1151 {
1152 return _("second register should follow dash in register list");
1153 exp2.X_add_number = exp.X_add_number;
1154 }
1155
1156 /* Add the rest of the registers in the range. */
1157 for (j = exp.X_add_number + 1; j <= exp2.X_add_number; j++)
1158 {
1159 int i;
1160
1161 /* Locate the given register in the list, and if it is there,
1162 insert the corresponding bit into the instruction. */
1163 for (i = 0; i < 32; i++)
1164 {
1165 if (regs[i] == j)
1166 {
1167 *insn |= (1 << i);
1168 break;
1169 }
1170 }
1171
1172 if (i == 32)
1173 return _("illegal register included in list");
1174 }
1175 }
1176 else
1177 {
1178 break;
1179 }
1180
1181 skip_white_space ();
1182 }
1183
1184 return NULL;
1185 }
1186
1187 CONST char *md_shortopts = "m:";
1188
1189 struct option md_longopts[] = {
1190 {NULL, no_argument, NULL, 0}
1191 };
1192
1193 size_t md_longopts_size = sizeof (md_longopts);
1194
1195 void
1196 md_show_usage (stream)
1197 FILE *stream;
1198 {
1199 fprintf (stream, _(" V850 options:\n"));
1200 fprintf (stream, _(" -mwarn-signed-overflow Warn if signed immediate values overflow\n"));
1201 fprintf (stream, _(" -mwarn-unsigned-overflow Warn if unsigned immediate values overflow\n"));
1202 fprintf (stream, _(" -mv850 The code is targeted at the v850\n"));
1203 fprintf (stream, _(" -mv850e The code is targeted at the v850e\n"));
1204 fprintf (stream, _(" -mv850ea The code is targeted at the v850ea\n"));
1205 fprintf (stream, _(" -mv850any The code is generic, despite any processor specific instructions\n"));
1206 }
1207
1208 int
1209 md_parse_option (c, arg)
1210 int c;
1211 char *arg;
1212 {
1213 if (c != 'm')
1214 {
1215 if (c != 'a')
1216 /* xgettext:c-format */
1217 fprintf (stderr, _("unknown command line option: -%c%s\n"), c, arg);
1218 return 0;
1219 }
1220
1221 if (strcmp (arg, "warn-signed-overflow") == 0)
1222 {
1223 warn_signed_overflows = TRUE;
1224 }
1225 else if (strcmp (arg, "warn-unsigned-overflow") == 0)
1226 {
1227 warn_unsigned_overflows = TRUE;
1228 }
1229 else if (strcmp (arg, "v850") == 0)
1230 {
1231 machine = 0;
1232 processor_mask = PROCESSOR_V850;
1233 }
1234 else if (strcmp (arg, "v850e") == 0)
1235 {
1236 machine = bfd_mach_v850e;
1237 processor_mask = PROCESSOR_V850E;
1238 }
1239 else if (strcmp (arg, "v850ea") == 0)
1240 {
1241 machine = bfd_mach_v850ea;
1242 processor_mask = PROCESSOR_V850EA;
1243 }
1244 else if (strcmp (arg, "v850any") == 0)
1245 {
1246 /* Tell the world that this is for any v850 chip. */
1247 machine = 0;
1248
1249 /* But support instructions for the extended versions. */
1250 processor_mask = PROCESSOR_V850EA;
1251 }
1252 else
1253 {
1254 /* xgettext:c-format */
1255 fprintf (stderr, _("unknown command line option: -%c%s\n"), c, arg);
1256 return 0;
1257 }
1258
1259 return 1;
1260 }
1261
1262 symbolS *
1263 md_undefined_symbol (name)
1264 char *name ATTRIBUTE_UNUSED;
1265 {
1266 return 0;
1267 }
1268
1269 char *
1270 md_atof (type, litp, sizep)
1271 int type;
1272 char *litp;
1273 int *sizep;
1274 {
1275 int prec;
1276 LITTLENUM_TYPE words[4];
1277 char *t;
1278 int i;
1279
1280 switch (type)
1281 {
1282 case 'f':
1283 prec = 2;
1284 break;
1285
1286 case 'd':
1287 prec = 4;
1288 break;
1289
1290 default:
1291 *sizep = 0;
1292 return _("bad call to md_atof");
1293 }
1294
1295 t = atof_ieee (input_line_pointer, type, words);
1296 if (t)
1297 input_line_pointer = t;
1298
1299 *sizep = prec * 2;
1300
1301 for (i = prec - 1; i >= 0; i--)
1302 {
1303 md_number_to_chars (litp, (valueT) words[i], 2);
1304 litp += 2;
1305 }
1306
1307 return NULL;
1308 }
1309
1310 /* Very gross. */
1311
1312 void
1313 md_convert_frag (abfd, sec, fragP)
1314 bfd *abfd ATTRIBUTE_UNUSED;
1315 asection *sec;
1316 fragS *fragP;
1317 {
1318 subseg_change (sec, 0);
1319
1320 /* In range conditional or unconditional branch. */
1321 if (fragP->fr_subtype == 0 || fragP->fr_subtype == 2)
1322 {
1323 fix_new (fragP, fragP->fr_fix, 2, fragP->fr_symbol,
1324 fragP->fr_offset, 1, BFD_RELOC_UNUSED + (int)fragP->fr_opcode);
1325 fragP->fr_fix += 2;
1326 }
1327 /* Out of range conditional branch. Emit a branch around a jump. */
1328 else if (fragP->fr_subtype == 1)
1329 {
1330 unsigned char *buffer =
1331 (unsigned char *) (fragP->fr_fix + fragP->fr_literal);
1332
1333 /* Reverse the condition of the first branch. */
1334 buffer[0] ^= 0x08;
1335 /* Mask off all the displacement bits. */
1336 buffer[0] &= 0x8f;
1337 buffer[1] &= 0x07;
1338 /* Now set the displacement bits so that we branch
1339 around the unconditional branch. */
1340 buffer[0] |= 0x30;
1341
1342 /* Now create the unconditional branch + fixup to the final
1343 target. */
1344 md_number_to_chars (buffer + 2, 0x00000780, 4);
1345 fix_new (fragP, fragP->fr_fix + 2, 4, fragP->fr_symbol,
1346 fragP->fr_offset, 1, BFD_RELOC_UNUSED +
1347 (int) fragP->fr_opcode + 1);
1348 fragP->fr_fix += 6;
1349 }
1350 /* Out of range unconditional branch. Emit a jump. */
1351 else if (fragP->fr_subtype == 3)
1352 {
1353 md_number_to_chars (fragP->fr_fix + fragP->fr_literal, 0x00000780, 4);
1354 fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol,
1355 fragP->fr_offset, 1, BFD_RELOC_UNUSED +
1356 (int) fragP->fr_opcode + 1);
1357 fragP->fr_fix += 4;
1358 }
1359 else
1360 abort ();
1361 }
1362
1363 valueT
1364 md_section_align (seg, addr)
1365 asection *seg;
1366 valueT addr;
1367 {
1368 int align = bfd_get_section_alignment (stdoutput, seg);
1369 return ((addr + (1 << align) - 1) & (-1 << align));
1370 }
1371
1372 void
1373 md_begin ()
1374 {
1375 char *prev_name = "";
1376 register const struct v850_opcode *op;
1377 flagword applicable;
1378
1379 if (strncmp (TARGET_CPU, "v850ea", 6) == 0)
1380 {
1381 if (machine == -1)
1382 machine = bfd_mach_v850ea;
1383
1384 if (processor_mask == -1)
1385 processor_mask = PROCESSOR_V850EA;
1386 }
1387 else if (strncmp (TARGET_CPU, "v850e", 5) == 0)
1388 {
1389 if (machine == -1)
1390 machine = bfd_mach_v850e;
1391
1392 if (processor_mask == -1)
1393 processor_mask = PROCESSOR_V850E;
1394 }
1395 else if (strncmp (TARGET_CPU, "v850", 4) == 0)
1396 {
1397 if (machine == -1)
1398 machine = 0;
1399
1400 if (processor_mask == -1)
1401 processor_mask = PROCESSOR_V850;
1402 }
1403 else
1404 /* xgettext:c-format */
1405 as_bad (_("Unable to determine default target processor from string: %s"),
1406 TARGET_CPU);
1407
1408 v850_hash = hash_new ();
1409
1410 /* Insert unique names into hash table. The V850 instruction set
1411 has many identical opcode names that have different opcodes based
1412 on the operands. This hash table then provides a quick index to
1413 the first opcode with a particular name in the opcode table. */
1414
1415 op = v850_opcodes;
1416 while (op->name)
1417 {
1418 if (strcmp (prev_name, op->name))
1419 {
1420 prev_name = (char *) op->name;
1421 hash_insert (v850_hash, op->name, (char *) op);
1422 }
1423 op++;
1424 }
1425
1426 bfd_set_arch_mach (stdoutput, TARGET_ARCH, machine);
1427
1428 applicable = bfd_applicable_section_flags (stdoutput);
1429
1430 call_table_data_section = subseg_new (".call_table_data", 0);
1431 bfd_set_section_flags (stdoutput, call_table_data_section,
1432 applicable & (SEC_ALLOC | SEC_LOAD | SEC_RELOC
1433 | SEC_DATA | SEC_HAS_CONTENTS));
1434
1435 call_table_text_section = subseg_new (".call_table_text", 0);
1436 bfd_set_section_flags (stdoutput, call_table_text_section,
1437 applicable & (SEC_ALLOC | SEC_LOAD | SEC_READONLY
1438 | SEC_CODE));
1439
1440 /* Restore text section as the current default. */
1441 subseg_set (text_section, 0);
1442 }
1443
1444 static bfd_reloc_code_real_type
1445 handle_ctoff (const struct v850_operand *operand)
1446 {
1447 if (operand == NULL)
1448 return BFD_RELOC_V850_CALLT_16_16_OFFSET;
1449
1450 if (operand->bits != 6
1451 || operand->shift != 0)
1452 {
1453 as_bad (_("ctoff() relocation used on an instruction which does not support it"));
1454 return BFD_RELOC_64; /* Used to indicate an error condition. */
1455 }
1456
1457 return BFD_RELOC_V850_CALLT_6_7_OFFSET;
1458 }
1459
1460 static bfd_reloc_code_real_type
1461 handle_sdaoff (const struct v850_operand *operand)
1462 {
1463 if (operand == NULL)
1464 return BFD_RELOC_V850_SDA_16_16_OFFSET;
1465
1466 if (operand->bits == 15 && operand->shift == 17)
1467 return BFD_RELOC_V850_SDA_15_16_OFFSET;
1468
1469 if (operand->bits == -1)
1470 return BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET;
1471
1472 if (operand->bits != 16
1473 || operand->shift != 16)
1474 {
1475 as_bad (_("sdaoff() relocation used on an instruction which does not support it"));
1476 return BFD_RELOC_64; /* Used to indicate an error condition. */
1477 }
1478
1479 return BFD_RELOC_V850_SDA_16_16_OFFSET;
1480 }
1481
1482 static bfd_reloc_code_real_type
1483 handle_zdaoff (const struct v850_operand *operand)
1484 {
1485 if (operand == NULL)
1486 return BFD_RELOC_V850_ZDA_16_16_OFFSET;
1487
1488 if (operand->bits == 15 && operand->shift == 17)
1489 return BFD_RELOC_V850_ZDA_15_16_OFFSET;
1490
1491 if (operand->bits == -1)
1492 return BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET;
1493
1494 if (operand->bits != 16
1495 || operand->shift != 16)
1496 {
1497 as_bad (_("zdaoff() relocation used on an instruction which does not support it"));
1498 /* Used to indicate an error condition. */
1499 return BFD_RELOC_64;
1500 }
1501
1502 return BFD_RELOC_V850_ZDA_16_16_OFFSET;
1503 }
1504
1505 static bfd_reloc_code_real_type
1506 handle_tdaoff (const struct v850_operand *operand)
1507 {
1508 if (operand == NULL)
1509 /* Data item, not an instruction. */
1510 return BFD_RELOC_V850_TDA_7_7_OFFSET;
1511
1512 if (operand->bits == 6 && operand->shift == 1)
1513 /* sld.w/sst.w, operand: D8_6 */
1514 return BFD_RELOC_V850_TDA_6_8_OFFSET;
1515
1516 if (operand->bits == 4 && operand->insert != NULL)
1517 /* sld.hu, operand: D5-4 */
1518 return BFD_RELOC_V850_TDA_4_5_OFFSET;
1519
1520 if (operand->bits == 4 && operand->insert == NULL)
1521 /* sld.bu, operand: D4 */
1522 return BFD_RELOC_V850_TDA_4_4_OFFSET;
1523
1524 if (operand->bits == 16 && operand->shift == 16)
1525 /* set1 & chums, operands: D16 */
1526 return BFD_RELOC_V850_TDA_16_16_OFFSET;
1527
1528 if (operand->bits != 7)
1529 {
1530 as_bad (_("tdaoff() relocation used on an instruction which does not support it"));
1531 /* Used to indicate an error condition. */
1532 return BFD_RELOC_64;
1533 }
1534
1535 return operand->insert != NULL
1536 ? BFD_RELOC_V850_TDA_7_8_OFFSET /* sld.h/sst.h, operand: D8_7 */
1537 : BFD_RELOC_V850_TDA_7_7_OFFSET; /* sld.b/sst.b, opreand: D7 */
1538 }
1539
1540 /* Warning: The code in this function relies upon the definitions
1541 in the v850_operands[] array (defined in opcodes/v850-opc.c)
1542 matching the hard coded values contained herein. */
1543
1544 static bfd_reloc_code_real_type
1545 v850_reloc_prefix (const struct v850_operand *operand)
1546 {
1547 boolean paren_skipped = false;
1548
1549 /* Skip leading opening parenthesis. */
1550 if (*input_line_pointer == '(')
1551 {
1552 ++input_line_pointer;
1553 paren_skipped = true;
1554 }
1555
1556 #define CHECK_(name, reloc) \
1557 if (strncmp (input_line_pointer, name##"(", strlen (name) + 1) == 0) \
1558 { \
1559 input_line_pointer += strlen (name); \
1560 return reloc; \
1561 }
1562
1563 CHECK_ ("hi0", BFD_RELOC_HI16 );
1564 CHECK_ ("hi", BFD_RELOC_HI16_S );
1565 CHECK_ ("lo", BFD_RELOC_LO16 );
1566 CHECK_ ("sdaoff", handle_sdaoff (operand));
1567 CHECK_ ("zdaoff", handle_zdaoff (operand));
1568 CHECK_ ("tdaoff", handle_tdaoff (operand));
1569 CHECK_ ("hilo", BFD_RELOC_32 );
1570 CHECK_ ("ctoff", handle_ctoff (operand) );
1571
1572 /* Restore skipped parenthesis. */
1573 if (paren_skipped)
1574 --input_line_pointer;
1575
1576 return BFD_RELOC_UNUSED;
1577 }
1578
1579 /* Insert an operand value into an instruction. */
1580
1581 static unsigned long
1582 v850_insert_operand (insn, operand, val, file, line, str)
1583 unsigned long insn;
1584 const struct v850_operand *operand;
1585 offsetT val;
1586 char *file;
1587 unsigned int line;
1588 char *str;
1589 {
1590 if (operand->insert)
1591 {
1592 const char *message = NULL;
1593
1594 insn = operand->insert (insn, val, &message);
1595 if (message != NULL)
1596 {
1597 if ((operand->flags & V850_OPERAND_SIGNED)
1598 && ! warn_signed_overflows
1599 && strstr (message, "out of range") != NULL)
1600 {
1601 /* Skip warning... */
1602 }
1603 else if ((operand->flags & V850_OPERAND_SIGNED) == 0
1604 && ! warn_unsigned_overflows
1605 && strstr (message, "out of range") != NULL)
1606 {
1607 /* Skip warning... */
1608 }
1609 else if (str)
1610 {
1611 if (file == (char *) NULL)
1612 as_warn ("%s: %s", str, message);
1613 else
1614 as_warn_where (file, line, "%s: %s", str, message);
1615 }
1616 else
1617 {
1618 if (file == (char *) NULL)
1619 as_warn (message);
1620 else
1621 as_warn_where (file, line, message);
1622 }
1623 }
1624 }
1625 else
1626 {
1627 if (operand->bits != 32)
1628 {
1629 long min, max;
1630
1631 if ((operand->flags & V850_OPERAND_SIGNED) != 0)
1632 {
1633 if (! warn_signed_overflows)
1634 max = (1 << operand->bits) - 1;
1635 else
1636 max = (1 << (operand->bits - 1)) - 1;
1637
1638 min = -(1 << (operand->bits - 1));
1639 }
1640 else
1641 {
1642 max = (1 << operand->bits) - 1;
1643
1644 if (! warn_unsigned_overflows)
1645 min = -(1 << (operand->bits - 1));
1646 else
1647 min = 0;
1648 }
1649
1650 if (val < (offsetT) min || val > (offsetT) max)
1651 {
1652 /* xgettext:c-format */
1653 const char *err =
1654 _("operand out of range (%s not between %ld and %ld)");
1655 char buf[100];
1656
1657 /* Restore min and mix to expected values for decimal ranges. */
1658 if ((operand->flags & V850_OPERAND_SIGNED)
1659 && ! warn_signed_overflows)
1660 max = (1 << (operand->bits - 1)) - 1;
1661
1662 if (! (operand->flags & V850_OPERAND_SIGNED)
1663 && ! warn_unsigned_overflows)
1664 min = 0;
1665
1666 if (str)
1667 {
1668 sprintf (buf, "%s: ", str);
1669
1670 sprint_value (buf + strlen (buf), val);
1671 }
1672 else
1673 sprint_value (buf, val);
1674
1675 if (file == (char *) NULL)
1676 as_warn (err, buf, min, max);
1677 else
1678 as_warn_where (file, line, err, buf, min, max);
1679 }
1680 }
1681
1682 insn |= (((long) val & ((1 << operand->bits) - 1)) << operand->shift);
1683 }
1684
1685 return insn;
1686 }
1687 \f
1688 static char copy_of_instruction[128];
1689
1690 void
1691 md_assemble (str)
1692 char *str;
1693 {
1694 char *s;
1695 char *start_of_operands;
1696 struct v850_opcode *opcode;
1697 struct v850_opcode *next_opcode;
1698 const unsigned char *opindex_ptr;
1699 int next_opindex;
1700 int relaxable = 0;
1701 unsigned long insn;
1702 unsigned long insn_size;
1703 char *f;
1704 int i;
1705 int match;
1706 boolean extra_data_after_insn = false;
1707 unsigned extra_data_len = 0;
1708 unsigned long extra_data = 0;
1709 char *saved_input_line_pointer;
1710
1711 strncpy (copy_of_instruction, str, sizeof (copy_of_instruction) - 1);
1712
1713 /* Get the opcode. */
1714 for (s = str; *s != '\0' && ! ISSPACE (*s); s++)
1715 continue;
1716
1717 if (*s != '\0')
1718 *s++ = '\0';
1719
1720 /* Find the first opcode with the proper name. */
1721 opcode = (struct v850_opcode *) hash_find (v850_hash, str);
1722 if (opcode == NULL)
1723 {
1724 /* xgettext:c-format */
1725 as_bad (_("Unrecognized opcode: `%s'"), str);
1726 ignore_rest_of_line ();
1727 return;
1728 }
1729
1730 str = s;
1731 while (ISSPACE (*str))
1732 ++str;
1733
1734 start_of_operands = str;
1735
1736 saved_input_line_pointer = input_line_pointer;
1737
1738 for (;;)
1739 {
1740 const char *errmsg = NULL;
1741
1742 match = 0;
1743
1744 if ((opcode->processors & processor_mask) == 0)
1745 {
1746 errmsg = _("Target processor does not support this instruction.");
1747 goto error;
1748 }
1749
1750 relaxable = 0;
1751 fc = 0;
1752 next_opindex = 0;
1753 insn = opcode->opcode;
1754 extra_data_after_insn = false;
1755
1756 input_line_pointer = str = start_of_operands;
1757
1758 for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++)
1759 {
1760 const struct v850_operand *operand;
1761 char *hold;
1762 expressionS ex;
1763 bfd_reloc_code_real_type reloc;
1764
1765 if (next_opindex == 0)
1766 {
1767 operand = &v850_operands[*opindex_ptr];
1768 }
1769 else
1770 {
1771 operand = &v850_operands[next_opindex];
1772 next_opindex = 0;
1773 }
1774
1775 errmsg = NULL;
1776
1777 while (*str == ' ' || *str == ',' || *str == '[' || *str == ']')
1778 ++str;
1779
1780 if (operand->flags & V850_OPERAND_RELAX)
1781 relaxable = 1;
1782
1783 /* Gather the operand. */
1784 hold = input_line_pointer;
1785 input_line_pointer = str;
1786
1787 /* lo(), hi(), hi0(), etc... */
1788 if ((reloc = v850_reloc_prefix (operand)) != BFD_RELOC_UNUSED)
1789 {
1790 /* This is a fake reloc, used to indicate an error condition. */
1791 if (reloc == BFD_RELOC_64)
1792 {
1793 match = 1;
1794 goto error;
1795 }
1796
1797 expression (&ex);
1798
1799 if (ex.X_op == O_constant)
1800 {
1801 switch (reloc)
1802 {
1803 case BFD_RELOC_V850_ZDA_16_16_OFFSET:
1804 /* To cope with "not1 7, zdaoff(0xfffff006)[r0]"
1805 and the like. */
1806 /* Fall through. */
1807
1808 case BFD_RELOC_LO16:
1809 {
1810 /* Truncate, then sign extend the value. */
1811 ex.X_add_number = SEXT16 (ex.X_add_number);
1812 break;
1813 }
1814
1815 case BFD_RELOC_HI16:
1816 {
1817 /* Truncate, then sign extend the value. */
1818 ex.X_add_number = SEXT16 (ex.X_add_number >> 16);
1819 break;
1820 }
1821
1822 case BFD_RELOC_HI16_S:
1823 {
1824 /* Truncate, then sign extend the value. */
1825 int temp = (ex.X_add_number >> 16) & 0xffff;
1826
1827 temp += (ex.X_add_number >> 15) & 1;
1828
1829 ex.X_add_number = SEXT16 (temp);
1830 break;
1831 }
1832
1833 case BFD_RELOC_32:
1834 if ((operand->flags & V850E_IMMEDIATE32) == 0)
1835 {
1836 errmsg = _("immediate operand is too large");
1837 goto error;
1838 }
1839
1840 extra_data_after_insn = true;
1841 extra_data_len = 4;
1842 extra_data = ex.X_add_number;
1843 ex.X_add_number = 0;
1844 break;
1845
1846 default:
1847 fprintf (stderr, "reloc: %d\n", reloc);
1848 as_bad (_("AAARG -> unhandled constant reloc"));
1849 break;
1850 }
1851
1852 if (fc > MAX_INSN_FIXUPS)
1853 as_fatal (_("too many fixups"));
1854
1855 fixups[fc].exp = ex;
1856 fixups[fc].opindex = *opindex_ptr;
1857 fixups[fc].reloc = reloc;
1858 fc++;
1859 }
1860 else
1861 {
1862 if (reloc == BFD_RELOC_32)
1863 {
1864 if ((operand->flags & V850E_IMMEDIATE32) == 0)
1865 {
1866 errmsg = _("immediate operand is too large");
1867 goto error;
1868 }
1869
1870 extra_data_after_insn = true;
1871 extra_data_len = 4;
1872 extra_data = ex.X_add_number;
1873 }
1874
1875 if (fc > MAX_INSN_FIXUPS)
1876 as_fatal (_("too many fixups"));
1877
1878 fixups[fc].exp = ex;
1879 fixups[fc].opindex = *opindex_ptr;
1880 fixups[fc].reloc = reloc;
1881 fc++;
1882 }
1883 }
1884 else
1885 {
1886 errmsg = NULL;
1887
1888 if ((operand->flags & V850_OPERAND_REG) != 0)
1889 {
1890 if (!register_name (&ex))
1891 {
1892 errmsg = _("invalid register name");
1893 }
1894 else if ((operand->flags & V850_NOT_R0)
1895 && ex.X_add_number == 0)
1896 {
1897 errmsg = _("register r0 cannot be used here");
1898
1899 /* Force an error message to be generated by
1900 skipping over any following potential matches
1901 for this opcode. */
1902 opcode += 3;
1903 }
1904 }
1905 else if ((operand->flags & V850_OPERAND_SRG) != 0)
1906 {
1907 if (!system_register_name (&ex, true, false))
1908 {
1909 errmsg = _("invalid system register name");
1910 }
1911 }
1912 else if ((operand->flags & V850_OPERAND_EP) != 0)
1913 {
1914 char *start = input_line_pointer;
1915 char c = get_symbol_end ();
1916
1917 if (strcmp (start, "ep") != 0 && strcmp (start, "r30") != 0)
1918 {
1919 /* Put things back the way we found them. */
1920 *input_line_pointer = c;
1921 input_line_pointer = start;
1922 errmsg = _("expected EP register");
1923 goto error;
1924 }
1925
1926 *input_line_pointer = c;
1927 str = input_line_pointer;
1928 input_line_pointer = hold;
1929
1930 while (*str == ' ' || *str == ','
1931 || *str == '[' || *str == ']')
1932 ++str;
1933 continue;
1934 }
1935 else if ((operand->flags & V850_OPERAND_CC) != 0)
1936 {
1937 if (!cc_name (&ex))
1938 {
1939 errmsg = _("invalid condition code name");
1940 }
1941 }
1942 else if (operand->flags & V850E_PUSH_POP)
1943 {
1944 errmsg = parse_register_list (&insn, operand);
1945
1946 /* The parse_register_list() function has already done
1947 everything, so fake a dummy expression. */
1948 ex.X_op = O_constant;
1949 ex.X_add_number = 0;
1950 }
1951 else if (operand->flags & V850E_IMMEDIATE16)
1952 {
1953 expression (&ex);
1954
1955 if (ex.X_op != O_constant)
1956 errmsg = _("constant expression expected");
1957 else if (ex.X_add_number & 0xffff0000)
1958 {
1959 if (ex.X_add_number & 0xffff)
1960 errmsg = _("constant too big to fit into instruction");
1961 else if ((insn & 0x001fffc0) == 0x00130780)
1962 ex.X_add_number >>= 16;
1963 else
1964 errmsg = _("constant too big to fit into instruction");
1965 }
1966
1967 extra_data_after_insn = true;
1968 extra_data_len = 2;
1969 extra_data = ex.X_add_number;
1970 ex.X_add_number = 0;
1971 }
1972 else if (operand->flags & V850E_IMMEDIATE32)
1973 {
1974 expression (&ex);
1975
1976 if (ex.X_op != O_constant)
1977 errmsg = _("constant expression expected");
1978
1979 extra_data_after_insn = true;
1980 extra_data_len = 4;
1981 extra_data = ex.X_add_number;
1982 ex.X_add_number = 0;
1983 }
1984 else if (register_name (&ex)
1985 && (operand->flags & V850_OPERAND_REG) == 0)
1986 {
1987 char c;
1988 int exists = 0;
1989
1990 /* It is possible that an alias has been defined that
1991 matches a register name. For example the code may
1992 include a ".set ZERO, 0" directive, which matches
1993 the register name "zero". Attempt to reparse the
1994 field as an expression, and only complain if we
1995 cannot generate a constant. */
1996
1997 input_line_pointer = str;
1998
1999 c = get_symbol_end ();
2000
2001 if (symbol_find (str) != NULL)
2002 exists = 1;
2003
2004 *input_line_pointer = c;
2005 input_line_pointer = str;
2006
2007 expression (&ex);
2008
2009 if (ex.X_op != O_constant)
2010 {
2011 /* If this register is actually occuring too early on
2012 the parsing of the instruction, (because another
2013 field is missing) then report this. */
2014 if (opindex_ptr[1] != 0
2015 && (v850_operands[opindex_ptr[1]].flags
2016 & V850_OPERAND_REG))
2017 errmsg = _("syntax error: value is missing before the register name");
2018 else
2019 errmsg = _("syntax error: register not expected");
2020
2021 /* If we created a symbol in the process of this
2022 test then delete it now, so that it will not
2023 be output with the real symbols... */
2024 if (exists == 0
2025 && ex.X_op == O_symbol)
2026 symbol_remove (ex.X_add_symbol,
2027 &symbol_rootP, &symbol_lastP);
2028 }
2029 }
2030 else if (system_register_name (&ex, false, false)
2031 && (operand->flags & V850_OPERAND_SRG) == 0)
2032 {
2033 errmsg = _("syntax error: system register not expected");
2034 }
2035 else if (cc_name (&ex)
2036 && (operand->flags & V850_OPERAND_CC) == 0)
2037 {
2038 errmsg = _("syntax error: condition code not expected");
2039 }
2040 else
2041 {
2042 expression (&ex);
2043 /* Special case:
2044 If we are assembling a MOV instruction (or a CALLT.... :-)
2045 and the immediate value does not fit into the bits
2046 available then create a fake error so that the next MOV
2047 instruction will be selected. This one has a 32 bit
2048 immediate field. */
2049
2050 if (((insn & 0x07e0) == 0x0200)
2051 && ex.X_op == O_constant
2052 && (ex.X_add_number < (-(1 << (operand->bits - 1)))
2053 || ex.X_add_number > ((1 << operand->bits) - 1)))
2054 errmsg = _("immediate operand is too large");
2055 }
2056
2057 if (errmsg)
2058 goto error;
2059
2060 #if 0
2061 fprintf (stderr,
2062 " insn: %x, operand %d, op: %d, add_number: %d\n",
2063 insn, opindex_ptr - opcode->operands,
2064 ex.X_op, ex.X_add_number);
2065 #endif
2066
2067 switch (ex.X_op)
2068 {
2069 case O_illegal:
2070 errmsg = _("illegal operand");
2071 goto error;
2072 case O_absent:
2073 errmsg = _("missing operand");
2074 goto error;
2075 case O_register:
2076 if ((operand->flags
2077 & (V850_OPERAND_REG | V850_OPERAND_SRG)) == 0)
2078 {
2079 errmsg = _("invalid operand");
2080 goto error;
2081 }
2082 insn = v850_insert_operand (insn, operand, ex.X_add_number,
2083 (char *) NULL, 0,
2084 copy_of_instruction);
2085 break;
2086
2087 case O_constant:
2088 insn = v850_insert_operand (insn, operand, ex.X_add_number,
2089 (char *) NULL, 0,
2090 copy_of_instruction);
2091 break;
2092
2093 default:
2094 /* We need to generate a fixup for this expression. */
2095 if (fc >= MAX_INSN_FIXUPS)
2096 as_fatal (_("too many fixups"));
2097
2098 fixups[fc].exp = ex;
2099 fixups[fc].opindex = *opindex_ptr;
2100 fixups[fc].reloc = BFD_RELOC_UNUSED;
2101 ++fc;
2102 break;
2103 }
2104 }
2105
2106 str = input_line_pointer;
2107 input_line_pointer = hold;
2108
2109 while (*str == ' ' || *str == ',' || *str == '[' || *str == ']'
2110 || *str == ')')
2111 ++str;
2112 }
2113 match = 1;
2114
2115 error:
2116 if (match == 0)
2117 {
2118 next_opcode = opcode + 1;
2119 if (next_opcode->name != NULL
2120 && strcmp (next_opcode->name, opcode->name) == 0)
2121 {
2122 opcode = next_opcode;
2123
2124 /* Skip versions that are not supported by the target
2125 processor. */
2126 if ((opcode->processors & processor_mask) == 0)
2127 goto error;
2128
2129 continue;
2130 }
2131
2132 as_bad ("%s: %s", copy_of_instruction, errmsg);
2133
2134 if (*input_line_pointer == ']')
2135 ++input_line_pointer;
2136
2137 ignore_rest_of_line ();
2138 input_line_pointer = saved_input_line_pointer;
2139 return;
2140 }
2141 break;
2142 }
2143
2144 while (ISSPACE (*str))
2145 ++str;
2146
2147 if (*str != '\0')
2148 /* xgettext:c-format */
2149 as_bad (_("junk at end of line: `%s'"), str);
2150
2151 input_line_pointer = str;
2152
2153 /* Tie dwarf2 debug info to the address at the start of the insn.
2154 We can't do this after the insn has been output as the current
2155 frag may have been closed off. eg. by frag_var. */
2156 dwarf2_emit_insn (0);
2157
2158 /* Write out the instruction. */
2159
2160 if (relaxable && fc > 0)
2161 {
2162 insn_size = 2;
2163 fc = 0;
2164
2165 if (!strcmp (opcode->name, "br"))
2166 {
2167 f = frag_var (rs_machine_dependent, 4, 2, 2,
2168 fixups[0].exp.X_add_symbol,
2169 fixups[0].exp.X_add_number,
2170 (char *) fixups[0].opindex);
2171 md_number_to_chars (f, insn, insn_size);
2172 md_number_to_chars (f + 2, 0, 2);
2173 }
2174 else
2175 {
2176 f = frag_var (rs_machine_dependent, 6, 4, 0,
2177 fixups[0].exp.X_add_symbol,
2178 fixups[0].exp.X_add_number,
2179 (char *) fixups[0].opindex);
2180 md_number_to_chars (f, insn, insn_size);
2181 md_number_to_chars (f + 2, 0, 4);
2182 }
2183 }
2184 else
2185 {
2186 /* Four byte insns have an opcode with the two high bits on. */
2187 if ((insn & 0x0600) == 0x0600)
2188 insn_size = 4;
2189 else
2190 insn_size = 2;
2191
2192 /* Special case: 32 bit MOV. */
2193 if ((insn & 0xffe0) == 0x0620)
2194 insn_size = 2;
2195
2196 f = frag_more (insn_size);
2197 md_number_to_chars (f, insn, insn_size);
2198
2199 if (extra_data_after_insn)
2200 {
2201 f = frag_more (extra_data_len);
2202 md_number_to_chars (f, extra_data, extra_data_len);
2203
2204 extra_data_after_insn = false;
2205 }
2206 }
2207
2208 /* Create any fixups. At this point we do not use a
2209 bfd_reloc_code_real_type, but instead just use the
2210 BFD_RELOC_UNUSED plus the operand index. This lets us easily
2211 handle fixups for any operand type, although that is admittedly
2212 not a very exciting feature. We pick a BFD reloc type in
2213 md_apply_fix3. */
2214 for (i = 0; i < fc; i++)
2215 {
2216 const struct v850_operand *operand;
2217 bfd_reloc_code_real_type reloc;
2218
2219 operand = &v850_operands[fixups[i].opindex];
2220
2221 reloc = fixups[i].reloc;
2222
2223 if (reloc != BFD_RELOC_UNUSED)
2224 {
2225 reloc_howto_type *reloc_howto =
2226 bfd_reloc_type_lookup (stdoutput, reloc);
2227 int size;
2228 int address;
2229 fixS *fixP;
2230
2231 if (!reloc_howto)
2232 abort ();
2233
2234 size = bfd_get_reloc_size (reloc_howto);
2235
2236 /* XXX This will abort on an R_V850_8 reloc -
2237 is this reloc actually used? */
2238 if (size != 2 && size != 4)
2239 abort ();
2240
2241 address = (f - frag_now->fr_literal) + insn_size - size;
2242
2243 if (reloc == BFD_RELOC_32)
2244 address += 2;
2245
2246 fixP = fix_new_exp (frag_now, address, size,
2247 &fixups[i].exp,
2248 reloc_howto->pc_relative,
2249 reloc);
2250
2251 switch (reloc)
2252 {
2253 case BFD_RELOC_LO16:
2254 case BFD_RELOC_HI16:
2255 case BFD_RELOC_HI16_S:
2256 fixP->fx_no_overflow = 1;
2257 break;
2258 default:
2259 break;
2260 }
2261 }
2262 else
2263 {
2264 fix_new_exp (frag_now,
2265 f - frag_now->fr_literal, 4,
2266 & fixups[i].exp,
2267 1 /* FIXME: V850_OPERAND_RELATIVE ??? */,
2268 (bfd_reloc_code_real_type) (fixups[i].opindex
2269 + (int) BFD_RELOC_UNUSED));
2270 }
2271 }
2272
2273 input_line_pointer = saved_input_line_pointer;
2274 }
2275
2276 /* If while processing a fixup, a reloc really needs to be created
2277 then it is done here. */
2278
2279 arelent *
2280 tc_gen_reloc (seg, fixp)
2281 asection *seg ATTRIBUTE_UNUSED;
2282 fixS *fixp;
2283 {
2284 arelent *reloc;
2285
2286 reloc = (arelent *) xmalloc (sizeof (arelent));
2287 reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
2288 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
2289 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
2290 reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
2291
2292 if (reloc->howto == (reloc_howto_type *) NULL)
2293 {
2294 as_bad_where (fixp->fx_file, fixp->fx_line,
2295 /* xgettext:c-format */
2296 _("reloc %d not supported by object file format"),
2297 (int) fixp->fx_r_type);
2298
2299 xfree (reloc);
2300
2301 return NULL;
2302 }
2303
2304 if (fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY
2305 || fixp->fx_r_type == BFD_RELOC_VTABLE_INHERIT)
2306 reloc->addend = fixp->fx_offset;
2307 else
2308 reloc->addend = fixp->fx_addnumber;
2309
2310 return reloc;
2311 }
2312
2313 /* Return current size of variable part of frag. */
2314
2315 int
2316 md_estimate_size_before_relax (fragp, seg)
2317 fragS *fragp;
2318 asection *seg ATTRIBUTE_UNUSED;
2319 {
2320 if (fragp->fr_subtype >= sizeof (md_relax_table) / sizeof (md_relax_table[0]))
2321 abort ();
2322
2323 return md_relax_table[fragp->fr_subtype].rlx_length;
2324 }
2325
2326 long
2327 v850_pcrel_from_section (fixp, section)
2328 fixS *fixp;
2329 segT section;
2330 {
2331 /* If the symbol is undefined, or in a section other than our own,
2332 or it is weak (in which case it may well be in another section,
2333 then let the linker figure it out. */
2334 if (fixp->fx_addsy != (symbolS *) NULL
2335 && (! S_IS_DEFINED (fixp->fx_addsy)
2336 || S_IS_WEAK (fixp->fx_addsy)
2337 || (S_GET_SEGMENT (fixp->fx_addsy) != section)))
2338 return 0;
2339
2340 return fixp->fx_frag->fr_address + fixp->fx_where;
2341 }
2342
2343 void
2344 md_apply_fix3 (fixP, valueP, seg)
2345 fixS *fixP;
2346 valueT *valueP;
2347 segT seg ATTRIBUTE_UNUSED;
2348 {
2349 valueT value = * valueP;
2350 char *where;
2351
2352 if (fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
2353 || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
2354 {
2355 fixP->fx_done = 0;
2356 return;
2357 }
2358
2359 if (fixP->fx_addsy == (symbolS *) NULL)
2360 fixP->fx_done = 1;
2361
2362 else if (fixP->fx_pcrel)
2363 ;
2364
2365 else
2366 {
2367 value = fixP->fx_offset;
2368 if (fixP->fx_subsy != (symbolS *) NULL)
2369 {
2370 if (S_GET_SEGMENT (fixP->fx_subsy) == absolute_section)
2371 value -= S_GET_VALUE (fixP->fx_subsy);
2372 else
2373 {
2374 /* We don't actually support subtracting a symbol. */
2375 as_bad_where (fixP->fx_file, fixP->fx_line,
2376 _("expression too complex"));
2377 }
2378 }
2379 }
2380
2381 if ((int) fixP->fx_r_type >= (int) BFD_RELOC_UNUSED)
2382 {
2383 int opindex;
2384 const struct v850_operand *operand;
2385 unsigned long insn;
2386
2387 opindex = (int) fixP->fx_r_type - (int) BFD_RELOC_UNUSED;
2388 operand = &v850_operands[opindex];
2389
2390 /* Fetch the instruction, insert the fully resolved operand
2391 value, and stuff the instruction back again.
2392
2393 Note the instruction has been stored in little endian
2394 format! */
2395 where = fixP->fx_frag->fr_literal + fixP->fx_where;
2396
2397 insn = bfd_getl32 ((unsigned char *) where);
2398 insn = v850_insert_operand (insn, operand, (offsetT) value,
2399 fixP->fx_file, fixP->fx_line, NULL);
2400 bfd_putl32 ((bfd_vma) insn, (unsigned char *) where);
2401
2402 if (fixP->fx_done)
2403 /* Nothing else to do here. */
2404 return;
2405
2406 /* Determine a BFD reloc value based on the operand information.
2407 We are only prepared to turn a few of the operands into relocs. */
2408
2409 if (operand->bits == 22)
2410 fixP->fx_r_type = BFD_RELOC_V850_22_PCREL;
2411 else if (operand->bits == 9)
2412 fixP->fx_r_type = BFD_RELOC_V850_9_PCREL;
2413 else
2414 {
2415 #if 0
2416 fprintf (stderr, "bits: %d, insn: %x\n", operand->bits, insn);
2417 #endif
2418
2419 as_bad_where (fixP->fx_file, fixP->fx_line,
2420 _("unresolved expression that must be resolved"));
2421 fixP->fx_done = 1;
2422 return;
2423 }
2424 }
2425 else if (fixP->fx_done)
2426 {
2427 /* We still have to insert the value into memory! */
2428 where = fixP->fx_frag->fr_literal + fixP->fx_where;
2429
2430 if (fixP->fx_size == 1)
2431 *where = value & 0xff;
2432 else if (fixP->fx_size == 2)
2433 bfd_putl16 (value & 0xffff, (unsigned char *) where);
2434 else if (fixP->fx_size == 4)
2435 bfd_putl32 (value, (unsigned char *) where);
2436 }
2437
2438 fixP->fx_addnumber = value;
2439 }
2440 \f
2441 /* Parse a cons expression. We have to handle hi(), lo(), etc
2442 on the v850. */
2443
2444 void
2445 parse_cons_expression_v850 (exp)
2446 expressionS *exp;
2447 {
2448 /* See if there's a reloc prefix like hi() we have to handle. */
2449 hold_cons_reloc = v850_reloc_prefix (NULL);
2450
2451 /* Do normal expression parsing. */
2452 expression (exp);
2453 }
2454
2455 /* Create a fixup for a cons expression. If parse_cons_expression_v850
2456 found a reloc prefix, then we use that reloc, else we choose an
2457 appropriate one based on the size of the expression. */
2458
2459 void
2460 cons_fix_new_v850 (frag, where, size, exp)
2461 fragS *frag;
2462 int where;
2463 int size;
2464 expressionS *exp;
2465 {
2466 if (hold_cons_reloc == BFD_RELOC_UNUSED)
2467 {
2468 if (size == 4)
2469 hold_cons_reloc = BFD_RELOC_32;
2470 if (size == 2)
2471 hold_cons_reloc = BFD_RELOC_16;
2472 if (size == 1)
2473 hold_cons_reloc = BFD_RELOC_8;
2474 }
2475
2476 if (exp != NULL)
2477 fix_new_exp (frag, where, size, exp, 0, hold_cons_reloc);
2478 else
2479 fix_new (frag, where, size, NULL, 0, 0, hold_cons_reloc);
2480
2481 hold_cons_reloc = BFD_RELOC_UNUSED;
2482 }
2483
2484 boolean
2485 v850_fix_adjustable (fixP)
2486 fixS *fixP;
2487 {
2488 if (fixP->fx_addsy == NULL)
2489 return 1;
2490
2491 /* Prevent all adjustments to global symbols. */
2492 if (S_IS_EXTERN (fixP->fx_addsy))
2493 return 0;
2494
2495 /* Similarly for weak symbols. */
2496 if (S_IS_WEAK (fixP->fx_addsy))
2497 return 0;
2498
2499 /* Don't adjust function names. */
2500 if (S_IS_FUNCTION (fixP->fx_addsy))
2501 return 0;
2502
2503 /* We need the symbol name for the VTABLE entries. */
2504 if (fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
2505 || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
2506 return 0;
2507
2508 return 1;
2509 }
2510
2511 int
2512 v850_force_relocation (fixP)
2513 struct fix *fixP;
2514 {
2515 if (fixP->fx_addsy && S_IS_WEAK (fixP->fx_addsy))
2516 return 1;
2517
2518 if (fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
2519 || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
2520 return 1;
2521
2522 return 0;
2523 }
GDB Binutils - Deliverables
This page took 0.081288 seconds and 4 git commands to generate.