2 Copyright (C) 2014-2017 Free Software Foundation, Inc.
3 Contributed by Dimitar Dimitrov <dimitar@dinux.eu>
6 This file is part of GAS, the GNU Assembler.
8 GAS is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GAS is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GAS; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
24 #include "bfd_stdint.h"
25 #include "opcode/pru.h"
29 #include "dwarf2dbg.h"
31 #include "safe-ctype.h"
32 #include "dw2gencfi.h"
35 /* We are not supporting any other target so we throw a compile time error. */
36 #error "OBJ_ELF not defined"
39 /* This array holds the chars that always start a comment. If the
40 pre-processor is disabled, these aren't very useful. */
41 const char comment_chars
[] = "#;";
43 /* This array holds the chars that only start a comment at the beginning of
44 a line. If the line seems to have the form '# 123 filename'
45 .line and .file directives will appear in the pre-processed output. */
46 /* Note that input_file.c hand checks for '#' at the beginning of the
47 first line of the input file. This is because the compiler outputs
48 #NO_APP at the beginning of its output. */
49 /* Also note that C style comments are always supported. */
50 const char line_comment_chars
[] = "#;*";
52 /* This array holds machine specific line separator characters. */
53 const char line_separator_chars
[] = "";
55 /* Chars that can be used to separate mant from exp in floating point nums. */
56 const char EXP_CHARS
[] = "eE";
58 /* Chars that mean this number is a floating point constant.
61 const char FLT_CHARS
[] = "rRsSfFdDxXpP";
63 /* Machine-dependent command-line options. */
67 /* -mno-link-relax / -mlink-relax: generate (or not)
68 relocations for linker relaxation. */
69 bfd_boolean link_relax
;
71 /* -mno-warn-regname-label: do not output a warning that a label name
72 matches a register name. */
73 bfd_boolean warn_regname_label
;
76 static struct pru_opt_s pru_opt
= { TRUE
, TRUE
};
78 const char *md_shortopts
= "r";
82 OPTION_LINK_RELAX
= OPTION_MD_BASE
+ 1,
84 OPTION_NO_WARN_REGNAME_LABEL
,
87 struct option md_longopts
[] = {
88 { "mlink-relax", no_argument
, NULL
, OPTION_LINK_RELAX
},
89 { "mno-link-relax", no_argument
, NULL
, OPTION_NO_LINK_RELAX
},
90 { "mno-warn-regname-label", no_argument
, NULL
,
91 OPTION_NO_WARN_REGNAME_LABEL
},
92 { NULL
, no_argument
, NULL
, 0 }
95 size_t md_longopts_size
= sizeof (md_longopts
);
97 typedef struct pru_insn_reloc
99 /* Any expression in the instruction is parsed into this field,
100 which is passed to fix_new_exp () to generate a fixup. */
101 expressionS reloc_expression
;
103 /* The type of the relocation to be applied. */
104 bfd_reloc_code_real_type reloc_type
;
107 unsigned int reloc_pcrel
;
109 /* The next relocation to be applied to the instruction. */
110 struct pru_insn_reloc
*reloc_next
;
113 /* This struct is used to hold state when assembling instructions. */
114 typedef struct pru_insn_info
116 /* Assembled instruction. */
117 unsigned long insn_code
;
118 /* Used for assembling LDI32. */
119 unsigned long ldi32_imm32
;
121 /* Pointer to the relevant bit of the opcode table. */
122 const struct pru_opcode
*insn_pru_opcode
;
123 /* After parsing ptrs to the tokens in the instruction fill this array
124 it is terminated with a null pointer (hence the first +1).
125 The second +1 is because in some parts of the code the opcode
126 is not counted as a token, but still placed in this array. */
127 const char *insn_tokens
[PRU_MAX_INSN_TOKENS
+ 1 + 1];
129 /* This holds information used to generate fixups
130 and eventually relocations if it is not null. */
131 pru_insn_relocS
*insn_reloc
;
134 /* Opcode hash table. */
135 static struct hash_control
*pru_opcode_hash
= NULL
;
136 #define pru_opcode_lookup(NAME) \
137 ((struct pru_opcode *) hash_find (pru_opcode_hash, (NAME)))
139 /* Register hash table. */
140 static struct hash_control
*pru_reg_hash
= NULL
;
141 #define pru_reg_lookup(NAME) \
142 ((struct pru_reg *) hash_find (pru_reg_hash, (NAME)))
144 /* The known current alignment of the current section. */
145 static int pru_current_align
;
146 static segT pru_current_align_seg
;
148 static int pru_auto_align_on
= 1;
150 /* The last seen label in the current section. This is used to auto-align
151 labels preceding instructions. */
152 static symbolS
*pru_last_label
;
155 /** Utility routines. */
156 /* Function md_chars_to_number takes the sequence of
157 bytes in buf and returns the corresponding value
158 in an int. n must be 1, 2, 4 or 8. */
160 md_chars_to_number (char *buf
, int n
)
165 gas_assert (n
== 1 || n
== 2 || n
== 4 || n
== 8);
168 for (i
= 0; i
< n
; ++i
)
169 val
= val
| ((buf
[i
] & 0xff) << 8 * i
);
174 /* This function turns a C long int, short int or char
175 into the series of bytes that represent the number
176 on the target machine. */
178 md_number_to_chars (char *buf
, valueT val
, int n
)
180 gas_assert (n
== 1 || n
== 2 || n
== 4 || n
== 8);
181 number_to_chars_littleendian (buf
, val
, n
);
184 /* Turn a string in input_line_pointer into a floating point constant
185 of type TYPE, and store the appropriate bytes in *LITP. The number
186 of LITTLENUMS emitted is stored in *SIZEP. An error message is
187 returned, or NULL on OK. */
189 md_atof (int type
, char *litP
, int *sizeP
)
191 return ieee_md_atof (type
, litP
, sizeP
, FALSE
);
194 /* Return true if STR starts with PREFIX, which should be a string literal. */
195 #define strprefix(STR, PREFIX) \
196 (strncmp ((STR), PREFIX, strlen (PREFIX)) == 0)
198 /* nop fill pattern for text section. */
199 static char const nop
[4] = { 0xe0, 0xe0, 0xe0, 0x12 };
201 /* Handles all machine-dependent alignment needs. */
203 pru_align (int log_size
, const char *pfill
, symbolS
*label
)
206 long max_alignment
= 15;
208 /* The front end is prone to changing segments out from under us
209 temporarily when -g is in effect. */
210 int switched_seg_p
= (pru_current_align_seg
!= now_seg
);
213 if (align
> max_alignment
)
215 align
= max_alignment
;
216 as_bad (_("Alignment too large: %d assumed"), align
);
220 as_warn (_("Alignment negative: 0 assumed"));
226 if (subseg_text_p (now_seg
) && align
>= 2)
228 /* First, make sure we're on a four-byte boundary, in case
229 someone has been putting .byte values the text section. */
230 if (pru_current_align
< 2 || switched_seg_p
)
231 frag_align (2, 0, 0);
233 /* Now fill in the alignment pattern. */
235 frag_align_pattern (align
, pfill
, sizeof nop
, 0);
237 frag_align (align
, 0, 0);
240 frag_align (align
, 0, 0);
243 pru_current_align
= align
;
245 /* If the last label was in a different section we can't align it. */
246 if (label
!= NULL
&& !switched_seg_p
)
249 int label_seen
= FALSE
;
250 struct frag
*old_frag
;
254 gas_assert (S_GET_SEGMENT (label
) == now_seg
);
256 old_frag
= symbol_get_frag (label
);
257 old_value
= S_GET_VALUE (label
);
258 new_value
= (valueT
) frag_now_fix ();
260 /* It is possible to have more than one label at a particular
261 address, especially if debugging is enabled, so we must
262 take care to adjust all the labels at this address in this
263 fragment. To save time we search from the end of the symbol
264 list, backwards, since the symbols we are interested in are
265 almost certainly the ones that were most recently added.
266 Also to save time we stop searching once we have seen at least
267 one matching label, and we encounter a label that is no longer
268 in the target fragment. Note, this search is guaranteed to
269 find at least one match when sym == label, so no special case
270 code is necessary. */
271 for (sym
= symbol_lastP
; sym
!= NULL
; sym
= symbol_previous (sym
))
272 if (symbol_get_frag (sym
) == old_frag
273 && S_GET_VALUE (sym
) == old_value
)
276 symbol_set_frag (sym
, frag_now
);
277 S_SET_VALUE (sym
, new_value
);
279 else if (label_seen
&& symbol_get_frag (sym
) != old_frag
)
282 record_alignment (now_seg
, align
);
287 /** Support for self-check mode. */
289 /* Mode of the assembler. */
292 PRU_MODE_ASSEMBLE
, /* Ordinary operation. */
293 PRU_MODE_TEST
/* Hidden mode used for self testing. */
296 static PRU_MODE pru_mode
= PRU_MODE_ASSEMBLE
;
298 /* This function is used to in self-checking mode
299 to check the assembled instruction
300 opcode should be the assembled opcode, and exp_opcode
301 the parsed string representing the expected opcode. */
303 pru_check_assembly (unsigned int opcode
, const char *exp_opcode
)
305 if (pru_mode
== PRU_MODE_TEST
)
307 if (exp_opcode
== NULL
)
308 as_bad (_("expecting opcode string in self test mode"));
309 else if (opcode
!= strtoul (exp_opcode
, NULL
, 16))
310 as_bad (_("assembly 0x%08x, expected %s"), opcode
, exp_opcode
);
315 /** Support for machine-dependent assembler directives. */
316 /* Handle the .align pseudo-op. This aligns to a power of two. It
317 also adjusts any current instruction label. We treat this the same
318 way the MIPS port does: .align 0 turns off auto alignment. */
320 s_pru_align (int ignore ATTRIBUTE_UNUSED
)
324 const char *pfill
= NULL
;
325 long max_alignment
= 15;
327 align
= get_absolute_expression ();
328 if (align
> max_alignment
)
330 align
= max_alignment
;
331 as_bad (_("Alignment too large: %d assumed"), align
);
335 as_warn (_("Alignment negative: 0 assumed"));
339 if (*input_line_pointer
== ',')
341 input_line_pointer
++;
342 fill
= get_absolute_expression ();
343 pfill
= (const char *) &fill
;
345 else if (subseg_text_p (now_seg
))
346 pfill
= (const char *) &nop
;
350 pru_last_label
= NULL
;
355 pru_auto_align_on
= 1;
356 pru_align (align
, pfill
, pru_last_label
);
357 pru_last_label
= NULL
;
360 pru_auto_align_on
= 0;
362 demand_empty_rest_of_line ();
365 /* Handle the .text pseudo-op. This is like the usual one, but it
366 clears the saved last label and resets known alignment. */
371 pru_last_label
= NULL
;
372 pru_current_align
= 0;
373 pru_current_align_seg
= now_seg
;
376 /* Handle the .data pseudo-op. This is like the usual one, but it
377 clears the saved last label and resets known alignment. */
382 pru_last_label
= NULL
;
383 pru_current_align
= 0;
384 pru_current_align_seg
= now_seg
;
387 /* Handle the .section pseudo-op. This is like the usual one, but it
388 clears the saved last label and resets known alignment. */
390 s_pru_section (int ignore
)
392 obj_elf_section (ignore
);
393 pru_last_label
= NULL
;
394 pru_current_align
= 0;
395 pru_current_align_seg
= now_seg
;
398 /* Explicitly unaligned cons. */
400 s_pru_ucons (int nbytes
)
403 hold
= pru_auto_align_on
;
404 pru_auto_align_on
= 0;
406 pru_auto_align_on
= hold
;
409 /* .set sets assembler options. */
411 s_pru_set (int equiv
)
413 char *save
= input_line_pointer
;
415 char delim
= get_symbol_name (&directive
);
416 char *endline
= input_line_pointer
;
418 (void) restore_line_pointer (delim
);
420 /* We only want to handle ".set XXX" if the
421 user has tried ".set XXX, YYY" they are not
422 trying a directive. This prevents
423 us from polluting the name space. */
425 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
427 bfd_boolean done
= TRUE
;
430 if (!strcmp (directive
, "no_warn_regname_label"))
431 pru_opt
.warn_regname_label
= FALSE
;
438 demand_empty_rest_of_line ();
443 /* If we fall through to here, either we have ".set XXX, YYY"
444 or we have ".set XXX" where XXX is unknown or we have
446 input_line_pointer
= save
;
450 /* Machine-dependent assembler directives.
451 Format of each entry is:
452 { "directive", handler_func, param } */
453 const pseudo_typeS md_pseudo_table
[] = {
454 {"align", s_pru_align
, 0},
455 {"text", s_pru_text
, 0},
456 {"data", s_pru_data
, 0},
457 {"section", s_pru_section
, 0},
458 {"section.s", s_pru_section
, 0},
459 {"sect", s_pru_section
, 0},
460 {"sect.s", s_pru_section
, 0},
461 /* .dword and .half are included for compatibility with MIPS. */
464 /* PRU native word size is 4 bytes, so we override
465 the GAS default of 2. */
467 /* Explicitly unaligned directives. */
468 {"2byte", s_pru_ucons
, 2},
469 {"4byte", s_pru_ucons
, 4},
470 {"8byte", s_pru_ucons
, 8},
471 {"16byte", s_pru_ucons
, 16},
472 {"set", s_pru_set
, 0},
478 md_estimate_size_before_relax (fragS
*fragp ATTRIBUTE_UNUSED
,
479 asection
*seg ATTRIBUTE_UNUSED
)
486 md_convert_frag (bfd
*headers ATTRIBUTE_UNUSED
, segT segment ATTRIBUTE_UNUSED
,
487 fragS
*fragp ATTRIBUTE_UNUSED
)
494 relaxable_section (asection
*sec
)
496 return ((sec
->flags
& SEC_DEBUGGING
) == 0
497 && (sec
->flags
& SEC_CODE
) != 0
498 && (sec
->flags
& SEC_ALLOC
) != 0);
501 /* Does whatever the xtensa port does. */
503 pru_validate_fix_sub (fixS
*fix
)
505 segT add_symbol_segment
, sub_symbol_segment
;
507 /* The difference of two symbols should be resolved by the assembler when
508 linkrelax is not set. If the linker may relax the section containing
509 the symbols, then an Xtensa DIFF relocation must be generated so that
510 the linker knows to adjust the difference value. */
511 if (!linkrelax
|| fix
->fx_addsy
== NULL
)
514 /* Make sure both symbols are in the same segment, and that segment is
515 "normal" and relaxable. If the segment is not "normal", then the
516 fix is not valid. If the segment is not "relaxable", then the fix
517 should have been handled earlier. */
518 add_symbol_segment
= S_GET_SEGMENT (fix
->fx_addsy
);
519 if (! SEG_NORMAL (add_symbol_segment
)
520 || ! relaxable_section (add_symbol_segment
))
523 sub_symbol_segment
= S_GET_SEGMENT (fix
->fx_subsy
);
524 return (sub_symbol_segment
== add_symbol_segment
);
527 /* TC_FORCE_RELOCATION hook. */
529 /* If linkrelax is turned on, and the symbol to relocate
530 against is in a relaxable segment, don't compute the value -
531 generate a relocation instead. */
533 pru_force_relocation (fixS
*fix
)
535 if (linkrelax
&& fix
->fx_addsy
536 && relaxable_section (S_GET_SEGMENT (fix
->fx_addsy
)))
539 return generic_force_reloc (fix
);
544 /** Fixups and overflow checking. */
546 /* Check a fixup for overflow. */
547 static bfd_reloc_status_type
548 pru_check_overflow (valueT fixup
, reloc_howto_type
*howto
)
550 bfd_reloc_status_type ret
;
552 ret
= bfd_check_overflow (howto
->complain_on_overflow
,
555 bfd_get_reloc_size (howto
) * 8,
561 /* Emit diagnostic for fixup overflow. */
563 pru_diagnose_overflow (valueT fixup
, reloc_howto_type
*howto
,
564 fixS
*fixP
, valueT value
)
566 if (fixP
->fx_r_type
== BFD_RELOC_8
567 || fixP
->fx_r_type
== BFD_RELOC_16
568 || fixP
->fx_r_type
== BFD_RELOC_32
)
569 /* These relocs are against data, not instructions. */
570 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
571 _("immediate value 0x%x truncated to 0x%x"),
572 (unsigned int) fixup
,
573 (unsigned int) (~(~(valueT
) 0 << howto
->bitsize
) & fixup
));
576 /* What opcode is the instruction? This will determine
577 whether we check for overflow in immediate values
578 and what error message we get. */
579 const struct pru_opcode
*opcode
;
580 enum overflow_type overflow_msg_type
;
581 unsigned int range_min
;
582 unsigned int range_max
;
583 unsigned int address
;
584 gas_assert (fixP
->fx_size
== 4);
585 opcode
= pru_find_opcode (value
);
587 overflow_msg_type
= opcode
->overflow_msg
;
588 switch (overflow_msg_type
)
590 case call_target_overflow
:
592 = ((fixP
->fx_frag
->fr_address
+ fixP
->fx_where
) & 0xf0000000);
593 range_max
= range_min
+ 0x0fffffff;
594 address
= fixup
| range_min
;
596 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
597 _("call target address 0x%08x out of range 0x%08x to 0x%08x"),
598 address
, range_min
, range_max
);
600 case qbranch_target_overflow
:
601 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
602 _("quick branch offset %d out of range %d to %d"),
603 (int)fixup
, -((1<<9) * 4), (1 << 9) * 4);
605 case address_offset_overflow
:
606 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
607 _("%s offset %d out of range %d to %d"),
608 opcode
->name
, (int)fixup
, -32768, 32767);
610 case signed_immed16_overflow
:
611 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
612 _("immediate value %d out of range %d to %d"),
613 (int)fixup
, -32768, 32767);
615 case unsigned_immed32_overflow
:
616 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
617 _("immediate value %llu out of range %u to %lu"),
618 (unsigned long long)fixup
, 0, 0xfffffffflu
);
620 case unsigned_immed16_overflow
:
621 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
622 _("immediate value %u out of range %u to %u"),
623 (unsigned int)fixup
, 0, 65535);
625 case unsigned_immed5_overflow
:
626 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
627 _("immediate value %u out of range %u to %u"),
628 (unsigned int)fixup
, 0, 31);
631 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
632 _("overflow in immediate argument"));
638 /* Apply a fixup to the object file. */
640 md_apply_fix (fixS
*fixP
, valueT
*valP
, segT seg ATTRIBUTE_UNUSED
)
642 unsigned char *where
;
643 valueT value
= *valP
;
646 /* Assert that the fixup is one we can handle. */
647 gas_assert (fixP
!= NULL
&& valP
!= NULL
648 && (fixP
->fx_r_type
== BFD_RELOC_8
649 || fixP
->fx_r_type
== BFD_RELOC_16
650 || fixP
->fx_r_type
== BFD_RELOC_32
651 || fixP
->fx_r_type
== BFD_RELOC_64
652 || fixP
->fx_r_type
== BFD_RELOC_PRU_LDI32
653 || fixP
->fx_r_type
== BFD_RELOC_PRU_U16
654 || fixP
->fx_r_type
== BFD_RELOC_PRU_U16_PMEMIMM
655 || fixP
->fx_r_type
== BFD_RELOC_PRU_S10_PCREL
656 || fixP
->fx_r_type
== BFD_RELOC_PRU_U8_PCREL
657 || fixP
->fx_r_type
== BFD_RELOC_PRU_32_PMEM
658 || fixP
->fx_r_type
== BFD_RELOC_PRU_16_PMEM
659 /* Add other relocs here as we generate them. */
662 if (fixP
->fx_r_type
== BFD_RELOC_64
)
664 /* We may reach here due to .8byte directives, but we never output
665 BFD_RELOC_64; it must be resolved. */
666 if (fixP
->fx_addsy
!= NULL
)
667 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
668 _("cannot create 64-bit relocation"));
671 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
678 /* gas_assert (had_errors () || !fixP->fx_subsy); */
680 /* In general, fix instructions with immediate
681 constants. But leave LDI32 for the linker,
682 which is prepared to shorten insns. */
683 if (fixP
->fx_addsy
== (symbolS
*) NULL
684 && fixP
->fx_r_type
!= BFD_RELOC_PRU_LDI32
)
687 else if (fixP
->fx_pcrel
)
689 segT s
= S_GET_SEGMENT (fixP
->fx_addsy
);
691 if (s
== seg
|| s
== absolute_section
)
693 /* Blindly copied from AVR, but I don't understand why
694 this is needed in the first place. Fail hard to catch
695 when this curious code snippet is utilized. */
696 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
697 _("unexpected PC relative expression"));
698 value
+= S_GET_VALUE (fixP
->fx_addsy
);
702 else if (linkrelax
&& fixP
->fx_subsy
)
704 /* For a subtraction relocation expression, generate one
705 of the DIFF relocs, with the value being the difference.
706 Note that a sym1 - sym2 expression is adjusted into a
707 section_start_sym + sym4_offset_from_section_start - sym1
708 expression. fixP->fx_addsy holds the section start symbol,
709 fixP->fx_offset holds sym2's offset, and fixP->fx_subsy
710 holds sym1. Calculate the current difference and write value,
711 but leave fx_offset as is - during relaxation,
712 fx_offset - value gives sym1's value. */
714 offsetT diffval
; /* valueT is unsigned, so use offsetT. */
716 diffval
= S_GET_VALUE (fixP
->fx_addsy
)
717 + fixP
->fx_offset
- S_GET_VALUE (fixP
->fx_subsy
);
719 switch (fixP
->fx_r_type
)
722 fixP
->fx_r_type
= BFD_RELOC_PRU_GNU_DIFF8
;
725 fixP
->fx_r_type
= BFD_RELOC_PRU_GNU_DIFF16
;
728 fixP
->fx_r_type
= BFD_RELOC_PRU_GNU_DIFF32
;
730 case BFD_RELOC_PRU_16_PMEM
:
731 fixP
->fx_r_type
= BFD_RELOC_PRU_GNU_DIFF16_PMEM
;
733 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
734 _("residual low bits in pmem diff relocation"));
737 case BFD_RELOC_PRU_32_PMEM
:
738 fixP
->fx_r_type
= BFD_RELOC_PRU_GNU_DIFF32_PMEM
;
740 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
741 _("residual low bits in pmem diff relocation"));
745 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
746 _("expression too complex"));
750 value
= *valP
= diffval
;
752 fixP
->fx_subsy
= NULL
;
754 /* We don't actually support subtracting a symbol. */
755 if (fixP
->fx_subsy
!= (symbolS
*) NULL
)
756 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("expression too complex"));
758 /* For the DIFF relocs, write the value into the object file while still
759 keeping fx_done FALSE, as both the difference (recorded in the object file)
760 and the sym offset (part of fixP) are needed at link relax time. */
761 where
= (unsigned char *) fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
762 switch (fixP
->fx_r_type
)
764 case BFD_RELOC_PRU_GNU_DIFF8
:
767 case BFD_RELOC_PRU_GNU_DIFF16
:
768 case BFD_RELOC_PRU_GNU_DIFF16_PMEM
:
769 bfd_putl16 ((bfd_vma
) value
, where
);
771 case BFD_RELOC_PRU_GNU_DIFF32
:
772 case BFD_RELOC_PRU_GNU_DIFF32_PMEM
:
773 bfd_putl32 ((bfd_vma
) value
, where
);
780 /* Fully resolved fixup. */
782 reloc_howto_type
*howto
783 = bfd_reloc_type_lookup (stdoutput
, fixP
->fx_r_type
);
786 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
787 _("relocation is not supported"));
790 valueT fixup
= value
;
794 /* Get the instruction or data to be fixed up. */
795 buf
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
796 insn
= md_chars_to_number (buf
, fixP
->fx_size
);
798 /* Check for overflow, emitting a diagnostic if necessary. */
799 if (pru_check_overflow (fixup
, howto
) != bfd_reloc_ok
)
800 pru_diagnose_overflow (fixup
, howto
, fixP
, insn
);
802 /* Apply the right shift. */
803 fixup
= ((offsetT
)fixup
) >> howto
->rightshift
;
805 /* Truncate the fixup to right size. */
806 n
= sizeof (fixup
) * 8 - howto
->bitsize
;
807 fixup
= (fixup
<< n
) >> n
;
809 /* Fix up the instruction. Non-contiguous bitfields need
811 if (fixP
->fx_r_type
== BFD_RELOC_PRU_LDI32
)
813 /* As the only 64-bit "insn", LDI32 needs special handling. */
814 uint32_t insn1
= insn
& 0xffffffff;
815 uint32_t insn2
= insn
>> 32;
816 SET_INSN_FIELD (IMM16
, insn1
, fixup
& 0xffff);
817 SET_INSN_FIELD (IMM16
, insn2
, fixup
>> 16);
819 md_number_to_chars (buf
, insn1
, 4);
820 md_number_to_chars (buf
+ 4, insn2
, 4);
824 if (fixP
->fx_r_type
== BFD_RELOC_PRU_S10_PCREL
)
825 SET_BROFF_URAW (insn
, fixup
);
827 insn
= (insn
& ~howto
->dst_mask
) | (fixup
<< howto
->bitpos
);
828 md_number_to_chars (buf
, insn
, fixP
->fx_size
);
835 if (fixP
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
)
839 && !S_IS_DEFINED (fixP
->fx_addsy
) && !S_IS_WEAK (fixP
->fx_addsy
))
840 S_SET_WEAK (fixP
->fx_addsy
);
842 else if (fixP
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
848 /** Instruction parsing support. */
850 /* Creates a new pru_insn_relocS and returns a pointer to it. */
851 static pru_insn_relocS
*
852 pru_insn_reloc_new (bfd_reloc_code_real_type reloc_type
, unsigned int pcrel
)
854 pru_insn_relocS
*retval
;
855 retval
= XNEW (pru_insn_relocS
);
858 as_bad (_("can't create relocation"));
862 /* Fill out the fields with default values. */
863 retval
->reloc_next
= NULL
;
864 retval
->reloc_type
= reloc_type
;
865 retval
->reloc_pcrel
= pcrel
;
869 /* Frees up memory previously allocated by pru_insn_reloc_new (). */
871 pru_insn_reloc_destroy (pru_insn_relocS
*reloc
)
873 pru_insn_relocS
*next
;
877 next
= reloc
->reloc_next
;
883 /* The various pru_assemble_* functions call this
884 function to generate an expression from a string representing an expression.
885 It then tries to evaluate the expression, and if it can, returns its value.
886 If not, it creates a new pru_insn_relocS and stores the expression and
887 reloc_type for future use. */
889 pru_assemble_expression (const char *exprstr
,
890 pru_insn_infoS
*insn
,
891 pru_insn_relocS
*prev_reloc
,
892 bfd_reloc_code_real_type reloc_type
,
896 pru_insn_relocS
*reloc
;
897 char *saved_line_ptr
;
898 unsigned short value
;
900 gas_assert (exprstr
!= NULL
);
901 gas_assert (insn
!= NULL
);
903 /* We use this blank keyword to distinguish register from
905 if (strstr (exprstr
, "%label") != NULL
)
907 exprstr
+= strlen ("%label") + 1;
910 /* Check for pmem relocation operator.
911 Change the relocation type and advance the ptr to the start of
912 the expression proper. */
913 if (strstr (exprstr
, "%pmem") != NULL
)
915 reloc_type
= BFD_RELOC_PRU_U16_PMEMIMM
;
916 exprstr
+= strlen ("%pmem") + 1;
919 /* We potentially have a relocation. */
920 reloc
= pru_insn_reloc_new (reloc_type
, pcrel
);
921 if (prev_reloc
!= NULL
)
922 prev_reloc
->reloc_next
= reloc
;
924 insn
->insn_reloc
= reloc
;
926 /* Parse the expression string. */
927 ep
= &reloc
->reloc_expression
;
928 saved_line_ptr
= input_line_pointer
;
929 input_line_pointer
= (char *) exprstr
;
933 if (*input_line_pointer
)
934 as_bad (_("trailing garbage after expression: %s"), input_line_pointer
);
935 input_line_pointer
= saved_line_ptr
;
938 if (ep
->X_op
== O_illegal
|| ep
->X_op
== O_absent
)
939 as_bad (_("expected expression, got %s"), exprstr
);
941 /* This is redundant as the fixup will put this into
942 the instruction, but it is included here so that
943 self-test mode (-r) works. */
945 if (pru_mode
== PRU_MODE_TEST
&& ep
->X_op
== O_constant
)
946 value
= ep
->X_add_number
;
948 return (unsigned long) value
;
951 /* Try to parse a non-relocatable expression. */
953 pru_assemble_noreloc_expression (const char *exprstr
)
956 char *saved_line_ptr
;
959 gas_assert (exprstr
!= NULL
);
961 saved_line_ptr
= input_line_pointer
;
962 input_line_pointer
= (char *) exprstr
;
966 if (*input_line_pointer
)
967 as_bad (_("trailing garbage after expression: %s"), input_line_pointer
);
968 input_line_pointer
= saved_line_ptr
;
971 if (exp
.X_op
!= O_constant
)
972 as_bad (_("expected constant expression, got %s"), exprstr
);
974 val
= exp
.X_add_number
;
979 /* Argument assemble functions.
980 All take an instruction argument string, and a pointer
981 to an instruction opcode. Upon return the insn_opcode
982 has the relevant fields filled in to represent the arg
983 string. The return value is NULL if successful, or
984 an error message if an error was detected. */
987 pru_assemble_arg_d (pru_insn_infoS
*insn_info
, const char *argstr
)
989 struct pru_reg
*dst
= pru_reg_lookup (argstr
);
992 as_bad (_("unknown register %s"), argstr
);
995 SET_INSN_FIELD (RD
, insn_info
->insn_code
, dst
->index
);
996 SET_INSN_FIELD (RDSEL
, insn_info
->insn_code
, dst
->regsel
);
1001 pru_assemble_arg_D (pru_insn_infoS
*insn_info
, const char *argstr
)
1003 struct pru_reg
*dst
;
1005 /* The leading & before an address register is optional. */
1009 dst
= pru_reg_lookup (argstr
);
1012 as_bad (_("unknown register %s"), argstr
);
1015 unsigned long rxb
= 0;
1017 switch (dst
->regsel
)
1019 case RSEL_31_0
: rxb
= 0; break; /* whole register defaults to .b0 */
1020 case RSEL_7_0
: rxb
= 0; break;
1021 case RSEL_15_8
: rxb
= 1; break;
1022 case RSEL_23_16
: rxb
= 2; break;
1023 case RSEL_31_24
: rxb
= 3; break;
1025 as_bad (_("data transfer register cannot be halfword"));
1028 SET_INSN_FIELD (RD
, insn_info
->insn_code
, dst
->index
);
1029 SET_INSN_FIELD (RDB
, insn_info
->insn_code
, rxb
);
1034 pru_assemble_arg_R (pru_insn_infoS
*insn_info
, const char *argstr
)
1036 struct pru_reg
*dst
= pru_reg_lookup (argstr
);
1039 as_bad (_("unknown register %s"), argstr
);
1042 if (dst
->regsel
!= RSEL_31_0
)
1044 as_bad (_("destination register must be full-word"));
1047 SET_INSN_FIELD (RD
, insn_info
->insn_code
, dst
->index
);
1048 SET_INSN_FIELD (RDSEL
, insn_info
->insn_code
, dst
->regsel
);
1053 pru_assemble_arg_s (pru_insn_infoS
*insn_info
, const char *argstr
)
1055 struct pru_reg
*src1
= pru_reg_lookup (argstr
);
1058 as_bad (_("unknown register %s"), argstr
);
1061 SET_INSN_FIELD (RS1
, insn_info
->insn_code
, src1
->index
);
1062 SET_INSN_FIELD (RS1SEL
, insn_info
->insn_code
, src1
->regsel
);
1067 pru_assemble_arg_S (pru_insn_infoS
*insn_info
, const char *argstr
)
1069 struct pru_reg
*src1
= pru_reg_lookup (argstr
);
1072 as_bad (_("unknown register %s"), argstr
);
1075 if (src1
->regsel
!= RSEL_31_0
)
1076 as_bad (_("cannot use partial register %s for addressing"), argstr
);
1077 SET_INSN_FIELD (RS1
, insn_info
->insn_code
, src1
->index
);
1082 pru_assemble_arg_b (pru_insn_infoS
*insn_info
, const char *argstr
)
1084 struct pru_reg
*src2
= pru_reg_lookup (argstr
);
1087 unsigned long imm8
= pru_assemble_noreloc_expression (argstr
);
1088 SET_INSN_FIELD (IMM8
, insn_info
->insn_code
, imm8
);
1089 SET_INSN_FIELD (IO
, insn_info
->insn_code
, 1);
1093 SET_INSN_FIELD (IO
, insn_info
->insn_code
, 0);
1094 SET_INSN_FIELD (RS2
, insn_info
->insn_code
, src2
->index
);
1095 SET_INSN_FIELD (RS2SEL
, insn_info
->insn_code
, src2
->regsel
);
1101 pru_assemble_arg_B (pru_insn_infoS
*insn_info
, const char *argstr
)
1103 struct pru_reg
*src2
= pru_reg_lookup (argstr
);
1107 imm8
= pru_assemble_noreloc_expression (argstr
);
1108 if (!imm8
|| imm8
> 0xff)
1109 as_bad (_("loop count constant %ld is out of range [1..%d]"),
1111 /* Note: HW expects the immediate loop count field
1112 to be one less than the actual loop count. */
1113 SET_INSN_FIELD (IMM8
, insn_info
->insn_code
, imm8
- 1);
1114 SET_INSN_FIELD (IO
, insn_info
->insn_code
, 1);
1118 SET_INSN_FIELD (IO
, insn_info
->insn_code
, 0);
1119 SET_INSN_FIELD (RS2
, insn_info
->insn_code
, src2
->index
);
1120 SET_INSN_FIELD (RS2SEL
, insn_info
->insn_code
, src2
->regsel
);
1125 pru_assemble_arg_i (pru_insn_infoS
*insn_info
, const char *argstr
)
1127 unsigned long imm32
;
1129 /* We must not generate PRU_LDI32 relocation if relaxation is disabled in
1130 GAS. Consider the following scenario: GAS relaxation is disabled, so
1131 DIFF* expressions are fixed and not emitted as relocations. Then if LD
1132 has relaxation enabled, it may shorten LDI32 but will not update
1133 accordingly the DIFF expressions. */
1134 if (pru_opt
.link_relax
)
1135 imm32
= pru_assemble_expression (argstr
, insn_info
,
1136 insn_info
->insn_reloc
,
1137 BFD_RELOC_PRU_LDI32
, 0);
1139 imm32
= pru_assemble_noreloc_expression (argstr
);
1141 /* QUIRK: LDI must clear IO bit high, even though it has immediate arg. */
1142 SET_INSN_FIELD (IO
, insn_info
->insn_code
, 0);
1143 SET_INSN_FIELD (IMM16
, insn_info
->insn_code
, imm32
& 0xffff);
1144 insn_info
->ldi32_imm32
= imm32
;
1148 pru_assemble_arg_j (pru_insn_infoS
*insn_info
, const char *argstr
)
1150 struct pru_reg
*src2
= pru_reg_lookup (argstr
);
1154 unsigned long imm16
= pru_assemble_expression (argstr
, insn_info
,
1155 insn_info
->insn_reloc
,
1156 BFD_RELOC_PRU_U16_PMEMIMM
,
1158 SET_INSN_FIELD (IMM16
, insn_info
->insn_code
, imm16
);
1159 SET_INSN_FIELD (IO
, insn_info
->insn_code
, 1);
1163 SET_INSN_FIELD (IO
, insn_info
->insn_code
, 0);
1164 SET_INSN_FIELD (RS2
, insn_info
->insn_code
, src2
->index
);
1165 SET_INSN_FIELD (RS2SEL
, insn_info
->insn_code
, src2
->regsel
);
1170 pru_assemble_arg_W (pru_insn_infoS
*insn_info
, const char *argstr
)
1172 unsigned long imm16
= pru_assemble_expression (argstr
, insn_info
,
1173 insn_info
->insn_reloc
,
1174 BFD_RELOC_PRU_U16
, 0);
1175 /* QUIRK: LDI must clear IO bit high, even though it has immediate arg. */
1176 SET_INSN_FIELD (IO
, insn_info
->insn_code
, 0);
1177 SET_INSN_FIELD (IMM16
, insn_info
->insn_code
, imm16
);
1181 pru_assemble_arg_o (pru_insn_infoS
*insn_info
, const char *argstr
)
1183 unsigned long imm10
= pru_assemble_expression (argstr
, insn_info
,
1184 insn_info
->insn_reloc
,
1185 BFD_RELOC_PRU_S10_PCREL
, 1);
1186 SET_BROFF_URAW (insn_info
->insn_code
, imm10
);
1190 pru_assemble_arg_O (pru_insn_infoS
*insn_info
, const char *argstr
)
1192 unsigned long imm8
= pru_assemble_expression (argstr
, insn_info
,
1193 insn_info
->insn_reloc
,
1194 BFD_RELOC_PRU_U8_PCREL
, 1);
1195 SET_INSN_FIELD (LOOP_JMPOFFS
, insn_info
->insn_code
, imm8
);
1199 pru_assemble_arg_l (pru_insn_infoS
*insn_info
, const char *argstr
)
1201 unsigned long burstlen
= 0;
1202 struct pru_reg
*blreg
= pru_reg_lookup (argstr
);
1206 burstlen
= pru_assemble_noreloc_expression (argstr
);
1207 if (!burstlen
|| burstlen
> LSSBBO_BYTECOUNT_R0_BITS7_0
)
1208 as_bad (_("byte count constant %ld is out of range [1..%d]"),
1209 burstlen
, LSSBBO_BYTECOUNT_R0_BITS7_0
);
1214 if (blreg
->index
!= 0)
1215 as_bad (_("only r0 can be used as byte count register"));
1216 else if (blreg
->regsel
> RSEL_31_24
)
1217 as_bad (_("only r0.bX byte fields of r0 can be used as byte count"));
1219 burstlen
= LSSBBO_BYTECOUNT_R0_BITS7_0
+ blreg
->regsel
;
1221 SET_BURSTLEN (insn_info
->insn_code
, burstlen
);
1225 pru_assemble_arg_n (pru_insn_infoS
*insn_info
, const char *argstr
)
1227 unsigned long burstlen
= 0;
1228 struct pru_reg
*blreg
= pru_reg_lookup (argstr
);
1232 burstlen
= pru_assemble_noreloc_expression (argstr
);
1233 if (!burstlen
|| burstlen
> LSSBBO_BYTECOUNT_R0_BITS7_0
)
1234 as_bad (_("byte count constant %ld is out of range [1..%d]"),
1235 burstlen
, LSSBBO_BYTECOUNT_R0_BITS7_0
);
1240 if (blreg
->index
!= 0)
1241 as_bad (_("only r0 can be used as byte count register"));
1242 else if (blreg
->regsel
> RSEL_31_24
)
1243 as_bad (_("only r0.bX byte fields of r0 can be used as byte count"));
1245 burstlen
= LSSBBO_BYTECOUNT_R0_BITS7_0
+ blreg
->regsel
;
1247 SET_INSN_FIELD (XFR_LENGTH
, insn_info
->insn_code
, burstlen
);
1251 pru_assemble_arg_c (pru_insn_infoS
*insn_info
, const char *argstr
)
1253 unsigned long cb
= pru_assemble_noreloc_expression (argstr
);
1256 as_bad (_("invalid constant table offset %ld"), cb
);
1258 SET_INSN_FIELD (CB
, insn_info
->insn_code
, cb
);
1262 pru_assemble_arg_w (pru_insn_infoS
*insn_info
, const char *argstr
)
1264 unsigned long wk
= pru_assemble_noreloc_expression (argstr
);
1266 if (wk
!= 0 && wk
!= 1)
1267 as_bad (_("invalid WakeOnStatus %ld"), wk
);
1269 SET_INSN_FIELD (WAKEONSTATUS
, insn_info
->insn_code
, wk
);
1273 pru_assemble_arg_x (pru_insn_infoS
*insn_info
, const char *argstr
)
1275 unsigned long wba
= pru_assemble_noreloc_expression (argstr
);
1278 as_bad (_("invalid XFR WideBus Address %ld"), wba
);
1280 SET_INSN_FIELD (XFR_WBA
, insn_info
->insn_code
, wba
);
1283 /* The function consume_arg takes a pointer into a string
1284 of instruction tokens (args) and a pointer into a string
1285 representing the expected sequence of tokens and separators.
1286 It checks whether the first argument in argstr is of the
1287 expected type, throwing an error if it is not, and returns
1288 the pointer argstr. */
1290 pru_consume_arg (char *argstr
, const char *parsestr
)
1299 if (strprefix (argstr
, "%pmem") || strprefix (argstr
, "%label"))
1301 /* We zap the parentheses because we don't want them confused
1303 temp
= strchr (argstr
, '(');
1306 temp
= strchr (argstr
, ')');
1311 as_bad (_("badly formed expression near %s"), argstr
);
1320 /* Only 'j' really requires %label for distinguishing registers
1321 from labels, but we include 'o' and 'O' here to avoid
1322 confusing assembler programmers. Thus for completeness all
1323 jump operands can be prefixed with %label. */
1324 if (strprefix (argstr
, "%label"))
1326 /* We zap the parentheses because we don't want them confused
1328 temp
= strchr (argstr
, '(');
1331 temp
= strchr (argstr
, ')');
1336 as_bad (_("badly formed expression near %s"), argstr
);
1354 /* We can't have %pmem here. */
1356 as_bad (_("badly formed expression near %s"), argstr
);
1359 BAD_CASE (*parsestr
);
1366 /* The function consume_separator takes a pointer into a string
1367 of instruction tokens (args) and a pointer into a string representing
1368 the expected sequence of tokens and separators. It finds the first
1369 instance of the character pointed to by separator in argstr, and
1370 returns a pointer to the next element of argstr, which is the
1371 following token in the sequence. */
1373 pru_consume_separator (char *argstr
, const char *separator
)
1377 p
= strchr (argstr
, *separator
);
1382 as_bad (_("expecting %c near %s"), *separator
, argstr
);
1387 /* The principal argument parsing function which takes a string argstr
1388 representing the instruction arguments for insn, and extracts the argument
1389 tokens matching parsestr into parsed_args. */
1391 pru_parse_args (pru_insn_infoS
*insn ATTRIBUTE_UNUSED
, char *argstr
,
1392 const char *parsestr
, char **parsed_args
)
1399 bfd_boolean terminate
= FALSE
;
1401 /* This rest of this function is it too fragile and it mostly works,
1402 therefore special case this one. */
1403 if (*parsestr
== 0 && argstr
!= 0)
1405 as_bad (_("too many arguments"));
1406 parsed_args
[0] = NULL
;
1410 while (p
!= NULL
&& !terminate
&& i
< PRU_MAX_INSN_TOKENS
)
1412 parsed_args
[i
] = pru_consume_arg (p
, parsestr
);
1414 if (*parsestr
!= '\0')
1416 p
= pru_consume_separator (p
, parsestr
);
1421 /* Check that the argument string has no trailing arguments. */
1422 /* If we've got a %pmem relocation, we've zapped the parens with
1424 if (strprefix (p
, "%pmem") || strprefix (p
, "%label"))
1425 end
= strpbrk (p
, ",");
1427 end
= strpbrk (p
, " ,");
1430 as_bad (_("too many arguments"));
1433 if (*parsestr
== '\0' || (p
!= NULL
&& *p
== '\0'))
1438 parsed_args
[i
] = NULL
;
1440 /* There are no instructions with optional arguments; complain. */
1441 if (*parsestr
!= '\0')
1442 as_bad (_("missing argument"));
1446 /** Assembler output support. */
1448 /* Output a normal instruction. */
1450 output_insn (pru_insn_infoS
*insn
)
1453 pru_insn_relocS
*reloc
;
1456 /* This allocates enough space for the instruction
1457 and puts it in the current frag. */
1458 md_number_to_chars (f
, insn
->insn_code
, 4);
1459 /* Emit debug info. */
1460 dwarf2_emit_insn (4);
1461 /* Create any fixups to be acted on later. */
1462 for (reloc
= insn
->insn_reloc
; reloc
!= NULL
; reloc
= reloc
->reloc_next
)
1463 fix_new_exp (frag_now
, f
- frag_now
->fr_literal
, 4,
1464 &reloc
->reloc_expression
, reloc
->reloc_pcrel
,
1468 /* Output two LDI instructions from LDI32 macro */
1470 output_insn_ldi32 (pru_insn_infoS
*insn
)
1473 pru_insn_relocS
*reloc
;
1474 unsigned long insn2
;
1477 md_number_to_chars (f
, insn
->insn_code
, 4);
1479 insn2
= insn
->insn_code
;
1480 SET_INSN_FIELD (IMM16
, insn2
, insn
->ldi32_imm32
>> 16);
1481 SET_INSN_FIELD (RDSEL
, insn2
, RSEL_31_16
);
1482 md_number_to_chars (f
+ 4, insn2
, 4);
1484 /* Emit debug info. */
1485 dwarf2_emit_insn (8);
1487 /* Create any fixups to be acted on later. */
1488 for (reloc
= insn
->insn_reloc
; reloc
!= NULL
; reloc
= reloc
->reloc_next
)
1489 fix_new_exp (frag_now
, f
- frag_now
->fr_literal
, 4,
1490 &reloc
->reloc_expression
, reloc
->reloc_pcrel
,
1495 /** External interfaces. */
1497 /* The following functions are called by machine-independent parts of
1500 md_parse_option (int c
, const char *arg ATTRIBUTE_UNUSED
)
1505 /* Hidden option for self-test mode. */
1506 pru_mode
= PRU_MODE_TEST
;
1508 case OPTION_LINK_RELAX
:
1509 pru_opt
.link_relax
= TRUE
;
1511 case OPTION_NO_LINK_RELAX
:
1512 pru_opt
.link_relax
= FALSE
;
1514 case OPTION_NO_WARN_REGNAME_LABEL
:
1515 pru_opt
.warn_regname_label
= FALSE
;
1526 pru_target_format (void)
1531 /* Machine-dependent usage message. */
1533 md_show_usage (FILE *stream
)
1537 " -mlink-relax generate relocations for linker relaxation (default).\n"
1538 " -mno-link-relax don't generate relocations for linker relaxation.\n"
1543 /* This function is called once, at assembler startup time.
1544 It should set up all the tables, etc. that the MD part of the
1545 assembler will need. */
1550 const char *inserted
;
1552 /* Create and fill a hashtable for the PRU opcodes, registers and
1554 pru_opcode_hash
= hash_new ();
1555 pru_reg_hash
= hash_new ();
1557 for (i
= 0; i
< NUMOPCODES
; ++i
)
1560 = hash_insert (pru_opcode_hash
, pru_opcodes
[i
].name
,
1561 (PTR
) & pru_opcodes
[i
]);
1562 if (inserted
!= NULL
)
1564 fprintf (stderr
, _("internal error: can't hash `%s': %s\n"),
1565 pru_opcodes
[i
].name
, inserted
);
1566 /* Probably a memory allocation problem? Give up now. */
1567 as_fatal (_("Broken assembler. No assembly attempted."));
1571 for (i
= 0; i
< pru_num_regs
; ++i
)
1574 = hash_insert (pru_reg_hash
, pru_regs
[i
].name
,
1575 (PTR
) & pru_regs
[i
]);
1576 if (inserted
!= NULL
)
1578 fprintf (stderr
, _("internal error: can't hash `%s': %s\n"),
1579 pru_regs
[i
].name
, inserted
);
1580 /* Probably a memory allocation problem? Give up now. */
1581 as_fatal (_("Broken assembler. No assembly attempted."));
1586 linkrelax
= pru_opt
.link_relax
;
1587 /* Initialize the alignment data. */
1588 pru_current_align_seg
= now_seg
;
1589 pru_last_label
= NULL
;
1590 pru_current_align
= 0;
1594 /* Assembles a single line of PRU assembly language. */
1596 md_assemble (char *op_str
)
1599 char *op_strdup
= NULL
;
1600 pru_insn_infoS thisinsn
;
1601 pru_insn_infoS
*insn
= &thisinsn
;
1603 /* Make sure we are aligned on a 4-byte boundary. */
1604 if (pru_current_align
< 2)
1605 pru_align (2, NULL
, pru_last_label
);
1606 else if (pru_current_align
> 2)
1607 pru_current_align
= 2;
1608 pru_last_label
= NULL
;
1610 /* We don't want to clobber to op_str
1611 because we want to be able to use it in messages. */
1612 op_strdup
= strdup (op_str
);
1613 insn
->insn_tokens
[0] = strtok (op_strdup
, " ");
1614 argstr
= strtok (NULL
, "");
1616 /* Assemble the opcode. */
1617 insn
->insn_pru_opcode
= pru_opcode_lookup (insn
->insn_tokens
[0]);
1618 insn
->insn_reloc
= NULL
;
1620 if (insn
->insn_pru_opcode
!= NULL
)
1622 const char *argsfmt
= insn
->insn_pru_opcode
->args
;
1623 const char **argtk
= &insn
->insn_tokens
[1];
1626 /* Set the opcode for the instruction. */
1627 insn
->insn_code
= insn
->insn_pru_opcode
->match
;
1629 if (pru_mode
== PRU_MODE_TEST
)
1631 /* Add the "expected" instruction parameter used for validation. */
1632 argsfmt
= malloc (strlen (argsfmt
) + 3);
1633 sprintf ((char *)argsfmt
, "%s,E", insn
->insn_pru_opcode
->args
);
1635 pru_parse_args (insn
, argstr
, argsfmt
,
1636 (char **) &insn
->insn_tokens
[1]);
1638 for (argp
= argsfmt
; !had_errors () && *argp
&& *argtk
; ++argp
)
1640 gas_assert (argtk
<= &insn
->insn_tokens
[PRU_MAX_INSN_TOKENS
]);
1648 pru_assemble_arg_d (insn
, *argtk
++);
1651 pru_assemble_arg_D (insn
, *argtk
++);
1654 pru_assemble_arg_R (insn
, *argtk
++);
1657 pru_assemble_arg_s (insn
, *argtk
++);
1660 pru_assemble_arg_S (insn
, *argtk
++);
1663 pru_assemble_arg_b (insn
, *argtk
++);
1666 pru_assemble_arg_B (insn
, *argtk
++);
1669 pru_assemble_arg_i (insn
, *argtk
++);
1672 pru_assemble_arg_j (insn
, *argtk
++);
1675 pru_assemble_arg_W (insn
, *argtk
++);
1678 pru_assemble_arg_o (insn
, *argtk
++);
1681 pru_assemble_arg_O (insn
, *argtk
++);
1684 pru_assemble_arg_l (insn
, *argtk
++);
1687 pru_assemble_arg_n (insn
, *argtk
++);
1690 pru_assemble_arg_c (insn
, *argtk
++);
1693 pru_assemble_arg_w (insn
, *argtk
++);
1696 pru_assemble_arg_x (insn
, *argtk
++);
1700 pru_check_assembly (insn
->insn_code
, *argtk
++);
1706 if (*argp
&& !had_errors ())
1707 as_bad (_("missing argument"));
1711 if (insn
->insn_pru_opcode
->pinfo
& PRU_INSN_LDI32
)
1713 output_insn_ldi32 (insn
);
1721 if (pru_mode
== PRU_MODE_TEST
)
1722 free ((char *)argsfmt
);
1725 /* Unrecognised instruction - error. */
1726 as_bad (_("unrecognised instruction %s"), insn
->insn_tokens
[0]);
1728 /* Don't leak memory. */
1729 pru_insn_reloc_destroy (insn
->insn_reloc
);
1733 /* Round up section size. */
1735 md_section_align (asection
*seg
, valueT addr
)
1737 int align
= bfd_get_section_alignment (stdoutput
, seg
);
1738 return ((addr
+ (1 << align
) - 1) & (-((valueT
) 1 << align
)));
1741 /* Implement tc_fix_adjustable. */
1743 pru_fix_adjustable (fixS
*fixp
)
1745 if (fixp
->fx_addsy
== NULL
)
1748 /* Prevent all adjustments to global symbols. */
1749 if (OUTPUT_FLAVOR
== bfd_target_elf_flavour
1750 && (S_IS_EXTERNAL (fixp
->fx_addsy
) || S_IS_WEAK (fixp
->fx_addsy
)))
1753 if (fixp
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
1754 || fixp
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
1757 /* Preserve relocations against symbols with function type. */
1758 if (symbol_get_bfdsym (fixp
->fx_addsy
)->flags
& BSF_FUNCTION
)
1764 /* The function tc_gen_reloc creates a relocation structure for the
1765 fixup fixp, and returns a pointer to it. This structure is passed
1766 to bfd_install_relocation so that it can be written to the object
1767 file for linking. */
1769 tc_gen_reloc (asection
*section ATTRIBUTE_UNUSED
, fixS
*fixp
)
1771 arelent
*reloc
= XNEW (arelent
);
1772 reloc
->sym_ptr_ptr
= XNEW (asymbol
*);
1773 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
1775 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
1776 reloc
->addend
= fixp
->fx_offset
; /* fixp->fx_addnumber; */
1778 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
1779 if (reloc
->howto
== NULL
)
1781 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
1782 _("can't represent relocation type %s"),
1783 bfd_get_reloc_code_name (fixp
->fx_r_type
));
1785 /* Set howto to a garbage value so that we can keep going. */
1786 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, BFD_RELOC_32
);
1787 gas_assert (reloc
->howto
!= NULL
);
1793 md_pcrel_from (fixS
*fixP ATTRIBUTE_UNUSED
)
1795 return fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
1798 /* Called just before the assembler exits. */
1802 hash_die (pru_opcode_hash
);
1803 hash_die (pru_reg_hash
);
1807 md_undefined_symbol (char *name ATTRIBUTE_UNUSED
)
1812 /* Implement tc_frob_label. */
1814 pru_frob_label (symbolS
*lab
)
1816 /* Emit dwarf information. */
1817 dwarf2_emit_label (lab
);
1819 /* Update the label's address with the current output pointer. */
1820 symbol_set_frag (lab
, frag_now
);
1821 S_SET_VALUE (lab
, (valueT
) frag_now_fix ());
1823 /* Record this label for future adjustment after we find out what
1824 kind of data it references, and the required alignment therewith. */
1825 pru_last_label
= lab
;
1827 if (pru_opt
.warn_regname_label
&& pru_reg_lookup (S_GET_NAME (lab
)))
1828 as_warn (_("Label \"%s\" matches a CPU register name"), S_GET_NAME (lab
));
1831 static inline char *
1832 skip_space (char *s
)
1834 while (*s
== ' ' || *s
== '\t')
1839 /* Parse special CONS expression: pmem (expression). Idea from AVR.
1841 Used to catch and mark code (program memory) in constant expression
1842 relocations. Return non-zero for program memory. */
1845 pru_parse_cons_expression (expressionS
*exp
, int nbytes
)
1847 int is_pmem
= FALSE
;
1850 tmp
= input_line_pointer
= skip_space (input_line_pointer
);
1852 if (nbytes
== 4 || nbytes
== 2)
1854 const char *pmem_str
= "%pmem";
1855 int len
= strlen (pmem_str
);
1857 if (strncasecmp (input_line_pointer
, pmem_str
, len
) == 0)
1859 input_line_pointer
= skip_space (input_line_pointer
+ len
);
1861 if (*input_line_pointer
== '(')
1863 input_line_pointer
= skip_space (input_line_pointer
+ 1);
1867 if (*input_line_pointer
== ')')
1868 ++input_line_pointer
;
1871 as_bad (_("`)' required"));
1878 input_line_pointer
= tmp
;
1887 /* Implement TC_CONS_FIX_NEW. */
1889 pru_cons_fix_new (fragS
*frag
, int where
, unsigned int nbytes
,
1890 expressionS
*exp
, const int is_pmem
)
1892 bfd_reloc_code_real_type r
;
1894 switch (nbytes
| (!!is_pmem
<< 8))
1896 case 1 | (0 << 8): r
= BFD_RELOC_8
; break;
1897 case 2 | (0 << 8): r
= BFD_RELOC_16
; break;
1898 case 4 | (0 << 8): r
= BFD_RELOC_32
; break;
1899 case 8 | (0 << 8): r
= BFD_RELOC_64
; break;
1900 case 2 | (1 << 8): r
= BFD_RELOC_PRU_16_PMEM
; break;
1901 case 4 | (1 << 8): r
= BFD_RELOC_PRU_32_PMEM
; break;
1903 as_bad (_("illegal %s relocation size: %d"),
1904 is_pmem
? "text" : "data", nbytes
);
1908 fix_new_exp (frag
, where
, (int) nbytes
, exp
, 0, r
);
1911 /* Implement tc_regname_to_dw2regnum, to convert REGNAME to a DWARF-2
1914 pru_regname_to_dw2regnum (char *regname
)
1916 struct pru_reg
*r
= pru_reg_lookup (regname
);
1922 /* Implement tc_cfi_frame_initial_instructions, to initialize the DWARF-2
1923 unwind information for this procedure. */
1925 pru_frame_initial_instructions (void)
1927 const unsigned fp_regno
= 4;
1928 cfi_add_CFA_def_cfa (fp_regno
, 0);
1932 pru_allow_local_subtract (expressionS
* left
,
1933 expressionS
* right
,
1936 /* If we are not in relaxation mode, subtraction is OK. */
1940 /* If the symbols are not in a code section then they are OK. */
1941 if ((section
->flags
& SEC_CODE
) == 0)
1944 if (left
->X_add_symbol
== right
->X_add_symbol
)
1947 /* We have to assume that there may be instructions between the
1948 two symbols and that relaxation may increase the distance between