is_end_of_line fixes.
[deliverable/binutils-gdb.git] / gas / config / tc-mcore.c
1 /* tc-mcore.c -- Assemble code for M*Core
2 Copyright (C) 1999, 2000 Free Software Foundation.
3
4 This file is part of GAS, the GNU Assembler.
5
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
9 any later version.
10
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to the Free
18 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
19 02111-1307, USA. */
20
21 #include <stdio.h>
22 #include "as.h"
23 #include "bfd.h"
24 #include "subsegs.h"
25 #define DEFINE_TABLE
26 #include "../opcodes/mcore-opc.h"
27 #include <ctype.h>
28 #include <string.h>
29
30 #ifdef OBJ_ELF
31 #include "elf/mcore.h"
32 #endif
33
34 #ifndef streq
35 #define streq(a,b) (strcmp (a, b) == 0)
36 #endif
37
38 /* Forward declarations for dumb compilers. */
39 static void mcore_s_literals PARAMS ((int));
40 static void mcore_cons PARAMS ((int));
41 static void mcore_float_cons PARAMS ((int));
42 static void mcore_stringer PARAMS ((int));
43 static void mcore_fill PARAMS ((int));
44 static int log2 PARAMS ((unsigned int));
45 static char * parse_reg PARAMS ((char *, unsigned *));
46 static char * parse_creg PARAMS ((char *, unsigned *));
47 static char * parse_exp PARAMS ((char *, expressionS *));
48 static char * parse_rt PARAMS ((char *, char **, int, expressionS *));
49 static char * parse_imm PARAMS ((char *, unsigned *, unsigned, unsigned));
50 static char * parse_mem PARAMS ((char *, unsigned *, unsigned *, unsigned));
51 static char * parse_psrmod PARAMS ((char *, unsigned *));
52 static void make_name PARAMS ((char *, char *, int));
53 static int enter_literal PARAMS ((expressionS *, int));
54 static void dump_literals PARAMS ((int));
55 static void check_literals PARAMS ((int, int));
56 static void mcore_s_text PARAMS ((int));
57 static void mcore_s_data PARAMS ((int));
58 static void mcore_s_section PARAMS ((int));
59 static void mcore_s_bss PARAMS ((int));
60 #ifdef OBJ_ELF
61 static void mcore_s_comm PARAMS ((int));
62 #endif
63
64 /* Several places in this file insert raw instructions into the
65 object. They should use MCORE_INST_XXX macros to get the opcodes
66 and then use these two macros to crack the MCORE_INST value into
67 the appropriate byte values. */
68 #define INST_BYTE0(x) (target_big_endian ? (((x) >> 8) & 0xFF) : ((x) & 0xFF))
69 #define INST_BYTE1(x) (target_big_endian ? ((x) & 0xFF) : (((x) >> 8) & 0xFF))
70
71 const char comment_chars[] = "#/";
72 const char line_separator_chars[] = ";";
73 const char line_comment_chars[] = "#/";
74
75 const int md_reloc_size = 8;
76
77 static int do_jsri2bsr = 0; /* Change here from 1 by Cruess 19 August 97. */
78 static int sifilter_mode = 0;
79
80 const char EXP_CHARS[] = "eE";
81
82 /* Chars that mean this number is a floating point constant
83 As in 0f12.456
84 or 0d1.2345e12 */
85 const char FLT_CHARS[] = "rRsSfFdDxXpP";
86
87 #define C(what,length) (((what) << 2) + (length))
88 #define GET_WHAT(x) ((x >> 2))
89
90 /* These are the two types of relaxable instruction */
91 #define COND_JUMP 1
92 #define UNCD_JUMP 2
93
94 #define UNDEF_DISP 0
95 #define COND12 1
96 #define COND32 2
97 #define UNCD12 1
98 #define UNCD32 2
99 #define UNDEF_WORD_DISP 4
100 #define END 5
101
102 #define C12_LEN 2
103 #define C32_LEN 10 /* allow for align */
104 #define U12_LEN 2
105 #define U32_LEN 8 /* allow for align */
106
107 typedef enum
108 {
109 M210,
110 M340
111 }
112 cpu_type;
113
114 cpu_type cpu = M340;
115
116 /* Initialize the relax table. */
117 const relax_typeS md_relax_table[] =
118 {
119 { 1, 1, 0, 0 }, /* 0: unused */
120 { 1, 1, 0, 0 }, /* 1: unused */
121 { 1, 1, 0, 0 }, /* 2: unused */
122 { 1, 1, 0, 0 }, /* 3: unused */
123 { 1, 1, 0, 0 }, /* 4: unused */
124 { 2048, -2046, C12_LEN, C(COND_JUMP, COND32) }, /* 5: C(COND_JUMP, COND12) */
125 { 0, 0, C32_LEN, 0 }, /* 6: C(COND_JUMP, COND32) */
126 { 1, 1, 0, 0 }, /* 7: unused */
127 { 1, 1, 0, 0 }, /* 8: unused */
128 { 2048, -2046, U12_LEN, C(UNCD_JUMP, UNCD32) }, /* 9: C(UNCD_JUMP, UNCD12) */
129 { 0, 0, U32_LEN, 0 }, /*10: C(UNCD_JUMP, UNCD32) */
130 { 1, 1, 0, 0 }, /*11: unused */
131 { 0, 0, 0, 0 } /*12: unused */
132 };
133
134 /* Literal pool data structures. */
135 struct literal
136 {
137 unsigned short refcnt;
138 unsigned char ispcrel;
139 unsigned char unused;
140 expressionS e;
141 };
142
143 #define MAX_POOL_SIZE (1024/4)
144 static struct literal litpool [MAX_POOL_SIZE];
145 static unsigned poolsize;
146 static unsigned poolnumber;
147 static unsigned long poolspan;
148
149 /* SPANPANIC: the point at which we get too scared and force a dump
150 of the literal pool, and perhaps put a branch in place.
151 Calculated as:
152 1024 span of lrw/jmpi/jsri insn (actually span+1)
153 -2 possible alignment at the insn.
154 -2 possible alignment to get the table aligned.
155 -2 an inserted branch around the table.
156 == 1018
157 at 1018, we might be in trouble.
158 -- so we have to be smaller than 1018 and since we deal with 2-byte
159 instructions, the next good choice is 1016.
160 -- Note we have a test case that fails when we've got 1018 here. */
161 #define SPANPANIC (1016) /* 1024 - 1 entry - 2 byte rounding. */
162 #define SPANCLOSE (900)
163 #define SPANEXIT (600)
164 static symbolS * poolsym; /* label for current pool. */
165 static char poolname[8];
166 static struct hash_control * opcode_hash_control; /* Opcode mnemonics. */
167
168 /* This table describes all the machine specific pseudo-ops the assembler
169 has to support. The fields are:
170 Pseudo-op name without dot
171 Function to call to execute this pseudo-op
172 Integer arg to pass to the function. */
173 const pseudo_typeS md_pseudo_table[] =
174 {
175 { "export", s_globl, 0 },
176 { "import", s_ignore, 0 },
177 { "literals", mcore_s_literals, 0 },
178 { "page", listing_eject, 0 },
179
180 /* The following are to intercept the placement of data into the text
181 section (eg addresses for a switch table), so that the space they
182 occupy can be taken into account when deciding whether or not to
183 dump the current literal pool.
184 XXX - currently we do not cope with the .space and .dcb.d directives. */
185 { "ascii", mcore_stringer, 0 },
186 { "asciz", mcore_stringer, 1 },
187 { "byte", mcore_cons, 1 },
188 { "dc", mcore_cons, 2 },
189 { "dc.b", mcore_cons, 1 },
190 { "dc.d", mcore_float_cons, 'd'},
191 { "dc.l", mcore_cons, 4 },
192 { "dc.s", mcore_float_cons, 'f'},
193 { "dc.w", mcore_cons, 2 },
194 { "dc.x", mcore_float_cons, 'x'},
195 { "double", mcore_float_cons, 'd'},
196 { "float", mcore_float_cons, 'f'},
197 { "hword", mcore_cons, 2 },
198 { "int", mcore_cons, 4 },
199 { "long", mcore_cons, 4 },
200 { "octa", mcore_cons, 16 },
201 { "quad", mcore_cons, 8 },
202 { "short", mcore_cons, 2 },
203 { "single", mcore_float_cons, 'f'},
204 { "string", mcore_stringer, 1 },
205 { "word", mcore_cons, 2 },
206 { "fill", mcore_fill, 0 },
207
208 /* Allow for the effect of section changes. */
209 { "text", mcore_s_text, 0 },
210 { "data", mcore_s_data, 0 },
211 { "bss", mcore_s_bss, 1 },
212 #ifdef OBJ_EF
213 { "comm", mcore_s_comm, 0 },
214 #endif
215 { "section", mcore_s_section, 0 },
216 { "section.s", mcore_s_section, 0 },
217 { "sect", mcore_s_section, 0 },
218 { "sect.s", mcore_s_section, 0 },
219
220 { 0, 0, 0 }
221 };
222
223 static void
224 mcore_s_literals (ignore)
225 int ignore;
226 {
227 dump_literals (0);
228 demand_empty_rest_of_line ();
229 }
230
231
232 static void
233 mcore_cons (nbytes)
234 int nbytes;
235 {
236 if (now_seg == text_section)
237 {
238 char * ptr = input_line_pointer;
239 int commas = 1;
240
241 /* Count the number of commas on the line. */
242 while (! is_end_of_line [(unsigned char) * ptr])
243 commas += * ptr ++ == ',';
244
245 poolspan += nbytes * commas;
246 }
247
248 cons (nbytes);
249
250 /* In theory we ought to call check_literals (2,0) here in case
251 we need to dump the literal table. We cannot do this however,
252 as the directives that we are intercepting may be being used
253 to build a switch table, and we must not interfere with its
254 contents. Instead we cross our fingers and pray... */
255 }
256
257 static void
258 mcore_float_cons (float_type)
259 int float_type;
260 {
261 if (now_seg == text_section)
262 {
263 char * ptr = input_line_pointer;
264 int commas = 1;
265
266 #ifdef REPEAT_CONS_EXPRESSIONS
267 #error REPEAT_CONS_EXPRESSIONS not handled
268 #endif
269
270 /* Count the number of commas on the line. */
271 while (! is_end_of_line [(unsigned char) * ptr])
272 commas += * ptr ++ == ',';
273
274 /* We would like to compute "hex_float (float_type) * commas"
275 but hex_float is not exported from read.c */
276 float_type == 'f' ? 4 : (float_type == 'd' ? 8 : 12);
277 poolspan += float_type * commas;
278 }
279
280 float_cons (float_type);
281
282 /* See the comment in mcore_cons () about calling check_literals.
283 It is unlikely that a switch table will be constructed using
284 floating point values, but it is still likely that an indexed
285 table of floating point constants is being created by these
286 directives, so again we must not interfere with their placement. */
287 }
288
289 static void
290 mcore_stringer (append_zero)
291 int append_zero;
292 {
293 if (now_seg == text_section)
294 {
295 char * ptr = input_line_pointer;
296
297 /* In theory we should compute how many bytes are going to
298 be occupied by the string(s) and add this to the poolspan.
299 To keep things simple however, we just add the number of
300 bytes left on the current line. This will be an over-
301 estimate, which is OK, and automatically allows for the
302 appending a zero byte, since the real string(s) is/are
303 required to be enclosed in double quotes. */
304 while (! is_end_of_line [(unsigned char) * ptr])
305 ptr ++;
306
307 poolspan += ptr - input_line_pointer;
308 }
309
310 stringer (append_zero);
311
312 /* We call check_literals here in case a large number of strings are
313 being placed into the text section with a sequence of stringer
314 directives. In theory we could be upsetting something if these
315 strings are actually in an indexed table instead of referenced by
316 individual labels. Let us hope that that never happens. */
317 check_literals (2, 0);
318 }
319
320 static void
321 mcore_fill (unused)
322 int unused;
323 {
324 if (now_seg == text_section)
325 {
326 char * str = input_line_pointer;
327 int size = 1;
328 int repeat;
329
330 repeat = atoi (str);
331
332 /* Look to see if a size has been specified. */
333 while (*str != '\n' && *str != 0 && *str != ',')
334 ++ str;
335
336 if (* str == ',')
337 {
338 size = atoi (str + 1);
339
340 if (size > 8)
341 size = 8;
342 else if (size < 0)
343 size = 0;
344 }
345
346 poolspan += size * repeat;
347 }
348
349 s_fill (unused);
350
351 check_literals (2, 0);
352 }
353
354 /* Handle the section changing pseudo-ops. These call through to the
355 normal implementations, but they dump the literal pool first. */
356 static void
357 mcore_s_text (ignore)
358 int ignore;
359 {
360 dump_literals (0);
361
362 #ifdef OBJ_ELF
363 obj_elf_text (ignore);
364 #else
365 s_text (ignore);
366 #endif
367 }
368
369 static void
370 mcore_s_data (ignore)
371 int ignore;
372 {
373 dump_literals (0);
374
375 #ifdef OBJ_ELF
376 obj_elf_data (ignore);
377 #else
378 s_data (ignore);
379 #endif
380 }
381
382 static void
383 mcore_s_section (ignore)
384 int ignore;
385 {
386 /* Scan forwards to find the name of the section. If the section
387 being switched to is ".line" then this is a DWARF1 debug section
388 which is arbitarily placed inside generated code. In this case
389 do not dump the literal pool because it is a) inefficient and
390 b) would require the generation of extra code to jump around the
391 pool. */
392 char * ilp = input_line_pointer;
393
394 while (*ilp != 0 && isspace(*ilp))
395 ++ ilp;
396
397 if (strncmp (ilp, ".line", 5) == 0
398 && (isspace (ilp[5]) || *ilp == '\n' || *ilp == '\r'))
399 ;
400 else
401 dump_literals (0);
402
403 #ifdef OBJ_ELF
404 obj_elf_section (ignore);
405 #endif
406 #ifdef OBJ_COFF
407 obj_coff_section (ignore);
408 #endif
409 }
410
411 static void
412 mcore_s_bss (needs_align)
413 int needs_align;
414 {
415 dump_literals (0);
416
417 s_lcomm_bytes (needs_align);
418 }
419
420 #ifdef OBJ_ELF
421 static void
422 mcore_s_comm (needs_align)
423 int needs_align;
424 {
425 dump_literals (0);
426
427 obj_elf_common (needs_align);
428 }
429 #endif
430
431 /* This function is called once, at assembler startup time. This should
432 set up all the tables, etc that the MD part of the assembler needs. */
433 void
434 md_begin ()
435 {
436 mcore_opcode_info * opcode;
437 char * prev_name = "";
438
439 opcode_hash_control = hash_new ();
440
441 /* Insert unique names into hash table */
442 for (opcode = mcore_table; opcode->name; opcode ++)
443 {
444 if (streq (prev_name, opcode->name))
445 {
446 /* Make all the opcodes with the same name point to the same
447 string. */
448 opcode->name = prev_name;
449 }
450 else
451 {
452 prev_name = opcode->name;
453 hash_insert (opcode_hash_control, opcode->name, (char *) opcode);
454 }
455 }
456 }
457
458 static int reg_m;
459 static int reg_n;
460 static expressionS immediate; /* absolute expression */
461
462 /* Get a log2(val). */
463 static int
464 log2 (val)
465 unsigned int val;
466 {
467 int log = -1;
468 while (val != 0)
469 {
470 log ++;
471 val >>= 1;
472 }
473
474 return log;
475 }
476
477 /* Try to parse a reg name. */
478 static char *
479 parse_reg (s, reg)
480 char * s;
481 unsigned * reg;
482 {
483 /* Strip leading whitespace. */
484 while (isspace (* s))
485 ++ s;
486
487 if (tolower (s[0]) == 'r')
488 {
489 if (s[1] == '1' && s[2] >= '0' && s[2] <= '5')
490 {
491 *reg = 10 + s[2] - '0';
492 return s + 3;
493 }
494
495 if (s[1] >= '0' && s[1] <= '9')
496 {
497 *reg = s[1] - '0';
498 return s + 2;
499 }
500 }
501 else if ( tolower (s[0]) == 's'
502 && tolower (s[1]) == 'p'
503 && ! isalnum (s[2]))
504 {
505 * reg = 0;
506 return s + 2;
507 }
508
509 as_bad (_("register expected, but saw '%.6s'"), s);
510 return s;
511 }
512
513 static struct Cregs
514 {
515 char * name;
516 unsigned int crnum;
517 }
518 cregs[] =
519 {
520 { "psr", 0},
521 { "vbr", 1},
522 { "epsr", 2},
523 { "fpsr", 3},
524 { "epc", 4},
525 { "fpc", 5},
526 { "ss0", 6},
527 { "ss1", 7},
528 { "ss2", 8},
529 { "ss3", 9},
530 { "ss4", 10},
531 { "gcr", 11},
532 { "gsr", 12},
533 { "", 0}
534 };
535
536 static char *
537 parse_creg (s, reg)
538 char * s;
539 unsigned * reg;
540 {
541 int i;
542
543 /* Strip leading whitespace. */
544 while (isspace (* s))
545 ++s;
546
547 if ((tolower (s[0]) == 'c' && tolower (s[1]) == 'r'))
548 {
549 if (s[2] == '3' && s[3] >= '0' && s[3] <= '1')
550 {
551 *reg = 30 + s[3] - '0';
552 return s + 4;
553 }
554
555 if (s[2] == '2' && s[3] >= '0' && s[3] <= '9')
556 {
557 *reg = 20 + s[3] - '0';
558 return s + 4;
559 }
560
561 if (s[2] == '1' && s[3] >= '0' && s[3] <= '9')
562 {
563 *reg = 10 + s[3] - '0';
564 return s + 4;
565 }
566
567 if (s[2] >= '0' && s[2] <= '9')
568 {
569 *reg = s[2] - '0';
570 return s + 3;
571 }
572 }
573
574 /* Look at alternate creg names before giving error. */
575 for (i = 0; cregs[i].name[0] != '\0'; i++)
576 {
577 char buf [10];
578 int length;
579 int j;
580
581 length = strlen (cregs[i].name);
582
583 for (j = 0; j < length; j++)
584 buf[j] = tolower (s[j]);
585
586 if (strncmp (cregs[i].name, buf, length) == 0)
587 {
588 *reg = cregs[i].crnum;
589 return s + length;
590 }
591 }
592
593 as_bad (_("control register expected, but saw '%.6s'"), s);
594
595 return s;
596 }
597
598 static char *
599 parse_psrmod (s, reg)
600 char * s;
601 unsigned * reg;
602 {
603 int i;
604 char buf[10];
605 static struct psrmods
606 {
607 char * name;
608 unsigned int value;
609 }
610 psrmods[] =
611 {
612 { "ie", 1 },
613 { "fe", 2 },
614 { "ee", 4 },
615 { "af", 8 } /* Really 0 and non-combinable. */
616 };
617
618 for (i = 0; i < 2; i++)
619 buf[i] = isascii (s[i]) ? tolower (s[i]) : 0;
620
621 for (i = sizeof (psrmods) / sizeof (psrmods[0]); i--;)
622 {
623 if (! strncmp (psrmods[i].name, buf, 2))
624 {
625 * reg = psrmods[i].value;
626
627 return s + 2;
628 }
629 }
630
631 as_bad (_("bad/missing psr specifier"));
632
633 * reg = 0;
634
635 return s;
636 }
637
638 static char *
639 parse_exp (s, e)
640 char * s;
641 expressionS * e;
642 {
643 char * save;
644 char * new;
645
646 /* Skip whitespace. */
647 while (isspace (* s))
648 ++ s;
649
650 save = input_line_pointer;
651 input_line_pointer = s;
652
653 expression (e);
654
655 if (e->X_op == O_absent)
656 as_bad (_("missing operand"));
657
658 new = input_line_pointer;
659 input_line_pointer = save;
660
661 return new;
662 }
663
664 static void
665 make_name (s, p, n)
666 char * s;
667 char * p;
668 int n;
669 {
670 static const char hex[] = "0123456789ABCDEF";
671
672 s[0] = p[0];
673 s[1] = p[1];
674 s[2] = p[2];
675 s[3] = hex[(n >> 12) & 0xF];
676 s[4] = hex[(n >> 8) & 0xF];
677 s[5] = hex[(n >> 4) & 0xF];
678 s[6] = hex[(n) & 0xF];
679 s[7] = 0;
680 }
681
682 #define POOL_END_LABEL ".LE"
683 #define POOL_START_LABEL ".LS"
684
685 static void
686 dump_literals (isforce)
687 int isforce;
688 {
689 int i;
690 struct literal * p;
691 symbolS * brarsym;
692
693 if (poolsize == 0)
694 return;
695
696 /* Must we branch around the literal table? */
697 if (isforce)
698 {
699 char * output;
700 char brarname[8];
701
702 make_name (brarname, POOL_END_LABEL, poolnumber);
703
704 brarsym = symbol_make (brarname);
705
706 symbol_table_insert (brarsym);
707
708 output = frag_var (rs_machine_dependent,
709 md_relax_table[C (UNCD_JUMP, UNCD32)].rlx_length,
710 md_relax_table[C (UNCD_JUMP, UNCD12)].rlx_length,
711 C (UNCD_JUMP, 0), brarsym, 0, 0);
712 output[0] = INST_BYTE0 (MCORE_INST_BR); /* br .+xxx */
713 output[1] = INST_BYTE1 (MCORE_INST_BR);
714 }
715
716 /* Make sure that the section is sufficiently aligned and that
717 the literal table is aligned within it. */
718 record_alignment (now_seg, 2);
719 frag_align (2, 0, 0);
720
721 colon (S_GET_NAME (poolsym));
722
723 for (i = 0, p = litpool; i < poolsize; i++, p++)
724 emit_expr (& p->e, 4);
725
726 if (isforce)
727 colon (S_GET_NAME (brarsym));
728
729 poolsize = 0;
730 }
731
732 static void
733 check_literals (kind, offset)
734 int kind;
735 int offset;
736 {
737 poolspan += offset;
738
739 /* SPANCLOSE and SPANEXIT are smaller numbers than SPANPANIC.
740 SPANPANIC means that we must dump now.
741 kind == 0 is any old instruction.
742 kind > 0 means we just had a control transfer instruction.
743 kind == 1 means within a function
744 kind == 2 means we just left a function
745
746 The dump_literals (1) call inserts a branch around the table, so
747 we first look to see if its a situation where we won't have to
748 insert a branch (e.g., the previous instruction was an unconditional
749 branch).
750
751 SPANPANIC is the point where we must dump a single-entry pool.
752 it accounts for alignments and an inserted branch.
753 the 'poolsize*2' accounts for the scenario where we do:
754 lrw r1,lit1; lrw r2,lit2; lrw r3,lit3
755 Note that the 'lit2' reference is 2 bytes further along
756 but the literal it references will be 4 bytes further along,
757 so we must consider the poolsize into this equation.
758 This is slightly over-cautious, but guarantees that we won't
759 panic because a relocation is too distant. */
760
761 if (poolspan > SPANCLOSE && kind > 0)
762 dump_literals (0);
763 else if (poolspan > SPANEXIT && kind > 1)
764 dump_literals (0);
765 else if (poolspan >= (SPANPANIC - poolsize * 2))
766 dump_literals (1);
767 }
768
769 static int
770 enter_literal (e, ispcrel)
771 expressionS * e;
772 int ispcrel;
773 {
774 int i;
775 struct literal * p;
776
777 if (poolsize >= MAX_POOL_SIZE - 2)
778 {
779 /* The literal pool is as full as we can handle. We have
780 to be 2 entries shy of the 1024/4=256 entries because we
781 have to allow for the branch (2 bytes) and the alignment
782 (2 bytes before the first insn referencing the pool and
783 2 bytes before the pool itself) == 6 bytes, rounds up
784 to 2 entries. */
785 dump_literals (1);
786 }
787
788 if (poolsize == 0)
789 {
790 /* Create new literal pool. */
791 if (++ poolnumber > 0xFFFF)
792 as_fatal (_("more than 65K literal pools"));
793
794 make_name (poolname, POOL_START_LABEL, poolnumber);
795 poolsym = symbol_make (poolname);
796 symbol_table_insert (poolsym);
797 poolspan = 0;
798 }
799
800 /* Search pool for value so we don't have duplicates. */
801 for (p = litpool, i = 0; i < poolsize; i++, p++)
802 {
803 if (e->X_op == p->e.X_op
804 && e->X_add_symbol == p->e.X_add_symbol
805 && e->X_add_number == p->e.X_add_number
806 && ispcrel == p->ispcrel)
807 {
808 p->refcnt ++;
809 return i;
810 }
811 }
812
813 p->refcnt = 1;
814 p->ispcrel = ispcrel;
815 p->e = * e;
816
817 poolsize ++;
818
819 return i;
820 }
821
822 /* Parse a literal specification. -- either new or old syntax.
823 old syntax: the user supplies the label and places the literal.
824 new syntax: we put it into the literal pool. */
825 static char *
826 parse_rt (s, outputp, ispcrel, ep)
827 char * s;
828 char ** outputp;
829 int ispcrel;
830 expressionS * ep;
831 {
832 expressionS e;
833 int n;
834
835 if (ep)
836 /* Indicate nothing there. */
837 ep->X_op = O_absent;
838
839 if (*s == '[')
840 {
841 s = parse_exp (s + 1, & e);
842
843 if (*s == ']')
844 s++;
845 else
846 as_bad (_("missing ']'"));
847 }
848 else
849 {
850 s = parse_exp (s, & e);
851
852 n = enter_literal (& e, ispcrel);
853
854 if (ep)
855 *ep = e;
856
857 /* Create a reference to pool entry. */
858 e.X_op = O_symbol;
859 e.X_add_symbol = poolsym;
860 e.X_add_number = n << 2;
861 }
862
863 * outputp = frag_more (2);
864
865 fix_new_exp (frag_now, (*outputp) - frag_now->fr_literal, 2, & e, 1,
866 BFD_RELOC_MCORE_PCREL_IMM8BY4);
867
868 return s;
869 }
870
871 static char *
872 parse_imm (s, val, min, max)
873 char * s;
874 unsigned * val;
875 unsigned min;
876 unsigned max;
877 {
878 char * new;
879 expressionS e;
880
881 new = parse_exp (s, & e);
882
883 if (e.X_op == O_absent)
884 ; /* An error message has already been emitted. */
885 else if (e.X_op != O_constant)
886 as_bad (_("operand must be a constant"));
887 else if (e.X_add_number < min || e.X_add_number > max)
888 as_bad (_("operand must be absolute in range %d..%d, not %d"),
889 min, max, e.X_add_number);
890
891 * val = e.X_add_number;
892
893 return new;
894 }
895
896 static char *
897 parse_mem (s, reg, off, siz)
898 char * s;
899 unsigned * reg;
900 unsigned * off;
901 unsigned siz;
902 {
903 char * new;
904
905 * off = 0;
906
907 while (isspace (* s))
908 ++ s;
909
910 if (* s == '(')
911 {
912 s = parse_reg (s + 1, reg);
913
914 while (isspace (* s))
915 ++ s;
916
917 if (* s == ',')
918 {
919 s = parse_imm (s + 1, off, 0, 63);
920
921 if (siz > 1)
922 {
923 if (siz > 2)
924 {
925 if (* off & 0x3)
926 as_bad (_("operand must be a multiple of 4"));
927
928 * off >>= 2;
929 }
930 else
931 {
932 if (* off & 0x1)
933 as_bad (_("operand must be a multiple of 2"));
934
935 * off >>= 1;
936 }
937 }
938 }
939
940 while (isspace (* s))
941 ++ s;
942
943 if (* s == ')')
944 s ++;
945 }
946 else
947 as_bad (_("base register expected"));
948
949 return s;
950 }
951
952 /* This is the guts of the machine-dependent assembler. STR points to a
953 machine dependent instruction. This function is supposed to emit
954 the frags/bytes it assembles to. */
955
956 void
957 md_assemble (str)
958 char * str;
959 {
960 char * op_start;
961 char * op_end;
962 mcore_opcode_info * opcode;
963 char * output;
964 int nlen = 0;
965 unsigned short inst;
966 unsigned reg;
967 unsigned off;
968 unsigned isize;
969 expressionS e;
970 char name[20];
971
972 /* Drop leading whitespace. */
973 while (isspace (* str))
974 str ++;
975
976 /* Find the op code end. */
977 for (op_start = op_end = str;
978 nlen < 20 && !is_end_of_line [(unsigned char) *op_end] && *op_end != ' ';
979 op_end++)
980 {
981 name[nlen] = op_start[nlen];
982 nlen++;
983 }
984
985 name [nlen] = 0;
986
987 if (nlen == 0)
988 {
989 as_bad (_("can't find opcode "));
990 return;
991 }
992
993 opcode = (mcore_opcode_info *) hash_find (opcode_hash_control, name);
994 if (opcode == NULL)
995 {
996 as_bad (_("unknown opcode \"%s\""), name);
997 return;
998 }
999
1000 inst = opcode->inst;
1001 isize = 2;
1002
1003 switch (opcode->opclass)
1004 {
1005 case O0:
1006 output = frag_more (2);
1007 break;
1008
1009 case OT:
1010 op_end = parse_imm (op_end + 1, & reg, 0, 3);
1011 inst |= reg;
1012 output = frag_more (2);
1013 break;
1014
1015 case O1:
1016 op_end = parse_reg (op_end + 1, & reg);
1017 inst |= reg;
1018 output = frag_more (2);
1019 break;
1020
1021 case JMP:
1022 op_end = parse_reg (op_end + 1, & reg);
1023 inst |= reg;
1024 output = frag_more (2);
1025 /* In a sifilter mode, we emit this insn 2 times,
1026 fixes problem of an interrupt during a jmp.. */
1027 if (sifilter_mode)
1028 {
1029 output[0] = INST_BYTE0 (inst);
1030 output[1] = INST_BYTE1 (inst);
1031 output = frag_more (2);
1032 }
1033 break;
1034
1035 case JSR:
1036 op_end = parse_reg (op_end + 1, & reg);
1037
1038 if (reg == 15)
1039 as_bad (_("invalid register: r15 illegal"));
1040
1041 inst |= reg;
1042 output = frag_more (2);
1043
1044 if (sifilter_mode)
1045 {
1046 /* Replace with: bsr .+2 ; addi r15,6; jmp rx ; jmp rx */
1047 inst = MCORE_INST_BSR; /* with 0 displacement */
1048 output[0] = INST_BYTE0 (inst);
1049 output[1] = INST_BYTE1 (inst);
1050
1051 output = frag_more (2);
1052 inst = MCORE_INST_ADDI;
1053 inst |= 15; /* addi r15,6 */
1054 inst |= (6 - 1) << 4; /* over the jmp's */
1055 output[0] = INST_BYTE0 (inst);
1056 output[1] = INST_BYTE1 (inst);
1057
1058 output = frag_more (2);
1059 inst = MCORE_INST_JMP | reg;
1060 output[0] = INST_BYTE0 (inst);
1061 output[1] = INST_BYTE1 (inst);
1062
1063 output = frag_more (2); /* 2nd emitted in fallthru */
1064 }
1065 break;
1066
1067 case OC:
1068 op_end = parse_reg (op_end + 1, & reg);
1069 inst |= reg;
1070
1071 /* Skip whitespace. */
1072 while (isspace (* op_end))
1073 ++ op_end;
1074
1075 if (*op_end == ',')
1076 {
1077 op_end = parse_creg (op_end + 1, & reg);
1078 inst |= reg << 4;
1079 }
1080
1081 output = frag_more (2);
1082 break;
1083
1084 case MULSH:
1085 if (cpu == M210)
1086 {
1087 as_bad (_("M340 specific opcode used when assembling for M210"));
1088 break;
1089 }
1090 /* drop through... */
1091 case O2:
1092 op_end = parse_reg (op_end + 1, & reg);
1093 inst |= reg;
1094
1095 /* Skip whitespace. */
1096 while (isspace (* op_end))
1097 ++ op_end;
1098
1099 if (* op_end == ',')
1100 {
1101 op_end = parse_reg (op_end + 1, & reg);
1102 inst |= reg << 4;
1103 }
1104 else
1105 as_bad (_("second operand missing"));
1106
1107 output = frag_more (2);
1108 break;
1109
1110 case X1: /* Handle both syntax-> xtrb- r1,rx OR xtrb- rx */
1111 op_end = parse_reg (op_end + 1, & reg);
1112
1113 /* Skip whitespace. */
1114 while (isspace (* op_end))
1115 ++ op_end;
1116
1117 if (* op_end == ',') /* xtrb- r1,rx */
1118 {
1119 if (reg != 1)
1120 as_bad (_("destination register must be r1"));
1121
1122 op_end = parse_reg (op_end + 1, & reg);
1123 }
1124
1125 inst |= reg;
1126 output = frag_more (2);
1127 break;
1128
1129 case O1R1: /* div- rx,r1 */
1130 op_end = parse_reg (op_end + 1, & reg);
1131 inst |= reg;
1132
1133 /* Skip whitespace. */
1134 while (isspace (* op_end))
1135 ++ op_end;
1136
1137 if (* op_end == ',')
1138 {
1139 op_end = parse_reg (op_end + 1, & reg);
1140 if (reg != 1)
1141 as_bad (_("source register must be r1"));
1142 }
1143 else
1144 as_bad (_("second operand missing"));
1145
1146 output = frag_more (2);
1147 break;
1148
1149 case OI:
1150 op_end = parse_reg (op_end + 1, & reg);
1151 inst |= reg;
1152
1153 /* Skip whitespace. */
1154 while (isspace (* op_end))
1155 ++ op_end;
1156
1157 if (* op_end == ',')
1158 {
1159 op_end = parse_imm (op_end + 1, & reg, 1, 32);
1160 inst |= (reg - 1) << 4;
1161 }
1162 else
1163 as_bad (_("second operand missing"));
1164
1165 output = frag_more (2);
1166 break;
1167
1168 case OB:
1169 op_end = parse_reg (op_end + 1, & reg);
1170 inst |= reg;
1171
1172 /* Skip whitespace. */
1173 while (isspace (* op_end))
1174 ++ op_end;
1175
1176 if (* op_end == ',')
1177 {
1178 op_end = parse_imm (op_end + 1, & reg, 0, 31);
1179 inst |= reg << 4;
1180 }
1181 else
1182 as_bad (_("second operand missing"));
1183
1184 output = frag_more (2);
1185 break;
1186
1187 case OB2: /* like OB, but arg is 2^n instead of n */
1188 op_end = parse_reg (op_end + 1, & reg);
1189 inst |= reg;
1190
1191 /* Skip whitespace. */
1192 while (isspace (* op_end))
1193 ++ op_end;
1194
1195 if (* op_end == ',')
1196 {
1197 op_end = parse_imm (op_end + 1, & reg, 1, 1 << 31);
1198 /* Further restrict the immediate to a power of two. */
1199 if ((reg & (reg - 1)) == 0)
1200 reg = log2 (reg);
1201 else
1202 {
1203 reg = 0;
1204 as_bad (_("immediate is not a power of two"));
1205 }
1206 inst |= (reg) << 4;
1207 }
1208 else
1209 as_bad (_("second operand missing"));
1210
1211 output = frag_more (2);
1212 break;
1213
1214 case OBRa: /* Specific for bgeni: imm of 0->6 translate to movi. */
1215 case OBRb:
1216 case OBRc:
1217 op_end = parse_reg (op_end + 1, & reg);
1218 inst |= reg;
1219
1220 /* Skip whitespace. */
1221 while (isspace (* op_end))
1222 ++ op_end;
1223
1224 if (* op_end == ',')
1225 {
1226 op_end = parse_imm (op_end + 1, & reg, 0, 31);
1227 /* immediate values of 0 -> 6 translate to movi */
1228 if (reg <= 6)
1229 {
1230 inst = (inst & 0xF) | MCORE_INST_BGENI_ALT;
1231 reg = 0x1 << reg;
1232 as_warn (_("translating bgeni to movi"));
1233 }
1234 inst &= ~ 0x01f0;
1235 inst |= reg << 4;
1236 }
1237 else
1238 as_bad (_("second operand missing"));
1239
1240 output = frag_more (2);
1241 break;
1242
1243 case OBR2: /* like OBR, but arg is 2^n instead of n */
1244 op_end = parse_reg (op_end + 1, & reg);
1245 inst |= reg;
1246
1247 /* Skip whitespace. */
1248 while (isspace (* op_end))
1249 ++ op_end;
1250
1251 if (* op_end == ',')
1252 {
1253 op_end = parse_imm (op_end + 1, & reg, 1, 1 << 31);
1254
1255 /* Further restrict the immediate to a power of two. */
1256 if ((reg & (reg - 1)) == 0)
1257 reg = log2 (reg);
1258 else
1259 {
1260 reg = 0;
1261 as_bad (_("immediate is not a power of two"));
1262 }
1263
1264 /* Immediate values of 0 -> 6 translate to movi. */
1265 if (reg <= 6)
1266 {
1267 inst = (inst & 0xF) | MCORE_INST_BGENI_ALT;
1268 reg = 0x1 << reg;
1269 as_warn (_("translating mgeni to movi"));
1270 }
1271
1272 inst |= reg << 4;
1273 }
1274 else
1275 as_bad (_("second operand missing"));
1276
1277 output = frag_more (2);
1278 break;
1279
1280 case OMa: /* Specific for bmaski: imm 1->7 translate to movi. */
1281 case OMb:
1282 case OMc:
1283 op_end = parse_reg (op_end + 1, & reg);
1284 inst |= reg;
1285
1286 /* Skip whitespace. */
1287 while (isspace (* op_end))
1288 ++ op_end;
1289
1290 if (* op_end == ',')
1291 {
1292 op_end = parse_imm (op_end + 1, & reg, 1, 32);
1293
1294 /* Immediate values of 1 -> 7 translate to movi. */
1295 if (reg <= 7)
1296 {
1297 inst = (inst & 0xF) | MCORE_INST_BMASKI_ALT;
1298 reg = (0x1 << reg) - 1;
1299 inst |= reg << 4;
1300
1301 as_warn (_("translating bmaski to movi"));
1302 }
1303 else
1304 {
1305 inst &= ~ 0x01F0;
1306 inst |= (reg & 0x1F) << 4;
1307 }
1308 }
1309 else
1310 as_bad (_("second operand missing"));
1311
1312 output = frag_more (2);
1313 break;
1314
1315 case SI:
1316 op_end = parse_reg (op_end + 1, & reg);
1317 inst |= reg;
1318
1319 /* Skip whitespace. */
1320 while (isspace (* op_end))
1321 ++ op_end;
1322
1323 if (* op_end == ',')
1324 {
1325 op_end = parse_imm (op_end + 1, & reg, 1, 31);
1326 inst |= reg << 4;
1327 }
1328 else
1329 as_bad (_("second operand missing"));
1330
1331 output = frag_more (2);
1332 break;
1333
1334 case I7:
1335 op_end = parse_reg (op_end + 1, & reg);
1336 inst |= reg;
1337
1338 /* Skip whitespace. */
1339 while (isspace (* op_end))
1340 ++ op_end;
1341
1342 if (* op_end == ',')
1343 {
1344 op_end = parse_imm (op_end + 1, & reg, 0, 0x7F);
1345 inst |= reg << 4;
1346 }
1347 else
1348 as_bad (_("second operand missing"));
1349
1350 output = frag_more (2);
1351 break;
1352
1353 case LS:
1354 op_end = parse_reg (op_end + 1, & reg);
1355 inst |= reg << 8;
1356
1357 /* Skip whitespace. */
1358 while (isspace (* op_end))
1359 ++ op_end;
1360
1361 if (* op_end == ',')
1362 {
1363 int size;
1364
1365 if ((inst & 0x6000) == 0)
1366 size = 4;
1367 else if ((inst & 0x6000) == 0x4000)
1368 size = 2;
1369 else if ((inst & 0x6000) == 0x2000)
1370 size = 1;
1371
1372 op_end = parse_mem (op_end + 1, & reg, & off, size);
1373
1374 if (off > 16)
1375 as_bad (_("displacement too large (%d)"), off);
1376 else
1377 inst |= (reg) | (off << 4);
1378 }
1379 else
1380 as_bad (_("second operand missing"));
1381
1382 output = frag_more (2);
1383 break;
1384
1385 case LR:
1386 op_end = parse_reg (op_end + 1, & reg);
1387
1388 if (reg == 0 || reg == 15)
1389 as_bad (_("Invalid register: r0 and r15 illegal"));
1390
1391 inst |= (reg << 8);
1392
1393 /* Skip whitespace. */
1394 while (isspace (* op_end))
1395 ++ op_end;
1396
1397 if (* op_end == ',')
1398 {
1399 /* parse_rt calls frag_more() for us. */
1400 input_line_pointer = parse_rt (op_end + 1, & output, 0, 0);
1401 op_end = input_line_pointer;
1402 }
1403 else
1404 {
1405 as_bad (_("second operand missing"));
1406 output = frag_more (2); /* save its space */
1407 }
1408 break;
1409
1410 case LJ:
1411 input_line_pointer = parse_rt (op_end + 1, & output, 1, 0);
1412 /* parse_rt() calls frag_more() for us. */
1413 op_end = input_line_pointer;
1414 break;
1415
1416 case RM:
1417 op_end = parse_reg (op_end + 1, & reg);
1418
1419 if (reg == 0 || reg == 15)
1420 as_bad (_("bad starting register: r0 and r15 invalid"));
1421
1422 inst |= reg;
1423
1424 /* Skip whitespace. */
1425 while (isspace (* op_end))
1426 ++ op_end;
1427
1428 if (* op_end == '-')
1429 {
1430 op_end = parse_reg (op_end + 1, & reg);
1431
1432 if (reg != 15)
1433 as_bad (_("ending register must be r15"));
1434
1435 /* Skip whitespace. */
1436 while (isspace (* op_end))
1437 ++ op_end;
1438 }
1439
1440 if (* op_end == ',')
1441 {
1442 op_end ++;
1443
1444 /* Skip whitespace. */
1445 while (isspace (* op_end))
1446 ++ op_end;
1447
1448 if (* op_end == '(')
1449 {
1450 op_end = parse_reg (op_end + 1, & reg);
1451
1452 if (reg != 0)
1453 as_bad (_("bad base register: must be r0"));
1454
1455 if (* op_end == ')')
1456 op_end ++;
1457 }
1458 else
1459 as_bad (_("base register expected"));
1460 }
1461 else
1462 as_bad (_("second operand missing"));
1463
1464 output = frag_more (2);
1465 break;
1466
1467 case RQ:
1468 op_end = parse_reg (op_end + 1, & reg);
1469
1470 if (reg != 4)
1471 as_fatal (_("first register must be r4"));
1472
1473 /* Skip whitespace. */
1474 while (isspace (* op_end))
1475 ++ op_end;
1476
1477 if (* op_end == '-')
1478 {
1479 op_end = parse_reg (op_end + 1, & reg);
1480
1481 if (reg != 7)
1482 as_fatal (_("last register must be r7"));
1483
1484 /* Skip whitespace. */
1485 while (isspace (* op_end))
1486 ++ op_end;
1487
1488 if (* op_end == ',')
1489 {
1490 op_end ++;
1491
1492 /* Skip whitespace. */
1493 while (isspace (* op_end))
1494 ++ op_end;
1495
1496 if (* op_end == '(')
1497 {
1498 op_end = parse_reg (op_end + 1, & reg);
1499
1500 if (reg >= 4 && reg <= 7)
1501 as_fatal ("base register cannot be r4, r5, r6, or r7");
1502
1503 inst |= reg;
1504
1505 /* Skip whitespace. */
1506 while (isspace (* op_end))
1507 ++ op_end;
1508
1509 if (* op_end == ')')
1510 op_end ++;
1511 }
1512 else
1513 as_bad (_("base register expected"));
1514 }
1515 else
1516 as_bad (_("second operand missing"));
1517 }
1518 else
1519 as_bad (_("reg-reg expected"));
1520
1521 output = frag_more (2);
1522 break;
1523
1524 case BR:
1525 input_line_pointer = parse_exp (op_end + 1, & e);
1526 op_end = input_line_pointer;
1527
1528 output = frag_more (2);
1529
1530 fix_new_exp (frag_now, output-frag_now->fr_literal,
1531 2, & e, 1, BFD_RELOC_MCORE_PCREL_IMM11BY2);
1532 break;
1533
1534 case BL:
1535 op_end = parse_reg (op_end + 1, & reg);
1536 inst |= reg << 4;
1537
1538 /* Skip whitespace. */
1539 while (isspace (* op_end))
1540 ++ op_end;
1541
1542 if (* op_end == ',')
1543 {
1544 op_end = parse_exp (op_end + 1, & e);
1545 output = frag_more (2);
1546
1547 fix_new_exp (frag_now, output-frag_now->fr_literal,
1548 2, & e, 1, BFD_RELOC_MCORE_PCREL_IMM4BY2);
1549 }
1550 else
1551 {
1552 as_bad (_("second operand missing"));
1553 output = frag_more (2);
1554 }
1555 break;
1556
1557 case JC:
1558 input_line_pointer = parse_exp (op_end + 1, & e);
1559 op_end = input_line_pointer;
1560
1561 output = frag_var (rs_machine_dependent,
1562 md_relax_table[C (COND_JUMP, COND32)].rlx_length,
1563 md_relax_table[C (COND_JUMP, COND12)].rlx_length,
1564 C (COND_JUMP, 0), e.X_add_symbol, e.X_add_number, 0);
1565 isize = C32_LEN;
1566 break;
1567
1568 case JU:
1569 input_line_pointer = parse_exp (op_end + 1, & e);
1570 op_end = input_line_pointer;
1571
1572 output = frag_var (rs_machine_dependent,
1573 md_relax_table[C (UNCD_JUMP, UNCD32)].rlx_length,
1574 md_relax_table[C (UNCD_JUMP, UNCD12)].rlx_length,
1575 C (UNCD_JUMP, 0), e.X_add_symbol, e.X_add_number, 0);
1576 isize = U32_LEN;
1577 break;
1578
1579 case JL:
1580 inst = MCORE_INST_JSRI; /* jsri */
1581 input_line_pointer = parse_rt (op_end + 1, & output, 1, & e);
1582 /* parse_rt() calls frag_more for us. */
1583 op_end = input_line_pointer;
1584
1585 /* Only do this if we know how to do it ... */
1586 if (e.X_op != O_absent && do_jsri2bsr)
1587 {
1588 /* Look at adding the R_PCREL_JSRIMM11BY2. */
1589 fix_new_exp (frag_now, output-frag_now->fr_literal,
1590 2, & e, 1, BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2);
1591 }
1592 break;
1593
1594 case RSI: /* SI, but imm becomes 32-imm */
1595 op_end = parse_reg (op_end + 1, & reg);
1596 inst |= reg;
1597
1598 /* Skip whitespace. */
1599 while (isspace (* op_end))
1600 ++ op_end;
1601
1602 if (* op_end == ',')
1603 {
1604 op_end = parse_imm (op_end + 1, & reg, 1, 31);
1605
1606 reg = 32 - reg;
1607 inst |= reg << 4;
1608 }
1609 else
1610 as_bad (_("second operand missing"));
1611
1612 output = frag_more (2);
1613 break;
1614
1615 case DO21: /* O2, dup rd, lit must be 1 */
1616 op_end = parse_reg (op_end + 1, & reg);
1617 inst |= reg;
1618 inst |= reg << 4;
1619
1620 /* Skip whitespace. */
1621 while (isspace (* op_end))
1622 ++ op_end;
1623
1624 if (* op_end == ',')
1625 {
1626 op_end = parse_imm (op_end + 1, & reg, 1, 31);
1627
1628 if (reg != 1)
1629 as_bad (_("second operand must be 1"));
1630 }
1631 else
1632 as_bad (_("second operand missing"));
1633
1634 output = frag_more (2);
1635 break;
1636
1637 case SIa:
1638 op_end = parse_reg (op_end + 1, & reg);
1639 inst |= reg;
1640
1641 /* Skip whitespace. */
1642 while (isspace (* op_end))
1643 ++ op_end;
1644
1645 if (* op_end == ',')
1646 {
1647 op_end = parse_imm (op_end + 1, & reg, 1, 31);
1648
1649 if (reg == 0)
1650 as_bad (_("zero used as immediate value"));
1651
1652 inst |= reg << 4;
1653 }
1654 else
1655 as_bad (_("second operand missing"));
1656
1657 output = frag_more (2);
1658 break;
1659
1660 case OPSR:
1661 if (cpu == M210)
1662 {
1663 as_bad (_("M340 specific opcode used when assembling for M210"));
1664 break;
1665 }
1666
1667 op_end = parse_psrmod (op_end + 1, & reg);
1668
1669 /* Look for further selectors. */
1670 while (* op_end == ',')
1671 {
1672 unsigned value;
1673
1674 op_end = parse_psrmod (op_end + 1, & value);
1675
1676 if (value & reg)
1677 as_bad (_("duplicated psr bit specifier"));
1678
1679 reg |= value;
1680 }
1681
1682 if (reg > 8)
1683 as_bad (_("`af' must appear alone"));
1684
1685 inst |= (reg & 0x7);
1686 output = frag_more (2);
1687 break;
1688
1689 default:
1690 as_bad (_("unimplemented opcode \"%s\""), name);
1691 }
1692
1693 /* Drop whitespace after all the operands have been parsed. */
1694 while (isspace (* op_end))
1695 op_end ++;
1696
1697 /* Give warning message if the insn has more operands than required. */
1698 if (strcmp (op_end, opcode->name) && strcmp (op_end, ""))
1699 as_warn (_("ignoring operands: %s "), op_end);
1700
1701 output[0] = INST_BYTE0 (inst);
1702 output[1] = INST_BYTE1 (inst);
1703
1704 check_literals (opcode->transfer, isize);
1705 }
1706
1707 symbolS *
1708 md_undefined_symbol (name)
1709 char * name;
1710 {
1711 return 0;
1712 }
1713
1714 void
1715 md_mcore_end ()
1716 {
1717 dump_literals (0);
1718 subseg_set (text_section, 0);
1719 }
1720
1721 /* Various routines to kill one day. */
1722 /* Equal to MAX_PRECISION in atof-ieee.c */
1723 #define MAX_LITTLENUMS 6
1724
1725 /* Turn a string in input_line_pointer into a floating point constant of type
1726 type, and store the appropriate bytes in *litP. The number of LITTLENUMS
1727 emitted is stored in *sizeP. An error message is returned, or NULL on OK.*/
1728 char *
1729 md_atof (type, litP, sizeP)
1730 int type;
1731 char * litP;
1732 int * sizeP;
1733 {
1734 int prec;
1735 LITTLENUM_TYPE words[MAX_LITTLENUMS];
1736 int i;
1737 char * t;
1738 char * atof_ieee ();
1739
1740 switch (type)
1741 {
1742 case 'f':
1743 case 'F':
1744 case 's':
1745 case 'S':
1746 prec = 2;
1747 break;
1748
1749 case 'd':
1750 case 'D':
1751 case 'r':
1752 case 'R':
1753 prec = 4;
1754 break;
1755
1756 case 'x':
1757 case 'X':
1758 prec = 6;
1759 break;
1760
1761 case 'p':
1762 case 'P':
1763 prec = 6;
1764 break;
1765
1766 default:
1767 *sizeP = 0;
1768 return _("Bad call to MD_NTOF()");
1769 }
1770
1771 t = atof_ieee (input_line_pointer, type, words);
1772
1773 if (t)
1774 input_line_pointer = t;
1775
1776 *sizeP = prec * sizeof (LITTLENUM_TYPE);
1777
1778 if (! target_big_endian)
1779 {
1780 for (i = prec - 1; i >= 0; i--)
1781 {
1782 md_number_to_chars (litP, (valueT) words[i],
1783 sizeof (LITTLENUM_TYPE));
1784 litP += sizeof (LITTLENUM_TYPE);
1785 }
1786 }
1787 else
1788 for (i = 0; i < prec; i++)
1789 {
1790 md_number_to_chars (litP, (valueT) words[i],
1791 sizeof (LITTLENUM_TYPE));
1792 litP += sizeof (LITTLENUM_TYPE);
1793 }
1794
1795 return 0;
1796 }
1797 \f
1798 CONST char * md_shortopts = "";
1799
1800 #define OPTION_JSRI2BSR_ON (OPTION_MD_BASE + 0)
1801 #define OPTION_JSRI2BSR_OFF (OPTION_MD_BASE + 1)
1802 #define OPTION_SIFILTER_ON (OPTION_MD_BASE + 2)
1803 #define OPTION_SIFILTER_OFF (OPTION_MD_BASE + 3)
1804 #define OPTION_CPU (OPTION_MD_BASE + 4)
1805 #define OPTION_EB (OPTION_MD_BASE + 5)
1806 #define OPTION_EL (OPTION_MD_BASE + 6)
1807
1808 struct option md_longopts[] =
1809 {
1810 { "no-jsri2bsr", no_argument, NULL, OPTION_JSRI2BSR_OFF},
1811 { "jsri2bsr", no_argument, NULL, OPTION_JSRI2BSR_ON},
1812 { "sifilter", no_argument, NULL, OPTION_SIFILTER_ON},
1813 { "no-sifilter", no_argument, NULL, OPTION_SIFILTER_OFF},
1814 { "cpu", required_argument, NULL, OPTION_CPU},
1815 { "EB", no_argument, NULL, OPTION_EB},
1816 { "EL", no_argument, NULL, OPTION_EL},
1817 { NULL, no_argument, NULL, 0}
1818 };
1819
1820 size_t md_longopts_size = sizeof (md_longopts);
1821
1822 int
1823 md_parse_option (c, arg)
1824 int c;
1825 char * arg;
1826 {
1827 int i;
1828 char * p;
1829
1830 switch (c)
1831 {
1832 case OPTION_CPU:
1833 if (streq (arg, "210"))
1834 {
1835 cpu = M210;
1836 target_big_endian = 1;
1837 }
1838 else if (streq (arg, "340"))
1839 cpu = M340;
1840 else
1841 as_warn (_("unrecognised cpu type '%s'"), arg);
1842 break;
1843
1844 case OPTION_EB: target_big_endian = 1; break;
1845 case OPTION_EL: target_big_endian = 0; cpu = M340; break;
1846 case OPTION_JSRI2BSR_ON: do_jsri2bsr = 1; break;
1847 case OPTION_JSRI2BSR_OFF: do_jsri2bsr = 0; break;
1848 case OPTION_SIFILTER_ON: sifilter_mode = 1; break;
1849 case OPTION_SIFILTER_OFF: sifilter_mode = 0; break;
1850 default: return 0;
1851 }
1852
1853 return 1;
1854 }
1855
1856 void
1857 md_show_usage (stream)
1858 FILE * stream;
1859 {
1860 fprintf (stream, _("\
1861 MCORE specific options:\n\
1862 -{no-}jsri2bsr {dis}able jsri to bsr transformation (def: dis)\n\
1863 -{no-}sifilter {dis}able silicon filter behavior (def: dis)\n\
1864 -cpu=[210|340] select CPU type\n\
1865 -EB assemble for a big endian system (default)\n\
1866 -EL assemble for a little endian system\n"));
1867 }
1868 \f
1869 int md_short_jump_size;
1870
1871 void
1872 md_create_short_jump (ptr, from_Nddr, to_Nddr, frag, to_symbol)
1873 char * ptr;
1874 addressT from_Nddr;
1875 addressT to_Nddr;
1876 fragS * frag;
1877 symbolS * to_symbol;
1878 {
1879 as_fatal (_("failed sanity check: short_jump"));
1880 }
1881
1882 void
1883 md_create_long_jump (ptr, from_Nddr, to_Nddr, frag, to_symbol)
1884 char * ptr;
1885 addressT from_Nddr;
1886 addressT to_Nddr;
1887 fragS * frag;
1888 symbolS * to_symbol;
1889 {
1890 as_fatal (_("failed sanity check: long_jump"));
1891 }
1892
1893 /* Called after relaxing, change the frags so they know how big they are. */
1894 void
1895 md_convert_frag (abfd, sec, fragP)
1896 bfd * abfd;
1897 segT sec;
1898 register fragS * fragP;
1899 {
1900 unsigned char * buffer;
1901 int targ_addr = S_GET_VALUE (fragP->fr_symbol) + fragP->fr_offset;
1902
1903 buffer = (unsigned char *) (fragP->fr_fix + fragP->fr_literal);
1904 targ_addr += symbol_get_frag (fragP->fr_symbol)->fr_address;
1905
1906 switch (fragP->fr_subtype)
1907 {
1908 case C (COND_JUMP, COND12):
1909 case C (UNCD_JUMP, UNCD12):
1910 {
1911 /* Get the address of the end of the instruction. */
1912 int next_inst = fragP->fr_fix + fragP->fr_address + 2;
1913 unsigned char t0;
1914 int disp = targ_addr - next_inst;
1915
1916 if (disp & 1)
1917 as_bad (_("odd displacement at %x"), next_inst - 2);
1918
1919 disp >>= 1;
1920
1921 if (! target_big_endian)
1922 {
1923 t0 = buffer[1] & 0xF8;
1924
1925 md_number_to_chars (buffer, disp, 2);
1926
1927 buffer[1] = (buffer[1] & 0x07) | t0;
1928 }
1929 else
1930 {
1931 t0 = buffer[0] & 0xF8;
1932
1933 md_number_to_chars (buffer, disp, 2);
1934
1935 buffer[0] = (buffer[0] & 0x07) | t0;
1936 }
1937
1938 fragP->fr_fix += 2;
1939 fragP->fr_var = 0;
1940 }
1941 break;
1942
1943 case C (COND_JUMP, COND32):
1944 case C (COND_JUMP, UNDEF_WORD_DISP):
1945 {
1946 /* A conditional branch wont fit into 12 bits so:
1947 * b!cond 1f
1948 * jmpi 0f
1949 * .align 2
1950 * 0: .long disp
1951 * 1:
1952 *
1953 * if the b!cond is 4 byte aligned, the literal which would
1954 * go at x+4 will also be aligned.
1955 */
1956 int first_inst = fragP->fr_fix + fragP->fr_address;
1957 int needpad = (first_inst & 3);
1958
1959 if (! target_big_endian)
1960 buffer[1] ^= 0x08;
1961 else
1962 buffer[0] ^= 0x08; /* Toggle T/F bit */
1963
1964 buffer[2] = INST_BYTE0 (MCORE_INST_JMPI); /* Build jmpi */
1965 buffer[3] = INST_BYTE1 (MCORE_INST_JMPI);
1966
1967 if (needpad)
1968 {
1969 if (! target_big_endian)
1970 {
1971 buffer[0] = 4; /* branch over jmpi, pad, and ptr */
1972 buffer[2] = 1; /* jmpi offset of 1 gets the pointer */
1973 }
1974 else
1975 {
1976 buffer[1] = 4; /* branch over jmpi, pad, and ptr */
1977 buffer[3] = 1; /* jmpi offset of 1 gets the pointer */
1978 }
1979
1980 buffer[4] = 0; /* alignment/pad */
1981 buffer[5] = 0;
1982 buffer[6] = 0; /* space for 32 bit address */
1983 buffer[7] = 0;
1984 buffer[8] = 0;
1985 buffer[9] = 0;
1986
1987 /* Make reloc for the long disp */
1988 fix_new (fragP, fragP->fr_fix + 6, 4,
1989 fragP->fr_symbol, fragP->fr_offset, 0, BFD_RELOC_32);
1990
1991 fragP->fr_fix += C32_LEN;
1992 }
1993 else
1994 {
1995 /* See comment below about this given gas' limitations for
1996 shrinking the fragment. '3' is the amount of code that
1997 we inserted here, but '4' is right for the space we reserved
1998 for this fragment. */
1999 if (! target_big_endian)
2000 {
2001 buffer[0] = 3; /* branch over jmpi, and ptr */
2002 buffer[2] = 0; /* jmpi offset of 0 gets the pointer */
2003 }
2004 else
2005 {
2006 buffer[1] = 3; /* branch over jmpi, and ptr */
2007 buffer[3] = 0; /* jmpi offset of 0 gets the pointer */
2008 }
2009
2010 buffer[4] = 0; /* space for 32 bit address */
2011 buffer[5] = 0;
2012 buffer[6] = 0;
2013 buffer[7] = 0;
2014
2015 /* Make reloc for the long disp. */
2016 fix_new (fragP, fragP->fr_fix + 4, 4,
2017 fragP->fr_symbol, fragP->fr_offset, 0, BFD_RELOC_32);
2018 fragP->fr_fix += C32_LEN;
2019
2020 /* Frag is actually shorter (see the other side of this ifdef)
2021 but gas isn't prepared for that. We have to re-adjust
2022 the branch displacement so that it goes beyond the
2023 full length of the fragment, not just what we actually
2024 filled in. */
2025 if (! target_big_endian)
2026 buffer[0] = 4; /* jmpi, ptr, and the 'tail pad' */
2027 else
2028 buffer[1] = 4; /* jmpi, ptr, and the 'tail pad' */
2029 }
2030
2031 fragP->fr_var = 0;
2032 }
2033 break;
2034
2035 case C (UNCD_JUMP, UNCD32):
2036 case C (UNCD_JUMP, UNDEF_WORD_DISP):
2037 {
2038 /* An unconditional branch will not fit in 12 bits, make code which
2039 looks like:
2040 jmpi 0f
2041 .align 2
2042 0: .long disp
2043 we need a pad if "first_inst" is 4 byte aligned.
2044 [because the natural literal place is x + 2] */
2045 int first_inst = fragP->fr_fix + fragP->fr_address;
2046 int needpad = !(first_inst & 3);
2047
2048 buffer[0] = INST_BYTE0 (MCORE_INST_JMPI); /* Build jmpi */
2049 buffer[1] = INST_BYTE1 (MCORE_INST_JMPI);
2050
2051 if (needpad)
2052 {
2053 if (! target_big_endian)
2054 buffer[0] = 1; /* jmpi offset of 1 since padded */
2055 else
2056 buffer[1] = 1; /* jmpi offset of 1 since padded */
2057 buffer[2] = 0; /* alignment */
2058 buffer[3] = 0;
2059 buffer[4] = 0; /* space for 32 bit address */
2060 buffer[5] = 0;
2061 buffer[6] = 0;
2062 buffer[7] = 0;
2063
2064 /* Make reloc for the long disp. */
2065 fix_new (fragP, fragP->fr_fix + 4, 4,
2066 fragP->fr_symbol, fragP->fr_offset, 0, BFD_RELOC_32);
2067
2068 fragP->fr_fix += U32_LEN;
2069 }
2070 else
2071 {
2072 if (! target_big_endian)
2073 buffer[0] = 0; /* jmpi offset of 0 if no pad */
2074 else
2075 buffer[1] = 0; /* jmpi offset of 0 if no pad */
2076 buffer[2] = 0; /* space for 32 bit address */
2077 buffer[3] = 0;
2078 buffer[4] = 0;
2079 buffer[5] = 0;
2080
2081 /* Make reloc for the long disp. */
2082 fix_new (fragP, fragP->fr_fix + 2, 4,
2083 fragP->fr_symbol, fragP->fr_offset, 0, BFD_RELOC_32);
2084 fragP->fr_fix += U32_LEN;
2085 }
2086
2087 fragP->fr_var = 0;
2088 }
2089 break;
2090
2091 default:
2092 abort ();
2093 }
2094 }
2095
2096 /* Applies the desired value to the specified location.
2097 Also sets up addends for 'rela' type relocations. */
2098 int
2099 md_apply_fix3 (fixP, valp, segment)
2100 fixS * fixP;
2101 valueT * valp;
2102 segT segment;
2103 {
2104 char * buf = fixP->fx_where + fixP->fx_frag->fr_literal;
2105 char * file = fixP->fx_file ? fixP->fx_file : _("unknown");
2106 const char * symname;
2107 /* Note: use offsetT because it is signed, valueT is unsigned. */
2108 offsetT val = (offsetT) * valp;
2109
2110 symname = fixP->fx_addsy ? S_GET_NAME (fixP->fx_addsy) : _("<unknown>");
2111 /* Save this for the addend in the relocation record. */
2112 fixP->fx_addnumber = val;
2113
2114 /* If the fix is relative to a symbol which is not defined, or not
2115 in the same segment as the fix, we cannot resolve it here. */
2116 if (fixP->fx_addsy != NULL
2117 && ( ! S_IS_DEFINED (fixP->fx_addsy)
2118 || (S_GET_SEGMENT (fixP->fx_addsy) != segment)))
2119 {
2120 fixP->fx_done = 0;
2121 #ifdef OBJ_ELF
2122 /* For ELF we can just return and let the reloc that will be generated
2123 take care of everything. For COFF we still have to insert 'val'
2124 into the insn since the addend field will be ignored. */
2125 return 0;
2126 #endif
2127 }
2128 else
2129 fixP->fx_done = 1;
2130
2131 switch (fixP->fx_r_type)
2132 {
2133 case BFD_RELOC_MCORE_PCREL_IMM11BY2: /* second byte of 2 byte opcode */
2134 if ((val & 1) != 0)
2135 as_bad_where (file, fixP->fx_line,
2136 _("odd distance branch (0x%x bytes)"), val);
2137 val /= 2;
2138 if (((val & ~0x3ff) != 0) && ((val | 0x3ff) != -1))
2139 as_bad_where (file, fixP->fx_line,
2140 _("pcrel for branch to %s too far (0x%x)"),
2141 symname, val);
2142 if (target_big_endian)
2143 {
2144 buf[0] |= ((val >> 8) & 0x7);
2145 buf[1] |= (val & 0xff);
2146 }
2147 else
2148 {
2149 buf[1] |= ((val >> 8) & 0x7);
2150 buf[0] |= (val & 0xff);
2151 }
2152 break;
2153
2154 case BFD_RELOC_MCORE_PCREL_IMM8BY4: /* lower 8 bits of 2 byte opcode */
2155 val += 3;
2156 val /= 4;
2157 if (val & ~0xff)
2158 as_bad_where (file, fixP->fx_line,
2159 _("pcrel for lrw/jmpi/jsri to %s too far (0x%x)"),
2160 symname, val);
2161 else if (! target_big_endian)
2162 buf[0] |= (val & 0xff);
2163 else
2164 buf[1] |= (val & 0xff);
2165 break;
2166
2167 case BFD_RELOC_MCORE_PCREL_IMM4BY2: /* loopt instruction */
2168 if ((val < -32) || (val > -2))
2169 as_bad_where (file, fixP->fx_line,
2170 _("pcrel for loopt too far (0x%x)"), val);
2171 val /= 2;
2172 if (! target_big_endian)
2173 buf[0] |= (val & 0xf);
2174 else
2175 buf[1] |= (val & 0xf);
2176 break;
2177
2178 case BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2:
2179 /* Conditional linker map jsri to bsr. */
2180 /* If its a local target and close enough, fix it.
2181 NB: >= -2k for backwards bsr; < 2k for forwards... */
2182 if (fixP->fx_addsy == 0 && val >= -2048 && val < 2048)
2183 {
2184 long nval = (val / 2) & 0x7ff;
2185 nval |= MCORE_INST_BSR;
2186
2187 /* REPLACE the instruction, don't just modify it. */
2188 buf[0] = INST_BYTE0 (nval);
2189 buf[1] = INST_BYTE1 (nval);
2190 }
2191 else
2192 fixP->fx_done = 0;
2193 break;
2194
2195 case BFD_RELOC_MCORE_PCREL_32:
2196 case BFD_RELOC_VTABLE_INHERIT:
2197 case BFD_RELOC_VTABLE_ENTRY:
2198 fixP->fx_done = 0;
2199 break;
2200
2201 default:
2202 if (fixP->fx_addsy != NULL)
2203 {
2204 /* If the fix is an absolute reloc based on a symbol's
2205 address, then it cannot be resolved until the final link. */
2206 fixP->fx_done = 0;
2207 }
2208 #ifdef OBJ_ELF
2209 else
2210 #endif
2211 {
2212 if (fixP->fx_size == 4)
2213 ;
2214 else if (fixP->fx_size == 2 && val >= -32768 && val <= 32767)
2215 ;
2216 else if (fixP->fx_size == 1 && val >= -256 && val <= 255)
2217 ;
2218 else
2219 abort ();
2220 md_number_to_chars (buf, val, fixP->fx_size);
2221 }
2222 break;
2223 }
2224
2225 return 0; /* Return value is ignored. */
2226 }
2227
2228 void
2229 md_operand (expressionP)
2230 expressionS * expressionP;
2231 {
2232 /* Ignore leading hash symbol, if poresent. */
2233 if (* input_line_pointer == '#')
2234 {
2235 input_line_pointer ++;
2236 expression (expressionP);
2237 }
2238 }
2239
2240 int md_long_jump_size;
2241
2242 /* Called just before address relaxation, return the length
2243 by which a fragment must grow to reach it's destination. */
2244 int
2245 md_estimate_size_before_relax (fragP, segment_type)
2246 register fragS * fragP;
2247 register segT segment_type;
2248 {
2249 switch (fragP->fr_subtype)
2250 {
2251 case C (UNCD_JUMP, UNDEF_DISP):
2252 /* Used to be a branch to somewhere which was unknown. */
2253 if (!fragP->fr_symbol)
2254 {
2255 fragP->fr_subtype = C (UNCD_JUMP, UNCD12);
2256 fragP->fr_var = md_relax_table[C (UNCD_JUMP, UNCD12)].rlx_length;
2257 }
2258 else if (S_GET_SEGMENT (fragP->fr_symbol) == segment_type)
2259 {
2260 fragP->fr_subtype = C (UNCD_JUMP, UNCD12);
2261 fragP->fr_var = md_relax_table[C (UNCD_JUMP, UNCD12)].rlx_length;
2262 }
2263 else
2264 {
2265 fragP->fr_subtype = C (UNCD_JUMP, UNDEF_WORD_DISP);
2266 fragP->fr_var = md_relax_table[C (UNCD_JUMP, UNCD32)].rlx_length;
2267 return md_relax_table[C (UNCD_JUMP, UNCD32)].rlx_length;
2268 }
2269 break;
2270
2271 default:
2272 abort ();
2273
2274 case C (COND_JUMP, UNDEF_DISP):
2275 /* Used to be a branch to somewhere which was unknown. */
2276 if (fragP->fr_symbol
2277 && S_GET_SEGMENT (fragP->fr_symbol) == segment_type)
2278 {
2279 /* Got a symbol and it's defined in this segment, become byte
2280 sized - maybe it will fix up */
2281 fragP->fr_subtype = C (COND_JUMP, COND12);
2282 fragP->fr_var = md_relax_table[C (COND_JUMP, COND12)].rlx_length;
2283 }
2284 else if (fragP->fr_symbol)
2285 {
2286 /* Its got a segment, but its not ours, so it will always be long. */
2287 fragP->fr_subtype = C (COND_JUMP, UNDEF_WORD_DISP);
2288 fragP->fr_var = md_relax_table[C (COND_JUMP, COND32)].rlx_length;
2289 return md_relax_table[C (COND_JUMP, COND32)].rlx_length;
2290 }
2291 else
2292 {
2293 /* We know the abs value. */
2294 fragP->fr_subtype = C (COND_JUMP, COND12);
2295 fragP->fr_var = md_relax_table[C (COND_JUMP, COND12)].rlx_length;
2296 }
2297
2298 break;
2299 }
2300
2301 return fragP->fr_var;
2302 }
2303
2304 /* Put number into target byte order. */
2305 void
2306 md_number_to_chars (ptr, use, nbytes)
2307 char * ptr;
2308 valueT use;
2309 int nbytes;
2310 {
2311 if (! target_big_endian)
2312 switch (nbytes)
2313 {
2314 case 4: ptr[3] = (use >> 24) & 0xff; /* fall through */
2315 case 3: ptr[2] = (use >> 16) & 0xff; /* fall through */
2316 case 2: ptr[1] = (use >> 8) & 0xff; /* fall through */
2317 case 1: ptr[0] = (use >> 0) & 0xff; break;
2318 default: abort ();
2319 }
2320 else
2321 switch (nbytes)
2322 {
2323 case 4: *ptr++ = (use >> 24) & 0xff; /* fall through */
2324 case 3: *ptr++ = (use >> 16) & 0xff; /* fall through */
2325 case 2: *ptr++ = (use >> 8) & 0xff; /* fall through */
2326 case 1: *ptr++ = (use >> 0) & 0xff; break;
2327 default: abort ();
2328 }
2329 }
2330
2331 /* Round up a section size to the appropriate boundary. */
2332 valueT
2333 md_section_align (segment, size)
2334 segT segment;
2335 valueT size;
2336 {
2337 return size; /* Byte alignment is fine */
2338 }
2339
2340
2341 /* The location from which a PC relative jump should be calculated,
2342 given a PC relative reloc. */
2343 long
2344 md_pcrel_from_section (fixp, sec)
2345 fixS * fixp;
2346 segT sec;
2347 {
2348 #ifdef OBJ_ELF
2349 /* If the symbol is undefined or defined in another section
2350 we leave the add number alone for the linker to fix it later.
2351 Only account for the PC pre-bump (which is 2 bytes on the MCore). */
2352 if (fixp->fx_addsy != (symbolS *) NULL
2353 && (! S_IS_DEFINED (fixp->fx_addsy)
2354 || (S_GET_SEGMENT (fixp->fx_addsy) != sec)))
2355
2356 {
2357 assert (fixp->fx_size == 2); /* must be an insn */
2358 return fixp->fx_size;
2359 }
2360 #endif
2361
2362 /* The case where we are going to resolve things... */
2363 return fixp->fx_size + fixp->fx_where + fixp->fx_frag->fr_address;
2364 }
2365
2366 #define F(SZ,PCREL) (((SZ) << 1) + (PCREL))
2367 #define MAP(SZ,PCREL,TYPE) case F (SZ, PCREL): code = (TYPE); break
2368
2369 arelent *
2370 tc_gen_reloc (section, fixp)
2371 asection * section;
2372 fixS * fixp;
2373 {
2374 arelent * rel;
2375 bfd_reloc_code_real_type code;
2376 int handled = 0;
2377
2378 switch (fixp->fx_r_type)
2379 {
2380 /* These confuse the size/pcrel macro approach. */
2381 case BFD_RELOC_VTABLE_INHERIT:
2382 case BFD_RELOC_VTABLE_ENTRY:
2383 case BFD_RELOC_MCORE_PCREL_IMM4BY2:
2384 case BFD_RELOC_MCORE_PCREL_IMM8BY4:
2385 case BFD_RELOC_MCORE_PCREL_IMM11BY2:
2386 case BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2:
2387 case BFD_RELOC_RVA:
2388 code = fixp->fx_r_type;
2389 break;
2390
2391 default:
2392 switch (F (fixp->fx_size, fixp->fx_pcrel))
2393 {
2394 MAP (1, 0, BFD_RELOC_8);
2395 MAP (2, 0, BFD_RELOC_16);
2396 MAP (4, 0, BFD_RELOC_32);
2397 MAP (1, 1, BFD_RELOC_8_PCREL);
2398 MAP (2, 1, BFD_RELOC_16_PCREL);
2399 MAP (4, 1, BFD_RELOC_32_PCREL);
2400 default:
2401 code = fixp->fx_r_type;
2402 as_bad (_("Can not do %d byte %srelocation"),
2403 fixp->fx_size,
2404 fixp->fx_pcrel ? _("pc-relative") : "");
2405 }
2406 break;
2407 }
2408
2409 rel = (arelent *) xmalloc (sizeof (arelent));
2410 rel->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
2411 *rel->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
2412 rel->address = fixp->fx_frag->fr_address + fixp->fx_where;
2413 /* Always pass the addend along! */
2414 rel->addend = fixp->fx_addnumber;
2415
2416 rel->howto = bfd_reloc_type_lookup (stdoutput, code);
2417
2418 if (rel->howto == NULL)
2419 {
2420 as_bad_where (fixp->fx_file, fixp->fx_line,
2421 _("Cannot represent relocation type %s"),
2422 bfd_get_reloc_code_name (code));
2423
2424 /* Set howto to a garbage value so that we can keep going. */
2425 rel->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_32);
2426 assert (rel->howto != NULL);
2427 }
2428
2429 return rel;
2430 }
2431
2432 #ifdef OBJ_ELF
2433 /* See whether we need to force a relocation into the output file.
2434 This is used to force out switch and PC relative relocations when
2435 relaxing. */
2436 int
2437 mcore_force_relocation (fix)
2438 fixS * fix;
2439 {
2440 if ( fix->fx_r_type == BFD_RELOC_VTABLE_INHERIT
2441 || fix->fx_r_type == BFD_RELOC_VTABLE_ENTRY
2442 || fix->fx_r_type == BFD_RELOC_RVA)
2443 return 1;
2444
2445 return 0;
2446 }
2447
2448 /* Return true if the fix can be handled by GAS, false if it must
2449 be passed through to the linker. */
2450 boolean
2451 mcore_fix_adjustable (fixP)
2452 fixS * fixP;
2453 {
2454 if (fixP->fx_addsy == NULL)
2455 return 1;
2456
2457 /* We need the symbol name for the VTABLE entries. */
2458 if ( fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
2459 || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
2460 return 0;
2461
2462 return 1;
2463 }
2464 #endif /* OBJ_ELF */
This page took 0.151405 seconds and 4 git commands to generate.