• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /* tc-tic54x.c -- Assembly code for the Texas Instruments TMS320C54X
2    Copyright (C) 1999-2014 Free Software Foundation, Inc.
3    Contributed by Timothy Wall (twall@cygnus.com)
4 
5    This file is part of GAS, the GNU Assembler.
6 
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)
10    any later version.
11 
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.
16 
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
20    02110-1301, USA.  */
21 
22 /* Texas Instruments TMS320C54X machine specific gas.
23    Written by Timothy Wall (twall@alum.mit.edu).
24 
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.
31 
32    Tests to add to expect testsuite:
33      '=' and '==' with .if, .elseif, and .break
34 
35    Incompatibilities (mostly trivial):
36    We don't allow '''
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.
43 
44    COFF1 limits section names to 8 characters.
45    Some of the default behavior changed from COFF1 to COFF2.  */
46 
47 #include "as.h"
48 #include <limits.h>
49 #include "safe-ctype.h"
50 #include "sb.h"
51 #include "macro.h"
52 #include "subsegs.h"
53 #include "struc-symbol.h"
54 #include "opcode/tic54x.h"
55 #include "obj-coff.h"
56 #include <math.h>
57 
58 
59 static struct stag
60 {
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.  */
65   int is_union;
66   struct stag_field		/* List of fields.  */
67   {
68     const char *name;
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;
73   } *field;
74   /* For nesting; used only in stag construction.  */
75   struct stag *inner;	        /* Enclosed .struct.  */
76   struct stag *outer;	        /* Enclosing .struct.  */
77 } *current_stag = NULL;
78 
79 #define MAX_LINE 256 /* Lines longer than this are truncated by TI's asm.  */
80 
81 typedef struct _tic54x_insn
82 {
83   const insn_template *tm;	/* Opcode template.  */
84 
85   char mnemonic[MAX_LINE];	/* Opcode name/mnemonic.  */
86   char parmnemonic[MAX_LINE];   /* 2nd mnemonic of parallel insn.  */
87 
88   int opcount;
89   struct opstruct
90   {
91     char buf[MAX_LINE];
92     enum optype type;
93     expressionS exp;
94   } operands[MAX_OPERANDS];
95 
96   int paropcount;
97   struct opstruct paroperands[MAX_OPERANDS];
98 
99   int is_lkaddr;
100   int lkoperand;
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?  */
104   struct
105   {
106     unsigned short word;	     /* Final encoded opcode data.  */
107     int unresolved;
108     int r_nchars;		     /* Relocation size.  */
109     bfd_reloc_code_real_type r_type; /* Relocation type.  */
110     expressionS addr_expr;	     /* Storage for unresolved expressions.  */
111   } opcode[3];
112 } tic54x_insn;
113 
114 enum cpu_version
115 {
116   VNONE = 0, V541 = 1, V542 = 2, V543 = 3, V545 = 5, V548 = 8, V549 = 9,
117   V545LP = 15, V546LP = 16
118 };
119 
120 enum address_mode
121 {
122   c_mode,   /* 16-bit addresses.  */
123   far_mode  /* >16-bit addresses.  */
124 };
125 
126 static segT stag_saved_seg;
127 static subsegT stag_saved_subseg;
128 
129 const char comment_chars[] = ";";
130 const char line_comment_chars[] = ";*#"; /* At column zero only.  */
131 const char line_separator_chars[] = ""; /* Not permitted.  */
132 
133 int emitting_long = 0;
134 
135 /* Characters which indicate that this is a floating point constant.  */
136 const char FLT_CHARS[] = "fF";
137 
138 /* Characters that can be used to separate mantissa from exp in FP
139    nums.  */
140 const char EXP_CHARS[] = "eE";
141 
142 const char *md_shortopts = "";
143 
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)
148 
149 struct option md_longopts[] =
150 {
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},
157 };
158 
159 size_t md_longopts_size = sizeof (md_longopts);
160 
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.
166 
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;
172 
173 /* Include string substitutions in listing?  */
174 static int listing_sslist = 0;
175 
176 /* Did we do subsym substitutions on the line?  */
177 static int substitution_line = 0;
178 
179 /* Last label seen.  */
180 static symbolS *last_label_seen = NULL;
181 
182 /* This ensures that all new labels are unique.  */
183 static int local_label_id;
184 
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];
190 
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
193 
194    We do our own local label handling 'cuz it's subtly different from the
195    stock GAS handling.
196 
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;
212 
213 /* Only word (et al.), align, or conditionals are allowed within
214    .struct/.union.  */
215 #define ILLEGAL_WITHIN_STRUCT()					\
216   do								\
217     if (current_stag != NULL)					\
218       { 							\
219 	as_bad (_("pseudo-op illegal within .struct/.union"));	\
220 	return;							\
221       }								\
222   while (0)
223 
224 
225 static void subsym_create_or_replace (char *, char *);
226 static char *subsym_lookup (char *, int);
227 static char *subsym_substitute (char *, int);
228 
229 
230 void
md_show_usage(FILE * stream)231 md_show_usage (FILE *stream)
232 {
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"));
238 }
239 
240 /* Output a single character (upper octect is zero).  */
241 
242 static void
tic54x_emit_char(char c)243 tic54x_emit_char (char c)
244 {
245   expressionS expn;
246 
247   expn.X_op = O_constant;
248   expn.X_add_number = c;
249   emit_expr (&expn, 2);
250 }
251 
252 /* Walk backwards in the frag chain.  */
253 
254 static fragS *
frag_prev(fragS * frag,segT seg)255 frag_prev (fragS *frag, segT seg)
256 {
257   segment_info_type *seginfo = seg_info (seg);
258   fragS *fragp;
259 
260   for (fragp = seginfo->frchainP->frch_root; fragp; fragp = fragp->fr_next)
261     if (fragp->fr_next == frag)
262       return fragp;
263 
264   return NULL;
265 }
266 
267 static fragS *
bit_offset_frag(fragS * frag,segT seg)268 bit_offset_frag (fragS *frag, segT seg)
269 {
270   while (frag != NULL)
271     {
272       if (frag->fr_fix == 0
273 	  && frag->fr_opcode == NULL
274 	  && frag->tc_frag_data == 0)
275 	frag = frag_prev (frag, seg);
276       else
277 	return frag;
278     }
279   return NULL;
280 }
281 
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.  */
284 
285 static int
frag_bit_offset(fragS * frag,segT seg)286 frag_bit_offset (fragS *frag, segT seg)
287 {
288   frag = bit_offset_frag (frag, seg);
289 
290   if (frag)
291     return frag->fr_opcode != NULL ? -1 : frag->tc_frag_data;
292 
293   return 0;
294 }
295 
296 /* Read an expression from a C string; returns a pointer past the end of the
297    expression.  */
298 
299 static char *
parse_expression(char * str,expressionS * expn)300 parse_expression (char *str, expressionS *expn)
301 {
302   char *s;
303   char *tmp;
304 
305   tmp = input_line_pointer;	/* Save line pointer.  */
306   input_line_pointer = str;
307   expression (expn);
308   s = input_line_pointer;
309   input_line_pointer = tmp;	/* Restore line pointer.  */
310   return s;			/* Return pointer to where parsing stopped.  */
311 }
312 
313 /* .asg "character-string"|character-string, symbol
314 
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
317    unsupported.  */
318 
319 static void
tic54x_asg(int x ATTRIBUTE_UNUSED)320 tic54x_asg (int x ATTRIBUTE_UNUSED)
321 {
322   int c;
323   char *name;
324   char *str;
325   char *tmp;
326   int quoted = *input_line_pointer == '"';
327 
328   ILLEGAL_WITHIN_STRUCT ();
329 
330   if (quoted)
331     {
332       int len;
333       str = demand_copy_C_string (&len);
334       c = *input_line_pointer;
335     }
336   else
337     {
338       str = input_line_pointer;
339       while ((c = *input_line_pointer) != ',')
340 	{
341 	  if (is_end_of_line[(int) *input_line_pointer])
342 	    break;
343 	  ++input_line_pointer;
344 	}
345       *input_line_pointer = 0;
346     }
347   if (c != ',')
348     {
349       as_bad (_("Comma and symbol expected for '.asg STRING, SYMBOL'"));
350       ignore_rest_of_line ();
351       return;
352     }
353 
354   name = ++input_line_pointer;
355   c = get_symbol_end ();	/* Get terminator.  */
356   if (!ISALPHA (*name))
357     {
358       as_bad (_("symbols assigned with .asg must begin with a letter"));
359       ignore_rest_of_line ();
360       return;
361     }
362 
363   tmp = xmalloc (strlen (str) + 1);
364   strcpy (tmp, str);
365   str = tmp;
366   tmp = xmalloc (strlen (name) + 1);
367   strcpy (tmp, name);
368   name = tmp;
369   subsym_create_or_replace (name, str);
370   *input_line_pointer = c;
371   demand_empty_rest_of_line ();
372 }
373 
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.  */
379 
380 static void
tic54x_eval(int x ATTRIBUTE_UNUSED)381 tic54x_eval (int x ATTRIBUTE_UNUSED)
382 {
383   char c;
384   int value;
385   char *name;
386   symbolS *symbolP;
387   char valuestr[32], *tmp;
388   int quoted;
389 
390   ILLEGAL_WITHIN_STRUCT ();
391 
392   SKIP_WHITESPACE ();
393 
394   quoted = *input_line_pointer == '"';
395   if (quoted)
396     ++input_line_pointer;
397   value = get_absolute_expression ();
398   if (quoted)
399     {
400       if (*input_line_pointer != '"')
401 	{
402 	  as_bad (_("Unterminated string after absolute expression"));
403 	  ignore_rest_of_line ();
404 	  return;
405 	}
406       ++input_line_pointer;
407     }
408   if (*input_line_pointer++ != ',')
409     {
410       as_bad (_("Comma and symbol expected for '.eval EXPR, SYMBOL'"));
411       ignore_rest_of_line ();
412       return;
413     }
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;
419 
420   if (!ISALPHA (*name))
421     {
422       as_bad (_("symbols assigned with .eval must begin with a letter"));
423       ignore_rest_of_line ();
424       return;
425     }
426   symbolP = symbol_new (name, absolute_section,
427 			(valueT) value, &zero_address_frag);
428   SF_SET_LOCAL (symbolP);
429   symbol_table_insert (symbolP);
430 
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);
438 
439   demand_empty_rest_of_line ();
440 }
441 
442 /* .bss symbol, size [, [blocking flag] [, alignment flag]
443 
444    alignment is to a longword boundary; blocking is to 128-word boundary.
445 
446    1) if there is a hole in memory, this directive should attempt to fill it
447       (not yet implemented).
448 
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
453       boundary.
454       (not yet implemented).  */
455 
456 static void
tic54x_bss(int x ATTRIBUTE_UNUSED)457 tic54x_bss (int x ATTRIBUTE_UNUSED)
458 {
459   char c;
460   char *name;
461   char *p;
462   int words;
463   segT current_seg;
464   subsegT current_subseg;
465   symbolS *symbolP;
466   int block = 0;
467   int align = 0;
468 
469   ILLEGAL_WITHIN_STRUCT ();
470 
471   current_seg = now_seg;	/* Save current seg.  */
472   current_subseg = now_subseg;	/* Save current subseg.  */
473 
474   name = input_line_pointer;
475   c = get_symbol_end ();	/* Get terminator.  */
476   if (c != ',')
477     {
478       as_bad (_(".bss size argument missing\n"));
479       ignore_rest_of_line ();
480       return;
481     }
482 
483   ++input_line_pointer;
484   words = get_absolute_expression ();
485   if (words < 0)
486     {
487       as_bad (_(".bss size %d < 0!"), words);
488       ignore_rest_of_line ();
489       return;
490     }
491 
492   if (*input_line_pointer == ',')
493     {
494       /* The blocking flag may be missing.  */
495       ++input_line_pointer;
496       if (*input_line_pointer != ',')
497 	block = get_absolute_expression ();
498       else
499 	block = 0;
500 
501       if (*input_line_pointer == ',')
502 	{
503 	  ++input_line_pointer;
504 	  align = get_absolute_expression ();
505 	}
506       else
507 	align = 0;
508     }
509   else
510     block = align = 0;
511 
512   subseg_set (bss_section, 0);
513   symbolP = symbol_find_or_make (name);
514 
515   if (S_GET_SEGMENT (symbolP) == bss_section)
516     symbolP->sy_frag->fr_symbol = (symbolS *) NULL;
517 
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.  */
522 
523   S_SET_SEGMENT (symbolP, bss_section);
524 
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);
530 
531   if (align)
532     {
533       /* s_align eats end of line; restore it */
534       s_align_bytes (4);
535       --input_line_pointer;
536     }
537 
538   if (block)
539     bss_section->flags |= SEC_TIC54X_BLOCK;
540 
541   subseg_set (current_seg, current_subseg);	/* Restore current seg.  */
542   demand_empty_rest_of_line ();
543 }
544 
545 static void
stag_add_field_symbols(struct stag * stag,const char * path,bfd_vma base_offset,symbolS * rootsym,const char * root_stag_name)546 stag_add_field_symbols (struct stag *stag,
547 			const char *path,
548 			bfd_vma base_offset,
549 			symbolS *rootsym,
550 			const char *root_stag_name)
551 {
552   char prefix[strlen (path) + 2];
553   struct stag_field *field = stag->field;
554 
555   /* Construct a symbol for every field contained within this structure
556      including fields within structure fields.  */
557   strcpy (prefix, path);
558   if (*path)
559     strcat (prefix, ".");
560 
561   while (field != NULL)
562     {
563       int len = strlen (prefix) + strlen (field->name) + 2;
564       char *name = xmalloc (len);
565       strcpy (name, prefix);
566       strcat (name, field->name);
567 
568       if (rootsym == NULL)
569 	{
570 	  symbolS *sym;
571 	  sym = symbol_new (name, absolute_section,
572 			    (field->stag ? field->offset :
573 			     (valueT) (base_offset + field->offset)),
574 			    &zero_address_frag);
575 	  SF_SET_LOCAL (sym);
576 	  symbol_table_insert (sym);
577 	}
578       else
579 	{
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);
587 	}
588 
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,
593 				field->offset,
594 				rootsym, root_stag_name);
595       field = field->next;
596     }
597 }
598 
599 /* Keep track of stag fields so that when structures are nested we can add the
600    complete dereferencing symbols to the symbol table.  */
601 
602 static void
stag_add_field(struct stag * parent,const char * name,bfd_vma offset,struct stag * stag)603 stag_add_field (struct stag *parent,
604 		const char *name,
605 		bfd_vma offset,
606 		struct stag *stag)
607 {
608   struct stag_field *sfield = xmalloc (sizeof (struct stag_field));
609 
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;
614   sfield->stag = stag;
615   if (parent->field == NULL)
616     parent->field = sfield;
617   else
618     {
619       struct stag_field *sf = parent->field;
620       while (sf->next != NULL)
621 	sf = sf->next;
622       sf->next = sfield;
623     }
624   /* Only create a symbol for this field if the parent has no name.  */
625   if (!strncmp (".fake", parent->name, 5))
626     {
627       symbolS *sym = symbol_new (name, absolute_section,
628 				 (valueT) offset, &zero_address_frag);
629       SF_SET_LOCAL (sym);
630       symbol_table_insert (sym);
631     }
632 }
633 
634 /* [STAG] .struct       [OFFSET]
635    Start defining structure offsets (symbols in absolute section).  */
636 
637 static void
tic54x_struct(int arg)638 tic54x_struct (int arg)
639 {
640   int start_offset = 0;
641   int is_union = arg;
642 
643   if (!current_stag)
644     {
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);
649     }
650   /* Align the current pointer.  */
651   else if (current_stag->current_bitfield_offset != 0)
652     {
653       ++abs_section_offset;
654       current_stag->current_bitfield_offset = 0;
655     }
656 
657   /* Offset expression is only meaningful for global .structs.  */
658   if (!is_union)
659     {
660       /* Offset is ignored in inner structs.  */
661       SKIP_WHITESPACE ();
662       if (!is_end_of_line[(int) *input_line_pointer])
663 	start_offset = get_absolute_expression ();
664       else
665 	start_offset = 0;
666     }
667 
668   if (current_stag)
669     {
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;
675       if (start_offset)
676 	as_warn (_("Offset on nested structures is ignored"));
677       start_offset = abs_section_offset;
678     }
679   else
680     {
681       current_stag = (struct stag *) xmalloc (sizeof (struct stag));
682       memset (current_stag, 0, sizeof (struct stag));
683       abs_section_offset = start_offset;
684     }
685   current_stag->is_union = is_union;
686 
687   if (line_label == NULL)
688     {
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,
694 				      &zero_address_frag);
695     }
696   else
697     {
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,
702 				      &zero_address_frag);
703     }
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);
709 
710   line_label = NULL;
711 }
712 
713 /* [LABEL] .endstruct
714    finish defining structure offsets; optional LABEL's value will be the size
715    of the structure.  */
716 
717 static void
tic54x_endstruct(int is_union)718 tic54x_endstruct (int is_union)
719 {
720   int size;
721   const char *path =
722     !strncmp (current_stag->name, ".fake", 5) ? "" : current_stag->name;
723 
724   if (!current_stag || current_stag->is_union != is_union)
725     {
726       as_bad (_(".end%s without preceding .%s"),
727 	      is_union ? "union" : "struct",
728 	      is_union ? "union" : "struct");
729       ignore_rest_of_line ();
730       return;
731     }
732 
733   /* Align end of structures.  */
734   if (current_stag->current_bitfield_offset)
735     {
736       ++abs_section_offset;
737       current_stag->current_bitfield_offset = 0;
738     }
739 
740   if (current_stag->is_union)
741     size = current_stag->size;
742   else
743     size = abs_section_offset - S_GET_VALUE (current_stag->sym);
744   if (line_label != NULL)
745     {
746       S_SET_VALUE (line_label, size);
747       symbol_table_insert (line_label);
748       line_label = NULL;
749     }
750 
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)
756     {
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),
760 			      NULL, NULL);
761     }
762   current_stag = current_stag->outer;
763 
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)
767     {
768       stag_add_field (current_stag, current_stag->inner->name,
769 		      S_GET_VALUE (current_stag->inner->sym),
770 		      current_stag->inner);
771     }
772   else
773     subseg_set (stag_saved_seg, stag_saved_subseg);
774 }
775 
776 /* [LABEL]      .tag    STAG
777    Reference a structure within a structure, as a sized field with an optional
778    label.
779    If used outside of a .struct/.endstruct, overlays the given structure
780    format on the existing allocated space.  */
781 
782 static void
tic54x_tag(int ignore ATTRIBUTE_UNUSED)783 tic54x_tag (int ignore ATTRIBUTE_UNUSED)
784 {
785   char *name = input_line_pointer;
786   int c = get_symbol_end ();
787   struct stag *stag = (struct stag *) hash_find (stag_hash, name);
788 
789   if (!stag)
790     {
791       if (*name)
792 	as_bad (_("Unrecognized struct/union tag '%s'"), name);
793       else
794 	as_bad (_(".tag requires a structure tag"));
795       ignore_rest_of_line ();
796       return;
797     }
798   if (line_label == NULL)
799     {
800       as_bad (_("Label required for .tag"));
801       ignore_rest_of_line ();
802       return;
803     }
804   else
805     {
806       char label[strlen (S_GET_NAME (line_label)) + 1];
807 
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),
812 			stag);
813       else
814 	{
815 	  symbolS *sym = symbol_find (label);
816 
817 	  if (!sym)
818 	    {
819 	      as_bad (_(".tag target '%s' undefined"), label);
820 	      ignore_rest_of_line ();
821 	      return;
822 	    }
823 	  stag_add_field_symbols (stag, S_GET_NAME (sym),
824 				  S_GET_VALUE (stag->sym), sym, stag->name);
825 	}
826     }
827 
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;
831 
832   *input_line_pointer = c;
833   demand_empty_rest_of_line ();
834   line_label = NULL;
835 }
836 
837 /* Handle all .byte, .char, .double, .field, .float, .half, .int, .long,
838    .short, .string, .ubyte, .uchar, .uhalf, .uint, .ulong, .ushort, .uword,
839    and .word.  */
840 
841 static void
tic54x_struct_field(int type)842 tic54x_struct_field (int type)
843 {
844   int size;
845   int count = 1;
846   int new_bitfield_offset = 0;
847   int field_align = current_stag->current_bitfield_offset != 0;
848   int longword_align = 0;
849 
850   SKIP_WHITESPACE ();
851   if (!is_end_of_line[(int) *input_line_pointer])
852     count = get_absolute_expression ();
853 
854   switch (type)
855     {
856     case 'b':
857     case 'B':
858     case 'c':
859     case 'C':
860     case 'h':
861     case 'H':
862     case 'i':
863     case 'I':
864     case 's':
865     case 'S':
866     case 'w':
867     case 'W':
868     case '*': /* String.  */
869       size = 1;
870       break;
871     case 'f':
872     case 'l':
873     case 'L':
874       longword_align = 1;
875       size = 2;
876       break;
877     case '.': /* Bitfield.  */
878       size = 0;
879       if (count < 1 || count > 32)
880 	{
881 	  as_bad (_(".field count '%d' out of range (1 <= X <= 32)"), count);
882 	  ignore_rest_of_line ();
883 	  return;
884 	}
885       if (current_stag->current_bitfield_offset + count > 16)
886 	{
887 	  /* Set the appropriate size and new field offset.  */
888 	  if (count == 32)
889 	    {
890 	      size = 2;
891 	      count = 1;
892 	    }
893 	  else if (count > 16)
894 	    {
895 	      size = 1;
896 	      count = 1;
897 	      new_bitfield_offset = count - 16;
898 	    }
899 	  else
900 	    new_bitfield_offset = count;
901 	}
902       else
903 	{
904 	  field_align = 0;
905 	  new_bitfield_offset = current_stag->current_bitfield_offset + count;
906 	}
907       break;
908     default:
909       as_bad (_("Unrecognized field type '%c'"), type);
910       ignore_rest_of_line ();
911       return;
912     }
913 
914   if (field_align)
915     {
916       /* Align to the actual starting position of the field.  */
917       current_stag->current_bitfield_offset = 0;
918       ++abs_section_offset;
919     }
920   /* Align to longword boundary.  */
921   if (longword_align && (abs_section_offset & 0x1))
922     ++abs_section_offset;
923 
924   if (line_label == NULL)
925     {
926       static int fieldno = 0;
927       char fake[] = ".fake_fieldNNNNN";
928 
929       sprintf (fake, ".fake_field%d", fieldno++);
930       stag_add_field (current_stag, fake,
931 		      abs_section_offset - S_GET_VALUE (current_stag->sym),
932 		      NULL);
933     }
934   else
935     {
936       char label[strlen (S_GET_NAME (line_label) + 1)];
937 
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),
941 		      NULL);
942     }
943 
944   if (current_stag->is_union)
945     {
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;
949     }
950   else
951     {
952       abs_section_offset += (unsigned) size * count;
953       current_stag->current_bitfield_offset = new_bitfield_offset;
954     }
955   line_label = NULL;
956 }
957 
958 /* Handle .byte, .word. .int, .long and all variants.  */
959 
960 static void
tic54x_cons(int type)961 tic54x_cons (int type)
962 {
963   unsigned int c;
964   int octets;
965 
966   /* If we're within a .struct construct, don't actually allocate space.  */
967   if (current_stag != NULL)
968     {
969       tic54x_struct_field (type);
970       return;
971     }
972 
973 #ifdef md_flush_pending_output
974   md_flush_pending_output ();
975 #endif
976 
977   generate_lineno_debug ();
978 
979   /* Align long words to long word boundaries (4 octets).  */
980   if (type == 'l' || type == 'L')
981     {
982       frag_align (2, 0, 2);
983       /* If there's a label, assign it to the first allocated word.  */
984       if (line_label != NULL)
985 	{
986 	  symbol_set_frag (line_label, frag_now);
987 	  S_SET_VALUE (line_label, frag_now_fix ());
988 	}
989     }
990 
991   switch (type)
992     {
993     case 'l':
994     case 'L':
995     case 'x':
996       octets = 4;
997       break;
998     case 'b':
999     case 'B':
1000     case 'c':
1001     case 'C':
1002       octets = 1;
1003       break;
1004     default:
1005       octets = 2;
1006       break;
1007     }
1008 
1009   do
1010     {
1011       if (*input_line_pointer == '"')
1012 	{
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] == '\"');
1017 	}
1018       else
1019 	{
1020 	  expressionS expn;
1021 
1022 	  input_line_pointer = parse_expression (input_line_pointer, &expn);
1023 	  if (expn.X_op == O_constant)
1024 	    {
1025 	      offsetT value = expn.X_add_number;
1026 	      /* Truncate overflows.  */
1027 	      switch (octets)
1028 		{
1029 		case 1:
1030 		  if ((value > 0 && value > 0xFF)
1031 		      || (value < 0 && value < - 0x100))
1032 		    as_warn (_("Overflow in expression, truncated to 8 bits"));
1033 		  break;
1034 		case 2:
1035 		  if ((value > 0 && value > 0xFFFF)
1036 		      || (value < 0 && value < - 0x10000))
1037 		    as_warn (_("Overflow in expression, truncated to 16 bits"));
1038 		  break;
1039 		}
1040 	    }
1041 	  if (expn.X_op != O_constant && octets < 2)
1042 	    {
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 ();
1047 	      return;
1048 	    }
1049 
1050 	  if (expn.X_op != O_constant
1051 	      && amode == c_mode
1052 	      && octets == 4)
1053 	    {
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).  */
1059 	      amode = far_mode;
1060 	      emitting_long = 1;
1061 	      emit_expr (&expn, 4);
1062 	      emitting_long = 0;
1063 	      amode = c_mode;
1064 	    }
1065 	  else
1066 	    {
1067 	      emitting_long = octets == 4;
1068 	      emit_expr (&expn, (octets == 1) ? 2 : octets);
1069 	      emitting_long = 0;
1070 	    }
1071 	}
1072     }
1073   while (*input_line_pointer++ == ',');
1074 
1075   input_line_pointer--;		/* Put terminator back into stream.  */
1076   demand_empty_rest_of_line ();
1077 }
1078 
1079 /* .global <symbol>[,...,<symbolN>]
1080    .def    <symbol>[,...,<symbolN>]
1081    .ref    <symbol>[,...,<symbolN>]
1082 
1083    These all identify global symbols.
1084 
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.
1087 
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.
1090 
1091    .global should act as a .ref or .def, as needed.
1092 
1093    global, def and ref all have symbol storage classes of C_EXT.
1094 
1095    I can't identify any difference in how the "other" c54x assembler treats
1096    these, so we ignore the type here.  */
1097 
1098 void
tic54x_global(int type)1099 tic54x_global (int type)
1100 {
1101   char *name;
1102   int c;
1103   symbolS *symbolP;
1104 
1105   if (type == 'r')
1106     as_warn (_("Use of .def/.ref is deprecated.  Use .global instead"));
1107 
1108   ILLEGAL_WITHIN_STRUCT ();
1109 
1110   do
1111     {
1112       name = input_line_pointer;
1113       c = get_symbol_end ();
1114       symbolP = symbol_find_or_make (name);
1115 
1116       *input_line_pointer = c;
1117       S_SET_STORAGE_CLASS (symbolP, C_EXT);
1118       if (c == ',')
1119 	{
1120 	  input_line_pointer++;
1121 	  if (is_end_of_line[(int) *input_line_pointer])
1122 	    c = *input_line_pointer;
1123 	}
1124     }
1125   while (c == ',');
1126 
1127   demand_empty_rest_of_line ();
1128 }
1129 
1130 /* Remove the symbol from the local label hash lookup.  */
1131 
1132 static void
tic54x_remove_local_label(const char * key,void * value ATTRIBUTE_UNUSED)1133 tic54x_remove_local_label (const char *key, void *value ATTRIBUTE_UNUSED)
1134 {
1135   void *elem = hash_delete (local_label_hash[macro_level], key, FALSE);
1136   free (elem);
1137 }
1138 
1139 /* Reset all local labels.  */
1140 
1141 static void
tic54x_clear_local_labels(int ignored ATTRIBUTE_UNUSED)1142 tic54x_clear_local_labels (int ignored ATTRIBUTE_UNUSED)
1143 {
1144   hash_traverse (local_label_hash[macro_level], tic54x_remove_local_label);
1145 }
1146 
1147 /* .text
1148    .data
1149    .sect "section name"
1150 
1151    Initialized section
1152    make sure local labels get cleared when changing sections
1153 
1154    ARG is 't' for text, 'd' for data, or '*' for a named section
1155 
1156    For compatibility, '*' sections are SEC_CODE if instructions are
1157    encountered, or SEC_DATA if not.
1158 */
1159 
1160 static void
tic54x_sect(int arg)1161 tic54x_sect (int arg)
1162 {
1163   ILLEGAL_WITHIN_STRUCT ();
1164 
1165   /* Local labels are cleared when changing sections.  */
1166   tic54x_clear_local_labels (0);
1167 
1168   if (arg == 't')
1169     s_text (0);
1170   else if (arg == 'd')
1171     s_data (0);
1172   else
1173     {
1174       char *name = NULL;
1175       int len;
1176 
1177       /* If there are quotes, remove them.  */
1178       if (*input_line_pointer == '"')
1179 	{
1180 	  name = demand_copy_C_string (&len);
1181 	  demand_empty_rest_of_line ();
1182 	  name = strcpy (xmalloc (len + 10), name);
1183 	}
1184       else
1185 	{
1186 	  int c;
1187 	  name = input_line_pointer;
1188 	  c = get_symbol_end ();
1189           len = strlen(name);
1190 	  name = strcpy (xmalloc (len + 10), name);
1191 	  *input_line_pointer = c;
1192 	  demand_empty_rest_of_line ();
1193 	}
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);
1199 
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)
1205 	{
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);
1211 	}
1212     }
1213 }
1214 
1215 /* [symbol] .space space_in_bits
1216    [symbol] .bes space_in_bits
1217    BES puts the symbol at the *last* word allocated
1218 
1219    cribbed from s_space.  */
1220 
1221 static void
tic54x_space(int arg)1222 tic54x_space (int arg)
1223 {
1224   expressionS expn;
1225   char *p = 0;
1226   int octets = 0;
1227   long words;
1228   int bits_per_byte = (OCTETS_PER_BYTE * 8);
1229   int bit_offset = 0;
1230   symbolS *label = line_label;
1231   int bes = arg;
1232 
1233   ILLEGAL_WITHIN_STRUCT ();
1234 
1235 #ifdef md_flush_pending_output
1236   md_flush_pending_output ();
1237 #endif
1238 
1239   /* Read the bit count.  */
1240   expression (&expn);
1241 
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)
1246     {
1247       struct bit_info *bi = xmalloc (sizeof (struct bit_info));
1248 
1249       bi->seg = now_seg;
1250       bi->type = bes;
1251       bi->sym = label;
1252       p = frag_var (rs_machine_dependent,
1253 		    65536 * 2, 1, (relax_substateT) 0,
1254 		    make_expr_symbol (&expn), (offsetT) 0,
1255 		    (char *) bi);
1256       if (p)
1257 	*p = 0;
1258 
1259       return;
1260     }
1261 
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)
1266     {
1267       int spare_bits = bits_per_byte - bit_offset;
1268 
1269       if (spare_bits >= expn.X_add_number)
1270 	{
1271 	  /* Don't have to do anything; sufficient bits have already been
1272 	     allocated; just point the label to the right place.  */
1273 	  if (label != NULL)
1274 	    {
1275 	      symbol_set_frag (label, frag_now);
1276 	      S_SET_VALUE (label, frag_now_fix () - 1);
1277 	      label = NULL;
1278 	    }
1279 	  frag_now->tc_frag_data += expn.X_add_number;
1280 	  goto getout;
1281 	}
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)
1286 	{
1287 	  symbol_set_frag (label, frag_now);
1288 	  S_SET_VALUE (label, frag_now_fix () - 1);
1289 	  label = NULL;
1290 	}
1291     }
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;
1297   if (octets < 0)
1298     {
1299       as_warn (_(".space/.bes repeat count is negative, ignored"));
1300       goto getout;
1301     }
1302   else if (octets == 0)
1303     {
1304       as_warn (_(".space/.bes repeat count is zero, ignored"));
1305       goto getout;
1306     }
1307 
1308   /* If we are in the absolute section, just bump the offset.  */
1309   if (now_seg == absolute_section)
1310     {
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;
1315       goto getout;
1316     }
1317 
1318   if (!need_pass_2)
1319     p = frag_var (rs_fill, 1, 1,
1320 		  (relax_substateT) 0, (symbolS *) 0,
1321 		  (offsetT) octets, (char *) 0);
1322 
1323   /* Make note of how many bits of this word we've allocated so far.  */
1324   frag_now->tc_frag_data = bit_offset;
1325 
1326   /* .bes puts label at *last* word allocated.  */
1327   if (bes && label != NULL)
1328     {
1329       symbol_set_frag (label, frag_now);
1330       S_SET_VALUE (label, frag_now_fix () - 1);
1331     }
1332 
1333   if (p)
1334     *p = 0;
1335 
1336  getout:
1337 
1338   demand_empty_rest_of_line ();
1339 }
1340 
1341 /* [symbol] .usect "section-name", size-in-words
1342 		   [, [blocking-flag] [, alignment-flag]]
1343 
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.
1348 
1349    Has no effect on the current section.  */
1350 
1351 static void
tic54x_usect(int x ATTRIBUTE_UNUSED)1352 tic54x_usect (int x ATTRIBUTE_UNUSED)
1353 {
1354   char c;
1355   char *name;
1356   char *section_name;
1357   char *p;
1358   segT seg;
1359   int size, blocking_flag, alignment_flag;
1360   segT current_seg;
1361   subsegT current_subseg;
1362   flagword flags;
1363 
1364   ILLEGAL_WITHIN_STRUCT ();
1365 
1366   current_seg = now_seg;	/* Save current seg.  */
1367   current_subseg = now_subseg;	/* Save current subseg.  */
1368 
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);
1376 
1377   if (*input_line_pointer == ',')
1378     ++input_line_pointer;
1379   else if (c != ',')
1380     {
1381       as_bad (_("Missing size argument"));
1382       ignore_rest_of_line ();
1383       return;
1384     }
1385 
1386   size = get_absolute_expression ();
1387 
1388   /* Read a possibly present third argument (blocking flag).  */
1389   if (*input_line_pointer == ',')
1390     {
1391       ++input_line_pointer;
1392       if (*input_line_pointer != ',')
1393 	blocking_flag = get_absolute_expression ();
1394       else
1395 	blocking_flag = 0;
1396 
1397       /* Read a possibly present fourth argument (alignment flag).  */
1398       if (*input_line_pointer == ',')
1399 	{
1400 	  ++input_line_pointer;
1401 	  alignment_flag = get_absolute_expression ();
1402 	}
1403       else
1404 	alignment_flag = 0;
1405     }
1406   else
1407     blocking_flag = alignment_flag = 0;
1408 
1409   seg = subseg_new (name, 0);
1410   flags = bfd_get_section_flags (stdoutput, seg) | SEC_ALLOC;
1411 
1412   if (alignment_flag)
1413     {
1414       /* s_align eats end of line; restore it.  */
1415       s_align_bytes (4);
1416       --input_line_pointer;
1417     }
1418 
1419   if (line_label != NULL)
1420     {
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);
1427     }
1428 
1429   seg_info (seg)->bss = 1;	/* Uninitialized data.  */
1430 
1431   p = frag_var (rs_fill, 1, 1,
1432 		(relax_substateT) 0, (symbolS *) line_label,
1433 		size * OCTETS_PER_BYTE, (char *) 0);
1434   *p = 0;
1435 
1436   if (blocking_flag)
1437     flags |= SEC_TIC54X_BLOCK;
1438 
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 ()));
1442 
1443   subseg_set (current_seg, current_subseg);	/* Restore current seg.  */
1444   demand_empty_rest_of_line ();
1445 }
1446 
1447 static enum cpu_version
lookup_version(const char * ver)1448 lookup_version (const char *ver)
1449 {
1450   enum cpu_version version = VNONE;
1451 
1452   if (ver[0] == '5' && ver[1] == '4')
1453     {
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;
1463     }
1464 
1465   return version;
1466 }
1467 
1468 static void
set_cpu(enum cpu_version version)1469 set_cpu (enum cpu_version version)
1470 {
1471   cpu = version;
1472   if (version == V545LP || version == V546LP)
1473     {
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);
1478     }
1479 }
1480 
1481 /* .version cpu-version
1482    cpu-version may be one of the following:
1483    541
1484    542
1485    543
1486    545
1487    545LP
1488    546LP
1489    548
1490    549
1491 
1492    This is for compatibility only.  It currently has no affect on assembly.  */
1493 static int cpu_needs_set = 1;
1494 
1495 static void
tic54x_version(int x ATTRIBUTE_UNUSED)1496 tic54x_version (int x ATTRIBUTE_UNUSED)
1497 {
1498   enum cpu_version version = VNONE;
1499   enum cpu_version old_version = cpu;
1500   int c;
1501   char *ver;
1502 
1503   ILLEGAL_WITHIN_STRUCT ();
1504 
1505   SKIP_WHITESPACE ();
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;
1511 
1512   version = lookup_version (ver);
1513 
1514   if (cpu != VNONE && cpu != version)
1515     as_warn (_("CPU version has already been set"));
1516 
1517   if (version == VNONE)
1518     {
1519       as_bad (_("Unrecognized version '%s'"), ver);
1520       ignore_rest_of_line ();
1521       return;
1522     }
1523   else if (assembly_begun && version != old_version)
1524     {
1525       as_bad (_("Changing of CPU version on the fly not supported"));
1526       ignore_rest_of_line ();
1527       return;
1528     }
1529 
1530   set_cpu (version);
1531 
1532   *input_line_pointer = c;
1533   demand_empty_rest_of_line ();
1534 }
1535 
1536 /* 'f' = float, 'x' = xfloat, 'd' = double, 'l' = ldouble.  */
1537 
1538 static void
tic54x_float_cons(int type)1539 tic54x_float_cons (int type)
1540 {
1541   if (current_stag != 0)
1542     tic54x_struct_field ('f');
1543 
1544 #ifdef md_flush_pending_output
1545   md_flush_pending_output ();
1546 #endif
1547 
1548   /* Align to long word boundary (4 octets) unless it's ".xfloat".  */
1549   if (type != 'x')
1550     {
1551       frag_align (2, 0, 2);
1552       /* If there's a label, assign it to the first allocated word.  */
1553       if (line_label != NULL)
1554 	{
1555 	  symbol_set_frag (line_label, frag_now);
1556 	  S_SET_VALUE (line_label, frag_now_fix ());
1557 	}
1558     }
1559 
1560   float_cons ('f');
1561 }
1562 
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.  */
1567 
1568 static void
tic54x_stringer(int type)1569 tic54x_stringer (int type)
1570 {
1571   unsigned int c;
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.  */
1575 
1576   if (current_stag != NULL)
1577     {
1578       tic54x_struct_field ('*');
1579       return;
1580     }
1581 
1582 #ifdef md_flush_pending_output
1583   md_flush_pending_output ();
1584 #endif
1585 
1586   c = ',';			/* Do loop.  */
1587   while (c == ',')
1588     {
1589       SKIP_WHITESPACE ();
1590       switch (*input_line_pointer)
1591 	{
1592 	default:
1593 	  {
1594 	    unsigned short value = get_absolute_expression ();
1595 	    FRAG_APPEND_1_CHAR ( value       & 0xFF);
1596 	    FRAG_APPEND_1_CHAR ((value >> 8) & 0xFF);
1597 	    break;
1598 	  }
1599 	case '\"':
1600 	  ++input_line_pointer;	/* -> 1st char of string.  */
1601 	  while (is_a_char (c = next_char_of_string ()))
1602 	    {
1603 	      if (!packed)
1604 		{
1605 		  FRAG_APPEND_1_CHAR (c);
1606 		  FRAG_APPEND_1_CHAR (0);
1607 		}
1608 	      else
1609 		{
1610 		  /* Packed strings are filled MS octet first.  */
1611 		  if (last_char == -1)
1612 		    last_char = c;
1613 		  else
1614 		    {
1615 		      FRAG_APPEND_1_CHAR (c);
1616 		      FRAG_APPEND_1_CHAR (last_char);
1617 		      last_char = -1;
1618 		    }
1619 		}
1620 	    }
1621 	  if (append_zero)
1622 	    {
1623 	      if (packed && last_char != -1)
1624 		{
1625 		  FRAG_APPEND_1_CHAR (0);
1626 		  FRAG_APPEND_1_CHAR (last_char);
1627 		  last_char = -1;
1628 		}
1629 	      else
1630 		{
1631 		  FRAG_APPEND_1_CHAR (0);
1632 		  FRAG_APPEND_1_CHAR (0);
1633 		}
1634 	    }
1635 	  know (input_line_pointer[-1] == '\"');
1636 	  break;
1637 	}
1638       SKIP_WHITESPACE ();
1639       c = *input_line_pointer;
1640       if (!is_end_of_line[c])
1641 	++input_line_pointer;
1642     }
1643 
1644   /* Finish up any leftover packed string.  */
1645   if (packed && last_char != -1)
1646     {
1647       FRAG_APPEND_1_CHAR (0);
1648       FRAG_APPEND_1_CHAR (last_char);
1649     }
1650   demand_empty_rest_of_line ();
1651 }
1652 
1653 static void
tic54x_p2align(int arg ATTRIBUTE_UNUSED)1654 tic54x_p2align (int arg ATTRIBUTE_UNUSED)
1655 {
1656   as_bad (_("p2align not supported on this target"));
1657 }
1658 
1659 static void
tic54x_align_words(int arg)1660 tic54x_align_words (int arg)
1661 {
1662   /* Only ".align" with no argument is allowed within .struct/.union.  */
1663   int count = arg;
1664 
1665   if (!is_end_of_line[(int) *input_line_pointer])
1666     {
1667       if (arg == 2)
1668 	as_warn (_("Argument to .even ignored"));
1669       else
1670 	count = get_absolute_expression ();
1671     }
1672 
1673   if (current_stag != NULL && arg == 128)
1674     {
1675       if (current_stag->current_bitfield_offset != 0)
1676 	{
1677 	  current_stag->current_bitfield_offset = 0;
1678 	  ++abs_section_offset;
1679 	}
1680       demand_empty_rest_of_line ();
1681       return;
1682     }
1683 
1684   ILLEGAL_WITHIN_STRUCT ();
1685 
1686   s_align_bytes (count << 1);
1687 }
1688 
1689 /* Initialize multiple-bit fields withing a single word of memory.  */
1690 
1691 static void
tic54x_field(int ignore ATTRIBUTE_UNUSED)1692 tic54x_field (int ignore ATTRIBUTE_UNUSED)
1693 {
1694   expressionS expn;
1695   int size = 16;
1696   char *p;
1697   valueT value;
1698   symbolS *label = line_label;
1699 
1700   if (current_stag != NULL)
1701     {
1702       tic54x_struct_field ('.');
1703       return;
1704     }
1705 
1706   input_line_pointer = parse_expression (input_line_pointer, &expn);
1707 
1708   if (*input_line_pointer == ',')
1709     {
1710       ++input_line_pointer;
1711       size = get_absolute_expression ();
1712       if (size < 1 || size > 32)
1713 	{
1714 	  as_bad (_("Invalid field size, must be from 1 to 32"));
1715 	  ignore_rest_of_line ();
1716 	  return;
1717 	}
1718     }
1719 
1720   /* Truncate values to the field width.  */
1721   if (expn.X_op != O_constant)
1722     {
1723       /* If the expression value is relocatable, the field size *must*
1724          be 16.  */
1725       if (size != 16)
1726 	{
1727 	  as_bad (_("field size must be 16 when value is relocatable"));
1728 	  ignore_rest_of_line ();
1729 	  return;
1730 	}
1731 
1732       frag_now->tc_frag_data = 0;
1733       emit_expr (&expn, 2);
1734     }
1735   else
1736     {
1737       unsigned long fmask = (size == 32) ? 0xFFFFFFFF : (1ul << size) - 1;
1738 
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.  */
1745       while (size >= 16)
1746 	{
1747 	  frag_now->tc_frag_data = 0;
1748 	  p = frag_more (2);
1749 	  md_number_to_chars (p, (value >> (size - 16)) & 0xFFFF, 2);
1750 	  size -= 16;
1751 	}
1752       if (size > 0)
1753 	{
1754 	  int bit_offset = frag_bit_offset (frag_now, now_seg);
1755 
1756 	  fragS *alloc_frag = bit_offset_frag (frag_now, now_seg);
1757 	  if (bit_offset == -1)
1758 	    {
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;
1763 
1764 	      size_exp.X_op = O_constant;
1765 	      size_exp.X_add_number = size;
1766 	      bi->seg = now_seg;
1767 	      bi->type = TYPE_FIELD;
1768 	      bi->value = value;
1769 	      p = frag_var (rs_machine_dependent,
1770 			    4, 1, (relax_substateT) 0,
1771 			    make_expr_symbol (&size_exp), (offsetT) 0,
1772 			    (char *) bi);
1773 	      goto getout;
1774 	    }
1775 	  else if (bit_offset == 0 || bit_offset + size > 16)
1776 	    {
1777 	      /* Align a new field.  */
1778 	      p = frag_more (2);
1779 	      frag_now->tc_frag_data = 0;
1780 	      alloc_frag = frag_now;
1781 	    }
1782 	  else
1783 	    {
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;
1788 	      if (label != NULL)
1789 		{
1790 		  symbol_set_frag (label, alloc_frag);
1791 		  if (alloc_frag == frag_now)
1792 		    S_SET_VALUE (label, frag_now_fix () - 1);
1793 		  label = NULL;
1794 		}
1795 	    }
1796 	  value <<= 16 - alloc_frag->tc_frag_data - size;
1797 
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;
1805 	}
1806     }
1807  getout:
1808   demand_empty_rest_of_line ();
1809 }
1810 
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.  */
1813 
1814 static int
tic54x_initialized_section(segT seg)1815 tic54x_initialized_section (segT seg)
1816 {
1817   return !seg_info (seg)->bss;
1818 }
1819 
1820 /* .clink ["section name"]
1821 
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.  */
1826 
1827 static void
tic54x_clink(int ignored ATTRIBUTE_UNUSED)1828 tic54x_clink (int ignored ATTRIBUTE_UNUSED)
1829 {
1830   segT seg = now_seg;
1831 
1832   ILLEGAL_WITHIN_STRUCT ();
1833 
1834   if (*input_line_pointer == '\"')
1835     {
1836       char *section_name = ++input_line_pointer;
1837       char *name;
1838 
1839       while (is_a_char (next_char_of_string ()))
1840 	;
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);
1845 
1846       seg = bfd_get_section_by_name (stdoutput, name);
1847       if (seg == NULL)
1848 	{
1849 	  as_bad (_("Unrecognized section '%s'"), section_name);
1850 	  ignore_rest_of_line ();
1851 	  return;
1852 	}
1853     }
1854   else
1855     {
1856       if (!tic54x_initialized_section (seg))
1857 	{
1858 	  as_bad (_("Current section is unitialized, "
1859 		    "section name required for .clink"));
1860 	  ignore_rest_of_line ();
1861 	  return;
1862 	}
1863     }
1864 
1865   seg->flags |= SEC_TIC54X_CLINK;
1866 
1867   demand_empty_rest_of_line ();
1868 }
1869 
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.  */
1873 
1874 static void
tic54x_set_default_include(int dot)1875 tic54x_set_default_include (int dot)
1876 {
1877   char *dir = ".";
1878   char *tmp = NULL;
1879 
1880   if (!dot)
1881     {
1882       char *curfile;
1883       unsigned lineno;
1884 
1885       as_where (&curfile, &lineno);
1886       dir = strcpy (xmalloc (strlen (curfile) + 1), curfile);
1887       tmp = strrchr (dir, '/');
1888     }
1889   if (tmp != NULL)
1890     {
1891       int len;
1892 
1893       *tmp = '\0';
1894       len = strlen (dir);
1895       if (include_dir_count == 0)
1896 	{
1897 	  include_dirs = (char **) xmalloc (sizeof (*include_dirs));
1898 	  include_dir_count = 1;
1899 	}
1900       include_dirs[0] = dir;
1901       if (len > include_dir_maxlen)
1902 	include_dir_maxlen = len;
1903     }
1904   else if (include_dirs != NULL)
1905     include_dirs[0] = ".";
1906 }
1907 
1908 /* .include "filename" | filename
1909    .copy    "filename" | filename
1910 
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?
1916 
1917    Entering/exiting included/copied file clears all local labels.  */
1918 
1919 static void
tic54x_include(int ignored ATTRIBUTE_UNUSED)1920 tic54x_include (int ignored ATTRIBUTE_UNUSED)
1921 {
1922   char newblock[] = " .newblock\n";
1923   char *filename;
1924   char *input;
1925   int len, c = -1;
1926 
1927   ILLEGAL_WITHIN_STRUCT ();
1928 
1929   SKIP_WHITESPACE ();
1930 
1931   if (*input_line_pointer == '"')
1932     {
1933       filename = demand_copy_C_string (&len);
1934       demand_empty_rest_of_line ();
1935     }
1936   else
1937     {
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 ();
1946     }
1947   /* Insert a partial line with the filename (for the sake of s_include)
1948      and a .newblock.
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);
1954 
1955   tic54x_clear_local_labels (0);
1956 
1957   tic54x_set_default_include (0);
1958 
1959   s_include (0);
1960 }
1961 
1962 static void
tic54x_message(int type)1963 tic54x_message (int type)
1964 {
1965   char *msg;
1966   char c;
1967   int len;
1968 
1969   ILLEGAL_WITHIN_STRUCT ();
1970 
1971   if (*input_line_pointer == '"')
1972     msg = demand_copy_C_string (&len);
1973   else
1974     {
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;
1982     }
1983 
1984   switch (type)
1985     {
1986     case 'm':
1987       as_tsktsk ("%s", msg);
1988       break;
1989     case 'w':
1990       as_warn ("%s", msg);
1991       break;
1992     case 'e':
1993       as_bad ("%s", msg);
1994       break;
1995     }
1996 
1997   demand_empty_rest_of_line ();
1998 }
1999 
2000 /* .label <symbol>
2001    Define a special symbol that refers to the loadtime address rather than the
2002    runtime address within the current section.
2003 
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).  */
2007 
2008 static void
tic54x_label(int ignored ATTRIBUTE_UNUSED)2009 tic54x_label (int ignored ATTRIBUTE_UNUSED)
2010 {
2011   char *name = input_line_pointer;
2012   symbolS *symbolP;
2013   int c;
2014 
2015   ILLEGAL_WITHIN_STRUCT ();
2016 
2017   c = get_symbol_end ();
2018   symbolP = colon (name);
2019   S_SET_STORAGE_CLASS (symbolP, C_STATLAB);
2020 
2021   *input_line_pointer = c;
2022   demand_empty_rest_of_line ();
2023 }
2024 
2025 /* .mmregs
2026    Install all memory-mapped register names into the symbol table as
2027    absolute local symbols.  */
2028 
2029 static void
tic54x_mmregs(int ignored ATTRIBUTE_UNUSED)2030 tic54x_mmregs (int ignored ATTRIBUTE_UNUSED)
2031 {
2032   symbol *sym;
2033 
2034   ILLEGAL_WITHIN_STRUCT ();
2035 
2036   for (sym = (symbol *) mmregs; sym->name; sym++)
2037     {
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);
2042     }
2043 }
2044 
2045 /* .loop [count]
2046    Count defaults to 1024.  */
2047 
2048 static void
tic54x_loop(int count)2049 tic54x_loop (int count)
2050 {
2051   ILLEGAL_WITHIN_STRUCT ();
2052 
2053   SKIP_WHITESPACE ();
2054   if (!is_end_of_line[(int) *input_line_pointer])
2055     count = get_absolute_expression ();
2056 
2057   do_repeat (count, "LOOP", "ENDLOOP");
2058 }
2059 
2060 /* Normally, endloop gets eaten by the preceding loop.  */
2061 
2062 static void
tic54x_endloop(int ignore ATTRIBUTE_UNUSED)2063 tic54x_endloop (int ignore ATTRIBUTE_UNUSED)
2064 {
2065   as_bad (_("ENDLOOP without corresponding LOOP"));
2066   ignore_rest_of_line ();
2067 }
2068 
2069 /* .break [condition].  */
2070 
2071 static void
tic54x_break(int ignore ATTRIBUTE_UNUSED)2072 tic54x_break (int ignore ATTRIBUTE_UNUSED)
2073 {
2074   int cond = 1;
2075 
2076   ILLEGAL_WITHIN_STRUCT ();
2077 
2078   SKIP_WHITESPACE ();
2079   if (!is_end_of_line[(int) *input_line_pointer])
2080     cond = get_absolute_expression ();
2081 
2082   if (cond)
2083     end_repeat (substitution_line ? 1 : 0);
2084 }
2085 
2086 static void
set_address_mode(int mode)2087 set_address_mode (int mode)
2088 {
2089   amode = mode;
2090   if (mode == far_mode)
2091     {
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);
2096     }
2097 }
2098 
2099 static int address_mode_needs_set = 1;
2100 
2101 static void
tic54x_address_mode(int mode)2102 tic54x_address_mode (int mode)
2103 {
2104   if (assembly_begun && amode != (unsigned) mode)
2105     {
2106       as_bad (_("Mixing of normal and extended addressing not supported"));
2107       ignore_rest_of_line ();
2108       return;
2109     }
2110   if (mode == far_mode && cpu != VNONE && cpu != V548 && cpu != V549)
2111     {
2112       as_bad (_("Extended addressing not supported on the specified CPU"));
2113       ignore_rest_of_line ();
2114       return;
2115     }
2116 
2117   set_address_mode (mode);
2118   demand_empty_rest_of_line ();
2119 }
2120 
2121 /* .sblock "section"|section [,...,"section"|section]
2122    Designate initialized sections for blocking.  */
2123 
2124 static void
tic54x_sblock(int ignore ATTRIBUTE_UNUSED)2125 tic54x_sblock (int ignore ATTRIBUTE_UNUSED)
2126 {
2127   int c = ',';
2128 
2129   ILLEGAL_WITHIN_STRUCT ();
2130 
2131   while (c == ',')
2132     {
2133       segT seg;
2134       char *name;
2135 
2136       if (*input_line_pointer == '"')
2137 	{
2138 	  int len;
2139 
2140 	  name = demand_copy_C_string (&len);
2141 	}
2142       else
2143 	{
2144 	  char *section_name = input_line_pointer;
2145 
2146 	  c = get_symbol_end ();
2147 	  name = xmalloc (strlen (section_name) + 1);
2148 	  strcpy (name, section_name);
2149 	  *input_line_pointer = c;
2150 	}
2151 
2152       seg = bfd_get_section_by_name (stdoutput, name);
2153       if (seg == NULL)
2154 	{
2155 	  as_bad (_("Unrecognized section '%s'"), name);
2156 	  ignore_rest_of_line ();
2157 	  return;
2158 	}
2159       else if (!tic54x_initialized_section (seg))
2160 	{
2161 	  as_bad (_(".sblock may be used for initialized sections only"));
2162 	  ignore_rest_of_line ();
2163 	  return;
2164 	}
2165       seg->flags |= SEC_TIC54X_BLOCK;
2166 
2167       c = *input_line_pointer;
2168       if (!is_end_of_line[(int) c])
2169 	++input_line_pointer;
2170     }
2171 
2172   demand_empty_rest_of_line ();
2173 }
2174 
2175 /* symbol .set value
2176    symbol .equ value
2177 
2178    value must be defined externals; no forward-referencing allowed
2179    symbols assigned with .set/.equ may not be redefined.  */
2180 
2181 static void
tic54x_set(int ignore ATTRIBUTE_UNUSED)2182 tic54x_set (int ignore ATTRIBUTE_UNUSED)
2183 {
2184   symbolS *symbolP;
2185   char *name;
2186 
2187   ILLEGAL_WITHIN_STRUCT ();
2188 
2189   if (!line_label)
2190     {
2191       as_bad (_("Symbol missing for .set/.equ"));
2192       ignore_rest_of_line ();
2193       return;
2194     }
2195   name = xstrdup (S_GET_NAME (line_label));
2196   line_label = NULL;
2197   if ((symbolP = symbol_find (name)) == NULL
2198       && (symbolP = md_undefined_symbol (name)) == NULL)
2199     {
2200       symbolP = symbol_new (name, absolute_section, 0, &zero_address_frag);
2201       S_SET_STORAGE_CLASS (symbolP, C_STAT);
2202     }
2203   free (name);
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 ();
2209 }
2210 
2211 /* .fclist
2212    .fcnolist
2213    List false conditional blocks.  */
2214 
2215 static void
tic54x_fclist(int show)2216 tic54x_fclist (int show)
2217 {
2218   if (show)
2219     listing &= ~LISTING_NOCOND;
2220   else
2221     listing |= LISTING_NOCOND;
2222   demand_empty_rest_of_line ();
2223 }
2224 
2225 static void
tic54x_sslist(int show)2226 tic54x_sslist (int show)
2227 {
2228   ILLEGAL_WITHIN_STRUCT ();
2229 
2230   listing_sslist = show;
2231 }
2232 
2233 /* .var SYM[,...,SYMN]
2234    Define a substitution string to be local to a macro.  */
2235 
2236 static void
tic54x_var(int ignore ATTRIBUTE_UNUSED)2237 tic54x_var (int ignore ATTRIBUTE_UNUSED)
2238 {
2239   static char empty[] = "";
2240   char *name;
2241   int c;
2242 
2243   ILLEGAL_WITHIN_STRUCT ();
2244 
2245   if (macro_level == 0)
2246     {
2247       as_bad (_(".var may only be used within a macro definition"));
2248       ignore_rest_of_line ();
2249       return;
2250     }
2251   do
2252     {
2253       if (!ISALPHA (*input_line_pointer))
2254 	{
2255 	  as_bad (_("Substitution symbols must begin with a letter"));
2256 	  ignore_rest_of_line ();
2257 	  return;
2258 	}
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;
2265       if (c == ',')
2266 	{
2267 	  ++input_line_pointer;
2268 	  if (is_end_of_line[(int) *input_line_pointer])
2269 	    c = *input_line_pointer;
2270 	}
2271     }
2272   while (c == ',');
2273 
2274   demand_empty_rest_of_line ();
2275 }
2276 
2277 /* .mlib <macro library filename>
2278 
2279    Macro libraries are archived (standard AR-format) text macro definitions
2280    Expand the file and include it.
2281 
2282    FIXME need to try the source file directory as well.  */
2283 
2284 static void
tic54x_mlib(int ignore ATTRIBUTE_UNUSED)2285 tic54x_mlib (int ignore ATTRIBUTE_UNUSED)
2286 {
2287   char *filename;
2288   char *path;
2289   int len, i;
2290   bfd *abfd, *mbfd;
2291 
2292   ILLEGAL_WITHIN_STRUCT ();
2293 
2294   /* Parse the filename.  */
2295   if (*input_line_pointer == '"')
2296     {
2297       if ((filename = demand_copy_C_string (&len)) == NULL)
2298 	return;
2299     }
2300   else
2301     {
2302       SKIP_WHITESPACE ();
2303       len = 0;
2304       while (!is_end_of_line[(int) *input_line_pointer]
2305 	     && !ISSPACE (*input_line_pointer))
2306 	{
2307 	  obstack_1grow (&notes, *input_line_pointer);
2308 	  ++input_line_pointer;
2309 	  ++len;
2310 	}
2311       obstack_1grow (&notes, '\0');
2312       filename = obstack_finish (&notes);
2313     }
2314   demand_empty_rest_of_line ();
2315 
2316   tic54x_set_default_include (0);
2317   path = xmalloc ((unsigned long) len + include_dir_maxlen + 5);
2318 
2319   for (i = 0; i < include_dir_count; i++)
2320     {
2321       FILE *try;
2322 
2323       strcpy (path, include_dirs[i]);
2324       strcat (path, "/");
2325       strcat (path, filename);
2326       if ((try = fopen (path, "r")) != NULL)
2327 	{
2328 	  fclose (try);
2329 	  break;
2330 	}
2331     }
2332 
2333   if (i >= include_dir_count)
2334     {
2335       free (path);
2336       path = filename;
2337     }
2338 
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);
2343 
2344   /* Expand all archive entries to temporary files and include them.  */
2345   abfd = bfd_openr (path, NULL);
2346   if (!abfd)
2347     {
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 ();
2351       return;
2352     }
2353   if (!bfd_check_format (abfd, bfd_archive))
2354     {
2355       as_bad (_("File '%s' not in macro archive format"), path);
2356       ignore_rest_of_line ();
2357       return;
2358     }
2359 
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))
2363     {
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);
2368       FILE *ftmp;
2369 
2370       /* We're not sure how big it is, but it will be smaller than "size".  */
2371       size = bfd_bread (buf, size, mbfd);
2372 
2373       /* Write to a temporary file, then use s_include to include it
2374 	 a bit of a hack.  */
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);
2379       fclose (ftmp);
2380       free (buf);
2381       input_scrub_insert_file (fname);
2382       unlink (fname);
2383     }
2384 }
2385 
2386 const pseudo_typeS md_pseudo_table[] =
2387 {
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
2434                                                              address.  */
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 },
2470   {0           , 0                        ,          0 }
2471 };
2472 
2473 int
md_parse_option(int c,char * arg)2474 md_parse_option (int c, char *arg)
2475 {
2476   switch (c)
2477     {
2478     default:
2479       return 0;
2480     case OPTION_COFF_VERSION:
2481       {
2482 	int version = atoi (arg);
2483 
2484 	if (version != 0 && version != 1 && version != 2)
2485 	  as_fatal (_("Bad COFF version '%s'"), arg);
2486 	/* FIXME -- not yet implemented.  */
2487 	break;
2488       }
2489     case OPTION_CPU_VERSION:
2490       {
2491 	cpu = lookup_version (arg);
2492 	cpu_needs_set = 1;
2493 	if (cpu == VNONE)
2494 	  as_fatal (_("Bad CPU version '%s'"), arg);
2495 	break;
2496       }
2497     case OPTION_ADDRESS_MODE:
2498       amode = far_mode;
2499       address_mode_needs_set = 1;
2500       break;
2501     case OPTION_STDERR_TO_FILE:
2502       {
2503 	char *filename = arg;
2504 	FILE *fp = fopen (filename, "w+");
2505 
2506 	if (fp == NULL)
2507 	  as_fatal (_("Can't redirect stderr to the file '%s'"), filename);
2508 	fclose (fp);
2509 	if ((fp = freopen (filename, "w+", stderr)) == NULL)
2510 	  as_fatal (_("Can't redirect stderr to the file '%s'"), filename);
2511 	break;
2512       }
2513     }
2514 
2515   return 1;
2516 }
2517 
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.  */
2522 
2523 void
tic54x_macro_start(void)2524 tic54x_macro_start (void)
2525 {
2526   ++macro_level;
2527   subsym_hash[macro_level] = hash_new ();
2528   local_label_hash[macro_level] = hash_new ();
2529 }
2530 
2531 void
tic54x_macro_info(const macro_entry * macro)2532 tic54x_macro_info (const macro_entry *macro)
2533 {
2534   const formal_entry *entry;
2535 
2536   /* Put the formal args into the substitution symbol table.  */
2537   for (entry = macro->formals; entry; entry = entry->next)
2538     {
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);
2543 
2544       name[entry->name.len] = '\0';
2545       value[entry->actual.len] = '\0';
2546       hash_insert (subsym_hash[macro_level], name, value);
2547     }
2548 }
2549 
2550 /* Get rid of this macro's .var's, arguments, and local labels.  */
2551 
2552 void
tic54x_macro_end(void)2553 tic54x_macro_end (void)
2554 {
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;
2559   --macro_level;
2560 }
2561 
2562 static int
subsym_symlen(char * a,char * ignore ATTRIBUTE_UNUSED)2563 subsym_symlen (char *a, char *ignore ATTRIBUTE_UNUSED)
2564 {
2565   return strlen (a);
2566 }
2567 
2568 /* Compare symbol A to string B.  */
2569 
2570 static int
subsym_symcmp(char * a,char * b)2571 subsym_symcmp (char *a, char *b)
2572 {
2573   return strcmp (a, b);
2574 }
2575 
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.  */
2578 
2579 static int
subsym_firstch(char * a,char * b)2580 subsym_firstch (char *a, char *b)
2581 {
2582   int val = atoi (b);
2583   char *tmp = strchr (a, val);
2584 
2585   return tmp ? tmp - a + 1 : 0;
2586 }
2587 
2588 /* Similar to firstch, but returns index of last occurrence of B in A.  */
2589 
2590 static int
subsym_lastch(char * a,char * b)2591 subsym_lastch (char *a, char *b)
2592 {
2593   int val = atoi (b);
2594   char *tmp = strrchr (a, val);
2595 
2596   return tmp ? tmp - a + 1 : 0;
2597 }
2598 
2599 /* Returns 1 if string A is defined in the symbol table (NOT the substitution
2600    symbol table).  */
2601 
2602 static int
subsym_isdefed(char * a,char * ignore ATTRIBUTE_UNUSED)2603 subsym_isdefed (char *a, char *ignore ATTRIBUTE_UNUSED)
2604 {
2605   symbolS *symbolP = symbol_find (a);
2606 
2607   return symbolP != NULL;
2608 }
2609 
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.  */
2613 
2614 static int
subsym_ismember(char * sym,char * list)2615 subsym_ismember (char *sym, char *list)
2616 {
2617   char *elem, *ptr, *listv;
2618 
2619   if (!list)
2620     return 0;
2621 
2622   listv = subsym_lookup (list, macro_level);
2623   if (!listv)
2624     {
2625       as_bad (_("Undefined substitution symbol '%s'"), list);
2626       ignore_rest_of_line ();
2627       return 0;
2628     }
2629 
2630   ptr = elem = xmalloc (strlen (listv) + 1);
2631   strcpy (elem, listv);
2632   while (*ptr && *ptr != ',')
2633     ++ptr;
2634   *ptr++ = 0;
2635 
2636   subsym_create_or_replace (sym, elem);
2637 
2638   /* Reassign the list.  */
2639   subsym_create_or_replace (list, ptr);
2640 
2641   /* Assume this value, docs aren't clear.  */
2642   return *list != 0;
2643 }
2644 
2645 /* Return zero if not a constant; otherwise:
2646    1 if binary
2647    2 if octal
2648    3 if hexadecimal
2649    4 if character
2650    5 if decimal.  */
2651 
2652 static int
subsym_iscons(char * a,char * ignore ATTRIBUTE_UNUSED)2653 subsym_iscons (char *a, char *ignore ATTRIBUTE_UNUSED)
2654 {
2655   expressionS expn;
2656 
2657   parse_expression (a, &expn);
2658 
2659   if (expn.X_op == O_constant)
2660     {
2661       int len = strlen (a);
2662 
2663       switch (TOUPPER (a[len - 1]))
2664 	{
2665 	case 'B':
2666 	  return 1;
2667 	case 'Q':
2668 	  return 2;
2669 	case 'H':
2670 	  return 3;
2671 	case '\'':
2672 	  return 4;
2673 	default:
2674 	  break;
2675 	}
2676       /* No suffix; either octal, hex, or decimal.  */
2677       if (*a == '0' && len > 1)
2678 	{
2679 	  if (TOUPPER (a[1]) == 'X')
2680 	    return 3;
2681 	  return 2;
2682 	}
2683       return 5;
2684     }
2685 
2686   return 0;
2687 }
2688 
2689 /* Return 1 if A is a valid symbol name.  Expects string input.   */
2690 
2691 static int
subsym_isname(char * a,char * ignore ATTRIBUTE_UNUSED)2692 subsym_isname (char *a, char *ignore ATTRIBUTE_UNUSED)
2693 {
2694   if (!is_name_beginner (*a))
2695     return 0;
2696   while (*a)
2697     {
2698       if (!is_part_of_name (*a))
2699 	return 0;
2700       ++a;
2701     }
2702   return 1;
2703 }
2704 
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.  */
2708 
2709 static int
subsym_isreg(char * a,char * ignore ATTRIBUTE_UNUSED)2710 subsym_isreg (char *a, char *ignore ATTRIBUTE_UNUSED)
2711 {
2712   if (hash_find (reg_hash, a))
2713     return 1;
2714   if (hash_find (mmreg_hash, a))
2715     return 1;
2716   return 0;
2717 }
2718 
2719 /* Return the structure size, given the stag.  */
2720 
2721 static int
subsym_structsz(char * name,char * ignore ATTRIBUTE_UNUSED)2722 subsym_structsz (char *name, char *ignore ATTRIBUTE_UNUSED)
2723 {
2724   struct stag *stag = (struct stag *) hash_find (stag_hash, name);
2725 
2726   if (stag)
2727     return stag->size;
2728 
2729   return 0;
2730 }
2731 
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.  */
2738 
2739 static int
subsym_structacc(char * stag_name ATTRIBUTE_UNUSED,char * ignore ATTRIBUTE_UNUSED)2740 subsym_structacc (char *stag_name ATTRIBUTE_UNUSED,
2741 		  char *ignore ATTRIBUTE_UNUSED)
2742 {
2743   return 0;
2744 }
2745 
2746 static float
math_ceil(float arg1,float ignore ATTRIBUTE_UNUSED)2747 math_ceil (float arg1, float ignore ATTRIBUTE_UNUSED)
2748 {
2749   return (float) ceil (arg1);
2750 }
2751 
2752 static float
math_cvi(float arg1,float ignore ATTRIBUTE_UNUSED)2753 math_cvi (float arg1, float ignore ATTRIBUTE_UNUSED)
2754 {
2755   return (int) arg1;
2756 }
2757 
2758 static float
math_floor(float arg1,float ignore ATTRIBUTE_UNUSED)2759 math_floor (float arg1, float ignore ATTRIBUTE_UNUSED)
2760 {
2761   return (float) floor (arg1);
2762 }
2763 
2764 static float
math_fmod(float arg1,float arg2)2765 math_fmod (float arg1, float arg2)
2766 {
2767   return (int) arg1 % (int) arg2;
2768 }
2769 
2770 static float
math_int(float arg1,float ignore ATTRIBUTE_UNUSED)2771 math_int (float arg1, float ignore ATTRIBUTE_UNUSED)
2772 {
2773   return ((float) ((int) arg1)) == arg1;
2774 }
2775 
2776 static float
math_round(float arg1,float ignore ATTRIBUTE_UNUSED)2777 math_round (float arg1, float ignore ATTRIBUTE_UNUSED)
2778 {
2779   return arg1 > 0 ? (int) (arg1 + 0.5) : (int) (arg1 - 0.5);
2780 }
2781 
2782 static float
math_sgn(float arg1,float ignore ATTRIBUTE_UNUSED)2783 math_sgn (float arg1, float ignore ATTRIBUTE_UNUSED)
2784 {
2785   return (arg1 < 0) ? -1 : (arg1 ? 1 : 0);
2786 }
2787 
2788 static float
math_trunc(float arg1,float ignore ATTRIBUTE_UNUSED)2789 math_trunc (float arg1, float ignore ATTRIBUTE_UNUSED)
2790 {
2791   return (int) arg1;
2792 }
2793 
2794 static float
math_acos(float arg1,float ignore ATTRIBUTE_UNUSED)2795 math_acos (float arg1, float ignore ATTRIBUTE_UNUSED)
2796 {
2797   return (float) acos (arg1);
2798 }
2799 
2800 static float
math_asin(float arg1,float ignore ATTRIBUTE_UNUSED)2801 math_asin (float arg1, float ignore ATTRIBUTE_UNUSED)
2802 {
2803   return (float) asin (arg1);
2804 }
2805 
2806 static float
math_atan(float arg1,float ignore ATTRIBUTE_UNUSED)2807 math_atan (float arg1, float ignore ATTRIBUTE_UNUSED)
2808 {
2809   return (float) atan (arg1);
2810 }
2811 
2812 static float
math_atan2(float arg1,float arg2)2813 math_atan2 (float arg1, float arg2)
2814 {
2815   return (float) atan2 (arg1, arg2);
2816 }
2817 
2818 static float
math_cosh(float arg1,float ignore ATTRIBUTE_UNUSED)2819 math_cosh (float arg1, float ignore ATTRIBUTE_UNUSED)
2820 {
2821   return (float) cosh (arg1);
2822 }
2823 
2824 static float
math_cos(float arg1,float ignore ATTRIBUTE_UNUSED)2825 math_cos (float arg1, float ignore ATTRIBUTE_UNUSED)
2826 {
2827   return (float) cos (arg1);
2828 }
2829 
2830 static float
math_cvf(float arg1,float ignore ATTRIBUTE_UNUSED)2831 math_cvf (float arg1, float ignore ATTRIBUTE_UNUSED)
2832 {
2833   return (float) arg1;
2834 }
2835 
2836 static float
math_exp(float arg1,float ignore ATTRIBUTE_UNUSED)2837 math_exp (float arg1, float ignore ATTRIBUTE_UNUSED)
2838 {
2839   return (float) exp (arg1);
2840 }
2841 
2842 static float
math_fabs(float arg1,float ignore ATTRIBUTE_UNUSED)2843 math_fabs (float arg1, float ignore ATTRIBUTE_UNUSED)
2844 {
2845   return (float) fabs (arg1);
2846 }
2847 
2848 /* expr1 * 2^expr2.  */
2849 
2850 static float
math_ldexp(float arg1,float arg2)2851 math_ldexp (float arg1, float arg2)
2852 {
2853   return arg1 * (float) pow (2.0, arg2);
2854 }
2855 
2856 static float
math_log10(float arg1,float ignore ATTRIBUTE_UNUSED)2857 math_log10 (float arg1, float ignore ATTRIBUTE_UNUSED)
2858 {
2859   return (float) log10 (arg1);
2860 }
2861 
2862 static float
math_log(float arg1,float ignore ATTRIBUTE_UNUSED)2863 math_log (float arg1, float ignore ATTRIBUTE_UNUSED)
2864 {
2865   return (float) log (arg1);
2866 }
2867 
2868 static float
math_max(float arg1,float arg2)2869 math_max (float arg1, float arg2)
2870 {
2871   return (arg1 > arg2) ? arg1 : arg2;
2872 }
2873 
2874 static float
math_min(float arg1,float arg2)2875 math_min (float arg1, float arg2)
2876 {
2877   return (arg1 < arg2) ? arg1 : arg2;
2878 }
2879 
2880 static float
math_pow(float arg1,float arg2)2881 math_pow (float arg1, float arg2)
2882 {
2883   return (float) pow (arg1, arg2);
2884 }
2885 
2886 static float
math_sin(float arg1,float ignore ATTRIBUTE_UNUSED)2887 math_sin (float arg1, float ignore ATTRIBUTE_UNUSED)
2888 {
2889   return (float) sin (arg1);
2890 }
2891 
2892 static float
math_sinh(float arg1,float ignore ATTRIBUTE_UNUSED)2893 math_sinh (float arg1, float ignore ATTRIBUTE_UNUSED)
2894 {
2895   return (float) sinh (arg1);
2896 }
2897 
2898 static float
math_sqrt(float arg1,float ignore ATTRIBUTE_UNUSED)2899 math_sqrt (float arg1, float ignore ATTRIBUTE_UNUSED)
2900 {
2901   return (float) sqrt (arg1);
2902 }
2903 
2904 static float
math_tan(float arg1,float ignore ATTRIBUTE_UNUSED)2905 math_tan (float arg1, float ignore ATTRIBUTE_UNUSED)
2906 {
2907   return (float) tan (arg1);
2908 }
2909 
2910 static float
math_tanh(float arg1,float ignore ATTRIBUTE_UNUSED)2911 math_tanh (float arg1, float ignore ATTRIBUTE_UNUSED)
2912 {
2913   return (float) tanh (arg1);
2914 }
2915 
2916 /* Built-in substitution symbol functions and math functions.  */
2917 typedef struct
2918 {
2919   char *name;
2920   int (*proc) (char *, char *);
2921   int nargs;
2922 } subsym_proc_entry;
2923 
2924 static const subsym_proc_entry subsym_procs[] =
2925 {
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,  },
2938   { NULL, NULL, 0 },
2939 };
2940 
2941 typedef struct
2942 {
2943   char *name;
2944   float (*proc) (float, float);
2945   int nargs;
2946   int int_return;
2947 } math_proc_entry;
2948 
2949 static const math_proc_entry math_procs[] =
2950 {
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 },
2955 
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 },
2983 };
2984 
2985 void
md_begin(void)2986 md_begin (void)
2987 {
2988   insn_template *tm;
2989   symbol *sym;
2990   const subsym_proc_entry *subsym_proc;
2991   const math_proc_entry *math_proc;
2992   const char *hash_err;
2993   char **symname;
2994   char *TIC54X_DIR = getenv ("TIC54X_DIR");
2995   char *A_DIR = TIC54X_DIR ? TIC54X_DIR : getenv ("A_DIR");
2996 
2997   local_label_id = 0;
2998 
2999   /* Look for A_DIR and add it to the include list.  */
3000   if (A_DIR != NULL)
3001     {
3002       char *tmp = xstrdup (A_DIR);
3003 
3004       do
3005 	{
3006 	  char *next = strchr (tmp, ';');
3007 
3008 	  if (next)
3009 	    *next++ = '\0';
3010 	  add_include_dir (tmp);
3011 	  tmp = next;
3012 	}
3013       while (tmp != NULL);
3014     }
3015 
3016   op_hash = hash_new ();
3017   for (tm = (insn_template *) tic54x_optab; tm->name; tm++)
3018     {
3019       if (hash_find (op_hash, tm->name))
3020 	continue;
3021       hash_err = hash_insert (op_hash, tm->name, (char *) tm);
3022       if (hash_err)
3023 	as_fatal ("Internal Error: Can't hash %s: %s",
3024 		  tm->name, hash_err);
3025     }
3026   parop_hash = hash_new ();
3027   for (tm = (insn_template *) tic54x_paroptab; tm->name; tm++)
3028     {
3029       if (hash_find (parop_hash, tm->name))
3030 	continue;
3031       hash_err = hash_insert (parop_hash, tm->name, (char *) tm);
3032       if (hash_err)
3033 	as_fatal ("Internal Error: Can't hash %s: %s",
3034 		  tm->name, hash_err);
3035     }
3036   reg_hash = hash_new ();
3037   for (sym = (symbol *) regs; sym->name; sym++)
3038     {
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);
3045     }
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);
3051 
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);
3055 
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);
3059 
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);
3063 
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);
3067 
3068   misc_symbol_hash = hash_new ();
3069   for (symname = (char **) misc_symbols; *symname; symname++)
3070     hash_err = hash_insert (misc_symbol_hash, *symname, *symname);
3071 
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);
3079 
3080   math_hash = hash_new ();
3081   for (math_proc = math_procs; math_proc->name; math_proc++)
3082     {
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);
3089     }
3090   subsym_recurse_hash = hash_new ();
3091   stag_hash = hash_new ();
3092 }
3093 
3094 static int
is_accumulator(struct opstruct * operand)3095 is_accumulator (struct opstruct *operand)
3096 {
3097   return strcasecmp (operand->buf, "a") == 0
3098     || strcasecmp (operand->buf, "b") == 0;
3099 }
3100 
3101 /* Return the number of operands found, or -1 on error, copying the
3102    operands into the given array and the accompanying expressions into
3103    the next array.  */
3104 
3105 static int
get_operands(struct opstruct operands[],char * line)3106 get_operands (struct opstruct operands[], char *line)
3107 {
3108   char *lptr = line;
3109   int numexp = 0;
3110   int expecting_operand = 0;
3111   int i;
3112 
3113   while (numexp < MAX_OPERANDS && !is_end_of_line[(int) *lptr])
3114     {
3115       int paren_not_balanced = 0;
3116       char *op_start, *op_end;
3117 
3118       while (*lptr && ISSPACE (*lptr))
3119 	++lptr;
3120       op_start = lptr;
3121       while (paren_not_balanced || *lptr != ',')
3122 	{
3123 	  if (*lptr == '\0')
3124 	    {
3125 	      if (paren_not_balanced)
3126 		{
3127 		  as_bad (_("Unbalanced parenthesis in operand %d"), numexp);
3128 		  return -1;
3129 		}
3130 	      else
3131 		break;
3132 	    }
3133 	  if (*lptr == '(')
3134 	    ++paren_not_balanced;
3135 	  else if (*lptr == ')')
3136 	    --paren_not_balanced;
3137 	  ++lptr;
3138 	}
3139       op_end = lptr;
3140       if (op_end != op_start)
3141 	{
3142 	  int len = op_end - op_start;
3143 
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;
3151 	  lptr = op_end;
3152 	  ++numexp;
3153 	}
3154       else
3155 	{
3156 	  if (expecting_operand || *lptr == ',')
3157 	    {
3158 	      as_bad (_("Expecting operand after ','"));
3159 	      return -1;
3160 	    }
3161 	}
3162       if (*lptr == ',')
3163 	{
3164 	  if (*++lptr == '\0')
3165 	    {
3166 	      as_bad (_("Expecting operand after ','"));
3167 	      return -1;
3168 	    }
3169 	  expecting_operand = 1;
3170 	}
3171     }
3172 
3173   while (*lptr && ISSPACE (*lptr++))
3174     ;
3175   if (!is_end_of_line[(int) *lptr])
3176     {
3177       as_bad (_("Extra junk on line"));
3178       return -1;
3179     }
3180 
3181   /* OK, now parse them into expressions.  */
3182   for (i = 0; i < numexp; i++)
3183     {
3184       memset (&operands[i].exp, 0, sizeof (operands[i].exp));
3185       if (operands[i].buf[0] == '#')
3186 	{
3187 	  /* Immediate.  */
3188 	  parse_expression (operands[i].buf + 1, &operands[i].exp);
3189 	}
3190       else if (operands[i].buf[0] == '@')
3191 	{
3192 	  /* Direct notation.  */
3193 	  parse_expression (operands[i].buf + 1, &operands[i].exp);
3194 	}
3195       else if (operands[i].buf[0] == '*')
3196 	{
3197 	  /* Indirect.  */
3198 	  char *paren = strchr (operands[i].buf, '(');
3199 
3200 	  /* Allow immediate syntax in the inner expression.  */
3201 	  if (paren && paren[1] == '#')
3202 	    *++paren = '(';
3203 
3204 	  /* Pull out the lk expression or SP offset, if present.  */
3205 	  if (paren != NULL)
3206 	    {
3207 	      int len = strlen (paren);
3208 	      char *end = paren + len;
3209 	      int c;
3210 
3211 	      while (end[-1] != ')')
3212 		if (--end <= paren)
3213 		  {
3214 		    as_bad (_("Badly formed address expression"));
3215 		    return -1;
3216 		  }
3217 	      c = *end;
3218 	      *end = '\0';
3219 	      parse_expression (paren, &operands[i].exp);
3220 	      *end = c;
3221 	    }
3222 	  else
3223 	    operands[i].exp.X_op = O_absent;
3224 	}
3225       else
3226 	parse_expression (operands[i].buf, &operands[i].exp);
3227     }
3228 
3229   return numexp;
3230 }
3231 
3232 /* Predicates for different operand types.  */
3233 
3234 static int
is_immediate(struct opstruct * operand)3235 is_immediate (struct opstruct *operand)
3236 {
3237   return *operand->buf == '#';
3238 }
3239 
3240 /* This is distinguished from immediate because some numbers must be constants
3241    and must *not* have the '#' prefix.  */
3242 
3243 static int
is_absolute(struct opstruct * operand)3244 is_absolute (struct opstruct *operand)
3245 {
3246   return operand->exp.X_op == O_constant && !is_immediate (operand);
3247 }
3248 
3249 /* Is this an indirect operand?  */
3250 
3251 static int
is_indirect(struct opstruct * operand)3252 is_indirect (struct opstruct *operand)
3253 {
3254   return operand->buf[0] == '*';
3255 }
3256 
3257 /* Is this a valid dual-memory operand?  */
3258 
3259 static int
is_dual(struct opstruct * operand)3260 is_dual (struct opstruct *operand)
3261 {
3262   if (is_indirect (operand) && strncasecmp (operand->buf, "*ar", 3) == 0)
3263     {
3264       char *tmp = operand->buf + 3;
3265       int arf;
3266       int valid_mod;
3267 
3268       arf = *tmp++ - '0';
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;
3275     }
3276   return 0;
3277 }
3278 
3279 static int
is_mmreg(struct opstruct * operand)3280 is_mmreg (struct opstruct *operand)
3281 {
3282   return (is_absolute (operand)
3283 	  || is_immediate (operand)
3284 	  || hash_find (mmreg_hash, operand->buf) != 0);
3285 }
3286 
3287 static int
is_type(struct opstruct * operand,enum optype type)3288 is_type (struct opstruct *operand, enum optype type)
3289 {
3290   switch (type)
3291     {
3292     case OP_None:
3293       return operand->buf[0] == 0;
3294     case OP_Xmem:
3295     case OP_Ymem:
3296       return is_dual (operand);
3297     case OP_Sind:
3298       return is_indirect (operand);
3299     case OP_xpmad_ms7:
3300       /* This one *must* be immediate.  */
3301       return is_immediate (operand);
3302     case OP_xpmad:
3303     case OP_pmad:
3304     case OP_PA:
3305     case OP_dmad:
3306     case OP_Lmem:
3307     case OP_MMR:
3308       return 1;
3309     case OP_Smem:
3310       /* Address may be a numeric, indirect, or an expression.  */
3311       return !is_immediate (operand);
3312     case OP_MMRY:
3313     case OP_MMRX:
3314       return is_mmreg (operand);
3315     case OP_SRC:
3316     case OP_SRC1:
3317     case OP_RND:
3318     case OP_DST:
3319       return is_accumulator (operand);
3320     case OP_B:
3321       return is_accumulator (operand) && TOUPPER (operand->buf[0]) == 'B';
3322     case OP_A:
3323       return is_accumulator (operand) && TOUPPER (operand->buf[0]) == 'A';
3324     case OP_ARX:
3325       return strncasecmp ("ar", operand->buf, 2) == 0
3326 	&& ISDIGIT (operand->buf[2]);
3327     case OP_SBIT:
3328       return hash_find (sbit_hash, operand->buf) != 0 || is_absolute (operand);
3329     case OP_CC:
3330       return hash_find (cc_hash, operand->buf) != 0;
3331     case OP_CC2:
3332       return hash_find (cc2_hash, operand->buf) != 0;
3333     case OP_CC3:
3334       return hash_find (cc3_hash, operand->buf) != 0
3335 	|| is_immediate (operand) || is_absolute (operand);
3336     case OP_16:
3337       return (is_immediate (operand) || is_absolute (operand))
3338 	&& operand->exp.X_add_number == 16;
3339     case OP_N:
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;
3344     case OP_12:
3345     case OP_123:
3346       return is_absolute (operand) || is_immediate (operand);
3347     case OP_SHFT:
3348       return (is_immediate (operand) || is_absolute (operand))
3349 	&& operand->exp.X_add_number >= 0 && operand->exp.X_add_number < 16;
3350     case OP_SHIFT:
3351       /* Let this one catch out-of-range values.  */
3352       return (is_immediate (operand) || is_absolute (operand))
3353 	&& operand->exp.X_add_number != 16;
3354     case OP_BITC:
3355     case OP_031:
3356     case OP_k8:
3357       return is_absolute (operand) || is_immediate (operand);
3358     case OP_k8u:
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;
3363     case OP_lk:
3364     case OP_lku:
3365       /* Allow anything; assumes opcodes are ordered with Smem operands
3366 	 versions first.  */
3367       return 1;
3368     case OP_k5:
3369     case OP_k3:
3370     case OP_k9:
3371       /* Just make sure it's an integer; check range later.  */
3372       return is_immediate (operand);
3373     case OP_T:
3374       return strcasecmp ("t", operand->buf) == 0 ||
3375 	strcasecmp ("treg", operand->buf) == 0;
3376     case OP_TS:
3377       return strcasecmp ("ts", operand->buf) == 0;
3378     case OP_ASM:
3379       return strcasecmp ("asm", operand->buf) == 0;
3380     case OP_TRN:
3381       return strcasecmp ("trn", operand->buf) == 0;
3382     case OP_DP:
3383       return strcasecmp ("dp", operand->buf) == 0;
3384     case OP_ARP:
3385       return strcasecmp ("arp", operand->buf) == 0;
3386     default:
3387       return 0;
3388     }
3389 }
3390 
3391 static int
operands_match(tic54x_insn * insn,struct opstruct * operands,int opcount,const enum optype * refoptype,int minops,int maxops)3392 operands_match (tic54x_insn *insn,
3393 		struct opstruct *operands,
3394 		int opcount,
3395 		const enum optype *refoptype,
3396 		int minops,
3397 		int maxops)
3398 {
3399   int op = 0, refop = 0;
3400 
3401   if (opcount == 0 && minops == 0)
3402     return 1;
3403 
3404   while (op <= maxops && refop <= maxops)
3405     {
3406       while (!is_type (&operands[op], OPTYPE (refoptype[refop])))
3407 	{
3408 	  /* Skip an optional template operand if it doesn't agree
3409 	     with the current operand.  */
3410 	  if (refoptype[refop] & OPT)
3411 	    {
3412 	      ++refop;
3413 	      --maxops;
3414 	      if (refop > maxops)
3415 		return 0;
3416 	    }
3417 	  else
3418 	    return 0;
3419 	}
3420 
3421       /* Save the actual operand type for later use.  */
3422       operands[op].type = OPTYPE (refoptype[refop]);
3423       ++refop;
3424       ++op;
3425       /* Have we matched them all yet?  */
3426       if (op == opcount)
3427 	{
3428 	  while (op < maxops)
3429 	    {
3430 	      /* If a later operand is *not* optional, no match.  */
3431 	      if ((refoptype[refop] & OPT) == 0)
3432 		return 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;
3437 	      ++refop;
3438 	      ++op;
3439 	    }
3440 
3441 	  return 1;
3442 	}
3443     }
3444 
3445   return 0;
3446 }
3447 
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)
3451 
3452    We allow *(dmad) notation because the TI assembler allows it.
3453 
3454    XPC_CODE:
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).  */
3458 
3459 static int
encode_dmad(tic54x_insn * insn,struct opstruct * operand,int xpc_code)3460 encode_dmad (tic54x_insn *insn, struct opstruct *operand, int xpc_code)
3461 {
3462   int op = 1 + insn->is_lkaddr;
3463 
3464   /* Only allow *(dmad) expressions; all others are invalid.  */
3465   if (is_indirect (operand) && operand->buf[strlen (operand->buf) - 1] != ')')
3466     {
3467       as_bad (_("Invalid dmad syntax '%s'"), operand->buf);
3468       return 0;
3469     }
3470 
3471   insn->opcode[op].addr_expr = operand->exp;
3472 
3473   if (insn->opcode[op].addr_expr.X_op == O_constant)
3474     {
3475       valueT value = insn->opcode[op].addr_expr.X_add_number;
3476 
3477       if (xpc_code == 1)
3478 	{
3479 	  insn->opcode[0].word &= 0xFF80;
3480 	  insn->opcode[0].word |= (value >> 16) & 0x7F;
3481 	  insn->opcode[1].word = value & 0xFFFF;
3482 	}
3483       else if (xpc_code == 2)
3484 	insn->opcode[op].word = (value >> 16) & 0xFFFF;
3485       else
3486 	insn->opcode[op].word = value;
3487     }
3488   else
3489     {
3490       /* Do the fixup later; just store the expression.  */
3491       insn->opcode[op].word = 0;
3492       insn->opcode[op].r_nchars = 2;
3493 
3494       if (amode == c_mode)
3495 	insn->opcode[op].r_type = BFD_RELOC_TIC54X_16_OF_23;
3496       else if (xpc_code == 1)
3497 	{
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.  */
3505 	  insn->words = 1;
3506 	}
3507       else if (xpc_code == 2)
3508 	insn->opcode[op].r_type = BFD_RELOC_TIC54X_MS7_OF_23;
3509       else
3510 	insn->opcode[op].r_type = BFD_RELOC_TIC54X_16_OF_23;
3511 
3512       insn->opcode[op].unresolved = 1;
3513     }
3514 
3515   return 1;
3516 }
3517 
3518 /* 7-bit direct address encoding.  */
3519 
3520 static int
encode_address(tic54x_insn * insn,struct opstruct * operand)3521 encode_address (tic54x_insn *insn, struct opstruct *operand)
3522 {
3523   /* Assumes that dma addresses are *always* in word 0 of the opcode.  */
3524   insn->opcode[0].addr_expr = operand->exp;
3525 
3526   if (operand->exp.X_op == O_constant)
3527     insn->opcode[0].word |= (operand->exp.X_add_number & 0x7F);
3528   else
3529     {
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;
3536     }
3537 
3538   return 1;
3539 }
3540 
3541 static int
encode_indirect(tic54x_insn * insn,struct opstruct * operand)3542 encode_indirect (tic54x_insn *insn, struct opstruct *operand)
3543 {
3544   int arf;
3545   int mod;
3546 
3547   if (insn->is_lkaddr)
3548     {
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');
3555 
3556       insn->opcode[1].addr_expr = operand->exp;
3557 
3558       if (operand->exp.X_op == O_constant)
3559 	insn->opcode[1].word = operand->exp.X_add_number;
3560       else
3561 	{
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;
3566 	}
3567     }
3568   else if (strncasecmp (operand->buf, "*sp (", 4) == 0)
3569     {
3570       /* Stack offsets look the same as 7-bit direct addressing.  */
3571       return encode_address (insn, operand);
3572     }
3573   else
3574     {
3575       arf = (TOUPPER (operand->buf[1]) == 'A' ?
3576 	     operand->buf[3] : operand->buf[4]) - '0';
3577 
3578       if (operand->buf[1] == '+')
3579 	{
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."));
3584 	}
3585       else if (operand->buf[4] == '\0')
3586 	mod = 0;		    /* *ARx  */
3587       else if (operand->buf[5] == '\0')
3588 	mod = (operand->buf[4] == '-' ? 1 : 2); /* *ARx+ / *ARx-  */
3589       else if (operand->buf[6] == '\0')
3590 	{
3591 	  if (operand->buf[5] == '0')
3592 	    mod = (operand->buf[4] == '-' ? 5 : 6); /* *ARx+0 / *ARx-0  */
3593 	  else
3594 	    mod = (operand->buf[4] == '-' ? 8 : 10);/* *ARx+% / *ARx-%  */
3595 	}
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%  */
3600       else
3601 	{
3602 	  as_bad (_("Unrecognized indirect address format \"%s\""),
3603 		  operand->buf);
3604 	  return 0;
3605 	}
3606     }
3607 
3608   insn->opcode[0].word |= 0x80 | (mod << 3) | arf;
3609 
3610   return 1;
3611 }
3612 
3613 static int
encode_integer(tic54x_insn * insn,struct opstruct * operand,int which,int min,int max,unsigned short mask)3614 encode_integer (tic54x_insn *insn,
3615 		struct opstruct *operand,
3616 		int which,
3617 		int min,
3618 		int max,
3619 		unsigned short mask)
3620 {
3621   long parse, integer;
3622 
3623   insn->opcode[which].addr_expr = operand->exp;
3624 
3625   if (operand->exp.X_op == O_constant)
3626     {
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;
3632       else
3633 	integer = parse;
3634 
3635       if (integer >= min && integer <= max)
3636 	{
3637 	  insn->opcode[which].word |= (integer & mask);
3638 	  return 1;
3639 	}
3640       as_bad (_("Operand '%s' out of range (%d <= x <= %d)"),
3641 	      operand->buf, min, max);
3642     }
3643   else
3644     {
3645       if (insn->opcode[which].addr_expr.X_op == O_constant)
3646 	{
3647 	  insn->opcode[which].word |=
3648 	    insn->opcode[which].addr_expr.X_add_number & mask;
3649 	}
3650       else
3651 	{
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;
3658 
3659 	  if (rtype == BFD_RELOC_8)
3660 	    as_bad (_("Error in relocation handling"));
3661 
3662 	  insn->opcode[which].r_nchars = size;
3663 	  insn->opcode[which].r_type = rtype;
3664 	  insn->opcode[which].unresolved = 1;
3665 	}
3666 
3667       return 1;
3668     }
3669 
3670   return 0;
3671 }
3672 
3673 static int
encode_condition(tic54x_insn * insn,struct opstruct * operand)3674 encode_condition (tic54x_insn *insn, struct opstruct *operand)
3675 {
3676   symbol *cc = (symbol *) hash_find (cc_hash, operand->buf);
3677   if (!cc)
3678     {
3679       as_bad (_("Unrecognized condition code \"%s\""), operand->buf);
3680       return 0;
3681     }
3682 #define CC_GROUP 0x40
3683 #define CC_ACC   0x08
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))
3693     {
3694       if ((insn->opcode[0].word & CC_GROUP) != (cc->value & CC_GROUP))
3695 	{
3696 	  as_bad (_("Condition \"%s\" does not match preceding group"),
3697 		  operand->buf);
3698 	  return 0;
3699 	}
3700       if (insn->opcode[0].word & CC_GROUP)
3701 	{
3702 	  if ((insn->opcode[0].word & CC_ACC) != (cc->value & CC_ACC))
3703 	    {
3704 	      as_bad (_("Condition \"%s\" uses a different accumulator from "
3705 			"a preceding condition"),
3706 		      operand->buf);
3707 	      return 0;
3708 	    }
3709 	  if ((insn->opcode[0].word & CATG_A1) && (cc->value & CATG_A1))
3710 	    {
3711 	      as_bad (_("Only one comparison conditional allowed"));
3712 	      return 0;
3713 	    }
3714 	  if ((insn->opcode[0].word & CATG_B1) && (cc->value & CATG_B1))
3715 	    {
3716 	      as_bad (_("Only one overflow conditional allowed"));
3717 	      return 0;
3718 	    }
3719 	}
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)))
3723 	{
3724 	  as_bad (_("Duplicate %s conditional"), operand->buf);
3725 	  return 0;
3726 	}
3727     }
3728 
3729   insn->opcode[0].word |= cc->value;
3730   return 1;
3731 }
3732 
3733 static int
encode_cc3(tic54x_insn * insn,struct opstruct * operand)3734 encode_cc3 (tic54x_insn *insn, struct opstruct *operand)
3735 {
3736   symbol *cc3 = (symbol *) hash_find (cc3_hash, operand->buf);
3737   int value = cc3 ? cc3->value : operand->exp.X_add_number << 8;
3738 
3739   if ((value & 0x0300) != value)
3740     {
3741       as_bad (_("Unrecognized condition code \"%s\""), operand->buf);
3742       return 0;
3743     }
3744   insn->opcode[0].word |= value;
3745   return 1;
3746 }
3747 
3748 static int
encode_arx(tic54x_insn * insn,struct opstruct * operand)3749 encode_arx (tic54x_insn *insn, struct opstruct *operand)
3750 {
3751   int arf = strlen (operand->buf) >= 3 ? operand->buf[2] - '0' : -1;
3752 
3753   if (strncasecmp ("ar", operand->buf, 2) || arf < 0 || arf > 7)
3754     {
3755       as_bad (_("Invalid auxiliary register (use AR0-AR7)"));
3756       return 0;
3757     }
3758   insn->opcode[0].word |= arf;
3759   return 1;
3760 }
3761 
3762 static int
encode_cc2(tic54x_insn * insn,struct opstruct * operand)3763 encode_cc2 (tic54x_insn *insn, struct opstruct *operand)
3764 {
3765   symbol *cc2 = (symbol *) hash_find (cc2_hash, operand->buf);
3766 
3767   if (!cc2)
3768     {
3769       as_bad (_("Unrecognized condition code \"%s\""), operand->buf);
3770       return 0;
3771     }
3772   insn->opcode[0].word |= cc2->value;
3773   return 1;
3774 }
3775 
3776 static int
encode_operand(tic54x_insn * insn,enum optype type,struct opstruct * operand)3777 encode_operand (tic54x_insn *insn, enum optype type, struct opstruct *operand)
3778 {
3779   int ext = (insn->tm->flags & FL_EXT) != 0;
3780 
3781   if (type == OP_MMR && operand->exp.X_op != O_constant)
3782     {
3783       /* Disallow long-constant addressing for memory-mapped addressing.  */
3784       if (insn->is_lkaddr)
3785 	{
3786 	  as_bad (_("lk addressing modes are invalid for memory-mapped "
3787 		    "register addressing"));
3788 	  return 0;
3789 	}
3790       type = OP_Smem;
3791       /* Warn about *+ARx when used with MMR operands.  */
3792       if (strncasecmp (operand->buf, "*+ar", 4) == 0)
3793 	{
3794 	  as_warn (_("Address mode *+ARx is not allowed in memory-mapped "
3795 		     "register addressing.  Resulting behavior is "
3796 		     "undefined."));
3797 	}
3798     }
3799 
3800   switch (type)
3801     {
3802     case OP_None:
3803       return 1;
3804     case OP_dmad:
3805       /* 16-bit immediate value.  */
3806       return encode_dmad (insn, operand, 0);
3807     case OP_SRC:
3808       if (TOUPPER (*operand->buf) == 'B')
3809 	{
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);
3813 	}
3814       return 1;
3815     case OP_RND:
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)))
3819 	{
3820 	  as_bad (_("Destination accumulator for each part of this parallel "
3821 		    "instruction must be different"));
3822 	  return 0;
3823 	}
3824       return 1;
3825     case OP_SRC1:
3826     case OP_DST:
3827       if (TOUPPER (operand->buf[0]) == 'B')
3828 	insn->opcode[ext ? (1 + insn->is_lkaddr) : 0].word |= (1 << 8);
3829       return 1;
3830     case OP_Xmem:
3831     case OP_Ymem:
3832       {
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));
3839 	return 1;
3840       }
3841     case OP_Lmem:
3842     case OP_Smem:
3843       if (!is_indirect (operand))
3844 	return encode_address (insn, operand);
3845       /* Fall through.  */
3846     case OP_Sind:
3847       return encode_indirect (insn, operand);
3848     case OP_xpmad_ms7:
3849       return encode_dmad (insn, operand, 2);
3850     case OP_xpmad:
3851       return encode_dmad (insn, operand, 1);
3852     case OP_PA:
3853     case OP_pmad:
3854       return encode_dmad (insn, operand, 0);
3855     case OP_ARX:
3856       return encode_arx (insn, operand);
3857     case OP_MMRX:
3858     case OP_MMRY:
3859     case OP_MMR:
3860       {
3861 	int value = operand->exp.X_add_number;
3862 
3863 	if (type == OP_MMR)
3864 	  insn->opcode[0].word |= value;
3865 	else
3866 	  {
3867 	    if (value < 16 || value > 24)
3868 	      {
3869 		as_bad (_("Memory mapped register \"%s\" out of range"),
3870 			operand->buf);
3871 		return 0;
3872 	      }
3873 	    if (type == OP_MMRX)
3874 	      insn->opcode[0].word |= (value - 16) << 4;
3875 	    else
3876 	      insn->opcode[0].word |= (value - 16);
3877 	  }
3878 	return 1;
3879       }
3880     case OP_B:
3881     case OP_A:
3882       return 1;
3883     case OP_SHFT:
3884       return encode_integer (insn, operand, ext + insn->is_lkaddr,
3885 			     0, 15, 0xF);
3886     case OP_SHIFT:
3887       return encode_integer (insn, operand, ext + insn->is_lkaddr,
3888 			     -16, 15, 0x1F);
3889     case OP_lk:
3890       return encode_integer (insn, operand, 1 + insn->is_lkaddr,
3891 			     -32768, 32767, 0xFFFF);
3892     case OP_CC:
3893       return encode_condition (insn, operand);
3894     case OP_CC2:
3895       return encode_cc2 (insn, operand);
3896     case OP_CC3:
3897       return encode_cc3 (insn, operand);
3898     case OP_BITC:
3899       return encode_integer (insn, operand, 0, 0, 15, 0xF);
3900     case OP_k8:
3901       return encode_integer (insn, operand, 0, -128, 127, 0xFF);
3902     case OP_123:
3903       {
3904 	int value = operand->exp.X_add_number;
3905 	int code;
3906 	if (value < 1 || value > 3)
3907 	  {
3908 	    as_bad (_("Invalid operand (use 1, 2, or 3)"));
3909 	    return 0;
3910 	  }
3911 	code = value == 1 ? 0 : value == 2 ? 0x2 : 0x1;
3912 	insn->opcode[0].word |= (code << 8);
3913 	return 1;
3914       }
3915     case OP_031:
3916       return encode_integer (insn, operand, 0, 0, 31, 0x1F);
3917     case OP_k8u:
3918       return encode_integer (insn, operand, 0, 0, 255, 0xFF);
3919     case OP_lku:
3920       return encode_integer (insn, operand, 1 + insn->is_lkaddr,
3921 			     0, 65535, 0xFFFF);
3922     case OP_SBIT:
3923       {
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);
3927 	int reg = 0;
3928 
3929 	if (insn->opcount == 1)
3930 	  {
3931 	    if (!sbit)
3932 	      {
3933 		as_bad (_("A status register or status bit name is required"));
3934 		return 0;
3935 	      }
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"))
3939 	      reg = 1;
3940 	  }
3941 	if (value == -1)
3942 	  {
3943 	    as_bad (_("Unrecognized status bit \"%s\""), operand->buf);
3944 	    return 0;
3945 	  }
3946 	insn->opcode[0].word |= value;
3947 	insn->opcode[0].word |= (reg << 9);
3948 	return 1;
3949       }
3950     case OP_N:
3951       if (strcasecmp (operand->buf, "st0") == 0
3952 	  || strcasecmp (operand->buf, "st1") == 0)
3953 	{
3954 	  insn->opcode[0].word |=
3955 	    ((unsigned short) (operand->buf[2] - '0')) << 9;
3956 	  return 1;
3957 	}
3958       else if (operand->exp.X_op == O_constant
3959 	       && (operand->exp.X_add_number == 0
3960 		   || operand->exp.X_add_number == 1))
3961 	{
3962 	  insn->opcode[0].word |=
3963 	    ((unsigned short) (operand->exp.X_add_number)) << 9;
3964 	  return 1;
3965 	}
3966       as_bad (_("Invalid status register \"%s\""), operand->buf);
3967       return 0;
3968     case OP_k5:
3969       return encode_integer (insn, operand, 0, -16, 15, 0x1F);
3970     case OP_k3:
3971       return encode_integer (insn, operand, 0, 0, 7, 0x7);
3972     case OP_k9:
3973       return encode_integer (insn, operand, 0, 0, 0x1FF, 0x1FF);
3974     case OP_12:
3975       if (operand->exp.X_add_number != 1
3976 	  && operand->exp.X_add_number != 2)
3977 	{
3978 	  as_bad (_("Operand \"%s\" out of range (use 1 or 2)"), operand->buf);
3979 	  return 0;
3980 	}
3981       insn->opcode[0].word |= (operand->exp.X_add_number - 1) << 9;
3982       return 1;
3983     case OP_16:
3984     case OP_T:
3985     case OP_TS:
3986     case OP_ASM:
3987     case OP_TRN:
3988     case OP_DP:
3989     case OP_ARP:
3990       /* No encoding necessary.  */
3991       return 1;
3992     default:
3993       return 0;
3994     }
3995 
3996   return 1;
3997 }
3998 
3999 static void
emit_insn(tic54x_insn * insn)4000 emit_insn (tic54x_insn *insn)
4001 {
4002   int i;
4003   flagword oldflags = bfd_get_section_flags (stdoutput, now_seg);
4004   flagword flags = oldflags | SEC_CODE;
4005 
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 ()));
4010 
4011   for (i = 0; i < insn->words; i++)
4012     {
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);
4016 
4017       if (size == 2)
4018 	md_number_to_chars (p, (valueT) insn->opcode[i].word, 2);
4019       else
4020 	md_number_to_chars (p, (valueT) insn->opcode[i].word << 16, 4);
4021 
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);
4026     }
4027 }
4028 
4029 /* Convert the operand strings into appropriate opcode values
4030    return the total number of words used by the instruction.  */
4031 
4032 static int
build_insn(tic54x_insn * insn)4033 build_insn (tic54x_insn *insn)
4034 {
4035   int i;
4036 
4037   /* Only non-parallel instructions support lk addressing.  */
4038   if (!(insn->tm->flags & FL_PAR))
4039     {
4040       for (i = 0; i < insn->opcount; i++)
4041 	{
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)
4048 	    {
4049 	      insn->is_lkaddr = 1;
4050 	      insn->lkoperand = i;
4051 	      break;
4052 	    }
4053 	}
4054     }
4055   insn->words = insn->tm->words + insn->is_lkaddr;
4056 
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;
4060 
4061   for (i = 0; i < insn->opcount; i++)
4062     {
4063       enum optype type = insn->operands[i].type;
4064 
4065       if (!encode_operand (insn, type, &insn->operands[i]))
4066 	return 0;
4067     }
4068   if (insn->tm->flags & FL_PAR)
4069     for (i = 0; i < insn->paropcount; i++)
4070       {
4071 	enum optype partype = insn->paroperands[i].type;
4072 
4073 	if (!encode_operand (insn, partype, &insn->paroperands[i]))
4074 	  return 0;
4075       }
4076 
4077   emit_insn (insn);
4078 
4079   return insn->words;
4080 }
4081 
4082 static int
optimize_insn(tic54x_insn * insn)4083 optimize_insn (tic54x_insn *insn)
4084 {
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)
4088     {
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)
4094 	{
4095 	  --insn->opcount;
4096 	  insn->using_default_dst = 1;
4097 	  return 1;
4098 	}
4099 
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))
4109 	{
4110 	  insn->operands[1] = insn->operands[2];
4111 	  insn->opcount = 2;
4112 	  return 1;
4113 	}
4114     }
4115   else if (strcasecmp (insn->tm->name, "ld") == 0)
4116     {
4117       if (insn->opcount == 3 && insn->operands[0].type != OP_SRC)
4118 	{
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)))
4126 	    {
4127 	      insn->operands[1] = insn->operands[2];
4128 	      insn->opcount = 2;
4129 	      return 1;
4130 	    }
4131 	}
4132     }
4133   else if (strcasecmp (insn->tm->name, "sth") == 0
4134 	   || strcasecmp (insn->tm->name, "stl") == 0)
4135     {
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]))
4139 	{
4140 	  insn->operands[1] = insn->operands[2];
4141 	  insn->opcount = 2;
4142 	  return 1;
4143 	}
4144     }
4145   else if (strcasecmp (insn->tm->name, "sub") == 0)
4146     {
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)
4152 	{
4153 	  --insn->opcount;
4154 	  insn->using_default_dst = 1;
4155 	  return 1;
4156 	}
4157 
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)
4164 	{
4165 	  insn->operands[1] = insn->operands[2];
4166 	  insn->opcount = 2;
4167 	  return 1;
4168 	}
4169     }
4170   return 0;
4171 }
4172 
4173 /* Find a matching template if possible, and get the operand strings.  */
4174 
4175 static int
tic54x_parse_insn(tic54x_insn * insn,char * line)4176 tic54x_parse_insn (tic54x_insn *insn, char *line)
4177 {
4178   insn->tm = (insn_template *) hash_find (op_hash, insn->mnemonic);
4179   if (!insn->tm)
4180     {
4181       as_bad (_("Unrecognized instruction \"%s\""), insn->mnemonic);
4182       return 0;
4183     }
4184 
4185   insn->opcount = get_operands (insn->operands, line);
4186   if (insn->opcount < 0)
4187     return 0;
4188 
4189   /* Check each variation of operands for this mnemonic.  */
4190   while (insn->tm->name && strcasecmp (insn->tm->name, insn->mnemonic) == 0)
4191     {
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))
4197 	{
4198 	  /* SUCCESS! now try some optimizations.  */
4199 	  if (optimize_insn (insn))
4200 	    {
4201 	      insn->tm = (insn_template *) hash_find (op_hash,
4202                                                       insn->mnemonic);
4203 	      continue;
4204 	    }
4205 
4206 	  return 1;
4207 	}
4208       ++(insn->tm);
4209     }
4210   as_bad (_("Unrecognized operand list '%s' for instruction '%s'"),
4211 	  line, insn->mnemonic);
4212   return 0;
4213 }
4214 
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;
4218 
4219 /* See if this is part of a parallel instruction
4220    Look for a subsequent line starting with "||".  */
4221 
4222 static int
next_line_shows_parallel(char * next_line)4223 next_line_shows_parallel (char *next_line)
4224 {
4225   /* Look for the second half.  */
4226   while (ISSPACE (*next_line))
4227     ++next_line;
4228 
4229   return (next_line[0] == PARALLEL_SEPARATOR
4230 	  && next_line[1] == PARALLEL_SEPARATOR);
4231 }
4232 
4233 static int
tic54x_parse_parallel_insn_firstline(tic54x_insn * insn,char * line)4234 tic54x_parse_parallel_insn_firstline (tic54x_insn *insn, char *line)
4235 {
4236   insn->tm = (insn_template *) hash_find (parop_hash, insn->mnemonic);
4237   if (!insn->tm)
4238     {
4239       as_bad (_("Unrecognized parallel instruction \"%s\""),
4240 	      insn->mnemonic);
4241       return 0;
4242     }
4243 
4244   while (insn->tm->name && strcasecmp (insn->tm->name,
4245                                        insn->mnemonic) == 0)
4246     {
4247       insn->opcount = get_operands (insn->operands, line);
4248       if (insn->opcount < 0)
4249 	return 0;
4250       if (insn->opcount == 2
4251 	  && operands_match (insn, &insn->operands[0], insn->opcount,
4252 			     insn->tm->operand_types, 2, 2))
4253 	{
4254 	  return 1;
4255 	}
4256       ++(insn->tm);
4257     }
4258   /* Didn't find a matching parallel; try for a normal insn.  */
4259   return 0;
4260 }
4261 
4262 /* Parse the second line of a two-line parallel instruction.  */
4263 
4264 static int
tic54x_parse_parallel_insn_lastline(tic54x_insn * insn,char * line)4265 tic54x_parse_parallel_insn_lastline (tic54x_insn *insn, char *line)
4266 {
4267   int valid_mnemonic = 0;
4268 
4269   insn->paropcount = get_operands (insn->paroperands, line);
4270   while (insn->tm->name && strcasecmp (insn->tm->name,
4271 				       insn->mnemonic) == 0)
4272     {
4273       if (strcasecmp (insn->tm->parname, insn->parmnemonic) == 0)
4274 	{
4275 	  valid_mnemonic = 1;
4276 
4277 	  if (insn->paropcount >= insn->tm->minops
4278 	      && insn->paropcount <= insn->tm->maxops
4279 	      && operands_match (insn, insn->paroperands,
4280 				 insn->paropcount,
4281 				 insn->tm->paroperand_types,
4282 				 insn->tm->minops, insn->tm->maxops))
4283 	    return 1;
4284 	}
4285       ++(insn->tm);
4286     }
4287   if (valid_mnemonic)
4288     as_bad (_("Invalid operand (s) for parallel instruction \"%s\""),
4289 	    insn->parmnemonic);
4290   else
4291     as_bad (_("Unrecognized parallel instruction combination \"%s || %s\""),
4292 	    insn->mnemonic, insn->parmnemonic);
4293 
4294   return 0;
4295 }
4296 
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.  */
4301 
4302 static char *
subsym_get_arg(char * line,char * terminators,char ** str,int nosub)4303 subsym_get_arg (char *line, char *terminators, char **str, int nosub)
4304 {
4305   char *ptr = line;
4306   char *endp;
4307   int is_string = *line == '"';
4308   int is_char = ISDIGIT (*line);
4309 
4310   if (is_char)
4311     {
4312       while (ISDIGIT (*ptr))
4313 	++ptr;
4314       endp = ptr;
4315       *str = xmalloc (ptr - line + 1);
4316       strncpy (*str, line, ptr - line);
4317       (*str)[ptr - line] = 0;
4318     }
4319   else if (is_string)
4320     {
4321       char *savedp = input_line_pointer;
4322       int len;
4323 
4324       input_line_pointer = ptr;
4325       *str = demand_copy_C_string (&len);
4326       endp = input_line_pointer;
4327       input_line_pointer = savedp;
4328 
4329       /* Do forced substitutions if requested.  */
4330       if (!nosub && **str == ':')
4331 	*str = subsym_substitute (*str, 1);
4332     }
4333   else
4334     {
4335       char *term = terminators;
4336       char *value = NULL;
4337 
4338       while (*ptr && *ptr != *term)
4339 	{
4340 	  if (!*term)
4341 	    {
4342 	      term = terminators;
4343 	      ++ptr;
4344 	    }
4345 	  else
4346 	    ++term;
4347 	}
4348       endp = ptr;
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)
4354 	*str = value;
4355     }
4356 
4357   return endp;
4358 }
4359 
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.  */
4364 
4365 static void
subsym_create_or_replace(char * name,char * value)4366 subsym_create_or_replace (char *name, char *value)
4367 {
4368   int i;
4369 
4370   for (i = macro_level; i > 0; i--)
4371     {
4372       if (hash_find (subsym_hash[i], name))
4373 	{
4374 	  hash_replace (subsym_hash[i], name, value);
4375 	  return;
4376 	}
4377     }
4378   if (hash_find (subsym_hash[0], name))
4379     hash_replace (subsym_hash[0], name, value);
4380   else
4381     hash_insert (subsym_hash[0], name, value);
4382 }
4383 
4384 /* Look up the substitution string replacement for the given symbol.
4385    Start with the innermost macro substitution table given and work
4386    outwards.  */
4387 
4388 static char *
subsym_lookup(char * name,int nest_level)4389 subsym_lookup (char *name, int nest_level)
4390 {
4391   char *value = hash_find (subsym_hash[nest_level], name);
4392 
4393   if (value || nest_level == 0)
4394     return value;
4395 
4396   return subsym_lookup (name, nest_level - 1);
4397 }
4398 
4399 /* Do substitution-symbol replacement on the given line (recursively).
4400    return the argument if no substitution was done
4401 
4402    Also look for built-in functions ($func (arg)) and local labels.
4403 
4404    If FORCED is set, look for forced substitutions of the form ':SYMBOL:'.  */
4405 
4406 static char *
subsym_substitute(char * line,int forced)4407 subsym_substitute (char *line, int forced)
4408 {
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
4417                           .eval/.asg?  */
4418   char *eval_end = NULL;
4419   int recurse = 1;
4420   int line_conditional = 0;
4421   char *tmp;
4422 
4423   /* Work with a copy of the input line.  */
4424   replacement = xmalloc (strlen (line) + 1);
4425   strcpy (replacement, line);
4426 
4427   ptr = head = replacement;
4428 
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;
4436 
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"))
4440     eval_line = 1;
4441 
4442   /* If it's a macro definition, don't do substitution on the argument
4443      names.  */
4444   if (strstr (line, ".macro"))
4445     return line;
4446 
4447   while (!is_end_of_line[(int) *ptr])
4448     {
4449       int current_char = *ptr;
4450 
4451       /* Need to update this since LINE may have been modified.  */
4452       if (eval_line)
4453 	eval_end = strrchr (ptr, ',');
4454 
4455       /* Replace triple double quotes with bounding quote/escapes.  */
4456       if (current_char == '"' && ptr[1] == '"' && ptr[2] == '"')
4457 	{
4458 	  ptr[1] = '\\';
4459 	  tmp = strstr (ptr + 2, "\"\"\"");
4460 	  if (tmp)
4461 	    tmp[0] = '\\';
4462 	  changed = 1;
4463 	}
4464 
4465       /* Replace a single '=' with a '==';
4466 	 for compatibility with older code only.  */
4467       if (line_conditional && current_char == '=')
4468 	{
4469 	  if (ptr[1] == '=')
4470 	    {
4471 	      ptr += 2;
4472 	      continue;
4473 	    }
4474 	  *ptr++ = '\0';
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;
4479 	  free (replacement);
4480 	  head = replacement = tmp;
4481 	  changed = 1;
4482 	}
4483 
4484       /* Flag when we've reached the symbol part of .eval/.asg.  */
4485       if (eval_line && ptr >= eval_end)
4486 	eval_symbol = 1;
4487 
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)))
4492 	{
4493 	  char *name; /* Symbol to be replaced.  */
4494 	  char *savedp = input_line_pointer;
4495 	  int c;
4496 	  char *value = NULL;
4497 	  char *tail; /* Rest of line after symbol.  */
4498 
4499 	  /* Skip the colon.  */
4500 	  if (forced)
4501 	    ++ptr;
4502 
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
4506 	     label.  */
4507 	  if (c == '?')
4508 	    {
4509 	      *input_line_pointer++ = c;
4510 	      c = *input_line_pointer;
4511 	      *input_line_pointer = '\0';
4512 	    }
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);
4517 	  else
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;
4523 
4524 	  /* Check for local labels; replace them with the appropriate
4525 	     substitution.  */
4526 	  if ((*name == '$' && ISDIGIT (name[1]) && name[2] == '\0')
4527 	      || name[strlen (name) - 1] == '?')
4528 	    {
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);
4532 	      if (value == NULL)
4533 		{
4534 		  char digit[11];
4535 		  char *namecopy = strcpy (xmalloc (strlen (name) + 1), name);
4536 
4537 		  value = strcpy (xmalloc (strlen (name) + sizeof (digit) + 1),
4538 				  name);
4539 		  if (*value != '$')
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);
4544 		}
4545 	      /* Indicate where to continue looking for substitutions.  */
4546 	      ptr = tail;
4547 	    }
4548 	  /* Check for built-in subsym and math functions.  */
4549 	  else if (value != NULL && *name == '$')
4550 	    {
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;
4554 
4555 	      *ptr = c;
4556 	      if (entry == NULL)
4557 		{
4558 		  as_bad (_("Unrecognized substitution symbol function"));
4559 		  break;
4560 		}
4561 	      else if (*ptr != '(')
4562 		{
4563 		  as_bad (_("Missing '(' after substitution symbol function"));
4564 		  break;
4565 		}
4566 	      ++ptr;
4567 	      if (math_entry != NULL)
4568 		{
4569 		  float farg1, farg2 = 0;
4570 		  volatile float fresult;
4571 
4572 		  farg1 = (float) strtod (ptr, &ptr);
4573 		  if (math_entry->nargs == 2)
4574 		    {
4575 		      if (*ptr++ != ',')
4576 			{
4577 			  as_bad (_("Expecting second argument"));
4578 			  break;
4579 			}
4580 		      farg2 = (float) strtod (ptr, &ptr);
4581 		    }
4582 		  fresult = (*math_entry->proc) (farg1, farg2);
4583 		  value = xmalloc (128);
4584 		  if (math_entry->int_return)
4585 		    sprintf (value, "%d", (int) fresult);
4586 		  else
4587 		    sprintf (value, "%f", fresult);
4588 		  if (*ptr++ != ')')
4589 		    {
4590 		      as_bad (_("Extra junk in function call, expecting ')'"));
4591 		      break;
4592 		    }
4593 		  /* Don't bother recursing; the replacement isn't a
4594                      symbol.  */
4595 		  recurse = 0;
4596 		}
4597 	      else
4598 		{
4599 		  int val;
4600 		  int arg_type[2] = { *ptr == '"' , 0 };
4601 		  int ismember = !strcmp (entry->name, "$ismember");
4602 
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);
4610 		  if (!arg1)
4611 		    break;
4612 		  if (entry->nargs == 2)
4613 		    {
4614 		      if (*ptr++ != ',')
4615 			{
4616 			  as_bad (_("Function expects two arguments"));
4617 			  break;
4618 			}
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);
4623 		    }
4624 		  /* Args checking.  */
4625 		  if ((!strcmp (entry->name, "$firstch")
4626 		       || !strcmp (entry->name, "$lastch"))
4627 		      && arg_type[1] != 2)
4628 		    {
4629 		      as_bad (_("Expecting character constant argument"));
4630 		      break;
4631 		    }
4632 		  if (ismember
4633 		      && (arg_type[0] != 0 || arg_type[1] != 0))
4634 		    {
4635 		      as_bad (_("Both arguments must be substitution symbols"));
4636 		      break;
4637 		    }
4638 		  if (*ptr++ != ')')
4639 		    {
4640 		      as_bad (_("Extra junk in function call, expecting ')'"));
4641 		      break;
4642 		    }
4643 		  val = (*entry->proc) (arg1, arg2);
4644 		  value = xmalloc (64);
4645 		  sprintf (value, "%d", val);
4646 		}
4647 	      /* Fix things up to replace the entire expression, not just the
4648 		 function name.  */
4649 	      tail = ptr;
4650 	      c = *tail;
4651 	    }
4652 
4653 	  if (value != NULL && !eval_symbol)
4654 	    {
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.
4659 
4660 		 put the symbol into the recursion hash table so we only
4661 		 try to replace a symbol once.  */
4662 	      if (recurse)
4663 		{
4664 		  hash_insert (subsym_recurse_hash, name, name);
4665 		  value = subsym_substitute (value, macro_level > 0);
4666 		  hash_delete (subsym_recurse_hash, name, FALSE);
4667 		}
4668 
4669 	      /* Temporarily zero-terminate where the symbol started.  */
4670 	      *name = 0;
4671 	      if (forced)
4672 		{
4673 		  if (c == '(')
4674 		    {
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),
4681 					     value);
4682 
4683 		      savedp = input_line_pointer;
4684 		      input_line_pointer = tail + 1;
4685 		      beg = get_absolute_expression ();
4686 		      if (beg < 1)
4687 			{
4688 			  as_bad (_("Invalid subscript (use 1 to %d)"),
4689 				  (int) strlen (value));
4690 			  break;
4691 			}
4692 		      if (*input_line_pointer == ',')
4693 			{
4694 			  ++input_line_pointer;
4695 			  len = get_absolute_expression ();
4696 			  if (beg + len > strlen (value))
4697 			    {
4698 			      as_bad (_("Invalid length (use 0 to %d"),
4699 				      (int) strlen (value) - beg);
4700 			      break;
4701 			    }
4702 			}
4703 		      newval += beg - 1;
4704 		      newval[len] = 0;
4705 		      tail = input_line_pointer;
4706 		      if (*tail++ != ')')
4707 			{
4708 			  as_bad (_("Missing ')' in subscripted substitution "
4709 				    "symbol expression"));
4710 			  break;
4711 			}
4712 		      c = *tail;
4713 		      input_line_pointer = savedp;
4714 
4715 		      value = newval;
4716 		    }
4717 		  name[-1] = 0;
4718 		}
4719 	      tmp = xmalloc (strlen (head) + strlen (value) +
4720 			     strlen (tail + 1) + 2);
4721 	      strcpy (tmp, head);
4722 	      strcat (tmp, value);
4723 	      /* Make sure forced substitutions are properly terminated.  */
4724 	      if (forced)
4725 		{
4726 		  if (c != ':')
4727 		    {
4728 		      as_bad (_("Missing forced substitution terminator ':'"));
4729 		      break;
4730 		    }
4731 		  ++tail;
4732 		}
4733 	      else
4734 		/* Restore the character after the symbol end.  */
4735 		*tail = c;
4736 	      strcat (tmp, tail);
4737 	      /* Continue examining after the replacement value.  */
4738 	      ptr = tmp + strlen (head) + strlen (value);
4739 	      free (replacement);
4740 	      head = replacement = tmp;
4741 	      changed = 1;
4742 	    }
4743 	  else
4744 	    *ptr = c;
4745 	}
4746       else
4747 	{
4748 	  ++ptr;
4749 	}
4750     }
4751 
4752   if (changed)
4753     return replacement;
4754   else
4755     return line;
4756 }
4757 
4758 /* We use this to handle substitution symbols
4759    hijack input_line_pointer, replacing it with our substituted string.
4760 
4761    .sslist should enable listing the line after replacements are made...
4762 
4763    returns the new buffer limit.  */
4764 
4765 void
tic54x_start_line_hook(void)4766 tic54x_start_line_hook (void)
4767 {
4768   char *line, *endp;
4769   char *replacement = NULL;
4770 
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++])
4774     ;
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;
4778 
4779   /* Scan ahead for parallel insns.  */
4780   parallel_on_next_line_hint = next_line_shows_parallel (endp);
4781 
4782   /* If within a macro, first process forced replacements.  */
4783   if (macro_level > 0)
4784     replacement = subsym_substitute (line, 1);
4785   else
4786     replacement = line;
4787   replacement = subsym_substitute (replacement, 0);
4788 
4789   if (replacement != line)
4790     {
4791       char *tmp = replacement;
4792       char *comment = strchr (replacement, ';');
4793       char endc = replacement[strlen (replacement) - 1];
4794 
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)
4799 	{
4800 	  comment[0] = endc;
4801 	  comment[1] = 0;
4802 	  --comment;
4803 	}
4804       else
4805 	comment = replacement + strlen (replacement) - 1;
4806 
4807       /* Trim trailing whitespace.  */
4808       while (ISSPACE (*comment))
4809 	{
4810 	  comment[0] = endc;
4811 	  comment[1] = 0;
4812 	  --comment;
4813 	}
4814 
4815       /* Compact leading whitespace.  */
4816       while (ISSPACE (tmp[0]) && ISSPACE (tmp[1]))
4817 	++tmp;
4818 
4819       input_line_pointer = endp;
4820       input_scrub_insert_line (tmp);
4821       free (replacement);
4822       free (line);
4823       /* Keep track of whether we've done a substitution.  */
4824       substitution_line = 1;
4825     }
4826   else
4827     {
4828       /* No change.  */
4829       free (line);
4830       substitution_line = 0;
4831     }
4832 }
4833 
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.  */
4837 void
md_assemble(char * line)4838 md_assemble (char *line)
4839 {
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;
4844   char *lptr;
4845   char *savedp = input_line_pointer;
4846   int c;
4847 
4848   input_line_pointer = line;
4849   c = get_symbol_end ();
4850 
4851   if (cpu == VNONE)
4852     cpu = V542;
4853   if (address_mode_needs_set)
4854     {
4855       set_address_mode (amode);
4856       address_mode_needs_set = 0;
4857     }
4858   if (cpu_needs_set)
4859     {
4860       set_cpu (cpu);
4861       cpu_needs_set = 0;
4862     }
4863   assembly_begun = 1;
4864 
4865   if (is_parallel)
4866     {
4867       is_parallel = 0;
4868 
4869       strcpy (insn.parmnemonic, line);
4870       lptr = input_line_pointer;
4871       *lptr = c;
4872       input_line_pointer = savedp;
4873 
4874       if (tic54x_parse_parallel_insn_lastline (&insn, lptr))
4875 	{
4876 	  int words = build_insn (&insn);
4877 
4878 	  if (delay_slots != 0)
4879 	    {
4880 	      if (words > delay_slots)
4881 		{
4882 		  as_bad (_("Instruction does not fit in available delay "
4883 			    "slots (%d-word insn, %d slots left)"),
4884 			  words, delay_slots);
4885 		  delay_slots = 0;
4886 		  return;
4887 		}
4888 	      delay_slots -= words;
4889 	    }
4890 	}
4891       return;
4892     }
4893 
4894   memset (&insn, 0, sizeof (insn));
4895   strcpy (insn.mnemonic, line);
4896   lptr = input_line_pointer;
4897   *lptr = c;
4898   input_line_pointer = savedp;
4899 
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)
4904     {
4905       char *tmp = strstr (line, "||");
4906       if (tmp != NULL)
4907 	*tmp = '\0';
4908 
4909       if (tic54x_parse_parallel_insn_firstline (&insn, lptr))
4910 	{
4911 	  is_parallel = 1;
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.  */
4914 	  if (tmp != NULL)
4915 	    {
4916 	      while (ISSPACE (tmp[2]))
4917 		++tmp;
4918 	      md_assemble (tmp + 2);
4919 	    }
4920 	}
4921       else
4922 	{
4923 	  as_bad (_("Unrecognized parallel instruction '%s'"), line);
4924 	}
4925       return;
4926     }
4927 
4928   if (tic54x_parse_insn (&insn, lptr))
4929     {
4930       int words;
4931 
4932       if ((insn.tm->flags & FL_LP)
4933 	  && cpu != V545LP && cpu != V546LP)
4934 	{
4935 	  as_bad (_("Instruction '%s' requires an LP cpu version"),
4936 		  insn.tm->name);
4937 	  return;
4938 	}
4939       if ((insn.tm->flags & FL_FAR)
4940 	  && amode != far_mode)
4941 	{
4942 	  as_bad (_("Instruction '%s' requires far mode addressing"),
4943 		  insn.tm->name);
4944 	  return;
4945 	}
4946 
4947       words = build_insn (&insn);
4948 
4949       /* Is this instruction in a delay slot?  */
4950       if (delay_slots)
4951 	{
4952 	  if (words > delay_slots)
4953 	    {
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);
4958 	      delay_slots = 0;
4959 	      return;
4960 	    }
4961 	  /* Branches in delay slots are not allowed.  */
4962 	  if (insn.tm->flags & FL_BMASK)
4963 	    {
4964 	      as_warn (_("Instructions which cause PC discontinuity are not "
4965 			 "allowed in a delay slot. "
4966 			 "Resulting behavior is undefined."));
4967 	    }
4968 	  delay_slots -= words;
4969 	}
4970 
4971       /* Is this instruction the target of a repeat?  */
4972       if (repeat_slot)
4973 	{
4974 	  if (insn.tm->flags & FL_NR)
4975 	    as_warn (_("'%s' is not repeatable. "
4976 		       "Resulting behavior is undefined."),
4977 		     insn.tm->name);
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."));
4982 	  repeat_slot = 0;
4983 	}
4984 
4985       /* Make sure we check the target of a repeat instruction.  */
4986       if (insn.tm->flags & B_REPEAT)
4987 	{
4988 	  repeat_slot = 1;
4989 	  /* FIXME -- warn if repeat_slot == 1 at EOF.  */
4990 	}
4991       /* Make sure we check our delay slots for validity.  */
4992       if (insn.tm->flags & FL_DELAY)
4993 	{
4994 	  delay_slots = 2;
4995 	  /* FIXME -- warn if delay_slots != 0 at EOF.  */
4996 	}
4997     }
4998 }
4999 
5000 /* Do a final adjustment on the symbol table; in this case, make sure we have
5001    a ".file" symbol.  */
5002 
5003 void
tic54x_adjust_symtab(void)5004 tic54x_adjust_symtab (void)
5005 {
5006   if (symbol_rootP == NULL
5007       || S_GET_STORAGE_CLASS (symbol_rootP) != C_FILE)
5008     {
5009       char *filename;
5010       unsigned lineno;
5011       as_where (&filename, &lineno);
5012       c_dot_file_symbol (filename, 0);
5013     }
5014 }
5015 
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.  */
5019 
5020 int
tic54x_unrecognized_line(int c)5021 tic54x_unrecognized_line (int c)
5022 {
5023   return c == PARALLEL_SEPARATOR;
5024 }
5025 
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
5028    appropriate places.
5029    FIXME -- obviously this isn't done yet.  These locals still show up in the
5030    symbol table.  */
5031 void
tic54x_define_label(symbolS * sym)5032 tic54x_define_label (symbolS *sym)
5033 {
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;
5041 }
5042 
5043 /* Try to parse something that normal parsing failed at.  */
5044 
5045 symbolS *
tic54x_undefined_symbol(char * name)5046 tic54x_undefined_symbol (char *name)
5047 {
5048   symbol *sym;
5049 
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)
5056     {
5057       return symbol_new (name, reg_section,
5058 			 (valueT) sym->value,
5059 			 &zero_address_frag);
5060     }
5061 
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"))
5065     {
5066       return symbol_new (name, reg_section,
5067 			 (valueT) sym ? sym->value : 0,
5068 			 &zero_address_frag);
5069     }
5070 
5071   return NULL;
5072 }
5073 
5074 /* Parse a name in an expression before the expression parser takes a stab at
5075    it.  */
5076 
5077 int
tic54x_parse_name(char * name ATTRIBUTE_UNUSED,expressionS * expn ATTRIBUTE_UNUSED)5078 tic54x_parse_name (char *name ATTRIBUTE_UNUSED,
5079 		   expressionS *expn ATTRIBUTE_UNUSED)
5080 {
5081   return 0;
5082 }
5083 
5084 char *
md_atof(int type,char * literalP,int * sizeP)5085 md_atof (int type, char *literalP, int *sizeP)
5086 {
5087   /* Target data is little-endian, but floats are stored
5088      big-"word"ian.  ugh.  */
5089   return ieee_md_atof (type, literalP, sizeP, TRUE);
5090 }
5091 
5092 arelent *
tc_gen_reloc(asection * section,fixS * fixP)5093 tc_gen_reloc (asection *section, fixS *fixP)
5094 {
5095   arelent *rel;
5096   bfd_reloc_code_real_type code = fixP->fx_r_type;
5097   asymbol *sym = symbol_get_bfdsym (fixP->fx_addsy);
5098 
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;
5108 
5109   if (!rel->howto)
5110     {
5111       const char *name = S_GET_NAME (fixP->fx_addsy);
5112       if (name == NULL)
5113 	name = "<unknown>";
5114       as_fatal ("Cannot generate relocation type for symbol %s, code %s",
5115 		name, bfd_get_reloc_code_name (code));
5116       return NULL;
5117     }
5118   return rel;
5119 }
5120 
5121 /* Handle cons expressions.  */
5122 
5123 void
tic54x_cons_fix_new(fragS * frag,int where,int octets,expressionS * expn,bfd_reloc_code_real_type r)5124 tic54x_cons_fix_new (fragS *frag, int where, int octets, expressionS *expn,
5125 		     bfd_reloc_code_real_type r)
5126 {
5127   switch (octets)
5128     {
5129     default:
5130       as_bad (_("Unsupported relocation size %d"), octets);
5131       r = BFD_RELOC_TIC54X_16_OF_23;
5132       break;
5133     case 2:
5134       r = BFD_RELOC_TIC54X_16_OF_23;
5135       break;
5136     case 4:
5137       /* TI assembler always uses this, regardless of addressing mode.  */
5138       if (emitting_long)
5139 	r = BFD_RELOC_TIC54X_23;
5140       else
5141 	/* We never want to directly generate this; this is provided for
5142 	   stabs support only.  */
5143 	r = BFD_RELOC_32;
5144       break;
5145     }
5146   fix_new_exp (frag, where, octets, expn, 0, r);
5147 }
5148 
5149 /* Attempt to simplify or even eliminate a fixup.
5150    To indicate that a fixup has been eliminated, set fixP->fx_done.
5151 
5152    If fixp->fx_addsy is non-NULL, we'll have to generate a reloc entry.   */
5153 
5154 void
md_apply_fix(fixS * fixP,valueT * valP,segT seg ATTRIBUTE_UNUSED)5155 md_apply_fix (fixS *fixP, valueT *valP, segT seg ATTRIBUTE_UNUSED)
5156 {
5157   char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
5158   valueT val = * valP;
5159 
5160   switch (fixP->fx_r_type)
5161     {
5162     default:
5163       as_fatal ("Bad relocation type: 0x%02x", fixP->fx_r_type);
5164       return;
5165     case BFD_RELOC_TIC54X_MS7_OF_23:
5166       val = (val >> 16) & 0x7F;
5167       /* Fall through.  */
5168     case BFD_RELOC_TIC54X_16_OF_23:
5169     case BFD_RELOC_16:
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;
5174       break;
5175     case BFD_RELOC_TIC54X_PARTLS7:
5176       bfd_put_16 (stdoutput,
5177 		  (bfd_get_16 (stdoutput, buf) & 0xFF80) | (val & 0x7F),
5178 		  buf);
5179       /* Indicate what we're actually writing, so that we don't get warnings
5180 	 about exceeding available space.  */
5181       *valP = val & 0x7F;
5182       break;
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),
5188 		  buf);
5189       break;
5190     case BFD_RELOC_32:
5191     case BFD_RELOC_TIC54X_23:
5192       bfd_put_32 (stdoutput,
5193 		  (bfd_get_32 (stdoutput, buf) & 0xFF800000) | val,
5194 		  buf);
5195       break;
5196     }
5197 
5198   if (fixP->fx_addsy == NULL && fixP->fx_pcrel == 0)
5199     fixP->fx_done = 1;
5200 }
5201 
5202 /* This is our chance to record section alignment
5203    don't need to do anything here, since BFD does the proper encoding.  */
5204 
5205 valueT
md_section_align(segT segment ATTRIBUTE_UNUSED,valueT section_size)5206 md_section_align (segT segment ATTRIBUTE_UNUSED, valueT section_size)
5207 {
5208   return section_size;
5209 }
5210 
5211 long
md_pcrel_from(fixS * fixP ATTRIBUTE_UNUSED)5212 md_pcrel_from (fixS *fixP ATTRIBUTE_UNUSED)
5213 {
5214   return 0;
5215 }
5216 
5217 /* Mostly little-endian, but longwords (4 octets) get MS word stored
5218    first.  */
5219 
5220 void
tic54x_number_to_chars(char * buf,valueT val,int n)5221 tic54x_number_to_chars (char *buf, valueT val, int n)
5222 {
5223   if (n != 4)
5224     number_to_chars_littleendian (buf, val, n);
5225   else
5226     {
5227       number_to_chars_littleendian (buf    , val >> 16   , 2);
5228       number_to_chars_littleendian (buf + 2, val & 0xFFFF, 2);
5229     }
5230 }
5231 
5232 int
tic54x_estimate_size_before_relax(fragS * frag ATTRIBUTE_UNUSED,segT seg ATTRIBUTE_UNUSED)5233 tic54x_estimate_size_before_relax (fragS *frag ATTRIBUTE_UNUSED,
5234 				   segT seg ATTRIBUTE_UNUSED)
5235 {
5236   return 0;
5237 }
5238 
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.  */
5241 
5242 int
tic54x_relax_frag(fragS * frag,long stretch ATTRIBUTE_UNUSED)5243 tic54x_relax_frag (fragS *frag, long stretch ATTRIBUTE_UNUSED)
5244 {
5245   symbolS *sym = frag->fr_symbol;
5246   int growth = 0;
5247   int i;
5248 
5249   if (sym != NULL)
5250     {
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;
5256 
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"));
5262 
5263       if (size < 0)
5264 	{
5265 	  as_warn (_("negative value ignored in %s"),
5266 		   bi->type == TYPE_SPACE ? ".space" :
5267 		   bi->type == TYPE_BES ? ".bes" : ".field");
5268 	  growth = 0;
5269 	  frag->tc_frag_data = frag->fr_fix = 0;
5270 	  return 0;
5271 	}
5272 
5273       if (bi->type == TYPE_FIELD)
5274 	{
5275 	  /* Bit fields of 16 or larger will have already been handled.  */
5276 	  if (bit_offset != 0 && available >= size)
5277 	    {
5278 	      char *p = prev_frag->fr_literal;
5279 
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;
5286 	      if (bi->sym)
5287 		symbol_set_frag (bi->sym, prev_frag);
5288 	      /* This frag is no longer used.  */
5289 	      growth = -frag->fr_fix;
5290 	      frag->fr_fix = 0;
5291 	      frag->tc_frag_data = 0;
5292 	    }
5293 	  else
5294 	    {
5295 	      char *p = frag->fr_literal;
5296 
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;
5301 	      growth = 0;
5302 	    }
5303 	}
5304       else
5305 	{
5306 	  if (bit_offset != 0 && bit_offset < 16)
5307 	    {
5308 	      if (available >= size)
5309 		{
5310 		  if ((prev_frag->tc_frag_data += size) == 16)
5311 		    prev_frag->tc_frag_data = 0;
5312 		  if (bi->sym)
5313 		    symbol_set_frag (bi->sym, prev_frag);
5314 		  /* This frag is no longer used.  */
5315 		  growth = -frag->fr_fix;
5316 		  frag->fr_fix = 0;
5317 		  frag->tc_frag_data = 0;
5318 		  goto getout;
5319 		}
5320 	      if (bi->type == TYPE_SPACE && bi->sym)
5321 		symbol_set_frag (bi->sym, prev_frag);
5322 	      size -= available;
5323 	    }
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);
5332 	}
5333     getout:
5334       frag->fr_symbol = 0;
5335       frag->fr_opcode = 0;
5336       free ((void *) bi);
5337     }
5338   return growth;
5339 }
5340 
5341 void
tic54x_convert_frag(bfd * abfd ATTRIBUTE_UNUSED,segT seg ATTRIBUTE_UNUSED,fragS * frag)5342 tic54x_convert_frag (bfd *abfd ATTRIBUTE_UNUSED,
5343 		     segT seg ATTRIBUTE_UNUSED,
5344 		     fragS *frag)
5345 {
5346   /* Offset is in bytes.  */
5347   frag->fr_offset = (frag->fr_next->fr_address
5348 		     - frag->fr_address
5349 		     - frag->fr_fix) / frag->fr_var;
5350   if (frag->fr_offset < 0)
5351     {
5352       as_bad_where (frag->fr_file, frag->fr_line,
5353 		    _("attempt to .space/.bes backwards? (%ld)"),
5354 		    (long) frag->fr_offset);
5355     }
5356   frag->fr_type = rs_space;
5357 }
5358 
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).
5363 
5364    C is the character that used to be at *REST, which points to the end of the
5365    label.
5366 
5367    Don't allow labels to start with '.'  */
5368 
5369 int
tic54x_start_label(int c,char * rest)5370 tic54x_start_label (int c, char *rest)
5371 {
5372   /* If within .struct/.union, no auto line labels, please.  */
5373   if (current_stag != NULL)
5374     return 0;
5375 
5376   /* Disallow labels starting with "."  */
5377   if (c != ':')
5378     {
5379       char *label = rest;
5380 
5381       while (!is_end_of_line[(int) label[-1]])
5382 	--label;
5383       if (*label == '.')
5384 	{
5385 	  as_bad (_("Invalid label '%s'"), label);
5386 	  return 0;
5387 	}
5388     }
5389 
5390   if (is_end_of_line[(int) c])
5391     return 1;
5392 
5393   if (ISSPACE (c))
5394     while (ISSPACE (c = *++rest))
5395       ;
5396   if (c == '.')
5397     {
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]));
5405     }
5406 
5407   return 1;
5408 }
5409