1 /* tc-tic4x.c -- Assemble for the Texas Instruments TMS320C[34]x.
2 Copyright (C) 1997-2020 Free Software Foundation, Inc.
4 Contributed by Michael P. Hayes (m.hayes@elec.canterbury.ac.nz)
6 This file is part of GAS, the GNU Assembler.
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 3, or (at your option)
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.
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
20 the Free Software Foundation, 51 Franklin Street - Fifth Floor,
21 Boston, MA 02110-1301, USA. */
26 o .align cannot handle fill-data-width larger than 0xFF/8-bits. It
27 should be possible to define a 32-bits pattern.
29 o .align: Implement a 'bu' insn if the number of nop's exceeds 4
30 within the align frag. if(fragsize>4words) insert bu fragend+1
33 o .usect if has symbol on previous line not implemented
35 o .sym, .eos, .stag, .etag, .member not implemented
37 o Evaluation of constant floating point expressions (expr.c needs
40 o Support 'abc' constants (that is 0x616263). */
43 #include "safe-ctype.h"
44 #include "opcode/tic4x.h"
47 /* OK, we accept a syntax similar to the other well known C30
48 assembly tools. With TIC4X_ALT_SYNTAX defined we are more
49 flexible, allowing a more Unix-like syntax: `%' in front of
50 register names, `#' in front of immediate constants, and
51 not requiring `@' in front of direct addresses. */
53 #define TIC4X_ALT_SYNTAX
55 /* Handle of the inst mnemonic hash table. */
56 static htab_t tic4x_op_hash
= NULL
;
58 /* Handle asg pseudo. */
59 static htab_t tic4x_asg_hash
= NULL
;
61 static unsigned int tic4x_cpu
= 0; /* Default to TMS320C40. */
62 static unsigned int tic4x_revision
= 0; /* CPU revision */
63 static unsigned int tic4x_idle2
= 0; /* Idle2 support */
64 static unsigned int tic4x_lowpower
= 0; /* Lowpower support */
65 static unsigned int tic4x_enhanced
= 0; /* Enhanced opcode support */
66 static unsigned int tic4x_big_model
= 0; /* Default to small memory model. */
67 static unsigned int tic4x_reg_args
= 0; /* Default to args passed on stack. */
68 static unsigned long tic4x_oplevel
= 0; /* Opcode level */
70 #define OPTION_CPU 'm'
71 #define OPTION_BIG (OPTION_MD_BASE + 1)
72 #define OPTION_SMALL (OPTION_MD_BASE + 2)
73 #define OPTION_MEMPARM (OPTION_MD_BASE + 3)
74 #define OPTION_REGPARM (OPTION_MD_BASE + 4)
75 #define OPTION_IDLE2 (OPTION_MD_BASE + 5)
76 #define OPTION_LOWPOWER (OPTION_MD_BASE + 6)
77 #define OPTION_ENHANCED (OPTION_MD_BASE + 7)
78 #define OPTION_REV (OPTION_MD_BASE + 8)
80 const char *md_shortopts
= "bm:prs";
81 struct option md_longopts
[] =
83 { "mcpu", required_argument
, NULL
, OPTION_CPU
},
84 { "mdsp", required_argument
, NULL
, OPTION_CPU
},
85 { "mbig", no_argument
, NULL
, OPTION_BIG
},
86 { "msmall", no_argument
, NULL
, OPTION_SMALL
},
87 { "mmemparm", no_argument
, NULL
, OPTION_MEMPARM
},
88 { "mregparm", no_argument
, NULL
, OPTION_REGPARM
},
89 { "midle2", no_argument
, NULL
, OPTION_IDLE2
},
90 { "mlowpower", no_argument
, NULL
, OPTION_LOWPOWER
},
91 { "menhanced", no_argument
, NULL
, OPTION_ENHANCED
},
92 { "mrev", required_argument
, NULL
, OPTION_REV
},
93 { NULL
, no_argument
, NULL
, 0 }
96 size_t md_longopts_size
= sizeof (md_longopts
);
101 M_UNKNOWN
, M_IMMED
, M_DIRECT
, M_REGISTER
, M_INDIRECT
,
102 M_IMMED_F
, M_PARALLEL
, M_HI
106 typedef struct tic4x_operand
108 tic4x_addr_mode_t mode
; /* Addressing mode. */
109 expressionS expr
; /* Expression. */
110 int disp
; /* Displacement for indirect addressing. */
111 int aregno
; /* Aux. register number. */
112 LITTLENUM_TYPE fwords
[MAX_LITTLENUMS
]; /* Float immed. number. */
116 typedef struct tic4x_insn
118 char name
[TIC4X_NAME_MAX
]; /* Mnemonic of instruction. */
119 unsigned int in_use
; /* True if in_use. */
120 unsigned int parallel
; /* True if parallel instruction. */
121 unsigned int nchars
; /* This is always 4 for the C30. */
122 unsigned long opcode
; /* Opcode number. */
123 expressionS exp
; /* Expression required for relocation. */
124 /* Relocation type required. */
125 bfd_reloc_code_real_type reloc
;
126 int pcrel
; /* True if relocation PC relative. */
127 char *pname
; /* Name of instruction in parallel. */
128 unsigned int num_operands
; /* Number of operands in total. */
129 tic4x_inst_t
*inst
; /* Pointer to first template. */
130 tic4x_operand_t operands
[TIC4X_OPERANDS_MAX
];
134 static tic4x_insn_t the_insn
; /* Info about our instruction. */
135 static tic4x_insn_t
*insn
= &the_insn
;
137 static void tic4x_asg (int);
138 static void tic4x_bss (int);
139 static void tic4x_globl (int);
140 static void tic4x_cons (int);
141 static void tic4x_stringer (int);
142 static void tic4x_eval (int);
143 static void tic4x_newblock (int);
144 static void tic4x_sect (int);
145 static void tic4x_set (int);
146 static void tic4x_usect (int);
147 static void tic4x_version (int);
153 {"align", s_align_bytes
, 32},
154 {"ascii", tic4x_stringer
, 1},
155 {"asciz", tic4x_stringer
, 0},
156 {"asg", tic4x_asg
, 0},
157 {"block", s_space
, 4},
158 {"byte", tic4x_cons
, 1},
159 {"bss", tic4x_bss
, 0},
160 {"copy", s_include
, 0},
161 {"def", tic4x_globl
, 0},
162 {"equ", tic4x_set
, 0},
163 {"eval", tic4x_eval
, 0},
164 {"global", tic4x_globl
, 0},
165 {"globl", tic4x_globl
, 0},
166 {"hword", tic4x_cons
, 2},
167 {"ieee", float_cons
, 'i'},
168 {"int", tic4x_cons
, 4}, /* .int allocates 4 bytes. */
169 {"ldouble", float_cons
, 'e'},
170 {"newblock", tic4x_newblock
, 0},
171 {"ref", s_ignore
, 0}, /* All undefined treated as external. */
172 {"set", tic4x_set
, 0},
173 {"sect", tic4x_sect
, 1}, /* Define named section. */
174 {"space", s_space
, 4},
175 {"string", tic4x_stringer
, 0},
176 {"usect", tic4x_usect
, 0}, /* Reserve space in uninit. named sect. */
177 {"version", tic4x_version
, 0},
178 {"word", tic4x_cons
, 4}, /* .word allocates 4 bytes. */
179 {"xdef", tic4x_globl
, 0},
183 int md_short_jump_size
= 4;
184 int md_long_jump_size
= 4;
186 /* This array holds the chars that always start a comment. If the
187 pre-processor is disabled, these aren't very useful. */
188 #ifdef TIC4X_ALT_SYNTAX
189 const char comment_chars
[] = ";!";
191 const char comment_chars
[] = ";";
194 /* This array holds the chars that only start a comment at the beginning of
195 a line. If the line seems to have the form '# 123 filename'
196 .line and .file directives will appear in the pre-processed output.
197 Note that input_file.c hand checks for '#' at the beginning of the
198 first line of the input file. This is because the compiler outputs
199 #NO_APP at the beginning of its output.
200 Also note that comments like this one will always work. */
201 const char line_comment_chars
[] = "#*";
203 /* We needed an unused char for line separation to work around the
204 lack of macros, using sed and such. */
205 const char line_separator_chars
[] = "&";
207 /* Chars that can be used to separate mant from exp in floating point nums. */
208 const char EXP_CHARS
[] = "eE";
210 /* Chars that mean this number is a floating point constant. */
213 const char FLT_CHARS
[] = "fFilsS";
215 /* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
216 changed in read.c. Ideally it shouldn't have to know about it at
217 all, but nothing is ideal around here. */
219 /* Flonums returned here. */
220 extern FLONUM_TYPE generic_floating_point_number
;
222 /* Precision in LittleNums. */
223 #define MAX_PRECISION (4) /* It's a bit overkill for us, but the code
225 #define S_PRECISION (1) /* Short float constants 16-bit. */
226 #define F_PRECISION (2) /* Float and double types 32-bit. */
227 #define E_PRECISION (4) /* Extended precision, 64-bit (real 40-bit). */
230 /* Turn generic_floating_point_number into a real short/float/double. */
232 tic4x_gen_to_words (FLONUM_TYPE flonum
, LITTLENUM_TYPE
*words
, int precision
)
234 int return_value
= 0;
235 LITTLENUM_TYPE
*p
; /* Littlenum pointer. */
236 int mantissa_bits
; /* Bits in mantissa field. */
237 int exponent_bits
; /* Bits in exponent field. */
239 unsigned int sone
; /* Scaled one. */
240 unsigned int sfract
; /* Scaled fraction. */
241 unsigned int smant
; /* Scaled mantissa. */
243 unsigned int mover
; /* Mantissa overflow bits */
244 unsigned int rbit
; /* Round bit. */
245 int shift
; /* Shift count. */
247 /* NOTE: Svein Seldal <Svein@dev.seldal.com>
248 The code in this function is altered slightly to support floats
249 with 31-bits mantissas, thus the documentation below may be a
250 little bit inaccurate.
252 By Michael P. Hayes <m.hayes@elec.canterbury.ac.nz>
253 Here is how a generic floating point number is stored using
254 flonums (an extension of bignums) where p is a pointer to an
257 For example 2e-3 is stored with exp = -4 and
264 with low = &bits[2], high = &bits[5], and leader = &bits[5].
266 This number can be written as
267 0x0083126e978d4fde.00000000 * 65536**-4 or
268 0x0.0083126e978d4fde * 65536**0 or
269 0x0.83126e978d4fde * 2**-8 = 2e-3
271 Note that low points to the 65536**0 littlenum (bits[2]) and
272 leader points to the most significant non-zero littlenum
275 TMS320C3X floating point numbers are a bit of a strange beast.
276 The 32-bit flavour has the 8 MSBs representing the exponent in
277 twos complement format (-128 to +127). There is then a sign bit
278 followed by 23 bits of mantissa. The mantissa is expressed in
279 twos complement format with the binary point after the most
280 significant non sign bit. The bit after the binary point is
281 suppressed since it is the complement of the sign bit. The
282 effective mantissa is thus 24 bits. Zero is represented by an
285 The 16-bit flavour has the 4 MSBs representing the exponent in
286 twos complement format (-8 to +7). There is then a sign bit
287 followed by 11 bits of mantissa. The mantissa is expressed in
288 twos complement format with the binary point after the most
289 significant non sign bit. The bit after the binary point is
290 suppressed since it is the complement of the sign bit. The
291 effective mantissa is thus 12 bits. Zero is represented by an
292 exponent of -8. For example,
294 number norm mant m x e s i fraction f
295 +0.500 => 1.00000000000 -1 -1 0 1 .00000000000 (1 + 0) * 2^(-1)
296 +0.999 => 1.11111111111 -1 -1 0 1 .11111111111 (1 + 0.99) * 2^(-1)
297 +1.000 => 1.00000000000 0 0 0 1 .00000000000 (1 + 0) * 2^(0)
298 +1.500 => 1.10000000000 0 0 0 1 .10000000000 (1 + 0.5) * 2^(0)
299 +1.999 => 1.11111111111 0 0 0 1 .11111111111 (1 + 0.9) * 2^(0)
300 +2.000 => 1.00000000000 1 1 0 1 .00000000000 (1 + 0) * 2^(1)
301 +4.000 => 1.00000000000 2 2 0 1 .00000000000 (1 + 0) * 2^(2)
302 -0.500 => 1.00000000000 -1 -1 1 0 .10000000000 (-2 + 0) * 2^(-2)
303 -1.000 => 1.00000000000 0 -1 1 0 .00000000000 (-2 + 0) * 2^(-1)
304 -1.500 => 1.10000000000 0 0 1 0 .10000000000 (-2 + 0.5) * 2^(0)
305 -1.999 => 1.11111111111 0 0 1 0 .00000000001 (-2 + 0.11) * 2^(0)
306 -2.000 => 1.00000000000 1 1 1 0 .00000000000 (-2 + 0) * 2^(0)
307 -4.000 => 1.00000000000 2 1 1 0 .00000000000 (-2 + 0) * 2^(1)
309 where e is the exponent, s is the sign bit, i is the implied bit,
310 and f is the fraction stored in the mantissa field.
312 num = (1 + f) * 2^x = m * 2^e if s = 0
313 num = (-2 + f) * 2^x = -m * 2^e if s = 1
314 where 0 <= f < 1.0 and 1.0 <= m < 2.0
316 The fraction (f) and exponent (e) fields for the TMS320C3X format
317 can be derived from the normalised mantissa (m) and exponent (x) using:
319 f = m - 1, e = x if s = 0
320 f = 2 - m, e = x if s = 1 and m != 1.0
321 f = 0, e = x - 1 if s = 1 and m = 1.0
322 f = 0, e = -8 if m = 0
325 OK, the other issue we have to consider is rounding since the
326 mantissa has a much higher potential precision than what we can
327 represent. To do this we add half the smallest storable fraction.
328 We then have to renormalise the number to allow for overflow.
330 To convert a generic flonum into a TMS320C3X floating point
331 number, here's what we try to do....
333 The first thing is to generate a normalised mantissa (m) where
334 1.0 <= m < 2 and to convert the exponent from base 16 to base 2.
335 We desire the binary point to be placed after the most significant
336 non zero bit. This process is done in two steps: firstly, the
337 littlenum with the most significant non zero bit is located (this
338 is done for us since leader points to this littlenum) and the
339 binary point (which is currently after the LSB of the littlenum
340 pointed to by low) is moved to before the MSB of the littlenum
341 pointed to by leader. This requires the exponent to be adjusted
342 by leader - low + 1. In the earlier example, the new exponent is
343 thus -4 + (5 - 2 + 1) = 0 (base 65536). We now need to convert
344 the exponent to base 2 by multiplying the exponent by 16 (log2
345 65536). The exponent base 2 is thus also zero.
347 The second step is to hunt for the most significant non zero bit
348 in the leader littlenum. We do this by left shifting a copy of
349 the leader littlenum until bit 16 is set (0x10000) and counting
350 the number of shifts, S, required. The number of shifts then has to
351 be added to correct the exponent (base 2). For our example, this
352 will require 9 shifts and thus our normalised exponent (base 2) is
353 0 + 9 = 9. Note that the worst case scenario is when the leader
354 littlenum is 1, thus requiring 16 shifts.
356 We now have to left shift the other littlenums by the same amount,
357 propagating the shifted bits into the more significant littlenums.
358 To save a lot of unnecessary shifting we only have to consider
359 two or three littlenums, since the greatest number of mantissa
360 bits required is 24 + 1 rounding bit. While two littlenums
361 provide 32 bits of precision, the most significant littlenum
362 may only contain a single significant bit and thus an extra
363 littlenum is required.
365 Denoting the number of bits in the fraction field as F, we require
366 G = F + 2 bits (one extra bit is for rounding, the other gets
367 suppressed). Say we required S shifts to find the most
368 significant bit in the leader littlenum, the number of left shifts
369 required to move this bit into bit position G - 1 is L = G + S - 17.
370 Note that this shift count may be negative for the short floating
371 point flavour (where F = 11 and thus G = 13 and potentially S < 3).
372 If L > 0 we have to shunt the next littlenum into position. Bit
373 15 (the MSB) of the next littlenum needs to get moved into position
374 L - 1 (If L > 15 we need all the bits of this littlenum and
375 some more from the next one.). We subtract 16 from L and use this
376 as the left shift count; the resultant value we or with the
377 previous result. If L > 0, we repeat this operation. */
379 if (precision
!= S_PRECISION
)
381 if (precision
== E_PRECISION
)
382 words
[2] = words
[3] = 0x0000;
384 /* 0.0e0 or NaN seen. */
385 if (flonum
.low
> flonum
.leader
/* = 0.0e0 */
386 || flonum
.sign
== 0) /* = NaN */
389 as_bad (_("Nan, using zero."));
394 if (flonum
.sign
== 'P')
396 /* +INF: Replace with maximum float. */
397 if (precision
== S_PRECISION
)
404 if (precision
== E_PRECISION
)
411 else if (flonum
.sign
== 'N')
413 /* -INF: Replace with maximum float. */
414 if (precision
== S_PRECISION
)
418 if (precision
== E_PRECISION
)
423 exponent
= (flonum
.exponent
+ flonum
.leader
- flonum
.low
+ 1) * 16;
425 if (!(tmp
= *flonum
.leader
))
426 abort (); /* Hmmm. */
427 shift
= 0; /* Find position of first sig. bit. */
430 exponent
-= (16 - shift
); /* Adjust exponent. */
432 if (precision
== S_PRECISION
) /* Allow 1 rounding bit. */
437 else if(precision
== F_PRECISION
)
442 else /* E_PRECISION */
448 shift
= mantissa_bits
- shift
;
453 /* Store the mantissa data into smant and the roundbit into rbit */
454 for (p
= flonum
.leader
; p
>= flonum
.low
&& shift
> -16; p
--)
456 tmp
= shift
>= 0 ? *p
<< shift
: *p
>> -shift
;
457 rbit
= shift
< 0 ? ((*p
>> (-shift
-1)) & 0x1) : 0;
462 /* OK, we've got our scaled mantissa so let's round it up */
465 /* If the mantissa is going to overflow when added, lets store
466 the extra bit in mover. -- A special case exists when
467 mantissa_bits is 31 (E_PRECISION). Then the first test cannot
468 be trusted, as result is host-dependent, thus the second
470 if( smant
== ((unsigned)(1<<(mantissa_bits
+1))-1)
471 || smant
== (unsigned)-1 ) /* This is to catch E_PRECISION cases */
476 /* Get the scaled one value */
477 sone
= (1 << (mantissa_bits
));
479 /* The number may be unnormalised so renormalise it... */
483 smant
|= sone
; /* Insert the bit from mover into smant */
487 /* The binary point is now between bit positions 11 and 10 or 23 and 22,
488 i.e., between mantissa_bits - 1 and mantissa_bits - 2 and the
489 bit at mantissa_bits - 1 should be set. */
491 abort (); /* Ooops. */
493 if (flonum
.sign
== '+')
494 sfract
= smant
- sone
; /* smant - 1.0. */
497 /* This seems to work. */
505 sfract
= -smant
& (sone
-1); /* 2.0 - smant. */
507 sfract
|= sone
; /* Insert sign bit. */
510 if (abs (exponent
) >= (1 << (exponent_bits
- 1)))
511 as_bad (_("Cannot represent exponent in %d bits"), exponent_bits
);
513 /* Force exponent to fit in desired field width. */
514 exponent
&= (1 << (exponent_bits
)) - 1;
516 if (precision
== E_PRECISION
)
518 /* Map the float part first (100% equal format as F_PRECISION) */
519 words
[0] = exponent
<< (mantissa_bits
+1-24);
520 words
[0] |= sfract
>> 24;
521 words
[1] = sfract
>> 8;
523 /* Map the mantissa in the next */
524 words
[2] = sfract
>> 16;
525 words
[3] = sfract
& 0xffff;
529 /* Insert the exponent data into the word */
530 sfract
|= exponent
<< (mantissa_bits
+1);
532 if (precision
== S_PRECISION
)
536 words
[0] = sfract
>> 16;
537 words
[1] = sfract
& 0xffff;
544 /* Returns pointer past text consumed. */
546 tic4x_atof (char *str
, char what_kind
, LITTLENUM_TYPE
*words
)
548 /* Extra bits for zeroed low-order bits. The 1st MAX_PRECISION are
549 zeroed, the last contain flonum bits. */
550 static LITTLENUM_TYPE bits
[MAX_PRECISION
+ MAX_PRECISION
+ GUARD
];
552 /* Number of 16-bit words in the format. */
554 FLONUM_TYPE save_gen_flonum
;
556 /* We have to save the generic_floating_point_number because it
557 contains storage allocation about the array of LITTLENUMs where
558 the value is actually stored. We will allocate our own array of
559 littlenums below, but have to restore the global one on exit. */
560 save_gen_flonum
= generic_floating_point_number
;
563 generic_floating_point_number
.low
= bits
+ MAX_PRECISION
;
564 generic_floating_point_number
.high
= NULL
;
565 generic_floating_point_number
.leader
= NULL
;
566 generic_floating_point_number
.exponent
= 0;
567 generic_floating_point_number
.sign
= '\0';
569 /* Use more LittleNums than seems necessary: the highest flonum may
570 have 15 leading 0 bits, so could be useless. */
572 memset (bits
, '\0', sizeof (LITTLENUM_TYPE
) * MAX_PRECISION
);
578 precision
= S_PRECISION
;
585 precision
= F_PRECISION
;
590 precision
= E_PRECISION
;
594 as_bad (_("Invalid floating point number"));
598 generic_floating_point_number
.high
599 = generic_floating_point_number
.low
+ precision
- 1 + GUARD
;
601 if (atof_generic (&return_value
, ".", EXP_CHARS
,
602 &generic_floating_point_number
))
604 as_bad (_("Invalid floating point number"));
608 tic4x_gen_to_words (generic_floating_point_number
,
611 /* Restore the generic_floating_point_number's storage alloc (and
613 generic_floating_point_number
= save_gen_flonum
;
619 tic4x_insert_reg (const char *regname
, int regnum
)
624 symbol_table_insert (symbol_new (regname
, reg_section
,
625 &zero_address_frag
, regnum
));
626 for (i
= 0; regname
[i
]; i
++)
627 buf
[i
] = ISLOWER (regname
[i
]) ? TOUPPER (regname
[i
]) : regname
[i
];
630 symbol_table_insert (symbol_new (buf
, reg_section
,
631 &zero_address_frag
, regnum
));
635 tic4x_insert_sym (const char *symname
, int value
)
639 symbolP
= symbol_new (symname
, absolute_section
,
640 &zero_address_frag
, value
);
641 SF_SET_LOCAL (symbolP
);
642 symbol_table_insert (symbolP
);
646 tic4x_expression (char *str
, expressionS
*exp
)
651 t
= input_line_pointer
; /* Save line pointer. */
652 input_line_pointer
= str
;
654 s
= input_line_pointer
;
655 input_line_pointer
= t
; /* Restore line pointer. */
656 return s
; /* Return pointer to where parsing stopped. */
660 tic4x_expression_abs (char *str
, offsetT
*value
)
665 t
= input_line_pointer
; /* Save line pointer. */
666 input_line_pointer
= str
;
667 *value
= get_absolute_expression ();
668 s
= input_line_pointer
;
669 input_line_pointer
= t
; /* Restore line pointer. */
674 tic4x_emit_char (char c
, int b
)
678 exp
.X_op
= O_constant
;
679 exp
.X_add_number
= c
;
684 tic4x_seg_alloc (char *name ATTRIBUTE_UNUSED
,
685 segT seg ATTRIBUTE_UNUSED
,
689 /* Note that the size is in words
690 so we multiply it by 4 to get the number of bytes to allocate. */
692 /* If we have symbol: .usect ".fred", size etc.,
693 the symbol needs to point to the first location reserved
700 p
= frag_var (rs_fill
, 1, 1, (relax_substateT
) 0,
702 size
* OCTETS_PER_BYTE
, (char *) 0);
707 /* .asg ["]character-string["], symbol */
709 tic4x_asg (int x ATTRIBUTE_UNUSED
)
716 str
= input_line_pointer
;
718 /* Skip string expression. */
719 while (*input_line_pointer
!= ',' && *input_line_pointer
)
720 input_line_pointer
++;
721 if (*input_line_pointer
!= ',')
723 as_bad (_("Comma expected\n"));
726 *input_line_pointer
++ = '\0';
727 c
= get_symbol_name (&name
); /* Get terminator. */
729 name
= xstrdup (name
);
730 str_hash_insert (tic4x_asg_hash
, name
, str
);
731 (void) restore_line_pointer (c
);
732 demand_empty_rest_of_line ();
735 /* .bss symbol, size */
737 tic4x_bss (int x ATTRIBUTE_UNUSED
)
744 subsegT current_subseg
;
747 current_seg
= now_seg
; /* Save current seg. */
748 current_subseg
= now_subseg
; /* Save current subseg. */
751 c
= get_symbol_name (&name
); /* Get terminator. */
753 c
= * ++ input_line_pointer
;
756 as_bad (_(".bss size argument missing\n"));
761 tic4x_expression_abs (++input_line_pointer
, &size
);
764 as_bad (_(".bss size %ld < 0!"), (long) size
);
767 subseg_set (bss_section
, 0);
768 symbolP
= symbol_find_or_make (name
);
770 if (S_GET_SEGMENT (symbolP
) == bss_section
)
771 symbol_get_frag (symbolP
)->fr_symbol
= 0;
773 symbol_set_frag (symbolP
, frag_now
);
775 p
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
,
776 size
* OCTETS_PER_BYTE
, (char *) 0);
777 *p
= 0; /* Fill char. */
779 S_SET_SEGMENT (symbolP
, bss_section
);
781 /* The symbol may already have been created with a preceding
782 ".globl" directive -- be careful not to step on storage class
783 in that case. Otherwise, set it to static. */
784 if (S_GET_STORAGE_CLASS (symbolP
) != C_EXT
)
785 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
787 subseg_set (current_seg
, current_subseg
); /* Restore current seg. */
788 demand_empty_rest_of_line ();
792 tic4x_globl (int ignore ATTRIBUTE_UNUSED
)
800 c
= get_symbol_name (&name
);
801 symbolP
= symbol_find_or_make (name
);
802 *input_line_pointer
= c
;
803 SKIP_WHITESPACE_AFTER_NAME ();
804 S_SET_STORAGE_CLASS (symbolP
, C_EXT
);
805 S_SET_EXTERNAL (symbolP
);
808 input_line_pointer
++;
810 if (*input_line_pointer
== '\n')
816 demand_empty_rest_of_line ();
819 /* Handle .byte, .word. .int, .long */
821 tic4x_cons (int bytes
)
827 if (*input_line_pointer
== '"')
829 input_line_pointer
++;
830 while (is_a_char (c
= next_char_of_string ()))
831 tic4x_emit_char (c
, 4);
832 know (input_line_pointer
[-1] == '\"');
838 input_line_pointer
= tic4x_expression (input_line_pointer
, &exp
);
839 if (exp
.X_op
== O_constant
)
844 exp
.X_add_number
&= 255;
847 exp
.X_add_number
&= 65535;
851 /* Perhaps we should disallow .byte and .hword with
852 a non constant expression that will require relocation. */
856 while (*input_line_pointer
++ == ',');
858 input_line_pointer
--; /* Put terminator back into stream. */
859 demand_empty_rest_of_line ();
862 /* Handle .ascii, .asciz, .string */
864 tic4x_stringer (int append_zero
)
873 if (*input_line_pointer
== '"')
875 input_line_pointer
++;
876 while (is_a_char (c
= next_char_of_string ()))
878 tic4x_emit_char (c
, 1);
884 tic4x_emit_char (c
, 1);
888 know (input_line_pointer
[-1] == '\"');
894 input_line_pointer
= tic4x_expression (input_line_pointer
, &exp
);
895 if (exp
.X_op
!= O_constant
)
897 as_bad (_("Non-constant symbols not allowed\n"));
900 exp
.X_add_number
&= 255; /* Limit number to 8-bit */
905 while (*input_line_pointer
++ == ',');
907 /* Fill out the rest of the expression with 0's to fill up a full word */
909 tic4x_emit_char (0, 4-(bytes
&0x3));
911 input_line_pointer
--; /* Put terminator back into stream. */
912 demand_empty_rest_of_line ();
915 /* .eval expression, symbol */
917 tic4x_eval (int x ATTRIBUTE_UNUSED
)
925 tic4x_expression_abs (input_line_pointer
, &value
);
926 if (*input_line_pointer
++ != ',')
928 as_bad (_("Symbol missing\n"));
931 c
= get_symbol_name (&name
); /* Get terminator. */
932 tic4x_insert_sym (name
, value
);
933 (void) restore_line_pointer (c
);
934 demand_empty_rest_of_line ();
937 /* Reset local labels. */
939 tic4x_newblock (int x ATTRIBUTE_UNUSED
)
941 dollar_label_clear ();
944 /* .sect "section-name" [, value] */
945 /* .sect ["]section-name[:subsection-name]["] [, value] */
947 tic4x_sect (int x ATTRIBUTE_UNUSED
)
956 if (*input_line_pointer
== '"')
957 input_line_pointer
++;
958 c
= get_symbol_name (§ion_name
); /* Get terminator. */
960 c
= * ++ input_line_pointer
;
961 input_line_pointer
++; /* Skip null symbol terminator. */
962 name
= xstrdup (section_name
);
964 /* TI C from version 5.0 allows a section name to contain a
965 subsection name as well. The subsection name is separated by a
966 ':' from the section name. Currently we scan the subsection
968 Volker Kuhlmann <v.kuhlmann@elec.canterbury.ac.nz>. */
972 c
= get_symbol_name (&subname
); /* Get terminator. */
974 c
= * ++ input_line_pointer
;
975 input_line_pointer
++; /* Skip null symbol terminator. */
976 as_warn (_(".sect: subsection name ignored"));
979 /* We might still have a '"' to discard, but the character after a
980 symbol name will be overwritten with a \0 by get_symbol_name()
985 tic4x_expression_abs (input_line_pointer
, &num
);
986 else if (*input_line_pointer
== ',')
989 tic4x_expression_abs (++input_line_pointer
, &num
);
994 seg
= subseg_new (name
, num
);
995 if (line_label
!= NULL
)
997 S_SET_SEGMENT (line_label
, seg
);
998 symbol_set_frag (line_label
, frag_now
);
1001 if (bfd_section_flags (seg
) == SEC_NO_FLAGS
)
1003 if (!bfd_set_section_flags (seg
, SEC_DATA
))
1004 as_warn (_("Error setting flags for \"%s\": %s"), name
,
1005 bfd_errmsg (bfd_get_error ()));
1008 /* If the last character overwritten by get_symbol_name() was an
1009 end-of-line, we must restore it or the end of the line will not be
1010 recognised and scanning extends into the next line, stopping with
1011 an error (blame Volker Kuhlmann <v.kuhlmann@elec.canterbury.ac.nz>
1012 if this is not true). */
1013 if (is_end_of_line
[(unsigned char) c
])
1014 *(--input_line_pointer
) = c
;
1016 demand_empty_rest_of_line ();
1019 /* symbol[:] .set value or .set symbol, value */
1021 tic4x_set (int x ATTRIBUTE_UNUSED
)
1026 if ((symbolP
= line_label
) == NULL
)
1031 c
= get_symbol_name (&name
); /* Get terminator. */
1033 c
= * ++ input_line_pointer
;
1036 as_bad (_(".set syntax invalid\n"));
1037 ignore_rest_of_line ();
1040 ++input_line_pointer
;
1041 symbolP
= symbol_find_or_make (name
);
1044 symbol_table_insert (symbolP
);
1046 pseudo_set (symbolP
);
1047 demand_empty_rest_of_line ();
1050 /* [symbol] .usect ["]section-name["], size-in-words [, alignment-flag] */
1052 tic4x_usect (int x ATTRIBUTE_UNUSED
)
1058 offsetT size
, alignment_flag
;
1060 subsegT current_subseg
;
1062 current_seg
= now_seg
; /* save current seg. */
1063 current_subseg
= now_subseg
; /* save current subseg. */
1066 if (*input_line_pointer
== '"')
1067 input_line_pointer
++;
1068 c
= get_symbol_name (§ion_name
); /* Get terminator. */
1070 c
= * ++ input_line_pointer
;
1071 input_line_pointer
++; /* Skip null symbol terminator. */
1072 name
= xstrdup (section_name
);
1075 input_line_pointer
=
1076 tic4x_expression_abs (input_line_pointer
, &size
);
1077 else if (*input_line_pointer
== ',')
1079 input_line_pointer
=
1080 tic4x_expression_abs (++input_line_pointer
, &size
);
1085 /* Read a possibly present third argument (alignment flag) [VK]. */
1086 if (*input_line_pointer
== ',')
1088 input_line_pointer
=
1089 tic4x_expression_abs (++input_line_pointer
, &alignment_flag
);
1094 as_warn (_(".usect: non-zero alignment flag ignored"));
1096 seg
= subseg_new (name
, 0);
1097 if (line_label
!= NULL
)
1099 S_SET_SEGMENT (line_label
, seg
);
1100 symbol_set_frag (line_label
, frag_now
);
1101 S_SET_VALUE (line_label
, frag_now_fix ());
1103 seg_info (seg
)->bss
= 1; /* Uninitialised data. */
1104 if (!bfd_set_section_flags (seg
, SEC_ALLOC
))
1105 as_warn (_("Error setting flags for \"%s\": %s"), name
,
1106 bfd_errmsg (bfd_get_error ()));
1107 tic4x_seg_alloc (name
, seg
, size
, line_label
);
1109 if (S_GET_STORAGE_CLASS (line_label
) != C_EXT
)
1110 S_SET_STORAGE_CLASS (line_label
, C_STAT
);
1112 subseg_set (current_seg
, current_subseg
); /* Restore current seg. */
1113 demand_empty_rest_of_line ();
1116 /* .version cpu-version. */
1118 tic4x_version (int x ATTRIBUTE_UNUSED
)
1122 input_line_pointer
=
1123 tic4x_expression_abs (input_line_pointer
, &temp
);
1124 if (!IS_CPU_TIC3X (temp
) && !IS_CPU_TIC4X (temp
))
1125 as_bad (_("This assembler does not support processor generation %ld"),
1128 if (tic4x_cpu
&& temp
!= (offsetT
) tic4x_cpu
)
1129 as_warn (_("Changing processor generation on fly not supported..."));
1131 demand_empty_rest_of_line ();
1135 tic4x_init_regtable (void)
1139 for (i
= 0; i
< tic3x_num_registers
; i
++)
1140 tic4x_insert_reg (tic3x_registers
[i
].name
,
1141 tic3x_registers
[i
].regno
);
1143 if (IS_CPU_TIC4X (tic4x_cpu
))
1145 /* Add additional Tic4x registers, overriding some C3x ones. */
1146 for (i
= 0; i
< tic4x_num_registers
; i
++)
1147 tic4x_insert_reg (tic4x_registers
[i
].name
,
1148 tic4x_registers
[i
].regno
);
1153 tic4x_init_symbols (void)
1155 /* The TI tools accept case insensitive versions of these symbols,
1160 .TMS320xx 30,31,32,40,or 44 set according to -v flag
1161 .C3X or .C3x 1 or 0 1 if -v30,-v31,or -v32
1162 .C30 1 or 0 1 if -v30
1163 .C31 1 or 0 1 if -v31
1164 .C32 1 or 0 1 if -v32
1165 .C4X or .C4x 1 or 0 1 if -v40, or -v44
1166 .C40 1 or 0 1 if -v40
1167 .C44 1 or 0 1 if -v44
1169 .REGPARM 1 or 0 1 if -mr option used
1170 .BIGMODEL 1 or 0 1 if -mb option used
1172 These symbols are currently supported but will be removed in a
1174 .TMS320C30 1 or 0 1 if -v30,-v31,or -v32
1175 .TMS320C31 1 or 0 1 if -v31
1176 .TMS320C32 1 or 0 1 if -v32
1177 .TMS320C40 1 or 0 1 if -v40, or -v44
1178 .TMS320C44 1 or 0 1 if -v44
1180 Source: TI: TMS320C3x/C4x Assembly Language Tools User's Guide,
1181 1997, SPRU035C, p. 3-17/3-18. */
1182 tic4x_insert_sym (".REGPARM", tic4x_reg_args
);
1183 tic4x_insert_sym (".MEMPARM", !tic4x_reg_args
);
1184 tic4x_insert_sym (".BIGMODEL", tic4x_big_model
);
1185 tic4x_insert_sym (".C30INTERRUPT", 0);
1186 tic4x_insert_sym (".TMS320xx", tic4x_cpu
== 0 ? 40 : tic4x_cpu
);
1187 tic4x_insert_sym (".C3X", tic4x_cpu
== 30 || tic4x_cpu
== 31 || tic4x_cpu
== 32 || tic4x_cpu
== 33);
1188 tic4x_insert_sym (".C3x", tic4x_cpu
== 30 || tic4x_cpu
== 31 || tic4x_cpu
== 32 || tic4x_cpu
== 33);
1189 tic4x_insert_sym (".C4X", tic4x_cpu
== 0 || tic4x_cpu
== 40 || tic4x_cpu
== 44);
1190 tic4x_insert_sym (".C4x", tic4x_cpu
== 0 || tic4x_cpu
== 40 || tic4x_cpu
== 44);
1191 /* Do we need to have the following symbols also in lower case? */
1192 tic4x_insert_sym (".TMS320C30", tic4x_cpu
== 30 || tic4x_cpu
== 31 || tic4x_cpu
== 32 || tic4x_cpu
== 33);
1193 tic4x_insert_sym (".tms320C30", tic4x_cpu
== 30 || tic4x_cpu
== 31 || tic4x_cpu
== 32 || tic4x_cpu
== 33);
1194 tic4x_insert_sym (".TMS320C31", tic4x_cpu
== 31);
1195 tic4x_insert_sym (".tms320C31", tic4x_cpu
== 31);
1196 tic4x_insert_sym (".TMS320C32", tic4x_cpu
== 32);
1197 tic4x_insert_sym (".tms320C32", tic4x_cpu
== 32);
1198 tic4x_insert_sym (".TMS320C33", tic4x_cpu
== 33);
1199 tic4x_insert_sym (".tms320C33", tic4x_cpu
== 33);
1200 tic4x_insert_sym (".TMS320C40", tic4x_cpu
== 40 || tic4x_cpu
== 44 || tic4x_cpu
== 0);
1201 tic4x_insert_sym (".tms320C40", tic4x_cpu
== 40 || tic4x_cpu
== 44 || tic4x_cpu
== 0);
1202 tic4x_insert_sym (".TMS320C44", tic4x_cpu
== 44);
1203 tic4x_insert_sym (".tms320C44", tic4x_cpu
== 44);
1204 tic4x_insert_sym (".TMX320C40", 0); /* C40 first pass silicon ? */
1205 tic4x_insert_sym (".tmx320C40", 0);
1208 /* Insert a new instruction template into hash table. */
1210 tic4x_inst_insert (const tic4x_inst_t
*inst
)
1212 static char prev_name
[16];
1214 /* Only insert the first name if have several similar entries. */
1215 if (!strcmp (inst
->name
, prev_name
) || inst
->name
[0] == '\0')
1218 str_hash_insert (tic4x_op_hash
, inst
->name
, (void *) inst
);
1219 strcpy (prev_name
, inst
->name
);
1222 /* Make a new instruction template. */
1223 static tic4x_inst_t
*
1224 tic4x_inst_make (const char *name
, unsigned long opcode
, const char *args
)
1226 static tic4x_inst_t
*insts
= NULL
;
1227 static char *names
= NULL
;
1228 static int iindex
= 0;
1232 /* Allocate memory to store name strings. */
1233 names
= XNEWVEC (char, 8192);
1234 /* Allocate memory for additional insts. */
1235 insts
= XNEWVEC (tic4x_inst_t
, 1024);
1237 insts
[iindex
].name
= names
;
1238 insts
[iindex
].opcode
= opcode
;
1239 insts
[iindex
].opmask
= 0xffffffff;
1240 insts
[iindex
].args
= args
;
1248 return &insts
[iindex
- 1];
1251 /* Add instruction template, creating dynamic templates as required. */
1253 tic4x_inst_add (const tic4x_inst_t
*insts
)
1255 const char *s
= insts
->name
;
1262 /* We do not care about INSNs that is not a part of our
1264 if ((insts
->oplevel
& tic4x_oplevel
) == 0)
1273 /* Dynamically create all the conditional insts. */
1274 for (i
= 0; i
< tic4x_num_conds
; i
++)
1278 const char *c
= tic4x_conds
[i
].name
;
1288 /* If instruction found then have already processed it. */
1289 if (str_hash_find (tic4x_op_hash
, name
))
1294 inst
= tic4x_inst_make (name
, insts
[k
].opcode
+
1295 (tic4x_conds
[i
].cond
<<
1296 (*s
== 'B' ? 16 : 23)),
1298 if (k
== 0) /* Save strcmp() with following func. */
1299 tic4x_inst_insert (inst
);
1302 while (!strcmp (insts
->name
,
1308 tic4x_inst_insert (insts
);
1318 /* This function is called once, at assembler startup time. It should
1319 set up all the tables, etc., that the MD part of the assembler will
1326 /* Setup the proper opcode level according to the
1327 commandline parameters */
1328 tic4x_oplevel
= OP_C3X
;
1330 if ( IS_CPU_TIC4X(tic4x_cpu
) )
1331 tic4x_oplevel
|= OP_C4X
;
1333 if ( ( tic4x_cpu
== 31 && tic4x_revision
>= 6)
1334 || (tic4x_cpu
== 32 && tic4x_revision
>= 2)
1335 || (tic4x_cpu
== 33)
1337 tic4x_oplevel
|= OP_ENH
;
1339 if ( ( tic4x_cpu
== 30 && tic4x_revision
>= 7)
1340 || (tic4x_cpu
== 31 && tic4x_revision
>= 5)
1341 || (tic4x_cpu
== 32)
1343 tic4x_oplevel
|= OP_LPWR
;
1345 if ( ( tic4x_cpu
== 30 && tic4x_revision
>= 7)
1346 || (tic4x_cpu
== 31 && tic4x_revision
>= 5)
1347 || (tic4x_cpu
== 32)
1348 || (tic4x_cpu
== 33)
1349 || (tic4x_cpu
== 40 && tic4x_revision
>= 5)
1350 || (tic4x_cpu
== 44)
1352 tic4x_oplevel
|= OP_IDLE2
;
1354 /* Create hash table for mnemonics. */
1355 tic4x_op_hash
= str_htab_create ();
1357 /* Create hash table for asg pseudo. */
1358 tic4x_asg_hash
= str_htab_create ();
1360 /* Add mnemonics to hash table, expanding conditional mnemonics on fly. */
1361 for (i
= 0; i
< tic4x_num_insts
; i
++)
1362 tic4x_inst_add (tic4x_insts
+ i
);
1364 /* Create dummy inst to avoid errors accessing end of table. */
1365 tic4x_inst_make ("", 0, "");
1367 /* Add registers to symbol table. */
1368 tic4x_init_regtable ();
1370 /* Add predefined symbols to symbol table. */
1371 tic4x_init_symbols ();
1377 bfd_set_arch_mach (stdoutput
, bfd_arch_tic4x
,
1378 IS_CPU_TIC4X (tic4x_cpu
) ? bfd_mach_tic4x
: bfd_mach_tic3x
);
1382 tic4x_indirect_parse (tic4x_operand_t
*operand
,
1383 const tic4x_indirect_t
*indirect
)
1385 const char *n
= indirect
->name
;
1386 char *s
= input_line_pointer
;
1396 case 'a': /* Need to match aux register. */
1398 #ifdef TIC4X_ALT_SYNTAX
1402 while (ISALNUM (*s
))
1405 if (!(symbolP
= symbol_find (name
)))
1408 if (S_GET_SEGMENT (symbolP
) != reg_section
)
1411 operand
->aregno
= S_GET_VALUE (symbolP
);
1412 if (operand
->aregno
>= REG_AR0
&& operand
->aregno
<= REG_AR7
)
1415 as_bad (_("Auxiliary register AR0--AR7 required for indirect"));
1418 case 'd': /* Need to match constant for disp. */
1419 #ifdef TIC4X_ALT_SYNTAX
1420 if (*s
== '%') /* expr() will die if we don't skip this. */
1423 s
= tic4x_expression (s
, &operand
->expr
);
1424 if (operand
->expr
.X_op
!= O_constant
)
1426 operand
->disp
= operand
->expr
.X_add_number
;
1427 if (operand
->disp
< 0 || operand
->disp
> 255)
1429 as_bad (_("Bad displacement %d (require 0--255)\n"),
1435 case 'y': /* Need to match IR0. */
1436 case 'z': /* Need to match IR1. */
1437 #ifdef TIC4X_ALT_SYNTAX
1441 s
= tic4x_expression (s
, &operand
->expr
);
1442 if (operand
->expr
.X_op
!= O_register
)
1444 if (operand
->expr
.X_add_number
!= REG_IR0
1445 && operand
->expr
.X_add_number
!= REG_IR1
)
1447 as_bad (_("Index register IR0,IR1 required for displacement"));
1451 if (*n
== 'y' && operand
->expr
.X_add_number
== REG_IR0
)
1453 if (*n
== 'z' && operand
->expr
.X_add_number
== REG_IR1
)
1458 if (*s
!= '(') /* No displacement, assume to be 1. */
1469 if (TOLOWER (*s
) != *n
)
1474 if (*s
!= ' ' && *s
!= ',' && *s
!= '\0')
1476 input_line_pointer
= s
;
1481 tic4x_operand_parse (char *s
, tic4x_operand_t
*operand
)
1486 expressionS
*exp
= &operand
->expr
;
1487 char *save
= input_line_pointer
;
1490 struct hash_entry
*entry
= NULL
;
1492 input_line_pointer
= s
;
1495 c
= get_symbol_name (&str
); /* Get terminator. */
1496 new_pointer
= input_line_pointer
;
1497 if (strlen (str
) && (entry
= str_hash_find (tic4x_asg_hash
, str
)) != NULL
)
1499 (void) restore_line_pointer (c
);
1500 input_line_pointer
= (char *) entry
;
1504 (void) restore_line_pointer (c
);
1505 input_line_pointer
= str
;
1508 operand
->mode
= M_UNKNOWN
;
1509 switch (*input_line_pointer
)
1511 #ifdef TIC4X_ALT_SYNTAX
1513 input_line_pointer
= tic4x_expression (++input_line_pointer
, exp
);
1514 if (exp
->X_op
!= O_register
)
1515 as_bad (_("Expecting a register name"));
1516 operand
->mode
= M_REGISTER
;
1520 /* Denotes high 16 bits. */
1521 input_line_pointer
= tic4x_expression (++input_line_pointer
, exp
);
1522 if (exp
->X_op
== O_constant
)
1523 operand
->mode
= M_IMMED
;
1524 else if (exp
->X_op
== O_big
)
1526 if (exp
->X_add_number
)
1527 as_bad (_("Number too large")); /* bignum required */
1530 tic4x_gen_to_words (generic_floating_point_number
,
1531 operand
->fwords
, S_PRECISION
);
1532 operand
->mode
= M_IMMED_F
;
1535 /* Allow ori ^foo, ar0 to be equivalent to ldi .hi.foo, ar0 */
1536 /* WARNING : The TI C40 assembler cannot do this. */
1537 else if (exp
->X_op
== O_symbol
)
1538 operand
->mode
= M_HI
;
1540 as_bad (_("Expecting a constant value"));
1544 input_line_pointer
= tic4x_expression (++input_line_pointer
, exp
);
1545 if (exp
->X_op
== O_constant
)
1546 operand
->mode
= M_IMMED
;
1547 else if (exp
->X_op
== O_big
)
1549 if (exp
->X_add_number
> 0)
1550 as_bad (_("Number too large")); /* bignum required. */
1553 tic4x_gen_to_words (generic_floating_point_number
,
1554 operand
->fwords
, S_PRECISION
);
1555 operand
->mode
= M_IMMED_F
;
1558 /* Allow ori foo, ar0 to be equivalent to ldi .lo.foo, ar0 */
1559 /* WARNING : The TI C40 assembler cannot do this. */
1560 else if (exp
->X_op
== O_symbol
)
1561 operand
->mode
= M_IMMED
;
1563 as_bad (_("Expecting a constant value"));
1569 input_line_pointer
= tic4x_expression (++input_line_pointer
, exp
);
1570 if (exp
->X_op
!= O_constant
&& exp
->X_op
!= O_symbol
)
1571 as_bad (_("Bad direct addressing construct %s"), s
);
1572 if (exp
->X_op
== O_constant
)
1574 if (exp
->X_add_number
< 0)
1575 as_bad (_("Direct value of %ld is not suitable"),
1576 (long) exp
->X_add_number
);
1578 operand
->mode
= M_DIRECT
;
1583 for (i
= 0; i
< tic4x_num_indirects
; i
++)
1584 if ((ret
= tic4x_indirect_parse (operand
, &tic4x_indirects
[i
])))
1588 if (i
< tic4x_num_indirects
)
1590 operand
->mode
= M_INDIRECT
;
1591 /* Indirect addressing mode number. */
1592 operand
->expr
.X_add_number
= tic4x_indirects
[i
].modn
;
1593 /* Convert *+ARn(0) to *ARn etc. Maybe we should
1594 squeal about silly ones? */
1595 if (operand
->expr
.X_add_number
< 0x08 && !operand
->disp
)
1596 operand
->expr
.X_add_number
= 0x18;
1599 as_bad (_("Unknown indirect addressing mode"));
1603 operand
->mode
= M_IMMED
; /* Assume immediate. */
1604 str
= input_line_pointer
;
1605 input_line_pointer
= tic4x_expression (input_line_pointer
, exp
);
1606 if (exp
->X_op
== O_register
)
1608 know (exp
->X_add_symbol
== 0);
1609 know (exp
->X_op_symbol
== 0);
1610 operand
->mode
= M_REGISTER
;
1613 else if (exp
->X_op
== O_big
)
1615 if (exp
->X_add_number
> 0)
1616 as_bad (_("Number too large")); /* bignum required. */
1619 tic4x_gen_to_words (generic_floating_point_number
,
1620 operand
->fwords
, S_PRECISION
);
1621 operand
->mode
= M_IMMED_F
;
1625 #ifdef TIC4X_ALT_SYNTAX
1626 /* Allow ldi foo, ar0 to be equivalent to ldi @foo, ar0. */
1627 else if (exp
->X_op
== O_symbol
)
1629 operand
->mode
= M_DIRECT
;
1635 new_pointer
= input_line_pointer
;
1636 input_line_pointer
= save
;
1641 tic4x_operands_match (tic4x_inst_t
*inst
, tic4x_insn_t
*tinsn
, int check
)
1643 const char *args
= inst
->args
;
1644 unsigned long opcode
= inst
->opcode
;
1645 int num_operands
= tinsn
->num_operands
;
1646 tic4x_operand_t
*operand
= tinsn
->operands
;
1647 expressionS
*exp
= &operand
->expr
;
1651 /* Build the opcode, checking as we go to make sure that the
1654 If an operand matches, we modify insn or opcode appropriately,
1655 and do a "continue". If an operand fails to match, we "break". */
1657 tinsn
->nchars
= 4; /* Instructions always 4 bytes. */
1658 tinsn
->reloc
= NO_RELOC
;
1663 tinsn
->opcode
= opcode
;
1664 return num_operands
== 0;
1672 case '\0': /* End of args. */
1673 if (num_operands
== 1)
1675 tinsn
->opcode
= opcode
;
1678 break; /* Too many operands. */
1680 case '#': /* This is only used for ldp. */
1681 if (operand
->mode
!= M_DIRECT
&& operand
->mode
!= M_IMMED
)
1683 /* While this looks like a direct addressing mode, we actually
1684 use an immediate mode form of ldiu or ldpk instruction. */
1685 if (exp
->X_op
== O_constant
)
1687 if( ( IS_CPU_TIC4X (tic4x_cpu
) && exp
->X_add_number
<= 65535 )
1688 || ( IS_CPU_TIC3X (tic4x_cpu
) && exp
->X_add_number
<= 255 ) )
1690 INSERTS (opcode
, exp
->X_add_number
, 15, 0);
1696 as_bad (_("Immediate value of %ld is too large for ldf"),
1697 (long) exp
->X_add_number
);
1702 else if (exp
->X_op
== O_symbol
)
1704 tinsn
->reloc
= BFD_RELOC_HI16
;
1708 break; /* Not direct (dp) addressing. */
1710 case '@': /* direct. */
1711 if (operand
->mode
!= M_DIRECT
)
1713 if (exp
->X_op
== O_constant
)
1715 /* Store only the 16 LSBs of the number. */
1716 INSERTS (opcode
, exp
->X_add_number
, 15, 0);
1719 else if (exp
->X_op
== O_symbol
)
1721 tinsn
->reloc
= BFD_RELOC_LO16
;
1725 break; /* Not direct addressing. */
1728 if (operand
->mode
!= M_REGISTER
)
1730 reg
= exp
->X_add_number
;
1731 if (reg
>= REG_AR0
&& reg
<= REG_AR7
)
1732 INSERTU (opcode
, reg
- REG_AR0
, 24, 22);
1736 as_bad (_("Destination register must be ARn"));
1741 case 'B': /* Unsigned integer immediate. */
1742 /* Allow br label or br @label. */
1743 if (operand
->mode
!= M_IMMED
&& operand
->mode
!= M_DIRECT
)
1745 if (exp
->X_op
== O_constant
)
1747 if (exp
->X_add_number
< (1 << 24))
1749 INSERTU (opcode
, exp
->X_add_number
, 23, 0);
1755 as_bad (_("Immediate value of %ld is too large"),
1756 (long) exp
->X_add_number
);
1761 if (IS_CPU_TIC4X (tic4x_cpu
))
1763 tinsn
->reloc
= BFD_RELOC_24_PCREL
;
1768 tinsn
->reloc
= BFD_RELOC_24
;
1775 if (!IS_CPU_TIC4X (tic4x_cpu
))
1777 if (operand
->mode
!= M_INDIRECT
)
1779 /* Require either *+ARn(disp) or *ARn. */
1780 if (operand
->expr
.X_add_number
!= 0
1781 && operand
->expr
.X_add_number
!= 0x18)
1784 as_bad (_("Invalid indirect addressing mode"));
1788 INSERTU (opcode
, operand
->aregno
- REG_AR0
, 2, 0);
1789 INSERTU (opcode
, operand
->disp
, 7, 3);
1793 if (!(operand
->mode
== M_REGISTER
))
1795 INSERTU (opcode
, exp
->X_add_number
, 7, 0);
1799 if (!(operand
->mode
== M_REGISTER
))
1801 reg
= exp
->X_add_number
;
1802 if ( (reg
>= REG_R0
&& reg
<= REG_R7
)
1803 || (IS_CPU_TIC4X (tic4x_cpu
) && reg
>= REG_R8
&& reg
<= REG_R11
) )
1804 INSERTU (opcode
, reg
, 7, 0);
1808 as_bad (_("Register must be Rn"));
1814 if (operand
->mode
!= M_IMMED_F
1815 && !(operand
->mode
== M_IMMED
&& exp
->X_op
== O_constant
))
1818 if (operand
->mode
!= M_IMMED_F
)
1820 /* OK, we 've got something like cmpf 0, r0
1821 Why can't they stick in a bloody decimal point ?! */
1824 /* Create floating point number string. */
1825 sprintf (string
, "%d.0", (int) exp
->X_add_number
);
1826 tic4x_atof (string
, 's', operand
->fwords
);
1829 INSERTU (opcode
, operand
->fwords
[0], 15, 0);
1833 if (operand
->mode
!= M_REGISTER
)
1835 INSERTU (opcode
, exp
->X_add_number
, 15, 8);
1839 if (operand
->mode
!= M_REGISTER
)
1841 reg
= exp
->X_add_number
;
1842 if ( (reg
>= REG_R0
&& reg
<= REG_R7
)
1843 || (IS_CPU_TIC4X (tic4x_cpu
) && reg
>= REG_R8
&& reg
<= REG_R11
) )
1844 INSERTU (opcode
, reg
, 15, 8);
1848 as_bad (_("Register must be Rn"));
1854 if (operand
->mode
!= M_REGISTER
)
1856 reg
= exp
->X_add_number
;
1857 if (reg
>= REG_R0
&& reg
<= REG_R7
)
1858 INSERTU (opcode
, reg
- REG_R0
, 18, 16);
1862 as_bad (_("Register must be R0--R7"));
1868 if ( operand
->mode
== M_REGISTER
1869 && tic4x_oplevel
& OP_ENH
)
1871 reg
= exp
->X_add_number
;
1872 INSERTU (opcode
, reg
, 4, 0);
1873 INSERTU (opcode
, 7, 7, 5);
1879 if (operand
->mode
!= M_INDIRECT
)
1881 if (operand
->disp
!= 0 && operand
->disp
!= 1)
1883 if (IS_CPU_TIC4X (tic4x_cpu
))
1886 as_bad (_("Invalid indirect addressing mode displacement %d"),
1891 INSERTU (opcode
, operand
->aregno
- REG_AR0
, 2, 0);
1892 INSERTU (opcode
, operand
->expr
.X_add_number
, 7, 3);
1896 if ( operand
->mode
== M_REGISTER
1897 && tic4x_oplevel
& OP_ENH
)
1899 reg
= exp
->X_add_number
;
1900 INSERTU (opcode
, reg
, 12, 8);
1901 INSERTU (opcode
, 7, 15, 13);
1907 if (operand
->mode
!= M_INDIRECT
)
1909 if (operand
->disp
!= 0 && operand
->disp
!= 1)
1911 if (IS_CPU_TIC4X (tic4x_cpu
))
1914 as_bad (_("Invalid indirect addressing mode displacement %d"),
1919 INSERTU (opcode
, operand
->aregno
- REG_AR0
, 10, 8);
1920 INSERTU (opcode
, operand
->expr
.X_add_number
, 15, 11);
1924 if (operand
->mode
!= M_REGISTER
)
1926 reg
= exp
->X_add_number
;
1927 if (reg
>= REG_R0
&& reg
<= REG_R7
)
1928 INSERTU (opcode
, reg
- REG_R0
, 21, 19);
1932 as_bad (_("Register must be R0--R7"));
1938 if (operand
->mode
!= M_REGISTER
)
1940 reg
= exp
->X_add_number
;
1941 if (reg
>= REG_R0
&& reg
<= REG_R7
)
1942 INSERTU (opcode
, reg
- REG_R0
, 24, 22);
1946 as_bad (_("Register must be R0--R7"));
1952 if (operand
->mode
!= M_REGISTER
)
1954 reg
= exp
->X_add_number
;
1955 if (reg
== REG_R2
|| reg
== REG_R3
)
1956 INSERTU (opcode
, reg
- REG_R2
, 22, 22);
1960 as_bad (_("Destination register must be R2 or R3"));
1966 if (operand
->mode
!= M_REGISTER
)
1968 reg
= exp
->X_add_number
;
1969 if (reg
== REG_R0
|| reg
== REG_R1
)
1970 INSERTU (opcode
, reg
- REG_R0
, 23, 23);
1974 as_bad (_("Destination register must be R0 or R1"));
1980 if (!IS_CPU_TIC4X (tic4x_cpu
))
1982 if (operand
->mode
!= M_INDIRECT
)
1984 /* Require either *+ARn(disp) or *ARn. */
1985 if (operand
->expr
.X_add_number
!= 0
1986 && operand
->expr
.X_add_number
!= 0x18)
1989 as_bad (_("Invalid indirect addressing mode"));
1993 INSERTU (opcode
, operand
->aregno
- REG_AR0
, 10, 8);
1994 INSERTU (opcode
, operand
->disp
, 15, 11);
1997 case 'P': /* PC relative displacement. */
1998 /* Allow br label or br @label. */
1999 if (operand
->mode
!= M_IMMED
&& operand
->mode
!= M_DIRECT
)
2001 if (exp
->X_op
== O_constant
)
2003 if (exp
->X_add_number
>= -32768 && exp
->X_add_number
<= 32767)
2005 INSERTS (opcode
, exp
->X_add_number
, 15, 0);
2011 as_bad (_("Displacement value of %ld is too large"),
2012 (long) exp
->X_add_number
);
2017 tinsn
->reloc
= BFD_RELOC_16_PCREL
;
2023 if (operand
->mode
!= M_REGISTER
)
2025 reg
= exp
->X_add_number
;
2026 INSERTU (opcode
, reg
, 15, 0);
2030 if (operand
->mode
!= M_REGISTER
)
2032 reg
= exp
->X_add_number
;
2033 if ( (reg
>= REG_R0
&& reg
<= REG_R7
)
2034 || (IS_CPU_TIC4X (tic4x_cpu
) && reg
>= REG_R8
&& reg
<= REG_R11
) )
2035 INSERTU (opcode
, reg
, 15, 0);
2039 as_bad (_("Register must be Rn"));
2045 if (operand
->mode
!= M_REGISTER
)
2047 reg
= exp
->X_add_number
;
2048 INSERTU (opcode
, reg
, 20, 16);
2052 if (operand
->mode
!= M_REGISTER
)
2054 reg
= exp
->X_add_number
;
2055 if ( (reg
>= REG_R0
&& reg
<= REG_R7
)
2056 || (IS_CPU_TIC4X (tic4x_cpu
) && reg
>= REG_R8
&& reg
<= REG_R11
) )
2057 INSERTU (opcode
, reg
, 20, 16);
2061 as_bad (_("Register must be Rn"));
2066 case 'S': /* Short immediate int. */
2067 if (operand
->mode
!= M_IMMED
&& operand
->mode
!= M_HI
)
2069 if (exp
->X_op
== O_big
)
2072 as_bad (_("Floating point number not valid in expression"));
2076 if (exp
->X_op
== O_constant
)
2078 if (exp
->X_add_number
>= -32768 && exp
->X_add_number
<= 65535)
2080 INSERTS (opcode
, exp
->X_add_number
, 15, 0);
2086 as_bad (_("Signed immediate value %ld too large"),
2087 (long) exp
->X_add_number
);
2092 else if (exp
->X_op
== O_symbol
)
2094 if (operand
->mode
== M_HI
)
2096 tinsn
->reloc
= BFD_RELOC_HI16
;
2100 tinsn
->reloc
= BFD_RELOC_LO16
;
2105 /* Handle cases like ldi foo - $, ar0 where foo
2106 is a forward reference. Perhaps we should check
2107 for X_op == O_symbol and disallow things like
2109 tinsn
->reloc
= BFD_RELOC_16
;
2113 case 'T': /* 5-bit immediate value for tic4x stik. */
2114 if (!IS_CPU_TIC4X (tic4x_cpu
))
2116 if (operand
->mode
!= M_IMMED
)
2118 if (exp
->X_op
== O_constant
)
2120 if (exp
->X_add_number
< 16 && exp
->X_add_number
>= -16)
2122 INSERTS (opcode
, exp
->X_add_number
, 20, 16);
2128 as_bad (_("Immediate value of %ld is too large"),
2129 (long) exp
->X_add_number
);
2134 break; /* No relocations allowed. */
2136 case 'U': /* Unsigned integer immediate. */
2137 if (operand
->mode
!= M_IMMED
&& operand
->mode
!= M_HI
)
2139 if (exp
->X_op
== O_constant
)
2141 if (exp
->X_add_number
< (1 << 16) && exp
->X_add_number
>= 0)
2143 INSERTU (opcode
, exp
->X_add_number
, 15, 0);
2149 as_bad (_("Unsigned immediate value %ld too large"),
2150 (long) exp
->X_add_number
);
2155 else if (exp
->X_op
== O_symbol
)
2157 if (operand
->mode
== M_HI
)
2158 tinsn
->reloc
= BFD_RELOC_HI16
;
2160 tinsn
->reloc
= BFD_RELOC_LO16
;
2165 tinsn
->reloc
= BFD_RELOC_16
;
2169 case 'V': /* Trap numbers (immediate field). */
2170 if (operand
->mode
!= M_IMMED
)
2172 if (exp
->X_op
== O_constant
)
2174 if (exp
->X_add_number
< 512 && IS_CPU_TIC4X (tic4x_cpu
))
2176 INSERTU (opcode
, exp
->X_add_number
, 8, 0);
2179 else if (exp
->X_add_number
< 32 && IS_CPU_TIC3X (tic4x_cpu
))
2181 INSERTU (opcode
, exp
->X_add_number
| 0x20, 5, 0);
2187 as_bad (_("Immediate value of %ld is too large"),
2188 (long) exp
->X_add_number
);
2193 break; /* No relocations allowed. */
2195 case 'W': /* Short immediate int (0--7). */
2196 if (!IS_CPU_TIC4X (tic4x_cpu
))
2198 if (operand
->mode
!= M_IMMED
)
2200 if (exp
->X_op
== O_big
)
2203 as_bad (_("Floating point number not valid in expression"));
2207 if (exp
->X_op
== O_constant
)
2209 if (exp
->X_add_number
>= -256 && exp
->X_add_number
<= 127)
2211 INSERTS (opcode
, exp
->X_add_number
, 7, 0);
2217 as_bad (_("Immediate value %ld too large"),
2218 (long) exp
->X_add_number
);
2223 tinsn
->reloc
= BFD_RELOC_16
;
2227 case 'X': /* Expansion register for tic4x. */
2228 if (operand
->mode
!= M_REGISTER
)
2230 reg
= exp
->X_add_number
;
2231 if (reg
>= REG_IVTP
&& reg
<= REG_TVTP
)
2232 INSERTU (opcode
, reg
- REG_IVTP
, 4, 0);
2236 as_bad (_("Register must be ivtp or tvtp"));
2241 case 'Y': /* Address register for tic4x lda. */
2242 if (operand
->mode
!= M_REGISTER
)
2244 reg
= exp
->X_add_number
;
2245 if (reg
>= REG_AR0
&& reg
<= REG_SP
)
2246 INSERTU (opcode
, reg
, 20, 16);
2250 as_bad (_("Register must be address register"));
2255 case 'Z': /* Expansion register for tic4x. */
2256 if (operand
->mode
!= M_REGISTER
)
2258 reg
= exp
->X_add_number
;
2259 if (reg
>= REG_IVTP
&& reg
<= REG_TVTP
)
2260 INSERTU (opcode
, reg
- REG_IVTP
, 20, 16);
2264 as_bad (_("Register must be ivtp or tvtp"));
2270 if (operand
->mode
!= M_INDIRECT
)
2272 INSERTS (opcode
, operand
->disp
, 7, 0);
2273 INSERTU (opcode
, operand
->aregno
- REG_AR0
, 10, 8);
2274 INSERTU (opcode
, operand
->expr
.X_add_number
, 15, 11);
2277 case '|': /* treat as `,' if have ldi_ldi form. */
2278 if (tinsn
->parallel
)
2280 if (--num_operands
< 0)
2281 break; /* Too few operands. */
2283 if (operand
->mode
!= M_PARALLEL
)
2288 case ',': /* Another operand. */
2289 if (--num_operands
< 0)
2290 break; /* Too few operands. */
2292 exp
= &operand
->expr
;
2295 case ';': /* Another optional operand. */
2296 if (num_operands
== 1 || operand
[1].mode
== M_PARALLEL
)
2298 if (--num_operands
< 0)
2299 break; /* Too few operands. */
2301 exp
= &operand
->expr
;
2312 tic4x_insn_check (tic4x_insn_t
*tinsn
)
2315 if (!strcmp (tinsn
->name
, "lda"))
2317 if (tinsn
->num_operands
< 2 || tinsn
->num_operands
> 2)
2318 as_fatal ("Illegal internal LDA insn definition");
2320 if (tinsn
->operands
[0].mode
== M_REGISTER
2321 && tinsn
->operands
[1].mode
== M_REGISTER
2322 && tinsn
->operands
[0].expr
.X_add_number
== tinsn
->operands
[1].expr
.X_add_number
)
2323 as_bad (_("Source and destination register should not be equal"));
2325 else if (!strcmp (tinsn
->name
, "ldi_ldi")
2326 || !strcmp (tinsn
->name
, "ldi1_ldi2")
2327 || !strcmp (tinsn
->name
, "ldi2_ldi1")
2328 || !strcmp (tinsn
->name
, "ldf_ldf")
2329 || !strcmp (tinsn
->name
, "ldf1_ldf2")
2330 || !strcmp (tinsn
->name
, "ldf2_ldf1") )
2332 if (tinsn
->num_operands
< 4 || tinsn
->num_operands
> 5)
2333 as_fatal ("Illegal internal %s insn definition", tinsn
->name
);
2335 if (tinsn
->operands
[1].mode
== M_REGISTER
2336 && tinsn
->operands
[tinsn
->num_operands
-1].mode
== M_REGISTER
2337 && tinsn
->operands
[1].expr
.X_add_number
== tinsn
->operands
[tinsn
->num_operands
-1].expr
.X_add_number
)
2338 as_warn (_("Equal parallel destination registers, one result will be discarded"));
2343 tic4x_insn_output (tic4x_insn_t
*tinsn
)
2347 /* Grab another fragment for opcode. */
2348 dst
= frag_more (tinsn
->nchars
);
2350 /* Put out opcode word as a series of bytes in little endian order. */
2351 md_number_to_chars (dst
, tinsn
->opcode
, tinsn
->nchars
);
2353 /* Put out the symbol-dependent stuff. */
2354 if (tinsn
->reloc
!= NO_RELOC
)
2356 /* Where is the offset into the fragment for this instruction. */
2357 fix_new_exp (frag_now
,
2358 dst
- frag_now
->fr_literal
, /* where */
2359 tinsn
->nchars
, /* size */
2366 /* Parse the operands. */
2368 tic4x_operands_parse (char *s
, tic4x_operand_t
*operands
, int num_operands
)
2371 return num_operands
;
2374 s
= tic4x_operand_parse (s
, &operands
[num_operands
++]);
2375 while (num_operands
< TIC4X_OPERANDS_MAX
&& *s
++ == ',');
2377 if (num_operands
> TIC4X_OPERANDS_MAX
)
2379 as_bad (_("Too many operands scanned"));
2382 return num_operands
;
2385 /* Assemble a single instruction. Its label has already been handled
2386 by the generic front end. We just parse mnemonic and operands, and
2387 produce the bytes of data and relocation. */
2389 md_assemble (char *str
)
2396 tic4x_inst_t
*inst
; /* Instruction template. */
2397 tic4x_inst_t
*first_inst
;
2399 /* Scan for parallel operators */
2403 while (*s
&& *s
!= '|')
2406 if (*s
&& s
[1]=='|')
2410 as_bad (_("Parallel opcode cannot contain more than two instructions"));
2416 /* Lets take care of the first part of the parallel insn */
2421 /* .. and let the second run though here */
2425 if (str
&& insn
->parallel
)
2427 /* Find mnemonic (second part of parallel instruction). */
2429 /* Skip past instruction mnemonic. */
2430 while (*s
&& *s
!= ' ')
2432 if (*s
) /* Null terminate for str_hash_find. */
2433 *s
++ = '\0'; /* and skip past null. */
2434 len
= strlen (insn
->name
);
2435 snprintf (insn
->name
+ len
, TIC4X_NAME_MAX
- len
, "_%s", str
);
2437 insn
->operands
[insn
->num_operands
++].mode
= M_PARALLEL
;
2439 if ((i
= tic4x_operands_parse
2440 (s
, insn
->operands
, insn
->num_operands
)) < 0)
2446 insn
->num_operands
= i
;
2452 if ((insn
->inst
= (struct tic4x_inst
*)
2453 str_hash_find (tic4x_op_hash
, insn
->name
)) == NULL
)
2455 as_bad (_("Unknown opcode `%s'."), insn
->name
);
2465 ok
= tic4x_operands_match (inst
, insn
, 1);
2473 while (!ok
&& !strcmp (inst
->name
, inst
[1].name
) && inst
++);
2477 tic4x_insn_check (insn
);
2478 tic4x_insn_output (insn
);
2483 tic4x_operands_match (first_inst
, insn
, 0);
2484 as_bad (_("Invalid operands for %s"), insn
->name
);
2487 as_bad (_("Invalid instruction %s"), insn
->name
);
2492 /* Find mnemonic. */
2494 while (*s
&& *s
!= ' ') /* Skip past instruction mnemonic. */
2496 if (*s
) /* Null terminate for str_hash_find. */
2497 *s
++ = '\0'; /* and skip past null. */
2498 strncpy (insn
->name
, str
, TIC4X_NAME_MAX
- 1);
2499 insn
->name
[TIC4X_NAME_MAX
- 1] = '\0';
2501 if ((i
= tic4x_operands_parse (s
, insn
->operands
, 0)) < 0)
2503 insn
->inst
= NULL
; /* Flag that error occurred. */
2508 insn
->num_operands
= i
;
2517 tic4x_cleanup (void)
2523 /* Turn a string in input_line_pointer into a floating point constant
2524 of type type, and store the appropriate bytes in *litP. The number
2525 of chars emitted is stored in *sizeP. An error message is
2526 returned, or NULL on OK. */
2529 md_atof (int type
, char *litP
, int *sizeP
)
2533 LITTLENUM_TYPE words
[MAX_LITTLENUMS
];
2534 LITTLENUM_TYPE
*wordP
;
2539 case 's': /* .single */
2545 case 'd': /* .double */
2547 case 'f': /* .float */
2550 prec
= 2; /* 1 32-bit word */
2553 case 'i': /* .ieee */
2557 type
= 'f'; /* Rewrite type to be usable by atof_ieee(). */
2560 case 'e': /* .ldouble */
2562 prec
= 4; /* 2 32-bit words */
2568 return _("Unrecognized or unsupported floating point constant");
2572 t
= atof_ieee (input_line_pointer
, type
, words
);
2574 t
= tic4x_atof (input_line_pointer
, type
, words
);
2576 input_line_pointer
= t
;
2577 *sizeP
= prec
* sizeof (LITTLENUM_TYPE
);
2579 /* This loops outputs the LITTLENUMs in REVERSE order; in accord with
2580 little endian byte order. */
2581 /* SES: However it is required to put the words (32-bits) out in the
2582 correct order, hence we write 2 and 2 littlenums in little endian
2583 order, while we keep the original order on successive words. */
2584 for (wordP
= words
; wordP
<(words
+prec
) ; wordP
+=2)
2586 if (wordP
< (words
+ prec
- 1)) /* Dump wordP[1] (if we have one). */
2588 md_number_to_chars (litP
, (valueT
) (wordP
[1]),
2589 sizeof (LITTLENUM_TYPE
));
2590 litP
+= sizeof (LITTLENUM_TYPE
);
2594 md_number_to_chars (litP
, (valueT
) (wordP
[0]),
2595 sizeof (LITTLENUM_TYPE
));
2596 litP
+= sizeof (LITTLENUM_TYPE
);
2602 md_apply_fix (fixS
*fixP
, valueT
*value
, segT seg ATTRIBUTE_UNUSED
)
2604 char *buf
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
2605 valueT val
= *value
;
2607 switch (fixP
->fx_r_type
)
2609 case BFD_RELOC_HI16
:
2613 case BFD_RELOC_LO16
:
2620 switch (fixP
->fx_r_type
)
2626 case BFD_RELOC_24_PCREL
:
2630 case BFD_RELOC_16_PCREL
:
2631 case BFD_RELOC_LO16
:
2632 case BFD_RELOC_HI16
:
2639 as_bad (_("Bad relocation type: 0x%02x"), fixP
->fx_r_type
);
2643 if (fixP
->fx_addsy
== NULL
&& fixP
->fx_pcrel
== 0) fixP
->fx_done
= 1;
2646 /* Should never be called for tic4x. */
2648 md_convert_frag (bfd
*headers ATTRIBUTE_UNUSED
,
2649 segT sec ATTRIBUTE_UNUSED
,
2650 fragS
*fragP ATTRIBUTE_UNUSED
)
2652 as_fatal ("md_convert_frag");
2655 /* Should never be called for tic4x. */
2657 md_create_short_jump (char *ptr ATTRIBUTE_UNUSED
,
2658 addressT from_addr ATTRIBUTE_UNUSED
,
2659 addressT to_addr ATTRIBUTE_UNUSED
,
2660 fragS
*frag ATTRIBUTE_UNUSED
,
2661 symbolS
*to_symbol ATTRIBUTE_UNUSED
)
2663 as_fatal ("md_create_short_jmp\n");
2666 /* Should never be called for tic4x. */
2668 md_create_long_jump (char *ptr ATTRIBUTE_UNUSED
,
2669 addressT from_addr ATTRIBUTE_UNUSED
,
2670 addressT to_addr ATTRIBUTE_UNUSED
,
2671 fragS
*frag ATTRIBUTE_UNUSED
,
2672 symbolS
*to_symbol ATTRIBUTE_UNUSED
)
2674 as_fatal ("md_create_long_jump\n");
2677 /* Should never be called for tic4x. */
2679 md_estimate_size_before_relax (fragS
*fragP ATTRIBUTE_UNUSED
,
2680 segT segtype ATTRIBUTE_UNUSED
)
2682 as_fatal ("md_estimate_size_before_relax\n");
2688 md_parse_option (int c
, const char *arg
)
2692 case OPTION_CPU
: /* cpu brand */
2693 if (TOLOWER (*arg
) == 'c')
2695 tic4x_cpu
= atoi (arg
);
2696 if (!IS_CPU_TIC3X (tic4x_cpu
) && !IS_CPU_TIC4X (tic4x_cpu
))
2697 as_warn (_("Unsupported processor generation %d"), tic4x_cpu
);
2700 case OPTION_REV
: /* cpu revision */
2701 tic4x_revision
= atoi (arg
);
2705 as_warn (_("Option -b is depreciated, please use -mbig"));
2707 case OPTION_BIG
: /* big model */
2708 tic4x_big_model
= 1;
2712 as_warn (_("Option -p is depreciated, please use -mmemparm"));
2714 case OPTION_MEMPARM
: /* push args */
2719 as_warn (_("Option -r is depreciated, please use -mregparm"));
2721 case OPTION_REGPARM
: /* register args */
2726 as_warn (_("Option -s is depreciated, please use -msmall"));
2728 case OPTION_SMALL
: /* small model */
2729 tic4x_big_model
= 0;
2736 case OPTION_LOWPOWER
:
2740 case OPTION_ENHANCED
:
2752 md_show_usage (FILE *stream
)
2755 _("\nTIC4X options:\n"
2756 " -mcpu=CPU -mCPU select architecture variant. CPU can be:\n"
2758 " 31 - TMS320C31, TMS320LC31\n"
2760 " 33 - TMS320VC33\n"
2763 " -mrev=REV set cpu hardware revision (integer numbers).\n"
2764 " Combinations of -mcpu and -mrev will enable/disable\n"
2765 " the appropriate options (-midle2, -mlowpower and\n"
2766 " -menhanced) according to the selected type\n"
2767 " -mbig select big memory model\n"
2768 " -msmall select small memory model (default)\n"
2769 " -mregparm select register parameters (default)\n"
2770 " -mmemparm select memory parameters\n"
2771 " -midle2 enable IDLE2 support\n"
2772 " -mlowpower enable LOPOWER and MAXSPEED support\n"
2773 " -menhanced enable enhanced opcode support\n"));
2776 /* This is called when a line is unrecognized. This is used to handle
2777 definitions of TI C3x tools style local labels $n where n is a single
2780 tic4x_unrecognized_line (int c
)
2785 if (c
!= '$' || ! ISDIGIT (input_line_pointer
[0]))
2788 s
= input_line_pointer
;
2790 /* Let's allow multiple digit local labels. */
2792 while (ISDIGIT (*s
))
2794 lab
= lab
* 10 + *s
- '0';
2798 if (dollar_label_defined (lab
))
2800 as_bad (_("Label \"$%d\" redefined"), lab
);
2804 define_dollar_label (lab
);
2805 colon (dollar_label_name (lab
, 0));
2806 input_line_pointer
= s
+ 1;
2811 /* Handle local labels peculiar to us referred to in an expression. */
2813 md_undefined_symbol (char *name
)
2815 /* Look for local labels of the form $n. */
2816 if (name
[0] == '$' && ISDIGIT (name
[1]))
2822 while (ISDIGIT ((unsigned char) *s
))
2824 lab
= lab
* 10 + *s
- '0';
2827 if (dollar_label_defined (lab
))
2829 name
= dollar_label_name (lab
, 0);
2830 symbolP
= symbol_find (name
);
2834 name
= dollar_label_name (lab
, 1);
2835 symbolP
= symbol_find_or_make (name
);
2843 /* Parse an operand that is machine-specific. */
2845 md_operand (expressionS
*expressionP ATTRIBUTE_UNUSED
)
2849 /* Round up a section size to the appropriate boundary---do we need this? */
2851 md_section_align (segT segment ATTRIBUTE_UNUSED
, valueT size
)
2853 return size
; /* Byte (i.e., 32-bit) alignment is fine? */
2857 tic4x_pc_offset (unsigned int op
)
2859 /* Determine the PC offset for a C[34]x instruction.
2860 This could be simplified using some boolean algebra
2861 but at the expense of readability. */
2865 case 0x62: /* call (C4x) */
2866 case 0x64: /* rptb (C4x) */
2868 case 0x61: /* brd */
2869 case 0x63: /* laj */
2870 case 0x65: /* rptbd (C4x) */
2872 case 0x66: /* swi */
2879 switch ((op
& 0xffe00000) >> 20)
2881 case 0x6a0: /* bB */
2882 case 0x720: /* callB */
2883 case 0x740: /* trapB */
2886 case 0x6a2: /* bBd */
2887 case 0x6a6: /* bBat */
2888 case 0x6aa: /* bBaf */
2889 case 0x722: /* lajB */
2890 case 0x748: /* latB */
2891 case 0x798: /* rptbd */
2898 switch ((op
& 0xfe200000) >> 20)
2900 case 0x6e0: /* dbB */
2903 case 0x6e2: /* dbBd */
2913 /* Exactly what point is a PC-relative offset relative TO?
2914 With the C3x we have the following:
2915 DBcond, Bcond disp + PC + 1 => PC
2916 DBcondD, BcondD disp + PC + 3 => PC
2919 md_pcrel_from (fixS
*fixP
)
2924 buf
= (unsigned char *) fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
2925 op
= ((unsigned) buf
[3] << 24) | (buf
[2] << 16) | (buf
[1] << 8) | buf
[0];
2927 return ((fixP
->fx_where
+ fixP
->fx_frag
->fr_address
) >> 2) +
2928 tic4x_pc_offset (op
);
2931 /* Fill the alignment area with NOP's on .text, unless fill-data
2934 tic4x_do_align (int alignment
,
2939 /* Because we are talking lwords, not bytes, adjust alignment to do words */
2942 if (alignment
!= 0 && !need_pass_2
)
2946 if (subseg_text_p (now_seg
))
2950 md_number_to_chars (nop
, TIC_NOP_OPCODE
, 4);
2951 frag_align_pattern (alignment
, nop
, sizeof (nop
), max
);
2954 frag_align (alignment
, 0, max
);
2957 frag_align (alignment
, *fill
, max
);
2959 frag_align_pattern (alignment
, fill
, len
, max
);
2962 /* Return 1 to skip the default alignment function */
2966 /* Look for and remove parallel instruction operator ||. */
2968 tic4x_start_line (void)
2970 char *s
= input_line_pointer
;
2974 /* If parallel instruction prefix found at start of line, skip it. */
2975 if (*input_line_pointer
== '|' && input_line_pointer
[1] == '|')
2980 input_line_pointer
++;
2981 *input_line_pointer
= ' ';
2982 /* So line counters get bumped. */
2983 input_line_pointer
[-1] = '\n';
2988 /* Write out the previous insn here */
2991 input_line_pointer
= s
;
2996 tc_gen_reloc (asection
*seg ATTRIBUTE_UNUSED
, fixS
*fixP
)
3000 reloc
= XNEW (arelent
);
3002 reloc
->sym_ptr_ptr
= XNEW (asymbol
*);
3003 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixP
->fx_addsy
);
3004 reloc
->address
= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
3005 reloc
->address
/= OCTETS_PER_BYTE
;
3006 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixP
->fx_r_type
);
3007 if (reloc
->howto
== (reloc_howto_type
*) NULL
)
3009 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
3010 _("Reloc %d not supported by object file format"),
3011 (int) fixP
->fx_r_type
);
3015 if (fixP
->fx_r_type
== BFD_RELOC_HI16
)
3016 reloc
->addend
= fixP
->fx_offset
;
3018 reloc
->addend
= fixP
->fx_addnumber
;