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