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