1 /* tc-tic54x.c -- Assembly code for the Texas Instruments TMS320C54X
2 Copyright (C) 1999-2020 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 "opcode/tic54x.h"
60 symbolS
*sym
; /* Symbol for this stag; value is offset. */
61 const char *name
; /* Shortcut to symbol name. */
62 bfd_vma size
; /* Size of struct/union. */
63 int current_bitfield_offset
; /* Temporary for tracking fields. */
65 struct stag_field
/* List of fields. */
68 bfd_vma offset
; /* Of start of this field. */
69 int bitfield_offset
; /* Of start of this field. */
70 struct stag
*stag
; /* If field is struct/union. */
71 struct stag_field
*next
;
73 /* For nesting; used only in stag construction. */
74 struct stag
*inner
; /* Enclosed .struct. */
75 struct stag
*outer
; /* Enclosing .struct. */
76 } *current_stag
= NULL
;
78 #define MAX_LINE 256 /* Lines longer than this are truncated by TI's asm. */
80 typedef struct _tic54x_insn
82 const insn_template
*tm
; /* Opcode template. */
84 char mnemonic
[MAX_LINE
]; /* Opcode name/mnemonic. */
85 char parmnemonic
[MAX_LINE
]; /* 2nd mnemonic of parallel insn. */
93 } operands
[MAX_OPERANDS
];
96 struct opstruct paroperands
[MAX_OPERANDS
];
100 int words
; /* Size of insn in 16-bit words. */
101 int using_default_dst
; /* Do we need to explicitly set an
102 omitted OP_DST operand? */
105 unsigned short word
; /* Final encoded opcode data. */
107 int r_nchars
; /* Relocation size. */
108 bfd_reloc_code_real_type r_type
; /* Relocation type. */
109 expressionS addr_expr
; /* Storage for unresolved expressions. */
115 VNONE
= 0, V541
= 1, V542
= 2, V543
= 3, V545
= 5, V548
= 8, V549
= 9,
116 V545LP
= 15, V546LP
= 16
121 c_mode
, /* 16-bit addresses. */
122 far_mode
/* >16-bit addresses. */
125 static segT stag_saved_seg
;
126 static subsegT stag_saved_subseg
;
128 const char comment_chars
[] = ";";
129 const char line_comment_chars
[] = ";*#"; /* At column zero only. */
130 const char line_separator_chars
[] = ""; /* Not permitted. */
132 int emitting_long
= 0;
134 /* Characters which indicate that this is a floating point constant. */
135 const char FLT_CHARS
[] = "fF";
137 /* Characters that can be used to separate mantissa from exp in FP
139 const char EXP_CHARS
[] = "eE";
141 const char *md_shortopts
= "";
143 #define OPTION_ADDRESS_MODE (OPTION_MD_BASE)
144 #define OPTION_CPU_VERSION (OPTION_ADDRESS_MODE + 1)
145 #define OPTION_COFF_VERSION (OPTION_CPU_VERSION + 1)
146 #define OPTION_STDERR_TO_FILE (OPTION_COFF_VERSION + 1)
148 struct option md_longopts
[] =
150 { "mfar-mode", no_argument
, NULL
, OPTION_ADDRESS_MODE
},
151 { "mf", no_argument
, NULL
, OPTION_ADDRESS_MODE
},
152 { "mcpu", required_argument
, NULL
, OPTION_CPU_VERSION
},
153 { "merrors-to-file", required_argument
, NULL
, OPTION_STDERR_TO_FILE
},
154 { "me", required_argument
, NULL
, OPTION_STDERR_TO_FILE
},
155 { NULL
, no_argument
, NULL
, 0},
158 size_t md_longopts_size
= sizeof (md_longopts
);
160 static int assembly_begun
= 0;
161 /* Addressing mode is not entirely implemented; the latest rev of the Other
162 assembler doesn't seem to make any distinction whatsoever; all relocations
163 are stored as extended relocations. Older versions used REL16 vs RELEXT16,
164 but now it seems all relocations are RELEXT16. We use all RELEXT16.
166 The cpu version is kind of a waste of time as well. There is one
167 instruction (RND) for LP devices only, and several for devices with
168 extended addressing only. We include it for compatibility. */
169 static enum address_mode amode
= c_mode
;
170 static enum cpu_version cpu
= VNONE
;
172 /* Include string substitutions in listing? */
173 static int listing_sslist
= 0;
175 /* Did we do subsym substitutions on the line? */
176 static int substitution_line
= 0;
178 /* Last label seen. */
179 static symbolS
*last_label_seen
= NULL
;
181 /* This ensures that all new labels are unique. */
182 static int local_label_id
;
184 static htab_t subsym_recurse_hash
; /* Prevent infinite recurse. */
185 static htab_t math_hash
; /* Built-in math functions. */
186 /* Allow maximum levels of macro nesting; level 0 is the main substitution
187 symbol table. The other assembler only does 32 levels, so there! */
188 #define MAX_SUBSYM_HASH 100
189 static htab_t subsym_hash
[MAX_SUBSYM_HASH
];
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 htab_t local_label_hash
[100];
201 /* Keep track of struct/union tags. */
202 static htab_t stag_hash
;
203 static htab_t op_hash
;
204 static htab_t parop_hash
;
205 static htab_t reg_hash
;
206 static htab_t mmreg_hash
;
207 static htab_t cc_hash
;
208 static htab_t cc2_hash
;
209 static htab_t cc3_hash
;
210 static htab_t sbit_hash
;
211 static htab_t 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 octet 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
[(unsigned char) c
])
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 symbol_get_frag (symbolP
)->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 str_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
[(unsigned char) *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 str_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
*) str_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
[(unsigned char) *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
[(unsigned char) *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 (void **slot
, void *arg ATTRIBUTE_UNUSED
)
1123 string_tuple_t
*tuple
= *((string_tuple_t
**) slot
);
1124 void *elem
= str_hash_find (local_label_hash
[macro_level
], tuple
->key
);
1125 str_hash_delete (local_label_hash
[macro_level
], tuple
->key
);
1130 /* Reset all local labels. */
1133 tic54x_clear_local_labels (int ignored ATTRIBUTE_UNUSED
)
1135 htab_traverse (local_label_hash
[macro_level
], tic54x_remove_local_label
, NULL
);
1140 .sect "section name"
1143 make sure local labels get cleared when changing sections
1145 ARG is 't' for text, 'd' for data, or '*' for a named section
1147 For compatibility, '*' sections are SEC_CODE if instructions are
1148 encountered, or SEC_DATA if not.
1152 tic54x_sect (int arg
)
1154 ILLEGAL_WITHIN_STRUCT ();
1156 /* Local labels are cleared when changing sections. */
1157 tic54x_clear_local_labels (0);
1161 else if (arg
== 'd')
1167 /* Make sure all named initialized sections flagged properly. If we
1168 encounter instructions, we'll flag it with SEC_CODE as well. */
1169 const char *flags
= ",\"w\"\n";
1171 /* If there are quotes, remove them. */
1172 if (*input_line_pointer
== '"')
1174 name
= demand_copy_C_string (&len
);
1175 demand_empty_rest_of_line ();
1176 name
= concat (name
, flags
, (char *) NULL
);
1182 c
= get_symbol_name (&name
);
1183 name
= concat (name
, flags
, (char *) NULL
);
1184 (void) restore_line_pointer (c
);
1185 demand_empty_rest_of_line ();
1188 input_scrub_insert_line (name
);
1189 obj_coff_section (0);
1191 /* If there was a line label, make sure that it gets assigned the proper
1192 section. This is for compatibility, even though the actual behavior
1193 is not explicitly defined. For consistency, we make .sect behave
1194 like .usect, since that is probably what people expect. */
1195 if (line_label
!= NULL
)
1197 S_SET_SEGMENT (line_label
, now_seg
);
1198 symbol_set_frag (line_label
, frag_now
);
1199 S_SET_VALUE (line_label
, frag_now_fix ());
1200 if (S_GET_STORAGE_CLASS (line_label
) != C_EXT
)
1201 S_SET_STORAGE_CLASS (line_label
, C_LABEL
);
1206 /* [symbol] .space space_in_bits
1207 [symbol] .bes space_in_bits
1208 BES puts the symbol at the *last* word allocated
1210 cribbed from s_space. */
1213 tic54x_space (int arg
)
1219 int bits_per_byte
= (OCTETS_PER_BYTE
* 8);
1221 symbolS
*label
= line_label
;
1224 ILLEGAL_WITHIN_STRUCT ();
1226 #ifdef md_flush_pending_output
1227 md_flush_pending_output ();
1230 /* Read the bit count. */
1233 /* Some expressions are unresolvable until later in the assembly pass;
1234 postpone until relaxation/fixup. we also have to postpone if a previous
1235 partial allocation has not been completed yet. */
1236 if (expn
.X_op
!= O_constant
|| frag_bit_offset (frag_now
, now_seg
) == -1)
1238 struct bit_info
*bi
= XNEW (struct bit_info
);
1243 p
= frag_var (rs_machine_dependent
,
1244 65536 * 2, 1, (relax_substateT
) 0,
1245 make_expr_symbol (&expn
), (offsetT
) 0,
1253 /* Reduce the required size by any bit offsets currently left over
1254 from a previous .space/.bes/.field directive. */
1255 bit_offset
= frag_now
->tc_frag_data
;
1256 if (bit_offset
!= 0 && bit_offset
< 16)
1258 int spare_bits
= bits_per_byte
- bit_offset
;
1260 if (spare_bits
>= expn
.X_add_number
)
1262 /* Don't have to do anything; sufficient bits have already been
1263 allocated; just point the label to the right place. */
1266 symbol_set_frag (label
, frag_now
);
1267 S_SET_VALUE (label
, frag_now_fix () - 1);
1270 frag_now
->tc_frag_data
+= expn
.X_add_number
;
1273 expn
.X_add_number
-= spare_bits
;
1274 /* Set the label to point to the first word allocated, which in this
1275 case is the previous word, which was only partially filled. */
1276 if (!bes
&& label
!= NULL
)
1278 symbol_set_frag (label
, frag_now
);
1279 S_SET_VALUE (label
, frag_now_fix () - 1);
1283 /* Convert bits to bytes/words and octets, rounding up. */
1284 words
= ((expn
.X_add_number
+ bits_per_byte
- 1) / bits_per_byte
);
1285 /* How many do we have left over? */
1286 bit_offset
= expn
.X_add_number
% bits_per_byte
;
1287 octets
= words
* OCTETS_PER_BYTE
;
1290 as_warn (_(".space/.bes repeat count is negative, ignored"));
1293 else if (octets
== 0)
1295 as_warn (_(".space/.bes repeat count is zero, ignored"));
1299 /* If we are in the absolute section, just bump the offset. */
1300 if (now_seg
== absolute_section
)
1302 abs_section_offset
+= words
;
1303 if (bes
&& label
!= NULL
)
1304 S_SET_VALUE (label
, abs_section_offset
- 1);
1305 frag_now
->tc_frag_data
= bit_offset
;
1310 p
= frag_var (rs_fill
, 1, 1,
1311 (relax_substateT
) 0, (symbolS
*) 0,
1312 (offsetT
) octets
, (char *) 0);
1314 /* Make note of how many bits of this word we've allocated so far. */
1315 frag_now
->tc_frag_data
= bit_offset
;
1317 /* .bes puts label at *last* word allocated. */
1318 if (bes
&& label
!= NULL
)
1320 symbol_set_frag (label
, frag_now
);
1321 S_SET_VALUE (label
, frag_now_fix () - 1);
1329 demand_empty_rest_of_line ();
1332 /* [symbol] .usect "section-name", size-in-words
1333 [, [blocking-flag] [, alignment-flag]]
1335 Uninitialized section.
1336 Non-zero blocking means that if the section would cross a page (128-word)
1337 boundary, it will be page-aligned.
1338 Non-zero alignment aligns on a longword boundary.
1340 Has no effect on the current section. */
1343 tic54x_usect (int x ATTRIBUTE_UNUSED
)
1350 int size
, blocking_flag
, alignment_flag
;
1352 subsegT current_subseg
;
1355 ILLEGAL_WITHIN_STRUCT ();
1357 current_seg
= now_seg
; /* Save current seg. */
1358 current_subseg
= now_subseg
; /* Save current subseg. */
1360 c
= get_symbol_name (§ion_name
); /* Get terminator. */
1361 name
= xstrdup (section_name
);
1362 c
= restore_line_pointer (c
);
1365 ++input_line_pointer
;
1368 as_bad (_("Missing size argument"));
1369 ignore_rest_of_line ();
1373 size
= get_absolute_expression ();
1375 /* Read a possibly present third argument (blocking flag). */
1376 if (*input_line_pointer
== ',')
1378 ++input_line_pointer
;
1379 if (*input_line_pointer
!= ',')
1380 blocking_flag
= get_absolute_expression ();
1384 /* Read a possibly present fourth argument (alignment flag). */
1385 if (*input_line_pointer
== ',')
1387 ++input_line_pointer
;
1388 alignment_flag
= get_absolute_expression ();
1394 blocking_flag
= alignment_flag
= 0;
1396 seg
= subseg_new (name
, 0);
1397 flags
= bfd_section_flags (seg
) | SEC_ALLOC
;
1401 /* s_align eats end of line; restore it. */
1403 --input_line_pointer
;
1406 if (line_label
!= NULL
)
1408 S_SET_SEGMENT (line_label
, seg
);
1409 symbol_set_frag (line_label
, frag_now
);
1410 S_SET_VALUE (line_label
, frag_now_fix ());
1411 /* Set scl to label, since that's what TI does. */
1412 if (S_GET_STORAGE_CLASS (line_label
) != C_EXT
)
1413 S_SET_STORAGE_CLASS (line_label
, C_LABEL
);
1416 seg_info (seg
)->bss
= 1; /* Uninitialized data. */
1418 p
= frag_var (rs_fill
, 1, 1,
1419 (relax_substateT
) 0, (symbolS
*) line_label
,
1420 size
* OCTETS_PER_BYTE
, (char *) 0);
1424 flags
|= SEC_TIC54X_BLOCK
;
1426 if (!bfd_set_section_flags (seg
, flags
))
1427 as_warn (_("Error setting flags for \"%s\": %s"), name
,
1428 bfd_errmsg (bfd_get_error ()));
1430 subseg_set (current_seg
, current_subseg
); /* Restore current seg. */
1431 demand_empty_rest_of_line ();
1434 static enum cpu_version
1435 lookup_version (const char *ver
)
1437 enum cpu_version version
= VNONE
;
1439 if (ver
[0] == '5' && ver
[1] == '4')
1441 if (strlen (ver
) == 3
1442 && (ver
[2] == '1' || ver
[2] == '2' || ver
[2] == '3'
1443 || ver
[2] == '5' || ver
[2] == '8' || ver
[2] == '9'))
1444 version
= ver
[2] - '0';
1445 else if (strlen (ver
) == 5
1446 && TOUPPER (ver
[3]) == 'L'
1447 && TOUPPER (ver
[4]) == 'P'
1448 && (ver
[2] == '5' || ver
[2] == '6'))
1449 version
= ver
[2] - '0' + 10;
1456 set_cpu (enum cpu_version version
)
1459 if (version
== V545LP
|| version
== V546LP
)
1461 symbolS
*symbolP
= symbol_new ("__allow_lp", absolute_section
,
1462 (valueT
) 1, &zero_address_frag
);
1463 SF_SET_LOCAL (symbolP
);
1464 symbol_table_insert (symbolP
);
1468 /* .version cpu-version
1469 cpu-version may be one of the following:
1479 This is for compatibility only. It currently has no affect on assembly. */
1480 static int cpu_needs_set
= 1;
1483 tic54x_version (int x ATTRIBUTE_UNUSED
)
1485 enum cpu_version version
= VNONE
;
1486 enum cpu_version old_version
= cpu
;
1490 ILLEGAL_WITHIN_STRUCT ();
1493 ver
= input_line_pointer
;
1494 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
1495 ++input_line_pointer
;
1496 c
= *input_line_pointer
;
1497 *input_line_pointer
= 0;
1499 version
= lookup_version (ver
);
1501 if (cpu
!= VNONE
&& cpu
!= version
)
1502 as_warn (_("CPU version has already been set"));
1504 if (version
== VNONE
)
1506 as_bad (_("Unrecognized version '%s'"), ver
);
1507 ignore_rest_of_line ();
1510 else if (assembly_begun
&& version
!= old_version
)
1512 as_bad (_("Changing of CPU version on the fly not supported"));
1513 ignore_rest_of_line ();
1519 *input_line_pointer
= c
;
1520 demand_empty_rest_of_line ();
1523 /* 'f' = float, 'x' = xfloat, 'd' = double, 'l' = ldouble. */
1526 tic54x_float_cons (int type
)
1528 if (current_stag
!= 0)
1529 tic54x_struct_field ('f');
1531 #ifdef md_flush_pending_output
1532 md_flush_pending_output ();
1535 /* Align to long word boundary (4 octets) unless it's ".xfloat". */
1538 frag_align (2, 0, 2);
1539 /* If there's a label, assign it to the first allocated word. */
1540 if (line_label
!= NULL
)
1542 symbol_set_frag (line_label
, frag_now
);
1543 S_SET_VALUE (line_label
, frag_now_fix ());
1550 /* The argument is capitalized if it should be zero-terminated
1551 's' is normal string with upper 8-bits zero-filled, 'p' is packed.
1552 Code copied from stringer, and slightly modified so that strings are packed
1553 and encoded into the correct octets. */
1556 tic54x_stringer (int type
)
1559 int append_zero
= type
== 'S' || type
== 'P';
1560 int packed
= type
== 'p' || type
== 'P';
1561 int last_char
= -1; /* Packed strings need two bytes at a time to encode. */
1563 if (current_stag
!= NULL
)
1565 tic54x_struct_field ('*');
1569 #ifdef md_flush_pending_output
1570 md_flush_pending_output ();
1573 c
= ','; /* Do loop. */
1577 switch (*input_line_pointer
)
1581 unsigned short value
= get_absolute_expression ();
1582 FRAG_APPEND_1_CHAR ( value
& 0xFF);
1583 FRAG_APPEND_1_CHAR ((value
>> 8) & 0xFF);
1587 ++input_line_pointer
; /* -> 1st char of string. */
1588 while (is_a_char (c
= next_char_of_string ()))
1592 FRAG_APPEND_1_CHAR (c
);
1593 FRAG_APPEND_1_CHAR (0);
1597 /* Packed strings are filled MS octet first. */
1598 if (last_char
== -1)
1602 FRAG_APPEND_1_CHAR (c
);
1603 FRAG_APPEND_1_CHAR (last_char
);
1610 if (packed
&& last_char
!= -1)
1612 FRAG_APPEND_1_CHAR (0);
1613 FRAG_APPEND_1_CHAR (last_char
);
1618 FRAG_APPEND_1_CHAR (0);
1619 FRAG_APPEND_1_CHAR (0);
1622 know (input_line_pointer
[-1] == '\"');
1626 c
= *input_line_pointer
;
1627 if (!is_end_of_line
[c
])
1628 ++input_line_pointer
;
1631 /* Finish up any leftover packed string. */
1632 if (packed
&& last_char
!= -1)
1634 FRAG_APPEND_1_CHAR (0);
1635 FRAG_APPEND_1_CHAR (last_char
);
1637 demand_empty_rest_of_line ();
1641 tic54x_p2align (int arg ATTRIBUTE_UNUSED
)
1643 as_bad (_("p2align not supported on this target"));
1647 tic54x_align_words (int arg
)
1649 /* Only ".align" with no argument is allowed within .struct/.union. */
1652 if (!is_end_of_line
[(unsigned char) *input_line_pointer
])
1655 as_warn (_("Argument to .even ignored"));
1657 count
= get_absolute_expression ();
1660 if (current_stag
!= NULL
&& arg
== 128)
1662 if (current_stag
->current_bitfield_offset
!= 0)
1664 current_stag
->current_bitfield_offset
= 0;
1665 ++abs_section_offset
;
1667 demand_empty_rest_of_line ();
1671 ILLEGAL_WITHIN_STRUCT ();
1673 s_align_bytes (count
<< 1);
1676 /* Initialize multiple-bit fields within a single word of memory. */
1679 tic54x_field (int ignore ATTRIBUTE_UNUSED
)
1685 symbolS
*label
= line_label
;
1687 if (current_stag
!= NULL
)
1689 tic54x_struct_field ('.');
1693 input_line_pointer
= parse_expression (input_line_pointer
, &expn
);
1695 if (*input_line_pointer
== ',')
1697 ++input_line_pointer
;
1698 size
= get_absolute_expression ();
1699 if (size
< 1 || size
> 32)
1701 as_bad (_("Invalid field size, must be from 1 to 32"));
1702 ignore_rest_of_line ();
1707 /* Truncate values to the field width. */
1708 if (expn
.X_op
!= O_constant
)
1710 /* If the expression value is relocatable, the field size *must*
1714 as_bad (_("field size must be 16 when value is relocatable"));
1715 ignore_rest_of_line ();
1719 frag_now
->tc_frag_data
= 0;
1720 emit_expr (&expn
, 2);
1724 unsigned long fmask
= (size
== 32) ? 0xFFFFFFFF : (1ul << size
) - 1;
1726 value
= expn
.X_add_number
;
1727 expn
.X_add_number
&= fmask
;
1728 if (value
!= (valueT
) expn
.X_add_number
)
1729 as_warn (_("field value truncated"));
1730 value
= expn
.X_add_number
;
1731 /* Bits are stored MS first. */
1734 frag_now
->tc_frag_data
= 0;
1736 md_number_to_chars (p
, (value
>> (size
- 16)) & 0xFFFF, 2);
1741 int bit_offset
= frag_bit_offset (frag_now
, now_seg
);
1743 fragS
*alloc_frag
= bit_offset_frag (frag_now
, now_seg
);
1744 if (bit_offset
== -1)
1746 struct bit_info
*bi
= XNEW (struct bit_info
);
1747 /* We don't know the previous offset at this time, so store the
1748 info we need and figure it out later. */
1749 expressionS size_exp
;
1751 size_exp
.X_op
= O_constant
;
1752 size_exp
.X_add_number
= size
;
1754 bi
->type
= TYPE_FIELD
;
1756 p
= frag_var (rs_machine_dependent
,
1757 4, 1, (relax_substateT
) 0,
1758 make_expr_symbol (&size_exp
), (offsetT
) 0,
1762 else if (bit_offset
== 0 || bit_offset
+ size
> 16)
1764 /* Align a new field. */
1766 frag_now
->tc_frag_data
= 0;
1767 alloc_frag
= frag_now
;
1771 /* Put the new value entirely within the existing one. */
1772 p
= alloc_frag
== frag_now
?
1773 frag_now
->fr_literal
+ frag_now_fix_octets () - 2 :
1774 alloc_frag
->fr_literal
;
1777 symbol_set_frag (label
, alloc_frag
);
1778 if (alloc_frag
== frag_now
)
1779 S_SET_VALUE (label
, frag_now_fix () - 1);
1783 value
<<= 16 - alloc_frag
->tc_frag_data
- size
;
1785 /* OR in existing value. */
1786 if (alloc_frag
->tc_frag_data
)
1787 value
|= ((unsigned short) p
[1] << 8) | p
[0];
1788 md_number_to_chars (p
, value
, 2);
1789 alloc_frag
->tc_frag_data
+= size
;
1790 if (alloc_frag
->tc_frag_data
== 16)
1791 alloc_frag
->tc_frag_data
= 0;
1795 demand_empty_rest_of_line ();
1798 /* Ideally, we want to check SEC_LOAD and SEC_HAS_CONTENTS, but those aren't
1799 available yet. seg_info ()->bss is the next best thing. */
1802 tic54x_initialized_section (segT seg
)
1804 return !seg_info (seg
)->bss
;
1807 /* .clink ["section name"]
1809 Marks the section as conditionally linked (link only if contents are
1810 referenced elsewhere.
1811 Without a name, refers to the current initialized section.
1812 Name is required for uninitialized sections. */
1815 tic54x_clink (int ignored ATTRIBUTE_UNUSED
)
1819 ILLEGAL_WITHIN_STRUCT ();
1821 if (*input_line_pointer
== '\"')
1823 char *section_name
= ++input_line_pointer
;
1826 while (is_a_char (next_char_of_string ()))
1828 know (input_line_pointer
[-1] == '\"');
1829 input_line_pointer
[-1] = 0;
1830 name
= xstrdup (section_name
);
1832 seg
= bfd_get_section_by_name (stdoutput
, name
);
1835 as_bad (_("Unrecognized section '%s'"), section_name
);
1836 ignore_rest_of_line ();
1842 if (!tic54x_initialized_section (seg
))
1844 as_bad (_("Current section is uninitialized, "
1845 "section name required for .clink"));
1846 ignore_rest_of_line ();
1851 seg
->flags
|= SEC_TIC54X_CLINK
;
1853 demand_empty_rest_of_line ();
1856 /* Change the default include directory to be the current source file's
1857 directory, instead of the current working directory. If DOT is non-zero,
1858 set to "." instead. */
1861 tic54x_set_default_include (void)
1863 char *dir
, *tmp
= NULL
;
1864 const char *curfile
;
1867 curfile
= as_where (&lineno
);
1868 dir
= xstrdup (curfile
);
1869 tmp
= strrchr (dir
, '/');
1876 if (include_dir_count
== 0)
1878 include_dirs
= XNEWVEC (const char *, 1);
1879 include_dir_count
= 1;
1881 include_dirs
[0] = dir
;
1882 if (len
> include_dir_maxlen
)
1883 include_dir_maxlen
= len
;
1885 else if (include_dirs
!= NULL
)
1886 include_dirs
[0] = ".";
1889 /* .include "filename" | filename
1890 .copy "filename" | filename
1892 FIXME 'include' file should be omitted from any output listing,
1893 'copy' should be included in any output listing
1894 FIXME -- prevent any included files from changing listing (compat only)
1895 FIXME -- need to include source file directory in search path; what's a
1896 good way to do this?
1898 Entering/exiting included/copied file clears all local labels. */
1901 tic54x_include (int ignored ATTRIBUTE_UNUSED
)
1903 char newblock
[] = " .newblock\n";
1908 ILLEGAL_WITHIN_STRUCT ();
1912 if (*input_line_pointer
== '"')
1914 filename
= demand_copy_C_string (&len
);
1915 demand_empty_rest_of_line ();
1919 filename
= input_line_pointer
;
1920 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
1921 ++input_line_pointer
;
1922 c
= *input_line_pointer
;
1923 *input_line_pointer
= '\0';
1924 filename
= xstrdup (filename
);
1925 *input_line_pointer
= c
;
1926 demand_empty_rest_of_line ();
1928 /* Insert a partial line with the filename (for the sake of s_include)
1930 The included file will be inserted before the newblock, so that the
1931 newblock is executed after the included file is processed. */
1932 input
= concat ("\"", filename
, "\"\n", newblock
, (char *) NULL
);
1933 input_scrub_insert_line (input
);
1935 tic54x_clear_local_labels (0);
1937 tic54x_set_default_include ();
1943 tic54x_message (int type
)
1949 ILLEGAL_WITHIN_STRUCT ();
1951 if (*input_line_pointer
== '"')
1952 msg
= demand_copy_C_string (&len
);
1955 msg
= input_line_pointer
;
1956 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
1957 ++input_line_pointer
;
1958 c
= *input_line_pointer
;
1959 *input_line_pointer
= 0;
1960 msg
= xstrdup (msg
);
1961 *input_line_pointer
= c
;
1967 as_tsktsk ("%s", msg
);
1970 as_warn ("%s", msg
);
1977 demand_empty_rest_of_line ();
1981 Define a special symbol that refers to the loadtime address rather than the
1982 runtime address within the current section.
1984 This symbol gets a special storage class so that when it is resolved, it is
1985 resolved relative to the load address (lma) of the section rather than the
1986 run address (vma). */
1989 tic54x_label (int ignored ATTRIBUTE_UNUSED
)
1995 ILLEGAL_WITHIN_STRUCT ();
1997 c
= get_symbol_name (&name
);
1998 symbolP
= colon (name
);
1999 S_SET_STORAGE_CLASS (symbolP
, C_STATLAB
);
2001 (void) restore_line_pointer (c
);
2002 demand_empty_rest_of_line ();
2006 Install all memory-mapped register names into the symbol table as
2007 absolute local symbols. */
2010 tic54x_mmregs (int ignored ATTRIBUTE_UNUSED
)
2014 ILLEGAL_WITHIN_STRUCT ();
2016 for (sym
= (tic54x_symbol
*) mmregs
; sym
->name
; sym
++)
2018 symbolS
*symbolP
= symbol_new (sym
->name
, absolute_section
,
2019 (valueT
) sym
->value
, &zero_address_frag
);
2020 SF_SET_LOCAL (symbolP
);
2021 symbol_table_insert (symbolP
);
2026 Count defaults to 1024. */
2029 tic54x_loop (int count
)
2031 ILLEGAL_WITHIN_STRUCT ();
2034 if (!is_end_of_line
[(unsigned char) *input_line_pointer
])
2035 count
= get_absolute_expression ();
2037 do_repeat ((size_t) count
, "LOOP", "ENDLOOP");
2040 /* Normally, endloop gets eaten by the preceding loop. */
2043 tic54x_endloop (int ignore ATTRIBUTE_UNUSED
)
2045 as_bad (_("ENDLOOP without corresponding LOOP"));
2046 ignore_rest_of_line ();
2049 /* .break [condition]. */
2052 tic54x_break (int ignore ATTRIBUTE_UNUSED
)
2056 ILLEGAL_WITHIN_STRUCT ();
2059 if (!is_end_of_line
[(unsigned char) *input_line_pointer
])
2060 cond
= get_absolute_expression ();
2063 end_repeat (substitution_line
? 1 : 0);
2067 set_address_mode (int mode
)
2070 if (mode
== far_mode
)
2072 symbolS
*symbolP
= symbol_new ("__allow_far", absolute_section
,
2073 (valueT
) 1, &zero_address_frag
);
2074 SF_SET_LOCAL (symbolP
);
2075 symbol_table_insert (symbolP
);
2079 static int address_mode_needs_set
= 1;
2082 tic54x_address_mode (int mode
)
2084 if (assembly_begun
&& amode
!= (unsigned) mode
)
2086 as_bad (_("Mixing of normal and extended addressing not supported"));
2087 ignore_rest_of_line ();
2090 if (mode
== far_mode
&& cpu
!= VNONE
&& cpu
!= V548
&& cpu
!= V549
)
2092 as_bad (_("Extended addressing not supported on the specified CPU"));
2093 ignore_rest_of_line ();
2097 set_address_mode (mode
);
2098 demand_empty_rest_of_line ();
2101 /* .sblock "section"|section [,...,"section"|section]
2102 Designate initialized sections for blocking. */
2105 tic54x_sblock (int ignore ATTRIBUTE_UNUSED
)
2109 ILLEGAL_WITHIN_STRUCT ();
2116 if (*input_line_pointer
== '"')
2120 name
= demand_copy_C_string (&len
);
2126 c
= get_symbol_name (§ion_name
);
2127 name
= xstrdup (section_name
);
2128 (void) restore_line_pointer (c
);
2131 seg
= bfd_get_section_by_name (stdoutput
, name
);
2134 as_bad (_("Unrecognized section '%s'"), name
);
2135 ignore_rest_of_line ();
2138 else if (!tic54x_initialized_section (seg
))
2140 as_bad (_(".sblock may be used for initialized sections only"));
2141 ignore_rest_of_line ();
2144 seg
->flags
|= SEC_TIC54X_BLOCK
;
2146 c
= *input_line_pointer
;
2147 if (!is_end_of_line
[(unsigned char) c
])
2148 ++input_line_pointer
;
2151 demand_empty_rest_of_line ();
2154 /* symbol .set value
2157 value must be defined externals; no forward-referencing allowed
2158 symbols assigned with .set/.equ may not be redefined. */
2161 tic54x_set (int ignore ATTRIBUTE_UNUSED
)
2166 ILLEGAL_WITHIN_STRUCT ();
2170 as_bad (_("Symbol missing for .set/.equ"));
2171 ignore_rest_of_line ();
2174 name
= xstrdup (S_GET_NAME (line_label
));
2176 if ((symbolP
= symbol_find (name
)) == NULL
2177 && (symbolP
= md_undefined_symbol (name
)) == NULL
)
2179 symbolP
= symbol_new (name
, absolute_section
, 0, &zero_address_frag
);
2180 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
2183 S_SET_DATA_TYPE (symbolP
, T_INT
);
2184 S_SET_SEGMENT (symbolP
, absolute_section
);
2185 symbol_table_insert (symbolP
);
2186 pseudo_set (symbolP
);
2187 demand_empty_rest_of_line ();
2192 List false conditional blocks. */
2195 tic54x_fclist (int show
)
2198 listing
&= ~LISTING_NOCOND
;
2200 listing
|= LISTING_NOCOND
;
2201 demand_empty_rest_of_line ();
2205 tic54x_sslist (int show
)
2207 ILLEGAL_WITHIN_STRUCT ();
2209 listing_sslist
= show
;
2212 /* .var SYM[,...,SYMN]
2213 Define a substitution string to be local to a macro. */
2216 tic54x_var (int ignore ATTRIBUTE_UNUSED
)
2218 static char empty
[] = "";
2222 ILLEGAL_WITHIN_STRUCT ();
2224 if (macro_level
== 0)
2226 as_bad (_(".var may only be used within a macro definition"));
2227 ignore_rest_of_line ();
2232 if (!ISALPHA (*input_line_pointer
))
2234 as_bad (_("Substitution symbols must begin with a letter"));
2235 ignore_rest_of_line ();
2238 c
= get_symbol_name (&name
);
2239 /* .var symbols start out with a null string. */
2240 name
= xstrdup (name
);
2241 str_hash_insert (subsym_hash
[macro_level
], name
, empty
);
2242 c
= restore_line_pointer (c
);
2245 ++input_line_pointer
;
2246 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
2247 c
= *input_line_pointer
;
2252 demand_empty_rest_of_line ();
2255 /* .mlib <macro library filename>
2257 Macro libraries are archived (standard AR-format) text macro definitions
2258 Expand the file and include it.
2260 FIXME need to try the source file directory as well. */
2263 tic54x_mlib (int ignore ATTRIBUTE_UNUSED
)
2270 ILLEGAL_WITHIN_STRUCT ();
2272 /* Parse the filename. */
2273 if (*input_line_pointer
== '"')
2275 if ((filename
= demand_copy_C_string (&len
)) == NULL
)
2282 while (!is_end_of_line
[(unsigned char) *input_line_pointer
]
2283 && !ISSPACE (*input_line_pointer
))
2285 obstack_1grow (¬es
, *input_line_pointer
);
2286 ++input_line_pointer
;
2289 obstack_1grow (¬es
, '\0');
2290 filename
= obstack_finish (¬es
);
2292 demand_empty_rest_of_line ();
2294 tic54x_set_default_include ();
2295 path
= XNEWVEC (char, (unsigned long) len
+ include_dir_maxlen
+ 5);
2297 for (i
= 0; i
< include_dir_count
; i
++)
2301 strcpy (path
, include_dirs
[i
]);
2303 strcat (path
, filename
);
2304 if ((try = fopen (path
, "r")) != NULL
)
2311 if (i
>= include_dir_count
)
2317 /* FIXME: if path is found, malloc'd storage is not freed. Of course, this
2318 happens all over the place, and since the assembler doesn't usually keep
2319 running for a very long time, it really doesn't matter. */
2320 register_dependency (path
);
2322 /* Expand all archive entries to temporary files and include them. */
2323 abfd
= bfd_openr (path
, NULL
);
2326 as_bad (_("can't open macro library file '%s' for reading: %s"),
2327 path
, bfd_errmsg (bfd_get_error ()));
2328 ignore_rest_of_line ();
2331 if (!bfd_check_format (abfd
, bfd_archive
))
2333 as_bad (_("File '%s' not in macro archive format"), path
);
2334 ignore_rest_of_line ();
2338 /* Open each BFD as binary (it should be straight ASCII text). */
2339 for (mbfd
= bfd_openr_next_archived_file (abfd
, NULL
);
2340 mbfd
!= NULL
; mbfd
= bfd_openr_next_archived_file (abfd
, mbfd
))
2342 /* Get a size at least as big as the archive member. */
2343 bfd_size_type size
= bfd_get_size (mbfd
);
2344 char *buf
= XNEWVEC (char, size
);
2345 char *fname
= tmpnam (NULL
);
2348 /* We're not sure how big it is, but it will be smaller than "size". */
2349 size
= bfd_bread (buf
, size
, mbfd
);
2351 /* Write to a temporary file, then use s_include to include it
2353 ftmp
= fopen (fname
, "w+b");
2354 fwrite ((void *) buf
, size
, 1, ftmp
);
2355 if (size
== 0 || buf
[size
- 1] != '\n')
2356 fwrite ("\n", 1, 1, ftmp
);
2359 input_scrub_insert_file (fname
);
2364 const pseudo_typeS md_pseudo_table
[] =
2366 { "algebraic", s_ignore
, 0 },
2367 { "align" , tic54x_align_words
, 128 },
2368 { "ascii" , tic54x_stringer
, 'p' },
2369 { "asciz" , tic54x_stringer
, 'P' },
2370 { "even" , tic54x_align_words
, 2 },
2371 { "asg" , tic54x_asg
, 0 },
2372 { "eval" , tic54x_eval
, 0 },
2373 { "bss" , tic54x_bss
, 0 },
2374 { "byte" , tic54x_cons
, 'b' },
2375 { "ubyte" , tic54x_cons
, 'B' },
2376 { "char" , tic54x_cons
, 'c' },
2377 { "uchar" , tic54x_cons
, 'C' },
2378 { "clink" , tic54x_clink
, 0 },
2379 { "c_mode" , tic54x_address_mode
, c_mode
},
2380 { "copy" , tic54x_include
, 'c' },
2381 { "include" , tic54x_include
, 'i' },
2382 { "data" , tic54x_sect
, 'd' },
2383 { "double" , tic54x_float_cons
, 'd' },
2384 { "ldouble" , tic54x_float_cons
, 'l' },
2385 { "drlist" , s_ignore
, 0 },
2386 { "drnolist" , s_ignore
, 0 },
2387 { "emsg" , tic54x_message
, 'e' },
2388 { "mmsg" , tic54x_message
, 'm' },
2389 { "wmsg" , tic54x_message
, 'w' },
2390 { "far_mode" , tic54x_address_mode
, far_mode
},
2391 { "fclist" , tic54x_fclist
, 1 },
2392 { "fcnolist" , tic54x_fclist
, 0 },
2393 { "field" , tic54x_field
, -1 },
2394 { "float" , tic54x_float_cons
, 'f' },
2395 { "xfloat" , tic54x_float_cons
, 'x' },
2396 { "global" , tic54x_global
, 'g' },
2397 { "def" , tic54x_global
, 'd' },
2398 { "ref" , tic54x_global
, 'r' },
2399 { "half" , tic54x_cons
, 'h' },
2400 { "uhalf" , tic54x_cons
, 'H' },
2401 { "short" , tic54x_cons
, 's' },
2402 { "ushort" , tic54x_cons
, 'S' },
2403 { "if" , s_if
, (int) O_ne
},
2404 { "elseif" , s_elseif
, (int) O_ne
},
2405 { "else" , s_else
, 0 },
2406 { "endif" , s_endif
, 0 },
2407 { "int" , tic54x_cons
, 'i' },
2408 { "uint" , tic54x_cons
, 'I' },
2409 { "word" , tic54x_cons
, 'w' },
2410 { "uword" , tic54x_cons
, 'W' },
2411 { "label" , tic54x_label
, 0 }, /* Loadtime
2413 { "length" , s_ignore
, 0 },
2414 { "width" , s_ignore
, 0 },
2415 { "long" , tic54x_cons
, 'l' },
2416 { "ulong" , tic54x_cons
, 'L' },
2417 { "xlong" , tic54x_cons
, 'x' },
2418 { "loop" , tic54x_loop
, 1024 },
2419 { "break" , tic54x_break
, 0 },
2420 { "endloop" , tic54x_endloop
, 0 },
2421 { "mlib" , tic54x_mlib
, 0 },
2422 { "mlist" , s_ignore
, 0 },
2423 { "mnolist" , s_ignore
, 0 },
2424 { "mmregs" , tic54x_mmregs
, 0 },
2425 { "newblock" , tic54x_clear_local_labels
, 0 },
2426 { "option" , s_ignore
, 0 },
2427 { "p2align" , tic54x_p2align
, 0 },
2428 { "sblock" , tic54x_sblock
, 0 },
2429 { "sect" , tic54x_sect
, '*' },
2430 { "set" , tic54x_set
, 0 },
2431 { "equ" , tic54x_set
, 0 },
2432 { "space" , tic54x_space
, 0 },
2433 { "bes" , tic54x_space
, 1 },
2434 { "sslist" , tic54x_sslist
, 1 },
2435 { "ssnolist" , tic54x_sslist
, 0 },
2436 { "string" , tic54x_stringer
, 's' },
2437 { "pstring" , tic54x_stringer
, 'p' },
2438 { "struct" , tic54x_struct
, 0 },
2439 { "tag" , tic54x_tag
, 0 },
2440 { "endstruct", tic54x_endstruct
, 0 },
2441 { "tab" , s_ignore
, 0 },
2442 { "text" , tic54x_sect
, 't' },
2443 { "union" , tic54x_struct
, 1 },
2444 { "endunion" , tic54x_endstruct
, 1 },
2445 { "usect" , tic54x_usect
, 0 },
2446 { "var" , tic54x_var
, 0 },
2447 { "version" , tic54x_version
, 0 },
2452 md_parse_option (int c
, const char *arg
)
2458 case OPTION_COFF_VERSION
:
2460 int version
= atoi (arg
);
2462 if (version
!= 0 && version
!= 1 && version
!= 2)
2463 as_fatal (_("Bad COFF version '%s'"), arg
);
2464 /* FIXME -- not yet implemented. */
2467 case OPTION_CPU_VERSION
:
2469 cpu
= lookup_version (arg
);
2472 as_fatal (_("Bad CPU version '%s'"), arg
);
2475 case OPTION_ADDRESS_MODE
:
2477 address_mode_needs_set
= 1;
2479 case OPTION_STDERR_TO_FILE
:
2481 const char *filename
= arg
;
2482 FILE *fp
= fopen (filename
, "w+");
2485 as_fatal (_("Can't redirect stderr to the file '%s'"), filename
);
2487 if ((fp
= freopen (filename
, "w+", stderr
)) == NULL
)
2488 as_fatal (_("Can't redirect stderr to the file '%s'"), filename
);
2496 /* Create a "local" substitution string hash table for a new macro level
2497 Some docs imply that macros have to use .newblock in order to be able
2498 to re-use a local label. We effectively do an automatic .newblock by
2499 deleting the local label hash between macro invocations. */
2502 tic54x_macro_start (void)
2504 if (++macro_level
>= MAX_SUBSYM_HASH
)
2506 as_fatal (_("Macro nesting is too deep"));
2509 subsym_hash
[macro_level
] = str_htab_create ();
2510 local_label_hash
[macro_level
] = str_htab_create ();
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
= xstrndup (entry
->name
.ptr
, entry
->name
.len
);
2522 char *value
= xstrndup (entry
->actual
.ptr
, entry
->actual
.len
);
2524 name
[entry
->name
.len
] = '\0';
2525 value
[entry
->actual
.len
] = '\0';
2526 str_hash_insert (subsym_hash
[macro_level
], name
, value
);
2530 /* Get rid of this macro's .var's, arguments, and local labels. */
2533 tic54x_macro_end (void)
2535 htab_delete (subsym_hash
[macro_level
]);
2536 subsym_hash
[macro_level
] = NULL
;
2537 htab_delete (local_label_hash
[macro_level
]);
2538 local_label_hash
[macro_level
] = NULL
;
2543 subsym_symlen (char *a
, char *ignore ATTRIBUTE_UNUSED
)
2548 /* Compare symbol A to string B. */
2551 subsym_symcmp (char *a
, char *b
)
2553 return strcmp (a
, b
);
2556 /* Return the index of the first occurrence of B in A, or zero if none
2557 assumes b is an integer char value as a string. Index is one-based. */
2560 subsym_firstch (char *a
, char *b
)
2563 char *tmp
= strchr (a
, val
);
2565 return tmp
? tmp
- a
+ 1 : 0;
2568 /* Similar to firstch, but returns index of last occurrence of B in A. */
2571 subsym_lastch (char *a
, char *b
)
2574 char *tmp
= strrchr (a
, val
);
2576 return tmp
? tmp
- a
+ 1 : 0;
2579 /* Returns 1 if string A is defined in the symbol table (NOT the substitution
2583 subsym_isdefed (char *a
, char *ignore ATTRIBUTE_UNUSED
)
2585 symbolS
*symbolP
= symbol_find (a
);
2587 return symbolP
!= NULL
;
2590 /* Assign first member of comma-separated list B (e.g. "1,2,3") to the symbol
2591 A, or zero if B is a null string. Both arguments *must* be substitution
2592 symbols, unsubstituted. */
2595 subsym_ismember (char *sym
, char *list
)
2597 char *elem
, *ptr
, *listv
;
2602 listv
= subsym_lookup (list
, macro_level
);
2605 as_bad (_("Undefined substitution symbol '%s'"), list
);
2606 ignore_rest_of_line ();
2610 ptr
= elem
= xstrdup (listv
);
2611 while (*ptr
&& *ptr
!= ',')
2615 subsym_create_or_replace (sym
, elem
);
2617 /* Reassign the list. */
2618 subsym_create_or_replace (list
, ptr
);
2620 /* Assume this value, docs aren't clear. */
2624 /* Return zero if not a constant; otherwise:
2632 subsym_iscons (char *a
, char *ignore ATTRIBUTE_UNUSED
)
2636 parse_expression (a
, &expn
);
2638 if (expn
.X_op
== O_constant
)
2640 int len
= strlen (a
);
2642 switch (TOUPPER (a
[len
- 1]))
2655 /* No suffix; either octal, hex, or decimal. */
2656 if (*a
== '0' && len
> 1)
2658 if (TOUPPER (a
[1]) == 'X')
2668 /* Return 1 if A is a valid symbol name. Expects string input. */
2671 subsym_isname (char *a
, char *ignore ATTRIBUTE_UNUSED
)
2673 if (!is_name_beginner (*a
))
2677 if (!is_part_of_name (*a
))
2684 /* Return whether the string is a register; accepts ar0-7, unless .mmregs has
2685 been seen; if so, recognize any memory-mapped register.
2686 Note this does not recognize "A" or "B" accumulators. */
2689 subsym_isreg (char *a
, char *ignore ATTRIBUTE_UNUSED
)
2691 if (str_hash_find (reg_hash
, a
))
2693 if (str_hash_find (mmreg_hash
, a
))
2698 /* Return the structure size, given the stag. */
2701 subsym_structsz (char *name
, char *ignore ATTRIBUTE_UNUSED
)
2703 struct stag
*stag
= (struct stag
*) str_hash_find (stag_hash
, name
);
2711 /* If anybody actually uses this, they can fix it :)
2712 FIXME I'm not sure what the "reference point" of a structure is. It might
2713 be either the initial offset given .struct, or it may be the offset of the
2714 structure within another structure, or it might be something else
2715 altogether. since the TI assembler doesn't seem to ever do anything but
2716 return zero, we punt and return zero. */
2719 subsym_structacc (char *stag_name ATTRIBUTE_UNUSED
,
2720 char *ignore ATTRIBUTE_UNUSED
)
2726 math_ceil (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2728 return (float) ceil (arg1
);
2732 math_cvi (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2738 math_floor (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2740 return (float) floor (arg1
);
2744 math_fmod (float arg1
, float arg2
)
2746 return (int) arg1
% (int) arg2
;
2750 math_int (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2752 return ((float) ((int) arg1
)) == arg1
;
2756 math_round (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2758 return arg1
> 0 ? (int) (arg1
+ 0.5) : (int) (arg1
- 0.5);
2762 math_sgn (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2764 return (arg1
< 0) ? -1 : (arg1
? 1 : 0);
2768 math_trunc (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2774 math_acos (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2776 return (float) acos (arg1
);
2780 math_asin (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2782 return (float) asin (arg1
);
2786 math_atan (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2788 return (float) atan (arg1
);
2792 math_atan2 (float arg1
, float arg2
)
2794 return (float) atan2 (arg1
, arg2
);
2798 math_cosh (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2800 return (float) cosh (arg1
);
2804 math_cos (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2806 return (float) cos (arg1
);
2810 math_cvf (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2812 return (float) arg1
;
2816 math_exp (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2818 return (float) exp (arg1
);
2822 math_fabs (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2824 return (float) fabs (arg1
);
2827 /* expr1 * 2^expr2. */
2830 math_ldexp (float arg1
, float arg2
)
2832 return arg1
* (float) pow (2.0, arg2
);
2836 math_log10 (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2838 return (float) log10 (arg1
);
2842 math_log (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2844 return (float) log (arg1
);
2848 math_max (float arg1
, float arg2
)
2850 return (arg1
> arg2
) ? arg1
: arg2
;
2854 math_min (float arg1
, float arg2
)
2856 return (arg1
< arg2
) ? arg1
: arg2
;
2860 math_pow (float arg1
, float arg2
)
2862 return (float) pow (arg1
, arg2
);
2866 math_sin (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2868 return (float) sin (arg1
);
2872 math_sinh (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2874 return (float) sinh (arg1
);
2878 math_sqrt (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2880 return (float) sqrt (arg1
);
2884 math_tan (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2886 return (float) tan (arg1
);
2890 math_tanh (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2892 return (float) tanh (arg1
);
2895 /* Built-in substitution symbol functions and math functions. */
2899 int (*proc
) (char *, char *);
2901 } subsym_proc_entry
;
2903 static const subsym_proc_entry subsym_procs
[] =
2905 /* Assembler built-in string substitution functions. */
2906 { "$symlen", subsym_symlen
, 1, },
2907 { "$symcmp", subsym_symcmp
, 2, },
2908 { "$firstch", subsym_firstch
, 2, },
2909 { "$lastch", subsym_lastch
, 2, },
2910 { "$isdefed", subsym_isdefed
, 1, },
2911 { "$ismember", subsym_ismember
, 2, },
2912 { "$iscons", subsym_iscons
, 1, },
2913 { "$isname", subsym_isname
, 1, },
2914 { "$isreg", subsym_isreg
, 1, },
2915 { "$structsz", subsym_structsz
, 1, },
2916 { "$structacc", subsym_structacc
, 1, },
2923 float (*proc
) (float, float);
2928 static const math_proc_entry math_procs
[] =
2930 /* Integer-returning built-in math functions. */
2931 { "$cvi", math_cvi
, 1, 1 },
2932 { "$int", math_int
, 1, 1 },
2933 { "$sgn", math_sgn
, 1, 1 },
2935 /* Float-returning built-in math functions. */
2936 { "$acos", math_acos
, 1, 0 },
2937 { "$asin", math_asin
, 1, 0 },
2938 { "$atan", math_atan
, 1, 0 },
2939 { "$atan2", math_atan2
, 2, 0 },
2940 { "$ceil", math_ceil
, 1, 0 },
2941 { "$cosh", math_cosh
, 1, 0 },
2942 { "$cos", math_cos
, 1, 0 },
2943 { "$cvf", math_cvf
, 1, 0 },
2944 { "$exp", math_exp
, 1, 0 },
2945 { "$fabs", math_fabs
, 1, 0 },
2946 { "$floor", math_floor
, 1, 0 },
2947 { "$fmod", math_fmod
, 2, 0 },
2948 { "$ldexp", math_ldexp
, 2, 0 },
2949 { "$log10", math_log10
, 1, 0 },
2950 { "$log", math_log
, 1, 0 },
2951 { "$max", math_max
, 2, 0 },
2952 { "$min", math_min
, 2, 0 },
2953 { "$pow", math_pow
, 2, 0 },
2954 { "$round", math_round
, 1, 0 },
2955 { "$sin", math_sin
, 1, 0 },
2956 { "$sinh", math_sinh
, 1, 0 },
2957 { "$sqrt", math_sqrt
, 1, 0 },
2958 { "$tan", math_tan
, 1, 0 },
2959 { "$tanh", math_tanh
, 1, 0 },
2960 { "$trunc", math_trunc
, 1, 0 },
2961 { NULL
, NULL
, 0, 0 },
2969 const subsym_proc_entry
*subsym_proc
;
2970 const math_proc_entry
*math_proc
;
2972 char *TIC54X_DIR
= getenv ("TIC54X_DIR");
2973 char *A_DIR
= TIC54X_DIR
? TIC54X_DIR
: getenv ("A_DIR");
2977 /* Look for A_DIR and add it to the include list. */
2980 char *tmp
= xstrdup (A_DIR
);
2984 char *next
= strchr (tmp
, ';');
2988 add_include_dir (tmp
);
2991 while (tmp
!= NULL
);
2994 op_hash
= str_htab_create ();
2995 for (tm
= (insn_template
*) tic54x_optab
; tm
->name
; tm
++)
2997 if (str_hash_find (op_hash
, tm
->name
))
2999 str_hash_insert (op_hash
, tm
->name
, (char *) tm
);
3001 parop_hash
= str_htab_create ();
3002 for (tm
= (insn_template
*) tic54x_paroptab
; tm
->name
; tm
++)
3004 if (str_hash_find (parop_hash
, tm
->name
))
3006 str_hash_insert (parop_hash
, tm
->name
, (char *) tm
);
3008 reg_hash
= str_htab_create ();
3009 for (sym
= (tic54x_symbol
*) regs
; sym
->name
; sym
++)
3011 /* Add basic registers to the symbol table. */
3012 symbolS
*symbolP
= symbol_new (sym
->name
, absolute_section
,
3013 (valueT
) sym
->value
, &zero_address_frag
);
3014 SF_SET_LOCAL (symbolP
);
3015 symbol_table_insert (symbolP
);
3016 str_hash_insert (reg_hash
, sym
->name
, (char *) sym
);
3018 for (sym
= (tic54x_symbol
*) mmregs
; sym
->name
; sym
++)
3019 str_hash_insert (reg_hash
, sym
->name
, (char *) sym
);
3020 mmreg_hash
= str_htab_create ();
3021 for (sym
= (tic54x_symbol
*) mmregs
; sym
->name
; sym
++)
3022 str_hash_insert (mmreg_hash
, sym
->name
, (char *) sym
);
3024 cc_hash
= str_htab_create ();
3025 for (sym
= (tic54x_symbol
*) condition_codes
; sym
->name
; sym
++)
3026 str_hash_insert (cc_hash
, sym
->name
, (char *) sym
);
3028 cc2_hash
= str_htab_create ();
3029 for (sym
= (tic54x_symbol
*) cc2_codes
; sym
->name
; sym
++)
3030 str_hash_insert (cc2_hash
, sym
->name
, (char *) sym
);
3032 cc3_hash
= str_htab_create ();
3033 for (sym
= (tic54x_symbol
*) cc3_codes
; sym
->name
; sym
++)
3034 str_hash_insert (cc3_hash
, sym
->name
, (char *) sym
);
3036 sbit_hash
= str_htab_create ();
3037 for (sym
= (tic54x_symbol
*) status_bits
; sym
->name
; sym
++)
3038 str_hash_insert (sbit_hash
, sym
->name
, (char *) sym
);
3040 misc_symbol_hash
= str_htab_create ();
3041 for (symname
= (char **) misc_symbols
; *symname
; symname
++)
3042 str_hash_insert (misc_symbol_hash
, *symname
, *symname
);
3044 /* Only the base substitution table and local label table are initialized;
3045 the others (for local macro substitution) get instantiated as needed. */
3046 local_label_hash
[0] = str_htab_create ();
3047 subsym_hash
[0] = str_htab_create ();
3048 for (subsym_proc
= subsym_procs
; subsym_proc
->name
; subsym_proc
++)
3049 str_hash_insert (subsym_hash
[0], subsym_proc
->name
,
3050 (char *) subsym_proc
);
3052 math_hash
= str_htab_create ();
3053 for (math_proc
= math_procs
; math_proc
->name
; math_proc
++)
3055 /* Insert into the main subsym hash for recognition; insert into
3056 the math hash to actually store information. */
3057 str_hash_insert (subsym_hash
[0], math_proc
->name
,
3058 (char *) math_proc
);
3059 str_hash_insert (math_hash
, math_proc
->name
,
3060 (char *) math_proc
);
3062 subsym_recurse_hash
= str_htab_create ();
3063 stag_hash
= str_htab_create ();
3067 is_accumulator (struct opstruct
*operand
)
3069 return strcasecmp (operand
->buf
, "a") == 0
3070 || strcasecmp (operand
->buf
, "b") == 0;
3073 /* Return the number of operands found, or -1 on error, copying the
3074 operands into the given array and the accompanying expressions into
3078 get_operands (struct opstruct operands
[], char *line
)
3082 int expecting_operand
= 0;
3085 while (numexp
< MAX_OPERANDS
&& !is_end_of_line
[(unsigned char) *lptr
])
3087 int paren_not_balanced
= 0;
3088 char *op_start
, *op_end
;
3090 while (*lptr
&& ISSPACE (*lptr
))
3093 while (paren_not_balanced
|| *lptr
!= ',')
3097 if (paren_not_balanced
)
3099 as_bad (_("Unbalanced parenthesis in operand %d"), numexp
);
3106 ++paren_not_balanced
;
3107 else if (*lptr
== ')')
3108 --paren_not_balanced
;
3112 if (op_end
!= op_start
)
3114 int len
= op_end
- op_start
;
3116 strncpy (operands
[numexp
].buf
, op_start
, len
);
3117 operands
[numexp
].buf
[len
] = 0;
3118 /* Trim trailing spaces; while the preprocessor gets rid of most,
3119 there are weird usage patterns that can introduce them
3120 (i.e. using strings for macro args). */
3121 while (len
> 0 && ISSPACE (operands
[numexp
].buf
[len
- 1]))
3122 operands
[numexp
].buf
[--len
] = 0;
3128 if (expecting_operand
|| *lptr
== ',')
3130 as_bad (_("Expecting operand after ','"));
3136 if (*++lptr
== '\0')
3138 as_bad (_("Expecting operand after ','"));
3141 expecting_operand
= 1;
3145 while (*lptr
&& ISSPACE (*lptr
++))
3147 if (!is_end_of_line
[(unsigned char) *lptr
])
3149 as_bad (_("Extra junk on line"));
3153 /* OK, now parse them into expressions. */
3154 for (i
= 0; i
< numexp
; i
++)
3156 memset (&operands
[i
].exp
, 0, sizeof (operands
[i
].exp
));
3157 if (operands
[i
].buf
[0] == '#')
3160 parse_expression (operands
[i
].buf
+ 1, &operands
[i
].exp
);
3162 else if (operands
[i
].buf
[0] == '@')
3164 /* Direct notation. */
3165 parse_expression (operands
[i
].buf
+ 1, &operands
[i
].exp
);
3167 else if (operands
[i
].buf
[0] == '*')
3170 char *paren
= strchr (operands
[i
].buf
, '(');
3172 /* Allow immediate syntax in the inner expression. */
3173 if (paren
&& paren
[1] == '#')
3176 /* Pull out the lk expression or SP offset, if present. */
3179 int len
= strlen (paren
);
3180 char *end
= paren
+ len
;
3183 while (end
[-1] != ')')
3186 as_bad (_("Badly formed address expression"));
3191 parse_expression (paren
, &operands
[i
].exp
);
3195 operands
[i
].exp
.X_op
= O_absent
;
3198 parse_expression (operands
[i
].buf
, &operands
[i
].exp
);
3204 /* Predicates for different operand types. */
3207 is_immediate (struct opstruct
*operand
)
3209 return *operand
->buf
== '#';
3212 /* This is distinguished from immediate because some numbers must be constants
3213 and must *not* have the '#' prefix. */
3216 is_absolute (struct opstruct
*operand
)
3218 return operand
->exp
.X_op
== O_constant
&& !is_immediate (operand
);
3221 /* Is this an indirect operand? */
3224 is_indirect (struct opstruct
*operand
)
3226 return operand
->buf
[0] == '*';
3229 /* Is this a valid dual-memory operand? */
3232 is_dual (struct opstruct
*operand
)
3234 if (is_indirect (operand
) && strncasecmp (operand
->buf
, "*ar", 3) == 0)
3236 char *tmp
= operand
->buf
+ 3;
3241 /* Only allow *ARx, *ARx-, *ARx+, or *ARx+0%. */
3242 valid_mod
= *tmp
== '\0' ||
3243 strcasecmp (tmp
, "-") == 0 ||
3244 strcasecmp (tmp
, "+") == 0 ||
3245 strcasecmp (tmp
, "+0%") == 0;
3246 return arf
>= 2 && arf
<= 5 && valid_mod
;
3252 is_mmreg (struct opstruct
*operand
)
3254 return (is_absolute (operand
)
3255 || is_immediate (operand
)
3256 || str_hash_find (mmreg_hash
, operand
->buf
) != 0);
3260 is_type (struct opstruct
*operand
, enum optype type
)
3265 return operand
->buf
[0] == 0;
3268 return is_dual (operand
);
3270 return is_indirect (operand
);
3272 /* This one *must* be immediate. */
3273 return is_immediate (operand
);
3282 /* Address may be a numeric, indirect, or an expression. */
3283 return !is_immediate (operand
);
3286 return is_mmreg (operand
);
3291 return is_accumulator (operand
);
3293 return is_accumulator (operand
) && TOUPPER (operand
->buf
[0]) == 'B';
3295 return is_accumulator (operand
) && TOUPPER (operand
->buf
[0]) == 'A';
3297 return strncasecmp ("ar", operand
->buf
, 2) == 0
3298 && ISDIGIT (operand
->buf
[2]);
3300 return str_hash_find (sbit_hash
, operand
->buf
) != 0 || is_absolute (operand
);
3302 return str_hash_find (cc_hash
, operand
->buf
) != 0;
3304 return str_hash_find (cc2_hash
, operand
->buf
) != 0;
3306 return str_hash_find (cc3_hash
, operand
->buf
) != 0
3307 || is_immediate (operand
) || is_absolute (operand
);
3309 return (is_immediate (operand
) || is_absolute (operand
))
3310 && operand
->exp
.X_add_number
== 16;
3312 /* Allow st0 or st1 instead of a numeric. */
3313 return is_absolute (operand
) || is_immediate (operand
) ||
3314 strcasecmp ("st0", operand
->buf
) == 0 ||
3315 strcasecmp ("st1", operand
->buf
) == 0;
3318 return is_absolute (operand
) || is_immediate (operand
);
3320 return (is_immediate (operand
) || is_absolute (operand
))
3321 && operand
->exp
.X_add_number
>= 0 && operand
->exp
.X_add_number
< 16;
3323 /* Let this one catch out-of-range values. */
3324 return (is_immediate (operand
) || is_absolute (operand
))
3325 && operand
->exp
.X_add_number
!= 16;
3329 return is_absolute (operand
) || is_immediate (operand
);
3331 return is_immediate (operand
)
3332 && operand
->exp
.X_op
== O_constant
3333 && operand
->exp
.X_add_number
>= 0
3334 && operand
->exp
.X_add_number
< 256;
3337 /* Allow anything; assumes opcodes are ordered with Smem operands
3343 /* Just make sure it's an integer; check range later. */
3344 return is_immediate (operand
);
3346 return strcasecmp ("t", operand
->buf
) == 0 ||
3347 strcasecmp ("treg", operand
->buf
) == 0;
3349 return strcasecmp ("ts", operand
->buf
) == 0;
3351 return strcasecmp ("asm", operand
->buf
) == 0;
3353 return strcasecmp ("trn", operand
->buf
) == 0;
3355 return strcasecmp ("dp", operand
->buf
) == 0;
3357 return strcasecmp ("arp", operand
->buf
) == 0;
3364 operands_match (tic54x_insn
*insn
,
3365 struct opstruct
*operands
,
3367 const enum optype
*refoptype
,
3371 int op
= 0, refop
= 0;
3373 if (opcount
== 0 && minops
== 0)
3376 while (op
<= maxops
&& refop
<= maxops
)
3378 while (!is_type (&operands
[op
], OPTYPE (refoptype
[refop
])))
3380 /* Skip an optional template operand if it doesn't agree
3381 with the current operand. */
3382 if (refoptype
[refop
] & OPT
)
3393 /* Save the actual operand type for later use. */
3394 operands
[op
].type
= OPTYPE (refoptype
[refop
]);
3397 /* Have we matched them all yet? */
3402 /* If a later operand is *not* optional, no match. */
3403 if ((refoptype
[refop
] & OPT
) == 0)
3405 /* Flag any implicit default OP_DST operands so we know to add
3406 them explicitly when encoding the operand later. */
3407 if (OPTYPE (refoptype
[refop
]) == OP_DST
)
3408 insn
->using_default_dst
= 1;
3420 /* 16-bit direct memory address
3421 Explicit dmad operands are always in last word of insn (usually second
3422 word, but bumped to third if lk addressing is used)
3424 We allow *(dmad) notation because the TI assembler allows it.
3427 0 for 16-bit addresses
3428 1 for full 23-bit addresses
3429 2 for the upper 7 bits of a 23-bit address (LDX). */
3432 encode_dmad (tic54x_insn
*insn
, struct opstruct
*operand
, int xpc_code
)
3434 int op
= 1 + insn
->is_lkaddr
;
3436 /* Only allow *(dmad) expressions; all others are invalid. */
3437 if (is_indirect (operand
) && operand
->buf
[strlen (operand
->buf
) - 1] != ')')
3439 as_bad (_("Invalid dmad syntax '%s'"), operand
->buf
);
3443 insn
->opcode
[op
].addr_expr
= operand
->exp
;
3445 if (insn
->opcode
[op
].addr_expr
.X_op
== O_constant
)
3447 valueT value
= insn
->opcode
[op
].addr_expr
.X_add_number
;
3451 insn
->opcode
[0].word
&= 0xFF80;
3452 insn
->opcode
[0].word
|= (value
>> 16) & 0x7F;
3453 insn
->opcode
[1].word
= value
& 0xFFFF;
3455 else if (xpc_code
== 2)
3456 insn
->opcode
[op
].word
= (value
>> 16) & 0xFFFF;
3458 insn
->opcode
[op
].word
= value
;
3462 /* Do the fixup later; just store the expression. */
3463 insn
->opcode
[op
].word
= 0;
3464 insn
->opcode
[op
].r_nchars
= 2;
3466 if (amode
== c_mode
)
3467 insn
->opcode
[op
].r_type
= BFD_RELOC_TIC54X_16_OF_23
;
3468 else if (xpc_code
== 1)
3470 /* This relocation spans two words, so adjust accordingly. */
3471 insn
->opcode
[0].addr_expr
= operand
->exp
;
3472 insn
->opcode
[0].r_type
= BFD_RELOC_TIC54X_23
;
3473 insn
->opcode
[0].r_nchars
= 4;
3474 insn
->opcode
[0].unresolved
= 1;
3475 /* It's really 2 words, but we want to stop encoding after the
3476 first, since we must encode both words at once. */
3479 else if (xpc_code
== 2)
3480 insn
->opcode
[op
].r_type
= BFD_RELOC_TIC54X_MS7_OF_23
;
3482 insn
->opcode
[op
].r_type
= BFD_RELOC_TIC54X_16_OF_23
;
3484 insn
->opcode
[op
].unresolved
= 1;
3490 /* 7-bit direct address encoding. */
3493 encode_address (tic54x_insn
*insn
, struct opstruct
*operand
)
3495 /* Assumes that dma addresses are *always* in word 0 of the opcode. */
3496 insn
->opcode
[0].addr_expr
= operand
->exp
;
3498 if (operand
->exp
.X_op
== O_constant
)
3499 insn
->opcode
[0].word
|= (operand
->exp
.X_add_number
& 0x7F);
3502 if (operand
->exp
.X_op
== O_register
)
3503 as_bad (_("Use the .mmregs directive to use memory-mapped register names such as '%s'"), operand
->buf
);
3504 /* Do the fixup later; just store the expression. */
3505 insn
->opcode
[0].r_nchars
= 1;
3506 insn
->opcode
[0].r_type
= BFD_RELOC_TIC54X_PARTLS7
;
3507 insn
->opcode
[0].unresolved
= 1;
3514 encode_indirect (tic54x_insn
*insn
, struct opstruct
*operand
)
3519 if (insn
->is_lkaddr
)
3521 /* lk addresses always go in the second insn word. */
3522 mod
= ((TOUPPER (operand
->buf
[1]) == 'A') ? 12 :
3523 (operand
->buf
[1] == '(') ? 15 :
3524 (strchr (operand
->buf
, '%') != NULL
) ? 14 : 13);
3525 arf
= ((mod
== 12) ? operand
->buf
[3] - '0' :
3526 (mod
== 15) ? 0 : operand
->buf
[4] - '0');
3528 insn
->opcode
[1].addr_expr
= operand
->exp
;
3530 if (operand
->exp
.X_op
== O_constant
)
3531 insn
->opcode
[1].word
= operand
->exp
.X_add_number
;
3534 insn
->opcode
[1].word
= 0;
3535 insn
->opcode
[1].r_nchars
= 2;
3536 insn
->opcode
[1].r_type
= BFD_RELOC_TIC54X_16_OF_23
;
3537 insn
->opcode
[1].unresolved
= 1;
3540 else if (strncasecmp (operand
->buf
, "*sp (", 4) == 0)
3542 /* Stack offsets look the same as 7-bit direct addressing. */
3543 return encode_address (insn
, operand
);
3547 arf
= (TOUPPER (operand
->buf
[1]) == 'A' ?
3548 operand
->buf
[3] : operand
->buf
[4]) - '0';
3550 if (operand
->buf
[1] == '+')
3552 mod
= 3; /* *+ARx */
3553 if (insn
->tm
->flags
& FL_SMR
)
3554 as_warn (_("Address mode *+ARx is write-only. "
3555 "Results of reading are undefined."));
3557 else if (operand
->buf
[4] == '\0')
3559 else if (operand
->buf
[5] == '\0')
3560 mod
= (operand
->buf
[4] == '-' ? 1 : 2); /* *ARx+ / *ARx- */
3561 else if (operand
->buf
[6] == '\0')
3563 if (operand
->buf
[5] == '0')
3564 mod
= (operand
->buf
[4] == '-' ? 5 : 6); /* *ARx+0 / *ARx-0 */
3566 mod
= (operand
->buf
[4] == '-' ? 8 : 10);/* *ARx+% / *ARx-% */
3568 else if (TOUPPER (operand
->buf
[6]) == 'B')
3569 mod
= (operand
->buf
[4] == '-' ? 4 : 7); /* ARx+0B / *ARx-0B */
3570 else if (TOUPPER (operand
->buf
[6]) == '%')
3571 mod
= (operand
->buf
[4] == '-' ? 9 : 11); /* ARx+0% / *ARx - 0% */
3574 as_bad (_("Unrecognized indirect address format \"%s\""),
3580 insn
->opcode
[0].word
|= 0x80 | (mod
<< 3) | arf
;
3586 encode_integer (tic54x_insn
*insn
,
3587 struct opstruct
*operand
,
3591 unsigned short mask
)
3593 long parse
, integer
;
3595 insn
->opcode
[which
].addr_expr
= operand
->exp
;
3597 if (operand
->exp
.X_op
== O_constant
)
3599 parse
= operand
->exp
.X_add_number
;
3600 /* Hack -- fixup for 16-bit hex quantities that get converted positive
3601 instead of negative. */
3602 if ((parse
& 0x8000) && min
== -32768 && max
== 32767)
3603 integer
= (short) parse
;
3607 if (integer
>= min
&& integer
<= max
)
3609 insn
->opcode
[which
].word
|= (integer
& mask
);
3612 as_bad (_("Operand '%s' out of range (%d <= x <= %d)"),
3613 operand
->buf
, min
, max
);
3617 if (insn
->opcode
[which
].addr_expr
.X_op
== O_constant
)
3619 insn
->opcode
[which
].word
|=
3620 insn
->opcode
[which
].addr_expr
.X_add_number
& mask
;
3624 /* Do the fixup later; just store the expression. */
3625 bfd_reloc_code_real_type rtype
=
3626 (mask
== 0x1FF ? BFD_RELOC_TIC54X_PARTMS9
:
3627 mask
== 0xFFFF ? BFD_RELOC_TIC54X_16_OF_23
:
3628 mask
== 0x7F ? BFD_RELOC_TIC54X_PARTLS7
: BFD_RELOC_8
);
3629 int size
= (mask
== 0x1FF || mask
== 0xFFFF) ? 2 : 1;
3631 if (rtype
== BFD_RELOC_8
)
3632 as_bad (_("Error in relocation handling"));
3634 insn
->opcode
[which
].r_nchars
= size
;
3635 insn
->opcode
[which
].r_type
= rtype
;
3636 insn
->opcode
[which
].unresolved
= 1;
3646 encode_condition (tic54x_insn
*insn
, struct opstruct
*operand
)
3648 tic54x_symbol
*cc
= (tic54x_symbol
*) str_hash_find (cc_hash
, operand
->buf
);
3651 as_bad (_("Unrecognized condition code \"%s\""), operand
->buf
);
3654 #define CC_GROUP 0x40
3656 #define CATG_A1 0x07
3657 #define CATG_B1 0x30
3658 #define CATG_A2 0x30
3659 #define CATG_B2 0x0C
3660 #define CATG_C2 0x03
3661 /* Disallow group 1 conditions mixed with group 2 conditions
3662 if group 1, allow only one category A and one category B
3663 if group 2, allow only one each of category A, B, and C. */
3664 if (((insn
->opcode
[0].word
& 0xFF) != 0))
3666 if ((insn
->opcode
[0].word
& CC_GROUP
) != (cc
->value
& CC_GROUP
))
3668 as_bad (_("Condition \"%s\" does not match preceding group"),
3672 if (insn
->opcode
[0].word
& CC_GROUP
)
3674 if ((insn
->opcode
[0].word
& CC_ACC
) != (cc
->value
& CC_ACC
))
3676 as_bad (_("Condition \"%s\" uses a different accumulator from "
3677 "a preceding condition"),
3681 if ((insn
->opcode
[0].word
& CATG_A1
) && (cc
->value
& CATG_A1
))
3683 as_bad (_("Only one comparison conditional allowed"));
3686 if ((insn
->opcode
[0].word
& CATG_B1
) && (cc
->value
& CATG_B1
))
3688 as_bad (_("Only one overflow conditional allowed"));
3692 else if ( ((insn
->opcode
[0].word
& CATG_A2
) && (cc
->value
& CATG_A2
))
3693 || ((insn
->opcode
[0].word
& CATG_B2
) && (cc
->value
& CATG_B2
))
3694 || ((insn
->opcode
[0].word
& CATG_C2
) && (cc
->value
& CATG_C2
)))
3696 as_bad (_("Duplicate %s conditional"), operand
->buf
);
3701 insn
->opcode
[0].word
|= cc
->value
;
3706 encode_cc3 (tic54x_insn
*insn
, struct opstruct
*operand
)
3708 tic54x_symbol
*cc3
= (tic54x_symbol
*) str_hash_find (cc3_hash
, operand
->buf
);
3709 int value
= cc3
? cc3
->value
: operand
->exp
.X_add_number
<< 8;
3711 if ((value
& 0x0300) != value
)
3713 as_bad (_("Unrecognized condition code \"%s\""), operand
->buf
);
3716 insn
->opcode
[0].word
|= value
;
3721 encode_arx (tic54x_insn
*insn
, struct opstruct
*operand
)
3723 int arf
= strlen (operand
->buf
) >= 3 ? operand
->buf
[2] - '0' : -1;
3725 if (strncasecmp ("ar", operand
->buf
, 2) || arf
< 0 || arf
> 7)
3727 as_bad (_("Invalid auxiliary register (use AR0-AR7)"));
3730 insn
->opcode
[0].word
|= arf
;
3735 encode_cc2 (tic54x_insn
*insn
, struct opstruct
*operand
)
3737 tic54x_symbol
*cc2
= (tic54x_symbol
*) str_hash_find (cc2_hash
, operand
->buf
);
3741 as_bad (_("Unrecognized condition code \"%s\""), operand
->buf
);
3744 insn
->opcode
[0].word
|= cc2
->value
;
3749 encode_operand (tic54x_insn
*insn
, enum optype type
, struct opstruct
*operand
)
3751 int ext
= (insn
->tm
->flags
& FL_EXT
) != 0;
3753 if (type
== OP_MMR
&& operand
->exp
.X_op
!= O_constant
)
3755 /* Disallow long-constant addressing for memory-mapped addressing. */
3756 if (insn
->is_lkaddr
)
3758 as_bad (_("lk addressing modes are invalid for memory-mapped "
3759 "register addressing"));
3763 /* Warn about *+ARx when used with MMR operands. */
3764 if (strncasecmp (operand
->buf
, "*+ar", 4) == 0)
3766 as_warn (_("Address mode *+ARx is not allowed in memory-mapped "
3767 "register addressing. Resulting behavior is "
3777 /* 16-bit immediate value. */
3778 return encode_dmad (insn
, operand
, 0);
3780 if (TOUPPER (*operand
->buf
) == 'B')
3782 insn
->opcode
[ext
? (1 + insn
->is_lkaddr
) : 0].word
|= (1 << 9);
3783 if (insn
->using_default_dst
)
3784 insn
->opcode
[ext
? (1 + insn
->is_lkaddr
) : 0].word
|= (1 << 8);
3788 /* Make sure this agrees with the OP_DST operand. */
3789 if (!((TOUPPER (operand
->buf
[0]) == 'B') ^
3790 ((insn
->opcode
[0].word
& (1 << 8)) != 0)))
3792 as_bad (_("Destination accumulator for each part of this parallel "
3793 "instruction must be different"));
3799 if (TOUPPER (operand
->buf
[0]) == 'B')
3800 insn
->opcode
[ext
? (1 + insn
->is_lkaddr
) : 0].word
|= (1 << 8);
3805 int mod
= (operand
->buf
[4] == '\0' ? 0 : /* *arx */
3806 operand
->buf
[4] == '-' ? 1 : /* *arx- */
3807 operand
->buf
[5] == '\0' ? 2 : 3); /* *arx+, *arx+0% */
3808 int arf
= operand
->buf
[3] - '0' - 2;
3809 int code
= (mod
<< 2) | arf
;
3810 insn
->opcode
[0].word
|= (code
<< (type
== OP_Xmem
? 4 : 0));
3815 if (!is_indirect (operand
))
3816 return encode_address (insn
, operand
);
3819 return encode_indirect (insn
, operand
);
3821 return encode_dmad (insn
, operand
, 2);
3823 return encode_dmad (insn
, operand
, 1);
3826 return encode_dmad (insn
, operand
, 0);
3828 return encode_arx (insn
, operand
);
3833 int value
= operand
->exp
.X_add_number
;
3836 insn
->opcode
[0].word
|= value
;
3839 if (value
< 16 || value
> 24)
3841 as_bad (_("Memory mapped register \"%s\" out of range"),
3845 if (type
== OP_MMRX
)
3846 insn
->opcode
[0].word
|= (value
- 16) << 4;
3848 insn
->opcode
[0].word
|= (value
- 16);
3856 return encode_integer (insn
, operand
, ext
+ insn
->is_lkaddr
,
3859 return encode_integer (insn
, operand
, ext
+ insn
->is_lkaddr
,
3862 return encode_integer (insn
, operand
, 1 + insn
->is_lkaddr
,
3863 -32768, 32767, 0xFFFF);
3865 return encode_condition (insn
, operand
);
3867 return encode_cc2 (insn
, operand
);
3869 return encode_cc3 (insn
, operand
);
3871 return encode_integer (insn
, operand
, 0, 0, 15, 0xF);
3873 return encode_integer (insn
, operand
, 0, -128, 127, 0xFF);
3876 int value
= operand
->exp
.X_add_number
;
3878 if (value
< 1 || value
> 3)
3880 as_bad (_("Invalid operand (use 1, 2, or 3)"));
3883 code
= value
== 1 ? 0 : value
== 2 ? 0x2 : 0x1;
3884 insn
->opcode
[0].word
|= (code
<< 8);
3888 return encode_integer (insn
, operand
, 0, 0, 31, 0x1F);
3890 return encode_integer (insn
, operand
, 0, 0, 255, 0xFF);
3892 return encode_integer (insn
, operand
, 1 + insn
->is_lkaddr
,
3896 tic54x_symbol
*sbit
= (tic54x_symbol
*)
3897 str_hash_find (sbit_hash
, operand
->buf
);
3898 int value
= is_absolute (operand
) ?
3899 operand
->exp
.X_add_number
: (sbit
? sbit
->value
: -1);
3902 if (insn
->opcount
== 1)
3906 as_bad (_("A status register or status bit name is required"));
3909 /* Guess the register based on the status bit; "ovb" is the last
3910 status bit defined for st0. */
3911 if (sbit
> (tic54x_symbol
*) str_hash_find (sbit_hash
, "ovb"))
3916 as_bad (_("Unrecognized status bit \"%s\""), operand
->buf
);
3919 insn
->opcode
[0].word
|= value
;
3920 insn
->opcode
[0].word
|= (reg
<< 9);
3924 if (strcasecmp (operand
->buf
, "st0") == 0
3925 || strcasecmp (operand
->buf
, "st1") == 0)
3927 insn
->opcode
[0].word
|=
3928 ((unsigned short) (operand
->buf
[2] - '0')) << 9;
3931 else if (operand
->exp
.X_op
== O_constant
3932 && (operand
->exp
.X_add_number
== 0
3933 || operand
->exp
.X_add_number
== 1))
3935 insn
->opcode
[0].word
|=
3936 ((unsigned short) (operand
->exp
.X_add_number
)) << 9;
3939 as_bad (_("Invalid status register \"%s\""), operand
->buf
);
3942 return encode_integer (insn
, operand
, 0, -16, 15, 0x1F);
3944 return encode_integer (insn
, operand
, 0, 0, 7, 0x7);
3946 return encode_integer (insn
, operand
, 0, 0, 0x1FF, 0x1FF);
3948 if (operand
->exp
.X_add_number
!= 1
3949 && operand
->exp
.X_add_number
!= 2)
3951 as_bad (_("Operand \"%s\" out of range (use 1 or 2)"), operand
->buf
);
3954 insn
->opcode
[0].word
|= (operand
->exp
.X_add_number
- 1) << 9;
3963 /* No encoding necessary. */
3973 emit_insn (tic54x_insn
*insn
)
3976 flagword oldflags
= bfd_section_flags (now_seg
);
3977 flagword flags
= oldflags
| SEC_CODE
;
3979 if (!bfd_set_section_flags (now_seg
, flags
))
3980 as_warn (_("error setting flags for \"%s\": %s"),
3981 bfd_section_name (now_seg
),
3982 bfd_errmsg (bfd_get_error ()));
3984 for (i
= 0; i
< insn
->words
; i
++)
3986 int size
= (insn
->opcode
[i
].unresolved
3987 && insn
->opcode
[i
].r_type
== BFD_RELOC_TIC54X_23
) ? 4 : 2;
3988 char *p
= frag_more (size
);
3991 md_number_to_chars (p
, (valueT
) insn
->opcode
[i
].word
, 2);
3993 md_number_to_chars (p
, (valueT
) insn
->opcode
[i
].word
<< 16, 4);
3995 if (insn
->opcode
[i
].unresolved
)
3996 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
,
3997 insn
->opcode
[i
].r_nchars
, &insn
->opcode
[i
].addr_expr
,
3998 FALSE
, insn
->opcode
[i
].r_type
);
4002 /* Convert the operand strings into appropriate opcode values
4003 return the total number of words used by the instruction. */
4006 build_insn (tic54x_insn
*insn
)
4010 /* Only non-parallel instructions support lk addressing. */
4011 if (!(insn
->tm
->flags
& FL_PAR
))
4013 for (i
= 0; i
< insn
->opcount
; i
++)
4015 if ((OPTYPE (insn
->operands
[i
].type
) == OP_Smem
4016 || OPTYPE (insn
->operands
[i
].type
) == OP_Lmem
4017 || OPTYPE (insn
->operands
[i
].type
) == OP_Sind
)
4018 && strchr (insn
->operands
[i
].buf
, '(')
4019 /* Don't mistake stack-relative addressing for lk addressing. */
4020 && strncasecmp (insn
->operands
[i
].buf
, "*sp (", 4) != 0)
4022 insn
->is_lkaddr
= 1;
4023 insn
->lkoperand
= i
;
4028 insn
->words
= insn
->tm
->words
+ insn
->is_lkaddr
;
4030 insn
->opcode
[0].word
= insn
->tm
->opcode
;
4031 if (insn
->tm
->flags
& FL_EXT
)
4032 insn
->opcode
[1 + insn
->is_lkaddr
].word
= insn
->tm
->opcode2
;
4034 for (i
= 0; i
< insn
->opcount
; i
++)
4036 enum optype type
= insn
->operands
[i
].type
;
4038 if (!encode_operand (insn
, type
, &insn
->operands
[i
]))
4041 if (insn
->tm
->flags
& FL_PAR
)
4042 for (i
= 0; i
< insn
->paropcount
; i
++)
4044 enum optype partype
= insn
->paroperands
[i
].type
;
4046 if (!encode_operand (insn
, partype
, &insn
->paroperands
[i
]))
4056 optimize_insn (tic54x_insn
*insn
)
4058 /* Optimize some instructions, helping out the brain-dead programmer. */
4059 #define is_zero(op) ((op).exp.X_op == O_constant && (op).exp.X_add_number == 0)
4060 if (strcasecmp (insn
->tm
->name
, "add") == 0)
4062 if (insn
->opcount
> 1
4063 && is_accumulator (&insn
->operands
[insn
->opcount
- 2])
4064 && is_accumulator (&insn
->operands
[insn
->opcount
- 1])
4065 && strcasecmp (insn
->operands
[insn
->opcount
- 2].buf
,
4066 insn
->operands
[insn
->opcount
- 1].buf
) == 0)
4069 insn
->using_default_dst
= 1;
4073 /* Try to collapse if Xmem and shift count is zero. */
4074 if ((OPTYPE (insn
->tm
->operand_types
[0]) == OP_Xmem
4075 && OPTYPE (insn
->tm
->operand_types
[1]) == OP_SHFT
4076 && is_zero (insn
->operands
[1]))
4077 /* Or if Smem, shift is zero or absent, and SRC == DST. */
4078 || (OPTYPE (insn
->tm
->operand_types
[0]) == OP_Smem
4079 && OPTYPE (insn
->tm
->operand_types
[1]) == OP_SHIFT
4080 && is_type (&insn
->operands
[1], OP_SHIFT
)
4081 && is_zero (insn
->operands
[1]) && insn
->opcount
== 3))
4083 insn
->operands
[1] = insn
->operands
[2];
4088 else if (strcasecmp (insn
->tm
->name
, "ld") == 0)
4090 if (insn
->opcount
== 3 && insn
->operands
[0].type
!= OP_SRC
)
4092 if ((OPTYPE (insn
->tm
->operand_types
[1]) == OP_SHIFT
4093 || OPTYPE (insn
->tm
->operand_types
[1]) == OP_SHFT
)
4094 && is_zero (insn
->operands
[1])
4095 && (OPTYPE (insn
->tm
->operand_types
[0]) != OP_lk
4096 || (insn
->operands
[0].exp
.X_op
== O_constant
4097 && insn
->operands
[0].exp
.X_add_number
<= 255
4098 && insn
->operands
[0].exp
.X_add_number
>= 0)))
4100 insn
->operands
[1] = insn
->operands
[2];
4106 else if (strcasecmp (insn
->tm
->name
, "sth") == 0
4107 || strcasecmp (insn
->tm
->name
, "stl") == 0)
4109 if ((OPTYPE (insn
->tm
->operand_types
[1]) == OP_SHIFT
4110 || OPTYPE (insn
->tm
->operand_types
[1]) == OP_SHFT
)
4111 && is_zero (insn
->operands
[1]))
4113 insn
->operands
[1] = insn
->operands
[2];
4118 else if (strcasecmp (insn
->tm
->name
, "sub") == 0)
4120 if (insn
->opcount
> 1
4121 && is_accumulator (&insn
->operands
[insn
->opcount
- 2])
4122 && is_accumulator (&insn
->operands
[insn
->opcount
- 1])
4123 && strcasecmp (insn
->operands
[insn
->opcount
- 2].buf
,
4124 insn
->operands
[insn
->opcount
- 1].buf
) == 0)
4127 insn
->using_default_dst
= 1;
4131 if ( ((OPTYPE (insn
->tm
->operand_types
[0]) == OP_Smem
4132 && OPTYPE (insn
->tm
->operand_types
[1]) == OP_SHIFT
)
4133 || (OPTYPE (insn
->tm
->operand_types
[0]) == OP_Xmem
4134 && OPTYPE (insn
->tm
->operand_types
[1]) == OP_SHFT
))
4135 && is_zero (insn
->operands
[1])
4136 && insn
->opcount
== 3)
4138 insn
->operands
[1] = insn
->operands
[2];
4146 /* Find a matching template if possible, and get the operand strings. */
4149 tic54x_parse_insn (tic54x_insn
*insn
, char *line
)
4151 insn
->tm
= (insn_template
*) str_hash_find (op_hash
, insn
->mnemonic
);
4154 as_bad (_("Unrecognized instruction \"%s\""), insn
->mnemonic
);
4158 insn
->opcount
= get_operands (insn
->operands
, line
);
4159 if (insn
->opcount
< 0)
4162 /* Check each variation of operands for this mnemonic. */
4163 while (insn
->tm
->name
&& strcasecmp (insn
->tm
->name
, insn
->mnemonic
) == 0)
4165 if (insn
->opcount
>= insn
->tm
->minops
4166 && insn
->opcount
<= insn
->tm
->maxops
4167 && operands_match (insn
, &insn
->operands
[0], insn
->opcount
,
4168 insn
->tm
->operand_types
,
4169 insn
->tm
->minops
, insn
->tm
->maxops
))
4171 /* SUCCESS! now try some optimizations. */
4172 if (optimize_insn (insn
))
4174 insn
->tm
= (insn_template
*) str_hash_find (op_hash
,
4183 as_bad (_("Unrecognized operand list '%s' for instruction '%s'"),
4184 line
, insn
->mnemonic
);
4188 /* We set this in start_line_hook, 'cause if we do a line replacement, we
4189 won't be able to see the next line. */
4190 static int parallel_on_next_line_hint
= 0;
4192 /* See if this is part of a parallel instruction
4193 Look for a subsequent line starting with "||". */
4196 next_line_shows_parallel (char *next_line
)
4198 /* Look for the second half. */
4199 while (*next_line
!= 0 && ISSPACE (*next_line
))
4202 return (next_line
[0] == PARALLEL_SEPARATOR
4203 && next_line
[1] == PARALLEL_SEPARATOR
);
4207 tic54x_parse_parallel_insn_firstline (tic54x_insn
*insn
, char *line
)
4209 insn
->tm
= (insn_template
*) str_hash_find (parop_hash
, insn
->mnemonic
);
4212 as_bad (_("Unrecognized parallel instruction \"%s\""),
4217 while (insn
->tm
->name
&& strcasecmp (insn
->tm
->name
,
4218 insn
->mnemonic
) == 0)
4220 insn
->opcount
= get_operands (insn
->operands
, line
);
4221 if (insn
->opcount
< 0)
4223 if (insn
->opcount
== 2
4224 && operands_match (insn
, &insn
->operands
[0], insn
->opcount
,
4225 insn
->tm
->operand_types
, 2, 2))
4231 /* Didn't find a matching parallel; try for a normal insn. */
4235 /* Parse the second line of a two-line parallel instruction. */
4238 tic54x_parse_parallel_insn_lastline (tic54x_insn
*insn
, char *line
)
4240 int valid_mnemonic
= 0;
4242 insn
->paropcount
= get_operands (insn
->paroperands
, line
);
4243 while (insn
->tm
->name
&& strcasecmp (insn
->tm
->name
,
4244 insn
->mnemonic
) == 0)
4246 if (strcasecmp (insn
->tm
->parname
, insn
->parmnemonic
) == 0)
4250 if (insn
->paropcount
>= insn
->tm
->minops
4251 && insn
->paropcount
<= insn
->tm
->maxops
4252 && operands_match (insn
, insn
->paroperands
,
4254 insn
->tm
->paroperand_types
,
4255 insn
->tm
->minops
, insn
->tm
->maxops
))
4261 as_bad (_("Invalid operand (s) for parallel instruction \"%s\""),
4264 as_bad (_("Unrecognized parallel instruction combination \"%s || %s\""),
4265 insn
->mnemonic
, insn
->parmnemonic
);
4270 /* If quotes found, return copy of line up to closing quote;
4271 otherwise up until terminator.
4272 If it's a string, pass as-is; otherwise attempt substitution symbol
4273 replacement on the value. */
4276 subsym_get_arg (char *line
, const char *terminators
, char **str
, int nosub
)
4280 int is_string
= *line
== '"';
4281 int is_char
= ISDIGIT (*line
);
4285 while (ISDIGIT (*ptr
))
4288 *str
= xmemdup0 (line
, ptr
- line
);
4292 char *savedp
= input_line_pointer
;
4295 input_line_pointer
= ptr
;
4296 *str
= demand_copy_C_string (&len
);
4297 endp
= input_line_pointer
;
4298 input_line_pointer
= savedp
;
4300 /* Do forced substitutions if requested. */
4301 if (!nosub
&& **str
== ':')
4302 *str
= subsym_substitute (*str
, 1);
4306 const char *term
= terminators
;
4309 while (*ptr
&& *ptr
!= *term
)
4320 *str
= xmemdup0 (line
, ptr
- line
);
4321 /* Do simple substitution, if available. */
4322 if (!nosub
&& (value
= subsym_lookup (*str
, macro_level
)) != NULL
)
4329 /* Replace the given substitution string.
4330 We start at the innermost macro level, so that existing locals remain local
4331 Note: we're treating macro args identically to .var's; I don't know if
4332 that's compatible w/TI's assembler. */
4335 subsym_create_or_replace (char *name
, char *value
)
4339 for (i
= macro_level
; i
> 0; i
--)
4340 str_hash_insert (subsym_hash
[i
], name
, value
);
4341 str_hash_insert (subsym_hash
[0], name
, value
);
4344 /* Look up the substitution string replacement for the given symbol.
4345 Start with the innermost macro substitution table given and work
4349 subsym_lookup (char *name
, int nest_level
)
4351 char *value
= str_hash_find (subsym_hash
[nest_level
], name
);
4353 if (value
|| nest_level
== 0)
4356 return subsym_lookup (name
, nest_level
- 1);
4359 /* Do substitution-symbol replacement on the given line (recursively).
4360 return the argument if no substitution was done
4362 Also look for built-in functions ($func (arg)) and local labels.
4364 If FORCED is set, look for forced substitutions of the form ':SYMBOL:'. */
4367 subsym_substitute (char *line
, int forced
)
4369 /* For each apparent symbol, see if it's a substitution symbol, and if so,
4370 replace it in the input. */
4371 char *replacement
; /* current replacement for LINE. */
4372 char *head
; /* Start of line. */
4373 char *ptr
; /* Current examination point. */
4374 int changed
= 0; /* Did we make a substitution? */
4375 int eval_line
= 0; /* Is this line a .eval/.asg statement? */
4376 int eval_symbol
= 0; /* Are we in the middle of the symbol for
4378 char *eval_end
= NULL
;
4380 int line_conditional
= 0;
4383 /* Work with a copy of the input line. */
4384 replacement
= xstrdup (line
);
4386 ptr
= head
= replacement
;
4388 /* Flag lines where we might need to replace a single '=' with two;
4389 GAS uses single '=' to assign macro args values, and possibly other
4390 places, so limit what we replace. */
4391 if (strstr (line
, ".if")
4392 || strstr (line
, ".elseif")
4393 || strstr (line
, ".break"))
4394 line_conditional
= 1;
4396 /* Watch out for .eval, so that we avoid doing substitution on the
4397 symbol being assigned a value. */
4398 if (strstr (line
, ".eval") || strstr (line
, ".asg"))
4401 /* If it's a macro definition, don't do substitution on the argument
4403 if (strstr (line
, ".macro"))
4406 unsigned char current_char
;
4407 while (!is_end_of_line
[(current_char
= * (unsigned char *) ptr
)])
4409 /* Need to update this since LINE may have been modified. */
4411 eval_end
= strrchr (ptr
, ',');
4413 /* Replace triple double quotes with bounding quote/escapes. */
4414 if (current_char
== '"' && ptr
[1] == '"' && ptr
[2] == '"')
4417 tmp
= strstr (ptr
+ 2, "\"\"\"");
4423 /* Replace a single '=' with a '==';
4424 for compatibility with older code only. */
4425 if (line_conditional
&& current_char
== '=')
4433 tmp
= concat (head
, "==", ptr
, (char *) NULL
);
4434 /* Continue examining after the '=='. */
4435 ptr
= tmp
+ strlen (head
) + 2;
4437 head
= replacement
= tmp
;
4441 /* Flag when we've reached the symbol part of .eval/.asg. */
4442 if (eval_line
&& ptr
>= eval_end
)
4445 /* For each apparent symbol, see if it's a substitution symbol, and if
4446 so, replace it in the input. */
4447 if ((forced
&& current_char
== ':')
4448 || (!forced
&& is_name_beginner (current_char
)))
4450 char *name
; /* Symbol to be replaced. */
4451 char *savedp
= input_line_pointer
;
4454 char *tail
; /* Rest of line after symbol. */
4456 /* Skip the colon. */
4460 input_line_pointer
= ptr
;
4461 c
= get_symbol_name (&name
);
4462 /* '?' is not normally part of a symbol, but it IS part of a local
4466 *input_line_pointer
++ = c
;
4467 c
= *input_line_pointer
;
4468 *input_line_pointer
= '\0';
4470 /* Avoid infinite recursion; if a symbol shows up a second time for
4471 substitution, leave it as is. */
4472 if (str_hash_find (subsym_recurse_hash
, name
) == NULL
)
4473 value
= subsym_lookup (name
, macro_level
);
4475 as_warn (_("%s symbol recursion stopped at "
4476 "second appearance of '%s'"),
4477 forced
? "Forced substitution" : "Substitution", name
);
4478 ptr
= tail
= input_line_pointer
;
4479 input_line_pointer
= savedp
;
4481 /* Check for local labels; replace them with the appropriate
4483 if ((*name
== '$' && ISDIGIT (name
[1]) && name
[2] == '\0')
4484 || name
[strlen (name
) - 1] == '?')
4486 /* Use an existing identifier for that label if, available, or
4487 create a new, unique identifier. */
4488 value
= str_hash_find (local_label_hash
[macro_level
], name
);
4492 char *namecopy
= xstrdup (name
);
4494 value
= strcpy (xmalloc (strlen (name
) + sizeof (digit
) + 1),
4497 value
[strlen (value
) - 1] = '\0';
4498 sprintf (digit
, ".%d", local_label_id
++);
4499 strcat (value
, digit
);
4500 str_hash_insert (local_label_hash
[macro_level
], namecopy
, value
);
4502 /* Indicate where to continue looking for substitutions. */
4505 /* Check for built-in subsym and math functions. */
4506 else if (value
!= NULL
&& *name
== '$')
4508 subsym_proc_entry
*entry
= (subsym_proc_entry
*) value
;
4509 math_proc_entry
*math_entry
= str_hash_find (math_hash
, name
);
4510 char *arg1
, *arg2
= NULL
;
4515 as_bad (_("Unrecognized substitution symbol function"));
4518 else if (*ptr
!= '(')
4520 as_bad (_("Missing '(' after substitution symbol function"));
4524 if (math_entry
!= NULL
)
4526 float farg1
, farg2
= 0;
4527 volatile float fresult
;
4529 farg1
= (float) strtod (ptr
, &ptr
);
4530 if (math_entry
->nargs
== 2)
4534 as_bad (_("Expecting second argument"));
4537 farg2
= (float) strtod (ptr
, &ptr
);
4539 fresult
= (*math_entry
->proc
) (farg1
, farg2
);
4540 value
= XNEWVEC (char, 128);
4541 if (math_entry
->int_return
)
4542 sprintf (value
, "%d", (int) fresult
);
4544 sprintf (value
, "%f", fresult
);
4547 as_bad (_("Extra junk in function call, expecting ')'"));
4550 /* Don't bother recursing; the replacement isn't a
4557 int arg_type
[2] = { *ptr
== '"' , 0 };
4558 int ismember
= !strcmp (entry
->name
, "$ismember");
4560 /* Parse one or two args, which must be a substitution
4561 symbol, string or a character-string constant. */
4562 /* For all functions, a string or substitution symbol may be
4563 used, with the following exceptions:
4564 firstch/lastch: 2nd arg must be character constant
4565 ismember: both args must be substitution symbols. */
4566 ptr
= subsym_get_arg (ptr
, ",)", &arg1
, ismember
);
4569 if (entry
->nargs
== 2)
4573 as_bad (_("Function expects two arguments"));
4576 /* Character constants are converted to numerics
4577 by the preprocessor. */
4578 arg_type
[1] = (ISDIGIT (*ptr
)) ? 2 : (*ptr
== '"');
4579 ptr
= subsym_get_arg (ptr
, ")", &arg2
, ismember
);
4581 /* Args checking. */
4582 if ((!strcmp (entry
->name
, "$firstch")
4583 || !strcmp (entry
->name
, "$lastch"))
4584 && arg_type
[1] != 2)
4586 as_bad (_("Expecting character constant argument"));
4590 && (arg_type
[0] != 0 || arg_type
[1] != 0))
4592 as_bad (_("Both arguments must be substitution symbols"));
4597 as_bad (_("Extra junk in function call, expecting ')'"));
4600 val
= (*entry
->proc
) (arg1
, arg2
);
4601 value
= XNEWVEC (char, 64);
4602 sprintf (value
, "%d", val
);
4604 /* Fix things up to replace the entire expression, not just the
4610 if (value
!= NULL
&& !eval_symbol
)
4612 /* Replace the symbol with its string replacement and
4613 continue. Recursively replace VALUE until either no
4614 substitutions are performed, or a substitution that has been
4615 previously made is encountered again.
4617 Put the symbol into the recursion hash table so we only
4618 try to replace a symbol once. */
4621 str_hash_insert (subsym_recurse_hash
, name
, name
);
4622 value
= subsym_substitute (value
, macro_level
> 0);
4623 str_hash_delete (subsym_recurse_hash
, name
);
4626 /* Temporarily zero-terminate where the symbol started. */
4632 /* Subscripted substitution symbol -- use just the
4633 indicated portion of the string; the description
4634 kinda indicates that forced substitution is not
4635 supposed to be recursive, but I'm not sure. */
4636 unsigned beg
, len
= 1; /* default to a single char */
4637 char *newval
= xstrdup (value
);
4639 savedp
= input_line_pointer
;
4640 input_line_pointer
= tail
+ 1;
4641 beg
= get_absolute_expression ();
4644 as_bad (_("Invalid subscript (use 1 to %d)"),
4645 (int) strlen (value
));
4648 if (*input_line_pointer
== ',')
4650 ++input_line_pointer
;
4651 len
= get_absolute_expression ();
4652 if (beg
+ len
> strlen (value
))
4654 as_bad (_("Invalid length (use 0 to %d)"),
4655 (int) strlen (value
) - beg
);
4661 tail
= input_line_pointer
;
4664 as_bad (_("Missing ')' in subscripted substitution "
4665 "symbol expression"));
4669 input_line_pointer
= savedp
;
4675 tmp
= xmalloc (strlen (head
) + strlen (value
) +
4676 strlen (tail
+ 1) + 2);
4678 strcat (tmp
, value
);
4679 /* Make sure forced substitutions are properly terminated. */
4684 as_bad (_("Missing forced substitution terminator ':'"));
4690 /* Restore the character after the symbol end. */
4693 /* Continue examining after the replacement value. */
4694 ptr
= tmp
+ strlen (head
) + strlen (value
);
4696 head
= replacement
= tmp
;
4714 /* We use this to handle substitution symbols
4715 hijack input_line_pointer, replacing it with our substituted string.
4717 .sslist should enable listing the line after replacements are made...
4719 returns the new buffer limit. */
4722 tic54x_start_line_hook (void)
4725 char *replacement
= NULL
;
4727 /* Work with a copy of the input line, including EOL char. */
4728 for (endp
= input_line_pointer
; *endp
!= 0; )
4729 if (is_end_of_line
[(unsigned char) *endp
++])
4732 line
= xmemdup0 (input_line_pointer
, endp
- input_line_pointer
);
4734 /* Scan ahead for parallel insns. */
4735 parallel_on_next_line_hint
= next_line_shows_parallel (endp
);
4737 /* If within a macro, first process forced replacements. */
4738 if (macro_level
> 0)
4739 replacement
= subsym_substitute (line
, 1);
4742 replacement
= subsym_substitute (replacement
, 0);
4744 if (replacement
!= line
)
4746 char *tmp
= replacement
;
4747 char *comment
= strchr (replacement
, ';');
4748 char endc
= replacement
[strlen (replacement
) - 1];
4750 /* Clean up the replacement; we'd prefer to have this done by the
4751 standard preprocessing equipment (maybe do_scrub_chars?)
4752 but for now, do a quick-and-dirty. */
4753 if (comment
!= NULL
)
4760 comment
= replacement
+ strlen (replacement
) - 1;
4762 /* Trim trailing whitespace. */
4763 while (ISSPACE (*comment
))
4770 /* Compact leading whitespace. */
4771 while (ISSPACE (tmp
[0]) && ISSPACE (tmp
[1]))
4774 input_line_pointer
= endp
;
4775 input_scrub_insert_line (tmp
);
4778 /* Keep track of whether we've done a substitution. */
4779 substitution_line
= 1;
4785 substitution_line
= 0;
4789 /* This is the guts of the machine-dependent assembler. STR points to a
4790 machine dependent instruction. This function is supposed to emit
4791 the frags/bytes it assembles to. */
4793 md_assemble (char *line
)
4795 static int repeat_slot
= 0;
4796 static int delay_slots
= 0; /* How many delay slots left to fill? */
4797 static int is_parallel
= 0;
4798 static tic54x_insn insn
;
4800 char *savedp
= input_line_pointer
;
4803 input_line_pointer
= line
;
4804 c
= get_symbol_name (&line
);
4808 if (address_mode_needs_set
)
4810 set_address_mode (amode
);
4811 address_mode_needs_set
= 0;
4824 strcpy (insn
.parmnemonic
, line
);
4825 lptr
= input_line_pointer
;
4827 input_line_pointer
= savedp
;
4829 if (tic54x_parse_parallel_insn_lastline (&insn
, lptr
))
4831 int words
= build_insn (&insn
);
4833 if (delay_slots
!= 0)
4835 if (words
> delay_slots
)
4837 as_bad (ngettext ("Instruction does not fit in available "
4838 "delay slots (%d-word insn, %d slot left)",
4839 "Instruction does not fit in available "
4840 "delay slots (%d-word insn, %d slots left)",
4842 words
, delay_slots
);
4846 delay_slots
-= words
;
4852 memset (&insn
, 0, sizeof (insn
));
4853 strcpy (insn
.mnemonic
, line
);
4854 lptr
= input_line_pointer
;
4856 input_line_pointer
= savedp
;
4858 /* See if this line is part of a parallel instruction; if so, either this
4859 line or the next line will have the "||" specifier preceding the
4860 mnemonic, and we look for it in the parallel insn hash table. */
4861 if (strstr (line
, "||") != NULL
|| parallel_on_next_line_hint
)
4863 char *tmp
= strstr (line
, "||");
4867 if (tic54x_parse_parallel_insn_firstline (&insn
, lptr
))
4870 /* If the parallel part is on the same line, process it now,
4871 otherwise let the assembler pick up the next line for us. */
4874 while (ISSPACE (tmp
[2]))
4876 md_assemble (tmp
+ 2);
4881 as_bad (_("Unrecognized parallel instruction '%s'"), line
);
4886 if (tic54x_parse_insn (&insn
, lptr
))
4890 if ((insn
.tm
->flags
& FL_LP
)
4891 && cpu
!= V545LP
&& cpu
!= V546LP
)
4893 as_bad (_("Instruction '%s' requires an LP cpu version"),
4897 if ((insn
.tm
->flags
& FL_FAR
)
4898 && amode
!= far_mode
)
4900 as_bad (_("Instruction '%s' requires far mode addressing"),
4905 words
= build_insn (&insn
);
4907 /* Is this instruction in a delay slot? */
4910 if (words
> delay_slots
)
4912 as_warn (ngettext ("Instruction does not fit in available "
4913 "delay slots (%d-word insn, %d slot left). "
4914 "Resulting behavior is undefined.",
4915 "Instruction does not fit in available "
4916 "delay slots (%d-word insn, %d slots left). "
4917 "Resulting behavior is undefined.",
4919 words
, delay_slots
);
4923 /* Branches in delay slots are not allowed. */
4924 if (insn
.tm
->flags
& FL_BMASK
)
4926 as_warn (_("Instructions which cause PC discontinuity are not "
4927 "allowed in a delay slot. "
4928 "Resulting behavior is undefined."));
4930 delay_slots
-= words
;
4933 /* Is this instruction the target of a repeat? */
4936 if (insn
.tm
->flags
& FL_NR
)
4937 as_warn (_("'%s' is not repeatable. "
4938 "Resulting behavior is undefined."),
4940 else if (insn
.is_lkaddr
)
4941 as_warn (_("Instructions using long offset modifiers or absolute "
4942 "addresses are not repeatable. "
4943 "Resulting behavior is undefined."));
4947 /* Make sure we check the target of a repeat instruction. */
4948 if (insn
.tm
->flags
& B_REPEAT
)
4951 /* FIXME -- warn if repeat_slot == 1 at EOF. */
4953 /* Make sure we check our delay slots for validity. */
4954 if (insn
.tm
->flags
& FL_DELAY
)
4957 /* FIXME -- warn if delay_slots != 0 at EOF. */
4962 /* Do a final adjustment on the symbol table; in this case, make sure we have
4963 a ".file" symbol. */
4966 tic54x_adjust_symtab (void)
4968 if (symbol_rootP
== NULL
4969 || S_GET_STORAGE_CLASS (symbol_rootP
) != C_FILE
)
4972 const char * filename
= as_where (&lineno
);
4973 c_dot_file_symbol (filename
, 0);
4977 /* In order to get gas to ignore any | chars at the start of a line,
4978 this function returns true if a | is found in a line.
4979 This lets us process parallel instructions, which span two lines. */
4982 tic54x_unrecognized_line (int c
)
4984 return c
== PARALLEL_SEPARATOR
;
4987 /* Watch for local labels of the form $[0-9] and [_a-zA-Z][_a-zA-Z0-9]*?
4988 Encode their names so that only we see them and can map them to the
4990 FIXME -- obviously this isn't done yet. These locals still show up in the
4993 tic54x_define_label (symbolS
*sym
)
4995 /* Just in case we need this later; note that this is not necessarily the
4996 same thing as line_label...
4997 When aligning or assigning labels to fields, sometimes the label is
4998 assigned other than the address at which the label appears.
4999 FIXME -- is this really needed? I think all the proper label assignment
5000 is done in tic54x_cons. */
5001 last_label_seen
= sym
;
5004 /* Try to parse something that normal parsing failed at. */
5007 tic54x_undefined_symbol (char *name
)
5011 /* Not sure how to handle predefined symbols. */
5012 if ((sym
= (tic54x_symbol
*) str_hash_find (cc_hash
, name
)) != NULL
||
5013 (sym
= (tic54x_symbol
*) str_hash_find (cc2_hash
, name
)) != NULL
||
5014 (sym
= (tic54x_symbol
*) str_hash_find (cc3_hash
, name
)) != NULL
||
5015 (sym
= (tic54x_symbol
*) str_hash_find (misc_symbol_hash
, name
)) != NULL
||
5016 (sym
= (tic54x_symbol
*) str_hash_find (sbit_hash
, name
)) != NULL
)
5018 return symbol_new (name
, reg_section
,
5019 (valueT
) sym
->value
,
5020 &zero_address_frag
);
5023 if ((sym
= (tic54x_symbol
*) str_hash_find (reg_hash
, name
)) != NULL
||
5024 (sym
= (tic54x_symbol
*) str_hash_find (mmreg_hash
, name
)) != NULL
||
5025 !strcasecmp (name
, "a") || !strcasecmp (name
, "b"))
5027 return symbol_new (name
, reg_section
,
5028 (valueT
) sym
? sym
->value
: 0,
5029 &zero_address_frag
);
5035 /* Parse a name in an expression before the expression parser takes a stab at
5039 tic54x_parse_name (char *name ATTRIBUTE_UNUSED
,
5040 expressionS
*expn ATTRIBUTE_UNUSED
)
5046 md_atof (int type
, char *literalP
, int *sizeP
)
5048 /* Target data is little-endian, but floats are stored
5049 big-"word"ian. ugh. */
5050 return ieee_md_atof (type
, literalP
, sizeP
, TRUE
);
5054 tc_gen_reloc (asection
*section
, fixS
*fixP
)
5057 bfd_reloc_code_real_type code
= fixP
->fx_r_type
;
5058 asymbol
*sym
= symbol_get_bfdsym (fixP
->fx_addsy
);
5060 rel
= XNEW (arelent
);
5061 rel
->sym_ptr_ptr
= XNEW (asymbol
*);
5062 *rel
->sym_ptr_ptr
= sym
;
5063 /* We assume that all rel->address are host byte offsets. */
5064 rel
->address
= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
5065 rel
->address
/= OCTETS_PER_BYTE
;
5066 rel
->howto
= bfd_reloc_type_lookup (stdoutput
, code
);
5067 if (!strcmp (sym
->name
, section
->name
))
5068 rel
->howto
+= HOWTO_BANK
;
5072 const char *name
= S_GET_NAME (fixP
->fx_addsy
);
5075 as_fatal ("Cannot generate relocation type for symbol %s, code %s",
5076 name
, bfd_get_reloc_code_name (code
));
5082 /* Handle cons expressions. */
5085 tic54x_cons_fix_new (fragS
*frag
, int where
, int octets
, expressionS
*expn
,
5086 bfd_reloc_code_real_type r
)
5091 as_bad (_("Unsupported relocation size %d"), octets
);
5092 r
= BFD_RELOC_TIC54X_16_OF_23
;
5095 r
= BFD_RELOC_TIC54X_16_OF_23
;
5098 /* TI assembler always uses this, regardless of addressing mode. */
5100 r
= BFD_RELOC_TIC54X_23
;
5102 /* We never want to directly generate this; this is provided for
5103 stabs support only. */
5107 fix_new_exp (frag
, where
, octets
, expn
, 0, r
);
5110 /* Attempt to simplify or even eliminate a fixup.
5111 To indicate that a fixup has been eliminated, set fixP->fx_done.
5113 If fixp->fx_addsy is non-NULL, we'll have to generate a reloc entry. */
5116 md_apply_fix (fixS
*fixP
, valueT
*valP
, segT seg ATTRIBUTE_UNUSED
)
5118 char *buf
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
5119 valueT val
= * valP
;
5121 switch (fixP
->fx_r_type
)
5124 as_fatal ("Bad relocation type: 0x%02x", fixP
->fx_r_type
);
5126 case BFD_RELOC_TIC54X_MS7_OF_23
:
5127 val
= (val
>> 16) & 0x7F;
5129 case BFD_RELOC_TIC54X_16_OF_23
:
5131 bfd_put_16 (stdoutput
, val
, buf
);
5132 /* Indicate what we're actually writing, so that we don't get warnings
5133 about exceeding available space. */
5134 *valP
= val
& 0xFFFF;
5136 case BFD_RELOC_TIC54X_PARTLS7
:
5137 bfd_put_16 (stdoutput
,
5138 (bfd_get_16 (stdoutput
, buf
) & 0xFF80) | (val
& 0x7F),
5140 /* Indicate what we're actually writing, so that we don't get warnings
5141 about exceeding available space. */
5144 case BFD_RELOC_TIC54X_PARTMS9
:
5145 /* TI assembler doesn't shift its encoding for relocatable files, and is
5146 thus incompatible with this implementation's relocatable files. */
5147 bfd_put_16 (stdoutput
,
5148 (bfd_get_16 (stdoutput
, buf
) & 0xFE00) | (val
>> 7),
5152 case BFD_RELOC_TIC54X_23
:
5153 bfd_put_32 (stdoutput
,
5154 (bfd_get_32 (stdoutput
, buf
) & 0xFF800000) | val
,
5159 if (fixP
->fx_addsy
== NULL
&& fixP
->fx_pcrel
== 0)
5163 /* This is our chance to record section alignment
5164 don't need to do anything here, since BFD does the proper encoding. */
5167 md_section_align (segT segment ATTRIBUTE_UNUSED
, valueT section_size
)
5169 return section_size
;
5173 md_pcrel_from (fixS
*fixP ATTRIBUTE_UNUSED
)
5178 /* Mostly little-endian, but longwords (4 octets) get MS word stored
5182 tic54x_number_to_chars (char *buf
, valueT val
, int n
)
5185 number_to_chars_littleendian (buf
, val
, n
);
5188 number_to_chars_littleendian (buf
, val
>> 16 , 2);
5189 number_to_chars_littleendian (buf
+ 2, val
& 0xFFFF, 2);
5194 tic54x_estimate_size_before_relax (fragS
*frag ATTRIBUTE_UNUSED
,
5195 segT seg ATTRIBUTE_UNUSED
)
5200 /* We use this to handle bit allocations which we couldn't handle before due
5201 to symbols being in different frags. return number of octets added. */
5204 tic54x_relax_frag (fragS
*frag
, long stretch ATTRIBUTE_UNUSED
)
5206 symbolS
*sym
= frag
->fr_symbol
;
5212 struct bit_info
*bi
= (struct bit_info
*) frag
->fr_opcode
;
5213 int bit_offset
= frag_bit_offset (frag_prev (frag
, bi
->seg
), bi
->seg
);
5214 int size
= S_GET_VALUE (sym
);
5215 fragS
*prev_frag
= bit_offset_frag (frag_prev (frag
, bi
->seg
), bi
->seg
);
5216 int available
= 16 - bit_offset
;
5218 if (symbol_get_frag (sym
) != &zero_address_frag
5219 || S_IS_COMMON (sym
)
5220 || !S_IS_DEFINED (sym
))
5221 as_bad_where (frag
->fr_file
, frag
->fr_line
,
5222 _("non-absolute value used with .space/.bes"));
5226 as_warn (_("negative value ignored in %s"),
5227 bi
->type
== TYPE_SPACE
? ".space" :
5228 bi
->type
== TYPE_BES
? ".bes" : ".field");
5230 frag
->tc_frag_data
= frag
->fr_fix
= 0;
5234 if (bi
->type
== TYPE_FIELD
)
5236 /* Bit fields of 16 or larger will have already been handled. */
5237 if (bit_offset
!= 0 && available
>= size
)
5239 char *p
= prev_frag
->fr_literal
;
5241 valueT value
= bi
->value
;
5242 value
<<= available
- size
;
5243 value
|= ((unsigned short) p
[1] << 8) | p
[0];
5244 md_number_to_chars (p
, value
, 2);
5245 if ((prev_frag
->tc_frag_data
+= size
) == 16)
5246 prev_frag
->tc_frag_data
= 0;
5248 symbol_set_frag (bi
->sym
, prev_frag
);
5249 /* This frag is no longer used. */
5250 growth
= -frag
->fr_fix
;
5252 frag
->tc_frag_data
= 0;
5256 char *p
= frag
->fr_literal
;
5258 valueT value
= bi
->value
<< (16 - size
);
5259 md_number_to_chars (p
, value
, 2);
5260 if ((frag
->tc_frag_data
= size
) == 16)
5261 frag
->tc_frag_data
= 0;
5267 if (bit_offset
!= 0 && bit_offset
< 16)
5269 if (available
>= size
)
5271 if ((prev_frag
->tc_frag_data
+= size
) == 16)
5272 prev_frag
->tc_frag_data
= 0;
5274 symbol_set_frag (bi
->sym
, prev_frag
);
5275 /* This frag is no longer used. */
5276 growth
= -frag
->fr_fix
;
5278 frag
->tc_frag_data
= 0;
5281 if (bi
->type
== TYPE_SPACE
&& bi
->sym
)
5282 symbol_set_frag (bi
->sym
, prev_frag
);
5285 growth
= (size
+ 15) / 16 * OCTETS_PER_BYTE
- frag
->fr_fix
;
5286 for (i
= 0; i
< growth
; i
++)
5287 frag
->fr_literal
[i
] = 0;
5288 frag
->fr_fix
= growth
;
5289 frag
->tc_frag_data
= size
% 16;
5290 /* Make sure any BES label points to the LAST word allocated. */
5291 if (bi
->type
== TYPE_BES
&& bi
->sym
)
5292 S_SET_VALUE (bi
->sym
, frag
->fr_fix
/ OCTETS_PER_BYTE
- 1);
5295 frag
->fr_symbol
= 0;
5296 frag
->fr_opcode
= 0;
5303 tic54x_convert_frag (bfd
*abfd ATTRIBUTE_UNUSED
,
5304 segT seg ATTRIBUTE_UNUSED
,
5307 /* Offset is in bytes. */
5308 frag
->fr_offset
= (frag
->fr_next
->fr_address
5310 - frag
->fr_fix
) / frag
->fr_var
;
5311 if (frag
->fr_offset
< 0)
5313 as_bad_where (frag
->fr_file
, frag
->fr_line
,
5314 _("attempt to .space/.bes backwards? (%ld)"),
5315 (long) frag
->fr_offset
);
5317 frag
->fr_type
= rs_space
;
5320 /* We need to avoid having labels defined for certain directives/pseudo-ops
5321 since once the label is defined, it's in the symbol table for good. TI
5322 syntax puts the symbol *before* the pseudo (which is kinda like MRI syntax,
5323 I guess, except I've never seen a definition of MRI syntax).
5325 Don't allow labels to start with '.' */
5328 tic54x_start_label (char * label_start
, int nul_char
, int next_char
)
5332 /* If within .struct/.union, no auto line labels, please. */
5333 if (current_stag
!= NULL
)
5336 /* Disallow labels starting with "." */
5337 if (next_char
!= ':')
5339 if (*label_start
== '.')
5341 as_bad (_("Invalid label '%s'"), label_start
);
5346 if (is_end_of_line
[(unsigned char) next_char
])
5349 rest
= input_line_pointer
;
5350 if (nul_char
== '"')
5352 while (ISSPACE (next_char
))
5353 next_char
= *++rest
;
5354 if (next_char
!= '.')
5357 /* Don't let colon () define a label for any of these... */
5358 return ((strncasecmp (rest
, ".tag", 4) != 0 || !ISSPACE (rest
[4]))
5359 && (strncasecmp (rest
, ".struct", 7) != 0 || !ISSPACE (rest
[7]))
5360 && (strncasecmp (rest
, ".union", 6) != 0 || !ISSPACE (rest
[6]))
5361 && (strncasecmp (rest
, ".macro", 6) != 0 || !ISSPACE (rest
[6]))
5362 && (strncasecmp (rest
, ".set", 4) != 0 || !ISSPACE (rest
[4]))
5363 && (strncasecmp (rest
, ".equ", 4) != 0 || !ISSPACE (rest
[4])));