2 Copyright (C) 2010-2014 Free Software Foundation, Inc.
3 Contributed by Joseph Myers <joseph@codesourcery.com>
4 Bernd Schmidt <bernds@codesourcery.com>
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 "dwarf2dbg.h"
25 #include "dw2gencfi.h"
26 #include "safe-ctype.h"
28 #include "opcode/tic6x.h"
29 #include "elf/tic6x.h"
30 #include "elf32-tic6x.h"
32 /* Truncate and sign-extend at 32 bits, so that building on a 64-bit
33 host gives identical results to a 32-bit host. */
34 #define TRUNC(X) ((valueT) (X) & 0xffffffffU)
35 #define SEXT(X) ((TRUNC (X) ^ 0x80000000U) - 0x80000000U)
37 #define streq(a, b) (strcmp (a, b) == 0)
39 /* Stuff for .scomm symbols. */
40 static segT sbss_section
;
41 static asection scom_section
;
42 static asymbol scom_symbol
;
44 const char comment_chars
[] = ";";
45 const char line_comment_chars
[] = "#*;";
46 const char line_separator_chars
[] = "@";
48 const char EXP_CHARS
[] = "eE";
49 const char FLT_CHARS
[] = "dDfF";
51 const char *md_shortopts
= "";
55 OPTION_MARCH
= OPTION_MD_BASE
,
57 OPTION_MLITTLE_ENDIAN
,
66 struct option md_longopts
[] =
68 { "march", required_argument
, NULL
, OPTION_MARCH
},
69 { "mbig-endian", no_argument
, NULL
, OPTION_MBIG_ENDIAN
},
70 { "mlittle-endian", no_argument
, NULL
, OPTION_MLITTLE_ENDIAN
},
71 { "mdsbt", no_argument
, NULL
, OPTION_MDSBT
},
72 { "mno-dsbt", no_argument
, NULL
, OPTION_MNO_DSBT
},
73 { "mpid", required_argument
, NULL
, OPTION_MPID
},
74 { "mpic", no_argument
, NULL
, OPTION_MPIC
},
75 { "mno-pic", no_argument
, NULL
, OPTION_MNO_PIC
},
76 { "mgenerate-rel", no_argument
, NULL
, OPTION_MGENERATE_REL
},
77 { NULL
, no_argument
, NULL
, 0 }
79 size_t md_longopts_size
= sizeof (md_longopts
);
81 /* The instructions enabled based only on the selected architecture
82 (all instructions, if no architecture specified). */
83 static unsigned short tic6x_arch_enable
= (TIC6X_INSN_C62X
90 /* The instructions enabled based on the current set of features
91 (architecture, as modified by other options). */
92 static unsigned short tic6x_features
;
94 /* The architecture attribute value, or C6XABI_Tag_ISA_none if
96 static int tic6x_arch_attribute
= C6XABI_Tag_ISA_none
;
98 /* Whether any instructions at all have been seen. Once any
99 instructions have been seen, architecture attributes merge into the
100 previous attribute value rather than replacing it. */
101 static bfd_boolean tic6x_seen_insns
= FALSE
;
103 /* The number of registers in each register file supported by the
104 current architecture. */
105 static unsigned int tic6x_num_registers
;
107 /* Whether predication on A0 is possible. */
108 static bfd_boolean tic6x_predicate_a0
;
110 /* Whether execute packets can cross fetch packet boundaries. */
111 static bfd_boolean tic6x_can_cross_fp_boundary
;
113 /* Whether there are constraints on simultaneous reads and writes of
115 static bfd_boolean tic6x_long_data_constraints
;
117 /* Whether compact instructions are available. */
118 static bfd_boolean tic6x_compact_insns
;
120 /* Whether to generate RELA relocations. */
121 static bfd_boolean tic6x_generate_rela
= TRUE
;
123 /* Whether the code uses DSBT addressing. */
124 static bfd_boolean tic6x_dsbt
;
126 /* Types of position-independent data (attribute values for
135 /* The type of data addressing used in this code. */
136 static tic6x_pid_type tic6x_pid
;
138 /* Whether the code uses position-independent code. */
139 static bfd_boolean tic6x_pic
;
141 /* Table of supported architecture variants. */
146 unsigned short features
;
148 static const tic6x_arch_table tic6x_arches
[] =
150 { "c62x", C6XABI_Tag_ISA_C62X
, TIC6X_INSN_C62X
},
151 { "c64x", C6XABI_Tag_ISA_C64X
, TIC6X_INSN_C62X
| TIC6X_INSN_C64X
},
152 { "c64x+", C6XABI_Tag_ISA_C64XP
, (TIC6X_INSN_C62X
154 | TIC6X_INSN_C64XP
) },
155 { "c67x", C6XABI_Tag_ISA_C67X
, TIC6X_INSN_C62X
| TIC6X_INSN_C67X
},
156 { "c67x+", C6XABI_Tag_ISA_C67XP
, (TIC6X_INSN_C62X
158 | TIC6X_INSN_C67XP
) },
159 { "c674x", C6XABI_Tag_ISA_C674X
, (TIC6X_INSN_C62X
164 | TIC6X_INSN_C674X
) }
167 /* Caller saved register encodings. The standard frame layout uses this
168 order, starting from the highest address. There must be
169 TIC6X_NUM_UNWIND_REGS values. */
187 static void tic6x_output_unwinding (bfd_boolean need_extab
);
189 /* Return the frame unwind state for the current function, allocating
192 static tic6x_unwind_info
*tic6x_get_unwind (void)
194 tic6x_unwind_info
*unwind
;
196 unwind
= seg_info (now_seg
)->tc_segment_info_data
.unwind
;
200 unwind
= seg_info (now_seg
)->tc_segment_info_data
.text_unwind
;
204 unwind
= (tic6x_unwind_info
*)xmalloc (sizeof (tic6x_unwind_info
));
205 seg_info (now_seg
)->tc_segment_info_data
.unwind
= unwind
;
206 memset (unwind
, 0, sizeof (*unwind
));
210 /* Update the selected architecture based on ARCH, giving an error if
211 ARCH is an invalid value. Does not call tic6x_update_features; the
212 caller must do that if necessary. */
215 tic6x_use_arch (const char *arch
)
219 for (i
= 0; i
< ARRAY_SIZE (tic6x_arches
); i
++)
220 if (strcmp (arch
, tic6x_arches
[i
].arch
) == 0)
222 tic6x_arch_enable
= tic6x_arches
[i
].features
;
223 if (tic6x_seen_insns
)
225 = elf32_tic6x_merge_arch_attributes (tic6x_arch_attribute
,
226 tic6x_arches
[i
].attr
);
228 tic6x_arch_attribute
= tic6x_arches
[i
].attr
;
232 as_bad (_("unknown architecture '%s'"), arch
);
235 /* Table of supported -mpid arguments. */
240 } tic6x_pid_type_table
;
241 static const tic6x_pid_type_table tic6x_pid_types
[] =
243 { "no", tic6x_pid_no
},
244 { "near", tic6x_pid_near
},
245 { "far", tic6x_pid_far
}
248 /* Handle -mpid=ARG. */
251 tic6x_use_pid (const char *arg
)
255 for (i
= 0; i
< ARRAY_SIZE (tic6x_pid_types
); i
++)
256 if (strcmp (arg
, tic6x_pid_types
[i
].arg
) == 0)
258 tic6x_pid
= tic6x_pid_types
[i
].attr
;
262 as_bad (_("unknown -mpid= argument '%s'"), arg
);
265 /* Parse a target-specific option. */
268 md_parse_option (int c
, char *arg
)
273 tic6x_use_arch (arg
);
276 case OPTION_MBIG_ENDIAN
:
277 target_big_endian
= 1;
280 case OPTION_MLITTLE_ENDIAN
:
281 target_big_endian
= 0;
288 case OPTION_MNO_DSBT
:
304 case OPTION_MGENERATE_REL
:
305 tic6x_generate_rela
= FALSE
;
315 md_show_usage (FILE *stream ATTRIBUTE_UNUSED
)
319 fputc ('\n', stream
);
320 fprintf (stream
, _("TMS320C6000 options:\n"));
321 fprintf (stream
, _(" -march=ARCH enable instructions from architecture ARCH\n"));
322 fprintf (stream
, _(" -mbig-endian generate big-endian code\n"));
323 fprintf (stream
, _(" -mlittle-endian generate little-endian code\n"));
324 fprintf (stream
, _(" -mdsbt code uses DSBT addressing\n"));
325 fprintf (stream
, _(" -mno-dsbt code does not use DSBT addressing\n"));
326 fprintf (stream
, _(" -mpid=no code uses position-dependent data addressing\n"));
327 fprintf (stream
, _(" -mpid=near code uses position-independent data addressing,\n"
328 " GOT accesses use near DP addressing\n"));
329 fprintf (stream
, _(" -mpid=far code uses position-independent data addressing,\n"
330 " GOT accesses use far DP addressing\n"));
331 fprintf (stream
, _(" -mpic code addressing is position-independent\n"));
332 fprintf (stream
, _(" -mno-pic code addressing is position-dependent\n"));
333 /* -mgenerate-rel is only for testsuite use and is deliberately
336 fputc ('\n', stream
);
337 fprintf (stream
, _("Supported ARCH values are:"));
338 for (i
= 0; i
< ARRAY_SIZE (tic6x_arches
); i
++)
339 fprintf (stream
, " %s", tic6x_arches
[i
].arch
);
340 fputc ('\n', stream
);
343 /* Update enabled features based on the current architecture and
346 tic6x_update_features (void)
348 tic6x_features
= tic6x_arch_enable
;
351 = (tic6x_arch_enable
& (TIC6X_INSN_C64X
| TIC6X_INSN_C67XP
)) ? 32 : 16;
353 tic6x_predicate_a0
= (tic6x_arch_enable
& TIC6X_INSN_C64X
) ? TRUE
: FALSE
;
355 tic6x_can_cross_fp_boundary
357 & (TIC6X_INSN_C64X
| TIC6X_INSN_C67XP
)) ? TRUE
: FALSE
;
359 tic6x_long_data_constraints
360 = (tic6x_arch_enable
& TIC6X_INSN_C64X
) ? FALSE
: TRUE
;
362 tic6x_compact_insns
= (tic6x_arch_enable
& TIC6X_INSN_C64XP
) ? TRUE
: FALSE
;
365 /* Do configuration after all options have been parsed. */
368 tic6x_after_parse_args (void)
370 tic6x_update_features ();
373 /* Parse a .cantunwind directive. */
375 s_tic6x_cantunwind (int ignored ATTRIBUTE_UNUSED
)
377 tic6x_unwind_info
*unwind
= tic6x_get_unwind ();
379 /* GCC sometimes spits out superfluous .cantunwind directives, so ignore
381 if (unwind
->data_bytes
== 0)
384 if (unwind
->data_bytes
!= -1)
386 as_bad (_("unexpected .cantunwind directive"));
390 demand_empty_rest_of_line ();
392 if (unwind
->personality_routine
|| unwind
->personality_index
!= -1)
393 as_bad (_("personality routine specified for cantunwind frame"));
395 unwind
->personality_index
= -2;
398 /* Parse a .handlerdata directive. */
400 s_tic6x_handlerdata (int ignored ATTRIBUTE_UNUSED
)
402 tic6x_unwind_info
*unwind
= tic6x_get_unwind ();
404 if (!unwind
->saved_seg
)
406 as_bad (_("unexpected .handlerdata directive"));
410 if (unwind
->table_entry
|| unwind
->personality_index
== -2)
412 as_bad (_("duplicate .handlerdata directive"));
416 if (unwind
->personality_index
== -1 && unwind
->personality_routine
== NULL
)
418 as_bad (_("personality routine required before .handlerdata directive"));
422 tic6x_output_unwinding (TRUE
);
425 /* Parse a .endp directive. */
427 s_tic6x_endp (int ignored ATTRIBUTE_UNUSED
)
429 tic6x_unwind_info
*unwind
= tic6x_get_unwind ();
431 if (unwind
->data_bytes
!= 0)
433 /* Output a .exidx entry if we have not already done so.
434 Then switch back to the text section. */
435 if (!unwind
->table_entry
)
436 tic6x_output_unwinding (FALSE
);
438 subseg_set (unwind
->saved_seg
, unwind
->saved_subseg
);
441 unwind
->saved_seg
= NULL
;
442 unwind
->table_entry
= NULL
;
443 unwind
->data_bytes
= 0;
446 /* Parse a .personalityindex directive. */
448 s_tic6x_personalityindex (int ignored ATTRIBUTE_UNUSED
)
450 tic6x_unwind_info
*unwind
= tic6x_get_unwind ();
453 if (unwind
->personality_routine
|| unwind
->personality_index
!= -1)
454 as_bad (_("duplicate .personalityindex directive"));
458 if (exp
.X_op
!= O_constant
459 || exp
.X_add_number
< 0 || exp
.X_add_number
> 15)
461 as_bad (_("bad personality routine number"));
462 ignore_rest_of_line ();
466 unwind
->personality_index
= exp
.X_add_number
;
468 demand_empty_rest_of_line ();
472 s_tic6x_personality (int ignored ATTRIBUTE_UNUSED
)
475 tic6x_unwind_info
*unwind
= tic6x_get_unwind ();
477 if (unwind
->personality_routine
|| unwind
->personality_index
!= -1)
478 as_bad (_("duplicate .personality directive"));
480 name
= input_line_pointer
;
481 c
= get_symbol_end ();
482 p
= input_line_pointer
;
483 unwind
->personality_routine
= symbol_find_or_make (name
);
485 demand_empty_rest_of_line ();
488 /* Parse a .arch directive. */
490 s_tic6x_arch (int ignored ATTRIBUTE_UNUSED
)
495 arch
= input_line_pointer
;
496 while (*input_line_pointer
&& !ISSPACE (*input_line_pointer
))
497 input_line_pointer
++;
498 c
= *input_line_pointer
;
499 *input_line_pointer
= 0;
501 tic6x_use_arch (arch
);
502 tic6x_update_features ();
503 *input_line_pointer
= c
;
504 demand_empty_rest_of_line ();
507 /* Parse a .ehtype directive. */
510 s_tic6x_ehtype (int ignored ATTRIBUTE_UNUSED
)
515 #ifdef md_flush_pending_output
516 md_flush_pending_output ();
519 if (is_it_end_of_statement ())
521 demand_empty_rest_of_line ();
532 if (exp
.X_op
!= O_symbol
)
534 as_bad (_("expected symbol"));
539 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, 4,
540 &exp
, 0, BFD_RELOC_C6000_EHTYPE
);
542 demand_empty_rest_of_line ();
545 /* Parse a .nocmp directive. */
548 s_tic6x_nocmp (int ignored ATTRIBUTE_UNUSED
)
550 seg_info (now_seg
)->tc_segment_info_data
.nocmp
= TRUE
;
551 demand_empty_rest_of_line ();
554 /* .scomm pseudo-op handler.
556 This is a new pseudo-op to handle putting objects in .scommon.
557 By doing this the linker won't need to do any work,
558 and more importantly it removes the implicit -G arg necessary to
559 correctly link the object file. */
562 s_tic6x_scomm (int ignore ATTRIBUTE_UNUSED
)
572 name
= input_line_pointer
;
573 c
= get_symbol_end ();
575 /* Just after name is now '\0'. */
576 p
= input_line_pointer
;
579 if (*input_line_pointer
!= ',')
581 as_bad (_("expected comma after symbol name"));
582 ignore_rest_of_line ();
587 input_line_pointer
++;
588 if ((size
= get_absolute_expression ()) < 0)
590 /* xgettext:c-format */
591 as_warn (_("invalid length for .scomm directive"));
592 ignore_rest_of_line ();
596 /* The third argument to .scomm is the alignment. */
597 if (*input_line_pointer
!= ',')
601 ++input_line_pointer
;
602 align
= get_absolute_expression ();
605 as_warn (_("alignment is not a positive number"));
610 /* Convert to a power of 2 alignment. */
613 for (align2
= 0; (align
& 1) == 0; align
>>= 1, ++align2
)
617 as_bad (_("alignment is not a power of 2"));
618 ignore_rest_of_line ();
626 symbolP
= symbol_find_or_make (name
);
629 if (S_IS_DEFINED (symbolP
))
631 /* xgettext:c-format */
632 as_bad (_("attempt to re-define symbol `%s'"),
633 S_GET_NAME (symbolP
));
634 ignore_rest_of_line ();
638 if (S_GET_VALUE (symbolP
) && S_GET_VALUE (symbolP
) != (valueT
) size
)
640 /* xgettext:c-format */
641 as_bad (_("attempt to redefine `%s' with a different length"),
642 S_GET_NAME (symbolP
));
644 ignore_rest_of_line ();
648 if (symbol_get_obj (symbolP
)->local
)
650 segT old_sec
= now_seg
;
651 int old_subsec
= now_subseg
;
654 record_alignment (sbss_section
, align2
);
655 subseg_set (sbss_section
, 0);
658 frag_align (align2
, 0, 0);
660 if (S_GET_SEGMENT (symbolP
) == sbss_section
)
661 symbol_get_frag (symbolP
)->fr_symbol
= 0;
663 symbol_set_frag (symbolP
, frag_now
);
665 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
, size
,
668 S_SET_SIZE (symbolP
, size
);
669 S_SET_SEGMENT (symbolP
, sbss_section
);
670 S_CLEAR_EXTERNAL (symbolP
);
671 subseg_set (old_sec
, old_subsec
);
675 S_SET_VALUE (symbolP
, (valueT
) size
);
676 S_SET_ALIGN (symbolP
, 1 << align2
);
677 S_SET_EXTERNAL (symbolP
);
678 S_SET_SEGMENT (symbolP
, &scom_section
);
681 symbol_get_bfdsym (symbolP
)->flags
|= BSF_OBJECT
;
683 demand_empty_rest_of_line ();
686 /* Track for each attribute whether it has been set explicitly (and so
687 should not have a default value set by the assembler). */
688 static bfd_boolean tic6x_attributes_set_explicitly
[NUM_KNOWN_OBJ_ATTRIBUTES
];
690 /* Parse a .c6xabi_attribute directive. */
693 s_tic6x_c6xabi_attribute (int ignored ATTRIBUTE_UNUSED
)
695 int tag
= obj_elf_vendor_attribute (OBJ_ATTR_PROC
);
697 if (tag
< NUM_KNOWN_OBJ_ATTRIBUTES
)
698 tic6x_attributes_set_explicitly
[tag
] = TRUE
;
705 } tic6x_attribute_table
;
707 static const tic6x_attribute_table tic6x_attributes
[] =
709 #define TAG(tag, value) { #tag, tag },
710 #include "elf/tic6x-attrs.h"
714 /* Convert an attribute name to a number. */
717 tic6x_convert_symbolic_attribute (const char *name
)
721 for (i
= 0; i
< ARRAY_SIZE (tic6x_attributes
); i
++)
722 if (strcmp (name
, tic6x_attributes
[i
].name
) == 0)
723 return tic6x_attributes
[i
].tag
;
728 const pseudo_typeS md_pseudo_table
[] =
730 { "arch", s_tic6x_arch
, 0 },
731 { "c6xabi_attribute", s_tic6x_c6xabi_attribute
, 0 },
732 { "nocmp", s_tic6x_nocmp
, 0 },
733 { "scomm", s_tic6x_scomm
, 0 },
735 { "ehtype", s_tic6x_ehtype
, 0 },
736 { "endp", s_tic6x_endp
, 0 },
737 { "handlerdata", s_tic6x_handlerdata
, 0 },
738 { "personalityindex", s_tic6x_personalityindex
, 0 },
739 { "personality", s_tic6x_personality
, 0 },
740 { "cantunwind", s_tic6x_cantunwind
, 0 },
744 /* Hash table of opcodes. For each opcode name, this stores a pointer
745 to a tic6x_opcode_list listing (in an arbitrary order) all opcode
746 table entries with that name. */
747 static struct hash_control
*opcode_hash
;
749 /* Initialize the assembler (called once at assembler startup). */
759 bfd_set_arch_mach (stdoutput
, TARGET_ARCH
, 0);
761 /* Insert opcodes into the hash table. */
762 opcode_hash
= hash_new ();
763 for (id
= 0; id
< tic6x_opcode_max
; id
++)
766 tic6x_opcode_list
*opc
= xmalloc (sizeof (tic6x_opcode_list
));
769 opc
->next
= hash_find (opcode_hash
, tic6x_opcode_table
[id
].name
);
770 if ((errmsg
= hash_jam (opcode_hash
, tic6x_opcode_table
[id
].name
, opc
))
772 as_fatal ("%s", _(errmsg
));
775 /* Save the current subseg so we can restore it [it's the default one and
776 we don't want the initial section to be .sbss]. */
780 /* The sbss section is for local .scomm symbols. */
781 sbss_section
= subseg_new (".bss", 0);
782 seg_info (sbss_section
)->bss
= 1;
784 /* This is copied from perform_an_assembly_pass. */
785 applicable
= bfd_applicable_section_flags (stdoutput
);
786 bfd_set_section_flags (stdoutput
, sbss_section
, applicable
& SEC_ALLOC
);
788 subseg_set (seg
, subseg
);
790 /* We must construct a fake section similar to bfd_com_section
791 but with the name .scommon. */
792 scom_section
= *bfd_com_section_ptr
;
793 scom_section
.name
= ".scommon";
794 scom_section
.output_section
= & scom_section
;
795 scom_section
.symbol
= & scom_symbol
;
796 scom_section
.symbol_ptr_ptr
= & scom_section
.symbol
;
797 scom_symbol
= * bfd_com_section_ptr
->symbol
;
798 scom_symbol
.name
= ".scommon";
799 scom_symbol
.section
= & scom_section
;
802 /* Whether the current line being parsed had the "||" parallel bars. */
803 static bfd_boolean tic6x_line_parallel
;
805 /* Whether the current line being parsed started "||^" to indicate an
806 SPMASKed parallel instruction. */
807 static bfd_boolean tic6x_line_spmask
;
809 /* If the current line being parsed had an instruction predicate, the
810 creg value for that predicate (which must be nonzero); otherwise
812 static unsigned int tic6x_line_creg
;
814 /* If the current line being parsed had an instruction predicate, the
815 z value for that predicate; otherwise 0. */
816 static unsigned int tic6x_line_z
;
818 /* Return 1 (updating input_line_pointer as appropriate) if the line
819 starting with C (immediately before input_line_pointer) starts with
820 pre-opcode text appropriate for this target, 0 otherwise. */
823 tic6x_unrecognized_line (int c
)
828 bfd_boolean bad_predicate
;
833 if (input_line_pointer
[0] == '|')
835 if (input_line_pointer
[1] == '^')
837 tic6x_line_spmask
= TRUE
;
838 input_line_pointer
+= 2;
841 input_line_pointer
+= 1;
842 if (tic6x_line_parallel
)
843 as_bad (_("multiple '||' on same line"));
844 tic6x_line_parallel
= TRUE
;
846 as_bad (_("'||' after predicate"));
852 /* If it doesn't look like a predicate at all, just return 0.
853 If it looks like one but not a valid one, give a better
855 p
= input_line_pointer
;
856 while (*p
!= ']' && !is_end_of_line
[(unsigned char) *p
])
861 p
= input_line_pointer
;
863 bad_predicate
= FALSE
;
869 if (*p
== 'A' || *p
== 'a')
871 else if (*p
== 'B' || *p
== 'b')
875 areg
= TRUE
; /* Avoid uninitialized warning. */
876 bad_predicate
= TRUE
;
881 if (*p
!= '0' && *p
!= '1' && *p
!= '2')
882 bad_predicate
= TRUE
;
883 else if (p
[1] != ']')
884 bad_predicate
= TRUE
;
886 input_line_pointer
= p
+ 2;
890 as_bad (_("multiple predicates on same line"));
896 as_bad (_("bad predicate '%s'"), input_line_pointer
- 1);
898 input_line_pointer
= endp
;
905 tic6x_line_creg
= (areg
? 6 : 1);
906 if (areg
&& !tic6x_predicate_a0
)
907 as_bad (_("predication on A0 not supported on this architecture"));
911 tic6x_line_creg
= (areg
? 4 : 2);
915 tic6x_line_creg
= (areg
? 5 : 3);
930 /* Do any target-specific handling of a label required. */
933 tic6x_frob_label (symbolS
*sym
)
935 segment_info_type
*si
;
936 tic6x_label_list
*list
;
938 if (tic6x_line_parallel
)
940 as_bad (_("label after '||'"));
941 tic6x_line_parallel
= FALSE
;
942 tic6x_line_spmask
= FALSE
;
946 as_bad (_("label after predicate"));
951 si
= seg_info (now_seg
);
952 list
= si
->tc_segment_info_data
.label_list
;
953 si
->tc_segment_info_data
.label_list
= xmalloc (sizeof (tic6x_label_list
));
954 si
->tc_segment_info_data
.label_list
->next
= list
;
955 si
->tc_segment_info_data
.label_list
->label
= sym
;
957 /* Defining tc_frob_label overrides the ELF definition of
958 obj_frob_label, so we need to apply its effects here. */
959 dwarf2_emit_label (sym
);
962 /* At end-of-line, give errors for start-of-line decorations that
963 needed an instruction but were not followed by one. */
966 tic6x_end_of_line (void)
968 if (tic6x_line_parallel
)
970 as_bad (_("'||' not followed by instruction"));
971 tic6x_line_parallel
= FALSE
;
972 tic6x_line_spmask
= FALSE
;
976 as_bad (_("predicate not followed by instruction"));
982 /* Do any target-specific handling of the start of a logical line. */
985 tic6x_start_line_hook (void)
987 tic6x_end_of_line ();
990 /* Do target-specific handling immediately after an input file from
991 the command line, and any other inputs it includes, have been
997 tic6x_end_of_line ();
1000 /* Do target-specific initialization after arguments have been
1001 processed and the output file created. */
1004 tic6x_init_after_args (void)
1006 elf32_tic6x_set_use_rela_p (stdoutput
, tic6x_generate_rela
);
1009 /* Free LIST of labels (possibly NULL). */
1012 tic6x_free_label_list (tic6x_label_list
*list
)
1016 tic6x_label_list
*old
= list
;
1023 /* Handle a data alignment of N bytes. */
1026 tic6x_cons_align (int n ATTRIBUTE_UNUSED
)
1028 segment_info_type
*seginfo
= seg_info (now_seg
);
1030 /* Data means there is no current execute packet, and that any label
1031 applies to that data rather than a subsequent instruction. */
1032 tic6x_free_label_list (seginfo
->tc_segment_info_data
.label_list
);
1033 seginfo
->tc_segment_info_data
.label_list
= NULL
;
1034 seginfo
->tc_segment_info_data
.execute_packet_frag
= NULL
;
1035 seginfo
->tc_segment_info_data
.last_insn_lsb
= NULL
;
1036 seginfo
->tc_segment_info_data
.spmask_addr
= NULL
;
1037 seginfo
->tc_segment_info_data
.func_units_used
= 0;
1040 /* Handle an alignment directive. Return TRUE if the
1041 machine-independent frag generation should be skipped. */
1044 tic6x_do_align (int n
, char *fill
, int len ATTRIBUTE_UNUSED
, int max
)
1046 /* Given code alignments of 4, 8, 16 or 32 bytes, we try to handle
1047 them in the md_end pass by inserting NOPs in parallel with
1048 previous instructions. We only do this in sections containing
1049 nothing but instructions. Code alignments of 1 or 2 bytes have
1050 no effect in such sections (but we record them with
1051 machine-dependent frags anyway so they can be skipped or
1052 converted to machine-independent), while those of more than 64
1053 bytes cannot reliably be handled in this way. */
1059 && subseg_text_p (now_seg
))
1067 /* Machine-independent code would generate a frag here, but we
1068 wish to handle it in a machine-dependent way. */
1069 if (frag_now_fix () != 0)
1071 if (frag_now
->fr_type
!= rs_machine_dependent
)
1072 frag_wane (frag_now
);
1077 align_frag
= frag_now
;
1078 p
= frag_var (rs_machine_dependent
, 32, 32, max
, NULL
, n
, NULL
);
1079 /* This must be the same as the frag to which a pointer was just
1081 if (p
!= align_frag
->fr_literal
)
1083 align_frag
->tc_frag_data
.is_insns
= FALSE
;
1090 /* Types of operand for parsing purposes. These are used as bit-masks
1091 to tell tic6x_parse_operand what forms of operand are
1093 #define TIC6X_OP_EXP 0x0001u
1094 #define TIC6X_OP_REG 0x0002u
1095 #define TIC6X_OP_REGPAIR 0x0004u
1096 #define TIC6X_OP_IRP 0x0008u
1097 #define TIC6X_OP_NRP 0x0010u
1098 /* With TIC6X_OP_MEM_NOUNREG, the contents of a () offset are always
1099 interpreted as an expression, which may be a symbol with the same
1100 name as a register that ends up being implicitly DP-relative. With
1101 TIC6X_OP_MEM_UNREG, the contents of a () offset are interpreted as
1102 a register if they match one, and failing that as an expression,
1103 which must be constant. */
1104 #define TIC6X_OP_MEM_NOUNREG 0x0020u
1105 #define TIC6X_OP_MEM_UNREG 0x0040u
1106 #define TIC6X_OP_CTRL 0x0080u
1107 #define TIC6X_OP_FUNC_UNIT 0x0100u
1109 /* A register or register pair read by the assembler. */
1112 /* The side the register is on (1 or 2). */
1114 /* The register number (0 to 31). */
1118 /* Types of modification of a base address. */
1123 tic6x_mem_mod_minus
,
1124 tic6x_mem_mod_preinc
,
1125 tic6x_mem_mod_predec
,
1126 tic6x_mem_mod_postinc
,
1127 tic6x_mem_mod_postdec
1130 /* Scaled [] or unscaled () nature of an offset. */
1134 tic6x_offset_scaled
,
1135 tic6x_offset_unscaled
1136 } tic6x_mem_scaling
;
1138 /* A memory operand read by the assembler. */
1141 /* The base register. */
1142 tic6x_register base_reg
;
1143 /* How the base register is modified. */
1145 /* Whether there is an offset (required with plain "+" and "-"), and
1146 whether it is scaled or unscaled if so. */
1147 tic6x_mem_scaling scaled
;
1148 /* Whether the offset is a register (TRUE) or an expression
1150 bfd_boolean offset_is_reg
;
1159 /* A functional unit in SPMASK operands read by the assembler. */
1162 /* The basic unit. */
1163 tic6x_func_unit_base base
;
1164 /* The side (1 or 2). */
1166 } tic6x_func_unit_operand
;
1168 /* An operand read by the assembler. */
1171 /* The syntactic form of the operand, as one of the bit-masks
1174 /* The operand value. */
1177 /* An expression: TIC6X_OP_EXP. */
1179 /* A register: TIC6X_OP_REG, TIC6X_OP_REGPAIR. */
1181 /* A memory reference: TIC6X_OP_MEM_NOUNREG,
1182 TIC6X_OP_MEM_UNREG. */
1184 /* A control register: TIC6X_OP_CTRL. */
1186 /* A functional unit: TIC6X_OP_FUNC_UNIT. */
1187 tic6x_func_unit_operand func_unit
;
1191 #define skip_whitespace(str) do { if (*(str) == ' ') ++(str); } while (0)
1193 /* Parse a register operand, or part of an operand, starting at *P.
1194 If syntactically OK (including that the number is in the range 0 to
1195 31, but not necessarily in range for this architecture), return
1196 TRUE, putting the register side and number in *REG and update *P to
1197 point immediately after the register number; otherwise return FALSE
1198 without changing *P (but possibly changing *REG). Do not print any
1202 tic6x_parse_register (char **p
, tic6x_register
*reg
)
1223 if (*r
>= '0' && *r
<= '9')
1225 reg
->num
= *r
- '0';
1231 if (reg
->num
> 0 && *r
>= '0' && *r
<= '9')
1233 reg
->num
= reg
->num
* 10 + (*r
- '0');
1237 if (*r
>= '0' && *r
<= '9')
1246 /* Parse the initial two characters of a functional unit name starting
1247 at *P. If OK, set *BASE and *SIDE and return TRUE; otherwise,
1251 tic6x_parse_func_unit_base (char *p
, tic6x_func_unit_base
*base
,
1254 bfd_boolean good_func_unit
= TRUE
;
1255 tic6x_func_unit_base maybe_base
= tic6x_func_unit_nfu
;
1256 unsigned int maybe_side
= 0;
1262 maybe_base
= tic6x_func_unit_d
;
1267 maybe_base
= tic6x_func_unit_l
;
1272 maybe_base
= tic6x_func_unit_m
;
1277 maybe_base
= tic6x_func_unit_s
;
1281 good_func_unit
= FALSE
;
1297 good_func_unit
= FALSE
;
1307 return good_func_unit
;
1310 /* Parse an operand starting at *P. If the operand parses OK, return
1311 TRUE and store the value in *OP; otherwise return FALSE (possibly
1312 changing *OP). In any case, update *P to point to the following
1313 comma or end of line. The possible operand forms are given by
1314 OP_FORMS. For diagnostics, this is operand OPNO of an opcode
1315 starting at STR, length OPC_LEN. */
1318 tic6x_parse_operand (char **p
, tic6x_operand
*op
, unsigned int op_forms
,
1319 char *str
, int opc_len
, unsigned int opno
)
1321 bfd_boolean operand_parsed
= FALSE
;
1324 if ((op_forms
& (TIC6X_OP_MEM_NOUNREG
| TIC6X_OP_MEM_UNREG
))
1325 == (TIC6X_OP_MEM_NOUNREG
| TIC6X_OP_MEM_UNREG
))
1328 /* Check for functional unit names for SPMASK and SPMASKR. */
1329 if (!operand_parsed
&& (op_forms
& TIC6X_OP_FUNC_UNIT
))
1331 tic6x_func_unit_base base
= tic6x_func_unit_nfu
;
1332 unsigned int side
= 0;
1334 if (tic6x_parse_func_unit_base (q
, &base
, &side
))
1338 skip_whitespace (rq
);
1339 if (is_end_of_line
[(unsigned char) *rq
] || *rq
== ',')
1341 op
->form
= TIC6X_OP_FUNC_UNIT
;
1342 op
->value
.func_unit
.base
= base
;
1343 op
->value
.func_unit
.side
= side
;
1344 operand_parsed
= TRUE
;
1350 /* Check for literal "irp". */
1351 if (!operand_parsed
&& (op_forms
& TIC6X_OP_IRP
))
1353 if ((q
[0] == 'i' || q
[0] == 'I')
1354 && (q
[1] == 'r' || q
[1] == 'R')
1355 && (q
[2] == 'p' || q
[2] == 'P'))
1359 skip_whitespace (rq
);
1360 if (is_end_of_line
[(unsigned char) *rq
] || *rq
== ',')
1362 op
->form
= TIC6X_OP_IRP
;
1363 operand_parsed
= TRUE
;
1369 /* Check for literal "nrp". */
1370 if (!operand_parsed
&& (op_forms
& TIC6X_OP_NRP
))
1372 if ((q
[0] == 'n' || q
[0] == 'N')
1373 && (q
[1] == 'r' || q
[1] == 'R')
1374 && (q
[2] == 'p' || q
[2] == 'P'))
1378 skip_whitespace (rq
);
1379 if (is_end_of_line
[(unsigned char) *rq
] || *rq
== ',')
1381 op
->form
= TIC6X_OP_NRP
;
1382 operand_parsed
= TRUE
;
1388 /* Check for control register names. */
1389 if (!operand_parsed
&& (op_forms
& TIC6X_OP_CTRL
))
1393 for (crid
= 0; crid
< tic6x_ctrl_max
; crid
++)
1395 size_t len
= strlen (tic6x_ctrl_table
[crid
].name
);
1397 if (strncasecmp (tic6x_ctrl_table
[crid
].name
, q
, len
) == 0)
1401 skip_whitespace (rq
);
1402 if (is_end_of_line
[(unsigned char) *rq
] || *rq
== ',')
1404 op
->form
= TIC6X_OP_CTRL
;
1405 op
->value
.ctrl
= crid
;
1406 operand_parsed
= TRUE
;
1408 if (!(tic6x_ctrl_table
[crid
].isa_variants
& tic6x_features
))
1409 as_bad (_("control register '%s' not supported "
1410 "on this architecture"),
1411 tic6x_ctrl_table
[crid
].name
);
1417 /* See if this looks like a memory reference. */
1419 && (op_forms
& (TIC6X_OP_MEM_NOUNREG
| TIC6X_OP_MEM_UNREG
)))
1421 bfd_boolean mem_ok
= TRUE
;
1423 tic6x_mem_mod mem_mod
= tic6x_mem_mod_none
;
1424 tic6x_register base_reg
;
1425 bfd_boolean require_offset
, permit_offset
;
1426 tic6x_mem_scaling scaled
;
1427 bfd_boolean offset_is_reg
;
1428 expressionS offset_exp
;
1429 tic6x_register offset_reg
;
1438 skip_whitespace (mq
);
1444 mem_mod
= tic6x_mem_mod_preinc
;
1449 mem_mod
= tic6x_mem_mod_plus
;
1457 mem_mod
= tic6x_mem_mod_predec
;
1462 mem_mod
= tic6x_mem_mod_minus
;
1474 skip_whitespace (mq
);
1475 mem_ok
= tic6x_parse_register (&mq
, &base_reg
);
1478 if (mem_ok
&& mem_mod
== tic6x_mem_mod_none
)
1480 skip_whitespace (mq
);
1481 if (mq
[0] == '+' && mq
[1] == '+')
1483 mem_mod
= tic6x_mem_mod_postinc
;
1486 else if (mq
[0] == '-' && mq
[1] == '-')
1488 mem_mod
= tic6x_mem_mod_postdec
;
1493 if (mem_mod
== tic6x_mem_mod_none
)
1494 permit_offset
= FALSE
;
1496 permit_offset
= TRUE
;
1497 if (mem_mod
== tic6x_mem_mod_plus
|| mem_mod
== tic6x_mem_mod_minus
)
1498 require_offset
= TRUE
;
1500 require_offset
= FALSE
;
1501 scaled
= tic6x_offset_none
;
1502 offset_is_reg
= FALSE
;
1504 if (mem_ok
&& permit_offset
)
1508 skip_whitespace (mq
);
1512 scaled
= tic6x_offset_scaled
;
1518 scaled
= tic6x_offset_unscaled
;
1526 if (scaled
!= tic6x_offset_none
)
1528 skip_whitespace (mq
);
1529 if (scaled
== tic6x_offset_scaled
1530 || (op_forms
& TIC6X_OP_MEM_UNREG
))
1535 reg_ok
= tic6x_parse_register (&rq
, &offset_reg
);
1538 skip_whitespace (rq
);
1542 offset_is_reg
= TRUE
;
1548 char *save_input_line_pointer
;
1550 save_input_line_pointer
= input_line_pointer
;
1551 input_line_pointer
= mq
;
1552 expression (&offset_exp
);
1553 mq
= input_line_pointer
;
1554 input_line_pointer
= save_input_line_pointer
;
1556 skip_whitespace (mq
);
1564 if (mem_ok
&& require_offset
&& scaled
== tic6x_offset_none
)
1569 skip_whitespace (mq
);
1570 if (!is_end_of_line
[(unsigned char) *mq
] && *mq
!= ',')
1576 op
->form
= op_forms
& (TIC6X_OP_MEM_NOUNREG
| TIC6X_OP_MEM_UNREG
);
1577 op
->value
.mem
.base_reg
= base_reg
;
1578 op
->value
.mem
.mod
= mem_mod
;
1579 op
->value
.mem
.scaled
= scaled
;
1580 op
->value
.mem
.offset_is_reg
= offset_is_reg
;
1582 op
->value
.mem
.offset
.reg
= offset_reg
;
1584 op
->value
.mem
.offset
.exp
= offset_exp
;
1585 operand_parsed
= TRUE
;
1587 if (base_reg
.num
>= tic6x_num_registers
)
1588 as_bad (_("register number %u not supported on this architecture"),
1590 if (offset_is_reg
&& offset_reg
.num
>= tic6x_num_registers
)
1591 as_bad (_("register number %u not supported on this architecture"),
1596 /* See if this looks like a register or register pair. */
1597 if (!operand_parsed
&& (op_forms
& (TIC6X_OP_REG
| TIC6X_OP_REGPAIR
)))
1599 tic6x_register first_reg
, second_reg
;
1603 reg_ok
= tic6x_parse_register (&rq
, &first_reg
);
1607 if (*rq
== ':' && (op_forms
& TIC6X_OP_REGPAIR
))
1610 reg_ok
= tic6x_parse_register (&rq
, &second_reg
);
1613 skip_whitespace (rq
);
1614 if (is_end_of_line
[(unsigned char) *rq
] || *rq
== ',')
1616 if ((second_reg
.num
& 1)
1617 || (first_reg
.num
!= second_reg
.num
+ 1)
1618 || (first_reg
.side
!= second_reg
.side
))
1619 as_bad (_("register pair for operand %u of '%.*s'"
1620 " not a valid even/odd pair"), opno
,
1622 op
->form
= TIC6X_OP_REGPAIR
;
1623 op
->value
.reg
= second_reg
;
1624 operand_parsed
= TRUE
;
1629 else if (op_forms
& TIC6X_OP_REG
)
1631 skip_whitespace (rq
);
1632 if (is_end_of_line
[(unsigned char) *rq
] || *rq
== ',')
1634 op
->form
= TIC6X_OP_REG
;
1635 op
->value
.reg
= first_reg
;
1636 operand_parsed
= TRUE
;
1643 if (first_reg
.num
>= tic6x_num_registers
)
1644 as_bad (_("register number %u not supported on this architecture"),
1646 if (op
->form
== TIC6X_OP_REGPAIR
1647 && second_reg
.num
>= tic6x_num_registers
)
1648 as_bad (_("register number %u not supported on this architecture"),
1653 /* Otherwise, parse it as an expression. */
1654 if (!operand_parsed
&& (op_forms
& TIC6X_OP_EXP
))
1656 char *save_input_line_pointer
;
1658 save_input_line_pointer
= input_line_pointer
;
1659 input_line_pointer
= q
;
1660 op
->form
= TIC6X_OP_EXP
;
1661 expression (&op
->value
.exp
);
1662 q
= input_line_pointer
;
1663 input_line_pointer
= save_input_line_pointer
;
1664 operand_parsed
= TRUE
;
1669 /* Now the operand has been parsed, there must be nothing more
1670 before the comma or end of line. */
1671 skip_whitespace (q
);
1672 if (!is_end_of_line
[(unsigned char) *q
] && *q
!= ',')
1674 operand_parsed
= FALSE
;
1675 as_bad (_("junk after operand %u of '%.*s'"), opno
,
1677 while (!is_end_of_line
[(unsigned char) *q
] && *q
!= ',')
1683 /* This could not be parsed as any acceptable form of
1687 case TIC6X_OP_REG
| TIC6X_OP_REGPAIR
:
1688 as_bad (_("bad register or register pair for operand %u of '%.*s'"),
1689 opno
, opc_len
, str
);
1692 case TIC6X_OP_REG
| TIC6X_OP_CTRL
:
1694 as_bad (_("bad register for operand %u of '%.*s'"),
1695 opno
, opc_len
, str
);
1698 case TIC6X_OP_REGPAIR
:
1699 as_bad (_("bad register pair for operand %u of '%.*s'"),
1700 opno
, opc_len
, str
);
1703 case TIC6X_OP_FUNC_UNIT
:
1704 as_bad (_("bad functional unit for operand %u of '%.*s'"),
1705 opno
, opc_len
, str
);
1709 as_bad (_("bad operand %u of '%.*s'"),
1710 opno
, opc_len
, str
);
1714 while (!is_end_of_line
[(unsigned char) *q
] && *q
!= ',')
1718 return operand_parsed
;
1721 /* Table of assembler operators and associated O_* values. */
1726 } tic6x_operator_table
;
1727 static const tic6x_operator_table tic6x_operators
[] = {
1728 #define O_dsbt_index O_md1
1729 { "dsbt_index", O_dsbt_index
},
1732 #define O_dpr_got O_md3
1733 { "dpr_got", O_dpr_got
},
1734 #define O_dpr_byte O_md4
1735 { "dpr_byte", O_dpr_byte
},
1736 #define O_dpr_hword O_md5
1737 { "dpr_hword", O_dpr_hword
},
1738 #define O_dpr_word O_md6
1739 { "dpr_word", O_dpr_word
},
1740 #define O_pcr_offset O_md7
1741 { "pcr_offset", O_pcr_offset
}
1744 /* Parse a name in some machine-specific way. Used on C6X to handle
1745 assembler operators. */
1748 tic6x_parse_name (const char *name
, expressionS
*exprP
,
1749 enum expr_mode mode ATTRIBUTE_UNUSED
, char *nextchar
)
1751 char *p
= input_line_pointer
;
1752 char c
, *name_start
, *name_end
;
1753 const char *inner_name
;
1755 operatorT op
= O_illegal
;
1756 symbolS
*sym
, *op_sym
= NULL
;
1761 for (i
= 0; i
< ARRAY_SIZE (tic6x_operators
); i
++)
1762 if (strcasecmp (name
+ 1, tic6x_operators
[i
].name
) == 0)
1764 op
= tic6x_operators
[i
].op
;
1768 if (op
== O_illegal
)
1771 *input_line_pointer
= *nextchar
;
1772 skip_whitespace (p
);
1776 *input_line_pointer
= 0;
1780 skip_whitespace (p
);
1782 if (!is_name_beginner (*p
))
1784 *input_line_pointer
= 0;
1790 while (is_part_of_name (*p
))
1793 skip_whitespace (p
);
1795 if (op
== O_pcr_offset
)
1797 char *op_name_start
, *op_name_end
;
1801 *input_line_pointer
= 0;
1805 skip_whitespace (p
);
1807 if (!is_name_beginner (*p
))
1809 *input_line_pointer
= 0;
1815 while (is_part_of_name (*p
))
1818 skip_whitespace (p
);
1822 op_sym
= symbol_find_or_make (op_name_start
);
1828 *input_line_pointer
= 0;
1832 input_line_pointer
= p
+ 1;
1833 *nextchar
= *input_line_pointer
;
1834 *input_line_pointer
= 0;
1838 inner_name
= name_start
;
1839 if (op
== O_dsbt_index
&& strcmp (inner_name
, "__c6xabi_DSBT_BASE") != 0)
1841 as_bad (_("$DSBT_INDEX must be used with __c6xabi_DSBT_BASE"));
1842 inner_name
= "__c6xabi_DSBT_BASE";
1844 sym
= symbol_find_or_make (inner_name
);
1848 exprP
->X_add_symbol
= sym
;
1849 exprP
->X_add_number
= 0;
1850 exprP
->X_op_symbol
= op_sym
;
1856 /* Create a fixup for an expression. Same arguments as fix_new_exp,
1857 plus FIX_ADDA which is TRUE for ADDA instructions (to indicate that
1858 fixes resolving to constants should have those constants implicitly
1859 shifted) and FALSE otherwise, but look for C6X-specific expression
1860 types and adjust the relocations or give errors accordingly. */
1863 tic6x_fix_new_exp (fragS
*frag
, int where
, int size
, expressionS
*exp
,
1864 int pcrel
, bfd_reloc_code_real_type r_type
,
1865 bfd_boolean fix_adda
)
1867 bfd_reloc_code_real_type new_reloc
= BFD_RELOC_UNUSED
;
1868 symbolS
*subsy
= NULL
;
1876 case BFD_RELOC_C6000_SBR_U15_W
:
1877 new_reloc
= BFD_RELOC_C6000_DSBT_INDEX
;
1881 as_bad (_("$DSBT_INDEX not supported in this context"));
1889 case BFD_RELOC_C6000_SBR_U15_W
:
1890 new_reloc
= BFD_RELOC_C6000_SBR_GOT_U15_W
;
1894 as_bad (_("$GOT not supported in this context"));
1902 case BFD_RELOC_C6000_ABS_L16
:
1903 new_reloc
= BFD_RELOC_C6000_SBR_GOT_L16_W
;
1906 case BFD_RELOC_C6000_ABS_H16
:
1907 new_reloc
= BFD_RELOC_C6000_SBR_GOT_H16_W
;
1911 as_bad (_("$DPR_GOT not supported in this context"));
1919 case BFD_RELOC_C6000_ABS_S16
:
1920 new_reloc
= BFD_RELOC_C6000_SBR_S16
;
1923 case BFD_RELOC_C6000_ABS_L16
:
1924 new_reloc
= BFD_RELOC_C6000_SBR_L16_B
;
1927 case BFD_RELOC_C6000_ABS_H16
:
1928 new_reloc
= BFD_RELOC_C6000_SBR_H16_B
;
1932 as_bad (_("$DPR_BYTE not supported in this context"));
1940 case BFD_RELOC_C6000_ABS_L16
:
1941 new_reloc
= BFD_RELOC_C6000_SBR_L16_H
;
1944 case BFD_RELOC_C6000_ABS_H16
:
1945 new_reloc
= BFD_RELOC_C6000_SBR_H16_H
;
1949 as_bad (_("$DPR_HWORD not supported in this context"));
1957 case BFD_RELOC_C6000_ABS_L16
:
1958 new_reloc
= BFD_RELOC_C6000_SBR_L16_W
;
1961 case BFD_RELOC_C6000_ABS_H16
:
1962 new_reloc
= BFD_RELOC_C6000_SBR_H16_W
;
1966 as_bad (_("$DPR_WORD not supported in this context"));
1972 subsy
= exp
->X_op_symbol
;
1975 case BFD_RELOC_C6000_ABS_S16
:
1976 case BFD_RELOC_C6000_ABS_L16
:
1977 new_reloc
= BFD_RELOC_C6000_PCR_L16
;
1980 case BFD_RELOC_C6000_ABS_H16
:
1981 new_reloc
= BFD_RELOC_C6000_PCR_H16
;
1985 as_bad (_("$PCR_OFFSET not supported in this context"));
1996 as_bad (_("invalid PC-relative operand"));
2002 if (new_reloc
== BFD_RELOC_UNUSED
)
2003 fix
= fix_new_exp (frag
, where
, size
, exp
, pcrel
, r_type
);
2005 fix
= fix_new (frag
, where
, size
, exp
->X_add_symbol
, exp
->X_add_number
,
2007 fix
->tc_fix_data
.fix_subsy
= subsy
;
2008 fix
->tc_fix_data
.fix_adda
= fix_adda
;
2011 /* Generate a fix for a constant (.word etc.). Needed to ensure these
2012 go through the error checking in tic6x_fix_new_exp. */
2015 tic6x_cons_fix_new (fragS
*frag
, int where
, int size
, expressionS
*exp
,
2016 bfd_reloc_code_real_type r_type
)
2021 r_type
= BFD_RELOC_8
;
2025 r_type
= BFD_RELOC_16
;
2029 r_type
= BFD_RELOC_32
;
2033 as_bad (_("no %d-byte relocations available"), size
);
2037 tic6x_fix_new_exp (frag
, where
, size
, exp
, 0, r_type
, FALSE
);
2040 /* Initialize target-specific fix data. */
2043 tic6x_init_fix_data (fixS
*fixP
)
2045 fixP
->tc_fix_data
.fix_adda
= FALSE
;
2046 fixP
->tc_fix_data
.fix_subsy
= NULL
;
2049 /* Return true if the fix can be handled by GAS, false if it must
2050 be passed through to the linker. */
2053 tic6x_fix_adjustable (fixS
*fixP
)
2055 switch (fixP
->fx_r_type
)
2057 /* Adjust_reloc_syms doesn't know about the GOT. */
2058 case BFD_RELOC_C6000_SBR_GOT_U15_W
:
2059 case BFD_RELOC_C6000_SBR_GOT_H16_W
:
2060 case BFD_RELOC_C6000_SBR_GOT_L16_W
:
2061 case BFD_RELOC_C6000_EHTYPE
:
2064 case BFD_RELOC_C6000_PREL31
:
2067 case BFD_RELOC_C6000_PCR_H16
:
2068 case BFD_RELOC_C6000_PCR_L16
:
2076 /* Given the fine-grained form of an operand, return the coarse
2080 tic6x_coarse_operand_form (tic6x_operand_form form
)
2084 case tic6x_operand_asm_const
:
2085 case tic6x_operand_link_const
:
2086 return TIC6X_OP_EXP
;
2088 case tic6x_operand_reg
:
2089 case tic6x_operand_xreg
:
2090 case tic6x_operand_dreg
:
2091 case tic6x_operand_areg
:
2092 case tic6x_operand_retreg
:
2093 return TIC6X_OP_REG
;
2095 case tic6x_operand_regpair
:
2096 case tic6x_operand_xregpair
:
2097 case tic6x_operand_dregpair
:
2098 return TIC6X_OP_REGPAIR
;
2100 case tic6x_operand_irp
:
2101 return TIC6X_OP_IRP
;
2103 case tic6x_operand_nrp
:
2104 return TIC6X_OP_NRP
;
2106 case tic6x_operand_ctrl
:
2107 return TIC6X_OP_CTRL
;
2109 case tic6x_operand_mem_short
:
2110 case tic6x_operand_mem_long
:
2111 case tic6x_operand_mem_deref
:
2112 return TIC6X_OP_MEM_NOUNREG
;
2114 case tic6x_operand_mem_ndw
:
2115 return TIC6X_OP_MEM_UNREG
;
2117 case tic6x_operand_func_unit
:
2118 return TIC6X_OP_FUNC_UNIT
;
2125 /* How an operand may match or not match a desired form. If different
2126 instruction alternatives fail in different ways, the first failure
2127 in this list determines the diagnostic. */
2131 tic6x_match_matches
,
2132 /* Bad coarse form. */
2135 tic6x_match_non_const
,
2136 /* Register on wrong side. */
2137 tic6x_match_wrong_side
,
2138 /* Not a valid address register. */
2139 tic6x_match_bad_address
,
2140 /* Not a valid return address register. */
2141 tic6x_match_bad_return
,
2142 /* Control register not readable. */
2143 tic6x_match_ctrl_write_only
,
2144 /* Control register not writable. */
2145 tic6x_match_ctrl_read_only
,
2146 /* Not a valid memory reference for this instruction. */
2148 } tic6x_operand_match
;
2150 /* Return whether an operand matches the given fine-grained form and
2151 read/write usage, and, if it does not match, how it fails to match.
2152 The main functional unit side is SIDE; the cross-path side is CROSS
2153 (the same as SIDE if a cross path not used); the data side is
2155 static tic6x_operand_match
2156 tic6x_operand_matches_form (const tic6x_operand
*op
, tic6x_operand_form form
,
2157 tic6x_rw rw
, unsigned int side
, unsigned int cross
,
2158 unsigned int data_side
)
2160 unsigned int coarse
= tic6x_coarse_operand_form (form
);
2162 if (coarse
!= op
->form
)
2163 return tic6x_match_coarse
;
2167 case tic6x_operand_asm_const
:
2168 if (op
->value
.exp
.X_op
== O_constant
)
2169 return tic6x_match_matches
;
2171 return tic6x_match_non_const
;
2173 case tic6x_operand_link_const
:
2174 case tic6x_operand_irp
:
2175 case tic6x_operand_nrp
:
2176 case tic6x_operand_func_unit
:
2177 /* All expressions are link-time constants, although there may
2178 not be relocations to express them in the output file. "irp"
2179 and "nrp" are unique operand values. All parsed functional
2180 unit names are valid. */
2181 return tic6x_match_matches
;
2183 case tic6x_operand_reg
:
2184 case tic6x_operand_regpair
:
2185 if (op
->value
.reg
.side
== side
)
2186 return tic6x_match_matches
;
2188 return tic6x_match_wrong_side
;
2190 case tic6x_operand_xreg
:
2191 case tic6x_operand_xregpair
:
2192 if (op
->value
.reg
.side
== cross
)
2193 return tic6x_match_matches
;
2195 return tic6x_match_wrong_side
;
2197 case tic6x_operand_dreg
:
2198 case tic6x_operand_dregpair
:
2199 if (op
->value
.reg
.side
== data_side
)
2200 return tic6x_match_matches
;
2202 return tic6x_match_wrong_side
;
2204 case tic6x_operand_areg
:
2205 if (op
->value
.reg
.side
!= cross
)
2206 return tic6x_match_wrong_side
;
2207 else if (op
->value
.reg
.side
== 2
2208 && (op
->value
.reg
.num
== 14 || op
->value
.reg
.num
== 15))
2209 return tic6x_match_matches
;
2211 return tic6x_match_bad_address
;
2213 case tic6x_operand_retreg
:
2214 if (op
->value
.reg
.side
!= side
)
2215 return tic6x_match_wrong_side
;
2216 else if (op
->value
.reg
.num
!= 3)
2217 return tic6x_match_bad_return
;
2219 return tic6x_match_matches
;
2221 case tic6x_operand_ctrl
:
2225 if (tic6x_ctrl_table
[op
->value
.ctrl
].rw
== tic6x_rw_read
2226 || tic6x_ctrl_table
[op
->value
.ctrl
].rw
== tic6x_rw_read_write
)
2227 return tic6x_match_matches
;
2229 return tic6x_match_ctrl_write_only
;
2231 case tic6x_rw_write
:
2232 if (tic6x_ctrl_table
[op
->value
.ctrl
].rw
== tic6x_rw_write
2233 || tic6x_ctrl_table
[op
->value
.ctrl
].rw
== tic6x_rw_read_write
)
2234 return tic6x_match_matches
;
2236 return tic6x_match_ctrl_read_only
;
2242 case tic6x_operand_mem_deref
:
2243 if (op
->value
.mem
.mod
!= tic6x_mem_mod_none
)
2244 return tic6x_match_bad_mem
;
2245 else if (op
->value
.mem
.scaled
!= tic6x_offset_none
)
2247 else if (op
->value
.mem
.base_reg
.side
!= side
)
2248 return tic6x_match_bad_mem
;
2250 return tic6x_match_matches
;
2252 case tic6x_operand_mem_short
:
2253 case tic6x_operand_mem_ndw
:
2254 if (op
->value
.mem
.base_reg
.side
!= side
)
2255 return tic6x_match_bad_mem
;
2256 if (op
->value
.mem
.mod
== tic6x_mem_mod_none
)
2258 if (op
->value
.mem
.scaled
!= tic6x_offset_none
)
2260 return tic6x_match_matches
;
2262 if (op
->value
.mem
.scaled
== tic6x_offset_none
)
2264 if (op
->value
.mem
.mod
== tic6x_mem_mod_plus
2265 || op
->value
.mem
.mod
== tic6x_mem_mod_minus
)
2267 return tic6x_match_matches
;
2269 if (op
->value
.mem
.offset_is_reg
)
2271 if (op
->value
.mem
.scaled
== tic6x_offset_unscaled
2272 && form
!= tic6x_operand_mem_ndw
)
2274 if (op
->value
.mem
.offset
.reg
.side
== side
)
2275 return tic6x_match_matches
;
2277 return tic6x_match_bad_mem
;
2281 if (op
->value
.mem
.offset
.exp
.X_op
== O_constant
)
2282 return tic6x_match_matches
;
2284 return tic6x_match_bad_mem
;
2287 case tic6x_operand_mem_long
:
2288 if (op
->value
.mem
.base_reg
.side
== 2
2289 && (op
->value
.mem
.base_reg
.num
== 14
2290 || op
->value
.mem
.base_reg
.num
== 15))
2292 switch (op
->value
.mem
.mod
)
2294 case tic6x_mem_mod_none
:
2295 if (op
->value
.mem
.scaled
!= tic6x_offset_none
)
2297 return tic6x_match_matches
;
2299 case tic6x_mem_mod_plus
:
2300 if (op
->value
.mem
.scaled
== tic6x_offset_none
)
2302 if (op
->value
.mem
.offset_is_reg
)
2303 return tic6x_match_bad_mem
;
2304 else if (op
->value
.mem
.scaled
== tic6x_offset_scaled
2305 && op
->value
.mem
.offset
.exp
.X_op
!= O_constant
)
2306 return tic6x_match_bad_mem
;
2308 return tic6x_match_matches
;
2310 case tic6x_mem_mod_minus
:
2311 case tic6x_mem_mod_preinc
:
2312 case tic6x_mem_mod_predec
:
2313 case tic6x_mem_mod_postinc
:
2314 case tic6x_mem_mod_postdec
:
2315 return tic6x_match_bad_mem
;
2323 return tic6x_match_bad_mem
;
2330 /* Return the number of bits shift used with DP-relative coding method
2334 tic6x_dpr_shift (tic6x_coding_method coding
)
2338 case tic6x_coding_ulcst_dpr_byte
:
2341 case tic6x_coding_ulcst_dpr_half
:
2344 case tic6x_coding_ulcst_dpr_word
:
2352 /* Return the relocation used with DP-relative coding method
2355 static bfd_reloc_code_real_type
2356 tic6x_dpr_reloc (tic6x_coding_method coding
)
2360 case tic6x_coding_ulcst_dpr_byte
:
2361 return BFD_RELOC_C6000_SBR_U15_B
;
2363 case tic6x_coding_ulcst_dpr_half
:
2364 return BFD_RELOC_C6000_SBR_U15_H
;
2366 case tic6x_coding_ulcst_dpr_word
:
2367 return BFD_RELOC_C6000_SBR_U15_W
;
2374 /* Given a memory reference *MEM_REF as originally parsed, fill in
2375 defaults for missing offsets. */
2378 tic6x_default_mem_ref (tic6x_mem_ref
*mem_ref
)
2380 switch (mem_ref
->mod
)
2382 case tic6x_mem_mod_none
:
2383 if (mem_ref
->scaled
!= tic6x_offset_none
)
2385 mem_ref
->mod
= tic6x_mem_mod_plus
;
2386 mem_ref
->scaled
= tic6x_offset_unscaled
;
2387 mem_ref
->offset_is_reg
= FALSE
;
2388 memset (&mem_ref
->offset
.exp
, 0, sizeof mem_ref
->offset
.exp
);
2389 mem_ref
->offset
.exp
.X_op
= O_constant
;
2390 mem_ref
->offset
.exp
.X_add_number
= 0;
2391 mem_ref
->offset
.exp
.X_unsigned
= 0;
2394 case tic6x_mem_mod_plus
:
2395 case tic6x_mem_mod_minus
:
2396 if (mem_ref
->scaled
== tic6x_offset_none
)
2400 case tic6x_mem_mod_preinc
:
2401 case tic6x_mem_mod_predec
:
2402 case tic6x_mem_mod_postinc
:
2403 case tic6x_mem_mod_postdec
:
2404 if (mem_ref
->scaled
!= tic6x_offset_none
)
2406 mem_ref
->scaled
= tic6x_offset_scaled
;
2407 mem_ref
->offset_is_reg
= FALSE
;
2408 memset (&mem_ref
->offset
.exp
, 0, sizeof mem_ref
->offset
.exp
);
2409 mem_ref
->offset
.exp
.X_op
= O_constant
;
2410 mem_ref
->offset
.exp
.X_add_number
= 1;
2411 mem_ref
->offset
.exp
.X_unsigned
= 0;
2419 /* Return the encoding in the 8-bit field of an SPMASK or SPMASKR
2420 instruction of the specified UNIT, side SIDE. */
2423 tic6x_encode_spmask (tic6x_func_unit_base unit
, unsigned int side
)
2427 case tic6x_func_unit_l
:
2428 return 1 << (side
- 1);
2430 case tic6x_func_unit_s
:
2431 return 1 << (side
+ 1);
2433 case tic6x_func_unit_d
:
2434 return 1 << (side
+ 3);
2436 case tic6x_func_unit_m
:
2437 return 1 << (side
+ 5);
2444 /* Try to encode the instruction with opcode number ID and operands
2445 OPERANDS (number NUM_OPERANDS), creg value THIS_LINE_CREG and z
2446 value THIS_LINE_Z; FUNC_UNIT_SIDE, FUNC_UNIT_CROSS and
2447 FUNC_UNIT_DATA_SIDE describe the functional unit specification;
2448 SPLOOP_II is the ii value from the previous SPLOOP-family
2449 instruction, or 0 if not in such a loop; the only possible problems
2450 are operands being out of range (they already match the
2451 fine-grained form), and inappropriate predication. If this
2452 succeeds, return the encoding and set *OK to TRUE; otherwise return
2453 0 and set *OK to FALSE. If a fix is needed, set *FIX_NEEDED to
2454 true and fill in *FIX_EXP, *FIX_PCREL, *FX_R_TYPE and *FIX_ADDA.
2455 Print error messages for failure if PRINT_ERRORS is TRUE; the
2456 opcode starts at STR and has length OPC_LEN. */
2459 tic6x_try_encode (tic6x_opcode_id id
, tic6x_operand
*operands
,
2460 unsigned int num_operands
, unsigned int this_line_creg
,
2461 unsigned int this_line_z
, unsigned int func_unit_side
,
2462 unsigned int func_unit_cross
,
2463 unsigned int func_unit_data_side
, int sploop_ii
,
2464 expressionS
**fix_exp
, int *fix_pcrel
,
2465 bfd_reloc_code_real_type
*fx_r_type
, bfd_boolean
*fix_adda
,
2466 bfd_boolean
*fix_needed
, bfd_boolean
*ok
,
2467 bfd_boolean print_errors
, char *str
, int opc_len
)
2469 const tic6x_opcode
*opct
;
2470 const tic6x_insn_format
*fmt
;
2471 unsigned int opcode_value
;
2474 opct
= &tic6x_opcode_table
[id
];
2475 fmt
= &tic6x_insn_format_table
[opct
->format
];
2476 opcode_value
= fmt
->cst_bits
;
2478 for (fld
= 0; fld
< opct
->num_fixed_fields
; fld
++)
2480 if (opct
->fixed_fields
[fld
].min_val
== opct
->fixed_fields
[fld
].max_val
)
2482 const tic6x_insn_field
*fldd
;
2483 fldd
= tic6x_field_from_fmt (fmt
, opct
->fixed_fields
[fld
].field_id
);
2486 opcode_value
|= opct
->fixed_fields
[fld
].min_val
<< fldd
->bitfields
[0].low_pos
;
2490 for (fld
= 0; fld
< opct
->num_variable_fields
; fld
++)
2492 const tic6x_insn_field
*fldd
;
2498 unsigned int fcyc_bits
;
2503 fldd
= tic6x_field_from_fmt (fmt
, opct
->variable_fields
[fld
].field_id
);
2506 opno
= opct
->variable_fields
[fld
].operand_num
;
2507 switch (opct
->variable_fields
[fld
].coding_method
)
2509 case tic6x_coding_ucst
:
2510 if (operands
[opno
].form
!= TIC6X_OP_EXP
)
2512 if (operands
[opno
].value
.exp
.X_op
!= O_constant
)
2514 ucexp
= operands
[opno
].value
.exp
;
2516 if (ucexp
.X_add_number
< 0
2517 || ucexp
.X_add_number
>= (1 << fldd
->bitfields
[0].width
))
2520 as_bad (_("operand %u of '%.*s' out of range"), opno
+ 1,
2525 value
= ucexp
.X_add_number
;
2528 case tic6x_coding_scst
:
2529 if (operands
[opno
].form
!= TIC6X_OP_EXP
)
2531 if (operands
[opno
].value
.exp
.X_op
!= O_constant
)
2534 /* Opcode table should not permit non-constants without
2535 a known relocation for them. */
2536 if (fldd
->bitfields
[0].low_pos
!= 7 || fldd
->bitfields
[0].width
!= 16)
2539 *fix_exp
= &operands
[opno
].value
.exp
;
2541 *fx_r_type
= BFD_RELOC_C6000_ABS_S16
;
2545 sign_value
= SEXT (operands
[opno
].value
.exp
.X_add_number
);
2547 if (sign_value
< -(1 << (fldd
->bitfields
[0].width
- 1))
2548 || (sign_value
>= (1 << (fldd
->bitfields
[0].width
- 1))))
2551 as_bad (_("operand %u of '%.*s' out of range"), opno
+ 1,
2556 value
= sign_value
+ (1 << (fldd
->bitfields
[0].width
- 1));
2557 value
^= (1 << (fldd
->bitfields
[0].width
- 1));
2560 case tic6x_coding_ucst_minus_one
:
2561 if (operands
[opno
].form
!= TIC6X_OP_EXP
)
2563 if (operands
[opno
].value
.exp
.X_op
!= O_constant
)
2565 if (operands
[opno
].value
.exp
.X_add_number
<= 0
2566 || operands
[opno
].value
.exp
.X_add_number
> (1 << fldd
->bitfields
[0].width
))
2569 as_bad (_("operand %u of '%.*s' out of range"), opno
+ 1,
2574 value
= operands
[opno
].value
.exp
.X_add_number
- 1;
2577 case tic6x_coding_scst_negate
:
2578 if (operands
[opno
].form
!= TIC6X_OP_EXP
)
2580 if (operands
[opno
].value
.exp
.X_op
!= O_constant
)
2582 sign_value
= SEXT (-operands
[opno
].value
.exp
.X_add_number
);
2583 goto signed_constant
;
2585 case tic6x_coding_ulcst_dpr_byte
:
2586 case tic6x_coding_ulcst_dpr_half
:
2587 case tic6x_coding_ulcst_dpr_word
:
2588 bits
= tic6x_dpr_shift (opct
->variable_fields
[fld
].coding_method
);
2589 switch (operands
[opno
].form
)
2592 if (operands
[opno
].value
.exp
.X_op
== O_constant
)
2594 ucexp
= operands
[opno
].value
.exp
;
2595 goto unsigned_constant
;
2597 expp
= &operands
[opno
].value
.exp
;
2600 case TIC6X_OP_MEM_NOUNREG
:
2601 mem
= operands
[opno
].value
.mem
;
2602 tic6x_default_mem_ref (&mem
);
2603 if (mem
.offset_is_reg
)
2605 if (mem
.offset
.exp
.X_op
== O_constant
)
2607 ucexp
= mem
.offset
.exp
;
2608 if (mem
.scaled
== tic6x_offset_unscaled
)
2610 if (ucexp
.X_add_number
& ((1 << bits
) - 1))
2613 as_bad (_("offset in operand %u of '%.*s' not "
2614 "divisible by %u"), opno
+ 1, opc_len
,
2619 ucexp
.X_add_number
>>= bits
;
2621 goto unsigned_constant
;
2623 if (mem
.scaled
!= tic6x_offset_unscaled
)
2625 if (operands
[opno
].value
.mem
.mod
== tic6x_mem_mod_none
2626 || operands
[opno
].value
.mem
.scaled
!= tic6x_offset_unscaled
2627 || operands
[opno
].value
.mem
.offset_is_reg
)
2629 expp
= &operands
[opno
].value
.mem
.offset
.exp
;
2636 /* Opcode table should not use this encoding without a known
2638 if (fldd
->bitfields
[0].low_pos
!= 8 || fldd
->bitfields
[0].width
!= 15)
2640 /* We do not check for offset divisibility here; such a
2641 check is not needed at this point to encode the value,
2642 and if there is eventually a problem it will be detected
2643 either in md_apply_fix or at link time. */
2648 = tic6x_dpr_reloc (opct
->variable_fields
[fld
].coding_method
);
2649 if (operands
[opno
].form
== TIC6X_OP_EXP
)
2655 case tic6x_coding_lcst_low16
:
2656 if (operands
[opno
].form
!= TIC6X_OP_EXP
)
2658 if (operands
[opno
].value
.exp
.X_op
== O_constant
)
2659 value
= operands
[opno
].value
.exp
.X_add_number
& 0xffff;
2663 /* Opcode table should not use this encoding without a
2664 known relocation. */
2665 if (fldd
->bitfields
[0].low_pos
!= 7 || fldd
->bitfields
[0].width
!= 16)
2668 *fix_exp
= &operands
[opno
].value
.exp
;
2670 *fx_r_type
= BFD_RELOC_C6000_ABS_L16
;
2675 case tic6x_coding_lcst_high16
:
2676 if (operands
[opno
].form
!= TIC6X_OP_EXP
)
2678 if (operands
[opno
].value
.exp
.X_op
== O_constant
)
2679 value
= (operands
[opno
].value
.exp
.X_add_number
>> 16) & 0xffff;
2683 /* Opcode table should not use this encoding without a
2684 known relocation. */
2685 if (fldd
->bitfields
[0].low_pos
!= 7 || fldd
->bitfields
[0].width
!= 16)
2688 *fix_exp
= &operands
[opno
].value
.exp
;
2690 *fx_r_type
= BFD_RELOC_C6000_ABS_H16
;
2695 case tic6x_coding_pcrel
:
2696 case tic6x_coding_pcrel_half
:
2697 if (operands
[opno
].form
!= TIC6X_OP_EXP
)
2701 *fix_exp
= &operands
[opno
].value
.exp
;
2703 if (fldd
->bitfields
[0].low_pos
== 7 && fldd
->bitfields
[0].width
== 21)
2704 *fx_r_type
= BFD_RELOC_C6000_PCR_S21
;
2705 else if (fldd
->bitfields
[0].low_pos
== 16 && fldd
->bitfields
[0].width
== 12)
2706 *fx_r_type
= BFD_RELOC_C6000_PCR_S12
;
2707 else if (fldd
->bitfields
[0].low_pos
== 13 && fldd
->bitfields
[0].width
== 10)
2708 *fx_r_type
= BFD_RELOC_C6000_PCR_S10
;
2709 else if (fldd
->bitfields
[0].low_pos
== 16 && fldd
->bitfields
[0].width
== 7)
2710 *fx_r_type
= BFD_RELOC_C6000_PCR_S7
;
2712 /* Opcode table should not use this encoding without a
2713 known relocation. */
2718 case tic6x_coding_regpair_lsb
:
2719 switch (operands
[opno
].form
)
2721 case TIC6X_OP_REGPAIR
:
2722 value
= operands
[opno
].value
.reg
.num
;
2730 case tic6x_coding_regpair_msb
:
2731 switch (operands
[opno
].form
)
2733 case TIC6X_OP_REGPAIR
:
2734 value
= operands
[opno
].value
.reg
.num
+ 1;
2742 case tic6x_coding_reg
:
2743 switch (operands
[opno
].form
)
2746 case TIC6X_OP_REGPAIR
:
2747 value
= operands
[opno
].value
.reg
.num
;
2750 case TIC6X_OP_MEM_NOUNREG
:
2751 case TIC6X_OP_MEM_UNREG
:
2752 value
= operands
[opno
].value
.mem
.base_reg
.num
;
2760 case tic6x_coding_areg
:
2761 switch (operands
[opno
].form
)
2764 value
= (operands
[opno
].value
.reg
.num
== 15 ? 1 : 0);
2767 case TIC6X_OP_MEM_NOUNREG
:
2768 value
= (operands
[opno
].value
.mem
.base_reg
.num
== 15 ? 1 : 0);
2776 case tic6x_coding_crlo
:
2777 if (operands
[opno
].form
!= TIC6X_OP_CTRL
)
2779 value
= tic6x_ctrl_table
[operands
[opno
].value
.ctrl
].crlo
;
2782 case tic6x_coding_crhi
:
2783 if (operands
[opno
].form
!= TIC6X_OP_CTRL
)
2788 case tic6x_coding_reg_shift
:
2789 if (operands
[opno
].form
!= TIC6X_OP_REGPAIR
)
2791 value
= operands
[opno
].value
.reg
.num
>> 1;
2794 case tic6x_coding_mem_offset
:
2795 if (operands
[opno
].form
!= TIC6X_OP_MEM_NOUNREG
)
2797 mem
= operands
[opno
].value
.mem
;
2798 tic6x_default_mem_ref (&mem
);
2799 if (mem
.offset_is_reg
)
2801 if (mem
.scaled
!= tic6x_offset_scaled
)
2803 value
= mem
.offset
.reg
.num
;
2809 if (mem
.offset
.exp
.X_op
!= O_constant
)
2813 case tic6x_offset_scaled
:
2817 case tic6x_offset_unscaled
:
2818 scale
= opct
->operand_info
[opno
].size
;
2819 if (scale
!= 1 && scale
!= 2 && scale
!= 4 && scale
!= 8)
2826 if (mem
.offset
.exp
.X_add_number
< 0
2827 || mem
.offset
.exp
.X_add_number
>= (1 << fldd
->bitfields
[0].width
) * scale
)
2830 as_bad (_("offset in operand %u of '%.*s' out of range"),
2831 opno
+ 1, opc_len
, str
);
2835 if (mem
.offset
.exp
.X_add_number
% scale
)
2838 as_bad (_("offset in operand %u of '%.*s' not "
2840 opno
+ 1, opc_len
, str
, scale
);
2844 value
= mem
.offset
.exp
.X_add_number
/ scale
;
2848 case tic6x_coding_mem_offset_noscale
:
2849 if (operands
[opno
].form
!= TIC6X_OP_MEM_UNREG
)
2851 mem
= operands
[opno
].value
.mem
;
2852 tic6x_default_mem_ref (&mem
);
2853 if (mem
.offset_is_reg
)
2854 value
= mem
.offset
.reg
.num
;
2857 if (mem
.offset
.exp
.X_op
!= O_constant
)
2859 if (mem
.offset
.exp
.X_add_number
< 0
2860 || mem
.offset
.exp
.X_add_number
>= (1 << fldd
->bitfields
[0].width
))
2863 as_bad (_("offset in operand %u of '%.*s' out of range"),
2864 opno
+ 1, opc_len
, str
);
2868 value
= mem
.offset
.exp
.X_add_number
;
2872 case tic6x_coding_mem_mode
:
2873 if (operands
[opno
].form
!= TIC6X_OP_MEM_NOUNREG
2874 && operands
[opno
].form
!= TIC6X_OP_MEM_UNREG
)
2876 mem
= operands
[opno
].value
.mem
;
2877 tic6x_default_mem_ref (&mem
);
2880 case tic6x_mem_mod_plus
:
2884 case tic6x_mem_mod_minus
:
2888 case tic6x_mem_mod_preinc
:
2892 case tic6x_mem_mod_predec
:
2896 case tic6x_mem_mod_postinc
:
2900 case tic6x_mem_mod_postdec
:
2907 value
+= (mem
.offset_is_reg
? 4 : 0);
2910 case tic6x_coding_scaled
:
2911 if (operands
[opno
].form
!= TIC6X_OP_MEM_UNREG
)
2913 mem
= operands
[opno
].value
.mem
;
2914 tic6x_default_mem_ref (&mem
);
2917 case tic6x_offset_unscaled
:
2921 case tic6x_offset_scaled
:
2930 case tic6x_coding_spmask
:
2931 /* The position of such a field is hardcoded in the handling
2933 if (fldd
->bitfields
[0].low_pos
!= 18)
2936 for (opno
= 0; opno
< num_operands
; opno
++)
2940 v
= tic6x_encode_spmask (operands
[opno
].value
.func_unit
.base
,
2941 operands
[opno
].value
.func_unit
.side
);
2945 as_bad (_("functional unit already masked for operand "
2946 "%u of '%.*s'"), opno
+ 1, opc_len
, str
);
2954 case tic6x_coding_reg_unused
:
2955 /* This is a placeholder; correct handling goes along with
2956 resource constraint checks. */
2960 case tic6x_coding_fstg
:
2961 case tic6x_coding_fcyc
:
2962 if (operands
[opno
].form
!= TIC6X_OP_EXP
)
2964 if (operands
[opno
].value
.exp
.X_op
!= O_constant
)
2969 as_bad (_("'%.*s' instruction not in a software "
2978 else if (sploop_ii
<= 2)
2980 else if (sploop_ii
<= 4)
2982 else if (sploop_ii
<= 8)
2984 else if (sploop_ii
<= 14)
2988 if (fcyc_bits
> fldd
->bitfields
[0].width
)
2991 if (opct
->variable_fields
[fld
].coding_method
== tic6x_coding_fstg
)
2994 if (operands
[opno
].value
.exp
.X_add_number
< 0
2995 || (operands
[opno
].value
.exp
.X_add_number
2996 >= (1 << (fldd
->bitfields
[0].width
- fcyc_bits
))))
2999 as_bad (_("operand %u of '%.*s' out of range"), opno
+ 1,
3004 value
= operands
[opno
].value
.exp
.X_add_number
;
3005 for (t
= 0, i
= fcyc_bits
; i
< fldd
->bitfields
[0].width
; i
++)
3007 t
= (t
<< 1) | (value
& 1);
3010 value
= t
<< fcyc_bits
;
3014 if (operands
[opno
].value
.exp
.X_add_number
< 0
3015 || (operands
[opno
].value
.exp
.X_add_number
>= sploop_ii
))
3018 as_bad (_("operand %u of '%.*s' out of range"), opno
+ 1,
3023 value
= operands
[opno
].value
.exp
.X_add_number
;
3027 case tic6x_coding_fu
:
3028 value
= func_unit_side
== 2 ? 1 : 0;
3031 case tic6x_coding_data_fu
:
3032 value
= func_unit_data_side
== 2 ? 1 : 0;
3035 case tic6x_coding_xpath
:
3036 value
= func_unit_cross
;
3043 for (ffld
= 0; ffld
< opct
->num_fixed_fields
; ffld
++)
3044 if ((opct
->fixed_fields
[ffld
].field_id
3045 == opct
->variable_fields
[fld
].field_id
)
3046 && (value
< opct
->fixed_fields
[ffld
].min_val
3047 || value
> opct
->fixed_fields
[ffld
].max_val
))
3050 as_bad (_("operand %u of '%.*s' out of range"), opno
+ 1,
3056 opcode_value
|= value
<< fldd
->bitfields
[0].low_pos
;
3061 const tic6x_insn_field
*creg
;
3062 const tic6x_insn_field
*z
;
3064 creg
= tic6x_field_from_fmt (fmt
, tic6x_field_creg
);
3068 as_bad (_("instruction '%.*s' cannot be predicated"),
3073 z
= tic6x_field_from_fmt (fmt
, tic6x_field_z
);
3074 /* If there is a creg field, there must be a z field; otherwise
3075 there is an error in the format table. */
3079 opcode_value
|= this_line_creg
<< creg
->bitfields
[0].low_pos
;
3080 opcode_value
|= this_line_z
<< z
->bitfields
[0].low_pos
;
3084 return opcode_value
;
3087 /* Convert the target integer stored in N bytes in BUF to a host
3088 integer, returning that value. */
3091 md_chars_to_number (char *buf
, int n
)
3094 unsigned char *p
= (unsigned char *) buf
;
3096 if (target_big_endian
)
3101 result
|= (*p
++ & 0xff);
3109 result
|= (p
[n
] & 0xff);
3116 /* Assemble the instruction starting at STR (an opcode, with the
3117 opcode name all-lowercase). */
3120 md_assemble (char *str
)
3124 bfd_boolean this_line_parallel
;
3125 bfd_boolean this_line_spmask
;
3126 unsigned int this_line_creg
;
3127 unsigned int this_line_z
;
3128 tic6x_label_list
*this_insn_label_list
;
3129 segment_info_type
*seginfo
;
3130 tic6x_opcode_list
*opc_list
, *opc
;
3131 tic6x_func_unit_base func_unit_base
= tic6x_func_unit_nfu
;
3132 unsigned int func_unit_side
= 0;
3133 unsigned int func_unit_cross
= 0;
3134 unsigned int cross_side
= 0;
3135 unsigned int func_unit_data_side
= 0;
3136 unsigned int max_matching_opcodes
, num_matching_opcodes
;
3137 tic6x_opcode_id
*opcm
= NULL
;
3138 unsigned int opc_rank
[TIC6X_NUM_PREFER
];
3139 const tic6x_opcode
*opct
= NULL
;
3140 int min_rank
, try_rank
, max_rank
;
3141 bfd_boolean num_operands_permitted
[TIC6X_MAX_SOURCE_OPERANDS
+ 1]
3143 unsigned int operand_forms
[TIC6X_MAX_SOURCE_OPERANDS
] = { 0 };
3144 tic6x_operand operands
[TIC6X_MAX_SOURCE_OPERANDS
];
3145 unsigned int max_num_operands
;
3146 unsigned int num_operands_read
;
3147 bfd_boolean ok_this_arch
, ok_this_fu
, ok_this_arch_fu
;
3148 bfd_boolean bad_operands
= FALSE
;
3149 unsigned int opcode_value
;
3150 bfd_boolean encoded_ok
;
3151 bfd_boolean fix_needed
= FALSE
;
3152 expressionS
*fix_exp
= NULL
;
3154 bfd_reloc_code_real_type fx_r_type
= BFD_RELOC_UNUSED
;
3155 bfd_boolean fix_adda
= FALSE
;
3160 while (*p
&& !is_end_of_line
[(unsigned char) *p
] && *p
!= ' ')
3163 /* This function should only have been called when there is actually
3164 an instruction to assemble. */
3168 /* Now an instruction has been seen, architecture attributes from
3169 .arch directives merge with rather than overriding the previous
3171 tic6x_seen_insns
= TRUE
;
3172 /* If no .arch directives or -march options have been seen, we are
3173 assessing instruction validity based on the C674X default, so set
3174 the attribute accordingly. */
3175 if (tic6x_arch_attribute
== C6XABI_Tag_ISA_none
)
3176 tic6x_arch_attribute
= C6XABI_Tag_ISA_C674X
;
3178 /* Reset global settings for parallel bars and predicates now to
3179 avoid extra errors if there are problems with this opcode. */
3180 this_line_parallel
= tic6x_line_parallel
;
3181 this_line_spmask
= tic6x_line_spmask
;
3182 this_line_creg
= tic6x_line_creg
;
3183 this_line_z
= tic6x_line_z
;
3184 tic6x_line_parallel
= FALSE
;
3185 tic6x_line_spmask
= FALSE
;
3186 tic6x_line_creg
= 0;
3188 seginfo
= seg_info (now_seg
);
3189 this_insn_label_list
= seginfo
->tc_segment_info_data
.label_list
;
3190 seginfo
->tc_segment_info_data
.label_list
= NULL
;
3192 opc_list
= hash_find_n (opcode_hash
, str
, p
- str
);
3193 if (opc_list
== NULL
)
3197 as_bad (_("unknown opcode '%s'"), str
);
3203 skip_whitespace (p
);
3205 /* See if there is something that looks like a functional unit
3209 bfd_boolean good_func_unit
;
3210 tic6x_func_unit_base maybe_base
= tic6x_func_unit_nfu
;
3211 unsigned int maybe_side
= 0;
3212 unsigned int maybe_cross
= 0;
3213 unsigned int maybe_data_side
= 0;
3215 good_func_unit
= tic6x_parse_func_unit_base (p
+ 1, &maybe_base
,
3220 if (p
[3] == ' ' || is_end_of_line
[(unsigned char) p
[3]])
3222 else if ((p
[3] == 'x' || p
[3] == 'X')
3223 && (p
[4] == ' ' || is_end_of_line
[(unsigned char) p
[4]]))
3228 else if (maybe_base
== tic6x_func_unit_d
3229 && (p
[3] == 't' || p
[3] == 'T')
3230 && (p
[4] == '1' || p
[4] == '2')
3231 && (p
[5] == ' ' || is_end_of_line
[(unsigned char) p
[5]]))
3233 maybe_data_side
= p
[4] - '0';
3237 good_func_unit
= FALSE
;
3242 func_unit_base
= maybe_base
;
3243 func_unit_side
= maybe_side
;
3244 func_unit_cross
= maybe_cross
;
3245 cross_side
= (func_unit_cross
? 3 - func_unit_side
: func_unit_side
);
3246 func_unit_data_side
= maybe_data_side
;
3249 skip_whitespace (p
);
3252 /* Determine which entries in the opcode table match, and the
3253 associated permitted forms of operands. */
3254 max_matching_opcodes
= 0;
3255 for (opc
= opc_list
; opc
; opc
= opc
->next
)
3256 max_matching_opcodes
++;
3257 num_matching_opcodes
= 0;
3258 opcm
= xmalloc (max_matching_opcodes
* sizeof (*opcm
));
3259 max_num_operands
= 0;
3260 ok_this_arch
= FALSE
;
3262 ok_this_arch_fu
= FALSE
;
3263 for (opc
= opc_list
; opc
; opc
= opc
->next
)
3265 unsigned int num_operands
;
3267 bfd_boolean this_opc_arch_ok
= TRUE
;
3268 bfd_boolean this_opc_fu_ok
= TRUE
;
3270 if (tic6x_insn_format_table
[tic6x_opcode_table
[opc
->id
].format
].num_bits
3273 if (!(tic6x_opcode_table
[opc
->id
].isa_variants
& tic6x_features
))
3274 this_opc_arch_ok
= FALSE
;
3275 if (tic6x_opcode_table
[opc
->id
].func_unit
!= func_unit_base
)
3276 this_opc_fu_ok
= FALSE
;
3277 if (func_unit_side
== 1
3278 && (tic6x_opcode_table
[opc
->id
].flags
& TIC6X_FLAG_SIDE_B_ONLY
))
3279 this_opc_fu_ok
= FALSE
;
3281 && (tic6x_opcode_table
[opc
->id
].flags
& TIC6X_FLAG_NO_CROSS
))
3282 this_opc_fu_ok
= FALSE
;
3283 if (!func_unit_data_side
3284 && (tic6x_opcode_table
[opc
->id
].flags
3285 & (TIC6X_FLAG_LOAD
| TIC6X_FLAG_STORE
)))
3286 this_opc_fu_ok
= FALSE
;
3287 if (func_unit_data_side
3288 && !(tic6x_opcode_table
[opc
->id
].flags
3289 & (TIC6X_FLAG_LOAD
| TIC6X_FLAG_STORE
)))
3290 this_opc_fu_ok
= FALSE
;
3291 if (func_unit_data_side
== 1
3292 && (tic6x_opcode_table
[opc
->id
].flags
& TIC6X_FLAG_SIDE_T2_ONLY
))
3293 this_opc_fu_ok
= FALSE
;
3294 if (this_opc_arch_ok
)
3295 ok_this_arch
= TRUE
;
3298 if (!this_opc_arch_ok
|| !this_opc_fu_ok
)
3300 ok_this_arch_fu
= TRUE
;
3301 opcm
[num_matching_opcodes
] = opc
->id
;
3302 num_matching_opcodes
++;
3303 num_operands
= tic6x_opcode_table
[opc
->id
].num_operands
;
3305 if (tic6x_opcode_table
[opc
->id
].flags
& TIC6X_FLAG_SPMASK
)
3307 if (num_operands
!= 1
3308 || (tic6x_opcode_table
[opc
->id
].operand_info
[0].form
3309 != tic6x_operand_func_unit
))
3312 for (i
= 0; i
< num_operands
; i
++)
3315 |= tic6x_coarse_operand_form (tic6x_operand_func_unit
);
3316 num_operands_permitted
[i
] = TRUE
;
3321 for (i
= 0; i
< num_operands
; i
++)
3323 tic6x_operand_form f
3324 = tic6x_opcode_table
[opc
->id
].operand_info
[i
].form
;
3326 operand_forms
[i
] |= tic6x_coarse_operand_form (f
);
3329 num_operands_permitted
[num_operands
] = TRUE
;
3330 if (num_operands
> max_num_operands
)
3331 max_num_operands
= num_operands
;
3336 as_bad (_("'%.*s' instruction not supported on this architecture"),
3344 as_bad (_("'%.*s' instruction not supported on this functional unit"),
3350 if (!ok_this_arch_fu
)
3352 as_bad (_("'%.*s' instruction not supported on this functional unit"
3353 " for this architecture"),
3359 /* If there were no instructions matching the above availability
3360 checks, we should now have given an error and returned. */
3361 if (num_matching_opcodes
== 0)
3364 num_operands_read
= 0;
3367 skip_whitespace (p
);
3368 if (is_end_of_line
[(unsigned char) *p
])
3370 if (num_operands_read
> 0)
3372 as_bad (_("missing operand after comma"));
3373 bad_operands
= TRUE
;
3378 if (max_num_operands
== 0)
3380 as_bad (_("too many operands to '%.*s'"), opc_len
, str
);
3381 bad_operands
= TRUE
;
3385 if (!tic6x_parse_operand (&p
, &operands
[num_operands_read
],
3386 operand_forms
[num_operands_read
], str
, opc_len
,
3387 num_operands_read
+ 1))
3388 bad_operands
= TRUE
;
3389 num_operands_read
++;
3391 if (is_end_of_line
[(unsigned char) *p
])
3396 if (num_operands_read
== max_num_operands
)
3398 as_bad (_("too many operands to '%.*s'"), opc_len
, str
);
3399 bad_operands
= TRUE
;
3405 /* Operand parsing should consume whole operands. */
3409 if (!bad_operands
&& !num_operands_permitted
[num_operands_read
])
3411 as_bad (_("bad number of operands to '%.*s'"), opc_len
, str
);
3412 bad_operands
= TRUE
;
3417 /* Each operand is of the right syntactic form for some opcode
3418 choice, and the number of operands is valid. Check that each
3419 operand is OK in detail for some opcode choice with the right
3420 number of operands. */
3423 for (i
= 0; i
< num_operands_read
; i
++)
3425 bfd_boolean coarse_ok
= FALSE
;
3426 bfd_boolean fine_ok
= FALSE
;
3427 tic6x_operand_match fine_failure
= tic6x_match_matches
;
3430 for (j
= 0; j
< num_matching_opcodes
; j
++)
3432 tic6x_operand_form f
;
3435 tic6x_operand_match this_fine_failure
;
3437 if (tic6x_opcode_table
[opcm
[j
]].flags
& TIC6X_FLAG_SPMASK
)
3439 f
= tic6x_operand_func_unit
;
3444 if (tic6x_opcode_table
[opcm
[j
]].num_operands
3445 != num_operands_read
)
3448 f
= tic6x_opcode_table
[opcm
[j
]].operand_info
[i
].form
;
3449 rw
= tic6x_opcode_table
[opcm
[j
]].operand_info
[i
].rw
;
3451 cf
= tic6x_coarse_operand_form (f
);
3453 if (operands
[i
].form
!= cf
)
3458 = tic6x_operand_matches_form (&operands
[i
], f
, rw
,
3461 func_unit_data_side
);
3462 if (this_fine_failure
== tic6x_match_matches
)
3467 if (fine_failure
== tic6x_match_matches
3468 || fine_failure
> this_fine_failure
)
3469 fine_failure
= this_fine_failure
;
3472 /* No instructions should have operand syntactic forms only
3473 acceptable with certain numbers of operands, so no
3474 diagnostic for this case. */
3480 switch (fine_failure
)
3482 case tic6x_match_non_const
:
3483 as_bad (_("operand %u of '%.*s' not constant"),
3484 i
+ 1, opc_len
, str
);
3487 case tic6x_match_wrong_side
:
3488 as_bad (_("operand %u of '%.*s' on wrong side"),
3489 i
+ 1, opc_len
, str
);
3492 case tic6x_match_bad_return
:
3493 as_bad (_("operand %u of '%.*s' not a valid return "
3494 "address register"),
3495 i
+ 1, opc_len
, str
);
3498 case tic6x_match_ctrl_write_only
:
3499 as_bad (_("operand %u of '%.*s' is write-only"),
3500 i
+ 1, opc_len
, str
);
3503 case tic6x_match_ctrl_read_only
:
3504 as_bad (_("operand %u of '%.*s' is read-only"),
3505 i
+ 1, opc_len
, str
);
3508 case tic6x_match_bad_mem
:
3509 as_bad (_("operand %u of '%.*s' not a valid memory "
3511 i
+ 1, opc_len
, str
);
3514 case tic6x_match_bad_address
:
3515 as_bad (_("operand %u of '%.*s' not a valid base "
3516 "address register"),
3517 i
+ 1, opc_len
, str
);
3523 bad_operands
= TRUE
;
3531 /* Each operand is OK for some opcode choice, and the number of
3532 operands is valid. Check whether there is an opcode choice
3533 for which all operands are simultaneously valid. */
3535 bfd_boolean found_match
= FALSE
;
3537 for (i
= 0; i
< TIC6X_NUM_PREFER
; i
++)
3538 opc_rank
[i
] = (unsigned int) -1;
3540 min_rank
= TIC6X_NUM_PREFER
- 1;
3543 for (i
= 0; i
< num_matching_opcodes
; i
++)
3546 bfd_boolean this_matches
= TRUE
;
3548 if (!(tic6x_opcode_table
[opcm
[i
]].flags
& TIC6X_FLAG_SPMASK
)
3549 && tic6x_opcode_table
[opcm
[i
]].num_operands
!= num_operands_read
)
3552 for (j
= 0; j
< num_operands_read
; j
++)
3554 tic6x_operand_form f
;
3557 if (tic6x_opcode_table
[opcm
[i
]].flags
& TIC6X_FLAG_SPMASK
)
3559 f
= tic6x_operand_func_unit
;
3564 f
= tic6x_opcode_table
[opcm
[i
]].operand_info
[j
].form
;
3565 rw
= tic6x_opcode_table
[opcm
[i
]].operand_info
[j
].rw
;
3567 if (tic6x_operand_matches_form (&operands
[j
], f
, rw
,
3570 func_unit_data_side
)
3571 != tic6x_match_matches
)
3573 this_matches
= FALSE
;
3580 int rank
= TIC6X_PREFER_VAL (tic6x_opcode_table
[opcm
[i
]].flags
);
3582 if (rank
< min_rank
)
3584 if (rank
> max_rank
)
3587 if (opc_rank
[rank
] == (unsigned int) -1)
3590 /* The opcode table should provide a total ordering
3591 for all cases where multiple matches may get
3601 as_bad (_("bad operand combination for '%.*s'"), opc_len
, str
);
3602 bad_operands
= TRUE
;
3614 for (try_rank
= max_rank
; try_rank
>= min_rank
; try_rank
--)
3618 if (opc_rank
[try_rank
] == (unsigned int) -1)
3621 opcode_value
= tic6x_try_encode (opcm
[opc_rank
[try_rank
]], operands
,
3622 num_operands_read
, this_line_creg
,
3623 this_line_z
, func_unit_side
,
3624 func_unit_cross
, func_unit_data_side
,
3625 seginfo
->tc_segment_info_data
.sploop_ii
,
3626 &fix_exp
, &fix_pcrel
, &fx_r_type
,
3627 &fix_adda
, &fix_needed
, &encoded_ok
,
3628 (try_rank
== min_rank
? TRUE
: FALSE
),
3632 opct
= &tic6x_opcode_table
[opcm
[opc_rank
[try_rank
]]];
3642 if (this_line_parallel
)
3644 insn_frag
= seginfo
->tc_segment_info_data
.execute_packet_frag
;
3645 if (insn_frag
== NULL
)
3647 as_bad (_("parallel instruction not following another instruction"));
3651 if (insn_frag
->fr_fix
>= 32)
3653 as_bad (_("too many instructions in execute packet"));
3657 if (this_insn_label_list
!= NULL
)
3658 as_bad (_("label not at start of execute packet"));
3660 if (opct
->flags
& TIC6X_FLAG_FIRST
)
3661 as_bad (_("'%.*s' instruction not at start of execute packet"),
3664 *seginfo
->tc_segment_info_data
.last_insn_lsb
|= 0x1;
3665 output
= insn_frag
->fr_literal
+ insn_frag
->fr_fix
;
3669 tic6x_label_list
*l
;
3671 seginfo
->tc_segment_info_data
.spmask_addr
= NULL
;
3672 seginfo
->tc_segment_info_data
.func_units_used
= 0;
3674 /* Start a new frag for this execute packet. */
3675 if (frag_now_fix () != 0)
3677 if (frag_now
->fr_type
!= rs_machine_dependent
)
3678 frag_wane (frag_now
);
3683 insn_frag
= seginfo
->tc_segment_info_data
.execute_packet_frag
= frag_now
;
3684 for (l
= this_insn_label_list
; l
; l
= l
->next
)
3686 symbol_set_frag (l
->label
, frag_now
);
3687 S_SET_VALUE (l
->label
, 0);
3688 S_SET_SEGMENT (l
->label
, now_seg
);
3690 tic6x_free_label_list (this_insn_label_list
);
3691 dwarf2_emit_insn (0);
3692 output
= frag_var (rs_machine_dependent
, 32, 32, 0, NULL
, 0, NULL
);
3693 /* This must be the same as the frag to which a pointer was just
3695 if (output
!= insn_frag
->fr_literal
)
3697 insn_frag
->tc_frag_data
.is_insns
= TRUE
;
3698 insn_frag
->tc_frag_data
.can_cross_fp_boundary
3699 = tic6x_can_cross_fp_boundary
;
3702 if (func_unit_base
!= tic6x_func_unit_nfu
)
3704 unsigned int func_unit_enc
;
3706 func_unit_enc
= tic6x_encode_spmask (func_unit_base
, func_unit_side
);
3708 if (seginfo
->tc_segment_info_data
.func_units_used
& func_unit_enc
)
3709 as_bad (_("functional unit already used in this execute packet"));
3711 seginfo
->tc_segment_info_data
.func_units_used
|= func_unit_enc
;
3714 if (opct
->flags
& TIC6X_FLAG_SPLOOP
)
3716 if (seginfo
->tc_segment_info_data
.sploop_ii
)
3717 as_bad (_("nested software pipelined loop"));
3718 if (num_operands_read
!= 1
3719 || operands
[0].form
!= TIC6X_OP_EXP
3720 || operands
[0].value
.exp
.X_op
!= O_constant
)
3722 seginfo
->tc_segment_info_data
.sploop_ii
3723 = operands
[0].value
.exp
.X_add_number
;
3725 else if (opct
->flags
& TIC6X_FLAG_SPKERNEL
)
3727 if (!seginfo
->tc_segment_info_data
.sploop_ii
)
3728 as_bad (_("'%.*s' instruction not in a software pipelined loop"),
3730 seginfo
->tc_segment_info_data
.sploop_ii
= 0;
3733 if (this_line_spmask
)
3735 if (seginfo
->tc_segment_info_data
.spmask_addr
== NULL
)
3736 as_bad (_("'||^' without previous SPMASK"));
3737 else if (func_unit_base
== tic6x_func_unit_nfu
)
3738 as_bad (_("cannot mask instruction using no functional unit"));
3741 unsigned int spmask_opcode
;
3742 unsigned int mask_bit
;
3745 = md_chars_to_number (seginfo
->tc_segment_info_data
.spmask_addr
,
3747 mask_bit
= tic6x_encode_spmask (func_unit_base
, func_unit_side
);
3749 if (spmask_opcode
& mask_bit
)
3750 as_bad (_("functional unit already masked"));
3751 spmask_opcode
|= mask_bit
;
3752 md_number_to_chars (seginfo
->tc_segment_info_data
.spmask_addr
,
3757 record_alignment (now_seg
, 5);
3758 md_number_to_chars (output
, opcode_value
, 4);
3760 tic6x_fix_new_exp (insn_frag
, output
- insn_frag
->fr_literal
, 4, fix_exp
,
3761 fix_pcrel
, fx_r_type
, fix_adda
);
3762 insn_frag
->fr_fix
+= 4;
3763 insn_frag
->fr_var
-= 4;
3764 seginfo
->tc_segment_info_data
.last_insn_lsb
3765 = (target_big_endian
? output
+ 3 : output
);
3766 if (opct
->flags
& TIC6X_FLAG_SPMASK
)
3767 seginfo
->tc_segment_info_data
.spmask_addr
= output
;
3770 /* Modify NEWVAL (32-bit) by inserting VALUE, shifted right by SHIFT
3771 and the least significant BITS bits taken, at position POS. */
3772 #define MODIFY_VALUE(NEWVAL, VALUE, SHIFT, POS, BITS) \
3774 (NEWVAL) &= 0xffffffffU & ~(((1U << (BITS)) - 1) << (POS)); \
3775 (NEWVAL) |= (((VALUE) >> (SHIFT)) & ((1U << (BITS)) - 1)) << (POS); \
3778 /* Apply a fixup to the object file. */
3781 md_apply_fix (fixS
*fixP
, valueT
*valP
, segT seg ATTRIBUTE_UNUSED
)
3783 offsetT value
= *valP
;
3784 char *buf
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
3786 value
= SEXT (value
);
3789 fixP
->fx_offset
= SEXT (fixP
->fx_offset
);
3791 if (fixP
->fx_addsy
== NULL
&& fixP
->fx_pcrel
== 0)
3794 /* We do our own overflow checks. */
3795 fixP
->fx_no_overflow
= 1;
3797 switch (fixP
->fx_r_type
)
3799 case BFD_RELOC_NONE
:
3800 case BFD_RELOC_C6000_EHTYPE
:
3801 /* Force output to the object file. */
3806 if (fixP
->fx_done
|| !seg
->use_rela_p
)
3807 md_number_to_chars (buf
, value
, 4);
3811 if (fixP
->fx_done
|| !seg
->use_rela_p
)
3813 if (value
< -0x8000 || value
> 0xffff)
3814 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
3815 _("value too large for 2-byte field"));
3816 md_number_to_chars (buf
, value
, 2);
3821 if (fixP
->fx_done
|| !seg
->use_rela_p
)
3823 if (value
< -0x80 || value
> 0xff)
3824 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
3825 _("value too large for 1-byte field"));
3826 md_number_to_chars (buf
, value
, 1);
3830 case BFD_RELOC_C6000_ABS_S16
:
3831 case BFD_RELOC_C6000_ABS_L16
:
3832 case BFD_RELOC_C6000_SBR_S16
:
3833 case BFD_RELOC_C6000_SBR_L16_B
:
3834 case BFD_RELOC_C6000_SBR_L16_H
:
3835 case BFD_RELOC_C6000_SBR_L16_W
:
3836 case BFD_RELOC_C6000_SBR_GOT_L16_W
:
3837 if (fixP
->fx_done
|| !seg
->use_rela_p
)
3839 offsetT newval
= md_chars_to_number (buf
, 4);
3842 switch (fixP
->fx_r_type
)
3844 case BFD_RELOC_C6000_SBR_L16_H
:
3848 case BFD_RELOC_C6000_SBR_L16_W
:
3849 case BFD_RELOC_C6000_SBR_GOT_L16_W
:
3858 MODIFY_VALUE (newval
, value
, shift
, 7, 16);
3859 if ((value
< -0x8000 || value
> 0x7fff)
3860 && (fixP
->fx_r_type
== BFD_RELOC_C6000_ABS_S16
3861 || fixP
->fx_r_type
== BFD_RELOC_C6000_SBR_S16
))
3862 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
3863 _("immediate offset out of range"));
3865 md_number_to_chars (buf
, newval
, 4);
3868 && fixP
->fx_r_type
!= BFD_RELOC_C6000_ABS_S16
3869 && fixP
->fx_r_type
!= BFD_RELOC_C6000_ABS_L16
)
3873 case BFD_RELOC_C6000_ABS_H16
:
3874 case BFD_RELOC_C6000_SBR_H16_B
:
3875 case BFD_RELOC_C6000_SBR_H16_H
:
3876 case BFD_RELOC_C6000_SBR_H16_W
:
3877 case BFD_RELOC_C6000_SBR_GOT_H16_W
:
3878 if (fixP
->fx_done
|| !seg
->use_rela_p
)
3880 offsetT newval
= md_chars_to_number (buf
, 4);
3883 switch (fixP
->fx_r_type
)
3885 case BFD_RELOC_C6000_SBR_H16_H
:
3889 case BFD_RELOC_C6000_SBR_H16_W
:
3890 case BFD_RELOC_C6000_SBR_GOT_H16_W
:
3899 MODIFY_VALUE (newval
, value
, shift
, 7, 16);
3901 md_number_to_chars (buf
, newval
, 4);
3903 if (fixP
->fx_done
&& fixP
->fx_r_type
!= BFD_RELOC_C6000_ABS_H16
)
3907 case BFD_RELOC_C6000_PCR_H16
:
3908 case BFD_RELOC_C6000_PCR_L16
:
3909 if (fixP
->fx_done
|| !seg
->use_rela_p
)
3911 offsetT newval
= md_chars_to_number (buf
, 4);
3912 int shift
= fixP
->fx_r_type
== BFD_RELOC_C6000_PCR_H16
? 16 : 0;
3914 MODIFY_VALUE (newval
, value
, shift
, 7, 16);
3916 md_number_to_chars (buf
, newval
, 4);
3920 case BFD_RELOC_C6000_SBR_U15_B
:
3921 if (fixP
->fx_done
|| !seg
->use_rela_p
)
3923 offsetT newval
= md_chars_to_number (buf
, 4);
3925 MODIFY_VALUE (newval
, value
, 0, 8, 15);
3926 if (value
< 0 || value
> 0x7fff)
3927 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
3928 _("immediate offset out of range"));
3930 md_number_to_chars (buf
, newval
, 4);
3934 case BFD_RELOC_C6000_SBR_U15_H
:
3935 if (fixP
->fx_done
|| !seg
->use_rela_p
)
3937 offsetT newval
= md_chars_to_number (buf
, 4);
3939 /* Constant ADDA operands, processed as constant when the
3940 instruction is parsed, are encoded as-is rather than
3941 shifted. If the operand of an ADDA instruction is now
3942 constant (for example, the difference between two labels
3943 found after the instruction), ensure it is encoded the
3944 same way it would have been if the constant value had
3945 been known when the instruction was parsed. */
3946 if (fixP
->tc_fix_data
.fix_adda
&& fixP
->fx_done
)
3949 MODIFY_VALUE (newval
, value
, 1, 8, 15);
3951 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
3952 _("immediate offset not 2-byte-aligned"));
3953 if (value
< 0 || value
> 0xfffe)
3954 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
3955 _("immediate offset out of range"));
3957 md_number_to_chars (buf
, newval
, 4);
3961 case BFD_RELOC_C6000_SBR_U15_W
:
3962 case BFD_RELOC_C6000_SBR_GOT_U15_W
:
3963 if (fixP
->fx_done
|| !seg
->use_rela_p
)
3965 offsetT newval
= md_chars_to_number (buf
, 4);
3967 /* Constant ADDA operands, processed as constant when the
3968 instruction is parsed, are encoded as-is rather than
3969 shifted. If the operand of an ADDA instruction is now
3970 constant (for example, the difference between two labels
3971 found after the instruction), ensure it is encoded the
3972 same way it would have been if the constant value had
3973 been known when the instruction was parsed. */
3974 if (fixP
->tc_fix_data
.fix_adda
&& fixP
->fx_done
)
3977 MODIFY_VALUE (newval
, value
, 2, 8, 15);
3979 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
3980 _("immediate offset not 4-byte-aligned"));
3981 if (value
< 0 || value
> 0x1fffc)
3982 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
3983 _("immediate offset out of range"));
3985 md_number_to_chars (buf
, newval
, 4);
3987 if (fixP
->fx_done
&& fixP
->fx_r_type
!= BFD_RELOC_C6000_SBR_U15_W
)
3991 case BFD_RELOC_C6000_DSBT_INDEX
:
3993 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
3994 _("addend used with $DSBT_INDEX"));
3999 case BFD_RELOC_C6000_PCR_S21
:
4000 if (fixP
->fx_done
|| !seg
->use_rela_p
)
4002 offsetT newval
= md_chars_to_number (buf
, 4);
4004 MODIFY_VALUE (newval
, value
, 2, 7, 21);
4007 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
4008 _("PC-relative offset not 4-byte-aligned"));
4009 if (value
< -0x400000 || value
> 0x3ffffc)
4010 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
4011 _("PC-relative offset out of range"));
4013 md_number_to_chars (buf
, newval
, 4);
4017 case BFD_RELOC_C6000_PCR_S12
:
4018 if (fixP
->fx_done
|| !seg
->use_rela_p
)
4020 offsetT newval
= md_chars_to_number (buf
, 4);
4022 MODIFY_VALUE (newval
, value
, 2, 16, 12);
4025 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
4026 _("PC-relative offset not 4-byte-aligned"));
4027 if (value
< -0x2000 || value
> 0x1ffc)
4028 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
4029 _("PC-relative offset out of range"));
4031 md_number_to_chars (buf
, newval
, 4);
4035 case BFD_RELOC_C6000_PCR_S10
:
4036 if (fixP
->fx_done
|| !seg
->use_rela_p
)
4038 offsetT newval
= md_chars_to_number (buf
, 4);
4040 MODIFY_VALUE (newval
, value
, 2, 13, 10);
4043 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
4044 _("PC-relative offset not 4-byte-aligned"));
4045 if (value
< -0x800 || value
> 0x7fc)
4046 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
4047 _("PC-relative offset out of range"));
4049 md_number_to_chars (buf
, newval
, 4);
4053 case BFD_RELOC_C6000_PCR_S7
:
4054 if (fixP
->fx_done
|| !seg
->use_rela_p
)
4056 offsetT newval
= md_chars_to_number (buf
, 4);
4058 MODIFY_VALUE (newval
, value
, 2, 16, 7);
4061 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
4062 _("PC-relative offset not 4-byte-aligned"));
4063 if (value
< -0x100 || value
> 0xfc)
4064 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
4065 _("PC-relative offset out of range"));
4067 md_number_to_chars (buf
, newval
, 4);
4071 case BFD_RELOC_C6000_PREL31
:
4072 /* Force output to the object file. */
4081 /* Convert a floating-point number to target (IEEE) format. */
4084 md_atof (int type
, char *litP
, int *sizeP
)
4086 return ieee_md_atof (type
, litP
, sizeP
, target_big_endian
);
4089 /* Adjust the frags in SECTION (see tic6x_end). */
4092 tic6x_adjust_section (bfd
*abfd ATTRIBUTE_UNUSED
, segT section
,
4093 void *dummy ATTRIBUTE_UNUSED
)
4095 segment_info_type
*info
;
4098 bfd_boolean have_code
= FALSE
;
4099 bfd_boolean have_non_code
= FALSE
;
4101 info
= seg_info (section
);
4105 for (frchp
= info
->frchainP
; frchp
; frchp
= frchp
->frch_next
)
4106 for (fragp
= frchp
->frch_root
; fragp
; fragp
= fragp
->fr_next
)
4107 switch (fragp
->fr_type
)
4109 case rs_machine_dependent
:
4110 if (fragp
->tc_frag_data
.is_insns
)
4116 if (fragp
->fr_fix
> 0)
4117 have_non_code
= TRUE
;
4121 have_non_code
= TRUE
;
4125 /* Process alignment requirements in a code-only section. */
4126 if (have_code
&& !have_non_code
)
4128 /* If we need to insert an odd number of instructions to meet an
4129 alignment requirement, there must have been an odd number of
4130 instructions since the last 8-byte-aligned execute packet
4131 boundary. So there must have been an execute packet with an
4132 odd number (and so a number fewer than 8) of instructions
4133 into which we can insert a NOP without breaking any previous
4136 If then we need to insert a number 2 mod 4 of instructions,
4137 the number of instructions since the last 16-byte-aligned
4138 execute packet boundary must be 2 mod 4. So between that
4139 boundary and the following 8-byte-aligned boundary there must
4140 either be at least one execute packet with 2-mod-4
4141 instructions, or at least two with an odd number of
4142 instructions; again, greedily inserting NOPs as soon as
4143 possible suffices to meet the alignment requirement.
4145 If then we need to insert 4 instructions, we look between the
4146 last 32-byte-aligned boundary and the following
4147 16-byte-aligned boundary. The sizes of the execute packets
4148 in this range total 4 instructions mod 8, so again there is
4149 room for greedy insertion of NOPs to meet the alignment
4150 requirement, and before any intermediate point with 8-byte
4151 (2-instruction) alignment requirement the sizes of execute
4152 packets (and so the room for NOPs) will total 2 instructions
4153 mod 4 so greedy insertion will not break such alignments.
4155 So we can always meet these alignment requirements by
4156 inserting NOPs in parallel with existing execute packets, and
4157 by induction the approach described above inserts the minimum
4158 number of such NOPs. */
4160 /* The number of NOPs we are currently looking to insert, if we
4161 have gone back to insert NOPs. */
4162 unsigned int want_insert
= 0;
4164 /* Out of that number, the number inserted so far in the current
4165 stage of the above algorithm. */
4166 unsigned int want_insert_done_so_far
= 0;
4168 /* The position mod 32 at the start of the current frag. */
4169 unsigned int pos
= 0;
4171 /* The locations in the frag chain of the most recent frags at
4172 the start of which there is the given alignment. */
4173 frchainS
*frchp_last32
, *frchp_last16
, *frchp_last8
;
4174 fragS
*fragp_last32
, *fragp_last16
, *fragp_last8
;
4175 unsigned int pos_last32
, pos_last16
, pos_last8
;
4177 frchp_last32
= frchp_last16
= frchp_last8
= info
->frchainP
;
4178 fragp_last32
= fragp_last16
= fragp_last8
= info
->frchainP
->frch_root
;
4179 pos_last32
= pos_last16
= pos_last8
= 0;
4181 for (frchp
= info
->frchainP
; frchp
; frchp
= frchp
->frch_next
)
4182 for (fragp
= frchp
->frch_root
; fragp
; fragp
= fragp
->fr_next
)
4185 bfd_boolean go_back
= FALSE
;
4186 frchainS
*frchp_next
;
4189 if (fragp
->fr_type
!= rs_machine_dependent
)
4192 if (fragp
->tc_frag_data
.is_insns
4193 && pos
+ fragp
->fr_fix
> 32
4194 && !fragp
->tc_frag_data
.can_cross_fp_boundary
)
4196 /* As described above, we should always have met an
4197 alignment requirement by the time we come back to
4204 want_insert
= (32 - pos
) >> 2;
4205 if (want_insert
> 7)
4207 want_insert_done_so_far
= 0;
4211 if (!fragp
->tc_frag_data
.is_insns
)
4213 unsigned int would_insert_bytes
;
4215 if (!(pos
& ((1 << fragp
->fr_offset
) - 1)))
4216 /* This alignment requirement is already met. */
4219 /* As described above, we should always have met an
4220 alignment requirement by the time we come back to
4225 /* We may not be able to meet this requirement within
4226 the given number of characters. */
4228 = ((1 << fragp
->fr_offset
)
4229 - (pos
& ((1 << fragp
->fr_offset
) - 1)));
4231 if (fragp
->fr_subtype
!= 0
4232 && would_insert_bytes
> fragp
->fr_subtype
)
4235 /* An unmet alignment must be 8, 16 or 32 bytes;
4236 smaller ones must always be met within code-only
4237 sections and larger ones cause the section not to
4239 if (fragp
->fr_offset
!= 3
4240 && fragp
->fr_offset
!= 4
4241 && fragp
->fr_offset
!= 5)
4244 if (would_insert_bytes
& 3)
4246 want_insert
= would_insert_bytes
>> 2;
4247 if (want_insert
> 7)
4249 want_insert_done_so_far
= 0;
4252 else if (want_insert
&& !go_back
)
4254 unsigned int num_insns
= fragp
->fr_fix
>> 2;
4255 unsigned int max_poss_nops
= 8 - num_insns
;
4259 unsigned int cur_want_nops
, max_want_nops
, do_nops
, i
;
4261 if (want_insert
& 1)
4263 else if (want_insert
& 2)
4265 else if (want_insert
& 4)
4270 max_want_nops
= cur_want_nops
- want_insert_done_so_far
;
4272 do_nops
= (max_poss_nops
< max_want_nops
4275 for (i
= 0; i
< do_nops
; i
++)
4277 md_number_to_chars (fragp
->fr_literal
+ fragp
->fr_fix
,
4279 if (target_big_endian
)
4280 fragp
->fr_literal
[fragp
->fr_fix
- 1] |= 0x1;
4282 fragp
->fr_literal
[fragp
->fr_fix
- 4] |= 0x1;
4286 want_insert_done_so_far
+= do_nops
;
4287 if (want_insert_done_so_far
== cur_want_nops
)
4289 want_insert
-= want_insert_done_so_far
;
4290 want_insert_done_so_far
= 0;
4298 if (want_insert
& 1)
4300 frchp
= frchp_last8
;
4301 fragp
= fragp_last8
;
4304 else if (want_insert
& 2)
4306 frchp
= frchp_last8
= frchp_last16
;
4307 fragp
= fragp_last8
= fragp_last16
;
4308 pos
= pos_last8
= pos_last16
;
4310 else if (want_insert
& 4)
4312 frchp
= frchp_last8
= frchp_last16
= frchp_last32
;
4313 fragp
= fragp_last8
= fragp_last16
= fragp_last32
;
4314 pos
= pos_last8
= pos_last16
= pos_last32
;
4322 /* Update current position for moving past a code
4324 pos
+= fragp
->fr_fix
;
4327 fragp_next
= fragp
->fr_next
;
4328 if (fragp_next
== NULL
)
4330 frchp_next
= frchp
->frch_next
;
4331 if (frchp_next
!= NULL
)
4332 fragp_next
= frchp_next
->frch_root
;
4336 frchp_last8
= frchp_next
;
4337 fragp_last8
= fragp_next
;
4342 frchp_last16
= frchp_next
;
4343 fragp_last16
= fragp_next
;
4348 frchp_last32
= frchp_next
;
4349 fragp_last32
= fragp_next
;
4355 /* Now convert the machine-dependent frags to machine-independent
4357 for (frchp
= info
->frchainP
; frchp
; frchp
= frchp
->frch_next
)
4358 for (fragp
= frchp
->frch_root
; fragp
; fragp
= fragp
->fr_next
)
4360 if (fragp
->fr_type
== rs_machine_dependent
)
4362 if (fragp
->tc_frag_data
.is_insns
)
4366 fragp
->fr_type
= rs_align_code
;
4368 *fragp
->fr_literal
= 0;
4374 /* Initialize the machine-dependent parts of a frag. */
4377 tic6x_frag_init (fragS
*fragp
)
4379 fragp
->tc_frag_data
.is_insns
= FALSE
;
4380 fragp
->tc_frag_data
.can_cross_fp_boundary
= FALSE
;
4383 /* Set an attribute if it has not already been set by the user. */
4386 tic6x_set_attribute_int (int tag
, int value
)
4389 || tag
>= NUM_KNOWN_OBJ_ATTRIBUTES
)
4391 if (!tic6x_attributes_set_explicitly
[tag
])
4392 bfd_elf_add_proc_attr_int (stdoutput
, tag
, value
);
4395 /* Set object attributes deduced from the input file and command line
4396 rather than given explicitly. */
4398 tic6x_set_attributes (void)
4400 if (tic6x_arch_attribute
== C6XABI_Tag_ISA_none
)
4401 tic6x_arch_attribute
= C6XABI_Tag_ISA_C674X
;
4403 tic6x_set_attribute_int (Tag_ISA
, tic6x_arch_attribute
);
4404 tic6x_set_attribute_int (Tag_ABI_DSBT
, tic6x_dsbt
);
4405 tic6x_set_attribute_int (Tag_ABI_PID
, tic6x_pid
);
4406 tic6x_set_attribute_int (Tag_ABI_PIC
, tic6x_pic
);
4409 /* Do machine-dependent manipulations of the frag chains after all
4410 input has been read and before the machine-independent sizing and
4416 /* Set object attributes at this point if not explicitly set. */
4417 tic6x_set_attributes ();
4419 /* Meeting alignment requirements may require inserting NOPs in
4420 parallel in execute packets earlier in the segment. Future
4421 16-bit instruction generation involves whole-segment optimization
4422 to determine the best choice and ordering of 32-bit or 16-bit
4423 instructions. This doesn't fit will in the general relaxation
4424 framework, so handle alignment and 16-bit instruction generation
4426 bfd_map_over_sections (stdoutput
, tic6x_adjust_section
, NULL
);
4429 /* No machine-dependent frags at this stage; all converted in
4433 md_convert_frag (bfd
*abfd ATTRIBUTE_UNUSED
, segT asec ATTRIBUTE_UNUSED
,
4434 fragS
*fragp ATTRIBUTE_UNUSED
)
4439 /* No machine-dependent frags at this stage; all converted in
4443 md_estimate_size_before_relax (fragS
*fragp ATTRIBUTE_UNUSED
,
4444 segT seg ATTRIBUTE_UNUSED
)
4449 /* Put a number into target byte order. */
4452 md_number_to_chars (char *buf
, valueT val
, int n
)
4454 if (target_big_endian
)
4455 number_to_chars_bigendian (buf
, val
, n
);
4457 number_to_chars_littleendian (buf
, val
, n
);
4460 /* Machine-dependent operand parsing not currently needed. */
4463 md_operand (expressionS
*op ATTRIBUTE_UNUSED
)
4467 /* PC-relative operands are relative to the start of the fetch
4471 tic6x_pcrel_from_section (fixS
*fixp
, segT sec
)
4473 if (fixp
->fx_addsy
!= NULL
4474 && (!S_IS_DEFINED (fixp
->fx_addsy
)
4475 || S_GET_SEGMENT (fixp
->fx_addsy
) != sec
))
4477 return (fixp
->fx_where
+ fixp
->fx_frag
->fr_address
) & ~(long) 0x1f;
4480 /* Round up a section size to the appropriate boundary. */
4483 md_section_align (segT segment ATTRIBUTE_UNUSED
,
4486 /* Round up section sizes to ensure that text sections consist of
4487 whole fetch packets. */
4488 int align
= bfd_get_section_alignment (stdoutput
, segment
);
4489 return ((size
+ (1 << align
) - 1) & ((valueT
) -1 << align
));
4492 /* No special undefined symbol handling needed for now. */
4495 md_undefined_symbol (char *name ATTRIBUTE_UNUSED
)
4500 /* Translate internal representation of relocation info to BFD target
4504 tc_gen_reloc (asection
*section ATTRIBUTE_UNUSED
, fixS
*fixp
)
4508 bfd_reloc_code_real_type r_type
;
4510 reloc
= xmalloc (sizeof (arelent
));
4511 reloc
->sym_ptr_ptr
= xmalloc (sizeof (asymbol
*));
4512 symbol
= symbol_get_bfdsym (fixp
->fx_addsy
);
4513 *reloc
->sym_ptr_ptr
= symbol
;
4514 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
4515 reloc
->addend
= (tic6x_generate_rela
? fixp
->fx_offset
: 0);
4516 r_type
= fixp
->fx_r_type
;
4517 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, r_type
);
4519 if (reloc
->howto
== NULL
)
4521 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
4522 _("Cannot represent relocation type %s"),
4523 bfd_get_reloc_code_name (r_type
));
4527 /* Correct for adjustments bfd_install_relocation will make. */
4528 if (reloc
->howto
->pcrel_offset
&& reloc
->howto
->partial_inplace
)
4530 reloc
->addend
+= reloc
->address
;
4531 if (!bfd_is_com_section (symbol
))
4532 reloc
->addend
-= symbol
->value
;
4534 if (r_type
== BFD_RELOC_C6000_PCR_H16
4535 || r_type
== BFD_RELOC_C6000_PCR_L16
)
4537 symbolS
*t
= fixp
->tc_fix_data
.fix_subsy
;
4538 segT sub_symbol_segment
;
4540 resolve_symbol_value (t
);
4541 sub_symbol_segment
= S_GET_SEGMENT (t
);
4542 if (sub_symbol_segment
== undefined_section
)
4543 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
4544 _("undefined symbol %s in PCR relocation"),
4548 reloc
->addend
= reloc
->address
& ~0x1F;
4549 reloc
->addend
-= S_GET_VALUE (t
);
4555 /* Convert REGNAME to a DWARF-2 register number. */
4558 tic6x_regname_to_dw2regnum (char *regname
)
4564 reg_ok
= tic6x_parse_register (&rq
, ®
);
4571 case 1: /* A regs. */
4574 else if (reg
.num
< 32)
4575 return (reg
.num
- 16) + 37;
4579 case 2: /* B regs. */
4581 return reg
.num
+ 16;
4582 else if (reg
.num
< 32)
4583 return (reg
.num
- 16) + 53;
4592 /* Initialize the DWARF-2 unwind information for this procedure. */
4595 tic6x_frame_initial_instructions (void)
4597 /* CFA is initial stack pointer (B15). */
4598 cfi_add_CFA_def_cfa (31, 0);
4601 /* Start an exception table entry. If idx is nonzero this is an index table
4605 tic6x_start_unwind_section (const segT text_seg
, int idx
)
4607 tic6x_unwind_info
*unwind
= tic6x_get_unwind ();
4608 const char * text_name
;
4609 const char * prefix
;
4610 const char * prefix_once
;
4611 const char * group_name
;
4615 size_t sec_name_len
;
4622 prefix
= ELF_STRING_C6000_unwind
;
4623 prefix_once
= ELF_STRING_C6000_unwind_once
;
4624 type
= SHT_C6000_UNWIND
;
4628 prefix
= ELF_STRING_C6000_unwind_info
;
4629 prefix_once
= ELF_STRING_C6000_unwind_info_once
;
4630 type
= SHT_PROGBITS
;
4633 text_name
= segment_name (text_seg
);
4634 if (streq (text_name
, ".text"))
4637 if (strncmp (text_name
, ".gnu.linkonce.t.",
4638 strlen (".gnu.linkonce.t.")) == 0)
4640 prefix
= prefix_once
;
4641 text_name
+= strlen (".gnu.linkonce.t.");
4644 prefix_len
= strlen (prefix
);
4645 text_len
= strlen (text_name
);
4646 sec_name_len
= prefix_len
+ text_len
;
4647 sec_name
= (char *) xmalloc (sec_name_len
+ 1);
4648 memcpy (sec_name
, prefix
, prefix_len
);
4649 memcpy (sec_name
+ prefix_len
, text_name
, text_len
);
4650 sec_name
[prefix_len
+ text_len
] = '\0';
4656 /* Handle COMDAT group. */
4657 if (prefix
!= prefix_once
&& (text_seg
->flags
& SEC_LINK_ONCE
) != 0)
4659 group_name
= elf_group_name (text_seg
);
4660 if (group_name
== NULL
)
4662 as_bad (_("group section `%s' has no group signature"),
4663 segment_name (text_seg
));
4664 ignore_rest_of_line ();
4671 obj_elf_change_section (sec_name
, type
, flags
, 0, group_name
, linkonce
, 0);
4673 /* Set the section link for index tables. */
4675 elf_linked_to_section (now_seg
) = text_seg
;
4677 seg_info (now_seg
)->tc_segment_info_data
.text_unwind
= unwind
;
4682 tic6x_unwind_frame_regs
[TIC6X_NUM_UNWIND_REGS
] =
4683 /* A15 B15 B14 B13 B12 B11 B10 B3 A14 A13 A12 A11 A10. */
4684 { 15, 31, 30, 29, 28, 27, 26, 19, 14, 13, 12, 11, 10 };
4686 /* Register save offsets for __c6xabi_push_rts. */
4688 tic6x_pop_rts_offset_little
[TIC6X_NUM_UNWIND_REGS
] =
4689 /* A15 B15 B14 B13 B12 B11 B10 B3 A14 A13 A12 A11 A10. */
4690 { -1, 1, 0, -3, -4, -7, -8,-11, -2, -5, -6, -9,-10};
4693 tic6x_pop_rts_offset_big
[TIC6X_NUM_UNWIND_REGS
] =
4694 /* A15 B15 B14 B13 B12 B11 B10 B3 A14 A13 A12 A11 A10. */
4695 { -2, 1, 0, -4, -3, -8, -7,-12, -1, -6, -5,-10, -9};
4697 /* Map from dwarf register number to unwind frame register number. */
4699 tic6x_unwind_reg_from_dwarf (int dwarf
)
4703 for (reg
= 0; reg
< TIC6X_NUM_UNWIND_REGS
; reg
++)
4705 if (tic6x_unwind_frame_regs
[reg
] == dwarf
)
4712 /* Unwinding bytecode definitions. */
4713 #define UNWIND_OP_ADD_SP 0x00
4714 #define UNWIND_OP_ADD_SP2 0xd2
4715 #define UNWIND_OP2_POP 0x8000
4716 #define UNWIND_OP2_POP_COMPACT 0xa000
4717 #define UNWIND_OP_POP_REG 0xc0
4718 #define UNWIND_OP_MV_FP 0xd0
4719 #define UNWIND_OP_POP_RTS 0xd1
4720 #define UNWIND_OP_RET 0xe0
4722 /* Maximum stack adjustment for __c6xabi_unwind_cpp_pr3/4 */
4723 #define MAX_COMPACT_SP_OFFSET (0x7f << 3)
4726 tic6x_flush_unwind_word (valueT data
)
4728 tic6x_unwind_info
*unwind
= tic6x_get_unwind ();
4731 /* Create EXTAB entry if it does not exist. */
4732 if (unwind
->table_entry
== NULL
)
4734 tic6x_start_unwind_section (unwind
->saved_seg
, 0);
4735 frag_align (2, 0, 0);
4736 record_alignment (now_seg
, 2);
4737 unwind
->table_entry
= expr_build_dot ();
4738 ptr
= frag_more (4);
4739 unwind
->frag_start
= ptr
;
4743 /* Append additional word of data. */
4744 ptr
= frag_more (4);
4747 md_number_to_chars (ptr
, data
, 4);
4750 /* Add a single byte of unwinding data. */
4753 tic6x_unwind_byte (int byte
)
4755 tic6x_unwind_info
*unwind
= tic6x_get_unwind ();
4757 unwind
->data_bytes
++;
4758 /* Only flush the first word after we know multiple words are required. */
4759 if (unwind
->data_bytes
== 5)
4761 if (unwind
->personality_index
== -1)
4763 /* At this point we know we are too big for pr0. */
4764 unwind
->personality_index
= 1;
4765 tic6x_flush_unwind_word (0x81000000 | ((unwind
->data
>> 8) & 0xffff));
4766 unwind
->data
= ((unwind
->data
& 0xff) << 8) | byte
;
4767 unwind
->data_bytes
++;
4771 tic6x_flush_unwind_word (unwind
->data
);
4772 unwind
->data
= byte
;
4777 unwind
->data
= (unwind
->data
<< 8) | byte
;
4778 if ((unwind
->data_bytes
& 3) == 0 && unwind
->data_bytes
> 4)
4780 tic6x_flush_unwind_word (unwind
->data
);
4786 /* Add a two-byte unwinding opcode. */
4788 tic6x_unwind_2byte (int bytes
)
4790 tic6x_unwind_byte (bytes
>> 8);
4791 tic6x_unwind_byte (bytes
& 0xff);
4795 tic6x_unwind_uleb (offsetT offset
)
4797 while (offset
> 0x7f)
4799 tic6x_unwind_byte ((offset
& 0x7f) | 0x80);
4802 tic6x_unwind_byte (offset
);
4806 tic6x_cfi_startproc (void)
4808 tic6x_unwind_info
*unwind
= tic6x_get_unwind ();
4810 unwind
->personality_index
= -1;
4811 unwind
->personality_routine
= NULL
;
4812 if (unwind
->table_entry
)
4813 as_bad (_("missing .endp before .cfi_startproc"));
4815 unwind
->table_entry
= NULL
;
4816 unwind
->data_bytes
= -1;
4820 tic6x_output_exidx_entry (void)
4824 unsigned int marked_pr_dependency
;
4827 tic6x_unwind_info
*unwind
= tic6x_get_unwind ();
4830 old_subseg
= now_subseg
;
4832 /* Add index table entry. This is two words. */
4833 tic6x_start_unwind_section (unwind
->saved_seg
, 1);
4834 frag_align (2, 0, 0);
4835 record_alignment (now_seg
, 2);
4837 ptr
= frag_more (8);
4838 where
= frag_now_fix () - 8;
4840 /* Self relative offset of the function start. */
4841 fix_new (frag_now
, where
, 4, unwind
->function_start
, 0, 1,
4842 BFD_RELOC_C6000_PREL31
);
4844 /* Indicate dependency on ABI-defined personality routines to the
4845 linker, if it hasn't been done already. */
4846 marked_pr_dependency
4847 = seg_info (now_seg
)->tc_segment_info_data
.marked_pr_dependency
;
4848 if (unwind
->personality_index
>= 0 && unwind
->personality_index
< 5
4849 && !(marked_pr_dependency
& (1 << unwind
->personality_index
)))
4851 static const char *const name
[] =
4853 "__c6xabi_unwind_cpp_pr0",
4854 "__c6xabi_unwind_cpp_pr1",
4855 "__c6xabi_unwind_cpp_pr2",
4856 "__c6xabi_unwind_cpp_pr3",
4857 "__c6xabi_unwind_cpp_pr4"
4859 symbolS
*pr
= symbol_find_or_make (name
[unwind
->personality_index
]);
4860 fix_new (frag_now
, where
, 0, pr
, 0, 1, BFD_RELOC_NONE
);
4861 seg_info (now_seg
)->tc_segment_info_data
.marked_pr_dependency
4862 |= 1 << unwind
->personality_index
;
4865 if (unwind
->table_entry
)
4867 /* Self relative offset of the table entry. */
4868 fix_new (frag_now
, where
+ 4, 4, unwind
->table_entry
, 0, 1,
4869 BFD_RELOC_C6000_PREL31
);
4873 /* Inline exception table entry. */
4874 md_number_to_chars (ptr
+ 4, unwind
->data
, 4);
4877 /* Restore the original section. */
4878 subseg_set (old_seg
, old_subseg
);
4882 tic6x_output_unwinding (bfd_boolean need_extab
)
4884 tic6x_unwind_info
*unwind
= tic6x_get_unwind ();
4885 unsigned safe_mask
= unwind
->safe_mask
;
4886 unsigned compact_mask
= unwind
->compact_mask
;
4887 unsigned reg_saved_mask
= unwind
->reg_saved_mask
;
4888 offsetT cfa_offset
= unwind
->cfa_offset
;
4892 if (unwind
->personality_index
== -2)
4894 /* Function can not be unwound. */
4896 tic6x_output_exidx_entry ();
4900 if (unwind
->personality_index
== -1 && unwind
->personality_routine
== NULL
)
4902 /* Auto-select a personality routine if none specified. */
4903 if (reg_saved_mask
|| cfa_offset
>= MAX_COMPACT_SP_OFFSET
)
4904 unwind
->personality_index
= -1;
4906 unwind
->personality_index
= 3;
4908 unwind
->personality_index
= 4;
4911 /* Calculate unwinding opcodes, and emit to EXTAB if necessary. */
4912 unwind
->table_entry
= NULL
;
4913 if (unwind
->personality_index
== 3 || unwind
->personality_index
== 4)
4915 if (cfa_offset
>= MAX_COMPACT_SP_OFFSET
)
4917 as_bad (_("stack pointer offset too large for personality routine"));
4921 || (unwind
->personality_index
== 3 && compact_mask
!= 0)
4922 || (unwind
->personality_index
== 4 && safe_mask
!= 0))
4924 as_bad (_("stack frame layout does not match personality routine"));
4928 unwind
->data
= (1u << 31) | (unwind
->personality_index
<< 24);
4929 if (unwind
->cfa_reg
== 15)
4930 unwind
->data
|= 0x7f << 17;
4932 unwind
->data
|= cfa_offset
<< (17 - 3);
4934 if (unwind
->personality_index
== 3)
4935 unwind
->data
|= safe_mask
<< 4;
4937 unwind
->data
|= compact_mask
<< 4;
4938 unwind
->data
|= unwind
->return_reg
;
4939 unwind
->data_bytes
= 4;
4943 if (unwind
->personality_routine
)
4946 unwind
->data_bytes
= 5;
4947 tic6x_flush_unwind_word (0);
4948 /* First word is personality routine. */
4949 where
= frag_now_fix () - 4;
4950 fix_new (frag_now
, where
, 4, unwind
->personality_routine
, 0, 1,
4951 BFD_RELOC_C6000_PREL31
);
4953 else if (unwind
->personality_index
> 0)
4955 unwind
->data
= 0x8000 | (unwind
->personality_index
<< 8);
4956 unwind
->data_bytes
= 2;
4958 else /* pr0 or undecided */
4960 unwind
->data
= 0x80;
4961 unwind
->data_bytes
= 1;
4964 if (unwind
->return_reg
!= UNWIND_B3
)
4966 tic6x_unwind_byte (UNWIND_OP_RET
| unwind
->return_reg
);
4969 if (unwind
->cfa_reg
== 15)
4971 tic6x_unwind_byte (UNWIND_OP_MV_FP
);
4973 else if (cfa_offset
!= 0)
4976 if (cfa_offset
> 0x80)
4978 tic6x_unwind_byte (UNWIND_OP_ADD_SP2
);
4979 tic6x_unwind_uleb (cfa_offset
- 0x81);
4981 else if (cfa_offset
> 0x40)
4983 tic6x_unwind_byte (UNWIND_OP_ADD_SP
| 0x3f);
4984 tic6x_unwind_byte (UNWIND_OP_ADD_SP
| (cfa_offset
- 0x40));
4988 tic6x_unwind_byte (UNWIND_OP_ADD_SP
| (cfa_offset
- 1));
4993 tic6x_unwind_2byte (UNWIND_OP2_POP
| unwind
->safe_mask
);
4994 else if (unwind
->pop_rts
)
4995 tic6x_unwind_byte (UNWIND_OP_POP_RTS
);
4996 else if (compact_mask
)
4997 tic6x_unwind_2byte (UNWIND_OP2_POP_COMPACT
| unwind
->compact_mask
);
4998 else if (reg_saved_mask
)
5004 tic6x_unwind_byte (UNWIND_OP_POP_REG
| unwind
->saved_reg_count
);
5006 for (cur_offset
= 0; unwind
->saved_reg_count
> 0; cur_offset
-= 4)
5009 for (reg
= 0; reg
< TIC6X_NUM_UNWIND_REGS
; reg
++)
5011 if (!unwind
->reg_saved
[reg
])
5014 if (unwind
->reg_offset
[reg
] == cur_offset
)
5016 unwind
->saved_reg_count
--;
5021 if ((cur_offset
& 4) == 4)
5022 tic6x_unwind_byte ((last_val
<< 4) | val
);
5026 if ((cur_offset
& 4) == 4)
5027 tic6x_unwind_byte ((last_val
<< 4) | 0xf);
5030 /* Pad with RETURN opcodes. */
5031 while ((unwind
->data_bytes
& 3) != 0)
5032 tic6x_unwind_byte (UNWIND_OP_RET
| UNWIND_B3
);
5034 if (unwind
->personality_index
== -1 && unwind
->personality_routine
== NULL
)
5035 unwind
->personality_index
= 0;
5038 /* Force creation of an EXTAB entry if an LSDA is required. */
5039 if (need_extab
&& !unwind
->table_entry
)
5041 if (unwind
->data_bytes
!= 4)
5044 tic6x_flush_unwind_word (unwind
->data
);
5046 else if (unwind
->table_entry
&& !need_extab
)
5048 /* Add an empty descriptor if there is no user-specified data. */
5049 char *ptr
= frag_more (4);
5050 md_number_to_chars (ptr
, 0, 4);
5053 /* Fill in length of unwinding bytecode. */
5054 if (unwind
->table_entry
)
5057 if (unwind
->data_bytes
> 0x400)
5058 as_bad (_("too many unwinding instructions"));
5060 if (unwind
->personality_index
== -1)
5062 tmp
= md_chars_to_number (unwind
->frag_start
+ 4, 4);
5063 tmp
|= ((unwind
->data_bytes
- 8) >> 2) << 24;
5064 md_number_to_chars (unwind
->frag_start
+ 4, tmp
, 4);
5066 else if (unwind
->personality_index
== 1 || unwind
->personality_index
== 2)
5068 tmp
= md_chars_to_number (unwind
->frag_start
, 4);
5069 tmp
|= ((unwind
->data_bytes
- 4) >> 2) << 16;
5070 md_number_to_chars (unwind
->frag_start
, tmp
, 4);
5073 tic6x_output_exidx_entry ();
5076 /* FIXME: This will get horribly confused if cfi directives are emitted for
5077 function epilogue. */
5079 tic6x_cfi_endproc (struct fde_entry
*fde
)
5081 tic6x_unwind_info
*unwind
= tic6x_get_unwind ();
5082 struct cfi_insn_data
*insn
;
5084 unsigned safe_mask
= 0;
5085 unsigned compact_mask
= 0;
5086 unsigned reg_saved_mask
= 0;
5087 offsetT cfa_offset
= 0;
5088 offsetT save_offset
= 0;
5090 unwind
->cfa_reg
= 31;
5091 unwind
->return_reg
= UNWIND_B3
;
5092 unwind
->saved_reg_count
= 0;
5093 unwind
->pop_rts
= FALSE
;
5095 unwind
->saved_seg
= now_seg
;
5096 unwind
->saved_subseg
= now_subseg
;
5098 for (reg
= 0; reg
< TIC6X_NUM_UNWIND_REGS
; reg
++)
5099 unwind
->reg_saved
[reg
] = FALSE
;
5101 /* Scan FDE instructions to build up stack frame layout. */
5102 for (insn
= fde
->data
; insn
; insn
= insn
->next
)
5106 case DW_CFA_advance_loc
:
5109 case DW_CFA_def_cfa
:
5110 unwind
->cfa_reg
= insn
->u
.ri
.reg
;
5111 cfa_offset
= insn
->u
.ri
.offset
;
5114 case DW_CFA_def_cfa_register
:
5115 unwind
->cfa_reg
= insn
->u
.r
;
5118 case DW_CFA_def_cfa_offset
:
5119 cfa_offset
= insn
->u
.i
;
5122 case DW_CFA_undefined
:
5123 case DW_CFA_same_value
:
5124 reg
= tic6x_unwind_reg_from_dwarf (insn
->u
.r
);
5126 unwind
->reg_saved
[reg
] = FALSE
;
5130 reg
= tic6x_unwind_reg_from_dwarf (insn
->u
.ri
.reg
);
5133 as_bad (_("unable to generate unwinding opcode for reg %d"),
5137 unwind
->reg_saved
[reg
] = TRUE
;
5138 unwind
->reg_offset
[reg
] = insn
->u
.ri
.offset
;
5139 if (insn
->u
.ri
.reg
== UNWIND_B3
)
5140 unwind
->return_reg
= UNWIND_B3
;
5143 case DW_CFA_register
:
5144 if (insn
->u
.rr
.reg1
!= 19)
5146 as_bad (_("unable to generate unwinding opcode for reg %d"),
5151 reg
= tic6x_unwind_reg_from_dwarf (insn
->u
.rr
.reg2
);
5154 as_bad (_("unable to generate unwinding opcode for reg %d"),
5159 unwind
->return_reg
= reg
;
5160 unwind
->reg_saved
[UNWIND_B3
] = FALSE
;
5161 if (unwind
->reg_saved
[reg
])
5163 as_bad (_("unable to restore return address from "
5164 "previously restored reg"));
5169 case DW_CFA_restore
:
5170 case DW_CFA_remember_state
:
5171 case DW_CFA_restore_state
:
5172 case DW_CFA_GNU_window_save
:
5174 case CFI_val_encoded_addr
:
5175 as_bad (_("unhandled CFA insn for unwinding (%d)"), insn
->insn
);
5183 if (unwind
->cfa_reg
!= 15 && unwind
->cfa_reg
!= 31)
5185 as_bad (_("unable to generate unwinding opcode for frame pointer reg %d"),
5190 if (unwind
->cfa_reg
== 15)
5192 if (cfa_offset
!= 0)
5194 as_bad (_("unable to generate unwinding opcode for "
5195 "frame pointer offset"));
5201 if ((cfa_offset
& 7) != 0)
5203 as_bad (_("unwound stack pointer not doubleword aligned"));
5208 for (reg
= 0; reg
< TIC6X_NUM_UNWIND_REGS
; reg
++)
5210 if (unwind
->reg_saved
[reg
])
5211 reg_saved_mask
|= 1 << (TIC6X_NUM_UNWIND_REGS
- (reg
+ 1));
5214 /* Check for standard "safe debug" frame layout */
5218 for (reg
= 0; reg
< TIC6X_NUM_UNWIND_REGS
; reg
++)
5220 if (!unwind
->reg_saved
[reg
])
5223 if (target_big_endian
5224 && reg
< TIC6X_NUM_UNWIND_REGS
- 1
5225 && unwind
->reg_saved
[reg
+ 1]
5226 && tic6x_unwind_frame_regs
[reg
]
5227 == tic6x_unwind_frame_regs
[reg
+ 1] + 1
5228 && (tic6x_unwind_frame_regs
[reg
] & 1) == 1
5229 && (save_offset
& 4) == 4)
5232 if (save_offset
!= unwind
->reg_offset
[reg
+ 1]
5233 || save_offset
- 4 != unwind
->reg_offset
[reg
])
5240 if (save_offset
!= unwind
->reg_offset
[reg
])
5245 if (reg
== TIC6X_NUM_UNWIND_REGS
)
5247 safe_mask
= reg_saved_mask
;
5252 /* Check for compact frame layout. */
5256 for (reg
= 0; reg
< TIC6X_NUM_UNWIND_REGS
; reg
++)
5260 if (!unwind
->reg_saved
[reg
])
5263 if (reg
< TIC6X_NUM_UNWIND_REGS
- 1)
5267 if (!unwind
->reg_saved
[reg2
]
5268 || tic6x_unwind_frame_regs
[reg
]
5269 != tic6x_unwind_frame_regs
[reg2
] + 1
5270 || (tic6x_unwind_frame_regs
[reg2
] & 1) != 0
5271 || save_offset
== 0)
5280 if (target_big_endian
)
5281 high_offset
= 4; /* lower address = positive stack offset. */
5285 if (save_offset
+ 4 - high_offset
!= unwind
->reg_offset
[reg
]
5286 || save_offset
+ high_offset
!= unwind
->reg_offset
[reg2
])
5294 if (save_offset
!= unwind
->reg_offset
[reg
])
5300 if (reg
== TIC6X_NUM_UNWIND_REGS
)
5302 compact_mask
= reg_saved_mask
;
5307 /* Check for __c6xabi_pop_rts format */
5308 if (reg_saved_mask
== 0x17ff)
5310 const int *pop_rts_offset
= target_big_endian
5311 ? tic6x_pop_rts_offset_big
5312 : tic6x_pop_rts_offset_little
;
5315 for (reg
= 0; reg
< TIC6X_NUM_UNWIND_REGS
; reg
++)
5317 if (reg
== UNWIND_B15
)
5320 if (unwind
->reg_offset
[reg
] != pop_rts_offset
[reg
] * 4)
5324 if (reg
== TIC6X_NUM_UNWIND_REGS
)
5326 unwind
->pop_rts
= TRUE
;
5330 /* If all else fails then describe the frame manually. */
5335 for (reg
= 0; reg
< TIC6X_NUM_UNWIND_REGS
; reg
++)
5337 if (!unwind
->reg_saved
[reg
])
5340 unwind
->saved_reg_count
++;
5341 /* Encoding uses 4 bits per word, so size of unwinding opcode data
5342 limits the save area size. The exact cap will be figured out
5343 later due to overflow, the 0x800 here is just a quick sanity
5344 check to weed out obviously excessive offsets. */
5345 if (unwind
->reg_offset
[reg
] > 0 || unwind
->reg_offset
[reg
] < -0x800
5346 || (unwind
->reg_offset
[reg
] & 3) != 0)
5348 as_bad (_("stack frame layout too complex for unwinder"));
5352 if (unwind
->reg_offset
[reg
] < save_offset
)
5353 save_offset
= unwind
->reg_offset
[reg
] - 4;
5357 /* Align to 8-byte boundary (stack grows towards negative offsets). */
5360 if (unwind
->cfa_reg
== 31 && !reg_saved_mask
)
5362 cfa_offset
+= save_offset
;
5365 as_bad (_("unwound frame has negative size"));
5370 unwind
->safe_mask
= safe_mask
;
5371 unwind
->compact_mask
= compact_mask
;
5372 unwind
->reg_saved_mask
= reg_saved_mask
;
5373 unwind
->cfa_offset
= cfa_offset
;
5374 unwind
->function_start
= fde
->start_address
;