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')
1165 /* If there are quotes, remove them. */
1166 if (*input_line_pointer
== '"')
1168 name
= demand_copy_C_string (&len
);
1169 demand_empty_rest_of_line ();
1170 name
= strcpy (xmalloc (len
+ 10), name
);
1176 c
= get_symbol_name (&name
);
1178 name
= strcpy (xmalloc (len
+ 10), name
);
1179 (void) restore_line_pointer (c
);
1180 demand_empty_rest_of_line ();
1183 /* Make sure all named initialized sections flagged properly. If we
1184 encounter instructions, we'll flag it with SEC_CODE as well. */
1185 strcat (name
, ",\"w\"\n");
1186 input_scrub_insert_line (name
);
1187 obj_coff_section (0);
1189 /* If there was a line label, make sure that it gets assigned the proper
1190 section. This is for compatibility, even though the actual behavior
1191 is not explicitly defined. For consistency, we make .sect behave
1192 like .usect, since that is probably what people expect. */
1193 if (line_label
!= NULL
)
1195 S_SET_SEGMENT (line_label
, now_seg
);
1196 symbol_set_frag (line_label
, frag_now
);
1197 S_SET_VALUE (line_label
, frag_now_fix ());
1198 if (S_GET_STORAGE_CLASS (line_label
) != C_EXT
)
1199 S_SET_STORAGE_CLASS (line_label
, C_LABEL
);
1204 /* [symbol] .space space_in_bits
1205 [symbol] .bes space_in_bits
1206 BES puts the symbol at the *last* word allocated
1208 cribbed from s_space. */
1211 tic54x_space (int arg
)
1217 int bits_per_byte
= (OCTETS_PER_BYTE
* 8);
1219 symbolS
*label
= line_label
;
1222 ILLEGAL_WITHIN_STRUCT ();
1224 #ifdef md_flush_pending_output
1225 md_flush_pending_output ();
1228 /* Read the bit count. */
1231 /* Some expressions are unresolvable until later in the assembly pass;
1232 postpone until relaxation/fixup. we also have to postpone if a previous
1233 partial allocation has not been completed yet. */
1234 if (expn
.X_op
!= O_constant
|| frag_bit_offset (frag_now
, now_seg
) == -1)
1236 struct bit_info
*bi
= XNEW (struct bit_info
);
1241 p
= frag_var (rs_machine_dependent
,
1242 65536 * 2, 1, (relax_substateT
) 0,
1243 make_expr_symbol (&expn
), (offsetT
) 0,
1251 /* Reduce the required size by any bit offsets currently left over
1252 from a previous .space/.bes/.field directive. */
1253 bit_offset
= frag_now
->tc_frag_data
;
1254 if (bit_offset
!= 0 && bit_offset
< 16)
1256 int spare_bits
= bits_per_byte
- bit_offset
;
1258 if (spare_bits
>= expn
.X_add_number
)
1260 /* Don't have to do anything; sufficient bits have already been
1261 allocated; just point the label to the right place. */
1264 symbol_set_frag (label
, frag_now
);
1265 S_SET_VALUE (label
, frag_now_fix () - 1);
1268 frag_now
->tc_frag_data
+= expn
.X_add_number
;
1271 expn
.X_add_number
-= spare_bits
;
1272 /* Set the label to point to the first word allocated, which in this
1273 case is the previous word, which was only partially filled. */
1274 if (!bes
&& label
!= NULL
)
1276 symbol_set_frag (label
, frag_now
);
1277 S_SET_VALUE (label
, frag_now_fix () - 1);
1281 /* Convert bits to bytes/words and octets, rounding up. */
1282 words
= ((expn
.X_add_number
+ bits_per_byte
- 1) / bits_per_byte
);
1283 /* How many do we have left over? */
1284 bit_offset
= expn
.X_add_number
% bits_per_byte
;
1285 octets
= words
* OCTETS_PER_BYTE
;
1288 as_warn (_(".space/.bes repeat count is negative, ignored"));
1291 else if (octets
== 0)
1293 as_warn (_(".space/.bes repeat count is zero, ignored"));
1297 /* If we are in the absolute section, just bump the offset. */
1298 if (now_seg
== absolute_section
)
1300 abs_section_offset
+= words
;
1301 if (bes
&& label
!= NULL
)
1302 S_SET_VALUE (label
, abs_section_offset
- 1);
1303 frag_now
->tc_frag_data
= bit_offset
;
1308 p
= frag_var (rs_fill
, 1, 1,
1309 (relax_substateT
) 0, (symbolS
*) 0,
1310 (offsetT
) octets
, (char *) 0);
1312 /* Make note of how many bits of this word we've allocated so far. */
1313 frag_now
->tc_frag_data
= bit_offset
;
1315 /* .bes puts label at *last* word allocated. */
1316 if (bes
&& label
!= NULL
)
1318 symbol_set_frag (label
, frag_now
);
1319 S_SET_VALUE (label
, frag_now_fix () - 1);
1327 demand_empty_rest_of_line ();
1330 /* [symbol] .usect "section-name", size-in-words
1331 [, [blocking-flag] [, alignment-flag]]
1333 Uninitialized section.
1334 Non-zero blocking means that if the section would cross a page (128-word)
1335 boundary, it will be page-aligned.
1336 Non-zero alignment aligns on a longword boundary.
1338 Has no effect on the current section. */
1341 tic54x_usect (int x ATTRIBUTE_UNUSED
)
1348 int size
, blocking_flag
, alignment_flag
;
1350 subsegT current_subseg
;
1353 ILLEGAL_WITHIN_STRUCT ();
1355 current_seg
= now_seg
; /* Save current seg. */
1356 current_subseg
= now_subseg
; /* Save current subseg. */
1358 c
= get_symbol_name (§ion_name
); /* Get terminator. */
1359 name
= xstrdup (section_name
);
1360 c
= restore_line_pointer (c
);
1363 ++input_line_pointer
;
1366 as_bad (_("Missing size argument"));
1367 ignore_rest_of_line ();
1371 size
= get_absolute_expression ();
1373 /* Read a possibly present third argument (blocking flag). */
1374 if (*input_line_pointer
== ',')
1376 ++input_line_pointer
;
1377 if (*input_line_pointer
!= ',')
1378 blocking_flag
= get_absolute_expression ();
1382 /* Read a possibly present fourth argument (alignment flag). */
1383 if (*input_line_pointer
== ',')
1385 ++input_line_pointer
;
1386 alignment_flag
= get_absolute_expression ();
1392 blocking_flag
= alignment_flag
= 0;
1394 seg
= subseg_new (name
, 0);
1395 flags
= bfd_get_section_flags (stdoutput
, seg
) | SEC_ALLOC
;
1399 /* s_align eats end of line; restore it. */
1401 --input_line_pointer
;
1404 if (line_label
!= NULL
)
1406 S_SET_SEGMENT (line_label
, seg
);
1407 symbol_set_frag (line_label
, frag_now
);
1408 S_SET_VALUE (line_label
, frag_now_fix ());
1409 /* Set scl to label, since that's what TI does. */
1410 if (S_GET_STORAGE_CLASS (line_label
) != C_EXT
)
1411 S_SET_STORAGE_CLASS (line_label
, C_LABEL
);
1414 seg_info (seg
)->bss
= 1; /* Uninitialized data. */
1416 p
= frag_var (rs_fill
, 1, 1,
1417 (relax_substateT
) 0, (symbolS
*) line_label
,
1418 size
* OCTETS_PER_BYTE
, (char *) 0);
1422 flags
|= SEC_TIC54X_BLOCK
;
1424 if (!bfd_set_section_flags (stdoutput
, seg
, flags
))
1425 as_warn (_("Error setting flags for \"%s\": %s"), name
,
1426 bfd_errmsg (bfd_get_error ()));
1428 subseg_set (current_seg
, current_subseg
); /* Restore current seg. */
1429 demand_empty_rest_of_line ();
1432 static enum cpu_version
1433 lookup_version (const char *ver
)
1435 enum cpu_version version
= VNONE
;
1437 if (ver
[0] == '5' && ver
[1] == '4')
1439 if (strlen (ver
) == 3
1440 && (ver
[2] == '1' || ver
[2] == '2' || ver
[2] == '3'
1441 || ver
[2] == '5' || ver
[2] == '8' || ver
[2] == '9'))
1442 version
= ver
[2] - '0';
1443 else if (strlen (ver
) == 5
1444 && TOUPPER (ver
[3]) == 'L'
1445 && TOUPPER (ver
[4]) == 'P'
1446 && (ver
[2] == '5' || ver
[2] == '6'))
1447 version
= ver
[2] - '0' + 10;
1454 set_cpu (enum cpu_version version
)
1457 if (version
== V545LP
|| version
== V546LP
)
1459 symbolS
*symbolP
= symbol_new ("__allow_lp", absolute_section
,
1460 (valueT
) 1, &zero_address_frag
);
1461 SF_SET_LOCAL (symbolP
);
1462 symbol_table_insert (symbolP
);
1466 /* .version cpu-version
1467 cpu-version may be one of the following:
1477 This is for compatibility only. It currently has no affect on assembly. */
1478 static int cpu_needs_set
= 1;
1481 tic54x_version (int x ATTRIBUTE_UNUSED
)
1483 enum cpu_version version
= VNONE
;
1484 enum cpu_version old_version
= cpu
;
1488 ILLEGAL_WITHIN_STRUCT ();
1491 ver
= input_line_pointer
;
1492 while (!is_end_of_line
[(int) *input_line_pointer
])
1493 ++input_line_pointer
;
1494 c
= *input_line_pointer
;
1495 *input_line_pointer
= 0;
1497 version
= lookup_version (ver
);
1499 if (cpu
!= VNONE
&& cpu
!= version
)
1500 as_warn (_("CPU version has already been set"));
1502 if (version
== VNONE
)
1504 as_bad (_("Unrecognized version '%s'"), ver
);
1505 ignore_rest_of_line ();
1508 else if (assembly_begun
&& version
!= old_version
)
1510 as_bad (_("Changing of CPU version on the fly not supported"));
1511 ignore_rest_of_line ();
1517 *input_line_pointer
= c
;
1518 demand_empty_rest_of_line ();
1521 /* 'f' = float, 'x' = xfloat, 'd' = double, 'l' = ldouble. */
1524 tic54x_float_cons (int type
)
1526 if (current_stag
!= 0)
1527 tic54x_struct_field ('f');
1529 #ifdef md_flush_pending_output
1530 md_flush_pending_output ();
1533 /* Align to long word boundary (4 octets) unless it's ".xfloat". */
1536 frag_align (2, 0, 2);
1537 /* If there's a label, assign it to the first allocated word. */
1538 if (line_label
!= NULL
)
1540 symbol_set_frag (line_label
, frag_now
);
1541 S_SET_VALUE (line_label
, frag_now_fix ());
1548 /* The argument is capitalized if it should be zero-terminated
1549 's' is normal string with upper 8-bits zero-filled, 'p' is packed.
1550 Code copied from stringer, and slightly modified so that strings are packed
1551 and encoded into the correct octets. */
1554 tic54x_stringer (int type
)
1557 int append_zero
= type
== 'S' || type
== 'P';
1558 int packed
= type
== 'p' || type
== 'P';
1559 int last_char
= -1; /* Packed strings need two bytes at a time to encode. */
1561 if (current_stag
!= NULL
)
1563 tic54x_struct_field ('*');
1567 #ifdef md_flush_pending_output
1568 md_flush_pending_output ();
1571 c
= ','; /* Do loop. */
1575 switch (*input_line_pointer
)
1579 unsigned short value
= get_absolute_expression ();
1580 FRAG_APPEND_1_CHAR ( value
& 0xFF);
1581 FRAG_APPEND_1_CHAR ((value
>> 8) & 0xFF);
1585 ++input_line_pointer
; /* -> 1st char of string. */
1586 while (is_a_char (c
= next_char_of_string ()))
1590 FRAG_APPEND_1_CHAR (c
);
1591 FRAG_APPEND_1_CHAR (0);
1595 /* Packed strings are filled MS octet first. */
1596 if (last_char
== -1)
1600 FRAG_APPEND_1_CHAR (c
);
1601 FRAG_APPEND_1_CHAR (last_char
);
1608 if (packed
&& last_char
!= -1)
1610 FRAG_APPEND_1_CHAR (0);
1611 FRAG_APPEND_1_CHAR (last_char
);
1616 FRAG_APPEND_1_CHAR (0);
1617 FRAG_APPEND_1_CHAR (0);
1620 know (input_line_pointer
[-1] == '\"');
1624 c
= *input_line_pointer
;
1625 if (!is_end_of_line
[c
])
1626 ++input_line_pointer
;
1629 /* Finish up any leftover packed string. */
1630 if (packed
&& last_char
!= -1)
1632 FRAG_APPEND_1_CHAR (0);
1633 FRAG_APPEND_1_CHAR (last_char
);
1635 demand_empty_rest_of_line ();
1639 tic54x_p2align (int arg ATTRIBUTE_UNUSED
)
1641 as_bad (_("p2align not supported on this target"));
1645 tic54x_align_words (int arg
)
1647 /* Only ".align" with no argument is allowed within .struct/.union. */
1650 if (!is_end_of_line
[(int) *input_line_pointer
])
1653 as_warn (_("Argument to .even ignored"));
1655 count
= get_absolute_expression ();
1658 if (current_stag
!= NULL
&& arg
== 128)
1660 if (current_stag
->current_bitfield_offset
!= 0)
1662 current_stag
->current_bitfield_offset
= 0;
1663 ++abs_section_offset
;
1665 demand_empty_rest_of_line ();
1669 ILLEGAL_WITHIN_STRUCT ();
1671 s_align_bytes (count
<< 1);
1674 /* Initialize multiple-bit fields withing a single word of memory. */
1677 tic54x_field (int ignore ATTRIBUTE_UNUSED
)
1683 symbolS
*label
= line_label
;
1685 if (current_stag
!= NULL
)
1687 tic54x_struct_field ('.');
1691 input_line_pointer
= parse_expression (input_line_pointer
, &expn
);
1693 if (*input_line_pointer
== ',')
1695 ++input_line_pointer
;
1696 size
= get_absolute_expression ();
1697 if (size
< 1 || size
> 32)
1699 as_bad (_("Invalid field size, must be from 1 to 32"));
1700 ignore_rest_of_line ();
1705 /* Truncate values to the field width. */
1706 if (expn
.X_op
!= O_constant
)
1708 /* If the expression value is relocatable, the field size *must*
1712 as_bad (_("field size must be 16 when value is relocatable"));
1713 ignore_rest_of_line ();
1717 frag_now
->tc_frag_data
= 0;
1718 emit_expr (&expn
, 2);
1722 unsigned long fmask
= (size
== 32) ? 0xFFFFFFFF : (1ul << size
) - 1;
1724 value
= expn
.X_add_number
;
1725 expn
.X_add_number
&= fmask
;
1726 if (value
!= (valueT
) expn
.X_add_number
)
1727 as_warn (_("field value truncated"));
1728 value
= expn
.X_add_number
;
1729 /* Bits are stored MS first. */
1732 frag_now
->tc_frag_data
= 0;
1734 md_number_to_chars (p
, (value
>> (size
- 16)) & 0xFFFF, 2);
1739 int bit_offset
= frag_bit_offset (frag_now
, now_seg
);
1741 fragS
*alloc_frag
= bit_offset_frag (frag_now
, now_seg
);
1742 if (bit_offset
== -1)
1744 struct bit_info
*bi
= XNEW (struct bit_info
);
1745 /* We don't know the previous offset at this time, so store the
1746 info we need and figure it out later. */
1747 expressionS size_exp
;
1749 size_exp
.X_op
= O_constant
;
1750 size_exp
.X_add_number
= size
;
1752 bi
->type
= TYPE_FIELD
;
1754 p
= frag_var (rs_machine_dependent
,
1755 4, 1, (relax_substateT
) 0,
1756 make_expr_symbol (&size_exp
), (offsetT
) 0,
1760 else if (bit_offset
== 0 || bit_offset
+ size
> 16)
1762 /* Align a new field. */
1764 frag_now
->tc_frag_data
= 0;
1765 alloc_frag
= frag_now
;
1769 /* Put the new value entirely within the existing one. */
1770 p
= alloc_frag
== frag_now
?
1771 frag_now
->fr_literal
+ frag_now_fix_octets () - 2 :
1772 alloc_frag
->fr_literal
;
1775 symbol_set_frag (label
, alloc_frag
);
1776 if (alloc_frag
== frag_now
)
1777 S_SET_VALUE (label
, frag_now_fix () - 1);
1781 value
<<= 16 - alloc_frag
->tc_frag_data
- size
;
1783 /* OR in existing value. */
1784 if (alloc_frag
->tc_frag_data
)
1785 value
|= ((unsigned short) p
[1] << 8) | p
[0];
1786 md_number_to_chars (p
, value
, 2);
1787 alloc_frag
->tc_frag_data
+= size
;
1788 if (alloc_frag
->tc_frag_data
== 16)
1789 alloc_frag
->tc_frag_data
= 0;
1793 demand_empty_rest_of_line ();
1796 /* Ideally, we want to check SEC_LOAD and SEC_HAS_CONTENTS, but those aren't
1797 available yet. seg_info ()->bss is the next best thing. */
1800 tic54x_initialized_section (segT seg
)
1802 return !seg_info (seg
)->bss
;
1805 /* .clink ["section name"]
1807 Marks the section as conditionally linked (link only if contents are
1808 referenced elsewhere.
1809 Without a name, refers to the current initialized section.
1810 Name is required for uninitialized sections. */
1813 tic54x_clink (int ignored ATTRIBUTE_UNUSED
)
1817 ILLEGAL_WITHIN_STRUCT ();
1819 if (*input_line_pointer
== '\"')
1821 char *section_name
= ++input_line_pointer
;
1824 while (is_a_char (next_char_of_string ()))
1826 know (input_line_pointer
[-1] == '\"');
1827 input_line_pointer
[-1] = 0;
1828 name
= xstrdup (section_name
);
1830 seg
= bfd_get_section_by_name (stdoutput
, name
);
1833 as_bad (_("Unrecognized section '%s'"), section_name
);
1834 ignore_rest_of_line ();
1840 if (!tic54x_initialized_section (seg
))
1842 as_bad (_("Current section is unitialized, "
1843 "section name required for .clink"));
1844 ignore_rest_of_line ();
1849 seg
->flags
|= SEC_TIC54X_CLINK
;
1851 demand_empty_rest_of_line ();
1854 /* Change the default include directory to be the current source file's
1855 directory, instead of the current working directory. If DOT is non-zero,
1856 set to "." instead. */
1859 tic54x_set_default_include (int dot
)
1861 const char *dir
= ".";
1866 const char *curfile
;
1869 curfile
= as_where (&lineno
);
1870 dir
= xstrdup (curfile
);
1871 tmp
= strrchr (dir
, '/');
1879 if (include_dir_count
== 0)
1881 include_dirs
= XNEWVEC (const char *, 1);
1882 include_dir_count
= 1;
1884 include_dirs
[0] = dir
;
1885 if (len
> include_dir_maxlen
)
1886 include_dir_maxlen
= len
;
1888 else if (include_dirs
!= NULL
)
1889 include_dirs
[0] = ".";
1892 /* .include "filename" | filename
1893 .copy "filename" | filename
1895 FIXME 'include' file should be omitted from any output listing,
1896 'copy' should be included in any output listing
1897 FIXME -- prevent any included files from changing listing (compat only)
1898 FIXME -- need to include source file directory in search path; what's a
1899 good way to do this?
1901 Entering/exiting included/copied file clears all local labels. */
1904 tic54x_include (int ignored ATTRIBUTE_UNUSED
)
1906 char newblock
[] = " .newblock\n";
1911 ILLEGAL_WITHIN_STRUCT ();
1915 if (*input_line_pointer
== '"')
1917 filename
= demand_copy_C_string (&len
);
1918 demand_empty_rest_of_line ();
1922 filename
= input_line_pointer
;
1923 while (!is_end_of_line
[(int) *input_line_pointer
])
1924 ++input_line_pointer
;
1925 c
= *input_line_pointer
;
1926 *input_line_pointer
= '\0';
1927 filename
= xstrdup (filename
);
1928 *input_line_pointer
= c
;
1929 demand_empty_rest_of_line ();
1931 /* Insert a partial line with the filename (for the sake of s_include)
1933 The included file will be inserted before the newblock, so that the
1934 newblock is executed after the included file is processed. */
1935 input
= xmalloc (sizeof (newblock
) + strlen (filename
) + 4);
1936 sprintf (input
, "\"%s\"\n%s", filename
, newblock
);
1937 input_scrub_insert_line (input
);
1939 tic54x_clear_local_labels (0);
1941 tic54x_set_default_include (0);
1947 tic54x_message (int type
)
1953 ILLEGAL_WITHIN_STRUCT ();
1955 if (*input_line_pointer
== '"')
1956 msg
= demand_copy_C_string (&len
);
1959 msg
= input_line_pointer
;
1960 while (!is_end_of_line
[(int) *input_line_pointer
])
1961 ++input_line_pointer
;
1962 c
= *input_line_pointer
;
1963 *input_line_pointer
= 0;
1964 msg
= xstrdup (msg
);
1965 *input_line_pointer
= c
;
1971 as_tsktsk ("%s", msg
);
1974 as_warn ("%s", msg
);
1981 demand_empty_rest_of_line ();
1985 Define a special symbol that refers to the loadtime address rather than the
1986 runtime address within the current section.
1988 This symbol gets a special storage class so that when it is resolved, it is
1989 resolved relative to the load address (lma) of the section rather than the
1990 run address (vma). */
1993 tic54x_label (int ignored ATTRIBUTE_UNUSED
)
1999 ILLEGAL_WITHIN_STRUCT ();
2001 c
= get_symbol_name (&name
);
2002 symbolP
= colon (name
);
2003 S_SET_STORAGE_CLASS (symbolP
, C_STATLAB
);
2005 (void) restore_line_pointer (c
);
2006 demand_empty_rest_of_line ();
2010 Install all memory-mapped register names into the symbol table as
2011 absolute local symbols. */
2014 tic54x_mmregs (int ignored ATTRIBUTE_UNUSED
)
2018 ILLEGAL_WITHIN_STRUCT ();
2020 for (sym
= (symbol
*) mmregs
; sym
->name
; sym
++)
2022 symbolS
*symbolP
= symbol_new (sym
->name
, absolute_section
,
2023 (valueT
) sym
->value
, &zero_address_frag
);
2024 SF_SET_LOCAL (symbolP
);
2025 symbol_table_insert (symbolP
);
2030 Count defaults to 1024. */
2033 tic54x_loop (int count
)
2035 ILLEGAL_WITHIN_STRUCT ();
2038 if (!is_end_of_line
[(int) *input_line_pointer
])
2039 count
= get_absolute_expression ();
2041 do_repeat (count
, "LOOP", "ENDLOOP");
2044 /* Normally, endloop gets eaten by the preceding loop. */
2047 tic54x_endloop (int ignore ATTRIBUTE_UNUSED
)
2049 as_bad (_("ENDLOOP without corresponding LOOP"));
2050 ignore_rest_of_line ();
2053 /* .break [condition]. */
2056 tic54x_break (int ignore ATTRIBUTE_UNUSED
)
2060 ILLEGAL_WITHIN_STRUCT ();
2063 if (!is_end_of_line
[(int) *input_line_pointer
])
2064 cond
= get_absolute_expression ();
2067 end_repeat (substitution_line
? 1 : 0);
2071 set_address_mode (int mode
)
2074 if (mode
== far_mode
)
2076 symbolS
*symbolP
= symbol_new ("__allow_far", absolute_section
,
2077 (valueT
) 1, &zero_address_frag
);
2078 SF_SET_LOCAL (symbolP
);
2079 symbol_table_insert (symbolP
);
2083 static int address_mode_needs_set
= 1;
2086 tic54x_address_mode (int mode
)
2088 if (assembly_begun
&& amode
!= (unsigned) mode
)
2090 as_bad (_("Mixing of normal and extended addressing not supported"));
2091 ignore_rest_of_line ();
2094 if (mode
== far_mode
&& cpu
!= VNONE
&& cpu
!= V548
&& cpu
!= V549
)
2096 as_bad (_("Extended addressing not supported on the specified CPU"));
2097 ignore_rest_of_line ();
2101 set_address_mode (mode
);
2102 demand_empty_rest_of_line ();
2105 /* .sblock "section"|section [,...,"section"|section]
2106 Designate initialized sections for blocking. */
2109 tic54x_sblock (int ignore ATTRIBUTE_UNUSED
)
2113 ILLEGAL_WITHIN_STRUCT ();
2120 if (*input_line_pointer
== '"')
2124 name
= demand_copy_C_string (&len
);
2130 c
= get_symbol_name (§ion_name
);
2131 name
= xstrdup (section_name
);
2132 (void) restore_line_pointer (c
);
2135 seg
= bfd_get_section_by_name (stdoutput
, name
);
2138 as_bad (_("Unrecognized section '%s'"), name
);
2139 ignore_rest_of_line ();
2142 else if (!tic54x_initialized_section (seg
))
2144 as_bad (_(".sblock may be used for initialized sections only"));
2145 ignore_rest_of_line ();
2148 seg
->flags
|= SEC_TIC54X_BLOCK
;
2150 c
= *input_line_pointer
;
2151 if (!is_end_of_line
[(int) c
])
2152 ++input_line_pointer
;
2155 demand_empty_rest_of_line ();
2158 /* symbol .set value
2161 value must be defined externals; no forward-referencing allowed
2162 symbols assigned with .set/.equ may not be redefined. */
2165 tic54x_set (int ignore ATTRIBUTE_UNUSED
)
2170 ILLEGAL_WITHIN_STRUCT ();
2174 as_bad (_("Symbol missing for .set/.equ"));
2175 ignore_rest_of_line ();
2178 name
= xstrdup (S_GET_NAME (line_label
));
2180 if ((symbolP
= symbol_find (name
)) == NULL
2181 && (symbolP
= md_undefined_symbol (name
)) == NULL
)
2183 symbolP
= symbol_new (name
, absolute_section
, 0, &zero_address_frag
);
2184 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
2187 S_SET_DATA_TYPE (symbolP
, T_INT
);
2188 S_SET_SEGMENT (symbolP
, absolute_section
);
2189 symbol_table_insert (symbolP
);
2190 pseudo_set (symbolP
);
2191 demand_empty_rest_of_line ();
2196 List false conditional blocks. */
2199 tic54x_fclist (int show
)
2202 listing
&= ~LISTING_NOCOND
;
2204 listing
|= LISTING_NOCOND
;
2205 demand_empty_rest_of_line ();
2209 tic54x_sslist (int show
)
2211 ILLEGAL_WITHIN_STRUCT ();
2213 listing_sslist
= show
;
2216 /* .var SYM[,...,SYMN]
2217 Define a substitution string to be local to a macro. */
2220 tic54x_var (int ignore ATTRIBUTE_UNUSED
)
2222 static char empty
[] = "";
2226 ILLEGAL_WITHIN_STRUCT ();
2228 if (macro_level
== 0)
2230 as_bad (_(".var may only be used within a macro definition"));
2231 ignore_rest_of_line ();
2236 if (!ISALPHA (*input_line_pointer
))
2238 as_bad (_("Substitution symbols must begin with a letter"));
2239 ignore_rest_of_line ();
2242 c
= get_symbol_name (&name
);
2243 /* .var symbols start out with a null string. */
2244 name
= xstrdup (name
);
2245 hash_insert (subsym_hash
[macro_level
], name
, empty
);
2246 c
= restore_line_pointer (c
);
2249 ++input_line_pointer
;
2250 if (is_end_of_line
[(int) *input_line_pointer
])
2251 c
= *input_line_pointer
;
2256 demand_empty_rest_of_line ();
2259 /* .mlib <macro library filename>
2261 Macro libraries are archived (standard AR-format) text macro definitions
2262 Expand the file and include it.
2264 FIXME need to try the source file directory as well. */
2267 tic54x_mlib (int ignore ATTRIBUTE_UNUSED
)
2274 ILLEGAL_WITHIN_STRUCT ();
2276 /* Parse the filename. */
2277 if (*input_line_pointer
== '"')
2279 if ((filename
= demand_copy_C_string (&len
)) == NULL
)
2286 while (!is_end_of_line
[(int) *input_line_pointer
]
2287 && !ISSPACE (*input_line_pointer
))
2289 obstack_1grow (¬es
, *input_line_pointer
);
2290 ++input_line_pointer
;
2293 obstack_1grow (¬es
, '\0');
2294 filename
= obstack_finish (¬es
);
2296 demand_empty_rest_of_line ();
2298 tic54x_set_default_include (0);
2299 path
= XNEWVEC (char, (unsigned long) len
+ include_dir_maxlen
+ 5);
2301 for (i
= 0; i
< include_dir_count
; i
++)
2305 strcpy (path
, include_dirs
[i
]);
2307 strcat (path
, filename
);
2308 if ((try = fopen (path
, "r")) != NULL
)
2315 if (i
>= include_dir_count
)
2321 /* FIXME: if path is found, malloc'd storage is not freed. Of course, this
2322 happens all over the place, and since the assembler doesn't usually keep
2323 running for a very long time, it really doesn't matter. */
2324 register_dependency (path
);
2326 /* Expand all archive entries to temporary files and include them. */
2327 abfd
= bfd_openr (path
, NULL
);
2330 as_bad (_("can't open macro library file '%s' for reading: %s"),
2331 path
, bfd_errmsg (bfd_get_error ()));
2332 ignore_rest_of_line ();
2335 if (!bfd_check_format (abfd
, bfd_archive
))
2337 as_bad (_("File '%s' not in macro archive format"), path
);
2338 ignore_rest_of_line ();
2342 /* Open each BFD as binary (it should be straight ASCII text). */
2343 for (mbfd
= bfd_openr_next_archived_file (abfd
, NULL
);
2344 mbfd
!= NULL
; mbfd
= bfd_openr_next_archived_file (abfd
, mbfd
))
2346 /* Get a size at least as big as the archive member. */
2347 bfd_size_type size
= bfd_get_size (mbfd
);
2348 char *buf
= XNEWVEC (char, size
);
2349 char *fname
= tmpnam (NULL
);
2352 /* We're not sure how big it is, but it will be smaller than "size". */
2353 size
= bfd_bread (buf
, size
, mbfd
);
2355 /* Write to a temporary file, then use s_include to include it
2357 ftmp
= fopen (fname
, "w+b");
2358 fwrite ((void *) buf
, size
, 1, ftmp
);
2359 if (size
== 0 || buf
[size
- 1] != '\n')
2360 fwrite ("\n", 1, 1, ftmp
);
2363 input_scrub_insert_file (fname
);
2368 const pseudo_typeS md_pseudo_table
[] =
2370 { "algebraic", s_ignore
, 0 },
2371 { "align" , tic54x_align_words
, 128 },
2372 { "ascii" , tic54x_stringer
, 'p' },
2373 { "asciz" , tic54x_stringer
, 'P' },
2374 { "even" , tic54x_align_words
, 2 },
2375 { "asg" , tic54x_asg
, 0 },
2376 { "eval" , tic54x_eval
, 0 },
2377 { "bss" , tic54x_bss
, 0 },
2378 { "byte" , tic54x_cons
, 'b' },
2379 { "ubyte" , tic54x_cons
, 'B' },
2380 { "char" , tic54x_cons
, 'c' },
2381 { "uchar" , tic54x_cons
, 'C' },
2382 { "clink" , tic54x_clink
, 0 },
2383 { "c_mode" , tic54x_address_mode
, c_mode
},
2384 { "copy" , tic54x_include
, 'c' },
2385 { "include" , tic54x_include
, 'i' },
2386 { "data" , tic54x_sect
, 'd' },
2387 { "double" , tic54x_float_cons
, 'd' },
2388 { "ldouble" , tic54x_float_cons
, 'l' },
2389 { "drlist" , s_ignore
, 0 },
2390 { "drnolist" , s_ignore
, 0 },
2391 { "emsg" , tic54x_message
, 'e' },
2392 { "mmsg" , tic54x_message
, 'm' },
2393 { "wmsg" , tic54x_message
, 'w' },
2394 { "far_mode" , tic54x_address_mode
, far_mode
},
2395 { "fclist" , tic54x_fclist
, 1 },
2396 { "fcnolist" , tic54x_fclist
, 0 },
2397 { "field" , tic54x_field
, -1 },
2398 { "float" , tic54x_float_cons
, 'f' },
2399 { "xfloat" , tic54x_float_cons
, 'x' },
2400 { "global" , tic54x_global
, 'g' },
2401 { "def" , tic54x_global
, 'd' },
2402 { "ref" , tic54x_global
, 'r' },
2403 { "half" , tic54x_cons
, 'h' },
2404 { "uhalf" , tic54x_cons
, 'H' },
2405 { "short" , tic54x_cons
, 's' },
2406 { "ushort" , tic54x_cons
, 'S' },
2407 { "if" , s_if
, (int) O_ne
},
2408 { "elseif" , s_elseif
, (int) O_ne
},
2409 { "else" , s_else
, 0 },
2410 { "endif" , s_endif
, 0 },
2411 { "int" , tic54x_cons
, 'i' },
2412 { "uint" , tic54x_cons
, 'I' },
2413 { "word" , tic54x_cons
, 'w' },
2414 { "uword" , tic54x_cons
, 'W' },
2415 { "label" , tic54x_label
, 0 }, /* Loadtime
2417 { "length" , s_ignore
, 0 },
2418 { "width" , s_ignore
, 0 },
2419 { "long" , tic54x_cons
, 'l' },
2420 { "ulong" , tic54x_cons
, 'L' },
2421 { "xlong" , tic54x_cons
, 'x' },
2422 { "loop" , tic54x_loop
, 1024 },
2423 { "break" , tic54x_break
, 0 },
2424 { "endloop" , tic54x_endloop
, 0 },
2425 { "mlib" , tic54x_mlib
, 0 },
2426 { "mlist" , s_ignore
, 0 },
2427 { "mnolist" , s_ignore
, 0 },
2428 { "mmregs" , tic54x_mmregs
, 0 },
2429 { "newblock" , tic54x_clear_local_labels
, 0 },
2430 { "option" , s_ignore
, 0 },
2431 { "p2align" , tic54x_p2align
, 0 },
2432 { "sblock" , tic54x_sblock
, 0 },
2433 { "sect" , tic54x_sect
, '*' },
2434 { "set" , tic54x_set
, 0 },
2435 { "equ" , tic54x_set
, 0 },
2436 { "space" , tic54x_space
, 0 },
2437 { "bes" , tic54x_space
, 1 },
2438 { "sslist" , tic54x_sslist
, 1 },
2439 { "ssnolist" , tic54x_sslist
, 0 },
2440 { "string" , tic54x_stringer
, 's' },
2441 { "pstring" , tic54x_stringer
, 'p' },
2442 { "struct" , tic54x_struct
, 0 },
2443 { "tag" , tic54x_tag
, 0 },
2444 { "endstruct", tic54x_endstruct
, 0 },
2445 { "tab" , s_ignore
, 0 },
2446 { "text" , tic54x_sect
, 't' },
2447 { "union" , tic54x_struct
, 1 },
2448 { "endunion" , tic54x_endstruct
, 1 },
2449 { "usect" , tic54x_usect
, 0 },
2450 { "var" , tic54x_var
, 0 },
2451 { "version" , tic54x_version
, 0 },
2456 md_parse_option (int c
, const char *arg
)
2462 case OPTION_COFF_VERSION
:
2464 int version
= atoi (arg
);
2466 if (version
!= 0 && version
!= 1 && version
!= 2)
2467 as_fatal (_("Bad COFF version '%s'"), arg
);
2468 /* FIXME -- not yet implemented. */
2471 case OPTION_CPU_VERSION
:
2473 cpu
= lookup_version (arg
);
2476 as_fatal (_("Bad CPU version '%s'"), arg
);
2479 case OPTION_ADDRESS_MODE
:
2481 address_mode_needs_set
= 1;
2483 case OPTION_STDERR_TO_FILE
:
2485 const char *filename
= arg
;
2486 FILE *fp
= fopen (filename
, "w+");
2489 as_fatal (_("Can't redirect stderr to the file '%s'"), filename
);
2491 if ((fp
= freopen (filename
, "w+", stderr
)) == NULL
)
2492 as_fatal (_("Can't redirect stderr to the file '%s'"), filename
);
2500 /* Create a "local" substitution string hash table for a new macro level
2501 Some docs imply that macros have to use .newblock in order to be able
2502 to re-use a local label. We effectively do an automatic .newblock by
2503 deleting the local label hash between macro invocations. */
2506 tic54x_macro_start (void)
2509 subsym_hash
[macro_level
] = hash_new ();
2510 local_label_hash
[macro_level
] = hash_new ();
2514 tic54x_macro_info (const macro_entry
*macro
)
2516 const formal_entry
*entry
;
2518 /* Put the formal args into the substitution symbol table. */
2519 for (entry
= macro
->formals
; entry
; entry
= entry
->next
)
2521 char *name
= strncpy (xmalloc (entry
->name
.len
+ 1),
2522 entry
->name
.ptr
, entry
->name
.len
);
2523 char *value
= strncpy (xmalloc (entry
->actual
.len
+ 1),
2524 entry
->actual
.ptr
, entry
->actual
.len
);
2526 name
[entry
->name
.len
] = '\0';
2527 value
[entry
->actual
.len
] = '\0';
2528 hash_insert (subsym_hash
[macro_level
], name
, value
);
2532 /* Get rid of this macro's .var's, arguments, and local labels. */
2535 tic54x_macro_end (void)
2537 hash_die (subsym_hash
[macro_level
]);
2538 subsym_hash
[macro_level
] = NULL
;
2539 hash_die (local_label_hash
[macro_level
]);
2540 local_label_hash
[macro_level
] = NULL
;
2545 subsym_symlen (char *a
, char *ignore ATTRIBUTE_UNUSED
)
2550 /* Compare symbol A to string B. */
2553 subsym_symcmp (char *a
, char *b
)
2555 return strcmp (a
, b
);
2558 /* Return the index of the first occurrence of B in A, or zero if none
2559 assumes b is an integer char value as a string. Index is one-based. */
2562 subsym_firstch (char *a
, char *b
)
2565 char *tmp
= strchr (a
, val
);
2567 return tmp
? tmp
- a
+ 1 : 0;
2570 /* Similar to firstch, but returns index of last occurrence of B in A. */
2573 subsym_lastch (char *a
, char *b
)
2576 char *tmp
= strrchr (a
, val
);
2578 return tmp
? tmp
- a
+ 1 : 0;
2581 /* Returns 1 if string A is defined in the symbol table (NOT the substitution
2585 subsym_isdefed (char *a
, char *ignore ATTRIBUTE_UNUSED
)
2587 symbolS
*symbolP
= symbol_find (a
);
2589 return symbolP
!= NULL
;
2592 /* Assign first member of comma-separated list B (e.g. "1,2,3") to the symbol
2593 A, or zero if B is a null string. Both arguments *must* be substitution
2594 symbols, unsubstituted. */
2597 subsym_ismember (char *sym
, char *list
)
2599 char *elem
, *ptr
, *listv
;
2604 listv
= subsym_lookup (list
, macro_level
);
2607 as_bad (_("Undefined substitution symbol '%s'"), list
);
2608 ignore_rest_of_line ();
2612 ptr
= elem
= xstrdup (listv
);
2613 while (*ptr
&& *ptr
!= ',')
2617 subsym_create_or_replace (sym
, elem
);
2619 /* Reassign the list. */
2620 subsym_create_or_replace (list
, ptr
);
2622 /* Assume this value, docs aren't clear. */
2626 /* Return zero if not a constant; otherwise:
2634 subsym_iscons (char *a
, char *ignore ATTRIBUTE_UNUSED
)
2638 parse_expression (a
, &expn
);
2640 if (expn
.X_op
== O_constant
)
2642 int len
= strlen (a
);
2644 switch (TOUPPER (a
[len
- 1]))
2657 /* No suffix; either octal, hex, or decimal. */
2658 if (*a
== '0' && len
> 1)
2660 if (TOUPPER (a
[1]) == 'X')
2670 /* Return 1 if A is a valid symbol name. Expects string input. */
2673 subsym_isname (char *a
, char *ignore ATTRIBUTE_UNUSED
)
2675 if (!is_name_beginner (*a
))
2679 if (!is_part_of_name (*a
))
2686 /* Return whether the string is a register; accepts ar0-7, unless .mmregs has
2687 been seen; if so, recognize any memory-mapped register.
2688 Note this does not recognize "A" or "B" accumulators. */
2691 subsym_isreg (char *a
, char *ignore ATTRIBUTE_UNUSED
)
2693 if (hash_find (reg_hash
, a
))
2695 if (hash_find (mmreg_hash
, a
))
2700 /* Return the structure size, given the stag. */
2703 subsym_structsz (char *name
, char *ignore ATTRIBUTE_UNUSED
)
2705 struct stag
*stag
= (struct stag
*) hash_find (stag_hash
, name
);
2713 /* If anybody actually uses this, they can fix it :)
2714 FIXME I'm not sure what the "reference point" of a structure is. It might
2715 be either the initial offset given .struct, or it may be the offset of the
2716 structure within another structure, or it might be something else
2717 altogether. since the TI assembler doesn't seem to ever do anything but
2718 return zero, we punt and return zero. */
2721 subsym_structacc (char *stag_name ATTRIBUTE_UNUSED
,
2722 char *ignore ATTRIBUTE_UNUSED
)
2728 math_ceil (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2730 return (float) ceil (arg1
);
2734 math_cvi (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2740 math_floor (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2742 return (float) floor (arg1
);
2746 math_fmod (float arg1
, float arg2
)
2748 return (int) arg1
% (int) arg2
;
2752 math_int (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2754 return ((float) ((int) arg1
)) == arg1
;
2758 math_round (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2760 return arg1
> 0 ? (int) (arg1
+ 0.5) : (int) (arg1
- 0.5);
2764 math_sgn (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2766 return (arg1
< 0) ? -1 : (arg1
? 1 : 0);
2770 math_trunc (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2776 math_acos (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2778 return (float) acos (arg1
);
2782 math_asin (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2784 return (float) asin (arg1
);
2788 math_atan (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2790 return (float) atan (arg1
);
2794 math_atan2 (float arg1
, float arg2
)
2796 return (float) atan2 (arg1
, arg2
);
2800 math_cosh (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2802 return (float) cosh (arg1
);
2806 math_cos (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2808 return (float) cos (arg1
);
2812 math_cvf (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2814 return (float) arg1
;
2818 math_exp (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2820 return (float) exp (arg1
);
2824 math_fabs (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2826 return (float) fabs (arg1
);
2829 /* expr1 * 2^expr2. */
2832 math_ldexp (float arg1
, float arg2
)
2834 return arg1
* (float) pow (2.0, arg2
);
2838 math_log10 (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2840 return (float) log10 (arg1
);
2844 math_log (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2846 return (float) log (arg1
);
2850 math_max (float arg1
, float arg2
)
2852 return (arg1
> arg2
) ? arg1
: arg2
;
2856 math_min (float arg1
, float arg2
)
2858 return (arg1
< arg2
) ? arg1
: arg2
;
2862 math_pow (float arg1
, float arg2
)
2864 return (float) pow (arg1
, arg2
);
2868 math_sin (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2870 return (float) sin (arg1
);
2874 math_sinh (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2876 return (float) sinh (arg1
);
2880 math_sqrt (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2882 return (float) sqrt (arg1
);
2886 math_tan (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2888 return (float) tan (arg1
);
2892 math_tanh (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2894 return (float) tanh (arg1
);
2897 /* Built-in substitution symbol functions and math functions. */
2901 int (*proc
) (char *, char *);
2903 } subsym_proc_entry
;
2905 static const subsym_proc_entry subsym_procs
[] =
2907 /* Assembler built-in string substitution functions. */
2908 { "$symlen", subsym_symlen
, 1, },
2909 { "$symcmp", subsym_symcmp
, 2, },
2910 { "$firstch", subsym_firstch
, 2, },
2911 { "$lastch", subsym_lastch
, 2, },
2912 { "$isdefed", subsym_isdefed
, 1, },
2913 { "$ismember", subsym_ismember
, 2, },
2914 { "$iscons", subsym_iscons
, 1, },
2915 { "$isname", subsym_isname
, 1, },
2916 { "$isreg", subsym_isreg
, 1, },
2917 { "$structsz", subsym_structsz
, 1, },
2918 { "$structacc", subsym_structacc
, 1, },
2925 float (*proc
) (float, float);
2930 static const math_proc_entry math_procs
[] =
2932 /* Integer-returning built-in math functions. */
2933 { "$cvi", math_cvi
, 1, 1 },
2934 { "$int", math_int
, 1, 1 },
2935 { "$sgn", math_sgn
, 1, 1 },
2937 /* Float-returning built-in math functions. */
2938 { "$acos", math_acos
, 1, 0 },
2939 { "$asin", math_asin
, 1, 0 },
2940 { "$atan", math_atan
, 1, 0 },
2941 { "$atan2", math_atan2
, 2, 0 },
2942 { "$ceil", math_ceil
, 1, 0 },
2943 { "$cosh", math_cosh
, 1, 0 },
2944 { "$cos", math_cos
, 1, 0 },
2945 { "$cvf", math_cvf
, 1, 0 },
2946 { "$exp", math_exp
, 1, 0 },
2947 { "$fabs", math_fabs
, 1, 0 },
2948 { "$floor", math_floor
, 1, 0 },
2949 { "$fmod", math_fmod
, 2, 0 },
2950 { "$ldexp", math_ldexp
, 2, 0 },
2951 { "$log10", math_log10
, 1, 0 },
2952 { "$log", math_log
, 1, 0 },
2953 { "$max", math_max
, 2, 0 },
2954 { "$min", math_min
, 2, 0 },
2955 { "$pow", math_pow
, 2, 0 },
2956 { "$round", math_round
, 1, 0 },
2957 { "$sin", math_sin
, 1, 0 },
2958 { "$sinh", math_sinh
, 1, 0 },
2959 { "$sqrt", math_sqrt
, 1, 0 },
2960 { "$tan", math_tan
, 1, 0 },
2961 { "$tanh", math_tanh
, 1, 0 },
2962 { "$trunc", math_trunc
, 1, 0 },
2963 { NULL
, NULL
, 0, 0 },
2971 const subsym_proc_entry
*subsym_proc
;
2972 const math_proc_entry
*math_proc
;
2973 const char *hash_err
;
2975 char *TIC54X_DIR
= getenv ("TIC54X_DIR");
2976 char *A_DIR
= TIC54X_DIR
? TIC54X_DIR
: getenv ("A_DIR");
2980 /* Look for A_DIR and add it to the include list. */
2983 char *tmp
= xstrdup (A_DIR
);
2987 char *next
= strchr (tmp
, ';');
2991 add_include_dir (tmp
);
2994 while (tmp
!= NULL
);
2997 op_hash
= hash_new ();
2998 for (tm
= (insn_template
*) tic54x_optab
; tm
->name
; tm
++)
3000 if (hash_find (op_hash
, tm
->name
))
3002 hash_err
= hash_insert (op_hash
, tm
->name
, (char *) tm
);
3004 as_fatal ("Internal Error: Can't hash %s: %s",
3005 tm
->name
, hash_err
);
3007 parop_hash
= hash_new ();
3008 for (tm
= (insn_template
*) tic54x_paroptab
; tm
->name
; tm
++)
3010 if (hash_find (parop_hash
, tm
->name
))
3012 hash_err
= hash_insert (parop_hash
, tm
->name
, (char *) tm
);
3014 as_fatal ("Internal Error: Can't hash %s: %s",
3015 tm
->name
, hash_err
);
3017 reg_hash
= hash_new ();
3018 for (sym
= (symbol
*) regs
; sym
->name
; sym
++)
3020 /* Add basic registers to the symbol table. */
3021 symbolS
*symbolP
= symbol_new (sym
->name
, absolute_section
,
3022 (valueT
) sym
->value
, &zero_address_frag
);
3023 SF_SET_LOCAL (symbolP
);
3024 symbol_table_insert (symbolP
);
3025 hash_err
= hash_insert (reg_hash
, sym
->name
, (char *) sym
);
3027 for (sym
= (symbol
*) mmregs
; sym
->name
; sym
++)
3028 hash_err
= hash_insert (reg_hash
, sym
->name
, (char *) sym
);
3029 mmreg_hash
= hash_new ();
3030 for (sym
= (symbol
*) mmregs
; sym
->name
; sym
++)
3031 hash_err
= hash_insert (mmreg_hash
, sym
->name
, (char *) sym
);
3033 cc_hash
= hash_new ();
3034 for (sym
= (symbol
*) condition_codes
; sym
->name
; sym
++)
3035 hash_err
= hash_insert (cc_hash
, sym
->name
, (char *) sym
);
3037 cc2_hash
= hash_new ();
3038 for (sym
= (symbol
*) cc2_codes
; sym
->name
; sym
++)
3039 hash_err
= hash_insert (cc2_hash
, sym
->name
, (char *) sym
);
3041 cc3_hash
= hash_new ();
3042 for (sym
= (symbol
*) cc3_codes
; sym
->name
; sym
++)
3043 hash_err
= hash_insert (cc3_hash
, sym
->name
, (char *) sym
);
3045 sbit_hash
= hash_new ();
3046 for (sym
= (symbol
*) status_bits
; sym
->name
; sym
++)
3047 hash_err
= hash_insert (sbit_hash
, sym
->name
, (char *) sym
);
3049 misc_symbol_hash
= hash_new ();
3050 for (symname
= (char **) misc_symbols
; *symname
; symname
++)
3051 hash_err
= hash_insert (misc_symbol_hash
, *symname
, *symname
);
3053 /* Only the base substitution table and local label table are initialized;
3054 the others (for local macro substitution) get instantiated as needed. */
3055 local_label_hash
[0] = hash_new ();
3056 subsym_hash
[0] = hash_new ();
3057 for (subsym_proc
= subsym_procs
; subsym_proc
->name
; subsym_proc
++)
3058 hash_err
= hash_insert (subsym_hash
[0], subsym_proc
->name
,
3059 (char *) subsym_proc
);
3061 math_hash
= hash_new ();
3062 for (math_proc
= math_procs
; math_proc
->name
; math_proc
++)
3064 /* Insert into the main subsym hash for recognition; insert into
3065 the math hash to actually store information. */
3066 hash_err
= hash_insert (subsym_hash
[0], math_proc
->name
,
3067 (char *) math_proc
);
3068 hash_err
= hash_insert (math_hash
, math_proc
->name
,
3069 (char *) math_proc
);
3071 subsym_recurse_hash
= hash_new ();
3072 stag_hash
= hash_new ();
3076 is_accumulator (struct opstruct
*operand
)
3078 return strcasecmp (operand
->buf
, "a") == 0
3079 || strcasecmp (operand
->buf
, "b") == 0;
3082 /* Return the number of operands found, or -1 on error, copying the
3083 operands into the given array and the accompanying expressions into
3087 get_operands (struct opstruct operands
[], char *line
)
3091 int expecting_operand
= 0;
3094 while (numexp
< MAX_OPERANDS
&& !is_end_of_line
[(int) *lptr
])
3096 int paren_not_balanced
= 0;
3097 char *op_start
, *op_end
;
3099 while (*lptr
&& ISSPACE (*lptr
))
3102 while (paren_not_balanced
|| *lptr
!= ',')
3106 if (paren_not_balanced
)
3108 as_bad (_("Unbalanced parenthesis in operand %d"), numexp
);
3115 ++paren_not_balanced
;
3116 else if (*lptr
== ')')
3117 --paren_not_balanced
;
3121 if (op_end
!= op_start
)
3123 int len
= op_end
- op_start
;
3125 strncpy (operands
[numexp
].buf
, op_start
, len
);
3126 operands
[numexp
].buf
[len
] = 0;
3127 /* Trim trailing spaces; while the preprocessor gets rid of most,
3128 there are weird usage patterns that can introduce them
3129 (i.e. using strings for macro args). */
3130 while (len
> 0 && ISSPACE (operands
[numexp
].buf
[len
- 1]))
3131 operands
[numexp
].buf
[--len
] = 0;
3137 if (expecting_operand
|| *lptr
== ',')
3139 as_bad (_("Expecting operand after ','"));
3145 if (*++lptr
== '\0')
3147 as_bad (_("Expecting operand after ','"));
3150 expecting_operand
= 1;
3154 while (*lptr
&& ISSPACE (*lptr
++))
3156 if (!is_end_of_line
[(int) *lptr
])
3158 as_bad (_("Extra junk on line"));
3162 /* OK, now parse them into expressions. */
3163 for (i
= 0; i
< numexp
; i
++)
3165 memset (&operands
[i
].exp
, 0, sizeof (operands
[i
].exp
));
3166 if (operands
[i
].buf
[0] == '#')
3169 parse_expression (operands
[i
].buf
+ 1, &operands
[i
].exp
);
3171 else if (operands
[i
].buf
[0] == '@')
3173 /* Direct notation. */
3174 parse_expression (operands
[i
].buf
+ 1, &operands
[i
].exp
);
3176 else if (operands
[i
].buf
[0] == '*')
3179 char *paren
= strchr (operands
[i
].buf
, '(');
3181 /* Allow immediate syntax in the inner expression. */
3182 if (paren
&& paren
[1] == '#')
3185 /* Pull out the lk expression or SP offset, if present. */
3188 int len
= strlen (paren
);
3189 char *end
= paren
+ len
;
3192 while (end
[-1] != ')')
3195 as_bad (_("Badly formed address expression"));
3200 parse_expression (paren
, &operands
[i
].exp
);
3204 operands
[i
].exp
.X_op
= O_absent
;
3207 parse_expression (operands
[i
].buf
, &operands
[i
].exp
);
3213 /* Predicates for different operand types. */
3216 is_immediate (struct opstruct
*operand
)
3218 return *operand
->buf
== '#';
3221 /* This is distinguished from immediate because some numbers must be constants
3222 and must *not* have the '#' prefix. */
3225 is_absolute (struct opstruct
*operand
)
3227 return operand
->exp
.X_op
== O_constant
&& !is_immediate (operand
);
3230 /* Is this an indirect operand? */
3233 is_indirect (struct opstruct
*operand
)
3235 return operand
->buf
[0] == '*';
3238 /* Is this a valid dual-memory operand? */
3241 is_dual (struct opstruct
*operand
)
3243 if (is_indirect (operand
) && strncasecmp (operand
->buf
, "*ar", 3) == 0)
3245 char *tmp
= operand
->buf
+ 3;
3250 /* Only allow *ARx, *ARx-, *ARx+, or *ARx+0%. */
3251 valid_mod
= *tmp
== '\0' ||
3252 strcasecmp (tmp
, "-") == 0 ||
3253 strcasecmp (tmp
, "+") == 0 ||
3254 strcasecmp (tmp
, "+0%") == 0;
3255 return arf
>= 2 && arf
<= 5 && valid_mod
;
3261 is_mmreg (struct opstruct
*operand
)
3263 return (is_absolute (operand
)
3264 || is_immediate (operand
)
3265 || hash_find (mmreg_hash
, operand
->buf
) != 0);
3269 is_type (struct opstruct
*operand
, enum optype type
)
3274 return operand
->buf
[0] == 0;
3277 return is_dual (operand
);
3279 return is_indirect (operand
);
3281 /* This one *must* be immediate. */
3282 return is_immediate (operand
);
3291 /* Address may be a numeric, indirect, or an expression. */
3292 return !is_immediate (operand
);
3295 return is_mmreg (operand
);
3300 return is_accumulator (operand
);
3302 return is_accumulator (operand
) && TOUPPER (operand
->buf
[0]) == 'B';
3304 return is_accumulator (operand
) && TOUPPER (operand
->buf
[0]) == 'A';
3306 return strncasecmp ("ar", operand
->buf
, 2) == 0
3307 && ISDIGIT (operand
->buf
[2]);
3309 return hash_find (sbit_hash
, operand
->buf
) != 0 || is_absolute (operand
);
3311 return hash_find (cc_hash
, operand
->buf
) != 0;
3313 return hash_find (cc2_hash
, operand
->buf
) != 0;
3315 return hash_find (cc3_hash
, operand
->buf
) != 0
3316 || is_immediate (operand
) || is_absolute (operand
);
3318 return (is_immediate (operand
) || is_absolute (operand
))
3319 && operand
->exp
.X_add_number
== 16;
3321 /* Allow st0 or st1 instead of a numeric. */
3322 return is_absolute (operand
) || is_immediate (operand
) ||
3323 strcasecmp ("st0", operand
->buf
) == 0 ||
3324 strcasecmp ("st1", operand
->buf
) == 0;
3327 return is_absolute (operand
) || is_immediate (operand
);
3329 return (is_immediate (operand
) || is_absolute (operand
))
3330 && operand
->exp
.X_add_number
>= 0 && operand
->exp
.X_add_number
< 16;
3332 /* Let this one catch out-of-range values. */
3333 return (is_immediate (operand
) || is_absolute (operand
))
3334 && operand
->exp
.X_add_number
!= 16;
3338 return is_absolute (operand
) || is_immediate (operand
);
3340 return is_immediate (operand
)
3341 && operand
->exp
.X_op
== O_constant
3342 && operand
->exp
.X_add_number
>= 0
3343 && operand
->exp
.X_add_number
< 256;
3346 /* Allow anything; assumes opcodes are ordered with Smem operands
3352 /* Just make sure it's an integer; check range later. */
3353 return is_immediate (operand
);
3355 return strcasecmp ("t", operand
->buf
) == 0 ||
3356 strcasecmp ("treg", operand
->buf
) == 0;
3358 return strcasecmp ("ts", operand
->buf
) == 0;
3360 return strcasecmp ("asm", operand
->buf
) == 0;
3362 return strcasecmp ("trn", operand
->buf
) == 0;
3364 return strcasecmp ("dp", operand
->buf
) == 0;
3366 return strcasecmp ("arp", operand
->buf
) == 0;
3373 operands_match (tic54x_insn
*insn
,
3374 struct opstruct
*operands
,
3376 const enum optype
*refoptype
,
3380 int op
= 0, refop
= 0;
3382 if (opcount
== 0 && minops
== 0)
3385 while (op
<= maxops
&& refop
<= maxops
)
3387 while (!is_type (&operands
[op
], OPTYPE (refoptype
[refop
])))
3389 /* Skip an optional template operand if it doesn't agree
3390 with the current operand. */
3391 if (refoptype
[refop
] & OPT
)
3402 /* Save the actual operand type for later use. */
3403 operands
[op
].type
= OPTYPE (refoptype
[refop
]);
3406 /* Have we matched them all yet? */
3411 /* If a later operand is *not* optional, no match. */
3412 if ((refoptype
[refop
] & OPT
) == 0)
3414 /* Flag any implicit default OP_DST operands so we know to add
3415 them explicitly when encoding the operand later. */
3416 if (OPTYPE (refoptype
[refop
]) == OP_DST
)
3417 insn
->using_default_dst
= 1;
3429 /* 16-bit direct memory address
3430 Explicit dmad operands are always in last word of insn (usually second
3431 word, but bumped to third if lk addressing is used)
3433 We allow *(dmad) notation because the TI assembler allows it.
3436 0 for 16-bit addresses
3437 1 for full 23-bit addresses
3438 2 for the upper 7 bits of a 23-bit address (LDX). */
3441 encode_dmad (tic54x_insn
*insn
, struct opstruct
*operand
, int xpc_code
)
3443 int op
= 1 + insn
->is_lkaddr
;
3445 /* Only allow *(dmad) expressions; all others are invalid. */
3446 if (is_indirect (operand
) && operand
->buf
[strlen (operand
->buf
) - 1] != ')')
3448 as_bad (_("Invalid dmad syntax '%s'"), operand
->buf
);
3452 insn
->opcode
[op
].addr_expr
= operand
->exp
;
3454 if (insn
->opcode
[op
].addr_expr
.X_op
== O_constant
)
3456 valueT value
= insn
->opcode
[op
].addr_expr
.X_add_number
;
3460 insn
->opcode
[0].word
&= 0xFF80;
3461 insn
->opcode
[0].word
|= (value
>> 16) & 0x7F;
3462 insn
->opcode
[1].word
= value
& 0xFFFF;
3464 else if (xpc_code
== 2)
3465 insn
->opcode
[op
].word
= (value
>> 16) & 0xFFFF;
3467 insn
->opcode
[op
].word
= value
;
3471 /* Do the fixup later; just store the expression. */
3472 insn
->opcode
[op
].word
= 0;
3473 insn
->opcode
[op
].r_nchars
= 2;
3475 if (amode
== c_mode
)
3476 insn
->opcode
[op
].r_type
= BFD_RELOC_TIC54X_16_OF_23
;
3477 else if (xpc_code
== 1)
3479 /* This relocation spans two words, so adjust accordingly. */
3480 insn
->opcode
[0].addr_expr
= operand
->exp
;
3481 insn
->opcode
[0].r_type
= BFD_RELOC_TIC54X_23
;
3482 insn
->opcode
[0].r_nchars
= 4;
3483 insn
->opcode
[0].unresolved
= 1;
3484 /* It's really 2 words, but we want to stop encoding after the
3485 first, since we must encode both words at once. */
3488 else if (xpc_code
== 2)
3489 insn
->opcode
[op
].r_type
= BFD_RELOC_TIC54X_MS7_OF_23
;
3491 insn
->opcode
[op
].r_type
= BFD_RELOC_TIC54X_16_OF_23
;
3493 insn
->opcode
[op
].unresolved
= 1;
3499 /* 7-bit direct address encoding. */
3502 encode_address (tic54x_insn
*insn
, struct opstruct
*operand
)
3504 /* Assumes that dma addresses are *always* in word 0 of the opcode. */
3505 insn
->opcode
[0].addr_expr
= operand
->exp
;
3507 if (operand
->exp
.X_op
== O_constant
)
3508 insn
->opcode
[0].word
|= (operand
->exp
.X_add_number
& 0x7F);
3511 if (operand
->exp
.X_op
== O_register
)
3512 as_bad (_("Use the .mmregs directive to use memory-mapped register names such as '%s'"), operand
->buf
);
3513 /* Do the fixup later; just store the expression. */
3514 insn
->opcode
[0].r_nchars
= 1;
3515 insn
->opcode
[0].r_type
= BFD_RELOC_TIC54X_PARTLS7
;
3516 insn
->opcode
[0].unresolved
= 1;
3523 encode_indirect (tic54x_insn
*insn
, struct opstruct
*operand
)
3528 if (insn
->is_lkaddr
)
3530 /* lk addresses always go in the second insn word. */
3531 mod
= ((TOUPPER (operand
->buf
[1]) == 'A') ? 12 :
3532 (operand
->buf
[1] == '(') ? 15 :
3533 (strchr (operand
->buf
, '%') != NULL
) ? 14 : 13);
3534 arf
= ((mod
== 12) ? operand
->buf
[3] - '0' :
3535 (mod
== 15) ? 0 : operand
->buf
[4] - '0');
3537 insn
->opcode
[1].addr_expr
= operand
->exp
;
3539 if (operand
->exp
.X_op
== O_constant
)
3540 insn
->opcode
[1].word
= operand
->exp
.X_add_number
;
3543 insn
->opcode
[1].word
= 0;
3544 insn
->opcode
[1].r_nchars
= 2;
3545 insn
->opcode
[1].r_type
= BFD_RELOC_TIC54X_16_OF_23
;
3546 insn
->opcode
[1].unresolved
= 1;
3549 else if (strncasecmp (operand
->buf
, "*sp (", 4) == 0)
3551 /* Stack offsets look the same as 7-bit direct addressing. */
3552 return encode_address (insn
, operand
);
3556 arf
= (TOUPPER (operand
->buf
[1]) == 'A' ?
3557 operand
->buf
[3] : operand
->buf
[4]) - '0';
3559 if (operand
->buf
[1] == '+')
3561 mod
= 3; /* *+ARx */
3562 if (insn
->tm
->flags
& FL_SMR
)
3563 as_warn (_("Address mode *+ARx is write-only. "
3564 "Results of reading are undefined."));
3566 else if (operand
->buf
[4] == '\0')
3568 else if (operand
->buf
[5] == '\0')
3569 mod
= (operand
->buf
[4] == '-' ? 1 : 2); /* *ARx+ / *ARx- */
3570 else if (operand
->buf
[6] == '\0')
3572 if (operand
->buf
[5] == '0')
3573 mod
= (operand
->buf
[4] == '-' ? 5 : 6); /* *ARx+0 / *ARx-0 */
3575 mod
= (operand
->buf
[4] == '-' ? 8 : 10);/* *ARx+% / *ARx-% */
3577 else if (TOUPPER (operand
->buf
[6]) == 'B')
3578 mod
= (operand
->buf
[4] == '-' ? 4 : 7); /* ARx+0B / *ARx-0B */
3579 else if (TOUPPER (operand
->buf
[6]) == '%')
3580 mod
= (operand
->buf
[4] == '-' ? 9 : 11); /* ARx+0% / *ARx - 0% */
3583 as_bad (_("Unrecognized indirect address format \"%s\""),
3589 insn
->opcode
[0].word
|= 0x80 | (mod
<< 3) | arf
;
3595 encode_integer (tic54x_insn
*insn
,
3596 struct opstruct
*operand
,
3600 unsigned short mask
)
3602 long parse
, integer
;
3604 insn
->opcode
[which
].addr_expr
= operand
->exp
;
3606 if (operand
->exp
.X_op
== O_constant
)
3608 parse
= operand
->exp
.X_add_number
;
3609 /* Hack -- fixup for 16-bit hex quantities that get converted positive
3610 instead of negative. */
3611 if ((parse
& 0x8000) && min
== -32768 && max
== 32767)
3612 integer
= (short) parse
;
3616 if (integer
>= min
&& integer
<= max
)
3618 insn
->opcode
[which
].word
|= (integer
& mask
);
3621 as_bad (_("Operand '%s' out of range (%d <= x <= %d)"),
3622 operand
->buf
, min
, max
);
3626 if (insn
->opcode
[which
].addr_expr
.X_op
== O_constant
)
3628 insn
->opcode
[which
].word
|=
3629 insn
->opcode
[which
].addr_expr
.X_add_number
& mask
;
3633 /* Do the fixup later; just store the expression. */
3634 bfd_reloc_code_real_type rtype
=
3635 (mask
== 0x1FF ? BFD_RELOC_TIC54X_PARTMS9
:
3636 mask
== 0xFFFF ? BFD_RELOC_TIC54X_16_OF_23
:
3637 mask
== 0x7F ? BFD_RELOC_TIC54X_PARTLS7
: BFD_RELOC_8
);
3638 int size
= (mask
== 0x1FF || mask
== 0xFFFF) ? 2 : 1;
3640 if (rtype
== BFD_RELOC_8
)
3641 as_bad (_("Error in relocation handling"));
3643 insn
->opcode
[which
].r_nchars
= size
;
3644 insn
->opcode
[which
].r_type
= rtype
;
3645 insn
->opcode
[which
].unresolved
= 1;
3655 encode_condition (tic54x_insn
*insn
, struct opstruct
*operand
)
3657 symbol
*cc
= (symbol
*) hash_find (cc_hash
, operand
->buf
);
3660 as_bad (_("Unrecognized condition code \"%s\""), operand
->buf
);
3663 #define CC_GROUP 0x40
3665 #define CATG_A1 0x07
3666 #define CATG_B1 0x30
3667 #define CATG_A2 0x30
3668 #define CATG_B2 0x0C
3669 #define CATG_C2 0x03
3670 /* Disallow group 1 conditions mixed with group 2 conditions
3671 if group 1, allow only one category A and one category B
3672 if group 2, allow only one each of category A, B, and C. */
3673 if (((insn
->opcode
[0].word
& 0xFF) != 0))
3675 if ((insn
->opcode
[0].word
& CC_GROUP
) != (cc
->value
& CC_GROUP
))
3677 as_bad (_("Condition \"%s\" does not match preceding group"),
3681 if (insn
->opcode
[0].word
& CC_GROUP
)
3683 if ((insn
->opcode
[0].word
& CC_ACC
) != (cc
->value
& CC_ACC
))
3685 as_bad (_("Condition \"%s\" uses a different accumulator from "
3686 "a preceding condition"),
3690 if ((insn
->opcode
[0].word
& CATG_A1
) && (cc
->value
& CATG_A1
))
3692 as_bad (_("Only one comparison conditional allowed"));
3695 if ((insn
->opcode
[0].word
& CATG_B1
) && (cc
->value
& CATG_B1
))
3697 as_bad (_("Only one overflow conditional allowed"));
3701 else if ( ((insn
->opcode
[0].word
& CATG_A2
) && (cc
->value
& CATG_A2
))
3702 || ((insn
->opcode
[0].word
& CATG_B2
) && (cc
->value
& CATG_B2
))
3703 || ((insn
->opcode
[0].word
& CATG_C2
) && (cc
->value
& CATG_C2
)))
3705 as_bad (_("Duplicate %s conditional"), operand
->buf
);
3710 insn
->opcode
[0].word
|= cc
->value
;
3715 encode_cc3 (tic54x_insn
*insn
, struct opstruct
*operand
)
3717 symbol
*cc3
= (symbol
*) hash_find (cc3_hash
, operand
->buf
);
3718 int value
= cc3
? cc3
->value
: operand
->exp
.X_add_number
<< 8;
3720 if ((value
& 0x0300) != value
)
3722 as_bad (_("Unrecognized condition code \"%s\""), operand
->buf
);
3725 insn
->opcode
[0].word
|= value
;
3730 encode_arx (tic54x_insn
*insn
, struct opstruct
*operand
)
3732 int arf
= strlen (operand
->buf
) >= 3 ? operand
->buf
[2] - '0' : -1;
3734 if (strncasecmp ("ar", operand
->buf
, 2) || arf
< 0 || arf
> 7)
3736 as_bad (_("Invalid auxiliary register (use AR0-AR7)"));
3739 insn
->opcode
[0].word
|= arf
;
3744 encode_cc2 (tic54x_insn
*insn
, struct opstruct
*operand
)
3746 symbol
*cc2
= (symbol
*) hash_find (cc2_hash
, operand
->buf
);
3750 as_bad (_("Unrecognized condition code \"%s\""), operand
->buf
);
3753 insn
->opcode
[0].word
|= cc2
->value
;
3758 encode_operand (tic54x_insn
*insn
, enum optype type
, struct opstruct
*operand
)
3760 int ext
= (insn
->tm
->flags
& FL_EXT
) != 0;
3762 if (type
== OP_MMR
&& operand
->exp
.X_op
!= O_constant
)
3764 /* Disallow long-constant addressing for memory-mapped addressing. */
3765 if (insn
->is_lkaddr
)
3767 as_bad (_("lk addressing modes are invalid for memory-mapped "
3768 "register addressing"));
3772 /* Warn about *+ARx when used with MMR operands. */
3773 if (strncasecmp (operand
->buf
, "*+ar", 4) == 0)
3775 as_warn (_("Address mode *+ARx is not allowed in memory-mapped "
3776 "register addressing. Resulting behavior is "
3786 /* 16-bit immediate value. */
3787 return encode_dmad (insn
, operand
, 0);
3789 if (TOUPPER (*operand
->buf
) == 'B')
3791 insn
->opcode
[ext
? (1 + insn
->is_lkaddr
) : 0].word
|= (1 << 9);
3792 if (insn
->using_default_dst
)
3793 insn
->opcode
[ext
? (1 + insn
->is_lkaddr
) : 0].word
|= (1 << 8);
3797 /* Make sure this agrees with the OP_DST operand. */
3798 if (!((TOUPPER (operand
->buf
[0]) == 'B') ^
3799 ((insn
->opcode
[0].word
& (1 << 8)) != 0)))
3801 as_bad (_("Destination accumulator for each part of this parallel "
3802 "instruction must be different"));
3808 if (TOUPPER (operand
->buf
[0]) == 'B')
3809 insn
->opcode
[ext
? (1 + insn
->is_lkaddr
) : 0].word
|= (1 << 8);
3814 int mod
= (operand
->buf
[4] == '\0' ? 0 : /* *arx */
3815 operand
->buf
[4] == '-' ? 1 : /* *arx- */
3816 operand
->buf
[5] == '\0' ? 2 : 3); /* *arx+, *arx+0% */
3817 int arf
= operand
->buf
[3] - '0' - 2;
3818 int code
= (mod
<< 2) | arf
;
3819 insn
->opcode
[0].word
|= (code
<< (type
== OP_Xmem
? 4 : 0));
3824 if (!is_indirect (operand
))
3825 return encode_address (insn
, operand
);
3828 return encode_indirect (insn
, operand
);
3830 return encode_dmad (insn
, operand
, 2);
3832 return encode_dmad (insn
, operand
, 1);
3835 return encode_dmad (insn
, operand
, 0);
3837 return encode_arx (insn
, operand
);
3842 int value
= operand
->exp
.X_add_number
;
3845 insn
->opcode
[0].word
|= value
;
3848 if (value
< 16 || value
> 24)
3850 as_bad (_("Memory mapped register \"%s\" out of range"),
3854 if (type
== OP_MMRX
)
3855 insn
->opcode
[0].word
|= (value
- 16) << 4;
3857 insn
->opcode
[0].word
|= (value
- 16);
3865 return encode_integer (insn
, operand
, ext
+ insn
->is_lkaddr
,
3868 return encode_integer (insn
, operand
, ext
+ insn
->is_lkaddr
,
3871 return encode_integer (insn
, operand
, 1 + insn
->is_lkaddr
,
3872 -32768, 32767, 0xFFFF);
3874 return encode_condition (insn
, operand
);
3876 return encode_cc2 (insn
, operand
);
3878 return encode_cc3 (insn
, operand
);
3880 return encode_integer (insn
, operand
, 0, 0, 15, 0xF);
3882 return encode_integer (insn
, operand
, 0, -128, 127, 0xFF);
3885 int value
= operand
->exp
.X_add_number
;
3887 if (value
< 1 || value
> 3)
3889 as_bad (_("Invalid operand (use 1, 2, or 3)"));
3892 code
= value
== 1 ? 0 : value
== 2 ? 0x2 : 0x1;
3893 insn
->opcode
[0].word
|= (code
<< 8);
3897 return encode_integer (insn
, operand
, 0, 0, 31, 0x1F);
3899 return encode_integer (insn
, operand
, 0, 0, 255, 0xFF);
3901 return encode_integer (insn
, operand
, 1 + insn
->is_lkaddr
,
3905 symbol
*sbit
= (symbol
*) hash_find (sbit_hash
, operand
->buf
);
3906 int value
= is_absolute (operand
) ?
3907 operand
->exp
.X_add_number
: (sbit
? sbit
->value
: -1);
3910 if (insn
->opcount
== 1)
3914 as_bad (_("A status register or status bit name is required"));
3917 /* Guess the register based on the status bit; "ovb" is the last
3918 status bit defined for st0. */
3919 if (sbit
> (symbol
*) hash_find (sbit_hash
, "ovb"))
3924 as_bad (_("Unrecognized status bit \"%s\""), operand
->buf
);
3927 insn
->opcode
[0].word
|= value
;
3928 insn
->opcode
[0].word
|= (reg
<< 9);
3932 if (strcasecmp (operand
->buf
, "st0") == 0
3933 || strcasecmp (operand
->buf
, "st1") == 0)
3935 insn
->opcode
[0].word
|=
3936 ((unsigned short) (operand
->buf
[2] - '0')) << 9;
3939 else if (operand
->exp
.X_op
== O_constant
3940 && (operand
->exp
.X_add_number
== 0
3941 || operand
->exp
.X_add_number
== 1))
3943 insn
->opcode
[0].word
|=
3944 ((unsigned short) (operand
->exp
.X_add_number
)) << 9;
3947 as_bad (_("Invalid status register \"%s\""), operand
->buf
);
3950 return encode_integer (insn
, operand
, 0, -16, 15, 0x1F);
3952 return encode_integer (insn
, operand
, 0, 0, 7, 0x7);
3954 return encode_integer (insn
, operand
, 0, 0, 0x1FF, 0x1FF);
3956 if (operand
->exp
.X_add_number
!= 1
3957 && operand
->exp
.X_add_number
!= 2)
3959 as_bad (_("Operand \"%s\" out of range (use 1 or 2)"), operand
->buf
);
3962 insn
->opcode
[0].word
|= (operand
->exp
.X_add_number
- 1) << 9;
3971 /* No encoding necessary. */
3981 emit_insn (tic54x_insn
*insn
)
3984 flagword oldflags
= bfd_get_section_flags (stdoutput
, now_seg
);
3985 flagword flags
= oldflags
| SEC_CODE
;
3987 if (! bfd_set_section_flags (stdoutput
, now_seg
, flags
))
3988 as_warn (_("error setting flags for \"%s\": %s"),
3989 bfd_section_name (stdoutput
, now_seg
),
3990 bfd_errmsg (bfd_get_error ()));
3992 for (i
= 0; i
< insn
->words
; i
++)
3994 int size
= (insn
->opcode
[i
].unresolved
3995 && insn
->opcode
[i
].r_type
== BFD_RELOC_TIC54X_23
) ? 4 : 2;
3996 char *p
= frag_more (size
);
3999 md_number_to_chars (p
, (valueT
) insn
->opcode
[i
].word
, 2);
4001 md_number_to_chars (p
, (valueT
) insn
->opcode
[i
].word
<< 16, 4);
4003 if (insn
->opcode
[i
].unresolved
)
4004 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
,
4005 insn
->opcode
[i
].r_nchars
, &insn
->opcode
[i
].addr_expr
,
4006 FALSE
, insn
->opcode
[i
].r_type
);
4010 /* Convert the operand strings into appropriate opcode values
4011 return the total number of words used by the instruction. */
4014 build_insn (tic54x_insn
*insn
)
4018 /* Only non-parallel instructions support lk addressing. */
4019 if (!(insn
->tm
->flags
& FL_PAR
))
4021 for (i
= 0; i
< insn
->opcount
; i
++)
4023 if ((OPTYPE (insn
->operands
[i
].type
) == OP_Smem
4024 || OPTYPE (insn
->operands
[i
].type
) == OP_Lmem
4025 || OPTYPE (insn
->operands
[i
].type
) == OP_Sind
)
4026 && strchr (insn
->operands
[i
].buf
, '(')
4027 /* Don't mistake stack-relative addressing for lk addressing. */
4028 && strncasecmp (insn
->operands
[i
].buf
, "*sp (", 4) != 0)
4030 insn
->is_lkaddr
= 1;
4031 insn
->lkoperand
= i
;
4036 insn
->words
= insn
->tm
->words
+ insn
->is_lkaddr
;
4038 insn
->opcode
[0].word
= insn
->tm
->opcode
;
4039 if (insn
->tm
->flags
& FL_EXT
)
4040 insn
->opcode
[1 + insn
->is_lkaddr
].word
= insn
->tm
->opcode2
;
4042 for (i
= 0; i
< insn
->opcount
; i
++)
4044 enum optype type
= insn
->operands
[i
].type
;
4046 if (!encode_operand (insn
, type
, &insn
->operands
[i
]))
4049 if (insn
->tm
->flags
& FL_PAR
)
4050 for (i
= 0; i
< insn
->paropcount
; i
++)
4052 enum optype partype
= insn
->paroperands
[i
].type
;
4054 if (!encode_operand (insn
, partype
, &insn
->paroperands
[i
]))
4064 optimize_insn (tic54x_insn
*insn
)
4066 /* Optimize some instructions, helping out the brain-dead programmer. */
4067 #define is_zero(op) ((op).exp.X_op == O_constant && (op).exp.X_add_number == 0)
4068 if (strcasecmp (insn
->tm
->name
, "add") == 0)
4070 if (insn
->opcount
> 1
4071 && is_accumulator (&insn
->operands
[insn
->opcount
- 2])
4072 && is_accumulator (&insn
->operands
[insn
->opcount
- 1])
4073 && strcasecmp (insn
->operands
[insn
->opcount
- 2].buf
,
4074 insn
->operands
[insn
->opcount
- 1].buf
) == 0)
4077 insn
->using_default_dst
= 1;
4081 /* Try to collapse if Xmem and shift count is zero. */
4082 if ((OPTYPE (insn
->tm
->operand_types
[0]) == OP_Xmem
4083 && OPTYPE (insn
->tm
->operand_types
[1]) == OP_SHFT
4084 && is_zero (insn
->operands
[1]))
4085 /* Or if Smem, shift is zero or absent, and SRC == DST. */
4086 || (OPTYPE (insn
->tm
->operand_types
[0]) == OP_Smem
4087 && OPTYPE (insn
->tm
->operand_types
[1]) == OP_SHIFT
4088 && is_type (&insn
->operands
[1], OP_SHIFT
)
4089 && is_zero (insn
->operands
[1]) && insn
->opcount
== 3))
4091 insn
->operands
[1] = insn
->operands
[2];
4096 else if (strcasecmp (insn
->tm
->name
, "ld") == 0)
4098 if (insn
->opcount
== 3 && insn
->operands
[0].type
!= OP_SRC
)
4100 if ((OPTYPE (insn
->tm
->operand_types
[1]) == OP_SHIFT
4101 || OPTYPE (insn
->tm
->operand_types
[1]) == OP_SHFT
)
4102 && is_zero (insn
->operands
[1])
4103 && (OPTYPE (insn
->tm
->operand_types
[0]) != OP_lk
4104 || (insn
->operands
[0].exp
.X_op
== O_constant
4105 && insn
->operands
[0].exp
.X_add_number
<= 255
4106 && insn
->operands
[0].exp
.X_add_number
>= 0)))
4108 insn
->operands
[1] = insn
->operands
[2];
4114 else if (strcasecmp (insn
->tm
->name
, "sth") == 0
4115 || strcasecmp (insn
->tm
->name
, "stl") == 0)
4117 if ((OPTYPE (insn
->tm
->operand_types
[1]) == OP_SHIFT
4118 || OPTYPE (insn
->tm
->operand_types
[1]) == OP_SHFT
)
4119 && is_zero (insn
->operands
[1]))
4121 insn
->operands
[1] = insn
->operands
[2];
4126 else if (strcasecmp (insn
->tm
->name
, "sub") == 0)
4128 if (insn
->opcount
> 1
4129 && is_accumulator (&insn
->operands
[insn
->opcount
- 2])
4130 && is_accumulator (&insn
->operands
[insn
->opcount
- 1])
4131 && strcasecmp (insn
->operands
[insn
->opcount
- 2].buf
,
4132 insn
->operands
[insn
->opcount
- 1].buf
) == 0)
4135 insn
->using_default_dst
= 1;
4139 if ( ((OPTYPE (insn
->tm
->operand_types
[0]) == OP_Smem
4140 && OPTYPE (insn
->tm
->operand_types
[1]) == OP_SHIFT
)
4141 || (OPTYPE (insn
->tm
->operand_types
[0]) == OP_Xmem
4142 && OPTYPE (insn
->tm
->operand_types
[1]) == OP_SHFT
))
4143 && is_zero (insn
->operands
[1])
4144 && insn
->opcount
== 3)
4146 insn
->operands
[1] = insn
->operands
[2];
4154 /* Find a matching template if possible, and get the operand strings. */
4157 tic54x_parse_insn (tic54x_insn
*insn
, char *line
)
4159 insn
->tm
= (insn_template
*) hash_find (op_hash
, insn
->mnemonic
);
4162 as_bad (_("Unrecognized instruction \"%s\""), insn
->mnemonic
);
4166 insn
->opcount
= get_operands (insn
->operands
, line
);
4167 if (insn
->opcount
< 0)
4170 /* Check each variation of operands for this mnemonic. */
4171 while (insn
->tm
->name
&& strcasecmp (insn
->tm
->name
, insn
->mnemonic
) == 0)
4173 if (insn
->opcount
>= insn
->tm
->minops
4174 && insn
->opcount
<= insn
->tm
->maxops
4175 && operands_match (insn
, &insn
->operands
[0], insn
->opcount
,
4176 insn
->tm
->operand_types
,
4177 insn
->tm
->minops
, insn
->tm
->maxops
))
4179 /* SUCCESS! now try some optimizations. */
4180 if (optimize_insn (insn
))
4182 insn
->tm
= (insn_template
*) hash_find (op_hash
,
4191 as_bad (_("Unrecognized operand list '%s' for instruction '%s'"),
4192 line
, insn
->mnemonic
);
4196 /* We set this in start_line_hook, 'cause if we do a line replacement, we
4197 won't be able to see the next line. */
4198 static int parallel_on_next_line_hint
= 0;
4200 /* See if this is part of a parallel instruction
4201 Look for a subsequent line starting with "||". */
4204 next_line_shows_parallel (char *next_line
)
4206 /* Look for the second half. */
4207 while (ISSPACE (*next_line
))
4210 return (next_line
[0] == PARALLEL_SEPARATOR
4211 && next_line
[1] == PARALLEL_SEPARATOR
);
4215 tic54x_parse_parallel_insn_firstline (tic54x_insn
*insn
, char *line
)
4217 insn
->tm
= (insn_template
*) hash_find (parop_hash
, insn
->mnemonic
);
4220 as_bad (_("Unrecognized parallel instruction \"%s\""),
4225 while (insn
->tm
->name
&& strcasecmp (insn
->tm
->name
,
4226 insn
->mnemonic
) == 0)
4228 insn
->opcount
= get_operands (insn
->operands
, line
);
4229 if (insn
->opcount
< 0)
4231 if (insn
->opcount
== 2
4232 && operands_match (insn
, &insn
->operands
[0], insn
->opcount
,
4233 insn
->tm
->operand_types
, 2, 2))
4239 /* Didn't find a matching parallel; try for a normal insn. */
4243 /* Parse the second line of a two-line parallel instruction. */
4246 tic54x_parse_parallel_insn_lastline (tic54x_insn
*insn
, char *line
)
4248 int valid_mnemonic
= 0;
4250 insn
->paropcount
= get_operands (insn
->paroperands
, line
);
4251 while (insn
->tm
->name
&& strcasecmp (insn
->tm
->name
,
4252 insn
->mnemonic
) == 0)
4254 if (strcasecmp (insn
->tm
->parname
, insn
->parmnemonic
) == 0)
4258 if (insn
->paropcount
>= insn
->tm
->minops
4259 && insn
->paropcount
<= insn
->tm
->maxops
4260 && operands_match (insn
, insn
->paroperands
,
4262 insn
->tm
->paroperand_types
,
4263 insn
->tm
->minops
, insn
->tm
->maxops
))
4269 as_bad (_("Invalid operand (s) for parallel instruction \"%s\""),
4272 as_bad (_("Unrecognized parallel instruction combination \"%s || %s\""),
4273 insn
->mnemonic
, insn
->parmnemonic
);
4278 /* If quotes found, return copy of line up to closing quote;
4279 otherwise up until terminator.
4280 If it's a string, pass as-is; otherwise attempt substitution symbol
4281 replacement on the value. */
4284 subsym_get_arg (char *line
, const char *terminators
, char **str
, int nosub
)
4288 int is_string
= *line
== '"';
4289 int is_char
= ISDIGIT (*line
);
4293 while (ISDIGIT (*ptr
))
4296 *str
= xmalloc (ptr
- line
+ 1);
4297 strncpy (*str
, line
, ptr
- line
);
4298 (*str
)[ptr
- line
] = 0;
4302 char *savedp
= input_line_pointer
;
4305 input_line_pointer
= ptr
;
4306 *str
= demand_copy_C_string (&len
);
4307 endp
= input_line_pointer
;
4308 input_line_pointer
= savedp
;
4310 /* Do forced substitutions if requested. */
4311 if (!nosub
&& **str
== ':')
4312 *str
= subsym_substitute (*str
, 1);
4316 const char *term
= terminators
;
4319 while (*ptr
&& *ptr
!= *term
)
4330 *str
= xmalloc (ptr
- line
+ 1);
4331 strncpy (*str
, line
, ptr
- line
);
4332 (*str
)[ptr
- line
] = 0;
4333 /* Do simple substitution, if available. */
4334 if (!nosub
&& (value
= subsym_lookup (*str
, macro_level
)) != NULL
)
4341 /* Replace the given substitution string.
4342 We start at the innermost macro level, so that existing locals remain local
4343 Note: we're treating macro args identically to .var's; I don't know if
4344 that's compatible w/TI's assembler. */
4347 subsym_create_or_replace (char *name
, char *value
)
4351 for (i
= macro_level
; i
> 0; i
--)
4353 if (hash_find (subsym_hash
[i
], name
))
4355 hash_replace (subsym_hash
[i
], name
, value
);
4359 if (hash_find (subsym_hash
[0], name
))
4360 hash_replace (subsym_hash
[0], name
, value
);
4362 hash_insert (subsym_hash
[0], name
, value
);
4365 /* Look up the substitution string replacement for the given symbol.
4366 Start with the innermost macro substitution table given and work
4370 subsym_lookup (char *name
, int nest_level
)
4372 char *value
= hash_find (subsym_hash
[nest_level
], name
);
4374 if (value
|| nest_level
== 0)
4377 return subsym_lookup (name
, nest_level
- 1);
4380 /* Do substitution-symbol replacement on the given line (recursively).
4381 return the argument if no substitution was done
4383 Also look for built-in functions ($func (arg)) and local labels.
4385 If FORCED is set, look for forced substitutions of the form ':SYMBOL:'. */
4388 subsym_substitute (char *line
, int forced
)
4390 /* For each apparent symbol, see if it's a substitution symbol, and if so,
4391 replace it in the input. */
4392 char *replacement
; /* current replacement for LINE. */
4393 char *head
; /* Start of line. */
4394 char *ptr
; /* Current examination point. */
4395 int changed
= 0; /* Did we make a substitution? */
4396 int eval_line
= 0; /* Is this line a .eval/.asg statement? */
4397 int eval_symbol
= 0; /* Are we in the middle of the symbol for
4399 char *eval_end
= NULL
;
4401 int line_conditional
= 0;
4404 /* Work with a copy of the input line. */
4405 replacement
= xstrdup (line
);
4407 ptr
= head
= replacement
;
4409 /* Flag lines where we might need to replace a single '=' with two;
4410 GAS uses single '=' to assign macro args values, and possibly other
4411 places, so limit what we replace. */
4412 if (strstr (line
, ".if")
4413 || strstr (line
, ".elseif")
4414 || strstr (line
, ".break"))
4415 line_conditional
= 1;
4417 /* Watch out for .eval, so that we avoid doing substitution on the
4418 symbol being assigned a value. */
4419 if (strstr (line
, ".eval") || strstr (line
, ".asg"))
4422 /* If it's a macro definition, don't do substitution on the argument
4424 if (strstr (line
, ".macro"))
4427 while (!is_end_of_line
[(int) *ptr
])
4429 int current_char
= *ptr
;
4431 /* Need to update this since LINE may have been modified. */
4433 eval_end
= strrchr (ptr
, ',');
4435 /* Replace triple double quotes with bounding quote/escapes. */
4436 if (current_char
== '"' && ptr
[1] == '"' && ptr
[2] == '"')
4439 tmp
= strstr (ptr
+ 2, "\"\"\"");
4445 /* Replace a single '=' with a '==';
4446 for compatibility with older code only. */
4447 if (line_conditional
&& current_char
== '=')
4455 tmp
= xmalloc (strlen (head
) + 2 + strlen (ptr
) + 1);
4456 sprintf (tmp
, "%s==%s", head
, ptr
);
4457 /* Continue examining after the '=='. */
4458 ptr
= tmp
+ strlen (head
) + 2;
4460 head
= replacement
= tmp
;
4464 /* Flag when we've reached the symbol part of .eval/.asg. */
4465 if (eval_line
&& ptr
>= eval_end
)
4468 /* For each apparent symbol, see if it's a substitution symbol, and if
4469 so, replace it in the input. */
4470 if ((forced
&& current_char
== ':')
4471 || (!forced
&& is_name_beginner (current_char
)))
4473 char *name
; /* Symbol to be replaced. */
4474 char *savedp
= input_line_pointer
;
4477 char *tail
; /* Rest of line after symbol. */
4479 /* Skip the colon. */
4483 input_line_pointer
= ptr
;
4484 c
= get_symbol_name (&name
);
4485 /* '?' is not normally part of a symbol, but it IS part of a local
4489 *input_line_pointer
++ = c
;
4490 c
= *input_line_pointer
;
4491 *input_line_pointer
= '\0';
4493 /* Avoid infinite recursion; if a symbol shows up a second time for
4494 substitution, leave it as is. */
4495 if (hash_find (subsym_recurse_hash
, name
) == NULL
)
4496 value
= subsym_lookup (name
, macro_level
);
4498 as_warn (_("%s symbol recursion stopped at "
4499 "second appearance of '%s'"),
4500 forced
? "Forced substitution" : "Substitution", name
);
4501 ptr
= tail
= input_line_pointer
;
4502 input_line_pointer
= savedp
;
4504 /* Check for local labels; replace them with the appropriate
4506 if ((*name
== '$' && ISDIGIT (name
[1]) && name
[2] == '\0')
4507 || name
[strlen (name
) - 1] == '?')
4509 /* Use an existing identifier for that label if, available, or
4510 create a new, unique identifier. */
4511 value
= hash_find (local_label_hash
[macro_level
], name
);
4515 char *namecopy
= xstrdup (name
);
4517 value
= strcpy (xmalloc (strlen (name
) + sizeof (digit
) + 1),
4520 value
[strlen (value
) - 1] = '\0';
4521 sprintf (digit
, ".%d", local_label_id
++);
4522 strcat (value
, digit
);
4523 hash_insert (local_label_hash
[macro_level
], namecopy
, value
);
4525 /* Indicate where to continue looking for substitutions. */
4528 /* Check for built-in subsym and math functions. */
4529 else if (value
!= NULL
&& *name
== '$')
4531 subsym_proc_entry
*entry
= (subsym_proc_entry
*) value
;
4532 math_proc_entry
*math_entry
= hash_find (math_hash
, name
);
4533 char *arg1
, *arg2
= NULL
;
4538 as_bad (_("Unrecognized substitution symbol function"));
4541 else if (*ptr
!= '(')
4543 as_bad (_("Missing '(' after substitution symbol function"));
4547 if (math_entry
!= NULL
)
4549 float farg1
, farg2
= 0;
4550 volatile float fresult
;
4552 farg1
= (float) strtod (ptr
, &ptr
);
4553 if (math_entry
->nargs
== 2)
4557 as_bad (_("Expecting second argument"));
4560 farg2
= (float) strtod (ptr
, &ptr
);
4562 fresult
= (*math_entry
->proc
) (farg1
, farg2
);
4563 value
= XNEWVEC (char, 128);
4564 if (math_entry
->int_return
)
4565 sprintf (value
, "%d", (int) fresult
);
4567 sprintf (value
, "%f", fresult
);
4570 as_bad (_("Extra junk in function call, expecting ')'"));
4573 /* Don't bother recursing; the replacement isn't a
4580 int arg_type
[2] = { *ptr
== '"' , 0 };
4581 int ismember
= !strcmp (entry
->name
, "$ismember");
4583 /* Parse one or two args, which must be a substitution
4584 symbol, string or a character-string constant. */
4585 /* For all functions, a string or substitution symbol may be
4586 used, with the following exceptions:
4587 firstch/lastch: 2nd arg must be character constant
4588 ismember: both args must be substitution symbols. */
4589 ptr
= subsym_get_arg (ptr
, ",)", &arg1
, ismember
);
4592 if (entry
->nargs
== 2)
4596 as_bad (_("Function expects two arguments"));
4599 /* Character constants are converted to numerics
4600 by the preprocessor. */
4601 arg_type
[1] = (ISDIGIT (*ptr
)) ? 2 : (*ptr
== '"');
4602 ptr
= subsym_get_arg (ptr
, ")", &arg2
, ismember
);
4604 /* Args checking. */
4605 if ((!strcmp (entry
->name
, "$firstch")
4606 || !strcmp (entry
->name
, "$lastch"))
4607 && arg_type
[1] != 2)
4609 as_bad (_("Expecting character constant argument"));
4613 && (arg_type
[0] != 0 || arg_type
[1] != 0))
4615 as_bad (_("Both arguments must be substitution symbols"));
4620 as_bad (_("Extra junk in function call, expecting ')'"));
4623 val
= (*entry
->proc
) (arg1
, arg2
);
4624 value
= XNEWVEC (char, 64);
4625 sprintf (value
, "%d", val
);
4627 /* Fix things up to replace the entire expression, not just the
4633 if (value
!= NULL
&& !eval_symbol
)
4635 /* Replace the symbol with its string replacement and
4636 continue. Recursively replace VALUE until either no
4637 substitutions are performed, or a substitution that has been
4638 previously made is encountered again.
4640 Put the symbol into the recursion hash table so we only
4641 try to replace a symbol once. */
4644 hash_insert (subsym_recurse_hash
, name
, name
);
4645 value
= subsym_substitute (value
, macro_level
> 0);
4646 hash_delete (subsym_recurse_hash
, name
, FALSE
);
4649 /* Temporarily zero-terminate where the symbol started. */
4655 /* Subscripted substitution symbol -- use just the
4656 indicated portion of the string; the description
4657 kinda indicates that forced substitution is not
4658 supposed to be recursive, but I'm not sure. */
4659 unsigned beg
, len
= 1; /* default to a single char */
4660 char *newval
= xstrdup (value
);
4662 savedp
= input_line_pointer
;
4663 input_line_pointer
= tail
+ 1;
4664 beg
= get_absolute_expression ();
4667 as_bad (_("Invalid subscript (use 1 to %d)"),
4668 (int) strlen (value
));
4671 if (*input_line_pointer
== ',')
4673 ++input_line_pointer
;
4674 len
= get_absolute_expression ();
4675 if (beg
+ len
> strlen (value
))
4677 as_bad (_("Invalid length (use 0 to %d"),
4678 (int) strlen (value
) - beg
);
4684 tail
= input_line_pointer
;
4687 as_bad (_("Missing ')' in subscripted substitution "
4688 "symbol expression"));
4692 input_line_pointer
= savedp
;
4698 tmp
= xmalloc (strlen (head
) + strlen (value
) +
4699 strlen (tail
+ 1) + 2);
4701 strcat (tmp
, value
);
4702 /* Make sure forced substitutions are properly terminated. */
4707 as_bad (_("Missing forced substitution terminator ':'"));
4713 /* Restore the character after the symbol end. */
4716 /* Continue examining after the replacement value. */
4717 ptr
= tmp
+ strlen (head
) + strlen (value
);
4719 head
= replacement
= tmp
;
4737 /* We use this to handle substitution symbols
4738 hijack input_line_pointer, replacing it with our substituted string.
4740 .sslist should enable listing the line after replacements are made...
4742 returns the new buffer limit. */
4745 tic54x_start_line_hook (void)
4748 char *replacement
= NULL
;
4750 /* Work with a copy of the input line, including EOL char. */
4751 endp
= input_line_pointer
;
4752 while (!is_end_of_line
[(int) *endp
++])
4754 line
= xmalloc (endp
- input_line_pointer
+ 1);
4755 strncpy (line
, input_line_pointer
, endp
- input_line_pointer
+ 1);
4756 line
[endp
- input_line_pointer
] = 0;
4758 /* Scan ahead for parallel insns. */
4759 parallel_on_next_line_hint
= next_line_shows_parallel (endp
);
4761 /* If within a macro, first process forced replacements. */
4762 if (macro_level
> 0)
4763 replacement
= subsym_substitute (line
, 1);
4766 replacement
= subsym_substitute (replacement
, 0);
4768 if (replacement
!= line
)
4770 char *tmp
= replacement
;
4771 char *comment
= strchr (replacement
, ';');
4772 char endc
= replacement
[strlen (replacement
) - 1];
4774 /* Clean up the replacement; we'd prefer to have this done by the
4775 standard preprocessing equipment (maybe do_scrub_chars?)
4776 but for now, do a quick-and-dirty. */
4777 if (comment
!= NULL
)
4784 comment
= replacement
+ strlen (replacement
) - 1;
4786 /* Trim trailing whitespace. */
4787 while (ISSPACE (*comment
))
4794 /* Compact leading whitespace. */
4795 while (ISSPACE (tmp
[0]) && ISSPACE (tmp
[1]))
4798 input_line_pointer
= endp
;
4799 input_scrub_insert_line (tmp
);
4802 /* Keep track of whether we've done a substitution. */
4803 substitution_line
= 1;
4809 substitution_line
= 0;
4813 /* This is the guts of the machine-dependent assembler. STR points to a
4814 machine dependent instruction. This function is supposed to emit
4815 the frags/bytes it assembles to. */
4817 md_assemble (char *line
)
4819 static int repeat_slot
= 0;
4820 static int delay_slots
= 0; /* How many delay slots left to fill? */
4821 static int is_parallel
= 0;
4822 static tic54x_insn insn
;
4824 char *savedp
= input_line_pointer
;
4827 input_line_pointer
= line
;
4828 c
= get_symbol_name (&line
);
4832 if (address_mode_needs_set
)
4834 set_address_mode (amode
);
4835 address_mode_needs_set
= 0;
4848 strcpy (insn
.parmnemonic
, line
);
4849 lptr
= input_line_pointer
;
4851 input_line_pointer
= savedp
;
4853 if (tic54x_parse_parallel_insn_lastline (&insn
, lptr
))
4855 int words
= build_insn (&insn
);
4857 if (delay_slots
!= 0)
4859 if (words
> delay_slots
)
4861 as_bad (_("Instruction does not fit in available delay "
4862 "slots (%d-word insn, %d slots left)"),
4863 words
, delay_slots
);
4867 delay_slots
-= words
;
4873 memset (&insn
, 0, sizeof (insn
));
4874 strcpy (insn
.mnemonic
, line
);
4875 lptr
= input_line_pointer
;
4877 input_line_pointer
= savedp
;
4879 /* See if this line is part of a parallel instruction; if so, either this
4880 line or the next line will have the "||" specifier preceding the
4881 mnemonic, and we look for it in the parallel insn hash table. */
4882 if (strstr (line
, "||") != NULL
|| parallel_on_next_line_hint
)
4884 char *tmp
= strstr (line
, "||");
4888 if (tic54x_parse_parallel_insn_firstline (&insn
, lptr
))
4891 /* If the parallel part is on the same line, process it now,
4892 otherwise let the assembler pick up the next line for us. */
4895 while (ISSPACE (tmp
[2]))
4897 md_assemble (tmp
+ 2);
4902 as_bad (_("Unrecognized parallel instruction '%s'"), line
);
4907 if (tic54x_parse_insn (&insn
, lptr
))
4911 if ((insn
.tm
->flags
& FL_LP
)
4912 && cpu
!= V545LP
&& cpu
!= V546LP
)
4914 as_bad (_("Instruction '%s' requires an LP cpu version"),
4918 if ((insn
.tm
->flags
& FL_FAR
)
4919 && amode
!= far_mode
)
4921 as_bad (_("Instruction '%s' requires far mode addressing"),
4926 words
= build_insn (&insn
);
4928 /* Is this instruction in a delay slot? */
4931 if (words
> delay_slots
)
4933 as_warn (_("Instruction does not fit in available delay "
4934 "slots (%d-word insn, %d slots left). "
4935 "Resulting behavior is undefined."),
4936 words
, delay_slots
);
4940 /* Branches in delay slots are not allowed. */
4941 if (insn
.tm
->flags
& FL_BMASK
)
4943 as_warn (_("Instructions which cause PC discontinuity are not "
4944 "allowed in a delay slot. "
4945 "Resulting behavior is undefined."));
4947 delay_slots
-= words
;
4950 /* Is this instruction the target of a repeat? */
4953 if (insn
.tm
->flags
& FL_NR
)
4954 as_warn (_("'%s' is not repeatable. "
4955 "Resulting behavior is undefined."),
4957 else if (insn
.is_lkaddr
)
4958 as_warn (_("Instructions using long offset modifiers or absolute "
4959 "addresses are not repeatable. "
4960 "Resulting behavior is undefined."));
4964 /* Make sure we check the target of a repeat instruction. */
4965 if (insn
.tm
->flags
& B_REPEAT
)
4968 /* FIXME -- warn if repeat_slot == 1 at EOF. */
4970 /* Make sure we check our delay slots for validity. */
4971 if (insn
.tm
->flags
& FL_DELAY
)
4974 /* FIXME -- warn if delay_slots != 0 at EOF. */
4979 /* Do a final adjustment on the symbol table; in this case, make sure we have
4980 a ".file" symbol. */
4983 tic54x_adjust_symtab (void)
4985 if (symbol_rootP
== NULL
4986 || S_GET_STORAGE_CLASS (symbol_rootP
) != C_FILE
)
4989 const char * filename
= as_where (&lineno
);
4990 c_dot_file_symbol (filename
, 0);
4994 /* In order to get gas to ignore any | chars at the start of a line,
4995 this function returns true if a | is found in a line.
4996 This lets us process parallel instructions, which span two lines. */
4999 tic54x_unrecognized_line (int c
)
5001 return c
== PARALLEL_SEPARATOR
;
5004 /* Watch for local labels of the form $[0-9] and [_a-zA-Z][_a-zA-Z0-9]*?
5005 Encode their names so that only we see them and can map them to the
5007 FIXME -- obviously this isn't done yet. These locals still show up in the
5010 tic54x_define_label (symbolS
*sym
)
5012 /* Just in case we need this later; note that this is not necessarily the
5013 same thing as line_label...
5014 When aligning or assigning labels to fields, sometimes the label is
5015 assigned other than the address at which the label appears.
5016 FIXME -- is this really needed? I think all the proper label assignment
5017 is done in tic54x_cons. */
5018 last_label_seen
= sym
;
5021 /* Try to parse something that normal parsing failed at. */
5024 tic54x_undefined_symbol (char *name
)
5028 /* Not sure how to handle predefined symbols. */
5029 if ((sym
= (symbol
*) hash_find (cc_hash
, name
)) != NULL
||
5030 (sym
= (symbol
*) hash_find (cc2_hash
, name
)) != NULL
||
5031 (sym
= (symbol
*) hash_find (cc3_hash
, name
)) != NULL
||
5032 (sym
= (symbol
*) hash_find (misc_symbol_hash
, name
)) != NULL
||
5033 (sym
= (symbol
*) hash_find (sbit_hash
, name
)) != NULL
)
5035 return symbol_new (name
, reg_section
,
5036 (valueT
) sym
->value
,
5037 &zero_address_frag
);
5040 if ((sym
= (symbol
*) hash_find (reg_hash
, name
)) != NULL
||
5041 (sym
= (symbol
*) hash_find (mmreg_hash
, name
)) != NULL
||
5042 !strcasecmp (name
, "a") || !strcasecmp (name
, "b"))
5044 return symbol_new (name
, reg_section
,
5045 (valueT
) sym
? sym
->value
: 0,
5046 &zero_address_frag
);
5052 /* Parse a name in an expression before the expression parser takes a stab at
5056 tic54x_parse_name (char *name ATTRIBUTE_UNUSED
,
5057 expressionS
*expn ATTRIBUTE_UNUSED
)
5063 md_atof (int type
, char *literalP
, int *sizeP
)
5065 /* Target data is little-endian, but floats are stored
5066 big-"word"ian. ugh. */
5067 return ieee_md_atof (type
, literalP
, sizeP
, TRUE
);
5071 tc_gen_reloc (asection
*section
, fixS
*fixP
)
5074 bfd_reloc_code_real_type code
= fixP
->fx_r_type
;
5075 asymbol
*sym
= symbol_get_bfdsym (fixP
->fx_addsy
);
5077 rel
= XNEW (arelent
);
5078 rel
->sym_ptr_ptr
= XNEW (asymbol
*);
5079 *rel
->sym_ptr_ptr
= sym
;
5080 /* We assume that all rel->address are host byte offsets. */
5081 rel
->address
= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
5082 rel
->address
/= OCTETS_PER_BYTE
;
5083 rel
->howto
= bfd_reloc_type_lookup (stdoutput
, code
);
5084 if (!strcmp (sym
->name
, section
->name
))
5085 rel
->howto
+= HOWTO_BANK
;
5089 const char *name
= S_GET_NAME (fixP
->fx_addsy
);
5092 as_fatal ("Cannot generate relocation type for symbol %s, code %s",
5093 name
, bfd_get_reloc_code_name (code
));
5099 /* Handle cons expressions. */
5102 tic54x_cons_fix_new (fragS
*frag
, int where
, int octets
, expressionS
*expn
,
5103 bfd_reloc_code_real_type r
)
5108 as_bad (_("Unsupported relocation size %d"), octets
);
5109 r
= BFD_RELOC_TIC54X_16_OF_23
;
5112 r
= BFD_RELOC_TIC54X_16_OF_23
;
5115 /* TI assembler always uses this, regardless of addressing mode. */
5117 r
= BFD_RELOC_TIC54X_23
;
5119 /* We never want to directly generate this; this is provided for
5120 stabs support only. */
5124 fix_new_exp (frag
, where
, octets
, expn
, 0, r
);
5127 /* Attempt to simplify or even eliminate a fixup.
5128 To indicate that a fixup has been eliminated, set fixP->fx_done.
5130 If fixp->fx_addsy is non-NULL, we'll have to generate a reloc entry. */
5133 md_apply_fix (fixS
*fixP
, valueT
*valP
, segT seg ATTRIBUTE_UNUSED
)
5135 char *buf
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
5136 valueT val
= * valP
;
5138 switch (fixP
->fx_r_type
)
5141 as_fatal ("Bad relocation type: 0x%02x", fixP
->fx_r_type
);
5143 case BFD_RELOC_TIC54X_MS7_OF_23
:
5144 val
= (val
>> 16) & 0x7F;
5146 case BFD_RELOC_TIC54X_16_OF_23
:
5148 bfd_put_16 (stdoutput
, val
, buf
);
5149 /* Indicate what we're actually writing, so that we don't get warnings
5150 about exceeding available space. */
5151 *valP
= val
& 0xFFFF;
5153 case BFD_RELOC_TIC54X_PARTLS7
:
5154 bfd_put_16 (stdoutput
,
5155 (bfd_get_16 (stdoutput
, buf
) & 0xFF80) | (val
& 0x7F),
5157 /* Indicate what we're actually writing, so that we don't get warnings
5158 about exceeding available space. */
5161 case BFD_RELOC_TIC54X_PARTMS9
:
5162 /* TI assembler doesn't shift its encoding for relocatable files, and is
5163 thus incompatible with this implementation's relocatable files. */
5164 bfd_put_16 (stdoutput
,
5165 (bfd_get_16 (stdoutput
, buf
) & 0xFE00) | (val
>> 7),
5169 case BFD_RELOC_TIC54X_23
:
5170 bfd_put_32 (stdoutput
,
5171 (bfd_get_32 (stdoutput
, buf
) & 0xFF800000) | val
,
5176 if (fixP
->fx_addsy
== NULL
&& fixP
->fx_pcrel
== 0)
5180 /* This is our chance to record section alignment
5181 don't need to do anything here, since BFD does the proper encoding. */
5184 md_section_align (segT segment ATTRIBUTE_UNUSED
, valueT section_size
)
5186 return section_size
;
5190 md_pcrel_from (fixS
*fixP ATTRIBUTE_UNUSED
)
5195 /* Mostly little-endian, but longwords (4 octets) get MS word stored
5199 tic54x_number_to_chars (char *buf
, valueT val
, int n
)
5202 number_to_chars_littleendian (buf
, val
, n
);
5205 number_to_chars_littleendian (buf
, val
>> 16 , 2);
5206 number_to_chars_littleendian (buf
+ 2, val
& 0xFFFF, 2);
5211 tic54x_estimate_size_before_relax (fragS
*frag ATTRIBUTE_UNUSED
,
5212 segT seg ATTRIBUTE_UNUSED
)
5217 /* We use this to handle bit allocations which we couldn't handle before due
5218 to symbols being in different frags. return number of octets added. */
5221 tic54x_relax_frag (fragS
*frag
, long stretch ATTRIBUTE_UNUSED
)
5223 symbolS
*sym
= frag
->fr_symbol
;
5229 struct bit_info
*bi
= (struct bit_info
*) frag
->fr_opcode
;
5230 int bit_offset
= frag_bit_offset (frag_prev (frag
, bi
->seg
), bi
->seg
);
5231 int size
= S_GET_VALUE (sym
);
5232 fragS
*prev_frag
= bit_offset_frag (frag_prev (frag
, bi
->seg
), bi
->seg
);
5233 int available
= 16 - bit_offset
;
5235 if (symbol_get_frag (sym
) != &zero_address_frag
5236 || S_IS_COMMON (sym
)
5237 || !S_IS_DEFINED (sym
))
5238 as_bad_where (frag
->fr_file
, frag
->fr_line
,
5239 _("non-absolute value used with .space/.bes"));
5243 as_warn (_("negative value ignored in %s"),
5244 bi
->type
== TYPE_SPACE
? ".space" :
5245 bi
->type
== TYPE_BES
? ".bes" : ".field");
5247 frag
->tc_frag_data
= frag
->fr_fix
= 0;
5251 if (bi
->type
== TYPE_FIELD
)
5253 /* Bit fields of 16 or larger will have already been handled. */
5254 if (bit_offset
!= 0 && available
>= size
)
5256 char *p
= prev_frag
->fr_literal
;
5258 valueT value
= bi
->value
;
5259 value
<<= available
- size
;
5260 value
|= ((unsigned short) p
[1] << 8) | p
[0];
5261 md_number_to_chars (p
, value
, 2);
5262 if ((prev_frag
->tc_frag_data
+= size
) == 16)
5263 prev_frag
->tc_frag_data
= 0;
5265 symbol_set_frag (bi
->sym
, prev_frag
);
5266 /* This frag is no longer used. */
5267 growth
= -frag
->fr_fix
;
5269 frag
->tc_frag_data
= 0;
5273 char *p
= frag
->fr_literal
;
5275 valueT value
= bi
->value
<< (16 - size
);
5276 md_number_to_chars (p
, value
, 2);
5277 if ((frag
->tc_frag_data
= size
) == 16)
5278 frag
->tc_frag_data
= 0;
5284 if (bit_offset
!= 0 && bit_offset
< 16)
5286 if (available
>= size
)
5288 if ((prev_frag
->tc_frag_data
+= size
) == 16)
5289 prev_frag
->tc_frag_data
= 0;
5291 symbol_set_frag (bi
->sym
, prev_frag
);
5292 /* This frag is no longer used. */
5293 growth
= -frag
->fr_fix
;
5295 frag
->tc_frag_data
= 0;
5298 if (bi
->type
== TYPE_SPACE
&& bi
->sym
)
5299 symbol_set_frag (bi
->sym
, prev_frag
);
5302 growth
= (size
+ 15) / 16 * OCTETS_PER_BYTE
- frag
->fr_fix
;
5303 for (i
= 0; i
< growth
; i
++)
5304 frag
->fr_literal
[i
] = 0;
5305 frag
->fr_fix
= growth
;
5306 frag
->tc_frag_data
= size
% 16;
5307 /* Make sure any BES label points to the LAST word allocated. */
5308 if (bi
->type
== TYPE_BES
&& bi
->sym
)
5309 S_SET_VALUE (bi
->sym
, frag
->fr_fix
/ OCTETS_PER_BYTE
- 1);
5312 frag
->fr_symbol
= 0;
5313 frag
->fr_opcode
= 0;
5320 tic54x_convert_frag (bfd
*abfd ATTRIBUTE_UNUSED
,
5321 segT seg ATTRIBUTE_UNUSED
,
5324 /* Offset is in bytes. */
5325 frag
->fr_offset
= (frag
->fr_next
->fr_address
5327 - frag
->fr_fix
) / frag
->fr_var
;
5328 if (frag
->fr_offset
< 0)
5330 as_bad_where (frag
->fr_file
, frag
->fr_line
,
5331 _("attempt to .space/.bes backwards? (%ld)"),
5332 (long) frag
->fr_offset
);
5334 frag
->fr_type
= rs_space
;
5337 /* We need to avoid having labels defined for certain directives/pseudo-ops
5338 since once the label is defined, it's in the symbol table for good. TI
5339 syntax puts the symbol *before* the pseudo (which is kinda like MRI syntax,
5340 I guess, except I've never seen a definition of MRI syntax).
5342 Don't allow labels to start with '.' */
5345 tic54x_start_label (int nul_char
, int next_char
)
5349 /* If within .struct/.union, no auto line labels, please. */
5350 if (current_stag
!= NULL
)
5353 /* Disallow labels starting with "." */
5354 if (next_char
!= ':')
5356 char *label
= input_line_pointer
;
5358 while (!is_end_of_line
[(int) label
[-1]])
5362 as_bad (_("Invalid label '%s'"), label
);
5367 if (is_end_of_line
[(int) next_char
])
5370 rest
= input_line_pointer
;
5371 if (nul_char
== '"')
5373 while (ISSPACE (next_char
))
5374 next_char
= *++rest
;
5375 if (next_char
!= '.')
5378 /* Don't let colon () define a label for any of these... */
5379 return ((strncasecmp (rest
, ".tag", 4) != 0 || !ISSPACE (rest
[4]))
5380 && (strncasecmp (rest
, ".struct", 7) != 0 || !ISSPACE (rest
[7]))
5381 && (strncasecmp (rest
, ".union", 6) != 0 || !ISSPACE (rest
[6]))
5382 && (strncasecmp (rest
, ".macro", 6) != 0 || !ISSPACE (rest
[6]))
5383 && (strncasecmp (rest
, ".set", 4) != 0 || !ISSPACE (rest
[4]))
5384 && (strncasecmp (rest
, ".equ", 4) != 0 || !ISSPACE (rest
[4])));