1 /* tc-cris.c -- Assembler code for the CRIS CPU core.
2 Copyright 2000, 2001, 2002, 2003, 2004, 2006, 2007
3 Free Software Foundation, Inc.
5 Contributed by Axis Communications AB, Lund, Sweden.
6 Originally written for GAS 1.38.1 by Mikael Asker.
7 Updates, BFDizing, GNUifying and ELF support by Hans-Peter Nilsson.
9 This file is part of GAS, the GNU Assembler.
11 GAS is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3, or (at your option)
16 GAS is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with GAS; see the file COPYING. If not, write to the
23 Free Software Foundation, 51 Franklin Street - Fifth Floor, Boston,
24 MA 02110-1301, USA. */
27 #include "safe-ctype.h"
29 #include "opcode/cris.h"
30 #include "dwarf2dbg.h"
32 /* Conventions used here:
33 Generally speaking, pointers to binutils types such as "fragS" and
34 "expressionS" get parameter and variable names ending in "P", such as
35 "fragP", to harmonize with the rest of the binutils code. Other
36 pointers get a "p" suffix, such as "bufp". Any function or type-name
37 that could clash with a current or future binutils or GAS function get
40 #define SYNTAX_RELAX_REG_PREFIX "no_register_prefix"
41 #define SYNTAX_ENFORCE_REG_PREFIX "register_prefix"
42 #define SYNTAX_USER_SYM_LEADING_UNDERSCORE "leading_underscore"
43 #define SYNTAX_USER_SYM_NO_LEADING_UNDERSCORE "no_leading_underscore"
44 #define REGISTER_PREFIX_CHAR '$'
46 /* True for expressions where getting X_add_symbol and X_add_number is
47 enough to get the "base" and "offset"; no need to make_expr_symbol.
48 It's not enough to check if X_op_symbol is NULL; that misses unary
49 operations like O_uminus. */
50 #define SIMPLE_EXPR(EXP) \
51 ((EXP)->X_op == O_constant || (EXP)->X_op == O_symbol)
53 /* Like in ":GOT", ":GOTOFF" etc. Other ports use '@', but that's in
54 line_separator_chars for CRIS, so we avoid it. */
55 #define RELOC_SUFFIX_CHAR ':'
57 /* This might be CRIS_INSN_NONE if we're assembling a prefix-insn only.
58 Note that some prefix-insns might be assembled as CRIS_INSN_NORMAL. */
61 CRIS_INSN_NORMAL
, CRIS_INSN_NONE
, CRIS_INSN_BRANCH
, CRIS_INSN_MUL
64 /* An instruction will have one of these prefixes.
65 Although the same bit-pattern, we handle BDAP with an immediate
66 expression (eventually quick or [pc+]) different from when we only have
67 register expressions. */
70 PREFIX_NONE
, PREFIX_BDAP_IMM
, PREFIX_BDAP
, PREFIX_BIAP
, PREFIX_DIP
,
74 /* The prefix for an instruction. */
77 enum prefix_kind kind
;
81 /* There might be an expression to be evaluated, like I in [rN+I]. */
84 /* If there's an expression, we might need a relocation. Here's the
85 type of what relocation to start relaxaton with.
86 The relocation is assumed to start immediately after the prefix insn,
87 so we don't provide an offset. */
88 enum bfd_reloc_code_real reloc
;
91 /* The description of the instruction being assembled. */
92 struct cris_instruction
94 /* If CRIS_INSN_NONE, then this insn is of zero length. */
95 enum cris_insn_kind insn_type
;
97 /* If a special register was mentioned, this is its description, else
99 const struct cris_spec_reg
*spec_reg
;
103 /* An insn may have at most one expression; theoretically there could be
104 another in its prefix (but I don't see how that could happen). */
107 /* The expression might need a relocation. Here's one to start
109 enum bfd_reloc_code_real reloc
;
111 /* The size in bytes of an immediate expression, or zero if
119 arch_crisv0
, arch_crisv3
, arch_crisv8
, arch_crisv10
,
120 arch_cris_any_v0_v10
, arch_crisv32
, arch_cris_common_v10_v32
123 static enum cris_archs
cris_arch_from_string (char **);
124 static int cris_insn_ver_valid_for_arch (enum cris_insn_version_usage
,
127 static void cris_process_instruction (char *, struct cris_instruction
*,
128 struct cris_prefix
*);
129 static int get_bwd_size_modifier (char **, int *);
130 static int get_bw_size_modifier (char **, int *);
131 static int get_gen_reg (char **, int *);
132 static int get_spec_reg (char **, const struct cris_spec_reg
**);
133 static int get_sup_reg (char **, int *);
134 static int get_autoinc_prefix_or_indir_op (char **, struct cris_prefix
*,
137 static int get_3op_or_dip_prefix_op (char **, struct cris_prefix
*);
138 static int cris_get_expression (char **, expressionS
*);
139 static int get_flags (char **, int *);
140 static void gen_bdap (int, expressionS
*);
141 static int branch_disp (int);
142 static void gen_cond_branch_32 (char *, char *, fragS
*, symbolS
*, symbolS
*,
144 static void cris_number_to_imm (char *, long, int, fixS
*, segT
);
145 static void cris_create_short_jump (char *, addressT
, addressT
, fragS
*,
147 static void s_syntax (int);
148 static void s_cris_file (int);
149 static void s_cris_loc (int);
150 static void s_cris_arch (int);
152 /* Get ":GOT", ":GOTOFF", ":PLT" etc. suffixes. */
153 static void cris_get_reloc_suffix (char **, bfd_reloc_code_real_type
*,
155 static unsigned int cris_get_specified_reloc_size (bfd_reloc_code_real_type
);
157 /* All the .syntax functions. */
158 static void cris_force_reg_prefix (void);
159 static void cris_relax_reg_prefix (void);
160 static void cris_sym_leading_underscore (void);
161 static void cris_sym_no_leading_underscore (void);
162 static char *cris_insn_first_word_frag (void);
164 /* Handle to the opcode hash table. */
165 static struct hash_control
*op_hash
= NULL
;
167 /* If we target cris-axis-linux-gnu (as opposed to generic cris-axis-elf),
168 we default to no underscore and required register-prefixes. The
169 difference is in the default values. */
171 #define DEFAULT_CRIS_AXIS_LINUX_GNU TRUE
173 #define DEFAULT_CRIS_AXIS_LINUX_GNU FALSE
176 /* Whether we demand that registers have a `$' prefix. Default here. */
177 static bfd_boolean demand_register_prefix
= DEFAULT_CRIS_AXIS_LINUX_GNU
;
179 /* Whether global user symbols have a leading underscore. Default here. */
180 static bfd_boolean symbols_have_leading_underscore
181 = !DEFAULT_CRIS_AXIS_LINUX_GNU
;
183 /* Whether or not we allow PIC, and expand to PIC-friendly constructs. */
184 static bfd_boolean pic
= FALSE
;
186 /* Whether or not we allow TLS suffixes. For the moment, we always do. */
187 static const bfd_boolean tls
= TRUE
;
189 /* If we're configured for "cris", default to allow all v0..v10
190 instructions and register names. */
191 #ifndef DEFAULT_CRIS_ARCH
192 #define DEFAULT_CRIS_ARCH cris_any_v0_v10
195 /* No whitespace in the CONCAT2 parameter list. */
196 static enum cris_archs cris_arch
= XCONCAT2 (arch_
,DEFAULT_CRIS_ARCH
);
198 const pseudo_typeS md_pseudo_table
[] =
201 {"syntax", s_syntax
, 0},
202 {"file", s_cris_file
, 0},
203 {"loc", s_cris_loc
, 0},
204 {"arch", s_cris_arch
, 0},
208 static int warn_for_branch_expansion
= 0;
210 /* Whether to emit error when a MULS/MULU could be located last on a
212 static int err_for_dangerous_mul_placement
213 = (XCONCAT2 (arch_
,DEFAULT_CRIS_ARCH
) != arch_crisv32
);
215 const char cris_comment_chars
[] = ";";
217 /* This array holds the chars that only start a comment at the beginning of
218 a line. If the line seems to have the form '# 123 filename'
219 .line and .file directives will appear in the pre-processed output. */
220 /* Note that input_file.c hand-checks for '#' at the beginning of the
221 first line of the input file. This is because the compiler outputs
222 #NO_APP at the beginning of its output. */
223 /* Also note that slash-star will always start a comment. */
224 const char line_comment_chars
[] = "#";
225 const char line_separator_chars
[] = "@";
227 /* Now all floating point support is shut off. See md_atof. */
228 const char EXP_CHARS
[] = "";
229 const char FLT_CHARS
[] = "";
231 /* For CRIS, we encode the relax_substateTs (in e.g. fr_substate) as:
233 ---/ /--+-----------------+-----------------+-----------------+
234 | what state ? | how long ? |
235 ---/ /--+-----------------+-----------------+-----------------+
237 The "how long" bits are 00 = byte, 01 = word, 10 = dword (long).
238 Not all lengths are legit for a given value of (what state).
240 Groups for CRIS address relaxing:
243 length: byte, word, 10-byte expansion
246 length: byte, word, dword
249 Not really a relaxation (no infrastructure to get delay-slots
250 right), just an alignment and placement checker for the v10
253 4. Bcc (V32 and later)
254 length: byte, word, 14-byte expansion
257 length: byte, word, error
260 length: byte, word, dword
266 #define STATE_COND_BRANCH (1)
267 #define STATE_BASE_PLUS_DISP_PREFIX (2)
268 #define STATE_MUL (3)
269 #define STATE_COND_BRANCH_V32 (4)
270 #define STATE_COND_BRANCH_COMMON (5)
271 #define STATE_ABS_BRANCH_V32 (6)
272 #define STATE_LAPC (7)
273 #define STATE_COND_BRANCH_PIC (8)
275 #define STATE_LENGTH_MASK (3)
276 #define STATE_BYTE (0)
277 #define STATE_WORD (1)
278 #define STATE_DWORD (2)
279 /* Symbol undefined. */
280 #define STATE_UNDF (3)
281 #define STATE_MAX_LENGTH (3)
283 /* These displacements are relative to the address following the opcode
284 word of the instruction. The first letter is Byte, Word. The 2nd
285 letter is Forward, Backward. */
287 #define BRANCH_BF ( 254)
288 #define BRANCH_BB (-256)
289 #define BRANCH_BF_V32 ( 252)
290 #define BRANCH_BB_V32 (-258)
291 #define BRANCH_WF (2 + 32767)
292 #define BRANCH_WB (2 + -32768)
293 #define BRANCH_WF_V32 (-2 + 32767)
294 #define BRANCH_WB_V32 (-2 + -32768)
296 #define BDAP_BF ( 127)
297 #define BDAP_BB (-128)
298 #define BDAP_WF ( 32767)
299 #define BDAP_WB (-32768)
301 #define ENCODE_RELAX(what, length) (((what) << 2) + (length))
303 const relax_typeS md_cris_relax_table
[] =
305 /* Error sentinel (0, 0). */
318 {BRANCH_BF
, BRANCH_BB
, 0, ENCODE_RELAX (1, 1)},
320 /* Bcc [PC+] (1, 1). */
321 {BRANCH_WF
, BRANCH_WB
, 2, ENCODE_RELAX (1, 2)},
323 /* BEXT/BWF, BA, JUMP (external), JUMP (always), Bnot_cc, JUMP (default)
331 {BDAP_BF
, BDAP_BB
, 0, ENCODE_RELAX (2, 1)},
333 /* BDAP.[bw] [PC+] (2, 1). */
334 {BDAP_WF
, BDAP_WB
, 2, ENCODE_RELAX (2, 2)},
336 /* BDAP.d [PC+] (2, 2). */
342 /* MULS/MULU (3, 0). Positions (3, 1..3) are unused. */
343 {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0},
345 /* V32: Bcc o (4, 0). */
346 {BRANCH_BF_V32
, BRANCH_BB_V32
, 0, ENCODE_RELAX (4, 1)},
348 /* V32: Bcc [PC+] (4, 1). */
349 {BRANCH_WF_V32
, BRANCH_WB_V32
, 2, ENCODE_RELAX (4, 2)},
351 /* V32: BA .+12; NOP; BA32 target; NOP; Bcc .-6 (4, 2). */
357 /* COMMON: Bcc o (5, 0). The offsets are calculated as for v32. Code
358 should contain two nop insns (or four if offset size is large or
359 unknown) after every label. */
360 {BRANCH_BF_V32
, BRANCH_BB_V32
, 0, ENCODE_RELAX (5, 1)},
362 /* COMMON: Bcc [PC+] (5, 1). */
363 {BRANCH_WF_V32
, BRANCH_WB_V32
, 2, ENCODE_RELAX (5, 2)},
365 /* COMMON: FIXME: ???. Treat as error currently. */
371 /* V32: BA o (6, 0). */
372 {BRANCH_BF_V32
, BRANCH_BB_V32
, 0, ENCODE_RELAX (6, 1)},
374 /* V32: BA.W (6, 1). */
375 {BRANCH_WF_V32
, BRANCH_WB_V32
, 2, ENCODE_RELAX (6, 2)},
377 /* V32: BA.D (6, 2). */
383 /* LAPC: LAPCQ .+0..15*2,Rn (7, 0). */
384 {14*2, -1*2, 0, ENCODE_RELAX (7, 2)},
387 While there's a shorter sequence, e.g. LAPCQ + an ADDQ or SUBQ,
388 that would affect flags, so we can't do that as it wouldn't be a
389 proper insn expansion of LAPCQ. This row is associated with a
390 2-byte expansion, so it's unused rather than the next. */
393 /* LAPC: LAPC.D (7, 2). */
399 /* PIC for pre-v32: Bcc o (8, 0). */
400 {BRANCH_BF
, BRANCH_BB
, 0, ENCODE_RELAX (STATE_COND_BRANCH_PIC
, 1)},
402 /* Bcc [PC+] (8, 1). */
403 {BRANCH_WF
, BRANCH_WB
, 2, ENCODE_RELAX (STATE_COND_BRANCH_PIC
, 2)},
405 /* 32-bit expansion, PIC (8, 2). */
417 /* Target-specific multicharacter options, not const-declared. */
418 struct option md_longopts
[] =
420 #define OPTION_NO_US (OPTION_MD_BASE + 0)
421 {"no-underscore", no_argument
, NULL
, OPTION_NO_US
},
422 #define OPTION_US (OPTION_MD_BASE + 1)
423 {"underscore", no_argument
, NULL
, OPTION_US
},
424 #define OPTION_PIC (OPTION_US + 1)
425 {"pic", no_argument
, NULL
, OPTION_PIC
},
426 #define OPTION_MULBUG_ABORT_ON (OPTION_PIC + 1)
427 {"mul-bug-abort", no_argument
, NULL
, OPTION_MULBUG_ABORT_ON
},
428 #define OPTION_MULBUG_ABORT_OFF (OPTION_MULBUG_ABORT_ON + 1)
429 {"no-mul-bug-abort", no_argument
, NULL
, OPTION_MULBUG_ABORT_OFF
},
430 #define OPTION_ARCH (OPTION_MULBUG_ABORT_OFF + 1)
431 {"march", required_argument
, NULL
, OPTION_ARCH
},
432 {NULL
, no_argument
, NULL
, 0}
435 /* Not const-declared. */
436 size_t md_longopts_size
= sizeof (md_longopts
);
437 const char *md_shortopts
= "hHN";
439 /* At first glance, this may seems wrong and should be 4 (ba + nop); but
440 since a short_jump must skip a *number* of long jumps, it must also be
441 a long jump. Here, we hope to make it a "ba [16bit_offs]" and a "nop"
442 for the delay slot and hope that the jump table at most needs
443 32767/4=8191 long-jumps. A branch is better than a jump, since it is
444 relative; we will not have a reloc to fix up somewhere.
446 Note that we can't add relocs, because relaxation uses these fixed
447 numbers, and md_create_short_jump is called after relaxation. */
449 int md_short_jump_size
= 6;
451 /* The v32 version has a delay-slot, hence two bytes longer.
452 The pre-v32 PIC version uses a prefixed insn. */
453 #define cris_any_v0_v10_long_jump_size 6
454 #define cris_any_v0_v10_long_jump_size_pic 8
455 #define crisv32_long_jump_size 8
457 int md_long_jump_size
= XCONCAT2 (DEFAULT_CRIS_ARCH
,_long_jump_size
);
459 /* Report output format. Small changes in output format (like elf
460 variants below) can happen until all options are parsed, but after
461 that, the output format must remain fixed. */
464 cris_target_format (void)
466 switch (OUTPUT_FLAVOR
)
468 case bfd_target_aout_flavour
:
471 case bfd_target_elf_flavour
:
472 if (symbols_have_leading_underscore
)
473 return "elf32-us-cris";
482 /* Return a bfd_mach_cris... value corresponding to the value of
488 unsigned int retval
= 0;
492 case arch_cris_common_v10_v32
:
493 retval
= bfd_mach_cris_v10_v32
;
497 retval
= bfd_mach_cris_v32
;
501 case arch_cris_any_v0_v10
:
502 retval
= bfd_mach_cris_v0_v10
;
506 BAD_CASE (cris_arch
);
512 /* We need a port-specific relaxation function to cope with sym2 - sym1
513 relative expressions with both symbols in the same segment (but not
514 necessarily in the same frag as this insn), for example:
515 move.d [pc+sym2-(sym1-2)],r10
517 The offset can be 8, 16 or 32 bits long. */
520 cris_relax_frag (segT seg ATTRIBUTE_UNUSED
, fragS
*fragP
,
521 long stretch ATTRIBUTE_UNUSED
)
526 const relax_typeS
*this_type
;
527 const relax_typeS
*start_type
;
528 relax_substateT next_state
;
529 relax_substateT this_state
;
530 const relax_typeS
*table
= TC_GENERIC_RELAX_TABLE
;
532 /* We only have to cope with frags as prepared by
533 md_estimate_size_before_relax. The dword cases may get here
534 because of the different reasons that they aren't relaxable. */
535 switch (fragP
->fr_subtype
)
537 case ENCODE_RELAX (STATE_COND_BRANCH_PIC
, STATE_DWORD
):
538 case ENCODE_RELAX (STATE_COND_BRANCH
, STATE_DWORD
):
539 case ENCODE_RELAX (STATE_COND_BRANCH_V32
, STATE_DWORD
):
540 case ENCODE_RELAX (STATE_COND_BRANCH_COMMON
, STATE_DWORD
):
541 case ENCODE_RELAX (STATE_ABS_BRANCH_V32
, STATE_DWORD
):
542 case ENCODE_RELAX (STATE_LAPC
, STATE_DWORD
):
543 case ENCODE_RELAX (STATE_BASE_PLUS_DISP_PREFIX
, STATE_DWORD
):
544 /* When we get to these states, the frag won't grow any more. */
547 case ENCODE_RELAX (STATE_BASE_PLUS_DISP_PREFIX
, STATE_WORD
):
548 case ENCODE_RELAX (STATE_BASE_PLUS_DISP_PREFIX
, STATE_BYTE
):
549 if (fragP
->fr_symbol
== NULL
550 || S_GET_SEGMENT (fragP
->fr_symbol
) != absolute_section
)
551 as_fatal (_("internal inconsistency problem in %s: fr_symbol %lx"),
552 __FUNCTION__
, (long) fragP
->fr_symbol
);
553 symbolP
= fragP
->fr_symbol
;
554 if (symbol_resolved_p (symbolP
))
555 as_fatal (_("internal inconsistency problem in %s: resolved symbol"),
557 aim
= S_GET_VALUE (symbolP
);
560 case ENCODE_RELAX (STATE_MUL
, STATE_BYTE
):
561 /* Nothing to do here. */
565 as_fatal (_("internal inconsistency problem in %s: fr_subtype %d"),
566 __FUNCTION__
, fragP
->fr_subtype
);
569 /* The rest is stolen from relax_frag. There's no obvious way to
570 share the code, but fortunately no requirement to keep in sync as
571 long as fragP->fr_symbol does not have its segment changed. */
573 this_state
= fragP
->fr_subtype
;
574 start_type
= this_type
= table
+ this_state
;
578 /* Look backwards. */
579 for (next_state
= this_type
->rlx_more
; next_state
;)
580 if (aim
>= this_type
->rlx_backward
)
584 /* Grow to next state. */
585 this_state
= next_state
;
586 this_type
= table
+ this_state
;
587 next_state
= this_type
->rlx_more
;
593 for (next_state
= this_type
->rlx_more
; next_state
;)
594 if (aim
<= this_type
->rlx_forward
)
598 /* Grow to next state. */
599 this_state
= next_state
;
600 this_type
= table
+ this_state
;
601 next_state
= this_type
->rlx_more
;
605 growth
= this_type
->rlx_length
- start_type
->rlx_length
;
607 fragP
->fr_subtype
= this_state
;
611 /* Prepare machine-dependent frags for relaxation.
613 Called just before relaxation starts. Any symbol that is now undefined
614 will not become defined.
616 Return the correct fr_subtype in the frag.
618 Return the initial "guess for fr_var" to caller. The guess for fr_var
619 is *actually* the growth beyond fr_fix. Whatever we do to grow fr_fix
620 or fr_var contributes to our returned value.
622 Although it may not be explicit in the frag, pretend
623 fr_var starts with a value. */
626 md_estimate_size_before_relax (fragS
*fragP
, segT segment_type
)
629 symbolS
*symbolP
= fragP
->fr_symbol
;
631 #define HANDLE_RELAXABLE(state) \
632 case ENCODE_RELAX (state, STATE_UNDF): \
633 if (symbolP != NULL \
634 && S_GET_SEGMENT (symbolP) == segment_type \
635 && !S_IS_WEAK (symbolP)) \
636 /* The symbol lies in the same segment - a relaxable \
639 = ENCODE_RELAX (state, STATE_BYTE); \
641 /* Unknown or not the same segment, so not relaxable. */ \
643 = ENCODE_RELAX (state, STATE_DWORD); \
645 = md_cris_relax_table[fragP->fr_subtype].rlx_length; \
648 old_fr_fix
= fragP
->fr_fix
;
650 switch (fragP
->fr_subtype
)
652 HANDLE_RELAXABLE (STATE_COND_BRANCH
);
653 HANDLE_RELAXABLE (STATE_COND_BRANCH_V32
);
654 HANDLE_RELAXABLE (STATE_COND_BRANCH_COMMON
);
655 HANDLE_RELAXABLE (STATE_COND_BRANCH_PIC
);
656 HANDLE_RELAXABLE (STATE_ABS_BRANCH_V32
);
658 case ENCODE_RELAX (STATE_LAPC
, STATE_UNDF
):
660 && S_GET_SEGMENT (symbolP
) == segment_type
661 && !S_IS_WEAK (symbolP
))
663 /* The symbol lies in the same segment - a relaxable case.
664 Check if we currently have an odd offset; we can't code
665 that into the instruction. Relaxing presumably only cause
666 multiple-of-two changes, so we should only need to adjust
668 bfd_vma target_address
670 ? S_GET_VALUE (symbolP
)
671 : 0) + fragP
->fr_offset
;
672 bfd_vma var_part_offset
= fragP
->fr_fix
;
673 bfd_vma address_of_var_part
= fragP
->fr_address
+ var_part_offset
;
674 long offset
= target_address
- (address_of_var_part
- 2);
678 ? ENCODE_RELAX (STATE_LAPC
, STATE_DWORD
)
679 : ENCODE_RELAX (STATE_LAPC
, STATE_BYTE
);
682 /* Unknown or not the same segment, so not relaxable. */
684 = ENCODE_RELAX (STATE_LAPC
, STATE_DWORD
);
686 = md_cris_relax_table
[fragP
->fr_subtype
].rlx_length
;
689 case ENCODE_RELAX (STATE_BASE_PLUS_DISP_PREFIX
, STATE_UNDF
):
690 /* Note that we can not do anything sane with relaxing
691 [rX + a_known_symbol_in_text], it will have to be a 32-bit
694 We could play tricks with managing a constant pool and make
695 a_known_symbol_in_text a "bdap [pc + offset]" pointing there
696 (like the GOT for ELF shared libraries), but that's no use, it
697 would in general be no shorter or faster code, only more
700 if (S_GET_SEGMENT (symbolP
) != absolute_section
)
702 /* Go for dword if not absolute or same segment. */
704 = ENCODE_RELAX (STATE_BASE_PLUS_DISP_PREFIX
, STATE_DWORD
);
705 fragP
->fr_var
= md_cris_relax_table
[fragP
->fr_subtype
].rlx_length
;
707 else if (!symbol_resolved_p (fragP
->fr_symbol
))
709 /* The symbol will eventually be completely resolved as an
710 absolute expression, but right now it depends on the result
711 of relaxation and we don't know anything else about the
712 value. We start relaxation with the assumption that it'll
715 = ENCODE_RELAX (STATE_BASE_PLUS_DISP_PREFIX
, STATE_BYTE
);
716 fragP
->fr_var
= md_cris_relax_table
[fragP
->fr_subtype
].rlx_length
;
720 /* Absolute expression. */
722 value
= (symbolP
!= NULL
723 ? S_GET_VALUE (symbolP
) : 0) + fragP
->fr_offset
;
725 if (value
>= -128 && value
<= 127)
727 /* Byte displacement. */
728 (fragP
->fr_opcode
)[0] = value
;
732 /* Word or dword displacement. */
733 int pow2_of_size
= 1;
736 if (value
< -32768 || value
> 32767)
738 /* Outside word range, make it a dword. */
742 /* Modify the byte-offset BDAP into a word or dword offset
743 BDAP. Or really, a BDAP rX,8bit into a
744 BDAP.[wd] rX,[PC+] followed by a word or dword. */
745 (fragP
->fr_opcode
)[0] = BDAP_PC_LOW
+ pow2_of_size
* 16;
747 /* Keep the register number in the highest four bits. */
748 (fragP
->fr_opcode
)[1] &= 0xF0;
749 (fragP
->fr_opcode
)[1] |= BDAP_INCR_HIGH
;
751 /* It grew by two or four bytes. */
752 fragP
->fr_fix
+= 1 << pow2_of_size
;
753 writep
= fragP
->fr_literal
+ old_fr_fix
;
754 md_number_to_chars (writep
, value
, 1 << pow2_of_size
);
760 case ENCODE_RELAX (STATE_COND_BRANCH
, STATE_BYTE
):
761 case ENCODE_RELAX (STATE_COND_BRANCH
, STATE_WORD
):
762 case ENCODE_RELAX (STATE_COND_BRANCH
, STATE_DWORD
):
763 case ENCODE_RELAX (STATE_COND_BRANCH_PIC
, STATE_BYTE
):
764 case ENCODE_RELAX (STATE_COND_BRANCH_PIC
, STATE_WORD
):
765 case ENCODE_RELAX (STATE_COND_BRANCH_PIC
, STATE_DWORD
):
766 case ENCODE_RELAX (STATE_COND_BRANCH_V32
, STATE_BYTE
):
767 case ENCODE_RELAX (STATE_COND_BRANCH_V32
, STATE_WORD
):
768 case ENCODE_RELAX (STATE_COND_BRANCH_V32
, STATE_DWORD
):
769 case ENCODE_RELAX (STATE_COND_BRANCH_COMMON
, STATE_BYTE
):
770 case ENCODE_RELAX (STATE_COND_BRANCH_COMMON
, STATE_WORD
):
771 case ENCODE_RELAX (STATE_COND_BRANCH_COMMON
, STATE_DWORD
):
772 case ENCODE_RELAX (STATE_ABS_BRANCH_V32
, STATE_BYTE
):
773 case ENCODE_RELAX (STATE_ABS_BRANCH_V32
, STATE_WORD
):
774 case ENCODE_RELAX (STATE_ABS_BRANCH_V32
, STATE_DWORD
):
775 case ENCODE_RELAX (STATE_LAPC
, STATE_BYTE
):
776 case ENCODE_RELAX (STATE_LAPC
, STATE_DWORD
):
777 case ENCODE_RELAX (STATE_BASE_PLUS_DISP_PREFIX
, STATE_BYTE
):
778 case ENCODE_RELAX (STATE_BASE_PLUS_DISP_PREFIX
, STATE_WORD
):
779 case ENCODE_RELAX (STATE_BASE_PLUS_DISP_PREFIX
, STATE_DWORD
):
780 /* When relaxing a section for the second time, we don't need to
781 do anything except making sure that fr_var is set right. */
782 fragP
->fr_var
= md_cris_relax_table
[fragP
->fr_subtype
].rlx_length
;
785 case ENCODE_RELAX (STATE_MUL
, STATE_BYTE
):
786 /* Nothing to do here. */
790 BAD_CASE (fragP
->fr_subtype
);
793 return fragP
->fr_var
+ (fragP
->fr_fix
- old_fr_fix
);
796 /* Perform post-processing of machine-dependent frags after relaxation.
797 Called after relaxation is finished.
799 fr_type == rs_machine_dependent.
800 fr_subtype is what the address relaxed to.
802 Out: Any fixS:s and constants are set up.
804 The caller will turn the frag into a ".space 0". */
807 md_convert_frag (bfd
*abfd ATTRIBUTE_UNUSED
, segT sec ATTRIBUTE_UNUSED
,
810 /* Pointer to first byte in variable-sized part of the frag. */
813 /* Pointer to first opcode byte in frag. */
816 /* Used to check integrity of the relaxation.
817 One of 2 = long, 1 = word, or 0 = byte. */
820 /* Size in bytes of variable-sized part of frag. */
821 int var_part_size
= 0;
823 /* This is part of *fragP. It contains all information about addresses
824 and offsets to varying parts. */
826 unsigned long var_part_offset
;
828 /* Where, in file space, is _var of *fragP? */
829 unsigned long address_of_var_part
= 0;
831 /* Where, in file space, does addr point? */
832 unsigned long target_address
;
834 know (fragP
->fr_type
== rs_machine_dependent
);
836 length_code
= fragP
->fr_subtype
& STATE_LENGTH_MASK
;
837 know (length_code
>= 0 && length_code
< STATE_MAX_LENGTH
);
839 var_part_offset
= fragP
->fr_fix
;
840 var_partp
= fragP
->fr_literal
+ var_part_offset
;
841 opcodep
= fragP
->fr_opcode
;
843 symbolP
= fragP
->fr_symbol
;
844 target_address
= (symbolP
? S_GET_VALUE (symbolP
) : 0) + fragP
->fr_offset
;
845 address_of_var_part
= fragP
->fr_address
+ var_part_offset
;
847 switch (fragP
->fr_subtype
)
849 case ENCODE_RELAX (STATE_COND_BRANCH
, STATE_BYTE
):
850 case ENCODE_RELAX (STATE_COND_BRANCH_PIC
, STATE_BYTE
):
851 case ENCODE_RELAX (STATE_COND_BRANCH_V32
, STATE_BYTE
):
852 case ENCODE_RELAX (STATE_COND_BRANCH_COMMON
, STATE_BYTE
):
853 case ENCODE_RELAX (STATE_ABS_BRANCH_V32
, STATE_BYTE
):
854 opcodep
[0] = branch_disp ((target_address
- address_of_var_part
));
858 case ENCODE_RELAX (STATE_COND_BRANCH
, STATE_WORD
):
859 case ENCODE_RELAX (STATE_COND_BRANCH_PIC
, STATE_WORD
):
860 case ENCODE_RELAX (STATE_COND_BRANCH_V32
, STATE_WORD
):
861 case ENCODE_RELAX (STATE_COND_BRANCH_COMMON
, STATE_WORD
):
862 case ENCODE_RELAX (STATE_ABS_BRANCH_V32
, STATE_WORD
):
863 /* We had a quick immediate branch, now turn it into a word one i.e. a
865 opcodep
[0] = BRANCH_PC_LOW
;
867 opcodep
[1] |= BRANCH_INCR_HIGH
;
868 md_number_to_chars (var_partp
,
871 - (address_of_var_part
872 + (cris_arch
== arch_crisv32
873 || cris_arch
== arch_cris_common_v10_v32
879 case ENCODE_RELAX (STATE_COND_BRANCH
, STATE_DWORD
):
880 gen_cond_branch_32 (fragP
->fr_opcode
, var_partp
, fragP
,
881 fragP
->fr_symbol
, (symbolS
*) NULL
,
883 /* Ten bytes added: a branch, nop and a jump. */
884 var_part_size
= 2 + 2 + 4 + 2;
887 case ENCODE_RELAX (STATE_COND_BRANCH_PIC
, STATE_DWORD
):
888 gen_cond_branch_32 (fragP
->fr_opcode
, var_partp
, fragP
,
889 fragP
->fr_symbol
, (symbolS
*) NULL
,
891 /* Twelve bytes added: a branch, nop and a pic-branch-32. */
892 var_part_size
= 2 + 2 + 4 + 2 + 2;
895 case ENCODE_RELAX (STATE_COND_BRANCH_V32
, STATE_DWORD
):
896 gen_cond_branch_32 (fragP
->fr_opcode
, var_partp
, fragP
,
897 fragP
->fr_symbol
, (symbolS
*) NULL
,
899 /* Twelve bytes added: a branch, nop and another branch and nop. */
900 var_part_size
= 2 + 2 + 2 + 4 + 2;
903 case ENCODE_RELAX (STATE_COND_BRANCH_COMMON
, STATE_DWORD
):
904 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
905 _("Relaxation to long branches for .arch common_v10_v32\
907 /* Pretend we have twelve bytes for sake of quelling further
909 var_part_size
= 2 + 2 + 2 + 4 + 2;
912 case ENCODE_RELAX (STATE_ABS_BRANCH_V32
, STATE_DWORD
):
913 /* We had a quick immediate branch or a word immediate ba. Now
914 turn it into a dword one. */
915 opcodep
[0] = BA_DWORD_OPCODE
& 255;
916 opcodep
[1] = (BA_DWORD_OPCODE
>> 8) & 255;
917 fix_new (fragP
, var_partp
- fragP
->fr_literal
, 4, symbolP
,
918 fragP
->fr_offset
+ 6, 1, BFD_RELOC_32_PCREL
);
922 case ENCODE_RELAX (STATE_LAPC
, STATE_BYTE
):
924 long offset
= target_address
- (address_of_var_part
- 2);
926 /* This is mostly a sanity check; useful occurrences (if there
927 really are any) should have been caught in
928 md_estimate_size_before_relax. We can (at least
929 theoretically) stumble over invalid code with odd sizes and
930 .p2aligns within the code, so emit an error if that happens.
931 (The generic relaxation machinery is not fit to check this.) */
934 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
935 _("Complicated LAPC target operand is not\
936 a multiple of two. Use LAPC.D"));
938 /* FIXME: This *is* a sanity check. Remove when done with. */
939 if (offset
> 15*2 || offset
< 0)
940 as_fatal (_("Internal error found in md_convert_frag: offset %ld.\
941 Please report this."),
944 opcodep
[0] |= (offset
/ 2) & 0xf;
949 case ENCODE_RELAX (STATE_LAPC
, STATE_DWORD
):
951 md_number_to_chars (opcodep
,
952 LAPC_DWORD_OPCODE
+ (opcodep
[1] & 0xf0) * 256,
954 /* Remember that the reloc is against the position *after* the
955 relocated contents, so we need to adjust to the start of
957 fix_new (fragP
, var_partp
- fragP
->fr_literal
, 4, fragP
->fr_symbol
,
958 fragP
->fr_offset
+ 6, 1, BFD_RELOC_32_PCREL
);
963 case ENCODE_RELAX (STATE_BASE_PLUS_DISP_PREFIX
, STATE_BYTE
):
965 as_fatal (_("internal inconsistency in %s: bdapq no symbol"),
967 opcodep
[0] = S_GET_VALUE (symbolP
);
971 case ENCODE_RELAX (STATE_BASE_PLUS_DISP_PREFIX
, STATE_WORD
):
972 /* We had a BDAP 8-bit "quick immediate", now turn it into a 16-bit
973 one that uses PC autoincrement. */
974 opcodep
[0] = BDAP_PC_LOW
+ (1 << 4);
976 opcodep
[1] |= BDAP_INCR_HIGH
;
978 as_fatal (_("internal inconsistency in %s: bdap.w with no symbol"),
980 md_number_to_chars (var_partp
, S_GET_VALUE (symbolP
), 2);
984 case ENCODE_RELAX (STATE_BASE_PLUS_DISP_PREFIX
, STATE_DWORD
):
985 /* We had a BDAP 16-bit "word", change the offset to a dword. */
986 opcodep
[0] = BDAP_PC_LOW
+ (2 << 4);
988 opcodep
[1] |= BDAP_INCR_HIGH
;
989 if (fragP
->fr_symbol
== NULL
)
990 md_number_to_chars (var_partp
, fragP
->fr_offset
, 4);
992 fix_new (fragP
, var_partp
- fragP
->fr_literal
, 4, fragP
->fr_symbol
,
993 fragP
->fr_offset
, 0, BFD_RELOC_32
);
997 case ENCODE_RELAX (STATE_MUL
, STATE_BYTE
):
998 /* This is the only time we check position and alignment of the
999 placement-tracking frag. */
1000 if (sec
->alignment_power
< 2)
1001 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
1002 _("section alignment must be >= 4 bytes to check MULS/MULU safeness"));
1005 /* If the address after the MULS/MULU has alignment which is
1006 that of the section and may be that of a cache-size of the
1007 buggy versions, then the MULS/MULU can be placed badly. */
1008 if ((address_of_var_part
1009 & ((1 << sec
->alignment_power
) - 1) & 31) == 0)
1010 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
1011 _("dangerous MULS/MULU location; give it higher alignment"));
1016 BAD_CASE (fragP
->fr_subtype
);
1020 fragP
->fr_fix
+= var_part_size
;
1023 /* Generate a short jump around a secondary jump table.
1024 Used by md_create_long_jump.
1026 This used to be md_create_short_jump, but is now called from
1027 md_create_long_jump instead, when sufficient, since the sizes of the
1028 jumps are the same for pre-v32. */
1031 cris_create_short_jump (char *storep
, addressT from_addr
, addressT to_addr
,
1032 fragS
*fragP ATTRIBUTE_UNUSED
,
1033 symbolS
*to_symbol ATTRIBUTE_UNUSED
)
1037 /* See md_create_long_jump about the comment on the "+ 2". */
1038 long int max_minimal_minus_distance
;
1039 long int max_minimal_plus_distance
;
1042 if (cris_arch
== arch_crisv32
)
1044 max_minimal_minus_distance
= BRANCH_BB_V32
+ 2;
1045 max_minimal_plus_distance
= BRANCH_BF_V32
+ 2;
1046 nop_opcode
= NOP_OPCODE_V32
;
1050 max_minimal_minus_distance
= BRANCH_BB
+ 2;
1051 max_minimal_plus_distance
= BRANCH_BF
+ 2;
1052 nop_opcode
= NOP_OPCODE
;
1055 distance
= to_addr
- from_addr
;
1057 if (max_minimal_minus_distance
<= distance
1058 && distance
<= max_minimal_plus_distance
)
1060 /* Create a "short" short jump: "BA distance - 2". */
1061 storep
[0] = branch_disp (distance
- 2);
1062 storep
[1] = BA_QUICK_HIGH
;
1064 /* A nop for the delay slot. */
1065 md_number_to_chars (storep
+ 2, nop_opcode
, 2);
1067 /* The extra word should be filled with something sane too. Make it
1068 a nop to keep disassembly sane. */
1069 md_number_to_chars (storep
+ 4, nop_opcode
, 2);
1073 /* Make it a "long" short jump: "BA (PC+)". */
1074 md_number_to_chars (storep
, BA_PC_INCR_OPCODE
, 2);
1076 /* ".WORD distance - 4". */
1077 md_number_to_chars (storep
+ 2,
1078 (long) (distance
- 4
1079 - (cris_arch
== arch_crisv32
1083 /* A nop for the delay slot. */
1084 md_number_to_chars (storep
+ 4, nop_opcode
, 2);
1088 /* Generate a long jump in a secondary jump table.
1090 storep Where to store the jump instruction.
1091 from_addr Address of the jump instruction.
1092 to_addr Destination address of the jump.
1093 fragP Which frag the destination address operand
1095 to_symbol Destination symbol. */
1098 md_create_long_jump (char *storep
, addressT from_addr
, addressT to_addr
,
1099 fragS
*fragP
, symbolS
*to_symbol
)
1103 /* FIXME: What's that "+ 3"? It comes from the magic numbers that
1104 used to be here, it's just translated to the limit macros used in
1105 the relax table. But why + 3? */
1106 long int max_short_minus_distance
1107 = cris_arch
!= arch_crisv32
? BRANCH_WB
+ 3 : BRANCH_WB_V32
+ 3;
1109 long int max_short_plus_distance
1110 = cris_arch
!= arch_crisv32
? BRANCH_WF
+ 3 : BRANCH_WF_V32
+ 3;
1112 /* Bail out for compatibility mode. (It seems it can be implemented,
1113 perhaps with a 10-byte sequence: "move.d NNNN,$pc/$acr", "jump
1114 $acr", "nop"; but doesn't seem worth it at the moment.) */
1115 if (cris_arch
== arch_cris_common_v10_v32
)
1116 as_fatal (_("Out-of-range .word offset handling\
1117 is not implemented for .arch common_v10_v32"));
1119 distance
= to_addr
- from_addr
;
1121 if (max_short_minus_distance
<= distance
1122 && distance
<= max_short_plus_distance
)
1123 /* Then make it a "short" long jump. */
1124 cris_create_short_jump (storep
, from_addr
, to_addr
, fragP
,
1128 /* We have a "long" long jump: "JUMP [PC+]". If CRISv32, always
1129 make it a BA. Else make it an "MOVE [PC=PC+N],P0" if we're supposed
1130 to emit PIC code. */
1131 md_number_to_chars (storep
,
1132 cris_arch
== arch_crisv32
1134 : (pic
? MOVE_PC_INCR_OPCODE_PREFIX
1135 : JUMP_PC_INCR_OPCODE
),
1138 /* Follow with a ".DWORD to_addr", PC-relative for PIC. */
1139 fix_new (fragP
, storep
+ 2 - fragP
->fr_literal
, 4, to_symbol
,
1140 cris_arch
== arch_crisv32
? 6 : 0,
1141 cris_arch
== arch_crisv32
|| pic
? 1 : 0,
1142 cris_arch
== arch_crisv32
|| pic
1143 ? BFD_RELOC_32_PCREL
: BFD_RELOC_32
);
1145 /* Follow it with a "NOP" for CRISv32. */
1146 if (cris_arch
== arch_crisv32
)
1147 md_number_to_chars (storep
+ 6, NOP_OPCODE_V32
, 2);
1149 /* ...and the rest of the move-opcode for pre-v32 PIC. */
1150 md_number_to_chars (storep
+ 6, MOVE_PC_INCR_OPCODE_SUFFIX
, 2);
1154 /* Allocate space for the first piece of an insn, and mark it as the
1155 start of the insn for debug-format use. */
1158 cris_insn_first_word_frag (void)
1160 char *insnp
= frag_more (2);
1162 /* We need to mark the start of the insn by passing dwarf2_emit_insn
1163 the offset from the current fragment position. This must be done
1164 after the first fragment is created but before any other fragments
1165 (fixed or varying) are created. Note that the offset only
1166 corresponds to the "size" of the insn for a fixed-size,
1167 non-expanded insn. */
1168 if (OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
1169 dwarf2_emit_insn (2);
1174 /* Port-specific assembler initialization. */
1179 const char *hashret
= NULL
;
1182 /* Set up a hash table for the instructions. */
1183 op_hash
= hash_new ();
1184 if (op_hash
== NULL
)
1185 as_fatal (_("Virtual memory exhausted"));
1187 /* Enable use of ".if ..asm.arch.cris.v32"
1188 and ".if ..asm.arch.cris.common_v10_v32" and a few others. */
1189 symbol_table_insert (symbol_new ("..asm.arch.cris.v32", absolute_section
,
1190 (cris_arch
== arch_crisv32
),
1191 &zero_address_frag
));
1192 symbol_table_insert (symbol_new ("..asm.arch.cris.v10", absolute_section
,
1193 (cris_arch
== arch_crisv10
),
1194 &zero_address_frag
));
1195 symbol_table_insert (symbol_new ("..asm.arch.cris.common_v10_v32",
1197 (cris_arch
== arch_cris_common_v10_v32
),
1198 &zero_address_frag
));
1199 symbol_table_insert (symbol_new ("..asm.arch.cris.any_v0_v10",
1201 (cris_arch
== arch_cris_any_v0_v10
),
1202 &zero_address_frag
));
1204 while (cris_opcodes
[i
].name
!= NULL
)
1206 const char *name
= cris_opcodes
[i
].name
;
1208 if (! cris_insn_ver_valid_for_arch (cris_opcodes
[i
].applicable_version
,
1215 /* Need to cast to get rid of "const". FIXME: Fix hash_insert instead. */
1216 hashret
= hash_insert (op_hash
, name
, (void *) &cris_opcodes
[i
]);
1218 if (hashret
!= NULL
&& *hashret
!= '\0')
1219 as_fatal (_("Can't hash `%s': %s\n"), cris_opcodes
[i
].name
,
1220 *hashret
== 0 ? _("(unknown reason)") : hashret
);
1223 if (cris_opcodes
[i
].match
& cris_opcodes
[i
].lose
)
1224 as_fatal (_("Buggy opcode: `%s' \"%s\"\n"), cris_opcodes
[i
].name
,
1225 cris_opcodes
[i
].args
);
1229 while (cris_opcodes
[i
].name
!= NULL
1230 && strcmp (cris_opcodes
[i
].name
, name
) == 0);
1234 /* Assemble a source line. */
1237 md_assemble (char *str
)
1239 struct cris_instruction output_instruction
;
1240 struct cris_prefix prefix
;
1246 /* Do the low-level grunt - assemble to bits and split up into a prefix
1247 and ordinary insn. */
1248 cris_process_instruction (str
, &output_instruction
, &prefix
);
1250 /* Handle any prefixes to the instruction. */
1251 switch (prefix
.kind
)
1256 /* When the expression is unknown for a BDAP, it can need 0, 2 or 4
1257 extra bytes, so we handle it separately. */
1258 case PREFIX_BDAP_IMM
:
1259 /* We only do it if the relocation is unspecified, i.e. not a PIC or TLS
1261 if (prefix
.reloc
== BFD_RELOC_NONE
)
1263 gen_bdap (prefix
.base_reg_number
, &prefix
.expr
);
1270 opcodep
= cris_insn_first_word_frag ();
1272 /* Output the prefix opcode. */
1273 md_number_to_chars (opcodep
, (long) prefix
.opcode
, 2);
1275 /* Having a specified reloc only happens for DIP and for BDAP with
1276 PIC or TLS operands, but it is ok to drop through here for the other
1277 prefixes as they can have no relocs specified. */
1278 if (prefix
.reloc
!= BFD_RELOC_NONE
)
1280 unsigned int relocsize
1281 = (prefix
.kind
== PREFIX_DIP
1282 ? 4 : cris_get_specified_reloc_size (prefix
.reloc
));
1284 p
= frag_more (relocsize
);
1285 fix_new_exp (frag_now
, (p
- frag_now
->fr_literal
), relocsize
,
1286 &prefix
.expr
, 0, prefix
.reloc
);
1291 opcodep
= cris_insn_first_word_frag ();
1293 /* Output the prefix opcode. Being a "push", we add the negative
1294 size of the register to "sp". */
1295 if (output_instruction
.spec_reg
!= NULL
)
1297 /* Special register. */
1298 opcodep
[0] = -output_instruction
.spec_reg
->reg_size
;
1302 /* General register. */
1305 opcodep
[1] = (REG_SP
<< 4) + (BDAP_QUICK_OPCODE
>> 8);
1309 BAD_CASE (prefix
.kind
);
1312 /* If we only had a prefix insn, we're done. */
1313 if (output_instruction
.insn_type
== CRIS_INSN_NONE
)
1316 /* Done with the prefix. Continue with the main instruction. */
1317 if (prefix
.kind
== PREFIX_NONE
)
1318 opcodep
= cris_insn_first_word_frag ();
1320 opcodep
= frag_more (2);
1322 /* Output the instruction opcode. */
1323 md_number_to_chars (opcodep
, (long) (output_instruction
.opcode
), 2);
1325 /* Output the symbol-dependent instruction stuff. */
1326 if (output_instruction
.insn_type
== CRIS_INSN_BRANCH
)
1328 segT to_seg
= absolute_section
;
1329 int is_undefined
= 0;
1332 if (output_instruction
.expr
.X_op
!= O_constant
)
1334 to_seg
= S_GET_SEGMENT (output_instruction
.expr
.X_add_symbol
);
1336 if (to_seg
== undefined_section
)
1340 if (to_seg
== now_seg
|| is_undefined
1341 /* In CRISv32, there *is* a 32-bit absolute branch, so don't
1342 emit the 12-byte sequence for known symbols in other
1344 || (cris_arch
== arch_crisv32
1345 && output_instruction
.opcode
== BA_QUICK_OPCODE
))
1347 /* Handle complex expressions. */
1349 = (SIMPLE_EXPR (&output_instruction
.expr
)
1350 ? output_instruction
.expr
.X_add_number
1353 = (SIMPLE_EXPR (&output_instruction
.expr
)
1354 ? output_instruction
.expr
.X_add_symbol
1355 : make_expr_symbol (&output_instruction
.expr
));
1357 /* If is_undefined, the expression may still become now_seg.
1358 That case is handled by md_estimate_size_before_relax. */
1359 length_code
= to_seg
== now_seg
? STATE_BYTE
: STATE_UNDF
;
1361 /* Make room for max twelve bytes of variable length for v32 mode
1362 or PIC, ten for v10 and older. */
1363 frag_var (rs_machine_dependent
,
1364 (cris_arch
== arch_crisv32
1365 || cris_arch
== arch_cris_common_v10_v32
1366 || pic
) ? 12 : 10, 0,
1367 ENCODE_RELAX (cris_arch
== arch_crisv32
1368 ? (output_instruction
.opcode
1370 ? STATE_ABS_BRANCH_V32
1371 : STATE_COND_BRANCH_V32
)
1372 : (cris_arch
== arch_cris_common_v10_v32
1373 ? STATE_COND_BRANCH_COMMON
1374 : (pic
? STATE_COND_BRANCH_PIC
1375 : STATE_COND_BRANCH
)),
1377 sym
, addvalue
, opcodep
);
1381 /* We have: to_seg != now_seg && to_seg != undefined_section.
1382 This means it is a branch to a known symbol in another
1383 section, perhaps an absolute address. Emit a 32-bit branch. */
1385 = frag_more ((cris_arch
== arch_crisv32
1386 || cris_arch
== arch_cris_common_v10_v32
1390 gen_cond_branch_32 (opcodep
, cond_jump
, frag_now
,
1391 output_instruction
.expr
.X_add_symbol
,
1393 output_instruction
.expr
.X_add_number
);
1396 else if (output_instruction
.insn_type
== CRIS_INSN_MUL
1397 && err_for_dangerous_mul_placement
)
1398 /* Create a frag which which we track the location of the mul insn
1399 (in the last two bytes before the mul-frag). */
1400 frag_variant (rs_machine_dependent
, 0, 0,
1401 ENCODE_RELAX (STATE_MUL
, STATE_BYTE
),
1405 if (output_instruction
.imm_oprnd_size
> 0)
1407 /* The instruction has an immediate operand. */
1408 enum bfd_reloc_code_real reloc
= BFD_RELOC_NONE
;
1410 switch (output_instruction
.imm_oprnd_size
)
1412 /* Any byte-size immediate constants are treated as
1413 word-size. FIXME: Thus overflow check does not work
1417 /* Note that size-check for the explicit reloc has already
1418 been done when we get here. */
1419 if (output_instruction
.reloc
!= BFD_RELOC_NONE
)
1420 reloc
= output_instruction
.reloc
;
1422 reloc
= BFD_RELOC_16
;
1426 /* Allow a relocation specified in the operand. */
1427 if (output_instruction
.reloc
!= BFD_RELOC_NONE
)
1428 reloc
= output_instruction
.reloc
;
1430 reloc
= BFD_RELOC_32
;
1434 BAD_CASE (output_instruction
.imm_oprnd_size
);
1437 p
= frag_more (output_instruction
.imm_oprnd_size
);
1438 fix_new_exp (frag_now
, (p
- frag_now
->fr_literal
),
1439 output_instruction
.imm_oprnd_size
,
1440 &output_instruction
.expr
,
1441 reloc
== BFD_RELOC_32_PCREL
1442 || reloc
== BFD_RELOC_16_PCREL
1443 || reloc
== BFD_RELOC_8_PCREL
, reloc
);
1445 else if (output_instruction
.reloc
== BFD_RELOC_CRIS_LAPCQ_OFFSET
1446 && output_instruction
.expr
.X_md
!= 0)
1448 /* Handle complex expressions. */
1450 = (output_instruction
.expr
.X_op_symbol
!= NULL
1451 ? 0 : output_instruction
.expr
.X_add_number
);
1453 = (output_instruction
.expr
.X_op_symbol
!= NULL
1454 ? make_expr_symbol (&output_instruction
.expr
)
1455 : output_instruction
.expr
.X_add_symbol
);
1457 /* This is a relaxing construct, so we need a frag_var rather
1458 than the fix_new_exp call below. */
1459 frag_var (rs_machine_dependent
,
1461 ENCODE_RELAX (STATE_LAPC
, STATE_UNDF
),
1462 sym
, addvalue
, opcodep
);
1464 else if (output_instruction
.reloc
!= BFD_RELOC_NONE
)
1466 /* An immediate operand that has a relocation and needs to be
1467 processed further. */
1469 /* It is important to use fix_new_exp here and everywhere else
1470 (and not fix_new), as fix_new_exp can handle "difference
1471 expressions" - where the expression contains a difference of
1472 two symbols in the same segment. */
1473 fix_new_exp (frag_now
, (opcodep
- frag_now
->fr_literal
), 2,
1474 &output_instruction
.expr
,
1475 output_instruction
.reloc
== BFD_RELOC_32_PCREL
1476 || output_instruction
.reloc
== BFD_RELOC_16_PCREL
1477 || output_instruction
.reloc
== BFD_RELOC_8_PCREL
1478 || (output_instruction
.reloc
1479 == BFD_RELOC_CRIS_LAPCQ_OFFSET
),
1480 output_instruction
.reloc
);
1485 /* Low level text-to-bits assembly. */
1488 cris_process_instruction (char *insn_text
, struct cris_instruction
*out_insnp
,
1489 struct cris_prefix
*prefixp
)
1492 char modified_char
= 0;
1494 struct cris_opcode
*instruction
;
1501 /* Reset these fields to a harmless state in case we need to return in
1503 prefixp
->kind
= PREFIX_NONE
;
1504 prefixp
->reloc
= BFD_RELOC_NONE
;
1505 out_insnp
->insn_type
= CRIS_INSN_NONE
;
1506 out_insnp
->imm_oprnd_size
= 0;
1508 /* Find the end of the opcode mnemonic. We assume (true in 2.9.1)
1509 that the caller has translated the opcode to lower-case, up to the
1510 first non-letter. */
1511 for (operands
= insn_text
; ISLOWER (*operands
); ++operands
)
1514 /* Terminate the opcode after letters, but save the character there if
1515 it was of significance. */
1522 /* Put back the modified character later. */
1523 modified_char
= *operands
;
1527 /* Consume the character after the mnemonic
1528 and replace it with '\0'. */
1533 as_bad (_("Unknown opcode: `%s'"), insn_text
);
1537 /* Find the instruction. */
1538 instruction
= (struct cris_opcode
*) hash_find (op_hash
, insn_text
);
1539 if (instruction
== NULL
)
1541 as_bad (_("Unknown opcode: `%s'"), insn_text
);
1545 /* Put back the modified character. */
1546 switch (modified_char
)
1552 *--operands
= modified_char
;
1555 /* Try to match an opcode table slot. */
1556 for (s
= operands
;;)
1560 /* Initialize *prefixp, perhaps after being modified for a
1562 prefixp
->kind
= PREFIX_NONE
;
1563 prefixp
->reloc
= BFD_RELOC_NONE
;
1565 /* Initialize *out_insnp. */
1566 memset (out_insnp
, 0, sizeof (*out_insnp
));
1567 out_insnp
->opcode
= instruction
->match
;
1568 out_insnp
->reloc
= BFD_RELOC_NONE
;
1569 out_insnp
->insn_type
= CRIS_INSN_NORMAL
;
1570 out_insnp
->imm_oprnd_size
= 0;
1574 /* Build the opcode, checking as we go to make sure that the
1576 for (args
= instruction
->args
;; ++args
)
1581 /* If we've come to the end of arguments, we're done. */
1587 /* Non-matcher character for disassembly.
1595 /* These must match exactly. */
1601 /* "ACR", case-insensitive.
1602 Handle a sometimes-mandatory dollar sign as register
1604 if (*s
== REGISTER_PREFIX_CHAR
)
1606 else if (demand_register_prefix
)
1609 if ((*s
++ != 'a' && s
[-1] != 'A')
1610 || (*s
++ != 'c' && s
[-1] != 'C')
1611 || (*s
++ != 'r' && s
[-1] != 'R'))
1616 /* This is not really an operand, but causes a "BDAP
1617 -size,SP" prefix to be output, for PUSH instructions. */
1618 prefixp
->kind
= PREFIX_PUSH
;
1622 /* This letter marks an operand that should not be matched
1623 in the assembler. It is a branch with 16-bit
1624 displacement. The assembler will create them from the
1625 8-bit flavor when necessary. The assembler does not
1626 support the [rN+] operand, as the [r15+] that is
1627 generated for 16-bit displacements. */
1631 /* A 5-bit unsigned immediate in bits <4:0>. */
1632 if (! cris_get_expression (&s
, &out_insnp
->expr
))
1636 if (out_insnp
->expr
.X_op
== O_constant
1637 && (out_insnp
->expr
.X_add_number
< 0
1638 || out_insnp
->expr
.X_add_number
> 31))
1639 as_bad (_("Immediate value not in 5 bit unsigned range: %ld"),
1640 out_insnp
->expr
.X_add_number
);
1642 out_insnp
->reloc
= BFD_RELOC_CRIS_UNSIGNED_5
;
1647 /* A 4-bit unsigned immediate in bits <3:0>. */
1648 if (! cris_get_expression (&s
, &out_insnp
->expr
))
1652 if (out_insnp
->expr
.X_op
== O_constant
1653 && (out_insnp
->expr
.X_add_number
< 0
1654 || out_insnp
->expr
.X_add_number
> 15))
1655 as_bad (_("Immediate value not in 4 bit unsigned range: %ld"),
1656 out_insnp
->expr
.X_add_number
);
1658 out_insnp
->reloc
= BFD_RELOC_CRIS_UNSIGNED_4
;
1662 /* For 'd', check for an optional ".d" or ".D" at the
1663 start of the operands, followed by a space character. */
1665 if (modified_char
== '.' && *s
== '.')
1667 if ((s
[1] != 'd' && s
[1] == 'D')
1668 || ! ISSPACE (s
[2]))
1676 /* General register in bits <15:12> and <3:0>. */
1677 if (! get_gen_reg (&s
, ®no
))
1681 out_insnp
->opcode
|= regno
/* << 0 */;
1682 out_insnp
->opcode
|= regno
<< 12;
1687 /* Flags from the condition code register. */
1691 if (! get_flags (&s
, &flags
))
1694 out_insnp
->opcode
|= ((flags
& 0xf0) << 8) | (flags
& 0xf);
1699 /* A 6-bit signed immediate in bits <5:0>. */
1700 if (! cris_get_expression (&s
, &out_insnp
->expr
))
1704 if (out_insnp
->expr
.X_op
== O_constant
1705 && (out_insnp
->expr
.X_add_number
< -32
1706 || out_insnp
->expr
.X_add_number
> 31))
1707 as_bad (_("Immediate value not in 6 bit range: %ld"),
1708 out_insnp
->expr
.X_add_number
);
1709 out_insnp
->reloc
= BFD_RELOC_CRIS_SIGNED_6
;
1714 /* A 6-bit unsigned immediate in bits <5:0>. */
1715 if (! cris_get_expression (&s
, &out_insnp
->expr
))
1719 if (out_insnp
->expr
.X_op
== O_constant
1720 && (out_insnp
->expr
.X_add_number
< 0
1721 || out_insnp
->expr
.X_add_number
> 63))
1722 as_bad (_("Immediate value not in 6 bit unsigned range: %ld"),
1723 out_insnp
->expr
.X_add_number
);
1724 out_insnp
->reloc
= BFD_RELOC_CRIS_UNSIGNED_6
;
1729 /* A size modifier, B, W or D, to be put in a bit position
1730 suitable for CLEAR instructions (i.e. reflecting a zero
1732 if (! get_bwd_size_modifier (&s
, &size_bits
))
1739 out_insnp
->opcode
|= 0 << 12;
1743 out_insnp
->opcode
|= 4 << 12;
1747 out_insnp
->opcode
|= 8 << 12;
1754 /* A size modifier, B, W or D, to be put in bits <5:4>. */
1755 if (modified_char
!= '.'
1756 || ! get_bwd_size_modifier (&s
, &size_bits
))
1760 out_insnp
->opcode
|= size_bits
<< 4;
1765 /* A branch expression. */
1766 if (! cris_get_expression (&s
, &out_insnp
->expr
))
1770 out_insnp
->insn_type
= CRIS_INSN_BRANCH
;
1775 /* A 8-bit quick BDAP expression, "expr,R". */
1776 if (! cris_get_expression (&s
, &out_insnp
->expr
))
1784 if (!get_gen_reg (&s
, ®no
))
1787 out_insnp
->opcode
|= regno
<< 12;
1788 out_insnp
->reloc
= BFD_RELOC_CRIS_SIGNED_8
;
1792 /* A BDAP expression for any size, "expr,R". */
1793 if (! cris_get_expression (&s
, &prefixp
->expr
))
1802 if (!get_gen_reg (&s
, &prefixp
->base_reg_number
))
1805 /* Since 'O' is used with an explicit bdap, we have no
1806 "real" instruction. */
1807 prefixp
->kind
= PREFIX_BDAP_IMM
;
1809 = BDAP_QUICK_OPCODE
| (prefixp
->base_reg_number
<< 12);
1811 out_insnp
->insn_type
= CRIS_INSN_NONE
;
1816 /* Special register in bits <15:12>. */
1817 if (! get_spec_reg (&s
, &out_insnp
->spec_reg
))
1821 /* Use of some special register names come with a
1822 specific warning. Note that we have no ".cpu type"
1823 pseudo yet, so some of this is just unused
1825 if (out_insnp
->spec_reg
->warning
)
1826 as_warn (out_insnp
->spec_reg
->warning
);
1827 else if (out_insnp
->spec_reg
->applicable_version
1828 == cris_ver_warning
)
1829 /* Others have a generic warning. */
1830 as_warn (_("Unimplemented register `%s' specified"),
1831 out_insnp
->spec_reg
->name
);
1834 |= out_insnp
->spec_reg
->number
<< 12;
1839 /* This character is used in the disassembler to
1840 recognize a prefix instruction to fold into the
1841 addressing mode for the next instruction. It is
1846 /* General register in bits <15:12>. */
1847 if (! get_gen_reg (&s
, ®no
))
1851 out_insnp
->opcode
|= regno
<< 12;
1856 /* General register in bits <3:0>. */
1857 if (! get_gen_reg (&s
, ®no
))
1861 out_insnp
->opcode
|= regno
/* << 0 */;
1866 /* Source operand in bit <10> and a prefix; a 3-operand
1868 if (! get_3op_or_dip_prefix_op (&s
, prefixp
))
1874 /* Source operand in bits <10>, <3:0> and optionally a
1875 prefix; i.e. an indirect operand or an side-effect
1876 prefix (where valid). */
1877 if (! get_autoinc_prefix_or_indir_op (&s
, prefixp
, &mode
,
1884 if (prefixp
->kind
!= PREFIX_NONE
)
1886 /* A prefix, so it has the autoincrement bit
1888 out_insnp
->opcode
|= (AUTOINCR_BIT
<< 8);
1892 /* No prefix. The "mode" variable contains bits like
1893 whether or not this is autoincrement mode. */
1894 out_insnp
->opcode
|= (mode
<< 10);
1896 /* If there was a reloc specifier, then it was
1897 attached to the prefix. Note that we can't check
1898 that the reloc size matches, since we don't have
1899 all the operands yet in all cases. */
1900 if (prefixp
->reloc
!= BFD_RELOC_NONE
)
1901 out_insnp
->reloc
= prefixp
->reloc
;
1904 out_insnp
->opcode
|= regno
/* << 0 */ ;
1910 /* Like 's', but immediate operand only. Also do not
1911 modify insn. There are no insns where an explicit reloc
1912 specifier makes sense. */
1913 if (cris_get_expression (&s
, &out_insnp
->expr
))
1921 /* Like 'N', but PC-relative to the start of the insn.
1922 There might be a :PLT to request a PLT entry. */
1923 if (cris_get_expression (&s
, &out_insnp
->expr
))
1926 out_insnp
->reloc
= BFD_RELOC_32_PCREL
;
1928 /* We have to adjust the expression, because that
1929 relocation is to the location *after* the
1930 relocation. So add 2 for the insn and 4 for the
1932 out_insnp
->expr
.X_add_number
+= 6;
1934 /* TLS specifiers do not make sense here. */
1935 if (pic
&& *s
== RELOC_SUFFIX_CHAR
)
1936 cris_get_reloc_suffix (&s
, &out_insnp
->reloc
,
1944 /* Maybe 'u', maybe 'n'. Only for LAPC/LAPCQ. */
1945 if (cris_get_expression (&s
, &out_insnp
->expr
))
1947 out_insnp
->reloc
= BFD_RELOC_CRIS_LAPCQ_OFFSET
;
1949 /* Define 1 as relaxing. */
1950 out_insnp
->expr
.X_md
= 1;
1956 /* Four PC-relative bits in <3:0> representing <4:1>:0 of
1957 an offset relative to the beginning of the current
1959 if (cris_get_expression (&s
, &out_insnp
->expr
))
1961 out_insnp
->reloc
= BFD_RELOC_CRIS_LAPCQ_OFFSET
;
1963 /* Define 0 as non-relaxing. */
1964 out_insnp
->expr
.X_md
= 0;
1966 /* We have to adjust the expression, because that
1967 relocation is to the location *after* the
1968 insn. So add 2 for the insn. */
1969 out_insnp
->expr
.X_add_number
+= 2;
1975 /* Rs.m in bits <15:12> and <5:4>. */
1976 if (! get_gen_reg (&s
, ®no
)
1977 || ! get_bwd_size_modifier (&s
, &size_bits
))
1981 out_insnp
->opcode
|= (regno
<< 12) | (size_bits
<< 4);
1986 /* Source operand in bits <10>, <3:0> and optionally a
1987 prefix; i.e. an indirect operand or an side-effect
1990 The difference to 's' is that this does not allow an
1991 "immediate" expression. */
1992 if (! get_autoinc_prefix_or_indir_op (&s
, prefixp
,
2000 if (prefixp
->kind
!= PREFIX_NONE
)
2002 /* A prefix, and those matched here always have
2003 side-effects (see 's' case). */
2004 out_insnp
->opcode
|= (AUTOINCR_BIT
<< 8);
2008 /* No prefix. The "mode" variable contains bits
2009 like whether or not this is autoincrement
2011 out_insnp
->opcode
|= (mode
<< 10);
2014 out_insnp
->opcode
|= regno
/* << 0 */;
2019 /* Size modifier (B or W) in bit <4>. */
2020 if (! get_bw_size_modifier (&s
, &size_bits
))
2024 out_insnp
->opcode
|= size_bits
<< 4;
2029 if (cris_arch
== arch_crisv32
2030 && get_sup_reg (&s
, ®no
))
2032 out_insnp
->opcode
|= regno
<< 12;
2041 /* We get here when we fail a match above or we found a
2042 complete match. Break out of this loop. */
2046 /* Was it a match or a miss? */
2049 /* If it's just that the args don't match, maybe the next
2050 item in the table is the same opcode but with
2051 matching operands. First skip any invalid ones. */
2052 while (instruction
[1].name
!= NULL
2053 && strcmp (instruction
->name
, instruction
[1].name
) == 0
2054 && ! cris_insn_ver_valid_for_arch (instruction
[1]
2055 .applicable_version
,
2059 if (instruction
[1].name
!= NULL
2060 && strcmp (instruction
->name
, instruction
[1].name
) == 0
2061 && cris_insn_ver_valid_for_arch (instruction
[1]
2062 .applicable_version
,
2065 /* Yep. Restart and try that one instead. */
2072 /* We've come to the end of instructions with this
2073 opcode, so it must be an error. */
2074 as_bad (_("Illegal operands"));
2076 /* As discard_rest_of_line, but without continuing to the
2078 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
2079 input_line_pointer
++;
2085 /* We have a match. Check if there's anything more to do. */
2088 /* There was an immediate mode operand, so we must check
2089 that it has an appropriate size. */
2090 switch (instruction
->imm_oprnd_size
)
2094 /* Shouldn't happen; this one does not have immediate
2095 operands with different sizes. */
2096 BAD_CASE (instruction
->imm_oprnd_size
);
2100 out_insnp
->imm_oprnd_size
= 4;
2104 if (cris_arch
== arch_crisv32
)
2105 /* All immediate loads of special registers are
2106 32-bit on CRISv32. */
2107 out_insnp
->imm_oprnd_size
= 4;
2109 switch (out_insnp
->spec_reg
->reg_size
)
2112 if (out_insnp
->expr
.X_op
== O_constant
2113 && (out_insnp
->expr
.X_add_number
< -128
2114 || out_insnp
->expr
.X_add_number
> 255))
2115 as_bad (_("Immediate value not in 8 bit range: %ld"),
2116 out_insnp
->expr
.X_add_number
);
2119 /* FIXME: We need an indicator in the instruction
2120 table to pass on, to indicate if we need to check
2121 overflow for a signed or unsigned number. */
2122 if (out_insnp
->expr
.X_op
== O_constant
2123 && (out_insnp
->expr
.X_add_number
< -32768
2124 || out_insnp
->expr
.X_add_number
> 65535))
2125 as_bad (_("Immediate value not in 16 bit range: %ld"),
2126 out_insnp
->expr
.X_add_number
);
2127 out_insnp
->imm_oprnd_size
= 2;
2131 out_insnp
->imm_oprnd_size
= 4;
2135 BAD_CASE (out_insnp
->spec_reg
->reg_size
);
2140 case SIZE_FIELD_SIGNED
:
2141 case SIZE_FIELD_UNSIGNED
:
2144 /* FIXME: Find way to pass un/signedness to
2145 caller, and set reloc type instead, postponing
2146 this check until cris_number_to_imm. That
2147 necessarily corrects the reloc type for the
2148 byte case, maybe requiring further changes. */
2150 if (out_insnp
->expr
.X_op
== O_constant
)
2152 if (instruction
->imm_oprnd_size
== SIZE_FIELD
2153 && (out_insnp
->expr
.X_add_number
< -128
2154 || out_insnp
->expr
.X_add_number
> 255))
2155 as_bad (_("Immediate value not in 8 bit range: %ld"),
2156 out_insnp
->expr
.X_add_number
);
2157 else if (instruction
->imm_oprnd_size
== SIZE_FIELD_SIGNED
2158 && (out_insnp
->expr
.X_add_number
< -128
2159 || out_insnp
->expr
.X_add_number
> 127))
2160 as_bad (_("Immediate value not in 8 bit signed range: %ld"),
2161 out_insnp
->expr
.X_add_number
);
2162 else if (instruction
->imm_oprnd_size
== SIZE_FIELD_UNSIGNED
2163 && (out_insnp
->expr
.X_add_number
< 0
2164 || out_insnp
->expr
.X_add_number
> 255))
2165 as_bad (_("Immediate value not in 8 bit unsigned range: %ld"),
2166 out_insnp
->expr
.X_add_number
);
2171 if (out_insnp
->expr
.X_op
== O_constant
)
2173 if (instruction
->imm_oprnd_size
== SIZE_FIELD
2174 && (out_insnp
->expr
.X_add_number
< -32768
2175 || out_insnp
->expr
.X_add_number
> 65535))
2176 as_bad (_("Immediate value not in 16 bit range: %ld"),
2177 out_insnp
->expr
.X_add_number
);
2178 else if (instruction
->imm_oprnd_size
== SIZE_FIELD_SIGNED
2179 && (out_insnp
->expr
.X_add_number
< -32768
2180 || out_insnp
->expr
.X_add_number
> 32767))
2181 as_bad (_("Immediate value not in 16 bit signed range: %ld"),
2182 out_insnp
->expr
.X_add_number
);
2183 else if (instruction
->imm_oprnd_size
== SIZE_FIELD_UNSIGNED
2184 && (out_insnp
->expr
.X_add_number
< 0
2185 || out_insnp
->expr
.X_add_number
> 65535))
2186 as_bad (_("Immediate value not in 16 bit unsigned range: %ld"),
2187 out_insnp
->expr
.X_add_number
);
2189 out_insnp
->imm_oprnd_size
= 2;
2193 out_insnp
->imm_oprnd_size
= 4;
2197 BAD_CASE (out_insnp
->spec_reg
->reg_size
);
2201 /* If there was a relocation specified for the immediate
2202 expression (i.e. it had a PIC or TLS modifier) check that the
2203 size of the relocation matches the size specified by
2205 if (out_insnp
->reloc
!= BFD_RELOC_NONE
2206 && (cris_get_specified_reloc_size (out_insnp
->reloc
)
2207 != (unsigned int) out_insnp
->imm_oprnd_size
))
2208 as_bad (out_insnp
->reloc
== BFD_RELOC_CRIS_32_GD
2209 || out_insnp
->reloc
== BFD_RELOC_CRIS_32_TPREL
2210 || out_insnp
->reloc
== BFD_RELOC_CRIS_16_TPREL
2211 || out_insnp
->reloc
== BFD_RELOC_CRIS_32_IE
2212 ? _("TLS relocation size does not match operand size")
2213 : _("PIC relocation size does not match operand size"));
2215 else if (instruction
->op
== cris_muls_op
2216 || instruction
->op
== cris_mulu_op
)
2217 out_insnp
->insn_type
= CRIS_INSN_MUL
;
2223 /* Get a B, W, or D size modifier from the string pointed out by *cPP,
2224 which must point to a '.' in front of the modifier. On successful
2225 return, *cPP is advanced to the character following the size
2226 modifier, and is undefined otherwise.
2228 cPP Pointer to pointer to string starting
2229 with the size modifier.
2231 size_bitsp Pointer to variable to contain the size bits on
2234 Return 1 iff a correct size modifier is found, else 0. */
2237 get_bwd_size_modifier (char **cPP
, int *size_bitsp
)
2243 /* Consume the '.'. */
2267 /* Consume the size letter. */
2273 /* Get a B or W size modifier from the string pointed out by *cPP,
2274 which must point to a '.' in front of the modifier. On successful
2275 return, *cPP is advanced to the character following the size
2276 modifier, and is undefined otherwise.
2278 cPP Pointer to pointer to string starting
2279 with the size modifier.
2281 size_bitsp Pointer to variable to contain the size bits on
2284 Return 1 iff a correct size modifier is found, else 0. */
2287 get_bw_size_modifier (char **cPP
, int *size_bitsp
)
2293 /* Consume the '.'. */
2312 /* Consume the size letter. */
2318 /* Get a general register from the string pointed out by *cPP. The
2319 variable *cPP is advanced to the character following the general
2320 register name on a successful return, and has its initial position
2323 cPP Pointer to pointer to string, beginning with a general
2326 regnop Pointer to int containing the register number.
2328 Return 1 iff a correct general register designator is found,
2332 get_gen_reg (char **cPP
, int *regnop
)
2337 /* Handle a sometimes-mandatory dollar sign as register prefix. */
2338 if (**cPP
== REGISTER_PREFIX_CHAR
)
2340 else if (demand_register_prefix
)
2347 /* "P" as in "PC"? Consume the "P". */
2350 if ((**cPP
== 'C' || **cPP
== 'c')
2351 && ! ISALNUM ((*cPP
)[1])
2352 /* Here's a little twist: For v32 and the compatibility mode,
2353 we only recognize PC as a register number if there's '+]'
2354 after. We don't consume that, but the presence can only be
2355 valid after a register in a post-increment context, which
2356 is also the only valid context for PC as a register for
2357 v32. Not that it's used very often, but saying "MOVE.D
2358 [PC+],R5" should remain valid. It's not supported for
2359 jump-type insns or other insns with no [Rn+] mode, though. */
2360 && ((cris_arch
!= arch_crisv32
2361 && cris_arch
!= arch_cris_common_v10_v32
)
2362 || ((*cPP
)[1] == '+' && (*cPP
)[2] == ']')))
2364 /* It's "PC": consume the "c" and we're done. */
2371 /* Like with PC, we recognize ACR, but only if it's *not* followed
2372 by '+', and only for v32. */
2375 if (cris_arch
!= arch_crisv32
2376 || ((*cPP
)[1] != 'c' && (*cPP
)[1] != 'C')
2377 || ((*cPP
)[2] != 'r' && (*cPP
)[2] != 'R')
2378 || ISALNUM ((*cPP
)[3])
2379 || (*cPP
)[3] == '+')
2387 /* Hopefully r[0-9] or r1[0-5]. Consume 'R' or 'r'. */
2390 if (ISDIGIT (**cPP
))
2392 /* It's r[0-9]. Consume and check the next digit. */
2393 *regnop
= **cPP
- '0';
2396 if (! ISALNUM (**cPP
))
2398 /* No more digits, we're done. */
2403 /* One more digit. Consume and add. */
2404 *regnop
= *regnop
* 10 + (**cPP
- '0');
2406 /* We need to check for a valid register number; Rn,
2407 0 <= n <= MAX_REG. */
2408 if (*regnop
<= MAX_REG
)
2410 /* Consume second digit. */
2420 /* "S" as in "SP"? Consume the "S". */
2422 if (**cPP
== 'P' || **cPP
== 'p')
2424 /* It's "SP": consume the "p" and we're done. */
2432 /* Just here to silence compilation warnings. */
2436 /* We get here if we fail. Restore the pointer. */
2441 /* Get a special register from the string pointed out by *cPP. The
2442 variable *cPP is advanced to the character following the special
2443 register name if one is found, and retains its original position
2446 cPP Pointer to pointer to string starting with a special register
2449 sregpp Pointer to Pointer to struct spec_reg, where a pointer to the
2450 register description will be stored.
2452 Return 1 iff a correct special register name is found. */
2455 get_spec_reg (char **cPP
, const struct cris_spec_reg
**sregpp
)
2459 char *name_begin
= *cPP
;
2461 const struct cris_spec_reg
*sregp
;
2463 /* Handle a sometimes-mandatory dollar sign as register prefix. */
2464 if (*name_begin
== REGISTER_PREFIX_CHAR
)
2466 else if (demand_register_prefix
)
2469 /* Loop over all special registers. */
2470 for (sregp
= cris_spec_regs
; sregp
->name
!= NULL
; sregp
++)
2472 /* Start over from beginning of the supposed name. */
2476 while (*s2
!= '\0' && TOLOWER (*s1
) == *s2
)
2482 /* For a match, we must have consumed the name in the table, and we
2483 must be outside what could be part of a name. Assume here that a
2484 test for alphanumerics is sufficient for a name test. */
2485 if (*s2
== 0 && ! ISALNUM (*s1
)
2486 && cris_insn_ver_valid_for_arch (sregp
->applicable_version
,
2489 /* We have a match. Update the pointer and be done. */
2496 /* If we got here, we did not find any name. */
2500 /* Get a support register from the string pointed out by *cPP. The
2501 variable *cPP is advanced to the character following the support-
2502 register name if one is found, and retains its original position
2505 cPP Pointer to pointer to string starting with a support-register
2508 sregpp Pointer to int containing the register number.
2510 Return 1 iff a correct support-register name is found. */
2513 get_sup_reg (char **cPP
, int *regnop
)
2517 char *name_begin
= *cPP
;
2519 const struct cris_support_reg
*sregp
;
2521 /* Handle a sometimes-mandatory dollar sign as register prefix. */
2522 if (*name_begin
== REGISTER_PREFIX_CHAR
)
2524 else if (demand_register_prefix
)
2527 /* Loop over all support-registers. */
2528 for (sregp
= cris_support_regs
; sregp
->name
!= NULL
; sregp
++)
2530 /* Start over from beginning of the supposed name. */
2534 while (*s2
!= '\0' && TOLOWER (*s1
) == *s2
)
2540 /* For a match, we must have consumed the name in the table, and we
2541 must be outside what could be part of a name. Assume here that a
2542 test for alphanumerics is sufficient for a name test. */
2543 if (*s2
== 0 && ! ISALNUM (*s1
))
2545 /* We have a match. Update the pointer and be done. */
2547 *regnop
= sregp
->number
;
2552 /* If we got here, we did not find any name. */
2556 /* Get an unprefixed or side-effect-prefix operand from the string pointed
2557 out by *cPP. The pointer *cPP is advanced to the character following
2558 the indirect operand if we have success, else it contains an undefined
2561 cPP Pointer to pointer to string beginning with the first
2562 character of the supposed operand.
2564 prefixp Pointer to structure containing an optional instruction
2567 is_autoincp Pointer to int indicating the indirect or autoincrement
2570 src_regnop Pointer to int containing the source register number in
2573 imm_foundp Pointer to an int indicating if an immediate expression
2576 imm_exprP Pointer to a structure containing an immediate
2577 expression, if success and if *imm_foundp is nonzero.
2579 Return 1 iff a correct indirect operand is found. */
2582 get_autoinc_prefix_or_indir_op (char **cPP
, struct cris_prefix
*prefixp
,
2583 int *is_autoincp
, int *src_regnop
,
2584 int *imm_foundp
, expressionS
*imm_exprP
)
2586 /* Assume there was no immediate mode expression. */
2591 /* So this operand is one of:
2593 Autoincrement: [rN+]
2594 Indexed with assign: [rN=rM+rO.S]
2595 Offset with assign: [rN=rM+I], [rN=rM+[rO].s], [rN=rM+[rO+].s]
2597 Either way, consume the '['. */
2600 /* Get the rN register. */
2601 if (! get_gen_reg (cPP
, src_regnop
))
2602 /* If there was no register, then this cannot match. */
2606 /* We got the register, now check the next character. */
2610 /* Indirect mode. We're done here. */
2611 prefixp
->kind
= PREFIX_NONE
;
2616 /* This must be an auto-increment mode, if there's a
2618 prefixp
->kind
= PREFIX_NONE
;
2621 /* We consume this character and break out to check the
2627 /* This must be indexed with assign, or offset with assign
2628 to match. Not supported for crisv32 or in
2629 compatibility mode. */
2630 if (cris_arch
== arch_crisv32
2631 || cris_arch
== arch_cris_common_v10_v32
)
2636 /* Either way, the next thing must be a register. */
2637 if (! get_gen_reg (cPP
, &prefixp
->base_reg_number
))
2638 /* No register, no match. */
2642 /* We've consumed "[rN=rM", so we must be looking at
2643 "+rO.s]" or "+I]", or "-I]", or "+[rO].s]" or
2647 int index_reg_number
;
2653 /* This must be [rx=ry+[rz].s] or
2654 [rx=ry+[rz+].s] or no match. We must be
2655 looking at rz after consuming the '['. */
2658 if (!get_gen_reg (cPP
, &index_reg_number
))
2661 prefixp
->kind
= PREFIX_BDAP
;
2663 = (BDAP_INDIR_OPCODE
2664 + (prefixp
->base_reg_number
<< 12)
2665 + index_reg_number
);
2669 /* We've seen "[rx=ry+[rz+" here, so now we
2670 know that there must be "].s]" left to
2673 prefixp
->opcode
|= AUTOINCR_BIT
<< 8;
2676 /* If it wasn't autoincrement, we don't need to
2679 /* Check the next-to-last ']'. */
2685 /* Check the ".s" modifier. */
2686 if (! get_bwd_size_modifier (cPP
, &size_bits
))
2689 prefixp
->opcode
|= size_bits
<< 4;
2691 /* Now we got [rx=ry+[rz+].s or [rx=ry+[rz].s.
2692 We break out to check the final ']'. */
2695 /* It wasn't an indirection. Check if it's a
2697 else if (get_gen_reg (cPP
, &index_reg_number
))
2701 /* Indexed with assign mode: "[rN+rM.S]". */
2702 prefixp
->kind
= PREFIX_BIAP
;
2704 = (BIAP_OPCODE
+ (index_reg_number
<< 12)
2705 + prefixp
->base_reg_number
/* << 0 */);
2707 if (! get_bwd_size_modifier (cPP
, &size_bits
))
2708 /* Size missing, this isn't a match. */
2712 /* Size found, break out to check the
2714 prefixp
->opcode
|= size_bits
<< 4;
2718 /* Not a register. Then this must be "[rN+I]". */
2719 else if (cris_get_expression (cPP
, &prefixp
->expr
))
2721 /* We've got offset with assign mode. Fill
2722 in the blanks and break out to match the
2724 prefixp
->kind
= PREFIX_BDAP_IMM
;
2726 /* We tentatively put an opcode corresponding to
2727 a 32-bit operand here, although it may be
2728 relaxed when there's no relocation
2729 specifier for the operand. */
2731 = (BDAP_INDIR_OPCODE
2732 | (prefixp
->base_reg_number
<< 12)
2733 | (AUTOINCR_BIT
<< 8)
2735 | REG_PC
/* << 0 */);
2737 /* This can have a PIC suffix, specifying reloc
2739 if ((pic
|| tls
) && **cPP
== RELOC_SUFFIX_CHAR
)
2741 unsigned int relocsize
;
2743 cris_get_reloc_suffix (cPP
, &prefixp
->reloc
,
2746 /* Tweak the size of the immediate operand
2747 in the prefix opcode if it isn't what we
2750 = cris_get_specified_reloc_size (prefixp
->reloc
);
2753 = ((prefixp
->opcode
& ~(3 << 4))
2754 | ((relocsize
>> 1) << 4));
2759 /* Neither register nor expression found, so
2760 this can't be a match. */
2763 /* Not "[rN+" but perhaps "[rN-"? */
2764 else if (**cPP
== '-')
2766 /* We must have an offset with assign mode. */
2767 if (! cris_get_expression (cPP
, &prefixp
->expr
))
2768 /* No expression, no match. */
2772 /* We've got offset with assign mode. Fill
2773 in the blanks and break out to match the
2776 Note that we don't allow a relocation
2777 suffix for an operand with a minus
2779 prefixp
->kind
= PREFIX_BDAP_IMM
;
2784 /* Neither '+' nor '-' after "[rN=rM". Lose. */
2788 /* Neither ']' nor '+' nor '=' after "[rN". Lose. */
2793 /* When we get here, we have a match and will just check the closing
2794 ']'. We can still fail though. */
2799 /* Don't forget to consume the final ']'.
2800 Then return in glory. */
2805 /* No indirection. Perhaps a constant? */
2806 else if (cris_get_expression (cPP
, imm_exprP
))
2808 /* Expression found, this is immediate mode. */
2809 prefixp
->kind
= PREFIX_NONE
;
2811 *src_regnop
= REG_PC
;
2814 /* This can have a PIC suffix, specifying reloc type to use. The
2815 caller must check that the reloc size matches the operand size. */
2816 if ((pic
|| tls
) && **cPP
== RELOC_SUFFIX_CHAR
)
2817 cris_get_reloc_suffix (cPP
, &prefixp
->reloc
, imm_exprP
);
2822 /* No luck today. */
2826 /* This function gets an indirect operand in a three-address operand
2827 combination from the string pointed out by *cPP. The pointer *cPP is
2828 advanced to the character following the indirect operand on success, or
2829 has an unspecified value on failure.
2831 cPP Pointer to pointer to string beginning
2834 prefixp Pointer to structure containing an
2837 Returns 1 iff a correct indirect operand is found. */
2840 get_3op_or_dip_prefix_op (char **cPP
, struct cris_prefix
*prefixp
)
2845 /* We must have a '[' or it's a clean failure. */
2848 /* Eat the first '['. */
2853 /* A second '[', so this must be double-indirect mode. */
2855 prefixp
->kind
= PREFIX_DIP
;
2856 prefixp
->opcode
= DIP_OPCODE
;
2858 /* Get the register or fail entirely. */
2859 if (! get_gen_reg (cPP
, ®_number
))
2863 prefixp
->opcode
|= reg_number
/* << 0 */ ;
2866 /* Since we found a '+', this must be double-indirect
2867 autoincrement mode. */
2869 prefixp
->opcode
|= AUTOINCR_BIT
<< 8;
2872 /* There's nothing particular to do, if this was a
2873 double-indirect *without* autoincrement. */
2876 /* Check the first ']'. The second one is checked at the end. */
2880 /* Eat the first ']', so we'll be looking at a second ']'. */
2883 /* No second '['. Then we should have a register here, making
2885 else if (get_gen_reg (cPP
, &prefixp
->base_reg_number
))
2887 /* This must be indexed or offset mode: "[rN+I]" or
2888 "[rN+rM.S]" or "[rN+[rM].S]" or "[rN+[rM+].S]". */
2891 int index_reg_number
;
2897 /* This is "[rx+["... Expect a register next. */
2901 if (!get_gen_reg (cPP
, &index_reg_number
))
2904 prefixp
->kind
= PREFIX_BDAP
;
2906 = (BDAP_INDIR_OPCODE
2907 + (prefixp
->base_reg_number
<< 12)
2908 + index_reg_number
);
2910 /* We've seen "[rx+[ry", so check if this is
2914 /* Yep, now at "[rx+[ry+". */
2916 prefixp
->opcode
|= AUTOINCR_BIT
<< 8;
2918 /* If it wasn't autoincrement, we don't need to
2921 /* Check a first closing ']': "[rx+[ry]" or
2927 /* Now expect a size modifier ".S". */
2928 if (! get_bwd_size_modifier (cPP
, &size_bits
))
2931 prefixp
->opcode
|= size_bits
<< 4;
2933 /* Ok, all interesting stuff has been seen:
2934 "[rx+[ry+].S" or "[rx+[ry].S". We only need to
2935 expect a final ']', which we'll do in a common
2938 /* Seen "[rN+", but not a '[', so check if we have a
2940 else if (get_gen_reg (cPP
, &index_reg_number
))
2942 /* This is indexed mode: "[rN+rM.S]" or
2945 prefixp
->kind
= PREFIX_BIAP
;
2948 | prefixp
->base_reg_number
/* << 0 */
2949 | (index_reg_number
<< 12));
2951 /* Consume the ".S". */
2952 if (! get_bwd_size_modifier (cPP
, &size_bits
))
2953 /* Missing size, so fail. */
2956 /* Size found. Add that piece and drop down to
2957 the common checking of the closing ']'. */
2958 prefixp
->opcode
|= size_bits
<< 4;
2960 /* Seen "[rN+", but not a '[' or a register, so then
2961 it must be a constant "I".
2963 As a quality of implementation improvement, we check for a
2964 closing ']', like in an erroneous "[rN+]". If we don't,
2965 the expression parser will emit a confusing "bad
2966 expression" when it sees the ']', probably because it
2967 doesn't like seeing no expression. */
2968 else if (**cPP
!= ']' && cris_get_expression (cPP
, &prefixp
->expr
))
2970 /* Expression found, so fill in the bits of offset
2971 mode and drop down to check the closing ']'. */
2972 prefixp
->kind
= PREFIX_BDAP_IMM
;
2974 /* We tentatively put an opcode corresponding to a 32-bit
2975 operand here, although it may be relaxed when there's no
2976 PIC specifier for the operand. */
2978 = (BDAP_INDIR_OPCODE
2979 | (prefixp
->base_reg_number
<< 12)
2980 | (AUTOINCR_BIT
<< 8)
2982 | REG_PC
/* << 0 */);
2984 /* This can have a PIC suffix, specifying reloc type to use. */
2985 if ((pic
|| tls
) && **cPP
== RELOC_SUFFIX_CHAR
)
2987 unsigned int relocsize
;
2989 cris_get_reloc_suffix (cPP
, &prefixp
->reloc
, &prefixp
->expr
);
2991 /* Tweak the size of the immediate operand in the prefix
2992 opcode if it isn't what we set. */
2993 relocsize
= cris_get_specified_reloc_size (prefixp
->reloc
);
2996 = ((prefixp
->opcode
& ~(3 << 4))
2997 | ((relocsize
>> 1) << 4));
3001 /* Nothing valid here: lose. */
3004 /* Seen "[rN" but no '+', so check if it's a '-'. */
3005 else if (**cPP
== '-')
3007 /* Yep, we must have offset mode. */
3008 if (! cris_get_expression (cPP
, &prefixp
->expr
))
3009 /* No expression, so we lose. */
3013 /* Expression found to make this offset mode, so
3014 fill those bits and drop down to check the
3017 Note that we don't allow a PIC suffix for
3018 an operand with a minus sign like this. */
3019 prefixp
->kind
= PREFIX_BDAP_IMM
;
3024 /* We've seen "[rN", but not '+' or '-'; rather a ']'.
3025 Hmm. Normally this is a simple indirect mode that we
3026 shouldn't match, but if we expect ']', then we have a
3027 zero offset, so it can be a three-address-operand,
3028 like "[rN],rO,rP", thus offset mode.
3030 Don't eat the ']', that will be done in the closing
3032 prefixp
->expr
.X_op
= O_constant
;
3033 prefixp
->expr
.X_add_number
= 0;
3034 prefixp
->expr
.X_add_symbol
= NULL
;
3035 prefixp
->expr
.X_op_symbol
= NULL
;
3036 prefixp
->kind
= PREFIX_BDAP_IMM
;
3039 /* A '[', but no second '[', and no register. Check if we
3040 have an expression, making this "[I]" for a double-indirect
3042 else if (cris_get_expression (cPP
, &prefixp
->expr
))
3044 /* Expression found, the so called absolute mode for a
3045 double-indirect prefix on PC. */
3046 prefixp
->kind
= PREFIX_DIP
;
3047 prefixp
->opcode
= DIP_OPCODE
| (AUTOINCR_BIT
<< 8) | REG_PC
;
3048 prefixp
->reloc
= BFD_RELOC_32
;
3050 /* For :GD and :IE, it makes sense to have TLS specifiers here. */
3051 if ((pic
|| tls
) && **cPP
== RELOC_SUFFIX_CHAR
)
3052 cris_get_reloc_suffix (cPP
, &prefixp
->reloc
, &prefixp
->expr
);
3055 /* Neither '[' nor register nor expression. We lose. */
3058 /* We get here as a closing ceremony to a successful match. We just
3059 need to check the closing ']'. */
3061 /* Oops. Close but no air-polluter. */
3064 /* Don't forget to consume that ']', before returning in glory. */
3069 /* Get an expression from the string pointed out by *cPP.
3070 The pointer *cPP is advanced to the character following the expression
3071 on a success, or retains its original value otherwise.
3073 cPP Pointer to pointer to string beginning with the expression.
3075 exprP Pointer to structure containing the expression.
3077 Return 1 iff a correct expression is found. */
3080 cris_get_expression (char **cPP
, expressionS
*exprP
)
3082 char *saved_input_line_pointer
;
3085 /* The "expression" function expects to find an expression at the
3086 global variable input_line_pointer, so we have to save it to give
3087 the impression that we don't fiddle with global variables. */
3088 saved_input_line_pointer
= input_line_pointer
;
3089 input_line_pointer
= *cPP
;
3091 /* Avoid a common error, confusing addressing modes. Beware that the
3092 call to expression below does not signal that error; it treats []
3093 as parentheses, unless #define NEED_INDEX_OPERATOR in which case it
3094 gives them other confusing semantics rather than plain outlawing
3095 them, which is what we want. */
3096 if (*input_line_pointer
== '[')
3098 input_line_pointer
= saved_input_line_pointer
;
3102 exp
= expression (exprP
);
3103 if (exprP
->X_op
== O_illegal
|| exprP
->X_op
== O_absent
)
3105 input_line_pointer
= saved_input_line_pointer
;
3109 /* Everything seems to be fine, just restore the global
3110 input_line_pointer and say we're successful. */
3111 *cPP
= input_line_pointer
;
3112 input_line_pointer
= saved_input_line_pointer
;
3116 /* Get a sequence of flag characters from *spp. The pointer *cPP is
3117 advanced to the character following the expression. The flag
3118 characters are consecutive, no commas or spaces.
3120 cPP Pointer to pointer to string beginning with the expression.
3122 flagp Pointer to int to return the flags expression.
3124 Return 1 iff a correct flags expression is found. */
3127 get_flags (char **cPP
, int *flagsp
)
3135 if (! cris_insn_ver_valid_for_arch (cris_ver_v0_3
,
3143 if (! cris_insn_ver_valid_for_arch (cris_ver_v8_10
,
3151 if (! cris_insn_ver_valid_for_arch (cris_ver_v0_3
,
3159 if (! cris_insn_ver_valid_for_arch (cris_ver_v8_10
,
3167 if (! cris_insn_ver_valid_for_arch (cris_ver_v32p
,
3175 if (! cris_insn_ver_valid_for_arch (cris_ver_v32p
,
3212 /* We consider this successful if we stop at a comma or
3213 whitespace. Anything else, and we consider it a failure. */
3216 && ! ISSPACE (**cPP
))
3222 /* Don't forget to consume each flag character. */
3227 /* Generate code and fixes for a BDAP prefix.
3228 For v32, this handles ADDOQ because thankfully the opcodes are the
3231 base_regno Int containing the base register number.
3233 exprP Pointer to structure containing the offset expression. */
3236 gen_bdap (int base_regno
, expressionS
*exprP
)
3238 unsigned int opcode
;
3241 /* Put out the prefix opcode; assume quick immediate mode at first. */
3242 opcode
= BDAP_QUICK_OPCODE
| (base_regno
<< 12);
3243 opcodep
= cris_insn_first_word_frag ();
3244 md_number_to_chars (opcodep
, opcode
, 2);
3246 if (exprP
->X_op
== O_constant
)
3248 /* We have an absolute expression that we know the size of right
3253 value
= exprP
->X_add_number
;
3254 if (value
< -32768 || value
> 32767)
3255 /* Outside range for a "word", make it a dword. */
3258 /* Assume "word" size. */
3261 /* If this is a signed-byte value, we can fit it into the prefix
3263 if (value
>= -128 && value
<= 127)
3267 /* This is a word or dword displacement, which will be put in a
3268 word or dword after the prefix. */
3271 opcodep
[0] = BDAP_PC_LOW
+ (size
<< 4);
3273 opcodep
[1] |= BDAP_INCR_HIGH
;
3274 p
= frag_more (1 << size
);
3275 md_number_to_chars (p
, value
, 1 << size
);
3280 /* Handle complex expressions. */
3282 = SIMPLE_EXPR (exprP
) ? exprP
->X_add_number
: 0;
3284 = (SIMPLE_EXPR (exprP
)
3285 ? exprP
->X_add_symbol
: make_expr_symbol (exprP
));
3287 /* The expression is not defined yet but may become absolute. We
3288 make it a relocation to be relaxed. */
3289 frag_var (rs_machine_dependent
, 4, 0,
3290 ENCODE_RELAX (STATE_BASE_PLUS_DISP_PREFIX
, STATE_UNDF
),
3291 sym
, addvalue
, opcodep
);
3295 /* Encode a branch displacement in the range -256..254 into the form used
3296 by CRIS conditional branch instructions.
3298 offset The displacement value in bytes. */
3301 branch_disp (int offset
)
3305 /* Adjust all short branch offsets here. */
3306 if (cris_arch
== arch_crisv32
|| cris_arch
== arch_cris_common_v10_v32
)
3309 disp
= offset
& 0xFE;
3317 /* Generate code and fixes for a 32-bit conditional branch instruction
3318 created by "extending" an existing 8-bit branch instruction.
3320 opcodep Pointer to the word containing the original 8-bit branch
3323 writep Pointer to "extension area" following the first instruction
3326 fragP Pointer to the frag containing the instruction.
3328 add_symP, Parts of the destination address expression.
3333 gen_cond_branch_32 (char *opcodep
, char *writep
, fragS
*fragP
,
3334 symbolS
*add_symP
, symbolS
*sub_symP
, long int add_num
)
3340 if (cris_arch
== arch_crisv32
)
3342 nop_opcode
= NOP_OPCODE_V32
;
3344 branch_offset
= -2 - 8;
3348 nop_opcode
= NOP_OPCODE
;
3350 branch_offset
= -2 - 8;
3354 nop_opcode
= NOP_OPCODE
;
3356 branch_offset
= -2 - 6;
3359 /* We should never get here for compatibility mode. */
3360 if (cris_arch
== arch_cris_common_v10_v32
)
3361 as_fatal (_("Calling gen_cond_branch_32 for .arch common_v10_v32\n"));
3363 if (warn_for_branch_expansion
)
3364 as_warn_where (fragP
->fr_file
, fragP
->fr_line
,
3365 _("32-bit conditional branch generated"));
3367 /* Here, writep points to what will be opcodep + 2. First, we change
3368 the actual branch in opcodep[0] and opcodep[1], so that in the
3369 final insn, it will look like:
3372 This means we don't have to worry about changing the opcode or
3373 messing with the delay-slot instruction. So, we move it to last in
3374 the "extended" branch, and just change the displacement. Admittedly,
3375 it's not the optimal extended construct, but we should get this
3376 rarely enough that it shouldn't matter. */
3378 writep
[opc_offset
] = branch_disp (branch_offset
);
3379 writep
[opc_offset
+ 1] = opcodep
[1];
3381 /* Then, we change the branch to an unconditional branch over the
3382 extended part, to the new location of the Bcc:
3386 Note that these two writes are to currently different locations,
3389 md_number_to_chars (opcodep
, BA_QUICK_OPCODE
3390 + (cris_arch
== arch_crisv32
? 12 : (pic
? 10 : 8)),
3392 md_number_to_chars (writep
, nop_opcode
, 2);
3394 /* Then the extended thing, the 32-bit jump insn.
3395 opcodep+4: JUMP [PC+]
3396 or, in the PIC case,
3397 opcodep+4: MOVE [PC=PC+N],P0. */
3399 md_number_to_chars (writep
+ 2,
3400 cris_arch
== arch_crisv32
3402 : (pic
? MOVE_PC_INCR_OPCODE_PREFIX
3403 : JUMP_PC_INCR_OPCODE
), 2);
3405 /* We have to fill in the actual value too.
3407 This is most probably an expression, but we can cope with an absolute
3408 value too. FIXME: Testcase needed with and without pic. */
3410 if (add_symP
== NULL
&& sub_symP
== NULL
)
3412 /* An absolute address. */
3413 if (pic
|| cris_arch
== arch_crisv32
)
3414 fix_new (fragP
, writep
+ 4 - fragP
->fr_literal
, 4,
3415 section_symbol (absolute_section
),
3417 + (cris_arch
== arch_crisv32
? 6 : 0),
3418 1, BFD_RELOC_32_PCREL
);
3420 md_number_to_chars (writep
+ 4, add_num
, 4);
3424 if (sub_symP
!= NULL
)
3425 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
3426 _("Complex expression not supported"));
3428 /* Not absolute, we have to make it a frag for later evaluation. */
3429 fix_new (fragP
, writep
+ 4 - fragP
->fr_literal
, 4, add_symP
,
3430 add_num
+ (cris_arch
== arch_crisv32
? 6 : 0),
3431 pic
|| cris_arch
== arch_crisv32
? 1 : 0,
3432 pic
|| cris_arch
== arch_crisv32
3433 ? BFD_RELOC_32_PCREL
: BFD_RELOC_32
);
3436 if (cris_arch
== arch_crisv32
)
3437 /* Follow it with a "NOP" for CRISv32. */
3438 md_number_to_chars (writep
+ 8, NOP_OPCODE_V32
, 2);
3440 /* ...and the rest of the move-opcode for pre-v32 PIC. */
3441 md_number_to_chars (writep
+ 8, MOVE_PC_INCR_OPCODE_SUFFIX
, 2);
3444 /* Get the size of an immediate-reloc in bytes. Only valid for
3445 specified relocs (TLS, PIC). */
3448 cris_get_specified_reloc_size (bfd_reloc_code_real_type reloc
)
3451 reloc
== BFD_RELOC_CRIS_16_GOTPLT
3452 || reloc
== BFD_RELOC_CRIS_16_GOT
3453 || reloc
== BFD_RELOC_CRIS_16_GOT_GD
3454 || reloc
== BFD_RELOC_CRIS_16_DTPREL
3455 || reloc
== BFD_RELOC_CRIS_16_GOT_TPREL
3456 || reloc
== BFD_RELOC_CRIS_16_TPREL
3460 /* Store a reloc type at *RELOCP corresponding to the PIC suffix at *CPP.
3461 Adjust *EXPRP with any addend found after the PIC suffix. */
3464 cris_get_reloc_suffix (char **cPP
, bfd_reloc_code_real_type
*relocp
,
3469 expressionS const_expr
;
3471 const struct pic_suffixes_struct
3473 const char *const suffix
;
3475 bfd_reloc_code_real_type reloc
;
3481 #define PICMAP(s, r) {s, sizeof (s) - 1, r, TRUE, FALSE}
3482 #define PICTLSMAP(s, r) {s, sizeof (s) - 1, r, TRUE, TRUE}
3483 #define TLSMAP(s, r) {s, sizeof (s) - 1, r, FALSE, TRUE}
3484 /* Keep this in order with longest unambiguous prefix first. */
3485 PICMAP ("GOTPLT16", BFD_RELOC_CRIS_16_GOTPLT
),
3486 PICMAP ("GOTPLT", BFD_RELOC_CRIS_32_GOTPLT
),
3487 PICMAP ("PLTG", BFD_RELOC_CRIS_32_PLT_GOTREL
),
3488 PICMAP ("PLT", BFD_RELOC_CRIS_32_PLT_PCREL
),
3489 PICMAP ("GOTOFF", BFD_RELOC_CRIS_32_GOTREL
),
3490 PICMAP ("GOT16", BFD_RELOC_CRIS_16_GOT
),
3491 PICMAP ("GOT", BFD_RELOC_CRIS_32_GOT
),
3492 PICTLSMAP ("GDGOTREL16", BFD_RELOC_CRIS_16_GOT_GD
),
3493 PICTLSMAP ("GDGOTREL", BFD_RELOC_CRIS_32_GOT_GD
),
3494 TLSMAP ("GD", BFD_RELOC_CRIS_32_GD
),
3495 PICTLSMAP ("DTPREL16", BFD_RELOC_CRIS_16_DTPREL
),
3496 PICTLSMAP ("DTPREL", BFD_RELOC_CRIS_32_DTPREL
),
3497 TLSMAP ("IE", BFD_RELOC_CRIS_32_IE
),
3498 PICTLSMAP ("TPOFFGOT16", BFD_RELOC_CRIS_16_GOT_TPREL
),
3499 PICTLSMAP ("TPOFFGOT", BFD_RELOC_CRIS_32_GOT_TPREL
),
3500 TLSMAP ("TPOFF16", BFD_RELOC_CRIS_16_TPREL
),
3501 TLSMAP ("TPOFF", BFD_RELOC_CRIS_32_TPREL
)
3504 /* We've already seen the ':', so consume it. */
3507 for (i
= 0; i
< sizeof (pic_suffixes
)/sizeof (pic_suffixes
[0]); i
++)
3509 if (strncmp (s
, pic_suffixes
[i
].suffix
, pic_suffixes
[i
].len
) == 0
3510 && ! is_part_of_name (s
[pic_suffixes
[i
].len
])
3511 /* PIC and non-PIC relocations are exclusive. */
3512 && (pic
!= 0) == (pic_suffixes
[i
].pic_p
!= 0)
3513 /* But TLS can be active for non-TLS relocations too. */
3514 && (pic_suffixes
[i
].tls_p
== 0 || tls
))
3516 /* We have a match. Consume the suffix and set the relocation
3518 s
+= pic_suffixes
[i
].len
;
3520 /* There can be a constant term appended. If so, we will add it
3522 if (*s
== '+' || *s
== '-')
3524 if (! cris_get_expression (&s
, &const_expr
))
3525 /* There was some kind of syntax error. Bail out. */
3528 /* Allow complex expressions as the constant part. It still
3529 has to be an assembly-time constant or there will be an
3530 error emitting the reloc. This makes the PIC qualifiers
3531 idempotent; foo:GOTOFF+32 == foo+32:GOTOFF. The former we
3532 recognize here; the latter is parsed in the incoming
3534 exprP
->X_add_symbol
= make_expr_symbol (exprP
);
3535 exprP
->X_op
= O_add
;
3536 exprP
->X_add_number
= 0;
3537 exprP
->X_op_symbol
= make_expr_symbol (&const_expr
);
3540 *relocp
= pic_suffixes
[i
].reloc
;
3546 /* No match. Don't consume anything; fall back and there will be a
3550 /* This *could* have been:
3552 Turn a string in input_line_pointer into a floating point constant
3553 of type TYPE, and store the appropriate bytes in *LITP. The number
3554 of LITTLENUMS emitted is stored in *SIZEP.
3556 type A character from FLTCHARS that describes what kind of
3557 floating-point number is wanted.
3559 litp A pointer to an array that the result should be stored in.
3561 sizep A pointer to an integer where the size of the result is stored.
3563 But we don't support floating point constants in assembly code *at all*,
3564 since it's suboptimal and just opens up bug opportunities. GCC emits
3565 the bit patterns as hex. All we could do here is to emit what GCC
3566 would have done in the first place. *Nobody* writes floating-point
3567 code as assembly code, but if they do, they should be able enough to
3568 find out the correct bit patterns and use them. */
3571 md_atof (int type ATTRIBUTE_UNUSED
, char *litp ATTRIBUTE_UNUSED
,
3572 int *sizep ATTRIBUTE_UNUSED
)
3574 /* FIXME: Is this function mentioned in the internals.texi manual? If
3576 return _("Bad call to md_atof () - floating point formats are not supported");
3579 /* Turn a number as a fixS * into a series of bytes that represents the
3580 number on the target machine. The purpose of this procedure is the
3581 same as that of md_number_to_chars but this procedure is supposed to
3582 handle general bit field fixes and machine-dependent fixups.
3584 bufp Pointer to an array where the result should be stored.
3586 val The value to store.
3588 n The number of bytes in "val" that should be stored.
3590 fixP The fix to be applied to the bit field starting at bufp.
3592 seg The segment containing this number. */
3595 cris_number_to_imm (char *bufp
, long val
, int n
, fixS
*fixP
, segT seg
)
3602 /* We put the relative "vma" for the other segment for inter-segment
3603 relocations in the object data to stay binary "compatible" (with an
3604 uninteresting old version) for the relocation.
3605 Maybe delete some day. */
3607 && (sym_seg
= S_GET_SEGMENT (fixP
->fx_addsy
)) != seg
)
3608 val
+= sym_seg
->vma
;
3610 if (fixP
->fx_addsy
!= NULL
|| fixP
->fx_pcrel
)
3611 switch (fixP
->fx_r_type
)
3613 /* These must be fully resolved when getting here. */
3614 case BFD_RELOC_16_PCREL
:
3615 case BFD_RELOC_8_PCREL
:
3616 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
3617 _("PC-relative relocation must be trivially resolved"));
3622 /* Only use the computed value for old-arch binaries. For all
3623 others, where we're going to output a relocation, put 0 in the
3625 if (cris_arch
!= arch_cris_any_v0_v10
3626 && (fixP
->fx_addsy
!= NULL
|| fixP
->fx_pcrel
))
3629 switch (fixP
->fx_r_type
)
3631 /* Ditto here, we put the addend into the object code as
3632 well as the reloc addend. Keep it that way for now, to simplify
3633 regression tests on the object file contents. FIXME: Seems
3634 uninteresting now that we have a test suite. */
3636 case BFD_RELOC_CRIS_32_GOT_GD
:
3637 case BFD_RELOC_CRIS_16_GOT_GD
:
3638 case BFD_RELOC_CRIS_32_GD
:
3639 case BFD_RELOC_CRIS_32_IE
:
3640 case BFD_RELOC_CRIS_32_DTPREL
:
3641 case BFD_RELOC_CRIS_16_DTPREL
:
3642 case BFD_RELOC_CRIS_32_GOT_TPREL
:
3643 case BFD_RELOC_CRIS_16_GOT_TPREL
:
3644 case BFD_RELOC_CRIS_32_TPREL
:
3645 case BFD_RELOC_CRIS_16_TPREL
:
3646 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
3647 if (IS_ELF
&& fixP
->fx_addsy
!= NULL
)
3648 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
3652 case BFD_RELOC_CRIS_16_GOT
:
3653 case BFD_RELOC_CRIS_32_GOT
:
3654 case BFD_RELOC_CRIS_32_GOTREL
:
3655 case BFD_RELOC_CRIS_16_GOTPLT
:
3656 case BFD_RELOC_CRIS_32_GOTPLT
:
3657 case BFD_RELOC_CRIS_32_PLT_GOTREL
:
3658 case BFD_RELOC_CRIS_32_PLT_PCREL
:
3659 /* We don't want to put in any kind of non-zero bits in the data
3660 being relocated for these. */
3661 md_number_to_chars (bufp
, 0, n
);
3664 case BFD_RELOC_32_PCREL
:
3665 /* If this one isn't fully resolved, we don't want to put non-zero
3667 if (fixP
->fx_addsy
!= NULL
|| fixP
->fx_pcrel
)
3672 /* No use having warnings here, since most hosts have a 32-bit type
3673 for "long" (which will probably change soon, now that I wrote
3675 bufp
[3] = (val
>> 24) & 0xFF;
3676 bufp
[2] = (val
>> 16) & 0xFF;
3677 bufp
[1] = (val
>> 8) & 0xFF;
3678 bufp
[0] = val
& 0xFF;
3681 /* FIXME: The 16 and 8-bit cases should have a way to check
3682 whether a signed or unsigned (or any signedness) number is
3686 case BFD_RELOC_16_PCREL
:
3687 if (val
> 0xffff || val
< -32768)
3688 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
3689 _("Value not in 16 bit range: %ld"), val
);
3690 bufp
[1] = (val
>> 8) & 0xFF;
3691 bufp
[0] = val
& 0xFF;
3694 case BFD_RELOC_CRIS_SIGNED_16
:
3695 if (val
> 32767 || val
< -32768)
3696 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
3697 _("Value not in 16 bit signed range: %ld"), val
);
3698 bufp
[1] = (val
>> 8) & 0xFF;
3699 bufp
[0] = val
& 0xFF;
3703 case BFD_RELOC_8_PCREL
:
3704 if (val
> 255 || val
< -128)
3705 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("Value not in 8 bit range: %ld"), val
);
3706 bufp
[0] = val
& 0xFF;
3709 case BFD_RELOC_CRIS_SIGNED_8
:
3710 if (val
> 127 || val
< -128)
3711 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
3712 _("Value not in 8 bit signed range: %ld"), val
);
3713 bufp
[0] = val
& 0xFF;
3716 case BFD_RELOC_CRIS_LAPCQ_OFFSET
:
3717 /* FIXME: Test-cases for out-of-range values. Probably also need
3718 to use as_bad_where. */
3719 case BFD_RELOC_CRIS_UNSIGNED_4
:
3720 if (val
> 15 || val
< 0)
3721 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
3722 _("Value not in 4 bit unsigned range: %ld"), val
);
3723 bufp
[0] |= val
& 0x0F;
3726 case BFD_RELOC_CRIS_UNSIGNED_5
:
3727 if (val
> 31 || val
< 0)
3728 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
3729 _("Value not in 5 bit unsigned range: %ld"), val
);
3730 bufp
[0] |= val
& 0x1F;
3733 case BFD_RELOC_CRIS_SIGNED_6
:
3734 if (val
> 31 || val
< -32)
3735 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
3736 _("Value not in 6 bit range: %ld"), val
);
3737 bufp
[0] |= val
& 0x3F;
3740 case BFD_RELOC_CRIS_UNSIGNED_6
:
3741 if (val
> 63 || val
< 0)
3742 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
3743 _("Value not in 6 bit unsigned range: %ld"), val
);
3744 bufp
[0] |= val
& 0x3F;
3747 case BFD_RELOC_CRIS_BDISP8
:
3748 bufp
[0] = branch_disp (val
);
3751 case BFD_RELOC_NONE
:
3752 /* May actually happen automatically. For example at broken
3753 words, if the word turns out not to be broken.
3754 FIXME: When? Which testcase? */
3755 if (! fixP
->fx_addsy
)
3756 md_number_to_chars (bufp
, val
, n
);
3759 case BFD_RELOC_VTABLE_INHERIT
:
3760 /* This borrowed from tc-ppc.c on a whim. */
3762 && !S_IS_DEFINED (fixP
->fx_addsy
)
3763 && !S_IS_WEAK (fixP
->fx_addsy
))
3764 S_SET_WEAK (fixP
->fx_addsy
);
3767 case BFD_RELOC_VTABLE_ENTRY
:
3772 BAD_CASE (fixP
->fx_r_type
);
3776 /* Processes machine-dependent command line options. Called once for
3777 each option on the command line that the machine-independent part of
3778 GAS does not understand. */
3781 md_parse_option (int arg
, char *argp ATTRIBUTE_UNUSED
)
3787 printf (_("Please use --help to see usage and options for this assembler.\n"));
3788 md_show_usage (stdout
);
3789 exit (EXIT_SUCCESS
);
3792 warn_for_branch_expansion
= 1;
3796 demand_register_prefix
= TRUE
;
3798 if (OUTPUT_FLAVOR
== bfd_target_aout_flavour
)
3799 as_bad (_("--no-underscore is invalid with a.out format"));
3801 symbols_have_leading_underscore
= FALSE
;
3805 demand_register_prefix
= FALSE
;
3806 symbols_have_leading_underscore
= TRUE
;
3811 if (cris_arch
!= arch_crisv32
)
3812 md_long_jump_size
= cris_any_v0_v10_long_jump_size_pic
;
3814 md_long_jump_size
= crisv32_long_jump_size
;
3820 enum cris_archs argarch
= cris_arch_from_string (&str
);
3822 if (argarch
== arch_cris_unknown
)
3823 as_bad (_("invalid <arch> in --march=<arch>: %s"), argp
);
3825 cris_arch
= argarch
;
3827 if (argarch
== arch_crisv32
)
3829 err_for_dangerous_mul_placement
= 0;
3830 md_long_jump_size
= crisv32_long_jump_size
;
3835 md_long_jump_size
= cris_any_v0_v10_long_jump_size_pic
;
3837 md_long_jump_size
= cris_any_v0_v10_long_jump_size
;
3842 case OPTION_MULBUG_ABORT_OFF
:
3843 err_for_dangerous_mul_placement
= 0;
3846 case OPTION_MULBUG_ABORT_ON
:
3847 err_for_dangerous_mul_placement
= 1;
3857 /* Round up a section size to the appropriate boundary. */
3859 md_section_align (segT segment
, valueT size
)
3861 /* Round all sects to multiple of 4, except the bss section, which
3862 we'll round to word-size.
3864 FIXME: Check if this really matters. All sections should be
3865 rounded up, and all sections should (optionally) be assumed to be
3866 dword-aligned, it's just that there is actual usage of linking to a
3868 if (OUTPUT_FLAVOR
== bfd_target_aout_flavour
)
3870 if (segment
== bss_section
)
3871 return (size
+ 1) & ~1;
3872 return (size
+ 3) & ~3;
3876 /* FIXME: Is this wanted? It matches the testsuite, but that's not
3877 really a valid reason. */
3878 if (segment
== text_section
)
3879 return (size
+ 3) & ~3;
3885 /* Generate a machine-dependent relocation. */
3887 tc_gen_reloc (asection
*section ATTRIBUTE_UNUSED
, fixS
*fixP
)
3890 bfd_reloc_code_real_type code
;
3892 switch (fixP
->fx_r_type
)
3894 case BFD_RELOC_CRIS_SIGNED_8
:
3898 case BFD_RELOC_CRIS_SIGNED_16
:
3899 code
= BFD_RELOC_16
;
3902 case BFD_RELOC_CRIS_16_GOT
:
3903 case BFD_RELOC_CRIS_32_GOT
:
3904 case BFD_RELOC_CRIS_16_GOTPLT
:
3905 case BFD_RELOC_CRIS_32_GOTPLT
:
3906 case BFD_RELOC_CRIS_32_GOTREL
:
3907 case BFD_RELOC_CRIS_32_PLT_GOTREL
:
3908 case BFD_RELOC_CRIS_32_PLT_PCREL
:
3910 case BFD_RELOC_32_PCREL
:
3913 case BFD_RELOC_VTABLE_INHERIT
:
3914 case BFD_RELOC_VTABLE_ENTRY
:
3915 case BFD_RELOC_CRIS_UNSIGNED_8
:
3916 case BFD_RELOC_CRIS_UNSIGNED_16
:
3917 case BFD_RELOC_CRIS_LAPCQ_OFFSET
:
3918 case BFD_RELOC_CRIS_32_GOT_GD
:
3919 case BFD_RELOC_CRIS_16_GOT_GD
:
3920 case BFD_RELOC_CRIS_32_GD
:
3921 case BFD_RELOC_CRIS_32_IE
:
3922 case BFD_RELOC_CRIS_32_DTPREL
:
3923 case BFD_RELOC_CRIS_16_DTPREL
:
3924 case BFD_RELOC_CRIS_32_GOT_TPREL
:
3925 case BFD_RELOC_CRIS_16_GOT_TPREL
:
3926 case BFD_RELOC_CRIS_32_TPREL
:
3927 case BFD_RELOC_CRIS_16_TPREL
:
3928 code
= fixP
->fx_r_type
;
3931 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
3932 _("Semantics error. This type of operand can not be relocated, it must be an assembly-time constant"));
3936 relP
= (arelent
*) xmalloc (sizeof (arelent
));
3938 relP
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
3939 *relP
->sym_ptr_ptr
= symbol_get_bfdsym (fixP
->fx_addsy
);
3940 relP
->address
= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
3942 relP
->addend
= fixP
->fx_offset
;
3944 /* This is the standard place for KLUDGEs to work around bugs in
3945 bfd_install_relocation (first such note in the documentation
3946 appears with binutils-2.8).
3948 That function bfd_install_relocation does the wrong thing with
3949 putting stuff into the addend of a reloc (it should stay out) for a
3950 weak symbol. The really bad thing is that it adds the
3951 "segment-relative offset" of the symbol into the reloc. In this
3952 case, the reloc should instead be relative to the symbol with no
3953 other offset than the assembly code shows; and since the symbol is
3954 weak, any local definition should be ignored until link time (or
3956 To wit: weaksym+42 should be weaksym+42 in the reloc,
3957 not weaksym+(offset_from_segment_of_local_weaksym_definition)
3959 To "work around" this, we subtract the segment-relative offset of
3960 "known" weak symbols. This evens out the extra offset.
3962 That happens for a.out but not for ELF, since for ELF,
3963 bfd_install_relocation uses the "special function" field of the
3964 howto, and does not execute the code that needs to be undone. */
3966 if (OUTPUT_FLAVOR
== bfd_target_aout_flavour
3967 && fixP
->fx_addsy
&& S_IS_WEAK (fixP
->fx_addsy
)
3968 && ! bfd_is_und_section (S_GET_SEGMENT (fixP
->fx_addsy
)))
3970 relP
->addend
-= S_GET_VALUE (fixP
->fx_addsy
);
3973 relP
->howto
= bfd_reloc_type_lookup (stdoutput
, code
);
3978 name
= S_GET_NAME (fixP
->fx_addsy
);
3980 name
= _("<unknown>");
3981 as_fatal (_("Cannot generate relocation type for symbol %s, code %s"),
3982 name
, bfd_get_reloc_code_name (code
));
3988 /* Machine-dependent usage-output. */
3991 md_show_usage (FILE *stream
)
3993 /* The messages are formatted to line up with the generic options. */
3994 fprintf (stream
, _("CRIS-specific options:\n"));
3995 fprintf (stream
, "%s",
3996 _(" -h, -H Don't execute, print this help text. Deprecated.\n"));
3997 fprintf (stream
, "%s",
3998 _(" -N Warn when branches are expanded to jumps.\n"));
3999 fprintf (stream
, "%s",
4000 _(" --underscore User symbols are normally prepended with underscore.\n"));
4001 fprintf (stream
, "%s",
4002 _(" Registers will not need any prefix.\n"));
4003 fprintf (stream
, "%s",
4004 _(" --no-underscore User symbols do not have any prefix.\n"));
4005 fprintf (stream
, "%s",
4006 _(" Registers will require a `$'-prefix.\n"));
4007 fprintf (stream
, "%s",
4008 _(" --pic Enable generation of position-independent code.\n"));
4009 fprintf (stream
, "%s",
4010 _(" --march=<arch> Generate code for <arch>. Valid choices for <arch>\n\
4011 are v0_v10, v10, v32 and common_v10_v32.\n"));
4014 /* Apply a fixS (fixup of an instruction or data that we didn't have
4015 enough info to complete immediately) to the data in a frag. */
4018 md_apply_fix (fixS
*fixP
, valueT
*valP
, segT seg
)
4020 /* This assignment truncates upper bits if valueT is 64 bits (as with
4021 --enable-64-bit-bfd), which is fine here, though we cast to avoid
4022 any compiler warnings. */
4023 long val
= (long) *valP
;
4024 char *buf
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
4026 if (fixP
->fx_addsy
== 0 && !fixP
->fx_pcrel
)
4029 if (fixP
->fx_bit_fixP
|| fixP
->fx_im_disp
!= 0)
4031 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("Invalid relocation"));
4036 /* We can't actually support subtracting a symbol. */
4037 if (fixP
->fx_subsy
!= (symbolS
*) NULL
)
4038 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
4039 _("expression too complex"));
4041 /* This operand-type is scaled. */
4042 if (fixP
->fx_r_type
== BFD_RELOC_CRIS_LAPCQ_OFFSET
)
4044 cris_number_to_imm (buf
, val
, fixP
->fx_size
, fixP
, seg
);
4048 /* All relocations are relative to the location just after the fixup;
4049 the address of the fixup plus its size. */
4052 md_pcrel_from (fixS
*fixP
)
4054 valueT addr
= fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
4056 /* FIXME: We get here only at the end of assembly, when X in ".-X" is
4057 still unknown. Since we don't have pc-relative relocations in a.out,
4058 this is invalid. What to do if anything for a.out, is to add
4059 pc-relative relocations everywhere including the elinux program
4060 loader. For ELF, allow straight-forward PC-relative relocations,
4061 which are always relative to the location after the relocation. */
4062 if (OUTPUT_FLAVOR
!= bfd_target_elf_flavour
4063 || (fixP
->fx_r_type
!= BFD_RELOC_8_PCREL
4064 && fixP
->fx_r_type
!= BFD_RELOC_16_PCREL
4065 && fixP
->fx_r_type
!= BFD_RELOC_32_PCREL
4066 && fixP
->fx_r_type
!= BFD_RELOC_CRIS_LAPCQ_OFFSET
))
4067 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
4068 _("Invalid pc-relative relocation"));
4069 return fixP
->fx_size
+ addr
;
4072 /* We have no need to give defaults for symbol-values. */
4074 md_undefined_symbol (char *name ATTRIBUTE_UNUSED
)
4079 /* If this function returns non-zero, it prevents the relocation
4080 against symbol(s) in the FIXP from being replaced with relocations
4081 against section symbols, and guarantees that a relocation will be
4082 emitted even when the value can be resolved locally. */
4084 md_cris_force_relocation (struct fix
*fixp
)
4086 switch (fixp
->fx_r_type
)
4088 case BFD_RELOC_CRIS_16_GOT
:
4089 case BFD_RELOC_CRIS_32_GOT
:
4090 case BFD_RELOC_CRIS_16_GOTPLT
:
4091 case BFD_RELOC_CRIS_32_GOTPLT
:
4092 case BFD_RELOC_CRIS_32_GOTREL
:
4093 case BFD_RELOC_CRIS_32_PLT_GOTREL
:
4094 case BFD_RELOC_CRIS_32_PLT_PCREL
:
4100 return generic_force_reloc (fixp
);
4103 /* Check and emit error if broken-word handling has failed to fix up a
4104 case-table. This is called from write.c, after doing everything it
4105 knows about how to handle broken words. */
4108 tc_cris_check_adjusted_broken_word (offsetT new_offset
, struct broken_word
*brokwP
)
4110 if (new_offset
> 32767 || new_offset
< -32768)
4111 /* We really want a genuine error, not a warning, so make it one. */
4112 as_bad_where (brokwP
->frag
->fr_file
, brokwP
->frag
->fr_line
,
4113 _("Adjusted signed .word (%ld) overflows: `switch'-statement too large."),
4117 /* Make a leading REGISTER_PREFIX_CHAR mandatory for all registers. */
4120 cris_force_reg_prefix (void)
4122 demand_register_prefix
= TRUE
;
4125 /* Do not demand a leading REGISTER_PREFIX_CHAR for all registers. */
4128 cris_relax_reg_prefix (void)
4130 demand_register_prefix
= FALSE
;
4133 /* Adjust for having a leading '_' on all user symbols. */
4136 cris_sym_leading_underscore (void)
4138 /* We can't really do anything more than assert that what the program
4139 thinks symbol starts with agrees with the command-line options, since
4140 the bfd is already created. */
4142 if (!symbols_have_leading_underscore
)
4143 as_bad (_(".syntax %s requires command-line option `--underscore'"),
4144 SYNTAX_USER_SYM_LEADING_UNDERSCORE
);
4147 /* Adjust for not having any particular prefix on user symbols. */
4149 static void cris_sym_no_leading_underscore (void)
4151 if (symbols_have_leading_underscore
)
4152 as_bad (_(".syntax %s requires command-line option `--no-underscore'"),
4153 SYNTAX_USER_SYM_NO_LEADING_UNDERSCORE
);
4156 /* Handle the .syntax pseudo, which takes an argument that decides what
4157 syntax the assembly code has. */
4160 s_syntax (int ignore ATTRIBUTE_UNUSED
)
4162 static const struct syntaxes
4164 const char *const operand
;
4167 {{SYNTAX_ENFORCE_REG_PREFIX
, cris_force_reg_prefix
},
4168 {SYNTAX_RELAX_REG_PREFIX
, cris_relax_reg_prefix
},
4169 {SYNTAX_USER_SYM_LEADING_UNDERSCORE
, cris_sym_leading_underscore
},
4170 {SYNTAX_USER_SYM_NO_LEADING_UNDERSCORE
, cris_sym_no_leading_underscore
}};
4172 const struct syntaxes
*sp
;
4174 for (sp
= syntax_table
;
4175 sp
< syntax_table
+ sizeof (syntax_table
) / sizeof (syntax_table
[0]);
4178 if (strncmp (input_line_pointer
, sp
->operand
,
4179 strlen (sp
->operand
)) == 0)
4183 input_line_pointer
+= strlen (sp
->operand
);
4184 demand_empty_rest_of_line ();
4189 as_bad (_("Unknown .syntax operand"));
4192 /* Wrapper for dwarf2_directive_file to emit error if this is seen when
4193 not emitting ELF. */
4196 s_cris_file (int dummy
)
4198 if (OUTPUT_FLAVOR
!= bfd_target_elf_flavour
)
4199 as_bad (_("Pseudodirective .file is only valid when generating ELF"));
4201 dwarf2_directive_file (dummy
);
4204 /* Wrapper for dwarf2_directive_loc to emit error if this is seen when not
4208 s_cris_loc (int dummy
)
4210 if (OUTPUT_FLAVOR
!= bfd_target_elf_flavour
)
4211 as_bad (_("Pseudodirective .loc is only valid when generating ELF"));
4213 dwarf2_directive_loc (dummy
);
4216 /* Translate a <arch> string (as common to --march=<arch> and .arch <arch>)
4217 into an enum. If the string *STR is recognized, *STR is updated to point
4218 to the end of the string. If the string is not recognized,
4219 arch_cris_unknown is returned. */
4221 static enum cris_archs
4222 cris_arch_from_string (char **str
)
4224 static const struct cris_arch_struct
4226 const char *const name
;
4227 enum cris_archs arch
;
4229 /* Keep in order longest-first for choices where one is a prefix
4231 {{"v0_v10", arch_cris_any_v0_v10
},
4232 {"v10", arch_crisv10
},
4233 {"v32", arch_crisv32
},
4234 {"common_v10_v32", arch_cris_common_v10_v32
}};
4236 const struct cris_arch_struct
*ap
;
4238 for (ap
= arch_table
;
4239 ap
< arch_table
+ sizeof (arch_table
) / sizeof (arch_table
[0]);
4242 int len
= strlen (ap
->name
);
4244 if (strncmp (*str
, ap
->name
, len
) == 0
4245 && (str
[0][len
] == 0 || ISSPACE (str
[0][len
])))
4247 *str
+= strlen (ap
->name
);
4252 return arch_cris_unknown
;
4255 /* Return nonzero if architecture version ARCH matches version range in
4259 cris_insn_ver_valid_for_arch (enum cris_insn_version_usage iver
,
4260 enum cris_archs arch
)
4264 case arch_cris_any_v0_v10
:
4266 (iver
== cris_ver_version_all
4267 || iver
== cris_ver_warning
4268 || iver
== cris_ver_v0_3
4269 || iver
== cris_ver_v3p
4270 || iver
== cris_ver_v0_10
4271 || iver
== cris_ver_sim_v0_10
4272 || iver
== cris_ver_v3_10
4273 || iver
== cris_ver_v8
4274 || iver
== cris_ver_v8p
4275 || iver
== cris_ver_v8_10
4276 || iver
== cris_ver_v10
4277 || iver
== cris_ver_v10p
);
4281 (iver
== cris_ver_version_all
4282 || iver
== cris_ver_v3p
4283 || iver
== cris_ver_v8p
4284 || iver
== cris_ver_v10p
4285 || iver
== cris_ver_v32p
);
4287 case arch_cris_common_v10_v32
:
4289 (iver
== cris_ver_version_all
4290 || iver
== cris_ver_v3p
4291 || iver
== cris_ver_v8p
4292 || iver
== cris_ver_v10p
);
4296 (iver
== cris_ver_version_all
4297 || iver
== cris_ver_v0_3
4298 || iver
== cris_ver_v0_10
4299 || iver
== cris_ver_sim_v0_10
);
4303 (iver
== cris_ver_version_all
4304 || iver
== cris_ver_v0_3
4305 || iver
== cris_ver_v3p
4306 || iver
== cris_ver_v0_10
4307 || iver
== cris_ver_sim_v0_10
4308 || iver
== cris_ver_v3_10
);
4312 (iver
== cris_ver_version_all
4313 || iver
== cris_ver_v3p
4314 || iver
== cris_ver_v0_10
4315 || iver
== cris_ver_sim_v0_10
4316 || iver
== cris_ver_v3_10
4317 || iver
== cris_ver_v8
4318 || iver
== cris_ver_v8p
4319 || iver
== cris_ver_v8_10
);
4323 (iver
== cris_ver_version_all
4324 || iver
== cris_ver_v3p
4325 || iver
== cris_ver_v0_10
4326 || iver
== cris_ver_sim_v0_10
4327 || iver
== cris_ver_v3_10
4328 || iver
== cris_ver_v8p
4329 || iver
== cris_ver_v8_10
4330 || iver
== cris_ver_v10
4331 || iver
== cris_ver_v10p
);
4338 /* Assert that the .arch ARCHCHOICE1 is compatible with the specified or
4339 default --march=<ARCHCHOICE2> option. */
4342 s_cris_arch (int dummy ATTRIBUTE_UNUSED
)
4344 /* Right now we take the easy route and check for sameness. It's not
4345 obvious that allowing e.g. --march=v32 and .arch common_v0_v32
4346 would be more useful than confusing, implementation-wise and
4349 char *str
= input_line_pointer
;
4350 enum cris_archs arch
= cris_arch_from_string (&str
);
4352 if (arch
== arch_cris_unknown
)
4354 as_bad (_("unknown operand to .arch"));
4356 /* For this one, str does not reflect the end of the operand,
4357 since there was no matching arch. Skip it manually; skip
4358 things that can be part of a word (a name). */
4359 while (is_part_of_name (*str
))
4362 else if (arch
!= cris_arch
)
4363 as_bad (_(".arch <arch> requires a matching --march=... option"));
4365 input_line_pointer
= str
;
4366 demand_empty_rest_of_line ();
4372 * eval: (c-set-style "gnu")
4373 * indent-tabs-mode: t