1 /* tc-tic80.c -- Assemble for the TI TMS320C80 (MV)
2 Copyright (C) 1996, 1997 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to the Free
18 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
22 #include "opcode/tic80.h"
24 #define internal_error(what) \
25 as_fatal("internal error:%s:%d: %s\n",__FILE__,__LINE__,what)
26 #define internal_error_a(what,arg) \
27 as_fatal("internal error:%s:%d: %s %d\n",__FILE__,__LINE__,what,arg)
30 /* Generic assembler global variables which must be defined by all targets. */
32 /* Characters which always start a comment. */
33 const char comment_chars
[] = ";";
35 /* Characters which start a comment at the beginning of a line. */
36 const char line_comment_chars
[] = ";*";
38 /* Characters which may be used to separate multiple commands on a single
39 line. The semicolon is such a character by default and should not be
41 const char line_separator_chars
[] = "";
43 /* Characters which are used to indicate an exponent in a floating
45 const char EXP_CHARS
[] = "eE";
47 /* Characters which mean that a number is a floating point constant,
49 const char FLT_CHARS
[] = "dD";
51 /* This table describes all the machine specific pseudo-ops the assembler
52 has to support. The fields are:
54 pseudo-op name without dot
55 function to call to execute this pseudo-op
56 integer arg to pass to the function */
58 const pseudo_typeS md_pseudo_table
[] =
60 { "word", cons
, 4 }, /* FIXME: Should this be machine independent? */
61 { "bss", s_lcomm
, 1 },
65 /* Opcode hash table. */
66 static struct hash_control
*tic80_hash
;
68 static struct tic80_opcode
* find_opcode
PARAMS ((struct tic80_opcode
*, expressionS
[]));
69 static void build_insn
PARAMS ((struct tic80_opcode
*, expressionS
*));
70 static int get_operands
PARAMS ((expressionS exp
[]));
71 static int const_overflow
PARAMS ((unsigned long num
, int bits
, int flags
));
75 md_estimate_size_before_relax (fragP
, segment_type
)
79 internal_error ("Relaxation is a luxury we can't afford");
83 /* We have no need to default values of symbols. */
87 md_undefined_symbol (name
)
93 /* Turn a string in input_line_pointer into a floating point constant of type
94 type, and store the appropriate bytes in *litP. The number of LITTLENUMS
95 emitted is stored in *sizeP . An error message is returned, or NULL on OK.
98 #define MAX_LITTLENUMS 4
101 md_atof (type
, litP
, sizeP
)
107 LITTLENUM_TYPE words
[MAX_LITTLENUMS
];
108 LITTLENUM_TYPE
*wordP
;
130 return "bad call to md_atof ()";
133 t
= atof_ieee (input_line_pointer
, type
, words
);
136 input_line_pointer
= t
;
139 *sizeP
= prec
* sizeof (LITTLENUM_TYPE
);
141 for (wordP
= words
; prec
--;)
143 md_number_to_chars (litP
, (valueT
) (*wordP
++), sizeof (LITTLENUM_TYPE
));
144 litP
+= sizeof (LITTLENUM_TYPE
);
149 /* Check to see if the constant value in NUM will fit in a field of
150 width BITS if it has flags FLAGS. */
153 const_overflow (num
, bits
, flags
)
161 /* Only need to check fields less than 32 bits wide */
163 if (flags
& TIC80_OPERAND_SIGNED
)
165 max
= (1 << (bits
- 1)) - 1;
166 min
= - (1 << (bits
- 1));
167 retval
= ((long) num
> max
) || ((long) num
< min
);
171 max
= (1 << bits
) - 1;
173 retval
= (num
> max
) || (num
< min
);
178 /* get_operands() parses a string of operands and fills in a passed array of
181 Note that we use O_absent expressions to record additional information
182 about the previous non-O_absent expression, such as ":m" or ":s"
183 modifiers or register numbers enclosed in parens like "(r10)".
185 Returns the number of expressions that were placed in EXP.
193 char *p
= input_line_pointer
;
201 /* Skip leading whitespace */
202 while (*p
== ' ' || *p
== '\t' || *p
== ',')
207 /* Check to see if we have any operands left to parse */
208 if (*p
== 0 || *p
== '\n' || *p
== '\r')
213 /* Notice scaling or direct memory operand modifiers and save them in
214 an O_absent expression after the expression that they modify. */
219 exp
[numexp
].X_op
= O_absent
;
223 exp
[numexp
].X_add_number
= TIC80_OPERAND_M_SI
| TIC80_OPERAND_M_LI
;
228 exp
[numexp
].X_add_number
= TIC80_OPERAND_SCALED
;
232 as_bad ("':' not followed by 'm' or 's'");
238 /* Handle leading '(' on operands that use them, by recording that we
239 have entered a paren nesting level and then continuing. We complain
240 about multiple nesting. */
246 as_bad ("paren nesting");
252 /* Handle trailing ')' on operands that use them, by reducing the
253 nesting level and then continuing. We complain if there were too
258 /* Record that we have left a paren group and continue */
261 as_bad ("mismatched parenthesis");
267 /* Begin operand parsing at the current scan point. */
269 input_line_pointer
= p
;
270 expression (&exp
[numexp
]);
272 if (exp
[numexp
].X_op
== O_illegal
)
274 as_bad ("illegal operand");
276 else if (exp
[numexp
].X_op
== O_absent
)
278 as_bad ("missing operand");
282 p
= input_line_pointer
;
287 exp
[numexp
].X_op
= O_absent
;
288 exp
[numexp
++].X_add_number
= TIC80_OPERAND_PARENS
;
291 /* Mark the end of the valid operands with an illegal expression. */
292 exp
[numexp
].X_op
= O_illegal
;
297 /* find_opcode() gets a pointer to the entry in the opcode table that
298 matches the instruction being assembled, or returns NULL if no such match
301 First it parses all the operands and save them as expressions. Note that
302 we use O_absent expressions to record additional information about the
303 previous non-O_absent expression, such as ":m" or ":s" modifiers or
304 register numbers enclosed in parens like "(r10)".
306 It then looks at all opcodes with the same name and uses the operands to
307 choose the correct opcode. */
309 static struct tic80_opcode
*
310 find_opcode (opcode
, myops
)
311 struct tic80_opcode
*opcode
;
314 int numexp
; /* Number of expressions from parsing operands */
315 int expi
; /* Index of current expression to match */
316 int opi
; /* Index of current operand to match */
317 int match
= 0; /* Set to 1 when an operand match is found */
318 struct tic80_opcode
*opc
= opcode
; /* Pointer to current opcode table entry */
319 const struct tic80_opcode
*end
; /* Pointer to end of opcode table */
321 /* First parse all the operands so we only have to do it once. There may
322 be more expressions generated than there are operands. */
324 numexp
= get_operands (myops
);
326 /* For each opcode with the same name, try to match it against the parsed
329 end
= tic80_opcodes
+ tic80_num_opcodes
;
330 while (!match
&& (opc
< end
) && (strcmp (opc
-> name
, opcode
-> name
) == 0))
332 /* Start off assuming a match. If we find a mismatch, then this is
333 reset and the operand/expr matching loop terminates with match
334 equal to zero, which allows us to try the next opcode. */
338 /* For each expression, try to match it against the current operand
339 for the current opcode. Upon any mismatch, we abandon further
340 matching for the current opcode table entry. */
342 for (expi
= 0, opi
= -1; (expi
< numexp
) && match
; expi
++)
344 int bits
, flags
, X_op
, num
;
346 X_op
= myops
[expi
].X_op
;
347 num
= myops
[expi
].X_add_number
;
348 if (X_op
!= O_absent
)
350 /* The O_absent expressions apply to the previously seen
351 operand, so only increment the operand index when the
352 current expression needs to be matched against the next
356 flags
= tic80_operands
[opc
-> operands
[opi
]].flags
;
357 bits
= tic80_operands
[opc
-> operands
[opi
]].bits
;
362 /* Also check that registers that are supposed to be even actually
364 if (((flags
& TIC80_OPERAND_GPR
) != (num
& TIC80_OPERAND_GPR
)) ||
365 ((flags
& TIC80_OPERAND_FPA
) != (num
& TIC80_OPERAND_FPA
)) ||
366 ((flags
& TIC80_OPERAND_CR
) != (num
& TIC80_OPERAND_CR
)) ||
367 ((flags
& TIC80_OPERAND_EVEN
) && (num
& 1)) ||
368 const_overflow (num
& ~TIC80_OPERAND_MASK
, bits
, flags
))
374 if ((flags
& TIC80_OPERAND_ENDMASK
) && (num
== 32))
376 /* Endmask values of 0 and 32 give identical results */
379 if ((flags
& (TIC80_OPERAND_FPA
| TIC80_OPERAND_GPR
)) ||
380 const_overflow (num
, bits
, flags
))
386 if ((bits
< 32) && (flags
& TIC80_OPERAND_PCREL
))
388 /* For now we only allow PC relative relocations in the
389 short immediate fields, like the TI assembler.
390 FIXME: Should be able to choose "best-fit". */
392 else if ((bits
== 32) /* && (flags & TIC80_OPERAND_BASEREL) */)
394 /* For now we only allow base relative relocations in
395 the long immediate fields, like the TI assembler.
396 FIXME: Should be able to choose "best-fit". */
400 /* Symbols that don't match one of the above cases are
401 rejected as an operand. */
417 case O_bit_inclusive_or
:
419 case O_bit_exclusive_or
:
433 internal_error_a ("unhandled expression type", X_op
);
442 return (match
? opc
: NULL
);
446 /* Now search the opcode table table for one with operands that
447 matches what we've got. */
452 for (i
= 0; opcode
-> operands
[i
]; i
++)
454 int flags
= tic80_operands
[opcode
->operands
[i
]].flags
;
455 int X_op
= myops
[i
].X_op
;
456 int num
= myops
[i
].X_add_number
;
464 if (flags
& (TIC80_OPERAND_GPR
| TIC80_OPERAND_FPA
| TIC80_OPERAND_CR
))
466 if ((X_op
!= O_register
) ||
467 ((flags
& TIC80_OPERAND_GPR
) != (num
& TIC80_OPERAND_GPR
)) ||
468 ((flags
& TIC80_OPERAND_FPA
) != (num
& TIC80_OPERAND_FPA
)) ||
469 ((flags
& TIC80_OPERAND_CR
) != (num
& TIC80_OPERAND_CR
)))
476 if (((flags
& TIC80_OPERAND_MINUS
) && ((X_op
!= O_absent
) || (num
!= TIC80_OPERAND_MINUS
))) ||
477 ((flags
& TIC80_OPERAND_PLUS
) && ((X_op
!= O_absent
) || (num
!= TIC80_OPERAND_PLUS
))) ||
478 ((flags
& TIC80_OPERAND_ATMINUS
) && ((X_op
!= O_absent
) || (num
!= TIC80_OPERAND_ATMINUS
))) ||
479 ((flags
& TIC80_OPERAND_ATPAR
) && ((X_op
!= O_absent
) || (num
!= TIC80_OPERAND_ATPAR
))) ||
480 ((flags
& TIC80_OPERAND_ATSIGN
) && ((X_op
!= O_absent
) || (num
!= TIC80_OPERAND_ATSIGN
))))
486 /* we're only done if the operands matched so far AND there
487 are no more to check */
488 if (match
&& myops
[i
].X_op
==0)
493 next_opcode
= opcode
+1;
494 if (next_opcode
->opcode
== 0)
496 if (strcmp(next_opcode
->name
, opcode
->name
))
498 opcode
= next_opcode
;
503 as_bad ("bad opcode or operands");
507 /* Check that all registers that are required to be even are. */
508 /* Also, if any operands were marked as registers, but were really symbols */
510 for (i
=0; opcode
->operands
[i
]; i
++)
512 if ((tic80_operands
[opcode
->operands
[i
]].flags
& TIC80_OPERAND_EVEN
) &&
513 (myops
[i
].X_add_number
& 1))
514 as_fatal ("Register number must be EVEN");
515 if (myops
[i
].X_op
== O_register
)
517 if (!(tic80_operands
[opcode
->operands
[i
]].flags
& TIC80_OPERAND_REG
))
519 myops
[i
].X_op
= O_symbol
;
520 myops
[i
].X_add_symbol
= symbol_find_or_make ((char *)myops
[i
].X_op_symbol
);
521 myops
[i
].X_add_number
= 0;
522 myops
[i
].X_op_symbol
= NULL
;
530 /* build_insn takes a pointer to the opcode entry in the opcode table
531 and the array of operand expressions and writes out the instruction. */
534 build_insn (opcode
, opers
)
535 struct tic80_opcode
*opcode
;
538 int expi
; /* Index of current expression to match */
539 int opi
; /* Index of current operand to match */
540 unsigned long insn
[2]; /* Instruction and long immediate (if any) */
541 int extended
= 0; /* Nonzero if instruction is 8 bytes */
542 char *f
; /* Temporary pointer to output location */
544 /* Start with the raw opcode bits from the opcode table. */
545 insn
[0] = opcode
-> opcode
;
547 /* We are going to insert at least one 32 bit opcode so get the
552 /* For each operand expression, insert the appropriate bits into the
554 for (expi
= 0, opi
= -1; opers
[expi
].X_op
!= O_illegal
; expi
++)
556 int bits
, shift
, flags
, X_op
, num
;
558 X_op
= opers
[expi
].X_op
;
559 num
= opers
[expi
].X_add_number
;
560 if (X_op
!= O_absent
)
562 /* The O_absent expressions apply to the previously seen
563 operand, so only increment the operand index when the
564 current expression needs to be matched against the next
570 /* Found a modifier that applies to the previously
571 seen operand, so handle it. */
572 switch (opers
[expi
].X_add_number
)
574 case TIC80_OPERAND_M_SI
| TIC80_OPERAND_M_LI
:
575 internal_error_a ("unhandled operand modifier", opers
[expi
].X_add_number
);
577 case TIC80_OPERAND_SCALED
:
578 internal_error_a ("unhandled operand modifier", opers
[expi
].X_add_number
);
580 case TIC80_OPERAND_PARENS
:
581 internal_error_a ("unhandled operand modifier", opers
[expi
].X_add_number
);
584 internal_error_a ("unhandled operand modifier", opers
[expi
].X_add_number
);
588 flags
= tic80_operands
[opcode
-> operands
[opi
]].flags
;
589 bits
= tic80_operands
[opcode
-> operands
[opi
]].bits
;
590 shift
= tic80_operands
[opcode
-> operands
[opi
]].shift
;
595 num
&= ~TIC80_OPERAND_MASK
;
596 insn
[0] = insn
[0] | (num
<< shift
);
599 if ((flags
& TIC80_OPERAND_ENDMASK
) && (num
== 32))
601 /* Endmask values of 0 and 32 give identical results */
604 else if ((flags
& TIC80_OPERAND_BITNUM
))
606 /* BITNUM values are stored in one's complement form */
609 /* Mask off upper bits, just it case it is signed and is negative */
612 num
&= (1 << bits
) - 1;
613 insn
[0] = insn
[0] | (num
<< shift
);
622 if (flags
& TIC80_OPERAND_PCREL
)
624 fix_new_exp (frag_now
,
625 f
- (frag_now
-> fr_literal
),
626 4, /* FIXME! how is this used? */
631 else if (bits
== 32) /* was (flags & TIC80_OPERAND_BASEREL) */
634 fix_new_exp (frag_now
,
635 (f
+ 4) - (frag_now
-> fr_literal
),
643 internal_error ("symbol reloc that is not PC relative or 32 bits");
658 case O_bit_inclusive_or
:
660 case O_bit_exclusive_or
:
674 internal_error_a ("unhandled expression", X_op
);
679 /* Write out the instruction, either 4 or 8 bytes. */
681 md_number_to_chars (f
, insn
[0], 4);
685 md_number_to_chars (f
, insn
[1], 4);
689 /* This is the main entry point for the machine-dependent assembler. Gas
690 calls this function for each input line which does not contain a
693 STR points to a NULL terminated machine dependent instruction. This
694 function is supposed to emit the frags/bytes it assembles to. */
701 unsigned char *input_line_save
;
702 struct tic80_opcode
*opcode
;
703 expressionS myops
[16];
706 /* Ensure there is something there to assemble. */
709 /* Drop any leading whitespace. */
710 while (isspace (*str
))
715 /* Isolate the mnemonic from the rest of the string by finding the first
716 whitespace character and zapping it to a null byte. */
717 for (scan
= str
; *scan
!= '\000' && !isspace (*scan
); scan
++) {;}
723 /* Try to find this mnemonic in the hash table */
724 if ((opcode
= (struct tic80_opcode
*) hash_find (tic80_hash
, str
)) == NULL
)
726 as_bad ("Invalid mnemonic: '%s'", str
);
731 while (isspace (*scan
))
736 input_line_save
= input_line_pointer
;
737 input_line_pointer
= str
;
739 opcode
= find_opcode (opcode
, myops
);
742 as_bad ("Invalid operands: '%s'", input_line_save
);
745 input_line_pointer
= input_line_save
;
746 build_insn (opcode
, myops
);
749 /* This function is called once at the start of assembly, after the command
750 line arguments have been parsed and all the machine independent
751 initializations have been completed.
753 It should set up all the tables, etc., that the machine dependent part of
754 the assembler will need. */
759 char *prev_name
= "";
760 register const struct tic80_opcode
*op
;
761 register const struct tic80_opcode
*op_end
;
762 const struct predefined_symbol
*pdsp
;
764 tic80_hash
= hash_new ();
766 /* Insert unique names into hash table. The TIc80 instruction set
767 has many identical opcode names that have different opcodes based
768 on the operands. This hash table then provides a quick index to
769 the first opcode with a particular name in the opcode table. */
771 op_end
= tic80_opcodes
+ tic80_num_opcodes
;
772 for (op
= tic80_opcodes
; op
< op_end
; op
++)
774 if (strcmp (prev_name
, op
-> name
) != 0)
776 prev_name
= (char *) op
-> name
;
777 hash_insert (tic80_hash
, op
-> name
, (char *) op
);
781 /* Insert the predefined symbols into the symbol table. We use symbol_create
782 rather than symbol_new so that these symbols don't end up in the object
783 files' symbol table. Note that the values of the predefined symbols include
784 some upper bits that distinguish the type of the symbol (register, bitnum,
785 condition code, etc) and these bits must be masked away before actually
786 inserting the values into the instruction stream. For registers we put
787 these bits in the symbol table since we use them later and there is no
788 question that they aren't part of the register number. For constants we
789 can't do that since the constant can be any value, so they are masked off
790 before putting them into the symbol table. */
793 while ((pdsp
= tic80_next_predefined_symbol (pdsp
)) != NULL
)
799 symtype
= PDS_VALUE (pdsp
) & TIC80_OPERAND_MASK
;
802 case TIC80_OPERAND_GPR
:
803 case TIC80_OPERAND_FPA
:
804 case TIC80_OPERAND_CR
:
805 segment
= reg_section
;
806 valu
= PDS_VALUE (pdsp
);
808 case TIC80_OPERAND_CC
:
809 case TIC80_OPERAND_BITNUM
:
810 segment
= absolute_section
;
811 valu
= PDS_VALUE (pdsp
) & ~TIC80_OPERAND_MASK
;
814 internal_error_a ("unhandled predefined symbol bits", symtype
);
817 symbol_table_insert (symbol_create (PDS_NAME (pdsp
), segment
, valu
,
818 &zero_address_frag
));
824 /* The assembler adds md_shortopts to the string passed to getopt. */
826 CONST
char *md_shortopts
= "";
828 /* The assembler adds md_longopts to the machine independent long options
829 that are passed to getopt. */
831 struct option md_longopts
[] = {
832 {NULL
, no_argument
, NULL
, 0}
835 size_t md_longopts_size
= sizeof(md_longopts
);
837 /* The md_parse_option function will be called whenever getopt returns an
838 unrecognized code, presumably indicating a special code value which
839 appears in md_longopts for machine specific command line options. */
842 md_parse_option (c
, arg
)
849 /* The md_show_usage function will be called whenever a usage message is
850 printed. It should print a description of the machine specific options
851 found in md_longopts. */
854 md_show_usage (stream
)
860 /* Attempt to simplify or even eliminate a fixup. The return value is
861 ignored; perhaps it was once meaningful, but now it is historical.
862 To indicate that a fixup has been eliminated, set fixP->fx_done.
866 md_apply_fix (fixP
, val
)
870 char *dest
= fixP
-> fx_frag
-> fr_literal
+ fixP
-> fx_where
;
872 switch (fixP
-> fx_r_type
)
875 md_number_to_chars (dest
, (valueT
) val
, 4);
878 /* FIXME! - should check for overflow of the 15 bit field */
880 *dest
= (*dest
& 0x80) | val
>> 10;
883 internal_error_a ("unhandled relocation type in fixup", fixP
-> fx_r_type
);
889 /* Functions concerning relocs. */
891 /* The location from which a PC relative jump should be calculated,
892 given a PC relative reloc.
894 For the TIc80, this is the address of the 32 bit opcode containing
895 the PC relative field. */
901 return (fixP
-> fx_frag
-> fr_address
+ fixP
-> fx_where
) ;
905 * Called after relax() is finished.
906 * In: Address of frag.
907 * fr_type == rs_machine_dependent.
908 * fr_subtype is what the address relaxed to.
910 * Out: Any fixSs and constants are set up.
911 * Caller will turn frag into a ".space 0".
915 md_convert_frag (headers
, seg
, fragP
)
916 object_headers
*headers
;
920 internal_error ("md_convert_frag() not implemented yet");
927 tc_coff_symbol_emit_hook (ignore
)
935 tc_coff_fix2rtype (fixP
)
938 return (fixP
-> fx_r_type
);
941 #endif /* OBJ_COFF */
943 /* end of tc-tic80.c */