]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - gas/config/tc-tic54x.c
projects / thirdparty / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* config/atof-tahoe.c: Fix comment typos.
[thirdparty/binutils-gdb.git] / gas / config / tc-tic54x.c
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 addressing 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 Uninitialized 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 occurrence 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 structure 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 substitution 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 substitution 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 }
A mirror of the official binutils-gdb repository