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