1 /* tc-xgate.c -- Assembler code for Freescale XGATE
2 Copyright 2010, 2011, 2012
3 Free Software Foundation, Inc.
4 Contributed by Sean Keys <skeys@ipdatasys.com>
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. */
24 #include "safe-ctype.h"
26 #include "opcode/xgate.h"
27 #include "dwarf2dbg.h"
28 #include "elf/xgate.h"
30 const char comment_chars[] = ";!";
31 const char line_comment_chars[] = "#*";
32 const char line_separator_chars[] = "";
33 const char EXP_CHARS[] = "eE";
34 const char FLT_CHARS[] = "dD";
36 #define SIXTEENTH_BIT 0x8000
37 #define N_BITS_IN_WORD 16
38 #define MAX_NUM_OPERANDS 3
40 /* #define STATE_CONDITIONAL_BRANCH (1) */
41 #define STATE_PC_RELATIVE (2)
42 #define REGISTER_P(ptr) (ptr == 'r')
45 #define MAXREGISTER 07
46 #define MINREGISTER 00
48 #define OPTION_MMCU 'm'
50 /* This macro has no side-effects. */
51 #define ENCODE_RELAX(what,length) (((what) << 2) + (length))
53 /* Each unique opcode name has a handle. That handle may
54 contain pointers to opcodes with the same name but
55 different address modes. */
56 struct xgate_opcode_handle
60 struct xgate_opcode *opc0[MAX_OPCODES];
63 /* XGATE's registers all are 16-bit general purpose.
64 They are numbered according to the specifications. */
65 typedef enum register_id
80 /* Operand Modifiers */
81 typedef enum op_modifiers
91 typedef struct s_operand
99 /* Forward declarations. */
100 static inline char *skip_whitespace (char *);
101 static void get_default_target (void);
102 static char *extract_word (char *, char *, int);
103 static struct xgate_opcode *xgate_find_match (struct xgate_opcode_handle *,
105 static int cmp_opcode (struct xgate_opcode *, struct xgate_opcode *);
106 static void xgate_print_table (void);
107 static unsigned int xgate_get_operands (char *, s_operand []);
108 static register_id reg_name_search (char *);
109 static op_modifiers xgate_determine_modifiers(char **);
110 static void xgate_scan_operands (struct xgate_opcode *opcode, s_operand []);
111 static unsigned int xgate_parse_operand (struct xgate_opcode *, int *, int,
114 static struct hash_control *xgate_hash;
116 /* Previous opcode. */
117 static unsigned int prev = 0;
119 static unsigned char fixup_required = 0;
121 /* Used to enable clipping of 16 bit operands into 8 bit constraints. */
122 static unsigned char autoHiLo = 0;
124 static char oper_check;
125 static char flag_print_insn_syntax = 0;
126 static char flag_print_opcodes = 0;
128 static int current_architecture;
129 static const char *default_cpu;
131 /* ELF flags to set in the output file header. */
132 static int elf_flags = E_XGATE_F64;
134 /* This table describes how you change sizes for the various types of variable
135 size expressions. This version only supports two kinds. */
138 How far Forward this mode will reach.
139 How far Backward this mode will reach.
140 How many bytes this mode will add to the size of the frag.
141 Which mode to go to if the offset won't fit in this one. */
143 relax_typeS md_relax_table[] =
145 {1, 1, 0, 0}, /* First entries aren't used. */
146 {1, 1, 0, 0}, /* For no good reason except. */
147 {1, 1, 0, 0}, /* that the VAX doesn't either. */
149 /* XGATE 9 and 10 bit pc rel todo complete and test */
150 /*{(511), (-512), 0, ENCODE_RELAX (STATE_PC_RELATIVE, STATE_WORD)},
151 {(1023), (-1024), 0, ENCODE_RELAX (STATE_PC_RELATIVE, STATE_WORD)}, */
155 /* This table describes all the machine specific pseudo-ops the assembler
156 has to support. The fields are: pseudo-op name without dot function to
157 call to execute this pseudo-op Integer arg to pass to the function. */
158 const pseudo_typeS md_pseudo_table[] =
160 /* The following pseudo-ops are supported for MRI compatibility. */
164 const char *md_shortopts = "m:";
166 struct option md_longopts[] =
168 #define OPTION_PRINT_INSN_SYNTAX (OPTION_MD_BASE + 0)
169 { "print-insn-syntax", no_argument, NULL, OPTION_PRINT_INSN_SYNTAX },
171 #define OPTION_PRINT_OPCODES (OPTION_MD_BASE + 1)
172 { "print-opcodes", no_argument, NULL, OPTION_PRINT_OPCODES },
174 #define OPTION_GENERATE_EXAMPLE (OPTION_MD_BASE + 2)
175 { "generate-example", no_argument, NULL, OPTION_GENERATE_EXAMPLE },
177 #define OPTION_MSHORT (OPTION_MD_BASE + 3)
178 { "mshort", no_argument, NULL, OPTION_MSHORT },
180 #define OPTION_MLONG (OPTION_MD_BASE + 4)
181 { "mlong", no_argument, NULL, OPTION_MLONG },
183 #define OPTION_MSHORT_DOUBLE (OPTION_MD_BASE + 5)
184 { "mshort-double", no_argument, NULL, OPTION_MSHORT_DOUBLE },
186 #define OPTION_MLONG_DOUBLE (OPTION_MD_BASE + 6)
187 { "mlong-double", no_argument, NULL, OPTION_MLONG_DOUBLE },
189 { NULL, no_argument, NULL, 0 }
192 size_t md_longopts_size = sizeof(md_longopts);
195 md_atof (int type, char *litP, int *sizeP)
197 return ieee_md_atof (type, litP, sizeP, TRUE);
201 md_parse_option (int c, char *arg)
206 if (strcasecmp (arg, "v1") == 0)
207 current_architecture = XGATE_V1;
208 else if (strcasecmp (arg, "v2") == 0)
209 current_architecture = XGATE_V2;
210 else if (strcasecmp (arg, "v3") == 0)
211 current_architecture = XGATE_V3;
213 as_bad (_(" architecture variant invalid"));
216 case OPTION_PRINT_INSN_SYNTAX:
217 flag_print_insn_syntax = 1;
220 case OPTION_PRINT_OPCODES:
221 flag_print_opcodes = 1;
224 case OPTION_GENERATE_EXAMPLE:
225 flag_print_opcodes = 2;
229 elf_flags &= ~E_XGATE_I32;
233 elf_flags |= E_XGATE_I32;
236 case OPTION_MSHORT_DOUBLE:
237 elf_flags &= ~E_XGATE_F64;
240 case OPTION_MLONG_DOUBLE:
241 elf_flags |= E_XGATE_F64;
251 xgate_arch_format (void)
253 get_default_target ();
255 if (current_architecture & cpuxgate)
256 return "elf32-xgate";
262 get_default_target (void)
264 const bfd_target *target;
267 if (current_architecture != 0)
270 default_cpu = "unknown";
271 target = bfd_find_target (0, &abfd);
273 if (target && target->name)
275 if (strcmp (target->name, "elf32-xgate") == 0)
277 current_architecture = cpuxgate;
278 default_cpu = "XGATE V1";
282 as_bad (_("Default target `%s' is not supported."), target->name);
289 struct xgate_opcode *xgate_opcode_ptr = NULL;
290 struct xgate_opcode *xgate_op_table = NULL;
291 struct xgate_opcode_handle *op_handles = 0;
292 char *prev_op_name = 0;
294 int number_of_op_handles = 0;
297 /* Create a local copy of our opcode table
298 including an extra line for NULL termination. */
299 xgate_op_table = (struct xgate_opcode *)
300 xmalloc ((xgate_num_opcodes) * sizeof (struct xgate_opcode));
302 memset (xgate_op_table, 0,
303 sizeof(struct xgate_opcode) * (xgate_num_opcodes));
305 for (xgate_opcode_ptr = (struct xgate_opcode*) xgate_opcodes, i = 0;
306 i < xgate_num_opcodes; i++)
307 xgate_op_table[i] = xgate_opcode_ptr[i];
309 qsort (xgate_op_table, xgate_num_opcodes, sizeof(struct xgate_opcode),
310 (int (*)(const void *, const void *)) cmp_opcode);
312 /* Calculate number of handles since this will be
313 smaller than the raw number of opcodes in the table. */
315 for (xgate_opcode_ptr = xgate_op_table, i = 0; i < xgate_num_opcodes;
316 xgate_opcode_ptr++, i++)
318 if (strcmp (prev_op_name, xgate_opcode_ptr->name))
319 number_of_op_handles++;
320 prev_op_name = xgate_opcode_ptr->name;
323 op_handles = (struct xgate_opcode_handle *)
324 xmalloc (sizeof(struct xgate_opcode_handle) * (number_of_op_handles));
326 /* Insert unique opcode names into hash table, aliasing duplicates. */
327 xgate_hash = hash_new ();
330 for (xgate_opcode_ptr = xgate_op_table, i = 0, j = 0; i < xgate_num_opcodes;
331 i++, xgate_opcode_ptr++)
333 if (!strcmp (prev_op_name, xgate_opcode_ptr->name))
336 op_handles[j].opc0[handle_enum] = xgate_opcode_ptr;
343 op_handles[j].name = xgate_opcode_ptr->name;
344 op_handles[j].opc0[0] = xgate_opcode_ptr;
345 hash_insert (xgate_hash, (char *) op_handles[j].name,
346 (char *) &(op_handles[j]));
348 op_handles[j].number_of_modes = handle_enum;
349 prev_op_name = op_handles[j].name;
352 if (flag_print_opcodes)
354 print_opcode_list ();
360 xgate_init_after_args (void)
365 md_show_usage (FILE * stream)
367 get_default_target ();
371 Freescale XGATE co-processor options:\n\
372 -mshort use 16-bit int ABI (default)\n\
373 -mlong use 32-bit int ABI\n\
374 -mshort-double use 32-bit double ABI\n\
375 -mlong-double use 64-bit double ABI (default)\n\
376 --mxgate specify the processor variant[default %s]\n\
377 --print-insn-syntax print the syntax of instruction in case of error\n\
378 --print-opcodes print the list of instructions with syntax\n\
379 --generate-example generate an example of each instruction"),
383 enum bfd_architecture
386 get_default_target ();
387 return bfd_arch_xgate;
397 xgate_print_syntax (char *name)
401 for (i = 0; i < xgate_num_opcodes; i++)
403 if (!strcmp (xgate_opcodes[i].name, name))
405 if (!strcmp (xgate_opcodes[i].constraints, XGATE_OP_IDR))
406 printf ("\tFormat is %s\tRx, Rx, Rx+|-Rx|Rx\n",
407 xgate_opcodes[i].name);
408 if (!strcmp (xgate_opcodes[i].constraints, XGATE_OP_INH))
409 printf ("\tFormat is %s\n", xgate_opcodes[i].name);
410 if (!strcmp (xgate_opcodes[i].constraints, XGATE_OP_TRI))
411 printf ("\tFormat is %s\tRx, Rx, Rx\n", xgate_opcodes[i].name);
412 if (!strcmp (xgate_opcodes[i].constraints, XGATE_OP_DYA))
413 printf ("\tFormat is %s\tRx, Rx\n", xgate_opcodes[i].name);
414 if (!strcmp (xgate_opcodes[i].constraints, XGATE_OP_IMM3))
415 printf ("\tFormat is %s\t<3-bit value>\n", xgate_opcodes[i].name);
416 if (!strcmp (xgate_opcodes[i].constraints, XGATE_OP_IMM4))
417 printf ("\tFormat is %s\t<4 -bit value>\n", xgate_opcodes[i].name);
418 if (!strcmp (xgate_opcodes[i].constraints, XGATE_OP_IMM8))
419 printf ("\tFormat is %s\tRx, <8-bit value>\n",
420 xgate_opcodes[i].name);
421 if (!strcmp (xgate_opcodes[i].constraints, XGATE_OP_IMM16))
422 printf ("\tFormat is %s\tRx, <16-bit value>\n",
423 xgate_opcodes[i].name);
424 if (!strcmp (xgate_opcodes[i].constraints, XGATE_OP_MON_R_C))
425 printf ("\tFormat is %s\tRx, CCR\n", xgate_opcodes[i].name);
426 if (!strcmp (xgate_opcodes[i].constraints, XGATE_OP_MON_C_R))
427 printf ("\tFormat is %s\tCCR, Rx\n", xgate_opcodes[i].name);
428 if (!strcmp (xgate_opcodes[i].constraints, XGATE_OP_MON_R_P))
429 printf ("\tFormat is %s\tRx, PC\n", xgate_opcodes[i].name);
430 if (!strcmp (xgate_opcodes[i].constraints, XGATE_OP_IMM16mLDW))
431 printf ("\tFormat is %s\tRx, <16-bit value>\n",
432 xgate_opcodes[i].name);
438 xgate_print_table (void)
442 for (i = 0; i < xgate_num_opcodes; i++)
443 xgate_print_syntax (xgate_opcodes[i].name);
449 xgate_listing_header (void)
451 if (current_architecture & cpuxgate)
454 return "ERROR MC9S12X GAS ";
458 md_undefined_symbol (char *name ATTRIBUTE_UNUSED)
463 /* GAS will call this function for each section at the end of the assembly,
464 to permit the CPU backend to adjust the alignment of a section. */
467 md_section_align (asection * seg, valueT addr)
469 int align = bfd_get_section_alignment (stdoutput, seg);
470 return ((addr + (1 << align) - 1) & (-1 << align));
474 md_assemble (char *input_line)
476 struct xgate_opcode *opcode = 0;
477 struct xgate_opcode *macro_opcode = 0;
478 struct xgate_opcode_handle *opcode_handle = 0;
479 /* Caller expects it to be returned as it was passed. */
480 char *saved_input_line = input_line;
481 char op_name[9] = { 0 };
482 unsigned int sh_format = 0;
485 s_operand new_operands[MAX_NUM_OPERANDS];
488 oper_check = 0; /* set error flags */
489 input_line = extract_word (input_line, op_name, sizeof(op_name));
491 /* Check to make sure we are not reading a bogus line. */
493 as_bad (_("opcode missing or not found on input line"));
495 if (!(opcode_handle = (struct xgate_opcode_handle *) hash_find (xgate_hash,
498 as_bad (_("opcode %s not found in opcode hash table"), op_name);
502 /* Parse operands so we can find the proper opcode bin. */
504 sh_format = xgate_get_operands(input_line, new_operands);
506 opcode = xgate_find_match (opcode_handle, opcode_handle->number_of_modes,
511 as_bad (_("matching operands to opcode "));
512 xgate_print_syntax (opcode_handle->opc0[0]->name);
514 else if (opcode->size == 2)
516 /* Size is one word - assemble that native insn. */
517 xgate_scan_operands (opcode, new_operands);
521 /* Insn is a simplified instruction - expand it out. */
525 /* skip past our ';' separator. */
526 for (i = strlen (opcode->constraints), p = opcode->constraints; i > 0;
535 input_line = skip_whitespace (input_line);
536 char *macro_inline = input_line;
538 /* Loop though the macro's opcode list and apply operands to
540 for (i = 0; *p && i < (opcode->size / 2); i++)
542 /* Loop though macro operand list. */
543 input_line = macro_inline; /* Rewind. */
544 p = extract_word (p, op_name, 10);
546 if (!(opcode_handle = (struct xgate_opcode_handle *)
547 hash_find (xgate_hash, op_name)))
549 as_bad (_(": processing macro, real opcode handle"
550 " not found in hash"));
555 sh_format = xgate_get_operands(input_line, new_operands);
557 = xgate_find_match (opcode_handle,
558 opcode_handle->number_of_modes,
560 xgate_scan_operands (macro_opcode, new_operands);
567 input_line = saved_input_line;
570 /* Force truly undefined symbols to their maximum size, and generally set up
571 the frag list to be relaxed. */
574 md_estimate_size_before_relax (fragS *fragp, asection *seg)
576 /* If symbol is undefined or located in a different section,
577 select the largest supported relocation. */
578 relax_substateT subtype;
579 relax_substateT rlx_state[] = { 0, 2 };
581 for (subtype = 0; subtype < ARRAY_SIZE (rlx_state); subtype += 2)
583 if (fragp->fr_subtype == rlx_state[subtype]
584 && (!S_IS_DEFINED (fragp->fr_symbol)
585 || seg != S_GET_SEGMENT (fragp->fr_symbol)))
587 fragp->fr_subtype = rlx_state[subtype + 1];
592 if (fragp->fr_subtype >= ARRAY_SIZE (md_relax_table))
595 return md_relax_table[fragp->fr_subtype].rlx_length;
599 /* Relocation, relaxation and frag conversions. */
601 /* PC-relative offsets are relative to the start of the
602 next instruction. That is, the address of the offset, plus its
603 size, since the offset is always the last part of the insn. */
606 md_pcrel_from (fixS * fixP)
608 return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address;
611 /* If while processing a fixup, a reloc really needs to be created
612 then it is done here. */
615 tc_gen_reloc (asection * section ATTRIBUTE_UNUSED, fixS * fixp)
619 reloc = (arelent *) xmalloc (sizeof(arelent));
620 reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof(asymbol *));
621 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
622 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
624 if (fixp->fx_r_type == 0)
625 reloc->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_16);
627 reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
629 if (reloc->howto == (reloc_howto_type *) NULL)
631 as_bad_where (fixp->fx_file, fixp->fx_line, _
632 ("Relocation %d is not supported by object file format."),
633 (int) fixp->fx_r_type);
637 /* Since we use Rel instead of Rela, encode the vtable entry to be
638 used in the relocation's section offset. */
639 if (fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
640 reloc->address = fixp->fx_offset;
645 /* Patch the instruction with the resolved operand. Elf relocation
646 info will also be generated to take care of linker/loader fixups.
647 The XGATE addresses only 16-bit addresses.The BFD_RELOC_32 is necessary
648 for the support of --gstabs. */
651 md_apply_fix (fixS * fixP, valueT * valP, segT seg ATTRIBUTE_UNUSED)
658 /* If the fixup is done mark it done so no further symbol resolution
660 if (fixP->fx_addsy == (symbolS *) NULL)
663 /* We don't actually support subtracting a symbol. */
664 if (fixP->fx_subsy != (symbolS *) NULL)
665 as_bad_where (fixP->fx_file, fixP->fx_line, _("Expression too complex."));
667 where = fixP->fx_frag->fr_literal + fixP->fx_where;
668 opcode = bfd_getl16 (where);
671 switch (fixP->fx_r_type)
673 case R_XGATE_PCREL_9:
674 if (value < -512 || value > 511)
675 as_bad_where (fixP->fx_file, fixP->fx_line,
676 _("Value %ld too large for 9-bit PC-relative branch."),
678 result = ldiv (value, 2); /* from bytes to words */
681 as_bad_where (fixP->fx_file, fixP->fx_line, _
682 ("Value %ld not aligned by 2 for 9-bit"
683 " PC-relative branch."), value);
684 /* Clip into 8-bit field.
685 FIXME I'm sure there is a more proper place for this. */
688 number_to_chars_bigendian (where, (opcode | value), 2);
690 case R_XGATE_PCREL_10:
691 if (value < -1024 || value > 1023)
692 as_bad_where (fixP->fx_file, fixP->fx_line,
693 _("Value %ld too large for 10-bit PC-relative branch."),
695 result = ldiv (value, 2); /* from bytes to words */
698 as_bad_where (fixP->fx_file, fixP->fx_line, _
699 ("Value %ld not aligned by 2 for 10-bit"
700 " PC-relative branch."), value);
701 /* Clip into 9-bit field.
702 FIXME I'm sure there is a more proper place for this. */
705 number_to_chars_bigendian (where, (opcode | value), 2);
707 case BFD_RELOC_XGATE_IMM8_HI:
708 if (value < -65537 || value > 65535)
709 as_bad_where (fixP->fx_file, fixP->fx_line,
710 _("Value out of 16-bit range."));
713 bfd_putb16 ((bfd_vma) value | opcode, (void *) where);
715 case BFD_RELOC_XGATE_24:
716 case BFD_RELOC_XGATE_IMM8_LO:
717 if (value < -65537 || value > 65535)
718 as_bad_where (fixP->fx_file, fixP->fx_line,
719 _("Value out of 16-bit range."));
721 bfd_putb16 ((bfd_vma) value | opcode, (void *) where);
723 case BFD_RELOC_XGATE_IMM3:
724 if (value < 0 || value > 7)
725 as_bad_where (fixP->fx_file, fixP->fx_line,
726 _("Value out of 3-bit range."));
727 value <<= 8; /* make big endian */
728 number_to_chars_bigendian (where, (opcode | value), 2);
730 case BFD_RELOC_XGATE_IMM4:
731 if (value < 0 || value > 15)
732 as_bad_where (fixP->fx_file, fixP->fx_line,
733 _("Value out of 4-bit range."));
734 value <<= 4; /* align the operand bits */
735 number_to_chars_bigendian (where, (opcode | value), 2);
737 case BFD_RELOC_XGATE_IMM5:
738 if (value < 0 || value > 31)
739 as_bad_where (fixP->fx_file, fixP->fx_line,
740 _("Value out of 5-bit range."));
741 value <<= 5; /* align the operand bits */
742 number_to_chars_bigendian (where, (opcode | value), 2);
745 ((bfd_byte *) where)[0] = (bfd_byte) value;
748 bfd_putb32 ((bfd_vma) value, (unsigned char *) where);
751 bfd_putb16 ((bfd_vma) value, (unsigned char *) where);
754 as_fatal (_("Line %d: unknown relocation type: 0x%x."), fixP->fx_line,
760 /* See whether we need to force a relocation into the output file. */
763 tc_xgate_force_relocation (fixS * fixP)
765 if (fixP->fx_r_type == BFD_RELOC_XGATE_RL_GROUP)
767 return generic_force_reloc (fixP);
770 /* Here we decide which fixups can be adjusted to make them relative
771 to the beginning of the section instead of the symbol. Basically
772 we need to make sure that the linker relaxation is done
773 correctly, so in some cases we force the original symbol to be
777 tc_xgate_fix_adjustable (fixS * fixP)
779 switch (fixP->fx_r_type)
781 /* For the linker relaxation to work correctly, these relocs
782 need to be on the symbol itself. */
784 case BFD_RELOC_XGATE_RL_JUMP:
785 case BFD_RELOC_XGATE_RL_GROUP:
786 case BFD_RELOC_VTABLE_INHERIT:
787 case BFD_RELOC_VTABLE_ENTRY:
796 md_convert_frag (bfd * abfd ATTRIBUTE_UNUSED,
797 asection * sec ATTRIBUTE_UNUSED,
798 fragS * fragP ATTRIBUTE_UNUSED)
800 as_bad (("md_convert_frag not implemented yet"));
804 /* Set the ELF specific flags. */
807 xgate_elf_final_processing (void)
809 elf_flags |= EF_XGATE_MACH;
810 elf_elfheader (stdoutput)->e_flags &= ~EF_XGATE_ABI;
811 elf_elfheader (stdoutput)->e_flags |= elf_flags;
815 skip_whitespace (char *s)
817 while (*s == ' ' || *s == '\t' || *s == '(' || *s == ')')
823 /* Extract a word (continuous alpha-numeric chars) from the input line. */
826 extract_word (char *from, char *to, int limit)
831 /* Drop leading whitespace. */
832 from = skip_whitespace (from);
834 /* Find the op code end. */
835 for (op_end = from; *op_end != 0 && is_part_of_name (*op_end);)
837 to[size++] = *op_end++;
838 if (size + 1 >= limit)
846 xgate_new_instruction (int size)
848 char *f = frag_more (size);
849 dwarf2_emit_insn (size);
853 static unsigned short
854 xgate_apply_operand (unsigned short new_mask,
855 unsigned short *availiable_mask_bits,
857 unsigned char n_bits)
859 unsigned short n_shifts;
860 unsigned int n_drop_bits;
862 /* Shift until you find an available operand bit "1" and record
863 the number of shifts. */
865 !(*availiable_mask_bits & SIXTEENTH_BIT) && n_shifts < 16;
867 *availiable_mask_bits <<= 1;
869 /* Shift for the number of bits your operand requires while bits
871 for (n_drop_bits = n_bits;
872 n_drop_bits && (*availiable_mask_bits & SIXTEENTH_BIT);
874 *availiable_mask_bits <<= 1;
877 as_bad (_(":operand has too many bits"));
878 *availiable_mask_bits >>= n_shifts + n_bits;
879 if ((n_drop_bits == 0) && (*availiable_mask_bits == 0))
881 oper_check = 1; /* flag operand check as good */
883 new_mask <<= N_BITS_IN_WORD - (n_shifts + n_bits);
888 /* Parse ordinary expression. */
891 xgate_parse_exp (char *s, expressionS * op)
893 input_line_pointer = s;
895 if (op->X_op == O_absent)
896 as_bad (_("missing operand"));
897 return input_line_pointer;
901 cmp_opcode (struct xgate_opcode *op1, struct xgate_opcode *op2)
903 return strcmp (op1->name, op2->name);
906 static struct xgate_opcode *
907 xgate_find_match (struct xgate_opcode_handle *opcode_handle,
909 unsigned int sh_format)
913 if (numberOfModes == 0)
914 return opcode_handle->opc0[0];
916 for (i = 0; i <= numberOfModes; i++)
917 if (opcode_handle->opc0[i]->sh_format & sh_format)
918 return opcode_handle->opc0[i];
923 /* Because we are dealing with two different core that view the system
924 memory with different offsets, we must differentiate what core a
925 symbol belongs to, in order for the linker to cross-link. */
928 xgate_frob_symbol (symbolS *sym)
931 elf_symbol_type *elfsym;
933 bfdsym = symbol_get_bfdsym (sym);
934 elfsym = elf_symbol_from (bfd_asymbol_bfd (bfdsym), bfdsym);
938 /* Mark the symbol as being *from XGATE */
939 elfsym->internal_elf_sym.st_target_internal = 1;
945 xgate_get_operands (char *line, s_operand oprs[])
949 /* If there are no operands, then it must be inherent. */
950 if (*line == 0 || *line == '\n' || *line == '\r')
953 for (num_operands = 0; strlen (line) && (num_operands < MAX_NUM_OPERANDS);
956 line = skip_whitespace (line);
960 oprs[num_operands].mod = xgate_determine_modifiers (&line);
962 if ((oprs[num_operands].reg = reg_name_search (line)) == REG_NONE)
963 line = xgate_parse_exp (line, &oprs[num_operands].exp);
965 /* skip to next operand */
977 if (num_operands > MAX_NUM_OPERANDS)
980 switch (num_operands)
983 if (oprs[0].reg >= REG_R0 && oprs[0].reg <= REG_R7)
985 if (oprs[0].reg == REG_NONE)
989 if (oprs[0].reg >= REG_R0 && oprs[0].reg <= REG_R7)
991 if (oprs[1].reg >= REG_R0 && oprs[1].reg <= REG_R7)
993 if (oprs[1].reg == REG_CCR)
995 if (oprs[1].reg == REG_PC)
997 if (oprs[1].reg == REG_NONE)
1000 if (oprs[0].reg == REG_CCR)
1004 if (oprs[0].reg >= REG_R0 && oprs[0].reg <= REG_R7)
1006 if (oprs[1].reg >= REG_R0 && oprs[1].reg <= REG_R7)
1008 if (oprs[2].reg >= REG_R0 && oprs[2].reg <= REG_R7)
1010 if (oprs[2].reg >= REG_NONE)
1016 as_bad (_("unknown operand format"));
1023 /* reg_name_search() finds the register number given its name.
1024 Returns the register number or REG_NONE on failure. */
1026 reg_name_search (char *name)
1028 if (strncasecmp (name, "r0", 2) == 0)
1030 if (strncasecmp (name, "r1", 2) == 0)
1032 if (strncasecmp (name, "r2", 2) == 0)
1034 if (strncasecmp (name, "r3", 2) == 0)
1036 if (strncasecmp (name, "r4", 2) == 0)
1038 if (strncasecmp (name, "r5", 2) == 0)
1040 if (strncasecmp (name, "r6", 2) == 0)
1042 if (strncasecmp (name, "r7", 2) == 0)
1044 if (strncasecmp (name, "pc", 2) == 0)
1046 if (strncasecmp (name, "ccr", 3) == 0)
1051 /* Parse operand modifiers such as inc/dec/hi/low. */
1054 xgate_determine_modifiers(char **line)
1056 char *local_line = line[0];
1058 if (strncasecmp (local_line, "%hi", 3) == 0)
1061 return MOD_LOAD_HIGH;
1063 if (strncasecmp (local_line, "%lo", 3) == 0)
1066 return MOD_LOAD_LOW;
1068 if (*(local_line + 2) == '+')
1070 if (strncasecmp (local_line, "-r", 2) == 0)
1078 /* Parse instruction operands. */
1081 xgate_scan_operands (struct xgate_opcode *opcode, s_operand oprs[])
1083 char *frag = xgate_new_instruction (opcode->size);
1084 int where = frag - frag_now->fr_literal;
1085 char *op = opcode->constraints;
1086 unsigned int bin = (int) opcode->bin_opcode;
1087 unsigned short oper_mask = 0;
1088 int operand_bit_length = 0;
1089 unsigned int operand = 0;
1090 char n_operand_bits = 0;
1091 char first_operand_equals_second = 0;
1095 /* Generate available operand bits mask. */
1096 for (i = 0; (c = opcode->format[i]); i++)
1098 if (ISDIGIT (c) || (c == 's'))
1110 /* Parse first operand. */
1115 first_operand_equals_second = 1;
1118 operand = xgate_parse_operand (opcode, &operand_bit_length, where,
1121 bin = xgate_apply_operand (operand, &oper_mask, bin, operand_bit_length);
1123 if(first_operand_equals_second)
1124 bin = xgate_apply_operand (operand, &oper_mask, bin,
1125 operand_bit_length);
1126 /* Parse second operand. */
1131 if (first_operand_equals_second)
1133 bin = xgate_apply_operand (operand, &oper_mask, bin,
1134 operand_bit_length);
1139 operand = xgate_parse_operand (opcode, &operand_bit_length, where,
1141 bin = xgate_apply_operand (operand, &oper_mask, bin,
1142 operand_bit_length);
1146 /* Parse the third register. */
1151 operand = xgate_parse_operand (opcode, &operand_bit_length, where,
1153 bin = xgate_apply_operand (operand, &oper_mask, bin,
1154 operand_bit_length);
1157 if (opcode->size == 2 && fixup_required)
1159 bfd_putl16 (bin, frag);
1161 else if ((opcode->sh_format & XG_PCREL))
1163 /* Write our data to a frag for further processing. */
1164 bfd_putl16 (opcode->bin_opcode, frag);
1168 /* Apply operand mask(s)to bin opcode and write the output. */
1169 /* Since we are done write this frag in xgate BE format. */
1170 number_to_chars_bigendian (frag, bin, opcode->size);
1177 xgate_parse_operand (struct xgate_opcode *opcode,
1183 char *op_constraint = *op_con;
1184 unsigned int op_mask = 0;
1185 unsigned int pp_fix = 0;
1186 unsigned short max_size = 0;
1192 switch (*op_constraint)
1194 case '+': /* Indexed register operand +/- or plain r. */
1195 /* Default to neither inc or dec. */
1199 if (operand.reg == REG_NONE)
1200 as_bad (_(": expected register name r0-r7 ") );
1201 op_mask = operand.reg;
1202 if(operand.mod == MOD_POSTINC)
1204 if(operand.mod == MOD_PREDEC)
1210 case 'r': /* Register operand. */
1211 if (operand.reg == REG_NONE)
1212 as_bad (_(": expected register name r0-r7 "));
1216 op_mask = operand.reg;
1219 case 'i': /* Immediate value or expression expected. */
1220 /* Advance the original format pointer. */
1223 if (ISDIGIT (*op_constraint))
1224 *bit_width = (int) *op_constraint - '0';
1225 else if (*op_constraint == 'a')
1227 else if (*op_constraint == 'f')
1230 /* http://tigcc.ticalc.org/doc/gnuasm.html#SEC31 */
1231 if (operand.exp.X_op == O_constant)
1233 op_mask = operand.exp.X_add_number;
1234 if (((opcode->name[strlen (opcode->name) - 1] == 'l') && autoHiLo)
1235 || operand.mod == MOD_LOAD_LOW)
1237 else if (((opcode->name[strlen (opcode->name) - 1]) == 'h'
1238 && autoHiLo) || operand.mod == MOD_LOAD_HIGH)
1241 /* Make sure it fits. */
1242 for (i = *bit_width; i; i--)
1247 if (op_mask > max_size)
1248 as_bad (_(":operand value(%d) too big for constraint"), op_mask);
1252 /* Should be BFD_RELOC_XGATE_IMM8_LO instead of BFD_RELOC_XGATE_24
1255 if (*op_constraint == '8')
1257 if (((opcode->name[strlen (opcode->name) - 1] == 'l')
1258 && autoHiLo) || operand.mod == MOD_LOAD_LOW)
1259 fix_new_exp (frag_now, where, 2, &operand.exp, FALSE,
1260 BFD_RELOC_XGATE_24);
1261 else if (((opcode->name[strlen (opcode->name) - 1]) == 'h'
1262 && autoHiLo) || operand.mod == MOD_LOAD_HIGH )
1263 fix_new_exp (frag_now, where, 2, &operand.exp, FALSE,
1264 BFD_RELOC_XGATE_IMM8_HI);
1266 as_bad (_("you must use a hi/lo directive or 16-bit macro "
1267 "to load a 16-bit value."));
1269 else if (*op_constraint == '5')
1270 fix_new_exp (frag_now, where, 2, &operand.exp, FALSE,
1271 BFD_RELOC_XGATE_IMM5);
1272 else if (*op_constraint == '4')
1273 fix_new_exp (frag_now, where, 2, &operand.exp, FALSE,
1274 BFD_RELOC_XGATE_IMM4);
1275 else if (*op_constraint == '3')
1276 fix_new_exp (frag_now, where, 2, &operand.exp, FALSE,
1277 BFD_RELOC_XGATE_IMM3);
1279 as_bad (_(":unknown relocation constraint size"));
1283 case 'c': /* CCR register expected. */
1285 if (operand.reg != REG_CCR)
1286 as_bad (_(": expected register name ccr "));
1289 case 'p': /* PC register expected. */
1291 if (operand.reg != REG_PC)
1292 as_bad (_(": expected register name pc "));
1295 case 'b': /* Branch expected. */
1299 if (operand.exp.X_op != O_register)
1301 if (*op_constraint == '9')
1302 fix_new_exp (frag_now, where, 2, &operand.exp, TRUE,
1304 else if (*op_constraint == 'a')
1305 fix_new_exp (frag_now, where, 2, &operand.exp, TRUE,
1309 as_fatal (_("Operand `%x' not recognized in fixup8."),
1316 as_bad (_("unknown constraint `%c'"), *op_constraint);