1 /* tc-tic54x.c -- Assembly code for the Texas Instruments TMS320C54X
2 Copyright (C) 1999-2016 Free Software Foundation, Inc.
3 Contributed by Timothy Wall (twall@cygnus.com)
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
22 /* Texas Instruments TMS320C54X machine specific gas.
23 Written by Timothy Wall (twall@alum.mit.edu).
25 Valuable things to do:
26 Pipeline conflict warnings
27 We encode/decode "ld #_label, dp" differently in relocatable files
28 This means we're not compatible with TI output containing those
29 expressions. We store the upper nine bits; TI stores the lower nine
30 bits. How they recover the original upper nine bits is beyond me.
32 Tests to add to expect testsuite:
33 '=' and '==' with .if, .elseif, and .break
35 Incompatibilities (mostly trivial):
37 We fill text section with zeroes instead of "nop"s
38 We don't convert '' or "" to a single instance
39 We don't convert '' to '\0'
40 We don't allow strings with .byte/.half/.short/.long
41 Probably details of the subsym stuff are different
42 TI sets labels to be data type 4 (T_INT); GAS uses T_NULL.
44 COFF1 limits section names to 8 characters.
45 Some of the default behavior changed from COFF1 to COFF2. */
49 #include "safe-ctype.h"
53 #include "struc-symbol.h"
54 #include "opcode/tic54x.h"
61 symbolS
*sym
; /* Symbol for this stag; value is offset. */
62 const char *name
; /* Shortcut to symbol name. */
63 bfd_vma size
; /* Size of struct/union. */
64 int current_bitfield_offset
; /* Temporary for tracking fields. */
66 struct stag_field
/* List of fields. */
69 bfd_vma offset
; /* Of start of this field. */
70 int bitfield_offset
; /* Of start of this field. */
71 struct stag
*stag
; /* If field is struct/union. */
72 struct stag_field
*next
;
74 /* For nesting; used only in stag construction. */
75 struct stag
*inner
; /* Enclosed .struct. */
76 struct stag
*outer
; /* Enclosing .struct. */
77 } *current_stag
= NULL
;
79 #define MAX_LINE 256 /* Lines longer than this are truncated by TI's asm. */
81 typedef struct _tic54x_insn
83 const insn_template
*tm
; /* Opcode template. */
85 char mnemonic
[MAX_LINE
]; /* Opcode name/mnemonic. */
86 char parmnemonic
[MAX_LINE
]; /* 2nd mnemonic of parallel insn. */
94 } operands
[MAX_OPERANDS
];
97 struct opstruct paroperands
[MAX_OPERANDS
];
101 int words
; /* Size of insn in 16-bit words. */
102 int using_default_dst
; /* Do we need to explicitly set an
103 omitted OP_DST operand? */
106 unsigned short word
; /* Final encoded opcode data. */
108 int r_nchars
; /* Relocation size. */
109 bfd_reloc_code_real_type r_type
; /* Relocation type. */
110 expressionS addr_expr
; /* Storage for unresolved expressions. */
116 VNONE
= 0, V541
= 1, V542
= 2, V543
= 3, V545
= 5, V548
= 8, V549
= 9,
117 V545LP
= 15, V546LP
= 16
122 c_mode
, /* 16-bit addresses. */
123 far_mode
/* >16-bit addresses. */
126 static segT stag_saved_seg
;
127 static subsegT stag_saved_subseg
;
129 const char comment_chars
[] = ";";
130 const char line_comment_chars
[] = ";*#"; /* At column zero only. */
131 const char line_separator_chars
[] = ""; /* Not permitted. */
133 int emitting_long
= 0;
135 /* Characters which indicate that this is a floating point constant. */
136 const char FLT_CHARS
[] = "fF";
138 /* Characters that can be used to separate mantissa from exp in FP
140 const char EXP_CHARS
[] = "eE";
142 const char *md_shortopts
= "";
144 #define OPTION_ADDRESS_MODE (OPTION_MD_BASE)
145 #define OPTION_CPU_VERSION (OPTION_ADDRESS_MODE + 1)
146 #define OPTION_COFF_VERSION (OPTION_CPU_VERSION + 1)
147 #define OPTION_STDERR_TO_FILE (OPTION_COFF_VERSION + 1)
149 struct option md_longopts
[] =
151 { "mfar-mode", no_argument
, NULL
, OPTION_ADDRESS_MODE
},
152 { "mf", no_argument
, NULL
, OPTION_ADDRESS_MODE
},
153 { "mcpu", required_argument
, NULL
, OPTION_CPU_VERSION
},
154 { "merrors-to-file", required_argument
, NULL
, OPTION_STDERR_TO_FILE
},
155 { "me", required_argument
, NULL
, OPTION_STDERR_TO_FILE
},
156 { NULL
, no_argument
, NULL
, 0},
159 size_t md_longopts_size
= sizeof (md_longopts
);
161 static int assembly_begun
= 0;
162 /* Addressing mode is not entirely implemented; the latest rev of the Other
163 assembler doesn't seem to make any distinction whatsoever; all relocations
164 are stored as extended relocatiosn. Older versions used REL16 vs RELEXT16,
165 but now it seems all relocations are RELEXT16. We use all RELEXT16.
167 The cpu version is kind of a waste of time as well. There is one
168 instruction (RND) for LP devices only, and several for devices with
169 extended addressing only. We include it for compatibility. */
170 static enum address_mode amode
= c_mode
;
171 static enum cpu_version cpu
= VNONE
;
173 /* Include string substitutions in listing? */
174 static int listing_sslist
= 0;
176 /* Did we do subsym substitutions on the line? */
177 static int substitution_line
= 0;
179 /* Last label seen. */
180 static symbolS
*last_label_seen
= NULL
;
182 /* This ensures that all new labels are unique. */
183 static int local_label_id
;
185 static struct hash_control
*subsym_recurse_hash
; /* Prevent infinite recurse. */
186 static struct hash_control
*math_hash
; /* Built-in math functions. */
187 /* Allow maximum levels of macro nesting; level 0 is the main substitution
188 symbol table. The other assembler only does 32 levels, so there! */
189 static struct hash_control
*subsym_hash
[100];
191 /* Keep track of local labels so we can substitute them before GAS sees them
192 since macros use their own 'namespace' for local labels, use a separate hash
194 We do our own local label handling 'cuz it's subtly different from the
197 We use our own macro nesting counter, since GAS overloads it when expanding
198 other things (like conditionals and repeat loops). */
199 static int macro_level
= 0;
200 static struct hash_control
*local_label_hash
[100];
201 /* Keep track of struct/union tags. */
202 static struct hash_control
*stag_hash
;
203 static struct hash_control
*op_hash
;
204 static struct hash_control
*parop_hash
;
205 static struct hash_control
*reg_hash
;
206 static struct hash_control
*mmreg_hash
;
207 static struct hash_control
*cc_hash
;
208 static struct hash_control
*cc2_hash
;
209 static struct hash_control
*cc3_hash
;
210 static struct hash_control
*sbit_hash
;
211 static struct hash_control
*misc_symbol_hash
;
213 /* Only word (et al.), align, or conditionals are allowed within
215 #define ILLEGAL_WITHIN_STRUCT() \
217 if (current_stag != NULL) \
219 as_bad (_("pseudo-op illegal within .struct/.union")); \
225 static void subsym_create_or_replace (char *, char *);
226 static char *subsym_lookup (char *, int);
227 static char *subsym_substitute (char *, int);
231 md_show_usage (FILE *stream
)
233 fprintf (stream
, _("C54x-specific command line options:\n"));
234 fprintf (stream
, _("-mfar-mode | -mf Use extended addressing\n"));
235 fprintf (stream
, _("-mcpu=<CPU version> Specify the CPU version\n"));
236 fprintf (stream
, _("-merrors-to-file <filename>\n"));
237 fprintf (stream
, _("-me <filename> Redirect errors to a file\n"));
240 /* Output a single character (upper octect is zero). */
243 tic54x_emit_char (char c
)
247 expn
.X_op
= O_constant
;
248 expn
.X_add_number
= c
;
249 emit_expr (&expn
, 2);
252 /* Walk backwards in the frag chain. */
255 frag_prev (fragS
*frag
, segT seg
)
257 segment_info_type
*seginfo
= seg_info (seg
);
260 for (fragp
= seginfo
->frchainP
->frch_root
; fragp
; fragp
= fragp
->fr_next
)
261 if (fragp
->fr_next
== frag
)
268 bit_offset_frag (fragS
*frag
, segT seg
)
272 if (frag
->fr_fix
== 0
273 && frag
->fr_opcode
== NULL
274 && frag
->tc_frag_data
== 0)
275 frag
= frag_prev (frag
, seg
);
282 /* Return the number of bits allocated in the most recent word, or zero if
283 none. .field/.space/.bes may leave words partially allocated. */
286 frag_bit_offset (fragS
*frag
, segT seg
)
288 frag
= bit_offset_frag (frag
, seg
);
291 return frag
->fr_opcode
!= NULL
? -1 : frag
->tc_frag_data
;
296 /* Read an expression from a C string; returns a pointer past the end of the
300 parse_expression (char *str
, expressionS
*expn
)
305 tmp
= input_line_pointer
; /* Save line pointer. */
306 input_line_pointer
= str
;
308 s
= input_line_pointer
;
309 input_line_pointer
= tmp
; /* Restore line pointer. */
310 return s
; /* Return pointer to where parsing stopped. */
313 /* .asg "character-string"|character-string, symbol
315 .eval is the only pseudo-op allowed to perform arithmetic on substitution
316 symbols. all other use of symbols defined with .asg are currently
320 tic54x_asg (int x ATTRIBUTE_UNUSED
)
325 int quoted
= *input_line_pointer
== '"';
327 ILLEGAL_WITHIN_STRUCT ();
332 str
= demand_copy_C_string (&len
);
333 c
= *input_line_pointer
;
337 str
= input_line_pointer
;
338 while ((c
= *input_line_pointer
) != ',')
340 if (is_end_of_line
[(int) *input_line_pointer
])
342 ++input_line_pointer
;
344 *input_line_pointer
= 0;
348 as_bad (_("Comma and symbol expected for '.asg STRING, SYMBOL'"));
349 ignore_rest_of_line ();
353 ++input_line_pointer
;
354 c
= get_symbol_name (&name
); /* Get terminator. */
355 if (!ISALPHA (*name
))
357 as_bad (_("symbols assigned with .asg must begin with a letter"));
358 ignore_rest_of_line ();
363 name
= xstrdup (name
);
364 subsym_create_or_replace (name
, str
);
365 (void) restore_line_pointer (c
);
366 demand_empty_rest_of_line ();
369 /* .eval expression, symbol
370 There's something screwy about this. The other assembler sometimes does and
371 sometimes doesn't substitute symbols defined with .eval.
372 We'll put the symbols into the subsym table as well as the normal symbol
373 table, since that's what works best. */
376 tic54x_eval (int x ATTRIBUTE_UNUSED
)
382 char valuestr
[32], *tmp
;
385 ILLEGAL_WITHIN_STRUCT ();
389 quoted
= *input_line_pointer
== '"';
391 ++input_line_pointer
;
392 value
= get_absolute_expression ();
395 if (*input_line_pointer
!= '"')
397 as_bad (_("Unterminated string after absolute expression"));
398 ignore_rest_of_line ();
401 ++input_line_pointer
;
403 if (*input_line_pointer
++ != ',')
405 as_bad (_("Comma and symbol expected for '.eval EXPR, SYMBOL'"));
406 ignore_rest_of_line ();
409 c
= get_symbol_name (&name
); /* Get terminator. */
410 name
= xstrdup (name
);
411 (void) restore_line_pointer (c
);
413 if (!ISALPHA (*name
))
415 as_bad (_("symbols assigned with .eval must begin with a letter"));
416 ignore_rest_of_line ();
419 symbolP
= symbol_new (name
, absolute_section
,
420 (valueT
) value
, &zero_address_frag
);
421 SF_SET_LOCAL (symbolP
);
422 symbol_table_insert (symbolP
);
424 /* The "other" assembler sometimes doesn't put .eval's in the subsym table
425 But since there's not written rule as to when, don't even bother trying
426 to match their behavior. */
427 sprintf (valuestr
, "%d", value
);
428 tmp
= xstrdup (valuestr
);
429 subsym_create_or_replace (name
, tmp
);
431 demand_empty_rest_of_line ();
434 /* .bss symbol, size [, [blocking flag] [, alignment flag]
436 alignment is to a longword boundary; blocking is to 128-word boundary.
438 1) if there is a hole in memory, this directive should attempt to fill it
439 (not yet implemented).
441 2) if the blocking flag is not set, allocate at the current SPC
442 otherwise, check to see if the current SPC plus the space to be
443 allocated crosses the page boundary (128 words).
444 if there's not enough space, create a hole and align with the next page
446 (not yet implemented). */
449 tic54x_bss (int x ATTRIBUTE_UNUSED
)
456 subsegT current_subseg
;
461 ILLEGAL_WITHIN_STRUCT ();
463 current_seg
= now_seg
; /* Save current seg. */
464 current_subseg
= now_subseg
; /* Save current subseg. */
466 c
= get_symbol_name (&name
); /* Get terminator. */
468 c
= * ++ input_line_pointer
;
471 as_bad (_(".bss size argument missing\n"));
472 ignore_rest_of_line ();
476 ++input_line_pointer
;
477 words
= get_absolute_expression ();
480 as_bad (_(".bss size %d < 0!"), words
);
481 ignore_rest_of_line ();
485 if (*input_line_pointer
== ',')
487 /* The blocking flag may be missing. */
488 ++input_line_pointer
;
489 if (*input_line_pointer
!= ',')
490 block
= get_absolute_expression ();
494 if (*input_line_pointer
== ',')
496 ++input_line_pointer
;
497 align
= get_absolute_expression ();
505 subseg_set (bss_section
, 0);
506 symbolP
= symbol_find_or_make (name
);
508 if (S_GET_SEGMENT (symbolP
) == bss_section
)
509 symbolP
->sy_frag
->fr_symbol
= (symbolS
*) NULL
;
511 symbol_set_frag (symbolP
, frag_now
);
512 p
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
,
513 (offsetT
) (words
* OCTETS_PER_BYTE
), (char *) 0);
514 *p
= 0; /* Fill char. */
516 S_SET_SEGMENT (symbolP
, bss_section
);
518 /* The symbol may already have been created with a preceding
519 ".globl" directive -- be careful not to step on storage class
520 in that case. Otherwise, set it to static. */
521 if (S_GET_STORAGE_CLASS (symbolP
) != C_EXT
)
522 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
526 /* s_align eats end of line; restore it */
528 --input_line_pointer
;
532 bss_section
->flags
|= SEC_TIC54X_BLOCK
;
534 subseg_set (current_seg
, current_subseg
); /* Restore current seg. */
535 demand_empty_rest_of_line ();
539 stag_add_field_symbols (struct stag
*stag
,
543 const char *root_stag_name
)
546 struct stag_field
*field
= stag
->field
;
548 /* Construct a symbol for every field contained within this structure
549 including fields within structure fields. */
550 prefix
= concat (path
, *path
? "." : "", NULL
);
552 while (field
!= NULL
)
554 char *name
= concat (prefix
, field
->name
, NULL
);
559 sym
= symbol_new (name
, absolute_section
,
560 (field
->stag
? field
->offset
:
561 (valueT
) (base_offset
+ field
->offset
)),
564 symbol_table_insert (sym
);
570 replacement
= concat (S_GET_NAME (rootsym
), "+", root_stag_name
,
571 name
+ strlen (S_GET_NAME (rootsym
)), NULL
);
572 hash_insert (subsym_hash
[0], name
, replacement
);
575 /* Recurse if the field is a structure.
576 Note the field offset is relative to the outermost struct. */
577 if (field
->stag
!= NULL
)
578 stag_add_field_symbols (field
->stag
, name
,
580 rootsym
, root_stag_name
);
587 /* Keep track of stag fields so that when structures are nested we can add the
588 complete dereferencing symbols to the symbol table. */
591 stag_add_field (struct stag
*parent
,
596 struct stag_field
*sfield
= XCNEW (struct stag_field
);
598 sfield
->name
= xstrdup (name
);
599 sfield
->offset
= offset
;
600 sfield
->bitfield_offset
= parent
->current_bitfield_offset
;
602 if (parent
->field
== NULL
)
603 parent
->field
= sfield
;
606 struct stag_field
*sf
= parent
->field
;
607 while (sf
->next
!= NULL
)
611 /* Only create a symbol for this field if the parent has no name. */
612 if (!strncmp (".fake", parent
->name
, 5))
614 symbolS
*sym
= symbol_new (name
, absolute_section
,
615 (valueT
) offset
, &zero_address_frag
);
617 symbol_table_insert (sym
);
621 /* [STAG] .struct [OFFSET]
622 Start defining structure offsets (symbols in absolute section). */
625 tic54x_struct (int arg
)
627 int start_offset
= 0;
632 /* Starting a new struct, switch to absolute section. */
633 stag_saved_seg
= now_seg
;
634 stag_saved_subseg
= now_subseg
;
635 subseg_set (absolute_section
, 0);
637 /* Align the current pointer. */
638 else if (current_stag
->current_bitfield_offset
!= 0)
640 ++abs_section_offset
;
641 current_stag
->current_bitfield_offset
= 0;
644 /* Offset expression is only meaningful for global .structs. */
647 /* Offset is ignored in inner structs. */
649 if (!is_end_of_line
[(int) *input_line_pointer
])
650 start_offset
= get_absolute_expression ();
657 /* Nesting, link to outer one. */
658 current_stag
->inner
= XCNEW (struct stag
);
659 current_stag
->inner
->outer
= current_stag
;
660 current_stag
= current_stag
->inner
;
662 as_warn (_("Offset on nested structures is ignored"));
663 start_offset
= abs_section_offset
;
667 current_stag
= XCNEW (struct stag
);
668 abs_section_offset
= start_offset
;
670 current_stag
->is_union
= is_union
;
672 if (line_label
== NULL
)
674 static int struct_count
= 0;
675 char fake
[] = ".fake_stagNNNNNNN";
676 sprintf (fake
, ".fake_stag%d", struct_count
++);
677 current_stag
->sym
= symbol_new (fake
, absolute_section
,
678 (valueT
) abs_section_offset
,
683 char * label
= xstrdup (S_GET_NAME (line_label
));
684 current_stag
->sym
= symbol_new (label
,
686 (valueT
) abs_section_offset
,
690 current_stag
->name
= S_GET_NAME (current_stag
->sym
);
691 SF_SET_LOCAL (current_stag
->sym
);
692 /* Nested .structs don't go into the symbol table. */
693 if (current_stag
->outer
== NULL
)
694 symbol_table_insert (current_stag
->sym
);
699 /* [LABEL] .endstruct
700 finish defining structure offsets; optional LABEL's value will be the size
704 tic54x_endstruct (int is_union
)
708 !strncmp (current_stag
->name
, ".fake", 5) ? "" : current_stag
->name
;
710 if (!current_stag
|| current_stag
->is_union
!= is_union
)
712 as_bad (_(".end%s without preceding .%s"),
713 is_union
? "union" : "struct",
714 is_union
? "union" : "struct");
715 ignore_rest_of_line ();
719 /* Align end of structures. */
720 if (current_stag
->current_bitfield_offset
)
722 ++abs_section_offset
;
723 current_stag
->current_bitfield_offset
= 0;
726 if (current_stag
->is_union
)
727 size
= current_stag
->size
;
729 size
= abs_section_offset
- S_GET_VALUE (current_stag
->sym
);
730 if (line_label
!= NULL
)
732 S_SET_VALUE (line_label
, size
);
733 symbol_table_insert (line_label
);
737 /* Union size has already been calculated. */
738 if (!current_stag
->is_union
)
739 current_stag
->size
= size
;
740 /* Nested .structs don't get put in the stag table. */
741 if (current_stag
->outer
== NULL
)
743 hash_insert (stag_hash
, current_stag
->name
, current_stag
);
744 stag_add_field_symbols (current_stag
, path
,
745 S_GET_VALUE (current_stag
->sym
),
748 current_stag
= current_stag
->outer
;
750 /* If this is a nested .struct/.union, add it as a field to the enclosing
751 one. otherwise, restore the section we were in. */
752 if (current_stag
!= NULL
)
754 stag_add_field (current_stag
, current_stag
->inner
->name
,
755 S_GET_VALUE (current_stag
->inner
->sym
),
756 current_stag
->inner
);
759 subseg_set (stag_saved_seg
, stag_saved_subseg
);
763 Reference a structure within a structure, as a sized field with an optional
765 If used outside of a .struct/.endstruct, overlays the given structure
766 format on the existing allocated space. */
769 tic54x_tag (int ignore ATTRIBUTE_UNUSED
)
772 int c
= get_symbol_name (&name
);
773 struct stag
*stag
= (struct stag
*) hash_find (stag_hash
, name
);
778 as_bad (_("Unrecognized struct/union tag '%s'"), name
);
780 as_bad (_(".tag requires a structure tag"));
781 ignore_rest_of_line ();
784 if (line_label
== NULL
)
786 as_bad (_("Label required for .tag"));
787 ignore_rest_of_line ();
794 label
= xstrdup (S_GET_NAME (line_label
));
795 if (current_stag
!= NULL
)
796 stag_add_field (current_stag
, label
,
797 abs_section_offset
- S_GET_VALUE (current_stag
->sym
),
801 symbolS
*sym
= symbol_find (label
);
805 as_bad (_(".tag target '%s' undefined"), label
);
806 ignore_rest_of_line ();
810 stag_add_field_symbols (stag
, S_GET_NAME (sym
),
811 S_GET_VALUE (stag
->sym
), sym
, stag
->name
);
816 /* Bump by the struct size, but only if we're within a .struct section. */
817 if (current_stag
!= NULL
&& !current_stag
->is_union
)
818 abs_section_offset
+= stag
->size
;
820 (void) restore_line_pointer (c
);
821 demand_empty_rest_of_line ();
825 /* Handle all .byte, .char, .double, .field, .float, .half, .int, .long,
826 .short, .string, .ubyte, .uchar, .uhalf, .uint, .ulong, .ushort, .uword,
830 tic54x_struct_field (int type
)
834 int new_bitfield_offset
= 0;
835 int field_align
= current_stag
->current_bitfield_offset
!= 0;
836 int longword_align
= 0;
839 if (!is_end_of_line
[(int) *input_line_pointer
])
840 count
= get_absolute_expression ();
856 case '*': /* String. */
865 case '.': /* Bitfield. */
867 if (count
< 1 || count
> 32)
869 as_bad (_(".field count '%d' out of range (1 <= X <= 32)"), count
);
870 ignore_rest_of_line ();
873 if (current_stag
->current_bitfield_offset
+ count
> 16)
875 /* Set the appropriate size and new field offset. */
885 new_bitfield_offset
= count
- 16;
888 new_bitfield_offset
= count
;
893 new_bitfield_offset
= current_stag
->current_bitfield_offset
+ count
;
897 as_bad (_("Unrecognized field type '%c'"), type
);
898 ignore_rest_of_line ();
904 /* Align to the actual starting position of the field. */
905 current_stag
->current_bitfield_offset
= 0;
906 ++abs_section_offset
;
908 /* Align to longword boundary. */
909 if (longword_align
&& (abs_section_offset
& 0x1))
910 ++abs_section_offset
;
912 if (line_label
== NULL
)
914 static int fieldno
= 0;
915 char fake
[] = ".fake_fieldNNNNN";
917 sprintf (fake
, ".fake_field%d", fieldno
++);
918 stag_add_field (current_stag
, fake
,
919 abs_section_offset
- S_GET_VALUE (current_stag
->sym
),
926 label
= xstrdup (S_GET_NAME (line_label
));
927 stag_add_field (current_stag
, label
,
928 abs_section_offset
- S_GET_VALUE (current_stag
->sym
),
933 if (current_stag
->is_union
)
935 /* Note we treat the element as if it were an array of COUNT. */
936 if (current_stag
->size
< (unsigned) size
* count
)
937 current_stag
->size
= size
* count
;
941 abs_section_offset
+= (unsigned) size
* count
;
942 current_stag
->current_bitfield_offset
= new_bitfield_offset
;
947 /* Handle .byte, .word. .int, .long and all variants. */
950 tic54x_cons (int type
)
955 /* If we're within a .struct construct, don't actually allocate space. */
956 if (current_stag
!= NULL
)
958 tic54x_struct_field (type
);
962 #ifdef md_flush_pending_output
963 md_flush_pending_output ();
966 generate_lineno_debug ();
968 /* Align long words to long word boundaries (4 octets). */
969 if (type
== 'l' || type
== 'L')
971 frag_align (2, 0, 2);
972 /* If there's a label, assign it to the first allocated word. */
973 if (line_label
!= NULL
)
975 symbol_set_frag (line_label
, frag_now
);
976 S_SET_VALUE (line_label
, frag_now_fix ());
1000 if (*input_line_pointer
== '"')
1002 input_line_pointer
++;
1003 while (is_a_char (c
= next_char_of_string ()))
1004 tic54x_emit_char (c
);
1005 know (input_line_pointer
[-1] == '\"');
1011 input_line_pointer
= parse_expression (input_line_pointer
, &expn
);
1012 if (expn
.X_op
== O_constant
)
1014 offsetT value
= expn
.X_add_number
;
1015 /* Truncate overflows. */
1019 if ((value
> 0 && value
> 0xFF)
1020 || (value
< 0 && value
< - 0x100))
1021 as_warn (_("Overflow in expression, truncated to 8 bits"));
1024 if ((value
> 0 && value
> 0xFFFF)
1025 || (value
< 0 && value
< - 0x10000))
1026 as_warn (_("Overflow in expression, truncated to 16 bits"));
1030 if (expn
.X_op
!= O_constant
&& octets
< 2)
1032 /* Disallow .byte with a non constant expression that will
1033 require relocation. */
1034 as_bad (_("Relocatable values require at least WORD storage"));
1035 ignore_rest_of_line ();
1039 if (expn
.X_op
!= O_constant
1043 /* FIXME -- at one point TI tools used to output REL16
1044 relocations, but I don't think the latest tools do at all
1045 The current tools output extended relocations regardless of
1046 the addressing mode (I actually think that ".c_mode" is
1047 totally ignored in the latest tools). */
1050 emit_expr (&expn
, 4);
1056 emitting_long
= octets
== 4;
1057 emit_expr (&expn
, (octets
== 1) ? 2 : octets
);
1062 while (*input_line_pointer
++ == ',');
1064 input_line_pointer
--; /* Put terminator back into stream. */
1065 demand_empty_rest_of_line ();
1068 /* .global <symbol>[,...,<symbolN>]
1069 .def <symbol>[,...,<symbolN>]
1070 .ref <symbol>[,...,<symbolN>]
1072 These all identify global symbols.
1074 .def means the symbol is defined in the current module and can be accessed
1075 by other files. The symbol should be placed in the symbol table.
1077 .ref means the symbol is used in the current module but defined in another
1078 module. The linker is to resolve this symbol's definition at link time.
1080 .global should act as a .ref or .def, as needed.
1082 global, def and ref all have symbol storage classes of C_EXT.
1084 I can't identify any difference in how the "other" c54x assembler treats
1085 these, so we ignore the type here. */
1088 tic54x_global (int type
)
1095 as_warn (_("Use of .def/.ref is deprecated. Use .global instead"));
1097 ILLEGAL_WITHIN_STRUCT ();
1101 c
= get_symbol_name (&name
);
1102 symbolP
= symbol_find_or_make (name
);
1103 c
= restore_line_pointer (c
);
1105 S_SET_STORAGE_CLASS (symbolP
, C_EXT
);
1108 input_line_pointer
++;
1109 if (is_end_of_line
[(int) *input_line_pointer
])
1110 c
= *input_line_pointer
;
1115 demand_empty_rest_of_line ();
1118 /* Remove the symbol from the local label hash lookup. */
1121 tic54x_remove_local_label (const char *key
, void *value ATTRIBUTE_UNUSED
)
1123 void *elem
= hash_delete (local_label_hash
[macro_level
], key
, FALSE
);
1127 /* Reset all local labels. */
1130 tic54x_clear_local_labels (int ignored ATTRIBUTE_UNUSED
)
1132 hash_traverse (local_label_hash
[macro_level
], tic54x_remove_local_label
);
1137 .sect "section name"
1140 make sure local labels get cleared when changing sections
1142 ARG is 't' for text, 'd' for data, or '*' for a named section
1144 For compatibility, '*' sections are SEC_CODE if instructions are
1145 encountered, or SEC_DATA if not.
1149 tic54x_sect (int arg
)
1151 ILLEGAL_WITHIN_STRUCT ();
1153 /* Local labels are cleared when changing sections. */
1154 tic54x_clear_local_labels (0);
1158 else if (arg
== 'd')
1164 /* Make sure all named initialized sections flagged properly. If we
1165 encounter instructions, we'll flag it with SEC_CODE as well. */
1166 const char *flags
= ",\"w\"\n";
1168 /* If there are quotes, remove them. */
1169 if (*input_line_pointer
== '"')
1171 name
= demand_copy_C_string (&len
);
1172 demand_empty_rest_of_line ();
1173 name
= concat (name
, flags
, (char *) NULL
);
1179 c
= get_symbol_name (&name
);
1180 name
= concat (name
, flags
, (char *) NULL
);
1181 (void) restore_line_pointer (c
);
1182 demand_empty_rest_of_line ();
1185 input_scrub_insert_line (name
);
1186 obj_coff_section (0);
1188 /* If there was a line label, make sure that it gets assigned the proper
1189 section. This is for compatibility, even though the actual behavior
1190 is not explicitly defined. For consistency, we make .sect behave
1191 like .usect, since that is probably what people expect. */
1192 if (line_label
!= NULL
)
1194 S_SET_SEGMENT (line_label
, now_seg
);
1195 symbol_set_frag (line_label
, frag_now
);
1196 S_SET_VALUE (line_label
, frag_now_fix ());
1197 if (S_GET_STORAGE_CLASS (line_label
) != C_EXT
)
1198 S_SET_STORAGE_CLASS (line_label
, C_LABEL
);
1203 /* [symbol] .space space_in_bits
1204 [symbol] .bes space_in_bits
1205 BES puts the symbol at the *last* word allocated
1207 cribbed from s_space. */
1210 tic54x_space (int arg
)
1216 int bits_per_byte
= (OCTETS_PER_BYTE
* 8);
1218 symbolS
*label
= line_label
;
1221 ILLEGAL_WITHIN_STRUCT ();
1223 #ifdef md_flush_pending_output
1224 md_flush_pending_output ();
1227 /* Read the bit count. */
1230 /* Some expressions are unresolvable until later in the assembly pass;
1231 postpone until relaxation/fixup. we also have to postpone if a previous
1232 partial allocation has not been completed yet. */
1233 if (expn
.X_op
!= O_constant
|| frag_bit_offset (frag_now
, now_seg
) == -1)
1235 struct bit_info
*bi
= XNEW (struct bit_info
);
1240 p
= frag_var (rs_machine_dependent
,
1241 65536 * 2, 1, (relax_substateT
) 0,
1242 make_expr_symbol (&expn
), (offsetT
) 0,
1250 /* Reduce the required size by any bit offsets currently left over
1251 from a previous .space/.bes/.field directive. */
1252 bit_offset
= frag_now
->tc_frag_data
;
1253 if (bit_offset
!= 0 && bit_offset
< 16)
1255 int spare_bits
= bits_per_byte
- bit_offset
;
1257 if (spare_bits
>= expn
.X_add_number
)
1259 /* Don't have to do anything; sufficient bits have already been
1260 allocated; just point the label to the right place. */
1263 symbol_set_frag (label
, frag_now
);
1264 S_SET_VALUE (label
, frag_now_fix () - 1);
1267 frag_now
->tc_frag_data
+= expn
.X_add_number
;
1270 expn
.X_add_number
-= spare_bits
;
1271 /* Set the label to point to the first word allocated, which in this
1272 case is the previous word, which was only partially filled. */
1273 if (!bes
&& label
!= NULL
)
1275 symbol_set_frag (label
, frag_now
);
1276 S_SET_VALUE (label
, frag_now_fix () - 1);
1280 /* Convert bits to bytes/words and octets, rounding up. */
1281 words
= ((expn
.X_add_number
+ bits_per_byte
- 1) / bits_per_byte
);
1282 /* How many do we have left over? */
1283 bit_offset
= expn
.X_add_number
% bits_per_byte
;
1284 octets
= words
* OCTETS_PER_BYTE
;
1287 as_warn (_(".space/.bes repeat count is negative, ignored"));
1290 else if (octets
== 0)
1292 as_warn (_(".space/.bes repeat count is zero, ignored"));
1296 /* If we are in the absolute section, just bump the offset. */
1297 if (now_seg
== absolute_section
)
1299 abs_section_offset
+= words
;
1300 if (bes
&& label
!= NULL
)
1301 S_SET_VALUE (label
, abs_section_offset
- 1);
1302 frag_now
->tc_frag_data
= bit_offset
;
1307 p
= frag_var (rs_fill
, 1, 1,
1308 (relax_substateT
) 0, (symbolS
*) 0,
1309 (offsetT
) octets
, (char *) 0);
1311 /* Make note of how many bits of this word we've allocated so far. */
1312 frag_now
->tc_frag_data
= bit_offset
;
1314 /* .bes puts label at *last* word allocated. */
1315 if (bes
&& label
!= NULL
)
1317 symbol_set_frag (label
, frag_now
);
1318 S_SET_VALUE (label
, frag_now_fix () - 1);
1326 demand_empty_rest_of_line ();
1329 /* [symbol] .usect "section-name", size-in-words
1330 [, [blocking-flag] [, alignment-flag]]
1332 Uninitialized section.
1333 Non-zero blocking means that if the section would cross a page (128-word)
1334 boundary, it will be page-aligned.
1335 Non-zero alignment aligns on a longword boundary.
1337 Has no effect on the current section. */
1340 tic54x_usect (int x ATTRIBUTE_UNUSED
)
1347 int size
, blocking_flag
, alignment_flag
;
1349 subsegT current_subseg
;
1352 ILLEGAL_WITHIN_STRUCT ();
1354 current_seg
= now_seg
; /* Save current seg. */
1355 current_subseg
= now_subseg
; /* Save current subseg. */
1357 c
= get_symbol_name (§ion_name
); /* Get terminator. */
1358 name
= xstrdup (section_name
);
1359 c
= restore_line_pointer (c
);
1362 ++input_line_pointer
;
1365 as_bad (_("Missing size argument"));
1366 ignore_rest_of_line ();
1370 size
= get_absolute_expression ();
1372 /* Read a possibly present third argument (blocking flag). */
1373 if (*input_line_pointer
== ',')
1375 ++input_line_pointer
;
1376 if (*input_line_pointer
!= ',')
1377 blocking_flag
= get_absolute_expression ();
1381 /* Read a possibly present fourth argument (alignment flag). */
1382 if (*input_line_pointer
== ',')
1384 ++input_line_pointer
;
1385 alignment_flag
= get_absolute_expression ();
1391 blocking_flag
= alignment_flag
= 0;
1393 seg
= subseg_new (name
, 0);
1394 flags
= bfd_get_section_flags (stdoutput
, seg
) | SEC_ALLOC
;
1398 /* s_align eats end of line; restore it. */
1400 --input_line_pointer
;
1403 if (line_label
!= NULL
)
1405 S_SET_SEGMENT (line_label
, seg
);
1406 symbol_set_frag (line_label
, frag_now
);
1407 S_SET_VALUE (line_label
, frag_now_fix ());
1408 /* Set scl to label, since that's what TI does. */
1409 if (S_GET_STORAGE_CLASS (line_label
) != C_EXT
)
1410 S_SET_STORAGE_CLASS (line_label
, C_LABEL
);
1413 seg_info (seg
)->bss
= 1; /* Uninitialized data. */
1415 p
= frag_var (rs_fill
, 1, 1,
1416 (relax_substateT
) 0, (symbolS
*) line_label
,
1417 size
* OCTETS_PER_BYTE
, (char *) 0);
1421 flags
|= SEC_TIC54X_BLOCK
;
1423 if (!bfd_set_section_flags (stdoutput
, seg
, flags
))
1424 as_warn (_("Error setting flags for \"%s\": %s"), name
,
1425 bfd_errmsg (bfd_get_error ()));
1427 subseg_set (current_seg
, current_subseg
); /* Restore current seg. */
1428 demand_empty_rest_of_line ();
1431 static enum cpu_version
1432 lookup_version (const char *ver
)
1434 enum cpu_version version
= VNONE
;
1436 if (ver
[0] == '5' && ver
[1] == '4')
1438 if (strlen (ver
) == 3
1439 && (ver
[2] == '1' || ver
[2] == '2' || ver
[2] == '3'
1440 || ver
[2] == '5' || ver
[2] == '8' || ver
[2] == '9'))
1441 version
= ver
[2] - '0';
1442 else if (strlen (ver
) == 5
1443 && TOUPPER (ver
[3]) == 'L'
1444 && TOUPPER (ver
[4]) == 'P'
1445 && (ver
[2] == '5' || ver
[2] == '6'))
1446 version
= ver
[2] - '0' + 10;
1453 set_cpu (enum cpu_version version
)
1456 if (version
== V545LP
|| version
== V546LP
)
1458 symbolS
*symbolP
= symbol_new ("__allow_lp", absolute_section
,
1459 (valueT
) 1, &zero_address_frag
);
1460 SF_SET_LOCAL (symbolP
);
1461 symbol_table_insert (symbolP
);
1465 /* .version cpu-version
1466 cpu-version may be one of the following:
1476 This is for compatibility only. It currently has no affect on assembly. */
1477 static int cpu_needs_set
= 1;
1480 tic54x_version (int x ATTRIBUTE_UNUSED
)
1482 enum cpu_version version
= VNONE
;
1483 enum cpu_version old_version
= cpu
;
1487 ILLEGAL_WITHIN_STRUCT ();
1490 ver
= input_line_pointer
;
1491 while (!is_end_of_line
[(int) *input_line_pointer
])
1492 ++input_line_pointer
;
1493 c
= *input_line_pointer
;
1494 *input_line_pointer
= 0;
1496 version
= lookup_version (ver
);
1498 if (cpu
!= VNONE
&& cpu
!= version
)
1499 as_warn (_("CPU version has already been set"));
1501 if (version
== VNONE
)
1503 as_bad (_("Unrecognized version '%s'"), ver
);
1504 ignore_rest_of_line ();
1507 else if (assembly_begun
&& version
!= old_version
)
1509 as_bad (_("Changing of CPU version on the fly not supported"));
1510 ignore_rest_of_line ();
1516 *input_line_pointer
= c
;
1517 demand_empty_rest_of_line ();
1520 /* 'f' = float, 'x' = xfloat, 'd' = double, 'l' = ldouble. */
1523 tic54x_float_cons (int type
)
1525 if (current_stag
!= 0)
1526 tic54x_struct_field ('f');
1528 #ifdef md_flush_pending_output
1529 md_flush_pending_output ();
1532 /* Align to long word boundary (4 octets) unless it's ".xfloat". */
1535 frag_align (2, 0, 2);
1536 /* If there's a label, assign it to the first allocated word. */
1537 if (line_label
!= NULL
)
1539 symbol_set_frag (line_label
, frag_now
);
1540 S_SET_VALUE (line_label
, frag_now_fix ());
1547 /* The argument is capitalized if it should be zero-terminated
1548 's' is normal string with upper 8-bits zero-filled, 'p' is packed.
1549 Code copied from stringer, and slightly modified so that strings are packed
1550 and encoded into the correct octets. */
1553 tic54x_stringer (int type
)
1556 int append_zero
= type
== 'S' || type
== 'P';
1557 int packed
= type
== 'p' || type
== 'P';
1558 int last_char
= -1; /* Packed strings need two bytes at a time to encode. */
1560 if (current_stag
!= NULL
)
1562 tic54x_struct_field ('*');
1566 #ifdef md_flush_pending_output
1567 md_flush_pending_output ();
1570 c
= ','; /* Do loop. */
1574 switch (*input_line_pointer
)
1578 unsigned short value
= get_absolute_expression ();
1579 FRAG_APPEND_1_CHAR ( value
& 0xFF);
1580 FRAG_APPEND_1_CHAR ((value
>> 8) & 0xFF);
1584 ++input_line_pointer
; /* -> 1st char of string. */
1585 while (is_a_char (c
= next_char_of_string ()))
1589 FRAG_APPEND_1_CHAR (c
);
1590 FRAG_APPEND_1_CHAR (0);
1594 /* Packed strings are filled MS octet first. */
1595 if (last_char
== -1)
1599 FRAG_APPEND_1_CHAR (c
);
1600 FRAG_APPEND_1_CHAR (last_char
);
1607 if (packed
&& last_char
!= -1)
1609 FRAG_APPEND_1_CHAR (0);
1610 FRAG_APPEND_1_CHAR (last_char
);
1615 FRAG_APPEND_1_CHAR (0);
1616 FRAG_APPEND_1_CHAR (0);
1619 know (input_line_pointer
[-1] == '\"');
1623 c
= *input_line_pointer
;
1624 if (!is_end_of_line
[c
])
1625 ++input_line_pointer
;
1628 /* Finish up any leftover packed string. */
1629 if (packed
&& last_char
!= -1)
1631 FRAG_APPEND_1_CHAR (0);
1632 FRAG_APPEND_1_CHAR (last_char
);
1634 demand_empty_rest_of_line ();
1638 tic54x_p2align (int arg ATTRIBUTE_UNUSED
)
1640 as_bad (_("p2align not supported on this target"));
1644 tic54x_align_words (int arg
)
1646 /* Only ".align" with no argument is allowed within .struct/.union. */
1649 if (!is_end_of_line
[(int) *input_line_pointer
])
1652 as_warn (_("Argument to .even ignored"));
1654 count
= get_absolute_expression ();
1657 if (current_stag
!= NULL
&& arg
== 128)
1659 if (current_stag
->current_bitfield_offset
!= 0)
1661 current_stag
->current_bitfield_offset
= 0;
1662 ++abs_section_offset
;
1664 demand_empty_rest_of_line ();
1668 ILLEGAL_WITHIN_STRUCT ();
1670 s_align_bytes (count
<< 1);
1673 /* Initialize multiple-bit fields withing a single word of memory. */
1676 tic54x_field (int ignore ATTRIBUTE_UNUSED
)
1682 symbolS
*label
= line_label
;
1684 if (current_stag
!= NULL
)
1686 tic54x_struct_field ('.');
1690 input_line_pointer
= parse_expression (input_line_pointer
, &expn
);
1692 if (*input_line_pointer
== ',')
1694 ++input_line_pointer
;
1695 size
= get_absolute_expression ();
1696 if (size
< 1 || size
> 32)
1698 as_bad (_("Invalid field size, must be from 1 to 32"));
1699 ignore_rest_of_line ();
1704 /* Truncate values to the field width. */
1705 if (expn
.X_op
!= O_constant
)
1707 /* If the expression value is relocatable, the field size *must*
1711 as_bad (_("field size must be 16 when value is relocatable"));
1712 ignore_rest_of_line ();
1716 frag_now
->tc_frag_data
= 0;
1717 emit_expr (&expn
, 2);
1721 unsigned long fmask
= (size
== 32) ? 0xFFFFFFFF : (1ul << size
) - 1;
1723 value
= expn
.X_add_number
;
1724 expn
.X_add_number
&= fmask
;
1725 if (value
!= (valueT
) expn
.X_add_number
)
1726 as_warn (_("field value truncated"));
1727 value
= expn
.X_add_number
;
1728 /* Bits are stored MS first. */
1731 frag_now
->tc_frag_data
= 0;
1733 md_number_to_chars (p
, (value
>> (size
- 16)) & 0xFFFF, 2);
1738 int bit_offset
= frag_bit_offset (frag_now
, now_seg
);
1740 fragS
*alloc_frag
= bit_offset_frag (frag_now
, now_seg
);
1741 if (bit_offset
== -1)
1743 struct bit_info
*bi
= XNEW (struct bit_info
);
1744 /* We don't know the previous offset at this time, so store the
1745 info we need and figure it out later. */
1746 expressionS size_exp
;
1748 size_exp
.X_op
= O_constant
;
1749 size_exp
.X_add_number
= size
;
1751 bi
->type
= TYPE_FIELD
;
1753 p
= frag_var (rs_machine_dependent
,
1754 4, 1, (relax_substateT
) 0,
1755 make_expr_symbol (&size_exp
), (offsetT
) 0,
1759 else if (bit_offset
== 0 || bit_offset
+ size
> 16)
1761 /* Align a new field. */
1763 frag_now
->tc_frag_data
= 0;
1764 alloc_frag
= frag_now
;
1768 /* Put the new value entirely within the existing one. */
1769 p
= alloc_frag
== frag_now
?
1770 frag_now
->fr_literal
+ frag_now_fix_octets () - 2 :
1771 alloc_frag
->fr_literal
;
1774 symbol_set_frag (label
, alloc_frag
);
1775 if (alloc_frag
== frag_now
)
1776 S_SET_VALUE (label
, frag_now_fix () - 1);
1780 value
<<= 16 - alloc_frag
->tc_frag_data
- size
;
1782 /* OR in existing value. */
1783 if (alloc_frag
->tc_frag_data
)
1784 value
|= ((unsigned short) p
[1] << 8) | p
[0];
1785 md_number_to_chars (p
, value
, 2);
1786 alloc_frag
->tc_frag_data
+= size
;
1787 if (alloc_frag
->tc_frag_data
== 16)
1788 alloc_frag
->tc_frag_data
= 0;
1792 demand_empty_rest_of_line ();
1795 /* Ideally, we want to check SEC_LOAD and SEC_HAS_CONTENTS, but those aren't
1796 available yet. seg_info ()->bss is the next best thing. */
1799 tic54x_initialized_section (segT seg
)
1801 return !seg_info (seg
)->bss
;
1804 /* .clink ["section name"]
1806 Marks the section as conditionally linked (link only if contents are
1807 referenced elsewhere.
1808 Without a name, refers to the current initialized section.
1809 Name is required for uninitialized sections. */
1812 tic54x_clink (int ignored ATTRIBUTE_UNUSED
)
1816 ILLEGAL_WITHIN_STRUCT ();
1818 if (*input_line_pointer
== '\"')
1820 char *section_name
= ++input_line_pointer
;
1823 while (is_a_char (next_char_of_string ()))
1825 know (input_line_pointer
[-1] == '\"');
1826 input_line_pointer
[-1] = 0;
1827 name
= xstrdup (section_name
);
1829 seg
= bfd_get_section_by_name (stdoutput
, name
);
1832 as_bad (_("Unrecognized section '%s'"), section_name
);
1833 ignore_rest_of_line ();
1839 if (!tic54x_initialized_section (seg
))
1841 as_bad (_("Current section is unitialized, "
1842 "section name required for .clink"));
1843 ignore_rest_of_line ();
1848 seg
->flags
|= SEC_TIC54X_CLINK
;
1850 demand_empty_rest_of_line ();
1853 /* Change the default include directory to be the current source file's
1854 directory, instead of the current working directory. If DOT is non-zero,
1855 set to "." instead. */
1858 tic54x_set_default_include (int dot
)
1860 const char *dir
= ".";
1865 const char *curfile
;
1868 curfile
= as_where (&lineno
);
1869 dir
= xstrdup (curfile
);
1870 tmp
= strrchr (dir
, '/');
1878 if (include_dir_count
== 0)
1880 include_dirs
= XNEWVEC (const char *, 1);
1881 include_dir_count
= 1;
1883 include_dirs
[0] = dir
;
1884 if (len
> include_dir_maxlen
)
1885 include_dir_maxlen
= len
;
1887 else if (include_dirs
!= NULL
)
1888 include_dirs
[0] = ".";
1891 /* .include "filename" | filename
1892 .copy "filename" | filename
1894 FIXME 'include' file should be omitted from any output listing,
1895 'copy' should be included in any output listing
1896 FIXME -- prevent any included files from changing listing (compat only)
1897 FIXME -- need to include source file directory in search path; what's a
1898 good way to do this?
1900 Entering/exiting included/copied file clears all local labels. */
1903 tic54x_include (int ignored ATTRIBUTE_UNUSED
)
1905 char newblock
[] = " .newblock\n";
1910 ILLEGAL_WITHIN_STRUCT ();
1914 if (*input_line_pointer
== '"')
1916 filename
= demand_copy_C_string (&len
);
1917 demand_empty_rest_of_line ();
1921 filename
= input_line_pointer
;
1922 while (!is_end_of_line
[(int) *input_line_pointer
])
1923 ++input_line_pointer
;
1924 c
= *input_line_pointer
;
1925 *input_line_pointer
= '\0';
1926 filename
= xstrdup (filename
);
1927 *input_line_pointer
= c
;
1928 demand_empty_rest_of_line ();
1930 /* Insert a partial line with the filename (for the sake of s_include)
1932 The included file will be inserted before the newblock, so that the
1933 newblock is executed after the included file is processed. */
1934 input
= concat ("\"", filename
, "\"\n", newblock
, (char *) NULL
);
1935 input_scrub_insert_line (input
);
1937 tic54x_clear_local_labels (0);
1939 tic54x_set_default_include (0);
1945 tic54x_message (int type
)
1951 ILLEGAL_WITHIN_STRUCT ();
1953 if (*input_line_pointer
== '"')
1954 msg
= demand_copy_C_string (&len
);
1957 msg
= input_line_pointer
;
1958 while (!is_end_of_line
[(int) *input_line_pointer
])
1959 ++input_line_pointer
;
1960 c
= *input_line_pointer
;
1961 *input_line_pointer
= 0;
1962 msg
= xstrdup (msg
);
1963 *input_line_pointer
= c
;
1969 as_tsktsk ("%s", msg
);
1972 as_warn ("%s", msg
);
1979 demand_empty_rest_of_line ();
1983 Define a special symbol that refers to the loadtime address rather than the
1984 runtime address within the current section.
1986 This symbol gets a special storage class so that when it is resolved, it is
1987 resolved relative to the load address (lma) of the section rather than the
1988 run address (vma). */
1991 tic54x_label (int ignored ATTRIBUTE_UNUSED
)
1997 ILLEGAL_WITHIN_STRUCT ();
1999 c
= get_symbol_name (&name
);
2000 symbolP
= colon (name
);
2001 S_SET_STORAGE_CLASS (symbolP
, C_STATLAB
);
2003 (void) restore_line_pointer (c
);
2004 demand_empty_rest_of_line ();
2008 Install all memory-mapped register names into the symbol table as
2009 absolute local symbols. */
2012 tic54x_mmregs (int ignored ATTRIBUTE_UNUSED
)
2016 ILLEGAL_WITHIN_STRUCT ();
2018 for (sym
= (tic54x_symbol
*) mmregs
; sym
->name
; sym
++)
2020 symbolS
*symbolP
= symbol_new (sym
->name
, absolute_section
,
2021 (valueT
) sym
->value
, &zero_address_frag
);
2022 SF_SET_LOCAL (symbolP
);
2023 symbol_table_insert (symbolP
);
2028 Count defaults to 1024. */
2031 tic54x_loop (int count
)
2033 ILLEGAL_WITHIN_STRUCT ();
2036 if (!is_end_of_line
[(int) *input_line_pointer
])
2037 count
= get_absolute_expression ();
2039 do_repeat (count
, "LOOP", "ENDLOOP");
2042 /* Normally, endloop gets eaten by the preceding loop. */
2045 tic54x_endloop (int ignore ATTRIBUTE_UNUSED
)
2047 as_bad (_("ENDLOOP without corresponding LOOP"));
2048 ignore_rest_of_line ();
2051 /* .break [condition]. */
2054 tic54x_break (int ignore ATTRIBUTE_UNUSED
)
2058 ILLEGAL_WITHIN_STRUCT ();
2061 if (!is_end_of_line
[(int) *input_line_pointer
])
2062 cond
= get_absolute_expression ();
2065 end_repeat (substitution_line
? 1 : 0);
2069 set_address_mode (int mode
)
2072 if (mode
== far_mode
)
2074 symbolS
*symbolP
= symbol_new ("__allow_far", absolute_section
,
2075 (valueT
) 1, &zero_address_frag
);
2076 SF_SET_LOCAL (symbolP
);
2077 symbol_table_insert (symbolP
);
2081 static int address_mode_needs_set
= 1;
2084 tic54x_address_mode (int mode
)
2086 if (assembly_begun
&& amode
!= (unsigned) mode
)
2088 as_bad (_("Mixing of normal and extended addressing not supported"));
2089 ignore_rest_of_line ();
2092 if (mode
== far_mode
&& cpu
!= VNONE
&& cpu
!= V548
&& cpu
!= V549
)
2094 as_bad (_("Extended addressing not supported on the specified CPU"));
2095 ignore_rest_of_line ();
2099 set_address_mode (mode
);
2100 demand_empty_rest_of_line ();
2103 /* .sblock "section"|section [,...,"section"|section]
2104 Designate initialized sections for blocking. */
2107 tic54x_sblock (int ignore ATTRIBUTE_UNUSED
)
2111 ILLEGAL_WITHIN_STRUCT ();
2118 if (*input_line_pointer
== '"')
2122 name
= demand_copy_C_string (&len
);
2128 c
= get_symbol_name (§ion_name
);
2129 name
= xstrdup (section_name
);
2130 (void) restore_line_pointer (c
);
2133 seg
= bfd_get_section_by_name (stdoutput
, name
);
2136 as_bad (_("Unrecognized section '%s'"), name
);
2137 ignore_rest_of_line ();
2140 else if (!tic54x_initialized_section (seg
))
2142 as_bad (_(".sblock may be used for initialized sections only"));
2143 ignore_rest_of_line ();
2146 seg
->flags
|= SEC_TIC54X_BLOCK
;
2148 c
= *input_line_pointer
;
2149 if (!is_end_of_line
[(int) c
])
2150 ++input_line_pointer
;
2153 demand_empty_rest_of_line ();
2156 /* symbol .set value
2159 value must be defined externals; no forward-referencing allowed
2160 symbols assigned with .set/.equ may not be redefined. */
2163 tic54x_set (int ignore ATTRIBUTE_UNUSED
)
2168 ILLEGAL_WITHIN_STRUCT ();
2172 as_bad (_("Symbol missing for .set/.equ"));
2173 ignore_rest_of_line ();
2176 name
= xstrdup (S_GET_NAME (line_label
));
2178 if ((symbolP
= symbol_find (name
)) == NULL
2179 && (symbolP
= md_undefined_symbol (name
)) == NULL
)
2181 symbolP
= symbol_new (name
, absolute_section
, 0, &zero_address_frag
);
2182 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
2185 S_SET_DATA_TYPE (symbolP
, T_INT
);
2186 S_SET_SEGMENT (symbolP
, absolute_section
);
2187 symbol_table_insert (symbolP
);
2188 pseudo_set (symbolP
);
2189 demand_empty_rest_of_line ();
2194 List false conditional blocks. */
2197 tic54x_fclist (int show
)
2200 listing
&= ~LISTING_NOCOND
;
2202 listing
|= LISTING_NOCOND
;
2203 demand_empty_rest_of_line ();
2207 tic54x_sslist (int show
)
2209 ILLEGAL_WITHIN_STRUCT ();
2211 listing_sslist
= show
;
2214 /* .var SYM[,...,SYMN]
2215 Define a substitution string to be local to a macro. */
2218 tic54x_var (int ignore ATTRIBUTE_UNUSED
)
2220 static char empty
[] = "";
2224 ILLEGAL_WITHIN_STRUCT ();
2226 if (macro_level
== 0)
2228 as_bad (_(".var may only be used within a macro definition"));
2229 ignore_rest_of_line ();
2234 if (!ISALPHA (*input_line_pointer
))
2236 as_bad (_("Substitution symbols must begin with a letter"));
2237 ignore_rest_of_line ();
2240 c
= get_symbol_name (&name
);
2241 /* .var symbols start out with a null string. */
2242 name
= xstrdup (name
);
2243 hash_insert (subsym_hash
[macro_level
], name
, empty
);
2244 c
= restore_line_pointer (c
);
2247 ++input_line_pointer
;
2248 if (is_end_of_line
[(int) *input_line_pointer
])
2249 c
= *input_line_pointer
;
2254 demand_empty_rest_of_line ();
2257 /* .mlib <macro library filename>
2259 Macro libraries are archived (standard AR-format) text macro definitions
2260 Expand the file and include it.
2262 FIXME need to try the source file directory as well. */
2265 tic54x_mlib (int ignore ATTRIBUTE_UNUSED
)
2272 ILLEGAL_WITHIN_STRUCT ();
2274 /* Parse the filename. */
2275 if (*input_line_pointer
== '"')
2277 if ((filename
= demand_copy_C_string (&len
)) == NULL
)
2284 while (!is_end_of_line
[(int) *input_line_pointer
]
2285 && !ISSPACE (*input_line_pointer
))
2287 obstack_1grow (¬es
, *input_line_pointer
);
2288 ++input_line_pointer
;
2291 obstack_1grow (¬es
, '\0');
2292 filename
= obstack_finish (¬es
);
2294 demand_empty_rest_of_line ();
2296 tic54x_set_default_include (0);
2297 path
= XNEWVEC (char, (unsigned long) len
+ include_dir_maxlen
+ 5);
2299 for (i
= 0; i
< include_dir_count
; i
++)
2303 strcpy (path
, include_dirs
[i
]);
2305 strcat (path
, filename
);
2306 if ((try = fopen (path
, "r")) != NULL
)
2313 if (i
>= include_dir_count
)
2319 /* FIXME: if path is found, malloc'd storage is not freed. Of course, this
2320 happens all over the place, and since the assembler doesn't usually keep
2321 running for a very long time, it really doesn't matter. */
2322 register_dependency (path
);
2324 /* Expand all archive entries to temporary files and include them. */
2325 abfd
= bfd_openr (path
, NULL
);
2328 as_bad (_("can't open macro library file '%s' for reading: %s"),
2329 path
, bfd_errmsg (bfd_get_error ()));
2330 ignore_rest_of_line ();
2333 if (!bfd_check_format (abfd
, bfd_archive
))
2335 as_bad (_("File '%s' not in macro archive format"), path
);
2336 ignore_rest_of_line ();
2340 /* Open each BFD as binary (it should be straight ASCII text). */
2341 for (mbfd
= bfd_openr_next_archived_file (abfd
, NULL
);
2342 mbfd
!= NULL
; mbfd
= bfd_openr_next_archived_file (abfd
, mbfd
))
2344 /* Get a size at least as big as the archive member. */
2345 bfd_size_type size
= bfd_get_size (mbfd
);
2346 char *buf
= XNEWVEC (char, size
);
2347 char *fname
= tmpnam (NULL
);
2350 /* We're not sure how big it is, but it will be smaller than "size". */
2351 size
= bfd_bread (buf
, size
, mbfd
);
2353 /* Write to a temporary file, then use s_include to include it
2355 ftmp
= fopen (fname
, "w+b");
2356 fwrite ((void *) buf
, size
, 1, ftmp
);
2357 if (size
== 0 || buf
[size
- 1] != '\n')
2358 fwrite ("\n", 1, 1, ftmp
);
2361 input_scrub_insert_file (fname
);
2366 const pseudo_typeS md_pseudo_table
[] =
2368 { "algebraic", s_ignore
, 0 },
2369 { "align" , tic54x_align_words
, 128 },
2370 { "ascii" , tic54x_stringer
, 'p' },
2371 { "asciz" , tic54x_stringer
, 'P' },
2372 { "even" , tic54x_align_words
, 2 },
2373 { "asg" , tic54x_asg
, 0 },
2374 { "eval" , tic54x_eval
, 0 },
2375 { "bss" , tic54x_bss
, 0 },
2376 { "byte" , tic54x_cons
, 'b' },
2377 { "ubyte" , tic54x_cons
, 'B' },
2378 { "char" , tic54x_cons
, 'c' },
2379 { "uchar" , tic54x_cons
, 'C' },
2380 { "clink" , tic54x_clink
, 0 },
2381 { "c_mode" , tic54x_address_mode
, c_mode
},
2382 { "copy" , tic54x_include
, 'c' },
2383 { "include" , tic54x_include
, 'i' },
2384 { "data" , tic54x_sect
, 'd' },
2385 { "double" , tic54x_float_cons
, 'd' },
2386 { "ldouble" , tic54x_float_cons
, 'l' },
2387 { "drlist" , s_ignore
, 0 },
2388 { "drnolist" , s_ignore
, 0 },
2389 { "emsg" , tic54x_message
, 'e' },
2390 { "mmsg" , tic54x_message
, 'm' },
2391 { "wmsg" , tic54x_message
, 'w' },
2392 { "far_mode" , tic54x_address_mode
, far_mode
},
2393 { "fclist" , tic54x_fclist
, 1 },
2394 { "fcnolist" , tic54x_fclist
, 0 },
2395 { "field" , tic54x_field
, -1 },
2396 { "float" , tic54x_float_cons
, 'f' },
2397 { "xfloat" , tic54x_float_cons
, 'x' },
2398 { "global" , tic54x_global
, 'g' },
2399 { "def" , tic54x_global
, 'd' },
2400 { "ref" , tic54x_global
, 'r' },
2401 { "half" , tic54x_cons
, 'h' },
2402 { "uhalf" , tic54x_cons
, 'H' },
2403 { "short" , tic54x_cons
, 's' },
2404 { "ushort" , tic54x_cons
, 'S' },
2405 { "if" , s_if
, (int) O_ne
},
2406 { "elseif" , s_elseif
, (int) O_ne
},
2407 { "else" , s_else
, 0 },
2408 { "endif" , s_endif
, 0 },
2409 { "int" , tic54x_cons
, 'i' },
2410 { "uint" , tic54x_cons
, 'I' },
2411 { "word" , tic54x_cons
, 'w' },
2412 { "uword" , tic54x_cons
, 'W' },
2413 { "label" , tic54x_label
, 0 }, /* Loadtime
2415 { "length" , s_ignore
, 0 },
2416 { "width" , s_ignore
, 0 },
2417 { "long" , tic54x_cons
, 'l' },
2418 { "ulong" , tic54x_cons
, 'L' },
2419 { "xlong" , tic54x_cons
, 'x' },
2420 { "loop" , tic54x_loop
, 1024 },
2421 { "break" , tic54x_break
, 0 },
2422 { "endloop" , tic54x_endloop
, 0 },
2423 { "mlib" , tic54x_mlib
, 0 },
2424 { "mlist" , s_ignore
, 0 },
2425 { "mnolist" , s_ignore
, 0 },
2426 { "mmregs" , tic54x_mmregs
, 0 },
2427 { "newblock" , tic54x_clear_local_labels
, 0 },
2428 { "option" , s_ignore
, 0 },
2429 { "p2align" , tic54x_p2align
, 0 },
2430 { "sblock" , tic54x_sblock
, 0 },
2431 { "sect" , tic54x_sect
, '*' },
2432 { "set" , tic54x_set
, 0 },
2433 { "equ" , tic54x_set
, 0 },
2434 { "space" , tic54x_space
, 0 },
2435 { "bes" , tic54x_space
, 1 },
2436 { "sslist" , tic54x_sslist
, 1 },
2437 { "ssnolist" , tic54x_sslist
, 0 },
2438 { "string" , tic54x_stringer
, 's' },
2439 { "pstring" , tic54x_stringer
, 'p' },
2440 { "struct" , tic54x_struct
, 0 },
2441 { "tag" , tic54x_tag
, 0 },
2442 { "endstruct", tic54x_endstruct
, 0 },
2443 { "tab" , s_ignore
, 0 },
2444 { "text" , tic54x_sect
, 't' },
2445 { "union" , tic54x_struct
, 1 },
2446 { "endunion" , tic54x_endstruct
, 1 },
2447 { "usect" , tic54x_usect
, 0 },
2448 { "var" , tic54x_var
, 0 },
2449 { "version" , tic54x_version
, 0 },
2454 md_parse_option (int c
, const char *arg
)
2460 case OPTION_COFF_VERSION
:
2462 int version
= atoi (arg
);
2464 if (version
!= 0 && version
!= 1 && version
!= 2)
2465 as_fatal (_("Bad COFF version '%s'"), arg
);
2466 /* FIXME -- not yet implemented. */
2469 case OPTION_CPU_VERSION
:
2471 cpu
= lookup_version (arg
);
2474 as_fatal (_("Bad CPU version '%s'"), arg
);
2477 case OPTION_ADDRESS_MODE
:
2479 address_mode_needs_set
= 1;
2481 case OPTION_STDERR_TO_FILE
:
2483 const char *filename
= arg
;
2484 FILE *fp
= fopen (filename
, "w+");
2487 as_fatal (_("Can't redirect stderr to the file '%s'"), filename
);
2489 if ((fp
= freopen (filename
, "w+", stderr
)) == NULL
)
2490 as_fatal (_("Can't redirect stderr to the file '%s'"), filename
);
2498 /* Create a "local" substitution string hash table for a new macro level
2499 Some docs imply that macros have to use .newblock in order to be able
2500 to re-use a local label. We effectively do an automatic .newblock by
2501 deleting the local label hash between macro invocations. */
2504 tic54x_macro_start (void)
2507 subsym_hash
[macro_level
] = hash_new ();
2508 local_label_hash
[macro_level
] = hash_new ();
2512 tic54x_macro_info (const macro_entry
*macro
)
2514 const formal_entry
*entry
;
2516 /* Put the formal args into the substitution symbol table. */
2517 for (entry
= macro
->formals
; entry
; entry
= entry
->next
)
2519 char *name
= xstrndup (entry
->name
.ptr
, entry
->name
.len
);
2520 char *value
= xstrndup (entry
->actual
.ptr
, entry
->actual
.len
);
2522 name
[entry
->name
.len
] = '\0';
2523 value
[entry
->actual
.len
] = '\0';
2524 hash_insert (subsym_hash
[macro_level
], name
, value
);
2528 /* Get rid of this macro's .var's, arguments, and local labels. */
2531 tic54x_macro_end (void)
2533 hash_die (subsym_hash
[macro_level
]);
2534 subsym_hash
[macro_level
] = NULL
;
2535 hash_die (local_label_hash
[macro_level
]);
2536 local_label_hash
[macro_level
] = NULL
;
2541 subsym_symlen (char *a
, char *ignore ATTRIBUTE_UNUSED
)
2546 /* Compare symbol A to string B. */
2549 subsym_symcmp (char *a
, char *b
)
2551 return strcmp (a
, b
);
2554 /* Return the index of the first occurrence of B in A, or zero if none
2555 assumes b is an integer char value as a string. Index is one-based. */
2558 subsym_firstch (char *a
, char *b
)
2561 char *tmp
= strchr (a
, val
);
2563 return tmp
? tmp
- a
+ 1 : 0;
2566 /* Similar to firstch, but returns index of last occurrence of B in A. */
2569 subsym_lastch (char *a
, char *b
)
2572 char *tmp
= strrchr (a
, val
);
2574 return tmp
? tmp
- a
+ 1 : 0;
2577 /* Returns 1 if string A is defined in the symbol table (NOT the substitution
2581 subsym_isdefed (char *a
, char *ignore ATTRIBUTE_UNUSED
)
2583 symbolS
*symbolP
= symbol_find (a
);
2585 return symbolP
!= NULL
;
2588 /* Assign first member of comma-separated list B (e.g. "1,2,3") to the symbol
2589 A, or zero if B is a null string. Both arguments *must* be substitution
2590 symbols, unsubstituted. */
2593 subsym_ismember (char *sym
, char *list
)
2595 char *elem
, *ptr
, *listv
;
2600 listv
= subsym_lookup (list
, macro_level
);
2603 as_bad (_("Undefined substitution symbol '%s'"), list
);
2604 ignore_rest_of_line ();
2608 ptr
= elem
= xstrdup (listv
);
2609 while (*ptr
&& *ptr
!= ',')
2613 subsym_create_or_replace (sym
, elem
);
2615 /* Reassign the list. */
2616 subsym_create_or_replace (list
, ptr
);
2618 /* Assume this value, docs aren't clear. */
2622 /* Return zero if not a constant; otherwise:
2630 subsym_iscons (char *a
, char *ignore ATTRIBUTE_UNUSED
)
2634 parse_expression (a
, &expn
);
2636 if (expn
.X_op
== O_constant
)
2638 int len
= strlen (a
);
2640 switch (TOUPPER (a
[len
- 1]))
2653 /* No suffix; either octal, hex, or decimal. */
2654 if (*a
== '0' && len
> 1)
2656 if (TOUPPER (a
[1]) == 'X')
2666 /* Return 1 if A is a valid symbol name. Expects string input. */
2669 subsym_isname (char *a
, char *ignore ATTRIBUTE_UNUSED
)
2671 if (!is_name_beginner (*a
))
2675 if (!is_part_of_name (*a
))
2682 /* Return whether the string is a register; accepts ar0-7, unless .mmregs has
2683 been seen; if so, recognize any memory-mapped register.
2684 Note this does not recognize "A" or "B" accumulators. */
2687 subsym_isreg (char *a
, char *ignore ATTRIBUTE_UNUSED
)
2689 if (hash_find (reg_hash
, a
))
2691 if (hash_find (mmreg_hash
, a
))
2696 /* Return the structure size, given the stag. */
2699 subsym_structsz (char *name
, char *ignore ATTRIBUTE_UNUSED
)
2701 struct stag
*stag
= (struct stag
*) hash_find (stag_hash
, name
);
2709 /* If anybody actually uses this, they can fix it :)
2710 FIXME I'm not sure what the "reference point" of a structure is. It might
2711 be either the initial offset given .struct, or it may be the offset of the
2712 structure within another structure, or it might be something else
2713 altogether. since the TI assembler doesn't seem to ever do anything but
2714 return zero, we punt and return zero. */
2717 subsym_structacc (char *stag_name ATTRIBUTE_UNUSED
,
2718 char *ignore ATTRIBUTE_UNUSED
)
2724 math_ceil (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2726 return (float) ceil (arg1
);
2730 math_cvi (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2736 math_floor (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2738 return (float) floor (arg1
);
2742 math_fmod (float arg1
, float arg2
)
2744 return (int) arg1
% (int) arg2
;
2748 math_int (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2750 return ((float) ((int) arg1
)) == arg1
;
2754 math_round (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2756 return arg1
> 0 ? (int) (arg1
+ 0.5) : (int) (arg1
- 0.5);
2760 math_sgn (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2762 return (arg1
< 0) ? -1 : (arg1
? 1 : 0);
2766 math_trunc (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2772 math_acos (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2774 return (float) acos (arg1
);
2778 math_asin (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2780 return (float) asin (arg1
);
2784 math_atan (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2786 return (float) atan (arg1
);
2790 math_atan2 (float arg1
, float arg2
)
2792 return (float) atan2 (arg1
, arg2
);
2796 math_cosh (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2798 return (float) cosh (arg1
);
2802 math_cos (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2804 return (float) cos (arg1
);
2808 math_cvf (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2810 return (float) arg1
;
2814 math_exp (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2816 return (float) exp (arg1
);
2820 math_fabs (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2822 return (float) fabs (arg1
);
2825 /* expr1 * 2^expr2. */
2828 math_ldexp (float arg1
, float arg2
)
2830 return arg1
* (float) pow (2.0, arg2
);
2834 math_log10 (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2836 return (float) log10 (arg1
);
2840 math_log (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2842 return (float) log (arg1
);
2846 math_max (float arg1
, float arg2
)
2848 return (arg1
> arg2
) ? arg1
: arg2
;
2852 math_min (float arg1
, float arg2
)
2854 return (arg1
< arg2
) ? arg1
: arg2
;
2858 math_pow (float arg1
, float arg2
)
2860 return (float) pow (arg1
, arg2
);
2864 math_sin (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2866 return (float) sin (arg1
);
2870 math_sinh (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2872 return (float) sinh (arg1
);
2876 math_sqrt (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2878 return (float) sqrt (arg1
);
2882 math_tan (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2884 return (float) tan (arg1
);
2888 math_tanh (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2890 return (float) tanh (arg1
);
2893 /* Built-in substitution symbol functions and math functions. */
2897 int (*proc
) (char *, char *);
2899 } subsym_proc_entry
;
2901 static const subsym_proc_entry subsym_procs
[] =
2903 /* Assembler built-in string substitution functions. */
2904 { "$symlen", subsym_symlen
, 1, },
2905 { "$symcmp", subsym_symcmp
, 2, },
2906 { "$firstch", subsym_firstch
, 2, },
2907 { "$lastch", subsym_lastch
, 2, },
2908 { "$isdefed", subsym_isdefed
, 1, },
2909 { "$ismember", subsym_ismember
, 2, },
2910 { "$iscons", subsym_iscons
, 1, },
2911 { "$isname", subsym_isname
, 1, },
2912 { "$isreg", subsym_isreg
, 1, },
2913 { "$structsz", subsym_structsz
, 1, },
2914 { "$structacc", subsym_structacc
, 1, },
2921 float (*proc
) (float, float);
2926 static const math_proc_entry math_procs
[] =
2928 /* Integer-returning built-in math functions. */
2929 { "$cvi", math_cvi
, 1, 1 },
2930 { "$int", math_int
, 1, 1 },
2931 { "$sgn", math_sgn
, 1, 1 },
2933 /* Float-returning built-in math functions. */
2934 { "$acos", math_acos
, 1, 0 },
2935 { "$asin", math_asin
, 1, 0 },
2936 { "$atan", math_atan
, 1, 0 },
2937 { "$atan2", math_atan2
, 2, 0 },
2938 { "$ceil", math_ceil
, 1, 0 },
2939 { "$cosh", math_cosh
, 1, 0 },
2940 { "$cos", math_cos
, 1, 0 },
2941 { "$cvf", math_cvf
, 1, 0 },
2942 { "$exp", math_exp
, 1, 0 },
2943 { "$fabs", math_fabs
, 1, 0 },
2944 { "$floor", math_floor
, 1, 0 },
2945 { "$fmod", math_fmod
, 2, 0 },
2946 { "$ldexp", math_ldexp
, 2, 0 },
2947 { "$log10", math_log10
, 1, 0 },
2948 { "$log", math_log
, 1, 0 },
2949 { "$max", math_max
, 2, 0 },
2950 { "$min", math_min
, 2, 0 },
2951 { "$pow", math_pow
, 2, 0 },
2952 { "$round", math_round
, 1, 0 },
2953 { "$sin", math_sin
, 1, 0 },
2954 { "$sinh", math_sinh
, 1, 0 },
2955 { "$sqrt", math_sqrt
, 1, 0 },
2956 { "$tan", math_tan
, 1, 0 },
2957 { "$tanh", math_tanh
, 1, 0 },
2958 { "$trunc", math_trunc
, 1, 0 },
2959 { NULL
, NULL
, 0, 0 },
2967 const subsym_proc_entry
*subsym_proc
;
2968 const math_proc_entry
*math_proc
;
2969 const char *hash_err
;
2971 char *TIC54X_DIR
= getenv ("TIC54X_DIR");
2972 char *A_DIR
= TIC54X_DIR
? TIC54X_DIR
: getenv ("A_DIR");
2976 /* Look for A_DIR and add it to the include list. */
2979 char *tmp
= xstrdup (A_DIR
);
2983 char *next
= strchr (tmp
, ';');
2987 add_include_dir (tmp
);
2990 while (tmp
!= NULL
);
2993 op_hash
= hash_new ();
2994 for (tm
= (insn_template
*) tic54x_optab
; tm
->name
; tm
++)
2996 if (hash_find (op_hash
, tm
->name
))
2998 hash_err
= hash_insert (op_hash
, tm
->name
, (char *) tm
);
3000 as_fatal ("Internal Error: Can't hash %s: %s",
3001 tm
->name
, hash_err
);
3003 parop_hash
= hash_new ();
3004 for (tm
= (insn_template
*) tic54x_paroptab
; tm
->name
; tm
++)
3006 if (hash_find (parop_hash
, tm
->name
))
3008 hash_err
= hash_insert (parop_hash
, tm
->name
, (char *) tm
);
3010 as_fatal ("Internal Error: Can't hash %s: %s",
3011 tm
->name
, hash_err
);
3013 reg_hash
= hash_new ();
3014 for (sym
= (tic54x_symbol
*) regs
; sym
->name
; sym
++)
3016 /* Add basic registers to the symbol table. */
3017 symbolS
*symbolP
= symbol_new (sym
->name
, absolute_section
,
3018 (valueT
) sym
->value
, &zero_address_frag
);
3019 SF_SET_LOCAL (symbolP
);
3020 symbol_table_insert (symbolP
);
3021 hash_err
= hash_insert (reg_hash
, sym
->name
, (char *) sym
);
3023 for (sym
= (tic54x_symbol
*) mmregs
; sym
->name
; sym
++)
3024 hash_err
= hash_insert (reg_hash
, sym
->name
, (char *) sym
);
3025 mmreg_hash
= hash_new ();
3026 for (sym
= (tic54x_symbol
*) mmregs
; sym
->name
; sym
++)
3027 hash_err
= hash_insert (mmreg_hash
, sym
->name
, (char *) sym
);
3029 cc_hash
= hash_new ();
3030 for (sym
= (tic54x_symbol
*) condition_codes
; sym
->name
; sym
++)
3031 hash_err
= hash_insert (cc_hash
, sym
->name
, (char *) sym
);
3033 cc2_hash
= hash_new ();
3034 for (sym
= (tic54x_symbol
*) cc2_codes
; sym
->name
; sym
++)
3035 hash_err
= hash_insert (cc2_hash
, sym
->name
, (char *) sym
);
3037 cc3_hash
= hash_new ();
3038 for (sym
= (tic54x_symbol
*) cc3_codes
; sym
->name
; sym
++)
3039 hash_err
= hash_insert (cc3_hash
, sym
->name
, (char *) sym
);
3041 sbit_hash
= hash_new ();
3042 for (sym
= (tic54x_symbol
*) status_bits
; sym
->name
; sym
++)
3043 hash_err
= hash_insert (sbit_hash
, sym
->name
, (char *) sym
);
3045 misc_symbol_hash
= hash_new ();
3046 for (symname
= (char **) misc_symbols
; *symname
; symname
++)
3047 hash_err
= hash_insert (misc_symbol_hash
, *symname
, *symname
);
3049 /* Only the base substitution table and local label table are initialized;
3050 the others (for local macro substitution) get instantiated as needed. */
3051 local_label_hash
[0] = hash_new ();
3052 subsym_hash
[0] = hash_new ();
3053 for (subsym_proc
= subsym_procs
; subsym_proc
->name
; subsym_proc
++)
3054 hash_err
= hash_insert (subsym_hash
[0], subsym_proc
->name
,
3055 (char *) subsym_proc
);
3057 math_hash
= hash_new ();
3058 for (math_proc
= math_procs
; math_proc
->name
; math_proc
++)
3060 /* Insert into the main subsym hash for recognition; insert into
3061 the math hash to actually store information. */
3062 hash_err
= hash_insert (subsym_hash
[0], math_proc
->name
,
3063 (char *) math_proc
);
3064 hash_err
= hash_insert (math_hash
, math_proc
->name
,
3065 (char *) math_proc
);
3067 subsym_recurse_hash
= hash_new ();
3068 stag_hash
= hash_new ();
3072 is_accumulator (struct opstruct
*operand
)
3074 return strcasecmp (operand
->buf
, "a") == 0
3075 || strcasecmp (operand
->buf
, "b") == 0;
3078 /* Return the number of operands found, or -1 on error, copying the
3079 operands into the given array and the accompanying expressions into
3083 get_operands (struct opstruct operands
[], char *line
)
3087 int expecting_operand
= 0;
3090 while (numexp
< MAX_OPERANDS
&& !is_end_of_line
[(int) *lptr
])
3092 int paren_not_balanced
= 0;
3093 char *op_start
, *op_end
;
3095 while (*lptr
&& ISSPACE (*lptr
))
3098 while (paren_not_balanced
|| *lptr
!= ',')
3102 if (paren_not_balanced
)
3104 as_bad (_("Unbalanced parenthesis in operand %d"), numexp
);
3111 ++paren_not_balanced
;
3112 else if (*lptr
== ')')
3113 --paren_not_balanced
;
3117 if (op_end
!= op_start
)
3119 int len
= op_end
- op_start
;
3121 strncpy (operands
[numexp
].buf
, op_start
, len
);
3122 operands
[numexp
].buf
[len
] = 0;
3123 /* Trim trailing spaces; while the preprocessor gets rid of most,
3124 there are weird usage patterns that can introduce them
3125 (i.e. using strings for macro args). */
3126 while (len
> 0 && ISSPACE (operands
[numexp
].buf
[len
- 1]))
3127 operands
[numexp
].buf
[--len
] = 0;
3133 if (expecting_operand
|| *lptr
== ',')
3135 as_bad (_("Expecting operand after ','"));
3141 if (*++lptr
== '\0')
3143 as_bad (_("Expecting operand after ','"));
3146 expecting_operand
= 1;
3150 while (*lptr
&& ISSPACE (*lptr
++))
3152 if (!is_end_of_line
[(int) *lptr
])
3154 as_bad (_("Extra junk on line"));
3158 /* OK, now parse them into expressions. */
3159 for (i
= 0; i
< numexp
; i
++)
3161 memset (&operands
[i
].exp
, 0, sizeof (operands
[i
].exp
));
3162 if (operands
[i
].buf
[0] == '#')
3165 parse_expression (operands
[i
].buf
+ 1, &operands
[i
].exp
);
3167 else if (operands
[i
].buf
[0] == '@')
3169 /* Direct notation. */
3170 parse_expression (operands
[i
].buf
+ 1, &operands
[i
].exp
);
3172 else if (operands
[i
].buf
[0] == '*')
3175 char *paren
= strchr (operands
[i
].buf
, '(');
3177 /* Allow immediate syntax in the inner expression. */
3178 if (paren
&& paren
[1] == '#')
3181 /* Pull out the lk expression or SP offset, if present. */
3184 int len
= strlen (paren
);
3185 char *end
= paren
+ len
;
3188 while (end
[-1] != ')')
3191 as_bad (_("Badly formed address expression"));
3196 parse_expression (paren
, &operands
[i
].exp
);
3200 operands
[i
].exp
.X_op
= O_absent
;
3203 parse_expression (operands
[i
].buf
, &operands
[i
].exp
);
3209 /* Predicates for different operand types. */
3212 is_immediate (struct opstruct
*operand
)
3214 return *operand
->buf
== '#';
3217 /* This is distinguished from immediate because some numbers must be constants
3218 and must *not* have the '#' prefix. */
3221 is_absolute (struct opstruct
*operand
)
3223 return operand
->exp
.X_op
== O_constant
&& !is_immediate (operand
);
3226 /* Is this an indirect operand? */
3229 is_indirect (struct opstruct
*operand
)
3231 return operand
->buf
[0] == '*';
3234 /* Is this a valid dual-memory operand? */
3237 is_dual (struct opstruct
*operand
)
3239 if (is_indirect (operand
) && strncasecmp (operand
->buf
, "*ar", 3) == 0)
3241 char *tmp
= operand
->buf
+ 3;
3246 /* Only allow *ARx, *ARx-, *ARx+, or *ARx+0%. */
3247 valid_mod
= *tmp
== '\0' ||
3248 strcasecmp (tmp
, "-") == 0 ||
3249 strcasecmp (tmp
, "+") == 0 ||
3250 strcasecmp (tmp
, "+0%") == 0;
3251 return arf
>= 2 && arf
<= 5 && valid_mod
;
3257 is_mmreg (struct opstruct
*operand
)
3259 return (is_absolute (operand
)
3260 || is_immediate (operand
)
3261 || hash_find (mmreg_hash
, operand
->buf
) != 0);
3265 is_type (struct opstruct
*operand
, enum optype type
)
3270 return operand
->buf
[0] == 0;
3273 return is_dual (operand
);
3275 return is_indirect (operand
);
3277 /* This one *must* be immediate. */
3278 return is_immediate (operand
);
3287 /* Address may be a numeric, indirect, or an expression. */
3288 return !is_immediate (operand
);
3291 return is_mmreg (operand
);
3296 return is_accumulator (operand
);
3298 return is_accumulator (operand
) && TOUPPER (operand
->buf
[0]) == 'B';
3300 return is_accumulator (operand
) && TOUPPER (operand
->buf
[0]) == 'A';
3302 return strncasecmp ("ar", operand
->buf
, 2) == 0
3303 && ISDIGIT (operand
->buf
[2]);
3305 return hash_find (sbit_hash
, operand
->buf
) != 0 || is_absolute (operand
);
3307 return hash_find (cc_hash
, operand
->buf
) != 0;
3309 return hash_find (cc2_hash
, operand
->buf
) != 0;
3311 return hash_find (cc3_hash
, operand
->buf
) != 0
3312 || is_immediate (operand
) || is_absolute (operand
);
3314 return (is_immediate (operand
) || is_absolute (operand
))
3315 && operand
->exp
.X_add_number
== 16;
3317 /* Allow st0 or st1 instead of a numeric. */
3318 return is_absolute (operand
) || is_immediate (operand
) ||
3319 strcasecmp ("st0", operand
->buf
) == 0 ||
3320 strcasecmp ("st1", operand
->buf
) == 0;
3323 return is_absolute (operand
) || is_immediate (operand
);
3325 return (is_immediate (operand
) || is_absolute (operand
))
3326 && operand
->exp
.X_add_number
>= 0 && operand
->exp
.X_add_number
< 16;
3328 /* Let this one catch out-of-range values. */
3329 return (is_immediate (operand
) || is_absolute (operand
))
3330 && operand
->exp
.X_add_number
!= 16;
3334 return is_absolute (operand
) || is_immediate (operand
);
3336 return is_immediate (operand
)
3337 && operand
->exp
.X_op
== O_constant
3338 && operand
->exp
.X_add_number
>= 0
3339 && operand
->exp
.X_add_number
< 256;
3342 /* Allow anything; assumes opcodes are ordered with Smem operands
3348 /* Just make sure it's an integer; check range later. */
3349 return is_immediate (operand
);
3351 return strcasecmp ("t", operand
->buf
) == 0 ||
3352 strcasecmp ("treg", operand
->buf
) == 0;
3354 return strcasecmp ("ts", operand
->buf
) == 0;
3356 return strcasecmp ("asm", operand
->buf
) == 0;
3358 return strcasecmp ("trn", operand
->buf
) == 0;
3360 return strcasecmp ("dp", operand
->buf
) == 0;
3362 return strcasecmp ("arp", operand
->buf
) == 0;
3369 operands_match (tic54x_insn
*insn
,
3370 struct opstruct
*operands
,
3372 const enum optype
*refoptype
,
3376 int op
= 0, refop
= 0;
3378 if (opcount
== 0 && minops
== 0)
3381 while (op
<= maxops
&& refop
<= maxops
)
3383 while (!is_type (&operands
[op
], OPTYPE (refoptype
[refop
])))
3385 /* Skip an optional template operand if it doesn't agree
3386 with the current operand. */
3387 if (refoptype
[refop
] & OPT
)
3398 /* Save the actual operand type for later use. */
3399 operands
[op
].type
= OPTYPE (refoptype
[refop
]);
3402 /* Have we matched them all yet? */
3407 /* If a later operand is *not* optional, no match. */
3408 if ((refoptype
[refop
] & OPT
) == 0)
3410 /* Flag any implicit default OP_DST operands so we know to add
3411 them explicitly when encoding the operand later. */
3412 if (OPTYPE (refoptype
[refop
]) == OP_DST
)
3413 insn
->using_default_dst
= 1;
3425 /* 16-bit direct memory address
3426 Explicit dmad operands are always in last word of insn (usually second
3427 word, but bumped to third if lk addressing is used)
3429 We allow *(dmad) notation because the TI assembler allows it.
3432 0 for 16-bit addresses
3433 1 for full 23-bit addresses
3434 2 for the upper 7 bits of a 23-bit address (LDX). */
3437 encode_dmad (tic54x_insn
*insn
, struct opstruct
*operand
, int xpc_code
)
3439 int op
= 1 + insn
->is_lkaddr
;
3441 /* Only allow *(dmad) expressions; all others are invalid. */
3442 if (is_indirect (operand
) && operand
->buf
[strlen (operand
->buf
) - 1] != ')')
3444 as_bad (_("Invalid dmad syntax '%s'"), operand
->buf
);
3448 insn
->opcode
[op
].addr_expr
= operand
->exp
;
3450 if (insn
->opcode
[op
].addr_expr
.X_op
== O_constant
)
3452 valueT value
= insn
->opcode
[op
].addr_expr
.X_add_number
;
3456 insn
->opcode
[0].word
&= 0xFF80;
3457 insn
->opcode
[0].word
|= (value
>> 16) & 0x7F;
3458 insn
->opcode
[1].word
= value
& 0xFFFF;
3460 else if (xpc_code
== 2)
3461 insn
->opcode
[op
].word
= (value
>> 16) & 0xFFFF;
3463 insn
->opcode
[op
].word
= value
;
3467 /* Do the fixup later; just store the expression. */
3468 insn
->opcode
[op
].word
= 0;
3469 insn
->opcode
[op
].r_nchars
= 2;
3471 if (amode
== c_mode
)
3472 insn
->opcode
[op
].r_type
= BFD_RELOC_TIC54X_16_OF_23
;
3473 else if (xpc_code
== 1)
3475 /* This relocation spans two words, so adjust accordingly. */
3476 insn
->opcode
[0].addr_expr
= operand
->exp
;
3477 insn
->opcode
[0].r_type
= BFD_RELOC_TIC54X_23
;
3478 insn
->opcode
[0].r_nchars
= 4;
3479 insn
->opcode
[0].unresolved
= 1;
3480 /* It's really 2 words, but we want to stop encoding after the
3481 first, since we must encode both words at once. */
3484 else if (xpc_code
== 2)
3485 insn
->opcode
[op
].r_type
= BFD_RELOC_TIC54X_MS7_OF_23
;
3487 insn
->opcode
[op
].r_type
= BFD_RELOC_TIC54X_16_OF_23
;
3489 insn
->opcode
[op
].unresolved
= 1;
3495 /* 7-bit direct address encoding. */
3498 encode_address (tic54x_insn
*insn
, struct opstruct
*operand
)
3500 /* Assumes that dma addresses are *always* in word 0 of the opcode. */
3501 insn
->opcode
[0].addr_expr
= operand
->exp
;
3503 if (operand
->exp
.X_op
== O_constant
)
3504 insn
->opcode
[0].word
|= (operand
->exp
.X_add_number
& 0x7F);
3507 if (operand
->exp
.X_op
== O_register
)
3508 as_bad (_("Use the .mmregs directive to use memory-mapped register names such as '%s'"), operand
->buf
);
3509 /* Do the fixup later; just store the expression. */
3510 insn
->opcode
[0].r_nchars
= 1;
3511 insn
->opcode
[0].r_type
= BFD_RELOC_TIC54X_PARTLS7
;
3512 insn
->opcode
[0].unresolved
= 1;
3519 encode_indirect (tic54x_insn
*insn
, struct opstruct
*operand
)
3524 if (insn
->is_lkaddr
)
3526 /* lk addresses always go in the second insn word. */
3527 mod
= ((TOUPPER (operand
->buf
[1]) == 'A') ? 12 :
3528 (operand
->buf
[1] == '(') ? 15 :
3529 (strchr (operand
->buf
, '%') != NULL
) ? 14 : 13);
3530 arf
= ((mod
== 12) ? operand
->buf
[3] - '0' :
3531 (mod
== 15) ? 0 : operand
->buf
[4] - '0');
3533 insn
->opcode
[1].addr_expr
= operand
->exp
;
3535 if (operand
->exp
.X_op
== O_constant
)
3536 insn
->opcode
[1].word
= operand
->exp
.X_add_number
;
3539 insn
->opcode
[1].word
= 0;
3540 insn
->opcode
[1].r_nchars
= 2;
3541 insn
->opcode
[1].r_type
= BFD_RELOC_TIC54X_16_OF_23
;
3542 insn
->opcode
[1].unresolved
= 1;
3545 else if (strncasecmp (operand
->buf
, "*sp (", 4) == 0)
3547 /* Stack offsets look the same as 7-bit direct addressing. */
3548 return encode_address (insn
, operand
);
3552 arf
= (TOUPPER (operand
->buf
[1]) == 'A' ?
3553 operand
->buf
[3] : operand
->buf
[4]) - '0';
3555 if (operand
->buf
[1] == '+')
3557 mod
= 3; /* *+ARx */
3558 if (insn
->tm
->flags
& FL_SMR
)
3559 as_warn (_("Address mode *+ARx is write-only. "
3560 "Results of reading are undefined."));
3562 else if (operand
->buf
[4] == '\0')
3564 else if (operand
->buf
[5] == '\0')
3565 mod
= (operand
->buf
[4] == '-' ? 1 : 2); /* *ARx+ / *ARx- */
3566 else if (operand
->buf
[6] == '\0')
3568 if (operand
->buf
[5] == '0')
3569 mod
= (operand
->buf
[4] == '-' ? 5 : 6); /* *ARx+0 / *ARx-0 */
3571 mod
= (operand
->buf
[4] == '-' ? 8 : 10);/* *ARx+% / *ARx-% */
3573 else if (TOUPPER (operand
->buf
[6]) == 'B')
3574 mod
= (operand
->buf
[4] == '-' ? 4 : 7); /* ARx+0B / *ARx-0B */
3575 else if (TOUPPER (operand
->buf
[6]) == '%')
3576 mod
= (operand
->buf
[4] == '-' ? 9 : 11); /* ARx+0% / *ARx - 0% */
3579 as_bad (_("Unrecognized indirect address format \"%s\""),
3585 insn
->opcode
[0].word
|= 0x80 | (mod
<< 3) | arf
;
3591 encode_integer (tic54x_insn
*insn
,
3592 struct opstruct
*operand
,
3596 unsigned short mask
)
3598 long parse
, integer
;
3600 insn
->opcode
[which
].addr_expr
= operand
->exp
;
3602 if (operand
->exp
.X_op
== O_constant
)
3604 parse
= operand
->exp
.X_add_number
;
3605 /* Hack -- fixup for 16-bit hex quantities that get converted positive
3606 instead of negative. */
3607 if ((parse
& 0x8000) && min
== -32768 && max
== 32767)
3608 integer
= (short) parse
;
3612 if (integer
>= min
&& integer
<= max
)
3614 insn
->opcode
[which
].word
|= (integer
& mask
);
3617 as_bad (_("Operand '%s' out of range (%d <= x <= %d)"),
3618 operand
->buf
, min
, max
);
3622 if (insn
->opcode
[which
].addr_expr
.X_op
== O_constant
)
3624 insn
->opcode
[which
].word
|=
3625 insn
->opcode
[which
].addr_expr
.X_add_number
& mask
;
3629 /* Do the fixup later; just store the expression. */
3630 bfd_reloc_code_real_type rtype
=
3631 (mask
== 0x1FF ? BFD_RELOC_TIC54X_PARTMS9
:
3632 mask
== 0xFFFF ? BFD_RELOC_TIC54X_16_OF_23
:
3633 mask
== 0x7F ? BFD_RELOC_TIC54X_PARTLS7
: BFD_RELOC_8
);
3634 int size
= (mask
== 0x1FF || mask
== 0xFFFF) ? 2 : 1;
3636 if (rtype
== BFD_RELOC_8
)
3637 as_bad (_("Error in relocation handling"));
3639 insn
->opcode
[which
].r_nchars
= size
;
3640 insn
->opcode
[which
].r_type
= rtype
;
3641 insn
->opcode
[which
].unresolved
= 1;
3651 encode_condition (tic54x_insn
*insn
, struct opstruct
*operand
)
3653 tic54x_symbol
*cc
= (tic54x_symbol
*) hash_find (cc_hash
, operand
->buf
);
3656 as_bad (_("Unrecognized condition code \"%s\""), operand
->buf
);
3659 #define CC_GROUP 0x40
3661 #define CATG_A1 0x07
3662 #define CATG_B1 0x30
3663 #define CATG_A2 0x30
3664 #define CATG_B2 0x0C
3665 #define CATG_C2 0x03
3666 /* Disallow group 1 conditions mixed with group 2 conditions
3667 if group 1, allow only one category A and one category B
3668 if group 2, allow only one each of category A, B, and C. */
3669 if (((insn
->opcode
[0].word
& 0xFF) != 0))
3671 if ((insn
->opcode
[0].word
& CC_GROUP
) != (cc
->value
& CC_GROUP
))
3673 as_bad (_("Condition \"%s\" does not match preceding group"),
3677 if (insn
->opcode
[0].word
& CC_GROUP
)
3679 if ((insn
->opcode
[0].word
& CC_ACC
) != (cc
->value
& CC_ACC
))
3681 as_bad (_("Condition \"%s\" uses a different accumulator from "
3682 "a preceding condition"),
3686 if ((insn
->opcode
[0].word
& CATG_A1
) && (cc
->value
& CATG_A1
))
3688 as_bad (_("Only one comparison conditional allowed"));
3691 if ((insn
->opcode
[0].word
& CATG_B1
) && (cc
->value
& CATG_B1
))
3693 as_bad (_("Only one overflow conditional allowed"));
3697 else if ( ((insn
->opcode
[0].word
& CATG_A2
) && (cc
->value
& CATG_A2
))
3698 || ((insn
->opcode
[0].word
& CATG_B2
) && (cc
->value
& CATG_B2
))
3699 || ((insn
->opcode
[0].word
& CATG_C2
) && (cc
->value
& CATG_C2
)))
3701 as_bad (_("Duplicate %s conditional"), operand
->buf
);
3706 insn
->opcode
[0].word
|= cc
->value
;
3711 encode_cc3 (tic54x_insn
*insn
, struct opstruct
*operand
)
3713 tic54x_symbol
*cc3
= (tic54x_symbol
*) hash_find (cc3_hash
, operand
->buf
);
3714 int value
= cc3
? cc3
->value
: operand
->exp
.X_add_number
<< 8;
3716 if ((value
& 0x0300) != value
)
3718 as_bad (_("Unrecognized condition code \"%s\""), operand
->buf
);
3721 insn
->opcode
[0].word
|= value
;
3726 encode_arx (tic54x_insn
*insn
, struct opstruct
*operand
)
3728 int arf
= strlen (operand
->buf
) >= 3 ? operand
->buf
[2] - '0' : -1;
3730 if (strncasecmp ("ar", operand
->buf
, 2) || arf
< 0 || arf
> 7)
3732 as_bad (_("Invalid auxiliary register (use AR0-AR7)"));
3735 insn
->opcode
[0].word
|= arf
;
3740 encode_cc2 (tic54x_insn
*insn
, struct opstruct
*operand
)
3742 tic54x_symbol
*cc2
= (tic54x_symbol
*) hash_find (cc2_hash
, operand
->buf
);
3746 as_bad (_("Unrecognized condition code \"%s\""), operand
->buf
);
3749 insn
->opcode
[0].word
|= cc2
->value
;
3754 encode_operand (tic54x_insn
*insn
, enum optype type
, struct opstruct
*operand
)
3756 int ext
= (insn
->tm
->flags
& FL_EXT
) != 0;
3758 if (type
== OP_MMR
&& operand
->exp
.X_op
!= O_constant
)
3760 /* Disallow long-constant addressing for memory-mapped addressing. */
3761 if (insn
->is_lkaddr
)
3763 as_bad (_("lk addressing modes are invalid for memory-mapped "
3764 "register addressing"));
3768 /* Warn about *+ARx when used with MMR operands. */
3769 if (strncasecmp (operand
->buf
, "*+ar", 4) == 0)
3771 as_warn (_("Address mode *+ARx is not allowed in memory-mapped "
3772 "register addressing. Resulting behavior is "
3782 /* 16-bit immediate value. */
3783 return encode_dmad (insn
, operand
, 0);
3785 if (TOUPPER (*operand
->buf
) == 'B')
3787 insn
->opcode
[ext
? (1 + insn
->is_lkaddr
) : 0].word
|= (1 << 9);
3788 if (insn
->using_default_dst
)
3789 insn
->opcode
[ext
? (1 + insn
->is_lkaddr
) : 0].word
|= (1 << 8);
3793 /* Make sure this agrees with the OP_DST operand. */
3794 if (!((TOUPPER (operand
->buf
[0]) == 'B') ^
3795 ((insn
->opcode
[0].word
& (1 << 8)) != 0)))
3797 as_bad (_("Destination accumulator for each part of this parallel "
3798 "instruction must be different"));
3804 if (TOUPPER (operand
->buf
[0]) == 'B')
3805 insn
->opcode
[ext
? (1 + insn
->is_lkaddr
) : 0].word
|= (1 << 8);
3810 int mod
= (operand
->buf
[4] == '\0' ? 0 : /* *arx */
3811 operand
->buf
[4] == '-' ? 1 : /* *arx- */
3812 operand
->buf
[5] == '\0' ? 2 : 3); /* *arx+, *arx+0% */
3813 int arf
= operand
->buf
[3] - '0' - 2;
3814 int code
= (mod
<< 2) | arf
;
3815 insn
->opcode
[0].word
|= (code
<< (type
== OP_Xmem
? 4 : 0));
3820 if (!is_indirect (operand
))
3821 return encode_address (insn
, operand
);
3824 return encode_indirect (insn
, operand
);
3826 return encode_dmad (insn
, operand
, 2);
3828 return encode_dmad (insn
, operand
, 1);
3831 return encode_dmad (insn
, operand
, 0);
3833 return encode_arx (insn
, operand
);
3838 int value
= operand
->exp
.X_add_number
;
3841 insn
->opcode
[0].word
|= value
;
3844 if (value
< 16 || value
> 24)
3846 as_bad (_("Memory mapped register \"%s\" out of range"),
3850 if (type
== OP_MMRX
)
3851 insn
->opcode
[0].word
|= (value
- 16) << 4;
3853 insn
->opcode
[0].word
|= (value
- 16);
3861 return encode_integer (insn
, operand
, ext
+ insn
->is_lkaddr
,
3864 return encode_integer (insn
, operand
, ext
+ insn
->is_lkaddr
,
3867 return encode_integer (insn
, operand
, 1 + insn
->is_lkaddr
,
3868 -32768, 32767, 0xFFFF);
3870 return encode_condition (insn
, operand
);
3872 return encode_cc2 (insn
, operand
);
3874 return encode_cc3 (insn
, operand
);
3876 return encode_integer (insn
, operand
, 0, 0, 15, 0xF);
3878 return encode_integer (insn
, operand
, 0, -128, 127, 0xFF);
3881 int value
= operand
->exp
.X_add_number
;
3883 if (value
< 1 || value
> 3)
3885 as_bad (_("Invalid operand (use 1, 2, or 3)"));
3888 code
= value
== 1 ? 0 : value
== 2 ? 0x2 : 0x1;
3889 insn
->opcode
[0].word
|= (code
<< 8);
3893 return encode_integer (insn
, operand
, 0, 0, 31, 0x1F);
3895 return encode_integer (insn
, operand
, 0, 0, 255, 0xFF);
3897 return encode_integer (insn
, operand
, 1 + insn
->is_lkaddr
,
3901 tic54x_symbol
*sbit
= (tic54x_symbol
*)
3902 hash_find (sbit_hash
, operand
->buf
);
3903 int value
= is_absolute (operand
) ?
3904 operand
->exp
.X_add_number
: (sbit
? sbit
->value
: -1);
3907 if (insn
->opcount
== 1)
3911 as_bad (_("A status register or status bit name is required"));
3914 /* Guess the register based on the status bit; "ovb" is the last
3915 status bit defined for st0. */
3916 if (sbit
> (tic54x_symbol
*) hash_find (sbit_hash
, "ovb"))
3921 as_bad (_("Unrecognized status bit \"%s\""), operand
->buf
);
3924 insn
->opcode
[0].word
|= value
;
3925 insn
->opcode
[0].word
|= (reg
<< 9);
3929 if (strcasecmp (operand
->buf
, "st0") == 0
3930 || strcasecmp (operand
->buf
, "st1") == 0)
3932 insn
->opcode
[0].word
|=
3933 ((unsigned short) (operand
->buf
[2] - '0')) << 9;
3936 else if (operand
->exp
.X_op
== O_constant
3937 && (operand
->exp
.X_add_number
== 0
3938 || operand
->exp
.X_add_number
== 1))
3940 insn
->opcode
[0].word
|=
3941 ((unsigned short) (operand
->exp
.X_add_number
)) << 9;
3944 as_bad (_("Invalid status register \"%s\""), operand
->buf
);
3947 return encode_integer (insn
, operand
, 0, -16, 15, 0x1F);
3949 return encode_integer (insn
, operand
, 0, 0, 7, 0x7);
3951 return encode_integer (insn
, operand
, 0, 0, 0x1FF, 0x1FF);
3953 if (operand
->exp
.X_add_number
!= 1
3954 && operand
->exp
.X_add_number
!= 2)
3956 as_bad (_("Operand \"%s\" out of range (use 1 or 2)"), operand
->buf
);
3959 insn
->opcode
[0].word
|= (operand
->exp
.X_add_number
- 1) << 9;
3968 /* No encoding necessary. */
3978 emit_insn (tic54x_insn
*insn
)
3981 flagword oldflags
= bfd_get_section_flags (stdoutput
, now_seg
);
3982 flagword flags
= oldflags
| SEC_CODE
;
3984 if (! bfd_set_section_flags (stdoutput
, now_seg
, flags
))
3985 as_warn (_("error setting flags for \"%s\": %s"),
3986 bfd_section_name (stdoutput
, now_seg
),
3987 bfd_errmsg (bfd_get_error ()));
3989 for (i
= 0; i
< insn
->words
; i
++)
3991 int size
= (insn
->opcode
[i
].unresolved
3992 && insn
->opcode
[i
].r_type
== BFD_RELOC_TIC54X_23
) ? 4 : 2;
3993 char *p
= frag_more (size
);
3996 md_number_to_chars (p
, (valueT
) insn
->opcode
[i
].word
, 2);
3998 md_number_to_chars (p
, (valueT
) insn
->opcode
[i
].word
<< 16, 4);
4000 if (insn
->opcode
[i
].unresolved
)
4001 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
,
4002 insn
->opcode
[i
].r_nchars
, &insn
->opcode
[i
].addr_expr
,
4003 FALSE
, insn
->opcode
[i
].r_type
);
4007 /* Convert the operand strings into appropriate opcode values
4008 return the total number of words used by the instruction. */
4011 build_insn (tic54x_insn
*insn
)
4015 /* Only non-parallel instructions support lk addressing. */
4016 if (!(insn
->tm
->flags
& FL_PAR
))
4018 for (i
= 0; i
< insn
->opcount
; i
++)
4020 if ((OPTYPE (insn
->operands
[i
].type
) == OP_Smem
4021 || OPTYPE (insn
->operands
[i
].type
) == OP_Lmem
4022 || OPTYPE (insn
->operands
[i
].type
) == OP_Sind
)
4023 && strchr (insn
->operands
[i
].buf
, '(')
4024 /* Don't mistake stack-relative addressing for lk addressing. */
4025 && strncasecmp (insn
->operands
[i
].buf
, "*sp (", 4) != 0)
4027 insn
->is_lkaddr
= 1;
4028 insn
->lkoperand
= i
;
4033 insn
->words
= insn
->tm
->words
+ insn
->is_lkaddr
;
4035 insn
->opcode
[0].word
= insn
->tm
->opcode
;
4036 if (insn
->tm
->flags
& FL_EXT
)
4037 insn
->opcode
[1 + insn
->is_lkaddr
].word
= insn
->tm
->opcode2
;
4039 for (i
= 0; i
< insn
->opcount
; i
++)
4041 enum optype type
= insn
->operands
[i
].type
;
4043 if (!encode_operand (insn
, type
, &insn
->operands
[i
]))
4046 if (insn
->tm
->flags
& FL_PAR
)
4047 for (i
= 0; i
< insn
->paropcount
; i
++)
4049 enum optype partype
= insn
->paroperands
[i
].type
;
4051 if (!encode_operand (insn
, partype
, &insn
->paroperands
[i
]))
4061 optimize_insn (tic54x_insn
*insn
)
4063 /* Optimize some instructions, helping out the brain-dead programmer. */
4064 #define is_zero(op) ((op).exp.X_op == O_constant && (op).exp.X_add_number == 0)
4065 if (strcasecmp (insn
->tm
->name
, "add") == 0)
4067 if (insn
->opcount
> 1
4068 && is_accumulator (&insn
->operands
[insn
->opcount
- 2])
4069 && is_accumulator (&insn
->operands
[insn
->opcount
- 1])
4070 && strcasecmp (insn
->operands
[insn
->opcount
- 2].buf
,
4071 insn
->operands
[insn
->opcount
- 1].buf
) == 0)
4074 insn
->using_default_dst
= 1;
4078 /* Try to collapse if Xmem and shift count is zero. */
4079 if ((OPTYPE (insn
->tm
->operand_types
[0]) == OP_Xmem
4080 && OPTYPE (insn
->tm
->operand_types
[1]) == OP_SHFT
4081 && is_zero (insn
->operands
[1]))
4082 /* Or if Smem, shift is zero or absent, and SRC == DST. */
4083 || (OPTYPE (insn
->tm
->operand_types
[0]) == OP_Smem
4084 && OPTYPE (insn
->tm
->operand_types
[1]) == OP_SHIFT
4085 && is_type (&insn
->operands
[1], OP_SHIFT
)
4086 && is_zero (insn
->operands
[1]) && insn
->opcount
== 3))
4088 insn
->operands
[1] = insn
->operands
[2];
4093 else if (strcasecmp (insn
->tm
->name
, "ld") == 0)
4095 if (insn
->opcount
== 3 && insn
->operands
[0].type
!= OP_SRC
)
4097 if ((OPTYPE (insn
->tm
->operand_types
[1]) == OP_SHIFT
4098 || OPTYPE (insn
->tm
->operand_types
[1]) == OP_SHFT
)
4099 && is_zero (insn
->operands
[1])
4100 && (OPTYPE (insn
->tm
->operand_types
[0]) != OP_lk
4101 || (insn
->operands
[0].exp
.X_op
== O_constant
4102 && insn
->operands
[0].exp
.X_add_number
<= 255
4103 && insn
->operands
[0].exp
.X_add_number
>= 0)))
4105 insn
->operands
[1] = insn
->operands
[2];
4111 else if (strcasecmp (insn
->tm
->name
, "sth") == 0
4112 || strcasecmp (insn
->tm
->name
, "stl") == 0)
4114 if ((OPTYPE (insn
->tm
->operand_types
[1]) == OP_SHIFT
4115 || OPTYPE (insn
->tm
->operand_types
[1]) == OP_SHFT
)
4116 && is_zero (insn
->operands
[1]))
4118 insn
->operands
[1] = insn
->operands
[2];
4123 else if (strcasecmp (insn
->tm
->name
, "sub") == 0)
4125 if (insn
->opcount
> 1
4126 && is_accumulator (&insn
->operands
[insn
->opcount
- 2])
4127 && is_accumulator (&insn
->operands
[insn
->opcount
- 1])
4128 && strcasecmp (insn
->operands
[insn
->opcount
- 2].buf
,
4129 insn
->operands
[insn
->opcount
- 1].buf
) == 0)
4132 insn
->using_default_dst
= 1;
4136 if ( ((OPTYPE (insn
->tm
->operand_types
[0]) == OP_Smem
4137 && OPTYPE (insn
->tm
->operand_types
[1]) == OP_SHIFT
)
4138 || (OPTYPE (insn
->tm
->operand_types
[0]) == OP_Xmem
4139 && OPTYPE (insn
->tm
->operand_types
[1]) == OP_SHFT
))
4140 && is_zero (insn
->operands
[1])
4141 && insn
->opcount
== 3)
4143 insn
->operands
[1] = insn
->operands
[2];
4151 /* Find a matching template if possible, and get the operand strings. */
4154 tic54x_parse_insn (tic54x_insn
*insn
, char *line
)
4156 insn
->tm
= (insn_template
*) hash_find (op_hash
, insn
->mnemonic
);
4159 as_bad (_("Unrecognized instruction \"%s\""), insn
->mnemonic
);
4163 insn
->opcount
= get_operands (insn
->operands
, line
);
4164 if (insn
->opcount
< 0)
4167 /* Check each variation of operands for this mnemonic. */
4168 while (insn
->tm
->name
&& strcasecmp (insn
->tm
->name
, insn
->mnemonic
) == 0)
4170 if (insn
->opcount
>= insn
->tm
->minops
4171 && insn
->opcount
<= insn
->tm
->maxops
4172 && operands_match (insn
, &insn
->operands
[0], insn
->opcount
,
4173 insn
->tm
->operand_types
,
4174 insn
->tm
->minops
, insn
->tm
->maxops
))
4176 /* SUCCESS! now try some optimizations. */
4177 if (optimize_insn (insn
))
4179 insn
->tm
= (insn_template
*) hash_find (op_hash
,
4188 as_bad (_("Unrecognized operand list '%s' for instruction '%s'"),
4189 line
, insn
->mnemonic
);
4193 /* We set this in start_line_hook, 'cause if we do a line replacement, we
4194 won't be able to see the next line. */
4195 static int parallel_on_next_line_hint
= 0;
4197 /* See if this is part of a parallel instruction
4198 Look for a subsequent line starting with "||". */
4201 next_line_shows_parallel (char *next_line
)
4203 /* Look for the second half. */
4204 while (ISSPACE (*next_line
))
4207 return (next_line
[0] == PARALLEL_SEPARATOR
4208 && next_line
[1] == PARALLEL_SEPARATOR
);
4212 tic54x_parse_parallel_insn_firstline (tic54x_insn
*insn
, char *line
)
4214 insn
->tm
= (insn_template
*) hash_find (parop_hash
, insn
->mnemonic
);
4217 as_bad (_("Unrecognized parallel instruction \"%s\""),
4222 while (insn
->tm
->name
&& strcasecmp (insn
->tm
->name
,
4223 insn
->mnemonic
) == 0)
4225 insn
->opcount
= get_operands (insn
->operands
, line
);
4226 if (insn
->opcount
< 0)
4228 if (insn
->opcount
== 2
4229 && operands_match (insn
, &insn
->operands
[0], insn
->opcount
,
4230 insn
->tm
->operand_types
, 2, 2))
4236 /* Didn't find a matching parallel; try for a normal insn. */
4240 /* Parse the second line of a two-line parallel instruction. */
4243 tic54x_parse_parallel_insn_lastline (tic54x_insn
*insn
, char *line
)
4245 int valid_mnemonic
= 0;
4247 insn
->paropcount
= get_operands (insn
->paroperands
, line
);
4248 while (insn
->tm
->name
&& strcasecmp (insn
->tm
->name
,
4249 insn
->mnemonic
) == 0)
4251 if (strcasecmp (insn
->tm
->parname
, insn
->parmnemonic
) == 0)
4255 if (insn
->paropcount
>= insn
->tm
->minops
4256 && insn
->paropcount
<= insn
->tm
->maxops
4257 && operands_match (insn
, insn
->paroperands
,
4259 insn
->tm
->paroperand_types
,
4260 insn
->tm
->minops
, insn
->tm
->maxops
))
4266 as_bad (_("Invalid operand (s) for parallel instruction \"%s\""),
4269 as_bad (_("Unrecognized parallel instruction combination \"%s || %s\""),
4270 insn
->mnemonic
, insn
->parmnemonic
);
4275 /* If quotes found, return copy of line up to closing quote;
4276 otherwise up until terminator.
4277 If it's a string, pass as-is; otherwise attempt substitution symbol
4278 replacement on the value. */
4281 subsym_get_arg (char *line
, const char *terminators
, char **str
, int nosub
)
4285 int is_string
= *line
== '"';
4286 int is_char
= ISDIGIT (*line
);
4290 while (ISDIGIT (*ptr
))
4293 *str
= xmemdup0 (line
, ptr
- line
);
4297 char *savedp
= input_line_pointer
;
4300 input_line_pointer
= ptr
;
4301 *str
= demand_copy_C_string (&len
);
4302 endp
= input_line_pointer
;
4303 input_line_pointer
= savedp
;
4305 /* Do forced substitutions if requested. */
4306 if (!nosub
&& **str
== ':')
4307 *str
= subsym_substitute (*str
, 1);
4311 const char *term
= terminators
;
4314 while (*ptr
&& *ptr
!= *term
)
4325 *str
= xmemdup0 (line
, ptr
- line
);
4326 /* Do simple substitution, if available. */
4327 if (!nosub
&& (value
= subsym_lookup (*str
, macro_level
)) != NULL
)
4334 /* Replace the given substitution string.
4335 We start at the innermost macro level, so that existing locals remain local
4336 Note: we're treating macro args identically to .var's; I don't know if
4337 that's compatible w/TI's assembler. */
4340 subsym_create_or_replace (char *name
, char *value
)
4344 for (i
= macro_level
; i
> 0; i
--)
4346 if (hash_find (subsym_hash
[i
], name
))
4348 hash_replace (subsym_hash
[i
], name
, value
);
4352 if (hash_find (subsym_hash
[0], name
))
4353 hash_replace (subsym_hash
[0], name
, value
);
4355 hash_insert (subsym_hash
[0], name
, value
);
4358 /* Look up the substitution string replacement for the given symbol.
4359 Start with the innermost macro substitution table given and work
4363 subsym_lookup (char *name
, int nest_level
)
4365 char *value
= hash_find (subsym_hash
[nest_level
], name
);
4367 if (value
|| nest_level
== 0)
4370 return subsym_lookup (name
, nest_level
- 1);
4373 /* Do substitution-symbol replacement on the given line (recursively).
4374 return the argument if no substitution was done
4376 Also look for built-in functions ($func (arg)) and local labels.
4378 If FORCED is set, look for forced substitutions of the form ':SYMBOL:'. */
4381 subsym_substitute (char *line
, int forced
)
4383 /* For each apparent symbol, see if it's a substitution symbol, and if so,
4384 replace it in the input. */
4385 char *replacement
; /* current replacement for LINE. */
4386 char *head
; /* Start of line. */
4387 char *ptr
; /* Current examination point. */
4388 int changed
= 0; /* Did we make a substitution? */
4389 int eval_line
= 0; /* Is this line a .eval/.asg statement? */
4390 int eval_symbol
= 0; /* Are we in the middle of the symbol for
4392 char *eval_end
= NULL
;
4394 int line_conditional
= 0;
4397 /* Work with a copy of the input line. */
4398 replacement
= xstrdup (line
);
4400 ptr
= head
= replacement
;
4402 /* Flag lines where we might need to replace a single '=' with two;
4403 GAS uses single '=' to assign macro args values, and possibly other
4404 places, so limit what we replace. */
4405 if (strstr (line
, ".if")
4406 || strstr (line
, ".elseif")
4407 || strstr (line
, ".break"))
4408 line_conditional
= 1;
4410 /* Watch out for .eval, so that we avoid doing substitution on the
4411 symbol being assigned a value. */
4412 if (strstr (line
, ".eval") || strstr (line
, ".asg"))
4415 /* If it's a macro definition, don't do substitution on the argument
4417 if (strstr (line
, ".macro"))
4420 while (!is_end_of_line
[(int) *ptr
])
4422 int current_char
= *ptr
;
4424 /* Need to update this since LINE may have been modified. */
4426 eval_end
= strrchr (ptr
, ',');
4428 /* Replace triple double quotes with bounding quote/escapes. */
4429 if (current_char
== '"' && ptr
[1] == '"' && ptr
[2] == '"')
4432 tmp
= strstr (ptr
+ 2, "\"\"\"");
4438 /* Replace a single '=' with a '==';
4439 for compatibility with older code only. */
4440 if (line_conditional
&& current_char
== '=')
4448 tmp
= concat (head
, "==", ptr
, (char *) NULL
);
4449 /* Continue examining after the '=='. */
4450 ptr
= tmp
+ strlen (head
) + 2;
4452 head
= replacement
= tmp
;
4456 /* Flag when we've reached the symbol part of .eval/.asg. */
4457 if (eval_line
&& ptr
>= eval_end
)
4460 /* For each apparent symbol, see if it's a substitution symbol, and if
4461 so, replace it in the input. */
4462 if ((forced
&& current_char
== ':')
4463 || (!forced
&& is_name_beginner (current_char
)))
4465 char *name
; /* Symbol to be replaced. */
4466 char *savedp
= input_line_pointer
;
4469 char *tail
; /* Rest of line after symbol. */
4471 /* Skip the colon. */
4475 input_line_pointer
= ptr
;
4476 c
= get_symbol_name (&name
);
4477 /* '?' is not normally part of a symbol, but it IS part of a local
4481 *input_line_pointer
++ = c
;
4482 c
= *input_line_pointer
;
4483 *input_line_pointer
= '\0';
4485 /* Avoid infinite recursion; if a symbol shows up a second time for
4486 substitution, leave it as is. */
4487 if (hash_find (subsym_recurse_hash
, name
) == NULL
)
4488 value
= subsym_lookup (name
, macro_level
);
4490 as_warn (_("%s symbol recursion stopped at "
4491 "second appearance of '%s'"),
4492 forced
? "Forced substitution" : "Substitution", name
);
4493 ptr
= tail
= input_line_pointer
;
4494 input_line_pointer
= savedp
;
4496 /* Check for local labels; replace them with the appropriate
4498 if ((*name
== '$' && ISDIGIT (name
[1]) && name
[2] == '\0')
4499 || name
[strlen (name
) - 1] == '?')
4501 /* Use an existing identifier for that label if, available, or
4502 create a new, unique identifier. */
4503 value
= hash_find (local_label_hash
[macro_level
], name
);
4507 char *namecopy
= xstrdup (name
);
4509 value
= strcpy (xmalloc (strlen (name
) + sizeof (digit
) + 1),
4512 value
[strlen (value
) - 1] = '\0';
4513 sprintf (digit
, ".%d", local_label_id
++);
4514 strcat (value
, digit
);
4515 hash_insert (local_label_hash
[macro_level
], namecopy
, value
);
4517 /* Indicate where to continue looking for substitutions. */
4520 /* Check for built-in subsym and math functions. */
4521 else if (value
!= NULL
&& *name
== '$')
4523 subsym_proc_entry
*entry
= (subsym_proc_entry
*) value
;
4524 math_proc_entry
*math_entry
= hash_find (math_hash
, name
);
4525 char *arg1
, *arg2
= NULL
;
4530 as_bad (_("Unrecognized substitution symbol function"));
4533 else if (*ptr
!= '(')
4535 as_bad (_("Missing '(' after substitution symbol function"));
4539 if (math_entry
!= NULL
)
4541 float farg1
, farg2
= 0;
4542 volatile float fresult
;
4544 farg1
= (float) strtod (ptr
, &ptr
);
4545 if (math_entry
->nargs
== 2)
4549 as_bad (_("Expecting second argument"));
4552 farg2
= (float) strtod (ptr
, &ptr
);
4554 fresult
= (*math_entry
->proc
) (farg1
, farg2
);
4555 value
= XNEWVEC (char, 128);
4556 if (math_entry
->int_return
)
4557 sprintf (value
, "%d", (int) fresult
);
4559 sprintf (value
, "%f", fresult
);
4562 as_bad (_("Extra junk in function call, expecting ')'"));
4565 /* Don't bother recursing; the replacement isn't a
4572 int arg_type
[2] = { *ptr
== '"' , 0 };
4573 int ismember
= !strcmp (entry
->name
, "$ismember");
4575 /* Parse one or two args, which must be a substitution
4576 symbol, string or a character-string constant. */
4577 /* For all functions, a string or substitution symbol may be
4578 used, with the following exceptions:
4579 firstch/lastch: 2nd arg must be character constant
4580 ismember: both args must be substitution symbols. */
4581 ptr
= subsym_get_arg (ptr
, ",)", &arg1
, ismember
);
4584 if (entry
->nargs
== 2)
4588 as_bad (_("Function expects two arguments"));
4591 /* Character constants are converted to numerics
4592 by the preprocessor. */
4593 arg_type
[1] = (ISDIGIT (*ptr
)) ? 2 : (*ptr
== '"');
4594 ptr
= subsym_get_arg (ptr
, ")", &arg2
, ismember
);
4596 /* Args checking. */
4597 if ((!strcmp (entry
->name
, "$firstch")
4598 || !strcmp (entry
->name
, "$lastch"))
4599 && arg_type
[1] != 2)
4601 as_bad (_("Expecting character constant argument"));
4605 && (arg_type
[0] != 0 || arg_type
[1] != 0))
4607 as_bad (_("Both arguments must be substitution symbols"));
4612 as_bad (_("Extra junk in function call, expecting ')'"));
4615 val
= (*entry
->proc
) (arg1
, arg2
);
4616 value
= XNEWVEC (char, 64);
4617 sprintf (value
, "%d", val
);
4619 /* Fix things up to replace the entire expression, not just the
4625 if (value
!= NULL
&& !eval_symbol
)
4627 /* Replace the symbol with its string replacement and
4628 continue. Recursively replace VALUE until either no
4629 substitutions are performed, or a substitution that has been
4630 previously made is encountered again.
4632 Put the symbol into the recursion hash table so we only
4633 try to replace a symbol once. */
4636 hash_insert (subsym_recurse_hash
, name
, name
);
4637 value
= subsym_substitute (value
, macro_level
> 0);
4638 hash_delete (subsym_recurse_hash
, name
, FALSE
);
4641 /* Temporarily zero-terminate where the symbol started. */
4647 /* Subscripted substitution symbol -- use just the
4648 indicated portion of the string; the description
4649 kinda indicates that forced substitution is not
4650 supposed to be recursive, but I'm not sure. */
4651 unsigned beg
, len
= 1; /* default to a single char */
4652 char *newval
= xstrdup (value
);
4654 savedp
= input_line_pointer
;
4655 input_line_pointer
= tail
+ 1;
4656 beg
= get_absolute_expression ();
4659 as_bad (_("Invalid subscript (use 1 to %d)"),
4660 (int) strlen (value
));
4663 if (*input_line_pointer
== ',')
4665 ++input_line_pointer
;
4666 len
= get_absolute_expression ();
4667 if (beg
+ len
> strlen (value
))
4669 as_bad (_("Invalid length (use 0 to %d"),
4670 (int) strlen (value
) - beg
);
4676 tail
= input_line_pointer
;
4679 as_bad (_("Missing ')' in subscripted substitution "
4680 "symbol expression"));
4684 input_line_pointer
= savedp
;
4690 tmp
= xmalloc (strlen (head
) + strlen (value
) +
4691 strlen (tail
+ 1) + 2);
4693 strcat (tmp
, value
);
4694 /* Make sure forced substitutions are properly terminated. */
4699 as_bad (_("Missing forced substitution terminator ':'"));
4705 /* Restore the character after the symbol end. */
4708 /* Continue examining after the replacement value. */
4709 ptr
= tmp
+ strlen (head
) + strlen (value
);
4711 head
= replacement
= tmp
;
4729 /* We use this to handle substitution symbols
4730 hijack input_line_pointer, replacing it with our substituted string.
4732 .sslist should enable listing the line after replacements are made...
4734 returns the new buffer limit. */
4737 tic54x_start_line_hook (void)
4740 char *replacement
= NULL
;
4742 /* Work with a copy of the input line, including EOL char. */
4743 endp
= input_line_pointer
;
4744 while (!is_end_of_line
[(int) *endp
++])
4746 line
= xmemdup0 (input_line_pointer
, endp
- input_line_pointer
);
4748 /* Scan ahead for parallel insns. */
4749 parallel_on_next_line_hint
= next_line_shows_parallel (endp
);
4751 /* If within a macro, first process forced replacements. */
4752 if (macro_level
> 0)
4753 replacement
= subsym_substitute (line
, 1);
4756 replacement
= subsym_substitute (replacement
, 0);
4758 if (replacement
!= line
)
4760 char *tmp
= replacement
;
4761 char *comment
= strchr (replacement
, ';');
4762 char endc
= replacement
[strlen (replacement
) - 1];
4764 /* Clean up the replacement; we'd prefer to have this done by the
4765 standard preprocessing equipment (maybe do_scrub_chars?)
4766 but for now, do a quick-and-dirty. */
4767 if (comment
!= NULL
)
4774 comment
= replacement
+ strlen (replacement
) - 1;
4776 /* Trim trailing whitespace. */
4777 while (ISSPACE (*comment
))
4784 /* Compact leading whitespace. */
4785 while (ISSPACE (tmp
[0]) && ISSPACE (tmp
[1]))
4788 input_line_pointer
= endp
;
4789 input_scrub_insert_line (tmp
);
4792 /* Keep track of whether we've done a substitution. */
4793 substitution_line
= 1;
4799 substitution_line
= 0;
4803 /* This is the guts of the machine-dependent assembler. STR points to a
4804 machine dependent instruction. This function is supposed to emit
4805 the frags/bytes it assembles to. */
4807 md_assemble (char *line
)
4809 static int repeat_slot
= 0;
4810 static int delay_slots
= 0; /* How many delay slots left to fill? */
4811 static int is_parallel
= 0;
4812 static tic54x_insn insn
;
4814 char *savedp
= input_line_pointer
;
4817 input_line_pointer
= line
;
4818 c
= get_symbol_name (&line
);
4822 if (address_mode_needs_set
)
4824 set_address_mode (amode
);
4825 address_mode_needs_set
= 0;
4838 strcpy (insn
.parmnemonic
, line
);
4839 lptr
= input_line_pointer
;
4841 input_line_pointer
= savedp
;
4843 if (tic54x_parse_parallel_insn_lastline (&insn
, lptr
))
4845 int words
= build_insn (&insn
);
4847 if (delay_slots
!= 0)
4849 if (words
> delay_slots
)
4851 as_bad (_("Instruction does not fit in available delay "
4852 "slots (%d-word insn, %d slots left)"),
4853 words
, delay_slots
);
4857 delay_slots
-= words
;
4863 memset (&insn
, 0, sizeof (insn
));
4864 strcpy (insn
.mnemonic
, line
);
4865 lptr
= input_line_pointer
;
4867 input_line_pointer
= savedp
;
4869 /* See if this line is part of a parallel instruction; if so, either this
4870 line or the next line will have the "||" specifier preceding the
4871 mnemonic, and we look for it in the parallel insn hash table. */
4872 if (strstr (line
, "||") != NULL
|| parallel_on_next_line_hint
)
4874 char *tmp
= strstr (line
, "||");
4878 if (tic54x_parse_parallel_insn_firstline (&insn
, lptr
))
4881 /* If the parallel part is on the same line, process it now,
4882 otherwise let the assembler pick up the next line for us. */
4885 while (ISSPACE (tmp
[2]))
4887 md_assemble (tmp
+ 2);
4892 as_bad (_("Unrecognized parallel instruction '%s'"), line
);
4897 if (tic54x_parse_insn (&insn
, lptr
))
4901 if ((insn
.tm
->flags
& FL_LP
)
4902 && cpu
!= V545LP
&& cpu
!= V546LP
)
4904 as_bad (_("Instruction '%s' requires an LP cpu version"),
4908 if ((insn
.tm
->flags
& FL_FAR
)
4909 && amode
!= far_mode
)
4911 as_bad (_("Instruction '%s' requires far mode addressing"),
4916 words
= build_insn (&insn
);
4918 /* Is this instruction in a delay slot? */
4921 if (words
> delay_slots
)
4923 as_warn (_("Instruction does not fit in available delay "
4924 "slots (%d-word insn, %d slots left). "
4925 "Resulting behavior is undefined."),
4926 words
, delay_slots
);
4930 /* Branches in delay slots are not allowed. */
4931 if (insn
.tm
->flags
& FL_BMASK
)
4933 as_warn (_("Instructions which cause PC discontinuity are not "
4934 "allowed in a delay slot. "
4935 "Resulting behavior is undefined."));
4937 delay_slots
-= words
;
4940 /* Is this instruction the target of a repeat? */
4943 if (insn
.tm
->flags
& FL_NR
)
4944 as_warn (_("'%s' is not repeatable. "
4945 "Resulting behavior is undefined."),
4947 else if (insn
.is_lkaddr
)
4948 as_warn (_("Instructions using long offset modifiers or absolute "
4949 "addresses are not repeatable. "
4950 "Resulting behavior is undefined."));
4954 /* Make sure we check the target of a repeat instruction. */
4955 if (insn
.tm
->flags
& B_REPEAT
)
4958 /* FIXME -- warn if repeat_slot == 1 at EOF. */
4960 /* Make sure we check our delay slots for validity. */
4961 if (insn
.tm
->flags
& FL_DELAY
)
4964 /* FIXME -- warn if delay_slots != 0 at EOF. */
4969 /* Do a final adjustment on the symbol table; in this case, make sure we have
4970 a ".file" symbol. */
4973 tic54x_adjust_symtab (void)
4975 if (symbol_rootP
== NULL
4976 || S_GET_STORAGE_CLASS (symbol_rootP
) != C_FILE
)
4979 const char * filename
= as_where (&lineno
);
4980 c_dot_file_symbol (filename
, 0);
4984 /* In order to get gas to ignore any | chars at the start of a line,
4985 this function returns true if a | is found in a line.
4986 This lets us process parallel instructions, which span two lines. */
4989 tic54x_unrecognized_line (int c
)
4991 return c
== PARALLEL_SEPARATOR
;
4994 /* Watch for local labels of the form $[0-9] and [_a-zA-Z][_a-zA-Z0-9]*?
4995 Encode their names so that only we see them and can map them to the
4997 FIXME -- obviously this isn't done yet. These locals still show up in the
5000 tic54x_define_label (symbolS
*sym
)
5002 /* Just in case we need this later; note that this is not necessarily the
5003 same thing as line_label...
5004 When aligning or assigning labels to fields, sometimes the label is
5005 assigned other than the address at which the label appears.
5006 FIXME -- is this really needed? I think all the proper label assignment
5007 is done in tic54x_cons. */
5008 last_label_seen
= sym
;
5011 /* Try to parse something that normal parsing failed at. */
5014 tic54x_undefined_symbol (char *name
)
5018 /* Not sure how to handle predefined symbols. */
5019 if ((sym
= (tic54x_symbol
*) hash_find (cc_hash
, name
)) != NULL
||
5020 (sym
= (tic54x_symbol
*) hash_find (cc2_hash
, name
)) != NULL
||
5021 (sym
= (tic54x_symbol
*) hash_find (cc3_hash
, name
)) != NULL
||
5022 (sym
= (tic54x_symbol
*) hash_find (misc_symbol_hash
, name
)) != NULL
||
5023 (sym
= (tic54x_symbol
*) hash_find (sbit_hash
, name
)) != NULL
)
5025 return symbol_new (name
, reg_section
,
5026 (valueT
) sym
->value
,
5027 &zero_address_frag
);
5030 if ((sym
= (tic54x_symbol
*) hash_find (reg_hash
, name
)) != NULL
||
5031 (sym
= (tic54x_symbol
*) hash_find (mmreg_hash
, name
)) != NULL
||
5032 !strcasecmp (name
, "a") || !strcasecmp (name
, "b"))
5034 return symbol_new (name
, reg_section
,
5035 (valueT
) sym
? sym
->value
: 0,
5036 &zero_address_frag
);
5042 /* Parse a name in an expression before the expression parser takes a stab at
5046 tic54x_parse_name (char *name ATTRIBUTE_UNUSED
,
5047 expressionS
*expn ATTRIBUTE_UNUSED
)
5053 md_atof (int type
, char *literalP
, int *sizeP
)
5055 /* Target data is little-endian, but floats are stored
5056 big-"word"ian. ugh. */
5057 return ieee_md_atof (type
, literalP
, sizeP
, TRUE
);
5061 tc_gen_reloc (asection
*section
, fixS
*fixP
)
5064 bfd_reloc_code_real_type code
= fixP
->fx_r_type
;
5065 asymbol
*sym
= symbol_get_bfdsym (fixP
->fx_addsy
);
5067 rel
= XNEW (arelent
);
5068 rel
->sym_ptr_ptr
= XNEW (asymbol
*);
5069 *rel
->sym_ptr_ptr
= sym
;
5070 /* We assume that all rel->address are host byte offsets. */
5071 rel
->address
= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
5072 rel
->address
/= OCTETS_PER_BYTE
;
5073 rel
->howto
= bfd_reloc_type_lookup (stdoutput
, code
);
5074 if (!strcmp (sym
->name
, section
->name
))
5075 rel
->howto
+= HOWTO_BANK
;
5079 const char *name
= S_GET_NAME (fixP
->fx_addsy
);
5082 as_fatal ("Cannot generate relocation type for symbol %s, code %s",
5083 name
, bfd_get_reloc_code_name (code
));
5089 /* Handle cons expressions. */
5092 tic54x_cons_fix_new (fragS
*frag
, int where
, int octets
, expressionS
*expn
,
5093 bfd_reloc_code_real_type r
)
5098 as_bad (_("Unsupported relocation size %d"), octets
);
5099 r
= BFD_RELOC_TIC54X_16_OF_23
;
5102 r
= BFD_RELOC_TIC54X_16_OF_23
;
5105 /* TI assembler always uses this, regardless of addressing mode. */
5107 r
= BFD_RELOC_TIC54X_23
;
5109 /* We never want to directly generate this; this is provided for
5110 stabs support only. */
5114 fix_new_exp (frag
, where
, octets
, expn
, 0, r
);
5117 /* Attempt to simplify or even eliminate a fixup.
5118 To indicate that a fixup has been eliminated, set fixP->fx_done.
5120 If fixp->fx_addsy is non-NULL, we'll have to generate a reloc entry. */
5123 md_apply_fix (fixS
*fixP
, valueT
*valP
, segT seg ATTRIBUTE_UNUSED
)
5125 char *buf
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
5126 valueT val
= * valP
;
5128 switch (fixP
->fx_r_type
)
5131 as_fatal ("Bad relocation type: 0x%02x", fixP
->fx_r_type
);
5133 case BFD_RELOC_TIC54X_MS7_OF_23
:
5134 val
= (val
>> 16) & 0x7F;
5136 case BFD_RELOC_TIC54X_16_OF_23
:
5138 bfd_put_16 (stdoutput
, val
, buf
);
5139 /* Indicate what we're actually writing, so that we don't get warnings
5140 about exceeding available space. */
5141 *valP
= val
& 0xFFFF;
5143 case BFD_RELOC_TIC54X_PARTLS7
:
5144 bfd_put_16 (stdoutput
,
5145 (bfd_get_16 (stdoutput
, buf
) & 0xFF80) | (val
& 0x7F),
5147 /* Indicate what we're actually writing, so that we don't get warnings
5148 about exceeding available space. */
5151 case BFD_RELOC_TIC54X_PARTMS9
:
5152 /* TI assembler doesn't shift its encoding for relocatable files, and is
5153 thus incompatible with this implementation's relocatable files. */
5154 bfd_put_16 (stdoutput
,
5155 (bfd_get_16 (stdoutput
, buf
) & 0xFE00) | (val
>> 7),
5159 case BFD_RELOC_TIC54X_23
:
5160 bfd_put_32 (stdoutput
,
5161 (bfd_get_32 (stdoutput
, buf
) & 0xFF800000) | val
,
5166 if (fixP
->fx_addsy
== NULL
&& fixP
->fx_pcrel
== 0)
5170 /* This is our chance to record section alignment
5171 don't need to do anything here, since BFD does the proper encoding. */
5174 md_section_align (segT segment ATTRIBUTE_UNUSED
, valueT section_size
)
5176 return section_size
;
5180 md_pcrel_from (fixS
*fixP ATTRIBUTE_UNUSED
)
5185 /* Mostly little-endian, but longwords (4 octets) get MS word stored
5189 tic54x_number_to_chars (char *buf
, valueT val
, int n
)
5192 number_to_chars_littleendian (buf
, val
, n
);
5195 number_to_chars_littleendian (buf
, val
>> 16 , 2);
5196 number_to_chars_littleendian (buf
+ 2, val
& 0xFFFF, 2);
5201 tic54x_estimate_size_before_relax (fragS
*frag ATTRIBUTE_UNUSED
,
5202 segT seg ATTRIBUTE_UNUSED
)
5207 /* We use this to handle bit allocations which we couldn't handle before due
5208 to symbols being in different frags. return number of octets added. */
5211 tic54x_relax_frag (fragS
*frag
, long stretch ATTRIBUTE_UNUSED
)
5213 symbolS
*sym
= frag
->fr_symbol
;
5219 struct bit_info
*bi
= (struct bit_info
*) frag
->fr_opcode
;
5220 int bit_offset
= frag_bit_offset (frag_prev (frag
, bi
->seg
), bi
->seg
);
5221 int size
= S_GET_VALUE (sym
);
5222 fragS
*prev_frag
= bit_offset_frag (frag_prev (frag
, bi
->seg
), bi
->seg
);
5223 int available
= 16 - bit_offset
;
5225 if (symbol_get_frag (sym
) != &zero_address_frag
5226 || S_IS_COMMON (sym
)
5227 || !S_IS_DEFINED (sym
))
5228 as_bad_where (frag
->fr_file
, frag
->fr_line
,
5229 _("non-absolute value used with .space/.bes"));
5233 as_warn (_("negative value ignored in %s"),
5234 bi
->type
== TYPE_SPACE
? ".space" :
5235 bi
->type
== TYPE_BES
? ".bes" : ".field");
5237 frag
->tc_frag_data
= frag
->fr_fix
= 0;
5241 if (bi
->type
== TYPE_FIELD
)
5243 /* Bit fields of 16 or larger will have already been handled. */
5244 if (bit_offset
!= 0 && available
>= size
)
5246 char *p
= prev_frag
->fr_literal
;
5248 valueT value
= bi
->value
;
5249 value
<<= available
- size
;
5250 value
|= ((unsigned short) p
[1] << 8) | p
[0];
5251 md_number_to_chars (p
, value
, 2);
5252 if ((prev_frag
->tc_frag_data
+= size
) == 16)
5253 prev_frag
->tc_frag_data
= 0;
5255 symbol_set_frag (bi
->sym
, prev_frag
);
5256 /* This frag is no longer used. */
5257 growth
= -frag
->fr_fix
;
5259 frag
->tc_frag_data
= 0;
5263 char *p
= frag
->fr_literal
;
5265 valueT value
= bi
->value
<< (16 - size
);
5266 md_number_to_chars (p
, value
, 2);
5267 if ((frag
->tc_frag_data
= size
) == 16)
5268 frag
->tc_frag_data
= 0;
5274 if (bit_offset
!= 0 && bit_offset
< 16)
5276 if (available
>= size
)
5278 if ((prev_frag
->tc_frag_data
+= size
) == 16)
5279 prev_frag
->tc_frag_data
= 0;
5281 symbol_set_frag (bi
->sym
, prev_frag
);
5282 /* This frag is no longer used. */
5283 growth
= -frag
->fr_fix
;
5285 frag
->tc_frag_data
= 0;
5288 if (bi
->type
== TYPE_SPACE
&& bi
->sym
)
5289 symbol_set_frag (bi
->sym
, prev_frag
);
5292 growth
= (size
+ 15) / 16 * OCTETS_PER_BYTE
- frag
->fr_fix
;
5293 for (i
= 0; i
< growth
; i
++)
5294 frag
->fr_literal
[i
] = 0;
5295 frag
->fr_fix
= growth
;
5296 frag
->tc_frag_data
= size
% 16;
5297 /* Make sure any BES label points to the LAST word allocated. */
5298 if (bi
->type
== TYPE_BES
&& bi
->sym
)
5299 S_SET_VALUE (bi
->sym
, frag
->fr_fix
/ OCTETS_PER_BYTE
- 1);
5302 frag
->fr_symbol
= 0;
5303 frag
->fr_opcode
= 0;
5310 tic54x_convert_frag (bfd
*abfd ATTRIBUTE_UNUSED
,
5311 segT seg ATTRIBUTE_UNUSED
,
5314 /* Offset is in bytes. */
5315 frag
->fr_offset
= (frag
->fr_next
->fr_address
5317 - frag
->fr_fix
) / frag
->fr_var
;
5318 if (frag
->fr_offset
< 0)
5320 as_bad_where (frag
->fr_file
, frag
->fr_line
,
5321 _("attempt to .space/.bes backwards? (%ld)"),
5322 (long) frag
->fr_offset
);
5324 frag
->fr_type
= rs_space
;
5327 /* We need to avoid having labels defined for certain directives/pseudo-ops
5328 since once the label is defined, it's in the symbol table for good. TI
5329 syntax puts the symbol *before* the pseudo (which is kinda like MRI syntax,
5330 I guess, except I've never seen a definition of MRI syntax).
5332 Don't allow labels to start with '.' */
5335 tic54x_start_label (int nul_char
, int next_char
)
5339 /* If within .struct/.union, no auto line labels, please. */
5340 if (current_stag
!= NULL
)
5343 /* Disallow labels starting with "." */
5344 if (next_char
!= ':')
5346 char *label
= input_line_pointer
;
5348 while (!is_end_of_line
[(int) label
[-1]])
5352 as_bad (_("Invalid label '%s'"), label
);
5357 if (is_end_of_line
[(int) next_char
])
5360 rest
= input_line_pointer
;
5361 if (nul_char
== '"')
5363 while (ISSPACE (next_char
))
5364 next_char
= *++rest
;
5365 if (next_char
!= '.')
5368 /* Don't let colon () define a label for any of these... */
5369 return ((strncasecmp (rest
, ".tag", 4) != 0 || !ISSPACE (rest
[4]))
5370 && (strncasecmp (rest
, ".struct", 7) != 0 || !ISSPACE (rest
[7]))
5371 && (strncasecmp (rest
, ".union", 6) != 0 || !ISSPACE (rest
[6]))
5372 && (strncasecmp (rest
, ".macro", 6) != 0 || !ISSPACE (rest
[6]))
5373 && (strncasecmp (rest
, ".set", 4) != 0 || !ISSPACE (rest
[4]))
5374 && (strncasecmp (rest
, ".equ", 4) != 0 || !ISSPACE (rest
[4])));