1 /* tc-mcore.c -- Assemble code for M*Core
2 Copyright 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
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)
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.
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
26 #include "../opcodes/mcore-opc.h"
27 #include "safe-ctype.h"
31 #include "elf/mcore.h"
35 #define streq(a,b) (strcmp (a, b) == 0)
38 /* Forward declarations for dumb compilers. */
39 static void mcore_s_literals
PARAMS ((int));
40 static void mcore_pool_count
PARAMS ((void (*) (int), int));
41 static void mcore_cons
PARAMS ((int));
42 static void mcore_float_cons
PARAMS ((int));
43 static void mcore_stringer
PARAMS ((int));
44 static void mcore_fill
PARAMS ((int));
45 static int log2
PARAMS ((unsigned int));
46 static char * parse_reg
PARAMS ((char *, unsigned *));
47 static char * parse_creg
PARAMS ((char *, unsigned *));
48 static char * parse_exp
PARAMS ((char *, expressionS
*));
49 static char * parse_rt
PARAMS ((char *, char **, int, expressionS
*));
50 static char * parse_imm
PARAMS ((char *, unsigned *, unsigned, unsigned));
51 static char * parse_mem
PARAMS ((char *, unsigned *, unsigned *, unsigned));
52 static char * parse_psrmod
PARAMS ((char *, unsigned *));
53 static void make_name
PARAMS ((char *, char *, int));
54 static int enter_literal
PARAMS ((expressionS
*, int));
55 static void dump_literals
PARAMS ((int));
56 static void check_literals
PARAMS ((int, int));
57 static void mcore_s_text
PARAMS ((int));
58 static void mcore_s_data
PARAMS ((int));
59 static void mcore_s_section
PARAMS ((int));
60 static void mcore_s_bss
PARAMS ((int));
62 static void mcore_s_comm
PARAMS ((int));
65 /* Several places in this file insert raw instructions into the
66 object. They should use MCORE_INST_XXX macros to get the opcodes
67 and then use these two macros to crack the MCORE_INST value into
68 the appropriate byte values. */
69 #define INST_BYTE0(x) (target_big_endian ? (((x) >> 8) & 0xFF) : ((x) & 0xFF))
70 #define INST_BYTE1(x) (target_big_endian ? ((x) & 0xFF) : (((x) >> 8) & 0xFF))
72 const char comment_chars
[] = "#/";
73 const char line_separator_chars
[] = ";";
74 const char line_comment_chars
[] = "#/";
76 const int md_reloc_size
= 8;
78 static int do_jsri2bsr
= 0; /* Change here from 1 by Cruess 19 August 97. */
79 static int sifilter_mode
= 0;
81 const char EXP_CHARS
[] = "eE";
83 /* Chars that mean this number is a floating point constant
86 const char FLT_CHARS
[] = "rRsSfFdDxXpP";
88 #define C(what,length) (((what) << 2) + (length))
89 #define GET_WHAT(x) ((x >> 2))
91 /* These are the two types of relaxable instruction */
98 #define UNDEF_WORD_DISP 3
101 #define C32_LEN 10 /* allow for align */
103 #define U32_LEN 8 /* allow for align */
114 /* Initialize the relax table. */
115 const relax_typeS md_relax_table
[] = {
122 { 0, 0, 0, 0 }, /* UNDEF_DISP */
123 { 2048, -2046, C12_LEN
, C(COND_JUMP
, DISP32
) }, /* DISP12 */
124 { 0, 0, C32_LEN
, 0 }, /* DISP32 */
125 { 0, 0, C32_LEN
, 0 }, /* UNDEF_WORD_DISP */
128 { 0, 0, 0, 0 }, /* UNDEF_DISP */
129 { 2048, -2046, U12_LEN
, C(UNCD_JUMP
, DISP32
) }, /* DISP12 */
130 { 0, 0, U32_LEN
, 0 }, /* DISP32 */
131 { 0, 0, U32_LEN
, 0 } /* UNDEF_WORD_DISP */
135 /* Literal pool data structures. */
138 unsigned short refcnt
;
139 unsigned char ispcrel
;
140 unsigned char unused
;
144 #define MAX_POOL_SIZE (1024/4)
145 static struct literal litpool
[MAX_POOL_SIZE
];
146 static unsigned poolsize
;
147 static unsigned poolnumber
;
148 static unsigned long poolspan
;
150 /* SPANPANIC: the point at which we get too scared and force a dump
151 of the literal pool, and perhaps put a branch in place.
153 1024 span of lrw/jmpi/jsri insn (actually span+1)
154 -2 possible alignment at the insn.
155 -2 possible alignment to get the table aligned.
156 -2 an inserted branch around the table.
158 at 1018, we might be in trouble.
159 -- so we have to be smaller than 1018 and since we deal with 2-byte
160 instructions, the next good choice is 1016.
161 -- Note we have a test case that fails when we've got 1018 here. */
162 #define SPANPANIC (1016) /* 1024 - 1 entry - 2 byte rounding. */
163 #define SPANCLOSE (900)
164 #define SPANEXIT (600)
165 static symbolS
* poolsym
; /* label for current pool. */
166 static char poolname
[8];
167 static struct hash_control
* opcode_hash_control
; /* Opcode mnemonics. */
169 /* This table describes all the machine specific pseudo-ops the assembler
170 has to support. The fields are:
171 Pseudo-op name without dot
172 Function to call to execute this pseudo-op
173 Integer arg to pass to the function. */
174 const pseudo_typeS md_pseudo_table
[] =
176 { "export", s_globl
, 0 },
177 { "import", s_ignore
, 0 },
178 { "literals", mcore_s_literals
, 0 },
179 { "page", listing_eject
, 0 },
181 /* The following are to intercept the placement of data into the text
182 section (eg addresses for a switch table), so that the space they
183 occupy can be taken into account when deciding whether or not to
184 dump the current literal pool.
185 XXX - currently we do not cope with the .space and .dcb.d directives. */
186 { "ascii", mcore_stringer
, 0 },
187 { "asciz", mcore_stringer
, 1 },
188 { "byte", mcore_cons
, 1 },
189 { "dc", mcore_cons
, 2 },
190 { "dc.b", mcore_cons
, 1 },
191 { "dc.d", mcore_float_cons
, 'd'},
192 { "dc.l", mcore_cons
, 4 },
193 { "dc.s", mcore_float_cons
, 'f'},
194 { "dc.w", mcore_cons
, 2 },
195 { "dc.x", mcore_float_cons
, 'x'},
196 { "double", mcore_float_cons
, 'd'},
197 { "float", mcore_float_cons
, 'f'},
198 { "hword", mcore_cons
, 2 },
199 { "int", mcore_cons
, 4 },
200 { "long", mcore_cons
, 4 },
201 { "octa", mcore_cons
, 16 },
202 { "quad", mcore_cons
, 8 },
203 { "short", mcore_cons
, 2 },
204 { "single", mcore_float_cons
, 'f'},
205 { "string", mcore_stringer
, 1 },
206 { "word", mcore_cons
, 2 },
207 { "fill", mcore_fill
, 0 },
209 /* Allow for the effect of section changes. */
210 { "text", mcore_s_text
, 0 },
211 { "data", mcore_s_data
, 0 },
212 { "bss", mcore_s_bss
, 1 },
214 { "comm", mcore_s_comm
, 0 },
216 { "section", mcore_s_section
, 0 },
217 { "section.s", mcore_s_section
, 0 },
218 { "sect", mcore_s_section
, 0 },
219 { "sect.s", mcore_s_section
, 0 },
225 mcore_s_literals (ignore
)
229 demand_empty_rest_of_line ();
232 /* Perform FUNC (ARG), and track number of bytes added to frag. */
235 mcore_pool_count (func
, arg
)
236 void (*func
) PARAMS ((int));
239 const fragS
*curr_frag
= frag_now
;
240 offsetT added
= -frag_now_fix_octets ();
244 while (curr_frag
!= frag_now
)
246 added
+= curr_frag
->fr_fix
;
247 curr_frag
= curr_frag
->fr_next
;
250 added
+= frag_now_fix_octets ();
258 if (now_seg
== text_section
)
259 mcore_pool_count (cons
, nbytes
);
263 /* In theory we ought to call check_literals (2,0) here in case
264 we need to dump the literal table. We cannot do this however,
265 as the directives that we are intercepting may be being used
266 to build a switch table, and we must not interfere with its
267 contents. Instead we cross our fingers and pray... */
271 mcore_float_cons (float_type
)
274 if (now_seg
== text_section
)
275 mcore_pool_count (float_cons
, float_type
);
277 float_cons (float_type
);
279 /* See the comment in mcore_cons () about calling check_literals.
280 It is unlikely that a switch table will be constructed using
281 floating point values, but it is still likely that an indexed
282 table of floating point constants is being created by these
283 directives, so again we must not interfere with their placement. */
287 mcore_stringer (append_zero
)
290 if (now_seg
== text_section
)
291 mcore_pool_count (stringer
, append_zero
);
293 stringer (append_zero
);
295 /* We call check_literals here in case a large number of strings are
296 being placed into the text section with a sequence of stringer
297 directives. In theory we could be upsetting something if these
298 strings are actually in an indexed table instead of referenced by
299 individual labels. Let us hope that that never happens. */
300 check_literals (2, 0);
307 if (now_seg
== text_section
)
308 mcore_pool_count (s_fill
, unused
);
312 check_literals (2, 0);
315 /* Handle the section changing pseudo-ops. These call through to the
316 normal implementations, but they dump the literal pool first. */
318 mcore_s_text (ignore
)
324 obj_elf_text (ignore
);
331 mcore_s_data (ignore
)
337 obj_elf_data (ignore
);
344 mcore_s_section (ignore
)
347 /* Scan forwards to find the name of the section. If the section
348 being switched to is ".line" then this is a DWARF1 debug section
349 which is arbitarily placed inside generated code. In this case
350 do not dump the literal pool because it is a) inefficient and
351 b) would require the generation of extra code to jump around the
353 char * ilp
= input_line_pointer
;
355 while (*ilp
!= 0 && ISSPACE (*ilp
))
358 if (strncmp (ilp
, ".line", 5) == 0
359 && (ISSPACE (ilp
[5]) || *ilp
== '\n' || *ilp
== '\r'))
365 obj_elf_section (ignore
);
368 obj_coff_section (ignore
);
373 mcore_s_bss (needs_align
)
378 s_lcomm_bytes (needs_align
);
383 mcore_s_comm (needs_align
)
388 obj_elf_common (needs_align
);
392 /* This function is called once, at assembler startup time. This should
393 set up all the tables, etc that the MD part of the assembler needs. */
397 const mcore_opcode_info
* opcode
;
398 char * prev_name
= "";
400 opcode_hash_control
= hash_new ();
402 /* Insert unique names into hash table */
403 for (opcode
= mcore_table
; opcode
->name
; opcode
++)
405 if (! streq (prev_name
, opcode
->name
))
407 prev_name
= opcode
->name
;
408 hash_insert (opcode_hash_control
, opcode
->name
, (char *) opcode
);
415 static expressionS immediate
; /* absolute expression */
417 /* Get a log2(val). */
432 /* Try to parse a reg name. */
438 /* Strip leading whitespace. */
439 while (ISSPACE (* s
))
442 if (TOLOWER (s
[0]) == 'r')
444 if (s
[1] == '1' && s
[2] >= '0' && s
[2] <= '5')
446 *reg
= 10 + s
[2] - '0';
450 if (s
[1] >= '0' && s
[1] <= '9')
456 else if ( TOLOWER (s
[0]) == 's'
457 && TOLOWER (s
[1]) == 'p'
464 as_bad (_("register expected, but saw '%.6s'"), s
);
498 /* Strip leading whitespace. */
499 while (ISSPACE (* s
))
502 if ((TOLOWER (s
[0]) == 'c' && TOLOWER (s
[1]) == 'r'))
504 if (s
[2] == '3' && s
[3] >= '0' && s
[3] <= '1')
506 *reg
= 30 + s
[3] - '0';
510 if (s
[2] == '2' && s
[3] >= '0' && s
[3] <= '9')
512 *reg
= 20 + s
[3] - '0';
516 if (s
[2] == '1' && s
[3] >= '0' && s
[3] <= '9')
518 *reg
= 10 + s
[3] - '0';
522 if (s
[2] >= '0' && s
[2] <= '9')
529 /* Look at alternate creg names before giving error. */
530 for (i
= 0; cregs
[i
].name
[0] != '\0'; i
++)
536 length
= strlen (cregs
[i
].name
);
538 for (j
= 0; j
< length
; j
++)
539 buf
[j
] = TOLOWER (s
[j
]);
541 if (strncmp (cregs
[i
].name
, buf
, length
) == 0)
543 *reg
= cregs
[i
].crnum
;
548 as_bad (_("control register expected, but saw '%.6s'"), s
);
554 parse_psrmod (s
, reg
)
560 static struct psrmods
570 { "af", 8 } /* Really 0 and non-combinable. */
573 for (i
= 0; i
< 2; i
++)
574 buf
[i
] = TOLOWER (s
[i
]);
576 for (i
= sizeof (psrmods
) / sizeof (psrmods
[0]); i
--;)
578 if (! strncmp (psrmods
[i
].name
, buf
, 2))
580 * reg
= psrmods
[i
].value
;
586 as_bad (_("bad/missing psr specifier"));
601 /* Skip whitespace. */
602 while (ISSPACE (* s
))
605 save
= input_line_pointer
;
606 input_line_pointer
= s
;
610 if (e
->X_op
== O_absent
)
611 as_bad (_("missing operand"));
613 new = input_line_pointer
;
614 input_line_pointer
= save
;
625 static const char hex
[] = "0123456789ABCDEF";
630 s
[3] = hex
[(n
>> 12) & 0xF];
631 s
[4] = hex
[(n
>> 8) & 0xF];
632 s
[5] = hex
[(n
>> 4) & 0xF];
633 s
[6] = hex
[(n
) & 0xF];
637 #define POOL_END_LABEL ".LE"
638 #define POOL_START_LABEL ".LS"
641 dump_literals (isforce
)
651 /* Must we branch around the literal table? */
657 make_name (brarname
, POOL_END_LABEL
, poolnumber
);
659 brarsym
= symbol_make (brarname
);
661 symbol_table_insert (brarsym
);
663 output
= frag_var (rs_machine_dependent
,
664 md_relax_table
[C (UNCD_JUMP
, DISP32
)].rlx_length
,
665 md_relax_table
[C (UNCD_JUMP
, DISP12
)].rlx_length
,
666 C (UNCD_JUMP
, 0), brarsym
, 0, 0);
667 output
[0] = INST_BYTE0 (MCORE_INST_BR
); /* br .+xxx */
668 output
[1] = INST_BYTE1 (MCORE_INST_BR
);
671 /* Make sure that the section is sufficiently aligned and that
672 the literal table is aligned within it. */
673 record_alignment (now_seg
, 2);
674 frag_align (2, 0, 0);
676 colon (S_GET_NAME (poolsym
));
678 for (i
= 0, p
= litpool
; i
< poolsize
; i
++, p
++)
679 emit_expr (& p
->e
, 4);
682 colon (S_GET_NAME (brarsym
));
688 check_literals (kind
, offset
)
694 /* SPANCLOSE and SPANEXIT are smaller numbers than SPANPANIC.
695 SPANPANIC means that we must dump now.
696 kind == 0 is any old instruction.
697 kind > 0 means we just had a control transfer instruction.
698 kind == 1 means within a function
699 kind == 2 means we just left a function
701 The dump_literals (1) call inserts a branch around the table, so
702 we first look to see if its a situation where we won't have to
703 insert a branch (e.g., the previous instruction was an unconditional
706 SPANPANIC is the point where we must dump a single-entry pool.
707 it accounts for alignments and an inserted branch.
708 the 'poolsize*2' accounts for the scenario where we do:
709 lrw r1,lit1; lrw r2,lit2; lrw r3,lit3
710 Note that the 'lit2' reference is 2 bytes further along
711 but the literal it references will be 4 bytes further along,
712 so we must consider the poolsize into this equation.
713 This is slightly over-cautious, but guarantees that we won't
714 panic because a relocation is too distant. */
716 if (poolspan
> SPANCLOSE
&& kind
> 0)
718 else if (poolspan
> SPANEXIT
&& kind
> 1)
720 else if (poolspan
>= (SPANPANIC
- poolsize
* 2))
725 enter_literal (e
, ispcrel
)
732 if (poolsize
>= MAX_POOL_SIZE
- 2)
734 /* The literal pool is as full as we can handle. We have
735 to be 2 entries shy of the 1024/4=256 entries because we
736 have to allow for the branch (2 bytes) and the alignment
737 (2 bytes before the first insn referencing the pool and
738 2 bytes before the pool itself) == 6 bytes, rounds up
745 /* Create new literal pool. */
746 if (++ poolnumber
> 0xFFFF)
747 as_fatal (_("more than 65K literal pools"));
749 make_name (poolname
, POOL_START_LABEL
, poolnumber
);
750 poolsym
= symbol_make (poolname
);
751 symbol_table_insert (poolsym
);
755 /* Search pool for value so we don't have duplicates. */
756 for (p
= litpool
, i
= 0; i
< poolsize
; i
++, p
++)
758 if (e
->X_op
== p
->e
.X_op
759 && e
->X_add_symbol
== p
->e
.X_add_symbol
760 && e
->X_add_number
== p
->e
.X_add_number
761 && ispcrel
== p
->ispcrel
)
769 p
->ispcrel
= ispcrel
;
777 /* Parse a literal specification. -- either new or old syntax.
778 old syntax: the user supplies the label and places the literal.
779 new syntax: we put it into the literal pool. */
781 parse_rt (s
, outputp
, ispcrel
, ep
)
791 /* Indicate nothing there. */
796 s
= parse_exp (s
+ 1, & e
);
801 as_bad (_("missing ']'"));
805 s
= parse_exp (s
, & e
);
807 n
= enter_literal (& e
, ispcrel
);
812 /* Create a reference to pool entry. */
814 e
.X_add_symbol
= poolsym
;
815 e
.X_add_number
= n
<< 2;
818 * outputp
= frag_more (2);
820 fix_new_exp (frag_now
, (*outputp
) - frag_now
->fr_literal
, 2, & e
, 1,
821 BFD_RELOC_MCORE_PCREL_IMM8BY4
);
827 parse_imm (s
, val
, min
, max
)
836 new = parse_exp (s
, & e
);
838 if (e
.X_op
== O_absent
)
839 ; /* An error message has already been emitted. */
840 else if (e
.X_op
!= O_constant
)
841 as_bad (_("operand must be a constant"));
842 else if (e
.X_add_number
< min
|| e
.X_add_number
> max
)
843 as_bad (_("operand must be absolute in range %d..%d, not %d"),
844 min
, max
, e
.X_add_number
);
846 * val
= e
.X_add_number
;
852 parse_mem (s
, reg
, off
, siz
)
862 while (ISSPACE (* s
))
867 s
= parse_reg (s
+ 1, reg
);
869 while (ISSPACE (* s
))
874 s
= parse_imm (s
+ 1, off
, 0, 63);
881 as_bad (_("operand must be a multiple of 4"));
888 as_bad (_("operand must be a multiple of 2"));
895 while (ISSPACE (* s
))
902 as_bad (_("base register expected"));
907 /* This is the guts of the machine-dependent assembler. STR points to a
908 machine dependent instruction. This function is supposed to emit
909 the frags/bytes it assembles to. */
917 mcore_opcode_info
* opcode
;
927 /* Drop leading whitespace. */
928 while (ISSPACE (* str
))
931 /* Find the op code end. */
932 for (op_start
= op_end
= str
;
933 nlen
< 20 && !is_end_of_line
[(unsigned char) *op_end
] && *op_end
!= ' ';
936 name
[nlen
] = op_start
[nlen
];
944 as_bad (_("can't find opcode "));
948 opcode
= (mcore_opcode_info
*) hash_find (opcode_hash_control
, name
);
951 as_bad (_("unknown opcode \"%s\""), name
);
958 switch (opcode
->opclass
)
961 output
= frag_more (2);
965 op_end
= parse_imm (op_end
+ 1, & reg
, 0, 3);
967 output
= frag_more (2);
971 op_end
= parse_reg (op_end
+ 1, & reg
);
973 output
= frag_more (2);
977 op_end
= parse_reg (op_end
+ 1, & reg
);
979 output
= frag_more (2);
980 /* In a sifilter mode, we emit this insn 2 times,
981 fixes problem of an interrupt during a jmp.. */
984 output
[0] = INST_BYTE0 (inst
);
985 output
[1] = INST_BYTE1 (inst
);
986 output
= frag_more (2);
991 op_end
= parse_reg (op_end
+ 1, & reg
);
994 as_bad (_("invalid register: r15 illegal"));
997 output
= frag_more (2);
1001 /* Replace with: bsr .+2 ; addi r15,6; jmp rx ; jmp rx */
1002 inst
= MCORE_INST_BSR
; /* with 0 displacement */
1003 output
[0] = INST_BYTE0 (inst
);
1004 output
[1] = INST_BYTE1 (inst
);
1006 output
= frag_more (2);
1007 inst
= MCORE_INST_ADDI
;
1008 inst
|= 15; /* addi r15,6 */
1009 inst
|= (6 - 1) << 4; /* over the jmp's */
1010 output
[0] = INST_BYTE0 (inst
);
1011 output
[1] = INST_BYTE1 (inst
);
1013 output
= frag_more (2);
1014 inst
= MCORE_INST_JMP
| reg
;
1015 output
[0] = INST_BYTE0 (inst
);
1016 output
[1] = INST_BYTE1 (inst
);
1018 output
= frag_more (2); /* 2nd emitted in fallthru */
1023 op_end
= parse_reg (op_end
+ 1, & reg
);
1026 /* Skip whitespace. */
1027 while (ISSPACE (* op_end
))
1032 op_end
= parse_creg (op_end
+ 1, & reg
);
1036 output
= frag_more (2);
1042 as_bad (_("M340 specific opcode used when assembling for M210"));
1045 /* drop through... */
1047 op_end
= parse_reg (op_end
+ 1, & reg
);
1050 /* Skip whitespace. */
1051 while (ISSPACE (* op_end
))
1054 if (* op_end
== ',')
1056 op_end
= parse_reg (op_end
+ 1, & reg
);
1060 as_bad (_("second operand missing"));
1062 output
= frag_more (2);
1065 case X1
: /* Handle both syntax-> xtrb- r1,rx OR xtrb- rx */
1066 op_end
= parse_reg (op_end
+ 1, & reg
);
1068 /* Skip whitespace. */
1069 while (ISSPACE (* op_end
))
1072 if (* op_end
== ',') /* xtrb- r1,rx */
1075 as_bad (_("destination register must be r1"));
1077 op_end
= parse_reg (op_end
+ 1, & reg
);
1081 output
= frag_more (2);
1084 case O1R1
: /* div- rx,r1 */
1085 op_end
= parse_reg (op_end
+ 1, & reg
);
1088 /* Skip whitespace. */
1089 while (ISSPACE (* op_end
))
1092 if (* op_end
== ',')
1094 op_end
= parse_reg (op_end
+ 1, & reg
);
1096 as_bad (_("source register must be r1"));
1099 as_bad (_("second operand missing"));
1101 output
= frag_more (2);
1105 op_end
= parse_reg (op_end
+ 1, & reg
);
1108 /* Skip whitespace. */
1109 while (ISSPACE (* op_end
))
1112 if (* op_end
== ',')
1114 op_end
= parse_imm (op_end
+ 1, & reg
, 1, 32);
1115 inst
|= (reg
- 1) << 4;
1118 as_bad (_("second operand missing"));
1120 output
= frag_more (2);
1124 op_end
= parse_reg (op_end
+ 1, & reg
);
1127 /* Skip whitespace. */
1128 while (ISSPACE (* op_end
))
1131 if (* op_end
== ',')
1133 op_end
= parse_imm (op_end
+ 1, & reg
, 0, 31);
1137 as_bad (_("second operand missing"));
1139 output
= frag_more (2);
1142 case OB2
: /* like OB, but arg is 2^n instead of n */
1143 op_end
= parse_reg (op_end
+ 1, & reg
);
1146 /* Skip whitespace. */
1147 while (ISSPACE (* op_end
))
1150 if (* op_end
== ',')
1152 op_end
= parse_imm (op_end
+ 1, & reg
, 1, 1 << 31);
1153 /* Further restrict the immediate to a power of two. */
1154 if ((reg
& (reg
- 1)) == 0)
1159 as_bad (_("immediate is not a power of two"));
1164 as_bad (_("second operand missing"));
1166 output
= frag_more (2);
1169 case OBRa
: /* Specific for bgeni: imm of 0->6 translate to movi. */
1172 op_end
= parse_reg (op_end
+ 1, & reg
);
1175 /* Skip whitespace. */
1176 while (ISSPACE (* op_end
))
1179 if (* op_end
== ',')
1181 op_end
= parse_imm (op_end
+ 1, & reg
, 0, 31);
1182 /* immediate values of 0 -> 6 translate to movi */
1185 inst
= (inst
& 0xF) | MCORE_INST_BGENI_ALT
;
1187 as_warn (_("translating bgeni to movi"));
1193 as_bad (_("second operand missing"));
1195 output
= frag_more (2);
1198 case OBR2
: /* like OBR, but arg is 2^n instead of n */
1199 op_end
= parse_reg (op_end
+ 1, & reg
);
1202 /* Skip whitespace. */
1203 while (ISSPACE (* op_end
))
1206 if (* op_end
== ',')
1208 op_end
= parse_imm (op_end
+ 1, & reg
, 1, 1 << 31);
1210 /* Further restrict the immediate to a power of two. */
1211 if ((reg
& (reg
- 1)) == 0)
1216 as_bad (_("immediate is not a power of two"));
1219 /* Immediate values of 0 -> 6 translate to movi. */
1222 inst
= (inst
& 0xF) | MCORE_INST_BGENI_ALT
;
1224 as_warn (_("translating mgeni to movi"));
1230 as_bad (_("second operand missing"));
1232 output
= frag_more (2);
1235 case OMa
: /* Specific for bmaski: imm 1->7 translate to movi. */
1238 op_end
= parse_reg (op_end
+ 1, & reg
);
1241 /* Skip whitespace. */
1242 while (ISSPACE (* op_end
))
1245 if (* op_end
== ',')
1247 op_end
= parse_imm (op_end
+ 1, & reg
, 1, 32);
1249 /* Immediate values of 1 -> 7 translate to movi. */
1252 inst
= (inst
& 0xF) | MCORE_INST_BMASKI_ALT
;
1253 reg
= (0x1 << reg
) - 1;
1256 as_warn (_("translating bmaski to movi"));
1261 inst
|= (reg
& 0x1F) << 4;
1265 as_bad (_("second operand missing"));
1267 output
= frag_more (2);
1271 op_end
= parse_reg (op_end
+ 1, & reg
);
1274 /* Skip whitespace. */
1275 while (ISSPACE (* op_end
))
1278 if (* op_end
== ',')
1280 op_end
= parse_imm (op_end
+ 1, & reg
, 1, 31);
1284 as_bad (_("second operand missing"));
1286 output
= frag_more (2);
1290 op_end
= parse_reg (op_end
+ 1, & reg
);
1293 /* Skip whitespace. */
1294 while (ISSPACE (* op_end
))
1297 if (* op_end
== ',')
1299 op_end
= parse_imm (op_end
+ 1, & reg
, 0, 0x7F);
1303 as_bad (_("second operand missing"));
1305 output
= frag_more (2);
1309 op_end
= parse_reg (op_end
+ 1, & reg
);
1312 /* Skip whitespace. */
1313 while (ISSPACE (* op_end
))
1316 if (* op_end
== ',')
1320 if ((inst
& 0x6000) == 0)
1322 else if ((inst
& 0x6000) == 0x4000)
1324 else if ((inst
& 0x6000) == 0x2000)
1327 op_end
= parse_mem (op_end
+ 1, & reg
, & off
, size
);
1330 as_bad (_("displacement too large (%d)"), off
);
1332 inst
|= (reg
) | (off
<< 4);
1335 as_bad (_("second operand missing"));
1337 output
= frag_more (2);
1341 op_end
= parse_reg (op_end
+ 1, & reg
);
1343 if (reg
== 0 || reg
== 15)
1344 as_bad (_("Invalid register: r0 and r15 illegal"));
1348 /* Skip whitespace. */
1349 while (ISSPACE (* op_end
))
1352 if (* op_end
== ',')
1354 /* parse_rt calls frag_more() for us. */
1355 input_line_pointer
= parse_rt (op_end
+ 1, & output
, 0, 0);
1356 op_end
= input_line_pointer
;
1360 as_bad (_("second operand missing"));
1361 output
= frag_more (2); /* save its space */
1366 input_line_pointer
= parse_rt (op_end
+ 1, & output
, 1, 0);
1367 /* parse_rt() calls frag_more() for us. */
1368 op_end
= input_line_pointer
;
1372 op_end
= parse_reg (op_end
+ 1, & reg
);
1374 if (reg
== 0 || reg
== 15)
1375 as_bad (_("bad starting register: r0 and r15 invalid"));
1379 /* Skip whitespace. */
1380 while (ISSPACE (* op_end
))
1383 if (* op_end
== '-')
1385 op_end
= parse_reg (op_end
+ 1, & reg
);
1388 as_bad (_("ending register must be r15"));
1390 /* Skip whitespace. */
1391 while (ISSPACE (* op_end
))
1395 if (* op_end
== ',')
1399 /* Skip whitespace. */
1400 while (ISSPACE (* op_end
))
1403 if (* op_end
== '(')
1405 op_end
= parse_reg (op_end
+ 1, & reg
);
1408 as_bad (_("bad base register: must be r0"));
1410 if (* op_end
== ')')
1414 as_bad (_("base register expected"));
1417 as_bad (_("second operand missing"));
1419 output
= frag_more (2);
1423 op_end
= parse_reg (op_end
+ 1, & reg
);
1426 as_fatal (_("first register must be r4"));
1428 /* Skip whitespace. */
1429 while (ISSPACE (* op_end
))
1432 if (* op_end
== '-')
1434 op_end
= parse_reg (op_end
+ 1, & reg
);
1437 as_fatal (_("last register must be r7"));
1439 /* Skip whitespace. */
1440 while (ISSPACE (* op_end
))
1443 if (* op_end
== ',')
1447 /* Skip whitespace. */
1448 while (ISSPACE (* op_end
))
1451 if (* op_end
== '(')
1453 op_end
= parse_reg (op_end
+ 1, & reg
);
1455 if (reg
>= 4 && reg
<= 7)
1456 as_fatal ("base register cannot be r4, r5, r6, or r7");
1460 /* Skip whitespace. */
1461 while (ISSPACE (* op_end
))
1464 if (* op_end
== ')')
1468 as_bad (_("base register expected"));
1471 as_bad (_("second operand missing"));
1474 as_bad (_("reg-reg expected"));
1476 output
= frag_more (2);
1480 input_line_pointer
= parse_exp (op_end
+ 1, & e
);
1481 op_end
= input_line_pointer
;
1483 output
= frag_more (2);
1485 fix_new_exp (frag_now
, output
-frag_now
->fr_literal
,
1486 2, & e
, 1, BFD_RELOC_MCORE_PCREL_IMM11BY2
);
1490 op_end
= parse_reg (op_end
+ 1, & reg
);
1493 /* Skip whitespace. */
1494 while (ISSPACE (* op_end
))
1497 if (* op_end
== ',')
1499 op_end
= parse_exp (op_end
+ 1, & e
);
1500 output
= frag_more (2);
1502 fix_new_exp (frag_now
, output
-frag_now
->fr_literal
,
1503 2, & e
, 1, BFD_RELOC_MCORE_PCREL_IMM4BY2
);
1507 as_bad (_("second operand missing"));
1508 output
= frag_more (2);
1513 input_line_pointer
= parse_exp (op_end
+ 1, & e
);
1514 op_end
= input_line_pointer
;
1516 output
= frag_var (rs_machine_dependent
,
1517 md_relax_table
[C (COND_JUMP
, DISP32
)].rlx_length
,
1518 md_relax_table
[C (COND_JUMP
, DISP12
)].rlx_length
,
1519 C (COND_JUMP
, 0), e
.X_add_symbol
, e
.X_add_number
, 0);
1524 input_line_pointer
= parse_exp (op_end
+ 1, & e
);
1525 op_end
= input_line_pointer
;
1527 output
= frag_var (rs_machine_dependent
,
1528 md_relax_table
[C (UNCD_JUMP
, DISP32
)].rlx_length
,
1529 md_relax_table
[C (UNCD_JUMP
, DISP12
)].rlx_length
,
1530 C (UNCD_JUMP
, 0), e
.X_add_symbol
, e
.X_add_number
, 0);
1535 inst
= MCORE_INST_JSRI
; /* jsri */
1536 input_line_pointer
= parse_rt (op_end
+ 1, & output
, 1, & e
);
1537 /* parse_rt() calls frag_more for us. */
1538 op_end
= input_line_pointer
;
1540 /* Only do this if we know how to do it ... */
1541 if (e
.X_op
!= O_absent
&& do_jsri2bsr
)
1543 /* Look at adding the R_PCREL_JSRIMM11BY2. */
1544 fix_new_exp (frag_now
, output
-frag_now
->fr_literal
,
1545 2, & e
, 1, BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2
);
1549 case RSI
: /* SI, but imm becomes 32-imm */
1550 op_end
= parse_reg (op_end
+ 1, & reg
);
1553 /* Skip whitespace. */
1554 while (ISSPACE (* op_end
))
1557 if (* op_end
== ',')
1559 op_end
= parse_imm (op_end
+ 1, & reg
, 1, 31);
1565 as_bad (_("second operand missing"));
1567 output
= frag_more (2);
1570 case DO21
: /* O2, dup rd, lit must be 1 */
1571 op_end
= parse_reg (op_end
+ 1, & reg
);
1575 /* Skip whitespace. */
1576 while (ISSPACE (* op_end
))
1579 if (* op_end
== ',')
1581 op_end
= parse_imm (op_end
+ 1, & reg
, 1, 31);
1584 as_bad (_("second operand must be 1"));
1587 as_bad (_("second operand missing"));
1589 output
= frag_more (2);
1593 op_end
= parse_reg (op_end
+ 1, & reg
);
1596 /* Skip whitespace. */
1597 while (ISSPACE (* op_end
))
1600 if (* op_end
== ',')
1602 op_end
= parse_imm (op_end
+ 1, & reg
, 1, 31);
1605 as_bad (_("zero used as immediate value"));
1610 as_bad (_("second operand missing"));
1612 output
= frag_more (2);
1618 as_bad (_("M340 specific opcode used when assembling for M210"));
1622 op_end
= parse_psrmod (op_end
+ 1, & reg
);
1624 /* Look for further selectors. */
1625 while (* op_end
== ',')
1629 op_end
= parse_psrmod (op_end
+ 1, & value
);
1632 as_bad (_("duplicated psr bit specifier"));
1638 as_bad (_("`af' must appear alone"));
1640 inst
|= (reg
& 0x7);
1641 output
= frag_more (2);
1645 as_bad (_("unimplemented opcode \"%s\""), name
);
1648 /* Drop whitespace after all the operands have been parsed. */
1649 while (ISSPACE (* op_end
))
1652 /* Give warning message if the insn has more operands than required. */
1653 if (strcmp (op_end
, opcode
->name
) && strcmp (op_end
, ""))
1654 as_warn (_("ignoring operands: %s "), op_end
);
1656 output
[0] = INST_BYTE0 (inst
);
1657 output
[1] = INST_BYTE1 (inst
);
1659 check_literals (opcode
->transfer
, isize
);
1663 md_undefined_symbol (name
)
1673 subseg_set (text_section
, 0);
1676 /* Various routines to kill one day. */
1677 /* Equal to MAX_PRECISION in atof-ieee.c */
1678 #define MAX_LITTLENUMS 6
1680 /* Turn a string in input_line_pointer into a floating point constant of type
1681 type, and store the appropriate bytes in *litP. The number of LITTLENUMS
1682 emitted is stored in *sizeP. An error message is returned, or NULL on OK.*/
1684 md_atof (type
, litP
, sizeP
)
1690 LITTLENUM_TYPE words
[MAX_LITTLENUMS
];
1693 char * atof_ieee ();
1723 return _("Bad call to MD_NTOF()");
1726 t
= atof_ieee (input_line_pointer
, type
, words
);
1729 input_line_pointer
= t
;
1731 *sizeP
= prec
* sizeof (LITTLENUM_TYPE
);
1733 if (! target_big_endian
)
1735 for (i
= prec
- 1; i
>= 0; i
--)
1737 md_number_to_chars (litP
, (valueT
) words
[i
],
1738 sizeof (LITTLENUM_TYPE
));
1739 litP
+= sizeof (LITTLENUM_TYPE
);
1743 for (i
= 0; i
< prec
; i
++)
1745 md_number_to_chars (litP
, (valueT
) words
[i
],
1746 sizeof (LITTLENUM_TYPE
));
1747 litP
+= sizeof (LITTLENUM_TYPE
);
1753 const char * md_shortopts
= "";
1755 #define OPTION_JSRI2BSR_ON (OPTION_MD_BASE + 0)
1756 #define OPTION_JSRI2BSR_OFF (OPTION_MD_BASE + 1)
1757 #define OPTION_SIFILTER_ON (OPTION_MD_BASE + 2)
1758 #define OPTION_SIFILTER_OFF (OPTION_MD_BASE + 3)
1759 #define OPTION_CPU (OPTION_MD_BASE + 4)
1760 #define OPTION_EB (OPTION_MD_BASE + 5)
1761 #define OPTION_EL (OPTION_MD_BASE + 6)
1763 struct option md_longopts
[] =
1765 { "no-jsri2bsr", no_argument
, NULL
, OPTION_JSRI2BSR_OFF
},
1766 { "jsri2bsr", no_argument
, NULL
, OPTION_JSRI2BSR_ON
},
1767 { "sifilter", no_argument
, NULL
, OPTION_SIFILTER_ON
},
1768 { "no-sifilter", no_argument
, NULL
, OPTION_SIFILTER_OFF
},
1769 { "cpu", required_argument
, NULL
, OPTION_CPU
},
1770 { "EB", no_argument
, NULL
, OPTION_EB
},
1771 { "EL", no_argument
, NULL
, OPTION_EL
},
1772 { NULL
, no_argument
, NULL
, 0}
1775 size_t md_longopts_size
= sizeof (md_longopts
);
1778 md_parse_option (c
, arg
)
1788 if (streq (arg
, "210"))
1791 target_big_endian
= 1;
1793 else if (streq (arg
, "340"))
1796 as_warn (_("unrecognised cpu type '%s'"), arg
);
1799 case OPTION_EB
: target_big_endian
= 1; break;
1800 case OPTION_EL
: target_big_endian
= 0; cpu
= M340
; break;
1801 case OPTION_JSRI2BSR_ON
: do_jsri2bsr
= 1; break;
1802 case OPTION_JSRI2BSR_OFF
: do_jsri2bsr
= 0; break;
1803 case OPTION_SIFILTER_ON
: sifilter_mode
= 1; break;
1804 case OPTION_SIFILTER_OFF
: sifilter_mode
= 0; break;
1812 md_show_usage (stream
)
1815 fprintf (stream
, _("\
1816 MCORE specific options:\n\
1817 -{no-}jsri2bsr {dis}able jsri to bsr transformation (def: dis)\n\
1818 -{no-}sifilter {dis}able silicon filter behavior (def: dis)\n\
1819 -cpu=[210|340] select CPU type\n\
1820 -EB assemble for a big endian system (default)\n\
1821 -EL assemble for a little endian system\n"));
1824 int md_short_jump_size
;
1827 md_create_short_jump (ptr
, from_Nddr
, to_Nddr
, frag
, to_symbol
)
1832 symbolS
* to_symbol
;
1834 as_fatal (_("failed sanity check: short_jump"));
1838 md_create_long_jump (ptr
, from_Nddr
, to_Nddr
, frag
, to_symbol
)
1843 symbolS
* to_symbol
;
1845 as_fatal (_("failed sanity check: long_jump"));
1848 /* Called after relaxing, change the frags so they know how big they are. */
1850 md_convert_frag (abfd
, sec
, fragP
)
1853 register fragS
* fragP
;
1855 unsigned char * buffer
;
1856 int targ_addr
= S_GET_VALUE (fragP
->fr_symbol
) + fragP
->fr_offset
;
1858 buffer
= (unsigned char *) (fragP
->fr_fix
+ fragP
->fr_literal
);
1860 switch (fragP
->fr_subtype
)
1862 case C (COND_JUMP
, DISP12
):
1863 case C (UNCD_JUMP
, DISP12
):
1865 /* Get the address of the end of the instruction. */
1866 int next_inst
= fragP
->fr_fix
+ fragP
->fr_address
+ 2;
1868 int disp
= targ_addr
- next_inst
;
1871 as_bad (_("odd displacement at %x"), next_inst
- 2);
1875 if (! target_big_endian
)
1877 t0
= buffer
[1] & 0xF8;
1879 md_number_to_chars (buffer
, disp
, 2);
1881 buffer
[1] = (buffer
[1] & 0x07) | t0
;
1885 t0
= buffer
[0] & 0xF8;
1887 md_number_to_chars (buffer
, disp
, 2);
1889 buffer
[0] = (buffer
[0] & 0x07) | t0
;
1896 case C (COND_JUMP
, DISP32
):
1897 case C (COND_JUMP
, UNDEF_WORD_DISP
):
1899 /* A conditional branch wont fit into 12 bits so:
1906 * if the b!cond is 4 byte aligned, the literal which would
1907 * go at x+4 will also be aligned.
1909 int first_inst
= fragP
->fr_fix
+ fragP
->fr_address
;
1910 int needpad
= (first_inst
& 3);
1912 if (! target_big_endian
)
1915 buffer
[0] ^= 0x08; /* Toggle T/F bit */
1917 buffer
[2] = INST_BYTE0 (MCORE_INST_JMPI
); /* Build jmpi */
1918 buffer
[3] = INST_BYTE1 (MCORE_INST_JMPI
);
1922 if (! target_big_endian
)
1924 buffer
[0] = 4; /* branch over jmpi, pad, and ptr */
1925 buffer
[2] = 1; /* jmpi offset of 1 gets the pointer */
1929 buffer
[1] = 4; /* branch over jmpi, pad, and ptr */
1930 buffer
[3] = 1; /* jmpi offset of 1 gets the pointer */
1933 buffer
[4] = 0; /* alignment/pad */
1935 buffer
[6] = 0; /* space for 32 bit address */
1940 /* Make reloc for the long disp */
1941 fix_new (fragP
, fragP
->fr_fix
+ 6, 4,
1942 fragP
->fr_symbol
, fragP
->fr_offset
, 0, BFD_RELOC_32
);
1944 fragP
->fr_fix
+= C32_LEN
;
1948 /* See comment below about this given gas' limitations for
1949 shrinking the fragment. '3' is the amount of code that
1950 we inserted here, but '4' is right for the space we reserved
1951 for this fragment. */
1952 if (! target_big_endian
)
1954 buffer
[0] = 3; /* branch over jmpi, and ptr */
1955 buffer
[2] = 0; /* jmpi offset of 0 gets the pointer */
1959 buffer
[1] = 3; /* branch over jmpi, and ptr */
1960 buffer
[3] = 0; /* jmpi offset of 0 gets the pointer */
1963 buffer
[4] = 0; /* space for 32 bit address */
1968 /* Make reloc for the long disp. */
1969 fix_new (fragP
, fragP
->fr_fix
+ 4, 4,
1970 fragP
->fr_symbol
, fragP
->fr_offset
, 0, BFD_RELOC_32
);
1971 fragP
->fr_fix
+= C32_LEN
;
1973 /* Frag is actually shorter (see the other side of this ifdef)
1974 but gas isn't prepared for that. We have to re-adjust
1975 the branch displacement so that it goes beyond the
1976 full length of the fragment, not just what we actually
1978 if (! target_big_endian
)
1979 buffer
[0] = 4; /* jmpi, ptr, and the 'tail pad' */
1981 buffer
[1] = 4; /* jmpi, ptr, and the 'tail pad' */
1986 case C (UNCD_JUMP
, DISP32
):
1987 case C (UNCD_JUMP
, UNDEF_WORD_DISP
):
1989 /* An unconditional branch will not fit in 12 bits, make code which
1994 we need a pad if "first_inst" is 4 byte aligned.
1995 [because the natural literal place is x + 2] */
1996 int first_inst
= fragP
->fr_fix
+ fragP
->fr_address
;
1997 int needpad
= !(first_inst
& 3);
1999 buffer
[0] = INST_BYTE0 (MCORE_INST_JMPI
); /* Build jmpi */
2000 buffer
[1] = INST_BYTE1 (MCORE_INST_JMPI
);
2004 if (! target_big_endian
)
2005 buffer
[0] = 1; /* jmpi offset of 1 since padded */
2007 buffer
[1] = 1; /* jmpi offset of 1 since padded */
2008 buffer
[2] = 0; /* alignment */
2010 buffer
[4] = 0; /* space for 32 bit address */
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
);
2019 fragP
->fr_fix
+= U32_LEN
;
2023 if (! target_big_endian
)
2024 buffer
[0] = 0; /* jmpi offset of 0 if no pad */
2026 buffer
[1] = 0; /* jmpi offset of 0 if no pad */
2027 buffer
[2] = 0; /* space for 32 bit address */
2032 /* Make reloc for the long disp. */
2033 fix_new (fragP
, fragP
->fr_fix
+ 2, 4,
2034 fragP
->fr_symbol
, fragP
->fr_offset
, 0, BFD_RELOC_32
);
2035 fragP
->fr_fix
+= U32_LEN
;
2045 /* Applies the desired value to the specified location.
2046 Also sets up addends for 'rela' type relocations. */
2049 md_apply_fix3 (fixP
, valP
, segment
)
2054 char * buf
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
2055 char * file
= fixP
->fx_file
? fixP
->fx_file
: _("unknown");
2056 const char * symname
;
2057 /* Note: use offsetT because it is signed, valueT is unsigned. */
2058 offsetT val
= *valP
;
2060 symname
= fixP
->fx_addsy
? S_GET_NAME (fixP
->fx_addsy
) : _("<unknown>");
2061 /* Save this for the addend in the relocation record. */
2062 fixP
->fx_addnumber
= val
;
2064 if (fixP
->fx_addsy
!= NULL
)
2067 /* For ELF we can just return and let the reloc that will be generated
2068 take care of everything. For COFF we still have to insert 'val'
2069 into the insn since the addend field will be ignored. */
2076 switch (fixP
->fx_r_type
)
2078 case BFD_RELOC_MCORE_PCREL_IMM11BY2
: /* second byte of 2 byte opcode */
2080 as_bad_where (file
, fixP
->fx_line
,
2081 _("odd distance branch (0x%x bytes)"), val
);
2083 if (((val
& ~0x3ff) != 0) && ((val
| 0x3ff) != -1))
2084 as_bad_where (file
, fixP
->fx_line
,
2085 _("pcrel for branch to %s too far (0x%x)"),
2087 if (target_big_endian
)
2089 buf
[0] |= ((val
>> 8) & 0x7);
2090 buf
[1] |= (val
& 0xff);
2094 buf
[1] |= ((val
>> 8) & 0x7);
2095 buf
[0] |= (val
& 0xff);
2099 case BFD_RELOC_MCORE_PCREL_IMM8BY4
: /* lower 8 bits of 2 byte opcode */
2103 as_bad_where (file
, fixP
->fx_line
,
2104 _("pcrel for lrw/jmpi/jsri to %s too far (0x%x)"),
2106 else if (! target_big_endian
)
2107 buf
[0] |= (val
& 0xff);
2109 buf
[1] |= (val
& 0xff);
2112 case BFD_RELOC_MCORE_PCREL_IMM4BY2
: /* loopt instruction */
2113 if ((val
< -32) || (val
> -2))
2114 as_bad_where (file
, fixP
->fx_line
,
2115 _("pcrel for loopt too far (0x%x)"), val
);
2117 if (! target_big_endian
)
2118 buf
[0] |= (val
& 0xf);
2120 buf
[1] |= (val
& 0xf);
2123 case BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2
:
2124 /* Conditional linker map jsri to bsr. */
2125 /* If its a local target and close enough, fix it.
2126 NB: >= -2k for backwards bsr; < 2k for forwards... */
2127 if (fixP
->fx_addsy
== 0 && val
>= -2048 && val
< 2048)
2129 long nval
= (val
/ 2) & 0x7ff;
2130 nval
|= MCORE_INST_BSR
;
2132 /* REPLACE the instruction, don't just modify it. */
2133 buf
[0] = INST_BYTE0 (nval
);
2134 buf
[1] = INST_BYTE1 (nval
);
2140 case BFD_RELOC_MCORE_PCREL_32
:
2141 case BFD_RELOC_VTABLE_INHERIT
:
2142 case BFD_RELOC_VTABLE_ENTRY
:
2147 if (fixP
->fx_addsy
!= NULL
)
2149 /* If the fix is an absolute reloc based on a symbol's
2150 address, then it cannot be resolved until the final link. */
2157 if (fixP
->fx_size
== 4)
2159 else if (fixP
->fx_size
== 2 && val
>= -32768 && val
<= 32767)
2161 else if (fixP
->fx_size
== 1 && val
>= -256 && val
<= 255)
2165 md_number_to_chars (buf
, val
, fixP
->fx_size
);
2172 md_operand (expressionP
)
2173 expressionS
* expressionP
;
2175 /* Ignore leading hash symbol, if poresent. */
2176 if (* input_line_pointer
== '#')
2178 input_line_pointer
++;
2179 expression (expressionP
);
2183 int md_long_jump_size
;
2185 /* Called just before address relaxation, return the length
2186 by which a fragment must grow to reach it's destination. */
2188 md_estimate_size_before_relax (fragP
, segment_type
)
2189 register fragS
* fragP
;
2190 register segT segment_type
;
2192 switch (fragP
->fr_subtype
)
2197 case C (UNCD_JUMP
, UNDEF_DISP
):
2198 /* Used to be a branch to somewhere which was unknown. */
2199 if (!fragP
->fr_symbol
)
2201 fragP
->fr_subtype
= C (UNCD_JUMP
, DISP12
);
2203 else if (S_GET_SEGMENT (fragP
->fr_symbol
) == segment_type
)
2205 fragP
->fr_subtype
= C (UNCD_JUMP
, DISP12
);
2209 fragP
->fr_subtype
= C (UNCD_JUMP
, UNDEF_WORD_DISP
);
2213 case C (COND_JUMP
, UNDEF_DISP
):
2214 /* Used to be a branch to somewhere which was unknown. */
2215 if (fragP
->fr_symbol
2216 && S_GET_SEGMENT (fragP
->fr_symbol
) == segment_type
)
2218 /* Got a symbol and it's defined in this segment, become byte
2219 sized - maybe it will fix up */
2220 fragP
->fr_subtype
= C (COND_JUMP
, DISP12
);
2222 else if (fragP
->fr_symbol
)
2224 /* Its got a segment, but its not ours, so it will always be long. */
2225 fragP
->fr_subtype
= C (COND_JUMP
, UNDEF_WORD_DISP
);
2229 /* We know the abs value. */
2230 fragP
->fr_subtype
= C (COND_JUMP
, DISP12
);
2234 case C (UNCD_JUMP
, DISP12
):
2235 case C (UNCD_JUMP
, DISP32
):
2236 case C (UNCD_JUMP
, UNDEF_WORD_DISP
):
2237 case C (COND_JUMP
, DISP12
):
2238 case C (COND_JUMP
, DISP32
):
2239 case C (COND_JUMP
, UNDEF_WORD_DISP
):
2240 /* When relaxing a section for the second time, we don't need to
2241 do anything besides return the current size. */
2245 return md_relax_table
[fragP
->fr_subtype
].rlx_length
;
2248 /* Put number into target byte order. */
2250 md_number_to_chars (ptr
, use
, nbytes
)
2255 if (! target_big_endian
)
2258 case 4: ptr
[3] = (use
>> 24) & 0xff; /* fall through */
2259 case 3: ptr
[2] = (use
>> 16) & 0xff; /* fall through */
2260 case 2: ptr
[1] = (use
>> 8) & 0xff; /* fall through */
2261 case 1: ptr
[0] = (use
>> 0) & 0xff; break;
2267 case 4: *ptr
++ = (use
>> 24) & 0xff; /* fall through */
2268 case 3: *ptr
++ = (use
>> 16) & 0xff; /* fall through */
2269 case 2: *ptr
++ = (use
>> 8) & 0xff; /* fall through */
2270 case 1: *ptr
++ = (use
>> 0) & 0xff; break;
2275 /* Round up a section size to the appropriate boundary. */
2277 md_section_align (segment
, size
)
2281 return size
; /* Byte alignment is fine */
2284 /* The location from which a PC relative jump should be calculated,
2285 given a PC relative reloc. */
2287 md_pcrel_from_section (fixp
, sec
)
2292 /* If the symbol is undefined or defined in another section
2293 we leave the add number alone for the linker to fix it later.
2294 Only account for the PC pre-bump (which is 2 bytes on the MCore). */
2295 if (fixp
->fx_addsy
!= (symbolS
*) NULL
2296 && (! S_IS_DEFINED (fixp
->fx_addsy
)
2297 || (S_GET_SEGMENT (fixp
->fx_addsy
) != sec
)))
2300 assert (fixp
->fx_size
== 2); /* must be an insn */
2301 return fixp
->fx_size
;
2305 /* The case where we are going to resolve things... */
2306 return fixp
->fx_size
+ fixp
->fx_where
+ fixp
->fx_frag
->fr_address
;
2309 #define F(SZ,PCREL) (((SZ) << 1) + (PCREL))
2310 #define MAP(SZ,PCREL,TYPE) case F (SZ, PCREL): code = (TYPE); break
2313 tc_gen_reloc (section
, fixp
)
2318 bfd_reloc_code_real_type code
;
2321 switch (fixp
->fx_r_type
)
2323 /* These confuse the size/pcrel macro approach. */
2324 case BFD_RELOC_VTABLE_INHERIT
:
2325 case BFD_RELOC_VTABLE_ENTRY
:
2326 case BFD_RELOC_MCORE_PCREL_IMM4BY2
:
2327 case BFD_RELOC_MCORE_PCREL_IMM8BY4
:
2328 case BFD_RELOC_MCORE_PCREL_IMM11BY2
:
2329 case BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2
:
2331 code
= fixp
->fx_r_type
;
2335 switch (F (fixp
->fx_size
, fixp
->fx_pcrel
))
2337 MAP (1, 0, BFD_RELOC_8
);
2338 MAP (2, 0, BFD_RELOC_16
);
2339 MAP (4, 0, BFD_RELOC_32
);
2340 MAP (1, 1, BFD_RELOC_8_PCREL
);
2341 MAP (2, 1, BFD_RELOC_16_PCREL
);
2342 MAP (4, 1, BFD_RELOC_32_PCREL
);
2344 code
= fixp
->fx_r_type
;
2345 as_bad (_("Can not do %d byte %srelocation"),
2347 fixp
->fx_pcrel
? _("pc-relative") : "");
2352 rel
= (arelent
*) xmalloc (sizeof (arelent
));
2353 rel
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
2354 *rel
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
2355 rel
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
2356 /* Always pass the addend along! */
2357 rel
->addend
= fixp
->fx_addnumber
;
2359 rel
->howto
= bfd_reloc_type_lookup (stdoutput
, code
);
2361 if (rel
->howto
== NULL
)
2363 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2364 _("Cannot represent relocation type %s"),
2365 bfd_get_reloc_code_name (code
));
2367 /* Set howto to a garbage value so that we can keep going. */
2368 rel
->howto
= bfd_reloc_type_lookup (stdoutput
, BFD_RELOC_32
);
2369 assert (rel
->howto
!= NULL
);
2376 /* See whether we need to force a relocation into the output file.
2377 This is used to force out switch and PC relative relocations when
2380 mcore_force_relocation (fix
)
2383 if ( fix
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
2384 || fix
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
2385 || fix
->fx_r_type
== BFD_RELOC_RVA
)
2388 return S_FORCE_RELOC (fix
->fx_addsy
);
2391 /* Return true if the fix can be handled by GAS, false if it must
2392 be passed through to the linker. */
2394 mcore_fix_adjustable (fixP
)
2397 /* We need the symbol name for the VTABLE entries. */
2398 if ( fixP
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
2399 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
2404 #endif /* OBJ_ELF */