Home | History | Annotate | Download | only in config
      1 /* tc-ip2k.c -- Assembler for the Scenix IP2xxx.
      2    Copyright (C) 2000-2014 Free Software Foundation, Inc.
      3 
      4    This file is part of GAS, the GNU Assembler.
      5 
      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 3, or (at your option)
      9    any later version.
     10 
     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.
     15 
     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
     18    the Free Software Foundation, 51 Franklin Street - Fifth Floor,
     19    Boston, MA 02110-1301, USA.  */
     20 
     21 #include "as.h"
     22 #include "subsegs.h"
     23 #include "symcat.h"
     24 #include "opcodes/ip2k-desc.h"
     25 #include "opcodes/ip2k-opc.h"
     26 #include "cgen.h"
     27 #include "elf/common.h"
     28 #include "elf/ip2k.h"
     29 #include "libbfd.h"
     30 
     31 /* Structure to hold all of the different components describing
     32    an individual instruction.  */
     33 typedef struct
     34 {
     35   const CGEN_INSN *	insn;
     36   const CGEN_INSN *	orig_insn;
     37   CGEN_FIELDS		fields;
     38 #if CGEN_INT_INSN_P
     39   CGEN_INSN_INT         buffer [1];
     40 #define INSN_VALUE(buf) (*(buf))
     41 #else
     42   unsigned char         buffer [CGEN_MAX_INSN_SIZE];
     43 #define INSN_VALUE(buf) (buf)
     44 #endif
     45   char *		addr;
     46   fragS *		frag;
     47   int                   num_fixups;
     48   fixS *                fixups [GAS_CGEN_MAX_FIXUPS];
     49   int                   indices [MAX_OPERAND_INSTANCES];
     50 }
     51 ip2k_insn;
     52 
     53 const char comment_chars[]        = ";";
     54 const char line_comment_chars[]   = "#";
     55 const char line_separator_chars[] = "";
     56 const char EXP_CHARS[]            = "eE";
     57 const char FLT_CHARS[]            = "dD";
     58 
     59 /* Flag to detect when switching to code section where insn alignment is
     60    implied.  */
     61 static int force_code_align = 0;
     62 
     63 /* Mach selected from command line.  */
     64 static int ip2k_mach = 0;
     65 static unsigned ip2k_mach_bitmask = 0;
     66 
     67 
     68 static void
     69 ip2k_elf_section_rtn (int i)
     70 {
     71   obj_elf_section(i);
     72 
     73   if (force_code_align)
     74     {
     75       /* The s_align_ptwo function expects that we are just after a .align
     76 	 directive and it will either try and read the align value or stop
     77 	 if end of line so we must fake it out so it thinks we are at the
     78 	 end of the line.  */
     79       char *old_input_line_pointer = input_line_pointer;
     80       input_line_pointer = "\n";
     81       s_align_ptwo (1);
     82       force_code_align = 0;
     83       /* Restore.  */
     84       input_line_pointer = old_input_line_pointer;
     85     }
     86 }
     87 
     88 static void
     89 ip2k_elf_section_text (int i)
     90 {
     91   char *old_input_line_pointer;
     92   obj_elf_text(i);
     93 
     94   /* the s_align_ptwo function expects that we are just after a .align
     95      directive and it will either try and read the align value or stop if
     96      end of line so we must fake it out so it thinks we are at the end of
     97      the line.  */
     98   old_input_line_pointer = input_line_pointer;
     99   input_line_pointer = "\n";
    100   s_align_ptwo (1);
    101   force_code_align = 0;
    102   /* Restore.  */
    103   input_line_pointer = old_input_line_pointer;
    104 }
    105 
    106 /* The target specific pseudo-ops which we support.  */
    107 const pseudo_typeS md_pseudo_table[] =
    108 {
    109     { "text",   ip2k_elf_section_text,  0 },
    110     { "sect",   ip2k_elf_section_rtn,   0 },
    111     { NULL, 	NULL,			0 }
    112 };
    113 
    114 
    115 
    117 enum options
    118 {
    119   OPTION_CPU_IP2022 = OPTION_MD_BASE,
    120   OPTION_CPU_IP2022EXT
    121 };
    122 
    123 struct option md_longopts[] =
    124 {
    125   { "mip2022",     no_argument, NULL, OPTION_CPU_IP2022 },
    126   { "mip2022ext",  no_argument, NULL, OPTION_CPU_IP2022EXT },
    127   { NULL,           no_argument, NULL, 0 },
    128 };
    129 size_t md_longopts_size = sizeof (md_longopts);
    130 
    131 const char * md_shortopts = "";
    132 
    133 int
    134 md_parse_option (int c ATTRIBUTE_UNUSED, char * arg ATTRIBUTE_UNUSED)
    135 {
    136   switch (c)
    137     {
    138     case OPTION_CPU_IP2022:
    139       ip2k_mach = bfd_mach_ip2022;
    140       ip2k_mach_bitmask = 1 << MACH_IP2022;
    141       break;
    142 
    143     case OPTION_CPU_IP2022EXT:
    144       ip2k_mach = bfd_mach_ip2022ext;
    145       ip2k_mach_bitmask = 1 << MACH_IP2022EXT;
    146       break;
    147 
    148     default:
    149       return 0;
    150     }
    151 
    152   return 1;
    153 }
    154 
    155 void
    156 md_show_usage (FILE * stream)
    157 {
    158   fprintf (stream, _("IP2K specific command line options:\n"));
    159   fprintf (stream, _("  -mip2022               restrict to IP2022 insns \n"));
    160   fprintf (stream, _("  -mip2022ext            permit extended IP2022 insn\n"));
    161 }
    162 
    163 
    164 void
    166 md_begin (void)
    167 {
    168   /* Initialize the `cgen' interface.  */
    169 
    170   /* Set the machine number and endian.  */
    171   gas_cgen_cpu_desc = ip2k_cgen_cpu_open (CGEN_CPU_OPEN_MACHS,
    172 					  ip2k_mach_bitmask,
    173 					  CGEN_CPU_OPEN_ENDIAN,
    174 					  CGEN_ENDIAN_BIG,
    175 					  CGEN_CPU_OPEN_END);
    176   ip2k_cgen_init_asm (gas_cgen_cpu_desc);
    177 
    178   /* This is a callback from cgen to gas to parse operands.  */
    179   cgen_set_parse_operand_fn (gas_cgen_cpu_desc, gas_cgen_parse_operand);
    180 
    181   /* Set the machine type.  */
    182   bfd_default_set_arch_mach (stdoutput, bfd_arch_ip2k, ip2k_mach);
    183 }
    184 
    185 
    186 void
    187 md_assemble (char * str)
    188 {
    189   ip2k_insn insn;
    190   char * errmsg;
    191 
    192   /* Initialize GAS's cgen interface for a new instruction.  */
    193   gas_cgen_init_parse ();
    194 
    195   insn.insn = ip2k_cgen_assemble_insn
    196       (gas_cgen_cpu_desc, str, & insn.fields, insn.buffer, & errmsg);
    197 
    198   if (!insn.insn)
    199     {
    200       as_bad ("%s", errmsg);
    201       return;
    202     }
    203 
    204   /* Check for special relocation required by SKIP instructions.  */
    205   if (CGEN_INSN_ATTR_VALUE (insn.insn, CGEN_INSN_SKIPA))
    206     /* Unconditional skip has a 1-bit relocation of the current pc, so
    207        that we emit either sb pcl.0 or snb pcl.0 depending on whether
    208        the PCL (pc + 2) >> 1 is odd or even.  */
    209     {
    210       enum cgen_parse_operand_result result_type;
    211       bfd_vma value;
    212       const char *curpc_plus_2 = ".+2";
    213       const char *err;
    214 
    215       err = cgen_parse_address (gas_cgen_cpu_desc, & curpc_plus_2,
    216 				IP2K_OPERAND_ADDR16CJP,
    217 				BFD_RELOC_IP2K_PC_SKIP,
    218 				& result_type, & value);
    219       if (err)
    220 	{
    221 	  as_bad ("%s", err);
    222 	  return;
    223 	}
    224     }
    225 
    226   /* Doesn't really matter what we pass for RELAX_P here.  */
    227   gas_cgen_finish_insn (insn.insn, insn.buffer,
    228 			CGEN_FIELDS_BITSIZE (& insn.fields), 1, NULL);
    229 }
    230 
    231 valueT
    232 md_section_align (segT segment, valueT size)
    233 {
    234   int align = bfd_get_section_alignment (stdoutput, segment);
    235 
    236   return ((size + (1 << align) - 1) & (-1 << align));
    237 }
    238 
    239 
    240 symbolS *
    241 md_undefined_symbol (char * name ATTRIBUTE_UNUSED)
    242 {
    243     return 0;
    244 }
    245 
    246 int
    248 md_estimate_size_before_relax (fragS * fragP ATTRIBUTE_UNUSED,
    249 			       segT    segment ATTRIBUTE_UNUSED)
    250 {
    251   as_fatal (_("relaxation not supported\n"));
    252   return 1;
    253 }
    254 
    255 
    256 /* *fragP has been relaxed to its final size, and now needs to have
    257    the bytes inside it modified to conform to the new size.
    258 
    259    Called after relaxation is finished.
    260    fragP->fr_type == rs_machine_dependent.
    261    fragP->fr_subtype is the subtype of what the address relaxed to.  */
    262 
    263 void
    264 md_convert_frag (bfd   * abfd  ATTRIBUTE_UNUSED,
    265 		 segT    sec   ATTRIBUTE_UNUSED,
    266 		 fragS * fragP ATTRIBUTE_UNUSED)
    267 {
    268 }
    269 
    270 
    271 /* Functions concerning relocs.  */
    273 
    274 long
    275 md_pcrel_from (fixS *fixP ATTRIBUTE_UNUSED)
    276 {
    277   abort ();
    278 }
    279 
    280 
    281 /* Return the bfd reloc type for OPERAND of INSN at fixup FIXP.
    282    Returns BFD_RELOC_NONE if no reloc type can be found.
    283    *FIXP may be modified if desired.  */
    284 
    285 bfd_reloc_code_real_type
    286 md_cgen_lookup_reloc (const CGEN_INSN *    insn     ATTRIBUTE_UNUSED,
    287 		      const CGEN_OPERAND * operand,
    288 		      fixS *               fixP     ATTRIBUTE_UNUSED)
    289 {
    290   bfd_reloc_code_real_type result;
    291 
    292   result = BFD_RELOC_NONE;
    293 
    294   switch (operand->type)
    295     {
    296     case IP2K_OPERAND_FR:
    297     case IP2K_OPERAND_ADDR16L:
    298     case IP2K_OPERAND_ADDR16H:
    299     case IP2K_OPERAND_LIT8:
    300       /* These may have been processed at parse time.  */
    301       if (fixP->fx_cgen.opinfo != 0)
    302 	result = fixP->fx_cgen.opinfo;
    303       fixP->fx_no_overflow = 1;
    304       break;
    305 
    306     case IP2K_OPERAND_ADDR16CJP:
    307       result = fixP->fx_cgen.opinfo;
    308       if (result == 0 || result == BFD_RELOC_NONE)
    309 	result = BFD_RELOC_IP2K_ADDR16CJP;
    310       fixP->fx_no_overflow = 1;
    311       break;
    312 
    313     case IP2K_OPERAND_ADDR16P:
    314       result = BFD_RELOC_IP2K_PAGE3;
    315       fixP->fx_no_overflow = 1;
    316       break;
    317 
    318     default:
    319       result = BFD_RELOC_NONE;
    320       break;
    321     }
    322 
    323   return result;
    324 }
    325 
    326 
    327 /* Write a value out to the object file, using the appropriate endianness.  */
    328 
    329 void
    330 md_number_to_chars (char * buf, valueT val, int n)
    331 {
    332   number_to_chars_bigendian (buf, val, n);
    333 }
    334 
    335 char *
    336 md_atof (int type, char * litP, int *  sizeP)
    337 {
    338   return ieee_md_atof (type, litP, sizeP, TRUE);
    339 }
    340 
    341 
    342 /* See whether we need to force a relocation into the output file.
    343    Force most of them, since the linker's bfd relocation engine
    344    understands range limits better than gas' cgen fixup engine.
    345    Consider the case of a fixup intermediate value being larger than
    346    the instruction it will be eventually encoded within.  */
    347 
    348 int
    349 ip2k_force_relocation (fixS * fix)
    350 {
    351   switch (fix->fx_r_type)
    352     {
    353     case BFD_RELOC_IP2K_FR9:
    354     case BFD_RELOC_IP2K_FR_OFFSET:
    355     case BFD_RELOC_IP2K_BANK:
    356     case BFD_RELOC_IP2K_ADDR16CJP:
    357     case BFD_RELOC_IP2K_PAGE3:
    358     case BFD_RELOC_IP2K_LO8DATA:
    359     case BFD_RELOC_IP2K_HI8DATA:
    360     case BFD_RELOC_IP2K_EX8DATA:
    361     case BFD_RELOC_IP2K_LO8INSN:
    362     case BFD_RELOC_IP2K_HI8INSN:
    363     case BFD_RELOC_IP2K_PC_SKIP:
    364     case BFD_RELOC_IP2K_TEXT:
    365       return 1;
    366 
    367     case BFD_RELOC_16:
    368       if (fix->fx_subsy && S_IS_DEFINED (fix->fx_subsy)
    369 	  && fix->fx_addsy && S_IS_DEFINED (fix->fx_addsy)
    370 	  && (S_GET_SEGMENT (fix->fx_addsy)->flags & SEC_CODE))
    371 	{
    372 	  fix->fx_r_type = BFD_RELOC_IP2K_TEXT;
    373 	  return 0;
    374 	}
    375       break;
    376 
    377     default:
    378       break;
    379     }
    380 
    381   return generic_force_reloc (fix);
    382 }
    383 
    384 void
    385 ip2k_apply_fix (fixS *fixP, valueT *valueP, segT seg)
    386 {
    387   if (fixP->fx_r_type == BFD_RELOC_IP2K_TEXT
    388       && ! fixP->fx_addsy
    389       && ! fixP->fx_subsy)
    390     {
    391       *valueP = ((int)(* valueP)) / 2;
    392       fixP->fx_r_type = BFD_RELOC_16;
    393     }
    394   else if (fixP->fx_r_type == BFD_RELOC_UNUSED + IP2K_OPERAND_FR)
    395     {
    396       /* Must be careful when we are fixing up an FR.  We could be
    397 	 fixing up an offset to (SP) or (DP) in which case we don't
    398 	 want to step on the top 2 bits of the FR operand.  The
    399 	 gas_cgen_md_apply_fix doesn't know any better and overwrites
    400 	 the entire operand.  We counter this by adding the bits
    401 	 to the new value.  */
    402       char *where = fixP->fx_frag->fr_literal + fixP->fx_where;
    403 
    404       /* Canonical name, since used a lot.  */
    405       CGEN_CPU_DESC cd = gas_cgen_cpu_desc;
    406       CGEN_INSN_INT insn_value
    407 	= cgen_get_insn_value (cd, (unsigned char *) where,
    408 			       CGEN_INSN_BITSIZE (fixP->fx_cgen.insn));
    409       /* Preserve (DP) or (SP) specification.  */
    410       *valueP += (insn_value & 0x180);
    411     }
    412 
    413   gas_cgen_md_apply_fix (fixP, valueP, seg);
    414 }
    415 
    416 int
    417 ip2k_elf_section_flags (flagword flags,
    418 			bfd_vma attr ATTRIBUTE_UNUSED,
    419 			int type ATTRIBUTE_UNUSED)
    420 {
    421   /* This is used to detect when the section changes to an executable section.
    422      This function is called by the elf section processing.  When we note an
    423      executable section specifier we set an internal flag to denote when
    424      word alignment should be forced.  */
    425   if (flags & SEC_CODE)
    426     force_code_align = 1;
    427 
    428   return flags;
    429 }
    430 
    431