?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* reloc.c: Add BFD_RELOC_RX_OP_NEG.
[binutils.git] / gas / config / tc-rx.c
blobd1980509823da223f0adb11912d2760a9625cdc6
1 /* tc-rx.c -- Assembler for the Renesas RX
2 Copyright 2008, 2009, 2010
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 3, 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 the Free
19 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
20 02110-1301, USA. */
21
22 #include "as.h"
23 #include "struc-symbol.h"
24 #include "obstack.h"
25 #include "safe-ctype.h"
26 #include "dwarf2dbg.h"
27 #include "libbfd.h"
28 #include "elf/common.h"
29 #include "elf/rx.h"
30 #include "rx-defs.h"
31 #include "filenames.h"
32 #include "listing.h"
33 #include "sb.h"
34 #include "macro.h"
35
36 #define RX_OPCODE_BIG_ENDIAN 0
37
38 const char comment_chars[] = ";";
39 /* Note that input_file.c hand checks for '#' at the beginning of the
40 first line of the input file. This is because the compiler outputs
41 #NO_APP at the beginning of its output. */
42 const char line_comment_chars[] = "#";
43 const char line_separator_chars[] = "!";
44
45 const char EXP_CHARS[] = "eE";
46 const char FLT_CHARS[] = "dD";
47 \f
48 /* ELF flags to set in the output file header. */
49 static int elf_flags = 0;
50
51 bfd_boolean rx_use_conventional_section_names = FALSE;
52 static bfd_boolean rx_use_small_data_limit = FALSE;
53
54 enum options
55 {
56 OPTION_BIG = OPTION_MD_BASE,
57 OPTION_LITTLE,
58 OPTION_32BIT_DOUBLES,
59 OPTION_64BIT_DOUBLES,
60 OPTION_CONVENTIONAL_SECTION_NAMES,
61 OPTION_RENESAS_SECTION_NAMES,
62 OPTION_SMALL_DATA_LIMIT,
63 OPTION_RELAX
64 };
65
66 #define RX_SHORTOPTS ""
67 const char * md_shortopts = RX_SHORTOPTS;
68
69 /* Assembler options. */
70 struct option md_longopts[] =
71 {
72 {"mbig-endian-data", no_argument, NULL, OPTION_BIG},
73 {"mlittle-endian-data", no_argument, NULL, OPTION_LITTLE},
74 /* The next two switches are here because the
75 generic parts of the linker testsuite uses them. */
76 {"EB", no_argument, NULL, OPTION_BIG},
77 {"EL", no_argument, NULL, OPTION_LITTLE},
78 {"m32bit-doubles", no_argument, NULL, OPTION_32BIT_DOUBLES},
79 {"m64bit-doubles", no_argument, NULL, OPTION_64BIT_DOUBLES},
80 /* This option is here mainly for the binutils testsuites,
81 as many of their tests assume conventional section naming. */
82 {"muse-conventional-section-names", no_argument, NULL, OPTION_CONVENTIONAL_SECTION_NAMES},
83 {"muse-renesas-section-names", no_argument, NULL, OPTION_RENESAS_SECTION_NAMES},
84 {"msmall-data-limit", no_argument, NULL, OPTION_SMALL_DATA_LIMIT},
85 {"relax", no_argument, NULL, OPTION_RELAX},
86 {NULL, no_argument, NULL, 0}
87 };
88 size_t md_longopts_size = sizeof (md_longopts);
89
90 int
91 md_parse_option (int c ATTRIBUTE_UNUSED, char * arg ATTRIBUTE_UNUSED)
92 {
93 switch (c)
94 {
95 case OPTION_BIG:
96 target_big_endian = 1;
97 return 1;
98
99 case OPTION_LITTLE:
100 target_big_endian = 0;
101 return 1;
102
103 case OPTION_32BIT_DOUBLES:
104 elf_flags &= ~ E_FLAG_RX_64BIT_DOUBLES;
105 return 1;
106
107 case OPTION_64BIT_DOUBLES:
108 elf_flags |= E_FLAG_RX_64BIT_DOUBLES;
109 return 1;
110
111 case OPTION_CONVENTIONAL_SECTION_NAMES:
112 rx_use_conventional_section_names = TRUE;
113 return 1;
114
115 case OPTION_RENESAS_SECTION_NAMES:
116 rx_use_conventional_section_names = FALSE;
117 return 1;
118
119 case OPTION_SMALL_DATA_LIMIT:
120 rx_use_small_data_limit = TRUE;
121 return 1;
122
123 case OPTION_RELAX:
124 linkrelax = 1;
125 return 1;
126 }
127 return 0;
128 }
129
130 void
131 md_show_usage (FILE * stream)
132 {
133 fprintf (stream, _(" RX specific command line options:\n"));
134 fprintf (stream, _(" --mbig-endian-data\n"));
135 fprintf (stream, _(" --mlittle-endian-data [default]\n"));
136 fprintf (stream, _(" --m32bit-doubles [default]\n"));
137 fprintf (stream, _(" --m64bit-doubles\n"));
138 fprintf (stream, _(" --muse-conventional-section-names\n"));
139 fprintf (stream, _(" --muse-renesas-section-names [default]\n"));
140 fprintf (stream, _(" --msmall-data-limit\n"));
141 }
142
143 static void
144 s_bss (int ignore ATTRIBUTE_UNUSED)
145 {
146 int temp;
147
148 temp = get_absolute_expression ();
149 subseg_set (bss_section, (subsegT) temp);
150 demand_empty_rest_of_line ();
151 }
152
153 static void
154 rx_float_cons (int ignore ATTRIBUTE_UNUSED)
155 {
156 if (elf_flags & E_FLAG_RX_64BIT_DOUBLES)
157 return float_cons ('d');
158 return float_cons ('f');
159 }
160
161 static char *
162 rx_strcasestr (const char *string, const char *sub)
163 {
164 int subl;
165 int strl;
166
167 if (!sub || !sub[0])
168 return (char *)string;
169
170 subl = strlen (sub);
171 strl = strlen (string);
172
173 while (strl >= subl)
174 {
175 /* strncasecmp is in libiberty. */
176 if (strncasecmp (string, sub, subl) == 0)
177 return (char *)string;
178
179 string ++;
180 strl --;
181 }
182 return NULL;
183 }
184
185 static void
186 rx_include (int ignore)
187 {
188 FILE * try;
189 char * path;
190 char * filename;
191 char * current_filename;
192 char * eof;
193 char * p;
194 char * d;
195 char * f;
196 char end_char;
197 size_t len;
198
199 /* The RX version of the .INCLUDE pseudo-op does not
200 have to have the filename inside double quotes. */
201 SKIP_WHITESPACE ();
202 if (*input_line_pointer == '"')
203 {
204 /* Treat as the normal GAS .include pseudo-op. */
205 s_include (ignore);
206 return;
207 }
208
209 /* Get the filename. Spaces are allowed, NUL characters are not. */
210 filename = input_line_pointer;
211 eof = find_end_of_line (filename, FALSE);
212 input_line_pointer = eof;
213
214 while (eof >= filename && (* eof == ' ' || * eof == '\n'))
215 -- eof;
216 end_char = *(++ eof);
217 * eof = 0;
218 if (eof == filename)
219 {
220 as_bad (_("no filename following .INCLUDE pseudo-op"));
221 * eof = end_char;
222 return;
223 }
224
225 as_where (& current_filename, NULL);
226 f = (char *) xmalloc (strlen (current_filename) + strlen (filename) + 1);
227
228 /* Check the filename. If [@]..FILE[@] is found then replace
229 this with the current assembler source filename, stripped
230 of any directory prefixes or extensions. */
231 if ((p = rx_strcasestr (filename, "..file")) != NULL)
232 {
233 char * c;
234
235 len = 6; /* strlen ("..file"); */
236
237 if (p > filename && p[-1] == '@')
238 -- p, ++len;
239
240 if (p[len] == '@')
241 len ++;
242
243 for (d = c = current_filename; *c; c++)
244 if (IS_DIR_SEPARATOR (* c))
245 d = c + 1;
246 for (c = d; *c; c++)
247 if (*c == '.')
248 break;
249
250 sprintf (f, "%.*s%.*s%.*s", (int) (p - filename), filename,
251 (int) (c - d), d,
252 (int) (strlen (filename) - ((p + len) - filename)),
253 p + len);
254 }
255 else
256 strcpy (f, filename);
257
258 /* RX .INCLUDE semantics say that 'filename' is located by:
259
260 1. If filename is absolute, just try that. Otherwise...
261
262 2. If the current source file includes a directory component
263 then prepend that to the filename and try. Otherwise...
264
265 3. Try any directories specified by the -I command line
266 option(s).
267
268 4 .Try a directory specifed by the INC100 environment variable. */
269
270 if (IS_ABSOLUTE_PATH (f))
271 try = fopen (path = f, FOPEN_RT);
272 else
273 {
274 char * env = getenv ("INC100");
275
276 try = NULL;
277
278 len = strlen (current_filename);
279 if ((size_t) include_dir_maxlen > len)
280 len = include_dir_maxlen;
281 if (env && strlen (env) > len)
282 len = strlen (env);
283
284 path = (char *) xmalloc (strlen (f) + len + 5);
285
286 if (current_filename != NULL)
287 {
288 for (d = NULL, p = current_filename; *p; p++)
289 if (IS_DIR_SEPARATOR (* p))
290 d = p;
291
292 if (d != NULL)
293 {
294 sprintf (path, "%.*s/%s", (int) (d - current_filename), current_filename,
295 f);
296 try = fopen (path, FOPEN_RT);
297 }
298 }
299
300 if (try == NULL)
301 {
302 int i;
303
304 for (i = 0; i < include_dir_count; i++)
305 {
306 sprintf (path, "%s/%s", include_dirs[i], f);
307 if ((try = fopen (path, FOPEN_RT)) != NULL)
308 break;
309 }
310 }
311
312 if (try == NULL && env != NULL)
313 {
314 sprintf (path, "%s/%s", env, f);
315 try = fopen (path, FOPEN_RT);
316 }
317
318 free (f);
319 }
320
321 if (try == NULL)
322 {
323 as_bad (_("unable to locate include file: %s"), filename);
324 free (path);
325 }
326 else
327 {
328 fclose (try);
329 register_dependency (path);
330 input_scrub_insert_file (path);
331 }
332
333 * eof = end_char;
334 }
335
336 static void
337 parse_rx_section (char * name)
338 {
339 asection * sec;
340 int type;
341 int attr = SHF_ALLOC | SHF_EXECINSTR;
342 int align = 2;
343 char end_char;
344
345 do
346 {
347 char * p;
348
349 SKIP_WHITESPACE ();
350 for (p = input_line_pointer; *p && strchr ("\n\t, =", *p) == NULL; p++)
351 ;
352 end_char = *p;
353 *p = 0;
354
355 if (strcasecmp (input_line_pointer, "ALIGN") == 0)
356 {
357 *p = end_char;
358
359 if (end_char == ' ')
360 while (ISSPACE (*p))
361 p++;
362
363 if (*p == '=')
364 {
365 ++ p;
366 while (ISSPACE (*p))
367 p++;
368 switch (*p)
369 {
370 case '2': align = 2; break;
371 case '4': align = 4; break;
372 case '8': align = 8; break;
373 default:
374 as_bad (_("unrecognised alignment value in .SECTION directive: %s"), p);
375 ignore_rest_of_line ();
376 return;
377 }
378 ++ p;
379 }
380
381 end_char = *p;
382 }
383 else if (strcasecmp (input_line_pointer, "CODE") == 0)
384 attr = SHF_ALLOC | SHF_EXECINSTR;
385 else if (strcasecmp (input_line_pointer, "DATA") == 0)
386 attr = SHF_ALLOC | SHF_WRITE;
387 else if (strcasecmp (input_line_pointer, "ROMDATA") == 0)
388 attr = SHF_ALLOC;
389 else
390 {
391 as_bad (_("unknown parameter following .SECTION directive: %s"),
392 input_line_pointer);
393
394 *p = end_char;
395 input_line_pointer = p + 1;
396 ignore_rest_of_line ();
397 return;
398 }
399
400 *p = end_char;
401 input_line_pointer = p + 1;
402 }
403 while (end_char != '\n' && end_char != 0);
404
405 if ((sec = bfd_get_section_by_name (stdoutput, name)) == NULL)
406 {
407 if (strcmp (name, "B") && strcmp (name, "B_1") && strcmp (name, "B_2"))
408 type = SHT_NULL;
409 else
410 type = SHT_NOBITS;
411
412 obj_elf_change_section (name, type, attr, 0, NULL, FALSE, FALSE);
413 }
414 else /* Try not to redefine a section, especially B_1. */
415 {
416 int flags = sec->flags;
417
418 type = elf_section_type (sec);
419
420 attr = ((flags & SEC_READONLY) ? 0 : SHF_WRITE)
421 | ((flags & SEC_ALLOC) ? SHF_ALLOC : 0)
422 | ((flags & SEC_CODE) ? SHF_EXECINSTR : 0)
423 | ((flags & SEC_MERGE) ? SHF_MERGE : 0)
424 | ((flags & SEC_STRINGS) ? SHF_STRINGS : 0)
425 | ((flags & SEC_THREAD_LOCAL) ? SHF_TLS : 0);
426
427 obj_elf_change_section (name, type, attr, 0, NULL, FALSE, FALSE);
428 }
429
430 bfd_set_section_alignment (stdoutput, now_seg, align);
431 }
432
433 static void
434 rx_section (int ignore)
435 {
436 char * p;
437
438 /* The as100 assembler supports a different syntax for the .section
439 pseudo-op. So check for it and handle it here if necessary. */
440 SKIP_WHITESPACE ();
441
442 /* Peek past the section name to see if arguments follow. */
443 for (p = input_line_pointer; *p; p++)
444 if (*p == ',' || *p == '\n')
445 break;
446
447 if (*p == ',')
448 {
449 int len = p - input_line_pointer;
450
451 while (ISSPACE (*++p))
452 ;
453
454 if (*p != '"' && *p != '#')
455 {
456 char * name = (char *) xmalloc (len + 1);
457
458 strncpy (name, input_line_pointer, len);
459 name[len] = 0;
460
461 input_line_pointer = p;
462 parse_rx_section (name);
463 return;
464 }
465 }
466
467 obj_elf_section (ignore);
468 }
469
470 static void
471 rx_list (int ignore ATTRIBUTE_UNUSED)
472 {
473 SKIP_WHITESPACE ();
474
475 if (strncasecmp (input_line_pointer, "OFF", 3))
476 listing_list (0);
477 else if (strncasecmp (input_line_pointer, "ON", 2))
478 listing_list (1);
479 else
480 as_warn (_("expecting either ON or OFF after .list"));
481 }
482
483 /* Like the .rept pseudo op, but supports the
484 use of ..MACREP inside the repeated region. */
485
486 static void
487 rx_rept (int ignore ATTRIBUTE_UNUSED)
488 {
489 int count = get_absolute_expression ();
490
491 do_repeat_with_expander (count, "MREPEAT", "ENDR", "..MACREP");
492 }
493
494 /* Like cons() accept that strings are allowed. */
495
496 static void
497 rx_cons (int size)
498 {
499 SKIP_WHITESPACE ();
500
501 if (* input_line_pointer == '"')
502 stringer (8+0);
503 else
504 cons (size);
505 }
506
507 static void
508 rx_nop (int ignore ATTRIBUTE_UNUSED)
509 {
510 ignore_rest_of_line ();
511 }
512
513 static void
514 rx_unimp (int idx)
515 {
516 as_warn (_("The \".%s\" pseudo-op is not implemented\n"),
517 md_pseudo_table[idx].poc_name);
518 ignore_rest_of_line ();
519 }
520
521 /* The target specific pseudo-ops which we support. */
522 const pseudo_typeS md_pseudo_table[] =
523 {
524 /* These are unimplemented. They're listed first so that we can use
525 the poc_value as the index into this array, to get the name of
526 the pseudo. So, keep these (1) first, and (2) in order, with (3)
527 the poc_value's in sequence. */
528 { "btglb", rx_unimp, 0 },
529 { "call", rx_unimp, 1 },
530 { "einsf", rx_unimp, 2 },
531 { "fb", rx_unimp, 3 },
532 { "fbsym", rx_unimp, 4 },
533 { "id", rx_unimp, 5 },
534 { "initsct", rx_unimp, 6 },
535 { "insf", rx_unimp, 7 },
536 { "instr", rx_unimp, 8 },
537 { "lbba", rx_unimp, 9 },
538 { "len", rx_unimp, 10 },
539 { "optj", rx_unimp, 11 },
540 { "rvector", rx_unimp, 12 },
541 { "sb", rx_unimp, 13 },
542 { "sbbit", rx_unimp, 14 },
543 { "sbsym", rx_unimp, 15 },
544 { "sbsym16", rx_unimp, 16 },
545
546 /* These are the do-nothing pseudos. */
547 { "stk", rx_nop, 0 },
548 /* The manual documents ".stk" but the compiler emits ".stack". */
549 { "stack", rx_nop, 0 },
550
551 /* Theae are Renesas as100 assembler pseudo-ops that we do support. */
552 { "addr", rx_cons, 3 },
553 { "align", s_align_bytes, 2 },
554 { "byte", rx_cons, 1 },
555 { "fixed", float_cons, 'f' },
556 { "form", listing_psize, 0 },
557 { "glb", s_globl, 0 },
558 { "include", rx_include, 0 },
559 { "list", rx_list, 0 },
560 { "lword", rx_cons, 4 },
561 { "mrepeat", rx_rept, 0 },
562 { "section", rx_section, 0 },
563
564 /* FIXME: The following pseudo-ops place their values (and associated
565 label if present) in the data section, regardless of whatever
566 section we are currently in. At the moment this code does not
567 implement that part of the semantics. */
568 { "blka", s_space, 3 },
569 { "blkb", s_space, 1 },
570 { "blkd", s_space, 8 },
571 { "blkf", s_space, 4 },
572 { "blkl", s_space, 4 },
573 { "blkw", s_space, 2 },
574
575 /* Our "standard" pseudos. */
576 { "double", rx_float_cons, 0 },
577 { "bss", s_bss, 0 },
578 { "3byte", cons, 3 },
579 { "int", cons, 4 },
580 { "word", cons, 4 },
581
582 /* End of list marker. */
583 { NULL, NULL, 0 }
584 };
585
586 static asymbol * gp_symbol;
587
588 void
589 md_begin (void)
590 {
591 if (rx_use_small_data_limit)
592 /* Make the __gp symbol now rather
593 than after the symbol table is frozen. We only do this
594 when supporting small data limits because otherwise we
595 pollute the symbol table. */
596 gp_symbol = symbol_get_bfdsym (symbol_find_or_make ("__gp"));
597 }
598
599 char * rx_lex_start;
600 char * rx_lex_end;
601
602 typedef struct rx_bytesT
603 {
604 char base[4];
605 int n_base;
606 char ops[8];
607 int n_ops;
608 struct
609 {
610 expressionS exp;
611 char offset;
612 char nbits;
613 char type; /* RXREL_*. */
614 int reloc;
615 fixS * fixP;
616 } fixups[2];
617 int n_fixups;
618 struct
619 {
620 char type;
621 char field_pos;
622 char val_ofs;
623 } relax[2];
624 int n_relax;
625 int link_relax;
626 fixS *link_relax_fixP;
627 char times_grown;
628 char times_shrank;
629 } rx_bytesT;
630
631 static rx_bytesT rx_bytes;
632
633 void
634 rx_relax (int type, int pos)
635 {
636 rx_bytes.relax[rx_bytes.n_relax].type = type;
637 rx_bytes.relax[rx_bytes.n_relax].field_pos = pos;
638 rx_bytes.relax[rx_bytes.n_relax].val_ofs = rx_bytes.n_base + rx_bytes.n_ops;
639 rx_bytes.n_relax ++;
640 }
641
642 void
643 rx_linkrelax_dsp (int pos)
644 {
645 switch (pos)
646 {
647 case 4:
648 rx_bytes.link_relax |= RX_RELAXA_DSP4;
649 break;
650 case 6:
651 rx_bytes.link_relax |= RX_RELAXA_DSP6;
652 break;
653 case 14:
654 rx_bytes.link_relax |= RX_RELAXA_DSP14;
655 break;
656 }
657 }
658
659 void
660 rx_linkrelax_imm (int pos)
661 {
662 switch (pos)
663 {
664 case 6:
665 rx_bytes.link_relax |= RX_RELAXA_IMM6;
666 break;
667 case 12:
668 rx_bytes.link_relax |= RX_RELAXA_IMM12;
669 break;
670 }
671 }
672
673 void
674 rx_linkrelax_branch (void)
675 {
676 rx_bytes.link_relax |= RX_RELAXA_BRA;
677 }
678
679 static void
680 rx_fixup (expressionS exp, int offsetbits, int nbits, int type)
681 {
682 rx_bytes.fixups[rx_bytes.n_fixups].exp = exp;
683 rx_bytes.fixups[rx_bytes.n_fixups].offset = offsetbits;
684 rx_bytes.fixups[rx_bytes.n_fixups].nbits = nbits;
685 rx_bytes.fixups[rx_bytes.n_fixups].type = type;
686 rx_bytes.fixups[rx_bytes.n_fixups].reloc = exp.X_md;
687 rx_bytes.n_fixups ++;
688 }
689
690 #define rx_field_fixup(exp, offset, nbits, type) \
691 rx_fixup (exp, offset, nbits, type)
692
693 #define rx_op_fixup(exp, offset, nbits, type) \
694 rx_fixup (exp, offset + 8 * rx_bytes.n_base, nbits, type)
695
696 void
697 rx_base1 (int b1)
698 {
699 rx_bytes.base[0] = b1;
700 rx_bytes.n_base = 1;
701 }
702
703 void
704 rx_base2 (int b1, int b2)
705 {
706 rx_bytes.base[0] = b1;
707 rx_bytes.base[1] = b2;
708 rx_bytes.n_base = 2;
709 }
710
711 void
712 rx_base3 (int b1, int b2, int b3)
713 {
714 rx_bytes.base[0] = b1;
715 rx_bytes.base[1] = b2;
716 rx_bytes.base[2] = b3;
717 rx_bytes.n_base = 3;
718 }
719
720 void
721 rx_base4 (int b1, int b2, int b3, int b4)
722 {
723 rx_bytes.base[0] = b1;
724 rx_bytes.base[1] = b2;
725 rx_bytes.base[2] = b3;
726 rx_bytes.base[3] = b4;
727 rx_bytes.n_base = 4;
728 }
729
730 /* This gets complicated when the field spans bytes, because fields
731 are numbered from the MSB of the first byte as zero, and bits are
732 stored LSB towards the LSB of the byte. Thus, a simple four-bit
733 insertion of 12 at position 4 of 0x00 yields: 0x0b. A three-bit
734 insertion of b'MXL at position 7 is like this:
735
736 - - - - - - - - - - - - - - - -
737 M X L */
738
739 void
740 rx_field (int val, int pos, int sz)
741 {
742 int valm;
743 int bytep, bitp;
744
745 if (sz > 0)
746 {
747 if (val < 0 || val >= (1 << sz))
748 as_bad (_("Value %d doesn't fit in unsigned %d-bit field"), val, sz);
749 }
750 else
751 {
752 sz = - sz;
753 if (val < -(1 << (sz - 1)) || val >= (1 << (sz - 1)))
754 as_bad (_("Value %d doesn't fit in signed %d-bit field"), val, sz);
755 }
756
757 /* This code points at 'M' in the above example. */
758 bytep = pos / 8;
759 bitp = pos % 8;
760
761 while (bitp + sz > 8)
762 {
763 int ssz = 8 - bitp;
764 int svalm;
765
766 svalm = val >> (sz - ssz);
767 svalm = svalm & ((1 << ssz) - 1);
768 svalm = svalm << (8 - bitp - ssz);
769 gas_assert (bytep < rx_bytes.n_base);
770 rx_bytes.base[bytep] |= svalm;
771
772 bitp = 0;
773 sz -= ssz;
774 bytep ++;
775 }
776 valm = val & ((1 << sz) - 1);
777 valm = valm << (8 - bitp - sz);
778 gas_assert (bytep < rx_bytes.n_base);
779 rx_bytes.base[bytep] |= valm;
780 }
781
782 /* Special case of the above, for 3-bit displacements of 2..9. */
783
784 void
785 rx_disp3 (expressionS exp, int pos)
786 {
787 rx_field_fixup (exp, pos, 3, RXREL_PCREL);
788 }
789
790 /* Special case of the above, for split 5-bit displacements. Assumes
791 the displacement has been checked with rx_disp5op. */
792 /* ---- -432 1--- 0--- */
793
794 void
795 rx_field5s (expressionS exp)
796 {
797 int val;
798
799 val = exp.X_add_number;
800 rx_bytes.base[0] |= val >> 2;
801 rx_bytes.base[1] |= (val << 6) & 0x80;
802 rx_bytes.base[1] |= (val << 3) & 0x08;
803 }
804
805 /* ---- ---- 4--- 3210 */
806
807 void
808 rx_field5s2 (expressionS exp)
809 {
810 int val;
811
812 val = exp.X_add_number;
813 rx_bytes.base[1] |= (val << 3) & 0x80;
814 rx_bytes.base[1] |= (val ) & 0x0f;
815 }
816
817 #define OP(x) rx_bytes.ops[rx_bytes.n_ops++] = (x)
818
819 #define F_PRECISION 2
820
821 void
822 rx_op (expressionS exp, int nbytes, int type)
823 {
824 int v = 0;
825
826 if ((exp.X_op == O_constant || exp.X_op == O_big)
827 && type != RXREL_PCREL)
828 {
829 if (exp.X_op == O_big && exp.X_add_number <= 0)
830 {
831 LITTLENUM_TYPE w[2];
832 char * ip = rx_bytes.ops + rx_bytes.n_ops;
833
834 gen_to_words (w, F_PRECISION, 8);
835 #if RX_OPCODE_BIG_ENDIAN
836 ip[0] = w[0] >> 8;
837 ip[1] = w[0];
838 ip[2] = w[1] >> 8;
839 ip[3] = w[1];
840 #else
841 ip[3] = w[0] >> 8;
842 ip[2] = w[0];
843 ip[1] = w[1] >> 8;
844 ip[0] = w[1];
845 #endif
846 rx_bytes.n_ops += 4;
847 }
848 else
849 {
850 v = exp.X_add_number;
851 while (nbytes)
852 {
853 #if RX_OPCODE_BIG_ENDIAN
854 OP ((v >> (8 * (nbytes - 1))) & 0xff);
855 #else
856 OP (v & 0xff);
857 v >>= 8;
858 #endif
859 nbytes --;
860 }
861 }
862 }
863 else
864 {
865 rx_op_fixup (exp, rx_bytes.n_ops * 8, nbytes * 8, type);
866 memset (rx_bytes.ops + rx_bytes.n_ops, 0, nbytes);
867 rx_bytes.n_ops += nbytes;
868 }
869 }
870
871 int
872 rx_wrap (void)
873 {
874 return 0;
875 }
876
877 #define APPEND(B, N_B) \
878 if (rx_bytes.N_B) \
879 { \
880 memcpy (bytes + idx, rx_bytes.B, rx_bytes.N_B); \
881 idx += rx_bytes.N_B; \
882 }
883
884 void
885 rx_frag_init (fragS * fragP)
886 {
887 if (rx_bytes.n_relax || rx_bytes.link_relax)
888 {
889 fragP->tc_frag_data = malloc (sizeof (rx_bytesT));
890 memcpy (fragP->tc_frag_data, & rx_bytes, sizeof (rx_bytesT));
891 }
892 else
893 fragP->tc_frag_data = 0;
894 }
895
896 /* Handle the as100's version of the .equ pseudo-op. It has the syntax:
897 <symbol_name> .equ <expression> */
898
899 static void
900 rx_equ (char * name, char * expression)
901 {
902 char saved_name_end_char;
903 char * name_end;
904 char * saved_ilp;
905
906 while (ISSPACE (* name))
907 name ++;
908
909 for (name_end = name + 1; *name_end; name_end ++)
910 if (! ISALNUM (* name_end))
911 break;
912
913 saved_name_end_char = * name_end;
914 * name_end = 0;
915
916 saved_ilp = input_line_pointer;
917 input_line_pointer = expression;
918
919 equals (name, 1);
920
921 input_line_pointer = saved_ilp;
922 * name_end = saved_name_end_char;
923 }
924
925 /* Look for Renesas as100 pseudo-ops that occur after a symbol name
926 rather than at the start of a line. (eg .EQU or .DEFINE). If one
927 is found, process it and return TRUE otherwise return FALSE. */
928
929 static bfd_boolean
930 scan_for_infix_rx_pseudo_ops (char * str)
931 {
932 char * p;
933 char * pseudo_op;
934 char * dot = strchr (str, '.');
935
936 if (dot == NULL || dot == str)
937 return FALSE;
938
939 /* A real pseudo-op must be preceeded by whitespace. */
940 if (dot[-1] != ' ' && dot[-1] != '\t')
941 return FALSE;
942
943 pseudo_op = dot + 1;
944
945 if (!ISALNUM (* pseudo_op))
946 return FALSE;
947
948 for (p = pseudo_op + 1; ISALNUM (* p); p++)
949 ;
950
951 if (strncasecmp ("EQU", pseudo_op, p - pseudo_op) == 0)
952 rx_equ (str, p);
953 else if (strncasecmp ("DEFINE", pseudo_op, p - pseudo_op) == 0)
954 as_warn (_("The .DEFINE pseudo-op is not implemented"));
955 else if (strncasecmp ("MACRO", pseudo_op, p - pseudo_op) == 0)
956 as_warn (_("The .MACRO pseudo-op is not implemented"));
957 else if (strncasecmp ("BTEQU", pseudo_op, p - pseudo_op) == 0)
958 as_warn (_("The .BTEQU pseudo-op is not implemented."));
959 else
960 return FALSE;
961
962 return TRUE;
963 }
964
965 void
966 md_assemble (char * str)
967 {
968 char * bytes;
969 int idx = 0;
970 int i, rel;
971 fragS * frag_then = frag_now;
972 expressionS *exp;
973
974 memset (& rx_bytes, 0, sizeof (rx_bytes));
975
976 rx_lex_init (str, str + strlen (str));
977 if (scan_for_infix_rx_pseudo_ops (str))
978 return;
979 rx_parse ();
980
981 /* This simplifies the relaxation code. */
982 if (rx_bytes.n_relax || rx_bytes.link_relax)
983 {
984 /* We do it this way because we want the frag to have the
985 rx_bytes in it, which we initialize above. */
986 bytes = frag_more (12);
987 frag_then = frag_now;
988 frag_variant (rs_machine_dependent,
989 0 /* max_chars */,
990 0 /* var */,
991 0 /* subtype */,
992 0 /* symbol */,
993 0 /* offset */,
994 0 /* opcode */);
995 frag_then->fr_opcode = bytes;
996 frag_then->fr_fix += rx_bytes.n_base + rx_bytes.n_ops;
997 frag_then->fr_subtype = rx_bytes.n_base + rx_bytes.n_ops;
998 }
999 else
1000 {
1001 bytes = frag_more (rx_bytes.n_base + rx_bytes.n_ops);
1002 frag_then = frag_now;
1003 }
1004
1005 APPEND (base, n_base);
1006 APPEND (ops, n_ops);
1007
1008 if (rx_bytes.link_relax && rx_bytes.n_fixups)
1009 {
1010 fixS * f;
1011
1012 f = fix_new (frag_then,
1013 (char *) bytes - frag_then->fr_literal,
1014 0,
1015 abs_section_sym,
1016 rx_bytes.link_relax | rx_bytes.n_fixups,
1017 0,
1018 BFD_RELOC_RX_RELAX);
1019 frag_then->tc_frag_data->link_relax_fixP = f;
1020 }
1021
1022 for (i = 0; i < rx_bytes.n_fixups; i ++)
1023 {
1024 /* index: [nbytes][type] */
1025 static int reloc_map[5][4] =
1026 {
1027 { 0, 0, 0, BFD_RELOC_RX_DIR3U_PCREL },
1028 { BFD_RELOC_8, BFD_RELOC_RX_8U, BFD_RELOC_RX_NEG8, BFD_RELOC_8_PCREL },
1029 { BFD_RELOC_RX_16_OP, BFD_RELOC_RX_16U, BFD_RELOC_RX_NEG16, BFD_RELOC_16_PCREL },
1030 { BFD_RELOC_RX_24_OP, BFD_RELOC_RX_24U, BFD_RELOC_RX_NEG24, BFD_RELOC_24_PCREL },
1031 { BFD_RELOC_RX_32_OP, BFD_RELOC_32, BFD_RELOC_RX_NEG32, BFD_RELOC_32_PCREL },
1032 };
1033 fixS * f;
1034
1035 idx = rx_bytes.fixups[i].offset / 8;
1036 rel = reloc_map [rx_bytes.fixups[i].nbits / 8][(int) rx_bytes.fixups[i].type];
1037
1038 if (rx_bytes.fixups[i].reloc)
1039 rel = rx_bytes.fixups[i].reloc;
1040
1041 if (frag_then->tc_frag_data)
1042 exp = & frag_then->tc_frag_data->fixups[i].exp;
1043 else
1044 exp = & rx_bytes.fixups[i].exp;
1045
1046 f = fix_new_exp (frag_then,
1047 (char *) bytes + idx - frag_then->fr_literal,
1048 rx_bytes.fixups[i].nbits / 8,
1049 exp,
1050 rx_bytes.fixups[i].type == RXREL_PCREL ? 1 : 0,
1051 rel);
1052 if (frag_then->tc_frag_data)
1053 frag_then->tc_frag_data->fixups[i].fixP = f;
1054 }
1055
1056 dwarf2_emit_insn (idx);
1057 }
1058
1059 void
1060 rx_md_end (void)
1061 {
1062 }
1063
1064 /* Write a value out to the object file, using the appropriate endianness. */
1065
1066 void
1067 md_number_to_chars (char * buf, valueT val, int n)
1068 {
1069 if (target_big_endian)
1070 number_to_chars_bigendian (buf, val, n);
1071 else
1072 number_to_chars_littleendian (buf, val, n);
1073 }
1074
1075 static struct
1076 {
1077 char * fname;
1078 int reloc;
1079 }
1080 reloc_functions[] =
1081 {
1082 { "gp", BFD_RELOC_GPREL16 },
1083 { 0, 0 }
1084 };
1085
1086 void
1087 md_operand (expressionS * exp ATTRIBUTE_UNUSED)
1088 {
1089 int reloc = 0;
1090 int i;
1091
1092 for (i = 0; reloc_functions[i].fname; i++)
1093 {
1094 int flen = strlen (reloc_functions[i].fname);
1095
1096 if (input_line_pointer[0] == '%'
1097 && strncasecmp (input_line_pointer + 1, reloc_functions[i].fname, flen) == 0
1098 && input_line_pointer[flen + 1] == '(')
1099 {
1100 reloc = reloc_functions[i].reloc;
1101 input_line_pointer += flen + 2;
1102 break;
1103 }
1104 }
1105 if (reloc == 0)
1106 return;
1107
1108 expression (exp);
1109 if (* input_line_pointer == ')')
1110 input_line_pointer ++;
1111
1112 exp->X_md = reloc;
1113 }
1114
1115 valueT
1116 md_section_align (segT segment, valueT size)
1117 {
1118 int align = bfd_get_section_alignment (stdoutput, segment);
1119 return ((size + (1 << align) - 1) & (-1 << align));
1120 }
1121
1122 /* NOP - 1 cycle */
1123 static unsigned char nop_1[] = { 0x03};
1124 /* MOV.L R0,R0 - 1 cycle */
1125 static unsigned char nop_2[] = { 0xef, 0x00};
1126 /* MAX R0,R0 - 1 cycle */
1127 static unsigned char nop_3[] = { 0xfc, 0x13, 0x00 };
1128 /* MUL #1,R0 - 1 cycle */
1129 static unsigned char nop_4[] = { 0x76, 0x10, 0x01, 0x00 };
1130 /* MUL #1,R0 - 1 cycle */
1131 static unsigned char nop_5[] = { 0x77, 0x10, 0x01, 0x00, 0x00 };
1132 /* MUL #1,R0 - 1 cycle */
1133 static unsigned char nop_6[] = { 0x74, 0x10, 0x01, 0x00, 0x00, 0x00 };
1134 /* BRA.S .+7 - 1 cycle */
1135 static unsigned char nop_7[] = { 0x0F, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03 };
1136
1137 static unsigned char *nops[] = { NULL, nop_1, nop_2, nop_3, nop_4, nop_5, nop_6, nop_7 };
1138 #define BIGGEST_NOP 7
1139
1140 /* When relaxing, we need to output a reloc for any .align directive
1141 so that we can retain this alignment as we adjust opcode sizes. */
1142 void
1143 rx_handle_align (fragS * frag)
1144 {
1145 if ((frag->fr_type == rs_align
1146 || frag->fr_type == rs_align_code)
1147 && subseg_text_p (now_seg))
1148 {
1149 int count = (frag->fr_next->fr_address
1150 - frag->fr_address
1151 - frag->fr_fix);
1152 unsigned char *base = (unsigned char *)frag->fr_literal + frag->fr_fix;
1153
1154 if (count > BIGGEST_NOP)
1155 {
1156 base[0] = 0x2e;
1157 base[1] = count;
1158 frag->fr_var = 2;
1159 }
1160 else if (count > 0)
1161 {
1162 memcpy (base, nops[count], count);
1163 frag->fr_var = count;
1164 }
1165 }
1166
1167 if (linkrelax
1168 && (frag->fr_type == rs_align
1169 || frag->fr_type == rs_align_code)
1170 && frag->fr_address + frag->fr_fix > 0
1171 && frag->fr_offset > 0
1172 && now_seg != bss_section)
1173 {
1174 fix_new (frag, frag->fr_fix, 0,
1175 &abs_symbol, RX_RELAXA_ALIGN + frag->fr_offset,
1176 0, BFD_RELOC_RX_RELAX);
1177 /* For the purposes of relaxation, this relocation is attached
1178 to the byte *after* the alignment - i.e. the byte that must
1179 remain aligned. */
1180 fix_new (frag->fr_next, 0, 0,
1181 &abs_symbol, RX_RELAXA_ELIGN + frag->fr_offset,
1182 0, BFD_RELOC_RX_RELAX);
1183 }
1184 }
1185
1186 char *
1187 md_atof (int type, char * litP, int * sizeP)
1188 {
1189 return ieee_md_atof (type, litP, sizeP, target_big_endian);
1190 }
1191
1192 symbolS *
1193 md_undefined_symbol (char * name ATTRIBUTE_UNUSED)
1194 {
1195 return NULL;
1196 }
1197
1198 /*----------------------------------------------------------------------*/
1199 /* To recap: we estimate everything based on md_estimate_size, then
1200 adjust based on rx_relax_frag. When it all settles, we call
1201 md_convert frag to update the bytes. The relaxation types and
1202 relocations are in fragP->tc_frag_data, which is a copy of that
1203 rx_bytes.
1204
1205 Our scheme is as follows: fr_fix has the size of the smallest
1206 opcode (like BRA.S). We store the number of total bytes we need in
1207 fr_subtype. When we're done relaxing, we use fr_subtype and the
1208 existing opcode bytes to figure out what actual opcode we need to
1209 put in there. If the fixup isn't resolvable now, we use the
1210 maximal size. */
1211
1212 #define TRACE_RELAX 0
1213 #define tprintf if (TRACE_RELAX) printf
1214
1215 typedef enum
1216 {
1217 OT_other,
1218 OT_bra,
1219 OT_beq,
1220 OT_bne,
1221 OT_bsr,
1222 OT_bcc
1223 } op_type_T;
1224
1225 /* We're looking for these types of relaxations:
1226
1227 BRA.S 00001dsp
1228 BRA.B 00101110 dspppppp
1229 BRA.W 00111000 dspppppp pppppppp
1230 BRA.A 00000100 dspppppp pppppppp pppppppp
1231
1232 BEQ.S 00010dsp
1233 BEQ.B 00100000 dspppppp
1234 BEQ.W 00111010 dspppppp pppppppp
1235
1236 BNE.S 00011dsp
1237 BNE.B 00100001 dspppppp
1238 BNE.W 00111011 dspppppp pppppppp
1239
1240 BSR.W 00111001 dspppppp pppppppp
1241 BSR.A 00000101 dspppppp pppppppp pppppppp
1242
1243 Bcc.B 0010cond dspppppp
1244
1245 Additionally, we can synthesize longer conditional branches using
1246 pairs of opcodes, one with an inverted conditional (flip LSB):
1247
1248 Bcc.W 0010ncnd 00000110 00111000 dspppppp pppppppp
1249 Bcc.A 0010ncnd 00000111 00000100 dspppppp pppppppp pppppppp
1250 BEQ.A 00011100 00000100 dspppppp pppppppp pppppppp
1251 BNE.A 00010100 00000100 dspppppp pppppppp pppppppp */
1252
1253 /* Given the opcode bytes at OP, figure out which opcode it is and
1254 return the type of opcode. We use this to re-encode the opcode as
1255 a different size later. */
1256
1257 static op_type_T
1258 rx_opcode_type (char * op)
1259 {
1260 unsigned char b = (unsigned char) op[0];
1261
1262 switch (b & 0xf8)
1263 {
1264 case 0x08: return OT_bra;
1265 case 0x10: return OT_beq;
1266 case 0x18: return OT_bne;
1267 }
1268
1269 switch (b)
1270 {
1271 case 0x2e: return OT_bra;
1272 case 0x38: return OT_bra;
1273 case 0x04: return OT_bra;
1274
1275 case 0x20: return OT_beq;
1276 case 0x3a: return OT_beq;
1277
1278 case 0x21: return OT_bne;
1279 case 0x3b: return OT_bne;
1280
1281 case 0x39: return OT_bsr;
1282 case 0x05: return OT_bsr;
1283 }
1284
1285 if ((b & 0xf0) == 0x20)
1286 return OT_bcc;
1287
1288 return OT_other;
1289 }
1290
1291 /* Returns zero if *addrP has the target address. Else returns nonzero
1292 if we cannot compute the target address yet. */
1293
1294 static int
1295 rx_frag_fix_value (fragS * fragP,
1296 segT segment,
1297 int which,
1298 addressT * addrP,
1299 int need_diff,
1300 addressT * sym_addr)
1301 {
1302 addressT addr = 0;
1303 rx_bytesT * b = fragP->tc_frag_data;
1304 expressionS * exp = & b->fixups[which].exp;
1305
1306 if (need_diff && exp->X_op != O_subtract)
1307 return 1;
1308
1309 if (exp->X_add_symbol)
1310 {
1311 if (S_FORCE_RELOC (exp->X_add_symbol, 1))
1312 return 1;
1313 if (S_GET_SEGMENT (exp->X_add_symbol) != segment)
1314 return 1;
1315 addr += S_GET_VALUE (exp->X_add_symbol);
1316 }
1317
1318 if (exp->X_op_symbol)
1319 {
1320 if (exp->X_op != O_subtract)
1321 return 1;
1322 if (S_FORCE_RELOC (exp->X_op_symbol, 1))
1323 return 1;
1324 if (S_GET_SEGMENT (exp->X_op_symbol) != segment)
1325 return 1;
1326 addr -= S_GET_VALUE (exp->X_op_symbol);
1327 }
1328 if (sym_addr)
1329 * sym_addr = addr;
1330 addr += exp->X_add_number;
1331 * addrP = addr;
1332 return 0;
1333 }
1334
1335 /* Estimate how big the opcode is after this relax pass. The return
1336 value is the difference between fr_fix and the actual size. We
1337 compute the total size in rx_relax_frag and store it in fr_subtype,
1338 sowe only need to subtract fx_fix and return it. */
1339
1340 int
1341 md_estimate_size_before_relax (fragS * fragP ATTRIBUTE_UNUSED, segT segment ATTRIBUTE_UNUSED)
1342 {
1343 int opfixsize;
1344 int delta;
1345
1346 tprintf ("\033[32m est frag: addr %08lx fix %ld var %ld ofs %ld lit %p opc %p type %d sub %d\033[0m\n",
1347 (unsigned long) (fragP->fr_address
1348 + (fragP->fr_opcode - fragP->fr_literal)),
1349 (long) fragP->fr_fix, (long) fragP->fr_var, (long) fragP->fr_offset,
1350 fragP->fr_literal, fragP->fr_opcode, fragP->fr_type, fragP->fr_subtype);
1351
1352 /* This is the size of the opcode that's accounted for in fr_fix. */
1353 opfixsize = fragP->fr_fix - (fragP->fr_opcode - fragP->fr_literal);
1354 /* This is the size of the opcode that isn't. */
1355 delta = (fragP->fr_subtype - opfixsize);
1356
1357 tprintf (" -> opfixsize %d delta %d\n", opfixsize, delta);
1358 return delta;
1359 }
1360
1361 /* Given the new addresses for this relax pass, figure out how big
1362 each opcode must be. We store the total number of bytes needed in
1363 fr_subtype. The return value is the difference between the size
1364 after the last pass and the size after this pass, so we use the old
1365 fr_subtype to calculate the difference. */
1366
1367 int
1368 rx_relax_frag (segT segment ATTRIBUTE_UNUSED, fragS * fragP, long stretch)
1369 {
1370 addressT addr0, sym_addr;
1371 addressT mypc;
1372 int disp;
1373 int oldsize = fragP->fr_subtype;
1374 int newsize = oldsize;
1375 op_type_T optype;
1376 /* Index of relaxation we care about. */
1377 int ri;
1378
1379 tprintf ("\033[36mrelax frag: addr %08lx fix %ld var %ld ofs %ld lit %p opc %p type %d sub %d str %ld\033[0m\n",
1380 (unsigned long) (fragP->fr_address
1381 + (fragP->fr_opcode - fragP->fr_literal)),
1382 (long) fragP->fr_fix, (long) fragP->fr_var, (long) fragP->fr_offset,
1383 fragP->fr_literal, fragP->fr_opcode, fragP->fr_type, fragP->fr_subtype, stretch);
1384
1385 optype = rx_opcode_type (fragP->fr_opcode);
1386
1387 /* In the one case where we have both a disp and imm relaxation, we want
1388 the imm relaxation here. */
1389 ri = 0;
1390 if (fragP->tc_frag_data->n_relax > 1
1391 && fragP->tc_frag_data->relax[0].type == RX_RELAX_DISP)
1392 ri = 1;
1393
1394 /* Try to get the target address. */
1395 if (rx_frag_fix_value (fragP, segment, ri, & addr0,
1396 fragP->tc_frag_data->relax[ri].type != RX_RELAX_BRANCH,
1397 & sym_addr))
1398 {
1399 /* If we don't, we must use the maximum size for the linker.
1400 Note that we don't use synthetically expanded conditionals
1401 for this. */
1402 switch (fragP->tc_frag_data->relax[ri].type)
1403 {
1404 case RX_RELAX_BRANCH:
1405 switch (optype)
1406 {
1407 case OT_bra:
1408 case OT_bsr:
1409 newsize = 4;
1410 break;
1411 case OT_beq:
1412 case OT_bne:
1413 newsize = 3;
1414 break;
1415 case OT_bcc:
1416 newsize = 2;
1417 break;
1418 case OT_other:
1419 newsize = oldsize;
1420 break;
1421 }
1422 break;
1423
1424 case RX_RELAX_IMM:
1425 newsize = fragP->tc_frag_data->relax[ri].val_ofs + 4;
1426 break;
1427 }
1428 fragP->fr_subtype = newsize;
1429 tprintf (" -> new %d old %d delta %d (external)\n", newsize, oldsize, newsize-oldsize);
1430 return newsize - oldsize;
1431 }
1432
1433 mypc = fragP->fr_address + (fragP->fr_opcode - fragP->fr_literal);
1434 if (sym_addr > mypc)
1435 addr0 += stretch;
1436
1437 switch (fragP->tc_frag_data->relax[ri].type)
1438 {
1439 case RX_RELAX_BRANCH:
1440 tprintf ("branch, addr %08lx pc %08lx disp %ld\n",
1441 (unsigned long) addr0, (unsigned long) mypc,
1442 (long) (addr0 - mypc));
1443 disp = (int) addr0 - (int) mypc;
1444
1445 switch (optype)
1446 {
1447 case OT_bcc:
1448 if (disp >= -128 && (disp - (oldsize-2)) <= 127)
1449 /* bcc.b */
1450 newsize = 2;
1451 else if (disp >= -32768 && (disp - (oldsize-5)) <= 32767)
1452 /* bncc.b/bra.w */
1453 newsize = 5;
1454 else
1455 /* bncc.b/bra.a */
1456 newsize = 6;
1457 break;
1458
1459 case OT_beq:
1460 case OT_bne:
1461 if ((disp - (oldsize-1)) >= 3 && (disp - (oldsize-1)) <= 10 && !linkrelax)
1462 /* beq.s */
1463 newsize = 1;
1464 else if (disp >= -128 && (disp - (oldsize-2)) <= 127)
1465 /* beq.b */
1466 newsize = 2;
1467 else if (disp >= -32768 && (disp - (oldsize-3)) <= 32767)
1468 /* beq.w */
1469 newsize = 3;
1470 else
1471 /* bne.s/bra.a */
1472 newsize = 5;
1473 break;
1474
1475 case OT_bra:
1476 case OT_bsr:
1477 if ((disp - (oldsize-1)) >= 3 && (disp - (oldsize-1)) <= 10 && !linkrelax)
1478 /* bra.s */
1479 newsize = 1;
1480 else if (disp >= -128 && (disp - (oldsize-2)) <= 127)
1481 /* bra.b */
1482 newsize = 2;
1483 else if (disp >= -32768 && (disp - (oldsize-3)) <= 32767)
1484 /* bra.w */
1485 newsize = 3;
1486 else
1487 /* bra.a */
1488 newsize = 4;
1489 break;
1490
1491 case OT_other:
1492 break;
1493 }
1494 tprintf (" - newsize %d\n", newsize);
1495 break;
1496
1497 case RX_RELAX_IMM:
1498 tprintf ("other, addr %08lx pc %08lx LI %d OF %d\n",
1499 (unsigned long) addr0, (unsigned long) mypc,
1500 fragP->tc_frag_data->relax[ri].field_pos,
1501 fragP->tc_frag_data->relax[ri].val_ofs);
1502
1503 newsize = fragP->tc_frag_data->relax[ri].val_ofs;
1504
1505 if ((long) addr0 >= -128 && (long) addr0 <= 127)
1506 newsize += 1;
1507 else if ((long) addr0 >= -32768 && (long) addr0 <= 32767)
1508 newsize += 2;
1509 else if ((long) addr0 >= -8388608 && (long) addr0 <= 8388607)
1510 newsize += 3;
1511 else
1512 newsize += 4;
1513 break;
1514
1515 default:
1516 break;
1517 }
1518
1519 if (fragP->tc_frag_data->relax[ri].type == RX_RELAX_BRANCH)
1520 switch (optype)
1521 {
1522 case OT_bra:
1523 case OT_bcc:
1524 case OT_beq:
1525 case OT_bne:
1526 break;
1527 case OT_bsr:
1528 if (newsize < 3)
1529 newsize = 3;
1530 break;
1531 case OT_other:
1532 break;
1533 }
1534
1535 /* This prevents infinite loops in align-heavy sources. */
1536 if (newsize < oldsize)
1537 {
1538 if (fragP->tc_frag_data->times_shrank > 10
1539 && fragP->tc_frag_data->times_grown > 10)
1540 newsize = oldsize;
1541 if (fragP->tc_frag_data->times_shrank < 20)
1542 fragP->tc_frag_data->times_shrank ++;
1543 }
1544 else if (newsize > oldsize)
1545 {
1546 if (fragP->tc_frag_data->times_grown < 20)
1547 fragP->tc_frag_data->times_grown ++;
1548 }
1549
1550 fragP->fr_subtype = newsize;
1551 tprintf (" -> new %d old %d delta %d\n", newsize, oldsize, newsize-oldsize);
1552 return newsize - oldsize;
1553 }
1554
1555 /* This lets us test for the opcode type and the desired size in a
1556 switch statement. */
1557 #define OPCODE(type,size) ((type) * 16 + (size))
1558
1559 /* Given the opcode stored in fr_opcode and the number of bytes we
1560 think we need, encode a new opcode. We stored a pointer to the
1561 fixup for this opcode in the tc_frag_data structure. If we can do
1562 the fixup here, we change the relocation type to "none" (we test
1563 for that in tc_gen_reloc) else we change it to the right type for
1564 the new (biggest) opcode. */
1565
1566 void
1567 md_convert_frag (bfd * abfd ATTRIBUTE_UNUSED,
1568 segT segment ATTRIBUTE_UNUSED,
1569 fragS * fragP ATTRIBUTE_UNUSED)
1570 {
1571 rx_bytesT * rxb = fragP->tc_frag_data;
1572 addressT addr0, mypc;
1573 int disp;
1574 int reloc_type, reloc_adjust;
1575 char * op = fragP->fr_opcode;
1576 int keep_reloc = 0;
1577 int ri;
1578 int fi = (rxb->n_fixups > 1) ? 1 : 0;
1579 fixS * fix = rxb->fixups[fi].fixP;
1580
1581 tprintf ("\033[31mconvrt frag: addr %08lx fix %ld var %ld ofs %ld lit %p opc %p type %d sub %d\033[0m\n",
1582 (unsigned long) (fragP->fr_address
1583 + (fragP->fr_opcode - fragP->fr_literal)),
1584 (long) fragP->fr_fix, (long) fragP->fr_var, (long) fragP->fr_offset,
1585 fragP->fr_literal, fragP->fr_opcode, fragP->fr_type,
1586 fragP->fr_subtype);
1587
1588 #if TRACE_RELAX
1589 {
1590 int i;
1591
1592 printf ("lit %08x opc %08x", (int) fragP->fr_literal, (int) fragP->fr_opcode);
1593 for (i = 0; i < 10; i++)
1594 printf (" %02x", (unsigned char) (fragP->fr_opcode[i]));
1595 printf ("\n");
1596 }
1597 #endif
1598
1599 /* In the one case where we have both a disp and imm relaxation, we want
1600 the imm relaxation here. */
1601 ri = 0;
1602 if (fragP->tc_frag_data->n_relax > 1
1603 && fragP->tc_frag_data->relax[0].type == RX_RELAX_DISP)
1604 ri = 1;
1605
1606 /* Try to get the target address. If we fail here, we just use the
1607 largest format. */
1608 if (rx_frag_fix_value (fragP, segment, 0, & addr0,
1609 fragP->tc_frag_data->relax[ri].type != RX_RELAX_BRANCH, 0))
1610 keep_reloc = 1;
1611
1612 if (linkrelax)
1613 keep_reloc = 1;
1614
1615 /* We used a new frag for this opcode, so the opcode address should
1616 be the frag address. */
1617 mypc = fragP->fr_address + (fragP->fr_opcode - fragP->fr_literal);
1618 disp = (int) addr0 - (int) mypc;
1619
1620 reloc_type = BFD_RELOC_NONE;
1621 reloc_adjust = 0;
1622
1623 tprintf ("convert, op is %d, disp %d (%lx-%lx)\n",
1624 rx_opcode_type (fragP->fr_opcode), disp,
1625 (unsigned long) addr0, (unsigned long) mypc);
1626 switch (fragP->tc_frag_data->relax[ri].type)
1627 {
1628 case RX_RELAX_BRANCH:
1629 switch (OPCODE (rx_opcode_type (fragP->fr_opcode), fragP->fr_subtype))
1630 {
1631 case OPCODE (OT_bra, 1): /* BRA.S - no change. */
1632 op[0] = 0x08 + (disp & 7);
1633 break;
1634 case OPCODE (OT_bra, 2): /* BRA.B - 8 bit. */
1635 op[0] = 0x2e;
1636 op[1] = disp;
1637 reloc_type = keep_reloc ? BFD_RELOC_8_PCREL : BFD_RELOC_NONE;
1638 reloc_adjust = 1;
1639 break;
1640 case OPCODE (OT_bra, 3): /* BRA.W - 16 bit. */
1641 op[0] = 0x38;
1642 #if RX_OPCODE_BIG_ENDIAN
1643 op[1] = (disp >> 8) & 0xff;
1644 op[2] = disp;
1645 #else
1646 op[2] = (disp >> 8) & 0xff;
1647 op[1] = disp;
1648 #endif
1649 reloc_adjust = 1;
1650 reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE;
1651 break;
1652 case OPCODE (OT_bra, 4): /* BRA.A - 24 bit. */
1653 op[0] = 0x04;
1654 #if RX_OPCODE_BIG_ENDIAN
1655 op[1] = (disp >> 16) & 0xff;
1656 op[2] = (disp >> 8) & 0xff;
1657 op[3] = disp;
1658 #else
1659 op[3] = (disp >> 16) & 0xff;
1660 op[2] = (disp >> 8) & 0xff;
1661 op[1] = disp;
1662 #endif
1663 reloc_type = keep_reloc ? BFD_RELOC_24_PCREL : BFD_RELOC_NONE;
1664 reloc_adjust = 1;
1665 break;
1666
1667 case OPCODE (OT_beq, 1): /* BEQ.S - no change. */
1668 op[0] = 0x10 + (disp & 7);
1669 break;
1670 case OPCODE (OT_beq, 2): /* BEQ.B - 8 bit. */
1671 op[0] = 0x20;
1672 op[1] = disp;
1673 reloc_adjust = 1;
1674 reloc_type = keep_reloc ? BFD_RELOC_8_PCREL : BFD_RELOC_NONE;
1675 break;
1676 case OPCODE (OT_beq, 3): /* BEQ.W - 16 bit. */
1677 op[0] = 0x3a;
1678 #if RX_OPCODE_BIG_ENDIAN
1679 op[1] = (disp >> 8) & 0xff;
1680 op[2] = disp;
1681 #else
1682 op[2] = (disp >> 8) & 0xff;
1683 op[1] = disp;
1684 #endif
1685 reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE;
1686 reloc_adjust = 1;
1687 break;
1688 case OPCODE (OT_beq, 5): /* BEQ.A - synthetic. */
1689 op[0] = 0x1e; /* bne.s .+4. */
1690 op[1] = 0x04; /* bra.a dsp:24. */
1691 disp -= 1;
1692 #if RX_OPCODE_BIG_ENDIAN
1693 op[2] = (disp >> 16) & 0xff;
1694 op[3] = (disp >> 8) & 0xff;
1695 op[4] = disp;
1696 #else
1697 op[4] = (disp >> 16) & 0xff;
1698 op[3] = (disp >> 8) & 0xff;
1699 op[2] = disp;
1700 #endif
1701 reloc_type = keep_reloc ? BFD_RELOC_24_PCREL : BFD_RELOC_NONE;
1702 reloc_adjust = 2;
1703 break;
1704
1705 case OPCODE (OT_bne, 1): /* BNE.S - no change. */
1706 op[0] = 0x18 + (disp & 7);
1707 break;
1708 case OPCODE (OT_bne, 2): /* BNE.B - 8 bit. */
1709 op[0] = 0x21;
1710 op[1] = disp;
1711 reloc_adjust = 1;
1712 reloc_type = keep_reloc ? BFD_RELOC_8_PCREL : BFD_RELOC_NONE;
1713 break;
1714 case OPCODE (OT_bne, 3): /* BNE.W - 16 bit. */
1715 op[0] = 0x3b;
1716 #if RX_OPCODE_BIG_ENDIAN
1717 op[1] = (disp >> 8) & 0xff;
1718 op[2] = disp;
1719 #else
1720 op[2] = (disp >> 8) & 0xff;
1721 op[1] = disp;
1722 #endif
1723 reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE;
1724 reloc_adjust = 1;
1725 break;
1726 case OPCODE (OT_bne, 5): /* BNE.A - synthetic. */
1727 op[0] = 0x15; /* beq.s .+4. */
1728 op[1] = 0x04; /* bra.a dsp:24. */
1729 disp -= 1;
1730 #if RX_OPCODE_BIG_ENDIAN
1731 op[2] = (disp >> 16) & 0xff;
1732 op[3] = (disp >> 8) & 0xff;
1733 op[4] = disp;
1734 #else
1735 op[4] = (disp >> 16) & 0xff;
1736 op[3] = (disp >> 8) & 0xff;
1737 op[2] = disp;
1738 #endif
1739 reloc_type = keep_reloc ? BFD_RELOC_24_PCREL : BFD_RELOC_NONE;
1740 reloc_adjust = 2;
1741 break;
1742
1743 case OPCODE (OT_bsr, 3): /* BSR.W - 16 bit. */
1744 op[0] = 0x39;
1745 #if RX_OPCODE_BIG_ENDIAN
1746 op[1] = (disp >> 8) & 0xff;
1747 op[2] = disp;
1748 #else
1749 op[2] = (disp >> 8) & 0xff;
1750 op[1] = disp;
1751 #endif
1752 reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE;
1753 reloc_adjust = 0;
1754 break;
1755 case OPCODE (OT_bsr, 4): /* BSR.A - 24 bit. */
1756 op[0] = 0x05;
1757 #if RX_OPCODE_BIG_ENDIAN
1758 op[1] = (disp >> 16) & 0xff;
1759 op[2] = (disp >> 8) & 0xff;
1760 op[3] = disp;
1761 #else
1762 op[3] = (disp >> 16) & 0xff;
1763 op[2] = (disp >> 8) & 0xff;
1764 op[1] = disp;
1765 #endif
1766 reloc_type = keep_reloc ? BFD_RELOC_24_PCREL : BFD_RELOC_NONE;
1767 reloc_adjust = 0;
1768 break;
1769
1770 case OPCODE (OT_bcc, 2): /* Bcond.B - 8 bit. */
1771 op[1] = disp;
1772 reloc_type = keep_reloc ? BFD_RELOC_8_PCREL : BFD_RELOC_NONE;
1773 break;
1774 case OPCODE (OT_bcc, 5): /* Bcond.W - synthetic. */
1775 op[0] ^= 1; /* Invert condition. */
1776 op[1] = 5; /* Displacement. */
1777 op[2] = 0x38;
1778 disp -= 2;
1779 #if RX_OPCODE_BIG_ENDIAN
1780 op[3] = (disp >> 8) & 0xff;
1781 op[4] = disp;
1782 #else
1783 op[4] = (disp >> 8) & 0xff;
1784 op[3] = disp;
1785 #endif
1786 reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE;
1787 reloc_adjust = 2;
1788 break;
1789 case OPCODE (OT_bcc, 6): /* Bcond.S - synthetic. */
1790 op[0] ^= 1; /* Invert condition. */
1791 op[1] = 6; /* Displacement. */
1792 op[2] = 0x04;
1793 disp -= 2;
1794 #if RX_OPCODE_BIG_ENDIAN
1795 op[3] = (disp >> 16) & 0xff;
1796 op[4] = (disp >> 8) & 0xff;
1797 op[5] = disp;
1798 #else
1799 op[5] = (disp >> 16) & 0xff;
1800 op[4] = (disp >> 8) & 0xff;
1801 op[3] = disp;
1802 #endif
1803 reloc_type = keep_reloc ? BFD_RELOC_24_PCREL : BFD_RELOC_NONE;
1804 reloc_adjust = 2;
1805 break;
1806
1807 default:
1808 /* These are opcodes we'll relax in th linker, later. */
1809 if (rxb->n_fixups)
1810 reloc_type = rxb->fixups[ri].fixP->fx_r_type;
1811 break;
1812 }
1813 break;
1814
1815 case RX_RELAX_IMM:
1816 {
1817 int nbytes = fragP->fr_subtype - fragP->tc_frag_data->relax[ri].val_ofs;
1818 int li;
1819 char * imm = op + fragP->tc_frag_data->relax[ri].val_ofs;
1820
1821 switch (nbytes)
1822 {
1823 case 1:
1824 li = 1;
1825 imm[0] = addr0;
1826 reloc_type = BFD_RELOC_8;
1827 break;
1828 case 2:
1829 li = 2;
1830 #if RX_OPCODE_BIG_ENDIAN
1831 imm[1] = addr0;
1832 imm[0] = addr0 >> 8;
1833 #else
1834 imm[0] = addr0;
1835 imm[1] = addr0 >> 8;
1836 #endif
1837 reloc_type = BFD_RELOC_RX_16_OP;
1838 break;
1839 case 3:
1840 li = 3;
1841 #if RX_OPCODE_BIG_ENDIAN
1842 imm[2] = addr0;
1843 imm[1] = addr0 >> 8;
1844 imm[0] = addr0 >> 16;
1845 #else
1846 imm[0] = addr0;
1847 imm[1] = addr0 >> 8;
1848 imm[2] = addr0 >> 16;
1849 #endif
1850 reloc_type = BFD_RELOC_RX_24_OP;
1851 break;
1852 case 4:
1853 li = 0;
1854 #if RX_OPCODE_BIG_ENDIAN
1855 imm[3] = addr0;
1856 imm[2] = addr0 >> 8;
1857 imm[1] = addr0 >> 16;
1858 imm[0] = addr0 >> 24;
1859 #else
1860 imm[0] = addr0;
1861 imm[1] = addr0 >> 8;
1862 imm[2] = addr0 >> 16;
1863 imm[3] = addr0 >> 24;
1864 #endif
1865 reloc_type = BFD_RELOC_RX_32_OP;
1866 break;
1867 default:
1868 as_bad (_("invalid immediate size"));
1869 li = -1;
1870 }
1871
1872 switch (fragP->tc_frag_data->relax[ri].field_pos)
1873 {
1874 case 6:
1875 op[0] &= 0xfc;
1876 op[0] |= li;
1877 break;
1878 case 12:
1879 op[1] &= 0xf3;
1880 op[1] |= li << 2;
1881 break;
1882 case 20:
1883 op[2] &= 0xf3;
1884 op[2] |= li << 2;
1885 break;
1886 default:
1887 as_bad (_("invalid immediate field position"));
1888 }
1889 }
1890 break;
1891
1892 default:
1893 if (rxb->n_fixups)
1894 {
1895 reloc_type = fix->fx_r_type;
1896 reloc_adjust = 0;
1897 }
1898 break;
1899 }
1900
1901 if (rxb->n_fixups)
1902 {
1903
1904 fix->fx_r_type = reloc_type;
1905 fix->fx_where += reloc_adjust;
1906 switch (reloc_type)
1907 {
1908 case BFD_RELOC_NONE:
1909 fix->fx_size = 0;
1910 break;
1911 case BFD_RELOC_8:
1912 fix->fx_size = 1;
1913 break;
1914 case BFD_RELOC_16_PCREL:
1915 case BFD_RELOC_RX_16_OP:
1916 fix->fx_size = 2;
1917 break;
1918 case BFD_RELOC_24_PCREL:
1919 case BFD_RELOC_RX_24_OP:
1920 fix->fx_size = 3;
1921 break;
1922 case BFD_RELOC_RX_32_OP:
1923 fix->fx_size = 4;
1924 break;
1925 }
1926 }
1927
1928 fragP->fr_fix = fragP->fr_subtype + (fragP->fr_opcode - fragP->fr_literal);
1929 tprintf ("fragP->fr_fix now %ld (%d + (%p - %p)\n", (long) fragP->fr_fix,
1930 fragP->fr_subtype, fragP->fr_opcode, fragP->fr_literal);
1931 fragP->fr_var = 0;
1932
1933 if (fragP->fr_next != NULL
1934 && ((offsetT) (fragP->fr_next->fr_address - fragP->fr_address)
1935 != fragP->fr_fix))
1936 as_bad (_("bad frag at %p : fix %ld addr %ld %ld \n"), fragP,
1937 (long) fragP->fr_fix,
1938 (long) fragP->fr_address, (long) fragP->fr_next->fr_address);
1939 }
1940
1941 #undef OPCODE
1942 \f
1943 int
1944 rx_validate_fix_sub (struct fix * f)
1945 {
1946 /* We permit the subtraction of two symbols in a few cases. */
1947 /* mov #sym1-sym2, R3 */
1948 if (f->fx_r_type == BFD_RELOC_RX_32_OP)
1949 return 1;
1950 /* .long sym1-sym2 */
1951 if (f->fx_r_type == BFD_RELOC_RX_DIFF
1952 && ! f->fx_pcrel
1953 && (f->fx_size == 4 || f->fx_size == 2 || f->fx_size == 1))
1954 return 1;
1955 return 0;
1956 }
1957
1958 long
1959 md_pcrel_from_section (fixS * fixP, segT sec)
1960 {
1961 long rv;
1962
1963 if (fixP->fx_addsy != NULL
1964 && (! S_IS_DEFINED (fixP->fx_addsy)
1965 || S_GET_SEGMENT (fixP->fx_addsy) != sec))
1966 /* The symbol is undefined (or is defined but not in this section).
1967 Let the linker figure it out. */
1968 return 0;
1969
1970 rv = fixP->fx_frag->fr_address + fixP->fx_where;
1971 switch (fixP->fx_r_type)
1972 {
1973 case BFD_RELOC_RX_DIR3U_PCREL:
1974 return rv;
1975 default:
1976 return rv - 1;
1977 }
1978 }
1979
1980 void
1981 rx_cons_fix_new (fragS * frag,
1982 int where,
1983 int size,
1984 expressionS * exp)
1985 {
1986 bfd_reloc_code_real_type type;
1987
1988 switch (size)
1989 {
1990 case 1:
1991 type = BFD_RELOC_8;
1992 break;
1993 case 2:
1994 type = BFD_RELOC_16;
1995 break;
1996 case 3:
1997 type = BFD_RELOC_24;
1998 break;
1999 case 4:
2000 type = BFD_RELOC_32;
2001 break;
2002 default:
2003 as_bad (_("unsupported constant size %d\n"), size);
2004 return;
2005 }
2006
2007 if (exp->X_op == O_subtract && exp->X_op_symbol)
2008 {
2009 if (size != 4 && size != 2 && size != 1)
2010 as_bad (_("difference of two symbols only supported with .long, .short, or .byte"));
2011 else
2012 type = BFD_RELOC_RX_DIFF;
2013 }
2014
2015 fix_new_exp (frag, where, (int) size, exp, 0, type);
2016 }
2017
2018 void
2019 md_apply_fix (struct fix * f ATTRIBUTE_UNUSED,
2020 valueT * t ATTRIBUTE_UNUSED,
2021 segT s ATTRIBUTE_UNUSED)
2022 {
2023 /* Instruction bytes are always little endian. */
2024 char * op;
2025 unsigned long val;
2026
2027 if (f->fx_addsy && S_FORCE_RELOC (f->fx_addsy, 1))
2028 return;
2029 if (f->fx_subsy && S_FORCE_RELOC (f->fx_subsy, 1))
2030 return;
2031
2032 #define OP2(x) op[target_big_endian ? 1-x : x]
2033 #define OP3(x) op[target_big_endian ? 2-x : x]
2034 #define OP4(x) op[target_big_endian ? 3-x : x]
2035
2036 op = f->fx_frag->fr_literal + f->fx_where;
2037 val = (unsigned long) * t;
2038
2039 /* Opcode words are always the same endian. Data words are either
2040 big or little endian. */
2041
2042 switch (f->fx_r_type)
2043 {
2044 case BFD_RELOC_NONE:
2045 break;
2046
2047 case BFD_RELOC_RX_RELAX:
2048 f->fx_done = 1;
2049 break;
2050
2051 case BFD_RELOC_RX_DIR3U_PCREL:
2052 if (val < 3 || val > 10)
2053 as_bad_where (f->fx_file, f->fx_line,
2054 _("jump not 3..10 bytes away (is %d)"), (int) val);
2055 op[0] &= 0xf8;
2056 op[0] |= val & 0x07;
2057 break;
2058
2059 case BFD_RELOC_8:
2060 case BFD_RELOC_8_PCREL:
2061 case BFD_RELOC_RX_8U:
2062 op[0] = val;
2063 break;
2064
2065 case BFD_RELOC_16:
2066 OP2(1) = val & 0xff;
2067 OP2(0) = (val >> 8) & 0xff;
2068 break;
2069
2070 case BFD_RELOC_16_PCREL:
2071 case BFD_RELOC_RX_16_OP:
2072 case BFD_RELOC_RX_16U:
2073 #if RX_OPCODE_BIG_ENDIAN
2074 op[1] = val & 0xff;
2075 op[0] = (val >> 8) & 0xff;
2076 #else
2077 op[0] = val & 0xff;
2078 op[1] = (val >> 8) & 0xff;
2079 #endif
2080 break;
2081
2082 case BFD_RELOC_24:
2083 OP3(0) = val & 0xff;
2084 OP3(1) = (val >> 8) & 0xff;
2085 OP3(2) = (val >> 16) & 0xff;
2086 break;
2087
2088 case BFD_RELOC_24_PCREL:
2089 case BFD_RELOC_RX_24_OP:
2090 case BFD_RELOC_RX_24U:
2091 #if RX_OPCODE_BIG_ENDIAN
2092 op[2] = val & 0xff;
2093 op[1] = (val >> 8) & 0xff;
2094 op[0] = (val >> 16) & 0xff;
2095 #else
2096 op[0] = val & 0xff;
2097 op[1] = (val >> 8) & 0xff;
2098 op[2] = (val >> 16) & 0xff;
2099 #endif
2100 break;
2101
2102 case BFD_RELOC_RX_DIFF:
2103 switch (f->fx_size)
2104 {
2105 case 1:
2106 op[0] = val & 0xff;
2107 break;
2108 case 2:
2109 OP2(0) = val & 0xff;
2110 OP2(1) = (val >> 8) & 0xff;
2111 break;
2112 case 4:
2113 OP4(0) = val & 0xff;
2114 OP4(1) = (val >> 8) & 0xff;
2115 OP4(2) = (val >> 16) & 0xff;
2116 OP4(3) = (val >> 24) & 0xff;
2117 break;
2118 }
2119 break;
2120
2121 case BFD_RELOC_32:
2122 OP4(0) = val & 0xff;
2123 OP4(1) = (val >> 8) & 0xff;
2124 OP4(2) = (val >> 16) & 0xff;
2125 OP4(3) = (val >> 24) & 0xff;
2126 break;
2127
2128 case BFD_RELOC_RX_32_OP:
2129 #if RX_OPCODE_BIG_ENDIAN
2130 op[3] = val & 0xff;
2131 op[2] = (val >> 8) & 0xff;
2132 op[1] = (val >> 16) & 0xff;
2133 op[0] = (val >> 24) & 0xff;
2134 #else
2135 op[0] = val & 0xff;
2136 op[1] = (val >> 8) & 0xff;
2137 op[2] = (val >> 16) & 0xff;
2138 op[3] = (val >> 24) & 0xff;
2139 #endif
2140 break;
2141
2142 case BFD_RELOC_RX_NEG8:
2143 op[0] = - val;
2144 break;
2145
2146 case BFD_RELOC_RX_NEG16:
2147 val = -val;
2148 #if RX_OPCODE_BIG_ENDIAN
2149 op[1] = val & 0xff;
2150 op[0] = (val >> 8) & 0xff;
2151 #else
2152 op[0] = val & 0xff;
2153 op[1] = (val >> 8) & 0xff;
2154 #endif
2155 break;
2156
2157 case BFD_RELOC_RX_NEG24:
2158 val = -val;
2159 #if RX_OPCODE_BIG_ENDIAN
2160 op[2] = val & 0xff;
2161 op[1] = (val >> 8) & 0xff;
2162 op[0] = (val >> 16) & 0xff;
2163 #else
2164 op[0] = val & 0xff;
2165 op[1] = (val >> 8) & 0xff;
2166 op[2] = (val >> 16) & 0xff;
2167 #endif
2168 break;
2169
2170 case BFD_RELOC_RX_NEG32:
2171 val = -val;
2172 #if RX_OPCODE_BIG_ENDIAN
2173 op[3] = val & 0xff;
2174 op[2] = (val >> 8) & 0xff;
2175 op[1] = (val >> 16) & 0xff;
2176 op[0] = (val >> 24) & 0xff;
2177 #else
2178 op[0] = val & 0xff;
2179 op[1] = (val >> 8) & 0xff;
2180 op[2] = (val >> 16) & 0xff;
2181 op[3] = (val >> 24) & 0xff;
2182 #endif
2183 break;
2184
2185 case BFD_RELOC_RX_GPRELL:
2186 val >>= 1;
2187 case BFD_RELOC_RX_GPRELW:
2188 val >>= 1;
2189 case BFD_RELOC_RX_GPRELB:
2190 #if RX_OPCODE_BIG_ENDIAN
2191 op[1] = val & 0xff;
2192 op[0] = (val >> 8) & 0xff;
2193 #else
2194 op[0] = val & 0xff;
2195 op[1] = (val >> 8) & 0xff;
2196 #endif
2197 break;
2198
2199 default:
2200 as_bad (_("Unknown reloc in md_apply_fix: %s"),
2201 bfd_get_reloc_code_name (f->fx_r_type));
2202 break;
2203 }
2204
2205 if (f->fx_addsy == NULL)
2206 f->fx_done = 1;
2207 }
2208
2209 arelent **
2210 tc_gen_reloc (asection * seg ATTRIBUTE_UNUSED, fixS * fixp)
2211 {
2212 static arelent * reloc[5];
2213 int is_opcode = 0;
2214
2215 if (fixp->fx_r_type == BFD_RELOC_NONE)
2216 {
2217 reloc[0] = NULL;
2218 return reloc;
2219 }
2220
2221 if (fixp->fx_subsy
2222 && S_GET_SEGMENT (fixp->fx_subsy) == absolute_section)
2223 {
2224 fixp->fx_offset -= S_GET_VALUE (fixp->fx_subsy);
2225 fixp->fx_subsy = NULL;
2226 }
2227
2228 reloc[0] = (arelent *) xmalloc (sizeof (arelent));
2229 reloc[0]->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
2230 * reloc[0]->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
2231 reloc[0]->address = fixp->fx_frag->fr_address + fixp->fx_where;
2232 reloc[0]->addend = fixp->fx_offset;
2233
2234 if (fixp->fx_r_type == BFD_RELOC_RX_32_OP
2235 && fixp->fx_subsy)
2236 {
2237 fixp->fx_r_type = BFD_RELOC_RX_DIFF;
2238 is_opcode = 1;
2239 }
2240
2241 /* Certain BFD relocations cannot be translated directly into
2242 a single (non-Red Hat) RX relocation, but instead need
2243 multiple RX relocations - handle them here. */
2244 switch (fixp->fx_r_type)
2245 {
2246 case BFD_RELOC_RX_DIFF:
2247 reloc[0]->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_SYM);
2248
2249 reloc[1] = (arelent *) xmalloc (sizeof (arelent));
2250 reloc[1]->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
2251 * reloc[1]->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_subsy);
2252 reloc[1]->address = fixp->fx_frag->fr_address + fixp->fx_where;
2253 reloc[1]->addend = 0;
2254 reloc[1]->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_SYM);
2255
2256 reloc[2] = (arelent *) xmalloc (sizeof (arelent));
2257 reloc[2]->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_OP_SUBTRACT);
2258 reloc[2]->addend = 0;
2259 reloc[2]->sym_ptr_ptr = reloc[1]->sym_ptr_ptr;
2260 reloc[2]->address = fixp->fx_frag->fr_address + fixp->fx_where;
2261
2262 reloc[3] = (arelent *) xmalloc (sizeof (arelent));
2263 switch (fixp->fx_size)
2264 {
2265 case 1:
2266 reloc[3]->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_ABS8);
2267 break;
2268 case 2:
2269 if (!is_opcode && target_big_endian)
2270 reloc[3]->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_ABS16_REV);
2271 else
2272 reloc[3]->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_ABS16);
2273 break;
2274 case 4:
2275 if (!is_opcode && target_big_endian)
2276 reloc[3]->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_ABS32_REV);
2277 else
2278 reloc[3]->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_ABS32);
2279 break;
2280 }
2281 reloc[3]->addend = 0;
2282 reloc[3]->sym_ptr_ptr = reloc[1]->sym_ptr_ptr;
2283 reloc[3]->address = fixp->fx_frag->fr_address + fixp->fx_where;
2284
2285 reloc[4] = NULL;
2286 break;
2287
2288 case BFD_RELOC_RX_GPRELL:
2289 reloc[0]->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_SYM);
2290
2291 reloc[1] = (arelent *) xmalloc (sizeof (arelent));
2292 reloc[1]->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
2293 if (gp_symbol == NULL)
2294 {
2295 if (symbol_table_frozen)
2296 {
2297 symbolS * gp;
2298
2299 gp = symbol_find ("__gp");
2300 if (gp == NULL)
2301 as_bad (("unable to create __gp symbol: please re-assemble with the -msmall-data-limit option specified"));
2302 else
2303 gp_symbol = symbol_get_bfdsym (gp);
2304 }
2305 else
2306 gp_symbol = symbol_get_bfdsym (symbol_find_or_make ("__gp"));
2307 }
2308 * reloc[1]->sym_ptr_ptr = gp_symbol;
2309 reloc[1]->address = fixp->fx_frag->fr_address + fixp->fx_where;
2310 reloc[1]->addend = 0;
2311 reloc[1]->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_SYM);
2312
2313 reloc[2] = (arelent *) xmalloc (sizeof (arelent));
2314 reloc[2]->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_OP_SUBTRACT);
2315 reloc[2]->addend = 0;
2316 reloc[2]->sym_ptr_ptr = reloc[1]->sym_ptr_ptr;
2317 reloc[2]->address = fixp->fx_frag->fr_address + fixp->fx_where;
2318
2319 reloc[3] = (arelent *) xmalloc (sizeof (arelent));
2320 reloc[3]->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_ABS16UL);
2321 reloc[3]->addend = 0;
2322 reloc[3]->sym_ptr_ptr = reloc[1]->sym_ptr_ptr;
2323 reloc[3]->address = fixp->fx_frag->fr_address + fixp->fx_where;
2324
2325 reloc[4] = NULL;
2326 break;
2327
2328 case BFD_RELOC_RX_GPRELW:
2329 reloc[0]->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_SYM);
2330
2331 reloc[1] = (arelent *) xmalloc (sizeof (arelent));
2332 reloc[1]->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
2333 if (gp_symbol == NULL)
2334 {
2335 if (symbol_table_frozen)
2336 {
2337 symbolS * gp;
2338
2339 gp = symbol_find ("__gp");
2340 if (gp == NULL)
2341 as_bad (("unable to create __gp symbol: please re-assemble with the -msmall-data-limit option specified"));
2342 else
2343 gp_symbol = symbol_get_bfdsym (gp);
2344 }
2345 else
2346 gp_symbol = symbol_get_bfdsym (symbol_find_or_make ("__gp"));
2347 }
2348 * reloc[1]->sym_ptr_ptr = gp_symbol;
2349 reloc[1]->address = fixp->fx_frag->fr_address + fixp->fx_where;
2350 reloc[1]->addend = 0;
2351 reloc[1]->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_SYM);
2352
2353 reloc[2] = (arelent *) xmalloc (sizeof (arelent));
2354 reloc[2]->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_OP_SUBTRACT);
2355 reloc[2]->addend = 0;
2356 reloc[2]->sym_ptr_ptr = reloc[1]->sym_ptr_ptr;
2357 reloc[2]->address = fixp->fx_frag->fr_address + fixp->fx_where;
2358
2359 reloc[3] = (arelent *) xmalloc (sizeof (arelent));
2360 reloc[3]->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_ABS16UW);
2361 reloc[3]->addend = 0;
2362 reloc[3]->sym_ptr_ptr = reloc[1]->sym_ptr_ptr;
2363 reloc[3]->address = fixp->fx_frag->fr_address + fixp->fx_where;
2364
2365 reloc[4] = NULL;
2366 break;
2367
2368 case BFD_RELOC_RX_GPRELB:
2369 reloc[0]->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_SYM);
2370
2371 reloc[1] = (arelent *) xmalloc (sizeof (arelent));
2372 reloc[1]->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
2373 if (gp_symbol == NULL)
2374 {
2375 if (symbol_table_frozen)
2376 {
2377 symbolS * gp;
2378
2379 gp = symbol_find ("__gp");
2380 if (gp == NULL)
2381 as_bad (("unable to create __gp symbol: please re-assemble with the -msmall-data-limit option specified"));
2382 else
2383 gp_symbol = symbol_get_bfdsym (gp);
2384 }
2385 else
2386 gp_symbol = symbol_get_bfdsym (symbol_find_or_make ("__gp"));
2387 }
2388 * reloc[1]->sym_ptr_ptr = gp_symbol;
2389 reloc[1]->address = fixp->fx_frag->fr_address + fixp->fx_where;
2390 reloc[1]->addend = 0;
2391 reloc[1]->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_SYM);
2392
2393 reloc[2] = (arelent *) xmalloc (sizeof (arelent));
2394 reloc[2]->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_OP_SUBTRACT);
2395 reloc[2]->addend = 0;
2396 reloc[2]->sym_ptr_ptr = reloc[1]->sym_ptr_ptr;
2397 reloc[2]->address = fixp->fx_frag->fr_address + fixp->fx_where;
2398
2399 reloc[3] = (arelent *) xmalloc (sizeof (arelent));
2400 reloc[3]->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_ABS16U);
2401 reloc[3]->addend = 0;
2402 reloc[3]->sym_ptr_ptr = reloc[1]->sym_ptr_ptr;
2403 reloc[3]->address = fixp->fx_frag->fr_address + fixp->fx_where;
2404
2405 reloc[4] = NULL;
2406 break;
2407
2408 case BFD_RELOC_RX_NEG32:
2409 reloc[0]->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_SYM);
2410
2411 reloc[1] = (arelent *) xmalloc (sizeof (arelent));
2412 reloc[1]->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_OP_NEG);
2413 reloc[1]->addend = 0;
2414 reloc[1]->sym_ptr_ptr = reloc[0]->sym_ptr_ptr;
2415 reloc[1]->address = fixp->fx_frag->fr_address + fixp->fx_where;
2416
2417 reloc[2] = (arelent *) xmalloc (sizeof (arelent));
2418 reloc[2]->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_ABS32);
2419 reloc[2]->addend = 0;
2420 reloc[2]->sym_ptr_ptr = reloc[0]->sym_ptr_ptr;
2421 reloc[2]->address = fixp->fx_frag->fr_address + fixp->fx_where;
2422
2423 reloc[3] = NULL;
2424 break;
2425
2426 default:
2427 reloc[0]->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
2428 reloc[1] = NULL;
2429 break;
2430 }
2431
2432 return reloc;
2433 }
2434
2435 /* Set the ELF specific flags. */
2436
2437 void
2438 rx_elf_final_processing (void)
2439 {
2440 elf_elfheader (stdoutput)->e_flags |= elf_flags;
2441 }
2442
2443 /* Scan the current input line for occurances of Renesas
2444 local labels and replace them with the GAS version. */
2445
2446 void
2447 rx_start_line (void)
2448 {
2449 int in_double_quote = 0;
2450 int in_single_quote = 0;
2451 int done = 0;
2452 char * p = input_line_pointer;
2453
2454 /* Scan the line looking for question marks. Skip past quote enclosed regions. */
2455 do
2456 {
2457 switch (*p)
2458 {
2459 case '\n':
2460 case 0:
2461 done = 1;
2462 break;
2463
2464 case '"':
2465 in_double_quote = ! in_double_quote;
2466 break;
2467
2468 case '\'':
2469 in_single_quote = ! in_single_quote;
2470 break;
2471
2472 case '?':
2473 if (in_double_quote || in_single_quote)
2474 break;
2475
2476 if (p[1] == ':')
2477 *p = '1';
2478 else if (p[1] == '+')
2479 {
2480 p[0] = '1';
2481 p[1] = 'f';
2482 }
2483 else if (p[1] == '-')
2484 {
2485 p[0] = '1';
2486 p[1] = 'b';
2487 }
2488 break;
2489
2490 default:
2491 break;
2492 }
2493
2494 p ++;
2495 }
2496 while (! done);
2497 }
git-cvsimport of binutils cvsroot