Context Navigation

source: trunk/binutils/gas/config/tc-tic54x.c@ 2709

Visit:

Last change on this file since 2709 was 610, checked in by bird, 22 years ago
This commit was generated by cvs2svn to compensate for changes in r609, which included commits to RCS files with non-trunk default branches.
Property cvs2svn:cvs-rev set to `1.1.1.2` Property svn:eol-style set to `native` Property svn:executable set to ``*
File size: 150.9 KB

Line
1	/* tc-tic54x.c -- Assembly code for the Texas Instruments TMS320C54X
2	Copyright 1999, 2000, 2001, 2002 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 2, 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, 59 Temple Place - Suite 330, Boston, MA
20	02111-1307, 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 <stdlib.h>
48	#include <limits.h>
49	#include <errno.h>
50	#include "as.h"
51	#include "safe-ctype.h"
52	#include "sb.h"
53	#include "macro.h"
54	#include "subsegs.h"
55	#include "struc-symbol.h"
56	#include "opcode/tic54x.h"
57	#include "obj-coff.h"
58	#include <math.h>
59
60
61	static struct stag
62	{
63	symbolS sym; / Symbol for this stag; value is offset. */
64	const char name; / Shortcut to symbol name. */
65	bfd_vma size; /* Size of struct/union. */
66	int current_bitfield_offset; /* Temporary for tracking fields. */
67	int is_union;
68	struct stag_field /* List of fields. */
69	{
70	const char *name;
71	bfd_vma offset; /* Of start of this field. */
72	int bitfield_offset; /* Of start of this field. */
73	struct stag stag; / If field is struct/union. */
74	struct stag_field *next;
75	} *field;
76	/* For nesting; used only in stag construction. */
77	struct stag inner; / Enclosed .struct. */
78	struct stag outer; / Enclosing .struct. */
79	} *current_stag = NULL;
80
81	#define MAX_LINE 256 /* Lines longer than this are truncated by TI's asm. */
82
83	typedef struct _tic54x_insn
84	{
85	const template tm; / Opcode template. */
86
87	char mnemonic[MAX_LINE]; /* Opcode name/mnemonic. */
88	char parmnemonic[MAX_LINE]; /* 2nd mnemonic of parallel insn. */
89
90	int opcount;
91	struct opstruct
92	{
93	char buf[MAX_LINE];
94	enum optype type;
95	expressionS exp;
96	} operands[MAX_OPERANDS];
97
98	int paropcount;
99	struct opstruct paroperands[MAX_OPERANDS];
100
101	int is_lkaddr;
102	int lkoperand;
103	int words; /* Size of insn in 16-bit words. */
104	int using_default_dst; /* Do we need to explicitly set an
105	omitted OP_DST operand? */
106	struct
107	{
108	unsigned short word; /* Final encoded opcode data. */
109	int unresolved;
110	int r_nchars; /* Relocation size. */
111	bfd_reloc_code_real_type r_type; /* Relocation type. */
112	expressionS addr_expr; /* Storage for unresolved expressions. */
113	} opcode[3];
114	} tic54x_insn;
115
116	enum cpu_version
117	{
118	VNONE = 0, V541 = 1, V542 = 2, V543 = 3, V545 = 5, V548 = 8, V549 = 9,
119	V545LP = 15, V546LP = 16
120	};
121
122	enum address_mode
123	{
124	c_mode, /* 16-bit addresses. */
125	far_mode /* >16-bit addresses. */
126	};
127
128	static segT stag_saved_seg;
129	static subsegT stag_saved_subseg;
130
131	const char comment_chars[] = ";";
132	const char line_comment_chars[] = ";#"; / At column zero only. */
133	const char line_separator_chars[] = ""; /* Not permitted. */
134
135	int emitting_long = 0;
136
137	/* Characters which indicate that this is a floating point constant. */
138	const char FLT_CHARS[] = "fF";
139
140	/* Characters that can be used to separate mantissa from exp in FP
141	nums. */
142	const char EXP_CHARS[] = "eE";
143
144	const char *md_shortopts = "";
145
146	#define OPTION_ADDRESS_MODE (OPTION_MD_BASE)
147	#define OPTION_CPU_VERSION (OPTION_ADDRESS_MODE + 1)
148	#define OPTION_COFF_VERSION (OPTION_CPU_VERSION + 1)
149	#define OPTION_STDERR_TO_FILE (OPTION_COFF_VERSION + 1)
150
151	struct option md_longopts[] =
152	{
153	{ "mfar-mode", no_argument, NULL, OPTION_ADDRESS_MODE },
154	{ "mf", no_argument, NULL, OPTION_ADDRESS_MODE },
155	{ "mcpu", required_argument, NULL, OPTION_CPU_VERSION },
156	#if 0
157	{ "mcoff-version", required_argument, NULL, OPTION_COFF_VERSION },
158	#endif
159	{ "merrors-to-file", required_argument, NULL, OPTION_STDERR_TO_FILE },
160	{ "me", required_argument, NULL, OPTION_STDERR_TO_FILE },
161	{ NULL, no_argument, NULL, 0},
162	};
163
164	size_t md_longopts_size = sizeof (md_longopts);
165
166	static int assembly_begun = 0;
167	/* Addressing mode is not entirely implemented; the latest rev of the Other
168	assembler doesn't seem to make any distinction whatsoever; all relocations
169	are stored as extended relocatiosn. Older versions used REL16 vs RELEXT16,
170	but now it seems all relocations are RELEXT16. We use all RELEXT16.
171
172	The cpu version is kind of a waste of time as well. There is one
173	instruction (RND) for LP devices only, and several for devices with
174	extended addressing only. We include it for compatibility. */
175	static enum address_mode amode = c_mode;
176	static enum cpu_version cpu = VNONE;
177
178	/* Include string substitutions in listing? */
179	static int listing_sslist = 0;
180
181	/* Did we do subsym substitutions on the line? */
182	static int substitution_line = 0;
183
184	/* Last label seen. */
185	static symbolS *last_label_seen = NULL;
186
187	/* This ensures that all new labels are unique. */
188	static int local_label_id;
189
190	static struct hash_control subsym_recurse_hash; / Prevent infinite recurse. */
191	static struct hash_control math_hash; / Built-in math functions. */
192	/* Allow maximum levels of macro nesting; level 0 is the main substitution
193	symbol table. The other assembler only does 32 levels, so there! */
194	static struct hash_control *subsym_hash[100];
195
196	/* Keep track of local labels so we can substitute them before GAS sees them
197	since macros use their own 'namespace' for local labels, use a separate hash
198
199	We do our own local label handling 'cuz it's subtly different from the
200	stock GAS handling.
201
202	We use our own macro nesting counter, since GAS overloads it when expanding
203	other things (like conditionals and repeat loops). */
204	static int macro_level = 0;
205	static struct hash_control *local_label_hash[100];
206	/* Keep track of struct/union tags. */
207	static struct hash_control *stag_hash;
208	static struct hash_control *op_hash;
209	static struct hash_control *parop_hash;
210	static struct hash_control *reg_hash;
211	static struct hash_control *mmreg_hash;
212	static struct hash_control *cc_hash;
213	static struct hash_control *cc2_hash;
214	static struct hash_control *cc3_hash;
215	static struct hash_control *sbit_hash;
216	static struct hash_control *misc_symbol_hash;
217
218	/* Only word (et al.), align, or conditionals are allowed within
219	.struct/.union. */
220	#define ILLEGAL_WITHIN_STRUCT() \
221	do \
222	if (current_stag != NULL) \
223	{ \
224	as_bad (_("pseudo-op illegal within .struct/.union")); \
225	return; \
226	} \
227	while (0)
228
229	static void tic54x_emit_char PARAMS ((char));
230	static fragS * frag_prev PARAMS ((fragS *, segT));
231	static fragS * bit_offset_frag PARAMS ((fragS *, segT));
232	static int frag_bit_offset PARAMS ((fragS *, segT));
233	static char * parse_expression PARAMS ((char , expressionS ));
234	static void tic54x_asg PARAMS ((int));
235	static void tic54x_eval PARAMS ((int));
236	static void tic54x_bss PARAMS ((int));
237	static void stag_add_field_symbols PARAMS ((struct stag , const char , bfd_vma, symbolS , const char ));
238	static void stag_add_field PARAMS ((struct stag , const char , bfd_vma, struct stag *));
239	static void tic54x_struct PARAMS ((int));
240	static void tic54x_endstruct PARAMS ((int));
241	static void tic54x_tag PARAMS ((int));
242	static void tic54x_struct_field PARAMS ((int));
243	static void tic54x_cons PARAMS ((int));
244	static void tic54x_remove_local_label PARAMS ((const char *, PTR));
245	static void tic54x_clear_local_labels PARAMS ((int));
246	static void tic54x_sect PARAMS ((int));
247	static void tic54x_space PARAMS ((int));
248	static void tic54x_usect PARAMS ((int));
249	static enum cpu_version lookup_version PARAMS ((const char *));
250	static void set_cpu PARAMS ((enum cpu_version));
251	static void tic54x_version PARAMS ((int));
252	static void tic54x_float_cons PARAMS ((int));
253	static void tic54x_stringer PARAMS ((int));
254	static void tic54x_p2align PARAMS ((int));
255	static void tic54x_align_words PARAMS ((int));
256	static void tic54x_field PARAMS ((int));
257	static int tic54x_initialized_section PARAMS ((segT));
258	static void tic54x_clink PARAMS ((int));
259	static void tic54x_set_default_include PARAMS ((int));
260	static void tic54x_include PARAMS ((int));
261	static void tic54x_message PARAMS ((int));
262	static void tic54x_label PARAMS ((int));
263	static void tic54x_mmregs PARAMS ((int));
264	static void tic54x_loop PARAMS ((int));
265	static void tic54x_endloop PARAMS ((int));
266	static void tic54x_break PARAMS ((int));
267	static void set_address_mode PARAMS ((int));
268	static void tic54x_address_mode PARAMS ((int));
269	static void tic54x_sblock PARAMS ((int));
270	static void tic54x_set PARAMS ((int));
271	static void tic54x_fclist PARAMS ((int));
272	static void tic54x_sslist PARAMS ((int));
273	static void tic54x_var PARAMS ((int));
274	static void tic54x_mlib PARAMS ((int));
275	static int subsym_symlen PARAMS ((char , char ));
276	static int subsym_symcmp PARAMS ((char , char ));
277	static int subsym_firstch PARAMS ((char , char ));
278	static int subsym_lastch PARAMS ((char , char ));
279	static int subsym_isdefed PARAMS ((char , char ));
280	static int subsym_ismember PARAMS ((char , char ));
281	static int subsym_iscons PARAMS ((char , char ));
282	static int subsym_isname PARAMS ((char , char ));
283	static int subsym_isreg PARAMS ((char , char ));
284	static int subsym_structsz PARAMS ((char , char ));
285	static int subsym_structacc PARAMS ((char , char ));
286	static float math_ceil PARAMS ((float, float));
287	static float math_cvi PARAMS ((float, float));
288	static float math_floor PARAMS ((float, float));
289	static float math_fmod PARAMS ((float, float));
290	static float math_int PARAMS ((float, float));
291	static float math_round PARAMS ((float, float));
292	static float math_sgn PARAMS ((float, float));
293	static float math_trunc PARAMS ((float, float));
294	static float math_acos PARAMS ((float, float));
295	static float math_asin PARAMS ((float, float));
296	static float math_atan PARAMS ((float, float));
297	static float math_atan2 PARAMS ((float, float));
298	static float math_cosh PARAMS ((float, float));
299	static float math_cos PARAMS ((float, float));
300	static float math_cvf PARAMS ((float, float));
301	static float math_exp PARAMS ((float, float));
302	static float math_fabs PARAMS ((float, float));
303	static float math_ldexp PARAMS ((float, float));
304	static float math_log10 PARAMS ((float, float));
305	static float math_log PARAMS ((float, float));
306	static float math_max PARAMS ((float, float));
307	static float math_min PARAMS ((float, float));
308	static float math_pow PARAMS ((float, float));
309	static float math_sin PARAMS ((float, float));
310	static float math_sinh PARAMS ((float, float));
311	static float math_sqrt PARAMS ((float, float));
312	static float math_tan PARAMS ((float, float));
313	static float math_tanh PARAMS ((float, float));
314	static int is_accumulator PARAMS ((struct opstruct *));
315	static int get_operands PARAMS ((struct opstruct operands[], char *));
316	static int is_immediate PARAMS ((struct opstruct *));
317	static int is_absolute PARAMS ((struct opstruct *));
318	static int is_indirect PARAMS ((struct opstruct *));
319	static int is_dual PARAMS ((struct opstruct *));
320	static int is_mmreg PARAMS ((struct opstruct *));
321	static int is_type PARAMS ((struct opstruct *, enum optype));
322	static int operands_match PARAMS ((tic54x_insn , struct opstruct , int, const enum optype *, int, int));
323	static int encode_dmad PARAMS ((tic54x_insn , struct opstruct , int));
324	static int encode_address PARAMS ((tic54x_insn , struct opstruct ));
325	static int encode_indirect PARAMS ((tic54x_insn , struct opstruct ));
326	static int encode_integer PARAMS ((tic54x_insn , struct opstruct , int, int, int, unsigned short));
327	static int encode_condition PARAMS ((tic54x_insn , struct opstruct ));
328	static int encode_cc3 PARAMS ((tic54x_insn , struct opstruct ));
329	static int encode_arx PARAMS ((tic54x_insn , struct opstruct ));
330	static int encode_cc2 PARAMS ((tic54x_insn , struct opstruct ));
331	static int encode_operand PARAMS ((tic54x_insn , enum optype, struct opstruct ));
332	static void emit_insn PARAMS ((tic54x_insn *));
333	static int build_insn PARAMS ((tic54x_insn *));
334	static int optimize_insn PARAMS ((tic54x_insn *));
335	static int tic54x_parse_insn PARAMS ((tic54x_insn , char ));
336	static int next_line_shows_parallel PARAMS ((char *));
337	static int tic54x_parse_parallel_insn_firstline PARAMS ((tic54x_insn , char ));
338	static int tic54x_parse_parallel_insn_lastline PARAMS ((tic54x_insn , char ));
339	static char * subsym_get_arg PARAMS ((char , char , char **, int));
340	static void subsym_create_or_replace PARAMS ((char , char ));
341	static char * subsym_lookup PARAMS ((char *, int));
342	static char * subsym_substitute PARAMS ((char *, int));
343
344
345	void
346	md_show_usage (stream)
347	FILE *stream;
348	{
349	fprintf (stream, _("C54x-specific command line options:\n"));
350	fprintf (stream, _("-mfar-mode \| -mf Use extended addressing\n"));
351	fprintf (stream, _("-mcpu=<CPU version> Specify the CPU version\n"));
352	#if 0
353	fprintf (stream, _("-mcoff-version={0\|1\|2} Select COFF version\n"));
354	#endif
355	fprintf (stream, _("-merrors-to-file <filename>\n"));
356	fprintf (stream, _("-me <filename> Redirect errors to a file\n"));
357	}
358
359	/* Output a single character (upper octect is zero). */
360
361	static void
362	tic54x_emit_char (c)
363	char c;
364	{
365	expressionS exp;
366
367	exp.X_op = O_constant;
368	exp.X_add_number = c;
369	emit_expr (&exp, 2);
370	}
371
372	/* Walk backwards in the frag chain. */
373
374	static fragS *
375	frag_prev (frag, seg)
376	fragS *frag;
377	segT seg;
378	{
379	segment_info_type *seginfo = seg_info (seg);
380	fragS *fragp;
381
382	for (fragp = seginfo->frchainP->frch_root; fragp; fragp = fragp->fr_next)
383	if (fragp->fr_next == frag)
384	return fragp;
385
386	return NULL;
387	}
388
389	static fragS *
390	bit_offset_frag (frag, seg)
391	fragS *frag;
392	segT seg;
393	{
394	while (frag != NULL)
395	{
396	if (frag->fr_fix == 0
397	&& frag->fr_opcode == NULL
398	&& frag->tc_frag_data == 0)
399	frag = frag_prev (frag, seg);
400	else
401	return frag;
402	}
403	return NULL;
404	}
405
406	/* Return the number of bits allocated in the most recent word, or zero if
407	none. .field/.space/.bes may leave words partially allocated. */
408
409	static int
410	frag_bit_offset (frag, seg)
411	fragS *frag;
412	segT seg;
413	{
414	frag = bit_offset_frag (frag, seg);
415
416	if (frag)
417	return frag->fr_opcode != NULL ? -1 : frag->tc_frag_data;
418
419	return 0;
420	}
421
422	/* Read an expression from a C string; returns a pointer past the end of the
423	expression. */
424
425	static char *
426	parse_expression (str, exp)
427	char *str;
428	expressionS * exp;
429	{
430	char *s;
431	char *tmp;
432
433	tmp = input_line_pointer; /* Save line pointer. */
434	input_line_pointer = str;
435	expression (exp);
436	s = input_line_pointer;
437	input_line_pointer = tmp; /* Restore line pointer. */
438	return s; /* Return pointer to where parsing stopped. */
439	}
440
441	/* .asg "character-string"\|character-string, symbol
442
443	.eval is the only pseudo-op allowed to perform arithmetic on substitution
444	symbols. all other use of symbols defined with .asg are currently
445	unsupported. */
446
447	static void
448	tic54x_asg (x)
449	int x ATTRIBUTE_UNUSED;
450	{
451	int c;
452	char *name;
453	char *str;
454	char *tmp;
455	int quoted = *input_line_pointer == '"';
456
457	ILLEGAL_WITHIN_STRUCT ();
458
459	if (quoted)
460	{
461	int len;
462	str = demand_copy_C_string (&len);
463	c = *input_line_pointer;
464	}
465	else
466	{
467	str = input_line_pointer;
468	while ((c = *input_line_pointer) != ',')
469	{
470	if (is_end_of_line[(int) *input_line_pointer])
471	break;
472	++input_line_pointer;
473	}
474	*input_line_pointer = 0;
475	}
476	if (c != ',')
477	{
478	as_bad (_("Comma and symbol expected for '.asg STRING, SYMBOL'"));
479	ignore_rest_of_line ();
480	return;
481	}
482
483	name = ++input_line_pointer;
484	c = get_symbol_end (); /* Get terminator. */
485	if (!ISALPHA (*name))
486	{
487	as_bad ("symbols assigned with .asg must begin with a letter");
488	ignore_rest_of_line ();
489	return;
490	}
491
492	tmp = xmalloc (strlen (str) + 1);
493	strcpy (tmp, str);
494	str = tmp;
495	tmp = xmalloc (strlen (name) + 1);
496	strcpy (tmp, name);
497	name = tmp;
498	subsym_create_or_replace (name, str);
499	*input_line_pointer = c;
500	demand_empty_rest_of_line ();
501	}
502
503	/* .eval expression, symbol
504	There's something screwy about this. The other assembler sometimes does and
505	sometimes doesn't substitute symbols defined with .eval.
506	We'll put the symbols into the subsym table as well as the normal symbol
507	table, since that's what works best. */
508
509	static void
510	tic54x_eval (x)
511	int x ATTRIBUTE_UNUSED;
512	{
513	char c;
514	int value;
515	char *name;
516	symbolS *symbolP;
517	char valuestr[32], *tmp;
518	int quoted;
519
520	ILLEGAL_WITHIN_STRUCT ();
521
522	SKIP_WHITESPACE ();
523
524	quoted = *input_line_pointer == '"';
525	if (quoted)
526	++input_line_pointer;
527	value = get_absolute_expression ();
528	if (quoted)
529	{
530	if (*input_line_pointer != '"')
531	{
532	as_bad (_("Unterminated string after absolute expression"));
533	ignore_rest_of_line ();
534	return;
535	}
536	++input_line_pointer;
537	}
538	if (*input_line_pointer++ != ',')
539	{
540	as_bad (_("Comma and symbol expected for '.eval EXPR, SYMBOL'"));
541	ignore_rest_of_line ();
542	return;
543	}
544	name = input_line_pointer;
545	c = get_symbol_end (); /* Get terminator. */
546	tmp = xmalloc (strlen (name) + 1);
547	name = strcpy (tmp, name);
548	*input_line_pointer = c;
549
550	if (!ISALPHA (*name))
551	{
552	as_bad (_("symbols assigned with .eval must begin with a letter"));
553	ignore_rest_of_line ();
554	return;
555	}
556	symbolP = symbol_new (name, absolute_section,
557	(valueT) value, &zero_address_frag);
558	SF_SET_LOCAL (symbolP);
559	symbol_table_insert (symbolP);
560
561	/* The "other" assembler sometimes doesn't put .eval's in the subsym table
562	But since there's not written rule as to when, don't even bother trying
563	to match their behavior. */
564	sprintf (valuestr, "%d", value);
565	tmp = xmalloc (strlen (valuestr) + 1);
566	strcpy (tmp, valuestr);
567	subsym_create_or_replace (name, tmp);
568
569	demand_empty_rest_of_line ();
570	}
571
572	/* .bss symbol, size [, [blocking flag] [, alignment flag]
573
574	alignment is to a longword boundary; blocking is to 128-word boundary.
575
576	1) if there is a hole in memory, this directive should attempt to fill it
577	(not yet implemented).
578
579	2) if the blocking flag is not set, allocate at the current SPC
580	otherwise, check to see if the current SPC plus the space to be
581	allocated crosses the page boundary (128 words).
582	if there's not enough space, create a hole and align with the next page
583	boundary.
584	(not yet implemented). */
585
586	static void
587	tic54x_bss (x)
588	int x ATTRIBUTE_UNUSED;
589	{
590	char c;
591	char *name;
592	char *p;
593	int words;
594	segT current_seg;
595	subsegT current_subseg;
596	symbolS *symbolP;
597	int block = 0;
598	int align = 0;
599
600	ILLEGAL_WITHIN_STRUCT ();
601
602	current_seg = now_seg; /* Save current seg. */
603	current_subseg = now_subseg; /* Save current subseg. */
604
605	name = input_line_pointer;
606	c = get_symbol_end (); /* Get terminator. */
607	if (c != ',')
608	{
609	as_bad (".bss size argument missing\n");
610	ignore_rest_of_line ();
611	return;
612	}
613
614	++input_line_pointer;
615	words = get_absolute_expression ();
616	if (words < 0)
617	{
618	as_bad (".bss size %d < 0!", words);
619	ignore_rest_of_line ();
620	return;
621	}
622
623	if (*input_line_pointer == ',')
624	{
625	/* The blocking flag may be missing. */
626	++input_line_pointer;
627	if (*input_line_pointer != ',')
628	block = get_absolute_expression ();
629	else
630	block = 0;
631
632	if (*input_line_pointer == ',')
633	{
634	++input_line_pointer;
635	align = get_absolute_expression ();
636	}
637	else
638	align = 0;
639	}
640	else
641	block = align = 0;
642
643	subseg_set (bss_section, 0);
644	symbolP = symbol_find_or_make (name);
645
646	if (S_GET_SEGMENT (symbolP) == bss_section)
647	symbolP->sy_frag->fr_symbol = (symbolS *) NULL;
648
649	symbol_set_frag (symbolP, frag_now);
650	p = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP,
651	(offsetT) (words * OCTETS_PER_BYTE), (char *) 0);
652	p = 0; / Fill char. */
653
654	S_SET_SEGMENT (symbolP, bss_section);
655
656	/* The symbol may already have been created with a preceding
657	".globl" directive -- be careful not to step on storage class
658	in that case. Otherwise, set it to static. */
659	if (S_GET_STORAGE_CLASS (symbolP) != C_EXT)
660	S_SET_STORAGE_CLASS (symbolP, C_STAT);
661
662	if (align)
663	{
664	/* s_align eats end of line; restore it */
665	s_align_bytes (4);
666	--input_line_pointer;
667	}
668
669	if (block)
670	bss_section->flags \|= SEC_BLOCK;
671
672	subseg_set (current_seg, current_subseg); /* Restore current seg. */
673	demand_empty_rest_of_line ();
674	}
675
676	static void
677	stag_add_field_symbols (stag, path, base_offset, rootsym, root_stag_name)
678	struct stag *stag;
679	const char *path;
680	bfd_vma base_offset;
681	symbolS *rootsym;
682	const char *root_stag_name;
683	{
684	char prefix[strlen (path) + 2];
685	struct stag_field *field = stag->field;
686
687	/* Construct a symbol for every field contained within this structure
688	including fields within structure fields. */
689	strcpy (prefix, path);
690	if (*path)
691	strcat (prefix, ".");
692
693	while (field != NULL)
694	{
695	int len = strlen (prefix) + strlen (field->name) + 2;
696	char *name = xmalloc (len);
697	strcpy (name, prefix);
698	strcat (name, field->name);
699
700	if (rootsym == NULL)
701	{
702	symbolS *sym;
703	sym = symbol_new (name, absolute_section,
704	(field->stag ? field->offset :
705	(valueT) (base_offset + field->offset)),
706	&zero_address_frag);
707	SF_SET_LOCAL (sym);
708	symbol_table_insert (sym);
709	}
710	else
711	{
712	char *replacement = xmalloc (strlen (name)
713	+ strlen (stag->name) + 2);
714	strcpy (replacement, S_GET_NAME (rootsym));
715	strcat (replacement, "+");
716	strcat (replacement, root_stag_name);
717	strcat (replacement, name + strlen (S_GET_NAME (rootsym)));
718	hash_insert (subsym_hash[0], name, replacement);
719	}
720
721	/* Recurse if the field is a structure.
722	Note the field offset is relative to the outermost struct. */
723	if (field->stag != NULL)
724	stag_add_field_symbols (field->stag, name,
725	field->offset,
726	rootsym, root_stag_name);
727	field = field->next;
728	}
729	}
730
731	/* Keep track of stag fields so that when structures are nested we can add the
732	complete dereferencing symbols to the symbol table. */
733
734	static void
735	stag_add_field (parent, name, offset, stag)
736	struct stag *parent;
737	const char *name;
738	bfd_vma offset;
739	struct stag *stag;
740	{
741	struct stag_field *sfield = xmalloc (sizeof (struct stag_field));
742
743	memset (sfield, 0, sizeof (*sfield));
744	sfield->name = strcpy (xmalloc (strlen (name) + 1), name);
745	sfield->offset = offset;
746	sfield->bitfield_offset = parent->current_bitfield_offset;
747	sfield->stag = stag;
748	if (parent->field == NULL)
749	parent->field = sfield;
750	else
751	{
752	struct stag_field *sf = parent->field;
753	while (sf->next != NULL)
754	sf = sf->next;
755	sf->next = sfield;
756	}
757	/* Only create a symbol for this field if the parent has no name. */
758	if (!strncmp (".fake", parent->name, 5))
759	{
760	symbolS *sym = symbol_new (name, absolute_section,
761	(valueT) offset, &zero_address_frag);
762	SF_SET_LOCAL (sym);
763	symbol_table_insert (sym);
764	}
765	}
766
767	/* [STAG] .struct [OFFSET]
768	Start defining structure offsets (symbols in absolute section). */
769
770	static void
771	tic54x_struct (arg)
772	int arg;
773	{
774	int start_offset = 0;
775	int is_union = arg;
776
777	if (!current_stag)
778	{
779	/* Starting a new struct, switch to absolute section. */
780	stag_saved_seg = now_seg;
781	stag_saved_subseg = now_subseg;
782	subseg_set (absolute_section, 0);
783	}
784	/* Align the current pointer. */
785	else if (current_stag->current_bitfield_offset != 0)
786	{
787	++abs_section_offset;
788	current_stag->current_bitfield_offset = 0;
789	}
790
791	/* Offset expression is only meaningful for global .structs. */
792	if (!is_union)
793	{
794	/* Offset is ignored in inner structs. */
795	SKIP_WHITESPACE ();
796	if (!is_end_of_line[(int) *input_line_pointer])
797	start_offset = get_absolute_expression ();
798	else
799	start_offset = 0;
800	}
801
802	if (current_stag)
803	{
804	/* Nesting, link to outer one. */
805	current_stag->inner = (struct stag *) xmalloc (sizeof (struct stag));
806	memset (current_stag->inner, 0, sizeof (struct stag));
807	current_stag->inner->outer = current_stag;
808	current_stag = current_stag->inner;
809	if (start_offset)
810	as_warn (_("Offset on nested structures is ignored"));
811	start_offset = abs_section_offset;
812	}
813	else
814	{
815	current_stag = (struct stag *) xmalloc (sizeof (struct stag));
816	memset (current_stag, 0, sizeof (struct stag));
817	abs_section_offset = start_offset;
818	}
819	current_stag->is_union = is_union;
820
821	if (line_label == NULL)
822	{
823	static int struct_count = 0;
824	char fake[] = ".fake_stagNNNNNNN";
825	sprintf (fake, ".fake_stag%d", struct_count++);
826	current_stag->sym = symbol_new (fake, absolute_section,
827	(valueT) abs_section_offset,
828	&zero_address_frag);
829	}
830	else
831	{
832	char label[strlen (S_GET_NAME (line_label)) + 1];
833	strcpy (label, S_GET_NAME (line_label));
834	current_stag->sym = symbol_new (label, absolute_section,
835	(valueT) abs_section_offset,
836	&zero_address_frag);
837	}
838	current_stag->name = S_GET_NAME (current_stag->sym);
839	SF_SET_LOCAL (current_stag->sym);
840	/* Nested .structs don't go into the symbol table. */
841	if (current_stag->outer == NULL)
842	symbol_table_insert (current_stag->sym);
843
844	line_label = NULL;
845	}
846
847	/* [LABEL] .endstruct
848	finish defining structure offsets; optional LABEL's value will be the size
849	of the structure. */
850
851	static void
852	tic54x_endstruct (is_union)
853	int is_union;
854	{
855	int size;
856	const char *path =
857	!strncmp (current_stag->name, ".fake", 5) ? "" : current_stag->name;
858
859	if (!current_stag \|\| current_stag->is_union != is_union)
860	{
861	as_bad (_(".end%s without preceding .%s"),
862	is_union ? "union" : "struct",
863	is_union ? "union" : "struct");
864	ignore_rest_of_line ();
865	return;
866	}
867
868	/* Align end of structures. */
869	if (current_stag->current_bitfield_offset)
870	{
871	++abs_section_offset;
872	current_stag->current_bitfield_offset = 0;
873	}
874
875	if (current_stag->is_union)
876	size = current_stag->size;
877	else
878	size = abs_section_offset - S_GET_VALUE (current_stag->sym);
879	if (line_label != NULL)
880	{
881	S_SET_VALUE (line_label, size);
882	symbol_table_insert (line_label);
883	line_label = NULL;
884	}
885
886	/* Union size has already been calculated. */
887	if (!current_stag->is_union)
888	current_stag->size = size;
889	/* Nested .structs don't get put in the stag table. */
890	if (current_stag->outer == NULL)
891	{
892	hash_insert (stag_hash, current_stag->name, current_stag);
893	stag_add_field_symbols (current_stag, path,
894	S_GET_VALUE (current_stag->sym),
895	NULL, NULL);
896	}
897	current_stag = current_stag->outer;
898
899	/* If this is a nested .struct/.union, add it as a field to the enclosing
900	one. otherwise, restore the section we were in. */
901	if (current_stag != NULL)
902	{
903	stag_add_field (current_stag, current_stag->inner->name,
904	S_GET_VALUE (current_stag->inner->sym),
905	current_stag->inner);
906	}
907	else
908	subseg_set (stag_saved_seg, stag_saved_subseg);
909	}
910
911	/* [LABEL] .tag STAG
912	Reference a structure within a structure, as a sized field with an optional
913	label.
914	If used outside of a .struct/.endstruct, overlays the given structure
915	format on the existing allocated space. */
916
917	static void
918	tic54x_tag (ignore)
919	int ignore ATTRIBUTE_UNUSED;
920	{
921	char *name = input_line_pointer;
922	int c = get_symbol_end ();
923	struct stag stag = (struct stag ) hash_find (stag_hash, name);
924
925	if (!stag)
926	{
927	if (*name)
928	as_bad (_("Unrecognized struct/union tag '%s'"), name);
929	else
930	as_bad (_(".tag requires a structure tag"));
931	ignore_rest_of_line ();
932	return;
933	}
934	if (line_label == NULL)
935	{
936	as_bad (_("Label required for .tag"));
937	ignore_rest_of_line ();
938	return;
939	}
940	else
941	{
942	char label[strlen (S_GET_NAME (line_label)) + 1];
943
944	strcpy (label, S_GET_NAME (line_label));
945	if (current_stag != NULL)
946	stag_add_field (current_stag, label,
947	abs_section_offset - S_GET_VALUE (current_stag->sym),
948	stag);
949	else
950	{
951	symbolS *sym = symbol_find (label);
952
953	if (!sym)
954	{
955	as_bad (_(".tag target '%s' undefined"), label);
956	ignore_rest_of_line ();
957	return;
958	}
959	stag_add_field_symbols (stag, S_GET_NAME (sym),
960	S_GET_VALUE (stag->sym), sym, stag->name);
961	}
962	}
963
964	/* Bump by the struct size, but only if we're within a .struct section. */
965	if (current_stag != NULL && !current_stag->is_union)
966	abs_section_offset += stag->size;
967
968	*input_line_pointer = c;
969	demand_empty_rest_of_line ();
970	line_label = NULL;
971	}
972
973	/* Handle all .byte, .char, .double, .field, .float, .half, .int, .long,
974	.short, .string, .ubyte, .uchar, .uhalf, .uint, .ulong, .ushort, .uword,
975	and .word. */
976
977	static void
978	tic54x_struct_field (type)
979	int type;
980	{
981	int size;
982	int count = 1;
983	int new_bitfield_offset = 0;
984	int field_align = current_stag->current_bitfield_offset != 0;
985	int longword_align = 0;
986
987	SKIP_WHITESPACE ();
988	if (!is_end_of_line[(int) *input_line_pointer])
989	count = get_absolute_expression ();
990
991	switch (type)
992	{
993	case 'b':
994	case 'B':
995	case 'c':
996	case 'C':
997	case 'h':
998	case 'H':
999	case 'i':
1000	case 'I':
1001	case 's':
1002	case 'S':
1003	case 'w':
1004	case 'W':
1005	case '': / String. */
1006	size = 1;
1007	break;
1008	case 'f':
1009	case 'l':
1010	case 'L':
1011	longword_align = 1;
1012	size = 2;
1013	break;
1014	case '.': /* Bitfield. */
1015	size = 0;
1016	if (count < 1 \|\| count > 32)
1017	{
1018	as_bad (_(".field count '%d' out of range (1 <= X <= 32)"), count);
1019	ignore_rest_of_line ();
1020	return;
1021	}
1022	if (current_stag->current_bitfield_offset + count > 16)
1023	{
1024	/* Set the appropriate size and new field offset. */
1025	if (count == 32)
1026	{
1027	size = 2;
1028	count = 1;
1029	}
1030	else if (count > 16)
1031	{
1032	size = 1;
1033	count = 1;
1034	new_bitfield_offset = count - 16;
1035	}
1036	else
1037	new_bitfield_offset = count;
1038	}
1039	else
1040	{
1041	field_align = 0;
1042	new_bitfield_offset = current_stag->current_bitfield_offset + count;
1043	}
1044	break;
1045	default:
1046	as_bad (_("Unrecognized field type '%c'"), type);
1047	ignore_rest_of_line ();
1048	return;
1049	}
1050
1051	if (field_align)
1052	{
1053	/* Align to the actual starting position of the field. */
1054	current_stag->current_bitfield_offset = 0;
1055	++abs_section_offset;
1056	}
1057	/* Align to longword boundary. */
1058	if (longword_align && (abs_section_offset & 0x1))
1059	++abs_section_offset;
1060
1061	if (line_label == NULL)
1062	{
1063	static int fieldno = 0;
1064	char fake[] = ".fake_fieldNNNNN";
1065
1066	sprintf (fake, ".fake_field%d", fieldno++);
1067	stag_add_field (current_stag, fake,
1068	abs_section_offset - S_GET_VALUE (current_stag->sym),
1069	NULL);
1070	}
1071	else
1072	{
1073	char label[strlen (S_GET_NAME (line_label) + 1)];
1074
1075	strcpy (label, S_GET_NAME (line_label));
1076	stag_add_field (current_stag, label,
1077	abs_section_offset - S_GET_VALUE (current_stag->sym),
1078	NULL);
1079	}
1080
1081	if (current_stag->is_union)
1082	{
1083	/* Note we treat the element as if it were an array of COUNT. */
1084	if (current_stag->size < (unsigned) size * count)
1085	current_stag->size = size * count;
1086	}
1087	else
1088	{
1089	abs_section_offset += (unsigned) size * count;
1090	current_stag->current_bitfield_offset = new_bitfield_offset;
1091	}
1092	line_label = NULL;
1093	}
1094
1095	/* Handle .byte, .word. .int, .long and all variants. */
1096
1097	static void
1098	tic54x_cons (type)
1099	int type;
1100	{
1101	unsigned int c;
1102	int octets;
1103
1104	/* If we're within a .struct construct, don't actually allocate space. */
1105	if (current_stag != NULL)
1106	{
1107	tic54x_struct_field (type);
1108	return;
1109	}
1110
1111	#ifdef md_flush_pending_output
1112	md_flush_pending_output ();
1113	#endif
1114
1115	generate_lineno_debug ();
1116
1117	/* Align long words to long word boundaries (4 octets). */
1118	if (type == 'l' \|\| type == 'L')
1119	{
1120	frag_align (2, 0, 2);
1121	/* If there's a label, assign it to the first allocated word. */
1122	if (line_label != NULL)
1123	{
1124	symbol_set_frag (line_label, frag_now);
1125	S_SET_VALUE (line_label, frag_now_fix ());
1126	}
1127	}
1128
1129	switch (type)
1130	{
1131	case 'l':
1132	case 'L':
1133	case 'x':
1134	octets = 4;
1135	break;
1136	case 'b':
1137	case 'B':
1138	case 'c':
1139	case 'C':
1140	octets = 1;
1141	break;
1142	default:
1143	octets = 2;
1144	break;
1145	}
1146
1147	do
1148	{
1149	if (*input_line_pointer == '"')
1150	{
1151	input_line_pointer++;
1152	while (is_a_char (c = next_char_of_string ()))
1153	tic54x_emit_char (c);
1154	know (input_line_pointer[-1] == '\"');
1155	}
1156	else
1157	{
1158	expressionS exp;
1159
1160	input_line_pointer = parse_expression (input_line_pointer, &exp);
1161	if (exp.X_op == O_constant)
1162	{
1163	offsetT value = exp.X_add_number;
1164	/* Truncate overflows. */
1165	switch (octets)
1166	{
1167	case 1:
1168	if ((value > 0 && value > 0xFF)
1169	\|\| (value < 0 && value < - 0x100))
1170	as_warn ("Overflow in expression, truncated to 8 bits");
1171	break;
1172	case 2:
1173	if ((value > 0 && value > 0xFFFF)
1174	\|\| (value < 0 && value < - 0x10000))
1175	as_warn ("Overflow in expression, truncated to 16 bits");
1176	break;
1177	}
1178	}
1179	if (exp.X_op != O_constant && octets < 2)
1180	{
1181	/* Disallow .byte with a non constant expression that will
1182	require relocation. */
1183	as_bad (_("Relocatable values require at least WORD storage"));
1184	ignore_rest_of_line ();
1185	return;
1186	}
1187
1188	if (exp.X_op != O_constant
1189	&& amode == c_mode
1190	&& octets == 4)
1191	{
1192	/* FIXME -- at one point TI tools used to output REL16
1193	relocations, but I don't think the latest tools do at all
1194	The current tools output extended relocations regardless of
1195	the addresing mode (I actually think that ".c_mode" is
1196	totally ignored in the latest tools). */
1197	amode = far_mode;
1198	emitting_long = 1;
1199	emit_expr (&exp, 4);
1200	emitting_long = 0;
1201	amode = c_mode;
1202	}
1203	else
1204	{
1205	emitting_long = octets == 4;
1206	emit_expr (&exp, (octets == 1) ? 2 : octets);
1207	emitting_long = 0;
1208	}
1209	}
1210	}
1211	while (*input_line_pointer++ == ',');
1212
1213	input_line_pointer--; /* Put terminator back into stream. */
1214	demand_empty_rest_of_line ();
1215	}
1216
1217	/* .global <symbol>[,...,<symbolN>]
1218	.def <symbol>[,...,<symbolN>]
1219	.ref <symbol>[,...,<symbolN>]
1220
1221	These all identify global symbols.
1222
1223	.def means the symbol is defined in the current module and can be accessed
1224	by other files. The symbol should be placed in the symbol table.
1225
1226	.ref means the symbol is used in the current module but defined in another
1227	module. The linker is to resolve this symbol's definition at link time.
1228
1229	.global should act as a .ref or .def, as needed.
1230
1231	global, def and ref all have symbol storage classes of C_EXT.
1232
1233	I can't identify any difference in how the "other" c54x assembler treats
1234	these, so we ignore the type here. */
1235
1236	void
1237	tic54x_global (type)
1238	int type;
1239	{
1240	char *name;
1241	int c;
1242	symbolS *symbolP;
1243
1244	if (type == 'r')
1245	as_warn (_("Use of .def/.ref is deprecated. Use .global instead"));
1246
1247	ILLEGAL_WITHIN_STRUCT ();
1248
1249	do
1250	{
1251	name = input_line_pointer;
1252	c = get_symbol_end ();
1253	symbolP = symbol_find_or_make (name);
1254
1255	*input_line_pointer = c;
1256	S_SET_STORAGE_CLASS (symbolP, C_EXT);
1257	if (c == ',')
1258	{
1259	input_line_pointer++;
1260	if (is_end_of_line[(int) *input_line_pointer])
1261	c = *input_line_pointer;
1262	}
1263	}
1264	while (c == ',');
1265
1266	demand_empty_rest_of_line ();
1267	}
1268
1269	/* Remove the symbol from the local label hash lookup. */
1270
1271	static void
1272	tic54x_remove_local_label (key, value)
1273	const char *key;
1274	PTR value ATTRIBUTE_UNUSED;
1275	{
1276	PTR *elem = hash_delete (local_label_hash[macro_level], key);
1277	free (elem);
1278	}
1279
1280	/* Reset all local labels. */
1281
1282	static void
1283	tic54x_clear_local_labels (ignored)
1284	int ignored ATTRIBUTE_UNUSED;
1285	{
1286	hash_traverse (local_label_hash[macro_level], tic54x_remove_local_label);
1287	}
1288
1289	/* .text
1290	.data
1291	.sect "section name"
1292
1293	Initialized section
1294	make sure local labels get cleared when changing sections
1295
1296	ARG is 't' for text, 'd' for data, or '*' for a named section
1297
1298	For compatibility, '*' sections are SEC_CODE if instructions are
1299	encountered, or SEC_DATA if not.
1300	*/
1301
1302	static void
1303	tic54x_sect (arg)
1304	int arg;
1305	{
1306	ILLEGAL_WITHIN_STRUCT ();
1307
1308	/* Local labels are cleared when changing sections. */
1309	tic54x_clear_local_labels (0);
1310
1311	if (arg == 't')
1312	s_text (0);
1313	else if (arg == 'd')
1314	s_data (0);
1315	else
1316	{
1317	char *name = NULL;
1318	int len;
1319
1320	/* If there are quotes, remove them. */
1321	if (*input_line_pointer == '"')
1322	{
1323	name = demand_copy_C_string (&len);
1324	demand_empty_rest_of_line ();
1325	name = strcpy (xmalloc (len + 10), name);
1326	}
1327	else
1328	{
1329	int c;
1330	name = input_line_pointer;
1331	c = get_symbol_end ();
1332	len = strlen(name);
1333	name = strcpy (xmalloc (len + 10), name);
1334	*input_line_pointer = c;
1335	demand_empty_rest_of_line ();
1336	}
1337	/* Make sure all named initialized sections flagged properly. If we
1338	encounter instructions, we'll flag it with SEC_CODE as well. */
1339	strcat (name, ",\"w\"\n");
1340	input_scrub_insert_line (name);
1341	obj_coff_section (0);
1342
1343	/* If there was a line label, make sure that it gets assigned the proper
1344	section. This is for compatibility, even though the actual behavior
1345	is not explicitly defined. For consistency, we make .sect behave
1346	like .usect, since that is probably what people expect. */
1347	if (line_label != NULL)
1348	{
1349	S_SET_SEGMENT (line_label, now_seg);
1350	symbol_set_frag (line_label, frag_now);
1351	S_SET_VALUE (line_label, frag_now_fix ());
1352	if (S_GET_STORAGE_CLASS (line_label) != C_EXT)
1353	S_SET_STORAGE_CLASS (line_label, C_LABEL);
1354	}
1355	}
1356	}
1357
1358	/* [symbol] .space space_in_bits
1359	[symbol] .bes space_in_bits
1360	BES puts the symbol at the last word allocated
1361
1362	cribbed from s_space. */
1363
1364	static void
1365	tic54x_space (arg)
1366	int arg;
1367	{
1368	expressionS exp;
1369	char *p = 0;
1370	int octets = 0;
1371	long words;
1372	int bits_per_byte = (OCTETS_PER_BYTE * 8);
1373	int bit_offset = 0;
1374	symbolS *label = line_label;
1375	int bes = arg;
1376
1377	ILLEGAL_WITHIN_STRUCT ();
1378
1379	#ifdef md_flush_pending_output
1380	md_flush_pending_output ();
1381	#endif
1382
1383	/* Read the bit count. */
1384	expression (&exp);
1385
1386	/* Some expressions are unresolvable until later in the assembly pass;
1387	postpone until relaxation/fixup. we also have to postpone if a previous
1388	partial allocation has not been completed yet. */
1389	if (exp.X_op != O_constant \|\| frag_bit_offset (frag_now, now_seg) == -1)
1390	{
1391	struct bit_info *bi = xmalloc (sizeof (struct bit_info));
1392	char *p;
1393
1394	bi->seg = now_seg;
1395	bi->type = bes;
1396	bi->sym = label;
1397	p = frag_var (rs_machine_dependent,
1398	65536 * 2, 1, (relax_substateT) 0,
1399	make_expr_symbol (&exp), (offsetT) 0,
1400	(char *) bi);
1401	if (p)
1402	*p = 0;
1403
1404	return;
1405	}
1406
1407	/* Reduce the required size by any bit offsets currently left over
1408	from a previous .space/.bes/.field directive. */
1409	bit_offset = frag_now->tc_frag_data;
1410	if (bit_offset != 0 && bit_offset < 16)
1411	{
1412	int spare_bits = bits_per_byte - bit_offset;
1413
1414	if (spare_bits >= exp.X_add_number)
1415	{
1416	/* Don't have to do anything; sufficient bits have already been
1417	allocated; just point the label to the right place. */
1418	if (label != NULL)
1419	{
1420	symbol_set_frag (label, frag_now);
1421	S_SET_VALUE (label, frag_now_fix () - 1);
1422	label = NULL;
1423	}
1424	frag_now->tc_frag_data += exp.X_add_number;
1425	goto getout;
1426	}
1427	exp.X_add_number -= spare_bits;
1428	/* Set the label to point to the first word allocated, which in this
1429	case is the previous word, which was only partially filled. */
1430	if (!bes && label != NULL)
1431	{
1432	symbol_set_frag (label, frag_now);
1433	S_SET_VALUE (label, frag_now_fix () - 1);
1434	label = NULL;
1435	}
1436	}
1437	/* Convert bits to bytes/words and octets, rounding up. */
1438	words = ((exp.X_add_number + bits_per_byte - 1) / bits_per_byte);
1439	/* How many do we have left over? */
1440	bit_offset = exp.X_add_number % bits_per_byte;
1441	octets = words * OCTETS_PER_BYTE;
1442	if (octets < 0)
1443	{
1444	as_warn (_(".space/.bes repeat count is negative, ignored"));
1445	goto getout;
1446	}
1447	else if (octets == 0)
1448	{
1449	as_warn (_(".space/.bes repeat count is zero, ignored"));
1450	goto getout;
1451	}
1452
1453	/* If we are in the absolute section, just bump the offset. */
1454	if (now_seg == absolute_section)
1455	{
1456	abs_section_offset += words;
1457	if (bes && label != NULL)
1458	S_SET_VALUE (label, abs_section_offset - 1);
1459	frag_now->tc_frag_data = bit_offset;
1460	goto getout;
1461	}
1462
1463	if (!need_pass_2)
1464	p = frag_var (rs_fill, 1, 1,
1465	(relax_substateT) 0, (symbolS *) 0,
1466	(offsetT) octets, (char *) 0);
1467
1468	/* Make note of how many bits of this word we've allocated so far. */
1469	frag_now->tc_frag_data = bit_offset;
1470
1471	/* .bes puts label at last word allocated. */
1472	if (bes && label != NULL)
1473	{
1474	symbol_set_frag (label, frag_now);
1475	S_SET_VALUE (label, frag_now_fix () - 1);
1476	}
1477
1478	if (p)
1479	*p = 0;
1480
1481	getout:
1482
1483	demand_empty_rest_of_line ();
1484	}
1485
1486	/* [symbol] .usect "section-name", size-in-words
1487	[, [blocking-flag] [, alignment-flag]]
1488
1489	Unitialized section.
1490	Non-zero blocking means that if the section would cross a page (128-word)
1491	boundary, it will be page-aligned.
1492	Non-zero alignment aligns on a longword boundary.
1493
1494	Has no effect on the current section. */
1495
1496	static void
1497	tic54x_usect (x)
1498	int x ATTRIBUTE_UNUSED;
1499	{
1500	char c;
1501	char *name;
1502	char *section_name;
1503	char *p;
1504	segT seg;
1505	int size, blocking_flag, alignment_flag;
1506	segT current_seg;
1507	subsegT current_subseg;
1508	flagword flags;
1509
1510	ILLEGAL_WITHIN_STRUCT ();
1511
1512	current_seg = now_seg; /* Save current seg. */
1513	current_subseg = now_subseg; /* Save current subseg. */
1514
1515	if (*input_line_pointer == '"')
1516	input_line_pointer++;
1517	section_name = input_line_pointer;
1518	c = get_symbol_end (); /* Get terminator. */
1519	input_line_pointer++; /* Skip null symbol terminator. */
1520	name = xmalloc (input_line_pointer - section_name + 1);
1521	strcpy (name, section_name);
1522
1523	if (*input_line_pointer == ',')
1524	++input_line_pointer;
1525	else if (c != ',')
1526	{
1527	as_bad (_("Missing size argument"));
1528	ignore_rest_of_line ();
1529	return;
1530	}
1531
1532	size = get_absolute_expression ();
1533
1534	/* Read a possibly present third argument (blocking flag). */
1535	if (*input_line_pointer == ',')
1536	{
1537	++input_line_pointer;
1538	if (*input_line_pointer != ',')
1539	blocking_flag = get_absolute_expression ();
1540	else
1541	blocking_flag = 0;
1542
1543	/* Read a possibly present fourth argument (alignment flag). */
1544	if (*input_line_pointer == ',')
1545	{
1546	++input_line_pointer;
1547	alignment_flag = get_absolute_expression ();
1548	}
1549	else
1550	alignment_flag = 0;
1551	}
1552	else
1553	blocking_flag = alignment_flag = 0;
1554
1555	seg = subseg_new (name, 0);
1556	flags = bfd_get_section_flags (stdoutput, seg) \| SEC_ALLOC;
1557
1558	if (alignment_flag)
1559	{
1560	/* s_align eats end of line; restore it. */
1561	s_align_bytes (4);
1562	--input_line_pointer;
1563	}
1564
1565	if (line_label != NULL)
1566	{
1567	S_SET_SEGMENT (line_label, seg);
1568	symbol_set_frag (line_label, frag_now);
1569	S_SET_VALUE (line_label, frag_now_fix ());
1570	/* Set scl to label, since that's what TI does. */
1571	if (S_GET_STORAGE_CLASS (line_label) != C_EXT)
1572	S_SET_STORAGE_CLASS (line_label, C_LABEL);
1573	}
1574
1575	seg_info (seg)->bss = 1; /* Uninitialized data. */
1576
1577	p = frag_var (rs_fill, 1, 1,
1578	(relax_substateT) 0, (symbolS *) line_label,
1579	size * OCTETS_PER_BYTE, (char *) 0);
1580	*p = 0;
1581
1582	if (blocking_flag)
1583	flags \|= SEC_BLOCK;
1584
1585	if (!bfd_set_section_flags (stdoutput, seg, flags))
1586	as_warn ("Error setting flags for \"%s\": %s", name,
1587	bfd_errmsg (bfd_get_error ()));
1588
1589	subseg_set (current_seg, current_subseg); /* Restore current seg. */
1590	demand_empty_rest_of_line ();
1591	}
1592
1593	static enum cpu_version
1594	lookup_version (ver)
1595	const char *ver;
1596	{
1597	enum cpu_version version = VNONE;
1598
1599	if (ver[0] == '5' && ver[1] == '4')
1600	{
1601	if (strlen (ver) == 3
1602	&& (ver[2] == '1' \|\| ver[2] == '2' \|\| ver[2] == '3'
1603	\|\| ver[2] == '5' \|\| ver[2] == '8' \|\| ver[2] == '9'))
1604	version = ver[2] - '0';
1605	else if (strlen (ver) == 5
1606	&& TOUPPER (ver[3]) == 'L'
1607	&& TOUPPER (ver[4]) == 'P'
1608	&& (ver[2] == '5' \|\| ver[2] == '6'))
1609	version = ver[2] - '0' + 10;
1610	}
1611
1612	return version;
1613	}
1614
1615	static void
1616	set_cpu (version)
1617	enum cpu_version version;
1618	{
1619	cpu = version;
1620	if (version == V545LP \|\| version == V546LP)
1621	{
1622	symbolS *symbolP = symbol_new ("__allow_lp", absolute_section,
1623	(valueT) 1, &zero_address_frag);
1624	SF_SET_LOCAL (symbolP);
1625	symbol_table_insert (symbolP);
1626	}
1627	}
1628
1629	/* .version cpu-version
1630	cpu-version may be one of the following:
1631	541
1632	542
1633	543
1634	545
1635	545LP
1636	546LP
1637	548
1638	549
1639
1640	This is for compatibility only. It currently has no affect on assembly. */
1641	static int cpu_needs_set = 1;
1642
1643	static void
1644	tic54x_version (x)
1645	int x ATTRIBUTE_UNUSED;
1646	{
1647	enum cpu_version version = VNONE;
1648	enum cpu_version old_version = cpu;
1649	int c;
1650	char *ver;
1651
1652	ILLEGAL_WITHIN_STRUCT ();
1653
1654	SKIP_WHITESPACE ();
1655	ver = input_line_pointer;
1656	while (!is_end_of_line[(int) *input_line_pointer])
1657	++input_line_pointer;
1658	c = *input_line_pointer;
1659	*input_line_pointer = 0;
1660
1661	version = lookup_version (ver);
1662
1663	if (cpu != VNONE && cpu != version)
1664	as_warn (_("CPU version has already been set"));
1665
1666	if (version == VNONE)
1667	{
1668	as_bad (_("Unrecognized version '%s'"), ver);
1669	ignore_rest_of_line ();
1670	return;
1671	}
1672	else if (assembly_begun && version != old_version)
1673	{
1674	as_bad (_("Changing of CPU version on the fly not supported"));
1675	ignore_rest_of_line ();
1676	return;
1677	}
1678
1679	set_cpu (version);
1680
1681	*input_line_pointer = c;
1682	demand_empty_rest_of_line ();
1683	}
1684
1685	/* 'f' = float, 'x' = xfloat, 'd' = double, 'l' = ldouble. */
1686
1687	static void
1688	tic54x_float_cons (type)
1689	int type;
1690	{
1691	if (current_stag != 0)
1692	tic54x_struct_field ('f');
1693
1694	#ifdef md_flush_pending_output
1695	md_flush_pending_output ();
1696	#endif
1697
1698	/* Align to long word boundary (4 octets) unless it's ".xfloat". */
1699	if (type != 'x')
1700	{
1701	frag_align (2, 0, 2);
1702	/* If there's a label, assign it to the first allocated word. */
1703	if (line_label != NULL)
1704	{
1705	symbol_set_frag (line_label, frag_now);
1706	S_SET_VALUE (line_label, frag_now_fix ());
1707	}
1708	}
1709
1710	float_cons ('f');
1711	}
1712
1713	/* The argument is capitalized if it should be zero-terminated
1714	's' is normal string with upper 8-bits zero-filled, 'p' is packed.
1715	Code copied from stringer, and slightly modified so that strings are packed
1716	and encoded into the correct octets. */
1717
1718	static void
1719	tic54x_stringer (type)
1720	int type;
1721	{
1722	unsigned int c;
1723	char *start;
1724	int append_zero = type == 'S' \|\| type == 'P';
1725	int packed = type == 'p' \|\| type == 'P';
1726	int last_char = -1; /* Packed strings need two bytes at a time to encode. */
1727
1728	if (current_stag != NULL)
1729	{
1730	tic54x_struct_field ('*');
1731	return;
1732	}
1733
1734	#ifdef md_flush_pending_output
1735	md_flush_pending_output ();
1736	#endif
1737
1738	c = ','; /* Do loop. */
1739	while (c == ',')
1740	{
1741	SKIP_WHITESPACE ();
1742	switch (*input_line_pointer)
1743	{
1744	default:
1745	{
1746	unsigned short value = get_absolute_expression ();
1747	FRAG_APPEND_1_CHAR ( value & 0xFF);
1748	FRAG_APPEND_1_CHAR ((value >> 8) & 0xFF);
1749	break;
1750	}
1751	case '\"':
1752	++input_line_pointer; /* -> 1st char of string. */
1753	start = input_line_pointer;
1754	while (is_a_char (c = next_char_of_string ()))
1755	{
1756	if (!packed)
1757	{
1758	FRAG_APPEND_1_CHAR (c);
1759	FRAG_APPEND_1_CHAR (0);
1760	}
1761	else
1762	{
1763	/* Packed strings are filled MS octet first. */
1764	if (last_char == -1)
1765	last_char = c;
1766	else
1767	{
1768	FRAG_APPEND_1_CHAR (c);
1769	FRAG_APPEND_1_CHAR (last_char);
1770	last_char = -1;
1771	}
1772	}
1773	}
1774	if (append_zero)
1775	{
1776	if (packed && last_char != -1)
1777	{
1778	FRAG_APPEND_1_CHAR (0);
1779	FRAG_APPEND_1_CHAR (last_char);
1780	last_char = -1;
1781	}
1782	else
1783	{
1784	FRAG_APPEND_1_CHAR (0);
1785	FRAG_APPEND_1_CHAR (0);
1786	}
1787	}
1788	know (input_line_pointer[-1] == '\"');
1789	break;
1790	}
1791	SKIP_WHITESPACE ();
1792	c = *input_line_pointer;
1793	if (!is_end_of_line[c])
1794	++input_line_pointer;
1795	}
1796
1797	/* Finish up any leftover packed string. */
1798	if (packed && last_char != -1)
1799	{
1800	FRAG_APPEND_1_CHAR (0);
1801	FRAG_APPEND_1_CHAR (last_char);
1802	}
1803	demand_empty_rest_of_line ();
1804	}
1805
1806	static void
1807	tic54x_p2align (arg)
1808	int arg ATTRIBUTE_UNUSED;
1809	{
1810	as_bad (_("p2align not supported on this target"));
1811	}
1812
1813	static void
1814	tic54x_align_words (arg)
1815	int arg;
1816	{
1817	/* Only ".align" with no argument is allowed within .struct/.union. */
1818	int count = arg;
1819
1820	if (!is_end_of_line[(int) *input_line_pointer])
1821	{
1822	if (arg == 2)
1823	as_warn (_("Argument to .even ignored"));
1824	else
1825	count = get_absolute_expression ();
1826	}
1827
1828	if (current_stag != NULL && arg == 128)
1829	{
1830	if (current_stag->current_bitfield_offset != 0)
1831	{
1832	current_stag->current_bitfield_offset = 0;
1833	++abs_section_offset;
1834	}
1835	demand_empty_rest_of_line ();
1836	return;
1837	}
1838
1839	ILLEGAL_WITHIN_STRUCT ();
1840
1841	s_align_bytes (count << 1);
1842	}
1843
1844	/* Initialize multiple-bit fields withing a single word of memory. */
1845
1846	static void
1847	tic54x_field (ignore)
1848	int ignore ATTRIBUTE_UNUSED;
1849	{
1850	expressionS exp;
1851	int size = 16;
1852	char *p;
1853	valueT value;
1854	symbolS *label = line_label;
1855
1856	if (current_stag != NULL)
1857	{
1858	tic54x_struct_field ('.');
1859	return;
1860	}
1861
1862	input_line_pointer = parse_expression (input_line_pointer, &exp);
1863
1864	if (*input_line_pointer == ',')
1865	{
1866	++input_line_pointer;
1867	size = get_absolute_expression ();
1868	if (size < 1 \|\| size > 32)
1869	{
1870	as_bad (_("Invalid field size, must be from 1 to 32"));
1871	ignore_rest_of_line ();
1872	return;
1873	}
1874	}
1875
1876	/* Truncate values to the field width. */
1877	if (exp.X_op != O_constant)
1878	{
1879	/* If the expression value is relocatable, the field size must
1880	be 16. */
1881	if (size != 16)
1882	{
1883	as_bad (_("field size must be 16 when value is relocatable"));
1884	ignore_rest_of_line ();
1885	return;
1886	}
1887
1888	frag_now->tc_frag_data = 0;
1889	emit_expr (&exp, 2);
1890	}
1891	else
1892	{
1893	unsigned long fmask = (size == 32) ? 0xFFFFFFFF : (1ul << size) - 1;
1894
1895	value = exp.X_add_number;
1896	exp.X_add_number &= fmask;
1897	if (value != (valueT) exp.X_add_number)
1898	as_warn (_("field value truncated"));
1899	value = exp.X_add_number;
1900	/* Bits are stored MS first. */
1901	while (size >= 16)
1902	{
1903	frag_now->tc_frag_data = 0;
1904	p = frag_more (2);
1905	md_number_to_chars (p, (value >> (size - 16)) & 0xFFFF, 2);
1906	size -= 16;
1907	}
1908	if (size > 0)
1909	{
1910	int bit_offset = frag_bit_offset (frag_now, now_seg);
1911
1912	fragS *alloc_frag = bit_offset_frag (frag_now, now_seg);
1913	if (bit_offset == -1)
1914	{
1915	struct bit_info *bi = xmalloc (sizeof (struct bit_info));
1916	/* We don't know the previous offset at this time, so store the
1917	info we need and figure it out later. */
1918	expressionS size_exp;
1919
1920	size_exp.X_op = O_constant;
1921	size_exp.X_add_number = size;
1922	bi->seg = now_seg;
1923	bi->type = TYPE_FIELD;
1924	bi->value = value;
1925	p = frag_var (rs_machine_dependent,
1926	4, 1, (relax_substateT) 0,
1927	make_expr_symbol (&size_exp), (offsetT) 0,
1928	(char *) bi);
1929	goto getout;
1930	}
1931	else if (bit_offset == 0 \|\| bit_offset + size > 16)
1932	{
1933	/* Align a new field. */
1934	p = frag_more (2);
1935	frag_now->tc_frag_data = 0;
1936	alloc_frag = frag_now;
1937	}
1938	else
1939	{
1940	/* Put the new value entirely within the existing one. */
1941	p = alloc_frag == frag_now ?
1942	frag_now->fr_literal + frag_now_fix_octets () - 2 :
1943	alloc_frag->fr_literal;
1944	if (label != NULL)
1945	{
1946	symbol_set_frag (label, alloc_frag);
1947	if (alloc_frag == frag_now)
1948	S_SET_VALUE (label, frag_now_fix () - 1);
1949	label = NULL;
1950	}
1951	}
1952	value <<= 16 - alloc_frag->tc_frag_data - size;
1953
1954	/* OR in existing value. */
1955	if (alloc_frag->tc_frag_data)
1956	value \|= ((unsigned short) p[1] << 8) \| p[0];
1957	md_number_to_chars (p, value, 2);
1958	alloc_frag->tc_frag_data += size;
1959	if (alloc_frag->tc_frag_data == 16)
1960	alloc_frag->tc_frag_data = 0;
1961	}
1962	}
1963	getout:
1964	demand_empty_rest_of_line ();
1965	}
1966
1967	/* Ideally, we want to check SEC_LOAD and SEC_HAS_CONTENTS, but those aren't
1968	available yet. seg_info ()->bss is the next best thing. */
1969
1970	static int
1971	tic54x_initialized_section (seg)
1972	segT seg;
1973	{
1974	return !seg_info (seg)->bss;
1975	}
1976
1977	/* .clink ["section name"]
1978
1979	Marks the section as conditionally linked (link only if contents are
1980	referenced elsewhere.
1981	Without a name, refers to the current initialized section.
1982	Name is required for uninitialized sections. */
1983
1984	static void
1985	tic54x_clink (ignored)
1986	int ignored ATTRIBUTE_UNUSED;
1987	{
1988	segT seg = now_seg;
1989
1990	ILLEGAL_WITHIN_STRUCT ();
1991
1992	if (*input_line_pointer == '\"')
1993	{
1994	char *section_name = ++input_line_pointer;
1995	char *name;
1996
1997	while (is_a_char (next_char_of_string ()))
1998	;
1999	know (input_line_pointer[-1] == '\"');
2000	input_line_pointer[-1] = 0;
2001	name = xmalloc (input_line_pointer - section_name + 1);
2002	strcpy (name, section_name);
2003
2004	seg = bfd_get_section_by_name (stdoutput, name);
2005	if (seg == NULL)
2006	{
2007	as_bad (_("Unrecognized section '%s'"), section_name);
2008	ignore_rest_of_line ();
2009	return;
2010	}
2011	}
2012	else
2013	{
2014	if (!tic54x_initialized_section (seg))
2015	{
2016	as_bad (_("Current section is unitialized, "
2017	"section name required for .clink"));
2018	ignore_rest_of_line ();
2019	return;
2020	}
2021	}
2022
2023	seg->flags \|= SEC_CLINK;
2024
2025	demand_empty_rest_of_line ();
2026	}
2027
2028	/* Change the default include directory to be the current source file's
2029	directory, instead of the current working directory. If DOT is non-zero,
2030	set to "." instead. */
2031
2032	static void
2033	tic54x_set_default_include (dot)
2034	int dot;
2035	{
2036	char *dir = ".";
2037	char *tmp = NULL;
2038
2039	if (!dot)
2040	{
2041	char *curfile;
2042	unsigned lineno;
2043
2044	as_where (&curfile, &lineno);
2045	dir = strcpy (xmalloc (strlen (curfile) + 1), curfile);
2046	tmp = strrchr (dir, '/');
2047	}
2048	if (tmp != NULL)
2049	{
2050	int len;
2051
2052	*tmp = '\0';
2053	len = strlen (dir);
2054	if (include_dir_count == 0)
2055	{
2056	include_dirs = (char *) xmalloc (sizeof (include_dirs));
2057	include_dir_count = 1;
2058	}
2059	include_dirs[0] = dir;
2060	if (len > include_dir_maxlen)
2061	include_dir_maxlen = len;
2062	}
2063	else if (include_dirs != NULL)
2064	include_dirs[0] = ".";
2065	}
2066
2067	/* .include "filename" \| filename
2068	.copy "filename" \| filename
2069
2070	FIXME 'include' file should be omitted from any output listing,
2071	'copy' should be included in any output listing
2072	FIXME -- prevent any included files from changing listing (compat only)
2073	FIXME -- need to include source file directory in search path; what's a
2074	good way to do this?
2075
2076	Entering/exiting included/copied file clears all local labels. */
2077
2078	static void
2079	tic54x_include (ignored)
2080	int ignored ATTRIBUTE_UNUSED;
2081	{
2082	char newblock[] = " .newblock\n";
2083	char *filename;
2084	char *input;
2085	int len, c = -1;
2086
2087	ILLEGAL_WITHIN_STRUCT ();
2088
2089	SKIP_WHITESPACE ();
2090
2091	if (*input_line_pointer == '"')
2092	{
2093	filename = demand_copy_C_string (&len);
2094	demand_empty_rest_of_line ();
2095	}
2096	else
2097	{
2098	filename = input_line_pointer;
2099	while (!is_end_of_line[(int) *input_line_pointer])
2100	++input_line_pointer;
2101	c = *input_line_pointer;
2102	*input_line_pointer = '\0';
2103	filename = strcpy (xmalloc (strlen (filename) + 1), filename);
2104	*input_line_pointer = c;
2105	demand_empty_rest_of_line ();
2106	}
2107	/* Insert a partial line with the filename (for the sake of s_include)
2108	and a .newblock.
2109	The included file will be inserted before the newblock, so that the
2110	newblock is executed after the included file is processed. */
2111	input = xmalloc (sizeof (newblock) + strlen (filename) + 4);
2112	sprintf (input, "\"%s\"\n%s", filename, newblock);
2113	input_scrub_insert_line (input);
2114
2115	tic54x_clear_local_labels (0);
2116
2117	tic54x_set_default_include (0);
2118
2119	s_include (0);
2120	}
2121
2122	static void
2123	tic54x_message (type)
2124	int type;
2125	{
2126	char *msg;
2127	char c;
2128	int len;
2129
2130	ILLEGAL_WITHIN_STRUCT ();
2131
2132	if (*input_line_pointer == '"')
2133	msg = demand_copy_C_string (&len);
2134	else
2135	{
2136	msg = input_line_pointer;
2137	while (!is_end_of_line[(int) *input_line_pointer])
2138	++input_line_pointer;
2139	c = *input_line_pointer;
2140	*input_line_pointer = 0;
2141	msg = strcpy (xmalloc (strlen (msg) + 1), msg);
2142	*input_line_pointer = c;
2143	}
2144
2145	switch (type)
2146	{
2147	case 'm':
2148	as_tsktsk ("%s", msg);
2149	break;
2150	case 'w':
2151	as_warn ("%s", msg);
2152	break;
2153	case 'e':
2154	as_bad ("%s", msg);
2155	break;
2156	}
2157
2158	demand_empty_rest_of_line ();
2159	}
2160
2161	/* .label <symbol>
2162	Define a special symbol that refers to the loadtime address rather than the
2163	runtime address within the current section.
2164
2165	This symbol gets a special storage class so that when it is resolved, it is
2166	resolved relative to the load address (lma) of the section rather than the
2167	run address (vma). */
2168
2169	static void
2170	tic54x_label (ignored)
2171	int ignored ATTRIBUTE_UNUSED;
2172	{
2173	char *name = input_line_pointer;
2174	symbolS *symbolP;
2175	int c;
2176
2177	ILLEGAL_WITHIN_STRUCT ();
2178
2179	c = get_symbol_end ();
2180	symbolP = colon (name);
2181	S_SET_STORAGE_CLASS (symbolP, C_STATLAB);
2182
2183	*input_line_pointer = c;
2184	demand_empty_rest_of_line ();
2185	}
2186
2187	/* .mmregs
2188	Install all memory-mapped register names into the symbol table as
2189	absolute local symbols. */
2190
2191	static void
2192	tic54x_mmregs (ignored)
2193	int ignored ATTRIBUTE_UNUSED;
2194	{
2195	symbol *sym;
2196
2197	ILLEGAL_WITHIN_STRUCT ();
2198
2199	for (sym = (symbol *) mmregs; sym->name; sym++)
2200	{
2201	symbolS *symbolP = symbol_new (sym->name, absolute_section,
2202	(valueT) sym->value, &zero_address_frag);
2203	SF_SET_LOCAL (symbolP);
2204	symbol_table_insert (symbolP);
2205	}
2206	}
2207
2208	/* .loop [count]
2209	Count defaults to 1024. */
2210
2211	static void
2212	tic54x_loop (count)
2213	int count;
2214	{
2215	ILLEGAL_WITHIN_STRUCT ();
2216
2217	SKIP_WHITESPACE ();
2218	if (!is_end_of_line[(int) *input_line_pointer])
2219	count = get_absolute_expression ();
2220
2221	do_repeat (count, "LOOP", "ENDLOOP");
2222	}
2223
2224	/* Normally, endloop gets eaten by the preceding loop. */
2225
2226	static void
2227	tic54x_endloop (ignore)
2228	int ignore ATTRIBUTE_UNUSED;
2229	{
2230	as_bad (_("ENDLOOP without corresponding LOOP"));
2231	ignore_rest_of_line ();
2232	}
2233
2234	/* .break [condition]. */
2235
2236	static void
2237	tic54x_break (ignore)
2238	int ignore ATTRIBUTE_UNUSED;
2239	{
2240	int cond = 1;
2241
2242	ILLEGAL_WITHIN_STRUCT ();
2243
2244	SKIP_WHITESPACE ();
2245	if (!is_end_of_line[(int) *input_line_pointer])
2246	cond = get_absolute_expression ();
2247
2248	if (cond)
2249	end_repeat (substitution_line ? 1 : 0);
2250	}
2251
2252	static void
2253	set_address_mode (mode)
2254	int mode;
2255	{
2256	amode = mode;
2257	if (mode == far_mode)
2258	{
2259	symbolS *symbolP = symbol_new ("__allow_far", absolute_section,
2260	(valueT) 1, &zero_address_frag);
2261	SF_SET_LOCAL (symbolP);
2262	symbol_table_insert (symbolP);
2263	}
2264	}
2265
2266	static int address_mode_needs_set = 1;
2267
2268	static void
2269	tic54x_address_mode (mode)
2270	int mode;
2271	{
2272	if (assembly_begun && amode != (unsigned) mode)
2273	{
2274	as_bad (_("Mixing of normal and extended addressing not supported"));
2275	ignore_rest_of_line ();
2276	return;
2277	}
2278	if (mode == far_mode && cpu != VNONE && cpu != V548 && cpu != V549)
2279	{
2280	as_bad (_("Extended addressing not supported on the specified CPU"));
2281	ignore_rest_of_line ();
2282	return;
2283	}
2284
2285	set_address_mode (mode);
2286	demand_empty_rest_of_line ();
2287	}
2288
2289	/* .sblock "section"\|section [,...,"section"\|section]
2290	Designate initialized sections for blocking. */
2291
2292	static void
2293	tic54x_sblock (ignore)
2294	int ignore ATTRIBUTE_UNUSED;
2295	{
2296	int c = ',';
2297
2298	ILLEGAL_WITHIN_STRUCT ();
2299
2300	while (c == ',')
2301	{
2302	segT seg;
2303	char *name;
2304
2305	if (*input_line_pointer == '"')
2306	{
2307	int len;
2308
2309	name = demand_copy_C_string (&len);
2310	}
2311	else
2312	{
2313	char *section_name = input_line_pointer;
2314
2315	c = get_symbol_end ();
2316	name = xmalloc (strlen (section_name) + 1);
2317	strcpy (name, section_name);
2318	*input_line_pointer = c;
2319	}
2320
2321	seg = bfd_get_section_by_name (stdoutput, name);
2322	if (seg == NULL)
2323	{
2324	as_bad (_("Unrecognized section '%s'"), name);
2325	ignore_rest_of_line ();
2326	return;
2327	}
2328	else if (!tic54x_initialized_section (seg))
2329	{
2330	as_bad (_(".sblock may be used for initialized sections only"));
2331	ignore_rest_of_line ();
2332	return;
2333	}
2334	seg->flags \|= SEC_BLOCK;
2335
2336	c = *input_line_pointer;
2337	if (!is_end_of_line[(int) c])
2338	++input_line_pointer;
2339	}
2340
2341	demand_empty_rest_of_line ();
2342	}
2343
2344	/* symbol .set value
2345	symbol .equ value
2346
2347	value must be defined externals; no forward-referencing allowed
2348	symbols assigned with .set/.equ may not be redefined. */
2349
2350	static void
2351	tic54x_set (ignore)
2352	int ignore ATTRIBUTE_UNUSED;
2353	{
2354	symbolS *symbolP;
2355	char *name;
2356
2357	ILLEGAL_WITHIN_STRUCT ();
2358
2359	if (!line_label)
2360	{
2361	as_bad (_("Symbol missing for .set/.equ"));
2362	ignore_rest_of_line ();
2363	return;
2364	}
2365	name = xstrdup (S_GET_NAME (line_label));
2366	line_label = NULL;
2367	if ((symbolP = symbol_find (name)) == NULL
2368	&& (symbolP = md_undefined_symbol (name)) == NULL)
2369	{
2370	symbolP = symbol_new (name, absolute_section, 0, &zero_address_frag);
2371	S_SET_STORAGE_CLASS (symbolP, C_STAT);
2372	}
2373	free (name);
2374	S_SET_DATA_TYPE (symbolP, T_INT);
2375	S_SET_SEGMENT (symbolP, absolute_section);
2376	symbol_table_insert (symbolP);
2377	pseudo_set (symbolP);
2378	demand_empty_rest_of_line ();
2379	}
2380
2381	/* .fclist
2382	.fcnolist
2383	List false conditional blocks. */
2384
2385	static void
2386	tic54x_fclist (show)
2387	int show;
2388	{
2389	if (show)
2390	listing &= ~LISTING_NOCOND;
2391	else
2392	listing \|= LISTING_NOCOND;
2393	demand_empty_rest_of_line ();
2394	}
2395
2396	static void
2397	tic54x_sslist (show)
2398	int show;
2399	{
2400	ILLEGAL_WITHIN_STRUCT ();
2401
2402	listing_sslist = show;
2403	}
2404
2405	/* .var SYM[,...,SYMN]
2406	Define a substitution string to be local to a macro. */
2407
2408	static void
2409	tic54x_var (ignore)
2410	int ignore ATTRIBUTE_UNUSED;
2411	{
2412	static char empty[] = "";
2413	char *name;
2414	int c;
2415
2416	ILLEGAL_WITHIN_STRUCT ();
2417
2418	if (macro_level == 0)
2419	{
2420	as_bad (_(".var may only be used within a macro definition"));
2421	ignore_rest_of_line ();
2422	return;
2423	}
2424	do
2425	{
2426	if (!ISALPHA (*input_line_pointer))
2427	{
2428	as_bad (_("Substitution symbols must begin with a letter"));
2429	ignore_rest_of_line ();
2430	return;
2431	}
2432	name = input_line_pointer;
2433	c = get_symbol_end ();
2434	/* .var symbols start out with a null string. */
2435	name = strcpy (xmalloc (strlen (name) + 1), name);
2436	hash_insert (subsym_hash[macro_level], name, empty);
2437	*input_line_pointer = c;
2438	if (c == ',')
2439	{
2440	++input_line_pointer;
2441	if (is_end_of_line[(int) *input_line_pointer])
2442	c = *input_line_pointer;
2443	}
2444	}
2445	while (c == ',');
2446
2447	demand_empty_rest_of_line ();
2448	}
2449
2450	/* .mlib <macro library filename>
2451
2452	Macro libraries are archived (standard AR-format) text macro definitions
2453	Expand the file and include it.
2454
2455	FIXME need to try the source file directory as well. */
2456
2457	static void
2458	tic54x_mlib (ignore)
2459	int ignore ATTRIBUTE_UNUSED;
2460	{
2461	char *filename;
2462	char *path;
2463	int len, i;
2464	bfd abfd, mbfd;
2465
2466	ILLEGAL_WITHIN_STRUCT ();
2467
2468	/* Parse the filename. */
2469	if (*input_line_pointer == '"')
2470	{
2471	if ((filename = demand_copy_C_string (&len)) == NULL)
2472	return;
2473	}
2474	else
2475	{
2476	SKIP_WHITESPACE ();
2477	len = 0;
2478	while (!is_end_of_line[(int) *input_line_pointer]
2479	&& !ISSPACE (*input_line_pointer))
2480	{
2481	obstack_1grow (&notes, *input_line_pointer);
2482	++input_line_pointer;
2483	++len;
2484	}
2485	obstack_1grow (&notes, '\0');
2486	filename = obstack_finish (&notes);
2487	}
2488	demand_empty_rest_of_line ();
2489
2490	tic54x_set_default_include (0);
2491	path = xmalloc ((unsigned long) len + include_dir_maxlen + 5);
2492
2493	for (i = 0; i < include_dir_count; i++)
2494	{
2495	FILE *try;
2496
2497	strcpy (path, include_dirs[i]);
2498	strcat (path, "/");
2499	strcat (path, filename);
2500	if ((try = fopen (path, "r")) != NULL)
2501	{
2502	fclose (try);
2503	break;
2504	}
2505	}
2506
2507	if (i >= include_dir_count)
2508	{
2509	free (path);
2510	path = filename;
2511	}
2512
2513	/* FIXME: if path is found, malloc'd storage is not freed. Of course, this
2514	happens all over the place, and since the assembler doesn't usually keep
2515	running for a very long time, it really doesn't matter. */
2516	register_dependency (path);
2517
2518	/* Expand all archive entries to temporary files and include them. */
2519	abfd = bfd_openr (path, NULL);
2520	if (!abfd)
2521	{
2522	as_bad (_("Can't open macro library file '%s' for reading."), path);
2523	as_perror ("%s", path);
2524	ignore_rest_of_line ();
2525	return;
2526	}
2527	if (!bfd_check_format (abfd, bfd_archive))
2528	{
2529	as_bad (_("File '%s' not in macro archive format"), path);
2530	ignore_rest_of_line ();
2531	return;
2532	}
2533
2534	/* Open each BFD as binary (it should be straight ASCII text). */
2535	for (mbfd = bfd_openr_next_archived_file (abfd, NULL);
2536	mbfd != NULL; mbfd = bfd_openr_next_archived_file (abfd, mbfd))
2537	{
2538	/* Get a size at least as big as the archive member. */
2539	bfd_size_type size = bfd_get_size (mbfd);
2540	char *buf = xmalloc (size);
2541	char *fname = tmpnam (NULL);
2542	FILE *ftmp;
2543
2544	/* We're not sure how big it is, but it will be smaller than "size". */
2545	bfd_bread (buf, size, mbfd);
2546
2547	/* Write to a temporary file, then use s_include to include it
2548	a bit of a hack. */
2549	ftmp = fopen (fname, "w+b");
2550	fwrite ((void *) buf, size, 1, ftmp);
2551	if (buf[size - 1] != '\n')
2552	fwrite ("\n", 1, 1, ftmp);
2553	fclose (ftmp);
2554	free (buf);
2555	input_scrub_insert_file (fname);
2556	unlink (fname);
2557	}
2558	}
2559
2560	const pseudo_typeS md_pseudo_table[] =
2561	{
2562	{ "algebraic", s_ignore , 0 },
2563	{ "align" , tic54x_align_words , 128 },
2564	{ "ascii" , tic54x_stringer , 'p' },
2565	{ "asciz" , tic54x_stringer , 'P' },
2566	{ "even" , tic54x_align_words , 2 },
2567	{ "asg" , tic54x_asg , 0 },
2568	{ "eval" , tic54x_eval , 0 },
2569	{ "bss" , tic54x_bss , 0 },
2570	{ "byte" , tic54x_cons , 'b' },
2571	{ "ubyte" , tic54x_cons , 'B' },
2572	{ "char" , tic54x_cons , 'c' },
2573	{ "uchar" , tic54x_cons , 'C' },
2574	{ "clink" , tic54x_clink , 0 },
2575	{ "c_mode" , tic54x_address_mode , c_mode },
2576	{ "copy" , tic54x_include , 'c' },
2577	{ "include" , tic54x_include , 'i' },
2578	{ "data" , tic54x_sect , 'd' },
2579	{ "double" , tic54x_float_cons , 'd' },
2580	{ "ldouble" , tic54x_float_cons , 'l' },
2581	{ "drlist" , s_ignore , 0 },
2582	{ "drnolist" , s_ignore , 0 },
2583	{ "emsg" , tic54x_message , 'e' },
2584	{ "mmsg" , tic54x_message , 'm' },
2585	{ "wmsg" , tic54x_message , 'w' },
2586	#if 0
2587	{ "end" , s_end , 0 },
2588	#endif
2589	{ "far_mode" , tic54x_address_mode , far_mode },
2590	{ "fclist" , tic54x_fclist , 1 },
2591	{ "fcnolist" , tic54x_fclist , 0 },
2592	{ "field" , tic54x_field , -1 },
2593	{ "float" , tic54x_float_cons , 'f' },
2594	{ "xfloat" , tic54x_float_cons , 'x' },
2595	{ "global" , tic54x_global , 'g' },
2596	{ "def" , tic54x_global , 'd' },
2597	{ "ref" , tic54x_global , 'r' },
2598	{ "half" , tic54x_cons , 'h' },
2599	{ "uhalf" , tic54x_cons , 'H' },
2600	{ "short" , tic54x_cons , 's' },
2601	{ "ushort" , tic54x_cons , 'S' },
2602	{ "if" , s_if , (int) O_ne },
2603	{ "elseif" , s_elseif , (int) O_ne },
2604	{ "else" , s_else , 0 },
2605	{ "endif" , s_endif , 0 },
2606	{ "int" , tic54x_cons , 'i' },
2607	{ "uint" , tic54x_cons , 'I' },
2608	{ "word" , tic54x_cons , 'w' },
2609	{ "uword" , tic54x_cons , 'W' },
2610	{ "label" , tic54x_label , 0 }, /* Loadtime
2611	address. */
2612	{ "length" , s_ignore , 0 },
2613	{ "width" , s_ignore , 0 },
2614	#if 0
2615	{ "list" , listing_list , 1 },
2616	{ "nolist" , listing_list , 0 },
2617	#endif
2618	{ "long" , tic54x_cons , 'l' },
2619	{ "ulong" , tic54x_cons , 'L' },
2620	{ "xlong" , tic54x_cons , 'x' },
2621	{ "loop" , tic54x_loop , 1024 },
2622	{ "break" , tic54x_break , 0 },
2623	{ "endloop" , tic54x_endloop , 0 },
2624	{ "mlib" , tic54x_mlib , 0 },
2625	{ "mlist" , s_ignore , 0 },
2626	{ "mnolist" , s_ignore , 0 },
2627	{ "mmregs" , tic54x_mmregs , 0 },
2628	{ "newblock" , tic54x_clear_local_labels, 0 },
2629	{ "option" , s_ignore , 0 },
2630	{ "p2align" , tic54x_p2align , 0 },
2631	#if 0
2632	{ "page" , listing_eject , 0 },
2633	#endif
2634	{ "sblock" , tic54x_sblock , 0 },
2635	{ "sect" , tic54x_sect , '*' },
2636	{ "set" , tic54x_set , 0 },
2637	{ "equ" , tic54x_set , 0 },
2638	{ "space" , tic54x_space , 0 },
2639	{ "bes" , tic54x_space , 1 },
2640	{ "sslist" , tic54x_sslist , 1 },
2641	{ "ssnolist" , tic54x_sslist , 0 },
2642	{ "string" , tic54x_stringer , 's' },
2643	{ "pstring" , tic54x_stringer , 'p' },
2644	{ "struct" , tic54x_struct , 0 },
2645	{ "tag" , tic54x_tag , 0 },
2646	{ "endstruct", tic54x_endstruct , 0 },
2647	{ "tab" , s_ignore , 0 },
2648	{ "text" , tic54x_sect , 't' },
2649	#if 0
2650	{ "title" , listing_title , 0 },
2651	#endif
2652	{ "union" , tic54x_struct , 1 },
2653	{ "endunion" , tic54x_endstruct , 1 },
2654	{ "usect" , tic54x_usect , 0 },
2655	{ "var" , tic54x_var , 0 },
2656	{ "version" , tic54x_version , 0 },
2657	{0 , 0 , 0 }
2658	};
2659
2660	#if 0
2661	/* For debugging, strings for each operand type. */
2662	static const char *optypes[] =
2663	{
2664	"none", "Xmem", "Ymem", "pmad", "dmad", "Smem", "Lmem", "MMR", "PA",
2665	"Sind", "xpmad", "xpmad+", "MMRX", "MMRY",
2666	"SRC1", "SRC", "RND", "DST",
2667	"ARX",
2668	"SHIFT", "SHFT",
2669	"B", "A", "lk", "TS", "k8", "16", "BITC", "CC", "CC2", "CC3", "123", "031",
2670	"k5", "k8u", "ASM", "T", "DP", "ARP", "k3", "lku", "N", "SBIT", "12",
2671	"k9", "TRN",
2672	};
2673	#endif
2674
2675	int
2676	md_parse_option (c, arg)
2677	int c;
2678	char *arg;
2679	{
2680	switch (c)
2681	{
2682	default:
2683	return 0;
2684	case OPTION_COFF_VERSION:
2685	{
2686	int version = atoi (arg);
2687
2688	if (version != 0 && version != 1 && version != 2)
2689	as_fatal (_("Bad COFF version '%s'"), arg);
2690	/* FIXME -- not yet implemented. */
2691	break;
2692	}
2693	case OPTION_CPU_VERSION:
2694	{
2695	cpu = lookup_version (arg);
2696	cpu_needs_set = 1;
2697	if (cpu == VNONE)
2698	as_fatal (_("Bad CPU version '%s'"), arg);
2699	break;
2700	}
2701	case OPTION_ADDRESS_MODE:
2702	amode = far_mode;
2703	address_mode_needs_set = 1;
2704	break;
2705	case OPTION_STDERR_TO_FILE:
2706	{
2707	char *filename = arg;
2708	FILE *fp = fopen (filename, "w+");
2709
2710	if (fp == NULL)
2711	as_fatal (_("Can't redirect stderr to the file '%s'"), filename);
2712	fclose (fp);
2713	if ((fp = freopen (filename, "w+", stderr)) == NULL)
2714	as_fatal (_("Can't redirect stderr to the file '%s'"), filename);
2715	break;
2716	}
2717	}
2718
2719	return 1;
2720	}
2721
2722	/* Create a "local" substitution string hash table for a new macro level
2723	Some docs imply that macros have to use .newblock in order to be able
2724	to re-use a local label. We effectively do an automatic .newblock by
2725	deleting the local label hash between macro invocations. */
2726
2727	void
2728	tic54x_macro_start ()
2729	{
2730	++macro_level;
2731	subsym_hash[macro_level] = hash_new ();
2732	local_label_hash[macro_level] = hash_new ();
2733	}
2734
2735	void
2736	tic54x_macro_info (info)
2737	void *info;
2738	{
2739	struct formal_struct
2740	{
2741	struct formal_struct next; / Next formal in list */
2742	sb name; /* Name of the formal */
2743	sb def; /* The default value */
2744	sb actual; /* The actual argument (changed on
2745	each expansion) */
2746	int index; /* The index of the formal
2747	0 .. formal_count - 1 */
2748	} *entry;
2749	struct macro_struct
2750	{
2751	sb sub; /* Substitution text. */
2752	int formal_count; /* Number of formal args. */
2753	struct formal_struct formals; / Pointer to list of
2754	formal_structs. */
2755	struct hash_control formal_hash; / Hash table of formals. */
2756	} *macro;
2757
2758	macro = (struct macro_struct *) info;
2759
2760	/* Put the formal args into the substitution symbol table. */
2761	for (entry = macro->formals; entry; entry = entry->next)
2762	{
2763	char *name = strncpy (xmalloc (entry->name.len + 1),
2764	entry->name.ptr, entry->name.len);
2765	char *value = strncpy (xmalloc (entry->actual.len + 1),
2766	entry->actual.ptr, entry->actual.len);
2767
2768	name[entry->name.len] = '\0';
2769	value[entry->actual.len] = '\0';
2770	hash_insert (subsym_hash[macro_level], name, value);
2771	}
2772	}
2773
2774	/* Get rid of this macro's .var's, arguments, and local labels. */
2775
2776	void
2777	tic54x_macro_end ()
2778	{
2779	hash_die (subsym_hash[macro_level]);
2780	subsym_hash[macro_level] = NULL;
2781	hash_die (local_label_hash[macro_level]);
2782	local_label_hash[macro_level] = NULL;
2783	--macro_level;
2784	}
2785
2786	static int
2787	subsym_symlen (a, ignore)
2788	char *a;
2789	char *ignore ATTRIBUTE_UNUSED;
2790	{
2791	return strlen (a);
2792	}
2793
2794	/* Compare symbol A to string B. */
2795
2796	static int
2797	subsym_symcmp (a, b)
2798	char *a;
2799	char *b;
2800	{
2801	return strcmp (a, b);
2802	}
2803
2804	/* Return the index of the first occurence of B in A, or zero if none
2805	assumes b is an integer char value as a string. Index is one-based. */
2806
2807	static int
2808	subsym_firstch (a, b)
2809	char *a;
2810	char *b;
2811	{
2812	int val = atoi (b);
2813	char *tmp = strchr (a, val);
2814
2815	return tmp ? tmp - a + 1 : 0;
2816	}
2817
2818	/* Similar to firstch, but returns index of last occurrence of B in A. */
2819
2820	static int
2821	subsym_lastch (a, b)
2822	char *a;
2823	char *b;
2824	{
2825	int val = atoi (b);
2826	char *tmp = strrchr (a, val);
2827
2828	return tmp ? tmp - a + 1 : 0;
2829	}
2830
2831	/* Returns 1 if string A is defined in the symbol table (NOT the substitution
2832	symbol table). */
2833
2834	static int
2835	subsym_isdefed (a, ignore)
2836	char *a;
2837	char *ignore ATTRIBUTE_UNUSED;
2838	{
2839	symbolS *symbolP = symbol_find (a);
2840
2841	return symbolP != NULL;
2842	}
2843
2844	/* Assign first member of comma-separated list B (e.g. "1,2,3") to the symbol
2845	A, or zero if B is a null string. Both arguments must be substitution
2846	symbols, unsubstituted. */
2847
2848	static int
2849	subsym_ismember (sym, list)
2850	char *sym;
2851	char *list;
2852	{
2853	char elem, ptr, *listv;
2854
2855	if (!list)
2856	return 0;
2857
2858	listv = subsym_lookup (list, macro_level);
2859	if (!listv)
2860	{
2861	as_bad (_("Undefined substitution symbol '%s'"), list);
2862	ignore_rest_of_line ();
2863	return 0;
2864	}
2865
2866	ptr = elem = xmalloc (strlen (listv) + 1);
2867	strcpy (elem, listv);
2868	while (ptr && ptr != ',')
2869	++ptr;
2870	*ptr++ = 0;
2871
2872	subsym_create_or_replace (sym, elem);
2873
2874	/* Reassign the list. */
2875	subsym_create_or_replace (list, ptr);
2876
2877	/* Assume this value, docs aren't clear. */
2878	return *list != 0;
2879	}
2880
2881	/* Return zero if not a constant; otherwise:
2882	1 if binary
2883	2 if octal
2884	3 if hexadecimal
2885	4 if character
2886	5 if decimal. */
2887
2888	static int
2889	subsym_iscons (a, ignore)
2890	char *a;
2891	char *ignore ATTRIBUTE_UNUSED;
2892	{
2893	expressionS exp;
2894
2895	parse_expression (a, &exp);
2896
2897	if (exp.X_op == O_constant)
2898	{
2899	int len = strlen (a);
2900
2901	switch (TOUPPER (a[len - 1]))
2902	{
2903	case 'B':
2904	return 1;
2905	case 'Q':
2906	return 2;
2907	case 'H':
2908	return 3;
2909	case '\'':
2910	return 4;
2911	default:
2912	break;
2913	}
2914	/* No suffix; either octal, hex, or decimal. */
2915	if (*a == '0' && len > 1)
2916	{
2917	if (TOUPPER (a[1]) == 'X')
2918	return 3;
2919	return 2;
2920	}
2921	return 5;
2922	}
2923
2924	return 0;
2925	}
2926
2927	/* Return 1 if A is a valid symbol name. Expects string input. */
2928
2929	static int
2930	subsym_isname (a, ignore)
2931	char *a;
2932	char *ignore ATTRIBUTE_UNUSED;
2933	{
2934	if (!is_name_beginner (*a))
2935	return 0;
2936	while (*a)
2937	{
2938	if (!is_part_of_name (*a))
2939	return 0;
2940	++a;
2941	}
2942	return 1;
2943	}
2944
2945	/* Return whether the string is a register; accepts ar0-7, unless .mmregs has
2946	been seen; if so, recognize any memory-mapped register.
2947	Note this does not recognize "A" or "B" accumulators. */
2948
2949	static int
2950	subsym_isreg (a, ignore)
2951	char *a;
2952	char *ignore ATTRIBUTE_UNUSED;
2953	{
2954	if (hash_find (reg_hash, a))
2955	return 1;
2956	if (hash_find (mmreg_hash, a))
2957	return 1;
2958	return 0;
2959	}
2960
2961	/* Return the structrure size, given the stag. */
2962
2963	static int
2964	subsym_structsz (name, ignore)
2965	char *name;
2966	char *ignore ATTRIBUTE_UNUSED;
2967	{
2968	struct stag stag = (struct stag ) hash_find (stag_hash, name);
2969
2970	if (stag)
2971	return stag->size;
2972
2973	return 0;
2974	}
2975
2976	/* If anybody actually uses this, they can fix it :)
2977	FIXME I'm not sure what the "reference point" of a structure is. It might
2978	be either the initial offset given .struct, or it may be the offset of the
2979	structure within another structure, or it might be something else
2980	altogether. since the TI assembler doesn't seem to ever do anything but
2981	return zero, we punt and return zero. */
2982
2983	static int
2984	subsym_structacc (stag_name, ignore)
2985	char *stag_name ATTRIBUTE_UNUSED;
2986	char *ignore ATTRIBUTE_UNUSED;
2987	{
2988	return 0;
2989	}
2990
2991	static float
2992	math_ceil (arg1, ignore)
2993	float arg1;
2994	float ignore ATTRIBUTE_UNUSED;
2995	{
2996	return (float) ceil (arg1);
2997	}
2998
2999	static float
3000	math_cvi (arg1, ignore)
3001	float arg1;
3002	float ignore ATTRIBUTE_UNUSED;
3003	{
3004	return (int) arg1;
3005	}
3006
3007	static float
3008	math_floor (arg1, ignore)
3009	float arg1;
3010	float ignore ATTRIBUTE_UNUSED;
3011	{
3012	return (float) floor (arg1);
3013	}
3014
3015	static float
3016	math_fmod (arg1, arg2)
3017	float arg1;
3018	float arg2;
3019	{
3020	return (int) arg1 % (int) arg2;
3021	}
3022
3023	static float
3024	math_int (arg1, ignore)
3025	float arg1;
3026	float ignore ATTRIBUTE_UNUSED;
3027	{
3028	return ((float) ((int) arg1)) == arg1;
3029	}
3030
3031	static float
3032	math_round (arg1, ignore)
3033	float arg1;
3034	float ignore ATTRIBUTE_UNUSED;
3035	{
3036	return arg1 > 0 ? (int) (arg1 + 0.5) : (int) (arg1 - 0.5);
3037	}
3038
3039	static float
3040	math_sgn (arg1, ignore)
3041	float arg1;
3042	float ignore ATTRIBUTE_UNUSED;
3043	{
3044	return (arg1 < 0) ? -1 : (arg1 ? 1 : 0);
3045	}
3046
3047	static float
3048	math_trunc (arg1, ignore)
3049	float arg1;
3050	float ignore ATTRIBUTE_UNUSED;
3051	{
3052	return (int) arg1;
3053	}
3054
3055	static float
3056	math_acos (arg1, ignore)
3057	float arg1;
3058	float ignore ATTRIBUTE_UNUSED;
3059	{
3060	return (float) acos (arg1);
3061	}
3062
3063	static float
3064	math_asin (arg1, ignore)
3065	float arg1;
3066	float ignore ATTRIBUTE_UNUSED;
3067	{
3068	return (float) asin (arg1);
3069	}
3070
3071	static float
3072	math_atan (arg1, ignore)
3073	float arg1;
3074	float ignore ATTRIBUTE_UNUSED;
3075	{
3076	return (float) atan (arg1);
3077	}
3078
3079	static float
3080	math_atan2 (arg1, arg2)
3081	float arg1;
3082	float arg2;
3083	{
3084	return (float) atan2 (arg1, arg2);
3085	}
3086
3087	static float
3088	math_cosh (arg1, ignore)
3089	float arg1;
3090	float ignore ATTRIBUTE_UNUSED;
3091	{
3092	return (float) cosh (arg1);
3093	}
3094
3095	static float
3096	math_cos (arg1, ignore)
3097	float arg1;
3098	float ignore ATTRIBUTE_UNUSED;
3099	{
3100	return (float) cos (arg1);
3101	}
3102
3103	static float
3104	math_cvf (arg1, ignore)
3105	float arg1;
3106	float ignore ATTRIBUTE_UNUSED;
3107	{
3108	return (float) arg1;
3109	}
3110
3111	static float
3112	math_exp (arg1, ignore)
3113	float arg1;
3114	float ignore ATTRIBUTE_UNUSED;
3115	{
3116	return (float) exp (arg1);
3117	}
3118
3119	static float
3120	math_fabs (arg1, ignore)
3121	float arg1;
3122	float ignore ATTRIBUTE_UNUSED;
3123	{
3124	return (float) fabs (arg1);
3125	}
3126
3127	/* expr1 * 2^expr2. */
3128
3129	static float
3130	math_ldexp (arg1, arg2)
3131	float arg1;
3132	float arg2;
3133	{
3134	return arg1 * (float) pow (2.0, arg2);
3135	}
3136
3137	static float
3138	math_log10 (arg1, ignore)
3139	float arg1;
3140	float ignore ATTRIBUTE_UNUSED;
3141	{
3142	return (float) log10 (arg1);
3143	}
3144
3145	static float
3146	math_log (arg1, ignore)
3147	float arg1;
3148	float ignore ATTRIBUTE_UNUSED;
3149	{
3150	return (float) log (arg1);
3151	}
3152
3153	static float
3154	math_max (arg1, arg2)
3155	float arg1;
3156	float arg2;
3157	{
3158	return (arg1 > arg2) ? arg1 : arg2;
3159	}
3160
3161	static float
3162	math_min (arg1, arg2)
3163	float arg1;
3164	float arg2;
3165	{
3166	return (arg1 < arg2) ? arg1 : arg2;
3167	}
3168
3169	static float
3170	math_pow (arg1, arg2)
3171	float arg1;
3172	float arg2;
3173	{
3174	return (float) pow (arg1, arg2);
3175	}
3176
3177	static float
3178	math_sin (arg1, ignore)
3179	float arg1;
3180	float ignore ATTRIBUTE_UNUSED;
3181	{
3182	return (float) sin (arg1);
3183	}
3184
3185	static float
3186	math_sinh (arg1, ignore)
3187	float arg1;
3188	float ignore ATTRIBUTE_UNUSED;
3189	{
3190	return (float) sinh (arg1);
3191	}
3192
3193	static float
3194	math_sqrt (arg1, ignore)
3195	float arg1;
3196	float ignore ATTRIBUTE_UNUSED;
3197	{
3198	return (float) sqrt (arg1);
3199	}
3200
3201	static float
3202	math_tan (arg1, ignore)
3203	float arg1;
3204	float ignore ATTRIBUTE_UNUSED;
3205	{
3206	return (float) tan (arg1);
3207	}
3208
3209	static float
3210	math_tanh (arg1, ignore)
3211	float arg1;
3212	float ignore ATTRIBUTE_UNUSED;
3213	{
3214	return (float) tanh (arg1);
3215	}
3216
3217	/* Built-in substitution symbol functions and math functions. */
3218	typedef struct
3219	{
3220	char *name;
3221	int (proc) PARAMS ((char , char *));
3222	int nargs;
3223	} subsym_proc_entry;
3224
3225	static const subsym_proc_entry subsym_procs[] =
3226	{
3227	/* Assembler built-in string substitution functions. */
3228	{ "$symlen", subsym_symlen, 1, },
3229	{ "$symcmp", subsym_symcmp, 2, },
3230	{ "$firstch", subsym_firstch, 2, },
3231	{ "$lastch", subsym_lastch, 2, },
3232	{ "$isdefed", subsym_isdefed, 1, },
3233	{ "$ismember", subsym_ismember, 2, },
3234	{ "$iscons", subsym_iscons, 1, },
3235	{ "$isname", subsym_isname, 1, },
3236	{ "$isreg", subsym_isreg, 1, },
3237	{ "$structsz", subsym_structsz, 1, },
3238	{ "$structacc", subsym_structacc, 1, },
3239	{ NULL, NULL, 0 },
3240	};
3241
3242	typedef struct
3243	{
3244	char *name;
3245	float (*proc) PARAMS ((float, float));
3246	int nargs;
3247	int int_return;
3248	} math_proc_entry;
3249
3250	static const math_proc_entry math_procs[] =
3251	{
3252	/* Integer-returning built-in math functions. */
3253	{ "$cvi", math_cvi, 1, 1 },
3254	{ "$int", math_int, 1, 1 },
3255	{ "$sgn", math_sgn, 1, 1 },
3256
3257	/* Float-returning built-in math functions. */
3258	{ "$acos", math_acos, 1, 0 },
3259	{ "$asin", math_asin, 1, 0 },
3260	{ "$atan", math_atan, 1, 0 },
3261	{ "$atan2", math_atan2, 2, 0 },
3262	{ "$ceil", math_ceil, 1, 0 },
3263	{ "$cosh", math_cosh, 1, 0 },
3264	{ "$cos", math_cos, 1, 0 },
3265	{ "$cvf", math_cvf, 1, 0 },
3266	{ "$exp", math_exp, 1, 0 },
3267	{ "$fabs", math_fabs, 1, 0 },
3268	{ "$floor", math_floor, 1, 0 },
3269	{ "$fmod", math_fmod, 2, 0 },
3270	{ "$ldexp", math_ldexp, 2, 0 },
3271	{ "$log10", math_log10, 1, 0 },
3272	{ "$log", math_log, 1, 0 },
3273	{ "$max", math_max, 2, 0 },
3274	{ "$min", math_min, 2, 0 },
3275	{ "$pow", math_pow, 2, 0 },
3276	{ "$round", math_round, 1, 0 },
3277	{ "$sin", math_sin, 1, 0 },
3278	{ "$sinh", math_sinh, 1, 0 },
3279	{ "$sqrt", math_sqrt, 1, 0 },
3280	{ "$tan", math_tan, 1, 0 },
3281	{ "$tanh", math_tanh, 1, 0 },
3282	{ "$trunc", math_trunc, 1, 0 },
3283	{ NULL, NULL, 0, 0 },
3284	};
3285
3286	void
3287	md_begin ()
3288	{
3289	template *tm;
3290	symbol *sym;
3291	const subsym_proc_entry *subsym_proc;
3292	const math_proc_entry *math_proc;
3293	const char *hash_err;
3294	char **symname;
3295	char *TIC54X_DIR = getenv ("TIC54X_DIR");
3296	char *A_DIR = TIC54X_DIR ? TIC54X_DIR : getenv ("A_DIR");
3297
3298	local_label_id = 0;
3299
3300	/* Look for A_DIR and add it to the include list. */
3301	if (A_DIR != NULL)
3302	{
3303	char *tmp = xstrdup (A_DIR);
3304
3305	do
3306	{
3307	char *next = strchr (tmp, ';');
3308
3309	if (next)
3310	*next++ = '\0';
3311	add_include_dir (tmp);
3312	tmp = next;
3313	}
3314	while (tmp != NULL);
3315	}
3316
3317	op_hash = hash_new ();
3318	for (tm = (template *) tic54x_optab; tm->name; tm++)
3319	{
3320	if (hash_find (op_hash, tm->name))
3321	continue;
3322	hash_err = hash_insert (op_hash, tm->name, (char *) tm);
3323	if (hash_err)
3324	as_fatal ("Internal Error: Can't hash %s: %s",
3325	tm->name, hash_err);
3326	}
3327	parop_hash = hash_new ();
3328	for (tm = (template *) tic54x_paroptab; tm->name; tm++)
3329	{
3330	if (hash_find (parop_hash, tm->name))
3331	continue;
3332	hash_err = hash_insert (parop_hash, tm->name, (char *) tm);
3333	if (hash_err)
3334	as_fatal ("Internal Error: Can't hash %s: %s",
3335	tm->name, hash_err);
3336	}
3337	reg_hash = hash_new ();
3338	for (sym = (symbol *) regs; sym->name; sym++)
3339	{
3340	/* Add basic registers to the symbol table. */
3341	symbolS *symbolP = symbol_new (sym->name, absolute_section,
3342	(valueT) sym->value, &zero_address_frag);
3343	SF_SET_LOCAL (symbolP);
3344	symbol_table_insert (symbolP);
3345	hash_err = hash_insert (reg_hash, sym->name, (char *) sym);
3346	}
3347	for (sym = (symbol *) mmregs; sym->name; sym++)
3348	hash_err = hash_insert (reg_hash, sym->name, (char *) sym);
3349	mmreg_hash = hash_new ();
3350	for (sym = (symbol *) mmregs; sym->name; sym++)
3351	hash_err = hash_insert (mmreg_hash, sym->name, (char *) sym);
3352
3353	cc_hash = hash_new ();
3354	for (sym = (symbol *) condition_codes; sym->name; sym++)
3355	hash_err = hash_insert (cc_hash, sym->name, (char *) sym);
3356
3357	cc2_hash = hash_new ();
3358	for (sym = (symbol *) cc2_codes; sym->name; sym++)
3359	hash_err = hash_insert (cc2_hash, sym->name, (char *) sym);
3360
3361	cc3_hash = hash_new ();
3362	for (sym = (symbol *) cc3_codes; sym->name; sym++)
3363	hash_err = hash_insert (cc3_hash, sym->name, (char *) sym);
3364
3365	sbit_hash = hash_new ();
3366	for (sym = (symbol *) status_bits; sym->name; sym++)
3367	hash_err = hash_insert (sbit_hash, sym->name, (char *) sym);
3368
3369	misc_symbol_hash = hash_new ();
3370	for (symname = (char *) misc_symbols; symname; symname++)
3371	hash_err = hash_insert (misc_symbol_hash, symname, symname);
3372
3373	/* Only the base substitution table and local label table are initialized;
3374	the others (for local macro substitution) get instantiated as needed. */
3375	local_label_hash[0] = hash_new ();
3376	subsym_hash[0] = hash_new ();
3377	for (subsym_proc = subsym_procs; subsym_proc->name; subsym_proc++)
3378	hash_err = hash_insert (subsym_hash[0], subsym_proc->name,
3379	(char *) subsym_proc);
3380
3381	math_hash = hash_new ();
3382	for (math_proc = math_procs; math_proc->name; math_proc++)
3383	{
3384	/* Insert into the main subsym hash for recognition; insert into
3385	the math hash to actually store information. */
3386	hash_err = hash_insert (subsym_hash[0], math_proc->name,
3387	(char *) math_proc);
3388	hash_err = hash_insert (math_hash, math_proc->name,
3389	(char *) math_proc);
3390	}
3391	subsym_recurse_hash = hash_new ();
3392	stag_hash = hash_new ();
3393	}
3394
3395	static int
3396	is_accumulator (operand)
3397	struct opstruct *operand;
3398	{
3399	return strcasecmp (operand->buf, "a") == 0
3400	\|\| strcasecmp (operand->buf, "b") == 0;
3401	}
3402
3403	/* Return the number of operands found, or -1 on error, copying the
3404	operands into the given array and the accompanying expressions into
3405	the next array. */
3406
3407	static int
3408	get_operands (operands, line)
3409	struct opstruct operands[];
3410	char *line;
3411	{
3412	char *lptr = line;
3413	int numexp = 0;
3414	int expecting_operand = 0;
3415	int i;
3416
3417	while (numexp < MAX_OPERANDS && !is_end_of_line[(int) *lptr])
3418	{
3419	int paren_not_balanced = 0;
3420	char op_start, op_end;
3421
3422	while (lptr && ISSPACE (lptr))
3423	++lptr;
3424	op_start = lptr;
3425	while (paren_not_balanced \|\| *lptr != ',')
3426	{
3427	if (*lptr == '\0')
3428	{
3429	if (paren_not_balanced)
3430	{
3431	as_bad ("Unbalanced parenthesis in operand %d", numexp);
3432	return -1;
3433	}
3434	else
3435	break;
3436	}
3437	if (*lptr == '(')
3438	++paren_not_balanced;
3439	else if (*lptr == ')')
3440	--paren_not_balanced;
3441	++lptr;
3442	}
3443	op_end = lptr;
3444	if (op_end != op_start)
3445	{
3446	int len = op_end - op_start;
3447
3448	strncpy (operands[numexp].buf, op_start, len);
3449	operands[numexp].buf[len] = 0;
3450	/* Trim trailing spaces; while the preprocessor gets rid of most,
3451	there are weird usage patterns that can introduce them
3452	(i.e. using strings for macro args). */
3453	while (len > 0 && ISSPACE (operands[numexp].buf[len - 1]))
3454	operands[numexp].buf[--len] = 0;
3455	lptr = op_end;
3456	++numexp;
3457	}
3458	else
3459	{
3460	if (expecting_operand \|\| *lptr == ',')
3461	{
3462	as_bad ("Expecting operand after ','");
3463	return -1;
3464	}
3465	}
3466	if (*lptr == ',')
3467	{
3468	if (*++lptr == '\0')
3469	{
3470	as_bad ("Expecting operand after ','");
3471	return -1;
3472	}
3473	expecting_operand = 1;
3474	}
3475	}
3476
3477	while (lptr && ISSPACE (lptr++))
3478	;
3479	if (!is_end_of_line[(int) *lptr])
3480	{
3481	as_bad ("Extra junk on line");
3482	return -1;
3483	}
3484
3485	/* OK, now parse them into expressions. */
3486	for (i = 0; i < numexp; i++)
3487	{
3488	memset (&operands[i].exp, 0, sizeof (operands[i].exp));
3489	if (operands[i].buf[0] == '#')
3490	{
3491	/* Immediate. */
3492	parse_expression (operands[i].buf + 1, &operands[i].exp);
3493	}
3494	else if (operands[i].buf[0] == '@')
3495	{
3496	/* Direct notation. */
3497	parse_expression (operands[i].buf + 1, &operands[i].exp);
3498	}
3499	else if (operands[i].buf[0] == '*')
3500	{
3501	/* Indirect. */
3502	char *paren = strchr (operands[i].buf, '(');
3503
3504	/* Allow immediate syntax in the inner expression. */
3505	if (paren && paren[1] == '#')
3506	*++paren = '(';
3507
3508	/* Pull out the lk expression or SP offset, if present. */
3509	if (paren != NULL)
3510	{
3511	int len = strlen (paren);
3512	char *end = paren + len;
3513	int c;
3514
3515	while (end[-1] != ')')
3516	if (--end <= paren)
3517	{
3518	as_bad (_("Badly formed address expression"));
3519	return -1;
3520	}
3521	c = *end;
3522	*end = '\0';
3523	parse_expression (paren, &operands[i].exp);
3524	*end = c;
3525	}
3526	else
3527	operands[i].exp.X_op = O_absent;
3528	}
3529	else
3530	parse_expression (operands[i].buf, &operands[i].exp);
3531	}
3532
3533	return numexp;
3534	}
3535
3536	/* Predicates for different operand types. */
3537
3538	static int
3539	is_immediate (operand)
3540	struct opstruct *operand;
3541	{
3542	return *operand->buf == '#';
3543	}
3544
3545	/* This is distinguished from immediate because some numbers must be constants
3546	and must not have the '#' prefix. */
3547
3548	static int
3549	is_absolute (operand)
3550	struct opstruct *operand;
3551	{
3552	return operand->exp.X_op == O_constant && !is_immediate (operand);
3553	}
3554
3555	/* Is this an indirect operand? */
3556
3557	static int
3558	is_indirect (operand)
3559	struct opstruct *operand;
3560	{
3561	return operand->buf[0] == '*';
3562	}
3563
3564	/* Is this a valid dual-memory operand? */
3565
3566	static int
3567	is_dual (operand)
3568	struct opstruct *operand;
3569	{
3570	if (is_indirect (operand) && strncasecmp (operand->buf, "*ar", 3) == 0)
3571	{
3572	char *tmp = operand->buf + 3;
3573	int arf;
3574	int valid_mod;
3575
3576	arf = *tmp++ - '0';
3577	/* Only allow ARx, ARx-, ARx+, or ARx+0%. */
3578	valid_mod = *tmp == '\0' \|\|
3579	strcasecmp (tmp, "-") == 0 \|\|
3580	strcasecmp (tmp, "+") == 0 \|\|
3581	strcasecmp (tmp, "+0%") == 0;
3582	return arf >= 2 && arf <= 5 && valid_mod;
3583	}
3584	return 0;
3585	}
3586
3587	static int
3588	is_mmreg (operand)
3589	struct opstruct *operand;
3590	{
3591	return (is_absolute (operand)
3592	\|\| is_immediate (operand)
3593	\|\| hash_find (mmreg_hash, operand->buf) != 0);
3594	}
3595
3596	static int
3597	is_type (operand, type)
3598	struct opstruct *operand;
3599	enum optype type;
3600	{
3601	switch (type)
3602	{
3603	case OP_None:
3604	return operand->buf[0] == 0;
3605	case OP_Xmem:
3606	case OP_Ymem:
3607	return is_dual (operand);
3608	case OP_Sind:
3609	return is_indirect (operand);
3610	case OP_xpmad_ms7:
3611	/* This one must be immediate. */
3612	return is_immediate (operand);
3613	case OP_xpmad:
3614	case OP_pmad:
3615	case OP_PA:
3616	case OP_dmad:
3617	case OP_Lmem:
3618	case OP_MMR:
3619	return 1;
3620	case OP_Smem:
3621	/* Address may be a numeric, indirect, or an expression. */
3622	return !is_immediate (operand);
3623	case OP_MMRY:
3624	case OP_MMRX:
3625	return is_mmreg (operand);
3626	case OP_SRC:
3627	case OP_SRC1:
3628	case OP_RND:
3629	case OP_DST:
3630	return is_accumulator (operand);
3631	case OP_B:
3632	return is_accumulator (operand) && TOUPPER (operand->buf[0]) == 'B';
3633	case OP_A:
3634	return is_accumulator (operand) && TOUPPER (operand->buf[0]) == 'A';
3635	case OP_ARX:
3636	return strncasecmp ("ar", operand->buf, 2) == 0
3637	&& ISDIGIT (operand->buf[2]);
3638	case OP_SBIT:
3639	return hash_find (sbit_hash, operand->buf) != 0 \|\| is_absolute (operand);
3640	case OP_CC:
3641	return hash_find (cc_hash, operand->buf) != 0;
3642	case OP_CC2:
3643	return hash_find (cc2_hash, operand->buf) != 0;
3644	case OP_CC3:
3645	return hash_find (cc3_hash, operand->buf) != 0
3646	\|\| is_immediate (operand) \|\| is_absolute (operand);
3647	case OP_16:
3648	return (is_immediate (operand) \|\| is_absolute (operand))
3649	&& operand->exp.X_add_number == 16;
3650	case OP_N:
3651	/* Allow st0 or st1 instead of a numeric. */
3652	return is_absolute (operand) \|\| is_immediate (operand) \|\|
3653	strcasecmp ("st0", operand->buf) == 0 \|\|
3654	strcasecmp ("st1", operand->buf) == 0;
3655	case OP_12:
3656	case OP_123:
3657	return is_absolute (operand) \|\| is_immediate (operand);
3658	case OP_SHFT:
3659	return (is_immediate (operand) \|\| is_absolute (operand))
3660	&& operand->exp.X_add_number >= 0 && operand->exp.X_add_number < 16;
3661	case OP_SHIFT:
3662	/* Let this one catch out-of-range values. */
3663	return (is_immediate (operand) \|\| is_absolute (operand))
3664	&& operand->exp.X_add_number != 16;
3665	case OP_BITC:
3666	case OP_031:
3667	case OP_k8:
3668	return is_absolute (operand) \|\| is_immediate (operand);
3669	case OP_k8u:
3670	return is_immediate (operand)
3671	&& operand->exp.X_op == O_constant
3672	&& operand->exp.X_add_number >= 0
3673	&& operand->exp.X_add_number < 256;
3674	case OP_lk:
3675	case OP_lku:
3676	/* Allow anything; assumes opcodes are ordered with Smem operands
3677	versions first. */
3678	return 1;
3679	case OP_k5:
3680	case OP_k3:
3681	case OP_k9:
3682	/* Just make sure it's an integer; check range later. */
3683	return is_immediate (operand);
3684	case OP_T:
3685	return strcasecmp ("t", operand->buf) == 0 \|\|
3686	strcasecmp ("treg", operand->buf) == 0;
3687	case OP_TS:
3688	return strcasecmp ("ts", operand->buf) == 0;
3689	case OP_ASM:
3690	return strcasecmp ("asm", operand->buf) == 0;
3691	case OP_TRN:
3692	return strcasecmp ("trn", operand->buf) == 0;
3693	case OP_DP:
3694	return strcasecmp ("dp", operand->buf) == 0;
3695	case OP_ARP:
3696	return strcasecmp ("arp", operand->buf) == 0;
3697	default:
3698	return 0;
3699	}
3700	}
3701
3702	static int
3703	operands_match (insn, operands, opcount, refoptype, minops, maxops)
3704	tic54x_insn *insn;
3705	struct opstruct *operands;
3706	int opcount;
3707	const enum optype *refoptype;
3708	int minops;
3709	int maxops;
3710	{
3711	int op = 0, refop = 0;
3712
3713	if (opcount == 0 && minops == 0)
3714	return 1;
3715
3716	while (op <= maxops && refop <= maxops)
3717	{
3718	while (!is_type (&operands[op], OPTYPE (refoptype[refop])))
3719	{
3720	/* Skip an optional template operand if it doesn't agree
3721	with the current operand. */
3722	if (refoptype[refop] & OPT)
3723	{
3724	++refop;
3725	--maxops;
3726	if (refop > maxops)
3727	return 0;
3728	}
3729	else
3730	return 0;
3731	}
3732
3733	/* Save the actual operand type for later use. */
3734	operands[op].type = OPTYPE (refoptype[refop]);
3735	++refop;
3736	++op;
3737	/* Have we matched them all yet? */
3738	if (op == opcount)
3739	{
3740	while (op < maxops)
3741	{
3742	/* If a later operand is not optional, no match. */
3743	if ((refoptype[refop] & OPT) == 0)
3744	return 0;
3745	/* Flag any implicit default OP_DST operands so we know to add
3746	them explicitly when encoding the operand later. */
3747	if (OPTYPE (refoptype[refop]) == OP_DST)
3748	insn->using_default_dst = 1;
3749	++refop;
3750	++op;
3751	}
3752
3753	return 1;
3754	}
3755	}
3756
3757	return 0;
3758	}
3759
3760	/* 16-bit direct memory address
3761	Explicit dmad operands are always in last word of insn (usually second
3762	word, but bumped to third if lk addressing is used)
3763
3764	We allow *(dmad) notation because the TI assembler allows it.
3765
3766	XPC_CODE:
3767	0 for 16-bit addresses
3768	1 for full 23-bit addresses
3769	2 for the upper 7 bits of a 23-bit address (LDX). */
3770
3771	static int
3772	encode_dmad (insn, operand, xpc_code)
3773	tic54x_insn *insn;
3774	struct opstruct *operand;
3775	int xpc_code;
3776	{
3777	int op = 1 + insn->is_lkaddr;
3778
3779	/* Only allow (dmad) expressions; all others are invalid. /
3780	if (is_indirect (operand) && operand->buf[strlen (operand->buf) - 1] != ')')
3781	{
3782	as_bad (_("Invalid dmad syntax '%s'"), operand->buf);
3783	return 0;
3784	}
3785
3786	insn->opcode[op].addr_expr = operand->exp;
3787
3788	if (insn->opcode[op].addr_expr.X_op == O_constant)
3789	{
3790	valueT value = insn->opcode[op].addr_expr.X_add_number;
3791
3792	if (xpc_code == 1)
3793	{
3794	insn->opcode[0].word &= 0xFF80;
3795	insn->opcode[0].word \|= (value >> 16) & 0x7F;
3796	insn->opcode[1].word = value & 0xFFFF;
3797	}
3798	else if (xpc_code == 2)
3799	insn->opcode[op].word = (value >> 16) & 0xFFFF;
3800	else
3801	insn->opcode[op].word = value;
3802	}
3803	else
3804	{
3805	/* Do the fixup later; just store the expression. */
3806	insn->opcode[op].word = 0;
3807	insn->opcode[op].r_nchars = 2;
3808
3809	if (amode == c_mode)
3810	insn->opcode[op].r_type = BFD_RELOC_TIC54X_16_OF_23;
3811	else if (xpc_code == 1)
3812	{
3813	/* This relocation spans two words, so adjust accordingly. */
3814	insn->opcode[0].addr_expr = operand->exp;
3815	insn->opcode[0].r_type = BFD_RELOC_TIC54X_23;
3816	insn->opcode[0].r_nchars = 4;
3817	insn->opcode[0].unresolved = 1;
3818	/* It's really 2 words, but we want to stop encoding after the
3819	first, since we must encode both words at once. */
3820	insn->words = 1;
3821	}
3822	else if (xpc_code == 2)
3823	insn->opcode[op].r_type = BFD_RELOC_TIC54X_MS7_OF_23;
3824	else
3825	insn->opcode[op].r_type = BFD_RELOC_TIC54X_16_OF_23;
3826
3827	insn->opcode[op].unresolved = 1;
3828	}
3829
3830	return 1;
3831	}
3832
3833	/* 7-bit direct address encoding. */
3834
3835	static int
3836	encode_address (insn, operand)
3837	tic54x_insn *insn;
3838	struct opstruct *operand;
3839	{
3840	/* Assumes that dma addresses are always in word 0 of the opcode. */
3841	insn->opcode[0].addr_expr = operand->exp;
3842
3843	if (operand->exp.X_op == O_constant)
3844	insn->opcode[0].word \|= (operand->exp.X_add_number & 0x7F);
3845	else
3846	{
3847	if (operand->exp.X_op == O_register)
3848	as_bad (_("Use the .mmregs directive to use memory-mapped register names such as '%s'"), operand->buf);
3849	/* Do the fixup later; just store the expression. */
3850	insn->opcode[0].r_nchars = 1;
3851	insn->opcode[0].r_type = BFD_RELOC_TIC54X_PARTLS7;
3852	insn->opcode[0].unresolved = 1;
3853	}
3854
3855	return 1;
3856	}
3857
3858	static int
3859	encode_indirect (insn, operand)
3860	tic54x_insn *insn;
3861	struct opstruct *operand;
3862	{
3863	int arf;
3864	int mod;
3865
3866	if (insn->is_lkaddr)
3867	{
3868	/* lk addresses always go in the second insn word. */
3869	mod = ((TOUPPER (operand->buf[1]) == 'A') ? 12 :
3870	(operand->buf[1] == '(') ? 15 :
3871	(strchr (operand->buf, '%') != NULL) ? 14 : 13);
3872	arf = ((mod == 12) ? operand->buf[3] - '0' :
3873	(mod == 15) ? 0 : operand->buf[4] - '0');
3874
3875	insn->opcode[1].addr_expr = operand->exp;
3876
3877	if (operand->exp.X_op == O_constant)
3878	insn->opcode[1].word = operand->exp.X_add_number;
3879	else
3880	{
3881	insn->opcode[1].word = 0;
3882	insn->opcode[1].r_nchars = 2;
3883	insn->opcode[1].r_type = BFD_RELOC_TIC54X_16_OF_23;
3884	insn->opcode[1].unresolved = 1;
3885	}
3886	}
3887	else if (strncasecmp (operand->buf, "*sp (", 4) == 0)
3888	{
3889	/* Stack offsets look the same as 7-bit direct addressing. */
3890	return encode_address (insn, operand);
3891	}
3892	else
3893	{
3894	arf = (TOUPPER (operand->buf[1]) == 'A' ?
3895	operand->buf[3] : operand->buf[4]) - '0';
3896
3897	if (operand->buf[1] == '+')
3898	{
3899	mod = 3; /* +ARx /
3900	if (insn->tm->flags & FL_SMR)
3901	as_warn (_("Address mode *+ARx is write-only. "
3902	"Results of reading are undefined."));
3903	}
3904	else if (operand->buf[4] == '\0')
3905	mod = 0; /* ARx /
3906	else if (operand->buf[5] == '\0')
3907	mod = (operand->buf[4] == '-' ? 1 : 2); /* ARx+ / ARx- */
3908	else if (operand->buf[6] == '\0')
3909	{
3910	if (operand->buf[5] == '0')
3911	mod = (operand->buf[4] == '-' ? 5 : 6); /* ARx+0 / ARx-0 */
3912	else
3913	mod = (operand->buf[4] == '-' ? 8 : 10);/* ARx+% / ARx-% */
3914	}
3915	else if (TOUPPER (operand->buf[6]) == 'B')
3916	mod = (operand->buf[4] == '-' ? 4 : 7); /* ARx+0B / ARx-0B /
3917	else if (TOUPPER (operand->buf[6]) == '%')
3918	mod = (operand->buf[4] == '-' ? 9 : 11); /* ARx+0% / ARx - 0% /
3919	else
3920	{
3921	as_bad (_("Unrecognized indirect address format \"%s\""),
3922	operand->buf);
3923	return 0;
3924	}
3925	}
3926
3927	insn->opcode[0].word \|= 0x80 \| (mod << 3) \| arf;
3928
3929	return 1;
3930	}
3931
3932	static int
3933	encode_integer (insn, operand, which, min, max, mask)
3934	tic54x_insn *insn;
3935	struct opstruct *operand;
3936	int which;
3937	int min;
3938	int max;
3939	unsigned short mask;
3940	{
3941	long parse, integer;
3942
3943	insn->opcode[which].addr_expr = operand->exp;
3944
3945	if (operand->exp.X_op == O_constant)
3946	{
3947	parse = operand->exp.X_add_number;
3948	/* Hack -- fixup for 16-bit hex quantities that get converted positive
3949	instead of negative. */
3950	if ((parse & 0x8000) && min == -32768 && max == 32767)
3951	integer = (short) parse;
3952	else
3953	integer = parse;
3954
3955	if (integer >= min && integer <= max)
3956	{
3957	insn->opcode[which].word \|= (integer & mask);
3958	return 1;
3959	}
3960	as_bad (_("Operand '%s' out of range (%d <= x <= %d)"),
3961	operand->buf, min, max);
3962	}
3963	else
3964	{
3965	if (insn->opcode[which].addr_expr.X_op == O_constant)
3966	{
3967	insn->opcode[which].word \|=
3968	insn->opcode[which].addr_expr.X_add_number & mask;
3969	}
3970	else
3971	{
3972	/* Do the fixup later; just store the expression. */
3973	bfd_reloc_code_real_type rtype =
3974	(mask == 0x1FF ? BFD_RELOC_TIC54X_PARTMS9 :
3975	mask == 0xFFFF ? BFD_RELOC_TIC54X_16_OF_23 :
3976	mask == 0x7F ? BFD_RELOC_TIC54X_PARTLS7 : BFD_RELOC_8);
3977	int size = (mask == 0x1FF \|\| mask == 0xFFFF) ? 2 : 1;
3978
3979	if (rtype == BFD_RELOC_8)
3980	as_bad (_("Error in relocation handling"));
3981
3982	insn->opcode[which].r_nchars = size;
3983	insn->opcode[which].r_type = rtype;
3984	insn->opcode[which].unresolved = 1;
3985	}
3986
3987	return 1;
3988	}
3989
3990	return 0;
3991	}
3992
3993	static int
3994	encode_condition (insn, operand)
3995	tic54x_insn *insn;
3996	struct opstruct *operand;
3997	{
3998	symbol cc = (symbol ) hash_find (cc_hash, operand->buf);
3999	if (!cc)
4000	{
4001	as_bad (_("Unrecognized condition code \"%s\""), operand->buf);
4002	return 0;
4003	}
4004	#define CC_GROUP 0x40
4005	#define CC_ACC 0x08
4006	#define CATG_A1 0x07
4007	#define CATG_B1 0x30
4008	#define CATG_A2 0x30
4009	#define CATG_B2 0x0C
4010	#define CATG_C2 0x03
4011	/* Disallow group 1 conditions mixed with group 2 conditions
4012	if group 1, allow only one category A and one category B
4013	if group 2, allow only one each of category A, B, and C. */
4014	if (((insn->opcode[0].word & 0xFF) != 0))
4015	{
4016	if ((insn->opcode[0].word & CC_GROUP) != (cc->value & CC_GROUP))
4017	{
4018	as_bad (_("Condition \"%s\" does not match preceding group"),
4019	operand->buf);
4020	return 0;
4021	}
4022	if (insn->opcode[0].word & CC_GROUP)
4023	{
4024	if ((insn->opcode[0].word & CC_ACC) != (cc->value & CC_ACC))
4025	{
4026	as_bad (_("Condition \"%s\" uses a different accumulator from "
4027	"a preceding condition"),
4028	operand->buf);
4029	return 0;
4030	}
4031	if ((insn->opcode[0].word & CATG_A1) && (cc->value & CATG_A1))
4032	{
4033	as_bad (_("Only one comparison conditional allowed"));
4034	return 0;
4035	}
4036	if ((insn->opcode[0].word & CATG_B1) && (cc->value & CATG_B1))
4037	{
4038	as_bad (_("Only one overflow conditional allowed"));
4039	return 0;
4040	}
4041	}
4042	else if ( ((insn->opcode[0].word & CATG_A2) && (cc->value & CATG_A2))
4043	\|\| ((insn->opcode[0].word & CATG_B2) && (cc->value & CATG_B2))
4044	\|\| ((insn->opcode[0].word & CATG_C2) && (cc->value & CATG_C2)))
4045	{
4046	as_bad (_("Duplicate %s conditional"), operand->buf);
4047	return 0;
4048	}
4049	}
4050
4051	insn->opcode[0].word \|= cc->value;
4052	return 1;
4053	}
4054
4055	static int
4056	encode_cc3 (insn, operand)
4057	tic54x_insn *insn;
4058	struct opstruct *operand;
4059	{
4060	symbol cc3 = (symbol ) hash_find (cc3_hash, operand->buf);
4061	int value = cc3 ? cc3->value : operand->exp.X_add_number << 8;
4062
4063	if ((value & 0x0300) != value)
4064	{
4065	as_bad (_("Unrecognized condition code \"%s\""), operand->buf);
4066	return 0;
4067	}
4068	insn->opcode[0].word \|= value;
4069	return 1;
4070	}
4071
4072	static int
4073	encode_arx (insn, operand)
4074	tic54x_insn *insn;
4075	struct opstruct *operand;
4076	{
4077	int arf = strlen (operand->buf) >= 3 ? operand->buf[2] - '0' : -1;
4078
4079	if (strncasecmp ("ar", operand->buf, 2) \|\| arf < 0 \|\| arf > 7)
4080	{
4081	as_bad (_("Invalid auxiliary register (use AR0-AR7)"));
4082	return 0;
4083	}
4084	insn->opcode[0].word \|= arf;
4085	return 1;
4086	}
4087
4088	static int
4089	encode_cc2 (insn, operand)
4090	tic54x_insn *insn;
4091	struct opstruct *operand;
4092	{
4093	symbol cc2 = (symbol ) hash_find (cc2_hash, operand->buf);
4094
4095	if (!cc2)
4096	{
4097	as_bad (_("Unrecognized condition code \"%s\""), operand->buf);
4098	return 0;
4099	}
4100	insn->opcode[0].word \|= cc2->value;
4101	return 1;
4102	}
4103
4104	static int
4105	encode_operand (insn, type, operand)
4106	tic54x_insn *insn;
4107	enum optype type;
4108	struct opstruct *operand;
4109	{
4110	int ext = (insn->tm->flags & FL_EXT) != 0;
4111
4112	if (type == OP_MMR && operand->exp.X_op != O_constant)
4113	{
4114	/* Disallow long-constant addressing for memory-mapped addressing. */
4115	if (insn->is_lkaddr)
4116	{
4117	as_bad (_("lk addressing modes are invalid for memory-mapped "
4118	"register addressing"));
4119	return 0;
4120	}
4121	type = OP_Smem;
4122	/* Warn about +ARx when used with MMR operands. /
4123	if (strncasecmp (operand->buf, "*+ar", 4) == 0)
4124	{
4125	as_warn (_("Address mode *+ARx is not allowed in memory-mapped "
4126	"register addressing. Resulting behavior is "
4127	"undefined."));
4128	}
4129	}
4130
4131	switch (type)
4132	{
4133	case OP_None:
4134	return 1;
4135	case OP_dmad:
4136	/* 16-bit immediate value. */
4137	return encode_dmad (insn, operand, 0);
4138	case OP_SRC:
4139	if (TOUPPER (*operand->buf) == 'B')
4140	{
4141	insn->opcode[ext ? (1 + insn->is_lkaddr) : 0].word \|= (1 << 9);
4142	if (insn->using_default_dst)
4143	insn->opcode[ext ? (1 + insn->is_lkaddr) : 0].word \|= (1 << 8);
4144	}
4145	return 1;
4146	case OP_RND:
4147	/* Make sure this agrees with the OP_DST operand. */
4148	if (!((TOUPPER (operand->buf[0]) == 'B') ^
4149	((insn->opcode[0].word & (1 << 8)) != 0)))
4150	{
4151	as_bad (_("Destination accumulator for each part of this parallel "
4152	"instruction must be different"));
4153	return 0;
4154	}
4155	return 1;
4156	case OP_SRC1:
4157	case OP_DST:
4158	if (TOUPPER (operand->buf[0]) == 'B')
4159	insn->opcode[ext ? (1 + insn->is_lkaddr) : 0].word \|= (1 << 8);
4160	return 1;
4161	case OP_Xmem:
4162	case OP_Ymem:
4163	{
4164	int mod = (operand->buf[4] == '\0' ? 0 : /* arx /
4165	operand->buf[4] == '-' ? 1 : /* arx- /
4166	operand->buf[5] == '\0' ? 2 : 3); /* arx+, arx+0% */
4167	int arf = operand->buf[3] - '0' - 2;
4168	int code = (mod << 2) \| arf;
4169	insn->opcode[0].word \|= (code << (type == OP_Xmem ? 4 : 0));
4170	return 1;
4171	}
4172	case OP_Lmem:
4173	case OP_Smem:
4174	if (!is_indirect (operand))
4175	return encode_address (insn, operand);
4176	/* Fall through. */
4177	case OP_Sind:
4178	return encode_indirect (insn, operand);
4179	case OP_xpmad_ms7:
4180	return encode_dmad (insn, operand, 2);
4181	case OP_xpmad:
4182	return encode_dmad (insn, operand, 1);
4183	case OP_PA:
4184	case OP_pmad:
4185	return encode_dmad (insn, operand, 0);
4186	case OP_ARX:
4187	return encode_arx (insn, operand);
4188	case OP_MMRX:
4189	case OP_MMRY:
4190	case OP_MMR:
4191	{
4192	int value = operand->exp.X_add_number;
4193
4194	if (type == OP_MMR)
4195	insn->opcode[0].word \|= value;
4196	else
4197	{
4198	if (value < 16 \|\| value > 24)
4199	{
4200	as_bad (_("Memory mapped register \"%s\" out of range"),
4201	operand->buf);
4202	return 0;
4203	}
4204	if (type == OP_MMRX)
4205	insn->opcode[0].word \|= (value - 16) << 4;
4206	else
4207	insn->opcode[0].word \|= (value - 16);
4208	}
4209	return 1;
4210	}
4211	case OP_B:
4212	case OP_A:
4213	return 1;
4214	case OP_SHFT:
4215	return encode_integer (insn, operand, ext + insn->is_lkaddr,
4216	0, 15, 0xF);
4217	case OP_SHIFT:
4218	return encode_integer (insn, operand, ext + insn->is_lkaddr,
4219	-16, 15, 0x1F);
4220	case OP_lk:
4221	return encode_integer (insn, operand, 1 + insn->is_lkaddr,
4222	-32768, 32767, 0xFFFF);
4223	case OP_CC:
4224	return encode_condition (insn, operand);
4225	case OP_CC2:
4226	return encode_cc2 (insn, operand);
4227	case OP_CC3:
4228	return encode_cc3 (insn, operand);
4229	case OP_BITC:
4230	return encode_integer (insn, operand, 0, 0, 15, 0xF);
4231	case OP_k8:
4232	return encode_integer (insn, operand, 0, -128, 127, 0xFF);
4233	case OP_123:
4234	{
4235	int value = operand->exp.X_add_number;
4236	int code;
4237	if (value < 1 \|\| value > 3)
4238	{
4239	as_bad (_("Invalid operand (use 1, 2, or 3)"));
4240	return 0;
4241	}
4242	code = value == 1 ? 0 : value == 2 ? 0x2 : 0x1;
4243	insn->opcode[0].word \|= (code << 8);
4244	return 1;
4245	}
4246	case OP_031:
4247	return encode_integer (insn, operand, 0, 0, 31, 0x1F);
4248	case OP_k8u:
4249	return encode_integer (insn, operand, 0, 0, 255, 0xFF);
4250	case OP_lku:
4251	return encode_integer (insn, operand, 1 + insn->is_lkaddr,
4252	0, 65535, 0xFFFF);
4253	case OP_SBIT:
4254	{
4255	symbol sbit = (symbol ) hash_find (sbit_hash, operand->buf);
4256	int value = is_absolute (operand) ?
4257	operand->exp.X_add_number : (sbit ? sbit->value : -1);
4258	int reg = 0;
4259
4260	if (insn->opcount == 1)
4261	{
4262	if (!sbit)
4263	{
4264	as_bad (_("A status register or status bit name is required"));
4265	return 0;
4266	}
4267	/* Guess the register based on the status bit; "ovb" is the last
4268	status bit defined for st0. */
4269	if (sbit > (symbol *) hash_find (sbit_hash, "ovb"))
4270	reg = 1;
4271	}
4272	if (value == -1)
4273	{
4274	as_bad (_("Unrecognized status bit \"%s\""), operand->buf);
4275	return 0;
4276	}
4277	insn->opcode[0].word \|= value;
4278	insn->opcode[0].word \|= (reg << 9);
4279	return 1;
4280	}
4281	case OP_N:
4282	if (strcasecmp (operand->buf, "st0") == 0
4283	\|\| strcasecmp (operand->buf, "st1") == 0)
4284	{
4285	insn->opcode[0].word \|=
4286	((unsigned short) (operand->buf[2] - '0')) << 9;
4287	return 1;
4288	}
4289	else if (operand->exp.X_op == O_constant
4290	&& (operand->exp.X_add_number == 0
4291	\|\| operand->exp.X_add_number == 1))
4292	{
4293	insn->opcode[0].word \|=
4294	((unsigned short) (operand->exp.X_add_number)) << 9;
4295	return 1;
4296	}
4297	as_bad (_("Invalid status register \"%s\""), operand->buf);
4298	return 0;
4299	case OP_k5:
4300	return encode_integer (insn, operand, 0, -16, 15, 0x1F);
4301	case OP_k3:
4302	return encode_integer (insn, operand, 0, 0, 7, 0x7);
4303	case OP_k9:
4304	return encode_integer (insn, operand, 0, 0, 0x1FF, 0x1FF);
4305	case OP_12:
4306	if (operand->exp.X_add_number != 1
4307	&& operand->exp.X_add_number != 2)
4308	{
4309	as_bad (_("Operand \"%s\" out of range (use 1 or 2)"), operand->buf);
4310	return 0;
4311	}
4312	insn->opcode[0].word \|= (operand->exp.X_add_number - 1) << 9;
4313	return 1;
4314	case OP_16:
4315	case OP_T:
4316	case OP_TS:
4317	case OP_ASM:
4318	case OP_TRN:
4319	case OP_DP:
4320	case OP_ARP:
4321	/* No encoding necessary. */
4322	return 1;
4323	default:
4324	return 0;
4325	}
4326
4327	return 1;
4328	}
4329
4330	static void
4331	emit_insn (insn)
4332	tic54x_insn *insn;
4333	{
4334	int i;
4335	flagword oldflags = bfd_get_section_flags (stdoutput, now_seg);
4336	flagword flags = oldflags \| SEC_CODE;
4337
4338	if (! bfd_set_section_flags (stdoutput, now_seg, flags))
4339	as_warn (_("error setting flags for \"%s\": %s"),
4340	bfd_section_name (stdoutput, now_seg),
4341	bfd_errmsg (bfd_get_error ()));
4342
4343	for (i = 0; i < insn->words; i++)
4344	{
4345	int size = (insn->opcode[i].unresolved
4346	&& insn->opcode[i].r_type == BFD_RELOC_TIC54X_23) ? 4 : 2;
4347	char *p = frag_more (size);
4348
4349	if (size == 2)
4350	md_number_to_chars (p, (valueT) insn->opcode[i].word, 2);
4351	else
4352	md_number_to_chars (p, (valueT) insn->opcode[i].word << 16, 4);
4353
4354	if (insn->opcode[i].unresolved)
4355	fix_new_exp (frag_now, p - frag_now->fr_literal,
4356	insn->opcode[i].r_nchars, &insn->opcode[i].addr_expr,
4357	FALSE, insn->opcode[i].r_type);
4358	}
4359	}
4360
4361	/* Convert the operand strings into appropriate opcode values
4362	return the total number of words used by the instruction. */
4363
4364	static int
4365	build_insn (insn)
4366	tic54x_insn *insn;
4367	{
4368	int i;
4369
4370	/* Only non-parallel instructions support lk addressing. */
4371	if (!(insn->tm->flags & FL_PAR))
4372	{
4373	for (i = 0; i < insn->opcount; i++)
4374	{
4375	if ((OPTYPE (insn->operands[i].type) == OP_Smem
4376	\|\| OPTYPE (insn->operands[i].type) == OP_Lmem
4377	\|\| OPTYPE (insn->operands[i].type) == OP_Sind)
4378	&& strchr (insn->operands[i].buf, '(')
4379	/* Don't mistake stack-relative addressing for lk addressing. */
4380	&& strncasecmp (insn->operands[i].buf, "*sp (", 4) != 0)
4381	{
4382	insn->is_lkaddr = 1;
4383	insn->lkoperand = i;
4384	break;
4385	}
4386	}
4387	}
4388	insn->words = insn->tm->words + insn->is_lkaddr;
4389
4390	insn->opcode[0].word = insn->tm->opcode;
4391	if (insn->tm->flags & FL_EXT)
4392	insn->opcode[1 + insn->is_lkaddr].word = insn->tm->opcode2;
4393
4394	for (i = 0; i < insn->opcount; i++)
4395	{
4396	enum optype type = insn->operands[i].type;
4397
4398	if (!encode_operand (insn, type, &insn->operands[i]))
4399	return 0;
4400	}
4401	if (insn->tm->flags & FL_PAR)
4402	for (i = 0; i < insn->paropcount; i++)
4403	{
4404	enum optype partype = insn->paroperands[i].type;
4405
4406	if (!encode_operand (insn, partype, &insn->paroperands[i]))
4407	return 0;
4408	}
4409
4410	emit_insn (insn);
4411
4412	return insn->words;
4413	}
4414
4415	static int
4416	optimize_insn (insn)
4417	tic54x_insn *insn;
4418	{
4419	/* Optimize some instructions, helping out the brain-dead programmer. */
4420	#define is_zero(op) ((op).exp.X_op == O_constant && (op).exp.X_add_number == 0)
4421	if (strcasecmp (insn->tm->name, "add") == 0)
4422	{
4423	if (insn->opcount > 1
4424	&& is_accumulator (&insn->operands[insn->opcount - 2])
4425	&& is_accumulator (&insn->operands[insn->opcount - 1])
4426	&& strcasecmp (insn->operands[insn->opcount - 2].buf,
4427	insn->operands[insn->opcount - 1].buf) == 0)
4428	{
4429	--insn->opcount;
4430	insn->using_default_dst = 1;
4431	return 1;
4432	}
4433
4434	/* Try to collapse if Xmem and shift count is zero. */
4435	if ((OPTYPE (insn->tm->operand_types[0]) == OP_Xmem
4436	&& OPTYPE (insn->tm->operand_types[1]) == OP_SHFT
4437	&& is_zero (insn->operands[1]))
4438	/* Or if Smem, shift is zero or absent, and SRC == DST. */
4439	\|\| (OPTYPE (insn->tm->operand_types[0]) == OP_Smem
4440	&& OPTYPE (insn->tm->operand_types[1]) == OP_SHIFT
4441	&& is_type (&insn->operands[1], OP_SHIFT)
4442	&& is_zero (insn->operands[1]) && insn->opcount == 3))
4443	{
4444	insn->operands[1] = insn->operands[2];
4445	insn->opcount = 2;
4446	return 1;
4447	}
4448	}
4449	else if (strcasecmp (insn->tm->name, "ld") == 0)
4450	{
4451	if (insn->opcount == 3 && insn->operands[0].type != OP_SRC)
4452	{
4453	if ((OPTYPE (insn->tm->operand_types[1]) == OP_SHIFT
4454	\|\| OPTYPE (insn->tm->operand_types[1]) == OP_SHFT)
4455	&& is_zero (insn->operands[1])
4456	&& (OPTYPE (insn->tm->operand_types[0]) != OP_lk
4457	\|\| (insn->operands[0].exp.X_op == O_constant
4458	&& insn->operands[0].exp.X_add_number <= 255
4459	&& insn->operands[0].exp.X_add_number >= 0)))
4460	{
4461	insn->operands[1] = insn->operands[2];
4462	insn->opcount = 2;
4463	return 1;
4464	}
4465	}
4466	}
4467	else if (strcasecmp (insn->tm->name, "sth") == 0
4468	\|\| strcasecmp (insn->tm->name, "stl") == 0)
4469	{
4470	if ((OPTYPE (insn->tm->operand_types[1]) == OP_SHIFT
4471	\|\| OPTYPE (insn->tm->operand_types[1]) == OP_SHFT)
4472	&& is_zero (insn->operands[1]))
4473	{
4474	insn->operands[1] = insn->operands[2];
4475	insn->opcount = 2;
4476	return 1;
4477	}
4478	}
4479	else if (strcasecmp (insn->tm->name, "sub") == 0)
4480	{
4481	if (insn->opcount > 1
4482	&& is_accumulator (&insn->operands[insn->opcount - 2])
4483	&& is_accumulator (&insn->operands[insn->opcount - 1])
4484	&& strcasecmp (insn->operands[insn->opcount - 2].buf,
4485	insn->operands[insn->opcount - 1].buf) == 0)
4486	{
4487	--insn->opcount;
4488	insn->using_default_dst = 1;
4489	return 1;
4490	}
4491
4492	if ( ((OPTYPE (insn->tm->operand_types[0]) == OP_Smem
4493	&& OPTYPE (insn->tm->operand_types[1]) == OP_SHIFT)
4494	\|\| (OPTYPE (insn->tm->operand_types[0]) == OP_Xmem
4495	&& OPTYPE (insn->tm->operand_types[1]) == OP_SHFT))
4496	&& is_zero (insn->operands[1])
4497	&& insn->opcount == 3)
4498	{
4499	insn->operands[1] = insn->operands[2];
4500	insn->opcount = 2;
4501	return 1;
4502	}
4503	}
4504	return 0;
4505	}
4506
4507	/* Find a matching template if possible, and get the operand strings. */
4508
4509	static int
4510	tic54x_parse_insn (insn, line)
4511	tic54x_insn *insn;
4512	char *line;
4513	{
4514	insn->tm = (template *) hash_find (op_hash, insn->mnemonic);
4515	if (!insn->tm)
4516	{
4517	as_bad (_("Unrecognized instruction \"%s\""), insn->mnemonic);
4518	return 0;
4519	}
4520
4521	insn->opcount = get_operands (insn->operands, line);
4522	if (insn->opcount < 0)
4523	return 0;
4524
4525	/* Check each variation of operands for this mnemonic. */
4526	while (insn->tm->name && strcasecmp (insn->tm->name, insn->mnemonic) == 0)
4527	{
4528	if (insn->opcount >= insn->tm->minops
4529	&& insn->opcount <= insn->tm->maxops
4530	&& operands_match (insn, &insn->operands[0], insn->opcount,
4531	insn->tm->operand_types,
4532	insn->tm->minops, insn->tm->maxops))
4533	{
4534	/* SUCCESS! now try some optimizations. */
4535	if (optimize_insn (insn))
4536	{
4537	insn->tm = (template *) hash_find (op_hash,
4538	insn->mnemonic);
4539	continue;
4540	}
4541
4542	return 1;
4543	}
4544	++(insn->tm);
4545	}
4546	as_bad (_("Unrecognized operand list '%s' for instruction '%s'"),
4547	line, insn->mnemonic);
4548	return 0;
4549	}
4550
4551	/* We set this in start_line_hook, 'cause if we do a line replacement, we
4552	won't be able to see the next line. */
4553	static int parallel_on_next_line_hint = 0;
4554
4555	/* See if this is part of a parallel instruction
4556	Look for a subsequent line starting with "\|\|". */
4557
4558	static int
4559	next_line_shows_parallel (next_line)
4560	char *next_line;
4561	{
4562	/* Look for the second half. */
4563	while (ISSPACE (*next_line))
4564	++next_line;
4565
4566	return (next_line[0] == PARALLEL_SEPARATOR
4567	&& next_line[1] == PARALLEL_SEPARATOR);
4568	}
4569
4570	static int
4571	tic54x_parse_parallel_insn_firstline (insn, line)
4572	tic54x_insn *insn;
4573	char *line;
4574	{
4575	insn->tm = (template *) hash_find (parop_hash, insn->mnemonic);
4576	if (!insn->tm)
4577	{
4578	as_bad (_("Unrecognized parallel instruction \"%s\""),
4579	insn->mnemonic);
4580	return 0;
4581	}
4582
4583	while (insn->tm->name && strcasecmp (insn->tm->name,
4584	insn->mnemonic) == 0)
4585	{
4586	insn->opcount = get_operands (insn->operands, line);
4587	if (insn->opcount < 0)
4588	return 0;
4589	if (insn->opcount == 2
4590	&& operands_match (insn, &insn->operands[0], insn->opcount,
4591	insn->tm->operand_types, 2, 2))
4592	{
4593	return 1;
4594	}
4595	++(insn->tm);
4596	}
4597	/* Didn't find a matching parallel; try for a normal insn. */
4598	return 0;
4599	}
4600
4601	/* Parse the second line of a two-line parallel instruction. */
4602
4603	static int
4604	tic54x_parse_parallel_insn_lastline (insn, line)
4605	tic54x_insn *insn;
4606	char *line;
4607	{
4608	int valid_mnemonic = 0;
4609
4610	insn->paropcount = get_operands (insn->paroperands, line);
4611	while (insn->tm->name && strcasecmp (insn->tm->name,
4612	insn->mnemonic) == 0)
4613	{
4614	if (strcasecmp (insn->tm->parname, insn->parmnemonic) == 0)
4615	{
4616	valid_mnemonic = 1;
4617
4618	if (insn->paropcount >= insn->tm->minops
4619	&& insn->paropcount <= insn->tm->maxops
4620	&& operands_match (insn, insn->paroperands,
4621	insn->paropcount,
4622	insn->tm->paroperand_types,
4623	insn->tm->minops, insn->tm->maxops))
4624	return 1;
4625	}
4626	++(insn->tm);
4627	}
4628	if (valid_mnemonic)
4629	as_bad (_("Invalid operand (s) for parallel instruction \"%s\""),
4630	insn->parmnemonic);
4631	else
4632	as_bad (_("Unrecognized parallel instruction combination \"%s \|\| %s\""),
4633	insn->mnemonic, insn->parmnemonic);
4634
4635	return 0;
4636	}
4637
4638	/* If quotes found, return copy of line up to closing quote;
4639	otherwise up until terminator.
4640	If it's a string, pass as-is; otherwise attempt substitution symbol
4641	replacement on the value. */
4642
4643	static char *
4644	subsym_get_arg (line, terminators, str, nosub)
4645	char *line;
4646	char *terminators;
4647	char **str;
4648	int nosub;
4649	{
4650	char *ptr = line;
4651	char *endp;
4652	int is_string = *line == '"';
4653	int is_char = ISDIGIT (*line);
4654
4655	if (is_char)
4656	{
4657	while (ISDIGIT (*ptr))
4658	++ptr;
4659	endp = ptr;
4660	*str = xmalloc (ptr - line + 1);
4661	strncpy (*str, line, ptr - line);
4662	(*str)[ptr - line] = 0;
4663	}
4664	else if (is_string)
4665	{
4666	char *savedp = input_line_pointer;
4667	int len;
4668
4669	input_line_pointer = ptr;
4670	*str = demand_copy_C_string (&len);
4671	endp = input_line_pointer;
4672	input_line_pointer = savedp;
4673
4674	/* Do forced substitutions if requested. */
4675	if (!nosub && **str == ':')
4676	str = subsym_substitute (str, 1);
4677	}
4678	else
4679	{
4680	char *term = terminators;
4681	char *value = NULL;
4682
4683	while (ptr && ptr != *term)
4684	{
4685	if (!*term)
4686	{
4687	term = terminators;
4688	++ptr;
4689	}
4690	else
4691	++term;
4692	}
4693	endp = ptr;
4694	*str = xmalloc (ptr - line + 1);
4695	strncpy (*str, line, ptr - line);
4696	(*str)[ptr - line] = 0;
4697	/* Do simple substitution, if available. */
4698	if (!nosub && (value = subsym_lookup (*str, macro_level)) != NULL)
4699	*str = value;
4700	}
4701
4702	return endp;
4703	}
4704
4705	/* Replace the given substitution string.
4706	We start at the innermost macro level, so that existing locals remain local
4707	Note: we're treating macro args identically to .var's; I don't know if
4708	that's compatible w/TI's assembler. */
4709
4710	static void
4711	subsym_create_or_replace (name, value)
4712	char *name;
4713	char *value;
4714	{
4715	int i;
4716
4717	for (i = macro_level; i > 0; i--)
4718	{
4719	if (hash_find (subsym_hash[i], name))
4720	{
4721	hash_replace (subsym_hash[i], name, value);
4722	return;
4723	}
4724	}
4725	if (hash_find (subsym_hash[0], name))
4726	hash_replace (subsym_hash[0], name, value);
4727	else
4728	hash_insert (subsym_hash[0], name, value);
4729	}
4730
4731	/* Look up the substitution string replacement for the given symbol.
4732	Start with the innermost macro substituion table given and work
4733	outwards. */
4734
4735	static char *
4736	subsym_lookup (name, nest_level)
4737	char *name;
4738	int nest_level;
4739	{
4740	char *value = hash_find (subsym_hash[nest_level], name);
4741
4742	if (value \|\| nest_level == 0)
4743	return value;
4744
4745	return subsym_lookup (name, nest_level - 1);
4746	}
4747
4748	/* Do substitution-symbol replacement on the given line (recursively).
4749	return the argument if no substitution was done
4750
4751	Also look for built-in functions ($func (arg)) and local labels.
4752
4753	If FORCED is set, look for forced substitutions of the form ':SYMBOL:'. */
4754
4755	static char *
4756	subsym_substitute (line, forced)
4757	char * line;
4758	int forced;
4759	{
4760	/* For each apparent symbol, see if it's a substitution symbol, and if so,
4761	replace it in the input. */
4762	char replacement; / current replacement for LINE. */
4763	char head; / Start of line. */
4764	char ptr; / Current examination point. */
4765	int changed = 0; /* Did we make a substitution? */
4766	int eval_line = 0; /* Is this line a .eval/.asg statement? */
4767	int eval_symbol = 0; /* Are we in the middle of the symbol for
4768	.eval/.asg? */
4769	char *eval_end = NULL;
4770	int recurse = 1;
4771	int line_conditional = 0;
4772	char *tmp;
4773
4774	/* Work with a copy of the input line. */
4775	replacement = xmalloc (strlen (line) + 1);
4776	strcpy (replacement, line);
4777
4778	ptr = head = replacement;
4779
4780	/* Flag lines where we might need to replace a single '=' with two;
4781	GAS uses single '=' to assign macro args values, and possibly other
4782	places, so limit what we replace. */
4783	if (strstr (line, ".if")
4784	\|\| strstr (line, ".elseif")
4785	\|\| strstr (line, ".break"))
4786	line_conditional = 1;
4787
4788	/* Watch out for .eval, so that we avoid doing substitution on the
4789	symbol being assigned a value. */
4790	if (strstr (line, ".eval") \|\| strstr (line, ".asg"))
4791	eval_line = 1;
4792
4793	/* If it's a macro definition, don't do substitution on the argument
4794	names. */
4795	if (strstr (line, ".macro"))
4796	return line;
4797
4798	while (!is_end_of_line[(int) *ptr])
4799	{
4800	int current_char = *ptr;
4801
4802	/* Need to update this since LINE may have been modified. */
4803	if (eval_line)
4804	eval_end = strrchr (ptr, ',');
4805
4806	/* Replace triple double quotes with bounding quote/escapes. */
4807	if (current_char == '"' && ptr[1] == '"' && ptr[2] == '"')
4808	{
4809	ptr[1] = '\\';
4810	tmp = strstr (ptr + 2, "\"\"\"");
4811	if (tmp)
4812	tmp[0] = '\\';
4813	changed = 1;
4814	}
4815
4816	/* Replace a single '=' with a '==';
4817	for compatibility with older code only. */
4818	if (line_conditional && current_char == '=')
4819	{
4820	if (ptr[1] == '=')
4821	{
4822	ptr += 2;
4823	continue;
4824	}
4825	*ptr++ = '\0';
4826	tmp = xmalloc (strlen (head) + 2 + strlen (ptr) + 1);
4827	sprintf (tmp, "%s==%s", head, ptr);
4828	/* Continue examining after the '=='. */
4829	ptr = tmp + strlen (head) + 2;
4830	free (replacement);
4831	head = replacement = tmp;
4832	changed = 1;
4833	}
4834
4835	/* Flag when we've reached the symbol part of .eval/.asg. */
4836	if (eval_line && ptr >= eval_end)
4837	eval_symbol = 1;
4838
4839	/* For each apparent symbol, see if it's a substitution symbol, and if
4840	so, replace it in the input. */
4841	if ((forced && current_char == ':')
4842	\|\| (!forced && is_name_beginner (current_char)))
4843	{
4844	char name; / Symbol to be replaced. */
4845	char *savedp = input_line_pointer;
4846	int c;
4847	char *value = NULL;
4848	char tail; / Rest of line after symbol. */
4849
4850	/* Skip the colon. */
4851	if (forced)
4852	++ptr;
4853
4854	name = input_line_pointer = ptr;
4855	c = get_symbol_end ();
4856	/* '?' is not normally part of a symbol, but it IS part of a local
4857	label. */
4858	if (c == '?')
4859	{
4860	*input_line_pointer++ = c;
4861	c = *input_line_pointer;
4862	*input_line_pointer = '\0';
4863	}
4864	/* Avoid infinite recursion; if a symbol shows up a second time for
4865	substitution, leave it as is. */
4866	if (hash_find (subsym_recurse_hash, name) == NULL)
4867	value = subsym_lookup (name, macro_level);
4868	else
4869	as_warn (_("%s symbol recursion stopped at "
4870	"second appearance of '%s'"),
4871	forced ? "Forced substitution" : "Substitution", name);
4872	ptr = tail = input_line_pointer;
4873	input_line_pointer = savedp;
4874
4875	/* Check for local labels; replace them with the appropriate
4876	substitution. */
4877	if ((*name == '$' && ISDIGIT (name[1]) && name[2] == '\0')
4878	\|\| name[strlen (name) - 1] == '?')
4879	{
4880	/* Use an existing identifier for that label if, available, or
4881	create a new, unique identifier. */
4882	value = hash_find (local_label_hash[macro_level], name);
4883	if (value == NULL)
4884	{
4885	char digit[11];
4886	char *namecopy = strcpy (xmalloc (strlen (name) + 1), name);
4887
4888	value = strcpy (xmalloc (strlen (name) + sizeof (digit) + 1),
4889	name);
4890	if (*value != '$')
4891	value[strlen (value) - 1] = '\0';
4892	sprintf (digit, ".%d", local_label_id++);
4893	strcat (value, digit);
4894	hash_insert (local_label_hash[macro_level], namecopy, value);
4895	}
4896	/* Indicate where to continue looking for substitutions. */
4897	ptr = tail;
4898	}
4899	/* Check for built-in subsym and math functions. */
4900	else if (value != NULL && *name == '$')
4901	{
4902	subsym_proc_entry entry = (subsym_proc_entry ) value;
4903	math_proc_entry *math_entry = hash_find (math_hash, name);
4904	char arg1, arg2 = NULL;
4905
4906	*ptr = c;
4907	if (entry == NULL)
4908	{
4909	as_bad (_("Unrecognized substitution symbol function"));
4910	break;
4911	}
4912	else if (*ptr != '(')
4913	{
4914	as_bad (_("Missing '(' after substitution symbol function"));
4915	break;
4916	}
4917	++ptr;
4918	if (math_entry != NULL)
4919	{
4920	float arg1, arg2 = 0;
4921	volatile float fresult;
4922
4923	arg1 = (float) strtod (ptr, &ptr);
4924	if (math_entry->nargs == 2)
4925	{
4926	if (*ptr++ != ',')
4927	{
4928	as_bad (_("Expecting second argument"));
4929	break;
4930	}
4931	arg2 = (float) strtod (ptr, &ptr);
4932	}
4933	fresult = (*math_entry->proc) (arg1, arg2);
4934	value = xmalloc (128);
4935	if (math_entry->int_return)
4936	sprintf (value, "%d", (int) fresult);
4937	else
4938	sprintf (value, "%f", fresult);
4939	if (*ptr++ != ')')
4940	{
4941	as_bad (_("Extra junk in function call, expecting ')'"));
4942	break;
4943	}
4944	/* Don't bother recursing; the replacement isn't a
4945	symbol. */
4946	recurse = 0;
4947	}
4948	else
4949	{
4950	int val;
4951	int arg_type[2] = { *ptr == '"' , 0 };
4952	int ismember = !strcmp (entry->name, "$ismember");
4953
4954	/* Parse one or two args, which must be a substitution
4955	symbol, string or a character-string constant. */
4956	/* For all functions, a string or substitution symbol may be
4957	used, with the following exceptions:
4958	firstch/lastch: 2nd arg must be character constant
4959	ismember: both args must be substitution symbols. */
4960	ptr = subsym_get_arg (ptr, ",)", &arg1, ismember);
4961	if (!arg1)
4962	break;
4963	if (entry->nargs == 2)
4964	{
4965	if (*ptr++ != ',')
4966	{
4967	as_bad (_("Function expects two arguments"));
4968	break;
4969	}
4970	/* Character constants are converted to numerics
4971	by the preprocessor. */
4972	arg_type[1] = (ISDIGIT (ptr)) ? 2 : (ptr == '"');
4973	ptr = subsym_get_arg (ptr, ")", &arg2, ismember);
4974	}
4975	/* Args checking. */
4976	if ((!strcmp (entry->name, "$firstch")
4977	\|\| !strcmp (entry->name, "$lastch"))
4978	&& arg_type[1] != 2)
4979	{
4980	as_bad (_("Expecting character constant argument"));
4981	break;
4982	}
4983	if (ismember
4984	&& (arg_type[0] != 0 \|\| arg_type[1] != 0))
4985	{
4986	as_bad (_("Both arguments must be substitution symbols"));
4987	break;
4988	}
4989	if (*ptr++ != ')')
4990	{
4991	as_bad (_("Extra junk in function call, expecting ')'"));
4992	break;
4993	}
4994	val = (*entry->proc) (arg1, arg2);
4995	value = xmalloc (64);
4996	sprintf (value, "%d", val);
4997	}
4998	/* Fix things up to replace the entire expression, not just the
4999	function name. */
5000	tail = ptr;
5001	c = *tail;
5002	}
5003
5004	if (value != NULL && !eval_symbol)
5005	{
5006	/* Replace the symbol with its string replacement and
5007	continue. Recursively replace VALUE until either no
5008	substitutions are performed, or a substitution that has been
5009	previously made is encountered again.
5010
5011	put the symbol into the recursion hash table so we only
5012	try to replace a symbol once. */
5013	if (recurse)
5014	{
5015	hash_insert (subsym_recurse_hash, name, name);
5016	value = subsym_substitute (value, macro_level > 0);
5017	hash_delete (subsym_recurse_hash, name);
5018	}
5019
5020	/* Temporarily zero-terminate where the symbol started. */
5021	*name = 0;
5022	if (forced)
5023	{
5024	if (c == '(')
5025	{
5026	/* Subscripted substitution symbol -- use just the
5027	indicated portion of the string; the description
5028	kinda indicates that forced substituion is not
5029	supposed to be recursive, but I'm not sure. */
5030	unsigned beg, len = 1; /* default to a single char */
5031	char *newval = strcpy (xmalloc (strlen (value) + 1),
5032	value);
5033
5034	savedp = input_line_pointer;
5035	input_line_pointer = tail + 1;
5036	beg = get_absolute_expression ();
5037	if (beg < 1)
5038	{
5039	as_bad (_("Invalid subscript (use 1 to %d)"),
5040	strlen (value));
5041	break;
5042	}
5043	if (*input_line_pointer == ',')
5044	{
5045	++input_line_pointer;
5046	len = get_absolute_expression ();
5047	if (beg + len > strlen (value))
5048	{
5049	as_bad (_("Invalid length (use 0 to %d"),
5050	strlen (value) - beg);
5051	break;
5052	}
5053	}
5054	newval += beg - 1;
5055	newval[len] = 0;
5056	tail = input_line_pointer;
5057	if (*tail++ != ')')
5058	{
5059	as_bad (_("Missing ')' in subscripted substitution "
5060	"symbol expression"));
5061	break;
5062	}
5063	c = *tail;
5064	input_line_pointer = savedp;
5065
5066	value = newval;
5067	}
5068	name[-1] = 0;
5069	}
5070	tmp = xmalloc (strlen (head) + strlen (value) +
5071	strlen (tail + 1) + 2);
5072	strcpy (tmp, head);
5073	strcat (tmp, value);
5074	/* Make sure forced substitutions are properly terminated. */
5075	if (forced)
5076	{
5077	if (c != ':')
5078	{
5079	as_bad (_("Missing forced substitution terminator ':'"));
5080	break;
5081	}
5082	++tail;
5083	#if 0
5084	/* Try to replace required whitespace
5085	eliminated by the preprocessor; technically, a forced
5086	substitution could come anywhere, even mid-symbol,
5087	e.g. if x is "0", 'sym:x:end' should result in 'sym0end',
5088	but 'sym:x: end' should result in 'sym0 end'.
5089	FIXME -- this should really be fixed in the preprocessor,
5090	but would require several new states;
5091	KEEP_WHITE_AROUND_COLON does part of the job, but isn't
5092	complete. */
5093	if ((is_part_of_name (tail[1])
5094	&& tail[1] != '.'
5095	&& tail[1] != '$')
5096	\|\| tail[1] == '\0' \|\| tail[1] == ',' \|\| tail[1] == '"')
5097	++tail;
5098	else
5099	*tail = ' ';
5100	#endif
5101	}
5102	else
5103	/* Restore the character after the symbol end. */
5104	*tail = c;
5105	strcat (tmp, tail);
5106	/* Continue examining after the replacement value. */
5107	ptr = tmp + strlen (head) + strlen (value);
5108	free (replacement);
5109	head = replacement = tmp;
5110	changed = 1;
5111	}
5112	else
5113	*ptr = c;
5114	}
5115	else
5116	{
5117	++ptr;
5118	}
5119	}
5120
5121	if (changed)
5122	return replacement;
5123	else
5124	return line;
5125	}
5126
5127	/* We use this to handle substitution symbols
5128	hijack input_line_pointer, replacing it with our substituted string.
5129
5130	.sslist should enable listing the line after replacements are made...
5131
5132	returns the new buffer limit. */
5133
5134	void
5135	tic54x_start_line_hook ()
5136	{
5137	char line, endp;
5138	char *replacement = NULL;
5139
5140	/* Work with a copy of the input line, including EOL char. */
5141	endp = input_line_pointer;
5142	while (!is_end_of_line[(int) *endp++])
5143	;
5144	line = xmalloc (endp - input_line_pointer + 1);
5145	strncpy (line, input_line_pointer, endp - input_line_pointer + 1);
5146	line[endp - input_line_pointer] = 0;
5147
5148	/* Scan ahead for parallel insns. */
5149	parallel_on_next_line_hint = next_line_shows_parallel (endp + 1);
5150
5151	/* If within a macro, first process forced replacements. */
5152	if (macro_level > 0)
5153	replacement = subsym_substitute (line, 1);
5154	else
5155	replacement = line;
5156	replacement = subsym_substitute (replacement, 0);
5157
5158	if (replacement != line)
5159	{
5160	char *tmp = replacement;
5161	char *comment = strchr (replacement, ';');
5162	char endc = replacement[strlen (replacement) - 1];
5163
5164	/* Clean up the replacement; we'd prefer to have this done by the
5165	standard preprocessing equipment (maybe do_scrub_chars?)
5166	but for now, do a quick-and-dirty. */
5167	if (comment != NULL)
5168	{
5169	comment[0] = endc;
5170	comment[1] = 0;
5171	--comment;
5172	}
5173	else
5174	comment = replacement + strlen (replacement) - 1;
5175
5176	/* Trim trailing whitespace. */
5177	while (ISSPACE (*comment))
5178	{
5179	comment[0] = endc;
5180	comment[1] = 0;
5181	--comment;
5182	}
5183
5184	/* Compact leading whitespace. */
5185	while (ISSPACE (tmp[0]) && ISSPACE (tmp[1]))
5186	++tmp;
5187
5188	input_line_pointer = endp;
5189	input_scrub_insert_line (tmp);
5190	free (replacement);
5191	free (line);
5192	/* Keep track of whether we've done a substitution. */
5193	substitution_line = 1;
5194	}
5195	else
5196	{
5197	/* No change. */
5198	free (line);
5199	substitution_line = 0;
5200	}
5201	}
5202
5203	/* This is the guts of the machine-dependent assembler. STR points to a
5204	machine dependent instruction. This function is supposed to emit
5205	the frags/bytes it assembles to. */
5206	void
5207	md_assemble (line)
5208	char *line;
5209	{
5210	static int repeat_slot = 0;
5211	static int delay_slots = 0; /* How many delay slots left to fill? */
5212	static int is_parallel = 0;
5213	static tic54x_insn insn;
5214	char *lptr;
5215	char *savedp = input_line_pointer;
5216	int c;
5217
5218	input_line_pointer = line;
5219	c = get_symbol_end ();
5220
5221	if (cpu == VNONE)
5222	cpu = V542;
5223	if (address_mode_needs_set)
5224	{
5225	set_address_mode (amode);
5226	address_mode_needs_set = 0;
5227	}
5228	if (cpu_needs_set)
5229	{
5230	set_cpu (cpu);
5231	cpu_needs_set = 0;
5232	}
5233	assembly_begun = 1;
5234
5235	if (is_parallel)
5236	{
5237	is_parallel = 0;
5238
5239	strcpy (insn.parmnemonic, line);
5240	lptr = input_line_pointer;
5241	*lptr = c;
5242	input_line_pointer = savedp;
5243
5244	if (tic54x_parse_parallel_insn_lastline (&insn, lptr))
5245	{
5246	int words = build_insn (&insn);
5247
5248	if (delay_slots != 0)
5249	{
5250	if (words > delay_slots)
5251	{
5252	as_bad (_("Instruction does not fit in available delay "
5253	"slots (%d-word insn, %d slots left)"),
5254	words, delay_slots);
5255	delay_slots = 0;
5256	return;
5257	}
5258	delay_slots -= words;
5259	}
5260	}
5261	return;
5262	}
5263
5264	memset (&insn, 0, sizeof (insn));
5265	strcpy (insn.mnemonic, line);
5266	lptr = input_line_pointer;
5267	*lptr = c;
5268	input_line_pointer = savedp;
5269
5270	/* See if this line is part of a parallel instruction; if so, either this
5271	line or the next line will have the "\|\|" specifier preceding the
5272	mnemonic, and we look for it in the parallel insn hash table. */
5273	if (strstr (line, "\|\|") != NULL \|\| parallel_on_next_line_hint)
5274	{
5275	char *tmp = strstr (line, "\|\|");
5276	if (tmp != NULL)
5277	*tmp = '\0';
5278
5279	if (tic54x_parse_parallel_insn_firstline (&insn, lptr))
5280	{
5281	is_parallel = 1;
5282	/* If the parallel part is on the same line, process it now,
5283	otherwise let the assembler pick up the next line for us. */
5284	if (tmp != NULL)
5285	{
5286	while (ISSPACE (tmp[2]))
5287	++tmp;
5288	md_assemble (tmp + 2);
5289	}
5290	}
5291	else
5292	{
5293	as_bad (_("Unrecognized parallel instruction '%s'"), line);
5294	}
5295	return;
5296	}
5297
5298	if (tic54x_parse_insn (&insn, lptr))
5299	{
5300	int words;
5301
5302	if ((insn.tm->flags & FL_LP)
5303	&& cpu != V545LP && cpu != V546LP)
5304	{
5305	as_bad (_("Instruction '%s' requires an LP cpu version"),
5306	insn.tm->name);
5307	return;
5308	}
5309	if ((insn.tm->flags & FL_FAR)
5310	&& amode != far_mode)
5311	{
5312	as_bad (_("Instruction '%s' requires far mode addressing"),
5313	insn.tm->name);
5314	return;
5315	}
5316
5317	words = build_insn (&insn);
5318
5319	/* Is this instruction in a delay slot? */
5320	if (delay_slots)
5321	{
5322	if (words > delay_slots)
5323	{
5324	as_warn (_("Instruction does not fit in available delay "
5325	"slots (%d-word insn, %d slots left). "
5326	"Resulting behavior is undefined."),
5327	words, delay_slots);
5328	delay_slots = 0;
5329	return;
5330	}
5331	/* Branches in delay slots are not allowed. */
5332	if (insn.tm->flags & FL_BMASK)
5333	{
5334	as_warn (_("Instructions which cause PC discontinuity are not "
5335	"allowed in a delay slot. "
5336	"Resulting behavior is undefined."));
5337	}
5338	delay_slots -= words;
5339	}
5340
5341	/* Is this instruction the target of a repeat? */
5342	if (repeat_slot)
5343	{
5344	if (insn.tm->flags & FL_NR)
5345	as_warn (_("'%s' is not repeatable. "
5346	"Resulting behavior is undefined."),
5347	insn.tm->name);
5348	else if (insn.is_lkaddr)
5349	as_warn (_("Instructions using long offset modifiers or absolute "
5350	"addresses are not repeatable. "
5351	"Resulting behavior is undefined."));
5352	repeat_slot = 0;
5353	}
5354
5355	/* Make sure we check the target of a repeat instruction. */
5356	if (insn.tm->flags & B_REPEAT)
5357	{
5358	repeat_slot = 1;
5359	/* FIXME -- warn if repeat_slot == 1 at EOF. */
5360	}
5361	/* Make sure we check our delay slots for validity. */
5362	if (insn.tm->flags & FL_DELAY)
5363	{
5364	delay_slots = 2;
5365	/* FIXME -- warn if delay_slots != 0 at EOF. */
5366	}
5367	}
5368	}
5369
5370	/* Do a final adjustment on the symbol table; in this case, make sure we have
5371	a ".file" symbol. */
5372
5373	void
5374	tic54x_adjust_symtab ()
5375	{
5376	if (symbol_rootP == NULL
5377	\|\| S_GET_STORAGE_CLASS (symbol_rootP) != C_FILE)
5378	{
5379	char *filename;
5380	unsigned lineno;
5381	as_where (&filename, &lineno);
5382	c_dot_file_symbol (filename);
5383	}
5384	}
5385
5386	/* In order to get gas to ignore any \| chars at the start of a line,
5387	this function returns true if a \| is found in a line.
5388	This lets us process parallel instructions, which span two lines. */
5389
5390	int
5391	tic54x_unrecognized_line (int c)
5392	{
5393	return c == PARALLEL_SEPARATOR;
5394	}
5395
5396	/* Watch for local labels of the form $[0-9] and [_a-zA-Z][_a-zA-Z0-9]*?
5397	Encode their names so that only we see them and can map them to the
5398	appropriate places.
5399	FIXME -- obviously this isn't done yet. These locals still show up in the
5400	symbol table. */
5401	void
5402	tic54x_define_label (sym)
5403	symbolS *sym;
5404	{
5405	#if 0
5406	static int local_label_count = 0;
5407	const char *name = S_GET_NAME (sym);
5408	#endif
5409
5410	/* Just in case we need this later; note that this is not necessarily the
5411	same thing as line_label...
5412	When aligning or assigning labels to fields, sometimes the label is
5413	assigned other than the address at which the label appears.
5414	FIXME -- is this really needed? I think all the proper label assignment
5415	is done in tic54x_cons. */
5416	last_label_seen = sym;
5417	}
5418
5419	/* Try to parse something that normal parsing failed at. */
5420
5421	symbolS *
5422	tic54x_undefined_symbol (name)
5423	char *name;
5424	{
5425	symbol *sym;
5426
5427	/* Not sure how to handle predefined symbols. */
5428	if ((sym = (symbol *) hash_find (cc_hash, name)) != NULL \|\|
5429	(sym = (symbol *) hash_find (cc2_hash, name)) != NULL \|\|
5430	(sym = (symbol *) hash_find (cc3_hash, name)) != NULL \|\|
5431	(sym = (symbol *) hash_find (misc_symbol_hash, name)) != NULL \|\|
5432	(sym = (symbol *) hash_find (sbit_hash, name)) != NULL)
5433	{
5434	return symbol_new (name, reg_section,
5435	(valueT) sym->value,
5436	&zero_address_frag);
5437	}
5438
5439	if ((sym = (symbol *) hash_find (reg_hash, name)) != NULL \|\|
5440	(sym = (symbol *) hash_find (mmreg_hash, name)) != NULL \|\|
5441	!strcasecmp (name, "a") \|\| !strcasecmp (name, "b"))
5442	{
5443	return symbol_new (name, reg_section,
5444	(valueT) sym ? sym->value : 0,
5445	&zero_address_frag);
5446	}
5447
5448	return NULL;
5449	}
5450
5451	/* Parse a name in an expression before the expression parser takes a stab at
5452	it. */
5453
5454	int
5455	tic54x_parse_name (name, exp)
5456	char *name ATTRIBUTE_UNUSED;
5457	expressionS *exp ATTRIBUTE_UNUSED;
5458	{
5459	#if 0
5460	symbol sym = (symbol ) hash_find (mmreg_hash, name);
5461
5462	/* If it's a MMREG, replace it with its constant value. */
5463	if (sym)
5464	{
5465	exp->X_op = O_constant;
5466	exp->X_add_number = sym->value;
5467	return 1;
5468	}
5469	#endif
5470	return 0;
5471	}
5472
5473	char *
5474	md_atof (type, literalP, sizeP)
5475	int type;
5476	char *literalP;
5477	int *sizeP;
5478	{
5479	#define MAX_LITTLENUMS 2
5480	LITTLENUM_TYPE words[MAX_LITTLENUMS];
5481	LITTLENUM_TYPE *word;
5482	/* Only one precision on the c54x. */
5483	int prec = 2;
5484	char *t = atof_ieee (input_line_pointer, type, words);
5485	if (t)
5486	input_line_pointer = t;
5487	*sizeP = 4;
5488
5489	/* Target data is little-endian, but floats are stored
5490	big-"word"ian. ugh. */
5491	for (word = words; prec--;)
5492	{
5493	md_number_to_chars (literalP, (long) (*word++), sizeof (LITTLENUM_TYPE));
5494	literalP += sizeof (LITTLENUM_TYPE);
5495	}
5496
5497	return 0;
5498	}
5499
5500	arelent *
5501	tc_gen_reloc (section, fixP)
5502	asection *section;
5503	fixS *fixP;
5504	{
5505	arelent *rel;
5506	bfd_reloc_code_real_type code = fixP->fx_r_type;
5507	asymbol *sym = symbol_get_bfdsym (fixP->fx_addsy);
5508
5509	rel = (arelent *) xmalloc (sizeof (arelent));
5510	rel->sym_ptr_ptr = (asymbol *) xmalloc (sizeof (asymbol ));
5511	*rel->sym_ptr_ptr = sym;
5512	/* We assume that all rel->address are host byte offsets. */
5513	rel->address = fixP->fx_frag->fr_address + fixP->fx_where;
5514	rel->address /= OCTETS_PER_BYTE;
5515	rel->howto = bfd_reloc_type_lookup (stdoutput, code);
5516	if (!strcmp (sym->name, section->name))
5517	rel->howto += HOWTO_BANK;
5518
5519	if (!rel->howto)
5520	{
5521	const char *name = S_GET_NAME (fixP->fx_addsy);
5522	if (name == NULL)
5523	name = "<unknown>";
5524	as_fatal ("Cannot generate relocation type for symbol %s, code %s",
5525	name, bfd_get_reloc_code_name (code));
5526	return NULL;
5527	}
5528	return rel;
5529	}
5530
5531	/* Handle cons expressions. */
5532
5533	void
5534	tic54x_cons_fix_new (frag, where, octets, exp)
5535	fragS *frag;
5536	int where;
5537	int octets;
5538	expressionS *exp;
5539	{
5540	bfd_reloc_code_real_type r;
5541
5542	switch (octets)
5543	{
5544	default:
5545	as_bad (_("Unsupported relocation size %d"), octets);
5546	r = BFD_RELOC_TIC54X_16_OF_23;
5547	break;
5548	case 2:
5549	r = BFD_RELOC_TIC54X_16_OF_23;
5550	break;
5551	case 4:
5552	/* TI assembler always uses this, regardless of addressing mode. */
5553	if (emitting_long)
5554	r = BFD_RELOC_TIC54X_23;
5555	else
5556	/* We never want to directly generate this; this is provided for
5557	stabs support only. */
5558	r = BFD_RELOC_32;
5559	break;
5560	}
5561	fix_new_exp (frag, where, octets, exp, 0, r);
5562	}
5563
5564	/* Attempt to simplify or even eliminate a fixup.
5565	To indicate that a fixup has been eliminated, set fixP->fx_done.
5566
5567	If fixp->fx_addsy is non-NULL, we'll have to generate a reloc entry. */
5568
5569	void
5570	md_apply_fix3 (fixP, valP, seg)
5571	fixS *fixP;
5572	valueT * valP;
5573	segT seg ATTRIBUTE_UNUSED;
5574	{
5575	char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
5576	valueT val = * valP;
5577
5578	switch (fixP->fx_r_type)
5579	{
5580	default:
5581	as_fatal ("Bad relocation type: 0x%02x", fixP->fx_r_type);
5582	return;
5583	case BFD_RELOC_TIC54X_MS7_OF_23:
5584	val = (val >> 16) & 0x7F;
5585	/* Fall through. */
5586	case BFD_RELOC_TIC54X_16_OF_23:
5587	case BFD_RELOC_16:
5588	bfd_put_16 (stdoutput, val, buf);
5589	/* Indicate what we're actually writing, so that we don't get warnings
5590	about exceeding available space. */
5591	*valP = val & 0xFFFF;
5592	break;
5593	case BFD_RELOC_TIC54X_PARTLS7:
5594	bfd_put_16 (stdoutput,
5595	(bfd_get_16 (stdoutput, buf) & 0xFF80) \| (val & 0x7F),
5596	buf);
5597	/* Indicate what we're actually writing, so that we don't get warnings
5598	about exceeding available space. */
5599	*valP = val & 0x7F;
5600	break;
5601	case BFD_RELOC_TIC54X_PARTMS9:
5602	/* TI assembler doesn't shift its encoding for relocatable files, and is
5603	thus incompatible with this implementation's relocatable files. */
5604	bfd_put_16 (stdoutput,
5605	(bfd_get_16 (stdoutput, buf) & 0xFE00) \| (val >> 7),
5606	buf);
5607	break;
5608	case BFD_RELOC_32:
5609	case BFD_RELOC_TIC54X_23:
5610	bfd_put_32 (stdoutput,
5611	(bfd_get_32 (stdoutput, buf) & 0xFF800000) \| val,
5612	buf);
5613	break;
5614	}
5615
5616	if (fixP->fx_addsy == NULL && fixP->fx_pcrel == 0)
5617	fixP->fx_done = 1;
5618	}
5619
5620	/* This is our chance to record section alignment
5621	don't need to do anything here, since BFD does the proper encoding. */
5622
5623	valueT
5624	md_section_align (segment, section_size)
5625	segT segment ATTRIBUTE_UNUSED;
5626	valueT section_size;
5627	{
5628	return section_size;
5629	}
5630
5631	long
5632	md_pcrel_from (fixP)
5633	fixS *fixP ATTRIBUTE_UNUSED;
5634	{
5635	return 0;
5636	}
5637
5638	#if defined OBJ_COFF
5639
5640	short
5641	tc_coff_fix2rtype (fixP)
5642	fixS *fixP;
5643	{
5644	return (fixP->fx_r_type);
5645	}
5646
5647	#endif /* OBJ_COFF */
5648
5649	/* Mostly little-endian, but longwords (4 octets) get MS word stored
5650	first. */
5651
5652	void
5653	tic54x_number_to_chars (buf, val, n)
5654	char *buf;
5655	valueT val;
5656	int n;
5657	{
5658	if (n != 4)
5659	number_to_chars_littleendian (buf, val, n);
5660	else
5661	{
5662	number_to_chars_littleendian (buf , val >> 16 , 2);
5663	number_to_chars_littleendian (buf + 2, val & 0xFFFF, 2);
5664	}
5665	}
5666
5667	int
5668	tic54x_estimate_size_before_relax (frag, seg)
5669	fragS *frag ATTRIBUTE_UNUSED;
5670	segT seg ATTRIBUTE_UNUSED;
5671	{
5672	return 0;
5673	}
5674
5675	/* We use this to handle bit allocations which we couldn't handle before due
5676	to symbols being in different frags. return number of octets added. */
5677
5678	int
5679	tic54x_relax_frag (frag, stretch)
5680	fragS *frag;
5681	long stretch ATTRIBUTE_UNUSED;
5682	{
5683	symbolS *sym = frag->fr_symbol;
5684	int growth = 0;
5685	int i;
5686
5687	if (sym != NULL)
5688	{
5689	struct bit_info bi = (struct bit_info ) frag->fr_opcode;
5690	int bit_offset = frag_bit_offset (frag_prev (frag, bi->seg), bi->seg);
5691	int size = S_GET_VALUE (sym);
5692	fragS *prev_frag = bit_offset_frag (frag_prev (frag, bi->seg), bi->seg);
5693	int available = 16 - bit_offset;
5694
5695	if (symbol_get_frag (sym) != &zero_address_frag
5696	\|\| S_IS_COMMON (sym)
5697	\|\| !S_IS_DEFINED (sym))
5698	as_bad_where (frag->fr_file, frag->fr_line,
5699	_("non-absolute value used with .space/.bes"));
5700
5701	if (size < 0)
5702	{
5703	as_warn (_("negative value ignored in %s"),
5704	bi->type == TYPE_SPACE ? ".space" :
5705	bi->type == TYPE_BES ? ".bes" : ".field");
5706	growth = 0;
5707	frag->tc_frag_data = frag->fr_fix = 0;
5708	return 0;
5709	}
5710
5711	if (bi->type == TYPE_FIELD)
5712	{
5713	/* Bit fields of 16 or larger will have already been handled. */
5714	if (bit_offset != 0 && available >= size)
5715	{
5716	char *p = prev_frag->fr_literal;
5717
5718	valueT value = bi->value;
5719	value <<= available - size;
5720	value \|= ((unsigned short) p[1] << 8) \| p[0];
5721	md_number_to_chars (p, value, 2);
5722	if ((prev_frag->tc_frag_data += size) == 16)
5723	prev_frag->tc_frag_data = 0;
5724	if (bi->sym)
5725	symbol_set_frag (bi->sym, prev_frag);
5726	/* This frag is no longer used. */
5727	growth = -frag->fr_fix;
5728	frag->fr_fix = 0;
5729	frag->tc_frag_data = 0;
5730	}
5731	else
5732	{
5733	char *p = frag->fr_literal;
5734
5735	valueT value = bi->value << (16 - size);
5736	md_number_to_chars (p, value, 2);
5737	if ((frag->tc_frag_data = size) == 16)
5738	frag->tc_frag_data = 0;
5739	growth = 0;
5740	}
5741	}
5742	else
5743	{
5744	if (bit_offset != 0 && bit_offset < 16)
5745	{
5746	if (available >= size)
5747	{
5748	if ((prev_frag->tc_frag_data += size) == 16)
5749	prev_frag->tc_frag_data = 0;
5750	if (bi->sym)
5751	symbol_set_frag (bi->sym, prev_frag);
5752	/* This frag is no longer used. */
5753	growth = -frag->fr_fix;
5754	frag->fr_fix = 0;
5755	frag->tc_frag_data = 0;
5756	goto getout;
5757	}
5758	if (bi->type == TYPE_SPACE && bi->sym)
5759	symbol_set_frag (bi->sym, prev_frag);
5760	size -= available;
5761	}
5762	growth = (size + 15) / 16 * OCTETS_PER_BYTE - frag->fr_fix;
5763	for (i = 0; i < growth; i++)
5764	frag->fr_literal[i] = 0;
5765	frag->fr_fix = growth;
5766	frag->tc_frag_data = size % 16;
5767	/* Make sure any BES label points to the LAST word allocated. */
5768	if (bi->type == TYPE_BES && bi->sym)
5769	S_SET_VALUE (bi->sym, frag->fr_fix / OCTETS_PER_BYTE - 1);
5770	}
5771	getout:
5772	frag->fr_symbol = 0;
5773	frag->fr_opcode = 0;
5774	free ((void *) bi);
5775	}
5776	return growth;
5777	}
5778
5779	void
5780	tic54x_convert_frag (abfd, seg, frag)
5781	bfd *abfd ATTRIBUTE_UNUSED;
5782	segT seg ATTRIBUTE_UNUSED;
5783	fragS *frag;
5784	{
5785	/* Offset is in bytes. */
5786	frag->fr_offset = (frag->fr_next->fr_address
5787	- frag->fr_address
5788	- frag->fr_fix) / frag->fr_var;
5789	if (frag->fr_offset < 0)
5790	{
5791	as_bad_where (frag->fr_file, frag->fr_line,
5792	_("attempt to .space/.bes backwards? (%ld)"),
5793	(long) frag->fr_offset);
5794	}
5795	frag->fr_type = rs_space;
5796	}
5797
5798	/* We need to avoid having labels defined for certain directives/pseudo-ops
5799	since once the label is defined, it's in the symbol table for good. TI
5800	syntax puts the symbol before the pseudo (which is kinda like MRI syntax,
5801	I guess, except I've never seen a definition of MRI syntax).
5802
5803	C is the character that used to be at *REST, which points to the end of the
5804	label.
5805
5806	Don't allow labels to start with '.' */
5807
5808	int
5809	tic54x_start_label (c, rest)
5810	int c;
5811	char *rest;
5812	{
5813	/* If within .struct/.union, no auto line labels, please. */
5814	if (current_stag != NULL)
5815	return 0;
5816
5817	/* Disallow labels starting with "." */
5818	if (c != ':')
5819	{
5820	char *label = rest;
5821
5822	while (!is_end_of_line[(int) label[-1]])
5823	--label;
5824	if (*label == '.')
5825	{
5826	as_bad (_("Invalid label '%s'"), label);
5827	return 0;
5828	}
5829	}
5830
5831	if (is_end_of_line[(int) c])
5832	return 1;
5833
5834	if (ISSPACE (c))
5835	while (ISSPACE (c = *++rest))
5836	;
5837	if (c == '.')
5838	{
5839	/* Don't let colon () define a label for any of these... */
5840	return (strncasecmp (rest, ".tag", 4) != 0 \|\| !ISSPACE (rest[4]))
5841	&& (strncasecmp (rest, ".struct", 7) != 0 \|\| !ISSPACE (rest[7]))
5842	&& (strncasecmp (rest, ".union", 6) != 0 \|\| !ISSPACE (rest[6]))
5843	&& (strncasecmp (rest, ".macro", 6) != 0 \|\| !ISSPACE (rest[6]))
5844	&& (strncasecmp (rest, ".set", 4) != 0 \|\| !ISSPACE (rest[4]))
5845	&& (strncasecmp (rest, ".equ", 4) != 0 \|\| !ISSPACE (rest[4]));
5846	}
5847
5848	return 1;
5849	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: