1 /* tc-cris.c -- Assembler code for the CRIS CPU core.
2 Copyright 2000, 2001 Free Software Foundation, Inc.
4 Contributed by Axis Communications AB, Lund, Sweden.
5 Originally written for GAS 1.38.1 by Mikael Asker.
6 Updates, BFDizing, GNUifying and ELF support by Hans-Peter Nilsson.
8 This file is part of GAS, the GNU Assembler.
10 GAS is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2, or (at your option)
15 GAS is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with GAS; see the file COPYING. If not, write to the
22 Free Software Foundation, 59 Temple Place - Suite 330, Boston,
23 MA 02111-1307, USA. */
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 /* Like in ":GOT", ":GOTOFF" etc. Other ports use '@', but that's in
47 line_separator_chars for CRIS, so we avoid it. */
48 #define PIC_SUFFIX_CHAR ':'
50 /* This might be CRIS_INSN_NONE if we're assembling a prefix-insn only.
51 Note that some prefix-insns might be assembled as CRIS_INSN_NORMAL. */
54 CRIS_INSN_NORMAL
, CRIS_INSN_NONE
, CRIS_INSN_BRANCH
57 /* An instruction will have one of these prefixes.
58 Although the same bit-pattern, we handle BDAP with an immediate
59 expression (eventually quick or [pc+]) different from when we only have
60 register expressions. */
63 PREFIX_NONE
, PREFIX_BDAP_IMM
, PREFIX_BDAP
, PREFIX_BIAP
, PREFIX_DIP
,
67 /* The prefix for an instruction. */
70 enum prefix_kind kind
;
74 /* There might be an expression to be evaluated, like I in [rN+I]. */
77 /* If there's an expression, we might need a relocation. Here's the
78 type of what relocation to start relaxaton with.
79 The relocation is assumed to start immediately after the prefix insn,
80 so we don't provide an offset. */
81 enum bfd_reloc_code_real reloc
;
84 /* The description of the instruction being assembled. */
85 struct cris_instruction
87 /* If CRIS_INSN_NONE, then this insn is of zero length. */
88 enum cris_insn_kind insn_type
;
90 /* If a special register was mentioned, this is its description, else
92 const struct cris_spec_reg
*spec_reg
;
96 /* An insn may have at most one expression; theoretically there could be
97 another in its prefix (but I don't see how that could happen). */
100 /* The expression might need a relocation. Here's one to start
102 enum bfd_reloc_code_real reloc
;
104 /* The size in bytes of an immediate expression, or zero if
109 static void cris_process_instruction
PARAMS ((char *,
110 struct cris_instruction
*,
111 struct cris_prefix
*));
112 static int get_bwd_size_modifier
PARAMS ((char **, int *));
113 static int get_bw_size_modifier
PARAMS ((char **, int *));
114 static int get_gen_reg
PARAMS ((char **, int *));
115 static int get_spec_reg
PARAMS ((char **,
116 const struct cris_spec_reg
**));
117 static int get_autoinc_prefix_or_indir_op
PARAMS ((char **,
118 struct cris_prefix
*,
121 static int get_3op_or_dip_prefix_op
PARAMS ((char **,
122 struct cris_prefix
*));
123 static int cris_get_expression
PARAMS ((char **, expressionS
*));
124 static int get_flags
PARAMS ((char **, int *));
125 static void gen_bdap
PARAMS ((int, expressionS
*));
126 static int branch_disp
PARAMS ((int));
127 static void gen_cond_branch_32
PARAMS ((char *, char *, fragS
*,
128 symbolS
*, symbolS
*, long int));
129 static void cris_number_to_imm
PARAMS ((char *, long, int, fixS
*, segT
));
130 static void cris_create_short_jump
PARAMS ((char *, addressT
, addressT
,
131 fragS
*, symbolS
*));
132 static void s_syntax
PARAMS ((int));
133 static void s_cris_file
PARAMS ((int));
134 static void s_cris_loc
PARAMS ((int));
136 /* Get ":GOT", ":GOTOFF", ":PLT" etc. suffixes. */
137 static void cris_get_pic_suffix
PARAMS ((char **,
138 bfd_reloc_code_real_type
*,
140 static unsigned int cris_get_pic_reloc_size
141 PARAMS ((bfd_reloc_code_real_type
));
143 /* All the .syntax functions. */
144 static void cris_force_reg_prefix
PARAMS ((void));
145 static void cris_relax_reg_prefix
PARAMS ((void));
146 static void cris_sym_leading_underscore
PARAMS ((void));
147 static void cris_sym_no_leading_underscore
PARAMS ((void));
149 /* Handle to the opcode hash table. */
150 static struct hash_control
*op_hash
= NULL
;
152 /* Whether we demand that registers have a `$' prefix. Default here. */
153 static boolean demand_register_prefix
= false;
155 /* Whether global user symbols have a leading underscore. Default here. */
156 static boolean symbols_have_leading_underscore
= true;
158 /* Whether or not we allow PIC, and expand to PIC-friendly constructs. */
159 static boolean pic
= false;
161 const pseudo_typeS md_pseudo_table
[] =
164 {"syntax", s_syntax
, 0},
165 {"file", s_cris_file
, 0},
166 {"loc", s_cris_loc
, 0},
170 static int warn_for_branch_expansion
= 0;
172 const char cris_comment_chars
[] = ";";
174 /* This array holds the chars that only start a comment at the beginning of
175 a line. If the line seems to have the form '# 123 filename'
176 .line and .file directives will appear in the pre-processed output. */
177 /* Note that input_file.c hand-checks for '#' at the beginning of the
178 first line of the input file. This is because the compiler outputs
179 #NO_APP at the beginning of its output. */
180 /* Also note that slash-star will always start a comment. */
181 const char line_comment_chars
[] = "#";
182 const char line_separator_chars
[] = "@";
184 /* Now all floating point support is shut off. See md_atof. */
185 const char EXP_CHARS
[] = "";
186 const char FLT_CHARS
[] = "";
188 /* For CRIS, we encode the relax_substateTs (in e.g. fr_substate) as:
190 ---/ /--+-----------------+-----------------+-----------------+
191 | what state ? | how long ? |
192 ---/ /--+-----------------+-----------------+-----------------+
194 The "how long" bits are 00 = byte, 01 = word, 10 = dword (long).
195 This is a Un*x convention.
196 Not all lengths are legit for a given value of (what state).
198 Groups for CRIS address relaxing:
201 length: byte, word, 10-byte expansion
204 length: byte, word, dword */
206 #define STATE_CONDITIONAL_BRANCH (1)
207 #define STATE_BASE_PLUS_DISP_PREFIX (2)
209 #define STATE_LENGTH_MASK (3)
210 #define STATE_BYTE (0)
211 #define STATE_WORD (1)
212 #define STATE_DWORD (2)
213 /* Symbol undefined. */
214 #define STATE_UNDF (3)
215 #define STATE_MAX_LENGTH (3)
217 /* These displacements are relative to the adress following the opcode
218 word of the instruction. The first letter is Byte, Word. The 2nd
219 letter is Forward, Backward. */
221 #define BRANCH_BF ( 254)
222 #define BRANCH_BB (-256)
223 #define BRANCH_WF (2 + 32767)
224 #define BRANCH_WB (2 + -32768)
226 #define BDAP_BF ( 127)
227 #define BDAP_BB (-128)
228 #define BDAP_WF ( 32767)
229 #define BDAP_WB (-32768)
231 #define ENCODE_RELAX(what, length) (((what) << 2) + (length))
233 const relax_typeS md_cris_relax_table
[] =
235 /* Error sentinel (0, 0). */
248 {BRANCH_BF
, BRANCH_BB
, 0, ENCODE_RELAX (1, 1)},
250 /* Bcc [PC+] (1, 1). */
251 {BRANCH_WF
, BRANCH_WB
, 2, ENCODE_RELAX (1, 2)},
253 /* BEXT/BWF, BA, JUMP (external), JUMP (always), Bnot_cc, JUMP (default)
261 {BDAP_BF
, BDAP_BB
, 0, ENCODE_RELAX (2, 1)},
263 /* BDAP.[bw] [PC+] (2, 1). */
264 {BDAP_WF
, BDAP_WB
, 2, ENCODE_RELAX (2, 2)},
266 /* BDAP.d [PC+] (2, 2). */
279 /* Target-specific multicharacter options, not const-declared at usage
280 in 2.9.1 and CVS of 2000-02-16. */
281 struct option md_longopts
[] =
283 #define OPTION_NO_US (OPTION_MD_BASE + 0)
284 {"no-underscore", no_argument
, NULL
, OPTION_NO_US
},
285 #define OPTION_US (OPTION_MD_BASE + 1)
286 {"underscore", no_argument
, NULL
, OPTION_US
},
287 #define OPTION_PIC (OPTION_MD_BASE + 2)
288 {"pic", no_argument
, NULL
, OPTION_PIC
},
289 {NULL
, no_argument
, NULL
, 0}
292 /* Not const-declared at usage in 2.9.1. */
293 size_t md_longopts_size
= sizeof (md_longopts
);
294 const char *md_shortopts
= "hHN";
296 /* At first glance, this may seems wrong and should be 4 (ba + nop); but
297 since a short_jump must skip a *number* of long jumps, it must also be
298 a long jump. Here, we hope to make it a "ba [16bit_offs]" and a "nop"
299 for the delay slot and hope that the jump table at most needs
300 32767/4=8191 long-jumps. A branch is better than a jump, since it is
301 relative; we will not have a reloc to fix up somewhere.
303 Note that we can't add relocs, because relaxation uses these fixed
304 numbers, and md_create_short_jump is called after relaxation. */
306 const int md_short_jump_size
= 6;
307 const int md_long_jump_size
= 6;
309 /* Report output format. Small changes in output format (like elf
310 variants below) can happen until all options are parsed, but after
311 that, the output format must remain fixed. */
314 cris_target_format ()
316 switch (OUTPUT_FLAVOR
)
318 case bfd_target_aout_flavour
:
321 case bfd_target_elf_flavour
:
322 if (symbols_have_leading_underscore
)
323 return "elf32-us-cris";
332 /* Prepare machine-dependent frags for relaxation.
334 Called just before relaxation starts. Any symbol that is now undefined
335 will not become defined.
337 Return the correct fr_subtype in the frag.
339 Return the initial "guess for fr_var" to caller. The guess for fr_var
340 is *actually* the growth beyond fr_fix. Whatever we do to grow fr_fix
341 or fr_var contributes to our returned value.
343 Although it may not be explicit in the frag, pretend
344 fr_var starts with a value. */
347 md_estimate_size_before_relax (fragP
, segment_type
)
349 /* The segment is either N_DATA or N_TEXT. */
354 old_fr_fix
= fragP
->fr_fix
;
356 switch (fragP
->fr_subtype
)
358 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, STATE_UNDF
):
359 if (S_GET_SEGMENT (fragP
->fr_symbol
) == segment_type
)
360 /* The symbol lies in the same segment - a relaxable case. */
362 = ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, STATE_BYTE
);
364 /* Unknown or not the same segment, so not relaxable. */
366 = ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, STATE_DWORD
);
367 fragP
->fr_var
= md_cris_relax_table
[fragP
->fr_subtype
].rlx_length
;
370 case ENCODE_RELAX (STATE_BASE_PLUS_DISP_PREFIX
, STATE_UNDF
):
371 /* Note that we can not do anything sane with relaxing
372 [rX + a_known_symbol_in_text], it will have to be a 32-bit
375 We could play tricks with managing a constant pool and make
376 a_known_symbol_in_text a "bdap [pc + offset]" pointing there
377 (like the GOT for ELF shared libraries), but that's no use, it
378 would in general be no shorter or faster code, only more
381 if (S_GET_SEGMENT (fragP
->fr_symbol
) != absolute_section
)
383 /* Go for dword if not absolute or same segment. */
385 = ENCODE_RELAX (STATE_BASE_PLUS_DISP_PREFIX
, STATE_DWORD
);
386 fragP
->fr_var
= md_cris_relax_table
[fragP
->fr_subtype
].rlx_length
;
390 /* Absolute expression. */
392 value
= S_GET_VALUE (fragP
->fr_symbol
) + fragP
->fr_offset
;
394 if (value
>= -128 && value
<= 127)
396 /* Byte displacement. */
397 (fragP
->fr_opcode
)[0] = value
;
401 /* Word or dword displacement. */
402 int pow2_of_size
= 1;
405 if (value
< -32768 || value
> 32767)
407 /* Outside word range, make it a dword. */
411 /* Modify the byte-offset BDAP into a word or dword offset
412 BDAP. Or really, a BDAP rX,8bit into a
413 BDAP.[wd] rX,[PC+] followed by a word or dword. */
414 (fragP
->fr_opcode
)[0] = BDAP_PC_LOW
+ pow2_of_size
* 16;
416 /* Keep the register number in the highest four bits. */
417 (fragP
->fr_opcode
)[1] &= 0xF0;
418 (fragP
->fr_opcode
)[1] |= BDAP_INCR_HIGH
;
420 /* It grew by two or four bytes. */
421 fragP
->fr_fix
+= 1 << pow2_of_size
;
422 writep
= fragP
->fr_literal
+ old_fr_fix
;
423 md_number_to_chars (writep
, value
, 1 << pow2_of_size
);
429 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, STATE_BYTE
):
430 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, STATE_WORD
):
431 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, STATE_DWORD
):
432 case ENCODE_RELAX (STATE_BASE_PLUS_DISP_PREFIX
, STATE_BYTE
):
433 case ENCODE_RELAX (STATE_BASE_PLUS_DISP_PREFIX
, STATE_WORD
):
434 case ENCODE_RELAX (STATE_BASE_PLUS_DISP_PREFIX
, STATE_DWORD
):
435 /* When relaxing a section for the second time, we don't need to
436 do anything except making sure that fr_var is set right. */
437 fragP
->fr_var
= md_cris_relax_table
[fragP
->fr_subtype
].rlx_length
;
441 BAD_CASE (fragP
->fr_subtype
);
444 return fragP
->fr_var
+ (fragP
->fr_fix
- old_fr_fix
);
447 /* Perform post-processing of machine-dependent frags after relaxation.
448 Called after relaxation is finished.
450 fr_type == rs_machine_dependent.
451 fr_subtype is what the address relaxed to.
453 Out: Any fixS:s and constants are set up.
455 The caller will turn the frag into a ".space 0". */
458 md_convert_frag (abfd
, sec
, fragP
)
459 bfd
*abfd ATTRIBUTE_UNUSED
;
460 segT sec ATTRIBUTE_UNUSED
;
463 /* Pointer to first byte in variable-sized part of the frag. */
466 /* Pointer to first opcode byte in frag. */
469 /* Used to check integrity of the relaxation.
470 One of 2 = long, 1 = word, or 0 = byte. */
473 /* Size in bytes of variable-sized part of frag. */
474 int var_part_size
= 0;
476 /* This is part of *fragP. It contains all information about addresses
477 and offsets to varying parts. */
479 unsigned long var_part_offset
;
481 /* Where, in file space, is _var of *fragP? */
482 unsigned long address_of_var_part
= 0;
484 /* Where, in file space, does addr point? */
485 unsigned long target_address
;
487 know (fragP
->fr_type
== rs_machine_dependent
);
489 length_code
= fragP
->fr_subtype
& STATE_LENGTH_MASK
;
490 know (length_code
>= 0 && length_code
< STATE_MAX_LENGTH
);
492 var_part_offset
= fragP
->fr_fix
;
493 var_partp
= fragP
->fr_literal
+ var_part_offset
;
494 opcodep
= fragP
->fr_opcode
;
496 symbolP
= fragP
->fr_symbol
;
499 ? S_GET_VALUE (symbolP
) + symbol_get_frag(fragP
->fr_symbol
)->fr_address
500 : 0 ) + fragP
->fr_offset
;
501 address_of_var_part
= fragP
->fr_address
+ var_part_offset
;
503 switch (fragP
->fr_subtype
)
505 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, STATE_BYTE
):
506 opcodep
[0] = branch_disp ((target_address
- address_of_var_part
));
510 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, STATE_WORD
):
511 /* We had a quick immediate branch, now turn it into a word one i.e. a
513 opcodep
[0] = BRANCH_PC_LOW
;
515 opcodep
[1] |= BRANCH_INCR_HIGH
;
516 md_number_to_chars (var_partp
,
517 (long) (target_address
- (address_of_var_part
+ 2)),
522 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, STATE_DWORD
):
523 gen_cond_branch_32 (fragP
->fr_opcode
, var_partp
, fragP
,
524 fragP
->fr_symbol
, (symbolS
*) NULL
,
526 /* Ten bytes added: a branch, nop and a jump. */
527 var_part_size
= 2 + 2 + 4 + 2;
530 case ENCODE_RELAX (STATE_BASE_PLUS_DISP_PREFIX
, STATE_BYTE
):
531 var_partp
[0] = target_address
- (address_of_var_part
+ 1);
535 case ENCODE_RELAX (STATE_BASE_PLUS_DISP_PREFIX
, STATE_WORD
):
536 /* We had a BDAP 8-bit "quick immediate", now turn it into a 16-bit
537 one that uses PC autoincrement. */
538 opcodep
[0] = BDAP_PC_LOW
+ (1 << 4);
540 opcodep
[1] |= BDAP_INCR_HIGH
;
541 md_number_to_chars (var_partp
, (long) (target_address
), 2);
545 case ENCODE_RELAX (STATE_BASE_PLUS_DISP_PREFIX
, STATE_DWORD
):
546 /* We had a BDAP 16-bit "word", change the offset to a dword. */
547 opcodep
[0] = BDAP_PC_LOW
+ (2 << 4);
549 opcodep
[1] |= BDAP_INCR_HIGH
;
550 if (fragP
->fr_symbol
== NULL
)
551 md_number_to_chars (var_partp
, fragP
->fr_offset
, 4);
553 fix_new (fragP
, var_partp
- fragP
->fr_literal
, 4, fragP
->fr_symbol
,
554 fragP
->fr_offset
, 0, BFD_RELOC_32
);
559 BAD_CASE (fragP
->fr_subtype
);
563 fragP
->fr_fix
+= var_part_size
;
566 /* Generate a short jump around a secondary jump table.
567 Used by md_create_long_jump.
569 This used to be md_create_short_jump, but is now called from
570 md_create_long_jump instead, when sufficient.
571 since the sizes of the jumps are the same. It used to be brittle,
572 making possibilities for creating bad code. */
575 cris_create_short_jump (storep
, from_addr
, to_addr
, fragP
, to_symbol
)
579 fragS
*fragP ATTRIBUTE_UNUSED
;
580 symbolS
*to_symbol ATTRIBUTE_UNUSED
;
584 distance
= to_addr
- from_addr
;
586 if (-254 <= distance
&& distance
<= 256)
588 /* Create a "short" short jump: "BA distance - 2". */
589 storep
[0] = branch_disp (distance
- 2);
590 storep
[1] = BA_QUICK_HIGH
;
592 /* A nop for the delay slot. */
593 md_number_to_chars (storep
+ 2, NOP_OPCODE
, 2);
595 /* The extra word should be filled with something sane too. Make it
596 a nop to keep disassembly sane. */
597 md_number_to_chars (storep
+ 4, NOP_OPCODE
, 2);
601 /* Make it a "long" short jump: "BA (PC+)". */
602 md_number_to_chars (storep
, BA_PC_INCR_OPCODE
, 2);
604 /* ".WORD distance - 4". */
605 md_number_to_chars (storep
+ 2, (long) (distance
- 4), 2);
607 /* A nop for the delay slot. */
608 md_number_to_chars (storep
+ 4, NOP_OPCODE
, 2);
612 /* Generate a long jump in a secondary jump table.
614 storep Where to store the jump instruction.
615 from_addr Address of the jump instruction.
616 to_addr Destination address of the jump.
617 fragP Which frag the destination address operand
619 to_symbol Destination symbol. */
622 md_create_long_jump (storep
, from_addr
, to_addr
, fragP
, to_symbol
)
631 distance
= to_addr
- from_addr
;
633 if (-32763 <= distance
&& distance
<= 32772)
635 /* Then make it a "short" long jump. */
636 cris_create_short_jump (storep
, from_addr
, to_addr
, fragP
,
641 /* We have a "long" long jump: "JUMP [PC+]".
642 Make it an "ADD [PC+],PC" if we're supposed to emit PIC code. */
643 md_number_to_chars (storep
,
644 pic
? ADD_PC_INCR_OPCODE
: JUMP_PC_INCR_OPCODE
, 2);
646 /* Follow with a ".DWORD to_addr", PC-relative for PIC. */
647 fix_new (fragP
, storep
+ 2 - fragP
->fr_literal
, 4, to_symbol
,
648 0, pic
? 1 : 0, pic
? BFD_RELOC_32_PCREL
: BFD_RELOC_32
);
652 /* Port-specific assembler initialization. */
657 const char *hashret
= NULL
;
660 /* Set up a hash table for the instructions. */
661 op_hash
= hash_new ();
663 as_fatal (_("Virtual memory exhausted"));
665 while (cris_opcodes
[i
].name
!= NULL
)
667 const char *name
= cris_opcodes
[i
].name
;
668 hashret
= hash_insert (op_hash
, name
, (PTR
) &cris_opcodes
[i
]);
670 if (hashret
!= NULL
&& *hashret
!= '\0')
671 as_fatal (_("Can't hash `%s': %s\n"), cris_opcodes
[i
].name
,
672 *hashret
== 0 ? _("(unknown reason)") : hashret
);
675 if (cris_opcodes
[i
].match
& cris_opcodes
[i
].lose
)
676 as_fatal (_("Buggy opcode: `%s' \"%s\"\n"), cris_opcodes
[i
].name
,
677 cris_opcodes
[i
].args
);
681 while (cris_opcodes
[i
].name
!= NULL
682 && strcmp (cris_opcodes
[i
].name
, name
) == 0);
686 /* Assemble a source line. */
692 struct cris_instruction output_instruction
;
693 struct cris_prefix prefix
;
700 /* Do the low-level grunt - assemble to bits and split up into a prefix
701 and ordinary insn. */
702 cris_process_instruction (str
, &output_instruction
, &prefix
);
704 /* Handle any prefixes to the instruction. */
710 /* When the expression is unknown for a BDAP, it can need 0, 2 or 4
711 extra bytes, so we handle it separately. */
712 case PREFIX_BDAP_IMM
:
713 /* We only do it if the relocation is unspecified, i.e. not a PIC
715 if (prefix
.reloc
== BFD_RELOC_NONE
)
717 gen_bdap (prefix
.base_reg_number
, &prefix
.expr
);
725 opcodep
= frag_more (2);
727 /* Output the prefix opcode. */
728 md_number_to_chars (opcodep
, (long) prefix
.opcode
, 2);
730 /* Having a specified reloc only happens for DIP and for BDAP with
731 PIC operands, but it is ok to drop through here for the other
732 prefixes as they can have no relocs specified. */
733 if (prefix
.reloc
!= BFD_RELOC_NONE
)
735 unsigned int relocsize
736 = (prefix
.kind
== PREFIX_DIP
737 ? 4 : cris_get_pic_reloc_size (prefix
.reloc
));
739 insn_size
+= relocsize
;
740 p
= frag_more (relocsize
);
741 fix_new_exp (frag_now
, (p
- frag_now
->fr_literal
), relocsize
,
742 &prefix
.expr
, 0, prefix
.reloc
);
748 opcodep
= frag_more (2);
750 /* Output the prefix opcode. Being a "push", we add the negative
751 size of the register to "sp". */
752 if (output_instruction
.spec_reg
!= NULL
)
754 /* Special register. */
755 opcodep
[0] = -output_instruction
.spec_reg
->reg_size
;
759 /* General register. */
762 opcodep
[1] = (REG_SP
<< 4) + (BDAP_QUICK_OPCODE
>> 8);
766 BAD_CASE (prefix
.kind
);
769 /* If we only had a prefix insn, we're done. */
770 if (output_instruction
.insn_type
== CRIS_INSN_NONE
)
773 /* Done with the prefix. Continue with the main instruction. */
775 opcodep
= frag_more (2);
777 /* Output the instruction opcode. */
778 md_number_to_chars (opcodep
, (long) (output_instruction
.opcode
), 2);
780 /* Output the symbol-dependent instruction stuff. */
781 if (output_instruction
.insn_type
== CRIS_INSN_BRANCH
)
783 segT to_seg
= absolute_section
;
784 int is_undefined
= 0;
787 if (output_instruction
.expr
.X_op
!= O_constant
)
789 to_seg
= S_GET_SEGMENT (output_instruction
.expr
.X_add_symbol
);
791 if (to_seg
== undefined_section
)
795 if (output_instruction
.expr
.X_op
== O_constant
796 || to_seg
== now_seg
|| is_undefined
)
798 /* Handle complex expressions. */
800 = (output_instruction
.expr
.X_op_symbol
!= NULL
801 ? 0 : output_instruction
.expr
.X_add_number
);
803 = (output_instruction
.expr
.X_op_symbol
!= NULL
804 ? make_expr_symbol (&output_instruction
.expr
)
805 : output_instruction
.expr
.X_add_symbol
);
807 /* If is_undefined, then the expression may BECOME now_seg. */
808 length_code
= is_undefined
? STATE_UNDF
: STATE_BYTE
;
810 /* Make room for max ten bytes of variable length. */
811 frag_var (rs_machine_dependent
, 10, 0,
812 ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, length_code
),
813 sym
, addvalue
, opcodep
);
817 /* We have: to_seg != now_seg && to_seg != undefined_section.
818 This means it is a branch to a known symbol in another
819 section. Code in data? Weird but valid. Emit a 32-bit
821 char *cond_jump
= frag_more (10);
824 gen_cond_branch_32 (opcodep
, cond_jump
, frag_now
,
825 output_instruction
.expr
.X_add_symbol
,
827 output_instruction
.expr
.X_add_number
);
832 if (output_instruction
.imm_oprnd_size
> 0)
834 /* The intruction has an immediate operand. */
835 enum bfd_reloc_code_real reloc
= BFD_RELOC_NONE
;
837 switch (output_instruction
.imm_oprnd_size
)
839 /* Any byte-size immediate constants are treated as
840 word-size. FIXME: Thus overflow check does not work
844 /* Note that size-check for the explicit reloc has already
845 been done when we get here. */
846 if (output_instruction
.reloc
!= BFD_RELOC_NONE
)
847 reloc
= output_instruction
.reloc
;
849 reloc
= BFD_RELOC_16
;
853 /* Allow a relocation specified in the operand. */
854 if (output_instruction
.reloc
!= BFD_RELOC_NONE
)
855 reloc
= output_instruction
.reloc
;
857 reloc
= BFD_RELOC_32
;
861 BAD_CASE (output_instruction
.imm_oprnd_size
);
864 insn_size
+= output_instruction
.imm_oprnd_size
;
865 p
= frag_more (output_instruction
.imm_oprnd_size
);
866 fix_new_exp (frag_now
, (p
- frag_now
->fr_literal
),
867 output_instruction
.imm_oprnd_size
,
868 &output_instruction
.expr
, 0, reloc
);
870 else if (output_instruction
.reloc
!= BFD_RELOC_NONE
)
872 /* An immediate operand that has a relocation and needs to be
873 processed further. */
875 /* It is important to use fix_new_exp here and everywhere else
876 (and not fix_new), as fix_new_exp can handle "difference
877 expressions" - where the expression contains a difference of
878 two symbols in the same segment. */
879 fix_new_exp (frag_now
, (opcodep
- frag_now
->fr_literal
), 2,
880 &output_instruction
.expr
, 0,
881 output_instruction
.reloc
);
885 if (OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
886 dwarf2_emit_insn (insn_size
);
889 /* Low level text-to-bits assembly. */
892 cris_process_instruction (insn_text
, out_insnp
, prefixp
)
894 struct cris_instruction
*out_insnp
;
895 struct cris_prefix
*prefixp
;
898 char modified_char
= 0;
900 struct cris_opcode
*instruction
;
907 /* Reset these fields to a harmless state in case we need to return in
909 prefixp
->kind
= PREFIX_NONE
;
910 prefixp
->reloc
= BFD_RELOC_NONE
;
911 out_insnp
->insn_type
= CRIS_INSN_NORMAL
;
912 out_insnp
->imm_oprnd_size
= 0;
914 /* Find the end of the opcode mnemonic. We assume (true in 2.9.1)
915 that the caller has translated the opcode to lower-case, up to the
917 for (operands
= insn_text
; islower (*operands
); ++operands
)
920 /* Terminate the opcode after letters, but save the character there if
921 it was of significance. */
928 /* Put back the modified character later. */
929 modified_char
= *operands
;
933 /* Consume the character after the mnemonic
934 and replace it with '\0'. */
939 as_bad (_("Unknown opcode: `%s'"), insn_text
);
943 /* Find the instruction. */
944 instruction
= (struct cris_opcode
*) hash_find (op_hash
, insn_text
);
945 if (instruction
== NULL
)
947 as_bad (_("Unknown opcode: `%s'"), insn_text
);
951 /* Put back the modified character. */
952 switch (modified_char
)
958 *--operands
= modified_char
;
961 /* Try to match an opcode table slot. */
966 /* Initialize *prefixp, perhaps after being modified for a
968 prefixp
->kind
= PREFIX_NONE
;
969 prefixp
->reloc
= BFD_RELOC_NONE
;
971 /* Initialize *out_insnp. */
972 memset (out_insnp
, 0, sizeof (*out_insnp
));
973 out_insnp
->opcode
= instruction
->match
;
974 out_insnp
->reloc
= BFD_RELOC_NONE
;
975 out_insnp
->insn_type
= CRIS_INSN_NORMAL
;
976 out_insnp
->imm_oprnd_size
= 0;
980 /* Build the opcode, checking as we go to make sure that the
982 for (args
= instruction
->args
;; ++args
)
987 /* If we've come to the end of arguments, we're done. */
993 /* Non-matcher character for disassembly.
999 /* These must match exactly. */
1005 /* This is not really an operand, but causes a "BDAP
1006 -size,SP" prefix to be output, for PUSH instructions. */
1007 prefixp
->kind
= PREFIX_PUSH
;
1011 /* This letter marks an operand that should not be matched
1012 in the assembler. It is a branch with 16-bit
1013 displacement. The assembler will create them from the
1014 8-bit flavor when necessary. The assembler does not
1015 support the [rN+] operand, as the [r15+] that is
1016 generated for 16-bit displacements. */
1020 /* A 5-bit unsigned immediate in bits <4:0>. */
1021 if (! cris_get_expression (&s
, &out_insnp
->expr
))
1025 if (out_insnp
->expr
.X_op
== O_constant
1026 && (out_insnp
->expr
.X_add_number
< 0
1027 || out_insnp
->expr
.X_add_number
> 31))
1028 as_bad (_("Immediate value not in 5 bit unsigned range: %ld"),
1029 out_insnp
->expr
.X_add_number
);
1031 out_insnp
->reloc
= BFD_RELOC_CRIS_UNSIGNED_5
;
1036 /* A 4-bit unsigned immediate in bits <3:0>. */
1037 if (! cris_get_expression (&s
, &out_insnp
->expr
))
1041 if (out_insnp
->expr
.X_op
== O_constant
1042 && (out_insnp
->expr
.X_add_number
< 0
1043 || out_insnp
->expr
.X_add_number
> 15))
1044 as_bad (_("Immediate value not in 4 bit unsigned range: %ld"),
1045 out_insnp
->expr
.X_add_number
);
1047 out_insnp
->reloc
= BFD_RELOC_CRIS_UNSIGNED_4
;
1052 /* General register in bits <15:12> and <3:0>. */
1053 if (! get_gen_reg (&s
, ®no
))
1057 out_insnp
->opcode
|= regno
/* << 0 */;
1058 out_insnp
->opcode
|= regno
<< 12;
1063 /* Flags from the condition code register. */
1067 if (! get_flags (&s
, &flags
))
1070 out_insnp
->opcode
|= ((flags
& 0xf0) << 8) | (flags
& 0xf);
1075 /* A 6-bit signed immediate in bits <5:0>. */
1076 if (! cris_get_expression (&s
, &out_insnp
->expr
))
1080 if (out_insnp
->expr
.X_op
== O_constant
1081 && (out_insnp
->expr
.X_add_number
< -32
1082 || out_insnp
->expr
.X_add_number
> 31))
1083 as_bad (_("Immediate value not in 6 bit range: %ld"),
1084 out_insnp
->expr
.X_add_number
);
1085 out_insnp
->reloc
= BFD_RELOC_CRIS_SIGNED_6
;
1090 /* A 6-bit unsigned immediate in bits <5:0>. */
1091 if (! cris_get_expression (&s
, &out_insnp
->expr
))
1095 if (out_insnp
->expr
.X_op
== O_constant
1096 && (out_insnp
->expr
.X_add_number
< 0
1097 || out_insnp
->expr
.X_add_number
> 63))
1098 as_bad (_("Immediate value not in 6 bit unsigned range: %ld"),
1099 out_insnp
->expr
.X_add_number
);
1100 out_insnp
->reloc
= BFD_RELOC_CRIS_UNSIGNED_6
;
1105 /* A size modifier, B, W or D, to be put in a bit position
1106 suitable for CLEAR instructions (i.e. reflecting a zero
1108 if (! get_bwd_size_modifier (&s
, &size_bits
))
1115 out_insnp
->opcode
|= 0 << 12;
1119 out_insnp
->opcode
|= 4 << 12;
1123 out_insnp
->opcode
|= 8 << 12;
1130 /* A size modifier, B, W or D, to be put in bits <5:4>. */
1131 if (! get_bwd_size_modifier (&s
, &size_bits
))
1135 out_insnp
->opcode
|= size_bits
<< 4;
1140 /* A branch expression. */
1141 if (! cris_get_expression (&s
, &out_insnp
->expr
))
1145 out_insnp
->insn_type
= CRIS_INSN_BRANCH
;
1150 /* A BDAP expression for any size, "expr,r". */
1151 if (! cris_get_expression (&s
, &prefixp
->expr
))
1160 if (!get_gen_reg (&s
, &prefixp
->base_reg_number
))
1163 /* Since 'O' is used with an explicit bdap, we have no
1164 "real" instruction. */
1165 prefixp
->kind
= PREFIX_BDAP_IMM
;
1167 = BDAP_QUICK_OPCODE
| (prefixp
->base_reg_number
<< 12);
1169 out_insnp
->insn_type
= CRIS_INSN_NONE
;
1174 /* Special register in bits <15:12>. */
1175 if (! get_spec_reg (&s
, &out_insnp
->spec_reg
))
1179 /* Use of some special register names come with a
1180 specific warning. Note that we have no ".cpu type"
1181 pseudo yet, so some of this is just unused
1183 if (out_insnp
->spec_reg
->warning
)
1184 as_warn (out_insnp
->spec_reg
->warning
);
1185 else if (out_insnp
->spec_reg
->applicable_version
1186 == cris_ver_warning
)
1187 /* Others have a generic warning. */
1188 as_warn (_("Unimplemented register `%s' specified"),
1189 out_insnp
->spec_reg
->name
);
1192 |= out_insnp
->spec_reg
->number
<< 12;
1197 /* This character is used in the disassembler to
1198 recognize a prefix instruction to fold into the
1199 addressing mode for the next instruction. It is
1204 /* General register in bits <15:12>. */
1205 if (! get_gen_reg (&s
, ®no
))
1209 out_insnp
->opcode
|= regno
<< 12;
1214 /* General register in bits <3:0>. */
1215 if (! get_gen_reg (&s
, ®no
))
1219 out_insnp
->opcode
|= regno
/* << 0 */;
1224 /* Source operand in bit <10> and a prefix; a 3-operand
1226 if (! get_3op_or_dip_prefix_op (&s
, prefixp
))
1232 /* Source operand in bits <10>, <3:0> and optionally a
1233 prefix; i.e. an indirect operand or an side-effect
1235 if (! get_autoinc_prefix_or_indir_op (&s
, prefixp
, &mode
,
1242 if (prefixp
->kind
!= PREFIX_NONE
)
1244 /* A prefix, so it has the autoincrement bit
1246 out_insnp
->opcode
|= (AUTOINCR_BIT
<< 8);
1250 /* No prefix. The "mode" variable contains bits like
1251 whether or not this is autoincrement mode. */
1252 out_insnp
->opcode
|= (mode
<< 10);
1254 /* If there was a PIC reloc specifier, then it was
1255 attached to the prefix. Note that we can't check
1256 that the reloc size matches, since we don't have
1257 all the operands yet in all cases. */
1258 if (prefixp
->reloc
!= BFD_RELOC_NONE
)
1259 out_insnp
->reloc
= prefixp
->reloc
;
1262 out_insnp
->opcode
|= regno
/* << 0 */ ;
1267 /* Rs.m in bits <15:12> and <5:4>. */
1268 if (! get_gen_reg (&s
, ®no
)
1269 || ! get_bwd_size_modifier (&s
, &size_bits
))
1273 out_insnp
->opcode
|= (regno
<< 12) | (size_bits
<< 4);
1278 /* Source operand in bits <10>, <3:0> and optionally a
1279 prefix; i.e. an indirect operand or an side-effect
1282 The difference to 's' is that this does not allow an
1283 "immediate" expression. */
1284 if (! get_autoinc_prefix_or_indir_op (&s
, prefixp
,
1292 if (prefixp
->kind
!= PREFIX_NONE
)
1294 /* A prefix, and those matched here always have
1295 side-effects (see 's' case). */
1296 out_insnp
->opcode
|= (AUTOINCR_BIT
<< 8);
1300 /* No prefix. The "mode" variable contains bits
1301 like whether or not this is autoincrement
1303 out_insnp
->opcode
|= (mode
<< 10);
1306 out_insnp
->opcode
|= regno
/* << 0 */;
1311 /* Size modifier (B or W) in bit <4>. */
1312 if (! get_bw_size_modifier (&s
, &size_bits
))
1316 out_insnp
->opcode
|= size_bits
<< 4;
1324 /* We get here when we fail a match above or we found a
1325 complete match. Break out of this loop. */
1329 /* Was it a match or a miss? */
1332 /* If it's just that the args don't match, maybe the next
1333 item in the table is the same opcode but with
1334 matching operands. */
1335 if (instruction
[1].name
!= NULL
1336 && ! strcmp (instruction
->name
, instruction
[1].name
))
1338 /* Yep. Restart and try that one instead. */
1345 /* We've come to the end of instructions with this
1346 opcode, so it must be an error. */
1347 as_bad (_("Illegal operands"));
1353 /* We have a match. Check if there's anything more to do. */
1356 /* There was an immediate mode operand, so we must check
1357 that it has an appropriate size. */
1358 switch (instruction
->imm_oprnd_size
)
1362 /* Shouldn't happen; this one does not have immediate
1363 operands with different sizes. */
1364 BAD_CASE (instruction
->imm_oprnd_size
);
1368 out_insnp
->imm_oprnd_size
= 4;
1372 switch (out_insnp
->spec_reg
->reg_size
)
1375 if (out_insnp
->expr
.X_op
== O_constant
1376 && (out_insnp
->expr
.X_add_number
< -128
1377 || out_insnp
->expr
.X_add_number
> 255))
1378 as_bad (_("Immediate value not in 8 bit range: %ld"),
1379 out_insnp
->expr
.X_add_number
);
1382 /* FIXME: We need an indicator in the instruction
1383 table to pass on, to indicate if we need to check
1384 overflow for a signed or unsigned number. */
1385 if (out_insnp
->expr
.X_op
== O_constant
1386 && (out_insnp
->expr
.X_add_number
< -32768
1387 || out_insnp
->expr
.X_add_number
> 65535))
1388 as_bad (_("Immediate value not in 16 bit range: %ld"),
1389 out_insnp
->expr
.X_add_number
);
1390 out_insnp
->imm_oprnd_size
= 2;
1394 out_insnp
->imm_oprnd_size
= 4;
1398 BAD_CASE (out_insnp
->spec_reg
->reg_size
);
1406 if (out_insnp
->expr
.X_op
== O_constant
1407 && (out_insnp
->expr
.X_add_number
< -128
1408 || out_insnp
->expr
.X_add_number
> 255))
1409 as_bad (_("Immediate value not in 8 bit range: %ld"),
1410 out_insnp
->expr
.X_add_number
);
1413 if (out_insnp
->expr
.X_op
== O_constant
1414 && (out_insnp
->expr
.X_add_number
< -32768
1415 || out_insnp
->expr
.X_add_number
> 65535))
1416 as_bad (_("Immediate value not in 16 bit range: %ld"),
1417 out_insnp
->expr
.X_add_number
);
1418 out_insnp
->imm_oprnd_size
= 2;
1422 out_insnp
->imm_oprnd_size
= 4;
1426 BAD_CASE (out_insnp
->spec_reg
->reg_size
);
1430 /* If there was a relocation specified for the immediate
1431 expression (i.e. it had a PIC modifier) check that the
1432 size of the PIC relocation matches the size specified by
1434 if (out_insnp
->reloc
!= BFD_RELOC_NONE
1435 && (cris_get_pic_reloc_size (out_insnp
->reloc
)
1436 != (unsigned int) out_insnp
->imm_oprnd_size
))
1437 as_bad (_("PIC relocation size does not match operand size"));
1444 /* Get a B, W, or D size modifier from the string pointed out by *cPP,
1445 which must point to a '.' in front of the modifier. On successful
1446 return, *cPP is advanced to the character following the size
1447 modifier, and is undefined otherwise.
1449 cPP Pointer to pointer to string starting
1450 with the size modifier.
1452 size_bitsp Pointer to variable to contain the size bits on
1455 Return 1 iff a correct size modifier is found, else 0. */
1458 get_bwd_size_modifier (cPP
, size_bitsp
)
1466 /* Consume the '.'. */
1490 /* Consume the size letter. */
1496 /* Get a B or W size modifier from the string pointed out by *cPP,
1497 which must point to a '.' in front of the modifier. On successful
1498 return, *cPP is advanced to the character following the size
1499 modifier, and is undefined otherwise.
1501 cPP Pointer to pointer to string starting
1502 with the size modifier.
1504 size_bitsp Pointer to variable to contain the size bits on
1507 Return 1 iff a correct size modifier is found, else 0. */
1510 get_bw_size_modifier (cPP
, size_bitsp
)
1518 /* Consume the '.'. */
1537 /* Consume the size letter. */
1543 /* Get a general register from the string pointed out by *cPP. The
1544 variable *cPP is advanced to the character following the general
1545 register name on a successful return, and has its initial position
1548 cPP Pointer to pointer to string, beginning with a general
1551 regnop Pointer to int containing the register number.
1553 Return 1 iff a correct general register designator is found,
1557 get_gen_reg (cPP
, regnop
)
1564 /* Handle a sometimes-mandatory dollar sign as register prefix. */
1565 if (**cPP
== REGISTER_PREFIX_CHAR
)
1567 else if (demand_register_prefix
)
1574 /* "P" as in "PC"? Consume the "P". */
1577 if ((**cPP
== 'C' || **cPP
== 'c')
1578 && ! isalnum ((*cPP
)[1]))
1580 /* It's "PC": consume the "c" and we're done. */
1589 /* Hopefully r[0-9] or r1[0-5]. Consume 'R' or 'r'. */
1592 if (isdigit (**cPP
))
1594 /* It's r[0-9]. Consume and check the next digit. */
1595 *regnop
= **cPP
- '0';
1598 if (! isalnum (**cPP
))
1600 /* No more digits, we're done. */
1605 /* One more digit. Consume and add. */
1606 *regnop
= *regnop
* 10 + (**cPP
- '0');
1608 /* We need to check for a valid register number; Rn,
1609 0 <= n <= MAX_REG. */
1610 if (*regnop
<= MAX_REG
)
1612 /* Consume second digit. */
1622 /* "S" as in "SP"? Consume the "S". */
1624 if (**cPP
== 'P' || **cPP
== 'p')
1626 /* It's "SP": consume the "p" and we're done. */
1634 /* Just here to silence compilation warnings. */
1638 /* We get here if we fail. Restore the pointer. */
1643 /* Get a special register from the string pointed out by *cPP. The
1644 variable *cPP is advanced to the character following the special
1645 register name if one is found, and retains its original position
1648 cPP Pointer to pointer to string starting with a special register
1651 sregpp Pointer to Pointer to struct spec_reg, where a pointer to the
1652 register description will be stored.
1654 Return 1 iff a correct special register name is found. */
1657 get_spec_reg (cPP
, sregpp
)
1659 const struct cris_spec_reg
**sregpp
;
1663 char *name_begin
= *cPP
;
1665 const struct cris_spec_reg
*sregp
;
1667 /* Handle a sometimes-mandatory dollar sign as register prefix. */
1668 if (*name_begin
== REGISTER_PREFIX_CHAR
)
1670 else if (demand_register_prefix
)
1673 /* Loop over all special registers. */
1674 for (sregp
= cris_spec_regs
; sregp
->name
!= NULL
; sregp
++)
1676 /* Start over from beginning of the supposed name. */
1681 && (isupper (*s1
) ? tolower (*s1
) == *s2
: *s1
== *s2
))
1687 /* For a match, we must have consumed the name in the table, and we
1688 must be outside what could be part of a name. Assume here that a
1689 test for alphanumerics is sufficient for a name test. */
1690 if (*s2
== 0 && ! isalnum (*s1
))
1692 /* We have a match. Update the pointer and be done. */
1699 /* If we got here, we did not find any name. */
1703 /* Get an unprefixed or side-effect-prefix operand from the string pointed
1704 out by *cPP. The pointer *cPP is advanced to the character following
1705 the indirect operand if we have success, else it contains an undefined
1708 cPP Pointer to pointer to string beginning with the first
1709 character of the supposed operand.
1711 prefixp Pointer to structure containing an optional instruction
1714 is_autoincp Pointer to int indicating the indirect or autoincrement
1717 src_regnop Pointer to int containing the source register number in
1720 imm_foundp Pointer to an int indicating if an immediate expression
1723 imm_exprP Pointer to a structure containing an immediate
1724 expression, if success and if *imm_foundp is nonzero.
1726 Return 1 iff a correct indirect operand is found. */
1729 get_autoinc_prefix_or_indir_op (cPP
, prefixp
, is_autoincp
, src_regnop
,
1730 imm_foundp
, imm_exprP
)
1732 struct cris_prefix
*prefixp
;
1736 expressionS
*imm_exprP
;
1738 /* Assume there was no immediate mode expression. */
1743 /* So this operand is one of:
1745 Autoincrement: [rN+]
1746 Indexed with assign: [rN=rM+rO.S]
1747 Offset with assign: [rN=rM+I], [rN=rM+[rO].s], [rN=rM+[rO+].s]
1749 Either way, consume the '['. */
1752 /* Get the rN register. */
1753 if (! get_gen_reg (cPP
, src_regnop
))
1754 /* If there was no register, then this cannot match. */
1758 /* We got the register, now check the next character. */
1762 /* Indirect mode. We're done here. */
1763 prefixp
->kind
= PREFIX_NONE
;
1768 /* This must be an auto-increment mode, if there's a
1770 prefixp
->kind
= PREFIX_NONE
;
1773 /* We consume this character and break out to check the
1779 /* This must be indexed with assign, or offset with assign
1783 /* Either way, the next thing must be a register. */
1784 if (! get_gen_reg (cPP
, &prefixp
->base_reg_number
))
1785 /* No register, no match. */
1789 /* We've consumed "[rN=rM", so we must be looking at
1790 "+rO.s]" or "+I]", or "-I]", or "+[rO].s]" or
1794 int index_reg_number
;
1800 /* This must be [rx=ry+[rz].s] or
1801 [rx=ry+[rz+].s] or no match. We must be
1802 looking at rz after consuming the '['. */
1805 if (!get_gen_reg (cPP
, &index_reg_number
))
1808 prefixp
->kind
= PREFIX_BDAP
;
1810 = (BDAP_INDIR_OPCODE
1811 + (prefixp
->base_reg_number
<< 12)
1812 + index_reg_number
);
1816 /* We've seen "[rx=ry+[rz+" here, so now we
1817 know that there must be "].s]" left to
1820 prefixp
->opcode
|= AUTOINCR_BIT
<< 8;
1823 /* If it wasn't autoincrement, we don't need to
1826 /* Check the next-to-last ']'. */
1832 /* Check the ".s" modifier. */
1833 if (! get_bwd_size_modifier (cPP
, &size_bits
))
1836 prefixp
->opcode
|= size_bits
<< 4;
1838 /* Now we got [rx=ry+[rz+].s or [rx=ry+[rz].s.
1839 We break out to check the final ']'. */
1842 /* It wasn't an indirection. Check if it's a
1844 else if (get_gen_reg (cPP
, &index_reg_number
))
1848 /* Indexed with assign mode: "[rN+rM.S]". */
1849 prefixp
->kind
= PREFIX_BIAP
;
1851 = (BIAP_OPCODE
+ (index_reg_number
<< 12)
1852 + prefixp
->base_reg_number
/* << 0 */);
1854 if (! get_bwd_size_modifier (cPP
, &size_bits
))
1855 /* Size missing, this isn't a match. */
1859 /* Size found, break out to check the
1861 prefixp
->opcode
|= size_bits
<< 4;
1865 /* Not a register. Then this must be "[rN+I]". */
1866 else if (cris_get_expression (cPP
, &prefixp
->expr
))
1868 /* We've got offset with assign mode. Fill
1869 in the blanks and break out to match the
1871 prefixp
->kind
= PREFIX_BDAP_IMM
;
1873 /* We tentatively put an opcode corresponding to
1874 a 32-bit operand here, although it may be
1875 relaxed when there's no PIC specifier for the
1878 = (BDAP_INDIR_OPCODE
1879 | (prefixp
->base_reg_number
<< 12)
1880 | (AUTOINCR_BIT
<< 8)
1882 | REG_PC
/* << 0 */);
1884 /* This can have a PIC suffix, specifying reloc
1886 if (pic
&& **cPP
== PIC_SUFFIX_CHAR
)
1888 unsigned int relocsize
;
1890 cris_get_pic_suffix (cPP
, &prefixp
->reloc
,
1893 /* Tweak the size of the immediate operand
1894 in the prefix opcode if it isn't what we
1897 = cris_get_pic_reloc_size (prefixp
->reloc
);
1900 = ((prefixp
->opcode
& ~(3 << 4))
1901 | ((relocsize
>> 1) << 4));
1906 /* Neither register nor expression found, so
1907 this can't be a match. */
1910 /* Not "[rN+" but perhaps "[rN-"? */
1911 else if (**cPP
== '-')
1913 /* We must have an offset with assign mode. */
1914 if (! cris_get_expression (cPP
, &prefixp
->expr
))
1915 /* No expression, no match. */
1919 /* We've got offset with assign mode. Fill
1920 in the blanks and break out to match the
1923 Note that we don't allow a PIC suffix for an
1924 operand with a minus sign. */
1925 prefixp
->kind
= PREFIX_BDAP_IMM
;
1930 /* Neither '+' nor '-' after "[rN=rM". Lose. */
1934 /* Neither ']' nor '+' nor '=' after "[rN". Lose. */
1939 /* When we get here, we have a match and will just check the closing
1940 ']'. We can still fail though. */
1945 /* Don't forget to consume the final ']'.
1946 Then return in glory. */
1951 /* No indirection. Perhaps a constant? */
1952 else if (cris_get_expression (cPP
, imm_exprP
))
1954 /* Expression found, this is immediate mode. */
1955 prefixp
->kind
= PREFIX_NONE
;
1957 *src_regnop
= REG_PC
;
1960 /* This can have a PIC suffix, specifying reloc type to use. The
1961 caller must check that the reloc size matches the operand size. */
1962 if (pic
&& **cPP
== PIC_SUFFIX_CHAR
)
1963 cris_get_pic_suffix (cPP
, &prefixp
->reloc
, imm_exprP
);
1968 /* No luck today. */
1972 /* This function gets an indirect operand in a three-address operand
1973 combination from the string pointed out by *cPP. The pointer *cPP is
1974 advanced to the character following the indirect operand on success, or
1975 has an unspecified value on failure.
1977 cPP Pointer to pointer to string begining
1980 prefixp Pointer to structure containing an
1983 Returns 1 iff a correct indirect operand is found. */
1986 get_3op_or_dip_prefix_op (cPP
, prefixp
)
1988 struct cris_prefix
*prefixp
;
1993 /* We must have a '[' or it's a clean failure. */
1996 /* Eat the first '['. */
2001 /* A second '[', so this must be double-indirect mode. */
2003 prefixp
->kind
= PREFIX_DIP
;
2004 prefixp
->opcode
= DIP_OPCODE
;
2006 /* Get the register or fail entirely. */
2007 if (! get_gen_reg (cPP
, ®_number
))
2011 prefixp
->opcode
|= reg_number
/* << 0 */ ;
2014 /* Since we found a '+', this must be double-indirect
2015 autoincrement mode. */
2017 prefixp
->opcode
|= AUTOINCR_BIT
<< 8;
2020 /* There's nothing particular to do, if this was a
2021 double-indirect *without* autoincrement. */
2024 /* Check the first ']'. The second one is checked at the end. */
2028 /* Eat the first ']', so we'll be looking at a second ']'. */
2031 /* No second '['. Then we should have a register here, making
2033 else if (get_gen_reg (cPP
, &prefixp
->base_reg_number
))
2035 /* This must be indexed or offset mode: "[rN+I]" or
2036 "[rN+rM.S]" or "[rN+[rM].S]" or "[rN+[rM+].S]". */
2039 int index_reg_number
;
2045 /* This is "[rx+["... Expect a register next. */
2049 if (!get_gen_reg (cPP
, &index_reg_number
))
2052 prefixp
->kind
= PREFIX_BDAP
;
2054 = (BDAP_INDIR_OPCODE
2055 + (prefixp
->base_reg_number
<< 12)
2056 + index_reg_number
);
2058 /* We've seen "[rx+[ry", so check if this is
2062 /* Yep, now at "[rx+[ry+". */
2064 prefixp
->opcode
|= AUTOINCR_BIT
<< 8;
2066 /* If it wasn't autoincrement, we don't need to
2069 /* Check a first closing ']': "[rx+[ry]" or
2075 /* Now expect a size modifier ".S". */
2076 if (! get_bwd_size_modifier (cPP
, &size_bits
))
2079 prefixp
->opcode
|= size_bits
<< 4;
2081 /* Ok, all interesting stuff has been seen:
2082 "[rx+[ry+].S" or "[rx+[ry].S". We only need to
2083 expect a final ']', which we'll do in a common
2086 /* Seen "[rN+", but not a '[', so check if we have a
2088 else if (get_gen_reg (cPP
, &index_reg_number
))
2090 /* This is indexed mode: "[rN+rM.S]" or
2093 prefixp
->kind
= PREFIX_BIAP
;
2096 | prefixp
->base_reg_number
/* << 0 */
2097 | (index_reg_number
<< 12));
2099 /* Consume the ".S". */
2100 if (! get_bwd_size_modifier (cPP
, &size_bits
))
2101 /* Missing size, so fail. */
2104 /* Size found. Add that piece and drop down to
2105 the common checking of the closing ']'. */
2106 prefixp
->opcode
|= size_bits
<< 4;
2108 /* Seen "[rN+", but not a '[' or a register, so then
2109 it must be a constant "I". */
2110 else if (cris_get_expression (cPP
, &prefixp
->expr
))
2112 /* Expression found, so fill in the bits of offset
2113 mode and drop down to check the closing ']'. */
2114 prefixp
->kind
= PREFIX_BDAP_IMM
;
2116 /* We tentatively put an opcode corresponding to a 32-bit
2117 operand here, although it may be relaxed when there's no
2118 PIC specifier for the operand. */
2120 = (BDAP_INDIR_OPCODE
2121 | (prefixp
->base_reg_number
<< 12)
2122 | (AUTOINCR_BIT
<< 8)
2124 | REG_PC
/* << 0 */);
2126 /* This can have a PIC suffix, specifying reloc type to use. */
2127 if (pic
&& **cPP
== PIC_SUFFIX_CHAR
)
2129 unsigned int relocsize
;
2131 cris_get_pic_suffix (cPP
, &prefixp
->reloc
, &prefixp
->expr
);
2133 /* Tweak the size of the immediate operand in the prefix
2134 opcode if it isn't what we set. */
2135 relocsize
= cris_get_pic_reloc_size (prefixp
->reloc
);
2138 = ((prefixp
->opcode
& ~(3 << 4))
2139 | ((relocsize
>> 1) << 4));
2143 /* Nothing valid here: lose. */
2146 /* Seen "[rN" but no '+', so check if it's a '-'. */
2147 else if (**cPP
== '-')
2149 /* Yep, we must have offset mode. */
2150 if (! cris_get_expression (cPP
, &prefixp
->expr
))
2151 /* No expression, so we lose. */
2155 /* Expression found to make this offset mode, so
2156 fill those bits and drop down to check the
2159 Note that we don't allow a PIC suffix for
2160 an operand with a minus sign like this. */
2161 prefixp
->kind
= PREFIX_BDAP_IMM
;
2166 /* We've seen "[rN", but not '+' or '-'; rather a ']'.
2167 Hmm. Normally this is a simple indirect mode that we
2168 shouldn't match, but if we expect ']', then we have a
2169 zero offset, so it can be a three-address-operand,
2170 like "[rN],rO,rP", thus offset mode.
2172 Don't eat the ']', that will be done in the closing
2174 prefixp
->expr
.X_op
= O_constant
;
2175 prefixp
->expr
.X_add_number
= 0;
2176 prefixp
->expr
.X_add_symbol
= NULL
;
2177 prefixp
->expr
.X_op_symbol
= NULL
;
2178 prefixp
->kind
= PREFIX_BDAP_IMM
;
2181 /* A '[', but no second '[', and no register. Check if we
2182 have an expression, making this "[I]" for a double-indirect
2184 else if (cris_get_expression (cPP
, &prefixp
->expr
))
2186 /* Expression found, the so called absolute mode for a
2187 double-indirect prefix on PC. */
2188 prefixp
->kind
= PREFIX_DIP
;
2189 prefixp
->opcode
= DIP_OPCODE
| (AUTOINCR_BIT
<< 8) | REG_PC
;
2190 prefixp
->reloc
= BFD_RELOC_32
;
2193 /* Neither '[' nor register nor expression. We lose. */
2196 /* We get here as a closing ceremony to a successful match. We just
2197 need to check the closing ']'. */
2199 /* Oops. Close but no air-polluter. */
2202 /* Don't forget to consume that ']', before returning in glory. */
2207 /* Get an expression from the string pointed out by *cPP.
2208 The pointer *cPP is advanced to the character following the expression
2209 on a success, or retains its original value otherwise.
2211 cPP Pointer to pointer to string beginning with the expression.
2213 exprP Pointer to structure containing the expression.
2215 Return 1 iff a correct expression is found. */
2218 cris_get_expression (cPP
, exprP
)
2222 char *saved_input_line_pointer
;
2225 /* The "expression" function expects to find an expression at the
2226 global variable input_line_pointer, so we have to save it to give
2227 the impression that we don't fiddle with global variables. */
2228 saved_input_line_pointer
= input_line_pointer
;
2229 input_line_pointer
= *cPP
;
2231 exp
= expression (exprP
);
2232 if (exprP
->X_op
== O_illegal
|| exprP
->X_op
== O_absent
)
2234 input_line_pointer
= saved_input_line_pointer
;
2238 /* Everything seems to be fine, just restore the global
2239 input_line_pointer and say we're successful. */
2240 *cPP
= input_line_pointer
;
2241 input_line_pointer
= saved_input_line_pointer
;
2245 /* Get a sequence of flag characters from *spp. The pointer *cPP is
2246 advanced to the character following the expression. The flag
2247 characters are consecutive, no commas or spaces.
2249 cPP Pointer to pointer to string beginning with the expression.
2251 flagp Pointer to int to return the flags expression.
2253 Return 1 iff a correct flags expression is found. */
2256 get_flags (cPP
, flagsp
)
2309 /* We consider this successful if we stop at a comma or
2310 whitespace. Anything else, and we consider it a failure. */
2313 && ! isspace (**cPP
))
2319 /* Don't forget to consume each flag character. */
2324 /* Generate code and fixes for a BDAP prefix.
2326 base_regno Int containing the base register number.
2328 exprP Pointer to structure containing the offset expression. */
2331 gen_bdap (base_regno
, exprP
)
2335 unsigned int opcode
;
2338 /* Put out the prefix opcode; assume quick immediate mode at first. */
2339 opcode
= BDAP_QUICK_OPCODE
| (base_regno
<< 12);
2340 opcodep
= frag_more (2);
2341 md_number_to_chars (opcodep
, opcode
, 2);
2343 if (exprP
->X_op
== O_constant
)
2345 /* We have an absolute expression that we know the size of right
2350 value
= exprP
->X_add_number
;
2351 if (value
< -32768 || value
> 32767)
2352 /* Outside range for a "word", make it a dword. */
2355 /* Assume "word" size. */
2358 /* If this is a signed-byte value, we can fit it into the prefix
2360 if (value
>= -128 && value
<= 127)
2364 /* This is a word or dword displacement, which will be put in a
2365 word or dword after the prefix. */
2368 opcodep
[0] = BDAP_PC_LOW
+ (size
<< 4);
2370 opcodep
[1] |= BDAP_INCR_HIGH
;
2371 p
= frag_more (1 << size
);
2372 md_number_to_chars (p
, value
, 1 << size
);
2377 /* Handle complex expressions. */
2379 = exprP
->X_op_symbol
!= NULL
? 0 : exprP
->X_add_number
;
2381 = (exprP
->X_op_symbol
!= NULL
2382 ? make_expr_symbol (exprP
) : exprP
->X_add_symbol
);
2384 /* The expression is not defined yet but may become absolute. We
2385 make it a relocation to be relaxed. */
2386 frag_var (rs_machine_dependent
, 4, 0,
2387 ENCODE_RELAX (STATE_BASE_PLUS_DISP_PREFIX
, STATE_UNDF
),
2388 sym
, addvalue
, opcodep
);
2392 /* Encode a branch displacement in the range -256..254 into the form used
2393 by CRIS conditional branch instructions.
2395 offset The displacement value in bytes. */
2398 branch_disp (offset
)
2403 disp
= offset
& 0xFE;
2411 /* Generate code and fixes for a 32-bit conditional branch instruction
2412 created by "extending" an existing 8-bit branch instruction.
2414 opcodep Pointer to the word containing the original 8-bit branch
2417 writep Pointer to "extension area" following the first instruction
2420 fragP Pointer to the frag containing the instruction.
2422 add_symP, Parts of the destination address expression.
2427 gen_cond_branch_32 (opcodep
, writep
, fragP
, add_symP
, sub_symP
, add_num
)
2435 if (warn_for_branch_expansion
)
2436 as_warn_where (fragP
->fr_file
, fragP
->fr_line
,
2437 _("32-bit conditional branch generated"));
2439 /* Here, writep points to what will be opcodep + 2. First, we change
2440 the actual branch in opcodep[0] and opcodep[1], so that in the
2441 final insn, it will look like:
2444 This means we don't have to worry about changing the opcode or
2445 messing with the delay-slot instruction. So, we move it to last in
2446 the "extended" branch, and just change the displacement. Admittedly,
2447 it's not the optimal extended construct, but we should get this
2448 rarely enough that it shouldn't matter. */
2450 writep
[8] = branch_disp (-2 - 6);
2451 writep
[9] = opcodep
[1];
2453 /* Then, we change the branch to an unconditional branch over the
2454 extended part, to the new location of the Bcc:
2458 Note that these two writes are to currently different locations,
2461 md_number_to_chars (opcodep
, BA_QUICK_OPCODE
+ 8, 2);
2462 md_number_to_chars (writep
, NOP_OPCODE
, 2);
2464 /* Then the extended thing, the 32-bit jump insn.
2465 opcodep+4: JUMP [PC+]
2466 or, in the PIC case,
2467 opcodep+4: ADD [PC+],PC. */
2469 md_number_to_chars (writep
+ 2,
2470 pic
? ADD_PC_INCR_OPCODE
: JUMP_PC_INCR_OPCODE
, 2);
2472 /* We have to fill in the actual value too.
2474 This is most probably an expression, but we can cope with an absolute
2475 value too. FIXME: Testcase needed with and without pic. */
2477 if (add_symP
== NULL
&& sub_symP
== NULL
)
2479 /* An absolute address. */
2481 fix_new (fragP
, writep
+ 4 - fragP
->fr_literal
, 4,
2482 section_symbol (absolute_section
),
2483 add_num
, 1, BFD_RELOC_32_PCREL
);
2485 md_number_to_chars (writep
+ 4, add_num
, 4);
2489 if (sub_symP
!= NULL
)
2490 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2491 _("Complex expression not supported"));
2493 /* Not absolute, we have to make it a frag for later evaluation. */
2494 fix_new (fragP
, writep
+ 4 - fragP
->fr_literal
, 4, add_symP
,
2495 add_num
, pic
? 1 : 0, pic
? BFD_RELOC_32_PCREL
: BFD_RELOC_32
);
2499 /* Get the size of an immediate-reloc in bytes. Only valid for PIC
2503 cris_get_pic_reloc_size (reloc
)
2504 bfd_reloc_code_real_type reloc
;
2506 return reloc
== BFD_RELOC_CRIS_16_GOTPLT
|| reloc
== BFD_RELOC_CRIS_16_GOT
2510 /* Store a reloc type at *RELOCP corresponding to the PIC suffix at *CPP.
2511 Adjust *EXPRP with any addend found after the PIC suffix. */
2514 cris_get_pic_suffix (cPP
, relocp
, exprP
)
2516 bfd_reloc_code_real_type
*relocp
;
2521 expressionS const_expr
;
2523 const struct pic_suffixes_struct
2525 const char *const suffix
;
2527 bfd_reloc_code_real_type reloc
;
2531 #define PICMAP(s, r) {s, sizeof (s) - 1, r}
2532 /* Keep this in order with longest unambiguous prefix first. */
2533 PICMAP ("GOTPLT16", BFD_RELOC_CRIS_16_GOTPLT
),
2534 PICMAP ("GOTPLT", BFD_RELOC_CRIS_32_GOTPLT
),
2535 PICMAP ("PLTG", BFD_RELOC_CRIS_32_PLT_GOTREL
),
2536 PICMAP ("PLT", BFD_RELOC_CRIS_32_PLT_PCREL
),
2537 PICMAP ("GOTOFF", BFD_RELOC_CRIS_32_GOTREL
),
2538 PICMAP ("GOT16", BFD_RELOC_CRIS_16_GOT
),
2539 PICMAP ("GOT", BFD_RELOC_CRIS_32_GOT
)
2542 /* We've already seen the ':', so consume it. */
2545 for (i
= 0; i
< sizeof (pic_suffixes
)/sizeof (pic_suffixes
[0]); i
++)
2547 if (strncmp (s
, pic_suffixes
[i
].suffix
, pic_suffixes
[i
].len
) == 0
2548 && ! is_part_of_name (s
[pic_suffixes
[i
].len
]))
2550 /* We have a match. Consume the suffix and set the relocation
2552 s
+= pic_suffixes
[i
].len
;
2554 /* There can be a constant term appended. If so, we will add it
2556 if (*s
== '+' || *s
== '-')
2558 if (! cris_get_expression (&s
, &const_expr
))
2559 /* There was some kind of syntax error. Bail out. */
2562 /* Allow complex expressions as the constant part. It still
2563 has to be a assembly-time constant or there will be an
2564 error emitting the reloc. This makes the PIC qualifiers
2565 idempotent; foo:GOTOFF+32 == foo+32:GOTOFF. The former we
2566 recognize here; the latter is parsed in the incoming
2568 exprP
->X_add_symbol
= make_expr_symbol (exprP
);
2569 exprP
->X_op
= O_add
;
2570 exprP
->X_add_number
= 0;
2571 exprP
->X_op_symbol
= make_expr_symbol (&const_expr
);
2574 *relocp
= pic_suffixes
[i
].reloc
;
2580 /* No match. Don't consume anything; fall back and there will be a
2586 Turn a string in input_line_pointer into a floating point constant
2587 of type TYPE, and store the appropriate bytes in *LITP. The number
2588 of LITTLENUMS emitted is stored in *SIZEP.
2590 type A character from FLTCHARS that describes what kind of
2591 floating-point number is wanted.
2593 litp A pointer to an array that the result should be stored in.
2595 sizep A pointer to an integer where the size of the result is stored.
2597 But we don't support floating point constants in assembly code *at all*,
2598 since it's suboptimal and just opens up bug opportunities. GCC emits
2599 the bit patterns as hex. All we could do here is to emit what GCC
2600 would have done in the first place. *Nobody* writes floating-point
2601 code as assembly code, but if they do, they should be able enough to
2602 find out the correct bit patterns and use them. */
2605 md_atof (type
, litp
, sizep
)
2606 char type ATTRIBUTE_UNUSED
;
2607 char *litp ATTRIBUTE_UNUSED
;
2608 int *sizep ATTRIBUTE_UNUSED
;
2610 /* FIXME: Is this function mentioned in the internals.texi manual? If
2612 return _("Bad call to md_atof () - floating point formats are not supported");
2615 /* Turn a number as a fixS * into a series of bytes that represents the
2616 number on the target machine. The purpose of this procedure is the
2617 same as that of md_number_to_chars but this procedure is supposed to
2618 handle general bit field fixes and machine-dependent fixups.
2620 bufp Pointer to an array where the result should be stored.
2622 val The value to store.
2624 n The number of bytes in "val" that should be stored.
2626 fixP The fix to be applied to the bit field starting at bufp.
2628 seg The segment containing this number. */
2631 cris_number_to_imm (bufp
, val
, n
, fixP
, seg
)
2643 /* We put the relative "vma" for the other segment for inter-segment
2644 relocations in the object data to stay binary "compatible" (with an
2645 uninteresting old version) for the relocation.
2646 Maybe delete some day. */
2648 && (sym_seg
= S_GET_SEGMENT (fixP
->fx_addsy
)) != seg
)
2649 val
+= sym_seg
->vma
;
2651 if (fixP
->fx_addsy
!= NULL
|| fixP
->fx_pcrel
)
2652 switch (fixP
->fx_r_type
)
2654 /* These must be fully resolved when getting here. */
2655 case BFD_RELOC_32_PCREL
:
2656 case BFD_RELOC_16_PCREL
:
2657 case BFD_RELOC_8_PCREL
:
2658 as_bad_where (fixP
->fx_frag
->fr_file
, fixP
->fx_frag
->fr_line
,
2659 _("PC-relative relocation must be trivially resolved"));
2664 switch (fixP
->fx_r_type
)
2666 /* Ditto here, we put the addend into the object code as
2667 well as the reloc addend. Keep it that way for now, to simplify
2668 regression tests on the object file contents. FIXME: Seems
2669 uninteresting now that we have a test suite. */
2671 case BFD_RELOC_CRIS_16_GOT
:
2672 case BFD_RELOC_CRIS_32_GOT
:
2673 case BFD_RELOC_CRIS_32_GOTREL
:
2674 case BFD_RELOC_CRIS_16_GOTPLT
:
2675 case BFD_RELOC_CRIS_32_GOTPLT
:
2676 case BFD_RELOC_CRIS_32_PLT_GOTREL
:
2677 case BFD_RELOC_CRIS_32_PLT_PCREL
:
2678 /* We don't want to put in any kind of non-zero bits in the data
2679 being relocated for these. */
2683 case BFD_RELOC_32_PCREL
:
2684 /* No use having warnings here, since most hosts have a 32-bit type
2685 for "long" (which will probably change soon, now that I wrote
2687 bufp
[3] = (val
>> 24) & 0xFF;
2688 bufp
[2] = (val
>> 16) & 0xFF;
2689 bufp
[1] = (val
>> 8) & 0xFF;
2690 bufp
[0] = val
& 0xFF;
2693 /* FIXME: The 16 and 8-bit cases should have a way to check
2694 whether a signed or unsigned (or any signedness) number is
2696 FIXME: Does the as_bad calls find the line number by themselves,
2697 or should we change them into as_bad_where? */
2700 case BFD_RELOC_16_PCREL
:
2701 if (val
> 0xffff || val
< -32768)
2702 as_bad (_("Value not in 16 bit range: %ld"), val
);
2703 if (! fixP
->fx_addsy
)
2705 bufp
[1] = (val
>> 8) & 0xFF;
2706 bufp
[0] = val
& 0xFF;
2711 case BFD_RELOC_8_PCREL
:
2712 if (val
> 255 || val
< -128)
2713 as_bad (_("Value not in 8 bit range: %ld"), val
);
2714 if (! fixP
->fx_addsy
)
2715 bufp
[0] = val
& 0xFF;
2718 case BFD_RELOC_CRIS_UNSIGNED_4
:
2719 if (val
> 15 || val
< 0)
2720 as_bad (_("Value not in 4 bit unsigned range: %ld"), val
);
2721 if (! fixP
->fx_addsy
)
2722 bufp
[0] |= val
& 0x0F;
2725 case BFD_RELOC_CRIS_UNSIGNED_5
:
2726 if (val
> 31 || val
< 0)
2727 as_bad (_("Value not in 5 bit unsigned range: %ld"), val
);
2728 if (! fixP
->fx_addsy
)
2729 bufp
[0] |= val
& 0x1F;
2732 case BFD_RELOC_CRIS_SIGNED_6
:
2733 if (val
> 31 || val
< -32)
2734 as_bad (_("Value not in 6 bit range: %ld"), val
);
2735 if (! fixP
->fx_addsy
)
2736 bufp
[0] |= val
& 0x3F;
2739 case BFD_RELOC_CRIS_UNSIGNED_6
:
2740 if (val
> 63 || val
< 0)
2741 as_bad (_("Value not in 6 bit unsigned range: %ld"), val
);
2742 if (! fixP
->fx_addsy
)
2743 bufp
[0] |= val
& 0x3F;
2746 case BFD_RELOC_CRIS_BDISP8
:
2747 if (! fixP
->fx_addsy
)
2748 bufp
[0] = branch_disp (val
);
2751 case BFD_RELOC_NONE
:
2752 /* May actually happen automatically. For example at broken
2753 words, if the word turns out not to be broken.
2754 FIXME: When? Which testcase? */
2755 if (! fixP
->fx_addsy
)
2756 md_number_to_chars (bufp
, val
, n
);
2759 case BFD_RELOC_VTABLE_INHERIT
:
2760 /* This borrowed from tc-ppc.c on a whim. */
2762 && !S_IS_DEFINED (fixP
->fx_addsy
)
2763 && !S_IS_WEAK (fixP
->fx_addsy
))
2764 S_SET_WEAK (fixP
->fx_addsy
);
2767 case BFD_RELOC_VTABLE_ENTRY
:
2772 BAD_CASE (fixP
->fx_r_type
);
2776 /* Processes machine-dependent command line options. Called once for
2777 each option on the command line that the machine-independent part of
2778 GAS does not understand. */
2781 md_parse_option (arg
, argp
)
2783 char *argp ATTRIBUTE_UNUSED
;
2789 printf (_("Please use --help to see usage and options for this assembler.\n"));
2790 md_show_usage (stdout
);
2791 exit (EXIT_SUCCESS
);
2794 warn_for_branch_expansion
= 1;
2798 demand_register_prefix
= true;
2800 if (OUTPUT_FLAVOR
== bfd_target_aout_flavour
)
2801 as_bad (_("--no-underscore is invalid with a.out format"));
2803 symbols_have_leading_underscore
= false;
2807 demand_register_prefix
= false;
2808 symbols_have_leading_underscore
= true;
2820 /* Round up a section size to the appropriate boundary. */
2822 md_section_align (segment
, size
)
2826 /* Round all sects to multiple of 4, except the bss section, which
2827 we'll round to word-size.
2829 FIXME: Check if this really matters. All sections should be
2830 rounded up, and all sections should (optionally) be assumed to be
2831 dword-aligned, it's just that there is actual usage of linking to a
2833 if (OUTPUT_FLAVOR
== bfd_target_aout_flavour
)
2835 if (segment
== bss_section
)
2836 return (size
+ 1) & ~1;
2837 return (size
+ 3) & ~3;
2841 /* FIXME: Is this wanted? It matches the testsuite, but that's not
2842 really a valid reason. */
2843 if (segment
== text_section
)
2844 return (size
+ 3) & ~3;
2850 /* Generate a machine-dependent relocation. */
2852 tc_gen_reloc (section
, fixP
)
2853 asection
*section ATTRIBUTE_UNUSED
;
2857 bfd_reloc_code_real_type code
;
2859 switch (fixP
->fx_r_type
)
2861 case BFD_RELOC_CRIS_16_GOT
:
2862 case BFD_RELOC_CRIS_32_GOT
:
2863 case BFD_RELOC_CRIS_16_GOTPLT
:
2864 case BFD_RELOC_CRIS_32_GOTPLT
:
2865 case BFD_RELOC_CRIS_32_GOTREL
:
2866 case BFD_RELOC_CRIS_32_PLT_GOTREL
:
2867 case BFD_RELOC_CRIS_32_PLT_PCREL
:
2871 case BFD_RELOC_VTABLE_INHERIT
:
2872 case BFD_RELOC_VTABLE_ENTRY
:
2873 code
= fixP
->fx_r_type
;
2876 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2877 _("Semantics error. This type of operand can not be relocated, it must be an assembly-time constant"));
2881 relP
= (arelent
*) xmalloc (sizeof (arelent
));
2883 relP
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
2884 *relP
->sym_ptr_ptr
= symbol_get_bfdsym (fixP
->fx_addsy
);
2885 relP
->address
= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
2888 /* FIXME: Is this correct? */
2889 relP
->addend
= fixP
->fx_addnumber
;
2891 /* At least *this one* is correct. */
2892 relP
->addend
= fixP
->fx_offset
;
2894 /* This is the standard place for KLUDGEs to work around bugs in
2895 bfd_install_relocation (first such note in the documentation
2896 appears with binutils-2.8).
2898 That function bfd_install_relocation does the wrong thing with
2899 putting stuff into the addend of a reloc (it should stay out) for a
2900 weak symbol. The really bad thing is that it adds the
2901 "segment-relative offset" of the symbol into the reloc. In this
2902 case, the reloc should instead be relative to the symbol with no
2903 other offset than the assembly code shows; and since the symbol is
2904 weak, any local definition should be ignored until link time (or
2906 To wit: weaksym+42 should be weaksym+42 in the reloc,
2907 not weaksym+(offset_from_segment_of_local_weaksym_definition)
2909 To "work around" this, we subtract the segment-relative offset of
2910 "known" weak symbols. This evens out the extra offset.
2912 That happens for a.out but not for ELF, since for ELF,
2913 bfd_install_relocation uses the "special function" field of the
2914 howto, and does not execute the code that needs to be undone. */
2916 if (OUTPUT_FLAVOR
== bfd_target_aout_flavour
2917 && fixP
->fx_addsy
&& S_IS_WEAK (fixP
->fx_addsy
)
2918 && ! bfd_is_und_section (S_GET_SEGMENT (fixP
->fx_addsy
)))
2920 relP
->addend
-= S_GET_VALUE (fixP
->fx_addsy
);
2923 relP
->howto
= bfd_reloc_type_lookup (stdoutput
, code
);
2928 name
= S_GET_NAME (fixP
->fx_addsy
);
2930 name
= _("<unknown>");
2931 as_fatal (_("Cannot generate relocation type for symbol %s, code %s"),
2932 name
, bfd_get_reloc_code_name (code
));
2938 /* Machine-dependent usage-output. */
2941 md_show_usage (stream
)
2944 /* The messages are formatted to line up with the generic options. */
2945 fprintf (stream
, _("CRIS-specific options:\n"));
2946 fprintf (stream
, "%s",
2947 _(" -h, -H Don't execute, print this help text. Deprecated.\n"));
2948 fprintf (stream
, "%s",
2949 _(" -N Warn when branches are expanded to jumps.\n"));
2950 fprintf (stream
, "%s",
2951 _(" --underscore User symbols are normally prepended with underscore.\n"));
2952 fprintf (stream
, "%s",
2953 _(" Registers will not need any prefix.\n"));
2954 fprintf (stream
, "%s",
2955 _(" --no-underscore User symbols do not have any prefix.\n"));
2956 fprintf (stream
, "%s",
2957 _(" Registers will require a `$'-prefix.\n"));
2958 fprintf (stream
, "%s",
2959 _(" --pic Enable generation of position-independent code.\n"));
2962 /* Apply a fixS (fixup of an instruction or data that we didn't have
2963 enough info to complete immediately) to the data in a frag. */
2966 md_apply_fix3 (fixP
, valP
, seg
)
2973 char *buf
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
2975 if (fixP
->fx_addsy
== 0 && !fixP
->fx_pcrel
)
2978 if (fixP
->fx_bit_fixP
|| fixP
->fx_im_disp
!= 0)
2980 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("Invalid relocation"));
2985 /* I took this from tc-arc.c, since we used to not support
2986 fx_subsy != NULL. I'm not totally sure it's TRT. */
2987 if (fixP
->fx_subsy
!= (symbolS
*) NULL
)
2989 if (S_GET_SEGMENT (fixP
->fx_subsy
) == absolute_section
)
2990 val
-= S_GET_VALUE (fixP
->fx_subsy
);
2993 /* We can't actually support subtracting a symbol. */
2994 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2995 _("expression too complex"));
2999 cris_number_to_imm (buf
, val
, fixP
->fx_size
, fixP
, seg
);
3005 /* All relocations are relative to the location just after the fixup;
3006 the address of the fixup plus its size. */
3009 md_pcrel_from (fixP
)
3012 valueT addr
= fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
3014 /* FIXME: We get here only at the end of assembly, when X in ".-X" is
3015 still unknown. Since we don't have pc-relative relocations in a.out,
3016 this is invalid. What to do if anything for a.out, is to add
3017 pc-relative relocations everywhere including the elinux program
3018 loader. For ELF, allow straight-forward PC-relative relocations,
3019 which are always relative to the location after the relocation. */
3020 if (OUTPUT_FLAVOR
!= bfd_target_elf_flavour
3021 || (fixP
->fx_r_type
!= BFD_RELOC_8_PCREL
3022 && fixP
->fx_r_type
!= BFD_RELOC_16_PCREL
3023 && fixP
->fx_r_type
!= BFD_RELOC_32_PCREL
))
3024 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
3025 _("Invalid pc-relative relocation"));
3026 return fixP
->fx_size
+ addr
;
3029 /* We have no need to give defaults for symbol-values. */
3031 md_undefined_symbol (name
)
3032 char *name ATTRIBUTE_UNUSED
;
3037 /* Definition of TC_FORCE_RELOCATION.
3038 FIXME: Unsure of this. Can we omit it? Just copied from tc-i386.c
3039 when doing multi-object format with ELF, since it's the only other
3040 multi-object-format target with a.out and ELF. */
3042 md_cris_force_relocation (fixp
)
3045 switch (fixp
->fx_r_type
)
3047 case BFD_RELOC_VTABLE_INHERIT
:
3048 case BFD_RELOC_VTABLE_ENTRY
:
3049 case BFD_RELOC_CRIS_16_GOT
:
3050 case BFD_RELOC_CRIS_32_GOT
:
3051 case BFD_RELOC_CRIS_16_GOTPLT
:
3052 case BFD_RELOC_CRIS_32_GOTPLT
:
3053 case BFD_RELOC_CRIS_32_GOTREL
:
3054 case BFD_RELOC_CRIS_32_PLT_GOTREL
:
3055 case BFD_RELOC_CRIS_32_PLT_PCREL
:
3064 /* Check and emit error if broken-word handling has failed to fix up a
3065 case-table. This is called from write.c, after doing everything it
3066 knows about how to handle broken words. */
3069 tc_cris_check_adjusted_broken_word (new_offset
, brokwP
)
3071 struct broken_word
*brokwP
;
3073 if (new_offset
> 32767 || new_offset
< -32768)
3074 /* We really want a genuine error, not a warning, so make it one. */
3075 as_bad_where (brokwP
->frag
->fr_file
, brokwP
->frag
->fr_line
,
3076 _("Adjusted signed .word (%ld) overflows: `switch'-statement too large."),
3080 /* Make a leading REGISTER_PREFIX_CHAR mandatory for all registers. */
3082 static void cris_force_reg_prefix ()
3084 demand_register_prefix
= true;
3087 /* Do not demand a leading REGISTER_PREFIX_CHAR for all registers. */
3089 static void cris_relax_reg_prefix ()
3091 demand_register_prefix
= false;
3094 /* Adjust for having a leading '_' on all user symbols. */
3096 static void cris_sym_leading_underscore ()
3098 /* We can't really do anything more than assert that what the program
3099 thinks symbol starts with agrees with the command-line options, since
3100 the bfd is already created. */
3102 if (symbols_have_leading_underscore
== false)
3103 as_bad (".syntax %s requires command-line option `--underscore'",
3104 SYNTAX_USER_SYM_LEADING_UNDERSCORE
);
3107 /* Adjust for not having any particular prefix on user symbols. */
3109 static void cris_sym_no_leading_underscore ()
3111 if (symbols_have_leading_underscore
== true)
3112 as_bad (".syntax %s requires command-line option `--no-underscore'",
3113 SYNTAX_USER_SYM_NO_LEADING_UNDERSCORE
);
3116 /* Handle the .syntax pseudo, which takes an argument that decides what
3117 syntax the assembly code has. */
3121 int ignore ATTRIBUTE_UNUSED
;
3123 static const struct syntaxes
3125 const char *operand
;
3126 void (*fn
) PARAMS ((void));
3128 {{SYNTAX_ENFORCE_REG_PREFIX
, cris_force_reg_prefix
},
3129 {SYNTAX_RELAX_REG_PREFIX
, cris_relax_reg_prefix
},
3130 {SYNTAX_USER_SYM_LEADING_UNDERSCORE
, cris_sym_leading_underscore
},
3131 {SYNTAX_USER_SYM_NO_LEADING_UNDERSCORE
, cris_sym_no_leading_underscore
}};
3133 const struct syntaxes
*sp
;
3135 for (sp
= syntax_table
;
3136 sp
< syntax_table
+ sizeof (syntax_table
) / sizeof (syntax_table
[0]);
3139 if (strncmp (input_line_pointer
, sp
->operand
,
3140 strlen (sp
->operand
)) == 0)
3144 input_line_pointer
+= strlen (sp
->operand
);
3145 demand_empty_rest_of_line ();
3150 as_bad (_("Unknown .syntax operand"));
3153 /* Wrapper for dwarf2_directive_file to emit error if this is seen when
3154 not emitting ELF. */
3160 if (OUTPUT_FLAVOR
!= bfd_target_elf_flavour
)
3161 as_bad ("Pseudodirective .file is only valid when generating ELF");
3163 dwarf2_directive_file (dummy
);
3166 /* Wrapper for dwarf2_directive_loc to emit error if this is seen when not
3173 if (OUTPUT_FLAVOR
!= bfd_target_elf_flavour
)
3174 as_bad ("Pseudodirective .loc is only valid when generating ELF");
3176 dwarf2_directive_loc (dummy
);
3181 * eval: (c-set-style "gnu")
3182 * indent-tabs-mode: t