1 /* tc-tic54x.c -- Assembly code for the Texas Instruments TMS320C54X
2 Copyright (C) 1999-2015 Free Software Foundation, Inc.
3 Contributed by Timothy Wall (twall@cygnus.com)
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
22 /* Texas Instruments TMS320C54X machine specific gas.
23 Written by Timothy Wall (twall@alum.mit.edu).
25 Valuable things to do:
26 Pipeline conflict warnings
27 We encode/decode "ld #_label, dp" differently in relocatable files
28 This means we're not compatible with TI output containing those
29 expressions. We store the upper nine bits; TI stores the lower nine
30 bits. How they recover the original upper nine bits is beyond me.
32 Tests to add to expect testsuite:
33 '=' and '==' with .if, .elseif, and .break
35 Incompatibilities (mostly trivial):
37 We fill text section with zeroes instead of "nop"s
38 We don't convert '' or "" to a single instance
39 We don't convert '' to '\0'
40 We don't allow strings with .byte/.half/.short/.long
41 Probably details of the subsym stuff are different
42 TI sets labels to be data type 4 (T_INT); GAS uses T_NULL.
44 COFF1 limits section names to 8 characters.
45 Some of the default behavior changed from COFF1 to COFF2. */
49 #include "safe-ctype.h"
53 #include "struc-symbol.h"
54 #include "opcode/tic54x.h"
61 symbolS
*sym
; /* Symbol for this stag; value is offset. */
62 const char *name
; /* Shortcut to symbol name. */
63 bfd_vma size
; /* Size of struct/union. */
64 int current_bitfield_offset
; /* Temporary for tracking fields. */
66 struct stag_field
/* List of fields. */
69 bfd_vma offset
; /* Of start of this field. */
70 int bitfield_offset
; /* Of start of this field. */
71 struct stag
*stag
; /* If field is struct/union. */
72 struct stag_field
*next
;
74 /* For nesting; used only in stag construction. */
75 struct stag
*inner
; /* Enclosed .struct. */
76 struct stag
*outer
; /* Enclosing .struct. */
77 } *current_stag
= NULL
;
79 #define MAX_LINE 256 /* Lines longer than this are truncated by TI's asm. */
81 typedef struct _tic54x_insn
83 const insn_template
*tm
; /* Opcode template. */
85 char mnemonic
[MAX_LINE
]; /* Opcode name/mnemonic. */
86 char parmnemonic
[MAX_LINE
]; /* 2nd mnemonic of parallel insn. */
94 } operands
[MAX_OPERANDS
];
97 struct opstruct paroperands
[MAX_OPERANDS
];
101 int words
; /* Size of insn in 16-bit words. */
102 int using_default_dst
; /* Do we need to explicitly set an
103 omitted OP_DST operand? */
106 unsigned short word
; /* Final encoded opcode data. */
108 int r_nchars
; /* Relocation size. */
109 bfd_reloc_code_real_type r_type
; /* Relocation type. */
110 expressionS addr_expr
; /* Storage for unresolved expressions. */
116 VNONE
= 0, V541
= 1, V542
= 2, V543
= 3, V545
= 5, V548
= 8, V549
= 9,
117 V545LP
= 15, V546LP
= 16
122 c_mode
, /* 16-bit addresses. */
123 far_mode
/* >16-bit addresses. */
126 static segT stag_saved_seg
;
127 static subsegT stag_saved_subseg
;
129 const char comment_chars
[] = ";";
130 const char line_comment_chars
[] = ";*#"; /* At column zero only. */
131 const char line_separator_chars
[] = ""; /* Not permitted. */
133 int emitting_long
= 0;
135 /* Characters which indicate that this is a floating point constant. */
136 const char FLT_CHARS
[] = "fF";
138 /* Characters that can be used to separate mantissa from exp in FP
140 const char EXP_CHARS
[] = "eE";
142 const char *md_shortopts
= "";
144 #define OPTION_ADDRESS_MODE (OPTION_MD_BASE)
145 #define OPTION_CPU_VERSION (OPTION_ADDRESS_MODE + 1)
146 #define OPTION_COFF_VERSION (OPTION_CPU_VERSION + 1)
147 #define OPTION_STDERR_TO_FILE (OPTION_COFF_VERSION + 1)
149 struct option md_longopts
[] =
151 { "mfar-mode", no_argument
, NULL
, OPTION_ADDRESS_MODE
},
152 { "mf", no_argument
, NULL
, OPTION_ADDRESS_MODE
},
153 { "mcpu", required_argument
, NULL
, OPTION_CPU_VERSION
},
154 { "merrors-to-file", required_argument
, NULL
, OPTION_STDERR_TO_FILE
},
155 { "me", required_argument
, NULL
, OPTION_STDERR_TO_FILE
},
156 { NULL
, no_argument
, NULL
, 0},
159 size_t md_longopts_size
= sizeof (md_longopts
);
161 static int assembly_begun
= 0;
162 /* Addressing mode is not entirely implemented; the latest rev of the Other
163 assembler doesn't seem to make any distinction whatsoever; all relocations
164 are stored as extended relocatiosn. Older versions used REL16 vs RELEXT16,
165 but now it seems all relocations are RELEXT16. We use all RELEXT16.
167 The cpu version is kind of a waste of time as well. There is one
168 instruction (RND) for LP devices only, and several for devices with
169 extended addressing only. We include it for compatibility. */
170 static enum address_mode amode
= c_mode
;
171 static enum cpu_version cpu
= VNONE
;
173 /* Include string substitutions in listing? */
174 static int listing_sslist
= 0;
176 /* Did we do subsym substitutions on the line? */
177 static int substitution_line
= 0;
179 /* Last label seen. */
180 static symbolS
*last_label_seen
= NULL
;
182 /* This ensures that all new labels are unique. */
183 static int local_label_id
;
185 static struct hash_control
*subsym_recurse_hash
; /* Prevent infinite recurse. */
186 static struct hash_control
*math_hash
; /* Built-in math functions. */
187 /* Allow maximum levels of macro nesting; level 0 is the main substitution
188 symbol table. The other assembler only does 32 levels, so there! */
189 static struct hash_control
*subsym_hash
[100];
191 /* Keep track of local labels so we can substitute them before GAS sees them
192 since macros use their own 'namespace' for local labels, use a separate hash
194 We do our own local label handling 'cuz it's subtly different from the
197 We use our own macro nesting counter, since GAS overloads it when expanding
198 other things (like conditionals and repeat loops). */
199 static int macro_level
= 0;
200 static struct hash_control
*local_label_hash
[100];
201 /* Keep track of struct/union tags. */
202 static struct hash_control
*stag_hash
;
203 static struct hash_control
*op_hash
;
204 static struct hash_control
*parop_hash
;
205 static struct hash_control
*reg_hash
;
206 static struct hash_control
*mmreg_hash
;
207 static struct hash_control
*cc_hash
;
208 static struct hash_control
*cc2_hash
;
209 static struct hash_control
*cc3_hash
;
210 static struct hash_control
*sbit_hash
;
211 static struct hash_control
*misc_symbol_hash
;
213 /* Only word (et al.), align, or conditionals are allowed within
215 #define ILLEGAL_WITHIN_STRUCT() \
217 if (current_stag != NULL) \
219 as_bad (_("pseudo-op illegal within .struct/.union")); \
225 static void subsym_create_or_replace (char *, char *);
226 static char *subsym_lookup (char *, int);
227 static char *subsym_substitute (char *, int);
231 md_show_usage (FILE *stream
)
233 fprintf (stream
, _("C54x-specific command line options:\n"));
234 fprintf (stream
, _("-mfar-mode | -mf Use extended addressing\n"));
235 fprintf (stream
, _("-mcpu=<CPU version> Specify the CPU version\n"));
236 fprintf (stream
, _("-merrors-to-file <filename>\n"));
237 fprintf (stream
, _("-me <filename> Redirect errors to a file\n"));
240 /* Output a single character (upper octect is zero). */
243 tic54x_emit_char (char c
)
247 expn
.X_op
= O_constant
;
248 expn
.X_add_number
= c
;
249 emit_expr (&expn
, 2);
252 /* Walk backwards in the frag chain. */
255 frag_prev (fragS
*frag
, segT seg
)
257 segment_info_type
*seginfo
= seg_info (seg
);
260 for (fragp
= seginfo
->frchainP
->frch_root
; fragp
; fragp
= fragp
->fr_next
)
261 if (fragp
->fr_next
== frag
)
268 bit_offset_frag (fragS
*frag
, segT seg
)
272 if (frag
->fr_fix
== 0
273 && frag
->fr_opcode
== NULL
274 && frag
->tc_frag_data
== 0)
275 frag
= frag_prev (frag
, seg
);
282 /* Return the number of bits allocated in the most recent word, or zero if
283 none. .field/.space/.bes may leave words partially allocated. */
286 frag_bit_offset (fragS
*frag
, segT seg
)
288 frag
= bit_offset_frag (frag
, seg
);
291 return frag
->fr_opcode
!= NULL
? -1 : frag
->tc_frag_data
;
296 /* Read an expression from a C string; returns a pointer past the end of the
300 parse_expression (char *str
, expressionS
*expn
)
305 tmp
= input_line_pointer
; /* Save line pointer. */
306 input_line_pointer
= str
;
308 s
= input_line_pointer
;
309 input_line_pointer
= tmp
; /* Restore line pointer. */
310 return s
; /* Return pointer to where parsing stopped. */
313 /* .asg "character-string"|character-string, symbol
315 .eval is the only pseudo-op allowed to perform arithmetic on substitution
316 symbols. all other use of symbols defined with .asg are currently
320 tic54x_asg (int x ATTRIBUTE_UNUSED
)
326 int quoted
= *input_line_pointer
== '"';
328 ILLEGAL_WITHIN_STRUCT ();
333 str
= demand_copy_C_string (&len
);
334 c
= *input_line_pointer
;
338 str
= input_line_pointer
;
339 while ((c
= *input_line_pointer
) != ',')
341 if (is_end_of_line
[(int) *input_line_pointer
])
343 ++input_line_pointer
;
345 *input_line_pointer
= 0;
349 as_bad (_("Comma and symbol expected for '.asg STRING, SYMBOL'"));
350 ignore_rest_of_line ();
354 name
= ++input_line_pointer
;
355 c
= get_symbol_end (); /* Get terminator. */
356 if (!ISALPHA (*name
))
358 as_bad (_("symbols assigned with .asg must begin with a letter"));
359 ignore_rest_of_line ();
363 tmp
= xmalloc (strlen (str
) + 1);
366 tmp
= xmalloc (strlen (name
) + 1);
369 subsym_create_or_replace (name
, str
);
370 *input_line_pointer
= c
;
371 demand_empty_rest_of_line ();
374 /* .eval expression, symbol
375 There's something screwy about this. The other assembler sometimes does and
376 sometimes doesn't substitute symbols defined with .eval.
377 We'll put the symbols into the subsym table as well as the normal symbol
378 table, since that's what works best. */
381 tic54x_eval (int x ATTRIBUTE_UNUSED
)
387 char valuestr
[32], *tmp
;
390 ILLEGAL_WITHIN_STRUCT ();
394 quoted
= *input_line_pointer
== '"';
396 ++input_line_pointer
;
397 value
= get_absolute_expression ();
400 if (*input_line_pointer
!= '"')
402 as_bad (_("Unterminated string after absolute expression"));
403 ignore_rest_of_line ();
406 ++input_line_pointer
;
408 if (*input_line_pointer
++ != ',')
410 as_bad (_("Comma and symbol expected for '.eval EXPR, SYMBOL'"));
411 ignore_rest_of_line ();
414 name
= input_line_pointer
;
415 c
= get_symbol_end (); /* Get terminator. */
416 tmp
= xmalloc (strlen (name
) + 1);
417 name
= strcpy (tmp
, name
);
418 *input_line_pointer
= c
;
420 if (!ISALPHA (*name
))
422 as_bad (_("symbols assigned with .eval must begin with a letter"));
423 ignore_rest_of_line ();
426 symbolP
= symbol_new (name
, absolute_section
,
427 (valueT
) value
, &zero_address_frag
);
428 SF_SET_LOCAL (symbolP
);
429 symbol_table_insert (symbolP
);
431 /* The "other" assembler sometimes doesn't put .eval's in the subsym table
432 But since there's not written rule as to when, don't even bother trying
433 to match their behavior. */
434 sprintf (valuestr
, "%d", value
);
435 tmp
= xmalloc (strlen (valuestr
) + 1);
436 strcpy (tmp
, valuestr
);
437 subsym_create_or_replace (name
, tmp
);
439 demand_empty_rest_of_line ();
442 /* .bss symbol, size [, [blocking flag] [, alignment flag]
444 alignment is to a longword boundary; blocking is to 128-word boundary.
446 1) if there is a hole in memory, this directive should attempt to fill it
447 (not yet implemented).
449 2) if the blocking flag is not set, allocate at the current SPC
450 otherwise, check to see if the current SPC plus the space to be
451 allocated crosses the page boundary (128 words).
452 if there's not enough space, create a hole and align with the next page
454 (not yet implemented). */
457 tic54x_bss (int x ATTRIBUTE_UNUSED
)
464 subsegT current_subseg
;
469 ILLEGAL_WITHIN_STRUCT ();
471 current_seg
= now_seg
; /* Save current seg. */
472 current_subseg
= now_subseg
; /* Save current subseg. */
474 name
= input_line_pointer
;
475 c
= get_symbol_end (); /* Get terminator. */
478 as_bad (_(".bss size argument missing\n"));
479 ignore_rest_of_line ();
483 ++input_line_pointer
;
484 words
= get_absolute_expression ();
487 as_bad (_(".bss size %d < 0!"), words
);
488 ignore_rest_of_line ();
492 if (*input_line_pointer
== ',')
494 /* The blocking flag may be missing. */
495 ++input_line_pointer
;
496 if (*input_line_pointer
!= ',')
497 block
= get_absolute_expression ();
501 if (*input_line_pointer
== ',')
503 ++input_line_pointer
;
504 align
= get_absolute_expression ();
512 subseg_set (bss_section
, 0);
513 symbolP
= symbol_find_or_make (name
);
515 if (S_GET_SEGMENT (symbolP
) == bss_section
)
516 symbolP
->sy_frag
->fr_symbol
= (symbolS
*) NULL
;
518 symbol_set_frag (symbolP
, frag_now
);
519 p
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
,
520 (offsetT
) (words
* OCTETS_PER_BYTE
), (char *) 0);
521 *p
= 0; /* Fill char. */
523 S_SET_SEGMENT (symbolP
, bss_section
);
525 /* The symbol may already have been created with a preceding
526 ".globl" directive -- be careful not to step on storage class
527 in that case. Otherwise, set it to static. */
528 if (S_GET_STORAGE_CLASS (symbolP
) != C_EXT
)
529 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
533 /* s_align eats end of line; restore it */
535 --input_line_pointer
;
539 bss_section
->flags
|= SEC_TIC54X_BLOCK
;
541 subseg_set (current_seg
, current_subseg
); /* Restore current seg. */
542 demand_empty_rest_of_line ();
546 stag_add_field_symbols (struct stag
*stag
,
550 const char *root_stag_name
)
552 char prefix
[strlen (path
) + 2];
553 struct stag_field
*field
= stag
->field
;
555 /* Construct a symbol for every field contained within this structure
556 including fields within structure fields. */
557 strcpy (prefix
, path
);
559 strcat (prefix
, ".");
561 while (field
!= NULL
)
563 int len
= strlen (prefix
) + strlen (field
->name
) + 2;
564 char *name
= xmalloc (len
);
565 strcpy (name
, prefix
);
566 strcat (name
, field
->name
);
571 sym
= symbol_new (name
, absolute_section
,
572 (field
->stag
? field
->offset
:
573 (valueT
) (base_offset
+ field
->offset
)),
576 symbol_table_insert (sym
);
580 char *replacement
= xmalloc (strlen (name
)
581 + strlen (stag
->name
) + 2);
582 strcpy (replacement
, S_GET_NAME (rootsym
));
583 strcat (replacement
, "+");
584 strcat (replacement
, root_stag_name
);
585 strcat (replacement
, name
+ strlen (S_GET_NAME (rootsym
)));
586 hash_insert (subsym_hash
[0], name
, replacement
);
589 /* Recurse if the field is a structure.
590 Note the field offset is relative to the outermost struct. */
591 if (field
->stag
!= NULL
)
592 stag_add_field_symbols (field
->stag
, name
,
594 rootsym
, root_stag_name
);
599 /* Keep track of stag fields so that when structures are nested we can add the
600 complete dereferencing symbols to the symbol table. */
603 stag_add_field (struct stag
*parent
,
608 struct stag_field
*sfield
= xmalloc (sizeof (struct stag_field
));
610 memset (sfield
, 0, sizeof (*sfield
));
611 sfield
->name
= strcpy (xmalloc (strlen (name
) + 1), name
);
612 sfield
->offset
= offset
;
613 sfield
->bitfield_offset
= parent
->current_bitfield_offset
;
615 if (parent
->field
== NULL
)
616 parent
->field
= sfield
;
619 struct stag_field
*sf
= parent
->field
;
620 while (sf
->next
!= NULL
)
624 /* Only create a symbol for this field if the parent has no name. */
625 if (!strncmp (".fake", parent
->name
, 5))
627 symbolS
*sym
= symbol_new (name
, absolute_section
,
628 (valueT
) offset
, &zero_address_frag
);
630 symbol_table_insert (sym
);
634 /* [STAG] .struct [OFFSET]
635 Start defining structure offsets (symbols in absolute section). */
638 tic54x_struct (int arg
)
640 int start_offset
= 0;
645 /* Starting a new struct, switch to absolute section. */
646 stag_saved_seg
= now_seg
;
647 stag_saved_subseg
= now_subseg
;
648 subseg_set (absolute_section
, 0);
650 /* Align the current pointer. */
651 else if (current_stag
->current_bitfield_offset
!= 0)
653 ++abs_section_offset
;
654 current_stag
->current_bitfield_offset
= 0;
657 /* Offset expression is only meaningful for global .structs. */
660 /* Offset is ignored in inner structs. */
662 if (!is_end_of_line
[(int) *input_line_pointer
])
663 start_offset
= get_absolute_expression ();
670 /* Nesting, link to outer one. */
671 current_stag
->inner
= (struct stag
*) xmalloc (sizeof (struct stag
));
672 memset (current_stag
->inner
, 0, sizeof (struct stag
));
673 current_stag
->inner
->outer
= current_stag
;
674 current_stag
= current_stag
->inner
;
676 as_warn (_("Offset on nested structures is ignored"));
677 start_offset
= abs_section_offset
;
681 current_stag
= (struct stag
*) xmalloc (sizeof (struct stag
));
682 memset (current_stag
, 0, sizeof (struct stag
));
683 abs_section_offset
= start_offset
;
685 current_stag
->is_union
= is_union
;
687 if (line_label
== NULL
)
689 static int struct_count
= 0;
690 char fake
[] = ".fake_stagNNNNNNN";
691 sprintf (fake
, ".fake_stag%d", struct_count
++);
692 current_stag
->sym
= symbol_new (fake
, absolute_section
,
693 (valueT
) abs_section_offset
,
698 char label
[strlen (S_GET_NAME (line_label
)) + 1];
699 strcpy (label
, S_GET_NAME (line_label
));
700 current_stag
->sym
= symbol_new (label
, absolute_section
,
701 (valueT
) abs_section_offset
,
704 current_stag
->name
= S_GET_NAME (current_stag
->sym
);
705 SF_SET_LOCAL (current_stag
->sym
);
706 /* Nested .structs don't go into the symbol table. */
707 if (current_stag
->outer
== NULL
)
708 symbol_table_insert (current_stag
->sym
);
713 /* [LABEL] .endstruct
714 finish defining structure offsets; optional LABEL's value will be the size
718 tic54x_endstruct (int is_union
)
722 !strncmp (current_stag
->name
, ".fake", 5) ? "" : current_stag
->name
;
724 if (!current_stag
|| current_stag
->is_union
!= is_union
)
726 as_bad (_(".end%s without preceding .%s"),
727 is_union
? "union" : "struct",
728 is_union
? "union" : "struct");
729 ignore_rest_of_line ();
733 /* Align end of structures. */
734 if (current_stag
->current_bitfield_offset
)
736 ++abs_section_offset
;
737 current_stag
->current_bitfield_offset
= 0;
740 if (current_stag
->is_union
)
741 size
= current_stag
->size
;
743 size
= abs_section_offset
- S_GET_VALUE (current_stag
->sym
);
744 if (line_label
!= NULL
)
746 S_SET_VALUE (line_label
, size
);
747 symbol_table_insert (line_label
);
751 /* Union size has already been calculated. */
752 if (!current_stag
->is_union
)
753 current_stag
->size
= size
;
754 /* Nested .structs don't get put in the stag table. */
755 if (current_stag
->outer
== NULL
)
757 hash_insert (stag_hash
, current_stag
->name
, current_stag
);
758 stag_add_field_symbols (current_stag
, path
,
759 S_GET_VALUE (current_stag
->sym
),
762 current_stag
= current_stag
->outer
;
764 /* If this is a nested .struct/.union, add it as a field to the enclosing
765 one. otherwise, restore the section we were in. */
766 if (current_stag
!= NULL
)
768 stag_add_field (current_stag
, current_stag
->inner
->name
,
769 S_GET_VALUE (current_stag
->inner
->sym
),
770 current_stag
->inner
);
773 subseg_set (stag_saved_seg
, stag_saved_subseg
);
777 Reference a structure within a structure, as a sized field with an optional
779 If used outside of a .struct/.endstruct, overlays the given structure
780 format on the existing allocated space. */
783 tic54x_tag (int ignore ATTRIBUTE_UNUSED
)
785 char *name
= input_line_pointer
;
786 int c
= get_symbol_end ();
787 struct stag
*stag
= (struct stag
*) hash_find (stag_hash
, name
);
792 as_bad (_("Unrecognized struct/union tag '%s'"), name
);
794 as_bad (_(".tag requires a structure tag"));
795 ignore_rest_of_line ();
798 if (line_label
== NULL
)
800 as_bad (_("Label required for .tag"));
801 ignore_rest_of_line ();
806 char label
[strlen (S_GET_NAME (line_label
)) + 1];
808 strcpy (label
, S_GET_NAME (line_label
));
809 if (current_stag
!= NULL
)
810 stag_add_field (current_stag
, label
,
811 abs_section_offset
- S_GET_VALUE (current_stag
->sym
),
815 symbolS
*sym
= symbol_find (label
);
819 as_bad (_(".tag target '%s' undefined"), label
);
820 ignore_rest_of_line ();
823 stag_add_field_symbols (stag
, S_GET_NAME (sym
),
824 S_GET_VALUE (stag
->sym
), sym
, stag
->name
);
828 /* Bump by the struct size, but only if we're within a .struct section. */
829 if (current_stag
!= NULL
&& !current_stag
->is_union
)
830 abs_section_offset
+= stag
->size
;
832 *input_line_pointer
= c
;
833 demand_empty_rest_of_line ();
837 /* Handle all .byte, .char, .double, .field, .float, .half, .int, .long,
838 .short, .string, .ubyte, .uchar, .uhalf, .uint, .ulong, .ushort, .uword,
842 tic54x_struct_field (int type
)
846 int new_bitfield_offset
= 0;
847 int field_align
= current_stag
->current_bitfield_offset
!= 0;
848 int longword_align
= 0;
851 if (!is_end_of_line
[(int) *input_line_pointer
])
852 count
= get_absolute_expression ();
868 case '*': /* String. */
877 case '.': /* Bitfield. */
879 if (count
< 1 || count
> 32)
881 as_bad (_(".field count '%d' out of range (1 <= X <= 32)"), count
);
882 ignore_rest_of_line ();
885 if (current_stag
->current_bitfield_offset
+ count
> 16)
887 /* Set the appropriate size and new field offset. */
897 new_bitfield_offset
= count
- 16;
900 new_bitfield_offset
= count
;
905 new_bitfield_offset
= current_stag
->current_bitfield_offset
+ count
;
909 as_bad (_("Unrecognized field type '%c'"), type
);
910 ignore_rest_of_line ();
916 /* Align to the actual starting position of the field. */
917 current_stag
->current_bitfield_offset
= 0;
918 ++abs_section_offset
;
920 /* Align to longword boundary. */
921 if (longword_align
&& (abs_section_offset
& 0x1))
922 ++abs_section_offset
;
924 if (line_label
== NULL
)
926 static int fieldno
= 0;
927 char fake
[] = ".fake_fieldNNNNN";
929 sprintf (fake
, ".fake_field%d", fieldno
++);
930 stag_add_field (current_stag
, fake
,
931 abs_section_offset
- S_GET_VALUE (current_stag
->sym
),
936 char label
[strlen (S_GET_NAME (line_label
) + 1)];
938 strcpy (label
, S_GET_NAME (line_label
));
939 stag_add_field (current_stag
, label
,
940 abs_section_offset
- S_GET_VALUE (current_stag
->sym
),
944 if (current_stag
->is_union
)
946 /* Note we treat the element as if it were an array of COUNT. */
947 if (current_stag
->size
< (unsigned) size
* count
)
948 current_stag
->size
= size
* count
;
952 abs_section_offset
+= (unsigned) size
* count
;
953 current_stag
->current_bitfield_offset
= new_bitfield_offset
;
958 /* Handle .byte, .word. .int, .long and all variants. */
961 tic54x_cons (int type
)
966 /* If we're within a .struct construct, don't actually allocate space. */
967 if (current_stag
!= NULL
)
969 tic54x_struct_field (type
);
973 #ifdef md_flush_pending_output
974 md_flush_pending_output ();
977 generate_lineno_debug ();
979 /* Align long words to long word boundaries (4 octets). */
980 if (type
== 'l' || type
== 'L')
982 frag_align (2, 0, 2);
983 /* If there's a label, assign it to the first allocated word. */
984 if (line_label
!= NULL
)
986 symbol_set_frag (line_label
, frag_now
);
987 S_SET_VALUE (line_label
, frag_now_fix ());
1011 if (*input_line_pointer
== '"')
1013 input_line_pointer
++;
1014 while (is_a_char (c
= next_char_of_string ()))
1015 tic54x_emit_char (c
);
1016 know (input_line_pointer
[-1] == '\"');
1022 input_line_pointer
= parse_expression (input_line_pointer
, &expn
);
1023 if (expn
.X_op
== O_constant
)
1025 offsetT value
= expn
.X_add_number
;
1026 /* Truncate overflows. */
1030 if ((value
> 0 && value
> 0xFF)
1031 || (value
< 0 && value
< - 0x100))
1032 as_warn (_("Overflow in expression, truncated to 8 bits"));
1035 if ((value
> 0 && value
> 0xFFFF)
1036 || (value
< 0 && value
< - 0x10000))
1037 as_warn (_("Overflow in expression, truncated to 16 bits"));
1041 if (expn
.X_op
!= O_constant
&& octets
< 2)
1043 /* Disallow .byte with a non constant expression that will
1044 require relocation. */
1045 as_bad (_("Relocatable values require at least WORD storage"));
1046 ignore_rest_of_line ();
1050 if (expn
.X_op
!= O_constant
1054 /* FIXME -- at one point TI tools used to output REL16
1055 relocations, but I don't think the latest tools do at all
1056 The current tools output extended relocations regardless of
1057 the addressing mode (I actually think that ".c_mode" is
1058 totally ignored in the latest tools). */
1061 emit_expr (&expn
, 4);
1067 emitting_long
= octets
== 4;
1068 emit_expr (&expn
, (octets
== 1) ? 2 : octets
);
1073 while (*input_line_pointer
++ == ',');
1075 input_line_pointer
--; /* Put terminator back into stream. */
1076 demand_empty_rest_of_line ();
1079 /* .global <symbol>[,...,<symbolN>]
1080 .def <symbol>[,...,<symbolN>]
1081 .ref <symbol>[,...,<symbolN>]
1083 These all identify global symbols.
1085 .def means the symbol is defined in the current module and can be accessed
1086 by other files. The symbol should be placed in the symbol table.
1088 .ref means the symbol is used in the current module but defined in another
1089 module. The linker is to resolve this symbol's definition at link time.
1091 .global should act as a .ref or .def, as needed.
1093 global, def and ref all have symbol storage classes of C_EXT.
1095 I can't identify any difference in how the "other" c54x assembler treats
1096 these, so we ignore the type here. */
1099 tic54x_global (int type
)
1106 as_warn (_("Use of .def/.ref is deprecated. Use .global instead"));
1108 ILLEGAL_WITHIN_STRUCT ();
1112 name
= input_line_pointer
;
1113 c
= get_symbol_end ();
1114 symbolP
= symbol_find_or_make (name
);
1116 *input_line_pointer
= c
;
1117 S_SET_STORAGE_CLASS (symbolP
, C_EXT
);
1120 input_line_pointer
++;
1121 if (is_end_of_line
[(int) *input_line_pointer
])
1122 c
= *input_line_pointer
;
1127 demand_empty_rest_of_line ();
1130 /* Remove the symbol from the local label hash lookup. */
1133 tic54x_remove_local_label (const char *key
, void *value ATTRIBUTE_UNUSED
)
1135 void *elem
= hash_delete (local_label_hash
[macro_level
], key
, FALSE
);
1139 /* Reset all local labels. */
1142 tic54x_clear_local_labels (int ignored ATTRIBUTE_UNUSED
)
1144 hash_traverse (local_label_hash
[macro_level
], tic54x_remove_local_label
);
1149 .sect "section name"
1152 make sure local labels get cleared when changing sections
1154 ARG is 't' for text, 'd' for data, or '*' for a named section
1156 For compatibility, '*' sections are SEC_CODE if instructions are
1157 encountered, or SEC_DATA if not.
1161 tic54x_sect (int arg
)
1163 ILLEGAL_WITHIN_STRUCT ();
1165 /* Local labels are cleared when changing sections. */
1166 tic54x_clear_local_labels (0);
1170 else if (arg
== 'd')
1177 /* If there are quotes, remove them. */
1178 if (*input_line_pointer
== '"')
1180 name
= demand_copy_C_string (&len
);
1181 demand_empty_rest_of_line ();
1182 name
= strcpy (xmalloc (len
+ 10), name
);
1187 name
= input_line_pointer
;
1188 c
= get_symbol_end ();
1190 name
= strcpy (xmalloc (len
+ 10), name
);
1191 *input_line_pointer
= c
;
1192 demand_empty_rest_of_line ();
1194 /* Make sure all named initialized sections flagged properly. If we
1195 encounter instructions, we'll flag it with SEC_CODE as well. */
1196 strcat (name
, ",\"w\"\n");
1197 input_scrub_insert_line (name
);
1198 obj_coff_section (0);
1200 /* If there was a line label, make sure that it gets assigned the proper
1201 section. This is for compatibility, even though the actual behavior
1202 is not explicitly defined. For consistency, we make .sect behave
1203 like .usect, since that is probably what people expect. */
1204 if (line_label
!= NULL
)
1206 S_SET_SEGMENT (line_label
, now_seg
);
1207 symbol_set_frag (line_label
, frag_now
);
1208 S_SET_VALUE (line_label
, frag_now_fix ());
1209 if (S_GET_STORAGE_CLASS (line_label
) != C_EXT
)
1210 S_SET_STORAGE_CLASS (line_label
, C_LABEL
);
1215 /* [symbol] .space space_in_bits
1216 [symbol] .bes space_in_bits
1217 BES puts the symbol at the *last* word allocated
1219 cribbed from s_space. */
1222 tic54x_space (int arg
)
1228 int bits_per_byte
= (OCTETS_PER_BYTE
* 8);
1230 symbolS
*label
= line_label
;
1233 ILLEGAL_WITHIN_STRUCT ();
1235 #ifdef md_flush_pending_output
1236 md_flush_pending_output ();
1239 /* Read the bit count. */
1242 /* Some expressions are unresolvable until later in the assembly pass;
1243 postpone until relaxation/fixup. we also have to postpone if a previous
1244 partial allocation has not been completed yet. */
1245 if (expn
.X_op
!= O_constant
|| frag_bit_offset (frag_now
, now_seg
) == -1)
1247 struct bit_info
*bi
= xmalloc (sizeof (struct bit_info
));
1252 p
= frag_var (rs_machine_dependent
,
1253 65536 * 2, 1, (relax_substateT
) 0,
1254 make_expr_symbol (&expn
), (offsetT
) 0,
1262 /* Reduce the required size by any bit offsets currently left over
1263 from a previous .space/.bes/.field directive. */
1264 bit_offset
= frag_now
->tc_frag_data
;
1265 if (bit_offset
!= 0 && bit_offset
< 16)
1267 int spare_bits
= bits_per_byte
- bit_offset
;
1269 if (spare_bits
>= expn
.X_add_number
)
1271 /* Don't have to do anything; sufficient bits have already been
1272 allocated; just point the label to the right place. */
1275 symbol_set_frag (label
, frag_now
);
1276 S_SET_VALUE (label
, frag_now_fix () - 1);
1279 frag_now
->tc_frag_data
+= expn
.X_add_number
;
1282 expn
.X_add_number
-= spare_bits
;
1283 /* Set the label to point to the first word allocated, which in this
1284 case is the previous word, which was only partially filled. */
1285 if (!bes
&& label
!= NULL
)
1287 symbol_set_frag (label
, frag_now
);
1288 S_SET_VALUE (label
, frag_now_fix () - 1);
1292 /* Convert bits to bytes/words and octets, rounding up. */
1293 words
= ((expn
.X_add_number
+ bits_per_byte
- 1) / bits_per_byte
);
1294 /* How many do we have left over? */
1295 bit_offset
= expn
.X_add_number
% bits_per_byte
;
1296 octets
= words
* OCTETS_PER_BYTE
;
1299 as_warn (_(".space/.bes repeat count is negative, ignored"));
1302 else if (octets
== 0)
1304 as_warn (_(".space/.bes repeat count is zero, ignored"));
1308 /* If we are in the absolute section, just bump the offset. */
1309 if (now_seg
== absolute_section
)
1311 abs_section_offset
+= words
;
1312 if (bes
&& label
!= NULL
)
1313 S_SET_VALUE (label
, abs_section_offset
- 1);
1314 frag_now
->tc_frag_data
= bit_offset
;
1319 p
= frag_var (rs_fill
, 1, 1,
1320 (relax_substateT
) 0, (symbolS
*) 0,
1321 (offsetT
) octets
, (char *) 0);
1323 /* Make note of how many bits of this word we've allocated so far. */
1324 frag_now
->tc_frag_data
= bit_offset
;
1326 /* .bes puts label at *last* word allocated. */
1327 if (bes
&& label
!= NULL
)
1329 symbol_set_frag (label
, frag_now
);
1330 S_SET_VALUE (label
, frag_now_fix () - 1);
1338 demand_empty_rest_of_line ();
1341 /* [symbol] .usect "section-name", size-in-words
1342 [, [blocking-flag] [, alignment-flag]]
1344 Uninitialized section.
1345 Non-zero blocking means that if the section would cross a page (128-word)
1346 boundary, it will be page-aligned.
1347 Non-zero alignment aligns on a longword boundary.
1349 Has no effect on the current section. */
1352 tic54x_usect (int x ATTRIBUTE_UNUSED
)
1359 int size
, blocking_flag
, alignment_flag
;
1361 subsegT current_subseg
;
1364 ILLEGAL_WITHIN_STRUCT ();
1366 current_seg
= now_seg
; /* Save current seg. */
1367 current_subseg
= now_subseg
; /* Save current subseg. */
1369 if (*input_line_pointer
== '"')
1370 input_line_pointer
++;
1371 section_name
= input_line_pointer
;
1372 c
= get_symbol_end (); /* Get terminator. */
1373 input_line_pointer
++; /* Skip null symbol terminator. */
1374 name
= xmalloc (input_line_pointer
- section_name
+ 1);
1375 strcpy (name
, section_name
);
1377 if (*input_line_pointer
== ',')
1378 ++input_line_pointer
;
1381 as_bad (_("Missing size argument"));
1382 ignore_rest_of_line ();
1386 size
= get_absolute_expression ();
1388 /* Read a possibly present third argument (blocking flag). */
1389 if (*input_line_pointer
== ',')
1391 ++input_line_pointer
;
1392 if (*input_line_pointer
!= ',')
1393 blocking_flag
= get_absolute_expression ();
1397 /* Read a possibly present fourth argument (alignment flag). */
1398 if (*input_line_pointer
== ',')
1400 ++input_line_pointer
;
1401 alignment_flag
= get_absolute_expression ();
1407 blocking_flag
= alignment_flag
= 0;
1409 seg
= subseg_new (name
, 0);
1410 flags
= bfd_get_section_flags (stdoutput
, seg
) | SEC_ALLOC
;
1414 /* s_align eats end of line; restore it. */
1416 --input_line_pointer
;
1419 if (line_label
!= NULL
)
1421 S_SET_SEGMENT (line_label
, seg
);
1422 symbol_set_frag (line_label
, frag_now
);
1423 S_SET_VALUE (line_label
, frag_now_fix ());
1424 /* Set scl to label, since that's what TI does. */
1425 if (S_GET_STORAGE_CLASS (line_label
) != C_EXT
)
1426 S_SET_STORAGE_CLASS (line_label
, C_LABEL
);
1429 seg_info (seg
)->bss
= 1; /* Uninitialized data. */
1431 p
= frag_var (rs_fill
, 1, 1,
1432 (relax_substateT
) 0, (symbolS
*) line_label
,
1433 size
* OCTETS_PER_BYTE
, (char *) 0);
1437 flags
|= SEC_TIC54X_BLOCK
;
1439 if (!bfd_set_section_flags (stdoutput
, seg
, flags
))
1440 as_warn (_("Error setting flags for \"%s\": %s"), name
,
1441 bfd_errmsg (bfd_get_error ()));
1443 subseg_set (current_seg
, current_subseg
); /* Restore current seg. */
1444 demand_empty_rest_of_line ();
1447 static enum cpu_version
1448 lookup_version (const char *ver
)
1450 enum cpu_version version
= VNONE
;
1452 if (ver
[0] == '5' && ver
[1] == '4')
1454 if (strlen (ver
) == 3
1455 && (ver
[2] == '1' || ver
[2] == '2' || ver
[2] == '3'
1456 || ver
[2] == '5' || ver
[2] == '8' || ver
[2] == '9'))
1457 version
= ver
[2] - '0';
1458 else if (strlen (ver
) == 5
1459 && TOUPPER (ver
[3]) == 'L'
1460 && TOUPPER (ver
[4]) == 'P'
1461 && (ver
[2] == '5' || ver
[2] == '6'))
1462 version
= ver
[2] - '0' + 10;
1469 set_cpu (enum cpu_version version
)
1472 if (version
== V545LP
|| version
== V546LP
)
1474 symbolS
*symbolP
= symbol_new ("__allow_lp", absolute_section
,
1475 (valueT
) 1, &zero_address_frag
);
1476 SF_SET_LOCAL (symbolP
);
1477 symbol_table_insert (symbolP
);
1481 /* .version cpu-version
1482 cpu-version may be one of the following:
1492 This is for compatibility only. It currently has no affect on assembly. */
1493 static int cpu_needs_set
= 1;
1496 tic54x_version (int x ATTRIBUTE_UNUSED
)
1498 enum cpu_version version
= VNONE
;
1499 enum cpu_version old_version
= cpu
;
1503 ILLEGAL_WITHIN_STRUCT ();
1506 ver
= input_line_pointer
;
1507 while (!is_end_of_line
[(int) *input_line_pointer
])
1508 ++input_line_pointer
;
1509 c
= *input_line_pointer
;
1510 *input_line_pointer
= 0;
1512 version
= lookup_version (ver
);
1514 if (cpu
!= VNONE
&& cpu
!= version
)
1515 as_warn (_("CPU version has already been set"));
1517 if (version
== VNONE
)
1519 as_bad (_("Unrecognized version '%s'"), ver
);
1520 ignore_rest_of_line ();
1523 else if (assembly_begun
&& version
!= old_version
)
1525 as_bad (_("Changing of CPU version on the fly not supported"));
1526 ignore_rest_of_line ();
1532 *input_line_pointer
= c
;
1533 demand_empty_rest_of_line ();
1536 /* 'f' = float, 'x' = xfloat, 'd' = double, 'l' = ldouble. */
1539 tic54x_float_cons (int type
)
1541 if (current_stag
!= 0)
1542 tic54x_struct_field ('f');
1544 #ifdef md_flush_pending_output
1545 md_flush_pending_output ();
1548 /* Align to long word boundary (4 octets) unless it's ".xfloat". */
1551 frag_align (2, 0, 2);
1552 /* If there's a label, assign it to the first allocated word. */
1553 if (line_label
!= NULL
)
1555 symbol_set_frag (line_label
, frag_now
);
1556 S_SET_VALUE (line_label
, frag_now_fix ());
1563 /* The argument is capitalized if it should be zero-terminated
1564 's' is normal string with upper 8-bits zero-filled, 'p' is packed.
1565 Code copied from stringer, and slightly modified so that strings are packed
1566 and encoded into the correct octets. */
1569 tic54x_stringer (int type
)
1572 int append_zero
= type
== 'S' || type
== 'P';
1573 int packed
= type
== 'p' || type
== 'P';
1574 int last_char
= -1; /* Packed strings need two bytes at a time to encode. */
1576 if (current_stag
!= NULL
)
1578 tic54x_struct_field ('*');
1582 #ifdef md_flush_pending_output
1583 md_flush_pending_output ();
1586 c
= ','; /* Do loop. */
1590 switch (*input_line_pointer
)
1594 unsigned short value
= get_absolute_expression ();
1595 FRAG_APPEND_1_CHAR ( value
& 0xFF);
1596 FRAG_APPEND_1_CHAR ((value
>> 8) & 0xFF);
1600 ++input_line_pointer
; /* -> 1st char of string. */
1601 while (is_a_char (c
= next_char_of_string ()))
1605 FRAG_APPEND_1_CHAR (c
);
1606 FRAG_APPEND_1_CHAR (0);
1610 /* Packed strings are filled MS octet first. */
1611 if (last_char
== -1)
1615 FRAG_APPEND_1_CHAR (c
);
1616 FRAG_APPEND_1_CHAR (last_char
);
1623 if (packed
&& last_char
!= -1)
1625 FRAG_APPEND_1_CHAR (0);
1626 FRAG_APPEND_1_CHAR (last_char
);
1631 FRAG_APPEND_1_CHAR (0);
1632 FRAG_APPEND_1_CHAR (0);
1635 know (input_line_pointer
[-1] == '\"');
1639 c
= *input_line_pointer
;
1640 if (!is_end_of_line
[c
])
1641 ++input_line_pointer
;
1644 /* Finish up any leftover packed string. */
1645 if (packed
&& last_char
!= -1)
1647 FRAG_APPEND_1_CHAR (0);
1648 FRAG_APPEND_1_CHAR (last_char
);
1650 demand_empty_rest_of_line ();
1654 tic54x_p2align (int arg ATTRIBUTE_UNUSED
)
1656 as_bad (_("p2align not supported on this target"));
1660 tic54x_align_words (int arg
)
1662 /* Only ".align" with no argument is allowed within .struct/.union. */
1665 if (!is_end_of_line
[(int) *input_line_pointer
])
1668 as_warn (_("Argument to .even ignored"));
1670 count
= get_absolute_expression ();
1673 if (current_stag
!= NULL
&& arg
== 128)
1675 if (current_stag
->current_bitfield_offset
!= 0)
1677 current_stag
->current_bitfield_offset
= 0;
1678 ++abs_section_offset
;
1680 demand_empty_rest_of_line ();
1684 ILLEGAL_WITHIN_STRUCT ();
1686 s_align_bytes (count
<< 1);
1689 /* Initialize multiple-bit fields withing a single word of memory. */
1692 tic54x_field (int ignore ATTRIBUTE_UNUSED
)
1698 symbolS
*label
= line_label
;
1700 if (current_stag
!= NULL
)
1702 tic54x_struct_field ('.');
1706 input_line_pointer
= parse_expression (input_line_pointer
, &expn
);
1708 if (*input_line_pointer
== ',')
1710 ++input_line_pointer
;
1711 size
= get_absolute_expression ();
1712 if (size
< 1 || size
> 32)
1714 as_bad (_("Invalid field size, must be from 1 to 32"));
1715 ignore_rest_of_line ();
1720 /* Truncate values to the field width. */
1721 if (expn
.X_op
!= O_constant
)
1723 /* If the expression value is relocatable, the field size *must*
1727 as_bad (_("field size must be 16 when value is relocatable"));
1728 ignore_rest_of_line ();
1732 frag_now
->tc_frag_data
= 0;
1733 emit_expr (&expn
, 2);
1737 unsigned long fmask
= (size
== 32) ? 0xFFFFFFFF : (1ul << size
) - 1;
1739 value
= expn
.X_add_number
;
1740 expn
.X_add_number
&= fmask
;
1741 if (value
!= (valueT
) expn
.X_add_number
)
1742 as_warn (_("field value truncated"));
1743 value
= expn
.X_add_number
;
1744 /* Bits are stored MS first. */
1747 frag_now
->tc_frag_data
= 0;
1749 md_number_to_chars (p
, (value
>> (size
- 16)) & 0xFFFF, 2);
1754 int bit_offset
= frag_bit_offset (frag_now
, now_seg
);
1756 fragS
*alloc_frag
= bit_offset_frag (frag_now
, now_seg
);
1757 if (bit_offset
== -1)
1759 struct bit_info
*bi
= xmalloc (sizeof (struct bit_info
));
1760 /* We don't know the previous offset at this time, so store the
1761 info we need and figure it out later. */
1762 expressionS size_exp
;
1764 size_exp
.X_op
= O_constant
;
1765 size_exp
.X_add_number
= size
;
1767 bi
->type
= TYPE_FIELD
;
1769 p
= frag_var (rs_machine_dependent
,
1770 4, 1, (relax_substateT
) 0,
1771 make_expr_symbol (&size_exp
), (offsetT
) 0,
1775 else if (bit_offset
== 0 || bit_offset
+ size
> 16)
1777 /* Align a new field. */
1779 frag_now
->tc_frag_data
= 0;
1780 alloc_frag
= frag_now
;
1784 /* Put the new value entirely within the existing one. */
1785 p
= alloc_frag
== frag_now
?
1786 frag_now
->fr_literal
+ frag_now_fix_octets () - 2 :
1787 alloc_frag
->fr_literal
;
1790 symbol_set_frag (label
, alloc_frag
);
1791 if (alloc_frag
== frag_now
)
1792 S_SET_VALUE (label
, frag_now_fix () - 1);
1796 value
<<= 16 - alloc_frag
->tc_frag_data
- size
;
1798 /* OR in existing value. */
1799 if (alloc_frag
->tc_frag_data
)
1800 value
|= ((unsigned short) p
[1] << 8) | p
[0];
1801 md_number_to_chars (p
, value
, 2);
1802 alloc_frag
->tc_frag_data
+= size
;
1803 if (alloc_frag
->tc_frag_data
== 16)
1804 alloc_frag
->tc_frag_data
= 0;
1808 demand_empty_rest_of_line ();
1811 /* Ideally, we want to check SEC_LOAD and SEC_HAS_CONTENTS, but those aren't
1812 available yet. seg_info ()->bss is the next best thing. */
1815 tic54x_initialized_section (segT seg
)
1817 return !seg_info (seg
)->bss
;
1820 /* .clink ["section name"]
1822 Marks the section as conditionally linked (link only if contents are
1823 referenced elsewhere.
1824 Without a name, refers to the current initialized section.
1825 Name is required for uninitialized sections. */
1828 tic54x_clink (int ignored ATTRIBUTE_UNUSED
)
1832 ILLEGAL_WITHIN_STRUCT ();
1834 if (*input_line_pointer
== '\"')
1836 char *section_name
= ++input_line_pointer
;
1839 while (is_a_char (next_char_of_string ()))
1841 know (input_line_pointer
[-1] == '\"');
1842 input_line_pointer
[-1] = 0;
1843 name
= xmalloc (input_line_pointer
- section_name
+ 1);
1844 strcpy (name
, section_name
);
1846 seg
= bfd_get_section_by_name (stdoutput
, name
);
1849 as_bad (_("Unrecognized section '%s'"), section_name
);
1850 ignore_rest_of_line ();
1856 if (!tic54x_initialized_section (seg
))
1858 as_bad (_("Current section is unitialized, "
1859 "section name required for .clink"));
1860 ignore_rest_of_line ();
1865 seg
->flags
|= SEC_TIC54X_CLINK
;
1867 demand_empty_rest_of_line ();
1870 /* Change the default include directory to be the current source file's
1871 directory, instead of the current working directory. If DOT is non-zero,
1872 set to "." instead. */
1875 tic54x_set_default_include (int dot
)
1885 as_where (&curfile
, &lineno
);
1886 dir
= strcpy (xmalloc (strlen (curfile
) + 1), curfile
);
1887 tmp
= strrchr (dir
, '/');
1895 if (include_dir_count
== 0)
1897 include_dirs
= (char **) xmalloc (sizeof (*include_dirs
));
1898 include_dir_count
= 1;
1900 include_dirs
[0] = dir
;
1901 if (len
> include_dir_maxlen
)
1902 include_dir_maxlen
= len
;
1904 else if (include_dirs
!= NULL
)
1905 include_dirs
[0] = ".";
1908 /* .include "filename" | filename
1909 .copy "filename" | filename
1911 FIXME 'include' file should be omitted from any output listing,
1912 'copy' should be included in any output listing
1913 FIXME -- prevent any included files from changing listing (compat only)
1914 FIXME -- need to include source file directory in search path; what's a
1915 good way to do this?
1917 Entering/exiting included/copied file clears all local labels. */
1920 tic54x_include (int ignored ATTRIBUTE_UNUSED
)
1922 char newblock
[] = " .newblock\n";
1927 ILLEGAL_WITHIN_STRUCT ();
1931 if (*input_line_pointer
== '"')
1933 filename
= demand_copy_C_string (&len
);
1934 demand_empty_rest_of_line ();
1938 filename
= input_line_pointer
;
1939 while (!is_end_of_line
[(int) *input_line_pointer
])
1940 ++input_line_pointer
;
1941 c
= *input_line_pointer
;
1942 *input_line_pointer
= '\0';
1943 filename
= strcpy (xmalloc (strlen (filename
) + 1), filename
);
1944 *input_line_pointer
= c
;
1945 demand_empty_rest_of_line ();
1947 /* Insert a partial line with the filename (for the sake of s_include)
1949 The included file will be inserted before the newblock, so that the
1950 newblock is executed after the included file is processed. */
1951 input
= xmalloc (sizeof (newblock
) + strlen (filename
) + 4);
1952 sprintf (input
, "\"%s\"\n%s", filename
, newblock
);
1953 input_scrub_insert_line (input
);
1955 tic54x_clear_local_labels (0);
1957 tic54x_set_default_include (0);
1963 tic54x_message (int type
)
1969 ILLEGAL_WITHIN_STRUCT ();
1971 if (*input_line_pointer
== '"')
1972 msg
= demand_copy_C_string (&len
);
1975 msg
= input_line_pointer
;
1976 while (!is_end_of_line
[(int) *input_line_pointer
])
1977 ++input_line_pointer
;
1978 c
= *input_line_pointer
;
1979 *input_line_pointer
= 0;
1980 msg
= strcpy (xmalloc (strlen (msg
) + 1), msg
);
1981 *input_line_pointer
= c
;
1987 as_tsktsk ("%s", msg
);
1990 as_warn ("%s", msg
);
1997 demand_empty_rest_of_line ();
2001 Define a special symbol that refers to the loadtime address rather than the
2002 runtime address within the current section.
2004 This symbol gets a special storage class so that when it is resolved, it is
2005 resolved relative to the load address (lma) of the section rather than the
2006 run address (vma). */
2009 tic54x_label (int ignored ATTRIBUTE_UNUSED
)
2011 char *name
= input_line_pointer
;
2015 ILLEGAL_WITHIN_STRUCT ();
2017 c
= get_symbol_end ();
2018 symbolP
= colon (name
);
2019 S_SET_STORAGE_CLASS (symbolP
, C_STATLAB
);
2021 *input_line_pointer
= c
;
2022 demand_empty_rest_of_line ();
2026 Install all memory-mapped register names into the symbol table as
2027 absolute local symbols. */
2030 tic54x_mmregs (int ignored ATTRIBUTE_UNUSED
)
2034 ILLEGAL_WITHIN_STRUCT ();
2036 for (sym
= (symbol
*) mmregs
; sym
->name
; sym
++)
2038 symbolS
*symbolP
= symbol_new (sym
->name
, absolute_section
,
2039 (valueT
) sym
->value
, &zero_address_frag
);
2040 SF_SET_LOCAL (symbolP
);
2041 symbol_table_insert (symbolP
);
2046 Count defaults to 1024. */
2049 tic54x_loop (int count
)
2051 ILLEGAL_WITHIN_STRUCT ();
2054 if (!is_end_of_line
[(int) *input_line_pointer
])
2055 count
= get_absolute_expression ();
2057 do_repeat (count
, "LOOP", "ENDLOOP");
2060 /* Normally, endloop gets eaten by the preceding loop. */
2063 tic54x_endloop (int ignore ATTRIBUTE_UNUSED
)
2065 as_bad (_("ENDLOOP without corresponding LOOP"));
2066 ignore_rest_of_line ();
2069 /* .break [condition]. */
2072 tic54x_break (int ignore ATTRIBUTE_UNUSED
)
2076 ILLEGAL_WITHIN_STRUCT ();
2079 if (!is_end_of_line
[(int) *input_line_pointer
])
2080 cond
= get_absolute_expression ();
2083 end_repeat (substitution_line
? 1 : 0);
2087 set_address_mode (int mode
)
2090 if (mode
== far_mode
)
2092 symbolS
*symbolP
= symbol_new ("__allow_far", absolute_section
,
2093 (valueT
) 1, &zero_address_frag
);
2094 SF_SET_LOCAL (symbolP
);
2095 symbol_table_insert (symbolP
);
2099 static int address_mode_needs_set
= 1;
2102 tic54x_address_mode (int mode
)
2104 if (assembly_begun
&& amode
!= (unsigned) mode
)
2106 as_bad (_("Mixing of normal and extended addressing not supported"));
2107 ignore_rest_of_line ();
2110 if (mode
== far_mode
&& cpu
!= VNONE
&& cpu
!= V548
&& cpu
!= V549
)
2112 as_bad (_("Extended addressing not supported on the specified CPU"));
2113 ignore_rest_of_line ();
2117 set_address_mode (mode
);
2118 demand_empty_rest_of_line ();
2121 /* .sblock "section"|section [,...,"section"|section]
2122 Designate initialized sections for blocking. */
2125 tic54x_sblock (int ignore ATTRIBUTE_UNUSED
)
2129 ILLEGAL_WITHIN_STRUCT ();
2136 if (*input_line_pointer
== '"')
2140 name
= demand_copy_C_string (&len
);
2144 char *section_name
= input_line_pointer
;
2146 c
= get_symbol_end ();
2147 name
= xmalloc (strlen (section_name
) + 1);
2148 strcpy (name
, section_name
);
2149 *input_line_pointer
= c
;
2152 seg
= bfd_get_section_by_name (stdoutput
, name
);
2155 as_bad (_("Unrecognized section '%s'"), name
);
2156 ignore_rest_of_line ();
2159 else if (!tic54x_initialized_section (seg
))
2161 as_bad (_(".sblock may be used for initialized sections only"));
2162 ignore_rest_of_line ();
2165 seg
->flags
|= SEC_TIC54X_BLOCK
;
2167 c
= *input_line_pointer
;
2168 if (!is_end_of_line
[(int) c
])
2169 ++input_line_pointer
;
2172 demand_empty_rest_of_line ();
2175 /* symbol .set value
2178 value must be defined externals; no forward-referencing allowed
2179 symbols assigned with .set/.equ may not be redefined. */
2182 tic54x_set (int ignore ATTRIBUTE_UNUSED
)
2187 ILLEGAL_WITHIN_STRUCT ();
2191 as_bad (_("Symbol missing for .set/.equ"));
2192 ignore_rest_of_line ();
2195 name
= xstrdup (S_GET_NAME (line_label
));
2197 if ((symbolP
= symbol_find (name
)) == NULL
2198 && (symbolP
= md_undefined_symbol (name
)) == NULL
)
2200 symbolP
= symbol_new (name
, absolute_section
, 0, &zero_address_frag
);
2201 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
2204 S_SET_DATA_TYPE (symbolP
, T_INT
);
2205 S_SET_SEGMENT (symbolP
, absolute_section
);
2206 symbol_table_insert (symbolP
);
2207 pseudo_set (symbolP
);
2208 demand_empty_rest_of_line ();
2213 List false conditional blocks. */
2216 tic54x_fclist (int show
)
2219 listing
&= ~LISTING_NOCOND
;
2221 listing
|= LISTING_NOCOND
;
2222 demand_empty_rest_of_line ();
2226 tic54x_sslist (int show
)
2228 ILLEGAL_WITHIN_STRUCT ();
2230 listing_sslist
= show
;
2233 /* .var SYM[,...,SYMN]
2234 Define a substitution string to be local to a macro. */
2237 tic54x_var (int ignore ATTRIBUTE_UNUSED
)
2239 static char empty
[] = "";
2243 ILLEGAL_WITHIN_STRUCT ();
2245 if (macro_level
== 0)
2247 as_bad (_(".var may only be used within a macro definition"));
2248 ignore_rest_of_line ();
2253 if (!ISALPHA (*input_line_pointer
))
2255 as_bad (_("Substitution symbols must begin with a letter"));
2256 ignore_rest_of_line ();
2259 name
= input_line_pointer
;
2260 c
= get_symbol_end ();
2261 /* .var symbols start out with a null string. */
2262 name
= strcpy (xmalloc (strlen (name
) + 1), name
);
2263 hash_insert (subsym_hash
[macro_level
], name
, empty
);
2264 *input_line_pointer
= c
;
2267 ++input_line_pointer
;
2268 if (is_end_of_line
[(int) *input_line_pointer
])
2269 c
= *input_line_pointer
;
2274 demand_empty_rest_of_line ();
2277 /* .mlib <macro library filename>
2279 Macro libraries are archived (standard AR-format) text macro definitions
2280 Expand the file and include it.
2282 FIXME need to try the source file directory as well. */
2285 tic54x_mlib (int ignore ATTRIBUTE_UNUSED
)
2292 ILLEGAL_WITHIN_STRUCT ();
2294 /* Parse the filename. */
2295 if (*input_line_pointer
== '"')
2297 if ((filename
= demand_copy_C_string (&len
)) == NULL
)
2304 while (!is_end_of_line
[(int) *input_line_pointer
]
2305 && !ISSPACE (*input_line_pointer
))
2307 obstack_1grow (¬es
, *input_line_pointer
);
2308 ++input_line_pointer
;
2311 obstack_1grow (¬es
, '\0');
2312 filename
= obstack_finish (¬es
);
2314 demand_empty_rest_of_line ();
2316 tic54x_set_default_include (0);
2317 path
= xmalloc ((unsigned long) len
+ include_dir_maxlen
+ 5);
2319 for (i
= 0; i
< include_dir_count
; i
++)
2323 strcpy (path
, include_dirs
[i
]);
2325 strcat (path
, filename
);
2326 if ((try = fopen (path
, "r")) != NULL
)
2333 if (i
>= include_dir_count
)
2339 /* FIXME: if path is found, malloc'd storage is not freed. Of course, this
2340 happens all over the place, and since the assembler doesn't usually keep
2341 running for a very long time, it really doesn't matter. */
2342 register_dependency (path
);
2344 /* Expand all archive entries to temporary files and include them. */
2345 abfd
= bfd_openr (path
, NULL
);
2348 as_bad (_("can't open macro library file '%s' for reading: %s"),
2349 path
, bfd_errmsg (bfd_get_error ()));
2350 ignore_rest_of_line ();
2353 if (!bfd_check_format (abfd
, bfd_archive
))
2355 as_bad (_("File '%s' not in macro archive format"), path
);
2356 ignore_rest_of_line ();
2360 /* Open each BFD as binary (it should be straight ASCII text). */
2361 for (mbfd
= bfd_openr_next_archived_file (abfd
, NULL
);
2362 mbfd
!= NULL
; mbfd
= bfd_openr_next_archived_file (abfd
, mbfd
))
2364 /* Get a size at least as big as the archive member. */
2365 bfd_size_type size
= bfd_get_size (mbfd
);
2366 char *buf
= xmalloc (size
);
2367 char *fname
= tmpnam (NULL
);
2370 /* We're not sure how big it is, but it will be smaller than "size". */
2371 size
= bfd_bread (buf
, size
, mbfd
);
2373 /* Write to a temporary file, then use s_include to include it
2375 ftmp
= fopen (fname
, "w+b");
2376 fwrite ((void *) buf
, size
, 1, ftmp
);
2377 if (size
== 0 || buf
[size
- 1] != '\n')
2378 fwrite ("\n", 1, 1, ftmp
);
2381 input_scrub_insert_file (fname
);
2386 const pseudo_typeS md_pseudo_table
[] =
2388 { "algebraic", s_ignore
, 0 },
2389 { "align" , tic54x_align_words
, 128 },
2390 { "ascii" , tic54x_stringer
, 'p' },
2391 { "asciz" , tic54x_stringer
, 'P' },
2392 { "even" , tic54x_align_words
, 2 },
2393 { "asg" , tic54x_asg
, 0 },
2394 { "eval" , tic54x_eval
, 0 },
2395 { "bss" , tic54x_bss
, 0 },
2396 { "byte" , tic54x_cons
, 'b' },
2397 { "ubyte" , tic54x_cons
, 'B' },
2398 { "char" , tic54x_cons
, 'c' },
2399 { "uchar" , tic54x_cons
, 'C' },
2400 { "clink" , tic54x_clink
, 0 },
2401 { "c_mode" , tic54x_address_mode
, c_mode
},
2402 { "copy" , tic54x_include
, 'c' },
2403 { "include" , tic54x_include
, 'i' },
2404 { "data" , tic54x_sect
, 'd' },
2405 { "double" , tic54x_float_cons
, 'd' },
2406 { "ldouble" , tic54x_float_cons
, 'l' },
2407 { "drlist" , s_ignore
, 0 },
2408 { "drnolist" , s_ignore
, 0 },
2409 { "emsg" , tic54x_message
, 'e' },
2410 { "mmsg" , tic54x_message
, 'm' },
2411 { "wmsg" , tic54x_message
, 'w' },
2412 { "far_mode" , tic54x_address_mode
, far_mode
},
2413 { "fclist" , tic54x_fclist
, 1 },
2414 { "fcnolist" , tic54x_fclist
, 0 },
2415 { "field" , tic54x_field
, -1 },
2416 { "float" , tic54x_float_cons
, 'f' },
2417 { "xfloat" , tic54x_float_cons
, 'x' },
2418 { "global" , tic54x_global
, 'g' },
2419 { "def" , tic54x_global
, 'd' },
2420 { "ref" , tic54x_global
, 'r' },
2421 { "half" , tic54x_cons
, 'h' },
2422 { "uhalf" , tic54x_cons
, 'H' },
2423 { "short" , tic54x_cons
, 's' },
2424 { "ushort" , tic54x_cons
, 'S' },
2425 { "if" , s_if
, (int) O_ne
},
2426 { "elseif" , s_elseif
, (int) O_ne
},
2427 { "else" , s_else
, 0 },
2428 { "endif" , s_endif
, 0 },
2429 { "int" , tic54x_cons
, 'i' },
2430 { "uint" , tic54x_cons
, 'I' },
2431 { "word" , tic54x_cons
, 'w' },
2432 { "uword" , tic54x_cons
, 'W' },
2433 { "label" , tic54x_label
, 0 }, /* Loadtime
2435 { "length" , s_ignore
, 0 },
2436 { "width" , s_ignore
, 0 },
2437 { "long" , tic54x_cons
, 'l' },
2438 { "ulong" , tic54x_cons
, 'L' },
2439 { "xlong" , tic54x_cons
, 'x' },
2440 { "loop" , tic54x_loop
, 1024 },
2441 { "break" , tic54x_break
, 0 },
2442 { "endloop" , tic54x_endloop
, 0 },
2443 { "mlib" , tic54x_mlib
, 0 },
2444 { "mlist" , s_ignore
, 0 },
2445 { "mnolist" , s_ignore
, 0 },
2446 { "mmregs" , tic54x_mmregs
, 0 },
2447 { "newblock" , tic54x_clear_local_labels
, 0 },
2448 { "option" , s_ignore
, 0 },
2449 { "p2align" , tic54x_p2align
, 0 },
2450 { "sblock" , tic54x_sblock
, 0 },
2451 { "sect" , tic54x_sect
, '*' },
2452 { "set" , tic54x_set
, 0 },
2453 { "equ" , tic54x_set
, 0 },
2454 { "space" , tic54x_space
, 0 },
2455 { "bes" , tic54x_space
, 1 },
2456 { "sslist" , tic54x_sslist
, 1 },
2457 { "ssnolist" , tic54x_sslist
, 0 },
2458 { "string" , tic54x_stringer
, 's' },
2459 { "pstring" , tic54x_stringer
, 'p' },
2460 { "struct" , tic54x_struct
, 0 },
2461 { "tag" , tic54x_tag
, 0 },
2462 { "endstruct", tic54x_endstruct
, 0 },
2463 { "tab" , s_ignore
, 0 },
2464 { "text" , tic54x_sect
, 't' },
2465 { "union" , tic54x_struct
, 1 },
2466 { "endunion" , tic54x_endstruct
, 1 },
2467 { "usect" , tic54x_usect
, 0 },
2468 { "var" , tic54x_var
, 0 },
2469 { "version" , tic54x_version
, 0 },
2474 md_parse_option (int c
, char *arg
)
2480 case OPTION_COFF_VERSION
:
2482 int version
= atoi (arg
);
2484 if (version
!= 0 && version
!= 1 && version
!= 2)
2485 as_fatal (_("Bad COFF version '%s'"), arg
);
2486 /* FIXME -- not yet implemented. */
2489 case OPTION_CPU_VERSION
:
2491 cpu
= lookup_version (arg
);
2494 as_fatal (_("Bad CPU version '%s'"), arg
);
2497 case OPTION_ADDRESS_MODE
:
2499 address_mode_needs_set
= 1;
2501 case OPTION_STDERR_TO_FILE
:
2503 char *filename
= arg
;
2504 FILE *fp
= fopen (filename
, "w+");
2507 as_fatal (_("Can't redirect stderr to the file '%s'"), filename
);
2509 if ((fp
= freopen (filename
, "w+", stderr
)) == NULL
)
2510 as_fatal (_("Can't redirect stderr to the file '%s'"), filename
);
2518 /* Create a "local" substitution string hash table for a new macro level
2519 Some docs imply that macros have to use .newblock in order to be able
2520 to re-use a local label. We effectively do an automatic .newblock by
2521 deleting the local label hash between macro invocations. */
2524 tic54x_macro_start (void)
2527 subsym_hash
[macro_level
] = hash_new ();
2528 local_label_hash
[macro_level
] = hash_new ();
2532 tic54x_macro_info (const macro_entry
*macro
)
2534 const formal_entry
*entry
;
2536 /* Put the formal args into the substitution symbol table. */
2537 for (entry
= macro
->formals
; entry
; entry
= entry
->next
)
2539 char *name
= strncpy (xmalloc (entry
->name
.len
+ 1),
2540 entry
->name
.ptr
, entry
->name
.len
);
2541 char *value
= strncpy (xmalloc (entry
->actual
.len
+ 1),
2542 entry
->actual
.ptr
, entry
->actual
.len
);
2544 name
[entry
->name
.len
] = '\0';
2545 value
[entry
->actual
.len
] = '\0';
2546 hash_insert (subsym_hash
[macro_level
], name
, value
);
2550 /* Get rid of this macro's .var's, arguments, and local labels. */
2553 tic54x_macro_end (void)
2555 hash_die (subsym_hash
[macro_level
]);
2556 subsym_hash
[macro_level
] = NULL
;
2557 hash_die (local_label_hash
[macro_level
]);
2558 local_label_hash
[macro_level
] = NULL
;
2563 subsym_symlen (char *a
, char *ignore ATTRIBUTE_UNUSED
)
2568 /* Compare symbol A to string B. */
2571 subsym_symcmp (char *a
, char *b
)
2573 return strcmp (a
, b
);
2576 /* Return the index of the first occurrence of B in A, or zero if none
2577 assumes b is an integer char value as a string. Index is one-based. */
2580 subsym_firstch (char *a
, char *b
)
2583 char *tmp
= strchr (a
, val
);
2585 return tmp
? tmp
- a
+ 1 : 0;
2588 /* Similar to firstch, but returns index of last occurrence of B in A. */
2591 subsym_lastch (char *a
, char *b
)
2594 char *tmp
= strrchr (a
, val
);
2596 return tmp
? tmp
- a
+ 1 : 0;
2599 /* Returns 1 if string A is defined in the symbol table (NOT the substitution
2603 subsym_isdefed (char *a
, char *ignore ATTRIBUTE_UNUSED
)
2605 symbolS
*symbolP
= symbol_find (a
);
2607 return symbolP
!= NULL
;
2610 /* Assign first member of comma-separated list B (e.g. "1,2,3") to the symbol
2611 A, or zero if B is a null string. Both arguments *must* be substitution
2612 symbols, unsubstituted. */
2615 subsym_ismember (char *sym
, char *list
)
2617 char *elem
, *ptr
, *listv
;
2622 listv
= subsym_lookup (list
, macro_level
);
2625 as_bad (_("Undefined substitution symbol '%s'"), list
);
2626 ignore_rest_of_line ();
2630 ptr
= elem
= xmalloc (strlen (listv
) + 1);
2631 strcpy (elem
, listv
);
2632 while (*ptr
&& *ptr
!= ',')
2636 subsym_create_or_replace (sym
, elem
);
2638 /* Reassign the list. */
2639 subsym_create_or_replace (list
, ptr
);
2641 /* Assume this value, docs aren't clear. */
2645 /* Return zero if not a constant; otherwise:
2653 subsym_iscons (char *a
, char *ignore ATTRIBUTE_UNUSED
)
2657 parse_expression (a
, &expn
);
2659 if (expn
.X_op
== O_constant
)
2661 int len
= strlen (a
);
2663 switch (TOUPPER (a
[len
- 1]))
2676 /* No suffix; either octal, hex, or decimal. */
2677 if (*a
== '0' && len
> 1)
2679 if (TOUPPER (a
[1]) == 'X')
2689 /* Return 1 if A is a valid symbol name. Expects string input. */
2692 subsym_isname (char *a
, char *ignore ATTRIBUTE_UNUSED
)
2694 if (!is_name_beginner (*a
))
2698 if (!is_part_of_name (*a
))
2705 /* Return whether the string is a register; accepts ar0-7, unless .mmregs has
2706 been seen; if so, recognize any memory-mapped register.
2707 Note this does not recognize "A" or "B" accumulators. */
2710 subsym_isreg (char *a
, char *ignore ATTRIBUTE_UNUSED
)
2712 if (hash_find (reg_hash
, a
))
2714 if (hash_find (mmreg_hash
, a
))
2719 /* Return the structure size, given the stag. */
2722 subsym_structsz (char *name
, char *ignore ATTRIBUTE_UNUSED
)
2724 struct stag
*stag
= (struct stag
*) hash_find (stag_hash
, name
);
2732 /* If anybody actually uses this, they can fix it :)
2733 FIXME I'm not sure what the "reference point" of a structure is. It might
2734 be either the initial offset given .struct, or it may be the offset of the
2735 structure within another structure, or it might be something else
2736 altogether. since the TI assembler doesn't seem to ever do anything but
2737 return zero, we punt and return zero. */
2740 subsym_structacc (char *stag_name ATTRIBUTE_UNUSED
,
2741 char *ignore ATTRIBUTE_UNUSED
)
2747 math_ceil (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2749 return (float) ceil (arg1
);
2753 math_cvi (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2759 math_floor (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2761 return (float) floor (arg1
);
2765 math_fmod (float arg1
, float arg2
)
2767 return (int) arg1
% (int) arg2
;
2771 math_int (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2773 return ((float) ((int) arg1
)) == arg1
;
2777 math_round (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2779 return arg1
> 0 ? (int) (arg1
+ 0.5) : (int) (arg1
- 0.5);
2783 math_sgn (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2785 return (arg1
< 0) ? -1 : (arg1
? 1 : 0);
2789 math_trunc (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2795 math_acos (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2797 return (float) acos (arg1
);
2801 math_asin (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2803 return (float) asin (arg1
);
2807 math_atan (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2809 return (float) atan (arg1
);
2813 math_atan2 (float arg1
, float arg2
)
2815 return (float) atan2 (arg1
, arg2
);
2819 math_cosh (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2821 return (float) cosh (arg1
);
2825 math_cos (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2827 return (float) cos (arg1
);
2831 math_cvf (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2833 return (float) arg1
;
2837 math_exp (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2839 return (float) exp (arg1
);
2843 math_fabs (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2845 return (float) fabs (arg1
);
2848 /* expr1 * 2^expr2. */
2851 math_ldexp (float arg1
, float arg2
)
2853 return arg1
* (float) pow (2.0, arg2
);
2857 math_log10 (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2859 return (float) log10 (arg1
);
2863 math_log (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2865 return (float) log (arg1
);
2869 math_max (float arg1
, float arg2
)
2871 return (arg1
> arg2
) ? arg1
: arg2
;
2875 math_min (float arg1
, float arg2
)
2877 return (arg1
< arg2
) ? arg1
: arg2
;
2881 math_pow (float arg1
, float arg2
)
2883 return (float) pow (arg1
, arg2
);
2887 math_sin (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2889 return (float) sin (arg1
);
2893 math_sinh (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2895 return (float) sinh (arg1
);
2899 math_sqrt (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2901 return (float) sqrt (arg1
);
2905 math_tan (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2907 return (float) tan (arg1
);
2911 math_tanh (float arg1
, float ignore ATTRIBUTE_UNUSED
)
2913 return (float) tanh (arg1
);
2916 /* Built-in substitution symbol functions and math functions. */
2920 int (*proc
) (char *, char *);
2922 } subsym_proc_entry
;
2924 static const subsym_proc_entry subsym_procs
[] =
2926 /* Assembler built-in string substitution functions. */
2927 { "$symlen", subsym_symlen
, 1, },
2928 { "$symcmp", subsym_symcmp
, 2, },
2929 { "$firstch", subsym_firstch
, 2, },
2930 { "$lastch", subsym_lastch
, 2, },
2931 { "$isdefed", subsym_isdefed
, 1, },
2932 { "$ismember", subsym_ismember
, 2, },
2933 { "$iscons", subsym_iscons
, 1, },
2934 { "$isname", subsym_isname
, 1, },
2935 { "$isreg", subsym_isreg
, 1, },
2936 { "$structsz", subsym_structsz
, 1, },
2937 { "$structacc", subsym_structacc
, 1, },
2944 float (*proc
) (float, float);
2949 static const math_proc_entry math_procs
[] =
2951 /* Integer-returning built-in math functions. */
2952 { "$cvi", math_cvi
, 1, 1 },
2953 { "$int", math_int
, 1, 1 },
2954 { "$sgn", math_sgn
, 1, 1 },
2956 /* Float-returning built-in math functions. */
2957 { "$acos", math_acos
, 1, 0 },
2958 { "$asin", math_asin
, 1, 0 },
2959 { "$atan", math_atan
, 1, 0 },
2960 { "$atan2", math_atan2
, 2, 0 },
2961 { "$ceil", math_ceil
, 1, 0 },
2962 { "$cosh", math_cosh
, 1, 0 },
2963 { "$cos", math_cos
, 1, 0 },
2964 { "$cvf", math_cvf
, 1, 0 },
2965 { "$exp", math_exp
, 1, 0 },
2966 { "$fabs", math_fabs
, 1, 0 },
2967 { "$floor", math_floor
, 1, 0 },
2968 { "$fmod", math_fmod
, 2, 0 },
2969 { "$ldexp", math_ldexp
, 2, 0 },
2970 { "$log10", math_log10
, 1, 0 },
2971 { "$log", math_log
, 1, 0 },
2972 { "$max", math_max
, 2, 0 },
2973 { "$min", math_min
, 2, 0 },
2974 { "$pow", math_pow
, 2, 0 },
2975 { "$round", math_round
, 1, 0 },
2976 { "$sin", math_sin
, 1, 0 },
2977 { "$sinh", math_sinh
, 1, 0 },
2978 { "$sqrt", math_sqrt
, 1, 0 },
2979 { "$tan", math_tan
, 1, 0 },
2980 { "$tanh", math_tanh
, 1, 0 },
2981 { "$trunc", math_trunc
, 1, 0 },
2982 { NULL
, NULL
, 0, 0 },
2990 const subsym_proc_entry
*subsym_proc
;
2991 const math_proc_entry
*math_proc
;
2992 const char *hash_err
;
2994 char *TIC54X_DIR
= getenv ("TIC54X_DIR");
2995 char *A_DIR
= TIC54X_DIR
? TIC54X_DIR
: getenv ("A_DIR");
2999 /* Look for A_DIR and add it to the include list. */
3002 char *tmp
= xstrdup (A_DIR
);
3006 char *next
= strchr (tmp
, ';');
3010 add_include_dir (tmp
);
3013 while (tmp
!= NULL
);
3016 op_hash
= hash_new ();
3017 for (tm
= (insn_template
*) tic54x_optab
; tm
->name
; tm
++)
3019 if (hash_find (op_hash
, tm
->name
))
3021 hash_err
= hash_insert (op_hash
, tm
->name
, (char *) tm
);
3023 as_fatal ("Internal Error: Can't hash %s: %s",
3024 tm
->name
, hash_err
);
3026 parop_hash
= hash_new ();
3027 for (tm
= (insn_template
*) tic54x_paroptab
; tm
->name
; tm
++)
3029 if (hash_find (parop_hash
, tm
->name
))
3031 hash_err
= hash_insert (parop_hash
, tm
->name
, (char *) tm
);
3033 as_fatal ("Internal Error: Can't hash %s: %s",
3034 tm
->name
, hash_err
);
3036 reg_hash
= hash_new ();
3037 for (sym
= (symbol
*) regs
; sym
->name
; sym
++)
3039 /* Add basic registers to the symbol table. */
3040 symbolS
*symbolP
= symbol_new (sym
->name
, absolute_section
,
3041 (valueT
) sym
->value
, &zero_address_frag
);
3042 SF_SET_LOCAL (symbolP
);
3043 symbol_table_insert (symbolP
);
3044 hash_err
= hash_insert (reg_hash
, sym
->name
, (char *) sym
);
3046 for (sym
= (symbol
*) mmregs
; sym
->name
; sym
++)
3047 hash_err
= hash_insert (reg_hash
, sym
->name
, (char *) sym
);
3048 mmreg_hash
= hash_new ();
3049 for (sym
= (symbol
*) mmregs
; sym
->name
; sym
++)
3050 hash_err
= hash_insert (mmreg_hash
, sym
->name
, (char *) sym
);
3052 cc_hash
= hash_new ();
3053 for (sym
= (symbol
*) condition_codes
; sym
->name
; sym
++)
3054 hash_err
= hash_insert (cc_hash
, sym
->name
, (char *) sym
);
3056 cc2_hash
= hash_new ();
3057 for (sym
= (symbol
*) cc2_codes
; sym
->name
; sym
++)
3058 hash_err
= hash_insert (cc2_hash
, sym
->name
, (char *) sym
);
3060 cc3_hash
= hash_new ();
3061 for (sym
= (symbol
*) cc3_codes
; sym
->name
; sym
++)
3062 hash_err
= hash_insert (cc3_hash
, sym
->name
, (char *) sym
);
3064 sbit_hash
= hash_new ();
3065 for (sym
= (symbol
*) status_bits
; sym
->name
; sym
++)
3066 hash_err
= hash_insert (sbit_hash
, sym
->name
, (char *) sym
);
3068 misc_symbol_hash
= hash_new ();
3069 for (symname
= (char **) misc_symbols
; *symname
; symname
++)
3070 hash_err
= hash_insert (misc_symbol_hash
, *symname
, *symname
);
3072 /* Only the base substitution table and local label table are initialized;
3073 the others (for local macro substitution) get instantiated as needed. */
3074 local_label_hash
[0] = hash_new ();
3075 subsym_hash
[0] = hash_new ();
3076 for (subsym_proc
= subsym_procs
; subsym_proc
->name
; subsym_proc
++)
3077 hash_err
= hash_insert (subsym_hash
[0], subsym_proc
->name
,
3078 (char *) subsym_proc
);
3080 math_hash
= hash_new ();
3081 for (math_proc
= math_procs
; math_proc
->name
; math_proc
++)
3083 /* Insert into the main subsym hash for recognition; insert into
3084 the math hash to actually store information. */
3085 hash_err
= hash_insert (subsym_hash
[0], math_proc
->name
,
3086 (char *) math_proc
);
3087 hash_err
= hash_insert (math_hash
, math_proc
->name
,
3088 (char *) math_proc
);
3090 subsym_recurse_hash
= hash_new ();
3091 stag_hash
= hash_new ();
3095 is_accumulator (struct opstruct
*operand
)
3097 return strcasecmp (operand
->buf
, "a") == 0
3098 || strcasecmp (operand
->buf
, "b") == 0;
3101 /* Return the number of operands found, or -1 on error, copying the
3102 operands into the given array and the accompanying expressions into
3106 get_operands (struct opstruct operands
[], char *line
)
3110 int expecting_operand
= 0;
3113 while (numexp
< MAX_OPERANDS
&& !is_end_of_line
[(int) *lptr
])
3115 int paren_not_balanced
= 0;
3116 char *op_start
, *op_end
;
3118 while (*lptr
&& ISSPACE (*lptr
))
3121 while (paren_not_balanced
|| *lptr
!= ',')
3125 if (paren_not_balanced
)
3127 as_bad (_("Unbalanced parenthesis in operand %d"), numexp
);
3134 ++paren_not_balanced
;
3135 else if (*lptr
== ')')
3136 --paren_not_balanced
;
3140 if (op_end
!= op_start
)
3142 int len
= op_end
- op_start
;
3144 strncpy (operands
[numexp
].buf
, op_start
, len
);
3145 operands
[numexp
].buf
[len
] = 0;
3146 /* Trim trailing spaces; while the preprocessor gets rid of most,
3147 there are weird usage patterns that can introduce them
3148 (i.e. using strings for macro args). */
3149 while (len
> 0 && ISSPACE (operands
[numexp
].buf
[len
- 1]))
3150 operands
[numexp
].buf
[--len
] = 0;
3156 if (expecting_operand
|| *lptr
== ',')
3158 as_bad (_("Expecting operand after ','"));
3164 if (*++lptr
== '\0')
3166 as_bad (_("Expecting operand after ','"));
3169 expecting_operand
= 1;
3173 while (*lptr
&& ISSPACE (*lptr
++))
3175 if (!is_end_of_line
[(int) *lptr
])
3177 as_bad (_("Extra junk on line"));
3181 /* OK, now parse them into expressions. */
3182 for (i
= 0; i
< numexp
; i
++)
3184 memset (&operands
[i
].exp
, 0, sizeof (operands
[i
].exp
));
3185 if (operands
[i
].buf
[0] == '#')
3188 parse_expression (operands
[i
].buf
+ 1, &operands
[i
].exp
);
3190 else if (operands
[i
].buf
[0] == '@')
3192 /* Direct notation. */
3193 parse_expression (operands
[i
].buf
+ 1, &operands
[i
].exp
);
3195 else if (operands
[i
].buf
[0] == '*')
3198 char *paren
= strchr (operands
[i
].buf
, '(');
3200 /* Allow immediate syntax in the inner expression. */
3201 if (paren
&& paren
[1] == '#')
3204 /* Pull out the lk expression or SP offset, if present. */
3207 int len
= strlen (paren
);
3208 char *end
= paren
+ len
;
3211 while (end
[-1] != ')')
3214 as_bad (_("Badly formed address expression"));
3219 parse_expression (paren
, &operands
[i
].exp
);
3223 operands
[i
].exp
.X_op
= O_absent
;
3226 parse_expression (operands
[i
].buf
, &operands
[i
].exp
);
3232 /* Predicates for different operand types. */
3235 is_immediate (struct opstruct
*operand
)
3237 return *operand
->buf
== '#';
3240 /* This is distinguished from immediate because some numbers must be constants
3241 and must *not* have the '#' prefix. */
3244 is_absolute (struct opstruct
*operand
)
3246 return operand
->exp
.X_op
== O_constant
&& !is_immediate (operand
);
3249 /* Is this an indirect operand? */
3252 is_indirect (struct opstruct
*operand
)
3254 return operand
->buf
[0] == '*';
3257 /* Is this a valid dual-memory operand? */
3260 is_dual (struct opstruct
*operand
)
3262 if (is_indirect (operand
) && strncasecmp (operand
->buf
, "*ar", 3) == 0)
3264 char *tmp
= operand
->buf
+ 3;
3269 /* Only allow *ARx, *ARx-, *ARx+, or *ARx+0%. */
3270 valid_mod
= *tmp
== '\0' ||
3271 strcasecmp (tmp
, "-") == 0 ||
3272 strcasecmp (tmp
, "+") == 0 ||
3273 strcasecmp (tmp
, "+0%") == 0;
3274 return arf
>= 2 && arf
<= 5 && valid_mod
;
3280 is_mmreg (struct opstruct
*operand
)
3282 return (is_absolute (operand
)
3283 || is_immediate (operand
)
3284 || hash_find (mmreg_hash
, operand
->buf
) != 0);
3288 is_type (struct opstruct
*operand
, enum optype type
)
3293 return operand
->buf
[0] == 0;
3296 return is_dual (operand
);
3298 return is_indirect (operand
);
3300 /* This one *must* be immediate. */
3301 return is_immediate (operand
);
3310 /* Address may be a numeric, indirect, or an expression. */
3311 return !is_immediate (operand
);
3314 return is_mmreg (operand
);
3319 return is_accumulator (operand
);
3321 return is_accumulator (operand
) && TOUPPER (operand
->buf
[0]) == 'B';
3323 return is_accumulator (operand
) && TOUPPER (operand
->buf
[0]) == 'A';
3325 return strncasecmp ("ar", operand
->buf
, 2) == 0
3326 && ISDIGIT (operand
->buf
[2]);
3328 return hash_find (sbit_hash
, operand
->buf
) != 0 || is_absolute (operand
);
3330 return hash_find (cc_hash
, operand
->buf
) != 0;
3332 return hash_find (cc2_hash
, operand
->buf
) != 0;
3334 return hash_find (cc3_hash
, operand
->buf
) != 0
3335 || is_immediate (operand
) || is_absolute (operand
);
3337 return (is_immediate (operand
) || is_absolute (operand
))
3338 && operand
->exp
.X_add_number
== 16;
3340 /* Allow st0 or st1 instead of a numeric. */
3341 return is_absolute (operand
) || is_immediate (operand
) ||
3342 strcasecmp ("st0", operand
->buf
) == 0 ||
3343 strcasecmp ("st1", operand
->buf
) == 0;
3346 return is_absolute (operand
) || is_immediate (operand
);
3348 return (is_immediate (operand
) || is_absolute (operand
))
3349 && operand
->exp
.X_add_number
>= 0 && operand
->exp
.X_add_number
< 16;
3351 /* Let this one catch out-of-range values. */
3352 return (is_immediate (operand
) || is_absolute (operand
))
3353 && operand
->exp
.X_add_number
!= 16;
3357 return is_absolute (operand
) || is_immediate (operand
);
3359 return is_immediate (operand
)
3360 && operand
->exp
.X_op
== O_constant
3361 && operand
->exp
.X_add_number
>= 0
3362 && operand
->exp
.X_add_number
< 256;
3365 /* Allow anything; assumes opcodes are ordered with Smem operands
3371 /* Just make sure it's an integer; check range later. */
3372 return is_immediate (operand
);
3374 return strcasecmp ("t", operand
->buf
) == 0 ||
3375 strcasecmp ("treg", operand
->buf
) == 0;
3377 return strcasecmp ("ts", operand
->buf
) == 0;
3379 return strcasecmp ("asm", operand
->buf
) == 0;
3381 return strcasecmp ("trn", operand
->buf
) == 0;
3383 return strcasecmp ("dp", operand
->buf
) == 0;
3385 return strcasecmp ("arp", operand
->buf
) == 0;
3392 operands_match (tic54x_insn
*insn
,
3393 struct opstruct
*operands
,
3395 const enum optype
*refoptype
,
3399 int op
= 0, refop
= 0;
3401 if (opcount
== 0 && minops
== 0)
3404 while (op
<= maxops
&& refop
<= maxops
)
3406 while (!is_type (&operands
[op
], OPTYPE (refoptype
[refop
])))
3408 /* Skip an optional template operand if it doesn't agree
3409 with the current operand. */
3410 if (refoptype
[refop
] & OPT
)
3421 /* Save the actual operand type for later use. */
3422 operands
[op
].type
= OPTYPE (refoptype
[refop
]);
3425 /* Have we matched them all yet? */
3430 /* If a later operand is *not* optional, no match. */
3431 if ((refoptype
[refop
] & OPT
) == 0)
3433 /* Flag any implicit default OP_DST operands so we know to add
3434 them explicitly when encoding the operand later. */
3435 if (OPTYPE (refoptype
[refop
]) == OP_DST
)
3436 insn
->using_default_dst
= 1;
3448 /* 16-bit direct memory address
3449 Explicit dmad operands are always in last word of insn (usually second
3450 word, but bumped to third if lk addressing is used)
3452 We allow *(dmad) notation because the TI assembler allows it.
3455 0 for 16-bit addresses
3456 1 for full 23-bit addresses
3457 2 for the upper 7 bits of a 23-bit address (LDX). */
3460 encode_dmad (tic54x_insn
*insn
, struct opstruct
*operand
, int xpc_code
)
3462 int op
= 1 + insn
->is_lkaddr
;
3464 /* Only allow *(dmad) expressions; all others are invalid. */
3465 if (is_indirect (operand
) && operand
->buf
[strlen (operand
->buf
) - 1] != ')')
3467 as_bad (_("Invalid dmad syntax '%s'"), operand
->buf
);
3471 insn
->opcode
[op
].addr_expr
= operand
->exp
;
3473 if (insn
->opcode
[op
].addr_expr
.X_op
== O_constant
)
3475 valueT value
= insn
->opcode
[op
].addr_expr
.X_add_number
;
3479 insn
->opcode
[0].word
&= 0xFF80;
3480 insn
->opcode
[0].word
|= (value
>> 16) & 0x7F;
3481 insn
->opcode
[1].word
= value
& 0xFFFF;
3483 else if (xpc_code
== 2)
3484 insn
->opcode
[op
].word
= (value
>> 16) & 0xFFFF;
3486 insn
->opcode
[op
].word
= value
;
3490 /* Do the fixup later; just store the expression. */
3491 insn
->opcode
[op
].word
= 0;
3492 insn
->opcode
[op
].r_nchars
= 2;
3494 if (amode
== c_mode
)
3495 insn
->opcode
[op
].r_type
= BFD_RELOC_TIC54X_16_OF_23
;
3496 else if (xpc_code
== 1)
3498 /* This relocation spans two words, so adjust accordingly. */
3499 insn
->opcode
[0].addr_expr
= operand
->exp
;
3500 insn
->opcode
[0].r_type
= BFD_RELOC_TIC54X_23
;
3501 insn
->opcode
[0].r_nchars
= 4;
3502 insn
->opcode
[0].unresolved
= 1;
3503 /* It's really 2 words, but we want to stop encoding after the
3504 first, since we must encode both words at once. */
3507 else if (xpc_code
== 2)
3508 insn
->opcode
[op
].r_type
= BFD_RELOC_TIC54X_MS7_OF_23
;
3510 insn
->opcode
[op
].r_type
= BFD_RELOC_TIC54X_16_OF_23
;
3512 insn
->opcode
[op
].unresolved
= 1;
3518 /* 7-bit direct address encoding. */
3521 encode_address (tic54x_insn
*insn
, struct opstruct
*operand
)
3523 /* Assumes that dma addresses are *always* in word 0 of the opcode. */
3524 insn
->opcode
[0].addr_expr
= operand
->exp
;
3526 if (operand
->exp
.X_op
== O_constant
)
3527 insn
->opcode
[0].word
|= (operand
->exp
.X_add_number
& 0x7F);
3530 if (operand
->exp
.X_op
== O_register
)
3531 as_bad (_("Use the .mmregs directive to use memory-mapped register names such as '%s'"), operand
->buf
);
3532 /* Do the fixup later; just store the expression. */
3533 insn
->opcode
[0].r_nchars
= 1;
3534 insn
->opcode
[0].r_type
= BFD_RELOC_TIC54X_PARTLS7
;
3535 insn
->opcode
[0].unresolved
= 1;
3542 encode_indirect (tic54x_insn
*insn
, struct opstruct
*operand
)
3547 if (insn
->is_lkaddr
)
3549 /* lk addresses always go in the second insn word. */
3550 mod
= ((TOUPPER (operand
->buf
[1]) == 'A') ? 12 :
3551 (operand
->buf
[1] == '(') ? 15 :
3552 (strchr (operand
->buf
, '%') != NULL
) ? 14 : 13);
3553 arf
= ((mod
== 12) ? operand
->buf
[3] - '0' :
3554 (mod
== 15) ? 0 : operand
->buf
[4] - '0');
3556 insn
->opcode
[1].addr_expr
= operand
->exp
;
3558 if (operand
->exp
.X_op
== O_constant
)
3559 insn
->opcode
[1].word
= operand
->exp
.X_add_number
;
3562 insn
->opcode
[1].word
= 0;
3563 insn
->opcode
[1].r_nchars
= 2;
3564 insn
->opcode
[1].r_type
= BFD_RELOC_TIC54X_16_OF_23
;
3565 insn
->opcode
[1].unresolved
= 1;
3568 else if (strncasecmp (operand
->buf
, "*sp (", 4) == 0)
3570 /* Stack offsets look the same as 7-bit direct addressing. */
3571 return encode_address (insn
, operand
);
3575 arf
= (TOUPPER (operand
->buf
[1]) == 'A' ?
3576 operand
->buf
[3] : operand
->buf
[4]) - '0';
3578 if (operand
->buf
[1] == '+')
3580 mod
= 3; /* *+ARx */
3581 if (insn
->tm
->flags
& FL_SMR
)
3582 as_warn (_("Address mode *+ARx is write-only. "
3583 "Results of reading are undefined."));
3585 else if (operand
->buf
[4] == '\0')
3587 else if (operand
->buf
[5] == '\0')
3588 mod
= (operand
->buf
[4] == '-' ? 1 : 2); /* *ARx+ / *ARx- */
3589 else if (operand
->buf
[6] == '\0')
3591 if (operand
->buf
[5] == '0')
3592 mod
= (operand
->buf
[4] == '-' ? 5 : 6); /* *ARx+0 / *ARx-0 */
3594 mod
= (operand
->buf
[4] == '-' ? 8 : 10);/* *ARx+% / *ARx-% */
3596 else if (TOUPPER (operand
->buf
[6]) == 'B')
3597 mod
= (operand
->buf
[4] == '-' ? 4 : 7); /* ARx+0B / *ARx-0B */
3598 else if (TOUPPER (operand
->buf
[6]) == '%')
3599 mod
= (operand
->buf
[4] == '-' ? 9 : 11); /* ARx+0% / *ARx - 0% */
3602 as_bad (_("Unrecognized indirect address format \"%s\""),
3608 insn
->opcode
[0].word
|= 0x80 | (mod
<< 3) | arf
;
3614 encode_integer (tic54x_insn
*insn
,
3615 struct opstruct
*operand
,
3619 unsigned short mask
)
3621 long parse
, integer
;
3623 insn
->opcode
[which
].addr_expr
= operand
->exp
;
3625 if (operand
->exp
.X_op
== O_constant
)
3627 parse
= operand
->exp
.X_add_number
;
3628 /* Hack -- fixup for 16-bit hex quantities that get converted positive
3629 instead of negative. */
3630 if ((parse
& 0x8000) && min
== -32768 && max
== 32767)
3631 integer
= (short) parse
;
3635 if (integer
>= min
&& integer
<= max
)
3637 insn
->opcode
[which
].word
|= (integer
& mask
);
3640 as_bad (_("Operand '%s' out of range (%d <= x <= %d)"),
3641 operand
->buf
, min
, max
);
3645 if (insn
->opcode
[which
].addr_expr
.X_op
== O_constant
)
3647 insn
->opcode
[which
].word
|=
3648 insn
->opcode
[which
].addr_expr
.X_add_number
& mask
;
3652 /* Do the fixup later; just store the expression. */
3653 bfd_reloc_code_real_type rtype
=
3654 (mask
== 0x1FF ? BFD_RELOC_TIC54X_PARTMS9
:
3655 mask
== 0xFFFF ? BFD_RELOC_TIC54X_16_OF_23
:
3656 mask
== 0x7F ? BFD_RELOC_TIC54X_PARTLS7
: BFD_RELOC_8
);
3657 int size
= (mask
== 0x1FF || mask
== 0xFFFF) ? 2 : 1;
3659 if (rtype
== BFD_RELOC_8
)
3660 as_bad (_("Error in relocation handling"));
3662 insn
->opcode
[which
].r_nchars
= size
;
3663 insn
->opcode
[which
].r_type
= rtype
;
3664 insn
->opcode
[which
].unresolved
= 1;
3674 encode_condition (tic54x_insn
*insn
, struct opstruct
*operand
)
3676 symbol
*cc
= (symbol
*) hash_find (cc_hash
, operand
->buf
);
3679 as_bad (_("Unrecognized condition code \"%s\""), operand
->buf
);
3682 #define CC_GROUP 0x40
3684 #define CATG_A1 0x07
3685 #define CATG_B1 0x30
3686 #define CATG_A2 0x30
3687 #define CATG_B2 0x0C
3688 #define CATG_C2 0x03
3689 /* Disallow group 1 conditions mixed with group 2 conditions
3690 if group 1, allow only one category A and one category B
3691 if group 2, allow only one each of category A, B, and C. */
3692 if (((insn
->opcode
[0].word
& 0xFF) != 0))
3694 if ((insn
->opcode
[0].word
& CC_GROUP
) != (cc
->value
& CC_GROUP
))
3696 as_bad (_("Condition \"%s\" does not match preceding group"),
3700 if (insn
->opcode
[0].word
& CC_GROUP
)
3702 if ((insn
->opcode
[0].word
& CC_ACC
) != (cc
->value
& CC_ACC
))
3704 as_bad (_("Condition \"%s\" uses a different accumulator from "
3705 "a preceding condition"),
3709 if ((insn
->opcode
[0].word
& CATG_A1
) && (cc
->value
& CATG_A1
))
3711 as_bad (_("Only one comparison conditional allowed"));
3714 if ((insn
->opcode
[0].word
& CATG_B1
) && (cc
->value
& CATG_B1
))
3716 as_bad (_("Only one overflow conditional allowed"));
3720 else if ( ((insn
->opcode
[0].word
& CATG_A2
) && (cc
->value
& CATG_A2
))
3721 || ((insn
->opcode
[0].word
& CATG_B2
) && (cc
->value
& CATG_B2
))
3722 || ((insn
->opcode
[0].word
& CATG_C2
) && (cc
->value
& CATG_C2
)))
3724 as_bad (_("Duplicate %s conditional"), operand
->buf
);
3729 insn
->opcode
[0].word
|= cc
->value
;
3734 encode_cc3 (tic54x_insn
*insn
, struct opstruct
*operand
)
3736 symbol
*cc3
= (symbol
*) hash_find (cc3_hash
, operand
->buf
);
3737 int value
= cc3
? cc3
->value
: operand
->exp
.X_add_number
<< 8;
3739 if ((value
& 0x0300) != value
)
3741 as_bad (_("Unrecognized condition code \"%s\""), operand
->buf
);
3744 insn
->opcode
[0].word
|= value
;
3749 encode_arx (tic54x_insn
*insn
, struct opstruct
*operand
)
3751 int arf
= strlen (operand
->buf
) >= 3 ? operand
->buf
[2] - '0' : -1;
3753 if (strncasecmp ("ar", operand
->buf
, 2) || arf
< 0 || arf
> 7)
3755 as_bad (_("Invalid auxiliary register (use AR0-AR7)"));
3758 insn
->opcode
[0].word
|= arf
;
3763 encode_cc2 (tic54x_insn
*insn
, struct opstruct
*operand
)
3765 symbol
*cc2
= (symbol
*) hash_find (cc2_hash
, operand
->buf
);
3769 as_bad (_("Unrecognized condition code \"%s\""), operand
->buf
);
3772 insn
->opcode
[0].word
|= cc2
->value
;
3777 encode_operand (tic54x_insn
*insn
, enum optype type
, struct opstruct
*operand
)
3779 int ext
= (insn
->tm
->flags
& FL_EXT
) != 0;
3781 if (type
== OP_MMR
&& operand
->exp
.X_op
!= O_constant
)
3783 /* Disallow long-constant addressing for memory-mapped addressing. */
3784 if (insn
->is_lkaddr
)
3786 as_bad (_("lk addressing modes are invalid for memory-mapped "
3787 "register addressing"));
3791 /* Warn about *+ARx when used with MMR operands. */
3792 if (strncasecmp (operand
->buf
, "*+ar", 4) == 0)
3794 as_warn (_("Address mode *+ARx is not allowed in memory-mapped "
3795 "register addressing. Resulting behavior is "
3805 /* 16-bit immediate value. */
3806 return encode_dmad (insn
, operand
, 0);
3808 if (TOUPPER (*operand
->buf
) == 'B')
3810 insn
->opcode
[ext
? (1 + insn
->is_lkaddr
) : 0].word
|= (1 << 9);
3811 if (insn
->using_default_dst
)
3812 insn
->opcode
[ext
? (1 + insn
->is_lkaddr
) : 0].word
|= (1 << 8);
3816 /* Make sure this agrees with the OP_DST operand. */
3817 if (!((TOUPPER (operand
->buf
[0]) == 'B') ^
3818 ((insn
->opcode
[0].word
& (1 << 8)) != 0)))
3820 as_bad (_("Destination accumulator for each part of this parallel "
3821 "instruction must be different"));
3827 if (TOUPPER (operand
->buf
[0]) == 'B')
3828 insn
->opcode
[ext
? (1 + insn
->is_lkaddr
) : 0].word
|= (1 << 8);
3833 int mod
= (operand
->buf
[4] == '\0' ? 0 : /* *arx */
3834 operand
->buf
[4] == '-' ? 1 : /* *arx- */
3835 operand
->buf
[5] == '\0' ? 2 : 3); /* *arx+, *arx+0% */
3836 int arf
= operand
->buf
[3] - '0' - 2;
3837 int code
= (mod
<< 2) | arf
;
3838 insn
->opcode
[0].word
|= (code
<< (type
== OP_Xmem
? 4 : 0));
3843 if (!is_indirect (operand
))
3844 return encode_address (insn
, operand
);
3847 return encode_indirect (insn
, operand
);
3849 return encode_dmad (insn
, operand
, 2);
3851 return encode_dmad (insn
, operand
, 1);
3854 return encode_dmad (insn
, operand
, 0);
3856 return encode_arx (insn
, operand
);
3861 int value
= operand
->exp
.X_add_number
;
3864 insn
->opcode
[0].word
|= value
;
3867 if (value
< 16 || value
> 24)
3869 as_bad (_("Memory mapped register \"%s\" out of range"),
3873 if (type
== OP_MMRX
)
3874 insn
->opcode
[0].word
|= (value
- 16) << 4;
3876 insn
->opcode
[0].word
|= (value
- 16);
3884 return encode_integer (insn
, operand
, ext
+ insn
->is_lkaddr
,
3887 return encode_integer (insn
, operand
, ext
+ insn
->is_lkaddr
,
3890 return encode_integer (insn
, operand
, 1 + insn
->is_lkaddr
,
3891 -32768, 32767, 0xFFFF);
3893 return encode_condition (insn
, operand
);
3895 return encode_cc2 (insn
, operand
);
3897 return encode_cc3 (insn
, operand
);
3899 return encode_integer (insn
, operand
, 0, 0, 15, 0xF);
3901 return encode_integer (insn
, operand
, 0, -128, 127, 0xFF);
3904 int value
= operand
->exp
.X_add_number
;
3906 if (value
< 1 || value
> 3)
3908 as_bad (_("Invalid operand (use 1, 2, or 3)"));
3911 code
= value
== 1 ? 0 : value
== 2 ? 0x2 : 0x1;
3912 insn
->opcode
[0].word
|= (code
<< 8);
3916 return encode_integer (insn
, operand
, 0, 0, 31, 0x1F);
3918 return encode_integer (insn
, operand
, 0, 0, 255, 0xFF);
3920 return encode_integer (insn
, operand
, 1 + insn
->is_lkaddr
,
3924 symbol
*sbit
= (symbol
*) hash_find (sbit_hash
, operand
->buf
);
3925 int value
= is_absolute (operand
) ?
3926 operand
->exp
.X_add_number
: (sbit
? sbit
->value
: -1);
3929 if (insn
->opcount
== 1)
3933 as_bad (_("A status register or status bit name is required"));
3936 /* Guess the register based on the status bit; "ovb" is the last
3937 status bit defined for st0. */
3938 if (sbit
> (symbol
*) hash_find (sbit_hash
, "ovb"))
3943 as_bad (_("Unrecognized status bit \"%s\""), operand
->buf
);
3946 insn
->opcode
[0].word
|= value
;
3947 insn
->opcode
[0].word
|= (reg
<< 9);
3951 if (strcasecmp (operand
->buf
, "st0") == 0
3952 || strcasecmp (operand
->buf
, "st1") == 0)
3954 insn
->opcode
[0].word
|=
3955 ((unsigned short) (operand
->buf
[2] - '0')) << 9;
3958 else if (operand
->exp
.X_op
== O_constant
3959 && (operand
->exp
.X_add_number
== 0
3960 || operand
->exp
.X_add_number
== 1))
3962 insn
->opcode
[0].word
|=
3963 ((unsigned short) (operand
->exp
.X_add_number
)) << 9;
3966 as_bad (_("Invalid status register \"%s\""), operand
->buf
);
3969 return encode_integer (insn
, operand
, 0, -16, 15, 0x1F);
3971 return encode_integer (insn
, operand
, 0, 0, 7, 0x7);
3973 return encode_integer (insn
, operand
, 0, 0, 0x1FF, 0x1FF);
3975 if (operand
->exp
.X_add_number
!= 1
3976 && operand
->exp
.X_add_number
!= 2)
3978 as_bad (_("Operand \"%s\" out of range (use 1 or 2)"), operand
->buf
);
3981 insn
->opcode
[0].word
|= (operand
->exp
.X_add_number
- 1) << 9;
3990 /* No encoding necessary. */
4000 emit_insn (tic54x_insn
*insn
)
4003 flagword oldflags
= bfd_get_section_flags (stdoutput
, now_seg
);
4004 flagword flags
= oldflags
| SEC_CODE
;
4006 if (! bfd_set_section_flags (stdoutput
, now_seg
, flags
))
4007 as_warn (_("error setting flags for \"%s\": %s"),
4008 bfd_section_name (stdoutput
, now_seg
),
4009 bfd_errmsg (bfd_get_error ()));
4011 for (i
= 0; i
< insn
->words
; i
++)
4013 int size
= (insn
->opcode
[i
].unresolved
4014 && insn
->opcode
[i
].r_type
== BFD_RELOC_TIC54X_23
) ? 4 : 2;
4015 char *p
= frag_more (size
);
4018 md_number_to_chars (p
, (valueT
) insn
->opcode
[i
].word
, 2);
4020 md_number_to_chars (p
, (valueT
) insn
->opcode
[i
].word
<< 16, 4);
4022 if (insn
->opcode
[i
].unresolved
)
4023 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
,
4024 insn
->opcode
[i
].r_nchars
, &insn
->opcode
[i
].addr_expr
,
4025 FALSE
, insn
->opcode
[i
].r_type
);
4029 /* Convert the operand strings into appropriate opcode values
4030 return the total number of words used by the instruction. */
4033 build_insn (tic54x_insn
*insn
)
4037 /* Only non-parallel instructions support lk addressing. */
4038 if (!(insn
->tm
->flags
& FL_PAR
))
4040 for (i
= 0; i
< insn
->opcount
; i
++)
4042 if ((OPTYPE (insn
->operands
[i
].type
) == OP_Smem
4043 || OPTYPE (insn
->operands
[i
].type
) == OP_Lmem
4044 || OPTYPE (insn
->operands
[i
].type
) == OP_Sind
)
4045 && strchr (insn
->operands
[i
].buf
, '(')
4046 /* Don't mistake stack-relative addressing for lk addressing. */
4047 && strncasecmp (insn
->operands
[i
].buf
, "*sp (", 4) != 0)
4049 insn
->is_lkaddr
= 1;
4050 insn
->lkoperand
= i
;
4055 insn
->words
= insn
->tm
->words
+ insn
->is_lkaddr
;
4057 insn
->opcode
[0].word
= insn
->tm
->opcode
;
4058 if (insn
->tm
->flags
& FL_EXT
)
4059 insn
->opcode
[1 + insn
->is_lkaddr
].word
= insn
->tm
->opcode2
;
4061 for (i
= 0; i
< insn
->opcount
; i
++)
4063 enum optype type
= insn
->operands
[i
].type
;
4065 if (!encode_operand (insn
, type
, &insn
->operands
[i
]))
4068 if (insn
->tm
->flags
& FL_PAR
)
4069 for (i
= 0; i
< insn
->paropcount
; i
++)
4071 enum optype partype
= insn
->paroperands
[i
].type
;
4073 if (!encode_operand (insn
, partype
, &insn
->paroperands
[i
]))
4083 optimize_insn (tic54x_insn
*insn
)
4085 /* Optimize some instructions, helping out the brain-dead programmer. */
4086 #define is_zero(op) ((op).exp.X_op == O_constant && (op).exp.X_add_number == 0)
4087 if (strcasecmp (insn
->tm
->name
, "add") == 0)
4089 if (insn
->opcount
> 1
4090 && is_accumulator (&insn
->operands
[insn
->opcount
- 2])
4091 && is_accumulator (&insn
->operands
[insn
->opcount
- 1])
4092 && strcasecmp (insn
->operands
[insn
->opcount
- 2].buf
,
4093 insn
->operands
[insn
->opcount
- 1].buf
) == 0)
4096 insn
->using_default_dst
= 1;
4100 /* Try to collapse if Xmem and shift count is zero. */
4101 if ((OPTYPE (insn
->tm
->operand_types
[0]) == OP_Xmem
4102 && OPTYPE (insn
->tm
->operand_types
[1]) == OP_SHFT
4103 && is_zero (insn
->operands
[1]))
4104 /* Or if Smem, shift is zero or absent, and SRC == DST. */
4105 || (OPTYPE (insn
->tm
->operand_types
[0]) == OP_Smem
4106 && OPTYPE (insn
->tm
->operand_types
[1]) == OP_SHIFT
4107 && is_type (&insn
->operands
[1], OP_SHIFT
)
4108 && is_zero (insn
->operands
[1]) && insn
->opcount
== 3))
4110 insn
->operands
[1] = insn
->operands
[2];
4115 else if (strcasecmp (insn
->tm
->name
, "ld") == 0)
4117 if (insn
->opcount
== 3 && insn
->operands
[0].type
!= OP_SRC
)
4119 if ((OPTYPE (insn
->tm
->operand_types
[1]) == OP_SHIFT
4120 || OPTYPE (insn
->tm
->operand_types
[1]) == OP_SHFT
)
4121 && is_zero (insn
->operands
[1])
4122 && (OPTYPE (insn
->tm
->operand_types
[0]) != OP_lk
4123 || (insn
->operands
[0].exp
.X_op
== O_constant
4124 && insn
->operands
[0].exp
.X_add_number
<= 255
4125 && insn
->operands
[0].exp
.X_add_number
>= 0)))
4127 insn
->operands
[1] = insn
->operands
[2];
4133 else if (strcasecmp (insn
->tm
->name
, "sth") == 0
4134 || strcasecmp (insn
->tm
->name
, "stl") == 0)
4136 if ((OPTYPE (insn
->tm
->operand_types
[1]) == OP_SHIFT
4137 || OPTYPE (insn
->tm
->operand_types
[1]) == OP_SHFT
)
4138 && is_zero (insn
->operands
[1]))
4140 insn
->operands
[1] = insn
->operands
[2];
4145 else if (strcasecmp (insn
->tm
->name
, "sub") == 0)
4147 if (insn
->opcount
> 1
4148 && is_accumulator (&insn
->operands
[insn
->opcount
- 2])
4149 && is_accumulator (&insn
->operands
[insn
->opcount
- 1])
4150 && strcasecmp (insn
->operands
[insn
->opcount
- 2].buf
,
4151 insn
->operands
[insn
->opcount
- 1].buf
) == 0)
4154 insn
->using_default_dst
= 1;
4158 if ( ((OPTYPE (insn
->tm
->operand_types
[0]) == OP_Smem
4159 && OPTYPE (insn
->tm
->operand_types
[1]) == OP_SHIFT
)
4160 || (OPTYPE (insn
->tm
->operand_types
[0]) == OP_Xmem
4161 && OPTYPE (insn
->tm
->operand_types
[1]) == OP_SHFT
))
4162 && is_zero (insn
->operands
[1])
4163 && insn
->opcount
== 3)
4165 insn
->operands
[1] = insn
->operands
[2];
4173 /* Find a matching template if possible, and get the operand strings. */
4176 tic54x_parse_insn (tic54x_insn
*insn
, char *line
)
4178 insn
->tm
= (insn_template
*) hash_find (op_hash
, insn
->mnemonic
);
4181 as_bad (_("Unrecognized instruction \"%s\""), insn
->mnemonic
);
4185 insn
->opcount
= get_operands (insn
->operands
, line
);
4186 if (insn
->opcount
< 0)
4189 /* Check each variation of operands for this mnemonic. */
4190 while (insn
->tm
->name
&& strcasecmp (insn
->tm
->name
, insn
->mnemonic
) == 0)
4192 if (insn
->opcount
>= insn
->tm
->minops
4193 && insn
->opcount
<= insn
->tm
->maxops
4194 && operands_match (insn
, &insn
->operands
[0], insn
->opcount
,
4195 insn
->tm
->operand_types
,
4196 insn
->tm
->minops
, insn
->tm
->maxops
))
4198 /* SUCCESS! now try some optimizations. */
4199 if (optimize_insn (insn
))
4201 insn
->tm
= (insn_template
*) hash_find (op_hash
,
4210 as_bad (_("Unrecognized operand list '%s' for instruction '%s'"),
4211 line
, insn
->mnemonic
);
4215 /* We set this in start_line_hook, 'cause if we do a line replacement, we
4216 won't be able to see the next line. */
4217 static int parallel_on_next_line_hint
= 0;
4219 /* See if this is part of a parallel instruction
4220 Look for a subsequent line starting with "||". */
4223 next_line_shows_parallel (char *next_line
)
4225 /* Look for the second half. */
4226 while (ISSPACE (*next_line
))
4229 return (next_line
[0] == PARALLEL_SEPARATOR
4230 && next_line
[1] == PARALLEL_SEPARATOR
);
4234 tic54x_parse_parallel_insn_firstline (tic54x_insn
*insn
, char *line
)
4236 insn
->tm
= (insn_template
*) hash_find (parop_hash
, insn
->mnemonic
);
4239 as_bad (_("Unrecognized parallel instruction \"%s\""),
4244 while (insn
->tm
->name
&& strcasecmp (insn
->tm
->name
,
4245 insn
->mnemonic
) == 0)
4247 insn
->opcount
= get_operands (insn
->operands
, line
);
4248 if (insn
->opcount
< 0)
4250 if (insn
->opcount
== 2
4251 && operands_match (insn
, &insn
->operands
[0], insn
->opcount
,
4252 insn
->tm
->operand_types
, 2, 2))
4258 /* Didn't find a matching parallel; try for a normal insn. */
4262 /* Parse the second line of a two-line parallel instruction. */
4265 tic54x_parse_parallel_insn_lastline (tic54x_insn
*insn
, char *line
)
4267 int valid_mnemonic
= 0;
4269 insn
->paropcount
= get_operands (insn
->paroperands
, line
);
4270 while (insn
->tm
->name
&& strcasecmp (insn
->tm
->name
,
4271 insn
->mnemonic
) == 0)
4273 if (strcasecmp (insn
->tm
->parname
, insn
->parmnemonic
) == 0)
4277 if (insn
->paropcount
>= insn
->tm
->minops
4278 && insn
->paropcount
<= insn
->tm
->maxops
4279 && operands_match (insn
, insn
->paroperands
,
4281 insn
->tm
->paroperand_types
,
4282 insn
->tm
->minops
, insn
->tm
->maxops
))
4288 as_bad (_("Invalid operand (s) for parallel instruction \"%s\""),
4291 as_bad (_("Unrecognized parallel instruction combination \"%s || %s\""),
4292 insn
->mnemonic
, insn
->parmnemonic
);
4297 /* If quotes found, return copy of line up to closing quote;
4298 otherwise up until terminator.
4299 If it's a string, pass as-is; otherwise attempt substitution symbol
4300 replacement on the value. */
4303 subsym_get_arg (char *line
, char *terminators
, char **str
, int nosub
)
4307 int is_string
= *line
== '"';
4308 int is_char
= ISDIGIT (*line
);
4312 while (ISDIGIT (*ptr
))
4315 *str
= xmalloc (ptr
- line
+ 1);
4316 strncpy (*str
, line
, ptr
- line
);
4317 (*str
)[ptr
- line
] = 0;
4321 char *savedp
= input_line_pointer
;
4324 input_line_pointer
= ptr
;
4325 *str
= demand_copy_C_string (&len
);
4326 endp
= input_line_pointer
;
4327 input_line_pointer
= savedp
;
4329 /* Do forced substitutions if requested. */
4330 if (!nosub
&& **str
== ':')
4331 *str
= subsym_substitute (*str
, 1);
4335 char *term
= terminators
;
4338 while (*ptr
&& *ptr
!= *term
)
4349 *str
= xmalloc (ptr
- line
+ 1);
4350 strncpy (*str
, line
, ptr
- line
);
4351 (*str
)[ptr
- line
] = 0;
4352 /* Do simple substitution, if available. */
4353 if (!nosub
&& (value
= subsym_lookup (*str
, macro_level
)) != NULL
)
4360 /* Replace the given substitution string.
4361 We start at the innermost macro level, so that existing locals remain local
4362 Note: we're treating macro args identically to .var's; I don't know if
4363 that's compatible w/TI's assembler. */
4366 subsym_create_or_replace (char *name
, char *value
)
4370 for (i
= macro_level
; i
> 0; i
--)
4372 if (hash_find (subsym_hash
[i
], name
))
4374 hash_replace (subsym_hash
[i
], name
, value
);
4378 if (hash_find (subsym_hash
[0], name
))
4379 hash_replace (subsym_hash
[0], name
, value
);
4381 hash_insert (subsym_hash
[0], name
, value
);
4384 /* Look up the substitution string replacement for the given symbol.
4385 Start with the innermost macro substitution table given and work
4389 subsym_lookup (char *name
, int nest_level
)
4391 char *value
= hash_find (subsym_hash
[nest_level
], name
);
4393 if (value
|| nest_level
== 0)
4396 return subsym_lookup (name
, nest_level
- 1);
4399 /* Do substitution-symbol replacement on the given line (recursively).
4400 return the argument if no substitution was done
4402 Also look for built-in functions ($func (arg)) and local labels.
4404 If FORCED is set, look for forced substitutions of the form ':SYMBOL:'. */
4407 subsym_substitute (char *line
, int forced
)
4409 /* For each apparent symbol, see if it's a substitution symbol, and if so,
4410 replace it in the input. */
4411 char *replacement
; /* current replacement for LINE. */
4412 char *head
; /* Start of line. */
4413 char *ptr
; /* Current examination point. */
4414 int changed
= 0; /* Did we make a substitution? */
4415 int eval_line
= 0; /* Is this line a .eval/.asg statement? */
4416 int eval_symbol
= 0; /* Are we in the middle of the symbol for
4418 char *eval_end
= NULL
;
4420 int line_conditional
= 0;
4423 /* Work with a copy of the input line. */
4424 replacement
= xmalloc (strlen (line
) + 1);
4425 strcpy (replacement
, line
);
4427 ptr
= head
= replacement
;
4429 /* Flag lines where we might need to replace a single '=' with two;
4430 GAS uses single '=' to assign macro args values, and possibly other
4431 places, so limit what we replace. */
4432 if (strstr (line
, ".if")
4433 || strstr (line
, ".elseif")
4434 || strstr (line
, ".break"))
4435 line_conditional
= 1;
4437 /* Watch out for .eval, so that we avoid doing substitution on the
4438 symbol being assigned a value. */
4439 if (strstr (line
, ".eval") || strstr (line
, ".asg"))
4442 /* If it's a macro definition, don't do substitution on the argument
4444 if (strstr (line
, ".macro"))
4447 while (!is_end_of_line
[(int) *ptr
])
4449 int current_char
= *ptr
;
4451 /* Need to update this since LINE may have been modified. */
4453 eval_end
= strrchr (ptr
, ',');
4455 /* Replace triple double quotes with bounding quote/escapes. */
4456 if (current_char
== '"' && ptr
[1] == '"' && ptr
[2] == '"')
4459 tmp
= strstr (ptr
+ 2, "\"\"\"");
4465 /* Replace a single '=' with a '==';
4466 for compatibility with older code only. */
4467 if (line_conditional
&& current_char
== '=')
4475 tmp
= xmalloc (strlen (head
) + 2 + strlen (ptr
) + 1);
4476 sprintf (tmp
, "%s==%s", head
, ptr
);
4477 /* Continue examining after the '=='. */
4478 ptr
= tmp
+ strlen (head
) + 2;
4480 head
= replacement
= tmp
;
4484 /* Flag when we've reached the symbol part of .eval/.asg. */
4485 if (eval_line
&& ptr
>= eval_end
)
4488 /* For each apparent symbol, see if it's a substitution symbol, and if
4489 so, replace it in the input. */
4490 if ((forced
&& current_char
== ':')
4491 || (!forced
&& is_name_beginner (current_char
)))
4493 char *name
; /* Symbol to be replaced. */
4494 char *savedp
= input_line_pointer
;
4497 char *tail
; /* Rest of line after symbol. */
4499 /* Skip the colon. */
4503 name
= input_line_pointer
= ptr
;
4504 c
= get_symbol_end ();
4505 /* '?' is not normally part of a symbol, but it IS part of a local
4509 *input_line_pointer
++ = c
;
4510 c
= *input_line_pointer
;
4511 *input_line_pointer
= '\0';
4513 /* Avoid infinite recursion; if a symbol shows up a second time for
4514 substitution, leave it as is. */
4515 if (hash_find (subsym_recurse_hash
, name
) == NULL
)
4516 value
= subsym_lookup (name
, macro_level
);
4518 as_warn (_("%s symbol recursion stopped at "
4519 "second appearance of '%s'"),
4520 forced
? "Forced substitution" : "Substitution", name
);
4521 ptr
= tail
= input_line_pointer
;
4522 input_line_pointer
= savedp
;
4524 /* Check for local labels; replace them with the appropriate
4526 if ((*name
== '$' && ISDIGIT (name
[1]) && name
[2] == '\0')
4527 || name
[strlen (name
) - 1] == '?')
4529 /* Use an existing identifier for that label if, available, or
4530 create a new, unique identifier. */
4531 value
= hash_find (local_label_hash
[macro_level
], name
);
4535 char *namecopy
= strcpy (xmalloc (strlen (name
) + 1), name
);
4537 value
= strcpy (xmalloc (strlen (name
) + sizeof (digit
) + 1),
4540 value
[strlen (value
) - 1] = '\0';
4541 sprintf (digit
, ".%d", local_label_id
++);
4542 strcat (value
, digit
);
4543 hash_insert (local_label_hash
[macro_level
], namecopy
, value
);
4545 /* Indicate where to continue looking for substitutions. */
4548 /* Check for built-in subsym and math functions. */
4549 else if (value
!= NULL
&& *name
== '$')
4551 subsym_proc_entry
*entry
= (subsym_proc_entry
*) value
;
4552 math_proc_entry
*math_entry
= hash_find (math_hash
, name
);
4553 char *arg1
, *arg2
= NULL
;
4558 as_bad (_("Unrecognized substitution symbol function"));
4561 else if (*ptr
!= '(')
4563 as_bad (_("Missing '(' after substitution symbol function"));
4567 if (math_entry
!= NULL
)
4569 float farg1
, farg2
= 0;
4570 volatile float fresult
;
4572 farg1
= (float) strtod (ptr
, &ptr
);
4573 if (math_entry
->nargs
== 2)
4577 as_bad (_("Expecting second argument"));
4580 farg2
= (float) strtod (ptr
, &ptr
);
4582 fresult
= (*math_entry
->proc
) (farg1
, farg2
);
4583 value
= xmalloc (128);
4584 if (math_entry
->int_return
)
4585 sprintf (value
, "%d", (int) fresult
);
4587 sprintf (value
, "%f", fresult
);
4590 as_bad (_("Extra junk in function call, expecting ')'"));
4593 /* Don't bother recursing; the replacement isn't a
4600 int arg_type
[2] = { *ptr
== '"' , 0 };
4601 int ismember
= !strcmp (entry
->name
, "$ismember");
4603 /* Parse one or two args, which must be a substitution
4604 symbol, string or a character-string constant. */
4605 /* For all functions, a string or substitution symbol may be
4606 used, with the following exceptions:
4607 firstch/lastch: 2nd arg must be character constant
4608 ismember: both args must be substitution symbols. */
4609 ptr
= subsym_get_arg (ptr
, ",)", &arg1
, ismember
);
4612 if (entry
->nargs
== 2)
4616 as_bad (_("Function expects two arguments"));
4619 /* Character constants are converted to numerics
4620 by the preprocessor. */
4621 arg_type
[1] = (ISDIGIT (*ptr
)) ? 2 : (*ptr
== '"');
4622 ptr
= subsym_get_arg (ptr
, ")", &arg2
, ismember
);
4624 /* Args checking. */
4625 if ((!strcmp (entry
->name
, "$firstch")
4626 || !strcmp (entry
->name
, "$lastch"))
4627 && arg_type
[1] != 2)
4629 as_bad (_("Expecting character constant argument"));
4633 && (arg_type
[0] != 0 || arg_type
[1] != 0))
4635 as_bad (_("Both arguments must be substitution symbols"));
4640 as_bad (_("Extra junk in function call, expecting ')'"));
4643 val
= (*entry
->proc
) (arg1
, arg2
);
4644 value
= xmalloc (64);
4645 sprintf (value
, "%d", val
);
4647 /* Fix things up to replace the entire expression, not just the
4653 if (value
!= NULL
&& !eval_symbol
)
4655 /* Replace the symbol with its string replacement and
4656 continue. Recursively replace VALUE until either no
4657 substitutions are performed, or a substitution that has been
4658 previously made is encountered again.
4660 put the symbol into the recursion hash table so we only
4661 try to replace a symbol once. */
4664 hash_insert (subsym_recurse_hash
, name
, name
);
4665 value
= subsym_substitute (value
, macro_level
> 0);
4666 hash_delete (subsym_recurse_hash
, name
, FALSE
);
4669 /* Temporarily zero-terminate where the symbol started. */
4675 /* Subscripted substitution symbol -- use just the
4676 indicated portion of the string; the description
4677 kinda indicates that forced substitution is not
4678 supposed to be recursive, but I'm not sure. */
4679 unsigned beg
, len
= 1; /* default to a single char */
4680 char *newval
= strcpy (xmalloc (strlen (value
) + 1),
4683 savedp
= input_line_pointer
;
4684 input_line_pointer
= tail
+ 1;
4685 beg
= get_absolute_expression ();
4688 as_bad (_("Invalid subscript (use 1 to %d)"),
4689 (int) strlen (value
));
4692 if (*input_line_pointer
== ',')
4694 ++input_line_pointer
;
4695 len
= get_absolute_expression ();
4696 if (beg
+ len
> strlen (value
))
4698 as_bad (_("Invalid length (use 0 to %d"),
4699 (int) strlen (value
) - beg
);
4705 tail
= input_line_pointer
;
4708 as_bad (_("Missing ')' in subscripted substitution "
4709 "symbol expression"));
4713 input_line_pointer
= savedp
;
4719 tmp
= xmalloc (strlen (head
) + strlen (value
) +
4720 strlen (tail
+ 1) + 2);
4722 strcat (tmp
, value
);
4723 /* Make sure forced substitutions are properly terminated. */
4728 as_bad (_("Missing forced substitution terminator ':'"));
4734 /* Restore the character after the symbol end. */
4737 /* Continue examining after the replacement value. */
4738 ptr
= tmp
+ strlen (head
) + strlen (value
);
4740 head
= replacement
= tmp
;
4758 /* We use this to handle substitution symbols
4759 hijack input_line_pointer, replacing it with our substituted string.
4761 .sslist should enable listing the line after replacements are made...
4763 returns the new buffer limit. */
4766 tic54x_start_line_hook (void)
4769 char *replacement
= NULL
;
4771 /* Work with a copy of the input line, including EOL char. */
4772 endp
= input_line_pointer
;
4773 while (!is_end_of_line
[(int) *endp
++])
4775 line
= xmalloc (endp
- input_line_pointer
+ 1);
4776 strncpy (line
, input_line_pointer
, endp
- input_line_pointer
+ 1);
4777 line
[endp
- input_line_pointer
] = 0;
4779 /* Scan ahead for parallel insns. */
4780 parallel_on_next_line_hint
= next_line_shows_parallel (endp
);
4782 /* If within a macro, first process forced replacements. */
4783 if (macro_level
> 0)
4784 replacement
= subsym_substitute (line
, 1);
4787 replacement
= subsym_substitute (replacement
, 0);
4789 if (replacement
!= line
)
4791 char *tmp
= replacement
;
4792 char *comment
= strchr (replacement
, ';');
4793 char endc
= replacement
[strlen (replacement
) - 1];
4795 /* Clean up the replacement; we'd prefer to have this done by the
4796 standard preprocessing equipment (maybe do_scrub_chars?)
4797 but for now, do a quick-and-dirty. */
4798 if (comment
!= NULL
)
4805 comment
= replacement
+ strlen (replacement
) - 1;
4807 /* Trim trailing whitespace. */
4808 while (ISSPACE (*comment
))
4815 /* Compact leading whitespace. */
4816 while (ISSPACE (tmp
[0]) && ISSPACE (tmp
[1]))
4819 input_line_pointer
= endp
;
4820 input_scrub_insert_line (tmp
);
4823 /* Keep track of whether we've done a substitution. */
4824 substitution_line
= 1;
4830 substitution_line
= 0;
4834 /* This is the guts of the machine-dependent assembler. STR points to a
4835 machine dependent instruction. This function is supposed to emit
4836 the frags/bytes it assembles to. */
4838 md_assemble (char *line
)
4840 static int repeat_slot
= 0;
4841 static int delay_slots
= 0; /* How many delay slots left to fill? */
4842 static int is_parallel
= 0;
4843 static tic54x_insn insn
;
4845 char *savedp
= input_line_pointer
;
4848 input_line_pointer
= line
;
4849 c
= get_symbol_end ();
4853 if (address_mode_needs_set
)
4855 set_address_mode (amode
);
4856 address_mode_needs_set
= 0;
4869 strcpy (insn
.parmnemonic
, line
);
4870 lptr
= input_line_pointer
;
4872 input_line_pointer
= savedp
;
4874 if (tic54x_parse_parallel_insn_lastline (&insn
, lptr
))
4876 int words
= build_insn (&insn
);
4878 if (delay_slots
!= 0)
4880 if (words
> delay_slots
)
4882 as_bad (_("Instruction does not fit in available delay "
4883 "slots (%d-word insn, %d slots left)"),
4884 words
, delay_slots
);
4888 delay_slots
-= words
;
4894 memset (&insn
, 0, sizeof (insn
));
4895 strcpy (insn
.mnemonic
, line
);
4896 lptr
= input_line_pointer
;
4898 input_line_pointer
= savedp
;
4900 /* See if this line is part of a parallel instruction; if so, either this
4901 line or the next line will have the "||" specifier preceding the
4902 mnemonic, and we look for it in the parallel insn hash table. */
4903 if (strstr (line
, "||") != NULL
|| parallel_on_next_line_hint
)
4905 char *tmp
= strstr (line
, "||");
4909 if (tic54x_parse_parallel_insn_firstline (&insn
, lptr
))
4912 /* If the parallel part is on the same line, process it now,
4913 otherwise let the assembler pick up the next line for us. */
4916 while (ISSPACE (tmp
[2]))
4918 md_assemble (tmp
+ 2);
4923 as_bad (_("Unrecognized parallel instruction '%s'"), line
);
4928 if (tic54x_parse_insn (&insn
, lptr
))
4932 if ((insn
.tm
->flags
& FL_LP
)
4933 && cpu
!= V545LP
&& cpu
!= V546LP
)
4935 as_bad (_("Instruction '%s' requires an LP cpu version"),
4939 if ((insn
.tm
->flags
& FL_FAR
)
4940 && amode
!= far_mode
)
4942 as_bad (_("Instruction '%s' requires far mode addressing"),
4947 words
= build_insn (&insn
);
4949 /* Is this instruction in a delay slot? */
4952 if (words
> delay_slots
)
4954 as_warn (_("Instruction does not fit in available delay "
4955 "slots (%d-word insn, %d slots left). "
4956 "Resulting behavior is undefined."),
4957 words
, delay_slots
);
4961 /* Branches in delay slots are not allowed. */
4962 if (insn
.tm
->flags
& FL_BMASK
)
4964 as_warn (_("Instructions which cause PC discontinuity are not "
4965 "allowed in a delay slot. "
4966 "Resulting behavior is undefined."));
4968 delay_slots
-= words
;
4971 /* Is this instruction the target of a repeat? */
4974 if (insn
.tm
->flags
& FL_NR
)
4975 as_warn (_("'%s' is not repeatable. "
4976 "Resulting behavior is undefined."),
4978 else if (insn
.is_lkaddr
)
4979 as_warn (_("Instructions using long offset modifiers or absolute "
4980 "addresses are not repeatable. "
4981 "Resulting behavior is undefined."));
4985 /* Make sure we check the target of a repeat instruction. */
4986 if (insn
.tm
->flags
& B_REPEAT
)
4989 /* FIXME -- warn if repeat_slot == 1 at EOF. */
4991 /* Make sure we check our delay slots for validity. */
4992 if (insn
.tm
->flags
& FL_DELAY
)
4995 /* FIXME -- warn if delay_slots != 0 at EOF. */
5000 /* Do a final adjustment on the symbol table; in this case, make sure we have
5001 a ".file" symbol. */
5004 tic54x_adjust_symtab (void)
5006 if (symbol_rootP
== NULL
5007 || S_GET_STORAGE_CLASS (symbol_rootP
) != C_FILE
)
5011 as_where (&filename
, &lineno
);
5012 c_dot_file_symbol (filename
, 0);
5016 /* In order to get gas to ignore any | chars at the start of a line,
5017 this function returns true if a | is found in a line.
5018 This lets us process parallel instructions, which span two lines. */
5021 tic54x_unrecognized_line (int c
)
5023 return c
== PARALLEL_SEPARATOR
;
5026 /* Watch for local labels of the form $[0-9] and [_a-zA-Z][_a-zA-Z0-9]*?
5027 Encode their names so that only we see them and can map them to the
5029 FIXME -- obviously this isn't done yet. These locals still show up in the
5032 tic54x_define_label (symbolS
*sym
)
5034 /* Just in case we need this later; note that this is not necessarily the
5035 same thing as line_label...
5036 When aligning or assigning labels to fields, sometimes the label is
5037 assigned other than the address at which the label appears.
5038 FIXME -- is this really needed? I think all the proper label assignment
5039 is done in tic54x_cons. */
5040 last_label_seen
= sym
;
5043 /* Try to parse something that normal parsing failed at. */
5046 tic54x_undefined_symbol (char *name
)
5050 /* Not sure how to handle predefined symbols. */
5051 if ((sym
= (symbol
*) hash_find (cc_hash
, name
)) != NULL
||
5052 (sym
= (symbol
*) hash_find (cc2_hash
, name
)) != NULL
||
5053 (sym
= (symbol
*) hash_find (cc3_hash
, name
)) != NULL
||
5054 (sym
= (symbol
*) hash_find (misc_symbol_hash
, name
)) != NULL
||
5055 (sym
= (symbol
*) hash_find (sbit_hash
, name
)) != NULL
)
5057 return symbol_new (name
, reg_section
,
5058 (valueT
) sym
->value
,
5059 &zero_address_frag
);
5062 if ((sym
= (symbol
*) hash_find (reg_hash
, name
)) != NULL
||
5063 (sym
= (symbol
*) hash_find (mmreg_hash
, name
)) != NULL
||
5064 !strcasecmp (name
, "a") || !strcasecmp (name
, "b"))
5066 return symbol_new (name
, reg_section
,
5067 (valueT
) sym
? sym
->value
: 0,
5068 &zero_address_frag
);
5074 /* Parse a name in an expression before the expression parser takes a stab at
5078 tic54x_parse_name (char *name ATTRIBUTE_UNUSED
,
5079 expressionS
*expn ATTRIBUTE_UNUSED
)
5085 md_atof (int type
, char *literalP
, int *sizeP
)
5087 /* Target data is little-endian, but floats are stored
5088 big-"word"ian. ugh. */
5089 return ieee_md_atof (type
, literalP
, sizeP
, TRUE
);
5093 tc_gen_reloc (asection
*section
, fixS
*fixP
)
5096 bfd_reloc_code_real_type code
= fixP
->fx_r_type
;
5097 asymbol
*sym
= symbol_get_bfdsym (fixP
->fx_addsy
);
5099 rel
= (arelent
*) xmalloc (sizeof (arelent
));
5100 rel
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
5101 *rel
->sym_ptr_ptr
= sym
;
5102 /* We assume that all rel->address are host byte offsets. */
5103 rel
->address
= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
5104 rel
->address
/= OCTETS_PER_BYTE
;
5105 rel
->howto
= bfd_reloc_type_lookup (stdoutput
, code
);
5106 if (!strcmp (sym
->name
, section
->name
))
5107 rel
->howto
+= HOWTO_BANK
;
5111 const char *name
= S_GET_NAME (fixP
->fx_addsy
);
5114 as_fatal ("Cannot generate relocation type for symbol %s, code %s",
5115 name
, bfd_get_reloc_code_name (code
));
5121 /* Handle cons expressions. */
5124 tic54x_cons_fix_new (fragS
*frag
, int where
, int octets
, expressionS
*expn
,
5125 bfd_reloc_code_real_type r
)
5130 as_bad (_("Unsupported relocation size %d"), octets
);
5131 r
= BFD_RELOC_TIC54X_16_OF_23
;
5134 r
= BFD_RELOC_TIC54X_16_OF_23
;
5137 /* TI assembler always uses this, regardless of addressing mode. */
5139 r
= BFD_RELOC_TIC54X_23
;
5141 /* We never want to directly generate this; this is provided for
5142 stabs support only. */
5146 fix_new_exp (frag
, where
, octets
, expn
, 0, r
);
5149 /* Attempt to simplify or even eliminate a fixup.
5150 To indicate that a fixup has been eliminated, set fixP->fx_done.
5152 If fixp->fx_addsy is non-NULL, we'll have to generate a reloc entry. */
5155 md_apply_fix (fixS
*fixP
, valueT
*valP
, segT seg ATTRIBUTE_UNUSED
)
5157 char *buf
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
5158 valueT val
= * valP
;
5160 switch (fixP
->fx_r_type
)
5163 as_fatal ("Bad relocation type: 0x%02x", fixP
->fx_r_type
);
5165 case BFD_RELOC_TIC54X_MS7_OF_23
:
5166 val
= (val
>> 16) & 0x7F;
5168 case BFD_RELOC_TIC54X_16_OF_23
:
5170 bfd_put_16 (stdoutput
, val
, buf
);
5171 /* Indicate what we're actually writing, so that we don't get warnings
5172 about exceeding available space. */
5173 *valP
= val
& 0xFFFF;
5175 case BFD_RELOC_TIC54X_PARTLS7
:
5176 bfd_put_16 (stdoutput
,
5177 (bfd_get_16 (stdoutput
, buf
) & 0xFF80) | (val
& 0x7F),
5179 /* Indicate what we're actually writing, so that we don't get warnings
5180 about exceeding available space. */
5183 case BFD_RELOC_TIC54X_PARTMS9
:
5184 /* TI assembler doesn't shift its encoding for relocatable files, and is
5185 thus incompatible with this implementation's relocatable files. */
5186 bfd_put_16 (stdoutput
,
5187 (bfd_get_16 (stdoutput
, buf
) & 0xFE00) | (val
>> 7),
5191 case BFD_RELOC_TIC54X_23
:
5192 bfd_put_32 (stdoutput
,
5193 (bfd_get_32 (stdoutput
, buf
) & 0xFF800000) | val
,
5198 if (fixP
->fx_addsy
== NULL
&& fixP
->fx_pcrel
== 0)
5202 /* This is our chance to record section alignment
5203 don't need to do anything here, since BFD does the proper encoding. */
5206 md_section_align (segT segment ATTRIBUTE_UNUSED
, valueT section_size
)
5208 return section_size
;
5212 md_pcrel_from (fixS
*fixP ATTRIBUTE_UNUSED
)
5217 /* Mostly little-endian, but longwords (4 octets) get MS word stored
5221 tic54x_number_to_chars (char *buf
, valueT val
, int n
)
5224 number_to_chars_littleendian (buf
, val
, n
);
5227 number_to_chars_littleendian (buf
, val
>> 16 , 2);
5228 number_to_chars_littleendian (buf
+ 2, val
& 0xFFFF, 2);
5233 tic54x_estimate_size_before_relax (fragS
*frag ATTRIBUTE_UNUSED
,
5234 segT seg ATTRIBUTE_UNUSED
)
5239 /* We use this to handle bit allocations which we couldn't handle before due
5240 to symbols being in different frags. return number of octets added. */
5243 tic54x_relax_frag (fragS
*frag
, long stretch ATTRIBUTE_UNUSED
)
5245 symbolS
*sym
= frag
->fr_symbol
;
5251 struct bit_info
*bi
= (struct bit_info
*) frag
->fr_opcode
;
5252 int bit_offset
= frag_bit_offset (frag_prev (frag
, bi
->seg
), bi
->seg
);
5253 int size
= S_GET_VALUE (sym
);
5254 fragS
*prev_frag
= bit_offset_frag (frag_prev (frag
, bi
->seg
), bi
->seg
);
5255 int available
= 16 - bit_offset
;
5257 if (symbol_get_frag (sym
) != &zero_address_frag
5258 || S_IS_COMMON (sym
)
5259 || !S_IS_DEFINED (sym
))
5260 as_bad_where (frag
->fr_file
, frag
->fr_line
,
5261 _("non-absolute value used with .space/.bes"));
5265 as_warn (_("negative value ignored in %s"),
5266 bi
->type
== TYPE_SPACE
? ".space" :
5267 bi
->type
== TYPE_BES
? ".bes" : ".field");
5269 frag
->tc_frag_data
= frag
->fr_fix
= 0;
5273 if (bi
->type
== TYPE_FIELD
)
5275 /* Bit fields of 16 or larger will have already been handled. */
5276 if (bit_offset
!= 0 && available
>= size
)
5278 char *p
= prev_frag
->fr_literal
;
5280 valueT value
= bi
->value
;
5281 value
<<= available
- size
;
5282 value
|= ((unsigned short) p
[1] << 8) | p
[0];
5283 md_number_to_chars (p
, value
, 2);
5284 if ((prev_frag
->tc_frag_data
+= size
) == 16)
5285 prev_frag
->tc_frag_data
= 0;
5287 symbol_set_frag (bi
->sym
, prev_frag
);
5288 /* This frag is no longer used. */
5289 growth
= -frag
->fr_fix
;
5291 frag
->tc_frag_data
= 0;
5295 char *p
= frag
->fr_literal
;
5297 valueT value
= bi
->value
<< (16 - size
);
5298 md_number_to_chars (p
, value
, 2);
5299 if ((frag
->tc_frag_data
= size
) == 16)
5300 frag
->tc_frag_data
= 0;
5306 if (bit_offset
!= 0 && bit_offset
< 16)
5308 if (available
>= size
)
5310 if ((prev_frag
->tc_frag_data
+= size
) == 16)
5311 prev_frag
->tc_frag_data
= 0;
5313 symbol_set_frag (bi
->sym
, prev_frag
);
5314 /* This frag is no longer used. */
5315 growth
= -frag
->fr_fix
;
5317 frag
->tc_frag_data
= 0;
5320 if (bi
->type
== TYPE_SPACE
&& bi
->sym
)
5321 symbol_set_frag (bi
->sym
, prev_frag
);
5324 growth
= (size
+ 15) / 16 * OCTETS_PER_BYTE
- frag
->fr_fix
;
5325 for (i
= 0; i
< growth
; i
++)
5326 frag
->fr_literal
[i
] = 0;
5327 frag
->fr_fix
= growth
;
5328 frag
->tc_frag_data
= size
% 16;
5329 /* Make sure any BES label points to the LAST word allocated. */
5330 if (bi
->type
== TYPE_BES
&& bi
->sym
)
5331 S_SET_VALUE (bi
->sym
, frag
->fr_fix
/ OCTETS_PER_BYTE
- 1);
5334 frag
->fr_symbol
= 0;
5335 frag
->fr_opcode
= 0;
5342 tic54x_convert_frag (bfd
*abfd ATTRIBUTE_UNUSED
,
5343 segT seg ATTRIBUTE_UNUSED
,
5346 /* Offset is in bytes. */
5347 frag
->fr_offset
= (frag
->fr_next
->fr_address
5349 - frag
->fr_fix
) / frag
->fr_var
;
5350 if (frag
->fr_offset
< 0)
5352 as_bad_where (frag
->fr_file
, frag
->fr_line
,
5353 _("attempt to .space/.bes backwards? (%ld)"),
5354 (long) frag
->fr_offset
);
5356 frag
->fr_type
= rs_space
;
5359 /* We need to avoid having labels defined for certain directives/pseudo-ops
5360 since once the label is defined, it's in the symbol table for good. TI
5361 syntax puts the symbol *before* the pseudo (which is kinda like MRI syntax,
5362 I guess, except I've never seen a definition of MRI syntax).
5364 C is the character that used to be at *REST, which points to the end of the
5367 Don't allow labels to start with '.' */
5370 tic54x_start_label (int c
, char *rest
)
5372 /* If within .struct/.union, no auto line labels, please. */
5373 if (current_stag
!= NULL
)
5376 /* Disallow labels starting with "." */
5381 while (!is_end_of_line
[(int) label
[-1]])
5385 as_bad (_("Invalid label '%s'"), label
);
5390 if (is_end_of_line
[(int) c
])
5394 while (ISSPACE (c
= *++rest
))
5398 /* Don't let colon () define a label for any of these... */
5399 return (strncasecmp (rest
, ".tag", 4) != 0 || !ISSPACE (rest
[4]))
5400 && (strncasecmp (rest
, ".struct", 7) != 0 || !ISSPACE (rest
[7]))
5401 && (strncasecmp (rest
, ".union", 6) != 0 || !ISSPACE (rest
[6]))
5402 && (strncasecmp (rest
, ".macro", 6) != 0 || !ISSPACE (rest
[6]))
5403 && (strncasecmp (rest
, ".set", 4) != 0 || !ISSPACE (rest
[4]))
5404 && (strncasecmp (rest
, ".equ", 4) != 0 || !ISSPACE (rest
[4]));